Load/Save config on EEPROM

Saitek-X52-PPM.ino

@@ -20,6 +20,7 @@
 #include "x52.h"
 #include "cppm.h"
 #include "frsky.h"
+#include "config.h"
 
 #define ENABLE_SERIAL_PORT
 //#define DEBUG_OUTPUT Serial
@@ -74,6 +75,8 @@ void setup() {
     pinMode(13, OUTPUT);
     digitalWrite(13, LOW);
 
+    eepromRead();
+
     if (usb.Init() == -1) {
         digitalWrite(13, HIGH);
 #ifdef DEBUG_OUTPUT

config.cpp

@@ -0,0 +1,128 @@
+/*
+ * EEPROM configuration storage utility
+ * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+#include <EEPROM.h>
+#include "cppm.h"
+#include "events.h"
+#include "config.h"
+
+//#define DEBUG_OUTPUT Serial
+
+static void toEEPROM(const ConfigData& data) {
+    for (uint8_t i = 0; i < CONFIG_VERSION_LENGTH; i++) {
+        EEPROM.write(i, CONFIG_VERSION[i]);
+    }
+
+    const uint8_t* buffer = (const uint8_t*)((const void*)&data);
+    uint8_t sum = 0;
+    for (uint8_t i = 0; i < CONFIG_DATA_LENGTH; i++) {
+        EEPROM.write(CONFIG_VERSION_LENGTH + i, buffer[i]);
+        sum ^= buffer[i];
+    }
+
+    EEPROM.write(CONFIG_VERSION_LENGTH + CONFIG_DATA_LENGTH, sum);
+
+#ifdef DEBUG_OUTPUT
+    DEBUG_OUTPUT.println("EEPROM write success!");
+#endif
+}
+
+// Return 0 on valid data, otherwise header or checksum wrong
+static uint8_t fromEEPROM(ConfigData& data) {
+    for (uint8_t i = 0; i < CONFIG_VERSION_LENGTH; i++) {
+        if (EEPROM.read(i) != CONFIG_VERSION[i]) {
+#ifdef DEBUG_OUTPUT
+            DEBUG_OUTPUT.println("EEPROM header wrong!");
+#endif
+            return 1;
+        }
+    }
+
+    uint8_t* buffer = (uint8_t*)((void*)&data);
+    uint8_t sum = 0;
+    for (uint8_t i = 0; i < CONFIG_DATA_LENGTH; i++) {
+        buffer[i] = EEPROM.read(CONFIG_VERSION_LENGTH + i);
+        sum ^= buffer[i];
+    }
+
+    uint8_t storedSum = EEPROM.read(CONFIG_VERSION_LENGTH + CONFIG_DATA_LENGTH);
+    if (storedSum != sum) {
+#ifdef DEBUG_OUTPUT
+        DEBUG_OUTPUT.println("EEPROM checksum wrong!");
+#endif
+        return 2;
+    }
+
+#ifdef DEBUG_OUTPUT
+    DEBUG_OUTPUT.println("EEPROM read success!");
+#endif
+
+    return 0;
+}
+
+void eepromRead() {
+    ConfigData data;
+    if (fromEEPROM(data) != 0) {
+        data.channels = DEFAULT_CHANNELS;
+        data.frameLength = DEFAULT_FRAME_LENGTH;
+        data.pulseLength = DEFAULT_PULSE_LENGTH;
+        data.inverted = DEFAULT_INVERT_STATE;
+        for (uint8_t i = 0; i < CHANNELS_MAX; i++) {
+            data.invert[i] = 0;
+            data.minimum[i] = CHANNEL_MINIMUM_VALUE;
+            data.maximum[i] = CHANNEL_MAXIMUM_VALUE;
+            data.trim[i] = 0;
+        }
+
+        /*
+         * Default values to match my personal setup.
+         * Can be changed using the on-screen menu.
+         */
+        data.invert[CHANNEL_THROTTLE] = 1;
+        data.invert[CHANNEL_PITCH] = 1;
+        data.minimum[CHANNEL_THROTTLE] = 1010;
+        data.maximum[CHANNEL_THROTTLE] = 1950;
+        data.minimum[CHANNEL_ROLL] = 1050;
+        data.maximum[CHANNEL_ROLL] = 1950;
+        data.minimum[CHANNEL_PITCH] = 1080;
+        data.maximum[CHANNEL_PITCH] = 1890;
+        data.minimum[CHANNEL_AUX1] = 990;
+        data.maximum[CHANNEL_AUX1] = 2100;
+        data.minimum[CHANNEL_AUX2] = 990;
+        data.maximum[CHANNEL_AUX2] = 1990;
+
+        toEEPROM(data);
+    }
+
+    CPPM::instance().setChannels(data.channels);
+    CPPM::instance().setFrameLength(data.frameLength);
+    CPPM::instance().setPulseLength(data.pulseLength);
+    CPPM::instance().setInvert(data.inverted);
+    for (uint8_t i = 0; i < CHANNELS_MAX; i++) {
+        joyCPPM.setInvert(i, data.invert[i]);
+        joyCPPM.setMinimum(i, data.minimum[i]);
+        joyCPPM.setMaximum(i, data.maximum[i]);
+        joyCPPM.setTrim(i, data.trim[i]);
+    }
+}
+
+void eepromWrite() {
+    ConfigData data;
+    data.channels = CPPM::instance().getChannels();
+    data.frameLength = CPPM::instance().getFrameLength();
+    data.pulseLength = CPPM::instance().getPulseLength();
+    data.inverted = CPPM::instance().getInvert();
+    for (uint8_t i = 0; i < CHANNELS_MAX; i++) {
+        data.invert[i] = joyCPPM.getInvert(i);
+        data.minimum[i] = joyCPPM.getMinimum(i);
+        data.maximum[i] = joyCPPM.getMaximum(i);
+        data.trim[i] = joyCPPM.getTrim(i);
+    }
+    toEEPROM(data);
+}
+

config.h

@@ -0,0 +1,51 @@
+/*
+ * EEPROM configuration storage utility
+ * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#ifndef __CONFIG_H__
+#define __CONFIG_H__
+
+#include <stdint.h>
+
+#define CPPM_OUTPUT_PIN 4
+#define CHANNEL_MINIMUM_VALUE 1000
+#define CHANNEL_DEFAULT_VALUE 1500
+#define CHANNEL_MAXIMUM_VALUE 2000
+#define CHANNELS_MAX 12
+#define DEFAULT_CHANNELS 6
+#define DEFAULT_FRAME_LENGTH 20000
+#define DEFAULT_PULSE_LENGTH 300
+#define DEFAULT_INVERT_STATE 0
+
+enum RxChannels {
+    CHANNEL_ROLL = 0,
+    CHANNEL_PITCH = 1,
+    CHANNEL_THROTTLE = 2,
+    CHANNEL_YAW = 3,
+    CHANNEL_AUX1 = 4,
+    CHANNEL_AUX2 = 5
+};
+
+// Increase string number when struct changes!
+#define CONFIG_VERSION "USBCPPM-01"
+#define CONFIG_VERSION_LENGTH (sizeof(CONFIG_VERSION) - 1)
+
+struct ConfigData {
+    uint16_t channels, frameLength, pulseLength, inverted;
+    uint16_t minimum[CHANNELS_MAX];
+    uint16_t maximum[CHANNELS_MAX];
+    uint16_t invert[CHANNELS_MAX];
+    int16_t trim[CHANNELS_MAX];
+};
+#define CONFIG_DATA_LENGTH (sizeof(ConfigData))
+
+void eepromRead();
+void eepromWrite();
+
+#endif // __CONFIG_H__
+

cppm.h

@@ -12,10 +12,7 @@
 
 #include <stdint.h>
 #include <avr/interrupt.h>
-
-#define CPPM_OUTPUT_PIN 4
-#define CHANNEL_DEFAULT_VALUE 1500
-#define CHANNELS_MAX 12
+#include "config.h"
 
 ISR(TIMER1_COMPA_vect);
 
@@ -48,7 +45,8 @@ class CPPM {
     inline void setInvert(uint8_t i) { onState = !i; }
 
   private:
-    CPPM() : channels(6), frameLength(20000), pulseLength(300), onState(1) { }
+    CPPM() : channels(DEFAULT_CHANNELS), frameLength(DEFAULT_FRAME_LENGTH),
+            pulseLength(DEFAULT_PULSE_LENGTH), onState(!DEFAULT_INVERT_STATE) { }
     CPPM(CPPM&) { }
 
     volatile uint16_t channels;

events.h

@@ -14,18 +14,10 @@
 #define __JOYSTICK_EVENTS_H__
 
 #include <stdint.h>
+#include "config.h"
 
 class GamePadEventData;
 
-enum RxChannels {
-    CHANNEL_ROLL = 0,
-    CHANNEL_PITCH = 1,
-    CHANNEL_THROTTLE = 2,
-    CHANNEL_YAW = 3,
-    CHANNEL_AUX1 = 4,
-    CHANNEL_AUX2 = 5
-};
-
 class JoystickEvents {
   public:
     JoystickEvents(JoystickEvents* _client = 0) : client(_client) { }
@@ -59,51 +51,50 @@ class JoystickEventsCPPM : public JoystickEvents {
     virtual void OnGamePadChanged(const GamePadEventData& evt);
 
     uint8_t getInvert(uint8_t ch) {
-        if (ch < channels) return invert[ch];
+        if (ch < CHANNELS_MAX) return invert[ch];
         else return 0;
     }
 
     void setInvert(uint8_t ch, uint8_t i) {
-        if (ch < channels) invert[ch] = i;
+        if (ch < CHANNELS_MAX) invert[ch] = i;
     }
 
     uint16_t getMinimum(uint8_t ch) {
-        if (ch < channels) return minimum[ch];
+        if (ch < CHANNELS_MAX) return minimum[ch];
         else return 0;
     }
 
     void setMinimum(uint8_t ch, uint16_t i) {
-        if (ch < channels) minimum[ch] = i;
+        if (ch < CHANNELS_MAX) minimum[ch] = i;
     }
 
     uint16_t getMaximum(uint8_t ch) {
-        if (ch < channels) return maximum[ch];
+        if (ch < CHANNELS_MAX) return maximum[ch];
         else return 0;
     }
 
     void setMaximum(uint8_t ch, uint16_t i) {
-        if (ch < channels) maximum[ch] = i;
+        if (ch < CHANNELS_MAX) maximum[ch] = i;
     }
 
     int16_t getTrim(uint8_t ch) {
-        if (ch < channels) return trim[ch];
+        if (ch < CHANNELS_MAX) return trim[ch];
         else return 0;
     }
 
     void setTrim(uint8_t ch, int16_t i) {
-        if (ch < channels) trim[ch] = i;
+        if (ch < CHANNELS_MAX) 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];
+    uint16_t values[CHANNELS_MAX];
+    uint8_t invert[CHANNELS_MAX];
+    uint16_t minimum[CHANNELS_MAX];
+    uint16_t maximum[CHANNELS_MAX];
+    int16_t trim[CHANNELS_MAX];
 };
 
 class JoystickEventsButtons : public JoystickEvents {

events_buttons.cpp

@@ -15,6 +15,7 @@
 #include "x52.h"
 #include "cppm.h"
 #include "events.h"
+#include "config.h"
 
 //#define DEBUG_OUTPUT Serial
 //#define DEBUG_BUTTON_MFD
@@ -47,7 +48,8 @@ JoystickEventsButtons::JoystickEventsButtons(JoystickEvents* client)
 
 void JoystickEventsButtons::printMenu() {
     static const char* mainMenu[] = {
-        "Status", "Trim Axis", "Trim Endpoint", "Invert Axis", "CPPM Config"
+        "Status", "Trim Axis", "Trim Endpoint", "Invert Axis", "CPPM Config",
+        "Save EEPROM", "Load EEPROM"
     };
     static const uint8_t mainMenuCount = sizeof(mainMenu) / sizeof(mainMenu[0]);
 
@@ -141,6 +143,12 @@ void JoystickEventsButtons::OnButtonDown(uint8_t but_id) {
             } else if (index == 4) {
                 state = CPPMMENU;
                 index = 0;
+            } else if (index == 5) {
+                eepromWrite();
+                index = 0;
+            } else if (index == 6) {
+                eepromRead();
+                index = 0;
             }
         } else if (state == TRIMAXISMENU) {
             if (index == 0) {

events_cppm.cpp

@@ -16,11 +16,11 @@
 #include "events.h"
 
 JoystickEventsCPPM::JoystickEventsCPPM(JoystickEvents* client) : JoystickEvents(client) {
-    for (uint8_t i = 0; i < channels; i++) {
-        values[i] = 1500;
+    for (uint8_t i = 0; i < CHANNELS_MAX; i++) {
+        values[i] = CHANNEL_DEFAULT_VALUE;
         invert[i] = 0;
-        minimum[i] = 1000;
-        maximum[i] = 2000;
+        minimum[i] = CHANNEL_MINIMUM_VALUE;
+        maximum[i] = CHANNEL_MAXIMUM_VALUE;
         trim[i] = 0;
     }
 
@@ -29,25 +29,8 @@ JoystickEventsCPPM::JoystickEventsCPPM(JoystickEvents* client) : JoystickEvents(
      * Ensure we're not sending high values when
      * no joystick has been connected...
      */
-    values[CHANNEL_AUX1] = 1000;
-    values[CHANNEL_AUX2] = 1000;
-
-    /*
-     * Default values to match my personal setup.
-     * Can be changed using the on-screen menu.
-     */
-    invert[CHANNEL_THROTTLE] = 1;
-    invert[CHANNEL_PITCH] = 1;
-    minimum[CHANNEL_THROTTLE] = 1010;
-    maximum[CHANNEL_THROTTLE] = 1950;
-    minimum[CHANNEL_ROLL] = 1050;
-    maximum[CHANNEL_ROLL] = 1950;
-    minimum[CHANNEL_PITCH] = 1080;
-    maximum[CHANNEL_PITCH] = 1890;
-    minimum[CHANNEL_AUX1] = 990;
-    maximum[CHANNEL_AUX1] = 2100;
-    minimum[CHANNEL_AUX2] = 990;
-    maximum[CHANNEL_AUX2] = 1990;
+    values[CHANNEL_AUX1] = CHANNEL_MINIMUM_VALUE;
+    values[CHANNEL_AUX2] = CHANNEL_MINIMUM_VALUE;
 
     CPPM::instance().copy(values);
 }