MSFS 2020 SU16 release.

Author: mattnischan

src/garminsdk/autopilot/GarminAPConfig.ts

@@ -93,6 +93,18 @@ export type GarminAPConfigDirectorOptions = {
    */
   lowBankAngle?: number;
 
+  /**
+   * The target pitch angle, in degrees, commanded by the TO director. Positive values indicate upward pitch. Defaults
+   * to `10`.
+   */
+  toPitchAngle?: number;
+
+  /**
+   * The target pitch angle, in degrees, commanded by the GA director. Positive values indicate upward pitch. Defaults
+   * to `7.5`.
+   */
+  gaPitchAngle?: number;
+
   /**
    * The threshold difference between selected heading and current heading, in degrees, at which the heading director
    * unlocks its commanded turn direction and chooses a new optimal turn direction to establish on the selected
@@ -127,6 +139,9 @@ export type GarminAPConfigOptions = GarminAPConfigDirectorOptions & {
    * `navToNavGuidance` is undefined.
    */
   navToNavOptions?: Readonly<GarminNavToNavManager2Options>;
+
+  /** Whether to deactivate the autopilot when GA mode is armed in response to a TO/GA mode button press. Defaults to `true`. */
+  deactivateAutopilotOnGa?: boolean;
 }
 
 /**
@@ -148,6 +163,12 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   /** The default maximum bank angle, in degrees, in Low Bank Mode. */
   public static readonly DEFAULT_LOW_BANK_ANGLE = 15;
 
+  /** The default target pitch angle, in degrees, commanded by the TO director. Positive values indicate upward pitch. */
+  public static readonly DEFAULT_TO_PITCH_ANGLE = 10;
+
+  /** The default target pitch angle, in degrees, commanded by the GA director. Positive values indicate upward pitch. */
+  public static readonly DEFAULT_GA_PITCH_ANGLE = 7.5;
+
   /** The default HDG director turn direction unlock threshold, in degrees. */
   public static readonly DEFAULT_HDG_DIRECTION_UNLOCK_THRESHOLD = 331;
 
@@ -158,6 +179,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   /** @inheritDoc */
   public readonly cdiId: string;
 
+  /** @inheritDoc */
+  public readonly deactivateAutopilotOnGa: boolean;
+
   public autopilotDriverOptions: AutopilotDriverOptions;
 
   /**
@@ -185,6 +209,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   private readonly lnavMaxBankAngle: number;
   private readonly lowBankAngle: number;
 
+  private readonly toPitchAngle: number;
+  private readonly gaPitchAngle: number;
+
   private readonly hdgTurnReversalThreshold: number;
 
   private vnavManager?: GarminVNavManager2;
@@ -248,6 +275,7 @@ export class GarminAPConfig implements GarminAPConfigInterface {
     options?: Readonly<GarminAPConfigOptions>
   ) {
     this.cdiId = options?.cdiId ?? '';
+    this.deactivateAutopilotOnGa = options?.deactivateAutopilotOnGa ?? true;
 
     if (arg2 instanceof FlightPlanner) {
       this.flightPlanner = arg2;
@@ -305,6 +333,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
     this.lnavMaxBankAngle = options?.lnavMaxBankAngle ?? GarminAPConfig.DEFAULT_MAX_BANK_ANGLE;
     this.lowBankAngle = options?.lowBankAngle ?? GarminAPConfig.DEFAULT_LOW_BANK_ANGLE;
     this.hdgTurnReversalThreshold = options?.hdgTurnReversalThreshold ?? GarminAPConfig.DEFAULT_HDG_DIRECTION_UNLOCK_THRESHOLD;
+
+    this.toPitchAngle = options?.toPitchAngle ?? GarminAPConfig.DEFAULT_TO_PITCH_ANGLE;
+    this.gaPitchAngle = options?.gaPitchAngle ?? GarminAPConfig.DEFAULT_GA_PITCH_ANGLE;
   }
 
   /** @inheritdoc */
@@ -372,6 +403,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   public createVorDirector(apValues: APValues): APNavDirector {
     return new APNavDirector(this.bus, apValues, APLateralModes.VOR, {
       maxBankAngle: () => apValues.maxBankId.get() === 1 ? Math.min(this.vorMaxBankAngle, this.lowBankAngle) : this.vorMaxBankAngle,
+      canArm: GarminAPUtils.navCanArm,
+      canActivate: GarminAPUtils.navCanActivate,
+      canRemainActive: GarminAPUtils.navCanRemainActive,
       lateralInterceptCurve: GarminAPUtils.navIntercept
     });
   }
@@ -380,6 +414,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   public createLocDirector(apValues: APValues): APNavDirector {
     return new APNavDirector(this.bus, apValues, APLateralModes.LOC, {
       maxBankAngle: () => apValues.maxBankId.get() === 1 ? Math.min(this.locMaxBankAngle, this.lowBankAngle) : this.locMaxBankAngle,
+      canArm: GarminAPUtils.navCanArm,
+      canActivate: GarminAPUtils.navCanActivate,
+      canRemainActive: GarminAPUtils.navCanRemainActive,
       lateralInterceptCurve: GarminAPUtils.navIntercept
     });
   }
@@ -388,6 +425,9 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   public createBcDirector(apValues: APValues): APBackCourseDirector {
     return new APBackCourseDirector(this.bus, apValues, {
       maxBankAngle: () => apValues.maxBankId.get() === 1 ? Math.min(this.locMaxBankAngle, this.lowBankAngle) : this.locMaxBankAngle,
+      canArm: GarminAPUtils.backCourseCanArm,
+      canActivate: GarminAPUtils.backCourseCanActivate,
+      canRemainActive: GarminAPUtils.backCourseCanRemainActive,
       lateralInterceptCurve: (distanceToSource: number, deflection: number, xtk: number, tas: number) => GarminAPUtils.localizerIntercept(xtk, tas)
     });
   }
@@ -440,6 +480,7 @@ export class GarminAPConfig implements GarminAPConfigInterface {
   public createGpDirector(apValues: APValues): APGPDirector {
     return new APGPDirector(this.bus, apValues, {
       guidance: this.glidepathGuidance,
+      canArm: GarminAPUtils.glidepathCanArm.bind(undefined, apValues),
       canCapture: this.glidepathGuidance
         ? () => {
           return apValues.lateralActive.get() === APLateralModes.GPSS && this.glidepathGuidance!.get().canCapture;
@@ -450,19 +491,21 @@ export class GarminAPConfig implements GarminAPConfigInterface {
 
   /** @inheritdoc */
   public createGsDirector(apValues: APValues): APGSDirector {
-    return new APGSDirector(this.bus, apValues);
+    return new APGSDirector(this.bus, apValues, {
+      canArm: GarminAPUtils.glideslopeCanArm,
+      canActivate: GarminAPUtils.glideslopeCanActivate,
+      canRemainActive: GarminAPUtils.glideslopeCanRemainActive
+    });
   }
 
   /** @inheritdoc */
-  public createToVerticalDirector(): PlaneDirector | undefined {
-    //TODO: This value should be read in from the systems.cfg 'pitch_takeoff_ga' value
-
-    return new APTogaPitchDirector(10);
+  public createToVerticalDirector(apValues: APValues): PlaneDirector | undefined {
+    return new APTogaPitchDirector(apValues, { targetPitchAngle: this.toPitchAngle });
   }
 
   /** @inheritdoc */
-  public createGaVerticalDirector(): PlaneDirector | undefined {
-    return new APTogaPitchDirector(7.5);
+  public createGaVerticalDirector(apValues: APValues): PlaneDirector | undefined {
+    return new APTogaPitchDirector(apValues, { targetPitchAngle: this.gaPitchAngle });
   }
 
   /** @inheritdoc */

src/garminsdk/autopilot/GarminAPUtils.ts

@@ -1,9 +1,214 @@
-import { MathUtils, NavMath, UnitType } from '@microsoft/msfs-sdk';
+import {
+  APBackCourseDirectorActivateNavData,
+  APBackCourseDirectorNavData,
+  APGSDirectorActivateNavData, APGSDirectorNavData, APLateralModes, APNavDirectorActivateNavData, APNavDirectorNavData,
+  APValues, APVerticalModes, MathUtils, NavMath, NavSourceType, RadioUtils, SimVarValueType, UnitType
+} from '@microsoft/msfs-sdk';
 
 /**
  * A utility class for working with Garmin autopilots.
  */
 export class GarminAPUtils {
+  /**
+   * Checks whether a nav director can be armed.
+   * @param mode The director's lateral mode.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be armed.
+   */
+  public static navCanArm(mode: APLateralModes, apValues: APValues, navData: Readonly<APNavDirectorNavData>): boolean {
+    if (apValues.cdiSource.get().type === NavSourceType.Gps) {
+      return !!apValues.navToNavArmableLateralMode && apValues.navToNavArmableLateralMode() === mode;
+    } else {
+      return navData.navSource.index !== 0 && RadioUtils.isLocalizerFrequency(navData.frequency) === (mode === APLateralModes.LOC);
+    }
+  }
+
+  /**
+   * Checks whether a nav director can be activated from an armed state.
+   * @param mode The director's lateral mode.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be activated from an armed state.
+   */
+  public static navCanActivate(mode: APLateralModes, apValues: APValues, navData: Readonly<APNavDirectorNavData>): boolean {
+    if (
+      apValues.cdiSource.get().type === NavSourceType.Nav
+      && navData.deviation !== null
+      && Math.abs(navData.deviation) < 1
+      && (navData.hasLoc || navData.obsCourse !== null)
+    ) {
+      const dtk = navData.hasLoc
+        ? navData.locCourse
+        : navData.obsCourse;
+      if (dtk === null) {
+        return false;
+      }
+      const headingDiff = NavMath.diffAngle(SimVar.GetSimVarValue('PLANE HEADING DEGREES MAGNETIC', SimVarValueType.Degree), dtk);
+      const sensitivity = navData.hasLoc ? 1 : .6;
+      if (Math.abs(navData.deviation * sensitivity) < 1 && Math.abs(headingDiff) < 110) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Checks whether a nav director can remain in the active state.
+   * @param mode The director's lateral mode.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @param isInZoneOfConfusion Whether the source of the radio navigation data is a VOR and the airplane's position
+   * is close enough to the VOR to render lateral deviation values unreliable.
+   * @param activateNavData The radio navigation data received by the director at the moment of activation.
+   * @returns Whether the director can remain in the active state.
+   */
+  public static navCanRemainActive(
+    mode: APLateralModes,
+    apValues: APValues,
+    navData: Readonly<APNavDirectorNavData>,
+    isInZoneOfConfusion: boolean,
+    activateNavData: Readonly<APNavDirectorActivateNavData>
+  ): boolean {
+    if (
+      apValues.cdiSource.get().type !== NavSourceType.Nav
+      || navData.navSource.index !== activateNavData.navSource.index
+      || navData.frequency !== activateNavData.frequency
+    ) {
+      return false;
+    }
+
+    if (mode === APLateralModes.LOC) {
+      return navData.hasLoc
+        && navData.locCourse !== null
+        && navData.deviation !== null
+        && Math.abs(navData.deviation) < 1;
+    } else {
+      return !navData.hasLoc
+        && navData.obsCourse !== null
+        && (isInZoneOfConfusion || (navData.deviation !== null && Math.abs(navData.deviation) < 1));
+    }
+  }
+
+  /**
+   * Checks whether a localizer back-course director can be armed.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be armed.
+   */
+  public static backCourseCanArm(apValues: APValues, navData: Readonly<APBackCourseDirectorNavData>): boolean {
+    return apValues.cdiSource.get().type === NavSourceType.Nav
+      && navData.navSource.index !== 0
+      && RadioUtils.isLocalizerFrequency(navData.frequency);
+  }
+
+  /**
+   * Checks whether a localizer back-course director can be activated from an armed state.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be activated from an armed state.
+   */
+  public static backCourseCanActivate(apValues: APValues, navData: Readonly<APBackCourseDirectorNavData>): boolean {
+    if (
+      apValues.cdiSource.get().type === NavSourceType.Nav
+      && navData.hasLoc
+      && navData.locCourse !== null
+      && navData.deviation !== null
+      && Math.abs(navData.deviation) < 1
+    ) {
+      const dtk = NavMath.normalizeHeading(navData.locCourse + 180);
+      const headingDiff = NavMath.diffAngle(SimVar.GetSimVarValue('PLANE HEADING DEGREES MAGNETIC', SimVarValueType.Degree), dtk);
+      if (Math.abs(headingDiff) < 110) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Checks whether a localizer back-course director can remain in the active state.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @param activateNavData The radio navigation data received by the director at the moment of activation.
+   * @returns Whether the director can remain in the active state.
+   */
+  public static backCourseCanRemainActive(
+    apValues: APValues,
+    navData: Readonly<APBackCourseDirectorNavData>,
+    activateNavData: Readonly<APBackCourseDirectorActivateNavData>
+  ): boolean {
+    return apValues.cdiSource.get().type === NavSourceType.Nav
+      && navData.navSource.index === activateNavData.navSource.index
+      && navData.frequency === activateNavData.frequency
+      && navData.hasLoc
+      && navData.locCourse !== null
+      && navData.deviation !== null
+      && Math.abs(navData.deviation) < 1;
+  }
+
+  /**
+   * Checks whether a glideslope director can be armed.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be armed.
+   */
+  public static glideslopeCanArm(apValues: APValues, navData: Readonly<APGSDirectorNavData>): boolean {
+    if (apValues.lateralActive.get() !== APLateralModes.LOC && apValues.lateralArmed.get() !== APLateralModes.LOC) {
+      return false;
+    }
+
+    if (apValues.cdiSource.get().type === NavSourceType.Gps) {
+      return !!apValues.navToNavArmableVerticalMode && apValues.navToNavArmableVerticalMode() === APVerticalModes.GS;
+    } else {
+      return navData.navSource.index !== 0 && RadioUtils.isLocalizerFrequency(navData.frequency);
+    }
+  }
+
+  /**
+   * Checks whether a glideslope director can be activated from an armed state.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @returns Whether the director can be activated from an armed state.
+   */
+  public static glideslopeCanActivate(apValues: APValues, navData: Readonly<APGSDirectorNavData>): boolean {
+    return apValues.lateralActive.get() === APLateralModes.LOC
+      && navData.gsAngleError !== null
+      && Math.abs(navData.gsAngleError) <= 0.1;
+  }
+
+  /**
+   * Checks whether a glideslope director can remain in the active state.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @param navData The current radio navigation data received by the director.
+   * @param activateNavData The radio navigation data received by the director at the moment of activation.
+   * @returns Whether the director can remain in the active state.
+   */
+  public static glideslopeCanRemainActive(
+    apValues: APValues,
+    navData: Readonly<APGSDirectorNavData>,
+    activateNavData: Readonly<APGSDirectorActivateNavData>
+  ): boolean {
+    return apValues.lateralActive.get() === APLateralModes.LOC
+      && navData.navSource.index === activateNavData.navSource.index
+      && navData.frequency === activateNavData.frequency
+      && navData.gsAngleError !== null;
+  }
+
+  /**
+   * Checks whether a glidepath director can be armed.
+   * @param apValues Autopilot values from the director's parent autopilot.
+   * @returns Whether the director can be armed.
+   */
+  public static glidepathCanArm(apValues: APValues): boolean {
+    return apValues.cdiSource.get().type === NavSourceType.Gps
+      && (
+        apValues.lateralActive.get() === APLateralModes.GPSS
+        || apValues.lateralArmed.get() === APLateralModes.GPSS
+      );
+  }
+
   /**
    * Calculates intercept angles for radio nav.
    * @param distanceToSource The distance from the plane to the source of the navigation signal, in nautical miles.