Can now set CPPM parameters using MFD

Saitek-X52-PPM.ino

 
 #define ENABLE_SERIAL_PORT
 #define DEBUG_OUTPUT
-//#define DEBUG_INPUT
+//#define DEBUG_MFD_UPTIME
 
 USB usb;
 USBHub hub(&usb);
         ErrorMessage<uint8_t >(PSTR("SetReportParser"), 1);
     }
 
-    cppmInit();
+    CPPM::instance().init();
 }
 
 void init_joystick() {
     x52.initialize();
     x52.setMFDText(0, "Arduino X52 Host");
-    x52.setMFDText(1, "  initialized!  ");
-    x52.setMFDText(2, "                ");
+    x52.setMFDText(1, "should be ready!");
+    x52.setMFDText(2, " OK for options ");
 }
 
 void loop() {
             initialized = 1;
         }
 
+#ifdef DEBUG_MFD_UPTIME
         String text = "Uptime: " + String(millis() / 1000) + "s";
         x52.setMFDText(2, text.c_str());
-    }
-
-#ifdef DEBUG_INPUT
-    if (Serial.available()) {
-        char c = Serial.read();
-        if (c == 't') {
-            x52.setMFDText(0, "Arduino");
-            x52.setMFDText(1, "Hello");
-            x52.setMFDText(2, "World");
-        } else if (c == '0') {
-            x52.setMFDBrightness(0);
-        } else if (c == '1') {
-            x52.setMFDBrightness(1);
-        } else if (c == '2') {
-            x52.setMFDBrightness(2);
-        } else if (c == '3') {
-            x52.setLEDBrightness(0);
-        } else if (c == '4') {
-            x52.setLEDBrightness(1);
-        } else if (c == '5') {
-            x52.setLEDBrightness(2);
-        } else if (c == 'q') {
-            x52.setShift(1);
-        } else if (c == 'w') {
-            x52.setShift(0);
-        } else if (c == 'a') {
-            x52.setBlink(1);
-        } else if (c == 's') {
-            x52.setBlink(0);
-        } else if (c == 'z') {
-            x52.setDate(1, 1, 1);
-        } else if (c == 'x') {
-            x52.setTime(12, 42);
-            x52.setTimeOffset(0, -120);
-            x52.setTimeOffset(0, 240);
-        } else {
-            Serial.println("Unknown command!");
-        }
-    }
 #endif
+    }
 }
 

cppm.cpp

 
 //#define DEBUG_OUTPUT
 
-#define CHANNELS 8 // set the number of chanels
-#define CHANNEL_DEFAULT_VALUE 1500 // set the default servo value
-#define FRAME_LENGTH 20000 // set the PPM frame length in microseconds (1ms = 1000µs)
-#define PULSE_LENGTH 100 // set the pulse length
-#define ON_STATE 1 // set polarity of the pulses: 1 is positive, 0 is negative
+CPPM* CPPM::inst = NULL;
 
-static volatile uint16_t cppmData[CHANNELS];
-static volatile uint8_t state = 1;
-static volatile uint8_t currentChannel = CHANNELS;
-static volatile uint16_t calcRest = 0;
-
-void cppmInit(void) {
+void CPPM::init(void) {
 #ifdef DEBUG_OUTPUT
     Serial.println("Initializing Timer...");
 #endif
 
-    for (uint8_t i = 0; i < CHANNELS; i++) {
-        cppmData[i] = CHANNEL_DEFAULT_VALUE;
+    state = 1;
+    currentChannel = channels;
+    calcRest = 0;
+    for (uint8_t i = 0; i < channels; i++) {
+        data[i] = CHANNEL_DEFAULT_VALUE;
     }
 
     pinMode(CPPM_OUTPUT_PIN, OUTPUT);
-    digitalWrite(CPPM_OUTPUT_PIN, ON_STATE ? LOW : HIGH);
+    digitalWrite(CPPM_OUTPUT_PIN, CPPM::inst->onState ? LOW : HIGH);
 
     cli();
     TCCR1A = 0; // set entire TCCR1 register to 0
     sei();
 }
 
-void cppmCopy(uint16_t *data) {
+void CPPM::copy(uint16_t* d) {
 #ifdef DEBUG_OUTPUT
     Serial.println("New CPPM data!");
 #endif
 
     cli();
-    for (int i = 0; i < CHANNELS; i++) {
-        cppmData[i] = data[i];
+    for (int i = 0; i < channels; i++) {
+        data[i] = d[i];
     }
     sei();
 }
 
-ISR(TIMER1_COMPA_vect){
+ISR(TIMER1_COMPA_vect) {
+    if (!CPPM::inst) {
+        return;
+    }
+
     TCNT1 = 0;
-    if (state) {
+    if (CPPM::inst->state) {
         // start pulse
-        digitalWrite(CPPM_OUTPUT_PIN, ON_STATE ? HIGH : LOW);
-        OCR1A = PULSE_LENGTH << 1;
-        state = 0;
+        digitalWrite(CPPM_OUTPUT_PIN, CPPM::inst->onState ? HIGH : LOW);
+        OCR1A = CPPM::inst->pulseLength << 1;
+        CPPM::inst->state = 0;
     } else {
         // end pulse and calculate when to start the next pulse
-        digitalWrite(CPPM_OUTPUT_PIN, ON_STATE ? LOW : HIGH);
-        state = 1;
-        if (currentChannel >= CHANNELS) {
-            currentChannel = 0;
-            calcRest += PULSE_LENGTH;
-            OCR1A = (FRAME_LENGTH - calcRest) << 1;
-            calcRest = 0;
+        digitalWrite(CPPM_OUTPUT_PIN, CPPM::inst->onState ? LOW : HIGH);
+        CPPM::inst->state = 1;
+        if (CPPM::inst->currentChannel >= CPPM::inst->channels) {
+            CPPM::inst->currentChannel = 0;
+            CPPM::inst->calcRest += CPPM::inst->pulseLength;
+            OCR1A = (CPPM::inst->frameLength - CPPM::inst->calcRest) << 1;
+            CPPM::inst->calcRest = 0;
         } else {
-            OCR1A = (cppmData[currentChannel] - PULSE_LENGTH) << 1;
-            calcRest += cppmData[currentChannel];
-            currentChannel++;
+            OCR1A = (CPPM::inst->data[CPPM::inst->currentChannel] - CPPM::inst->pulseLength) << 1;
+            CPPM::inst->calcRest += CPPM::inst->data[CPPM::inst->currentChannel];
+            CPPM::inst->currentChannel++;
         }
     }
 }

cppm.h

 #define __CPPM_H__
 
 #include <stdint.h>
+#include <avr/interrupt.h>
 
 #define CPPM_OUTPUT_PIN 4
+#define CHANNEL_DEFAULT_VALUE 1500
+#define CHANNELS_MAX 12
 
-void cppmInit(void);
-void cppmCopy(uint16_t *data);
+ISR(TIMER1_COMPA_vect);
+
+class CPPM {
+  public:
+    inline static CPPM& instance() {
+        if (!inst) {
+            inst = new CPPM();
+        }
+        return *inst;
+    }
+
+    void init(void);
+    void copy(uint16_t* d);
+
+    inline uint16_t getChannels() { return channels; }
+    inline void setChannels(uint16_t c) {
+        if (c > CHANNELS_MAX)
+            c = CHANNELS_MAX;
+        channels = c;
+    }
+
+    inline uint16_t getFrameLength() { return frameLength; }
+    inline void setFrameLength(uint16_t fl) { frameLength = fl; }
+
+    inline uint16_t getPulseLength() { return pulseLength; }
+    inline void setPulseLength(uint16_t pl) { pulseLength = pl; }
+
+    inline uint8_t getInvert() { return !onState; }
+    inline void setInvert(uint8_t i) { onState = !i; }
+
+  private:
+    CPPM() : channels(6), frameLength(20000), pulseLength(300), onState(1) { }
+    CPPM(CPPM&) { }
+
+    volatile uint16_t channels;
+    volatile uint16_t frameLength; // PPM frame length in microseconds (1ms = 1000µs)
+    volatile uint16_t pulseLength;
+    volatile uint8_t onState; // polarity of the pulses: 1 is positive, 0 is negative
+
+    volatile uint16_t data[CHANNELS_MAX];
+    volatile uint8_t state;
+    volatile uint8_t currentChannel;
+    volatile uint16_t calcRest;
+
+    static CPPM* inst;
+    friend void TIMER1_COMPA_vect(void);
+};
 
 #endif // __CPPM_H__
 

events.h

     virtual void OnMouseMoved(uint8_t x, uint8_t y);
 
   private:
-    const static uint8_t channels = 8;
+    const static uint8_t channels = 12;
     uint16_t values[channels];
 };
 
     virtual void OnMouseMoved(uint8_t x, uint8_t y);
 
   private:
+    enum MenuState {
+        NONE = 0,
+        MAINMENU,
+
+        STATES_EDIT,
+        EDIT_CHANNELS,
+        EDIT_FRAME_LENGTH,
+        EDIT_PULSE_LENGTH,
+        EDIT_INVERT,
+
+        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);
+
     X52* x52;
+    MenuState state;
+    uint8_t index;
+    uint16_t value;
 };
 
 #endif // __JOYSTICK_EVENTS_H__

events_buttons.cpp

 #include <Arduino.h>
 #include "data.h"
 #include "x52.h"
+#include "cppm.h"
 #include "events.h"
 
-#define DEBUG_BUTTON_MFD
+#define DEBUG_OUTPUT
+//#define DEBUG_BUTTON_MFD
+
+#define MENU_BUTTON_ENTER_1 29
+#define MENU_BUTTON_ENTER_2 26
+#define MENU_BUTTON_DOWN 27
+#define MENU_BUTTON_UP 28
+
+#define MODE_BUTTON_GREEN 23
+#define MODE_BUTTON_YELLOW 24
+#define MODE_BUTTON_RED 25
 
 JoystickEventsButtons::JoystickEventsButtons(X52* x, JoystickEvents* client)
-        : JoystickEvents(client), x52(x) { }
+        : JoystickEvents(client), x52(x), state(NONE), index(0), value(0) { }
 
 void JoystickEventsButtons::OnGamePadChanged(const GamePadEventData& evt) {
     if (client) {
     }
 }
 
+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::printMenu() {
+    static const char* mainMenu[] = {
+        "Channels", "Frame Length",
+        "Pulse Length", "Invert"
+    };
+    static const uint8_t mainMenuCount = sizeof(mainMenu) / sizeof(mainMenu[0]);
+
+    if (state == MAINMENU) {
+        menuHelper(mainMenuCount, mainMenu, "Main Menu");
+    } else if (state == EDIT_CHANNELS) {
+        printValue(4, CHANNELS_MAX, mainMenu[0]);
+    } else if (state == EDIT_FRAME_LENGTH) {
+        printValue(10000, 30000, mainMenu[1]);
+    } else if (state == EDIT_PULSE_LENGTH) {
+        printValue(100, 1000, mainMenu[2]);
+    } else if (state == EDIT_INVERT) {
+        printValue(0, 1, mainMenu[3]);
+    }
+}
+
+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";
     x52->setMFDText(1, text.c_str());
 #endif
 
-    if (but_id == 23) {
+    if (but_id == MODE_BUTTON_GREEN) {
         x52->setLEDBrightness(2);
         x52->setMFDBrightness(2);
-    } else if (but_id == 24) {
+    } else if (but_id == MODE_BUTTON_YELLOW) {
         x52->setLEDBrightness(1);
         x52->setMFDBrightness(1);
-    } else if (but_id == 25) {
+    } else if (but_id == MODE_BUTTON_RED) {
         x52->setLEDBrightness(0);
         x52->setMFDBrightness(0);
+    } else if ((but_id == MENU_BUTTON_ENTER_1) || (but_id == MENU_BUTTON_ENTER_2)) {
+        if (state == NONE) {
+            state = MAINMENU;
+        } else if (state == MAINMENU) {
+            if (index == 0) {
+                state = EDIT_CHANNELS;
+                value = CPPM::instance().getChannels();
+            } else if (index == 1) {
+                state = EDIT_FRAME_LENGTH;
+                value = CPPM::instance().getFrameLength();
+            } else if (index == 2) {
+                state = EDIT_PULSE_LENGTH;
+                value = CPPM::instance().getPulseLength();
+            } else if (index == 3) {
+                state = EDIT_INVERT;
+                value = CPPM::instance().getInvert();
+            }
+        } else if (state == EDIT_CHANNELS) {
+            CPPM::instance().setChannels(value);
+            state = MAINMENU;
+        } else if (state == EDIT_FRAME_LENGTH) {
+            CPPM::instance().setFrameLength(value);
+            state = MAINMENU;
+        } else if (state == EDIT_PULSE_LENGTH) {
+            CPPM::instance().setPulseLength(value);
+            state = MAINMENU;
+        } else if (state == EDIT_INVERT) {
+            CPPM::instance().setInvert(value);
+            state = MAINMENU;
+        }
+        printMenu();
+    } else if (but_id == MENU_BUTTON_DOWN) {
+        if (state > STATES_EDIT) {
+            if (value > 0) {
+                value--;
+            }
+        } else if (state != NONE) {
+            index++;
+        }
+        printMenu();
+    } else if (but_id == MENU_BUTTON_UP) {
+        if (state > STATES_EDIT) {
+            if (value < 0xFFFF) {
+                value++;
+            }
+        } else if (state != NONE) {
+            if (index > 0) {
+                index--;
+            }
+        }
+        printMenu();
     }
 
     if (client) {

events_cppm.cpp

     values[CHANNEL_AUX1] = 1000;
     values[CHANNEL_AUX2] = 1000;
 
-    cppmCopy(values);
+    CPPM::instance().copy(values);
 }
 
 void JoystickEventsCPPM::OnGamePadChanged(const GamePadEventData& evt) {
     values[CHANNEL_AUX1] = map(evt.Ry, 0, 0xFF, 1000, 2000);
     values[CHANNEL_AUX2] = map(evt.Slider, 0, 0xFF, 1000, 2000);
 
-    cppmCopy(values);
+    CPPM::instance().copy(values);
 
     if (client) {
         client->OnGamePadChanged(evt);

x52.h

      * Print text on the MFD lines (0 - 2).
      * Maximum of 16 characters per line.
      */
-    void setMFDText(uint8_t line, const char* text);
+    void setMFDText(uint8_t line, const char* text = "                ");
 
     /*
      * Enable (1) or Disable(0) the MFD shift indicator.