The MagPi Issue 7

IISSSSUUEE 0077 NNOOVV 22001122

AA MMaaggaazziinnee ffoorr RRaassppbbeerrrryy PPii UUsseerrss

hh tt tt pp :: // // ww ww ww .. tt hh ee mm aa gg pp ii .. cc oo mm

Raspberry Pi is a trademark of The Raspberry Pi Foundation.This magazine was created using a Raspberry Pi computer.

TThhiiss IIssssuuee.. .. ..

•• IInntteerruuppttss•• SSoollaarr PPii•• TTuurrbboo MMooddee•• PPii EEvvoolluutt iioonn•• CC++++

PPlluuss.. .. ..•• AAnn iinntteerrvv iieeww wwii tthh tthheeRRaassppbbiiaann ddeevveellooppeerrss•• MMaakkee yyoouurr oowwnn llaaddddeerrggaammee uussiinngg PPCCBBss•• TThhee bbaassiiccss ooff GGNNUU mmaakkee

AArrdduuiinnoo AAnnddRRaassPPii GGeett

CCoonnnneecctteedd!!

AA cchhaannccee ttoowwiinn aa PPIINNKKRRaassPPii CCaassee!!

Support us even moreby buying the printedcopy of this mag!

Welcome to Issue 7,

The Raspberry Pi and Arduino are a perfect match for real time applications

where a bit more CPU power is needed for control. Coupling the two devices

together opens up the possibility to use a wealth of Arduino shields too. We look

forward to seeing some really interesting projects in the future.

There is an interview from the lead developer of Raspbian (Debian build for the

Raspberry Pi), competitions and a selection of programming articles to get your

teeth into.

If you would prefer to receive your copy of The MagPi in printed form, visit

http://www.modmypi.com and place your order now!

Ash Stone, Chief Editor of The MagPi

Ash StoneChief Editor /Administrator

Jason 'Jaseman' DaviesWriter /Website /Page Designs

Tim 'Meltwater' CoxWriter /Photographer /Page Designs

Chris 'tzj' StaggWriter /Photographer /Page Designs

Ian McAlpinePage Designs /Graphics /Writer

Joshua MarinacciPage Designs /Graphics

LixPage Designs /Graphics

PaisleyBoyPage Designs /Graphics

Sam MarshallPage Designs /Graphics

Aaron ShawPage Designs /Graphics

NickPage Designs /Graphics

Matt '0the0judge0'Administrator /Website

Matthew Timmons-BrownWriter

Gordon HendersonWriter

Colin DeadyWriter /Page Designs

Stewart C. RussellWriter

W.H.BellWriter

Colin NorrisEditor /Graphics

AntiloquaxWriter

Richard RynikerWriter

Alex KerrWriter

04 PI AND ARDUINO IN ACTION

Program the Arduino using a Raspberry Pi, by Stewart C. Russel l

07 THIS MONTH'S COMPETITION

Win some excel lent additions to your setup, from PC Supplies Ltd

08 SOLAR PI

When on the move the sun can keep the Pi going, by M eltwater

1 0 GORDON'S LADDER BOARD

Soldering irons at the ready, by Gordon H enderson

1 2 GPIO AND INTERRUPTS

A review of how to handle the GPI O from the command line, by Richard Ryniker

1 6 RASPBIAN, THE STORY SO FAR

An interview with M ike Thompson, the lead developer of Raspbian, by Colin Deady

1 8 TURBO SETTINGS FOR MAXIMUM PERFORMANCE

A review of how to tune up the Pi, by M atthew Timmons-Brown

21 THIS MONTH'S EVENTS LIST

Raspberry J ams and other community events

22 PI-EVOLUTION

A review on the Raspberry Pi 's development, by J aseman

24 THE BASICS OF GNU MAKE

Speeding up code development with GN U M ake, by W. H . Bel l

26 WELCOME TO THE C++ CACHE

Getting to grips with C++, by Alex Kerr

28 THE SCRATCH PATCH

H ave a go at defensive programming, by Anti loquax.

30 THE PYTHON PIT

U sing command line arguments, by Colin Deady

32 FEEDBACK & DISCLAIMER

Contents

This example combines output (setting thebrightness of an LED with a graphical sl ider)with input (reading the temperature from anLM58).

Required MaterialsRaspberry PiArduinoInternet ConnectionSmall solder-less breadboardLM35 temperature sensor(http://www.ti .com/product/lm35)5 mm red LED1 20Ω resistor4× male-male jumper wires (here colouredred, yel low, blue and black)Short-ish breadboard jumper (1 7.8 mm or0.7", here coloured black)

Firmata (http://firmata.org) is a simple serialprotocol that al lows you to read and write I/Oports on the Arduino from a host computer. I t'smost often used with the graphicalprogramming language "Processing"(http://processing.org) but there is support forother languages.

Installing the Arduino IDE and Firmata

The Arduino IDE is already included in theRaspbian repositories, so you can instal l i t al lwith:

$ sudo aptget install arduino

I f i t's the first time you've run it, the IDE mayask you to create a folder for its programs(cal led “sketches”) .

Next, you'l l have to choose what Arduinoboard you're using from the Tools/Board menu(I 'm using an Uno, but I have also tested thison an older Duemilanove board).

You'l l also need to choose which serial port touse from Tools/Serial Port — for an Uno thatwould be /dev/ttyACM0, and older boardstend to use /dev/ttyUSB0.

To instal l the Firmata sketch onto yourArduino, select Fi le / Examples / Firmata /StandardFirmata and cl ick the Upload button.

The IDE goes off and compiles your sketch,and uploads it. I f al l you get is bl inking l ightsand a ‘Done uploading’ message, success! I fyou get any kind of red error messages, thenthere's l ikely something up with the connectionor power to the Arduino.

I 'd strongly recommend connecting yourArduino either through a powered hub orapplying external power, as the Raspberry Piis a bit l imited in what it can power over USB.

I f you get stuck try the websitehttp://www.ladyada.net/learn/arduino/

Installing pyFirmata

pyFirmata is the magic that al lows yourArduino running Firmata to talk to Python. I ttakes a few more commands to instal l i t:

$ sudo aptget install pythonserial me

rcurial

$ hg clone https://bitbucket.org/tino/p

yfirmata

$ cd pyfirmata

$ sudo python setup.py install

I f this succeeds, you can remove the pyfirmatafolder:

$ cd .. ; sudo rm r pyfirmata

Raspberry Pi & ArduinoWhile there are many I/O boards under development for the

Raspberry Pi, the Arduino is well established. This article

shows you how talk to an Arduino through Python and the

Firmata protocol.

DIFFICULTY: INTERMEDIATE

ARDUINO LM35

+5V +Vs

A0 Vout

GND GND

Building the circuit

Place the parts as shown in the diagram usingthe fol lowing tables to assist:

NOTE: I f you accidental ly connect the LM35the wrong way round, it goes from being atemperature sensor to being a remarkabletemperature generator — the D-shaped burnscar on my left index finger reminds me of thisevery day…

Running the codeEnter the progam on the next page and save itas arduino_firmata_ty.py. With your Arduinoplugged in, and the circuit wired up, you runthe program like this:

$ python arduino_firmata_tk.py

I t wi l l take a few seconds for the window tocome up and, once it does, you can control theLED's brightness with the sl ider on screen.

The LED doesn't seem to get much brighterabove 33%, you'l l notice; there isn't a straight-l ine l ink between brightness and PWM inputvoltage.

I f you touch the LM35, you'l l notice thetemperature reading changing. LM35 sensorsare a bit noisy, so you might notice thenumbers jumping about.

Once you're done, hit the window closewidget, and everything should exit cleanly.

The Python code does three main tasks:

1 . Set up serial communications and configurethe Arduino's I/O pins.

Two important detai ls we have to do here isset up an iterator thread to stop the RaspberryPi 's serial buffer overflowing while it receivesdata from the Arduino, and also to wait for theArduino to start sending real data before wemove on to the main program.

2. Define three functions to be called by theGUI:

get_temp() — this reads the value fromArduino pin A0, converts it to °C, and updatesthe label at the bottom of the window.

I f you're famil iar with Arduino, pyFirmatareturns analogue values between 0.0 and 1 .0instead of the integer range 0-1 023.

This routine ends by asking the main Tkprocess to reschedule itself after half a second(500 ms), and that way we keep updating thetemperature display separate from the mainloop.

Continuedover page...

ARDUINO LED

D3 Anode (Long Wire)

Cathode (Short Wire)

(Going Through the

1 20Ω resistor)

set_brightness() — this converts the 0-1 00value from the GUI 's Scale sl ider widget to a0.0-1 .0 floating point range, and writes it to pinD3.

cleanup() — all this routine does is turn theLED off, and tries to shut down the programneatly. I t doesn't always quite manage to dothis, however; sometimes you have to hit Ctrl-C in the terminal window too.

3. Set up the Tkinter GUI. Tk (and its Pythonversion, Tkinter) is quite an old GUI system,but is also quite simple to use.

I t rel ies on each widget (or graphical control)to run a callback routine or set a variable'svalue as it is cl icked or changed.

So here, I 'm setting up a 400 pixel wide Scalesl ider that cal ls the routine set_brightness()with the current value of the sl ider as itchanges.

Moved ful ly to the right, the sl ide would cal lset_brightness(1 00), turning the LED ful ly on.

Since the window is so simple – just one Scalewidget and a label — I'm using Tk's crudepack() method to arrange items in the window.

I t first draws the items, then packs themtogether, Tetris-l ike, into the window frame.

Once it's done that, i t schedules the firsttemperature reading (which schedules thenext, and so on), then final ly sits in the Tkmainloop() for the rest of the program,responding to your input.

Further directions

This is a very simple example of control l ing anArduino from Python.

While Firmata can control more complexoutputs such as servos, it does take over thewhole logic processing of the Arduino board.

Any sensor that requires complex setup orreal-time control isn't going to work so well .

That aside, you've now got al l the power of theRaspberry Pi hooked up to the simplerobustness of the Arduino; the sky's not eventhe l imit!

Article byStewart C. RussellStewart C. Russel l l ives in Toronto, where he engineers

wind farms and solar power plants. When he's not

lurking in the world's sunny/windy places, he's at home

on amateur radio (cal l sign VA3PID), playing banjo,

fiddl ing with computers, or avoiding gardening. His

website is http://scruss.com/blog

import pyfirmata

from Tkinter import *

# Create a new board object,

# specifying serial port;

# could be /dev/ttyUSB0 for older

# Arduinos

board = pyfirmata.Arduino('/dev/ttyACM0')

# start an iterator thread so

# serial buffer doesn't overflow

iter8 = pyfirmata.util.Iterator(board)

iter8.start()

# set up pins

# A0 Input (LM35)

pin0 = board.get_pin('a:0:i')

# D3 PWM Output (LED)

pin3 = board.get_pin('d:3:p')

# IMPORTANT! discard first reads

# until A0 gets something valid

while pin0.read() is None:

def get_temp():

# LM35 reading in deg C to label

label_text = "Temp: %6.1f C" % (

pin0.read() * 5 * 100)

label.config(text = label_text)

# reschedule after half second

root.after(500, get_temp)

def set_brightness(x):

# set LED

# Scale widget returns 0 .. 100

# pyfirmata expects 0 .. 1.0

pin3.write(float(x) / 100.0)

def cleanup():

# clean up on exit

# and turn LED back off

pin3.write(0)

board.exit()

# set up GUI

root = Tk()

# ensure cleanup() is called on exit

root.wm_protocol("WM_DELETE_WINDOW",cleanup)

# draw a big slider for LED brightness

scale = Scale(root,

command = set_brightness,

orient = HORIZONTAL,

length = 400,

label = 'Brightness')

scale.pack(anchor = CENTER)

# place label up against scale widget

label = Label(root)

label.pack(anchor = 'nw')

# start temperature read loop

root.after(500, get_temp)

# run Tk event loop

root.mainloop()

To see the large range of PCSL brand Raspberry Pi accessories visit

http://www.pcslshop.com

Last Month's Winners!The 5 winners of the PCSL Limited Edition LCD mount are Mike Bradbury (Manchester,

UK), David Corne (Birmingham, UK), Brian Bowman (Chelmsford, UK), Bart

Sekulski (Bristol, UK) and William Green (Doncaster, UK).

Congratulations. We wil l be email ing you soon with detai ls of how to claim all of those

fantastic goodies!

This month there wil l be FIVE prizes!

Each winner wil l receive a Raspberry

Colour Case by PCSL. Suitable for both

Model A and Model B with GPIO cable

access and LED light pipes.

For a chance to take part in this month's

competition visit:

http://www.pcslshop.com/info/magpi

Closing date is 20th November 201 2.

Winners wil l be notified in next month's

magazine and by email . Good luck!

Once again The MagPi and PC Supplies Limited are proud to announce yetanother chance to win some fantastic R-Pi goodies!

NOVEMBER COMPETITION

Unit Operation:This solar device essential ly acts as a solarcharger for the 4xAA batteries placed inside,which in turn are able to supply power to theRaspberry Pi itself. The device also serves asa neat holder for the raspberry pi and as abonus it can also be used to recharge mostUSB powered devices.

1 . The sun shines on the solar panel.

2. Avai lable power is used to charge thebattery pack (just insert your own standard4xAAs NiCad/NiMh of your requiredcapacity) .

3. The battery pack stores the energy andseamlessly provides power even whenthere is l i ttle or no sun.

4. The Raspberry Pi is powered!

A. The micro USB power lead plugs directlyinto the Raspberry Pi (neatly fitted upside-down into the base of the unit) .

B. The ful l size USB plug can be used todirectly power the Raspberry Pi, and if thebatteries are flat add some extra charge(charging via the sun is required to ful lycharge the cel ls) . This plug can also beused to daisy chain additional solar units toproviding additional solar power and longerbattery l i fe (by plugging into the side USBsocket (C)) .

C. An additional USB socket on the side of theunit provides an auxi l iary charging point formobile phones and other USB devices.Apple iDevices such as iPods / iPhones /iPads are supported with an upgradedversion if required.

Typical Outputs

Directly facing ful l sun approx. 300mA+

Laying flat 200-250mA

Cloudy 30mA

A Little RayOf Sunshine…

While browsing for interesting Raspberry Pi devices, I came

across the following item from CottonPickersPlace.

Specifications

Solar Panel 1 2 cel l 330mA 2 Watt Polycrystal l ine

1 1 0x1 35mm

Case Printed by BRB-3000 3D Printer with PLA

(PolyLactic Acid) material – bio-

degradeable. Typical ly takes 2h1 5min to

print. The raspberry pi, sits neatly inside.

60x90x45mm

Estimated Charge Times

The unit wi l l not overcharge the cel ls, and there is no

leakage discharge when it is not charging.

3000mAh Cells

21 00mAh Cells

CloudyFul l Flat

1 00h1 0h 1 3h20m

70h7h 9h20m

Usage Considerations:My own tests with some old 2500mAh Cells,provided around 4 hours of night-time usage,reasonable considering the batteries areseveral years old.

By using minimal peripherals and using themore efficient Model A Raspberry Pi (whenreleased) should greatly extend the runtime.The efficiency of the Raspberry Pi can also beimproved by replacing the bui lt-in 3.3V linearregulator with a more efficient switched-modeone – an extreme measure, but reported tosave about 25% of power (seehttp://goo.gl/dqUZL for detai ls) .

Although the Raspberry Pi can be used inmany situations remotely, often you wil l wantto use it with a screen. Currently mostscreens wil l require just as much if not morepower than the Raspberry Pi itself. This mayimprove when the foundation can supply LCDscreens directly driven from the Raspberry Pi,ultimately requiring less power than yourtypical LCD monitor or TV. To this end, asuper-efficient e-ink based display would bean excel lent option, fingers crossed thatbecomes a reality.

For 24 hour remote operation (somethingseveral Raspberry Pi users desire), i t is l ikelythat 2 or more solar units and plentiful sunwould be required. Additional ly, by designingsome methods to remotely switch off theRaspberry Pi power supply and switch it backon when required would mean that anunattended remote setup would be viable.Such a system could even monitor theavai lable battery levels and power theRaspberry Pi accordingly or set specific timeintervals for operations. We would love tohear of some suitable designs!

Conclusions:The compact unit offers a number of flexiblefeatures, and for running the Raspberry Pifrom batteries it presents a good solution.

The addition of the solar panel nicely extendsthe runtime of the system (particularly if youl ive in a sunnier cl imate), or al lows chargingduring the day and use at night for hours at atime. When mains powered, it offers excel lentprotection against power-cuts, effectivelyfunctioning as a UPS (Uninterruptible PowerSupply) . The unit also provides a means toquickly transfer the unit to various locationswithout powering off the unit (ideal for quicklymoving to the big screen to play some movies,without the normal hassle of finding anavai lable power socket, booting up etc).

CottonPickersPlace is working on a few largerpanel models which support larger batteriestoo, which should be able to manage 24/7operation and/or power 3rd party screens etcat the same time.

Overal l , the unit offers great flexibi l i ty atexcel lent value for money (around £25delivered). I t is very clear that a lot of time andeffort is put into each hand crafted unit.CottonPicker has clearly taken care with thedesign to keep the overal l cost as low aspossible without compromising on quality orfeatures, in my opinon hitting a great balance.

This may just be the missing piece you’vebeen looking for to complete your project, orjust a handy case which al lows you to cut thepower cord whenever you feel l ike it!

Article byMeltwater

Available from:

www.cottonpickersplace.com

Direct l ink: goo.gl/w9Rs3

Estimated Raspberry Pi Runtime

Model B – typical estimated power usage 430mAdepending on what is connected (ranges from 322mA

idle to 480mA+ peaks).

Model A – Eben stated this is around 200mA, so300mA should be a good conservative estimate.

3000mAh Cells

21 00mAh Cells

CloudyFul l Flat

7h30m23h 1 4h30m

5h1 5m1 6h 1 0h1 5m

3000mAh Cells

21 00mAh Cells

1 1 hCharge 40h

7h45mCharge 28h

Model B

Model A

The Raspberry Ladder BoardThe Raspberry Ladderboard is a kit ofpartsintended to be used asan introduction tosoldering andGPIOprogramming on theRaspberryPi.

The ladder board is based on my

original ladder game which I made

earl ier this year on a breadboard,

detai ls of which can be found here:

https://projects.drogon.net/raspberry-

pi/gpio-examples/ladder-game/

This version has been modified to

make it more useful for other

projects and hopeful ly wil l

encourage you to write your own

little games and simulations. The

software that I ’ l l be providing wil l

be a version of my original ladder

game, my Tuxx crossing simulator

and a new “Simon Says” game.

The kit includes a professional ly

made PCB, 8 standard LEDs (2

each of blue, green, yel low and

red), 2 smaller LEDs (green and

red), 4 push button switches, 1 4

resistors for the LEDs and

switches and a short (ready-

made) ribbon cable and IDC

connectors to connect the ladder

board to your Raspberry Pi.

You wil l need basic soldering

equipment, (soldering iron, some

solder, a pair of wire cutters) and

some time to assemble the board.

Additional ly some PCB cleaner

spray may be useful once it’s al l

finished, but it’s not essential . I f

you are comfortable with soldering

then it should not take you more

than 1 0-1 5 minutes to ful ly

assemble the board, but if not,

then it can be done in stages and

you can even test each stage as

you go.

You can buy the complete kit

including PCB from Tandy for

£7.00 including postage.

http://www.tandyonl ine.co.uk/electroni

cs/kits/raspberry-ladder-kit.html

Soldering the PCB version:Soldering is not difficult, but

requires practice. Before you start,

please read this comic strip:

http://mightyohm.com/soldercomic

Once done reading, have a look at

the PCB and the components -

don’t remove the components from

their packs at this stage - the

Tandy kit wi l l be packed in the

bags in the order that you need

them, but see if you can identify

everything first. Study the photo of

the ful ly assembled board to see

what to expect.

Check the PCB - Look for any

obvious signs of damage and

identify where the components are

fitted. The white printed symbols

wil l help. The resistors have little

rectangles, the switches bigger

rectangles (almost square), and

the LEDs circles with a flat side to

them. There is a short row of 5

holes which are not used in this

project and 2 longer rows of holes

which are used for the ribbon

cable connector.

First we need to identify which

resistors are which. In the kit there

are two types, 220Ω and 1 000Ω.

The 220Ω ones are identified by

their colour banding - Red, Red,

Brown and the 1 000Ω ones are

Brown, Black, Red. However if you

are confused, then there are 1 0 x

220Ω resistors and 4 x 1 000Ω

resistors - just count them to see

which is which.

Start with the 4 x 1 000Ω resistors.

Bend the legs at the end of the

resistor and insert them into the

PCB in the four locations.

Resistors can go either way, but it

looks better if you make them all

l ine up the same way. Push the

leads of the resistors through their

holes and bend the leads outwards

as shown on page 4 of the comic

above.

I l ike to put al l four in at once then

use something l ike blu-tak to hold

them in-place when I turn the

board over to solder, but you may

wish to do them one at a time to

start with.

Assembly:You need two hands, so make

sure the board is secure. I t’s also a

good idea to be in a well-l i t

location so you can see what

you're doing! See the video for

more ideas however, in-general

touch the soldering iron to both the

Prototype Raspberry Ladder Board and PCB

lead of the component and the pad

at the same time, wait 1 or 2

seconds, touch the solder to the

pad or the very end of the

soldering iron - it should flow

immediately and fi l l al l the gaps.

Remove the solder and then (quite

important this bit! ) keep the

soldering iron there for another

second or two.

Most components wil l be

damaged by excess heat, but do

not be afraid to keep the heat

there for up to 1 0 seconds if

required. With practice you should

be able to do a solder joint in

about 5 seconds. Iron to pad and

component lead, pause, solder

unti l i t flows, pause, remove iron. I f

you feel it’s not a good join, then

wait a moment for it to cool down

and try again.

Make sure your soldering iron is

clean each time you pick it up -

use a damp sponge or the newer

“dry wipe” systems that look l ike a

tub of brassy springs.

Once you have soldered in your

first components (or first four! )

then it’s time to cl ip the leads

short. Again, this is a two-hand job

and you must hold the end of the

lead when you cut it - i f you don’t,

then it wi l l go flying off and when it

hits you it wi l l hurt. (Additional ly

your partner, mother, etc. wi l l not

be happy cleaning up the mess of

tiny l i ttle spikes of metal! ) Hold the

end, and cut right next to the

solder join and put in the bin.

Once you have the first four

resistors soldered in, you can

progress to the 220Ω resistors.

Start with the two near the top of

the board, then the other eight

down the side.

Next is the switches. These should

hold themselves in the board while

soldering, but make sure you put

them in the right way round - they

are sl ightly rectangular, so if they

don’t seem to fit, then rotate them

a quarter of a turn and try again.

Now the LEDs. Hopeful ly by now

you should be getting the hang of

soldering. I left the LEDs unti l now

for two reasons - firstly it’s

general ly better to solder the low

components first, then the tal ler

ones, and also to give you lots of

practice soldering resistors and

switches which are more resistant

to overheating than LEDs are. You

should sti l l be OK for up to 1 0

seconds with the LEDs, but

hopeful ly by now you should be a

little quicker and more confident.

The LEDs are sensitive to which

way they go in, so do look at them

careful ly. They have a flat on one

side and this corresponds to the

flat on the image on the PCB. The

flat side always goes to the

negative side of the circuit, and

the other side (which has a longer

leg) always goes to the positive

side of the circuit.

Take your time when soldering

these in - try to make sure they al l

sit flat on the PCB and that they

l ine-up in a neat l ine.

Final ly the GPIO connector. Fit i t

into the board, secure it, solder

one pin then check it before

soldering the rest. You may wish

to go down one long l ine, then turn

the board and go down the other

l ine.

We’re done! Hopeful ly your

finished board wil l look something

l ike the one on the facing page.

Now it’s time to connect it up to a

Raspberry Pi and run the test

software.

Note: when you first turn on your

Raspberry Pi, or reboot it with the

ladder board connected, the two

smaller LEDs may be glowing

dimly. This is to be expected as

they’re being supplied with current

from the Pi’s on-board I2C pul l-up

resistors that form part of the I2C

Testing:The test software uses the

wiringPi gpio command, so you

need wiringPi instal led first.

For wiringPi (if you don’t already

have it) :

For the raspberry ladder software:

To run the test program:

I t should take you through a few

simple steps to check that your

board is working properly.

A sl ightly modified version of the

Tux Crossing program is also

there - run it with:

When it’s initial ised, push the

bottom button to start the

sequence. More software and

detai ls next month!

Ful l documentation is supplied in

the README fi le about how the

LEDs are connected up, and the

ladderTest program is a bash

script which you may copy and

edit as required. You may also

look at some of the GPIO example

programs supplied with the

wiringPi package, but the real fun

starts next month when we write

some more programs for it.

$ git clone

git://git.drogon.net/wiringPi

$ cd WiringPi

$ ./bulid

$ git clone

git://git.drogon.net/ladder

$ cd ladder

$ ./ladderTest.sh

$ ./tuxx.sh

Article byGordon Henderson

After some initial experiments where a Rasp-berry Pi operates LEDs and reads switches,when the "I t works! " euphoria fades, astuteusers may understand there wil l be problemswhen they undertake to extend those simpleprograms to more complex environments.

I discuss two such issues here: how to shareGPIO resources among multiple applications,and use of interrupts to replace wastefulstatus check loops.

There has been a frightful incidence of "runthis program as root" instructions published forthe Raspberry Pi user. This sounds to an ex-perienced user rather l ike "Here, chi ldren;these are razor blades. Take them outside,and see what you can cut with them."

Root privi lege should be viewed as a last re-sort. I ts proper use is system creation andconfiguration - the establ ishment of a protec-ted environment where faults in one programwil l not affect other applications, and cannotcause fai lure of the operating system. Atworst, a user program that errs should com-promise only the resources al located to thatprogram.

Linux has a large number of device drivers,programs typical ly part of the kernel that inter-face between hardware resources and applic-ation programs. Examples are fi le systems,which expose user-friendly functions l ikeopen, read, and write, whi le they managehardware access and maintain the necessarydata structures to al locate and free diskspace, share access in appropriate waysbetween multiple programs, and handle recov-ery after events such as power fai lures.

Root privi lege makes it easy to interfere withsystem activities. I f one is lucky, the result is

immediate panic and the system crashes. Inless fortunate circumstances, malicious soft-ware could be instal led in a system: this soft-ware can then communicate over an Internetconnection with criminals who seek personalinformation or might exploit your Raspberry Pifor nefarious activities.

Linux has a general faci l i ty to manage GPIOresources. I t creates a convenient interfacefor user programs, protects GPIO resourcesused by device drivers such as I2C and SPI,and delivers pin-specific access so one ap-pl ication does not need to worry about whatother programs do with other GPIO pins. Thisindividual pin interface is important, becausewithout it every GPIO application would haveto worry about race conditions with other ap-pl ications that share a bank of GPIO pins(locks, interrupt management, or other com-plexities would be needed).

The Linux GPIO faci l i ty uses fi les in the/sys/class/gpio/ directory. Yes, l ike many sys-tem configuration or control fi les, these fi lesare owned by root. I shal l ignore this for now,to make description of the interface easier, butpromise to return later and present a tool toencapsulate the privi leged operation in a re-sponsible way.

Setting Up The Pins

The echo command is commonly used in shel lprocedures to display messages to standardoutput, or with output redirection to write to afi le. A simple example:

echo Hello there.

Interrupts and Other Activities withGPIO Pins

Howto share GPIO resources among multiple applications,

anduse ofinterrupts to replace wasteful status check loops.

writes the output "Hel lo there." With output re-direction:

echo Hello there. >file_01

creates the fi le "fi le_01 " that contains thesame message.

The echo command wil l be used for some ex-amples of GPIO use. Pin 23 is used becauseit is convenient and easi ly accessible at ter-minal 1 6 of the 26-terminal Raspberry Piheader. I t is labeled GPIO_GEN4 on theRaspberry Pi schematic(http://www.raspberrypi.org/wp-content/uploads/201 2/04/Raspberry-Pi-Schematics-R1 .0.pdf) .

To create a user interface for pin 23, use sudoor, as root, execute:

echo 23 >/sys/class/gpio/export

This causes the kernel to create a/sys/class/gpio/gpio23 directory which con-tains four fi les relevant to this discussion: act-ive_low, direction, edge, and value. The initialvalues in these fi les (if there is no externalconnection to this pin) are:

active_low 0

direction in

edge none

value 0

To make this an output pin:

echo out

>/sys/class/gpio/gpio23/direction

I f the output value should be initial ized first,before the output driver is enabled, one of thefol lowing may be used to set pindirection with an initial value:

echo low >/sys/class/gpio/gpio23/

direction

echo high

>/sys/class/gpio/gpio23/direction

To set this pin output on or off:

echo 1 >/sys/class/gpio/gpio23/value

echo 0 >/sys/class/gpio/gpio23/value

To invert the pin logic:

echo 1 >/sys/class/gpio/gpio23/

active_low

Do this before reading an input or setting anoutput value. When active_low is 1 (or any-thing other than 0) and value is set to 1 , thepin is driven low, etc.

PleasenoteGPIOreferencechangesfor

pins3,5& 13onRevision2.0

How fast can this mechanism change GPIOpin values? A simple python programhttp://ryniker.ods.org/raspberrypi/MagPi/gpio23-max.py wil l generate pulses at 1 9 kHz.I f this is written in C (see http://ryniker.ods.org/raspberrypi/MagPi/23-maxa.c)the frequency increases to roughly 1 20 kHz.The actual frequency varies because theRaspberry Pi does other things that temporar-i ly suspend the loop - clock maintenance, net-work activity and other user and systemprocesses.

The Program

As promised earl ier, here is the programhttp://ryniker.ods.org/raspberrypi/MagPi/gpio_control.c that executes operations whichrequire root privi lege in order to export a GPIOpin for use by ordinary users. Comments atthe beginning of the program describe how tocompile and instal l i t. Once it is instal led (byroot) , because of its "setuid" characteristic, theprogram runs with an effective userid of root.Therefore, it has the privi lege needed to ex-port or unexport a GPIO pin and set appropri-ate permissions for the fi les used to controlthat pin.

Programs that execute with root privi legeshould be written by real ly paranoid program-mers. Most of the code in gpio_control.csimply checks that the arguments are reason-able, and tries to be informative if anything un-usual happens.

To use gpio_control to export pin 23 so all ofthe pin manipulations discussed earl ier do notrequire root privi lege, simply execute:

gpio_control 23 export

gpio_control.c may be easi ly configured, be-fore it is compiled, to al low GPIO access to al lusers or only users in the cal ler's group.Each of the 26 GPIO pins may be individual lyconfigured to permit or forbid export.

The Raspberry Pi uses GPIO pin 1 6 to controlthe "Status OK" green LED. I f one tries to ex-port GPIO pin 1 6, the operation fai ls becausethe kernel is using this resource:

ryniker@raspberrypi:~$ gpio_control

16 export

export failed: Device or resource busy

Other kernel programs may acquire GPIOpins, which can make them unavai lable tousers. This is good. Little harm could comefrom a user turning the status LED on and off,but what about the kernel I2C driver? It couldeasi ly suffer erratic fai lures if the pins it usesare changed in ways it cannot understand.

The kernel remembers the state of GPIO pins.For example, suppose a pin is exported, setby the user as an output pin, then unexported.The userspace fi les disappear, but the pin re-mains an output pin with the last value set. I fthis pin is again exported, the userspace fi lesare recreated to manifest the saved state.

The echo command is convenient to use inshel l scripts, occasional ly on the commandline, but Python is much easier for real pro-grams. The dozen l ines in gpio23-max.pyshould provide a simple example.

Now that the basic elements of GPIO controlhave been exhibited, this faci l i ty can be usedto replace the "infinite loop" operation, where aprogram repeatedly reads the value of an in-put signal and performs some operation whenit changes; with a vastly more efficient pro-gram that only runs when the input signalchanges. With only one input, and absolutelynothing else to do unti l i t changes, a loop maynot be a problem. However, such a loopwants to consume 1 00 percent of theCPU resource, and therefore competes ag-gressively with everything else that might wantsome piece of the Raspberry Pi.

One can introduce a delay in the pol l loop, saya "sleep 0.5" command to delay one-halfsecond before starting the next loop iteration.

This al lows other activities to run during thesleep period, but means there is an averagedelay of one-quarter second before anychange in the input is observed. Shorterdelay, faster response, more wastedCPU... ugly choice.

As the number of inputs grows, and the num-ber of responses to those inputs becomes lar-ger and more varied, it often is necessary tomanage tasks with different priorities. Inter-rupts are the means to quickly connect an in-put such as "There is a chasm directly in frontof the vehicle" to the response "Stop! ".

Another Python Program

http://ryniker.ods.org/raspberrypi/MagPi/interrupt_test23.py wil l i l lustrate GPIO inter-rupt handl ing. This program configures pin 23as an input, sets the pin's edge fi le to "both" sointerrupts wil l occur for "fal l ing" and "rising"transitions, then opens the pin's value fi le. In-vocation of select.pol l() creates a poll ing ob-ject "po", then po.register() adds the GPIOpin's value fi le as one of the sources whichcan satisfy a subsequent po.pol l() request.This program uses only the one interruptsource, but other GPIO pins, and many othersources, can be registered with the pol l object.For instance, a pipe that connects to anotherprocess could be an interrupt source, or asocket that receives data over a network froma remote system.

The second operand to po.register specifieswhich of three conditions wil l be recognized asinterrupts. The select.POLLPRI value spe-cifies only "priority data to read" wil l cause aninterrupt. The other possible conditions -"data avai lable" and "ready for output" - are al-ways true for a GPIO pin, therefore a poll op-eration when either of these is enabled wouldalways complete immediately. I f other inter-rupt sources are registered with po, they mightuse these conditions.

Sometimes, the absence of an expected sig-nal may be important. The po.pol l(60000) cal lwi l l wait for an interrupt, but only for 60seconds (60,000 mil l iseconds), before it re-turns an empty l ist of interrupt signals to indic-ate it timed out.

The kernel maintains the value fi le for a GPIOpin with two bytes of content: a 0 or 1 charac-ter to represent the pin's current value, and anewline character. f.seek(0) resets the currentlocation in the fi le to the beginning, so thevalue of the first character may be read again.

Expanding The GPIO

Only a few GPIO pins are accessible on theRaspberry Pi, but several people have shownhow inexpensive ICs such as MCP2301 7 canuse the I2C interface to expand this number.A design such ashttp://shop.ciseco.co.uk/k002-sl ice-of-pi-o/can be used up to 8 times to add 1 28 digitalI /O pins to a Raspberry Pi. Use theMCP2301 7 open-drain interrupt configurationto connect interrupt signals from multipledevices to a single GPIO pin. A pul l-up resist-or to 3V3 keeps the input high, unti l a connec-ted device drives it low. When aninterrupt occurs, the interrupt handler has toread values from all the interrupt-generatingdevices to learn which have active interruptsignals (there may be several) , launch the ap-propriate response programs, then clear al lthe interrupt requests (so the GPIO inputreturns to the high state) to al low the next in-terrupt to occur.

A Summary Of The URLs

Raspberry Pi schematic:http://www.raspberrypi.org/wp-content/uploads/201 2/04/Raspberry-Pi-Schematics-R1 .0.pdf

The programs:http://ryniker.ods.org/raspberrypi/MagPi/gpio23-max.pyhttp://ryniker.ods.org/raspberrypi/MagPi/23-maxa.c

IO Expander:http://shop.ciseco.co.uk/k002-sl ice-of-pi-o/

Article byRichardRyniker

Q:Whydid you choose to start Raspbian?

I read in January that the Foundation wasplanning to use Fedora and I wondered if Icould do the same thing but with Debian asthat is my preferred Linux distribution on ARMprocessors. For a long time I have beeninterested in learning how to bui ld anoperating system and also to contributesomething back to the Debian community.Raspbian gave me this opportunity.

I real ised it was going to take a certain amountof resources, time and effort to createRaspbian. I started asking questions on theforums to understand what someone wouldhave to consider if they undertook this. Ipoked around to see how to make it happenand it unfolded from there.

Raspbian is a joint effort between myself andPeter Green (Plugwash) who is a Debiandeveloper.

Q: Why the Raspberry Pi, as there are otherrelatively lowcost boards available?

I have a personal interest in inexpensive Linuxsystems and am very encouraged by theRaspberry Pi Foundation demonstrating thedesire and need in the market for a systemsuch as the Raspberry Pi. Ultimately myinterest is in seeing these systems at a $5-$1 0price point. I t may take a few years to getthere but things could get a lot moreinteresting in this world when there is largescale access to very cheap but relativelysophisticated computers such as theRaspberry Pi.

Q: How did you go from having a workingbuild of Raspbian to being the official OS forthe RaspberryPi Foundation?

Peter Green and I were well under way withthe project when in the middle of June we gothints that the Foundation was interested inRaspbian. When I started my expectation was

to create an alternative to Fedora used bymaybe 1 0-20% of Raspberry Pi users and Idid not expect Raspbian to become the"official" Linux distribution on Raspberry Pi.After releasing the first few test images ofRaspbian and a significant part of therepository was bui lt people started gettingenthusiastic saying they were hoping theFoundation was going to choose a Debianbased distribution. I knew the Foundation wasaware of Raspbian via the forums and that ifthey thought it was worthwhi le they wouldmake a choice to use it.

Q: How do Raspbian and the Foundation'sreleases differ?

Raspbian is a recompilation of the packagesthat comprise Debian ARM Wheezy hardfloatwith the compilation settings tuned for theARMv6 processor in the Raspberry Pi. We areusing the kernel work coming out of theFoundation unchanged because the binaryinterfaces into the kernel do not have anyfloating point components. That saved a lot ofeffort enabling us to concentrate on therecompilation of the packages.

Alex Bradbury, the Foundation's leaddeveloper, worked on the Foundation'sRaspbian image. As Raspbian is essential ly aclone of Debian he took the same scripts hehad used for the Debian based image, mademinor changes and used them to bui ld theirown Raspbian based image. I think he waspleased to see that we were closely fol lowingDebian, hence it was a fairly trivial process tocreate a Raspberry Pi optimised version ofDebian based on our Raspbian packages.

Q: How suitable did the Freescale iMX53Quick Start Board you bought in March proveto be as a build platform?

We are sti l l using 8 Freescale iMX53 boardsto bui ld Raspbian packages. These are fairlyfast systems with a 1 GHz ARMv7 processorand 1 GB of RAM. When bui lding, some of the

An interview with Mike ThompsonThe Raspbian distribution of Debian provides the operating system behind most

RaspberryPi installations. In this month's The MagPiwe interviewMike Thompson

the founder ofRaspbian.

packages require lots of RAM to bui ldenormous l ink structures in memory and werun into 1 .5-2GB of swap as we are exceedingthe avai lable RAM. A typical modern PC with4GB of memory may take an hour or so tobui ld a large package, but on these ARMsystems it can take upwards of 20-30 hours.Having 8 systems avai lable for paral lel bui ldswas needed in May and June when we werebui lding the bulk of the 1 8000 sourcepackages which translates into just under38000 binary packages for Raspbian. I f weonly had one system we would sti l l be bui ldingpackages today. We are using modifiedversions of Debian's own bui ld tools todistribute the bui lding of packages across the8 systems.

I came into this project with very l imitedexperience of bui lding operating systems andhad to learn everything needed. Fortunatelyfor me, Peter Green joined and his experiencewith Debian and Debian bui ld tools wasessential to making Raspbian possible. I hadbeen a software developer al l my career butnever attempted any bui ld on this scale. I nowful ly understand why companies have bui ldengineers that just focus on bui lding largesoftware projects!

Q: How dependent were you on the upstreamwork undertaken by the Linux community?

Extremely dependent. Raspbian would not bepossible if the group in Debian who createdarmhf had not done their upstream work 1 8months prior, albeit they went for ARMv7 andnot ARMv6. Peter Green is adamant, and Ithink correctly so, that Raspbian be as closeto an official Debian release as possiblewithout actual ly being an official release. Aslong as we maintain that commitment withRaspbian, it wi l l remain a firm base for theRaspberry Pi Foundation and the community.

Downstream, keeping Raspbian so close toDebian reduces the risk of just two guysworking on it. Peter Green ensured everythingwe have done is completely open. I f we wereto close up shop tomorrow our work is outthere mirrored in 30-40 places around theworld. Anyone with knowledge of bui ldingDebian could easi ly pick it up and keepmaintaining it. Therefore Raspbian is a lowrisk to the Foundation.

Q: Are there any other performance gains thatcan be had in Raspbian?

I think we are maxed out on the software sideof things. Replacing the CPU with an ARMv7

or adding more memory [Editor's note: the Pihas just started shipping with 51 2MB RAM! ]would be great as some people are hitting thecei l ing, for example with web browsing on aGUI desktop.

I think in general software efficiency has goneby the wayside, especial ly with GUIapplications. I always value lean and efficientuse of memory for computation. Unfortunatelythe real ity is that lots of RAM and a powerfulCPU is now needed for most GUI apps. Weshould sti l l encourage people to learn toprogram efficiently with l imited resources. I fsystems like the Raspberry Pi had beenavai lable eight years ago we may have seen alean branch of productivity software requiringless resources in general on al l computerplatforms.

Compared to Turbo Pascal that came out onCP/M in the early 1 980s, and later Turbo C,both of which featured small , fast and ful lyintegrated development environments,modern GUI based developmentenvironments take up enormous resourcesand do not run well , i f at al l , on the RaspberryPi. I t is sad that today there is no realequivalent of Turbo Pascal or Turbo C on theRaspberry Pi as these systems went awaywhen GUIs came in. I bel ieve there is a hugeopportunity to bring these types of tools backfor the comparatively low resourceenvironment of the Raspberry Pi.

Q:Whatwork is left to do on Raspbian?

We are now largely in maintenance mode. AsDebian releases updates to packages we pullthem down, bui ld and push out to therepositories. Personal ly, I have achieved mygoal with Raspbian of creating an ARMv6hardfloat version of Debian.

I am happy that Raspbian has enabled somany things in the Raspberry Pi community. I tis also great that I have been able to give backto the wider Linux community and I hope thiswil l lead to thousands more Debian users inthe future.

Mike Thompson is a Computer Engineer living inthe San Francisco Bay Area. He has a diversebackground in embedded systems design,handheld/mobile application development, PCapplication development and large scale Internetsystems design. He is a serial entrepreneur whocofounded two previous companies and is thefounder and a lead developer for Raspbian, theleading operating system for the Raspberry Pi.

The Raspberry Pi 's processor has a clockspeed of 700MHz. This means it performs700,000,000 cycles every second. The clockspeed of a processor is an indication of howfast it can perform operations. I t is measuredeither in megahertz (MHz) or gigahertz (GHz)with 1 000MHz equal to 1 GHz. So, the higherthe MHz the faster the processor wil l operate.

What are Overclock and Overvolt?

While 700MHz is the design speed of theRaspberry Pi processor, there is a way ofgetting faster performance... Overclocking.. .and thanks to the latest Raspbian image it iseasier than ever!

Overclocking is the process of making acomponent or computer run faster than itsdesigned speed, though it can involve a trade-off with increased instabi l i ty and decreasedprocessor l i fe. For the Raspberry Pi these sideeffects are so minimal you would be fool ishNOT to perform some overclocking!

Overclocking requires additional power. I f youwant to overclock your Raspberry Pi to900MHz and higher you wil l need toprovide extra power by 'overvolting'. Howfar you can overclock depends on severalfactors; your Raspberry Pi, the quality ofyour power supply and possibly also yourSD card. Because of manufacturingtolerances, 700MHz is the manufacturer’sguaranteed performance. But everyRaspberry Pi is different and so each onehas different l imits.

There are several overclock and overvoltsettings. These are detai led athttp: //elinux. org/RPi_config. txt#

Overclocking_options but the latestRaspbian image contains an easy

configuration option. Importantly this al lowsyou to overclock and overvolt your RaspberryPi whi le sti l l keeping the warranty intact.

Power supply considerations

When overclocking it is important that you usea good power supply. I use a Kindle chargerthat is high quality and provides a current of850mA. Original Apple iPhone chargers arealso good choices and provide 1 A of current.Beware of third party iPhone chargers. TheRaspberry Pi Foundation has identified thatsome of these do not perform as specified.

CAUTION: Make a backup

Before we begin, it is worth noting that there isa possibi l i ty that overclocking may corrupt thedata on your SD card, especial ly if the Turbooption is chosen. Make sure you have abackup of any important documents and alsoof your /boot/config. txt fi le. The easiestway to do this is to copy the fi les to a USBthumb drive or upload them to an onl inestorage service such as Dropbox.

Alternatively you can make a complete backupimage of your SD card using the sameWin32DiskImager program that you used tocreate your Raspbian SD card. This time,instead of writing an image to the SD card you

Fancygetting some more oomph from yourPi?

Go Turbo!

are going to create a backup image by readingfrom the SD card. Insert your SD card into anSD card reader in your Windows machine andstart Win32DiskImager. Enter a name for yourbackup image and cl ick on Read. When thebackup is complete, the fi le size of the backupimage fi le should be very similar to the size ofyour SD card.

Overclocking

To change the overclock settings start yourRaspberry Pi. From the terminal enter thecommand:

$ sudo raspiconfig

A blue box should appear, as shown on theopposite page. This is the same configurationmenu that appears when you start theRaspbian image for the first time. The firstthing to do is to update the raspi-config tool.Use the arrow keys to scrol l down and choosethe “update” option. Wait for raspi-config tolook for its latest version. Once that hasfinished we can get on with overclocking!

Now scrol l down and choose the “overclock”option. You can select how far you would l iketo overclock. There are five preset options foryou to pick from; None, Modest, Medium, Highor Turbo.

Use the arrow keys and choose your preferredoverclock preset. I t is best to start with Turboto see if that is stable. I f not then try High,fol lowed by Medium then Modest. Aftermaking your choice, exit from the raspi-configtool and reboot. You must reboot before thechanges wil l be made. The changes arewritten to the fi le /boot/config. txt .

Did I just break my Pi?

But what if your Raspberry Pi does not boot upany more? This means that the overclocksettings have exceeded the operating l imits ofyour Raspberry Pi, but don't worry as it is easyto fix. First unplug the power to yourRaspberry Pi, wait a few seconds then powerup your Raspberry Pi again. Immediatelypress and hold down the <SHIFT> key onyour keyboard. Watch the text on your screen.You wil l see the fol lowing text:

[ ok ] Checking if shift key is held down: Yes.

Not switching scaling governor.

This means that the overclock settings areignored and wil l al low you to boot up asnormal. I f you were unlucky, it is possible yourSD card fi le system got corrupted and you wil lhave to restore from your backup image. I f youhave powered up successful ly, you can openthe terminal and enter the command:

$ sudo raspiconfig

This time, when you choose “overclock” try aslower option.

I f you operate your Raspberry Pi headless viaSSH or another remote access applicationand cannot hold down the <SHIFT> key

during start-up then you need to changethe overclock settings manually usinganother computer with an SD card slot.You want to edit the fi le config. txt .For Linux and Apple Mac you can usetheir default text editor programs. ForWindows you wil l find it awkward to editthe config.txt fi le using Notepad. For abetter alternative I suggest youdownload the free TextPad programfrom http: //www. textpad. com.The entries that you need to edit arearm_freq, core_freq, sdram_freqand over_voltage . Use the image to

the left as a reference for the values youshould use.

You have chosen an overclock preset andyour Raspberry Pi appears to have startedagain without any problems. How do you knowit wi l l be rel iable?

Reliability tests

There are a couple of tests you can perform todetermine if your Raspberry Pi wi l l be rel iable.I t is no fun having a fast but unrel iable system.I f you have Quake 3 instal led this is a greattest of both the CPU and GPU overclocksettings. Another very easy test that I use is tosimply perform an upgrade of the Raspbianimage. To do this start your Raspberry Pi,open the terminal and enter the fol lowingcommands:

$ sudo aptget update

$ sudo aptget upgrade y

This is a good test of the CPU and SDRAMoverclock settings. Depending on the numberof updates this could take 30 minutes but youwil l now have the latest system.

Once complete, reboot your Raspberry Pi.This time you want to pay close attention tothe messages that appear during start-up.Look out for “mmc” messages or anymessages related to fi le system errors.Additional ly look out for [ warn ] and [ fai l ]messages. I f you see these messages thissuggests a potential weakness and youshould try the next lowest overclock preset.

I f you have different SD cards then it is worthtesting each of these. I tested three RaspberryPis with nine different SD cards ranging inspeed from class 2 to class 1 0. EachRaspberry Pi was a Revision 1 device with theUSB poly fuses replaced with wire l inks. Theywere powered from the same USB hub whichhad a 2A power supply. One of the RaspberryPis was successful up to the Mediumoverclock preset; the other two weresuccessful up to the High overclock preset.None of the Raspberry Pis worked rel iablywith the Turbo preset.

Interestingly, the two Raspberry Pis thatworked with the High overclock preset onlydid so with seven of the nine SD cards. Theyfai led with the other two cards; a Transcend 4GB class 6 card and a Lexar 1 6 GB class 6card. However, your results may be different.

Monitoring

When overclocking it is very useful to know

the current CPU frequency and CPUtemperature. You can do this very easi ly inLXDE. Right-cl ick on the Task Bar along thebottom of the screen and choose Add /

Remove Panel Items. The PanelPreferences dialog wil l appear and the PanelApplets tab should be selected. Click on theAdd button. Choose CPUFreq frontend

and cl ick the Add button. Repeat this processbut this time choose Temperature

Monitor . You may find it useful to add otherapplets such as Volume Control andNetwork Status Monitor .

Another simple test is to start Midori and visithttp: //www. raspberrypi. org. Whi lethis is loading, keep your mouse hovered overthe CPUFreq frontend applet. You wil l seethis change between 700MHz and the CPUfrequency defined in your current overclockpreset.

To watch a video about overclocking plusother Raspberry Pi topics, please visit myYouTube channel:http: //www. youtube. com/user/TheRa

spberryPiGuy.

Article byMatthewTimmons-Brown& Ian McAlpine

While ordering a copy of The MagPi fromhttp: //www. modmypi. com, I noticedthey sel l a cool ing kit. "The Raspberry PiHeat Sink Kit" comprises of three smallheat sinks plus thermal tape and couldhelp improve device rel iabi l i ty. There is aheat sink for the SoC, GPU and powerregulator.

In my own tests the CPU temperaturedropped from a maximum of 61 oC withoutthe heat sink to a maximum of only 52oCwith the heat sink.

DID YOU

Want to keep up to date with al l things Raspberry Pi in your area?Then this new section of The MagPi is for you! We aim to l ist Raspberry Jam events in your area,

providing you with a Raspberry Pi calendar for the month ahead.

Are you in charge of running a Raspberry Pi event? Want to publicise it?Email us at: editor@themagpi.com

Bloominglabs Raspberry Pi MeetupWhen: First Tuesday of every month @ 7:00pm

Where: Bloomington, Indiana, USA

Meetings are the first Tuesday of every month starting at 7:00pm unti l 9:00pm, everyone iswelcome. Further information is avai lable at http://bloominglabs.org

Durham Raspberry JamWhen: Wednesday 1 4th November 201 2 @ 5:30pmWhere: Durham Johnston School, Durham, UK

The meeting wil l run from 5:30pm unti l 7:00pm and there are a l imited number of places.Tickets and further information are avai lable at http://durhamjam-eorg.eventbrite.com

Sheffield Raspberry JamWhen: Last Wednesday of the month @ 6:30pm

Where: 1 st Floor, The Workstation, Grinders Hil l / Brown St., Sheffield, S1 2BX, UK

The meetings are hosted by GISThub. Doors open at 6:20pm and the meeting runs from 6:30pmunti l 8:30pm. Further information is avai lable at http://sheffieldraspi1 21 0.eventbrite.com

Publicise your

Raspberry

Jamhere

I f you were an early adopter of the Raspberry Pi, you

most l ikely started off running 'Debian Squeeze' - a

Linux Operating System. You spent time learning how

to download the image, and write it to an SD Card.

Then you were probably introduced to LXDE - the

l ightweight x-window graphical user interface. I t looked

similar to Windows but things were just sl ightly

different. You then had to work out how to use a

package manager - the 'apt-get' command, 'aptitude' or

perhaps 'synaptic', so that you could download and

instal l new application packages.

You just got a decent col lection of useful applications

instal led, when you discover that a newer version of

Squeeze is avai lable, which is better than the previous

one, so you start over again. Then not much later there

is yet another updated operating system - Debian

Wheezy 'Beta'. But you heard that there were some

problems with that version, and didn't know whether to

stick with Squeeze or move to Wheezy. I t was all so

confusing.

Meanwhile, many other people were sti l l waiting

patiently for their Raspberry Pi order to be processed.

Final ly the l ittle bundle arrived and you were so happy.

Then you learned that a new and improved version of

the Pi was now available, which had mount holes and

various other tweaks, and you wondered if yours would

now be considered 'old-hat'. Then to make things even

worse, it is announced that the Raspberry Pi wi l l now

come with double the amount of memory, and for the

same price!

Final ly a better version of Wheezy comes along, but

now it's become something cal led 'Raspbian Wheezy',

which is much faster, and many of the bugs have been

fixed. Oh, wait a second, here comes another release

of it, which is even better, and I hear there is another

version already planned to be released in the next

couple of weeks.

Now, if you are someone that hates change, you are

probably banging your head against the wall by this

point, and wondering if this computer stuff is real ly for

you after al l .

In computing, things often happen very quickly, and

dealing with a steady of flow of updates is something

that you have to get used to. I f you can't adapt to

change, then you wil l get left behind.

Most l ikely the pace of development wil l start to slow

down to a degree once the foundations are put in place

- but we are not quite there yet. You can expect with

the educational release of the Pi that the boards wil l

come with a case included and probably some form of

instruction manual. Also l ikely is a much improved

image, bundled with many goodies. Despite this, we

PPIIEEVVOOLLUUTTIIOONNThe pace of development surrounding the Raspberry Pi is

hard to keep up with...

must not expect things to stagnate at that stage. A

number of hardware add-ons and accessories are due

to fol low; cameras, screens, and other electronic

devices that can be hooked up to your Pi. Most l ikely at

that stage, your current non-cased, 256Mb Pi which

lacks mount holes is going to be practical ly worthless.

[Ed: Not true! See "Peter Lomas Interview" in Issue 12].

What we have to remember is that the purpose of the Pi

is to learn the principles of programming, interfacing, or

just general computing. Although many things change,

the fundamental principles do not. The Raspberry Pi is

a device for learning, and for experimenting with. I t is

not a fashion accessory or a luxury gadget. The Pi is

more of a cheap disposable item. There are people that

sel l their iPhone 4 just because there is now an iPhone

5 avai lable. There wil l be Pi owners that fal l into the

same trap, but the people who wil l get the most from the

Pi are those that stop worrying about these things and

spend more time tinkering with whichever version they

happen to have, and learning from the experience.

With this in mind, I real ised that my own SD card was

out-of-date and thought I had better take a peek at

'Raspbian Wheezy 1 8/09/201 2 Edition'.

Back in issue 5, I wrote an article comparing Debian

Squeeze and Wheezy, and one of the major downfal ls I

discovered was that although Wheezy was quite a lot

faster than Squeeze, it scored very poorly on

multimedia playback. So I decided I would first see if

anything had improved with the updated image.

Firstly I downloaded the 439MB zipped image fi le from

http://raspberrypi.org/downloads. This took about 45

minutes using the direct download l ink from my

Windows computer. Then another 45 mins to write the

image to the SD card using Win32 Disk Imager. I have

a class 4 MicroSD card which is rather slow, but it does

the job.

Next I plugged the MicroSD card (inside a normal SD

card adapter) into my Pi and booted up to the Raspi

Config screen.

Interestingly, I didn't have to change the overscan

values for my monitor this time (as I have always had to

do with previous versions of Debian).

I chose to expand the rootfs so that I could make use of

the 1 6Gb card. I also set the timezone to London and

configured the overclock to 1 000MHz Turbo Mode,

then exited the menu and rebooted.

After logging in I started LXDE by typing 'startx'. The

desktop looked almost identical to the previous version,

although the picture looked sharper. I opened an

LXTerminal window and typed 'sudo amixer cset

numid=3 1 ' to direct audio to the analogue output.

Then I used 'sudo apt-get update' and 'sudo apt-get

instal l xine-ui ' to get the xine media player. Xine is a

media player I had looked at some time ago (during the

making of The MagPi issue 3). I t looked promising, but

was real ly too sluggish to be useful. I thought perhaps

with the newer OS and the overclock that things might

be better this time around.

Fortunately my new Pi had final ly arrived from RS

Components (after a six month wait) , and it was able to

handle the ful l 'Turbo mode'. Unfortunately it arrived a

week before the 51 2MB version came out and it also

lacked the mount holes.

I did have an older revision of the Pi board that

Anti loquax had kindly sent me, but this one couldn't

handle the overclock - it fai led to boot in Turbo mode

and was unstable with any of the lower overclock levels.

Xine was able to open and play many formats that I

tested, although there was something odd about getting

the fi les to open. Only after cl icking the 'play next

chapter >| ' button would it select the correct media to

play, otherwise a message stating 'There is no MRL'

kept appearing. Xine managed to play avi, mp3, mp4,

mov as well as wma, wmv and... mpeg - YES MPEG.

However, it started dropping frames if you attempted to

play a video at anything larger than 1 00% zoom. I

haven't paid for the codec for MPEG. Xine was rather

buggy and unstable, however the command line player

'omxplayer' worked better, but supported far fewer

formats. Sti l l a massive improvement over the previous

version of Raspbian Wheezy, and I think this one is

worthy of putting Squeeze final ly to rest once and for al l .

I took a break from media players and instal led Scribus

- the desktop publishing program we use to make The

MagPi. I loaded up one of the Python Pit documents

from issue 6, and noticed that it was significantly

quicker thanks to the overclocking. I t was particularly

better when switching between layers, zooming and

right-cl icking to bring up the properties dialogue box.

Final ly I instal led a few arcade games: 'beneath-a-steel-

sky', 'geki2', 'geki3', 'pangzero' and 'xsoldier' al l worked

nicely.

Updated distributions are not necessari ly better overal l

- sometimes it's worth holding back from upgrading unti l

the bugs have been ironed out, but burying your head in

the sand and ignoring the march of progress is also a

bad idea. Always keep an eye on what's going on in the

community to avoid missing out on the cool updates

and performance tweaks.

Article byJaseman

make is a central part of bui lding packages of compiled code or documentation on a Linux system.

Open a terminal window. Then use the nano editor, described in the Issue 3 C Cave article, to create a fi le cal led

Makefile containing:

# Create newFile.txt if it is not presentnewFile.txt:

touch newFile.txtwhere there is one tab before touch. Save the fi le and in the same terminal window type make. The first time make is

typed, make looks for the fi le newFile.txt. I f the fi le does not exist it runs the touch command and the touchcommand creates newFile.txt. I f make is typed again, it finds newFile.txt and does not run the touchcommand.

Similar to other scripting languages, comments start with a hash or pound character (#). The target newFile.txthas no spaces or tabs in front of it and is fol lowed by a colon. Dependencies for the target can be added after the

colon. The actions are given on l ines after the target name and must be prefixed by a tab character. I f white spaces

are used, make wil l report an error. By default make looks for a fi le cal led Makefile. Other fi le names can be used

by using the -f option. For example, make -f another.mkProcessing dependencies is where make becomes real ly useful . A small C program can be used to demonstrate this

concept. Using the nano editor, create three fi les - main.c, printString.c, printString.h - and place

them In a new folder.

main.c#include "printString.h"int main()

printString();return 0;

printString.c

#include <stdio.h>void printString()

printf("Built with make!\n");

and printString.hvoid printString();

The basics ofGNUMake

MMaakkiinngg ccooddee ddeevveellooppmmeenntt ffaasstteerr

Now create a new fi le cal led Makefile containing,

printString: main.o printString.ogcc -o printString main.o printString.o

main.o:gcc -c main.c

printString.o:gcc -c printString.c

clean:rm -f *.o

This time typing make wil l cause each .c fi le to be compiled into a .o fi le. Then the .o fi les are l inked together to form

an executable cal led printString. The printString target is the first target in the fi le and is therefore the default

target. When make runs it checks the dependencies of printString, which are that the main.o and

printString.o fi les exist and are not newer than the target printString. I f the fi les do not exist then the target to

make the fi le is run. Any target other than the default target can be run by typing the target name after the make

command, e.g. make cleanWriting make fi les where each of the fi le names needs to be specified can rapidly become very time consuming.

Automatic variables can be used instead of explicitly specified targets,

printIt: main.o printString.ogcc -o $@ $^

%.o: %.cgcc -c $< -o $@

clean:rm -f *.o

This Makefile has exactly the same action as the previous one. The automatic variable $@ is the target name, $^are the names of al l of the dependencies, and $< is the name of the first prerequisite. For each .o fi le required by the

default target, make tries the wildcard %.c. I f the .c fi le is missing make wil l report an error.

Wildcards can also be used to define a l ist of objects from the l ist of .c fi les in the present working directory,

OBJECTS = $(patsubst %.c,%.o, $(wildcard *.c))printIt: $(OBJECTS)

gcc -o $@ $^%.o: %.c

gcc -c $< -o $@where OBJECTS is a variable. In this case, al l of the .c fi les in the present working directory are used to bui ld an

executable cal led printIt. The command wildcard l ists al l fi les which match the pattern *.c. Then patsubstremoves the .c ending and replaces it with .o. The resulting l ist is assigned to the OBJECTS variable. Try using

touch to update each fi le time stamp and then re-run make to see what happens.

Makefiles can have many layers of dependencies. For software distribution on multiple platforms, the Makefilesare typical ly generated from templates using the autoconf tool.

Article byW. H. Bell

C++ is a programming language, l ike C, Python and Java. I t is a bit more advanced, but it is verypopular and many of today’s video games and many other programs are written in C++. I t's fastand easi ly portable, which means the same code is mostly transferable between Linux, Windowsand Mac OS machines. I f you're up for the chal lenge, read on!

Try typing:

#include <iostream>using namespace std;int main() // Output a message.cout << “Hello, welcome to C++” << endl;return 0;

save it as “hello.cpp” and then compile by typing g++ -o hello hello.cppAfter compil ing and running, you should see it print the message within the speech marks. Trychanging this, recompil ing and running, and see what happens. At first this looks quite daunting,but look below and on the next page, where there is an explanation of the unfamil iar terms.

So now we’ve written our first program, how do we know what it wi l l do,and what everything means? Here I wi l l explain the important aspects ofthe program:

#include <iostream>This is our include statement. This is used to include function, class and data definitions from thestandard iostream l ibrary. The include statement is needed to use the cout and endlfunctions. The iostream l ibrary contains information on inputting and outputting.

int main()This is the main function. Al l programs need a main function and anything within the main functionis executed. Al l functions begin with ‘‘ and end in ‘’ .// Output a message

Anything beginning with ‘//’ in C++ is a comment, and l ike comments in other programs these areignored by the compiler. C-style comments using /* */ are also al lowed.

cout and endlThese are our commands. The cout command tel ls the program to output everything between the‘<<’ and the ‘;’ . endl simply means ‘end l ine’ .

An introduction to the C++ programming language - one of

the most popular used today.

;Some languages use these, semicolons. To explain them, think of the way we write normal, spokenlanguages l ike English. We end our sentences with a ful l stop. This is a similar idea - every time wewant the program to move onto something new, we end it with a semicolon. Because of this we canuse whitespace, which are spaces and new lines, however we like.

return 0;This lets the program know that the main function is over, which means it is finished. I t wi l l stoprunning past this point.

With this information, lets move on to some more examples. Try the fol lowing:

#include <iostream>using namespace std;int main() // Create 2 variablesint a, b;a = 1;b = 2;

// Output the sum of these variablescout << “a + b = ” << a + b << endl;return 0;Here, we have made two variables, a and b. They are integers, which means they are wholenumbers. We have created the two, and then output the sum of the two.

Of course this is al l wel l and good, but the output wil l always be 3 unless we change the code,which is not very useful. Instead, we could modify the program so we take a user input, and addthose together. Try this:

#include <iostream>using namespace std;int main() // Create 2 variablesint a, b;

// Ask for and store user inputcout << “Input the first number: ”;cin >> a;cout << “Input the second number: ”;cin >> b;// Output the sum of these variablescout << a << “ + ” << b << “ = ” << a + b << endl;return 0;

This wil l al low you to get the user’s inputs and add the two values.Article byAlexKerr

Defensive Bases

This month we are having a go at some "defensive

programming"; in other words trying to write a program

that can handle errors.

The "get_base" Script

This part of the code al lows you to set the input and

output base for the program to use. I t won't al low you to

enter a number less than 2 or greater than 16. This wi l l

help to avoid some real ly strange (and incorrect) results.

Hex Joke!

I f only DEAD people understand hexadecimal ,how many people understand hexadecimal?

(answer on next page! )

This converts a number

from denary into the

output base, getting the

digits from the string

"DIGITS" (see next page).

Sorry the scripts are in a funny order this month - space is tight!

Stuck?

You can get al l the scripts at:

http: //tinyurl .com/Scratchbases

Here's the start of the main program.

After the "get_base" script has got your

input and output bases, the "get_number"

script makes sure you have entered a val id

number in your chosen input base.

The "get_number" script also works out the

denary (base 10) version of your number,

ready to cal l "to_base_out" .

As Scratch doesn't have an "x to the power y" block,

I am using logarithms:

10 (log x)*y = xy

Joke Answer:

57005 people understand Hex.

This bit means that if you are doing

base 4 (for instance), the only digits

you are al lowed are 0, 1, 2 & 3.

Scratch On!

Last month The Python Pit showed how

to pull in configuration settings from an

external text file. This month another

option is presented.

Using command line arguments gives

fine control over a program at the

moment of execution.

# line generator with command line arguments

# By Colin Deady 03 October 2012

import os, pygame, argparse, sys

from pygame.locals import *

# initialise pygame (to render the image)

pygame.init()

# Define two functions that will be used:

# 1) fnAppend2Log will write a line to a log file

def fnAppend2Log( line2write ):

logfile = open('lines.log', 'a')

logfile.write(line2write + '\n')

logfile.close()

# 2) fnPlotLines will render a quarter of the shape.

# Uses the previous coordinates as the new starting coordinates

def fnPlotLines(quarter, sX, sY, eX, eY, incSX, incSY, incEX, incEY ):

fnAppend2Log(quarter + ' quarter coordinates:')

# calculate and loop through line coordinates

for i in range(0,iterations, args.step):

nSX = sX + (incSX * i) # start X

nSY = sY + (incSY * i) # start Y

nEX = eX + (incEX * i) # end X

nEY = eY + (incEY * i) # end Y

# draw a line between the pair of coordinates.

pygame.draw.line(screen,(lineColour),(nSX,nSY),(nEX,nEY),1)

PYTHON VERSION: 2.7.3rc2

PYGAME VERSION: 1 .9.2a0

O.S.: Debian 7

This Pygame line renderer uses Python's argparse:http://docs.python.org/dev/l ibrary/argparse.htmlAt the LXTerminal run the command:

python lines.py h

This wil l display al l arguments avai lable. For example:

python lines.py s 3 t 4

wil l generate a shape larger than the default (-s 2) andwith sl ightly denser l ines (-t 5). Experiment with theoptions avai lable.

# construct a string for the window title and the log file

coordText = '('+str(nSX)+','+str(nSY)+')

('+str(nEX)+','+str(nEY)+')'

# render the image line by line (takes longer)?

if args.renderlines == 'y':

pygame.display.update();

pygame.display.set_caption(coordText)

# output coordinates to the log

fnAppend2Log(coordText)

# return the final calculated coordinates

return (nSX, nSY, nEX, nEY);

# define the command line arguments:

parser = argparse.ArgumentParser(description='Render shape')

parser.add_argument('s', action='store', dest='scale', type=int,

default=2, help='Render size, default=2, 200x200px)')

parser.add_argument('t', action='store', dest='step', type=int,

default=5,

help='Lower step values for denser lines (default=5)')

parser.add_argument('r', action='store', dest='renderlines',

choices=('y','n'), default='y',

help='Render line by line (Y) or finished object (n)')

args = parser.parse_args()

# Define the variables that will be needed

sz = 100*args.scale # size in pixels horiz x vert of a quarter image

iterations = sz +5 # number of lines to render per quarter

lineColour = 0,0,255 # the colour of the line to draw (blue)

# open a pygame screen on which to render our objects

# the image size is twice the object to be rendered as we render 4 quarters

screen = pygame.display.set_mode([sz*2,sz*2],0,32)

# Draw the lines, quarter by quarter, returning the coordinate pairs

# The starting coordinates equal the end from the last quarter rendered

sx, sy, ex, ey = fnPlotLines('Top left', sz, 0, sz, sz, 0, 1, 1, 0 )

sx, sy, ex, ey = fnPlotLines('Bottom left', ex, ey, sx, sy, 1, 0, 0, 1 )

sx, sy, ex, ey = fnPlotLines('Bottom right', ex, ey, sx, sy, 0, 1, 1, 0 )

sx, sy, ex, ey = fnPlotLines('Top right', ex, ey, sx, sy, 1, 0, 0, 1 )

# if rendering each line is suppressed then display the final image

if args.renderlines == 'n':

pygame.display.update();

# save the rendered image to a file

pygame.image.save(screen, 'lineimage.png')

# display the result for 10 seconds

pygame.time.wait(10000)

Try adding an extra argument to optional ly disable writing to the log fi le.This wil l improve rendering time. Hint: as well as the argument you wil lneed to add two if statements as the log is written to in two differentplaces within the code.

Some other ideas for command line arguments:- let the user choose the fi lename for the output image- specify the background and line colours from a list of defaults(black, white,red, green, blue)- enter a demo mode that loops the code, rendering many shapes inrandom colours

The MagPi is a trademark of The MagPi Ltd. Raspberry Pi is a trademark of the Raspberry Pi Foundation. The MagPi magazine is

collaboratively produced by an independent group of Raspberry Pi owners, and is not affiliated in any way with the Raspberry Pi

Foundation. It is prohibited to commercially produce this magazine without authorization from The MagPi Ltd. Printing for non

commercial purposes is agreeable under the Creative Commons license below. The MagPi does not accept ownership or

responsibility for the content or opinions expressed in any of the articles included in this issue. All articles are checked and tested

before the release deadline is met but some faults may remain. The reader is responsible for all consequences, both to software and

hardware, following the implementation of any of the advice or code printed. The MagPi does not claim to own any copyright licenses

and all content of the articles are submitted with the responsibility lying with that of the article writer.

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of

this license, visit:

http://creativecommons.org/licenses/by-nc-sa/3.0/

Alternatively, send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041 , USA.

Feedback & Question Time

editor@themagpi.com

Q: Regarding the Skutter series,you mention a robot arm can bemounted. Could you pleasespecify which robot arm andwhere I can get it?

Richard

A: Skutter is a longterm series,with the first article published inissue 1 of The MagPi. Thiscontains some backgroundinformation: "The robotic arm kitcalled the OWI Edge is currentlyavailable from Maplin electronicsand it uses a simple USB interfaceto control it."http://www.maplin.co.uk/roboticarmkitwithusbpcinterface266257

Q: Is it going to be possible toview the mag on an iPad in thenear future or am I missing thepoint?

A: The Issuu site we use hasrecently started to supportHTML5, so it should now work oniPads and iPhones etc. You canalso download the PDF and view itwithin iBooks. We are currentlyworking with a developerregarding a Newsstand app.

Thank you for making a printededition of The MagPi availablefrom http://www.modmypi.com. Ialways print out each issuebecause I prefer to read frompaper rather than online. Imaginemy surprise to discover that thecost is only £2.49. It almost coststhat much for me to print out 32colour pages myself!

Q: As a new user of theRaspberry Pi I'm very interested inyour excellent magazine. I havehad no difficulty reading yourIssues 1 to 6 on my desktopcomputer that uses Linux Mint 13.Imagine my disappointment whenI found that, of the six issues, Ican only open Issue 3 on myRaspberry Pi. Not being familiarwith the MuPDF program thatRaspbian uses, I thought I'd bettercheck by installing and testingMuPDF on my Linux Mintmachine. The result is that everyMagPi issue opens without aproblem using MuPDF on myLinux machine. This is possiblynot your technical problem but Ithought you would want to knowthat a significant and growingnumber of Raspberry Pi ownerscannot read your magazine.

A: This problem extends to manyother PDF files. MuPDF seems towork fine for some users but notothers. Personally I have removedMuPDF and use xPDF instead,which works with everything. Youcan do this with the followingcommands:$ sudo apt-get remove MuPDF

$ sudo apt-get install xPDF

The MagPi Issue 7

Documents

Transcript of The MagPi Issue 7

The MagPi Issue 22 En

The MagPi Issue 17

The MagPi Issue 29

The Magpi-Issue 6

The MagPi Issue 12

The MagPi Issue 16 En

The MagPi 2015 02 Issue 30

The Raspberry Magazine Pi.The MagPi. Issue 18

The MagPi Issue 8

The MagPi Issue 22

The Magpi-Issue 4

The MagPi issue 7.pdf

MagPi 7 français

The MagPi 2014 12 Issue 29

The MagPi Issue 20 En

The MagPi Issue 19

The Raspberry Pi Magazine.The MagPi. Issue 17

The MagPi Issue 28 Nov 2014

The Magpi-Issue 5

The MagPi Issue 1 En