AsterixDisplayAnalyser.CAT62I185UserData.DecodeCAT62I185 C# (CSharp) Метод

DecodeCAT62I185() публичный статический Метод

public static DecodeCAT62I185 ( byte Data ) : void
Data byte
Результат void
        public static void DecodeCAT62I185(byte[] Data)
        {
            CAT62I185Types.CalculatedGSPandHDG_Type CalculatedGSPDandHDG = new CAT62I185Types.CalculatedGSPandHDG_Type();

            // Get an instance of bit ops
            Bit_Ops BO = new Bit_Ops();

            BO.DWord[Bit_Ops.Bits0_7_Of_DWord] = Data[CAT62.CurrentDataBufferOctalIndex + 3];
            BO.DWord[Bit_Ops.Bits8_15_Of_DWord] = Data[CAT62.CurrentDataBufferOctalIndex + 2];
            BO.DWord[Bit_Ops.Bits16_23_Of_DWord] = Data[CAT62.CurrentDataBufferOctalIndex + 1];
            BO.DWord[Bit_Ops.Bits24_31_Of_DWord] = Data[CAT62.CurrentDataBufferOctalIndex];

            double Vx = 0.0;
            double Vy = 0.0;
            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Vx
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit31] == true)
            {
                Bit_Ops BO1_Temp = new Bit_Ops();

                BO1_Temp.DWord[Bit_Ops.Bit0] = !BO.DWord[Bit_Ops.Bit16];
                BO1_Temp.DWord[Bit_Ops.Bit1] = !BO.DWord[Bit_Ops.Bit17];
                BO1_Temp.DWord[Bit_Ops.Bit2] = !BO.DWord[Bit_Ops.Bit18];
                BO1_Temp.DWord[Bit_Ops.Bit3] = !BO.DWord[Bit_Ops.Bit19];
                BO1_Temp.DWord[Bit_Ops.Bit4] = !BO.DWord[Bit_Ops.Bit20];
                BO1_Temp.DWord[Bit_Ops.Bit5] = !BO.DWord[Bit_Ops.Bit21];
                BO1_Temp.DWord[Bit_Ops.Bit6] = !BO.DWord[Bit_Ops.Bit22];
                BO1_Temp.DWord[Bit_Ops.Bit7] = !BO.DWord[Bit_Ops.Bit23];
                BO1_Temp.DWord[Bit_Ops.Bit8] = !BO.DWord[Bit_Ops.Bit24];
                BO1_Temp.DWord[Bit_Ops.Bit9] = !BO.DWord[Bit_Ops.Bit25];
                BO1_Temp.DWord[Bit_Ops.Bit10] = !BO.DWord[Bit_Ops.Bit26];
                BO1_Temp.DWord[Bit_Ops.Bit11] = !BO.DWord[Bit_Ops.Bit27];
                BO1_Temp.DWord[Bit_Ops.Bit12] = !BO.DWord[Bit_Ops.Bit28];
                BO1_Temp.DWord[Bit_Ops.Bit13] = !BO.DWord[Bit_Ops.Bit29];
                BO1_Temp.DWord[Bit_Ops.Bit14] = !BO.DWord[Bit_Ops.Bit30];
                BO1_Temp.DWord[Bit_Ops.Bit15] = !BO.DWord[Bit_Ops.Bit31];

                BO1_Temp.DWord[Bit_Ops.Bit16] = false;
                BO1_Temp.DWord[Bit_Ops.Bit17] = false;
                BO1_Temp.DWord[Bit_Ops.Bit18] = false;
                BO1_Temp.DWord[Bit_Ops.Bit19] = false;
                BO1_Temp.DWord[Bit_Ops.Bit20] = false;
                BO1_Temp.DWord[Bit_Ops.Bit21] = false;
                BO1_Temp.DWord[Bit_Ops.Bit22] = false;
                BO1_Temp.DWord[Bit_Ops.Bit23] = false;
                BO1_Temp.DWord[Bit_Ops.Bit24] = false;
                BO1_Temp.DWord[Bit_Ops.Bit25] = false;
                BO1_Temp.DWord[Bit_Ops.Bit26] = false;
                BO1_Temp.DWord[Bit_Ops.Bit27] = false;
                BO1_Temp.DWord[Bit_Ops.Bit28] = false;
                BO1_Temp.DWord[Bit_Ops.Bit29] = false;
                BO1_Temp.DWord[Bit_Ops.Bit30] = false;
                BO1_Temp.DWord[Bit_Ops.Bit31] = false;

                BO1_Temp.DWord[Bit_Ops.Bits0_15_Of_DWord] = BO1_Temp.DWord[Bit_Ops.Bits0_15_Of_DWord] + 1;

                if (BO1_Temp.DWord[Bit_Ops.Bit0] == true)
                    Vx = V_1;
                if (BO1_Temp.DWord[Bit_Ops.Bit1] == true)
                    Vx = Vx + V_2;
                if (BO1_Temp.DWord[Bit_Ops.Bit2] == true)
                    Vx = Vx + V_3;
                if (BO1_Temp.DWord[Bit_Ops.Bit3] == true)
                    Vx = Vx + V_4;
                if (BO1_Temp.DWord[Bit_Ops.Bit4] == true)
                    Vx = Vx + V_5;
                if (BO1_Temp.DWord[Bit_Ops.Bit5] == true)
                    Vx = Vx + V_6;
                if (BO1_Temp.DWord[Bit_Ops.Bit6] == true)
                    Vx = Vx + V_7;
                if (BO1_Temp.DWord[Bit_Ops.Bit7] == true)
                    Vx = Vx + V_8;
                if (BO1_Temp.DWord[Bit_Ops.Bit8] == true)
                    Vx = Vx + V_9;
                if (BO1_Temp.DWord[Bit_Ops.Bit9] == true)
                    Vx = Vx + V_10;
                if (BO1_Temp.DWord[Bit_Ops.Bit10] == true)
                    Vx = Vx + V_11;
                if (BO1_Temp.DWord[Bit_Ops.Bit11] == true)
                    Vx = Vx + V_12;
                if (BO1_Temp.DWord[Bit_Ops.Bit12] == true)
                    Vx = Vx + V_13;
                if (BO1_Temp.DWord[Bit_Ops.Bit13] == true)
                    Vx = Vx + V_14;
                if (BO1_Temp.DWord[Bit_Ops.Bit14] == true)
                    Vx = Vx + V_15;
                if (BO1_Temp.DWord[Bit_Ops.Bit15] == true)
                    Vx = Vx + V_16;

                Vx = -Vx;
            }
            else
            {
                if (BO.DWord[Bit_Ops.Bit16] == true)
                    Vx = V_1;
                if (BO.DWord[Bit_Ops.Bit17] == true)
                    Vx = Vx + V_2;
                if (BO.DWord[Bit_Ops.Bit18] == true)
                    Vx = Vx + V_3;
                if (BO.DWord[Bit_Ops.Bit19] == true)
                    Vx = Vx + V_4;
                if (BO.DWord[Bit_Ops.Bit20] == true)
                    Vx = Vx + V_5;
                if (BO.DWord[Bit_Ops.Bit21] == true)
                    Vx = Vx + V_6;
                if (BO.DWord[Bit_Ops.Bit22] == true)
                    Vx = Vx + V_7;
                if (BO.DWord[Bit_Ops.Bit23] == true)
                    Vx = Vx + V_8;
                if (BO.DWord[Bit_Ops.Bit24] == true)
                    Vx = Vx + V_9;
                if (BO.DWord[Bit_Ops.Bit25] == true)
                    Vx = Vx + V_10;
                if (BO.DWord[Bit_Ops.Bit26] == true)
                    Vx = Vx + V_11;
                if (BO.DWord[Bit_Ops.Bit27] == true)
                    Vx = Vx + V_12;
                if (BO.DWord[Bit_Ops.Bit28] == true)
                    Vx = Vx + V_13;
                if (BO.DWord[Bit_Ops.Bit29] == true)
                    Vx = Vx + V_14;
                if (BO.DWord[Bit_Ops.Bit30] == true)
                    Vx = Vx + V_15;
                if (BO.DWord[Bit_Ops.Bit31] == true)
                    Vx = Vx + V_16;
            }

            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Vy
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit15] == true)
            {
                Bit_Ops BO1_Temp = new Bit_Ops();

                BO1_Temp.DWord[Bit_Ops.Bit0] = !BO.DWord[Bit_Ops.Bit0];
                BO1_Temp.DWord[Bit_Ops.Bit1] = !BO.DWord[Bit_Ops.Bit1];
                BO1_Temp.DWord[Bit_Ops.Bit2] = !BO.DWord[Bit_Ops.Bit2];
                BO1_Temp.DWord[Bit_Ops.Bit3] = !BO.DWord[Bit_Ops.Bit3];
                BO1_Temp.DWord[Bit_Ops.Bit4] = !BO.DWord[Bit_Ops.Bit4];
                BO1_Temp.DWord[Bit_Ops.Bit5] = !BO.DWord[Bit_Ops.Bit5];
                BO1_Temp.DWord[Bit_Ops.Bit6] = !BO.DWord[Bit_Ops.Bit6];
                BO1_Temp.DWord[Bit_Ops.Bit7] = !BO.DWord[Bit_Ops.Bit7];
                BO1_Temp.DWord[Bit_Ops.Bit8] = !BO.DWord[Bit_Ops.Bit8];
                BO1_Temp.DWord[Bit_Ops.Bit9] = !BO.DWord[Bit_Ops.Bit9];
                BO1_Temp.DWord[Bit_Ops.Bit10] = !BO.DWord[Bit_Ops.Bit10];
                BO1_Temp.DWord[Bit_Ops.Bit11] = !BO.DWord[Bit_Ops.Bit11];
                BO1_Temp.DWord[Bit_Ops.Bit12] = !BO.DWord[Bit_Ops.Bit12];
                BO1_Temp.DWord[Bit_Ops.Bit13] = !BO.DWord[Bit_Ops.Bit13];
                BO1_Temp.DWord[Bit_Ops.Bit14] = !BO.DWord[Bit_Ops.Bit14];
                BO1_Temp.DWord[Bit_Ops.Bit15] = !BO.DWord[Bit_Ops.Bit15];

                BO1_Temp.DWord[Bit_Ops.Bit16] = false;
                BO1_Temp.DWord[Bit_Ops.Bit17] = false;
                BO1_Temp.DWord[Bit_Ops.Bit18] = false;
                BO1_Temp.DWord[Bit_Ops.Bit19] = false;
                BO1_Temp.DWord[Bit_Ops.Bit20] = false;
                BO1_Temp.DWord[Bit_Ops.Bit21] = false;
                BO1_Temp.DWord[Bit_Ops.Bit22] = false;
                BO1_Temp.DWord[Bit_Ops.Bit23] = false;
                BO1_Temp.DWord[Bit_Ops.Bit24] = false;
                BO1_Temp.DWord[Bit_Ops.Bit25] = false;
                BO1_Temp.DWord[Bit_Ops.Bit26] = false;
                BO1_Temp.DWord[Bit_Ops.Bit27] = false;
                BO1_Temp.DWord[Bit_Ops.Bit28] = false;
                BO1_Temp.DWord[Bit_Ops.Bit29] = false;
                BO1_Temp.DWord[Bit_Ops.Bit30] = false;
                BO1_Temp.DWord[Bit_Ops.Bit31] = false;

                BO1_Temp.DWord[Bit_Ops.Bits0_15_Of_DWord] = BO1_Temp.DWord[Bit_Ops.Bits0_15_Of_DWord] + 1;

                if (BO1_Temp.DWord[Bit_Ops.Bit0] == true)
                    Vy = V_1;
                if (BO1_Temp.DWord[Bit_Ops.Bit1] == true)
                    Vy = Vy + V_2;
                if (BO1_Temp.DWord[Bit_Ops.Bit2] == true)
                    Vy = Vy + V_3;
                if (BO1_Temp.DWord[Bit_Ops.Bit3] == true)
                    Vy = Vy + V_4;
                if (BO1_Temp.DWord[Bit_Ops.Bit4] == true)
                    Vy = Vy + V_5;
                if (BO1_Temp.DWord[Bit_Ops.Bit5] == true)
                    Vy = Vy + V_6;
                if (BO1_Temp.DWord[Bit_Ops.Bit6] == true)
                    Vy = Vy + V_7;
                if (BO1_Temp.DWord[Bit_Ops.Bit7] == true)
                    Vy = Vy + V_8;
                if (BO1_Temp.DWord[Bit_Ops.Bit8] == true)
                    Vy = Vy + V_9;
                if (BO1_Temp.DWord[Bit_Ops.Bit9] == true)
                    Vy = Vy + V_10;
                if (BO1_Temp.DWord[Bit_Ops.Bit10] == true)
                    Vy = Vy + V_11;
                if (BO1_Temp.DWord[Bit_Ops.Bit11] == true)
                    Vy = Vy + V_12;
                if (BO1_Temp.DWord[Bit_Ops.Bit12] == true)
                    Vy = Vy + V_13;
                if (BO1_Temp.DWord[Bit_Ops.Bit13] == true)
                    Vy = Vy + V_14;
                if (BO1_Temp.DWord[Bit_Ops.Bit14] == true)
                    Vy = Vy + V_15;
                if (BO1_Temp.DWord[Bit_Ops.Bit15] == true)
                    Vy = Vy + V_16;

                Vy = -Vy;
            }
            else
            {
                if (BO.DWord[Bit_Ops.Bit0] == true)
                    Vy = V_1;
                if (BO.DWord[Bit_Ops.Bit1] == true)
                    Vy = Vy + V_2;
                if (BO.DWord[Bit_Ops.Bit2] == true)
                    Vy = Vy + V_3;
                if (BO.DWord[Bit_Ops.Bit3] == true)
                    Vy = Vy + V_4;
                if (BO.DWord[Bit_Ops.Bit4] == true)
                    Vy = Vy + V_5;
                if (BO.DWord[Bit_Ops.Bit5] == true)
                    Vy = Vy + V_6;
                if (BO.DWord[Bit_Ops.Bit6] == true)
                    Vy = Vy + V_7;
                if (BO.DWord[Bit_Ops.Bit7] == true)
                    Vy = Vy + V_8;
                if (BO.DWord[Bit_Ops.Bit8] == true)
                    Vy = Vy + V_9;
                if (BO.DWord[Bit_Ops.Bit9] == true)
                    Vy = Vy + V_10;
                if (BO.DWord[Bit_Ops.Bit10] == true)
                    Vy = Vy + V_11;
                if (BO.DWord[Bit_Ops.Bit11] == true)
                    Vy = Vy + V_12;
                if (BO.DWord[Bit_Ops.Bit12] == true)
                    Vy = Vy + V_13;
                if (BO.DWord[Bit_Ops.Bit13] == true)
                    Vy = Vy + V_14;
                if (BO.DWord[Bit_Ops.Bit14] == true)
                    Vy = Vy + V_15;
                if (BO.DWord[Bit_Ops.Bit15] == true)
                    Vy = Vy + V_16;
            }

            CalculatedGSPDandHDG = ToPolarFromCarteisan(Vx, Vy);

            //////////////////////////////////////////////////////////////////////////////////
            // Now assign it to the generic list
            CAT62.I062DataItems[CAT62.ItemIDToIndex("185")].value = CalculatedGSPDandHDG;
            //////////////////////////////////////////////////////////////////////////////////

            // Increase data buffer index so it ready for the next data item.
            CAT62.CurrentDataBufferOctalIndex = CAT62.CurrentDataBufferOctalIndex + 4;
        }

Usage Example

Пример #1
0
        // This method will accept a buffer of data with the assumption that
        // category has been determined. It will then decode the data and save
        // it in the shared buffer. Everry time a message is passed in the data
        // will be appended to the buffer. This means that each line will contain
        // data for one message. For data items which are not in the message,
        // indicated by the FSPEC field, N/A will be inserted instead. The shared
        // buffer is loacted in the SharedData and will not be saved. It is responsibility
        // of the user to save the data in a file it desired.
        public static void Do(byte[] Data)
        {
            // I048/010     Data Source Identifier                     2
            // NO NEED to do anything this is handled in CAT01

            // 2.     - Spare -

            // I062/015 Service Identification                          1
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("015")].CurrentlyPresent == true)
            {
                CAT62I015UserData.DecodeCAT62I015(Data);
            }

            // I062/070 Time Of Track Information                       3
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("070")].CurrentlyPresent == true)
            {
                CAT62I070UserData.DecodeCAT62I070(Data);
            }

            // I062/105 Calculated Track Position (WGS-84)              8
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("105")].CurrentlyPresent == true)
            {
                CAT62I105UserData.DecodeCAT62I105(Data);
            }

            // I062/100 Calculated Track Position (Cartesian)           6
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("100")].CurrentlyPresent == true)
            {
                CAT62I100UserData.DecodeCAT62I100(Data);
            }

            // I062/185 Calculated Track Velocity (Cartesian)           4
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("185")].CurrentlyPresent == true)
            {
                CAT62I185UserData.DecodeCAT62I185(Data);
            }

            // FX.     - Field extension indicator -
            //

            // I062/210 Calculated Acceleration (Cartesian)             2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("210")].CurrentlyPresent == true)
            {
                CAT62I210UserData.DecodeCAT62I210(Data);
            }

            // I062/060 Track Mode 3/A Code                             2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("060")].CurrentlyPresent == true)
            {
                CAT62I060UserData.DecodeCAT62I060(Data);
            }

            // I062/245 Target Identification                           7
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("245")].CurrentlyPresent == true)
            {
                CAT62I245UserData.DecodeCAT62I245(Data);
            }

            // I062/380 Aircraft Derived Data                           1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("380")].CurrentlyPresent == true)
            {
                CAT62I380UserData.DecodeCAT62I380(Data);
            }

            // I062/040 Track Number                                    2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("040")].CurrentlyPresent == true)
            {
                CAT62I040UserData.DecodeCAT62I040(Data);
            }

            // I062/080 Track Status                                    1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("080")].CurrentlyPresent == true)
            {
                CAT62I080UserData.DecodeCAT62I080(Data);
            }

            // I062/290 System Track Update Ages                        1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("290")].CurrentlyPresent == true)
            {
                CAT62I290UserData.DecodeCAT62I290(Data);
            }

            // FX.     - Field extension indicator -
            //
            // I062/200 Mode of Movement                                1
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("200")].CurrentlyPresent == true)
            {
                CAT62I200UserData.DecodeCAT62I200(Data);
            }

            // I062/295 Track Data Ages                                 1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("295")].CurrentlyPresent == true)
            {
                CAT62I295UserData.DecodeCAT62I295(Data);
            }

            // I062/136 Measured Flight Level                           2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("136")].CurrentlyPresent == true)
            {
                CAT62I136UserData.DecodeCAT62I136(Data);
            }

            // I062/130 Calculated Track Geometric Altitude             2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("130")].CurrentlyPresent == true)
            {
                CAT62I130UserData.DecodeCAT62I130(Data);
            }

            // I062/135 Calculated Track Barometric Altitude            2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("135")].CurrentlyPresent == true)
            {
                CAT62I135UserData.DecodeCAT62I135(Data);
            }

            // I062/220 Calculated Rate Of Climb/Descent                2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("220")].CurrentlyPresent == true)
            {
                CAT62I220UserData.DecodeCAT62I220(Data);
            }

            // I062/390 Flight Plan Related Data                        1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("390")].CurrentlyPresent == true)
            {
                CAT62I390UserData.DecodeCAT62I390(Data);
            }

            // FX.     - Field extension indicator -
            //

            // I062/270 Target Size & Orientation                       1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("270")].CurrentlyPresent == true)
            {
                CAT62I270UserData.DecodeCAT62I270(Data);
            }

            // I062/300 Vehicle Fleet Identification                    1
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("300")].CurrentlyPresent == true)
            {
                CAT62I300UserData.DecodeCAT62I300(Data);
            }

            // I062/110 Mode 5 Data reports & Extended Mode 1 Code      1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("110")].CurrentlyPresent == true)
            {
                CAT62I110UserData.DecodeCAT62I110(Data);
            }

            // I062/120 Track Mode 2 Code                               2
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("120")].CurrentlyPresent == true)
            {
                CAT62I120UserData.DecodeCAT62I120(Data);
            }

            // I062/510 Composed Track Number                           3+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("510")].CurrentlyPresent == true)
            {
                CAT62I510UserData.DecodeCAT62I510(Data);
            }

            // I062/500 Estimated Accuracies                            1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("500")].CurrentlyPresent == true)
            {
                CAT62I500UserData.DecodeCAT62I500(Data);
            }

            // I062/340 Measured Information                            1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("340")].CurrentlyPresent == true)
            {
                CAT62I340UserData.DecodeCAT62I340(Data);
            }

            // FX.     - Field extension indicator -

            // I062/500 Estimated Accuracies                            1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("REF")].CurrentlyPresent == true)
            {
                CAT62IREFUserData.DecodeCAT62IREF(Data);
            }

            // I062/340 Measured Information                            1+
            if (CAT62.I062DataItems[CAT62.ItemIDToIndex("SPI")].CurrentlyPresent == true)
            {
                CAT62ISPIUserData.DecodeCAT62ISPI(Data);
            }


            ////////////////////////////////////////////////////////////////////////////////////
            // All CAT62 data has been decoded, so lets save off the message data to the global
            // storage for latter usage

            MainASTERIXDataStorage.CAT62Data CAT62MessageData = new MainASTERIXDataStorage.CAT62Data();

            foreach (CAT62.CAT062DataItem Item in CAT62.I062DataItems)
            {
                CAT62.CAT062DataItem MyItem = new CAT62.CAT062DataItem();

                MyItem.CurrentlyPresent = Item.CurrentlyPresent;
                MyItem.Description      = Item.Description;
                MyItem.HasBeenPresent   = Item.HasBeenPresent;
                MyItem.ID    = Item.ID;
                MyItem.value = Item.value;
                CAT62MessageData.CAT62DataItems.Add(MyItem);
            }

            MainASTERIXDataStorage.CAT62Message.Add(CAT62MessageData);
            CAT62.Intitialize(false);
        }