Fabrizio Lyles, Felix Vivongsy, David Pisacane

Published April 17, 2019

IoT Makeshift Door Lock

Tired of getting off your couch to unlock your door for your roommate? Forget to lock your door on your way to class? Say no more…

IntermediateFull instructions provided1,185

Things used in this project

Hardware components

Particle Photon

Solderless Breadboard Half Size

Jumper wires (generic)

Elegoo 28BYJ-48 Stepper Motor + Driver Board

Elegoo Stepper Motor Driver (uln2003 driver)

3D Printed Base

3D Printed Attachment

Software apps and online services

Particle Build Web IDE

Blynk

Story

Overview

We are all lazy.

There have been countless times where I have rushed out the door in a hurry to a class that I’m 30 minutes late for — due to oversleeping — and have forgotten to lock the door. I could also account for the times that I have been under a mountain of snacks while on the couch and someone comes to the door, resulting in me having to tumble off the couch, walk to the door, and unlock the door.

Not anymore.

The solution is a photon connected to a stepper motor that stays in front of the door lock.

Assembly

Before construction, specific parts need to be made for the stepper motor to couple onto the lock. Two objects were designed as a modification to our door lock.

Object one is an attachment that goes directly onto the shaft of the stepper motor. This part was designed to be a tight fit, requiring no locks or set screws as you would see in a standard coupler. The opposing end had a generic shape that goes around the area of the lock just enough so that it rotates relative to the stepper motor.

SolidWorks Model of object 1

Object 2 is the body (housing) of the system. This part goes over the door lock and grounds the stepper motor. Measurements were taken to design the part to fit around our lock frame which was approximately 2.10 inches.

SoliddWorks model of object 2

Simplify 3D is the slicer software used to print this part, given a .stl file.

Object one displayed in Simplify 3D

Cross-section view of object one with 20% infill

Final assembly (device attached to door)

How It Works

Simplicity was the goal of our project which meant that our application had to be intuitive and easy to use. Using Blynk, we were able to remotely control the stepper motor by toggling through a single button. Only two functions were needed in this design; lock and unlock.

When the button is set to "UNLOCKED", digital pin 3 is set to LOW which verifies that the door is unlocked. If the door is in a locked state prior to activating the button, the program will run through a series of IF statements until the lock has rotated a certain number of times in the counter-clockwise direction.

Blynk App (door is unlocked)

When the button is set to "LOCKED", digital pin 3 is set to HIGH which verifies that the door is locked. If the door is in a locked state prior to activating the button, the program will run through a series of IF statements until the lock has rotated a certain number of times in the clockwise direction.

Blynk App (door is locked)

The circuit board for the stepper motor schematic is shown below. The following image after is the device attached to our front door.

Equipment setup

Communication & Graphing

The particle photons (1, 2, and 3) communicate with one another once the locking mechanism is triggered to rotate by the Blynk application on a user’s phone. A list of the line of communication and responses:

When the door is locked:
Particle 1 sends communication to Particle 2. It turns the D7 LED on. In turn, Particle 2 connects with Particle 1 (which turns its originally on LED off for 5 seconds then back on) and with Particle 3 (which turns its originally off D7 LED on).Then, Particle 3 returns communication to both Particle 1 and 2; Particle 1 blinks its LED off for 5 seconds and then back on; Particle 2 turns its now on LED off.
At this point the communication string is complete for locking the door.

When the door is unlocked:
A similar pattern is taken with mostly opposite actions. The Blynk app tells the motor to turn and turns the D7 LED off on Particle 1. When activated, Particle 1 sends a publication subscribed to by Particle 2. It then turns its D7 LED on and communicates with 1 and 3; Particle 1 blinks its D7 LED on for 5 seconds before turning it off; Particle 3 turns its D7 LED off. Particle 3 then publishes an event. Particle 1 blinks its D7 LED on for 5 seconds and off again when it subscribes; Particle 2 turns its D7 LED off when it subscribes.
This completes the communication string for unlocking the door.

The third particle simultaneously and continuously publishes data to ThingSpeak.com. This graph publishes locked and unlocked data versus time. A 1 is published when the door is locked and the D7 LED is on; a 0 is published when the door is unlocked and the D7 LED is off. The communication strings detailed above show how & why the LED is turned on. The time stamps include the data and military time allowing the viewer to be able to see what times of the day their door was locked or unlocked.

Sample graphing of the lock's data

The graph sample shows that the door remained unlocked from about 21:16 to about 21:21. Then the door was briefly locked before being unlocked for a minute. It was again locked and unlocked.
A continuous, updating version of this graph can be found at this website.

(If the hyperlink doesn't work, copy and paste this url https://thingspeak.com/channels/757464/charts/1?bgcolor=%23ffffff&color=%23d62020&dynamic=true&results=60&type=line&update=15)

Schematics

Code

#define BLYNK_PRINT Serial  
#include <blynk.h>

int button = D3;
#define STEPPER_PIN_1 D7
#define STEPPER_PIN_2 D6
#define STEPPER_PIN_3 D5
#define STEPPER_PIN_4 D4

int step_number = 0;                                    // step_numer is the counter
bool shouldResetLow = false;                            // flag that says if the button is selected, set step_number back to zero
bool shouldResetHigh = false;                           // flag that says if the button is selected, set step_number back to zero (other state)
int maxCount = 5000;                                    // timer

char auth[] = "7b4d8606e64443138782c8dc9cb94c7b";       // authentication for Blynk button

void setup(){
    pinMode(STEPPER_PIN_1, OUTPUT);
    pinMode(STEPPER_PIN_2, OUTPUT);
    pinMode(STEPPER_PIN_3, OUTPUT);
    pinMode(STEPPER_PIN_4, OUTPUT);

    Blynk.begin(auth);
    
    Particle.subscribe("Connect_to_three", name4, MY_DEVICES); // Subscribe from 02-particle
    Particle.subscribe("Back_2", name5, MY_DEVICES); // subscribe from 03-particle
}

void name4(const char *event, const char *data){
delay(5000);
    if (digitalRead(D7) == HIGH){
        digitalWrite(D7, LOW);
        delay(5000);
        digitalWrite(D7, HIGH);
        delay(5000);
//return;
    }
    
    else if (digitalRead(D7) == LOW){
        digitalWrite(D7, HIGH);
        delay(1000);
        digitalWrite(D7, LOW);
        delay(5000);
//return;
    }
    
    delay(1000);
Particle.unsubscribe();
    
}


void name5(const char *event, const char *data){
    delay(5000);
    if (digitalRead(D7) == HIGH){
        digitalWrite(D7, LOW);
        delay(5000);
        digitalWrite(D7, HIGH);
//return;
    }
    else if (digitalRead(D7) == LOW){
        digitalWrite(D7, HIGH);
        delay(5000);
        digitalWrite(D7, LOW);
//return;    
    }
    delay(1000);
Particle.unsubscribe();

}


void loop(){
    Blynk.run();
    if (digitalRead(button) == LOW) {  // LOW is when the button is unlocked
        if (shouldResetLow) {
            step_number = 0;                            // starts at zero and runs steps
            shouldResetLow = false;                     // no longer reset
        
        
        Particle.publish("Connect", "unlocked", 60, PRIVATE);
        
        
        }
        if (step_number < maxCount) {                   // counts to maxCount and stalls until button is seleted
            OneStep(true);          
            if (step_number >= maxCount) {
                shouldResetHigh = true;                 // resets to zero when button is seltec (high)
            }
        }
    } else if (digitalRead(button) == HIGH) {           // HIGH is when the button is locked
        if (shouldResetHigh) {          
            step_number = 0;                            // starts at zero and runs steps  
            shouldResetHigh = false;                    // no longer reset
        }
        if (step_number < maxCount) {                   // counts to maxCount and stalls until button is seleted
            OneStep(false);
            if (step_number >= maxCount) {
                Particle.publish("Connect", "locked", 60, PRIVATE);
                shouldResetLow = true;
            }
        }
    }
}

void OneStep(bool dir) {                                // OneStep is exactly as stated. Entire function runs through a single step in the motor
        if(dir) {                                       // Sets a true/false
            switch(step_number %4){                     // step_number divided by 4; motor rotates clockwise
              case 0:
              digitalWrite(STEPPER_PIN_1, HIGH);        
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
              case 1:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, HIGH);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
              case 2:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, HIGH);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
              case 3:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, HIGH);
              break;
            } 
        } else {
            switch(step_number %4){                     // step_number divided by 4; motor rotates counter-lockwise
              case 0:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, HIGH);
              break;
              case 1:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, HIGH);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
              case 2:
              digitalWrite(STEPPER_PIN_1, LOW);
              digitalWrite(STEPPER_PIN_2, HIGH);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
              case 3:
              digitalWrite(STEPPER_PIN_1, HIGH);
              digitalWrite(STEPPER_PIN_2, LOW);
              digitalWrite(STEPPER_PIN_3, LOW);
              digitalWrite(STEPPER_PIN_4, LOW);
              break;
            }
        }
        step_number++;
}

void setup() {
    pinMode(D7, OUTPUT);
    Particle.subscribe("Connect", name2, MY_DEVICES); // subscribe from 01-particle


}

void name2(const char *event, const char *data){
    delay(5000);
    if(digitalRead(D7) == LOW){
    digitalWrite(D7, HIGH);
    delay(5000);

//    digitalWrite(D7, LOW);
            Particle.publish("Connect_to_three", "light is off", 60, PRIVATE);
    return;
    }
            
//    Particle.unsubscribe();
    
    
    Particle.subscribe("Back_2", name3, MY_DEVICES); // subscribe from 03-particle
}


void name3(const char *event, const char *data){
    delay(5000);
    if (digitalRead(D7) == HIGH){
        digitalWrite(D7, LOW);
        delay(5000);
    }
    else if (digitalRead(D7) == LOW){
        digitalWrite(D7, HIGH);
        delay(5000);

//    Particle.unsubscribe();
    }

}


void loop() {
//    if(digitalRead(D7) == HIGH){
//        Particle.publish("Connect_to_three", "on", 60, PRIVATE); // publish to 03-particle and back to 01-particle
//    }
    

}

int led = D7;

void setup() {
    pinMode(D7, OUTPUT);
    Particle.subscribe("Connect_to_three", name3, MY_DEVICES);
}

void name3(const char *event, const char *data){

    delay(2000);
    if(digitalRead(led) == LOW){
        digitalWrite(led, HIGH);
        delay(10000);
        Particle.publish("Back_2", "I am back", 60, PRIVATE);
        delay(2000);        
        return;
    }
    else if (digitalRead(led) == HIGH){
        digitalWrite(led, LOW);
        delay(10000);
        Particle.publish("Back_2", "I am back", 60, PRIVATE);
        delay(2000);
        return;
    }    
    
    
    
 /*   if (digitalRead(D7) == LOW){
        delay(5000);
        digitalWrite(D7, HIGH);
        delay(2000);
    
        Particle.publish("position", "on mode", 60, PRIVATE); // Connects back to 02-particle
    }
    else if (digitalRead(D7) == HIGH){
        delay(5000);
        digitalWrite(D7, HIGH);
        delay(2000);
        
        Particle.publish("position", "on mode", 60, PRIVATE); // Connects back to 02-particle
 */   }
    

    

void loop() {
        if(digitalRead(D7) == HIGH){

        String data = String(1);
        delay(30000);

        Particle.publish("position", data, PRIVATE);
        delay(30000);
    }
    
    else if (digitalRead(D7) == LOW){
        String data = String(0);
        delay(30000);

        Particle.publish("position", data, PRIVATE);
        delay(30000);
    }   

}

IoT Makeshift Door Lock

Things used in this project

Hardware components

Software apps and online services

Story

Overview

Assembly

How It Works

Communication & Graphing

Custom parts and enclosures

Lock Cover

Lock Attachment

Schematics

Circuit Board

Circuit Board

Code

Unlock/Lock the door

Indicator for when door is unlocked

Presence indicator

Credits

Fabrizio Lyles

Felix Vivongsy

David Pisacane

Comments

Embed the widget on your own site

IoT Makeshift Door Lock

IoT Makeshift Door Lock

Things used in this project

Hardware components

Software apps and online services

Story

Overview

Assembly

How It Works

Communication & Graphing

Custom parts and enclosures

Lock Cover

Lock Attachment

Schematics

Circuit Board

Circuit Board

Code

Unlock/Lock the door

Indicator for when door is unlocked

Presence indicator

Credits

Fabrizio Lyles

Felix Vivongsy

David Pisacane

Comments

Related channels and tags