Control Philips Hue Lights Automatically with Enviro pHAT

2022-06-09 | By Pimoroni

License: See Original Project

Courtesy of Pimoroni

Guide by Pimoroni

This tutorial will show you how to install the Enviro pHAT Python library, and ‎then utilize the advanced pi-lluminate.py example. You'll learn how the Enviro ‎pHAT can be used to sense the ambient light level in a room, and then turn ‎your Philips Hue lights on or off depending on how dark it is.‎

If you haven't already soldered the header to your Enviro pHAT, then you can ‎follow the guide to soldering pHATs here, or you can use our GPIO Hammer ‎Headers instead.‎

Installing the Software

It's always recommended to use the most up-to-date version of Raspbian, as ‎this is what boards and software are tested against, and it often helps to ‎start with a completely fresh install of Raspbian, although this isn't necessary.‎

As with most of the Pimoroni boards, there's a really quick and easy one-line-‎installer to get your Enviro pHAT set up. It's suggested that you use this ‎method to install the Enviro pHAT software.‎

Open a new terminal, and type the following, making sure to type y or n when ‎prompted:‎

curl https://get.pimoroni.com/envirophat | bash

Once that's done, it’s probably a good idea to reboot your Pi to let the ‎changes propagate, if the installer doesn't prompt you to reboot.‎

Configuring IFTTT

IFTTT (If This, Then That) is extremely useful. It allows you to create a wide ‎range of applets to trigger a variety of actions (i.e., if this happens, ‎then that should happen). For our pi-lluminate.py script to work properly, we'll ‎need to ensure our Philips Hue account is connected to our IFTTT account ‎and then we'll need to create an applet using the webhooks service.‎

Once you have created an IFTTT account and connected your Philips Hue ‎account, you'll want to create two new applets: one for when it's dark ,and ‎one for when it's light. Select this and then choose webhooks, then select ‎‎"Receive a web request". You'll be asked for an "Event Name", so pick ‎something appropriate such as dark. Then select the that option and ‎choose Philips Hue and finally "Turn on lights". You'll then be able to select ‎which lights you want to control from the drop-down menu.‎

Repeat this again, but this time set the "Event Name" to light and then select ‎‎"Turn off lights" in the "that" part. Once you have done this, you'll have two ‎webhook applets.‎

Get your webhooks

Now, you'll need to get the webhooks that will be included in our pi-‎lluminate.py example. To find these, go to your IFTTT account and select ‎‎"Services" from the menu and search for webhooks, or click here. You'll' see a ‎button called "Documentation" - click that and you'll see a screen similar to ‎this:‎

In the example above, we've blurred out our key, as anybody who knows this ‎could control your lights! The part to make note of is the URL that looks ‎like: https://maker.ifttt.com/trigger/{event}/with/key/YOURKEYISHERE as we'll need to ‎substitute the {event} with our "Event Name", i.e. dark and light, so your ‎webhooks will look ‎like

https://maker.ifttt.com/trigger/dark/with/key/YOURKEYISHERE and

https://maker.ifttt.com‎‎/trigger/light/with/key/YOURKEYISHERE.‎

Make note of your key and the two "Event Names" (dark and light) as we'll ‎need them later. If you wanted to, you could test that they worked by running ‎the example shown at the bottom, via the command line on your Raspberry ‎Pi:‎

curl -X POST https://maker.ifttt.com/trigger/dark/with/key/YOURKEYISHERE

Hopefully, your Philips Hue lights just turned on! If not, double check that ‎you've connected your account correctly and check the applets are ‎configured properly.‎

Using the Software

In order to use the pi-lluminate.py example, you'll need to make a few changes ‎to the bundled example to include the webhooks that we just created. The ‎easiest way to do this is by running the following inside the advanced folder ‎‎(assuming it is in /home/pi/Pimoroni/enviro-phat/examples/advanced):‎

nano /home/pi/Pimoroni/enviro-phat/examples/advanced/pi-lluminate.py

Find the line that starts with def turn_off(): and you should see there are two ‎variables called TRIGGER_WORD and TOKEN. Replace the "YOUR CHOSEN TRIGGER WORD ‎GOES HERE" in this section with light (or the "Event Name" that you used to ‎trigger the action to turn off your lights) and then replace "YOUR IFTTT TOKEN GOES ‎HERE" with the key that we made note of previously:‎

def turn_off():
    # Set your trigger word - e.g. "light" - and the IFTTT Webhook token below.
    TRIGGER_WORD = "light"
    TOKEN = "YOURKEYISHERE"

Do the same for the def turn_on():, except this time "YOUR CHOSEN TRIGGER WORD GOES HERE" will be dark (or the "Event Name" that you used to trigger the action to turn on your lights):

def turn_on():
    # Set your trigger word - e.g. "dark" - and the IFTTT Webhook token below.
    TRIGGER_WORD = "dark"
    TOKEN = "YOURKEYISHERE"

These variables are baked into the webhook commands within our script, so ‎you should not need to make any changes to the actual URL that is called. ‎Handy!‎

Adjusting the Sensitivity

The Enviro pHAT measures the amount of light, in units called Lux, using the ‎light sensor and we'll take advantage of this to measure the ambient light ‎level in the room and then trigger either the turn_on() function or ‎the turn_off() fucntion depending on the value.‎

We've chosen a low and high value in our code, but you if you find that your ‎lights are not turning on soon enough, or are turning off when it is still too ‎dark, you can tweak the values:‎

try:
    # Local variables.
    state = 0   # Sets the state for the lights.
    low = 260   # Low value for light level (lux).
    high = 300  # High value for light level (lux).
    period = 90 # Delay, in seconds, between calls.
    while True:
    # Get the average lux level first,
    room_light = average_lux()
    # Now check if the room is dark enough then turn on the lights.
    if room_light < low and not lights_on:
        turn_on()
        lights_on = True
    elif room_light > high and lights_on:
        turn_off()
        lights_on = False
    print("Waiting {} seconds before trying again".format(period))
    time.sleep(period)
except KeyboardInterrupt:
    pass

As you can see above, the low value is set to 260 Lux and the high value is set ‎to 300 Lux. We've set a state variable so that our code knows whether the ‎lights are on or off, to prevent the functions from being triggered constantly. ‎The period variable is the time, in seconds, between calls and we found ‎that 90 is a suitable number, but you can tweak this if you need to as well.‎

How It Works

Put simply, the pi-lluminate.py script uses the Enviro pHAT to measure the ‎ambient light level (in Lux) and calculates and average value over 60 seconds. ‎If the average value is below the low variable, the turn_on() function is triggered, ‎which sends a webhook to IFTTT that triggers the Philips Hue lights to turn ‎on.‎

Likewise, if the Enviro pHAT measures the ambient light level and is it above ‎the high variable, the turn_off() fucntion is triggered, which sends a webhook to ‎IFTTT that triggers the Philips Hue lights to turn off:‎

def average_lux():
    # Variables for calculating the average Lux levels
    start_time = time.time()
    curr_time = time.time()
    collect_light_time = 60
    collect_light_data = []

    # Calculate the average Lux level over 60 seconds
    print("Calculating average light level...")
    while curr_time - start_time < collect_light_time:
          curr_time = time.time()
          avg = light.light()
          collect_light_data.append(avg)
      time.sleep(1)
    # Take the last 45 data points taken over 60 seconds to calculate the average
    average_light = sum(collect_light_data[-45:]) / 45.0
    now = whats_the_time()
    print("Average over {collect_time} seconds is: {average} Lux. Last checked at {time}".format(
        collect_time=collect_light_time,
        average=average_light,
        time=now
    ))
    return average_light

Testing It Out

The easiest way to test this out is either to block the light sensor on the ‎Enviro pHAT with your hand, or to use a torch to shine more light on the ‎Enviro pHAT and see if your Philips Hue lights react by turning on or off. To ‎test, run the following command in your Raspberry Pi's terminal:‎

python /home/pi/Pimoroni/enviro-phat/examples/advanced/pi-lluminate.py

You should see a printout that says Calculating average light level... followed shortly ‎by Average over 60 seconds is: 255 Lux. Last checked at 13:43, but your values may vary ‎depending on what the Lux level is and what time it was recorded.

‎In theory, when the Enviro pHAT is covered with your hand, the lights should ‎come on in about a minute, and then should turn off again if you shine a ‎torch on the Enviro pHAT for about a minute. We found that without taking an ‎average reading, our lights were being triggered quite frequently, especially ‎on days where it was sunny then cloudy, then sunny again (i.e., typical British ‎weather!)‎

Taking It Further

You could automate when the script runs using a cron job, which is handy if ‎you want to control your lights at specific times of the day - i.e., during the ‎late afternoon / early evening. Alternatively, you could create a service that ‎runs when your Raspberry Pi boots, and it'll control your lights whenever you ‎need.‎

That's all folks!‎

Have questions or comments? Continue the conversation on TechForum, DigiKey's online community and technical resource.

Visit TechForum

Arduino | 3D Printing | Raspberry Pi