Plugging the FTDI Cable into the ESP8266

An FTDI cable is plugged into the end of the Adafruit Huzzah ESP8266. Make sure you align the GND pin on the FTDI Cable with the GND pin on the ESP8266 breakout board as shown in Figure 5-6.

Figure 5-6. FTDI Cable Plugged into the Huzzah Board. Note GND Connection

Table 5-3 contains the wiring list for the IOTPulse project.

IOTPulse.ino

IOTPulse.ino is the main program for IOTPulse (Listing 5-2). It consists of two major functions, setup() and loop() . The setup() function initializes the ESP8266 WiFi code, reads an IP address using DCHP from the local wireless access point, and initializes variables for containing micros(), which is a function returning the number of microseconds since the reboot of the ESP8266 micros() is a timekeeping function. Note that the ESP8266 does not have a real-time clock on board and really doesn’t know what time it is. It only knows how long it has been running. If you wish to set the time of day in the ESP8266, please check out the NTP protocol in this Instructable[ http://www.instructables.com/id/Internet-time-syncronized-clock-for-Arduino/ ].

In the IOTPulse project, we really don’t care what time it is. When we send a sample to the Bluemix IOT Platform, our friend IBM will timestamp the reception of the data. If we cared about our time, we could build an NTP receiver and synchronize it to network time at a specific NTP server. We are much more interested in intervals of time (specifically 2 milliseconds and 10 seconds intervals) rather than absolute time.

The loop() function contains the code for ongoing operation of the IOTPulse data-gathering operation. We basically do four things in the loop() function:

• We check the value of QS. If QS is true, then the software in Interrupt.h has found a BPM (Beats Per Minute) and IBI (Interval Between beats) value for the current pulse rate for our PulseSensor connected to your ear.

• Next, if 10 seconds have elapsed (10,000,000 microseconds), we send the current value of BPM and IBI up to the IBM Bluemix IOT cloud. We then reset the time to wait for the next 10-second interval, which is stored in the oldIOTTime variable. The actual time for the next interval is oldIOTTime + 10 seconds (10,000,000 microseconds) .

• If 2 milliseconds have elapsed since oldPulseTime variable (initialized in loop()), we call the timerCallback() function defined in Interrupt.h. We then reset the oldPulseTime variable and wait for another 2ms.

Note at the end of the loop() function, there is a yield() function. This MUST be called periodically for the ESP8266 software to continue running the WiFi interface and other housekeeping functions. Remember, unlike a regular Arduino, there is a great deal going on in the background to keep this chip running and connected to the network.

One limitation of the current ESP8266 software is that you can’t use the timers [ http://www.switchdoc.com/2015/10/iot-esp8266-timer-tutorial-arduino-ide/ ] to generate interrupts without causing the WiFi to fail and stop connecting to the local WiFI access point and the Internet.

This makes it very difficult to generate an interrupt to the computer every 2ms as is called for by the PulseSensor. You could generate an interrupt every 2ms by using an external hardware timer and then connecting the output of the hardware timer to one of the GPIO pins on the ESP8266, which can all be programmed to generate an interrupt to the CPU.

To solve this issue, we use a scheduling technique that is more CPU intensive (read uses more power) than the interrupt scheme. We check the time periodically and run the PulseSensor software every 2ms and also connect to the IBM Bluemix every 10 seconds.

The biggest disadvantage of this is that we cannot “sleep” the processor very easily. We are looking for an alternative architecture for this problem and are watching the ESP8266 development web sites for solutions.

However, with the exception of power consumption, the current solution works well.

Listing 5-2. IOTPulse.ino

/*
    SwitchDoc Labs Code for IOT Pulse
    Connects Pulse detector to the IBM Bluemix IoT using a ESP8266 processor
    based on pulsecounting code from www.pulsesensor.com
    November 2015

  ----------------------  Notes ----------------------  ----------------------
  This code:
  1) Blinks an LED to User's Live Heartbeat   PIN 0

  2) Determines BPM

  3) Sends information to the IBM Bluemix IOT
*/

extern "C" {
#include "user_interface.h"
}
#include <ESP8266WiFi.h>
#include <PubSubClient.h> // https://github.com/knolleary/pubsubclient/releases/tag/v2.3

//----------------------------------------------------------------------
//Local WiFi Variables

const char* ssid = "yourssid";
const char* password = "yourpassword";

#define IOTPULSEVERSION 004

// IBM BlueMix IOT Foundation Data

#define ORG "XXXXX"
#define DEVICE_TYPE "IOTPulse-01"
#define DEVICE_ID "1"
#define TOKEN "YYYYYYYYY"

// setup for IOT IBM

char server[] = ORG ".messaging.internetofthings.ibmcloud.com";
char topic[] = "iot-2/evt/status/fmt/json";
char authMethod[] = "use-token-auth";
char token[] = TOKEN;
char clientId[] = "d:" ORG ":" DEVICE_TYPE ":" DEVICE_ID;

//----------------------------------------------------------------------

//  Variables
int pulsePin = A0;                  // Pulse Sensor purple wire connected to analog pin 0
int blinkPin = 0;                   // pin to blink led at each beat
int fadePin = 5;                    // pin to do fancy classy fading blink at each beat
int fadeRate = 0;                   // used to fade LED on with PWM on fadePin

// Volatile Variables, used in the interrupt service routine!
volatile int BPM;                   // int that holds raw Analog in 0. updated every 2mS
volatile int Signal;                // holds the incoming raw data
volatile int IBI = 600;             // int that holds the time interval between beats! Must be seeded!
volatile boolean Pulse = false;     // "True" when User's live heartbeat is detected. "False" when not a "live beat".
volatile boolean QS = false;        // becomes true when Arduoino finds a beat.

// Regards Serial OutPut  -- Set This Up to your needs
static boolean serialData = true;   // Set to 'false' by Default.  Re-set to 'true' to see Arduino Serial Monitor data

#include "AllSerialHandling.h"
#include "Interrupt.h"

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.println("callback invoked from IOT BlueMix");
}

WiFiClient wifiClient;
PubSubClient client(server, 1883, callback, wifiClient);

unsigned long oldPulseTime;
unsigned long oldIOTTime;

void setup() {

  pinMode(blinkPin, OUTPUT);        // pin that will blink to your heartbeat!

  Serial.begin(115200);             // we agree to talk fast!

  Serial.println("----------------");
  Serial.println("IOTPulse IBM Bluemix IOT");
  Serial.println("----------------");

  Serial.print("Connecting to ");
  Serial.print(ssid);

  // NOTE below:  Newer versions of the ESP8266 Libraries may require the following statement
  // instead of the other statement.  WiFi.SSID() has changed definitions in new versions
  // if (strcmp (WiFi.SSID().c_str(), ssid) != 0) {

  if (strcmp (WiFi.SSID(), ssid) != 0) {
    WiFi.begin(ssid, password);
  }
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");

  Serial.print("Local WiFi connected, IP address: ");
  Serial.println(WiFi.localIP());

  // interruptSetup();                 // sets up to read Pulse Sensor signal every 2mS
  // Note:  Interrupts based on os_timer seems to break the ESP8266 WiFi.  Moving to micros() polling methodology
  oldPulseTime = micros();
  oldIOTTime = micros();
}

int sampleCount = 0;
int beatCount = 0;

int beatValue = 0;
unsigned long newPulseDeltaTime;
unsigned long newIOTDeltaTime;

//  Where the Magic Happens
void loop() {

  //serialOutput() ;

  if (QS == true) {    // A Heartbeat Was Found
    // BPM and IBI have been Determined
    // Quantified Self "QS" true when arduino finds a heartbeat
    digitalWrite(blinkPin, LOW);    // Blink LED, we got a beat.
    beatCount++;

    serialOutputWhenBeatHappens();   // A Beat Happened, Output that to serial.
    QS = false;                     // reset the Quantified Self flag for next time
  }

  newPulseDeltaTime = micros() - oldPulseTime; // doing this handles the 71 second rollover because of unsighned arithmetic

  newIOTDeltaTime = micros() - oldIOTTime; // doing this handles the 71 second rollover because of unsighned arithmetic

  // do this every ten seconds
  if (newIOTDeltaTime > 10000000)  // check for 10sec work to be done
  {

    Serial.print("IOT Delta time =");
    Serial.println(newIOTDeltaTime);
    sampleCount++;

    // Sending payload: {"d":{"IOTPulse":"IP1","VER":2"SC":0,"BPM":235,"IBI":252}}

    String payload = "{"d":{"IOTPulse":"IP1",";
    payload += ""VER":";
    payload += IOTPULSEVERSION;
    payload += ","SC":";
    payload += sampleCount;
    payload += ","BPM":";
    payload += BPM;
    payload += ","IBI":";
    payload += IBI;
    payload += ","BC":";
    payload += beatCount;
    payload += "}}";

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

    Serial.print("Sending IOTPulse payload: ");
    Serial.println(payload);

    if (client.publish(topic, (char*) payload.c_str())) {
      Serial.println("BlueMix IOT Publish ok");
    } else {
      Serial.println("BlueMix IOT Publish failed");
    }
    oldIOTTime = micros();

    // restart the pulse counter
    restartPulse();
  }

  //Serial.print("micros()=");
  //Serial.println(micros());

  if (newPulseDeltaTime > 2000)  // check for 2ms work to be done
  {

    //Serial.print("Pulse Delta time =");
    //Serial.println(newPulseDeltaTime);
    // do the work for pulse calculation
    timerCallback(NULL);

    oldPulseTime = micros();
  }

  yield(); //  take a break
}

AllserialHandling.h (Listing 5-3) contains the serial output debugging routines that are useful when modifying the code.

Listing 5-3. AllSerialHandling.h

//////////
/////////  All Serial Handling Code,
/////////  It's Changeable with the 'serialVisual' variable
/////////  Set it to 'true' or 'false' when it's declared at start of code.
/////////

void sendDataToSerial(char symbol, int data );                                                                                                              

void serialOutput() {  // Decide How To Output Serial.

    sendDataToSerial('S', Signal);     // goes to sendDataToSerial function
}

//  Decides How To OutPut BPM and IBI Data
void serialOutputWhenBeatHappens() {
  if (serialData == true) {           //  Code to Make the Serial Monitor Visualizer Work
    Serial.print("*** Heart-Beat Happened *** ");  //ASCII Art Madness
    Serial.print("BPM: ");
    Serial.print(BPM);
    Serial.print(" IBI: ");
    Serial.print(IBI);
    Serial.println("  ");
  }
}

//  Sends Data to Pulse Sensor Processing App, Native Mac App, or Third-party Serial Readers.
void sendDataToSerial(char symbol, int data ) {
  Serial.print(symbol);

  Serial.println(data);
}

Interrupt.h (Listing 5-4) is called this because the original PulseSensor software used an Arduino timer to generate a 2ms interrupt. As is explained above, the ESP8266 is not currently capable of doing the same thing while maintaining a functional WiFi interface. The function timerCallback() in Interrupt.h is now called at a scheduled time by the loop() function in the IOTPulse.ino file.

Basically, timerCallback() acts as a detector and averaging filter that detects the upswing on the PulseSensor output and then builds a set of times for IBI (Interval Between beats) and provides an average. It adjusts to the recorded levels coming from the PulseSensor because the actual level is not as important as the time interval between adjusted pulses from the PulseSensor. The software acts as a peak and trough detector with an average system that removes high-frequency noise.

Listing 5-4. Interrupt.h

volatile int rate[10];                    // array to hold last ten IBI values
volatile unsigned long sampleCounter = 0;    // used to determine pulse timing
volatile unsigned long lastBeatTime = 0;     // used to find IBI
volatile int P = 680;                     // used to find peak in pulse wave, seeded 512
volatile int T = 680;                     // used to find trough in pulse wave, seeded 512
volatile int thresh = 700;                // used to find instant moment of heart beat, seeded 525
volatile int amp = 100;                   // used to hold amplitude of pulse waveform, seeded
volatile boolean firstBeat = true;        // used to seed rate array so we startup with reasonable BPM
volatile boolean secondBeat = false;      // used to seed rate array so we startup with reasonable BPM

void restartPulse()
{

  sampleCounter = 0;          // used to determine pulse timing
  lastBeatTime = 0;           // used to find IBI
  P = 680;                    // used to find peak in pulse wave, seeded 512
  T = 680;                    // used to find trough in pulse wave, seeded 512
  thresh = 700;               // used to find instant moment of heart beat, seeded 525
  amp = 100;                  // used to hold amplitude of pulse waveform, seeded
  firstBeat = true;           // used to seed rate array so we startup with reasonable BPM
  secondBeat = false;

}
void timerCallback(void *pArg);

// Timer  makes sure that we take a reading every 2 miliseconds
void timerCallback(void *pArg) {              // triggered on interrupts
  //cli();                                    // disable interrupts while we do this
  Signal = analogRead(pulsePin);              // read the Pulse Sensor
  //Serial.print("Signal-A0-:");
  //Serial.println(Signal);

  sampleCounter += 2;                         // keep track of the time in mS with this variable
  int N = sampleCounter - lastBeatTime;       // monitor the time since the last beat to avoid noise

  //  find the peak and trough of the pulse wave
  if (Signal < thresh && N > (IBI / 5) * 3) { // avoid dichrotic noise by waiting 3/5 of last IBI
    if (Signal < T) {                         // T is the trough
      T = Signal;                             // keep track of lowest point in pulse wave
    }                                                                                                              
  }

  if (Signal > thresh && Signal > P) {        // thresh condition helps avoid noise
    P = Signal;                               // P is the peak
  }                                           // keep track of highest point in pulse wave

  //  NOW IT'S TIME TO LOOK FOR THE HEART BEAT
  // signal surges up in value every time there is a pulse
  if (N > 250) {                             // avoid high frequency noise
    if ( (Signal > thresh) && (Pulse == false) && (N > (IBI / 5) * 3) ) {
      Pulse = true;                          // set the Pulse flag when we think there is a pulse
      digitalWrite(blinkPin, LOW);           // turn on  LED
      IBI = sampleCounter - lastBeatTime;    // measure time between beats in mS
      lastBeatTime = sampleCounter;          // keep track of time for next pulse

      if (secondBeat) {                      // if this is the second beat, if secondBeat == TRUE
        secondBeat = false;                  // clear secondBeat flag
        for (int i = 0; i <= 9; i++) {       // seed the running total to get a realisitic BPM at startup
          rate[i] = IBI;
        }
      }

      if (firstBeat) {                       // if it's the first time we found a beat, if firstBeat == TRUE
        firstBeat = false;                   // clear firstBeat flag
        secondBeat = true;                   // set the second beat flag
        //sei();                             // enable interrupts again
        return;                              // IBI value is unreliable so discard it
      }

      // keep a running total of the last 10 IBI values
      word runningTotal = 0;                 // clear the runningTotal variable

      for (int i = 0; i <= 8; i++) {         // shift data in the rate array
        rate[i] = rate[i + 1];               // and drop the oldest IBI value
        runningTotal += rate[i];             // add up the 9 oldest IBI values
      }

      rate[9] = IBI;                         // add the latest IBI to the rate array
      runningTotal += rate[9];               // add the latest IBI to runningTotal
      runningTotal /= 10;                    // average the last 10 IBI values
      BPM = 60000 / runningTotal;            // how many beats can fit into a minute? that's BPM!
      // reduce to 83% based on comparison
      BPM= (BPM * 83)/100;
      QS = true;                             // set Quantified Self flag
      // QS FLAG IS NOT CLEARED INSIDE THIS ISR
    }
  }                                                                                                              

  if (Signal < thresh && Pulse == true) {  // when the values are going down, the beat is over
    digitalWrite(blinkPin, HIGH);          // turn off pin 13 LED
    Pulse = false;                         // reset the Pulse flag so we can do it again
    amp = P - T;                           // get amplitude of the pulse wave
    thresh = amp / 2 + T;                  // set thresh at 50% of the amplitude
    P = thresh;                            // reset these for next time
    T = thresh;
  }

  if (N > 2500) {                          // if 2.5 seconds go by without a beat
    thresh = 512;                          // set thresh default
    P = 512;                               // set P default
    T = 512;                               // set T default
    lastBeatTime = sampleCounter;          // bring the lastBeatTime up to date
    firstBeat = true;                      // set these to avoid noise
    secondBeat = false;                    // when we get the heartbeat back
  }

  //sei();                                 // enable interrupts when youre done!
}// end isr

MQTT

MQTT is a publish-subscribe-based "light weight" messaging protocol for use on top of the TCP/IP protocol, such as the WiFi packets that we are using in this project. It is designed for connections with remote locations where a "small code footprint" is required or the network bandwidth is limited. Both of these conditions are met with an ESP8266 IOT design, so it makes sense to use. There is also an excellent library available for MQTT for the Arduino IDE [ https://github.com/knolleary/pubsubclient ]. The publish-subscribe messaging pattern requires a message broker. The broker is responsible for distributing messages to interested clients based on the topic of a message (Figure 5-13) .

Figure 5-13. MQTT Publish-Subscribe Protocol

Publish-subscribe is a pattern where senders of messages, called publishers (in this case our ESP8266 is the publisher), don't program the messages to be sent directly to subscribers, but instead characterize message payloads into classes without the specific knowledge of which subscribers the messages are sent to. Similarly, subscribers (the IBM Bluemix IOT in this case) will only receive messages that are of interest without specific knowledge of which publishers there are. The IBM Bluemix operates as the broker in this system and routes the published data to the appropriate subscribers inside of Bluemix.

JSON Data Payload

JSON is an open standard format that uses human-readable text to transmit data objects consisting of attribute–value pairs. It is the primary data format used for asynchronous browser/server communication, largely replacing XML. XML is a "heavier" protocol that is also hierarchical in nature, but with a great deal more redundancy that JSON. Yes, there are class wars going on for people that advocate JSON over XML, but in today’s world of higher speed communication, it rarely matters. You can make the argument that the higher data density of JSON is a better choice for IOT applications.

Here is an example of the data packet we are using in the ESP8266 Bluemix code in JSON for the LightSwarm data payload:

{"d":
      {
         "LightSwarm IOT":"LS1",
         "sampleCount":2118,
         "lightValue":383                                                                                                                          
      }
}

Authentication

We need to have a secure method of authenticating that our ESP8266 device is allowed to put data into the right slots inside the IBM Bluemix. This is done in our case by exchanging a cryptographic token that was generated by Bluemix and included in our ESP8266 code.

To do this we need to go back to the Bluemix account that you set up in the previous posting and complete the following steps:

1. Click the Internet of Things Foundation icon on the Bluemix dashboard.

2. Next, click the Launch dashboard button under “Connect your devices” (Figure 5-14).

   

   Figure 5-14. Connect your Devices to Bluemix

3. Go to the Devices Tab and “Add Device” down at the bottom of the page.

4. Click “Create Device Type,” and the screen in Figure 5-15 appears .

   

   Figure 5-15. Create Bluemix Device Type

We would suggest you use IOTPulse-01 for the name of the device type.

Move through the rest of the steps. There are many configuration options that nearly all can be left blank in our current application. You are required to have a device type and a device ID.

When the device has been created, you’ll see the Device Credentials page. Be sure to save those details, as they are used to authenticate your ESP8266 Arduino IDE sketch in in the next step (we have not found any way of recovering these credentials from the Bluemix system). Obviously, don't use the credentials in Figure 5-16. They will not work. You need to create your own.

Figure 5-16. Bluemix Credential Screen

Adding Real-Time Insights

Step 1: Add the IoT Real-Time Insights service to your Bluemix dashboard. Open the Bluemix dashboard (the first dashboard after login) and click “USE SERVICES OR APIS” and add the IoT Real-time Insights as a service. It is way down at the bottom of the page. You will then see the screen in Figure 5-17.

Figure 5-17. IoT Real-Time Insights

Step 2: Connect our device to the IoT Real-Time Insights Page by generating an API key and then generating a data source. Click the IoT Real-Time Insights block shown in Figure 5-16.

Step 3: Generate the API keys for using the Data Source and create API keys to connect the two services (IoT Foundation and IoT Real-Time Display):

1. From the Bluemix dashboard, click the Internet of Things tile.

2. Click Launch dashboard to open the Internet of Things Foundation dashboard.

3. Navigate to Access > API Keys.

4. Click Generate API Key.

5. Make a note of the API Key, Authentication Token, and the Organization ID that is displayed at the top of the IoT Foundation dashboard. You use this information in IoT Real-Time Insights to connect the services. These keys will remain displayed in the data source.

Adding the Data Source

Adding the data source (our IOTPulse device) consists of the following (Figure 5-18):

Figure 5-18. Adding the Data Source

1. Go to Devices > Manage Schemas and click Add new message schema.

2. Enter a name for the message schema: for example, IOTMessageSchema.

3. Click Link new data source and select the data source and device type that corresponds to your IoT Foundation instance and device. Event types for your device are here.

4. Add one or more data points that you want to include in the device dashboards (sampleCount and lightValue in our example).

5. The available data points are defined in the JSON payload of the messages that are sent by a device.

6. Click Select from connected device.

7. In the Add data points dialog, select one or more data points to add, and then click OK.

8. The selected data points are added with the description set to the name of the data point.

9. Then click the green arrow (on the left side of the screen) to save the information and create the data source .

Once all of the configuration data is in place and the authentication information is in place in the IOTPulse program, data should start to flow as shown in Figure 5-19.

Figure 5-19. IOT Data Starts to Flow

Now we add the displays to visualize our data.

Adding the Dashboard to the IoT Real-Time Display

From the screen in Figure 5-20, click Launch IoT Real-Time Insights Dashboard in the lower right-hand column.

Figure 5-20. IoT Real-Time Insights

Click dashboard and browse dashboards. Add a new dashboard. Then do the following:

1. Add new component;

2. Select chart;

3. Add line to the chart;

4. Select your device and then select lightValue as the parameter;

5. Click the green arrow.

Figure 5-21 shows the IBM BlueMix screen for laying out your dashboard interface.

Figure 5-21. Building your IoT Real-TimeDashboard

If your ESP8266 is running and sending data up to the IBM Bluemix IOT, then you will see the values start to populate the graph, as shown in Figure 5-22.

Figure 5-22. Bluemix IoT Real-Time Dashboard Operational