Implemented missing channel invert, trim and endpoint menus

Saitek-X52-PPM.ino

 X52 x52(&usb, &hid);
 JoystickEventsCPPM joyCPPM;
 JoystickEventsButtons joyButtons(&x52, (JoystickEvents*)&joyCPPM);
-JoystickEventsDeadZone joyevents((JoystickEvents*)&joyButtons);
-JoystickReportParser joy(&joyevents);
+JoystickEventsDeadZone joyDeadZone((JoystickEvents*)&joyButtons);
+JoystickReportParser joy(&joyDeadZone);
 FrSky frsky(&Serial);
 
 void setup() {

events.h

     const static uint8_t centerMouseX, centerMouseY;
 };
 
+#define CHANNEL_ROLL 0
+#define CHANNEL_PITCH 1
+#define CHANNEL_THROTTLE 2
+#define CHANNEL_YAW 3
+#define CHANNEL_AUX1 4
+#define CHANNEL_AUX2 5
+
 class JoystickEventsCPPM : public JoystickEvents {
   public:
     JoystickEventsCPPM(JoystickEvents* client = 0);
     virtual void OnGamePadChanged(const GamePadEventData& evt);
 
+    uint8_t getInvert(uint8_t ch) {
+        if (ch < channels) return invert[ch];
+        else return 0;
+    }
+
+    void setInvert(uint8_t ch, uint8_t i) {
+        if (ch < channels) invert[ch] = i;
+    }
+
+    uint16_t getMinimum(uint8_t ch) {
+        if (ch < channels) return minimum[ch];
+        else return 0;
+    }
+
+    void setMinimum(uint8_t ch, uint16_t i) {
+        if (ch < channels) minimum[ch] = i;
+    }
+
+    uint16_t getMaximum(uint8_t ch) {
+        if (ch < channels) return maximum[ch];
+        else return 0;
+    }
+
+    void setMaximum(uint8_t ch, uint16_t i) {
+        if (ch < channels) maximum[ch] = i;
+    }
+
+    int16_t getTrim(uint8_t ch) {
+        if (ch < channels) return trim[ch];
+        else return 0;
+    }
+
+    void setTrim(uint8_t ch, int16_t i) {
+        if (ch < channels) trim[ch] = i;
+    }
+
   private:
+    uint16_t getJoystickAxis(const GamePadEventData& evt, uint8_t ch);
+    uint16_t getJoystickMax(uint8_t ch);
+
     const static uint8_t channels = 12;
     uint16_t values[channels];
+    uint8_t invert[channels];
+    uint16_t minimum[channels];
+    uint16_t maximum[channels];
+    int16_t trim[channels];
 };
 
 class JoystickEventsButtons : public JoystickEvents {
         EDIT_FRAME_LENGTH,
         EDIT_PULSE_LENGTH,
         EDIT_INVERT,
+        EDIT_MIN_ROLL,
+        EDIT_MAX_ROLL,
+        EDIT_MIN_PITCH,
+        EDIT_MAX_PITCH,
+        EDIT_MIN_YAW,
+        EDIT_MAX_YAW,
+        EDIT_MIN_THROTTLE,
+        EDIT_MAX_THROTTLE,
+        EDIT_MIN_AUX1,
+        EDIT_MAX_AUX1,
+        EDIT_MIN_AUX2,
+        EDIT_MAX_AUX2,
+        EDIT_INVERT_ROLL,
+        EDIT_INVERT_PITCH,
+        EDIT_INVERT_YAW,
+        EDIT_INVERT_THROTTLE,
+        EDIT_INVERT_AUX1,
+        EDIT_INVERT_AUX2,
+
+        STATES_EDIT_SIGNED,
+        EDIT_TRIM_ROLL,
+        EDIT_TRIM_PITCH,
+        EDIT_TRIM_YAW,
+        EDIT_TRIM_THROTTLE,
+        EDIT_TRIM_AUX1,
+        EDIT_TRIM_AUX2,
 
         STATES_MAX
     };
     void printMenu();
     void menuHelper(uint8_t count, const char** menu, const char* title);
     void printValue(uint16_t min, uint16_t max, const char* title);
+    void printSignedValue(int16_t min, int16_t max, const char* title);
 
     X52* x52;
     MenuState state;
     uint8_t index;
     uint16_t value;
+    int16_t signedValue;
     unsigned long menuTime;
 };
 
+extern JoystickEventsCPPM joyCPPM;
+extern JoystickEventsButtons joyButtons;
+extern JoystickEventsDeadZone joyDeadZone;
+
 #endif // __JOYSTICK_EVENTS_H__
 

events_buttons.cpp

 #define MODE_BUTTON_RED 25
 
 JoystickEventsButtons::JoystickEventsButtons(X52* x, JoystickEvents* client)
-        : JoystickEvents(client), x52(x), state(NONE), index(0), value(0), menuTime(0) { }
-
-void JoystickEventsButtons::menuHelper(uint8_t count, const char** menu, const char* title) {
-    if (index >= count) {
-        index = count - 1;
-    }
-
-    uint8_t start = 0, line = 0;
-    if (index > 1) {
-        start = index - 1;
-    }
-
-    uint8_t end = start + 2;
-    if (index == 0) {
-        x52->setMFDText(0, title);
-        line = 1;
-        end = start + 1;
-    }
-
-    if (end >= count) {
-        end = count - 1;
-    }
-
-    for (uint8_t i = start; i <= end; i++) {
-        String tmp = (index == i) ? "-> " : "   ";
-        x52->setMFDText(line++, (tmp + menu[i]).c_str());
-    }
-
-    if (line == 2) {
-        x52->setMFDText(2);
-    }
-
-#ifdef DEBUG_OUTPUT
-    Serial.print("menuHelper() state=");
-    Serial.print(state);
-    Serial.print(" index=");
-    Serial.print(index);
-    Serial.print(" start=");
-    Serial.print(start);
-    Serial.print(" end=");
-    Serial.println(end);
-#endif
-}
+        : JoystickEvents(client), x52(x), state(NONE), index(0),
+        value(0), signedValue(0), menuTime(0) { }
 
 void JoystickEventsButtons::printMenu() {
     static const char* mainMenu[] = {
     };
     static const uint8_t endpointMenuCount = sizeof(endpointMenu) / sizeof(endpointMenu[0]);
 
-    if (state == MAINMENU) {
+    if (state == NONE) {
+        x52->setMFDText(0, "Telemetry Status");
+        x52->setMFDText(1, "???%        ???%");
+        x52->setMFDText(2, "??.?V      ??.?V");
+    } else if (state == MAINMENU) {
         menuHelper(mainMenuCount, mainMenu, "Main Menu");
     } else if (state == CPPMMENU) {
         menuHelper(cppmMenuCount, cppmMenu, "CPPM Config Menu");
     } else if (state == INVERTAXISMENU) {
         menuHelper(axisMenuCount, axisMenu, "Invert Axis Menu");
     } else if (state == EDIT_CHANNELS) {
-        printValue(4, CHANNELS_MAX, mainMenu[0]);
+        printValue(4, CHANNELS_MAX, cppmMenu[0]);
     } else if (state == EDIT_FRAME_LENGTH) {
-        printValue(10000, 30000, mainMenu[1]);
+        printValue(10000, 30000, cppmMenu[1]);
     } else if (state == EDIT_PULSE_LENGTH) {
-        printValue(100, 1000, mainMenu[2]);
+        printValue(100, 1000, cppmMenu[2]);
     } else if (state == EDIT_INVERT) {
-        printValue(0, 1, mainMenu[3]);
+        printValue(0, 1, cppmMenu[3]);
+    } else if ((state >= EDIT_INVERT_ROLL) && (state <= EDIT_INVERT_AUX2)) {
+        uint8_t index = state - EDIT_INVERT_ROLL;
+        printValue(0, 1, (String("Invert ") + axisMenu[index]).c_str());
+    } else if ((state >= EDIT_MIN_ROLL) && (state <= EDIT_MAX_AUX2)) {
+        uint8_t index = state - EDIT_MIN_ROLL;
+        if (index & 0x01) {
+            printValue(1500, 2500, endpointMenu[index]);
+        } else {
+            printValue(500, 1500, endpointMenu[index]);
+        }
+    } else if ((state >= EDIT_TRIM_ROLL) && (state <= EDIT_TRIM_AUX2)) {
+        uint8_t index = state - EDIT_TRIM_ROLL;
+        printSignedValue(-100, 100, (String("Trim ") + axisMenu[index]).c_str());
     }
 
     menuTime = millis();
 }
 
-void JoystickEventsButtons::printValue(uint16_t min, uint16_t max, const char* title) {
-#ifdef DEBUG_OUTPUT
-    Serial.print("printValue() state=");
-    Serial.print(state);
-    Serial.print(" index=");
-    Serial.print(index);
-    Serial.print(" min=");
-    Serial.print(min);
-    Serial.print(" max=");
-    Serial.println(max);
-#endif
-
-    if (value < min) {
-        value = min;
-    }
-    if (value > max) {
-        value = max;
-    }
-
-    x52->setMFDText(0, (String(title) + ":").c_str());
-    x52->setMFDText(1, String(value).c_str());
-    x52->setMFDText(2, "Press OK to save");
-}
-
 void JoystickEventsButtons::OnButtonDown(uint8_t but_id) {
 #ifdef DEBUG_BUTTON_MFD
     String text = "Button " + String(but_id) + " down";
             if (index == 0) {
                 state = NONE;
             } else if (index == 1) {
-                //state = TRIMAXISMENU;
-                //index = 0;
+                state = TRIMAXISMENU;
+                index = 0;
             } else if (index == 2) {
-                //state = TRIMENDPOINTMENU;
-                //index = 0;
+                state = TRIMENDPOINTMENU;
+                index = 0;
             } else if (index == 3) {
-                //state = INVERTAXISMENU;
-                //index = 0;
+                state = INVERTAXISMENU;
+                index = 0;
             } else if (index == 4) {
                 state = CPPMMENU;
                 index = 0;
             }
         } else if (state == TRIMAXISMENU) {
             if (index == 0) {
+                state = EDIT_TRIM_ROLL;
+                signedValue = joyCPPM.getTrim(CHANNEL_ROLL);
             } else if (index == 1) {
+                state = EDIT_TRIM_PITCH;
+                signedValue = joyCPPM.getTrim(CHANNEL_PITCH);
             } else if (index == 2) {
+                state = EDIT_TRIM_YAW;
+                signedValue = joyCPPM.getTrim(CHANNEL_YAW);
             } else if (index == 3) {
+                state = EDIT_TRIM_THROTTLE;
+                signedValue = joyCPPM.getTrim(CHANNEL_THROTTLE);
             } else if (index == 4) {
+                state = EDIT_TRIM_AUX1;
+                signedValue = joyCPPM.getTrim(CHANNEL_AUX1);
             } else if (index == 5) {
+                state = EDIT_TRIM_AUX2;
+                signedValue = joyCPPM.getTrim(CHANNEL_AUX2);
             } else if (index == 6) {
                 state = MAINMENU;
                 index = 0;
             }
         } else if (state == TRIMENDPOINTMENU) {
             if (index == 0) {
+                state = EDIT_MIN_ROLL;
+                value = joyCPPM.getMinimum(CHANNEL_ROLL);
             } else if (index == 1) {
+                state = EDIT_MAX_ROLL;
+                value = joyCPPM.getMaximum(CHANNEL_ROLL);
             } else if (index == 2) {
+                state = EDIT_MIN_PITCH;
+                value = joyCPPM.getMinimum(CHANNEL_PITCH);
             } else if (index == 3) {
+                state = EDIT_MAX_PITCH;
+                value = joyCPPM.getMaximum(CHANNEL_PITCH);
             } else if (index == 4) {
+                state = EDIT_MIN_YAW;
+                value = joyCPPM.getMinimum(CHANNEL_YAW);
             } else if (index == 5) {
+                state = EDIT_MAX_YAW;
+                value = joyCPPM.getMaximum(CHANNEL_YAW);
             } else if (index == 6) {
+                state = EDIT_MIN_THROTTLE;
+                value = joyCPPM.getMinimum(CHANNEL_THROTTLE);
             } else if (index == 7) {
+                state = EDIT_MAX_THROTTLE;
+                value = joyCPPM.getMaximum(CHANNEL_THROTTLE);
             } else if (index == 8) {
+                state = EDIT_MIN_AUX1;
+                value = joyCPPM.getMinimum(CHANNEL_AUX1);
             } else if (index == 9) {
+                state = EDIT_MAX_AUX1;
+                value = joyCPPM.getMaximum(CHANNEL_AUX1);
             } else if (index == 10) {
+                state = EDIT_MIN_AUX2;
+                value = joyCPPM.getMinimum(CHANNEL_AUX2);
             } else if (index == 11) {
+                state = EDIT_MAX_AUX2;
+                value = joyCPPM.getMaximum(CHANNEL_AUX2);
             } else if (index == 12) {
+                state = EDIT_MIN_ROLL;
                 state = MAINMENU;
                 index = 0;
             }
         } else if (state == INVERTAXISMENU) {
             if (index == 0) {
+                state = EDIT_INVERT_ROLL;
+                value = joyCPPM.getInvert(CHANNEL_ROLL);
             } else if (index == 1) {
+                state = EDIT_INVERT_PITCH;
+                value = joyCPPM.getInvert(CHANNEL_PITCH);
             } else if (index == 2) {
+                state = EDIT_INVERT_YAW;
+                value = joyCPPM.getInvert(CHANNEL_YAW);
             } else if (index == 3) {
+                state = EDIT_INVERT_THROTTLE;
+                value = joyCPPM.getInvert(CHANNEL_THROTTLE);
             } else if (index == 4) {
+                state = EDIT_INVERT_AUX1;
+                value = joyCPPM.getInvert(CHANNEL_AUX1);
             } else if (index == 5) {
+                state = EDIT_INVERT_AUX2;
+                value = joyCPPM.getInvert(CHANNEL_AUX2);
             } else if (index == 6) {
                 state = MAINMENU;
                 index = 0;
             }
         } else if (state == EDIT_CHANNELS) {
             CPPM::instance().setChannels(value);
-            state = MAINMENU;
+            state = CPPMMENU;
         } else if (state == EDIT_FRAME_LENGTH) {
             CPPM::instance().setFrameLength(value);
-            state = MAINMENU;
+            state = CPPMMENU;
         } else if (state == EDIT_PULSE_LENGTH) {
             CPPM::instance().setPulseLength(value);
-            state = MAINMENU;
+            state = CPPMMENU;
         } else if (state == EDIT_INVERT) {
             CPPM::instance().setInvert(value);
-            state = MAINMENU;
+            state = CPPMMENU;
+        } else if (state == EDIT_INVERT_ROLL) {
+            joyCPPM.setInvert(CHANNEL_ROLL, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_INVERT_PITCH) {
+            joyCPPM.setInvert(CHANNEL_PITCH, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_INVERT_YAW) {
+            joyCPPM.setInvert(CHANNEL_YAW, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_INVERT_THROTTLE) {
+            joyCPPM.setInvert(CHANNEL_THROTTLE, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_INVERT_AUX1) {
+            joyCPPM.setInvert(CHANNEL_AUX1, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_INVERT_AUX2) {
+            joyCPPM.setInvert(CHANNEL_AUX2, value);
+            state = INVERTAXISMENU;
+        } else if (state == EDIT_MIN_ROLL) {
+            joyCPPM.setMinimum(CHANNEL_ROLL, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_ROLL) {
+            joyCPPM.setMaximum(CHANNEL_ROLL, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MIN_PITCH) {
+            joyCPPM.setMinimum(CHANNEL_PITCH, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_PITCH) {
+            joyCPPM.setMaximum(CHANNEL_PITCH, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MIN_YAW) {
+            joyCPPM.setMinimum(CHANNEL_YAW, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_YAW) {
+            joyCPPM.setMaximum(CHANNEL_YAW, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MIN_THROTTLE) {
+            joyCPPM.setMinimum(CHANNEL_THROTTLE, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_THROTTLE) {
+            joyCPPM.setMaximum(CHANNEL_THROTTLE, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MIN_AUX1) {
+            joyCPPM.setMinimum(CHANNEL_AUX1, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_AUX1) {
+            joyCPPM.setMaximum(CHANNEL_AUX1, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MIN_AUX2) {
+            joyCPPM.setMinimum(CHANNEL_AUX2, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_MAX_AUX2) {
+            joyCPPM.setMaximum(CHANNEL_AUX2, value);
+            state = TRIMENDPOINTMENU;
+        } else if (state == EDIT_TRIM_ROLL) {
+            joyCPPM.setTrim(CHANNEL_ROLL, signedValue);
+            state = TRIMAXISMENU;
+        } else if (state == EDIT_TRIM_PITCH) {
+            joyCPPM.setTrim(CHANNEL_PITCH, signedValue);
+            state = TRIMAXISMENU;
+        } else if (state == EDIT_TRIM_YAW) {
+            joyCPPM.setTrim(CHANNEL_YAW, signedValue);
+            state = TRIMAXISMENU;
+        } else if (state == EDIT_TRIM_THROTTLE) {
+            joyCPPM.setTrim(CHANNEL_THROTTLE, signedValue);
+            state = TRIMAXISMENU;
+        } else if (state == EDIT_TRIM_AUX1) {
+            joyCPPM.setTrim(CHANNEL_AUX1, signedValue);
+            state = TRIMAXISMENU;
+        } else if (state == EDIT_TRIM_AUX2) {
+            joyCPPM.setTrim(CHANNEL_AUX2, signedValue);
+            state = TRIMAXISMENU;
         }
         printMenu();
     } else if (but_id == MENU_BUTTON_DOWN) {
-        if (state > STATES_EDIT) {
+        if ((state > STATES_EDIT) && (state < STATES_EDIT_SIGNED)) {
             if (value > 0) {
                 value--;
             }
+        } else if (state > STATES_EDIT_SIGNED) {
+            if (signedValue > -32767) {
+                signedValue--;
+            }
         } else if (state != NONE) {
             index++;
         }
         printMenu();
     } else if (but_id == MENU_BUTTON_UP) {
-        if (state > STATES_EDIT) {
+        if ((state > STATES_EDIT) && (state < STATES_EDIT_SIGNED)) {
             if (value < 0xFFFF) {
                 value++;
             }
+        } else if (state > STATES_EDIT_SIGNED) {
+            if (signedValue < 32767) {
+                signedValue++;
+            }
         } else if (state != NONE) {
             if (index > 0) {
                 index--;
     }
 }
 
+void JoystickEventsButtons::menuHelper(uint8_t count, const char** menu, const char* title) {
+    if (index >= count) {
+        index = count - 1;
+    }
+
+    uint8_t start = 0, line = 0;
+    if (index > 1) {
+        start = index - 1;
+    }
+
+    uint8_t end = start + 2;
+    if (index == 0) {
+        x52->setMFDText(0, title);
+        line = 1;
+        end = start + 1;
+    }
+
+    if (end >= count) {
+        end = count - 1;
+    }
+
+    for (uint8_t i = start; i <= end; i++) {
+        String tmp = (index == i) ? "-> " : "   ";
+        x52->setMFDText(line++, (tmp + menu[i]).c_str());
+    }
+
+    if (line == 2) {
+        x52->setMFDText(2);
+    }
+
+#ifdef DEBUG_OUTPUT
+    Serial.print("menuHelper() state=");
+    Serial.print(state);
+    Serial.print(" index=");
+    Serial.print(index);
+    Serial.print(" start=");
+    Serial.print(start);
+    Serial.print(" end=");
+    Serial.println(end);
+#endif
+}
+
+void JoystickEventsButtons::printValue(uint16_t min, uint16_t max, const char* title) {
+#ifdef DEBUG_OUTPUT
+    Serial.print("printValue() state=");
+    Serial.print(state);
+    Serial.print(" index=");
+    Serial.print(index);
+    Serial.print(" min=");
+    Serial.print(min);
+    Serial.print(" max=");
+    Serial.println(max);
+#endif
+
+    if (value < min) {
+        value = min;
+    }
+    if (value > max) {
+        value = max;
+    }
+
+    x52->setMFDText(0, (String(title) + ":").c_str());
+    x52->setMFDText(1, String(value).c_str());
+    x52->setMFDText(2, "Press OK to save");
+}
+
+void JoystickEventsButtons::printSignedValue(int16_t min, int16_t max, const char* title) {
+#ifdef DEBUG_OUTPUT
+    Serial.print("printSignedValue() state=");
+    Serial.print(state);
+    Serial.print(" index=");
+    Serial.print(index);
+    Serial.print(" min=");
+    Serial.print(min);
+    Serial.print(" max=");
+    Serial.println(max);
+#endif
+
+    if (signedValue < min) {
+        signedValue = min;
+    }
+    if (signedValue > max) {
+        signedValue = max;
+    }
+
+    x52->setMFDText(0, (String(title) + ":").c_str());
+    x52->setMFDText(1, String(signedValue).c_str());
+    x52->setMFDText(2, "Press OK to save");
+}
+

events_cppm.cpp

 #include "cppm.h"
 #include "events.h"
 
-#define CHANNEL_ROLL 0
-#define CHANNEL_PITCH 1
-#define CHANNEL_THROTTLE 2
-#define CHANNEL_YAW 3
-#define CHANNEL_AUX1 4
-#define CHANNEL_AUX2 5
-
 JoystickEventsCPPM::JoystickEventsCPPM(JoystickEvents* client) : JoystickEvents(client) {
     for (uint8_t i = 0; i < channels; i++) {
         values[i] = 1500;
+        invert[i] = 0;
+        minimum[i] = 1000;
+        maximum[i] = 2000;
+        trim[i] = 0;
     }
 
     values[CHANNEL_AUX1] = 1000;
     values[CHANNEL_AUX2] = 1000;
+    invert[CHANNEL_THROTTLE] = 1;
 
     CPPM::instance().copy(values);
 }
 
 void JoystickEventsCPPM::OnGamePadChanged(const GamePadEventData& evt) {
-    values[CHANNEL_ROLL] = map(evt.X, 0, 0x7FF, 1000, 2000);
-    values[CHANNEL_PITCH] = map(evt.Y, 0, 0x7FF, 1000, 2000);
-    values[CHANNEL_THROTTLE] = map(evt.Z, 0, 0xFF, 2000, 1000);
-    values[CHANNEL_YAW] = map(evt.Rz, 0, 0x3FF, 1000, 2000);
-    values[CHANNEL_AUX1] = map(evt.Ry, 0, 0xFF, 1000, 2000);
-    values[CHANNEL_AUX2] = map(evt.Slider, 0, 0xFF, 1000, 2000);
-    values[CHANNEL_AUX2 + 1] = map(evt.Rx, 0, 0xFF, 1000, 2000);
+    for (uint8_t i = 0; i < (CHANNEL_AUX2 + 1); i++) {
+        uint16_t value = ((int32_t)getJoystickAxis(evt, i)) + trim[i];
+        values[i] = map(value, 0, getJoystickMax(i),
+                invert[i] ? maximum[i] : minimum[i], invert[i] ? minimum[i] : maximum[i]);
+    }
 
     CPPM::instance().copy(values);
 
     }
 }
 
+uint16_t JoystickEventsCPPM::getJoystickAxis(const GamePadEventData& evt, uint8_t ch) {
+    if (ch == CHANNEL_ROLL) {
+        return evt.X;
+    } else if (ch == CHANNEL_PITCH) {
+        return evt.Y;
+    } else if (ch == CHANNEL_THROTTLE) {
+        return evt.Z;
+    } else if (ch == CHANNEL_YAW) {
+        return evt.Rz;
+    } else if (ch == CHANNEL_AUX1) {
+        return evt.Ry;
+    } else if (ch == CHANNEL_AUX2) {
+        return evt.Slider;
+    } else if (ch == (CHANNEL_AUX2 + 1)) {
+        return evt.Rx;
+    } else {
+        return 0;
+    }
+}
+
+uint16_t JoystickEventsCPPM::getJoystickMax(uint8_t ch) {
+    if (ch == CHANNEL_ROLL) {
+        return 0x7FF;
+    } else if (ch == CHANNEL_PITCH) {
+        return 0x7FF;
+    } else if (ch == CHANNEL_THROTTLE) {
+        return 0xFF;
+    } else if (ch == CHANNEL_YAW) {
+        return 0x3FF;
+    } else if (ch == CHANNEL_AUX1) {
+        return 0xFF;
+    } else if (ch == CHANNEL_AUX2) {
+        return 0xFF;
+    } else if (ch == (CHANNEL_AUX2 + 1)) {
+        return 0xFF;
+    } else {
+        return 0xFF;
+    }
+}
+