Ejemplo n.º 1
0
        /// <summary>
        /// Asynchronously reads specified number of ushorts starting from the specified address.
        /// </summary>
        /// <param name="startAddress">Address to start to read from</param>
        /// <param name="count">Number of ushorts to read</param>
        /// <returns>Read data</returns>
        public async Task <ushort[]> ReadAsync(FinsAddress startAddress, ushort count)
        {
            var sid = IncrementSid();
            var cmd = FinsDriver.ReadCommand(startAddress, new Header(sid, true), count);

            return((await CommandAsync(sid, cmd)).Data);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Asynchronously writes specified data to specified memory address.
        /// </summary>
        /// <param name="startAddress">Address to start to write to</param>
        /// <param name="data">Data to write</param>
        public async Task WriteAsync(FinsAddress startAddress, ushort[] data)
        {
            var sid = IncrementSid();
            var cmd = FinsDriver.WriteCommand(startAddress, new Header(sid, true), data);

            await CommandAsync(sid, cmd);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Syncroniously writes specified data to specified address.
        /// </summary>
        /// <param name="startAddress">Address to start write to</param>
        /// <param name="data">Data to write</param>
        public void Write(FinsAddress startAddress, ushort[] data)
        {
            var sid = IncrementSid();
            var cmd = FinsDriver.WriteCommand(startAddress, new Header(sid, true), data);

            Write(sid, cmd);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Syncroniously reads specified number of ushorts starting from specified address.
        /// </summary>
        /// <param name="startAddress">Address to start to read from</param>
        /// <param name="count">Number of ushorts to read</param>
        /// <returns>Read data</returns>
        public ushort[] Read(FinsAddress startAddress, ushort count)
        {
            var sid = IncrementSid();
            var cmd = FinsDriver.ReadCommand(startAddress, new Header(sid, true), count);

            return(Read(sid, cmd));
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Writes specified data to specified address of data memory without
        /// waiting for a response.
        /// </summary>
        /// <param name="startAddress">Address to start to read from</param>
        /// <param name="count">Number of ushorts to read</param>
        public void WriteNoResponse(FinsAddress startAddress, ushort[] data)
        {
            var sid = IncrementSid();
            var cmd = FinsDriver.WriteCommand(startAddress, new Header(sid, false), data);

            _udpClient.SendAsync(cmd, cmd.Length);
        }
Ejemplo n.º 6
0
        public static byte[] ReadCommand(FinsAddress memoryAddress, Header header, ushort readCount)
        {
            var ms = new BinaryWriter(new MemoryStream());

            header.WriteTo(ms);
            ms.Write(CommandMemoryAreaRead);
            ms.Write(memoryAddress.Area);
            ms.Write((byte)(memoryAddress.Offset >> 8));
            ms.Write((byte)memoryAddress.Offset);
            ms.Write((byte)0); // Address Bit
            ms.Write((byte)(readCount >> 8));
            ms.Write((byte)readCount);
            return(((MemoryStream)ms.BaseStream).ToArray());
        }
Ejemplo n.º 7
0
        public static byte[] WriteCommand(FinsAddress memoryAddress, Header header, ushort[] data)
        {
            var ms = new BinaryWriter(new MemoryStream());

            header.WriteTo(ms);
            ms.Write(CommandMemoryAreaWrite);
            ms.Write(memoryAddress.Area);
            ms.Write((byte)(memoryAddress.Offset >> 8));
            ms.Write((byte)memoryAddress.Offset);
            ms.Write((byte)0); // Address Bit
            ms.Write((byte)(data.Length >> 8));
            ms.Write((byte)data.Length);
            ms.Write(ToBytes(data));
            return(((MemoryStream)ms.BaseStream).ToArray());
        }
Ejemplo n.º 8
0
        public static bool TryParse(string address, out FinsAddress finsAddress)
        {
            finsAddress = Empty;

            var areas = new Dictionary <string, byte> {
                { "D", 0x82 }, { "DM", 0x82 },
                { "T", 0x89 }, { "TC", 0x89 },
                { "E0_", 0xA0 },
                { "E1_", 0xA1 },
                { "E2_", 0xA2 },
                { "E3_", 0xA3 },
                { "E4_", 0xA4 },
                { "E5_", 0xA5 },
                { "E6_", 0xA6 },
                { "E7_", 0xA7 },
                { "E8_", 0xA8 },
                { "E9_", 0xA9 },
                { "EA_", 0xAA },
                { "EB_", 0xAB },
                { "EC_", 0xAC },
                { "IO", 0xB0 }, { "CIO", 0xB0 },
                { "W", 0xB1 }, { "WR", 0xB1 },
                { "H", 0xB2 }, { "HR", 0xB2 },
                { "A", 0xB3 }, { "AR", 0xB3 },
            };

            var area = areas.Keys.FirstOrDefault(address.StartsWith);

            if (area == null)
            {
                return(false);
            }

            if (address.Length == area.Length)
            {
                finsAddress = new FinsAddress(areas[area], 0);
                return(true);
            }

            if (ushort.TryParse(address.Substring(area.Length), out var offset))
            {
                finsAddress = new FinsAddress(areas[area], offset);
                return(true);
            }

            return(false);
        }