LCD kijelző– gyakori vendég az Arduino projektekben. De az összetett áramkörökben előfordulhat, hogy hiányoznak az Arduino portok, mivel sok-sok tűvel rendelkező pajzsot kell csatlakoztatni. A megoldás ebben a helyzetben az lehet I2C/IIC egy adapter, amely egy szinte szabványos Arduino 1602 pajzsot köt össze Uno, Nano vagy Mega kártyákkal, mindössze 4 tűvel. Ebben a cikkben megvizsgáljuk, hogyan csatlakoztathat LCD képernyőt I2C interfésszel, milyen könyvtárakat használhat, írunk egy rövid példavázlatot, és megnézzük a gyakori hibákat.

Folyadékkristályos kijelző LCD 1602 jó választás karakterláncok kimenetére különféle projektekben. Olcsó, különféle módosítások vannak különböző háttérvilágítási színekkel, könnyen letölthet kész könyvtárakat az Arduino vázlatokhoz. De ennek a képernyőnek a fő hátránya, hogy a kijelző 16 digitális tűvel rendelkezik, amelyből legalább 6 szükséges, ezért ennek az LCD-képernyőnek az i2c nélküli használata komoly korlátozásokat jelent az Arduino Uno vagy Nano kártyák számára. Ha nincs elég érintkező, akkor vásárolnia kell egy Arduino Mega kártyát, vagy mentenie kell a névjegyeket, beleértve a kijelző i2c-n keresztüli csatlakoztatását is.

Az LCD 1602 lábak rövid leírása

Nézzük meg közelebbről az LCD1602 érintkezőit:

Mindegyik csapnak megvan a maga célja:

1. Földi GND;
2. Tápellátás 5 V;
3. A monitor kontrasztjának beállítása;
4. Parancs, adat;
5. Adatok írása és olvasása;
6. Engedélyezés;

7-14. Adatvonalak;

1. Plusz háttérvilágítás;
2. Mínusz a háttérvilágítás.

Kijelző specifikációi:

• Karakter megjelenítési típus, lehetőség van szimbólumok betöltésére;
• LED háttérvilágítás;
• Vezérlő HD44780;
• Tápfeszültség 5V;
• 16x2 karakteres formátum;
• Üzemi hőmérséklet tartomány -20C és +70C között, tárolási hőmérséklet -30C és +80C között;
• Betekintési szög 180 fok.

Az LCD csatlakozási rajza az Arduino kártyához i2C nélkül

A monitor I2C nélküli Arduino mikrokontrollerhez való közvetlen csatlakoztatásának szabványos diagramja a következő.

A csatlakoztatott érintkezők nagy száma miatt előfordulhat, hogy nincs elég hely a szükséges elemek csatlakoztatásához. Az I2C használatával a vezetékek száma 4-re, a foglalt érintkezők száma pedig 2-re csökken.

Hol vásárolhat LCD képernyőket és pajzsokat az Arduino számára

Az 1602-es LCD-kijelző (és a 2004-es verzió) meglehetősen népszerű, így a hazai webáruházakban és a külföldi oldalakon is könnyen megtalálható. Íme néhány link a leginkább elérhető lehetőségekhez:

LCD1602+I2C kék képernyős modul, Arduino kompatibilis	Egy egyszerű LCD1602 kijelző (zöld háttérvilágítás) olcsóbb, mint 80 rubel	Nagy LCD2004 képernyő I2C HD44780-zal Arduinohoz (kék és zöld háttérvilágítás)
1602-es kijelző IIC adapterrel és kék háttérvilágítással	Az LCD1602 másik változata forrasztott I2C modullal	IIC/I2C/TWI/SPI portos adaptermodul 1602-es pajzshoz, kompatibilis az Arduino-val
RGB háttérvilágítású kijelző! LCD 16×2 + billentyűzet + Buzzer Shield Arduino-hoz	Pajzs Arduino-hoz gombokkal és képernyővel LCD1602 LCD 1602	LCD kijelző 3D nyomtatóhoz (Smart Controller for RAMPS 1.4, Text LCD 20×4), SD és MicroSD kártyaolvasó modul

Az I2C protokoll leírása

Mielőtt megvitatná a kijelző Arduino-hoz i2c adapteren keresztüli csatlakoztatását, beszéljünk röviden magáról az i2C protokollról.

I2C/IIC(Inter-Integrated Circuit) egy protokoll, amelyet eredetileg az integrált áramkörök elektronikus eszközön belüli kommunikálására hoztak létre. A fejlesztés a Philips tulajdona. Az i2c protokoll egy 8 bites busz használatán alapul, amely a vezérlőelektronikában lévő blokkok kommunikálásához szükséges, valamint egy címzési rendszeren, melynek köszönhetően ugyanazon a vezetékeken keresztül több eszközzel is kommunikálhatunk. Egyszerűen csak adatokat továbbítunk egyik vagy másik eszközre, az adatcsomagokhoz hozzáadva a kívánt elem azonosítóját.

A legegyszerűbb I2C áramkör tartalmazhat egy mestereszközt (leggyakrabban egy Arduino mikrokontroller) és több szolgát (például egy LCD-kijelzőt). Minden eszköznek van egy címe 7 és 127 között. Nem lehet két azonos című eszköz ugyanabban az áramkörben.

Az Arduino alaplap támogatja az i2c-t hardverben. Az A4 és A5 érintkezők segítségével csatlakoztathatja az eszközöket ezzel a protokollal.

Az I2C működésének számos előnye van:

• A működéshez csak 2 vonal szükséges - SDA (adatvonal) és SCL (szinkronizálási vonal).
• Számos vezető eszköz csatlakoztatása.
• Csökkentett fejlesztési idő.
• Csak egy mikrokontroller szükséges a teljes eszközkészlet vezérléséhez.
• Az egy buszra csatlakoztatható mikroáramkörök számát csak a maximális kapacitás korlátozza.
• Magas fokú adatbiztonság az áramkörökbe épített speciális túlfeszültség-szűrő szűrőnek köszönhetően.
• Egyszerű eljárás a felmerülő hibák diagnosztizálására és a hibák gyors hibakeresésére.
• A busz már magába az Arduinóba integrálva van, így nincs szükség további buszinterfész fejlesztésére.

Hibák:

• Van egy kapacitív korlát a vonalon - 400 pF.
• Nehéz programozni egy I2C vezérlőt, ha több különböző eszköz van a buszon.
• Nagyszámú eszköz esetén megnehezíti a hiba elkülönítését, ha az egyik hibásan lemerül.

i2c modul LCD 1602 Arduino-hoz

Az i2c kijelző használatának leggyorsabb és legkényelmesebb módja az Arduino-ban, ha kész képernyőt vásárol beépített protokolltámogatással. De nincs túl sok ilyen képernyő, és nem is olcsók. De már rengeteg különböző szabványos képernyőt gyártottak. Ezért ma a legkedvezőbb és legnépszerűbb lehetőség egy külön I2C modul vásárlása és használata - egy adapter, amely így néz ki:

A modul egyik oldalán i2c érintkezőket látunk - föld, táp és 2 az adatátvitelhez. A másik adapteren külső tápcsatlakozókat látunk. És természetesen a táblán sok csap található, amelyekkel a modult a szabványos képernyőtüskékre forrasztják.

Az i2c kimenetek az Arduino kártyához való csatlakozásra szolgálnak. Szükség esetén külső tápellátást csatlakoztatunk a háttérvilágításhoz. A beépített trimmerrel egyéni kontrasztértékeket állíthatunk be J

A piacon megtalálhatók az LCD 1602 modulok már forrasztott adapterekkel, használatuk a lehető legegyszerűbb. Ha külön adaptert vásárolt, akkor azt először a modulhoz kell forrasztania.

Az LCD-képernyő csatlakoztatása az Arduino-hoz I2C-n keresztül

A csatlakoztatáshoz magára az Arduino kártyára, egy kijelzőre, egy kenyérsütő táblára, összekötő vezetékekre és egy potenciométerre van szükség.

Ha speciális különálló i2c adaptert használ, először forrasztania kell a képernyőmodulhoz. Ott nehéz hibázni, ezt a sémát lehet követni.

Az i2c támogatással rendelkező LCD monitor négy vezetékkel csatlakozik az alaplaphoz - két vezeték az adatokhoz, két vezeték az áramellátáshoz.

• A GND tű csatlakozik a GND-hez az alaplapon.
• A VCC tűje 5V-on van.
• Az SCL az A5 érintkezőhöz csatlakozik.
• Az SDA az A érintkezőhöz csatlakozik.

És ez minden! Nincsenek dróthálók, amelyekbe nagyon könnyű belegabalyodni. Ugyanakkor egyszerűen a könyvtárakra bízhatjuk az i2C protokoll megvalósításának minden bonyolultságát.

Könyvtárak az i2c LCD kijelzővel való munkavégzéshez

Az Arduino és az LCD 1602 I2C buszon keresztüli interakciójához legalább két könyvtárra lesz szüksége:

• Az I2C-vel való munkavégzéshez használható Wire.h könyvtár már benne van a szabványos Arduino IDE programban.
• A LiquidCrystal_I2C.h könyvtár, amely sokféle parancsot tartalmaz a monitor I2C buszon keresztüli vezérléséhez, és lehetővé teszi a vázlat egyszerűbbé és rövidebbé tételét. Ezenkívül telepítenie kell a könyvtárat A kijelző csatlakoztatása után telepítenie kell a LiquidCrystal_I2C.h könyvtárat is.

Miután az összes szükséges könyvtárat a vázlathoz csatlakoztattuk, létrehozunk egy objektumot, és használhatjuk annak összes funkcióját. A teszteléshez töltsük be a következő szabványos példavázlatot.

#beleértve #beleértve // A könyvtárat is beleértve //#include // Alternatív könyvtár csatlakoztatása LiquidCrystal_I2C lcd(0x27,16,2); // Adja meg az I2C címet (a leggyakoribb érték), valamint a képernyő paramétereit (LCD 1602 esetén - 2 sor, egyenként 16 karakter //LiquidCrystal_PCF8574 lcd(0x27); // Opció a PCF8574 könyvtárhoz void setup( ) ( lcd.init (); // A kijelző inicializálása lcd.backlight(); // A háttérvilágítás csatlakoztatása lcd.setCursor(0,0); // Állítsa a kurzort az első sor elejére lcd.print(" Hello"); lcd.setCursor(0,1); // Állítsa a kurzort a második sor elejére lcd.print("ArduinoMaster"); // Írjon be szöveget a második sorba ) void loop() ( )

A LiquidCrystal_I2C könyvtár funkcióinak és módszereinek leírása:

• home() és clear() - az első funkció lehetővé teszi a kurzor visszaállítását a képernyő elejére, a második ugyanezt teszi, ugyanakkor töröl mindent, ami korábban a monitoron volt.
• write(ch) – lehetővé teszi egyetlen ch karakter kinyomtatását a képernyőre.
• cursor() és noCursor() – megjeleníti/elrejti a kurzort a képernyőn.
• blink() és noBlink() – a kurzor villog/nem villog (ha a megjelenítése korábban engedélyezve volt).
• display() és noDisplay() – lehetővé teszi a kijelző csatlakoztatását/letiltását.
• scrollDisplayLeft() és scrollDisplayRight() – görgeti a képernyőt egy karakterrel balra/jobbra.
• autoscroll() és noAutoscroll() – lehetővé teszi az automatikus görgetés mód engedélyezését/letiltását. Ebben a módban minden új karakter ugyanarra a helyre kerül, és kiszorítja a képernyőre korábban írottakat.
• leftToRight() és rightTo Left() – A megjelenített szöveg irányának beállítása – balról jobbra vagy jobbról balra.
• createChar(ch, bitmap) – létrehoz egy karaktert ch kóddal (0–7), bittérképek tömbjét használva fekete-fehér pontok létrehozásához.

Alternatív könyvtár az i2c kijelzővel való munkavégzéshez

Bizonyos esetekben hibák léphetnek fel, amikor a megadott könyvtárat PCF8574 vezérlőkkel felszerelt eszközökkel használja. Ebben az esetben a LiquidCrystal_PCF8574.h könyvtár javasolható alternatívaként. Kibővíti a LiquidCrystal_I2C-t, így nem lehet probléma a használatával.

Problémák az i2c lcd kijelző csatlakoztatásakor

Ha a vázlat feltöltése után nem lát semmilyen üzenetet a kijelzőn, próbálkozzon a következő lépésekkel.

Először is növelheti vagy csökkentheti a monitor kontrasztját. A karakterek gyakran egyszerűen nem láthatók a kontraszt és a háttérvilágítási mód miatt.

Ha ez nem segít, ellenőrizze, hogy az érintkezők megfelelően vannak-e csatlakoztatva, és hogy a háttérvilágítás csatlakoztatva van-e. Ha külön i2c adaptert használt, akkor ellenőrizze újra az érintkezők forrasztásának minőségét.

A képernyőről hiányzó szöveg másik gyakori oka lehet a helytelen i2c-cím. Először próbálja meg megváltoztatni az eszköz címét a vázlatban 0x27 0x20-ról 0x3F-re. A különböző gyártók eltérő alapértelmezett címeket programozhatnak be. Ha ez nem segít, akkor futtathatja az i2c szkenner vázlatot, amely minden csatlakoztatott eszközt átvizsgál, és nyers erővel meghatározza a címüket. Példa egy i2c szkenner vázlatára.

Ha a képernyő továbbra sem működik, próbálja meg kiforrasztani az adaptert, és a szokásos módon csatlakoztassa az LCD-t.

Következtetés

Ebben a cikkben megvizsgáltuk az LCD-képernyő használatának főbb kérdéseit összetett Arduino-projektekben, amikor szabad tűket kell mentenünk a táblán. Egy egyszerű és olcsó i2c adapter lehetővé teszi egy 1602-es LCD képernyő csatlakoztatását, amely mindössze 2 analóg érintkezőt foglal el. Ez sok esetben nagyon fontos lehet. Az ár a kényelem kedvéért egy további modul - konverter és könyvtár - használatának szükségessége. Véleményünk szerint ez nem túl magas ár a kényelemért, és erősen javasoljuk ennek a funkciónak a használatát projektekben.

Csinálnom kellett egy mikroáramkörre épülő órát, aminek van I 2 C interfésze. RTC chip, ún. "valós idejű óra" PCF8583.

A chip belsejében van: óra, ébresztőóra, időzítő, naptár (görbe) és 240 bájt RAM, ahová bármilyen információt rögzíthetünk. A RAM egy nagyon hasznos dolog, a flash memóriával ellentétben a RAM-nak nincs korlátozása az újraírási ciklusok számában, néhány adatot, beállítást tetszés szerinti gyakorisággal menthetünk el rá.

De volt egy probléma - igazán nem akartam kódot írni, ezért úgy döntöttem, hogy kész kódot keresek az interneten. Mint később kiderült, „magától” találta meg. Letöltöttem egy példát az I 2 C-vel való munkavégzésre, kijavítottam, és felvillantottam a mikrokontrollert. Nem sikerült. Elkezdtem babrálni a kóddal, kerestem az okát, hogy miért nem működik... és elborzadtam!! Egyes esetekben a felvétel a teljes portra egyszerre történt, nem pedig bizonyos bitekre. Így ha valami mást csatlakoztat a porthoz, például egy kijelzőt, akkor valószínűleg nem fog működni. Ezenkívül a buszon az adatok olvasása helytelenül lett megvalósítva (vételvégi feltétel generálása nélkül, vagy egyszerűen NACK nélkül). De ez a baj fele. A fő probléma más. A kód szerzője gyakran logikai „1”-et állított be a portra, és mint tudjuk, az I 2 C busz vezérlése az SDA és SCL érintkezők közös vezetékre való „húzásával” történik. A buszon pedig a logikai „1”-et úgy alakítjuk ki, hogy a tápot 4,7 kiloohmos ellenállásokkal pluszba húzzuk. Így, ha a mikrokontroller kimenete logikai „1”-re van állítva, és a slave eszköz ezt a kimenetet „húzza” a közös vezetékre, akkor „bumm-bang” rövidzárlat keletkezik. Ez nem igazán tetszett, és úgy döntöttem, hogy újra feltalálom a saját kerekem, és írok saját könyvtárat, vagy inkább 2 könyvtárat: az egyiket az I 2 C busszal, a másikat pedig közvetlenül a PCF8583 valós idejű munkához. óra. Igen, egyébként a kód be van írva.

Ahhoz, hogy az I 2 C könyvtárat a projekthez kapcsolódhassa, be kell vennie az include-on keresztül, mint a képen, és a könyvtárat a projekt mappájába kell másolni.

Ezt követően meg kell nyitnia az „i2c.h” fájlt, és meg kell adnia a mikrokontroller lábait, amelyek I 2 C buszként működnek ). A beállítás pedig itt történik:

Ez az, csatlakoztattuk az I2C könyvtárat, konfiguráltuk a lábakat, és a könyvtár készen áll a használatra. Használati példa:

I2c_init(); // Az I2C busz inicializálása i2c_start_cond(); //busz indítása i2c_send_byte (0xA0); // a buszon lógó eszköz címe i2c_send_byte (0x10); // az eszközre írt adatbájt i2c_send_byte (0x10); // még egy bájt adat, amit az eszközre írunk i2c_stop_cond(); // stop gumik

A stop feltétel után ellenőrizhetjük, hogy minden rendben van-e az I 2 C busszal. Ehhez be kell olvasnunk az „i2c_frame_error” változót. Ha minden normális, akkor 0 lesz. Ha az egyik busztüske nincs „felhúzva” a tápegységre, és a logikai „1” nincs felszerelve a buszra, akkor a könyvtár hibát generál és kiírja a 1. szám az „i2c_frame_error” változóhoz. Olvassa el az „i2c_frame_error” változót a leállítási feltétel után. Az alábbi ábrán bemutatom a hibakezelés működését:

Most csatlakoztassuk a PCF8583 valós idejű órakönyvtárat. Ehhez ugyanazokat a lépéseket kell végrehajtania. Másoljuk a "PCF8583.h" fájlt a projekt mappájába, és adjuk hozzá az include-hoz, ahogy a képen is látható:

Kész. A PCF8583 valós idejű órakönyvtár csatlakoztatva van. Nem igényel semmilyen beállítást, így azonnal elkezdheti olvasni az időt és a dátumot a chipről. Felhívjuk figyelmét, hogy a PCF8583 könyvtár az I2C könyvtár használatával működik, így ha PCF8583-mal akarunk dolgozni, akkor mindkét könyvtárat össze kell kapcsolnunk!

Példa a könyvtár használatára (írási és olvasási idő és dátum):

// Az I2C busz inicializálása i2c_init(); // A PCF8583 chipre való írás időpontjának és dátumának előkészítése PCF_hour=23; // 23 óra PCF_min=59; // 59 perc PCF_day=31; // 31. nap PCF_month=12; // 12. hónap - december PCF_év=0; // év (0 - nem szökőév) PCF_weekday=6; // A hét 6. napja (vasárnap) // Írja be az időt és a dátumot a PCF8583 chipre PCF_write_hh_mm_ss(); // Olvassa be az időt és a dátumot a PCF8583 chipről PCF_read_hh_mm_ss(); Példa a RAM-mal való munkára (írás és olvasás): // 5 bájt előkészítése a PCF8583 chipre való íráshoz PCF_data_ram_1=255; // 1. bájt PCF_data_ram_2=255; // 2. bájt PCF_data_ram_3=255; // 3. bájt PCF_data_ram_4=255; // 4. bájt PCF_data_ram_5=255; // 5. bájt // 5 bájt írása a PCF8583 chipre PCF_write_ram(); // 5 bájt olvasása a PCF8583 chipről PCF_read_ram();

A mikroáramkörökről való olvasás még egyszerűbb - csak hívja a funkciótPCF_ olvas_ hh_ mm_ ss() ezután az idő és a dátum megjelenik a változókban, ahonnan csak átveszi őket. A RAM olvasásához a függvényt használjukPCF_ olvas_ ram() ezt követően változókban gyűjtjük az adatokatPCF_ adat_ ram_ N

Itt található a változók listája, ahol és mit tárolunk:

// idő és dátum PCF_óra=0; // idő, óra (0-tól 23-ig, túlcsordulás elleni védelem írásnál és olvasásnál) PCF_min=0; // idő, perc (0-tól 59-ig, túlcsordulás elleni védelem íráskor és olvasáskor) PCF_sec=0; // idő, másodperc (csak olvasható, íráskor visszaállítás 00-ra) PCF_day=0; // nap (1-től 31-ig, túlcsordulás védelem íráskor és olvasáskor) PCF_weekday=0 // a hét napja (0-hétfő; 6-vasárnap, túlcsordulás elleni védelem íráskor és olvasáskor) PCF_month=0; // hónap (1-től 12-ig, túlcsordulás elleni védelem írásnál és olvasásnál) PCF_year=0; // év (0-ugrás; 1,2,3-nem ugrás, túlcsordulás elleni védelem írásnál és olvasásnál) // RAM PCF_data_ram_1; // Adatok (PCF8583 RAM), 1. bájt PCF_data_ram_2; // Adatok (PCF8583 RAM), 2. bájt PCF_data_ram_3; // Adatok (PCF8583 RAM), 3. bájt PCF_data_ram_4; // Adatok (PCF8583 RAM), 4. bájt PCF_data_ram_5; // Adatok (PCF8583 RAM), 5. bájt

Most a túlcsordulás elleni védelemről fogok beszélni. Tegyük fel, hogy elfelejtettük csatlakoztatni a mikroáramkört. Olvassuk ki az adatokat a mikroáramkörből, és... az 11111111-es bájt, vagyis a 255-ös szám lesz beolvasva, az a helyzet, hogy az I 2 C busz 2 felhúzó ellenállásra épül, tehát logikai „egyeket” adnak. ha a mikroáramkör nincs csatlakoztatva. Az ilyen esetek elleni védekezésül a PCF8583 könyvtárban készítettem egy túlcsordulás elleni védelmet, ami gondoskodik arról, hogy az óra ne 62 óra 81 percet mutasson... A túlcsordulás megléte a “PCF_overflow” változó leolvasásával figyelhető meg. Ha 0, akkor nem volt túlcsordulási hiba. Ha 1 vagy több van benne, akkor túlcsordulási hibák vannak. A „PCF_overflow” változót a dátum- és időolvasási funkció után kell beolvasniaPCF_ olvas_ hh_ mm_ ss()

Az egyértelműség kedvéért mellékeljük az ATmega32 AVR Studio 6 projektjét. Bármilyen AVR-hez újrafordíthatod. A projektben egy kijelzőt is csatlakoztattam vizuális vezérléshez. Áramellátás esetén a mikrokontroller 23 óra 59 percre állítja be, december 31., vasárnap. És egy perccel később 00 óra 00 perc lesz, január 1, hétfő.

Most elmondom, miért beszéltem ennek a mikroáramkörnek a „ferde” naptáráról. A helyzet az, hogy a mikroáramkör nem tudja, hogyan tárolja az aktuális naptári évet, csak a szökőév jelzőjét tárolja. Röviden:
0 – szökőév
1 – nem szökőév
2 – nem szökőév
3 – nem szökőév

És így tovább a 0-1-2-3-0-1-2-3-0 ciklusban...

Általában egy normál naptár elkészítéséhez szoftveres számítást és az év mentését kell végrehajtania, például ugyanabba a PCF8583 RAM-ba, de ez nem kényelmes. És a lényeg, hogy ha áramtalanítják az áramkört, jaj, senki nem írja felül a memóriát...

A cikk végére egy rövid videós beszámolót is mellékelek. Mondhatom kezdő vagyok a programozásban, bár 3 éve programozom (apránként), ne ítélje meg szigorúan a kódot, ha van kiegészítés, észrevétel, írjon, javítunk. Jó alkotást mindenkinek!

Radioelemek listája

Kijelölés	Írja be	Megnevezés	Mennyiség	Jegyzet	Üzlet	A jegyzettömböm
	MK AVR 8 bites	ATmega32	1			Jegyzettömbhöz
	Valós idejű óra (RTC)	PCF8583	1			Jegyzettömbhöz
	LCD kijelző	WH1602	1

A Wire könyvtár leírása

Ez a könyvtár lehetővé teszi az I2C / TWI eszközökkel való interakciót. Az R3-as elrendezésű Arduino kártyákon (1.0-s kivezetés) az SDA (adatvonal) és az SCL (óravonal) az AREF tű közelében található érintkezőkön találhatók. Az Arduino Due két I2C/TWI interfésszel rendelkezik: az SDA1 és az SCL1 az AREF érintkezők közelében, további vonalak pedig a 20-as és 21-es érintkezőkön találhatók.

Az alábbi táblázat azt mutatja, hogy hol helyezkednek el a TWI érintkezők a különböző Arduino kártyákon.

Az Arduino 1.0 óta ez a könyvtár örökli a Stream funkciókat, így kompatibilis más olvasási/írási könyvtárakkal. Emiatt a send() és a Receive() helyett a read() és write() .

Jegyzet

Az I2C-címeknek 7 és 8 bites változata van. 7 bit azonosítja az eszközt, a 8. bit pedig azt, hogy az eszközt írják vagy olvassák. A Wire könyvtár 7 bites címeket használ. Ha van egy adatlapja vagy példakódja, amely 8 bites címet használ, akkor a legkisebb jelentőségű bitet kell megfordítania (azaz egy bittel jobbra kell tolnia az értéket), ami 0-tól 127-ig terjedő címet eredményez. 7 nem használatos, mivel le vannak foglalva, így az első használható cím a 8. Vegye figyelembe, hogy az SDA/SCL érintkezők csatlakoztatásakor felhúzó ellenállásokra van szükség. További részletekért lásd a példákat. A MEGA 2560 lap 20-as és 21-es érintkezőjén felhúzó ellenállások vannak.

A módszerek leírása

Wire.begin()

Leírás

Inicializálja a Wire könyvtárat, és mesterként vagy slaveként csatlakozik az I2C buszhoz. Általában csak egyszer kell hívni.

Szintaxis

Wire.begin(cím)

Opciók

cím: a slave eszköz 7 bites címe (opcionális); ha nincs megadva, a kártya masterként csatlakozik a buszhoz.

Visszatérési érték

Példa

A szolga eszközökre vonatkozó példákért tekintse meg az onReceive() és onRequest() metódusokra vonatkozó példákat. A fő eszközre vonatkozó példákért tekintse meg a többi módszer példáit. .

Wire.requestFrom()

Leírás

A mester arra használja, hogy bájtokat kérjen a slave-től. Ezeket a bájtokat az elérhető() és read() metódusokkal lehet megszerezni.

Ha ez az argumentum igaz, akkor a requestFrom() STOP üzenetet küld a kérés után, felszabadítva az I2C buszt.

Ha ez az argumentum hamis, akkor a requestFrom() RESTART üzenetet küld a kérés után. A busz nincs felszabadítva, ami megakadályozza, hogy egy másik mestereszköz kerüljön az üzenetek közé. Ez lehetővé teszi, hogy egy mester több kérést küldjön, miközben vezérli a buszt.

Szintaxis

Wire.requestFrom(cím, mennyiség)

Wire.requestFrom(cím, mennyiség, megálló)

Opciók

• cím: annak az eszköznek a 7 bites címe, amelyről bájtokat kérnek;
• mennyiség: kért bájtok száma;
• stop: logikai. true STOP üzenetet küld a kérés után. false RESTART üzenetet küld a kérés után, így a kapcsolat aktív marad.

Visszatérési érték

bájt: a slave-től visszaadott bájtok száma.

Példa

Wire.beginTransmission()

Leírás

Megkezdi az átvitelt az I2C slave eszközre a megadott címmel. Ezt követően a write() függvény segítségével sorba állítjuk a továbbítandó bájtok sorozatát, majd az endTransmission() hívással továbbítjuk.

Szintaxis

Wire.beginTransmission(cím)

Opciók

cím: annak az eszköznek a 7 bites címe, amelyre az adatokat továbbítani kell.

Visszatérési érték

Példa

Wire.endTransmission()

Leírás

Befejez egy átvitelt a slave-nek, amelyet a beginTransmission() metódus indított el, és átadja a write() metódus által sorba állított bájtokat.

Bizonyos I2C eszközökkel való kompatibilitás érdekében az Arduino 1.0.1 óta a requestFrom() elfogad egy logikai adattípus argumentumot, amely megváltoztatja a viselkedését.

Ha ez az argumentum igaz, akkor a requestFrom() STOP üzenetet küld az átvitel után, felszabadítva az I2C buszt.

Ha ez az argumentum hamis, akkor a requestFrom() RESTART üzenetet küld az átvitel után. A busz nincs felszabadítva, ami megakadályozza, hogy egy másik mestereszköz kerüljön az üzenetek közé. Ez lehetővé teszi, hogy egy mester több adást küldjön, miközben figyeli a buszt.

Alapértelmezés szerint ez az érv igaz.

Szintaxis

Wire.endTransmission()

Wire.end Transmission(stop)

Opciók

stop: logikai. true STOP üzenetet küld az átvitel után. false RESTART üzenetet küld az átvitel után, így a kapcsolat aktív marad.

Visszatérési érték

bájt, amely az átvitel állapotát jelzi:

• 0: siker;
• 1: Az adat túl hosszú az átviteli puffer feltöltéséhez;
• 2: NACK fogadott cím továbbításakor;
• 3: NACK vétel adatátvitelkor;
• 4: egyéb hibák.

Példa

Lásd a példát a write() metódushoz.

Wire.write()

Leírás

Adatokat ír a slave-től a mester kérésére válaszul, vagy bájtokat állít sorba az átvitelhez a mastertől a slave-ig (a beginTransmission() és endTransmission() hívások között).

Szintaxis

Wire.write(érték)

Wire.write(karakterlánc)

Wire.write(adatok, hossz)

Opciók

• érték: átviendő érték, egy bájt.
• string: továbbítandó karakterlánc, bájtok sorozata.
• adatok: átviendő adatok tömbje, bájtok.
• hossz: az átvitelhez szükséges bájtok száma.

Visszatérési érték

byte: az write() a megírt bájtok számát adja vissza, bár ezt a számot nem szükséges elolvasni.

Példa #include bájt val = 0; void setup() ( Wire.begin(); // csatlakozás az i2c buszhoz ) void loop() ( Wire.beginTransmission(44); // átvitel a #44 eszközre (0x2c) // az eszköz címe a vezetékben van megadva műszaki leírás write(val) // az érték byte elküldése Val++ // érték növelése if(val == 64) // ha elértük a 64. val = 0; // elölről kezdeni ) delay(500);

Wire.available()

Leírás

A read() paranccsal lekérhető bájtok számát adja vissza. Ezt a metódust a masteren kell meghívni a requestFrom() meghívása után, vagy a slave-en az onReceive() kezelőn belül.

Szintaxis

Wire.available()

Opciók

Visszatérési érték

Az olvasásra rendelkezésre álló bájtok száma.

Példa

Lásd a read() metódus példáját.

Wire.read()

Leírás

Beolvassa azt a bájtot, amely a slave-ről a masterre került a requestFrom() meghívása után, vagy amely a masterről a slave-re került.

Szintaxis

Opciók

Visszatérési érték

bájt: következő bájt érkezett.

Példa #include bájt val = 0; void setup() ( Wire.begin(); // csatlakozni az i2c buszhoz (a mester címe nem kötelező) Serial.begin(9600); // a soros port konfigurálása a kimenethez ) void loop() ( Wire.requestFrom(2) , 6); // 6 bájt kérése a slave #2-től while(Wire.available()) // a slave kevesebbet küldhet a kértnél ( char c = Wire.read(); // a bájt elfogadása Serial.print karakterként () c); // kiírja a szimbólumot ) delay(500);

Wire.setClock()

Leírás

Módosítja az I2C busz kommunikáció órafrekvenciáját. Az I2C slave-eknek nincs minimális üzemi órajel-frekvenciája, de jellemzően 100 kHz-et használnak.

Szintaxis

Wire.setClock(órafrekvencia)

Opciók

clockFrequency: Az órajel frekvencia értéke (hertzben). Az elfogadott értékek 100 000 (normál mód) és 400 000 (gyors mód). Egyes processzorok támogatják az 10000 (alacsony sebességű mód), 1000000 (gyors plusz mód) és 3400000 (nagy sebességű mód) processzorokat is. A szükséges mód támogatásának biztosításához tekintse meg az adott processzor műszaki dokumentációját.

Visszatérési érték

Wire.onReceive()

Leírás

Regisztrál egy funkciót, amely akkor kerül meghívásra, amikor a slave adást kap a mastertől.

Szintaxis

Wire.onReceive (kezelő)

Opciók

kezelő: egy függvény, amely akkor kerül meghívásra, amikor a slave eszköz adatokat fogad; egy int paramétert kell vennie (a mesterből kiolvasott bájtok száma), és semmit sem ad vissza, azaz:

void myHandler(int numBytes)

Visszatérési érték

Példa

#beleértve void setup() ( Wire.begin(8); // csatlakozni az i2c buszhoz #8 címmel Wire.onReceive(receiveEvent); // eseménykezelő regisztrálása Serial.begin(9600); // soros port konfigurálása output ) void loop() ( delay(100); ) // egy függvény, amely akkor kerül végrehajtásra, amikor adat érkezik a mastertől // ez a függvény eseménykezelőként van regisztrálva, lásd: setup() void ReceiveEvent(int howMany) ( míg (1< Wire.available()) // пройтись по всем до последнего { char c = Wire.read(); // принять байт как символ Serial.print(c); // напечатать символ } int x = Wire.read(); // принять байт как целое число Serial.println(x); // напечатать число }

Wire.onRequest()

Leírás

Regisztrál egy függvényt, amely akkor kerül meghívásra, amikor a master adatokat kér a slave-től.

Szintaxis

Wire.onRequest(kezelő)

Opciók

kezelő: a meghívandó függvény, nem vesz fel paramétereket és nem ad vissza semmit, azaz:

érvénytelen myHandler()

Visszatérési érték

Példa

A rabszolgaként működő Arduino tábla kódja:

#beleértve void setup() ( Wire.begin(8); // csatlakozni az i2c buszhoz #8 címmel Wire.onRequest(requestEvent); // eseménykezelő regisztrálása ) void loop() ( delay(100); ) // függvény, amely akkor kerül végrehajtásra, amikor a mester // adatokat kér // ez a függvény eseménykezelőként van regisztrálva, lásd: setup() void requestEvent() ( Wire.write("hello "); // válaszolj üzenettel )

Ebben a cikkben arra tettünk kísérletet, hogy az összes legnépszerűbb Arduino-könyvtár linkjeit egy helyre gyűjtsük össze, és a legnépszerűbb könyvtárakból is készítettünk egy válogatást. Előbb-utóbb minden Arduino-felhasználó szembesül azzal, hogy egyik vagy másik könyvtárat használnia kell. Végül is a kész kód használata nagymértékben csökkenti a programozási időt. Reméljük, hogy a népszerű könyvtárakkal kapcsolatos információk egy helyre gyűjtve, letöltési linkekkel és rövid használati példákkal ellátva segítik projektjeit.

Az Arduino könyvtár egyfajta programkód, amelyet nem vázlatban, hanem külső fájlokban tárolnak, amelyek csatlakoztathatók a projekthez. A könyvtár különféle módszereket és adatstruktúrákat tárol, amelyek az érzékelőkkel, indikátorokkal, modulokkal és egyéb komponensekkel való munka egyszerűsítéséhez szükségesek. A kész programok használata nagymértékben leegyszerűsíti a projektekkel kapcsolatos munkát, mivel a fő logikára koncentrálhat anélkül, hogy sok apróságra időt pazarolna.

Mára rengeteg könyvtár jött létre, amelyek könnyen megtalálhatók és letölthetők az interneten. A könyvtárak túlnyomó többségét ingyenes licenc alatt terjesztik, így nem kell „kalóz” verziókat keresni. A fő dolog, hogy tanulj.

Arduino szabványos könyvtárak

Jobb, ha a könyvtárakkal való ismerkedést a hivatalos webhelyről kezdi, ahol lenyűgöző listát talál a szabványos modulokról és a hivatalos partnerkönyvtárak linkjeit.

A beépített könyvtárak listája (az Arduino IDE disztribúcióhoz tartoznak):

• EEPROM
• Ethernet / Ethernet 2
• Firmata
• Liquid Crystal
• Szervo
• SoftwareSerial
• lépegető

Válogatás a könyvtárakból egy archívumban

Ha nincs ideje sok webhely részletes elemzésére, és egy archívumban szeretne letölteni mindent, amire szüksége van a külső Arduino-eszközökkel való munkához, elkészítettük a 40 legnépszerűbb könyvtár listáját. Egyszerűen csomagolja ki a tartalmát (a könyvtárak mappáját) az Arduino mappába.

Képernyők, indikátorok és kijelzők könyvtárai

I2C könyvtár

Periféria I2C protokollt használó működtetésére tervezett könyvtár.

Használati példa:

#ifndef I2C_MASTER_H

#define I2C_MASTER_H

void I2C_init (void) – objektum létrehozása, a busz megfelelő frekvenciájának beállítása.

uint8_t I2C_start () – kapcsolat létrehozása egy új eszközzel.

uint8_t I2C_write() – adatokat ír az aktuális eszközre.

uint8_t I2C_read_ack() – egy bájt beolvasása az eszközről, a következő bájt kérése.

LiquidCrystal Library

Az Arduino IDE-ben telepített szabványos könyvtár. LCD folyadékkristályos kijelzők vezérlésére tervezték.

Használati példa:

#beleértve . Annak érdekében, hogy ne kövessen el hibákat az írás során, a Sketch - Import Library - LiquidCrystal menün keresztül csatlakozhat.

Az osztálykonstruktor a LiquidCristal(...). Az argumentumok: rs, rw, en, do…d7. Az első 3 megfelel az RS, RW és Enable jel érintkezőknek. A d érintkezők azoknak az adatbuszok számának felelnek meg, amelyekhez a kijelző csatlakozik.

A void begin(cols, rows) egy metódus, amely inicializálja a megjelenítési felületet. Az argumentumok a soronkénti karakterek száma (oszlopok) és a sorok száma (sorok). Ezt a módszert először meg kell határozni.

void createChar(szám, adat) – egyéni karakterek létrehozásához szükséges módszer.

UTFT könyvtár

A szabványos könyvtár, amely ahhoz szükséges, hogy az Arduino különböző típusú TFT-képernyőkkel működjön. Az összes támogatott kijelzőt a kísérő könyvtári dokumentum tartalmazza.

Használati példa:

#beleértve

UTFT(); – UTFT-példány létrehozása.

textRus(char*st, int x, int y); – olyan módszer, amely lehetővé teszi egy karakterlánc megjelenítését egy indexből. Például char *dht = “Hőmérséklet, C”;

textRus(string st, int x, int y); – a paramétert jelző karakterláncot adja ki. Például g.textRus(“Hőmérséklet, C”, 0, 20);

LedControl könyvtár

Lehetővé teszi a hétszegmenses kijelzők vezérlését és LED-ek egy mátrixba való kombinálását.

Használati példa:

#beleértve

LedControl lc1= LedControl();

– szükséges a könyvtár inicializálásához. Négy argumentumból kell állnia - azon tűk számából, amelyekhez a kijelző csatlakozik (az első 3 argumentum) és a csatlakoztatott chipek számából.

writeArduinoOn7Segment() – Az összes számot 0 és 15 között jeleníti meg a kijelzőn. A setChar() függvényt használja az a és d karakterekhez, valamint a setRow() függvényt a hiányzó karakterek elrendezésének létrehozásához.

LedControl.shutdown() – kikapcsolja a képet.

setIntensity() – fényerő szabályozás.

Könyvtárak az Arduino dátum és idő használatához

Könyvtár RTClib

Egy könyvtár a valós idejű órával való munkavégzéshez, leegyszerűsítve az Arduino-val való interakciót.

Használati példa:

#beleértve

RTC_DS1307 RTC; – érzékelő kiválasztása (jelen esetben DS1307).

rtc.adjust(DateTime(Date, Time)); – idő és naptár beállítások.

dayOfTheWeek() – a hét napját adja ki. Érv 0-tól 6-ig, 0 – vasárnap.

Timelib könyvtár

Lehetővé teszi az Arduino számára, hogy információkat szerezzen a dátumról és az időpontról egy adott pillanatban.

Használati példa:

#beleértve

Idő(); – példány létrehozása.

setTime(t); – az idő beállítása. A t argumentum: óra, perc, másodperc, nap, hónap és év.

timeStatus(); – megmutatja, hogy be van-e állítva az idő.

módosítaniTime(beállítás); – időbeállítás.

Könyvtár Ds1307

Könyvtár a DS1307 óra és az Arduino közötti kényelmes interakcióhoz a Wire könyvtár segítségével.

Használati példa:

#beleértve

osztály DS1307RTC – DS1307 objektum létrehozása.

SetTime() – az idő beállítása.

get() – beolvassa az RTC-t, és visszaadja a kapott dátumot POSIX formátumban.

Set(time_t t) – a dátum beírása az RTC-be

DS 3231 könyvtár

A dátum és az idő vezérlésére tervezték a ds3231 modulban.

#include „ds3231.h”

DS3231 óra (SDA, SCL); – DS3231 objektum létrehozása, óravonalhoz és adatvonalhoz való csatlakozás.

getTime(); – dátum és idő leolvasása az óráról.

setDate(dátum, mon, év); – a dátum beállítása.

Arduino rendszerkönyvtárak

EEPROM könyvtár

Szabványos könyvtár. Nem felejtő memóriával való együttműködésre tervezték (adatrögzítés, olvasás).

Használati példa:

#beleértve

EEPROM.read(); – objektum létrehozása, bájt beolvasása egy címen a nem felejtő memóriából.

EEPROM.write(cím, érték) – egy bájtot ír a nem felejtő memóriába.

EEPROM.put() – lebegőpontos számsorokat ír.

EEPROM.get() – karakterláncok és lebegőpontos számok olvasása.

Szoftversoros könyvtár

Olyan könyvtár, amely lehetővé teszi soros interfészek megvalósítását bármilyen digitális érintkezőről. Lehetővé teszi több soros port létrehozását is, amelyek akár 115 200 baud sebességgel működnek.

#beleértve

SoftwareSerial mySerial(RX, TX) – objektum létrehozása, argumentumok – tűk, amelyekhez RX és TX csatlakozik.

Serial.begin(); – beállítja a port sebességét az Arduino és a számítógép közötti kommunikációhoz.

mySerial.overflow() – ellenőrzi a bemeneti puffert túlcsordulás szempontjából.

Math Library

Számos matematikai függvényt tartalmaz a lebegőpontos számokkal való munkavégzéshez.

Használati példa:

#beleértve

Matek(); – matematikai példány létrehozása.

Serial.print("cos num = "); – egy szám koszinuszát adja vissza.

Serial.println(fmod(double__x, double__y)); – modulo számokat ad vissza.

Ütemező könyvtár

Úgy tervezték, hogy az Arduino Due-val működjön, lehetővé teszi a többfeladatos üzemmódban való munkát. Egyelőre ez egy kísérleti könyvtár.

Használati példa:

#beleértve

Ütemező; – példány létrehozása.

Scheduler.startLoop() - lehetővé teszi egy függvény hozzáadását, amely a loop()-kal együtt kerül végrehajtásra.

result() – lehetővé teszi az irányítás átadását más feladatokhoz.

Szervomotorok és léptetőmotorok könyvtárai

Szervo Könyvtár

Szabványos könyvtár. Nélkülözhetetlen a szervomotorok vezérléséhez, és gyakran használják manipulátorokkal végzett robotprojektekben.

Használati példa:

#beleértve

Szervo myservo; – objektum létrehozása a szervomotor számára.

myservo.attach(); – annak a kimenetnek a száma, amelyre a szervomotor csatlakoztatva van.

myservo.write(180, 30, igaz); – mozgás 180 fok, sebesség 30, a mozgás végére várva.

Stepper könyvtár

Egypólusú és bipoláris léptetőmotorok vezérléséhez szükséges.

#beleértve

const int stepsPerRevolution = ; – a lépések száma, amennyi a motornak egy teljes fordulat megtételéhez szükséges.

Stepper myStepper = Stepper(lépések, pin1, pin2) – létrehozza egy osztály példányát a megadott számú lépéssel és tűvel, amelyhez a motor csatlakozik.

Arduino szenzorkönyvtárak

DHT könyvtár

#beleértve< DHT.h>

DHT dht(DHTPIN, DHT11); – inicializálja az érzékelőt (jelen esetben DHT11).

dht.begin(); – az érzékelő indítása.

float t = dht.readTemperature(); – az aktuális hőmérsékleti érték leolvasása Celsius fokban.

DallasTemperature Library

Dallas érzékelőkkel való együttműködésre tervezték. A OneWire könyvtárral együtt működik.

#beleértve

DallasHőmérséklet dallasÉrzékelők(&oneWire); – oneWire objektum átvitele az érzékelővel való munkavégzéshez.

tedd be a nyilvántartásba.

printTemperature(sensorAddress); – kérje a mért hőmérsékleti érték beszerzését.

Ultrahangos könyvtár

Lehetővé teszi, hogy az Arduino a HC-SR04 ultrahangos távolságmérő érzékelővel működjön.

#beleértve

Ultrahangos ultrahang (tig, echo) – objektum deklaráció, argumentumok – Trig kontaktus és Echo kontaktus.

dist = ultrasonic.distanceRead(); – a tárgy távolságának meghatározása. Argumentum – centiméter (CM) vagy hüvelyk (INC).

Timing() – az impulzus időtartamának leolvasása az Echo kimeneten, konvertálása a kívánt számrendszerre.

ADXL345 könyvtár

Úgy tervezték, hogy az ADXL345 gyorsulásmérővel működjön.

Használati példa:

#beleértve

ADXL345_ADDRESS – objektum létrehozása, címének megadása.

ADXL345_REG_DEVID – eszközazonosító.

ADXL345_REG_OFSX – eltolás az X tengely mentén.

ADXL345_REG_BW_RATE – adatátviteli sebesség szabályozása.

Könyvtár BME280

Úgy tervezték, hogy a BME280 hőmérséklet-, páratartalom- és nyomásérzékelővel működjön.

Használati példa:

#beleértve

BME280_ADDRESS – BME280 objektum létrehozása, a cím megadásával.

begin(uint8_t addr = BME280_CÍM); – az érzékelő működésének kezdete.

getTemperature – a mért hőmérséklet lekérése.

getPressure – a mért nyomás lekérése.

BMP280 könyvtár

A BMP280 légköri nyomásérzékelővel való működéshez szükséges.

Használati példa:

#beleértve

BMP280_CHIPID – példány létrehozása, címének megadása.

getTemperature(float *temp); – a mért hőmérséklet lekérése.

getPressure(float *nyomás); – a mért nyomásérték lekérése.

Könyvtár BMP085

BMP085 nyomásérzékelővel való használathoz szükséges.

Használati példa:

#beleértve

Adafruit_BMP085 bmp; – BMP085 példány létrehozása.

dps.init(MODE_ULTRA_HIGHRES, 25000, true); – nyomásmérés, argumentum 25000 – tengerszint feletti magasság (jelen esetben 250 m tengerszint feletti magasság).

dps.getPressure(&Nyomás); – nyomás meghatározása.

Ujjlenyomat-könyvtár

Az ujjlenyomat-szkennerrel való működéshez szükséges.

Példahasználat:

#beleértve

Adafruit_Ujjlenyomat ujj = Adafruit_Fingerprint(&mySerial); – az Ujj objektum deklarálása. Paraméter – hivatkozás egy objektumra az UART-val való munkavégzéshez, amelyhez a modul csatlakozik.

ujj.begin(); – az ujjlenyomat modul inicializálása.

Func_sensor_communication(); – az ujjlenyomat modul felhívása.

Kommunikációs könyvtárak

Wire Library

Kétvezetékes I2C interfésszel való működéshez szükséges.

Használati példa:

#beleértve

Wire.begin() – könyvtár inicializálása, csatlakozás az I2C buszhoz.

Wire.requestFrom() – mester kérés bájtokra a slave eszköztől.

Wire.beginTransmission() – az átvitel kezdete a slave eszközhöz.

Irremote Library

Az Arduino infravörös vevővel való működéséhez szükséges.

Használati példa:

#beleértve

IRrecv irrecv(RECV_PIN); – tű, amelyhez az infravörös vevő csatlakozik.

SetPinAndButton(int ir1,int ir2,int pin) – lehetővé teszi egy adott kimenet konfigurálását, hogy az ir1, ir2 megadott értékeinél aktiválódjon.

GSM könyvtár

GSM-kártyán keresztüli csatlakozáshoz szükséges a GSM/GRPS hálózathoz. Segítségével GSM telefonnal végrehajtott műveleteket hajthat végre, hanghívásokkal dolgozhat és GRPS-en keresztül csatlakozhat az internethez.

Használati példa:

#beleértve

GSM GSMAccess – inicializálja az osztály egy példányát.

gprs.powerOn() – bekapcsolás.

GPRS – internetkapcsolat beállítása.

GSM – rádiós modem vezérlés.

RFID könyvtár

Az Arduino és az RFID modul csatlakoztatásához szükséges.

Használati példa:

#beleértve

RFID rfid(SS_PIN, RST_PIN); – rfid példány létrehozása, argumentumok – tűk, amelyekhez a modul csatlakozik.

rfid.init(); – az RFID modul inicializálása.

MFRC 522 könyvtár

Az Arduino és az MFRC522 modul csatlakoztatásához szükséges.

Használati példa:

#beleértve

MFRC522 mfrc522(SS_PIN, RST_PIN); – MFRC522 példány létrehozása, az argumentumok, amelyek meghatározzák azokat a kimeneteket, amelyekhez a modul csatlakozik.

mfrc522.PCD_Init(); – az MFRC522 inicializálása.

Ethershield könyvtár

Új verzió https://github.com/jcw/ethercard

Az Arduino helyi hálózathoz vagy internethez való csatlakoztatásához szükséges. A könyvtár már nem támogatott, az Ethercard újabb verziója. Van egy szabványos Ethernet könyvtár is.

Használati példa:

#include "EtherShield.h"

#beleértve

EtherShield es = EtherShield(); – weboldal készítés

ether.begin(sizeof Ethernet::buffer, mymac,); – kezdő lépések, argumentumok – Mac-cím és portszám, amelyre a CS kimenet csatlakozik.

Könyvtár Nrf24l01

Az RF24 rádiómodullal való működéshez szükséges.

Használati példa:

#include „RF24.h”

RF24 – A konstruktor új illesztőprogram-példányt hoz létre. Használat előtt létre kell hoznia egy példányt, és meg kell adnia azokat a tűket, amelyekhez a chip csatlakozik (_cepin: Enable module pin, cspin: Select module pin).

Kezdés – a chip működésének kezdete.

setChannel – csatornák az RF kommunikációhoz.

setPayloadSize – rögzített átviteli méret beállítása.

getPayloadSize – fix méret elérése.

TinyGPS könyvtár

GPGGA és GPRMC üzenetek olvasásához szükséges. Segít a pozíció, dátum, idő, magasság és egyéb paraméterek leolvasásában.

Használati példa:

#beleértve

TinyGPS gps; – TinyGPS példány létrehozása.

kódolás () – szekvenciális adatok továbbítása az objektumhoz egy-egy karakterrel.

gps.stats() – statisztikai módszer. Azt jelzi, hogy helyes adat érkezett-e vagy sem.

Könyvtárak az Arduino IDE-ben

A sokféle könyvtár között 3 fő csoportot lehet megkülönböztetni:

• A beépített könyvtárak, amelyeket eredetileg az Arduino IDE-be telepítettek. Ezeket nem kell külön letölteni vagy telepíteni, a fejlesztői környezet elindítása után azonnal használhatóak a programban.
• További olyan könyvtárak, amelyeket magának kell letöltenie és telepítenie. Általában az ilyen típusú könyvtárakat az érzékelők, érzékelők és egyéb alkatrészek gyártója fejleszti az Arduino-val való munka megkönnyítése érdekében.
• Függő könyvtárak - egy további könyvtár asszisztenseként telepítve, attól külön nem működnek.

Az Arduino könyvtárakkal való munkavégzés legegyszerűbb módja az Arduino IDE beépített képességeinek használata. Erről egy külön cikkben fogunk beszélni.