public XBeeInterfaceReceiver(Radio_Series1 p)
 {
     state = (int)RXState.IDLE;
     buffer = new byte[128];
     packet = new XBeeRXPacket();
     parent = p;
 }
        public Boolean Fill(byte[] bytes, int len)
        {
            byte b;
            int i;
            for (i = 0; i < len; i++)
            {
                b = bytes[i];
                switch (state)
                {
                    case RXState.IDLE:
                        if (b == 0x7E)
                        {
                            bytesRead = 0;
                            state = RXState.LEN;
                        }
                        break;

                    case RXState.LEN:
                        if (bytesRead == 0)
                        {
                            packet.length = (uint)b << 8;
                        }
                        else if (bytesRead == 1)
                        {
                            packet.length |= b;
                        }
                        bytesRead++;
                        if (bytesRead == 2)
                        {
                            bytesRead = 0;
                            state = RXState.COMMAND;
                        }
                        break;

                    case RXState.COMMAND:
                        if (b == (byte)XBeeCommands.RX64)
                        {
                            packet.command = b;
                            packet.data = new byte[packet.length - 11];
                            packet.src64 = 0;
                            state = RXState.SRC64;
                        }
                        else if (b == (byte)XBeeCommands.TX)
                        {
                            bytesRead = 0;
                            state = RXState.UNKNOWN;
                        }
                        else
                        {
                            bytesRead = 0;
                            Debug.Print("UNKNOWN PACKET!! " + b);
                            state = RXState.UNKNOWN;
                        }
                        break;

                    case RXState.SRC64:
                        //Read 64bit Sender's Address
                        packet.src64Bytes[bytesRead] = b;
                        packet.src64 += (UInt64)b << (8 * bytesRead);

                        bytesRead++;
                        if (bytesRead == 8)
                        {
                            bytesRead = 0;
                            state = RXState.RSSI;

                            //get first interface packet and store 64bit address
                            if (parent.interfaceAddress == 0)
                            {
                                parent.interfaceAddress = packet.src64;
                                parent.interfaceAddressBytes = packet.src64Bytes;
                                //parent.telemetryThread.Start();
                            }
                            else
                            {
                                //ignore interface packets from the wrong address
                                if (parent.interfaceAddress != packet.src64)
                                {
                                    //state = (int)RXState.UNKNOWN;
                                }
                            }

                        }
                        break;

                    case RXState.SRC16:
                        //Read 16bit Sender's Address
                        packet.src16 = (ushort)((packet.src16 << 8) | b);
                        bytesRead++;

                        if (bytesRead == 2)
                        {
                            bytesRead = 0;
                            state = RXState.RSSI;
                        }
                        break;

                    case RXState.RSSI:
                        packet.rssi = b;
                        state = RXState.OPTIONS;
                        break;

                    case RXState.OPTIONS:
                        packet.options = b;
                        state = RXState.DATA;
                        break;

                    case RXState.DATA:
                        //The beef
                        packet.data[bytesRead] = b;
                        bytesRead++;
                        if (bytesRead == packet.data.Length)
                        {
                            state = RXState.CHECKSUM;
                        }
                        break;

                    case RXState.CHECKSUM:
                        fullPacket = true;
                        state = RXState.IDLE;
                        break;

                    case RXState.UNKNOWN:
                        //ignore all bytes in packet before trying to parse again (all XBee API functions generate a confirmation packet sent as a packet)
                        //We dont care about most of them.
                        //We can get information about the current XBee module (like requesting its serial number or coordinator or network status)
                        bytesRead++;
                        if (bytesRead == packet.length)
                        {
                            state = RXState.IDLE;
                            bytesRead = 0;
                        }
                        break;
                }
            }

            if (fullPacket) return true;
            return false;
        }
示例#3
0
        private RXState state; /** Current state of the receiver. */

        #endregion Fields

        #region Constructors

        /** Constructor for the XBeeInterfaceReceiver class.
         *  @param p The parent Radio instance we're parsing packets for. */
        public XBeeInterfaceReceiver(Radio p)
        {
            state = (int)RXState.IDLE;
            packet = new XBeeRXPacket();
            parent = p;
        }