Overview

This is an opportunity to look at another language (Python), another IDE (IDLE) and have another go at Scissors, Paper, Stone.

Hardware

This is going to use the GPIO pins (the two rows of 13 pins - 26 in total) on the Pi. We'll connect them to the 3 boxes we used in the PIC session via a breadboard.

Raspberry Pi

Start by connecting all the usual bits to the Pi - but DON'T plug the power supply in or switch it on yet!

The breadboard I've used is an SYB-120 700 point breadboard. These are cheap and readily available on eBay. For anyone who's never used one, the idea is that there are lots of connection points and inside they are joined together in groups. If you hold it vertically, on this board there are 60 rows, each with 10 connection points (and also one column of 50 down each side, but we won't be using those). Each row has 5 connection points on the left, all joined inside - and 5 on the right, all joined - with a gap in the middle.

We'll use jumper wires to connect the breadboard to the GPIO pins on the Pi, so we'll need plenty of male to female jumper wires (readily available on eBay). We'll also need a few male to male jumper wires for connections between points on the breadboard.

Lastly we'll need some 470 ohm resistors.

See links on the first Raspberry Pi session page for links to relevant sources.

This image shows the pins on the Pi. A word of warning here - the Pi mostly runs on 3.3V - but the 5V0 GPIO pin (pin 2 - see below) exposes the raw 5V USB supply voltage. That 5V can be enough to kill the Pi permanently as there is no general voltage protection on the GPIO pins, so be VERY careful not to connect ANYTHING to that 5V pin. You might even want to cut off a female connector from a jumper wire and put it on the pin beforehand to stop anyone putting anything else on it.

Raspberry Pi GPIO pins

The wiring diagram (see link below) shows how to connect everything up and pin numbering on the Pi.

Start with the connections from 3 boxes to the breadboard down the left hand side (don't worry about the 3 VSS white wires for the moment).

Then plug in the 7 resistors (470 ohm) - the black rectangular blobs on the diagram. These are pull-up resistors on the switch inputs - the PIC had pull-up resistors built into the chip, so we didn't need these. The Pi doesn't, so we need extra external components. The idea is that the input pin is weakly connected to VSS (0V) via the resistor when the button is not pressed - but connected straight to VDD (3.3V in this case) when it is pressed. See the Circuit Components handout.

Breadboard Closeup

Now connect the Pi pins to the breadboard (don't worry about connections from pins 1 and 6 yet) with male to female jumper wires. It's a good idea to keep things colour coded - use the same colour wires here as for the corresponding wires from the boxes. Do make sure the resistor wires don't touch each other or anything else . . .

Now a couple of male to male jumper wires for the links shown to tie all the right hand ends of the resistors together.

Now plug the 3 white VSS wires from the boxes in.

And finally jumpers from the Pi pins 1 and 6 to the VDD and VSS connection points.

For the curious, the S and D in VSS and VDD stand for Source and Drain - with VSS being 0V and VDD being 3.3V Electrons are negatively charged and flow from negative to positive - i.e. 0V to 3.3V - so VSS is a source of elctrons and VDD is where they drain away.

Breadboard

Software

Assuming you have all the other bits connected to the Pi as in the earlier session, you're good to plug in the power supply, switch on, log in and start the GUI.

Initially some of the LEDs on the boxes may light up. That's normal. At startup there isn't any defined configuration for the GPIO pins so don't try to make any sense of what you see at this stage.

Now start up the Python environment - IDLE3.

IDLE3 / Python on the Raspberry Pi

The File Open to open up the Python file (download below).

And Run, Run Module to run it.

Hopefully the game will now play in exactly the way it did on the PIC.

To stop the programme, close the Python Shell window - and click OKto kill the programme. But don't close the window with the Python source code.

Discussion Topics

OK - time now to explore the code.

First, note that it doesn't use curly braces ('{' and '}') to define blocks of code - it just uses the level of indent from the left-hand margin.

Next, look at the "initialize" routine - we have to start by telling the Pi which of the GPIO pins will be inputs and which will be outputs. Note that we've got a block of code towards the end of the file that defines all sorts of variables to have particular values. This is common in programming - these are in some sense arbitrary values, so by doing this we achieve two things. It makes it easier to use the values in the main body of the code as we are using descriptive names and don't have to remember or keep checking what values we need, so we'll probably make fewer mistakes. And by having all the values set in one place we can set them up once and then forget about them - and if we need to make any changes, we only have one place to look and one place to make the changes.

Now look at the "main" routine. This is the key entry point for our programme and is called from the "main()" statement right at the end of the programme - the ONLY statement that isn't in a separate routine. Every programme needs to know how to start and having a "main" routine is common - in "C" it's actually compulsory and the only way any programme can ever be started.

Think about "routines" as reusable building blocks of code that can be "called" from anywhere. They are an essential way to add structure to code. And mean that you don't have to keep rewriting similar chunks of code every time you need them - write the code once, put it into a routine and call the routine every time you need that code.

Note also that the "main" routine has a "while" loop. The value 1 (like anything else that isn't 0) equates to True, so the condition is always satisfied and the loop will run forever - just like the forever loop in Scratch.

We also have a timing routine to get things to run at a sensible speed. And can change the defined value for the delay time, so can spped up or slow down the game. Think about units of time milli means a thousandth - millisecond, millimetre, milli-anything else. What about other prefixes - micro (millionth), nano (billionth), pico (trillionth), kilo (a thousand), Mega (a million), Giga (a billion), Tera (a trillion) - hence units like Megabyte, kilometre, Gigahertz, microgramme.

Handouts

Coding is Fun - Resources - 9 - Raspberry Pi

Coding is Fun - Resources - 9 - Raspberry Pi - Circuit Components

Coding is Fun - Resources - 9 - Raspberry Pi - Wiring

Software

Coding is Fun - Resources - 9 - Raspberry Pi - Software

Links

Python
   Official Web Site
      Python - www.python.org