- Materiale necesare
- Modul de afișaj LCD 16X2
- Diagrama circuitului și conexiunile
- Programare ARM7-LPC2148
Afișajul este partea necesară a unei mașini, indiferent dacă este vorba despre orice aparat de uz casnic sau mașini industriale. Afișajul nu numai că afișează opțiunile de control pentru operarea mașinii, ci și starea și ieșirea sarcinii efectuate de mașină. Există mai multe tipuri de display - uri utilizate în domeniul electronicii ca afișaj cu 7 segmente, afișaj LCD, TFT ecran tactil, ecran cu LED - uri etc. 16x2 display LCD este cel mai de bază și de afișare, de asemenea, utilizat în unele mici echipamente electronice, avem multe de făcut de proiecte folosind LCD 16x2, inclusiv interfața de bază cu alte microcontrolere:
- Interfață LCD cu microcontroler 8051
- Interfață LCD cu microcontroler ATmega32
- Interfață LCD cu microcontroler PIC
- Interfață LCD 16x2 cu Arduino
- Interfață LCD 16x2 cu Raspberry Pi folosind Python
În acest tutorial, vom vedea cum să interfațăm un ecran LCD de 16x2 cu microcontrolerul ARM7-LPC2148 și să afișăm un mesaj simplu de bun venit. Dacă sunteți nou cu ARM7, începeți cu elementele de bază ale ARM7 LPC2148 și aflați cum poate fi programat folosind Keil uVision
Materiale necesare
Hardware
- ARM7-LPC2148 Placă de microcontroler
- LCD (16X2)
- Potențiometru
- Regulator de tensiune 5V IC
- Breadboard
- Conectarea firelor
- Baterie de 9V
- Cablu micro USB
Software
- Keil uVision 5
- Instrumentul Flash Magic
Înainte de a intra în proiect, trebuie să știm câteva lucruri despre modurile de operare LCD și despre codurile LCD Hex.
Modul de afișaj LCD 16X2
Un LCD 16X2 spune că are 16 coloane și 2 rânduri. Acest LCD are 16 pini. Mai jos, imaginea și tabelul prezintă numele pinilor afișajului LCD și funcțiile acestuia.
|
NUME |
FUNCŢIE |
|
VSS |
Pinul la sol |
|
VDD |
Pin de intrare + 5V |
|
VEE |
Pinul de reglare a contrastului |
|
RS |
Selectați înregistrare |
|
R / W |
Citire / Scriere Pin |
|
E |
Activați Pin |
|
D0-D7 |
Pini de date (8 pini) |
|
LED A |
Pin anodic (+ 5V) |
|
LED K |
Pin catodic (GND) |
Ecranul LCD poate funcționa în două moduri diferite, și anume modul pe 4 biți și modul pe 8 biți. În modul 4 biți trimitem datele ciugulit cu ciugulit, mai întâi ciugulit superior și apoi ciugulit inferior. Pentru cei dintre voi care nu știu ce este un ciugulit: un ciugulit este un grup de patru biți, astfel încât cei patru biți inferiori (D0-D3) ai unui octet formează ciugulitul inferior în timp ce cei patru biți superiori (D4-D7) a unui octet formează ciugulitul superior. Acest lucru ne permite să trimitem date pe 8 biți.
În timp ce în modul 8 biți putem trimite datele pe 8 biți direct într-o singură linie, deoarece folosim toate cele 8 linii de date.
Aici, în acest proiect, vom folosi cel mai frecvent utilizat mod, care este modul pe 4 biți. În modul pe patru biți putem salva 4 pini de microcontroler și, de asemenea, putem reduce cablurile de suprafață.
16x2 folosește, de asemenea, codul HEX pentru a lua orice comandă, există multe comenzi hexagonale pentru LCD, cum ar fi să mutați cursorul, să selectați modul, să comutați controlul pe a doua linie etc. Pentru a afla mai multe despre modulul de afișare LCD 16X2 și comenzile hexagonale, urmați linkul.
Diagrama circuitului și conexiunile
Tabelul de mai jos prezintă conexiunile de circuit între LCD și ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Selectare înregistrare) |
|
P0.6 |
E (Activare) |
|
P0.12 |
D4 (pinul de date 4) |
|
P0.13 |
D5 (pinul de date 5) |
|
P0.14 |
D6 (pinul 6) |
|
P0.15 |
D7 (pinul de date 7) |
Conexiuni ale regulatorului de tensiune cu stick LCD și ARM7
Tabelul de mai jos prezintă conexiunile dintre ARM7 și LCD cu regulatorul de tensiune.
|
IC regulator de tensiune |
Funcția Pin |
LCD și ARM-7 LPC2148 |
|
1. Pin stânga |
+ Ve de la baterie Intrare 9V |
NC |
|
2. Centrul Pin |
- Vine de la baterie |
VSS, R / W, K de LCD GND din ARM7 |
|
3. Pinul drept |
Ieșire reglementată + 5V |
VDD, un ecran LCD + 5V din ARM7 |
Potențiometru cu LCD
Un potențiometru este utilizat pentru a varia contrastul afișajului LCD. Un pot are trei pini, pinul stâng (1) este conectat la + 5V și centrul (2) la VEE sau V0 al modulului LCD, iar pinul drept (3) este conectat la GND. Putem regla contrastul rotind butonul.
Setări jumper
Un știft jumper este prezent în ARM7-Stick, astfel încât să putem alimenta și încărca cod utilizând USB sau utilizând o intrare de 5V DC numai pentru alimentare. Puteți vedea imaginile de mai jos.
Imaginea de mai jos arată că jumperul este în poziția DC. Asta înseamnă că trebuie să alimentăm placa de la o sursă externă de 5V.
Și această imagine arată că jumperul este conectat în modul USB. Aici puterea și codul sunt furnizate prin portul micro USB.
NOTĂ: Aici, în acest tutorial, am încărcat codul utilizând USB prin setarea jumperului pe USB și apoi am schimbat jumperul în modul DC pentru a alimenta LPC2148 de la intrarea de 5v a regulatorului. Puteți verifica acest lucru în videoclipul dat la final.
Circuitul final pentru interfața LCD 16x2 cu microcontrolerul ARM7 va arăta astfel:
Programare ARM7-LPC2148
Pentru a programa ARM7-LPC2148 avem nevoie de instrumentul keil uVision și Flash Magic. Folosim cablul USB pentru a programa Stick ARM7 prin port micro USB. Scriem cod folosind Keil și creăm un fișier hexagonal și apoi fișierul HEX este afișat pe stick-ul ARM7 folosind Flash Magic. Pentru a afla mai multe despre instalarea keil uVision și Flash Magic și despre modul de utilizare, urmați linkul Noțiuni introductive despre microcontrolerul ARM7 LPC2148 și programați-l folosind Keil uVision.
Codul complet pentru interfața LCD cu ARM 7 este dat la sfârșitul acestui tutorial, aici explicăm câteva părți ale acestuia.
În primul rând trebuie să includem fișierele antet necesare
#include
Inițializarea modulului LCD este un pas foarte important. Aici folosim anumite coduri HEX, care sunt de fapt comenzi, pentru a spune LCD-ului despre modul de funcționare (4 biți), tipul de LCD (16x2), linia de start etc.
void LCD_INITILIZE (void) // Funcție pentru a pregăti ecranul LCD { IO0DIR = 0x0000FFF0; // Setează pinul P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 ca OUTPUT delay_ms (20); LCD_SEND (0x02); // Inițializați lcd în modul de operare pe 4 biți LCD_SEND (0x28); // 2 linii (16X2) LCD_SEND (0x0C); // Afișare pe cursor dezactivat LCD_SEND (0x06); // Cursor auto increment LCD_SEND (0x01); // Afișează LCD_SEND clar (0x80); // Prima linie prima poziție }
Pentru modul 4-Bit avem diferite tipuri de funcții de scriere pentru pini, adică folosind nibble superior și inferior. Să vedem, cum se face
void LCD_SEND (comanda char) // Funcția de a trimite comenzi hexagonale nibble by nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Trimiteți răsucirea superioară a comenzii IO0SET = 0x00000040; // Activarea activării HIGH IO0CLR = 0x00000030; // Realizarea RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // Activare Activare LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comandă & 0x0F) << 12)); // Trimiteți piciorul inferior al comenzii IO0SET = 0x00000040; // ENABLE HIGH IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ENABLE LOW delay_ms (5); }
Logică de trimitere a Nibble
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comandă & 0x0F) << 12)); // Trimiteți piciorul inferior al comenzii IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((comanda & 0xF0) << 8)); // Trimiteți răsucirea superioară a comenzii
Peste două afirmații joacă un rol important în acest program. Prima comandă trimite nibble inferior și a doua trimite nibble superior. Asta fără a afecta celelalte știfturi pe care le facem. Să vedem cum se întâmplă înainte ca noi să aflăm mai întâi despre această logică
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Deci, folosim un concept de mascare și o operație de schimbare logică fără a afecta celelalte pini. Înseamnă doar pinii (P0.12-P0.15) și nu sunt afectați alți pini precum P0.4, P0.6. Se va face prin deplasarea datelor în patru biți și realizarea ciugulitului superior în locul ciugulitului inferior și mascarea ciugulitului superior. Și apoi facem biții inferiori zero (0XF0) și OR cu datele nibble pentru a obține datele nibble superioare la ieșire.
Proces similar este utilizat pentru date mai mici, dar aici nu trebuie să schimbăm datele.
În timp ce scrieți date la ieșire, adică în modul de comandă RS ar trebui să fie LOW și să execute enable trebuie să fie HIGH, iar în modul de date RS să fie HIGH și să execute enable trebuie să fie HIGH.
Acum, pentru a trimite datele șirului care urmează să fie tipărite la ieșire, același principiu este folosit nibble by nibble. Pasul important aici este că REGISTR SELECT (RS) trebuie să fie HIGH pentru modul de date.
void LCD_DISPLAY (char * msg) // Funcția de imprimare a caracterelor trimise unul câte unul { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Trimite nibble superior IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH pentru a imprima date IO0CLR = 0x00000020; // RW LOW Scriere mod întârziere ms (2); IO0CLR = 0x00000040; // EN = 0, RS și RW neschimbate (adică RS = 1, RW = 0) întârziere ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Trimite nibble inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; întârziere ms (2); IO0CLR = 0x00000040; întârziere ms (5); i ++; }
Videoclipul complet de codificare și demonstrație este prezentat mai jos.