Lezioni su Arduino: creare un ticker utilizzando un microcontrollore. Lezioni su Arduino: creare un ticker utilizzando un microcontrollore Ticker su un display 1602

02.07.2020 Sicurezza

Tutti sono da tempo abituati al fatto che ogni dispositivo elettronico ha uno schermo, con l'aiuto del quale fornisce a una persona ogni sorta di informazioni utili. Il lettore MP3 mostra il nome del brano in riproduzione, il telecomando del quadricottero mostra la telemetria di volo, anche la lavatrice mostra il tempo rimanente fino alla fine del lavaggio e lo smartphone generalmente ospita l'intero desktop di un personal computer! Molto probabilmente, il tuo prossimo dispositivo potrebbe utilizzare anche un piccolo display :) Proviamo a realizzare un semplice orologio elettronico! E come tabellone segnapunti utilizziamo il comune ed economico display a cristalli liquidi a caratteri 1602. Eccolo, proprio come in foto: Oltre al 16x2, un display a caratteri 20x4 (quattro righe da 20 caratteri ciascuna), oltre ad un display grafico con una risoluzione di 128x64 pixel, sono considerati piuttosto popolari. Eccoli nelle immagini:

1. Collegamento del display LCD a caratteri 1602

Il display 1602 ha 16 pin. Di solito sono numerati da sinistra a destra, se lo guardi come nell'immagine. A volte i pin sono firmati, come: DB0, DB1, EN, ecc. E a volte indicano semplicemente il numero di uscita. In ogni caso la lista dei pin è sempre la stessa: 1 — “GND”, terra (meno alimentazione); 2 — “Vcc”, alimentazione +5V; 3 — “VEE”, contrasto 4 — “RS”,; selezione registro; “R/W”, direzione di trasferimento dati (scrittura/lettura); 7-14 - “DB0”, “DB1”, .., “DB7” - bus dati; ); 16 — catodo di retroilluminazione (terra). Alle uscite digitali del controller sono collegate le linee VEE, RS e quattro linee dati DB4, DB5, DB6, DB7. Collegheremo la linea “R/W” alla “massa” del controller (poiché abbiamo solo bisogno della funzione di scrittura nella memoria del display). Per ora non collegheremo la retroilluminazione, penso che tu possa capirlo facilmente da solo :) Diagramma schematico di collegamento del display a ArduinoUno

Aspetto del layout

Per ogni evenienza, anche sotto forma di cartello:

Display LCD1602	1	2	4	6	11	12	13	14	15	16
ArduinoUno	GND	+5V	4	5	6	7	8	9	+5V	GND

2. Programmazione “Ciao mondo!”

Per lavorare con display LCD di varie dimensioni e tipologie, l'editor IDE di Arduino dispone di una libreria speciale Cristalli liquidi. Per includere la libreria, scriviamo la seguente espressione nella prima riga del nostro programma: #include Successivamente, dovremo indicare quali pin Arduino abbiamo utilizzato per collegare il display. Indicheremo queste informazioni durante l'inizializzazione del modulo: LiquidCrystal lcd(4, 5, 6, 7, 8, 9); Qui, i primi due argomenti sono i pin RS ed EN e i restanti quattro sono il bus dati DB4-DB7 linee. Successivamente, specifichiamo la dimensione del display utilizzando il comando “begin”: lcd.begin(16, 2); Lascia che ti ricordi che il nostro display ha due righe, 16 caratteri ciascuna. Infine, abbiamo bisogno di una semplice funzione "stampa" per produrre testo. L'output di questa frase ben nota utilizzando questa funzione sarà simile a questo: lcd.print("Hello, world!"); L'intero programma sarà simile a questo: #include LCD a cristalli liquidi (4, 5, 6, 7, 8, 9); void setup())( lcd.begin(16, 2); lcd.print("Hello, world!"); ) void loop())( ) Caricalo su Arduino Uno e guarda cosa succede sul display. Possono esserci tre situazioni principali 🙂 1) Il display visualizzerà "Hello, world!". Ciò significa che hai collegato tutto correttamente e che il contrasto in qualche modo miracolosamente si è rivelato inizialmente impostato correttamente. Ci rallegriamo e passiamo al capitolo successivo. 2) Il display mostrerà una serie di rettangoli neri: è necessaria la regolazione del contrasto! Ecco perché abbiamo aggiunto al circuito un potenziometro con manopola. Lo ruotiamo da un bordo all'altro finché sul display non appare un'iscrizione chiara. 3) Due file di rettangoli neri. Molto probabilmente hai commesso un errore durante la connessione. Controlla tre volte tutti i cavi. Se non trovi un errore, chiedi al tuo gatto di controllare!

3. Programmazione dell'orologio

Ora che il display funziona correttamente, proviamo a trasformare il nostro semplice dispositivo in un vero e proprio orologio elettronico. Attenzione! Per visualizzare l'ora, abbiamo bisogno della libreria Time. Se non è ancora installato, puoi scaricare l'archivio dal collegamento. Colleghiamolo: #include Quindi impostiamo la data e l'ora correnti utilizzando la funzione “setTime”: setTime(23, 59, 59, 12, 31, 2015 Qui è tutto chiaro: ore, minuti, secondi, mese, giorno, anno); Per visualizzare la data utilizziamo una serie di funzioni:

year() - ci restituirà l'anno;
mese(): mese;
giorno() - giorno;
ora() - ora;
minuto() - restituirà il minuto;
secondo() - secondo.

Ora prestiamo attenzione a questo fatto. Se contiamo il numero di caratteri in una tipica data: “31/12/2015 23:59:59”, otteniamo 19. E ne abbiamo solo 16! Tuttavia, non rientra in una riga. Puoi risolvere il problema con un'altra funzione utile: "setCursor". Questa funzione imposta il cursore nella posizione desiderata. Ad esempio: lcd.setCursor(0,1); Posiziona il cursore all'inizio della seconda riga. Il cursore è la posizione del carattere da cui inizierà l'output del testo con il successivo comando "stampa". Usiamo questa funzione per visualizzare la data nella prima riga e l'ora nella seconda. Ora tutto è chiaro con la visualizzazione di data e ora. Rimangono le cose di routine. Ad esempio, dopo che ogni display si è riempito, lo cancelleremo con la funzione “clear()”: lcd.clear(); Inoltre, non ha senso visualizzare i dati più di una volta al secondo, quindi metteremo in pausa 1000 millisecondi tra due iterazioni. Quindi, mettendo insieme il tutto, otteniamo il seguente programma: #include #includere LCD a cristalli liquidi (4, 5, 6, 7, 8, 9); void setup())( lcd.begin(16, 2); setTime(7,0,0,1,10,2015); // 7:00, 10 gennaio 2015) void loop())( lcd.clear( ); lcd.print(giorno()); lcd.print("); lcd.print("); lcd.setCursor(0 , 1); lcd.print(ora()); (":"); lcd.print(":"); (1000) Carica lo schizzo su Arduino Uno e guarda l'avanzamento dell'orologio! 🙂 Per consolidare le conoscenze acquisite, consiglio di aggiornare il nostro orologio con una sveglia a tutti gli effetti. Tutto quello che devi fare è aggiungere un paio di pulsanti e un cicalino :)

Per lavorare con i display grafici dei caratteri, suggeriamo di utilizzare la libreria LiquidCrystal, inclusa nel set IDE Arduino standard ed è progettata per funzionare tramite un'interfaccia parallela a 8 bit (4 bit). Se il tuo display è collegato ad Arduino tramite il bus I2, devi installare la libreria LiquidCrystal_I2C (la maggior parte delle cui funzioni ripetono le funzioni della prima libreria).

Display supportati:

Schermo	Connessione e inizializzazione
LCD1602 - display caratteri (16x02 caratteri),	#includere [ , 8 , 9 , 10 , 11 ]); configurazione nulla())( lcd.begin(16, 2);} // Spiegazione: configurazione nulla())( OGGETTO.begin(NUM_COLUMN, NUMBER_ROWS); ) OGGETTO Cristallo Liquido(RS, E, D0, D1, D2, D3, D4, D5, D6, D7);
con interfaccia I2C (blu)	#includere #includere LiquidCrystal_I2C lcd(0x27 O 0x3F, 16 , 2); configurazione nulla())( lcd.init(); } // Spiegazione:
LCD1602 I2C - display caratteri (16x02 caratteri), con interfaccia I2C (verde)	#includere #includere LiquidCrystal_I2C lcd(0x27 O 0x3F, 16 , 2); configurazione nulla())( lcd.init(); } // Spiegazione: OGGETTO LiquidCrystal_I2C (I2C_ADDRESS, COLUMNS_COLUMN, ROW_COUNTY); // I2C_ADDRESS può essere 0x27 o 0x3F
LCD2004 - display caratteri (20x04 caratteri), con interfaccia parallela (blu)	#includere LCD a cristalli liquidi (2, 3, 4, 5, 6, 7[ , 8 , 9 , 10 , 11 ]); configurazione nulla())( lcd.begin(20, 4);} // Spiegazione: OGGETTO Cristallo Liquido(RS, E, D4, D5, D6, D7); void setup())( OBJECT.begin(NUM_COLUMN, NUM_ROWS); ) // Se vengono utilizzati 8 cavi del bus dati, indicarli tutti OGGETTO Cristallo Liquido(RS, E, D0, D1, D2, D3, D4, D5, D6, D7);
LCD2004 I2C - display caratteri (20x04 caratteri), con interfaccia I2C (blu)	#includere #includere LiquidCrystal_I2C lcd(0x27 O 0x3F, 20 , 4); configurazione nulla())( lcd.init(); } // Spiegazione: OGGETTO LiquidCrystal_I2C (I2C_ADDRESS, COLUMNS_COLUMN, ROW_COUNTY); // I2C_ADDRESS può essere 0x27 o 0x3F

#1 Esempio

Visualizziamo la scritta sul display LCD1602 collegato tramite bus I2C. Per funzionare con il display LCD2004, è necessario modificare la riga 3 in LiquidCrystal_I2C lcd(0x27,20,4);

#includere // Collega la libreria per lavorare con un display LCD tramite il bus I2C LiquidCrystal_I2C lcd(0x27,16,2); // Dichiara l'oggetto della libreria, specificando i parametri di visualizzazione (indirizzo I2C = 0x27, numero di colonne = 16, numero di righe = 2) // Se la scritta non appare, sostituire l'indirizzo 0x27 con 0x3F void setup())( / / lcd.init(); // Avvia il lavoro con il display LCD lcd.backlight(); // Accende la retroilluminazione del display LCD lcd.setCursor(0, 0); , 0 righe) lcd.print("LCD"); // Stampa il testo "LCD", a partire dalla posizione impostata del cursore lcd.setCursor(0, 1); // Imposta il cursore sulla posizione (0 colonna, 1 riga ) lcd.print("www.iarduino.ru"); Visualizziamo il testo "www.iarduino.ru", a partire dalla posizione impostata del cursore) // // void loop()() // Il codice all'interno del loop la funzione viene eseguita continuamente. Ma poiché stiamo visualizzando testo statico, dobbiamo visualizzarlo solo una volta all'avvio, senza utilizzare il codice del loop

#2 Esempio

Visualizziamo la scritta sul display LCD1602 collegato tramite bus parallelo a 4 bit. Per lavorare con il display LCD2004, è necessario modificare la riga 5 in lcd.begin(20, 4);

#includere // Collega la libreria LiquidCrystal per lavorare con il display LCD LiquidCrystal lcd(2,3,4,5,6,7); // Dichiara un oggetto della libreria, indicando i pin di visualizzazione (RS, E, D4, D5, D6, D7) // Se vengono utilizzati 8 fili del bus dati, specificare (RS, E, D0, D1, D2, D3, D4 , D5, D6,D7) void setup())( // lcd.begin(16, 2); // Avvia il lavoro con il display LCD, indicando il numero (colonne, righe) lcd.setCursor(0, 0); // Imposta il cursore sulla posizione (0 colonne, 0 righe) lcd.print("LCD2004"); // Stampa il testo "LDC1602", iniziando dalla posizione impostata del cursore lcd.setCursor(0, 1); Imposta il cursore sulla posizione (0 colonna, 1 riga) ) lcd.print("www.iarduino.ru"); // Stampa il testo "www.iarduino.ru", iniziando dalla posizione impostata del cursore ) // // void loop()() // Il codice all'interno della funzione loop viene eseguito continuamente. Ma poiché stiamo visualizzando testo statico, dobbiamo visualizzarlo solo una volta all'avvio, senza utilizzare il codice del loop

# 3 Esempio

Visualizziamo la scritta "Lingua russa" sul display LCD1602 collegato tramite il bus I2C:

# 4 Esempio

Visualizziamo il tempo trascorso dopo la partenza sul display LCD1602 collegato tramite bus I2C:

#includere // Collega la libreria per lavorare con il bus I2C #include // Collega la libreria per lavorare con un display LCD tramite il bus I2C LiquidCrystal_I2C lcd(0x27,16,2); // Dichiara l'oggetto della libreria, specificando i parametri di visualizzazione (indirizzo I2C = 0x27, numero di colonne = 16, numero di righe = 2) // uint8_t tim_D, tim_H, tim_M, tim_S; //Dichiara variabili per memorizzare giorni, ore, minuti e secondi. uint32_ttim; //Dichiara una variabile per memorizzare la quantità totale di tempo trascorso dall'inizio. // Se la scritta non appare, sostituisci l'indirizzo 0x27 con 0x3F void setup())( // lcd.init(); // Avvia il lavoro con il display LCD lcd.backlight(); // Accendi la retroilluminazione del Display LCD ) // // void loop())( // // Ottieni il tempo trascorso dall'inizio: // tim = millis() / 1000; // Ottieni il numero totale di secondi (massimo 4"294"967 sec ≈ 49,7 giorni). tim_S = tim % 60 ; // Ottieni i secondi: il resto della divisione di tutti i secondi per minuto (60 sec) // Ottieni il numero totale di minuti tim_M = tim % 60; minuti all'ora (60 minuti) tim = (tim-tim_M) // Ottieni il numero totale di ore tim_H = tim % 24; di giorni // Visualizza il tempo trascorso dall'inizio: // if (millis()%1000)<100){ // Условие выполняется в течении 100 первых миллисекунд каждой новой секунды. delay(100); lcd.setCursor(0, 0); // Устанавливаем курсор в позицию (0 столбец, 0 строка). lcd.print("Days: "); // Выводим текст. if(tim_D<10){lcd.print(0);} // Выводим 0 перед количеством дней. lcd.print(tim_D); // Выводим количество дней. lcd.setCursor(0, 1); // Устанавливаем курсор в позицию (0 столбец, 1 строка) lcd.print("Time: "); // Выводим текст. if(tim_H<10){lcd.print(0);} // Выводим 0 перед количеством часов. lcd.print(tim_H); // Выводим количество часов. lcd.print(":"); // Выводим символ. if(tim_M<10){lcd.print(0);} // Выводим 0 перед количеством минут. lcd.print(tim_M); // Выводим количество минут. lcd.print(":"); // Выводим символ. if(tim_S<10){lcd.print(0);} // Выводим 0 перед количеством секунд. lcd.print(tim_S); // Выводим количество секунд. } // } //

Funzioni comuni alle librerie LiquidCrystal e LiquidCrystal_I2C:

inizio( colonne, righe, ); – Inizializza il display con il numero di colonne, righe e dimensione dei caratteri.
chiaro();– Cancellare il display con il cursore nella posizione 0,0 (richiede molto tempo!).
casa();– Impostare il cursore sulla posizione 0,0 (richiede molto tempo!).
Schermo();– Accendere velocemente il display (senza modificare i dati in RAM).
noDisplay();– Spegnimento rapido del display (senza modificare i dati in RAM).
battito di ciglia();– Accendere il cursore lampeggiante (con frequenza di circa 1 Hz).
noBlink();– Disattivare il cursore lampeggiante.
cursore();– Abilita la sottolineatura del cursore.
noCursore();– Disabilita la sottolineatura del cursore.
scrollDisplayLeft();– Fa scorrere il display verso sinistra. Sposta le coordinate di visualizzazione di una colonna a sinistra (senza modificare la RAM).
scrollDisplayRight();– Fa scorrere il display verso destra. Sposta le coordinate di visualizzazione di una colonna a destra (senza modificare la RAM).
da sinistra a destra();– Specifica di spostare ulteriormente la posizione del cursore, dopo aver visualizzato il carattere successivo, di una colonna a destra.
da destra a sinistra();– Specifica di spostare ulteriormente la posizione del cursore, dopo aver visualizzato il carattere successivo, di una colonna a sinistra.
noAutoscorrimento();– Specifica che il testo verrà allineato a sinistra della posizione del cursore in futuro (come al solito).
scorrimento automatico();– Indica che in futuro il testo verrà allineato a destra rispetto alla posizione del cursore.
createChar( numero, matrice ); – Scrivere un carattere personalizzato nella CGRAM del display sotto il numero specificato.
setCursore( col,riga ); – Posizionare il cursore nella posizione indicata dalla colonna e dal numero di riga.
stampa( testo ); – Visualizzare testo, simboli o numeri sullo schermo del display. La sintassi è simile alla funzione di classe Serial con lo stesso nome.

Funzioni implementate solo nella libreria LiquidCrystal_I2C:

dentro();– Visualizzazione dell'inizializzazione. Deve essere il primo comando della libreria LiquidCrystal_I2C dopo la creazione dell'oggetto. In effetti, questa funzione è presente anche nella libreria LiquidCrystal, ma in quella libreria viene chiamata automaticamente (per impostazione predefinita) quando viene creato un oggetto.
retroilluminazione();– Accendere la retroilluminazione del display.
noRetroilluminazione();– Spegne la retroilluminazione del display.
setRetroilluminazione( bandiera ); – Controllo della retroilluminazione (true - attiva / false - disattiva), utilizzato al posto delle funzioni noBacklight e retroilluminazione.

Connessione:

// Per il bus I2C: #includere #includere LiquidCrystal_I2C lcd( indirizzo , col , riga ); configurazione nulla())( lcd.init(); }	Parametro: indirizzo: Visualizza l'indirizzo sul bus I2C: 0x27 o 0x3F col: riga:
// Per un bus parallelo a 4 fili: #includere Cristalli liquidi lcd( RS , E , D4 , D5 , D6 , D7 ); configurazione nulla())( lcd.begin( col , riga ); }	Parametro: RS: N. del pin Arduino a cui è collegato il pin RS E: Numero del pin di Arduino a cui è collegato il pin E D0...D3: Numero di pin Arduino a cui sono collegati i pin D0-D3 D4...D7: Numero di pin Arduino a cui sono collegati i pin D4-D7 col: numero di colonne implementate nel display riga: numero di righe implementate nel display
// Per un bus parallelo a 8 fili: #includere Cristalli liquidi lcd( RS , E , D0 , D1 , D2 , D3 , D4 , D5 , D6 , D7 ); configurazione nulla())( lcd.begin( col , riga ); }
inizio( col , riga , ); Inizializza il display con le dimensioni e i caratteri dello schermo.	Parametro: col: numero di colonne implementate nel display riga: numero di righe implementate nel display misurare: dimensione del carattere, indicata da una costante: LCD_5x8DOTS (predefinito) o LCD_5x10DOTS

/* Per il bus I2C: */ #include // Collega la libreria per lavorare con il bus I2C #include // Collega la libreria per lavorare con un display LCD tramite il bus I2C LiquidCrystal_I2C lcd(0x3F,20,4); // Dichiara un oggetto della libreria, indicando i parametri di visualizzazione (indirizzo I2C = 0x3F, numero di colonne = 20, numero di righe = 4) // void setup())( // lcd.init(); // Inizia il lavoro con il display LCD lcd.backlight (); // Accende la retroilluminazione del display LCD... // Visualizza le informazioni che dovrebbero essere visualizzate all'avvio) // // void loop()() // ... // Informazioni sull'output che dovrebbero cambiare in base all'algoritmo del codice) // /* Per un bus parallelo a 4 fili: */ #include // Collega la libreria LiquidCrystal per lavorare con il display LCD LiquidCrystal lcd(2,3,4,5,6,7); // Dichiara un oggetto della libreria, indicando i pin di visualizzazione (RS, E, D4, D5, D6, D7) // Se vengono utilizzati 8 fili del bus dati, specificare (RS, E, D0, D1, D2, D3, D4 , D5, D6,D7) void setup())( // lcd.begin(16, 2); // Avvia il lavoro con il display LCD, indicando il numero (colonne, righe) ... // Visualizza le informazioni che dovrebbero essere visualizzato all'avvio) / // void loop()() // ... // Informazioni sull'output che dovrebbero cambiare in base all'algoritmo del codice) //

Funzioni di controllo del display:

Schermo(); Accende il display dopo che è stato spento dalla funzione noDisplay.	Nota: la funzione viene eseguita rapidamente e non modifica la RAM del display.
noDisplay(); Spegne il display. I dati sul display non verranno visualizzati finché non viene richiamata la funzione di visualizzazione, ma non verranno cancellati dalla memoria RAM e, dopo aver richiamato la funzione di visualizzazione, verranno visualizzati nuovamente.	Nota: la funzione viene eseguita rapidamente e non modifica la RAM del display.
scrollDisplayLeft(); Sposta le coordinate di visualizzazione di una colonna a sinistra.
scrollDisplayRight(); Sposta le coordinate di visualizzazione di una colonna a destra. Chiamare costantemente questa funzione creerà un effetto di linea strisciante. Le coordinate vengono spostate sia per le informazioni disponibili sul display che per quelle che verranno visualizzate successivamente.	Nota: la funzione funziona senza modificare la RAM del display. Se chiami la funzione 40 volte di seguito, le coordinate torneranno al punto originale
chiaro(); Cancella il display impostando il cursore sulla posizione 0,0. Le informazioni sul display verranno cancellate definitivamente.	Nota: richiede molto tempo.
retroilluminazione(); Attiva la retroilluminazione del display.
noRetroilluminazione(); Disattiva la retroilluminazione del display.	Nota: la funzione è implementata solo nella libreria LiquidCrystal_I2C.
setRetroilluminazione( bandiera ); Controllo della retroilluminazione (invece di noBacklight e funzioni di retroilluminazione).	Parametro: bandiera: vero - si accende e falso - spegne la retroilluminazione. Nota: la funzione è implementata solo nella libreria LiquidCrystal_I2C.

/* Visualizza un messaggio per monitorare le funzioni di controllo del display: */ lcd.cursor(0,0); // Imposta il cursore sull'angolo più alto del display (0 colonne, 0 righe) lcd.print("iarduino.ru"); // Visualizza il testo "iarduino.ru" (la prima lettera "i" sarà nella posizione "0.0" e l'ultima "u" nella posizione "10.0", cursore invisibile nella posizione "11.0") // lcd.noDisplay (); // Spegne il display (la scritta scomparirà dal display) lcd.display(); // Accendi il display (la scritta apparirà sul display nello stesso posto) lcd.scrollDisplayLeft(); // Sposta le coordinate delle colonne a sinistra (il display visualizzerà "arduino.ru" senza la prima lettera "i", che andrà oltre il display, ma rimarrà nella sua RAM) lcd.scrollDisplayRight(); // Sposta le coordinate della colonna a destra (il display visualizzerà "iarduino.ru" nello stesso posto in cui era originariamente visualizzato) lcd.clear(); // Pulisci il display (la scritta scomparirà definitivamente dal display) lcd.noBacklight(); // Spegne la retroilluminazione del display lcd.backlight(); // Accende la retroilluminazione del display lcd.setBacklight(0); // Disattiva la retroilluminazione del display lcd.setBacklight(1); // Accende la retroilluminazione del display

Funzioni di controllo del cursore:

setCursore( col , riga ); Posiziona il cursore nella posizione specificata.	Parametro: col: numero di colonna (a partire da 0). riga: numero di riga (a partire da 0)
casa(); Impostazione del cursore sulla posizione 0,0. Funziona come la funzione setCursor(0,0);	Nota: richiede molto tempo.
battito di ciglia(); Abilita il cursore lampeggiante.	Nota: Il cursore occupa l'intero campo carattere e lampeggia con una frequenza di circa 1 Hz, nella posizione in cui era precedentemente impostato.
noBlink(); Disattiva il cursore lampeggiante.	Nota: il cursore diventa invisibile, ma la sua posizione viene mantenuta.
cursore(); Abilita la sottolineatura del cursore.	Nota: il cursore assume la forma di un carattere di sottolineatura e si trova nella posizione in cui era precedentemente posizionato.
noCursore(); Disattiva la sottolineatura del cursore.	Nota: il cursore diventa invisibile, ma la sua posizione viene mantenuta.

lcd.setCursore(0, 1); // Imposta il cursore sul primo carattere della seconda riga (la numerazione delle righe e delle colonne inizia da 0) lcd.home(); // Imposta il cursore sul primo carattere della prima riga (come quando si chiama lcd.setCursor(0,0);) lcd.blink(); // Rende visibile il cursore (un rettangolo lampeggerà al posto del cursore) lcd.noBlink(); // Rende invisibile il cursore (rimuove il rettangolo lampeggiante) lcd.cursor(); // Rende visibile il cursore (al posto del cursore apparirà un carattere di sottolineatura) lcd.noCursor(); // Rende invisibile il cursore (rimuove il carattere di sottolineatura) // Se il cursore colpisce un punto in cui è presente un carattere, questo carattere non scompare

Funzioni che indicano la direzione e l'allineamento:

da sinistra a destra(); Specifica che dopo ogni nuovo carattere, la posizione del cursore deve spostarsi di una colonna a destra.	Nota: se si visualizza il testo "abc", il display mostrerà "abc" e il testo sarà a destra della posizione originale del cursore. (Come di solito)
da destra a sinistra(); Specifica che dopo ogni nuovo carattere, la posizione del cursore dovrebbe spostarsi di una colonna a sinistra.	Nota: se si visualizza il testo "abc", il display visualizzerà "cba" e il testo sarà a sinistra della posizione originale del cursore. (Scrivendo da destra a sinistra)
noAutoscorrimento(); Indica che in futuro il testo dovrà essere allineato a sinistra della posizione originale del cursore.	Nota: se si posiziona il cursore nella posizione 10.0 e si visualizza il testo, il primo carattere del testo visualizzato si troverà in questa posizione. (Come di solito)
scorrimento automatico(); Indica che in futuro il testo dovrà essere allineato a destra della posizione originale del cursore.	Nota: se si posiziona il cursore nella posizione 10.0 e si visualizza il testo, il cursore si troverà in questa posizione. (Le coordinate di visualizzazione verranno spostate a sinistra, come se avessi chiamato la funzione scrollDisplayLeft tante volte quante sono le lettere nel testo di output)

lcd.sinistraadestra(); // Ordina al cursore di spostarsi a destra (come al solito nella scrittura europea) lcd.clear(); lcd.setCursor(5,0); lcd.print("ABC"); // Sul display vedremo: "ABC" (Dopo "A" il cursore si è spostato a destra e è stata visualizzata "B", poi il cursore si è spostato a destra e è stata visualizzata "C") lcd.rightToLeft(); // Dice al cursore di spostarsi a sinistra (come nella scrittura da destra a sinistra) lcd.clear(); lcd.setCursor(5,0); lcd.print("ABC"); // Sul display vedremo: "CBA" (Dopo "A" il cursore si è spostato a sinistra e è stata visualizzata "B", poi il cursore si è spostato a sinistra e è stata visualizzata "C") lcd.noAutoscroll(); // Imposta l'allineamento a sinistra (come al solito) lcd.clear(); lcd.setCursor(5,0); lcd.print("ABC"); // Sul display vedremo: "ABC" (Come al solito) lcd.autoscroll(); // Imposta l'allineamento a destra (le coordinate di visualizzazione verranno spostate a sinistra in base al numero di caratteri visualizzati) lcd.clear(); lcd.setCursor(5,0); lcd.print("ABC"); // Sul display vedremo: "ABC" (Le coordinate del display verranno spostate di 3 caratteri a sinistra, poiché dopo ogni carattere viene effettuata una chiamata alla funzione scrollDisplayLeft)

Funzioni di immissione di testo e simboli:

createChar(num,array); Scrive un carattere personalizzato nella CGRAM del display sotto il numero specificato. Se vuoi visualizzare il testo (usando la funzione print) che dovrebbe contenere il carattere che hai impostato, specifica una barra e il numero sotto il quale è stato scritto questo carattere: print("C\1MBO\2").	Parametro: numero: il numero sotto il quale verrà scritto il simbolo. vettore: un array che rappresenta il carattere da scrivere. Nota: l'array è composto da più byte, il cui numero è uguale al numero di righe nel simbolo. Ogni bit di byte impostato corrisponde a un pixel di carattere impostato (visualizzato).
stampa(testo); Visualizza testo, simboli o numeri sullo schermo del display.	Parametro: testo: carattere, numero o stringa da visualizzare. Nota: la sintassi è simile alla funzione di classe Serial con lo stesso nome.

#includere // Collega la libreria per lavorare con il bus I2C #include // Collega la libreria per lavorare con un display LCD tramite il bus I2C LiquidCrystal_I2C lcd(0x27,16,2); // Dichiara un oggetto della libreria, indicando i parametri di visualizzazione (indirizzo I2C = 0x27, numero di colonne = 16, numero di righe = 2) // uint8_t simbolo_d = (0b00000, // 1 riga del simbolo "d" 0b00000, / / 2a riga del simbolo "d" " 0b00110, // 3a riga del carattere "d" 0b01010, // 4a riga del carattere "d" 0b01010, // 5a riga del carattere "d" 0b01010, // 6a riga del carattere "d" 0b11111, // 7a riga del carattere "d" " 0b10001); // ottava riga del simbolo "d" L'intero array può essere scritto in una riga: uint8_t simbolo_d=(0,0,6,10,10,10,31,17); // uint8_t simbolo_i = (0b00000, // 1a riga del simbolo "e" 0b00000, // 2a riga del simbolo "e" 0b10001, // 3a riga del simbolo "e" 0b10011, // 4a riga del simbolo "e" simbolo "e" 0b10101, // 5a riga del simbolo "e" 0b11001, // 6a riga del simbolo "e" 0b10001, // 7a riga del simbolo "e" 0b00000); // ottava riga del simbolo "e" L'intero array può essere scritto in una riga: uint8_t simbolo_i=(0,0,17,19,21,25,17,0); void setup())( // lcd.init(); // Avvia il lavoro con il display LCD lcd.backlight(); // Accende la retroilluminazione del display LCD lcd.createChar(1,symbol_d); // Carica il primo simbolo nella memoria del display lcd .createChar(2,symbol_i); // Carica il secondo simbolo nella memoria del display lcd.clear( // Cancella lo schermo lcd.setCursor(0,0); cursore sull'angolo più in alto lcd.print("Pa\ 1\2o"); // Emette il testo "Radio" mentre scrive i caratteri "P", "a", "o" in latino, ) // ed emette il caratteri "d", "i" dalla memoria del display, indicando i loro numeri // void loop())( // lcd.setCursor(0,1); lcd.print(" "); // cancella l'intera riga inferiore lcd.setCursor(0,1); lcd.print("i"); lcd.print("arduino"); lcd.print(".ru"); ru" nella riga di fondo delay(2000); // aspetta 2 secondi lcd.setCursor( 0,1); lcd.print(" "); // cancella l'intera riga di fondo lcd.setCursor(0,1); lcd .print(12.345); // stampa il numero 12.34 (vengono visualizzate 2 cifre decimali) delay(2000) // attende 2 secondi lcd.setCursor(0,1); // cancella l'intera riga di fondo lcd.setCursor(0,1); lcd.print(12, HEX); // visualizza il numero 12 come numero esadecimale delay(2000); // attendi 2 secondi lcd.setCursor(0,1); lcd.print(" "); // cancella l'intera riga di fondo lcd.setCursor(0,1); lcd.stampa(1); // visualizza il ritardo numero 1(2000); // aspetta 2 secondi)

Linea strisciante nel display LCD dell'HD44780.

La ricerca di una “soluzione già pronta” per un ticker in C non ha prodotto risultati. Quindi ho dovuto farlo da solo.

Questo "pezzo" di codice consente di visualizzare una linea corrente (da destra a sinistra), in qualsiasi luogo e con qualsiasi numero di familiarità, negli indicatori LCD con un controller HD44780 o simile.

La prima cosa da sottolineare è che il linguaggio C non permette di lavorare con le stringhe “direttamente”. Cioè, è impossibile copiare un carattere da una stringa all'altra utilizzando l'operatore di assegnazione ( = )... per questo è necessario utilizzare una funzione speciale strncpy(). In generale, per lavorare con le stringhe in C vengono utilizzate diverse funzioni. In Self-Tormentors, un capitolo a parte è dedicato all'uso di queste funzioni. In Help"e su CV_AVR, una descrizione delle funzioni per lavorare con le stringhe si trova nella sezione "Funzioni delle stringhe". I prototipi di queste funzioni sono nel file stringa.h.

"...stringa sorgente..." - una stringa di caratteri da cui deve essere visualizzata nella riga "in esecuzione";

"...caratteri visualizzati..." - l'effettiva "linea strisciante".

Per organizzare la linea strisciante è stato scelto il seguente algoritmo:

1. I caratteri visualizzati si spostano da destra a sinistra. Quello più a sinistra è “perso” in questo caso.

2. Dopo lo spostamento, il carattere successivo della stringa sorgente viene copiato nel carattere più a destra.

3. Quando viene raggiunta la fine della riga di origine, il primo carattere della riga di origine diventa il carattere successivo.

Per spostare i caratteri: per la cella da spostare, il codice del carattere viene letto dalla RAM dello schermo (DDRAM) HD44780 e scritto nella cella RAM di sinistra.

Secondo il DataSheet sull'HD44780, il carattere sinistro della riga superiore ha un indirizzo DDRAM di 0x00, e il carattere sinistro della riga inferiore ha un indirizzo di 0x40. Va ricordato che per poter accedere alla RAM dello schermo (e non alla RAM del generatore di caratteri), è necessario che il bit RS sia uguale a 1 (RS è il bit più significativo nel byte di indirizzo, vedi DataSheet).

Di conseguenza, otteniamo che per "indirizzare" il secondo carattere a sinistra della riga superiore, è necessario "lavorare" con l'indirizzo 0x01 | 0x80 = 0x81.

Nella libreria sono presenti le funzioni di scrittura e lettura dei “contenuti interni” dell'HD44780 (prototipi in lcd.h.... quindi.. il programma stesso:

/* per CV_AVR

In questo esempio, la linea corrente viene visualizzata nei bit da 8 (0xC7) a 16 della linea inferiore di un indicatore a 16 bit.

. ......

#includere

carattere senza segno n_sim=1,m_end=43; //43 - lunghezza della linea nell'esempio
...........

implorare_stroka())(
carattere i senza segno;

// sposta la linea strisciante

if(beg_str)(
per(i=0;i<9;i++)lcd_write_byte(0xC7+i,lcd_read_byte(0xC8+i));
stra_beg=0;

// scrive il carattere successivo nella posizione più a destra

lcd_gotoxy(15,1);
lcd_putchar(ish_str);
if(++n_sim>m_end)n_sim=1;
}
}

Glossario:

n_sim - puntatore alla posizione del carattere corrente nella stringa sorgente;

m_end - il numero totale di caratteri nella stringa di origine;

supplicare_str- bit "abilita" spostamento. Con il suo aiuto puoi regolare la velocità di corsa;

ish_str - stringa di origine.

Molto probabilmente, ciascuno dei compilatori C esistenti dispone di funzioni di libreria per lavorare con l'HD44780. Pertanto, "rifare" il programma per il "tuo" compilatore non sarà difficile.

“Preparo” la stringa sorgente utilizzando la nota utility “HD44780.exe”. Quando lo si utilizza, la lunghezza della riga è indicata nei commenti: "/* Lunghezza massima di una riga: 43 byte */"