2014.06.22.
16:55

Írta: harsanyireka

13. /5) Kommunikációs könyvtárak: Ethernet

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

 

Az OSI (Open Systems Interconnection) modell szerint – mely hét absztrakt rétegre osztja a kommunikációs technológiák funkcionális szintjeit – az Ethernet 1985 óta a számítógépeket összekötő hálózatok fő kommunikációs technológiai szabványa és fizikai rétegtől az adatkapcsolati rétegig nyújt szolgáltatásokat. A fizikai réteg magát a hardware-t jelenti, az adatok bitenkénti csatornákra juttatását. Az adatátviteli réteg pedig két hálózati elem közötti átvitelt biztosító eljárásokért felelős.

13.9. †bra Open Systems Interconnection modell.png

Open Systems Interconnection modell

Az Ethernet kiegészítő modullal (shield) és a hozzá tartozó könyvtár segítségével eljuthatunk a hálózati rétegig és internetképessé tehetjük az Arduinot. A shield a Wiznet, SPI kommunikáción alapuló W5100-as integrált áramkörére épül és fenntartja az SD kártya csatlakoztatásának lehetőségét is. A kiegészítőt elég csatlakoztatni. A következő példákban megnézzük, hogyan lehet bejövő kapcsolatokat kezelő szerverként és kimenőket intéző kliensként egyaránt működtetni.

 13.10. †bra Arduino Ethernet Shielddel.jpeg

Arduino Ethernet Shielddel

 

 13.11. †bra Csatorn†k kioszt†sa az Eethernet Shieldhez.png

Csatornák kiosztása az Eethernet Shield-hez

 

Ethernet osztály

Ethernet.begin()

Az ethernet könyvtárat és a hálózati beállításokat inicializálja a parancs. A begin() függvénnyel megadhatjuk az eszközünk MAC (Media Access Control – fizikai) és az IP (Internet Protocol) címét. A könyvtár támogatja a DHCP (Dynamic Host Configuration Protocol) alapú IP-cím igénylést, ezért ha csak a fizikai címet adjuk meg, ebbe az üzemmódba kerül. Az automatikus címigényléshez a könyvtár nagyobb hányada töltődik az Arduinoba, ezért ez a mód sokkal több memóriát igényel, mintha csak statikus címet adnánk meg. Ethernet.begin(mac) sikeres cím igénylés esetén 1-et, sikertelen esetén 0-át ad vissza.

Szintaxisa:

Ethernet.begin(mac),

Ethernet.begin(mac, ip),

Ethernet.begin(mac, ip, dns),

Ethernet.begin(mac, ip, dns, gateway),

Ethernet.begin(mac, ip, dns, gateway, subnet).

Paraméterei:

mac: 6 bájtos tömb, az eszköz fizikai címe,

ip: 4 bájtos tömb, az eszköz IP-címe,

dns: 4 bájtos tömb, DNS (Domain Name Server) IP-címe,

gateway: 4 bájtos tömb, hálózati átjáró címe,

subnet: 4 bájtos tömb, a hálózat alhálózati maszkja, alapállapotban 255.255.255.0.

 

Ethernet.localIP()

Visszaadja az eszköz aktuális IP-címét. Ez akkor hasznos, ha automatikusan igényeltük.

 

Ethernet.maintain()

DHCP használata esetén egy meghatározott időre kap az eszköz IP-címet. Amikor ez lejár, meg kell újítani. Ezzel a függvénnyel a lejárt cím helyett újat igényelhetünk, ami a DHCP szervertől függően lehet ugyanaz, egy teljesen más, vagy semmi is. Egy számot ad vissza, ami ha:

0: nem történt semmi,

1: cím megújítása sikertelen,

2: cím megújítása sikeres,

3: újrakapcsolódás sikertelen,

4: újrakapcsolódás sikeres.

  

IPAddress osztály 

IPAddress()

Meghatározza az IP-címet, ami lehet helyi és távoli cím is.

Szintaxisa:

IPAddress(address) 

Paramétere:

address: vesszőkkel elválasztott 4 bájt (pl.: 192,168,1,1).

Arduino kód: 64IPaddress

Arduino kód: 65localIP

 

Server osztály 

EthernetServer()

Létrehoz egy szervert, ami a bejövő kapcsolatokat figyeli egy előre meghatározott porton.

Szintaxisa:

Server(port).

Paramétere:

port: a port száma, amit a szerver figyel.

Példakód:

EthernetServer server = EthernetServer(23);

 

server.begin()

Szól a szervernek, hogy kezdjen figyelni.

 

server.available()

Visszaadja egy csatlakozott kliens címét, ha rendelkezésre állnak olvasható adatok.

Példakód:

EthernetClient client = server.available();

 

server.write()

Adatokat küld a szerverhez kapcsolódott klienseknek. Az adat bájt vagy karakter típusú lehet.

 

server.print()

ASCII kódolású adatokat küld a szerverhez kapcsolódott klienseknek. A server.println() az adatot kiegészíti a soremelés kódjával.

Szintaxisa:

server.print(data),

server.println(data, BASE).

Paraméterei:

data: char, byte, int, long, string, amit a szervernek ki kell küldenie,

BASE: a számrendszer alapja BIN, HEX, OCT, DEC.

  

Arduino kód: 66server

 

Client osztály

EthernetClient()

Létrehoz egy klienst, ami egy IP-címen meghatározott porthoz képes csatlakozni.

 

If(ethernetClient)

Megvizsgálja, hogy a kliens készen áll-e. Bool típusú változóban adja vissza a választ.

 

client.connected()

Megvizsgálja, hogy a kliens kapcsolatban van-e. Amíg van olvasatlan adat, addig igen.

 

client.connect()

A meghatározott címre és portra kapcsolja a klienst, ha sikerült, IGAZ választ ad vissza.

 

client.write()

Adatot küld a szervernek, amelyikhez a kliens kapcsolódott.

 

client.print() és client.println()

ASCII kódolású adatokat küld a szervernek.

 

client.available()

Visszaadja a szerver által küldött, olvasásra kész bájtok számát.

 

client.read()

Beolvassa a szerver által küldött utolsó bájtot.

 

client.flush()

Kiüríti az átmeneti tárolót, minden olvasatlan bájtot töröl.

 

client.stop()

Megszakítja a kapcsolatot a szerverrel.

 

Arduino kód: 67client

 

EthernetUDP osztály

Az UDP (User Datagram Protocoll) az internetet alkotó protokollok egyike, amivel számítógép-alkalmazások cserélnek úgynevezett datagrammokat egymás között. Leginkább olyan esetekben érdemes használni, amikor nem fontos a hibaellenőrzés és -javítás a csomagok átvitelekor. Ez általában valós idejű adatátviteli rendszereknél fontos, ahol egy csomag elvesztése kisebb probléma, mint az ellenőrzésekből fakadó késés.

 

UDP.begin()

Inicializálja az UDP könyvtárat és hálózati beállításait.

Szintaxisa:

EthernetUDP.begin(localPort); 

Paraméterei:

localPort: helyi port száma

 

UDP.read()

Datagrammot olvas egy meghatározott tárolóból. Argumentumok nélkül a soron következő karaktert adja vissza.

Szintaxisa:

UDP.read(packetBuffer, MaxSize).

Paraméterei:

packetBuffer: az átmeneti tároló, ami a bejövő karaktereket tárolja,

MaxSize: az átmeneti tároló maximális mérete.

 

UDP.write()

Datagrammot ír egy távoli kapcsolatnak. beginPacket() és endPacket() között kell használni. Az elküldött karakterek számát adja vissza.

Szintaxisa:

UDP.write(message); 

Paraméterei:

message: kimenő üzenet (char adattípus)

 

UDP.beginPacket()

Inicializálja a datagramm elküldését. A küldendő adatokat a write()-tal határozzuk meg.

Szintaxisa:

UDP.beginPacket(remoteIP, remotePort);

Paraméterei:

remoteIP: a távoli kapcsolat IP címe (4 byte)

remotePort: a távoli kapcsolat port száma (int)

 

UDP.endPacket()

Jóváhagyja a datagramm továbbítását. 

Szintaxisa:

UDP.endPacket();  

Paraméterei:

nincs

 

UDP.parsePacket()

Megvizsgálja, van-e elérhető datagramm, és ha van, visszaadja a méretét. Read() előtt kell használni.

Szintaxisa:

UDP.parsePacket();  

Paraméterei:

nincs

 

UDP.available()

Az átmeneti tárolóba már megérkezett bájtok (karakterek) számát adja vissza. A parsePacket() után érdemes használni. 

Szintaxisa:

UDP.available(); 

Paraméterei:

nincs

  

UDP.remoteIP()

Visszaadja a távoli kapcsolat IP-címét. A parsePacket() után kell használni.

Szintaxisa:

UDP.remoteIP();  

Paraméterei:

nincs

 

UDP.remotePort()

Visszaadja a távoli kapcsolat portjának számát. A parsePacket() után kell használni. 

Szintaxisa:

UDP.remotePort(); 

Paraméterei:

nincs

 

Arduino kód: 68UDP

 

- - - - - - - - - -

forrás: http://arduino.cc/en/Tutorial/HomePagehttp://arduino.cc/en/reference/ethernet

 

 

 

Szólj hozzá!

Címkék: leckék könyvtárak Ethernet lektorált

2014.06.22.
16:22

Írta: harsanyireka

13. /4) Kommunikációs könyvtárak: SPI

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

 

Az SPI (Serial Peripherial Interface) egy szinkron soros protokoll. Alapvető különbség az I2C-hez képest, hogy külön adatvonalat tart fenn a mestertől a szolga felé és az ellenkező irányú kommunikáció céljára, továbbá nem használ címzést, az egyetlen mester az eszközöket egyenként külön vonalakon engedélyezi. Mindezek együttesen egy gyorsabb soros adatátvitelt tesznek lehetővé a mikrokontroller és perifériái között. A közös adatvonalak a MISO (Master In Slave Out), amin keresztül a mester fogad adatokat, a MOSI (Master Out Slave In), amin a szolgák fogadnak adatokat és az SCK (Serial Clock) órajel a szinkronizáláshoz. Az eszközönként specifikus vonal az engedélyezéshez az SS (Slave Select). Amikor egy szolga SS vonala logikai alacsony szintre kerül, létrejön a kapcsolata a mesterrel, ha magas szinten tartjuk, akkor teljesen kimarad a buszon való kommunikációból, így nem zavarhatja a többi perifériát.

13.6. †bra SPI busz funkcion†lis rajza tîbb szolgaeszkîz esetÇn.png

SPI busz funkcionális rajza több szolgaeszköz esetén 

A nyílt fejlesztésű rendszernek és a közösségben együttműködő programozóknak köszönhetően az Arduinoval számtalan SPI alkatrész került implementálásra, és a könyvtár ebből a rutinból fakadóan rendelkezik olyan függvényekkel, amik megkönnyítik az új eszközök használatát. Mindazonáltal az SPI protokoll meglehetősen szabadon értelmezett az eszközgyártók körében, ezért, ha egy új alkatrészhez szeretnénk programot írni, akkor nézzük meg alaposan az adatlapját.

 

Eltérések a következő paraméterekben lehetnek:

  • MSB (Most Significant Bit): legnagyobb helyi értékű bitet küldi a szolga először.
  • LSB: (Less Significant Bit): legkisebb helyi értékű bitet küldi a szolga először.

A két változat között az SPI.setBitOrder() függvény biztosítja az átjárást.

  • Órajel frekvenciája: Az órajel sebességét az SPI.setClockDivider()-rel adhatjuk meg.
  • Órajel fázisa (CPHA): Az adatok az órajel negatív vagy pozitív élével vannak szinkronban.
  • Órajel polaritása (CPOL): A várakozás logikailag magas vagy alacsony szint.

Erről az SPI.setDataMode() függvény segítségével dönthetünk:

 

Mód

 

CPOL CPHA

SPI_MODE0

0

0

SPI_MODE1

0

1

SPI_MODE2

1

0

SPI_MODE3

1

1


táblázat: setDataMode függvény állapotai

 

Az SPI kivezetéseit megtalálhatjuk az Arduino alaplapján egy külön csatlakozón is, amit ICSP-nek (In Circuit Serial Programming) hívunk.

13.7. †bra ICSP csatlakoz¢ kioszt†sa.jpeg

ICSP csatlakozó kiosztása

Mivel ezen a csatlakozón keresztül tölthetjük fel az Arduino alapprogramját, a bootloadert is, ezért megtalálható minden típusú alaplapon ugyanebben a formában. Mint azt láttuk, a kivezetések sokszor több különböző funkciót is el tudnak látni, így nem meglepő, hogy az ICSP vonalait az eddig tárgyalt csatlakozók valamelyikén is megtaláljuk:

 

Típus

MOSI MISO SCK

SS (szolga)

SS (mester)

UNO

13

11

12

10

-

Mega

51

50

52

53

-

Leonardo

ICSP4

ICSP1

ICSP3

-

-

DUE

ICSP4

ICSP1

ICSP3

-

4, 10, 52

 

SPI csatornák kivezetései a különböző típusú Arduino alaplapokon

 

Az eltérések nem kizárólag az alapvető kommunikációban mutatkoznak meg, minden alkatrész rendelkezik saját utasításkészlettel és regiszterekkel.

Az SD kártyák is SPI buszon kommunikálnak, amiket viszonylag könnyen és nagyon sokféleképpen hasznosíthatunk arduinos projektjeinkben (háttértár, hangfelvétel, lejátszás, adatrögzítés, GPS). Példánkban a Libelium által gyártott microSD panelt fogjuk alkalmazni, aminek kialakításakor figyelembe vették mind a kétféle csatlakoztatási módot.

 13.8. †bra Arduino Libelium microSD modullal.png

Arduino Libelium microSD modullal

Az SD kártyák csatlakoztatása a modul megvásárlása nélkül is igen egyszerű, mindössze pár ellenállásra van szükség, amikkel az Arduino 5 V-os rendszerű SPI buszának vonalait a memóriakártyák által elfogadható 3,3 V-os szintűvé alakítjuk. Tulajdonképpen a bemutatásra kerülő modul sem tesz ennél többet. A kártya eléréséhez az SPI könyvtár egy módosított változatát fogjuk használni, ami képes FAT partíción fájlstruktúrák kezelésére.

 

Amire szükségünk lesz:

-       Arduino,

-       Libelium microSD modul, vagy

-       5 V – 3,3 V szintillesztő.

 

Arduino kód: 63SDkartya

 

- - - - - - - - - -

forrás: http://arduino.cc/en/Reference/SDhttp://arduino.cc/en/Tutorial/HomePage

 

 

Szólj hozzá!

Címkék: leckék könyvtárak SD SPI lektorált

2014.06.22.
14:24

Írta: harsanyireka

13. /3) Kommunikációs könyvtárak: Wire

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

 

Az I2C, vagy más néven TWI (Two Wire Interface) egy soros buszrendszer, amit a Philips fejlesztett ki, hogy mikrokontrollerekhez alacsony sebességű perifériákat két vezeték használatával lehessen illeszteni. Ilyen eszközök például a Maxim által gyártott csatornabővítők (MAX6956 I2C-t 20 párhuzamos I/O csatornává alakít), LED meghajtók, adatátalakítók (pl. digitalizálók), Microchip által gyártott soros EEPROM-ok (legnagyobb 1Mbyte-os), vagy az NXP termékei: órák, memóriák, audio és video jelfeldolgozók, szintátalakítók.

 13.2. †bra A buszon keresztÅl sok eszkîzt csatlakoztathatunk.png 

A buszon keresztül sok eszközt csatlakoztathatunk 

A buszokra általánosságban az a jellemző, hogy az eszközök megosztoznak az adatvezetékeken, ezért minden eszköznek rendelkeznie kell egy címmel, ami megkülönbözteti a többi buszhoz kapcsolt egységtől. Az I2C esetén a címzés eszköztől függően kétféle lehet, 7 vagy 8 bites. Az utóbbi esetben 7 bit a tényleges címet kódolja, míg a 8. bit arról ad információt, hogy a címen írás vagy olvasás folyik. A Wire könyvtár mindkét típust támogatja. Az adatvezetékeket rendre SDA (Serial Data) és SCL (Serial Clock) neveket viselik, míg az egyiken a szinkronitást fenntartó órajel, a másikon a szekvenciális adat jelenik meg bitenként. Az Arduino mikrokontrollere fizikailag tartalmaz csatolófelületet a buszhoz, aminek kivezetései UNO – és megelőző típusok – esetében az (analóg bemenetként is használható) A4 (SDA) és A5 (SCL).

Ezen a busztípuson kétféle eszköztípus, egy mester (Master) és a címek elfogyásáig tetszőleges mennyiségű szolga (slave) eszköz kommunikálhat. A mester eszköz az, aki adott címen végrehajthat írást vagy olvasást, a szolgák pedig, akik a mester parancsait követik. A könyvtár alapbeállítása szerint a mester az Arduino, de ha könyvtár inicializálásakor címet adunk neki, akkor szolgaként is tudjuk használni – ez akkor lehet hasznunkra, ha olyan hálózatot szeretnénk építeni, amihez I2C eszközök is és több Arduino is csatlakozik (lásd 13.2. ábra). Ha képesek vagyunk a buszon a konfliktusokat kezelni, több mesteregység használata is elképzelhető.

 

A könyvtár függvényei:

begin()

Inicializálja az I2C kommunikációt. Ha nem adunk meg neki külön címet, automatikusan az Arduino lesz a mester, ellenkező esetben a megadott címen szolgaként fog működni.

Szintaxisa:

Wire.begin(address). 

Paramétere:

address: 7 bites cím.

 

requestFrom()

A mester által használt parancs, hogy bájtokat kérjen valamelyik szolgaeszköztől. Az eszközök válaszait az available() vagy read() függvényekkel kezelhetjük. Az I2C eszközök közötti működésbeli különbségek áthidalására ez a függvény elfogad bemenetként bool típusú változót. Ami ha igaz (alapállapot), akkor a lekérés után STOP jelet küld, és nem kommunikál a buszon, ha hamis, akkor RESTART jelet küld, és nem szabadítja fel a buszt.

Szintaxisa:

Wire.requestFrom(address, quantity),

Wire.requestFrom(address, quantity, stop).

Paraméterei:

address: 7 bites cím,

quantity: lekérdezendő bájtok száma,

stop: bool változó.

  

available()

Visszaadja az olvasásra kész bájtok számát. Mestereszközön requestFrom() után kell meghívni, szolgaeszközön pedig az onReceive() kezelőben.

Szintaxisa:

Wire.available().

  

read()

Beolvassa a soron következő bájtot.

Szintaxisa:

Wire.read().

 

Arduino kód: 60wire01

 

write()

Küld egy bájtot a szolgaeszközről a mestertől kapott kérésre válaszul – vagy a beginTransmission() és endTransmission között használva a mestereszközről küld egy bájtot valamelyik szolgának.

Szintaxisa:

Wire.write(value),

Wire.write(string),

Wire.write(data, length).

Paraméterei:

value: bájtként küldendő érték,

string: bájtok sorozata,

data: length hosszúságú bájtok tömbje.

 

Arduino kód: 61wire02

 

beginTransmission()

Adatküldés inicializálása szolgaeszköz felé, a bájt értékének megadása a write() függvénnyel, endTransmission() küldi végül el.

 

endTransmission()

Elküldi a beginTransmission()-nel hívott címre a write()-ban megadott értékeket. Egy bájtot ad vissza, ami ötféle érték lehet:

0: sikeres átvitel,

1: az adat nem fér bele az átviteli tárolóba,

2: a címről nem érkezett válasz,

3: az adatot nem fogadták,

4: egyéb hiba.

Szintaxisa:

Wire.endTransmission(),

Wire.endTransmission(stop) (stop – lásd feljebb).

 

onReceive()

Szolgaeszközön regisztrál egy függvényt, amit végre kell hajtania, ha a mestertől bármi érkezik.

Szintaxisa:

onReceive(handler).

Paramétere:

handler: a függvény, amit végre kell hajtania.

 

onRequest()

Szolgaeszközön regisztrál egy függvényt, amit végre kell hajtania, ha a mestereszköz adatot szeretne lekérdezni.

Szintaxisa:

onReceive(handler).

Paramétere:

handler: a függvény, amit végre kell hajtania.

  

A gyakorlatban például nagyon hasznos I2C eszköznek bizonyul a digitális potméter, amivel kiterjeszthetjük az Arduino analóg kimeneteinek számát, vagy programozhatóvá alakíthatunk olyan analóg áramköröket, mint egy erősítő vagy rádió.

13.3. †bra Digit†lis potmÇter funkcion†lis rajza.gif

Digitális potméter funkcionális rajza

A digitális potméter egy integrált áramkör (IC – Integrated Circuit), amiben az I2C protokollt értelmező vezérlő, elektronikus kapcsolók és számtalan különféle értékű ellenállás kapott helyet (13.3. ábra AD5171 típusú áramkör).

13.4. †bra Az AD5171 l†bkioszt†sa.png

Az AD5171 lábkiosztása

A 13.3. és 13.4. ábrák összevetésével el tudjuk képzelni, hogy az áramkör fizikai lábaihoz mely funkciók társulnak – ezeket a rajzokat a gyártó biztosítja. GND (ground v. föld) a potenciál alapja, Vdd a tápfeszültség, SCL (Serial Clock) az órajel, SDA (Serial Data) az adatvonal, AD0 (Address), amivel beállíthatjuk az eszköz címét a buszon, A és B a potméter két „szélső” kivezetése, míg W a közepe. Változtassuk egy LED fényerejét I2C buszon kommunikáló digitális potméter segítségével!

 

Amire szükségünk lesz:

-       Arduino,

-       AD5171 (DIP tokozású),

-       LED,

-       220 ohmos ellenállás,

-       2 db 4,7 kiloohmos ellenállás,

-       próbapanel,

-       vezetékek.

 

Kapcsolás:

Kössük az IC tápvezetékeit értelemszerűen az Arduino földjéhez és + 5 V jelölésű kivezetéséhez! Az A4 és A5 csatornákat 4,7 kiloohmos ellenálláson keresztül szintén a + 5 V-hoz. Ezek az úgynevezett felhúzó ellenállások, amik stabilizálják a busz vonalait. Ezután illesszük A4-et az IC SDA (5.) lábához, A5-öt az SCL (4.) lábához. A potmétert használjuk feszültségosztónak és a közepéről hajtsuk meg a LED-et a 220 ohmos soros ellenálláson keresztül. AD0-t, ha földre kötjük, a címet 44-re, ha + 5 V-ra kötjük, 45-re állítja.

13.5. †bra AD5171 bekîtÇse az Arduinoba.png

AD5171 bekötése az Arduinoba 

Arduino kód: 62wirepoti

 

- - - - - - - - - - 

forrás: http://arduino.cc/en/Tutorial/HomePage

Szólj hozzá!

Címkék: leckék könyvtárak Wire lektorált

2014.06.22.
14:09

Írta: harsanyireka

13. /2) Kommunikációs könyvtárak: Firmata

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

A Firmata egy kommunikációs protokoll, aminek célja a számítógépes környezetekkel való adatcsere megkönnyítése.

Sok olyan gyors prototipizálásra alkalmas környezet létezik, amelyiken a firmata protokoll használata már megoldott. Ilyenek például a VVVV, Max/MSP, Processing és Flash. Létezik olyan firmata alapú program (firmware), ami az Arduino minden funkcióját elérhetővé teszi soros parancsokon keresztül, az analóg olvasástól a digitális csatornák kapcsolgatásáig, és ezeket saját számítógépen futó fejlesztőkörnyezetünkből el is tudjuk érni. A könyvtár használatával anélkül hozhatunk létre célfeladatokra kétirányú soros kommunikációs programot, hogy saját protokollt (pl. handshaking) vagy objektumokat fejlesztenénk.

 

Metódusai:

begin()

Elindítja a könyvtárat.

 

begin(long)

Elindítja a könyvtárat és felülírja az előzőleg beállított adatátviteli sebességet arra, amit megadunk.

 

printVersion()

Elküldi a protokoll verziószámát a számítógépnek.

 

blinkVersion()

Elvillogja a protokoll verziószámát a 13-as csatornára kötött LED-en keresztül.

 

printFirmwareVersion()

Elküldi a firmware nevét és verziószámát a számítógépnek.

 

setFirmwareVersion(byte major, byte minor)

Beállíthatjuk a firmware nevét és verziószámát. A firmware neve a programunk nevével fog megegyezni a (.pde) kiterjesztés nélkül.

 

 

Üzenetek küldése:

sendAnalog(byte pin, int value)

Elküldi az analóg bemenet csatornájának számát és értékét.

 

sendDigitalPorts(byte pin, byte firstPort, byte secondPort)

Elküldi a két digitális port állapotát különálló bájtokként.

 

sendDigitalPortPair(byte pin, int value)

Elküldi a két digitális port állapotát egy integer változóként.

 

sendSysex(byte command, byte bytec, byte* bytev)

Önkényesen választott bájtok tömbjeként küld parancsot.

 

sendString(const char* string)

Stringet küld a számítógépnek.

 

sendString(byte command, const char* string)

Parancsként is definiálhatunk stringet, amit elküld.

 

 

Üzenetek fogadása:

available()

Leellenőrzi, hogy van-e bejövő adat a tárolóban.

 

processInput()

Feldolgozza a tárolóban található bejövő üzeneteket és – ha vannak – átvezeti őket a megfelelő visszahívási funkciókhoz.

 

attach(byte command, callbackFunction myFunction)

Funkciót köt bizonyos típusú bejövő üzenetekhez.

 

detach(byte command)

Törli az üzenet típusához kapcsolt funkciót.

 

 

Visszahívási funkciók:

Ahhoz, hogy egy üzenettípushoz funkciót tudjunk társítani, annak valamelyik szabvány visszahívási funkcióval egyeznie kell. Három különböző visszahívási funkció létezik: 

generic

void callbackFunction(byte pin, int value);

Általános visszahívási funkció, pl. csatornák állapotának lekérdezésére.

system_reset

 

void systemResetCallbackFunction(void);

Visszaállítja a firmware-t az alapállapotba.

string

 

void stringCallbackFunction(char *myString);

Karakterláncok visszaadásához.

sysex

 

void sysexCallbackFunction(byte pin, byte byteCount, byte *arrayPointer);

pl. MIDI vezérlőjelek visszaadásához.

 

 

Üzenettípusok: 

ANALOG_MESSAGE

Egy analóg bemenethez tartozó aktuális érték.

 

DIGITAL_MESSAGE

Egy digitális port 8 bitjének értéke.

 

REPORT_ANALOG

Ki-/bekapcsolja az analóg üzeneteket.

 

REPORT_DIGITAL

Ki-/bekapcsolja a digitális üzeneteket.

 

SET_PIN_MODE

Beállít egy csatornát: INPUT/OUTPUT/PWM.

 

FIRMATA_STRING

stringCallbackFunction-nel társítható string alapú üzenettípus.

 

SYSEX_START

Általános, változó hosszúságú üzenetek (pl. MIDI SysEx protokoll)sysexCallbackFunction-nel társítható üzenettípus.

 

SYSTEM_RESET

Visszaállítja a firmware-t az alapállapotába, systemResetCallbackFunction-nel társítható üzenettípus.

 

 

 13.1. †bra Elãre elkÇsz°tett firmata alap£ firmware-ek.png

Előre elkészített firmata alapú firmware-ek

Miután firmatára támaszkodó, előre elkészített firmware-ből többféle is létezik a programcsomagban, nézzük inkább ezek gyakorlati hasznát!

 

AllInputsFirmata

Az összes analóg és digitális bemenet aktuális állapotát a lehető leggyorsabban továbbítja a számítógépnek. Létrehozását az Arduino2Max program inspirálta.

 

AnalogFirmata

A lehető legtöbb analóg portot hasznosítja, beleértve az összes analóg bemenetet, 3, 5, 6, 9, 10, 11 PWM kimeneteket, melyek közül a 9 és 10 szervo meghajtóként is használható.

 

ServoFirmata

Az összes digitális csatornát szervo meghajtóként érhetjük el.

 

I2CFirmata

I2C protokollt használó eszközökkel kommunikálhatunk az Arduinon, mint átalakítón keresztül.

 

StandardFirmata

Minden felsorolt funkciót támogat, elérhetjük a digitális és analóg ki-/bemeneteket, I2C kommunikációt, használhatunk digitális csatornákat szervo meghajtónak.

 

StandardFirmata használata Processingből

Processing kód: 59processingfirmata

Arduino.cc library letöltése: 
http://playground.arduino.cc/Interfacing/Processing 

 

StandardFirmata használata Max/MSP-vel

13.3.2. StandardFirmata haszn†lata MaxMSP-vel.png

 

- - - - - - - - - -

forrás: http://arduino.cc/en/Tutorial/HomePage

 

Szólj hozzá!

Címkék: leckék könyvtárak Firmata lektorált

2014.06.22.
13:39

Írta: harsanyireka

13. /1) Kommunikációs könyvtárak: SoftwareSerial

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

Számítástudományban a könyvtár olyan előre megírt kódrészeket jelent, amik meghatározott komplex funkciók elvégzésére képesek. Osztályaik és függvényeik felhasználásával a független programokban nincs szükség ezen feladatok ismételt megoldására. Általánosságban olyan csomagokként értelmezzük őket, amik szolgáltatásként teszik elérhetővé a konfigurációs adatokat, konstansokat és kódokat. Például egy matematikai könyvtár (Arduino esetében a math.h) a programnyelvből közvetlenül nem elérhető függvényeket írja le, mint a tangens, kotangens, logaritmus, gyökvonás.  A rendkívül hasznos függvényeken túl sok esetben bizonyos típusú hardware elemek használatát könnyítik meg – operációs rendszer hiányában ezeket a könyvtárakat felfoghatjuk úgy is, mint eszközillesztő programokat (device driver). Mivel az Arduino egy nyílt forrású, együttműködő közösség által is fejlesztett rendszer, megkülönböztetünk hivatalos és kontribúciós könyvtárakat. Az előbbieket standardként is szokás nevezni, mivel kiforrottságuk miatt a fejlesztőkörnyezet programcsomagjának részét képezik, és olyan általános funkciókat írnak le, amik végrehajtására minden Arduino-típus képes.

 

Könyvtárak szerkezete

Amikor a két fő rutin mellett (setup és loop) szubrutinokat szeretnénk létrehozni, az a void szubrutin_neve() összefüggés segítségével tehető meg:

Arduino kód: 52voiddot

Ha a fenti kódból könyvtárat szeretnénk létrehozni, akkor legalább két fájlra lesz szükségünk, az egyik az úgynevezett fejléc vagy header fájl (kiterjesztése .h), a másik pedig a forrás vagy source fájl (kiterjesztése .cpp). A fejléc definiálja a könyvtárat – minden kifejezésnek szerepelnie kell benne, amire hivatkozni szeretnénk –, míg a forrásfájl tartalmazza a kódot.

A fejléc már a fájl nevében tartalmazza a könyvtárunk nevét (Morse.h):
53morseH

A forrásfájlba már betöltjük a fejlécet, hiszen a definiált osztályt és szubrutinjait töltjük meg tartalommal (Morse.cpp):
54morseCpp

Végül a kész könyvtárunkkal a fenti példakódunk lerövidült és univerzálisabbá vált – használata pedig így néz ki:
55morsekonyvtar

 

A fentiek alapján láthatjuk, hogyan épülnek fel a könyvtárak és hogyan kell őket használni. Akár saját könyvtár készítéséhez is hozzáfoghatunk, azonban mielőtt ezt megtennénk, érdemes kutatómunkát végezni, hiszen mérhetetlenül sokféle funkciót lefed a már létező könyvtárak összessége.

 

SoftwareSerial könyvtár

Az Arduino egyetlen fizikai soros porttal rendelkezik, ami a beépített UART (Universal Asynchronous Receiver Transmitter) terhére mentesíti a feldolgozóegység erőforrásait, amíg a 64 bájtnyi soros átmeneti tárolóban van elég hely. Az integrált port a 0-ás és 1-es digitális csatornákon kommunikál (lásd 9. fejezet), ahol a számítógéphez USB átalakítóval is csatlakozik.

A SoftwareSerial könyvtárat – ahogy a neve is sugallja – azért fejlesztették ki, hogy a feldolgozóegység terhére a többi digitális csatornán is létre lehessen hozni soros kommunikációs felületeket. Segítségével egyszerre kapcsolódhatunk a számítógéphez és más soros eszközökhöz, kijelzőkhöz, digitális szenzorokhoz, vagy kialakíthatunk soros hálózatot több Arduino között. A szoftveres portok maximális sebessége is 115200 baud lehet, ráadásul megváltoztatható a jel polaritása, ami szélesíti a kompatibilis egységek spektrumát, azonban több port létrehozása esetén az adatok egyidejű fogadása nem lehetséges.

Arduino kód: 56softwareserial

A könyvtár függvényei:

  • available()
  • begin()
  • isListening()
  • overflow()
  • peek()
  • read()
  • print()
  • println()
  • listen()
  • write()

 

SoftwareSerial()

Hívásakor létrehoz egy SoftwareSerial objektumot az általunk megadott névvel. Ahhoz, hogy a kommunikációt engedélyezzük, meg kell hívnunk a SoftwareSerial.begin() parancsot is. 

Szintaxisa:

SoftwareSerial(Rx,Tx). 

Paraméterei:

Rx: a szoftveres soros portunk bejövő csatornája,

Tx: a szoftveres soros portunk kimenő csatornája.

Példakód:

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin); 

 

available()

Visszaadja a szoftveres átmeneti tárolóban elérhető, beérkezett bájtok számát. 

Szintaxisa:

mySerial.available(). 

Példakód:

void loop() {
    if (mySerial.available()>0){ // ha már van valami a tárolóban
    mySerial.read(); // olvassuk ki
   }
}

 

begin()

Beállítja a soros kommunikáció sebességét (baud rate). A szabvány átviteli sebességek: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600 és 115200.

Szintaxisa:

mySerial.begin(baudrate).

Paramétere:

baudrate: long típusú változó a fenti szabványértékek valamelyike. 

Példakód:

void setup()  {
  // beállítjuk a vevő és adó csatornákat bemenetnek és kimenetnek
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // meghatározzuk az átviteli sebességet és megnyitjuk a portot
  mySerial.begin(9600);
}

  

isListening()

Megnézhetjük vele, hogy a kiválasztott szoftveres soros port valóban aktív-e. Boole típusú választ ad vissza.

Szintaxisa:

mySerial.isListening(). 

Példakód:

void loop() {
    if (portOne.isListening()) { // ha a port aktív, akkor
       Serial.println("A port aktív!"); 
}

  

overflow()

A szoftveres soros port átmeneti tárolója 64 bájtot képes elraktározni. Amennyiben ezek nem kerülnek időben kiolvasásra, a tároló túlcsordul – a régi adatok helyét nem veszik át az újak és lemaradunk a közölt információ egy részéről. Ezzel a függvénnyel ellenőrizhetjük, hogy történt-e túlcsordulás. Az ellenőrzést követően a függvény válaszát képező Bool változó hamis állapotba kerül.

Szintaxisa:

mySerial.overflow().

Példakód: 

void loop() {
    if (portOne.overflow()) { // ha túlcsordult a tároló, akkor
       Serial.println("A tároló túlcsordult!"); 
}

 

read()

Karakterenként kiolvassa a soros tárolót. 

Szintaxisa:

mySerial.read().

Példakód:

void loop() {
  char c = mySerial.read();
}

 

peek()

Hasonlóan a read()-hez, az utolsó a porton beolvasott karaktert adja vissza, ha nem jött semmi –1-et.

Szintaxisa:

mySerial.peek().

 

print()

Adatokat küld a szoftveres soros port Tx csatornájára. A kiírt bájtok számát adja vissza. 

Arduino kód: 57softwareserial02

 

println()

Ahogy az a fenti példából is látszik, a küldendő adatot automatikusan kiegészíti a „soremelés” kódjával – ugyanúgy, mint azt a hardware-es soros portnál már láttuk.

 

listen()

Több szoftveres soros port használata esetén egyszerre csak egy port kaphatja meg az olvasás jogát. Ezzel a függvénnyel beállíthatjuk, melyik port legyen az, amelyik olvashat. Az összes többi portra érkező adatok elvesznek. 

Szintaxisa:

mySerial.listen().

Arduino kód: 58softwareserial03

 

write()

Az adatokat nyers bájt formátumban küldi ki a portra és visszaadja a kiírt bájtok számát. 

Példakód:

//elküldi a “hello” karaktersort és visszaadja a kiküldött karakterek számát

int bytesSent = mySerial.write(“hello”);

 

- - - - - - - - - -

forrás: http://arduino.cc/en/Tutorial/HomePage

Szólj hozzá!

Címkék: leckék könyvtárak softwareserial lektorált

süti beállítások módosítása