Pocket ECG Monitor.

Project Overview

A single-lead ECG recorder that captures a clean, filtered heart trace, detects the QRS complex, computes heart-rate variability, and flags irregular rhythm — with the analogue design and the honest limits both explained properly.

An electrocardiogram measures the electrical activity of the heart at the skin surface. It is one of the oldest and most valuable measurements in medicine, and it is also one of the most demanding to acquire cleanly, because the signal you want is about one millivolt riding on top of interference that is often ten to a hundred times larger. Most of the engineering in this project is about recovering that one millivolt.

The heart of the analogue front end is the AD8232, a single-chip instrumentation amplifier purpose-built for ECG. It provides the high common-mode rejection needed to cancel the interference that appears equally on both electrodes, a right-leg drive that actively pushes back against mains hum on the body, and a built-in band-pass that keeps the 0.5–40 Hz range where the ECG lives while rejecting the DC electrode offset below it and the muscle noise above it. Understanding what each of those does is the difference between a clean trace and a wandering mess.

On the digital side the ESP32 samples the conditioned signal, applies a Pan-Tompkins-style QRS detector — the classic algorithm that every ECG device on earth is a descendant of — and derives heart rate and beat-to-beat variability. It can flag an irregular rhythm, which is the single most useful screening output, because atrial fibrillation is common, often silent, and a major stroke risk.

The most important thing this project does is tell you clearly what it is not. It is a single-lead rhythm recorder, comparable in what it can see to a consumer smartwatch ECG, and nothing like the twelve-lead diagnostic ECG a cardiologist reads. It can show you your rhythm and flag that it looks irregular. It cannot diagnose a heart attack, localise ischaemia, or replace a clinical assessment — and this documentation says so in the device output itself, not just in a footnote.

What this project does

• Acquires a single-lead ECG with the AD8232 analogue front end at 500 samples per second.
• Applies digital filtering to remove residual baseline wander and mains interference.
• Detects QRS complexes with a Pan-Tompkins-style algorithm and marks each R peak.
• Computes heart rate and beat-to-beat (RR) interval variability metrics.
• Flags irregular rhythm from RR-interval dispersion as a screening indicator.
• Streams the live waveform to a phone over BLE and stores recordings for review.
• Runs entirely on battery, fully isolated from mains, as any body-connected device must.

Real-World Applications

Deployment contexts where a build of this kind earns its keep.

Features & Capabilities

• AD8232 front end with right-leg drive and a two-pole band-pass tuned for ECG.
• Lead-off detection that tells you when an electrode has lost contact rather than showing a flat line.
• 500 Hz sampling — enough to resolve the QRS complex, which contains energy up to about 40 Hz.
• Digital notch and baseline filtering to clean up what the analogue stage leaves behind.
• Pan-Tompkins QRS detection with adaptive thresholds and a physiological refractory period.
• Time-domain HRV (mean RR, SDNN, RMSSD, pNN50) computed over a rolling window.
• Irregular-rhythm flag from RR dispersion, the basis of consumer AF screening.
• Battery isolation — the device is never connected to mains while attached to a person.

Difficulty, Time & Required Skills

Skills you should have (or will pick up)

• Analogue signal conditioning intuition — gain, common-mode rejection, filtering
• Arduino C++ with real-time sampling and DSP on buffers
• Digital filter design: band-pass, notch, moving-window integration
• The Pan-Tompkins QRS detection pipeline
• BLE streaming of a continuous waveform
• Enough physiology to interpret P, QRS and T

Bill of Materials

Every part below is commonly available from Indian and international hobby-electronics suppliers. Prices are indicative 2026 retail figures in Indian rupees and will drift — treat them as a budgeting guide, not a quotation.

Estimated total: ₹9,125, excluding tools, shipping and consumables.

Tools and consumables

• Soldering iron (temperature controlled, 350 °C) with 0.8 mm 60/40 or lead-free solder
• Digital multimeter — continuity, DC volts and current ranges
• Wire strippers, flush cutters and a small set of precision screwdrivers
• Heat-shrink tubing and a heat gun (or a lighter, carefully)
• A laptop with a USB port and the toolchain listed above

Hardware Specifications

Consolidated electrical and interface specifications for every active part in the build.

Power Budget & Supply Sizing

Add up the typical active current of every part, then size the supply with at least 50 % headroom so transmit bursts and motor inrush never brown out the controller.

Summed typical draw is 1180.17 mA. With a 1.5× design margin the supply should deliver at least 1800 mA continuously at the stated rail voltage.

Software Requirements & Development Environment

Reference toolchain: Arduino IDE 2.3.x with the ESP32 board package 3.x (or PlatformIO on VS Code). Anything newer normally works; anything older may lack the board definitions used here.

• Install the Arduino IDE 2.3.x (or PlatformIO if you prefer a real editor and dependency locking).
• Add https://espressif.github.io/arduino-esp32/package_esp32_index.json under File → Preferences → Additional Board Manager URLs, then install esp32 from the Boards Manager.
• Set the correct port under Tools → Port. On Linux add yourself to the dialout group: sudo usermod -aG dialout $USER and log out and back in.
• Open the Serial Monitor at 115200 baud — every sketch here logs its state there.
• Keep File → Preferences → Show verbose output during: compilation switched on while you are debugging build errors.

Required libraries

Block Diagram

The block diagram shows the functional decomposition of the system — what senses, what decides, what acts, and where the data ends up.

Circuit Diagram & Wiring

Every signal line in the build is shown below, followed by a pin-by-pin connection table you can work through with a multimeter in hand.

Wire one row at a time and tick it off — most "it does not work" reports trace back to a single swapped pair.

Wiring explanation

• This device must be battery powered and never connected to mains while attached to a person. A body-connected circuit sharing ground with a mains-powered charger or a USB-connected laptop is a genuine electrocution risk. Charge it disconnected from the body, full stop.
• Standard three-electrode placement for Lead I: RA (right arm) to the AD8232 RA input, LA (left arm) to LA, and RL (right leg) to the reference/right-leg-drive output. Getting RA and LA swapped simply inverts the trace; getting RL wrong loses the interference cancellation.
• The AD8232 OUTPUT is a ~1.5 V-centred analogue signal. Feed it to an ADC1 pin (32–39). Do not use ADC2 — it is unavailable while Wi-Fi is active and returns garbage.
• Keep the electrode leads short and shielded, and keep them away from the OLED and any switching. The input impedance is enormous and the signal is a millivolt; it picks up everything.
• Add the reference-buffer and right-leg-drive components exactly as the AD8232 datasheet application circuit shows. These are what reject the 50/60 Hz mains hum that otherwise dominates the trace.
• Decouple the AD8232 supply well. A noisy supply rail appears directly in the output because the amplifier gain is around 1100.

System Architecture

Read the stack from the bottom up: physical hardware, the firmware that drives it, the transport that moves data off the device, and the software a human actually looks at.

Working Principle

The heart is an electrical organ. Each beat begins with a wave of depolarisation that spreads through the atria (the P wave), passes through the AV node, then sweeps rapidly through the ventricles (the QRS complex, the large spike), followed by repolarisation of the ventricles (the T wave). Electrodes on the skin pick up the voltage differences this activity creates, which at Lead I — right arm to left arm — is on the order of one millivolt.

One millivolt is tiny, and it arrives buried in interference. The largest source is mains hum at 50 or 60 Hz, capacitively coupled into the body from every wire in the room. The body acts as an antenna and this hum appears on both electrodes almost equally — it is a common-mode signal. The instrumentation amplifier's job is to amplify the difference between the electrodes (the ECG) while rejecting what is common to both (the hum). Its ability to do this is the common-mode rejection ratio, and the AD8232's is high enough to make the ECG visible.

The right-leg drive improves this actively. It measures the common-mode voltage on the body, inverts it, and drives it back into the body through the third electrode, cancelling much of the interference at source rather than relying on the amplifier alone. It is a feedback loop that keeps the body's common-mode potential near the amplifier's reference, and it is why a two-electrode ECG is so much noisier than a three-electrode one.

The AD8232 also band-passes the signal, and both ends matter. The high-pass at about 0.5 Hz removes the large, slowly-varying DC offset between the electrode and skin — an offset that can be hundreds of millivolts, dwarfing the ECG, and that wanders as the electrode dries or the person moves. The low-pass at about 40 Hz removes muscle noise (EMG) and high-frequency interference while preserving the QRS, whose energy is concentrated below 40 Hz.

The digital side implements Pan-Tompkins, the 1985 algorithm that remains the foundation of QRS detection. It is a pipeline: band-pass filter to isolate QRS energy (5–15 Hz), differentiate to emphasise the steep slopes of the QRS, square to make everything positive and amplify large values, then integrate over a moving window sized to the QRS width. The result is a smooth pulse for each QRS, and an adaptive dual-threshold scheme with a 200 ms refractory period picks the peaks while rejecting T waves and noise. The 200 ms refractory corresponds to 300 beats per minute — faster than any real heart — so it cannot miss real beats but does reject the tall T wave that would otherwise be counted as a second beat.

From the sequence of R-peak times comes everything clinically interesting at this level. Heart rate is 60 divided by the RR interval. Heart-rate variability — the beat-to-beat fluctuation — reflects autonomic nervous system balance and is computed as SDNN (overall variability), RMSSD (short-term, parasympathetic), and pNN50 (proportion of successive intervals differing by more than 50 ms). And an irregular rhythm shows up as high RR dispersion with no periodicity, which is the signature of atrial fibrillation and the basis of every consumer AF-screening feature.

The maths behind it

Common-mode rejection

Differential (ECG) signal:  V_diff ≈ 1 mV
Common-mode (mains) signal: V_cm  ≈ 100–1000 mV on the body

Output = A_diff · V_diff + A_cm · V_cm

CMRR (dB) = 20·log10(A_diff / A_cm)

AD8232 CMRR ≈ 80 dB at 60 Hz → A_cm = A_diff / 10000

With A_diff = 1100:
  ECG output      = 1100 × 1 mV      = 1.10 V
  mains leakthrough= 0.11 × 500 mV   = 0.055 V

The right-leg drive reduces V_cm further at source,
typically by another 20–40 dB.

Pan-Tompkins pipeline

x     : raw samples at fs = 500 Hz
b     = bandpass(x, 5–15 Hz)      isolate QRS energy
d[n]  = (2·b[n] + b[n-1] − b[n-3] − 2·b[n-4]) / 8   derivative
s[n]  = d[n]²                     square (all positive, amplify peaks)
i[n]  = (1/N) · Σ s[n-k], k=0..N-1   moving-window integrate

Window N ≈ 0.15·fs = 75 samples (QRS width ~150 ms)

A peak in i[] above the adaptive threshold, at least
200 ms after the last, is an R peak.

Adaptive threshold and HRV

Adaptive threshold (per Pan-Tompkins):
  SPKI = 0.125·PEAKI + 0.875·SPKI    (signal estimate)
  NPKI = 0.125·PEAKI + 0.875·NPKI    (noise estimate)
  THRESHOLD = NPKI + 0.25·(SPKI − NPKI)

HRV over N successive RR intervals (ms):
  meanRR = (1/N)·Σ RR
  SDNN   = sqrt( (1/(N-1))·Σ (RR - meanRR)² )
  RMSSD  = sqrt( (1/(N-1))·Σ (RR[i+1]-RR[i])² )
  pNN50  = 100 · count(|RR[i+1]-RR[i]| > 50 ms) / (N-1)

Irregular-rhythm indicator:
  irregular if (SDNN > 120 ms) AND (RMSSD > 100 ms)
              AND no dominant RR periodicity

Program Flowchart

The firmware is a single cooperative loop. Nothing blocks for long, so networking, sensing and the user interface all stay responsive.

Assembly Instructions

Build on a breadboard first and only commit to solder once the whole system has run for an hour without a fault.

Step-by-Step Implementation Guide

Work through these in order. Each step ends in something you can observe, so a failure is always localised to the step you just finished.

Complete Source Code

The listing below is complete and compiles as written — there are no elided sections. Read the annotations under each block before you upload it.

/* ═══════════════════════════════════════════════════════════════
   Pocket ECG Monitor — ESP32 + AD8232

   Single-lead ECG acquisition at 500 Hz with digital filtering,
   Pan-Tompkins QRS detection, heart-rate variability, and an
   irregular-rhythm screening flag.

   SINGLE-LEAD RHYTHM RECORDER — comparable to a consumer smartwatch
   ECG. NOT a diagnostic 12-lead ECG. BATTERY POWER ONLY; never connect
   to mains while attached to a person.
   ══════════════════════════════════════════════════════════════════ */

#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <math.h>

#define PIN_ECG    34
#define PIN_LO_P   32
#define PIN_LO_N   33
#define PIN_SDN    27
#define PIN_BTN    25
#define PIN_LED    26

#define FS         500              // sampling rate, Hz
#define BUF_LEN    2500             // 5 s of trace
#define REFRACTORY_MS 200           // 300 bpm ceiling
#define RR_HISTORY  64

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

/* ── ring buffer and filter state ───────────────────────────── */
float raw[BUF_LEN];
int   bufIdx = 0;

// Band-pass 5–15 Hz: cascade of low-pass and high-pass integer filters
// (the classic Pan-Tompkins realisation for integer hardware).
int32_t lpBuf[13] = {0}, hpBuf[33] = {0};
float   derivBuf[4] = {0};
float   mwiBuf[75]  = {0};          // moving-window integrator
int     mwiIdx = 0;
float   mwiSum = 0;

float   SPKI = 0, NPKI = 0, threshold = 0;
uint32_t lastBeatMs = 0;
float   rr[RR_HISTORY];
uint8_t rrHead = 0, rrCount = 0;
float   heartRate = 0, sdnn = 0, rmssd = 0, pnn50 = 0;
bool    irregular = false, leadOff = true;

/* ── Pan-Tompkins band-pass (integer, per the original paper) ── */
float bandpass(float x) {
  // Low-pass: y[n] = 2y[n-1] - y[n-2] + x[n] - 2x[n-6] + x[n-12]
  static float ly1 = 0, ly2 = 0, lx[13] = {0};
  for (int i = 12; i > 0; i--) lx[i] = lx[i - 1];
  lx[0] = x;
  float ly = 2 * ly1 - ly2 + lx[0] - 2 * lx[6] + lx[12];
  ly2 = ly1; ly1 = ly;

  // High-pass: y[n] = y[n-1] - x[n]/32 + x[n-16] - x[n-17] + x[n-32]/32
  static float hy1 = 0, hx[33] = {0};
  for (int i = 32; i > 0; i--) hx[i] = hx[i - 1];
  hx[0] = ly;
  float hy = hy1 - hx[0] / 32.0f + hx[16] - hx[17] + hx[32] / 32.0f;
  hy1 = hy;
  return hy;
}

float derivative(float x) {
  static float d[5] = {0};
  for (int i = 4; i > 0; i--) d[i] = d[i - 1];
  d[0] = x;
  return (2 * d[0] + d[1] - d[3] - 2 * d[4]) / 8.0f;
}

float movingWindow(float x) {
  mwiSum -= mwiBuf[mwiIdx];
  mwiBuf[mwiIdx] = x;
  mwiSum += x;
  mwiIdx = (mwiIdx + 1) % 75;
  return mwiSum / 75.0f;
}

/* ── QRS detection ──────────────────────────────────────────── */
bool detectQRS(float integrated, uint32_t nowMs) {
  static float prev = 0, prevPrev = 0;
  bool isPeak = prev > prevPrev && prev > integrated && prev > threshold;

  // Adaptive thresholds (Pan-Tompkins).
  if (prev > threshold) SPKI = 0.125f * prev + 0.875f * SPKI;
  else                  NPKI = 0.125f * prev + 0.875f * NPKI;
  threshold = NPKI + 0.25f * (SPKI - NPKI);

  prevPrev = prev; prev = integrated;
  if (!isPeak) return false;
  if (nowMs - lastBeatMs < REFRACTORY_MS) return false;   // rejects T waves

  uint32_t interval = nowMs - lastBeatMs;
  lastBeatMs = nowMs;
  if (interval < 200 || interval > 2500) return false;    // 24–300 bpm sane

  rr[rrHead] = interval;
  rrHead = (rrHead + 1) % RR_HISTORY;
  if (rrCount < RR_HISTORY) rrCount++;
  return true;
}

/* ── HRV and rhythm ─────────────────────────────────────────── */
void updateMetrics() {
  if (rrCount < 5) return;

  float mean = 0;
  for (int i = 0; i < rrCount; i++) mean += rr[i];
  mean /= rrCount;
  heartRate = 60000.0f / mean;

  double var = 0, succ = 0; int over50 = 0;
  for (int i = 0; i < rrCount; i++) { float d = rr[i] - mean; var += d * d; }
  for (int i = 1; i < rrCount; i++) {
    float d = rr[i] - rr[i - 1];
    succ += (double)d * d;
    if (fabsf(d) > 50) over50++;
  }
  sdnn  = sqrt(var / (rrCount - 1));
  rmssd = sqrt(succ / (rrCount - 1));
  pnn50 = 100.0f * over50 / (rrCount - 1);

  // Irregular-rhythm screen: high dispersion without periodicity.
  irregular = (sdnn > 120 && rmssd > 100);
}

/* ── lead-off ───────────────────────────────────────────────── */
bool checkLeadOff() {
  return digitalRead(PIN_LO_P) == HIGH || digitalRead(PIN_LO_N) == HIGH;
}

/* ── display ────────────────────────────────────────────────── */
void drawTrace() {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);

  if (leadOff) {
    oled.setTextSize(1);
    oled.setCursor(0, 24); oled.println("Check electrodes");
    oled.setCursor(0, 36); oled.println("(lead off)");
    oled.display();
    return;
  }

  // Scroll the last 128 samples across the top 40 px.
  float lo = 1e9, hi = -1e9;
  for (int i = 0; i < 128; i++) {
    float v = raw[(bufIdx + BUF_LEN - 128 + i) % BUF_LEN];
    lo = fminf(lo, v); hi = fmaxf(hi, v);
  }
  float span = hi - lo; if (span < 1) span = 1;
  for (int i = 1; i < 128; i++) {
    int y0 = 40 - (int)((raw[(bufIdx + BUF_LEN - 129 + i) % BUF_LEN] - lo) / span * 38);
    int y1 = 40 - (int)((raw[(bufIdx + BUF_LEN - 128 + i) % BUF_LEN] - lo) / span * 38);
    oled.drawLine(i - 1, y0, i, y1, SSD1306_WHITE);
  }

  oled.setTextSize(2); oled.setCursor(0, 46);
  oled.printf("%3.0f", heartRate);
  oled.setTextSize(1); oled.setCursor(42, 52); oled.print("bpm");
  oled.setCursor(66, 46); oled.printf("SDNN %.0f", sdnn);
  oled.setCursor(66, 56);
  oled.print(irregular ? "IRREGULAR - see MD" : "regular rhythm");
  oled.display();
}

/* ── sampling timer ─────────────────────────────────────────── */
hw_timer_t *timer = NULL;
volatile bool sampleReady = false;
void IRAM_ATTR onTimer() { sampleReady = true; }

void setup() {
  Serial.begin(115200);
  pinMode(PIN_LO_P, INPUT); pinMode(PIN_LO_N, INPUT);
  pinMode(PIN_SDN, OUTPUT); digitalWrite(PIN_SDN, HIGH);   // enable AD8232
  pinMode(PIN_BTN, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  analogSetPinAttenuation(PIN_ECG, ADC_11db);

  Wire.begin(21, 22);
  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);

  // Hardware timer at exactly 500 Hz — jitter-free sampling matters
  // enormously for a filtered biomedical signal.
  timer = timerBegin(0, 80, true);            // 80 MHz / 80 = 1 MHz tick
  timerAttachInterrupt(timer, &onTimer, true);
  timerAlarmWrite(timer, 2000, true);         // 1 MHz / 2000 = 500 Hz
  timerAlarmEnable(timer);

  Serial.println("Pocket ECG — SINGLE-LEAD RHYTHM ONLY, battery power only");
}

void loop() {
  if (sampleReady) {
    sampleReady = false;
    uint32_t nowMs = millis();

    leadOff = checkLeadOff();
    if (leadOff) { rrCount = 0; return; }

    float x = analogRead(PIN_ECG);
    raw[bufIdx] = x;
    bufIdx = (bufIdx + 1) % BUF_LEN;

    float b = bandpass(x);
    float d = derivative(b);
    float s = d * d;
    float i = movingWindow(s);

    if (detectQRS(i, nowMs)) {
      digitalWrite(PIN_LED, HIGH);
      updateMetrics();
    } else if (nowMs - lastBeatMs > 60) {
      digitalWrite(PIN_LED, LOW);
    }
  }

  static uint32_t lastDraw = 0;
  if (millis() - lastDraw > 100) {            // 10 fps display, not per-sample
    lastDraw = millis();
    drawTrace();
    Serial.printf("HR %.0f  SDNN %.0f  RMSSD %.0f  pNN50 %.0f  %s\n",
                  heartRate, sdnn, rmssd, pnn50, irregular ? "IRREGULAR" : "regular");
  }
}

Configuration & Calibration

Dataset, Model & Training

Dataset

The QRS detector here is the classical rule-based Pan-Tompkins algorithm, not a learned model — and for a first build that is the right choice, because it is transparent, well-validated, and does not require training data or risk overfitting to a small personal recording.

If you want to go further into learned rhythm classification, the MIT-BIH Arrhythmia Database on PhysioNet is the standard benchmark: 48 half-hour two-channel recordings with beat-by-beat cardiologist annotations, used to validate essentially every published detector. The PhysioNet/CinC Challenge 2017 dataset provides single-lead recordings labelled for atrial fibrillation, which is directly relevant to the screening flag.

Validate your detector against MIT-BIH before trusting it: run it over the annotated records and compute sensitivity and positive predictivity against the reference beat annotations. A good QRS detector achieves over 99 % on both — anything much below that has a bug.

Evaluation, Metrics & Deployment

The figures below are for the Pan-Tompkins QRS detector validated against the MIT-BIH reference annotations, the standard benchmark. They characterise the detection stage, not clinical diagnostic accuracy, which this device does not claim.

Figures from the reference training run described above — reproduce them before trusting your own changes.

Testing Procedure & Expected Output

Test from the bottom up. Confirm power, then each sensor in isolation, then the integrated loop — the first failing step tells you exactly where to look.

Bench-test checklist. If a row fails, stop and fix it before moving on.

Expected output

With everything wired and the firmware uploaded, the Serial Monitor at 115200 baud should look similar to the trace below. Values will differ; the shape of the output should not.

Troubleshooting: Common Errors & Fixes

Performance Optimisation

• Sample from a hardware timer, not the loop. Jitter in the sample interval smears every filter and degrades QRS detection more than any algorithm change can fix.
• Keep the display refresh at about 10 fps. Redrawing the OLED per sample at 500 Hz would consume most of the CPU for no visible benefit.
• Do the DSP in floats on the ESP32 — it has hardware floating point, and integer scaling of the Pan-Tompkins stages is a false economy that only introduces rounding error.
• Replace every delay() with a millis() comparison — blocking delays are the single most common cause of dropped readings.
• Sample sensors on a fixed cadence and publish on a slower one; you almost never need to transmit at the sampling rate.
• Move networking into its own FreeRTOS task so a slow DNS lookup cannot stall the control loop.
• Use uint8_t / uint16_t where the range allows; on an 8-bit AVR a 32-bit add costs four times as much.
• For battery builds use deep sleep between samples: an ESP32 drops from ~160 mA awake to about 10 µA asleep, which is the difference between days and months of runtime.
• Profile before optimising — print micros() deltas around each stage and fix the slowest one first.

Safety Precautions

• Battery power only. Never connect to mains — or to a mains-powered computer — while the device is attached to a person. This is the single non-negotiable safety rule. A body-connected circuit that shares ground with mains is an electrocution risk.
• This is a single-lead rhythm recorder, comparable to a consumer smartwatch ECG. It cannot diagnose a heart attack, and a normal-looking trace does not mean your heart is fine. Chest pain, breathlessness or collapse is a medical emergency regardless of what this shows.
• The irregular-rhythm flag is a prompt to see a doctor, never a diagnosis. Do not start, stop or change any medication based on it.
• Use fresh, single-use electrodes and do not share them. Do not use on broken skin.
• Anyone with an implanted pacemaker or defibrillator should not use experimental body-connected electronics without medical advice.
• Lithium cells vent and burn when abused. Only use protected cells or a proper BMS, never charge below 0 °C, and never leave a charging pack unattended on a wooden desk.
• Wear eye protection when soldering or cutting, and solder in a ventilated space — rosin flux fumes are a respiratory irritant.
• Power the circuit through a bench supply with a current limit while you are testing. A 300 mA limit turns a wiring mistake into a beep instead of a dead board.
• Disconnect power before changing any wiring. Hot-plugging a sensor onto a live bus is the fastest way to lose a controller.

Maintenance

• Re-check every screw terminal and header after the first week — thermal cycling loosens connections that felt tight on day one.
• Log pack voltage. When resting voltage after a full charge drops below about 4.0 V, the cell is near end of life — replace it.
• Recalibrate at the interval given in the calibration section, and keep the constants in a text file next to the firmware — not only in flash.
• Keep a short logbook of firmware versions and what changed. Six months later you will not remember why that constant is 1.083.

Future Improvements & Upgrades

A working v1 is a platform, not a finish line. These are the upgrades that add the most capability for the least rework.

• Add a learned AF classifier trained on the CinC 2017 dataset, which materially outperforms the simple RR-dispersion rule and can flag other arrhythmias.
• Add multiple leads with additional AD8232 channels or a dedicated multi-lead front end (ADS1292R), moving toward the spatial information a clinician actually uses.
• Add proper artefact rejection so the device works during light activity, using an accelerometer to gate detection during motion.
• Add PDF strip export in the standard scale (25 mm/s, 10 mm/mV) so a clinician can read a recording in the familiar format.
• Add long-term event recording — buffer to SD when the rhythm looks abnormal, turning it into a personal event monitor.
• Design a proper PCB. Once the breadboard version has run for a month, moving to a two-layer board removes the intermittent-contact failures that dominate prototype faults.
• Add connectivity — an ESP32 and an MQTT publish turn a local gadget into something you can graph, alert on and analyse over months.
• Add persistent local storage (microSD or the on-chip flash) so a network outage does not create a hole in your data.
• Move configuration out of the source: a captive-portal setup page or a JSON config file makes the build reusable without a recompile.
• Add a battery and solar option so the unit survives a power cut and can be sited away from a socket.
• Write a small test harness that feeds synthetic sensor values through the decision logic, so you can validate thresholds without physically triggering the event.

Frequently Asked Questions

References & Learning Resources

These are the primary sources worth reading in full. Manufacturer datasheets always outrank forum posts when the two disagree.

1. AD8232 single-lead heart rate monitor front end — datasheetAnalog Devices
2. Pan & Tompkins, "A Real-Time QRS Detection Algorithm"IEEE TBME, 1985
3. PhysioNet — MIT-BIH Arrhythmia DatabasePhysioNet
4. PhysioNet/CinC Challenge 2017 — AF classification from a short single leadPhysioNet
5. Task Force of ESC/NASPE, "Heart rate variability: standards of measurement"Circulation, 1996
6. IEC 60601-2-47 — safety of ambulatory electrocardiographic systemsIEC