You know those gaming PC's with their awesome LEDs spinning around? Well, I don't have one of those. But I am learning Linux on my Raspberry Pi. And I learn quicker by working on fun small side projects. So I decided to spice my Raspberry Pi up using the Pimoroni Blinkt.
In this post we're going to write a little Python script, and in the next post we'll turn the LEDs on as a background process at startup and switch them off again during shutdown.
Setting up the Blinkt is quite straight-forward. First, make sure to place the Blinkt on the Raspberry Pi's 40-pin header. The rounded corners of the Blinkt should align with the Pi's rounded corner.
Make sure you are logged into your Pi and in the terminal run
$ curl https://get.pimoroni.com/blinkt | bash
This will install the software you'll need to run the Blinkt. We're using the documentation to learn how to set up a linear blue/purple pattern.
Create and open a new Python file in your terminal. In my case I created one in the Pimoroni folder:
$ nano Pimoroni/blue_purple.py
I did this using the
nano editor. You can also create a file another way and open it in your preferred editor.
First, we need to import the libraries we need. At the top of the file we import
blinkt to control the LEDs,
time to create time-outs and
numpy to create a range of decimals later on.
#!/usr/bin/env python import blinkt import time import numpy
Create a list of colors in RGB format. With this, I mean that we create a list of lists. Each small list contains a number for r, g, and b.
Then we use
numpy to create a range of floats between
0.5. The range is made with steps of
0.03. This range will help us gradually light up each pixel.
COLOR_LIST = [[0, 127, 255], [0, 0, 255], [127, 0, 255], [255, 0, 255], [255, 0, 127]] BRIGHTNESS_RANGE = numpy.arange(0, 0.5, 0.03)
Add the following script to ensure that if the script stops, the LEDs clear.
We will create a function that takes a pixel, the RGB colors and a range of values that represent the different brightnesses as arguments. It will loop over the list of values for brightness and for every brightness value it will set a pixel with the correct color.
def set_brightness(pixel, r, g, b, brightRange): for brightness in brightRange: blinkt.set_pixel(pixel, r, g, b, brightness) blinkt.show() # we need to run show after setting the pixel # otherwise we won't see anything change. time.sleep(0.01) # give it a little time to add a slight effect.
Now we're going to get to the actual loop that is going to make our Pimoroni Blinkt light up.
We are going to start a while loop and inside loop over every color array in
When we run the script inside the terminal and press
CTRL-C it will throw a KeyboardInterrupt exception. Because we want to make sure we can stop our
While True loop, we use
try and listen for the exception to stop the loop.
The blinkt library has its own constant called
blinkt.NUM_PIXELS that spits out the amount of pixels that are available on the device. For every pixel, we call the
set_brightness function. We pass the pixel and RGB colors, together with the
try: while True: for color in COLOR_LIST: for pixel in range(blinkt.NUM_PIXELS): set_brightness(pixel, color, color, color, BRIGHTNESS_RANGE) for pixel in reversed(range(blinkt.NUM_PIXELS)): set_brightness(pixel, color, color, color, reversed(BRIGHTNESS_RANGE)) except KeyboardInterrupt: pass
Because we want the pixels to light up, and then gradually turn off again, we do a reversed for loop. See the difference between the two? We use
reversed(range(blinkt.NUM_PIXELS)) and we also send a reversed
This is it for now! Try it out by saving the file and running it:
$ python blue_purple.py
To stop the script, use
This is only the first part. In the next post, we will set up our Raspberry Pi so it starts running this script as a background process on startup, and close it when we shut the Pi down.
Check the finished script