Game Controller

1. Introduction 

A game controller is an important input device for manually controlling a robot. Most game controllers generally have two joysticks, two triggers, two bumpers, four pad buttons, four user buttons, and three special buttons. Some game controllers also have a vibration motor, LEDs, and a speaker. Each joystick has two potentiometers for the X and Y axes and a push button. Each trigger has a potentiometer for its axis.

The Xbox 360 and PlayStation controllers are two of the most popular game controllers. They can be connected to a computer using a USB cable or Bluetooth, and can also be connected to a microcontroller using USB or Bluetooth. In this tutorial, we are going to use a PS4 controller and an ESP32 WROOM32 module. The ESP32 supports both classic Bluetooth and BLE, while the PS4 controller only supports classic Bluetooth.

2. Understanding the flow of Data and Signals from Game Controller to Actuator 

The ESP32 acts as a wireless receiver, parsing HID data from the PS4 controller and converting it into a common JoyData format. This data is then sent to the STM32 via UART, where the STM32 uses the JoyData to control the actuators. The ESP32 can be replaced with a Raspberry Pi Pico W or any other. The standardized JoyData format makes it easy to swap out the receiver as needed.

3. Joystick Data Format from Receiving Controller 

Creating a header file for the JoyData structure is a good practice, as it allows you to define the structure in a single place and include it in multiple source files. This makes it easier to include, maintain and update the structure if needed.

joy_msg.hpp

#ifndef _JOY_MSG_HPP
#define _JOY_MSG_HPP

#include <math.h>
#include <stdint.h>

#define BUTTONS(button) (1 << button)

namespace myPS4
{
  enum Buttons
  {
    CROSS,
    CIRCLE,
    SQUARE,
    TRIANGLE,
    SHARE,
    PS_BUTTON,
    OPTION,
    L3,
    R3,
    L1,
    R1,
    UP,
    DOWN,
    LEFT,
    RIGHT,
    TOUCH
  };
}

namespace myXBox
{
  enum Buttons
  {
    A,
    B,
    X,
    Y,
    BACK,
    XBOX_BUTTON,
    START,
    LSTICK,
    RSTICK,
    LB,
    RB,
    UP,
    DOWN,
    LEFT,
    RIGHT
  };
}

#pragma pack(push, 1)
struct JoyData
{
  int8_t lx;
  int8_t ly;
  int8_t rx;
  int8_t ry;
  uint8_t lt;
  uint8_t rt;
  uint16_t buttons;
};
#pragma pack(pop)

#endif // _JOY_MSG_HPP

The total size of JoyData is 8-bytes and contains the following fields:

lx: Left joystick X-axis value
ly: Left joystick Y-axis value
rx: Right joystick X-axis value
ry: Right joystick Y-axis value
lt: Left trigger value
rt: Right trigger value
buttons: Bitmask representing the state of the buttons. Each button is represented by a bit in the bitmask, where 1 indicates that the button is pressed and 0 indicates that it is not pressed.

The buttons are defined in the myPS4 and myXBox namespaces, and each button is assigned a unique value. The buttons are represented as bitmasks, which means that multiple buttons can be pressed at the same time. The JoyData structure is packed to ensure that the data is aligned correctly in memory. The #pragma pack(push, 1) directive tells the compiler to align the structure on a 1-byte boundary, which means that there will be no padding between the fields of the structure. The #pragma pack(pop) directive restores the previous packing alignment.

4. Setting ESP32 as Receiver 

ESP32 WROOM32 — **DOIT ESP32 DEVKIT V1**

There are some Arduino libraries available for interfacing PS4 controller with ESP32. Some examples for ESP32 IDF are also avialable which uses Bluetooth as well as USB. We are going to use Arduino library for this tutorial.

4.1. Installing ESP32 Board by Espressif in Arduino IDE 

Open Arduino IDE.
Search for ESP32 in the board manager.
Install the board by Espressif.

4.2. Finding MAC Address of ESP32 and Setting up PS4 Controller 

The MAC address is used to pair the PS4 controller with the ESP32 board. Follow the steps below to find the MAC address of the ESP32 board and set up the PS4 controller:

Open Arduino IDE and create a new sketch.

Copy the following code into the sketch:

esp_mac_loockup.ino

#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "BluetoothSerial.h"

BluetoothSerial SerialBT;

void printDeviceAddress() {
  const uint8_t* point = esp_bt_dev_get_address();
  for (int i = 0; i < 6; i++) {
    char str[3];
    sprintf(str, "%02X", (int)point[i]);
    Serial.print(str);
    if (i < 5){
      Serial.print(":");
    }
  }
}

void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32 Bluetooth");
}

void loop() {
  printDeviceAddress();
  delay(1000);
}

Save the sketch as esp_mac_loockup.ino.
Select board DOIT ESP32 DEVKIT V1 from Tools > Board > esp32.
Upload the code to the ESP32 board and open the Serial Monitor. The MAC address will be displayed in the Serial Monitor.
Open SixaxisPairTool on Windows. See installation if you do not have. Plug the PS4 controller to PC using USB Cable. Driver for the controller will be installed, if it is first time.
Connect the PS4 controller to the PC using a USB cable. The SixaxisPairTool will display the MAC address of the PS4 controller. Write the Bluetooth Mac Address of the ESP32 into Master MAC Adrress Field and click update.

4.3. Using PS4Controller Library by Juan Pablo Marquez 

Install the library from Arduino Library Manager or download from here.

Create a new sketch and paste the following contents:

esp_rx_ps4_library.ino

#define DEBUG // Disable it by commenting in actual implementation

#include <PS4Controller.h>
#include "crc8.hpp"
#include "joy_msg.hpp"
using namespace myPS4;

/** @brief Pins assignments of ESP32 */
#define IN_BUILT_LED_BLUE 2
#define RXD2 16
#define TXD2 17

/** @brief Start byte of packet */
#define START_BYTE 0xA5

CRC8 crc(7);

JoyData jdata;
bool is_flash_set = false;
bool is_braked;

uint32_t last_transmit = 0;

/** @brief Initialize controller parameters */
void setup() {

  Serial.begin(115200, SERIAL_8N1);
  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);

  pinMode(IN_BUILT_LED_BLUE, OUTPUT);
  digitalWrite(IN_BUILT_LED_BLUE, LOW);

  PS4.attachOnConnect(onConnect);
  PS4.attachOnDisconnect(onDisConnect);

  PS4.begin();
  Serial.print("ESP32 MAC: ");
  Serial.println(PS4.getAddress());
}

/** @brief Operation */
void loop() {
  if (!PS4.isConnected())
    return;

  uint32_t now = millis();
  if (now - last_transmit < 10)
    return;

  uint8_t packet[10];
  jdata.lx = PS4.LStickX();
  jdata.ly = -PS4.LStickY();
  jdata.rx = PS4.RStickX();
  jdata.ry = -PS4.RStickY();
  jdata.lt = PS4.L2Value();
  jdata.rt = PS4.R2Value();

  jdata.buttons = 0;

  if (PS4.Cross()) jdata.buttons |= BUTTONS(CROSS);
  if (PS4.Circle()) jdata.buttons |= BUTTONS(CIRCLE);
  if (PS4.Square()) jdata.buttons |= BUTTONS(SQUARE);
  if (PS4.Triangle()) jdata.buttons |= BUTTONS(TRIANGLE);

  if (PS4.Share()) jdata.buttons |= BUTTONS(SHARE);
  if (PS4.PSButton()) jdata.buttons |= BUTTONS(PS_BUTTON);
  if (PS4.Options()) jdata.buttons |= BUTTONS(OPTION);

  if (PS4.L3()) jdata.buttons |= BUTTONS(L3);
  if (PS4.R3()) jdata.buttons |= BUTTONS(R3);
  if (PS4.L1()) jdata.buttons |= BUTTONS(L1);
  if (PS4.R1()) jdata.buttons |= BUTTONS(R1);

  if (PS4.Up()) jdata.buttons |= BUTTONS(UP);
  if (PS4.UpLeft()) jdata.buttons |= (BUTTONS(UP) | BUTTONS(LEFT));
  if (PS4.Left()) jdata.buttons |= BUTTONS(LEFT);
  if (PS4.DownLeft()) jdata.buttons |= (BUTTONS(LEFT) | BUTTONS(DOWN));
  if (PS4.Down()) jdata.buttons |= BUTTONS(DOWN);
  if (PS4.DownRight()) jdata.buttons |= (BUTTONS(DOWN) | BUTTONS(RIGHT));
  if (PS4.Right()) jdata.buttons |= BUTTONS(RIGHT);
  if (PS4.UpRight()) jdata.buttons |= (BUTTONS(UP) | BUTTONS(RIGHT));
  
  if (PS4.Touchpad()) jdata.buttons |= BUTTONS(TOUCH);

  packet[0] = START_BYTE;
  memcpy((uint8_t*)packet + 1, (uint8_t*)&jdata, sizeof(jdata));
  packet[9] = crc.get_hash(packet + 1, sizeof(jdata));

  // Finally send packet to STM32 through UART2
  Serial2.write(packet, sizeof(packet));

  if (PS4.PSButton()) {
    if (PS4.L1() && PS4.R1()) {
      if (is_braked) {
        PS4.setLed(0, 255, 0);
        PS4.sendToController();
        // Serial.println("Brake removed");
        is_braked = false;
      }
    } else {
      if (!is_braked) {
        PS4.setLed(255, 0, 255);
        PS4.sendToController();
        // Serial.println("Braked");
        is_braked = true;
      }
    }
  }

#ifdef DEBUG
  Serial.printf("%lu: %hd %hd %hd %hd %hu %hu %04X\n",
                now - last_transmit, jdata.lx, jdata.ly, jdata.rx, jdata.ry, jdata.lt, jdata.rt, jdata.buttons);
#endif

  last_transmit = now;
}

/** @brief Callback on connect */
void onConnect() {
  digitalWrite(IN_BUILT_LED_BLUE, HIGH);
  Serial.printf("Battery: %d\n", PS4.Battery());
  PS4.setLed(0, 255, 0);
  PS4.sendToController();
  Serial.println("PS4 Connected.");
}

/** @brief Callback on disconnect */
void onDisConnect() {
  digitalWrite(IN_BUILT_LED_BLUE, LOW);
  Serial.println("!!PS4 Disconnected!!");
}

Save the sketch as esp_rx_ps4_library.ino.
Create a new file joy_msg.hpp in the same directory as the sketch. Copy the contents of the JoyData structure from above into this.
Create two files crc8.hpp and crc8.cpp in the same directory as the sketch. The contents of these files are as follows:

crc8.hpp

/**
 *******************************************************************************
 * @file    crc8.hpp
 * @brief   Header file 8-bit crc calculation
 * @author  Robotics Team, IOE Pulchowk Campus
 *******************************************************************************
 */

#ifndef CRC8_HPP_
#define CRC8_HPP_

#include <stdint.h>

#define WIDTH (8)                       /**< CRC width */
#define CRC_HASH_TABLE_SIZE (256)       /**< Size of CRC hash table */
#define TOP_BIT (1 << 7)                /**< Top bit position */

/**
 * @brief Class for CRC-8 checksum calculation.
 */
class CRC8
{
public:
    /**
     * @brief Constructor for CRC8 class.
     * @param polynomial Polynomial value for CRC calculation.
     */
    CRC8(uint8_t polynomial);

    /**
     * @brief Destructor for CRC8 class.
     */
    ~CRC8() {}

    /**
     * @brief Calculate CRC-8 checksum for the given data.
     * @param buf Pointer to the data buffer.
     * @param len Length of the data buffer.
     * @return CRC-8 checksum value.
     */
    uint8_t get_hash(uint8_t *buf, uint16_t len);

private:
    uint8_t table_[CRC_HASH_TABLE_SIZE]; /**< CRC hash table. */
};

#endif // CRC_HPP_

crc8.cpp

/**
********************************************************************************
 * @file crc8.cpp
 * @brief Implementation file for the crc8 class
 * @author Robotics Team, IOE Pulchowk Campus
 * @date 2023
 *******************************************************************************
 */

#include "crc8.hpp"

/**
 * @brief Constructor for CRC8 class.
 * 
 * This constructor initializes the CRC8 object with the specified polynomial.
 * It pre-computes the CRC hash table used for CRC calculation.
 * 
 * @param poly The polynomial value for CRC calculation.
 */
CRC8::CRC8(uint8_t poly)
{
    uint8_t remainder;
    int dividend = 0;

    for (; dividend < 256; ++dividend)
    {
        remainder = dividend << (WIDTH - 8);

        for (uint8_t b = 8; b > 0; --b)
        {
            if (remainder & TOP_BIT)
            {
                remainder = (remainder << 1) ^ poly;
            }
            else
            {
                remainder = (remainder << 1);
            }
        }
        table_[dividend] = remainder;
    }
}

/**
 * @brief Calculate CRC-8 checksum for the given data.
 * 
 * This method calculates the CRC-8 checksum for the provided data buffer.
 * 
 * @param buf Pointer to the data buffer.
 * @param len Length of the data buffer.
 * @return CRC-8 checksum value.
 */
uint8_t CRC8::get_hash(uint8_t *buf, uint16_t len)
{
    uint8_t data;
    uint8_t remainder = 0;

    for (uint16_t index = 0; index < len; ++index)
    {
        data = buf[index] ^ (remainder >> (WIDTH - 8));
        remainder = table_[data] ^ (remainder << 8);
    }

    return remainder;
}

Select board DOIT ESP32 DEVKIT V1 from Tools > Board > esp32.
Select port and upload the sketch to the ESP32 board.
Open the Serial Monitor. Press the PS button on the PS4 controller to turn it on. You should see the joystick data changing according to the input from the PS4 controller.

4.4. Using ESP32_Bluepad32 

In Arduino IDE, go to File > Preferences and add the following URL to the Additional Board Manager URLs field:

https://raw.githubusercontent.com/ricardoquesada/esp32-arduino-lib-builder/master/bluepad32_files/package_esp32_bluepad32_index.json

Open the Board Manager by going to Tools > Board > Board Manager. Search for esp32_bluepad32 by Ricardo Quesda and install the package.

Create a new sketch and paste the following contents:

esp_rx_bluepad.ino

#include <Bluepad32.h>
#include "joy_msg.hpp"
#include "crc8.hpp"

#define IN_BUILT_LED_BLUE 2
#define IN_BUILT_LED_BLUE 2
#define RXD2 16
#define TXD2 17
#define START_BYTE 0xA5

bool connected = false;

namespace BPB {
enum BluePadButtonsMask {
  Cross = 0x1,
  Circle = 0x2,
  Square = 0x04,
  Triangle = 0x08,
  Share = 0x02,
  Power = 0x01,
  Option = 0x04,
  L3 = 0x100,
  R3 = 0x200,
  L1 = 0x10,
  R1 = 0x20,
  Up = 0x01,
  Down = 0x02,
  Left = 0x08,
  Right = 0x04
  // Touch
};
}

ControllerPtr myControllers[BP32_MAX_GAMEPADS];
CRC8 crc(7);
JoyData jdata;
bool isBraked = false;
uint32_t last_transmit = 0;

// This callback gets called any time a new gamepad is connected.
// Up to 4 gamepads can be connected at the same time.
void onConnectedController(ControllerPtr ctl) {
  bool foundEmptySlot = false;
  // for (int i = 0; i < BP32_MAX_GAMEPADS; i++) {
    if (myControllers[0] == nullptr) {
      Serial.printf("CALLBACK: Controller is connected, index=%d\n", 0);
      // Additionally, you can get certain gamepad properties like:
      // Model, VID, PID, BTAddr, flags, etc.
      ControllerProperties properties = ctl->getProperties();
      Serial.printf("Controller model: %s, VID=0x%04x, PID=0x%04x\n", ctl->getModelName().c_str(), properties.vendor_id,
                    properties.product_id);
      myControllers[0] = ctl;
      foundEmptySlot = true;
      connected = true;
      digitalWrite(IN_BUILT_LED_BLUE, HIGH);
      ctl->setColorLED(0, 255, 0);
      // break;
    // }
  }
  if (!foundEmptySlot) {
    Serial.println("CALLBACK: Controller connected, but could not found empty slot");
  }
}

void onDisconnectedController(ControllerPtr ctl) {
  bool foundController = false;

  // for (int i = 0; i < BP32_MAX_GAMEPADS; i++) {
    if (myControllers[0] == ctl) {
      Serial.printf("CALLBACK: Controller disconnected from index=%d\n", 0);
      myControllers[0] = nullptr;
      foundController = true;
      connected = false;
      digitalWrite(IN_BUILT_LED_BLUE, LOW);
      // break;
    // }
  }

  if (!foundController) {
    Serial.println("CALLBACK: Controller disconnected, but not found in myControllers");
  }
}

void blinkColorLED(ControllerPtr ctl) {
  static bool isRed = false;
  static uint32_t last_blink = 0;
  uint32_t now = millis();
  if (now - last_blink > 1000) {
    if (isRed) {
      if (isBraked) {
        ctl->setColorLED(255, 0, 255);
      } else {
        ctl->setColorLED(0, 255, 0);
      }
    } else {
      ctl->setColorLED(50, 0, 0);
    }

    isRed = !isRed;
    last_blink = now;
  }
}

void dumpGamepad(ControllerPtr ctl) {
  Serial.printf(
    "idx=%d, dpad: 0x%02x, buttons: 0x%04x, axis L: %4d, %4d, axis R: %4d, %4d, brake: %4d, throttle: %4d, "
    "misc: 0x%02x, gyro x:%6d y:%6d z:%6d, accel x:%6d y:%6d z:%6d bat:%d\n",
    ctl->index(),        // Controller Index
    ctl->dpad(),         // D-pad
    ctl->buttons(),      // bitmask of pressed buttons
    ctl->axisX(),        // (-511 - 512) left X Axis
    ctl->axisY(),        // (-511 - 512) left Y axis
    ctl->axisRX(),       // (-511 - 512) right X axis
    ctl->axisRY(),       // (-511 - 512) right Y axis
    ctl->brake(),        // (0 - 1023): brake button
    ctl->throttle(),     // (0 - 1023): throttle (AKA gas) button
    ctl->miscButtons(),  // bitmask of pressed "misc" buttons
    ctl->gyroX(),        // Gyro X
    ctl->gyroY(),        // Gyro Y
    ctl->gyroZ(),        // Gyro Z
    ctl->accelX(),       // Accelerometer X
    ctl->accelY(),       // Accelerometer Y
    ctl->accelZ(),       // Accelerometer Z
    ctl->battery());
}

void dumpJoyData(JoyData &jd) {
  Serial.printf("JoyData:: lx:%d ly:%d rx:%d ry:%d lt:%u rt:%u bt:%04x\n",
                jd.lx,
                jd.ly,
                jd.rx,
                jd.ry,
                jd.lt,
                jd.rt,
                jd.buttons);
}

template<typename T>
T map(T in, T inMin, T inMid, T inMax, T outMin, T outMid, T outMax) {
  T out;
  if (in <= inMid) {
    // Map from [inMin, inMid] to [outMin, outMid]
    T inRange = inMid - inMin;
    T outRange = outMid - outMin;
    out = (in - inMin) * outRange / inRange + outMin;
  } else {
    // Map from [inMid, inMax] to [outMid, outMax]
    T inRange = inMax - inMid;
    T outRange = outMax - outMid;
    out = (in - inMid) * outRange / inRange + outMid;
  }
  return out;
}

void processControllers() {
  auto myController = myControllers[0];
  if (myController && myController->isConnected() && myController->hasData()) {
    if (myController->isGamepad()) {
      //  dumpGamepad(myController);

      jdata.lx = map(myController->axisX(), -508, -12, 512, -127, 0, 127);
      jdata.ly = map(myController->axisY(), -508, 8, 512, -127, 0, 127);
      jdata.rx = map(myController->axisRX(), -508, -32, 512, -127, 0, 127);
      jdata.ry = map(myController->axisRY(), -508, 18, 512, -127, 0, 127);
      jdata.lt = map(myController->brake(), 0, 1020, 0, 255);
      jdata.rt = map(myController->throttle(), 0, 1020, 0, 255);

      jdata.buttons = 0;
      if (myController->buttons() & BPB::Cross) jdata.buttons |= BUTTONS(myPS4::CROSS);
      if (myController->buttons() & BPB::Circle) jdata.buttons |= BUTTONS(myPS4::CIRCLE);
      if (myController->buttons() & BPB::Square) jdata.buttons |= BUTTONS(myPS4::SQUARE);
      if (myController->buttons() & BPB::Triangle) jdata.buttons |= BUTTONS(myPS4::TRIANGLE);
      if (myController->miscButtons() & BPB::Share) jdata.buttons |= BUTTONS(myPS4::SHARE);
      if (myController->miscButtons() & BPB::Power) jdata.buttons |= BUTTONS(myPS4::PS_BUTTON);
      if (myController->miscButtons() & BPB::Option) jdata.buttons |= BUTTONS(myPS4::OPTION);
      if (myController->buttons() & BPB::L3) jdata.buttons |= BUTTONS(myPS4::L3);
      if (myController->buttons() & BPB::R3) jdata.buttons |= BUTTONS(myPS4::R3);
      if (myController->buttons() & BPB::L1) jdata.buttons |= BUTTONS(myPS4::L1);
      if (myController->buttons() & BPB::R1) jdata.buttons |= BUTTONS(myPS4::R1);
      if (myController->dpad() & BPB::Up) jdata.buttons |= BUTTONS(myPS4::UP);
      if (myController->dpad() & BPB::Down) jdata.buttons |= BUTTONS(myPS4::DOWN);
      if (myController->dpad() & BPB::Left) jdata.buttons |= BUTTONS(myPS4::LEFT);
      if (myController->dpad() & BPB::Right) jdata.buttons |= BUTTONS(myPS4::RIGHT);

      if (myController->miscButtons() & BPB::Power) {
        if (myController->buttons() & BPB::L1 && myController->buttons() & BPB::R1) {
          myController->setColorLED(0, 255, 0);
          isBraked = false;
        } else {
          myController->setColorLED(255, 0, 255);
          isBraked = true;
        }
      }

      if (myController->battery() < 100)
        blinkColorLED(myController);
    }
  }
}

void sendPacket() {
  uint32_t now = millis();

  if (now - last_transmit >= 10) {
    uint8_t packet[sizeof(jdata) + 2];
    packet[0] = START_BYTE;
    memcpy((uint8_t *)packet + 1, (uint8_t *)&jdata, sizeof(jdata));
    packet[9] = crc.get_hash(packet + 1, sizeof(jdata));

    // Finally send packet to STM32 through UART2
    Serial2.write(packet, sizeof(packet));
    // Serial.printf("%lu\t", now - last_transmit);
    last_transmit = now;
    // dumpJoyData(jdata);
  }
}
// Arduino setup function. Runs in CPU 1
void setup() {
  pinMode(IN_BUILT_LED_BLUE, OUTPUT);
  Serial.begin(115200);
  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);

  Serial.printf("Firmware: %s\n", BP32.firmwareVersion());
  const uint8_t *addr = BP32.localBdAddress();
  Serial.printf("BD Addr: %2X:%2X:%2X:%2X:%2X:%2X\n", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);

  // Setup the Bluepad32 callbacks
  BP32.setup(&onConnectedController, &onDisconnectedController);

  // "forgetBluetoothKeys()" should be called when the user performs
  // a "device factory reset", or similar.
  // Calling "forgetBluetoothKeys" in setup() just as an example.
  // Forgetting Bluetooth keys prevents "paired" gamepads to reconnect.
  // But it might also fix some connection / re-connection issues.
  BP32.forgetBluetoothKeys();


  // Enables mouse / touchpad support for gamepads that support them.
  // When enabled, controllers like DualSense and DualShock4 generate two connected devices:
  // - First one: the gamepad
  // - Second one, which is a "virtual device", is a mouse.
  // By default, it is disabled.
  BP32.enableVirtualDevice(false);

  BP32.enableNewBluetoothConnections(false);
}

// Arduino loop function. Runs in CPU 1.
void loop() {
  // This call fetches all the controllers' data.
  // Call this function in your main loop.
  if (BP32.update()) {
    processControllers();
    if (connected)
      sendPacket();
  }
  // The main loop must have some kind of "yield to lower priority task" event.
  // Otherwise, the watchdog will get triggered.
  // If your main loop doesn't have one, just add a simple `vTaskDelay(1)`.
  // Detailed info here:
  // https://stackoverflow.com/questions/66278271/task-watchdog-got-triggered-the-tasks-did-not-reset-the-watchdog-in-time

  vTaskDelay(1);
  // delay(150);
}

Save the sketch as esp_rx_bluepad.ino.
Create a new file joy_msg.hpp in the same directory as the sketch. Copy the contents of the JoyData structure from above into this.
Create two files crc8.hpp and crc8.cpp in the same directory as the sketch. The contents are same as above.
Select board DOIT ESP32 DEVKIT V1 from Tools > Board > esp32_bluepad32.
Select port and upload the sketch to the ESP32 board.
Open the Serial Monitor. Press the PS button and the Share button on the PS4 controller to pair it with the ESP32 board. You should see the joystick data changing according to the input from the PS4 controller.

For more information on the ESP32_Bluepad32 package, see the documentation.

5. Setting Raspberry Pi Pico W as Receiver 

For the Raspberry Pi Pico W, we use Pico SDK. The Pico SDK is a C/C++ SDK for the Raspberry Pi Pico and Pico W. It provides a set of libraries and tools to help you develop applications for the Pico and Pico W.

Till now, we have provided code straight on the page. Now, we are going to deal with huge code base. So we will provide the link of github repository. Follow the following instructions below to set up the Pico SDK and build the code for receving from PS4 controller:

To install Pico SDK, run pico_setup.sh cloning from here.

git clone https://github.com/raspberrypi/pico-setup.git
cd pico-setup
export SKIP_VSCODE=1 && bash pico_setup.sh

Clone this repository and update submodule.

git clone https://github.com/Robotics-Club-Pulchowk/picow_ds4.git
cd picow_ds4
git submodule update --init --recursive

Find out MAC Address of PS4 Controller. In easy way, connect it to yout PC and see the MAC Address.
Get into the source code folder, open Src/bt_hid.c, scroll down a little and replace remote_addr_string value by the MAC address of PS4.
To print data on Serial Monitor, enable stdio usb by editing this line of Src/CMakeLists.txt.
```
pico_enable_stdio_usb(picow_ds4 1)
```

From the project directory, make build folder, execute cmake and makefile.

cd picow_ds4
git submodule update --init --recursive
mkdir build
cd build
cmake .. # you might use `-DPICO_BOARD=pico_w -DPICO_SDK_PATH=/your/path/to/pico-sdk` if environment is not set
make -j4

.uf2 file is used for programming Pico. You can find it at build/src/picow_ds4.uf2

Hold the boot button and connect the Pico W to PC using USB.
Drag and drop the picow_ds4.uf2 file from build/src to Pico W Mass Storage. You also can use similar command.
```
# Just hit `tab` `tab` after `/media`.
cp picow_ds4.uf2 /media/pi/PICOW
```
Long press share and PS4 button simultaneous untill fast blink of PS4 LED. It will connect to Pico W. Pico W blinks its green LED if no controller is connected and solid green if it detects and connects to a controller.

Pico W sends uart packet same as ESP32 througth its UART0 default Tx and Rx pin i.e. pin 0 and pin 1.

6. Setting STM32 to Receive Data from ESP32 or Pico W 

6.1 STM32CubeMX Configuration 

Open CubeMX and generate basic code with:
- microcontroller: stm32f407vgt6 or board: STM32F407VG-DISC1
- project name: stm32_joystick_master
- Toolchain/IDE: CMake
Move to STM32CubeMX Pinout and Congiguration. From Categories, select Connectivity > USART4. Change mode to Asynchronous mode. You may change alternate pins from for USART4_RX and USART4_TX.
Under Configuration > DMA Settings, add USART4_RX DMA request.
Set PD12 Pin as GPIO Output. This pin is used to turn on/off the LED.
Generate code and open the project.

6.2. Joystick Class with Other Classes and Setups 

Create a new file joy_msg.hpp inside Core > Inc. Copy and paste the below contents.

joy_msg.hpp

#ifndef _JOY_MSG_HPP
#define _JOY_MSG_HPP

#include <stdint.h>

#define BUTTONS(button) (1 << button)

namespace PS4
{
  enum Buttons
  {
    CROSS,
    CIRCLE,
    SQUARE,
    TRIANGLE,
    SHARE,
    PS,
    OPTION,
    L3,
    R3,
    L1,
    R1,
    UP,
    DOWN,
    LEFT,
    RIGHT,
    TOUCH
  };
}

namespace XBox
{
  enum Buttons
  {
    A,
    B,
    X,
    Y,
    BACK,
    XBOX,
    START,
    LSTICL,
    RSTICK,
    LB,
    RB,
    UP,
    DOWN,
    LEFT,
    RIGHT
  };
}

#pragma pack(push, 1)
struct JoyData
{
  int8_t lx;
  int8_t ly;
  int8_t rx;
  int8_t ry;
  uint8_t lt;
  uint8_t rt;
  uint16_t buttons;
};
#pragma pack(pop)

#endif // _JOY_MSG_HPP

This joy_msg.hpp has different identifier names for namespaces and some buttons than above.

Create a new file printf_config.h inside Core > Inc. Copy and paste the below contents:

printf_config.c

#include "stm32f4xx_hal.h"

#ifdef STDIO_USB
#include "usbd_cdc_if.h"

/*Redirect printf to USB CDC. We can see output on Serial Monitor*/
int _write(int file, char *data, int len)
{
    CDC_Transmit_FS((uint8_t *)data, (uint16_t)len);
    return len;
}

#else
/*Redirect printf to ITM. We can see output on Serial Wire Viewer on STM32CubeProgrammer*/
int _write(int file, char *data, int len)
{
    for (int i = 0; i < len; ++i)
    {
        ITM_SendChar(data[i]);
    }
    return len;
}
#endif

Create two new files crc8.hpp and crc8.cpp inside Core > Inc and Core > Src respectively. The contents of these files are as follows:

crc8.hpp

/**
 ******************************************************************************
 * @file    crc8.hpp
 * @brief   Header file 8-bit crc calculation
 * @author  Robotics Team, IOE Pulchowk Campus
 ******************************************************************************
 */

#ifndef CRC8_HPP_
#define CRC8_HPP_

#include <cstdint>

#ifndef CRC_POLYNOMIAL
#define CRC_POLYNOMIAL 7 /**< CRC Polynomial **/
#endif

// clang-format off
#define CRC_WIDTH               8           /**< CRC width */
#define CRC_HASH_TABLE_SIZE     256         /**< Size of CRC hash table */
#define TOP_BIT                 (1 << 7)    /**< Top bit position */
// clang-format on

/**
 * @brief Class for CRC-8 checksum calculation.
 */
class CRC8
{
public:
    /**
     * @brief Destructor for CRC8 class.
     */
    ~CRC8() {}

    /**
     * @brief Calculate CRC-8 checksum for uint8_t type data.
     * @param buf Pointer to the data buffer.
     * @param len Length of the data buffer.
     * @return CRC-8 checksum value.
     */
    uint8_t get_hash(uint8_t *buf, uint16_t len);

    static CRC8 Instance; /**< Singleton instance of CRC8 class. */

private:
    static uint8_t polynomial;                  /** CRC polynomial **/
    static uint8_t table_[CRC_HASH_TABLE_SIZE]; /**< CRC hash table. */

    /**
     * @brief Private constructor for CRC8 class.
     */
    CRC8();

    /**
     * @brief Initialize the CRC hash table.
     */
    static void initialize_table();
};

#endif // CRC_HPP_

crc8.cpp

/***********************************************************************************************
 * @file crc8.cpp
 * @brief Implementation file for the crc8 class
 * @author Robotics Team, IOE Pulchowk Campus
 * @date 2024
 *
 * For more information on CRC calculation in C, \
 * see \link https://barrgroup.com/embedded-systems/how-to/crc-calculation-c-code \endlink.
 **********************************************************************************************/

#include "crc8.hpp"

CRC8 CRC8::Instance;
uint8_t CRC8::polynomial;
uint8_t CRC8::table_[CRC_HASH_TABLE_SIZE];

CRC8::CRC8()
{
    polynomial = CRC_POLYNOMIAL;
    initialize_table();
}

void CRC8::initialize_table()
{
    uint8_t remainder;
    int dividend = 0;

    for (; dividend < 256; ++dividend)
    {
#if CRC_WIDTH == 8
        remainder = dividend;
#else
        remainder = dividend << (CRC_WIDTH - 8);
#endif
        for (uint8_t b = 8; b > 0; --b)
        {
            if (remainder & TOP_BIT)
            {
                remainder = (remainder << 1) ^ polynomial;
            }
            else
            {
                remainder = (remainder << 1);
            }
        }
        table_[dividend] = remainder;
    }
}

uint8_t CRC8::get_hash(uint8_t *buf, uint16_t len)
{
    uint8_t data;
    uint8_t remainder = 0;

    for (uint16_t index = 0; index < len; ++index)
    {
#if CRC_WIDTH == 8
        data = buf[index] ^ remainder;
#else
        data = buf[index] ^ (remainder >> (CRC_WIDTH - 8));
#endif
        remainder = table_[data] ^ (remainder << 8);
    }

    return remainder;
}

Create two new files uart_def.h and uart.hpp inside Core > Inc and a new file uart.cpp inside Core > Src respectively. The contents of these files are as follows:

uart_def.h

#ifndef UART_DEFINES_H__
#define UART_DEFINES_H__

#ifndef UART_START_BYTE
#define UART_START_BYTE 0xA5 /**< Start byte of packet */
#endif

#ifndef UART_MAX_RX_BUFFER_SIZE
#define UART_MAX_RX_BUFFER_SIZE 50 /**< Maximum size of receive buffer */
#endif

#ifndef UART_MAX_TX_BUFFER_SIZE
#define UART_MAX_TX_BUFFER_SIZE 50 /**< Maximum size of transmit buffer */
#endif

#ifndef UART_CONNCETION_TIMEOUT
#define UART_CONNCETION_TIMEOUT 100 /**< Timeout for UART connection */
#endif

#endif // UART_DEFINES_H__

uart.hpp

/**
 ******************************************************************************
 * @file    uart.hpp
 * @brief   Header file for our custom UART Class
 * @author  Robotics Team, IOE Pulchowk Campus
 ******************************************************************************
 */

#ifndef UART_HPP__
#define UART_HPP__

#include "stm32f4xx_hal.h"
#include "crc8.hpp"
#include "uart_def.h"

enum UARTMode
{
  UART_RECEIVING,    /**< UART in receiving mode */
  UART_TRANSMITTING, /**< UART in transmitting mode */
  UART_BOTH          /**< UART in both receiving and transmitting mode */
};

/**
 * @brief Enumeration defining the status of UART reception
 */
enum UARTReceiveStatus
{
  UART_START_BYTE_MATCHED, /**< Start byte of packet matched */
  UART_START_BYTE_ERROR,  /**< Start byte of packet failed to match */
  UART_CRC_MATCHED,        /**< CRC hash matched */
  UART_CRC_ERROR,         /**< CRC hash failed to match */
  UART_INTERRUPT_CRASHED   /**< UART Interrupt crashed while receiving*/
};

/**
 * @brief Class representing the UART communication functionality
 */
class UART
{
public:
  /**
   * @brief Default constructor for UART class
   * @warning Be careful, do not call init() if uart handle is not set
   */
  UART();

  /**
   * @brief Constructor for UART class
   * @param[in] _huart Pointer to the UART handle
   * @param[in] _mode UART Mode
   * @param[in] _rt_size Size of receiving or transmitting data
   * @param[in] _t_size Size of transmittin data used if r_size and t_size are different
   */
  UART(UART_HandleTypeDef *_huart, UARTMode _mode, uint16_t _rt_size, uint16_t _t_size = 0);

  /**
   * @brief Default copy constructor for UART class
   */
  UART(const UART &) = default;

  /**
   * @brief Default assignment operator for UART class
   */
  UART &operator=(const UART &) = default;

  /**
   * @brief Default destructor for UART class
   */
  ~UART() = default;

  /**
   * @brief Initialize UART communication
   */
  bool init();

  /**
   * @brief Parse the received data and check for start byte, data, and CRC
   */
  UARTReceiveStatus process_receive_callback();

  /**
   * @brief Process transmit callback to update status
   */
  void process_transmit_callback();

  /**
   * @brief Copy data from the received data buffer to the provided buffer
   * @param[in] Pointer to the data to be received
   */
  bool get_received_data(uint8_t *data);

  /**
   * @brief Transmit data over UART in blocking mode
   * @param[in] Pointer to the data to be transmitted
   * @return True if the data is transmitted successfully, false otherwise
   */
  bool transmit(uint8_t *);

  /**
   * @brief Get the UART instance
   * @return Pointer to the UART handle
   */
  USART_TypeDef *get_uart_instance();

  /**
   * @brief Check if the UART is connected
   * @return True if connected, false otherwise
   */
  bool connected();

  /**
   * @brief Get the tick count of the last received data
   * @return Tick count of the last received data
   */
  uint32_t get_last_receive_tick();

  /**
   * @brief Get the tick count of the last data reception completion
   * @return Tick count of the last data reception completion
   */
  uint32_t get_last_receive_cplt_tick();

  /**
   * @brief Get the tick count of the last data transmission
   * @return Tick count of the last data transmission
   */
  uint32_t get_last_transmit_tick();

  /**
   * @brief Get the tick count of the last data transmission completion
   * @return Tick count of the last data transmission completion
   */
  uint32_t get_last_transmit_cplt_tick();

  /**
   * @brief Get the period of last data reception completion
   * @return Period of last data reception completion
   */
  uint32_t get_receive_cplt_period();

  /**
   * @brief Get the frequency of last data reception completion
   * @return Frequency(Hz) of last data reception completion
   */
  float get_receive_cplt_frequency();

  /**
   * @breie Get Receive Throughput
   * @param[in] time Time(ms) for bytes count [defualt 1000]
   * @return Receive Throughput in bytes per time
   */
  uint32_t get_receive_throughput(uint32_t time = 1000);

  /**
   * @brief Get the sequence number of the received data
   * @return Sequence number of the received data
   */
  uint32_t get_receive_seq();

  /**
   * @brief Get the period of last data transmit completion
   * @return Period of last data transmit completion
   */
  uint32_t get_transmit_cplt_period();

  /**
   * @brief Get the frequency of last data transmit completion
   * @return Frequency(Hz) of last data transmit completion
   */
  float get_transmit_cplt_frequency();

  /**
   * @breie Get Transmit Throughput
   * @param[in] time Time(ms) for bytes count [defualt 1000]
   * @return Transmit Throughput in bytes per time
   */
  uint32_t get_transmit_throughput(uint32_t time = 1000);

  /**
   * @brief Print UART status
   */
  void print_uart_status();

  /**
   * @brief Display the latest received packet in hexadecimal format
   */
  void print_receive_buffer();

  /**
   * @brief Display the transmitting data in hexadecimal format
   */
  void print_transmit_buffer();

  /**
   * @brief  Recieve Error handler function
   */
  static void UART_RxErrorCallBack(UART_HandleTypeDef *huart, UARTReceiveStatus status);

  /**
   * @brief Transmit Error handler function
   */
  static void UART_TxErrorCallBack(UART_HandleTypeDef *huart);

private:
  UART_HandleTypeDef *huart; /**< Pointer to the UART handle */

  uint8_t receive_buffer[UART_MAX_RX_BUFFER_SIZE];   /**< Array to receive data */
  uint8_t transmit_buffer[UART_MAX_TX_BUFFER_SIZE];  /**< Array to transmit start byte, data, hash */
  uint8_t receive_data[UART_MAX_RX_BUFFER_SIZE - 2]; /**< Array to receive data */
  uint16_t r_size;                                   /**< Sizes for receiving data */
  uint16_t t_size;                                   /**< Sizes for tarnsmitting data */

  uint32_t last_receive_tick = 0;       /**< last receive function call tick  */
  uint32_t last_transmit_tick = 0;      /**< last  transmit function call tick */
  uint32_t last_receive_cplt_tick = 0;  /**< last receive complete tick after crc matched */
  uint32_t last_transmit_cplt_tick = 0; /**< last transmit complete tick after transmit cplt callback */
  uint32_t receive_cplt_period = 0;     /**< Period of last receive complete */
  uint32_t transmit_cplt_period = 0;    /**< Period of last transmit complete */

  bool is_waiting_for_start_byte;      /**< Current state of receiving */
  bool is_transmitting;                /**< Current state of transmitting */
  UARTMode mode;                       /**< Current UART mode */
  UARTReceiveStatus received_status;   /**< last receive status */
  uint16_t receive_seq = 0;            /**< Sequence number of received data */
  uint16_t prev_receive_seq = 0;       /**< Previous sequence number of received data */
  uint32_t start_byte_error_count = 0; /**< Count of start byte errors */
  uint32_t check_error_count = 0;      /**< Count of CRC hash errors */
  uint32_t transmit_error_count = 0;   /**< Count of transmit errors */
};

#endif // UART_HPP__

uart.cpp

/***********************************************************************************************
 * @file uart.cpp
 * @brief Implementation file for the UART class providing communication functionality.
 * @author Robotics Team, IOE Pulchowk Campus
 * @date 2023
 **********************************************************************************************/

#include <memory.h>
#include <stdio.h>

#include "uart.hpp"

UART::UART() : huart(nullptr) {}

UART::UART(UART_HandleTypeDef *_huart, UARTMode _mode, uint16_t _rt_size, uint16_t _t_size)
    : huart(_huart), mode(_mode)
{
    if (_mode == UART_RECEIVING || _mode == UART_BOTH)
    {
        r_size = _rt_size;
    }
    if (_mode == UART_TRANSMITTING || _mode == UART_BOTH)
    {
        t_size = _t_size > 0 ? _t_size : _rt_size;
    }
}

bool UART::init()
{
    if (huart == nullptr)
        return false;

    is_waiting_for_start_byte = true;
    is_transmitting = false;

    if (mode == UART_RECEIVING || mode == UART_BOTH)
    {
        HAL_UART_Receive_DMA(huart, receive_buffer, 1);
    }

    return true;
}

/**
 * This function receives data over UART. It performs the following steps:
 * - Checks whether the start byte has been received.
 *   - If the start byte is received, proceeds to receive the data payload along with the CRC.
 *   - If the start byte is not received, continues waiting for it.
 * - Once the data is received, validates the CRC.
 * - Copies the data to the provided buffer and updates the reception status accordingly.
 *
 * @attention This function assumes that the UART has been initialized in RECEIVING mode or BOTH
 *            prior to calling this function. If the UART is initialized in a different mode,
 *            the behavior of this function may not be as expected.
 */
UARTReceiveStatus UART::process_receive_callback()
{
    /* Know the current tick */
    uint32_t current_tick = HAL_GetTick();

    /* Check whether received start byte or data */
    if (is_waiting_for_start_byte)
    {
        /* If it is start byte, check its value */
        if (receive_buffer[0] == UART_START_BYTE)
        {
            /* Reset start byte flag for receiving data */
            is_waiting_for_start_byte = false;

            /* Trigger DMA for receiving data */
            HAL_UART_Receive_DMA(huart, receive_buffer + 1, r_size + 1);

            /* Update received_status for start byte matched */
            received_status = UART_START_BYTE_MATCHED;
        }
        else /* Start byte failed */
        {
            /* Increase start byte error count for testing*/
            start_byte_error_count++;
            /* Call user defined error callback */
            UART_RxErrorCallBack(huart, UART_START_BYTE_ERROR);
            /* Again try to receive start byte */
            HAL_UART_Receive_DMA(huart, receive_buffer, 1);

            /* Update received_status for start byte failure */
            received_status = UART_START_BYTE_ERROR;
        }
    }
    else /* Receive data */
    {
        /* Calculate CRC for received data */
        uint8_t hash = CRC8::Instance.get_hash(receive_buffer + 1, r_size);

        /* Compare with received Hash */
        if (hash == receive_buffer[r_size + 1])
        {
            /* Put data from receive buffer to receive data*/
            memcpy(receive_data, receive_buffer + 1, r_size);

            /* Update received_status for CRC Matched */
            received_status = UART_CRC_MATCHED;

            /* Update receive_seq, receive_cplt_period and last_receive_cplt_tick as new data is received in user memory */
            if (receive_seq == 65535)
                receive_seq = 0;
            else
                receive_seq++;

            receive_cplt_period = current_tick - last_receive_cplt_tick;
            last_receive_cplt_tick = current_tick;
        }
        else /* Hash didn't match */
        {
            /* Increase check error count for testing*/
            check_error_count++;
            /* Call user defined error callback */
            UART_RxErrorCallBack(huart, UART_CRC_ERROR);
            /* Update received_status for CRC failure */
            received_status = UART_CRC_ERROR;
        }

        /* Set start byte flag to receive start byte again for the next packet */
        is_waiting_for_start_byte = true;

        /* Trigger DMA for receiving start byte */
        HAL_UART_Receive_DMA(huart, receive_buffer, 1);
    }

    /* Update last_receive_tick to track receive call */
    last_receive_tick = current_tick;

    /* Return received_status */
    return received_status;
}

void UART::process_transmit_callback()
{
    /* Update transmit_cplt_period */
    uint32_t now = HAL_GetTick();
    transmit_cplt_period = now - last_transmit_cplt_tick;
    last_transmit_cplt_tick = now;
    is_transmitting = false;
}

/**
 * This function receives data over UART. It checks whether the data has been received
 * and copies the data to the provided buffer.
 */
bool UART::get_received_data(uint8_t *r_data)
{
    if (receive_seq != prev_receive_seq)
    {
        /* Copy the data*/
        memcpy(r_data, receive_data, r_size);
        /*Update prev_receive_seq so we can use it in next receive*/
        prev_receive_seq = receive_seq;

        return true;
    }

    return false;
}

/**
 * This function transmits data over UART. It prepares the data packet by loading
 * the start byte, copying the transmitted data, calculating and loading the CRC,
 * then transmitting the data using DMA. It also updates the transmit tick.
 *
 * @note This function assumes that the UART communication has been initialized
 *       prior to calling this function.
 */
bool UART::transmit(uint8_t *t_data)
{
    /* Load start byte */
    transmit_buffer[0] = UART_START_BYTE;

    /* Load tx data */
    memcpy(transmit_buffer + 1, t_data, t_size);

    /* Calculate and Load CRC */
    transmit_buffer[t_size + 1] = CRC8::Instance.get_hash(transmit_buffer + 1, t_size);

    /* Transmit tx data using DMA */
    if (HAL_UART_Transmit_DMA(huart, transmit_buffer, t_size + 2) == HAL_OK)
    {
        /* Update transmit tick */
        last_transmit_tick = HAL_GetTick();
        /* Update is_transmitting flag */
        is_transmitting = true;
        return true;
    }

    /* Increase transmit error count for testing*/
    transmit_error_count++;
    /* Call user defined error callback */
    UART_TxErrorCallBack(huart);

    return false;
}

USART_TypeDef *UART::get_uart_instance()
{
    return huart->Instance;
}

bool UART::connected()
{
    return (HAL_GetTick() - last_receive_cplt_tick < UART_CONNCETION_TIMEOUT);
}

uint32_t UART::get_last_receive_tick()
{
    return last_receive_tick;
}

uint32_t UART::get_last_transmit_tick()
{
    return last_transmit_tick;
}

uint32_t UART::get_last_receive_cplt_tick()
{
    return last_receive_cplt_tick;
}

uint32_t UART::get_receive_cplt_period()
{
    return receive_cplt_period;
}

float UART::get_receive_cplt_frequency()
{
    if (receive_cplt_period == 0)
        return 0.0f;

    return 1000.0f / receive_cplt_period;
}

uint32_t UART::get_receive_throughput(uint32_t time)
{
    if (receive_cplt_period == 0 || time == 0)
        return 0;

    return (r_size + 2) * time / receive_cplt_period;
}

uint32_t UART::get_receive_seq()
{
    return receive_seq;
}

uint32_t UART::get_transmit_cplt_period()
{
    return transmit_cplt_period;
}

float UART::get_transmit_cplt_frequency()
{
    if (transmit_cplt_period == 0)
        return 0.0f;

    return 1000.0f / transmit_cplt_period;
}

uint32_t UART::get_transmit_throughput(uint32_t time)
{
    if (transmit_cplt_period == 0 || time == 0)
        return 0;

    return (t_size + 2) * time / transmit_cplt_period;
}

void UART::print_uart_status()
{
    printf("========================================\n");
    printf("UART Status\n");
    printf("========================================\n");
    printf("Receive Status:\n");
    printf("----------------------------------------\n");
    printf("is_waiting_for_start_byte:: %d\n", is_waiting_for_start_byte);
    printf("Receive Seq:: %hu\n", receive_seq);
    printf("Start Byte Error Count:: %lu\n", start_byte_error_count);
    printf("Check Error Count:: %lu\n", check_error_count);
    printf("Last Receive Tick:: %lu\n", last_receive_tick);
    printf("Last Transmit Tick:: %lu\n", last_transmit_tick);
    printf("Last Receive Cplt Tick:: %lu\n", last_receive_cplt_tick);
    printf("Last Transmit Cplt Tick:: %lu\n", last_transmit_cplt_tick);
    printf("Receive Cplt Period:: %lu\n", receive_cplt_period);
    printf("Receive Cplt Frequency:: %.2f\n", get_receive_cplt_frequency());
    printf("Receive Throughput:: %lu\n", get_receive_throughput());
    printf("----------------------------------------\n");
    printf("Transmit Status:\n");
    printf("----------------------------------------\n");
    printf("is_transmitting:: %d\n", is_transmitting);
    printf("Transmit Cplt Period:: %lu\n", transmit_cplt_period);
    printf("Transmit Cplt Frequency:: %.2f\n", get_transmit_cplt_frequency());
    printf("Transmit Throughput:: %lu\n", get_transmit_throughput());
    printf("========================================\n\n");
}

void UART::print_receive_buffer()
{
    printf("UART RX Data::");
    for (int i = 0; i <= r_size + 1; ++i)
    {
        printf(" %02x", receive_buffer[i]);
    }
    printf("\n");
}

void UART::print_transmit_buffer()
{
    printf("UART TX Data::");
    for (int i = 0; i <= t_size + 1; ++i)
    {
        printf("%02x ", transmit_buffer[i]);
    }
    printf("\n");
}

/*Weakly defined, so user can have its own implementation and donot throw error if not defined*/
__weak void UART::UART_RxErrorCallBack(UART_HandleTypeDef *huart, UARTReceiveStatus status)
{
    (void)huart;
    (void)status;
}

/*Weakly defined, so user can have its own implementation and donot throw error if not defined*/
__weak void UART::UART_TxErrorCallBack(UART_HandleTypeDef *huart)
{
    (void)huart;
}

Create two new files joystick.hpp and joystick.cpp inside Core > Inc and Core > Src repsectively. Copy and paste the below contents:

joystick.hpp

/**
 ******************************************************************************
 * @file    joystick.hpp
 * @brief   Header file for supporting joysticks
 * @author  Robotics Team, IOE Pulchowk Campus
 ******************************************************************************
 */

#ifndef _JOYSTICK_HPP
#define _JOYSTICK_HPP

#include <math.h>

#include "stm32f4xx_hal.h"
#include "joy_msg.hpp"
#include "uart.hpp"

#ifndef JOYSTICK_LONG_PRESS_DURATION
#define JOYSTICK_LONG_PRESS_DURATION 750 // ms
#endif
#ifndef JOYSTICK_DEBOUNCE_DURATION
#define JOYSTICK_DEBOUNCE_DURATION 30 // ms
#endif

#if !(defined USE_PS4 || USE_XBOX)
#define USE_PS4
#endif

template <typename t>
inline t map(t x, t in_min, t in_max, t out_min, t out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

template <typename t>
inline t map(t x, t out_min, t out_max)
{
  return map(x, 0, 1, out_min, out_max);
}

/**
 * @brief Base class for joystick functionality.
 *
 * This class provides basic functionality for working with joysticks,
 * including initialization, data retrieval, and printing raw data.
 */
class Joystick
{
private:
    uint8_t dead_band;                  /**< Deadband value for joystick axes. */
    uint16_t timeout;                   /**< Timeout value for checking joystick connection. */
    JoyData data;                       /**< Structure to hold joystick data. */
    uint16_t prev_buttons = 0;          /**< Previous button state. */
    uint16_t pressed_buttons = 0;       /**< Pressed buttons. */
    uint16_t just_pressed_buttons = 0;  /**< Just pressed buttons. */
    uint16_t just_released_buttons = 0; /**< Just released buttons. */
    uint16_t clicked_buttons = 0;       /**< Clicked buttons. */
    uint16_t long_pressed_buttons = 0;  /**< Long pressed buttons. */
    uint32_t first_pressed_tick[16] = {0};
    uint32_t button_update_tick = 0;

public:
    UART uart; /**< UART instance for communication. */

    /**
     * @brief Default constructor.
     */
    Joystick() = default;

    /**
     * @brief Constructor with parameters.
     *
     * Initializes the joystick with the given UART instance, deadband value, and timeout.
     *
     * @param _huart Pointer to the UART_HandleTypeDef for UART communication.
     * @param _dead_band Deadband value for joystick axes.
     * @param _timeout Timeout value for checking joystick connection.
     */
    Joystick(UART_HandleTypeDef *_huart, uint8_t _dead_band = 20, uint16_t _timeout = 100);

    Joystick(const Joystick &) = default;

    Joystick &operator=(const Joystick &) = default;

    /**
     * @brief Default destructor.
     */
    ~Joystick() = default;

    /**
     * @brief Initialize joystick to start UART communication.
     */
    bool init()
    {
        return uart.init();
    }

    /**
     * @brief Update joystick data.
     *
     * @return True if data is updated, false otherwise.
     */
    bool update();

    /**
     * @brief Print received data from joystick uart.
     */
    void print_received_data();

    /**
     * @brief Print data from joystick.
     */
    void print_data();

    /**
     * @brief Callback function for UART communication.
     */
    void uart_callback()
    {
        uart.process_receive_callback();
    }

    /**
     * @brief Check if joystick is connected.

     * @return True if joystick is connected, false otherwise.
     */
    bool connected()
    {
        if ((HAL_GetTick() - uart.get_last_receive_cplt_tick() < timeout) && (uart.get_last_receive_cplt_tick() != 0))
            return true;
        return false;
    }

    /**
     * @brief Get joystick data.
     *
     * @return JoyData structure containing joystick data.
     */
    JoyData get_data()
    {
        return data;
    }

    /**
     * @brief Get button state.
     *
     * @return 16-bit integer representing button state.
     */
    uint16_t get_buttons()
    {
        return data.buttons;
    }

    /**
     * @brief Get previous button state.
     *
     * @return 16-bit integer representing clicked button flag.
     */
    uint16_t get_clicked_buttons()
    {
        return clicked_buttons;
    }

    /**
     * @brief Get toggled button state.
     *
     * @return 16-bit integer representing toggled button flag.
     */
    uint16_t get_toggled_buttons()
    {
        return just_pressed_buttons | just_pressed_buttons;
    }

    /**
     * @brief Get long pressed button state.
     *
     * @return 16-bit integer representing long pressed button flag.
     */
    uint16_t get_long_pressed_buttons()
    {
        return long_pressed_buttons;
    }

    /**
     * @brief Get button state.
     *
     * @param button Button number.
     * @return True if button is pressed, false otherwise.
     */
    bool pressed(uint8_t button)
    {
        return pressed_buttons & BUTTONS(button);
    }

    bool only_pressed(uint8_t button)
    {
        return (pressed_buttons & BUTTONS(button)) && !(pressed_buttons & ~BUTTONS(button));
    }

    /**
     * @brief Get button state.
     *
     * @param button Button number.
     * @return True if button is released, false otherwise.
     */
    bool released(uint8_t button)
    {
        return !(pressed_buttons & BUTTONS(button));
    }

    bool just_pressed(uint8_t button)
    {
        return just_pressed_buttons & BUTTONS(button);
    }

    bool just_released(uint8_t button)
    {
        return just_released_buttons & BUTTONS(button);
    }

    /**
     * @brief Get button state.
     *
     * @param button Button number.
     * @return True if button is clicked, false otherwise.
     */
    bool clicked(uint8_t button)
    {
        return clicked_buttons & BUTTONS(button);
    }

    bool only_clicked(uint8_t button)
    {
        return (clicked_buttons & BUTTONS(button)) && !(pressed_buttons & ~BUTTONS(button));
    }

    /**
     * @brief Get button state.
     *
     * @param button Button number.
     * @return True if button is toggled, false otherwise.
     */
    bool toggled(uint8_t button)
    {
        return get_toggled_buttons() & BUTTONS(button);
    }

    /**
     * @brief Get button state.
     *
     * @param button Button number.
     * @return True if button is long pressed, false otherwise.
     */
    bool long_pressed(uint8_t button)
    {
        return long_pressed_buttons & BUTTONS(button);
    }

    /**
     * @brief Get left stick x-axis.
     *
     * @return float Normalized left stick value of x-axis.
     */
    float lx()
    {
        if (abs(data.lx) < dead_band)
            return 0.0f;
        return (map<float>((float)data.lx, -127.0f, 127.0f, -1.0f, 1.0f));
    }

    /**
     * @brief Get left stick y-axis.
     *
     * @return float Normalized left stick value of y-axis.
     */
    float ly()
    {
        if (abs(data.ly) < dead_band)
            return 0.0f;
        return (map<float>((float)data.ly, -127.0f, 127.0f, -1.0f, 1.0f));
    }

    /**
     * @brief Get right stick x-axis.
     *
     * @return float Normalized right stick value of x-axis.
     */
    float rx()
    {
        if (abs(data.rx) < dead_band)
            return 0.0f;
        return (map<float>((float)data.rx, -127.0f, 127.0f, -1.0f, 1.0f));
    }

    /**
     * @brief Get right stick y-axis.
     *
     * @return float Normalized right stick value of y-axis.
     */
    float ry()
    {
        if (abs(data.ry) < dead_band)
            return 0.0f;
        return (map<float>((float)data.ry, -127.0f, 127.0f, -1.0f, 1.0f));
    }

    /**
     * @brief Get left trigger.
     *
     * @return float Normalized left trigger value.
     */
    float lt()
    {
        return (map<float>((float)data.lt, 0.0f, 255.0f, 0.0f, 1.0f));
    }

    /**
     * @brief Get right trigger normalized value.
     *
     * @return float Normalized right trigger value.
     */
    float rt()
    {
        return (map<float>((float)data.rt, 0.0f, 255.0f, 0.0f, 1.0f));
    }
};

#endif // _JOYSTICK_HPP

joystick.cpp

/**
 ******************************************************************************
 * @file    joystick.cpp
 * @brief   Implementation for supporting joystics
 * @author  Robotics Team, IOE Pulchowk Campus
 ******************************************************************************
 */

#include <math.h>
#include <stdio.h>

#include "joystick.hpp"

Joystick::Joystick(UART_HandleTypeDef *_huart, uint8_t _dead_band, uint16_t _timeout)
    : dead_band(_dead_band), timeout(_timeout), uart(_huart, UART_RECEIVING, 8) {}

bool Joystick::update()
{
    if (!connected())
    {
        prev_buttons = 0;
        pressed_buttons = 0;
        just_pressed_buttons = 0;
        just_released_buttons = 0;
        clicked_buttons = 0;
        long_pressed_buttons = 0;
        return false;
    }

    just_pressed_buttons = 0;
    just_released_buttons = 0;
    clicked_buttons = 0;

    if (!uart.get_received_data((uint8_t *)&data))
        return false;

    uint32_t now = HAL_GetTick();

    if (now - button_update_tick >= JOYSTICK_DEBOUNCE_DURATION)
    {
        long_pressed_buttons = 0;
        pressed_buttons = data.buttons;
        just_pressed_buttons = (data.buttons & ~prev_buttons);
        just_released_buttons = (~data.buttons & prev_buttons);

        for (int i = 0; i < 16; ++i)
        {
            bool is_pressed = data.buttons & BUTTONS(i);

            if (is_pressed)
            {
                if (!(prev_buttons & BUTTONS(i)))
                {
                    first_pressed_tick[i] = now;
                }

                if (now - first_pressed_tick[i] >= JOYSTICK_LONG_PRESS_DURATION)
                {
                    long_pressed_buttons |= BUTTONS(i);
                }
            }
            else
            {
                if (prev_buttons & BUTTONS(i))
                {
                    if (now - first_pressed_tick[i] < JOYSTICK_LONG_PRESS_DURATION)
                    {
                        clicked_buttons |= BUTTONS(i);
                    }
                }
            }
        }

        prev_buttons = data.buttons;
        button_update_tick = now;
    }

    return true;
}

void Joystick::print_received_data()
{
    printf("Joystick: lx:%d ly:%d rx:%d ry:%d lt:%u rt:%u buttons:%04x\n",
           data.lx,
           data.ly,
           data.rx,
           data.ry,
           data.lt,
           data.rt,
           data.buttons);
}

void Joystick::print_data()
{
    printf("Joystick: lx:%f ly:%f rx:%f ry:%f lt:%f rt:%f, prs:%04x, tgl:%04x clk:%04x lng:%04x:\n",
           lx(),
           ly(),
           rx(),
           ry(),
           lt(),
           rt(),
           pressed_buttons,
           get_toggled_buttons(),
           clicked_buttons,
           long_pressed_buttons);
}

6.3. Code to Receive Data 

Create two new files App.h and App.cpp inside Core > Inc and Core > Src respectively. Copy and paste the below contents:

app.h

#ifndef __APP_H
#define __APP_H

#ifdef __cplusplus
extern "C" {
#endif

void setup();

void loop();

#ifdef __cplusplus
}
#endif

#endif // __APP_H

app.cpp

#include <stdio.h>

#include "usart.h"
#include "joystick.hpp"
#include "app.h"

Joystick joystick(&huart4);
uint32_t last_loop_tick = 0;
uint32_t last_rx_tick = 0;
uint32_t last_print_tick = 0;

void setup()
{
    joystick.init();
    printf("Joystick initialized\n");
    last_loop_tick = HAL_GetTick();
}

void loop()
{
    if (HAL_GetTick() - last_loop_tick < 10)
    return;

    last_loop_tick = HAL_GetTick();

    // Must call every 10ms or less.
    bool is_joystick_updated = joystick.update();

    if (!joystick.connected())
    {
        printf("Joystick not connected\n");
    }

    if (is_joystick_updated)
    {
        if (HAL_GetTick() - last_print_tick > 100)
        {
            last_print_tick = HAL_GetTick();
            joystick.print_data();
            // joystick.print_received_data();
        }
    }

    float lx, ly, rx, ry, lt, rt;
    lx = joystick.lx();
    ly = joystick.ly();
    rx = joystick.rx();
    ry = joystick.ry();
    lt = joystick.lt();
    rt = joystick.rt();

    bool is_lb_clicked = joystick.clicked(PS4::L1);
    bool is_rb_clicked = joystick.clicked(PS4::R1);

    // only clicked is true if the button is clicked and no other button is pressed
    bool is_lb_only_clicked = joystick.only_clicked(PS4::L1);
    bool is_rb_only_clicked = joystick.only_clicked(PS4::R1);
    bool is_lb_pressed = joystick.pressed(PS4::L1);
    bool is_rb_pressed = joystick.pressed(PS4::R1);
    bool is_lb_long_pressed = joystick.long_pressed(PS4::L1);
    bool is_rb_long_pressed = joystick.long_pressed(PS4::R1);

    // experiment yourself :)
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == joystick.uart.get_uart_instance())
    {
        joystick.uart_callback();
        last_rx_tick = HAL_GetTick();

        if (HAL_GetTick() - last_rx_tick > 30)
        {
            last_rx_tick = HAL_GetTick();
            HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_12);
        }
    }
}

Navigate to Core > Src and open main.c. Include app.h.

/* USER CODE BEGIN Includes */
#include "app.h"
/* USER CODE END Includes */

Call setup and loop in main function.

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
 loop();
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */

6.4. Build and Flash 

Now inside Core, the structure should look similar to this:

Inc\
  └── app.h
  └── crc8.hpp
  └── dma.h
  └── gpio.h
  └── joy_msg.hpp
  └── joystick.hpp
  └── main.h
  └── stm32f4xx_hal_conf.h
  └── stm32f4xx_it.h
  └── uart_def.h
  └── uart.hpp
  └── usart.h
Src\
  └── app.cpp
  └── crc8.cpp
  └── dma.c
  └── gpio.c
  └── joystick.cpp
  └── main.c
  └── printf_config.c
  └── stm32_crc8.cpp
  └── stm32f4xx_hal_msp.c
  └── stm32f4xx_it.c
  └── syscalls.c
  └── sysmem.c
  └── system_stm32f4xx.c
  └── uart.cpp
  └── usart.c

Update CMakeLists.txt as follows:

CMakeLists.txt

cmake_minimum_required(VERSION 3.22)

#
# This file is generated only once,
# and is not re-generated if converter is called multiple times.
#
# User is free to modify the file as much as necessary
#

# Setup compiler settings
set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS ON)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS ON)


# Define the build type
if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Debug")
endif()

# Set the project name
set(CMAKE_PROJECT_NAME stm32_joystick_master)

# Include toolchain file
include("cmake/gcc-arm-none-eabi.cmake")

# Enable compile command to ease indexing with e.g. clangd
set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)

# Core project settings
project(${CMAKE_PROJECT_NAME})
message("Build type: " ${CMAKE_BUILD_TYPE})

# Enable CMake support for ASM and C languages
enable_language(CXX C ASM)

# Create an executable object type
add_executable(${CMAKE_PROJECT_NAME})

# Add STM32CubeMX generated sources
add_subdirectory(cmake/stm32cubemx)

# Link directories setup
target_link_directories(${CMAKE_PROJECT_NAME} PRIVATE
    # Add user defined library search paths
)

# Add sources to executable
target_sources(${CMAKE_PROJECT_NAME} PRIVATE
    # Add user sources here
    ${CMAKE_SOURCE_DIR}/Core/Src/printf_config.c
    ${CMAKE_SOURCE_DIR}/Core/Src/crc8.cpp
    ${CMAKE_SOURCE_DIR}/Core/Src/uart.cpp
    ${CMAKE_SOURCE_DIR}/Core/Src/joystick.cpp
    ${CMAKE_SOURCE_DIR}/Core/Src/app.cpp
)

# Add include paths
target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE
    # Add user defined include paths
)

# Add project symbols (macros)
target_compile_definitions(${CMAKE_PROJECT_NAME} PRIVATE
    # Add user defined symbols
)

# Add linked libraries
target_link_libraries(${CMAKE_PROJECT_NAME}
    stm32cubemx

    # Add user defined libraries
)

# Generate binary
add_custom_command(
    OUTPUT ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.bin
    COMMAND arm-none-eabi-objcopy -O binary ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.elf ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.bin
    DEPENDS ${CMAKE_PROJECT_NAME}
    COMMENT "Converting ELF to binary"
)

# Binary target
add_custom_target(bin ALL
    DEPENDS ${CMAKE_BINARY_DIR}/${CMAKE_PROJECT_NAME}.bin
    COMMENT "Generating binary file"
)

Build and flash the program.

mkdir build
cd build
cmake ..
make -j
st-flash write stm32_joystick_master.bin 0x8000000

Connect the ESP32 or Pico W to the STM32 board througth UART. Also connect PS4 controller.
Open STM32CubeProgrammer and connect to the STM32 board. You should see the joystick data changing according to the input from the PS4 controller. The LED on PD12 pin blinks if STM32 is receiving data from the ESP32 or Pico W.

Do your own experiment with the Joystick class in App.cpp.