Lug 182013
 

In questo articolo facciamo una breve introduzione ai display LCD e ci focalizzeremo al collegamento di quelli compatibili con il driver Hitachi HD44780.

Ci sono una miriade di applicazioni in cui vi sarebbe la necessità di dotare Arduino di un display per comunicarci informazioni di vario tipo, a partire dal debug del software alla visualizzazione di valori legati al vero e proprio funzionamento del nostro circuito. Prima di iniziare con pinout, collegamenti e programmazione, dobbiamo cominciare con il classificare sommariamente le tipologie di display che possiamo adottare. Dobbiamo innanzitutto distinguere due grosse categorie, ossia i display che potremmo definire grafici, ossia nei quali abbiamo un’area di pixel in cui ci possiamo fare quel che vogliamo per ogni singolo pixel, o quelli che potremmo definire “a caratteri”, nel senso che ci sono delle piccole aree rettangolari di pixel, ognuna deputata al disegno di un singolo carattere o eventualmente un piccolo elemento grafico, ma in cui ogni elemento è comunque separato dagli altri. In quest’ultimo caso abbiamo un numero limitato di righe e colonne, ad esempio i classici 16×2 o i 16×4. In questo articolo ci limitiamo a descrivere questa seconda grossa famiglia di display. Anche nel contesto di questo tipo di display “a caratteri” c’è un’importante sotto classificazione da fare. Ci sono infatti display di tipo seriale e parallelo. I primi usano poche connessioni ma sono molto più costosi, i secondi utilizzano molte più connessioni ma sono decisamente più economici. Gli HD44780 compatibili fanno parte di questa seconda categoria, ossia sono più economici ma necessitano di un numero più elevato di connessioni. Quest’ultimo punto è sicuramente un handicap se non in quei pochi casi in cui il nostro progetto impiega pochi pin del nostro IC (Arduino o altro), ma se ricordate questo precedente articolo, sapete già che è possibile utilizzare un 74HC595 e quindi ci risulta possibile pilotare uno di questi display con l’impiego di soli tre pin, cosa che vedremo in un futuro articolo.

Come sempre partiamo dal pinout:pinoutlcd

  1. Vss  -Massa
  2. Vcc – Generalmente 5V
  3. Vee – Controllo contrasto
  4. R\S – 0 per inviare comandi, 1 per inviare dati
  5. R\W – 0 per scrittura, 1 per lettura
  6. E – Inizio ciclo di lettura o scrittura
  7. D0
  8. D1
  9. D2
  10. D3
  11. D4
  12. D5
  13. D6
  14. D7
  15. Vcc – Vcc retroilluminazione (se presente)
  16. Vss – Massa retroilluminazione (se presente)

Se togliamo tutti i collegamenti alla Vcc e massa ci restano comunque la bellezza di 11pin. C’è però da dire che ci sono due modalità di trasferimento, quella ad 8bit che a dirla tutta è utilizzata di rado proprio per l’alto numero di pin necessari e quella a 4bit (nibble) che utilizza i pin da D4 a D7 per trasferire in due momenti successivi 4 bit alla volta, in due tempi. Ciò permette di risparmiare altri 4 pin portando i pin necessari a 7, anche se vedremo che possiamo eliminarne ancora uno. Attraverso questi pin possiamo inviare tutta una serie di comandi all’HD44780 che equipaggia il nostro display; quest’ultimo li interpreta ed esegue l’istruzione da noi impostata. La cosa che deve essere chiara è che noi non andiamo ad “accendere e spegnere” i singoli pixel che compongono ogni carattere, ma inviamo specifici comandi che il display interpreta. Con Arduino possiamo usare la libreria LiquidCrystal che esegue tutte le operazioni necessarie grazie a poche semplici funzioni. Se non siete interessati alla parte più tecnica che segue qui sotto, potete tranquillamente saltare il paragrafo, guardatevi solo l’immagine con la cablatura del display e potete passare alla descizione della LiquidCrystal.

Hitachi HD44780

Il chip HD44780 è un cosidetto “standard de facto”, ossia pur non rappresentando uno standard riconosciuto ufficialmente è in realtà utilizzato pressoché da tutti ed i chip alternativi di fatto copiano le stesse identiche funzioni di questo. Il display ha bisogno di una fase di inizializzazione nella quale dobbiamo stabilire alcuni parametri, ad esempio è necessario comunicare al chip se intendiamo utilizzare la sintassi completa o quella nibble (4 bit), dobbiamo specificare quante righe e colonne usare, il tipo di font, se far lampeggiare il cursore e molto altro.

La primissima operazione da fare per inizializzare il display è ….. aspettare. Il chip del display ha bisogno di un certo tempo per effettuare un reset e prepararsi a ricevere i comandi per cui da quando viene data alimentazione a quando è pronto a ricevere i comandi occorre attendere un tempo variabile fra i 15ms e i 40ms a seconda del tipo di alimentazione (valori rispettivamente per 5V e 2.7V).

Dopo questa prima fase di attesa dobbiamo comunicare al display se siamo intenzionati ad usare la sintassi a 4 o 8 bit, quante righe ha il display e che font vogliamo utilizzare. Il fatto che dobbiamo indicare noi all’HD44780 quante righe possiede il nostro display dipende dal fatto che questo chip può controllare display di dimensioni differenti per cui è nostro compito fornirgli questo dato. Per non differire dal datasheet originale utilizzerò le stesse sigle in modo da non creare confusione se andate a leggervi altri articoli in giro per il web. La sintassi del comando da inviare è:

DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 1 DL N F 0 0

Con DB0-7 sono indicati gli ingressi che nel pinout sono indicati dal 7 al 14. I tre parametri indicati in tabella corrispondono a:

  • DL: Indica i bits della comunicazione. Zero indica i 4 bit e 1 indica gli 8.
  • N: Indica le linee del display: Zero indica una riga, 1 indica 2 righe.
  • F: Seleziona il font: con zero indica il font 5×8 (punti per carattere) e con 1 5×10.

Per inviare questo comando però dobbiamo prima chiederci: “come si inviano i comandi?”. La procedura generica per inviare pacchetti di dati a 4 bit è quella qui di seguito:

  • Settiamo il pin RS (1 per i dati, zero per i comandi)
  • Portiamo E (Enable) a 1 (indichiamo l’inizio della lettura / scrittura)
  • Inviamo i 4 bit più significativi (per pacchetti a 8 bit li inviamo tutti ed 8)
  • Riportiamo E a zero per indicare che il pacchetto di dati è stato inviato.
  • Portiamo nuovamente E a 1 per indicare una seconda fase di scrittura. (solo per pacchetti a 4 bit)
  • Inviamo i 4 bit meno significativi (solo per pacchetti a 4 bit)
  • Riportiamo E a zero per indicare che il secondo pacchetto dati è stato inviato (solo per pacchetti a 4 bit)

Ovviamente nella procedura a 8bit la sequenza è più corta e veloce visto che inviamo tutti i dati in un’unica fase. Nella pratica possiamo fare una semplificazione. Infatti possiamo preoccuparci di settare tutti i pin dati ed i registri RS ed RW. Una volta fatto utilizziamo il pin E per dire al displaty che ci sono dati pronti sui suoi ingressi e che può andarli a leggere: per fare ciò portiamo E da LOW ad HIGH, lo manteniamo HIGH per almeno 450 nanosecondi e poi lo riportiamo a LOW. Prima di inviare un nuovo comando dobbiamo attendere almeno altri 37 microsecondi per dare il tempo al display di effettuare l’operazione richiesta (Nota: operazioni diverse richiedono tempi diversi e variano leggermente in base al voltaggio di alimentazione, il tipo di chip e la temperatura di esercizio).

Ora facciamo una piccola riflessione. Prima di indicare al display se usare comunicazioni a 4 o 8 bit, secondo voi come si aspetta di riceverle visto che non  è ancora inizializzato? Ovviamente il display non sa se sono connessi 4 o 8 connettori per cui sarebbe logico attendersi che sia necessario usare i 4 che sono connessi in entrambi i tipi di configurazione. Invece non è così, infatti il display nella fase iniziale di reset si prepara per ricevere comandi ad 8 bit. A dirla tutta il display nel momento in cui viene alimentato, non si limita a settare l’interfaccia ad 8bit, ma anche a settare una singola riga di visualizzazione, utilizzo del font 5×8, movimento del cursore verso destra, etc. Fra le varie preselezioni, il display si pone in uno stato “spento”, ossia non visualizza nulla finché non riceve un comando specifico per l’attivazione della visualizzazione. Ma torniamo a noi, come inviamo il nostro comando? Ho letto a lungo la documentazione ufficiale e vari tutorials sparsi per la rete, ma la procedura di inizializzazione del display è un vero e proprio “mistero della fede”, probabilmente per il fatto che l’interfaccia è settata ad 8 bit, ma nella fase di inizializzazione vengono letti solo i primi 4. La procedura è ben codificata ma darne una spiegazione logica credo sia impossibile:

  • Inviare 0011
  • Attendere 4.1 ms
  • Inviare 0011
  • Attendere 100 microsecondi
  • Inviare 0011 (Nota: ricorda di attendere almeno 37 microsecondi fra un comando e l’altro)
  • Inviare 0010 (interfaccia a 4 bit)

A questo punto può essere inviato il comando di inizializzzazione vero e proprio:

  • Inviare 0010
  • Inviare 1100

Faccio notare, per completezza che molti display si settano correttamente anche senza reinviare più volte il comando iniziale, ma conviene sempre seguire alla lettera il datasheet per impedire che si verificichino problemi di compatibilità con diversi tipi di display. Vi faccio notare che il comando completo (0010 1100) setta il display a 2 righe con font 5×10.

Rivediamo i passi da fare:

  • Settiamo il pin RS (1 per i dati, zero per i comandi)
  • Portiamo E (Enable) a 1 (indichiamo l’inizio della lettura / scrittura)
  • Inviamo i 4 bit più significativi (0 0 1 1) // settaggio a 8 bit (anche se intendiamo usare i 4 bit)
  • Riportiamo E a zero per indicare che il pacchetto di dati è stato inviato.
  • Attendere 4.1ms
  • Portiamo nuovamente E a 1 per indicare una seconda fase di scrittura.
  • Reinviamo nuovamentei 4 bit più significativi (0 0 1 1)
  • Riportiamo E a zero per indicare che il pacchetto di dati è stato inviato.
  • Attendiamo 100 microsecondi
  • Reinviamo ancora 0 0 1 1 ed attendiamo un minimo di 37 microsecondi prima del prossimo comando
  • Riportiamo E a zero per indicare che il pacchetto dati è stato inviato.
  • Portiamo nuovamente E a 1 per indicare una nuova fase di scrittura.
  • Inviamo 0 0 1 0 (4 bit)
  • Riportiamo E a LOWper indicare che il pacchetto dati è stato inviato.
  • Portiamo nuovamente E a 1 per indicare una nuova fase di scrittura.
  • Ora inviamo finalmente i 4 bit più significativi del comando di inizializzazione (0 0 1 0) (non prima di 37 microsecondi)
  • Riportiamo E a LOWper indicare che il pacchetto dati è stato inviato.
  • Completiamo il comando con 1 1 0 0 (due righe, font 5×10).
  • Riportiamo E a LOWper indicare che il pacchetto dati è stato inviato.

A questo punto il display è settato. Vi faccio notare che quando dico “inviamo i 4 bit”, significa settare ad HIGH o LOW i rispettivi 4 pin (8 nel caso di comunicazioni ad 8 bit). Ricordiamoci che ogni volta che portiamo E ad HIGH ed abbiamo settato i vari pin, dobbiamo attendere almeno 450 nanosecondi prima di riportare E a LOW, inoltre dopo ogni comando dobbiamo attendere almeno 37 microsecondi prima di inviare un nuovo comando (attenzione alle unità di misura!). Una volta capita la procedura di reset possiamo andare avanti speditamente. Dopo il reset il display deve essere “acceso” e per fare ciò c’è un’altro comando specifico.

DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 1 D C B

Il comando (Display ON/Off) è identificato dal pin DB3. Gli altri due parametri variabili indicano:

  • D: 0=Display spento / 1=Display acceso
  • C: 0=Cursore spento / 1=Cursore acceso
  • B: 0=Cursore fisso / 1= Cursore lampeggiante

Una volta acceso il display, siamo pronti per inviarvi i caratteri da scrivere. In realtà ci sono ancora diversi comandi, ma quelli basilari per far funzionare il display li abbiamo descritti.

Il collegamento

Anche se da un punto di vista teorico abbiamo già visto come collegare questi display, vale la pena perdere qualche minuto in più con uno schema davanti agli occhi per discutere alcuni particolari pratici che è meglio conoscere. Nel disegno qui sotto i pin del display vanno da 1, a sinistra, al 16, verso destra.

Lcd Arduino

Ora osserviamo il quinto pin. Vedete che è collegato a massa? Quallo è il registro RW che se posto a 0 indica la scrittura di dati/istruzioni e con 1 la lettura. Visto che la nostra intenzione di base è scrivere dati sul display, possiamo collegare direttamente questo pin a massa. Ma la domanda c’è la dobbiamo porre: “perchè dovremmo leggere il display?”. Ogni HD44780 gestisce una memoria per 80 caratteri ma se il nostro display è ad esempio un 16×2, gli altri 48 che fine fanno? Semplice, noi possiamo tranquillamente scrivere anche in quelle posizioni ma nulla sarà visualizzato sul display. In questo modo possiamo utilizzare quei bytes come della RAM sfruttabile per i nostri scopi, utile ad esempio se lavoriamo con processori con scarse risorse. Oltre a leggere ciò che và “fuori” dal display, possiamo leggere anche il contenuto vero e proprio di ciò che è visualizzato, cosa che ci permette ad esempio di scrivere dei dati senza memorizzarne il contenuto sul nostro IC. Infatti  sapendo che possiamo ripescare il contenuto del display direttamente da esso, possiamo sempre rileggerlo per conoscerne il contenuto. Ovviamente questa tecnica è utile se abbiamo scarse risorse a disposizione, altrimenti difficilmente la utilizzeremo visto che è una pratica non molto veloce e piuttosto dispendiosa in termini di istruzioni da impartire. Un’altra cosa che vi faccio notare è la resistenza sul pin del led per la retroilluminazione. Come tutti i LED dovete SEMPRE mettere una resistenza che limita la corrente, è possibile che alcuni display abbiano la resistenza già integrata, ma se non avete il datasheet del vostro display è buona pratica metterne una (io ho usato una resistenza da 270Ω. L’altra cosa che vi faccio notare è il potenziometro per la regolazione del contrasto dei caratteri. Ho provato due display differenti con la medesima resistenza ed il risultato è stato diverso, motivo per cui il potenziometro vi permette di regolare la resistenza caso per caso. Con un circuito definitivo potreste pensare di usare una resistenza fissa calcolata in base ad un prototipo o ad un Trimmer, dipende da cosa volete ottenere.

Scriviamo un carattere sul display

La scrittura dei caratteri sul display segue le procedure sopra viste, solo che tutti i bit vengono utilizzati per identificare il carattere. La differenza sostanziale sta nel fatto che il registro RS anziché essere posto a 0 (comandi) viene posto in uno stato HIGH (dati) per cui il display capisce che deve scrivere il carattere corrispondente. L’altra cosa a cui stare attenti è l’impostazione del registro RW a zero (scrittura) visto che se impostato ad 1 viene effettuata la lettura del display e non la scrittura. Ora la domanda è: “Come scegliamo il carattere da scrivere sul display?”. L’HD47780 ha una ROM (CGROM – Character Generator Read Only Memory) da cui “attingiamo” i caratteri che vogliamo visualizzare. Questi vengono copiati nella memoria di visualizzazione del display (DDRAM: Display Data RAM). A dirla tutta possiamo attingere alcuni caratteri anche dalla CGRAM ( Character Generator RAM) che è una piccola memoria dove possono essere memorizzati caratteri definibili dall’utente. Come dicevamo prima, la DDRAM è formata da 80 caratteri, indipendentemente dal fatto che siano o meno sfruttati tutti sul display. La corrispondenza fra DDRAM e caratteri visualizzati dipende dal numero di righe del display. Il primo carattere ha l’indirizzo 0, il secondo 1, etc.

Display ad una riga
0 1 2 3

Nei display a 2 righe, la seconda riga comincia da 40, perciò se avete un display 16×2, il primo carattere della prima riga andrà copiato sulla locazione 0, mentre il primo carattere della seconda riga alla locazione 40. I successivi saranno 41,42, etc sino al completamento della riga del display. Se ne deduce che le locazioni di memoria fra la fine della prima riga e l’inizio della seconda non sono contigue.

Display a due colonne
 0  1  2  3  …
 40  41  42 43  …

Nei display a 4 righe le prime due sono identiche ai display a 2 righe, le due rimanenti vengono indirizzate alle locazioni 20 e 60. Se ne deduce che la lunghezza massima nei display a 4 righe è di 20 colonne.

Display a quattro colonne
0 1 2 3 ….
40 41 42 43
20 21 22 23
60 61 62 63

La CGROM contiene 208 caratteri 5×8 e 32 caratteri 10×8 mentre la CGRAM, ossia quella definibile dall’utente, può contenere 8 caratteri 5×8 oppure 4 da 5×10. Ora dobbiamo fare in modo di dire all’HD44780 di prelevare dalla CGROM quel dato carattere che ci interessa e stamparlo sul display (DDRAM) nella posizione attuale del cursore. Anche se non abbiamo ancora trattato i comandi per posizionare il cursore, è necessario sapere che dopo il reset iniziale il cursore viene posizionato su 0,0 ossia la prima riga, prima colonna. Ci sono comandi specifici che ci permettono di stabilire quale comportamento deve assumere il cursore dopo la scrittura di ogni singola lettera, potremmo infatti farlo spostare in automatico verso destra, in questo modo non siamo costretti ad inviare le coordinate dopo ogni scrittura con netta riduzione dei passaggi necessari. La cosa fondamentale da conoscere è l’indirizzo dei caratteri nella CGROM, infatti se vogliamo scrivere una A sul display dobbiamo conscere l’indirizzo nella CGROM di quel carattere.

HD44780-ASCII1

HD44780-ASCII2

Dalle tabelle sopra allegate (click per la visione al 100%) potete vedere la corrispondenza fra i vari caratteri ed i relativi codici. Non spaventatevi, la cosa è molto più semplice di quanto sembri, infatti non è nulla di particolare se non la classica codifica ASCII (si legge ASCHII). Come sempre ci sono caratteri standard quali le lettere maiuscole, minuscole, punteggiatura e numeri, mentre con i simboli, e fra questi non dimentichiamoci le lettere accentate, difficilmente troverete una corrispondenza fra dispositivi diversi. Il fatto di avere una codifica ASCII fa si che il codice della “A” di Arduino sarà il medesimo dell’HD44780 per cui se non avete necessità di usare dei simboli “non standard”, non dovrete fare nessun tipo di conversione.

Ci resta solo un comando fondamentale per il controllo base del display, ossia quello che ci permette di settare l’indirizzo DDRAM, ossia la posizione sul display ove verrà disegnato il prossimo carattere.

Il comando è:

DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
1 X X X X X X X

Con XXXXXXX è ovviamente indicato l’indirizzo di memoria della cella da puntare.

Visto che questo articolo è già di per se piuttosto corposo, rimandiamo ad un successivo approfondimento la programmazione dei caratteri personalizzati e l’approfondimento di alcuni comandi che in questa sede tralasceremo per non creare troppa confusione.

Per mostrarvi praticamente quanto esposto finora ho preparato un listato molto semplice anche se poco elegante e per nulla ottimizzato. Ho utilizzato due funzioni. La SetCommandPin prende come parametri i pin da D7 a D4 che setta con i valori HIGH o LOW a seconda di cosa viene passato. L’altra funzione, presa “a prestito” dalla libreria LiquidCrystal che vedremo a breve, è la PulseEnable che si occupa di innalzare il pin E ad HIGH e riportarlo poi a LOW, rispettando le tempistiche necessarie affinché il display interpreti correttamente il comando passato.

// preparo le variabili per i pin E,RS e quelli da D4 a D7
int pin_RS;
int pin_E;
int pin_D4;
int pin_D5;
int pin_D6;
int pin_D7;

//prototipi
void SetCommandPin(bool,bool,bool,bool);
void PulseEnable(void);

void setup() 
{
 //setto le corrispondenze fra i pin dell'HD e quelle di Arduino
 int i;
 pin_RS=7; // collego il pin 7 di Arduino all'RS del Display
 pin_E=6;
 pin_D4=5;
 pin_D5=4;
 pin_D6=3;
 pin_D7=2;


 // setto i vari pin di Arduino come OUTPUT
 pinMode(pin_RS, OUTPUT);
 pinMode(pin_E, OUTPUT);
 pinMode(pin_D4, OUTPUT);
 pinMode(pin_D5, OUTPUT);
 pinMode(pin_D6, OUTPUT);
 pinMode(pin_D7, OUTPUT);
 
 
 
 //procedura di reset
 delayMicroseconds(50000); // attesa iniziale....40ms ( ho usato tempi abbondanti
 
 digitalWrite(pin_E, LOW); // mi accerto che il pin E sia allo stao LOW prima di cominciare
 digitalWrite(pin_RS, LOW); // comando con RS=LOW
  
 SetCommandPin(0,0,1,1); // invio 0011
 PulseEnable();
 delayMicroseconds(4500); // 4.1ms
  
  SetCommandPin(0,0,1,1); // reinvio 0011
  PulseEnable(); 
  delayMicroseconds(150); // 100us
  
  SetCommandPin(0,0,1,1); // reinvio 0011
  PulseEnable(); 
  
  SetCommandPin(0,0,1,0); // ...settiamo i 4 bit...
  PulseEnable();  

  SetCommandPin(0,0,1,0); // ...finalmente possiamo inviare il comando completo
  PulseEnable(); 
  SetCommandPin(1,1,0,0); // ..... i restanti quattro per settare font e righe
  PulseEnable(); 

 // accendo il display
  SetCommandPin(0,0,0,0); // primi 4
  PulseEnable();
  SetCommandPin(1,1,1,1); //ultimi 4 diplay acceso, cursore presente e lampeggiante
  PulseEnable();

 //clear
  SetCommandPin(0,0,0,0); // primi 4
 PulseEnable();
  SetCommandPin(0,0,0,1); 
 PulseEnable();

 
 // scrivo una lettera
  digitalWrite(pin_RS, HIGH); // porto RS ad HIGH per indicare l'invio di DATI
  SetCommandPin(0,1,0,0); // primi 4
  PulseEnable();
  SetCommandPin(1,0,0,0); // ultimi 4
  PulseEnable();
   delayMicroseconds(50); // 37us
}

void loop() 
{
  delay(1000); 
  digitalWrite(pin_RS, HIGH); // porto RS ad HIGH per indicare l'invio di DATI
  SetCommandPin(0,1,0,0); // primi 4
  PulseEnable();
  SetCommandPin(1,1,0,0); // ultimi 4
  PulseEnable();
  delay(1000); 
  
}

void SetCommandPin(bool D7,bool D6,bool D5,bool D4)
{
  digitalWrite(pin_D7, D7); 
  digitalWrite(pin_D6, D6); 
  digitalWrite(pin_D5, D5); 
  digitalWrite(pin_D4, D4);   
}

void PulseEnable(void) {
  digitalWrite(pin_E, LOW);
  delayMicroseconds(1);   // >450ns
  digitalWrite(pin_E, HIGH);
  delayMicroseconds(1);    //  >450ns
  digitalWrite(pin_E, LOW);
  delayMicroseconds(100);   //  > 37us
}

LiquidCrystal

Questa libreria è già inclusa nel pacchetto software di Arduino con tanto di relativi esempi e serve ovviamente a pilotare i display di cui abbiamo parlato sinora, semplificando notevolmente tutta la parte di gestione dei pin, comandi, temporizzazioni etc. La prima cosa da fare è creare un oggetto LiquidCrystal indicando nel costruttore quali sono i pin che abbiamo utilizzato per connettere il display.

IMAG0760

Se avete connesso il display come nello schema prima proposto l’istruzione sarà:

LiquidCrystal lcd(12,11,5,4,3,2)

La seconda cosa da fare è l’inizializzazione del display che ovviamente andiamo a fare nel setup.

lcd.begin(16, 2);

Come vedete l’istruzione è molto semplice, basta indicare il numero di righe e colonne del display ed il gioco è fatto. In questo modo anche se non conoscete la complessa base teorica che ci sta dietro sarete in grado di utilizzare questi display su Arduino. Ci sono ancora due istruzioni fondamentali da analizzare, la prima ci permette di decidere dove posizionare il cursore sul display, il secondo stampa la stringa che desideriamo sul display:

  lcd.setCursor(0, 0);
  lcd.print("McMajan!");
  lcd.setCursor(0, 1);
  lcd.print("www.mcmajan.com");

Faccio notare che tramite SetCursor non dobbiamo conoscere le locazioni di memoria della DDRAM ma ci limitiamo semplicemente a fornire il numero di colonna e riga. La semplicità è tale da non necessitare quasi di alcun commento. L’unica cosa da dire è che i parametri della SetCursor sono rispettivamente la colonna (X) e la riga (Y) e si comincia a contare da zero, ossia la prima riga / colonna è la zero, la seconda è la uno. Come vedete con sole 4 istruzioni siamo in grado di gestire come ci pare il display. Ci sono anche altre funzioni pronte all’uso ma le andiamo ad analizzare nel prossimo articolo di approfondimento, parallelamente all’analisi dei meccanismi che ci stanno dietro. Nella foto qui vicino potete vedere un display 16×4, non badate a tutti quei cavi perché nel complesso è un prototipo che sto portando avanti e di volta in volta ci aggiungo qualche pezzo …  questa volta è toccato al display.

  2 Responses to “Arduino e display HD44780 compatibile”

  1.  

    Ciao,
    bell’articolo! ti volevo solo dire che nell’esempio hai indicato
    pin_RS=7; pin_E=6;
    mentre nel disegno sono collegati i pin 11 e 12
    Carlo

    •  

      mi fa sempre piacere quando qualcuno si accorge di questi errori perchè significa che ha letto con molta attenzione. Devo stare più attento, spesso faccio i disegni e poi scrivo l’articolo, ma durante la scrittura frequentemente faccio delle modifiche per i più svariati motivi e non mi accorgo delle discordanze con il disegno…Grazie mille per la segnalazione.