Track When Your Roommate Steals Your Food!

If you would like to be informed about when your roommate decides to munch on your snacks, see how to use a Particle Photon to do it.

BeginnerFull instructions provided2 hours842

Track When Your Roommate Steals Your Food!

Things used in this project

Hardware components

Particle Photon

Jumper wires (generic)

PIR Motion Sensor (generic)

Resistor 1k ohm

USB-A to Micro-USB Cable

Breadboard (generic)

Software apps and online services

Particle.io

IFTTT Maker service

Google Sheets

Fritzing

Story

This project was conceptualized when it became apparent that Tyler's roommate was stealing his food from the pantry. At first, he would just apologize and claim he would buy Tyler more food, but never did. Now, he just flat out denies it. So, in order to see when he is sneaking a snack of Tyler's, the Particle Photon motion sensor will track when the pantry door is open!

How the project works

The kitchen pantry where the Photon and Motion Sensor is hidden

The first Photon is mounted in the kitchen pantry above the doorway so it will not be noticed. It has a PIR sensor attached to it which will see when the door is opened and a body is in the doorway. The positioning of the sensor is critical to make sure no other events in the kitchen are detected. This Photon will be programmed so that the internal LED at pin D7 would light up when motion is detected. This LED will allow us to know if the sensor is working properly.

The Photon was wrapped in a pop-tart box so that when the LED lit up detecting motion, the person in the pantry would not see the LED or be alarmed. Since there are no outlets in the pantry, the Photon was connected to a portable battery charger that was also wrapped in part of a pop-tart box to avoid detection.

Photon placement in pop-tart box before being attached to wall in pantry

Photon and Motion Sensor setup above doorway in pantry

View from looking upwards in doorway of pantry to see Photon setup

The Photon with the PIR sensor will publish events when motion is detected. These events will also be sent to the second photon. A notification will be sent to Tyler's iPhone alerting him that somebody is in the pantry and possibly stealing his food. He will be able to know what time the notification was sent so that he can figure out if he was in the pantry or if one of his roommates were. The second Photon is placed in Tyler's bedroom upstairs so that if he is in his room, the LED on pin D7 will light up alerting him someone is in the pantry.

The two Photons communicated with each other by the Particle.subscribe and Particle.publish functions. Tyler's Photon was subscribed to Melissa's Photon so that his Photon would send out a notification that motion has been detected in the pantry.

IFTTT notification of motion detected in the pantry

The IFTTT( If This Than That) app was used to send the notification. The code uses "intact" and "broken" to determine when motion is or is not detected. The numbers "1" and "0" were used for intact and broken so it would be easier to graph and understand that motion has been detected. Applets were created in IFTTT to send the data to Google Sheets to be graphed when motion is detected and when motion is not detected.

The applet for motion being detected used the event "1" which means the beam is intact and there is motion being detected by the motion sensor. Since Tyler's Photon was subscribed to Melissa's Photon, the device used in the applet was Tyler's Photon. The event of motion was sent to Tyler's Photon which allowed for his Photon to run the applet and send notifications.

1 / 3 • Applet settings for motion being detected and to send a notification to Tyler's phone

The applet below was used to send a "0" to Google Docs/Sheets when the motion detected stops. This allowed for the motion data to be sent and graphed in Google Sheets as motion is detected. A name for a new Google Sheet was added in this applet so it would send the data there and start a new row every time data was sent to the spreadsheet. Another applet that is the same as the one below was used to send a "1" to Google Docs/Sheets when motion is being detected. This allowed for a graph to be created when motion is detected and when motion stops.

1 / 4 • Applet that sends motion data to Google Sheets

The motion detector was left above the doorway in the kitchen pantry. We recorded when Tyler went into the pantry so we would know when his roommates were in the pantry grabbing food. The value of "1" described when motion was detected. The value "0" described when there was no motion being detected. For example, if there was a flat line at 1 on the graph, that showed that there was constant motion for the time the line was flat and as soon as the line dropped to 0, was when motion stopped.

Motion detected over a large range of time

Tyler was recorded to be in the pantry at 9:50 pm and 11:21 pm. Every other time one of his roommates were in the pantry. As seen in the beginning of the graph, there is a constant blue spot which shows that there was constant motion in the pantry for that time range. When motion was detected, a spike was shown on the graph that motion was detected when no motion was detected for a while.

Motion detected over a small range of time

This graph is the same graph as the one with a larger time range. This graph allows for the constant motion to be seen and at what specific times motion was detected by the sensor. This graph is a better representation of motion being detected as it shows specifically when it was detected and how the values drop down to zero when there is no motion present.

Code

int inputPin = D0;              // choose the input 
int ledPin = D7;                // LED Pin
int pirState = LOW;             // assuming no motion detected
int val = 0;                    // variable for reading the pin 

int calibrateTime = 1000;      // wait for calibratation to end

void setup()
{
  pinMode(ledPin, OUTPUT );
  pinMode(inputPin, INPUT);     // declare sensor as input
}

void loop()
{

  // if the sensor is calibrated
  if ( calibrated() )
  {
  // get the data from sensor
    readTheSensor();

    // report if the state has changed
    reportTheData();
  }
}

void readTheSensor() {
  val = digitalRead(inputPin);
}
bool calibrated() {
  return millis() - calibrateTime > 0;
}

void reportTheData() {

  // if the sensor reads high or there is motion
  if (val == HIGH) {

    // the current state is no motion
    // call the change by publishing an eent
    if (pirState == LOW) {
      // we have just turned on
      Particle.publish("Missy-food-tracker","intact",PUBLIC);
      delay(1000);
      // Update the current state
      pirState = HIGH;
      setLED( pirState );
    }
  } else {
    if (pirState == HIGH) {
      Particle.publish("Missy-food-tracker","broken",PUBLIC);
      delay(1000);
      pirState = LOW;
      setLED( pirState );
    }
  }
}

void setLED( int state )
{
  digitalWrite( ledPin, state );
}

// -----------------------------------------
// Publish and Subscribe with PIR Motion Sensors
/* -----------------------------------------

We are going to Particle.publish a public event to the cloud.
That means that everyone can see you event and anyone can subscribe to it.
You and your buddy will both publish an event, and listen for each others events.

------------------------------------------*/


int led = D0;
int boardLed = D7;
int photoresistor = A0;
int power = A5;

int intactValue;
int brokenValue;
int beamThreshold;

bool beamBroken = false;

// We start with the setup function.

void setup() {
      // This part is mostly the same:
  pinMode(led,OUTPUT); // Our LED pin is output (lighting up the LED)
  pinMode(boardLed,OUTPUT); // Our on-board LED is output as well
  pinMode(photoresistor,INPUT);  // Our photoresistor pin is input (reading the photoresistor)
  pinMode(power,OUTPUT); // The pin powering the photoresistor is output (sending out consistent power)


  // Here we are going to subscribe to your buddy's event using Particle.subscribe
  Particle.subscribe("Missy-food-tracker", myHandler);
  // Subscribe will listen for the event buddy_unique_event_name and, when it finds it, will run the function myHandler()
  // (Remember to replace buddy_unique_event_name with your buddy's actual unique event name that they have in their firmware.)
  // myHandler() is declared later in this app.
}


void loop() {
  // This loop sends a publish when the beam is broken.
  if (analogRead(photoresistor)>beamThreshold) {
    if (beamBroken==true) {
        Particle.publish("Tyler-food-tracker","intact",60,PUBLIC);
        // publish this public event
        // rename your_unique_event_name with your actual unique event name. No spaces, 63 ASCII characters.
        // give your event name to your buddy and have them put it in their app.

        // Set the flag to reflect the current status of the beam.
        beamBroken=false;
    }
  }

  else {
      if (beamBroken==false) {
        // Same deal as before...
        Particle.publish("Tyler-food-tracker","broken",60,PUBLIC);
        beamBroken=true;
      }
  }
}


// Now for the myHandler function, which is called when the cloud tells us that our buddy's event is published.
void myHandler(const char *event, const char *data)
{
  if (strcmp(data,"intact")==0) {
    // if your buddy's beam is intact, then turn your board LED on
    digitalWrite(boardLed,HIGH);
     Particle.publish("Tyler-food-tracker","intact",60,PUBLIC);
  }
  else if (strcmp(data,"broken")==0) {
    // if your buddy's beam is broken, turn your board LED off
    digitalWrite(boardLed,LOW);
  }
  else {
    // if the data is something else, don't do anything.
    // Really the data shouldn't be anything but those two listed above.
  }
}