- Materiali richiesti
- Modulo display LCD 16X2
- Schema elettrico e collegamenti
- Programmazione ARM7-LPC2148
Il display è la parte necessaria di una macchina, sia che si tratti di un elettrodomestico o di una macchina industriale. Il display non solo mostra le opzioni di controllo per azionare la macchina, ma mostra anche lo stato e l'output dell'attività eseguita da quella macchina. Esistono molti tipi di display utilizzati nell'elettronica come display a 7 segmenti, display LCD, display touch screen TFT, display a LED, ecc. Il display LCD 16x2 è il più semplice e viene utilizzato anche in alcune piccole apparecchiature elettroniche, abbiamo fatto molto progetti che utilizzano LCD 16x2 inclusa l'interfaccia di base con altri microcontrollori:
- Interfacciamento LCD con microcontrollore 8051
- Interfacciamento LCD con il microcontrollore ATmega32
- Interfacciamento LCD con microcontrollore PIC
- Interfacciamento LCD 16x2 con Arduino
- Interfaccia LCD 16x2 con Raspberry Pi utilizzando Python
In questo tutorial vedremo come interfacciare un LCD 16x2 con il microcontrollore ARM7-LPC2148 e visualizzare un semplice messaggio di benvenuto. Se sei nuovo con ARM7, inizia con le basi di ARM7 LPC2148 e scopri come può essere programmato usando Keil uVision
Materiali richiesti
Hardware
- Scheda microcontrollore ARM7-LPC2148
- LCD (16X2)
- Potenziometro
- Regolatore di tensione 5V IC
- Breadboard
- Collegamento dei cavi
- Batteria da 9V
- Cavo micro USB
Software
- Keil uVision 5
- Strumento Flash magico
Prima di entrare nel progetto dobbiamo sapere alcune cose sulle modalità di funzionamento LCD e sui codici LCD Hex.
Modulo display LCD 16X2
Un LCD 16X2 dice che ha 16 colonne e 2 righe. Questo LCD ha 16 pin. L'immagine e la tabella seguenti mostrano i nomi dei pin del display LCD e le sue funzioni.
|
NOME |
FUNZIONE |
|
VSS |
Pin di terra |
|
VDD |
Pin di ingresso + 5V |
|
VEE |
Perno di regolazione del contrasto |
|
RS |
Registrati Seleziona |
|
R / W |
Lettura / scrittura Pin |
|
E |
Abilita Pin |
|
D0-D7 |
Pin dati (8 pin) |
|
LED A |
Pin anodo (+ 5V) |
|
LED K |
Pin del catodo (GND) |
Il display LCD può funzionare in due diverse modalità, vale a dire la modalità a 4 bit e la modalità a 8 bit. In modalità 4 bit inviamo i dati nibble per nibble, prima nibble superiore e poi nibble inferiore. Per quelli di voi che non sanno cosa sia un bocconcino: un bocconcino è un gruppo di quattro bit, quindi i quattro bit inferiori (D0-D3) di un byte formano il bocconcino inferiore mentre i quattro bit superiori (D4-D7) di un byte formano il bocconcino più alto. Questo ci consente di inviare dati a 8 bit.
Mentre in modalità 8 bit possiamo inviare i dati a 8 bit direttamente in un colpo poiché utilizziamo tutte le 8 linee di dati.
Qui in questo progetto useremo la modalità più comunemente usata che è la modalità a 4 bit. In modalità a quattro bit possiamo salvare 4 pin del microcontrollore e anche ridurre il sovraccarico di cablaggio.
16x2 utilizza anche il codice HEX per prendere qualsiasi comando, ci sono molti comandi esadecimali per LCD come spostare il cursore, selezionare la modalità, spostare il controllo sulla seconda riga ecc. Per saperne di più sul modulo display LCD 16X2 e sui comandi esadecimali, segui il link.
Schema elettrico e collegamenti
La tabella seguente mostra le connessioni del circuito tra LCD e ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (selezione registro) |
|
P0.6 |
E (Abilita) |
|
P0.12 |
D4 (Data pin 4) |
|
P0.13 |
D5 (Data pin 5) |
|
P0.14 |
D6 (Data pin 6) |
|
P0.15 |
D7 (Data pin 7) |
Collegamenti del regolatore di tensione con LCD e stick ARM7
La tabella sottostante mostra i collegamenti tra ARM7 e LCD con regolatore di tensione.
|
Regolatore di tensione IC |
Funzione pin |
LCD e ARM-7 LPC2148 |
|
1. Perno sinistro |
+ Ve da batteria 9V Input |
NC |
|
2.Pin centrale |
- Ve da batteria |
VSS, R / W, K di LCD GND di ARM7 |
|
3.Pin destro |
Uscita + 5V regolata |
VDD, A di LCD + 5V di ARM7 |
Potenziometro con LCD
Un potenziometro viene utilizzato per variare il contrasto del display LCD. Un pot ha tre pin, il pin sinistro (1) è collegato a + 5V e il centro (2) a VEE o V0 del modulo LCD e il pin destro (3) è collegato a GND. Possiamo regolare il contrasto ruotando la manopola.
Impostazioni dei ponticelli
Un pin jumper è presente in ARM7-Stick in modo che possiamo alimentare e caricare il codice utilizzando USB o utilizzando un ingresso 5 V CC solo per l'alimentazione. Puoi vedere le immagini qui sotto.
L'immagine sotto mostra che il jumper è in posizione DC. Ciò significa che dobbiamo alimentare la scheda da un'alimentazione 5V esterna.
E questa immagine mostra che il ponticello è collegato in modalità USB. Qui l'alimentazione e il codice vengono forniti tramite la porta micro USB.
NOTA: qui in questo tutorial abbiamo caricato il codice utilizzando USB impostando il jumper su USB e quindi cambiato il jumper in modalità DC per alimentare LPC2148 dall'ingresso 5v del regolatore. Puoi dare un'occhiata a questo nel video fornito alla fine.
Il circuito finale per l' interfacciamento di LCD 16x2 con il microcontrollore ARM7 sarà simile a questo:
Programmazione ARM7-LPC2148
Per programmare ARM7-LPC2148 abbiamo bisogno dello strumento keil uVision e Flash Magic. Stiamo utilizzando il cavo USB per programmare ARM7 Stick tramite la porta micro USB. Scriviamo il codice usando Keil e creiamo un file esadecimale, quindi il file HEX viene aggiornato su ARM7 stick usando Flash Magic. Per saperne di più sull'installazione di keil uVision e Flash Magic e su come usarli, segui il link Primi passi con il microcontrollore ARM7 LPC2148 e programmalo usando Keil uVision.
Il codice completo per interfacciare LCD con ARM 7 è fornito alla fine di questo tutorial, qui ne spieghiamo alcune parti.
Prima di tutto dobbiamo includere i file di intestazione richiesti
#includere
L'inizializzazione del modulo LCD è un passaggio molto importante. Qui utilizziamo alcuni codici HEX, che in realtà sono comandi, per indicare all'LCD la modalità di funzionamento (4 bit), il tipo di LCD (16x2), la linea di partenza ecc.
void LCD_INITILIZE (void) // Funzione per preparare l'LCD { IO0DIR = 0x0000FFF0; // Imposta il pin P0.4, P0.6, P0.12, P0.13, P0.14, P0.15 come OUTPUT delay_ms (20); LCD_SEND (0x02); // Inizializza lcd in modalità operativa a 4 bit LCD_SEND (0x28); // 2 righe (16X2) LCD_SEND (0x0C); // Visualizza sul cursore spento LCD_SEND (0x06); // Incremento automatico del cursore LCD_SEND (0x01); // Visualizza LCD_SEND chiaro (0x80); // Prima riga prima posizione }
Per la modalità a 4 bit abbiamo diversi tipi di funzione di scrittura per i pin, ovvero utilizzando nibble superiore e inferiore. Vediamo come si fa
void LCD_SEND (char command) // Funzione per inviare comandi esadecimali nibble per nibble { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Invia il nibble superiore del comando IO0SET = 0x00000040; // Making Enable HIGH IO0CLR = 0x00000030; // Rendere RS & RW BASSO delay_ms (5); IO0CLR = 0x00000040; // Attivazione LOW delay_ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0x0F) << 12)); // Invia il nibble inferiore del comando IO0SET = 0x00000040; // ABILITA IO0CLR ALTO = 0x00000030; // RS & RW LOW delay_ms (5); IO0CLR = 0x00000040; // ENABLE LOW delay_ms (5); }
Nibble Sending Logic
IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0x0F) << 12)); // Invia il nibble inferiore del comando IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((command & 0xF0) << 8)); // Invia il nibble superiore del comando
Le due affermazioni precedenti giocano un ruolo importante in questo programma. Il primo comando invia il nibble inferiore e il secondo invia il nibble superiore. Questo senza influire sugli altri pin che facciamo. Vediamo come sta accadendo prima di conoscere prima questa logica
ORing- (A-0 = A), (A-1 = 1) ANDing- (A & 0 = 0), (A & 1 = A)
Quindi utilizziamo un concetto di mascheramento e un'operazione di spostamento logico senza influire sugli altri pin. Significa che vengono utilizzati solo i pin (P0.12-P0.15) e nessun altro pin come P0.4, P0.6 è interessato. Sarà fatto spostando i dati in quattro bit e rendendo il bocconcino superiore al posto del bocconcino inferiore e mascherando il bocconcino superiore. Quindi rendiamo zero i bit inferiori (0XF0) e OR con i dati nibble per ottenere i dati nibble superiori in uscita.
Un processo simile viene utilizzato per dati di nibble inferiori, ma qui non è necessario spostare i dati.
Durante la scrittura dei dati in uscita, cioè in modalità di comando RS dovrebbe essere BASSA e per eseguire l'abilitazione deve essere ALTA, e in modalità dati RS dovrebbe essere ALTA e per eseguire l'abilitazione deve essere ALTA.
Ora, per inviare i dati della stringa che devono essere stampati in uscita, viene utilizzato lo stesso principio nibble by nibble. Il passaggio importante qui è REGISTER SELECT (RS) deve essere ALTO per la modalità dati.
void LCD_DISPLAY (char * msg) // Funzione per stampare i caratteri inviati uno per uno { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Invia il nibble superiore IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH per stampare i dati IO0CLR = 0x00000020; // RW LOW Ritardo modalità di scrittura ms (2); IO0CLR = 0x00000040; // EN = 0, RS e RW invariati (cioè RS = 1, RW = 0) ritardo ms (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Invia il nibble inferiore IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; ritardo ms (2); IO0CLR = 0x00000040; ritardo ms (5); i ++; }
Di seguito viene fornito un video completo di codifica e dimostrazione.