ECG board

An ECG board with an Arduino that sends samples over serial to a Processing monitor. I soldered and tested the board, connected the probes, and wrote the monitor, which draws a scrolling trace and estimates heart rate from the time between threshold crossings.

Hardware: Ninetales board and an Arduino
Software: An Arduino sketch and a Processing monitor
Context: A classroom monitor

Explore details

BME 2081C, University of Cincinnati · Summer 2026

ECG board

A soldered board, an Arduino and a Processing monitor, followed from the skin to a beat flag on screen.

Move the probe Where the numbers come from

I soldered: and tested the Ninetales board and connected the ECG probes
I adapted: the Arduino sketch from the course example
I wrote: the Processing monitor: trace, beat flag and rate estimate

Educational prototype. It is not a diagnostic or clinically validated monitor, and the trace on the scope is synthetic.

Signal scope synthetic trace

Probe at: Electrode leads
Screen: Raw analog voltage
Signal: weak

Threshold 450

Probe at The electrodes

Three electrodes on the skin pick up the heart signal. At this point it is small, noisy and drifting.

Arduino C++

ECG Arduino sketch

6 parts. Click a part name, or press j and k.

Original PDF (opens in a new tab)

// This Arduino code has been written by Univeristy Of Cincinnati Student Hamza Al Halabi [Alhalaha] for use in Circuits BME2081C for Summer of 2026

// This code runs in parallel with Processing to create visual outputs including audio, light, and graphic representation

// Enjoy!

// FILENAME: Alhalaha_ECG_Monitor.ino

// Based on EXAMPLE02_Sample.ino (Orlando S. Hoilett, Ph.D.)

// Reads ECG analog input from Ninetales board and transmits values over Serial to Processing for real-time visualization & beat detection.

// ECG Channel Pin (A2 is default for EXG/ECG on Ninetales, A1 can also be used)

const int ECG_PIN = A1;

void setup() {

// Initialize serial communication at 9600 baud for smooth plotting

Serial.begin(9600);

}

void loop() {

// Read the analog signal from Ninetales (0 to 1023)

int ecgSignal = analogRead(ECG_PIN);

// Send raw value over Serial

Serial.println(ecgSignal);

// 10ms delay gives ~100 Hz sampling rate, ideal for ECG capture

delay(10);

}

1Part 1 of 6lines 1–7
Header: who wrote what
Plain English
Comments only. They say this is my sketch for the BME2081C course, that it runs alongside a Processing program, and that it is based on the course example EXAMPLE02_Sample.ino.
Why this way
I adapted the Arduino sketch from EXAMPLE02_Sample.ino; the header keeps the course example's credit.
Tweaks
The header credits the course example the sketch is adapted from.
2Part 2 of 6lines 10–11
Which pin is the ECG
Plain English
Names the analog input the sketch reads: A1. The comment says A2 is the default ECG input on the Ninetales board and that A1 can also be used.
Why this way
ECG_PIN selects the analog input and must match the board channel.
Tweaks
Point ECG_PIN at another channel (the comment names A2) if you plug the cable in elsewhere. If the trace is flat, the wrong channel is the first thing to check.
3Part 3 of 6lines 13–16
setup: open the serial port
Plain English
Runs once at power-up. Serial.begin(9600) opens the USB serial link at 9600 baud, which is bits per second.
Why this way
Both programs configure the serial link at 9600 baud, and the two numbers have to match.
Tweaks
A faster rate such as 115200 is possible, but you must change it in both programs. At 9600 the link has room for one short number every 10 ms, so it is not what limits this build.
4Part 4 of 6lines 18–20
Read the analog input
Plain English
Start of loop(), which repeats forever. analogRead(ECG_PIN) turns the voltage on A1 into a whole number from 0 to 1023, and stores it in ecgSignal.
Why this way
The Ninetales board does the analog work (amplifying and filtering the tiny electrode signal). The Arduino only has to measure the board's output voltage once per pass.
Tweaks
You could average a few reads to smooth noise, at the cost of a slower loop. No scaling is done here: the raw count goes out untouched, so every threshold downstream is in raw counts.
5Part 5 of 6lines 22–23
Send it over serial
Plain English
Serial.println(ecgSignal) sends the number as text, then a line break. One reading, one line.
Why this way
Text with a newline is easy to debug in the Arduino Serial Monitor and easy for Processing to cut apart, since it can wait for the line break.
Tweaks
Sending two raw bytes per sample is shorter than text, but harder to read by eye. Another channel could go on the same line, separated by a comma.
6Part 6 of 6lines 25–27
delay(10): the loop delay
Plain English
Waits 10 milliseconds, then loop() starts again. The comment in the source says 10 ms gives about 100 Hz.
Why this way
The loop waits 10 ms after reading and sending a sample. The source calls this approximately 100 Hz; the actual rate was not measured, since the read and the serial write add time on every pass. 'Ideal' in the comment is the original author's word; nothing here tested it.
Tweaks
delay(5) would aim for about 200 Hz, and the link and the monitor would need checking again. For a rate you can trust, time the loop with micros() or use a hardware timer.

Processing (Java)

ECG Processing monitor

11 parts. Click a part name, or press j and k.

Original PDF (opens in a new tab)

// This Processing code has been written by Univeristy Of Cincinnati Student Hamza Al Halabi [Alhalaha] for use in Circuits BME2081C for Summer of 2026

// No Artificial intelligence was used for this program with the unique exception of line 32 to obtain the correct hospital monitor pitch

// This Code runs in parallel with the arduino code to provide the visual and audible outputs

// Code is fully commented to allow for easy navigation to essential chunck loops such as line trace, bpm tracking, sound initialization, et as well explain certain functionalities

// Enjoy!

import processing.serial.*;

import processing.sound.*; // Import the Sound library

Serial myPort;

SinOsc beepSound; // Create the sine wave oscillator

int ecgValue = 0;

// Variables for the scrolling line

int xPos = 0;

float previousX = 0;

float previousY = 0;

// Threshold and Visual settings

int threshold = 450;

int flashTimer = 0;

// BPM Calculation Variables

boolean isPeak = false;

long lastBeatTime = 0;

float currentBPM = 0;

void setup() {

size(1000, 500);

background(5, 10, 5);

// Initialize the beep sound

beepSound = new SinOsc(this);

beepSound.freq(700); // 700 Hz is a standard clinical monitor pitch

beepSound.play();

beepSound.amp(0.0); // Start it muted

printArray(Serial.list());

try {

String portName = Serial.list()[12];

myPort = new Serial(this, portName, 9600);

myPort.bufferUntil('\n');

println("SUCCESS: Connected to " + portName);

} catch (Exception e) {

println("CRITICAL ERROR: Could not connect to the COM port!");

println("Close the Arduino Serial Monitor and try again.");

}

void draw() {

// ==========================================

// 1. DRAW TRACE AREA (WITH ERASE BAR & GRID)

// ==========================================

float traceWidth = width - 280;

// Erase the path ahead of the drawing line

noStroke();

fill(5, 10, 5);

rect(xPos, 0, 40, height);

// Draw faint clinical grid lines

stroke(15, 30, 15);

strokeWeight(1);

for (int i = 0; i < height; i += 50) {

line(xPos, i, xPos + 40, i);

}

for (int i = 0; i < traceWidth; i += 50) {

if (i >= xPos && i < xPos + 40) {

line(i, 0, i, height);

}

// ==========================================

// 2. THRESHOLD, BPM, AND AUDIO LOGIC

// ==========================================

if (ecgValue >= threshold && !isPeak) {

flashTimer = 10;

isPeak = true;

beepSound.amp(0.4); // Turn the beep volume up when threshold is crossed

long currentTime = millis();

long timeInterval = currentTime - lastBeatTime;

// Filter noise: Calculate only if interval is between 300ms (200 BPM) and 2000ms (30 BPM)

if (timeInterval > 300 && timeInterval < 2000) {

currentBPM = 60000.0 / timeInterval;

}

lastBeatTime = currentTime;

}

if (ecgValue < threshold - 20) {

isPeak = false; // Reset lock

}

// ==========================================

// 3. DRAW RIGHT-SIDE VITALS PANEL

// ==========================================

noStroke();

fill(15, 20, 15);

rect(traceWidth, 0, 280, height);

// Panel Border Line

stroke(30, 60, 30);

strokeWeight(3);

line(traceWidth, 0, traceWidth, height);

// Beating Heart Icon & Audio Mute Logic

if (flashTimer > 0) {

fill(255, 40, 40); // Bright Red Flash

flashTimer--;

// Mute the beep the moment the flash finishes

if (flashTimer == 0) {

beepSound.amp(0.0);

}

} else {

fill(60, 15, 15); // Dim Red Rest

}

ellipse(traceWidth + 50, 60, 25, 25);

// Label

fill(200);

textSize(20);

text("ECG / EKG", traceWidth + 80, 67);

// MASSIVE BPM DISPLAY

fill(0, 255, 100); // Neon Green text

textSize(24);

text("HR", traceWidth + 30, 160);

textSize(80); // Giant clinical font

if (currentBPM > 0) {

text(int(currentBPM), traceWidth + 80, 180);

} else {

text("--", traceWidth + 80, 180);

}

textSize(20);

text("bpm", traceWidth + 210, 180);

// DYNAMIC LEVEL INDICATOR

String levelText = "ANALYZING...";

color levelColor = color(100);

if (currentBPM > 0) {

if (currentBPM < 60) {

levelText = "LOW (BRADYCARDIA)";

levelColor = color(255, 255, 100); // Yellow

} else if (currentBPM <= 99) {

levelText = "NORMAL RESTING";

levelColor = color(100, 200, 255); // Cyan

} else if (currentBPM <= 139) {

levelText = "ACTIVE";

levelColor = color(255, 150, 0); // Orange

} else {

levelText = "ELEVATED";

levelColor = color(255, 50, 50); // Red

}

fill(levelColor);

textSize(22);

text(levelText, traceWidth + 30, 240);

// Debug/Raw Data at the bottom of the panel

fill(0, 150, 50);

textSize(14);

text("RAW SIGNAL: " + ecgValue, traceWidth + 30, height - 50);

text("THRESHOLD: " + threshold, traceWidth + 30, height - 30);

// ==========================================

// 4. DRAW THE ECG TRACE

// ==========================================

float mappedY = map(ecgValue, 300, 600, height - 40, 40);

stroke(0, 255, 50); // Bright Hospital Green

strokeWeight(3);

if (xPos > 0 && xPos < traceWidth) {

line(previousX, previousY, xPos, mappedY);

}

previousX = xPos;

previousY = mappedY;

xPos += 3; // Speed of the scan line

// Wrap around when it hits the panel

if (xPos >= traceWidth) {

xPos = 0;

previousX = 0;

}

// Automatically triggers whenever Arduino sends data

void serialEvent(Serial myPort) {

String inString = myPort.readStringUntil('\n');

if (inString != null) {

inString = trim(inString);

try {

ecgValue = int(inString);

} catch (NumberFormatException e) {}

}

1Part 1 of 11lines 1–5
Header: who wrote what
Plain English
Comments only. They say I wrote this monitor for BME2081C, that it runs alongside the Arduino sketch, and that no AI was used except for one line: the pitch of the beep. The header gives that line as 32.
Why this way
I wrote the monitor and used AI to choose the beep pitch. The beep pitch line, beepSound.freq(700), sets the pitch.
Tweaks
The header comment does not affect how the program runs.
2Part 2 of 11lines 7–27
Libraries, state, threshold
Plain English
Loads the serial and sound libraries and declares the program's memory: the latest reading (ecgValue), the scan position (xPos), a flash countdown, a peak lock (isPeak), the time of the last beat and the current heart-rate estimate. threshold is set to 450 right here.
Why this way
Everything the draw loop needs between frames lives in these globals. The threshold is a fixed number written in the source. It is a raw count on the 0 to 1023 scale, so it only suits a signal that rises above 450 on every beat.
Tweaks
For this classroom demo, set the threshold between the baseline and peak raw counts: read the RAW SIGNAL number on screen at rest and at the peak. Changes in baseline or signal size can cause missed or repeated flags.
3Part 3 of 11lines 29–37
setup: a muted 700 Hz tone
Plain English
Sets the window to 1000 by 500 pixels with a near-black green background. Then it creates a sine-wave oscillator at 700 Hz, starts it playing and turns its volume to zero.
Why this way
The oscillator keeps running while the program changes its volume. I chose 700 Hz for the demo. The source comment calls it a standard clinical monitor pitch; this project did not check that.
Tweaks
Change freq(700) for a different pitch. Lower the 0.4 volume used on a beat if it is loud. Mute it entirely by never raising the amp.
4Part 4 of 11lines 39–50
setup: open the serial port
Plain English
Prints the list of serial ports, then tries to open one at 9600 baud. It uses the port at position 12 in that list, and bufferUntil('\n') makes Processing wait for a full line before it calls serialEvent. If anything fails, it prints an error telling you to close the Arduino Serial Monitor.
Why this way
Only one program can hold a serial port at a time, which is why the error message names the Serial Monitor. The 9600 matches Serial.begin(9600) in the Arduino sketch. Port index 12 is specific to my setup.
Tweaks
Check the printed port list before changing the index; an invalid index and a busy port produce the same error message.
5Part 5 of 11lines 53–73
draw: erase bar and grid
Plain English
Each frame it paints a 40-pixel dark block just ahead of the scan position, to wipe the old trace. Then it redraws faint grid lines inside that block only. The trace area is the window width minus 280 pixels, which leaves room for the side panel.
Why this way
The screen is never cleared. The block ahead of the line is erased as the line moves, which gives the sweeping look of a bedside monitor and keeps the drawing cheap.
Tweaks
Widen the 40 for a bigger gap ahead of the line. Change the 50-pixel grid spacing. This block does not touch the data.
6Part 6 of 11lines 75–95
Beat detection and heart rate
Plain English
The monitor flags a threshold crossing when the latest reading reaches 450 ADC counts and no peak is already being tracked. It starts a 10-frame flash, locks isPeak, raises the beep volume and takes the time since the last flag. The peak lock re-arms when the reading falls below 430. The heart-rate estimate is 60000 divided by the gap, updated only for gaps greater than 300 ms and less than 2000 ms.
Why this way
The peak lock stops one tall peak from being flagged many times while the value stays high. The 20-count drop gives it a little room against jitter. The gap window is a plain rule on timing; it does not tell noise from a heartbeat.
Tweaks
This is a fixed-threshold detector, so it depends on signal size and baseline: a smaller or drifting signal can miss beats or never re-arm. It runs once per drawn frame, not once per sample. Options: an adaptive threshold, a smoothed rate over several beats, or checking the frame rate.
7Part 7 of 11lines 97–121
Flash, beep off, heart icon
Plain English
Draws the dark side panel and its border. Then the heart dot: while flashTimer is above zero it is bright red and counts down; when it reaches zero the beep volume goes back to 0. Otherwise the dot is dim red.
Why this way
The flash and the beep share one countdown, so the light and the sound start together and stop together. Both last ten drawn frames.
Tweaks
Raise flashTimer in the beat block for a longer flash and beep. Because the timer counts frames, it also changes with the frame rate, and this program never sets one.
8Part 8 of 11lines 123–165
Heart-rate readout and level label
Plain English
Writes the 'ECG / EKG' label and a big rate estimate, or '--' until one exists. Below it a label and colour set by fixed cut-offs: under 60, up to 99, up to 139, above that, and ANALYZING while there is no estimate yet.
Why this way
These labels belong to a classroom demo program I wrote. They are fixed cut-offs on a number from a fixed-threshold detector. They are not a diagnosis, and nothing here was checked against a clinical device. The source text keeps its original wording.
Tweaks
For a revised display, remove the condition labels and show only the estimated rate and raw trace.
9Part 9 of 11lines 167–171
Raw value and threshold on screen
Plain English
Prints the current raw reading and the threshold in small green text at the bottom of the panel.
Why this way
This is the tuning aid. To set the threshold you need to see the raw numbers your own signal produces.
Tweaks
Add the current frame rate or the last beat gap to the debug text.
10Part 10 of 11lines 173–194
draw: the trace line
Plain English
Maps the raw reading from the range 300 to 600 onto the screen height, draws a line from the last point to the new one, then moves right by 3 pixels. At the end of the trace area it wraps back to the left edge.
Why this way
One point is drawn per frame, using whatever value serialEvent stored last. So the trace follows the frames of the window, not the 10 ms samples one by one. The 300 to 600 range is why 450 sits mid-screen. A value outside that range is drawn off the plot, because map() does not clamp.
Tweaks
Change 300 and 600 to fit your signal. Draw every incoming sample, not one per frame, to see the full sample stream. Change xPos += 3 for a faster or slower sweep.
11Part 11 of 11lines 196–205
serialEvent: read one line
Plain English
Processing calls this on its own each time a full line has arrived from the Arduino. It reads the line, trims the line break and turns the text into an integer stored in ecgValue.
Why this way
This is the only place the data comes in. It is a hand-off: serialEvent writes ecgValue, draw() reads it. That is why detection and drawing run at the frame rate and not at the sample rate.
Tweaks
Keep a list of recent values, and you could draw every sample or smooth the signal. Handle a bad line deliberately: the catch block here ignores the error silently.

The electrodes
Three electrodes on the skin pick up the heart signal. At this point it is small, noisy and drifting.
No code runs at the electrodes. The Arduino sketch starts at pin A1.
The Ninetales board
I soldered and tested this board. It amplifies and filters the electrode signal, then puts it on header pin A1.
Code for this point: Which pin. The explorer below has it.
Arduino pin A1
analogRead turns the voltage on the pin into a whole number from 0 to 1023, a count.
Code for this point: analogRead. The explorer below has it.
The sampling loop
loop() reads, sends, then waits delay(10). That is about 100 samples a second, nominal. I did not measure the real rate.
Code for this point: delay(10). The explorer below has it.
Serial at 9600 baud
Each reading leaves as text: its digits, then a line break. Both programs have to use 9600 baud.
Code for this point: println, begin 9600, Open the port, serialEvent. The explorer below has it.
The Processing monitor
serialEvent stores the newest number. draw() maps 300 to 600 onto the window height and plots one point per frame.
Code for this point: Trace line, Erase bar, serialEvent. The explorer below has it.
The beat detector
A reading at or above the threshold sets a flag, then the detector re-arms 20 counts below. Gaps from 300 to 2000 ms give the rate.
Code for this point: Beat and rate, Flash, Readout. The explorer below has it.

Source values

Nominal sampling rate from a 10 ms loop delay: about 100 HzNominal: the 10 ms delay plus conversion and serial time. I did not measure the actual rate. Source sketch
Analog input used on the Ninetales board: A1 Source sketch
Serial speed between Arduino and Processing: 9600 baud Source sketch
Beat-detection threshold in the Processing monitor: 450A raw ADC count hard-coded in the source: a fixed threshold with no adaptive detection. Source sketch

The 100 Hz is nominal; I did not measure the real rate. The threshold is a fixed constant, and the heart-rate figure is an estimate from the gap between detected peaks.

No schematic or parts list is published, because none is cleared for release.

ECG board

The signal chain, probe point by probe point

The electrodes

The Ninetales board

Arduino pin A1

The sampling loop

Serial at 9600 baud

The Processing monitor

The beat detector

Source values

Optional analytics