====== WIRE library funkciók ====== A Wire könyvtárral valósítható meg legegyszerűbben az [[hu:comm:bus_i2c|I²C]] és TWI kommunikáció az [[hu:arduino:boards|Arduino kártyák]]kal. A kommunikáció az [[hu:comm:bus_i2c|I²C]] esetében minden esetben master-slave jellegű, de ez nem zárja ki az oda-vissza kommunikációt sem. Sőt, az Arduino-k között is alkalmazható a (kétirányú) [[hu:comm:bus_i2c|I²C]]. A standard I²C egyaránt alkalmazhat 7 és 8 bites címzést. A Wire könyvtár 7 bites címzést használ. Ezen felül a könyvtár 32 bájt hosszú puffert használ, azaz ennél nagyobb méretű telegrammokat nem tud továbbítani (az efölötti részt egyszerűen levágja). A könytár a **Wire.h** néven hívható fel, az alapból telepített IDE tartalmazza:


#include

Külön problémát jelenthet, hogy az I²C bájtos átvitelt alkalmaz, ehhez sok mindent, például a float típusú méréseredményeket vég nélkül konvertálgatni kell. Erre ad pár megoldást az [[hu:arduino:avr_reference|avr_libc standard könyvtár]]. Konkrétan a fenti példára például [[hu:arduino:avr_reference#dtostrf|itt]] talál megoldást. ===== Wire.begin() ===== {{anchor:begin}} A paranccsal az I²C funkció inicializálható a SETUP blokkban. === Szintaktika === Wire.begin() \\ Wire.begin(address) //address (byte)//: 7 bites slave cím (0..127) \\ A címet a slave-nél kell megadni. Ha nincs cím-megadás, akkor a master-t definiáltuk. ===== Wire.requestFrom() ===== {{anchor:requestfrom}} A masteren alkalmazható parancs egy slave eszköztől kér adott mennyiségű információt. Mindaddig, amíg a kérés nem teljesül, a master blokkolja az I²C forgalmát, azaz prioritással várja az adott mennyiségű információt a slave-től. === Szintaktika === Wire.requestFrom(address, quantity) \\ Wire.requestFrom(address, quantity, stop) \\ //address// (byte): 7 bites slave címe, ahonnan az adatokat várja (0..127) \\ //quantity// (byte): a várt adathossz bájtban \\ //stop// (bool): **true:** a kérés után felszabadítja az I²C-t, **false:** folyamatosan újraküldési parancsot ad ki a slave felé, ezáltal blokkolja az I²C-t \\ Default: **TRUE**. \\ A függvény **visszatérési értéke** bájt, megadja, hogy hány bájt érkezett a slave felől.Olvasása opcionális. === Példa ===


  Wire.beginTransmission(address);
  Wire.write(0x5);                   // starting with register 0x5
  Wire.endTransmission(false);
  Wire.requestFrom(address,3,true);  // request a total of 3 registers
  value1 = Wire.read();              //register 0x5
  value2 = Wire.read();              //register 0x6
  value3 = Wire.read();              //register 0x7

===== Wire.beginTransmission() ===== {{anchor:begintransmission}} Az átvitel megkezdése az adott slave-en. A parancsot a Wire.write()-nak, majd az endTransmission()-nak kell követnie. === Szintaktika === Wire.beginTransmission(address) //address// (byte): 7 bites slave címe, ahová az adatokat kell továbbítani (0..127) \\ ===== Wire.endTransmission() ===== {{anchor:endtransmission}} Az átvitel lezárása az adott slave-en. A parancsot a Wire.write()-nak, és az endTransmission()-nak kell megelőznie. === Szintaktika === Wire.endTransmission() \\ Wire.endTransmission(stop) \\ //stop// (bool): **true:** "stop" parancsot küld, felszabadítja az I²C-t, **false:** folyamatosan újraküldési parancsot ad ki a slave felé, ezáltal blokkolja az I²C-t \\ Default: **TRUE**. A függvény visszatérési értéke bájt: Olvasása opcionális. \\ * 0 : végrehajtva * 1 : az adat túl nagy a pufferhez képest (> 32 byte) * 2 : a cím nem érvényes / nem található * 3 : az adat nem továbbítható (nem fogadja a címzett egység) * 4 : egyéb probléma ===== Wire.write() ===== {{anchor:write}} A paranccsal adatok küldhetők az I²C-n keresztül. === Szintaktika === Wire.write(value) \\ Wire.write(string) \\ Wire.write(data, length) \\ //value// (byte): egy bájt küldése \\ //string// (byte): egy sorozat bájt küldése (kisbetűs string!) \\ //data// (byte): egy bájt-tömb küldése \\ //length// (byte): a bájtok száma (maximum 32 fér a pufferbe, a többit levágja) \\ A függvény visszatérési értéke bájt, az átvitt bájtok számát adja meg. Olvasása opcionális. === Példa ===



// OB121.com példaprogram magyarul

#include 

byte val = 0;

void setup()
{
  Wire.begin(); // az i2c felhívása
}

void loop()
{
  Wire.beginTransmission(44);  // a #44 című egység felé forgalmazás (0x2c)                             
  Wire.write(val);             // egy bájt küldése 
  Wire.endTransmission();      // átvitel leállítása

  val++;        // érték növelése
  if(val == 64) // 64-nél..
  {
    val = 0;    // ..vissza 0-ra
  }
  delay(500);
}

===== Wire.available() ===== {{anchor:available}} A paranccsal a pufferben beolvasásra váró bájtok száma érhető el. === Szintaktika === Wire.available() A függvénynek paramétere nincs, visszatérési értéke a beolvasásra váró bájtok száma. ===== Wire.read() ===== {{anchor:read}} A paranccsal egy bájt olvasható a pufferből. === Szintaktika === Wire.read() A függvénynek paramétere nincs, visszatérési értéke a következő bájt (//azaz mindig csak egy bájt//) a pufferből. Az ott található adatmennyiséget a //requestFrom()//-mal lehet lekérdezni. A függvény a //Steam// alkalmazási osztályt hívja fel. === Példa ===


// OB121.com példaprogram magyarul
#include 

void setup()
{
  Wire.begin();        // i2c start
  Serial.begin(9600);  // soros monitor bekapcsolása
}

void loop()
{
  Wire.requestFrom(2, 6);    // 6 bájtot vár a #2 című slave-től

  while(Wire.available())    // lehet, hogy a slave kevesebbet küldött
  { 
    char c = Wire.read();    // a bájtnyi információ beolvasása char-ként
    Serial.print(c);         // az egy karakter kiírása a soros monitorra
  }

  delay(500);
}

===== Wire.SetClock() ===== {{anchor:setclock}} A funkció módosítja az I²C kommunikáció órajelét. Az I²C slave-eknek nincs minimum sebességhatáruk, de jellemzően az I²C egységek 100KHz-en kommunikálnak. === Szintaktika === Wire.setClock(clockFrequency) //clockFrequency// (long): a kommunikáció frekvenciája: \\ Az elfogadott értékek: \\ * 100000 (standard mode) * 400000 (fast mode) Néhány processzor kezeli az alábbi értékeket is: * 10000 (low speed mode) * 1000000 (fast mode plus) * 3400000 (high speed mode) Tájékozódjon a technikai leírásokból, hogy az adott egységek mely sebességeket preferálják. A függvénynek visszatérési értéke nincs. ===== Wire.onReceive() ===== {{anchor:onreceive}} A regisztálható funkció akkor kerül felhívásra, ha a slave egység forgalmazást vár a master-től. === Szintaktika === Wire.onReceive(handler) //handler// A paraméter a slave által várt bájtok számát adja meg. A funkciót függvényként kell felhívni: **void myHandler(int numBytes)**. A funkciónak visszatérési értéke nincs. === Példa ===


// OB121.com példaprogram magyarul
#include 

void setup() {
  Wire.begin(8);                // bejelentkezik a i2c-re a 8-as címmel
  Wire.onReceive(receiveEvent); // a funkció regisztrálása
  Serial.begin(9600);           // soros monitor inicializálása
}

void loop() {                   // a loop maradhat ezesetben üresen, 
  delay(100);                   // némi késleltetéssel
}

// a regisztrálás után a funkció önálló függvényként érhető el:

void receiveEvent(int howMany) {
  while (1 < Wire.available()) {   // amíg van a pufferben valami
    char c = Wire.read();          // egy bájt beolvasása char-ként
    Serial.print(c);               // kiírás a soros monitorra
  }
  int x = Wire.read();             // a megkapott bájtok száma
  Serial.println(x);               // kiírás a soros monitorra
}

===== Wire.onRequest() ===== {{anchor:onrequest}} A regisztálható funkció akkor kerül felhívásra, ha a master egység forgalmazást vár a slave-től. === Szintaktika === Wire.onRequest(handler) //handler// A funkciót függvényként kell felhívni: **void myHandler()**. A hívásnak paramétere nincs. A funkciónak visszatérési értéke nincs. === Példa ===

=== Kapcsolódó témakörök ===