Earth Notes: On The Green Light Signal and Beyond (2021)

2021-04: Green Light Signal

In April 2021 the UK's National Grid created its Green Light Signal:

In a bid to help Britain understand where it gets electricity from, National Grid has launched the Green Light Signal - a low-energy light bulb designed to glow green when the electricity supply at home is cleanest so people can make smarter energy choices. The clever gadget is powered by National Grid's carbon intensity API (carbonintensity.org.uk), a carbon intensity forecasting tool with a regional breakdown, built by National Grid ESO, WWF and The University of Oxford and The European Defence Fund.

You put the lamp provided into a 'spare' light fitting which you leave on, set up some IoT magic, and the lamp stays off most of the time, but goes green when your bit of the GB grid is 'green'. (Well, this was my experience for the limited time that I ran it as supplied!)

I am very much in favour of simple traffic-light-style signals as a nudge for behaviour...

Many many thanks to Duncan Burt of National Grid for sending me one to try out and get my thoughts racing! This overcame my inertia trying to get something similar actually up and running!

Below I make some observations on the kit as delivered, and then subvert the whole thing for a somewhat different use case!

Critique of Pure Greenness

Hats off to National Grid for putting something together that works! That's always the hardest bit.

Here are some observations that may sound like carping, but are meant as honest analysis especially for my situation:

• This instructions rely on installing native apps in an Android or iOS (Apple) phone and having a capable home WiFi system:
  • Users may not have a smartphone.
  • Users may not have a smartphone running one of the supported operating systems.
  • Users may be averse to installing native apps, for privacy and security reasons. (I don't even run the store on my phone.)
  • Users may not have space for native apps (I don't on one of my candidate devices)
  • (The really key native app is reported as flaky by some users, and no official alternative is supported, and it took me a fortnight to find a way round this: more later.)
  • Users may not have a new enough device (I tried an old tablet and two old phones, all Andorid, that would load none or one of the apps at best).
  • Users may not have WiFi at home, or it may be too old or not capable (or this tech may get left behind as WiFi security gets upgraded over time).
  • Users may not wish to run IoT equipment on their home WiFi, for privacy and security reasons. (I don't, but was able to create a separate SSID for this.)
  • Users may not want to have a chatty device sitting inside their home, for privacy and security reasons.
  • Users may not want to have a device that may be used to attack their laptops and other devices or snoop on traffic inside their home, for privacy and security reasons.
  • Users may not wish to create more on-line accounts, for privacy and security reasons (I don't, and had to set up three new ones in order to do this).
  • Users may not be technically skilled enough to complete the quite complex setup.
  • Sometimes it is just going to be hard, however savvy the user.
  • Changing WiFi or ISP or anything may need all these hoops to be jumped through again.
  • There is a reset mechanism for the lamp itself so that it can be moved to another network. I'd say that with children in the house it's almost certain to be invoked by accident at least once, requiring everything to be set up again. At this point all boxes and notes will have been lost!
• This goes green when the electricity supply is relatively green:
  • That seems to be an invitation to use more at green times. In my opinion it is better to encourage using less, especially at bad ('red') times.
  • Green times are often in the wee hours of the morning, and I'm pretty sure that I don't want to be woken by a lurid bright green light then!
  • This encourages leaving something on all the time which is an additional vampire load.
  • This is a somewhat expensive single-purpose gadget, and has a UCE (Upfront Carbon Cost) and running cost for that one task.
  • This presumes someone's home is large enough to have a 'spare' light fixture that can be left on, and that will be noticed when the green signal fires up!
  • The lamp provided is an ES27 (spotlight screw) fitting, with a B22 bayonet adaptor. With the adaptor it is going to be too long for many fittings, for example one of my good candidates (our hallway).

Quite a lot of this is unmitigated inherent IoT setup complexity, some is use case selection.

A More Gentle Way?

Before I come to all the technical detail, here's what my re-spin of the signal looks like.

(I'm still tuning it. As of this writing I am quietly running a couple of lamps on my new scheme, waiting for spontaneous comment from the family...)

My approach is to avoid dedicating a whole light fitting and lamp. Instead, I tweak the colour of a lamp when it is in use. The light is switched on and off at the wall switch as usual. So I'm not adding any new load to the grid. Nor am I requiring a 'spare' that may not exist.

I have the lamp on a normal warm-ish white most of the time. When the grid is relatively green, tinge the lamp colour green. When the grid is high carbon intensity (or other factors), tinge the lamp red and dim it a little. Possibly have it 'breathe' a little to gently get attention that saving energy would be a good thing now.

Basically just a light that is switched on and off as usual, providing light when light is needed, and carrying a subtle hint when needed. No computer interface need be touched in normal use.

A lamp does double duty.

This does not deliver a grid green/red signal if you don't have a light on. Is that a problem? My working hypothesis is: probably not.

(I also have this working on a GU10 style bulb, which will suit quite a few more locations in typical GB households. In fact the way that I have set it up currently, I can control any number of lamps simultaneously, sprinkled throughout the house, though I have just two for now!)

GU10s might be especially good for kitchens where a lot of household peak-time demand happens.

Diary of an Install

Here is a summary of my journey to get the Green Light Signal set up, and then me going "off piste"!

I was busy with other things, so this took quite a while! At least I did not give up and leave it to gather dust somewhere...

2021-04-23: arrival and first impressions

The Green Light Signal package arrived late afternoon on the 23rd April from National Grid ESO. Thank you!

The box contains a leaflet, and what turns out to be a smart lamp in the manufacturer's cardboard tube inside a National Grid card sleeve. (I took a while to work out how to get into the lamp.) All sitting in a bed of something like hay, nicely presented.

The package could have been smaller and lighter and cheaper. (I'm thinking embedded / upfront carbon and other eco costs here!)

An initial inspection showed that the lamp requires an ES27 (spotlight, screw) style socket (or a B22 bayonet socket with the supplied adaptor). We don't have either of those in all rooms these days.

The system also seems to require downloading native apps for LIFX (the lamp is an LIFX Mini Colour, 9W 800lm) and IFTTT, and setting up (new) accounts for both. The IFTTT account may (eventually) cost money, it's not clear.

For security reasons I don't have the Play Store running, nor therefore in general run native apps on my own phone! So I have dug out some older (Android) devices to see if I can use one of them.

The LIFX app will load on my old Huawei tablet (Android 4.4.4) but seems to fail silently when trying to register an account. It seems to believe that it is not connected to the Internet, though it is. The LIFX 'virtual bulb' feature does seem to interact with my MacBook just fine.

There does not seem to be an IFTTT app that will even load on the tablet.

I note that Amazon has an LIFX GU10 multicolour lamp available.

It may not be necessary to to run the native IFTTT app on the phone. I may be able to set IFTTT up via my laptop browser.

I have dug out an old LG phone with Android 5.x. Downloading LIFX (V3.1) app onto that seems to work. I am reluctantly creating an account registering against one of my web mail accounts with relatively good SPAM defences.

The LIFX app detects the lamp when I turn it on at the wall, but seems unable to actually connect to it. An eventual failure pop-up starts Oops, that didn't work.

Before that is sometimes a smaller warning/notification of the form:

Cannot search all WiFi networks. Check SIM card ...

or

Internet not available for {lamp name}

So I'm currently stuck.

The set-up seems to require something that I don't have, or that I am not prepared to use for privacy and security reasons.

LIFX lamp retains state when turned off

An important discovery in the middle of all of this: when turned off at the wall an LIFX lamp retains the colour and brightness that it was last set to. Turning on again at the wall has the lamp continue just as it was before being turned off.

Thus always setting the lamp over WiFi to a full (or near full) brightness value will mean that the user can just switch the light on and off at the wall in the obvious way without going near a computer.

Sending the target colour at least every few minutes to the lamp will allow it to respond reasonably fast to changes in grid conditions. That update by default (if updating to the colour/brightness already shown) is invisible, ie no flicker or other annoyance.

2021-05-16: lifx-hacks and contact!

Yesterday someone pointed me at LIFX Hacks.

With lifx-hacks I was able to bind the bulb to my now IoT-only WiFi SSID! Hurrah!

Yes it was as I had guessed: lifx-hacks passes your WiFi SSID and password to the lamp, which uses them to connect as a client.

It's really not clear to me (nor many others) what LIFX gains by being obstructive on this point. LIFX could even issue a tiny Windows 10 (or Android, iOS, Linux, etc) program to do just this.

Now LIFX's (unsupported) Windows 10 app let me 'claim' the lamp for my cloud account as the Android app should have done.

Three weeks' delay and a lot of effort...

After this things began to race ahead.

I was quickly able to, in IFTTT, connect with the Green Light Signal applet.

A few minutes later, the bulb had turned (lurid) green, which accords with carbonintensity.org.uk for this area.

(To keep things as simple as possible, in the DHCP server on my router, I fixed the IP address for the lamp, in case I want to talk to it directly.)

The updates seem to be coming in, a little irregularly, every couple of minutes.

About an hour after first getting the GLS/IFTTT combo driving my lamp, and because carbonintensity.org.uk was showing London as green for a day or so, I changed the 'postcode' to 'Nation' in the IFTTT config ('England' was amber), and a couple of minutes later the light went off!

Turning the lamp off at the wall and back on had it come on dimly. I don't think that this UX is going to work for me!

Better for me might be:

• when grid green make the light go green-ish if on
• when grid red make the light go red-ish if on, maybe with some 'breathing'
• otherwise leave light on at warm white and full brightness.

About half an hour later I disconnected the Green Light Signal app in IFTTT!

I then set about controlling the lamp directly from my MacBook, and my Raspberry Pi server using my own live GB Grid Carbon Intensity traffic-light signals. I describe this in more detail below.

By bedtime I was all set up.

2021-05-18: LIFX GU10

I took a punt and hoped that the same lifx-hacks magic would work more generally.

I had ordered a LIFX GU10 multicolour lamp (6W 400lm) from Amazon (£47.50 including P&P + VAT), and it arrived today.

I bound it to my IoT WiFi SSID with lifx-hacks which was quick. Then the new lamp was working alongside the other one!

I initially set up all the colour changes to be done by broadcast, which meant that no extra code was needed for the second lamp. With the two lamps in the same room the both seem to change at once in response to each command.

The original lamp is staying in my study.

The GU10 lamp has been put on one of the two GU10 strings in the kitchen, illuminating the corner with the kettle. I'm hoping that that light string will be on when there is lots of (say) cooking to be done, and can therefore provide a non-annoying grid status. The 'red' and 'green' signals are relatively subtle tints.

Note that I have not claimed this new lamp in my LIFX cloud account. I don't know if it's calling home or not, though it has no need to, since all control is local within my building LAN.

Technical Details

Here is more technical detail from some of the diary steps and beyond.

lifxlan

I installed it with pip (or pip3) on both my MacBook and my RPi server.

I then had one of the example scripts supplied with the lamp powered up:

% python3 hello_world.py

Discovery will go much faster if you provide the number of lights on your LAN:
  python hello_world.py <number of lights on LAN>

Discovering lights...

Found 1 light(s):

LIFX Mini 633F93
  MAC Address: d0:73:d5:63:3F:93
  IP Address: 192.168.0.XXX
  Port: 56700
  Service: UDP
  Power: On
  Location: 16WW
  Group: 5s
  Color (HSBK): (21845, 65535, 65535, 3200)
  Host Firmware Build Timestamp: 1574901399000000000 (2019-11-28 00:36:39 UTC)
  Host Firmware Build Version: 3.6
  Wifi Firmware Build Timestamp: 0 (1970-01-01 00:00:00 UTC)
  Wifi Firmware Build Version: 0.0
  Vendor: 1
  Product: 49 (LIFX Mini Color)
  Version: 16843010
  Features: {'color': True, 'temperature': True, 'infrared': False, 'multizone': False, 'chain': False, 'matrix': False, 'min_kelvin': 1500, 'max_kelvin': 9000, 'hev': False, 'relays': False, 'buttons': False}
  Current Time: 1937257498000 (1970-01-01 00:32:17.257498 UTC)
  Uptime (ns): 1937257498000 (0.54 hours)
  Last Downtime Duration +/-5s (ns): 0 (0.0 hours)
  Wifi Signal Strength (mW): 5.011870030102727e-07
  Wifi TX (bytes): 3877702633
  Wifi RX (bytes): 3877702633

I'm impressed with lifxlan. I'm using a couple of its example scripts directly. I have modified another for some specialised polling.

Note that to receive responses to broadcasts, eg polling what state all lamps are in, I had to open up a little the firewall running on my RPi itself.

Integration with traffic light page

Once every 5 or 10 minutes on my RPi server, a script is run to update the live GB Grid Carbon Intensity page.

I added a hook into the end of that, and a couple of other times in a ten-minute cycle, to run a script that currently looks like this:

#!/bin/sh
# Broadcast grid intensity to all LIFX lamps.

# $1 is the intensity to signal:
#   * "auto" to use the flags set by the trafficLights application.
#   * "red" for high grid intensity.
#   * "green" for low grid intensity.
#   * "warm" for warm-white general room lighting.
#   * "noon" for near-noon cooler white general room lighting.
#   * "yellow" or anything else gives a 'normal' status, warm/noon.

# Normal can be signalled by a white normal lamp colour.
# The other colours are shown as somewhat unsaturated versions
# so as to not be too annoying.
#
# In future they may breathe, and/or more states may be shown.

# Requires the lifxlan package to installed and locatable at run-time.
# https://github.com/mclarkk/lifxlan

# Colours to set the LIFX lamps to.
# 'Warm' and 'daylight' whites.
WARM_WHITE="58275 0 65535 3200"
WHITE="58275 0 65535 5500"
# Red and green are desaturated to be a subtle hint!
RED="65535 7000 55000 3200" # Dim a little to save some more energy!
PRERED="65535 20000 50000 3200" # Pre-red flicker to emphasise red.
GREEN="16173 10000 65535 3200"

# Default to DEFAULT_COLOUR, ie warm white (~3200K).
# But in middle of day use a cooler white (~5500K).
DEFAULT_COLOUR="$WARM_WHITE"
SOLARHOUR="`date -u +%H`"
if [ "$SOLARHOUR" -ge 8 -a "$SOLARHOUR" -lt 16 ]; then
    DEFAULT_COLOUR="$WHITE"
fi
COLOUR="$DEFAULT_COLOUR"

# Process command argument.
case "$1" in
auto)
    if [ -f _gridCarbonIntensityGB.red.flag ]; then COLOUR="$RED";
    elif [ ! -f _gridCarbonIntensityGB.flag ]; then COLOUR="$GREEN";
    fi;;
red) COLOUR="$RED";;
green) COLOUR="$GREEN";;
warm) COLOUR="$WARM_WHITE";;
noon) COLOUR="$WHITE";;
esac

# If on red, attract attention gently.
if [ "$RED" = "$COLOUR" ]; then
    python3 .work/script/lifxlan/broadcast_color.py $PRERED
    sleep 0.5 || sleep 1
fi

# Invoke lifxlan example script!
exec python3 .work/script/lifxlan/broadcast_color.py $COLOUR

This does too much and is too clever and also probably needs more tuning!

Note the final line (and a few above it) broadcast_color.py. That is one of the supplied example scripts. Run it with either a single colour argument such as "RED" or a HSBK (Hue Saturation Brightness Kelvin) tuple, and all the lamps are set to that colour.

There's a bit in the middle that uses _gridCarbonIntensityGB*.flags as described in the GB Grid Carbon Intensity page to decide which colour to set the lamp if "auto" is passed in. Else if "red" or "green" are passed in those colours are used. Else a normal white colour is used, as for a normal manually switched lamp! That white will be cooler near to noon, because I can.

Note that the red and green are hints of colour rather than being lurid, so that the lamp still works as a manually-switched lamp.

Additionally, when red, it is dimmed a little (which may save power too), and there is a brief more saturated dip on each update as a stronger hint.

Shaky video of sequence of "noon" "noon" "red" "red" "warm" "warm" "green" "green" with 5-second gaps as seen in corner of kitchen (video heavily compressed by clideo.com):