Team MedicAlert:

Shagufta

•

Souleymane

•

Kevin Vu

Published February 20, 2018 © GPL3+

MedicAlert: A Next-Generation Connected Pill Dispenser

A connected pill dispenser to stop worrying about your beloved one's medication.

IntermediateWork in progress3 hours2,855

MedicAlert: A Next-Generation Connected Pill Dispenser

Things used in this project

Hardware components

NodeMCU ESP8266 Breakout Board

LED (generic)

Resistor 10k ohm

A1302KUA-T - Hall Effect Sensor

Servos (Tower Pro MG996R)

Breadboard (generic)

Magnet (generic)

Software apps and online services

IBM BlueMix

Arduino IDE

Android Studio

Hand tools and fabrication machines

3D Printer (generic)

Story

Nowadays when people have severe disease, they use pill dispenser to gather all their tablets into one place. Having all these drugs to handle can become very inconvenient. Plus, people around them barely know what they actually take, or what they need. Often, this lack of attention can become very dangerous for a patient. Here we present a cheap solution to keep track of your medication: a connected pill dispenser.

The system

We printed 2 wheels, one for each kind of drugs. These can rotate thanks to our 2 servos :

Placement of the 2 wheels and the servos

After a determined number of rotations, we get the number of pills to take in the pot.

Upper view of the system

The rotation is controlled by the ESP8266 placed inside the box. It also controls the hall effect sensor. There is a magnet where you see a red spot under the pot. On the other side of the box, you have the hall effect sensor that tell you if the pot is there, so if the patient took his pills.

Inside the white box

The entire system's communication is done through MQTT protocol, which is based on publisher/subscriber clients and a central broker redirecting information to right topics. A client can publish on a particular topic and clients who subscribed to that topic will receive the published message. For more details check out this link.

In this project we have 3 major communications :

System's communication

The android application sends the prescription to the cloudant database, the Node-Red application retrieves that data and publishes information to the ESP8266.

Getting started

Arduino IDE

First of all you need to make sure that your IDE's target board is the ESP8266. To do so, go under File > Preferences and paste the following url :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

and hit OK. Now, by going to Tools > Boards > Boards Manager you can install nodeMCU 1.0 (ESP-12E Module) if it was not already there, or simply select it as your new target board.

Then, you can select libraries needed for this project, under Sketch > Include Library > Manage Libraries :

esp8266webser

esp8266wifi

esp8266webser

esp8266httpclient

arduinojson

Finally download pubsubclient library from the following GitHub. Include this library by going under Sketch > Include Library > Add .zip Library.

Note : You can download the program under the code section, and wire the LED, the 2 servos and the hall effect sensor just like the schematic shows it. Put your own information where it is indicated.

Bluemix

You will need a Bluemix account, follow the link below to register :

https://console.bluemix.net/registration/

Select Catalog, and search Node-Red. You will be asked to give your Node-Red application a name and you have to choose a cloudantNoSQLDB application.

You can navigate to your new database under your bluemix dashboard / Services, hit the Lauch button.

Before applying any changes to the Node-Red application, set up the database :

Choose the name of your database. The "Actions" column gives you access to "set permissions for" your database. Generate an API key, and save the password associated to that key. Give that key all the permissions it can have : read, write, admin, replication. Save your database id which looks like this :

584400a7-df99-4eec-a847-5ef9d85bf82b-bluemix

It is in the url of your database.

Note : Do not forget to save the generated password from Bluemix ! You cannot have access to it again. All these information will be needed for the android application.

Follow this tutorial to connect your ESP8266 to your Node-Red application.

Node-Red application

Let's move on to the Node-Red application. As you saw in the system schematic, we need 3 communication canals covered by our application.

1. From the android application to Node-Red :

Topic Update : whenever there is a change in the database, the application publishes a message to that topic.

In Node-Red topics are represented by ibmiot nodes.

Retrieving data from database

The first ibmiot node is an input. Set the input type to device event with a device id : androidapp. The event will be our topic Update, with a string format. This is linked to a cloudant node that allows us to access data from the database. Put the name of your database and select "search by all elements".

The first function node takes the number of pills from the database to initialize an array of 2 drugs.

/* FIRST NODE FUNCTION */
var myStringArray = msg.payload;
var arrayLength = myStringArray.length;
var drugs = {"Morning":{"drug1":0,"drug2":0},
   "Afternoon":{"drug1":0,"drug2":0},
   "Noon":{"drug1":0,"drug2":0}
};
var cpt = 0;
for (var i = 0; i < arrayLength; i++) {
   var result = (myStringArray[i]);
   if (result.index !== 0){
       if(cpt === 0){
           drugs.Morning.drug1 = result.numberPillMorning;
           drugs.Afternoon.drug1 = result.numberPillAfternoon;
           drugs.Noon.drug1 = result.numberPillNoon;
           cpt = 1;
       }
       else{
          drugs.Morning.drug2 = result.numberPillMorning;
          drugs.Afternoon.drug2 = result.numberPillAfternoon;
          drugs.Noon.drug2 = result.numberPillNoon;
       }
   }
}
msg.payload = medocs;
return msg;
/* END FIRST NODE FUNCTION */

The second function node creates a string with all information from the array :

/* SECOND NODE FUNCTION */
var string = msg.payload.Morning.drug1 + ";"
string += msg.payload.Afternoon.drug1 + ";"
string += msg.payload.Noon.drug1 + ";"
string += msg.payload.Morning.drug2 + ";"
string += msg.payloadAfternoon.drug2 + ";"
string += msg.payload.Noon.drug2 + ";"
var msg = {'payload':string};
return msg;
/* END SECOND NODE FUNCTION */

That string will be sent to the ESP8266 via the ibmiot output node, which is a command type node with string format. This node is related to the TakeDrugs topic explained in the next section.

2. From Node-Red to the ESP8266 :

Topic TakeDrugs : the ESP8266 is the subscriber and the Node-Red application is the publisher. When the patient takes his drugs the Node-Red application publishes a message to notify the ESP8266 that he has to turn on the servos controlling the wheels containing drugs.

Setting medication timing

On the right, you can see an inject node. This node tells at what time the patient has to take his drugs on mornings, afternoons and noons.

Put JSON format in this node and add the following code :

{"Morning": { "hour": "XX:XX" },"Afternoon": { "hour": "XX:XX"}, "Noon": { "hour":"XX:XX"}}

Replace xx:xx by your desired hour.

Add 3 functions nodes with the following code :

var string ="on_override"+msg.payload.YYYY.hour
var msg = {'payload':string};
return msg;

Replace YYYY by Morning, afternoon, or noon depending on which function it will be.

Nodes after are Big Timer.

Finally, add a switch node : set it for string == OutputON. That node is connected to the ibmiot output node.

By doing this you have 2 options to send the command to the ESP8266, the time you set or the injet node OutputON (which is SortieOn on the schematic).

At the end of this section your Node-Red flow should look like this :

Sending command to the ESP8266

3. From the ESP8266 to Node-Red : The ESP82266 publishes to 3 different topics :

Topic DrugNotTaken : the Node-Red application will start a timer that is going to send a reminder once the timer is expired. The LED blinks whenever there is a reminder.

Topic StopTimer : if the reminder works and the patient takes his drugs, we stop the Node-Red timer.

Node-Red flow for DrugNotTaken and StopTimer

Here the ibmiot output node has the same settings as the previous one. Both input ibmiot nodes are event type, support JSON format, and are related to DrugNotTaken and StopTimer topics.

Topic ContactFamily : If we have no positive response after 4 reminders, we send an email to the family members.

Node-Red flow for sending an email to family

The ibmiot input node is also event type for the ContactFamily topic and supports JSON format. Create documents in your database containing the email of the familly members and for all of them set the _id to Contact.

The first function node gets the email :

msg.payload="Contact"; return msg;

The second function node will turn it into a string :

var msg2; msg2 ={"to":msg.payload.to,"complete":true}; return msg2;

The last node allows you to enter the text of your email :

msg.payload="My text"; msg.topic ="My Topic"; return msg;

Android application

You will find the project files in this GitHub. This application allows you to create a new prescription, which are going to be uploaded automatically to your database. Change the settings.xml file with your own database name, API key/password and bluemix id.

And do not forget to hit the publish button, to notify database change to the Node-Red application.

Here you go, this connected pill dispenser can be improved in many ways, have fun !

Wiring of the system

• ESP8266 GND pin to Servo1 GND
• ESP8266 3.3V pin to Servo1 3.3V
• ESP8266 D2 pin to Servo1 data
• ESP8266 GND pin to Servo2 GND
• ESP8266 3.3V pin to Servo2 3.3V
• ESP8266 D3 pin to Servo2 data
• ESP8266 D1 pin to resistor1
• Resistor 1 to LED
• LED to ESP8266 GND
• ESP8266 D4 pin to hall effect sensor data
• ESP8266 GND pin to hall effect sensor GND
• ESP8266 3.3V pin to hall effect sensor 3.3V
• Resistor 2 between hall effect sensor 3.3V and hall effect sensor data

Code

ESP8266 code

/*
 *  Inspired by Ivan Grokhotkov, 2015.
 *  This example is in public domain.
 */

#include <stdio.h>
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <ESP8266HTTPClient.h>
#include <PubSubClient.h>
#include  <ESP8266WebServer.h>      //  Include the WebServer library
#include <Servo.h>

/***********MODIFY THIS**********/
const char* ssid = "SSID";
const char* password = "PASSWORD";
#define DEVICE_TYPE "ESP8266"
#define DEVICE_ID "ID"
/********************************/
#define ORG "ORG"
#define TOKEN "TOKEN"
#define ANGLE 19
#define ANGLE2 22 
//-------- Customise the above values --------


const char* mqtt_server = ORG ".messaging.internetofthings.ibmcloud.com";
char topic[] = "iot-2/evt/setMed/fmt/json";
char askRev[] = "iot-2/evt/askRev/fmt/String";
char prendreMedocTopic[] = "iot-2/cmd/prendreMedoc/fmt/String";
char MsgFamille[] = "iot-2/evt/MsgFamille/fmt/String";
char medocNonPris[] = "iot-2/evt/medocNonPris/fmt/String";
char stopRappel[] = "iot-2/evt/stopRappel/fmt/String";

char authMethod[] = "use-token-auth";
char token[] = TOKEN;
char clientId[] = "d:" ORG ":" DEVICE_TYPE ":" DEVICE_ID;
const int MQTTPort = 1883;

#define DELAISEC 20 //5 Min  = 300 sec

WiFiClient wifiClient;
PubSubClient client(wifiClient);

enum PERIODE_JOURNEE{MATIN, MIDI, SOIR};
enum ETAT{ATT_PRISE, PRISE_MEDOC, MEDOC_PRIS, MEDOC_NON_PRIS}; 
bool medocPris = false;
int nbRappels = 0;
long lastMsg = 0;
long lastMsg2 = 0;
bool PassageUnefois = false;

const int buttonPin = D1;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

PERIODE_JOURNEE JourCourant = MATIN;
ETAT EtatCourant = ATT_PRISE;

unsigned long previousMillis = 0;
const long intervalLed = 1000;
int ledState = LOW;  
Servo myservo1;
Servo myservo2;
int position1 = 0;
int position2 = 0;
int roue1[3];
int roue2[3];
char msg[20];
void setup() {
  Serial.begin(9600);
  setup_wifi();
  
  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
  digitalWrite(LED_BUILTIN, HIGH);
  pinMode(buttonPin, INPUT);
    pinMode(D4, OUTPUT);              // LED VERTE

  client.setServer(mqtt_server, MQTTPort);
  client.setCallback(callback);
  mqttConnect();

  myservo1.attach(D2); 
  myservo2.attach(D3);
  myservo1.write(position1); 
  myservo2.write(position2);  

}

void setup_wifi(){

  Serial.println();
  Serial.print("connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    msg[i] = (char)payload[i];
    Serial.print((char)payload[i]);
  }
  Serial.println();
  Serial.println(msg);
  if(!strcmp(topic, prendreMedocTopic)){
    if((length == 8) || (length == 7)){
      EtatCourant = PRISE_MEDOC;
    }
    else if(length == 12){
      sscanf( msg, "%d;%d;%d;%d;%d;%d;", 
          &roue1[0], &roue1[1], &roue1[2], &roue2[0], &roue2[1], &roue2[2]);
      for(int i = 0; i < 3; i++){
        Serial.println(roue1[i]);
        Serial.println(roue2[i]);
      }
    }
  }
  /*// Parse JSON object
  DynamicJsonBuffer jsonBuffer;

  JsonObject& root = jsonBuffer.parseObject((char*)payload);
  if (!root.success()) {
    Serial.println("Parsing failed!");
    return;
  }
  Serial.print("reponse: ");
  */
  

}

void initManagedDevice() {
   if (client.subscribe(prendreMedocTopic)) {
     Serial.println("subscribe to PrendreMedocTopic OK");
   } else {
     Serial.println("subscribe to PrendreMedocTopic FAILED");
   }
 }

void mqttConnect() {
  if (!client.connected()) {
    Serial.print("Reconnecting MQTT client to "); Serial.println(mqtt_server);
    while (!client.connect(clientId, authMethod, token)) {
      Serial.print(".");
      delay(500);
    }
    initManagedDevice();
    Serial.println();
  }
}
  

void prendreMedoc(){
  unsigned long delaiMili = DELAISEC*1000;

  long now = millis();

  String payload= "{}";
  if ((now - lastMsg2) > (delaiMili/2)) {
    lastMsg2 = now;
    if (client.publish(askRev, (char*) payload.c_str())) {
      Serial.println("Publish ok");
    } else {
      Serial.println("Publish failed");
    }
  }

}

void tournerRoues(){
  switch(JourCourant)
  {
    case MATIN:
      for(int i = 0; i < roue1[0]*2; i++){
        myservo1.write(position1 + ANGLE);
        position1 = position1 + ANGLE+i;
        delay(1500);
      }
      for(int i = 0; i < roue2[0]*2; i++){
        myservo2.write(position2 + ANGLE2);
        position2 = position2 + ANGLE2+i;
        delay(1500);
      }
    break;

    case MIDI:
      for(int i = 0; i < roue1[1]*2; i++){
        myservo1.write(position1 + ANGLE);
        position1 = position1 + ANGLE+i;
        delay(1500);
      }
      for(int i = 0; i < roue2[1]*2; i++){
        myservo2.write(position2 + ANGLE2);
        position2 = position2 + ANGLE2+i;
        delay(1500);
      }
    break;

    case SOIR:
      for(int i = 0; i < roue1[2]*2; i++){
        myservo1.write(position1 + ANGLE);
        position1 = position1 + ANGLE+i;
        delay(1500);
      }
      for(int i = 0; i < roue2[2]*2; i++){
        myservo2.write(position2 + ANGLE2);
        position2 = position2 + ANGLE2+i;
        delay(1500);
      }
    break;
  }
}

void checkPrise(){
  //Serial.println("Dans Check Prise");
  unsigned long delaiMili = DELAISEC*1000;

  long now = millis();
  if(!medocPris){
    if ((now - lastMsg) > delaiMili) {
      //Va demarrer un timer de 30 min pour nouveau rappel
      lastMsg = now;
      String payload= "nonPris";
      if (client.publish(medocNonPris, (char*) payload.c_str())) {
        Serial.println("Publish non pris ok");
      } else {
        Serial.println("Publish failed");
      }
      EtatCourant = ATT_PRISE;   
    }  
  }
  else{
    EtatCourant = MEDOC_PRIS;
  }
  
}
void checkPriseApresRappel(){
  if(medocPris){
    EtatCourant = MEDOC_PRIS;
    String payload= "stop";
      if (client.publish(stopRappel, (char*) payload.c_str())) {
        Serial.println("Publish ok");
      } else {
        Serial.println("Publish failed");
      }  
  }

}
void actionsDeRappel(){
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis >= intervalLed) {
    previousMillis = currentMillis;   
   if (ledState == LOW){
            digitalWrite(D4, HIGH);
      ledState = HIGH;  // Note that this switches the LED *off*

    }
    else{
            digitalWrite(D4, LOW);
      ledState = LOW;   // Note that this switches the LED *on*
    }
    digitalWrite(LED_BUILTIN, ledState);
  }
}

void contacterFamille(){
      String payload= "Contact";
      if (client.publish(MsgFamille, (char*) payload.c_str())) {
        Serial.println("Publish ok");
      } else {
        Serial.println("Publish failed");
      }

      EtatCourant = ATT_PRISE;
}

void machineEtat(){
  switch(EtatCourant)
  {
    case ATT_PRISE:
      if(nbRappels){
        checkPriseApresRappel();
      }
    break;

    case PRISE_MEDOC:
        if(!nbRappels)
          tournerRoues();
        lastMsg = millis();
        nbRappels++;
        EtatCourant = MEDOC_NON_PRIS;
        Serial.print("Premier Passage dans Prise_medoc, nbRappels = ");
        Serial.println(nbRappels);
      
    break;

    case MEDOC_PRIS:
      EtatCourant = ATT_PRISE;
      nbRappels = 0;
      medocPris = false;
      PassageUnefois = false;
      //Si medicament pris, passage a la prochaine periode
      switch (JourCourant){
        case MATIN:
          JourCourant = MIDI;
        break;
        case MIDI:
          JourCourant = SOIR;
        break;
        case SOIR:
          JourCourant = MATIN;
        break;
        
    }
    break;

    case MEDOC_NON_PRIS:
        if(nbRappels > 3){
          contacterFamille();
          EtatCourant = MEDOC_PRIS;
        }
        actionsDeRappel();//Clignoter les leds, buzzer ?
        checkPrise();
            
    break;
    
  }
  
}
void verifConteneur(){
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == LOW) {
      medocPris = true;
      Serial.println("Medoc Pris");
  } else {
    // turn LED off:
    medocPris = false;
  }
}


// Il faudrait faire une fonction qui dit à quel periode de la journée on est au tout premier lancement de l'appli/pilulier apres la configuration

void loop() {
  machineEtat();
  if(nbRappels)
    verifConteneur();
  //Ajouter fonction qui verifie que le conteneur de medicament a ete pris
  if (!client.loop()) {
    mqttConnect();
  }
  
}