Final Project — Seebscribe My Heartbeat

Phase 1 — Proof of Signal

Wiring my custom Yaro board and AD8232

AD8232 Pin Breakdown

Power

Signal output

Leads-off detection

Electrode connections — this is the key part

These names come from the clinical ECG convention — they don't mean you literally attach to an arm. For your chest configuration:

· RA → right chest electrode

· LA → left chest electrode

· RL → lower chest or lower left abdomen (noise reference)

Wiring to Yaroboard

AD8232          Yaroboard (ESP32-C3)
--------        ---------------------
3.3V    ----->  3V3
GND     ----->  GND
OUTPUT  ----->  D0  (ADC pin, reads analog ECG)
LO+     ----->  D1  (digital in, HIGH = electrode off)
LO-     ----->  D2  (digital in, HIGH = electrode off)
SDN     ----->  leave floating or tie to 3V3
RA      ----->  right chest electrode (snap/wire)
LA      ----->  left chest electrode (snap/wire)
RL      ----->  lower abdomen electrode (noise reference)

XIAO ESP32-C3 pinout reference.

For easy connection I solder Pin header to AD8232 board

For the wiring part, this was quite easy because I used jumper wires and I have pin headers.

Also, when I'm connected to the power and I can touch some electrodes, I can see that the AD8232 boards start blinking

Next is positioning electrodes to harvest an accurate heartbeat signal. Here is a diagram of how to make it better.

I also found an article about how to experiment with Arduino and AD8232 board to harvest the heartbeat signal.

https://circuitdigest.com/microcontroller-projects/understanding-ecg-sensor-and-program-ad8232-ecg-sensor-with-arduino-to-diagnose-various-medical-conditions

Connecting electrodes

I ask AI to generate simple code to check sensor AD8232 and some heartbeat signals.

Generate a simple code for ESP32-C3 and AD8272 sensor to check the electrodes and heart beat signal:

Check code:

// ─────────────────────────────────────────────
// Seebscribe — AD8232 ECG reader
// XIAO ESP32-C3 + AD8232
// View output in: Tools → Serial Plotter
// ─────────────────────────────────────────────
const int ECG_PIN  = A0;  // AD8232 OUTPUT → A0
const int LO_PLUS  = D1;  // AD8232 LO+   → D1
const int LO_MINUS = D2;  // AD8232 LO-   → D2
void setup() {
  Serial.begin(115200);
  pinMode(LO_PLUS,  INPUT);
  pinMode(LO_MINUS, INPUT);
  delay(500);
  Serial.println("Seebscribe ECG ready");
}
void loop() {
  // Check if electrodes are connected
  if (digitalRead(LO_PLUS) == HIGH ||
      digitalRead(LO_MINUS) == HIGH) {
    Serial.println(0);  // flat line when disconnected
    delay(4);
    return;
  }
  // Read and print ECG value
  int ecgValue = analogRead(ECG_PIN);
  Serial.println(ecgValue);
  delay(4);  // ~250 Hz sample rate
}

And it's working. I can see some numbers in the serial monitor.

Next step to see visual in serial plotter.

Ai request:

Okay, code is working now. Can you generate a simple code to see the actual heartbeat signal like ECG on the serial plotter?

// ─────────────────────────────────────────────────────────────
// Seebscribe — ECG Serial Plotter
// Hardware: XIAO ESP32-C3 + AD8232 ECG frontend
// Output:   Tools → Serial Plotter (115200 baud)
// Wiring:   AD8232 OUTPUT → A0
//           AD8232 LO+    → D1
//           AD8232 LO-    → D2
//           AD8232 3.3V   → 3V3
//           AD8232 GND    → GND
// ─────────────────────────────────────────────────────────────
// ── Pin definitions ──────────────────────────────────────────
const int ECG_PIN  = A0;  // Analog ECG signal from AD8232 OUTPUT pin
const int LO_PLUS  = D1;  // Leads-off detection: HIGH when LA electrode disconnected
const int LO_MINUS = D2;  // Leads-off detection: HIGH when RA electrode disconnected
// ── Moving average filter settings ───────────────────────────
// A moving average reduces high-frequency noise from the ADC
// without blurring the sharp QRS spike we want to see clearly.
// FILTER_SIZE = 4 means we average the last 4 raw ADC readings.
// Larger values = smoother signal but slower response to peaks.
const int FILTER_SIZE = 4;
int  filterBuffer[FILTER_SIZE]; // Circular buffer storing recent readings
int  filterIndex = 0;           // Current position in the circular buffer
long filterSum   = 0;           // Running total of values in the buffer
// ── smoothedRead() ───────────────────────────────────────────
// Reads a new raw value from the ADC, adds it to the circular
// buffer, removes the oldest value, and returns the average.
// Called once per loop iteration instead of analogRead() directly.
int smoothedRead() {
  int raw = analogRead(ECG_PIN);    // Read raw 12-bit ADC value (0–4095)
  filterSum -= filterBuffer[filterIndex]; // Subtract the oldest value from the sum
  filterBuffer[filterIndex] = raw;        // Overwrite it with the new reading
  filterSum += raw;                       // Add new reading to the running sum
  // Advance the buffer index, wrapping back to 0 after reaching FILTER_SIZE
  filterIndex = (filterIndex + 1) % FILTER_SIZE;
  return filterSum / FILTER_SIZE;   // Return the integer average of all buffered values
}
// ── setup() ──────────────────────────────────────────────────
// Runs once at startup. Initialises serial communication,
// configures pin modes, and pre-fills the filter buffer so
// the first readings are not distorted by zeros in the average.
void setup() {
  Serial.begin(115200);             // Start serial at 115200 baud — must match Serial Plotter
  pinMode(LO_PLUS,  INPUT);         // LO+ is a digital output from AD8232, read as input here
  pinMode(LO_MINUS, INPUT);         // LO- same — goes HIGH if an electrode is not on the skin
  // Pre-fill the filter buffer with real ADC readings
  // so smoothedRead() gives a valid average from the very first call
  for (int i = 0; i < FILTER_SIZE; i++) {
    filterBuffer[i] = analogRead(ECG_PIN);
    filterSum += filterBuffer[i];
  }
}
// ── loop() ───────────────────────────────────────────────────
// Runs continuously. Each iteration reads one ECG sample and
// sends it to Serial Plotter. The 4ms delay sets the sample
// rate to ~250 Hz — fast enough to capture the sharp QRS spike
// clearly without overwhelming the serial buffer.
void loop() {
  // ── Leads-off check ────────────────────────────────────────
  // If either electrode is not making skin contact, the AD8232
  // pulls LO+ or LO- HIGH to signal the problem.
  // We print the ADC midpoint (2048) so the Serial Plotter
  // stays centred on screen rather than jumping to zero.
  if (digitalRead(LO_PLUS) == HIGH ||
      digitalRead(LO_MINUS) == HIGH) {
    Serial.println(2048);           // Flat line at midpoint while electrodes are off
    delayMicroseconds(4000);        // Maintain consistent timing even when not reading
    return;                         // Skip the rest of the loop
  }
  // ── Read and transmit ECG sample ───────────────────────────
  // smoothedRead() returns the filtered ADC value (0–4095).
  // Serial.println() sends it as a number followed by newline,
  // which is exactly the format Serial Plotter expects to draw
  // one point on the graph per line.
  int ecg = smoothedRead();
  Serial.println(ecg);
  // ── Timing ─────────────────────────────────────────────────
  // delayMicroseconds(4000) = 4 ms per sample = 250 Hz.
  // More precise than delay(4) which has millisecond rounding.
  // 250 Hz is well above the ~150 Hz bandwidth needed for ECG.
  delayMicroseconds(4000);
}

The signal is visible now. Arduino Serial Plotter auto-scales continuously and cannot lock the Y axis, making ECG baselines unstable and the waveform unreadable for documentation and visual.

The real solution for a medical-looking display is to stop using Arduino Serial Plotter and use a Python script instead. Python can draw a proper scrolling ECG trace with a dark background, fixed scale, and grid — exactly like a medical monitor.

The Python visualiser using pyserial and matplotlib fixes the Y range, draws a clinical-style grid, and applies an additional smoothing pass — producing a stable, presentation-quality ECG trace from the same hardware.

Installing packages

pip3 install pyserial matplotlib

Ai request:

Write a Python visualiser for live ECG data from serial port — dark background, green trace, fixed Y axis, ECG paper grid, using pyserial and matplotlib.

# ─────────────────────────────────────────────────────────────
# Seebscribe — ECG Medical Monitor Visualiser
# Hardware: XIAO ESP32-C3 + AD8232
#
# INSTALL DEPENDENCIES (run once in Terminal):
#   pip3 install pyserial matplotlib
#
# BEFORE RUNNING:
#   1. Upload the Arduino ECG code to your XIAO ESP32-C3
#   2. Close Arduino Serial Plotter (only one app can use serial at a time)
#   3. Change PORT below to match your board's port
#      Mac:     /dev/cu.usbmodem1101  (check Arduino IDE → Tools → Port)
#      Windows: COM3  (or COM4, COM5 — check Device Manager)
#      Linux:   /dev/ttyUSB0
#
# RUN:
#   python3 ecg_monitor.py
# ─────────────────────────────────────────────────────────────
import serial
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from collections import deque
import sys
# ── Configuration ─────────────────────────────────────────────
# !! CHANGE THIS to your actual port !!
PORT  = "/dev/cu.usbmodem1101"
BAUD  = 115200   # must match Serial.begin() in your Arduino code
# Number of samples visible on screen at once.
# At 125 Hz (8ms interval in Arduino):
#   500  samples = ~4 seconds visible
#   750  samples = ~6 seconds visible
#   1000 samples = ~8 seconds visible
WINDOW = 500
# Y axis range — based on your screenshots signal sits ~2100-2500.
# Adjust if signal is clipping at top or too small to see.
Y_MIN = 1600
Y_MAX = 2900
# ── Serial connection ─────────────────────────────────────────
try:
    ser = serial.Serial(PORT, BAUD, timeout=1)
    print(f"Connected: {PORT} at {BAUD} baud")
    print("Close Arduino Serial Plotter before running this script.")
    print("Press Ctrl+C or close the window to stop.")
except Exception as e:
    print(f"\nERROR: Could not open port {PORT}")
    print(f"Reason: {e}")
    print("\nFix: Change the PORT variable at the top of this file.")
    print("     Check Arduino IDE → Tools → Port for the correct port name.")
    sys.exit(1)
# ── Data buffer ───────────────────────────────────────────────
# deque automatically drops oldest values as new ones arrive.
# Initialised with midpoint value so graph starts flat.
data = deque([2300] * WINDOW, maxlen=WINDOW)
# ── Plot setup — dark medical monitor style ───────────────────
fig, ax = plt.subplots(figsize=(14, 5))
fig.patch.set_facecolor('#0a0a0a')
ax.set_facecolor('#0a0a0a')
# Classic green ECG trace
line, = ax.plot(list(data), color='#00ff66', linewidth=1.4, antialiased=True)
# Fixed Y axis — prevents auto-scale jumping
ax.set_ylim(Y_MIN, Y_MAX)
ax.set_xlim(0, WINDOW)
# Major grid — large squares like ECG paper (every 50 samples)
ax.grid(True,
        which='major',
        color='#1f3d1f',
        linewidth=0.8,
        linestyle='-')
# Minor grid — small squares like ECG paper (every 10 samples)
ax.minorticks_on()
ax.grid(True,
        which='minor',
        color='#121f12',
        linewidth=0.4,
        linestyle='-')
ax.set_xticks(range(0, WINDOW + 1, 50))
ax.set_yticks(range(Y_MIN, Y_MAX + 1, 50))
# Title and labels
ax.set_title('Seebscribe My Heartbeat  ·  Live ECG',
             color='#00cc44',
             fontsize=12,
             fontweight='bold',
             pad=12)
ax.set_xlabel(f'Samples  (window = {WINDOW} samples)',
              color='#336633', fontsize=8)
ax.set_ylabel('ADC value  (0–4095)',
              color='#336633', fontsize=8)
ax.tick_params(colors='#2d5c2d', labelsize=7)
for spine in ax.spines.values():
    spine.set_edgecolor('#1f3d1f')
# Status text — shows connection info bottom left
status = ax.text(10, Y_MIN + 20,
                 f'Port: {PORT}  |  {BAUD} baud  |  Seebscribe v.1',
                 color='#2d5c2d', fontsize=7)
plt.tight_layout()
# ── Animation update function ─────────────────────────────────
# Called by matplotlib every few milliseconds.
# Reads all available serial lines, parses integers,
# adds valid ECG values to the scrolling buffer.
def update(frame):
    """Read new serial data and update the ECG trace."""
    # Read all lines currently waiting in the serial buffer.
    # in_waiting = number of bytes ready to read right now.
    # We loop so we don't fall behind if data arrives in bursts.
    while ser.in_waiting > 0:
        try:
            raw_line = ser.readline().decode('utf-8', errors='ignore').strip()
            # Handle both single-value and comma-separated formats:
            #   "2350"        — from the single-value Arduino sketch
            #   "2100,2350"   — from the dual-value Arduino sketch (take second value)
            if ',' in raw_line:
                parts = raw_line.split(',')
                val = int(parts[-1])   # take the ECG value (last column)
            else:
                val = int(raw_line)
            # Only accept values in the valid 12-bit ADC range
            if 0 <= val <= 4095:
                data.append(val)
        except (ValueError, UnicodeDecodeError):
            pass  # skip malformed or empty lines silently
    line.set_ydata(list(data))
    return line,
# ── Start animation ───────────────────────────────────────────
# interval=8 means redraw every 8ms — matches 125 Hz Arduino rate.
# blit=True only redraws the changed line, not the whole figure.
# cache_frame_data=False prevents memory growth during long sessions.
ani = animation.FuncAnimation(
    fig,
    update,
    interval=8,
    blit=True,
    cache_frame_data=False
)
# ── Cleanup on close ─────────────────────────────────────────
def on_close(event):
    """Close serial port cleanly when window is closed."""
    try:
        ser.close()
        print("Serial port closed.")
    except:
        pass
fig.canvas.mpl_connect('close_event', on_close)
plt.show()

The result looks beautiful.

Next, update the interface.

Upgrade the ECG Python visualiser to add a live dashboard below the trace showing: real-time BPM calculated from R-peak detection, RR interval in milliseconds, HRV using RMSSD, rhythm pattern classification (normal, tachycardia, bradycardia, irregular), signal quality indicator, beat counter, and session timer. Include medical reference ranges on screen. Use matplotlib gridspec for the layout.

If some problem appears with displaying information, I think the recognition is not correct about my actual situation because my hardware is only 13 bits per minute and I have bradycardia. I just need to tune it.

After a series of interactions and adjustments I realized that I need a library which can process a signal from HeartBeat better.

NeuroKit2 — the best single library for current use case. Handles ECG peak detection, HRV analysis, signal quality assessment, and waveform feature extraction all in one package.

pip3 install neurokit2

BioSPPy — older but simpler, good for learning

pip3 install biosppy

HeartPy — specifically designed for wearable/PPG but works for noisy ECG too:

pip3 install heartpy

SciPy — lower level, but gives you the DSP building blocks (bandpass filter, Butterworth filter, wavelet transform) if you want to build your own pipeline:

pip3 install scipy

After using many different libraries, the accuracy became better, but I still realized that it was using different methods of sensing and decided to separate them.

After several hours of experiments with accuracy and troubleshooting with AI, I have this dashboard which can demonstrate different listening methods. Sometimes signal it is the same, but usually it's different.

But still, it's messy and too much information, and now I need to clear the signal. On this stage I decided to switch to Codex and apply more AI in depth on this project. Here are 15 AI requests that I sent to Codex.

Ai requests in CODEX

1.     Analyze my existing ECG/heartbeat sensor files, including Python, Arduino, and dashboard files, and explain how the current system works.
    2.     Review my Fab Academy final project page and connect the ECG heartbeat monitor work to the broader Aura/Seebscribe project concept.
    3.     List possible improvements for streaming heartbeat data, signal accuracy, interface structure, and project organization before implementation.
    4.     Create a cleaner browser-first ECG streaming service, improve signal streaming, test the interface, check basic detection accuracy, and create new files without overwriting the old work.
    5.     Check whether the current XIAO ESP32-C3 Arduino sketch is compatible with the new Python ECG streamer, and provide a new firmware file only if needed.
    6.     Diagnose why the dashboard shows live ECG signal but does not reliably show BPM, RR, RMSSD, or beat count.
    7.     Look at the live ECG screenshot and explain whether the signal looks normal, what the dashboard is showing, and how the ECG-to-BPM pipeline works.
    8.     Update the system to better diagnose AD8232 lead-off pins after correcting LO+ and LO- wiring.
    9.     Create an Arduino diagnostic sketch for XIAO ESP32-C3 + AD8232 that streams raw ECG plus LO+ and LO- states.
    10.  Improve beat detection so noisy peaks are rejected, unstable BPM is marked as tentative, and HRV is only shown when enough clean RR intervals exist.
    11.  Evaluate whether this DIY AD8232 ECG monitor can reach medical-type accuracy, and explain the gap between project-grade monitoring and validated medical ECG systems.
    12.  Create a Phase 1 snapshot folder containing all related Arduino, Python, dashboard, README, and archive files for documentation and future reference.
    13.  List the minimum required files for running Phase 1: the Arduino firmware to upload and the Python service to run.
    14.  Read the Edge Impulse HR/HRV article and translate the useful cardio concepts into practical next steps for this ECG project.
    15.  Summarize all AI collaboration requests that led to the current Phase 1 ECG heartbeat monitor stage.

Finally I got a very beautiful page with very precise accuracy. I can use my Xiaomi Mi Band 8 to compare it with my real touch on my chest to send the heartbeat and everything is accurate. Everything is the same, which is great news.

Phase 1 Files

• Download Phase 1 current-condition archive