Arduino Programming Notebook

Arduino Programming Notebook  Written and compiled by Brian W. Evans

With information or inspiration taken from: http:www.arduino.cc http:www.wiring.org.co http:www.arduino.ccenBooklet!omePage http:cslibrary.stanford.edu"#"

  arduino  programming   notebook 

$ncluding material written by: Paul Badger  %assimo Ban&i !ernando Barrag'n (avid )uartielles *om $goe (aniel +olliffe *odd ,urt (avid %ellis and others

 brian w. evans

Published: -irst Edition August ##/ 0econd Edition 0eptember ##1

"c bao *his work is licensed under the )reative )ommons Attribution20hare Alike .3 4icense. *o view a copy of this license5 visit: http:creativecommons.orglicensesby2sa.3 6r send a letter to: )reative )ommons "/" 0econd 0treet5 0uite 7## 0an -rancisco5 )alifornia5 89"#35 0A

contents

structure structure

/

setup;<

/

loop;<

/

functions

1

=> curly braces

1

? semicolon

8

@ @ block comments

8

 line comments

8

variables variables

"#

variable declaration

"#

variable scope

""

datatypes  byte

"

int

"

long

"

float

"

arrays

"7

arithmetic arithmetic

"9

compound assignments

"9

comparison operators

"3

logical operators

"3

constants constants

"

truefalse

"

highlow

"

inputoutput

"

flow control if 

"/

if else

"1

for 

"8

while

#

do while

#

digital io  pin%ode;pin5 mode<

"

digitalCead;pin<



digitalWrite;pin5 value<



analog io analogCead;pin<

7

analogWrite;pin5 value<

7

delay;ms<

9

millis;<

9

min;D5 y<

9

maD;D5 y<

9

time

math

random random0eed;seed<

3

random;min5 maD<

3

0erial.begin;rate<



0erial.println;data<



serial

appendiD digital output

8

digital input

7#

high current output

7"

 pwm output

7

 potentiometer input

77

variable resistor input

79

servo output

73

 preface

*his notebook serves as a convenient5 easy to use programming reference for the command structure and basic syntaD of the Arduino microcontroller. *o keep it simple5 certain eDclusions were made that make this a beginners reference best used as a secondary source alongside other websites5 books5 workshops5 or classes. *his decision has lead to a slight emphasis on using the Arduino for standalone  purposes and5 for eDample5 eDcludes the more compleD uses of arrays or advanced forms of serial communication.

Beginning with the basic structure of ArduinoFs ) derived programming language5 this notebook continues on to describe the syntaD of the most common elements of the language and illustrates their usage with eDamples and code fragments. *his includes many functions of the core library followed by an appendiD with sample schematics and starter programs. *he overall format compliments 60ullivan and $goes Physical )omputing where possible. -or an introduction to the Arduino and interactive design5 refer to Ban&is Getting 0tarted with Arduino5 aka the Arduino Booklet. -or the brave few interested in the intricacies of programming in )5 ,ernighan a nd Citchies *he ) Programming 4anguage5 second edition5 as well as Prin& and )rawfords ) in a Nutshell5 provide some insight into the original programming syntaD. Above all else5 this notebook would not have been possible without the great community of makers and shear mass of original material to be found at the Arduino website5 playground5 and forum at http:www.arduino.cc.

structure *he basic structure of the Arduino programming language is fairly simple and runs in at least two parts. *hese two reHuired parts5 or functions5 enclose blocks of  statements. void setup;< =   statements? > void loop;< =   statements? > Where setup;< is the preparation5 loop;< is the eDecution. Both functions are reHuired for the program to work. *he setup function should follow the declaration of any variables at the very  beginning of the program. $t is the first function to run in the program5 is run only once5 and is used to set pin%ode or initiali&e serial communication. *he loop function follows neDt and includes the code to be eDecuted continuously I  reading inputs5 triggering outputs5 etc. *his function is the core of all Arduino  programs and does the bulk of the work.

setup;< *he setup;< function is called once when your program starts. se it to initiali&e pin modes5 or begin serial. $t must be included in a program even if there are no statements to run. void setup;< = pin%ode;pin5 6*P*

 sets the FpinF as output

loop;< After calling the setup;< function5 the loop;< function does precisely what its name suggests5 and loops consecutively5 allowing the program to change5 respond5 and control the Arduino board. void loop;< = digitalWrite;pin5 !$G!
   

turns FpinF on  pauses for one second turns FpinF off   pauses for one second

>

structure J /

functions A function is a block of code that has a name and a block of statements that are eDecuted when the function is called. *he functions void setup;< and void loop;< have already been discussed and other built2in functions will be discussed later. )ustom functions can be written to perform repetitive tasks and reduce clutter in a  program. -unctions are declared by first declaring the function type. *his is the type of value to be returned by the function such as FintF for an integer type function. $f no value is to be returned the function type would be void. After type5 declare the name given to the function and in parenthesis any parameters being passed to the function. type functionName;parameters< =   statements? > *he following integer type function delayKal;< is used to set a delay value in a  program by reading the value of a potentiometer. $t first declares a local variable v5 sets v to the value of the potentiometer which gives a number between #2"#75 then divides that value by 9 for a final value between #2335 and finally returns that value  back to the main program. int delayKal;< = int v? v L analogCead;pot

   

create temporary variable FvF read potentiometer value converts #2"#7 to #233 return final value

=> curly braces )urly braces ;also referred to as Must braces or curly brackets< define the  beginning and end of function blocks and statement blocks such as the void loop;< function and the for and if statements. type function;< =   statements? > An opening curly brace = must always be followed by a closing curly brace >. *his is often referred to as the braces being balanced. nbalanced braces can often lead to cryptic5 impenetrable compiler errors that can sometimes be hard to track down in a large program. *he Arduino environment includes a convenient feature to check the balance of curly  braces. +ust select a brace5 or even click the insertion point immediately following a  brace5 and its logical companion will be highlighted.

1 J structure

? semicolon A semicolon must be used to end a statement and s eparate elements of the program. A semicolon is also used to separate elements in a for loop. int D L "7?

 declares variable FDF as the integer "7

 Note: -orgetting to end a line in a semicolon will result in a compiler error. *he error  teDt may be obvious5 and refer to a missing semicolon5 or it may not. $f an impenetrable or seemingly illogical compiler error comes up5 one of the first things to check is a missing semicolon5 near the line where the compiler complained.

@ @ block comments Block comments5 or multi2line comments5 are areas of teDt ignored by the program and are used for large teDt descriptions of code or comments that help others understand parts of the program. *hey begin with @ and end with @ and can span multiple lines. @

this is an enclosed block comment dont forget the closing comment 2 they have to be balancedQ

@ Because comments are ignored by the program and take no memory space they should be used generously and can also be used to Ocomment out blocks of code for  debugging purposes.  Note: While it is possible to enclose single line comments within a block comment5 enclosing a second block comment is not allowed.

 line comments 0ingle line comments begin with  and end with the neDt line of code. 4ike block  comments5 they are ignored by the program and take no memory space.  this is a single line comment 0ingle line comments are often used after a valid statement to provide more information about what the statement accomplishes or to provide a future reminder.

structure J 8

variables A variable is a way of naming and storing a numerical value for later use by the  program. As their namesake suggests5 variables are numbers that can be continually changed as opposed to constants whose value never changes. A variable needs to  be declared and optionally assigned to the value needing to be stored. *he following code declares a variable called inputKariable and then assigns it the value obtained on analog input pin : int inputKariable L #?  inputKariable L analogCead;
declares a variable and assigns value of # set variable to value of  analog pin 

RinputKariable is the variable itself. *he first line declares that it will contain an int5 short for integer. *he second line sets the variable to the value at analog pin . *his makes the value of pin  accessible elsewhere in the code. 6nce a variable has been assigned5 or re2assigned5 you can test its value to see if it meets certain conditions5 or you can use its value directly. As an eDample to illustrate three useful operations with variables5 the following code tests whether the inputKariable is less than "##5 if true it ass igns the value "## to inputKariable5 and then sets a delay based on inputKariable which is now a minimum of "##: if ;inputKariable S "##<  tests variable if less t han "## = inputKariable L "##? if true assigns value of "## > delay;inputKariable
variable declaration All variables have to be declared before they can be used. (eclaring a variable means defining its value type5 as in int5 long5 float5 etc.5 s etting a specified name5 and optionally assigning an initial value. *his only needs to be done once in a program but the value can be changed at any time using arithmetic and various assignments. *he following eDample declares that inputKariable is an int5 or integer type5 and that its initial value eHuals &ero. *his is call ed a simple assignment. int inputKariable L #? A variable can be declared in a number of locations throughout the program and where this definition takes place determines what parts of the program can use the variable.

"# J variables

variable scope A variable can be declared at the beginning of the program before void setup;<5 locally inside of functions5 and sometimes within a statement block such as for loops. Where the variable is declared determines the variable scope5 or the ability of certain  parts of a program to make use of the variable. A global variable is one that can be seen and used b y every function and statement in a program. *his variable is declared at the beginning of the program5 before the setup;< function. A local variable is one that is defined inside a function or as part of a for loop. $t is only visible and can only be used inside the function in which it was declared. $t is therefore possible to have two or more variables of the same name in different parts of the same program that contain different values. Ensuring that only one function has access to its variables simplifies the program and reduces the potential for   programming errors. *he following eDample shows how to declare a few different types of variables and demonstrates each variables visibility: int value?

 FvalueF is visible  to any function

void setup;< =  no setup needed > void loop;< = for ;int iL#? iS#?< =   iTT? > float f? >

 FiF is only visible  inside the for2loop

 FfF is only visible  inside loop

variables J ""

 byte Byte stores an 12bit numerical value without decimal points. *hey have a range of #2 33.  byte someKariable L "1#?

 declares FsomeKariableF  as a byte type

int $ntegers are the primary datatype for storage of numbers without decimal points and store a "2bit value with a range of 75// to 275/1. int someKariable L "3##?

 declares FsomeKariableF  as an integer type

 Note: $nteger variables will roll over if forced past their maDimum or minimum values  by an assignment or comparison. -or eDample5 if D L 7// and a subseHuent statement adds " to D5 D L D T " or DTT5 D will then rollover and eHual 275/1.

long EDtended si&e datatype for long integers5 without decimal points5 stored in a 72bit value with a range of 5"9/591759/ to 25"9/5917591. long someKariable L 8####?  declares FsomeKariableF  as a long type

float A datatype for floating2point numbers5 or numbers that have a decimal point. -loating2  point numbers have greater resolution than integers and are stored as a 72bit value with a range of 7.9#173ET71 to 27.9#173ET71. float someKariable L 7."9?  declares FsomeKariableF  as a floating2point type  Note: -loating2point numbers are not eDact5 and may yield strange results when compared. -loating point math is also much slower than integer math in performing calculations5 so should be avoided if possible.

" J datatypes

arrays An array is a collection of values that are accessed wi th an indeD number. Any value in the array may be called upon by calling the name of the array and the indeD number of the value. Arrays are &ero indeDed5 with the first value in the array  beginning at indeD number #. An array needs to be declared and optionally assigned values before they can be used. int myArrayUV L =value#5 value"5 value...> 4ikewise it is possible to declare an array by declaring the array type and si&e and later assign values to an indeD position: int myArrayU3V? myArrayU7V L "#?

 declares integer array w  positions  assigns the 9th indeD the value "#

*o retrieve a value from an array5 assign a variable to the array and indeD position: D L myArrayU7V?

 D now eHuals "#

Arrays are often used in for loops5 where the increment counter is also used as the indeD position for each array value. *he following eDample uses an array to flicker an 4E(. sing a for loop5 the counter begins at #5 writes the value contained at indeD  position # in the array flickerUV5 in this case "1#5 to the PW% pin "#5 pauses for  ##ms5 then moves to the neDt indeD position. int ledPin L "#? 4E( on pin "#  byte flickerUV L ="1#5 7#5 335 ##5 "#5 8#5 "3#5 #>?  above array of 1 void setup;< different values = pin%ode;ledPin5 6*P*

void loop;< = for;int iL#? iS/? iTT< = analogWrite;ledPin5 flickerUiV >

   

loop eHuals number  of values in array write indeD value  pause ##ms

datatypes J "7

arithmetic Arithmetic operators include addition5 subtraction5 multiplication5 and division. *hey return the sum5 difference5 product5 or Huotient ;respectively< of two operands. y D i r 

L L L L

y D  M r 

T 2 @ 

7? /? ? 3?

*he operation is conducted using the data type of the operands5 so5 for eDample5 8  9 results in  instead of .3 since 8 and 9 are ints and are incapable of using decimal  points. *his also means that the operation can overflow if the result is larger than what can be stored in the data type. $f the operands are of different types5 the larger type is used for the calculation. -or  eDample5 if one of the numbers ;operands< are of the type float and the other of type integer5 floating point math will be used for the calculation. )hoose variable si&es that are large enough to hold the largest results from your  calculations. ,now at what point your variable will rollover and also what happens in the other direction e.g. ;# 2 "< 6C ;# 2 2 7/1<. -or math that reHuires fractions5 use float variables5 but be aware of their drawbacks: large si&e and slow computation speeds.  Note: se the cast operator e.g. ;int
compound assignments )ompound assignments combine an arithmetic operation with a variable assignment. *hese are commonly found in for loops as described later. *he most common compound assignments include: D D D D D D

TT 22 TL 2L @L L

y y y y

 same as D L D T "5 or increments D by T"   same as D L D 2 "5 or decrements D by 2"  same as D L D T y5 or increments D by Ty  same as D L D 2 y5 or decrements D by 2y  same as D L D @ y5 or multiplies D by y  same as D L D  y5 or divides D by y

 Note: -or eDample5 D @L 7 would triple the old value of D and re2assign the resulting value to D.

"9 J arithmetic

comparison operators )omparisons of one variable or constant against another are often used in if  statements to test if a specified condition is true. $n the eDamples found on the following pages5  is used to indicate any of the following conditions: D D D D D D

LL QL S X SL XL

y y y y y y

     

D D D D D D

is is is is is is

eHual to y not eHual to less than y greater than less than or  greater than

y y eHual to y or eHual to y

logical operators 4ogical operators are usually a way to compare two eDpressions and return a *CE or -A40E depending on the operator. *here are three logical operators5 AN(5 6C5 and N6*5 that are often used in if statements: 4ogical AN(: if ;D X # YY D S 3<

4ogical 6C: if ;D X # JJ y X #<

4ogical N6*: if ;QD X #<

 true only if both  eDpressions are true

 true if either   eDpression is true

 true only if   eDpression is false

arithmetic J "3

constants *he Arduino language has a few predefined values5 which are called constants. *hey are used to make the programs easier to read. )onstants are classified in groups.

truefalse *hese are Boolean constants that define logic levels. -A40E is easily defined as # ;&ero< while *CE is often defined as "5 but can also be an ything else eDcept &ero. 0o in a Boolean sense5 2"5 5 and 2## are all also defined as * CE. if ;b LL *CE

highlow *hese constants define pin levels as !$G! or 46W and are used when reading or  writing to digital pins. !$G! is defined as l ogic level "5 6N5 or 3 volts while 46W is logic level #5 6--5 or # volts. digitalWrite;"75 !$G!
inputoutput )onstants used with the pin%ode;< function to define the mode of a digital pin as either $NP* or 6*P*.  pin%ode;"75 6*P*
" J constants

if  if statements test whether a certain condition has been reached5 such as an analog value being above a certain number5 and eDecutes any statements inside the  brackets if the statement is true. $f false the program skips over the statement. *he format for an if test is: if ;someKariable  value< =   do0omething? > *he above eDample compares someKariable to another value5 which can be either a variable or constant. $f the comparison5 or condition in parentheses is true5 the statements inside the brackets are run. $f not5 the program skips over them and continues on after the brackets.  Note: Beware of accidentally using RL5 as in if;DL"#<5 while technically valid5 defines the variable D to the value of "# and is as a result always true. $nstead use RLL5 as in if;DLL"#<5 which only tests whether D happens to eHual the value "# or  not. *hink of RL as OeHuals opposed to RLL being Ois eHual to.

flow control J "/

if else if else allows for Reither2or decisions to be made. -or eDample5 if you wanted to test a digital input5 and do one thing if the input went !$G! or i nstead do another thing if  the input was 46W5 you would write that this way: if ;inputPin LL !$G!< =   do*hingA? > else =   do*hingB? >

else can also precede another if test5 so that multiple5 mutually eDclusive tests can be run at the same time. $t is even possible to have an unlimited number of these else  branches. Cemember though5 only one set of statements will be run depending on the condition tests: if ;inputPin S 3##< =   do*hingA? > else if ;inputPin XL "###< =   do*hingB? > else =   do*hing)? >

 Note: An if statement simply tests whether the condition inside the parenthesis is true or false. *his statement can be any valid ) statement as in the first eDample5 if  ;inputPin LL !$G!<. $n this eDample5 the if statement only checks to see if  indeed the specified input is at logic level high5 or T3v.

"1 J flow control

for  *he for statement is used to repeat a block of statements enclosed in curly braces a specified number of times. An increment counter is often used to increment and terminate the loop. *here are three parts5 separated by semicolons ;?<5 to the for loop header: for ;initiali&ation? condition? eDpression< =   do0omething? > *he initiali&ation of a local variable5 or increment counter5 happens first and only once. Each time through the loop5 the following condition is tested. $f the condition remains true5 the following statements and eDpression are eDecuted and the condition is tested again. When the condition becomes false5 the loop ends. *he following eDample starts the integer i at #5 tests to see if i is still less than # and if true5 increments i by " and eDecutes the enclosed statements: for ;int iL#? iS#? iTT< = digitalWrite;"75 !$G!

     

declares i5 tests if less than #5 increments i by " turns pin "7 on  pauses for "9 second turns pin "7 off   pauses for "9 second

 Note: *he ) for loop is much more fleDible than for loops found in some other  computer languages5 including BA0$). Any or all of the three header elements may  be omitted5 although the semicolons are reHuired. Also the statements for  initiali&ation5 condition5 and eDpression can be any valid ) statements with unrelated variables. *hese types of unusual for statements may provide solutions to some rare  programming problems.

flow control J "8

while while loops will loop continuously5 and infinitely5 until the eDpression inside the  parenthesis becomes false. 0omething must change the tested variable5 or the while loop will never eDit. *his could be in your code5 such as an incremented variable5 or  an eDternal condition5 such as testing a sensor. while ;someKariable  value< =   do0omething? > *he following eDample tests whether RsomeKariable is less than ## and if true eDecutes the statements inside the brackets and will continue looping until RsomeKariable is no longer less than ##. while ;someKariable S ##<  tests if less than ## = do0omething? eDecutes enclosed statements someKariableTT? increments variable by " >

do while *he do loop is a bottom driven loop that works in the same manner as the while loop5 with the eDception that the condition is tested at the end of the loop5 so the do loop will always run at least once. do =   do0omething? > while ;someKariable  value while ;D S "##
# J flow control

 assigns the value of   read0ensors;< to D   pauses 3# milliseconds  loops if D is less than "##

 pin%ode;pin5 mode< sed in void setup;< to configure a specified pin to behave either as an $NP* or  an 6*P*.  pin%ode;pin5 6*P*
 sets Rpin to output

Arduino digital pins default to inputs5 so they donFt need to be eDplicitly declared as inputs with pin%ode;<. Pins configured as $NP* are said to be in a high2impedance state. *here are also convenient #,Z pullup resistors built into the Atmega chip that can  be accessed from software. *hese built2in pullup resistors are accessed in the following manner:  pin%ode;pin5 $NP*
 set Rpin to input  turn on pullup resistors

Pullup resistors would normally be used for connecting inputs like switches. Notice in the above eDample it does not convert pin to an output5 it is merely a method for  activating the internal pull2ups. Pins configured as 6*P* are said to be in a low2impedance state and can provide 9# mA ;milliamps< of current to other devicescircuits. *his is enough current to  brightly light up an 4E( ;donFt forget the series resistor<5 but not enough current to run most relays5 solenoids5 or motors. 0hort circuits on Arduino pins and eDcessive current can damage or destroy the output pin5 or damage the entire Atmega chip. $t is often a good idea to connect an 6*P* pin to an eDternal device in series with a 9/#Z or ",Z resistor.

digital io J "

digitalCead;pin< Ceads the value from a specified digital pin with the result either !$G! or 46W. *he  pin can be specified as either a variable or constant ;#2"7<. value L digitalCead;Pin
 sets FvalueF eHual to  the input pin

digitalWrite;pin5 value< 6utputs either logic level !$G! or 46W at ;turns on or off< a specified digital pin. *he  pin can be specified as either a variable or constant ;#2"7<. digitalWrite;pin5 !$G!
 sets FpinF to high

*he following eDample reads a pushbutton connected to a digital input and turns on an 4E( connected to a digital output when the button has been pressed: int ledL "7? int pinL /? int value L #? void setup;< = pin%ode;led5 6*P* void loop;< = value L digitalCead;pin

 J digital io

 connect 4E( to pin "7  connect pushbutton to pin /  variable to store the read value

 sets pin "7 as output  sets pin / as input

   

sets FvalueF eHual to the input pin sets FledF to the  buttonFs value

analogCead;pin< Ceads the value from a specified analog pin with a "#2bit resolution. *his function only works on the analog in pins ;#23<. *he resulting integer values range from # to "#7. value L analogCead;pin
 sets FvalueF eHual to FpinF

 Note: Analog pins unlike digital ones5 do not need to be first declared as $NP* nor  6*P*.

analogWrite;pin5 value< Writes a pseudo2analog value using hardware enabled pulse width modulation ;PW%< to an output pin marked PW%. 6n newer Arduinos with the A*mega"1 chip5 this function works on pins 75 35 5 85 "#5 and "". 6lder Arduinos with an A*mega1 only support pins 85 "#5 and "". *he value can be specified as a variable or constant with a value from #233. analogWrite;pin5 value
 writes FvalueF to analog FpinF

A value of # generates a steady # volts output at the specified pin? a value of 33 generates a steady 3 volts output at the specified pin. -or values in between # and 335 the pin rapidly alternates between # and 3 volts 2 the higher the value5 the more often the pin is !$G! ;3 volts<. -or eDample5 a value of 9 will be # volts three2 Huarters of the time5 and 3 volts one Huarter of the time? a value of "1 wil l be at # half the time and 33 half the time? and a value of "8 will be # volts one Huarter of  the time and 3 volts three2Huarters of the time.

Because this is a hardware function5 the pin will generate a steady wave after a call to analogWrite in the background until the neDt call to analogWrite ;or a call to digitalCead or digitalWrite on the same pin<.  Note: Analog pins unlike digital ones5 do not need to be first declared as $NP* nor  6*P*. *he following eDample reads an analog value from an analog input pin5 converts the value by dividing by 95 and outputs a PW% signal on a PW% pin: int led L "#? int pin L #? int value?

 4E( with # resistor on pin "#  potentiometer on analog pin #  value for reading

void setup;<=>

 no setup needed

void loop;< = value L analogCead;pin

 sets FvalueF eHual to FpinF  converts #2"#7 to #233  outputs PW% signal to led

analog io J 7

delay;ms< Pauses a program for the amount of time as specified in milliseconds5 where "### eHuals " second. delay;"###
 waits for one second

millis;< Ceturns the number of milliseconds since the Arduino board began running the current program as an unsigned long value. value L millis;
 sets Rvalue eHual to millis;<

 Note: *his number will overflow ;reset back to &ero<5 after approDimately 8 hours.

min;D5 y< )alculates the minimum of two numbers of any data type and returns the smaller  number. value L min;value5 "##
maD;D5 y< )alculates the maDimum of two numbers of any data type and returns the larger  number. value L maD;value5 "##
9 J time and math

random0eed;seed< 0ets a value5 or seed5 as the starting point for the random;< function. random0eed;value
 sets Rvalue as the random seed

Because the Arduino is unable to create a truly random number5 random0eed allows you to place a variable5 constant5 or other function into the random function5 which helps to generate more random random numbers. *here are a variety of different seeds5 or functions5 that can be used in this function including millis;< or even analogCead;< to read electrical noise t hrough an analog pin.

random;maD< random;min5 maD< *he random function allows you to return pseudo2random numbers within a range specified by min and maD values. value L random;"##5 ##
 sets FvalueF to a random  number between "##2##

 Note: se this after using the random0eed;< function. *he following eDample creates a random value between #233 and outputs a PW% signal on a PW% pin eHual to the random value: int randNumber? int led L "#?

 variable to store the random value  4E( with # resistor on pin "#

void setup;< =>

 no setup needed

void loop;< =   random0eed;millis;<

   

sets millis;< as seed random number from #233 outputs PW% signal  pauses for half a second

random J 3

0erial.begin;rate< 6pens serial port and sets the baud rate for serial data transmission. *he typical  baud rate for communicating with the computer is 8## although other speeds are supported. void setup;< =   0erial.begin;8##

 opens serial port  sets data rate to 8## bps

 Note: When using serial communication5 digital pins # ;C[< and " ;*[< cannot be used at the same time.

0erial.println;data< Prints data to the serial port5 followed by an automatic carriage return and line feed. *his command takes the same form as 0erial.print;<5 but is easier for reading data on the 0erial %onitor. 0erial.println;analogKalue
 sends the value of    FanalogKalueF

 Note: -or more information on the various permutations of the 0erial.println;< and 0erial.print;< functions please refer to the Arduino website. *he following simple eDample takes a reading from analog pin# and sends this data to the computer every " second. void setup;< =   0erial.begin;8## void loop;< = 0erial.println;analogCead;#<

 J serial

 sets serial to 8##bps

appendiD

digital output

*his is the basic Rhello world program used to si mply turn something on or off. $n this eDample5 an 4E( is connected to pin"75 and is blinked every second. *he resistor  may be omitted on this pin since the Arduino has one built i n.

int ledPin L "7?

 4E( on digital pin "7

void setup;< = pin%ode;ledPin5 6*P*

 run once

void loop;< = digitalWrite;ledPin5 !$G!

 run over and over again

 sets pin "7 as output

   

turns the 4E( on  pauses for " second turns the 4E( off   pauses for " second

appendiD J 8

digital input

*his is the simplest form of input with only two possible states: on or off. *his eDample reads a simple switch or pushbutton connected to pin. When the switch is closed the input pin will read !$G! and turn on an 4E(.

int ledPin L "7? int inPin L ? void setup;< = pin%ode;ledPin5 6*P* void loop;< = if ;digitalCead;inPin< LL !$G!< = digitalWrite;ledPin5 !$G! >

7# J appendiD

 output pin for the 4E(  input pin ;for a switch<

 declare 4E( as output  declare switch as input

 check if input is !$G!    

turns  pause turns  pause

the for  the for 

4E( on " second 4E( off  " second

high current output

0ometimes it is necessary to control more than 9#ma from the Arduino. $n this case a %60-E* or transistor could be used to switch higher current loads. *he following eDample Huickly turns on and off the %60-E* 3 times every second.  Note: *he schematic shows a motor and protection diode but other non2inductive loads could be used without the diode.

int outPin

L

3?

void setup;< = pin%ode;outPin5 6*P* void loop;< = for ;int iL#? iSL3? iTT< = digitalWrite;outPin5 !$G!   delay;"###

 output pin for the %60-E*

 sets pin3 as output

 loops 3 times    

turns %60-E* on  pauses "9 second turns %60-E* off   pauses "9 second

 pauses " second

appendiD J 7"

 pwm output

Pulsewidth %odulation ;PW%< is a way to fake an analog output by pulsing the output. *his could be used to dim and brighten an 4E( or later to control a s ervo motor. *he following eDample slowly brightens and dims an 4E( using for loops.

int ledPin

L

void setup;<=> void loop;< = for ;int iL#? iSL33? =   analogWrite;ledPin5   delay;"## for ;int iL33? iXL#? =   analogWrite;ledPin5   delay;"## >

7 J appendiD

8?

 PW% pin for the 4E(  no setup needed

iTT<

 ascending value for i

i
 sets brightess level to i  pauses for "##ms

i22<

 descending value for i

i
 sets brightess level to i  pauses for "##ms

 potentiometer input

sing a potentiometer and one of the Arduinos analog2to2digital conversion ;A()<  pins it is possible to read analog values from #2"#9. *he following eDample uses a  potentiometer to control an 4E(s rate of blinking.

int potPin L #? int ledPin L "7? void setup;< = pin%ode;ledPin5 6*P* void loop;< = digitalWrite;ledPin5 !$G!

 input pin for the potentiometer   output pin for the 4E(

 declare ledPin as 6*P*

   

turns  pause turns  pause

ledPin on  program ledPin off   program

appendiD J 77

variable resistor input

Kariable resistors include )d0 light sensors5 thermistors5 fleD sensors5 and so on. *his eDample makes use of a function to read the analog value and set a delay time. *his controls the speed at which an 4E( brightens and dims.

int ledPinL int analogPin L

8? #?

void setup;<=> void loop;< = for ;int iL#? iSL33? =   analogWrite;ledPin5   delay;delayKal;< for ;int iL33? iXL#? =   analogWrite;ledPin5   delay;delayKal;< >

int delayKal;< = int v? v L analogCead;analogPin

79 J appendiD

 PW% pin for the 4E(  variable resistor on analog pin #  no setup needed

iTT<

 ascending value for i

i
 sets brightess level to i  gets time value and pauses

i22<

 descending value for i

i
 sets brightess level to i  gets time value and pauses

   

create temporary variable read analog value convert #2"#9 to #2"1 returns final value

servo output

!obby servos are a type of self2contained motor that can move in a "1#\ arc. All t hat is needed is a pulse sent every #ms. *his eDample uses a servoPulse function to move the servo from "#\ 2"/#\ and back again.

int servoPin L ? int myAngle? int pulseWidth? void setup;< = pin%ode;servoPin5 6*P*

 servo connected to digital pin   angle of the servo roughly #2"1#  servoPulse function variable

 sets pin  as output

void servoPulse;int servoPin5 int myAngle< = pulseWidth L ;myAngle @ "#< T ##?  determines delay digitalWrite;servoPin5 !$G!

void loop;< =  servo starts at "# deg and rotates to "/# deg for ;myAngleL"#? myAngleSL"/#? myAngleTT< = servoPulse;servoPin5 myAngle  servo starts at "/# deg and rotates to "# deg for ;myAngleL"/#? myAngleXL"#? myAngle22< = servoPulse;servoPin5 myAngle >

appendiD J 73