Afișaj LCD– un invitat frecvent în proiectele Arduino. Dar în circuitele complexe putem avea problema lipsei de porturi Arduino din cauza necesității de a conecta un scut care are mulți, mulți pini. Soluția în această situație ar putea fi I2C/IIC un adaptor care conectează un scut Arduino 1602 aproape standard la plăcile Uno, Nano sau Mega folosind doar 4 pini. În acest articol vom analiza cum puteți conecta un ecran LCD cu o interfață I2C, ce biblioteci puteți utiliza, vom scrie un scurt exemplu de schiță și vom analiza erorile comune.

Display cu cristale lichide LCD 1602 este o alegere bună pentru ieșirea șirurilor de caractere într-o varietate de proiecte. Este ieftin, există diverse modificări cu diferite culori de iluminare de fundal, puteți descărca cu ușurință biblioteci gata făcute pentru schițe Arduino. Dar principalul dezavantaj al acestui ecran este faptul că display-ul are 16 pini digitali, dintre care sunt necesari cel puțin 6 Prin urmare, utilizarea acestui ecran LCD fără i2c adaugă restricții serioase pentru plăcile Arduino Uno sau Nano. Dacă nu sunt suficiente contacte, atunci va trebui să cumpărați o placă Arduino Mega sau să salvați contacte, inclusiv prin conectarea afișajului prin i2c.

Scurtă descriere a LCD 1602 pini

Să aruncăm o privire mai atentă la pinii LCD1602:

Fiecare dintre pini are propriul său scop:

1. Pământ GND;
2. Alimentare 5 V;
3. Setarea contrastului monitorului;
4. Comanda, date;
5. Scrierea și citirea datelor;
6. Permite;

7-14. linii de date;

1. Plus iluminare de fundal;
2. Minus lumina de fundal.

Specificații afișaj:

• Tip de afișare a caracterelor, este posibilă încărcarea simbolurilor;
• iluminare din spate cu LED;
• Controler HD44780;
• Tensiune de alimentare 5V;
• Format 16x2 caractere;
• Interval de temperatură de funcționare de la -20C la +70C, intervalul de temperatură de depozitare de la -30C la +80C;
• Unghi de vizualizare 180 de grade.

Schema de conectare a LCD-ului la placa Arduino fără i2C

Diagrama standard pentru conectarea unui monitor direct la un microcontroler Arduino fără I2C este următoarea.

Din cauza numărului mare de contacte conectate, este posibil să nu existe suficient spațiu pentru conectarea elementelor necesare. Utilizarea I2C reduce numărul de fire la 4 și pinii ocupați la 2.

De unde să cumpărați ecrane i2c 1602 pentru Arduino

Ecranul LCD 1602 este destul de popular, așa că îl puteți găsi cu ușurință atât în ​​magazinele online interne, cât și pe site-uri străine. Iată câteva link-uri către cele mai disponibile opțiuni:

• O variantă a unui afișaj obișnuit de la un vânzător destul de cunoscut Wavgat la un preț sub 100 de ruble.
• Set de ecran și adaptor i2c (trebuie să-l lipiți singur). Preț - sub 200 de ruble
• Screen shield i2c – modul LCD 1602 cu butoane de control și placă de expansiune.

Descrierea protocolului I2C

Înainte de a discuta despre conectarea afișajului la Arduino printr-un adaptor i2c, să vorbim pe scurt despre protocolul i2C în sine.

I2C/IIC(Inter-Integrated Circuit) este un protocol creat inițial pentru a comunica circuitele integrate într-un dispozitiv electronic. Dezvoltarea aparține Philips. Protocolul i2c se bazează pe utilizarea unei magistrale de 8 biți, care este necesară pentru a comunica blocurile din electronica de control și a unui sistem de adresare, datorită căruia puteți comunica prin aceleași fire cu mai multe dispozitive. Pur și simplu transferăm date pe unul sau altul dispozitiv, adăugând la pachetele de date identificatorul elementului dorit.

Cel mai simplu circuit I2C poate conține un dispozitiv master (cel mai adesea un microcontroler Arduino) și mai mulți slave (de exemplu, un afișaj LCD). Fiecare dispozitiv are o adresă în intervalul de la 7 la 127. Nu ar trebui să existe două dispozitive cu aceeași adresă în același circuit.

Placa Arduino acceptă i2c în hardware. Puteți utiliza pinii A4 și A5 pentru a conecta dispozitive folosind acest protocol.

Există mai multe avantaje pentru funcționarea I2C:

• Funcționarea necesită doar 2 linii - SDA (linie de date) și SCL (linie de sincronizare).
• Conectarea unui număr mare de dispozitive de vârf.
• Timp de dezvoltare redus.
• Este necesar un singur microcontroler pentru a controla întregul set de dispozitive.
• Numărul posibil de microcircuite conectate la o magistrală este limitat doar de capacitatea maximă.
• Grad ridicat de securitate a datelor datorită unui filtru special de suprimare a supratensiunii încorporat în circuite.
• O procedură simplă pentru diagnosticarea defecțiunilor emergente și depanarea rapidă a erorilor.
• Autobuzul este deja integrat în Arduino în sine, deci nu este nevoie să dezvoltați o interfață suplimentară de magistrală.

Defecte:

• Există o limită capacitivă pe linie - 400 pF.
• Este dificil de programat un controler I2C dacă există mai multe dispozitive diferite pe magistrală.
• Cu un număr mare de dispozitive, devine dificil să izolați o defecțiune dacă unul dintre ele scade în mod eronat.

Modul i2c pentru LCD 1602 Arduino

Cel mai rapid și mai convenabil mod de a utiliza un afișaj i2c în Arduino este să achiziționați un ecran gata făcut cu suport de protocol încorporat. Dar nu sunt foarte multe dintre aceste ecrane și nu sunt ieftine. Dar un număr mare de ecrane standard diferite au fost deja produse. Prin urmare, cea mai accesibilă și populară opțiune astăzi este achiziționarea și utilizarea unui modul I2C separat - un adaptor, care arată astfel:

Pe o parte a modulului vedem pini i2c - masă, putere și 2 pentru transferul de date. Pe celălalt adaptor vedem conectori de alimentare externi. Și, firește, placa are multe picioare cu care modulul este lipit la pinii ecranului standard.

Ieșirile i2c sunt folosite pentru a se conecta la placa Arduino. Dacă este necesar, conectăm alimentarea externă pentru iluminare de fundal. Cu trimmer-ul încorporat putem seta valori personalizate de contrast J

Pe piata gasesti module LCD 1602 cu adaptoare deja lipite, utilizarea lor este pe cat posibil simplificata. Dacă ați achiziționat un adaptor separat, va trebui mai întâi să-l lipiți la modul.

Conectarea ecranului LCD la Arduino prin I2C

Pentru a vă conecta, aveți nevoie de placa Arduino în sine, un afișaj, o placă de breadboard, fire de conectare și un potențiometru.

Dacă utilizați un adaptor special i2c separat, trebuie mai întâi să îl lipiți pe modulul ecranului. Este greu să faci o greșeală acolo, poți urma această schemă.

Un monitor LCD cu suport i2c este conectat la placă folosind patru fire - două fire pentru date, două fire pentru alimentare.

• Pinul GND se conectează la GND de pe placă.
• Pinul VCC este la 5V.
• SCL se conectează la pinul A5.
• SDA este conectat la pinul A.

Și asta-i tot! Fără fire de fire, în care se încurcă foarte ușor. În același timp, putem pur și simplu încredința bibliotecilor toată complexitatea implementării protocolului i2C.

Biblioteci pentru lucrul cu afișajul LCD i2c

Pentru a interacționa cu Arduino și LCD 1602 prin magistrala I2C, veți avea nevoie de cel puțin două biblioteci:

• Biblioteca Wire.h pentru lucrul cu I2C este deja inclusă în programul standard Arduino IDE.
• Biblioteca LiquidCrystal_I2C.h, care include o mare varietate de comenzi pentru controlul monitorului prin magistrala I2C și vă permite să faceți schița mai simplă și mai scurtă. Trebuie să instalați suplimentar biblioteca După conectarea afișajului, trebuie să instalați suplimentar biblioteca LiquidCrystal_I2C.h

După conectarea tuturor bibliotecilor necesare la schiță, creăm un obiect și putem folosi toate funcțiile acestuia. Pentru testare, să încărcăm următorul exemplu de schiță standard.

#include #include // Inclusiv biblioteca //#include // Conectarea unei biblioteci alternative LiquidCrystal_I2C lcd(0x27,16,2); // Specificați adresa I2C (cea mai comună valoare), precum și parametrii ecranului (în cazul LCD 1602 - 2 linii a câte 16 caractere fiecare //LiquidCrystal_PCF8574 lcd(0x27); // Opțiune pentru configurarea bibliotecii PCF8574 void( ) ( lcd.init (); // Inițializați afișajul lcd.backlight(); // Conectați iluminarea de fundal lcd.setCursor(0,0); // Setați cursorul la începutul primei linii lcd.print(" Salut"); lcd.setCursor(0,1); // Setați cursorul la începutul celei de-a doua rânduri lcd.print("ArduinoMaster"); // Introduceți text pe a doua linie ) void loop() ( )

Descrierea funcțiilor și metodelor bibliotecii LiquidCrystal_I2C:

• home() și clear() - prima funcție vă permite să întoarceți cursorul la începutul ecranului, a doua face același lucru, dar în același timp șterge tot ce era pe monitor înainte.
• write(ch) – vă permite să imprimați un singur caracter ch pe ecran.
• cursor() și noCursor() – arată/ascunde cursorul pe ecran.
• blink() și noBlink() – cursorul clipește/nu clipește (dacă afișarea sa a fost activată înainte).
• display() și noDisplay() – vă permite să conectați/dezactivați afișajul.
• scrollDisplayLeft() și scrollDisplayRight() – derulează ecranul cu un caracter la stânga/dreapta.
• autoscroll() și noAutoscroll() – vă permite să activați/dezactivați modul de autoscroll. În acest mod, fiecare caracter nou este scris în același loc, înlocuind ceea ce a fost scris anterior pe ecran.
• leftToRight() și rightToLeft() – Setarea direcției textului afișat – de la stânga la dreapta sau de la dreapta la stânga.
• createChar(ch, bitmap) – creează un caracter cu codul ch (0 – 7), folosind o matrice de bitmap pentru a crea puncte alb-negru.

Bibliotecă alternativă pentru lucrul cu afișajul i2c

În unele cazuri, pot apărea erori la utilizarea bibliotecii specificate cu dispozitive echipate cu controlere PCF8574. În acest caz, biblioteca LiquidCrystal_PCF8574.h poate fi sugerată ca alternativă. Se extinde LiquidCrystal_I2C, deci nu ar trebui să existe probleme de utilizare.

Probleme la conectarea ecranului LCD i2c

Dacă după încărcarea schiței nu vedeți niciun mesaj pe afișaj, încercați pașii următori.

În primul rând, puteți crește sau micșora contrastul monitorului. Adesea caracterele pur și simplu nu sunt vizibile din cauza contrastului și a modului de iluminare de fundal.

Dacă acest lucru nu ajută, atunci verificați dacă contactele sunt conectate corect și dacă alimentarea cu iluminare de fundal este conectată. Dacă ați folosit un adaptor i2c separat, verificați din nou calitatea lipirii contactelor.

Un alt motiv comun pentru lipsa textului de pe ecran poate fi o adresă i2c incorectă. Mai întâi încercați să schimbați adresa dispozitivului din schiță de la 0x27 0x20 sau la 0x3F. Diferiți producători pot avea diferite adrese implicite programate. Dacă acest lucru nu ajută, puteți rula schița scanerului i2c, care scanează toate dispozitivele conectate și determină adresa lor folosind forța brută. Un exemplu de schiță de scaner i2c.

Dacă ecranul tot nu funcționează, încercați să dezlipiți adaptorul și să conectați LCD-ul ca de obicei.

Concluzie

În acest articol, ne-am uitat la principalele probleme ale utilizării unui ecran LCD în proiecte complexe Arduino, atunci când trebuie să salvam pinii liberi pe placă. Un adaptor i2c simplu și ieftin vă va permite să conectați un ecran LCD 1602, ocupând doar 2 pini analogici. În multe situații, acest lucru poate fi foarte important. Prețul pentru comoditate este necesitatea de a utiliza un modul suplimentar - un convertor și o bibliotecă. În opinia noastră, acesta nu este un preț mare de plătit pentru comoditate și vă recomandăm cu căldură utilizarea acestei funcții în proiecte.

Ecranele LCD de 1602 dimensiuni, bazate pe controlerul HD44780, sunt unul dintre cele mai simple, mai accesibile și populare afișaje pentru dezvoltarea diferitelor dispozitive electronice. Poate fi găsit atât în ​​aparatele asamblate pe genunchi, cât și în dispozitivele industriale, precum, de exemplu, aparatele de cafea. Cele mai populare module și scuturi cu tematică Arduino, cum ar fi și, sunt colectate pe baza acestui afișaj.

În acest articol vă vom spune cum să îl conectați la Arduino și să afișați informații.

Componente folosite (cumpărare din China):

. Placa de control

. Fire de conectare

Aceste afișaje au două modele: iluminare de fundal galbenă cu litere negre sau, ceea ce este mai frecvent, iluminare de fundal albastră cu litere albe.

Dimensiunea afișajelor de pe controlerul HD44780 poate fi diferită, dar acestea vor fi controlate în același mod. Cele mai comune dimensiuni sunt 16x02 (adică 16 caractere pe două rânduri) sau 20x04. Rezoluția simbolurilor în sine este de 5x8 pixeli.

Majoritatea afișajelor nu acceptă alfabetul chirilic numai afișajele marcate CTK; Dar putem încerca să rezolvăm parțial această problemă (continuare în articol).

Ieșiri afișate:

Display-ul are un conector cu 16 pini pentru conectare. Știfturile sunt marcate pe spatele plăcii.

1 (VSS) - Alimentare controler (-)
2 (VDD) - Alimentare controler (+)
3 (VO) - Pin de control al contrastului
4 (RS) - Selectare înregistrare
5 (R/W) - Citire/Scriere (modul de scriere atunci când este conectat la masă)
6 (E) - Activare (stroboscop în declin)
7-10 (DB0-DB3) - Biți de ordin inferior ai interfeței pe 8 biți
11-14 (DB4-DB7) - Biți de ordin înalt ai interfeței
15 (A) - Sursă de alimentare cu iluminare din fundal anod (+).
16 (K) - Alimentare cu iluminare din spate catod (-).

Modul autotest:

Înainte de a încerca să vă conectați și să afișați informații, ar fi o idee bună să aflați dacă afișajul funcționează sau nu. Pentru a face acest lucru, trebuie să aplicați tensiune controlerului însuși ( VSS și VDD), porniți lumina de fundal ( A și K) și, de asemenea, reglați contrastul.

Pentru a regla contrastul, utilizați un potențiometru de 10 kOhm. Nu contează ce formă va avea. +5V și GND sunt furnizate la picioarele exterioare, piciorul central este conectat la ieșire V.O.

După aplicarea alimentării circuitului, este necesar să se obțină contrastul corect dacă nu este setat corect, atunci nu va fi afișat nimic pe ecran. Pentru a regla contrastul, ar trebui să te joci cu potențiometrul.

Dacă circuitul este asamblat corect și contrastul este reglat corect, linia de sus ar trebui să fie umplută cu dreptunghiuri pe ecran.

Ieșire de informații:

Biblioteca LiquidCrystal.h încorporată în Arduino IDE este utilizată pentru a opera afișajul.

Funcționalitatea bibliotecii

//Lucrează cu cursorul lcd.setCursor(0, 0); // Setați cursorul (numărul celulei, linie) lcd.home(); // Setați cursorul la zero (0, 0) lcd.cursor(); // Activați vizibilitatea cursorului (subliniat) lcd.noCursor(); // Eliminați vizibilitatea cursorului (subliniere) lcd.blink(); // Activați clipirea cursorului (cursor 5x8) lcd.noBlink(); // Opriți clipirea cursorului (cursor 5x8) //Informații de ieșire lcd.print("site-ul"); // Informații de ieșire lcd.clear(); // Ștergeți afișajul, (ștergeți toate datele) setați cursorul la zero lcd.rightToLeft(); // Înregistrarea se face de la dreapta la stânga lcd.leftToRight(); // Scrierea se face de la stânga la dreapta lcd.scrollDisplayRight(); // Deplasați totul pe afișaj cu un caracter la dreapta lcd.scrollDisplayLeft(); // Deplasați totul de pe afișaj cu un caracter la stânga //Informații utile pentru spioni :) lcd.noDisplay(); // Informațiile de pe afișaj devin invizibile, datele nu sunt șterse // dacă, în momentul în care această funcție este activă, nu este afișat nimic, atunci lcd.display(); // La apelarea funcției display(), toate informațiile care au fost restaurate anterior sunt restaurate pe afișaj.

Afișajul în sine poate funcționa în două moduri:

Mod pe 8 biți - pentru aceasta sunt utilizați atât biți scăzuti, cât și biți înalți (BB0-DB7)

Mod pe 4 biți - doar biții mai puțin semnificativi sunt utilizați pentru aceasta (BB4-DB7)

Utilizarea modului pe 8 biți pe acest afișaj nu este recomandată. Funcționarea lui necesită încă 4 picioare și practic nu există câștig de viteză pentru că Rata de reîmprospătare a acestui afișaj este limitată< 10раз в секунду.

Pentru a scoate text, trebuie să conectați pinii RS, E, DB4, DB5, DB6, DB7 la pinii controlerului. Ele pot fi conectate la orice pini Arduino, principalul lucru este să setați secvența corectă în cod.

Exemplu de cod:

//Testat pe Arduino IDE 1.0.5#include // Adăugați biblioteca necesară LiquidCrystal lcd (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) gol înființat()(lcd.begin(16, 2); // Setați dimensiunea ecranului lcd.setCursor(0, 0); // Setați cursorul la începutul unei linii lcd.print("Bună, lume!"); // Afișează text lcd.setCursor (0, 1); // Setați cursorul la începutul liniei 2 lcd.print("site-ul"); // Ieșire text ) void buclă (){ }

Creează-ți propriile simboluri

Am aranjat textul, literele alfabetului englez sunt conectate în memoria controlerului din interiorul afișajului și nu există probleme cu ele. Dar ce să faci dacă simbolul necesar nu este în memoria controlerului?

• Modulul FC-113 se bazează pe cipul PCF8574T, care este un registru de deplasare de 8 biți - un „expander” de intrare-ieșire pentru magistrala serială I2C. În figură, microcircuitul este desemnat DD1.
• R1 este un rezistor de tăiere pentru reglarea contrastului afișajului LCD.
• Jumperul J1 este folosit pentru a porni iluminarea de fundal a afișajului.
• Pinii 1...16 sunt utilizați pentru a conecta modulul la pinii afișajului LCD.
• Padurile de contact A1...A3 sunt necesare pentru a schimba adresa I2C a dispozitivului. Prin lipirea jumperilor corespunzătoare, puteți schimba adresa dispozitivului. Tabelul arată corespondența adreselor și a jumperilor: „0” corespunde unui circuit deschis, „1” unui jumper instalat. În mod implicit, toate cele 3 jumperi sunt deschise și adresa dispozitivului 0x27.

2 Schema de conectare pentru afișajul LCD la Arduino prin protocolul I2C

Modulul este conectat la Arduino într-un mod standard pentru magistrala I2C: pinul SDA al modulului este conectat la portul analogic A4, pinul SCL este conectat la portul analogic A5 al Arduino. Modulul este alimentat de la +5 V de la Arduino. Modulul în sine este conectat prin pinii 1…16 la pinii corespunzători 1…16 de pe afișajul LCD.

3 Biblioteca pentru munca prin protocolul I2C

Acum avem nevoie de o bibliotecă pentru a lucra cu LCD prin interfața I2C. Puteți folosi, de exemplu, acesta (link în linia „Descărcați codul de exemplu și biblioteca”).

Arhiva descărcată LiquidCrystal_I2Cv1-1.rar dezarhivați într-un folder \biblioteci\, care se află în directorul IDE Arduino.

Biblioteca acceptă un set de funcții standard pentru ecranele LCD:

4 Schiță pentru redarea textului la ecranul LCD prin magistrala I2C

Să deschidem proba: Exemple de fișiere LiquidCrystal_I2C CustomCharsși o vom schimba puțin. Vom afișa un mesaj la sfârșitul căruia va apărea un simbol intermitent. Comentariile la cod comentează toate nuanțele schiței.

#include // include biblioteca Wire #include // conectează biblioteca LCD #define printByte(args) write(args); // uint8_t heart = (0x0,0xa,0x1f,0x1f,0xe,0x4,0x0); // mască de biți a simbolului „inima” LiquidCrystal_I2C lcd(0x27, 16, 2); // Setați adresa 0x27 pentru afișajul LCD 16x2 void setup() ( lcd.init(); // inițializarea afișajului LCD lcd.backlight(); // pornește iluminarea de fundal a afișajului lcd.createChar(3, heart); // creează un simbol „inimă” în celula de memorie 3 lcd.home(); // plasează cursorul în colțul din stânga sus, în poziția (0,0) lcd.!"); // imprimă o linie de text lcd.setCursor(0, 1); // mută cursorul pe linia 2, caracter 1 lcd.print( " i "); // imprimă mesajul pe linia 2 lcd.printByte(3) // imprimă simbolul „inima” situat în celula a 3-a lcd.print(" Arduino "); } void loop() (// clipește ultimul caracter lcd.setCursor(13, 1); // muta cursorul pe linia 2, caracterul 1 lcd.print("\t"); }

întârziere (500); lcd.setCursor(13, 1); // muta cursorul pe linia 2, caracterul 1 lcd.print(" ");întârziere (500);

5 Creează-ți propriile simboluri Apropo, caracterele scrise de comanda

lcd.createChar(); , rămân în memoria afișajului chiar și după oprirea alimentării, deoarece scris pe afișarea ROM 1602. pentru display LCD {00000, 01010, 11111, 11111, 01110, 00100, 00000} Să aruncăm o privire mai atentă asupra problemei creării propriilor simboluri pentru ecranele LCD. Fiecare caracter de pe ecran este format din 35 de puncte: 5 lățime și 7 înalte (+1 linie de rezervă pentru subliniere). În rândul 6 din schița de mai sus definim o matrice de 7 numere:

6 (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Să convertim numerele hexazecimale în binare:

. Aceste numere nu sunt altceva decât măști de biți pentru fiecare dintre cele 7 linii ale simbolului, unde „0” indică un punct luminos și „1” un punct întunecat. De exemplu, un simbol de inimă specificat ca o mască de biți va apărea pe ecran, așa cum se arată în figură.

7 Control ecran LCD prin magistrala I2C

Să încărcăm schița pe Arduino. Pe ecran va apărea inscripția pe care am specificat-o cu un cursor care clipește la sfârșit.

Autobuz I2C Ca bonus, să ne uităm la diagrama de timp pentru afișarea caracterelor latine „A”, „B” și „C” pe afișajul LCD. Aceste caractere sunt stocate în ROM-ul afișajului și sunt afișate pe ecran pur și simplu prin transmiterea adreselor lor pe afișaj. Diagrama este preluată de la pinii RS, RW, E, D4, D5, D6 și D7 ai afișajului, adică. deja după convertorul FC-113 „I2C paralel bus”. Putem spune că ne scufundăm puțin mai adânc în hardware. Diagrama de timp a ieșirii caracterelor latine „A”, „B” și „C” pe afișajul LCD 1602 Diagrama arată că caracterele care se află în ROM-ul de afișare (a se vedea pagina 11 a fișei de date, linkul de mai jos) sunt transmise în două nibble-uri, primul dintre care determină numărul coloanei tabelului, iar al doilea - numărul rândului. În acest caz, datele sunt „blocate” la marginea semnalului pe linie(Selectare înregistrare) este într-o stare logică, ceea ce înseamnă că datele sunt transferate. O stare scăzută pe linia RS înseamnă că sunt trimise instrucțiuni, ceea ce vedem înainte ca fiecare caracter să fie transmis. În acest caz, se transmite codul de instrucțiune pentru întoarcerea căruciorului în poziția (0, 0) a afișajului LCD, care poate fi aflat și studiind descrierea tehnică a afișajului.

Și încă un exemplu. Această diagramă de timp arată ieșirea simbolului inimii pe afișajul LCD.

Din nou, primele două impulsuri Permite respectați instrucțiunile Acasă()(0000 0010 2) - readuceți căruciorul în poziția (0; 0), iar al doilea - ieșire pe afișajul LCD stocat în celula de memorie 3 10 (0000 0011 2) simbolul „Inimă” (instrucțiune lcd.createChar(3, inima); schiţa).

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.

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.
R1 - Rezistor 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 risipește energie, pe care, de exemplu, atunci când este alimentată de o baterie, ar 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:

Display cu cristale lichide (LCD) mod. 1602 (fișa de date) este o alegere excelentă pentru proiectele dumneavoastră.

Primul lucru care ne mulțumește este prețul mic. Al doilea este disponibilitatea bibliotecilor gata făcute pentru Arduino. În al treilea rând, există mai multe modificări, care vin și cu diferite lumini de fundal (albastru, verde). În acest articol, ne vom uita la elementele de bază ale conectării acestui afișaj la Arduino și vom oferi un exemplu de proiect mic pentru a afișa nivelul de lumină pe un afișaj folosind un fotorezistor.

Contacte și schema de conectare a LCD 1602 la Arduino

Știfturile de pe acest afișaj sunt numerotate de la 1 la 16. Sunt amplasate pe spatele plăcii. Cum se conectează exact la Arduino este prezentat în tabelul de mai jos.

Masă 1. Conectarea LCD 1620 pini la Arduino

Conectarea 1602 la Arduino Dacă afișajul 1602 este alimentat de la Arduino printr-un cablu USB de 5 volți și pinul corespunzător, o valoare de 2 kOhm poate fi utilizată pentru pinul de contrast al afișajului (al treilea conector - Contrast). Pentru contactul Back LED+, puteți utiliza un rezistor de 100 Ohm. De asemenea, puteți utiliza un rezistor variabil - potențiometru pentru a regla manual contrastul.

Pe baza tabelului 1 și a diagramei de mai jos, conectați afișajul LCD la Arduino. Pentru a vă conecta veți avea nevoie de un set de conductori. Este recomandabil să folosiți fire de culori diferite pentru a evita confuzia.

Masă 2. Culori preferate ale conductorilor

Schema de conectare pentru afișajul LCD 1602 la Arduino:

Exemplu de program de bază pentru lucrul LCD 1602 cu Arduino

Exemplul folosește pinii Arduino 0, 1, 2, 3, 4 și 5 pentru a conecta pinii corespunzători 4, 6, 11, 12, 13 și 14 de pe afișajul 1602 (vezi Tabelul 1). După aceea, în codul Arduino, inițializam lcd() după cum urmează:

LiquidCrystal lcd(0, 1, 2, 3, 4, 5);

Această bucată de cod explică Arduino exact cum este conectat afișajul LCD.

Întregul fișier sursă al proiectului stației meteo, care utilizează afișajul LCD 1602, poate fi descărcat de pe acest link.

LCD 1602A, Arduino și senzor de lumină (fotorezistor)

În exemplu, ne vom uita la conectarea unei modificări de afișare - 1602A și a unui fotorezistor. Ca urmare a acestui proiect, vom putea afișa valori numerice proporționale cu intensitatea luminii de pe afișaj.

Acest exemplu va fi un bun început pentru începătorii să înțeleagă Arduino. Este de remarcat faptul că afișajul 1602 are diverse modificări. În consecință, locația contactelor de pe ele poate diferi ușor.

Materiale necesare

• 1 Arduino UNO;
• 1 panou (63 șine);
• 1 senzor de lumină (fotorezistor);
• 1 potențiometru 50 kOhm;
• 1 display LCD 1602A;
• 1 rezistor 10 kOhm;
• 1 șină de conectori (16 pini);
• 1 cablu USB.

Display LCD 1602A

Display-urile sunt de obicei vândute fără conectori lipiți. Adică va trebui să ții fierul de lipit în mâini. Veți avea nevoie de 16 ace. Lipiți pe partea laterală a picioarelor scurte, lăsați picioarele lungi pentru o conexiune ulterioară la placă sau alte dispozitive periferice.

După dezlipire, puteți instala afișajul pe placa. De preferință, pe calea cea mai de jos, astfel încât să aveți în continuare posibilitatea de a conecta afișajul prin conectori suplimentari la placă.

Conectarea display-ului 1602A la Arduino

Primul lucru pe care trebuie să-l faceți este să porniți afișajul. Conectați cele două cabluri de la +5 volți și împământare la rândurile corespunzătoare plus/minus de pe placa.

Conectați: pinul de 5 volți (5V) de la Arduino la una dintre pistele de la placa.

Conectați: pinul de masă al lui Arduino (GND) la o altă pistă (placă).

După aceasta, conectăm puterea ecranului și iluminarea de fundal a acestuia la pistele de pe placa, pe care obținem 5 volți și minus.

Conectați: pista GND (minus) de pe placa de breadboard la pinul 1 de pe ecranul LCD (etichetat VSS).

Conectați: pista de 5 volți (plus) de pe placa de breadboard la pinul 2 de pe ecranul LCD (etichetat VDD).

Conectați: pista de 5 volți (plus) de pe placa de breadboard la pinul 15 de pe ecranul LCD (etichetat A).

Conectați: pista GND (minus) de pe placa de breadboard la pinul 16 de pe ecranul LCD (etichetat K).

Ne conectăm Arduino la un computer personal printr-un cablu USB și voila! Ecranul ar trebui să se aprindă.

Următorul pas este să conectați un potențiometru pentru a regla contrastul afișajului. Majoritatea ghidurilor folosesc un potențiometru de 10k ohmi, dar și 50k ohmi vor funcționa. Datorită gamei mai mari de valori de rezistență la ieșirea potențiometrului, reglarea mai precisă devine mai dificilă, dar pentru noi, în acest caz, acest lucru nu este critic. Montați potențiometrul pe placa și conectați cei trei pini ai acestuia.

Conectați: primul pin de pe potențiometru la negativul de pe placa.

Conectați: pinul din mijloc al potențiometrului la pinul 3 de pe afișaj (etichetat V0).

Conectați: al treilea pin de pe potențiometru la pozitivul de pe placa.

După ce placa este alimentată prin cablul USB, primul rând al afișajului ar trebui să fie umplut cu dreptunghiuri. Dacă nu le vedeți, rotiți ușor potențiometrul de la stânga la dreapta pentru a regla contrastul. Mai târziu, când vom afișa valori numerice pe ecran, veți putea regla contrastul mai precis. Dacă afișajul tău arată cam așa, ai procedat corect:

Să continuăm. Acum trebuie să comunicăm între Arduino și LCD-ul 1602A pentru a afișa caracterele.

Pentru a face acest lucru, conectați 4 pini ai afișajului (RS) la 7 pini ai Arduino (conector galben). Pinul afișajului 5 (RW) – la rândul de pini de împământare de pe placa de breadboard (cablu negru).

Afișează pinul 6 (E) – la pinul Arduino 8 (PWM).

Afișează pinul 11 ​​(D4) – la pinul Arduino 9 (PWM).

Afișează pinul 12 (D5) – la pinul Arduino 10 (PWM).

Afișează pinul 13 (D6) – la pinul Arduino 11 (PWM).

Afișează pinul 14 (D7) – la pinul Arduino 12 (PWM).

Program pentru Arduino IDE - afișarea textului pe afișajul 1602A

Piesa de cod prezentată mai jos trebuie doar copiată și lipită în Arduino IDE și încărcată pe placă:

#include <LiquidCrystal.h>

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

lcd.begin(16, 2);

lcd.setCursor(0,1);

lcd.write("LUMINĂ: ");

După încărcarea programului pe placă, pe a doua linie a afișajului va apărea următorul mesaj:

Un fel de „bună lume!” lansat pe LCD 1602A. te felicit.

Conectăm fotorezistorul și încărcăm întregul program în Arduino

Acum să conectăm fotorezistorul. Conectați trei fire la șinele libere de pe placa de breadboard (să le numim 1, 2, 3). Lăsați puțin spațiu în șine pentru senzorul de lumină în sine și pentru rezistență.

Conectăm șina GND de la placa de breadboard la șina 1. A0 (intrare analogică) de la Arduino - la șina 2. 5 volți de la placa - la șina 3.

Apoi ne conectăm senzorul și rezistența la șinele pregătite. Ce picioare merg la sol și care merg la sursa de alimentare nu contează pentru senzorul și rezistența noastră de lumină (spre deosebire de, de exemplu, un LED, care are un catod și un anod). Deci nu există confuzie aici.

Conectăm senzorul de lumină la șina 1 și șina 2. Rezistorul este conectat la șina 2 și șina 3.

Acum să ne întoarcem la programul nostru și să adăugăm câteva linii în corpul gol al funcției loop():

int sensorValue = analogRead(A0);

lcd.setCursor(7,1);

lcd.print(sensorValue);

După încărcarea versiunii finale a programului nostru pe Arduino, afișajul va afișa valorile actuale ale nivelului de lumină.