Team INGE-CONNECTES (ENGINEERS OF THINGS): Benjamin Cadot, François SAILLARD, Redouane Amour, Chadi Amour, Paul Faure, Andreas Kraft, SeungMyeong Jeong, Bob Flynn, Miguel Angel Reina Ortega, Laurent Velez, Samir Medjiah, Xavier Piednoir, Wonbae Son, 안일엽, monteil

Published November 17, 2021

Wearable wristband for the monitoring of elderly healthcare

Healthcare for elder people is an important concern. We want to create a wristband to monitor from distance the health conditions of elders.

IntermediateFull instructions provided1,418

Wearable wristband for the monitoring of elderly healthcare

Things used in this project

Hardware components

NodeMCU ESP8266 Breakout Board

Raspberry Pi 3 Model B

DFRobot 6 DOF Sensor - MPU6050

Replacement watch strap

Battery, 3.7 V

Software apps and online services

Arduino IDE

Raspberry Pi Raspbian

Microsoft Visual Studio 2015

oneM2M

Hand tools and fabrication machines

Soldering iron (generic)

Story

Today, the healthcare for elder people is at stake. Nursing homes and retiring homes are not necessarily affordable for everyone and as the aged population grows, the lack of available rooms has become a major issue. Moreover, most elders would like to keep living independently at home. Our idea is to offer them the opportunity to choose between staying at home or leaving. To achieve that, we made a wireless wearable wristband measuring the essential physical conditions (temperature, acceleration) thanks to multiple sensors integrated on the ESP8266 board. The data is sent from the ESP8266 to the gateway through Wifi. The gateway transmits it to a web application displaying in real-time the measurements and the alerts. The main purpose is to monitor from distance patient's health condition in case of emergencies (high fevers, heavy falls). It also can be deployed for several people in a retirement home and used to alert nurses if needed. To demonstrate this, we will develop ESP prototype self-powered by a battery, including a temperature sensor and an accelerometer, a RaspberryPi as a gateway and a computer as a server. The relevant data will be accessible via a web application.

Detailed technical description of our solution

Project's architecture :

1 / 2

Wristband mounting :

Hardware and software components used

The accelorometer and the temperature sensors are integrated on a MPU-6050 chip with a 16 Bit AD Sensor Module Data Converter mounted on the GY-521 board. This board is linked with the ESP8266 board by a serial I²C bus.
The ESP8266 board is powered by a Lipo battery, 3.7V-650mAh for a long life autonomy. The ESP8266 board is composed of analog and digital pins to read the values of the sensors. It also includes a Wi-Fi module that is connected to the Raspberry Gateway wirelessly.
Use of Arduino C/C++ IDE to program the ESP8266 readings and Wi-Fi communication.
Use of Linux environment to download the Middle Node CSE resources on the Raspberry Pi (gateway) and configure the settings to enable the communication. Use of Java to start the Middle Node CSE exe file. To make it easier for raspberry configuration, you also need an HDMI wire, a mouse, a keyboard and a power supply wire and plug all of them onto the raspberry.
Use of Java to run the Infrastructure Node CSE on the server.
Use of Node JS for the back-end development of the web server handling subscription/notifications processes with the IN-CSE.
Use of Node JS/Webpack for the frontend web application.

User guide

Let's keep in mind we have 4 main parts :

1. The Infrastructure Node

2. The Middle Node

3. The Web application

4. The Sensors

We will go over those 4 parts to explain how it works.

----------------------------------------------INSTALLATION---------------------------------------------

Please make sure to install these four parts in the same way described below

1. The Infrastructure Node contains 2 main softwares :

the IN-CSE platform (eclipse project OM2M) : Download the one we added in the attachments.
a backend server : this Node JS backend server handles notifications and subcriptions processes as well as the login/logout part for the web application. To install it and run it, you need to follow the instructions of the README file of the repository (see link of the repository in attachments).

2. The Middle Node : Take your raspberry pi 3 and download the oneM2M eclipse mn-cse resources we added in the attachments because we already created the AE, CTs and ACPIs required for the whole project. To install it and run it, you need to follow the instructions of the README file of the repository (see link of the repository in attachments).

At this point the raspberry pi should be powered and connected to the Wi-Fi network, the mn-cse should be running on the raspberry pi and the in-cse should be running on another machine.

Note : To make it easier, we highly recommend to install the Infrastructure Node and the Web Application (the web application will be installed in section 3) on the same machine, but it is up to your decision to separate them.

3. The Web Application : It is a frontend program to display the health data of the patients. This application communicates with the Infrastructure Node to get all the patients' data. You will need to run this web application on the Google Chrome navigator before going further. To install it and run it, you need to follow the instructions of the README file of the repository (see link of the repository in attachments). The app should be very easy to use. Once you followed all the instructions of the README file, the first app page you should see is a login page, the login account is "admin" and the password is "admin". In fact we created a "admin" user and a "test" user. The admin has access to every data and patients' health conditions whereas the "test" user has only access to its dedicated patient. On this login page, once you click on "submit" button, you should see monitoring board that will display all the data for each patient, once you run the sensors part of course. In fact, this board will be first empty until you power on the sensors (see part 4 below)

The final step deals with the sensors communication. Before going any further you must have completed the previous steps to enable the reception of the data.

4. The Sensors : This is the MPU60_50 board with integrated sensors :

You must connect the VCC, GND, SCL, and SDA pins to the ESP8266. The SDA and SCL pins of the MPU6050 board should be connected to the digital pins of the ESP8266 :

Plug the ESP8266 to your computer with the USB cable. Download the Arduino IDE as well as the program in attachments and open it. Download the following libraries : <Adafruit_MPU6050.h> ; <Adafruit_Sensor.h> ; <ESP8266WiFi.h> ; <ESP8266HTTPClient.h>. Go to the "tools" bar and select the Node MCU board ESP8266. Go back to the "tools" bar, modify the "upload speed at 115200" which is the baudrate for the serial communication, and also select the port number "COM" :

Go to the very beginning of the code file and enter the IP address of the raspberry pi (MN Node) as well as the port number of the mn-cse running on the raspberry. Enter the same Wi-Fi network name and the password associated. Note that the ESP8266 and the Raspberry Pi 3 must be connected to the same Wi-Fi Network :

Run the program. (It might take some time before running). To make sure the program works, open the Arduino monitor, you should observe the connection of the ESP8266 to the Wi-Fi as well as the previous set up of the sensors :

Then you should see the HTTP POST request of the temperature and acceleration, with the code "201". If the code displayed is not "201" (404 for example), that means the program works but the reception of the data is not working. To repair it, you must check on your mn-cse or in-cse (make sure they are running) :

Once you have managed to display the data of the sensors both on the in-cse (OM2M platform) and the Web Application, you can now unplug the ESP8266 of your computer and connect the Lipo battery to the VCC and GND pins.

WARNING ! : BE CAREFUL NOT TO PLUG THE ESP8266 TO BOTH COMPUTER AND BATTERY AT THE SAME TIME. ALSO BE CAREFUL NOT TO INVERT THE BATTERY POLARIZATION : The + must be connected to the VCC and the - to the GND. Otherwise, both issues might cause several damages to the circuit. By the way, we decided to solder the battery directly to the ESP8266 on VCC and GND pins to make it handy. Now you have a self-powered, portable and wearable system :

CONCLUSION : Our project is just a simple prototype of the healthcare monitoring. We would like to implement more sensors to get a general overview of the elder health condition (skin humidity, blood pressure, heart pulses, covid-19 symptoms). We could also add on a database on the server to collect the daily motion and make a study out of it (steps, body gestures, localization). The doctors and the nurses could get reliable analysis to detect and prevent any danger. This could even lead to prediction and anticipation. Finally a top notch feature could be the modification of the network communication from local Wi-Fi to GSM modules in order to give complete freedom to the elders. They could walk anywhere, anytime and even travel as long as we have the supervision in real-time.

ESP32 Arduino program - WiFi connection and acquisition of acceleration/temperature

/*  

This program enables the WiFi connection of the MCU ESP32 and sends the values of the acceleration and temperature, through the HTTP IP protocol. 

*/
#include <Wire.h>
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
Adafruit_MPU6050 mpu;

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <string>
#include <stdio.h>
#include<stdlib.h>
using namespace std;

#define SERVER_IP "172.20.10.4:8282" // MN-CSE (RASPBERRY) IP Adress

#ifndef STASSID
#define STASSID "iPhone de Chadi" // ID of the Local WiFi network 
#define STAPSK  "ChadiA98" // Password for the connection to Local WiFi network
#endif

void setup() {
  Wire.begin();
  Serial.begin(115200); // Baudrate
  
  while(!Serial);
  delay(100);

  Serial.println("Adafruit MPU6050 test!"); // The temperature, the acceleration and the rotation sensors are part of an Arduino integrated circuit called the MPU6050 which is connected to the MCU ESP32 pins. 
 
    // Try to initialize the integrated sensors (accelerometer, gyroscope and temperature) through I2C communication. 
  if (!mpu.begin()) {
    Serial.println("Failed to find MPU6050 chip");
    while (1) {
      delay(10);
    }
  }

  Serial.println();
  Serial.println();
  Serial.println();

  WiFi.begin(STASSID, STAPSK); // WiFi protocol - the programm will not start until the WiFi connection has been set. 

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());


Serial.println("MPU6050 Found!");
  mpu.setAccelerometerRange(MPU6050_RANGE_8_G); // Calibration of the integrated sensors for acceleration
  Serial.print("Accelerometer range set to: ");
  switch (mpu.getAccelerometerRange()) {
  case MPU6050_RANGE_2_G:
    Serial.println("+-2G");
    break;
  case MPU6050_RANGE_4_G:
    Serial.println("+-4G");
    break;
  case MPU6050_RANGE_8_G:
    Serial.println("+-8G");
    break;
  case MPU6050_RANGE_16_G:
    Serial.println("+-16G");
    break;
  }
  mpu.setGyroRange(MPU6050_RANGE_500_DEG); // Calibration of the integrated sensors for gyroscope. 
  Serial.print("Gyro range set to: ");
  switch (mpu.getGyroRange()) {
  case MPU6050_RANGE_250_DEG:
    Serial.println("+- 250 deg/s");
    break;
  case MPU6050_RANGE_500_DEG:
    Serial.println("+- 500 deg/s");
    break;
  case MPU6050_RANGE_1000_DEG:
    Serial.println("+- 1000 deg/s");
    break;
  case MPU6050_RANGE_2000_DEG:
    Serial.println("+- 2000 deg/s");
    break;
  }

  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ); // Select the filter bandwidth for the signals
  Serial.print("Filter bandwidth set to: ");
  switch (mpu.getFilterBandwidth()) {
  case MPU6050_BAND_260_HZ:
    Serial.println("260 Hz");
    break;
  case MPU6050_BAND_184_HZ:
    Serial.println("184 Hz");
    break;
  case MPU6050_BAND_94_HZ:
    Serial.println("94 Hz");
    break;
  case MPU6050_BAND_44_HZ:
    Serial.println("44 Hz");
    break;
  case MPU6050_BAND_21_HZ:
    Serial.println("21 Hz");
    break;
  case MPU6050_BAND_10_HZ:
    Serial.println("10 Hz");
    break;
  case MPU6050_BAND_5_HZ:
    Serial.println("5 Hz");
    break;
  }
  Serial.println("");
  delay(5000); // valeur initiale a 100ms mais je veux voir l'affichage du setup donc 5000ms
}


void loop() {

/* Get new sensor events with the readings */
  sensors_event_t a, g, temp; // the variable "a" will contain the acceleration, "g" the rotation, "temp" the temperature
  mpu.getEvent(&a, &g, &temp); // The MPU6050 reads the analog values and stores them into a, g and temp. 


String acceleration_x = String (a.acceleration.x,1); // Convert from integer to string
String acceleration_y = String (a.acceleration.y,1);
String acceleration_z = String (a.acceleration.z,1);

String temperature = String (temp.temperature,2);

  Serial.println("");
  delay(500);


  if ((WiFi.status() == WL_CONNECTED)) {

    WiFiClient client;  // wait for WiFi connection


   // HTTP REQUEST TO POST THE TEMPERATURE
    HTTPClient http;
    Serial.print("[HTTP] begin...\n");
    http.begin(client, "http://" SERVER_IP "/~/mn-cse/cnt-623708435"); // configure the HTTP request with the url of the Data Container on the mn-cse
    http.addHeader("X-M2M-Origin","admin:admin");
    http.addHeader("Content-Type", "application/xml;ty=4"); 
    Serial.print("[HTTP] POST...\n");
    // start connection and send HTTP header and body
    int httpCode = http.POST(String("<m2m:cin xmlns:m2m=\"http://www.onem2m.org/xml/protocols\"> <cnf>message</cnf> <con> &lt;obj&gt; &lt;int name=&quot;data&quot; val=&quot;") + temperature + String("&quot;/&gt; &lt;/obj&gt;  </con> </m2m:cin>"));
    // httpCode will be negative on error
    if (httpCode > 0) {
      // HTTP header has been send and Server response header has been handled
      Serial.printf("[HTTP] POST... code: %d\n", httpCode);
      Serial.println(temperature);
      // file found at server
      if (httpCode == HTTP_CODE_OK) {
        const String& payload = http.getString();
        Serial.println("received payload:\n<<");
        Serial.println(payload);
        Serial.println(">>");
      }
    } else {
      Serial.printf("[HTTP] POST... failed, error: %s\n", http.errorToString(httpCode).c_str());
    }

    http.end();
      delay (100) ;
      

 // HTTP REQUEST TO POST THE ACCELERATION
    HTTPClient http_acceleration;
    Serial.print("[HTTP] begin...\n");
    // configure traged server and url
    http_acceleration.begin(client, "http://" SERVER_IP "/~/mn-cse/cnt-800110039"); //HTTP
    http_acceleration.addHeader("X-M2M-Origin","admin:admin");
    http_acceleration.addHeader("Content-Type", "application/xml;ty=4");
    Serial.print("[HTTP] POST...\n");
    // start connection and send HTTP header and body
    int httpCode_acceleration = http_acceleration.POST(String("<m2m:cin xmlns:m2m=\"http://www.onem2m.org/xml/protocols\"> <cnf>message</cnf> <con> &lt;obj&gt; &lt;int name=&quot;data&quot; val=&quot;") + acceleration_z + String("&quot;/&gt; &lt;/obj&gt;  </con> </m2m:cin>"));
    // httpCode will be negative on error
    if (httpCode_acceleration > 0) {
      // HTTP header has been send and Server response header has been handled
      Serial.printf("[HTTP] POST... code: %d\n", httpCode);
      Serial.println("chute" + acceleration_z);
      // file found at server
      if (httpCode_acceleration == HTTP_CODE_OK) {
        const String& payload = http_acceleration.getString();
        Serial.println("received payload:\n<<");
        Serial.println(payload);
        Serial.println(">>");
      }
    } 
   else {
      Serial.printf("[HTTP] POST... failed, error: %s\n", http_acceleration.errorToString(httpCode).c_str());
   }

    http_acceleration.end();
    delay(100);
 
Serial.println(" ") ;
Serial.println(" ");
delay(100);
}
}

Back-End : Node JS Server (a sub part of the IN-CSE node)

It is a server program that acts like an interface between the Middle Node and the Web User application. This Node JS server needs to be runned on the same machine than the IN-CSE platform. This Node JS server aims at sending notifications to the web user application whenever a new data for a specific patient has been collected on the Middle Node. This server susbribes to the Middle Node by requesting the OneM2M Infrastructure Node platform. In terms of architecture, this server program runs on the Infrastructure Node host