Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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
0DVWHU3XEOLVKLQJDQG3K\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
YROWDJHRQDSLQLVHIGHYROWVRULOWYROWV7KH$UGXLQRIXQFWLRQWRFRQILJXUHD
SLQIRUUHDGLQJLQSXWLVpinMode(pin, INPUT)
2QDW\SLFDOERDUGWKHUHDUHGLJLWDOSLQVQXPEHUHGWRDVVKRZQDWWKHWRSRI
)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
EHFDXVHWKHYROWDJHLVSXOOHGXSWRWKH9OLQHWKDWWKHUHVLVWRULVFRQQHFWHGWRRU
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
$SLQPXVWEHVHWWROUTPUTPRGHIRUdigitalWriteWRFRQWUROWKHSLQV
RXWSXWYROWDJH,WPXVWEHLQINPUTPRGHWRUHDGWKHGLJLWDOLQSXW
'RQRWFRQQHFWDGLJLWDORUDQDORJSLQWRDYROWDJHKLJKHUWKDQYROWV
RUYROWVRQD9ERDUG7KLVFDQGDPDJHWKHSLQDQGSRVVLEO\
GHVWUR\WKHHQWLUHFKLS$OVRPDNHVXUH\RXGRQWZLUHWKHVZLWFKVR
WKDWLWVKRUWVWKHYROWVWRJURXQGZLWKRXWDUHVLVWRU$OWKRXJKWKLV
PD\QRWGDPDJHWKH$UGXLQRFKLSLWLVQRWJRRGIRUWKHSRZHUVXSSO\
7KHVZLWFKXVHGLQWKLVH[DPSOHDQGDOPRVWHYHU\ZKHUHHOVHLQWKLV
ERRNPDNHVHOHFWULFDOFRQWDFWZKHQSUHVVHGDQGEUHDNVFRQWDFWZKHQ
QRWSUHVVHG7KHVHVZLWFKHVDUHFDOOHG1RUPDOO\2SHQ12VHHWKLV
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
}
)LJXUH6ZLWFKFRQQHFWHGXVLQJSXOOXSUHVLVWRU
See Also
7KH$UGXLQRUHIHUHQFHIRUdigitalReadKWWSDUGXLQRFFHQ5HIHUHQFH'LJLWDO5HDG
7KH$UGXLQRUHIHUHQFHIRUdigitalWriteKWWSDUGXLQRFFHQ5HIHUHQFH'LJLWDO:ULWH
7KH$UGXLQRUHIHUHQFHIRUpinModeKWWSDUGXLQRFFHQ5HIHUHQFH3LQ0RGH
7KH$UGXLQRUHIHUHQFHVIRUFRQVWDQWVHIGH LOWHWFKWWSDUGXLQRFFHQ5HIHUHQFH
&RQVWDQWV
$UGXLQRWXWRULDORQGLJLWDOSLQVKWWSDUGXLQRFFHQ7XWRULDO'LJLWDO3LQV
)LJXUH6ZLWFKZLUHGIRUXVHZLWKLQWHUQDOSXOOXSUHVLVWRU
7KHVZLWFKLVRQO\FRQQHFWHGEHWZHHQSLQDQG*QG*QGLVVKRUWIRUJURXQGDQGLV
DWYROWVE\GHILQLWLRQ
/*
Pullup sketch
a switch connected to pin 2 lights the LED on pin 13
*/
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inputPin, INPUT);
digitalWrite(inputPin,HIGH); // turn on internal pull-up on the inputPin
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 <www.wowebook.com>
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
// debounce returns true if the switch in the given pin is closed and stable
boolean debounce(int pin)
{
boolean state;
boolean previousState;
return state;
}
void setup()
{
pinMode(inputPin, INPUT);
pinMode(ledPin, OUTPUT);
}
void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH);
}
}
)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);
void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH);
count++; // increment count
Serial.println(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
Solution
7KHIROORZLQJVNHWFKGHPRQVWUDWHVWKHVHWWLQJRIDFRXQWGRZQWLPHU7KHZLULQJLVWKH
VDPHDVLQ)LJXUHIURP5HFLSH3UHVVLQJDVZLWFKVHWVWKHWLPHUE\LQFUHPHQWLQJ
WKHWLPHUFRXQWUHOHDVLQJWKHVZLWFKVWDUWVWKHFRXQWGRZQ7KHFRGHGHERXQFHVWKH
VZLWFKDQGDFFHOHUDWHVWKHUDWHDWZKLFKWKHFRXQWHULQFUHDVHVZKHQWKHVZLWFKLVKHOG
IRUORQJHUSHULRGV7KHWLPHUFRXQWLVLQFUHPHQWHGE\RQHZKHQWKHVZLWFKLVLQLWLDOO\
SUHVVHGDIWHUGHERXQFLQJ+ROGLQJWKHVZLWFKIRUPRUHWKDQRQHVHFRQGLQFUHDVHVWKH
LQFUHPHQWUDWHE\IRXUKROGLQJWKHVZLWFKIRUIRXUVHFRQGVLQFUHDVHVWKHUDWHE\WHQ
*/
const int ledPin = 13; // the number of the output pin
const int inPin = 2; // the number of the input pin
void setup()
{
pinMode(inPin, INPUT);
digitalWrite(inPin, HIGH); // turn on pull-up resistor
pinMode(ledPin, OUTPUT);
Serial.begin(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
}
}
// 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
Discussion
7KHKHDUWRIWKLVUHFLSHLVWKH switchTimeIXQFWLRQ7KLVUHWXUQVWKHQXPEHURIPLOOL
VHFRQGV WKDW WKH VZLWFK KDV EHHQ SUHVVHG %HFDXVH WKLV UHFLSH XVHV LQWHUQDO SXOOXS
UHVLVWRUVVHH5HFLSHWKH 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
7KLVDSSURDFKWRGHERXQFLQJFDQEHKDQG\LI\RXKDYHPRUHWKDQRQHVZLWFKEHFDXVH
\RXFDQSHHNLQDQGORRNDWWKHDPRXQWRIWLPHDVZLWFKKDVEHHQSUHVVHGDQGSURFHVV
RWKHUWDVNVZKLOHZDLWLQJIRUDVZLWFKWREHFRPHVWDEOH7RLPSOHPHQWWKLV\RXQHHG
WR VWRUH WKH FXUUHQW VWDWH RI WKH VZLWFK SUHVVHG RU QRW DQG WKH WLPH WKH VWDWH ODVW
void setup()
{
pinMode(switchAPin, INPUT);
digitalWrite(switchAPin, HIGH); // turn on pull-up resistors
pinMode(switchBPin, INPUT);
digitalWrite(switchBPin, HIGH); // turn on pull-up resistors
Serial.begin(9600);
}
void loop()
{
unsigned long time;
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
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
*/
// 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()
{
Serial.begin(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
Serial.print("Got key ");
Serial.println(key);
}
}
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
KLJKSXOOHGXSXQOHVVDVZLWFKLVFORVHGFORVLQJDVZLWFKSURGXFHVDLOWVLJQDORQWKH
LQSXWSLQ,IWKH\DUH LOWWKLVLQGLFDWHVWKDWWKHVZLWFKIRUWKDWURZDQGFROXPQLV
FORVHG$GHOD\LVXVHGWRHQVXUHWKDWWKHVZLWFKLVQRWERXQFLQJVHH5HFLSHWKH
FRGHZDLWVIRUWKHVZLWFKWREHUHOHDVHGDQGWKHFKDUDFWHUDVVRFLDWHGZLWKWKHVZLWFK
LVIRXQGLQWKHkeymapDUUD\DQGUHWXUQHGIURPWKHIXQFWLRQ$0LVUHWXUQHGLIQRVZLWFK
LVSUHVVHG
$OLEUDU\LQWKH$UGXLQR3OD\JURXQGWKDWLVVLPLODUWRWKHSUHFHGLQJH[DPSOHSURYLGHV
PRUHIXQFWLRQDOLW\7KHOLEUDU\PDNHVLWHDVLHUWRKDQGOHGLIIHUHQWQXPEHUVRINH\VDQG
LWFDQEHPDGHWRZRUNZKLOHVKDULQJVRPHRIWKHSLQVZLWKDQ/&'<RXFDQILQGWKH
OLEUDU\DWKWWSZZZDUGXLQRFFSOD\JURXQG0DLQ.H\SDG7XWRULDO
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\LQWKHPLGGOHLVFRQQHFWHGWRDZLSHUWKDWFDQEHURWDWHGWR
PDNH FRQWDFW DQ\ZKHUH RQ WKH UHVLVWLYH PDWHULDO $V WKH SRWHQWLRPHWHU URWDWHV WKH
UHVLVWDQFHEHWZHHQWKHZLSHUDQGRQHRIWKHSLQVLQFUHDVHVZKLOHWKHRWKHUGHFUHDVHV
7KHVFKHPDWLFGLDJUDPIRUWKLVUHFLSH)LJXUHPD\KHOS\RXYLVXDOL]HKRZDSR
WHQWLRPHWHUZRUNVDVWKHZLSHUPRYHVWRZDUGWKHERWWRPHQGWKHZLSHUWKHOLQHZLWK
,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
Solution
8VHWKH$UGXLQRmapIXQFWLRQWRVFDOHYDOXHVWRWKHUDQJH\RXZDQW7KLVVNHWFKUHDGV
WKHYROWDJHRQDSRWLQWRWKHYDULDEOH valDQGVFDOHVWKLVIURPWRDVWKHSRWLV
URWDWHGIURPRQHHQGWRWKHRWKHU,WEOLQNVDQ/('ZLWKDUDWHSURSRUWLRQDOWRWKH
YROWDJHRQWKHSLQDQGSULQWVWKHVFDOHGUDQJHWRWKHVHULDOSRUWVHH 5HFLSHIRU
LQVWUXFWLRQVRQPRQLWRULQJWKHVHULDOSRUW5HFLSHVHH)LJXUHVKRZVKRZWKH
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
Serial.begin(9600);
}
void loop() {
int val; // The value coming from the sensor
int percent; // The mapped value
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
WLRQDOWRDYROWDJHWKDWUDQJHVIURPYROWVPLOOLYROWVWRYROWVPLO
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
6HH5HFLSHIRUPRUHGHWDLOVRQKRZanalogReadYDOXHVUHODWHWRDFWXDOYROWDJH
See Also
7KH$UGXLQRUHIHUHQFHIRUmapKWWSZZZDUGXLQRFFHQ5HIHUHQFH0DS
// 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
Serial.begin(9600);
}
void loop () {
// print the values for each channel once per second
for(int channel = 0; channel < 8; channel++)
{
int value = getValue(channel);
Serial.print("Channel ");
Serial.print(channel);
Serial.print(" = ");
Serial.println(value);
}
delay (1000);
}
Discussion
$QDORJPXOWLSOH[HUVDUHGLJLWDOO\FRQWUROOHGDQDORJVZLWFKHV7KHVHOHFWVRQHRI
HLJKWLQSXWVWKURXJKWKUHHVHOHFWRUSLQV66DQG67KHUHDUHHLJKWGLIIHUHQWFRP
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
'RQWIRUJHWWRFRQQHFWWKHJURXQGIURPWKHGHYLFHV\RXDUHPHDVXULQJ
WRWKHJURXQGRQWKHDQG$UGXLQRDVVKRZQLQ)LJXUH
%HDULQPLQGWKDWWKLVWHFKQLTXHVHOHFWVDQGPRQLWRUVWKHHLJKWLQSXWVVHTXHQWLDOO\VR
LWUHTXLUHVPRUHWLPHEHWZHHQWKHUHDGLQJVRQDJLYHQLQSXWFRPSDUHGWRXVLQJanalog
ReadGLUHFWO\,I\RXDUHUHDGLQJHLJKWLQSXWVLWZLOOWDNHHLJKWWLPHVORQJHUIRUHDFK
LQSXWWREHUHDG7KLVPD\PDNHWKLVPHWKRGXQVXLWDEOHIRULQSXWVWKDWFKDQJHYDOXH
TXLFNO\
See Also
Download from Wow! eBook <www.wowebook.com>
$UGXLQR3OD\JURXQGWXWRULDOIRUWKHKWWSZZZDUGXLQRFFSOD\JURXQG/HDUQLQJ
&'GDWDVKHHWKWWSZZZIDLUFKLOGVHPLFRPGV&')&'%&SGI
$QDORJGLJLWDO08;EUHDNRXWERDUGGDWDVKHHWKWWSZZZQNFHOHFWURQLFVFRPDQDORJ
GLJLWDOPX[EUHDNRXWKWPO
Solution
8VH AnalogRead WR PHDVXUH WKH YROWDJH RQ DQ DQDORJ SLQ &RQYHUW WKH UHDGLQJ WR D
YROWDJHE\XVLQJWKHUDWLRRIWKHUHDGLQJWRWKHUHIHUHQFHYROWDJHYROWVDVVKRZQLQ
)LJXUH
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.
*/
void setup()
{
Serial.begin(9600);
}
void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
float volts = (val / 1023) * referenceVolts; // calculate the ratio
Serial.println(volts); // print the value in volts
}
)ORDWLQJSRLQWQXPEHUVFRQVXPHORWVRIPHPRU\VRXQOHVV\RXDUHDOUHDG\XVLQJIORDW
LQJSRLQWHOVHZKHUHLQ\RXUVNHWFKLWLVPRUHHIILFLHQWWRXVHLQWHJHUYDOXHV7KHIRO
ORZLQJFRGHORRNVDOLWWOHVWUDQJHDWILUVWEXWEHFDXVH analogReadUHWXUQVDYDOXHRI
1023IRUYROWVHDFKVWHSLQYDOXHZLOOEHGLYLGHGE\,QXQLWVRIPLOOLYROWVWKLV
LVGLYLGHGE\
7KLVFRGHSULQWVWKHYDOXHLQPLOOLYROWV
const int batteryPin = 0;
void setup()
{
Serial.begin(9600);
}
void loop()
{
long val = analogRead(batteryPin); // read the value from the sensor - note
val is a long int
Serial.println( (val * (500000/1023)) / 100); // print the value in millivolts
}
7KHIROORZLQJFRGHSULQWVWKHYDOXHXVLQJGHFLPDOSRLQWV,WSULQWV1.5LIWKHYROWDJHLV
YROWV
const int batteryPin 0;
void setup()
{
Serial.begin(9600);
}
void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
Serial.println(val/(1023/5)); // print the integer value of the voltage
Serial.print('.');
Serial.println(val % (1023/5)); // print the fraction
}
,I\RXDUHXVLQJD9ERDUGFKDQJH(1023/5)WR(int)(1023/3.3)
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
*/
void setup()
{
pinMode(ledPin, OUTPUT);
}
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\
Solution
8VHDVROXWLRQVLPLODUWR5HFLSHEXWFRQQHFWWKHYROWDJHWKURXJKDYROWDJHGLYLGHU
VHH)LJXUH)RUYROWDJHVXSWRYROWV\RXFDQXVHWZR.RKPUHVLVWRUV)RU
KLJKHUYROWDJHV\RXFDQGHWHUPLQHWKHUHTXLUHGUHVLVWRUVXVLQJ7DEOH
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.
*/
void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor
float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio
Serial.println(volts); // print the value in volts
}
Discussion
/LNHWKHSUHYLRXVDQDORJUHFLSHVWKLVUHFLSHUHOLHVRQWKHIDFWWKDWWKHanalogReadYDOXH
LVDUDWLRRIWKHPHDVXUHGYROWDJHWRWKHUHIHUHQFH%XWEHFDXVHWKHPHDVXUHGYROWDJHLV
Download from Wow! eBook <www.wowebook.com>
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\KDOIresistorFactorLVKDOIRIVRWKHYDOXHRIWKHvoltsYDULDEOHZLOOEH
WZLFHWKHYROWDJHWKDWDSSHDUVRQWKHLQSXWSLQ:LWKUHVLVWRUVVHOHFWHGIRUYROWVWKH
DQDORJUHDGLQJIURPD9EDWWHU\ZLOOEHDSSUR[LPDWHO\
0RUHWKDQYROWVRQWKHSLQFDQGDPDJHWKHSLQDQGSRVVLEO\GHVWUR\
WKHFKLSGRXEOHFKHFNWKDW\RXKDYHFKRVHQWKHULJKWYDOXHUHVLVWRUV
DQGZLUHGWKHPFRUUHFWO\EHIRUHFRQQHFWLQJWKHPWRDQ$UGXLQRLQSXW
SLQ,I\RXKDYHDPXOWLPHWHUPHDVXUHWKHYROWDJHEHIRUHFRQQHFWLQJ
DQ\WKLQJWKDWFRXOGSRVVLEO\FDUU\YROWDJHVKLJKHUWKDQYROWV