示例#1
0
        private void Worker()
        {
            ByteArrayWriter byteArrayWriter = (ByteArrayWriter)null;

            while (!this._closing)
            {
                int bytesToRead = this.Port.BytesToRead;
                if (bytesToRead > 0)
                {
                    byte[] numArray = new byte[bytesToRead];
                    this.Port.Read(numArray, 0, bytesToRead);
                    this.Protocol.OnIncommingData(numArray);
                    if (byteArrayWriter == null)
                    {
                        byteArrayWriter = new ByteArrayWriter();
                    }
                    byteArrayWriter.WriteBytes(numArray, 0, bytesToRead);
                    ServerCommData data = new ServerCommData(this.Protocol);
                    data.IncomingData = byteArrayWriter.ToReader();
                    CommResponse commResponse = this.Protocol.Codec.ServerDecode((CommDataBase)data);
                    if (commResponse.Status == 3)
                    {
                        this.OnServeCommand(data);
                        this.Protocol.Codec.ServerEncode((CommDataBase)data);
                        byte[] array = data.OutgoingData.ToArray();
                        this.Port.Write(array, 0, array.Length);
                        this.Protocol.OnOutgoingData(array);
                        byteArrayWriter = (ByteArrayWriter)null;
                    }
                    else if (commResponse.Status == 1)
                    {
                        byteArrayWriter = (ByteArrayWriter)null;
                    }
                }
                Thread.Sleep(100);
            }
        }
        /// <summary>
        /// Entry-point for submitting a query to the remote device
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public CommResponse Query(ClientCommData data)
        {
            lock (Port)
            {
                //convert the request data as an ordinary byte array
                byte[] outgoing = data
                                  .OutgoingData
                                  .ToArray();

                //create a writer for accumulate the incoming data
                var incoming = new ByteArrayWriter();

                const int tempSize = 256;
                var       temp     = new byte[tempSize];

                //retries loop
                for (int attempt = 0, retries = data.Retries; attempt < retries; attempt++)
                {
                    //flush any residual content
                    Port
                    .DiscardInBuffer();

                    Port
                    .DiscardOutBuffer();

                    //phyiscal writing
                    Port
                    .Write(outgoing, 0, outgoing.Length);

                    incoming.Reset();
                    Thread.Sleep(100);
                    //start the local timer
                    bool timeoutExpired;
                    int  totalTimeout = Latency + data.Timeout;

                    using (Timer timer = new Timer(
                               _ => timeoutExpired = true,
                               state: null,
                               dueTime: totalTimeout,
                               period: Timeout.Infinite))
                    {
                        //reception loop, until a valid response or timeout
                        timeoutExpired = false;
                        while (timeoutExpired == false)
                        {
                            int length = Port.BytesToRead;

                            if (length > 0)
                            {
                                if (length > tempSize)
                                {
                                    length = tempSize;
                                }

                                //read the incoming data from the physical port
                                Port
                                .Read(temp, 0, length);

                                //append data to the writer
                                incoming.WriteBytes(
                                    temp,
                                    0,
                                    length);

                                //try to decode the stream
                                data.IncomingData = incoming.ToReader();

                                CommResponse result = data
                                                      .OwnerProtocol
                                                      .Codec
                                                      .ClientDecode(data);

                                //exit whether any concrete result: either good or bad
                                if (result.Status == CommResponse.Ack)
                                {
                                    return(result);
                                }
                                else if (result.Status == CommResponse.Critical)
                                {
                                    return(result);
                                }
                                else if (result.Status != CommResponse.Unknown)
                                {
                                    break;
                                }
                            }

                            Thread.Sleep(100);

                            //stop immediately if the host asked to abort

                            //TODO
                        }
                    }   //using (timer)
                }       //for

                //no attempt was successful
                return(new CommResponse(
                           data,
                           CommResponse.Critical));
            }   //lock
        }
示例#3
0
        /// <summary>
        /// Running thread handler
        /// </summary>
        private void Worker()
        {
            //create a writer for the incoming data
            ByteArrayWriter writer = null;

            //loop, until the host closes
            while (_closing == false)
            {
                //look for incoming data
                int length = Port.BytesToRead;
                if (length > 0)
                {
                    var buffer = new byte[length];

                    //read the data from the physical port
                    Port.Read(
                        buffer,
                        0,
                        length);
                    Protocol.OnIncommingData(buffer, length);
                    //append the data to the writer
                    if (writer == null)
                    {
                        writer = new ByteArrayWriter();
                    }

                    writer.WriteBytes(
                        buffer,
                        0,
                        length);

                    //try to decode the incoming data
                    var data = new ServerCommData(Protocol);
                    data.IncomingData = writer.ToReader();

                    CommResponse result = Protocol
                                          .Codec
                                          .ServerDecode(data);

                    if (result.Status == CommResponse.Ack)
                    {
                        //the command is recognized, so call the host back
                        OnServeCommand(data);

                        //encode the host data
                        Protocol
                        .Codec
                        .ServerEncode(data);

                        //return the resulting data to the remote caller
                        byte[] outgoing = data
                                          .OutgoingData
                                          .ToArray();

                        Port.Write(
                            outgoing,
                            0,
                            outgoing.Length);
                        Protocol.OnOutgoingData(outgoing);
                        writer = null;
                    }
                    else if (result.Status == CommResponse.Ignore)
                    {
                        writer = null;
                    }
                }

                Thread.Sleep(100);
            }
        }