Synchronized Light Switch

This project uses two Particle Photons and photoresistors to synchronize a pair of light switches in a combined living room/kitchen.

IntermediateFull instructions provided825

Things used in this project

Hardware components

Particle Photon

Male/Female Jumper Wires

Resistor 221 ohm

Photo resistor

Futaba S3003 Standard Servo

Male/Male Jumper Wires

Software apps and online services

ThingSpeak API

Story

In the on campus apartments at UNCC, the living room and kitchen are combined into a single large room. This causes some problems, since the two parts of it are lit with different light sources controlled by different light switches. This can create situations where there is a pretty significant light gradient across the room, especially at night.

This project uses two IoT connected Particle Photons to control the light switch for the living room portion of the apartment in order to equalize the light level in the whole room. Essentially, If the living room area is darker than the kitchen area, then a servo flips on the light switch for the living area. If the kitchen area is darker than the living room area, then the servo flips the switch off.

The first photon uses a pair of photoresistors to determine the relative light level in each portion of the room. One photoresistor is attached to the back wall of the kitchen area such that it has no direct line to the light source in the living area, but is almost directly below the kitchen area light. For our physical setup, this required running a pair of wires from the points where the photoresistor appears on our schematic to its actual location, since the Photon was installed several feet away. The other photoresistor has a direct line of sight ot both the light in the living area and the window, the two primary sources of light in the living area, but is in shadow when only the kitchen light is on. For our physical setup, this photoresistor was able to remain on the same breadboard as Photon#1. The two photoresistors are in parallel with each other and each in series with a 221 Ohm resistor. Jumper wires connect the parts of the circuit between each photoresistor and their respective regular resistor to ports on the Photon configured as analog read. The software on this Photon (called Light Sensor Code below) takes an average value from each photoresistor circuit over about 1.5 seconds and compares them. If a boolean tracking the status of the living room light switch indicates the switch is down, and the photoresistor reading from the living area lower than the reading from the kitchen area, then the Photon publishes an event called "On125". If the photoresistor reading from the living area is not lower, and the boolean is in the other position, then the photon publishes the event "Off125". The boolean tracking the lightswitch position is controlled by the event "LightsLog", which is published by the second Photon and subscribed to by the first.

The second photon physically controls the living area light switch using a servo motor. This is connected directly to Photon#2, getting its power supply from the Vin and GND ports on that Photon and its control data via PWM signal from port D0. On the software side, this photon is using the Particle servo control functions and is subscribed to the events "On125" and "Off125" from Photon#1. When "On125" is published, the Photon sets the servo to 120 degrees and publishes the event "LightsLog" with the data "On". When "Off125" is published, the Photon sets the servo to 15 degrees and publishes the event "LightsLog" with the data "Off". These servo position degree values were determined through testing as the smallest amount of movement in the servo that allowed it to reliably flip the light switch.

1 / 7 • Photosensor Photon

ThingSpeak Channels:

ThingSpeak is an open IoT platform that connects to MATLAB and can provide data analytics. In this case, webhooks in the code on each of the Photons used in this project send light level and servo position data whenever the system turns the light switch on or off. Samples of the data are shown below the links to the ThingSpeak channels providing real time data on the system for each aspect.

One limitation of the ThingSpeak system is that the free version only allows a channel to accept new data every 15 seconds, which means that rapid switching of the light on and off would not appear on the ThingSpeak channel correctly. To combat this, 15 second delays would need to be put into the code for the light switch, which would reduce its effectiveness at synchronizing the lights in the main room of the apartment.

Kitchen Light Level

Living Room Light Level

Servo Position

Code

int led = D7;
int ph1 = A0;
int ph2=A1;
int power = A5;
int LightKitchen;     
int LightLiving;
bool Darker= false;
int On=1;
int Off=1;

//This section of code assigns the pins on the Particle Photon, and names 
//variables that will be used later in the code.

void setup() {
    pinMode(led,OUTPUT);
    pinMode(power,OUTPUT);
    pinMode(ph1, INPUT);
    pinMode(ph2, INPUT);
    
    digitalWrite(power,HIGH);
    
     Particle.variable("LightKitchen", &LightKitchen, INT);
     Particle.variable("LightLiving", &LightLiving, INT);
    
    Particle.subscribe("LightsLog", Lightflip, "420038000c47363433353735");
    
}

//This section of the code defines how each pin used will function as well as
//well as the variables used to establish light level in the kitchen section and living section of 
//the room.  It also turns on the power supply to the photoresistors.

void Lightflip (const char *event, const char *data){
    if (strcmp(data,"On")==0) {
    
    Darker=false;
    Particle.publish("DarkStatus", "Darker=false");
  }
  else if (strcmp(data,"Off")==0) {
    
    Darker=true;
    Particle.publish("DarkStatus", "Darker=true");
  }
  else {
    
  }
}

void loop() {
    
   int loopdelay=2000;
   delay(loopdelay);
   int gap=300;
    int In1 = analogRead(ph1);
    int Out1= analogRead(ph2);
    delay(gap);
    int In2= analogRead(ph1);
    int Out2= analogRead(ph2);
    delay(gap);
    int In3= analogRead(ph1);
    int Out3= analogRead(ph2);
    delay(gap);
    int In4= analogRead(ph1);
    int Out4= analogRead(ph2);
    delay(gap);
    int In5= analogRead(ph1);
    int Out5= analogRead(ph2);
    delay(gap);
    LightKitchen=(In1+In2+In3+In4+In5)/5;
    LightLiving=(Out1+Out2+Out3+Out4+Out5)/5;
    //This section takes the average of 5 readings over 1.5 seconds for each of the photosensors to 
    //get a more accurate measurement of the light level in each part of the room.
   
    
    
    
   if (LightLiving < LightKitchen){
       if (Darker==true){
        Particle.publish("On125", String(On));              //Publishes the event that will cause the 
                                                            //other photon turn on the Living Room section Light Switch
        digitalWrite(led,HIGH);                             //Turns on Indicator LED
        Particle.publish("LightKitchen", String(LightKitchen));   //Publishes the event that allows a webhook 
                                                            //to get data from the inside photosensor
                                                            //to ThingSpeak graph
        delay(16000);
        Particle.publish("LightLiving", String(LightLiving)); //Publishes the event that allows a webhook 
                                                            //to get data from the photosensor outside
                                                            //to ThingSpeak graph
        }
        
        
    }
    else {
        if (Darker==false){
        Particle.publish("Off125",String(Off));             //Publishes the event that will cause the 
                                                            //other photon to begin opening the blinds
         digitalWrite(led,LOW);                             //Turns off Indicator LED
         delay(16000);
         Particle.publish("LightKitchen", String(LightKitchen));  //Publishes the event that allows a webhook 
                                                            //to get data from the Kitchen photosensor
                                                            //to ThingSpeak graph
        Particle.publish("LightLiving", String(LightLiving)); //Publishes the event that allows a webhook 
                                                            //to get data from the photosensor in the 
                                                            //living room section to ThingSpeak graph
        }
        
    }
        
}
    
//This loop checks the analogue value of the photoresistor in the kitchen section and compares it to the
//analogue value of photoresistor on the side of the counter measuring the living room light leel.  Then, 
//depending on whether the light level is higher inside or outside, the Particle publishes an event to the 
//console, with the event reading either "On" or "Off."

//ServoLightSwitch
// Connect RED wire to VIN (~5V)
// Connect ORANGE, YELLOW, or WHITE wire to A0 (servo signal)
// Connect BLACK or BROWN wire to GND (0V)
// Adjust these connections for your particular servo
// if you have a wiring diagram for it
//----------------------------------------------------------------------------

Servo myservo;
                // create servo object to control a servo
                // a maximum of eight servo objects can be created

int pos = 0;    // variable to store the servo position
int led= D7;
int angle=0;
void setup()
{ 
    Particle.subscribe("Off125", turnoff, "43003a000547363332363639");
    Particle.subscribe("On125", turnon, "43003a000547363332363639");
    
    pinMode(led,OUTPUT);
    
    myservo.attach(D0);
    myservo.write(10);
    angle=myservo.read();
    Particle.publish("Servo_Start",String(angle));
  
  // register the Spark function
  Spark.function("servo", updateServo);
  }
int updateServo(String command)
{
  // convert string to integer
  uint8_t pos = command.toInt();
  
  
}

void turnoff(const char *event, const char *data)
{
    digitalWrite (led, HIGH);
    int angle_start=myservo.read();
    pos=15;
    myservo.write(pos);
    Particle.publish("LightsLog","Off");
    angle=myservo.read();
    delay(16000);
    Particle.publish("Servo_Position",String(angle_start));
    delay(16000);
    Particle.publish("Servo_Position",String(angle));
    
}
void turnon(const char *On125, const char *On)  
{
    digitalWrite (led, LOW);
    int angle_start=myservo.read();
    pos=120;
    myservo.write(pos);
    Particle.publish("LightsLog","On");
    angle=myservo.read();
    delay(16000);
    Particle.publish("Servo_Position",String(angle_start));
    delay(16000);
    Particle.publish("Servo_Position",String(angle));
  }