fizikai számítástechnika, arduino

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 

EEPROM könyvtár

Az Arduino három különböző típusú memóriával rendelkezik, az egyes típusok kapacitása a mikrokontroller fajtájától függ:

• Flash: Többszörösen újraírható memória, tartalma az eszköz kikapcsolását követően is megmarad. A fejlesztőkörnyezet által lefordított kódunk itt tárolódik gépi utasítások formájában.
• RAM: Gyors hozzáférésű memória s programunk futtatása közben ideiglenesen tárolt adatok számára. Tartalma kikapcsoláskor elvész.
• EEPROM: Flashnél régebbi technológia a kikapcsolást követően is megőrzendő adatok, konfigurációs beállítások, kezdeti állapotok, hosszabb szövegek eltárolásához. Nagyságrendileg 100.000 törlés az életideje.

Az EEPROM könyvtár azokat a funkciókat fogja össze, amikkel bájtonként tudjuk írni és olvasni a beépített memória ezen típusát. Az Arduino Mega kontrollerének (ATmega1280 és ATmega2560) 4096, az UNO és Duemilanove (ATmega328) 1024, a Diecimila, NG (ATmega168) és Digital (ATmega8) 512 bájt a kapacitása.

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

-       read()

-       write()

EEPROM.read() 

Visszaadja az EEPROM adott címén található bájt értékét.

Szintaxisa:

EEPROM.read(address).

Paraméterei:

address: a memóriacím, ahonnan az olvasás kezdődik (0-tól számozva).

Arduino kód: 69eepromread

EEPROM.write()

Beállítja az EEPROM adott címén a megadott bájt értékét. Egy bájt kiírása 3,3 ms-ot vesz igénybe, ami a többi memóriatípus sebességét tekintve igen lassú folyamatnak számít, használata kihathat a teljes kódunk futására. Ne felejtsük el, hogy az EEPROM 100.000 írás után használhatatlanná válik!

Szintaxisa:

EEPROM.write(address, value). 

Paraméterei:

address: a memóriacím, ahonnan az olvasás kezdődik (0-tól számozva),

value: a bájt értéke, amit szeretnénk beírni.

Arduino kód: 70eepromwrite

LiquidCrystal könyvtár

A Hitachi HD44780 folyadékkristályos kijelző meghajtó IC hosszú időn keresztül uralta a piacot, mint a rendkívül populáris, kizárólag monokróm szöveg megjelenítésére alkalmas faxok, telefonok, lézernyomtatók, fénymásoló gépek kijelzőjének vezérlője. Mostanra hobbisták és gyors prototipizálók közkedvelt megoldásává vált a mikrokontrollerek alfanumerikus üzeneteinek megjelenítésére. Az IC által meghajtott kijelzők pár általános szabálynak felelnek meg. Egy karakter mindig 5 vízszintes és 8 függőleges pixelből áll. A leggyakoribb típus egy sorban 8 karakter megjelenítésére alkalmas (8 x 1), de létezik 16 x 2, 20 x 2 és 20 x 4-es is. A kijelzők készülhetnek LED-es, fluoreszcens, elektrolumineszcens háttérvilágítással, vagy anélkül. Az IC maga is egy mikrokontroller, ROM-jában 208 karakter térképét tárolja – japán verziója a kana, európai verziója nyugati és cirill ABC betűiből áll. A LiquidCrystal könyvtár a vezérlő IC instrukciós kódjait és kommunikációs protokollját implementálta pár könnyen használható függvény formájában.

6 x 2-es alfanumerikus LCD HD44780-as vezérlővel

A kijelző csatolófelülete (interface), amihez kapcsolódhatunk, egy párhuzamos interfész – a 8 bitnyi adatot minden órajelre egyszerre kell megadni (D0-D7 lábak). Szerencsére szöveges üzenetekhez 4 bites üzemmódot is választhatunk, ami szabadon hagy 4 Arduino csatornát más célokra. Az RS (Register Select) láb logikai alacsonyra vagy magasra állításával választhatjuk meg, hogy az adatvonalak a kijelző mely memóriaterületére írjanak. Az írást az EN (Enable) lábbal engedélyezhetjük. Az adatregiszter tárolja az ASCII kódolású bájtokat, amik karakterként kerülnek megjelenítésre, az instrukciós regiszterben pedig utasítások tárolódnak a meghajtó számára. Ezek az utasítások a kijelző törlésére, a kurzor mozgatására és egyéb funkciókra vonatkoznak. A regiszterek állapotát vissza is olvashatjuk – az RW láb állapotának változtatásával megfordítható a D0-D7 adatvonalak iránya. A kijelző kontrasztját analóg módon a tápfeszültség leosztásával Vo lábon tudjuk beállítani (vagy digitális potméterrel). A háttérvilágítást annak típusától függően a kontraszthoz hasonló módon kezelhetjük. Megfelelő illesztéssel LED-es háttérvilágítást az Arduino egy PWM képes kimenetére is köthetjük, így programozhatóvá válik a fényerő állítása is.

Amire szükség lesz:

-       Arduino,

-       LCD kijelző HD44780-as meghajtóval,

-       10 kiloohmos potméter,

-       próbapanel,

-       vezetékek.

Kapcsolás:

Kössük az LCD RS lábát az Arduino digitális 12-es csatornájára, az EN lábát pedig a digitális 11-re. Az LCD 4-es, 5-ös, 6-os, 7-es adatvonalait pedig rendre a digitális 5, 4, 3, 2 csatornákra. A 10 kiloohmos potméterrel készítsünk feszültségosztót az 5 V-os tápvezetékről és kössük be a potméter közepét az LCD kontrasztját szabályozó Vo lábra. Az LCD 5 V-os tápfeszültségről működik (GND, Vcc). RW-t kössük a földre!

LCD kijelző Arduinohoz kapcsolása

Arduino kód: 71LCD

LiquidCrystal()

Létrehozza a kijelző egy példányát, ami 4 vagy 8 bites módban fog működni, attól függően, hogy a híváskor hány adatvonalat adunk meg. 

Szintaxisa:

LiquidCrystal(RS, EN, D4, D5, D6, D7),

LiquidCrystal(RS, RW, EN, D4, D5, D6, D7),

LiquidCrystal(RS, EN, D0, D1, D2, D3, D4, D5, D6, D7),

LiquidCrystal(RS, RW, EN, D0, D1, D2, D3, D4, D5, D6, D7).

Paraméterei:

RS: Annak a digitális csatornának a száma, amihez a REGISTER SELECT van kötve.

EN: Annak a digitális csatornának a száma, amihez az ENABLE van kötve.

RW: Annak a digitális csatornának a száma, amihez a READ/WRITE van kötve.

D0-D7: Azok a digitális csatornák, amikhez az adatvonalak kapcsolódnak.

begin()

A kijelző méreteit, sorok és oszlopok számát határozza meg a könyvtár számára.

Szintaxisa:

lcd.begin(cols, rows).

Paraméterei:

lcd: a LiquidCrystal példány neve,

cols: a kijelző oszlopainak száma,

rows: a kijelző sorainak száma.

clear()

Üresre törli az megjelenítendő karaktereket tartalmazó adatregisztert és a kijelzőt.

Szintaxisa:

lcd.clear().

Paramétere:

lcd: a LiquidCrystal példány neve.

home()

A kurzort az első sor első karakterére – kijelző bal felső sarkába – mozgatja. 

Szintaxisa:

lcd.home(). 

Paramétere:

lcd: a LiquidCrystal példány neve.

setCursor()

A kurzort a megadott helyre mozgatja.

Szintaxisa:

lcd.setCursor(cols,rows). 

Paraméterei:

lcd: a LiquidCrystal példány neve,

cols: az oszlop, ahová a kurzort mozgatjuk,

rows: a sor, ahová a kurzort mozgatjuk.

write()

Egy bájtot, vagyis karaktert ír ki a kijelzőre. 

Szintaxisa:

lcd.write(data).

Paraméterei:

lcd: a LiquidCrystal példány neve,

data: a megjelenítendő karakter ASCII-kódja.

Példakód:

void loop() {
  if (Serial.available()) {
    lcd.write(Serial.read());
  }
}

print()

Szöveget jelenít meg a kijelzőn.

Szintaxisa:

lcd.print(data),

lcd.print(data, BASE).

Paraméterei:

lcd: a LiquidCrystal példány neve,

data: char, byte, long, int, string – amit megjelenítünk,

BASE: számrendszer alapja (opcionális) BIN, HEX, OCT, DEC.

cursor()

Hívását követően egy alulvonásként megjeleníti a kurzort.

noCursor()

Hívását követően kikapcsolja a kurzor megjelenítését.

blink()

Ha a kurzor látható, akkor bekapcsolja a villogtatását.

noBlink()

Ha a kurzor látható, akkor kikapcsolja a villogtatását.

noDisplay()

Kikapcsolja a kijelzőt.

display()

Visszakapcsolja a kijelzőt, ha előtte a noDisplay() hívással ki volt kapcsolva, és újra megjeleníti a szöveget, ami a kikapcsolás pillanatában volt látható.

scrollDisplayLeft()

Hívásakor egy karakterrel eltolja a kijelző teljes tartalmát balra.

scrollDisplayRight()

Hívásakor egy karakterrel eltolja a kijelző teljes tartalmát jobbra.

Arduino kód: 72LCDscroll

autoScroll()

Bekapcsolja a karakterek automatikus eltolását. Amikor egy új karaktert jelenítünk meg, a beállított iránynak megfelelően a már meglévő szöveget egy pozícióval elmozgatja.

Arduino kód: 73LCDauto

noAutoscroll()

Kikapcsolja a karakterek automatikus eltolását.

leftToRight()

Az automatikus karaktereltolás irányának beállítása balról jobbra.

rightToLeft()

Az automatikus karaktereltolás irányának beállítása jobbról balra.

createChar()

Segítségével létrehozhatunk olyan karaktereket, amit nem tartalmaz a ROM. Ezeket az 5 x 8 pontból álló jeleket glyph-nek is szokás nevezni. A vezérlő 8 különféle glyph-et tud eltárolni a létrehozása után.

Szintaxisa:

lcd.createChar(num, data).

Paraméterei:

lcd: a LiquidCrystal példány neve,

num: 0–7 a glyph száma, amelyik pozíción tárolni szeretnénk,

data: a karakter pixeleit tartalmazó tömb.

Arduino kód: 74create

Smiley glyph

- - - - - - - - -

forrás: http://arduino.cc/en/Tutorial/HomePage, http://arduino.cc/en/Tutorial/LiquidCrystal, http://arduino.cc/en/Reference/EEPROM

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.

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.

Arduino Ethernet Shielddel

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/HomePage, http://arduino.cc/en/reference/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 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.

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:

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.

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:

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.

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/SD, http://arduino.cc/en/Tutorial/HomePage

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.

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ó.

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).

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.

AD5171 bekötése az Arduinoba 

Arduino kód: 62wirepoti

- - - - - - - - - - 

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

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.

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

- - - - - - - - - -

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