- Materials necessaris
- Mòdul de pantalla LCD 16X2
- Diagrama de circuits i connexions
- Programació ARM7-LPC2148
La pantalla és la part necessària d’una màquina, tant si es tracta d’aparells domèstics com de màquines industrials. La pantalla no només mostra les opcions de control per fer funcionar la màquina, sinó que també mostra l'estat i la sortida de la tasca realitzada per aquesta màquina. Hi ha molts tipus de pantalles utilitzades a l’electrònica, com ara pantalles de 7 segments, pantalla LCD, pantalla tàctil TFT, pantalla LED, etc. La pantalla LCD de 16x2 és la més bàsica i també s’utilitza en alguns equips electrònics petits. projectes que utilitzen LCD de 16x2 incloent la interfície bàsica amb altres microcontroladors:
- Interfície LCD amb microcontrolador 8051
- Interfície LCD amb microcontrolador ATmega32
- Interfície LCD amb microcontrolador PIC
- Interfície LCD 16x2 amb Arduino
- Interfície LCD de 16x2 amb Raspberry Pi mitjançant Python
En aquest tutorial, veurem com connectar una pantalla LCD de 16x2 amb un microcontrolador ARM7-LPC2148 i mostrar un simple missatge de benvinguda. Si sou nou amb ARM7, comenceu amb els conceptes bàsics d’ARM7 LPC2148 i apreneu com es pot programar mitjançant Keil uVision
Materials necessaris
Maquinari
- Placa de microcontroladors ARM7-LPC2148
- Pantalla LCD (16X2)
- Potenciòmetre
- Regulador de tensió 5V IC
- Taula de pa
- Connexió de cables
- Bateria de 9V
- Cable micro USB
Programari
- Keil uVision 5
- Eina Magic Flash
Abans d’entrar al projecte, hem de saber poques coses sobre els modes de funcionament de la pantalla LCD i sobre els codis hexadecimals de la pantalla LCD.
Mòdul de pantalla LCD 16X2
Una pantalla LCD de 16X2 diu que té 16 columnes i 2 files. Aquesta pantalla LCD té 16 pins. A sota de la imatge i la taula es mostren els noms dels pins de la pantalla LCD i les seves funcions.
|
NOM |
FUNCIÓ |
|
VSS |
Pin de terra |
|
VDD |
Pin d'entrada + 5V |
|
VEE |
Pin d'ajust del contrast |
|
RS |
Selecciona el registre |
|
R / N |
Pin de lectura / escriptura |
|
E |
Activa Pin |
|
D0-D7 |
Pins de dades (8 pins) |
|
LED A |
Pin d'ànode (+ 5V) |
|
LED K |
Pin de càtode (GND) |
La pantalla LCD pot funcionar en dos modes diferents, és a dir, el mode de 4 bits i el mode de 8 bits. En el mode de 4 bits enviem les dades nibble per nibble, primer nibble superior i després nibble inferior. Per a aquells que no sabeu què és un rosegador: un rosegador és un grup de quatre bits, de manera que els quatre bits inferiors (D0-D3) d’un byte formen el rosegador inferior mentre que els quatre bits superiors (D4-D7) d'un byte formen el picat superior. Això ens permet enviar dades de 8 bits.
Mentre que en el mode de 8 bits podem enviar les dades de 8 bits directament en un sol cop, ja que fem servir totes les línies de dades de 8.
Aquí en aquest projecte utilitzarem el mode més utilitzat, que és el mode de 4 bits. En el mode de quatre bits podem estalviar 4 pins de microcontrolador i també reduir la sobrecàrrega del cablejat.
El 16x2 també utilitza el codi HEX per prendre qualsevol ordre, hi ha moltes ordres hexadecimals per a la pantalla LCD, com per moure el cursor, seleccionar el mode, canviar el control a la segona línia, etc..
Diagrama de circuits i connexions
A la taula següent es mostren les connexions de circuits entre LCD i ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Selecciona registre) |
|
P0.6 |
E (Activa) |
|
P0.12 |
D4 (pin de dades 4) |
|
P0.13 |
D5 (pin de dades 5) |
|
P0.14 |
D6 (pin de dades 6) |
|
P0.15 |
D7 (pin de dades 7) |
Connexions del regulador de voltatge amb LCD i pal ARM7
A la taula següent es mostren les connexions entre ARM7 i LCD amb regulador de voltatge.
|
CI de regulador de tensió |
Funció Pin |
LCD i ARM-7 LPC2148 |
|
1. Pin esquerre |
+ Ve de la bateria d'entrada de 9V |
NC |
|
2. Pin del centre |
- Ve de la bateria |
VSS, R / W, K de pantalla LCD GND de ARM7 |
|
3. Pin dret |
Sortida regulada + 5V |
VDD, A de pantalla LCD + 5 V d'ARM7 |
Potenciòmetre amb pantalla LCD
Es fa servir un potenciòmetre per variar el contrast de la pantalla LCD. Un pot té tres pins, el pin esquerre (1) està connectat a + 5V i el centre (2) a VEE o V0 del mòdul LCD i el pin dret (3) està connectat a GND. Podem ajustar el contrast girant el pom.
Configuració del pont
A ARM7-Stick hi ha un passador per poder alimentar i carregar codi mitjançant USB o mitjançant una entrada de 5 V CC només per alimentar-lo. Podeu veure les imatges següents.
La imatge següent mostra que el pont està en posició de CC. Això vol dir que hem d’alimentar la placa des d’un subministrament extern de 5V.
I aquesta imatge mostra que el pont està connectat en mode USB. Aquí l'alimentació i el codi es proporcionen a través del port micro USB.
NOTA: Aquí, en aquest tutorial, hem carregat codi mitjançant USB configurant el pont a USB i, a continuació, hem canviat el pont a mode CC per alimentar LPC2148 des de l’entrada de 5 V del regulador. Podeu comprovar-ho al vídeo que es dóna al final.
El circuit final per a la interfície de LCD 16x2 amb el microcontrolador ARM7 serà així:
Programació ARM7-LPC2148
Per programar ARM7-LPC2148 necessitem l'eina keil uVision i Flash Magic. Estem utilitzant un cable USB per programar ARM7 Stick mitjançant un port micro USB. Escrivim codi amb Keil i creem un fitxer hexadecimal i, a continuació, el fitxer HEX es converteix en un pal ARM7 mitjançant Flash Magic. Per obtenir més informació sobre com instal·lar keil uVision i Flash Magic i com utilitzar-los, seguiu l’enllaç Introducció al microcontrolador ARM7 LPC2148 i programeu-lo mitjançant Keil uVision.
El codi complet per a la interfície de la pantalla LCD amb ARM 7 es dóna al final d’aquest tutorial, aquí en detallem algunes parts.
Primer de tot, hem d’incloure els fitxers de capçalera necessaris
#incloure
La inicialització del mòdul LCD és un pas molt important. Aquí fem servir determinats codis HEX, que en realitat són ordres, per informar a la pantalla LCD del mode de funcionament (4 bits), el tipus de pantalla LCD (16x2), la línia d’inici, etc.
void LCD_INITILIZE (void) // Funció per preparar la pantalla LCD { IO0DIR = 0x0000FFF0; // Estableix el pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 com a OUTPUT delay_ms (20); LCD_SEND (0x02); // Inicialitzar lcd en mode de funcionament de 4 bits LCD_SEND (0x28); // 2 línies (16X2) LCD_SEND (0x0C); // Mostra el cursor desactivat LCD_SEND (0x06); // Cursor d'increment automàtic LCD_SEND (0x01); // Mostra LCD_SEND clar (0x80); // Primera línia primera posició }
Per al mode de 4 bits, tenim diferents tipus de funcions d'escriptura per als pins, és a dir, mitjançant l'ús de pinzell superior i inferior. A veure, com es fa
void LCD_SEND (ordre char) // Funció per enviar ordres hexagonals nibble by nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Envia un pic de comandament superior IO0SET = 0x00000040; // Activar HO HIGH IO0CLR = 0x00000030; // Fer RS & RW BAIX delay_ms (5); IO0CLR = 0x00000040; // Activar LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((ordre & 0x0F) << 12)); // Envia un pic de comandament inferior IO0SET = 0x00000040; // ACTIVA ALTA IO0CLR = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ACTIVA BAIX delay_ms (5); }
Lògica d'enviament de picades
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((ordre & 0x0F) << 12)); // Envia una picada inferior de l'ordre IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((ordre & 0xF0) << 8)); // Envia un pic de comandament superior
Més de dues afirmacions tenen un paper important en aquest programa. La primera ordre envia el picat inferior i el segon envia el picet superior. Això sense afectar els altres pins que fem. Vegem com està passant abans de conèixer aquesta lògica primer
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Per tant, fem servir un concepte d’emmascarament i una operació de desplaçament lògic sense afectar els altres pins. Significa que només s’utilitzen els pins (P0.12-P0.15) i que no es veuen afectats altres pins com P0.4 i P0.6. Es farà desplaçant les dades en quatre bits i fent que el picat superior es posi al lloc del picat inferior i emmascara el picat superior. I després fem que els bits inferiors siguin zero (0XF0) i OR amb les dades de picat per obtenir les dades de picat superior a la sortida.
S'utilitza un procés similar per a dades de picades inferiors, però aquí no hem de canviar les dades.
Mentre escriviu dades a la sortida, és a dir, en mode d’ordres RS ha de ser BAIX i l’execució de l’habilitació ha de ser ALTA, i en mode de dades RS ha de ser ALTA i l’execució de l’habilitació ha de ser ALTA.
Ara per enviar les dades de cadena que s’imprimiran a la sortida, s’utilitza el mateix principi nibble by nibble. El pas important aquí és que REGISTR SELECT (RS) ha de ser ALTA per al mode de dades.
void LCD_DISPLAY (char * msg) // Funció per imprimir els caràcters enviats un per un { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Envia mordassa superior IO0SET = 0x00000050; // RS HIGH & ACTIVE HIGH per imprimir dades IO0CLR = 0x00000020; // RW LOW Mode d'escriptura retard ms (2); IO0CLR = 0x00000040; // EN = 0, RS i RW sense canvis (és a dir, RS = 1, RW = 0) retard ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Envia un picet inferior IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; retard ms (2); IO0CLR = 0x00000040; retard ms (5); i ++; }
A continuació es mostra un vídeo complet de codificació i demostració.