Plumbing for the Arduino - Concurrency.cc

93 Pages·2011·12.9 MB·English

Plumbing for
the Arduino
MatthewC.Jadud
ChristianL.Jacobsen
AdamT.Sampson
Revision2011-01-24
2
Contents
1 Getting Started 11
1.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 InstallingtheDrivers—orNot . . . . . . . . . . 11
1.2.1 YouhaveanoldArduino . . . . . . . . 12
1.2.2 Youuseanadapter . . . . . . . . . . . . 13
1.2.3 YouhaveanewArduino . . . . . . . . 14
1.3 TestingJEdit . . . . . . . . . . . . . . . . . . . . 14
1.3.1 UploadtheFirmware . . . . . . . . . . 15
2 One Blinkenlight 18
2.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2 Code . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.1 OpenJEdit . . . . . . . . . . . . . . . . . 19
2.2.2 WriteyourProgram . . . . . . . . . . . 20
2.2.3 BuildYourCode . . . . . . . . . . . . . 21
2.3 Patterns . . . . . . . . . . . . . . . . . . . . . . . 22
2.3.1 ThePROCedureDefinition . . . . . . . . 22
2.3.2 APROCedureCall . . . . . . . . . . . . 24
2.4 Breakage . . . . . . . . . . . . . . . . . . . . . . 25
2.4.1 ProgrammingStrategies . . . . . . . . . 28
2.5 OtherResources . . . . . . . . . . . . . . . . . . 29
3
Contents
3 Speedy Blinkenlight 30
3.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2 BuildingtheCircuit . . . . . . . . . . . . . . . . 30
3.2.1 TheBreadboard . . . . . . . . . . . . . . 33
3.2.2 TheArduino . . . . . . . . . . . . . . . . 33
3.2.3 TheResistor . . . . . . . . . . . . . . . . 34
3.2.4 TheLED . . . . . . . . . . . . . . . . . . 35
3.2.5 Completingthecircuit . . . . . . . . . . 36
3.3 Code . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Patterns . . . . . . . . . . . . . . . . . . . . . . . 37
3.5 ExperimentingwithChanges . . . . . . . . . . 39
3.6 Breakage . . . . . . . . . . . . . . . . . . . . . . 39
3.6.1 Breakyourcircuit . . . . . . . . . . . . . 39
3.6.2 Breakyourprogram . . . . . . . . . . . 40
4 Two Blinkenlights 42
4.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 42
4.2 Buildthecircuit . . . . . . . . . . . . . . . . . . 42
4.3 Code . . . . . . . . . . . . . . . . . . . . . . . . 44
4.4 ThePARpattern . . . . . . . . . . . . . . . . . . 44
4.4.1 ThetruthaboutPAR . . . . . . . . . . . 45
4.4.2 Explorations . . . . . . . . . . . . . . . . 47
4.5 Breakage . . . . . . . . . . . . . . . . . . . . . . 48
5 Push the Button 51
5.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 51
5.2 TheCircuit . . . . . . . . . . . . . . . . . . . . . 51
5.3 PicturesandCode . . . . . . . . . . . . . . . . . 54
5.3.1 Frompicturestocode . . . . . . . . . . 55
5.3.2 Insummary . . . . . . . . . . . . . . . . 58
5.4 Breakage . . . . . . . . . . . . . . . . . . . . . . 59
4
Contents
6 Tick... tick... tick... 60
6.1 Seeingtheparts . . . . . . . . . . . . . . . . . . 60
6.2 Exploring“plug-n-play” . . . . . . . . . . . . . 63
7 Undressing Toggle 64
7.1 TheCircuit . . . . . . . . . . . . . . . . . . . . . 64
7.2 TheNetwork . . . . . . . . . . . . . . . . . . . . 65
7.3 Breakingupishardtodo . . . . . . . . . . . . 65
7.3.1 Frompicturestocode . . . . . . . . . . 66
7.4 Whatdoestoggledo? . . . . . . . . . . . . . . 68
7.5 Pattern: APipeline . . . . . . . . . . . . . . . . 70
7.6 ExplorationsandBreakage . . . . . . . . . . . . 72
8 Buttons Everywhere 74
8.1 TheChallenge . . . . . . . . . . . . . . . . . . . 74
8.2 TheCircuit . . . . . . . . . . . . . . . . . . . . . 75
8.3 ReusingProcedures . . . . . . . . . . . . . . . . 76
8.4 Managingcomplexity. . . . . . . . . . . . . . . 78
8.5 TheCode . . . . . . . . . . . . . . . . . . . . . . 80
8.6 Breakage . . . . . . . . . . . . . . . . . . . . . . 80
9 Making things Move: Servos 82
9.1 Goals . . . . . . . . . . . . . . . . . . . . . . . . 82
9.2 BuildingtheCircuit . . . . . . . . . . . . . . . . 83
9.3 Code . . . . . . . . . . . . . . . . . . . . . . . . 84
10 Acknowledgements 89
10.1 Software . . . . . . . . . . . . . . . . . . . . . . 89
10.1.1 occam-π andPlumbing . . . . . . . . . 90
10.2 Images . . . . . . . . . . . . . . . . . . . . . . . 91
5
Contents
11 Book Bugs 93
6
Preface
Embeddedprogramminghasalwaysbeenaboutdealingwith
therealworldinatimelymanner.
Whenyoupushabuttononyourmicrowave,itbeepsand
updates the display immediately. It doesn’t matter if the mi-
crowave is currently making popcorn or not—it responds in
near real-time to your touch. If you’ve ever tried to achieve
this with your Arduino (or other embedded controller), you
discovered that it is very difficult to make your embedded
projectdotwothingsatonce—likecontrollingamotorwhile
waitingforabuttontobepressed. Youeitherfoundyourself
writinglarge,complexloopsthatconstantlycheckeverything
aboutyoursystem,oryoufoundyourselfreadingabout“in-
terruptvectors,”andwonderedifyoushouldhavepaidmore
attentioninyourhighschoolphysicsclass.
Plumbing,andthelanguageitiswrittenin(occam-π),makes
theseproblemsgoaway.
7
Contents
Parallelism Yesterday
occam is an old programming
language; it was developed in the
early 1980’s for use on the Trans-
puter, a specialized processor de-
velopedbytheBritishcompanyin-
mos. This processor was special
because it was able to switch be-
tween many thousands of paral-
lel processes very, very quickly. It
also had four special “links” that TheT414.
allowedittobeconnectedtoother
Transputers,instantaneouslycreatingadistributedclusterof
processors. occam made it possible, in just a few lines of
code, to write programs thatwould run across many proces-
sorsinparallel,takingadvantageofthesenetworkedclusters
ofTransputers.
In 2010, this may not seem impressive: for example, ev-
ery computer shipped by Apple Computer has at least two
cores, as is the case with many computer manufacturers to-
day. However, we are talking about parallel processors de-
signedandmanufacturednearly30yearsago. Andthelan-
guage, occam, has evolved—it is now called occam-π, and
wehaveworkedhardtomakesureitrunsoneverythingfrom
yourArduinotoyourdesktopcomputer,regardlessoftheop-
eratingsystem(Linux,Mac,Windows)youchoosetouse.
8
Contents
Parallelism Today
Thinkingabouthandlingthings“inparallel”meanshandling
them “at the same time.” With only one processor, you can
only pretend to handle two things at once—we call this con-
currency. If you want to control a motor while waiting for a
buttontobepressed,ortocontrol64LEDs“atthesametime,”
youcoulddoitwithaloop. Theloopwouldgetcomplex,and
you’d be responsible for managing all of the concurrency in
yourcode.
Or, you could use occam-π. And on the Arduino, you
coulduseourlibraryofcode,calledPlumbing,tomakethese
tasks much easier. For example, take a look at the code from
Chapter4:TwoBlinkenlights.
PAR
1
blink (11, 500)
2
blink (12, 500)
3
With the right circuit, this code would tell our Arduino to
blink two LEDs in PARallel, one on pin 11, and one on pin
12. TheblinkcommandcomesfromthePlumbinglibraryof
code, and the PAR comes from occam-π. Combined, the lan-
guage and the library of code make it easy to express ideas
about problems that involve two things happening “at the
sametime,”or(asweprefertosay),concurrently.
Weassumethatyou, thereader, havelittleornoprogram-
ming experience, but are excited to explore our tools with
yourtrustyArduinoinhand. Please—enjoy.
9
Contents
The Commons
This text, as well as all of the tools you need to explore it,
are free and open. Our text is made available under a Cre-
ative Commons license, our software under the LGPL, and
wehavechosentheArduino(anditsmanyvariants)because
oftheopennatureofthatcommunityaswell. Weencourage
you to begin exploring parallel programming using Plumb-
ing,occam-π,andyourArduino.
http://creativecommons.org/licenses/by-sa/3.0/us/
Ifyou’reapublisher,andareinterestedinworkingwithus
toproduceaprinteditionofthistext,pleasedropanemailto
matt at concurrency dot cc.
Bugs
Ifyoufinderrorsinthetext,pleasepassthemontobookbugs
at concurrency dot cc.
10