Code Explanation
Libraries and Configuration
Objects and Variables
Functions
setup_wifi(
reconnect(
onBeatDetected(
setup(
loop(
Working Demonstration

Published November 12, 2024

Health Monitoring System using Arduino UNO R4 WiFi and IoT

This project facilitates real-time remote monitoring of critical health metrics such as heart rate, SpO2, body temperature, and ECG data,

IntermediateFull instructions provided5 hours646

Health Monitoring System using Arduino UNO R4 WiFi and IoT

Things used in this project

Hardware components

Arduino UNO R4 WiFi

SparkFun Single Lead Heart Rate Monitor - AD8232

Maxim Integrated MAX30102 High-Sensitivity Pulse Oximeter and Heart-Rate Sensor for Wearable Health

M5Stack NCIR Unit Contactless Temperature Sensor Module (MLX90614)

Software apps and online services

Arduino IDE

Ubidots

Story

I used Fritzing to create the circuit diagram. For power input, I am using a 2S Li-ion battery pack, which provides an average voltage of 7.4V. This is connected to the Vin pin of the Arduino UNO Board.How It All Comes Together:

Data Collection:

The ECG sensor (AD8232) continuously monitors the heart’s electrical activity, detecting anomalies.
The MLX90614 temperature sensor tracks body temperature, alerting to potential fever or temperature changes.
The MAX30102 pulse oximeter measures both blood oxygen levels and heart rate, providing insights into respiratory and cardiovascular health.
Data Collection:The ECG sensor (AD8232) continuously monitors the heart’s electrical activity, detecting anomalies.The MLX90614 temperature sensor tracks body temperature, alerting to potential fever or temperature changes.The MAX30102 pulse oximeter measures both blood oxygen levels and heart rate, providing insights into respiratory and cardiovascular health.

Data Processing:

The Arduino Uno R4 WiFi collects data from all the sensors.
It processes this data to generate meaningful health metrics. For example, it can calculate heart rate variability from ECG signals or determine average SpO2 levels from multiple readings.
Data Processing:The Arduino Uno R4 WiFi collects data from all the sensors.It processes this data to generate meaningful health metrics. For example, it can calculate heart rate variability from ECG signals or determine average SpO2 levels from multiple readings.

Real-Time Monitoring and Alerts:

The Arduino sends the processed data to the Blink app via its WiFi capabilities.
The Blink app provides real-time monitoring of health metrics, enabling remote observation.
If any health parameters fall outside of predefined thresholds (e.g., abnormally high heart rate or low SpO2), the system can trigger alerts to both the patient and healthcare providers.
Real-Time Monitoring and Alerts:The Arduino sends the processed data to the Blink app via its WiFi capabilities.The Blink app provides real-time monitoring of health metrics, enabling remote observation.If any health parameters fall outside of predefined thresholds (e.g., abnormally high heart rate or low SpO2), the system can trigger alerts to both the patient and healthcare providers.

Remote Access and Management:

The Blink app enables users to view their health data remotely, reducing the need for frequent in-person visits to healthcare facilities.
Healthcare providers can access the data to make informed decisions and intervene when necessary, improving patient outcomes through proactive care.
Remote Access and Management:The Blink app enables users to view their health data remotely, reducing the need for frequent in-person visits to healthcare facilities.Healthcare providers can access the data to make informed decisions and intervene when necessary, improving patient outcomes through proactive care.

Adaptability and Scalability:

The modular design allows for easy upgrades and integration of additional sensors or features as technology advances.
This adaptability ensures the system can be customized for different healthcare needs and patient profiles.
Adaptability and Scalability:The modular design allows for easy upgrades and integration of additional sensors or features as technology advances.This adaptability ensures the system can be customized for different healthcare needs and patient profiles.

Above, you can see the assembled image of the components. With the connections completed, let's move on to coding the Arduino board.

Code Explanation

This code is designed for an Arduino UNO R4 WiFi microcontroller to collect physiological data (heart rate, SpO2, body temperature, and ECG) using multiple sensors, then send that data to Ubidots, an IoT platform, via Wi-Fi using MQTT (Message Queuing Telemetry Transport). Here’s a breakdown:

Libraries and Configuration

Libraries:

Wire: For I2C communication (used by some sensors).
MAX30100_PulseOximeter: To communicate with the MAX30100 pulse oximeter sensor.
Adafruit_MLX90614: To interact with the MLX90614 temperature sensor.
WiFiS3: To handle Wi-Fi communication.
PubSubClient: To send data to the Ubidots MQTT broker.
Libraries:Wire: For I2C communication (used by some sensors).MAX30100_PulseOximeter: To communicate with the MAX30100 pulse oximeter sensor.Adafruit_MLX90614: To interact with the MLX90614 temperature sensor.WiFiS3: To handle Wi-Fi communication.PubSubClient: To send data to the Ubidots MQTT broker.

Constants:

WIFISSID, PASSWORD: Credentials for Wi-Fi connection.
TOKEN: Ubidots API token for authorization.
DEVICE_LABEL and VARIABLE_LABEL_*: Labels used in Ubidots to identify this device and its data variables.
MQTT_CLIENT_NAME: Unique name for the MQTT client.
ECG_PIN: Analog pin where the ECG sensor (AD8232) is connected.
REPORTING_PERIOD_MS: Interval (1000 ms) between each data upload to Ubidots.
Constants:WIFISSID, PASSWORD: Credentials for Wi-Fi connection.TOKEN: Ubidots API token for authorization.DEVICE_LABEL and VARIABLE_LABEL_*: Labels used in Ubidots to identify this device and its data variables.MQTT_CLIENT_NAME: Unique name for the MQTT client.ECG_PIN: Analog pin where the ECG sensor (AD8232) is connected.REPORTING_PERIOD_MS: Interval (1000 ms) between each data upload to Ubidots.

Objects and Variables

Sensor Objects:

PulseOximeter pox: Interface object for the MAX30100.
Adafruit_MLX90614 mlx: Interface object for the MLX90614.
Sensor Objects:PulseOximeter pox: Interface object for the MAX30100.Adafruit_MLX90614 mlx: Interface object for the MLX90614.

WiFi and MQTT Objects:

WiFiClient espClient: Used for Wi-Fi communication.
PubSubClient client: Used for MQTT communication with Ubidots.
WiFi and MQTT Objects:WiFiClient espClient: Used for Wi-Fi communication.PubSubClient client: Used for MQTT communication with Ubidots.

Data Buffers:

topic and payload: Used to store MQTT topic and JSON payload data.
Data Buffers:topic and payload: Used to store MQTT topic and JSON payload data.

Functions

setup_wifi()

This function connects the ESP32 to Wi-Fi.

Prints Wi-Fi status in the Serial Monitor.
Checks the connection status every second, printing dots (".") until successfully connected.
Once connected, it displays the IP address.

reconnect()

This function reconnects to the MQTT broker if disconnected.

Attempts to connect with client.connect() using MQTT_CLIENT_NAME and TOKEN for authentication.
If the connection fails, it waits 2 seconds before retrying.

onBeatDetected()

Callback function executed each time a heartbeat is detected by the MAX30100, printing "Beat Detected!" to the Serial Monitor.

setup()

This is the main setup function for the program.

Serial Communication: Starts Serial for data output to the monitor.
Wi-Fi Setup: Calls setup_wifi() to establish Wi-Fi connection.
MQTT Setup: Configures Ubidots as the MQTT server at industrial.api.ubidots.com on port 1883.

Sensor Initialization:

Initializes the MAX30100 pulse oximeter and sets the IR LED current.
Initializes the MLX90614 temperature sensor.
Sets the ECG pin (A0) as an input.
Sensor Initialization:Initializes the MAX30100 pulse oximeter and sets the IR LED current.Initializes the MLX90614 temperature sensor.Sets the ECG pin (A0) as an input.

loop()

This function contains the main code loop, running continuously.

MQTT Reconnection: Calls reconnect() if the MQTT client is disconnected.
MAX30100 Update: Reads and processes data from the MAX30100 for heart rate and SpO2.
ECG Reading: Reads the analog ECG signal from the AD8232 connected to A0.

Data Reporting:

Every 1000 ms, retrieves sensor data:

Heart Rate and SpO2: Reads heart rate and SpO2 values from the MAX30100.
Temperature: Reads ambient and object temperatures from the MLX90614.
ECG Value: Analog reading from ECG sensor.
Every 1000 ms, retrieves sensor data:Heart Rate and SpO2: Reads heart rate and SpO2 values from the MAX30100.Temperature: Reads ambient and object temperatures from the MLX90614.ECG Value: Analog reading from ECG sensor.
Prints all values to the Serial Monitor.
Data Reporting:Every 1000 ms, retrieves sensor data:Heart Rate and SpO2: Reads heart rate and SpO2 values from the MAX30100.Temperature: Reads ambient and object temperatures from the MLX90614.ECG Value: Analog reading from ECG sensor.Prints all values to the Serial Monitor.

Payload Creation and Publishing:

Constructs a JSON payload with the sensor data.
Publishes the data to Ubidots via MQTT.
Payload Creation and Publishing:Constructs a JSON payload with the sensor data.Publishes the data to Ubidots via MQTT.
Timestamp Update: Updates the tsLastReport timestamp to control the reporting interval.

This setup continuously gathers sensor data and uploads it to Ubidots for real-time monitoring.Next, let's upload the code and see how it works.

Working Demonstration

After uploading the code to the Arduino UNO R4 WiFi board, I turned on the hotspot and waited for the system to connect to the network. After some time, it connected successfully and began updating the fields in the Ubidots Cloud dashboard.

Code

Untitled file

#include <Wire.h>
#include "MAX30100_PulseOximeter.h"
#include <Adafruit_MLX90614.h>
#include <WiFiS3.h>
#include <PubSubClient.h>
// WiFi and Ubidots configuration
#define WIFISSID "Wi-Fi SSID"                  // Your Wi-Fi SSID
#define PASSWORD " Wi-Fi password"              // Your Wi-Fi password
#define TOKEN " Ubidots TOKEN" // Your Ubidots TOKEN
#define DEVICE_LABEL "esp132"             // Your device label for Ubidots
#define VARIABLE_LABEL_HR "heartrate"      // Variable label for heart rate
#define VARIABLE_LABEL_SPO2 "spo2"         // Variable label for SpO2
#define VARIABLE_LABEL_TEMP "temperature"   // Variable label for temperature
#define VARIABLE_LABEL_ECG "ecgvalue"      // Variable label for ECG value
#define MQTT_CLIENT_NAME "ESP32_MLX_MAX30100" // MQTT client name
#define ECG_PIN A0                         // Define the pin for ECG sensor (AD8232 connected to A0)
#define REPORTING_PERIOD_MS 1000           // Data reporting period (1 second)
// Sensor objects
PulseOximeter pox;                      // Pulse Oximeter object for MAX30100
Adafruit_MLX90614 mlx = Adafruit_MLX90614(); // MLX90614 temperature sensor
uint32_t tsLastReport = 0;              // Time for the last data report
// WiFi and MQTT clients
WiFiClient espClient;
PubSubClient client(espClient);
// Buffers for MQTT topic and payload
char topic[150];
char payload[700];
// Function to connect to Wi-Fi
void setup_wifi() {
   delay(10);
   Serial.println();
   Serial.print("Connecting to ");
   Serial.println(WIFISSID);
   WiFi.begin(WIFISSID, PASSWORD);
   while (WiFi.status() != WL_CONNECTED) {
       delay(1000);
       Serial.print(".");
   }
   Serial.println();
   Serial.println("WiFi connected");
   Serial.println("IP address: ");
   Serial.println(WiFi.localIP());
}
// Function to reconnect to MQTT broker
void reconnect() {
   while (!client.connected()) {
       Serial.print("Attempting MQTT connection...");
       if (client.connect(MQTT_CLIENT_NAME, TOKEN, "")) {
           Serial.println("connected");
       } else {
           Serial.print("failed, rc=");
           Serial.print(client.state());
           Serial.println(" try again in 2 seconds");
           delay(2000);
       }
   }
}
// Callback routine executed when a pulse is detected
void onBeatDetected() {
   Serial.println("Beat Detected!");
}
void setup() {
   Serial.begin(115200);  // Begin Serial communication
   setup_wifi();           // Connect to Wi-Fi
   client.setServer("industrial.api.ubidots.com", 1883);
   // Initialize the MAX30100 Pulse Oximeter
   Serial.print("Initializing MAX30100 Pulse Oximeter...");
   if (!pox.begin()) {
       Serial.println("FAILED");
       for (;;);  // Stuck here if initialization fails
   } else {
       Serial.println("SUCCESS");
   }
   // Set the IR LED current for the MAX30100
   pox.setIRLedCurrent(MAX30100_LED_CURR_7_6MA);
   pox.setOnBeatDetectedCallback(onBeatDetected);
   // Initialize the MLX90614 temperature sensor
   Serial.print("Initializing MLX90614 Temperature Sensor...");
   if (!mlx.begin()) {
       Serial.println("FAILED");
       for (;;);  // Stuck here if initialization fails
   } else {
       Serial.println("SUCCESS");
   }
   // Initialize ECG pin as input
   pinMode(ECG_PIN, INPUT);
   Serial.println("ECG Sensor Initialized...");
}
void loop() {
   if (!client.connected()) {
       reconnect();
   }
   // Update the MAX30100 sensor readings
   pox.update();
   // Read ECG analog signal from the AD8232
   int ecgValue = analogRead(ECG_PIN);
   // Send data to Ubidots every REPORTING_PERIOD_MS
   if (millis() - tsLastReport > REPORTING_PERIOD_MS) {
       // Get heart rate and SpO2
       float heartRate = pox.getHeartRate();
       float spo2 = pox.getSpO2();
       // Read the ambient and object temperature from MLX90614
       float ambientTemp = mlx.readAmbientTempC();
       float objectTemp = mlx.readObjectTempC();
       // Print values to Serial Monitor
       Serial.print("Heart rate: ");
       Serial.print(heartRate);
       Serial.print(" bpm / SpO2: ");
       Serial.print(spo2);
       Serial.println(" %");
       Serial.print("Ambient Temperature: ");
       Serial.print(ambientTemp);
       Serial.println(" °C");
       Serial.print("Object Temperature: ");
       Serial.print(objectTemp);
       Serial.println(" °C");
       Serial.print("ECG Value: ");
       Serial.println(ecgValue);
       // Create topic and payload
       sprintf(topic, "/v1.6/devices/%s", DEVICE_LABEL);
       sprintf(payload, "{"%s": {"value": %.2f}, "%s": {"value": %.2f}, "%s": {"value": %.2f}, "%s": {"value": %d}}",
               VARIABLE_LABEL_HR, heartRate, VARIABLE_LABEL_SPO2, spo2, VARIABLE_LABEL_TEMP, objectTemp, VARIABLE_LABEL_ECG, ecgValue);
       // Publish data to Ubidots
       client.publish(topic, payload);
       client.loop();  // Handle MQTT client
       // Update last report time
       tsLastReport = millis();
   }
}