Пример #1
0
        public void Decode(byte[] dataPck, out DecodedDataPck decodedDataPck)
        {
            var    status  = DecodeStatus.FailedCrcCheck;
            UInt32 readCrc = 0;

            DataPck pck = null;

            if (this.crcController != null)
            {
                //Extract CRC
                readCrc = BitConverter.ToUInt32(dataPck, 2);
                var computedCrc = this.crcController.CalculateCrc(
                    new ArraySegment <byte>(dataPck, 6, DataPckTypes.DataPckDataSize));


                var arraySeg    = new ArraySegment <byte>(dataPck, 6, DataPckTypes.DataPckDataSize);
                var dataPckType = DataPckDecoderHelper.DataPacketType(arraySeg);
                status = readCrc == computedCrc ? DecodeStatus.Complete : DecodeStatus.FailedCrcCheck;
                DataPckDecoderHelper.ByteArrayToDataPckClass(arraySeg, dataPckType, out pck);
            }
            else
            {
                throw new ArgumentNullException();
            }

            decodedDataPck = new DecodedDataPck(readCrc, status, pck);
        }
Пример #2
0
 public QuadRecvPck(DataPck data, UInt32 crc)
 {
     this.Msg = data;
     this.CRC = crc;
 }
Пример #3
0
 internal DecodedDataPck(UInt32 dataPckCrc, DecodeStatus status, DataPck decodedDataPck)
 {
     this.status         = status;
     this.decodedDataPck = decodedDataPck;
     this.dataPckCrc     = dataPckCrc;
 }
        public static void ByteArrayToDataPckClass(ArraySegment <byte> dataPckBytes, DataPckTypes.DataPcks dataPckType, out DataPck dataPck)
        {
            var data = new byte[dataPckBytes.Count];

            for (var iter = dataPckBytes.Offset; iter < dataPckBytes.Count; iter++)
            {
                data[iter - dataPckBytes.Offset] = dataPckBytes.Array[iter];
            }

            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);


            switch (dataPckType)
            {
            case DataPckTypes.DataPcks.FlightData:
            {
                dataPck = (FlightData)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(FlightData));
                break;
            }

            case DataPckTypes.DataPcks.SendConf:
            {
                dataPck = (SendConf)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(SendConf));
                break;
            }

            case DataPckTypes.DataPcks.SystemId:
            {
                dataPck = (SystemId)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(SystemId));
                break;
            }

            case DataPckTypes.DataPcks.DataLogger:
            {
                dataPck = (DataLogger)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DataLogger));
                break;
            }

            case DataPckTypes.DataPcks.RequiredMsgType:
            {
                dataPck = (RequiredMsgType)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(RequiredMsgType));
                break;
            }

            case DataPckTypes.DataPcks.Message:
            case DataPckTypes.DataPcks.FreeTxtMsg:
            {
                dataPck = (MsgData)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(MsgData));
                break;
            }

            case DataPckTypes.DataPcks.RequestData:
            {
                dataPck = (DataRequest)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DataRequest));
                break;
            }

            case DataPckTypes.DataPcks.HeartBeat:
            {
                dataPck = (HeartBeatData)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(HeartBeatData));
                break;
            }

            default:
            {
                dataPck = null;
                break;
            }
            }

            handle.Free();
        }