Team Group 49: Cherokee Hall, Joshua Woods, Jack Donoghue

Published November 23, 2021

Proximity Bike Lock

The proximity motorcycle lock can lock/unlock itself when the user is within a certain distance and inform them of prime riding conditions.

IntermediateFull instructions providedOver 1 day604

Things used in this project

Hardware components

Particle Argon

Breadboard (generic)

OLED Screen

Temperature and Humidity Sensor

PIR Infrared Sensor (Motion Sensor)

Linear Actuator

Forward and Reverse Relay Module Controller (H Bridge)

12 V AA Battery Housing

LED (generic)

Dupont Wires

Songhe DC 1 Channel Optocoupler 3V/3.3V Relay

AA Batteries

Software apps and online services

Particle Build Web IDE

ThingSpeak API

Story

Introduction:

Have you ever been in a rush to class and wished that your bike could lock or unlock itself on its own? Our group, containing members Cherokee Hall, Joshua Woods, and Jack Donoghue, have developed a solution for you! Not only that, but the simple Bluetooth remote also displays time, lock status, and the temperature at your bike.

Background:

In an ideal world, most of our everyday items would be "automatic" or occur on their own with little to no assistance from the user. Additionally, such tasks would ideally save the user valuable time that could be spent on more tedious tasks. With this in mind, our group decided to take on a project that we have yet to see marketed or tackled; a proximity bike lock.

In order to fulfill this project we utilized three Particle Argon’s all tasked to handle a specific role. Attached to the bike itself, one Argon serves as a sensor cluster; gathering temperature, humidity, and motion data. In addition to this, an Argon in charge of locking the bike is also located on the bike. This Argon constantly scans for a unique Bluetooth signature in order to lock and unlock the bike autonomously. The third Argon acts as a remote and stays on the person; displaying date, time, temperature, and lock status. This beacon/remote constantly sends out a Bluetooth signal so the bike is locked when you are away from the bike.

Important Questions:

What problem are you solving?

Security is key, but it can often be a lot of work. Our goal for this project was to create a smart lock that ensures peace of mind while simultaneously requiring absolutely zero input from the user. When integrated on the bike and deployed, it disables the use of the bike and allows the user to monitor its status at all times. Additionally, without having to leave the comfort of their home they can check the weather conditions surrounding their bike or motorcycle and determine whether or not it is prime riding weather.

How is it useful?

Protecting your belongings against theft is crucial. Our lock provides fully autonomous, hassle-free security anytime, anywhere.

Why would someone want it?

This product is a necessity for modern security. Not only do you have constant access to the status and condition of your bike, but your bike is always secure. Never forget to lock your bike ever again.

What makes your solution novel?

No product exists with 100% input-free security, automatically locks and unlocks for you and only you, and displays conditions for you anywhere anytime. While this product is centered more towards serving a bicycle or motorcycle, the concept of this product could be implemented in a plethora of other products; such as strollers and wheelchairs. The versatility of this concept allows it to be utilized in multiple industries.

How are your newly acquired IOT skills allowing you to bring such a solution alive?

The internet of things (IOT) interconnects sensors and computing devices to the internet, allowing for live communication of data and events anywhere with WiFi. Advantages lie in instant data monitoring, accessibility, ease of connections, automation, control, and much more. Understanding and implementing IOT serves to improve data acquisition and analysis. With data and communication being broadcast to the internet, monitoring, troubleshooting, and communication between devices becomes much easier.

A fundamental understanding of how sensors operate was obtained throughout this project while the Argons served to improve our practical coding ability astronomically. Our problem-solving skills were continuously tested throughout the project in mechanical, electrical, and software engineering. Overall we believe the implementation of this proof of concept met and exceeded expectations, and could potentially be a profitable and marketable product.

How it Works:

Sensor Cluster

The primary sensor cluster utilized a combination of temperature, humidity, and PIR motion sensors connected to a Particle Argon. These sensors were powered from the 3.3V power supply from the Argon. The temperature and humidity sensor served to output its gathered data to the D2 pin. The Argon supplied 3.3 volts to the sensor while the adafruit library converted the readings at the D2 pin to a temperature and humidity value. Afterward, both measurements were plotted using ThingSpeak to display live graphs of the measurements. Readings were actively published every 30 seconds in order to update the OLED’s displayed temperature. Upon a successful subscribe and publish, the beacon returns a receipt that the data was gathered and subsequently flashes an LED on the sensor cluster Argon.

The temperature and humidity sensor served as an indication of riding conditions, while the PIR motion sensor helped alert the owner of any disturbances to their bike. If the bike is disturbed, a high voltage is sent to the D4 pin, and an alert is published.

Sensor Cluster Setup

Sensor Cluster Bike Attachment

OLED Beacon(Remote)

The final Particle Argon was designed to be kept on the person to determine proximity. The OLED beacon serves as an automatic remote or key fob for the bike’s lock and requires the user to take it with them while the other Particle Argons are attached to the bike. The OLED beacon Particle Argon was tasked with communicating with not only the sensor cluster Particle Argon but the locking mechanism Particle Argon as well.

The primary purpose of this Argon was to subscribe and display temperature data to the OLED, return publish events as acknowledgments of data received, and serve as a Bluetooth proximity output for the locking mechanism. In order for the OLED screen to properly display the temperature readings the GND, or ground pin, of the OLED had to be wired to the ground pin of the Particle Argon. The screen was powered via the Argon’s 3V3 power pin. To display the data readings properly the code utilizes the I2C protocol. This protocol causes the OLED’s SCL pin to read as a serial clock pin and is wired to the SCL or D1 pin. In addition, the protocol causes the SDA pin of the OLED to serve as a serial data pin and is wired to the SDA or D0 pin. The displayed temperature allows the user to check the weather conditions at their bike so that they can determine whether or not they would like to ride that day.

In addition to the subscription of the Argon to the data produced from the sensor cluster, these two Argons perform a bi-directional, or 2-way communication. Within its code, the OLED beacon defines and stores an integer known as “TemperatureRead” which is published so that the sensor cluster Particle Argon can subscribe to this event. The “TemperatureRead” integer appears in the code every time the OLED receives a temperature reading from the sensor cluster Particle Argon. Once this event occurs and the sensor cluster receives the subscribed integer value back, an LED light is triggered on the breadboard, completing the 2-way communication.

The Bluetooth signal output from this Argon serves a fundamental role in determining proximity. A constant Bluetooth signature is broadcasted from the Argon. When the signature is in close proximity to the locking mechanism it automatically signals the bike to unlock. The locking mechanism’s Argon published an event as locked or unlocked based on the Bluetooth’s live signal. This event is subscribed to in order to display the status of the lock on the LED connected to pin D4. When unlocked, the voltage to D4 is set to high and the LED light turns on.

OLED Beacon (Remote) Setup

Locking Mechanism

The Particle Argon in charge of the mechanical locking mechanism determined proximity via a Bluetooth signal to determine the lock’s state. Upon receiving a Bluetooth signal from the beacon, it goes into an unlocked state. This state sets pin D5 to low, reversing the linear actuator to unlock the bike. When the Bluetooth signal is lost the pin D5 sets to high, moving the linear actuator to the forward position and consequently locking the bike. The beacon argon outputs a low-energy Bluetooth signal and is scanned for in the code. The proximity range is roughly 15 meters and will change the color of the Argon’s status LED when the beacon is within that range. In addition, when the OLED Beacon argon believes the Argon is unlocked, it publishes an event. The green LED at pin D6 subscribes to this event and will light up green to indicate the remote's publish event. This helps diagnose any signal errors and shows that that the remote is functioning.

The linear actuator runs off of a 12-volt power supply and passes power through an H bridge to the linear actuator. Due to the difference in voltage and amperage between our locking mechanism and Argon, we utilized a relay to operate the switch. The relay connects the D5, 3v3 power, and GND pins to the Fwd, Rev, and GND pins of the H bridge.

The code initially tests for a ble signal from the beacon. If it reads a signal, it operates the D5 pin and subsequently outputs a publish event. This publish event only sends out a change in status, to prevent overloading the console with events. When a change in locked or unlocked status arises, a new event will be published as locked or unlocked. This satisfies the 2-way communication requirement with the beacon, as the locking mechanism receives proximity data from the beacon and a publish event for the LED, while the beacon receives a locked or unlocked status in return.

Locking Mechanism Setup

Locking Mechanism Assembly

Locking Mechanism Bike Attachment

Flow Chart

Project Flow Chart

Real-Time Graphs:

Live Graph of Temperature Readings

Live Graph of Humidity Readings

Particle Events Associated with Live Graphs and Live Demonstration

LiveDataLinks:

Click here

Video Demonstration:

Code

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

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

// This example assumes the sensor to be plugged into CONN2
#define DHTPIN 2     // what pin we're connected to

// Here we define the type of sensor used
#define DHTTYPE DHT11        // DHT 11 
int TemperatureRead = 0; //define integer for later use in Particle Subscribe

int currentTemp = 0; //define integer for current temperature reading

int currentHumid = 0; //define integer for current humidity reading

int LED = D6; //define integer for LED to corresponding Argon Pin

int val; //define integer for variable to correspond to Motion Sensor Detection

DHT dht(DHTPIN, DHTTYPE);

TCPClient client;

unsigned long lastcheck = 0; //variable to define time between Temperature and Humidity Checks

unsigned long myChannelNumber = 1571524;
const char * myWriteAPIKey = "VWUUI86CR774ZEC6"; //inputs for ThingSpeak channel

int checkhandler(String command) { //code for temperature and humidity checks
    checktemp();
    checkhumid();
    
    return 1;
}

void checktemp() { //measure and publish temperature measurement
    currentTemp=(int)dht.getTempFarenheit();
    if (currentTemp>0) {
        Particle.publish("currentTemp", String(currentTemp), PRIVATE);
    }
}

void checkhumid() { //measure humidity
    currentHumid=(int)dht.getHumidity();
    
}

void setup() { 
    ThingSpeak.begin(client); //Begin ThingSpeak
    dht.begin(); 
    Serial.begin(9600); 
    pinMode(LED, OUTPUT); //set mode of pin D6 as Output
    pinMode(D4, INPUT); //set mode of pin D4 as Input for Motion Detection
    
    checktemp(); //code to check temperature
    Particle.variable("temp", currentTemp); //define variable to check temperature and humidity on particle console
    Particle.variable("humid", currentHumid);
    
    Particle.function("checktemp", checkhandler); //function to be able to check temperature and humidity via particle console
    Particle.function("checkhumid", checkhandler);
    
    Particle.subscribe("TemperatureRead",led, MY_DEVICES); //subscribe to event to confirm temperature readings was read
}

void led(const char *event, const char *data) { //blink LED to confirm temperature reading
    digitalWrite(LED, HIGH);
    delay(1000);
    digitalWrite(LED, LOW);
}

void loop() {
    unsigned long currentMillis = millis(); //define time in milliseconds
    
    val = digitalRead(D4); //read pin D4
    
    if (val == HIGH) {
        Particle.publish("motion", "motion detected", PRIVATE); //publish event when motion is detected
    }
    
    if (currentMillis-lastcheck > 10000) { //check temperature and humidity based on last check
        lastcheck=currentMillis;
        
        checktemp();
        checkhumid();
        
    }
    
    if (currentTemp>0) { //filter to not publish sensor misreadings to ThingSpeak
        ThingSpeak.setField(1,currentTemp);
        Serial.print(dht.getTempFarenheit());
        Serial.println("currentTemp");
        ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);  
        delay(16000); // ThingSpeak will only accept updates every 15 seconds.
    }
    
    if (currentHumid>0) {
        ThingSpeak.setField(2,currentHumid);
        Serial.print(dht.getHumidity());
        Serial.println("currentHumid");
        ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);  
        delay(16000); // ThingSpeak will only accept updates every 15 seconds. 
    }
    
}

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

// This #include statement was automatically added by the Particle IDE.

#include "Particle.h"

SerialLogHandler logHandler(LOG_LEVEL_TRACE);

const uint32_t myColor = 0xff0000;
// 0xff0000 = red
// 0x00ff00 = green
// 0x0000ff = blue

void setAdvertisingData();

#define OLED_SCL    D1
#define OLED_SDA  D0

int TemperatureRead = 1;
char currentTemp[9]; 
String currentTemp0;




Adafruit_SSD1306 display(-1);

void setup()  
{
   Serial.begin(9600);
   pinMode(D4, OUTPUT);
   
    Serial.println(F("OLEDisplay 128x64"));
    Particle.subscribe("currentTemp", HAT, MY_DEVICES);//Subscribes to the HAT Particle Argon to receive the temperature readings.
    display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
    display.clearDisplay();
    display.display();
    
    Particle.subscribe("unlock", anything, "e00fce6866adfe3d29154ce9");//Subscribes to the unlock function of the Locking Mechanism Particle Argon
    Particle.subscribe("lock", lockmech, "e00fce6866adfe3d29154ce9");//Subscribes to the lock function of the Locking Mechanism Particle Argon
    
    (void)logHandler; // Does nothing, just to eliminate the unused variable warning

    BLE.on();

    setAdvertisingData();

}


void anything(const char *event, const char *data)
{
    digitalWrite(D4, HIGH);//Signals LED on
    Particle.publish("Bluetoothsignal", "on", PRIVATE); //publish event to signal other Argon when Bluetooth is in proximity
}

void lockmech(const char *event, const char *data)
{
    digitalWrite(D4, LOW);//Signals LED off
}

void loop() 
{
   
    display.clearDisplay();
    display.setTextColor(WHITE);
    display.setTextSize(1);
    display.setCursor(0,0); 
    Time.zone(-5);
    display.print(Time.timeStr().c_str());//Displays accurate date and time
    display.setCursor(0,20);
 
    if (currentTemp>0); {
        
        display.setTextSize(2);
        display.setCursor(0,30);
        display.printf("Temp  %0.4s F", currentTemp);//Displays the temperature readings acquired by the HAT Particle Argon
    
    }
   
    
     display.display();
    delay(500);
    
}


void HAT(const char *event, const char *data)
{
    if (currentTemp>0) {
        strcpy(currentTemp,data);
        delay(3000);
        Particle.publish("TemperatureRead", String(TemperatureRead), PRIVATE); //Publishes TemperatureRead function for the Sensor Cluster to subscribe to. Turns on LED when OLED receives the temperature reading.
}

   }
   
   
   
   void setAdvertisingData() {
    uint8_t buf[BLE_MAX_ADV_DATA_LEN];

    size_t offset = 0;

    // Manufacturer-specific data
    // 16-bit: Company ID (0xffff)
    // Byte: Internal packet identifier (0x55)
    // 32-bit: Color code

    // Company ID (0xffff internal use/testing)
    buf[offset++] = 0xff;
    buf[offset++] = 0xff;

    // Internal packet type. This is arbitrary, but provides an extra
    // check to make sure the data is my data, since we use the 0xffff company
    // code.
    buf[offset++] = 0x55;

    // Our specific data, color code
    memcpy(&buf[offset], &myColor, 4);
    offset += 4;

    BleAdvertisingData advData;
    advData.appendCustomData(buf, offset);

    // Advertise every 100 milliseconds. Unit is 0.625 millisecond intervals.
    BLE.setAdvertisingInterval(160);

    // Continuously advertise
    BLE.advertise(&advData);
}

#include "Particle.h"

// This example does not require the cloud so you can run it in manual mode or
// normal cloud-connected mode
// SYSTEM_MODE(MANUAL);

SerialLogHandler logHandler(LOG_LEVEL_TRACE);

const size_t SCAN_RESULT_MAX = 30;

BleScanResult scanResults[SCAN_RESULT_MAX];
LEDStatus ledOverride(RGB_COLOR_WHITE, LED_PATTERN_SOLID, LED_SPEED_NORMAL, LED_PRIORITY_IMPORTANT);

bool Unlock = false; //boolean for if statement to initiate publish event
bool Lock = false; //boolean for if statement to initiate publish event


void setup() {
	(void)logHandler; // Does nothing, just to eliminate the unused variable warning

	BLE.on();
    pinMode(D5, OUTPUT); //set D5 pin mode as output
    pinMode(D6, OUTPUT); //set D6 pin mode as output
    Particle.subscribe("Bluetoothsignal", LED, "e00fce68ed92efdad5e8ef3c"); //subscribe to event for 2-way communication
}

void LED(const char *event, const char *data)
{
    digitalWrite(D6, HIGH);//Signals LED on when in proximity
}

void loop() {
	// Only scan for 500 milliseconds
    
	BLE.setScanTimeout(2000);
	int count = BLE.scan(scanResults, SCAN_RESULT_MAX);

	uint32_t curColorCode;
	int curRssi = -999;
    
	for (int ii = 0; ii < count; ii++) {
		uint8_t buf[BLE_MAX_ADV_DATA_LEN];
		size_t len;

		// When getting a specific AD Type, the length returned does not include the length or AD Type so len will be one less
		// than what we put in the beacon code, because that includes the AD Type.
		len = scanResults[ii].advertisingData.get(BleAdvertisingDataType::MANUFACTURER_SPECIFIC_DATA, buf, BLE_MAX_ADV_DATA_LEN);
		if (len == 7) {
			// We have manufacturer-specific advertising data (0xff) and it's 7 bytes (without the AD type)

			// Byte: BLE_SIG_AD_TYPE_MANUFACTURER_SPECIFIC_DATA (0xff)
			// 16-bit: Company ID (0xffff)
			// Byte: Internal packet identifier (0x55)
			// 32-bit: Color code

			if (buf[0] == 0xff && buf[1] == 0xff && buf[2] == 0x55) {
				// Company ID and internal packet identifier match

				uint32_t colorCode;
				memcpy(&colorCode, &buf[3], 4);

				Log.info("colorCode: 0x%lx rssi=%d address=%02X:%02X:%02X:%02X:%02X:%02X ",
						colorCode, scanResults[ii].rssi,
						scanResults[ii].address[0], scanResults[ii].address[1], scanResults[ii].address[2],
						scanResults[ii].address[3], scanResults[ii].address[4], scanResults[ii].address[5]);

				if (scanResults[ii].rssi > curRssi) {
					// Show whatever device has the strongest signal
					curRssi = scanResults[ii].rssi;
					curColorCode = colorCode;
					
				}
			}
		}
	}
	if (curRssi != -999) {
		ledOverride.setColor(curColorCode); //change LED on Argon depending on Bluetooth Signal
		ledOverride.setActive(true);
		digitalWrite(D5, LOW); //set pin D5 low to unlock the actuator
		delay(2000);
		if (Unlock == false) {
		    Particle.publish("unlock", "In Proximity", PRIVATE); //publish unlock event to signal other Argon to light LED
		    Unlock = true;
		    Lock = false;
		}
	}
	else {
		ledOverride.setActive(false); //change LED on Argon depending on Bluetooth Signal
		digitalWrite(D5, HIGH); //set pin D5 to HIGH to extend linear actuator
		if (Lock == false) {
		    Particle.publish("lock", "Out Proximity", PRIVATE); //publish lock event to signal other Argon to turn of LED
		    digitalWrite(D6, LOW); //turn  off LED when no bluetooth signal
		    Unlock = false;
		    Lock = true;
		}
	}
}

Proximity Bike Lock

Things used in this project

Hardware components

Software apps and online services

Story

Introduction:

Background:

Important Questions:

How it Works:

Flow Chart

Video Demonstration:

Schematics

Sensor Cluster

OLED Beacon (Remote)

Locking Mechanism

Code

Sensor Cluster

OLED Beacon (Remote)

Locking Mechanism

Credits

Cherokee Hall

Joshua Woods

Jack Donoghue

Comments

Embed the widget on your own site

Proximity Bike Lock

Proximity Bike Lock

Things used in this project

Hardware components

Software apps and online services

Story

Introduction:

Background:

Important Questions:

How it Works:

Flow Chart

Video Demonstration:

Schematics

Sensor Cluster

OLED Beacon (Remote)

Locking Mechanism

Code

Sensor Cluster

OLED Beacon (Remote)

Locking Mechanism

Credits

Cherokee Hall

Joshua Woods

Jack Donoghue

Comments

Related channels and tags