arduino pri ruck a program at or a

ARDUINO pruka programtora 1 hobbyrobot.cz

ARDUINO pruka programtora

STRUKTURA PROGRAMU Zkladn struktura programovacho jazyka Arduino je pomrn jednoduch a skld se nejmn ze dvou st, pesnji funkc. Bloky pkaz v tle tchto dvou funkc jsou ohranieny sloenmi zvorkami.

vo id setup() {

p kazy; }

vo id loop() {

p kazy; }

Funkce setup() je ppravn a provd se jen jednou na zatku programu, funkce loop() je vkonn a provd se neustle dokola. Pro sprvnou innost programu je vdy nutn pout ob tyto funkce. Funkce setup() by mla bt volna a po deklaraci vech promnnch na zatku programu. Tato funkce se pouv napklad k nastaven pin Arduina na vstup nebo vstup, nastaven parametr sriov komunikace a podobnch jednorzovch akc. Po funkci setup() nsleduje funkce loop(). Tlo tto funkce obsahuje programov kd, kter bude opakovan provdn v nekonen smyce, napklad ten vstup, nastavovn vstup, vpoty, atd. Tato funkce je jdrem vech program Arduina a vykonv vtinu innost.

setup() Funkce setup(), jak ji bylo eeno ve, se vol pouze jednou pi sputn programu. Pouv se k inicializaci reimu jednotlivch pin, k nastaven sriov komunikace apod. Tato funkce mus bt v programu obsaena vdy, i kdy dn inicializan pkazy neobsahuje.

vo id setup() {

p inMode(pin, OUTPUT); / / nastav 'p in ' na vstup }

loop() Po dokonen funkce setup(), se zane neustle dokola provdt funkce loop(), jak jej nzev (loop = smyka) ostatn napovd. Pkazy, obsaen v tle tto funkce, jsou ureny k provdn veker innosti Arduina.

void loop() {

d ig i ta lW rite(p in, HIGH); / / nastav 'p in ' na log. 1 delay(1000); / / ekej jednu sekundu d ig i ta lW rite(p in, LOW ); / / nastav 'p in ' na log. 0 delay(1000); / / ekej jednu sekundu

}


Syntaxe

{} sloen zvorky Sloen zvorky definuj zatek a konec bloku kdu. Pouvaj se ve funkcch i ve smykch.

type funct ion() {

p kazy; }

Za vodn sloenou zvorkou [ { ] mus vdy nsledovat zvorka uzavrac [ } ]. Proto se asto uvd, e sloen zvorky mus bt provny. Samostatn umstn zvorky (vodn bez uzavrac a naopak) mohou asto vst k zhadnm, patn dohledatelnm chybm kompiltoru. Programov prosted Arduino obsahuje praktickou funkci pro kontrolu provn sloench zvorek. Sta vybrat zvorku, nebo kliknout my bezprostedn pod zvorku a souvisejc zvorka bude zvraznna.

; stednk Stednkem mus bt ukonena deklarace i jednotliv prvky programu. Stednk je tak pouvn k oddlen prvk ve smyce.

int x = 13; / / dek laruje promnnou 'x ' jako datov typ in teger s hodnotou 13

Poznmka: Pokud zapomenete dek programu stednkem ukonit, dojde k chyb kompiltoru. Z chybovho hlen me bt zejm, e se jedn o zapomenut stednk, ovem tak nemus. Pokud se objev hlen o zhadn nebo zdnliv nelogick chyb kompiltoru, zkontrolujte nejprve, zda v zpisu programu nechyb stednk v blzkosti msta, kde kompiltor chybu ohlsil.

/* */ blokov komente Blokov komente, nebo vcedkov komente jsou oblasti textu, kter jsou programem ignorovny. Jsou pouvny pro obsanj komentovn kdu nebo poznmky, kter pomohou pochopit ostatnm vznam st programu. Blokov komente zanaj / * a kon * / a mohou obsahovat vce dk textu.

/* Toto je b lokov koment , nezapome te ho ukon i t . Znaky pro jeho zatek a konec mus bt vdy v pru! */

Vzhledem k tomu, e komente jsou programem ignorovny, nezabraj dn pamov prostor; mohou tedy bt hojn pouvny. Mohou bt tak pouity k doasnmu znefunknn celch blok kdu programu pro ely ladn.

Poznmka: Do blokovho komente je mono vloit i jednodkov komente (uvozen //), ale nen mono do blokovho komente vloit dal blokov koment.

// jednodkov komente Jednotliv dky komente mus zanat // a kon na konci dku. Stejn jako blokov komente jsou jednodkov komente programem ignorovny a nezabraj dn pamov prostor.

/ / toto je jednodkov koment


Jednodkov komente jsou asto pouvny za pkazy k vysvtlen jejich funkce nebo jako poznmka pro dal pouit.

PROMNN Promnn je zpsob pojmenovn a uloen seln hodnoty pro pozdj pouit v programu. Jak jejich nzev naznauje, promnn jsou sla, jejich hodnota me bt prbn zmnna, na rozdl od konstant, jejich hodnota se nikdy nemn. Promnn mus bt deklarovny a voliteln jim lze piadit hodnoty, kter maj bt do nich uloeny. Nsledujc kd deklaruje promnnou nzvem inputVariable a piad j hodnotu, zskanou tenm analogov hodnoty vstupnho pinu 2:

int inputVar iable = 0; / / dek laruje promnnou / / a p iad j hodnotu 0

inputVar iable = analogRead(2) ; / / p iad promnn hodnotu / / podle analogov hodnoty p inu 2

Promnnou pojmenujeme 'InputVariable'. Prvn dek kdu deklaruje, e promnn bude obsahovat datov typ int (zkratka pro nzev integer) a nastav jej hodnotu na 0. Druh dek nastav hodnotu promnn podle hodnoty analogovho na pinu 2, kter je dostupn jinde v programovm kdu. Jakmile byla promnn piazena nebo zmnna hodnota, mete mete pout jej hodnotu pmo nebo testovat, zda tato hodnota spluje urit podmnky. Pklad ukazuje ti uiten operace s promnnmi. Nsledujc kd testuje, zda hodnota promnn inputVariable je men ne 100, je-li to pravda, pak promnn inputVariable piad hodnotu 100, a pak nastav na zklad hodnoty promnn inputVariable prodlevu, kter je nyn minimln 100:

i f ( inputVar iable < 100) / / testuje, zda je hodnota promnn mn ne 100 {

inputVar iable = 100; / / je- l i to pravda, je j p iazena hodnota 100 } delay( inputVar iable); / / poui je hodnotu promnn jako parametr funkce

/ / de lay

Poznmka: Promnnm bychom mli pro lep orientaci v programovm kdu dvat popisn nzvy. Jmna promnnch, jako je tiltSensor nebo pushButton pomhaj programtorovi i komukoli jinmu pi ten kdu snadnji poznat, co promnn znamen. V naich pkladech ale naopak pouvme krtk jmna promnnch (napklad var nebo value), aby byl kd krat a pehlednj. Promnn me bt pojmenovna libovolnm jmnem, kter nepat mezi klov slova v jazyce Arduino.

deklarace promnnch Vechny promnn mus bt deklarovny jet ped jejich prvnm pouitm. Deklarace promnn znamen, e definujete jej typ (int, long, float, atd.), nastavte jej jmno, a ppadn piadte poten hodnotu. Tyto deklarace posta v programu provst jen jednou, hodnotu promnn ale mete v programu kdykoliv zmnit. Nsledujc pklad deklaruje, e promnn inputVariable je typu int neboli integer, a e jej poten hodnota je rovna nule. To se nazv jednoduch piazen.

int inputVar iable = 0;

Promnn me bt deklarovna kdekoli v programu a je pouiteln od msta deklarace dle.


platnost promnnch Promnn me bt deklarovna na zatku programu, jet ped funkc void setup(), lokln uvnit funkce, a nkdy v deklaraci bloku, jako je tomu u smyek. Msto, kde je promnn deklarovna, uruje jej pouitelnost pro nkter sti programu. Globln promnn je ta, ke kter maj pstup a mohou pouvat vechny funkce a deklarace v programu. Takov promnn mus bt deklarovna na zatku programu, jet ped funkc void setup(). Lokln promnn je ta, kter je definovna uvnit funkce nebo jako soust smyky. Je dostupn a me bt pouita pouze uvnit funkce, uvnit kter byla deklarovna. Je tedy mon mt v rznch stech tho programu umstn dv nebo vce promnnch stejnho jmna, kter obsahuj rzn hodnoty. To, e pstup ke svm loklnm promnnm m pouze dan funkce zjednoduuje program a sniuje monost programovch chyb. Nsledujc pklad ukazuje, jakm zpsobem meme deklarovat rzn typy promnnch a pedvd viditelnost kad z promnnch v programu:

int va lue; / / promnn 'va lue' je v idi teln / / pro vechny funkce

void setup() { } / / funkce neobsahuje dn in ic ia l izan p kazy

vo id loop() {

for ( in t i=0; i


p inMode(13, OUTPUT);

Datov typ y

byte Datov typ byte ukld hodnoty jako 8-bitov seln hodnoty bez desetinnch mst. Ukld hodnotu v rozsahu 0-255.

byte someVar iable = 180; / / dek laruje promnnou 'someVar iable' / / jako datov typ byte

int Celoseln datov typ integer je nejbnjm zpsobem ukldn celch sel. Ukld hodnotu jako 16-bitovou v rozsahu -32 768 a 32 767.

int someVar iable = 1500; / / dek laruje promnnou 'someVar iable' / / jako datov typ in teger

Poznmka: Celoseln promnn petee (podtee), pokud dojde k pekroen jej maximln nebo minimln hodnoty. Napklad, je-li x = 32 767 a nsledn operace zvt hodnotu o 1, napklad x = x + 1 nebo x ++, hodnota x je po peteen rovna -32 768.

long Datov typ long (integer) je uren pro velk sla bez desetinnch mst. Ukld hodnotu jako 32-bitovou v rozsahu -2 147 483 648 a 2 147 483 647.

long someVar iable = 90000; / / dek laruje promnnou 'someVar iable' / / jako datov typ long

float Datov typ float je uren pro operace s sly s plovouc desetinnou rkou. sla s plovouc desetinnou rkou maj vt rozlien ne cel sla a jsou uloena jako 32-bitov hodnoty s rozsahem -3,4028235E38 k 3,4028235E38.

f loat someVariable = 3,14; / / dek laruje promnnou 'someVar iable' / / jako datov typ f loat

Poznmka: sla s plovouc desetinnou rkou maj omezenou pesnost, dky n me dojt k problmm pi porovnvn dvou takovch sel. Matematick operace s plovouc desetinnou rkou jsou tak mnohem pomalej ne celoseln aritmetika a je vhodn pokud je to mon se jim vyhbat.

pole Polem se nazv mnoina prvk, ke kterm je mono pistupovat prostednictvm indexace. Libovoln hodnota v poli me bt zpstupnna uvedenm nzvu pole a indexu hodnoty. Pole jsou indexovna od nuly, piem prvn hodnota v poli m index 0. Pole mus bt deklarovna a je jim mono piadit hodnoty dve, ne je meme pout.

int myArray[ ] = {hodnota0, hodnota1, hodnota2. . .}


Stejn tak je mon deklarovat pole tak, e mu urme datov typ a velikost a pozdji mu piadme hodnoty na pozice dan indexem:

int myArray[5]; / / dek laruje pole typu integer se est i prvky myArray[3] = 10; / / p iad tvr tmu prvku pole hodnotu 10

Chcete-li nast do promnn hodnotu z pole, piadme promnn nzev pole a index pozice:

x = myArray[3] ; / / 'x ' se nyn rovn 10

Pole jsou asto pouvna v cyklech for, kde je prstek tae je zrove pouit jako index pozice pro kadou hodnotu pole. V nsledujcm pkladu definujeme pole pro blikn LED. Pouijeme smyku, jej ta zan na 0. Hodnota indexu na pozici 0 z pole 'flicker[]' se zape do promnn 'ledPin' (v tomto ppad 180), na pinu 10, kter je nastaven do analogovho mdu se objev PWM modulace s parametry, urenmi promnnou 'ledPin', pozastav se bh programu na 200 ms. Pak se smyka znovu opakuje, vybere se dal prvek pole podle hodnoty promnn tae atd.

int ledPin = 10; / / LED na pinu 10 byte f l icker[ ] = {180, 30, 255, 200, 10, 90, 150, 60};

/ / vytvo eno pole s osmi prvky rznch hodnot

vo id setup() {

p inMode( ledPin, OUTPUT); / / nastav p in jako VSTUP }

vo id loop() {

for( int i=0; i


Pro sv promnn zvolte vdy takov datov typ, kter doke uloit dostaten velk sla jako vsledky vaich vpot. Mjte na pamti, v kterm okamiku vae promnn petee a tak to, co se stane pi pechodu v opanm smru, nap. (0 -1) nebo (0 -32768). Pro matematiku, kter vyaduje zlomky, zvolte promnn typu float, ale bute si vdomi jejich nedostatk: zabraj vce msta v pamti a vpoet je pomalej.

Poznmka: Pomoc opertoru petypovn nap. (int) myFloat lze pevst jeden typ promnn na jin ani by bylo nutn ukldat petypovanou hodnotu do promnn. Napklad, i = (int) 3,6 nastav i rovno 3.

sloen piazen Sloen piazen kombinuje aritmetick operace s piazenm hodnoty promnn. Tyto operace se bn vyskytuj v cyklech for, jak je popsno dle. Mezi nejastj sloen piazen pat:

x ++ / / je tot jako x = x + 1, tedy zv ten hodnoty x o +1 x -- / / je tot jako x = x 1, tedy zmenen hodnoty x o -1 x += y / / je tot jako x = x + y, tedy zv ten hodnoty x o hodnotu +y x -= y / / je tot jako x = x y, tedy zmenen hodnoty x o hodnotu -y x *= y / / je tot jako x = x * y, tedy vynsoben x y x /= y / / je tot jako x = x / y, tedy pod len x y

Poznmka: Napklad operace x *= 3 ztrojnsob pvodn hodnotu x a znovu j piad vsledn hodnot x.

relan opertory Porovnn jedn promnn nebo konstanty s jinou se asto pouv v testech uvnit pkazu if , kdy se porovnv, zda zadan podmnka plat. Pklady naleznete na nsledujcch strnkch. Znak '??' zastupuje v dalm textu nkterou z nsledujcch podmnek:

x == y / / x je rovno y x != y / / x nen rovno y x < y / / x je men ne y x > y / / x je v t ne y x = y / / x je v t nebo rovno y

logick opertory Logick opertory jsou obvykl zpsob, jak porovnvat dva vrazy. Tyto opertory vrac hodnotu TRUE nebo FALSE v zvislosti na typu operace. K dispozici jsou ti logick opertory, AND, OR a NOT, kter jsou asto pouvan v testu 'if':

Logick AND: i f (x > 0 && x < 5) / / Vrac hodnotu TRUE, kdy oba

/ / vrazy maj hodnotu TRUE

Logick OR: i f (x > 0 | | y > 0) / / Vrac hodnotu TRUE, kdy k terkol i

/ / z prvk m hodnotu TRUE

Logick NOT: i f ( ! x > 0) / / Vrac hodnotu TRUE, kdy oba

/ / prvky maj hodnotu FALSE


zen toku programu

if Pkaz if testuje, zda bylo dosaeno urit podmnky, teba zda analogov hodnota je vt ne zadan, a provd vechny pkazy uvnit zvorek, pokud tvrzen je pravdiv (TRUE). Pokud tvrzen pravdiv nen (FALSE), program pkazy uvnit zvorek pesko. Formt pkazu if je:

i f (someVar iable ?? value) {

p kazy; }

Ve uveden pklad porovnv hodnotu promnn someVariable s jinou hodnotou, kterou me bt opt bu promnn nebo konstanta. Pokud je vsledek porovnn hodnot v zvorce pravda (TRUE), jsou vykonny pkazy uvnit sloench zvorek. Pokud ne, program je pesko a pokrauje za nimi.

Poznmka: Dejte si pozor na nhodn pouit '=' msto '==' v pkazu if (x = 10), zpis je syntakticky sprvn, ale nastavuje hodnotu promnn x na hodnotu 10 a vsledkem je tedy vdy pravda (TRUE). Msto '=' je nutno pout vraz '==', tedy (x == 10), kter jen testuje, zda x se rovn hodnot 10, nebo ne. Myslete na '=' jako na "rovn se" na rozdl od '==' kter znamen "se rovn".

if .. else Operace 'if .. else' umouje rozhodovn stylem 'bu nebo' a vtven programu podle vsledku operace. Napklad, pokud chcete otestovat stav digitlnho vstup a pak provst njakou innost, pokud je vstupn pin ve stavu HIGH nebo naopak provst nco jinho, pokud je vstupn rove nzk, mete to zapsat tmto zpsobem:

i f ( inputPin == HIGH) {

doThingA; } e lse {

doThingB; }

nebo me tak pedchzet jin 'if', pokud testujeme vce vzjemn se vyluujcch podmnek. Testy lze spustit souasn. Je dokonce mon mt neomezen poet tchto vtven else. Pamatujte si vak, e je mono vdy spustit v zvislosti na podmnkch test jen jednu st kdu:

i f ( inputPin < 500) {

doThingA; } e lse i f ( inputPin >= 1000) {

doThingB; } e lse {

doThingC; }


Poznmka: Pkaz if pouze testuje, zda je podmnka v zvorce pravdiv nebo nepravdiv. Touto podmnkou me bt jakkoli platn pkaz jazyka C jako napklad, if (inputPin == HIGH). V tomto pkladu 'if' pouze zkontroluje, zda opravdu m zadan vstup logickou rove HIGH neboli 5 V.

for Pkaz for se pouv k nkolikansobnmu opakovn bloku pkaz, uzavench do sloench zvorek. Zhlav smyky se skld ze t st, oddlench stednkem(;):

for ( in ic ia l izace; podmnka; vraz) { p kazy; }

Nejprve je deklarovna lokln promnn 'i' ve funkci prstkovho tae. Tato promnn se deklaruje jen jednou. Za deklarac promnn nsleduje podmnka, kter se testuje pi kadm prchodu smykou. Dokud je podmnka pravdiv, jsou provedeny pkazy a vrazy, uzaven ve sloench zvorkch a podmnka je znovu testovna. Kdy se podmnka stane nepravdivou, smyka se ukon. Nsledujc pklad testuje hodnotu promnn 'i' typu integer, nastaven na 0 a zjiuje, zda je jej hodnota stle men ne 20. Je-li to pravda, zvt hodnotu promnn 'i' o 1 a provede pkazy, uzaven ve sloench zvorkch:

for ( in t i=0; i


whi le (someVar iable < 200) / / test , zda je promn men ne 200 { p kazy; / / vykonn p kaz someVar iable++; / / zv ten promnn o 1 }

do .. while Tato smyka pracuje stejn jako smyka while, jen s tm rozdlem, e podmnka je testovna nikoli na zatku, ale a na konci smyky, take smyka probhne vdy nejmn jednou.

do {

p kazy; } whi le (someVar iable ?? value) ;

Nsledujc pklad piad funkci readSensors() hodnotu promnn 'x', zastav innost na 50 milisekund, pot bude smyku opakovat, dokud nebude 'x' men ne 100:

do { x = readSensors() ; / / p ia funkci readSensors()

/ / hodnotu promnn 'x ' de lay (50); / / ekej 50 mil isekund } whi le (x < 100); / / znovu na zatek dokud 'x '

/ / nen men ne 100

FUNKCE Funkce je st kdu, kter je pojmenovn a kter ve svm tle obsahuje blok pkaz, kter jsou provedeny pi sputn tto funkce. innosti funkc void setup() a void loop() ji byly popsny ve a dal vestavn funkce budou popsny dle. Vlastn funkce mohou vykonvat opakujc se kony a slou tak k udren pehlednosti programu. Funkce mus bt ped pouitm nejprve deklarovny, ili mus bt uvedeno, jakho jsou typu. To je datov typ hodnoty, kterou bude funkce vracet jako vsledek sv innosti, napklad 'int' (zkratka pro integer), pokud funkce vrac celoselnou hodnotu. Pokud se nem vracet dn hodnota, deklarujeme funkci typu void (przdn). Po uveden typu nsleduje nzev funkce a v zvorce seznam parametr, pedvanch funkci.

type funct ionName(parameters) {

p kazy; }

Nsledujc funkce delayVal() typu integer slou v programu k nastaven velikosti zpodn tenm hodnoty napt z potenciometru. Nejprve deklarujeme lokln promnnou 'v', vlome do n hodnotu, petenou z potenciometru, kter me nabvat hodnoty v rozsahu mezi 0 a 1023, pak podlme tuto hodnotu 4, abychom zskali slo v rozsahu mezi 0 a 255, a nakonec vrtme tuto hodnotu zpt do hlavnho programu.


int delayVal() {

int v; / / vytvo doasnou promnnou 'v ' v = analogRead(pot) ; / / pe te hodnotu potenc iometru v /= 4; / / konveruje s lo z rozsahu 0 a1023 na 0 a 255 return v; / / vrt f in ln hodnotu 'v '

}

Dig i t ln vs tupy a vstupy pinMode(pin, mode)

Tato konstanta se pouv ve funkci void setup() a nastavuje urit pin na vstup (INPUT) nebo vstup (OUTPUT).

pinMode(pin, OUTPUT); / / nastav 'p in ' jako vs tupn

Digitln piny Arduina jsou standardn nastaveny jako vstupn, take je nen nutno do tohoto stavu znovu nastavovat pomoc funkce pinMode(). Piny nakonfigurovan jako vstupn jsou ve stavu vysok impedance. Na piny ale mohou bt pipojeny zdvihac (pull-up) rezistory o velikosti 20 a 50 kOhm, kter jsou obsaeny v intern struktue mikrokontrolru. Ve vchozm nastaven mikrokontrolru jsou tyto zdvihac rezistory odpojeny, ale je mono je programov pipojit. Provd se to nsledujcm zpsobem:

p inMode(pin, INPUT); / / nastav 'p in ' jako vs tupn d ig i ta lW rite(p in, HIGH); / / zapni pul l-up resis tory

Vimnte si, ve ve uvedenm pkladu se nepepn pin na vstup, je to jen zpsob aktivace vnitnho pull-up rezistoru. Pull-up rezistory se bn pouvaj, pokud na vstup pipojujeme napklad spna.

Poznmka: Piny, nakonfigurovan jako vstup, mohou poskytnout proud a 40 mA do jinch zazen i obvod. Takov proud posta pro jasn rozsvcen LED (nezapomete na pedadn rezistor), ale nen to dostaten proud pro sepnut vtiny rel, solenoid nebo motor. Zkraty na pinech Arduina nebo jejich zaten nadmrnm proudem me obvod vstupnho pinu pokodit nebo zniit, ppadn pokodit cel ip ATmega. Proto je vhodn pi pipojovn vstupnho pinu k externmu zazen pout rezistor s odporem 470 nebo 1 k, zapojenm v srii s pipojovanm zazenm.

digitalRead(pin) Funkce digitalRead(pin) pete hodnoty z urenho digitlnho pinu. Vsledkem je vysok nebo nzk rove. Pin me bt zadn bu jako promnn nebo jako konstanta (0-13).

va lue = dig ita lRead(Pin); / / nastav promnnou 'va lue' do s tejnho / / s tavu, jako m vstupn p in

digitalWrite(pin, value) Nastav zadan digitln pin na vysokou (H) nebo nzkou (L) rove. slo pinu me bt zadno bu jako promnn nebo jako konstanta (0-13).

d ig i ta lW rite(p in, HIGH); / / nastav 'p in ' na HIGH

Nsledujc pklad te stav tlatka, pipojenho na digitln vstup a pokud je sepnuto, rozsvt LED, pipojenou k digitln vstup.


int led = 13; / / p ipoj LED na p in 13 int p in = 7; / / p ipoj t la tko na pin 7 int va lue = 0; / / promnn pro uloen pe ten hodnoty void setup() { p inMode( led, OUTPUT); / / nastav p in 13 jako vs tup p inMode(pin, INPUT); / / nastav p in 7 jako vs tup } vo id loop() { va lue = dig ita lRead(pin); / / v lo do promnn 'va lue' s tav

/ / vs tupnho p inu d ig i ta lW rite( led, va lue); / / nastav hodnotu promnn ' led ' podle } / / s tavu t la tka

Analogo v vs tupy a vstupy analogRead(pin)

Pete hodnotu napt z urenho analogovho pinu v 10-bitovm rozlienm. Tato funkce pracuje pouze s analogovmi piny (0-5). Vsledn hodnota je celoseln s rozsahem od 0 do 1023.

va lue = analogRead(pin); / / nastav hodnotu promnn 'va lue' / / na hodnotu promnn 'p in '

Poznmka: Analogov piny na rozdl od tch digitlnch, nemus bt nejprve deklarovny jako vstupn nebo vstupn.

analogWrite(pin, value) Zape pseudo-analogov hodnoty, generovan pomoc hardwarov zen pulsn kov modulace (PWM) na vstupn piny oznaen jako PWM. Na novjch Arduinech s ipy ATmega168, tato funkce pracuje na pinech 3, 5, 6, 9, 10 a 11. U starch Arduina s ipy ATmega8 jsou k dispozici pouze piny 9, 10 a 11. Hodnota v rozsahu 0-255 me bt zadna jako promnn nebo konstanta.

analogW rite(p in, va lue); / / zape 'va lue' analogov na 'p in '

Hodnota 0, zapsan do 'value' nastavuje na zadanm vstupnm pinu napt 0 volt (log.0), hodnota 255 nastavuje na zadanm vstupnm pinu napt 5 volt (log.1). Aby bylo mono doshnout hodnot napt mezi 0 a 5 volty, std se na vstupnm pinu hodnota 0 a 1. Pomr tohoto stdn je uren hodnotou 'value' (0 a 255) m vy hodnota, tm dle je na pinu vysok logick rove (5 V). Napklad, pro hodnotu 64 je na pinu rove 0 ti tvrtiny asu, a 1 tvrtinu asu, pro hodnotu 128 bude na pinu rove 0 polovinu asu a 1 druhou polovinu, a hodnota 192 znamen, e na pinu bude hodnota 0 tvrtinu asu a 1 ti tvrtiny asu. Protoe se jedn o hardwarovou funkci, bude pin po zavoln funkce analogWrite na pozad bhu programu generovat nastavenou PWM a do ptho voln funkce analogWrite (nebo do zavoln funkce digitalRead i digitalWrite na stejnm pinu).

Poznmka: Analogov piny na rozdl od tch digitlnch, nemus bt nejprve deklarovny jako vstupn nebo vstupn.

Nsledujc pklad te analogovou hodnotu ze vstupnho pinu, uprav jej hodnotu vydlenm tymi a vstupy PWM signl na pinu PWM:


int led = 10; / / LED s rezis torem 220 ohm na p inu 10 int p in = 0; / / potenc iometer na analogov p in 0 int va lue; / / def in ice promnn value void setup() {} / / dn nastaven nen potebn void loop() { va lue = analogRead(pin); / / pepi hodnotu 'va lue' do 'p in ' va lue /= 4; / / konvertuj rozsah 0-1023 na 0-255 analogW rite( led, va lue); / / vy l i vstupn PW M signal na p in led }

asovn

delay(ms) Pozastav program na dobu urenou v milisekundch, hodnota 1000 tedy odpovd jedn sekund.

de lay(1000); / / ekej jednu sekundu

millis() Vrac poet milisekund od okamiku rozbhu aktulnho programu na desce Arduino ve formtu unsigned long.

va lue = mil l is() ; / / nastav 'va lue' shodn s mil l is()

Poznmka: Hodnota tto promnn petee (peto se zpt na nulu), piblin po 9 hodinch nepetritho bhu Arduina.

Matemat ick funkce

min(x, y) Vypot pomr dvou sel jakhokoli datovho typu a vrt men z nich.

va lue = min(value, 100); / / nastav 'va lue' na men z hodnot / / 'va lue' nebo 100, m zaj is t , e / / promnn 'va lue' nepekro 100

max(x, y) Vypot pomr dvou sel jakhokoli datovho typu a vrt vt z nich.

va lue = max(value, 100); / / nastav 'va lue' na v t z hodnot / / 'va lue' nebo 100, m zaj is t , e / / promnn 'va lue' nek lesne pod 100


Nhodn s la

randomSeed(seed) Nastavuje hodnotu nebo semnko jako vchoz bod pro funkci random().

randomSeed(value); / / poui j hodnotu promnn 'va lue ' jako semnko

Vzhledem k tomu, Arduino nen schopno vytvoit skuten nhodn slo, funkce randomSeed umouje umstit promnnou, konstantu, nebo jinou funkci do funkce random. Tento postup pomh vytvoit nhodnj "nhodn" sla. Existuje cel ada rznch semnek nebo funkc, kter mohou bt pouity jako zklad funkce random, vetn funkce Millis() nebo dokonce funkce analogRead(), kter me st elektrick um pes analogov pin.

Poznmka: Random seed (nhodn semnko) je nhodn slo (nebo pole), kter se pouv pi inicializaci genertoru pseudonhodnch sel. Genertor pi pouit jinho semnka vrac jinou sekvenci pseudonhodnch dat.

random(max) random(min, max) Funkce random vrac pseudo-nhodn sla v rozsahu, stanovenm hodnotami min a max.

va lue = random(100, 200) ; / / zapi do 'va lue' nhodn / / s lo mezi 100-200

Poznmka: Nejprve pouijte funkci randomSeed().

Nsledujc pklad vytvo nhodnou hodnotu mezi 0-255 a pouije ji pro zen rovn PWM signlu pinu PWM:

int randNumber ; / / promnn pro uloen nhodnho s la int led = 10; / / LED s rezis torem 220 ohm na p in 10

vo id setup() { } / / n ic se nenastavuje

vo id loop() {

randomSeed(mil l is()) ; / / poui j funkci mil l is() jako semnko randNumber = random(255) ; / / u lo nhodn s lo mezi 0-255 do promnn analogW rite( led, randNumber); / / zapi hodnotu promnn na vs tup delay(500) ; / / ekej 0,5 sekundy

}


Komunikace

Serial.begin(rate) Oteve sriov port a nastav komunikan rychlost pro penos dat. Typick penosov rychlost pro komunikaci s potaem je 9600 bps, ale jsou podporovny i jin penosov rychlosti.

vo id setup() {

Ser ia l .begin(9600) ; / / o tev i sr iov port } / / nastav penosovou rychlos t na 9600 bps

Poznmka: Pi pouit sriov komunikace nelze pout piny 0 (RX) a 1 (TX) souasn jako digitln.

Serial.println(data) Odele data na sriov port a pid k nim automaticky znak CR a LF. Tento pkaz m stejn tvar jako Serial.print(), ale jednodueji se s nm pracuje, pokud zobrazujeme data v programu Serial Monitor.

Ser ia l .pr int ln(analogValue); / / odel i hodnotu / / promnn 'analogValue'

Poznmka: Dal informace o rznch monostech funkc Serial.println() a Serial.print() naleznete na webovch strnkch Arduino.cc.

Nsledujc jednoduch pklad te data z analogovho pinu 0 a odesl tato data jednou za sekundu do potae.

vo id setup() {

Ser ia l .begin(9600) ; / / nastav komunikan rychlos t na 9600bps } vo id loop() {

Ser ia l .pr int ln(analogRead(0)) ; / / odel i analogovou hodnotu delay(1000); / / ekej 1 sekundu

}

arduino pri ruck a program at or a

Documents