Esempio n. 1
0
        /// <summary>
        ///  Sends Cctalk message to device and waits for answer.
        /// </summary>
        public CctalkMessage Send(CctalkMessage com, ICctalkChecksum chHandler)
        {
            // TODO: handle BUSY message
            lock (_callSyncRoot)
            {
                Trace.TraceInformation("Sending message from {0} to {1}. Header={2}", com.SourceAddr, com.DestAddr, com.Header);

                var msgBytes = com.GetTransferDataNoChecksumm();
                chHandler.CalcAndApply(msgBytes);

                //_respondChecksumChecker = chHandler;

                _port.DiscardInBuffer();

                _port.Write(msgBytes, 0, msgBytes.Length);

                Trace.TraceInformation("Message sent, waiting for respond");

                _port.ReadTimeout = RespondStartTimeout;
                Int32 respondBufPos = 0;
                CctalkMessage respond;

                var echoRemover = 0;
                while (true)
                {
                    try
                    {
                        var b = (Byte)_port.ReadByte();
                        // after first respond package we wait fo rest respond packages with another timout
                        _port.ReadTimeout = RespondDataTimeout;

                        if (_removeEcho && (echoRemover < msgBytes.Length))
                        {
                            echoRemover++;
                            continue;
                        }
                        _respondBuf[respondBufPos] = b;
                        respondBufPos++;

                        var isRespondComplete = GenericCctalkDevice.IsRespondComplete(_respondBuf, respondBufPos);
                        if (isRespondComplete)
                        {
                            if (!chHandler.Check(_respondBuf, 0, respondBufPos))
                            {
                                var copy = new byte[respondBufPos];
                                Array.Copy(_respondBuf, copy, respondBufPos);
                                throw new InvalidRespondFormatException(copy, "Checksumm check fail");
                            }
                            respond = GenericCctalkDevice.ParseRespond(_respondBuf, 0, respondBufPos);
                            Array.Clear(_respondBuf, 0, _respondBuf.Length);
                            break;
                        }

                    }
                    catch (TimeoutException ex)
                    {
                        if (_port.ReadTimeout == RespondStartTimeout)
                            throw new TimeoutException("Device not respondng", ex);

                        var respondBufContents = new StringBuilder();
                        for (int i = 0; i > respondBufPos; i++)
                        {
                            respondBufContents.Append(_respondBuf[i].ToString("X"))
                                              .Append(" ");

                        }
                        Trace.TraceInformation("Pause in reply error. Recive buffer contents {0} bytes: {1}", respondBufPos, respondBufContents);
                        Array.Clear(_respondBuf, 0, _respondBuf.Length);
                        throw new TimeoutException("Pause in reply (should reset all communication vatiables and be ready to recive the next message)", ex);

                    }
                }

                return respond;

                /*
                 * When receiving bytes within a message packet, the communication software should
                 * wait up to 50ms for another byte if it is expected. If a timeout condition occurs, the
                 * software should reset all communication variables and be ready to receive the next
                 * message. No other action should be taken. (cctalk spec part1, 11.1)
                 */

            }
        }
 public CctalkMessage Send(CctalkMessage com, ICctalkChecksum checksumHandler)
 {
     throw new NotImplementedException();
 }
        public static CctalkMessage ParseMessage(Byte[] source, Int32 offset, Int32 length)
        {
            if (source == null)
                throw new ArgumentNullException("source");
            if (source.Length < offset + length)
                throw new ArgumentException("offset or length are invalid");

            if (length < CctalkMessage.MinMessageLength)
                throw new ArgumentException("too small for message", "length");

            //if (header != this.Header)
            //    throw new ArgumentException("invalid message type for this class", "source");

            var dataLen = source[CctalkMessage.PosDataLen + offset];

            if (dataLen + 5 != length)
                throw new ArgumentException("invalid message data lengh", "source");

            var ret = new CctalkMessage
                          {
                              Header = source[CctalkMessage.PosHeader + offset],
                              DestAddr = source[CctalkMessage.PosDestAddr + offset],
                              SourceAddr = source[CctalkMessage.PosSourceAddr + offset]
                          };

            if (dataLen > 0)
            {
                ret.Data = new byte[dataLen];
                Array.Copy(source, CctalkMessage.PosDataStart + offset, ret.Data, 0, dataLen);
            }

            return ret;
        }
 public InvalidRespondException(CctalkMessage respond, string message)
     : base(message)
 {
     InvalidRespond = respond;
 }
 public InvalidRespondException(CctalkMessage respond)
     : this(respond, "Invalid respond")
 {
 }
        /// <summary>
        ///  Sends Cctalk message to device and waits for answer.
        /// </summary>
        public CctalkMessage Send(CctalkMessage com, ICctalkChecksum chHandler)
        {
            // TODO: handle BUSY message
            lock (_callSyncRoot)
            {

                var msgBytes = com.GetTransferDataNoChecksumm();
                chHandler.CalcAndApply(msgBytes);

                //_respondChecksumChecker = chHandler;

                _port.DiscardInBuffer();

                _port.Write(msgBytes, 0, msgBytes.Length);

                _port.ReadTimeout = RespondStartTimeout;
                Int32 respondBufPos = 0;
                CctalkMessage respond;

                var echoRemover = 0;
                while (true)
                {
                    try
                    {
                        var b = (Byte)_port.ReadByte();
                        _port.ReadTimeout = RespondDataTimeout;

                        if (_removeEcho && (echoRemover < msgBytes.Length))
                        {
                            echoRemover++;
                            continue;
                        }
                        _respondBuf[respondBufPos] = b;
                        respondBufPos++;

                        var isRespondComplete = GenericCctalkDevice.IsRespondComplete(_respondBuf, respondBufPos);
                        if (isRespondComplete)
                        {
                            if (!chHandler.Check(_respondBuf, 0, respondBufPos))
                            {
                                var copy = new byte[respondBufPos];
                                Array.Copy(_respondBuf, copy, respondBufPos);
                                throw new InvalidRespondFormatException(copy, "Checksumm check fail");
                            }
                            respond = GenericCctalkDevice.ParseRespond(_respondBuf, 0, respondBufPos);
                            Array.Clear(_respondBuf, 0, _respondBuf.Length);
                            break;
                        }

                    }
                    catch (TimeoutException ex)
                    {
                        if (_port.ReadTimeout == RespondStartTimeout)
                            throw new TimeoutException("Device not respondng", ex);

                        throw new TimeoutException("Pause in reply (should reset all communication vatiables and be ready to recive the next message)", ex);

                    }
                }

                return respond;

                /*
                 * When receiving bytes within a message packet, the communication software should
                 * wait up to 50ms for another byte if it is expected. If a timeout condition occurs, the
                 * software should reset all communication variables and be ready to receive the next
                 * message. No other action should be taken. (cctalk spec part1, 11.1)
                 */

            }
        }