Ejemplo n.º 1
0
        void HandleDataMessage(Header header, SecsMessage msg)
        {
            int systembyte = header.SystemBytes;

            if (header.DeviceId != DeviceId && msg.S != 9 && msg.F != 1)
            {
                _tracer.TraceMessageIn(msg, systembyte);
                _tracer.TraceWarning("Received Unrecognized Device Id Message");
                try
                {
                    SendDataMessage(new SecsMessage(9, 1, false, "Unrecognized Device Id", Item.B(header.Bytes)), NewSystemByte());
                }
                catch (Exception ex)
                {
                    _tracer.TraceError("Send S9F1 Error", ex);
                }
                return;
            }

            if (msg.F % 2 != 0)
            {
                if (msg.S != 9)
                {
                    //Primary message
                    _tracer.TraceMessageIn(msg, systembyte);
                    PrimaryMessageHandler(msg, secondary =>
                    {
                        if (!header.ReplyExpected || State != ConnectionState.Selected)
                        {
                            return;
                        }

                        secondary = secondary ?? new SecsMessage(9, 7, false, "Unknown Message", Item.B(header.Bytes));
                        secondary.ReplyExpected = false;
                        try
                        {
                            SendDataMessage(secondary, secondary.S == 9 ? NewSystemByte() : header.SystemBytes);
                        }
                        catch (Exception ex)
                        {
                            _tracer.TraceError("Reply Secondary Message Error", ex);
                        }
                    });
                    return;
                }
                // Error message
                var headerBytes = (byte[])msg.SecsItem;
                systembyte = BitConverter.ToInt32(new byte[] { headerBytes[9], headerBytes[8], headerBytes[7], headerBytes[6] }, 0);
            }

            // Secondary message
            SecsAsyncResult ar = null;

            if (_replyExpectedMsgs.TryGetValue(systembyte, out ar))
            {
                ar.EndProcess(msg, false);
            }
            _tracer.TraceMessageIn(msg, systembyte);
        }
Ejemplo n.º 2
0
        void HandleControlMessage(Header header)
        {
            int systembyte = header.SystemBytes;

            if ((byte)header.MessageType % 2 == 0)
            {
                SecsAsyncResult ar = null;
                if (_replyExpectedMsgs.TryGetValue(systembyte, out ar))
                {
                    ar.EndProcess(ControlMessage, false);
                }
                else
                {
                    _tracer.TraceWarning("Received Unexpected Control Message: " + header.MessageType);
                    return;
                }
            }
            _tracer.TraceInfo("Receive Control message: " + header.MessageType);
            switch (header.MessageType)
            {
            case MessageType.Select_req:
                SendControlMessage(MessageType.Select_rsp, systembyte);
                CommunicationStateChanging(ConnectionState.Selected);
                break;

            case MessageType.Select_rsp:
                switch (header.F)
                {
                case 0:
                    CommunicationStateChanging(ConnectionState.Selected);
                    break;

                case 1:
                    _tracer.TraceError("Communication Already Active.");
                    break;

                case 2:
                    _tracer.TraceError("Connection Not Ready.");
                    break;

                case 3:
                    _tracer.TraceError("Connection Exhaust.");
                    break;

                default:
                    _tracer.TraceError("Connection Status Is Unknown.");
                    break;
                }
                break;

            case MessageType.Linktest_req:
                SendControlMessage(MessageType.Linktest_rsp, systembyte);
                break;

            case MessageType.Seperate_req:
                CommunicationStateChanging(ConnectionState.Retry);
                break;
            }
        }
Ejemplo n.º 3
0
        SecsAsyncResult SendDataMessage(SecsMessage msg, int systembyte, AsyncCallback callback = null, object syncState = null)
        {
            if (State != ConnectionState.Selected)
            {
                throw new SecsException("Device is not selected");
            }

            var header = new Header(new byte[10])
            {
                S             = msg.S,
                F             = msg.F,
                ReplyExpected = msg.ReplyExpected,
                DeviceId      = DeviceId,
                SystemBytes   = systembyte
            };
            var buffer = new EncodedBuffer(header.Bytes, msg.RawDatas);

            SecsAsyncResult ar = null;

            if (msg.ReplyExpected)
            {
                ar = new SecsAsyncResult(msg, callback, syncState);
                _replyExpectedMsgs[systembyte] = ar;

                ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle,
                                                       (state, timeout) =>
                {
                    SecsAsyncResult ars;
                    if (_replyExpectedMsgs.TryRemove((int)state, out ars) && timeout)
                    {
                        _tracer.TraceError($"T3 Timeout[id=0x{state:X8}]");
                        ars.EndProcess(null, timeout);
                    }
                }, systembyte, T3, true);
            }

            SocketError error;

            _socket.Send(buffer, SocketFlags.None, out error);
            if (error != SocketError.Success)
            {
                var errorMsg = "Socket send error :" + new SocketException((int)error).Message;
                _tracer.TraceError(errorMsg);
                CommunicationStateChanging(ConnectionState.Retry);
                throw new SecsException(errorMsg);
            }

            _tracer.TraceMessageOut(msg, systembyte);
            return(ar);
        }
Ejemplo n.º 4
0
        void SendControlMessage(MessageType msgType, int systembyte)
        {
            if (_socket == null || !_socket.Connected)
            {
                return;
            }

            if ((byte)msgType % 2 == 1 && msgType != MessageType.Seperate_req)
            {
                var ar = new SecsAsyncResult(ControlMessage);
                _replyExpectedMsgs[systembyte] = ar;

                ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle,
                                                       (state, timeout) =>
                {
                    SecsAsyncResult ars;
                    if (_replyExpectedMsgs.TryRemove((int)state, out ars) && timeout)
                    {
                        _tracer.TraceError("T6 Timeout");
                        CommunicationStateChanging(ConnectionState.Retry);
                    }
                }, systembyte, T6, true);
            }

            var header = new Header(new byte[10])
            {
                MessageType = msgType,
                SystemBytes = systembyte
            };

            header.Bytes[0] = 0xFF;
            header.Bytes[1] = 0xFF;
            _socket.Send(new List <ArraySegment <byte> >(2)
            {
                ControlMessageLengthBytes,
                new ArraySegment <byte>(header.Bytes)
            });
            _tracer.TraceInfo("Sent Control Message: " + header.MessageType);
        }