•

Kelvin Limanto

•

Andrew Nguyen

Published November 25, 2021 © GPL3+

MEGR 3171 IOT Project: Interactive Lamp

An Interactive Lamp that can be remotely controlled by sound, motion, and touch.

BeginnerFull instructions provided4 hours156

Things used in this project

Hardware components

Particle Argon

Breadboard (generic)

TTP223B Capacitive Touch Sensor

Model: TTP223B Capacitive Touch Sensor Brand: HiLetgo

Relay Module Switch

Model: HiLetgo 2pcs 5V One Channel Relay Module Relay Switch Brand: HiLetgo

LED (generic)

Resistor 100k ohm

HC-SR501 Pir Motion IR Sensor

Model: HC-SR501 Brand: DIYmall

Software apps and online services

Particle Build Web IDE

Hand tools and fabrication machines

Soldering iron (generic)

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Multitool, Screwdriver

Scissor, Electrician

Tape, Electrical

Story

The IOT device we chose to create for the MEGR 3171 design project was an interactive lamp. Three particle argons were used for wireless data transmission. This lamp has three different sensors to switch the light on and off: motion, capacitive touch, and sound. The first sensors are 2 capacitive touch sensors, one that will turn the light on and off with just a touch, and the other that will change the mode from manual touch and sound to automatic motion activation. The mode is indicated by an LED on the touch and sound sensor module. Automatic mode turns on the motion sensor module, meaning the light will turn on when motion is detected. If motion is not detected in a set amount of time, the light will automatically turn off. The signals will be sent over the particle cloud to remotely turn on and off the lamp. The head argon unit that is attached to the lamp relay will send a signal back to these sensor modules to blink the onboard LED’s to confirm that the signal is being sent between these units. With three sensors to dictate whether the lamp is on or off, this system can fully automate turning the lamp on and off. Live lamp state data can be accessed from the internet. The times during the day that the light is turned on or off is logged and sent over to the internet from Thing Speak.

Here is the link to the Thing Speak live data mapping of our lamp: https://thingspeak.com/channels/1580958

The value of this automated lamp system comes from the accessibility and usefulness of it. The idea itself isn’t groundbreaking but this device system optimizes a lamp to be a little bit more practical. Imagine the following scenario, you enter your dark bedroom with your hands full. Instead of trying to navigate across a dark room possibly dropping your belongings, the light would turn on the moment you walk into range of the motion sensor, and if you desired the light to be on before that all you had to do was make a semi-loud noise above the decibel limit of the sound sensor. This lamp also has an auto-turn off function, if motion is not detected above a limit for a certain amount of time then the light will turn off by itself, this can prove useful to save electricity when a normal lamp would continuously run when left on by mistake.

What makes our lamp unique is the system in which it is set up and how new devices can be added. This system can be applied to any device with an on or off switch and can be used for multiple appliances be Motion sensor lights typically only have one input from the motion sensor itself and are used frequently in places like public bathrooms. Sound activated lamps aren’t commonly used, and are expensive. An infinite number of lights can easily be added to this system and be wirelessly connected as long as there is a WIFI signal. The uniqueness of this device comes from the combination of 3 different inputs into one ergonomic system.

Our team learned a lot about computer programming and circuit building. These new skills assisted the completion of our IOT device.

Here are some close up images of our IOT device.

The exterior of the manual module with two capacitive touch sensors and a sound sensor.

The interior of the sound and touch module with a couple debugging LEDs and a Particle Argon.

The exterior of the automatic module with a status LED and a motion sensor.

The interior of the motion sensor module with a Particle Argon on a breadboard and some wiring

The interior of the main lamp control module with a Particle Argon and a relay.

Below is a short video showing how our interactive lamp works.

Code

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

int lamp = D7;
int lampState = LOW;

//toggle between auto and manual mode
//auto mode (HIGH) will use the pir sensor
//manual mode (LOW) will touch and sound sensor
int modeState = LOW;

TCPClient client;

unsigned long myChannelNumber =  1580958;
const char * myWriteAPIKey = "FQE3WRD0IAK9LAG1";

void setup() {
    pinMode(lamp, OUTPUT);
    digitalWrite(lamp, LOW);
    
    //subscribes this argon to the touch toggle event
    Particle.subscribe("touchToggle", touchToggleLamp, MY_DEVICES);
    
    //subscribes this argon to the sound toggle event
    Particle.subscribe("soundToggle", soundToggleLamp, MY_DEVICES);
    
    //subscribes this argon to the on and off events
    Particle.subscribe("lampOnOff", pirLampOnOff, MY_DEVICES);
    
    //subscibes this argon to the mode toggle event
    Particle.subscribe("modeToggle", modeToggleState, MY_DEVICES);
    
    ThingSpeak.begin(client);
}


//toggles the light on and off from the touch sensor
void touchToggleLamp(const char *event, const char *data) {
    
    if (modeState == LOW) {
        //toggles the lamp state if the touch sensor is triggered
        lampState = !lampState;
        
        //sends lamp state change event to other argons
        Particle.publish("lampChange", PRIVATE);
    }
}

//toggles the light on and off from the sound sensor
void soundToggleLamp(const char *event, const char *data) {
    
    if (modeState == LOW) {
        //toggles the lamp state if the touch sensor is triggered
        lampState = !lampState;
        
        //sends lamp state change event to other argons
        Particle.publish("lampChange", PRIVATE);
    }
}

//turns the light on and off from the motion sensor
void pirLampOnOff (const char *event, const char *data) {
    if (strcmp(data, "off") == 0) {
        lampState = LOW;
    }
    
    else if (strcmp(data, "on") == 0) {
        lampState = HIGH;
    }
    Particle.publish("lampChange", PRIVATE);
}

//toggles between auto and manual sensor modes
void modeToggleState(const char *event, const char *data) {
    if (strcmp(data, "manual") == 0) {
        modeState = LOW;
    }
    
    else if (strcmp(data, "auto") == 0) {
        modeState = HIGH;
    }
}

void loop() {
    
    ThingSpeak.setField(1, lampState);
    Serial.print(lampState);
    Serial.println("Lamp State");
    ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);
    
    //updates the lamp state to the current lamp state
    digitalWrite(lamp, lampState);
}

int led = D7;
int button = D6;
int modeButton = D5;
int modeLed = D4;
int sound = D3;
int soundLed = D2;
int lastButtonState;
int currentButtonState;
int modeLastButtonState;
int modeCurrentButtonState;
int soundCurrentState;
int soundLastState;
int lampState = LOW;
int modeState = LOW;

void setup() {
     
    pinMode(led, OUTPUT);
    digitalWrite(led, LOW);
    currentButtonState = digitalRead(button);
    pinMode(button, INPUT);
    pinMode(modeLed, OUTPUT);
    digitalWrite(modeLed, LOW);
    modeCurrentButtonState = digitalRead(modeButton);
    pinMode(modeButton, INPUT);
    pinMode(sound, INPUT);
    soundCurrentState = digitalRead(sound);
    
    //subscribes this argon to the lamp change event
    Particle.subscribe("lampChange", blinkLight, MY_DEVICES);
}

//blinks the D7 led 3 times, if the lamp changes state
void blinkLight(const char *event, const char *data) {
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, lampState);
}

void blinkSoundLed(){
    digitalWrite(soundLed, HIGH);
    delay(100);
    digitalWrite(soundLed, LOW);
    delay(100);
    digitalWrite(soundLed, HIGH);
    delay(100);
    digitalWrite(soundLed, LOW);
    delay(100);
    digitalWrite(soundLed, HIGH);
    delay(100);
    digitalWrite(soundLed, LOW);
    delay(100);
    digitalWrite(soundLed, HIGH);
    delay(100);
    digitalWrite(soundLed, LOW);
}

void loop() {
    lastButtonState = currentButtonState;
    currentButtonState = digitalRead(button);
    
    //if statement is excecuted if touch sensor is triggered
    if (lastButtonState == HIGH && currentButtonState == LOW) {
        lampState = !lampState;
        digitalWrite(led, lampState);
        
        //tells the lamp argon to toggle on or off
        Particle.publish("touchToggle", PRIVATE);
    }
    
    modeLastButtonState = modeCurrentButtonState;
    modeCurrentButtonState = digitalRead(modeButton);
    
    //if statement is excecuted if mode touch sensor is triggered
    if (modeLastButtonState == HIGH && modeCurrentButtonState == LOW) {
        modeState = !modeState;
        digitalWrite(modeLed, modeState);
        
        //updates the mode state on the lamp argon
        if(modeState == LOW){
            Particle.publish("modeToggle", "manual", PRIVATE);
        }
        else {
            Particle.publish("modeToggle", "auto", PRIVATE);
        }
    }
    
    soundLastState = soundCurrentState;
    soundCurrentState = digitalRead(sound);
    
    if (soundLastState == HIGH && soundCurrentState == LOW) {
        lampState = !lampState;
        digitalWrite(led, lampState);
        
        //blinks the sound led if the sound sensor hears a loud noise
        blinkSoundLed();
        
        //tells the lamp argon to toggle on or off
        Particle.publish("soundToggle", PRIVATE);
    }
}

int pirIn = D4;
int led = D7;
int statusLed = D6;
int state = LOW;
int val = 0;
int calibrationTime = 15000;
int modeState = LOW;
int lampState = LOW;
int secondsCounter = 0;

//time in seconds for the light to automatically turn off
//if the motion sensor does not detect movement
int motionResetTime = 10;

void setup() {
    
    Particle.subscribe("modeToggle", modeToggleState, MY_DEVICES);
    Particle.subscribe("lampChange", blinkLight, MY_DEVICES);
    
    pinMode(pirIn, INPUT);
    pinMode(led, OUTPUT);
    digitalWrite(led, LOW);
    pinMode(statusLed, OUTPUT);
    digitalWrite(statusLed, LOW);
    delay(calibrationTime);
    digitalWrite(led, HIGH);
    digitalWrite(statusLed, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    digitalWrite(statusLed, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    digitalWrite(statusLed, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    digitalWrite(statusLed, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    digitalWrite(statusLed, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    digitalWrite(statusLed, LOW);
    
    //converts auto turn off time from seconds to miliseconds
    motionResetTime = motionResetTime * 1000;
}

//blinks the D7 led 3 times, if the lamp changes state
void blinkLight(const char *event, const char *data) {
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, lampState);
}


void modeToggleState(const char *event, const char *data) {
    if (strcmp(data, "manual") == 0) {
        modeState = LOW;
    }
    
    else if (strcmp(data, "auto") == 0) {
        modeState = HIGH;
    }
}

void readTheSensor() {
    val = digitalRead(pirIn);
    if (val == HIGH) {
        lampState = HIGH;
        secondsCounter = 0;
    }
    else {
        secondsCounter = secondsCounter + 50;
    }
}

void updateLed() {
    if (val == HIGH){
        state = HIGH;
    }
    else {
        state = LOW;
    }
    digitalWrite(led, state);
}

void updateLampOnOff() {
    if (modeState == HIGH ) {
        if (lampState == HIGH) {
            Particle.publish("lampOnOff", "on", PRIVATE);
            //Particle.publish("touchToggle", PRIVATE);
            digitalWrite(statusLed, lampState);
        }
        else {
            Particle.publish("lampOnOff", "off", PRIVATE);
            //Particle.publish("touchToggle", PRIVATE);
            digitalWrite(statusLed, lampState);        
        }
        delay(1000);
    }
}

void loop() {
        readTheSensor();
        updateLed();
        
        //set the wait time to automatically turn off in miliseconds
        if (secondsCounter%motionResetTime == 0) {
            updateLampOnOff();
            lampState = LOW;
        }
        delay(50);
}

Credits

Comments

Please log in or sign up to comment.

MEGR 3171 IOT Project: Interactive Lamp

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

T16MOSO Circuit Diagram

T16TOUCH Circuit Diagram

T16LAMP Circuit Diagram

Live Data Graph Capture

Communication Flow Chart

Code

T16LAMP Code

T16TOUCH Code

T16MOSO Code

Credits

Eddie Rooke

Kelvin Limanto

Andrew Nguyen

Comments

Embed the widget on your own site

MEGR 3171 IOT Project: Interactive Lamp

MEGR 3171 IOT Project: Interactive Lamp

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

T16MOSO Circuit Diagram

T16TOUCH Circuit Diagram

T16LAMP Circuit Diagram

Live Data Graph Capture

Communication Flow Chart

Code

T16LAMP Code

T16TOUCH Code

T16MOSO Code

Credits

Eddie Rooke

Kelvin Limanto

Andrew Nguyen

Comments

Related channels and tags