//************************************************************************* // A340 EPL code for FS2004, USB Version // // copyright P. Dickenmann, 2006 // // Thanks to March Teichtahl, who showed me how to do a timer using the // EPL code. This timer is used to control the speed of the rotary encoders. // Turning them fast, the increments are bigger, turning them slow, the // increments are by 1 //************************************************************************* // TODO //------ // // //========================================================================= // Module definitions //========================================================================= //#include #include #include "modules.hpl" #include "devices_1.hpl" #include "devices_2.hpl" #include "A340.hpl" #include "A340.inc" //========================================================================= // Procedure blocks //========================================================================= //------------------------------------------------------------------------- // Initialization //------------------------------------------------------------------------- void INIT (void) { // configure rotary module senddata(7, 0, 0b01010101); // Rotary set as type one (two phase) (SPD, HDG, ALT, VS) senddata(7, 1, 0b01010101); // Rotary set as type one (two phase) (Baro Pilot/Copilot, Stdby COM Pilot hundreds and decimals) senddata(7, 2, 0b01010101); // Rotary set as type one (two phase) (Stdby COM Pilot hundreds and decimals, XPDR) // senddata(7, 3, 0b01010101); // not used yet // senddata(7, 4, 0b01010101); // not used yet jump(MainLoop); // once finished, jump to the main timing loop } //------------------------------------------------------------------------- // Main Timing Loop //------------------------------------------------------------------------- void MainLoop (void) { call(CheckSpeedTimers); // check to see if switch timers have expired and if so , handle them byt_Tick++; if (byt_Tick > 49) { byt_Tick = 0; } delay(1); // wait 20msec jump(MainLoop); // restart the main Loop } //=============================================================================== // Rotary encoders //=============================================================================== //------------------------------------------------------------------------- // Check timing state for multiple switches // This routine is called every 20msec. // It checks to see if the hold down timers on a per switch basis have expired // If they have, then call the routine to set the values. This means the user // has stopped turning the switch. If the knob is still turning (ND_TIME is value) // then we simply reduce the timer and keep going. //------------------------------------------------------------------------- void CheckSpeedTimers (void) { if (f_SpdTiming) // is speed/MACH knob turning { byt_SpdTime--; // decrement byt_SpdTime by 1 if (!byt_SpdTime) // if byt_SpdTime = 0 { f_SpdTiming = false; wrd_Temp = rvar_SPD; enque16(nqw_Cmd_SPD, wrd_Temp,FSMAPPER); // 0x37 -> entry required in EPICFSUIPC config.ini } } if (f_MACHTiming) // is speed/MACH knob turning { byt_MACHTime--; // decrement byt_MACHTime by 1 if (!byt_MACHTime) // if byt_MACHTime = 0 { f_MACHTiming = false; wrd_MACH = rvar_MACH; enque16(nqw_Cmd_MACH, wrd_MACH,FSMAPPER); // 0x47 -> entry required in EPICFSUIPC config.ini } } if (f_HdgTiming) { byt_HdgTime--; if (!byt_HdgTime) { f_HdgTiming = false; wrd_Temp = rvar_HDG; enque16(nqw_Cmd_HDG, wrd_Temp,FSMAPPER); // 0x36 -> entry required in EpicMapper config.ini } } if (f_AltTiming) { byt_AltTime--; if (!byt_AltTime) { f_AltTiming = false; enque16(nqw_Cmd_ALT, rvar_ALT,FSMAPPER); // 0x35 -> entry required in EpicMapper config.ini } } if (f_VSTiming) { byt_VSTime--; if (!byt_VSTime) { f_VSTiming = false; enque16(nqw_Cmd_VS, wrd_VS,FSMAPPER); // 0x38 -> entry required in EpicMapper config.ini } } if (f_FPATiming) { byt_FPATime--; if (!byt_FPATime) { f_FPATiming = false; enque16(nqw_Cmd_VS, wrd_FPA,FSMAPPER); } } if (f_BaroTiming_P) { byt_BaroTime_P--; if (!byt_BaroTime_P) { f_BaroTiming_P = false; enque16(nqw_Cmd_BARO_P, wrd_Baro_P, FSMAPPER); // 0x41 -> entry required in EpicMapper config.ini } } if (f_BaroTiming_CP) { byt_BaroTime_CP--; if (!byt_BaroTime_CP) { f_BaroTiming_CP = false; enque16(nqw_Cmd_BARO_CP, wrd_Baro_CP, FSMAPPER); // 0x42 -> entry required in EpicMapper config.ini } } } //------------------------------------------------------------------------- // Set Vertical Speed //------------------------------------------------------------------------- void Rotaries.r_cnt_VS.On (void) { jump(l_handle_VS_rot); } void Rotaries.r_cnt_VS.Off (void) { jump(l_handle_VS_rot); } void l_handle_VS_rot (void) { if (f_FPA_Mode_On) { if (Rotaries.r_dir_VS) { wrd_FPA -= FPA_DELTA; } else { wrd_FPA += FPA_DELTA; } byt_FPATime = FPA_TIMER; f_FPATiming = true; } else { if (Rotaries.r_dir_VS) { wrd_VS -= VS_DELTA; } else { wrd_VS += VS_DELTA; } byt_VSTime = VS_TIMER; f_VSTiming = true; } jump(l_VS_Disp); // VS display is handled within a procedure } //------------------------------------------------------------------------- // Set Speed. //------------------------------------------------------------------------- void Rotaries.r_cnt_SPD.On (void) { jump(l_handle_SPD_rot); } void Rotaries.r_cnt_SPD.Off (void) { jump(l_handle_SPD_rot); } void l_handle_SPD_rot (void) { if (f_SPD_Active) // speed is to be handled by the SPD rotary { if (Rotaries.r_dir_SPD) { if (f_SpdTiming) { rvar_SPD -= SPD_FAST_DELTA; } else { rvar_SPD -= SPD_SLOW_DELTA; } } else { if (f_SpdTiming) { rvar_SPD += SPD_FAST_DELTA; } else { rvar_SPD += SPD_SLOW_DELTA; } } byt_SpdTime = SPD_TIMER; f_SpdTiming = true; } else // MACH is to be handled by the SPD rotary { if (Rotaries.r_dir_SPD) // rotary is the same for setting the speed { rvar_MACH -= 1; } else { rvar_MACH += 1; } byt_MACHTime = MACH_TIMER; f_MACHTiming = true; } jump(l_SPD_MACH_Disp); } //------------------------------------------------------------------------- // Set Heading //------------------------------------------------------------------------- void Rotaries.r_cnt_HDG.On (void) { jump(l_handle_HDG_rot); } void Rotaries.r_cnt_HDG.Off (void) { jump(l_handle_HDG_rot); } void l_handle_HDG_rot (void) { if (Rotaries.r_dir_HDG) { if (f_HdgTiming) { rvar_HDG -= HDG_FAST_DELTA; } else { rvar_HDG -= HDG_SLOW_DELTA; } } else { if (f_HdgTiming) { rvar_HDG += HDG_FAST_DELTA; } else { rvar_HDG += HDG_SLOW_DELTA; } } byt_HdgTime = HDG_TIMER; f_HdgTiming = true; jump(l_HDG_Disp); } //------------------------------------------------------------------------- // Set Altitude //------------------------------------------------------------------------- void Rotaries.r_cnt_ALT.On (void) { jump(l_handle_ALT_rot); } void Rotaries.r_cnt_ALT.Off (void) { jump(l_handle_ALT_rot); } void l_handle_ALT_rot (void) { if (Rotaries.r_dir_ALT) { // If the 100/1000 switch is on, then increment ALT by 10 if(Joystick_02.b_range_ALT) { rvar_ALT -= ALT_FAST_DELTA; } else { rvar_ALT -= ALT_SLOW_DELTA; } } else { // If the 100/1000 switch is on, then decrement ALT by 10 if(Joystick_02.b_range_ALT) { rvar_ALT += ALT_FAST_DELTA; } else { rvar_ALT += ALT_SLOW_DELTA; } } byt_AltTime = ALT_TIMER; f_AltTiming = true; jump(l_ALT_Disp); } //------------------------------------------------------------------------- // Set Baro Pilot side //------------------------------------------------------------------------- void Rotaries.r_cnt_Baro_P.On (void) { jump(l_handle_Baro_P_rot); } void Rotaries.r_cnt_Baro_P.Off (void) { jump(l_handle_Baro_P_rot); } void l_handle_Baro_P_rot (void) { if (Rotaries.r_dir_Baro_P) { wrd_Baro_P -= BARO_DELTA; } else { wrd_Baro_P += BARO_DELTA; } byt_BaroTime_P = BARO_TIMER_P; f_BaroTiming_P = true; } //------------------------------------------------------------------------- // Set Baro CoPilot side //------------------------------------------------------------------------- void Rotaries.r_cnt_Baro_CP.On (void) { jump(l_handle_Baro_CP_rot); } void Rotaries.r_cnt_Baro_CP.Off (void) { jump(l_handle_Baro_CP_rot); } void l_handle_Baro_CP_rot (void) { if (Rotaries.r_dir_Baro_CP) { wrd_Baro_CP -= BARO_DELTA; } else { wrd_Baro_CP += BARO_DELTA; } byt_BaroTime_CP = BARO_TIMER_CP; f_BaroTiming_CP = true; } //---------- COM Pilot side, decimals -------------------------------------- // if the NAV backup switch is pressed, then the NAV backup function of // the RMP is enabled, that means, frequency or course of VOR, ADF, ILS // etc. are to be set instead of COM frequency via the encoders. // The ADF has frequencies from 0200.0 up to 1699.0. To still be able // to work with two variables (hundreds and decimals), the ADF frequency // is handled as xxx.xx instead of xxxx.x. The right format for the // display is achieved by setting the decimal point accordingly. // Selection if frequency or radial is to be selected is done in the // l_RMP_XFER_P routine. // When setting the course, only the hundreds knob of the dual concentric // Rotaries encoder is used. //-------------------------------------------------------------------------- void Rotaries.r_cnt_VHF1_d.On (void) { jump(l_rot_handle_VHF1_d); } void Rotaries.r_cnt_VHF1_d.Off (void) { jump(l_rot_handle_VHF1_d); } void l_rot_handle_VHF1_d (void) { if(Joystick_09.b_RMP_OnOff_P) // if RMP On/Off button is On { if(Joystick_09.b_RMP_NAV_P) // if pilot side RMO in NAV backup mode mode { jump(l_RMP_NAV_Set_d_P); } else // if pilot side RMP in VHF mode { jump(l_RMP_VHF_Set_d_P); } } } //---------- Tune frequency or course when in NAV bakup mode --------------- void l_RMP_NAV_Set_d_P (void) { if(f_RMP_VOR_P) // VOR is to be tuned { if(f_RMP_Freq_P) // frequency is to be set { if(Rotaries.r_dir_VHF1_d) { rvar_VOR1freq_d++; // increment by 1 } else { rvar_VOR1freq_d--; // decrement by 1 } Display.disp_VHF1stby_d = rvar_VOR1freq_d; } } if(f_RMP_ILS_P) // ILS is to be tuned { if(f_RMP_Freq_P) // frequency is to be set { if(Rotaries.r_dir_VHF1_d) { rvar_ILS1freq_d++; // increment by 1 } else { rvar_ILS1freq_d--; // decrement by 1 } Display.disp_VHF1stby_d = rvar_ILS1freq_d; } } // if(f_RMP_MLS_P) { // } if(f_RMP_ADF_P) { if(Rotaries.r_dir_VHF1_d) // is ADF frequency to be tuned? { rvar_ADF1stby_d++; // increment ADF 'decimal' value by 1 } else { rvar_ADF1stby_d--; // decrement ADF 'decimal' value by 1 } Display.disp_ADF1stby_d = rvar_ADF1stby_d; } // if(f_RMP_BFO_P) { // } } //---------- VHF frequencies tuning ----------------------------------------- void l_RMP_VHF_Set_d_P (void) { if(f_RMP_VHF1_P) // if VHF1 is to be tuned { if(Rotaries.r_dir_VHF1_d) { rvar_VHF1stby_d++; // increment by 1 } else { rvar_VHF1stby_d--; // decrement by 1 } Display.disp_VHF1stby_d = rvar_VHF1stby_d; } } //---------- COM Pilot side, hundreds --------------------------------------- // When setting the course, only the hundreds knob of the dual concentric // Rotaries encoder is used. // ILS and VOR are the same for FS2002, but dealed with individually here. // VOR, ADF, ILS frequency variables are set here and sent to FS by // the XFER button. // The course is sent directly to FS from here. //--------------------------------------------------------------------------- void Rotaries.r_cnt_VHF1_h.On (void) { jump(l_rot_handle_VHF1_h); } void Rotaries.r_cnt_VHF1_h.Off (void) { jump(l_rot_handle_VHF1_h); } void l_rot_handle_VHF1_h (void) { if(Joystick_09.b_RMP_OnOff_P) // if RMP On/Off button is On { if(Joystick_09.b_RMP_NAV_P) // if NAV backup mode enabled { jump(l_RMP_NAV_Set_h_P); } else // set VHF1 frequency { jump(l_RMP_VHF_Set_h_P); } } } //---------- NAV frequencies and course tuning when in NAV backup mode ----- void l_RMP_NAV_Set_h_P (void) { if(f_RMP_VOR_P) // if VOR is to be tuned, , set VOR1 frequency { if(f_RMP_Freq_P) // frequency is to be set { if(Rotaries.r_dir_VHF1_h) { rvar_VOR1freq_h++; // increment by 1 } else { rvar_VOR1freq_h--; // decrement by 1 } Display.disp_VHF1stby_h = rvar_VOR1freq_h; } else // course is to be set { if(Rotaries.r_dir_VHF1_h) { rvar_VOR1crs++; // increment by 1 } else { rvar_VOR1crs--; // decrement by 1 } wrd_Temp = rvar_VOR1crs; enque16(nqw_Cmd_VOR1crs, wrd_Temp,FSMAPPER); // send value to FS Display.disp_VOR1crs = rvar_VOR1crs; } } if(f_RMP_ILS_P) // ILS is to be tuned { if(f_RMP_Freq_P) // frequency is to be set { if(Rotaries.r_dir_VHF1_h) { rvar_ILS1freq_h++; // increment by 1 } else { rvar_ILS1freq_h--; // decrement by 1 } Display.disp_VHF1stby_h = rvar_ILS1freq_h; } else // course is to be set { if(Rotaries.r_dir_VHF1_h) { rvar_ILS1crs++; // increment by 1 } else { rvar_ILS1crs--; // decrement by 1 } wrd_Temp = rvar_ILS1crs; enque16(nqw_Cmd_ILS1crs, wrd_Temp, FSMAPPER); // send value to FS Display.disp_VOR1crs = rvar_ILS1crs; } } // if(f_RMP_MLS_P) { // } if(f_RMP_ADF_P) // set ADF frequency { if(Rotaries.r_dir_VHF1_h) { rvar_ADF1stby_h++; // increment by 1 } else { rvar_ADF1stby_h--; // decrement by 1 } Display.disp_ADF1stby_h = rvar_ADF1stby_h; } // if(f_RMP_BFO_P) { // } } //---------- VHF1 frequency set ------------------------------------------- void l_RMP_VHF_Set_h_P (void) { if(f_RMP_VHF1_P) // if VHF1 is to be tuned from pilot RMP { if(Rotaries.r_dir_VHF1_h) { rvar_VHF1stby_h++; // increment by 1 } else { rvar_VHF1stby_h--; // decrement by 1 } Display.disp_VHF1stby_h = rvar_VHF1stby_h; } } //---------- COM CoPilot side, decimals ----------------------------------- void Rotaries.r_cnt_VHF2_d.On (void) { jump(l_rot_handle_VHF2_d); } void Rotaries.r_cnt_VHF2_d.Off (void) { jump(l_rot_handle_VHF2_d); } void l_rot_handle_VHF2_d (void) { if (Rotaries.r_dir_VHF2_d) { rvar_VHF2stby_d++; // increment by 1 } else { rvar_VHF2stby_d--; // decrement by 1 } Display.disp_VHF2stby_d = rvar_VHF2stby_d; } //---------- COM CoPilot side, hundreds ----------------------------------- void Rotaries.r_cnt_VHF2_h.On (void) { jump(l_rot_handle_VHF2_h); } void Rotaries.r_cnt_VHF2_h.Off (void) { jump(l_rot_handle_VHF2_h); } void l_rot_handle_VHF2_h (void) { if (Rotaries.r_dir_VHF2_h) { rvar_VHF2stby_h++; // increment by 1 } else { rvar_VHF2stby_h--; // decrement by 1 } Display.disp_VHF2stby_h = rvar_VHF2stby_h; } //------------------------------------------------------------------------- // Set Transponder // The handling of the XPDR doesn't correspond exactly to the real one in // my sim. Turning the large knob of the dual concentric encoder to the // right counts the hundres up by 1, turning it to the left counts the // thousands part down by one. The same procedure is applied to the tens // and ones. // Each rvar holds values from 0 to 7. //------------------------------------------------------------------------- // digits 1 & 2 (leftmost ones, thousands and hundreds) //------------------------------ void Rotaries.r_cnt_XPDR_high.On (void) { jump(l_handle_XPDR_high_rot); } void Rotaries.r_cnt_XPDR_high.Off (void) { jump(l_handle_XPDR_high_rot); } void l_handle_XPDR_high_rot (void) { if(Rotaries.r_dir_XPDR_high) // turn knob clockwise { rvar_XPDR_100++; // increment by 1 } else // turn knob counter clockwise { rvar_XPDR_1000--; // decrement thousands by 1 } jump(l_SetXPDR_Value); } // digits 3 & 4 (rightmost ones) //------------------------------ void Rotaries.r_cnt_XPDR_low.On (void) { jump(l_handle_XPDR_low_rot); } void Rotaries.r_cnt_XPDR_low.Off (void) { jump(l_handle_XPDR_low_rot); } void l_handle_XPDR_low_rot (void) { if (Rotaries.r_dir_XPDR_low) // turn knob clockwise { rvar_XPDR_1++; // increment by 1 } else // turn knob counter clockwise { rvar_XPDR_10--; // decrement decimals by 1 } jump(l_SetXPDR_Value); } void l_SetXPDR_Value (void) { wrd_XPDR = rvar_XPDR_1; wrd_Temp = rvar_XPDR_10 * 10; wrd_XPDR = wrd_XPDR + wrd_Temp; wrd_Temp = rvar_XPDR_100 * 100; wrd_XPDR = wrd_XPDR + wrd_Temp; wrd_Temp = rvar_XPDR_1000 * 1000; wrd_XPDR = wrd_XPDR + wrd_Temp; enque16(nqw_Cmd_XPDR, wrd_XPDR, FSMAPPER); // 0x41 -> entry required in EpicMapper config.ini jump(l_XPDR_Disp); // display the values immediatly } //========================================================================= // Button controls //========================================================================= //---------- Nosewheel/Antiskid -------------------------------------------- // //-------------------------------------------------------------------------- void Joystick_00.b_Askid_NW.On (void) { enque16(nqw_Cmd_Buttons_00, e_Askid_NW, FSMAPPER); } void Joystick_00.b_Askid_NW.Off (void) { enque16(nqw_Cmd_Buttons_00, e_Askid_NW, FSMAPPER); } //---------- Speed Brake --------------------------------------------------- // Speed Brake are Values from 0 to 16383 (according to the FSUIPC Documen- // tation) //-------------------------------------------------------------------------- void Joystick_01.b_SpdBrkArm.On (void) { enque16(nqw_Cmd_SPD_BRK_ARM, SPD_BRK_ARM, FSMAPPER); // Spilers Arm } void Joystick_01.b_SpdBrkArm.Off (void) { enque16(nqw_Cmd_SPD_BRK_ARM, SPD_BRK_DISARM, FSMAPPER); // Spilers disarm } void Joystick_01.b_SpdBrkUp.On (void) { enque16(nqw_Cmd_SPD_BRK, SPD_BRK_UP, FSMAPPER); // Spolers Off } void Joystick_01.b_SpdBrk1.On (void) { enque16(nqw_Cmd_SPD_BRK, SPD_BRK_1, FSMAPPER); // Spoilers first detente } void Joystick_01.b_SpdBrk2.On (void) { enque16(nqw_Cmd_SPD_BRK, SPD_BRK_2, FSMAPPER); // Spoliers second detente } void Joystick_01.b_SpdBrk3.On (void) { enque16(nqw_Cmd_SPD_BRK, SPD_BRK_3, FSMAPPER); // Spoilers third detente } void Joystick_01.b_SpdBrk4.On (void) { enque16(nqw_Cmd_SPD_BRK, SPD_BRK_4, FSMAPPER); // Spoilers full } //---------- Flaps --------------------------------------------------------- // Flaps are Values from 0 to 16383 (according to the FSUIPC Documen- // tation //-------------------------------------------------------------------------- void Joystick_01.b_FlapsUp.On (void) { enque16(nqw_Cmd_FLAPS, FLAPS_UP, FSMAPPER); // Flaps up } void Joystick_01.b_Flaps1.On (void) { enque16(nqw_Cmd_FLAPS, FLAPS_1, FSMAPPER); // Flaps 1 } void Joystick_01.b_Flaps2.On (void) { enque16(nqw_Cmd_FLAPS, FLAPS_2, FSMAPPER); // Flaps 2 } void Joystick_01.b_Flaps3.On (void) { enque16(nqw_Cmd_FLAPS, FLAPS_3, FSMAPPER); // Flaps 3 } void Joystick_01.b_FlapsFull.On (void) { enque16(nqw_Cmd_FLAPS, FLAPS_FULL, FSMAPPER); // Flaps full } //------------------------------------------------------------------------- // Landing Gear Up - Down //------------------------------------------------------------------------- void Joystick_00.b_LdgGear.On (void) { // lower landing gear enque16(nqw_Cmd_LDG_GEAR,LDG_GEAR_DOWN, FSMAPPER); // Ldg Gear Down } void Joystick_00.b_LdgGear.Off (void) { // raise landing gear enque16(nqw_Cmd_LDG_GEAR,LDG_GEAR_UP, FSMAPPER); // Ldg Gear Up } //------------------------------------------------------------------------- // Autobrake Low //------------------------------------------------------------------------- void Joystick_00.b_AutoBrakeLow.On (void) { if(f_AutoBrk_Low_On) { f_AutoBrk_Low_On = false; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_OFF, FSMAPPER); // Autobrake Low Off } else { f_AutoBrk_Low_On = true; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_LOW, FSMAPPER); // Autobrake Low On } } //------------------------------------------------------------------------- // Autobrake Mid //------------------------------------------------------------------------- void Joystick_00.b_AutoBrakeMed.On (void) { if(f_AutoBrk_Med_On) { f_AutoBrk_Med_On = false; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_OFF, FSMAPPER); // Autobrake Mid Off } else { f_AutoBrk_Med_On = true; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_MED, FSMAPPER); // Autobrake Med On } } //------------------------------------------------------------------------- // Autobrake Max //------------------------------------------------------------------------- void Joystick_00.b_AutoBrakeMax.On (void) { if(f_AutoBrk_Max_On) { f_AutoBrk_Max_On = false; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_OFF, FSMAPPER); // Autobrake Max Off } else { f_AutoBrk_Max_On = true; enque16(nqw_Cmd_AUTOBRAKE,AUTOBRAKE_MAX, FSMAPPER); // Autobrake Max On } } //------------------------------------------------------------------------- // AP disconnect button on/off //------------------------------------------------------------------------- void Joystick_00.b_AP_Dis.On (void) { enque16(nqw_Cmd_Buttons_00,e_AP_Dis, FSMAPPER); // Auto Pilot disconnect // tests can be made here if epic not connected on simulator buttons. } //------------------------------------------------------------------------- // Elevator Trim up button on/off //------------------------------------------------------------------------- void Joystick_00.b_ElevTrimUp.On (void) { enque16(nqw_Cmd_Elevator_trim, wrd_ElevTrimPos, FSMAPPER); // elev. Trim up } void Joystick_00.b_ElevTrimUp.Off (void) { enque16(nqw_Cmd_Elevator_trim,wrd_ElevTrimPos, FSMAPPER); } //------------------------------------------------------------------------- // Elevator Trim down button on/off //------------------------------------------------------------------------- void Joystick_00.b_ElevTrimDn.On (void) { enque16(nqw_Cmd_Elevator_trim,wrd_ElevTrimPos, FSMAPPER); // elev. Trim down } void Joystick_00.b_ElevTrimDn.Off (void) { enque16(nqw_Cmd_Elevator_trim,wrd_ElevTrimPos, FSMAPPER); } //------------------------------------------------------------------------- // Brakes //------------------------------------------------------------------------- void Joystick_00.b_Brake.On (void) { enque16(nqw_Cmd_Buttons_00,e_Brake, FSMAPPER); } void Joystick_00.b_Brake.Off (void) { enque16(nqw_Cmd_Buttons_00,e_Brake, FSMAPPER); } //------------------------------------------------------------------------- // select SELECTED or MANAGED SPD //------------------------------------------------------------------------- void Joystick_02.b_sel_SPD.On (void) { disablescan(Joystick_02.b_sel_SPD); delay(50); if(Joystick_02.b_sel_SPD) { jump(l_selected_SPD); } else { jump(l_managed_SPD); } } void l_selected_SPD (void) { enablescan(Joystick_02.b_sel_SPD); enque16(nqw_Cmd_Buttons_00, e_selected_SPD, FSMAPPER); f_SPD_valid = true; jump(l_SPD_MACH_Disp); } void l_managed_SPD (void) { enablescan(Joystick_02.b_sel_SPD); enque16(nqw_Cmd_Buttons_00, e_managed_SPD, FSMAPPER); f_SPD_valid = false; jump(l_SPD_MACH_Disp); } //------------------------------------------------------------------------- // select SELECTED or MANAGED HDG //------------------------------------------------------------------------- void Joystick_02.b_sel_HDG.On (void) { disablescan(Joystick_02.b_sel_HDG); delay(50); if(Joystick_02.b_sel_HDG) { jump(l_selected_HDG); } else { jump(l_managed_HDG); } } void l_selected_HDG (void) { enablescan(Joystick_02.b_sel_HDG); enque16(nqw_Cmd_Buttons_00, e_selected_HDG, FSMAPPER); f_HDG_valid = true; jump(l_HDG_Disp); } void l_managed_HDG (void) { enablescan(Joystick_02.b_sel_HDG); enque16(nqw_Cmd_Buttons_00, e_managed_HDG, FSMAPPER); f_HDG_valid = false; jump(l_HDG_Disp); } //------------------------------------------------------------------------- // engage managed ALT mode //------------------------------------------------------------------------- void Joystick_02.b_sel_ALT.On (void) { disablescan(Joystick_02.b_sel_ALT); delay(50); if(Joystick_02.b_sel_ALT) { jump(l_selected_ALT); } else { jump(l_managed_ALT); } } void l_selected_ALT (void) { enablescan(Joystick_02.b_sel_ALT); enque16(nqw_Cmd_Buttons_00, e_selected_ALT, FSMAPPER); f_ALT_valid = true; jump(l_ALT_Disp); } void l_managed_ALT (void) { enablescan(Joystick_02.b_sel_ALT); enque16(nqw_Cmd_Buttons_00, e_managed_ALT, FSMAPPER); f_ALT_valid = false; jump(l_ALT_Disp); } //------------------------------------------------------------------------- // engage managed ALT mode //------------------------------------------------------------------------- void Joystick_02.b_sel_VS.On (void) { disablescan(Joystick_02.b_sel_VS); delay(50); if(Joystick_02.b_sel_VS) { jump(l_selected_VS); } else { jump(l_LevelOff_VS); } } void l_selected_VS (void) { enablescan(Joystick_02.b_sel_VS); enque16(nqw_Cmd_Buttons_00, e_selected_VS, FSMAPPER); } void l_LevelOff_VS (void) { enablescan(Joystick_02.b_sel_VS); enque16(nqw_Cmd_Buttons_00, e_LevelOff_VS, FSMAPPER); } //------------------------------------------------------------------------- // Parking Brake //------------------------------------------------------------------------- void Joystick_01.b_ParkBrk.On (void) { enque16(nqw_Cmd_PARKBRK, PARKBRK_ON, FSMAPPER); } void Joystick_01.b_ParkBrk.Off (void) { enque16(nqw_Cmd_PARKBRK, PARKBRK_OFF, FSMAPPER); } //========================================================================= // FCU Buttons //========================================================================= //------------------------------------------------------------------------- // AutoPilot 1 //------------------------------------------------------------------------- void Joystick_02.b_AP1.On (void) { enque16(nqw_Cmd_Buttons_00, e_AP1, FSMAPPER); } //------------------------------------------------------------------------- // AutoPilot 2 //------------------------------------------------------------------------- void Joystick_02.b_AP2.On (void) { enque16(nqw_Cmd_Buttons_00, e_AP2, FSMAPPER); } //------------------------------------------------------------------------- // AutoThrottle //------------------------------------------------------------------------- void Joystick_02.b_AT.On (void) { if(f_BtnToggle_b_AT) { enque16(nqw_Cmd_Buttons_00, e_AT, FSMAPPER); f_BtnToggle_b_AT = false; } else { enque16(nqw_Cmd_Buttons_00, e_AT_Dis, FSMAPPER); f_BtnToggle_b_AT = true; } } //------------------------------------------------------------------------- // AutoThrottle disconnect buttons (on Throttles) //------------------------------------------------------------------------- void Joystick_01.b_AT_Dis.On (void) { enque16(nqw_Cmd_Buttons_00, e_AT_Dis, FSMAPPER); f_BtnToggle_b_AT = true; } //------------------------------------------------------------------------- // toggle between SPD and MACH display //------------------------------------------------------------------------- void Joystick_02.b_SPD_MACH.On (void) { enque16(nqw_Cmd_Buttons_00, e_SPD_MACH, FSMAPPER); } //------------------------------------------------------------------------- // Localizer engage //------------------------------------------------------------------------- void Joystick_02.b_LOC.On (void) { enque16(nqw_Cmd_Buttons_00, e_LOC, FSMAPPER); } //------------------------------------------------------------------------- // Altitude hold //------------------------------------------------------------------------- void Joystick_02.b_ALT.On (void) { enque16(nqw_Cmd_Buttons_00, e_ALT, FSMAPPER); } //------------------------------------------------------------------------- // toggle metric and feet altitude disp //------------------------------------------------------------------------- void Joystick_02.b_metric_ALT.On (void) { enque16(nqw_Cmd_Buttons_00, e_metric_ALT, FSMAPPER); } //------------------------------------------------------------------------- // select ALT range 10/100 //------------------------------------------------------------------------- void Joystick_02.b_range_ALT.On (void) { enque16(nqw_Cmd_Buttons_00, e_range_ALT, FSMAPPER); } //------------------------------------------------------------------------- // engage Approach mode //------------------------------------------------------------------------- void Joystick_02.b_APP.On (void) { enque16(nqw_Cmd_Buttons_00, e_APP, FSMAPPER); } //------------------------------------------------------------------------- // HDG / FPA mode selector //------------------------------------------------------------------------- void Joystick_02.b_HDG_FPA.On (void) { enque16(nqw_Cmd_Buttons_00, e_HDG_FPA, FSMAPPER); } //========================================================================= // Pilot Side EFIS Buttons //========================================================================= // ADF / VOR switches //------------------------------------------------------------------------- void Joystick_03.b_ADF1_P.On (void) { wrd_Offset_4f4_Data = ADFL_ON; jump(l_ND_Modes); } void Joystick_03.b_ADF1_P.Off (void) { wrd_Offset_4f4_Data = VORADFL_OFF; jump(l_ND_Modes); } void Joystick_03.b_VOR1_P.On (void) { wrd_Offset_4f4_Data = VORL_ON; jump(l_ND_Modes); } void Joystick_03.b_VOR1_P.Off (void) { wrd_Offset_4f4_Data = VORADFL_OFF; jump(l_ND_Modes); } void Joystick_03.b_ADF2_P.On (void) { wrd_Offset_4f4_Data = ADFR_ON; jump(l_ND_Modes); } void Joystick_03.b_ADF2_P.Off (void) { wrd_Offset_4f4_Data = VORADFR_OFF; jump(l_ND_Modes); } void Joystick_03.b_VOR2_P.On (void) { wrd_Offset_4f4_Data = VORR_ON; jump(l_ND_Modes); } void Joystick_03.b_VOR2_P.Off (void) { wrd_Offset_4f4_Data = VORADFR_OFF; jump(l_ND_Modes); } //------------------------------------------------------------------------- // LS enable, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_LS_P.On (void) { enque16(nqw_Cmd_ElanCode, LS_P, FSMAPPER); } //------------------------------------------------------------------------- // Flight director enable, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_FD_P.On (void) { if (f_FD_P_On) { f_FD_P_On = false; enque16(nqw_Cmd_ElanCode, FD_OFF_P, FSMAPPER); } else { f_FD_P_On = true; enque16(nqw_Cmd_ElanCode, FD_ON_P, FSMAPPER); } } //------------------------------------------------------------------------- // Baro enable, Pilot side. Pushing the button sets the baro to STD, // "pulling" the button (pushing it for more than 1 second in this case) // enables the setting of the baro pressure //------------------------------------------------------------------------- void Joystick_03.b_BaroStd_P.On (void) { disablescan(Joystick_03.b_BaroStd_P); delay(50); if(Joystick_03.b_BaroStd_P) { jump(l_Baro_Std_P); } else { jump(l_Baro_Sel_P); } } void l_Baro_Std_P (void) { enablescan(Joystick_03.b_BaroStd_P); enque16(nqw_Cmd_ElanCode, BARO_STD_P, FSMAPPER); } void l_Baro_Sel_P (void) { enablescan(Joystick_03.b_BaroStd_P); enque16(nqw_Cmd_ElanCode, BARO_SEL_P, FSMAPPER); } //------------------------------------------------------------------------- // Select betwen Hg and hPa display, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_InHg_hPa_P.On (void) { enque16(nqw_Cmd_ElanCode,BARO_IN_HPA, FSMAPPER); jump(l_Baro_Disp_P); } void Joystick_03.b_InHg_hPa_P.Off (void) { enque16(nqw_Cmd_ElanCode,BARO_IN_INCHES, FSMAPPER); // jump(l_Baro_Disp); jump(l_Baro_Disp_P); } //------------------------------------------------------------------------- // ND range 10, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_10_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_10; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode | WXR_RANGE_10; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 20, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_20_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_20; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode & WXR_RANGE_20; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 40, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_40_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_40; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode & WXR_RANGE_40; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 80, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_80_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_80; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode & WXR_RANGE_80; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 160, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_160_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_160; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode & WXR_RANGE_160; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 320, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_320_P.On (void) { wrd_Offset_4f4_Data = ND_RANGE_320; // set WXR range manually, as setting via PM does not work correctly wrd_WXR_Mode = wrd_WXR_Mode & WXR_RANGE_320; call(l_WXR_Mode); jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ARPT toggle, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ARPT_P.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_ARPT; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND NDB togle, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_NDB_P.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_NDB; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND VOR toggle, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_VORD_P.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_VOR; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND WPT toggle, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_WPT_P.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_WPT; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND CSTR toggle, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_CSTR_P.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_DATA; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ILS mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_ILS_P.On (void) { wrd_Offset_4f4_Data = ND_ILS; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND VOR mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_VOR_P.On (void) { wrd_Offset_4f4_Data = ND_VOR; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND NAV mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_NAV_P.On (void) { wrd_Offset_4f4_Data = ND_NAV; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ARC mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_ARC_P.On (void) { wrd_Offset_4f4_Data = ND_MAP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND PLN mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_PLN_P.On (void) { wrd_Offset_4f4_Data = ND_PLAN; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ENG mode, Pilot side //------------------------------------------------------------------------- void Joystick_03.b_ND_ENG_P.On (void) { wrd_Offset_4f4_Data = PFD_EICAS; jump(l_ND_Modes); } //========================================================================= // Pilot side glareshield wings Buttons //========================================================================= // Chrono Pilot side //------------------------------------------------------------------------- void Joystick_04.b_Chrono_P.On (void) { // Send Ctrl-Shift-T to PFD software wrd_Offset_4f4_Data = ND_CHRONO_TOGGLE; jump(l_ND_Modes); } //------------------------------------------------------------------------- // Master Caution pilot side //------------------------------------------------------------------------- void Joystick_04.b_MastCaut_P.On (void) { wrd_Offset_4f4_Data = CAUTION_RESET; jump(l_ND_Modes); } //------------------------------------------------------------------------- // Sidestick control takeover proprity captain side //------------------------------------------------------------------------- void Joystick_04.b_StickPrio_P.On (void) { enque16(nqw_Cmd_StickPriority,StickPrioTakeoverP_On); } //------------------------------------------------------------------------- // Sidestick control takeover proprity captain side //------------------------------------------------------------------------- void Joystick_04.b_StickPrio_P.Off (void) { enque16(nqw_Cmd_StickPriority,StickPrioTakeoverP_Off); } //========================================================================= // Autoland //------------------------------------------------------------------------- void Joystick_04.b_AutoLand_P.On (void) { } void Joystick_04.b_AutoLand_P.Off (void) { } //========================================================================= // Co-Pilot Side EFIS Buttons //========================================================================= //========================================================================= // ADF / VOR switches //------------------------------------------------------------------------- void Joystick_05.b_ADF1_CP.On (void) { wrd_Offset_4f4_Data = ADFL_ON + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_ADF1_CP.Off (void) { wrd_Offset_4f4_Data = VORADFL_OFF + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_VOR1_CP.On (void) { wrd_Offset_4f4_Data = VORL_ON + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_VOR1_CP.Off (void) { wrd_Offset_4f4_Data = VORADFL_OFF + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_ADF2_CP.On (void) { wrd_Offset_4f4_Data = ADFR_ON + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_ADF2_CP.Off (void) { wrd_Offset_4f4_Data = VORADFR_OFF + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_VOR2_CP.On (void) { wrd_Offset_4f4_Data = VORR_ON + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_05.b_VOR2_CP.Off (void) { wrd_Offset_4f4_Data = VORADFR_OFF + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // LS enable, Pilot side //------------------------------------------------------------------------- void Joystick_05.b_LS_CP.On (void) { enque16(nqw_Cmd_ElanCode, LS_CP, FSMAPPER); } //------------------------------------------------------------------------- // Flight director enable, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_FD_CP.On (void) { if (f_FD_CP_On) { f_FD_CP_On = false; enque16(nqw_Cmd_ElanCode, FD_ON_CP, FSMAPPER); } else { f_FD_CP_On = true; enque16(nqw_Cmd_ElanCode, FD_OFF_CP, FSMAPPER); } } //------------------------------------------------------------------------- // Baro enable, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_BaroStd_CP.On (void) { disablescan(Joystick_05.b_BaroStd_CP); delay(50); if(Joystick_05.b_BaroStd_CP) { jump(l_Baro_Std_CP); } else { jump(l_Baro_Sel_CP); } } void l_Baro_Std_CP (void) { enablescan(Joystick_05.b_BaroStd_CP); enque16(nqw_Cmd_ElanCode, BARO_STD_CP, FSMAPPER); } void l_Baro_Sel_CP (void) { enablescan(Joystick_05.b_BaroStd_CP); enque16(nqw_Cmd_ElanCode, BARO_SEL_CP, FSMAPPER); } //------------------------------------------------------------------------- // Select betwen Hg and hPa display, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_InHg_hPa_CP.On (void) { enque16(nqw_Cmd_ElanCode,BARO_IN_HPA, FSMAPPER); jump(l_Baro_Disp_CP); } void Joystick_05.b_InHg_hPa_CP.Off (void) { enque16(nqw_Cmd_ElanCode,BARO_IN_INCHES, FSMAPPER); jump(l_Baro_Disp_CP); } //------------------------------------------------------------------------- // ND range 10, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_10_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_10 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 20, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_20_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_20 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 40, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_40_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_40 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 80, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_80_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_80 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 160, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_160_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_160 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND range 320, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_320_CP.On (void) { wrd_Offset_4f4_Data = ND_RANGE_320 + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ARPT toggle, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ARPT_CP.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_ARPT + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND NDB togle, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_NDB_CP.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_NDB + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND VOR toggle, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_VORD_CP.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_VOR + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND WPT toggle, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_WPT_CP.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_WPT + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND CSTR toggle, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_CSTR_CP.On (void) { wrd_Offset_4f4_Data = ND_TOGGLE_DATA + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ILS mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_ILS_CP.On (void) { wrd_Offset_4f4_Data = ND_ILS + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND VOR mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_VOR_CP.On (void) { wrd_Offset_4f4_Data = ND_VOR + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND NAV mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_NAV_CP.On (void) { wrd_Offset_4f4_Data = ND_NAV + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ARC mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_ARC_CP.On (void) { wrd_Offset_4f4_Data = ND_MAP + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND PLN mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_PLN_CP.On (void) { wrd_Offset_4f4_Data = ND_PLAN + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // ND ENG mode, CoPilot side //------------------------------------------------------------------------- void Joystick_05.b_ND_ENG_CP.On (void) { wrd_Offset_4f4_Data = PFD_EICAS + ND_MODE_CP; jump(l_ND_Modes); } //========================================================================= // Pilot side glareshield wings Buttons //========================================================================= // Chrono CoPilot side //------------------------------------------------------------------------- void Joystick_06.b_Chrono_CP.On (void) { wrd_Offset_4f4_Data = ND_CHRONO_TOGGLE + ND_MODE_CP; jump(l_ND_Modes); } void Joystick_06.b_MastCaut_CP.On (void) { wrd_Offset_4f4_Data = CAUTION_RESET; jump(l_ND_Modes); } //------------------------------------------------------------------------- // Sidestick control takeover priority fist officer side //------------------------------------------------------------------------- void Joystick_06.b_StickPrio_CP.On (void) { enque16(nqw_Cmd_StickPriority,StickPrioTakeoverCP_On); } void Joystick_06.b_StickPrio_CP.Off (void) { enque16(nqw_Cmd_StickPriority,StickPrioTakeoverCP_Off); } //========================================================================= // MCDU Pilot side buttons // low byte -> ASCII character, high byte -> shift state // Bit 0 = shift // Bit 1 = Ctrl // Bit 2 = Alt // // 0x41 | 0x0010 -> key A, ctrl // 0b01000001 OR 0b100000010 // // 0b000000001000001 OR -> Low byte, ASCII code // 0b000000100000000 -> high byte, shift state // ----------------- -> 'OR ed' together // 0b000000101000001 -> result sent to EPIC //========================================================================= void Joystick_07.b_CDU_LSK1L_P.On (void) // Line select Key 1 left -> F1 { byt_KeyCode = KeyASCII_F1; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK2L_P.On (void) // Line select Key 2 left -> F2 { byt_KeyCode = KeyASCII_F2; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK3L_P.On (void) // Line select Key 3 left -> F3 { byt_KeyCode = KeyASCII_F3; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK4L_P.On (void) // Line select Key 4 left -> F4 { byt_KeyCode = KeyASCII_F4; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK5L_P.On (void) // Line select Key 5 left -> F5 { byt_KeyCode = KeyASCII_F5; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK6L_P.On (void) // Line select Key 6 left -> F6 { byt_KeyCode = KeyASCII_F6; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK1R_P.On (void) // Line select Key 1 right -> F7 { byt_KeyCode = KeyASCII_F7; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK2R_P.On (void) // Line select Key 2 right -> F8 { byt_KeyCode = KeyASCII_F8; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK3R_P.On (void) // Line select Key 3 right -> F9 { byt_KeyCode = KeyASCII_F9; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK4R_P.On (void) // Line select Key 4 right -> F10 { byt_KeyCode = KeyASCII_F10; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK5R_P.On (void) // Line select Key 5 right -> F11 { byt_KeyCode = KeyASCII_F11; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_LSK6R_P.On (void) // Line select Key 6 right -> F12 { byt_KeyCode = KeyASCII_F12; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_DIR_P.On (void) // DIR: Direct to page key -> CTRL-F1 { byt_KeyCode = KeyASCII_F1; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_PROG_P.On (void) // PROG: Progress page key -> CTRL-F2 { byt_KeyCode = KeyASCII_F2; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_PERF_P.On (void) // PERF: Performance page key -> CTRL-F3 { byt_KeyCode = KeyASCII_F3; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_INIT_P.On (void) // INIT: Init page key -> CTRL-F4 { byt_KeyCode = KeyASCII_F4; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_DATA_P.On (void) // DATA: Data page key -> CTRL-F5 { byt_KeyCode = KeyASCII_F5; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_FPLN_P.On (void) // F-PLN: Flight Plan page key-> CTRL-F6 { byt_KeyCode = KeyASCII_F6; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_RADNAV_P.On (void) // RAD-NAV: Radio/Navigation page key -> CTRL-F7 { byt_KeyCode = KeyASCII_F7; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_FPRED_P.On (void) // FUEL PRED: Fuel Prediction key -> CTRL-F8 { byt_KeyCode = KeyASCII_F8; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_SFPLN_P.On (void) // SEC F-PLAN: Secondary Flight Plan key -> CTRL-F9 { byt_KeyCode = KeyASCII_F9; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_MENU_P.On (void) // MENU: Menu Page Key -> CTRL-F11 -> CTRL-F10 { byt_KeyCode = KeyASCII_F10; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_ARPT_P.On (void) // ARPT: Airport page key -> CTRL-F12 { byt_KeyCode = KeyASCII_F12; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Function_Code); } void Joystick_07.b_CDU_NXTPG_P.On (void) // NEXT PAGE: Next Page key -> PgDn { byt_KeyCode = KeyASCII_PAGE_DN; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_VOID_P.On (void) // empty key, no function (so far) { byt_KeyCode = KeyASCII_F11; wrd_Key_ShiftState = Key_CTRL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_A_P.On (void) // A key { byt_KeyCode = KeyASCII_A; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_B_P.On (void) // B key { byt_KeyCode = KeyASCII_B; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_C_P.On (void) // C key { byt_KeyCode = KeyASCII_C; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_D_P.On (void) // D key { byt_KeyCode = KeyASCII_D; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_E_P.On (void) // E key { byt_KeyCode = KeyASCII_E; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_F_P.On (void) // F key { byt_KeyCode = KeyASCII_F; wrd_Key_ShiftState = Key_NORMAL; jump(p_Toggle_Keyboard_Code); wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; } void Joystick_07.b_CDU_G_P.On (void) // G key { byt_KeyCode = KeyASCII_G; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_H_P.On (void) // H key { byt_KeyCode = KeyASCII_H; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_I_P.On (void) // I key { byt_KeyCode = KeyASCII_I; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_J_P.On (void) // J key { byt_KeyCode = KeyASCII_J; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_K_P.On (void) // K key { byt_KeyCode = KeyASCII_K; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_L_P.On (void) // L key { byt_KeyCode = KeyASCII_L; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_M_P.On (void) // M key { byt_KeyCode = KeyASCII_M; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_N_P.On (void) // N key { byt_KeyCode = KeyASCII_N; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_O_P.On (void) // O key { byt_KeyCode = KeyASCII_O; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_P_P.On (void) // P key { byt_KeyCode = KeyASCII_P; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_Q_P.On (void) // Q key { byt_KeyCode = KeyASCII_Q; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_R_P.On (void) // R key { byt_KeyCode = KeyASCII_R; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_S_P.On (void) // S key { byt_KeyCode = KeyASCII_S; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_T_P.On (void) // T key { byt_KeyCode = KeyASCII_T; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_U_P.On (void) // U key { byt_KeyCode = KeyASCII_U; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_V_P.On (void) // V key { byt_KeyCode = KeyASCII_V; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_07.b_CDU_W_P.On (void) // W key { byt_KeyCode = KeyASCII_W; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_X_P.On (void) // X key { byt_KeyCode = KeyASCII_X; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_Y_P.On (void) // Y key { byt_KeyCode = KeyASCII_Y; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_Z_P.On (void) // Z key { byt_KeyCode = KeyASCII_Z; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_SLASH_P.On (void) // /: Slash key -> Slash { byt_KeyCode = KeyASCII_SLASH_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_SPACE_P.On (void) // _: Space key -> Space { byt_KeyCode = KeyASCII_SPACE; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_OVFY_P.On (void) // OVFY: Overfly key -> HOME { byt_KeyCode = KeyASCII_HOME; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_CLEAR_P.On (void) // CLR: Clear key -> BACKSPACE { byt_KeyCode = KeyASCII_BACKSPACE; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_SIGN_P.On (void) // +-: Sign key -> PLUS / MINUS, toggled { if (f_PlusSign) { byt_KeyCode = KeyASCII_MINUS_NUMPAD; f_PlusSign = false; } else { byt_KeyCode = KeyASCII_PLUS_NUMPAD; f_PlusSign = true; } wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_LEFT_P.On (void) // <: Left arrow key -> LEFT_ARROW { byt_KeyCode = KeyASCII_LEFT_ARROW; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_UP_P.On (void) // ^: Up arrow key -> UP_ARROW { byt_KeyCode = KeyASCII_UP_ARROW; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_RIGHT_P.On (void) // >: right arrow key -> RIGHT_ARROW { byt_KeyCode = KeyASCII_RIGHT_ARROW; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_DOWN_P.On (void) // v: Down arrow key -> DN_ARROW { byt_KeyCode = KeyASCII_DN_ARROW; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_1_P.On (void) // 1 key { byt_KeyCode = KeyASCII_1_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_2_P.On (void) // 2 key { byt_KeyCode = KeyASCII_2_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_3_P.On (void) // 3 key { byt_KeyCode = KeyASCII_3_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_4_P.On (void) // 4 key { byt_KeyCode = KeyASCII_4_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_5_P.On (void) // 5 key { byt_KeyCode = KeyASCII_5_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_6_P.On (void) // 6 key { byt_KeyCode = KeyASCII_6_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_7_P.On (void) // 7 key { byt_KeyCode = KeyASCII_7_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_8_P.On (void) // 8 key { byt_KeyCode = KeyASCII_8_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_9_P.On (void) // 9 key { byt_KeyCode = KeyASCII_9_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_0_P.On (void) // 0 key { byt_KeyCode = KeyASCII_0_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } void Joystick_08.b_CDU_POINT_P.On (void) // .: Decimal point key { byt_KeyCode = KeyASCII_POINT_NUMPAD; wrd_Key_ShiftState = Key_NORMAL; wrd_Cmd_KeyCode = nqw_Cmd_CDU_KEYS; jump(p_Toggle_Keyboard_Code); } //========================================================================= // Pilot side Radio Management Panel //========================================================================= //---------- Radio Management Panel, Pilot Side ------------------------------ // Transfer VHF1 stby freq. to active // Check if the NAV backup mode is enabled. if it is, then: // - check if frequency or course is to be changed (according to flag) // - if course is to be changed, then blank out the two higher digits // (a course selection has only 3 digits, not 5) // - send the frequency value to FS. The course flag is now set, // when turning the encoder the course is directly sent to FS. // Procedure used for exchanging the stby and active frequency variables: // 1. Set the work variable to the value of the stanby freq. variable // 2. Set the stby variable to the value of the active freq. variable // 3. Send the work variable to FS. The active freq. will be updated // as soon as FS has got a new value //----------------------------------------------------------------------------- void Joystick_09.b_RMP_XFER_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // Is RMP pilot side ON? { if(Joystick_09.b_RMP_NAV_P) // NAV backup mode active? { if(f_RMP_VOR_P) // is VOR mode active? { if(f_RMP_Freq_P) // frequency flag was set, course has to be set now { f_RMP_Freq_P = false; // clear the flag, course is to be set } else { f_RMP_Freq_P = true; // set the flag, frequency is to be set } #expand MakeDec16(wrd_VOR1freq,rvar_VOR1freq_h,rvar_VOR1freq_d) // make decimal value wrd_VOR1freq = wrd_VOR1freq - 10000; // FS wants the value without the 100's enque16(nqw_Cmd_VOR1freq, wrd_VOR1freq, FSMAPPER); jump(l_COM_Disp); } if(f_RMP_ILS_P) // is ILS mode active? { if(f_RMP_Freq_P) // frequency flag was set, course has to be set now { f_RMP_Freq_P = false; // clear the flag, course is to be set } else { f_RMP_Freq_P = true; // set the flag, frequency is to be set } #expand MakeDec16(wrd_ILS1freq,rvar_ILS1freq_h,rvar_ILS1freq_d) // make decimal value wrd_ILS1freq = wrd_ILS1freq - 10000; // FS wants the value without the 100's enque16(nqw_Cmd_ILS1freq, wrd_ILS1freq, FSMAPPER); jump(l_COM_Disp); } if(f_RMP_ADF_P) // is ADF mode active? { #expand MakeDec16(wrd_ADF1,rvar_ADF1stby_h,rvar_ADF1stby_d) if(wrd_BCD_Work < 9999) // if ADF freq < 9999 { enque16(nqw_Cmd_ADFfreq_Low, wrd_ADF1, FSMAPPER); // use ADF_LOWRANGE_SET } else { enque16(nqw_Cmd_ADFfreq_High, wrd_ADF1, FSMAPPER); // use ADF_HIGHRANGE_SET } } } else // COM frequency is to be set { #expand MakeDec16(wrd_VHF1,rvar_VHF1stby_h,rvar_VHF1stby_d) // make decimal value // rvar_VHF1stby_d = byt_VHF1act_d; // rvar_VHF1stby_h = byt_VHF1act_h; wrd_VHF1 = wrd_VHF1 - 10000; // FS wants the value without the 100's enque16(nqw_Cmd_VHF1freq, wrd_VHF1, FSMAPPER); jump(l_COM_Disp); } } } // VHF1 selector // currently only VHF1 selector is in use void Joystick_09.b_RMP_VHF1_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VHF1_P = true; // f_RMP_VHF2_P = false; // f_RMP_VHF3_P = false; } } // VHF2 selector void Joystick_09.b_RMP_VHF2_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VHF1_P = false; // f_RMP_VHF2_P = true; // f_RMP_VHF3_P = false; } } // VHF3 selector void Joystick_09.b_RMP_VHF3_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VHF1_P = false; // f_RMP_VHF2_P = false; // f_RMP_VHF3_P = true; } } // HF1 selector void Joystick_09.b_RMP_HF1_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_Dummy = true; } } // SEL light void Joystick_09.b_RMP_SEL_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_Dummy = true; } } // HF2 selector void Joystick_09.b_RMP_HF2_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On/ { f_Dummy = true; } } // AM selector void Joystick_09.b_RMP_AM_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_Dummy = true; } } //---------- NAV backup mode --------------------------------------------------- // NAV selector (enable NAV backp mode) // NAV button on the RMP panel is a on/off toggle switch. When on, then NAV backup mode // is enabled. The different backup modes are controlled by flags, because the corresponding // switches are momentary switches //------------------------------------------------------------------------------ void Joystick_09.b_RMP_NAV_P.On (void) // RMP in NAV backup mode { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { jump(l_COM_Disp); } } void Joystick_09.b_RMP_NAV_P.Off (void) // RMP in normal operations { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { jump(l_COM_Disp); } } // VOR frequency select enable void Joystick_09.b_RMP_VOR_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VOR_P = true; f_RMP_ILS_P = false; f_RMP_MLS_P = false; f_RMP_ADF_P = false; f_RMP_BFO_P = false; jump(l_COM_Disp); } } // ILS frequency select enable void Joystick_09.b_RMP_ILS_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VOR_P = false; f_RMP_ILS_P = true; f_RMP_MLS_P = false; f_RMP_ADF_P = false; f_RMP_BFO_P = false; jump(l_COM_Disp); } } // MLS frequency select enable void Joystick_09.b_RMP_MLS_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VOR_P = false; f_RMP_ILS_P = false; f_RMP_MLS_P = true; f_RMP_ADF_P = false; f_RMP_BFO_P = false; jump(l_COM_Disp); } } // ADF frequency select enable void Joystick_09.b_RMP_ADF_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VOR_P = false; f_RMP_ILS_P = false; f_RMP_MLS_P = false; f_RMP_ADF_P = true; f_RMP_BFO_P = false; jump(l_COM_Disp); } } // BFO frequency select enable void Joystick_09.b_RMP_BFO_P.On (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { f_RMP_VOR_P = false; f_RMP_ILS_P = false; f_RMP_MLS_P = false; f_RMP_ADF_P = false; f_RMP_BFO_P = true; jump(l_COM_Disp); } } // RMP pilot side On void Joystick_09.b_RMP_OnOff_P.On (void) // enable all pilot side RMP displays { jump(l_COM_Disp); } // RMP pilot side Off void Joystick_09.b_RMP_OnOff_P.Off (void) // blank out all pilot side RMP displays { Display.disp_VHF1stby_d = blank; Display.disp_VHF1stby_h = blank; // senddata(BITOUTPUT,4,0x8F); // blank out digit 0, row 4 -> 0b10001111 VHF1 stby // senddata(BITOUTPUT,4,0x9F); // blank out digit 1, row 4 -> 0b10011111 VHF1 stby // senddata(BITOUTPUT,4,0xAF); // blank out digit 2, row 4 -> 0b10101111 VHF1 stby // senddata(BITOUTPUT,4,0xBF); // blank out digit 3, row 4 -> 0b10111111 VHF1 stby // senddata(BITOUTPUT,4,0xCF); // blank out digit 4, row 4 -> 0b11001111 VHF1 stby // senddata(BITOUTPUT,5,0x8F); // blank out digit 0, row 5 -> 0b10001111 VHF1 stby // senddata(BITOUTPUT,5,0x9F); // blank out digit 1, row 5 -> 0b10011111 VHF1 stby // senddata(BITOUTPUT,5,0xAF); // blank out digit 2, row 5 -> 0b10101111 VHF1 stby // senddata(BITOUTPUT,5,0xBF); // blank out digit 3, row 5 -> 0b10111111 VHF1 stby // senddata(BITOUTPUT,5,0xCF); // blank out digit 4, row 5 -> 0b11001111 VHF1 stby } //----------------------------------------------------------------------------------------- // Rudder trim switch //----------------------------------------------------------------------------------------- void Joystick_09.b_RudderTrim_L.On (void); { enque16(nqw_Cmd_Buttons_00, e_RUD_TRIM_R, FSMAPPER); } void Joystick_09.b_RudderTrim_L.Off (void); { enque16(nqw_Cmd_Buttons_00, e_RUD_TRIM_L, FSMAPPER); //enque16(nqw_Cmd_Buttons_00, e_RUD_TRIM_R, FSMAPPER); //enque16(nqw_Cmd_Rudder_trim, wrd_RudTrimPos, FSMAPPER); // command to send Rudder Trim value } //----------------------------------------------------------------------------------------- // Secondary EICAS page select buttons //----------------------------------------------------------------------------------------- // Take off config page void Joystick_10.b_TO_CFG.On (void); { //enque16(nqw_Cmd_ND_Modes,SEC_EICAS_TO_CFG, FSMAPPER); } // Emergency cancel button void Joystick_10.b_EMER_CANC.On (void); { //enque16(nqw_Cmd_ND_Modes,SEC_EICAS_EMER_CANC, FSMAPPER); } // Engine page void Joystick_10.b_ENG_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_ENG, FSMAPPER); } // Bleed page void Joystick_10.b_BLEED_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_BLEED, FSMAPPER); } // Pressure page void Joystick_10.b_PRESS_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_PRESS, FSMAPPER); } // Electric AC page void Joystick_10.b_ELEC_AC_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_ELEC_AC, FSMAPPER); } // Electric DC page void Joystick_10.b_ELEC_DC_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_ELEC_DC, FSMAPPER); } // Hydraulic page void Joystick_10.b_HYD_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_HYD, FSMAPPER); } // Circuit breaker void Joystick_10.b_CIRCUIT_BREAKER_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_CIRCUIT_BREAKER, FSMAPPER); } // APU page void Joystick_10.b_APU_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_APU, FSMAPPER); } // Air condition page void Joystick_10.b_AIR_COND_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_AIRCOND, FSMAPPER); } // Door page void Joystick_10.b_DOOR_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_DOOR, FSMAPPER); } // Wheel page void Joystick_10.b_WHEEL_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_WHEEL, FSMAPPER); } // Flight control page void Joystick_10.b_FLIGHT_CTL_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_F_CTL, FSMAPPER); } // Fuel page void Joystick_10.b_FUEL_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_FUEL, FSMAPPER); } // All pages void Joystick_10.b_ALL_PAGES_BTN.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_ALL, FSMAPPER); } // Left clear button void Joystick_10.b_CLEAR_LEFT_BTN.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_CLR_LEFT, FSMAPPER); } // Status page void Joystick_10.b_STATUS_PAGE.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_STS, FSMAPPER); } // Recall button void Joystick_10.b_RECALL_BTN.On (void); { //enque16(nqw_Cmd_ND_Modes,SEC_EICAS_RCL, FSMAPPER); } // void Joystick_10.b_CLEAR_RIGHT_BTN.On (void); { enque16(nqw_Cmd_ND_Modes,SEC_EICAS_CLR_RIGHT, FSMAPPER); } // Upper ECAM on void Joystick_10.b_UPPER_ECAM.On (void); { enque16(nqw_Cmd_UPPER_ECAM_ON_OFF,DISPLAY_ON, FSMAPPER); } // Upper ECAM off void Joystick_10.b_UPPER_ECAM.Off (void); { enque16(nqw_Cmd_UPPER_ECAM_ON_OFF,DISPLAY_OFF, FSMAPPER); } // Lower ECAM on void Joystick_10.b_LOWER_ECAM.On (void); { enque16(nqw_Cmd_LOWER_ECAM_ON_OFF,DISPLAY_ON, FSMAPPER); } // Lower ECAM off void Joystick_10.b_LOWER_ECAM.Off (void); { enque16(nqw_Cmd_LOWER_ECAM_ON_OFF,DISPLAY_OFF, FSMAPPER); } //----------------------------------------------------------------------------------------- // Engine Start switch panel //----------------------------------------------------------------------------------------- void Joystick_11.b_ENG_1_STARTER.On (void); { enque16(nqw_Cmd_Buttons_00,M2R8B0, FSMAPPER); } void Joystick_11.b_ENG_1_STARTER.Off (void); { enque16(nqw_Cmd_Buttons_00,M2R8B0, FSMAPPER); } void Joystick_11.b_ENG_2_STARTER.On (void); { enque16(nqw_Cmd_Buttons_00,M2R8B1, FSMAPPER);} void Joystick_11.b_ENG_2_STARTER.Off (void); { enque16(nqw_Cmd_Buttons_00,M2R8B1, FSMAPPER); } void Joystick_11.b_ENG_3_STARTER.On (void); { enque16(nqw_Cmd_Buttons_00,M2R8B2, FSMAPPER); } void Joystick_11.b_ENG_3_STARTER.Off (void); { enque16(nqw_Cmd_Buttons_00,M2R8B2, FSMAPPER); } void Joystick_11.b_ENG_4_STARTER.On (void); { enque16(nqw_Cmd_Buttons_00,M2R8B3, FSMAPPER); } void Joystick_11.b_ENG_4_STARTER.Off (void); { enque16(nqw_Cmd_Buttons_00,M2R8B3, FSMAPPER); } void Joystick_11.b_ENG_NORM.On (void); { enque16(nqw_Cmd_EngStartSwitch,ENG_START_SWITCH_NORM, FSMAPPER); } void Joystick_11.b_ENG_NORM.Off (void); { } void Joystick_11.b_ENG_IGN_START.On (void); { enque16(nqw_Cmd_EngStartSwitch,ENG_START_SWITCH_START, FSMAPPER); } void Joystick_11.b_ENG_IGN_START.Off (void); { } void Joystick_11.b_ENG_CRANK.On (void); { enque16(nqw_Cmd_EngStartSwitch,ENG_START_SWITCH_CRANK, FSMAPPER); } void Joystick_11.b_ENG_CRANK.Off (void); { } //----------------------------------------------------------------------------------------- // CPT loudspeaker panel //----------------------------------------------------------------------------------------- void Joystick_11.b_LDSPKR_CPT_ON_OFF.On (void); { } void Joystick_11.b_LDSPKR_CPT_ON_OFF.Off (void); { } //----------------------------------------------------------------------------------------- // CPT EFIS-DMC panel //----------------------------------------------------------------------------------------- void Joystick_11.b_CPT_EFIS_DMC_2.On (void); { } void Joystick_11.b_CPT_EFIS_DMC_2.Off (void); { } void Joystick_11.b_CPT_EFIS_DMC_3.On (void); { } void Joystick_11.b_CPT_EFIS_DMC_3.Off (void); { } void Joystick_11.b_CPT_EFIS_DMC_NORM.On (void); { } void Joystick_11.b_CPT_EFIS_DMC_NORM.Off (void); { } void Joystick_11.b_CPT_PFD_ND_SWAP.On (void); { } void Joystick_11.b_CPT_PFD_ND_SWAP.Off (void); { } void Joystick_11.b_CPT_ND_ON_OFF.On (void); { enque16(nqw_Cmd_CPT_ND_ON_OFF,DISPLAY_ON, FSMAPPER); } void Joystick_11.b_CPT_ND_ON_OFF.Off (void); { enque16(nqw_Cmd_CPT_ND_ON_OFF,DISPLAY_OFF, FSMAPPER); } void Joystick_11.b_CPT_PFD_ON_OFF.On (void); { enque16(nqw_Cmd_CPT_PFD_ON_OFF,DISPLAY_ON, FSMAPPER); } void Joystick_11.b_CPT_PFD_ON_OFF.Off (void); { enque16(nqw_Cmd_CPT_PFD_ON_OFF,DISPLAY_OFF, FSMAPPER); } //----------------------------------------------------------------------------------------- // FO loudspeaker panel //----------------------------------------------------------------------------------------- void Joystick_11.b_LDSPKR_FO_ON_OFF.On (void); { } void Joystick_11.b_LDSPKR_FO_ON_OFF.Off (void); { } //----------------------------------------------------------------------------------------- // FO EFIS-DMC panel //----------------------------------------------------------------------------------------- void Joystick_11.b_FO_EFIS_DMC_1.On (void); { } void Joystick_11.b_FO_EFIS_DMC_1.Off (void); { } void Joystick_11.b_FO_EFIS_DMC_3.On (void); { } void Joystick_11.b_FO_EFIS_DMC_3.Off (void); { } void Joystick_11.b_FO_EFIS_DMC_NORM.On (void); { } void Joystick_11.b_FO_EFIS_DMC_NORM.Off (void); { } void Joystick_11.b_FO_PFD_ND_SWAP.On (void); { } void Joystick_11.b_FO_PFD_ND_SWAP.Off (void); { } void Joystick_11.b_FO_ND_ON_OFF.On (void); { enque16(nqw_Cmd_FO_ND_ON_OFF,DISPLAY_ON, FSMAPPER); } void Joystick_11.b_FO_ND_ON_OFF.Off (void); { enque16(nqw_Cmd_FO_ND_ON_OFF,DISPLAY_OFF, FSMAPPER); } void Joystick_11.b_FO_PFD_ON_OFF.On (void); { enque16(nqw_Cmd_FO_PFD_ON_OFF,DISPLAY_ON, FSMAPPER); } void Joystick_11.b_FO_PFD_ON_OFF.Off (void); { enque16(nqw_Cmd_FO_PFD_ON_OFF,DISPLAY_OFF, FSMAPPER); } //----------------------------------------------------------------------------------------- // Weather radar panel //----------------------------------------------------------------------------------------- void Joystick_11.b_WXR_SYS1.On (void); { jump(l_WXR_SYS_On); } void Joystick_11.b_WXR_SYS1.Off (void); { jump(l_WXR_SYS_Off); } void Joystick_11.b_WXR_SYS2.On (void); { jump(l_WXR_SYS_On); } void Joystick_11.b_WXR_SYS2.Off (void); { jump(l_WXR_SYS_Off); } //Weather radar modes void Joystick_11.b_WXR_WX.On (void); { // wrd_WXR_Mode = WXR_SYS1_WX; wrd_WXR_Mode = wrd_WXR_Mode & WXR_SYS1_WX; jump(l_WXR_Mode); } void Joystick_11.b_WXR_WX_TURB.On (void); { // wrd_WXR_Mode = WXR_SYS1_WX_TURB; wrd_WXR_Mode = wrd_WXR_Mode & WXR_SYS1_WX_TURB; jump(l_WXR_Mode); } void Joystick_11.b_WXR_MAP.On (void); { // wrd_WXR_Mode = WXR_SYS1_MAP; wrd_WXR_Mode = wrd_WXR_Mode & WXR_SYS1_MAP; jump(l_WXR_Mode); } /* void Joystick_11.b_WXR_GAIN_ON_OFF.On (void); { //enque16(nqw_Cmd_WXR, DISPLAY_OFF, FSMAPPER); } void Joystick_11.b_WXR_GAIN_ON_OFF.Off (void); { //enque16(nqw_Cmd_WXR,DISPLAY_OFF, FSMAPPER); } */ void l_WXR_SYS_On (void) { // send WXR start command and weather radar display on to PM PFD for CPT and FO f_WXR_SYS_On = true; if (Joystick_11.b_WXR_WX) { // wrd_WXR_Mode = WXR_SYS1_WX; wrd_WXR_Mode = wrd_WXR_Mode | WXR_SYS1_WX; call(l_WXR_Mode); } else { if (Joystick_11.b_WXR_WX_TURB) { // wrd_WXR_Mode = WXR_SYS1_WX_TURB; wrd_WXR_Mode = wrd_WXR_Mode | WXR_SYS1_WX_TURB; call(l_WXR_Mode); } else { // wrd_WXR_Mode = WXR_SYS1_MAP; wrd_WXR_Mode = wrd_WXR_Mode | WXR_SYS1_MAP; call(l_WXR_Mode); } } wrd_Offset_4f4_Data = WXR_Show; call(l_ND_Modes); wrd_Offset_4f4_Data = WXR_Show + ND_MODE_CP; jump(l_ND_Modes); } void l_WXR_Mode (void) { // Only change mode if the WXR is switched on if (f_WXR_SYS_On) { enque16(nqw_Cmd_WXR, wrd_WXR_Mode, FSMAPPER); } } void l_WXR_SYS_Off (void) { f_WXR_SYS_On = false; enque16(nqw_Cmd_WXR, WXR_OFF, FSMAPPER); wrd_Offset_4f4_Data = WXR_Hide; call(l_ND_Modes); wrd_Offset_4f4_Data = WXR_Hide + ND_MODE_CP; jump(l_ND_Modes); } //----------------------------------------------------------------------------------------- // ATC / XPDR panel. As there is no separate ATC/XPDR software or panel available, // the buttons on the ATC panel only show or hide the traffic in the PM GC //----------------------------------------------------------------------------------------- void Joystick_12.b_ATC_Ident.On (void); { jump(l_ATC_Ident_On); } void Joystick_12.b_ATC_Ident.Off (void); { jump(l_ATC_Ident_Off); } void Joystick_12.b_ATC_SYS2.On (void); { jump(l_ATC_SYS_On); } void Joystick_12.b_ATC_SYS2.Off (void); { jump(l_ATC_SYS_Off); } void Joystick_12.b_ATC_SYS1.On (void); { jump(l_ATC_SYS_On); } void Joystick_12.b_ATC_SYS1.Off (void); { jump(l_ATC_SYS_Off); } void Joystick_12.b_TCAS_Below.On (void); { } void Joystick_12.b_TCAS_Below.Off (void); { } void Joystick_12.b_TCAS_Above.On (void); { } void Joystick_12.b_TCAS_Above.Off (void); { } void Joystick_12.b_TCAS_Mode_TFC.On (void); { if (f_TCAS_On) { wrd_Offset_4f4_Data = TCAS_On; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_On + ND_MODE_CP; jump(l_ND_Modes); } } void Joystick_12.b_TCAS_Mode_TFC.Off (void); { //jump(l_ATC_SYS_Off); } void Joystick_12.b_TCAS_Mode_TA_RA.On (void); { if (f_TCAS_On) { wrd_Offset_4f4_Data = TCAS_All; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_All + ND_MODE_CP; jump(l_ND_Modes); } } void Joystick_12.b_TCAS_Mode_TA_RA.Off (void); { //jump(l_ATC_SYS_Off); } void Joystick_12.b_TCAS_Mode_TA.On (void); { if (f_TCAS_On) { wrd_Offset_4f4_Data = TCAS_All; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_All + ND_MODE_CP; jump(l_ND_Modes); } } void Joystick_12.b_TCAS_Mode_TA.Off (void); { //jump(l_ATC_SYS_Off); } void Joystick_12.b_TCAS_Mode_DEACT.On (void); { jump(l_ATC_SYS_Off); } void Joystick_12.b_TCAS_Mode_DEACT.Off (void); { jump(l_ATC_SYS_On); } void Joystick_12.b_TCAS_Mode_STBY.On (void); { } void Joystick_12.b_TCAS_Mode_STBY.Off (void); { } void Joystick_12.b_TCAS_Mode_XPDR.On (void); { } //============================================================================== // Overhead panels buttons //============================================================================== //------------------------------------------------------------------------------ // Strobe is off when strobe button is on //------------------------------------------------------------------------------ void Joystick_12.b_StrobeOff.On (void); { enque16(nqw_Cmd_Strobe, STROBE_ON, FSMAPPER); enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_ON, FSMAPPER); } void Joystick_12.b_StrobeOff.Off (void); { enque16(nqw_Cmd_Strobe, STROBE_OFF, FSMAPPER); enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_OFF, FSMAPPER); } //------------------------------------------------------------------------------ // Strobe is off when strobe button is on //------------------------------------------------------------------------------ void Joystick_12.b_LandingLights.On (void); { enque16(nqw_Cmd_Buttons_00, e_LandLightsL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsR, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsOutL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsOutR, FSMAPPER); } void Joystick_12.b_LandingLights.Off (void); { enque16(nqw_Cmd_Buttons_00, e_LandLightsL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsR, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsOutL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_LandLightsOutR, FSMAPPER); } //------------------------------------------------------------------------------ // Beacon //------------------------------------------------------------------------------ void Joystick_12.b_Beacon.On (void); { enque16(nqw_Cmd_Buttons_00, e_Beacon, FSMAPPER); } void Joystick_12.b_Beacon.Off (void); { enque16(nqw_Cmd_Buttons_00, e_Beacon, FSMAPPER); } //------------------------------------------------------------------------------ // Wing lights //------------------------------------------------------------------------------ void Joystick_12.b_WingLights.On (void); { enque16(nqw_Cmd_Buttons_00, e_WingLight, FSMAPPER); } void Joystick_12.b_WingLights.Off (void); { enque16(nqw_Cmd_Buttons_00, e_WingLight, FSMAPPER); } //------------------------------------------------------------------------------ // Nav logo // Nav logo off (when button on, when off -> AUTO) // Nav logo on (when button on, when off -> AUTO) //------------------------------------------------------------------------------ void Joystick_12.b_NavLogoOff.On (void); { enque16(nqw_Cmd_Buttons_00, e_LogoLight, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_NavLight, FSMAPPER); } void Joystick_12.b_NavLogoOff.Off (void); { } void Joystick_12.b_NavLogoOn.On (void); { enque16(nqw_Cmd_Buttons_00, e_LogoLight, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_NavLight, FSMAPPER); } void Joystick_12.b_NavLogoOn.Off (void); { } //------------------------------------------------------------------------------ // Runway turnoff lights //------------------------------------------------------------------------------ void Joystick_12.b_RwyTurnOff.On (void); { enque16(nqw_Cmd_Buttons_00, e_RwyTurnOffL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_RwyTurnOffR, FSMAPPER); } void Joystick_12.b_RwyTurnOff.Off (void); { enque16(nqw_Cmd_Buttons_00, e_RwyTurnOffL, FSMAPPER); enque16(nqw_Cmd_Buttons_00, e_RwyTurnOffR, FSMAPPER); } //------------------------------------------------------------------------------ // Nose wheel lights // Nose light off (when button on, when off -> TAXI) // Nose light T.O. (when button on, when off-> TAXI) //------------------------------------------------------------------------------ void Joystick_12.b_NoseLightTaxi.On (void); { enque16(nqw_Cmd_Buttons_00, e_TaxiLight, FSMAPPER); // switch on Taxi light (on nose wheel) } void Joystick_12.b_NoseLightTaxi.Off (void); { enque16(nqw_Cmd_Buttons_00, e_TaxiLight, FSMAPPER); // switch off Taxi light (on nose wheel) } void Joystick_12.b_NoseLightTO.On (void); { enque16(nqw_Cmd_Buttons_00, e_NoseLightTO, FSMAPPER); // switch on nose light ZO } void Joystick_12.b_NoseLightTO.Off (void); { enque16(nqw_Cmd_Buttons_00, e_NoseLightTO, FSMAPPER); // switch off nose light TO } //------------------------------------------------------------------------------ // APU master switch (momentary switch //------------------------------------------------------------------------------ void Joystick_12.b_ApuMaster.On (void); { enque16(nqw_Cmd_Buttons_00, e_APUMaster, FSMAPPER); } //------------------------------------------------------------------------------ // APU start switch (momentary switch // APU has status ON (value 1) when the APU master switch is set to ON //------------------------------------------------------------------------------ void Joystick_12.b_ApuStart.On (void); { if (wrd_APU_Status == APU_STATUS_ON) { enque16(nqw_Cmd_APU_Start, APU_STATUS_ON, FSMAPPER); } if (wrd_APU_Status == APU_STATUS_COOLING) { enque16(nqw_Cmd_APU_Start, APU_STATUS_OFF, FSMAPPER); } } //------------------------------------------------------------------------------ // Seat belts sign // seat belts off (when button on, when off -> AUTO) // seat belts on (when button on, when off -> AUTO) //------------------------------------------------------------------------------ void Joystick_12.b_SeatBeltsSignOff.On (void); { enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_OFF, FSMAPPER); } void Joystick_12.b_SeatBeltsSignOff.Off (void); { enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_AUTO, FSMAPPER); } void Joystick_12.b_SeatBeltsSignOn.On (void); { enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_ON, FSMAPPER); } void Joystick_12.b_SeatBeltsSignOn.Off (void); { enque16(nqw_Cmd_SeatBeltSign, SEAT_BELT_AUTO, FSMAPPER); } //------------------------------------------------------------------------------ // No smoking sign // no smoking off (when button on, when off -> AUTO) // no smoking on (when button on, when off -> AUTO) //------------------------------------------------------------------------------ void Joystick_12.b_NoSmokingSignOff.On (void); { enque16(nqw_Cmd_NoSmokingSign, NO_SMOKING_OFF, FSMAPPER); } void Joystick_12.b_NoSmokingSignOff.Off (void); { enque16(nqw_Cmd_NoSmokingSign, NO_SMOKING_AUTO, FSMAPPER); } void Joystick_12.b_NoSmokingSignOn.On (void); { enque16(nqw_Cmd_NoSmokingSign, NO_SMOKING_ON, FSMAPPER); } void Joystick_12.b_NoSmokingSignOn.Off (void); { enque16(nqw_Cmd_NoSmokingSign, NO_SMOKING_AUTO, FSMAPPER); } //------------------------------------------------------------------------------ // Annunciator lights // Annunciator light Bright off = dim // Annunciator light Test off = bright //------------------------------------------------------------------------------ void Joystick_12.b_AnnLight_Bright.On (void) { // no action so far } void Joystick_12.b_AnnLight_Bright.Off (void) { // no action so far } void Joystick_12.b_AnnLight_Test.On (void) { // light up all LEDs and displays LEDs.LEDs_0 = on; LEDs.LEDs_1 = on; LEDs.LEDs_2 = on; LEDs.LEDs_3 = on; LEDs.LEDs_4 = on; LEDs.LEDs_5 = on; LEDs.LEDs_6 = on; LEDs.LEDs_7 = on; Display.disp_ALT_000 =888; Display.disp_ALT_00 =88; Display.disp_MACH_blank =8.; Display.disp_MACH =88; Display.disp_VS =8888; Display.disp_sign_VS =8; Display.disp_HDG =888; Display.disp_BaroInHg_CP =88.88; Display.disp_BaroInHg_P =88.88; Display.disp_XPDR =8888; Display.disp_RudTrimPos =8.88; Display.disp_RudTrimPos_LR =888; Display.disp_VHF1stby_d =88; Display.disp_VHF1stby_h =888.; Display.disp_VHF1act =888.88; Display.disp_VHF2act =888.88; Display.disp_VHF2stby_d =88; Display.disp_VHF2stby_h =888.; } void Joystick_12.b_AnnLight_Test.Off (void) { // restore the annunciator light status call(l_COM_Disp); call(l_XPDR_Disp); call(l_LdgGearNose_Status); call(l_LdgGearLeft_Status); call(l_LdgGearRight_Status); call(l_HDG_Disp); call(l_ALT_Disp); call(l_SPD_MACH_Disp); call(l_VS_Disp); call(l_Baro_Disp_P); call(l_Baro_Disp_CP); LEDs.LEDs_0 = off; LEDs.LEDs_1 = off; LEDs.LEDs_2 = off; LEDs.LEDs_3 = off; LEDs.LEDs_4 = off; LEDs.LEDs_5 = off; LEDs.LEDs_6 = off; LEDs.LEDs_7 = off; // switch back to annunciator lights bright jump(Joystick_12.b_AnnLight_Bright.On); } //============================================================================= // Pigeon Holes //============================================================================= //============================================================================= // Pigeon Hole procedures (receive Data from FS into EPIC Variables) // byte and word elements can be mixed & appear in any order as long // as the total structure size doesn't exceed four (4) bytes. // examples: // ph1 (ph#) // byte byte0; // byte byte1; // byte byte2; // byte byte3; // // ph1 (ph#) // word word1; // byte byte0; // byte byte1; // etc. //============================================================================= //---------- VHF1, VHF2 ------------------------------------------------------- ph ph_VHF1 (1) { // pigeon hole elements word word0; word word1; // Set VHF1 frequency bcd_VHF1act = ph_VHF1.word1 + 10000; // get VHF 1 frequency out of byte 1 (rightmost byte) // set the fixed part of the display -> + 10000; jump(l_COM_Disp); }; //---------- VOR1 /ILS (no separate ILS frequency available in FS) --------- ph ph_VOR1freq (2) { // pigeon hole elements byte byte0; byte byte1; // Set VOR1 frequency rvar_VOR1freq_d = ph_VOR1freq.byte1; // get decimals value (PH 02) rvar_VOR1freq_h = ph_VOR1freq.byte0; // get hundreds value (PH 02) rvar_VOR1freq_h = rvar_VOR1freq_h + 100; // set the fixed part of the display jump(l_COM_Disp); }; //---------- ADF1 (in fact only 1 ADF is available) ------------------------ // extended ADF frequency. Word1 contains the 1000's digit and the fraction // value. So, for a frequency of 1234.5 this offset will // contain 0x0105. // To get the thousand part of the decimal number (I am using the BCD2DEC // conversion function in FSMAPPER for this Pigeon Hole value) // a division by 100 (to eliminate the ones and tens) and afterwards // a multiplication by 1000 (to get the thousand value) is performed. // // The fraction part is extracted by subtracting the thousands part from // the upper part of the value. // // example: // Value in Pigeon hole is 0109 -> this corresponds to 1xxx.9 of the // extended ADF frequency. // Get the thousands part: // work = 109 div 100 = 1 -> eliminate the tens and ones // Thousands = 1 * 1000 = 1000 // // The fraction part of the ADF frequency is extracted by subtracting the // hundred parts from the whole pigeon hole value: // work = 109 div 100 = 1 -> eliminate the tens and ones // hundreds = 1 * 100 = 100 // fraction part = pigeon hole value - hundreds = 109 - 100 = 9 //-------------------------------------------------------------------------- ph ph_ADF1ext (3) { // pigeon hole elements byte byte0; byte byte1; word word1; // Set ADF1 frequency wrd_Work = ph_ADF1ext.word1 / 100; // extract thousands value wrd_Work = wrd_Work * 100; wrd_ADF1act_fraction = ph_ADF1ext.word1 - wrd_Work; // get fraction value (PH 03) wrd_ADF1act_thousands = wrd_Work * 10; jump(l_ADFfreq_Set); }; //---------- ADF1 (in fact only 1 ADF is available) ------------------------ // ADF frequency. main 3 digits, in binary coded decimal. // A frequency of 1234.5 will have 0x0234 here and 0x0105 in offset 0356 // (PH 3) //-------------------------------------------------------------------------- ph ph_ADF1main (4) { // pigeon hole elements byte byte0; byte byte1; word word1; // Set ADF1 frequency wrd_ADF1act = ph_ADF1main.word1; // get ADF frequency jump(l_ADFfreq_Set); }; //---------- prepare ADF1 frequency for display ---------------------------- // byt_ADF1act_Thousands contains the thousands fraction of the extended // ADF frequency. e.g. 1000 // byt_ADF1act_fraction contains the fraction of the extended ADF frequency // (the digit to the right of the decimal point) // wrd_ADF1act contains the main part of the ADF frequency // This values are added together and moved to a bcd variable. //-------------------------------------------------------------------------- void l_ADFfreq_Set (void) { wrd_Work = wrd_ADF1act_thousands + wrd_ADF1act; wrd_Work = wrd_Work * 10; wrd_Work = wrd_Work + wrd_ADF1act_fraction; bcd_ADF1act = wrd_Work; jump(l_COM_Disp); } //---------- Transponder ------------------------------------------------------ ph ph_XPDR (5) { // pigeon hole elements word word0; word word1; wrd_XPDR = ph_XPDR.word0 * 100; wrd_XPDR = wrd_XPDR + ph_XPDR.word1; jump(l_XPDR_Disp); }; //---------- Rudder Trim Data ------------------------------------------------ ph ph_Trim (6) { // pigeon hole elements //byte byte0; //byte byte1; word word0; word word1; // Set Rudder Trim position display wrd_RudTrimPos = ph_Trim.word0; jump(l_RudTrimPos_Disp); }; //---------- Nose Gear Position ----------------------------------------------- // As there is no center gear in FS, I am handling the A340 center gear together // with the nose gear. To add a bit more of realism, I am using a random number // to delay the landing gear display. //----------------------------------------------------------------------------- ph ph_LdgGearNose (7) { // pigeon hole elements word word0; word word1; // Set Gear position variable wrd_LdgGearNose = ph_LdgGearNose.word1; jump(l_LdgGearNose_Status); }; //---------- Left Gear Position ----------------------------------------------- ph ph_LdgGearLeft (8) { // pigeon hole elements word word0; word word1; // Set Gear position variable wrd_LdgGearLeft = ph_LdgGearLeft.word1; jump(l_LdgGearLeft_Status); }; //---------- Right Gear Position ---------------------------------------------- ph ph_LdgGearRight(9) { // pigeon hole elements word word0; word word1; // Set Gear position variable wrd_LdgGearRight = ph_LdgGearRight.word1; jump(l_LdgGearRight_Status); }; //---------- Elevator trim position (-16383 to +16383) ------------------------ ph ph_ElevTrimPos(10) { // pigeon hole elements word word0; word word1; // Set Elevatro Trim position variable wrd_ElevTrimPos = ph_ElevTrimPos.word0; Display.disp_ElevTrimPos = wrd_ElevTrimPos; // display the elevator trim position }; //---------- Joystick_02 Heading setting update ------------------------------- ph ph_HDG (15) { // pigeon hole elements byte byte0; byte byte1; word word1; rvar_HDG = ph_HDG.word1; jump(l_HDG_Disp); }; //-------------------------------------------------------------------------- // Altitude //-------------------------------------------------------------------------- ph ph_ALT (16) { // pigeon hole elements byte byte0; byte byte1; word word1; rvar_ALT = ph_ALT.word1; jump(l_ALT_Disp); }; //---------- Speed (knots) update --------------------------------------------- // -1 (FFFF) in bytes 2 and 3 and 255 (FF) in byte 0 indicate that // the display should be dashed // PH 0x11 -> 17d //----------------------------------------------------------------------------- ph ph_SPD (17) { // pigeon hole elements byte byte0; byte byte1; word word1; rvar_SPD = ph_SPD.word1; // set the rvar_SPD variable jump(l_SPD_MACH_Disp); }; //---------- Speed (mach) update ---------------------------------------------- // SPD digits are digits 7,6,5 from row 0 of the first display module. // The digit to blank out when enabling MACH display is digit 7. // 0x7F = b01111111 than means: // 0 -> enables decimal point for digit // 111 -> digit 7 // 1111 -> Value to send to digit 7 (b1111 = 0xF -> blank out display) // PH 0x12 -> 18d //----------------------------------------------------------------------------- ph ph_MACH (18) { // pigeon hole elements byte byte0; byte byte1; word word1; rvar_MACH = ph_MACH.word1; // set the rvar_MACH variable jump(l_SPD_MACH_Disp); }; //-------------------------------------------------------------------------- // Vertical Speed // Byte0 and byte1 contain the absolute value (unsigned). Bytes 2-3 contain // a 16 bit (word) value in normal Intel lo-hi form. This value may be // negative, but in this case contains the absolute value with 32768 // (hexadecimal 8000) added. To test for negativeness, see if byte 2 is // 128 or greater. Intended values can therefore range from -32767 to // +32767, or 0 to 65535, depending wether negatives are used or not. // This value is always present even if byte 0 = 255, indicating an // invalid value. // //-------------------------------------------------------------------------- ph ph_VS (19) { // pigeon hole elements byte byte0; byte byte1; word word1; // signed value wrd_VS = ph_VS.word1; wrd_FPA = ph_VS.word1; jump(l_VS_Disp); }; //-------------------------------------------------------------------------- // VOR1 crs display //-------------------------------------------------------------------------- ph ph_VOR1crs (47) { // pigeon hole elements byte byte0; // absolute value byte byte1; word word1; // signed value wrd_VOR1crs = ph_VOR1crs.word1; jump(l_COM_Disp); }; //-------------------------------------------------------------------------- // VOR2 crs display //-------------------------------------------------------------------------- ph ph_VOR2crs (50) { // pigeon hole elements byte byte0; // absolute value byte byte1; word word1; wrd_VOR1crs = ph_VOR2crs.word1; jump(l_COM_Disp); }; //-------------------------------------------------------------------------- // Baro setting in mb (hPa) // The value sent by FS has to be divided by 16. Why? No idea. //-------------------------------------------------------------------------- ph ph_Baro_hPa_P (51) { // pigeon hole elements byte byte0; byte byte1; word word1; wrd_Baro_P = ph_Baro_hPa_P.word1; jump(l_Baro_Disp_P); }; //-------------------------------------------------------------------------- // Baro setting in InHg //-------------------------------------------------------------------------- ph ph_Baro_InHg_P (52) { // pigeon hole elements byte byte0; byte byte1; word word1; wrd_Baro_InHg_P = ph_Baro_InHg_P.word1; jump(l_Baro_Disp_P); }; //-------------------------------------------------------------------------- // Baro setting in mb (hPa) // The value sent by FS has to be divided by 16. Why? No idea. Done in // mapping options of FSMapper //-------------------------------------------------------------------------- ph ph_Baro_hPa_CP (53) { // pigeon hole elements byte byte0; byte byte1; word word1; wrd_Baro_CP = ph_Baro_hPa_CP.word1; jump(l_Baro_Disp_CP); }; //-------------------------------------------------------------------------- // Baro setting in InHg //-------------------------------------------------------------------------- ph ph_Baro_InHg_CP (54) { // pigeon hole elements byte byte0; byte byte1; word word1; wrd_Baro_InHg_CP = ph_Baro_InHg_CP.word1; jump(l_Baro_Disp_CP); }; //-------------------------------------------------------------------------- // Autobrake //-------------------------------------------------------------------------- ph ph_Autobrake (57) { // pigeon hole elements word word0; word word1; wrd_Autobrake = ph_Autobrake.word1; jump(l_Autobrake_Status); }; //------------------------------------------------------------------------- // APU Status //------------------------------------------------------------------------- ph ph_APU_Status (58) { // pigeon hole elements byte byte0; byte byte1; word word1; wrd_APU_Status = ph_APU_Status.word1 & Mask_UpperByte; jump(l_APU_Status); }; //========================================================================= // Procedures //========================================================================= //========================================================================= // General procedure for handling pilot and co-pilot ND modes //========================================================================= //------------------------------------------------------------------------- // APU status check // When APU master off -> APU off (status off = 0) // press APU master button -> APU status = on (=1) light APU master on // press APU start button -> APU status = running (=2) light APU master on, start on (prov. flashing) // -> APU status = cooling (=3) light APU master on, start on // press APU master button -> APU status = shutdown (=4) light APU master off, start off // after a few seconds -> APU status = off (=0) light APU master off, start off //------------------------------------------------------------------------- void l_APU_Status (void) { switch(wrd_APU_Status) { case APU_STATUS_OFF: jump (l_APU_off); case APU_STATUS_ON: jump (l_APU_on); case APU_STATUS_RUNNING: jump (l_APU_running); case APU_STATUS_COOLING: jump (l_APU_cooling); case APU_STATUS_SHUTDOWN: jump (l_APU_shutdown); default: jump (l_APU_shutdown); } } void l_APU_off (void) { LEDs.LEDs_6.led_APU_Master = off; //byt_APU_Start_LED_Status = LED_OFF; //jump(l_APU_Start_Status); LEDs.LEDs_6.led_APU_Start = off; } void l_APU_on (void) { LEDs.LEDs_6.led_APU_Master = on; //byt_APU_Start_LED_Status = LED_OFF; //jump(l_APU_Start_Status); LEDs.LEDs_6.led_APU_Start = off; } void l_APU_running (void) { LEDs.LEDs_6.led_APU_Master = on; //byt_APU_Start_LED_Status = LED_FLASH_NORMAL; //jump(l_APU_Start_Status); LEDs.LEDs_6.led_APU_Start = on; //(flashing) } void l_APU_cooling (void) { LEDs.LEDs_6.led_APU_Master = on; //byt_APU_Start_LED_Status = LED_ON; //jump(l_APU_Start_Status); LEDs.LEDs_6.led_APU_Start = on; //------------------------------------------------------------------- // Provisory. Switch on APU Bleed before shuting down APU // Light the "AVAIL" Light on the APU start switch //------------------------------------------------------------------- enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void l_APU_shutdown (void) { //------------------------------------------------------------------- // Provisory. Switch off APU Bleed before shuting down APU //------------------------------------------------------------------- enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); LEDs.LEDs_6.led_APU_Master = off; //byt_APU_Start_LED_Status = LED_OFF; //jump(l_APU_Start_Status); LEDs.LEDs_6.led_APU_Start = off; } void l_APU_Start_Status (void) { //------------------------------------------------------------------- // set the led to on, flashing or off, depending on the APU status //------------------------------------------------------------------- switch (byt_APU_Start_LED_Status) { case LED_FLASH_NORMAL: LEDs.LEDs_6.led_APU_Start = on; //delay(LED_FLASH_NORMAL); // wait by LED_FLASH_NORMAL * 20msec case LED_FLASH_FAULT: LEDs.LEDs_6.led_APU_Start = on; //delay(LED_FLASH_FAULT); // wait by LED_FLASH_FAULT * 20msec case LED_ON: LEDs.LEDs_6.led_APU_Start = on; case LED_OFF: LEDs.LEDs_6.led_APU_Start = off; } /* if(byt_APU_Start_LED_Status == LED_FLASH_NORMAL) { if(LEDs.LEDs_6.led_APU_Start == off) { LEDs.LEDs_6.led_APU_Start = on; } else { LEDs.LEDs_6.led_APU_Start = off; } delay(LED_FLASH_NORMAL); jump(l_APU_Start_Status); } */ } //------------------------------------------------------------------------- // Navigation display modes //------------------------------------------------------------------------- void l_ND_Modes (void) { enque16(nqw_Cmd_ND_Modes, wrd_Offset_4f4_Data, FSMAPPER); } //------------------------------------------------------------------- // Toggle_CDU_Key // // If the same character is sent in sequence then the PM CDU requires // one bit to be different, otherwise the subsequent keypress isn't // detected. // I don't know why, but the "switch" statement doesn't work here. The // compilation is ok, but it never enters the Key_CTRL case // statement //------------------------------------------------------------------- void p_Toggle_Keyboard_Code (void) { //------------------------------------------------------------------------ // Check if the highest bit of the last sent keycode was set. If not, // set it, otherwise "unset" it. // Example: // wrd_KeyCode = 0000000001010100 -> T Key, 0x54 // Key_LEFTMOST_BIT = 1111100000000000 // ---------------- // wrd_BitToggle (AND) = 0000000000000000 -> 0, Bit was not set // // New KeyCode = (wrd_Key_ShiftState | Key_LEFTMOST_BIT) | byt_KeyCode // // wrd_Key_ShiftState = 0000000100000000 -> Shift Key // Key_LEFTMOST_BIT = 1111100000000000 // ---------------- // KeyCode = 1111100100000000 // // byt_KeyCode = 0000000001010100 // KeyCode = 1111100100000000 // ---------------- // KeyCode = 1111100101010100 -> value sent // //------------------------------------------------------------------------- wrd_BitToggle = wrd_KeyCode & Key_LEFTMOST_BIT; if (wrd_BitToggle == 0) { // Highest bit was not set, so set it now wrd_KeyCode = wrd_Key_ShiftState | Key_LEFTMOST_BIT; } else { // Highest bit was set, so "unset" it now wrd_KeyCode = wrd_Key_ShiftState | 0; } wrd_KeyCode = wrd_KeyCode | byt_KeyCode; enque16(wrd_Cmd_KeyCode, wrd_KeyCode, FSMAPPER); } //========================================================================= // TEST TEST TEST //========================================================================= void p_Toggle_Function_Code (void) { wrd_KeyCode = wrd_Key_ShiftState | byt_KeyCode; enque16(wrd_Cmd_KeyCode, wrd_KeyCode, FSMAPPER); } //========================================================================= //------------------------------------------------------------------------- // Nose/Center Landing Gear Status //------------------------------------------------------------------------- void l_LdgGearNose_Status (void) { switch(wrd_LdgGearNose) { case LDG_GEAR_UP: LEDs.LEDs_3.led_LdgGearNoseLock = off; LEDs.LEDs_3.led_LdgGearNoseUnlck = off; LEDs.LEDs_3.led_LdgGearCenterLock = off; // center landing gear LEDs.LEDs_3.led_LdgGearCenterUnlck = off; // center landing gear jump(l_All_AutoBrk_Off); // switch off autobrake when landing gear is retracting case LDG_GEAR_DOWN: LEDs.LEDs_3.led_LdgGearNoseLock = on; LEDs.LEDs_3.led_LdgGearCenterLock = on; // center landing gear LEDs.LEDs_3.led_LdgGearNoseUnlck = off; LEDs.LEDs_3.led_LdgGearCenterUnlck = off; // center landing gear default: LEDs.LEDs_3.led_LdgGearNoseLock = off; LEDs.LEDs_3.led_LdgGearNoseUnlck = on; LEDs.LEDs_3.led_LdgGearCenterLock = off; // center landing gear LEDs.LEDs_3.led_LdgGearCenterUnlck = on; // center landing gear } } //------------------------------------------------------------------------- // Left Landing Gear Status //------------------------------------------------------------------------- void l_LdgGearLeft_Status (void) { switch(wrd_LdgGearLeft) { case LDG_GEAR_UP: // Landing Gear up LEDs.LEDs_3.led_LdgGearLeftLock = off; LEDs.LEDs_3.led_LdgGearLeftUnlck = off; case LDG_GEAR_DOWN: // Landing Gear down LEDs.LEDs_3.led_LdgGearLeftLock = on; LEDs.LEDs_3.led_LdgGearLeftUnlck = off; default: LEDs.LEDs_3.led_LdgGearLeftLock = off; LEDs.LEDs_3.led_LdgGearLeftUnlck = on; } } //------------------------------------------------------------------------- // Right Landing Gear Status //------------------------------------------------------------------------- void l_LdgGearRight_Status (void) { switch(wrd_LdgGearRight) { case LDG_GEAR_UP: // Landing Gear up LEDs.LEDs_3.led_LdgGearRightLock = off; LEDs.LEDs_3.led_LdgGearRightUnlck = off; case LDG_GEAR_DOWN: // Landing Gear down LEDs.LEDs_3.led_LdgGearRightLock = on; LEDs.LEDs_3.led_LdgGearRightUnlck = off; default: // Landing gear in transition LEDs.LEDs_3.led_LdgGearRightLock = off; LEDs.LEDs_3.led_LdgGearRightUnlck = on; } } //------------------------------------------------------------------------- // Autobrake Status // length of value in FSUIPC offset 2F80 is 1. Therefor the upper byte // must be nulled to be able to compare the value to a constant. // example: // value in Offset 2F80 -> 01010100 00000001 // garbage value // AND 00000000 11111111 -> 255 // ----------------- // 00000000 00000001 -> clean word // ================= // // therefore the value from FS must be "ANDED" with value 255. The result // is a word containing the right value. //------------------------------------------------------------------------- void l_Autobrake_Status (void) { //switch (byt_Autobrake) switch (wrd_Autobrake & 255) { case AUTOBRAKE_0: jump(l_Autobrake_Off); case AUTOBRAKE_OFF: jump(l_Autobrake_Off); case AUTOBRAKE_LOW: jump(l_Autobrake_Low); case AUTOBRAKE_MED: jump(l_Autobrake_Med); case AUTOBRAKE_MAX: jump(l_Autobrake_Max); case AUTOBRAKE_4: jump(l_Autobrake_Max); default: jump(l_Autobrake_Off); } } void l_Autobrake_Low (void) { LEDs.LEDs_2.led_AutoBrakeLow = on; LEDs.LEDs_2.led_AutoBrakeMed = off; LEDs.LEDs_2.led_AutoBrakeMax = off; f_AutoBrk_Low_On = true; f_AutoBrk_Med_On = false; f_AutoBrk_Max_On = false; } void l_Autobrake_Med (void) { LEDs.LEDs_2.led_AutoBrakeLow = off; LEDs.LEDs_2.led_AutoBrakeMed = on; LEDs.LEDs_2.led_AutoBrakeMax = off; f_AutoBrk_Low_On = false; f_AutoBrk_Med_On = true; f_AutoBrk_Max_On = false; } void l_Autobrake_Max (void) { LEDs.LEDs_2.led_AutoBrakeLow = off; LEDs.LEDs_2.led_AutoBrakeMed = off; LEDs.LEDs_2.led_AutoBrakeMax = on; f_AutoBrk_Low_On = false; f_AutoBrk_Med_On = false; f_AutoBrk_Max_On = true; } void l_Autobrake_Off (void) { LEDs.LEDs_2.led_AutoBrakeLow = off; LEDs.LEDs_2.led_AutoBrakeMed = off; LEDs.LEDs_2.led_AutoBrakeMax = off; f_AutoBrk_Low_On = false; f_AutoBrk_Med_On = false; f_AutoBrk_Max_On = false; } //------------------------------------------------------------------------------ // turn off any active auto brake //------------------------------------------------------------------------------ void l_All_AutoBrk_Off (void) { if(f_AutoBrk_Low_On) { call(Joystick_00.b_AutoBrakeLow.On); } if(f_AutoBrk_Med_On) { call(Joystick_00.b_AutoBrakeMed.On); } if(f_AutoBrk_Max_On) { call(Joystick_00.b_AutoBrakeMax.On); } } //------------------------------------------------------------------------------ // ATC global routines //------------------------------------------------------------------------------ void l_ATC_Ident_On (void) { wrd_Offset_4f4_Data = TCAS_Callsign; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_Callsign + ND_MODE_CP; jump(l_ND_Modes); } void l_ATC_Ident_Off (void) { } void l_ATC_SYS_On (void) { f_TCAS_On = true; wrd_Offset_4f4_Data = TCAS_On; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_On + ND_MODE_CP; jump(l_ND_Modes); } void l_ATC_SYS_Off (void) { f_TCAS_On = false; wrd_Offset_4f4_Data = TCAS_Off; call(l_ND_Modes); wrd_Offset_4f4_Data = TCAS_Off + ND_MODE_CP; jump(l_ND_Modes); } //------------------------------------------------------------------------- // Display the HDG value on the 7 segment display. When in managed HDG // mode or invalid data, dashes are displayed. //------------------------------------------------------------------------- void l_HDG_Disp (void) { if (f_HDG_valid) { Display.disp_HDG = rvar_HDG; } else { Display.disp_HDG = dash; } } //------------------------------------------------------------------------- // Display the ALT value on the 7 segment display. When in managed ALT // a decimal point is shown (provisory, until the LED is build in). // As there is no //------------------------------------------------------------------------- void l_ALT_Disp (void) { if (f_ALT_valid) { //Display.disp_ALT_000 = wrd_ALT; Display.disp_ALT_00 = 0; } else { //Display.disp_ALT_mngd = wrd_ALT; //Display.disp_ALT_mngd = rvar_ALT; Display.disp_ALT_mngd = 0; } Display.disp_ALT_000 = rvar_ALT; } //------------------------------------------------------------------------- // Display the SPD or MACH value on the 7 segment display, depending // on which mode is active. If managed SPD, then dashes are displayed. //------------------------------------------------------------------------- void l_SPD_MACH_Disp (void) { if (f_SPD_valid) { if (f_SPD_Active) { Display.disp_SPD = rvar_SPD; } else { Display.disp_MACH_blank = blank; Display.disp_MACH = rvar_MACH; } } else { Display.disp_SPD = dash; } } //------------------------------------------------------------------------- // Handle vertical speed display // // If the leftmost bit of wrd_VS is 1, then the value is negative. This test // is performed by checking if the leftmost bit is set to 1. // value to test 0b10010100 11101101 // Neg. value mask 0b10000000 00000000 -> 0x8000 // AND both together 0b10000000 00000000 -> result is 0x8000 //------------------------------------------------------------------------- void l_VS_Disp (void) { if (f_VS_valid) { wrd_Test = wrd_VS & NEG_SIGN_BIT_MASK; if (f_FPA_Mode_On) { // check if FPA of VS is active. If FPA, then divide value // by 100, as FPA is delivered in hundreds wrd_Test = wrd_FPA & NEG_SIGN_BIT_MASK; bcd_FPA = wrd_FPA; Display.disp_FPA_BLANK = blank; if (wrd_Test == 0x8000) { Display.disp_sign_FPA = dash; wrd_FPA_tmp = 0 - wrd_FPA; bcd_FPA = wrd_FPA_tmp >> 2; Display.disp_FPA = bcd_FPA >> 2; } else { Display.disp_sign_FPA = blank; Display.disp_FPA = bcd_FPA >> 2; } } else { wrd_Test = wrd_VS & NEG_SIGN_BIT_MASK; if (wrd_Test == 0x8000) { Display.disp_sign_VS = dash; wrd_VS_tmp = 0 - wrd_VS; Display.disp_VS = wrd_VS_tmp; } else { Display.disp_sign_VS = blank; Display.disp_VS = wrd_VS; } } } else { Display.disp_VS = dash; Display.disp_sign_VS = dash; } } //---------- Baro display update --------------------------------------------- // Baro in hPa has the format xx.yy. wrd_Baro contains a integer which when // being sent to the display which is BCD, the int is converted to BCD and so // becomes 1234.00. Since the definition is 99.99 the 1234.00 is truncated to // 34.00. // The shift right (>>) is a decimal shift for BCD so this is equivalent to // dividing by 100. //---------------------------------------------------------------------------- void l_Baro_Disp_P (void) { wrd_Baro_hPa_P = wrd_Baro_P; bcd_Baro_InHg_P = wrd_Baro_InHg_P; // convert to bcd -> e.g. 2992 becomes 2992.00 if(Joystick_03.b_InHg_hPa_P) { Display.disp_BarohPa_P = wrd_Baro_hPa_P; // display with decimal point enabled } else { Display.disp_BaroInHg_P = bcd_Baro_InHg_P >> 2; // display with decimal point enabled, divide the bcd value by 100 to get 29.92 } } void l_Baro_Disp_CP (void) { wrd_Baro_hPa_CP = wrd_Baro_CP; bcd_Baro_InHg_CP = wrd_Baro_InHg_CP; // convert to bcd -> e.g. 2992 becomes 2992.00 if(Joystick_05.b_InHg_hPa_CP) { Display.disp_BarohPa_CP = wrd_Baro_hPa_CP; // display with decimal point disabled } else { Display.disp_BaroInHg_CP = bcd_Baro_InHg_CP >> 2; // display with decimal point enabled, divide the bcd value by 100 to get 29.92 } } //---------- COM display update ---------------------------------------------- // As FS only manages 1 COM radio, VHF1 and VHF2 active frequency is filled with the // same value. FS sends the COM frequency in the format xx.xx. The 1 for xx.xx has // to be "hard wired" (hard programmed in my case). The VHF1 display definitions are // used for selecting NAV frequencies and courses when in the NAV backup mode. // According to the mode enabled, different variables are sent to the displays. // When dialing VOR or ILS, the frequency is changed in the STANBY window. When // pressing the XFER key, the frequency is sent to the ACTIVE window and the course // can be selected in the STANDBY window. //---------------------------------------------------------------------------- void l_COM_Disp (void) { if(Joystick_09.b_RMP_OnOff_P) // if pilot side RMP is On { if(Joystick_09.b_RMP_NAV_P) // if RMP in NAV backup mode { jump(RMP_NAV_P); } else // if RMP in VHF mode { jump(RMP_VHF_P); } } } // --------- Stanby NAV displays update --------------------------------------- void RMP_NAV_P (void) { if(f_RMP_VOR_P) { #expand MakeDec16(bcd_VOR1freq, rvar_VOR1freq_h, rvar_VOR1freq_d) Display.disp_VHF1act = bcd_VOR1freq >> 2; if(f_RMP_Freq_P) // should frequency be modified? { Display.disp_VHF1stby_h = rvar_VOR1freq_h; Display.disp_VHF1stby_d = rvar_VOR1freq_d; } else // or should the course be modified? { Display.disp_VOR1crs = rvar_VOR1crs; } } if(f_RMP_ILS_P) { #expand MakeDec16(bcd_ILS1freq, rvar_ILS1freq_h, rvar_ILS1freq_d) Display.disp_VHF1act = bcd_ILS1freq >> 2; if(f_RMP_Freq_P) // should frequency be modified? { Display.disp_VHF1stby_h = rvar_ILS1freq_h; Display.disp_VHF1stby_d = rvar_ILS1freq_d; } else // or should the course be modified? { Display.disp_VOR1crs = rvar_ILS1crs; } } if(f_RMP_ADF_P) { Display.disp_ADF1act = bcd_ADF1act >> 1; Display.disp_ADF1stby_h = rvar_ADF1stby_h; Display.disp_ADF1stby_d = rvar_ADF1stby_d; } } // ---------- VHF displays update ---------------------------------------------- void RMP_VHF_P (void) { Display.disp_VHF1act = bcd_VHF1act >> 2; // set the display to the value sent by FS Display.disp_VHF2act = bcd_VHF2act >> 2; // set the display to the value sent by FS Display.disp_VHF1stby_d = rvar_VHF1stby_d; Display.disp_VHF1stby_h = rvar_VHF1stby_h; Display.disp_VHF2stby_d = rvar_VHF2stby_d; Display.disp_VHF2stby_h = rvar_VHF2stby_h; } //---------- display update ---------------------------------------------- void l_XPDR_Disp (void) { Display.disp_XPDR = wrd_XPDR; } //---------- Ruder Trim display update ---------------------------------------- // Ruder Trim display (3 digits and one L/R indicator //----------------------------------------------------------------------------- void l_RudTrimPos_Disp (void) { Display.disp_RudTrimPos = wrd_RudTrimPos; // display the rudder position Display.disp_RudTrimPos_LR = byt_RudTrimPos_LR; // display R/L letter } //----------------------------------------------------------------------------- // the fist lever which reaches the position defined to enable a AT function // enables that function. All other levers are then ignored. //----------------------------------------------------------------------------- void l_AT_Status (void) { switch (byt_AT_mode) { case IDLE: if (byt_AT_Status == IDLE) { } else { byt_AT_Status = IDLE; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_IDLE, FSMAPPER); } case CLB: if (byt_AT_Status == CLB) { } else { byt_AT_Status = CLB; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_CLB, FSMAPPER); } case FLEX_MCT: if (byt_AT_Status == FLEX_MCT) { } else { byt_AT_Status = FLEX_MCT; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_FLX_MCT, FSMAPPER); } case TOGA: if (byt_AT_Status == TOGA) { } else { byt_AT_Status = TOGA; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_TOGA, FSMAPPER); } case REV_IDLE: if (byt_AT_Status == REV_IDLE) { } else { byt_AT_Status = REV_IDLE; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_IDLEREV, FSMAPPER); } case REV_MAX: if (byt_AT_Status == REV_MAX) { } else { byt_AT_Status = REV_MAX; enque16(nqw_Cmd_ATHR_GATES, ATHR_GATE_MAXREV, FSMAPPER); } default: f_Dummy = true; } } //---------- Auto Thrust handling routines ------------------------------------ // Depending on the position of the throttles lever one of the following // procedures is called // byt_AT_Status -> //----------------------------------------------------------------------------- // Throttle 1 ------------------------------ void ATHR_IDLE_1 (void) { byt_AT_mode = IDLE; jump(l_AT_Status); } void ATHR_CLB_1 (void) { byt_AT_mode = CLB; jump(l_AT_Status); } void ATHR_FLEX_MCT_1 (void) { byt_AT_mode = FLEX_MCT; jump(l_AT_Status); } void ATHR_TOGA_1 (void) { byt_AT_mode = TOGA; jump(l_AT_Status); } void ATHR_REV_IDLE_1 (void) { byt_AT_mode = REV_IDLE; jump(l_AT_Status); } void ATHR_REV_MAX_1 (void) { byt_AT_mode = REV_MAX; jump(l_AT_Status); } // Throttle 2 ------------------------------ void ATHR_IDLE_2 (void) { byt_AT_mode = IDLE; jump(l_AT_Status); } void ATHR_CLB_2 (void) { byt_AT_mode = CLB; jump(l_AT_Status); } void ATHR_FLEX_MCT_2 (void) { byt_AT_mode = FLEX_MCT; jump(l_AT_Status); } void ATHR_TOGA_2 (void) { byt_AT_mode = TOGA; jump(l_AT_Status); } void ATHR_REV_IDLE_2 (void) { byt_AT_mode = REV_IDLE; jump(l_AT_Status); } void ATHR_REV_MAX_2 (void) { byt_AT_mode = REV_MAX; jump(l_AT_Status); } // Throttle 3 ------------------------------ void ATHR_IDLE_3 (void) { byt_AT_mode = IDLE; jump(l_AT_Status); } void ATHR_CLB_3 (void) { byt_AT_mode = CLB; jump(l_AT_Status); } void ATHR_FLEX_MCT_3 (void) { byt_AT_mode = FLEX_MCT; jump(l_AT_Status); } void ATHR_TOGA_3 (void) { byt_AT_mode = TOGA; jump(l_AT_Status); } void ATHR_REV_IDLE_3 (void) { byt_AT_mode = REV_IDLE; jump(l_AT_Status); } void ATHR_REV_MAX_3 (void) { byt_AT_mode = REV_MAX; jump(l_AT_Status); } // Throttle 4 ------------------------------ void ATHR_IDLE_4 (void) { byt_AT_mode = IDLE; jump(l_AT_Status); } void ATHR_CLB_4 (void) { byt_AT_mode = CLB; jump(l_AT_Status); } void ATHR_FLEX_MCT_4 (void) { byt_AT_mode = FLEX_MCT; jump(l_AT_Status); } void ATHR_TOGA_4 (void) { byt_AT_mode = TOGA; jump(l_AT_Status); } void ATHR_REV_IDLE_4 (void) { byt_AT_mode = REV_IDLE; jump(l_AT_Status); } void ATHR_REV_MAX_4 (void) { byt_AT_mode = REV_MAX; jump(l_AT_Status); } //============================================================================= // QProc Routines //============================================================================= void LS_P_On (void) { } void LS_P_Off (void) { } void THR_Off (void) { } void THR_On (void) { } void FD_Off (void) { // f_FD_P_On = false; } void FD_On (void) { // f_FD_P_On = true; } void AP1_On (void) { LEDs.LEDs_0.led_AP1 = on; } void AP1_Off (void) { LEDs.LEDs_0.led_AP1 = off; } void AP2_On (void) { LEDs.LEDs_0.led_AP2 = on; } void AP2_Off (void) { LEDs.LEDs_0.led_AP2 = off; } void AT_On (void) { LEDs.LEDs_0.led_AT = on; } void AT_Off (void) { LEDs.LEDs_0.led_AT = off; } void ALTHold_Off (void) { LEDs.LEDs_0.led_ALT = off; } void ALTHold_On (void) { LEDs.LEDs_0.led_ALT = on; } void LOC_Off (void) { LEDs.LEDs_0.led_LOC = off; } void LOC_On (void) { LEDs.LEDs_0.led_LOC = on; } void APP_Off (void) { LEDs.LEDs_0.led_APP = off; } void APP_On (void) { LEDs.LEDs_0.led_APP = on; } void SPD_Off (void) { // f_SPD_Active = false; // jump(l_SPD_MACH_Disp); } void SPD_On (void) { // f_SPD_Active = true; // jump(l_SPD_MACH_Disp); } void MACH_Off (void) { f_SPD_Active = true; jump(l_SPD_MACH_Disp); } void MACH_On (void) { f_SPD_Active = false; jump(l_SPD_MACH_Disp); } void Mngd_HDG_Off (void) { LEDs.LEDs_0.led_mngd_HDG = off; f_HDG_valid = true; jump(l_HDG_Disp); } void Mngd_HDG_On (void) { LEDs.LEDs_0.led_mngd_HDG = on; f_HDG_valid = false; jump(l_HDG_Disp); } void Mngd_ALT_Off (void) { LEDs.LEDs_1.led_mngd_ALT = off; f_ALT_valid = true; jump(l_ALT_Disp); } void Mngd_ALT_On (void) { LEDs.LEDs_1.led_mngd_ALT = on; f_ALT_valid = false; jump(l_ALT_Disp); } void Mngd_SPD_Off (void) { LEDs.LEDs_0.led_mngd_SPD = off; f_SPD_valid = true; jump(l_SPD_MACH_Disp); } void FPA_Off (void) { f_FPA_Mode_On = false; jump(l_VS_Disp); } void FPA_On (void) { f_FPA_Mode_On = true; jump(l_VS_Disp); } void Mngd_SPD_On (void) { LEDs.LEDs_0.led_mngd_SPD = on; f_SPD_valid = false; jump(l_SPD_MACH_Disp); } void WindShear_Off (void) { f_MastWarn = false; LEDs.LEDs_1.led_MastWarn_P = off; } void WindShear_On (void) { f_MastWarn = true; LEDs.LEDs_1.led_MastWarn_P = on; } void BelowGS_Off (void) { f_MastCaut = false; LEDs.LEDs_1.led_MastCaut_P = off; } void BelowGS_On (void) { f_MastCaut = true; LEDs.LEDs_1.led_MastCaut_P = on; } void MastCaut_Off (void) { f_MastCaut = false; LEDs.LEDs_1.led_MastCaut_P = off; } void MastCaut_On (void) { f_MastCaut = true; LEDs.LEDs_1.led_MastCaut_P = on; } void SPD_dashed_On (void) { f_SPD_valid = false; jump(l_SPD_MACH_Disp); } void SPD_dashed_Off (void) { f_SPD_valid = true; jump(l_SPD_MACH_Disp); } void StickPrio_TakeOver_P_On (void) { } void StickPrio_TakeOver_P_Off (void) { } void StickPrio_RedArrow_P_On (void) { LEDs.LEDs_1.led_StickPrio_RedArrow_P = on; } void StickPrio_RedArrow_P_Off (void) { LEDs.LEDs_1.led_StickPrio_RedArrow_P = off; } void StickPrio_TakeOver_CP_On (void) { } void StickPrio_TakeOver_CP_Off (void) { } void StickPrio_RedArrow_CP_On (void) { LEDs.LEDs_1.led_StickPrio_RedArrow_CP = on; } void StickPrio_RedArrow_CP_Off (void) { LEDs.LEDs_1.led_StickPrio_RedArrow_CP = off; } void HDG_dashed_On (void) { } void HDG_dashed_Off (void) { } void VS_dashed_On (void) { f_VS_valid = false; jump(l_VS_Disp); } void VS_dashed_Off (void) { f_VS_valid = true; jump(l_VS_Disp); } void MastWarn_Off (void) { f_MastWarn = false; LEDs.LEDs_1.led_MastWarn_P = off; } void MastWarn_On (void) { f_MastWarn = true; LEDs.LEDs_1.led_MastWarn_P = on; } //************************************************************************************ // Second expansion module procedures //************************************************************************************ void AIR_Panel.b_APU_Bleed.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_0.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_1.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_2.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_3.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_4.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_5.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_6.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_7.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_8.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_9.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_10.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_11.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_12.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_13.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_14.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_15.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_16.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_17.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_18.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_19.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_20.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_21.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); } void AIR_Panel.b_5_23.On (void) { enque16(nqw_Cmd_Buttons_00, e_APU_Bleed, FSMAPPER); }