feat(hid): Update hid-rp to have support for Dualshock 4 hid report.

components/hid-rp/example/main/hid_rp_example.cpp

@@ -5,6 +5,7 @@
 
 #include "hid-rp-gamepad.hpp"
 #include "hid-rp-playstation.hpp"
+#include "hid-rp-ps4.hpp"
 #include "hid-rp-switch-pro.hpp"
 #include "hid-rp-xbox.hpp"
 #include "hid-rp.hpp"
@@ -90,6 +91,23 @@ extern "C" void app_main(void) {
   }
   logger.info("  Data: [{}]", str);
 
+  using PS4DualShock4Input = espp::PS4DualShock4GamepadInputReport<>;
+  PS4DualShock4Input ps4_input_report;
+  logger.info("{}", ps4_input_report);
+  logger.info("PS4 DualShock 4 Input Report Size: {}", ps4_input_report.get_report().size());
+  logger.info("PS4 DualShock 4 Input Report Data: {::#04X}", ps4_input_report.get_report());
+
+  auto ps4_raw_descriptor = espp::ps4_dualshock4_descriptor();
+  auto ps4_descriptor = std::vector<uint8_t>(ps4_raw_descriptor.begin(), ps4_raw_descriptor.end());
+
+  logger.info("PS4 DualShock 4 Report Descriptor:");
+  logger.info("  Size: {}", ps4_descriptor.size());
+  str = "";
+  for (auto &byte : ps4_descriptor) {
+    str += fmt::format("0x{:02X}, ", byte);
+  }
+  logger.info("  Data: [{}]", str);
+
   GamepadInput::Hat hat = GamepadInput::Hat::UP_RIGHT;
   int button_index = 5;
   float angle = 2.0f * M_PI * button_index / num_buttons;
@@ -100,13 +118,15 @@ extern "C" void app_main(void) {
   switch_pro_input_report.reset();
   dualsense_simple_input_report.reset();
   dualsense_complex_input_report.reset();
+  ps4_input_report.reset();
 
   // print out the reports in their default states
   logger.info("{}", gamepad_input_report);
   logger.info("{}", xbox_input_report);
   logger.info("{}", switch_pro_input_report);
   logger.info("{}", dualsense_simple_input_report);
   logger.info("{}", dualsense_complex_input_report);
+  logger.info("{}", ps4_input_report);
 
   // update the gamepad input report
   logger.info("{}", gamepad_input_report);
@@ -140,6 +160,17 @@ extern "C" void app_main(void) {
   dualsense_complex_input_report.set_left_trigger(std::abs(cos(angle)));
   dualsense_complex_input_report.set_right_trigger(std::abs(sin(angle)));
 
+  ps4_input_report.set_hat(hat);
+  ps4_input_report.set_button_cross(button_index == 1);
+  ps4_input_report.set_button_circle(button_index == 2);
+  ps4_input_report.set_button_square(button_index == 3);
+  ps4_input_report.set_button_triangle(button_index == 4);
+  ps4_input_report.set_left_joystick(128 + 127 * sin(angle), 128 + 127 * cos(angle));
+  ps4_input_report.set_right_joystick(128 + 127 * cos(angle), 128 + 127 * sin(angle));
+  ps4_input_report.set_l2_trigger(std::abs(cos(angle)) * 255);
+  ps4_input_report.set_r2_trigger(std::abs(sin(angle)) * 255);
+  ps4_input_report.set_battery_level(8);
+
   button_index = (button_index % num_buttons) + 1;
 
   // send an input report

components/hid-rp/include/hid-rp-ps4-formatters.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "format.hpp"
+
+template <uint8_t REPORT_ID>
+struct fmt::formatter<espp::PS4DualShock4GamepadInputReport<REPORT_ID>> {
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const espp::PS4DualShock4GamepadInputReport<REPORT_ID> &report,
+              FormatContext &ctx) const {
+    auto out = ctx.out();
+    fmt::format_to(out, "PS4DualShock4GamepadInputReport {{");
+    fmt::format_to(out, "left_stick: ({}, {}), ", report.get_left_joystick_x(),
+                   report.get_left_joystick_y());
+    fmt::format_to(out, "right_stick: ({}, {}), ", report.get_right_joystick_x(),
+                   report.get_right_joystick_y());
+    fmt::format_to(out, "triggers: (L2={}, R2={}), ", report.get_l2_trigger(),
+                   report.get_r2_trigger());
+    fmt::format_to(out, "hat: {}, ", static_cast<int>(report.get_hat()));
+    fmt::format_to(out, "buttons: [");
+    fmt::format_to(out, "Square={}, Cross={}, Circle={}, Triangle={}, ", report.get_button_square(),
+                   report.get_button_cross(), report.get_button_circle(),
+                   report.get_button_triangle());
+    fmt::format_to(out, "L1={}, R1={}, L2={}, R2={}, ", report.get_button_l1(),
+                   report.get_button_r1(), report.get_button_l2(), report.get_button_r2());
+    fmt::format_to(out, "Share={}, Options={}, L3={}, R3={}, ", report.get_button_share(),
+                   report.get_button_options(), report.get_button_l3(), report.get_button_r3());
+    fmt::format_to(out, "PS={}, Touchpad={}], ", report.get_button_home(),
+                   report.get_button_touchpad());
+    fmt::format_to(out, "battery: {}%, charging: {}, ", report.get_battery_level(),
+                   report.get_battery_charging());
+    auto gyro = report.get_gyroscope();
+    auto accel = report.get_accelerometer();
+    fmt::format_to(out, "gyro: ({}, {}, {}), ", gyro.X, gyro.Y, gyro.Z);
+    fmt::format_to(out, "accel: ({}, {}, {}), ", accel.X, accel.Y, accel.Z);
+    fmt::format_to(out, "timestamp: {}, counter: {}", report.get_timestamp(), report.get_counter());
+    return fmt::format_to(out, "}}");
+  }
+};
+
+template <uint8_t REPORT_ID> struct fmt::formatter<espp::PS4DualShock4OutputReport<REPORT_ID>> {
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const espp::PS4DualShock4OutputReport<REPORT_ID> &report, FormatContext &ctx) const {
+    auto out = ctx.out();
+    fmt::format_to(out, "PS4DualShock4OutputReport {{");
+    fmt::format_to(out, "data: [{::#02X}]", report.data);
+    return fmt::format_to(out, "}}");
+  }
+};