Astăzi vom încerca să ne concentrăm asupra rezultatelor către un afișaj de text. Cel mai popular cip este HD44780 (sau KS0066 compatibil). Să le enumerăm avantajele și dezavantajele:

Pro:

1. Pret mic.
2. Ușor de programat, codul va fi același pentru orice model.
3. Varietate de modele - cele mai comune: 8×1, 16×2, 20×4. Poti gasi si modele 40x4 destul de exotice, i.e. patru rânduri a câte 40 de caractere fiecare.
4. Posibilitatea de a conecta mai multe display-uri la un singur Arduino.
5. Abilitatea de a vă seta propriile simboluri.

Contra:

1. Nu toate afișajele acceptă caractere rusești. Pentru mai multe detalii, vă rugăm să consultați descrierea afișajului specific.
2. Conectarea fără utilizarea magistralei I2C necesită utilizarea a 10-16 fire, ceea ce este foarte rău. cu I2C – 4 fire.

Pe baza celor de mai sus, voi lua în considerare doar conectarea afișajului prin I2C.

Să încercăm.

Ce ne trebuie?

1. Arduino (am luat modelul Nano)
2. Afișare pe cipul HD44780 cu sau fără modul I2C (atunci veți avea nevoie de o placă IIC LC1602 separată) - în cazul nostru 16x2 fără modul I2C
3. Rezistor de 10Kohm (dacă aveți nevoie de control manual al luminii de fundal).
4. Potențiometru (dacă aveți nevoie de control manual al luminii de fundal).
5. Placă de dezvoltare Breadboard.
6. Biblioteca LiquidCrystal_I2C.

Mică digresiune nr. 1: Cum să distingem un afișaj cu un modul I2C?

De fapt, este destul de simplu. Dacă, răsturnând afișajul, vedem un bloc lung de conectori (de obicei 16 bucăți), atunci nu există niciun modul I2C pe afișaj:

Și așa arată afișajul cu modulul I2C deja instalat:

Pinii SCL, SDA, VCC, GND sunt folosiți pentru Conexiuni Arduino. Cele două contacte din stânga - în imagine sunt închise cu un jumper - sunt necesare pentru ca lumina de fundal să funcționeze.

Dacă modulul nu este conectat, va trebui să o faceți singur. Principalul lucru la care trebuie să acordați atenție este să conectați contactele în ordinea corectă. De obicei, primul și 16 pini sunt marcate. Uneori se întâmplă ca 15-16 contacte, prin care se controlează lumina de fundal, să poată fi amplasate în fața primei (în acest caz vor fi numerotate). Pe modul în sine, primul pin poate fi, de asemenea, desemnat nu printr-un număr, ci printr-un pătrat în jurul pinului însuși.

Scheme:

Să punem cap la cap următoarea diagramă:

Aș dori să vă atrag atenția asupra următoarelor puncte:

1. Dacă dați peste un afișaj cu un modul I2C deja lipit, atunci firele marcate cu gri nu vor fi necesare. Altfel, nimic nu se schimba.
2. Dacă nu dorim să schimbăm luminozitatea afișajului, atunci diagrama va fi simplificată:

După cum ați observat, doi pini de pe modulul I2C etichetați cu LED sunt responsabili pentru iluminarea de fundal a afișajului. Dacă nu dorim să folosim controlul luminozității, le putem închide pur și simplu.

Acum să ne uităm la cod.

Aproape totul aici ar trebui să ne fie familiar. În rândul 5 indicăm adresa dispozitivului. În rândurile 16 și 17 - numărul de caractere din rând și numărul de rânduri. În rândurile 20-22 – Creăm un obiect pentru lucrul cu afișajul și descriem parametrul pentru lucrul cu acesta.

Mică digresiune nr. 2: Cum să aflați adresa unui dispozitiv I2C?

În cea mai mare parte, adresa poate fi găsită în fișa de date pentru cipul pe care este construit dispozitivul I2C. Dacă acest lucru nu este posibil, iată un link către o arhivă cu o schiță și diagrame - care determină adresele tuturor dispozitivelor conectate prin magistrala I2C. Trebuie doar să conectați dispozitivul la Arduino, să încărcați schița, să deschideți consola și să vedeți adresa.

Aici vedem o funcție care, de fapt, va fi responsabilă pentru ieșirea pe afișaj. Principiul de ieșire este cam așa:

– Setăm poziția începutului ieșirii folosind funcția setCursor().

– Imprimați un șir folosind funcția print().

După aceasta, următoarea funcție print() va începe scoaterea din următoarea poziție, după care s-a încheiat intrarea anterioară. De asemenea, aș dori să vă atrag atenția asupra faptului că, spre deosebire de ieșirea către consolă, funcția println() nu este folosită aici pentru a finaliza ieșirea și avansul de linie.

Astfel, pe ecran va apărea inscripția „Test LCD1602” în prima linie, iar a doua linie va indica rezoluția afișajului și un contor care arată câte cicluri a finalizat schița noastră.

Dar, dacă trebuie să afișăm multe valori variabile pe ecran, această metodă nu este complet convenabilă. Faptul este că procedura de ieșire a afișajului este foarte consumatoare de energie și lentă și facem ieșire în această funcție de până la 7 ori. Va fi mult mai ușor să generați șirul în avans și apoi să îl scoateți în întregime. Funcția de intrare formatată sprintf() ne va ajuta în acest sens.

Mică digresiune #3: Funcția de intrare formatată sprintf().

În limbajul C există câteva funcții foarte convenabile pentru ieșirea șirurilor de caractere - se numesc funcții de ieșire formatate - printf (din cuvintele print și format). În nostru caz concret Ne interesează funcția sprintf, care nu imprimă nimic pe ecran, ci generează un șir pentru ieșirea ulterioară. Arata cam asa:

sprintf (str , „Șir %d pentru ieșire “, i );

Funcția generează un șir (marcat cu albastru) folosind un șablon (galben) în care sunt înlocuite valorile variabilelor (cu verde). Rezultatul rezultat va fi scris într-o variabilă șir (în roșu).

Pot exista mai multe șabloane și variabile. În acest caz, variabilele sunt scrise separate prin virgulă. Principalul lucru este să vă asigurați că numărul de modele dintr-o linie corespunde numărului de variabile. Variabilele pentru șabloane sunt luate secvenţial, de exemplu. valoarea primei variabile este înlocuită în primul șablon, valoarea celei de-a doua variabile în al doilea etc.

Ce sunt șabloanele? Orice model începe cu simbolul „%” și se termină cu unul dintre simbolurile de tip zece (în cazul Arduino – șapte). Între ele pot exista o mulțime de informații despre cum să scoateți valoarea sau să nu existe absolut nimic.

Să ne uităm la ce poate fi în șablon. ÎN caz generalșablonul arată astfel:

%[flag ][width ][.precicision ]tip

Parantezele pătrate indică faptul că elementul cuprins în ele poate lipsi. O bară verticală indică faptul că una dintre valorile specificate ar trebui să fie selectată în acest câmp (în cazul nostru, una dintre literele H, I sau L).

Să ne ocupăm mai întâi de elementul necesar al șablonului - tipul. Specifică ce tip de variabilă va fi scoasă și poate lua una dintre următoarele valori:

Simbol	Sens
c	Un singur personaj
s	Șir de caractere
d,i	Număr întreg zecimal cu semn
o	Octal întreg
u	Număr întreg zecimal fără semn
x, X	Număr întreg hexazecimal
p	Indicator (în hexazecimal)
f	Număr fracționar în format fix
e, E	Număr fracționar în format științific
g, G	Număr fracționar în format științific sau fix

Acele tipuri care nu sunt aplicabile atunci când lucrați cu Arduino sunt marcate cu gri. Astfel, pentru a scoate un șir de caractere trebuie să specificați „%s” și pentru a scoate un număr întreg – „%d”.

În continuare, să ne uităm la câmpul de lățime. Numărul din acesta indică lățimea minimă a câmpului în care va fi afișat șablonul. Dacă dimensiunea valorii din variabilă este mai mică, câmpul va fi umplut cu spații dacă este mai mare, intrarea va depăși câmpul. Astfel, șablonul „%6d” pentru numărul 385 va scoate 385 (rețineți cele trei spații dinaintea numărului).

Specificatorul de precizie începe întotdeauna cu un punct și următorul număr specifică acțiuni diferite în funcție de tipul valorii. Pentru tipurile „d,o,u,x” va indica cantitate minima caractere care ar trebui să apară în timpul procesării. Pentru tipul „f” – numărul de zecimale. Pentru tipul „s” – numărul maxim de caractere șir de caractere care vor fi afișate. De exemplu, „%6.1f” pentru numărul 34.2345 va scoate „34.1” (rețineți că punctul este, de asemenea, considerat un semn și vor exista două spații înaintea numărului). Sau șablonul „%.3s” din șirul „precizie” va scoate doar primele trei caractere – „precizie”.

Steagul vă permite să schimbați afișarea valorii afișate:

Puteți citi mai multe despre șabloanele de funcție printf pe Internet. Aici am dat scurtă prezentare generală caracteristici utilizate cel mai frecvent.

Deci, funcția noastră de ieșire, rescrisă pentru a utiliza ieșirea formatată, ar arăta astfel:

Rețineți că în rândurile 33 și 37 generăm întreaga linie pentru ieșire, iar în rândurile 34 și 38 le tipărim.

În cele din urmă, funcțiile noastre preferate de configurare și buclă.

Pe linia 47 setăm rezoluția afișajului, pe linia 48 pornim lumina de fundal (a cărei luminozitate poate fi reglată cu un potențiometru). În linia 49 setăm contorul de cicluri la zero. Îl vom crește cu unul în a 37-a linie a rezultatului (vă amintiți construcția count++?). În cele din urmă, pe linia 56 numim funcția de afișare discutată mai devreme. Toate.

Ce poate fi schimbat sau îmbunătățit?

De exemplu, poți face control automat iluminare în funcție de iluminare, folosind un fotorezistor sau un senzor de lumină de la stația meteo discutată în mai multe articole anterior. De exemplu, în condiții de iluminare puternică, creșteți luminozitatea luminii de fundal, iar noaptea, reduceți-o. Sau atașați un senzor de mișcare și porniți lumina de fundal când apare un obiect în fața afișajului, sau... În general, cred că înțelegeți deja că, dacă doriți, înlocuind una sau mai multe componente și scriind o bucată de cod, puteți îmbunătăți destul de serios capacitatea de utilizare a afișajului. De asemenea, putem folosi propriile noastre simboluri dezvoltate pentru afișare.

Nu iau în considerare toate aceste întrebări aici, deoarece ele depășesc scopul unei recenzii pentru începători.

Și asta e tot ce am pentru azi.

Cu acest articol simplu vreau să încep seria mea de articole despre automatizarea locului de muncă.

În prezent pe piață există număr mare Afișaje LCD sau, așa cum sunt numite și, afișaje de sinteză a caracterelor. 1602 de afișaje (16 caractere, 2 linii) pe un cip au devenit deosebit de răspândite HD44780 și compatibile. Ele pot fi achiziționate ieftin în China.

Acest articol descrie în detaliu schema de conectare pentru acest ecran, dar este potrivit și pentru multe alte afișaje de text. Există o bibliotecă pentru arduino Cristal lichid cu care este foarte convenabil să lucrezi cu afișajul.

Componente necesare

1. LCD 1602 pe cip HD44780
2. Orice Arduino. În cazul meu, Arduino Nano
3. Rezistor trimmer
4. Aspect
5. Modul de putere
6. Fire de conectare

Conexiune la afișaj

Display-ul este alimentat de o tensiune de 5V. Iluminarea de fundal a afișajului este un circuit separat, care nu este conectat la restul circuitului. Îl puteți porni aplicând 5V la pinul 15 și conectând minus la pinul 16. Îl puteți face reglabil folosind un semnal PWM. De asemenea, este la modă să îl porniți și să îl opriți separat, dacă este necesar.

Alimentarea pentru restul circuitelor de afișare este furnizată la următorii pini:

• 1 - GND
• 2 - +5
• 3 - Contrast. Se conectează printr-un divizor de tensiune de la 5V. Divizorul este de obicei un rezistor obișnuit variabil sau de reglare.

Pentru a conecta display-ul, este suficient să folosiți 6 linii, 6 pini pe Arduino. Nu trebuie să citim afișajul, așa că conectăm imediat pinul 5 (RW), care este responsabil pentru citire și scriere, la masă.

Apoi, conectăm Arduino și ecranul cu cele 6 linii de comunicare ale noastre. Nu contează ce contacte vor fi selectate pe Arduino: le vom specifica în program, dar pentru exemplu am ales următoarea configurație:

• Afișează pinul 4 - al 4-lea Pin Arduino. Aceasta este linia de semnal al adresei. Cunoscut ca A0 sau RS. În funcție de faptul că este 0 sau 1, afișajul înțelege dacă avem o comandă pe linia de date precum „mutați cursorul” sau un cod de caracter de afișat.
• Pinul 6 al afișajului este pinul 5 Arduino. Aceasta este linia de permisiuni de acces la date. Cunoscut ca E sau Enable. Când această linie devine una, afișajul execută o comandă sau scoate un caracter din linia de date.
• Al 11-lea, al 12-lea, al 13-lea, al 14-lea pin al afișajului este al 10-lea, al 11-lea, al 12-lea, respectiv al 13-lea pin al Arduino. Acestea sunt linii de date. Cunoscut ca DB4, DB5, DB6, DB7.

Ecranul este conectat și gata să primească date. Tot ce rămâne este să scrieți un program pentru Arduino.

Programare

// Conectați biblioteca standard LiquidCrystal #include // Inițializați obiectul ecranului, transferați contactele // utilizate pentru conectarea la Arduino în ordine: // RS, E, DB4, DB5, DB6, DB7 LiquidCrystal lcd(4, 5, 10, 11, 12, 13); void setup() ( // setează dimensiunea (numărul de coloane și rânduri) ecranului lcd.begin(16, 2); // imprimă prima linie lcd.print("Hello World"); // setează cursorul la coloana 0, linia 1 Adică // aceasta este de fapt a doua linie, deoarece numerotarea începe de la zero lcd.setCursor(0, 1 // imprimă a doua linie lcd.print("LCD funcționează!!!); "); bucla() ( )

Totul este destul de simplu și ar trebui să fie clar din comentarii.

Când vă creați propriul dispozitiv, este adesea nevoie să afișați rapid diverse informații. De exemplu, dacă creați un controler casă inteligentă, atunci este rezonabil să echipați dispozitivul cu un dispozitiv de ieșire care vă permite să aflați rapid starea curentă a sistemelor. Cea mai bună soluție este un afișaj cu cristale lichide. Consumul de energie atunci când lumina de fundal este oprită este minim, iar lucrul cu afișajul este extrem de simplu și nu necesită multă intervenție în codul programului. De fapt, ieșirea informațiilor pe afișajul LCD nu este mult diferită de ieșirea către portul serial. Articolul discută conexiunea unui afișaj care generează caractere bazat pe popularul cip HD44780 la controlerul Arduino.

Cum funcționează un afișaj LCD cu text?

Pentru a înțelege unele dintre nuanțe, este util să știți cum funcționează un afișaj care generează caractere. O caracteristică specială a acestui tip de afișaj este prezența propriului controler cu propria memorie. DDRAM - memorie de afișare. Pentru a afișa un simbol pe ecran, trebuie să încărcați simbolul într-o celulă de memorie și apoi să transmiteți o comandă pentru a afișa celula de memorie. În timpul transmisiei, caracterele sunt codificate folosind coduri ASCII. De exemplu, când scrieți codul 0x31 în memorie, simbolul „ 1 " Corespondența codului simbolului cu afișarea acestuia pe ecran (adică „imaginea” simbolului) este stocată în memoria CGROM. CGROM este memorie nevolatilă. Prin urmare, afișajul poate afișa doar acele caractere care sunt „conectate” la controler. De aceea, nu orice afișaj este capabil să afișeze, de exemplu, caractere rusești. Display-urile vândute în magazinul nostru, din păcate, nu sunt rusificate. Există și memorie CGRAM. Este schimbabil. Ne putem crea propriile simboluri și le putem afișa pe afișaj. Merită să luați în considerare faptul că nu puteți crea mai mult de opt personaje.

Toată această muncă „sub capotă” este importantă doar pentru înțelegerea unora dintre nuanțe. Există o bibliotecă simplă și simplă pentru Arduino, care face toată treaba pentru tine, permițându-ți să controlezi ieșirea afișajului cu ușurință și simplu.

Conectarea ecranului LCD la Arduino

Pentru a conecta afișajul, desigur, trebuie să-l instalați pe o placă de breadboard. Vă rugăm să rețineți: afișajele vândute în magazinul nostru sunt vândute fără un conector cu pin lipit. Dacă doriți să primiți un afișaj imediat gata de instalare pe o placă de breadboard, bifați caseta de selectare „Conector de lipire” de pe pagina produsului și vom lipi conectorul pentru dvs. Transferul de date pe afișaj poate fi organizat în două moduri: 4 sau 8 biți o dată. În consecință, veți avea nevoie de 4 sau 8 pini Arduino. În practică, nu va exista un câștig de viteză atunci când utilizați o interfață pe opt biți. Prin urmare, avem nevoie doar de 4 pini digitali pentru a transmite date. Alți 3 pini vor fi necesari pentru a seta modul de funcționare a afișajului. În total, pentru a conecta afișajul veți avea nevoie doar de 7 ieșiri digitale ale controlerului. Contactele de pe afișaj sunt etichetate, ceea ce vă va ajuta să evitați confuzia atunci când vă conectați:

Numerotăm concluziile de la stânga la dreapta:

• 1-(VSS) Teren de afișare. Se conectează la șina de masă.
• 2-(VDD) Afișează sursa de alimentare. Se conectează la șina de alimentare.
• 3-(V.O.) Intrare potențiometru (inclusă). Contrastul afișajului este reglat cu ajutorul unui potențiometru. Ieșirea din mijloc a potențiometrului este conectată la pinul afișajului.
• 4-(R.S.) Intrare semnal „Comandă”. Se conectează la orice pin digital Arduino. În exemplu, este conectat la pinul nr. 12.
• 5-(RW) Setează modul „citire” sau „scriere”. O să înregistrăm. Conectăm contactul la masă.
• 6-(E) Activați. O altă ieșire „comandă”. Când se aplică una la ieșire, afișajul execută comanda transmisă anterior. Se conectează la orice ieșire digitală. În exemplu, este conectat la pinul nr. 11.
• 7-10 (D0-D3) îl lăsăm neconectat. Aceștia sunt pinii de date care sunt utilizați în interfața pe opt biți. Nu avem nevoie de ea.
• 11-14 (D4-D7) Contacte pentru transmisia de date în modul pe patru biți. Din nou, acestea sunt conectate la orice ieșire digitală. În exemplu, acestea sunt conectate la pinii 5, 4, 3 și, respectiv, 2 (D4 la pinul 5, D5 la pinul 4 etc.).
• 15 (O) Iluminare de fundal LED anod. Rezistorul de limitare a curentului este deja instalat pe afișaj, astfel încât anodul este pur și simplu conectat la șina de alimentare. Deoarece iluminarea de fundal folosește cel mai obișnuit LED, îl puteți conecta la orice pin care îl acceptă și puteți controla luminozitatea luminii de fundal în mod programat.
• 16 (K) Catod de iluminare. Se conectează la șina de masă.

Schema vizuală a conexiunii:

Programare

Impreuna cu Arduino IDE Este furnizată o bibliotecă excelentă pentru afișajele cu cristale lichide - LiquidCrystal. Biblioteca conține exemple care dezvăluie pe deplin capacitățile ecranului. Pentru a începe, utilizați exemplul standard „HelloWorld” (Fișier -> Exemple -> LiquidCrystal -> HelloWorld) sau încărcați următorul cod pe placă:

/* *Pinul afișajului RS la pinul arduino 12 *Activează pinul afișajului la pinul arduino 11 *pinul afișajului D4 la pinul arduino 5 *pinul afișajului D5 la pinul arduino 4 *pinul afișajului D6 la pinul 3 arduino *pinul afișajul D7 la pinul 2 arduino *Ieșirea R/W a afișajului la masă *Ieșirea potențiometrului la ieșirea VO a afișajului */ // conectați biblioteca: #include ; // Inițializează afișarea // Enumerează pini arduino la care // sunt conectate contacte de afișare RS, E, D4, D5, D6, D7 LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() ( // Specificați numărul de coloane și linii ale afișajului: lcd.begin(16, 2); // Afișează un mesaj pe afișaj. lcd.print("hello, world!"); ) void loop() ( // setează cursorul pe coloana 0 (zero) a primului rând // de fapt, cursorul va fi setat pe al doilea rând (inferior) // numerotarea rândurilor și coloanelor începe de la zero lcd.setCursor( 0, 1); // afiseaza numarul de secunde care au trecut din momentul in care placa este incarcata: lcd.print(millis()/1000);

* Pinul afișajului RS la pinul 12 arduino *Activați pinul afișajului la pinul 11 ​​arduino * Pinul afișajului D4 la pinul 5 arduino * Pinul afișajului D5 la pinul 4 arduino * Pinul afișajului D6 la pinul 3 arduino * Pinul afișajului D7 la pinul 2 arduino *Ieșire afișaj R/W la masă * Ieșirea potențiometrului la pinul VO al afișajului // conectați biblioteca: #include ; // Inițializați afișajul // Listați pinii arduino la care sunt conectați // Pini de afișare RS, E, D4, D5, D6, D7 void setup() ( // Specificați numărul de coloane și rânduri ale afișajului: lcd. începe (16, 2); // Afișează un mesaj pe afișaj. lcd. print ("bună, lume!"); void loop() ( // numerotarea rândurilor și coloanelor începe de la zero lcd. setCursor(0, 1); // afișează numărul de secunde // a trecut de când placa a fost încărcată: lcd. print(millis()/1000);

După încărcarea acestui cod în Placa Arduino Ecranul va afișa „bună, lume!”( engleză "Salut Lume!") pe prima linie și un cronometru care numără secundele de pe a doua linie.

Așa cum este de obicei cazul, codul este simplu și ușor de înțeles. Cu toate acestea, îl vom analiza în continuare mai detaliat:

• LCD cu cristale lichide(12, 11, 5, 4, 3, 2) - Această linie creează un obiect de afișare cu care vom lucra în viitor. Între paranteze, numerele de pin la care sunt conectate contactele afișajului sunt transmise ca argumente. În consecință: RS, E, D4, D5, D6, D7. După cum sa menționat mai sus, numerele de pin la conectare pot fi alese complet arbitrar.
• lcd.begin(16, 2) - aici am configurat dimensiunile afișajului. Acest exemplu are 16 coloane și 2 rânduri. Pentru afișajul nostru 20X4, această linie ar arăta astfel: lcd.begin(20, 4).
• lcd.print(„bună ziua, lume!”) - afișează text pe afișaj. După specificarea dimensiunii afișajului (lcd.begin), cursorul este poziționat în colțul din stânga sus al afișajului. Prin urmare, acest text va fi afișat pe prima linie (sus) din stânga.
• lcd.setCursor(0, 1) - setează cursorul în poziția specificată. În acest caz, este indicată poziția cea mai din stânga a celei de-a doua linii. Numărul coloanei este specificat în paranteze, apoi numărul rândului. Atât rândurile, cât și coloanele sunt numerotate din poziția zero. Astfel: lcd.setCursor(0, 0) - va seta cursorul în colțul din stânga sus, lcd.setCursor(15, 0) - în dreapta jos.
• lcd.print(millis()/1000) - deja descris mai sus. Aici, în loc de text, o formulă de calcul este transmisă ca parametru. Rezultatul este afișat pe ecran.

Acum că ne-am ocupat de cel mai simplu exemplu, putem trece la exemple mai complexe. Și dacă înțelegeți deja totul și sunteți gata să cumpărați un afișaj LCD, atunci am adunat pentru dvs. link-uri către vânzători de display chinezi pe care i-am verificat:

Afișaj LCD cu caractere

Dimensiunea afișajului (coloane*rânduri)	Culoare iluminare de fundal	Stare
20*4	Albastru	verificat
20*4	Galben	verificat
16*2	Albastru	verificat
16*2	Galben	verificat
16*2	Verde	verificat

Revizuirea altor exemple de biblioteci LiquidCrystal

În exemplele standard furnizate cu biblioteca LiquidCrystal puteți găsi următoarele schițe:

• Defilare automată- demonstrează capacitatea de a derula automat textul. Un fel de linie târâtoare. Când este afișat un caracter, caracterele anterioare sunt deplasate. Astfel, noul personaj este afișat în același loc.

• Clipi- demonstrează capacitatea de a activa afișarea unui cursor intermitent sub forma unui dreptunghi.

• Cursor- demonstrează capacitatea de a activa afișarea unui cursor sub forma unei linii orizontale intermitente.

• Caracter personalizat- este afișată posibilitatea de a crea propriile simboluri pentru a le afișa pe afișaj. Apropo, există o eroare în această schiță. Detalii mai jos.

• Afişa- arată o modalitate de a „opri” afișajul. Adică afișați sau ascundeți textul afișat.

• Derulați- demonstrează capacitatea de a derula textul manual.

• Serial Display- afiseaza pe ecran textul tiparit in fereastra monitor port (adica textul transmis prin portul serial).
• setCursor- umple afișajul cu litere, demonstrând capacitatea de a plasa cursorul în orice poziție de pe ecran.
• TextDirection- demonstrează capacitatea de a schimba direcția de ieșire a textului (de la dreapta la stânga sau de la stânga la dreapta).

Să luăm în considerare mai detaliat procedurile ale căror capacități sunt demonstrate de aceste exemple:

lcd.autoscroll()

După apelarea acestei proceduri, textul de pe ecran se va derula automat. Pentru a opri derularea, sunați lcd.noAutoscroll().

lcd.blink()

După apelarea procedurii, cursorul va apărea ca un dreptunghi intermitent. Pentru a dezactiva apelul lcd.noBlink()

lcd.cursor()

După apelarea procedurii, cursorul va apărea ca o linie orizontală care clipește. Pentru a dezactiva apelul lcd.noСursor(). Cursorul va deveni din nou invizibil.

lcd.createChar()

Procedura încarcă un caracter descris ca o matrice de octeți în tabelul de caractere al ecranului variabil (memoria CGRAM). Argumentul este numărul simbolului și o matrice de octeți care descrie simbolul. Să ne uităm la asta mai detaliat. Puteți introduce maximum opt caractere în memoria afișajului. Pentru a adăuga propriul simbol aveți nevoie de:

1. Creați o matrice de octeți care descrie caracterul.
2. Scrieți un simbol în memoria afișajului atribuindu-i un număr în tabelul de simboluri. Caracterele sunt numerotate în intervalul de la zero la șapte.
3. Afișați un caracter pe ecran utilizând procedura lcd.write()(a nu se confunda cu lcd.print()), ca argument al căruia trece numărul simbolului.

O eroare în mediul de dezvoltare și caracteristicile bibliotecii au dus la incapacitatea de a afișa simbolul numărul 0 (zero). Când compilatorul întâlnește linia lcd.write(0), va arunca o eroare: „ apelul „write(int)” supraîncărcat este ambiguu". Aceasta este exact linia care apare în exemplu Caracter personalizat biblioteci. Când încercați să compilați exemplul standard, veți primi o eroare:

CustomCharacter.ino: În funcția „void setup()”: CustomCharacter:115: eroare: apelul „write(int)” supraîncărcat este ambiguu /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal.h:82 : notă: candidații sunt: ​​virtual size_t LiquidCrystal::write(uint8_t) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print.h:49: note: size_t Print::write(const char *)

Caracter personalizat. ino: În funcția „void setup()”: CustomCharacter: 115: eroare: apelul „write (int)” supraîncărcat este ambiguu /home/nazarovd/arduino - 1.0.5/libraries/LiquidCrystal/LiquidCrystal. h : 82 : notă : candidații sunt : virtual size_t LiquidCrystal :: write (uint8_t ) /home/nazarovd/arduino - 1.0.5/hardware/arduino/cores/arduino/Print. h : 49 : note : size_t Print :: write (const char * )

Pentru a elimina eroarea, trebuie doar să schimbați linia lcd.write( 0 ) la lcd.write( (octet)0).
Acum un mic exemplu despre crearea propriului simbol. Să afișăm simbolul rublei.

// Includeți biblioteca #include ; // Inițializați afișajul LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Descrieți simbolul nostru. // Pur și simplu „desenăm” simbolul cu unități // Când sunt afișate pe ecran, unitățile vor apărea ca puncte umplute, zerourile nu vor fi completate în octet rubl = ( 0b00000, 0b01110, 0b01001, 0b01001, 0b01110, 0b01010, 0b01010 0b01000, ); void setup() ( // scrieți caracterul nostru în memoria ecranului // treceți numărul simbolului // și o matrice de octeți care descrie caracterul nostru ca argumente lcd.createChar(0, rubl); // setați afișajul lcd.begin( 16, 2); void loop() ( // setează cursorul în colțul din stânga sus al ecranului lcd.setCursor(0,0); // afișează numărul de caractere zero pe ecran lcd.write((byte)0 ); // nu face nimic timp de 10 secunde delay(10000);

// Includeți biblioteca #include ; // Inițializați afișajul LCD cristal lichid (12, 11, 5, 4, 3, 2);

Această instrucțiune arată cum să vă conectați la Arduino și să utilizați ecrane LCD 16x2 și 20x4. Aceste ecrane au o lumină de fundal încorporată bazată pe un LED de putere redusă și funcționează de la +5 V. Pentru a conecta aceste ecrane LCD veți avea nevoie de 6 pini. Puteți folosi orice pin de pe Arduino!

Instrucțiunile sunt scrise pe baza ecranelor LCD de la Adafruit - albastru-alb 16x2, RGB 16x2 LCD și albastru-alb 20x4, RGB 20x4. Dacă utilizați un ecran LCD de la alt producător, nu există nicio garanție 100% că va funcționa (deși funcționează 99% din timp).

LCD-uri cu caractere și grafice - care este diferența?

Există un număr mare de ecrane LCD diferite. În acest articol ne vom uita la ecranele LCD cu caractere. Ecrane ca acestea sunt o opțiune excelentă pentru afișarea textului. De asemenea, puteți personaliza afișarea pictogramelor, dar dimensiunea acestor pictograme nu trebuie să depășească 7 pixeli (foarte mici!).

Fotografia de mai jos arată un exemplu de monitor LCD cu 16 caractere cu două linii:

Dacă te uiți cu atenție, vei vedea dreptunghiuri mici în care sunt afișate simbolurile. Fiecare dreptunghi este o grilă separată de pixeli. Pentru comparație, un ecran LCD grafic este prezentat mai jos:

Pe afișajul grafic cu cristale lichide există unul plasă mare pixeli (în acest exemplu - 128x64). Puteți afișa text pe el, dar este mai bine să afișați imagini. LCD-urile grafice sunt de obicei mai mari, au mai mulți pini pentru conexiune și sunt oarecum mai dificil de utilizat decât ecranele LCD cu text.

În acest articol vom acoperi doar ecranele de text/caractere!

Diferite modele de ecrane LCD

După ce am limitat tipul de ecrane luate în considerare, să vedem care sunt acestea.

Deși sunt folosite doar pentru afișarea textului, există diferite modele și factori de formă: în colțul din stânga sus ecranul LCD este de 20x4 cu text alb pe fond albastru, în dreapta sus este de 16x4 cu text negru pe fundal verde, în stânga jos este și 16x1 cu text negru pe un fundal gri.

Vestea bună este că toate aceste ecrane sunt interschimbabile. Dacă ai configurat unul dintre ele, îl poți înlocui cu un alt model. Schița va trebui schimbată puțin, dar legătura este aceeași!

În această parte folosim ecrane LCD cu o șină și 16 pini pentru conectare (vezi fotografia de mai sus). Există și un LCD cu 2 șine de 8 contacte pentru conectare (în figura de mai jos).

Conectarea celui de-al doilea model la o placă de circuit fără lipire este mai dificilă.

Conectarea unui ecran LCD cu caractere la Arduino

Instalarea șinelor de contact

Pe lângă ecranul LCD, veți avea nevoie de cabluri suplimentare. În primul rând - la 10 kOhm. Cu ajutorul potențiometrului vom regla contrastul afișajului. Fiecare ecran LCD are setări de contrast diferite, așa că ajustările sunt obligatorii. În plus, veți avea nevoie de o șină de contact de 0,1".

Dacă șina cu contacte este prea lungă, puteți pur și simplu să tăiați contactele în exces!

Trebuie să lipiți pinii pe afișajul LCD.

Când lipiți, aveți grijă să nu vă deteriorați! Puteți „prinde” mai întâi primul și 16 contacte, apoi lipiți restul.

Putere și iluminare

Conectarea energiei electrice și a iluminatului

	Explicații
	Începem să ajungem la niște lucruri interesante! Instalați-vă LCD-ul pe placa.
	Alimentam placa de breadboard de la Arduino. Conectați +5V la șina roșie și Gnd la șina albastră.
	După aceasta, vom conecta lumina de fundal a ecranului LCD. Conectați pinul 16 la gnd și pinul 15 la +5V. Majoritatea ecranelor LCD au rezistențe pentru iluminarea de fundal. Dacă nu există rezistențe pe modulul dvs., va trebui să adăugați una între 5V și pinul 15. Pentru a calcula valoarea rezistenței, verificați curent maxim pentru alimentarea luminii de fundal și valoarea aproximativă a căderii de tensiune din fișa de date. Scădeți valoarea căderii de tensiune de la 5 V, apoi împărțiți cu putere maximă curent și rotunjiți la cea mai apropiată valoare standard mai mare a rezistenței. De exemplu, dacă căderea de tensiune este de 3,5 V și curentul este de 16 mA, valoarea rezistorului ar fi: (5 - 3,5)/0,016 = 93,75 ohmi sau 100 ohmi după rotunjirea la valoarea standard. Dacă nu puteți găsi fișa de date, utilizați un rezistor de 220 ohmi. Adevărat, în acest caz lumina de fundal poate fi destul de palidă.
	Conectați-vă Arduino la alimentare. Lumina de fundal ar trebui să se aprindă.

Apropo, unele ecrane LCD ieftine nu au iluminare din spate!

Circuit pentru reglarea contrastului

Circuit pentru reglarea contrastului

	Explicații
	Instalați potențiometrul. În fotografie este în dreapta pinului 1.
	Conectați o parte a potențiometrului la +5V și cealaltă la Gnd. Conectați contactul din mijloc al potențiometrului la pinul 3 de pe LCD.
	Acum conectăm logica ecranului nostru - acesta este un circuit separat de iluminarea de fundal! Pinul 1 merge la Gnd și pinul 2 merge la +5V.
	Porniți Arduino. Dacă monitorul LCD are lumină de fundal, acesta ar trebui să se aprindă. Rotiți butonul potențiometrului pentru a vedea primul dreptunghi de pixeli pe prima linie.

Dacă totul a funcționat, felicitări. Asta înseamnă că logica, iluminarea și contrastul funcționează! Dacă nu funcționează, nu treceți la următorii pași din instrucțiuni până nu vă dați seama care este eroarea!

Conexiunea finală

D0 până la D7, RS, EN și RW. D0-D7 sunt pinii care stochează valorile trimise pe afișaj. Pinul RS spune controlerului dacă vom afișa date (de exemplu, un caracter ASCII) sau dacă este un octet de control (de exemplu, schimbarea poziției cursorului). PIN-ul EN este prescurtarea pentru „activare” și cu acest pin îi spunem LCD-ului când datele sunt gata de citit. Pinul RW este folosit pentru a seta direcția - vrem să afișăm (de obicei) sau să citim (folosite mai puțin frecvent) date de pe afișaj.

Nu toți acești pini trebuie să fie conectați la Arduino. De exemplu, nu este nevoie să folosim RW dacă afișăm doar date pe ecran, așa că este suficient să îl „tragem în sus” la pinul Gnd. În plus, puteți comunica cu ecranul LCD folosind 4 pini în loc de 8. Probabil apare o întrebare firească, în ce cazuri se folosesc 8 pini? Acest lucru afectează cel mai probabil viteza de transfer de date. Adică, folosind 8 contacte în loc de 4, poți crește viteza schimbului de informații de 2 ori. În acest caz, viteza nu este importantă, așa că folosim 4 pini pentru a conecta LCD-ul la Arduino.

Deci, avem nevoie de 6 pini: RS, EN, D7, D6, D5 și D4.

Pentru a lucra cu ecranul LCD, vom folosi biblioteca LiquidCrystal, care simplifică foarte mult procesul de configurare a pinurilor. Unul dintre avantajele acestei biblioteci este că puteți utiliza orice pini de pe Arduino pentru a conecta pinii LCD. Deci, până la sfârșitul acestui ghid, veți putea înlocui cu ușurință contactele dacă este esențial pentru proiectul dvs.

Conexiunea finală a afișajului

	Explicații
	După cum am menționat mai sus, nu vom folosi pinul RW, așa că îl vom trage la pământ. Acesta este pinul 5.
	Apoi conectăm RS - acesta este pinul #4. Folosim firul maro pentru a-l conecta la pinul digital #7 de pe Arduino.
	Utilizați un fir alb pentru a conecta pinul EN - pinul #6 la pinul digital digital #8 de pe Arduino.
	Acum este timpul pentru contactele de date. DB7 este pinul #14 pe LCD. Este conectat cu un fir portocaliu la pinul #12 de pe Arduino.
	Au mai rămas trei pini de date, DB6 (pinul #13 galben), DB5 (pinul #12 verde) și DB4 (pinul #11 albastru). Se conectează la pinii #11, 10 și, respectiv, 9 de pe Arduino.
	Ca urmare a conexiunii, veți obține ceva similar cu fotografia din stânga.

Folosim un LCD cu caractere

Este timpul să încărcați schița pe Arduino pentru a controla ecranul LCD. Biblioteca LiquidCrystal este instalată implicit în Arduino IDE. Așa că trebuie doar să descarcăm unul dintre exemple și să-l reglam puțin în conformitate cu pinii pe care i-am folosit pentru a conecta.

Deschideți schița File→Examples→LiquidCrystal→HelloWorld.

Actualizăm informațiile despre pini. Căutăm următoarea linie:

LiquidCrystal lcd (12, 11, 5, 4, 3, 2);

Și schimbați-l în:

Acum puteți compila și încărca schița pe Arduino.

Dacă este necesar, reglați contrastul

Desigur, puteți utiliza afișajul LCD cu orice dimensiune. De exemplu, fotografia de mai jos arată Funcționare LCD 20x4.

Sau text negru pe fundal verde:

Unul dintre avantajele ecranelor cu text negru pe fundal verde este capacitatea de a opri lumina de fundal.

Să folosim câte linii

Să înțelegem cum gestionează ecranul LCD mesajele lungi și mai multe linii. De exemplu, dacă modificați următoarea linie:

lcd.print("bună, lume!");

La urmatoarea:

lcd.print("bună, lume! Acesta este un mesaj lung și lung");

Afișaj LCD 16x2 va trunchia totul după al 16-lea caracter:

Dar ecranul LCD 20x4 va transporta caracterele neafișate de la prima linie la a treia (a doua linie va continua până la a patra). Nu este foarte convenabil, dar în această etapă va trebui să-l suportați. Deci, atunci când afișați șiruri lungi, numărați caracterele astfel încât să nu depășiți lungimea permisă.

LCD cu iluminare de fundal RGB

Aceste ecrane funcționează la fel ca și ecranele obișnuite, dar există trei LED-uri (roșu, verde, albastru) pentru iluminare de fundal, astfel încât să puteți utiliza diferite culori de iluminare de fundal.

După conectarea LCD-ului și verificarea acestuia conform instrucțiunilor de mai sus, conectați LED-urile la pinii analogici PWM ai Arduino dvs. pentru a regla fin culorile. Dacă utilizați Arduino Uno, ar trebui să aveți trei contacte PWM gratuite rămase. conectați LED-ul roșu (pin 16 de pe LCD) la Digital 3, LED verde(pin 17) - la Digital 5, iar LED-ul albastru (pin 18 de pe LCD) - la digital 6. Modulul LCD are deja rezistențe, deci nu este nevoie să conectați altele suplimentare.

Acum încărcați schița de mai jos pe Arduino.

// includeți în schița bibliotecii:

#include

#include

#define REDLITE 3

#define GRENLITE 5

#define BLUELITE 6

// declarăm numărul de contacte pe care le folosim

// pentru transferul de date

LiquidCrystal lcd (7, 8, 9, 10, 11, 12);

// luminozitatea poate fi modificată în intervalul 0 -> 255

int luminozitate = 255;

// setați numărul de coloane și rânduri pe LCD:

lcd.begin(16, 2);

// afișează mesajul pe LCD.

lcd.print("Afișaj RGB 16x2");

lcd.setCursor(0,1);

lcd.print(" LCD multicolor ");

pinMode(REDLITE, IEȘIRE);

pinMode(GREENLITE, IEȘIRE);

pinMode(BLUELITE, IEȘIRE);

luminozitate = 100;

pentru (int i = 0; i< 255; i++) {

setBacklight(i, 0, 255-i);

pentru (int i = 0; i< 255; i++) {

setBacklight(255-i, i, 0);

pentru (int i = 0; i< 255; i++) {

setBacklight(0, 255-i, i);

void setBacklight(uint8_t r, uint8_t g, uint8_t b) (

// configurați LED-ul roșu - este mai luminos decât celelalte!

r = harta(r, 0, 255, 0, 100);

g = harta(g, 0, 255, 0, 150);

r = hartă(r, 0, 255, 0, luminozitate);

g = hartă(g, 0, 255, 0, luminozitate);

b = hartă(b, 0, 255, 0, luminozitate);

// anod comun, deci inversează!

r = harta(r, 0, 255, 255, 0);

g = harta(g, 0, 255, 255, 0);

b = harta(b, 0, 255, 255, 0);

Serial.print("R = "); Serial.print(r, DEC);

Serial.print(" G = "); Serial.print(g, DEC);

Serial.print(" B = "); Serial.println(b, DEC);

analogWrite(REDLITE, r);

analogWrite(GREENLITE, g);

analogWrite(BLUELITE, b);

Rezultatul acestei schițe este prezentat în videoclipul de mai jos.

comanda createChar

Probabil că veți dori să utilizați caractere speciale. De exemplu, dacă proiectați un proiect folosind un senzor de temperatură (), simbolul (°) vă va fi util.

Acest lucru poate fi realizat folosind comanda createChar. Alternativ, ați putea găsi un site web grozav care va face toată munca murdară de a crea simboluri noi pentru dvs.!

Lăsați comentariile, întrebările și distribuiți experiență personală de mai jos. Noi idei și proiecte se nasc adesea în discuții!

Cum se conectează o placă Arduino cu un afișaj de caractere? Destul de simplu! Totul este mai jos în ordine și cu detalii.

Dacă doriți să primiți informații de la Arduino fără a vă conecta la un computer și a le trimite la un port serial, puteți utiliza un afișaj de caractere. Nu este atât de greu de făcut. Comoditatea dobândită din comunicare este de neprețuit.
Pentru muncă, am folosit un afișaj LCD cu caractere J204A bazat pe cipul HD44780, adesea găsit pe eBay ca LCD2004. 4 rânduri de 20 de caractere, inversate. Cumpărat cu o grămadă de alții de pe eBay, pentru doar bănuți, de la 60 la 100 de ruble bucata. Limba rusă nu este acceptată implicit, dar aceasta este o problemă care se poate rezolva, mai multe despre asta data viitoare. Și conectorii din diagramă nu sunt lipiți, va trebui să lucrați cu un fier de lipit.
Biblioteca este folosită pentru a lucra cu afișaje LiquidCrystal.h incluse în IDE-ul implicit Arduino.

Dar nu am găsit o foaie de date pentru afișajul LCD2004, dar Internetul este plin de tabele de afișare. Dar practic nu sunt diferite unul de celălalt. Comenzile și conexiunile sunt complet identice. Singura diferență este numărul de linii/caractere de pe afișaj. Dar acest lucru nu va avea absolut niciun efect dacă aveți 1602.

Toate contactele sunt definite în tabel. Dacă iei display-ul și îl întorci spre tine, contactele vor fi localizate de la stânga la dreapta, respectiv, în tabel sunt listate în ordinea numărului crescător. În coloana de contacte, denumirea din fișa de date este indicată în paranteze.

#	Contacte	Pentru ce este folosit?	Nota
1	VSS (VSS)	GND. Pământ. Sursa de alimentare pentru microcontrolerul de afișare.	0V
2	VDD(VCC)	Tensiune de alimentare pentru microcontrolerul de afișare.	+5V
3	V0(VEE)	Contrastul caracterelor de pe afișaj. Este mai bine să vă conectați printr-un potențiometru.	de la 0v la +5V
4	RS (RS)	Înregistrați selecția.
5	RW (R/W)	Comutarea modului de citire/scriere. Să-l tragem la pământ, trebuie doar să transmitem informații pe afișaj.	0-scriere +5V-citire
6	E	Pontaj
7	D0 (DB0)		Date
8	D1 (DB1)	Transfer de date. (Nu o vom folosi)	Date
9	D2 (DB2)	Transfer de date. (Nu o vom folosi)	Date
10	D3 (DB3)	Transfer de date. (Nu o vom folosi)	Date
11	D4 (DB4)		Date
12	D5 (DB5)	Transfer de date. (logodit)	Date
13	D6 (DB6)	Transfer de date. (logodit)	Date
14	D7 (DB7)	Transfer de date. (logodit)	Date
15	A (LED+)	Tensiune +5V, iluminarea ecranului, luminozitatea afișajului pot fi reglate prin potențiometru.	+5V
16	K(LED-)	GND Pământ, iluminare de fundal afișaj	0V

v

Transmiterea datelor pe afișaj este posibilă în două opțiuni: 8 și 4 biți pe ceas. Deoarece Arduino are puține contacte, vom folosi 4 - acest lucru este mai mult decât suficient pentru a actualiza informațiile de pe afișaj la o viteză prohibitivă pentru percepție.

Așa se leagă toată treaba cu mine. Poate părea un haos, dar există un sistem aici. Puteți distinge firele roșii, verzi, galbene și portocalii. Cele roșii merg întotdeauna la +5V, cele verzi la GND, iar cele galbene și portocalii sunt firele pentru conectarea la Arduino, care transportă date.

Cea mai importantă parte este conexiunea fizică a afișajului. Făcând clic, se deschide la rezoluție înaltă, unde totul este clar vizibil.
Rezistor R1 - 200OM. Rezistența limitează curentul care trece prin iluminarea de fundal a afișajului.
R2 - Potențiometru cu rezistență de până la 10kOM. Întoarcem stiloul și selectăm contrastul simbolurilor.

Și o schiță extrem de simplă pentru a afișa câteva linii pe ecran.

H> // Conectăm biblioteca pentru lucrul cu afișajul. /* Comanda LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); Creăm o variabilă de tip LiquidCrystal și determinăm prin ce contacte funcționează Arduino cu afișajul. mai multe detalii despre această comandă aici http://arduino.cc/en/Reference/LiquidCrystalConstructor */ LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() ( lcd.begin(20, 4); // determinați caracteristicile afișajului (20 de caractere pe linie, 4 linii) // Pentru afișajul 1602 trebuie să specificați lcd.begin(16, 2); lcd .setCursor(1, 1) // Specificați din ce poziție să începeți afișarea textului. // 1 va muta deja o diviziune de la începutul ecranului line sub lcd.print("compblog.vlukyanov" ); // imprimă textul începând de la poziția specificată lcd.setCursor(7, 2) de pe ecranul lcd.print(".com). "); // text de imprimat. loop() ( // nu facem nimic altceva în buclă; totul a fost deja făcut în timpul inițializării plăcii. )

Rezultat. Dacă știți cum se conectează totul și cum să scrieți codul, atunci timpul pentru toată munca este de 5 minute.

De asemenea, afișajul poate îndeplini unele funcții în mod independent și este, de asemenea, posibilă setarea unor parametri.

De exemplu:

• Defilare text;
• Poziția cursorului flash;
• Porniți/opriți.

Și acum pentru bonus!
Iluminarea de fundal a afișajului irosește energie pe care, de exemplu, atunci când este alimentată de o baterie, ați dori să o economisiți. Am făcut această opțiune pentru mine - când apăsați butonul, iluminarea de fundal a afișajului se aprinde timp de 5 secunde.

H> // Conectăm biblioteca pentru lucrul cu afișajul. int buttonInt = 0; // Numărul întreruperii care va fi apelată. int screenLed = 4; // Numărul pinului la care este conectat ecranul. +5V volatil lung x = 5000; // variabilă pentru stocarea timpului LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup attach() (Interrupt(buttonInt, screenon, FALLING); // întrerupe parametrii lcd.begin(20, 4); pinMode(screenLed, OUTPUT); digitalWrite(screenLed,HIGH); // pornește afișajul lcd. setCursor(0 , 0); lcd.print("Start screenon test!") // Funcție care va fi executată la apăsarea butonului. void screenon() ( x = millis()+5000; // Amintiți-vă momentul când trebuie să opriți iluminarea de fundal. Timp de funcționare curent +5 secunde. digitalWrite(screenLed,HIGH); // Aplicați tensiune la iluminarea de fundal a afișajului. ) void loop() ( lcd.setCursor(0, 2); // mergeți la a treia linie lcd.print(x); // și afișați ora când afișajul se oprește lcd.setCursor(0, 3); / / mergeți la a patra linie lcd.print( millis()); // imprimați timpul de funcționare curent dacă (x< millis()) // если время работы выключения наступило >(digitalWrite(screenLed,LOW); // apoi opriți afișajul))

Si rezultatul: