Published June 23, 2020 © MIT

HealthEcos

HealthEcos - An ecosystem for realtime monitoring of health data and detection of the symptoms related to COVID-19 and medication management

AdvancedFull instructions provided20 hours967

Things used in this project

Hardware components

NodeMCU ESP8266 Breakout Board

Infineon DPS310

Pulse Sensor

SG90 Micro-servo motor

Jumper wires (generic)

Breadboard (generic)

Amazon Alexa Echo Dot

Software apps and online services

Blynk

Arduino IDE

The Processing Foundation Processing

Amazon Web Services AWS Lambda

Amazon Alexa Alexa Skills Kit

Story

With the COVID-19 pandemic grasping the whole world and affecting millions of lives within such a short period of time, it has become the need of the hour for continuous health monitoring and medication management of the people. With the symptoms like normal flu in mild cases, it becomes very hard to diagnose COVID-19. People with comorbidities and the elderly are at a higher risk of severe contraction of the COVID-19, which can result in losing many lives that could be saved. With an ecosystem that provides proper medication management and real-time health monitoring of the people. With improper medicine intake health condition of people might get worse and that can be life-threatening in the times of COVID-19. With the fall detection feature, people can take care, especially of the elderly if they feel uncomfortable or are experiencing drastic changes in vitals or breathing problems which may lead to falls and fatality. With this feature, emergency response can be initiated which may help to save the lives.

Prototype Architecture

Prototype and Working:

HealthBand

DPS310: A digital barometric air pressure sensor by “Infineon”. It is much miniaturized in terms of size and has high accuracy and low current consumption.

// Dps310 Opject
Dps310 Dps310PressureSensor = Dps310();

Creating a dps310 object that will be used in the rest of the code.

we have used the DPS310 breakout board which is cheap and highly accurate. The library used for this breakout board is different from the projects created using the other dps310 sensor module(integrated Bluetooth and lipo battery).

Pulse Sensor: It is a well-designed Plug and Play sensor through which users can take live pulse rate data

NodeMCU: It is an open-source microcontroller or development board with firmware based on the ESP8266 Wi-Fi module to provide Wi-Fi capabilities in a microcontroller with ESP8266 Wi-Fi embedded in it.

Circuit for band

Pill dispenser:

Servo Motor: This is an electrical device that can push or rotate an object with high precision. It helps us to rotate and object at some specific angles or distance

NodeMCU:

Pill dispensed from the dispenser

Please refer to the schematics for connections, all schematics are custom made for the project.

Blynk App:

Connecting to Blynk App:

Create a project in Blynk app

Choose the board and the connection type

For this project - Nodemcu and WiFi is chosen

An id is sent to the email id

The id is used for the communication of hardware and Blynk app

#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "1MctIWtYqw_*********NIpIYEL1FS";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "*****";
char pass[] = "*********";

Pill Dispenser data on Blynk App

It becomes quite difficult to remember what pills to take when and how much the correct dosage is. To overcome this issue, the smart pill dispenser will be able to take several pills of 2 or 3 kinds, sort them into the correct dosage, and dispense them at the correct interval. This takes the potential for error each day and moves it upstream to a single task: correctly inputting the prescription information into the pill sorter. With proper medication management, people can take care of their health and hence reduces the chance of being affected by COVID-19.

Pill data and notification is sent on phone if any of the pill gets over

Fall Detection feature

Using the temperature and pressure sensor data to calculate height and fall detection.

If there seems to be a sudden fall due to heart attacks or losing balance, or abnormal fall or rise in pulse rate it alters the nearby ones of the person to get immediate attention, the Health band also measures the temperature of the person in order to understand the person's health condition.

Checking for the pressure change while falling and getting up
Notifications are sent accordingly

p_new = pressure;
  diff = p_new - p_prev;
  p_prev = p_new;
  Serial.print(" Pressure Difference: ");
  Serial.println(diff);
  if(diff > 2.0)
  {
    Serial.println(" Person might had a fall");
    //Blynk.notify(" Person might had a fall, Waiting for 3 secs.... to detect if the fall truly happened ");
    Serial.println(" Waiting for 3 secs.... to detect if the fall truly happened ");
    delay(3000);
    float fall_pressure;
    ret = Dps310PressureSensor.measurePressureOnce(fall_pressure, oversampling);
    if (ret != 0)
  {
    //Something went wrong.
    //Look at the library code for more information about return codes
    Serial.print("FAIL! ret = ");
    Serial.println(ret);
  }
  else
  {
    Serial.print(" Fall Pressure: ");
    Serial.print(fall_pressure);
    Serial.println(" Pascal");
  }
//    float fall_pressure = f_pressure;
//    Serial.println(f_pressure);
//    Serial.print(" Fall pressure: ");
//    Serial.println(fall_pressure);
    if(abs(p_prev - fall_pressure) < 1.0)
    {
      Serial.println(" Help needed for the person. ");
      Blynk.notify(" Person had a fall, needs help!! ");
    }
  }

Fall detection

Altitude meter:

float Altitude()
{
float altitude;
float alt_pressure = b; // in Si units for Pascal
// alt_pressure = alt_pressure/100;
altitude = 44330 * (1.0 - pow((alt_pressure/1013.25), 0.1903));
//altitude = altitude/1000;
return altitude;
}

Real time temperature, pressure, pulse rate and altitude data

Real-time temperature and pulse data is really important for detecting COVID-19 as major symptoms are fever, tiredness, shortness of breathing. With this data, we can have an emergency plan and readily consult the required person,

Arduino IDE :

Output of data from band on serial monitor

Alexa Integration:

With Alexa integration, the pill dispenser can provide reminders through Alexa devices and with further improvement, can be used to initiate a conversation about the medicines in the dispensers.

We have created an ON/OFF skill for the pill dispenser. After successfully setting up the environments in required cloud services - ASD, Amazon AWS, Amazon Lambda which allows us to run functions without using servers. Lambda produces the GET requests for the commands given to Alexa. After entering the console of the ADS, we create a custom skill using the JSON editor.

AWS Lambda is set up for processing the commands from the skill interface.

The code is written for the Lambda function, which executes the Blynk API connecting it with the dispenser. Finally, the Skill is integrated with the Blynk API using the lambda function to control the pill dispenser.

Alexa Skill Working for Pill Dispenser

Conclusion

With this ecosystem, we aim to help people battle COVID-19 by maintaining their health through proper medicine intake and real-time monitoring of their health and taking necessary actions required,

Code

#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <Servo.h>

Servo servo;

char auth[] = "***************";

char ssid[] = "yolo***";
char pass[] = "*********";
int a = 0;
int b = 0;
int c = 10;
int d = 0;

void setup()
{
Serial.begin(9600);
Blynk.begin(auth, ssid, pass);
servo.attach(2); //D4
servo.write(0);
delay(1500);
}

BLYNK_WRITE(V1)
{
int pinValue = param.asInt();
a = pinValue;
}

BLYNK_WRITE(V2)
{
int pinValue = param.asInt();
b = pinValue;
}

BLYNK_WRITE(V3)
{
int pinValue = param.asInt();
c = pinValue;
}

BLYNK_WRITE(V4)
{
int pinValue = param.asInt();
d = pinValue;
}


void loop()
{
Blynk.run();
Serial.println(d);
if(d==1)
  {
    servo.write(90);
    Serial.println(a);
    Serial.println(b); 
    Serial.println(c);

    delay(c*1000);

    if(a>0 && b>0)
      {
        Serial.println("im in A loop");
        servo.write(90);
        delay(1000);
        servo.write(165);
        delay(1000);
        a=a-1;

        Serial.println("im in B loop");
        servo.write(90);
        delay(1000);
        servo.write(15);
        delay(1000);
        b=b-1;
      }

    else if(a>0 && b==0)
      {
        Serial.println("im in A loop");
        servo.write(90);
        delay(1000);
        servo.write(165);
        delay(1000);
        a=a-1;
    
        Serial.println("Refill Pill B");
        Blynk.notify("Refill Pill B");
      }

     else if(a==0 && b>0)
      {
        Serial.println("Refill Pill A");
        Blynk.notify("Refill Pill A");
        
        Serial.println("im in B loop");
        servo.write(90);
        delay(1000);
        servo.write(15);
        delay(1000);
        b=b-1;
      }
     else 
      {
        Blynk.notify("Refill Pill A & B");
        Serial.println("Refill Pill  A & B");
      }
   }
}

{
"interactionModel": {
"languageModel": {
"invocationName": "pill dispenser",
"modelConfiguration": {
"fallbackIntentSensitivity": {
"level": "LOW"
}
},
"intents": [
{
"name": "AMAZON.FallbackIntent",
"samples": []
},
{
"name": "AMAZON.CancelIntent",
"samples": []
},
{
"name": "AMAZON.HelpIntent",
"samples": []
},
{
"name": "AMAZON.StopIntent",

"samples": []
},
{
"name": "AMAZON.NavigateHomeIntent",
"samples": []
},
{
"name": "OnOffIntent",
"slots": [
{
"name": "OnOff",
"type": "OnOffValue",
"samples": [
"no",
"yes"
]
}
],
"samples": [
"switch {OnOff} pill dispenser",
"switch {OnOff} the pill dispenser",
"turn {OnOff} pill dispenser ",
"turn {OnOff} the pill dispenser"
]
}
],
"types": [
{
"name": "OnOffValue",
"values": [

{
"name": {
"value": "Off"
}
},
{
"name": {
"value": "On"
}
}
]
}
]
},
"dialog": {
"intents": [
{
"name": "OnOffIntent",
"confirmationRequired": false,
"prompts": {},
"slots": [
{
"name": "OnOff",
"type": "OnOffValue",
"confirmationRequired": false,
"elicitationRequired": true,
"prompts": {
"elicitation": "Elicit.Slot.1491531299731.496876215167"
}
}

]
}
],
"delegationStrategy": "SKILL_RESPONSE"
},
"prompts": [
{
"id": "Elicit.Slot.1491531299731.496876215167",
"variations": [
{
"type": "PlainText",
"value": "Do you want to turn the pill dispenser on or off?"
}
]
}
]
}
}

const http = require('http');
exports.handler = async (event, context, callback) => {
console.log(event.request.intent)
if (event.request.intent.slots.OnOff.value == "on") {
var responseJson = {
version: "1.0",
response: {
outputSpeech:
{
type: "PlainText",
text: "Okay, Switching On now",
},
shouldEndSession: true
},
sessionAttributes: {}
};
console.log("starting request...")
return new Promise((resolve, reject) => {
const options = {
host: 'blynk-cloud.com',
path: '/v3izbbVLp7NwS05NaSYIWq_NPIT-qnFk/update/V4?value=1',
port: 80,
method: 'GET'
};
const req = http.request(options, (res) => {
resolve('Success');
callback(null,responseJson);
});
req.on('error', (e) => {
reject(e.message);
var responseJson = {
version: "1.0",
response: {
outputSpeech:
{

type: "PlainText",
text: "I got an error from Blink",
},
shouldEndSession: true
},
sessionAttributes: {}
};
callback(null,responseJson);
});
// send the request
req.write('');
req.end();
});
} else {
return new Promise((resolve, reject) => {
var responseJson = {
version: "1.0",
response: {
outputSpeech:
{
type: "PlainText",
text: "Okay, Switching off now",
},
shouldEndSession: true
},
sessionAttributes: {}
};
const options = {
host: 'blynk-cloud.com',

path: '/v3izbbVLp7NwS05NaSYIWq_NPIT-qnFk/update/V4?value=0',
port: 80,
method: 'GET'
};
const req = http.request(options, (res) => {
resolve('Success');
callback(null,responseJson);
});
req.on('error', (e) => {
reject(e.message);
var responseJson = {
version: "1.0",
response: {
outputSpeech:
{
type: "PlainText",
text: "I got an error from Blink",
},
shouldEndSession: true
},
sessionAttributes: {}
};
callback(null,responseJson);
});
// send the request
req.write('');
req.end();
});
}
};

#include <Dps310.h>
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "********************"; // you need to create your own blynk id

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "Pi";
char pass[] = "********";

// Dps310 Opject
Dps310 Dps310PressureSensor = Dps310();
float a = 0;
float b = 0;
float p_prev;
float p_new;
float diff;
float height;

int Signal;
int s;
int PulseSensor= A0;

#define vTEMPERATURE_PIN V1
#define vPRESSURE_PIN V2
#define vPULSE_PIN V3
#define vALT_PIN V4


float Altitude()
{
  
  float altitude;
  float alt_pressure = b; // in Si units for Pascal
  // alt_pressure = alt_pressure/100;
  altitude = 44330 * (1.0 - pow((alt_pressure/1013.25), 0.1903));
  //altitude = altitude/1000;
  return altitude;
  
}


void setup()
{
  Blynk.begin(auth, ssid, pass);
  Serial.begin(9600);
  while (!Serial);


  //Call begin to initialize Dps310PressureSensor
  //The parameter 0x76 is the bus address. The default address is 0x77 and does not need to be given.
  //Dps310PressureSensor.begin(Wire, 0x76);
  //Use the commented line below instead of the one above to use the default I2C address.
  //if you are using the Pressure 3 click Board, you need 0x76
  Dps310PressureSensor.begin(Wire);

  Serial.println("Init complete!");
}
BLYNK_WRITE(V1)
{
  float pinValue = param.asFloat();
  a = pinValue;
  
 }



void loop()
{
  Blynk.run();
  float temperature;
  float pressure;
  uint8_t oversampling = 7;
  int16_t ret;
  Serial.println();
  //Serial.print("Hello");

  //lets the Dps310 perform a Single temperature measurement with the last (or standard) configuration
  //The result will be written to the paramerter temperature
  //ret = Dps310PressureSensor.measureTempOnce(temperature);
  //the commented line below does exactly the same as the one above, but you can also config the precision
  //oversampling can be a value from 0 to 7
  //the Dps 310 will perform 2^oversampling internal temperature measurements and combine them to one result with higher precision
  //measurements with higher precision take more time, consult datasheet for more information
  ret = Dps310PressureSensor.measureTempOnce(temperature, oversampling);

  if (ret != 0)
  {
    //Something went wrong.
    //Look at the library code for more information about return codes
    Serial.print("FAIL! ret = ");
    Serial.println(ret);
  }
  else
  {
    Serial.print(" Temperature: ");
    a = temperature;
    Serial.print(temperature);
    Serial.println(" degrees of Celsius");
    //Serial.println(a);
    Blynk.virtualWrite(vTEMPERATURE_PIN, a);
  }

  //Pressure measurement behaves like temperature measurement
  //ret = Dps310PressureSensor.measurePressureOnce(pressure);
  ret = Dps310PressureSensor.measurePressureOnce(pressure, oversampling);
  if (ret != 0)
  {
    //Something went wrong.
    //Look at the library code for more information about return codes
    Serial.print("FAIL! ret = ");
    Serial.println(ret);
  }
  else
  {
    Serial.print(" Pressure: ");
    Serial.print(pressure);
    Serial.println(" Pascal");
    b = pressure/100;
    Blynk.virtualWrite(vPRESSURE_PIN, b);
    
  }

  p_new = pressure;
  diff = p_new - p_prev;
  p_prev = p_new;
  Serial.print(" Pressure Difference: ");
  Serial.println(diff);
  if(diff > 2.0)
  {
    Serial.println(" Person might had a fall");
    //Blynk.notify(" Person might had a fall, Waiting for 3 secs.... to detect if the fall truly happened ");
    Serial.println(" Waiting for 3 secs.... to detect if the fall truly happened ");
    delay(3000);
    float fall_pressure;
    ret = Dps310PressureSensor.measurePressureOnce(fall_pressure, oversampling);
    if (ret != 0)
  {
    //Something went wrong.
    //Look at the library code for more information about return codes
    Serial.print("FAIL! ret = ");
    Serial.println(ret);
  }
  else
  {
    Serial.print(" Fall Pressure: ");
    Serial.print(fall_pressure);
    Serial.println(" Pascal");
  }
//    float fall_pressure = f_pressure;
//    Serial.println(f_pressure);
//    Serial.print(" Fall pressure: ");
//    Serial.println(fall_pressure);
    if(abs(p_prev - fall_pressure) < 1.0)
    {
      Serial.println(" Help needed for the person. ");
      Blynk.notify(" Person had a fall, needs help!! ");
    }
  }
// pulse sensor code
  Signal = analogRead(PulseSensor);
  s = Signal/8;
  Serial.print(" BPM: ");
  Serial.println(s);
  Blynk.virtualWrite(vPULSE_PIN,s);
  //Wait some time
  delay(500);

  
  height = Altitude();
  Blynk.virtualWrite(vALT_PIN,height);
}