Published October 6, 2015

IoT Refrigerator Tracker

An IoT device used to monitor when a refrigerator is opened. Great for tracking when you are snacking or to catch pesky thieves!

BeginnerFull instructions provided2,553

Things used in this project

Story

Have you ever found yourself mindlessly snacking not even realizing what, or how frequently you are eating? Even worse, have you ever had something in the fridge that you are excited to eat and when you go to take it out you realize someone else already beat you to it?

Consider these problems of the past with this new refrigerator alarm. By utilizing the Texas Instruments Launchpad, CC3100 WiFi BoosterPack, Educational BoosterPack MKII, and services provided by Temboo, we will be able to track every time the refrigerator is opened and document it to a spreadsheet on google drive.

Getting Temboo and Google Talking:

The first step in getting our refrigerator monitor up and running is to register for a Temboo account. Temboo is a service that makes interacting with many APIs seamless and is great for IoT development. For more depth on getting set up with Temboo, check out this other project. For our refrigerator monitor, we will be using the Google spreadsheet API which can be found by navigating to "Google" on the left pane and selecting "Spreadsheets". In order to use this, and any, Google Choreos, there a few steps to set up OAuth so that Temboo can talk to the Google API. The steps for setting up OAuth are found on the Spreadsheets Choreo page (this requires a google account). Make sure to take note of the ClientID, ClientSecret, and RefreshToken as you need all of these in the next step.

Instructions for getting OAuth set up

Create the Google Spreadsheet:

In the same Google account used to set up the API, navigate to the Google Drive page. Create a new Google Sheet and give it a title that is easy to remember (you are going to need it later). Go ahead and open up the spreadsheet so we can make a few changes. We are going to be using the AppendRow Choreo which adds information below the last full row using comma separated values and inserting information into only columns that have a title. Because of this, we want to go ahead and set up our column titles so we know what our imported data is. For This example, we import a timestamp using epoch time (more about this later) in the first column and the LUX (measurement of light) value read by the sensor in the second column. One last step to make sure the timestamp works correctly is to select the whole first column by clicking the letter 'A'. Go to Format --> Number and select "Date Time". This will cause google to change the imported epoch time value into a readable date and time. Now the spreadsheet is ready to receive data and should look something like the image below.

Example empty Google Sheet

Getting The Choreo Running:

After finishing up the OAuth portion and spreadsheet set up, it is time to get our Choreo talking to Google. Navigate to the AppendRow Choreo from the Spreadsheets Choreo page. Fill in all the information obtained when running through the OAuth section. For "RowData", you can enter a place holder so that it can be edited in code later with the timestamp and LUX values. "SpreadsheetTitle" has to match the spreadsheet that we created in the previous section. Go ahead and try and run the Choreo. You should get a "success" return at this point and see the spreadsheet update with whatever was in "RowData". If it did not work, it is most likely an issue with the OAuth process that can be solved by running through the steps again. Once we have successfully run the Choreo on the web, it is time to get it set up on the LaunchPad.

AppendRow Choreo Page

Coding the LaunchPad:

At this point, Temboo provides us the base code to append a row to an existing spreadsheet. This takes a lot of the work out of setting up the API, but the fun of actually using Temboo to solve a problem still remains. In order to create this refrigerator monitor we are going to be using the OPT3001 optical sensor on the Educational BoosterPack and we are also going to be using multi tasking which is new on the MSP432. Multi tasking allows us to have to individual sketches running simultaneously on the same launchpad and even lets them interact with each other. In this case we are going to have one tab called fridgeAlarm which is set up to monitor the optical sensor and append a row to the Google sheet on an event trigger. The other tab, called epochTime, is going to use WiFi to ping a time server and return the current time in epoch time. Epoch time is simply the number of seconds that has passed since January 1, 1970. More information can be found here.

fridgeAlaram:

The code below, called fridgeAlarm.ino, is the main function of the multi tasked program. It initializes all of the variables and sets up the WiFi connection as well as the optical sensor. Go ahead and download then open the code, or copy and paste it into a blank Energia sketch. Read through it and compare it to the code provided on the Temboo site. The code is very similar with a few exceptions such as allowing the optical sensor to trigger the event and actually setting up the data to be appended to the spreadsheet.

The maxLux value may need to be changed based on how bright your refrigerator light is. Make sure that it doesn't trigger when it is closed and it does trigger when it is open! A value of 100 should be okay as long as the optical sensor is exposed to the light bulb.

Line 86 begins a block of variables that you will need to fill in using the values provided by the Temboo AppendRow Choreo page. The lines that need to be changed are clarified with an "Edit Needed" commented along side.

Line 90 actually does the math on the epoch time to convert it to a value that google can use. Notice the variable timeZoneShift declared at the top of the page. This needs to be changed to match your difference from GMT (I used -5 to for CDT).

epochTime:

Now it is time to initialize the second task called epochTime. First, create a new tab in the Energia sketch as shown below.

Creating a new tab in Energia

Rename the tab epochTime to keep everything straight as seen below:

Naming the new tab

Now we should have two separate tabs that can run side by side! Copy the code listed below under epochTime.ino and paste it into this new tab. This code shouldn't need any changes, but if the time server is down the IP address can be changed to a different server. A list of servers can be found here.

TembooAccount.h:

Temboo uses a library to fill in your account information and communicate with your LaunchPad. Make sure to copy TembooAccount.h to where your local Energia libraries are stored prior to trying to run the code. Another example can be found here.

After getting both tabs set up the code should be ready to run! Flash your LaunchPad and set up your alarm in the refrigerator and every time someone opens it and the optical sensor triggers an event, a row will be appended to the google spreadsheet containing the time that the refrigerator was opened as well as the LUX value detected when the refrigerator was opened. No more night time pests stealing all your favorite leftovers!

Refrigerator Monitor is up and running!

#include <SPI.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <Wire.h>			// Needed by Energia for Tiva C LaunchPad 
#include "OPT3001.h"
#define USE_USCI_B1
#include <Temboo.h>
#include "TembooAccount.h" // Contains Temboo account information


unsigned long epoch; //Variable created to hold epoch time, used for the timestamp in google drive
opt3001 opt3001; //Declare the optical sensor on the Educational booster pack
WiFiClient client;

// The number of times to trigger the action if the condition is met
// We limit this so you won't use all of your Temboo calls while testing
int maxCalls = 10; //Change this value if you want the code to run indefinitely

// The number of times this Choreo has been run so far in this sketch
int calls = 0;

unsigned int readings = 0;
int maxLUX = 100; //Value used to determine which lux values trigger the choreo
int timeZoneShift = -5; //number of hours difference from GMT
void setup() {
  Serial.begin(9600);
  opt3001.begin();//initialize the optical sensor
  int wifiStatus = WL_IDLE_STATUS;

  // Determine if the WiFi Shield is present
  Serial.print("\n\nShield:");
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("FAIL");

    // If there's no WiFi shield, stop here
    while(true);
  }

  Serial.println("OK");

  // Try to connect to the local WiFi network
  while(wifiStatus != WL_CONNECTED) {
    Serial.print("WiFi:");
    wifiStatus = WiFi.begin(WIFI_SSID, WPA_PASSWORD);

    if (wifiStatus == WL_CONNECTED) {
      Serial.println("OK");
    } else {
      Serial.println("FAIL");
    }
    delay(5000);
  }

  // Initialize pins

  Serial.println("Setup complete.\n");
}

void loop() {
  //read from the optical sensor
  readings = opt3001.readResult();
  Serial.print("Lux Readings: ");
  Serial.println(readings,DEC);

  if (readings >= maxLUX) {
    if (calls < maxCalls) {
      Serial.println("\nTriggered! Calling appendRow Choreo...");
       runAppendRow(readings);
      calls++;
    } else {
      Serial.println("\nTriggered! Skipping to save Temboo calls. Adjust maxCalls as required.");
    }
  }
  delay(250);
}

void runAppendRow(int input) {
  TembooChoreo AppendRowChoreo(client);

  // Set Temboo account credentials
  AppendRowChoreo.setAccountName(TEMBOO_ACCOUNT);
  AppendRowChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
  AppendRowChoreo.setAppKey(TEMBOO_APP_KEY);

  // Set Choreo inputs
  String ClientSecretValue = "Replace with your own Secret Value";    //EDIT NEEDED
  AppendRowChoreo.addInput("ClientSecret", ClientSecretValue);
  String RefreshTokenValue = "Replace with your own Refresh token";  // EDIT NEEDED
  AppendRowChoreo.addInput("RefreshToken", RefreshTokenValue);
  String RowDataValue = "=(("+String(epoch)+"+("+timeZoneShift+"*3600))/86400)+25569,"+String(input);
  AppendRowChoreo.addInput("RowData", RowDataValue);
  String SpreadsheetTitleValue = "Replace with Spreadsheet Title";    //EDIT NEEDED
  AppendRowChoreo.addInput("SpreadsheetTitle", SpreadsheetTitleValue);
  String ClientIDValue = "Replace with your Client ID";               //EDIT NEEDED
  AppendRowChoreo.addInput("ClientID", ClientIDValue);

  // Identify the Choreo to run
  AppendRowChoreo.setChoreo("/Library/Google/Spreadsheets/AppendRow");

  // Run the Choreo
  unsigned int returnCode = AppendRowChoreo.run();

  // Read and print the error message
  while (AppendRowChoreo.available()) {
    char c = AppendRowChoreo.read();
    Serial.print(c);
  }
  Serial.println();
  AppendRowChoreo.close();
}

/*
 Udp NTP Client
Code adapted from github resource found here:
https://github.com/energia/Energia/blob/master/hardware/msp432/libraries/WiFi/examples/WiFiUdpNtpClient/WiFiUdpNtpClient.ino
 
 Modified 1 July 2014
 by Noah Luskey
 This code is in the public domain.
 */

unsigned int localPort = 2390;      // local port to listen for UDP packets
IPAddress timeServer(129,6,15,30); // time.nist.gov NTP server, can be changed.  Other servers can be found at http://tf.nist.gov/tf-cgi/servers.cgi
const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets

// A UDP instance to let us send and receive packets over UDP
WiFiUDP Udp;

void epochSetup()
{
  delay(10000); //give WiFi time to initialize in the main function
  Udp.begin(localPort);
}

void epochLoop()
{
  sendNTPpacket(timeServer); // send an NTP packet to a time server
  // wait to see if a reply is available
  delay(1000);
  if ( Udp.parsePacket() ) {
    // We've received a packet, read the data from it
    Udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer

    //the timestamp starts at byte 40 of the received packet and is four bytes,
    // or two words, long. First, esxtract the two words:

    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
    // combine the four bytes (two words) into a long integer
    // this is NTP time (seconds since Jan 1 1900):
    unsigned long secsSince1900 = highWord << 16 | lowWord;
    // now convert NTP time into everyday time:
    // Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
    const unsigned long seventyYears = 2208988800UL;
    // subtract seventy years:
    epoch = secsSince1900 - seventyYears;
    delay(2000);
  }
}

// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address)
{
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12]  = 49;
  packetBuffer[13]  = 0x4E;
  packetBuffer[14]  = 49;
  packetBuffer[15]  = 52;
  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  Udp.beginPacket(address, 123); //NTP requests are to port 123
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Udp.endPacket();
}

Credits

Chris Roberts

8 projects • 21 followers

I am an applications engineer with Texas Instruments working with the Launchpad by trade, and a maker by passion!

IoT Refrigerator Tracker

Things used in this project

Hardware components

Software apps and online services