upravljanje napravama spojenim preko ...programiranje u arduino jeziku koji je nastao iz jezika...
Post on 26-Dec-2019
5 Views
Preview:
TRANSCRIPT
SVEUČILIŠTE U ZAGREBU
FAKULTET ELEKTROTEHNIKE I RAČUNARSTVA
ZAVRŠNI RAD br. 4420
UPRAVLJANJE NAPRAVAMA SPOJENIM PREKO ARDUINO PLATFORME KROZ ARHITEKTURU INTERNETA STVARI
Roko Lisica
Zagreb, lipanj 2016.
3
SADRŽAJ
Sadržaj ................................................................................................................... 3
1. Uvod ................................................................................................................ 4
2. Arduino ............................................................................................................ 5
2.1. Uvodno o Arduinu ..................................................................................... 5
2.2. Razvoj za Arduino platformu ..................................................................... 6
2.2.1. Arduino programski jezik .................................................................... 7
2.2.2. Pisanje programa za Arduino ............................................................. 7
2.2.3. Biblioteke za Arduino .......................................................................... 9
3. Arduino periferija ............................................................................................ 11
3.1. Grove Starter Kit Plus .............................................................................. 12
3.1.1. Grove Base Shield ............................................................................ 12
3.1.2. Grove senzor temperature ................................................................ 13
3.1.3. Grove senzor zvuka .......................................................................... 14
3.1.4. Grove servo motor ............................................................................ 17
3.1.5. Ostale Grove komponente ................................................................ 17
3.2. Programska podrška za Grove Starter Kit Plus ....................................... 17
3.2.1. Implementacija programske podrške ................................................ 17
3.2.2. Korištenje programske potpore ......................................................... 20
3.2.3. Komentari za budući rad ................................................................... 22
4. Zaključak ........................................................................................................ 23
Literatura .............................................................................................................. 24
Sažetak ................................................................................................................ 25
Summary .............................................................................................................. 26
4
1. UVOD
Arduino je platforma koja je svijet ugradbenih sustava približila svim programerima
svojom lakoćom korištenja. Danas se u kontekstu ugradbenih sustava često
spominje i Internet Stvari (engl. Internet of Things). To je pojam koji označava
povezivanje malih sustava ugrađenih u stvari iz okoline u mrežu preko koje će se
razmjenjivati podatci. Arduino, kao savršen primjer jednostavne upravljačke
komponente, može poslužiti kao „jezgra“ koja upravlja senzore, motore i slično u
Internetu Stvari. Ovaj rad će objasniti princip korištenja Arduino platforme općenito
te u kombinaciji s Grove Starter Kit Plus ispitnim kompletom perifernih
komponenata. Pred kraj bit će riječi i o udaljenoj kontroli komponente te komunikaciji
s njome.
Rad je podjeljen u četiri poglavlja. U drugom poglavlju je općenito opisana Arduino
platforma te je dan kratak uvod u njeno korištenje. U trećem poglavlju opisane su
komponente Grove Starter Kit Plus kompleta, način na koji se one koriste, te je dan
primjer jednostavnog upravljačkog programa. U četvrtom poglavlju je zaključak o
temi.
5
2. ARDUINO
2.1. Uvodno o Arduinu
Arduino je razvojna platforma koja povezuje sklopovlje i softverske alate koji su
jednostavni za korištenje i usmjereni prema izradi prototipova i manjih projekata. I
izvorni kod koji stoji iza programskih alata i dizajn po kojem je rađeno Arduino
sklopovlje su javno dostupni (open-source). [1]
Arduino ploče su najrašireniji komercijalno dostupni dijelovi Arduino sklopovlja.
Arduino ploča je spoj sklopovlja čiju jezgru čini mikrokontroler, najčešće iz AVR
porodice. One se nazivaju mikrokontrolerima na jednoj ploči jer, osim samog
mikrokontrolera, imaju i ostale komponente nužne za izvedbu bilo kakvog
upravljačkog sklopa, npr. programska i podatkovna memorija, generator takta,
ulazno-izlazna sučelja i slično. Najčešće korištena ploča, koja se koristila i za
potrebe ovog rada je Arduino Uno (poznata i kao Genuino Uno) (slika 2.1.)[2]. Zato
što je dizajn Arduino ploča javno dostupan i slobodan korištenje, mnoge tvrtke
proizvode kopije, različite verzije i nadogradnje originalnih Arduino ploča.
Slika 2.1. Arduino Uno ploča [3]
Arduino IDE je softverski dio Arduino platforme. Taj IDE nudi okruženje za
programiranje u Arduino jeziku koji je nastao iz jezika Wiring te je srodan C-u i C++-
u. Programi namijenjeni izvođenju na Arduino ploči se u literaturi nazivaju „skice“
(engl. sketch). IDE nudi mogućnosti verificiranja (statičke analize grešaka),
6
prevođenja i prenošenja prevedenih skica na ploču, upravljanja vanjskim
bibliotekama te povezivanja s pločom preko serijskog sučelja. Izvorni kodovi IDE-a
i temeljnih biblioteka se izdaju pod GPL i GLPL dozvolama, a dostupni su na GitHub
stanici projekta. [1,4,5]
2.2. Razvoj za Arduino platformu
Arduino Uno, kao i većina novijih Arduino ploča, na svom AVR mikrokontroleru ima
ugrađen firmware za učitavanje programa (engl. bootloader) koji otklanja potrebu za
vanjskim programatorom. Taj firmware učitava podatke sa serijske veze i sprema ih
u programsku memoriju ploče. Osobno računalo na taj način postaje „programator“
Arduino ploče kad je na nju serijski spojeno. Arduino Uno ima USB priključak i
odgovarajući prilagodnik, što znači da bi se skoro svako osobno računalo trebalo
moći povezati s Arduino pločom. [2]
Sam proces je dosta jednostavan, jednom kad imamo spreman kod kojeg želimo
pokretati s ploče, povežemo ploču i računalo pomoću USB kabela, podesimo opcije
serijskog porta u IDE-u i odaberemo opciju upload u alatnoj traci ili izborniku Sketch.
IDE će, prije nego se program pošalje na ploču, verificirati kod i prevesti ga za
odgovarajuću arhitekturu mikrokontrolera. Ako verifikacija ne prođe, program se
neće slati na ploču. [4]
Arduino Uno ima 32 KB programske i 2 KB podatkovne memorije. [2] IDE će nas
upozoriti ako je program koji pokušavamo poslati prevelik za Arduino ploču koju
koristimo ili ako smo svu podatkovnu memoriju potrošili na globalne varijable. IDE,
naravno, ne može predvidjeti koliko će memorije zauzeti podaci na stogu i gomili za
vrijeme izvršavanja programa, na to mora paziti sam programer. Ako potroši svu
dostupnu podatkovnu memoriju, program se ruši ili počne raditi neočekivane stvari.
Bootloader zauzima dio dostupne programske memorije (0.5KB od 32KB na
Arduino Unu). Ako želimo iskoristiti svu programsku memoriju ili jednostavno želimo
zaobići bootloader iz drugih razloga, Arduino se može programirati i pomoću
programatora za odgovarajući mikrokontroler. Jednom kad se na takav način snimi
program na ploču, bootloader se briše i ako ga želimo ponovno koristiti u
budućnosti, potrebno ga je ponovno presnimiti na ploču, opet pomoću vanjskog
programatora. [2]
7
2.2.1. Arduino programski jezik
Arduino programski jezik ima sintaksu i jezična pravila identična C++-u. Podržava
sve glavne funkcionalnosti koje podržavaju izvedbe C++-a za mikrokontrolere,
međutim postoje dvije ključne razlike.[6]
Prvo, jezici imaju različitu strukturu glavnog programa. C++, kao i C, ima obaveznu
main funkciju koja se slijedno izvršava kad program počne s radom i izvršava se
dok program ne dođe do kraja te funkcije. Main funkcija može vratiti statusni broj
operacijskom sustavu, a ako se izvršava u okolini koja nema operacijski sustav,
onda ona ne vraća ništa, tj. tipa je void. Arduino programi umjesto maina imaju dvije
obavezne funkcije: setup i loop. Sadržaj setup funkcije se izvršava samo jednom i
to prilikom reseta ploče. Loop funkcija će se izvršavati u petlji dokle god je ploča
upaljena. I setup i loop su tipa void. Mikrokontroleri najčešće moraju obaviti neke
inicijalizacije na početku rada i zatim izvršavati nekakav kod u beskonačnoj petlji,
stoga ovakva organizacija koda ima smisla i poboljšava čitljivost. Ova organizacija
koda preuzeta je iz Wiring programskog jezika.
Drugu ključnu razliku čine ugrađene standardne Arduino biblioteke koje nije
potrebno dodavati u program uobičajenim includeovima. Te biblioteke pružaju
temeljne funkcionalnosti za rad s periferijom, pristup serijskom sučelju, konstante
vezane za logičke razine i analogne priključke i slično.
2.2.2. Pisanje programa za Arduino
Pisanje programa se na Arduinu konceptualno ne razlikuje puno od programiranja
za mikrokontrolere. Ograničavajući resurs je najčešće podatkovna memorija pa
programer uvijek mora koristiti minimalne veličine podataka koje su mu potrebne za
obavljanje nekog posla. Preporučuje se i izbjegavati dinamičku alokaciju memorije
da se izbjegne pojava dinamičke fragmentacije koja može dovesti do toga da
iskoristiva memorija bude manja od ukupne slobodne memorije. [7] Ako se mora
koristiti dinamička alokacija, vjerojatnost nepoželjnih učinaka fragmentacije može
se smanjiti alociranjem blokova približno jednakih veličina. Problemu manjka
podatkovne memorije može se doskočiti korištenjem programske memorije za
spremanje varijabli čiji je sadržaj poznat pri prevođenju i neće se mijenjati. To se
8
može postići na pločama s AVR mikrokontrolerima korištenjem „PROGMEM“
ključne riječi iz biblioteke avr/pgmspace.h na sljedeće načine:
const tip imeVarijable[] PROGMEM = {...};
const PROGMEM tip imeVarijable[] = {...};
Za konstantan niz znakova koji se ne sprema u varijablu ista stvar se može postići
i korištenjem F() makroa.[8]
Serial.print(F(“Posalji ovaj niz na serijsku vezu”));
Jedna od glavnih odlika Arduino platforme je lakoća korištenja periferije. Programski
se to svodi na korištenje nekoliko jednostavnih funkcija. Svi digitalni priključci koji se
koriste se moraju inicijalizirati ili kao ulazni ili kao izlazni priključci. Analogni priključci
mogu samo očitavati analogne signale pa su oni automatski postavljeni u ulazni
način rada. Inicijalizacije je potrebno izvršiti samo jednom pa se u pravilu stavljaju
u setup funkciju.
pinMode(buttonPin, INPUT); //ulazni
pinMode(ledPin, OUTPUT); //izlazni
pinMode(touchPin, INPUT_PULLUP) //ulazni s negativnom logikom
Čitanje s periferije i pisanje na periferiju se nakon toga obavlja funkcijama
digitalRead i digitalWrite za digitalne signale te analogRead i analogWrite
za analogne. Analogni signali mogu se čitati samo na analognim priključcima, a
mogu se slati samo na digitalne priključke koji podržavaju pulsno širinsku
modulaciju. Očitavanje analognog signala daje vrijednosti od 0 do 1023, dok slanje
prima vrijednosti od 0 do 255. U oba slučaja se te vrijednosti linearno preslikavaju
na izlazni ili ulazni napon od 0 do 5 V. Svi priključci se u kodu označuju cijelim
brojevima, no analognim priključcima su pridružena i simbolička imena (A0, A1,
A2...), kao što se vidi u ovom izvatku iz pins_arduino.h datoteke:
static const uint8_t A0 = 14;
static const uint8_t A1 = 15;
static const uint8_t A2 = 16;
Funkcija analogRead automatski će pretpostaviti da želimo čitati s analognog
priključka pa se njoj može direktno dati „simbolički broj“ analognog priključka. Npr.
poziv analogRead(1) je jednak pozivima analogRead(A1) i analogRead(15). [9]
Za primjer svega spomenutog, u isječku koda 2.1. je cijela Arduino skica. Kad se
presnimi na ploču, ona će zasvijetliti svijetleću diodu s intenzitetom koji odgovara
9
vrijednosti pročitanoj s priključka na kojem je rotacijski potenciometar, ali samo ako
je sklopka koja je spojena na priključak 3 preklopljena.
Isječak koda 2.1. Primjer jednostavne Arduino skice
const byte switchPin = 3;
const byte ledPin = 4;
const byte rotaryPin = A2;
void setup() {
pinMode(switchPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(rotaryPin, INPUT);
}
void loop() {
int switchState = digitalRead(switchPin);
int light = analogRead(lightPin);
int rotaryAngle;
if (switchState == HIGH) {
rotaryAngle = analogRead(rotaryPin);
analogWrite(ledPin, rotaryAngle/4);
} else {
analogWrite(ledPin, LOW);
}
}
2.2.3. Biblioteke za Arduino
Biblioteke za Arduino pišu se u C-u ili C++-u. Da bi ih IDE i prevoditelj mogli uključiti
u skicu, biblioteke moraju biti smještene u jednom od direktorija previđenih za to
(npr. „C:\Program Files (x86)\Arduino\libraries“, „D:\Documents\Arduino\libraries“,
...). Svaku biblioteku predstavlja jedan direktorij koji nosi njeno ime, a u njemu se
moraju nalaziti <ime_biblioteke>.cpp i <ime_biblioteke>.h datoteke u kojima je
iskodirana implementacija odnosno sučelje biblioteke. Poželjno je u direktorij dodati
još i „keywords.txt“ datoteku u kojoj su obilježena imena funkcija i struktura koje bi
IDE trebao označiti posebnom bojom. Uz to, u direktoriju smiju biti i druge datoteke
koje su nužne za pravilan rad biblioteke.
Ako želimo u .cpp ili .h datotekama koristiti elemente standardne Arduino biblioteke,
dovoljno je dodati #include <Arduino.h> na vrh koda.
Biblioteke se dodaju u Arduino skicu korištenjem includeova, kao i u običnom C-u.
Arduino IDE pruža mogućnost automatiziranog instaliranja ili ažuriranja biblioteka
10
odabranih preko grafičkog izbornika te automatsko generiranje include koda za
biblioteke koje želimo koristiti. [10,11]
11
3. ARDUINO PERIFERIJA
Kao što je već spomenuto, periferni uređaji mogu se spajati na Arduino ploču preko
njezinih digitalnih i analognih priključaka. Neki od priključaka mogu se koristiti i za
serijsku komunikaciju (0 i 1 na Arduino Unu) te komunikaciju protokolima TWI i SPI.
[2]
Postoje i ploče za proširenje funkcionalnosti, takozvani štitovi (engl. shield). Štitovi
se spajaju na Arduino i najčešće imaju dodatne ulazne ili izlazne priključke kojima
se sklopovski dodaju nove funkcionalnosti. S donje strane štita nalaze se nožice
koje su postavljene u jednak raspored kao i priključci na Arduino ploči, a s gornje
strane štita su priključci, također u istom rasporedu. Štit se spaja na Arduino ploču
umetanjem svih njegovih nožica u odgovarajući priključak. Neke od priključaka će
štit možda „rezervirati“ za vlastitu komunikaciju s Arduinom, a ostale će „proslijediti“
na svoje priključke da se ostali uređaji mogu spojiti direktno na njega. Ovim načinom
spajanja dobivamo i mogućnost da spajamo više štitova jednog na drugi i koristima
istovremeno, dokle god ti štitovi ne koriste iste priključke ili koriste protokole koji to
dopuštaju (TWI i SPI). [12] Primjer kaskadnog spajanja štitova može se vidjeti na
slici 3.1.
Slika 3.1. Stog od dva štita spojen na Arduino. Gornji štit pruža Ethernet funkcionalnost, a donji
GSM. [13]
12
Arduino ploče se često kupuju u kombinaciji s cijelim kompletom perifernih uređaja.
Komplet koji će se koristiti u ovom radu je Grove Starter Kit Plus.
3.1. Grove Starter Kit Plus
Grove sustav je skupina proizvoda kineske tvrtke Seeed Technology koji je
zamišljen kao sustav gradivih blokova u kontekstu Arduino elektronike. Grove
sustav bi trebao eliminirati potrebu za ikakvom dodatnom logikom i dodatnim
elektroničkim komponentama (otpornicima i slično) tako da će se sva periferija
spajati standardiziranim konektorima. Svaki od tih konektora ima po četiri priključka:
napajanje, uzemljenje te dva podatkovna priključka koji se spajaju na dva „susjedna“
Arduino priključka. Takvom kombinacijom se svaka komponenta korištenjem samo
jednog kabela može povezati u strujni krug s pločom, i u isto vrijeme komunicirati s
dva njena priključka. [14, 15]
Osim štita, komponente koje će biti korištene u ovom radu su dugme, prekidač,
senzor dodira, rotacijski potenciometar, senzor zvuka, senzor svijetla, senzor
temperature i servo motor.
3.1.1. Grove Base Shield
Temeljna komponenta Grove sustava je Grove Base Shield, štit pomoću kojeg se
sve druge Grove komponente spajaju na Arduino ploču. Štit se spaja na ploču na
klasični način, a na sebi ima standardizirane konektore na koje se spajaju ostale
Grove komponente. Verzija štita koja dolazi u ovom kompletu, Grove Base Sheild
v1.3b, ima 8 digitalnih konektora, 4 analogna konektora i 4 konektora za I2C sučelje,
to jest, njegovu varijantu TWI. Prvi digitalni konektor je spojen s priključcima 0 i 1,
što znači da se može koristiti i za serijsku komunikaciju. Ostalih sedam digitalnih
konektora se spajaju na svaka dva susjedna priključka od D2 do D9, a tako su
spojeni i analogni konektori. Štit i njegovi konektori se vide na slici. Većina
komponenata unutar ovog kompleta koristi samo jedan od dva priključka na koje je
spojeno preko standardnog konektora. Ako neka komponenta koristi dva, ne
smijemo koristiti konektore susjedne njoj (osim ako je u pitanju serijski ili TWI
konektor) jer će tad isti priključak biti spojen na dvije komponente. [15] Raspored
konektora vidi se na slici 3.2.
13
Slika 3.2. Grove Base Shield s gornje strane [16]
3.1.2. Grove senzor temperature
Grove senzor temperature temelji se na termootporniku (otporniku čija se svojstva
značajno mijenjaju pri promjeni temperature) koji je spojen u seriju s analognim
priključkom. Preko očitane vrijednosti napona na priključku mjeri se otpor
termootpornika, a nakon toga i njegova temperatura preko Steinhart-Hart
jednadžbe. Na wiki stranici Grove Starter Kit Plusa kao i papirnatim uputama koje
se dobiju u kompletu može se naći predložak koda (isječak) koji vrši ove
aproksimacije. Njega korisnik može kopirati i koristiti bez dubljeg razumijevanja
termootpornika i elektrotehnike.
Isječak koda 3.1. Predložak koda koji aproksimira temperaturu [16]
int B = 3975;
int a = analogRead(0);
float resistance = (float)(1023-a)*10000/a;
float temperature = 1/(log(resistance/10000)/B+1/298.15)-
273.15;
Temperaturni senzor može čitati temperature od -40 do 125 Celzijevih stupnjeva uz
preciznost od +/-1.5 Celzijeva stupnja. [16]
14
3.1.3. Grove senzor zvuka
Senzor zvuka je mikrofon čiji izlazni napon odgovara amplitudi zvuka. Jedan
problem ovog senzora je to što su mu očitanja poprilično osjetljiva na vibracije,
pozadinsku buku i slično, te su u nekim trenucima naizgled nasumična zbog čega
može biti dosta teško detektirati „korisne“ zvukove u blizini senzora. Sljedeća
mjerenja su obavljena u tihoj prostoriji sa zatvorenim prozorima. Vrijednost sa
senzora šalje se na računalo preko serijske veze gdje se ispisuje na grafu (jedna od
dodatnih funkcionalnosti Arduino IDE-a). Na slici 3.3. dobro se vidi spomenuta
pojava. Iako se proizvedeni zvukove vide na grafu, očitanja grafa kad nema
primjetnih zvukova često dosežu četvrtinu ili čak polovicu „korisnih“ zvukova, što
nam nije primjereno za većinu primjena u automatizaciji. Na primjer, ako želimo
napraviti sustav koji pali svijetlo kad netko uđe u kuću, ovakva očitanja će vrlo
vjerojatno okinuti paljenje svijetlo i kad nema nikog, zbog visokih smetnji i
pozadinske buke.
15
Slika 3.3. Graf svakog očitanja senzor u nekom vremenu
Ovaj problem lako možemo riješiti tako što za svako očitanje vrijednost sa senzora
očitamo više puta i izvučemo prosjek. Na ovaj način ćemo dobiti puno jasnije
podatke. Na slici 3.4. vide se prosječne vrijednost svakih pet očitanja. Valja primijetiti
da su ovaj put proizvedeni zvuci bili glasniji, no i dalje se vidi učinak smanjenja
pozadinske buke.
16
Slika 3.4. Prosječne vrijednosti iz uzorka od 5 očitanja
Učinak postaje još malo izraženiji s većim uzorkom (Slika 3.5.).
Slika 3.5. Prosječne vrijednosti iz uzorka od 10 očitanja
17
3.1.4. Grove servo motor
Grove servo motor je aktuator rotacijskog tipa koji se može pozicionirati na kuteve
između 0 i 180 stupnjeva od početnog položaja s preciznošću od jedan stupanj.
Servo motor se kontrolira analognim signalom, što znači da ga moramo spojiti na
digitalni priključak koji podržava pulsno širinsku modulaciju. Specifičnost korištenja
servo motora u kombinaciji s Arduinom je da se na njih ne piše direktno funkcijom
analogWrite već se koristi gotova Arduino biblioteka Servo.h.
Servo.h se koristi preko objektno orijentiranog sučelja tako što se instancira objekt
razreda Servo, njemu se prikači priključak metodom attach, nakon čega mu se
mogu slati željene pozicije metodom write. Nakon slanja pozicije dobro je pričekati
neko vrijeme da se servo motor postavi u poslanu poziciju prije nego pošaljemo
novu poziciju. Metoda write prima položaj u stupnjevima (od 0 do 180) kao
parametar. Ako imamo vrijednost koja je omeđena drugačijim intervalom, a želimo
je linearno mapirati na vrijednost unutar željenog intervala, za to postoji ugrađena
funkcija map. [16, 17]
3.1.5. Ostale Grove komponente
Ostale komponente u ovom kompletu nemaju neke specifičnost vezane za
korištenje već se koriste standardnim Arduino sučeljem. Dugme, prekidač i senzor
dodira su tipične digitalne ulazne komponente, znači spajamo ih na digitalni
priključak i čitamo funkcijom digitalRead, dok su senzor svjetlosti i rotacijski
potenciometar tipične analogne ulazne komponente i koje se čitaju na analognim
priključcima funkcijom analogRead. [16]
3.2. Programska podrška za Grove Starter Kit Plus
3.2.1. Implementacija programske podrške
Zbog raznolikosti komponenata periferije korisno je osmisliti i implementirati
objedinjeno sučelje preko kojeg će se one koristiti. Za primjer, u ovom radu će se
koristiti funkcija ovog prototipa:
char* sensor_control(
const char* ctrlStr,
void* obj,
18
char* retStr,
int retStrSize);
Prvi argument kojeg će funkcija primiti je kontrolni niz znakova. Taj kontrolni niz
znakova je ovog formata:
{INIT|GET|SET} IMEKOMPONENTE BROJPRIKLJUČKA [VRIJEDNOST]
Prva riječ u nizu je naredba koju treba izvršiti, druga je simboličko ime komponente
koju koristimo, treća je broj priključka na kojem se ta komponenta nalazi, a četvrta
riječ je vrijednost koju želimo upisati ako izvršavamo SET naredbu. Ako izvršavamo
neku drugu naredbu, zadnja riječ se zanemaruje.
Komponente koriste ova simbolička imena:
LED
SOUND
LIGHT
TEMPERATURE
TOUCH
BUTTON
ROTARY
SWITCH
SERVO
Za svijetleće diode se u polju VRIJEDNOST upisuje ON ili OFF, a za servo se
upisuje kut u stupnjevima.
Drugi parametar u funkciji je opcionalan i prima pokazivač na objekt s kojim funkcija
treba raditi. To nam treba za rad sa servom ili sličnim komponentama kojima treba
pristupati preko objektnog sučelja. Ako koristimo komponentu koja ne koristi taj
parametar, onda se on zanemaruje pa se funkciji na tom mjestu može predati i NULL
pokazivač.
Funkcija vraća niz oblika „IMEKOMPONENTE VRIJEDNOST“ ili prazan niz ako
nema vrijednost koju mora vratiti. Postoje dva način prosljeđivanja rezultata
korisniku. Prvi je preko parametara. Treći parametar je polje znakova u kojeg se
pohranjuje rezultat, a četvrti veličina tog polja. Funkcija će u ovom slučaju vratiti
pokazivač na to polje znakova. Drugi način je preko statičkog polja. Ako se umjesto
19
trećeg parametra preda NULL pokazivač, funkcija će svoj rezultat vratiti preko
statičkog polja definiranog unutar tijela funkcije, a četvrti parametar će se
zanemariti. Povratna vrijednost u tom slučaju će biti pokazivač na to statičko polje.
Ako dođe do greške (npr. neispravan kontrolni niz, premalo polje za rezultat ili
slično), funkcija vraća NULL pokazivač, a retStr se ne mijenja. U isječku koda 3.2.
prikazana je izvedba ovakvog načina rada.
Isječak koda 3.2. Izbor načina prosljeđivanja rezultata
#define STATIC_ARRAY_SIZE 20
char* sensor_control(const char* ctrlStr, void *obj,
char* retStr, int retStrSize) {
static char staticRetStr[STATIC_ARRAY_SIZE];
char *pRetStr;
int size;
...
if (retStr != NULL) {
pRetStr = retStr;
size = retStrSize;
} else {
pRetStr = staticRetStr;
size = STATIC_ARRAY_SIZE;
}
...
return pRetStr;
}
Bitno je uočiti da će se podaci u statičkom polju prepisati novim rezultatom svaki put
kad se ono koristi, što znači da ako korisnik želi imati spremljena dva ili više
rezultata, bolje je da koristi prvi način prosljeđivanja. Drugi način korištenja je čitljiviji
ako je korisniku potreban samo jedan rezultat u bilo kojem trenutku ili ga rezultat
uopće ne zanima. Uz to ima i prednost da se korisnik ne mora zamarati s time koliko
mu memorije treba jer će funkcija biti napisana tako da podrži i najduži mogući
rezultat.
Ostatak funkcije svodi se većinom na parsiranje kontrolnog niza što se radi
kombinacijom sscanf i strcmp funkcija. Jedna zanimljiva stvar za prokomentirati je
20
korištenje snprintf funkcije za zapis rezultata. Implementacija te funkcije i sličnih
funkcija na Arduino platformi ponaša se ponešto drugačije nego kako bismo to
očekivali u C-u. Zbog ograničenja u programskoj memoriji, iz implementacije je
isključena mogućnost upisivanja decimalnih brojeva. Umjesto toga, svaka pojava
„%f“ specifikatora će u rezultatu biti zamijenjena sa znakom upitnika („?“). To znači
da ako želimo zapisivati decimalne brojeve u niz znakova pomoću jedne od takvih
funkcija, to moramo činiti „ručno“. Primjer toga može se vidjeti u isječku koda 3.3.
Isječak koda 3.3. Zaobilaženje %f specifikatora
char dec = (long) (retval * 100) % 100;
if (dec < 0) dec = - dec;
int printSize = snprintf(pRetStr, size, "%s %d.%02d",
sensor, (int) retval, (int) dec);
if (printSize >= size || printSize < 0) {
return NULL;
}
Broj koji vratimo ovom metodom će uvijek biti decimalan i to zaokružen na dvije
decimale.
3.2.2. Korištenje programske potpore
Sad kad je funkcija za rad implementirana, možemo vidjeti kako se njome inicijalizira
senzor svijetla na analognom priključku 1:
sensor_control(“INIT LIGHT 1”, NULL, NULL, 0);
Ili kako se nakon toga s njega čita vrijednost:
char *p;
p = sensor_control(“GET LIGHT 1”, NULL, NULL, 0);
Ako želimo imati spremljena dva podatka s dva različita senzora, to možemo činiti
na ovaj način:
char temp[30];
char light[25];
sensor_control(“GET TEMPERATURE 1”, NULL, temp, 30);
sensor_control(“GET LIGHT 1”, NULL, light, 25);
Ako korisnik nije siguran da je alocirao dovoljno memorije, trebao bi provjeriti jesu li
pozivi funkcije vratili NULL pokazivač.
21
Servo se mora koristiti u kombinaciji s objektom koji ga predstavlja:
sensor_control(“INIT SERVO 1”, &servo, NULL, 0);
sensor_control(“SET SERVO 1 90”, &servo, NULL, 0);
Jedna malo naprednija mogućnost korištenja bila bi primanje kontrolnih nizova iz
nekog vanjskog izvora podataka, npr. serijske veze. Isječak 3.4. prikazuje primjer
Arduino skice koja će to raditi.
Isječak koda 3.4. Arduino skica koja učitava naredbe sa serijske veze
#include <Sensors.h>
void setup() {
Serial.begin(9600);
while (! Serial) {;}
sensor_control("INIT LED 2", NULL, NULL, 0);
sensor_control("SET LED 2 OFF", NULL, NULL, 0);
}
void loop() {
char ctrlStr[50];
char *p;
for (int i = 0; i < 50; i++) {
while (! Serial.available()) {;}
char c = Serial.read();
if (c == '\n') {
ctrlStr[i] = '\0';
break;
}
ctrlStr[i] = c;
}
sensor_control("SET LED 2 OFF", NULL, NULL, 0);
if ((p = sensor_control(ctrlStr, NULL, NULL, 0)) == NULL) {
sensor_control("SET LED 2 ON", NULL, NULL, 0);
} else {
Serial.println(p);
Serial.flush();
}
}
S druge strane serijske veze možemo slati naredbe po definiranom formatu. Ako
pošaljemo naredbu koja ne odgovara formatu upalit će se svjetleća dioda na
priključku 2, a ugasit će se nakon slanja sljedeće naredbe. Ako je naredba ispravna,
Arduino će na serijsku vezu poslati vraćeni niz znakova.
22
Korisna stvar kod ovog načina upravljanja je da se periferne komponente mogu
dodavati i koristiti bez mijenjanja koda koji je na Arduino ploču. Sve što moramo
učiniti kad spojimo novu komponentu na ploču je inicijalizirati INIT naredbom, nakon
čega je možemo normalno koristiti. Iznimka su komponente koje koriste objektno
sučelje, kao što je u našem slučaju servo, jer funkcije koje ih koriste moraju primiti
pokazivač na objekt. To, međutim, ne znači da se ostale komponente ne mogu
koristiti u kombinaciji sa servom koji je predviđen za vrijeme pisanja koda, već samo
da ga ne možemo naknadno dodati ako on nije predviđen.
3.2.3. Komentari za budući rad
Ovako osmišljena programska podrška omogućava nam prvi korak prema Internetu
Stvari, no ako želimo veću interoperabilnost među našim napravama, treba
razmišljati o standardiziranom formatu u kojem će se slati naredbe i očitani podaci.
Jedan takav format je JSON, za kojeg postoje gotove biblioteke za sve popularnije
programske jezike pa tako i za Arduino.
Sljedeći korak nakon standardizacije formata bio bi standardan protokol za
komunikaciju između stvari. Bilo bi korisno da stvari mogu zanemarivati poruke koje
im nisu namijenjene, da mogu prosljeđivati poruke i da imaju ugrađenu zaštitu od
grešaka pri prijenosu. Kad se implementira protokol, može se početi graditi mreža
stvari.
23
4. ZAKLJUČAK
Cilj ovog rada bio je istražiti mogućnosti Arduino platforme, naučiti kako se koristi te
primijeniti naučeno za nešto što se može razviti u Internet Stvari. Sve se to da
odraditi u relativno kratkom roku uz pomoć dobro napisane dokumentacije koja je
dostupna na Web-u i velike zajednice korisnika koji dijele svoja iskustva. Zbog toga
se za primjene istraživanja i brzog razvoja prototipova, Arduino još jednom pokazao
kao dobar izbor.
Rad je demonstrirao i korištenje Arduino periferije. Iako je nemoguće proučiti sve
komponente koje se mogu koristiti u kombinaciji s Arduinom, principi korištenja bit
će slični, što još i više potpomaže tu reputaciju usmjerenosti prema korisniku kojeg
je platforma stekla. Broj Arduino-kompatibilnih uređaja raste iz dana u dan, kao i
biblioteke koje nude napredne funkcionalnosti, a time rastu i mogućnosti u
primjenama i istraživanju.
24
LITERATURA
1. https://www.arduino.cc/en/Guide/Introduction, pristupano 12.6.2016.
2. https://www.arduino.cc/en/Main/ArduinoBoardUno, pristupano 12.6.2016
3. https://upload.wikimedia.org/wikipedia/commons/3/38/Arduino_Uno_-_R3.jpg,
pristupano 12.6.2016.
4. https://www.arduino.cc/en/Guide/Environment, pristupano 12.6.2016.
5. https://github.com/arduino/Arduino/blob/master/license.txt, pristupano
12.6.2016.
6. https://www.arduino.cc/en/Reference/Comparison, pristupano 12.6.2016.
7. http://web-engineering.info/node/30, pristupano 12.6.2016.
8. https://www.arduino.cc/en/Reference/PROGMEM, pristupano 12.6.2016.
9. https://www.arduino.cc/en/Reference/HomePage, pristupano 12.6.2016.
10. https://www.arduino.cc/en/Hacking/LibraryTutorial, pristupano 12.6.2016.
11. https://www.arduino.cc/en/hacking/libraries , pristupano 12.6.2016.
12. https://learn.sparkfun.com/tutorials/arduino-shields, pristupano 12.6.2016.
13. http://www.hwkitchen.com/products/gsm-playground/, pristupano 12.6.2016.
14. http://www.seeedstudio.com/wiki/Grove_System, pristupano 12.6.2016.
15. http://www.seeedstudio.com/wiki/Grove_-_Base_Shield_V1.3, pristupano
12.6.2016.
16. http://www.seeedstudio.com/wiki/Grove_-_Starter_Kit_Plus, pristupano
12.6.2016.
17. https://www.arduino.cc/en/Reference/Servo , pristupano 12.6.2016.
25
SAŽETAK
Naslov rada: Upravljanje napravama spojenim preko Arduino platforme kroz
arhitekturu Interneta stvari
Rad prvo opisuje općenito Arduino platformu i razvoj za tu platformu, s naglaskom
na funkcionalnosti koje će biti korištene kasnije u radu. Razvoj obuhvaća
specifičnosti programskog jezika, glavne funkcionalnosti temeljnih biblioteke te
proces dodavanja i pisanja dodatnih biblioteka.
U drugom poglavlju rad se usredotočuje na periferiju za Arduino platformu, prvo
neke općenite informacije o njoj, a zatim specifičnosti različitih komponenata na
primjeru Grove Starter Kit Plus kompleta. Nadalje, predstavlja se primjer
jednostavnije programske potpore kojom se standardizira upravljanje periferijom.
Demonstrira se korištenje te programske potpore te se komentiraju moguća
poboljšanja.
Ključne riječi: Arduino, Internet Stvari, Arduino IDE, Arduino štit, Grove, Grove
Starter Kit Plus, senzori
26
SUMMARY
Title of the thesis: Controlling devices with Arduino within Internet of Things
architecture
This thesis first describes the Arduino platform in general and development for
Arduino platform, with emphasis on functions which will later be used in the thesis.
Development includes the specifics of the programming language, main
functionalities of core libraries and process of adding and coding additional libraries.
In the second chapter, thesis focuses on the periferal devices for the Arduino
platform, first some general information regarding them, and then the distinctive
properties of different devices by example of ones found inside the Grove Starter
Kit Plus. Furthermore, an example of simple control software which standardizes
the management of periferal devices is presented. The use of this software is
demonstrated and some comments are given on possible improvments.
Keywords: Arduino, Internet of Things, Arduino IDE, Arduino shield, Grove, Grove
Starter Kit Plus, sensors
top related