Can configure debug output target

Saitek-X52-PPM.ino

 #include "frsky.h"
 
 #define ENABLE_SERIAL_PORT
-#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT Serial
 //#define DEBUG_MFD_UPTIME
 
 USB usb;
 #endif
 
 #ifdef DEBUG_OUTPUT
-    Serial.println("Start");
+    DEBUG_OUTPUT.println("Start");
 #endif
 
+    pinMode(13, OUTPUT);
+    digitalWrite(13, LOW);
+
     if (usb.Init() == -1) {
+        digitalWrite(13, HIGH);
 #ifdef DEBUG_OUTPUT
-        Serial.println("OSC did not start.");
+        DEBUG_OUTPUT.println("OSC did not start.");
 #endif
     }
 
     if (!hid.SetReportParser(0, &joy)) {
-        ErrorMessage<uint8_t >(PSTR("SetReportParser"), 1);
+        digitalWrite(13, HIGH);
+#ifdef DEBUG_OUTPUT
+        DEBUG_OUTPUT.println("Error adding report parser.");
+#endif
     }
 
     CPPM::instance().init();
     x52.setMFDText(0, "Arduino X52 Host");
     x52.setMFDText(1, "should be ready!");
     x52.setMFDText(2, " OK for options ");
+
+    // Sometimes the first message is lost, so send again
+    if (joyButtons.getCurrentMode() == 1) {
+        x52.setLEDBrightness(2);
+        x52.setMFDBrightness(2);
+    } else if (joyButtons.getCurrentMode() == 2) {
+        x52.setLEDBrightness(1);
+        x52.setMFDBrightness(1);
+    } else if (joyButtons.getCurrentMode() == 3) {
+        x52.setLEDBrightness(0);
+        x52.setMFDBrightness(0);
+    }
 }
 
 void loop() {
     static uint8_t initialized = 0;
     if ((millis() - lastTime) >= 1000) {
         lastTime = millis();
-        if (!initialized) {
-            init_joystick();
+        if (initialized == 0) {
             initialized = 1;
+        } else if (initialized == 1) {
+            init_joystick();
+            initialized = 2;
         }
 
 #ifdef DEBUG_MFD_UPTIME

cppm.cpp

 #include <Arduino.h>
 #include "cppm.h"
 
-//#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT Serial
 
 CPPM* CPPM::inst = NULL;
 
 void CPPM::init(void) {
 #ifdef DEBUG_OUTPUT
-    Serial.println("Initializing Timer...");
+    DEBUG_OUTPUT.println("Initializing Timer...");
 #endif
 
     state = 1;
 
 void CPPM::copy(uint16_t* d) {
 #ifdef DEBUG_OUTPUT
-    Serial.println("New CPPM data!");
+    DEBUG_OUTPUT.println("New CPPM data!");
 #endif
 
     cli();

events.h

     JoystickEventsButtons(X52* x = 0, JoystickEvents* client = 0);
     virtual void OnButtonDown(uint8_t but_id);
 
+    uint8_t getCurrentMode() { return currentMode; }
+
   private:
     enum MenuState {
         NONE = 0,
     uint8_t index;
     uint16_t value;
     int16_t signedValue;
-    unsigned long menuTime;
+    uint8_t currentMode;
 };
 
 extern JoystickEventsCPPM joyCPPM;

events_buttons.cpp

 #include "cppm.h"
 #include "events.h"
 
-//#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT Serial
 //#define DEBUG_BUTTON_MFD
 
 #define MENU_BUTTON_ENTER_1 29
 
 JoystickEventsButtons::JoystickEventsButtons(X52* x, JoystickEvents* client)
         : JoystickEvents(client), x52(x), state(NONE), index(0),
-        value(0), signedValue(0), menuTime(0) { }
+        value(0), signedValue(0), currentMode(0) { }
 
 void JoystickEventsButtons::printMenu() {
     static const char* mainMenu[] = {
         uint8_t index = state - EDIT_TRIM_ROLL;
         printSignedValue(-100, 100, (String("Trim ") + axisMenu[index]).c_str());
     }
-
-    menuTime = millis();
 }
 
 void JoystickEventsButtons::OnButtonDown(uint8_t but_id) {
     if (but_id == MODE_BUTTON_GREEN) {
         x52->setLEDBrightness(2);
         x52->setMFDBrightness(2);
+        currentMode = 1;
     } else if (but_id == MODE_BUTTON_YELLOW) {
         x52->setLEDBrightness(1);
         x52->setMFDBrightness(1);
+        currentMode = 2;
     } else if (but_id == MODE_BUTTON_RED) {
         x52->setLEDBrightness(0);
         x52->setMFDBrightness(0);
+        currentMode = 3;
     } else if ((but_id == MENU_BUTTON_ENTER_1) || (but_id == MENU_BUTTON_ENTER_2)) {
         if (state == NONE) {
             state = MAINMENU;
     }
 
 #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);
+    DEBUG_OUTPUT.print("menuHelper() state=");
+    DEBUG_OUTPUT.print(state);
+    DEBUG_OUTPUT.print(" index=");
+    DEBUG_OUTPUT.print(index);
+    DEBUG_OUTPUT.print(" start=");
+    DEBUG_OUTPUT.print(start);
+    DEBUG_OUTPUT.print(" end=");
+    DEBUG_OUTPUT.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);
+    DEBUG_OUTPUT.print("printValue() state=");
+    DEBUG_OUTPUT.print(state);
+    DEBUG_OUTPUT.print(" index=");
+    DEBUG_OUTPUT.print(index);
+    DEBUG_OUTPUT.print(" min=");
+    DEBUG_OUTPUT.print(min);
+    DEBUG_OUTPUT.print(" max=");
+    DEBUG_OUTPUT.println(max);
 #endif
 
     if (value < min) {
 
 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);
+    DEBUG_OUTPUT.print("printSignedValue() state=");
+    DEBUG_OUTPUT.print(state);
+    DEBUG_OUTPUT.print(" index=");
+    DEBUG_OUTPUT.print(index);
+    DEBUG_OUTPUT.print(" min=");
+    DEBUG_OUTPUT.print(min);
+    DEBUG_OUTPUT.print(" max=");
+    DEBUG_OUTPUT.println(max);
 #endif
 
     if (signedValue < min) {

events_deadzone.cpp

  * published by the Free Software Foundation, version 2.
  */
 
-#include <usb.h>
-
 #include "data.h"
 #include "events.h"
 
-//#define DEBUG_OUTPUT_RAW
-//#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT_RAW Serial
+//#define DEBUG_OUTPUT Serial
 
 /*
  * Deadzone around the axis center, in both directions.
 
 void JoystickEventsDeadZone::OnGamePadChanged(const GamePadEventData& evt) {
 #ifdef DEBUG_OUTPUT_RAW
-    Serial.print("Raw X: ");
-    PrintHex<uint16_t > (evt.X, 0x80);
-    Serial.print(" Y: ");
-    PrintHex<uint16_t > (evt.Y, 0x80);
-    Serial.print(" Z: ");
-    PrintHex<uint8_t > (evt.Z, 0x80);
-    Serial.print(" Rx: ");
-    PrintHex<uint8_t > (evt.Rx, 0x80);
-    Serial.print(" Ry: ");
-    PrintHex<uint8_t > (evt.Ry, 0x80);
-    Serial.print(" Rz: ");
-    PrintHex<uint16_t > (evt.Rz, 0x80);
-    Serial.print(" S: ");
-    PrintHex<uint8_t > (evt.Slider, 0x80);
-    Serial.println("");
+    DEBUG_OUTPUT_RAW.print("Raw X: ");
+    DEBUG_OUTPUT_RAW.print(evt.X, HEX);
+    DEBUG_OUTPUT_RAW.print(" Y: ");
+    DEBUG_OUTPUT_RAW.print(evt.Y, HEX);
+    DEBUG_OUTPUT_RAW.print(" Z: ");
+    DEBUG_OUTPUT_RAW.print(evt.Z, HEX);
+    DEBUG_OUTPUT_RAW.print(" Rx: ");
+    DEBUG_OUTPUT_RAW.print(evt.Rx, HEX);
+    DEBUG_OUTPUT_RAW.print(" Ry: ");
+    DEBUG_OUTPUT_RAW.print(evt.Ry, HEX);
+    DEBUG_OUTPUT_RAW.print(" Rz: ");
+    DEBUG_OUTPUT_RAW.print(evt.Rz, HEX);
+    DEBUG_OUTPUT_RAW.print(" S: ");
+    DEBUG_OUTPUT_RAW.println(evt.Slider, HEX);
 #endif
 
     GamePadEventData newData = centerValue;
 
 #ifdef DEBUG_OUTPUT
     if (updated) {
-        Serial.print("X: ");
-        PrintHex<uint16_t > (newData.X, 0x80);
-        Serial.print(" Y: ");
-        PrintHex<uint16_t > (newData.Y, 0x80);
-        Serial.print(" Z: ");
-        PrintHex<uint8_t > (newData.Z, 0x80);
-        Serial.print(" Rx: ");
-        PrintHex<uint8_t > (newData.Rx, 0x80);
-        Serial.print(" Ry: ");
-        PrintHex<uint8_t > (newData.Ry, 0x80);
-        Serial.print(" Rz: ");
-        PrintHex<uint16_t > (newData.Rz, 0x80);
-        Serial.print(" S: ");
-        PrintHex<uint8_t > (newData.Slider, 0x80);
-        Serial.println("");
+        DEBUG_OUTPUT.print("X: ");
+        DEBUG_OUTPUT.print(newData.X, HEX);
+        DEBUG_OUTPUT.print(" Y: ");
+        DEBUG_OUTPUT.print(newData.Y, HEX);
+        DEBUG_OUTPUT.print(" Z: ");
+        DEBUG_OUTPUT.print(newData.Z, HEX);
+        DEBUG_OUTPUT.print(" Rx: ");
+        DEBUG_OUTPUT.print(newData.Rx, HEX);
+        DEBUG_OUTPUT.print(" Ry: ");
+        DEBUG_OUTPUT.print(newData.Ry, HEX);
+        DEBUG_OUTPUT.print(" Rz: ");
+        DEBUG_OUTPUT.print(newData.Rz, HEX);
+        DEBUG_OUTPUT.print(" S: ");
+        DEBUG_OUTPUT.println(newData.Slider, HEX);
     }
 #endif
 
 
 void JoystickEventsDeadZone::OnMouseMoved(uint8_t x, uint8_t y) {
 #ifdef DEBUG_OUTPUT_RAW
-    Serial.print("Raw Mouse X: ");
-    PrintHex<uint8_t >(x, 0x80);
-    Serial.print("\tY: ");
-    PrintHex<uint8_t >(y, 0x80);
-    Serial.println("");
+    DEBUG_OUTPUT_RAW.print("Raw Mouse X: ");
+    DEBUG_OUTPUT_RAW.print(x, HEX);
+    DEBUG_OUTPUT_RAW.print("\tY: ");
+    DEBUG_OUTPUT_RAW.println(y, HEX);
 #endif
 
     uint8_t newX = centerMouseX;
 
 #ifdef DEBUG_OUTPUT
     if (updated) {
-        Serial.print("Mouse X: ");
-        PrintHex<uint8_t >(newX, 0x80);
-        Serial.print("\tY: ");
-        PrintHex<uint8_t >(newY, 0x80);
-        Serial.println("");
+        DEBUG_OUTPUT.print("Mouse X: ");
+        DEBUG_OUTPUT.print(newX, HEX);
+        DEBUG_OUTPUT.print("\tY: ");
+        DEBUG_OUTPUT.println(newY, HEX);
     }
 #endif
 

frsky.cpp

 
 #include "frsky.h"
 
-#define DEBUG_OUTPUT Serial
+//#define DEBUG_OUTPUT Serial
 
 FrSky::FrSky(Stream* s) : serial(s), dataHandler(0),
         alarmThresholdHandler(0), userDataHandler(0), bufferIndex(0) {

parser.cpp

 #include "events.h"
 #include "parser.h"
 
-//#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT Serial
 
 JoystickReportParser::JoystickReportParser(JoystickEvents* evt)
         : joyEvents(evt), oldHat(0), oldButtons(0), oldMouse(0), buffer(0) {
 
 #ifdef DEBUG_OUTPUT
     // Dump whole USB HID packet for debugging purposes
-    Serial.println("");
-    Serial.print("Packet: ");
+    DEBUG_OUTPUT.println("");
+    DEBUG_OUTPUT.print("Packet: ");
     for (uint8_t i = 0; i < (8 + len); i++) {
-        PrintHex<uint8_t >(buf[i], 0x80);
-        Serial.print(" ");
+        DEBUG_OUTPUT.print(buf[i], HEX);
+        DEBUG_OUTPUT.print(" ");
     }
-    Serial.println("");
-    Serial.println("");
+    DEBUG_OUTPUT.println("");
+    DEBUG_OUTPUT.println("");
 #endif
 
     // Checking if there are changes in report since the method was last called

x52.cpp

 
 #include "x52.h"
 
-//#define DEBUG_OUTPUT
+//#define DEBUG_OUTPUT Serial
 
 #define TIME_24H_FORMAT
 
     uint8_t ret = usb->getDevDescr(hid->GetAddress(), 0, sizeof(USB_DEVICE_DESCRIPTOR), (uint8_t*)buf);
     if (ret) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error getting descriptor: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error getting descriptor: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 
     uint16_t pid = udd->idProduct;
 
 #ifdef DEBUG_OUTPUT
-        Serial.print("VID: ");
-        Serial.print(vid, DEC);
-        Serial.print(" PID: ");
-        Serial.println(pid, DEC);
+        DEBUG_OUTPUT.print("VID: ");
+        DEBUG_OUTPUT.print(vid, DEC);
+        DEBUG_OUTPUT.print(" PID: ");
+        DEBUG_OUTPUT.println(pid, DEC);
 #endif
 
     if ((vid == 0x06A3) && (pid == 0x0255)) {
         ready = 1;
     } else {
 #ifdef DEBUG_OUTPUT
-        Serial.println("No valid VID/PID found!");
+        DEBUG_OUTPUT.println("No valid VID/PID found!");
 #endif
     }
 }
             );
     if (ret) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error setting time: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error setting time: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 }
             );
     if (ret) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error setting offset: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error setting offset: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 }
     }
     if (ret) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error setting date: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error setting date: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 }
     uint8_t ret = sendCommand(X52_BLINK_INDICATOR, state ? X52_BLINK_ON : X52_BLINK_OFF);
     if (ret != 0) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error setting blink: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error setting blink: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 }
     uint8_t ret = sendCommand(X52_SHIFT_INDICATOR, state ? X52_SHIFT_ON : X52_SHIFT_OFF);
     if (ret != 0) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error setting shift: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error setting shift: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
     }
 }
 
     if (line >= 3) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Invalid line: ");
-        Serial.println(line, DEC);
+        DEBUG_OUTPUT.print("Invalid line: ");
+        DEBUG_OUTPUT.println(line, DEC);
 #endif
         return;
     }
     uint8_t ret = sendCommand(X52_MFD_CLEAR_LINE | lines[line], 0);
     if (ret) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Error clearing line: ");
-        Serial.println(ret, DEC);
+        DEBUG_OUTPUT.print("Error clearing line: ");
+        DEBUG_OUTPUT.println(ret, DEC);
 #endif
         return;
     }
         ret = sendCommand(X52_MFD_WRITE_LINE | lines[line], value);
         if (ret) {
 #ifdef DEBUG_OUTPUT
-            Serial.print("Error writing to line: ");
-            Serial.println(ret, DEC);
+            DEBUG_OUTPUT.print("Error writing to line: ");
+            DEBUG_OUTPUT.println(ret, DEC);
 #endif
             return;
         }
 uint8_t X52::sendCommand(uint16_t command, uint16_t val) {
     if (!ready) {
 #ifdef DEBUG_OUTPUT
-        Serial.println("Invalid state!");
+        DEBUG_OUTPUT.println("Invalid state!");
 #endif
         return 23;
     }
     
     if ((!usb) || (!hid)) {
 #ifdef DEBUG_OUTPUT
-        Serial.println("Invalid objects!");
+        DEBUG_OUTPUT.println("Invalid objects!");
 #endif
         return 42;
     }
     const uint8_t valHi = (val & 0xFF00) >> 8;
 
 #ifdef DEBUG_OUTPUT
-    Serial.println("Sending X52 Ctrl-Req...");
+    DEBUG_OUTPUT.println("Sending X52 Ctrl-Req...");
 #endif
 
     uint8_t ret = usb->ctrlReq(hid->GetAddress(), 0,
                               0, 0, NULL, NULL);
     if (ret != 0) {
 #ifdef DEBUG_OUTPUT
-        Serial.print("Ctrl-Req Error Code: ");
-        Serial.println(val, DEC);
+        DEBUG_OUTPUT.print("Ctrl-Req Error Code: ");
+        DEBUG_OUTPUT.println(val, DEC);
 #endif
     }