 | Introduction
In my first Raspberry Pi article, I gave a quick look at the board, and showed how easy it was to load up an OS and kick the board into life, connect to the internet and browse to The CodeProject.
In this article, I hope to demonstrate how to hook up the board to the real world. Unlike the Arduino boards, there are no easy input output digital in/out or analog pins, just a simple general purpose input output (GPIO) set of pins.
Well, much to my happiness, there is a board for that!
|
Bring on the Gertboard!
The Gertboard is an interface extender board that connects to the Raspberry Pi via the GPIO pins using a ribbon cable. The image below is what the Gerboard (left) hooked up to RasPi (right) should look like when I'm finished. (photo courtesy of Element14);
I purchased mine through Element 14 (Part Code 211-5337). Just like the original RasPi release, there was a back order when I ordered mine, so just had to wait.
The kit I ordered was an unassembled unit and I don't mind dusting off the soldering iron. That was until I saw the kit when it arrived and discovered absolutely tiny surface mount components! In total there were 33 individual bags of components, IC's and various headers and jumpers and of course the 1x Gertboard PCB.
On the Farnell website, you can now order fully assembled boards which will take away some of the pain and trouble for some. (Part Code 225-0034).
Farnell now have a whole section dedicated to the Raspberry Pi, with various boards, cases, cameras and other accessories.
Building the board
After opening the package that arrived and spreading everything out. I noticed that there were no assembly instructions. So hadn't a clue where each component should go. A quick search online and found the assembly manual and user manual linked from the RasPi website back to Element14;
The photo below shows everything spread out still in its packaging before the mammoth task begins:
After downloading the assembly manual and opening up, it was nice to see in the intro a guide to soldering the surface mount devices. I had never attempted to solder these before, so was a little bit apprehensive given how small they were. As an example, there were 2 x 0 Ohm SMD resistors in the kit. These are 2mm x 1.2mm. In the photo above you can see the SMD component strips at the bottom left in the white bags.
I also had treated myself to a new soldering station. I did have an old 25W basic soldering iron, but thought it was about time to leave the dark ages. Well almost the dark ages, at least I didn't have to heat the iron up on a fire!
So it was time to get down to business. First thing I did was laid out the bags of SMD components. These only had the Farnell/Element14 part number on them and no content description. It is worth going onto the website and look up each component and write its description on the bag. The SMDs, whether capacitors or resistors look the same, so you don't want to mix them up. Also, when assembling the board, stick to one component type at a time, again so as you don't mix them up. Once completed with that component type, put away the bag of any spares and move to the next. It is advisable to start with the smallest component size, and then work up to the larger things like IC holders and Fuse holders.
Take your time, follow the instructions. All going well, everything should work out just fine!
How did it go then?
It went not too bad. Trying to open the SMD component wrappers was a bit of a pain, and the very first packet resulted in the capacitors being spread all over the place, but managed to find them all. I managed to put one of the resistor bridges into the wrong holes, but noticed when I had tacked the first leg.Then I put an IC holder in the wrong way round, but only had soldered 2 corners, so managed to recover the situation without much of a fuss.
In total it took me 2 hours 8 minutes to assemble the board. That included having to go and answer the doorbell at one point! Below, is the finished article;
Let's Do The Time Lapse!
On the RasPi website, there was a time lapse video by Mike Cook of him building his Gertboard. I had never done a time lapse video before, so thought I would also have a go at this. This would also be a good excuse to put my GoPro HD Hero 2 to use!
The video below was created by first shooting a time lapse sequence of the build at 1 Frame / 5 Seconds @ 3200 x 2400 resolution, then using the GoPro Cineform Studio convert this to 1280x720 HD Output at 10 Frames per second.
http://www.youtube.com/watch?v=hNPQao6wops
As you can see in the beginning of the video, the use of tweezers was definitely required to tackle the SMD components. They were a nightmare! I also had the pleasure of my eldest, Maya (8), joining me later to do a bit of supervising. Talk about (at least) twenty questions...
What is on the board?
The Gertboard has various functions. These are all broken out to various headers, allowing you to use them as you see fit. The main functions on the board are;
- 2 x Digital to Analog converters (8-bit)
- 2 x Analog to Digital converters (10-bit)
- 12 x LED indicators
- 3 x pushbuttons
- 6 x Open collector outputs
- 12 x Digital IO
- 1 x Motor Controller (bidirectional up to 18v @ 2Amps)
There are also 3 x Pushbuttons strapped to 3 of the IOs and also 12 x LEDs strapped to the IO.
Another noticeable aspect of the Gertboard, is the fact that it also has a ATMega328 microcontroller built onto the board, with all pins broken out to a set of headers. This effectively means there is an Arduino also on the board.
Testing the board
NOTE: Version 1 (Self Assembly) and Version 2 (Pre-Assembled) are slightly different in terms of connectors and jumpers, so you do need to refer to the correct guides for your own board.
In the user manual, there are links to download sample code from Element14 website, but there are a whole bunch of other things out there on the Gertboard. A good place to start is in this forum; http://www.raspberrypi.org/phpBB3/viewforum.php?f=42
Having downloaded and installed the latest version of Wheezy (as per my Episode 1 article), next need to get hold of the suitable python test code.
From the command console on the Raspi you can do the following;
wget http://raspi.tv/download/GB_Python.zip
unzip GB_Python.zip
cd GB_Python
nano README.txt
In the readme file, there are further instructions and links to code and demos videos on Youtube of the running code.
For the purpose of this article, I will just test a couple of these.
LED Test
Running the command;
sudo python leds-rg.py
results in the program printing out which jumpers you should connect for the test, and then waits for you to hit 'Enter'. This will run the LEDs through a sequence 1->12->1 etc.
Unfortunately, for whatever reason only the LEDs 1 to 8 would work on my board. I swapped the jumpers over on Pins B1 and B12 to confirm the B12 is trying to at least drive a signal, and this was confirmed by LED1 lighting up when it should as 12. The next thing I went to do was to swap over 2 of the ICs, just in case one of these was fried. I went and pulled the IC (U5) which drives the leds 9/10/11/12, and this is when I noticed I didn't have the jumper links installed which determine if this is Input or Output, popping these jumpers in, reinserting the IC and rerunning the test confirmed that the LEDs were now all sequencing correctly. Panic over!
RasPi.TV published a video of this test on Youtube here: http://www.youtube.com/watch?v=fFHEi1ur7yg (Note, in video you will only see that they have jumpered only the 1st 10 LEDs instead of the full 12).
Button Test
Running the command;
sudo python buttons-rg.py
results in the program again printing out the instructions of which jumpers to insert and then waits for your to press 'Enter'. Once you press the key, the program outputs the binary state of the buttons e.g. '111' and illuminates the LEDs, when you press the buttons, the binary state and LEDs change as you would expect.
Reference test on RasPi.TV : http://www.youtube.com/watch?v=DwlI2Fr1AXg
Code Behind
Often the best way to learn and understand what is going on is simply to open up the someone else code and take a peek. The code below is the LED test from leds-rg.py;
import RPi.GPIO as GPIO
from time import sleep
import sys
board_type = sys.argv[-1]
if GPIO.RPI_REVISION == 1:
ports = [25, 24, 23, 22, 21, 18, 17, 11, 10, 9, 8, 7]
else:
ports = [25, 24, 23, 22, 27, 18, 17, 11, 10, 9, 8, 7]
ports_rev = ports[:]
ports_rev.reverse()
GPIO.setmode(GPIO.BCM)
for port_num in ports:
GPIO.setup(port_num, GPIO.OUT)
def led_drive(reps, multiple, direction):
for i in range(reps):
for port_num in direction:
GPIO.output(port_num, 1)
sleep(0.11)
if not multiple:
GPIO.output(port_num, 0)
if board_type == "m":
print "These are the connections for the Multiface LEDs test:"
print "BUFFER DIRECTION SETTINGS, jumpers on all OUT positions (1-12)"
print "GPIO 25 --- BUFFERS 1 \nGPIO 24 --- BUFFERS 2"
print "GPIO 23 --- BUFFERS 3 \nGPIO 22 --- BUFFERS 4"
print "GPIO 21 --- BUFFERS 5 \nGPIO 18 --- BUFFERS 6"
print "GPIO 17 --- BUFFERS 7 \nGPIO 11 --- BUFFERS 8"
print "GPIO 10 --- BUFFERS 9 \nGPIO 9 --- BUFFERS 10"
print "GPIO 8 --- BUFFERS 11 \nGPIO 7 --- BUFFERS 12"
else:
print "These are the connections for the Gertboard LEDs test:"
print "jumpers in every out location (U3-out-B1, U3-out-B2, etc)"
print "GP25 in J2 --- B1 in J3 \nGP24 in J2 --- B2 in J3"
print "GP23 in J2 --- B3 in J3 \nGP22 in J2 --- B4 in J3"
print "GP21 in J2 --- B5 in J3 \nGP18 in J2 --- B6 in J3"
print "GP17 in J2 --- B7 in J3 \nGP11 in J2 --- B8 in J3"
print "GP10 in J2 --- B9 in J3 \nGP9 in J2 --- B10 in J3"
print "GP8 in J2 --- B11 in J3 \nGP7 in J2 --- B12 in J3"
print "(If you don't have enough straps and jumpers you can install"
print "just a few of them, then run again later with the next batch.)"
raw_input("When ready hit enter.\n")
try:
led_drive(3, 0, ports)
led_drive(1, 0, ports_rev)
led_drive(1, 0, ports)
led_drive(1, 0, ports_rev)
led_drive(1, 1, ports)
led_drive(1, 0, ports)
led_drive(1, 1, ports)
led_drive(1, 0, ports)
except KeyboardInterrupt:
GPIO.cleanup()
GPIO.cleanup()
As you can see it is fairly straight forward and commented to help understand what is going on without any more description. The code below is from the button test, this will allow use to understand how we read back onto display the state of the buttons (buttons-rg.py);
import RPi.GPIO as GPIO
import sys
board_type = sys.argv[-1]
GPIO.setmode(GPIO.BCM)
for i in range(23,26):
GPIO.setup(i, GPIO.IN, pull_up_down=GPIO.PUD_UP)
if board_type == "m":
print "These are the connections for the Multiface buttons test:"
print "GPIO 25 --- 1 in BUFFERS"
print "GPIO 24 --- 2 in BUFFERS"
print "GPIO 23 --- 3 in BUFFERS"
print "Optionally, if you want the LEDs to reflect button state do the following:"
print "jumper on BUFFER DIRECTION SETTINGS, OUT 1"
print "jumper on BUFFER DIRECTION SETTINGS, OUT 2"
print "jumper on BUFFER DIRECTION SETTINGS, OUT 3"
else:
print "These are the connections for the Gertboard buttons test:"
print "GP25 in J2 --- B1 in J3"
print "GP24 in J2 --- B2 in J3"
print "GP23 in J2 --- B3 in J3"
print "Optionally, if you want the LEDs to reflect button state do the following:"
print "jumper on U3-out-B1"
print "jumper on U3-out-B2"
print "jumper on U3-out-B3"
raw_input("When ready hit enter.\n")
button_press = 0
previous_status = ''
try:
while button_press < 20:
status_list = [GPIO.input(25), GPIO.input(24), GPIO.input(23)]
for i in range(0,3):
if status_list[i]:
status_list[i] = "1"
else:
status_list[i] = "0"
current_status = ''.join((status_list[0],status_list[1],status_list[2]))
if current_status != previous_status:
print current_status
previous_status = current_status
button_press += 1
except KeyboardInterrupt:
GPIO.cleanup()
GPIO.cleanup()
Temperature Test with DS18B20 1-Wire Temperature Sensor
I have a project in mind in which I want to monitor my home central heating, hot water, solar thermal and solar PV systems. To allow me to monitor the temperature I purchased a bunch of 'One Wire' temperature sensors. These were pre-wired into a waterproof probe and on a 1 metre lead. These sensor are Dallas Semiconductos DS18B20 and each sensors has a unique ID allowing them to be bus wired and polled.
The image below is my test setup, from left to right, RasPi, Gertboard, breadboard, Arduino (it just happens to be attached to the breadboard, but is not used in this article). You can see the tip of the sensor at the middle bottom of the image.
Rather than re-invent the wheel for a test, a quick search on Google pulled up this excellent tutorial over at Adafruit: Adafruit's Raspberry Pi Lesson 11. DS18B20 Temperature Sensing.
After following the example in the tutorial, as you can see below I successfully managed to read the device from the console and from a python script.
In the Python output above, you can see the temperature in 'C and 'F e.g. (33.5, 92.3)
Temperature Test Code
The slightly modified version of the example code from the tutorial is shown below;
import OS
import glob
import time
import subprocess
os.system('modprobe w1-gpio')
os.system('modprobe w1-therm')
base_dir = 'sys/bus/w1/devices/'
device_folder = glob.glob(base_dir + '28*')[0]
device_file = device_folder + '/w1_slave'
print "Device Folder: " + device_folder
print "Device File : + device_file
def read_temp_raw():
catdata = subprocess.Popen(['cat', device_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = catdata.communicate()
out_decode = out.decode('utf-8')
lines = out_decode.split('\n')
return lines
def read_temp():
print "Raw device data :"
lines = read_temp_raw()
print lines[0]
print lines[1]
print lines[2]
while (lines[0].find('YES') > 0):
lines = read_temp_raw()
equal_pos = lines[1].find('t=')
if equal_pos != -1:
temp_string = lines[1][equal_pos+2:]
temp_c = float(temp_string) / 1000.0
temp_f = temp_c * 9.0 / 5.0 + 32.0
return temp_c, temp_f
while True:
print "Current Temperature ('C, 'F):"
print(read_remp())
print ""
print "Sleeping.....(1 Second)."
time.sleep(1)
As you can see in the code above, it basically is parsing strings to extract the temperature from the line 't='. This is scaled up so need to be divided by 1000 to get the centigrade reading. The code will only currently work for a single bussed sensor, it will need to be modified to read multiple sensors.
What Next?
Well I am pleased with what has come together so far.
Next up, I will look at scaling this up to my multi sensors for temperature and optical (want to look at the burner viewing window to see when the heat demand is running). Then look at integrating my solar systems etc.
Demanding on how all that goes, it might make the subject of a future article.
Thanks for getting this far......see you in the next episode maybe.
Reference Links
History
5th December 2013 - Article first published.
