Real-Time Arrhythmia Detection at the Edge: Deploying TinyML on ESP32 for Raw ECG Analysis

​

In the world of wearable health technology, the holy grail has always been moving intelligence from the cloud to the edge. Waiting for a cloud server to analyze your heart rhythm is not just a latency issue—it’s a privacy and battery life concern. Today, we are diving deep into TinyML, Edge AI, and ECG signal processing to build a real-time abnormality detector.

By leveraging TensorFlow Lite for Microcontrollers and the versatile ESP32, we can process raw electrocardiogram (ECG) data locally. This approach ensures low-latency detection of arrhythmias while keeping sensitive medical data on-device. If you’ve been looking to bridge the gap between high-level deep learning and low-level embedded systems, you’re in the right place!

The Architecture: From Raw Signal to Insight 🏗️

The pipeline involves capturing a high-frequency analog signal, cleaning it, and feeding it into a quantized Convolutional Neural Network (CNN). Here is how the data flows through our ESP32:

graph TD
    A[Raw ECG Signal/Sensor] -->|ADC Sampling| B(Preprocessing: Bandpass Filter)
    B --> CBuffer Management
    C -->|Windowed Segment| D[TFLite Micro Inference Engine]
    D --> ECNN Model Classification
    E -->|Normal| F[Log: Sinus Rhythm]
    E -->|Abnormal| G[Trigger Alert: Arrhythmia]
    G -->|Bluetooth/Wi-Fi| H[Mobile Dashboard]

Prerequisites 🛠️

To follow this advanced guide, you’ll need:

• Hardware: ESP32 (DevKit V1 or similar).
• Sensor: AD8232 ECG Module (or simulated ECG data).
• Software: Arduino IDE or PlatformIO.
• Frameworks: TensorFlow Lite for Microcontrollers (TFLM), EloquentTinyML (optional wrapper), or the standard C++ TFLM library.

Step 1: Model Training & Quantization 🧠

Before we touch the C++ code, we need a model. Typically, we use the MIT-BIH Arrhythmia Database to train a 1D-CNN. The crucial step is Post-Training Quantization.

Since the ESP32 doesn’t have a dedicated NPU, we convert our 32-bit float model into an 8-bit integer (INT8) model. This reduces the size by 4x and speeds up inference significantly without a massive drop in accuracy.

Step 2: Implementation on ESP32 (C++) 💻

We need to load the model as a byte array and set up the TFLite interpreter. Here is a simplified implementation of the inference loop.

#include <TensorFlowLite.h>
#include "model_data.h" // Your exported INT8 model
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
// Constants for the ECG window
const int kTensorArenaSize = 30 * 1024; // 30KB Arena
uint8_t tensor_arena[kTensorArenaSize];
// TFLite globals
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* input = nullptr;
void setup() 
    Serial.begin(115200);
    // 1. Load the model
    static tflite::MicroMutableOpResolver<5> resolver;
    resolver.AddConv2D();
    resolver.AddMaxPool2D();
    resolver.AddFullyConnected();
    resolver.AddSoftmax();
    resolver.AddReshape();
    static tflite::MicroInterpreter static_interpreter(
        tflite::GetModel(g_model_data), resolver, tensor_arena, kTensorArenaSize);
    interpreter = &static_interpreter;
    interpreter->AllocateTensors();
    input = interpreter->input(0);

void loop() 
    // 2. Simulate/Read ECG Data (Sampled at 125Hz or 250Hz)
    float sample = analogRead(34); 
    // ... [Preprocessing Logic: Normalization & Filtering] ...
    // 3. Fill the Input Tensor
    for (int i = 0; i < input->dims->data[1]; i++) 
        input->data.f[i] = processed_samples[i]; 
    
    // 4. Run Inference
    TfLiteStatus invoke_status = interpreter->Invoke();
    if (invoke_status != kTfLiteOk) 
        Serial.println("Inference failed!");
        return;
    
    // 5. Analyze Results
    float normal_score = interpreter->output(0)->data.f[0];
    float abnormal_score = interpreter->output(0)->data.f[1];
    if (abnormal_score > 0.8) 
        Serial.println("⚠️ Warning: Abnormal Heart Rhythm Detected!");
    

Advanced Patterns: Optimizing for Production 🥑

When moving from a prototype to a production-grade wearable, you’ll encounter challenges like signal noise from muscle movement (EMG) and power consumption. For those looking to implement robust noise-cancellation algorithms or more efficient memory management in TinyML deployments, I highly recommend checking out more production-ready examples.

Pro-Tip: For a deep dive into advanced signal processing patterns and optimizing TensorFlow Lite for mission-critical edge applications, visit the WellAlly Tech Blog. They provide excellent resources on scaling these localized AI models to enterprise-grade health solutions.

Step 3: Handling the Jitter (Signal Preprocessing)

Raw ECG data is messy. You’ll need a digital Bandpass Filter (usually 0.5Hz to 40Hz) to remove baseline wander and high-frequency noise. In C++, this can be implemented as a simple IIR filter to keep the computational overhead low on the ESP32.

// Example: Simple Low-pass filter component
float lowPass(float input, float prevOutput, float alpha) 
    return prevOutput + alpha * (input - prevOutput);

Conclusion 🏁

Deploying a CNN on an ESP32 for real-time ECG analysis isn’t just a “cool project”—it’s a glimpse into the future of decentralized healthcare. By processing data locally, we respect user privacy and reduce the load on our infrastructure.

What’s next for your TinyML journey?

1. Try adding BLE (Bluetooth Low Energy) to send alerts to a smartphone.
2. Experiment with Pruning to make your model even smaller.
3. Let me know in the comments: Have you tried running TinyML on the ESP32-S3 with its vector instructions?

Happy hacking! 🚀💻

If you enjoyed this tutorial, don’t forget to ❤️ and bookmark it! For more advanced Edge AI content, keep an eye on my profile or visit the official WellAlly Blog.