//porta a cui è collegato il bus dati LCD
#define PORT_DATA PORTD
#definisci PIN_DATA PIN
#define DDRX_DATA DDRD

//porta a cui sono collegati i pin di controllo
#define PORT_SIG PORTB
#define PIN_SIG PINB
#define DDRX_SIG DDRB

// numeri pin del microcontrollore
//a cui sono collegati i pin di controllo LCD
#definisci RS 5
#definisci RW 6
#define IT 7

// macro per lavorare con i bit
#define ClearBit(reg, bit) reg &= (~(1<<(bit)))
#define SetBit(reg, bit) reg |= (1<<(bit))

#define F_CPU 8000000
#define _delay_us(us) __cicli_di_ritardo((F_CPU / 1000000) * (noi));
#define _delay_ms(ms) __cicli_di_ritardo((F_CPU / 1000) * (ms));

//funzione di immissione dei comandi
vuoto LcdWriteCom( carattere non firmato dati)
{
ClearBit(PORT_SIG, RS); // imposta RS a 0
PORT_DATA = dati; // invia i dati al bus
SetBit(PORT_SIG, EN); // imposta E su 1
_delay_us(2);
ClearBit(PORT_SIG, EN); // imposta E su 0
_delay_us(40);

//funzione di scrittura dei dati

ClearBit(PORT_SIG, EN); // imposta E su 0

delay_us(40);
}

int principale( vuoto )
{
mentre (1);
Restituzione 0;
}

Non ci sono posti complicati qui, tutto dovrebbe essere chiaro. Andare avanti.

Qualsiasi LCD deve essere inizializzato prima dell'uso. Il processo di inizializzazione è solitamente descritto nella scheda tecnica del controller video. Ma anche se non ci sono informazioni lì, è probabile che la sequenza sia così.

2. Attendere >40 ms

3. Diamo il comando Function set

DL– bit per impostare la larghezza del bus
Bus a 0 - 4 bit, bus a 1 - 8 bit

n– bit per impostare il numero di righe di visualizzazione
0 - modalità a linea singola, 1 - modalità a due linee

F- bit di impostazione del carattere
0 - formato 5*8, 1 - formato 5*11

* - non importa cosa ci sarà in questi bit

4. Dare il comando ON/OFF del display

D– Visualizza bit di abilitazione/disabilitazione
0 - display spento, 1 - display acceso

C– bit di abilitazione/disabilitazione del cursore
0 - cursore disabilitato, 1 - cursore abilitato

B– bit di abilitazione sfarfallio
0 - cursore lampeggiante abilitato, 1 - cursore lampeggiante disabilitato

5. Dare il comando Cancella visualizzazione

6. In attesa > 1,5 ms

7. Dare il comando Entry Mode Set

ID– ordine di incremento/decremento dell'indirizzo della DDRAM (visualizzazione dati RAM)
0 - il cursore si sposta a sinistra, l'indirizzo diminuisce di 1, 1 - il cursore si sposta a destra, l'indirizzo aumenta di 1

SH– ordine di spostamento dell'intero display
0 - nessuno spostamento, 1 - lo spostamento avviene in base al segnale I / D - se è 0 - il display si sposta a destra, 1 - il display si sposta a sinistra

Per il nostro esempio, la funzione di inizializzazione sarà simile a questa

I display LCD 1602, basati sul controller HD44780, sono uno dei display più semplici, convenienti e popolari per lo sviluppo di vari dispositivi elettronici. Si può trovare sia nei dispositivi a ginocchio che in dispositivi industriali, come ad esempio le macchine da caffè. Sulla base di questo display, i più popolari moduli e shield a tema Arduino, come e.

In questo articolo, ti diremo come collegarlo ad Arduino e visualizzare le informazioni.

Componenti utilizzati (acquista dalla Cina):

. pannello di controllo

. Fili di collegamento

Questi display sono disponibili in due versioni: retroilluminazione gialla con lettere nere o, più comunemente, retroilluminazione blu con lettere bianche.

Le dimensioni dei display sul controller HD44780 possono essere diverse, saranno controllati allo stesso modo. Le dimensioni più comuni sono 16x02 (cioè 16 caratteri su due righe) o 20x04. La risoluzione dei personaggi stessi è di 5x8 pixel.

La maggior parte dei display non ha il supporto cirillico, solo i display contrassegnati da CTK lo hanno. Ma questo problema può essere parzialmente risolto (continua nell'articolo).

Perni di visualizzazione:

Il display ha un connettore a 16 pin per la connessione. I pin sono contrassegnati sul retro della scheda.

1 (VSS) - Alimentazione controller (-)
2 (VDD) - Potenza controller (+)
3 (VO) - Uscita controllo contrasto
4 (RS) - Selezione registro
5 (R/W) - Lettura/Scrittura (modalità di scrittura quando connesso a terra)
6 (E) - Abilita (strobo in caduta)
7-10 (DB0-DB3) - LSB di interfaccia a 8 bit
11-14 (DB4-DB7) - Bit alti dell'interfaccia
15 (A) - Anodo (+) alimentazione retroilluminazione
16 (K) - Potenza della retroilluminazione del catodo (-).

Modalità di autotest:

Prima di provare a collegare e trasmettere informazioni, sarebbe bello sapere se il display funziona o meno. Per fare ciò, è necessario applicare la tensione al controller stesso ( VSS e VDD), accendere la retroilluminazione ( A e K) e regolare il contrasto.

Per regolare il contrasto, utilizzare un potenziometro da 10 kΩ. Quale sarà nella forma - non importa. +5V e GND sono forniti alle gambe estreme, la gamba centrale è collegata all'uscita VO

Dopo aver applicato l'alimentazione al circuito, è necessario ottenere il contrasto corretto, se non è impostato correttamente, sullo schermo non verrà visualizzato nulla. Per regolare il contrasto, dovresti giocare con il potenziometro.

Con il corretto assemblaggio del circuito e la corretta impostazione del contrasto, la riga superiore dello schermo dovrebbe essere riempita con rettangoli.

Output di informazioni:

Il display utilizza la libreria LiquidCrystal.h integrata nell'ambiente IDE Arduino.

Funzionalità della libreria

//Lavorare con il cursore lcd.setCursor(0, 0); // Imposta il cursore (numero di cella, riga) lcd.home(); // Imposta il cursore su zero (0, 0) lcd.cursore(); // Abilita la visibilità del cursore (sottolineato) lcd.noCursor(); // Rimuovi la visibilità del cursore (sottolineato) lcd.blink(); // Abilita cursore lampeggiante (cursore 5x8) lcd.noBlink(); // Disattiva il lampeggiamento del cursore (cursore 5x8) //Uscita delle informazioni lcd.print("sito"); // Output di informazioni lcd.clear(); // Cancella display, (cancella tutti i dati) imposta il cursore su zero lcd.rightToLeft(); // La scrittura viene eseguita da destra a sinistra lcd.leftToRight(); // La scrittura viene eseguita da sinistra a destra lcd.scrollDisplayRight(); // Sposta tutto sul display di un carattere a destra lcd.scrollDisplayLeft(); // Sposta tutto sul display di un carattere a sinistra //Informazioni utili per le spie :) lcd.noDisplay(); // Le informazioni sul display diventano invisibili, i dati non vengono cancellati // se, nel momento in cui questa funzione è attiva, non visualizza nulla, allora display LCD(); // Quando si chiama la funzione display(), il display ripristina tutte le informazioni che erano

Il display stesso può funzionare in due modalità:

Modalità a 8 bit: per questo vengono utilizzati sia i bit bassi che quelli alti (BB0-DB7)

Modalità a 4 bit: per questo vengono utilizzati solo i bit meno significativi (BB4-DB7)

L'uso della modalità a 8 bit su questo display non è pratico. Richiede 4 gambe in più per funzionare e praticamente non c'è guadagno di velocità. la frequenza di aggiornamento di questo display è limitata< 10раз в секунду.

Per emettere testo, è necessario collegare le uscite RS, E, DB4, DB5, DB6, DB7 alle uscite del controller. Possono essere collegati a qualsiasi pin Arduino, l'importante è impostare la sequenza corretta nel codice.

Esempio di codice di programma:

//Testato su Arduino IDE 1.0.5#includere // Aggiungiamo la libreria necessaria LCD a cristalli liquidi (7, 6, 5, 4, 3, 2); // (RS, E, DB4, DB5, DB6, DB7) vuoto impostare()( lcd.begin (16, 2); // Imposta la dimensione dello schermo lcd.setCursor(0, 0); // Posiziona il cursore all'inizio della riga 1 lcd.print("Ciao mondo!"); // Visualizza testo lcd.setCursor (0, 1); // Posiziona il cursore all'inizio della riga 2 lcd.print("sito"); // Testo visualizzato ) void ciclo continuo (){ }

Creare i propri simboli

Abbiamo capito l'output del testo, le lettere dell'alfabeto inglese sono cucite nella memoria del controller all'interno del display e non ci sono problemi con loro. Ma cosa fare se il carattere desiderato non è nella memoria del controller?

Istruzione

Il funzionamento del telemetro ad ultrasuoni HC-SR04 si basa sul principio dell'ecolocalizzazione. Emette impulsi sonori nello spazio e riceve il segnale riflesso dall'ostacolo. La distanza dall'oggetto è determinata dal tempo di propagazione dell'onda sonora all'ostacolo e viceversa.
L'inizio di un'onda sonora inizia con un impulso positivo con una durata di almeno 10 microsecondi sulla gamba TRIG del telemetro. Non appena l'impulso termina, il telemetro emette un'esplosione di impulsi sonori con una frequenza di 40 kHz nello spazio antistante. Allo stesso tempo, viene avviato l'algoritmo per determinare il tempo di ritardo del segnale riflesso e un'unità logica appare sulla gamba ECHO del telemetro. Non appena il sensore capta il segnale riflesso, sul pin ECHO compare uno zero logico. La durata di questo segnale ("Echo Delay" nella figura) determina la distanza dall'oggetto.
Il campo di misurazione della distanza del telemetro HC-SR04 è fino a 4 metri con una risoluzione di 0,3 cm L'angolo di osservazione è di 30 gradi, l'angolo effettivo è di 15 gradi. Consumo di corrente in modalità standby 2 mA, durante il funzionamento - 15 mA.

Il telemetro ad ultrasuoni è alimentato da +5 V. Gli altri due pin sono collegati a qualsiasi porta digitale Arduino, noi ci collegheremo a 11 e 12.

Ora scriviamo uno schizzo che determini la distanza dall'ostacolo e la emetta sulla porta seriale. Per prima cosa, impostiamo i numeri dei pin TRIG ed ECHO: questi sono i pin 12 e 11. Quindi dichiariamo il trigger come output e l'eco come input. Inizializziamo la porta seriale a 9600 baud. In ogni iterazione del ciclo ciclo continuo() leggiamo la distanza e la emettiamo alla porta.
Funzione getEchoTime() genera un impulso di avvio. Crea solo una corrente di 10 microsecondi un impulso, che è un trigger per il telemetro per iniziare a emettere un pacchetto di suoni nello spazio. Poi ricorda il tempo dall'inizio della trasmissione dell'onda sonora all'arrivo dell'eco.
Funzione getDistance() calcola la distanza dall'oggetto. Dal corso di fisica della scuola, ricordiamo che la distanza è uguale alla velocità per il tempo: S = V * t. La velocità del suono nell'aria è di 340 m/s, il tempo in microsecondi che conosciamo è "duratuion". Dividi per 1.000.000 per ottenere il tempo in secondi. Poiché il suono percorre il doppio della distanza - dall'oggetto e viceversa - è necessario dividere la distanza a metà. Quindi risulta che la distanza dall'oggetto è S = 34000 cm/sec * durata / 1.000.000 sec / 2 = 1,7 cm/sec / 100, che è quello che abbiamo scritto nello schizzo. Il microcontrollore esegue l'operazione di moltiplicazione più velocemente della divisione, quindi ho sostituito "/ 100" con l'equivalente "* 0.01".

Inoltre, molte librerie sono state scritte per funzionare con un telemetro a ultrasuoni. Ad esempio, questo: http://robocraft.ru/files/sensors/Ultrasonic/HC-SR04/ultrasonic-HC-SR04.zip. La libreria viene installata in un modo standard: scarica, decomprimi in una directory biblioteche, che si trova nella cartella Arduino IDE. Successivamente, è possibile utilizzare la libreria.
Dopo aver installato la libreria, scriviamo un nuovo sketch. Il risultato del suo lavoro è lo stesso: la distanza dall'oggetto in centimetri viene visualizzata nel monitor della porta seriale. Se nello schizzo scrivi float dist_cm = ultrasonico.Range(INC);, la distanza verrà visualizzata in pollici.

Quindi, abbiamo collegato un telemetro ad ultrasuoni HC-SR04 ad Arduino e ne abbiamo ricevuto i dati in due modi diversi: utilizzando una libreria speciale e senza.
Il vantaggio dell'utilizzo della libreria è che la quantità di codice è notevolmente ridotta e la leggibilità del programma è migliorata, non è necessario approfondire le complessità del dispositivo e puoi utilizzarlo immediatamente. Ma questo è anche uno svantaggio: hai una comprensione più scarsa di come funziona il dispositivo e quali processi avvengono al suo interno. In ogni caso, quale metodo utilizzare dipende da te.

Oggi proveremo a soffermarci sull'output in una visualizzazione di testo. Il più popolare è il chip HD44780 (o compatibile con KS0066). Elenchiamo i loro pro e contro:

Professionisti:

1. Prezzo basso.
2. Facile da programmare, il codice sarà lo stesso per qualsiasi modello.
3. Varietà di modelli: i più comuni: 8x1, 16x2, 20x4. 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.

Svantaggi:

1. Non tutti i display supportano i caratteri russi. Per maggiori dettagli, vedere la descrizione di una visualizzazione specifica.
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.

Proviamo.

Ciò che ci serve.

1. Arduino (ho preso il modello Nano)
2. Display su chip HD44780 con o senza modulo I2C (quindi è necessaria una scheda IIC LC1602 separata) - nel nostro caso 16x2 senza modulo I2C
3. Resistenza da 10 K (se è necessario il controllo manuale della retroilluminazione).
4. Potenziometro (se è necessario il controllo manuale della retroilluminazione).
5. Tagliere tagliere.
6. Libreria LiquidCrystal_I2C. http://www.ansealk.ru/files/LiquidCrystal_V1.2.1.zip

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

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

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

I pin SCL, SDA, VCC, GND sono usati per collegare Arduino. I due contatti a sinistra - nella foto sono chiusi con un ponticello - sono necessari 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, il primo e il 16 pin sono etichettati. A volte capita che i contatti 15-16, attraverso i quali viene controllata la retroilluminazione, possano trovarsi prima del primo (in questo caso saranno numerati). Sul modulo stesso, il primo pin può anche essere indicato non da un numero, ma da un quadrato attorno al pin stesso.

Schema:

Mettiamo insieme il seguente diagramma:

Attirerò la vostra attenzione sui seguenti punti:

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

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

Ora analizziamo il codice.

Qui, quasi tutto dovrebbe esserci familiare. Nella riga 5 indichiamo l'indirizzo del dispositivo. Sulle righe 16 e 17, il numero di caratteri per riga e il numero di righe. Nelle righe 20-22 - Creiamo un oggetto per lavorare con il display e descriviamo il parametro per lavorare con esso.

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

Per la maggior parte, l'indirizzo può essere trovato nella scheda tecnica del chip su cui è costruito il dispositivo I2C. Se ciò non è possibile, ecco un collegamento all'archivio con lo schizzo e gli schemi - http://www.ansealk.ru/files/Arduino_lcd_i2c.zip che determina gli indirizzi di tutti i dispositivi collegati tramite il bus I2C. Devi solo collegare il dispositivo ad Arduino, caricare lo sketch, aprire la console e vedere l'indirizzo.

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

Impostare la posizione iniziale dell'output utilizzando la funzione setCursor()

Stampa di una stringa con la funzione print()

Dopodiché, la prossima funzione print() inizierà l'output dalla posizione successiva dopo la quale l'input precedente è terminato. Si noti inoltre che, a differenza dell'output sulla console, la funzione println() non viene utilizzata qui per completare l'output e l'avanzamento riga.

Pertanto, la scritta "Test LCD1602" apparirà sullo schermo nella prima riga e nella seconda riga saranno indicati la risoluzione del display e un contatore che mostra quanti cicli ha elaborato il nostro schizzo.

Ma, se abbiamo bisogno di visualizzare molti valori variabili sullo schermo, questo metodo non è molto conveniente. Il fatto è che la procedura di visualizzazione del display è molto energivora e lenta, e in questa funzione eseguiamo l'output fino a 7 volte. Sarà molto più semplice preformare la stringa in anticipo e quindi emetterla nella sua interezza. La funzione di input formattata sprintf() ci aiuterà in questo.

Nota a margine n. 3: la funzione di input formattata sprintf().

Il linguaggio C ha diverse funzioni molto utili per la stampa di stringhe - sono chiamate funzioni di output formattato - printf (dalle parole print e format). Nel nostro caso particolare, siamo interessati alla funzione sprintf, che non mostra nulla sullo schermo, ma forma una stringa per l'output successivo. Sembra qualcosa del genere:

sprintf (str , "Stringa %d in uscita", i );

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

Possono esserci diversi modelli e variabili. In questo caso, le variabili sono separate da virgole. Soprattutto, assicurati 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 modello e così via.

Cosa sono i modelli? Qualsiasi modello inizia con un carattere "%" e termina con uno dei dieci (nel caso di Arduino - sette) caratteri di tipo. Tra di loro, potrebbero esserci molte informazioni su come visualizzare il valore o potrebbe non esserci nulla.

Vediamo cosa può esserci nel modello. In generale, il modello si presenta così:

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

Le parentesi quadre indicano che l'elemento racchiuso in esse può essere omesso. La barra verticale indica che in questo campo deve essere selezionato uno dei valori specificati (nel nostro caso, una delle lettere H, I o L).

Per prima cosa trattiamo l'elemento richiesto del modello: il tipo. Specifica quale tipo di variabile verrà emesso e può assumere uno dei seguenti valori:

Il grigio ha contrassegnato quei tipi che non sono applicabili quando si lavora con Arduino. Pertanto, per generare una stringa, è necessario specificare "%s" e per emettere un numero intero - "%d".

Quindi, considera il campo della larghezza. Il numero in esso contenuto indica la larghezza minima del campo in cui verrà visualizzato il modello. Se la dimensione del valore nella variabile è minore, il campo verrà completato con spazi, se è maggiore il record andrà oltre il campo. Quindi il modello "%6d" per il numero 385 stamperà 385 (notare i tre spazi prima del numero).

L'identificatore di precisione inizia sempre con un punto e il numero che lo segue indica azioni diverse a seconda del tipo di valore. Per i tipi "d,o,u,x" indicherà il numero minimo di 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 stringa da emettere. Ad esempio, "%6.1f" per il numero 34.2345 visualizzerà "34.1" (notare che anche il punto è considerato un segno e ci saranno due spazi prima del numero). Oppure il modello "%.3s" della stringa "precision" visualizzerà solo i primi tre caratteri - "punto".

Il flag permette di modificare la visualizzazione del valore visualizzato:

Puoi leggere ulteriori informazioni sui modelli di funzione printf su Internet. Qui ho fornito una breve panoramica delle funzionalità più comunemente utilizzate.

Pertanto, la nostra funzione di output, riscritta per utilizzare l'output formattato, sarà simile a questa:

Si noti che nelle righe 33 e 37 stiamo generando un'intera riga da stampare e nelle righe 34 e 38 le stiamo stampando.

Infine, le nostre funzioni di configurazione e loop preferite.

Nella riga 47 impostiamo la risoluzione del display, nella riga 48 accendiamo la retroilluminazione (la cui luminosità può essere regolata con un potenziometro). Alla riga 49, imposta il contatore del loop a zero. Lo aumenteremo di uno nella 37a riga durante l'output (ricordate il costrutto count++?). Infine, alla riga 56, chiamiamo la funzione di visualizzazione discussa in precedenza. Qualunque cosa.

Cosa si può cambiare o migliorare?

Ad esempio, è possibile eseguire il controllo automatico della retroilluminazione in base all'illuminazione utilizzando una fotoresistenza o un sensore di luce da una stazione meteorologica discussa in diversi articoli in precedenza. Ad esempio, in condizioni di luce intensa, aumentare la luminosità della retroilluminazione e di notte ridurla. Oppure avvitare un sensore di movimento e accendere la retroilluminazione quando un oggetto compare davanti al display, oppure... In generale, credo che tu l'abbia già capito, volendo, sostituendo uno o più componenti e scrivendo un pezzo di codice , puoi migliorare seriamente l'usabilità del display. Possiamo anche utilizzare simboli personalizzati da visualizzare sul display.

Non considero tutte queste domande qui, poiché esulano dallo scopo di una recensione per principianti.

E per oggi ho tutto.

Arduino. Collegamento del display LCD