Build A Diy Pulse Oximeter

About the project

In this project, you will learn how to build a working pulse oximeter using an Arduino Nano with the MAX30102 sensor module on a breadboard. This project is a great project to get started with learning how to use a breadboard, making electronic connections, and learning how to use arduino code.

Project info

Difficulty: Easy

Platforms: Arduino

Estimated time: 2 hours

License: GNU General Public License, version 3 or later (GPL3+)

Items used in this project

Hardware components

	Pulse Oximeter Sensor Max30102 https://amzn.to/3Uz8UqL	x 1
	OLED Screen https://amzn.to/4aRACEW	x 1
	Breadboard - Full-Size (Bare) https://amzn.to/4aQfijf	x 1
	100 nF capacitors	x 3
	1 kohm resistors https://amzn.to/49WSNYC	x 4
	LED https://amzn.to/44g8Sau	x 1
	Arduino Nano https://amzn.to/3JxLY53	x 1
	Push Buttons https://amzn.to/3UAsvac	x 3
	USB cable (or 9V for power)	x 1
	Jumper wires https://amzn.to/4dgJ0zf	x 1

View all

Story

SP02 monitors, also known as pulse oximeters, are essential medical devices used to measure blood oxygen saturation levels and pulse rates non-invasively. They utilize a technique called pulse oximetry, which involves emitting light wavelengths through body tissues and detecting the absorption patterns to determine oxygen saturation levels.

SP02 monitors are widely employed in various medical settings, including hospitals, clinics, and home healthcare environments. They are commonly integrated into patient monitoring systems, respiratory therapy devices, and wearable fitness trackers to provide real-time health data.

For this project, we are going to build a pulse oximeter on a breadboard. The connections are pictured below and in the downloadable schematic.

If you need help learning how to use a breadboard, check out this video

Schematics, diagrams and documents

Electrical Schematic

Breadboard Connections

Code

/* DIYSPO2 - v0.4b
   Written by Kevin Williams

   Check out more project healthcare projects at HTM-Workshop.com

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/


/* ==================================================

	WARNING: This program and its algorithms are for EDUCATIONAL PURPOSES ONLY.
	This program should NEVER be used in any medical setting. The values produced
	may be inaccurate or misleading and should not be used for medical diagnoses.

   ================================================== */


/*
	Wiring pinout for Arduino Uno and Nano:
		D2  - Alarm Menu Button
		D3  - Alarm Menu Up Button
		D4  - Alarm Menu Down Button
		D12 - Alarm Output
		A4  - I2C SDA
		A5  - I2C SCL
*/


static const char VERSION[] = "v0.4b";
static const char DATE[] = "NOV/29/2023";

// Compile options
// Uncomment the line below to enable dev mode. This will disable the screen and alarms.
//#define DEV_MODE
#ifndef DEV_MODE
#define SCREEN				// comment out to disable screen
#define ALARM				// comment out to disable alarm
#endif


// Library includes
#include <math.h>
#include <Wire.h>
#include "MAX30105.h"
#include "spo2.h"


// OLED Screen libraries and config.
#ifdef SCREEN
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 
#define SCREEN_HEIGHT 32
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
#endif


// Alarm System. Note, the alarm button will only work when it's attached to pin D2
#ifdef ALARM
#define ALARM_OUT 12
static uint8_t hr_alarm_max = 160;
static uint8_t hr_alarm_min = 40;
static bool menu_active = false;


// This variable will interrupt the SPO2 capture process when set to true.
// Automatically resets back to false after the interrupt is completed.
extern bool interrupt;
#endif


// Developer mode functions. These use a bunch of memory on the AVR chips which may cause the 
// chip to crash if the OLED screen is enabled at the same time.
#ifdef DEV_MODE
#define SERIAL_RATE 115200
#define SERIAL_OUTPUT_BUFFER_SIZE 128
char serial_output_buffer[SERIAL_OUTPUT_BUFFER_SIZE];


// quick and dirty vsnprintf wrapper
void __attribute__((optimize("Os"))) sprint(const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    vsnprintf(serial_output_buffer, SERIAL_OUTPUT_BUFFER_SIZE, fmt, args);
    va_end(args);
    Serial.print(serial_output_buffer);
}

void spo2_show_debug(const spo2_system *spo2) {
	sprint("HR: %03d\n", spo2->current_hr);
	sprint("SPO2: %03d\n", spo2->current_spo2);
	sprint("TIMEMS: %03d\n", spo2->time_ms);
	sprint("CUR R :");
	Serial.println(spo2->current_r);
	sprint("CUR RED:");
	Serial.println(spo2->average_red);
	sprint("RED [\n");
	for(int i = 0; i < BUFFER_SIZE; i++) {
		sprint("%d, ", spo2->buffer_red[i]);
	}
	sprint("\n\n]\n");
	sprint("-------------------------------------\n\n");
}
#endif


#ifdef SCREEN
// Initialize OLED display.
void display_init(void) {
	display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
	display.setTextSize(1);
	display.clearDisplay();
  	display.setTextColor(SSD1306_WHITE);// Draw white text
  	display.setCursor(0,0);             // Start at top-left corner
	display.print(F("DIYSPO2 - "));
	display.println(VERSION);
	display.println(DATE);
	display.println("\nNOT FOR MEDICAL USE");
	display.display();
	display.setTextSize(2);
	delay(3000);
}


// Update the OLED panel to show heartrate and spo2 readings.
void display_update(spo2_system *spo2) {
	if(spo2->average_red > 5000 || spo2->average_red < -5000) {
		display.clearDisplay();
		display.setCursor(0,0);
		display.print("HR:   ");
		if(spo2->current_hr > 10) {
			display.println(spo2->current_hr);
		} else {
			display.println("---");
		}
		display.print("SPO2: ");
		display.println(spo2->current_spo2);
		display.display();
	} else {
		display.clearDisplay();
		display.setCursor(0,0);
		display.println("HR:   ???");
		display.println("SPO2: ???");
		display.display();
	}
}
#endif


// init a new pariticle sensor instance
void max30105_init(MAX30105 *ps) {

    // Detect sensor. If no sensor is detected, flash the onboard LED and halt execution.
    if(!ps->begin(Wire, I2C_SPEED_FAST)) {
#ifdef DEV_MODE
        Serial.println("MAX30105 was not found. Please check wiring/power. ");
#endif
#ifdef SCREEN
		display.clearDisplay();
		display.setTextSize(1);
		display.setCursor(0,0);
		display.print(F("DIYSPO2 - "));
		display.println(VERSION);
		display.println("ERROR:\nMAX30105 not found!");
		display.println("Check wire/power.");
		display.display();
#endif
        while (1) {
			digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
#ifdef ALARM
			digitalWrite(ALARM_OUT, !digitalRead(ALARM_OUT));
#endif
			delay(1000);
		}
    }
    
	// Sensor module config parameters
    byte ledBrightness = 0x1F; 		//Options: 0=Off to 255=50mA
    byte sampleAverage = 4; 		//Options: 1, 2, 4, 8, 16, 32
    byte ledMode = 3; 				//Options: 1 = Red only, 2 = Red + IR, 3 = Red + IR + Green
    int sampleRate = 3200; 			//Options: 50, 100, 200, 400, 800, 1000, 1600, 3200
    int pulseWidth = 411; 			//Options: 69, 118, 215, 411
    int adcRange = 2048; 			//Options: 2048, 4096, 8192, 16384
	
	// Initialize sensor with above parameters
    ps->setup(ledBrightness, sampleAverage, ledMode, sampleRate, pulseWidth, adcRange);
}



#ifdef ALARM
// Display the alarm adjustment menu.
void alarm_display(const bool high_select) {
	display.clearDisplay();
	display.setCursor(0,0);
	if(high_select)
		display.print("*");
	display.print("HI:");
	display.println(hr_alarm_max);
	if(!high_select)
		display.print("*");
	display.print("LO:");
	display.println(hr_alarm_min);
	display.display();
}

// State-machine for the alarm adjustment menu
void alarm_menu() {

	// disable button interrupts
	EICRA &= ~(1 << ISC01);
	EIMSK &= ~(1 << INT0);

	// wait for user to release D2 before continuing
	while(digitalRead(2)) {}
	bool high_select = true;
	bool button_pressed = true;
	while(menu_active) {
		alarm_display(high_select);
		bool get_input = true;
		while(get_input) {
			bool b1 = !digitalRead(2);
			bool b2 = !digitalRead(3);
			bool b3 = !digitalRead(4);
			uint8_t b_state = ((b1 * 0x1) | (b2 * 0x2) | (b3 * 0x4));

			// button decoder
			if(!button_pressed && b_state != 0) {
				button_pressed = true;
				switch(b_state) {

					// Button D2 (menu)
					case(0x1): {
						get_input = false;
						if(high_select) {
							high_select = false;
							digitalWrite(LED_BUILTIN, HIGH);
							break;
						} else {
							menu_active = false;
							break;
						}
					} 

					// Button D3 (up)
					case(0x2): {
						get_input = false;
						if(high_select) {
							hr_alarm_max += 1;
							break;
						} else {
							hr_alarm_min += 1;
							break;
						}
					}

					// Button D4 (down)
					case(0x4): {
						get_input = false;
						if(high_select) {
							hr_alarm_max -= 1;
							break;
						} else {
							hr_alarm_min -= 1;
							break;
						}
					}
					default:
						break;
				}
			} else {
				if(!b_state)
					button_pressed = false;
			}
		}
	}
	digitalWrite(LED_BUILTIN, LOW);

	// wait for user to release D2 before continuing
	while(digitalRead(2)) {}

	// delay to compensate for any button weirdness, otherwise D2 interrupt may instantly re-trigger
	delay(100);				

	// re-enable button interrupt
	EICRA |= (1 << ISC01);
	EIMSK |= (1 << INT0);
}

// On the falling-edge of pin D2, this interrupt triggers.
ISR(INT0_vect) {
	if(!digitalRead(2)) {
		interrupt = true;		// abort any currently running capture
		menu_active = true;		// enable the alarm menu state-machine
	}
}
#endif // ALARM


void setup() {
	pinMode(LED_BUILTIN, 1);
#ifdef DEV_MODE
	Serial.begin(115200);
#endif
#ifdef ALARM
	pinMode(ALARM_OUT, 1);
	cli();						// disable interrupts
	EICRA |= (1 << ISC01);		// enable falling-edge interrupt on pin D2
	EIMSK |= (1 << INT0);		//  "
	sei();						// enable interrupts
#endif
#ifdef SCREEN
	display_init();
#endif
}


void loop() {

	// create sensor module instance
	MAX30105 sensor;
	max30105_init(&sensor);

	// create internal SPO2 system instance
	spo2_system spo2;
	spo2_init(&spo2);
	
	// main loop
	while(1) {

#ifdef ALARM
		if(menu_active)
			alarm_menu();
#endif

#ifdef SCREEN
		display_update(&spo2);
#endif
		// enable built-in LED during capture 
		digitalWrite(LED_BUILTIN, 1);

		// Get an entire new sample period of data. This is a blocking function, so to interrupt or abort it,
		// set the extern variable 'bool interrupt' to true.
		spo2_new_measurement(&sensor, &spo2);

		// disable built-in LED after capture
		digitalWrite(LED_BUILTIN, 0);
		
		// After a full sample period is obtained, analyze the data and update the SPO2 struct 
		spo2_update_all(&spo2);

#ifdef ALARM
		if(spo2.average_red > 4000 && spo2.current_hr > 10) {
			if(spo2.current_hr > hr_alarm_max || spo2.current_hr < hr_alarm_min) {
				digitalWrite(ALARM_OUT, HIGH);
			} else {
				digitalWrite(ALARM_OUT, LOW);
			}
		} else {
			digitalWrite(ALARM_OUT, LOW);
		}
#endif
	}
}

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

Build A Diy Pulse Oximeter

About the project

Project info