CHAPTER 5

Simple Digital and Analog Input

5.0 Introduction
7KH$UGXLQRVDELOLW\WRVHQVHGLJLWDODQGDQDORJLQSXWVDOORZVLWWRUHVSRQGWR\RXDQG
WRWKHZRUOGDURXQG\RX7KLVFKDSWHULQWURGXFHVWHFKQLTXHV\RXFDQXVHWRGRXVHIXO
WKLQJVZLWKWKHVHLQSXWV7KLVLVWKHILUVWRIPDQ\FKDSWHUVWRFRPHWKDWFRYHUHOHFWULFDO
FRQQHFWLRQVWR$UGXLQR,I\RXGRQWKDYHDQHOHFWURQLFVEDFNJURXQG\RXPD\ZDQW
WRORRNWKURXJK$SSHQGL[$RQHOHFWURQLFFRPSRQHQWV$SSHQGL[%RQVFKHPDWLFGL
DJUDPVDQGGDWDVKHHWV$SSHQGL[&RQEXLOGLQJDQGFRQQHFWLQJFLUFXLWVDQG$SSHQ
GL[(RQKDUGZDUHWURXEOHVKRRWLQJ,QDGGLWLRQPDQ\JRRGLQWURGXFWRU\WXWRULDOVDUH
DYDLODEOHFRYHULQJHOHFWURQLFV7ZRWKDWDUHSDUWLFXODUO\UHOHYDQWWR$UGXLQRDUH*HWWLQJ
6WDUWHGZLWK$UGXLQRE\0DVVLPR%DQ]L25HLOO\DQG0DNLQJ7KLQJV7DONE\7RP
,JRH25HLOO\2WKHUERRNVRIIHULQJDEDFNJURXQGRQHOHFWURQLFVWRSLFVFRYHUHGLQ
WKLVDQGWKHIROORZLQJFKDSWHUVLQFOXGH*HWWLQJ6WDUWHGLQ(OHFWURQLFVE\)RUUHVW0LPV
0DVWHU3XEOLVKLQJDQG3K\VLFDO&RPSXWLQJE\7RP,JRH&HQJDJH

,IZLULQJFRPSRQHQWVWR\RXU$UGXLQRLVQHZWR\RXEHFDUHIXODERXW
KRZ\RXFRQQHFWDQGSRZHUWKHWKLQJV\RXDWWDFK$UGXLQRXVHVDUR
EXVWFRQWUROOHUFKLSWKDWFDQWDNHDIDLUDPRXQWRIDEXVHEXW\RXFDQ
GDPDJHWKHFKLSLI\RXFRQQHFWWKHZURQJYROWDJHVRUVKRUWFLUFXLWDQ
RXWSXWSLQ0RVW$UGXLQRFRQWUROOHUFKLSVDUHSRZHUHGE\YROWVDQG
\RX PXVW QRW FRQQHFW H[WHUQDO SRZHU WR $UGXLQR SLQV ZLWK D KLJKHU
YROWDJHWKDQWKLVRUYROWVLI\RXU$UGXLQRFRQWUROOHUUXQVRQWKLV
YROWDJH
$UGXLQR ERDUGV WKDW DUH DLPHG DW EHJLQQHUV KDYH WKH PDLQ FKLS LQ D
VRFNHWWKDWFDQEHUHPRYHGDQGUHSODFHGVR\RXGRQWQHHGWRUHSODFH
WKHZKROHERDUGLI\RXGDPDJHWKHFKLS

)LJXUHVKRZVWKHDUUDQJHPHQWRISLQVRQDVWDQGDUG$UGXLQRERDUG6HHKWWSZZZ
DUGXLQRFFHQ0DLQ+DUGZDUHIRUDOLVWRIDOOWKHRIILFLDOERDUGVDORQJZLWKOLQNVWR
FRQQHFWLRQLQIRUPDWLRQIRUHDFK,I\RXUERDUGLVQRWRQWKDWOLVWFKHFN\RXUERDUG
VXSSOLHUVZHEVLWHIRUFRQQHFWLRQLQIRUPDWLRQ

133
)LJXUH6WDQGDUG$UGXLQRERDUG
7KLVFKDSWHUFRYHUVWKH$UGXLQRSLQVWKDWFDQVHQVHGLJLWDODQGDQDORJLQSXWV'LJLWDO
LQSXWSLQVVHQVHWKHSUHVHQFHDQGDEVHQFHRIYROWDJHRQDSLQ$QDORJLQSXWSLQVPHDV
XUHDUDQJHRIYROWDJHVRQDSLQ
7KH$UGXLQRIXQFWLRQWRGHWHFWGLJLWDOLQSXWLVdigitalReadDQGLWWHOOV\RXUVNHWFKLID
YROWDJHRQDSLQLVHIGHYROWVRULOWYROWV7KH$UGXLQRIXQFWLRQWRFRQILJXUHD
SLQIRUUHDGLQJLQSXWLVpinMode(pin, INPUT)
2QDW\SLFDOERDUGWKHUHDUHGLJLWDOSLQVQXPEHUHGWRDVVKRZQDWWKHWRSRI
)LJXUH3LQVDQGPDUNHG5;DQG7;DUHXVHGIRUWKH86%VHULDOFRQQHFWLRQ
DQGVKRXOGEHDYRLGHGIRURWKHUXVHV,I\RXQHHGPRUHGLJLWDOSLQVRQDVWDQGDUGERDUG
\RXFDQXVHWKHDQDORJSLQVDVGLJLWDOSLQVDQDORJSLQVWKURXJKFDQEHXVHGDV
GLJLWDOSLQVWKURXJK
7KH0HJDERDUGKDVPDQ\PRUHGLJLWDODQGDQDORJSLQV'LJLWDOSLQVWKURXJKDQG
DQDORJSLQVWKURXJKDUHORFDWHGLQWKHVDPHSODFHDVRQWKHVWDQGDUGERDUGVRWKDW
KDUGZDUHVKLHOGVGHVLJQHGIRUWKHVWDQGDUGERDUGFDQILWRQWRD0HJD$VZLWKWKH
VWDQGDUGERDUG\RXFDQXVHDQDORJSLQVDVGLJLWDOSLQVEXWZLWKWKH0HJDDQDORJSLQV
WKURXJKDUHGLJLWDOSLQQXPEHUVWKURXJK)LJXUHVKRZVWKH0HJDSLQ
OD\RXW
0RVWERDUGVKDYHDQ/('FRQQHFWHGWRSLQDQGVRPHRIWKHUHFLSHVXVHWKLVDVDQ
RXWSXWLQGLFDWRU,I\RXUERDUGGRHVQRWKDYHDQ/('RQSLQVNLSDKHDGWR5HF
LSHLI\RXQHHGKHOSFRQQHFWLQJDQ/('WRDGLJLWDOSLQ
5HFLSHVFRYHULQJGLJLWDOLQSXWVRPHWLPHVXVHH[WHUQDOUHVLVWRUVWRSURYLGHWKHYROWDJH
WKDWLVVHQVHGE\ digitalRead7KHVHUHVLVWRUVDUHFDOOHGSXOOXSUHVLVWRUVVRQDPHG
EHFDXVHWKHYROWDJHLVSXOOHGXSWRWKH9OLQHWKDWWKHUHVLVWRULVFRQQHFWHGWRRU

134 | Chapter 5: Simple Digital and Analog Input

)LJXUH$UGXLQR0HJDERDUG
SXOOGRZQUHVLVWRUVWKHYROWDJHLVSXOOHGGRZQWRYROWV$OWKRXJK.RKPVLVD
FRPPRQO\XVHGYDOXHDQ\WKLQJEHWZHHQ.DQG.RUPRUHZLOOZRUNVHH$SSHQ
GL[$IRUPRUHLQIRUPDWLRQDERXWWKHFRPSRQHQWVXVHGLQWKLVFKDSWHU
8QOLNHDGLJLWDOYDOXHZKLFKLVRQO\RQRURIIDQDORJYDOXHVDUHFRQWLQXRXVO\YDULDEOH
7KHYROXPHVHWWLQJRIDGHYLFHLVDJRRGH[DPSOHLWLVQRWMXVWRQRURIIEXWLWFDQKDYH
DUDQJHRIYDOXHVLQEHWZHHQ0DQ\VHQVRUVSURYLGHLQIRUPDWLRQE\YDU\LQJWKHYROWDJH
WR FRUUHVSRQG WR WKH VHQVRU PHDVXUHPHQW $UGXLQR FRGH XVHV D IXQFWLRQ FDOOHG
analogReadWRJHWDYDOXHSURSRUWLRQDOWRWKHYROWDJHLWVHHVRQRQHRILWVDQDORJSLQV
7KHYDOXHZLOOEHLIWKHUHDUHYROWVRQWKHSLQDQGIRUYROWV7KHYDOXHLQ
EHWZHHQZLOOEHSURSRUWLRQDOWRWKHYROWDJHRQWKHSLQVRYROWVKDOIRIYROWVZLOO
UHVXOWLQDYDOXHRIURXJKO\KDOIRI<RXFDQVHHWKHVL[DQDORJLQSXWSLQV
PDUNHGWRDWWKHERWWRPRI)LJXUHWKHVHSLQVFDQDOVREHXVHGDVGLJLWDOSLQV
WRLIWKH\DUHQRWQHHGHGIRUDQDORJ6RPHRIWKHDQDORJUHFLSHVXVHDSRWHQWL
RPHWHUSRWIRUVKRUWDOVRFDOOHGDYDULDEOHUHVLVWRUWRYDU\WKHYROWDJHRQDSLQ:KHQ
FKRRVLQJDSRWHQWLRPHWHUDYDOXHRI.LVWKHEHVWRSWLRQIRUFRQQHFWLQJWRDQDORJ
SLQV
$OWKRXJKPRVWRIWKHFLUFXLWVLQWKLVFKDSWHUDUHUHODWLYHO\HDV\WRFRQQHFW\RXPD\
ZDQWWRFRQVLGHUJHWWLQJDVROGHUOHVVEUHDGERDUGWRVLPSOLI\\RXUZLULQJWRH[WHUQDO
FRPSRQHQWVVRPHFKRLFHVDUHWKH-DPHFRWZREXVURZVSHUVLGH5DGLR6KDFN
RQHEXVURZSHUVLGH'LJL.H\1'DQG6SDUN)XQ357
$QRWKHUKDQG\LWHPLVDQLQH[SHQVLYHPXOWLPHWHU$OPRVWDQ\ZLOOGRDVORQJDVLWFDQ
PHDVXUHYROWDJHDQGUHVLVWDQFH&RQWLQXLW\FKHFNLQJDQGFXUUHQWPHDVXUHPHQWDUHQLFH
DGGLWLRQDOIHDWXUHVWRKDYH7KH-DPHFR5DGLR6KDFNDQG6SDUN)XQ
72/RIIHUWKHVHIHDWXUHV

5.0 Introduction | 135

5.1 Using a Switch
Problem
<RXZDQW\RXUVNHWFKWRUHVSRQGWRWKHFORVLQJRIDQHOHFWULFDOFRQWDFWIRUH[DPSOHD
SXVKEXWWRQRURWKHUVZLWFKRUDQH[WHUQDOGHYLFHWKDWPDNHVDQHOHFWULFDOFRQQHFWLRQ

Solution
8VHdigitalReadWRGHWHUPLQHWKHVWDWHRIDVZLWFKFRQQHFWHGWRDQ$UGXLQRGLJLWDOSLQ
VHWDVLQSXW7KHIROORZLQJFRGHOLJKWVDQ/('ZKHQDVZLWFKLVSUHVVHG)LJXUH
VKRZVKRZLWVKRXOGEHZLUHGXS
/*
Pushbutton sketch
a switch connected to pin 2 lights the LED on pin 13
*/

const int ledPin = 13; // choose the pin for the LED
const int inputPin = 2; // choose the input pin (for a pushbutton)

void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inputPin, INPUT); // declare pushbutton as input
}

void loop(){
int val = digitalRead(inputPin); // read input value
if (val == HIGH) // check if the input is HIGH
{
digitalWrite(ledPin, HIGH); // turn LED on if switch is pressed
}
else
{
digitalWrite(ledPin, LOW); // turn LED off
}
}

6WDQGDUG$UGXLQRERDUGVKDYHDEXLOWLQ/('FRQQHFWHGWRSLQ,I
\RXUERDUGGRHVQRWVHH5HFLSHIRULQIRUPDWLRQRQFRQQHFWLQJDQ
/('WRDQ$UGXLQRSLQ

Discussion
7KHsetupIXQFWLRQFRQILJXUHVWKH/('SLQDVOUTPUTDQGWKHVZLWFKSLQDVINPUT

136 | Chapter 5: Simple Digital and Analog Input

)LJXUH6ZLWFKFRQQHFWHGXVLQJSXOOGRZQUHVLVWRU

$SLQPXVWEHVHWWROUTPUTPRGHIRUdigitalWriteWRFRQWUROWKHSLQV
RXWSXWYROWDJH,WPXVWEHLQINPUTPRGHWRUHDGWKHGLJLWDOLQSXW

7KHdigitalReadIXQFWLRQPRQLWRUVWKHYROWDJHRQWKHLQSXWSLQinputPinDQGLWUH

WXUQVDYDOXHRIHIGHLIWKHYROWDJHLVKLJKYROWVDQGLOWLIWKHYROWDJHLVORZYROWV
$FWXDOO\DQ\YROWDJHWKDWLVJUHDWHUWKDQYROWVKDOIRIWKHYROWDJHSRZHULQJWKH
FKLSLVFRQVLGHUHGHIGHDQGOHVVWKDQWKLVLVWUHDWHGDVLOW,IWKHSLQLVOHIWXQFRQQHFWHG
NQRZQDVIORDWLQJWKHYDOXHUHWXUQHGIURP digitalReadLVLQGHWHUPLQDWHLWPD\EH
HIGHRU LOWDQGLWFDQQRWEHUHOLDEO\XVHG7KHUHVLVWRUVKRZQLQ)LJXUHHQVXUHV
WKDWWKHYROWDJHRQWKHSLQZLOOEHORZZKHQWKHVZLWFKLVQRWSUHVVHGEHFDXVHWKH
UHVLVWRUSXOOVGRZQWKHYROWDJHWRJURXQG:KHQWKHVZLWFKLVSXVKHGDFRQQHFWLRQ
LVPDGHEHWZHHQWKHSLQDQGYROWVVRWKHYDOXHRQWKHSLQLQWHUSUHWHGE\digital
ReadFKDQJHVIURPLOWWRHIGH

'RQRWFRQQHFWDGLJLWDORUDQDORJSLQWRDYROWDJHKLJKHUWKDQYROWV
RUYROWVRQD9ERDUG7KLVFDQGDPDJHWKHSLQDQGSRVVLEO\
GHVWUR\WKHHQWLUHFKLS$OVRPDNHVXUH\RXGRQWZLUHWKHVZLWFKVR
WKDWLWVKRUWVWKHYROWVWRJURXQGZLWKRXWDUHVLVWRU$OWKRXJKWKLV
PD\QRWGDPDJHWKH$UGXLQRFKLSLWLVQRWJRRGIRUWKHSRZHUVXSSO\

5.1 Using a Switch | 137

,QWKLVH[DPSOHWKHYDOXHIURP digitalReadLVVWRUHGLQWKHYDULDEOH val7KLVZLOOEH
HIGHLIWKHEXWWRQLVSUHVVHGLOWRWKHUZLVH

7KHVZLWFKXVHGLQWKLVH[DPSOHDQGDOPRVWHYHU\ZKHUHHOVHLQWKLV
ERRNPDNHVHOHFWULFDOFRQWDFWZKHQSUHVVHGDQGEUHDNVFRQWDFWZKHQ
QRWSUHVVHG7KHVHVZLWFKHVDUHFDOOHG1RUPDOO\2SHQ12VHHWKLV
ERRNVZHEVLWHIRUSDUWQXPEHUV7KHRWKHUNLQGRIPRPHQWDU\VZLWFK
LVFDOOHG1RUPDOO\&ORVHG1&

7KHRXWSXWSLQFRQQHFWHGWRWKH/('LVWXUQHGRQZKHQ\RXVHWvalWRHIGHLOOXPLQDWLQJ
WKH/('
$OWKRXJK$UGXLQRVHWVDOOGLJLWDOSLQVDVLQSXWVE\GHIDXOWLWLVDJRRGSUDFWLFHWRVHW
WKLVH[SOLFLWO\LQ\RXUVNHWFKWRUHPLQG\RXUVHOIDERXWWKHSLQV\RXDUHXVLQJ
<RXPD\VHHVLPLODUFRGHWKDWXVHVtrueLQVWHDGRIHIGHWKHVHFDQEHXVHGLQWHUFKDQJH
DEO\WKH\DUHDOVRVRPHWLPHVUHSUHVHQWHGDV1/LNHZLVHfalseLVWKHVDPHDVLOWDQG
08VHWKHIRUPWKDWEHVWH[SUHVVHVWKHPHDQLQJRIWKHORJLFLQ\RXUDSSOLFDWLRQ
$OPRVWDQ\VZLWFKFDQEHXVHGDOWKRXJKWKHRQHVFDOOHGPRPHQWDU\WDFWLOHVZLWFKHVDUH
SRSXODUEHFDXVHWKH\DUHLQH[SHQVLYHDQGFDQSOXJGLUHFWO\LQWRDEUHDGERDUG6HHWKH
ZHEVLWHIRUWKLVERRNIRUVRPHVXSSOLHUSDUWQXPEHUV
+HUHLVDQRWKHUZD\WRLPSOHPHQWWKHORJLFLQWKHSUHFHGLQJVNHWFK
void loop()
{
digitalWrite(ledPin, digitalRead(inputPin)); // turn LED ON if input pin is
HIGH, else turn OFF
}

7KLVGRHVQWVWRUHWKHEXWWRQVWDWHLQWRDYDULDEOH,QVWHDGLWVHWVWKH/('RQRURII
GLUHFWO\IURPWKHYDOXHREWDLQHGIURP digitalRead,WLVDKDQG\VKRUWFXWEXWLI\RX
ILQGLWRYHUO\WHUVHWKHUHLVQRSUDFWLFDOGLIIHUHQFHLQSHUIRUPDQFHVRSLFNZKLFKHYHU
IRUP\RXILQGHDVLHUWRXQGHUVWDQG
7KHSXOOXSFRGHLVVLPLODUWRWKHSXOOGRZQYHUVLRQEXWWKHORJLFLVUHYHUVHGWKHYDOXH
RQWKHSLQJRHVLOWZKHQWKHEXWWRQLVSUHVVHGVHH)LJXUHIRUDVFKHPDWLFGLDJUDP
RIWKLV,WPD\KHOSWRWKLQNRIWKLVDVSUHVVLQJWKHVZLWFKDOWNFDXVLQJWKHRXWSXWWR
JRLOW
void loop()
{
int val = digitalRead(inputPin); // read input value
if (val == HIGH) // check if the input is HIGH
{
digitalWrite(ledPin, LOW); // turn LED OFF
}

138 | Chapter 5: Simple Digital and Analog Input

 else
{
digitalWrite(ledPin, HIGH); // turn LED ON
}
}

)LJXUH6ZLWFKFRQQHFWHGXVLQJSXOOXSUHVLVWRU

See Also
7KH$UGXLQRUHIHUHQFHIRUdigitalReadKWWSDUGXLQRFFHQ5HIHUHQFH'LJLWDO5HDG
7KH$UGXLQRUHIHUHQFHIRUdigitalWriteKWWSDUGXLQRFFHQ5HIHUHQFH'LJLWDO:ULWH
7KH$UGXLQRUHIHUHQFHIRUpinModeKWWSDUGXLQRFFHQ5HIHUHQFH3LQ0RGH
7KH$UGXLQRUHIHUHQFHVIRUFRQVWDQWVHIGH LOWHWFKWWSDUGXLQRFFHQ5HIHUHQFH
&RQVWDQWV
$UGXLQRWXWRULDORQGLJLWDOSLQVKWWSDUGXLQRFFHQ7XWRULDO'LJLWDO3LQV

5.2 Using a Switch Without External Resistors

Problem
<RXZDQWWRVLPSOLI\\RXUZLULQJE\HOLPLQDWLQJH[WHUQDOSXOOXSUHVLVWRUVZKHQFRQ
QHFWLQJVZLWFKHV

5.2 Using a Switch Without External Resistors | 139

Solution
$VH[SODLQHGLQ5HFLSHGLJLWDOLQSXWVPXVWKDYHDUHVLVWRUWRKROGWKHSLQWRDNQRZQ
YDOXHZKHQWKHVZLWFKLVQRWSUHVVHG$UGXLQRKDVLQWHUQDOSXOOXSUHVLVWRUVWKDWFDQ
EHHQDEOHGE\ZULWLQJD HIGHYDOXHWRDSLQWKDWLVLQ INPUTPRGHWKHFRGHIRUWKLVLV
VKRZQLQ5HFLSH
)RUWKLVH[DPSOHWKHVZLWFKLVZLUHGDVVKRZQLQ)LJXUH7KLVLVDOPRVWH[DFWO\WKH
VDPHDV)LJXUHEXWZLWKRXWDQH[WHUQDOUHVLVWRU

)LJXUH6ZLWFKZLUHGIRUXVHZLWKLQWHUQDOSXOOXSUHVLVWRU

7KHVZLWFKLVRQO\FRQQHFWHGEHWZHHQSLQDQG*QG*QGLVVKRUWIRUJURXQGDQGLV
DWYROWVE\GHILQLWLRQ
/*
Pullup sketch
a switch connected to pin 2 lights the LED on pin 13
*/

const int ledPin = 13; // output pin for the LED

const int inputPin = 2; // input pin for the switch

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inputPin, INPUT);
digitalWrite(inputPin,HIGH); // turn on internal pull-up on the inputPin

140 | Chapter 5: Simple Digital and Analog Input

 }

void loop(){
int val = digitalRead(inputPin); // read input value
if (val == HIGH) // check if the input is HIGH
{
digitalWrite(ledPin, HIGH); // turn LED OFF
}
else
{
digitalWrite(ledPin, LOW); // turn LED ON
}
}

7KHUHDUHDIHZ*QGSLQVRQDQ$UGXLQRERDUGWKH\DUHDOOFRQQHFWHG
VRSLFNZKLFKHYHULVFRQYHQLHQW
Download from Wow! eBook <[Link]>

Discussion
<RXHQDEOHLQWHUQDOSXOOXSUHVLVWRUVE\ZULWLQJD HIGHYDOXHWRDSLQLQLQSXWPRGH
8VLQJ digitalWrite(pin, HIGH)RQDSLQLQLQSXWPRGHPD\QRWEHLQWXLWLYHDWILUVW
EXW\RXOOVRRQJHWXVHGWRLW<RXFDQWXUQWKHSXOOXSRIIE\ZULWLQJDLOWYDOXHWRWKH
SLQ
,I\RXUDSSOLFDWLRQVZLWFKHVWKHSLQPRGHEDFNDQGIRUWKEHWZHHQLQSXWDQGRXWSXW
EHDULQPLQGWKDWWKHVWDWHRIWKHSLQZLOOUHPDLQHIGHRULOWZKHQ\RXFKDQJHPRGHV
,QRWKHUZRUGVLI\RXKDYHVHWDQRXWSXWSLQHIGHDQGWKHQFKDQJHWRLQSXWPRGHWKH
SXOOXSZLOOEHRQDQGUHDGLQJWKHSLQZLOOSURGXFHD HIGH,I\RXVHWWKHSLQ LOWLQ
RXWSXWPRGHZLWK digitalWrite(pin, LOW)DQGWKHQFKDQJHWRLQSXWPRGHZLWK pin
Mode(pin, INPUT)WKHSXOOXSZLOOEHRII,I\RXWXUQDSXOOXSRQFKDQJLQJWRRXWSXW
PRGHZLOOVHWWKHSLQ HIGHZKLFKFRXOGIRUH[DPSOHXQLQWHQWLRQDOO\OLJKWDQ/('
FRQQHFWHGWRLW
7KHLQWHUQDOSXOOXSUHVLVWRUVDUH.RKPV7KLVLVVXLWDEOHIRUPRVWDSSOLFDWLRQVEXW
VRPHGHYLFHVPD\UHTXLUHORZHUYDOXHUHVLVWRUVVHHWKHGDWDVKHHWIRUH[WHUQDOGHYLFHV
\RXZDQWWRFRQQHFWWR$UGXLQRWRVHHLIWKHLQWHUQDOSXOOXSVDUHVXLWDEOHRUQRW

5.3 Reliably Detecting the Closing of a Switch

Problem
<RXZDQWWRDYRLGIDOVHUHDGLQJVGXHWRFRQWDFWERXQFHFRQWDFWERXQFHSURGXFHVVSX
ULRXVVLJQDOVDWWKHPRPHQWWKHVZLWFKFRQWDFWVFORVHRURSHQ7KHSURFHVVRIHOLPL
QDWLQJVSXULRXVUHDGLQJVLVFDOOHGGHERXQFLQJ

5.3 Reliably Detecting the Closing of a Switch | 141

Solution
7KHUH DUH PDQ\ ZD\V WR VROYH WKLV SUREOHP KHUH LV RQH XVLQJ WKH ZLULQJ VKRZQ LQ
)LJXUHIURP5HFLSH
/*
Debounce sketch
a switch connected to pin 2 lights the LED on pin 13
debounce logic prevents misreading of the switch state
*/

const int inputPin = 2; // the number of the input pin

const int ledPin = 13; // the number of the output pin
const int debounceDelay = 10; // milliseconds to wait until stable

// debounce returns true if the switch in the given pin is closed and stable
boolean debounce(int pin)
{
boolean state;
boolean previousState;

previousState = digitalRead(pin); // store switch state

for(int counter=0; counter < debounceDelay; counter++)
{
delay(1); // wait for 1 millisecond
state = digitalRead(pin); // read the pin
if( state != previousState)
{
counter = 0; // reset the counter if the state changes
previousState = state; // and save the current state
}
}
// here when the switch state has been stable longer than the debounce period

return state;
}

void setup()
{
pinMode(inputPin, INPUT);
pinMode(ledPin, OUTPUT);
}

void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH);
}
}

7KHdebounceIXQFWLRQLVFDOOHGXVHGZLWKWKHSLQQXPEHURIWKHVZLWFK\RXZDQWWR

GHERXQFH WKH IXQFWLRQ UHWXUQV true LI WKH VZLWFK LV SUHVVHG DQG VWDEOH ,W UHWXUQV
falseLILWLVQRWSUHVVHGRUQRW\HWVWDEOH

142 | Chapter 5: Simple Digital and Analog Input

Discussion
7KHdebouncePHWKRGFKHFNVWRVHHLILWJHWVWKHVDPHUHDGLQJIURPWKHVZLWFKDIWHUD
GHOD\WKDWQHHGVWREHORQJHQRXJKIRUWKHVZLWFKFRQWDFWVWRVWRSERXQFLQJ<RXPD\
UHTXLUHORQJHULQWHUYDOVIRUERXQFLHUVZLWFKHVVRPHVZLWFKHVFDQUHTXLUHDVPXFKDV
PVRUPRUH7KHIXQFWLRQZRUNVE\UHSHDWHGO\FKHFNLQJWKHVWDWHRIWKHVZLWFKIRU
DVPDQ\PLOOLVHFRQGVDVGHILQHGLQWKHdebounceWLPH,IWKHVZLWFKUHPDLQVVWDEOHIRU
WKLVWLPHWKHVWDWHRIWKHVZLWFKZLOOEHUHWXUQHGtrueLISUHVVHGDQG falseLIQRW,I
WKHVZLWFKVWDWHFKDQJHVZLWKLQWKHGHERXQFHSHULRGWKHFRXQWHULVUHVHWVRWKDWWKH
FKHFNVVWDUWRYHUXQWLOWKHVZLWFKVWDWHGRHVQRWFKDQJHZLWKLQWKHGHERXQFHWLPH
,I\RXUZLULQJXVHVSXOOXSUHVLVWRUVLQVWHDGRISXOOGRZQUHVLVWRUVVHH5HFLSH\RX
QHHGWRLQYHUWWKHYDOXHUHWXUQHGIURPWKH debounceIXQFWLRQEHFDXVHWKHVWDWHJRHV
LOW ZKHQ WKH VZLWFK LV SUHVVHG XVLQJ SXOOXSV EXW WKH IXQFWLRQ VKRXOG UHWXUQ true
trueLVWKHVDPHDVHIGHZKHQWKHVZLWFKLVSUHVVHG7KHGHERXQFHFRGHXVLQJSXOO
XSVLVDVIROORZVRQO\WKHODVWIRXUOLQHVKLJKOLJKWHGDUHFKDQJHGIURPWKHSUHYLRXV
YHUVLRQ
boolean debounce(int pin)
{
boolean state;
boolean previousState;

previousState = digitalRead(pin); // store switch state

for(int counter=0; counter < debounceDelay; counter++)
{
delay(1); // wait for 1 millisecond
state = digitalRead(pin); // read the pin
if( state != previousState)
{
counter = 0; // reset the counter if the state changes
previousState = state; // and save the current state
}
}
// here when the switch state has been stable longer than the debounce period
if(state == LOW) // LOW means pressed (because pull-ups are used)
return true;
else
return false;
}

)RUWHVWLQJ\RXFDQDGGDcountYDULDEOHWRGLVSOD\WKHQXPEHURISUHVVHV,I\RXYLHZ
WKLVRQWKH6HULDO0RQLWRUVHH&KDSWHU\RXFDQVHHZKHWKHULWLQFUHPHQWVRQFHSHU
SUHVV,QFUHDVHWKHYDOXHRIdebounceDelayXQWLOWKHFRXQWNHHSVVWHSZLWKWKHSUHVVHV
7KHIROORZLQJIUDJPHQWSULQWVWKHYDOXHRIcountZKHQXVHGZLWKWKHdebounceIXQFWLRQ
VKRZQHDUOLHU
int count; // add this variable to store the number of presses

void setup()
{
pinMode(inPin, INPUT);

5.3 Reliably Detecting the Closing of a Switch | 143

 pinMode(outPin, OUTPUT);
[Link](9600); // add this to the setup function
}

void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH);
count++; // increment count
[Link](count); // display the count on the Serial Monitor
}
}

7KLVdebounce()IXQFWLRQZLOOZRUNIRUDQ\QXPEHURIVZLWFKHVEXW\RXPXVWHQVXUH
WKDWWKHSLQVXVHGDUHLQLQSXWPRGH
$SRWHQWLDOGLVDGYDQWDJHRIWKLVPHWKRGIRUVRPHDSSOLFDWLRQVLVWKDWIURPWKHWLPHWKH
debounceIXQFWLRQLVFDOOHGHYHU\WKLQJZDLWVXQWLOWKHVZLWFKLVVWDEOH,QPRVWFDVHV
WKLVGRHVQWPDWWHUEXW\RXUVNHWFKPD\QHHGWREHDWWHQGLQJWRRWKHUWKLQJVZKLOH
ZDLWLQJIRU\RXUVZLWFKWRVWDELOL]H<RXFDQXVHWKHFRGHVKRZQLQ5HFLSHWRRYHU
FRPHWKLVSUREOHP

See Also
6HHWKH'HERXQFHH[DPSOHVNHWFKGLVWULEXWHGZLWK$UGXLQR)URPWKH)LOHPHQXVHOHFW
([DPSOHV 'LJLWDO 'HERXQFH

5.4 Determining How Long a Switch Is Pressed

Problem
<RXUDSSOLFDWLRQZDQWVWRGHWHFWWKHOHQJWKRIWLPHDVZLWFKKDVEHHQLQLWVFXUUHQW
VWDWH2U\RXZDQWWRLQFUHPHQWDYDOXHZKLOHDVZLWFKLVSXVKHGDQG\RXZDQWWKHUDWH
WRLQFUHDVHWKHORQJHUWKHVZLWFKLVKHOGWKHZD\PDQ\HOHFWURQLFFORFNVDUHVHW2U
\RXZDQWWRNQRZLIDVZLWFKKDVEHHQSUHVVHGORQJHQRXJKIRUWKHUHDGLQJWREHVWDEOH
VHH5HFLSH

Solution
7KHIROORZLQJVNHWFKGHPRQVWUDWHVWKHVHWWLQJRIDFRXQWGRZQWLPHU7KHZLULQJLVWKH
VDPHDVLQ)LJXUHIURP5HFLSH3UHVVLQJDVZLWFKVHWVWKHWLPHUE\LQFUHPHQWLQJ
WKHWLPHUFRXQWUHOHDVLQJWKHVZLWFKVWDUWVWKHFRXQWGRZQ7KHFRGHGHERXQFHVWKH
VZLWFKDQGDFFHOHUDWHVWKHUDWHDWZKLFKWKHFRXQWHULQFUHDVHVZKHQWKHVZLWFKLVKHOG
IRUORQJHUSHULRGV7KHWLPHUFRXQWLVLQFUHPHQWHGE\RQHZKHQWKHVZLWFKLVLQLWLDOO\
SUHVVHGDIWHUGHERXQFLQJ+ROGLQJWKHVZLWFKIRUPRUHWKDQRQHVHFRQGLQFUHDVHVWKH
LQFUHPHQWUDWHE\IRXUKROGLQJWKHVZLWFKIRUIRXUVHFRQGVLQFUHDVHVWKHUDWHE\WHQ

144 | Chapter 5: Simple Digital and Analog Input

5HOHDVLQJWKHVZLWFKVWDUWVWKHFRXQWGRZQDQGZKHQWKHFRXQWUHDFKHV]HURDSLQLV
VHWHIGHLQWKLVH[DPSOHOLJKWLQJDQ/('
/*
SwitchTime sketch
Countdown timer that decrements every tenth of a second
lights an LED when 0
Pressing button increments count, holding button down increases
rate of increment

*/
const int ledPin = 13; // the number of the output pin
const int inPin = 2; // the number of the input pin

const int debounceTime = 20; // the time in milliseconds required

for the switch to be stable
const int fastIncrement = 1000; // increment faster after this many
milliseconds
const int veryFastIncrement = 4000; // and increment even faster after
this many milliseconds
int count = 0; // count decrements every tenth of a
second until reaches 0

void setup()
{
pinMode(inPin, INPUT);
digitalWrite(inPin, HIGH); // turn on pull-up resistor
pinMode(ledPin, OUTPUT);
[Link](9600);
}

void loop()
{
int duration = switchTime();
if( duration > veryFastIncrement)
count = count + 10;
else if ( duration > fastIncrement)
count = count + 4;
else if ( duration > debounceTime)
count = count + 1;

else
{
// switch not pressed so service the timer
if( count == 0)
digitalWrite(ledPin, HIGH); // turn the LED on if the count is 0
else
{
digitalWrite(ledPin, LOW); // turn the LED off if the count is not 0
count = count - 1; // and decrement the count
}
}

5.4 Determining How Long a Switch Is Pressed | 145

 [Link](count);
delay(100);
}

// return the time in milliseconds that the switch has been in pressed (LOW)
long switchTime()
{
// these variables are static - see Discussion for an explanation
static unsigned long startTime = 0; // the time the switch state change was
first detected
static boolean state; // the current state of the switch

if(digitalRead(inPin) != state) // check to see if the switch has changed state

{
state = ! state; // yes, invert the state
startTime = millis(); // store the time
}
if( state == LOW)
return millis() - startTime; // switch pushed, return time in milliseconds
else
return 0; // return 0 if the switch is not pushed (in the HIGH state);
}

Discussion
7KHKHDUWRIWKLVUHFLSHLVWKH switchTimeIXQFWLRQ7KLVUHWXUQVWKHQXPEHURIPLOOL
VHFRQGV WKDW WKH VZLWFK KDV EHHQ SUHVVHG %HFDXVH WKLV UHFLSH XVHV LQWHUQDO SXOOXS
UHVLVWRUVVHH5HFLSHWKH digitalReadRIWKHVZLWFKSLQZLOOUHWXUQ LOWZKHQWKH
VZLWFKLVSUHVVHG
7KHloopFKHFNVWKHYDOXHUHWXUQHGIURPswitchTimeWRVHHZKDWVKRXOGKDSSHQ,IWKH
WLPHWKHVZLWFKKDVEHHQKHOGGRZQLVORQJHQRXJKIRUWKHIDVWHVWLQFUHPHQWWKHFRXQWHU
LVLQFUHPHQWHGE\WKDWDPRXQWLIQRWLWFKHFNVWKHfastYDOXHWRVHHLIWKDWVKRXOGEH
XVHGLIQRWLWFKHFNVLIWKHVZLWFKKDVEHHQKHOGGRZQORQJHQRXJKWRVWRSERXQFLQJ
DQGLIVRLWLQFUHPHQWVDVPDOODPRXQW$WPRVWRQHRIWKRVHZLOOKDSSHQ,IQRQHRI
WKHPDUHtrueWKHVZLWFKLVQRWEHLQJSUHVVHGRULWKDVQRWEHHQSUHVVHGORQJHQRXJK
WRKDYHVWRSSHGERXQFLQJ7KHFRXQWHUYDOXHLVFKHFNHGDQGDQ/('LVWXUQHGRQLILW
LV]HURLILWVQRW]HURWKHFRXQWHULVGHFUHPHQWHGDQGWKH/('LVWXUQHGRII
<RXFDQXVHWKHswitchTimeIXQFWLRQMXVWIRUGHERXQFLQJDVZLWFK7KHIROORZLQJFRGH
KDQGOHVGHERXQFHORJLFE\FDOOLQJWKHswitchTimeIXQFWLRQ
const int debounceTime = 20; // the time in milliseconds that the switch
needs to be stable

if( switchTime() > debounceTime);

[Link]("switch is debounced");

7KLVDSSURDFKWRGHERXQFLQJFDQEHKDQG\LI\RXKDYHPRUHWKDQRQHVZLWFKEHFDXVH
\RXFDQSHHNLQDQGORRNDWWKHDPRXQWRIWLPHDVZLWFKKDVEHHQSUHVVHGDQGSURFHVV
RWKHUWDVNVZKLOHZDLWLQJIRUDVZLWFKWREHFRPHVWDEOH7RLPSOHPHQWWKLV\RXQHHG
WR VWRUH WKH FXUUHQW VWDWH RI WKH VZLWFK SUHVVHG RU QRW DQG WKH WLPH WKH VWDWH ODVW

146 | Chapter 5: Simple Digital and Analog Input

FKDQJHG7KHUHDUHPDQ\ZD\VWRGRWKLVLQWKLVH[DPSOH\RXZLOOXVHDVHSDUDWH
IXQFWLRQIRUHDFKVZLWFK<RXFRXOGVWRUHWKHYDULDEOHVDVVRFLDWHGZLWKDOOWKHVZLWFKHV
DWWKHWRSRI\RXUVNHWFKDVJOREDOYDULDEOHVFDOOHGJOREDOEHFDXVHWKH\DUHDFFHVVLEOH
HYHU\ZKHUH%XWLWLVPRUHFRQYHQLHQWWRKDYHWKHYDULDEOHVIRUHDFKVZLWFKFRQWDLQHG
ZLWKWKHIXQFWLRQ
5HWDLQLQJYDOXHVRIYDULDEOHVGHILQHGLQDIXQFWLRQLVDFKLHYHGE\XVLQJVWDWLFYDULD
EOHV6WDWLFYDULDEOHVZLWKLQDIXQFWLRQSURYLGHSHUPDQHQWVWRUDJHIRUYDOXHVWKDWPXVW
EHPDLQWDLQHGEHWZHHQIXQFWLRQFDOOV$YDOXHDVVLJQHGWRDVWDWLFYDULDEOHLVUHWDLQHG
HYHQDIWHUWKHIXQFWLRQUHWXUQV7KHODVWYDOXHVHWZLOOEHDYDLODEOHWKHQH[WWLPHWKH
IXQFWLRQLVFDOOHG,QWKDWVHQVHVWDWLFYDULDEOHVDUHVLPLODUWRWKHJOREDOYDULDEOHVYDU
LDEOHVGHFODUHGRXWVLGHDIXQFWLRQXVXDOO\DWWKHEHJLQQLQJRIDVNHWFKWKDW\RXVDZ
LQWKHRWKHUUHFLSHV%XWXQOLNHJOREDOYDULDEOHVVWDWLFYDULDEOHVGHFODUHGLQDIXQFWLRQ
DUH RQO\ DFFHVVLEOH ZLWKLQ WKDW IXQFWLRQ 7KH EHQHILW RI VWDWLF YDULDEOHV LV WKDW WKH\
FDQQRWEHDFFLGHQWDOO\PRGLILHGE\VRPHRWKHUIXQFWLRQ
7KLVVNHWFKVKRZVDQH[DPSOHRIKRZ\RXFDQDGGVHSDUDWHIXQFWLRQVIRUGLIIHUHQW
VZLWFKHV7KHZLULQJIRUWKLVLVVLPLODUWR5HFLSHZLWKWKHVHFRQGVZLWFKZLUHG
VLPLODUO\WRWKHILUVWDVVKRZQLQ)LJXUHEXWFRQQHFWHGEHWZHHQSLQDQG*QG
/*
SwitchTimeMultiple sketch
Prints how long more than one switch has been pressed
*/

const int switchAPin = 2; // the pin for switch A

const int switchBPin = 3; // the pin for switch B

// functions with references must be explicitly declared

unsigned long switchTime(int pin, boolean &state, unsigned long &startTime);

void setup()
{
pinMode(switchAPin, INPUT);
digitalWrite(switchAPin, HIGH); // turn on pull-up resistors
pinMode(switchBPin, INPUT);
digitalWrite(switchBPin, HIGH); // turn on pull-up resistors
[Link](9600);
}

void loop()
{
unsigned long time;

[Link]("switch A time =");

time = switchATime();
[Link](time);

[Link](", switch B time =");

time = switchBTime();
[Link](time);
delay(1000);

5.4 Determining How Long a Switch Is Pressed | 147

 }

unsigned long switchTime(int pin, boolean &state, unsigned long &startTime)

{
if(digitalRead(pin) != state) // check to see if the switch has changed state
{
state = ! state; //yes, invert the state
startTime = millis(); // store the time
}
if( state == LOW)
return millis() - startTime; // return the time in milliseconds
else
return 0; // return 0 if the switch is not pushed (in the HIGH state);
}

long switchATime()
{
// these variables are static - see text for an explanation
static unsigned long startTime = 0; // the time the switch state change was
first detected
static boolean state; // the current state of the switch
return switchTime(switchAPin, state, startTime);
}

long switchBTime()
{
// these variables are static - see text for an explanation
static unsigned long startTime = 0; // the time the switch state change was
first detected
static boolean state; // the current state of the switch
return switchTime(switchBPin, state, startTime);
}

7KH WLPH FDOFXODWLRQ LV SHUIRUPHG LQ D IXQFWLRQ FDOOHG switchTime() 7KLV IXQFWLRQ
H[DPLQHVDQGXSGDWHVWKHVZLWFKVWDWHDQGGXUDWLRQ7KHIXQFWLRQXVHVUHIHUHQFHVWR
KDQGOHWKHSDUDPHWHUVUHIHUHQFHVZHUHFRYHUHGLQ5HFLSH$IXQFWLRQIRUHDFK
VZLWFKswitchATime()DQGswitchBTime()LVXVHGWRUHWDLQWKHVWDUWWLPHDQGVWDWHIRU
HDFKVZLWFK%HFDXVHWKHYDULDEOHVKROGLQJWKHYDOXHVDUHGHFODUHGDVVWDWLFWKHYDOXHV
ZLOO EH UHWDLQHG ZKHQ WKH IXQFWLRQV H[LW +ROGLQJ WKH YDULDEOHV ZLWKLQ WKH IXQFWLRQ
HQVXUHVWKDWWKHZURQJYDULDEOHZLOOQRWEHXVHG7KHSLQVXVHGE\WKHVZLWFKHVDUH
GHFODUHGDVJOREDOYDULDEOHVEHFDXVHWKHYDOXHVDUHQHHGHGE\ setupWRFRQILJXUHWKH
SLQV%XWEHFDXVHWKHVHYDULDEOHVDUHGHFODUHGZLWKWKH constNH\ZRUGWKHFRPSLOHU
ZLOOQRWDOORZWKHYDOXHVWREHPRGLILHGVRWKHUHLVQRFKDQFHWKDWWKHVHZLOOEHDFFL
GHQWDOO\FKDQJHGE\WKHVNHWFKFRGH
/LPLWLQJWKHH[SRVXUHRIDYDULDEOHEHFRPHVPRUHLPSRUWDQWDVSURMHFWVEHFRPHPRUH
FRPSOH[7KH$UGXLQRHQYLURQPHQWSURYLGHVDPRUHHOHJDQWZD\WRKDQGOHWKLVVHH
5HFLSHIRUDGLVFXVVLRQRQKRZWRLPSOHPHQWWKLVXVLQJFODVVHV

148 | Chapter 5: Simple Digital and Analog Input

5.5 Reading a Keypad
Problem
<RXKDYHDPDWUL[NH\SDGDQGZDQWWRUHDGWKHNH\SUHVVHVLQ\RXUVNHWFK)RUH[DPSOH
\RXKDYHDWHOHSKRQHVW\OHNH\SDGVLPLODUWRWKH6SDUN)XQEXWWRQNH\SDG6SDUN
)XQ&20

Solution
:LUHWKHURZVDQGFROXPQVIURPWKHNH\SDGFRQQHFWRUWRWKH$UGXLQRDVVKRZQLQ
)LJXUH

)LJXUH&RQQHFWLQJWKH6SDUN)XQNH\ERDUGPDWUL[

,I\RXYHZLUHG\RXU$UGXLQRDQGNH\SDGDVVKRZQLQ)LJXUHWKHIROORZLQJVNHWFK
ZLOOSULQWNH\SUHVVHVWRWKH6HULDO0RQLWRU
/*
Keypad sketch
prints the key pressed on a keypad to the serial port
*/

const int numRows = 4; // number of rows in the keypad

const int numCols = 3; // number of columns
const int debounceTime = 20; // number of milliseconds for switch to be stable

5.5 Reading a Keypad | 149

 // keymap defines the character returned when the corresponding key is pressed
const char keymap[numRows][numCols] = {
{ '1', '2', '3' } ,
{ '4', '5', '6' } ,
{ '7', '8', '9' } ,
{ '*', '0', '#' }
};

// this array determines the pins used for rows and columns
const int rowPins[numRows] = { 7, 2, 3, 6 }; // Rows 0 through 3
const int colPins[numCols] = { 5, 8, 4 }; // Columns 0 through 2

void setup()
{
[Link](9600);
for (int row = 0; row < numRows; row++)
{
pinMode(rowPins[row],INPUT); // Set row pins as input
digitalWrite(rowPins[row],HIGH); // turn on Pull-ups
}
for (int column = 0; column < numCols; column++)
{
pinMode(colPins[column],OUTPUT); // Set column pins as outputs for writing
digitalWrite(colPins[column],HIGH); // Make all columns inactive
}
}

void loop()
{
char key = getKey();
if( key != 0) { // if the character is not 0 then it's a valid key press
[Link]("Got key ");
[Link](key);
}
}

// returns with the key pressed, or 0 if no key is pressed

char getKey()
{
char key = 0; // 0 indicates no key pressed

for(int column = 0; column < numCols; column++)

{
digitalWrite(colPins[column],LOW); // Activate the current column.
for(int row = 0; row < numRows; row++) // Scan all rows for a key press.
{
if(digitalRead(rowPins[row]) == LOW) // Is a key pressed?
{
delay(debounceTime); // debounce
while(digitalRead(rowPins[row]) == LOW)
; // wait for key to be released
key = keymap[row][column]; // Remember which key was pressed.
}
}

150 | Chapter 5: Simple Digital and Analog Input

 digitalWrite(colPins[column],HIGH); // De-activate the current column.
}
return key; // returns the key pressed or 0 if none
}

7KLVVNHWFKZLOORQO\ZRUNFRUUHFWO\LIWKHZLULQJDJUHHVZLWKWKHFRGH7DEOHVKRZV
KRZWKHURZVDQGFROXPQVVKRXOGEHFRQQHFWHGWR$UGXLQRSLQV,I\RXDUHXVLQJD
GLIIHUHQWNH\SDGFKHFN\RXUGDWDVKHHWWRGHWHUPLQHWKHURZDQGFROXPQFRQQHFWLRQV
&KHFNFDUHIXOO\DVLQFRUUHFWZLULQJFDQVKRUWRXWWKHSLQVDQGWKDWFRXOGGDPDJH\RXU
FRQWUROOHUFKLS
7DEOH0DSSLQJRI$UGXLQRSLQVWR6SDUN)XQFRQQHFWRUDQGNH\SDGURZVDQGFROXPQV
Arduino pin Keypad connector Keypad row/column
2 7 Row 1
3 6 Row 2
4 5 Column 2
5 4 Column 0
6 3 Row 3
7 2 Row 0
8 1 Column 1

Discussion
0DWUL[NH\SDGVW\SLFDOO\FRQVLVWRI1RUPDOO\2SHQVZLWFKHVWKDWFRQQHFWDURZZLWK
DFROXPQZKHQSUHVVHG$1RUPDOO\2SHQVZLWFKRQO\PDNHVHOHFWULFDOFRQQHFWLRQ
ZKHQSXVKHG)LJXUHVKRZVKRZWKHLQWHUQDOFRQGXFWRUVFRQQHFWWKHEXWWRQURZV
DQGFROXPQVWRWKHNH\ERDUGFRQQHFWRU(DFKRIWKHIRXUURZVLVFRQQHFWHGWRDQLQSXW
SLQDQGHDFKFROXPQLVFRQQHFWHGWRDQRXWSXWSLQ7KH setupIXQFWLRQVHWVWKHSLQ
PRGHVDQGHQDEOHVSXOOXSUHVLVWRUVRQWKHLQSXWSLQVVHHWKHSXOOXSUHFLSHVLQWKH
EHJLQQLQJRIWKLVFKDSWHU
7KHgetkeyIXQFWLRQVHTXHQWLDOO\VHWVWKHSLQIRUHDFKFROXPQLOWDQGWKHQFKHFNVWR
VHHLIDQ\RIWKHURZSLQVDUHLOW%HFDXVHSXOOXSUHVLVWRUVDUHXVHGWKHURZVZLOOEH
KLJKSXOOHGXSXQOHVVDVZLWFKLVFORVHGFORVLQJDVZLWFKSURGXFHVDLOWVLJQDORQWKH
LQSXWSLQ,IWKH\DUH LOWWKLVLQGLFDWHVWKDWWKHVZLWFKIRUWKDWURZDQGFROXPQLV
FORVHG$GHOD\LVXVHGWRHQVXUHWKDWWKHVZLWFKLVQRWERXQFLQJVHH5HFLSHWKH
FRGHZDLWVIRUWKHVZLWFKWREHUHOHDVHGDQGWKHFKDUDFWHUDVVRFLDWHGZLWKWKHVZLWFK
LVIRXQGLQWKHkeymapDUUD\DQGUHWXUQHGIURPWKHIXQFWLRQ$0LVUHWXUQHGLIQRVZLWFK
LVSUHVVHG
$OLEUDU\LQWKH$UGXLQR3OD\JURXQGWKDWLVVLPLODUWRWKHSUHFHGLQJH[DPSOHSURYLGHV
PRUHIXQFWLRQDOLW\7KHOLEUDU\PDNHVLWHDVLHUWRKDQGOHGLIIHUHQWQXPEHUVRINH\VDQG
LWFDQEHPDGHWRZRUNZKLOHVKDULQJVRPHRIWKHSLQVZLWKDQ/&'<RXFDQILQGWKH
OLEUDU\DWKWWSZZZDUGXLQRFFSOD\JURXQG0DLQ.H\SDG7XWRULDO

5.5 Reading a Keypad | 151

See Also
)RUPRUHLQIRUPDWLRQRQWKH6SDUN)XQEXWWRQNH\SDGJRWRKWWSZZZVSDUNIXQ
FRPFRPPHUFHSURGXFWBLQIRSKS"SURGXFWVBLG 

5.6 Reading Analog Values

Problem
<RXZDQWWRUHDGWKHYROWDJHRQDQDQDORJSLQ3HUKDSV\RXZDQWDUHDGLQJIURPD
SRWHQWLRPHWHUSRWRUDGHYLFHRUVHQVRUWKDWSURYLGHVDYROWDJHEHWZHHQDQGYROWV

Solution
7KLVVNHWFKUHDGVWKHYROWDJHRQDQDQDORJSLQDQGIODVKHVDQ/('LQDSURSRUWLRQDO
UDWHWRWKHYDOXHUHWXUQHGIURPWKH analogReadIXQFWLRQ7KHYROWDJHLVDGMXVWHGE\D
SRWHQWLRPHWHUFRQQHFWHGDVVKRZQLQ)LJXUH
/*
Pot sketch
blink an LED at a rate set by the position of a potentiometer
*/

const int potPin = 0; // select the input pin for the potentiometer
const int ledPin = 13; // select the pin for the LED
int val = 0; // variable to store the value coming from the sensor

void setup()
{
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
}

void loop() {
val = analogRead(potPin); // read the voltage on the pot
digitalWrite(ledPin, HIGH); // turn the ledPin on
delay(val); // blink rate set by pot value (in milliseconds)
digitalWrite(ledPin, LOW); // turn the ledPin off
delay(val); // turn led off for same period as it was turned on
}

Discussion
7KLVVNHWFKXVHVWKH analogReadIXQFWLRQWRUHDGWKHYROWDJHRQWKHSRWHQWLRPHWHUV
ZLSHUWKHFHQWHUSLQ$SRWKDVWKUHHSLQVWZRDUHFRQQHFWHGWRDUHVLVWLYHPDWHULDO
DQGWKHWKLUGSLQXVXDOO\LQWKHPLGGOHLVFRQQHFWHGWRDZLSHUWKDWFDQEHURWDWHGWR
PDNH FRQWDFW DQ\ZKHUH RQ WKH UHVLVWLYH PDWHULDO $V WKH SRWHQWLRPHWHU URWDWHV WKH
UHVLVWDQFHEHWZHHQWKHZLSHUDQGRQHRIWKHSLQVLQFUHDVHVZKLOHWKHRWKHUGHFUHDVHV
7KHVFKHPDWLFGLDJUDPIRUWKLVUHFLSH)LJXUHPD\KHOS\RXYLVXDOL]HKRZDSR
WHQWLRPHWHUZRUNVDVWKHZLSHUPRYHVWRZDUGWKHERWWRPHQGWKHZLSHUWKHOLQHZLWK

152 | Chapter 5: Simple Digital and Analog Input

)LJXUH&RQQHFWLQJDSRWHQWLRPHWHUWR$UGXLQR
WKHDUURZZLOOKDYHORZHUUHVLVWDQFHFRQQHFWLQJWR*QGDQGKLJKHUUHVLVWDQFHFRQ
QHFWLQJWRYROWV$VWKHZLSHUPRYHVGRZQWKHYROWDJHRQWKHDQDORJSLQZLOOGHFUHDVH
WRDPLQLPXPRIYROWV0RYLQJWKHZLSHUXSZDUGZLOOKDYHWKHRSSRVLWHHIIHFWDQG
WKHYROWDJHRQWKHSLQZLOOLQFUHDVHXSWRDPD[LPXPRIYROWV

,IWKHYROWDJHRQWKHSLQGHFUHDVHVUDWKHUWKDQLQFUHDVHVDV\RXLQFUHDVH
WKHURWDWLRQRIWKHSRWHQWLRPHWHU\RXFDQUHYHUVHWKHFRQQHFWLRQVWR
WKHYROWVDQG*QGSLQV

7KHYROWDJHLVPHDVXUHGXVLQJanalogReadZKLFKSURYLGHVDYDOXHSURSRUWLRQDOWRWKH
DFWXDOYROWDJHRQWKHDQDORJSLQ7KHYDOXHZLOOEHZKHQWKHUHDUHYROWVRQWKHSLQ
DQGZKHQWKHUHDUHYROWV$YDOXHLQEHWZHHQZLOOEHSURSRUWLRQDOWRWKHUDWLR
RIWKHYROWDJHRQWKHSLQWRYROWV
3RWHQWLRPHWHUVZLWKDYDOXHRI.RKPVDUHWKHEHVWFKRLFHIRUFRQQHFWLQJWRDQDORJ
SLQV6HHWKLVERRNVZHEVLWHIRUUHFRPPHQGHGSDUWQXPEHUV

potPinGRHVQRWQHHGWREHVHWDVLQSXW7KLVLVGRQHIRU\RXDXWRPDW
LFDOO\HDFKWLPH\RXFDOOanalogRead

See Also
$SSHQGL[%IRUWLSVRQUHDGLQJVFKHPDWLFGLDJUDPV
$UGXLQRUHIHUHQFHIRUanalogReadKWWSZZZDUGXLQRFFHQ5HIHUHQFH$QDORJ5HDG

5.6 Reading Analog Values | 153

*HWWLQJ6WDUWHGZLWK$UGXLQRE\0DVVLPR%DQ]L0DNH

5.7 Changing the Range of Values

Problem
<RXZDQWWRFKDQJHWKHUDQJHRIDYDOXHVXFKDVWKHYDOXHIURPanalogReadREWDLQHG
E\FRQQHFWLQJDSRWHQWLRPHWHURURWKHUGHYLFHWKDWSURYLGHVDYDULDEOHYROWDJH)RU
H[DPSOHVXSSRVH\RXZDQWWRGLVSOD\WKHSRVLWLRQRIDSRWHQWLRPHWHUNQREDVDSHU
FHQWDJHIURPSHUFHQWWRSHUFHQW

Solution
8VHWKH$UGXLQRmapIXQFWLRQWRVFDOHYDOXHVWRWKHUDQJH\RXZDQW7KLVVNHWFKUHDGV
WKHYROWDJHRQDSRWLQWRWKHYDULDEOH valDQGVFDOHVWKLVIURPWRDVWKHSRWLV
URWDWHGIURPRQHHQGWRWKHRWKHU,WEOLQNVDQ/('ZLWKDUDWHSURSRUWLRQDOWRWKH
YROWDJHRQWKHSLQDQGSULQWVWKHVFDOHGUDQJHWRWKHVHULDOSRUWVHH 5HFLSHIRU
LQVWUXFWLRQVRQPRQLWRULQJWKHVHULDOSRUW5HFLSHVHH)LJXUHVKRZVKRZWKH
SRWLVFRQQHFWHG
/*
* Map sketch
* map the range of analog values from a pot to scale from 0 to 100
* resulting in an LED blink rate ranging from 0 to 100 milliseconds.
* and Pot rotation percent is written to the serial port
*/

const int potPin = 0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
[Link](9600);
}

void loop() {
int val; // The value coming from the sensor
int percent; // The mapped value

val = analogRead(potPin); // read the voltage on the pot (val ranges

// from 0 to 1023)
percent = map(val,0,1023,0,100); // percent will range from 0 to 100.
digitalWrite(ledPin, HIGH); // turn the ledPin on
delay(percent); // On time given by percent value
digitalWrite(ledPin, LOW); // turn the ledPin off
delay(100 - percent); // Off time is 100 minus On time
[Link](percent); // show the % of pot rotation on Serial Monitor
}

154 | Chapter 5: Simple Digital and Analog Input

Discussion
5HFLSHGHVFULEHVKRZWKHSRVLWLRQRIDSRWLVFRQYHUWHGWRDYDOXH+HUH\RXXVH
WKLVYDOXHZLWKWKHmapIXQFWLRQWRVFDOHWKHYDOXHWR\RXUGHVLUHGUDQJH,QWKLVH[DPSOH
WKHYDOXHSURYLGHGE\analogRead0WR1023LVPDSSHGWRDSHUFHQWDJHWR7KH
YDOXHVIURPanalogReadZLOOUDQJHIURP0WR1023LIWKHYROWDJHUDQJHVIURPWRYROWV
EXW\RXFDQXVHDQ\DSSURSULDWHYDOXHVIRUWKHVRXUFHDQGWDUJHWUDQJHV)RUH[DPSOH
DW\SLFDOSRWRQO\URWDWHVGHJUHHVIURPHQGWRHQGDQGLI\RXZDQWHGWRGLVSOD\
WKHDQJOHRIWKHNQRERQ\RXUSRW\RXFRXOGXVHWKLVFRGH
angle = map(val,0,1023,0,270); // angle of pot derived from analogRead val

5DQJHYDOXHVFDQDOVREHQHJDWLYH,I\RXZDQWWRGLVSOD\ 0ZKHQWKHSRWLVFHQWHUHG
DQGQHJDWLYHYDOXHVZKHQWKHSRWLVURWDWHGOHIWDQGSRVLWLYHYDOXHVZKHQLWLVURWDWHG
ULJKW\RXFDQGRWKLV
angle = map(val,0,1023,-135,135); // show angle of 270 degree pot with center
as 0

7KHmapIXQFWLRQFDQEHKDQG\ZKHUHWKHLQSXWUDQJH\RXDUHFRQFHUQHGZLWKGRHVQRW
VWDUWDW]HUR)RUH[DPSOHLI\RXKDYHDEDWWHU\ZKHUHWKHDYDLODEOHFDSDFLW\LVSURSRU
WLRQDOWRDYROWDJHWKDWUDQJHVIURPYROWVPLOOLYROWVWRYROWVPLO
OLYROWV\RXFDQGRWKHIROORZLQJ
const int empty = 5000 / 1100; // the voltage is 1.1 volts (1100mv) when empty
const int full = 5000 / 1500; // the voltage is 1.5 volts (1500mv) when full

int val = analogRead(potPin); // read the analog voltage

int percent = map(val, empty, full, 0,100); // map the actual range of voltage
to a percent
[Link](percent);

6HH5HFLSHIRUPRUHGHWDLOVRQKRZanalogReadYDOXHVUHODWHWRDFWXDOYROWDJH

See Also
7KH$UGXLQRUHIHUHQFHIRUmapKWWSZZZDUGXLQRFFHQ5HIHUHQFH0DS

5.8 Reading More Than Six Analog Inputs

Problem
<RXKDYHPRUHDQDORJLQSXWVWRPRQLWRUWKDQ\RXKDYHDYDLODEOHDQDORJSLQV$VWDQG
DUG$UGXLQRERDUGKDVVL[DQDORJLQSXWVWKH0HJDKDVDQGWKHUHPD\QRWEHHQRXJK
DQDORJLQSXWVDYDLODEOHIRU\RXUDSSOLFDWLRQ3HUKDSV\RXZDQWWRDGMXVWHLJKWSDUDP
HWHUVLQ\RXUDSSOLFDWLRQE\WXUQLQJNQREVRQHLJKWSRWHQWLRPHWHUV

5.8 Reading More Than Six Analog Inputs | 155

Solution
8VHDPXOWLSOH[HUFKLSWRVHOHFWDQGFRQQHFWPXOWLSOHYROWDJHVRXUFHVWRRQHDQDORJ
LQSXW%\VHTXHQWLDOO\VHOHFWLQJIURPPXOWLSOHVRXUFHV\RXFDQUHDGHDFKVRXUFHLQWXUQ
7KLVUHFLSHXVHVWKHSRSXODUFKLSFRQQHFWHGWR$UGXLQRDVVKRZQLQ)LJXUH
<RXUDQDORJLQSXWVJHWFRQQHFWHGWRWKHSLQVPDUNHG&KWR&K0DNHVXUH
WKHYROWDJHRQWKHFKDQQHOLQSXWSLQVLVQHYHUKLJKHUWKDQYROWV
/*
multiplexer sketch
read 1 of 8 analog values into single analog input pin with 4051 multiplexer
*/

// array of pins used to select 1 of 8 inputs on multiplexer

const int select[] = {2,3,4}; // array of the pins connected to the 4051 input
select lines
const int analogPin = 0; // the analog pin connected to the multiplexer
output

// this function returns the analog value for the given channel
int getValue( int channel)
{
// the following sets the selector pins HIGH and LOW to match the binary
value of channel
for(int bit = 0; bit < 3; bit++)
{
int pin = select[bit]; // the pin wired to the multiplexer select bit
int isBitSet = bitRead(channel, bit); // true if given bit set in channel
digitalWrite(pin, isBitSet);
}
return analogRead(analogPin);
}

void setup()
{
for(int bit = 0; bit < 3; bit++)
pinMode(select[bit], OUTPUT); // set the three select pins to output
[Link](9600);
}

void loop () {
// print the values for each channel once per second
for(int channel = 0; channel < 8; channel++)
{
int value = getValue(channel);
[Link]("Channel ");
[Link](channel);
[Link](" = ");
[Link](value);
}
delay (1000);
}

156 | Chapter 5: Simple Digital and Analog Input

)LJXUH7KHPXOWLSOH[HUFRQQHFWHGWR$UGXLQR

Discussion
$QDORJPXOWLSOH[HUVDUHGLJLWDOO\FRQWUROOHGDQDORJVZLWFKHV7KHVHOHFWVRQHRI
HLJKWLQSXWVWKURXJKWKUHHVHOHFWRUSLQV66DQG67KHUHDUHHLJKWGLIIHUHQWFRP
ELQDWLRQVRIYDOXHVIRUWKHWKUHHVHOHFWRUSLQVDQGWKHVNHWFKVHTXHQWLDOO\VHOHFWVHDFK
RIWKHSRVVLEOHELWSDWWHUQVVHH7DEOH
7DEOH7UXWKWDEOHIRUPXOWLSOH[HU
Selector pins Selected input
S2 S1 S0
0 0 0 0
0 0 1 1
0 1 0 2
0 1 1 3
1 0 0 4
1 0 1 5
1 1 0 6
1 1 1 7

<RXPD\UHFRJQL]HWKHSDWWHUQLQ7DEOHDVWKHELQDU\UHSUHVHQWDWLRQRIWKHGHFLPDO
YDOXHVIURPWR
,QWKHSUHFHGLQJVNHWFKgetValue()LVWKHIXQFWLRQWKDWVHWVWKHFRUUHFWVHOHFWRUELWVIRU
WKHJLYHQFKDQQHOXVLQJdigitalWrite(pin, isBitSet)DQGUHDGVWKHDQDORJYDOXHIURP

5.8 Reading More Than Six Analog Inputs | 157

 WKHVHOHFWHGLQSXWZLWKanalogRead(analogPin)7KHFRGHWRSURGXFHWKHELWSDW
WHUQVXVHVWKHEXLOWLQbitReadIXQFWLRQVHH5HFLSH

'RQWIRUJHWWRFRQQHFWWKHJURXQGIURPWKHGHYLFHV\RXDUHPHDVXULQJ
WRWKHJURXQGRQWKHDQG$UGXLQRDVVKRZQLQ)LJXUH

%HDULQPLQGWKDWWKLVWHFKQLTXHVHOHFWVDQGPRQLWRUVWKHHLJKWLQSXWVVHTXHQWLDOO\VR
LWUHTXLUHVPRUHWLPHEHWZHHQWKHUHDGLQJVRQDJLYHQLQSXWFRPSDUHGWRXVLQJanalog
ReadGLUHFWO\,I\RXDUHUHDGLQJHLJKWLQSXWVLWZLOOWDNHHLJKWWLPHVORQJHUIRUHDFK
LQSXWWREHUHDG7KLVPD\PDNHWKLVPHWKRGXQVXLWDEOHIRULQSXWVWKDWFKDQJHYDOXH
TXLFNO\

See Also
Download from Wow! eBook <[Link]>

$UGXLQR3OD\JURXQGWXWRULDOIRUWKHKWWSZZZDUGXLQRFFSOD\JURXQG/HDUQLQJ

&'GDWDVKHHWKWWSZZZIDLUFKLOGVHPLFRPGV&')&'%&SGI
$QDORJGLJLWDO08;EUHDNRXWERDUGGDWDVKHHWKWWSZZZQNFHOHFWURQLFVFRPDQDORJ
GLJLWDOPX[EUHDNRXWKWPO

5.9 Displaying Voltages Up to 5V

Problem
<RXZDQWWRPRQLWRUDQGGLVSOD\WKHYDOXHRIDYROWDJHEHWZHHQDQGYROWV)RU
H[DPSOHVXSSRVH\RXZDQWWRGLVSOD\WKHYROWDJHRIDVLQJOH9FHOORQWKH6HULDO
0RQLWRU

Solution
8VH AnalogRead WR PHDVXUH WKH YROWDJH RQ DQ DQDORJ SLQ &RQYHUW WKH UHDGLQJ WR D
YROWDJHE\XVLQJWKHUDWLRRIWKHUHDGLQJWRWKHUHIHUHQFHYROWDJHYROWVDVVKRZQLQ
)LJXUH

158 | Chapter 5: Simple Digital and Analog Input

)LJXUH0HDVXULQJYROWDJHVXSWRYROWVXVLQJ9ERDUG

7KHVLPSOHVWVROXWLRQXVHVDIORDWLQJSRLQWFDOFXODWLRQWRSULQWWKHYROWDJHWKLVH[DPSOH
VNHWFKFDOFXODWHVDQGSULQWVWKHUDWLRDVDYROWDJH
/*
Display5vOrless sketch
prints the voltage on analog pin to the serial port
Warning - do not connect more than 5 volts directly to an Arduino pin.
*/

const int referenceVolts = 5; // the default reference on a 5-volt board

const int batteryPin = 0; // battery is connected to analog pin 0

void setup()
{
[Link](9600);
}

void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
float volts = (val / 1023) * referenceVolts; // calculate the ratio
[Link](volts); // print the value in volts
}

7KHIRUPXODLV9ROWV DQDORJUHDGLQJDQDORJVWHSV5HIHUHQFHYROWDJH

3ULQWLQJDIORDWLQJSRLQWYDOXHWRWKHVHULDOSRUWZLWK printlnZLOOIRUPDWWKHYDOXHWR
WZRGHFLPDOSODFHV

5.9 Displaying Voltages Up to 5V | 159

 0DNHWKHIROORZLQJFKDQJHLI\RXDUHXVLQJD9ERDUG
const int referenceVolts = 3.3;

)ORDWLQJSRLQWQXPEHUVFRQVXPHORWVRIPHPRU\VRXQOHVV\RXDUHDOUHDG\XVLQJIORDW
LQJSRLQWHOVHZKHUHLQ\RXUVNHWFKLWLVPRUHHIILFLHQWWRXVHLQWHJHUYDOXHV7KHIRO
ORZLQJFRGHORRNVDOLWWOHVWUDQJHDWILUVWEXWEHFDXVH analogReadUHWXUQVDYDOXHRI
1023IRUYROWVHDFKVWHSLQYDOXHZLOOEHGLYLGHGE\,QXQLWVRIPLOOLYROWVWKLV
LVGLYLGHGE\
7KLVFRGHSULQWVWKHYDOXHLQPLOOLYROWV
const int batteryPin = 0;

void setup()
{
[Link](9600);
}

void loop()
{
long val = analogRead(batteryPin); // read the value from the sensor - note
val is a long int
[Link]( (val * (500000/1023)) / 100); // print the value in millivolts
}

7KHIROORZLQJFRGHSULQWVWKHYDOXHXVLQJGHFLPDOSRLQWV,WSULQWV1.5LIWKHYROWDJHLV
YROWV
const int batteryPin 0;

void setup()
{
[Link](9600);
}

void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
[Link](val/(1023/5)); // print the integer value of the voltage
[Link]('.');
[Link](val % (1023/5)); // print the fraction
}

,I\RXDUHXVLQJD9ERDUGFKDQJH(1023/5)WR(int)(1023/3.3)

160 | Chapter 5: Simple Digital and Analog Input

Discussion
7KHanalogRead()IXQFWLRQUHWXUQVDYDOXHWKDWLVSURSRUWLRQDOWRWKHUDWLRRIWKHPHDV
XUHGYROWDJHWRWKHUHIHUHQFHYROWDJHYROWV7RDYRLGWKHXVHRIIORDWLQJSRLQW\HW
PDLQWDLQSUHFLVLRQWKHFRGHRSHUDWHVRQYDOXHVDVPLOOLYROWVLQVWHDGRIYROWVWKHUHDUH
PLOOLYROWVLQYROW%HFDXVHDYDOXHRI1023LQGLFDWHVPLOOLYROWVHDFKXQLW
UHSUHVHQWVGLYLGHGE\PLOOLYROWVWKDWLVPLOOLYROWV7RHOLPLQDWHWKH
GHFLPDOSRLQWWKHYDOXHVDUHPXOWLSOLHGE\,QRWKHUZRUGVPLOOLYROWVWLPHV
GLYLGHGE\JLYHVWKHQXPEHURIPLOOLYROWVWLPHV'LYLGLQJWKLVE\
\LHOGVWKHYDOXHLQPLOOLYROWV,IPXOWLSO\LQJIUDFWLRQDOQXPEHUVE\WRHQDEOHWKH
FRPSLOHUWRSHUIRUPWKHFDOFXODWLRQXVLQJIL[HGSRLQWDULWKPHWLFVHHPVFRQYROXWHG\RX
FDQVWLFNWRWKHVORZHUDQGPRUHPHPRU\KXQJU\IORDWLQJSRLQWPHWKRG
7KLVVROXWLRQDVVXPHV\RXDUHXVLQJDVWDQGDUG$UGXLQRSRZHUHGIURPYROWV,I\RX
DUHXVLQJD9ERDUGWKHPD[LPXPYROWDJH\RXFDQPHDVXUHLVYROWVZLWKRXW
XVLQJDYROWDJHGLYLGHUVHH5HFLSH

5.10 Responding to Changes in Voltage

Problem
<RXZDQWWRPRQLWRURQHRUPRUHYROWDJHVDQGWDNHVRPHDFWLRQZKHQWKHYROWDJHULVHV
RUIDOOVEHORZDWKUHVKROG)RUH[DPSOH\RXZDQWWRIODVKDQ/('WRLQGLFDWHDORZ
EDWWHU\ OHYHOSHUKDSV WR VWDUW IODVKLQJ ZKHQ WKH YROWDJH GURSV EHORZ D ZDUQLQJ
WKUHVKROGDQGLQFUHDVLQJLQXUJHQF\DVWKHYROWDJHGURSVIXUWKHU

Solution
<RXFDQXVHWKHFRQQHFWLRQVVKRZQLQ)LJXUHLQ5HFLSHEXWKHUHZHOOFRPSDUH
WKH YDOXH IURP analogRead WR VHH LI LW GURSV EHORZ D WKUHVKROG 7KLV H[DPSOH VWDUWV
IODVKLQJDQ/('DWYROWVDQGLQFUHDVHVWKHRQWRRIIWLPHDVWKHYROWDJHGHFUHDVHV
EHORZWKHWKUHVKROG,IWKHYROWDJHGURSVEHORZDVHFRQGWKUHVKROGWKH/('VWD\VOLW
/*
RespondingToChanges sketch
flash an LED to indicate low voltage levels
*/

long warningThreshold = 1200; // Warning level in millivolts - LED flashes

long criticalThreshold = 1000; // Critical voltage level - LED stays on

const int batteryPin = 0;

const int ledPin = 13;

void setup()
{
pinMode(ledPin, OUTPUT);
}

5.10 Responding to Changes in Voltage | 161

 void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
if( val < (warningThreshold * 1023L)/5000) {
// in the line above, L following a number makes it a 32 bit value
flash(val) ;
}
}

// function to flash an led with on/off time determined by value passed

as percent
void flash(int percent)
{
digitalWrite(ledPin, HIGH);
delay(percent + 1);
digitalWrite(ledPin, LOW);
delay(100 - percent ); // check delay == 0?
}

Discussion
7KHKLJKOLJKWHGOLQHLQWKLVVNHWFKFDOFXODWHVWKHUDWLRRIWKHYDOXHUHDGIURPWKHDQDORJ
SRUWWRWKHYDOXHRIWKHWKUHVKROGYROWDJH)RUH[DPSOHZLWKDZDUQLQJWKUHVKROGRI
YROWDQGDUHIHUHQFHYROWDJHRIYROWV\RXZDQWWRNQRZZKHQWKHDQDORJUHDGLQJLV
RQHILIWKRIWKHUHIHUHQFHYROWDJH7KHH[SUHVVLRQ1023LWHOOVWKHFRPSLOHUWKDWWKLVLVD
ORQJ LQWHJHU D ELW LQWHJHU VHH 5HFLSH  VR WKH FRPSLOHU ZLOO SURPRWH DOO WKH
YDULDEOHVLQWKLVH[SUHVVLRQWRORQJLQWHJHUVWRSUHYHQWRYHUIORZLQJWKHFDSDFLW\RIDQ
intDQRUPDOELWLQWHJHU
:KHQUHDGLQJDQDORJYDOXHV\RXFDQZRUNLQWKHXQLWVWKDWDUHUHWXUQHGIURPanalog
ReadUDQJLQJIURPWRRU\RXFDQZRUNLQWKHDFWXDOYROWDJHVWKH\UHSUHVHQW
VHH5HFLSH$VLQWKLVUHFLSHLI\RXDUHQRWGLVSOD\LQJYROWDJHLWVVLPSOHUDQG
PRUHHIILFLHQWWRXVHWKHRXWSXWRIanalogReadGLUHFWO\

5.11 Measuring Voltages More Than 5V (Voltage Dividers)

Problem
<RXZDQWWRPHDVXUHYROWDJHVJUHDWHUWKDQYROWV)RUH[DPSOH\RXZDQWWRGLVSOD\
WKHYROWDJHRID9EDWWHU\DQGWULJJHUDQDODUP/('ZKHQWKHYROWDJHIDOOVEHORZD
FHUWDLQOHYHO

Solution
8VHDVROXWLRQVLPLODUWR5HFLSHEXWFRQQHFWWKHYROWDJHWKURXJKDYROWDJHGLYLGHU
VHH)LJXUH)RUYROWDJHVXSWRYROWV\RXFDQXVHWZR.RKPUHVLVWRUV)RU
KLJKHUYROWDJHV\RXFDQGHWHUPLQHWKHUHTXLUHGUHVLVWRUVXVLQJ7DEOH

162 | Chapter 5: Simple Digital and Analog Input

)LJXUH9ROWDJHGLYLGHUIRUPHDVXULQJYROWDJHVJUHDWHUWKDQYROWV

7DEOH5HVLVWRUYDOXHV
Calculation
Max voltage R1 R2 R2(R1 + R2) value of resistorFactor
5 Short (+V connected to None (Gnd connected to None 1023
analog pin) Gnd)
10 1K 1K 1(1 + 1) 511
15 2K 1K 1(2 + 1) 341
20 3K 1K 1(3 + 1) 255
30 4K (3.9K) 1K 1(4 + 1) 170

6HOHFWWKHURZZLWKWKHKLJKHVWYROWDJH\RXQHHGWRPHDVXUHWRILQGWKHYDOXHVIRUWKH
WZRUHVLVWRUV
/*
DisplayMoreThan5V sketch
prints the voltage on analog pin to the serial port
Do not connect more than 5 volts directly to an Arduino pin.
*/

const int referenceVolts = 5; // the default reference on a 5-volt board

//const float referenceVolts = 3.3; // use this for a 3.3-volt board

const int R1 = 1000; // value for a maximum voltage of 10 volts

const int R2 = 1000;
// determine by voltage divider resistors, see text
const int resistorFactor = 1023.0 / (R2/(R1 + R2));
const int batteryPin = 0; // +V from battery is connected to analog pin 0

5.11 Measuring Voltages More Than 5V (Voltage Dividers) | 163

 void setup()
{
[Link](9600);
}

void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio
[Link](volts); // print the value in volts
}

Discussion
/LNHWKHSUHYLRXVDQDORJUHFLSHVWKLVUHFLSHUHOLHVRQWKHIDFWWKDWWKHanalogReadYDOXH
LVDUDWLRRIWKHPHDVXUHGYROWDJHWRWKHUHIHUHQFH%XWEHFDXVHWKHPHDVXUHGYROWDJHLV
Download from Wow! eBook <[Link]>

GLYLGHGE\WKHWZRGURSSLQJUHVLVWRUVWKHanalogReadYDOXHQHHGVWREHPXOWLSOLHGWR
JHW WKH DFWXDO YROWDJH 7KLV FRGH LV VLPLODU WR 5HFLSH  EXW WKH YDOXH RI
resistorFactorLVVHOHFWHGEDVHGRQWKHYROWDJHGLYLGHUUHVLVWRUVDVVKRZQLQ7DEOH
const int resistorFactor = 511; // determine by voltage divider resistors,
see Table 5-3

7KHYDOXHUHDGIURPWKHDQDORJSLQLVGLYLGHGQRWE\EXWE\DYDOXHGHWHUPLQHG
E\WKHGURSSLQJUHVLVWRUV
float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio

7KHFDOFXODWLRQXVHGWRSURGXFHWKHWDEOHLVEDVHGRQWKHIROORZLQJIRUPXODWKHRXWSXW
YROWDJHLVHTXDOWRWKHLQSXWYROWDJHWLPHV5GLYLGHGE\WKHVXPRI5DQG5,QWKH
H[DPSOHZKHUHWZRHTXDOYDOXHUHVLVWRUVDUHXVHGWRGURSWKHYROWDJHIURPD9EDWWHU\
E\KDOIresistorFactorLVKDOIRIVRWKHYDOXHRIWKHvoltsYDULDEOHZLOOEH
WZLFHWKHYROWDJHWKDWDSSHDUVRQWKHLQSXWSLQ:LWKUHVLVWRUVVHOHFWHGIRUYROWVWKH
DQDORJUHDGLQJIURPD9EDWWHU\ZLOOEHDSSUR[LPDWHO\

0RUHWKDQYROWVRQWKHSLQFDQGDPDJHWKHSLQDQGSRVVLEO\GHVWUR\
WKHFKLSGRXEOHFKHFNWKDW\RXKDYHFKRVHQWKHULJKWYDOXHUHVLVWRUV
DQGZLUHGWKHPFRUUHFWO\EHIRUHFRQQHFWLQJWKHPWRDQ$UGXLQRLQSXW
SLQ,I\RXKDYHDPXOWLPHWHUPHDVXUHWKHYROWDJHEHIRUHFRQQHFWLQJ
DQ\WKLQJWKDWFRXOGSRVVLEO\FDUU\YROWDJHVKLJKHUWKDQYROWV

164 | Chapter 5: Simple Digital and Analog Input