Acasă › Sfat › Lucrul cu afișajul grafic 1602 în arduino. LCD WH1602B de la Winstar. Control ecran LCD prin magistrala I2C

Lucrul cu afișajul grafic 1602 în arduino. LCD WH1602B de la Winstar. Control ecran LCD prin magistrala I2C

A ajuns Arduino Nano, a sosit un kit, care conține o placă și un afișaj LCD. Afișajul de pe placă spune - 1602A, mai jos - QAPASS. Am început să sculptez primul dispozitiv și, bineînțeles, am vrut să afișez informații pe afișaj, și nu LED-urile să clipească.

Google a ajutat, mi-a spus că acesta este un afișaj de caractere; Dacă nu o distorsionați, atunci cel mai probabil sunt disponibile caractere ASCII - numere, latină, unele dintre caracterele de bază.

Următoarele materiale au ajutat la lansarea afișajului: Conducerea unui LCD de tip caracter de la un port de imprimantă pentru PC; Cum se conectează Arduino cu un LCD cu caractere; Pwm Servo Driver Control Motor PDF.

Display-ul este destul de comun, iar scuturile au fost deja inventate pentru el - există opțiuni cu SPI, like și/sau cu I2C, iar internetul este plin de rețete pentru aceste cazuri. Dar aveam doar display-ul original 16x2 și Arduino la care voiam să-l atașez.

Afișajul are un mod de funcționare și transmitere a datelor în nibbles, câte 4 biți, în timp ce biții de ordin inferior ai magistralei nu sunt folosiți. Conectarea doar a jumătate din magistrala de date este descrisă în multe locuri și nu mi-am dat seama cum să conectez afișajul și să lucrez cu el pe 8 linii. Sunt destul de mulțumit de modul în care funcționează.

Descriere bună a afișajelor de acest tip L-am găsit aici - http://greathard.ucoz.com/44780_rus.pdf. Și aici (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) este un exemplu de specificare a unui generator de caractere.

Conexiune

Ecranul meu a venit cu contacte nesudate. De la început am vrut să lipim cablul, să tai 16 fire cu duponturi și să le curăț. Și apoi am săpat în balenă și am găsit un pieptene DuPont pentru lipit pe placă. De acolo am rupt 16 contacte și le-am lipit.
Ecranul meu arăta cam așa (înainte de a lipi contactele):

Mai întâi am conectat pinul 15 (A) la +5V, 16 (K) la masă și m-am asigurat că lumina de fundal funcționează. În general, este corect să conectați catodul la masă printr-un rezistor de 220 ohmi, ceea ce am făcut atunci.

Apoi am conectat pământul (1) și puterea (2). Arduino poate fi alimentat de la USB, de la o tensiune stabilizată de 5V și de la un nestabilizat 6-12V, se selectează automat cea mai mare tensiune. Acum Arduino este alimentat de la USB și mă întrebam de unde să iau 5 volți. S-a dovedit că 5V este pe pinul Arduino, unde este conectat 5V stabilizat extern. Sau mai degrabă, s-a dovedit a fi 4,7V, dar asta a fost suficient pentru mine.

După conectarea la alimentare, dacă totul este bine, atunci rândul de sus se aprinde cu dreptunghiuri solide de familiaritate.

Apoi conectăm potențiometrul de contrast (pin 3 V0). Aruncăm unul dintre bornele extreme ale potențiometrului la pământ, al doilea la +5V, cel din mijloc la pinul 3 al afișajului. Se recomandă un potențiometru de 10K. Aveam 50K de la balenă, l-am folosit prima. Ajustarea a fost doar pe o margine; a fost necesar să se prindă foarte subtil contrastul dorit. Apoi am găsit unul similar la 5K într-o altă balenă și l-am instalat. Setarea se întindea de la o margine la o jumătate de tură. Aparent, puteți lua un potențiometru și mai mic. 10K este probabil recomandat pentru ca circuitul să consume mai puțin. Da, a trebuit să fac puțină lipire, am lipit fire cu duponturi la bornele potențiometrelor.

Schiță de testare

Luăm schița de testare din exemplele de la Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", trebuie doar să schimbăm contactele cu ale noastre - LiquidCrystal lcd( 7, 6, 5, 4, 3, 2);

În principiu, această schiță conține și o descriere a ce să se conecteze unde. Îl puteți conecta așa cum este indicat acolo, apoi nu trebuie să schimbați absolut nimic.

// include codul bibliotecii: #include // inițializați biblioteca cu numerele pinilor de interfață LiquidCrystal lcd(7, 6, 5, 4, 3, 2); void setup() ( // setați numărul de coloane și rânduri de pe ecranul LCD: lcd.begin(16, 2); // Imprimați un mesaj pe LCD. lcd.print ("bună ziua, lume!"); ) void loop() ( // setează cursorul pe coloana 0, linia 1 // (notă: linia 1 este al doilea rând, deoarece numărarea începe cu 0): lcd.setCursor(0, 1); // imprimă numărul de secunde de la resetare: lcd.print(millis() / 1000); )

Se dovedește ceva de genul:

Apropo, afișajul care mi-a venit în mâini nu funcționează fără iluminare de fundal. Adică funcționează, dar cu greu poți vedea nimic.

Contacte de afișare 1602A

# a lua legatura	Nume	Cum să te conectezi
1	VSS	GND
2	VDD	+5V
3	V0	Contrast - la borna mijlocie a potențiometrului
4	RS (Selectare înregistrare)	D7 Arduino
5	R/W (citește sau scrie)	GND
6	E (Semnal de activare)	D6 Arduino
7-14	D0-D7	D0-D3 - neconectat; D4-D7 - conectat la pinii D5-D2 ai Arduino
15	A	Anod de iluminare de fundal, conectat la +5V
16	K	Catod de iluminare de fundal, conectat la masă printr-un rezistor de 220 ohmi

Articolul vorbește despre cum să conectați corect un LCD la Arduino, tot ce trebuie să știți despre conectarea LCD 1602 și LCD i2c este acoperit.

Afișajele LCD de 1602 dimensiuni, create pe baza controlerului HD44780, rămân și astăzi unul dintre cele mai accesibile, simple și solicitate pentru dezvoltarea oricărui tip de dispozitive electronice.

Nu este de mirare că pot fi văzute atât în unități simple asamblate literalmente pe genunchi, cât și în cele industriale mai serioase, de exemplu, aparatele de cafea. Cu acest afișaj sunt asamblate cele mai populare module și scuturi legate de Arduino, de exemplu modulul LCD I2C și ecranul tastaturii LCD.

În următorii pași vă vom spune în detaliu cu imagini cum să conectați LCD-ul la Arduino și să afișați informațiile necesare pe afișaj.

Pasul 2. LCD 1602 pentru Arduino

Ecranele 1602 vin în două modele diferite:

lumină de fundal galbenă cu litere negre
sau (asta se întâmplă mult mai des) iluminare de fundal albastră cu cele albe.

Dimensiunea afișajelor de pe controlerul HD44780 variază foarte mult, dar acestea sunt controlate în același mod. Dimensiunile cele mai comune sunt 16 pe 02 (adică 16 caractere pe două rânduri) sau 20 pe 04. Caracterele în sine au o rezoluție de 5 pe 8 pixeli.

Majoritatea ecranelor nu acceptă chirilice (cu excepția afișajelor marcate CTK). Dar această problemă este parțial rezolvabilă, iar articolul descrie în detaliu cum se face acest lucru.

Ecranul are un conector cu 16 pini pentru conectare. Știfturile sunt marcate pe spatele plăcii, este după cum urmează:

1 (VSS) – alimentare negativă pentru controler.
2 (VDD) – alimentare pozitivă pentru controler.
3 (VO) – setări de control al contrastului.
4 (RS) – selectarea registrului.
5 (R/W) – citire și scriere, în special scriere atunci când este conectat la masă.
6 (E) – activare (activare).
7–10 (DB0-DB3) – biți de ordin inferior din interfața pe opt biți.
11–14 (DB4-DB7) – cei mai importanți biți din interfață
15 (A) – anod pozitiv pentru alimentarea cu iluminare de fundal.
16 (K) – catod negativ pentru alimentare cu iluminare din spate.

Pasul 3. Conectați afișajul LCD

Înainte de a conecta afișajul și de a transfera informații la acesta, merită să verificați funcționalitatea acestuia. Mai întâi, aplicați tensiune controlerului VSS și VDD, porniți lumina de fundal (A, K), apoi reglați contrastul.

Pentru astfel de setări, un potențiometru de 10 kOhm este potrivit; forma acestuia nu este importantă. +5V și GND sunt furnizate picioarelor exterioare, iar piciorul din centru este conectat la pinul VO.

Când circuitul este alimentat, trebuie să obțineți contrastul necesar; dacă este reglat incorect, atunci imaginea de pe ecran nu va fi vizibilă. Pentru a regla contrastul, trebuie să vă „jucați” cu potențiometrul. Când circuitul este asamblat corect și contrastul este reglat corect, linia de sus a ecranului ar trebui să fie umplută cu dreptunghiuri.

Pentru ca afișajul să funcționeze, se folosește o bibliotecă specială încorporată în mediul IDE Arduino, LiquidCrystal.h, despre care voi scrie mai jos. Poate funcționa în modul de 8 și 4 biți. În prima opțiune, sunt utilizați doar biții mai puțin semnificativi și cei mai semnificativi ( BB0-DB7), în al doilea – doar cei mai tineri ( BB4-DB7).

Dar folosirea modului pe 8 biți în acest afișaj este o decizie greșită; nu există aproape niciun avantaj de viteză, deoarece rata de reîmprospătare este întotdeauna mai mică de 10 ori pe secundă. Pentru a afișa text, trebuie să conectați pinii DB7, DB6, DB5, DB4, E și RS la pinii controlerului. Ele pot fi conectate la orice pini Arduino, principalul lucru este să setați secvența corectă în cod.

Dacă simbolul necesar nu este încă în memoria controlerului, îl puteți defini manual (până la șapte simboluri în total). Celula din afișajele luate în considerare are o extensie de cinci cu opt pixeli. Sarcina de a crea un simbol este să scrieți o mască de biți și să le plasați în locurile în care punctele ar trebui să fie aprinse și zerouri acolo unde nu ar trebui. Diagrama de conectare discutată mai sus nu este întotdeauna bună, deoarece pe Arduino sunt utilizate cel puțin șase ieșiri digitale.

Pasul 4. Schema de ocolire

Să explorăm o opțiune pentru a ocoli acest lucru și a ne descurcă cu doar două. Avem nevoie de un modul convertor suplimentar pentru LCD la IIC/I2C. Modul în care este lipit de afișaj și conectat la Arduino poate fi văzut în imaginile de mai jos.

Dar această opțiune de conectare funcționează doar cu o bibliotecă specială, LiquidCrystal_I2C1602V1, care, totuși, este ușor de găsit și de instalat pe Internet, după care o poți folosi fără probleme.

Pasul 4: Biblioteca LiquidCrystal.h

Biblioteca LiquidCrystal.h poate fi descărcată din secțiunea Biblioteci a site-ului nostru de pe această pagină sau din resursa oficială arduino.cc. Dar puteți descărca și de la linkurile de mai jos:

Pasul 5. Schiță (codul programului)

După ce ați descărcat arhiva, înlocuiți folderul LiquidCrystal în folderul biblioteci din directorul de instalare Arduino.

Puteți vedea un exemplu de schiță la:

Fișier -> Exemple -> LiquidCrystal -> HelloWorld_SPI

Sau, dacă aveți un meniu în engleză:

Fișier -> Exemple -> LiquidCrystal -> HelloWorld_SPI

Aceasta încheie următoarea noastră lecție. Vă dorim proiecte de calitate!

Ecran 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.

Ecran cu cristale lichide LCD 1602 este buna alegere pentru a scoate șiruri de caractere în diferite 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 minim 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:

Pământ GND;
Alimentare 5 V;
Setarea contrastului monitorului;
Comanda, date;
Scrierea și citirea datelor;
Permite;

7-14. linii de date;

Plus iluminare de fundal;
Minus lumina de fundal.

Specificații afișaj:

Tip de afișare a caracterelor, este posibilă încărcarea simbolurilor;
Lumini cu leduri;
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 LCD și scuturi pentru Arduino

Ecranul LCD 1602 (și versiunea 2004) 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-urile străine. Iată câteva link-uri către cele mai disponibile opțiuni:

Modul LCD1602+I2C cu ecran albastru, compatibil Arduino	Un afișaj LCD1602 simplu (iluminare de fundal verde) mai ieftin de 80 de ruble	Ecran LCD2004 mare cu I2C HD44780 pentru Arduino (iluminare de fundal albastră și verde)
Display 1602 cu adaptor IIC și lumină de fundal albastră	O altă versiune a LCD1602 cu un modul I2C lipit	Modul adaptor Port IIC/I2C/TWI/SPI pentru scut 1602, compatibil cu Arduino
Ecran RGB cu iluminare din spate! LCD 16×2 + tastatură + Buzzer Shield pentru Arduino	Shield pentru Arduino cu butoane și ecran LCD1602 LCD 1602	Afișaj LCD pentru imprimantă 3D (controller inteligent pentru RAMPS 1.4, LCD text 20×4), modul cititor de carduri SD și MicroSD

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 comunicare circuite integrate interior 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 circuit simplu I2C poate conține un dispozitiv master (cel mai adesea un microcontroler Arduino) și mai multe 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, bineînțeles, placa are mulți pini 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. E 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 e 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 standard Programul 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țializarea afișajului lcd.backlight(); // Conectarea iluminării de fundal lcd.setCursor(0,0); // Setarea cursorului la începutul primei linii lcd.print(" Bună ziua"); // Introduceți text pe prima linie 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 ) bucla void() ( )

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 autoscroll. În acest mod, fiecare personaj 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ă. Acesta 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 următorii pași.

Î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, am analizat principalele probleme ale utilizării unui ecran LCD în proiecte complexe Arduino, atunci când trebuie să salvăm 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.

Ce este o parte integrantă a unui număr mare de dispozitive electronice? Desigur, mijloace de indicare și ieșire grafică a datelor. Este întotdeauna mai convenabil și mai plăcut pentru utilizator atunci când rezultatul „cutiei inteligente” poate fi văzut vizual. Prin urmare, astăzi vom conecta un afișaj la STM32 pentru a afișa text și numere. Eroul experimentelor noastre va fi un spectacol destul de popular de la Winstar. Apropo, în comentarii a apărut o clarificare importantă că metodologia este practic aceeași pentru toate afișajele bazate pe HD44780. Mulțumim lui JekaKey pentru adăugarea importantă)

În primul rând, afișajul trebuie să fie conectat la controler. Descărcați fișa de date și căutați pinout-ul WH1602. Uite aici:

După cum știți, afișaj WH1602 are 16 pini. Să ne uităm la fiecare separat...

Pinii Vss, Vdd și K trebuie conectați la masă și la alimentare, adică exact așa cum este indicat în tabel, nu există surprize și nimic de discutat)

Pinul numărul 3 este folosit pentru a regla contrastul - dacă aplicăm +5V acolo, nu vom vedea absolut nimic, iar dacă scurtcircuitam pinul la masă, vom admira două rânduri de pătrate negre 😉 Desigur, acest lucru nu ni se potrivește , deci trebuie să atârnăm acolo un potențiometru (rezistor) cu rezistență variabilă) pentru a regla contrastul. Cea mai bună vizibilitate a caracterelor este oferită de o tensiune de 0,5-0,7 V la acest pin de afișare.

Pinul RS este deja un pin pe care noi înșine îl vom controla folosind un microcontroler. Un nivel scăzut de tensiune (0) pe acest pin înseamnă că va urma acum o comandă, un nivel ridicat (1) înseamnă că acum vor fi date care vor fi scrise în memoria afișajului.

Pin R/W - aici este clar, fie citim datele (afișează steag ocupat, de exemplu), în acest caz există 1 pe acest pin, fie scriem comanda/datele pe afișaj, atunci avem 0 aici.

DB7 – DB0 – magistrală de date și asta spune totul)

Pinul E este așa-numitul semnal de activare. Pentru asta este nevoie de el. Pentru a lucra cu afișajul - înregistrați date sau lansați o comandă - trebuie să emitem un impuls pozitiv acestui pin. Adică, procedura va arăta astfel:

Pe pinii RS, R/W, DB7 - DB0 - semnalele necesare corespunzătoare comenzii noastre.
Furnizăm unul la pinul E.
Zhdems (conform fișei de date – cel puțin 150 ns)
Aplicăm un nivel scăzut (0) pinului E.

Trebuie să puneți 4,2 V pe piciorul A/Vee pentru a alimenta iluminarea de fundal a afișajului.

Acesta este modul în care are loc comunicarea cu afișajul WH1602.

Ne-am dat seama să conectăm WH1602, dar înainte de a trece la exemplu, să ne uităm la ce comenzi înțelege în general afișajul nostru. Pentru a face acest lucru, intrăm în fișa de date și găsim un tabel interesant:

Toate comenzile și semnalele care ar trebui să fie pe pinii corespunzători ai WH1602 pentru fiecare comandă specifică sunt descrise aici. De exemplu, vrem să ștergem afișajul, ne uităm la tabel și iată comanda de care avem nevoie! Afișaj clar!

Aplicăm zerouri la pinii RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 și unul la pinul DB0. Gata! Ce urmează? Așa este, unul pe pinul E, apoi așteptați puțin și coborâți E la zero din nou. Gata, afișajul este șters 😉 Chiar înainte de a executa următoarea comandă trebuie să faceți pauză, indicată în fișa de date pentru fiecare comandă. Ar fi mai eficient să interogați indicatorul de ocupat; de îndată ce acesta este resetat la 0, puteți continua să lucrați. Există, de asemenea, o comandă specială pentru citirea acestui steag, așa că totul este clar cu asta) Să mergem mai departe...

Și, de fapt, totul este cu teoria, deja poți încerca să scrii ceva. Pentru a face lucrul cu afișajul mai ușor, am făcut o mică bibliotecă, acum să vedem cum poate fi folosită. În primul rând, descărcați

Avem la dispoziție 2 fișiere, MT_WH1602.c și MT_WH1602.h. Pe al doilea îl rupem, aici trebuie să selectăm pinii și controlerul folosit.

Apropo, afișajul meu este conectat astfel:

RS-PC2
R/W – PB10
E–PB14
DB7–PD2
DB6–PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5

Deschideți fișierul MT_WH1602.h:

#define PLATFORM (STM32F10x)

Apoi, selectați pinii microcontrolerului la care este conectat afișajul. Mai întâi, să setăm porturile pe care le folosim. Când mă conectez, folosesc GPIOA, GPIOB, GPIOC și GPIOD, scriem:

La fel și pentru alte picioare de microcontroler.

Am terminat cu setarea, să continuăm) Pentru a apela comenzile date la începutul articolului, fișierul MT_WH1602.c conține următoarele funcții (sunt denumite după numele comenzilor, deci cred că totul este clar) :

void MT_WH1602_ClearDisplay(void ); void MT_WH1602_ReturnHome(void ); void MT_WH1602_EntryModeSet (bool IDaddress, bool shift) ; void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; void MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit) ; void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit); void MT_WH1602_SetCGRAMAddress (adresă uint8_t) ; void MT_WH1602_SetDDRAMAddress (adresă uint8_t); bool MT_WH1602_ReadBusy(void); void MT_WH1602_WriteData(uint8_t data) ;

Pentru unele comenzi trebuie să transmitem parametrii funcției, de exemplu:

void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ;

Să ne uităm la tabelul de comenzi:

Vedem că comanda Display ON/OFF nu numai că pornește/oprește afișajul, dar activează/dezactivează și clipirea cursorului și a cursorului. În fișa de date, acești biți de comandă sunt desemnați ca D, C și B și îi pasăm ca parametri funcției. Dacă trebuie să pornim afișajul și cursorul, dar dezactivăm clipirea cursorului, apelăm comanda după cum urmează:

MT_WH1602_DisplayOnOff(1, 1, 0);

În general, totul este simplu 😉

Pe scurt, noi creăm proiect nou, adăugați o bibliotecă pentru a lucra cu afișajul WH1602, creați un fișier .c gol și începeți să îl completați cu codul:

// Includeți fișierul bibliotecii#include „MT_WH1602.h” /*******************************************************************/ int main(void) ( // Apelați funcția de inițializare, nu ne putem lipsi de ea =)() ; // Acum trebuie să facem configurația inițială a afișajului // Documentația și Internetul recomandă să faceți acest lucru ;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000 ) ; MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_ClearDisplay() ; MT_WH1602_Delay(2000) ; // De exemplu, am luat primele valori de întârziere care mi-au venit în minte) // În general, trebuie să verificați indicatorul de ocupat afișat // Să afișăm acum ceva, cum ar fi numele site-ului nostru MT_WH1602_WriteData(0x6D) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6F) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x74) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x65) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x68) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x73) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x2E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x75) ; MT_WH1602_Delay(100) ; în timp ce (1) ( __NOP() ; ) ) /*******************************************************************/

Gata, hai sa verificam)

După cum puteți vedea, totul funcționează corect)

Apropo, am pierdut cumva din vedere întrebarea ce să scriu pe afișaj pentru a afișa cutare sau cutare caracter. Iată placa din fișa tehnică:

Deci, pentru a determina ce valoare să scrieți în memoria afișajului, trebuie să luați numerele scrise în partea de sus și în stânga în acest tabel pentru un anumit simbol. De exemplu, simbolul „A”. Să vedem - acest simbol corespunde coloanei 0100 (0x4) și liniei 0001 (0x1). Se pare că pentru a afișa simbolul „A” trebuie să scrieți valoarea 0x41 pe afișaj.

Asta este acum =) Am rezolvat conexiunea și funcționarea afișajului WH1602, așa că ne vedem în curând!

P.S. Când lucram cu biblioteca, nu am testat funcția de citire a steagului ocupat, așa că, dacă dintr-o dată ceva nu funcționează așa cum ar trebui, scrieți, ne vom da seama)

Uneori ne confruntăm cu problema de a scoate diverse informații de la Arduino către lumea exterioară. Adesea, utilizarea unui port serial este imposibilă, incomodă și neprofitabilă.

Un afișaj de caractere este unul dintre cele mai simple și mai ieftine mijloace de afișare a informațiilor, deoarece are propriul microcontroler care stochează caracterele codificate. Acest sistem simplifică utilizarea acestor afișaje, dar în același timp limitează utilizarea lor doar la ieșire informații text, spre deosebire de afișajele grafice.

În exemplu, ne vom uita la afișajul Winstar wh1602l1, unul dintre cele mai comune afișaje de pe controlerul hd44780. În plus, puteți conecta LCD 2004 și altele similare.
Primele două cifre indică numărul de caractere pe linie, iar a doua numărul de rânduri, astfel încât afișajul selectat are 2 rânduri de 16 caractere.
Această metodă de conectare presupune ocuparea a cel puțin 6 porturi ale microcontrolerului Arduino. Dacă este necesar, puteți conecta afișajul de text 1602 prin interfața I2C (2 porturi).

Dintre elementele suplimentare de care avem nevoie rezistor variabil, pentru a controla contrastul. În caz contrar, totul este conectat conform diagramei, conform fișei de date și a ieșirilor Arduino selectate în program.

Pinii 15 și 16 de pe afișaj sunt responsabili pentru iluminarea de fundal; aceasta poate fi oprită sau luminozitatea poate fi ajustată automat atunci când conectați un fotorezistor la Arduino ca senzor de luminozitate.

În exemplul nostru, vom citi datele de pe portul serial și le vom afișa pe afișaj:

#include // Conectați biblioteca pentru lucrul cu afișajele de caractere LiquidCrystal lcd(13, 11, 5, 4, 3, 2); // (RS, E, D4, D5, D6, D7) conectați ieșirile afișajului conform secvenței, R/W – GND, deoarece vom scrie date pe afișaj și nu vom citi void setup() ( lcd.begin( 16, 2); // Inițializați LCD 1602 // lcd.begin(20, 4); // Inițializați LCD 2004 Serial.begin(9600); // Porniți portul serial ) void loop() ( dacă (Serial.available) ()) // Dacă datele provin de la port, atunci... ( delay(100); lcd.clear(); // Şterge complet ecranul în timp ce (Serial.available() > 0) // Dacă datele provin de la portul mai mare de 0, apoi ... ( lcd.write(Serial.read()); // Citiți valorile de pe portul serial și afișați-le pe afișaj ) ) )

Puteți complica codul și puteți scoate ceasul în timp real DS1307 pe Arduino pe LCD1602.

Acum să aruncăm o privire mai atentă la toate funcțiile din bibliotecă Cristal lichid:

Primul și cel mai important lucru este că folosind această bibliotecă nu puteți afișa litere rusești, chiar dacă afișajul are aceste caractere în memorie. Această problemă poate fi rezolvată fie prin alte biblioteci, fie prin scrierea valorilor folosind cod hexazecimal.

lcd.print();- cel mai simplu și cel mai des folosit, folosit pentru afișarea informațiilor.

lcd. clar(); - folosit pentru curățarea afișajului.

lcd.setCursor(X, y); - plasează cursorul într-un anumit loc.

X – schimbarea poziţiei în linie

Y – schimbare de linie

De exemplu, lcd.setCursor(0, 0); aceasta este celula din stânga sus.

lcd.home(); - plasează cursorul în pozițiile 0, 0

lcd.home(); = lcd.setCursor(0, 0);

lcd. scrollDisplayLeft(); - schimbă la stânga

lcd. scrollDisplayRight(); - schimba la dreapta

Lcd.createChar(Nume, matrice); - crearea propriului semn.

De exemplu, semnul gradului arată astfel: