diff --git a/Aircraft/Generic/kap140.nas b/Aircraft/Generic/kap140.nas new file mode 100644 index 000000000..ea068d9e7 --- /dev/null +++ b/Aircraft/Generic/kap140.nas @@ -0,0 +1,1695 @@ +## +# Bendix/King KAP140 Autopilot System +# Tries to behave like the Bendix/King KAP140 autopilot +# two axis w/altitude preselect. +# +# One would also need the autopilot configuration file +# KAP140.xml and the panel instrument configuration file +# +# Written by Roy Vegard Ovesen +# "Power-check" edits by Dave Perry +## + +# Properties + +locks = "/autopilot/KAP140/locks"; +settings = "/autopilot/KAP140/settings"; +annunciators = "/autopilot/KAP140/annunciators"; +internal = "/autopilot/internal"; +power="/systems/electrical/outputs/autopilot"; + +# locks +propLocks = props.globals.getNode(locks, 1); + +lockAltHold = propLocks.getNode("alt-hold", 1); +lockAprHold = propLocks.getNode("apr-hold", 1); +lockGsHold = propLocks.getNode("gs-hold", 1); +lockHdgHold = propLocks.getNode("hdg-hold", 1); +lockNavHold = propLocks.getNode("nav-hold", 1); +lockRevHold = propLocks.getNode("rev-hold", 1); +lockRollAxis = propLocks.getNode("roll-axis", 1); +lockRollMode = propLocks.getNode("roll-mode", 1); +lockPitchAxis = propLocks.getNode("pitch-axis", 1); +lockPitchMode = propLocks.getNode("pitch-mode", 1); +lockRollArm = propLocks.getNode("roll-arm", 1); +lockPitchArm = propLocks.getNode("pitch-arm", 1); + + +rollModes = { "OFF" : 0, "ROL" : 1, "HDG" : 2, "NAV" : 3, "REV" : 4, "APR" : 5 }; +pitchModes = { "OFF" : 0, "VS" : 1, "ALT" : 2, "GS" : 3 }; +rollArmModes = { "OFF" : 0, "NAV" : 1, "APR" : 2, "REV" : 3 }; +pitchArmModes = { "OFF" : 0, "ALT" : 1, "GS" : 2 }; + +# settings +propSettings = props.globals.getNode(settings, 1); + +settingTargetAltPressure = propSettings.getNode("target-alt-pressure", 1); +settingTargetInterceptAngle = propSettings.getNode("target-intercept-angle", 1); +settingTargetPressureRate = propSettings.getNode("target-pressure-rate", 1); +settingTargetTurnRate = propSettings.getNode("target-turn-rate", 1); +settingTargetAltFt = propSettings.getNode("target-alt-ft", 1); +settingBaroSettingInhg = propSettings.getNode("baro-setting-inhg", 1); +settingBaroSettingHpa = propSettings.getNode("baro-setting-hpa", 1); + +#annunciators +propAnnunciators = props.globals.getNode(annunciators, 1); + +annunciatorRol = propAnnunciators.getNode("rol", 1); +annunciatorHdg = propAnnunciators.getNode("hdg", 1); +annunciatorNav = propAnnunciators.getNode("nav", 1); +annunciatorNavArm = propAnnunciators.getNode("nav-arm", 1); +annunciatorApr = propAnnunciators.getNode("apr", 1); +annunciatorAprArm = propAnnunciators.getNode("apr-arm", 1); +annunciatorRev = propAnnunciators.getNode("rev", 1); +annunciatorRevArm = propAnnunciators.getNode("rev-arm", 1); +annunciatorVs = propAnnunciators.getNode("vs", 1); +annunciatorVsNumber = propAnnunciators.getNode("vs-number", 1); +annunciatorFpm = propAnnunciators.getNode("fpm", 1); +annunciatorAlt = propAnnunciators.getNode("alt", 1); +annunciatorAltArm = propAnnunciators.getNode("alt-arm", 1); +annunciatorAltNumber = propAnnunciators.getNode("alt-number", 1); +annunciatorAltAlert = propAnnunciators.getNode("alt-alert", 1); +annunciatorApr = propAnnunciators.getNode("apr", 1); +annunciatorGs = propAnnunciators.getNode("gs", 1); +annunciatorGsArm = propAnnunciators.getNode("gs-arm", 1); +annunciatorPtUp = propAnnunciators.getNode("pt-up", 1); +annunciatorPtDn = propAnnunciators.getNode("pt-dn", 1); +annunciatorBsHpaNumber = propAnnunciators.getNode("bs-hpa-number", 1); +annunciatorBsInhgNumber = propAnnunciators.getNode("bs-inhg-number", 1); +annunciatorAp = propAnnunciators.getNode("ap", 1); +annunciatorBeep = propAnnunciators.getNode("beep", 1); + +navRadio = "/instrumentation/nav"; +encoder = "/instrumentation/encoder"; +staticPort = "/systems/static"; + +annunciator = annunciatorAp; +annunciatorState = 0; +flashInterval = 0.0; +flashCount = 0.0; +flashTimer = -1.0; + +pressureUnits = { "inHg" : 0, "hPa" : 1 }; +baroSettingUnit = pressureUnits["inHg"]; +baroSettingInhg = 29.92; +baroSettingHpa = baroSettingInhg * 0.03386389; +baroSettingAdjusting = 0; +baroButtonDown = 0; +baroTimerRunning = 0; + +altPreselect = 0; +altButtonTimerRunning = 0; +altButtonTimerIgnore = 0; +altAlertOn = 0; +altCaptured = 0; + +valueTest = 0; +lastValue = 0; +newValue = 0; +minVoltageLimit = 8.0; + +flasher = func { + flashTimer = -1.0; + annunciator = arg[0]; + flashInterval = arg[1]; + flashCount = arg[2] + 1; + annunciatorState = arg[3]; + + flashTimer = 0.0; + + flashAnnunciator(); +} + +flashAnnunciator = func { + #print(annunciator.getName()); + #print("FI:", flashInterval); + #print("FC:", flashCount); + #print("FT:", flashTimer); + + ## + # If flashTimer is set to -1 then flashing is aborted + if (flashTimer < -0.5) + { + ##print ("flash abort ", annunciator); + annunciator.setBoolValue(0); + return; + } + + if (flashTimer < flashCount) + { + #flashTimer = flashTimer + 1.0; + if (annunciator.getValue() == 1) + { + annunciator.setBoolValue(0); + settimer(flashAnnunciator, flashInterval / 2.0); + } + else + { + flashTimer = flashTimer + 1.0; + annunciator.setBoolValue(1); + settimer(flashAnnunciator, flashInterval); + } + } + else + { + flashTimer = -1.0; + annunciator.setBoolValue(annunciatorState); + } +} + + +ptCheck = func { + ##print("pitch trim check"); + + if (lockPitchMode.getValue() == pitchModes["OFF"]) + { + annunciatorPtUp.setBoolValue(0); + annunciatorPtDn.setBoolValue(0); + return; + } + + else + { + elevatorControl = getprop("/controls/flight/elevator"); + ##print(elevatorControl); + + # Flash the pitch trim up annunciator + if (elevatorControl < -0.01) + { + if (annunciatorPtUp.getValue() == 0) + { + annunciatorPtUp.setBoolValue(1); + } + elsif (annunciatorPtUp.getValue() == 1) + { + annunciatorPtUp.setBoolValue(0); + } + } + # Flash the pitch trim down annunciator + elsif (elevatorControl > 0.01) + { + if (annunciatorPtDn.getValue() == 0) + { + annunciatorPtDn.setBoolValue(1); + } + elsif (annunciatorPtDn.getValue() == 1) + { + annunciatorPtDn.setBoolValue(0); + } + } + + else + { + annunciatorPtUp.setBoolValue(0); + annunciatorPtDn.setBoolValue(0); + } + } + + settimer(ptCheck, 0.5); +} + + +apInit = func { + ##print("ap init"); + + ## + # Initialises the autopilot. + ## + + lockAltHold.setBoolValue(0); + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockRollAxis.setBoolValue(0); + lockRollMode.setIntValue(rollModes["OFF"]); + lockPitchAxis.setBoolValue(0); + lockPitchMode.setIntValue(pitchModes["OFF"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); +# Reset the memory for power down or power up + altPreselect = 0; + baroSettingInhg = 29.92; + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + settingBaroSettingHpa.setDoubleValue(baroSettingInhg * 0.03386389); + settingTargetAltFt.setDoubleValue(altPreselect); + settingTargetAltPressure.setDoubleValue(0.0); + settingTargetInterceptAngle.setDoubleValue(0.0); + settingTargetPressureRate.setDoubleValue(0.0); + settingTargetTurnRate.setDoubleValue(0.0); + + annunciatorRol.setBoolValue(0); + annunciatorHdg.setBoolValue(0); + annunciatorNav.setBoolValue(0); + annunciatorNavArm.setBoolValue(0); + annunciatorApr.setBoolValue(0); + annunciatorAprArm.setBoolValue(0); + annunciatorRev.setBoolValue(0); + annunciatorRevArm.setBoolValue(0); + annunciatorVs.setBoolValue(0); + annunciatorVsNumber.setBoolValue(0); + annunciatorFpm.setBoolValue(0); + annunciatorAlt.setBoolValue(0); + annunciatorAltArm.setBoolValue(0); + annunciatorAltNumber.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorGsArm.setBoolValue(0); + annunciatorPtUp.setBoolValue(0); + annunciatorPtDn.setBoolValue(0); + annunciatorBsHpaNumber.setBoolValue(0); + annunciatorBsInhgNumber.setBoolValue(0); + annunciatorAp.setBoolValue(0); + annunciatorBeep.setBoolValue(0); + +# settimer(altAlert, 5.0); +} + + +apPower = func { + +## Monitor autopilot power +## Call apInit if the power is too low + + if (getprop(power) < minVoltageLimit) { + newValue = 0; + } else { + newValue = 1; + } + + valueTest = newValue - lastValue; +# print("v_test = ", v_test); + if (valueTest > 0.5){ + # autopilot just powered up + print("power up"); + apInit(); + altAlert(); + } elsif (valueTest < -0.5) { + # autopilot just lost power + print("power lost"); + apInit(); + annunciatorAltAlert.setBoolValue(0); + # note: all button and knobs disabled in functions below + } + lastValue = newValue; + settimer(apPower, 0.5); +} + +apButton = func { + ##print("apButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + ## + # Engages the autopilot in Wings level mode (ROL) and Vertical speed hold + # mode (VS). + ## + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + flashTimer = -1.0; + + lockAltHold.setBoolValue(0); + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["ROL"]); + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["VS"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + annunciatorRol.setBoolValue(1); + annunciatorVs.setBoolValue(1); + annunciatorVsNumber.setBoolValue(1); + + settingTargetTurnRate.setDoubleValue(0.0); + + ptCheck(); + + pressureRate = getprop(internal, "pressure-rate"); + #print(pressureRate); + fpm = -pressureRate * 58000; + #print(fpm); + if (fpm > 0.0) + { + fpm = int(fpm/100 + 0.5) * 100; + } + else + { + fpm = int(fpm/100 - 0.5) * 100; + } + #print(fpm); + + settingTargetPressureRate.setDoubleValue(-fpm / 58000); + + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + annunciatorAltNumber.setBoolValue(0); + } + } + ## + # Disengages all modes. + ## + elsif (lockRollMode.getValue() != rollModes["OFF"] and + lockPitchMode.getValue() != pitchModes["OFF"]) + { + flashTimer = -1.0; + + lockAltHold.setBoolValue(0); + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockRollAxis.setBoolValue(0); + lockRollMode.setIntValue(rollModes["OFF"]); + lockPitchAxis.setBoolValue(0); + lockPitchMode.setIntValue(pitchModes["OFF"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + settingTargetAltPressure.setDoubleValue(0.0); + settingTargetInterceptAngle.setDoubleValue(0.0); + settingTargetPressureRate.setDoubleValue(0.0); + settingTargetTurnRate.setDoubleValue(0.0); + + annunciatorRol.setBoolValue(0); + annunciatorHdg.setBoolValue(0); + annunciatorNav.setBoolValue(0); + annunciatorNavArm.setBoolValue(0); + annunciatorApr.setBoolValue(0); + annunciatorAprArm.setBoolValue(0); + annunciatorRev.setBoolValue(0); + annunciatorRevArm.setBoolValue(0); + annunciatorVs.setBoolValue(0); + annunciatorVsNumber.setBoolValue(0); + annunciatorAlt.setBoolValue(0); + annunciatorAltArm.setBoolValue(0); + annunciatorAltNumber.setBoolValue(0); + annunciatorApr.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorGsArm.setBoolValue(0); + annunciatorPtUp.setBoolValue(0); + annunciatorPtDn.setBoolValue(0); + + flasher(annunciatorAp, 1.0, 5, 0); + } +} + + +hdgButton = func { + ##print("hdgButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + ## + # Engages the heading mode (HDG) and vertical speed hold mode (VS). The + # commanded vertical speed is set to the vertical speed present at button + # press. + ## + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + flashTimer = -1.0; + + lockAltHold.setBoolValue(0); + lockAprHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["HDG"]); + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["VS"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + annunciatorHdg.setBoolValue(1); + annunciatorAlt.setBoolValue(0); + annunciatorApr.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorNav.setBoolValue(0); + annunciatorVs.setBoolValue(1); + annunciatorVsNumber.setBoolValue(1); + + settingTargetInterceptAngle.setDoubleValue(0.0); + + ptCheck(); + + pressureRate = getprop(internal, "pressure-rate"); + fpm = -pressureRate * 58000; + #print(fpm); + if (fpm > 0.0) + { + fpm = int(fpm/100 + 0.5) * 100; + } + else + { + fpm = int(fpm/100 - 0.5) * 100; + } + #print(fpm); + + settingTargetPressureRate.setDoubleValue(-fpm / 58000); + + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + annunciatorAltNumber.setBoolValue(0); + } + } + ## + # Switch from ROL to HDG mode, but don't change pitch mode. + ## + elsif (lockRollMode.getValue() == rollModes["ROL"]) + { + lockAprHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["HDG"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + + annunciatorApr.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorHdg.setBoolValue(1); + annunciatorNav.setBoolValue(0); + annunciatorRol.setBoolValue(0); + annunciatorRev.setBoolValue(0); + + settingTargetInterceptAngle.setDoubleValue(0.0); + } + ## + # Switch to HDG mode, but don't change pitch mode. + ## + elsif ( (lockRollMode.getValue() == rollModes["NAV"] or + lockRollArm.getValue() == rollArmModes["NAV"] or + lockRollMode.getValue() == rollModes["REV"] or + lockRollArm.getValue() == rollArmModes["REV"]) and + flashTimer < -0.5) + { + lockAprHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["HDG"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + + annunciatorApr.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorHdg.setBoolValue(1); + annunciatorNav.setBoolValue(0); + annunciatorRol.setBoolValue(0); + annunciatorRev.setBoolValue(0); + annunciatorNavArm.setBoolValue(0); + + settingTargetInterceptAngle.setDoubleValue(0.0); + } + ## + # If we already are in HDG mode switch to ROL mode. Again don't touch pitch + # mode. + ## + elsif (lockRollMode.getValue() == rollModes["HDG"]) + { + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["ROL"]); + + annunciatorApr.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorHdg.setBoolValue(0); + annunciatorNav.setBoolValue(0); + annunciatorRol.setBoolValue(1); + + settingTargetTurnRate.setDoubleValue(0.0); + } + ## + # If we are in APR mode we also have to change pitch mode. + # TODO: Should we switch to VS or ALT mode? (currently VS) + ## + elsif ( (lockRollMode.getValue() == rollModes["APR"] or + lockRollArm.getValue() == rollArmModes["APR"] or + lockPitchMode.getValue() == pitchModes["GS"] or + lockPitchArm.getValue() == pitchArmModes["GS"]) and + flashTimer < -0.5) + { + lockAltHold.setBoolValue(0); + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["HDG"]); + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["VS"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + annunciatorAlt.setBoolValue(0); + annunciatorAltArm.setBoolValue(0); + annunciatorHdg.setBoolValue(1); + annunciatorRol.setBoolValue(0); + annunciatorNav.setBoolValue(0); + annunciatorApr.setBoolValue(0); + annunciatorAprArm.setBoolValue(0); + annunciatorGs.setBoolValue(0); + annunciatorGsArm.setBoolValue(0); + annunciatorVs.setBoolValue(1); + annunciatorVsNumber.setBoolValue(1); + + settingTargetInterceptAngle.setDoubleValue(0.0); + + pressureRate = getprop(internal, "pressure-rate"); + #print(pressureRate); + fpm = -pressureRate * 58000; + #print(fpm); + if (fpm > 0.0) + { + fpm = int(fpm/100 + 0.5) * 100; + } + else + { + fpm = int(fpm/100 - 0.5) * 100; + } + #print(fpm); + + settingTargetPressureRate.setDoubleValue(-fpm / 58000); + + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + annunciatorAltNumber.setBoolValue(0); + } + } +} + + +navButton = func { + ##print("navButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + ## + # If we are in HDG mode we switch to the 45 degree angle intercept NAV mode + ## + if (lockRollMode.getValue() == rollModes["HDG"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["NAV"]); + lockRollMode.setIntValue(rollModes["NAV"]); + + annunciatorNavArm.setBoolValue(1); + + navArmFromHdg(); + } + ## + # If we are in ROL mode we switch to the all angle intercept NAV mode. + ## + elsif (lockRollMode.getValue() == rollModes["ROL"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["NAV"]); + lockRollMode.setIntValue(rollModes["NAV"]); + + annunciatorNavArm.setBoolValue(1); + + navArmFromRol(); + } + ## + # TODO: + # NAV mode can only be armed if we are in HDG or ROL mode. + # Can anyone verify that this is correct? + ## +} + +navArmFromHdg = func +{ + ## + # Abort the NAV-ARM mode if something has changed the arm mode to something + # else than NAV-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["NAV"]) + { + annunciatorNavArm.setBoolValue(0); + return; + } + + #annunciatorNavArm.setBoolValue(1); + ## + # Wait for the HDG annunciator flashing to finish. + ## + if (flashTimer > -0.5) + { + #print("flashing..."); + settimer(navArmFromHdg, 2.5); + return; + } + ## + # Activate the nav-hold controller and check the needle deviation. + ## + lockNavHold.setBoolValue(1); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(navArmFromHdg, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the NAV-ARM annunciator + # and show the NAV annunciator. End of NAV-ARM sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + lockRollArm.setIntValue(rollArmModes["OFF"]); + annunciatorNavArm.setBoolValue(0); + annunciatorNav.setBoolValue(1); + } +} + +navArmFromRol = func +{ + ## + # Abort the NAV-ARM mode if something has changed the arm mode to something + # else than NAV-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["NAV"]) + { + annunciatorNavArm.setBoolValue(0); + return; + } + ## + # Wait for the HDG annunciator flashing to finish. + ## + #annunciatorNavArm.setBoolValue(1); + if (flashTimer > -0.5) + { + #print("flashing..."); + annunciatorRol.setBoolValue(0); + settimer(navArmFromRol, 2.5); + return; + } + ## + # Turn the ROL annunciator back on and activate the ROL mode. + ## + annunciatorRol.setBoolValue(1); + lockRollAxis.setBoolValue(1); + settingTargetTurnRate.setDoubleValue(0.0); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(navArmFromRol, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the NAV-ARM annunciator + # and show the NAV annunciator. End of NAV-ARM sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + annunciatorRol.setBoolValue(0); + annunciatorNavArm.setBoolValue(0); + annunciatorNav.setBoolValue(1); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(1); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["NAV"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + } +} + +aprButton = func { + ##print("aprButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + ## + # If we are in HDG mode we switch to the 45 degree intercept angle APR mode + ## + if (lockRollMode.getValue() == rollModes["HDG"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(1); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["APR"]); + lockRollMode.setIntValue(rollModes["APR"]); + + annunciatorAprArm.setBoolValue(1); + + aprArmFromHdg(); + } + elsif (lockRollMode.getValue() == rollModes["ROL"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["APR"]); + lockRollMode.setIntValue(rollModes["APR"]); + + annunciatorAprArm.setBoolValue(1); + + aprArmFromRol(); + } +} + +aprArmFromHdg = func +{ + ## + # Abort the APR-ARM mode if something has changed the arm mode to something + # else than APR-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["APR"]) + { + annunciatorAprArm.setBoolValue(0); + return; + } + + #annunciatorAprArm.setBoolValue(1); + ## + # Wait for the HDG annunciator flashing to finish. + ## + if (flashTimer > -0.5) + { + #print("flashing..."); + settimer(aprArmFromHdg, 2.5); + return; + } + ## + # Activate the apr-hold controller and check the needle deviation. + ## + lockAprHold.setBoolValue(1); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(aprArmFromHdg, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the APR-ARM annunciator + # and show the APR annunciator. End of APR-ARM sequence. Start the GS-ARM + # sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + annunciatorAprArm.setBoolValue(0); + annunciatorApr.setBoolValue(1); + lockPitchArm.setIntValue(pitchArmModes["GS"]); + + gsArm(); + } +} + +aprArmFromRol = func +{ + ## + # Abort the APR-ARM mode if something has changed the roll mode to something + # else than APR-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["APR"]) + { + annunciatorAprArm.setBoolValue(0); + return; + } + + #annunciatorAprArm.setBoolValue(1); + ## + # Wait for the HDG annunciator flashing to finish. + ## + if (flashTimer > -0.5) + { + #print("flashing..."); + annunciatorRol.setBoolValue(0); + settimer(aprArmFromRol, 2.5); + return; + } + ## + # Turn the ROL annunciator back on and activate the ROL mode. + ## + annunciatorRol.setBoolValue(1); + lockRollAxis.setBoolValue(1); + settingTargetTurnRate.setDoubleValue(0.0); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(aprArmFromRol, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the APR-ARM annunciator + # and show the APR annunciator. End of APR-ARM sequence. Start the GS-ARM + # sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + annunciatorRol.setBoolValue(0); + annunciatorAprArm.setBoolValue(0); + annunciatorApr.setBoolValue(1); + + lockAprHold.setBoolValue(1); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["APR"]); + lockPitchArm.setIntValue(pitchArmModes["GS"]); + + gsArm(); + } +} + + +gsArm = func { + ## + # Abort the GS-ARM mode if something has changed the arm mode to something + # else than GS-ARM. + ## + if (lockPitchArm.getValue() != pitchArmModes["GS"]) + { + annunciatorGsArm.setBoolValue(0); + return; + } + + annunciatorGsArm.setBoolValue(1); + + deviation = getprop(navRadio, "gs-needle-deflection"); + ## + # If the deflection is more than 1 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 1.0) + { + #print("deviation"); + settimer(gsArm, 5); + return; + } + ## + # If the deviation is less than 1 degrees turn off the GS-ARM annunciator + # and show the GS annunciator. Activate the GS pitch mode. + ## + elsif (abs(deviation) < 1.1) + { + #print("capture"); + annunciatorAlt.setBoolValue(0); + annunciatorVs.setBoolValue(0); + annunciatorVsNumber.setBoolValue(0); + annunciatorGsArm.setBoolValue(0); + annunciatorGs.setBoolValue(1); + + lockAltHold.setBoolValue(0); + lockGsHold.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["GS"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + } + +} + + +revButton = func { + ##print("revButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + ## + # If we are in HDG mode we switch to the 45 degree intercept angle REV mode + ## + if (lockRollMode.getValue() == rollModes["HDG"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["REV"]); + + annunciatorRevArm.setBoolValue(1); + + revArmFromHdg(); + } + elsif (lockRollMode.getValue() == rollModes["ROL"]) + { + flasher(annunciatorHdg, 0.5, 8, 0); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(0); + lockHdgHold.setBoolValue(0); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["REV"]); + + annunciatorRevArm.setBoolValue(1); + + revArmFromRol(); + } +} + + +revArmFromHdg = func +{ + ## + # Abort the REV-ARM mode if something has changed the arm mode to something + # else than REV-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["REV"]) + { + annunciatorRevArm.setBoolValue(0); + return; + } + + #annunciatorRevArm.setBoolValue(1); + ## + # Wait for the HDG annunciator flashing to finish. + ## + if (flashTimer > -0.5) + { + #print("flashing..."); + settimer(revArmFromHdg, 2.5); + return; + } + ## + # Activate the rev-hold controller and check the needle deviation. + ## + lockRevHold.setBoolValue(1); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(revArmFromHdg, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the REV-ARM annunciator + # and show the REV annunciator. End of REV-ARM sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + annunciatorRevArm.setBoolValue(0); + annunciatorRev.setBoolValue(1); + lockRollArm.setIntValue(rollArmModes["OFF"]); + annunciatorRol.setBoolValue(0); + annunciatorRevArm.setBoolValue(0); + annunciatorRev.setBoolValue(1); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(1); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["REV"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + } +} + + +revArmFromRol = func +{ + ## + # Abort the REV-ARM mode if something has changed the arm mode to something + # else than REV-ARM. + ## + if (lockRollArm.getValue() != rollArmModes["REV"]) + { + annunciatorRevArm.setBoolValue(0); + return; + } + + #annunciatorRevArm.setBoolValue(1); + ## + # Wait for the HDG annunciator flashing to finish. + ## + if (flashTimer > -0.5) + { + #print("flashing..."); + annunciatorRol.setBoolValue(0); + settimer(revArmFromRol, 2.5); + return; + } + ## + # Turn the ROL annunciator back on and activate the ROL mode. + ## + annunciatorRol.setBoolValue(1); + lockRollAxis.setBoolValue(1); + settingTargetTurnRate.setDoubleValue(0.0); + deviation = getprop(navRadio, "heading-needle-deflection"); + ## + # If the deflection is more than 3 degrees wait 5 seconds and check again. + ## + if (abs(deviation) > 3.0) + { + #print("deviation"); + settimer(revArmFromRol, 5); + return; + } + ## + # If the deviation is less than 3 degrees turn of the REV-ARM annunciator + # and show the REV annunciator. End of REV-ARM sequence. + ## + elsif (abs(deviation) < 3.1) + { + #print("capture"); + annunciatorRol.setBoolValue(0); + annunciatorRevArm.setBoolValue(0); + annunciatorRev.setBoolValue(1); + + lockAprHold.setBoolValue(0); + lockGsHold.setBoolValue(0); + lockRevHold.setBoolValue(1); + lockHdgHold.setBoolValue(1); + lockNavHold.setBoolValue(0); + lockRollAxis.setBoolValue(1); + lockRollMode.setIntValue(rollModes["REV"]); + lockRollArm.setIntValue(rollArmModes["OFF"]); + } +} + + +altButtonTimer = func { + #print("alt button timer"); + #print(altButtonTimerIgnore); + + if (altButtonTimerIgnore == 0) + { + annunciatorVsNumber.setBoolValue(0); + annunciatorAltNumber.setBoolValue(1); + + altButtonTimerRunning = 0; + } + elsif (altButtonTimerIgnore > 0) + { + altButtonTimerIgnore = altButtonTimerIgnore - 1; + } +} + + +altButton = func { + ##print("altButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + + if (lockPitchMode.getValue() == pitchModes["ALT"]) + { + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + } + lockAltHold.setBoolValue(0); + + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["VS"]); + + annunciatorAlt.setBoolValue(0); + annunciatorAltNumber.setBoolValue(0); + annunciatorVs.setBoolValue(1); + annunciatorVsNumber.setBoolValue(1); + + pressureRate = getprop(internal, "pressure-rate"); + fpm = -pressureRate * 58000; + #print(fpm); + if (fpm > 0.0) + { + fpm = int(fpm/100 + 0.5) * 100; + } + else + { + fpm = int(fpm/100 - 0.5) * 100; + } + #print(fpm); + + settingTargetPressureRate.setDoubleValue(-fpm / 58000); + + } + elsif (lockPitchMode.getValue() == pitchModes["VS"]) + { + lockAltHold.setBoolValue(1); + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["ALT"]); + + annunciatorAlt.setBoolValue(1); + annunciatorVs.setBoolValue(0); + annunciatorVsNumber.setBoolValue(0); + annunciatorAltNumber.setBoolValue(1); + + altPressure = getprop(staticPort, "pressure-inhg"); + altFt = (baroSettingInhg - altPressure) / 0.00103; + if (altFt > 0.0) + { + altFt = int(altFt/20 + 0.5) * 20; + } + else + { + altFt = int(altFt/20 - 0.5) * 20; + } + #print(altFt); + + altPressure = baroSettingInhg - altFt * 0.00103; + settingTargetAltPressure.setDoubleValue(altPressure); + + } +} + + +downButton = func { + ##print("downButton");# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 0) + { + if (lockPitchMode.getValue() == pitchModes["VS"]) + { + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + } + elsif (altButtonTimerRunning == 1) + { + settimer(altButtonTimer, 3.0); + altButtonTimerIgnore = altButtonTimerIgnore + 1; + } + targetVS = getprop(settings, "target-pressure-rate"); + settingTargetPressureRate.setDoubleValue(targetVS + + 0.0017241379310345); + annunciatorAltNumber.setBoolValue(0); + annunciatorVsNumber.setBoolValue(1); + } + elsif (lockPitchMode.getValue() == pitchModes["ALT"]) + { + targetPressure = getprop(settings, "target-alt-pressure"); + settingTargetAltPressure.setDoubleValue(targetPressure + 0.0206); + } + } +} + +upButton = func { + ##print("upButton"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 0) + { + if (lockPitchMode.getValue() == pitchModes["VS"]) + { + if (altButtonTimerRunning == 0) + { + settimer(altButtonTimer, 3.0); + altButtonTimerRunning = 1; + altButtonTimerIgnore = 0; + } + elsif (altButtonTimerRunning == 1) + { + settimer(altButtonTimer, 3.0); + altButtonTimerIgnore = altButtonTimerIgnore + 1; + } + targetVS = getprop(settings, "target-pressure-rate"); + settingTargetPressureRate.setDoubleValue(targetVS - + 0.0017241379310345); + annunciatorAltNumber.setBoolValue(0); + annunciatorVsNumber.setBoolValue(1); + } + elsif (lockPitchMode.getValue() == pitchModes["ALT"]) + { + targetPressure = getprop(settings, "target-alt-pressure"); + settingTargetAltPressure.setDoubleValue(targetPressure - 0.0206); + } + } +} + +armButton = func { + #print("arm button"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + pitchArm = lockPitchArm.getValue(); + + if (pitchArm == pitchArmModes["OFF"]) + { + lockPitchArm.setIntValue(pitchArmModes["ALT"]); + + annunciatorAltArm.setBoolValue(1); + } + elsif (pitchArm == pitchArmModes["ALT"]) + { + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + annunciatorAltArm.setBoolValue(0); + } +} + + +baroButtonTimer = func { + #print("baro button timer"); + + baroTimerRunning = 0; + if (baroButtonDown == 1) + { + baroSettingUnit = !baroSettingUnit; + baroButtonDown = 0; + baroButtonPress(); + } + elsif (baroButtonDown == 0 and + baroSettingAdjusting == 0) + { + annunciatorBsHpaNumber.setBoolValue(0); + annunciatorBsInhgNumber.setBoolValue(0); + annunciatorAltNumber.setBoolValue(1); + } + elsif (baroSettingAdjusting == 1) + { + baroTimerRunning = 1; + baroSettingAdjusting = 0; + settimer(baroButtonTimer, 3.0); + } +} + +baroButtonPress = func { + #print("baro putton press"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroButtonDown == 0 and + baroTimerRunning == 0 and + altButtonTimerRunning == 0) + { + baroButtonDown = 1; + baroTimerRunning = 1; + settimer(baroButtonTimer, 3.0); + annunciatorAltNumber.setBoolValue(0); + + if (baroSettingUnit == pressureUnits["inHg"]) + { + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + + annunciatorBsInhgNumber.setBoolValue(1); + annunciatorBsHpaNumber.setBoolValue(0); + } + elsif (baroSettingUnit == pressureUnits["hPa"]) + { + settingBaroSettingHpa.setDoubleValue( + baroSettingInhg * 0.03386389); + + annunciatorBsHpaNumber.setBoolValue(1); + annunciatorBsInhgNumber.setBoolValue(0); + } + } +} + + +baroButtonRelease = func { + #print("baro button release"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + baroButtonDown = 0; +} + + +pow = func { + #print(arg[0],arg[1]); + return math.exp(arg[1]*math.ln(arg[0])); +} + + +pressureToHeight = func { + p0 = arg[1]; # [Pa] + p = arg[0]; # [Pa] + t0 = 288.15; # [K] + LR = -0.0065; # [K/m] + g = -9.80665; # [m/s²] + Rd = 287.05307; # [J/kg K] + + z = -(t0/LR) * (1.0-pow((p/p0),((Rd*LR)/g))); + return z; +} + + +heightToPressure = func { + p0 = arg[1]; # [Pa] + z = arg[0]; # [m] + t0 = 288.15; # [K] + LR = -0.0065; # [K/m] + g = -9.80665; # [m/s²] + Rd = 287.05307; # [J/kg K] + + p = p0 * pow(((t0+LR*z)/t0),(g/(Rd*LR))); + return p; +} + +hPartial = func { + p0 = arg[1]; # Units of p0 must match units of delta p + p = arg[0]; # Units of p must match units of delta p + t0 = 288.15; # [K] + LR = -0.0065; # [K/m] + g = -9.80665; # [m/s²] + Rd = 287.05307; # [J/kg K] + gamma = (Rd*LR)/g; + + z = -(t0/LR)*gamma*pow((p/p0),gamma)/p0; + return z; +} + +altAlert = func { + #print("alt alert"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + pressureAltitude = getprop(encoder, "pressure-alt-ft"); + altPressure = getprop(staticPort, "pressure-inhg"); + hPartStat = hPartial(altPressure, 29.92) / 0.3048006; + altFt = pressureAltitude + hPartStat * (baroSettingInhg - 29.92); + altDifference = abs(altPreselect - altFt); + #print(altDifference); + + if (altDifference > 1000) + { + annunciatorAltAlert.setBoolValue(0); + } + elsif (altDifference < 1000 and + altCaptured == 0) + { + if (flashTimer < -0.5) { + annunciatorAltAlert.setBoolValue(1); } + if (altDifference < 200) + { + if (flashTimer < -0.5) { + annunciatorAltAlert.setBoolValue(0); } + if (altDifference < 20) + { + #print("altCapture()"); + altCaptured = 1; + + if (lockPitchArm.getValue() == pitchArmModes["ALT"]) + { + lockAltHold.setBoolValue(1); + lockPitchAxis.setBoolValue(1); + lockPitchMode.setIntValue(pitchModes["ALT"]); + lockPitchArm.setIntValue(pitchArmModes["OFF"]); + + annunciatorAlt.setBoolValue(1); + annunciatorAltArm.setBoolValue(0); + annunciatorVs.setBoolValue(0); + annunciatorVsNumber.setBoolValue(0); + annunciatorAltNumber.setBoolValue(1); + + #altPressure = baroSettingInhg - altPreselect * 0.00103; + #altPressure = heightToPressure(altPreselect*0.3048006, + # baroSettingInhg*3386.389)/3386.389; + altPressure = getprop(staticPort, "pressure-inhg"); + settingTargetAltPressure.setDoubleValue(altPressure); + } + + flasher(annunciatorAltAlert, 1.0, 0, 0); + } + } + } + elsif (altDifference < 1000 and + altCaptured == 1) + { + if (altDifference > 200) + { + flasher(annunciatorAltAlert, 1.0, 5, 1); + altCaptured = 0; + } + } + settimer(altAlert, 2.0); +} + + +knobSmallUp = func { + #print("knob small up"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 1) + { + baroSettingAdjusting = 1; + if (baroSettingUnit == pressureUnits["inHg"]) + { + baroSettingInhg = baroSettingInhg + 0.01; + baroSettingHpa = baroSettingInhg * 0.03386389; + + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + } + elsif (baroSettingUnit == pressureUnits["hPa"]) + { + baroSettingHpa = baroSettingInhg * 0.03386389; + baroSettingHpa = baroSettingHpa + 0.001; + baroSettingInhg = baroSettingHpa / 0.03386389; + + settingBaroSettingHpa.setDoubleValue(baroSettingHpa); + } + } + elsif (baroTimerRunning == 0 and + altButtonTimerRunning == 0) + { + altCaptured = 0; + altPreselect = altPreselect + 20; + settingTargetAltFt.setDoubleValue(altPreselect); + + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + annunciatorAltNumber.setBoolValue(1); + if (altAlertOn == 0) + { + altAlertOn = 1; + } + } + elsif (lockPitchArm.getValue() == pitchArmModes["OFF"]) + { + lockPitchArm.setIntValue(pitchArmModes["ALT"]); + annunciatorAltArm.setBoolValue(1); + } + } +} + + +knobLargeUp = func { + #print("knob large up"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 1) + { + baroSettingAdjusting = 1; + if (baroSettingUnit == pressureUnits["inHg"]) + { + baroSettingInhg = baroSettingInhg + 1.0; + baroSettingHpa = baroSettingInhg * 0.03386389; + + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + } + elsif (baroSettingUnit == pressureUnits["hPa"]) + { + baroSettingHpa = baroSettingInhg * 0.03386389; + baroSettingHpa = baroSettingHpa + 0.1; + baroSettingInhg = baroSettingHpa / 0.03386389; + + settingBaroSettingHpa.setDoubleValue(baroSettingHpa); + } + } + elsif (baroTimerRunning == 0 and + altButtonTimerRunning == 0) + { + altCaptured = 0; + altPreselect = altPreselect + 100; + settingTargetAltFt.setDoubleValue(altPreselect); + + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + annunciatorAltNumber.setBoolValue(1); + if (altAlertOn == 0) + { + altAlertOn = 1; + } + } + elsif (lockPitchArm.getValue() == pitchArmModes["OFF"]) + { + lockPitchArm.setIntValue(pitchArmModes["ALT"]); + annunciatorAltArm.setBoolValue(1); + } + } +} + + +knobSmallDown = func { + #print("knob small down"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 1) + { + baroSettingAdjusting = 1; + if (baroSettingUnit == pressureUnits["inHg"]) + { + baroSettingInhg = baroSettingInhg - 0.01; + baroSettingHpa = baroSettingInhg * 0.03386389; + + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + } + elsif (baroSettingUnit == pressureUnits["hPa"]) + { + baroSettingHpa = baroSettingInhg * 0.03386389; + baroSettingHpa = baroSettingHpa - 0.001; + baroSettingInhg = baroSettingHpa / 0.03386389; + + settingBaroSettingHpa.setDoubleValue(baroSettingHpa); + } + } + elsif (baroTimerRunning == 0 and + altButtonTimerRunning == 0) + { + altCaptured = 0; + altPreselect = altPreselect - 20; + settingTargetAltFt.setDoubleValue(altPreselect); + + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + annunciatorAltNumber.setBoolValue(1); + if (altAlertOn == 0) + { + altAlertOn = 1; + } + } + elsif (lockPitchArm.getValue() == pitchArmModes["OFF"]) + { + lockPitchArm.setIntValue(pitchArmModes["ALT"]); + annunciatorAltArm.setBoolValue(1); + } + } +} + + +knobLargeDown = func { + #print("knob large down"); +# Disable button if too little power + if (getprop(power) < minVoltageLimit) { return; } + + if (baroTimerRunning == 1) + { + baroSettingAdjusting = 1; + if (baroSettingUnit == pressureUnits["inHg"]) + { + baroSettingInhg = baroSettingInhg - 1.0; + baroSettingHpa = baroSettingInhg * 0.03386389; + + settingBaroSettingInhg.setDoubleValue(baroSettingInhg); + } + elsif (baroSettingUnit == pressureUnits["hPa"]) + { + baroSettingHpa = baroSettingInhg * 0.03386389; + baroSettingHpa = baroSettingHpa - 0.1; + baroSettingInhg = baroSettingHpa / 0.03386389; + + settingBaroSettingHpa.setDoubleValue(baroSettingHpa); + } + } + elsif (baroTimerRunning == 0 and + altButtonTimerRunning == 0) + { + altCaptured = 0; + altPreselect = altPreselect - 100; + settingTargetAltFt.setDoubleValue(altPreselect); + + if (lockRollMode.getValue() == rollModes["OFF"] and + lockPitchMode.getValue() == pitchModes["OFF"]) + { + annunciatorAltNumber.setBoolValue(1); + if (altAlertOn == 0) + { + altAlertOn = 1; + } + } + elsif (lockPitchArm.getValue() == pitchArmModes["OFF"]) + { + lockPitchArm.setIntValue(pitchArmModes["ALT"]); + annunciatorAltArm.setBoolValue(1); + } + } +} + +var L = setlistener(power, func { + apPower(); + removelistener(L); +}); + + diff --git a/Aircraft/Generic/limits.nas b/Aircraft/Generic/limits.nas index 78a472063..7cb872680 100644 --- a/Aircraft/Generic/limits.nas +++ b/Aircraft/Generic/limits.nas @@ -14,7 +14,7 @@ # limits/max-positive-g # limits/max-negative-g (must be defined in max-positive-g defined) # -# You can defined multiple max-flap-extension-speed entries, for max extension +# You can define multiple max-flap-extension-speed entries for max extension # speeds for different flap settings. checkFlaps = func { diff --git a/Aircraft/Instruments/KAP140TwoAxis.xml b/Aircraft/Instruments/KAP140TwoAxis.xml index ca85a0ef8..a5889d836 100644 --- a/Aircraft/Instruments/KAP140TwoAxis.xml +++ b/Aircraft/Instruments/KAP140TwoAxis.xml @@ -51,7 +51,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/ap</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -80,7 +80,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rol</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -109,7 +109,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/hdg</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -138,7 +138,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/nav</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -167,7 +167,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/nav-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -196,7 +196,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/apr</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -225,7 +225,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/apr-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -254,7 +254,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rev</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -283,7 +283,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rev-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -312,7 +312,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/vs</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -341,7 +341,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/fpm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -370,7 +370,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/vs-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <type>text</type> @@ -406,7 +406,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -435,7 +435,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/gs</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -464,7 +464,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/gs-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -504,7 +504,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.ap_button(); + kap140.apButton(); </script> </binding> </action> @@ -519,7 +519,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.hdg_button(); + kap140.hdgButton(); </script> </binding> </action> @@ -534,7 +534,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.nav_button(); + kap140.navButton(); </script> </binding> </action> @@ -549,7 +549,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.apr_button(); + kap140.aprButton(); </script> </binding> </action> @@ -564,7 +564,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.alt_button(); + kap140.altButton(); </script> </binding> </action> @@ -579,7 +579,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.rev_button(); + kap140.revButton(); </script> </binding> </action> @@ -594,7 +594,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.dn_button(); + kap140.downButton(); </script> </binding> </action> @@ -609,11 +609,11 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.up_button(); + kap140.upButton(); </script> </binding> </action> </actions> -</PropertyList> \ No newline at end of file +</PropertyList> diff --git a/Aircraft/Instruments/KAP140TwoAxisAlt.xml b/Aircraft/Instruments/KAP140TwoAxisAlt.xml index f77468842..195408c2b 100644 --- a/Aircraft/Instruments/KAP140TwoAxisAlt.xml +++ b/Aircraft/Instruments/KAP140TwoAxisAlt.xml @@ -1,10 +1,9 @@ <?xml version="1.0"?> - <!-- _______________________________________________________________________________ KAP140 Two Axis with Altitude Preselect autopilot instrument. -Started 2004 by Roy Vegard Ovesen, rvovesen@tiscali.no. +Started 2004 by Roy Vegard Ovesen. This is an instrument configuration file for the open-source flight simulator FlightGear (www.flightgear.org). The file is an XML-encoded @@ -23,7 +22,6 @@ click. Actions always modify the values of properties, either by adjusting them, toggling them, or swaping them with other properties' values. --> - <PropertyList> <name>KAP140TwoAxisAlt</name> <w-base>512</w-base> @@ -51,7 +49,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/ap</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -80,7 +78,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rol</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -109,7 +107,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/hdg</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -138,7 +136,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/nav</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -167,7 +165,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/nav-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -196,7 +194,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/apr</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -225,7 +223,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/apr-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -254,7 +252,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rev</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -283,7 +281,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/rev-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -312,7 +310,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/vs</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -341,7 +339,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/vs-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -370,7 +368,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/vs-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <type>text</type> @@ -406,7 +404,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -435,7 +433,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -464,7 +462,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <type>text</type> @@ -500,7 +498,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -529,7 +527,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/alt-alert</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -558,7 +556,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/gs</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -587,7 +585,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/gs-arm</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -617,7 +615,7 @@ properties' values. <and> <equals> <property>/autopilot/KAP140/annunciators/pt-up</property> - <value>on</value> + <value type="bool">true</value> </equals> </and> </condition> @@ -648,7 +646,7 @@ properties' values. <and> <equals> <property>/autopilot/KAP140/annunciators/pt-dn</property> - <value>on</value> + <value type="bool">true</value> </equals> </and> </condition> @@ -678,7 +676,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/bs-inhg-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <type>text</type> @@ -714,7 +712,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/bs-inhg-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -743,7 +741,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/bs-hpa-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <type>text</type> @@ -779,7 +777,7 @@ properties' values. <condition> <equals> <property>/autopilot/KAP140/annunciators/bs-hpa-number</property> - <value>on</value> + <value type="bool">true</value> </equals> </condition> <texture> @@ -819,7 +817,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.ap_button(); + kap140.apButton(); </script> </binding> </action> @@ -834,7 +832,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.hdg_button(); + kap140.hdgButton(); </script> </binding> </action> @@ -849,7 +847,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.nav_button(); + kap140.navButton(); </script> </binding> </action> @@ -864,7 +862,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.apr_button(); + kap140.aprButton(); </script> </binding> </action> @@ -879,7 +877,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.alt_button(); + kap140.altButton(); </script> </binding> </action> @@ -894,7 +892,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.rev_button(); + kap140.revButton(); </script> </binding> </action> @@ -909,7 +907,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.dn_button(); + kap140.downButton(); </script> </binding> </action> @@ -924,7 +922,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.up_button(); + kap140.upButton(); </script> </binding> </action> @@ -939,7 +937,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.arm_button(); + kap140.armButton(); </script> </binding> </action> @@ -955,14 +953,14 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.baro_button_press(); + kap140.baroButtonPress(); </script> </binding> <mod-up> <binding> <command>nasal</command> <script> - kap140.baro_button_release(); + kap140.baroButtonRelease(); </script> </binding> </mod-up> @@ -978,7 +976,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.knob_s_up(); + kap140.knobSmallUp(); </script> </binding> </action> @@ -993,7 +991,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.knob_l_up(); + kap140.knobLargeUp(); </script> </binding> </action> @@ -1008,7 +1006,7 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.knob_s_dn(); + kap140.knobSmallDown(); </script> </binding> </action> @@ -1023,11 +1021,11 @@ properties' values. <binding> <command>nasal</command> <script> - kap140.knob_l_dn(); + kap140.knobLargeDown(); </script> </binding> </action> </actions> -</PropertyList> +</PropertyList> \ No newline at end of file diff --git a/Aircraft/Instruments/fuel-c172s.xml b/Aircraft/Instruments/fuel-c172s.xml index b8770be70..5d22790b5 100644 --- a/Aircraft/Instruments/fuel-c172s.xml +++ b/Aircraft/Instruments/fuel-c172s.xml @@ -207,4 +207,4 @@ Feb 7 2003 </layers> -</PropertyList> \ No newline at end of file +</PropertyList> diff --git a/Aircraft/c172p/Systems/KAP140.xml b/Aircraft/c172p/Systems/KAP140.xml index 7e9611f91..8e545329c 100644 --- a/Aircraft/c172p/Systems/KAP140.xml +++ b/Aircraft/c172p/Systems/KAP140.xml @@ -1,12 +1,8 @@ <?xml version="1.0"?> - <!-- KAP 140 Autopilot Configuration --> - <!-- Each component is evaluated in the order specified. You can make up --> <!-- property names to pass the result of one component on to a subsequent --> <!-- component. --> - - <PropertyList> <!-- =============================================================== --> @@ -20,7 +16,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/nav-hold</prop> - <value>nav</value> + <value type="bool">true</value> </enable> <input> <prop>/instrumentation/nav/heading-needle-deflection</prop> @@ -50,7 +46,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/apr-hold</prop> - <value>apr</value> + <value type="bool">true</value> </enable> <input> <prop>/instrumentation/nav/heading-needle-deflection</prop> @@ -80,7 +76,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/rev-hold</prop> - <value>rev</value> + <value type="bool">true</value> </enable> <input> <prop>/instrumentation/nav/heading-needle-deflection</prop> @@ -112,10 +108,10 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/hdg-hold</prop> - <value>hdg</value> + <value type="bool">true</value> </enable> <input> - <prop>/autopilot/internal/heading-bug-error-deg</prop> --> + <prop>/autopilot/internal/heading-bug-error-deg</prop> --> <!-- <prop>/instrumentation/gps/true-bug-error-deg</prop> --> </input> <reference> @@ -144,7 +140,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/roll-axis</prop> - <value>trn</value> + <value type="bool">true</value> </enable> <input> <prop>/instrumentation/turn-indicator/indicated-turn-rate</prop> @@ -178,7 +174,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/alt-hold</prop> - <value>alt</value> + <value type="bool">true</value> </enable> <input> <prop>/systems/static[0]/pressure-inhg[0]</prop> @@ -208,7 +204,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/gs-hold</prop> - <value>gs</value> + <value type="bool">true</value> </enable> <input> <prop>/instrumentation/nav/gs-needle-deflection</prop> @@ -247,7 +243,7 @@ <debug>false</debug> <enable> <prop>/autopilot/KAP140/locks/pitch-axis</prop> - <value>vs</value> + <value type="bool">true</value> </enable> <input> <prop>/autopilot/internal/filtered-pressure-rate</prop> diff --git a/Aircraft/c172p/c172p-set.xml b/Aircraft/c172p/c172p-set.xml index 328bff87f..33a29534f 100644 --- a/Aircraft/c172p/c172p-set.xml +++ b/Aircraft/c172p/c172p-set.xml @@ -118,6 +118,9 @@ Started October 23 2001 by John Check, fgpanels@rockfish.net <tumble-flag archive="y" type="bool">true</tumble-flag> </config> </attitude-indicator> + <encoder> + <serviceable type="bool">true</serviceable> + </encoder> </instrumentation> <engines> @@ -131,7 +134,7 @@ Started October 23 2001 by John Check, fgpanels@rockfish.net <file>Aircraft/c172/c172-electrical.nas</file> </electrical> <kap140> - <file>Aircraft/c172p/kap140.nas</file> + <file>Aircraft/Generic/kap140.nas</file> </kap140> </nasal> diff --git a/Aircraft/c172p/kap140.nas b/Aircraft/c172p/kap140.nas deleted file mode 100644 index 89cf894a3..000000000 --- a/Aircraft/c172p/kap140.nas +++ /dev/null @@ -1,1520 +0,0 @@ -## -# Bendix/King KAP140 Autopilot System -## - -Locks = "/autopilot/KAP140/locks"; -Settings = "/autopilot/KAP140/settings"; -Annunciators = "/autopilot/KAP140/annunciators"; -Internal = "/autopilot/internal"; - -annunciator = ""; -annunciator_state = ""; -flash_interval = 0.0; -flash_count = 0.0; -flash_timer = -1.0; - -# baro setting unit: 0=inHg, 1=hPa -baro_setting_unit = 0; -baro_setting = 29.92; -baro_setting_hpa = 1.013; -baro_setting_adjusting = 0; -baro_button_down = 0; -baro_timer_running = 0; - -alt_preselect = 0; -alt_button_timer_running = 0; -alt_button_timer_ignore = 0; -alt_alert_on = 0; -alt_captured = 0; - -old_alt_number_state = ["off", 0]; -old_vs_number_state = ["off", 0]; - - -flasher = func { - flash_timer = -1.0; - annunciator = arg[0]; - flash_interval = arg[1]; - flash_count = arg[2] + 1; - annunciator_state = arg[3]; - - flash_timer = 0.0; - - flash_annunciator(); -} - -flash_annunciator = func { - ##print(annunciator); - ##print(flash_interval); - ##print(flash_count); - - ## - # If flash_timer is set to -1 then flashing is aborted - if (flash_timer < -0.5) - { - ##print ("flash abort ", annunciator); - setprop(Annunciators, annunciator, "off"); - return; - } - - if (flash_timer < flash_count) - { - #flash_timer = flash_timer + 1.0; - if (getprop(Annunciators, annunciator) == "on") - { - setprop(Annunciators, annunciator, "off"); - settimer(flash_annunciator, flash_interval / 2.0); - } - else - #elsif (getprop(Annunciators, annunciator) == "off") - { - flash_timer = flash_timer + 1.0; - setprop(Annunciators, annunciator, "on"); - settimer(flash_annunciator, flash_interval); - } - } - else - { - flash_timer = -1.0; - setprop(Annunciators, annunciator, annunciator_state); - } -} - - -pt_check = func { - ##print("pitch trim check"); - - if (getprop(Locks, "pitch-mode") == "off") - { - setprop(Annunciators, "pt-up", "off"); - setprop(Annunciators, "pt-dn", "off"); - return; - } - - else - { - elevator_control = getprop("/controls/flight/elevator"); - ##print(elevator_control); - - # Flash the pitch trim up annunciator - if (elevator_control < -0.01) - { - if (getprop(Annunciators, "pt-up") == "off") - { - setprop(Annunciators, "pt-up", "on"); - } - elsif (getprop(Annunciators, "pt-up") == "on") - { - setprop(Annunciators, "pt-up", "off"); - } - } - # Flash the pitch trim down annunciator - elsif (elevator_control > 0.01) - { - if (getprop(Annunciators, "pt-dn") == "off") - { - setprop(Annunciators, "pt-dn", "on"); - } - elsif (getprop(Annunciators, "pt-dn") == "on") - { - setprop(Annunciators, "pt-dn", "off"); - } - } - - else - { - setprop(Annunciators, "pt-up", "off"); - setprop(Annunciators, "pt-dn", "off"); - } - } - - settimer(pt_check, 0.5); -} - - -ap_init = func { - ##print("ap init"); - - ## - # Initialises the autopilot. - ## - - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "roll-axis", "off"); - setprop(Locks, "roll-mode", "off"); - setprop(Locks, "pitch-axis", "off"); - setprop(Locks, "pitch-mode", "off"); - setprop(Locks, "roll-arm", "off"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Settings, "target-alt-pressure", 0.0); - setprop(Settings, "target-intercept-angle", 0.0); - setprop(Settings, "target-pressure-rate", 0.0); - setprop(Settings, "target-turn-rate", 0.0); - - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "hdg", "off"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "nav-arm", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "apr-arm", "off"); - setprop(Annunciators, "rev", "off"); - setprop(Annunciators, "rev-arm", "off"); - setprop(Annunciators, "vs", "off"); - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "fpm", "off"); - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "alt-arm", "off"); - setprop(Annunciators, "alt-number", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "gs-arm", "off"); - setprop(Annunciators, "pt-up", "off"); - setprop(Annunciators, "pt-dn", "off"); - setprop(Annunciators, "bs-hpa-number", "off"); - setprop(Annunciators, "bs-inhg-number", "off"); - setprop(Annunciators, "ap", "off"); - -} - - -ap_button = func { - ##print("ap_button"); - - ## - # Engages the autopilot in Wings level mode (ROL) and Vertical speed hold - # mode (VS). - ## - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - flash_timer = -1.0; - - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "rol"); - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "vs"); - setprop(Locks, "roll-arm", "off"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Annunciators, "rol", "on"); - setprop(Annunciators, "vs", "on"); - setprop(Annunciators, "vs-number", "on"); - - setprop(Settings, "target-turn-rate", 0.0); - - pt_check(); - - pressure_rate = getprop(Internal, "pressure-rate"); - #print(pressure_rate); - fpm = -pressure_rate * 58000; - #print(fpm); - if (fpm > 0.0) - { - fpm = int(fpm/100 + 0.5) * 100; - } - else - { - fpm = int(fpm/100 - 0.5) * 100; - } - #print(fpm); - - setprop(Settings, "target-pressure-rate", -fpm / 58000); - - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - setprop(Annunciators, "alt-number", "off"); - } - } - ## - # Disengages all modes. - ## - elsif (getprop(Locks, "roll-mode") != "off" and - getprop(Locks, "pitch-mode") != "off") - { - flash_timer = -1.0; - - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "roll-axis", "off"); - setprop(Locks, "roll-mode", "off"); - setprop(Locks, "pitch-axis", "off"); - setprop(Locks, "pitch-mode", "off"); - setprop(Locks, "roll-arm", "off"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Settings, "target-alt-pressure", 0.0); - setprop(Settings, "target-intercept-angle", 0.0); - setprop(Settings, "target-pressure-rate", 0.0); - setprop(Settings, "target-turn-rate", 0.0); - - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "hdg", "off"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "nav-arm", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "apr-arm", "off"); - setprop(Annunciators, "rev", "off"); - setprop(Annunciators, "rev-arm", "off"); - setprop(Annunciators, "vs", "off"); - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "alt-arm", "off"); - setprop(Annunciators, "alt-number", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "gs-arm", "off"); - setprop(Annunciators, "pt-up", "off"); - setprop(Annunciators, "pt-dn", "off"); - - flasher("ap", 1.0, 5, "off"); - } -} - - -hdg_button = func { - ##print("hdg_button"); - - ## - # Engages the heading mode (HDG) and vertical speed hold mode (VS). The - # commanded vertical speed is set to the vertical speed present at button - # press. - ## - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - flash_timer = -1.0; - - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "hdg"); - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "vs"); - setprop(Locks, "roll-arm", "off"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Annunciators, "hdg", "on"); - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "vs", "on"); - setprop(Annunciators, "vs-number", "on"); - - setprop(Settings, "target-intercept-angle", 0.0); - - pt_check(); - - pressure_rate = getprop(Internal, "pressure-rate"); - fpm = -pressure_rate * 58000; - #print(fpm); - if (fpm > 0.0) - { - fpm = int(fpm/100 + 0.5) * 100; - } - else - { - fpm = int(fpm/100 - 0.5) * 100; - } - #print(fpm); - - setprop(Settings, "target-pressure-rate", -fpm / 58000); - - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - setprop(Annunciators, "alt-number", "off"); - } - } - ## - # Switch from ROL to HDG mode, but don't change pitch mode. - ## - elsif (getprop(Locks, "roll-mode") == "rol") - { - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "hdg"); - setprop(Locks, "roll-arm", "off"); - - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "hdg", "on"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "rev", "off"); - - setprop(Settings, "target-intercept-angle", 0.0); - } - ## - # Switch to HDG mode, but don't change pitch mode. - ## - elsif ( (getprop(Locks, "roll-mode") == "nav" or - getprop(Locks, "roll-arm") == "nav-arm" or - getprop(Locks, "roll-mode") == "rev" or - getprop(Locks, "roll-arm") == "rev-arm") and - flash_timer < -0.5) - { - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "hdg"); - setprop(Locks, "roll-arm", "off"); - - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "hdg", "on"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "rev", "off"); - setprop(Annunciators, "nav-arm", "off"); - - setprop(Settings, "target-intercept-angle", 0.0); - } - ## - # If we already are in HDG mode switch to ROL mode. Again don't touch pitch - # mode. - ## - elsif (getprop(Locks, "roll-mode") == "hdg") - { - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "rol"); - - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "hdg", "off"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "rol", "on"); - - setprop(Settings, "target-turn-rate", 0.0); - } - ## - # If we are in APR mode we also have to change pitch mode. - # TODO: Should we switch to VS or ALT mode? (currently VS) - ## - elsif ( (getprop(Locks, "roll-mode") == "apr" or - getprop(Locks, "roll-arm") == "apr-arm" or - getprop(Locks, "pitch-mode") == "gs" or - getprop(Locks, "pitch-arm") == "gs-arm") and - flash_timer < -0.5) - { - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "hdg"); - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "vs"); - setprop(Locks, "roll-arm", "off"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "alt-arm", "off"); - setprop(Annunciators, "hdg", "on"); - setprop(Annunciators, "nav", "off"); - setprop(Annunciators, "apr", "off"); - setprop(Annunciators, "apr-arm", "off"); - setprop(Annunciators, "gs", "off"); - setprop(Annunciators, "gs-arm", "off"); - setprop(Annunciators, "vs", "on"); - setprop(Annunciators, "vs-number", "on"); - - setprop(Settings, "target-intercept-angle", 0.0); - - pressure_rate = getprop(Internal, "pressure-rate"); - #print(pressure_rate); - fpm = -pressure_rate * 58000; - #print(fpm); - if (fpm > 0.0) - { - fpm = int(fpm/100 + 0.5) * 100; - } - else - { - fpm = int(fpm/100 - 0.5) * 100; - } - #print(fpm); - - setprop(Settings, "target-pressure-rate", -fpm / 58000); - - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - setprop(Annunciators, "alt-number", "off"); - } - } -} - - -nav_button = func { - ##print("nav_button"); - - ## - # If we are in HDG mode we switch to the 45 degree angle intercept NAV mode - ## - if (getprop(Locks, "roll-mode") == "hdg") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "nav-arm"); - setprop(Locks, "roll-mode", "nav"); - - setprop(Annunciators, "nav-arm", "on"); - - nav_arm_from_hdg(); - } - ## - # If we are in ROL mode we switch to the all angle intercept NAV mode. - ## - elsif (getprop(Locks, "roll-mode") == "rol") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "nav-arm"); - setprop(Locks, "roll-mode", "nav"); - - setprop(Annunciators, "nav-arm", "on"); - - nav_arm_from_rol(); - } - ## - # TODO: - # NAV mode can only be armed if we are in HDG or ROL mode. - # Can anyone verify that this is correct? - ## -} - -nav_arm_from_hdg = func -{ - ## - # Abort the NAV-ARM mode if something has changed the arm mode to something - # else than NAV-ARM. - ## - if (getprop(Locks, "roll-arm") != "nav-arm") - { - setprop(Annunciators, "nav-arm", "off"); - return; - } - - #setprop(Annunciators, "nav-arm", "on"); - ## - # Wait for the HDG annunciator flashing to finish. - ## - if (flash_timer > -0.5) - { - #print("flashing..."); - settimer(nav_arm_from_hdg, 2.5); - return; - } - ## - # Activate the nav-hold controller and check the needle deviation. - ## - setprop(Locks, "nav-hold", "nav"); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(nav_arm_from_hdg, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the NAV-ARM annunciator - # and show the NAV annunciator. End of NAV-ARM sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Locks, "roll-arm", "off"); - setprop(Annunciators, "nav-arm", "off"); - setprop(Annunciators, "nav", "on"); - } -} - -nav_arm_from_rol = func -{ - ## - # Abort the NAV-ARM mode if something has changed the arm mode to something - # else than NAV-ARM. - ## - if (getprop(Locks, "roll-arm") != "nav-arm") - { - setprop(Annunciators, "nav-arm", "off"); - return; - } - ## - # Wait for the HDG annunciator flashing to finish. - ## - #setprop(Annunciators, "nav-arm", "on"); - if (flash_timer > -0.5) - { - #print("flashing..."); - setprop(Annunciators, "rol", "off"); - settimer(nav_arm_from_rol, 2.5); - return; - } - ## - # Turn the ROL annunciator back on and activate the ROL mode. - ## - setprop(Annunciators, "rol", "on"); - setprop(Locks, "roll-axis", "trn"); - setprop(Settings, "target-turn-rate", 0.0); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(nav_arm_from_rol, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the NAV-ARM annunciator - # and show the NAV annunciator. End of NAV-ARM sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "nav-arm", "off"); - setprop(Annunciators, "nav", "on"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "nav"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "nav"); - setprop(Locks, "roll-arm", "off"); - } -} - -apr_button = func { - ##print("apr_button"); - ## - # If we are in HDG mode we switch to the 45 degree intercept angle APR mode - ## - if (getprop(Locks, "roll-mode") == "hdg") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "apr"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "apr-arm"); - setprop(Locks, "roll-mode", "apr"); - - setprop(Annunciators, "apr-arm", "on"); - - apr_arm_from_hdg(); - } - elsif (getprop(Locks, "roll-mode") == "rol") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "apr-arm"); - setprop(Locks, "roll-mode", "apr"); - - setprop(Annunciators, "apr-arm", "on"); - - apr_arm_from_rol(); - } -} - -apr_arm_from_hdg = func -{ - ## - # Abort the APR-ARM mode if something has changed the arm mode to something - # else than APR-ARM. - ## - if (getprop(Locks, "roll-arm") != "apr-arm") - { - setprop(Annunciators, "apr-arm", "off"); - return; - } - - #setprop(Annunciators, "apr-arm", "on"); - ## - # Wait for the HDG annunciator flashing to finish. - ## - if (flash_timer > -0.5) - { - #print("flashing..."); - settimer(apr_arm_from_hdg, 2.5); - return; - } - ## - # Activate the apr-hold controller and check the needle deviation. - ## - setprop(Locks, "apr-hold", "apr"); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(apr_arm_from_hdg, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the APR-ARM annunciator - # and show the APR annunciator. End of APR-ARM sequence. Start the GS-ARM - # sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "apr-arm", "off"); - setprop(Annunciators, "apr", "on"); - setprop(Locks, "pitch-arm", "gs-arm"); - - gs_arm(); - } -} - -apr_arm_from_rol = func -{ - ## - # Abort the APR-ARM mode if something has changed the roll mode to something - # else than APR-ARM. - ## - if (getprop(Locks, "roll-arm") != "apr-arm") - { - setprop(Annunciators, "apr-arm", "off"); - return; - } - - #setprop(Annunciators, "apr-arm", "on"); - ## - # Wait for the HDG annunciator flashing to finish. - ## - if (flash_timer > -0.5) - { - #print("flashing..."); - setprop(Annunciators, "rol", "off"); - settimer(apr_arm_from_rol, 2.5); - return; - } - ## - # Turn the ROL annunciator back on and activate the ROL mode. - ## - setprop(Annunciators, "rol", "on"); - setprop(Locks, "roll-axis", "trn"); - setprop(Settings, "target-turn-rate", 0.0); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(apr_arm_from_rol, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the APR-ARM annunciator - # and show the APR annunciator. End of APR-ARM sequence. Start the GS-ARM - # sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "apr-arm", "off"); - setprop(Annunciators, "apr", "on"); - - setprop(Locks, "apr-hold", "apr"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "apr"); - setprop(Locks, "roll-arm", "gs-arm"); - - gs_arm(); - } -} - - -gs_arm = func { - ## - # Abort the GS-ARM mode if something has changed the arm mode to something - # else than GS-ARM. - ## - if (getprop(Locks, "pitch-arm") != "gs-arm") - { - setprop(Annunciators, "gs-arm", "off"); - return; - } - - setprop(Annunciators, "gs-arm", "on"); - - deviation = getprop("/instrumentation/nav/gs-needle-deflection"); - ## - # If the deflection is more than 1 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 1.0) - { - #print("deviation"); - settimer(gs_arm, 5); - return; - } - ## - # If the deviation is less than 1 degrees turn off the GS-ARM annunciator - # and show the GS annunciator. Activate the GS pitch mode. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "vs", "off"); - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "gs-arm", "off"); - setprop(Annunciators, "gs", "on"); - - setprop(Locks, "alt-hold", "off"); - setprop(Locks, "gs-hold", "gs"); - setprop(Locks, "pitch-mode", "gs"); - setprop(Locks, "pitch-arm", "off"); - } - -} - - -rev_button = func { - ##print("rev_button"); - ## - # If we are in HDG mode we switch to the 45 degree intercept angle REV mode - ## - if (getprop(Locks, "roll-mode") == "hdg") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "rev-arm"); - - rev_arm_from_hdg(); - } - elsif (getprop(Locks, "roll-mode") == "rol") - { - flasher("hdg", 0.5, 8, "off"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "off"); - setprop(Locks, "hdg-hold", "off"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-arm", "rev-arm"); - - rev_arm_from_rol(); - } -} - - -rev_arm_from_hdg = func -{ - ## - # Abort the REV-ARM mode if something has changed the arm mode to something - # else than REV-ARM. - ## - if (getprop(Locks, "roll-arm") != "rev-arm") - { - setprop(Annunciators, "rev-arm", "off"); - return; - } - - #setprop(Annunciators, "rev-arm", "on"); - ## - # Wait for the HDG annunciator flashing to finish. - ## - if (flash_timer > -0.5) - { - #print("flashing..."); - settimer(rev_arm_from_hdg, 2.5); - return; - } - ## - # Activate the rev-hold controller and check the needle deviation. - ## - setprop(Locks, "rev-hold", "rev"); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(rev_arm_from_hdg, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the REV-ARM annunciator - # and show the REV annunciator. End of REV-ARM sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "rev-arm", "off"); - setprop(Annunciators, "rev", "on"); - setprop(Locks, "roll-arm", "off"); - } -} - - -rev_arm_from_rol = func -{ - ## - # Abort the REV-ARM mode if something has changed the arm mode to something - # else than REV-ARM. - ## - if (getprop(Locks, "roll-arm") != "rev-arm") - { - setprop(Annunciators, "rev-arm", "off"); - return; - } - - #setprop(Annunciators, "rev-arm", "on"); - ## - # Wait for the HDG annunciator flashing to finish. - ## - if (flash_timer > -0.5) - { - #print("flashing..."); - setprop(Annunciators, "rol", "off"); - settimer(rev_arm_from_rol, 2.5); - return; - } - ## - # Turn the ROL annunciator back on and activate the ROL mode. - ## - setprop(Annunciators, "rol", "on"); - setprop(Locks, "roll-axis", "trn"); - setprop(Settings, "target-turn-rate", 0.0); - deviation = getprop("/instrumentation/nav/heading-needle-deflection"); - ## - # If the deflection is more than 3 degrees wait 5 seconds and check again. - ## - if (abs(deviation) > 3.0) - { - #print("deviation"); - settimer(rev_arm_from_rol, 5); - return; - } - ## - # If the deviation is less than 3 degrees turn of the REV-ARM annunciator - # and show the REV annunciator. End of REV-ARM sequence. - ## - elsif (abs(deviation) < 3.1) - { - #print("capture"); - setprop(Annunciators, "rol", "off"); - setprop(Annunciators, "rev-arm", "off"); - setprop(Annunciators, "rev", "on"); - - setprop(Locks, "apr-hold", "off"); - setprop(Locks, "gs-hold", "off"); - setprop(Locks, "rev-hold", "rev"); - setprop(Locks, "hdg-hold", "hdg"); - setprop(Locks, "nav-hold", "off"); - setprop(Locks, "roll-axis", "trn"); - setprop(Locks, "roll-mode", "rev"); - setprop(Locks, "roll-arm", "off"); - } -} - - -alt_button_timer = func { - #print("alt button timer"); - #print(alt_button_timer_ignore); - - if (alt_button_timer_ignore == 0) - { - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "alt-number", "on"); - - alt_button_timer_running = 0; - } - elsif (alt_button_timer_ignore > 0) - { - alt_button_timer_ignore = alt_button_timer_ignore - 1; - } -} - - -alt_button = func { - ##print("alt_button"); - - if (getprop(Locks, "pitch-mode") == "alt") - { - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - } - setprop(Locks, "alt-hold", "off"); - - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "vs"); - - setprop(Annunciators, "alt", "off"); - setprop(Annunciators, "alt-number", "off"); - setprop(Annunciators, "vs", "on"); - setprop(Annunciators, "vs-number", "on"); - - pressure_rate = getprop(Internal, "pressure-rate"); - fpm = -pressure_rate * 58000; - #print(fpm); - if (fpm > 0.0) - { - fpm = int(fpm/100 + 0.5) * 100; - } - else - { - fpm = int(fpm/100 - 0.5) * 100; - } - #print(fpm); - - setprop(Settings, "target-pressure-rate", -fpm / 58000); - - } - elsif (getprop(Locks, "pitch-mode") == "vs") - { - setprop(Locks, "alt-hold", "alt"); - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "alt"); - - setprop(Annunciators, "alt", "on"); - setprop(Annunciators, "vs", "off"); - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "alt-number", "on"); - - alt_pressure = getprop("/systems/static/pressure-inhg"); - alt_ft = (baro_setting - alt_pressure) / 0.00103; - if (alt_ft > 0.0) - { - alt_ft = int(alt_ft/20 + 0.5) * 20; - } - else - { - alt_ft = int(alt_ft/20 - 0.5) * 20; - } - #print(alt_ft); - - alt_pressure = baro_setting - alt_ft * 0.00103; - setprop(Settings, "target-alt-pressure", alt_pressure); - - } -} - - -dn_button = func { - ##print("dn_button"); - - if (baro_timer_running == 0) - { - if (getprop(Locks, "pitch-mode") == "vs") - { - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - } - elsif (alt_button_timer_running == 1) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_ignore = alt_button_timer_ignore + 1; - } - Target_VS = getprop(Settings, "target-pressure-rate"); - setprop(Settings, "target-pressure-rate", Target_VS + - 0.0017241379310345); - setprop(Annunciators, "alt-number", "off"); - setprop(Annunciators, "vs-number", "on"); - } - elsif (getprop(Locks, "pitch-mode") == "alt") - { - Target_Pressure = getprop(Settings, "target-alt-pressure"); - setprop(Settings, "target-alt-pressure", Target_Pressure + 0.0206); - } - } -} - -up_button = func { - ##print("up_button"); - - if (baro_timer_running == 0) - { - if (getprop(Locks, "pitch-mode") == "vs") - { - if (alt_button_timer_running == 0) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_running = 1; - alt_button_timer_ignore = 0; - } - elsif (alt_button_timer_running == 1) - { - settimer(alt_button_timer, 3.0); - alt_button_timer_ignore = alt_button_timer_ignore + 1; - } - Target_VS = getprop(Settings, "target-pressure-rate"); - setprop(Settings, "target-pressure-rate", Target_VS - - 0.0017241379310345); - setprop(Annunciators, "alt-number", "off"); - setprop(Annunciators, "vs-number", "on"); - } - elsif (getprop(Locks, "pitch-mode") == "alt") - { - Target_Pressure = getprop(Settings, "target-alt-pressure"); - setprop(Settings, "target-alt-pressure", Target_Pressure - 0.0206); - } - } -} - -arm_button = func { - #print("arm button"); - - pitch_arm = getprop(Locks, "pitch-arm"); - - if (pitch_arm == "off") - { - setprop(Locks, "pitch-arm", "alt-arm"); - - setprop(Annunciators, "alt-arm", "on"); - } - elsif (pitch_arm == "alt-arm") - { - setprop(Locks, "pitch-arm", "off"); - - setprop(Annunciators, "alt-arm", "off"); - } -} - - -baro_button_timer = func { - #print("baro button timer"); - - baro_timer_running = 0; - if (baro_button_down == 1) - { - baro_setting_unit = !baro_setting_unit; - baro_button_down = 0; - baro_button_press(); - } - elsif (baro_button_down == 0 and - baro_setting_adjusting == 0) - { - setprop(Annunciators, "bs-hpa-number", "off"); - setprop(Annunciators, "bs-inhg-number", "off"); - setprop(Annunciators, "alt-number", "on"); - } - elsif (baro_setting_adjusting == 1) - { - baro_timer_running = 1; - baro_setting_adjusting = 0; - settimer(baro_button_timer, 3.0); - } -} - -baro_button_press = func { - #print("baro putton press"); - - if (baro_button_down == 0 and - baro_timer_running == 0 and - alt_button_timer_running == 0) - { - baro_button_down = 1; - baro_timer_running = 1; - settimer(baro_button_timer, 3.0); - setprop(Annunciators, "alt-number", "off"); - - if (baro_setting_unit == 0) - { - setprop(Settings, "baro-setting-inhg", baro_setting); - - setprop(Annunciators, "bs-inhg-number", "on"); - setprop(Annunciators, "bs-hpa-number", "off"); - } - elsif (baro_setting_unit == 1) - { - setprop(Settings, "baro-setting-hpa", - baro_setting * 0.03386389); - - setprop(Annunciators, "bs-hpa-number", "on"); - setprop(Annunciators, "bs-inhg-number", "off"); - } - } -} - - -baro_button_release = func { - #print("baro button release"); - - baro_button_down = 0; -} - - -pow = func { - #print(arg[0],arg[1]); - return math.exp(arg[1]*math.ln(arg[0])); -} - - -pressureToHeight = func { - p0 = arg[1]; # [Pa] - p = arg[0]; # [Pa] - t0 = 288.15; # [K] - LR = -0.0065; # [K/m] - g = -9.80665; # [m/s²] - Rd = 287.05307; # [J/kg K] - - z = -(t0/LR) * (1.0-pow((p/p0),((Rd*LR)/g))); - return z; -} - - -heightToPressure = func { - p0 = arg[1]; # [Pa] - z = arg[0]; # [m] - t0 = 288.15; # [K] - LR = -0.0065; # [K/m] - g = -9.80665; # [m/s²] - Rd = 287.05307; # [J/kg K] - - p = p0 * pow(((t0+LR*z)/t0),(g/(Rd*LR))); - return p; -} - - -alt_alert = func { - #print("alt alert"); - - alt_pressure = getprop("/systems/static/pressure-inhg"); - alt_m = pressureToHeight(alt_pressure*3386.389, - baro_setting*3386.389); - #print(alt_m); - - alt_ft = alt_m / 0.3048006; - #print(alt_ft); - alt_difference = abs(alt_preselect - alt_ft); - #print(alt_difference); - - if (alt_difference > 1000) - { - setprop(Annunciators, "alt-alert", "off"); - } - elsif (alt_difference < 1000 and - alt_captured == 0) - { - if (flash_timer < -0.5) { - setprop(Annunciators, "alt-alert", "on"); } - if (alt_difference < 200) - { - if (flash_timer < -0.5) { - setprop(Annunciators, "alt-alert", "off"); } - if (alt_difference < 20) - { - #print("alt_capture()"); - alt_captured = 1; - - if (getprop(Locks, "pitch-arm") == "alt-arm") - { - setprop(Locks, "alt-hold", "alt"); - setprop(Locks, "pitch-axis", "vs"); - setprop(Locks, "pitch-mode", "alt"); - setprop(Locks, "pitch-arm", "off"); - - setprop(Annunciators, "alt", "on"); - setprop(Annunciators, "alt-arm", "off"); - setprop(Annunciators, "vs", "off"); - setprop(Annunciators, "vs-number", "off"); - setprop(Annunciators, "alt-number", "on"); - - #alt_pressure = baro_setting - alt_preselect * 0.00103; - alt_pressure = heightToPressure(alt_preselect*0.3048006, - baro_setting*3386.389)/3386.389; - setprop(Settings, "target-alt-pressure", alt_pressure); - } - - flasher("alt-alert", 1.0, 0, "off"); - } - } - } - elsif (alt_difference < 1000 and - alt_captured == 1) - { - if (alt_difference > 200) - { - flasher("alt-alert", 1.0, 5, "on"); - alt_captured = 0; - } - } - settimer(alt_alert, 2.0); -} - - -knob_s_up = func { - #print("knob small up"); - - if (baro_timer_running == 1) - { - baro_setting_adjusting = 1; - if (baro_setting_unit == 0) - { - baro_setting = baro_setting + 0.01; - baro_setting_hpa = baro_setting * 0.03386389; - - setprop(Settings, "baro-setting-inhg", baro_setting); - } - elsif (baro_setting_unit == 1) - { - baro_setting_hpa = baro_setting * 0.03386389; - baro_setting_hpa = baro_setting_hpa + 0.001; - baro_setting = baro_setting_hpa / 0.03386389; - - setprop(Settings, "baro-setting-hpa", baro_setting_hpa); - } - } - elsif (baro_timer_running == 0 and - alt_button_timer_running == 0) - { - alt_captured = 0; - alt_preselect = alt_preselect + 20; - setprop(Settings, "target-alt-ft", alt_preselect); - - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - setprop(Annunciators, "alt-number", "on"); - if (alt_alert_on == 0) - { - alt_alert_on = 1; - } - } - elsif (getprop(Locks, "pitch-arm") == "off") - { - setprop(Locks, "pitch-arm", "alt-arm"); - setprop(Annunciators, "alt-arm", "on"); - } - } -} - - -knob_l_up = func { - #print("knob large up"); - - if (baro_timer_running == 1) - { - baro_setting_adjusting = 1; - if (baro_setting_unit == 0) - { - baro_setting = baro_setting + 1.0; - baro_setting_hpa = baro_setting * 0.03386389; - - setprop(Settings, "baro-setting-inhg", baro_setting); - } - elsif (baro_setting_unit == 1) - { - baro_setting_hpa = baro_setting * 0.03386389; - baro_setting_hpa = baro_setting_hpa + 0.1; - baro_setting = baro_setting_hpa / 0.03386389; - - setprop(Settings, "baro-setting-hpa", baro_setting_hpa); - } - } - elsif (baro_timer_running == 0 and - alt_button_timer_running == 0) - { - alt_captured = 0; - alt_preselect = alt_preselect + 100; - setprop(Settings, "target-alt-ft", alt_preselect); - - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - setprop(Annunciators, "alt-number", "on"); - if (alt_alert_on == 0) - { - alt_alert_on = 1; - } - } - elsif (getprop(Locks, "pitch-arm") == "off") - { - setprop(Locks, "pitch-arm", "alt-arm"); - setprop(Annunciators, "alt-arm", "on"); - } - } -} - - -knob_s_dn = func { - #print("knob small down"); - - if (baro_timer_running == 1) - { - baro_setting_adjusting = 1; - if (baro_setting_unit == 0) - { - baro_setting = baro_setting - 0.01; - baro_setting_hpa = baro_setting * 0.03386389; - - setprop(Settings, "baro-setting-inhg", baro_setting); - } - elsif (baro_setting_unit == 1) - { - baro_setting_hpa = baro_setting * 0.03386389; - baro_setting_hpa = baro_setting_hpa - 0.001; - baro_setting = baro_setting_hpa / 0.03386389; - - setprop(Settings, "baro-setting-hpa", baro_setting_hpa); - } - } - elsif (baro_timer_running == 0 and - alt_button_timer_running == 0) - { - alt_captured = 0; - alt_preselect = alt_preselect - 20; - setprop(Settings, "target-alt-ft", alt_preselect); - - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - setprop(Annunciators, "alt-number", "on"); - if (alt_alert_on == 0) - { - alt_alert_on = 1; - } - } - elsif (getprop(Locks, "pitch-arm") == "off") - { - setprop(Locks, "pitch-arm", "alt-arm"); - setprop(Annunciators, "alt-arm", "on"); - } - } -} - - -knob_l_dn = func { - #print("knob large down"); - - if (baro_timer_running == 1) - { - baro_setting_adjusting = 1; - if (baro_setting_unit == 0) - { - baro_setting = baro_setting - 1.0; - baro_setting_hpa = baro_setting * 0.03386389; - - setprop(Settings, "baro-setting-inhg", baro_setting); - } - elsif (baro_setting_unit == 1) - { - baro_setting_hpa = baro_setting * 0.03386389; - baro_setting_hpa = baro_setting_hpa - 0.1; - baro_setting = baro_setting_hpa / 0.03386389; - - setprop(Settings, "baro-setting-hpa", baro_setting_hpa); - } - } - elsif (baro_timer_running == 0 and - alt_button_timer_running == 0) - { - alt_captured = 0; - alt_preselect = alt_preselect - 100; - setprop(Settings, "target-alt-ft", alt_preselect); - - if (getprop(Locks, "roll-mode") == "off" and - getprop(Locks, "pitch-mode") == "off") - { - setprop(Annunciators, "alt-number", "on"); - if (alt_alert_on == 0) - { - alt_alert_on = 1; - } - } - elsif (getprop(Locks, "pitch-arm") == "off") - { - setprop(Locks, "pitch-arm", "alt-arm"); - setprop(Annunciators, "alt-arm", "on"); - } - } -} - - -ap_init(); - -alt_alert();