Beispiel #1
0
 private void receive()
 {
     Task.Factory.StartNew(
         async() =>
     {
         while (!_cts.Token.IsCancellationRequested)
         {
             if (_ws.State == WebSocketState.Open)
             {
                 byte[] buffer = new byte[200000];
                 var result    = await _ws.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
                 if (result.MessageType == WebSocketMessageType.Binary)
                 {
                     _lastReceiveTime = DateTime.UtcNow.GetUnixTimeFromUTC();
                     var resultStr    = Decompress(buffer);
                     OnMsgReceived?.Invoke(this, resultStr);
                 }
                 else if (result.MessageType == WebSocketMessageType.Text)
                 {
                     _lastReceiveTime = DateTime.UtcNow.GetUnixTimeFromUTC();
                     var resultStr    = System.Text.Encoding.UTF8.GetString(buffer);
                     OnMsgReceived?.Invoke(this, resultStr);
                 }
                 else if (result.MessageType == WebSocketMessageType.Close)
                 {
                     try
                     {
                         await _ws.CloseOutputAsync(WebSocketCloseStatus.Empty, null, _cts.Token);
                     }
                     catch (Exception)
                     {
                         break;
                     }
                     break;
                 }
             }
         }
     }, _cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
 }
Beispiel #2
0
        private void ProcessReceive(int bytesTransferred, byte[] buffer, bool isTest = false)
        {
            if (bytesTransferred == 0)
            {
                Close(TcpConnectionCloseType.Expected, "Closed by remote end");
                return;
            }

            if (_incomingMsgVersion == 0)
            {
                _incomingMsgVersion = _recvBuffer[0];
                _incomingMsgLen     = -1;
            }

            _incomingMsgBytesReceived += bytesTransferred;
            while (true)
            {
                if (_incomingMsgLen == -1)
                {
                    byte incomingMsgVersion = _incomingMsgVersion;
                    if (incomingMsgVersion != 1)
                    {
                        Close(TcpConnectionCloseType.InvalidMessageFormat, "Received message has an invalid format");
                        return;
                    }

                    if (_incomingMsgBytesReceived > 4)
                    {
                        _incomingMsgLen = BitConverter.ToInt32(_recvBuffer, 1);
                        if (_recvBuffer.Length < _incomingMsgLen + 5)
                        {
                            Array.Resize(ref _recvBuffer, _incomingMsgLen + 5);
                        }
                    }

                    if (_incomingMsgLen == -1)
                    {
                        goto read;
                    }
                }

                int num = _incomingMsgLen + 5;
                if (_incomingMsgBytesReceived < num)
                {
                    goto read;
                }

                if (_incomingMsgBytesReceived >= num)
                {
                    OnMsgReceived?.Invoke(_recvBuffer, 5, _incomingMsgLen);
                    int num2 = 5 + _incomingMsgLen;
                    if (_incomingMsgBytesReceived <= num2)
                    {
                        goto reset;
                    }
                    int num3 = _incomingMsgBytesReceived - num2;
                    Array.Copy(_recvBuffer, num2, _recvBuffer, 0, num3);
                    ResetPending();
                    _incomingMsgVersion       = _recvBuffer[0];
                    _incomingMsgBytesReceived = num3;
                }
            }
reset:
            ResetPending();
read:
            StartRead(_incomingMsgBytesReceived);
        }
Beispiel #3
0
 public void SetCallback(OnMsgReceived onMessageReceived)
 {
     onMsgReceived = onMessageReceived;
 }
Beispiel #4
0
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (!(e.BytesTransferred > 0 && e.SocketError == SocketError.Success))
            {
                ProcessError(e);
                return;
            }

            if (GetPackageLength == null)
            {
                throw new ArgumentException("The function GetPackageLength can not be null!");
            }

            if (e.LastOperation != SocketAsyncOperation.Receive)
            {
                return;
            }

            byte[] data = new byte[e.BytesTransferred];
            Array.Copy(e.Buffer, e.Offset, data, 0, e.BytesTransferred);
            lock (receiveBufferList)
            {
                receiveBufferList.AddRange(data);
            }

            int headLen    = 0;
            int packageLen = 0;

            //如果当客户发送大数据流的时候,e.BytesTransferred的大小就会比客户端发送过来的要小,
            //需要分多次接收.所以收到包的时候,先判断包头的大小.够一个完整的包再处理.
            //如果客户短时间内发送多个小数据包时, 服务器可能会一次性把他们全收了.
            //这样如果没有一个循环来控制,那么只会处理第一个包,
            //剩下的包全部留在token.Buffer中了,只有等下一个数据包过来后,才会放出一个来.
            do
            {
                packageLen = GetPackageLength(receiveBufferList.ToArray(), out headLen); //获取包头标记的数据长度以及包头的长度

                if (packageLen > receiveBufferList.Count - headLen)
                {
                    break;
                }                                                                       //如果实际数据的长度小于数据中标记的长度,则退出循环,让程序继续接收

                byte[] rev = receiveBufferList.GetRange(headLen, packageLen).ToArray(); //包够长时,则提取出来,交给后面的程序去处理

                //从数据池中移除这组数据,若是同时接收了多个数据包,则token.Buffer中仍会存在数据,循环会继续
                lock (receiveBufferList)
                {
                    receiveBufferList.RemoveRange(0, packageLen + headLen);
                }

                //开启新线程处理消息,不影响继续接收消息
                Thread thread = new Thread(new ParameterizedThreadStart((obj) =>
                {
                    OnMsgReceived?.Invoke((byte[])obj);
                }));
                thread.IsBackground = true;
                thread.Start(rev);
            } while (receiveBufferList.Count > headLen);

            if (!(e.UserToken as Socket).ReceiveAsync(e))
            {
                ProcessReceive(e);
            }
        }
Beispiel #5
0
 public RxStateMachine(EndPoint id) : base(id)
 {
     onMsgReceived = null;
 }
Beispiel #6
0
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (!(e.BytesTransferred > 0 && e.SocketError == SocketError.Success))
            {
                CloseClientSocket(((MySocketAsyncEventArgs)e).UID);
                return;
            }

            if (GetPackageLength == null)
            {
                throw new ArgumentException("The function GetPackageLength can not be null!");
            }

            if (e.LastOperation != SocketAsyncOperation.Receive)
            {
                return;
            }

            AsyncUserToken token = (AsyncUserToken)e.UserToken;

            token.FreshTime = DateTime.Now;
            byte[] data = new byte[e.BytesTransferred];
            Array.Copy(e.Buffer, e.Offset, data, 0, e.BytesTransferred);
            lock (token.Buffer)
            {
                token.Buffer.AddRange(data);
            }

            int headLen    = 0;
            int packageLen = 0;

            //如果当客户发送大数据流的时候,e.BytesTransferred的大小就会比客户端发送过来的要小,
            //需要分多次接收.所以收到包的时候,先判断包头的大小.够一个完整的包再处理.
            //如果客户短时间内发送多个小数据包时, 服务器可能会一次性把他们全收了.
            //这样如果没有一个循环来控制,那么只会处理第一个包,
            //剩下的包全部留在token.Buffer中了,只有等下一个数据包过来后,才会放出一个来.
            do
            {
                packageLen = GetPackageLength(token.Buffer.ToArray(), out headLen); //获取包头标记的数据长度以及包头的长度

                if (packageLen > token.Buffer.Count - headLen)
                {
                    break;
                }                                                                  //如果实际数据的长度小于数据中标记的长度,则退出循环,让程序继续接收

                byte[] rev = token.Buffer.GetRange(headLen, packageLen).ToArray(); //包够长时,则提取出来,交给后面的程序去处理

                //从数据池中移除这组数据,若是同时接收了多个数据包,则token.Buffer中仍会存在数据,循环会继续
                lock (token.Buffer)
                {
                    token.Buffer.RemoveRange(0, packageLen + headLen);
                }

                OnMsgReceived?.Invoke(token, rev);
            } while (token.Buffer.Count > headLen);

            if (!token.Socket.ReceiveAsync(e))
            {
                ProcessReceive(e);
            }
        }
Beispiel #7
0
        /// <summary>
        /// 数据处理线程
        /// </summary>
        private static void DataProcessThread()
        {
            var mcuData         = new string[33];
            var mcuDataCount    = 0;
            var collocetMcuData = false;
            var recvData        = new string[8] {
                "", "", "", "", "", "", "", ""
            };

            while (true)
            {
                if (CAN != null)
                {
                    #region 数据处理部分

                    //发送下位机指令List中的指令
                    if (TableOrderList.Count > 0)
                    {
                        //if (DateTime.Now > tableOrderInterval)
                        //{
                        if ((TableOrderList.Count > 0 && IsSendData[0] == IsSendData[1]) || (DateTime.Now > tableOrderInterval) || IsSendData[1] == "FF FF FF FF FF FF FF FF")
                        {
                            if ((DateTime.Now > tableOrderInterval) && (IsSendData[0] != IsSendData[1]) && IsSendData[1] != "FF FF FF FF FF FF FF FF")
                            {
                                //  MessageBox.Show("接收指令超时:" + IsSendData[1]);

                                OnMsgReceived?.Invoke(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff  ") + "接收指令超时!");
                            }
                            IsSendData[0] = TableOrderList[0].ToString();
                            CAN.SendData(CanSendID, TableOrderList[0].ToString());

                            /* Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") +
                             *                  "                           向下位机发送指令:" + TableOrderList[0].ToString());*/
                            OnMsgReceived?.Invoke(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff  ") + "发送指令:" + IsSendData[0]);
                            tableOrderInterval = DateTime.Now.AddMilliseconds(2500);
                            IsSendData[1]      = "0";
                            TableOrderList.RemoveAt(0);
                        }

                        //}
                    }

                    #endregion

                    #region 数据接收部分

                    //    thrSleepTime = DateTime.Now.AddMilliseconds(0);
                    //Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") + "                CAN接收数据开始");

                    var data = CAN.RecviveData();
                    //Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") + "                CAN接收数据结束");

                    if (data.Length != 0)
                    {
                        foreach (string t in data)
                        {
                            recvData = t.Split(' ');
                            Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff ") + " 接到一组数据:" + t);
                            IsSendData[1] = t;

                            if (IsSendData[1] != "FF FF FF FF FF FF FF FF")
                            {
                                if (IsSendData[0] == IsSendData[1])
                                {
                                    OnMsgReceived?.Invoke(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff  ") + "操作成功:" + IsSendData[1]);
                                }
                            }
                            else
                            {
                                //   MessageBox.Show("操作失败:" + IsSendData[1]);
                                OnMsgReceived?.Invoke(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff  ") + "操作失败:" + IsSendData[1]);
                            }
                            //处理下位机采集数据
                            if (recvData[0] == "00")
                            {
                                if (recvData[1] == "00")
                                {
                                    //Debug.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff ")+"                   接到一组数据");
                                    collocetMcuData = true;
                                    mcuDataCount    = 0;
                                }
                                if (collocetMcuData)
                                {
                                }
                            }

                            for (var a = 0; a < recvData.Length; a++)
                            {
                                recvData[a] = "";
                            }
                        }
                    }

                    #endregion
                }
            }
        }
Beispiel #8
0
 public void SetCallback(OnMsgReceived onMessageReceived)
 {
     onMsgReceived = onMessageReceived;
 }
Beispiel #9
0
 public RxStateMachine(EndPoint id)
     : base(id)
 {
     onMsgReceived = null;
 }