He added: “The videos for Pi-Cars clearly show how much fun the whole family have with them, and I liked the way that Scratch has been integrated. It’s a fantastically accessible way for everyone to get started with programming, including younger family members, and when you connect Scratch to real cars running around the house, it really brings the abstract world of programming to life!”

Other projects that were highlighted in the last chapter include a talking reporting system for a boat, automated Halloween lights, a jukebox and a weather station.

You can find out more about Raspberry Pi For Dummies and how to buy at Sean’s website – click here.

You can buy a Pi-Car or Took Kit at our Embark-ideas website – click here.

The Raspberry Pi for Dummies book written by Sean McManus and Mike Cook features Pi-Cars in the 10 projects to do with your Pi-Car.

For the video lesson view the video below

If you can’t view video the full text-based lesson follows…

You should start from the screen with the big Raspberry Pi on it. It is a good idea to start from fresh so pull the power lead out and put it back in again and wait for the prompt to appear. Type pi then raspberry for your password and startx to start the graphical screen.

Double click on the LX terminal:

Make sure you are in the right directory by typing:

cd /home/pi

You then need to open a text editor to copy in the information which will be the python program that will let Scratch talk with the GPIO pins to control your car. So type:

sudo nano picars.py

It is easiest if you use exactly the same wording I have used above here. This  should bring up a screen like this:

You now need to copy in the text of the python program. Feel free to have a look at it but don’t think you have to understand it at the moment (you will be able to understand most of it by the end of your python driving lessons).

To get the program you need open the browser in your Raspberry Pi and go to this page on it (unless you are already viewing it on your Raspberry Pi!). You can open your browser by clicking on the icon as shown below:

Visit this page on the browser by putting http://www.pi-cars.com into the address bar and navigating to this page. You now need to copy the code in the box below, but there is a particular way to do this to ensure it is going to work and the instructions for this way are included beneath the code:

#!/usr/bin/env python

""" Must be run as root - sudo python picars.py """
""" Script based on original version from Simon Walters http://cymplecy.wordpress.com/ """
""" Modified slightly when troubleshooting. Currenly only does GPIO outputs in order to simplify """

import time, RPi.GPIO as GPIO
import socket
import sys
import threading
import time
import sys
import struct
from array import *
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7,GPIO.OUT)
GPIO.setup(11,GPIO.OUT)
GPIO.setup(12,GPIO.OUT)
GPIO.setup(13,GPIO.OUT)
GPIO.setup(15,GPIO.OUT)
GPIO.output(7,0)
GPIO.output(11,0)
GPIO.output(12,0)
GPIO.output(13,0)
GPIO.output(15,0)

PORT = 42001
DEFAULT_HOST = '127.0.0.1'
#HOST = askstring('Scratch Connector', 'IP:')
BUFFER_SIZE = 240 #used to be 100
SOCKET_TIMEOUT = 1

SCRATCH_SENSOR_NAME_OUTPUT = (
'gpio-output0',
'gpio-output1',
'gpio-output2',
'gpio-output3',
'gpio-output4'
)

#Map gpio to real connector P1 Pins
GPIO_PINS = array('i',[7,11,12,13,15])
GPIO_PIN_OUTPUT = array('i')
GPIO_PIN_INPUT = array('i')
print "Output Pins are:"
for i in range(0,len(SCRATCH_SENSOR_NAME_OUTPUT)):
	print GPIO_PINS[i]
	GPIO_PIN_OUTPUT.append(GPIO_PINS[i])

def create_socket(host, port):
    while True:
        try:
            print 'Trying'
            scratch_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            scratch_sock.connect((host, port))
            break
        except socket.error:
            print "There was an error connecting to Scratch! It may not have been started yet"
            print "I am looking for Scratch at host: %s, port: %s" % (host, port)
            time.sleep(3)
            #sys.exit(1)

    return scratch_sock

def cleanup_threads(thread):
	print 'About to stop thread'
	thread.stop()
	GPIO.cleanup()
	print 'Finished cleanup'
#	for thread in threads:
#		thread.stop()
#		for thread in threads:
#			thread.join()

class ScratchListener(threading.Thread):
    def __init__(self, socket):
        threading.Thread.__init__(self)
        self.scratch_socket = socket
        self._stop = threading.Event()

    def stop(self):
        self._stop.set()

    def stopped(self):
        return self._stop.isSet()

    def physical_pin_update(self, pin_index, value):
        physical_pin = GPIO_PIN_OUTPUT[pin_index]
        print 'setting GPIO %d (physical pin %d) to %d' % (pin_index,physical_pin,value)
        GPIO.output(physical_pin, value)

    def run(self):
	    while not self.stopped():
		    try:
			    data = self.scratch_socket.recv(BUFFER_SIZE)
			    dataraw = data[4:].lower()
			    print 'Length: %d, Data: %s' % (len(dataraw), dataraw)
			    print 'received something: %s' % dataraw
#			    time.sleep(0.2)
		    except socket.timeout:
			    print 'Socket timeout'
			    continue
		    except:
			    break
		    if 'sensor-update' in dataraw:
			    print 'Sensor update detected'
			    #check for individual port commands
			    for i in range(len(SCRATCH_SENSOR_NAME_OUTPUT)):
				     if 'gpio-output'+str(i) in dataraw:
					     print 'Found '+ 'gpio-output'+str(i)
					     outputall_pos = dataraw.find('gpio-output'+str(i))
					     sensor_value = dataraw[(outputall_pos+14):].split()
					     #print sensor_value[0]
					     self.physical_pin_update(i,int(sensor_value[0]))

if __name__ == '__main__':
    if len(sys.argv) > 1:
        host = sys.argv[1]
    else:
        host = DEFAULT_HOST

    # open the socket
    print 'Connecting...' ,
    the_socket = create_socket(host, PORT)
    print 'Connected!'

    the_socket.settimeout(SOCKET_TIMEOUT)
    listener = ScratchListener(the_socket)
    listener.start()
    print 'Starting cleaner'
    try:
	    while True:
		    time.sleep(0.5)
    except KeyboardInterrupt:
	    cleanup_threads(listener)
	    sys.exit()

To copy the code above click on the open code in new window icon – highlighted with a red circle in the diagram below:

This will open up a separate window with just the code in it:

In this window you can then press CTRL followed by the A button at the same time which will select all of the code in the window. You will then need to press the CTRL button followed by the C button to copy it to the clip board.

You now need to choose the terminal window you opened earlier and copy the python code into it. To do that you can right click in the terminal window and choose paste:

To save the file you can just press the CTRL key followed by the X key at the same time. This will ask you if you want to save the file and make sure you choose Y.

Finally you need to type:

sudo python picars.py

This should give you an output like the below:

This shows you that it is waiting for Scratch to tell it something which is what we want – Scratch is not started yet so it should be waiting. You will need to keep that terminal window so don’t shut it by clicking on the X but you can minimise it.

So with that palava over (it should be much easier when we get the apt-get repository up and running) you are now ready to fire up Scratch and talk to the Pi-Car through it.

Lots of different RC cars will work with the Tool Kit – basically anything that uses the TX2B chip. Listed below are the ones that can be bought together with the Tool Kit together with other models that we have had working in the past.

Cars that were used when creating the Tool Kit and can be bought together with the Tool Kit:

• New Bright Ferrari 1:24 Model

New Bright 1:24 Ferrari available in the Pi-Car Tool Kit

Can be bought separately from here.

• New Bright RC Toy Pick Up Model

New Bright Toy Pick Up truck that can be bought with the Pi-Cars Tool Kit

Can be bought separately from here.

Other New Bright Cars we know work with the Pi-Cars Tool Kit:

• New Bright RAM Basics 1:24 Scale

New Bright RAM Basics 1_24 Scale

Also works with Pi-Cars Tool Kit New Bright RAM Basics Black 1_24 Scale

• New Bright Ram HEMI, Mud Slingers, 1:6 Scale

Works with Pi-Cars Tool Kit – New Bright Ram HEMI, Mud Slingers, 1_6 Scale

• New Bright Sport Audi 1:16 Scale

New Bright RC Sport Audi for connecting to Pi-Car

We believe any of the New Bright Models will work with the same Tool Kit and instructions that we have provided in the Pi-Cars factory as we understand they use the same chip – if you have one already then why not convert it with the Tool Kit and let us know.

Hobby Fun Cars we converted:

We also converted a number of Hobby Fun cars from China. We don’t think they are available for sale in the UK but had fun with them and were impressed by them to. We gave these away in our earlier competition.

• 4 Channel Construction Car

Hobby Fun Radio Control Construction Vehicle that has been converted to a Pi-Car.

• 1:18 Mercedes-Benz SL65 AMG
  

1_18 Mercedes-Benz SL65 AMG that we have converted to a Pi-Car.

Pi-Cars converted by other people

• Porsche 911 GT3 RS Radio Controlled Car
  

Porsche 911 from Argos converted by Nilesh Gajjar

Well done to Nilesh Gajjar for converting this one. It can be bought from Argos – click here. Here is how he wired up the controller with one of our Pi-Car Tool Kits:

Converted Porsch radio controlled car to Pi-Car

Inside of the Porsche controller connected up as a Pi-Car.

• Buy a USB wireless adapter such as this one
• Plug it into the USB slot on your Raspberry Pi
• Configure it to join a wireless network

To configure the Raspberry Pi to connect to a wireless network perform the following steps:

Login to your Raspberry Pi either with a keyboard and mouse connected by pressing ‘startx’ at the prompt, or connect remotely using VNC viewer as shown in this post.

The first thing to do is double click on the wireless config item on the start screen:

Double click on the wireless configuration icon in order to add password details for your wireless network.

 This will bring up the following prompt:

Clicking on wireless config on the Raspberry Pi desktop brings up this page.

You then need to click on the Scan button:

On the desktop click on Scan to show the available networks.

Double click on the network you want to connect to which should bring up the following screen:

Once you have double clicked on the wireless network you want to join this screen should show.

You can then enter your password into the PSK field and click Add. Note that you may need to change the encryption method to the one that your wireless network uses:

Your password can be entered in the PSK field.

From a terminal you should now be able to ping google:

Checking you can ping google with the wireless network setup.

You can also inspect the network connection by typing the following into a terminal:

sudo /sbin/ifconfig

This should give you a screen similar to the following:

Output screen showing the setup on your interfaces.

If you are here you should be able use an editor to write Python code to control  your Pi-Car and understand what we mean when we talk about constants, variables and print statements. If not by all means have a go at this lesson but if you get stuck try Driving Lesson#1, Driving Lesson#2, Driving Lesson#3 or Driving Lesson#4.

• What’s in this driving lesson?

In this lesson we will look at another type of logical instruction and how we can use it to affect the ‘flow’ of the program. The instruction we will look at is called a ‘while loop’. This will help greatly in helping us to make the Raspberry Pi repeat instructions rather than have to continually write them out.

As with the other lessons you may get to the end and not realise how powerful the instruction is but try and think of examples in bigger programs how it could be used.

• A little theory

Unless you already know what a while instruction is you probably do need to read the theory section as it takes a little bit of time to get used to it. However, you can of course jump into the driving part and then come back to review this if necessary.

while instructions (also known as ‘while loops’)
In the real world we sometimes need to repeat the same task over and over again a number times until it’s finished.

An example of this is a race where we have to drive around a track a fixed number of times to complete it. Sometimes we will count down the number of laps completed i.e count down from 10 taking 1 off each time (10,9,8 etc) until we get to 0 and are finished.

Other times we will count up (1, 2, 3 etc) once each lap is finished, until we reach the number of laps to complete the race. We may also say we are on the third lap once we start it but do not count it until that lap is completed.

We may also want to do things whilst a certain situation is true e.g switch on windscreen wipers which will then continue to wipe whilst they are turned on, (or if you have sensors until  they go of automatically as there’s no longer any rain). Another example is when we start a car, the engine will continually run whilst the key is turned in the ignition.

In a program we also want to be able to do this sort of thing. The above examples are perfect examples of while loops in a program. What a while loop lets us do is tell the Raspberry Pi to repeat a certain block of instructions either a certain number of times or whilst a certain thing is true – such as the value of a variable currently being a certain value.

• Lets get driving…
  

The first thing we have to do before we start racing is to start the engine. Once you have done that you can then race the car around the track. So how can we do this in a python program?

A while loop lets us tell the Raspberry Pi to keep on repeating an instruction or set of instructions. It will go through the block of instructions in order and then start at the beginning of the block again.

We can also tell the Raspberry Pi to only repeat the instructions if a certain thing is true, a bit like we did in the if statement in the last lesson. The way we write this in the Python file is as follows:

engineStarted = "on"

while engineStarted == "on":
  print "Pi-Car engine running"
  time.sleep(2)

You can see above that we write the word ‘while’ followed by something that we want to check. If it is correct – this is also called being ‘true’ – the indented instructions below it will be repeated again and again. As with the if statement you can make the instructions indented by just pressing the tab key at the start of the line.

In the example above the variable engineStarted is being checked as to whether it is equal to on. Remember that the == symbol means ‘equal to’ and note how it is two equal signs rather than one. If engineStarted is equal to ‘on’ then the Raspberry Pi will execute the instructions below it – meaning it will print out some text and then wait for 2 seconds. Also notice that you need to put a colon ‘:’ symbol after the check – you have to do this, it is what the Python language accepts to make the Raspberry Pi process the instruction correctly.

If you run this program you will see it continually printing out “Pi-Car engine running” with a 3 second wait. The Raspberry Pi will continue to do this again and again and again. This is because in the code we wrote engineStarted will always be equal to “on” as this is what we set it to at the top of the file and we don’t change it anywhere else.

This does give us a bit of a problem in that we want to do something else rather than just watch the Raspberry Pi print out a statement forever. To stop the program and the while loop running you can press CTR + D or CTR + C.

So now we understand the while loop lets make it do something useful. We want it to make the Pi-Car do a certain number of laps before stopping. To do this we can combine the while statement with the if statement that we learnt in the last lesson.

engineStarted = "on"
lapsCompleted = 0

while engineStarted == "on":
       GPIO.output(FORWARDS, ON)
       GPIO.output(RIGHT, ON)
       print("Engine running, Pi-Car should be driving in a circle")
       if (lapsCompleted < 10) :
              print("Staring a new lap, laps completed",lapsCompleted)
              time.sleep(3)
              lapsCompleted = lapsCompleted + 1
       else :
              print("Laps done = ",lapsCompleted," race finished lets turn off the Pi-Car")
              GPIO.output(FORWARDS,OFF)
              GPIO.output(RIGHT,OFF)
              GPIO.cleanup()
              engineStarted = "off"

The main thing to discuss here is how we have added the if statement in the indented code after the while statement. This means that every time the Raspberry Pi goes through all of the code in the while loop it will evaluate the line

if (lapsCompleted < 10) :

We have already defined the lapsCompleted variable earlier in the program to a value of 0. We want to check on each loop that the value of lapsCompleted is not over a certain amount – we have chosen 10 here. In the last lesson we used the > symbol which means ‘more than’. Here we are using the opposite which means ‘less than’.

To make this while loop work we also have to increase  the lapsCompleted each time by one, if we didn’t it would mean that the loop would go on forever as before. This is referred to in programming as an infinite loop and can happen surprisingly often and easily.

The way we increase the number of laps completed is as follows:

lapsCompleted = lapsCompleted + 1

Notice that even though the code we have looked at so far does check for the number of laps completed, it does not actually do anything to stop the while loop. This is done in the else section:

else :
              print("Laps done = ",lapsCompleted," race finished lets turn off the Pi-Car")
              GPIO.output(FORWARDS,OFF)
              GPIO.output(RIGHT,OFF)
              GPIO.cleanup()
              engineStarted = "off"

You can see us here turning off the GPIO pins and also setting the enigneStarted variable to another value. This means that when the while loop next runs and checks whether engineStarted is equal to “on”, it will calculate that it is not – and therefore would not go through the indented code beneath it but would move onto the next set of instructions.

The full set of code should now look like the following:

import time, RPi.GPIO as GPIO

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

#variables
petrolLeft=50
engineStarted = "on"
lapsCompleted = 0

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

while engineStarted == "on":
       GPIO.output(FORWARDS, ON)
       GPIO.output(RIGHT, ON)
       print("Engine running, Pi-Car should be driving in a circle")
       if (lapsCompleted < 10) :
              print("Staring a new lap, laps completed",lapsCompleted)
              time.sleep(3)
              lapsCompleted = lapsCompleted + 1
       else :
              print("Laps done = ",lapsCompleted," race finished lets turn off the Pi-Car")
              GPIO.output(FORWARDS,OFF)
              GPIO.output(RIGHT,OFF)
              GPIO.cleanup()
              engineStarted = "off"

If you run the program you will now see that 10 laps are completed before the program exits the while loop as the engineStarted variable is changed. Pi-Car then stops. When you run the code change some of the variables – like the number of laps and see what happens.

• Driving Lesson review

while statements:

How to use:

1. Use the word ‘while’ followed by a statement. This statement should be evaluated and if correct, (or true) the indented lines of code below it should be executed one by one. When it reaches the last one, it will check whether the while statement is still true and then execute each line one by one:

engineStarted = "on"
lapsCompleted = 0

while engineStarted == "on":
       GPIO.output(FORWARDS, ON)
       GPIO.output(RIGHT, ON)
       print("Engine running, Pi-Car should be driving in a circle")
       if (lapsCompleted < 10) :
              print("Staring a new lap, laps completed",lapsCompleted)
              time.sleep(3)
              lapsCompleted = lapsCompleted + 1
       else :
              print("Laps done = ",lapsCompleted," race finished lets turn off the Pi-Car")
              GPIO.output(FORWARDS,OFF)
              GPIO.output(RIGHT,OFF)
              GPIO.cleanup()
              engineStarted = "off"

2. The thing you are checking will normally be a variable on the left compared to a value, or the value of a variable, on the right hand side.

Why do they help?

1. While loops are really helpful for not having to write extra lines in your program yourself. The while loop will do this for you and will also check on each loop whether it should continue based on.

• Gotcha’s

In any engineering things rarely work first time so don’t worry. Hopefully the list below will help. If not email us at info@pi-cars.com and leave a comment providing your code and what you tried to do, the solution will be obvious as soon as you see it!

1. Remember after an while statement you need to have a colon and then indent the lines you want the Raspberry Pi to execute if the statement is true. You can indent by pressing the tab at the start of the line.
2. Remember that you need to run Python (or idle 3) as sudo to interact with the GPIO pins.
3. When you are checking a variable is the same as a string make sure you put  the speech marks around the things you are comparing. For example engineStarted == “on” is correct engineStarted == on will not be correct.

Next -> Driving Lesson #6 More logic – Emergency Stops and procedures

Previous -> Driving Lesson  #4 – Python If statements

PDF Version

PDF version of this article - Python while loops – Driving lesson #5 _ Pi-Cars

If you are here you should be able use an editor to write Python code to control  your Pi-Car and understand what we mean when we talk about constants, variables and print statements. If not by all means have a go at this lesson but if you get stuck try Driving Lesson#1, Driving Lesson#2 or Driving Lesson#3.

• What’s in this driving lesson?

In this lesson we will be introducing logic – rather than the Raspberry Pi just carrying out each instruction in the program one after another as it has done so far, we can make it a bit cleverer.  We do this by adding logical instructions to the program that tell the Raspberry Pi to only do certain things based on what is happening at a certain time.

To do this we will introduce the concept of an if instruction and the else instruction.

This is where you may start to see how powerful programming can be. If you get to the end and still don’t really see why it is important, again don’t worry, just trust us that they are important! As you do more you will begin to see the power these instructions will give you to do increasingly complicated things.

• A little theory

Unless you already know what an if instruction is you probably do need to read the theory section this time – but I am sure this won’t stop you jumping down to the driving part! As always if you get stuck come back and have a read when you do, or just to refresh your mind, it may take a while to get these concepts.

if instructions (also known as ‘if statements’)

In the real world we have to make all sorts of decisions every day. Which decision we make depends on certain factors. For example a decision that (some) people have to make is -

‘Should I buy a Ferrari or a Mercedes today?’

There are probably loads of things they have to consider when making this decision but let’s just imagine it depends on whether they have enough money:

‘If I have enough money then buy a Ferrari, if I don’t then buy a Mercedes’

This is of course a much simplified version of how we may make a decision but demonstrates us (as humans) performing logical steps to make decisions and instruct ourselves to do certain things.

It follows that to make our program more intelligent we need give it the ability to make logical decisions – we don’t just want the Raspberry Pi to carry out all the instructions one after another but rather make decisions as to which instructions to perform.

As we have learnt, a program is a set of instructions that we have written down in advance. Therefore all of the decisions that we want the Raspberry Pi to make, and what happens on the outcome of each one, has to be written into the program.

To make one of these decisions in a program we make use of the ‘if’ instruction, more commonly know as the ‘if’ statement. There are certain rules around how we write this into  a Python program and we’ll now look at this based on the program we have been creating.

• Lets get driving…

At the end of the last driving lesson we finished with the following code.

If you don’t know how to get the code onto your Raspberry Pi, you can either copy it typing it into your text file. Or you can copy it in - instructions here.

import time, RPi.GPIO as GPIO

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

#variables
petrolLeft=100
driversName="Michael"

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

#Move car forwards
GPIO.output(FORWARDS,ON) #turn pin on
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF) #turn pin off
#make petrolLeft it's own current value less a fixed amount
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Move car backwards
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Change the driver
driversName = "Minnie"
print ("New driver is ",driversName)

#Move the car left - remember we have to move forwards as well
GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Move the car right - rememeber we have to move forwards as well
GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

print("Finished moving, petrol left = ", petrolLeft)
#remember to cleanup the GPIO pins
GPIO.cleanup()

Limitations of the current program 

Change the petrolLeft variable at the top of the file to be 50 instead of 100:

petrolLeft=50

Run the program and look at the print statements. It shows that the petrolLeft actually gets to a negative number but it keeps on instructing the car to keep going – not a very clever program.

Giving the program some intelligence with the if statement

To make the program better we can use an if statement to check before each time we move the Pi-Car whether there is any petrol left – if there is petrol left, move the car, if not don’t move it.

#Move car forwards if there is petrol left
if (petrolLeft > 0) :
        GPIO.output(FORWARDS,ON) #turn pin on
        print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
        time.sleep(3)
        GPIO.output(FORWARDS,OFF) #turn pin off
        #make petrolLeft it's own current value less a fixed amount
        petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
        print ("Current driver is ",driversName)

#Move car backwards
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

You can see above we have used a symbol we have not seen before – the ‘>’ symbol. This symbol means ‘more than’.

So when the Raspberry Pi looks at the ‘if petrolLeft > 0′ instruction it will look at the current value of the variable petrolLeft and see if it is more than 0. We could have put any value where we put the 0 but we currently just want to check if it is more than 0.

You will see that after the ‘if petrolLeft > 0′ we also put a ‘:’ symbol. This tells the Raspberry Pi that if it has worked out that petrolLeft is currently more than 0 it should continue and  carry out the instructions that follow which have been indented. By indented we mean the lines that have some space to the left of them, this space is created by pressing the tab key when you write the instruction.

So in the code above if petrolLeft is currently more than 0 all of the instruction lines up until the #Move car backwards line will be completed.

Else can join an if

We may also want to do something if the Raspberry Pi has worked out that petrolLeft is 0, or less than 0. The code below shows how to do this:

#Move car forwards if there is petrol left
if (petrolLeft > 0) :
        GPIO.output(FORWARDS,ON) #turn pin on
        print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
        time.sleep(3)
        GPIO.output(FORWARDS,OFF) #turn pin off
        #make petrolLeft it's own current value less a fixed amount
        petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
        print ("Current driver is ",driversName)
else :
        print ("Sorry not enough petrol, petrol left=",petrolLeft)

#Move car backwards
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

You can see that we used the word ‘else’ followed by a comma ‘:’ again. As with the if you need to let the Raspberry Pi know which instructions it should carry out, you do this by indenting the instructions you want it to execute.

You can only use an else after an if, you cannot use it on it’s own. Also remember that after an if or else only the instructions that are indented will be carried out. You can go ahead and put if and else statements in front of the rest of the code.

Petrol left should never be negative!

If you set the petrolLeft at the start to 30 and run the program you will notice that the petrolLeft can still get to a negative value. This is because we are currently only checking that the petrolLeft is more than 0. If it is only a little bit more then when the petrolLeft is reduced it can be reduced to less than 0.

To fix this we can check whether petrolLeft is more than the fixed amount that each movement takes:

#Move car forwards if there is petrol left
if (petrolLeft > PETROL_USED_PER_MOVE) :
        GPIO.output(FORWARDS,ON) #turn pin on
        print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
        time.sleep(3)
        GPIO.output(FORWARDS,OFF) #turn pin off
        #make petrolLeft it's own current value less a fixed amount
        petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
        print ("Current driver is ",driversName)
else :
        print ("Sorry not enough petrol, petrol left=",petrolLeft)

#Move car backwards
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

We used the constant PETROL_USED_PER_MOVE to do this and check that petrolLeft is more than it. If you run the program again you should now see that the petrolLeft does not go beneath 0. The code should now look as follows:

import time, RPi.GPIO as GPIO

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

#variables
petrolLeft=50
driversName="Michael"

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

#Move car forwards if there is petrol left
if (petrolLeft > PETROL_USED_PER_MOVE) :
	GPIO.output(FORWARDS,ON) #turn pin on
	print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
	time.sleep(3)
	GPIO.output(FORWARDS,OFF) #turn pin off
	#make petrolLeft it's own current value less a fixed amount
	petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
	print ("Current driver is ",driversName)
else :
	print ("Sorry not enough petrol left, petrol left =",petrolLeft)

#Move car backwards if there is petrol left
if (petrolLeft > PETROL_USED_PER_MOVE):
	GPIO.output(BACKWARDS,ON)
	print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
	time.sleep(3)
	GPIO.output(BACKWARDS,OFF)
	petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
	print ("Current driver is ",driversName)
else :
	print ("Sorry not enough petrol, petrol left =",petrolLeft)

#Change the driver
driversName = "Minnie"
print ("New driver is ",driversName)

#Move the car left if there is petrol left - remember we have to move forwards as well
if (petrolLeft > PETROL_USED_PER_MOVE) :
	GPIO.output(LEFT,ON)
	GPIO.output(FORWARDS,ON)
	print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
	time.sleep(3)
	GPIO.output(LEFT,OFF)
	GPIO.output(FORWARDS,OFF)
	petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
	print ("Current driver is ",driversName)
else :
	print ("Sorry not enough petrol, petrol left =", petrolLeft)

#Move the car right if there is petrol left - rememeber we have to move forwards as well
if (petrolLeft > PETROL_USED_PER_MOVE) :
	GPIO.output(RIGHT,ON)
	GPIO.output(FORWARDS,ON)
	print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
	time.sleep(3)
	GPIO.output(RIGHT,OFF)
	GPIO.output(FORWARDS,OFF)
	petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
	print ("Current driver is ",driversName)
else :
	print ("Sorry not enough petrol, petrol left =", petrolLeft)

print("Finished moving, petrol left = ", petrolLeft)
#remember to cleanup the GPIO pins
GPIO.cleanup()

So you have now added your first bit of logic to your program which has made it more intelligent. We’ll go on to look at other bits of logic we can add in the next driving lesson, but before we do we’ll finish this lesson by looking at some of the other ways we can make decisions.

Other operators

In the code we added so far we have used the ‘>’ symbol to indicate ‘more than’ when checking if there was enough petrol left and the ‘-’ symbol to reduce the petrol left after each time the Pi-Car moved. There are a number of other symbols like this we can use in a Python program -they are called operators. They can be used when setting variables. Some you will probably recognise already:

• ‘+’ used for adding up e.g. petrolLeft = petrolLeft + 30
• ‘-’ used for subtracting e.g. petrolLeft = petrolLeft – PETROL_USED_PER_MOVE
• ‘*’ used for multiplying e.g. timeTaken = 30 * 20
• ‘/’ used for division e.g. movesLeft = petrolLeft / PETROL_USED_PER_MOVE

We have seen one of these already and will come on to use the remaining ones in the following lessons so don’t worry if you don’t understand how they would be used at the moment.

Other operators which you may not recognise if you have not done anything like this before are shown below. These are very useful for comparing the current value of a variable to another value like we did with the petrolLeft. They will often be used in if statements (and others that we will come onto look at).

• ‘>’ used to check if the value on the left is ‘more than’ the value on the right e.g. if (petrolLeft > PETROL_USED_PER_MOVE)
• ‘<’ used to check whether the value on the left is ‘less than’ the value on the right
• ‘>=’ used to check if the value on the left is ‘more than or equal to’ the value on the right
• ‘<=’ used to check if the value on the left is ‘less than or equal to’ the value on the right
• ‘==’ used when you want to check that two variables are the same
• ‘!=’ used when you want to check that two variables are not the same. You can also use <> for this

Again we will come on to actually use these in future driving lessons so at the moment just be aware that they exist and you may be able to think of some ways you could use them in your program. There are in fact even more operators than this but for the time being these will be enough and help us make our programs much more powerful.

• Driving Lesson review

If and else statements:

How to use:

1. Use the word ‘if’ followed by a statement you are checking.  If the thing you are checking is true then the lines after it which have been indented will be executed:

if (petrolLeft > 25) :
      print ("This will be printed if the value of petrolLeft is more than 25")

print ("This line will always be printed whether petrolLeft is more than 25 or not)

2. The thing you are checking will normally be a variable on the left compared to a value, or the value of a variable, on the right hand side.

3. You can also use the ‘else’ instruction to carry out some instructions if the thing you were checking turned out not to be true:

if (petrolLeft > 25) :
      print ("This will be printed if the value of petrolLeft is more than 25")

else :
      print ("This will only be printed out if petrolLeft is less than or equal to 25")

print ("This line will always be printed whether petrolLeft is more than 25 or not)

Why do they help?

1. Your program can now make decisions! It means that rather than just carrying out each instruction one after another, you can tell the Raspberry Pi to only do certain instructions in certain situations.

• Gotcha’s

In any engineering things rarely work first time so don’t worry. Hopefully the list below will help. If not email us at info@pi-cars.com and leave a comment providing your code and what you tried to do, the solution will be obvious as soon as you see it!

1. Remember after an if statement you need to have a colon and then indent the lines you want the Raspberry Pi to execute if the statement is true. You can indent by pressing the tab at the start of the line.

Next -> Driving Lesson #5 More logic – While loops and Emergency Stops

Previous -> Driving Lesson  #3 Variables and constants

 PDF Version 

PDF version of this article - Python if else statements – Driving Lesson #4 _ Pi-Cars

If you are here you should be able use an editor to write Python code to control  your Pi-Car. If not by all means have a go at this lesson but if you get stuck try Driving Lesson#1 or Driving Lesson#2.

• What’s in this driving lesson?

In this lesson we will be considering things called variables and comments. As with the last lesson you may get to the end and still wonder why you need them and why they are important. However, stick with it, when you get to the next Driving lesson and the start of logic it will become clearer.

• A little theory
  

We will start with a bit of theory again, so most of you will probably skip this bit and go down to the actual doing part but do come back if you don’t understand it!

Variables

So what is a variable? In the last Driving Lesson we learnt about a constant. A variable is similar to a constant in that it is something that holds a value but as the name suggests this value can vary.

This means that as the Raspberry Pi works through the instructions in the program one by one a variable can hold a certain value at one stage in the program but a different value at another stage.

As with a constant, in programming you have the variable name on the left side followed by a ‘=’ symbol and then a value on the right side of it. For example:

petrolLeft = 100

This variable might be used to indicate how much petrol is left as your program runs. Here it is being set to 100 initially,  it can then be set to a different value later.

Also pay attention to the variable name, even though it is two words – petrol and left – there is no space between them. This is one of the rules of the Python language – you cannot have spaces in variables. With this variable you will see we put a capital on the second word in order to make it easier to read. This is a common trick to use.

Variable types

Before we get driving we do just need to consider the different types of variables. The one  we used above was obviously a number but we can also have a variable that have a word, or a number of words associated to it. This is referred to as a String – as in a string of letters. If we want to assign a string we need to put speech marks around it so the Raspberry Pi knows what we mean:

carDriver = “Michael”

• Lets get driving…
  

Enough of the theory (for those of you who read it) let’s try and drive our Pi-Car and use some variables. At the end of the last driving lesson we finished with the following code.

If you don’t know how to get the code onto your Raspberry Pi, you can either copy it typing it into your text file. Or you can copy it in – instructions here.

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS)
time.sleep(3)
GPIO.output(FORWARDS,OFF)
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)

In this code the car should move forwards, wait for a bit, move backwards, wait for a bit, move forwards and left, wait for a bit and then move forwards and right and wait for a bit. It will also print out what it is doing to the screen.

Adding a variable

So lets add a variable. We will add a variable that stores how much petrol is left and then reduce it as the car moves which we can then print out. Put it just beneath the constants you created.

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15

petrolLeft = 100

Now we have our variable let’s print out the value – as we did with the constants:

print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS, " Petrol left = ",petrolLeft)

If you can remember we need to add any words we want to print out in speech marks when we do a print and if we want to print out the value of a variable or constant add a ‘,’ and then the variable name.

Add the part above that prints out the Petrol Left value to each print statement in the code. You should now have the following:

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
petrolLeft=100

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF)
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)

If you now save this file and run it you should see it print out the same value for petrol left each time it moves which obviously isn’t right as when a car moves it uses up petrol (yes I know they are batteries in a Pi-Car!).

Changing the value of a variable

So what we want to do is change the value of the petrolLeft variable after each time it moves. To do this we could set it to a different value each time. For example we could say each movement reduces the petrolLeft by 20, so after the first one we could assign petrolLeft to 80.

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF)

petrolLeft = 80

So when petrol left is printed out the first time it will print out 100, the next time it will print out 80.

Doing this, we have to work out the value each time throughout the file. It would be easier for us to just say lets take 20 off the current value of petrolLeft and we can do this quite easily by typing:

petrolLeft = petrolLeft – 20

What we are doing here is saying the value of petrolLeft should be whatever the value it is at the moment – which at the start of the file is 100 – and then take 20 away from it. This will then mean that petrolLeft will then be assigned the value 80 (100 – 20).

Doing this means we do not have to work out the value ourselves – which will be very useful when things get more complicated.

What you may notice is that you are still typing in the number 20 a number of times always the same value – so why don’t we make it a constant? If we do this it means if we want to change it at some point we will only have to change it in one place.

Lets define the constant PETROL_USED_PER_MOVE with the other constants:

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

petrolLeft = 100

And then use it when we are calculating the petrolLeft value:

petrolLeft = petrolLeft – PETROL_USED_PER_MOVE

So this should mean you now have the following:

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20
petrolLeft=100

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

print("Finished moving, petrol left = ", petrolLeft)

Run your program and you should see it print out that the petrol is decreasing as your car moves. Also note that if you run your program again the petrolLeft variable will be set to 100 again because the Raspberry Pi executes each instruction in the program. It will not remember the value from the last time you ran it.

Adding a different type of variable

In the theory section we also introduced the idea that variables didn’t just have to store numbers they could also store a word these are referred to as Strings. So lets add a string variable where we will store the drivers name which we will called driversName:

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

petrolLeft = 100
driversName = "Michael"

We can now print out the drivers name whenever we want:

print ("Current drivers name is ",driversName)

If we want to change the drivers name halfway through we can do this by typing in the variable name and assigning it a new value:

print ("Current drivers name is ",driversName)
print ("Changing driver now")
driversName = "Minnie"
print ("New driver is",driversName)

This will now print out the new drivers name and your code should now look like the following:

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20
petrolLeft=100
driversName="Michael"

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)
driversName = "Minnie"
print ("New driver is ",driversName)

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

print("Finished moving, petrol left = ", petrolLeft)

When you run the code you should see the petrol reducing as the car moves and the name of the driver changing.

Comments make it easier

The final thing in this lesson is to learn about comments. When looking at computer code it is sometimes quite difficult to understand. You can make it easier by adding something called comments to your code.

These are lines that you can add which are only for people looking at it and are not meant for the Raspberry Pi to try and do anything with. However, to make sure the Raspberry Pi does not do anything with the line we type we have to tell it not to look any further. We do this by adding a ‘#’ (hash) symbol.

#make petrolLeft it's own current value less a fixed amount
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE

The # symbol means that the Raspberry Pi will not bother looking at the rest of the line and will skip onto the next one so you can type what you like.

import time, RPi.GPIO as GPIO

ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15
PETROL_USED_PER_MOVE=20

#variables
petrolLeft=100
driversName="Michael"

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

#Move car forwards
GPIO.output(FORWARDS,ON) #turn pin on
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(FORWARDS,OFF) #turn pin off
#make petrolLeft it's own current value less a fixed amount
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Move car backwards
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Change the driver
driversName = "Minnie"
print ("New driver is ",driversName)

#Move the car left - remember we have to move forwards as well
GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

#Move the car right - rememeber we have to move forwards as well
GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT," Petrol Left = ",petrolLeft)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)
petrolLeft = petrolLeft - PETROL_USED_PER_MOVE
print ("Current driver is ",driversName)

print("Finished moving, petrol left = ", petrolLeft)
#remember to cleanup the GPIO pins
GPIO.cleanup()

The above code shows some comments which makes it a bit easier to understand. As with the other things we are learning, these become more important as things get more complicated.

You may also have notice that you do not have to put the # symbol at the start of the line. You can put it half way through the line. This will not mean the Raspberry Pi will ignore the whole line it will only ignore anything after the hash.

• Driving Lesson review

Variables:

How to use:

1. Put the name on the left and the value on the right and choose a suitable name – the same as constants. Remember no spaces, and also the convention is to not use all upper case for variables:

petrolLeft = 100

2. Unlike constants at a different point in the program you can then assign a different value to the variable.

3. Also remember you can use the variable itself when you are changing it’s value.

petrolLeft = petrolLeft - 20

Why do they help?

1. You can use them to store things that change that you will want to use in your program – you will see the real use in the next few Driving Lessons.

Comments:

How to use:

1. Put a # symbol and then write any useful comment after it on the same line

#reduce the petrol left by its current value less 20
petrolLeft = petrolLeft - 20

Why do they help?

1. They make the code easier to understand

• Gotcha’s

In any engineering things rarely work first time so don’t worry. Hopefully the list below will help. If not email us at info@pi-cars.com and leave a comment providing your code and what you tried to do, the solution will be obvious as soon as you see it!

Next -> Driving Lesson #4 If statements

Previous -> Driving Lesson #2 Pi-Cars and Python

PDF Version

PDF version of this article - Python variables and commenting – Driving Lesson #3 _ Pi-Cars

• How to get the code onto your Raspberry Pi and run it
  

To select the code and use it:

• Visit this page on your Raspberry Pi with the browser
• Move your cursor over the code segments below and in the top right corner a <> should appear.
• Click on it and a new window should open with all the code in it.
• Select it all with the mouse or click CTR + A.
• Copy it by clicking CTR + C or right click and select copy.
• Minimize the browser to reveal the desktop.
• Open up a command prompt by double clicking on the LX terminal on the desktop.
• Open a text editor using a command like ‘nano PiCarTest.py’
• Paste the clipboard into the text file by right clicking and choosing paste.
• Save the file (in nano CTR + X, then type ‘y’ then press enter).

You can then run with the command:

sudo python PiCarTest.py

• Example Python code
  

Here is a file which has variables, constants, while loops, if else and procedures (you may know them as methods or functions). There are also some comments! :

#!/usr/bin/env python

""" Must be run as root - sudo python PicarsFunctions.py """

import time, datetime, RPi.GPIO as GPIO

FORWARD=12
BACK=11
LEFT=13
RIGHT=15
TURBO=7

GPIO.setmode(GPIO.BOARD)
#Remember to setup the GPIO pin as input or output
GPIO.setup(FORWARD, GPIO.OUT)
GPIO.setup(BACK, GPIO.OUT)
GPIO.setup(LEFT, GPIO.OUT)
GPIO.setup(RIGHT, GPIO.OUT)

def print_time(): #prints out the time now in a format we like
    #print "Time before statement is run"
    print datetime.datetime.now()

def forwards_on(): #turns the forwards pin on
    print "About to turn forwards pin on"
    print_time()
    #turn back off as well
    backwards_off()
    GPIO.output(FORWARD,1)

def forwards_off(): #turns the forwards pin off
    print "About to turn forwards pin off"
    print_time()
    GPIO.output(FORWARD,0)

def backwards_on(): #turns backwards pin on
    print "About to turn the backwards pin on"
    print_time()
    #turn forwards off as well
    forwards_off()
    GPIO.output(BACK,1)

def backwards_off(): #turns backwards pin off
    print "About to turn the backwards pin off"
    print_time()
    GPIO.output(BACK,0)

def left_on(): #turns the left pin on
    print "About to turn the left pin on"
    print_time()
    #turn right off as well
    right_off()
    GPIO.output(LEFT,1)

def left_off(): #turns the left pin off
    print "About to turn the left pin off"
    print_time()
    GPIO.output(LEFT,0)

def right_on(): #turns the right pin on
    print "About to turn the right pin on"
    print_time()
    #turn left off as well
    left_off()
    GPIO.output(RIGHT,1)

def right_off(): #turns the right pin off
    print "About tot turn the right pin off"
    print_time()
    GPIO.output(RIGHT,0)

def choose_dir(dirWanted=LEFT):
    if dirWanted == LEFT:
        right_off()
        left_on()
    else:
        left_off()
        right_on()

def straighten():
    print "About to straighten"
    print_time()
    left_off()
    right_off()

def slalom(startSideDir=RIGHT,startDir=FORWARD,turns=4, interval=0.1): #does a slalom by default starting right and doing it 4 times with an interval of 0.1
    i = 0
    #need to determine which way we should be going with the direction
    if startDir == FORWARD:
        print "Going to move forwards in the slalom"
        print_time()
        forwards_on()
    else:
        print "Going to move backwards in the slalom"
        print_time()
        backwards_on()
    #now do the turns
    while i < turns:
        print "about to slalom to = ", startSideDir
        choose_dir(startSideDir)
        print "Left direction", LEFT
        print "Right direction", RIGHT
        print_time()
        if i == 0:
            #the first turn should only be half the amount
            time.sleep(interval/2)
        else:
            time.sleep(interval)
        #toggle direction for next time
        if startSideDir == RIGHT:
            startSideDir = LEFT
        else:
            startSideDir = RIGHT
        i = i + 1
    #at the end straighten the wheels
    straighten()

def all_off(): #turns all of the pins off - always call at the end to save battery  
    GPIO.output(FORWARD,0)
    GPIO.output(BACK,0)
    GPIO.output(LEFT,0)
    GPIO.output(RIGHT,0)

def cleanup(): #cleans up the GPIO pins
    GPIO.cleanup()

def sleep(sleepTime=1):
    time.sleep(sleepTime)

def main():
    try:
        forwards_on()
#        sleep(0.6)
#        right_on()
        sleep(0.5)
        #all_off()
        slalom(LEFT,FORWARD,400,0.5)
        sleep(0.5)
        all_off()
        sleep(0.5)
        #time.sleep(0.4)
        #backwards_on()
        #time.sleep(1)
        slalom(LEFT,BACK,4,0.5)
        sleep(0.5)
        #forwards_on()
        #time.sleep(1)
        #right_on()
        #time.sleep(0.5)
        #right_off()
        #time.sleep(0.5)
        #left_on()
        #time.sleep(0.5)
        #left_off()
        #time.sleep(0.5)
        #forwards_off()
        #time.sleep(0.5)
        #backwards_on()
        #time.sleep(1)
        all_off()
        cleanup()
    except KeyboardInterrupt:
        cleanup()

if __name__ == "__main__":
    main()

If you are here you should have set up your Raspberry Pi,  understand how to connect your Pi-Car to your Raspberry Pi and know how to use IDLE or another editor to write Python code and run it. If not don’t worry:

For more information on setting up your Raspberry Pi click here.

For more information on how to connect your Pi-Car to your Raspberry Pi click here.

For more information on how to start-up and use the IDLE3 editor to write and run Python code click here.

We would also recommend that you have completed the Pi-Cars Driving Lesson #1 where you do a quick test with Pi-Car to check everything is working and you can see how to actually write a Python program and then run it.

• What’s in this driving lesson?

By now you will have written a few lines of code and run it to make the wheels move on the Pi-Car but you may not have understood much. This lesson introduces a bit more about what a program is and the concept of constants.

• A little theory
  

Much like real driving, we do need some theory in order to understand how to drive a Pi-Car and get the most out of it. I am sure lots of you will just skip this section and get onto the actual driving part, however, do come back and read on if you are at all unsure as you do need to understand the concepts here in order to be able to program.

Some of the concepts in programming and you might not understand how important they are but keep with it, as you start using them you will see why they are important.

What is a program?

A program is a set of instructions to the Raspberry Pi to get it to do something. The program must be written in a language – a language which has certain rules as to how it is written. The language we are going to use is called Python.

All we need to know at the moment is that the Raspberry Pi understands Python. This is just the same as you or I can understand English. So if somebody gives us some instructions in English we can carry them out. Likewise with the Raspberry Pi if it is given  some instructions in Python it can understand them and carry them out. This happens when the program is run.

It is also important to realise that once the program has been run it will try and carry out every instruction, one line after another in the order you had written them down in the program. It will only stop when it has no more instructions to carry out.

Much like speaking a language, when you write a programming language there are certain building blocks that you use which let you do powerful things with a program and also help you organise it. The first of these building blocks we will introduce are called constants.

Constants and how they can help

As you may have seen from the previous bit of code that got the Pi-Car going, it was actually quite difficult to understand. The first thing that can help us with this are called constants.

The best way of explaining a constant is by adding them to the code we created in driving lesson #1.

• Lets get driving…
  

Adding constants

Here is the code created in the first driving lesson:

import time, RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(12,GPIO.OUT)

GPIO.output(12,1)

time.sleep(3)

GPIO.output(12,0)

Chances are you probably cannot remember what all of this means and what it makes the Pi-Car do, so lets add some constants to make it easier to understand. Change your code so it looks like below:

import time, RPi.GPIO as GPIO

ON = 1
OFF = 0

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(12,GPIO.OUT)

GPIO.output(12,ON)

time.sleep(3)

GPIO.output(12,OFF)

With the changes you made above it is a good idea to run the program again to check that you have it right. As before, if connected to the Pi-Car it should move forwards, wait for 3 seconds and the stop. If you cannot remember how you actually write Python code on the Raspberry Pi and then run it click here.

Lets have a look at what we added in the program above. Adding the lines:

ON = 1
OFF = 0

means that you are instructing the program to create a constant called ON and another constant called OFF. The ‘=’ sign is used to give each constant a value. In programming you have to have it this way round with the name on the left hand-side followed by the ‘=’ symbol and and the value you want to set it to on the right hand-side.

Once your constants are created you can then use them later in the same program:

GPIO.output(12,ON)

time.sleep(3)

GPIO.output(12,OFF)

This makes it much easier to understand, you can quickly see that you are turning GPIO pin 12 on and off (which in turn moves the Pi-Car forwards and then stops it moving forwards).

Adding more constants

It may not appear that important to be able to do this at the moment but when your programs get bigger it is a great help to be able to understand what is happening. We can see this in action by adding more instructions to the program to move the Pi-Car in other directions. We do this by turning on and off other GPIO pins.

In a Pi-Car the way the GPIO pins result in a particular command to the Pi-Car is as follows:

• GPIO pin 11 – backwards
• GPIO pin 12 – forwards
• GPIO pin 13 – left
• GPIO pin 15 – right

Rather than always having to put the GPIO pin number into the code, these are perfect candidates to make into constants. Once they are we do not need to keep on remembering that 13 is left every time we want to use it, or that 12 is forwards. It makes our life that bit easier which is what engineering is all about!

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
BACKWARDS = 11
FORWARDS = 12
LEFT = 13
RIGHT = 15

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.output(FORWARDS,ON)
time.sleep(3)
GPIO.output(FORWARDS,OFF)

Again with the changes you have made above run the code again to check that it still works. Your Pi-Car should still just move forwards, wait for 3 seconds and stop moving forwards.

As we did before we create our constants with the names on the left, following by an ‘=’ symbol and then the value we want to give it:

BACKWARDS = 11
FORWARDS = 12
LEFT = 13
RIGHT = 15

With the constants created we can then use them later in the program instead of writing the number:

GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.output(FORWARDS,ON)
time.sleep(3)
GPIO.output(FORWARDS,OFF)

This helps us when we try and understand the program and also it means we will not make an error typing the number in.

With our constants defined it is now quite easy to write the instructions that make the Pi-Car goes in other directions:

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS = 12
BACKWARDS = 11
LEFT = 13
RIGHT = 15

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
time.sleep(3)
GPIO.output(FORWARDS,OFF)

GPIO.output(BACKWARDS,ON)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)

GPIO.output(LEFT,ON)
time.sleep(3)
GPIO.output(LEFT,OFF)

GPIO.output(RIGHT,ON)
time.sleep(3)
GPIO.output(RIGHT,OFF)

It is now quite easy to understand what the code above is trying to do, so run the Python code again and check that your Pi-Car does what you asked it to.

Moving the Pi-Car left and right

So we can now activate all the functions of the Pi-Car from the Raspberry Pi but it is still quite basic. For instance you will have noticed that when you ran the program above the Pi-Car wheels just turned left and then right rather than moving left and right because forwards was not on.

In order to make the Pi-Car actually move left for example you will need to do the following:

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)

Getting the program to talk to us

You may have found that when you tried to do run the programs above they did not work as you hoped. You may also not always want to chase after your Pi-Car all the time as you are writing your program and want another way of knowing what it is doing.

So how can we find this out? The best way is to have the Python program tell you what it is doing. The way to do this with Python is to use the print statement. The print statement could say

print ("moving forwards")

Or:

print ("moving backwards")

We simply need to add this instruction to the program and Python will understand it and print to the screen where Python is running.

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards")
time.sleep(3)
GPIO.output(FORWARDS,OFF)

GPIO.output(BACKWARDS,ON)
print ("Moving backwards")
time.sleep(3)
GPIO.output(BACKWARDS,OFF)

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left")
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right")
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)

Try and run the program and you should see the text print to screen at the same time as your Pi-Car moves around. All you have to remember is to put what you want to print inside brackets and between the speech marks – ” “.

Another thing you can do is print out the value of the constants you created. For example maybe you got your GPIO pin numbers muddled up. You would be able to find this out by printing out the value of the constants you are using for FORWARDS, BACKWARDS and the others:

import time, RPi.GPIO as GPIO
ON = 1
OFF = 0
FORWARDS=12
BACKWARDS=11
LEFT=13
RIGHT=15

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(FORWARDS,GPIO.OUT)
GPIO.setup(BACKWARDS,GPIO.OUT)
GPIO.setup(LEFT,GPIO.OUT)
GPIO.setup(RIGHT,GPIO.OUT)

GPIO.output(FORWARDS,ON)
print ("Moving forwards after turning on forwards GPIO pin no = ", FORWARDS)
time.sleep(3)
GPIO.output(FORWARDS,OFF)
GPIO.output(BACKWARDS,ON)
print ("Moving backwards after turning on backwards GPIO pin no = ",BACKWARDS)
time.sleep(3)
GPIO.output(BACKWARDS,OFF)

GPIO.output(LEFT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving left after turning on left GPIO pin no = ",LEFT)
time.sleep(3)
GPIO.output(LEFT,OFF)
GPIO.output(FORWARDS,OFF)

GPIO.output(RIGHT,ON)
GPIO.output(FORWARDS,ON)
print ("Moving right after turning on right GPIO pin no = ",RIGHT)
time.sleep(3)
GPIO.output(RIGHT,OFF)
GPIO.output(FORWARDS,OFF)

When you run the program this time you should see the GPIO pin numbers print out. Notice here that you put the constant name outside of the speech marks:

print ("Moving right after turning on right GPIO pin no = ",RIGHT)

If you put it inside the speech marks the Raspberry Pi would think you wanted to print out the word RIGHT. Because you put the ‘,’ symbol this tells the Raspberry Pi you want to add it to the end of the string.

• Driving Lesson review
  

Congratulations you made it through, hopefully you did actually crash your Pi-Car a few times as it means you managed to get it moving. In this lesson you leant two main things:

Constants:

How to use

1. Put the name on the left and the value on the right, choose a suitable name:

ON = 1

2. Create them before you can use them in your program.

Why do they help?

1. It makes it easier to read your program.

2. If you use the same value in lots of different places it will make sure that it always is the same. Also if you want to change it you can just change it in one place.

• Print statement:

How to use

1. Add the word print followed by what you want to print out in speech marks:

print ("moving forwards")

2. If you want to print out the value of a constant add the name of the constant and make sure it is not inside the speech marks:

print ("Moving right after turning on right GPIO pin no = ",RIGHT)

• Gotcha’s
  

In any engineering things rarely work first time so don’t worry. Hopefully the list below will help. If not email us at info@pi-cars.com and leave a comment providing your code and what you tried to do, the solution will be obvious as soon as you see it!

1. I keep on getting invalid syntax after I try and run the code? The code listed above will run by typing sudo python filename in the command prompt and also when run from IDLE3 but from IDLE it will complain of a syntax error. This is because of IDLE wants the print statement without the brackets, like print “message” rather than print (“message”)
2. How to I edit and run the code? You can write Python code into any text editor, you can open up Leaf that comes with the Raspberry Pi, or you can open a terminal and type sudo nano which will open a text editor. Our tutorials use IDLE3 as this provides tips on syntax and you can also run it from there. If you use a text editor you will have to run the code by opening a terminal and typing sudo python filename.py
3. It tells me to try root what is that!? Accessing the GPIO pins currently needs you to have a bit of extra power than a normal user. To do this if you run your Python file from the command line you will need to type ‘sudo python filename.py’ rather than just python. The sudo word gives you the extra power. If you are using IDLE3 you need to open a terminal and type ‘sudo idle3′ rather than double clicking on it. A bit of a pain which will be fixed soon!

Next -> Driving Lesson #3 Variables

Previous -> Driving Lesson #1 Pi-Cars and Python

PDF Version

PDF version of this article - Introduction to Python, constants and print statements – Driving Lesson #2 _ Pi-Cars

Welcome to where you will learn how to build a Pi-Car, we call it the Pi-Cars Factory. We hope that this page contains all you need to know as well as linking to resources to let you find out more about how it all works.

We hope the instructions and photos below are clear enough but if not please leave a comment or email us at info@pi-cars.com Remember you can click on all the photos in order to see a close up.

In the film Matt is teaching Emily how to build a Pi-Car. Before this Emily had never done any soldering or electronics so hopefully you will be successful as well – even if you have never done anything like it before.

Health and Safety awareness:

Please be aware that a small amount of soldering is required for making a Pi-Car and soldering can be dangerous because of the heat and fumes. If in doubt always consult an adult with some knowledge of soldering and make sure you work in a well ventilated area.

Also remember that the Tool Kit and it’s parts contain small parts which may pose a choking hazard. Keep away from children under three years old.

Finally when using the screwdriver to take the back off the controller take care and follow the instructions below – it comes off quite easily if you press in the correct place. Ensure that the screwdriver does not slip.

Factory tour:

To make your Pi-Car you obviously need a factory and all the relevant bits. What you need is listed below together with where you can get them from:

• Pi-Car Tool Kit – you can reserve this by clicking here
• Compatible radio controlled car – you can reserve one of these by clicking here
• Soldering Iron
• Flat-head screwdriver and smaller Philips screwdriver
• Wire trimmers
• Multimeter – optional
• A factory to work in! You do need some space to work in – a table top is enough and as you will be soldering it is best to have an area close to a window so you can get a draft to blow away the fumes.

Preparing your Radio Controlled car for transformation into a Pi-Car:

Selecting and un-boxing the car

There are a number of different radio controlled cars that can be transformed into Pi-Cars. We have converted quite a number of different types! We will sell a variety of different models that we know work in the Pi-Cars shop – click here to reserve one or click here to see them in the Pi-Cars showroom.

The instructions below have been completed using a New Bright Model 1825. If you use a different model or manufacturer the instructions and photos that focus on the controller will be slightly different. If you convert a car that is not in our Showroom send us a video or the details and we’ll add it!

With your car selected un-box it and fit the batteries – for this car you will need 2 AA batteries to go into the controller and 3 AA batteries to go into your radio controlled car.

Take the controller to bits

You may want to have a play with the car first before you start disconnecting it! Once you are done playing take the battery cover off and the batteries out and unscrew the back from the controller.

Remove the highlighted screw to remove the cover.

Next peel off the CE label (bear in mind this does invalidate the warranty of the car at this point). With the label removed you can now un-clip the four different clips – two on the top and two on the bottom. You can do this with a flat-head screwdriver easing it open.

On the two clips on the top push in the flat-head screwdriver, push it in and then lever it down:

Top of controller with screwdriver about to be pressed in.

Top of controller with screwdriver pressed in before levering down.

Top of controller with screwdriver levered down in order to disconnect.

With the top two unclipped you can now un-clip the bottom clips as well in the same manner:

Bottom of controller with screwdriver to disconnect.

You now need to take the levers out – you can do this by moving out one side of the lever followed by the other. They may need to be un-clicked out:

Controller with the forwards / back and left / right levers removed.

Test and understand the car

At this point you can test the car with a multimeter which will help you understand how we are going to modify the Radio controlled car to turn it into a Pi-Car. You can jump this section if you wish but if you do have access to a multimeter we do recommend that you complete it.

Firstly check that the buttons still work by pressing the small black micro switches with your fingers. When you press them the car should move as if moving the levers:

Controller with the switches highlighted that move the car forwards, backwards, left and right.

Turn the multimeter to 20 volts DC by moving the dial:

You can run some tests on the controller with a multimeter set to 20 volts as above.

Put the black probe onto the silver test point marked TP202 highlighted in the diagram below. This corresponds to zero volts:

Test point 202 highlighted on the controller – this is zero vaults – the black probe from the multimeter should be placed on this test point.

The red probe should go on the silver test point marked TP81 highlighted in the diagram below which traces through to backwards:

The red probe from the multimeter should go on test point 80 (highlighted) which relates to backwards.

When you have the probes on these test points you should see on the multimeter that you have a reading of 3 volts. If you then press the backwards switch the voltage should decrease to zero this is because one side of the switch is being pulled down to zero volts.

Transforming the Controller:

Soldering with the controller

We now need to connect wires onto the test points which will be connected via the electronics we’ll construct from our Tool Kit onto the Raspberry Pi GPIO pins.

In order to make it easier to connect these wires to the controller, firstly the test points on the controller need to be enlarged. This is your first chance to use your soldering iron! For the Raspberry Pi guide to soldering click here. For the Instructables guide click here for the Make guide to solder click here.

Heat up your soldering iron place the flat end of the soldering iron onto the test point. After around  a second the test point will melt. You can then place a piece of solder onto the soldering iron. This will create a bigger ‘bubble’ of solder onto the test point.

Using a soldering iron and some solder to expand a test point.

Each of the test points highlighted below need to be enlarged. These are test points

• TP202 (0 volts)
• TP81 (backwards)
• TP80 (forwards)
• TP82 (left)
• TP83 (right)

All the test points highlighted needs to be expanded.

Tinning and feeding through wires 

Select the wires shown in the picture below. On one end they have a black connector (this is called a female) and on the other end they just have a bare wire coming out.

Set of 5 cables female at one end and stripped wire at the other.

Before feeding through the wires it is a good idea to add some solder to the wires. This is called ‘tinning the wires’ and means they get a much better connection when they are soldered on.

Before you can tin them you need to make sure all the strands of wire are nicely compacted to get a good connection. You can do this by simply twisting the strands as shown in the photo below:

Two of the wires have been twisted to provide a nice solid wire, the remaining three show how they may look out of the pack.

To tin the wire it is easiest to rest the wires on something so that they are suspended. One at a time place the soldering iron underneath the wire and touch it onto the wire to heat it up. Touch the solder onto the wire and then move it along the wire to spread some solder along the length of the wire.

Setting the wires up to tin them with the soldering iron and some solder.

Beginning to tin the wire with the solder and soldering iron.

Almost completed the tinning of the wire.

You don’t have to do this but it will make it much easier to connect the wire to the controller test points later!

Feed through the wires through the existing hole in the back of the controller, they need to be fed through over the back of the board. This can be done all at once:

The bare wire ends can be fed through the existing hole at the back of the controller.

You can then pull the wires through ready for soldering onto the test points of the controller as shown below:

Pull the bare ends of the wires through so that they are ready for soldering onto the board.

You are ready for connecting up to the test points.

Soldering the wires onto the test points on the controller

You can now solder the wires to the controller. The different colour wires should be connected as follows:

• Purple wire – TP202 (0 volts)
• Blue wire – TP81 (backwards)
• Green wire – TP80 (forwards)
• Yellow wire – TP82 (left)
• Orange wire – TP83 (right)

Before you connect on the wires you probably need to trim them down slightly so they fit nicely. You may have burnt back some of the sheath of the wire when you were soldering so just trim the wire back until there is just less than half a centimetre left:

Snip back the wire so there is just less than half a centimetre left.

Solder each wire one at a time by placing the soldering iron onto the test point which should melt after about a second. When it does place the wire into the melted solder and remove the  soldering iron.

Soldering the wires onto the controller.

Controller with wires connected onto test points.

Creating the Electronics:

Introducing the breadboard

Take the white rectangular object that came with your Pi-Cars Tool Kit, this is the Breadboard.

Close up of breadboard from Pi-Cars Tool Kit

The breadboard is used for making electronics circuits. The video provides a further explanation of how the breadboard works and how you can use your multimeter to understand it:

Our upcoming research and development section will also provide more detail on exactly how a breadboard works.

Putting the components on the breadboard

We are now ready to start adding components to the breadboard. The first items to add are the Field-effect Transistors (FETS). There are three legs for each of these FETS and each leg should go into a hole in a different row. It is important to get the FET the right way round. The circular side should be pointed towards the left edge of the breadboard as shown below (click on the photo to increase the size):

The FET should be added as per the above diagram – note that it needs to be the correct way round.

Each FET has three legs called the drain, gate and the source. These should go into three holes next to each other

• Drain into column A row 1
• Gate into column A row 2
• Source into column A row 3

As shown in the photo below:

FET legs going into the different rows on the breadboard.

Add three more FETS to the breadboard making them evenly spaced along the breadboard. We would suggest the following holes for the breadboard:

• Second FET – leg 1 – row 10, leg 2 – row 11, leg 3 – row 12
• Third FET – leg 1 – row 19, leg 2 row 20, leg 3 row 21
• Fourth FET – leg 1 – row 28, leg 2 row 29, leg 3 row 30

As shown below:

Breadboard with all four FETs added.

The next item to add is the resistor onto the board. One of these should be put into column C of the breadboard so that there is one spare hole between the resistor and the FET. Each resistor only has two legs these should be in line with the gate and the source legs of the FET. Don’t worry you cannot get the resistor the wrong way round.

So the first leg of the first resistor should go into column C row 2. You will then need to bend the resistor to position the next leg into column C row 3 as shown in the diagram below:

Add the resistor onto the breadboard, one leg should go into column C row 2 and the other leg into column C row 3.

Breadboard with FETs and one resistor added.

The remaining three resistors should then be added to the breadboard. These should be placed as the first resistor all going into column C. If you put your FETs into the rows we detailed earlier you should put your resistors as follows:

• First resistor legs into column C rows 2 and 3.
• Second resistor legs into column C rows 11 and 12.
• Third resistor legs into column C rows 20 and 21.
• Fourth resistor legs into column C rows 29 and 30.

Breadboard with all resistors added in addition to the FETs

Next you need to take the male to male jumper leads onto the breadboard. The four male to male leads are shown in the photo below. These are the collection of four wires which may be black, grey, white or brown:

Male to male cables of the same colour for breadboard interconnections

Firstly you need to press one end of the jumper lead into the row in between the FET and the resistor. It should go into the row with the second leg of the resistor and the third leg (the source) of the FET. If you followed the numbering above this would be in column B row 3:

Male jumper cable inserted into column between FET and resistor.

The other end of the cable needs to go to a column where all zero volts cables should go. Here we are allocating this as the far right column marked with a minus sign so the cable should be pressed into that column.

The cable can in fact go into any row in that column but for neatness sake we will put it into the same row as the other end.

Jumper cable connected at both ends, one to ground or zero volts and the other to the resistor and FET.

You can now put the remaining three cables into place. As with the first cable put one end of the lead into column B row 3 between the second leg of the resistor and the third leg of the FET. If you have followed the numbering on the breadboard so far it will mean:

• First jumper lead into column B row 3
• Second jumper lead into column B row 12.
• Third jumper lead into column B row 21.
• Fourth jumper lead into column B row 30.

All jumper leads connected at both ends.

Connecting up the Raspberry Pi and controller cables onto the breadboard

With these components set up we need to connect one side to the Raspberry Pi GPIO pins and the other side to the radio controller. There will be five cables, one for zero volts and one each for forwards, backwards, left and right. Firstly we will concentrate on the connection to the GPIO pins.

Take the set of five joined together female to male jumper cables:

Male to female jumper cables.

The male end of the cable will go into the breadboard whereas the female end will go onto the GPIO pins. Take the purple cable and insert the male end into the row we have defined as zero volts on the breadboard as shown in the photo below:

Zero volts cable connected to the breadboard, the other end will go onto the GPIO pin of the Raspberry Pi.

We can now connect up the cables that will move the Pi-Car backwards, forwards left and right. The following colours are used:

• Blue cable – backwards
• Green cable – forwards
• Yellow cable – left
• Orange cable – right

The photo below shows the blue cable connected onto the breadboard. It did not matter which row the zero volts cable went into but it does matter which row each of these cables go into. They should go in line with the second leg of the FET (the gate) and the first leg of the resistor – if you have used the numbering above this should be column E row 29:

The blue cable is plugged into column E row 29 – in line with the second leg of the FET.

You can now plug in the remaining cables – the green, yellow and red cables. As with the blue cable they should go in line with the second leg (the gate) of the FET and the first leg of the resistor. If you have used the numbering above in the lesson the cables should be pushed into the breadboard as follows:

• Green – column E, row 20
• Yellow – column E, row 11
• Orange – column E, row 2
• Blue – column E, row 29

Cables which will go from Raspberry Pi GPIO to the breadboard.

We now need the other set of five connected male to male jumper cables which we will connect one end onto the breadboard and the other end onto the female connectors from the controller. These are shown below:

The five coloured male to male jumper leads.

Again we will do the zero volts cable first so take the purple cable and put it next to the other purple cable you just added from the other set of five. It could go in any row on the breadboard in the same column but we’ll put it here to keep it neat as shown in the photo below:

Purple zero volts cable which will go to controller connected onto breadboard next to other purple cable.

As before the remaining coloured cables now need to be connected onto the breadboard. These will go in the same row as the first leg of the FET (the drain) in column D. The cables should be connected as follows:

• Blue cable – column D row 28
• Green cable – column D row 19
• Yellow cable – column D row 10
• Orange cable – column D row 1

The photo below shows these cables connected:

Cables from the Raspberry Pi and the controller connected to the breadboard.

Connecting the controller cables to the breadboard cables

You can now connect the cables from breadboard onto the cables coming from the controller. From the breadboard you need to select the ‘male’ cables. These are the ones with the silver wire extending from the black connector at the end of the coloured cable.

Make sure you connect up the same coloured wires to each other:

Connecting the purple zero volts cable from the breadboard to the female connector coming from the controller.

All cables connected up from the breadboard to the controller.

Connecting the breadboard wires to the Raspberry Pi end

You now need to connect the other set of cables to complete your Pi-Car. These will be connected to the GPIO pins on the Raspberry Pi (the small prongs on the top right of the Pi shown in the photo below).

You do need to take care to connect them to the correct GPIO pins so please pay attention to the drawing below, it is highlighted with which colour cable should be plugged into which GPIO pin:

Highlights which colour cables should be connected into which GPIO pins.

• Purple wire – GPIO pin 6 (0 volts)
• Blue wire – GPIO pin 11 (backwards)
• Green wire – GPIO pin 12 (forwards)
• Yellow wire – GPIO pin 13 (left)
• Orange wire – GPIO pin 15 (right)

The pins are numbered starting with the one at the top of the left column being ’1′ and the one at the top of the right column being ’2′. The next one in the left column is ’3′, the next one in the right column ’4′ and so on.

If you are not using the software we provide to access the GPIO pins you should be aware that they can be referred to with different numbering schemes. You can click here for more information on that. If you are using the Pi-Cars provided software such as the driving lessons and software tool box then you don’t need to worry about this at the moment.

Take the collection of five coloured cables coming from the breadboard and push each connector onto the correct GPIO pin as shown in the photo above and those below. The connector should push down firmly into place (click on the diagrams for larger images):

Connect purple cable to the GPIO pin for zero volts – GPIO pin 6.

Connect the blue cable to GPIO pin 11. This is the cable that will move the car backwards.

Connect the green cable to GPIO pin 12 – this will be the cable that moves the Pi-Car forwards.

Connect the yellow cable to GPIO pin 13. This will be the cable that moves the car left.

Connect the orange cable to GPIO pin 15 – this will be the cable that moves the car right.

A new Pi-Car is born (why don’t you name it!)

Pi-Cars Tool Kit with one side connected to the controller and the other to the GPIO pins on the Raspberry Pi.

Testing your Pi-Car:

Test your Pi-Car before you connect back together

Now you have finished constructing your Pi-Car it is always a good idea to give it a visual inspection. Check all the wires are pressed in tightly and the there are no loose wires.

Firstly turn your car back on and check that it moves when you press the little switches to go forwards and backwards, left and right as shown below:

Controller with the switches highlighted that move the car forwards, backwards, left and right.

Jump starting your Pi-Car

Once you have confirmed this works we can now try and control the Pi-Car through the Raspberry Pi. Make sure the wires are connected to the GPIO pins on the Raspberry Pi and your Raspberry Pi is turned on.

The best way of testing your Pi-Car quickly is with the Jump Start guides. These enable you to move your Pi-Car in four lines of Python code or through Scratch getting the software from the Raspberry Pi Store.

We chose to use the Python Jump Start when we built our Tool Kit:

You can access the full instructions for the Jump Start for Python by clicking here. For accessing full instructions for Jump Starting your Pi-Car with Scratch click here.

Congratulations you have created a Pi-Car (hopefully) and you can now go on and complete the Driving lessons for Scratch and Python which will teach you about programming. Click here for Scratch Driving Lessons and click here for Python Driving Lessons.

If your Pi-Car is not working don’t panic – leave a comment here and try to explain any problem you had or email to info@pi-cars.com . Don’t worry if you think you have just made a really basic mistake – the reason most things in engineering don’t work comes down to simple mistakes.

PDF Version

PDF version of this article - Pi-Cars Factory – Tool Kit _ Pi-Cars