Blog My Wiki!

In the first part of this project, we made some traffic lights out of LEDs attached to a Raspberry Pi computer, and we wrote code to make them light in sequence using the Python programming language.

This was made really easy because we used a Python library called GPIO Zero. Now we’re going to add a button to simulate a pedestrian crossing, and we’ll see just how incredibly easy that is, thanks again to GPIO Zero.

First, we need to find a switch and connect it to the Raspberry Pi. I used a tiny button that fits on my breadboard, but you can use any button as long as it’s ‘fleeting’ – that means it should pop back out when you let your finger off it.

I wired up one side of my button to GPIO 3 (that’s the blue wire in the diagram below), and the other side back to our common earth / GND (that’s column 7 A-E on my little breadboard). The wiring diagram now looks something like this:

In real life, it looks something like this:

Open Python 3 / IDLE, and edit the traffic-lights.py code from last time, to look like this:

You can copy and paste the code from here:

from gpiozero import LED, Button
from time import sleep

red = LED(18)
amber = LED(2)
green = LED(17)
button = Button(3)

print("Press the button when you want to cross.")

green.on()
amber.off()
red.off()

while True:
    print("Wait")
    button.wait_for_press()
    green.off()
    amber.on()
    sleep(5)
    amber.off()
    red.on()
    print("Cross now.")
    sleep(10)
    amber.on()
    sleep(5)
    green.on()
    amber.off()
    red.off()

Now when you run the code (press F5), the traffic lights should stay green, until you press the button. This is like the button on a pedestrian crossing. Then the lights should change and you get a message in the console window telling you to cross – when the traffic light is red.

Let’s look at some new instructions we’ve used here.

from gpiozero import LED, Button

Here we’ve imported the ‘Button’ function (as well as the ‘LED’ one we used before) from the GPIO Zero library.

button = Button(3)

This tells the Raspberry Pi that we’ve connected a button to GPIO pin 3.

print("Press the button when you want to cross.")

This prints a message in the console window. That’s how we know when to cross.

button.wait_for_press()

This is a really, really clever instruction. It pauses our code until you press the button – useful because we want the traffic lights to stay green, until we want to cross the road.

So that’s it – you’ve made a working pedestrian crossing – sort of!

If you want to take this project further, here are a few ideas:

• Instead of printing ‘wait’ and ‘cross now’ in the console, add red and green LEDs for a separate set of lights for the pedestrian. Build them into a box with the button, perhaps using an old soap box.
• Add a buzzer to go BEEP BEEP BEEP when you can cross.
• Add another button for the other side of the road. Can you make the WAIT lamp light on the other side when a pedestrian presses the button to cross?
• Add another set of traffic lights for cars, and build them into cardboard tubes like toilet roll holders.

I’m really excited about a Python library called GPIO Zero. This makes it very easy to use the Raspberry Pi’s GPIO pins to do some physical computing in the Python programming language. The GPIO pins are how you connect your Pi to the real world, and their accessibility is what makes the Rapsberry Pi such an exciting device for so many people.

Here’s a simple traffic light project you could use to introduce Python and physical computing at the same time. You can get ready-made traffic light kits, but you make this one yourself.

Aim
In this project you will make a pedestrian crossing with 1 set of traffic lights and a push button, and learn how to connect your Raspberry Pi to lights and switches, and also learn some simple concepts of the Python programming language.

You will need:

• A Raspberry Pi (any model should do) with a recent version of Raspbian OS and the GPIO pins physically accessible – the Pibow Coupé case is good for this.
• An internet connection to install the GPIO Zero Python library (not needed thereafter).
• 3 LED lights, preferably red, yellow and green.
• A small breadboard (I used a tiny one I got with an Arduino kit).
• Some female – male jumper wires to connect to your Pi.
• Some male-male jumper wires to connect things on your breadboard to each other.
• 3 x 270Ω (or similar) resistors.
• A push button switch – any kind will do, as long as it’s a fleeting switch that pops back up after you press it, and you can connect it to your breadboard.

Getting ready
First, install GPIO Zero. You can find instructions here. I got some error messages when I did this, but it still seems to work ok.

Next, choose some GPIO pins on your Pi to use. You can use others, but I used pins 17, 18 and 2 using the BCM numbering system. (There are two different ways of numbering the Raspberry Pi pins; GPIO Zero uses the BCM / Broadcom system, which is how the pins are labeled on the Pibow Coupé case). If you’re not sure which pin is which, look at this incredibly clever & comprehensive interactive guide by Gadgetoid.

With your Pi turned off, wire up some light bulbs before we get programming. Use 4 female-male jumper wires to connect BCM pins 17, 18, 2 and a GND (ground/earth) pin – I used physical pin 6 as my GND, though there are others – to separate rows on your breadboard. It could look something like this:

I used the GND pin as a common earth for all the LEDs. When you wire up a light bulb in school, you need to complete a circuit by connecting it back to the negative terminal on a battery, and this is the same – completing the circuit by connecting it back to GND. We can use the same GND for all our LEDs to make our wiring simpler.

The basic idea is that you connect GPIO Pin 17 on the Raspberry Pi to a 270Ω or 330Ω resistor – this is to stop the LED taking too much current from the Pi. You then connect the other side of the resistor to the long leg of the LED, and the short leg of the LED back to the GND pin on the Pi. You do the same for the other LEDs, all using the same GND pin.

The wiring looks a bit like this:

Now turn the Raspberry Pi on and test the LEDs and wiring. Open the Python IDLE editor (Menu > Programming > Python 3):

and enter the following Python code in the shell:

from gpiozero import LED
green = LED(17)
red = LED(18)
amber = LED(2)
green.on()
amber.on()
red.on()

That’s all the code you need to start lighting the LEDs. It should light each LED in turn. If they don’t all light, check your wiring and check the LEDs are the right way round – they only work one way.

Have a play around, turning the LEDs off and on, and see if you can make them blink:

Let’s look at these instructions line-by-line to understand what they do:

from gpiozero import LED

Python uses libraries of useful code that lots of people want to use. Here we are importing the ‘LED’ statement from the ‘GPIO Zero’ library, which makes physical computing in Python really easy to code.

green = LED(17)
red = LED(18)
amber = LED(2)

The next 3 lines then tell the RaspberryPi that we have connected some LEDs to pins 17, 18 and 2 and that we’re going to call them red, amber and green – you could pick any names you want.

The last 3 lines turn the lights on:

green.on()
amber.on()
red.on()

So far we’ve been typing commands straight into the Python ‘shell’, or command line. It’s useful to be able to save sets of instructions in a text file so they can be run over and over again, without having to retype the code each time. So, next open a new file and save it as traffic-lights.py:

Then type in the following, save it again, and run it by pressing F5. Your LEDs should now light in a sequence like a set of real traffic lights: green, amber, red, red & amber together, and then green again.

from gpiozero import LED
from time import sleep

red = LED(18)
amber = LED(2)
green = LED(17)

green.on()
amber.off()
red.off()

while True:
    sleep(10)
    green.off()
    amber.on()
    sleep(5)
    amber.off()
    red.on()
    sleep(5)
    amber.on()
    sleep(5)
    green.on()
    amber.off()
    red.off()

Notice we’ve got some new Python commands here. We have imported ‘sleep’ from the time module – sleep(10) pauses for 10 seconds, sleep(5) for 5 seconds.

We’ve also used ‘while True:’ – this is like the ‘forever’ block in Scratch. The code that follows while True: will keep on running until you close Python.

Notice as well that the code that follows is all indented by 4 spaces at the start of each line. These spaces at the starts of lines are important in Python, as we will see in the next part when we will add a push-button to make a pedestrian crossing…

Massive thanks to Ben Nuttall and the rest of the folk at the GPIO Zero project for building such a great Python library that, I think, makes physical computing with Python actually easier to learn that Scratch! My code is rather similar to theirs, but I wrote it even before I realised they had a traffic light project too – check it out!

I love Scratch. I think it’s actually under-rated as a way of teaching computing, even in secondary schools (KS3). I remember a long time ago someone on the BBC ‘Computer Programme’ defending BASIC with the words ‘it’s a bad workman who blames his tools’, and I think the same applies to Scratch. You can do a lot with Scratch, more than I think some people give it credit for. If you can do a bubble sort or build a simple or complex working Enigma machine, it’s quite a flexible programming language.

But I want to do some physical computing with my KS3 students. I excitedly read news about the new version of Scratch bundled with Raspbian Jesse with GPIO hooks built-in – but then I looked at the sample code and blocks…

Ouch. The broadcast messages to make the GPIO pins work – to light LEDs, poll switches etc – look really complex. So complex, in fact, I think they totally defeat the point of using Scratch in the first place.

I’ve already decided Python will be our text-based language of choice as we introduce computing to the curriculum, so I’m incredibly excited by a project called GPIO Zero created by Ben Nuttall of the Raspberry Pi foundation and others. This is a Python library designed to make physical computing on the Raspberry Pi under Python as simple as, well, it should be. Look at this code:

That is the entire code needed to turn an LED on and off in a loop. Pretty impressive.

I had a play and hooked 3 different LEDs up to a Raspberry Pi and got them all blinking in turn and then lighting up together in a matter of seconds. Very promising, and I am increasingly convinced that Python is the way to go for teaching computing in KS3.