Edge-based intelligent and smart health monitoring on PYNQ-Z2 using lightweight protocol and integration of machine learning models

This subsystem gathers multiple medical parameters such as HR, body temperature, SpO₂, and vital signs using sensors. Analog data from the sensors are processed and converted to a digital format for storage and transmission. Table 2 presents and summarizes the dataset for the proposed system.

• (1)

  HR and blood oxygen monitoring: The MAX30100 sensor measures HR and SpO₂ levels through optical reflection. It uses the I2C communication protocol via SDA and SCL pins to interface with the ESP32 microcontroller.

• (2)

  Body temperature measurement: The DS18B20 sensor measures body temperature using methods such as oral, axillary, or tympanic. It communicates with the ESP32 via the SPI protocol for configuration and data transfer.

The ESP32 microcontroller is used for data acquisition, processing, and transmission. It supports low-power operations and is programmable using Arduino IDE or Micro-Python. Equipped with multiple communication interfaces (I2C, SPI, and UART), it processes sensor data and performs initial analysis to detect abnormalities.

The communication subsystem is designed for fast, low-cost, and reliable data transfer. The ESP32 handles data transmission using the MQTT protocol, while the RPI serves as the MQTT broker for data storage and management.

• (1)

  ESP32 with MQTT: The ESP32 connects to a Wi-Fi network and acts as an MQTT client to publish sensor data to specific topics (e.g., esp32/pulse, esp32/temperature, and esp32/SpO₂). The MQTT broker, running on RPI, receives and manages these messages.

• (2)

  RPI as MQTT broker: The RPI, running Raspbian OS, hosts the MQTT broker (Mosquitto) to facilitate data exchange between devices. It stores patient data, provides historical information, and acts as a web server for remote monitoring. The MQTT protocol ensures reliable message delivery and supports thousands of clients, making it ideal for scalable healthcare applications.

The system’s MQTT architecture employs a publish/subscribe model for efficient data exchange. Users can access the monitoring system remotely by entering the server’s IP address. Based on login credentials, the system provides specific functionalities for administrators, doctors, and patients. For instance, doctors can monitor patient health, search records, and manage patient lists via a dedicated web interface.

The system employs various ML classifiers, including KNN, SVM, and DT. A brief overview of these classifiers is presented below [41]:

• (1)

  KNN algorithm: KNN [38] is a nonparametric supervised learning algorithm that classifies new data points based on their similarity to the K-nearest training data points. The algorithm calculates the distance between the new data point and all training data points and assigns the majority class label among the KNN.

  Mathematical representation
  • (a)

    Let k be the number of neighbors considered for classification.

  • (b)

    D (x_i, x_j): A distance function between data points x_i and x_j.

  • (c)

    For a new instance x, the algorithm identifies its KNN and assigns it the majority class label.

• (2)

  SVM algorithm: SVM [39] constructs a hyperplane to separate data points into distinct classes. The algorithm seeks the hyperplane that maximizes the margin, defined as the distance between the hyperplane and the nearest data points from either class. A linear kernel is used in this system to simplify computation.

  Mathematical representation
  • (a)

    Let X represent the training data points and Y the class labels.

  • (b)

    The hyperplane is defined as w · x + b = 0, where w is the weight vector and b the bias.

  • (c)

    The SVM maximizes the margin while ensuring data points on the same side of the hyperplane are in the same class.

• (3)

  DT algorithm: The DT [40] algorithm uses a tree-like structure to classify data points. Each internal node represents a feature, branches denote decisions based on feature values, and leaf nodes represent the final class labels. The tree is constructed by recursively splitting the data based on the most significant feature.

  Mathematical representation
  • (a)

    Let X be the training data points and Y the class labels.

  • (b)

    At each node, split X into subsets X_l and X_r based on a feature f and threshold θ:

    • X_l = {x ∈ X | x[f] < θ}

    • X_r = {x ∈ X | x[f] ≥ θ}

  • (c)

    Recursively, the trees are built until each leaf node contains data points of the same class.

The health monitoring system employs the following key steps for ML-based prediction:

• (1)

  Data collection and preparation: Data were collected from the proposed hardware system, which measured various health parameters. This dataset, comprising more than 900 complete patient records, was used to train and validate the model. Data collection timing varied, ensuring a diverse range of samples. Key criteria for data selection included:

  • Inclusion of critical health parameters such as HR, SpO₂, and temperature.

  • Consistent formatting and completeness of data records.

• (2)

  Feature extraction and classification: The collected data were processed to extract relevant features for classification. These features included:

  • Vital signs (HR, SpO₂, and body temperature)

  • Demographic information (gender and age)

  The extracted features were fed into the ML classifiers (KNN, SVM, and DT) to train the prediction model. Once trained, the system classified patient health status and identified potential abnormalities.

• (3)

  Evaluation metrics: To evaluate the reliability of the ML algorithms trained on the dataset, we used four key metrics: accuracy, precision, recall, and the F1 score. These metrics [42] provide a comprehensive view of the predictive model’s performance in identifying safe or unsafe healthcare data based on various analytical techniques. The models were both trained and tested on the collected dataset.

  • Accuracy

    Accuracy measures the proportion of correct predictions made by the model relative to the total number of predictions. It is calculated using the formula: Accuracy=Number of Correct PredictionsTotal Number of Predictions {\rm{Accuracy}} = {{{\rm{Number}}\;{\rm{of}}\;{\rm{Correct}}\;{\rm{Predictions}}} \over {{\rm{Total}}\;{\rm{Number}}\;{\rm{of}}\;{\rm{Predictions}}}}

    The accuracy score is determined by comparing the true labels (actual values of data points) with the predicted labels (values predicted by the model). High accuracy indicates that the model is effective across the dataset.

  • Precision

    Precision evaluates the model’s ability to correctly identify positive predictions. It is calculated as the ratio of true positives to the total number of positive predictions (true positives + false positives): Precision=TimePositiveTrue Positive+False Positive {\rm{Precision}} = {{{\rm{TimePositive}}} \over {{\rm{True}}\;{\rm{Positive }} + {\rm{False}}\;{\rm{Positive}}}}

    A high precision value indicates that the model minimizes false positives and is effective in identifying positive cases.

  • F1 Score

    The F1 score provides a balanced measure of a model’s precision and recall by calculating their harmonic mean. It is particularly useful when there is an imbalance between classes in the dataset. The F1 score is given by: F1=2⋅Precision⋅RecallPrecision⋅Recall {\rm{F}}1 = 2 \cdot {{{\rm{Precision}} \cdot {\rm{Recall}}} \over {{\rm{Precision}} + {\rm{Recall}}}}

    The F1 score ranges from 0 to 1, with a higher value indicating better performance.

  • Recall

    It measures the proportion of true positive predictions out of all actual positive instances. High recall indicates few false negatives. Recall=True PositivesTrue Positives+False Negatives {\rm{Recall}} = {{{\rm{True}}\;{\rm{Positives}}} \over {{\rm{True}}\;{\rm{Positives}} + {\rm{False}}\;{\rm{Negatives}}}}

  • Evaluation approach

    Using the selected combination of features for this study, we assessed the predictive performance of the ML models. Three ML models are evaluated and compared based on the defined metrics. A comparative analysis was conducted to identify the model that best fits each data column for prediction.

• Import dataset: Load the dataset into the system.

• Preprocess data: Clean the dataset by removing null values.

• Optimize data: Transform data columns into a 1D array for classification. Convert string datatypes into integer values using NumPy for compatibility.

• Select kernel: Choose a kernel for the classification algorithm (e.g., linear kernel for SVM).

• Classification: Apply three different classifiers (KNN, SVM, and DT) to classify columns, such as HR, SpO₂, and temperature. Measure the model’s precision and accuracy.

• Train model: Train the classifiers using the dataset.

• Test system: Test the trained system by predicting cardiac conditions for input test data. Repeat the process for other classifiers.

• Comparison: Graphically compare precision, recall, F1 score, and accuracy across classifiers.

By analyzing HR, body temperature, and SpO₂ levels, this system provides personalized care for chronic conditions. It leverages IoT and cloud technologies for continuous monitoring, with data being processed and analyzed by three classifiers. Comparative analysis identifies the most effective classifier, and the data are sent directly to the medical cloud server.

• A. Power ON the system

• B. Initialize the ESP32 microcontroller

• C. Set up the MQTT protocol

• D. Select the health parameter to measure

  • –

    Press push-button 1 to measure HR and SpO₂

  • –

    Press push-button 2 to measure body temperature

• E. Display the measured parameters on the LCD screen

• F. Evaluate the data

  • –

    If within threshold values, a green LED blinks

  • –

    If outside threshold values, a red LED blinks, and a buzzer sounds

• G. Data upload

  • –

    If internet connectivity is available, upload measured data to the cloud server for access by remote doctors.

  • –

    In emergencies, doctors receive an immediate email notification.

• H. Offline operation:

  • –

    If the internet is unavailable, the system uses its ML model to predict the patient’s condition based on measured data and personal details like age and gender.

  • –

    Predicted results are stored in the cloud for later access.

The design and implementation of the proposed architecture are described in this section. Figures 2A–2D illustrate the hardware implementation of the health monitoring system. The system displays temperature readings on the LCD every 3 s, while HR and SpO₂ values are updated every 15 s.

Figure 2:

Hardware implementation of the proposed MQTT and ML-based smart health monitoring system (A) SPO₂-HR monitoring (B) body temperature monitoring (C, D) overall experimental set up. ML, machine learning; MQTT, message queuing telemetry transport.

Data can be optionally sent to the ThingSpeak cloud [43]. Table 3 presents vital health parameters as displayed on the LCD and ThingSpeak cloud server during different sessions. The ThingSpeak channel also provides a graphical visualization of the sensor data, making it accessible to doctors and physicians through external webpages. In case of abnormal health parameters, the system alerts the patient via a buzzer and LED. When internet connectivity is available, vital signs such as HR, SpO₂, and body temperature are immediately uploaded to the ThingSpeak cloud server [43].

Figures 3A–3C demonstrate the uploaded data for a single patient and show the graphical representations of vital parameters such as SpO₂ (%), HR (bpm), and temperature (°F) over time for a patient, respectively. Table 3 displays vital health parameters data, both for local visualization and cloud-based monitoring.

Figure 3:

Graphs showing monitoring (A) SpO₂, (B) HR, and (C) body temperature of a patient. HR, heart rate; SpO₂, blood oxygen saturation.

The performance analysis of three ML classifiers—KNN, DT, and SVM—is carried out by evaluating metrics such as accuracy, precision, recall, and F1-score. Results are summarized in Tables 4 and 5.

KNN demonstrates superior performance across all metrics, particularly in accuracy, precision, recall, and F1-score. By contrast, DT and SVM exhibit lower performance, especially for HR and SpO₂. Figures 4–7 illustrate the graphical comparisons of accuracy, precision, F1-score, and recall among the classifiers.

Figure 4:

Graphical representation of accuracy for three different classifiers. DT, decision tree; SVM, support vector machine.

Figure 5:

Graphical representation of precision for three different classifiers. DT, decision tree; SVM, support vector machine.

Figure 6:

Graphical representation of F1 scores for three different classifiers. DT, decision tree; KNN, K-nearest neighbors.

Figure 7:

Graphical representation of recall for three different classifiers. DT, decision tree; SVM, support vector machine.

PYNQ (Python Productivity for ZYNQ) combines programmable logic (PL) and programmable system (PS) within the Xilinx ZYNQ FPGA system-on-chip (SoC) [44, 45]. The integration of Python and programing libraries simplifies FPGA-based embedded system development. Figure 8 shows the PYNQ Z2 FPGA board [44]. Using the Vivado Design Suite, we created and connected an AXI Stream interface IP to the PS part of the FPGA block design.

Figure 8:

PYNQ Z2 FPGA board.

The ML model, developed in Python, is deployed on PYNQ via Jupyter Notebook. The KNN hardware accelerator overlay design, illustrated in Figure 9, enhances the classifier’s performance by leveraging PL as a hardware accelerator [45, 46]. Figure 10 outlines the joint simulation system that links Python programs to FPGA hardware through an AXI interface. Figure 11 FPGA presents overall experimental set up for FPGA-based implementation.

Figure 9:

KNN accelerator data path diagram. KNN, K-nearest neighbors; PL, programmable logic; PS, programmable system.

Figure 10:

Joint simulation system. PL, programmable logic; PS, programmable system.

Figure 11:

Presents the experimental setup for the FPGA-based implementation.

Implementation results for KNN and SVM classifiers are shown in Table 6. Table 6 summarizes the hardware implementation results of KNN and SVM classifiers, detailing parameters such as accuracy, clock frequency, resource utilization, and power consumption. Among the classifiers, KNN is more efficient, occupying fewer hardware resources and consuming less power (0.228 W).

It achieves an overall classification accuracy of 85.55%, with faster processing times compared to SVM. The results demonstrate that deploying KNN on PYNQ Z2 FPGA accelerates the classification process while maintaining high accuracy and efficient resource utilization.

The experimental results clearly indicate that the KNN classifier outperforms SVM in terms of both classification accuracy (85.55% vs 62.22%) and hardware efficiency on the PYNQ-Z2 FPGA platform. This superior performance is primarily due to KNN’s simple, instance-based learning approach, which avoids complex training phases and extensive parameter tuning, making it particularly effective for the small and structured dataset used in this work. Additionally, KNN’s straightforward distance computation and voting mechanism map efficiently onto FPGA resources such as look-up tables (LUTs) and flip-flops, resulting in reduced hardware complexity and a higher operating frequency (100.07 MHz for KNN vs 32.28 MHz for SVM). The integration of lightweight communication protocols further complements KNN’s predictable and low-latency operations, leading to lower power consumption (0.228 W compared to 0.414 W for SVM) and higher throughput, which are crucial for real-time edge applications. Moreover, the sensor data features used for health monitoring are well-separated and linearly distinguishable, favoring distance-based methods like KNN. SVM’s performance may degrade in such scenarios unless a carefully selected kernel is employed, which was avoided to minimize hardware overhead.

We used a comparative analysis using tabular format that places our proposed PYNQ-Z2 FPGA implementations of KNN and SVM classifiers side by side with previous FPGA-based works, highlighting classification accuracy, power consumption, frequency, cost, and resource usage shown in Table 7.

Although the proposed KNN-based health monitoring system on the PYNQ-Z2 platform demonstrates superior classification accuracy and efficient hardware utilization, but there are several limitations affect its real-time performance. First, KNN is a lazy learner, meaning that during inference, the algorithm requires real-time computation of distances between the incoming data and all stored instances. As the dataset size grows, this can lead to increased latency and reduced throughput, particularly in continuous monitoring scenarios. Second, while FPGA resources, such as LUTs and BRAM, are utilized efficiently, the limited on-chip memory of PYNQ-Z2 restricts the ability to handle larger feature sets or high-frequency sensor data streams without external memory support. Additionally, the implemented lightweight protocols, while power-efficient, may introduce network latency when transmitting large volumes of sensor data for real-time analysis. Finally, the model lacks adaptive learning capabilities; any update to the dataset requires reloading or reconfiguring the stored instances, which could hinder dynamic performance in real-world deployments.

The proposed framework can be further enhanced by integrating wearable and IoT-enabled health devices to enable continuous real-time monitoring and personalized healthcare services. Incorporating advanced ML paradigms, including deep learning technique and ensemble-based hybrid ML models, will significantly improve predictive accuracy and adaptability to diverse health conditions. Moreover, hardware-aware optimizations, such as model pruning, quantization, and compression techniques, can minimize latency and power consumption for edge deployments. Memory optimization using external DDR memory or advanced memory management techniques to handle high-frequency sensor streams and large feature sets Finally, secure cloud-edge collaboration and privacy-preserving methods, such as federated learning or blockchain-based data sharing, can be explored to achieve scalable, reliable, and privacy-centric healthcare solutions.