Meniul
AcasăTehnică

Curs de pregatire. Conectarea LCD la microcontroler. Obținerea primelor rezultate. Arduino. Conectarea ecranului LCD

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 inteligent pentru casă, atunci este rezonabil să echipați dispozitivul cu un dispozitiv de ieșire care vă permite să aflați rapid starea actuală 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 sa 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) Permite. O altă ieșire de „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 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. Conectați din nou 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 (A) 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

Arduino IDE vine cu o bibliotecă excelentă pentru afișaje 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țializați afișajul // Listați pinii arduino la care // sunt conectate contactele afișajului 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.

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 pe placa Arduino, ecranul va afișa „hello, world!”( 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 (de 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 fundalstare
20*4 Albastruverificat
20*4 Galbenverificat
16*2 Albastruverificat
16*2 Galbenverificat
16*2 Verdeverificat

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.

    • Sul- 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 simbolul nostru în memoria ecranului // treceți numărul simbolului // și o matrice de octeți care descrie simbolul 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);

Fiecare radioamator, după un anumit număr de proiecte simple de casă, ajunge la scopul de a construi ceva grandios folosind senzori și butoane. La urma urmei, este mult mai interesant să afișați datele pe un afișaj, mai degrabă decât pe un monitor de port. Dar atunci apare întrebarea: ce afișaj să alegi? Și, în general, cum să-l conectați, ce este necesar pentru a vă conecta? Răspunsurile la aceste întrebări vor fi discutate în acest articol.

LCD 1602

Dintre numeroasele opțiuni dintre afișaje, aș dori să menționez în mod special afișajul LCD1602 bazat pe controlerul HD4478. Acest afișaj este disponibil în două culori: litere albe pe fond albastru, litere negre pe fond galben. De asemenea, conectarea LCD 1602 la Arduino nu va cauza probleme, deoarece există o bibliotecă încorporată și nu este nevoie să descărcați nimic suplimentar. Ecranele diferă nu numai prin preț, ci și prin dimensiune. Adesea, radioamatorii folosesc 16 x 2, adică 2 rânduri de 16 caractere. Dar există și 20 x 4, unde sunt 4 rânduri de 20 de caractere. Dimensiunile și culoarea nu joacă niciun rol în conectarea afișajului lcd 1602 la Arduno, acestea sunt conectate în același mod. Unghiul de vizualizare este de 35 de grade, timpul de răspuns al afișajului este de 250 ms. Poate funcționa la temperaturi de la -20 la 70 de grade Celsius. În timpul funcționării, folosește 4 mA pentru ecran și 120 mA pentru iluminarea de fundal.

Unde este folosit?

Acest afișaj este popular nu numai printre amatorii de radio, ci și printre marii producători. De exemplu, imprimantele și aparatele de cafea folosesc și LCD1602. Acest lucru se datorează prețului său scăzut, acest afișaj costă 200-300 de ruble pe site-urile chinezești. Merită să cumpărați acolo, deoarece în magazinele noastre markupurile pentru acest afișaj sunt foarte mari.

Conectarea la Arduino

Conectarea LCD 1602 la Arduino Nano și Uno nu este diferită. Puteți lucra cu afișajul în două moduri: 4 biți și 8. Când lucrați cu 8 biți, se folosesc atât biții de ordin inferior, cât și biți de ordin înalt, iar la 4 biți, doar cei de ordin inferioară. Nu are rost să lucrezi cu 8 biți, deoarece se vor adăuga încă 4 contacte pentru conectare, ceea ce nu este recomandabil, deoarece viteza nu va fi mai mare, limita pentru actualizările afișajului este de 10 ori pe secundă. În general, pentru a conecta lcd-ul 1602 la Arduino, se folosesc o mulțime de fire, ceea ce provoacă unele inconveniente, dar există scuturi speciale, dar mai multe despre asta mai târziu. Fotografia arată conexiunea afișajului la Arduino Uno:

Cod simplu:

#include // Adăugați biblioteca LiquidCrystal necesară lcd(7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) void setup())( lcd.begin(16, 2); // Setați dimensiunea ecranului lcd.setCursor(0, 0); // Setați cursorul la începutul 1 linii lcd.print("Bună, lume!" // Imprimă textul lcd.setCursor(0, 1) // Setează cursorul la începutul liniei 2 lcd.print("site"); ; // Imprimă textul ) bucla nulă ()( )

Ce face codul? Primul pas este să conectați biblioteca pentru a lucra cu afișajul. După cum am menționat mai sus, această bibliotecă este deja inclusă în Arduino IDE și nu trebuie descărcată și instalată suplimentar. În continuare, se determină contactele care sunt conectate la pini: RS, E, DB4, DB5, DB6, respectiv DB7. Apoi dimensiunea ecranului este setată. Deoarece lucrăm cu o versiune cu 16 caractere și 2 rânduri, scriem următoarele valori. Plasăm cursorul la începutul primei rânduri și afișăm primul text Hello World. Apoi, plasați cursorul pe a doua linie și afișați numele site-ului. Asta e tot! Sa luat în considerare conectarea lcd 1602 la Arduino Uno.

Ce este I2C și de ce este necesar?

După cum am menționat mai sus, conectarea afișajului necesită o mulțime de contacte. De exemplu, atunci când lucrați cu mai mulți senzori și un afișaj LCD, 1602 pini pot să nu fie de ajuns. Adesea, radioamatorii folosesc versiunile Uno sau Nano, care nu au multe contacte. Apoi oamenii au venit cu scuturi speciale. De exemplu, I2C. Vă permite să conectați un afișaj cu doar 4 pini. Aceasta este de două ori mai mult. Modulul I2C este vândut atât separat, unde trebuie să îl lipiți singur, cât și deja lipit pe afișajul LCD 1602.

Conexiune folosind modulul I2C

Conectarea LCD 1602 la Arduino Nano cu I2C ocupă puțin spațiu, doar 4 pini: masă, putere și 2 ieșiri de date. Conectăm alimentarea și împământarea la 5V și respectiv GND pe Arduino. Conectăm celelalte două contacte: SCL și SDA la orice pin analogic. În fotografie puteți vedea un exemplu de conectare a unui lcd 1602 la un arduino cu un modul I2C:

Cod program

Dacă pentru a lucra cu un afișaj fără modul a fost necesar să folosiți o singură bibliotecă, atunci pentru a lucra cu un modul aveți nevoie de două biblioteci. Unul dintre ele este deja inclus în Arduino IDE - Wire. O altă bibliotecă, LiquidCrystal I2C, trebuie descărcată separat și instalată. Pentru a instala biblioteca în Arduino, conținutul arhivei descărcate trebuie să fie încărcat în folderul rădăcină Biblioteci. Exemplu de cod de program folosind I2C:

#include #include LiquidCrystal_I2C lcd(0x27,16,2); // Setați afișajul void setup() ( lcd.init(); lcd.backlight(); // Activați iluminarea de fundal a afișajului lcd..setCursor(8, 1); lcd.print("LCD 1602"); ) void loop( ) ( // Setați cursorul pe a doua linie și pe caracterul zero. lcd.setCursor(0, 1); // Afișează numărul de secunde de când a pornit Arduino lcd.print(millis()/1000); )

După cum puteți vedea, codul este aproape același.

Cum să adăugați propriul simbol?

Problema cu aceste afișaje este că nu există suport pentru alfabetul și simbolurile chirilice. De exemplu, trebuie să încărcați un simbol pe afișaj, astfel încât să îl reflecte. Pentru a face acest lucru, afișajul vă permite să creați până la 7 dintre propriile simboluri. Imaginați-vă masa:

0 0 0 1 0
0 0 0 0 1
1 1 0 0 1
0 0 0 0 1
1 1 0 0 1
0 0 0 0 1
0 0 0 1 0
0 0 0 0 0

Dacă 0 - nu există nimic acolo, dacă 1 - aceasta este o zonă pictată. În exemplul de mai sus puteți vedea crearea simbolului „zâmbet zâmbitor”. Folosind un exemplu de program în Arduino, ar arăta astfel:

#include #include // Adăugați biblioteca necesară // Mască de biți a simbolului zâmbet octet zâmbet = ( B00010, B00001, B11001, B00001, B11001, B00001, B00010, ); LiquidCrystal lcd (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) void setup())( lcd.begin(16, 2); // Setați dimensiunea ecranului lcd.createChar(1, smile); // Creați numărul caracterului 1 lcd.setCursor(0, 0); // Setează cursorul la începutul liniei 1 lcd.print("\1" // Imprimă un smiley (numărul caracterului 1) - "\1" ) void loop(); ) ( )

După cum puteți vedea, a fost creată o mască de bit la fel ca tabelul. Odată creat, acesta poate fi afișat ca variabilă pe afișaj. Amintiți-vă că puteți stoca doar 7 caractere în memorie. În principiu, acest lucru este suficient. De exemplu, dacă trebuie să afișați un simbol de grad.

Probleme în care afișajul poate să nu funcționeze

Există momente când afișajul nu funcționează. De exemplu, pornește, dar nu afișează caractere. Sau nu se aprinde deloc. Mai întâi, verificați dacă ați conectat corect pinii. Dacă ați folosit o conexiune LCD 1202 la Arduino fără I2C, este foarte ușor să vă încurcați în fire, ceea ce poate face ca afișajul să nu funcționeze corect. De asemenea, ar trebui să vă asigurați că contrastul afișajului este crescut, deoarece cu contrastul minim nici măcar nu este vizibil dacă LCD 1602 este pornit sau nu. Dacă acest lucru nu ajută, atunci poate că problema poate fi lipirea contactelor, aceasta este atunci când utilizați un modul I2C. Un alt motiv comun pentru care afișajul poate să nu funcționeze este setarea incorectă a adresei I2C. Faptul este că există mulți producători și pot pune o adresă diferită, trebuie să o corectați aici:

LiquidCrystal_I2C lcd(0x27,16,2);

În paranteze puteți vedea două valori, 0x27 și 16.2 (16.2 este dimensiunea afișajului, iar 0x27 este adresa I2C). În loc de aceste valori, puteți încerca să setați 0x37 sau 0x3F. Ei bine, un alt motiv este pur și simplu un LCD 1602 defect. Având în vedere că aproape totul pentru Arduino este fabricat în China, nu poți fi 100% sigur că produsul achiziționat nu este defect.

Avantaje și dezavantaje ale LCD-ului 1602

Să ne uităm la avantajele și dezavantajele afișajului LCD 1602.

  • Preț. Acest modul poate fi achiziționat la un preț foarte accesibil din magazinele chinezești. Prețul este de 200-300 de ruble. Uneori este chiar vândut împreună cu un modul I2C.
  • Ușor de conectat. Probabil că nimeni nu conectează LCD 1602 fără I2C în aceste zile. Și cu acest modul, conexiunea durează doar 4 contacte, nu vor exista „pânze” de fire.
  • Programare. Datorită bibliotecilor gata făcute, lucrul cu acest modul este ușor, toate funcțiile sunt deja scrise. Și dacă trebuie să adăugați propriul simbol, durează doar câteva minute.
  • În timpul utilizării sale de către mii de radioamatori, nu au fost identificate dezavantaje majore, doar că există cazuri de achiziții defecte, deoarece sunt utilizate în principal versiunile chinezești ale afișajelor.

Acest articol a analizat conectarea 1602 la Arduino și a oferit, de asemenea, exemple de programe pentru lucrul cu acest afișaj. Este într-adevăr unul dintre cele mai bune din categoria sa, nu degeaba mii de radioamatori îl aleg pentru proiectele lor!

Instrucțiuni

Funcționarea telemetrului cu ultrasunete HC-SR04 se bazează pe principiul ecolocației. Emite impulsuri sonore în spațiu și primește un semnal reflectat de la un obstacol. Distanța până la obiect este determinată de timpul de propagare a undei sonore la obstacol și înapoi.
Unda sonoră este declanșată prin aplicarea unui impuls pozitiv care durează cel puțin 10 microsecunde la piciorul TRIG al telemetrului. De îndată ce pulsul se termină, telemetrul emite un pachet de impulsuri sonore cu o frecvență de 40 kHz în spațiul din fața lui. În același timp, algoritmul pentru determinarea timpului de întârziere al semnalului reflectat este lansat și o unitate logică apare pe piciorul telemetrului ECHO. De îndată ce senzorul detectează semnalul reflectat, la pinul ECHO apare un zero logic. Durata acestui semnal („Echo Delay” în figură) determină distanța până la obiect.
Intervalul de măsurare a distanței al telemetrului HC-SR04 este de până la 4 metri cu o rezoluție de 0,3 cm. Unghiul de vizualizare este de 30 de grade, unghiul efectiv de 15 grade. Consumul de curent în modul standby este de 2 mA, în timpul funcționării - 15 mA.

Telemetrul cu ultrasunete este alimentat de o tensiune de +5 V. Ceilalți doi pini sunt conectați la orice porturi digitale Arduino pe care le vom conecta la 11 și 12.

Acum să scriem o schiță care determină distanța până la obstacol și o trimite la portul serial. Mai întâi, setăm numerele pinii TRIG și ECHO - aceștia sunt pinii 12 și 11. Apoi declarăm declanșatorul ca ieșire și ecoul ca intrare. Inițializați portul serial la 9600 baud. Fiecare repetare a ciclului buclă() Citim distanța și o trimitem în port.
Funcţie getEchoTiming() generează un impuls de declanșare. Doar creează un curent de 10 microsecunde, un puls, care este un declanșator pentru ca telometrul să înceapă să emită un pachet de sunet în spațiu. În continuare, își amintește timpul de la începutul transmiterii undei sonore până la sosirea ecoului.
Funcţie getDistance() calculează distanța până la obiect. Ne amintim de la cursul de fizică de la școală că distanța este egală cu viteza ori timpul: S = V*t. Viteza sunetului în aer este de 340 m/sec, știm timpul în microsecunde, aceasta este „durație”. Pentru a obține timpul în secunde, împărțiți la 1.000.000. Deoarece sunetul parcurge de două ori distanța - până la obiect și înapoi - trebuie să împărțiți distanța la jumătate. Deci, se dovedește că distanța până la obiect este S = 34000 cm/sec * durata / 1.000.000 sec / 2 = 1,7 cm/sec / 100, ceea ce am scris în schiță. Microcontrolerul efectuează operația de înmulțire mai rapid decât împărțirea, așa că am înlocuit „/ 100” cu echivalentul „* 0.01”.

De asemenea, multe biblioteci au fost scrise pentru a lucra cu telemetru cu ultrasunete. De exemplu, acesta: http://robocraft.ru/files/sensors/Ultrasonic/HC-SR04/ultrasonic-HC-SR04.zip. Biblioteca este instalată standard: descărcați, dezarhivați într-un director biblioteci, care se află în folderul Arduino IDE. După aceasta, biblioteca poate fi folosită.
După ce ați instalat biblioteca, să scriem o nouă schiță. Rezultatul funcționării sale este același - monitorul portului serial afișează distanța până la obiect în centimetri. Dacă scrii într-o schiță float dist_cm = ultrasonic.Ranging(INC);, distanța va fi afișată în inci.

Deci, am conectat telemetrul cu ultrasunete HC-SR04 la Arduino și am primit date de la acesta în două moduri diferite: folosind o bibliotecă specială și fără.
Avantajul utilizării bibliotecii este că cantitatea de cod este redusă semnificativ și lizibilitatea programului este îmbunătățită, nu trebuie să vă aprofundați în complexitățile dispozitivului și îl puteți utiliza imediat. Dar aici se află un dezavantaj: înțelegeți mai rău modul în care funcționează dispozitivul și ce procese au loc în el. În orice caz, ce metodă să folosești depinde de tine.

Această instrucțiune arată cum să vă conectați la Arduino și să utilizați ecrane LCD 16x2 și 20x4.

Aceste ecrane au o iluminare 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. Ecranele 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 despre cum funcționează un 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:

Ecranul grafic cu cristale lichide are o grilă mare de 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 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ă: ecranul LCD din stânga sus este de 20x4 cu text alb pe fundal albastru, partea din dreapta sus este de 16x4 cu text negru pe fundal verde, partea din stânga jos este de 16x2 cu text alb pe fundal albastru și 16x1 cu text negru pe 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 Arduino va trebui să se schimbe puțin, dar conexiunea 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, un potențiometru de 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, fiți extrem de atenți să nu vă deteriorați Breadboard-ul! 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 unul între 5V și pinul 15. Pentru a calcula valorile rezistenței, verificați curentul maxim pentru alimentarea luminii de fundal și valoarea aproximativă a căderii de tensiune din foaia de date. Scădeți valoarea căderii de tensiune de la 5V, apoi împărțiți cu amperajul maxim ș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 aflați care este eroarea!

Conexiune 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ționarea unui 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");

Un afișaj LCD 16x2 va tăia 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 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 un Arduino Uno, ar trebui să aveți trei pini PWM liberi. conectați LED-ul roșu (pin 16 de pe LCD) la Digital 3, LED-ul verde (pin 17) la Digital 5 și LED-ul albastru (pin 18 de pe LCD) la digital 6. Modulul LCD are deja rezistențe, așa că nu este necesar 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 = hartă(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 = hartă(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ă (termocuplu), simbolul (°) 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.!

Lasă-ți comentariile, întrebările și împărtășește-ți experiențele personale 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. Confortul 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? Notă
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 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. (activat) Date
13 D6 (DB6) Transfer de date. (activat) Date
14 D7 (DB7) Transfer de date. (activat) 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ă care este 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:

  • Derulați textul;
  • 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: