Funziona con display grafico 1602 in arduino. LCD WH1602B di Winstar. Controllo dello schermo LCD tramite bus I2C
Era arrivato Arduino Nano, è arrivato un kit contenente una breadboard e un display LCD. Il display sulla scheda dice - 1602A, sotto - QAPASS. Ho iniziato a scolpire il primo dispositivo e, ovviamente, volevo visualizzare le informazioni sul display e non i LED lampeggianti.
Google mi ha aiutato, mi ha detto che si tratta di una visualizzazione dei caratteri; Se non lo distorci, molto probabilmente sono disponibili caratteri ASCII: numeri, latino, alcuni dei caratteri di base.
I seguenti materiali hanno contribuito al lancio del display: Guidare un display LCD a caratteri dalla porta di una stampante del PC; Come collegare Arduino con un LCD a caratteri; PDF Controllo motore servoazionamento Pwm.
Il display è abbastanza comune e per questo sono già stati inventati gli scudi: ci sono opzioni con SPI, come, e/o con I2C, e Internet è piena di ricette per questi casi. Ma avevo solo il display originale 16x2 e l'Arduino a cui volevo collegarlo.
Il display ha una modalità di funzionamento e trasmissione dati in nibble, 4 bit ciascuno, mentre i bit meno significativi del bus non vengono utilizzati. Il collegamento di solo metà del bus dati è descritto in molti punti e non ho capito come collegare il display e lavorare con esso su 8 righe. Sono abbastanza soddisfatto di come funziona.
Buona descrizione dei display di questo tipo L'ho trovato qui: http://greathard.ucoz.com/44780_rus.pdf. E qui (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) c'è un esempio di specifica di un generatore di caratteri.
Connessione
Il mio display è arrivato con contatti dissaldati. Fin dall'inizio volevo saldare il cavo, tagliare 16 fili con dupont e pulirli. E poi ho scavato nella balena e ho trovato un pettine DuPont da saldare alla scheda. Da lì ho interrotto 16 contatti e li ho saldati.Il mio display assomigliava a questo (prima di saldare i contatti):
Per prima cosa ho collegato il pin 15 (A) a +5V, 16 (K) a terra e mi sono assicurato che la retroilluminazione funzionasse. In generale è corretto collegare il catodo a massa tramite una resistenza da 220 Ohm, come poi ho fatto io.
Quindi ho collegato la terra (1) e l'alimentazione (2). Arduino può essere alimentato da USB, da una tensione stabilizzata di 5V e da una non stabilizzata 6-12V, viene selezionata automaticamente la tensione più alta. Ora Arduino è alimentato tramite USB e mi chiedevo dove prendere 5 Volt. Si è scoperto che 5 V sono sul pin Arduino, dove è collegato 5 V stabilizzato esterno. O meglio, si è scoperto che erano 4,7 V, ma mi è bastato.
Dopo aver collegato l'alimentazione, se tutto va bene, la riga superiore si illumina con solidi rettangoli di familiarità.
Quindi colleghiamo il potenziometro del contrasto (pin 3 V0). Gettiamo a terra uno dei terminali estremi del potenziometro, il secondo a +5V, quello centrale al pin 3 del display. Si consiglia un potenziometro da 10K. Avevo 50K dalla balena, l'ho usato per primo. La regolazione è avvenuta solo su un bordo; è stato necessario catturare in modo molto sottile il contrasto desiderato. Poi ne ho trovato uno simile a 5K in un'altra balena e l'ho installato. L'impostazione si estendeva da un bordo a mezzo giro. Apparentemente, puoi prendere un potenziometro ancora più piccolo. Probabilmente è consigliato 10K in modo che il circuito consumi meno. Sì, ho dovuto fare un po' di saldatura; ho saldato i fili con dupont ai terminali dei potenziometri.
Schizzo di prova
Prendiamo lo schizzo di prova dagli esempi di Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", dobbiamo solo cambiare i contatti con i nostri - LiquidCrystal lcd( 7, 6, 5, 4, 3, 2);In linea di principio, questo schizzo contiene anche una descrizione di cosa collegare e dove. Puoi collegarlo come indicato lì, quindi non è necessario modificare nulla.
// include il codice della libreria: #include
Risulta qualcosa del genere: 
A proposito, il display che mi è capitato tra le mani non funziona senza retroilluminazione. Voglio dire, funziona, ma difficilmente riesci a vedere nulla.
Contatti display 1602A
| # contatto | Nome | Come connettere |
|---|---|---|
| 1 | VSS | GND |
| 2 | VDD | +5V |
| 3 | V0 | Contrasto: al terminale centrale del potenziometro |
| 4 | RS (selezione registro) | D7Arduino |
| 5 | R/W (lettura o scrittura) | GND |
| 6 | E (Abilita segnale) | D6Arduino |
| 7-14 | D0-D7 | D0-D3 - non connesso; D4-D7 - collegato ai pin D5-D2 di Arduino |
| 15 | UN | Anodo di retroilluminazione, collegato a +5V |
| 16 | K | Catodo di retroilluminazione, collegato a terra tramite una resistenza da 220 Ohm |
L'articolo parla di come collegare correttamente un LCD ad Arduino, tutto quello che devi sapere sul collegamento di LCD 1602 e LCD i2c è coperto.
I display LCD di 1602 dimensioni, creati sulla base del controller HD44780, rimangono ancora oggi uno dei più convenienti, semplici e richiesti per lo sviluppo di qualsiasi tipo di dispositivo elettronico.
Non sorprende che possano essere visti sia in semplici unità assemblate letteralmente sul ginocchio, sia in quelle industriali più serie, ad esempio le macchine da caffè. È con questo display che vengono assemblati i moduli e gli scudi più popolari relativi ad Arduino, ad esempio il modulo LCD I2C e lo schermo per tastiera LCD.
Nei passaggi successivi vi racconteremo nel dettaglio con immagini come collegare il display LCD ad Arduino e visualizzare sul display le informazioni necessarie.
Passaggio 2. LCD 1602 per Arduino
I display 1602 sono disponibili in due diversi design:
- retroilluminazione gialla con lettere nere
- oppure (questo accade molto più spesso) retroilluminazione blu con retroilluminazione bianca.
La dimensione dei display sul controller HD44780 varia notevolmente, ma vengono controllati allo stesso modo. Le dimensioni più comuni sono 16 x 02 (ovvero 16 caratteri su due righe) o 20 x 04. I caratteri stessi hanno una risoluzione di 5 x 8 pixel.
La maggior parte dei display non supporta il cirillico (ad eccezione dei display contrassegnati con CTK). Ma questo problema è parzialmente risolvibile e l'articolo descrive ulteriormente in dettaglio come farlo.
Il display dispone di un connettore a 16 PIN per il collegamento. I pin sono contrassegnati sul retro della scheda, è il seguente:
- 1 (VSS) – alimentazione negativa per il controller.
- 2 (VDD) – alimentazione positiva per il controller.
- 3 (VO) – impostazioni di controllo del contrasto.
- 4 (RS) – selezione del registro.
- 5 (R/W) – lettura e scrittura, in particolare scrittura quando collegato a terra.
- 6 (E) – attivazione (abilita).
- 7–10 (DB0-DB3) – bit di ordine basso dall'interfaccia a otto bit.
- 11–14 (DB4-DB7) – bit più significativi dall'interfaccia
- 15 (A) – anodo positivo per alimentazione retroilluminazione.
- 16 (K) – catodo negativo per alimentazione retroilluminazione.
Passaggio 3. Collegare lo schermo LCD
Prima di collegare il display e trasferirvi le informazioni, vale la pena verificarne la funzionalità. Innanzitutto, applicare la tensione al controller VSS e VDD, accendere la retroilluminazione (A, K), quindi regolare il contrasto.
Per tali impostazioni è adatto un potenziometro da 10 kOhm, la sua forma non è importante. +5 V e GND vengono forniti ai piedini esterni e il piedino al centro è collegato al pin VO.
Quando viene fornita alimentazione al circuito, è necessario ottenere il contrasto necessario; se viene regolato in modo errato, l'immagine sullo schermo non sarà visibile. Per regolare il contrasto è necessario “giocare” con il potenziometro. Quando il circuito è assemblato correttamente e il contrasto è regolato correttamente, la riga superiore dello schermo dovrebbe essere riempita di rettangoli.
Per far funzionare il display viene utilizzata una libreria speciale integrata nell'ambiente IDE di Arduino, LiquidCrystal.h, di cui scriverò di seguito. Può funzionare in modalità 8 bit e 4 bit. Nella prima opzione vengono utilizzati solo i bit meno significativi e quelli più significativi ( BB0-DB7), nella seconda – solo i più giovani ( BB4-DB7).
Ma utilizzare la modalità a 8 bit in questo display è una decisione sbagliata; non c'è quasi alcun vantaggio in termini di velocità, poiché la frequenza di aggiornamento è sempre inferiore a 10 volte al secondo. Per visualizzare il testo, è necessario collegare i pin DB7, DB6, DB5, DB4, E e RS ai pin del controller. Possono essere collegati a qualsiasi pin Arduino, l'importante è impostare la sequenza corretta nel codice.
Se il simbolo richiesto non è ancora nella memoria del controller, è possibile definirlo manualmente (fino a sette simboli in totale). La cella dei display in esame ha un'estensione di cinque per otto pixel. Il compito di creare un simbolo è scrivere una maschera di bit e posizionare gli uno nei punti in cui i punti dovrebbero essere illuminati e gli zeri dove non dovrebbero. Lo schema di collegamento discusso sopra non è sempre corretto, poiché su Arduino vengono utilizzate almeno sei uscite digitali.
Passaggio 4. Schema di bypass
Esploriamo un'opzione per aggirare questo problema e cavarcela solo con due. Abbiamo bisogno di un modulo convertitore aggiuntivo da LCD a IIC/I2C. Come è saldato al display e collegato ad Arduino può essere visto nelle immagini sottostanti.
Ma questa opzione di connessione funziona solo con una libreria speciale, LiquidCrystal_I2C1602V1, che però è facile da trovare su Internet e da installare, dopodiché è possibile utilizzarla senza problemi.
Passaggio 4: libreria LiquidCrystal.h
La libreria LiquidCrystal.h può essere scaricata dalla sezione Librerie del nostro sito web in questa pagina o dalla risorsa ufficiale arduino.cc. Ma puoi anche scaricarlo dai link sottostanti:
Passaggio 5. Schizzo (codice programma)
Una volta scaricato l'archivio, sostituisci la cartella LiquidCrystal nella cartella delle librerie della directory di installazione di Arduino.
Puoi vedere uno schizzo di esempio su:
File -> Esempi -> LiquidCrystal -> HelloWorld_SPI
Oppure, se hai un menu in inglese:
File -> Esempi -> LiquidCrystal -> HelloWorld_SPI
Questo conclude la nostra prossima lezione. Vi auguriamo progetti di qualità!
display LCD– un ospite frequente nei progetti Arduino. Ma nei circuiti complessi, potremmo avere il problema della mancanza di porte Arduino a causa della necessità di collegare uno schermo che ha molti, molti pin. La soluzione in questa situazione potrebbe essere I2C/IIC un adattatore che collega uno scudo Arduino 1602 quasi standard alle schede Uno, Nano o Mega utilizzando solo 4 pin. In questo articolo vedremo come collegare uno schermo LCD con un'interfaccia I2C, quali librerie è possibile utilizzare, scriveremo un breve schizzo di esempio e esamineremo gli errori comuni.
Schermo a cristalli liquidi LCD1602È bella scelta per produrre stringhe di caratteri in vari progetti. È economico, ci sono varie modifiche con diversi colori di retroilluminazione, puoi facilmente scaricare librerie già pronte per gli schizzi di Arduino. Ma lo svantaggio principale di questo schermo è il fatto che il display ha 16 pin digitali, di cui ne sono necessari almeno 6. Pertanto, l'utilizzo di questo schermo LCD senza i2c aggiunge gravi restrizioni per le schede Arduino Uno o Nano. Se i contatti non sono sufficienti, dovrai acquistare una scheda Arduino Mega o salvare i contatti, anche collegando il display tramite i2c.
Breve descrizione del display LCD 1602 pin
Diamo uno sguardo più da vicino ai pin LCD1602:
Ciascuno dei perni ha il suo scopo:
- Terra GND;
- Alimentazione 5 V;
- Impostazione del contrasto del monitor;
- Comando, dati;
- Scrittura e lettura di dati;
- Abilitare;
7-14. Linee dati;
- Inoltre retroilluminazione;
- Meno la retroilluminazione.
Specifiche dello schermo:
- Tipo di visualizzazione dei caratteri, è possibile caricare simboli;
- Luci a LED;
- Controllore HD44780;
- Tensione di alimentazione 5V;
- Formato 16x2 caratteri;
- Intervallo di temperatura operativa da -20°C a +70°C, intervallo di temperatura di stoccaggio da -30°C a +80°C;
- Angolo di visione 180 gradi.
Schema di collegamento dell'LCD alla scheda Arduino senza i2C
Lo schema standard per collegare un monitor direttamente a un microcontrollore Arduino senza I2C è il seguente.
A causa dell'elevato numero di contatti collegati, potrebbe non esserci spazio sufficiente per collegare gli elementi necessari. L'uso di I2C riduce il numero di fili a 4 e i pin occupati a 2.
Dove acquistare schermi LCD e schermature per Arduino
Lo schermo LCD 1602 (e la versione 2004) è piuttosto popolare, quindi puoi trovarlo facilmente sia nei negozi online nazionali che su siti stranieri. Di seguito sono riportati alcuni collegamenti alle opzioni più disponibili:
 Modulo schermata blu LCD1602+I2C, compatibile con Arduino
|
 Un semplice display LCD1602 (retroilluminazione verde) costa meno di 80 rubli
|
 Ampio schermo LCD2004 con I2C HD44780 per Arduino (retroilluminazione blu e verde)
|
 Display 1602 con adattatore IIC e retroilluminazione blu
|
 Un'altra versione di LCD1602 con un modulo I2C saldato
|
 Modulo adattatore porta IIC/I2C/TWI/SPI per scudo 1602, compatibile con Arduino
|
 Display retroilluminato RGB! LCD 16×2 + tastiera + Buzzer Shield per Arduino
|
 Shield per Arduino con pulsanti e schermo LCD1602 LCD 1602
|
 Display LCD per stampante 3D (Smart Controller for RAMPS 1.4, Text LCD 20×4), modulo lettore di schede SD e MicroSD
|
Descrizione del protocollo I2C
Prima di parlare del collegamento del display ad Arduino tramite un adattatore i2c, parliamo brevemente del protocollo i2C stesso.
I2C/IIC(Inter-Integrated Circuit) è un protocollo originariamente creato per la comunicazione circuiti integrati dentro dispositivo elettronico. Lo sviluppo appartiene a Philips. Il protocollo i2c si basa sull'utilizzo di un bus a 8 bit, necessario per comunicare i blocchi dell'elettronica di controllo, e di un sistema di indirizzamento, grazie al quale è possibile comunicare sugli stessi cavi con più dispositivi. Trasferiamo semplicemente i dati all'uno o all'altro dispositivo, aggiungendo l'identificatore dell'elemento desiderato ai pacchetti di dati.
Più circuito semplice I2C può contenere un dispositivo master (molto spesso un microcontrollore Arduino) e diversi slave (ad esempio un display LCD). Ogni dispositivo ha un indirizzo compreso tra 7 e 127. Non dovrebbero esserci due dispositivi con lo stesso indirizzo nello stesso circuito.
La scheda Arduino supporta i2c nell'hardware. È possibile utilizzare i pin A4 e A5 per connettere i dispositivi utilizzando questo protocollo.
Ci sono diversi vantaggi nel funzionamento I2C:
- Il funzionamento richiede solo 2 linee: SDA (linea dati) e SCL (linea di sincronizzazione).
- Collegamento di un gran numero di dispositivi leader.
- Tempi di sviluppo ridotti.
- È necessario un solo microcontrollore per controllare l'intero set di dispositivi.
- Il numero possibile di microcircuiti collegati a un bus è limitato solo dalla capacità massima.
- Elevato grado di sicurezza dei dati grazie a uno speciale filtro soppressore di sovratensioni integrato nei circuiti.
- Una procedura semplice per diagnosticare i guasti emergenti ed eseguire rapidamente il debug degli errori.
- Il bus è già integrato nell'Arduino stesso, quindi non è necessario sviluppare un'interfaccia bus aggiuntiva.
Screpolatura:
- C'è un limite capacitivo sulla linea: 400 pF.
- Difficile programmare un controller I2C se sul bus sono presenti più dispositivi diversi.
- Con un gran numero di dispositivi, diventa difficile isolare un guasto se uno di essi si abbassa erroneamente.
Modulo i2c per LCD 1602 Arduino
Il modo più rapido e conveniente per utilizzare un display i2c in Arduino è acquistare uno schermo già pronto con supporto del protocollo integrato. Ma non ce ne sono molti di questi schermi e non sono economici. Ma è già stato prodotto un numero enorme di schermi standard diversi. Pertanto, l'opzione più economica e popolare oggi è acquistare e utilizzare un modulo I2C separato, un adattatore simile a questo:
Su un lato del modulo vediamo i pin i2c: terra, alimentazione e 2 per il trasferimento dati. Sull'altro adattatore vediamo connettori di alimentazione esterni. E, naturalmente, la scheda ha molti pin con cui il modulo è saldato ai pin dello schermo standard.
Le uscite i2c vengono utilizzate per connettersi alla scheda Arduino. Se necessario, colleghiamo l'alimentazione esterna per la retroilluminazione. Con il trimmer integrato possiamo impostare valori di contrasto personalizzati J
In commercio si possono trovare moduli LCD 1602 con adattatori già saldati; il loro utilizzo è semplificato al massimo. Se hai acquistato un adattatore separato, dovrai prima saldarlo al modulo.
Collegamento dello schermo LCD ad Arduino tramite I2C
Per la connessione sono necessari la scheda Arduino stessa, un display, una breadboard, cavi di collegamento e un potenziometro.
Se utilizzi uno speciale adattatore i2c separato, devi prima saldarlo al modulo schermo. È difficile commettere un errore lì, puoi seguire questo schema.
Un monitor LCD con supporto i2c è collegato alla scheda tramite quattro fili: due fili per i dati, due fili per l'alimentazione.
- Il pin GND si collega a GND sulla scheda.
- Il pin VCC è a 5V.
- SCL si collega al pin A5.
- SDA è collegato al pin A.
E questo è tutto! Nessuna rete di fili, in cui è molto facile impigliarsi. Allo stesso tempo, possiamo semplicemente affidare alle biblioteche tutta la complessità dell’implementazione del protocollo i2C.
Librerie per lavorare con il display LCD i2c
Per interagire con Arduino e LCD 1602 tramite il bus I2C, avrai bisogno di almeno due librerie:
- La libreria Wire.h per lavorare con I2C è già inclusa nello standard Programma Arduino IDE.
- La libreria LiquidCrystal_I2C.h, che include un'ampia varietà di comandi per il controllo del monitor tramite il bus I2C e consente di rendere lo schizzo più semplice e breve. È necessario installare in aggiunta la libreria Dopo aver collegato il display, è necessario installare in aggiunta la libreria LiquidCrystal_I2C.h
Dopo aver collegato tutte le librerie necessarie allo schizzo, creiamo un oggetto e possiamo utilizzare tutte le sue funzioni. Per testare, carichiamo il seguente schizzo di esempio standard.
#includere
Descrizione delle funzioni e dei metodi della libreria LiquidCrystal_I2C:
- home() e clear(): la prima funzione consente di riportare il cursore all'inizio dello schermo, la seconda fa lo stesso, ma allo stesso tempo cancella tutto ciò che prima era sul monitor.
- write(ch) – consente di stampare un singolo carattere ch sullo schermo.
- cursor() e noCursor() – mostra/nasconde il cursore sullo schermo.
- flick() e noBlink() – il cursore lampeggia/non lampeggia (se la sua visualizzazione era abilitata in precedenza).
- display() e noDisplay() – consente di connettere/disattivare il display.
- scrollDisplayLeft() e scrollDisplayRight() – scorre lo schermo di un carattere a sinistra/destra.
- autoscroll() e noAutoscroll() – consente di abilitare/disabilitare la modalità di scorrimento automatico. In questa modalità ogni nuovo carattere viene scritto nello stesso posto, sostituendo ciò che era scritto precedentemente sullo schermo.
- leftToRight() e rightToLeft() – Impostazione della direzione del testo visualizzato: da sinistra a destra o da destra a sinistra.
- createChar(ch, bitmap) – crea un carattere con codice ch (0 – 7), utilizzando una serie di bitmap bitmap per creare punti bianchi e neri.
Libreria alternativa per lavorare con il display i2c
In alcuni casi potrebbero verificarsi errori quando si utilizza la libreria specificata con dispositivi dotati di controller PCF8574. In questo caso si può suggerire come alternativa la libreria LiquidCrystal_PCF8574.h. Estende LiquidCrystal_I2C, quindi non dovrebbero esserci problemi nell'usarlo.
Problemi di connessione del display LCD i2c
Se dopo aver caricato lo schizzo non vedi alcun messaggio sul display, prova i seguenti passaggi.
Innanzitutto, puoi aumentare o diminuire il contrasto del monitor. Spesso i caratteri semplicemente non sono visibili a causa del contrasto e della modalità di retroilluminazione.
Se ciò non aiuta, controlla se i contatti sono collegati correttamente e se l'alimentazione della retroilluminazione è collegata. Se hai utilizzato un adattatore i2c separato, controlla nuovamente la qualità della saldatura dei contatti.
Un altro motivo comune per la mancanza di testo sullo schermo potrebbe essere un indirizzo i2c errato. Per prima cosa prova a cambiare l'indirizzo del dispositivo nello sketch da 0x27 0x20 o a 0x3F. Produttori diversi potrebbero avere indirizzi predefiniti diversi programmati. Se questo non aiuta, puoi eseguire lo schizzo dello scanner i2c, che scansiona tutti i dispositivi collegati e determina il loro indirizzo usando la forza bruta. Un esempio di schizzo di uno scanner i2c.
Se lo schermo continua a non funzionare, prova a dissaldare l'adattatore e a collegare lo schermo LCD come al solito.
Conclusione
In questo articolo abbiamo esaminato i problemi principali legati all'utilizzo di uno schermo LCD in progetti Arduino complessi, quando è necessario salvare i pin liberi sulla scheda. Un adattatore i2c semplice ed economico ti consentirà di collegare uno schermo LCD 1602, occupando solo 2 pin analogici. In molte situazioni questo può essere molto importante. Il prezzo per comodità è la necessità di utilizzare un modulo aggiuntivo: un convertitore e una libreria. A nostro avviso, questo non è un prezzo elevato da pagare per comodità e consigliamo vivamente di utilizzare questa funzionalità nei progetti.
Cos'è parte integrante di un gran numero di dispositivi elettronici? Naturalmente mezzi di indicazione e di output grafico dei dati. È sempre più comodo e piacevole per l'utente quando il risultato della “smart box” può essere visto visivamente. Pertanto, oggi collegheremo un display all'STM32 per visualizzare testo e numeri. L'eroe dei nostri esperimenti sarà un display piuttosto popolare di Winstar. A proposito, nei commenti è apparso un importante chiarimento secondo cui la metodologia è sostanzialmente la stessa per tutti i display basati su HD44780. Grazie a JekaKey per l'importante aggiunta)
Innanzitutto, il display deve essere collegato al controller. Scarica la scheda tecnica e cerca il pinout WH1602. Guarda qui:
Come sapete, visualizzare WH1602 ha 16 pin. Diamo un'occhiata a ciascuno separatamente...
I pin Vss, Vdd e K vanno collegati a massa e all'alimentazione, cioè esattamente come indicato in tabella, non ci sono sorprese e nemmeno nulla da discutere)
Il pin numero 3 serve per regolare il contrasto: se applichiamo +5 V lì, non vedremo assolutamente nulla, e se cortocircuitiamo il pin a terra, ammireremo due file di quadrati neri 😉 Naturalmente questo non ci va bene , quindi dobbiamo appendere lì un potenziometro (resistore con resistenza variabile) per regolare il contrasto. La migliore visibilità dei caratteri è fornita da una tensione di 0,5-0,7 V su questo pin del display.
Il pin RS è già un pin che noi stessi controlleremo tramite un microcontrollore. Un livello di tensione basso (0) su questo pin significa che ora seguirà un comando, un livello alto (1) significa che ora ci saranno dati da scrivere nella memoria del display.
Pin R/W - qui è chiaro, o leggiamo i dati (display occupato, ad esempio), in questo caso c'è 1 su questo pin, oppure scriviamo il comando/dati sul display, quindi abbiamo 0 qui.
DB7 – DB0 – bus dati, e questo dice tutto)
Il pin E è il cosiddetto segnale di abilitazione. Questo è ciò per cui è necessario. Per lavorare con il display - registrare dati o emettere un comando - dobbiamo emettere un impulso positivo a questo pin. Cioè, la procedura sarà simile a questa:
- Sui pin RS, R/W, DB7 - DB0 - i segnali necessari corrispondenti al nostro comando.
- Ne forniamo uno al pin E.
- Zhdems (secondo la scheda tecnica – almeno 150 ns)
- Applichiamo un livello basso (0) al pin E.
È necessario inserire 4,2 V sul piedino A/V per alimentare la retroilluminazione del display.
Ecco come avviene la comunicazione con il display WH1602.
Abbiamo capito come collegare il WH1602, ma prima di passare all'esempio, diamo un'occhiata a quali comandi il nostro display generalmente comprende. Per fare ciò andiamo nel datasheet e troviamo una tabella interessante:
Qui sono descritti tutti i comandi e i segnali che dovrebbero trovarsi sui pin corrispondenti del WH1602 per ciascun comando specifico. Ad esempio, vogliamo cancellare il display, guardiamo la tabella ed ecco il comando che ci serve! Visualizzazione chiara!
Applichiamo zeri ai pin RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 e uno al pin DB0. Fatto! Qual è il prossimo passo? Esatto, uno sul pin E, quindi attendi un po' e abbassa nuovamente E a zero. Questo è tutto, il display si cancella 😉 Poco prima di eseguire il comando successivo è necessario fare una pausa, indicata nella scheda tecnica di ciascun comando. Sarebbe più efficace interrogare il flag di occupato; non appena viene reimpostato su 0, è possibile continuare a lavorare. C'è anche un comando speciale per leggere questa bandiera, quindi tutto è chiaro con questo) Andiamo avanti...
E, in effetti, tutto è con la teoria, puoi già provare a scrivere qualcosa. Per facilitare il lavoro con il display ho realizzato una piccola libreria, ora vediamo come può essere utilizzata. Innanzitutto, scarica
Otteniamo 2 file a nostra disposizione, MT_WH1602.c e MT_WH1602.h. Strappiamo il secondo, qui dobbiamo selezionare i pin e il controller utilizzato.
A proposito, il mio display è collegato in questo modo:
RS-PC2
R/W – PB10
E–PB14
DB7-PD2
DB6–PC12
DB5-PA8
DB4-PA10
DB3-PA15
DB2-PD11
DB1-PA3
DB0-PA5
Apri il file MT_WH1602.h:
| #define PIATTAFORMA (STM32F10x) |
Successivamente, seleziona i pin del microcontrollore a cui è collegato il display. Per prima cosa impostiamo quali porte utilizzare. Quando mi connetto utilizzo GPIOA, GPIOB, GPIOC e GPIOD, scriviamo:
Allo stesso modo per le altre gambe del microcontrollore.
Abbiamo finito con il setup, proseguiamo) Per richiamare i comandi dati all'inizio dell'articolo, il file MT_WH1602.c contiene le seguenti funzioni (prendono il nome dai nomi dei comandi, quindi penso che sia tutto chiaro) :
| void MT_WH1602_ClearDisplay(void) ; void MT_WH1602_ReturnHome(void) ; void MT_WH1602_EntryModeSet (bool IDindirizzo, bool shift) ; void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; void MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit) ; void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit) ; void MT_WH1602_SetCGRAMAddress (indirizzo uint8_t) ; void MT_WH1602_SetDDRAMAddress (indirizzo uint8_t) ; bool MT_WH1602_ReadBusy(void) ; void MT_WH1602_WriteData(uint8_t dati) ; |
Per alcuni comandi è necessario passare dei parametri alla funzione, ad esempio:
| void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; |
Diamo un'occhiata alla tabella dei comandi:
Vediamo che il comando Display ON/OFF non solo accende/spegne il display, ma attiva/disattiva anche il cursore e il suo lampeggiamento. Nel foglio dati, questi bit di comando sono designati come D, C e B e li passiamo come parametri alla funzione. Se dobbiamo accendere il display e il cursore, ma disabilitare il lampeggio del cursore, chiamiamo il comando come segue:
MT_WH1602_DisplayOnOff(1, 1, 0);
In generale, tutto è semplice 😉
In breve, creiamo nuovo progetto, aggiungi una libreria per lavorare con il display WH1602, crea un file .c vuoto e inizia a riempirlo con il codice:
| // Include il file della libreria#include "MT_WH1602.h" /*******************************************************************/ int principale(vuoto) ( // Chiama la funzione di inizializzazione, non possiamo farne a meno =)() ; // Ora dobbiamo effettuare la configurazione iniziale del display // La documentazione e Internet consigliano di farlo ;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000) ; MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000) ; MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000) ; MT_WH1602_ClearDisplay() ; MT_WH1602_Delay(2000) ; // Ad esempio ho preso i primi valori di ritardo che mi sono venuti in mente) // In generale, è necessario controllare il flag di occupato del display // Ora mostriamo qualcosa, come il nome del nostro sito MT_WH1602_WriteData(0x6D) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x6F) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x74) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x65) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x68) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x6E) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x73) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x2E) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Ritardo(100) ; MT_WH1602_WriteData(0x75) ; MT_WH1602_Ritardo(100) ; mentre (1) ( __NOP() ; ) ) /*******************************************************************/ |
Fatto, controlliamo) 
Come puoi vedere, tutto funziona correttamente)
A proposito, in qualche modo ho perso di vista la domanda su cosa scrivere sul display per visualizzare questo o quel carattere. Ecco la targa dal datasheet: 
Quindi, per determinare quale valore scrivere nella memoria del display, è necessario prendere i numeri scritti in alto e a sinistra in questa tabella per un simbolo specifico. Ad esempio, il simbolo "A". Vediamo: questo simbolo corrisponde alla colonna 0100 (0x4) e alla riga 0001 (0x1). Risulta che per visualizzare il simbolo “A” è necessario scrivere il valore 0x41 sul display.
Adesso è tutto =) Abbiamo sistemato il collegamento e il funzionamento del display WH1602, quindi a presto!
PS Quando lavoro con la libreria, non ho testato la funzione di lettura del flag di occupato, quindi se all'improvviso qualcosa non funziona come dovrebbe, scrivi, lo scopriremo)
A volte ci troviamo di fronte al problema di trasmettere varie informazioni da Arduino al mondo esterno. Spesso l'utilizzo di una porta seriale è impossibile, scomodo e non redditizio.
Un display a caratteri è uno dei mezzi più semplici ed economici per visualizzare le informazioni perché dispone di un proprio microcontrollore che memorizza i caratteri codificati. Questo sistema semplifica l'utilizzo di questi display, ma allo stesso tempo ne limita l'utilizzo al solo output informazioni di testo, a differenza dei display grafici.
Nell'esempio esamineremo il display Winstar wh1602l1, uno dei display più comuni sul controller hd44780. Inoltre è possibile collegare LCD 2004 e altri simili.
Le prime due cifre indicano il numero di caratteri per riga e la seconda il numero di righe, quindi il display selezionato ha 2 righe da 16 caratteri.
Questo metodo di connessione prevede l'occupazione di almeno 6 porte del microcontrollore Arduino. Se necessario è possibile collegare il display di testo 1602 tramite l'interfaccia I2C (2 porte).
Degli elementi aggiuntivi di cui abbiamo bisogno resistore variabile, per controllare il contrasto. Altrimenti tutto è collegato secondo lo schema, secondo la scheda tecnica e le uscite Arduino selezionate nel programma.
I pin 15 e 16 sul display sono responsabili della retroilluminazione; può essere disattivata o la luminosità può essere regolata automaticamente quando si collega una fotoresistenza ad Arduino come sensore di luminosità.
Nel nostro esempio leggeremo i dati dalla porta seriale e li visualizzeremo sul display:
#includere
Puoi complicare il codice e inviare l'orologio in tempo reale DS1307 su Arduino al tuo LCD1602.
Ora diamo uno sguardo più da vicino a tutte le funzioni della libreria Cristalli liquidi:
La prima e più importante cosa è che utilizzando questa libreria non è possibile visualizzare le lettere russe, anche se il display ha questi caratteri in memoria. Questo problema può essere risolto sia da altre librerie, sia scrivendo valori utilizzando il codice esadecimale.
lcd.stampa();- il più semplice e utilizzato più frequentemente, utilizzato per visualizzare le informazioni.
lcd. chiaro(); - utilizzato per pulire il display.
lcd.setCursor(X, sì); - posiziona il cursore in un punto specifico.
X – cambio di posizione nella linea
Y – cambio di linea
Ad esempio, lcd.setCursor(0, 0); questa è la cella in alto a sinistra.
lcd.casa(); - posiziona il cursore nella posizione 0, 0
lcd.casa(); = lcd.setCursor(0, 0);
lcd. scrollDisplayLeft(); - spostati a sinistra
lcd. scrollDisplayRight(); - sposta a destra
LCD.createChar(Nome, vettore); - creare il proprio segno.
Ad esempio, il segno di laurea assomiglia a questo:
Celc = (B00111, B00101, B00111, B00000, B00000, B00000, B00000, B00000 );
