Work on LCD menu

events.h

     enum MenuState {
         NONE = 0,
         MAINMENU,
+        CPPMMENU,
+        TRIMAXISMENU,
+        TRIMENDPOINTMENU,
+        INVERTAXISMENU,
 
         STATES_EDIT,
         EDIT_CHANNELS,
     MenuState state;
     uint8_t index;
     uint16_t value;
+    unsigned long menuTime;
 };
 
 #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) { }
+        : 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) {
     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);
     }
 
 void JoystickEventsButtons::printMenu() {
     static const char* mainMenu[] = {
-        "Channels", "Frame Length",
-        "Pulse Length", "Invert"
+        "Status", "Trim Axis", "Trim Endpoint", "Invert Axis", "CPPM Config"
     };
     static const uint8_t mainMenuCount = sizeof(mainMenu) / sizeof(mainMenu[0]);
 
+    static const char* cppmMenu[] = {
+        "Channels", "Frame Length", "Pulse Length", "Invert", "Main Menu"
+    };
+    static const uint8_t cppmMenuCount = sizeof(cppmMenu) / sizeof(cppmMenu[0]);
+
+    static const char* axisMenu[] = {
+        "Roll", "Pitch", "Yaw", "Throttle", "Aux1", "Aux2", "Main Menu"
+    };
+    static const uint8_t axisMenuCount = sizeof(axisMenu) / sizeof(axisMenu[0]);
+
+    static const char* endpointMenu[] = {
+        "Roll Min", "Roll Max", "Pitch Min", "Pitch Max", "Yaw Min", "Yaw Max",
+        "Throttle Min", "Throttle Max", "Aux1 Min", "Aux1 Max", "Aux2 Min",
+        "Aux2 Max", "Main Menu"
+    };
+    static const uint8_t endpointMenuCount = sizeof(endpointMenu) / sizeof(endpointMenu[0]);
+
     if (state == MAINMENU) {
         menuHelper(mainMenuCount, mainMenu, "Main Menu");
+    } else if (state == CPPMMENU) {
+        menuHelper(cppmMenuCount, cppmMenu, "CPPM Config Menu");
+    } else if (state == TRIMAXISMENU) {
+        menuHelper(axisMenuCount, axisMenu, "Trim Axis Menu");
+    } else if (state == TRIMENDPOINTMENU) {
+        menuHelper(endpointMenuCount, endpointMenu, "Trim Endpoints");
+    } else if (state == INVERTAXISMENU) {
+        menuHelper(axisMenuCount, axisMenu, "Invert Axis Menu");
     } else if (state == EDIT_CHANNELS) {
         printValue(4, CHANNELS_MAX, mainMenu[0]);
     } else if (state == EDIT_FRAME_LENGTH) {
     } else if (state == EDIT_INVERT) {
         printValue(0, 1, mainMenu[3]);
     }
+
+    menuTime = millis();
 }
 
 void JoystickEventsButtons::printValue(uint16_t min, uint16_t max, const char* title) {
     } else if ((but_id == MENU_BUTTON_ENTER_1) || (but_id == MENU_BUTTON_ENTER_2)) {
         if (state == NONE) {
             state = MAINMENU;
+            index = 0;
         } else if (state == MAINMENU) {
             if (index == 0) {
+                state = NONE;
+            } else if (index == 1) {
+                //state = TRIMAXISMENU;
+                //index = 0;
+            } else if (index == 2) {
+                //state = TRIMENDPOINTMENU;
+                //index = 0;
+            } else if (index == 3) {
+                //state = INVERTAXISMENU;
+                //index = 0;
+            } else if (index == 4) {
+                state = CPPMMENU;
+                index = 0;
+            }
+        } else if (state == TRIMAXISMENU) {
+            if (index == 0) {
+            } else if (index == 1) {
+            } else if (index == 2) {
+            } else if (index == 3) {
+            } else if (index == 4) {
+            } else if (index == 5) {
+            } else if (index == 6) {
+                state = MAINMENU;
+                index = 0;
+            }
+        } else if (state == TRIMENDPOINTMENU) {
+            if (index == 0) {
+            } else if (index == 1) {
+            } else if (index == 2) {
+            } else if (index == 3) {
+            } else if (index == 4) {
+            } else if (index == 5) {
+            } else if (index == 6) {
+            } else if (index == 7) {
+            } else if (index == 8) {
+            } else if (index == 9) {
+            } else if (index == 10) {
+            } else if (index == 11) {
+            } else if (index == 12) {
+                state = MAINMENU;
+                index = 0;
+            }
+        } else if (state == INVERTAXISMENU) {
+            if (index == 0) {
+            } else if (index == 1) {
+            } else if (index == 2) {
+            } else if (index == 3) {
+            } else if (index == 4) {
+            } else if (index == 5) {
+            } else if (index == 6) {
+                state = MAINMENU;
+                index = 0;
+            }
+        } else if (state == CPPMMENU) {
+            if (index == 0) {
                 state = EDIT_CHANNELS;
                 value = CPPM::instance().getChannels();
             } else if (index == 1) {
             } else if (index == 3) {
                 state = EDIT_INVERT;
                 value = CPPM::instance().getInvert();
+            } else if (index == 4) {
+                state = MAINMENU;
+                index = 0;
             }
         } else if (state == EDIT_CHANNELS) {
             CPPM::instance().setChannels(value);

events_cppm.cpp

 #include "cppm.h"
 #include "events.h"
 
-#define CHANNEL_THROTTLE 2
-#define CHANNEL_PITCH 1
 #define CHANNEL_ROLL 0
+#define CHANNEL_PITCH 1
+#define CHANNEL_THROTTLE 2
 #define CHANNEL_YAW 3
 #define CHANNEL_AUX1 4
 #define CHANNEL_AUX2 5
 }
 
 void JoystickEventsCPPM::OnGamePadChanged(const GamePadEventData& evt) {
-    values[CHANNEL_THROTTLE] = map(evt.Z, 0, 0xFF, 2000, 1000);
-    values[CHANNEL_PITCH] = map(evt.Y, 0, 0x7FF, 1000, 2000);
     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);
 
     CPPM::instance().copy(values);
 

events_deadzone.cpp

 //#define DEBUG_OUTPUT_RAW
 //#define DEBUG_OUTPUT
 
-// X, Y, Z, Rx, Ry, Rz, Slider
+/*
+ * Deadzone around the axis center, in both directions.
+ * You can try to counteract a faulty Yaw-Potentiometer
+ * with this, but it won't be enough in extreme cases.
+ * X, Y, Z, Rx, Ry, Rz, Slider
+ */
 const GamePadEventData JoystickEventsDeadZone::deadZone(
     4, 4, 2, 2, 5, 25, 2
 );
 const uint8_t JoystickEventsDeadZone::deadZoneMouseX = 1;
 const uint8_t JoystickEventsDeadZone::deadZoneMouseY = 1;
 
-// X, Y, Z, Rx, Ry, Rz, Slider
+/*
+ * Absolute values of the axis center. Deadzone will be applied
+ * in both directions around these values.
+ * X 11bit, Y 11bit, Z 8bit, Rx 8bit, Ry 8bit, Rz 10bit, Slider 8bit
+ */
 const GamePadEventData JoystickEventsDeadZone::centerValue(
     0x3FF, 0x3FF, 0x7F, 0x7F, 0x7F, 0x1FF, 0x7F
 );
 
 void JoystickEventsDeadZone::OnGamePadChanged(const GamePadEventData& evt) {
 #ifdef DEBUG_OUTPUT_RAW
-    Serial.print("X: ");
+    Serial.print("Raw X: ");
     PrintHex<uint16_t > (evt.X, 0x80);
     Serial.print(" Y: ");
     PrintHex<uint16_t > (evt.Y, 0x80);
 
 void JoystickEventsDeadZone::OnMouseMoved(uint8_t x, uint8_t y) {
 #ifdef DEBUG_OUTPUT_RAW
-    Serial.print("Mouse X: ");
+    Serial.print("Raw Mouse X: ");
     PrintHex<uint8_t >(x, 0x80);
     Serial.print("\tY: ");
     PrintHex<uint8_t >(y, 0x80);