Flashers in CircuitPython

January 20, 2021 ⁓ 8 min read

I just started playing around with CircuitPython on the Adafruit Trinket M0 microcontroller. Instead of doing the usual blink program, I thought how about blinking the DotStar RGB LED like a police car flasher.

Here are the stages of evolution of my flasher program. I am really rusty with Python and new to CircuitPython so I cannot guarantee that this is the best way, but it is the way I took.

Stage 1: basic red/blue flasher

First, the only libraries you need to add to the /lib directory are adafruit_dotstar and adafruit_pypixelbuf. This is just the typical infinite loop blinking a pattern. It seemed to me that police cars blink red, red, then blue, blue (I know that there are many variants, but this is the one I was going for).

While developing this program, I found out that setting the brightness to 1.0 really bothers the wife — not my intention, but good to know.

"""Red/Blue Police Flasher"""

import time
import board
import adafruit_dotstar

led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led.brightness = 0.5

while True:
    led[0] = (255, 0, 0)
    time.sleep(0.05)
    led[0] = (0, 0, 0)
    time.sleep(0.05)
    led[0] = (255, 0, 0)
    time.sleep(0.05)
    led[0] = (0, 0, 0)
    time.sleep(0.4)
    led[0] = (0, 0, 255)
    time.sleep(0.05)
    led[0] = (0, 0, 0)
    time.sleep(0.05)
    led[0] = (0, 0, 255)
    time.sleep(0.05)
    led[0] = (0, 0, 0)
    time.sleep(0.4)

Stage 2: symbolic value cleanup

The first version has way too many hard-coded values. It makes tweaking the timing or the colors a real pain. Let’s do some cleanup.

"""Red/Blue Police Flasher"""

import time
import board
import adafruit_dotstar

led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led.brightness = 0.5

SHORT = 0.05
LONG = 0.4

RED = (255, 0, 0)
BLUE = (0, 0, 255)
OFF = (0, 0, 0)

while True:
    led[0] = RED
    time.sleep(SHORT)
    led[0] = OFF
    time.sleep(SHORT)
    led[0] = RED
    time.sleep(SHORT)
    led[0] = OFF
    time.sleep(LONG)
    led[0] = BLUE
    time.sleep(SHORT)
    led[0] = OFF
    time.sleep(SHORT)
    led[0] = BLUE
    time.sleep(SHORT)
    led[0] = OFF
    time.sleep(LONG)

That is much better. It is easier to play with the timing now. So what is next?

Stage 3: creating a data structure

Using symbolic names for the colors and durations does make it easier to edit but there is still a lot of repetitive code. If we could move the pattern into some sort of data structure, it would be even more compact. Also, this opens up the possibility of having multiple flashing patterns.

I decided to put the patterns into a dictionary with each entry being an array of tuples containing the color (with the colors themselves being tuples) and duration. Using the patterns dictionary makes it much easier to add or edit any of the patterns. I added an “off” pattern as my second one (I know, it isn’t very exciting).

To display the police pattern is now down to three lines of code instead of 16. I also added a few more colors and tweaked the value of the long duration.

"""Light Flasher"""

import time
import board
import adafruit_dotstar

led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led.brightness = 0.5

SHORT = 0.05
LONG = 0.25

RED = (255, 0, 0)
AMBER = (255, 255, 0)
BLUE = (0, 0, 255)
WHITE = (255, 255, 255)
OFF = (0, 0, 0)

patterns = {
    "police": [
        (RED, SHORT),
        (OFF, SHORT),
        (RED, SHORT),
        (OFF, LONG),
        (BLUE, SHORT),
        (OFF, SHORT),
        (BLUE, SHORT),
        (OFF, LONG)
    ],
    "off": [
        (OFF, 100)
    ]
}

while True:
    for light in patterns["police"]:
        led[0] = light[0]
        time.sleep(light[1])

Stage 4: adding patterns

Let’s add a few more patterns. I took a shot at hazard (such as the amber flashers on a tow truck) and firetruck (red and white pattern).

"""Light Flasher"""

import time
import board
import adafruit_dotstar

led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led.brightness = 0.5

SHORT = 0.05
LONG = 0.25

RED = (255, 0, 0)
AMBER = (255, 255, 0)
BLUE = (0, 0, 255)
WHITE = (255, 255, 255)
OFF = (0, 0, 0)

patterns = {
    "police": [
        (RED, SHORT),
        (OFF, SHORT),
        (RED, SHORT),
        (OFF, LONG),
        (BLUE, SHORT),
        (OFF, SHORT),
        (BLUE, SHORT),
        (OFF, LONG)
    ],
    "hazard": [
        (AMBER, SHORT),
        (OFF, SHORT),
        (AMBER, SHORT),
        (OFF, LONG)
    ],
    "fire": [
        (RED, SHORT),
        (OFF, SHORT),
        (RED, SHORT),
        (OFF, LONG),
        (WHITE, SHORT),
        (OFF, SHORT),
        (WHITE, SHORT),
        (OFF, LONG)
    ],
    "off": [
        (OFF, 100)
    ]
}

while True:
    for light in patterns["fire"]:
        led[0] = light[0]
        time.sleep(light[1])

We are on the right track, but having to edit the code to select which pattern to display needs to change.

Stage 5: switching patterns by touch

The Trinket M0 has capacitive touch sensors. Let’s use pin 3 for touch input. This input will be used to cycle through the patterns. I set up interator p to be able to go through the patterns. Notice that the current pattern name is written to the serial console.

The loop for flashing the pattern now uses the pattern variable to select the pattern instead of a hardcoded value.

Now for the tricky part. After displaying the flasher pattern, we check the touch input to see if it is on. Realize here that the full pattern is displayed before the touch input is checked. Thus, if you have a really long pattern, it can take a while before the input is detected. Notice that I changed the “off” pattern from 100 seconds to 1 second.

When a touch is detected, pattern is set to the next pattern in the patterns dictionary. Once the end of the dictionary is reached, the iterator does not just start back at the beginning (let me know if there is a way to make it do so). Instead, it will throw a StopIteration error. I put in a try/except block to catch this error and restart the iterator. I do not know if this is the best way to handle this, but it works.

Some small tweaks:

Added a medium duration value, MED
Changed the “hazard” pattern to use the medium duration (I really need to look at the flashing pattern of the next tow truck I see)
Changed the white color. It had a pink tint to my eyes so I toned down the red a bit.

"""Light Flasher"""

import time
import board
import adafruit_dotstar
import touchio

led = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)
led.brightness = 0.5

touch = touchio.TouchIn(board.D3)

SHORT = 0.05
MED = 0.1
LONG = 0.25

RED = (255, 0, 0)
AMBER = (255, 255, 0)
BLUE = (0, 0, 255)
WHITE = (223, 255, 255)
OFF = (0, 0, 0)

patterns = {
    "police": [
        (RED, SHORT),
        (OFF, SHORT),
        (RED, SHORT),
        (OFF, LONG),
        (BLUE, SHORT),
        (OFF, SHORT),
        (BLUE, SHORT),
        (OFF, LONG)
    ],
    "hazard": [
        (AMBER, MED),
        (OFF, MED),
        (AMBER, MED),
        (OFF, LONG)
    ],
    "fire": [
        (RED, SHORT),
        (OFF, SHORT),
        (RED, SHORT),
        (OFF, LONG),
        (WHITE, SHORT),
        (OFF, SHORT),
        (WHITE, SHORT),
        (OFF, LONG)
    ],
    "off": [
        (OFF, 1)
    ]
}

p = iter(patterns)
pattern = next(p)
print(pattern)

while True:
    for light in patterns[pattern]:
        led[0] = light[0]
        time.sleep(light[1])

    if touch.value:
        try:
            pattern = next(p)
        except StopIteration:
            p = iter(patterns)
            pattern = next(p)

        print(pattern)

Next steps

So where can we go from here? I have a few ideas, such as:

use a toggle switch to control the brightness
install it into a case and add a battery
add a power switch so that the battery does not run down (even when in the “off” pattern)
add a siren