Particle Photon Door Lock and Sensor

A magnetic lock and proximity sensor connected to a particle photon that unlocks your door from a phone and records when the door opens.

IntermediateFull instructions provided4 hours1,850

Things used in this project

Hardware components

Particle Photon

Magnetic Reed Switch

Electric Bolt Lock

12v power supply

5V Relay

Resistor 221 ohm

LED (generic)

Jumper wires (generic)

Software apps and online services

ThingSpeak API

IFTTT Maker service

Story

Smart Door

Have you ever locked your keys in your house? This project was based off of that problem since that seems to be an issue for my partner and I . At some point in our lives we have been locked out of the house or have been forced to use a spare key. Do not worry any longer because we have developed a product that will eliminate the use of a key and will only require a device that is wifi capable and can download the Particle app.

What Is Smart Door?

Smart Door is a door that locks and unlocks from the fingertips of your smartphone. This Smart Door will not lock unless the door has been shut for approximately 3 seconds. This delay gives you time to insure that the door is closed flush. This technology will also alert you on your smart device if the door has been opened, potentially alerting you that your home has been breached. Please use the guidelines and code we have developed to create your own Smart Door.

The figure above shows the events logged from the magnetic reed switch. The event name "doorStat" indicates the door has been closed. The event name "mailbox_opened" incicates the door is open.

The photon was connected to thingsspeak to graphically relay the data. The graph above titled Particle Photon will spike when the door is opened.

Using IFTTT sends a notification to your cellphone.

Photon circuit that controls the door lock.

Photon that controls the magnetic reed switch

Code

// This #include statement was automatically added by the Particle IDE.
#include <Ubidots.h>

// This #include statement was automatically added by the Particle IDE.
#include <HttpClient.h>

// This #include statement was automatically added by the Particle IDE.
#include <ThingSpeak.h>

TCPClient client;
HttpClient http;

//These values come from Ubidots profile information.
#define VARIABLE_ID "a4f0088407e1381b61f4e681b387569f43f7a16e"
#define TOKEN "qfMt66OyPkjURdKUjzRHliGVVzQmEL"


// Headers currently need to be set at init, useful for API keys etc.
http_header_t headers[] = {

    { "Content-Type", "application/json" },
    { "X-Auth-Token" , TOKEN },
    { NULL, NULL } // NOTE: Always terminate headers with NULL
};

http_request_t request;
http_response_t response;

// List your variables for each scenario:
char resultstr[64];
char resultstrAnalog[64];
int unixTime = 0;
int doorStat = 0;
int doorStatOLD = 0;
int rawAnalogStrength = 0;
unsigned long myChannelNumber = 256818;
const char * myWriteAPIKey = "S745NICTJUQMU26R";

// Create the setup for the Particle code.
void setup() {
//Create particle variables    
    Particle.variable("isClosed", &doorStat, INT);
    Particle.variable("whenToggle", &unixTime, INT);
    Particle.variable("analogSignal", &rawAnalogStrength, INT);
// Initialize D0 pin as output   
    pinMode(D0, OUTPUT);
// WKP pin is reed switch input.
    pinMode(WKP, INPUT);
    request.hostname = "things.ubidots.com";
    request.port = 80;
// Run the Thingspeak Application
    ThingSpeak.begin(client);
}

void loop() {
// The returned value from the Core is going to be in the range from 0 to 4095

        rawAnalogStrength = analogRead(WKP);
        if (rawAnalogStrength < 400) {
            doorStatOLD = doorStat; // Save current value for later
            doorStat = 1; //closed
            digitalWrite(D0, LOW);    // Turn OFF the LED pins
            delay(100); 
           
            float voltage = rawAnalogStrength * (3.3 / 4095.0);
            ThingSpeak.writeField(myChannelNumber, 1, voltage, myWriteAPIKey);
            delay(20000); // ThingSpeak will only accept updates every 15 seconds.
            
        } else {
            doorStatOLD = doorStat; // Save current value for later
            doorStat = 0; //open
            digitalWrite(D0, HIGH);   // Turn ON the LED pins
            delay(100); 
            
            Particle.publish("doorStat","0"); // Publishes to IFTT
            
            float voltage = rawAnalogStrength * (3.3 / 4095.0);
            ThingSpeak.writeField(myChannelNumber, 1, voltage, myWriteAPIKey);
            delay(20000); // ThingSpeak will only accept updates every 15 seconds
        
            Particle.publish("door_opened");
        }
//Thanks to Hans for the Thinspeak code base.  
if (doorStatOLD != doorStat) { //If the door has opened or closed since the last reading then
// Send to Ubidots
    request.path = "/api/v1.6/variables/"VARIABLE_ID"/values"; //send binary result
    sprintf(resultstr, "{\"value\":%i}",doorStat); 
    request.body = resultstr;
    http.post(request, response, headers);
    Serial.println(response.body);
    delay(100);
}
}

// First, let's create our "shorthand" for the pins
int lock1 = D3;
int boardLed = D7;
    int i = 0;
void setup(){
    pinMode(boardLed,OUTPUT);
    //  sets the Lock as an output for the Photon
    digitalWrite(boardLed,LOW);
   Particle.subscribe("doorstat", doorstat ,"2e003f001447353136383631");
   
Serial.begin(9600);
pinMode(lock1, OUTPUT);

   // We are also going to declare a Particle.function so that we can turn the Lock on and off from the cloud.
   Particle.function("lock",lockToggle);
   // This is saying that when we ask the cloud for the function "lock", it will employ the function lockToggle() from this app.

   // For good measure, let's also make sure both Lock is off when we start:
   digitalWrite(lock1, LOW);

}
void doorstat(const char *event, const char *data)    {
    i++;
  Serial.print(i);
  Serial.print(event);
  Serial.print(", data: ");
  if (data)
    Serial.println(data);
  else
    Serial.println("NULL");
    Particle.publish("doorstat");
}
void loop()
{
  
}

int lockToggle(String command) {
    
    if (command=="on") {
        digitalWrite(lock1,HIGH);
        Particle.publish("doorstat");
        return 1;
    }
    else if (command=="off") {
        digitalWrite(lock1,LOW);
       Particle.publish("doorstat");
        return 0;
    }
    else {
        return -1;Particle.publish("doorstat");
    }
}