예제 #1
0
        public override ModbusTCPMessage Process(IMemoryModel memory)
        {
            int address = Int16Extensions.FromBytes(PDU.Data.First(), PDU.Data.Skip(1).First());
            int length  = Int16Extensions.FromBytes(PDU.Data.Skip(2).First(), PDU.Data.Skip(3).First());

            try
            {
                var values           = memory.Read4x(address, length);
                ProtocolDataUnit pdu = PDU.ValidResponse(
                    new byte[]
                    { (byte)(values.Count() * 2) }
                    .Concat(values.SelectMany(v => v.GetBytes())));
                ModbusTCPMessage reply = Create(
                    MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
                    pdu);
                return(reply);
            }
            catch
            {
                ProtocolDataUnit pdu   = PDU.ErrorResponse(new byte[] { 0x01 });
                ModbusTCPMessage reply = Create(
                    MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
                    pdu);
                return(reply);
            }
        }
예제 #2
0
        public static ModbusTCPMessage ParseBytes(IEnumerable <byte> message)
        {
            var og = new ModbusTCPMessage(message);
            ModbusFunctionCodes func = og.PDU.FunctionCode;

            switch (func)
            {
            case ModbusFunctionCodes.ReadHoldingRegisters:
                return(new ReadRegistersMessage(message));

            case ModbusFunctionCodes.PresetMultipleRegisters:
                return(new WriteHoldingRegistersMessage(message));

            default:
                return(new ModbusTCPMessage(message));
            }
        }
예제 #3
0
        private void _listener_OnConnectionAccepted(object sender, ConnectionAcceptedEventArgs e)
        {
            Task.Run(async() =>
            {
                while (e.Client.Connected)
                {
                    byte[] buffer            = new byte[1000];
                    var len                  = await e.Client.GetStream().ReadAsync(buffer, 0, buffer.Length);
                    ModbusTCPMessage message = ModbusTCPMessage.ParseBytes(buffer);

                    IEnumerable <byte> response = IllegalFunctionResponse(buffer);
                    if (!RespondWithError)
                    {
                        response = message.Process(_memoryModel).GetBytes();
                    }
                    e.Client.GetStream().Write(response.ToArray(), 0, response.Count());
                }
            }, e.CancellationToken);
        }
        public override ModbusTCPMessage Process(IMemoryModel memory)
        {
            try
            {
                int address = StartAddress();
                var values  = ParseValues();

                memory.Write4x(address, values);

                var pdu   = PDU.ValidResponse(((Int16)values.Count()).GetBytes());
                var reply = Create(
                    MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
                    pdu);
                return(reply);
            }
            catch
            {
                var pdu = PDU.ErrorResponse(new byte[] { 0x01 });
                ModbusTCPMessage reply = Create(
                    MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
                    pdu);
                return(reply);
            }
        }