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 de afișare, 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; ele 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, sunt folosiți atât biții de ordin inferior, cât și biți de ordine superioară, iar la 4 biți, doar cei de ordin inferioară. Nu are rost să lucrezi cu 8 biți, deoarece se va 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
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
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
După cum puteți vedea, a fost creată o mască de bit la fel ca tabelul. Odată creat, acesta poate fi afișat ca o 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!
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):
. Panou 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 îl au. 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ă alimentarea circuitului, este necesar să se obțină contrastul corect; dacă nu este setat corect, nu va fi afișat nimic pe ecran. Pentru a regla contrastul, jucați 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(); // Dezactivează clipirea cursorului (cursor 5x8) //Ieșire informații 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 de pe afișaj cu un caracter la dreapta lcd.scrollDisplayLeft(); // Deplasați totul de pe afișaj cu un caracter la stânga //Informatii 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 Ecran LCD(); // Când apelați funcția display(), toate informațiile care au fost
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.
Cod simplu:
#include
Creați-vă 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?
Nicio problemă, simbolul necesar poate fi creat manual (până la 7 simboluri în total). Celula din display-urile pe care le luăm în considerare are o rezoluție de 5x8 pixeli. Tot ceea ce se rezumă la sarcina creării unui simbol este să scrieți o mască și să le plasați în ea în locurile în care punctele ar trebui să fie aprinse și zerouri unde nu ar trebui.
În exemplul de mai jos vom desena o față zâmbitoare.
Cod simplu
//Testat pe Arduino IDE 1.0.5#include
Primă
În comentarii, un membru al comunității a trimis un link către generatorul de simboluri
- igorka
generator de caractere ca mai sus,
Am făcut-o pentru că nu eram slab)
Schema de conectare a indicatorului
Schema de conectare a afișajului LCD la MK
Am desenat schema de conectare. Pentru a alimenta afișajul aveți nevoie de o tensiune de 3,3V. Dacă alimentați microcontrolerul de la 5V, atunci instalați divizoare de rezistență și un microcircuit 78L33. Dacă întregul circuit este alimentat de la 3,3 V, nu sunt necesare divizoare de rezistență. Se pare că Atmega8A poate funcționa de la 3.3V cu condiția ca frecvența să nu fie mai mare de 8 MHz. Eu personal nu l-am incercat. Am totul asamblat pe o placă de depanare alimentată la 5V. În niciun caz nu trebuie să puneți un electrolit de mare capacitate în fața afișajului în sine. Chiar la începutul funcționării, controlerul trimite comenzi de inițializare pe afișaj. Este nevoie de timp pentru a încărca condensatorul. În timp ce se încarcă și afișajul începe să funcționeze, va trece ceva timp și nu va primi o comandă de inițializare. Desigur, acestea sunt milisecunde, dar în acest caz efectul este vizibil.
Afișează diagrama pinout
Ecranul Nokia 1202 are o interfață SPI pe 9 biți. Microcontrolerul pe care l-am ales nu are acest lux. Prin urmare, pentru a comunica cu afișajul, nu folosim hardware, ci software SPI, ca să spunem așa, „no-brainer”. Nu vă voi spune cum să creați noi proiecte în CodeVision - gândiți-vă singur. Voi spune doar că toți pinii PORTB trebuie configurați ca ieșire. În setările proiectului trebuie să bifați " Stocați constantele globale în memoria FLASH" Această acțiune este necesară pentru ca matricele de fonturi și imaginile noastre să fie stocate în flash.
Deci, am creat proiectul. Am ales un microcontroler, am setat frecvența ceasului și am configurat proiectul. Ce urmeaza? Și apoi trebuie să adăugați biblioteci pentru a lucra cu bibliotecile de afișare și de întârziere. Despachetați arhiva. Sunt două dosare acolo. Acestea trebuie copiate în anumite foldere. Sper că ați instalat CodeVision direct pe unitatea C:\. Dacă da, atunci copiați fișierele în căile corespunzătoare:
C:\cvavreval\inc pentru fișierul 1100.inc și
C:\cvavreval\lib pentru fișierul 1100.h .
De asemenea, vreau să spun că alocarea pinilor microcontrolerului poate fi modificată în fișier 1100.h. Apoi schema de conectare se va schimba. Să începem să codificăm. Să afișăm doar câteva inscripții pe afișaj cu fontul principal 5*8. La început vom adăuga biblioteci.
#include< 1100.h>// afișează biblioteca
#include
În partea de jos, înainte de bucla principală while(1)(), inițializam afișajul și îl ștergem.
lcd_init(); // afișează inițializarea
lcd_clear(); // șterge afișajul
De asemenea, ne vom plasa inscripția înaintea ciclului principal. Lasă controlerul să afișeze mai întâi mesajul pe afișaj, apoi se rotește în bucla principală. Scriem asta:
print_string("Ieșiți inscripția",5,0);
print_string("Orice vrem",0,1);
print_string("BUCKER",10,2);
Cred că totul este clar aici. Prima cifră este coordonatele x de pe afișaj. Poate lua o valoare de la 0 la 96. Al doilea este un șir. Este de la 0 la 7. În principiu, acolo se potrivesc 8 rânduri și jumătate, dar nu vom citi jumătate de rând. Compilăm și flashăm. Să ne uităm la rezultat. De asemenea, puteți instala Proteus și îl puteți testa. Controlerul poate fi configurat să funcționeze de la un generator intern la o frecvență specificată în proiect cu o întârziere de pornire de 64 ms. Adaug o arhivă cu proiectul compilat. Frecventa 8 MHz.
Dar, așa cum am scris deja la început, există și alte simboluri în bibliotecă. Adevărat, nu există litere, doar cifre. Acum să complicăm puțin sarcina. Inscripția să nu fie inertă, ci să se schimbe. Să presupunem că numără de la 0 la 9 cu un interval de 1 secundă. Când ajunge la 9, se va reseta la zero și va începe din nou. Să luăm numere mari care măsoară 24*32. Ei bine, să începem. Puteți lua proiectul anterior și șterge cele trei linii „print_string” Imediat după adăugarea bibliotecilor, să declarăm o anumită variabilă globală m.
char m = 0;
Puteți scrie pur și simplu:
În acest caz, i se va atribui automat valoarea 0. În bucla principală scriem asta:
char_24_32(m,35,2); //funcția de ieșire simbol 24*32
delay_ms(1000); // așteptați 1 secundă
m++; // adaugă 1 la variabila m
dacă(m>9)m=0; // Condiție. Dacă variabila m este mai mare decât 9, atunci m este egal cu 0.
Am realizat un scurt videoclip cu programul care funcționează
Voi încerca să vă spun cum să desenați imagini și să le afișați pe ecranul de afișare. Cum să creați matrice și funcții pentru a le ieși și cum să inversați o imagine. Bibliotecile au fost împrumutate de pe site-ul cxem.net. Material pregătit Beţiv.
Discutați articolul CONECTAREA UNUI DISPLAY LA UN MICROCONTROLLER
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, creăm un nou proiect, adăugăm o bibliotecă pentru lucrul cu afișajul WH1602, creăm un fișier .c gol și începem să-l umplem cu cod:
| // 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)
- 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 activa 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 Bibliotecă pentru muncă prin protocolul I2C
Acum avem nevoie de o bibliotecă pentru a lucra cu LCD prin interfața I2C. Puteți utiliza, 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:
| Funcţie | Scop |
|---|---|
| Cristal lichid() | creează o variabilă de tip LiquidCrystal și acceptă parametrii de conectare a afișajului (numerele de pin); |
| ÎNCEPE() | inițializarea afișajului LCD, setarea parametrilor (număr de linii și caractere); |
| clar() | ștergerea ecranului și readucerea cursorului la poziția de pornire; |
| Acasă() | readuceți cursorul în poziția de pornire; |
| setCursor() | setarea cursorului într-o poziție dată; |
| scrie() | afișează simbolul pe ecranul LCD; |
| imprimare() | afișează text pe ecranul LCD; |
| cursor() | afișează cursorul, adică sublinierea sub locul următorului caracter; |
| noCursor() | ascunde cursorul; |
| clipi () | cursorul clipește; |
| nu Blink() | Anulează clipirea; |
| noDisplay() | oprirea afișajului în timp ce salvează toate informațiile afișate; |
| afişa() | pornirea afișajului în timp ce salvează toate informațiile afișate; |
| scrollDisplayLeft() | derulați conținutul afișajului 1 poziție spre stânga; |
| scrollDisplayRight() | derulați conținutul afișajului 1 poziție spre dreapta; |
| autoscroll() | activați derularea automată; |
| noAutoscroll() | dezactivați derularea automată; |
| de la stânga la dreapta() | setează direcția textului de la stânga la dreapta; |
| de la dreapta la stanga() | direcția textului de la dreapta la stânga; |
| createChar() | creează un caracter personalizat pentru ecranul 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
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.
5 Creați-vă propriile simboluri pentru display LCD
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: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Convertiți numerele hexazecimale în binare: {00000, 01010, 11111, 11111, 01110, 00100, 00000} . 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ă.
6 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.
7 Ce e în spate 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 (vezi p. 11 a fișei de date, linkul de mai jos) sunt transmise în două nibbles, primul dintre care determină numărul coloanei tabelului, iar al doilea - numărul rândului. În acest caz, datele sunt „blocate” la marginea semnalului de pe linie E(Activare) și linia R.S.(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țiuni 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ță).
