
Ez a karakteres kijelzőkről, I2C bővítőről szóló cikk mindent tartalmaz, amit az Arduino rendszeren belüli használatáról tudni kell. A cikkben sok példakód, a buktatók leírásai is megtalálhatóak, amelyek segítenek az indulásban és/vagy a hibakeresésben. A továbbiakban szó lesz a karakteres kijelzők alapjairól, az I2CLCD bővítők különböző változatairól, a szöveg és a számok megjelenítésének különféle lehetőségeiről. A folytatásban részletesen megismerhető az egyéni karakterek megjelenítése, a használatot könnyebbé tevő parancsok és néhány előny és hátrány, amit a függvénykönyvtárak és az I2CLCD használatával okozunk. És végül bemutatásra kerül, hogy hogyan használjuk látványosan a karakteres kijelzőt – milyen animációk, speciális metódusok, fura karakterek és rajzok vannak már készen.
Hozzávalók
Eszközök
- Önálló I2C LCD modul és
- Karakteres kijelző vagy
- Egybeépített karakteres kijelző és I2CLCD modul
- Arduino UNO alaplap
- Jumper/Dupont kábel (anya-anya) – 4 érnyi
Szoftver
- Arduino IDE keretrendszer
A cikk a Windows alatti 1.8.13 verzióval készült.
Az I2CLCD alapjai
A felhasznált kijelző ideális szövegek és számok megjelenítésére (sőt, eredetileg is csak ezek megjelenítésére készült) – innen a „karakteres LCD” elnevezés. A cikkben ismertetett kijelző egy kis kiegészítő áramkört tartalmaz a modul hátoldalán – ez a kiegészítő-modul tartalmaz egy PCF8574 chipet (az I2C kommunikációhoz), egy potenciométert a kijelző kontrasztjának beállításához illetve (opcionálisan) egy jumpert (rövidzárat) a háttérvilágítás állandó ki- vagy bekapcsolásához. Az I2CLCD modul előnye, hogy a kábelezés nagyon egyszerűvé válik, hiszen a minimálisan szükséges 12 kábel (7x adat+1x kontraszt + 2x táp + 2x háttérvilágítás) helyett elég összesen 4 kábel (2x adat + 2x táp) használata. Sőt, az I2CLCD megoldással az vezérlést biztosító adatvonalak más eszközökkel is használhatóak közösen! Míg ha a hagyományos bekötést használjuk az LCD meghajtására – akkor azok más célra már nem is használhatóak. Így funkcionálisan elveszne 7 kivezetés….(sok chipen nincs is ennyi kivezetés összesen).
A normál LCD -k jellemzően 7 adat-csatlakozást igényelnek, ami problémát jelenthet, ha nem áll rendelkezésre ennyi szabad GPIO -kivezetés. Szerencsére az I2CLCD kiegészítő áramkört külön is hozzáférhető (I2CLCD bővítőmodul), így könnyen frissíthető egy szabványos LCD is a modullal. A szabványos karakteres LCD -k bemutatása és kapcsolási rajza a következő cikkben található: Hogyan használjunk 16 × 2 karakteres LCD -t Arduino -val
Az LCD minden egyes karaktere 5×8 képpontból áll. Ha minden képpont aktív, akkor egy téglalapot láthatunk a kiíráskor. Ha alaposan megnézzük az LCD-t, láthatóak a kis téglalapok – amelyek az LCD karaktereit alkotják. Minden téglalap 5 × 8 képpontos rácsból áll.
Ebben az oktatóanyagban később megnézzük, hogy hogyan lehet a képpontokat egyesével szabályozni és önálló karaktereket/grafikákat létrehozni a segítségével..
LCD jellemzők
A 16 × 2, 20 × 4 és más méretű karakterek kiírására szolgáló LCD -k jellemzői többnyire azonosak. Mindegyik ugyanazt a Hitachi HD44780 típusjelű LCD vezérlőt használja, így könnyen cserélhetőek. (Tipp: az újabb kijelzők a továbbfejlesztett HD44780 chipet használják – pl. KS0066 – és ezek működése csereszabatos. Így régebbi LCD modult kicserélve – a programkód bármi módosítása nélkül – tovább használható. Ha az LCD-ből eltérő karakterszámút kell használni – az azonos protokoll miatt – elegendő a kódban az LCD karakterszámát megváltoztatni. A tipikus 16 × 2 IIC/TWI kijelző specifikációi az alábbi táblázatban találhatók:
Működési feszültség | 5 V |
Vezérlő chip | Hitachi HD44780 / |
IIC/TWI cím | 0x27 |
Képernyőméret | 2 sor x 16 oszlop |
Karakterfelbontás | 5 × 8 pixel |
LCD modul méret | 80 × 36 × 12 mm |
Látható terület | 64.5 × 16.4 mm |
Részletes információk több helyen találhatóak: a kijelzők adatlapjaiban, a vezérlők leírásában. A 16 × 2 és 20 × 4 LCD modulok adatlapjai tartalmazzák az LCD méretét, és a HD44780 / KS0066 adatlapokon további információkat lehet találni a kijelző vezérléséről. A PCF8574 chip pedig az LCD hátoldalán található I2CLCD modulon került beépítésre.
- PCF8574 adatlap
- Hitachi HD44780 LCD kontroller adatlap
- KS0066 LCD vezérlő adatlap
- 20×4 LCD adatlap
- 16×2 LCD adatlap
Az I2CLCD modul bekötése az Arduino lapkára
Az alábbi kapcsolási rajz megmutatja, hogy hogyan kell csatlakoztatni az I2CLCD bővítővel ellátott modult az Arduino lapkához. Az I2C bővítővel szerelt LCD bekötése sokkal egyszerűbb, mint egy hagyományos LCD csatlakoztatása: elegendő a 4 kivezetést csatlakoztatni a 12 helyett! Tipp: ha az Arduino Uno lapkán a táp és az I2C csatlakozó dedikáltan is kivezetésre került – még áttekinthetőbb a bekötés (→a külön kivezetésről UNO/CH340 cikk ír bővebben)!

A bekötést az alábbi táblázat mutatja:
I2CLCD illesztővel szerelt LCD | Arduino UNO |
---|---|
GND | GND |
VCC | 5 V |
SDA | A4 |
SCL | A5 |
Ha nem Arduino Uno lapkára kerül az I2CLCD modul csatlakoztatása, akkor az SCL és az SDA eltérő helyen került kivezetésre! Az R3 elrendezésű Arduino lapokon (Mega, Uno, Leonardo) az I2C kivezetés már dedikált helyen érhető el – az Aref kivezetés közelébe.
Az I2C busz SCL és SDA kivezetése minden alappanelen másként közös funkcionális I/O kivezetésekkel:
Alaplap | SDA | SCL |
Arduino Uno | A4 | A5 |
Arduino Nano | A4 | A5 |
Arduino Micro | 2 | 3 |
Arduino Mega 2560 | 20 | 21 |
Arduino Leonardo | 2 | 3 |
Arduino Due | 20 | 21 |
Kontraszt beállítása
Az LCD modul bekötése után nagy valószínűséggel módosítani kell a kijelző kontrasztjának beállítását. Az I2CLCD bővítő modulon található egy potenciométer, amelyet egy kis csavarhúzóval lehet elforgatni.
Az I2CLCD bővítővel szerelt LCD modult az Arduino lappal való csatlakoztatás után tápfeszültség alá kell helyezni. Ezt legegyszerűbben az USB-n keresztüli tápellátással lehet megoldani.
Ekkor az LCD háttérvilágítása bekapcsolhat, és a bővítőmodul tápfeszültség-visszajelzése is világítani kezd.
Az LCD a tápfeszültség rákapcsolásakor ún. önteszt módba kapcsol. Ekkor az első és a harmadik sorban (4×20 karakteres kijelző esetén) kockákat kell látni, a 2. és 4. sor üres marad.

A potenciométert addig kell forgatni, míg egy sornyi (16×2 LCD) vagy két sornyi (20×4 LCD) téglalap nem lesz látható. Szükség esetén később is módosítható a kontraszt beállítása – például, ha a betekintés nem pont merőleges a kijelző síkjára. Ha a kontraszt beállítása megtörtént, elkezdhető az LCD programozása.
A LiquidCrystal_I2C Arduino könyvtár telepítése
Ebben az oktatóanyagban a LiquidCrystal_I2C
könyvtár került alkalmazásra. Persze sokféle I2CLCD kezelő program van – de ez biztosítja a legkezelhetőbb, legszéleskörűbb támogatást. Ez a könyvtár számos beépített funkcióval rendelkezik, amelyek nagyon megkönnyítik az LCD programozását. A legújabb verziója megtalálható a GitHub-on, vagy az Arduino beépített könyvtárkezelőjével is telepíthető. (Elérhetőség a GitHub-on: →LiquidCrystal_I2C)
Fontos! Egyéb I2CLCD kezelő könyvtár nem lehet az Arduino keretrendszerben telepítve – hibás működést okozhat! Minden más, ugyanilyen nevű könyvtár törlendő. Tipp: az Arduino ne fusson és a c:\Users\<user>\Documents\Arduino\libraries\, a c:\Program Files (x86)\Arduino\libraries\ és az Arduino\private\ mappák alatt is ellenőrizni szükséges, hogy ne maradjon telepítési “maradék”!
A LiquidCrystal_I2C
könyvtár a Wire.h
(I2C kezelő) alapkönyvtárral működik együtt (a Wire
könyvtár biztosítja az I2C eszközökkel az alapvető kommunikációt). Ez a könyvtár az Arduino keretrendszer telepítési része. A LiquidCrystal_I2C
könyvtár telepítése az Eszközök- Könyvtárak kezelése (Windows alatt Ctrl + Shift + I) menüpontban lehetséges. A Library Manager megnyitja és frissíti a telepített könyvtárak listáját.
A megnyíló Könyvtár-kezelő oldalon a telepítendő könyvtár nevét meg kell adni és a listából kiválasztani. A programkönyvtár LiquidCrystal I2C
néven szerepel és az írója: Frank de Brabander. Itt kiválasztva a legújabb verziót (jelen esetben a 1.1.2), majd a Telepítés gombra kell kattintani.
A telepítés után a Könyvtár-kezelőben már a telepített verzió látható:

A telepített eszközkönyvtár tartalmaz néhány példaprogramot, de lehet, hogy módosítani kell azokat a hardver beállításainak megfelelően, melyek:
- eszköz címe az I2C buszon,
- LCD mérete,
- LCD bekötése az I2CLCD bővítőre.
I2CLCD címmeghatározása az I2C buszon
A legtöbb I2C LCD az alapértelmezett 0x27 címen érhető el, de ez a PCF8574 chip illetve az áramkör kialakításától függően 0x20…0x27 illetve 0x38…0x3F tartományból bármi lehet. A bővítőpanel működési ellenőrzésének első lépése az kell hogy legyen, hogy az I2C buszon megszólítható-e a modul…
Hardware alapú címkeresés
De ha nem szoftveres megoldásra van szükség, akkor az áramkör visszarajzolásával is van erre mód. Így is egyszerűen meghatározható az eszköz címe. Az első lépés, hogy a modulon levő bővítő chipet és környezetét szemügyre vesszük:

A képen látható alapadatok:
- Az IC típusa: PCF8574A
Azaz a chip címtartománya a 0x38….0x3F tartományba esik (lásd a chip adatlap 5. oldala). - Az A0…A2 címválasztás
A címkiválasztási jumperek nincsenek átkötve. - A felhúzó ellenállások
A felhúzó ellenállások be vannak forrasztva.
Ezeket összerakva és az adatlapot megnézve:
Az I2C buszon a cím a chip típusa alapján (hardware cím): 0111. A felhúzó ellenállások be vannak forrasztva és a jumperrel nincs GND-re kötve az A0..A2 címkiválasztás, így: A2=1, A1=1 és A0=1 (logikai 1 szintek mérhetőek). Így az eszköz címe binárisan írva: B0111111, azaz hexadecimálisan: 0x3F.
Software alapú címkeresés
Az I2C címfelderítésre önálló függvénykönyvtár, illetve több mintakód is elérhető. Az ideális program a működés elején ellenőrzi a busz felhúzó ellenállásait, majd inicializálja a buszt. Utána a címtartományt ellenőrzi és ahol talál eszközt – annak címét kiírja a soros monitorra.
Tipp: az eszköz I2C buszon való megszólításakor többféle választ is kaphatunk:
- 0: sikeres kommunikáció,
- 1: az adatok túl hosszúak ahhoz, hogy beleférjenek az átviteli pufferbe,
- 2: NACK érkezett a cím továbbításakor,
- 3: NACK vétele adatátvitelkor,
- 4: egyéb hiba,
- nincs válasz.
A kommunikációnak a visszajelzéseit a legtöbb mintaprogram nem kezeli, csak a rendben és a nincs válasz visszajelzések alapján működnek…
De maga a címkereső program (kihagyva a felhúzó ellenállások jóságtesztjét és az esetlegesen beragadt adat/címvonalak ellenőrzését) (A cikkben található programkódok ide kattintva letölthetőek):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | /*I2C_scanner This sketch tests standard 7-bit addresses. Devices with higher bit address might not be seen properly.*/ #include <Wire.h> void setup() { Wire.begin(); Serial.begin(9600); while (!Serial); Serial.println("\nI2C Scanner"); } void loop() { byte error, address; int nDevices; Serial.println("Scanning..."); nDevices = 0; for (address = 1; address < 127; address++ ) { Wire.beginTransmission(address); error = Wire.endTransmission(); if (error == 0) { Serial.print("I2C device found at address 0x"); if (address < 16) Serial.print("0"); Serial.print(address, HEX); Serial.println(" !"); nDevices++; } else if (error == 4) { Serial.print("Unknown error at address 0x"); if (address < 16) Serial.print("0"); Serial.println(address, HEX); } } if (nDevices == 0) Serial.println("No I2C devices found\n"); else Serial.println("done\n"); delay(5000); } |
A mintaprogramot az Arduinoval lefordítva majd feltöltve az összerakott áramkörre, akkor a következő kimenetet kell látni a Soros monitoron (Ctrl + Shift + M):
Az itt megjelenő címek a buszon levő eszközök elérhetőségeit adják vissza. Ha csak I2CLCD illesztő van a buszon (és jól van bekötve és még működik is), akkor az eszköz címét kapjuk vissza.
Az I2C buszról, a protokoll, buktatókról, használati trükkökről részletesebben az Arduino tanfolyamban lehet bővebben olvasni, illetve a protokollt vizuálisan elemezni a Nyomozás a logikai analizátorral cikksorozatban lehet.

Arduino I2CLCD minimálkód
Az alábbi példakód a LiquidCrystal I2C telepítésével kerül az Arduino minták közé. A szerkeszthető, kipróbálható kód a Fájl-Példák-LiquidCrystal I2C alól nyitható meg, HelloWord néven:
A kód az alábbi, ahol a pirossal jelzett sort kell átírni a kijelző méretének és a I2CLCD modul I2C címének megfelelően:
1 | LiquidCrystal_I2C lcd(0x27,20,4); |
ahol a :
- cím 0x27 helyett 0x3F,
- az LCD oszlopok száma 20 helyett 16, és
- az LCD sorok száma 4 helyett 2.
A módosított kód – immár működőképesen – az Arduino keretrendszerben lefordítható és feltölthető. A mintaáramkörben, ami az Uno lapkát és a kijelzőt tartalmazza – az eredmény így fog mutatni (némi kiírási módosítás volt benne, mert a 4×20 karakteres kijelzőhöz volt az eredeti szöveg igazítva – a módosítások a letölthető programban már megtörténtek):
Persze idővel a 4×20 karakteres LCD is rendelkezésre állt.
A 4×20 karakteres kijelző címe: 0x27, és 4 sort tartalmaz, valamint 20 oszlopot. Így a definíciója:
1 | LiquidCrystal_I2C lcd(0x27,20,4); |
De hogyan működik valójában a kijelző a programkód tükrében?
A magyarázat megértéséhez és kipróbáláshoz a szükséges eljárás-könyvtárnak már feltelepítve kell lennie. A korábban már említett, és a közvetlen adatküldésért felelős : i2c / wire eljárást nem kell külön telepíteni: az Arduino egyik beépített alap eljáráskönyvtára.
A telepített LiquidCrystal_I2C
eljáráskönyvtár használata során a programkódban nem kell gondoskodni a működés alacsony szintű vezérlését végző wire
könyvtár meghívásáról. H a programban korábban nem lett meghívva – akkor az i2clcd kezelő eljáráskönyvtár gondoskodik a meghívásáról. Fontos! Más LCD kezelő könyvtárak esetén a dokumentációjából derül ki, hogy ezt a könyvtárat a használat előtt külön kell a programban elhelyezni, vagy mint általában – külön meg kell hivatkozni!
1 2 3 | // Include the libraries: LiquidCrystal_I2C.: https://github.com/johnrickman/LiquidCrystal_I2C #include <Wire.h> // Library for I2C communication (optional) #include <LiquidCrystal_I2C.h> // Library for LCD |
LCD objektum
A program elején a LiquidCrystal_I2C osztályú lcd (nevű) objektum létrehozása történik meg, valamint paraméterként az eszköz címe és a méretek megadása. Ehhez a LiquidCrystal_I2C
függvényt használjuk (cím, oszlopok, sorok). Itt, ebben a objektum létrehozásban kell módosítani az alapértelmezett címet is (ha szükséges). A leggyakoribb karakteres kijelző méretek: 16×2, 20×4, 20×2, 8×2.
1 | LiquidCrystal_I2C lcd(0x27,20,4); |
Megjegyzés: a kijelző méretét a járulékos programrészek használják: sor eltolása balra/jobbra, pozicionálás, stb. Ha 4×20-as kijelzőként inicializáljuk a 2×16 karakteres modult, akkor legfeljebb kisebb területen (bal felső részen) működnek pontosan a kiegészítő funkciók.

A kijelzőt (mint programbeli objektumot) lcd
-nek neveztük el. Ez szabadon elnevezhető objektum (értelemszerűen az angol abc betűi plusz aláhúzás jel lehet a névben – egyébként vagy fordítási hiba vagy hibás működés az eredmény) – azaz más név lehet az lcd
helyett, például a menu_display
. Egyszerűen így kell definiálni:
1 | LiquidCrystal_I2C menu_display(0x27,20,4); |
Hogy ez miért jó? Mert, ha például több kijelzőt kell használni – akkor ezt megoldhatjuk egyszerűen és programban pedig beszédesen hivatkozva (hardware alapon kifejezve: a két kijelző más I2C címen kell, hogy bejelentkezzen – így lehet a két kijelző független egymástól).
A címváltoztatás egyszerűen az A0..A2 címbeállítás átkötésével lehet:
Alapértelmezett beállítás: minden I2CLCD modul esetén a felhúzó-ellenállás érvényesül, egyik átkötés sincs forrasz-jumperrel megoldva: 0x27 (PCF8574 chip) vagy 0x3F (PCF8574A chip).
Fontos! Ha az lcd
objektum-hivatkozás meg lett változtatva, akkor azt a program összes többi részén szükséges megtenni! (hiszen ekkor az lcd
, mint objektum nincsen definiálva)
Inicializálás, alapok
1 2 3 4 5 | void setup() { // Initiate the LCD: lcd.init(); lcd.backlight(); } |
A beállítás során az LCD -t az lcd.init ()
program inicializálja (azaz beállítja) a LCD és a modul közti kommunikációt és az LCD programban való használathoz szükséges ún. 4 bites címzési módját választja ki és a képernyőt is letörli), a háttérvilágítást pedig az lcd.backlight ()
sorral lehet bekapcsolni.
Háttérinfo: az lcd.init()
kétszer szerepel a programban. Ennek oka, hogy egyes LCD modulok lassabban ébrednek fel és reagálnak a külső programozás-kérésre, vagy egyes LCD modulok esetén a 4-bites kommunikációs mód beállítása nem minden esetben sikeres elsőre. Így a kódban ez kétszer kerül kiadásra, és nem kell az LCD modulok esetleges eltéréseit is figyelni.
1 2 3 4 5 | lcd.setCursor(3,0); lcd.print("Hello, world!"); lcd.setCursor(2,1); lcd.print("Ywrobot Arduino!"); ... |
A kód következő szakaszában az LCD modulon a kurzor* a harmadik oszlopra és az első sorra áll az lcd.setCursor (2,0)
parancs hatására (Alapesetben a sorokat és az oszlopokat a nyelvtan és a matematika szerint 1-től kezdve számoljuk). Tipp: A sorok és oszlopok számlálása 0-tól kezdődik, így a 2×16 karakteres LCD sorai:0..1, oszlopai: 0..15 valamint a 4×20 karakteres LCD esetén a sorok 0..3 és az oszlopok 0…19 számot vehetnek fel (informatikai/programozási megközelítés). A megadott sor/oszlop számtartományon kívüli sor/oszlop értékek figyelmen kívül lesznek hagyva!
Ezután a “Hello World!” karakterláncot az lcd.print ("Hello World!")
segítségével írja ki a program a kijelzőre. Fontos, hogy az idézőjelek (“”) nem elhagyhatóak – ez jelzi, hogy szöveg kerül kiírásra. Ha számokat kell kiírni, vagy változókat – akkor nem szabad idézőjelet használni!
(*kurzor: a következő kiírás pozícióját adja meg – aláhúzás, villogó téglalap, vagy rejtett is lehet.)
A LiquidCrystal_I2C könyvtár egyéb hasznos funkciói
A fenti példa alapján lehet az LCD kijelzőz használatba venni. De van még néhány alapfunkció, ami a LiquidCrystal_I2C
illetve az LCD modul használatához elengedhetetlen.
clear()
A clear()
utasítás törli az LCD képernyőt és a kurzort a kijelző bal felső sarkában (0. sor és 0. oszlop) helyezi el. A kiírás egyéb pozícióját a már megismert setCursor()
paraméterrel lehet megadni.
1 | #include <LiquidCrystal_I2C.h> |
1 | LiquidCrystal_I2C lcd(0x3F, 16, 2); |
1 2 3 4 5 6 7 8 9 10 11 12 | void setup() { lcd.init(); lcd.backlight(); } void loop() { lcd.clear(); lcd.print("Monday"); delay(2000); lcd.clear(); lcd.print("13:45"); delay(2000); } |
home()
A home()
utasítás a kurzort az LCD bal felső sarkában helyezi el (képernyőtörlést nem végez!). Utasítás szinten megegyezik a setCursor(0,0)
-val.
cursor()
A cursor()
megjeleníti az LCD kurzorát: egy aláhúzást a következő nyomtatandó karakter helyén.
noCursor()
A noCursor()
elrejti az LCD kurzort. A következő példa villogó kurzort hoz létre a „Hello World!” kiírása után (gyakorlatilag a noCursor()
és a cursor()
utasítás kerül kiadásra 500msec időközönként).
1 2 3 4 5 6 7 8 9 10 11 12 13 | #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F, 16, 2); void setup() { lcd.init(); lcd.backlight(); lcd.print("Hello World!"); } void loop() { lcd.cursor(); delay(500); lcd.noCursor(); delay(500); } |

blink()
A blink()
villogó blokk stílusú LCD kurzort hoz létre: villogó téglalap a következő nyomtatandó karakter helyén.
noBlink()
A noBlink ()
letiltja a blokk stílusú LCD kurzort. A következő példa a villogó kurzort mutatja 5 másodpercig, majd 2 másodpercre letiltja.
1 2 3 4 5 6 7 8 9 10 11 12 13 | #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F, 16, 2); void setup() { lcd.init(); lcd.backlight(); lcd.print("blink() example"); } void loop() { lcd.blink(); delay(5000); lcd.noBlink(); delay(2000); } |
Tipp: a blink()
villogó téglalap kurzort hoz létre, a cursor()
állandóan jelenlevő aláhúzásjelet!
display()
A display()
funkció bekapcsolja az LCD képernyőt és megjeleníti a kijelzőre kiírt szöveget és/vagy kurzorokat.
noDisplay()
A noDisplay()
funkció kikapcsolja az LCD-re kiírt szöveg megjelenítését. Azonban a szöveg/adatok nem törlődnek az LCD memóriából! Ez azt jelenti, hogy a display()
meghívásakor ismét megjelenik az előzőekben az LCD-n levő kiírás. A következő példa villogó szöveghatást hoz létre.
1 2 3 4 5 6 7 8 9 10 11 12 13 | #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F, 16, 2); void setup() { lcd.init(); lcd.backlight(); lcd.print("Blinking text"); } void loop() { lcd.display(); delay(2000); lcd.noDisplay(); delay(2000); } |
write()
A write()
funkcióval nem a konkrét karakter írható ki, hanem az LCD-re a kiírandó karakter ASCII kódja kerül elküldésre. Bővebben az egyedi karakterek definiálása részben lehet olvasni.
scrollDisplayLeft() és scrollDisplayRight()
A scrollDisplayLeft()
a kijelző tartalmát (szöveg és kurzor) egy szóközzel balra görgeti, a scrollDisplayRight()
jobbra. Ezt a funkciót a késleltetéssel kombinálva görgethető szöveges animáció létrehozásához lehet használni.
1 2 3 4 5 6 7 8 9 10 11 | #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F, 16, 2); void setup() { lcd.init(); lcd.backlight(); lcd.print("Hello World!"); } void loop() { lcd.scrollDisplayLeft(); delay(500); } |
autoscroll()
Az autoscroll()
funkció bekapcsolja az LCD automatikus görgetését. Ez azt eredményezi, hogy a kijelzőn minden karakterkiírás egy szóközzel eltolja az előző karaktereket. Ha az aktuális szövegirány balról jobbra történik (az alapértelmezett), akkor kijelző balra görget; ha az aktuális kiírási irány jobbról balra, akkor a képernyő jobbra görgeti a kiírt szöveget. Ennek az a következménye, hogy minden új karaktert ugyanarra a helyre ír ki az LCD. A következő példavázlat bemutatja az automatikus görgetést: számokat ír ki 0-tól 9-ig.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x3F, 16, 2); void setup() { lcd.init(); lcd.backlight(); } void loop() { lcd.autoscroll(); lcd.setCursor(16, 0); for (int x = 0; x < 10; x++) { lcd.print(x); delay(500); } lcd.clear(); } |
noAutoscroll()
A noAutoscroll()
kikapcsolja az automatikus szövegkiírási görgetést.
leftToRight() és rightToLeft()
A leftToRight()
és rightToLeft()
funkciók megmondják, hogy a kijelzőn a kiírás milyen irányba történjen. Alapértelmezett kiírás a balról jobbra – leftToRight()
. Így a kijelző úgy viselkedik, mintha balraigazított bekezdést írnánk.
Hogyan lehet egyedi karaktereket létrehozni és megjeleníteni?
A createChar ()
funkcióval egyéni karaktereket lehet létrehozni és megjeleníteni a kijelzőn. Ez különösen akkor hasznos, ha olyan karaktert kell kiírni, ami a standard LCD kódtáblában nem érhető el (ezek a 16…127 azonosítójú karakterek) (Bővebben a kódtábla: →Standard ASCII kódtábla).
CGROM és CGRAM
A Hitachi HD44780 LCD vezérlőn alapuló LCD-k kétféle memóriával rendelkeznek: CGROM és CGRAM néven rövidített karaktergenerátor ROM és karaktergenerátor RAM. A CGROM tartalmazza az összes 5 x 8 pontból álló karaktermintát. A CGRAM a felhasználó által létrehozott karaktermintákat tartalmazza, mely karakterből összesen 8 db-ot lehet egyidejűleg létrehozni.
Egyéni karakterek
A következő példakód nyolc egyéni karaktert hoz létre és jelenít meg (0-7 azonosítójú hivatkozással).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | // Include the library: #include <LiquidCrystal_I2C.h> // Create lcd object of class LiquidCrystal_I2C: LiquidCrystal_I2C lcd(0x3F, 16, 2); // Change to (0x27,20,4) for 20x4 LCD. // Make custom characters: byte Heart[] = { B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000 }; byte Bell[] = { B00100, B01110, B01110, B01110, B11111, B00000, B00100, B00000 }; byte Alien[] = { B11111, B10101, B11111, B11111, B01110, B01010, B11011, B00000 }; byte Check[] = { B00000, B00001, B00011, B10110, B11100, B01000, B00000, B00000 }; byte Speaker[] = { B00001, B00011, B01111, B01111, B01111, B00011, B00001, B00000 }; byte Sound[] = { B00001, B00011, B00101, B01001, B01001, B01011, B11011, B11000 }; byte Skull[] = { B00000, B01110, B10101, B11011, B01110, B01110, B00000, B00000 }; byte Lock[] = { B01110, B10001, B10001, B11111, B11011, B11011, B11111, B00000 }; void setup() { // Initialize LCD and turn on the backlight: lcd.init(); lcd.backlight(); // Create new characters: lcd.createChar(0, Heart); lcd.createChar(1, Bell); lcd.createChar(2, Alien); lcd.createChar(3, Check); lcd.createChar(4, Speaker); lcd.createChar(5, Sound); lcd.createChar(6, Skull); lcd.createChar(7, Lock); // Clear the LCD screen: lcd.clear(); // Print a message to the lcd: lcd.print("Custom Character"); } // Print all the custom characters: void loop() { lcd.setCursor(0, 1); lcd.write(0); lcd.setCursor(2, 1); lcd.write(1); lcd.setCursor(4, 1); lcd.write(2); lcd.setCursor(6, 1); lcd.write(3); lcd.setCursor(8, 1); lcd.write(4); lcd.setCursor(10, 1); lcd.write(5); lcd.setCursor(12, 1); lcd.write(6); lcd.setCursor(14, 1); lcd.write(7); } |
A karakterek 0…7 néven hivatkozhatóak, ami megegyezik a 8…15 helyen levő karakterekkel.
Ha bővebben szükséges a karakteres LCD megismerési, minimozi létrehozása, a gyors és a hatékony kiírás trükkjei – akkor az a 90 nap alatt Arduino tanfolyamban megismerhető →90 nap alatt Arduino online tanfolyam.
Mintaprogramok
Az itt levő állományok a cikkhez kapcsolódó mintákat tartalmazzák. Az ezekben szereplő kódok szabadon felhasználhatóak – a bennük levő copyright betartásával.
- I2CLCD eredeti eljáráskönyvtár
- A cikkben előforduló mintakódok
- Egyéb I2CLCD eljárások, mintakódok, tippek-trükkök
- PCF8574 adatlap
- Hitachi HD44780 LCD kontroller adatlap
- KS0066 LCD vezérlő adatlap
- 20×4 LCD adatlap
- 16×2 LCD adatlap
Talán valakit érdekel, hogy hogyan tudtam elhelyezni egy második I2C kijelzőt a vezérlőtől 10m-re mindenféle kiegészítő távolságnövelő modul nélkül.
Üdv
Gyuri