/// <summary>
        /// Parses the provided packet. If the packet cannot be parsed, this method will
        /// throw an argument exception.
        /// </summary>
        /// <param name="packet">The packet to parse.</param>
        /// <returns></returns>
        public override GaugePacket ParsePacket(byte[] packet)
        {
            if (packet.Length < 18 || packet.Length > 20)
            {
                throw new Exception("Packet too short");
            }
            using (BinaryReader r = new BinaryReader(new MemoryStream(packet))) {
                var version = (EProtocolVersion)r.ReadByte();
                var battery = (int)r.ReadByte();

                var readings = new List <GaugeReading>();

                // According to the rigado protocol specification, the packet length should be no more than 19 bytes.
                var           count = 17;                                      // 19 - version and battery
                SensorPayload sp;
                while (count >= (sp = new SensorPayload(r.ReadByte())).length) // While the count still has another potential packet, pull the next packet.
                {
                    count -= sp.length;
                    if (sp.unitCode == 0)
                    {
                        continue;
                    }
                    sp.Parse(r);
                    readings.Add(new GaugeReading()
                    {
                        removed    = !sp.connected,
                        sensorType = UnitLookup.GetSensorTypeFromCode(sp.unitCode),
                        reading    = sp.unit.OfScalar(sp.measurement),
                    });
                }

                return(new GaugePacket(version, battery, readings.ToArray()));
            }
        }
Ejemplo n.º 2
0
        // Overridden from IGaugeProtocol
        public override GaugePacket ParsePacket(byte[] packetIn)
        {
            byte[] packet = Trim(packetIn);
            using (BinaryReader r = new BinaryReader(new MemoryStream(packet))) {
                int len = packet.Length;

                if (len < 8 || len % 6 != 2)
                {
                    /////should not throw exeptions
                    //throw new ArgumentException("Cannot parse: bad packet size {" + len + "}");
                }

                var v = r.ReadByte();

                if (v != 1 && v != 2)
                {
                    /////should not throw exeptions
                    //throw new ArgumentException("Cannot parse: invalid version code");
                }

                int battery = r.ReadByte();

                int maxGaugeCount = (len - 2) / 6;
                var readings      = new List <GaugeReading>();

                for (int i = 0; i < maxGaugeCount; i++)
                {
                    int exponent       = r.ReadByte();
                    int encodedReading = r.ReadInt32BE();
                    int unitCode       = r.ReadByte();

                    if (unitCode == 0)
                    {
                        break;
                    }

                    Unit unit = UnitLookup.GetUnit(unitCode);

                    var gr = new GaugeReading()
                    {
                        removed    = removedGaugeValue == encodedReading,
                        sensorType = UnitLookup.GetSensorTypeFromCode(unitCode),
                        reading    = unit.OfScalar(encodedReading / System.Math.Pow(10, exponent)),
                    };

                    if (gr.removed)
                    {
                        gr.reading = unit.OfScalar(0);
                    }

                    readings.Add(gr);
                }

                return(new GaugePacket(version, battery, readings.ToArray()));
            }
        }