Esempio n. 1
0
        public override void updateLocalElements(object sender, EventArgs e)
        {
            // GET AND SET OFFSET ANGLES
            double.TryParse(dataStorage.getData("AGC_N20R1"), out double or);
            string ors = dataStorage.getData("AGC_N20R1S");             // NEG if negative

            if (ors == "NEG")
            {
                or = or * -1;
            }

            double.TryParse(dataStorage.getData("AGC_N20R2"), out double op);
            string ops = dataStorage.getData("AGC_N20R2S");

            if (ops == "NEG")
            {
                op = op * -1;
            }

            double.TryParse(dataStorage.getData("AGC_N20R3"), out double oy);
            string oys = dataStorage.getData("AGC_N20R3S");

            if (oys == "NEG")
            {
                oy = oy * -1;
            }

            screenFDAI.setOffset(or / 100.0, op / 100.0, oy / 100.0);


            // UPDATE ROTATION, ERRORS, AND RATES
            if (screenFDAI != null && form.form.connected)
            {
                if (FDAImode == FDAIMode.SURF)
                {
                    rot   = screenStreams.GetData(DataType.flight_rotation);
                    Roll  = screenStreams.GetData(DataType.flight_roll);
                    Pitch = screenStreams.GetData(DataType.flight_pitch);
                    Yaw   = screenStreams.GetData(DataType.flight_heading);
                }
                else
                {
                    rot   = screenStreams.GetData(DataType.flight_inertial_rotation);
                    Roll  = screenStreams.GetData(DataType.flight_inertial_roll);
                    Pitch = screenStreams.GetData(DataType.flight_inertial_pitch);
                    Yaw   = screenStreams.GetData(DataType.flight_inertial_yaw);
                }


                // GET TARGET ANGLES
                double.TryParse(dataStorage.getData("AGC_N23R1"), out double tr);
                string trs = dataStorage.getData("AGC_N23R1S");
                if (trs == "NEG")
                {
                    tr = tr * -1;
                }

                double.TryParse(dataStorage.getData("AGC_N23R2"), out double tp);
                string tps = dataStorage.getData("AGC_N23R2S");
                if (tps == "NEG")
                {
                    tp = tp * -1;
                }

                double.TryParse(dataStorage.getData("AGC_N23R3"), out double ty);
                string tys = dataStorage.getData("AGC_N23R3S");
                if (tys == "NEG")
                {
                    ty = ty * -1;
                }


                RPY = Helper.RPYFromQuaternion(rot);

                // CALCULATE RATES
                double[] hRr = new double[5];
                double[] hPr = new double[5];
                double[] hYr = new double[5];
                for (int i = 0; i < 4; i++)
                {
                    hRr[i] = (lastRoll[i + 1] - lastRoll[i]) / (this.updateRate / 1000f);
                    hPr[i] = (lastPitch[i + 1] - lastPitch[i]) / (this.updateRate / 1000f);
                    hYr[i] = (lastYaw[i + 1] - lastYaw[i]) / (this.updateRate / 1000f);
                }
                hRr[4] = (RPY.Item1 - lastRoll[4]) / (this.updateRate / 1000f);
                hPr[4] = (RPY.Item2 - lastPitch[4]) / (this.updateRate / 1000f);
                hYr[4] = (RPY.Item3 - lastYaw[4]) / (this.updateRate / 1000f);


                // SUM AND AVERAGE RATES
                double r = 0;
                double p = 0;
                double y = 0;
                for (int i = 0; i < 5; i++)
                {
                    r += hRr[i];
                    p += hPr[i];
                    y += hYr[i];
                }

                r = r / 5.0;
                p = p / 5.0;
                y = y / 5.0;


                // Insert new value into rate arrays
                for (int i = 0; i < 4; i++)
                {
                    lastRoll[i]  = lastRoll[i + 1];
                    lastPitch[i] = lastPitch[i + 1];
                    lastYaw[i]   = lastYaw[i + 1];
                }
                lastRoll[4]  = RPY.Item1;
                lastPitch[4] = RPY.Item2;
                lastYaw[4]   = RPY.Item3;

                // SCALE IS CHOSEN BETWEEN 1, 5, or 10 degrees pr second
                // CORRESPONDING ERROR NEEDLES SCALE IS 5, 5, and 15 degrees.

                screenFDAI.setRates(r, p, y, rateScale);



                double rollError  = findError(tr / 100f, Roll, "ROLL");
                double pitchError = findError(tp / 100f, Pitch, "PITCH");
                double yawError   = findError(ty / 100f, Yaw, "YAW");

                screenFDAI.setError(rollError, pitchError, yawError, errorScale);

                screenFDAI.setRotation(rot);
            }

            // UPDATE INDICATORS
            if (rateScale == 1)
            {
                screenIndicators[2].setStatus(Indicator.status.AMBER);
            }
            else
            {
                screenIndicators[2].setStatus(Indicator.status.OFF);
            }
            if (rateScale == 5)
            {
                screenIndicators[3].setStatus(Indicator.status.AMBER);
            }
            else
            {
                screenIndicators[3].setStatus(Indicator.status.OFF);
            }
            if (rateScale == 10)
            {
                screenIndicators[4].setStatus(Indicator.status.AMBER);
            }
            else
            {
                screenIndicators[4].setStatus(Indicator.status.OFF);
            }

            if (FDAImode == FDAIMode.SURF)
            {
                screenIndicators[0].setStatus(Indicator.status.AMBER);
                screenIndicators[1].setStatus(Indicator.status.OFF);
            }
            else
            {
                screenIndicators[0].setStatus(Indicator.status.OFF);
                screenIndicators[1].setStatus(Indicator.status.AMBER);
            }

            screenFDAI.Invalidate();
        }
Esempio n. 2
0
        public override void updateLocalElements(object sender, EventArgs e)
        {
            // Re-usable data variable for graph data
            List <List <KeyValuePair <double, double?> > > data = new List <List <KeyValuePair <double, double?> > >();
            List <Plot.Type> types = new List <Plot.Type>();


            if (form.form.connected && form.form.krpc.CurrentGameScene == GameScene.Flight)
            {
                inertRotation          = screenStreams.GetData(DataType.flight_inertial_rotation);
                MET                    = screenStreams.GetData(DataType.vessel_MET);
                MeanAltitude           = screenStreams.GetData(DataType.flight_meanAltitude);
                SurfaceAltitude        = screenStreams.GetData(DataType.flight_surfaceAltitude);
                ApoapsisAltitude       = screenStreams.GetData(DataType.orbit_apoapsisAltitude);
                PeriapsisAltitude      = screenStreams.GetData(DataType.orbit_periapsisAltitude);
                TimeToApoapsis         = screenStreams.GetData(DataType.orbit_timeToApoapsis);
                TimeToPeriapsis        = screenStreams.GetData(DataType.orbit_timeToPeriapsis);
                Inclination            = screenStreams.GetData(DataType.orbit_inclination);
                Eccentricity           = screenStreams.GetData(DataType.orbit_eccentricity);
                OrbSpeed               = screenStreams.GetData(DataType.orbit_speed);
                Speed                  = screenStreams.GetData(DataType.flight_speed);
                EquatorialRadius       = screenStreams.GetData(DataType.body_radius);
                GravitationalParameter = screenStreams.GetData(DataType.body_gravityParameter);
                Roll                   = screenStreams.GetData(DataType.flight_roll);
                Pitch                  = screenStreams.GetData(DataType.flight_pitch);
                Yaw                    = screenStreams.GetData(DataType.flight_heading);
                BodyName               = screenStreams.GetData(DataType.body_name);
                lat                    = screenStreams.GetData(DataType.flight_latitude);
                lon                    = screenStreams.GetData(DataType.flight_longitude);
                AtmosphereDensity      = screenStreams.GetData(DataType.flight_atmosphereDensity);
                StaticPressure         = screenStreams.GetData(DataType.flight_staticPressure);
                DynamicPressure        = screenStreams.GetData(DataType.flight_dynamicPressure);
                LiquidFuelMax          = screenStreams.GetData(DataType.resource_stage_max_liquidFuel);
                LiquidFuelAmount       = screenStreams.GetData(DataType.resource_stage_amount_liquidFuel);
                OxidizerMax            = screenStreams.GetData(DataType.resource_stage_max_oxidizer);
                OxidizerAmount         = screenStreams.GetData(DataType.resource_stage_amount_oxidizer);
                MonoPropellantMax      = screenStreams.GetData(DataType.resource_stage_max_monoPropellant);
                MonoPropellantAmount   = screenStreams.GetData(DataType.resource_stage_amount_monoPropellant);
                ElectricChargeMax      = screenStreams.GetData(DataType.resource_stage_max_electricCharge);
                ElectricChargeAmount   = screenStreams.GetData(DataType.resource_stage_amount_electricCharge);
                SAS                    = screenStreams.GetData(DataType.control_SAS);
                RCS                    = screenStreams.GetData(DataType.control_RCS);
                Gear                   = screenStreams.GetData(DataType.control_gear);
                Brakes                 = screenStreams.GetData(DataType.control_brakes);
                Lights                 = screenStreams.GetData(DataType.control_lights);
                Abort                  = screenStreams.GetData(DataType.control_abort);
                GForce                 = screenStreams.GetData(DataType.flight_gForce);

                screenLabels[0].Text = " LT: " + Helper.timeString(DateTime.Now.TimeOfDay.TotalSeconds);
                screenLabels[1].Text = "MET: " + Helper.timeString(MET, 3);

                // Orbit info
                screenLabels[30].Text = "      Alt: " + Helper.prtlen(Math.Round(MeanAltitude).ToString(), 9, Helper.Align.RIGHT);            // Altitude
                screenLabels[31].Text = " Apoapsis: " + Helper.prtlen(Math.Round(ApoapsisAltitude).ToString(), 9, Helper.Align.RIGHT);        // Apoapsis
                screenLabels[32].Text = "Periapsis: " + Helper.prtlen(Math.Round(PeriapsisAltitude).ToString(), 9, Helper.Align.RIGHT);       // Periapasis
                screenLabels[33].Text = "      TtA: " + Helper.prtlen(Helper.timeString(TimeToApoapsis), 9, Helper.Align.RIGHT);              // Time to Apoapsis
                screenLabels[34].Text = "      TtP: " + Helper.prtlen(Helper.timeString(TimeToPeriapsis), 9, Helper.Align.RIGHT);             // Time to Periapsis
                screenLabels[35].Text = "      Inc: " + Helper.prtlen(Helper.toFixed(Helper.rad2deg(Inclination), 3), 9, Helper.Align.RIGHT); // Inclination
                screenLabels[36].Text = "      Ecc: " + Helper.prtlen(Helper.toFixed(Eccentricity, 3), 9, Helper.Align.RIGHT);                // Eccentricity
                screenLabels[37].Text = " Orb. Vel: " + Helper.prtlen(Helper.toFixed(OrbSpeed, 1), 9, Helper.Align.RIGHT);                    // Orbit Velocity
                screenLabels[38].Text = " Sur. Vel: " + Helper.prtlen(Helper.toFixed(Speed, 1), 9, Helper.Align.RIGHT);                       // Surface Velocity

                // Orbit Targets and Deltas
                double tgtA = 0, tgtP = 0;
                if (double.TryParse(screenInputs[0].Text, out tgtA) && double.TryParse(screenInputs[1].Text, out tgtP))
                {
                    double sMa    = (tgtA + tgtP + (EquatorialRadius * 2)) / 2;
                    double tgtEcc = (sMa - (tgtP + EquatorialRadius)) / sMa;
                    screenLabels[60].Text = Helper.prtlen(Helper.toFixed(tgtEcc, 3), 8, Helper.Align.RIGHT);                     // Target Eccentricity
                    screenLabels[67].Text = Helper.prtlen(Helper.toFixed(Eccentricity - tgtEcc, 3), 8, Helper.Align.RIGHT);      // Delta Eccentricity
                }

                if (double.TryParse(screenInputs[0].Text, out tgtA))
                {
                    screenLabels[65].Text = Helper.prtlen(Math.Round(tgtA - ApoapsisAltitude).ToString(), 8, Helper.Align.RIGHT);
                }                                                                                                                                 // Delta Apoapsis
                if (double.TryParse(screenInputs[1].Text, out tgtP))
                {
                    screenLabels[66].Text = Helper.prtlen(Math.Round(tgtP - PeriapsisAltitude).ToString(), 8, Helper.Align.RIGHT);
                }                                                                                                                                  // Delta Periapsis

                double u = GravitationalParameter;
                double a = EquatorialRadius + tgtA;
                double r = EquatorialRadius + tgtA;
                double v = Math.Sqrt(u * ((2 / r) - (1 / a)));
                screenLabels[61].Text = Helper.prtlen(Helper.toFixed(v, 1), 8, Helper.Align.RIGHT);                 // Target Obital Velocity at Apoapsis


                // POSITION AND ROTATION INFO
                Tuple <double, double, double> iRPY = Helper.RPYFromQuaternion(inertRotation, "INER");
                inertRoll  = (float)iRPY.Item1;
                inertPitch = (float)iRPY.Item2;
                inertYaw   = (float)iRPY.Item3;

                screenLabels[46].Text = "R: " + Helper.prtlen(Helper.toFixed(Roll, 2), 7, Helper.Align.RIGHT) + "  " + Helper.prtlen(Helper.toFixed(inertRoll, 2), 7, Helper.Align.RIGHT);
                screenLabels[47].Text = "P: " + Helper.prtlen(Helper.toFixed(Pitch, 2), 7, Helper.Align.RIGHT) + "  " + Helper.prtlen(Helper.toFixed(inertPitch, 2), 7, Helper.Align.RIGHT);
                screenLabels[48].Text = "Y: " + Helper.prtlen(Helper.toFixed(Yaw, 2), 7, Helper.Align.RIGHT) + "  " + Helper.prtlen(Helper.toFixed(inertYaw, 2), 7, Helper.Align.RIGHT);

                screenLabels[40].Text = "  Body: " + Helper.prtlen(BodyName, 9, Helper.Align.RIGHT);
                screenLabels[41].Text = "   Lat: " + Helper.prtlen(Helper.toFixed(lat, 5), 9, Helper.Align.RIGHT);
                screenLabels[42].Text = "   Lon: " + Helper.prtlen(Helper.toFixed(lon, 5), 9, Helper.Align.RIGHT);

                screenLabels[43].Text = " Atm.Den: " + Helper.prtlen(Helper.toFixed(AtmosphereDensity, 1), 9, Helper.Align.RIGHT) + "  Radar Alt: " + Helper.prtlen(Math.Round(SurfaceAltitude).ToString(), 7, Helper.Align.RIGHT);
                screenLabels[44].Text = " Atm.Pre: " + Helper.prtlen(Math.Round(StaticPressure).ToString(), 9, Helper.Align.RIGHT);
                screenLabels[45].Text = " Dyn.Pre: " + Helper.prtlen(Math.Round(DynamicPressure).ToString(), 9, Helper.Align.RIGHT) + "    G-Force: " + Helper.prtlen(Helper.toFixed(GForce, 2), 7, Helper.Align.RIGHT);

                // Supplies
                double mF = LiquidFuelMax;
                double cF = LiquidFuelAmount;

                double mO = OxidizerMax;
                double cO = OxidizerAmount;

                double mM = MonoPropellantMax;
                double cM = MonoPropellantAmount;

                double mE = ElectricChargeMax;
                double cE = ElectricChargeAmount;

                screenLabels[50].Text = "         LF     LO     MP     EC";
                screenLabels[51].Text = "STAGE:"
                                        + Helper.prtlen(Math.Round(cF).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round(cO).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Helper.toFixed(cM, 2), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round(cE).ToString(), 7, Helper.Align.RIGHT);
                screenLabels[52].Text = "    %:"
                                        + Helper.prtlen(Math.Round((cF / mF) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cO / mO) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cM / mM) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cE / mE) * 100).ToString(), 7, Helper.Align.RIGHT);

                mF = screenStreams.GetData(DataType.resource_total_max_liquidFuel);
                cF = screenStreams.GetData(DataType.resource_total_amount_liquidFuel);

                mO = screenStreams.GetData(DataType.resource_total_max_oxidizer);
                cO = screenStreams.GetData(DataType.resource_total_amount_oxidizer);

                mM = screenStreams.GetData(DataType.resource_total_max_monoPropellant);
                cM = screenStreams.GetData(DataType.resource_total_amount_monoPropellant);

                mE = screenStreams.GetData(DataType.resource_total_max_electricCharge);
                cE = screenStreams.GetData(DataType.resource_total_amount_electricCharge);

                screenLabels[54].Text = "  TOT:"
                                        + Helper.prtlen(Math.Round(cF).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round(cO).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Helper.toFixed(cM, 2), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round(cE).ToString(), 7, Helper.Align.RIGHT);
                screenLabels[55].Text = "    %:"
                                        + Helper.prtlen(Math.Round((cF / mF) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cO / mO) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cM / mM) * 100).ToString(), 7, Helper.Align.RIGHT)
                                        + Helper.prtlen(Math.Round((cE / mE) * 100).ToString(), 7, Helper.Align.RIGHT);



                // Status
                if (SAS)
                {
                    screenIndicators[0].setStatus(Indicator.status.GREEN);
                }
                else
                {
                    screenIndicators[0].setStatus(Indicator.status.OFF);
                }                                                                                                                                                 // SAS
                if (RCS)
                {
                    screenIndicators[1].setStatus(Indicator.status.GREEN);
                }
                else
                {
                    screenIndicators[1].setStatus(Indicator.status.OFF);
                }                                                                                                                                                 // RCS
                if (Gear)
                {
                    screenIndicators[2].setStatus(Indicator.status.GREEN);
                }
                else
                {
                    screenIndicators[2].setStatus(Indicator.status.OFF);
                }                                                                                                                                                  // GEAR
                if (Brakes)
                {
                    screenIndicators[3].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[3].setStatus(Indicator.status.OFF);
                }                                                                                                                                                  // Break
                if (Lights)
                {
                    screenIndicators[4].setStatus(Indicator.status.AMBER);
                }
                else
                {
                    screenIndicators[4].setStatus(Indicator.status.OFF);
                }                                                                                                                                                    // Lights
                if (Abort)
                {
                    screenIndicators[5].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[5].setStatus(Indicator.status.OFF);
                }                                                                                                                                                 // Abort

                if (GForce > 4)
                {
                    screenIndicators[7].setStatus(Indicator.status.AMBER);
                }
                else
                {
                    screenIndicators[7].setStatus(Indicator.status.OFF);
                }                                                                                                                                                        // G High

                double maxR = mE;
                double curR = cE;
                if (curR / maxR > 0.95)
                {
                    screenIndicators[6].setStatus(Indicator.status.GREEN);
                }
                else
                {
                    screenIndicators[6].setStatus(Indicator.status.OFF);
                }                                                                                                                                                                // Power High
                if (curR / maxR < 0.1)
                {
                    screenIndicators[9].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[9].setStatus(Indicator.status.OFF);
                }                                                                                                                                                             // Power Low

                maxR = mM;
                curR = cM;
                if (curR / maxR < 0.1)
                {
                    screenIndicators[10].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[10].setStatus(Indicator.status.OFF);
                }                                                                                                                                                               // Monopropellant Low

                maxR = mF;
                curR = cF;
                if (curR / maxR < 0.1)
                {
                    screenIndicators[11].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[11].setStatus(Indicator.status.OFF);
                }                                                                                                                                                               // Fuel Low

                maxR = mO;
                curR = cO;
                if (curR / maxR < 0.1)
                {
                    screenIndicators[8].setStatus(Indicator.status.RED);
                }
                else
                {
                    screenIndicators[8].setStatus(Indicator.status.OFF);
                }                                                                                                                                                             // LOW Low


                // Graphs
                int xMin = screenCharts[0].findMinX(chartData["altitudeTime"]);
                int xMax = screenCharts[0].findMaxX(chartData["altitudeTime"]);

                List <KeyValuePair <double, double?> > targetA = new List <KeyValuePair <double, double?> >();
                targetA.Add(new KeyValuePair <double, double?>(xMin, tgtA));
                targetA.Add(new KeyValuePair <double, double?>(xMax, tgtA));

                List <KeyValuePair <double, double?> > targetP = new List <KeyValuePair <double, double?> >();
                targetP.Add(new KeyValuePair <double, double?>(xMin, tgtP));
                targetP.Add(new KeyValuePair <double, double?>(xMax, tgtP));

                data  = new List <List <KeyValuePair <double, double?> > >();
                types = new List <Plot.Type>();
                data.Add(targetA);
                types.Add(Plot.Type.LINE);
                data.Add(targetP);
                types.Add(Plot.Type.LINE);
                data.Add(chartData["apoapsisTime"]);
                types.Add(Plot.Type.LINE);
                data.Add(chartData["periapsisTime"]);
                types.Add(Plot.Type.LINE);
                data.Add(chartData["altitudeTime"]);
                types.Add(Plot.Type.LINE);
                screenCharts[0].setData(data, types, false);

                data  = new List <List <KeyValuePair <double, double?> > >();
                types = new List <Plot.Type>();
                data.Add(chartData["geeTime"]);
                types.Add(Plot.Type.LINE);
                data.Add(chartData["dynPresTime"]);
                types.Add(Plot.Type.LINE);
                screenCharts[1].setData(data, types, true);
            }
        }
Esempio n. 3
0
        public override void updateLocalElements(object sender, EventArgs e)
        {
            screenLabels[2].Text = "LT: " + Helper.timeString(DateTime.Now.TimeOfDay.TotalSeconds, 2);

            if (form.form.connected && form.form.krpc.CurrentGameScene == GameScene.Flight)
            {
                // GET DATA

                screenLabels[3].Text = "MET: " + Helper.timeString(screenStreams.GetData(DataType.vessel_MET), 3);


                //surfaceRefsmmat = form.connection.SpaceCenter().ActiveVessel.SurfaceReferenceFrame;
                //inertialRefsmmat = form.connection.SpaceCenter().ActiveVessel.Orbit.Body.NonRotatingReferenceFrame;

                positionVector      = screenStreams.GetData(DataType.vessel_position);
                velocityVector      = screenStreams.GetData(DataType.vessel_velocity);
                vesselSurfDirection = screenStreams.GetData(DataType.flight_direction);

                vesselInerDirection = screenStreams.GetData(DataType.flight_inertial_direction);
                vesselInerRotation  = screenStreams.GetData(DataType.flight_inertial_rotation);

                surfaceRefsmmat  = screenStreams.GetData(DataType.vessel_surfaceReferenceFrame);
                vesselRefsmmat   = screenStreams.GetData(DataType.vessel_referenceFrame);
                inertialRefsmmat = screenStreams.GetData(DataType.body_nonRotatingReferenceFrame);

                // ROTATION
                // Ref (AGC NOUN 20)
                double ds;
                if (double.TryParse(dataStorage.getData("AGC_N20R1"), out ds))
                {
                    rR = ds / 100d;
                }
                else
                {
                    rR = 0;
                }

                if (double.TryParse(dataStorage.getData("AGC_N20R2"), out ds))
                {
                    rP = ds / 100d;
                }
                else
                {
                    rP = 0;
                }

                if (double.TryParse(dataStorage.getData("AGC_N20R3"), out ds))
                {
                    rY = ds / 100d;
                }
                else
                {
                    rY = 0;
                }


                Tuple <double, double, double> iRPY = Helper.RPYFromQuaternion(vesselInerRotation, "INER");
                iR = iRPY.Item1;
                iP = iRPY.Item2;
                iY = iRPY.Item3;


                bR = 0;
                bP = 0;
                bY = 0;

                sR = screenStreams.GetData(DataType.flight_roll);
                sP = screenStreams.GetData(DataType.flight_pitch);
                sY = screenStreams.GetData(DataType.flight_heading);

                // DIRECTION VECTORS
                inerPrograde   = screenStreams.GetData(DataType.flight_inertial_prograde);
                inerRetrograde = screenStreams.GetData(DataType.flight_inertial_retrograde);
                inerNormal     = screenStreams.GetData(DataType.flight_inertial_normal);
                inerAntiNormal = screenStreams.GetData(DataType.flight_inertial_antiNormal);
                inerRadial     = screenStreams.GetData(DataType.flight_inertial_radial);
                inerAntiRadial = screenStreams.GetData(DataType.flight_inertial_antiRadial);

                surfPrograde   = screenStreams.GetData(DataType.flight_prograde);
                surfRetrograde = screenStreams.GetData(DataType.flight_retrograde);
                surfNormal     = screenStreams.GetData(DataType.flight_normal);
                surfAntiNormal = screenStreams.GetData(DataType.flight_antiNormal);
                surfRadial     = screenStreams.GetData(DataType.flight_radial);
                surfAntiRadial = screenStreams.GetData(DataType.flight_antiRadial);



                // ORBIT ELEMENTS
                eccentricity        = screenStreams.GetData(DataType.orbit_eccentricity);
                semiMajorAxis       = screenStreams.GetData(DataType.orbit_semiMajorAxis);
                Inclination         = screenStreams.GetData(DataType.orbit_inclination);
                LongitudeOfNode     = screenStreams.GetData(DataType.orbit_longitudeOfAscendingNode);
                ArgumentOfPeriapsis = screenStreams.GetData(DataType.orbit_argumentOfPeriapsis);
                TrueAnomaly         = screenStreams.GetData(DataType.orbit_trueAnomaly);
                OrbitPeriod         = screenStreams.GetData(DataType.orbit_period);
                SOIChange           = screenStreams.GetData(DataType.orbit_timeToSOIChange);
                OrbitalSpeed        = screenStreams.GetData(DataType.orbit_speed);

                // FLIGHT ELEMENTS
                altitude        = screenStreams.GetData(DataType.flight_meanAltitude);
                apoapsis        = screenStreams.GetData(DataType.orbit_apoapsisAltitude);
                periapsis       = screenStreams.GetData(DataType.orbit_periapsisAltitude);
                timeToPeriapsis = screenStreams.GetData(DataType.orbit_timeToPeriapsis);
                timeToApoapsis  = screenStreams.GetData(DataType.orbit_timeToApoapsis);

                // STATE VECTORS
                screenLabels[32].Text = "Px: " + Helper.prtlen(Helper.toFixed(positionVector.Item1 / 1000d, 3, true), 9, Helper.Align.RIGHT);
                screenLabels[33].Text = "Py: " + Helper.prtlen(Helper.toFixed(positionVector.Item2 / 1000d, 3, true), 9, Helper.Align.RIGHT);
                screenLabels[34].Text = "Pz: " + Helper.prtlen(Helper.toFixed(positionVector.Item3 / 1000d, 3, true), 9, Helper.Align.RIGHT);

                // SPEED VECTORS
                screenLabels[41].Text = "Vx: " + Helper.prtlen(Helper.toFixed(velocityVector.Item1, 3, true), 9, Helper.Align.RIGHT);
                screenLabels[42].Text = "Vy: " + Helper.prtlen(Helper.toFixed(velocityVector.Item2, 3, true), 9, Helper.Align.RIGHT);
                screenLabels[43].Text = "Vz: " + Helper.prtlen(Helper.toFixed(velocityVector.Item3, 3, true), 9, Helper.Align.RIGHT);


                // ROTATION

                string iRs = Helper.prtlen(Helper.toFixed(iR, 2), 7, Helper.Align.RIGHT);
                string iPs = Helper.prtlen(Helper.toFixed(iP, 2), 7, Helper.Align.RIGHT);
                string iYs = Helper.prtlen(Helper.toFixed(iY, 2), 7, Helper.Align.RIGHT);
                string bRs = Helper.prtlen(Helper.toFixed(bR, 2), 7, Helper.Align.RIGHT);
                string bPs = Helper.prtlen(Helper.toFixed(bP, 2), 7, Helper.Align.RIGHT);
                string bYs = Helper.prtlen(Helper.toFixed(bY, 2), 7, Helper.Align.RIGHT);
                string sRs = Helper.prtlen(Helper.toFixed(sR, 2), 7, Helper.Align.RIGHT);
                string sPs = Helper.prtlen(Helper.toFixed(sP, 2), 7, Helper.Align.RIGHT);
                string sYs = Helper.prtlen(Helper.toFixed(sY, 2), 7, Helper.Align.RIGHT);
                string rRs = Helper.prtlen(Helper.toFixed(rR, 2), 7, Helper.Align.RIGHT);
                string rPs = Helper.prtlen(Helper.toFixed(rP, 2), 7, Helper.Align.RIGHT);
                string rYs = Helper.prtlen(Helper.toFixed(rY, 2), 7, Helper.Align.RIGHT);

                ifR = normalize(iR + rR, -180, 180);
                ifP = normalize(iP + rP, -90, 90);
                ifY = normalize(iY + rY, 0, 360);

                sfR = normalize(sR + rR, -180, 180);
                sfP = normalize(sP + rP, -90, 90);
                sfY = normalize(sY + rY, 0, 360);

                string ifRs = Helper.prtlen(Helper.toFixed(ifR, 2), 7, Helper.Align.RIGHT);
                string ifPs = Helper.prtlen(Helper.toFixed(ifP, 2), 7, Helper.Align.RIGHT);
                string ifYs = Helper.prtlen(Helper.toFixed(ifY, 2), 7, Helper.Align.RIGHT);

                string sfRs = Helper.prtlen(Helper.toFixed(sfR, 2), 7, Helper.Align.RIGHT);
                string sfPs = Helper.prtlen(Helper.toFixed(sfP, 2), 7, Helper.Align.RIGHT);
                string sfYs = Helper.prtlen(Helper.toFixed(sfY, 2), 7, Helper.Align.RIGHT);

                screenLabels[52].Text = "│ INER ATT:" + iRs + " " + iPs + " " + iYs + "  │";
                screenLabels[53].Text = "│    BURN :" + bRs + " " + bPs + " " + bYs + "  │";
                screenLabels[54].Text = "│    REF  :" + rRs + " " + rPs + " " + rYs + "  │";
                screenLabels[55].Text = "│    FDAI :" + ifRs + " " + ifPs + " " + ifYs + "  │";
                screenLabels[57].Text = "│ SURF ATT:" + sRs + " " + sPs + " " + sYs + "  │";
                screenLabels[58].Text = "│    REF  :" + rRs + " " + rPs + " " + rYs + "  │";
                screenLabels[59].Text = "│    FDAI :" + sfRs + " " + sfPs + " " + sfYs + "  │";


                // ORBITAL ELEMENTS
                screenLabels[10].Text = "     ECCENTRICITY: " + Helper.prtlen(Helper.toFixed(eccentricity, 5), 11, Helper.Align.RIGHT);
                screenLabels[11].Text = "   SEMIMAJOR AXIS: " + Helper.prtlen(Helper.toFixed(semiMajorAxis, 3), 11, Helper.Align.RIGHT);
                screenLabels[12].Text = "      INCLINATION: " + Helper.prtlen(Helper.toFixed(Helper.rad2deg(Inclination), 3), 11, Helper.Align.RIGHT);
                screenLabels[13].Text = "LONGITUDE OF NODE: " + Helper.prtlen(Helper.toFixed(Helper.rad2deg(LongitudeOfNode), 3), 11, Helper.Align.RIGHT);
                screenLabels[14].Text = "ARG. OF PERIAPSIS: " + Helper.prtlen(Helper.toFixed(Helper.rad2deg(ArgumentOfPeriapsis), 3), 11, Helper.Align.RIGHT);
                screenLabels[15].Text = "     TRUE ANOMALY: " + Helper.prtlen(Helper.toFixed(Helper.rad2deg(TrueAnomaly), 3), 11, Helper.Align.RIGHT);
                screenLabels[16].Text = "       ORB PERIOD: " + Helper.prtlen(Helper.timeString(OrbitPeriod, true, 2), 11, Helper.Align.RIGHT);
                screenLabels[17].Text = "       SOI CHANGE: " + Helper.prtlen(Helper.timeString(SOIChange, true, 2), 11, Helper.Align.RIGHT);
                screenLabels[18].Text = "        ORB SPEED: " + Helper.prtlen(Helper.toFixed(OrbitalSpeed, 3), 11, Helper.Align.RIGHT);

                // FLIGHT ELEMENTS
                screenLabels[21].Text = "         ALTITUDE: " + Helper.prtlen(Helper.toFixed(altitude, 3), 11, Helper.Align.RIGHT);
                screenLabels[22].Text = "         APOAPSIS: " + Helper.prtlen(Helper.toFixed(apoapsis, 3), 11, Helper.Align.RIGHT);
                screenLabels[23].Text = "        PERIAPSIS: " + Helper.prtlen(Helper.toFixed(periapsis, 3), 11, Helper.Align.RIGHT);
                screenLabels[24].Text = " TIME TO APOAPSIS: " + Helper.prtlen(Helper.timeString(timeToApoapsis, true, 2), 11, Helper.Align.RIGHT);
                screenLabels[25].Text = "TIME TO PERIAPSIS: " + Helper.prtlen(Helper.timeString(timeToPeriapsis, true, 2), 11, Helper.Align.RIGHT);


                // DIRECTION VECTORS
                Tuple <double, double, double> inerProgradeRPY   = inerVectorToRPY(inerPrograde);
                Tuple <double, double, double> inerRetrogradeRPY = inerVectorToRPY(inerRetrograde);
                Tuple <double, double, double> inerNormalRPY     = inerVectorToRPY(inerNormal);
                Tuple <double, double, double> inerAntiNormalRPY = inerVectorToRPY(inerAntiNormal);
                Tuple <double, double, double> inerRadialRPY     = inerVectorToRPY(inerRadial);
                Tuple <double, double, double> inerAntiRadialRPY = inerVectorToRPY(inerAntiRadial);

                Tuple <double, double, double> surfProgradeRPY   = surfVectorToRPY(surfPrograde);
                Tuple <double, double, double> surfRetrogradeRPY = surfVectorToRPY(surfRetrograde);
                Tuple <double, double, double> surfNormalRPY     = surfVectorToRPY(surfNormal);
                Tuple <double, double, double> surfAntiNormalRPY = surfVectorToRPY(surfAntiNormal);
                Tuple <double, double, double> surfRadialRPY     = surfVectorToRPY(surfRadial);
                Tuple <double, double, double> surfAntiRadialRPY = surfVectorToRPY(surfAntiRadial);

                // INERTIAL REFERENCE DIRECTIONS
                string prR = Helper.prtlen(Helper.toFixed(inerProgradeRPY.Item1, 2), 8, Helper.Align.RIGHT);
                string prP = Helper.prtlen(Helper.toFixed(inerProgradeRPY.Item2, 2), 10, Helper.Align.RIGHT);
                string prY = Helper.prtlen(Helper.toFixed(inerProgradeRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[82].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(inerRetrogradeRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(inerRetrogradeRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(inerRetrogradeRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[83].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(inerNormalRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(inerNormalRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(inerNormalRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[84].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(inerAntiNormalRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(inerAntiNormalRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(inerAntiNormalRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[85].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(inerRadialRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(inerRadialRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(inerRadialRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[86].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(inerAntiRadialRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(inerAntiRadialRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(inerAntiRadialRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[87].Text = prR + prP + prY;


                // SURFACE REFERENCE DIRECTIONS
                prR = Helper.prtlen(Helper.toFixed(surfProgradeRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfProgradeRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfProgradeRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[92].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(surfRetrogradeRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfRetrogradeRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfRetrogradeRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[93].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(surfNormalRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfNormalRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfNormalRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[94].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(surfAntiNormalRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfAntiNormalRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfAntiNormalRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[95].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(surfRadialRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfRadialRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfRadialRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[96].Text = prR + prP + prY;

                prR = Helper.prtlen(Helper.toFixed(surfAntiRadialRPY.Item1, 2), 8, Helper.Align.RIGHT);
                prP = Helper.prtlen(Helper.toFixed(surfAntiRadialRPY.Item2, 2), 10, Helper.Align.RIGHT);
                prY = Helper.prtlen(Helper.toFixed(surfAntiRadialRPY.Item3, 2), 10, Helper.Align.RIGHT);
                screenLabels[97].Text = prR + prP + prY;
            }
        }