Oggi proveremo a concentrarci sull'output su un display testuale. Il chip più popolare è l'HD44780 (o il suo compatibile KS0066). Elenchiamo i loro pro e contro:

Pro:

1. Prezzo basso.
2. Facile da programmare, il codice sarà lo stesso per qualsiasi modello.
3. Varietà di modelli: i più comuni: 8×1, 16×2, 20×4. Puoi anche trovare modelli 40x4 piuttosto esotici, ad es. quattro righe di 40 caratteri ciascuna.
4. Possibilità di collegare più display a un Arduino.
5. Possibilità di impostare i propri simboli.

Contro:

1. Non tutti i display supportano i caratteri russi. Per maggiori dettagli fare riferimento alla descrizione della specifica visualizzazione.
2. La connessione senza utilizzare il bus I2C richiede l'uso di 10-16 fili, il che è pessimo. con I2C – 4 fili.

Sulla base di quanto sopra, prenderò in considerazione solo il collegamento del display tramite I2C.

Proviamolo.

Di cosa abbiamo bisogno?

1. Arduino (ho preso il modello Nano)
2. Display sul chip HD44780 con o senza modulo I2C (quindi avrai bisogno di una scheda IIC LC1602 separata) - nel nostro caso 16x2 senza modulo I2C
3. Resistenza da 10Kohm (se è necessario il controllo manuale della retroilluminazione).
4. Potenziometro (se è necessario il controllo manuale della retroilluminazione).
5. Scheda di sviluppo breadboard.
6. Libreria LiquidCrystal_I2C.

Piccola digressione n.1: come distinguere un display con modulo I2C?

In realtà è abbastanza semplice. Se, capovolgendo il display, vediamo un lungo blocco di connettori (solitamente 16 pezzi), allora sul display non è presente alcun modulo I2C:

Ed ecco come appare il display con il modulo I2C già installato:

Vengono utilizzati i pin SCL, SDA, VCC, GND Connessioni Arduino. I due contatti a sinistra - nella foto chiusi con un ponticello - servono per il funzionamento della retroilluminazione.

Se il modulo non è collegato, dovrai farlo da solo. La cosa principale a cui prestare attenzione è collegare i contatti nell'ordine corretto. Di norma vengono contrassegnati il ​​primo e i 16 pin. A volte capita che 15-16 contatti, attraverso i quali viene controllata la retroilluminazione, possano trovarsi davanti al primo (in questo caso saranno numerati). Sul modulo stesso, il primo pin può anche essere contrassegnato non da un numero, ma da un quadrato attorno al pin stesso.

Schemi:

Mettiamo insieme il seguente diagramma:

Vorrei attirare la vostra attenzione sui seguenti punti:

1. Se ti imbatti in un display con un modulo I2C già saldato, i fili contrassegnati in grigio non saranno necessari. Altrimenti non cambia nulla.
2. Se non vogliamo modificare la luminosità del display, allora lo schema sarà semplificato:

Come hai notato, due pin sul modulo I2C etichettati LED sono responsabili della retroilluminazione del display. Se non vogliamo utilizzare il controllo della luminosità, possiamo semplicemente chiuderli.

Ora diamo un'occhiata al codice.

Quasi tutto qui dovrebbe esserci familiare. Nella riga 5 indichiamo l'indirizzo del dispositivo. Nelle righe 16 e 17: il numero di caratteri nella riga e il numero di righe. Nelle righe 20-22 – Creiamo un oggetto per lavorare con il display e descriviamo il parametro per lavorarci.

Piccola digressione n.2: Come scoprire l'indirizzo di un dispositivo I2C?

Nella maggior parte dei casi, l'indirizzo si trova nella scheda tecnica del chip su cui è costruito il dispositivo I2C. Se ciò non è possibile, ecco un collegamento a un archivio con uno schizzo e diagrammi, che determina gli indirizzi di tutti i dispositivi collegati tramite il bus I2C. Devi solo connettere il dispositivo ad Arduino, caricare lo sketch, aprire la console e vedere l'indirizzo.

Qui vediamo una funzione che, di fatto, sarà responsabile dell'output sul display. Il principio di output è qualcosa del genere:

– Impostiamo la posizione dell'inizio dell'output utilizzando la funzione setCursor()

– Stampa una stringa utilizzando la funzione print()

Successivamente, la successiva funzione print() inizierà l'output dalla posizione successiva alla quale è terminato l'input precedente. Vorrei anche attirare la vostra attenzione sul fatto che, a differenza dell'output sulla console, qui la funzione println() non viene utilizzata per completare l'output e l'avanzamento riga.

Pertanto, nella prima riga dello schermo apparirà la scritta "Test LCD1602" e la seconda riga indicherà la risoluzione del display e un contatore che mostrerà quanti cicli ha completato il nostro schizzo.

Ma se dobbiamo visualizzare molti valori variabili sullo schermo, questo metodo non è del tutto conveniente. Il fatto è che la procedura di output del display è molto dispendiosa in termini di energia e lenta e effettuiamo output in questa funzione fino a 7 volte. Sarà molto più semplice generare la stringa in anticipo e poi emetterla interamente. La funzione di input formattata sprintf() ci aiuterà in questo.

Piccola digressione n. 3: funzione di input formattata sprintf().

Nel linguaggio C ci sono diverse funzioni molto convenienti per l'output di stringhe: sono chiamate funzioni di output formattate - printf (dalle parole print e format). Nel nostro caso specifico A noi interessa la funzione sprintf, che non stampa nulla sullo schermo, ma genera una stringa per il successivo output. Sembra qualcosa del genere:

sprintf (str , “Stringa %d per output “, i );

La funzione genera una stringa (contrassegnata in blu) utilizzando un template (giallo) in cui vengono sostituiti i valori delle variabili (in verde). Il risultato risultante verrà scritto in una variabile stringa (in rosso).

Possono esserci diversi modelli e variabili. In questo caso le variabili vengono scritte separate da virgole. La cosa principale è garantire che il numero di modelli in una riga corrisponda al numero di variabili. Le variabili per i modelli vengono prese in sequenza, ad es. il valore della prima variabile viene sostituito nel primo modello, il valore della seconda variabile nel secondo, ecc.

Cosa sono i modelli? Qualsiasi modello inizia con il simbolo “%” e termina con uno dei dieci simboli di tipo (nel caso di Arduino – sette). Tra di loro potrebbero esserci molte informazioni su come generare il valore, oppure potrebbe non esserci nulla.

Diamo un'occhiata a cosa può essere nel modello. IN caso generale il modello è simile al seguente:

%[flag ][larghezza ][.precisione ]tipo

Le parentesi quadre indicano che l'elemento racchiuso al loro interno potrebbe mancare. Una barra verticale indica che in questo campo deve essere selezionato uno dei valori specificati (nel nostro caso, una delle lettere H, I o L).

Affrontiamo innanzitutto l'elemento richiesto del modello: il tipo. Specifica quale tipo di variabile verrà emessa e può assumere uno dei seguenti valori:

Simbolo	Senso
C	Un personaggio
S	Stringa di caratteri
d,i	Intero decimale con segno
o	Ottale intero
tu	Intero decimale senza segno
x, X	Intero esadecimale
P	Puntatore (in esadecimale)
F	Numero frazionario in formato fisso
e, E	Numero frazionario in formato scientifico
g, G	Numero frazionario in formato scientifico o fisso

I tipi che non sono applicabili quando si lavora con Arduino sono contrassegnati in grigio. Pertanto, per emettere una stringa è necessario specificare “%s” e per emettere un numero intero – “%d”.

Successivamente, diamo un'occhiata al campo della larghezza. Il numero in esso indicato indica la larghezza minima del campo in cui verrà visualizzato il modello. Se la dimensione del valore nella variabile è inferiore, il campo verrà riempito con spazi; se è maggiore, la voce andrà oltre il campo. Pertanto, il modello "%6d" per il numero 385 restituirà 385 (notare i tre spazi prima del numero).

L'identificatore di precisione inizia sempre con un punto e il numero successivo specifica azioni diverse a seconda del tipo di valore. Per i tipi “d,o,u,x” indicherà quantità minima caratteri che dovrebbero apparire durante l'elaborazione. Per il tipo “f” – il numero di cifre decimali. Per il tipo "s" – il numero massimo di caratteri di stringa che verranno emessi. Ad esempio, "%6.1f" per il numero 34.2345 restituirà "34.1" (nota che anche il punto è considerato un segno e ci saranno due spazi prima del numero). Oppure il modello “%.3s” della stringa “precision” restituirà solo i primi tre caratteri – “precision”.

Il flag permette di modificare la visualizzazione del valore visualizzato:

Puoi leggere ulteriori informazioni sui modelli di funzioni printf su Internet. Qui ho dato breve panoramica funzionalità utilizzate più frequentemente.

Quindi la nostra funzione di output, riscritta per utilizzare l'output formattato, sarebbe simile a questa:

Nota che nelle righe 33 e 37 generiamo l'intera riga per l'output e nelle righe 34 e 38 le stampiamo.

Infine, le nostre funzioni di configurazione e loop preferite.

Alla riga 47 impostiamo la risoluzione del display, alla riga 48 accendiamo la retroilluminazione (la cui luminosità può essere regolata con un potenziometro). Nella riga 49 impostiamo il contatore dei cicli a zero. Lo aumenteremo di uno nella 37a riga dell'output (ricordate la costruzione count++?). Infine, alla riga 56 chiamiamo la funzione display discussa in precedenza. Tutto.

Cosa può essere cambiato o migliorato?

Ad esempio, puoi farlo controllo automatico illuminazione a seconda dell'illuminazione, utilizzando una fotoresistenza o un sensore di luce della stazione meteorologica discussa in diversi articoli in precedenza. Ad esempio, in condizioni di forte illuminazione, aumentare la luminosità della retroilluminazione e ridurla di notte. Oppure collega un sensore di movimento e accendi la retroilluminazione quando appare un oggetto davanti al display, oppure... In generale, penso che tu abbia già capito che, se lo desideri, sostituendo uno o più componenti e scrivendo un pezzo di codice, puoi migliorare seriamente l'usabilità del display. Possiamo anche utilizzare i nostri simboli sviluppati per la visualizzazione.

Non prenderò in considerazione tutte queste domande qui, poiché esulano dallo scopo di una recensione per principianti.

E questo è tutto quello che ho per oggi.

Con questo semplice articolo voglio iniziare la mia serie di articoli sull'automazione del posto di lavoro.

Attualmente sul mercato c'è gran numero Display LCD o, come vengono anche chiamati, display di sintesi dei caratteri. Particolarmente diffuse sono le visualizzazioni 1602 (16 caratteri, 2 righe) su un chip HD44780 e compatibili. Possono essere acquistati a buon mercato in Cina.

Questo articolo descrive in dettaglio lo schema di collegamento per questa schermata, ma è adatto anche per molti altri display di testo. C'è una libreria per Arduino Cristallo liquido con il quale è molto comodo lavorare con il display.

Componenti richiesti

1. LCD 1602 su chip HD44780
2. Qualsiasi Arduino. Nel mio caso Arduino Nano
3. Resistenza trimmer
4. Disposizione
5. Modulo di potenza
6. Fili di collegamento

Visualizzazione della connessione

Il display è alimentato da una tensione di 5V. La retroilluminazione del display è un circuito separato, non collegato al resto del circuito. Puoi accenderlo applicando 5 V al pin 15 e collegando il meno al pin 16. Puoi renderlo dimmerabile utilizzando un segnale PWM. È anche di moda accenderlo e spegnerlo separatamente, se necessario.

L'alimentazione per il resto dei circuiti del display viene fornita ai seguenti pin:

• 1-TERRA
• 2 - +5
• 3 - Contrasto. Si collega tramite un partitore di tensione da 5V. Il divisore è solitamente una variabile regolare o un resistore di sintonizzazione.

Per collegare il display è sufficiente utilizzare 6 linee, 6 pin su Arduino. Non abbiamo bisogno di leggere il display, quindi colleghiamo immediatamente a terra il pin 5 (RW), responsabile della lettura e della scrittura.

Quindi colleghiamo Arduino e lo schermo con le nostre 6 linee di comunicazione. Non importa quali contatti verranno selezionati su Arduino: li specificheremo nel programma, ma per l'esempio abbiamo scelto la seguente configurazione:

• Display pin 4 - 4° Perno dell'Arduino. Questa è la linea del segnale dell'indirizzo. Conosciuto come A0 o RS. A seconda che sia 0 o 1 il display capisce se abbiamo un comando sulla linea dati come “sposta il cursore” oppure un codice carattere da visualizzare.
• Il pin 6 del display è il pin 5 di Arduino. Questa è la riga di autorizzazione di accesso ai dati. Conosciuto come E o Abilita. Quando questa riga diventa uno, il display esegue un comando o emette un carattere dalla riga dati.
• L'11°, 12°, 13°, 14° pin del display sono rispettivamente il 10°, 11°, 12°, 13° pin di Arduino. Queste sono linee dati. Conosciuto come DB4, DB5, DB6, DB7.

Lo schermo è connesso e pronto per ricevere dati. Non resta che scrivere un programma per Arduino.

Programmazione

// Collega la libreria standard LiquidCrystal #include // Inizializza l'oggetto screen, trasferisce i contatti // utilizzati per la connessione ad Arduino in ordine: // RS, E, DB4, DB5, DB6, DB7 LiquidCrystal lcd(4, 5, 10, 11, 12, 13); void setup() ( // imposta la dimensione (numero di colonne e righe) dello schermo lcd.begin(16, 2); // stampa la prima riga lcd.print("Hello World"); // imposta il cursore alla colonna 0, riga 1 Cioè, // questa è effettivamente la seconda riga, poiché la numerazione inizia da zero lcd.setCursor(0, 1); // stampa la seconda riga lcd.print("LCD funziona!!! "); ciclo continuo() ( )

Tutto è abbastanza semplice e dovrebbe essere chiaro dai commenti.

Quando si crea il proprio dispositivo, spesso è necessario visualizzare rapidamente varie informazioni. Ad esempio, se crei un controller casa intelligente, allora è ragionevole dotare il dispositivo di un dispositivo di output che consenta di scoprire rapidamente lo stato attuale dei sistemi. La soluzione miglioreè un display a cristalli liquidi. Il consumo energetico quando la retroilluminazione è disattivata è minimo e lavorare con il display è estremamente semplice e non richiede molto intervento nel codice del programma. In effetti, l'output delle informazioni sul display LCD non è molto diverso dall'output sulla porta seriale. L'articolo discute la connessione di un display generatore di caratteri basato sul popolare chip HD44780 al controller Arduino.

Come funziona un display di testo LCD?

Per comprendere alcune sfumature, è utile sapere come funziona un display di generazione dei caratteri. Una particolarità di questo tipo di display è la presenza di un proprio controller con una propria memoria. DDRAM: memoria di visualizzazione. Per visualizzare un simbolo sullo schermo, è necessario caricare il simbolo in una cella di memoria, quindi passare un comando per visualizzare la cella di memoria. Durante la trasmissione, i caratteri vengono codificati utilizzando codici ASCII. Ad esempio, quando si scrive in memoria il codice 0x31, il simbolo “ 1 " La corrispondenza del codice del simbolo con la sua visualizzazione sullo schermo (cioè l'“immagine” del simbolo) è memorizzata nella memoria CGROM. CGROM è una memoria non volatile. Pertanto, il display può visualizzare solo i caratteri “cablati” nel controller. Ecco perché non tutti i display sono in grado di visualizzare, ad esempio, i caratteri russi. Gli espositori venduti nel nostro negozio, purtroppo, non sono russificati. C'è anche la memoria CGRAM. È mutevole. Possiamo creare i nostri simboli e visualizzarli sul display. Vale la pena considerare che non puoi creare più di otto personaggi.

Tutto questo lavoro “sotto il cofano” è importante solo per comprendere alcune sfumature. Esiste una libreria semplice e diretta per Arduino che fa tutto il lavoro per te, permettendoti di controllare l'output del display in modo facile e semplice.

Collegamento del display LCD ad Arduino

Per collegare il display, ovviamente, è necessario installarlo su una breadboard. Nota: i display venduti nel nostro negozio sono venduti senza connettore pin saldato. Se desideri ricevere un display immediatamente pronto per l'installazione su una breadboard, seleziona la casella di controllo "connettore a saldare" sulla pagina del prodotto e noi saldiamo il connettore per te. Il trasferimento dei dati al display può essere organizzato in due modi: 4 o 8 bit alla volta. Di conseguenza, avrai bisogno di 4 o 8 pin Arduino. In pratica, non ci sarà alcun aumento di velocità quando si utilizza un'interfaccia a otto bit. Pertanto, abbiamo bisogno solo di 4 pin digitali per trasmettere i dati. Saranno necessari altri 3 pin per impostare la modalità operativa del display. In totale, per collegare il display saranno necessarie solo 7 uscite digitali del controller. I contatti sul display sono etichettati, il che ti aiuterà a evitare confusione durante la connessione:

Numeriamo le conclusioni da sinistra a destra:

• 1-(VSS) Visualizza il terreno. Si collega alla guida di terra.
• 2-(VDD) Visualizza l'alimentazione. Si collega alla barra di alimentazione.
• 3-(VO) Ingresso potenziometro (incluso). Il contrasto del display viene regolato tramite un potenziometro. L'uscita centrale del potenziometro è collegata al pin del display.
• 4-(RS) Ingresso segnale “Comando”. Si collega a qualsiasi pin digitale Arduino. Nell'esempio è collegato al pin n°12.
• 5-(RW) Imposta la modalità “lettura” o “scrittura”. Stiamo per registrare. Colleghiamo il contatto a terra.
• 6-(E)Abilitare. Un altro output di "comando". Quando viene applicato un uno all'uscita, il display esegue il comando precedentemente trasmesso. Si collega a qualsiasi uscita digitale. Nell'esempio è collegato al pin n°11.
• 7-10 (D0-D3) lo lasciamo non connesso. Questi sono i pin dati utilizzati nell'interfaccia a otto bit. Non ne abbiamo bisogno.
• 11-14 (D4-D7) Contatti per la trasmissione dei dati in modalità a quattro bit. Connettersi nuovamente a qualsiasi uscita digitale. Nell'esempio sono collegati rispettivamente ai pin 5, 4, 3 e 2 (D4 al pin 5, D5 al pin 4, ecc.).
• 15 (UN) Anodo LED retroilluminato. Il resistore limitatore di corrente è già installato nel display, quindi l'anodo è semplicemente collegato alla barra di alimentazione. Poiché la retroilluminazione utilizza il LED più comune, è possibile collegarlo a qualsiasi pin che lo supporti e controllare la luminosità della retroilluminazione in modo programmatico.
• 16 (K) Catodo di illuminazione. Si collega alla guida di terra.

Schema di collegamento visivo:

Programmazione

Insieme a IDE di Arduino Viene fornita un'eccellente libreria per display a cristalli liquidi: LiquidCrystal. La libreria contiene esempi che rivelano pienamente le capacità dello schermo. Per iniziare, utilizza l'esempio standard "HelloWorld" (File -> Esempi -> LiquidCrystal -> HelloWorld) o carica il seguente codice nella scheda:

/* *Pin display RS sul pin 12 di Arduino *Abilita pin display sul pin 11 di Arduino *Pin display D4 sul pin 5 di Arduino *Pin display D5 sul pin 4 di Arduino *Pin display D6 sul pin 3 di Arduino *Pin display D7 sul pin 2 di Arduino *Uscita R/W del display a terra *Uscita del potenziometro all'uscita VO del display */ // collega la libreria: #include ; // Inizializza il display // Enumera pin dell'arduino a cui sono collegati i contatti del display // RS, E, D4, D5, D6, D7 LiquidCrystal lcd(12, 11, 5, 4, 3, 2); void setup() ( // Specifica il numero di colonne e righe del display: lcd.begin(16, 2); // Visualizza un messaggio sul display. lcd.print("ciao, mondo!"); ) void loop() ( // posiziona il cursore sulla colonna 0 (zero) della prima riga // infatti il ​​cursore verrà posizionato sulla seconda riga (inferiore) // la numerazione di righe e colonne parte da zero lcd.setCursor( 0, 1); // visualizza il numero di secondi che // sono trascorsi dal momento del caricamento della scheda: lcd.print(millis()/1000);

*Perno del display RS sul pin 12 di Arduino *Abilita il pin di visualizzazione sul pin 11 di Arduino *Perno del display D4 sul pin 5 di Arduino *Perno del display D5 sul pin 4 di Arduino *Perno del display D6 sul pin 3 di Arduino *Perno del display D7 sul pin 2 di Arduino *Uscita display R/W a terra *Uscita del potenziometro sul pin VO del display // collega la libreria: #includere ; // Inizializza il display // Elenca i pin Arduino a cui sono collegati // Pin di visualizzazione RS, E, D4, D5, D6, D7 configurazione nulla() ( // Specifica il numero di colonne e righe del display: lcd. inizio(16, 2); // Visualizza un messaggio sul display. lcd. print("ciao mondo!") ; ciclo vuoto() ( // la numerazione di righe e colonne inizia da zero lcd. setCursore(0, 1); // visualizza il numero di secondi // trascorso dal caricamento della scheda: lcd. print(milli()/1000);

Dopo aver caricato questo codice in Scheda Arduino Lo schermo visualizzerà "ciao mondo!"( Inglese "Ciao mondo!") sulla prima riga e un timer che conta i secondi sulla seconda riga.

Come di solito accade, il codice è semplice e comprensibile. Lo analizzeremo comunque più nel dettaglio:

• Display LCD a cristalli liquidi(12, 11, 5, 4, 3, 2) - Questa riga crea un oggetto di visualizzazione con cui lavoreremo in futuro. Tra parentesi vengono passati come argomenti i numeri pin a cui sono collegati i contatti del display. Di conseguenza: RS, E, D4, D5, D6, D7. Come notato sopra, i numeri dei pin durante la connessione possono essere scelti in modo del tutto arbitrario.
• lcd.begin(16, 2) - qui abbiamo configurato le dimensioni del display. Questo esempio ha 16 colonne e 2 righe. Per il nostro display 20X4 questa linea sarebbe simile a questa: lcd.begin(20, 4).
• lcd.print(“ciao mondo!”) - visualizza il testo sul display. Dopo aver specificato la dimensione del display (lcd.begin), il cursore si posiziona nell'angolo superiore sinistro del display. Pertanto, questo testo verrà visualizzato sulla prima riga (in alto) a sinistra.
• lcd.setCursor(0, 1) - imposta il cursore nella posizione specificata. In questo caso viene indicata la posizione più a sinistra della seconda riga. Il numero della colonna è specificato tra parentesi, quindi il numero della riga. Sia le righe che le colonne sono numerate dalla posizione zero. Pertanto: lcd.setCursor(0, 0) - imposterà il cursore nell'angolo in alto a sinistra, lcd.setCursor(15, 0) - in basso a destra.
• lcd.print(millis()/1000) - già descritto sopra. Qui, invece del testo, come parametro viene passata una formula per il calcolo. Il risultato viene visualizzato sullo schermo.

Ora che abbiamo affrontato l’esempio più semplice, possiamo passare ad esempi più complessi. E se hai già capito tutto e sei pronto per acquistare un display LCD, allora ho raccolto per te i link ai venditori cinesi di display che ho verificato:

Display LCD a caratteri

Dimensioni di visualizzazione (colonne*righe)	Colore della retroilluminazione	Stato
20*4	Blu	verificato
20*4	Giallo	verificato
16*2	Blu	verificato
16*2	Giallo	verificato
16*2	Verde	verificato

Revisione di altri esempi di librerie LiquidCrystal

Negli esempi standard forniti con la libreria LiquidCrystal si possono trovare i seguenti schizzi:

• Scorrimento automatico- dimostra la capacità di scorrere automaticamente il testo. Una specie di linea strisciante. Quando viene visualizzato un carattere, i caratteri precedenti vengono spostati. Pertanto, il nuovo carattere viene visualizzato nello stesso posto.

• Battito di ciglia- dimostra la possibilità di abilitare la visualizzazione di un cursore lampeggiante sotto forma di rettangolo.

• Cursore- dimostra la possibilità di abilitare la visualizzazione di un cursore sotto forma di linea orizzontale lampeggiante.

• Carattere personalizzato- viene mostrata la possibilità di creare i propri simboli per visualizzarli sul display. A proposito, c'è un errore in questo schizzo. Dettagli di seguito.

• Display- mostra un modo per "spegnere" il display. Cioè, mostra o nascondi il testo visualizzato.

• Scorri- Dimostra la capacità di scorrere il testo manualmente.

• Display seriale- visualizza sullo schermo il testo stampato nella finestra del monitor della porta (ovvero il testo trasmesso attraverso la porta seriale).
• setCursor- riempie il display di lettere, dimostrando la possibilità di posizionare il cursore in qualsiasi posizione sullo schermo.
• DirezioneTesto- dimostra la capacità di cambiare la direzione dell'output del testo (da destra a sinistra o da sinistra a destra).

Consideriamo più in dettaglio le procedure le cui capacità sono dimostrate da questi esempi:

lcd.autoscroll()

Dopo aver richiamato questa procedura, il testo sullo schermo scorrerà automaticamente. Per interrompere lo scorrimento, chiama lcd.noAutoscroll().

lcd.lampeggio()

Dopo aver richiamato la procedura, il cursore apparirà come un rettangolo lampeggiante. Per disabilitare la chiamata lcd.noBlink()

lcd.cursore()

Dopo aver richiamato la procedura, il cursore apparirà come una linea orizzontale lampeggiante. Per disabilitare la chiamata lcd.noСursor(). Il cursore diventerà nuovamente invisibile.

lcd.createChar()

La procedura carica un carattere descritto come array di byte nella tabella dei caratteri dello schermo variabile (memoria CGRAM). L'argomento è il numero del simbolo e un array di byte che descrive il simbolo. Diamo un'occhiata a questo in modo più dettagliato. È possibile inserire un massimo di otto caratteri nella memoria del display. Per aggiungere il tuo simbolo è necessario:

1. Crea un array di byte che descrive il carattere.
2. Scrivere un simbolo nella memoria del display assegnandogli un numero nella tabella dei simboli. I caratteri sono numerati nell'intervallo da zero a sette.
3. Visualizzare un carattere sullo schermo utilizzando la procedura lcd.write()(da non confondere con lcd.print()), come argomento del quale passare il simbolo numero.

Un bug nell'ambiente di sviluppo e nelle funzionalità della libreria comportava l'impossibilità di visualizzare il simbolo numero 0 (zero). Quando il compilatore incontra la riga lcd.write(0), genererà un errore: " la chiamata di "write(int)" sovraccaricata è ambigua". Questa è esattamente la linea che appare nell'esempio Carattere personalizzato biblioteche. Quando provi a compilare l'esempio standard, riceverai un errore:

CustomCharacter.ino: Nella funzione 'void setup()': CustomCharacter:115: errore: la chiamata di 'write(int)' in sovraccarico è ambigua /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal.h:82 : nota: i candidati sono: virtual size_t LiquidCrystal::write(uint8_t) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print.h:49: nota: size_t Print::write(const char *)

Carattere personalizzato. ino: nella funzione 'void setup()': CustomCharacter: 115: errore: la chiamata di "write (int)" in sovraccarico è ambigua /home/nazarovd/arduino - 1.0.5/libraries/LiquidCrystal/LiquidCrystal. h : 82 : nota : i candidati sono : virtual size_t LiquidCrystal :: write (uint8_t ) /home/nazarovd/arduino - 1.0.5/hardware/arduino/cores/arduino/Print. h : 49 : nota : size_t Print :: write (const char * )

Per eliminare l'errore basta modificare la riga lcd.write( 0 ) in lcd.write( (byte)0).
Ora un piccolo esempio su come creare il tuo simbolo. Mostriamo il simbolo del rublo.

// Include la libreria #include ; // Inizializza il display LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Descrivi il nostro simbolo. // Semplicemente “disegniamo” il simbolo con le unità // Quando vengono visualizzate sullo schermo, le unità appariranno come punti pieni, gli zeri saranno vuoti byte rubl = ( 0b00000, 0b01110, 0b01001, 0b01001, 0b01110, 0b01000, 0b11110, 0b01000, ); void setup() ( // scrive il nostro carattere nella memoria dello schermo // passa il numero del simbolo // e un array di byte che descrive il nostro carattere come argomenti lcd.createChar(0, rubl); // imposta il display lcd.begin( 16, 2); ) void loop() ( // imposta il cursore nell'angolo in alto a sinistra dello schermo lcd.setCursor(0,0); // visualizza il carattere numero zero sullo schermo lcd.write((byte)0 ); // non fa nulla per 10 secondi di ritardo(10000);

// Include la libreria #includere ; // Inizializza il display LCD a cristalli liquidi (12, 11, 5, 4, 3, 2);

Queste istruzioni mostrano come connettersi ad Arduino e utilizzare schermi LCD 16x2 e 20x4. Questi schermi sono dotati di retroilluminazione integrata basata su un LED a basso consumo e funzionano a partire da +5 V. Per collegare questi schermi LCD sono necessari 6 pin. Puoi usare qualsiasi pin sul tuo Arduino!

Le istruzioni sono scritte sulla base degli schermi LCD di Adafruit: blu e bianco 16x2, RGB 16x2 LCD e blu e bianco 20x4, RGB 20x4. Se utilizzi uno schermo LCD di un altro produttore, non esiste una garanzia al 100% che funzioni (anche se funziona il 99% delle volte).

LCD a caratteri e grafici: qual è la differenza?

Esistono moltissimi schermi LCD diversi. In questo articolo esamineremo gli LCD dei caratteri. Schermate come queste sono un'ottima opzione per visualizzare il testo. Puoi anche personalizzare la visualizzazione delle icone, ma la dimensione di queste icone non deve superare i 7 pixel (molto piccola!).

La foto sotto mostra un esempio di monitor LCD da 16 caratteri con due righe:

Se guardi da vicino, vedrai piccoli rettangoli in cui sono visualizzati i simboli. Ogni rettangolo è una griglia separata di pixel. Per confronto, di seguito è mostrato uno schermo LCD grafico:

Sul display grafico a cristalli liquidi ce n'è uno maglia larga pixel (in questo esempio - 128x64). Puoi visualizzare del testo su di esso, ma è meglio visualizzare le immagini. Gli LCD grafici sono generalmente più grandi, hanno più pin per la connessione e sono un po' più difficili da usare rispetto agli LCD testuali.

In questo articolo tratteremo solo le schermate di testo/caratteri!

Diversi modelli di schermi LCD

Dopo aver limitato la tipologia di schermi in esame, vediamo cosa sono.

Nonostante servano solo per visualizzare testo, esistono diversi modelli e fattori di forma: nell'angolo in alto a sinistra lo schermo LCD è 20x4 con testo bianco su sfondo blu, in alto a destra è 16x4 con testo nero su sfondo verde, in quello in basso a sinistra è 16x1 con testo nero su sfondo grigio.

La buona notizia è che tutti questi schermi sono intercambiabili. Se ne hai configurato uno, puoi sostituirlo con un altro modello. Lo schizzo dovrà essere leggermente modificato, ma la connessione è la stessa!

In questa parte utilizziamo schermi LCD con un binario e 16 pin per il collegamento (vedi foto sopra). È presente anche un display LCD con 2 guide da 8 contatti per il collegamento (nella figura sotto).

Collegare il secondo modello a un circuito stampato senza saldatura è più difficile.

Collegamento di uno schermo LCD a caratteri ad Arduino

Installazione delle guide di contatto

Oltre allo schermo LCD, avrai bisogno di cavi aggiuntivi. Innanzitutto, a 10 kOhm. Utilizzando il potenziometro regoleremo il contrasto del display. Ogni schermo LCD ha diverse impostazioni di contrasto, quindi le regolazioni sono obbligatorie. Inoltre, avrai bisogno di una guida di contatto da 0,1 pollici.

Se la guida con i contatti è troppo lunga, puoi semplicemente tagliare i contatti in eccesso!

È necessario saldare i pin al display LCD.

Durante la saldatura, fai molta attenzione a non danneggiare il tuo ! Puoi prima "afferrare" il primo e 16 contatti, quindi saldare il resto.

Energia e illuminazione

Collegamento di alimentazione e illuminazione

	Spiegazioni
	Stiamo iniziando a scoprire alcune cose interessanti! Installa il tuo LCD sulla breadboard.
	Alimentiamo la breadboard dal nostro Arduino. Collegare +5V alla guida rossa e Gnd alla guida blu.
	Successivamente collegheremo la retroilluminazione del nostro schermo LCD. Collegare il pin 16 a terra e il pin 15 a +5V. La maggior parte degli schermi LCD sono dotati di resistori per la retroilluminazione. Se non ci sono resistori sul modulo, dovrai aggiungerne uno tra 5 V e il pin 15. Per calcolare il valore del resistore, controlla corrente massima per alimentare la retroilluminazione e il valore approssimativo della caduta di tensione dal datasheet. Sottrarre il valore della caduta di tensione da 5 V, quindi dividere per massima forza corrente e arrotondarlo al valore del resistore standard più alto più vicino. Ad esempio, se la caduta di tensione è 3,5 V e la corrente è 16 mA, il valore del resistore sarebbe: (5 - 3,5)/0,016 = 93,75 ohm o 100 ohm dopo l'arrotondamento al valore standard. Se non riesci a trovare la scheda tecnica, utilizza una resistenza da 220 ohm. È vero, in questo caso la retroilluminazione può essere piuttosto pallida.
	Collega il tuo Arduino all'alimentazione. La retroilluminazione dovrebbe accendersi.

A proposito, alcuni schermi LCD economici non hanno la retroilluminazione!

Circuito per la regolazione del contrasto

Circuito per la regolazione del contrasto

	Spiegazioni
	Installare il potenziometro. Nella foto è a destra del pin 1.
	Collegare un lato del potenziometro a +5V e l'altro a Gnd. Collegare il contatto centrale del potenziometro al pin 3 sul display LCD.
	Ora colleghiamo la logica del nostro schermo: questo è un circuito separato dalla retroilluminazione! Il pin 1 va a Gnd e il pin 2 va a +5V.
	Accendi il tuo Arduino. Se il monitor LCD è dotato di retroilluminazione, dovrebbe accendersi. Ruotare la manopola del potenziometro per vedere il primo rettangolo di pixel sulla prima riga.

Se tutto ha funzionato, congratulazioni. Ciò significa che logica, illuminazione e contrasto funzionano! Se non funziona, non procedere con i passaggi successivi delle istruzioni finché non scopri qual è l'errore!

Collegamento finale

Da D0 a D7, RS, EN e RW. D0-D7 sono i pin che memorizzano i valori inviati al display. Il pin RS dice al controller se visualizzeremo dei dati (ad esempio un carattere ASCII) o se si tratta di un byte di controllo (ad esempio cambiando la posizione del cursore). Il pin EN è l'abbreviazione di "abilita" e con questo pin comunichiamo al display LCD quando i dati sono pronti per essere letti. Il pin RW viene utilizzato per impostare la direzione: vogliamo visualizzare (di solito) o leggere (usati meno comunemente) i dati dal display.

Non tutti questi pin devono essere collegati ad Arduino. Ad esempio non è necessario utilizzare RW se stiamo solo visualizzando i dati sullo schermo, quindi è sufficiente “tirarlo su” al pin Gnd. Inoltre, è possibile comunicare con lo schermo LCD utilizzando 4 pin anziché 8. Probabilmente sorge spontanea una domanda: in quali casi vengono utilizzati 8 pin? Ciò molto probabilmente influisce sulla velocità di trasferimento dei dati. Cioè, utilizzando 8 contatti invece di 4, puoi aumentare la velocità di scambio delle informazioni di 2 volte. In questo caso la velocità non è importante, quindi utilizziamo 4 pin per collegare il display LCD ad Arduino.

Quindi, abbiamo bisogno di 6 pin: RS, EN, D7, D6, D5 e D4.

Per lavorare con lo schermo LCD, utilizzeremo la libreria LiquidCrystal, che semplifica notevolmente il processo di impostazione dei pin. Uno dei vantaggi di questa libreria è che puoi utilizzare qualsiasi pin dell'Arduino per collegare i pin dell'LCD. Quindi, alla fine di questa guida sarai in grado di sostituire facilmente i contatti se sono fondamentali per il tuo progetto.

Collegamento finale del display

	Spiegazioni
	Come accennato in precedenza, non utilizzeremo il pin RW, quindi lo collegheremo a terra. Questo è il perno 5.
	Quindi colleghiamo RS: questo è il pin n. 4. Usiamo il filo marrone per collegarlo al pin digitale n. 7 su Arduino.
	Utilizzare un filo bianco per collegare il pin EN - pin n. 6 al pin digitale n. 8 su Arduino.
	Ora è il momento dei contatti dati. DB7 è il pin n. 14 sul display LCD. È collegato con un filo arancione al pin n. 12 di Arduino.
	Sono rimasti tre pin dati, DB6 (pin n. 13 giallo), DB5 (pin n. 12 verde) e DB4 (pin n. 11 blu). Si collegano rispettivamente ai pin n. 11, 10 e 9 di Arduino.
	Come risultato della connessione, otterrai qualcosa di simile alla foto a sinistra.

Usiamo un LCD a caratteri

È ora di caricare lo schizzo su Arduino per controllare lo schermo LCD. La libreria LiquidCrystal è installata nell'IDE Arduino per impostazione predefinita. Quindi dobbiamo solo scaricare uno degli esempi e modificarlo leggermente in base ai pin che abbiamo utilizzato per connetterci.

Apri lo schizzo File→Esempi→LiquidCrystal→HelloWorld.

Aggiorniamo le informazioni sui pin. Stiamo cercando la seguente riga:

LCD a cristalli liquidi (12, 11, 5, 4, 3, 2);

E cambialo in:

Ora puoi compilare e caricare lo schizzo su Arduino.

Se necessario, regolare il contrasto

Naturalmente è possibile utilizzare il display LCD con qualsiasi dimensione. Ad esempio, la foto qui sotto mostra Funzionamento dell'LCD 20×4.

Oppure testo nero su sfondo verde:

Uno dei vantaggi degli schermi con testo nero su sfondo verde è la possibilità di disattivare la retroilluminazione.

Usiamo quante righe

Capiamo come lo schermo LCD gestisce i messaggi lunghi e le righe multiple. Ad esempio, se modifichi la seguente riga:

lcd.print("ciao mondo!");

Al successivo:

lcd.print("ciao mondo! questo è un messaggio molto lungo");

Display LCD 16x2 troncherà tutto dopo il 16° carattere:

Ma il display LCD 20x4 porterà i caratteri non visualizzati dalla prima riga alla terza (la seconda riga continuerà fino alla quarta). Non è molto conveniente, ma in questa fase dovrai sopportarlo. Pertanto, quando visualizzi stringhe lunghe, conta i caratteri in modo da non superare la lunghezza consentita.

LCD con retroilluminazione RGB

Questi schermi funzionano come gli schermi normali, ma sono presenti tre LED (rosso, verde, blu) per la retroilluminazione, quindi puoi utilizzare diversi colori di retroilluminazione.

Dopo aver collegato il display LCD e averlo controllato secondo le istruzioni sopra, collega i LED ai pin analogici PWM del tuo Arduino per ottimizzare i colori. Se stai usando ArduinoUno, dovrebbero rimanere tre contatti PWM liberi. collegare il LED rosso (pin 16 sul display LCD) a Digital 3, LED verde(pin 17) - a Digital 5 e il LED blu (pin 18 sul display LCD) - a Digital 6. Il modulo LCD è già dotato di resistori, quindi non è necessario collegarne di aggiuntivi.

Ora carica lo schizzo seguente sul tuo Arduino.

// includi le librerie nello sketch:

#includere

#includere

#definire REDLITE 3

#definire GREENLITE 5

#definireBLUELITE 6

// dichiara il numero di contatti che utilizziamo

// per il trasferimento dei dati

LCD a cristalli liquidi (7, 8, 9, 10, 11, 12);

// la luminosità può essere modificata nell'intervallo 0 -> 255

luminosità intera = 255;

// imposta il numero di colonne e righe sul display LCD:

lcd.inizio(16, 2);

// visualizza il messaggio sul display LCD.

lcd.print("Schermo RGB 16x2 ");

lcd.setCursore(0,1);

lcd.print("LCD multicolore");

pinMode(REDLITE, USCITA);

pinMode(GREENLITE, USCITA);

pinMode(BLUELITE, USCITA);

luminosità = 100;

for (int i = 0; i< 255; i++) {

setBacklight(i, 0, 255-i);

for (int i = 0; i< 255; i++) {

setBacklight(255-i, i, 0);

for (int i = 0; i< 255; i++) {

setBacklight(0, 255-i, i);

void setBacklight(uint8_t r, uint8_t g, uint8_t b) (

// imposta il LED rosso: è più luminoso degli altri!

r = mappa(r, 0, 255, 0, 100);

g = mappa(g, 0, 255, 0, 150);

r = mappa(r, 0, 255, 0, luminosità);

g = mappa(g, 0, 255, 0, luminosità);

b = mappa(b, 0, 255, 0, luminosità);

// anodo comune, quindi invertisci!

r = mappa(r, 0, 255, 255, 0);

g = mappa(g, 0, 255, 255, 0);

b = mappa(b, 0, 255, 255, 0);

Serial.print("R = "); Serial.print(r, DEC);

Serial.print(" G = "); Serial.print(g, DEC);

Serial.print(" B = "); Serial.println(b, DEC);

analogWrite(REDLITE, r);

analogWrite(GREENLITE, g);

analogWrite(BLUELITE, b);

Il risultato di questo schizzo è mostrato nel video qui sotto.

comando createChar

Probabilmente vorrai usare caratteri speciali. Ad esempio, se stai progettando un progetto utilizzando un sensore di temperatura (), il simbolo (°) ti tornerà utile.

Ciò può essere ottenuto utilizzando il comando createChar. In alternativa, potresti trovare un ottimo sito web che farà tutto il lavoro sporco di creare nuovi simboli per te!

Lascia i tuoi commenti, domande e condividi esperienza personale sotto. Spesso dalle discussioni nascono nuove idee e progetti!

Come collegare una scheda Arduino con un display a caratteri? Abbastanza semplice! Di seguito è tutto in ordine e con i dettagli.

Se desideri ricevere informazioni da Arduino senza collegarti a un computer e inviarle a una porta seriale, puoi utilizzare un display a caratteri. Non è così difficile da fare. La comodità ottenuta dalla comunicazione è inestimabile.
Per lavoro ho utilizzato un display LCD a caratteri J204A basato sul chip HD44780, spesso reperibile su eBay come LCD2004. 4 righe da 20 caratteri, invertite. Comprato insieme ad altri su eBay, per pochi centesimi, da 60 a 100 rubli l'uno. La lingua russa non è supportata per impostazione predefinita, ma questo è un problema risolvibile, ne parleremo la prossima volta. E i connettori nello schema non sono saldati, dovrai lavorare con un saldatore.
La libreria viene utilizzata per lavorare con i display LiquidCrystal.h incluso nell'IDE Arduino predefinito.

Ma non ho trovato una scheda tecnica per il display LCD2004, ma Internet è piena di tabelle di visualizzazione. Ma non sono praticamente diversi l'uno dall'altro. I controlli e le connessioni sono completamente identici. L'unica differenza è il numero di righe/caratteri sul display. Ma questo non avrà assolutamente alcun effetto se hai 1602.

Tutti i contatti sono definiti nella tabella. Se prendi il display e lo giri verso di te, i contatti verranno posizionati rispettivamente da sinistra a destra, nella tabella sono elencati in ordine numerico crescente. Nella colonna contatti la designazione presente nella scheda tecnica è indicata tra parentesi.

#	Contatti	A cosa serve?	Nota
1	VSS (VSS)	TERRA. Terra. Alimentazione per microcontrollore display.	0 V
2	VDD(VCC)	Tensione di alimentazione per il microcontrollore del display.	+5V
3	V0(VEE)	Contrasto dei caratteri sul display. È meglio connettersi tramite un potenziometro.	da 0V a +5V
4	RS (RS)	Selezione del registro.
5	LS (R/S)	Commutazione modalità lettura/scrittura. Tiriamolo a terra, dobbiamo solo trasmettere le informazioni al display.	0-scrittura +5V-lettura
6	E	Cronometraggio
7	D0 (DB0)		Dati
8	D1 (DB1)	Trasferimento dati. (Non lo useremo)	Dati
9	D2 (DB2)	Trasferimento dati. (Non lo useremo)	Dati
10	D3 (DB3)	Trasferimento dati. (Non lo useremo)	Dati
11	D4 (DB4)		Dati
12	D5 (DB5)	Trasferimento dati. (Attivato)	Dati
13	D6 (DB6)	Trasferimento dati. (Attivato)	Dati
14	D7 (DB7)	Trasferimento dati. (Attivato)	Dati
15	A (LED+)	+5V Voltaggio, retroilluminazione del display, luminosità del display regolabile tramite potenziometro.	+5V
16	K(LED-)	GND Terra, retroilluminazione del display	0 V

v

La trasmissione dei dati al display è possibile in due opzioni: 8 e 4 bit per clock. Perché Arduino ha pochi contatti, ne useremo 4: questo è più che sufficiente per aggiornare le informazioni sul display a una velocità proibitiva per la percezione.

Ecco come l'intera faccenda è collegata a me. Può sembrare caos, ma qui c'è un sistema. È possibile distinguere i fili rosso, verde, giallo e arancione. Quelli rossi vanno sempre a +5V, quelli verdi a GND, e quelli gialli e arancioni sono i fili per il collegamento ad Arduino, che trasportano i dati.

La parte più importante è la connessione fisica del display. Cliccando si apre in alta risoluzione, dove tutto è ben visibile.
R1 - Resistenza da 200OM. La resistenza limita la corrente che passa attraverso la retroilluminazione del display.
R2 - Potenziometro con resistenza fino a 10kOM. Giriamo la penna e selezioniamo il contrasto dei simboli.

E uno schizzo estremamente semplice per visualizzare un paio di righe sullo schermo.

H> // Colleghiamo la libreria per lavorare con il display. /* Comando LiquidCrystal lcd(rs, abilita, d4, d5, d6, d7); Creiamo una variabile di tipo LiquidCrystal e determiniamo attraverso quali contatti Arduino funziona con il display. maggiori dettagli su questo comando qui http://arduino.cc/en/Reference/LiquidCrystalConstructor */ LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() ( lcd.begin(20, 4); // determina le caratteristiche del display (20 caratteri per riga, 4 righe) // Per il display 1602 è necessario specificare lcd.begin(16, 2); lcd .setCursor(1, 1); // Specifica da quale posizione iniziare a visualizzare il testo Le righe e i caratteri iniziano da 0!!! // 1 sposterà già il carrello di una divisione dall'inizio dello schermo e sposterà il testo di una riga sotto lcd.print("compblog.vlukyanov" ); // stampa il testo a partire dalla posizione specificata lcd.setCursor(7, 2) // stampa dall'ottavo carattere sullo schermo lcd.print(".com "); // testo da stampare. loop() ( // non facciamo nient'altro nel loop; tutto è già stato fatto durante l'inizializzazione della scheda. )

Risultato. Se sai come tutto si collega e come scrivere il codice, il tempo per tutto il lavoro è di 5 minuti.

Il display può eseguire alcune funzioni anche in maniera indipendente, ed è inoltre possibile impostare alcuni parametri.

Per esempio:

• Scorri il testo;
• Posizione del cursore flash;
• Accendi/spegni.

E ora il bonus!
La retroilluminazione del display spreca energia che, ad esempio, se alimentato da una batteria, vorresti risparmiare. Ho creato questa opzione per me: quando premi il pulsante, la retroilluminazione del display si accende per 5 secondi.

H> // Colleghiamo la libreria per lavorare con il display. int pulsanteInt = 0; // Numero dell'interrupt che verrà chiamato. schermoLed int = 4; // Numero del pin a cui è collegato lo schermo. +5V volatile lungo x = 5000; // variabile per la memorizzazione del tempo LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup attach() (Interrupt(buttonInt, screenon, FALLING); // parametri di interruzione lcd.begin(20, 4); pinMode(screenLed, OUTPUT); digitalWrite(screenLed,HIGH); // accende il display lcd. setCursor(0, 0); lcd.print("Inizia il test dello schermo!"); void screenon() ( x = millis()+5000; // Ricorda l'ora in cui è necessario spegnere la retroilluminazione. Tempo di funzionamento attuale +5 secondi. digitalWrite(screenLed,HIGH); // Applica tensione alla retroilluminazione del display. ) void loop() ( lcd.setCursor(0, 2); // vai alla terza riga lcd.print(x); // e visualizza l'ora in cui il display si spegne lcd.setCursor(0, 3); / / vai alla quarta riga lcd.print(millis()); // stampa il tempo di funzionamento corrente if (x< millis()) // если время работы выключения наступило >( digitalWrite(screenLed,LOW); // quindi spegne il display) )

E il risultato: