Skip to main content
Created By: Manivannan S. Public Project Links: https://studio.edgeimpulse.com/public/1081144/live GitHub Repo: https://github.com/Manivannan-maker/SmartBoxingGlove Video: https://www.youtube.com/watch?v=k8IBs8f259c

​
Introduction

Boxers and fitness enthusiasts rarely have objective training metrics during practice. Coaches typically rely on visual observation to judge a session, which makes it difficult to quantify punch frequency, movement patterns, and overall workout intensity. Subjective feedback has real limits. By the time a coach calls out a technical correction, the moment has passed. And most athletes have no way to answer basic questions about their own training. e.g. how many combinations did I throw last round? Is my pace dropping in round three? Which punch am I actually dropping? For athletes building their own training tech, this smart boxing band gives you a DIY edge. It sits lightly on your wrist, tracks every punch you throw, and turns raw motion into live analytics you can actually use. The band’s display shifts color with your heartbeat, so you can see your intensity level without breaking rhythm. It’s a compact, athlete‑friendly tool that helps you understand your technique, pace your rounds, and push harder with real‑time feedback—perfect for anyone who wants to blend hands‑on making with serious boxing performance. This project addresses that gap by combining edge AI with wearable sensing to deliver training analytics directly on the athlete’s wrist. The wearable classifies boxing punches in real time from onboard IMU data, with the model trained and deployed entirely through Edge Impulse in the Arduino Nesso N1. Everything runs on the device, and there is no dashboard dependency, and no internet connection required. You get feedback while you are still in the ring.

​
How it works

Motion data is read from the onboard 6-axis IMU (inertial measurement unit) at a fixed sample rate, segmented into short windows, and uploaded to Edge Impulse for training. The trained model is then deployed back to the Nesso N1 as an Arduino library, so inference runs on the microcontroller in real-time, based on a ESP32-C6 processor.
This is the core idea worth noticing: Edge Impulse handles the full round trip. Data collection, feature design, model training, and deployment to hardware all happen in the same workflow, and once the model is on the board the device no longer needs Edge Impulse at runtime.

​
What it does

  • Real-time punch classification: identifies punch types as you throw them (Idle, JabCross, Hook, UpperCut)
  • On-device TinyML inference: no network dependency, no latency from a server round trip
  • Punch counting and analytics: frequency, technique trends, and session summaries
  • Heart-rate monitoring: continuous, with intensity shown visually on the display
  • Visual training intensity feedback: colour-coded intensity, readable at a glance mid-round
  • Fully offline operation: works in a gym, a ring, or anywhere without connectivity

​
Build the project

To build this project from scratch, follow these steps:

​
Collect boxing‑movement data using the Arduino Nesso

For this project, I selected the Arduino Nesso because its built‑in battery makes it ideal for fully portable operation, and its compact form factor allows it to be worn comfortably as a band. The integrated touchscreen also provides a convenient way to display punch counts and other real‑time boxing analytics directly on the device. In addition to these advantages, the Arduino Nesso N1 offers the following specifications:
  • ESP32-C6 microcontroller Dual 32-bit RISC-V processors with up to 160 MHz HP core and 20 MHz LP core
  • Wireless connectivity Wi-Fi® 6 (2.4 GHz), Bluetooth® 5.3, Thread® 1.4, LoRa® (850–960 MHz via SX1262), and Zigbee 3.0
  • Integrated display 1.14” touch screen for direct interaction and feedback
  • Onboard controls Two programmable buttons plus a power / reset / boot button
  • Built-in sensors and outputs 6-axis IMU, IR transmitter, RGB LED, and passive buzzer
  • Memory 16 MB NOR flash and 512 KB SRAM
  • Expandable I/O Grove and Qwiic connectors compatible with Arduino Modulino nodes and M5Stack sensor-hat ecosystem
  • Battery powered Built-in lithium polymer battery with nominal 5V input
  • USB connectivity USB-C connector for power and programming
  • Software support Compatible with Arduino IDE, MicroPython, UIFlow, and Arduino Cloud
  • Ready-to-use hardware Pre-assembled device with display and enclosure for immediate prototyping
  • Compact size 18 mm × 45 mm
To train the machine learning model we use Edge Impulse. First, we create a dataset and label the accelerometer samples using the four target classes: Idle, Hook, Jab-Cross, UppeCut. To acquire high‑quality datasets for various boxing movements, the Arduino Nesso N1 must stream raw sensor data continuously. Flash the Nesso_IMU.ino firmware onto the Nesso N1 to initialize the IMU, configure the sampling pipeline, and transmit 3‑axis accelerometer readings over the serial interface. These serialized motion frames are then ingested by Edge Impulse’s data forwarder, enabling precise capture, segmentation, and labeling of boxing‑move signals for subsequent model training. Once the Arduino code is flashed then we need to connect the board to the Edge Impulse account. To connect the Arduino Nesso board to the EI account, please follow the steps mentioned below.
  1. Go to your Edge Impulse account, and find the API key for your account.
  2. After getting the right API key, open the command window/Terminal (MacOs) and type the following command (Replace the YOUR_API_KEY with the API key from Edge Impulse account):
For accurate dataset collection, ensure the Arduino Nesso is mounted in its intended wearable position so the sensor orientation matches the final product configuration. I used a hook‑and‑loop strap to secure the Nesso N1 on the wrist, allowing the device to remain stable during motion capture, as shown in the reference setup.
Once the Arduino Nesso is linked to your Edge Impulse project, perform each boxing movement and assign the correct label so the system can map raw sensor data to the corresponding punch type.

​
Train a machine learning model in Edge Impulse

After preparing and labeling the dataset, we begin training the machine‑learning classifier model in Edge Impulse that can accurately recognize the different punches in real-time. In the Create Impulse section, use Time series data. I have selected the window size as 1200ms and stride as 750ms. Set the Preprocessing block as Spectral analysis and select Classification as the learning block.
Then generate the features and visualise to get high level overview of each labels.
Before training the machine learning model, in the Neural Network settings, configure the training cycles as 100 and learning rate as 0.05. In the Neural Network section, configure the layers as indicated.
The model achieved an accuracy of 100% during the training phase, which is sufficient to proceed to the next step. During the testing phase, the model is evaluated using new datasets that were not incorporated in the training process. The Model achieved 100 % which is sufficient for hardware deployment. Based on the validation results, we may need to refine the training parameters or collect additional samples to improve classification accuracy.

​
Deploy the trained model onto the Arduino Nesso N1

Once the model achieves a satisfactory performance level, we proceed to deploy it to the Arduino Nesso N1 using the generated Arduino library, enabling real‑time inference directly on the device. However, we won’t be deploying it directly to the Arduino Nesso N1 just yet, as we need to add more logic on top of the machine learning prediction.
Once the model is downloaded, follow these steps to import the library into the Arduino IDE:

​
Importing library in Arduino IDE

Open your Arduino IDE, go to Sketch > Add File, and select the downloaded file.

​
Integrate the pulse sensor with the inference output

To interface the Pulse Sensor with Arduino Nesso N1, ensure that the corresponding PulseSensor Playground library is installed in the Arduino IDE before proceeding with integration. I have connected the Pulse sensor to the Arduino Nesso N1 as per this connection diagram.
To make the PulseSensor Playground library work correctly on the Arduino Nesso N1, a small modification is required. Since the Nesso N1 exposes only a limited set of ADC‑capable pins, I selected GPIO5 for analog sampling. Therefore, the library’s source code must be updated to replace the default ADC pin (GPIO7) with GPIO5 so that the PulseSensor reads from the correct hardware channel. Open your installed library directory, locate the PulseSensor.cpp file, and update the line InputPin = 7; to InputPin = 5; so the library uses the correct ADC pin on the Arduino Nesso N1. To capture accurate pulse readings, the sensor must be positioned on the tip of the forefinger. I used a Hook‑and‑Loop strap to secure the sensor firmly in place on the finger.

​
Run the application

The final step is to integrate the Pulse Sensor with the machine‑learning inference output. I’ve already combined the required logic into this .ino file, and you can proceed to flash it onto the Arduino Nesso N1. Now, let me walk you through the architectural flow of how this integrated code operates:
The below diagram illustrates how the system dynamically adjusts the backlight colour based on the real‑time pulse value captured from the Pulse Sensor. This logic runs continuously inside the main loop, ensuring that the user receives immediate visual feedback corresponding to their heart‑rate intensity.
The flow works as follows:
  • Pulse Reading The system begins by sampling the analog pulse value from the sensor. If a valid reading is available, the value is passed through a series of conditional checks.
  • Green Zone — Pulse < 100 Indicates a resting or low‑intensity state. The backlight turns Green to show normal heart‑rate activity.Blue Zone — Pulse between 100 and 140 Represents moderate activity. The backlight switches to Blue, signaling increased exertion.Yellow Zone — Pulse between 140 and 160 Indicates high‑intensity movement. The backlight changes to Yellow, warning the user that they are entering a more demanding heart‑rate range.Red Zone — Pulse > 160 Shows very high exertion. The backlight turns Red, alerting the user to peak intensity levels.
  • Fallback Condition — No pulse reading available If the sensor fails to provide a valid reading, the system defaults the backlight to Black, indicating a sensor error or improper placement.

​
Why Edge Impulse?

Edge Impulse accelerated development significantly by providing everything needed in one place: data acquisition tools, sample labelling, feature extraction, neural network training, model validation, and one-click deployment. Rather than building a custom machine learning pipeline from scratch, I was able to move from raw sensor data to a working embedded solution without stitching together separate tools for each stage of the workflow.

​
Conclusion

This AI Boxing Band demonstrates how Edge Impulse can be used to build a sports wearables that recognises boxing punches in real-time, running entirely on embedded hardware with no cloud dependency. By combining TinyML-based motion classification with heart-rate monitoring and heartbeat-based intensity feedback, the system delivers the kind of objective measurement that is usually missing from everyday training practice. Instead of relying on intuition or a coach’s visual observation alone, athletes get immediate insight into how hard they are working and how their punch performance is trending, and can adjust their training accordingly. The project highlights the potential of Edge AI for sports performance monitoring, low-latency analytics, and next-generation wearable coaching solutions, showing that improvement in this domain can become measurable, consistent, and data-driven.