Fixed dead zone algorithm, some other small changes.

Saitek-X52-PPM.ino

 USBHub hub(&usb);
 HIDUniversal hid(&usb);
 X52 x52(&usb, &hid);
-JoystickEvents joyevents;
+JoystickEventsDeadZone joyevents;
 JoystickReportParser joy(&joyevents);
 
 void setup() {

hid_parser.cpp

 /*
  * Saitek X52 Arduino USB Host Shield Library.
  * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
- * 
+ *
  * Based on the USB Host Library HID Joystick example
  * https://www.circuitsathome.com/mcu/hid-joystick-code-sample
- * 
+ *
  * 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.
         }
     }
 
-    // Dump whole USB HID packet for debugging purposes
 #ifdef DEBUG_OUTPUT
+    // Dump whole USB HID packet for debugging purposes
     Serial.println("");
     Serial.print("Packet: ");
     for (uint8_t i = 0; i < (8 + len); i++) {
         buffer.Ry = buf[6];
         buffer.Slider = buf[7];
 
-        joyEvents->OnGamePadChanged((const GamePadEventData*)&buffer);
+        joyEvents->OnGamePadChanged(buffer);
 
         for (uint8_t i = 0; i < RPT_GEMEPAD_LEN; i++) {
             oldPad[i] = buf[i];

hid_parser.h

 /*
  * Saitek X52 Arduino USB Host Shield Library.
  * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
- * 
+ *
  * Based on the USB Host Library HID Joystick example
  * https://www.circuitsathome.com/mcu/hid-joystick-code-sample
- * 
+ *
  * 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.
 #define BUFFER_SIZE 16
 
 class JoystickReportParser : public HIDReportParser {
-    JoystickEvents* joyEvents;
+  public:
+    JoystickReportParser(JoystickEvents* evt);
+    virtual void Parse(HID* hid, bool is_rpt_id, uint8_t len, uint8_t* bufPart);
 
+  private:
     uint8_t buf[BUFFER_SIZE];
     uint8_t oldPad[RPT_GEMEPAD_LEN];
     uint8_t oldHat;
     uint64_t oldButtons;
     uint8_t oldMouse;
     GamePadEventData buffer;
-
-  public:
-    JoystickReportParser(JoystickEvents* evt);
-
-    virtual void Parse(HID* hid, bool is_rpt_id, uint8_t len, uint8_t* bufPart);
+    JoystickEvents* joyEvents;
 };
 
 #endif // __HID_PARSER_H__

joystick_events.cpp

 /*
  * Saitek X52 Arduino USB Host Shield Library.
  * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
- * 
+ *
  * Based on the USB Host Library HID Joystick example
  * https://www.circuitsathome.com/mcu/hid-joystick-code-sample
- * 
+ *
  * 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.
 //#define DEBUG_OUTPUT_RAW
 #define DEBUG_OUTPUT
 
+const GamePadEventData JoystickEventsDeadZone::deadZone(
+    0, 0, 0, 0, 0, 50, 0
+);
+const uint8_t JoystickEventsDeadZone::deadZoneMouseX = 0;
+const uint8_t JoystickEventsDeadZone::deadZoneMouseY = 0;
 
-/*
- * Uuuhhh TODO!!
- * This is not a deadzone, this is something like sensitivity.
- * For deadzone, we need to only apply it from the center outwards.
- */
+const GamePadEventData JoystickEventsDeadZone::centerValue(
+    0x3FF, 0x3FF, 0x7F,
+    0x7F, 0x7F, 0x1FF, 0x7F
+);
+const uint8_t JoystickEventsDeadZone::centerMouseX = 0x7F;
+const uint8_t JoystickEventsDeadZone::centerMouseY = 0x7F;
 
-
-JoystickEvents::JoystickEvents()
-        : lastData(0), lastMouseX(0), lastMouseY(0), deadZone(0) {
-    deadZone.X = 0;
-    deadZone.Y = 0;
-    deadZone.Z = 0;
-    deadZone.Rx = 0;
-    deadZone.Ry = 0;
-    deadZone.Rz = 50;
-    deadZoneMouseX = 0;
-    deadZoneMouseY = 0;
-}
-
-void JoystickEvents::OnGamePadChanged(const GamePadEventData *evt) {
+void JoystickEventsDeadZone::OnGamePadChanged(const GamePadEventData& evt) {
 #ifdef DEBUG_OUTPUT_RAW
     Serial.print("X: ");
-    PrintHex<uint16_t > (evt->X, 0x80);
+    PrintHex<uint16_t > (evt.X, 0x80);
     Serial.print(" Y: ");
-    PrintHex<uint16_t > (evt->Y, 0x80);
+    PrintHex<uint16_t > (evt.Y, 0x80);
     Serial.print(" Z: ");
-    PrintHex<uint8_t > (evt->Z, 0x80);
+    PrintHex<uint8_t > (evt.Z, 0x80);
     Serial.print(" Rx: ");
-    PrintHex<uint8_t > (evt->Rx, 0x80);
+    PrintHex<uint8_t > (evt.Rx, 0x80);
     Serial.print(" Ry: ");
-    PrintHex<uint8_t > (evt->Ry, 0x80);
+    PrintHex<uint8_t > (evt.Ry, 0x80);
     Serial.print(" Rz: ");
-    PrintHex<uint16_t > (evt->Rz, 0x80);
+    PrintHex<uint16_t > (evt.Rz, 0x80);
     Serial.print(" S: ");
-    PrintHex<uint8_t > (evt->Slider, 0x80);
+    PrintHex<uint8_t > (evt.Slider, 0x80);
     Serial.println("");
 #endif
 
-    GamePadEventData newData = lastData;
+    GamePadEventData newData = centerValue;
+
+#ifdef DEBUG_OUTPUT
     uint8_t updated = 0;
+#endif
+
+    if ((evt.X > (centerValue.X + deadZone.X))
+            || (evt.X < (centerValue.X - deadZone.X))) {
+        newData.X = evt.X;
 
-    if ((evt->X > (lastData.X + deadZone.X))
-            || (evt->X < (lastData.X - deadZone.X))) {
-        newData.X = evt->X;
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Y > (lastData.Y + deadZone.Y))
-            || (evt->Y < (lastData.Y - deadZone.Y))) {
-        newData.Y = evt->Y;
+    if ((evt.Y > (centerValue.Y + deadZone.Y))
+            || (evt.Y < (centerValue.Y - deadZone.Y))) {
+        newData.Y = evt.Y;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Z > (lastData.Z + deadZone.Z))
-            || (evt->Z < (lastData.Z - deadZone.Z))) {
-        newData.Z = evt->Z;
+    if ((evt.Z > (centerValue.Z + deadZone.Z))
+            || (evt.Z < (centerValue.Z - deadZone.Z))) {
+        newData.Z = evt.Z;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Rx > (lastData.Rx + deadZone.Rx))
-            || (evt->Rx < (lastData.Rx - deadZone.Rx))) {
-        newData.Rx = evt->Rx;
+    if ((evt.Rx > (centerValue.Rx + deadZone.Rx))
+            || (evt.Rx < (centerValue.Rx - deadZone.Rx))) {
+        newData.Rx = evt.Rx;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Ry > (lastData.Ry + deadZone.Ry))
-            || (evt->Ry < (lastData.Ry - deadZone.Ry))) {
-        newData.Ry = evt->Ry;
+    if ((evt.Ry > (centerValue.Ry + deadZone.Ry))
+            || (evt.Ry < (centerValue.Ry - deadZone.Ry))) {
+        newData.Ry = evt.Ry;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Rz > (lastData.Rz + deadZone.Rz))
-            || (evt->Rz < (lastData.Rz - deadZone.Rz))) {
-        newData.Rz = evt->Rz;
+    if ((evt.Rz > (centerValue.Rz + deadZone.Rz))
+            || (evt.Rz < (centerValue.Rz - deadZone.Rz))) {
+        newData.Rz = evt.Rz;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((evt->Slider > (lastData.Slider + deadZone.Slider))
-            || (evt->Slider < (lastData.Slider - deadZone.Slider))) {
-        newData.Slider = evt->Slider;
+    if ((evt.Slider > (centerValue.Slider + deadZone.Slider))
+            || (evt.Slider < (centerValue.Slider - deadZone.Slider))) {
+        newData.Slider = evt.Slider;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if (updated) {
 #ifdef DEBUG_OUTPUT
+    if (updated) {
         Serial.print("X: ");
         PrintHex<uint16_t > (newData.X, 0x80);
         Serial.print(" Y: ");
         Serial.print(" S: ");
         PrintHex<uint8_t > (newData.Slider, 0x80);
         Serial.println("");
-#endif
     }
+#endif
 
-    lastData = *evt;
+    if (client) {
+        client->OnGamePadChanged(newData);
+    }
 }
 
-void JoystickEvents::OnHatSwitch(uint8_t hat) {
+void JoystickEventsDeadZone::OnHatSwitch(uint8_t hat) {
 #ifdef DEBUG_OUTPUT
     Serial.print("Hat Switch: ");
     PrintHex<uint8_t > (hat, 0x80);
     Serial.println("");
 #endif
+
+    if (client) {
+        client->OnHatSwitch(hat);
+    }
 }
 
-void JoystickEvents::OnButtonUp(uint8_t but_id) {
+void JoystickEventsDeadZone::OnButtonUp(uint8_t but_id) {
 #ifdef DEBUG_OUTPUT
     Serial.print("Up: ");
     Serial.println(but_id, DEC);
 #endif
+
+    if (client) {
+        client->OnButtonUp(but_id);
+    }
 }
 
-void JoystickEvents::OnButtonDn(uint8_t but_id) {
+void JoystickEventsDeadZone::OnButtonDn(uint8_t but_id) {
 #ifdef DEBUG_OUTPUT
     Serial.print("Down: ");
     Serial.println(but_id, DEC);
 #endif
+
+    if (client) {
+        client->OnButtonDn(but_id);
+    }
 }
 
-void JoystickEvents::OnMouseMoved(uint8_t x, uint8_t y) {
+void JoystickEventsDeadZone::OnMouseMoved(uint8_t x, uint8_t y) {
 #ifdef DEBUG_OUTPUT_RAW
     Serial.print("Mouse X: ");
     PrintHex<uint8_t >(x, 0x80);
     Serial.println("");
 #endif
 
-    uint8_t newX = lastMouseX;
-    uint8_t newY = lastMouseY;
+    uint8_t newX = centerMouseX;
+    uint8_t newY = centerMouseY;
+
+#ifdef DEBUG_OUTPUT
     uint8_t updated = 0;
-    
-    if ((x > (lastMouseX + deadZoneMouseX))
-            || (x < (lastMouseX - deadZoneMouseX))) {
+#endif
+
+    if ((x > (centerMouseX + deadZoneMouseX))
+            || (x < (centerMouseX - deadZoneMouseX))) {
         newX = x;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if ((y > (lastMouseY + deadZoneMouseY))
-            || (y < (lastMouseY - deadZoneMouseY))) {
+    if ((y > (centerMouseY + deadZoneMouseY))
+            || (y < (centerMouseY - deadZoneMouseY))) {
         newY = y;
+
+#ifdef DEBUG_OUTPUT
         updated = 1;
+#endif
     }
 
-    if (updated) {
 #ifdef DEBUG_OUTPUT
+    if (updated) {
         Serial.print("Mouse X: ");
         PrintHex<uint8_t >(newX, 0x80);
         Serial.print("\tY: ");
         PrintHex<uint8_t >(newY, 0x80);
         Serial.println("");
-#endif
     }
+#endif
 
-    lastMouseX = x;
-    lastMouseY = y;
+    if (client) {
+        client->OnMouseMoved(x, y);
+    }
 }
 

joystick_events.h

 /*
  * Saitek X52 Arduino USB Host Shield Library.
  * Copyright 2016 by Thomas Buck <xythobuz@xythobuz.de>
- * 
+ *
  * Based on the USB Host Library HID Joystick example
  * https://www.circuitsathome.com/mcu/hid-joystick-code-sample
- * 
+ *
  * 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 __JOYSTICK_EVENTS_H__
 #define __JOYSTICK_EVENTS_H__
 
-struct GamePadEventData {
-    GamePadEventData(uint16_t v) : X(v), Y(v), Z(v), Rx(v), Ry(v), Rz(v) { }
-    
+class GamePadEventData {
+  public:
+    GamePadEventData(uint16_t v) : X(v), Y(v), Z(v), Rx(v), Ry(v), Rz(v), Slider(v) { }
+    GamePadEventData(uint16_t x, uint16_t y, uint8_t z, uint8_t rx, uint8_t ry,
+            uint16_t rz, uint8_t slider)
+            : X(x), Y(y), Z(z), Rx(rx), Ry(ry), Rz(rz), Slider(slider) { }
+
     uint16_t X, Y, Rz; // 11bit, 11bit, 10bit
     uint8_t Z, Rx, Ry, Slider;
 };
 
 class JoystickEvents {
   public:
-    JoystickEvents();
+    JoystickEvents(JoystickEvents* _client = NULL) : client(_client) { }
+    virtual void OnGamePadChanged(const GamePadEventData& evt) = 0;
+    virtual void OnHatSwitch(uint8_t hat) = 0;
+    virtual void OnButtonUp(uint8_t but_id) = 0;
+    virtual void OnButtonDn(uint8_t but_id) = 0;
+    virtual void OnMouseMoved(uint8_t x, uint8_t y) = 0;
 
-    virtual void OnGamePadChanged(const GamePadEventData *evt);
+  protected:
+    JoystickEvents* client;
+};
+
+class JoystickEventsDeadZone : public JoystickEvents {
+  public:
+    virtual void OnGamePadChanged(const GamePadEventData& evt);
     virtual void OnHatSwitch(uint8_t hat);
     virtual void OnButtonUp(uint8_t but_id);
     virtual void OnButtonDn(uint8_t but_id);
     virtual void OnMouseMoved(uint8_t x, uint8_t y);
 
   protected:
-    GamePadEventData lastData;
-    GamePadEventData deadZone;
-    uint8_t lastMouseX, lastMouseY;
-    uint8_t deadZoneMouseX, deadZoneMouseY;
+    const static GamePadEventData deadZone;
+    const static uint8_t deadZoneMouseX, deadZoneMouseY;
+
+    const static GamePadEventData centerValue;
+    const static uint8_t centerMouseX, centerMouseY;
 };
 
 #endif // __JOYSTICK_EVENTS_H__

x52.cpp

 }
 
 uint8_t X52::sendCommand(uint16_t command, uint16_t val) {
+    if ((!usb) || (!hid)) {
+#ifdef DEBUG_OUTPUT
+        Serial.println("Invalid objects!");
+#endif
+        return 42;
+    }
+
     const uint8_t valLo = (val & 0x00FF);
     const uint8_t valHi = (val & 0xFF00) >> 8;