Álix A., Nelson Fernando Monroy Rios, Ciro Alberto Gamboa, Sergio Alexander Salinas

Published December 7, 2015 © GPL3+

Longer Life For Drivers

This project helps to detect motorcycle accidents and monitor the driver and vehicle involved in it, in order to save many lives.

IntermediateFull instructions provided1,949

Second Prize

LinkIt ONE: Smart Devices for Smart Cities

Things used in this project

Hardware components

NXP Pressure Sensor

Arduino UNO

e-Health Shield

Pulse and Oxygen in blood Sensor

SparkFun Vibration Sensor

SparkFun Flex Sensor

Software apps and online services

Arduino IDE

Ubidots

Story

Welcome to Longer Life For Drivers

Because of the high accident rates in countries like Colombia, this tutorial talks about how can be made an smart equipment for drivers, increasing the possibilities to survive and get better medical care by sending information about what is going on the driver's body while he/she drives, specially when takes place an accident.

In summary, the wearable equipment consist in

A vest that provides data from the magnitude of a force applied to the thorax - A helmet that allows to know the severity of a head injury
Data from heart rate
Alerts from deformation in the vehicle
GPS by Web

Next, we describe each one of the parts of the equipment based in the development board LinkIt One.

1. Making the LLFD-Vest

For this, you will need the pressure sensors, some meters of medical hose, glue and of course a vest.

1 / 3

The LLFD vest operates using the relation between pressure and force, as you know pressure is equal to the force applied in a determined area, then if we distribute the force in a constant area, knowing the pressure we can also know the force that is being applied. In this way, we can establish that a hit could have taken place.

To measure the pressure at the vest you can use the medical hose, which must be distributed along the more critical parts of the thorax.

The superior ribs are strengthened by the clavicles and the inferior ones are not so critical as the medium ones

Investigating medical theory, we concluded that these parts are all around the ribs, as this provide protection to the principal organs. Then, the purpose of measure the force is finding when a rib could be broken and hurting a vital organ.

So, the first step to improve a regular vest is pasting the hose along those critical parts.

1 / 2 • The hose was placed with thread, but glue can be also appropriate

For the chest the hose should be covering the medium ribs, where also are lungs and heart.

Inside the hose there are air, which exerts a nominal pressure while there is no force applied, and a higher pressure when there is some force.

You may think ¿What if the hit occurs between the hose?, Well, in an accident hits are not so precise, and they occurs from falls and strokes with large surfaces.

To measure the pressure, was used the MPX5010 sensor, placing it at the hose end.

This sensor has six pins, of which three are for adjustments and the rest are the more important ones. As the image, the first pin is the output voltage, the next is ground and the third is the input voltage, that must be +5V.

Pressure Sensor pines

At this moment the vest is ready to start coding, the pins in the LinkIt One to work are, 5V, gnd and A0 y A1, which have the value of voltage from the sensors.

The code commented is at the end of the tutorial.

If we have already the values from the two sensors, the next step is converting them to an useful magnitude, to do this, we need to do a characterization.

The characterization consist in proving different forces and comparing to the voltage read by the LinkIt One, so, we can describe completely the behaviour for any force we could apply.

Sensor data and resulting equation

We used three different masses generating a force equals to mass*acceleration, in this case the acceleration is the same as gravity.

The forces' magnitude must be now printed in the serial monitor, but our objective is to have this information remotely, then, we use Ubidots.

Ubidots allows the exchange of data between the LinkIt One and Ubidots webpage with some options to see the information.

First, the previous code need some additional lines to get the connection using the Wi-Fi antenna, and send it out. The code is at the end.

In Ubidots, create a variable, in Sources>Add Data Source>Add Variable.

Variables from Sources in Ubidots.com

Next, in the Dashboard, add a Widget>Multi-line Chart

Creating a new Widget to visualize a Variable

At the moment we upload the code to the board, in Ubidots, there will be something like this

Graph of force in the vest

2. Preparing the LLFD-Bike

The motorcycle is well known to be an widely used vehicle around the world, that can provide practical solutions to daily problems.

However, the motorcycles have a great dissadvantage, the low security they offer to the driver.

Due to the massive use of motorbikes, the great speed they can reach, the recklessness of drivers and many other factors, are the cause of the main number of deaths on the road.

LLFD proposes a “motorcycle” prototype, which is able to provide information in the moment when an accident has happened.

In this tutorial, it is exposed the use of one of many parameters that can determine if an accident happened, it is the deflexion of the covers.

In order to accomplish this tutorial, you will need mainly some flex sensors, a plastic bottle and something to attach the sensors to the bottle.

How was it made?

For accomplish this tutorial you may need:

1 / 3 • Type in a caption for this image

By putting these sensors on a motorcycle, it can detect which side of the bike touched the ground.

If we know that the motorbike fell down on its right side, we can generate a better diagnostic, because it's highly possible that the greatest injuries of the driver, are on it's right side, so the authorities can take that information and be ready to provide a better care to the wounded one.

3. Making the LLFD-Helmet

The helmet is a fundamental piece for every motorcyclist, because it protects the head in case of impact.

Although being mandatory its use, in many countries, the motorcyclists drive with helmets that don't accomplish the security rules and are used in a wrong way, so if an accident occurs, the most possible case of death is by cranial trauma.

LLFD proposes the adaptation of a helmet that accomplishes the standart security rules, but also gives a sensor system, which is able to provide valuable information of the variables related to the helmet, especially when it is hit.

For that, two linear vibration sensors were used, with the purpose of detecting serious shocks in the head.

How was it made?

For this tutorial you may need:

1 / 2 • Type in a caption for this image

This helmet works by using the data taken by the analog read of the sensor vibration, and doing a relationship with force, area of impact and other parameters.

The characterization of the sensors was made by field tests, so we wanted to filter the vibrations caused by normal driving conditions, so we can ignore that data in order to get the real hits without mistake.

It was made by taking the data that sensors provide, with the a motorcyclist using the helmet and accelerating his bike at a maximum of 12.000 rpm. Also by moving its suspension we emulated some irregular road conditions.

Some of the collected data, are this ones:

1 / 6

As we can see, the sensors didn't report high vibrations, so it is possible to use a filter that may ignore them. The sensor are in the safest place of the helmet, so it's logical to think that it's necessary a bigger amount of force to reach them.

The codes used to this proves, are at the bottom of this tutorial.

To test the measurement the sensors give with a specific force applied to it, we drop a weight on the helmet, releasing it from a specific height and hitting a certain point of the helmet.

By physics we know that it is only needed the height and the weight to determine the force of a falling object on a specific point and depending on surface's texture, we have for example:

Height = 1m, Mass = 1.5 Kg, Force received and that point= 147N

Comparing the vibration with the result the sensors give, with a known force, we're sure it is able to detect a real accident.

1 / 8

4. Getting data from the body

When a motorcyclist is involved in a serious accident and needs prompt attention, regularly dies because the authorities take a long time to get to the accident place and also because they don't have a previous diagnosis so the proper care lasts a long and vital time.

Pulse-oximetry is a technique for the hemoglobin oxygen transported measurement , which travels through blood vessels, this data is obtained by a non-invasive device, known as pulse-oximeter.

According to the philosophy of the project, it allows us to get an idea of whether the driver is alive or not through the heart rate, further enables us to obtain an idea of the respiratory status of the user through obtaining oxygen saturation, where health professional can observe and interpret it to generate a series of diagnostics.

So we used a pulse-oximeter, with a shield upon an Arduino, connected to the Linkit One, in order to send some data to Ubidots.

How was it made?

For this tutorial you may need... It is not necessary to have the same device, any similar device that provides digital data of at least heart rate, should be ok.

1 / 2 • Type in a caption for this image

The shield needs some libraries in order to work, those can be found on https://www.cooking-hacks.com/documentation/tutorials/ehealth-biometric-sensor-platform-arduino-

When removing the contents of this file,which is compressed into a zip file and copy the folder arduino libraries can create a sketch for biomedical data from sensors connected to the shield. The path where it should be copied these libraries is:

C:\Program Files (x86)\Arduino\libraries (Windows 64 bits) or in C:\Users\xxxxx\Documents\Arduino\libraries.

For monitoring pulse-oximeter data should be acquired sensor compatible with the shield. From this point you can write some code to acquire the information of oxygen saturation and heart rate.

5. Mixing some parameters

In order to put the pulse-oximeter information on Ubidots, there's something that need attention. The pulse-oximeter we used, can not be directly connected to the LinkIt ONE, but with Arduino. That's why a small coupling is necessary in order to use serial communication between both devices.

As it is being used two different boards, the Arduino One that receives data from the pulse-oximeter and the LinkIt One that receives and process different analog sensors, also it communicates with Ubidots to save and show the obtained data; it is necessary to realize a communication between both development boards. As this, the development boards have different pins to make communication protocols as UART, I2C.

The Linkit One’s pins D0 and D1 are used for UART communication and for this, it must declare the following libraries at the beginning of this sketch.

#include<HardwareSerial.h>

#include<UARTClass.h>

In the Arduino Uno’s case, it uses the library SoftwareSerial.h, but, in order to get it to work it is necessary to do some modifications, as this has problems with the PinChageInt.h library, these modifications there will be listed next:

- Add the line #define NO_PORT2_PINCHANGES inside the file PinChangeInt.cpp

- Comment /#if defined(PCINT2_vect)

ISR(PCINT2_vect, ISR_ALIASOF(PCINT0_vect));

#endif in the file SoftwareSerial.cpp

Because of pulse-oximeter functionalities, we can use the 4 and 5 Arduino Uno’s pins to do the serial communication, after realizing these changes.

Now we can connect the pulse-oximeter with the Link It ONE y a proper way, here it's a more detailed explanation from the code's point of view.

By accomplishing it, we can slowly add the other sensors we used and make an integral system for future works; and the possibilities are getting higher and higher, now you can see the last example we provided with the pulse-oximeter in real time, geo-localization and the motorcycle's flex detection:

Now, we have each system working as previously thought, but you may think we have only data. It is not. Currently, there are four parameters known. To come to a conclusion, we think, two parameters in alert is enough, so with all these data we can make a diagnosis about what is really taking place with the driver.

For example, it is known that a force of about 3500 Newton can break a rib, what allow us to suppose a serious injury when the pressure sensor is saturated. For the helmet we have some levels of gravity, (despising normal vibration from the motorcycle). When the level is above the medium, it indicates that the driver suffered a head strike.

In addition, if the blood pressure is higher than the normal rate, it is possible to suppose something is happening, and if there is no blood pressure, the driver can be dead.

These and another affirmations are part of the general diagnosis, which will be send besides the GPS coordinates, to a relative or the medical or traffic authorities.

1 / 12

Code

//analog inputs
int sensorPin = A0; 
int sensorPin1 = A1;

//inicialize the measure
int sensorValue= 0; 
int sensorValue1= 0; 

void setup() {
  //inicialize the serial monitor
  Serial.begin(9600);
}

void loop() {
  //Read the value equivalent to the voltage from the sensors  
  sensorValue = analogRead(sensorPin);
  sensorValue1 = analogRead(sensorPin1);

  //equations for force in Newtons
  float forceback=((1.772*sensorValue)-536.6);
  float forcechest=((0.4118*sensorValue1)-24.3);
  
  //erase wrong data
  if(forceback<0){forceback=0;}
  if(forcechest<0){forcechest=0;}
  
  //prints the force and the mass in rest
  Serial.print("back: ");
  Serial.print(forceback);
  Serial.println(" Newtons");
  Serial.print(forceback/8);
  Serial.println(" Kg");
  Serial.print("torax: ");
  Serial.print(forcechest);
  Serial.println(" Newtons");
  Serial.print(forcechest/8);
  Serial.println(" Kg");
  Serial.println("");
  delay(100);
}

#include <LWiFi.h>
#include <LWiFiClient.h>

#define WIFI_AP "" //name
#define WIFI_PASSWORD "" //password

#define WIFI_AUTH LWIFI_WPA  // choose from LWIFI_OPEN, LWIFI_WPA, or LWIFI_WEP.

// Ubidots information
#define URL        "things.ubidots.com"
#define TOKEN      "ZhmOE6cKoBzsyAYHJ6Ujz37WZ3HleGPovTOu8bjLLeMLscHeAqNmHuNDsXzK" //can be found at profile         
#define S_BACK   "560880387625421327f293e4"  //Variable ID              
#define S_CHEST  "5658893d7625427789802a97"  //Variable ID

//analog inputs
int sensorBack = A0;
int sensorChest = A1;

//force variables
int BackValue, ChestValue = 0;
int presb,presc = 0;

void setup()
{
  //initialize wifi and serial monitor
  LWiFi.begin();
  Serial.begin(9600);

  // get wifi communication
  Serial.println("Connecting to AP");
  while (0 == LWiFi.connect(WIFI_AP, LWiFiLoginInfo(WIFI_AUTH, WIFI_PASSWORD)))
  {
    delay(1000);
  }
}

void loop()
{ 
  //read the sensors value
  BackValue = analogRead(sensorBack);
  ChestValue = analogRead(sensorChest);
  
  //print before send
  Serial.println(BackValue);
  Serial.println(ChestValue);
  delay(100);
  
  //converts the voltage to a force value
  presb=((1.772*BackValue)-144.59);
  presc=((0.4118*ChestValue)-14.476);
  
  //send the two values to Ubidots
  upload(String(presb), S_BACK);
  upload(String(presc), S_CHEST);
}

//Function that do the request
void upload(String value, String VARIABLEID){
 
  Serial.println("Sending value to Ubidots...");
  LWiFiClient c;
  while (!c.connect(URL, 80))
  {
    Serial.println("Retrying to connect...");
    delay(100);
  }

  String data = "{\"value\":"+ value + "}";
  String thisLength = String(data.length());
  
  // Build HTTP POST request
  c.print("POST /api/v1.6/variables/");
  c.print(VARIABLEID);
  c.print("/values?token=");
  c.print(TOKEN);
  c.println(" HTTP/1.1");
  c.println("Content-Type: application/json");
  c.println("Content-Length: " + thisLength);
  c.print("Host: ");
  c.println(URL);
  c.print("\n" + data);
  c.print(char(26));

  while (c){
    Serial.print((char)c.read());
  } 
  c.stop();
}

//Programmers: Ciro Gamboa - Alix Angarita - Nelson Monroy
//test of vibration sensors with delta technique
const int frontSensor=A1;
const int backSensor=A2;
int frontValue=0,backValue=0;
//delta's assingment
int deltaFront,deltaBack;

//Inputs and outputs
void setup() { 
  pinMode(frontSensor, INPUT);  
  pinMode(backSensor, INPUT);
  
  Serial.begin(9600);
  }

void loop() {
  
  deltaFront=frontValue;
  deltaBack=backValue;
  
  frontValue = analogRead(frontSensor); 
  backValue = analogRead(backSensor); 
  
  deltaFront=deltaFront-frontValue;
  deltaBack=deltaBack-backValue;
  
   Serial.print("Front=");
   Serial.print(abs(deltaFront));
   Serial.print("\tBack=");
   Serial.println(abs(deltaBack));
   
  
   delay(100);
   
}

//Programmers: Ciro Gamboa - Alix Angarita - Nelson Monroy
//test of vibration sensors with delta technique and filters
const int frontSensor=A1;
const int backSensor=A2;
int frontValue=0,backValue=0;
//delta's assingment
int deltaFront,deltaBack;

//Inputs and outputs
void setup() { 
  pinMode(frontSensor, INPUT);  
  pinMode(backSensor, INPUT);
  
  Serial.begin(9600);
  }

void loop() {
  
  deltaFront=frontValue;
  deltaBack=backValue;
  
  frontValue = analogRead(frontSensor); 
  backValue = analogRead(backSensor); 
  
  deltaFront=abs(deltaFront-frontValue);
  deltaBack=abs(deltaBack-backValue);
  
  if(deltaFront>=150)//if greater, means that it was serious
  {
    Serial.print("IMPACT OF ");
    Serial.print(deltaFront);
    Serial.println(" ON THE FRONT!!");
  }
  
   if(deltaBack>=150)//if greater, means that it was serious
  {
    Serial.print("IMPACT OF ");
    Serial.print(deltaBack);
    Serial.println(" ON THE BACK!!");
  }
   
  
   delay(100);
   
}

//Programmers: Ciro Gamboa - Alix Angarita - Nelson Monroy
//test of deflexion sensors with delta technique and filters

const int rightSide = A1;//right side of the motorbike
const int leftSide = A2; //left side of the motorbike
int rightValue=0,lefValue=0;//getters
int deltaRight,deltaLeft;

//Pins..
void setup() { 
  pinMode(rightSide, INPUT);  
  pinMode(leftSide, INPUT);
  
  Serial.begin(9600);
  }

void loop() {
  
  deltaRight=rightValue;
  deltaRLeft=leftValue;
  
   rightValue = analogRead(rightSide); 
   leftValue = analogRead(leftSide);
  
  deltaRight = abs(deltaRight - rightValue);
  deltaleft = abs(deltaLeft - leftValue);
   
  if(deltaRight>5)//it flexed!!
  {
    Serial.println("THE MOTORBIKE TOUCH THE GROUND ON ITS RIGHT SIDE!!");
  }
  
  if(deltaLeft>5)//it flexed!!
  {
    Serial.println("THE MOTORBIKE TOUCH THE GROUND ON ITS LEFT SIDE!!");
  }
    delay(100);
}

#include <PinChangeInt.h>//library for setting the pulse-oximeters interruption 
#include <eHealth.h>// shield's library
int cont = 0;
void setup() {
  Serial.begin(115200);
  eHealth.initPulsioximeter();///initializes the sensor 
  PCintPort::attachInterrupt(6, readPulsioximeter, RISING);// setting the interruption
}
void loop() {
  Serial.print("PRbpm : "); 
  Serial.print(eHealth.getBPM());//the heart rate is obtained
  Serial.print("    %SPo2 : ");
  Serial.print(eHealth.getOxygenSaturation());//the oxygen's saturation   is obtained
  Serial.print("\n");
  Serial.println("=============================");
  delay(500);
}
//=========================================================================
void readPulsioximeter(){
  cont ++;
  if (cont == 50) { //Get only of one 50 measures to reduce the latency
    eHealth.readPulsioximeter();
    cont = 0;
  }
}

/*
  Wifi-GPS_Flex
  Nelson Monroy
  Ciro Gamboa
  Alix Angarita
 */
//Library inclusion
#include <LWiFi.h>
#include <LWiFiClient.h>
#include <LTask.h>
#include <LGPS.h>
#include<HardwareSerial.h>///librerias para la comunicación con el arduino
#include<UARTClass.h>///librerias para la comunicación con el arduino

//Wifi Network settings
#define WIFI_AP "network_name" //NETWORK NAME
#define WIFI_PASSWORD "network_password"//NETWORK PASSWORD
#define WIFI_AUTH LWIFI_WPA/// -> LWIFI_OPEN, LWIFI_WPA, or LWIFI_WEP.

//////Variables
char action[] = "POST ";
char server[]="things.ubidots.com";//ADDRESS IN UBIDOTS WHERE I UPLOAD DATA
char path[]= "/api/v1.6/variables/XXXXXXXXXXXXXX/values";///  XXXXXX INCLUDE VARIABLE SOURCE KEY
char path2[]= "/api/v1.6/variables/XXXXXXXXXXXXXX/values";/// 
char path3[]= "/api/v1.6/variables/XXXXXXXXXXXXXX/values";/// HELMET
char path4[]= "/api/v1.6/variables/XXXXXXXXXXXXXX/values";/// BIKE
char path5[]= "/api/v1.6/variables/XXXXXXXXXXXXXX/values";/// VEST
char token[]="E6RqUj6gnQ9b9oyeGaKLuvu5At0peb"; /// THE APIKEY .
int port =80,BPM,SPO2,dato; //PORT OF CONNECTION TO THE SERVER
int FH,BH,BF,CF;

int num;
uint32_t sensorBikeRight =A2;
uint32_t sensorBikeLeft =A1;
int sensorValueBikeRight= 0;  
int sensorValueBikeRight=0;
String le, thisLength;
String var;
String var2,var3,var4;
unsigned long ReportingInterval = 100;// TIME TO ACTUALIZE SAMPLING
String Location="";// THE LOCATION STRING IS SAVED


///////////////////////////// INSTANCIATION
LWiFiClient globalClient;
gpsSentenceInfoStruct info;

/////////////////////////////////
void setup() {
 ///////////////////////////////
 Serial.begin(19200);
 Serial1.begin(19200);
 
 LWiFi.begin();
 LTask.begin();
 LGPS.powerOn();
 
 /////////////////////////////// 
 Serial.println();
 Serial.print("Connecting to server");
 if(LWiFi.connectWPA(WIFI_AP,WIFI_PASSWORD)<0)
    {
      Serial.println("FAIL!");
      return;
    }
    Serial.println("OK");
  LWiFiClient client;
 globalClient=client;
 }
void loop() {
  ////obtencion del dato de moto 
  int deltamotoderecho=sensorValuemotoderecha;
  sensorValuemotoderecha=analogRead(sensormotoderecho);
  deltamotoderecho=abs(deltamotoderecho-sensorValuemotoderecha);
  
  int deltamotoizquierdo=sensorValuemotoizquierda;
  sensorValuemotoizquierda=analogRead(sensormotoizquierdo);
   deltamotoizquierdo=abs(deltamotoizquierdo-sensorValuemotoizquierda);
  
  if (globalClient.available()) {// if there are incoming bytes available from the server
    char c = globalClient.read();   // read them and print them:
    Serial.print(c);
  }
  pulsioximetria();
  String value1 = String (BPM);
  String value2 = String (SPO2);
  String value3= String(deltaBikeRight);
  String value4= String(deltaBikeLeft);

  LGPS.getData(&info);
  if (ParseLocation((const char*)info.GPGGA)) {  // This is where we break out needed location information
      Serial.print("Location is: ");
      Serial.println(Location);                 // This is the format needed by Ubidots
    }
   if (Location.length()==0) {
      var2="{\"value\":"+ value2 + "}";
      var3="{\"value\":"+ value3 + "}";
      var4="{\"value\":"+ value4 + "}";   
    }
    else {
      var="{\"value\":"+ value1 + ", \"context\":"+ Location + "}";  // with GPS info
      var2="{\"value\":"+ value2 + "}"; 
      var3="{\"value\":"+ value3 + "}";     
      var4="{\"value\":"+ value4 + "}";
    }
  num=var.length();               // How long is the payload
  le=String(num);
  thisLength = String(var2.length());
  Serial.print("Connect to ");    // For the console - show you are connecting
    Serial.println(server);
    if (globalClient.connect(server, port)){  // if you get a connection, report back via serial:
      Serial.println("connected");  // Console monitoring
      Serial.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      Serial.print(path);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      Serial.println(" HTTP/1.1");
      Serial.println(("Content-Type: application/json"));
      Serial.print(("Content-Length: "));
      Serial.println(le);
      Serial.print(("X-Auth-Token: "));
      Serial.println(token);
      Serial.print(("Host: "));
      Serial.println(server);
      Serial.println();
      Serial.println(var);  // The payload defined above
      Serial.println();
      ////envio de datos de gps
      Serial.println((char)26); //This terminates the JSON SEND with a carriage return
      globalClient.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      globalClient.print(path);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      globalClient.println(" HTTP/1.1");
      globalClient.println(("Content-Type: application/json"));
      globalClient.print(("Content-Length: "));
      globalClient.println(le);
      globalClient.print(("X-Auth-Token: "));
      globalClient.println(token);
      globalClient.print(("Host: "));
      globalClient.println(server);
      globalClient.println();
      globalClient.println(var);  // The payload defined above
      globalClient.println();
      globalClient.println((char)26); //This terminates the JSON SEND with a carriage return
    }
    //envio datos spo
    if (globalClient.connect(server, port)){      
      Serial.println("SPO:"+ var2);
      Serial.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      Serial.print(path2);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      Serial.println(" HTTP/1.1");
      Serial.println(("Content-Type: application/json"));
      Serial.print(("Content-Length: "));
      Serial.println(thisLength);
      Serial.print(("X-Auth-Token: "));
      Serial.println(token);
      Serial.print(("Host: "));
      Serial.println(server);
      Serial.println();
      Serial.println(var);  // The payload defined above
      Serial.println();
      globalClient.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      globalClient.print(path2);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      globalClient.println(" HTTP/1.1");
      globalClient.println(("Content-Type: application/json"));
      globalClient.print(("Content-Length: "));
      globalClient.println(thisLength);
      globalClient.print(("X-Auth-Token: "));
      globalClient.println(token);
      globalClient.print(("Host: "));
      globalClient.println(server);
      globalClient.println();
      globalClient.println(var2);  // The payload defined above
      globalClient.println();
      globalClient.println((char)26);
    }
    //envio datos moto
    if (globalClient.connect(server, port)){      
      Serial.println("SHOCK ON THE RIGHT:"+ var3);
      Serial.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      Serial.print(path3);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      Serial.println(" HTTP/1.1");
      Serial.println(("Content-Type: application/json"));
      Serial.print(("Content-Length: "));
      Serial.println(thisLength);
      Serial.print(("X-Auth-Token: "));
      Serial.println(token);
      Serial.print(("Host: "));
      Serial.println(server);
      Serial.println();
      Serial.println(var3);  // The payload defined above
      Serial.println();
      globalClient.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      globalClient.print(path3);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      globalClient.println(" HTTP/1.1");
      globalClient.println(("Content-Type: application/json"));
      globalClient.print(("Content-Length: "));
      globalClient.println(thisLength);
      globalClient.print(("X-Auth-Token: "));
      globalClient.println(token);
      globalClient.print(("Host: "));
      globalClient.println(server);
      globalClient.println();
      globalClient.println(var3);  // The payload defined above
      globalClient.println();
      globalClient.println((char)26);
    }
    //envio datos moto
    if (globalClient.connect(server, port)){      
      Serial.println("SHOCK ON THE LEFT:"+ var4);
      Serial.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      Serial.print(path4);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      Serial.println(" HTTP/1.1");
      Serial.println(("Content-Type: application/json"));
      Serial.print(("Content-Length: "));
      Serial.println(thisLength);
      Serial.print(("X-Auth-Token: "));
      Serial.println(token);
      Serial.print(("Host: "));
      Serial.println(server);
      Serial.println();
      Serial.println(var4);  // The payload defined above
      Serial.println();
      globalClient.print(action);                   // These commands build a JSON request for Ubidots but fairly standard
      globalClient.print(path4);                     // specs for this command here: http://ubidots.com/docs/api/index.html
      globalClient.println(" HTTP/1.1");
      globalClient.println(("Content-Type: application/json"));
      globalClient.print(("Content-Length: "));
      globalClient.println(thisLength);
      globalClient.print(("X-Auth-Token: "));
      globalClient.println(token);
      globalClient.print(("Host: "));
      globalClient.println(server);
      globalClient.println();
      globalClient.println(var4);  // The payload defined above
      globalClient.println();
      globalClient.println((char)26);
    }
}

boolean ParseLocation(const char* GPGGAstr)
// Refer to http://www.gpsinformation.org/dale/nmea.htm#GGA
// Sample data: $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47
{
  char latarray[6];
  char longarray[6];
  int index = 0;
  Serial.println(GPGGAstr);
  Serial.print("Fix Quality: ");
  Serial.println(GPGGAstr[43]);
  if (GPGGAstr[43]=='0') {        //  This is the place in the sentence that shows Fix Quality 0 means no fix
    Serial.println("No GPS Fix");
    Location = "";           // No fix then no Location string
    return 0;
  }
  String GPSstring = String(GPGGAstr);
  for (int i=20; i<=26; i++) {         // We have to jump through some hoops here
    latarray[index] = GPGGAstr[i];     // we need to pick out the minutes from the char array
    index++;
  }
  float latdms = atof(latarray);        // and convert them to a float
  float lattitude = latdms/60;          // and convert that to decimal degrees
  String lattstring = String(lattitude,10);// Then put back into a string
  Location = "{\"lat\":";
  if(GPGGAstr[28] == 'S') Location = Location + "-";
  Location += GPSstring.substring(19,20) + "." + lattstring.substring(2,12);
  index = 0;
  for (int i=33; i<=38; i++) {         // And do the same thing for longitude
    longarray[index] = GPGGAstr[i];     // the good news is that the GPS data is fixed column
    index++;
  }
  float longdms = atof(longarray);        // and convert them to a float
  float longitude = longdms/60;          // and convert that to decimal degrees
  String longstring = String(longitude,8);// Then put back into a string
  Location += " ,\"lng\":";
  if(GPGGAstr[41] == 'W') Location = Location + "-";
  if(GPGGAstr[30] == '0') {
    Location = Location + GPSstring.substring(31,33) + "." + longstring.substring(2,12) + "}";
  }
  else {
    Location = Location + GPSstring.substring(30,33) + "." + longstring.substring(2,12) + "}";
  }
  return 1;
}

//Programmers: Nelson Monroy-Alix Angarita-Ciro Gamboa
void pulsioximetria()
{
  if(Serial1.available())
  {
  dato=Serial1.read();
  }
  switch(dato)
  {
    case 1:
    Serial.println("Beats per minute:");
    Serial.println(BPM);
    BPM=Serial1.read();//I get the heart rate
    dato=0;
    break;
    case 2:
    Serial.println("Blood's oxygen:");
    Serial.println(SPO2);
    SPO2=Serial1.read();//I get the oxygen saturation
    dato=0;
    break;
  }
}

Credits

Comments

Awards

Second Prize

LinkIt ONE: Smart Devices for Smart Cities

Longer Life For Drivers

Things used in this project

Hardware components

Software apps and online services

Story

Welcome to Longer Life For Drivers

1. Making the LLFD-Vest

2. Preparing the LLFD-Bike

How was it made?

3. Making the LLFD-Helmet

How was it made?

4. Getting data from the body

How was it made?

5. Mixing some parameters

Schematics

Flex sensors connection to Linkit One

Code

Analog input from vest V1.0

Analog input from vest V1.1 (Sending to Ubidots)

Vibration with delta

Vibration with delta and filters

Motorcycle deflexion

Use of pulse-oximeter

Pulse-oximeter, GPS,Flex, Ubidots

GPS settings

The little big function

Credits

Álix A.

Nelson Fernando Monroy Rios

Ciro Alberto Gamboa

Sergio Alexander Salinas

Comments

Awards

Embed the widget on your own site

Longer Life For Drivers

Longer Life For Drivers

Things used in this project

Hardware components

Software apps and online services

Story

Welcome to Longer Life For Drivers

1. Making the LLFD-Vest

2. Preparing the LLFD-Bike

How was it made?

3. Making the LLFD-Helmet

How was it made?

4. Getting data from the body

How was it made?

5. Mixing some parameters

Schematics

Flex sensors connection to Linkit One

Code

Analog input from vest V1.0

Analog input from vest V1.1 (Sending to Ubidots)

Vibration with delta

Vibration with delta and filters

Motorcycle deflexion

Use of pulse-oximeter

Pulse-oximeter, GPS,Flex, Ubidots

GPS settings

The little big function

Credits

Álix A.

Nelson Fernando Monroy Rios

Ciro Alberto Gamboa

Sergio Alexander Salinas

Comments

Awards

Related channels and tags