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