Orologio Internet con visualizzazione ESPTOP 10 e LCD utilizzando il client NTP e il codice Arduino
L'impostazione di un orologio NTP ESP32 è relativamente semplice, poiché l'ESP32 ha un supporto integrato per NTP e ci sono molte librerie disponibili per assistere con il display LCD. Una volta configurato, l'orologio NTP ESP32 può essere utilizzato per tenere traccia del tempo con alta precisione, anche se disconnesso da Internet.
Ora progetteremo un orologio basato su NTP usando ESP32.
Componenti richiesti
Per progettare un orologio basato su Internet NTP utilizzando ESP32 i seguenti componenti sono richiesti:
- Scheda ESP32
- Display LCD 16x2 I2C
- Collegamento dei fili
- Breadboard
Introduzione a NTP (Protocollo temporale di rete)
Il protocollo di rete (NTP) è un protocollo di networking per la sincronizzazione dell'orologio tra i sistemi informatici. È usato per garantire che gli orologi su diversi dispositivi siano sincronizzati tra loro, anche se si trovano in diverse parti del mondo.
NTP funziona utilizzando una gerarchia di server Time, con ogni server che sincronizza il suo orologio con una sorgente di tempo più accurata. Ciò consente ai dispositivi di sincronizzare i loro orologi con un alto livello di precisione, in genere all'interno di pochi millisecondi.
NTP è un protocollo importante per molte applicazioni, tra cui reti di computer, transazioni finanziarie e ricerca scientifica. Viene anche utilizzato per sincronizzare il tempo visualizzato su orologi digitali e altri dispositivi.
Come funziona NTP?
Il NTP (NTP) di Network Time Protocol) inviando e ricevendo timestamp tra server e client, utilizzando una combinazione dell'ora corrente e il tempo impiegato per l'invio e la ricezione del messaggio.
Il server NTP mantiene un orologio di riferimento ad alta precisione e utilizza questo orologio per regolare gli orologi su altri dispositivi. Il client NTP invia una richiesta al server e il server risponde con l'ora corrente e altri dati, come il tempo di andata e ritorno della richiesta e l'ora corrente del server. Il client utilizza quindi queste informazioni per regolare il proprio orologio e mantenere un tempo accurato.
Il client NTP regola l'orologio locale con il server NTP online utilizzando il ritardo del collegamento e l'offset locale definito all'interno del codice Arduino.
Orologio Internet con visualizzazione ESP32 e LCD utilizzando il client NTP
Progettare un orologio basato su server NTP in tempo reale utilizzando ESP32 ha molti vantaggi. Poiché non dipende dal modulo RTC interno in modo da poter ottenere tempo esatto utilizzando il server NTP. Per progettare prima questo orologio dobbiamo installare alcune librerie necessarie nell'IDE Arduino.
Installazione delle librerie richieste
Per creare orologio Internet ESP32 utilizzando NTP Server e visualizzare l'ora sullo schermo LCD, dobbiamo installare le seguenti librerie:
- Scarica la libreria NTPClient
- Scarica Library Time
- Scarica la libreria LCD I2C
Fai clic sul collegamento per scaricare la libreria NTPClient.
Per scaricare la libreria Time Apri il link e fai clic su Scarica Zip.
Dopo aver scaricato entrambe le librerie Apri IDE e andare a: Sketch> includi libreria> Aggiungi .Libreria zip.
Installa entrambe le librerie una per una. Ora per visualizzare il tempo sullo schermo LCD, aprire il gestore della libreria e installare il LiquidCrystal I2C Biblioteca di Franco.
Dopo aver installato le librerie richieste ora, possiamo integrare ESP32 con un display LCD.
Cablaggio del LCD all'ESP32
È possibile collegare un display LCD con un ESP32 tramite i suoi pin i2c. SDA Il pin è al D21 e SCL/SCK è a D22. Connetti ESP32 con LCD come mostrato nell'immagine seguente:
Di seguito sono riportate le connessioni:
| I2C LCD | ESP32 |
|---|---|
| VCC | Vin |
| GND | GND |
| SDA | D21 |
| SCL | D22 |
Ottenere l'indirizzo LCD I2C
Dopo aver collegato il LCD I2C con ESP32, è importante controllare l'indirizzo I2C. Nel caso in cui si utilizza più di un dispositivo sullo stesso bus i2c, ESP32 non sarà in grado di comunicare con entrambi.
Usa sempre dispositivi con diversi indirizzi I2C. Per ottenere l'indirizzo I2C useremo il Filo biblioteca. Per il codice Arduino più dettagliato, leggi l'articolo Ottieni l'indirizzo I2C in ESP32 utilizzando Arduino IDE.
Qui l'LCD che stiamo usando ha un indirizzo I2C 0x27.
Codice per ESP32 Internet Clock
Apri IDE e Carica il codice per connettersi a un server NTP. Una volta che ESP32 è collegato al server NTP utilizzando la connessione WiFi definita all'interno del codice, Arduino Serial Monitor e I2C LCD visualizzerà in tempo reale.
#includere
#includere
#includere
#includere
#includere
int lcd_columns = 16; /*Definisci la dimensione LCD*/
int lcd_rows = 2;
Liquidcrystal_i2c lcd (0x27, lcd_columns, lcd_rows); /*0x27 I2C Indirizzo per LCD*/
const char *ssid = "ssid"; /*Sostituisci con la rete ssid*/
const char *password = "password"; /*Sostituisci con password di rete*/
Wifiudp ntpudp;
NTPClient TimeClient (NTPUDP, "Time.nist.Gov ", 18000, 60000);
char time [] = "tempo: 00: 00: 00";
char data [] = "Data: 00/00/2000";
byte last_second, second_, minuto_, hour_, day_, mese_;
int year_;
void setup ()
Seriale.Inizia (115200);
LCD.dentro(); /*Inizializza il display LCD*/
LCD.retroilluminazione (); /*Su retroilluminazione LCD*/
LCD.setCursor (0, 0); /*Imposta cursore*/
LCD.print ("time"); /*Tempo di stampa su LCD*/
LCD.setCursor (0, 1); /*Imposta il cursore LCD*/
LCD.data di stampa); /*Data di stampa*/
Wifi.inizio (SSID, password); /*inizia wifi*/
Seriale.Stampa ("Collegamento.");
mentre (wifi.stato() != Wl_connected)
ritardo (500);
Seriale.stampa(".");
Seriale.println ("connesso");
Timeclient.inizio();
ritardo (1000);
LCD.chiaro(); /*Cancella lcd display*/
void loop ()
Timeclient.aggiornamento();
UNIX_EPOCH non firmato Long = TimeClient.getEpochtime (); // ottieni il tempo di epoca unix dal server NTP
secondo_ = secondo (unix_epoch);
if (last_second != secondo_)
minuto_ = minuto (unix_epoch);
ora_ = ora (unix_epoch);
day_ = day (unix_epoch);
Month_ = Month (unix_epoch);
anno_ = anno (unix_epoch);
Tempo [12] = secondo_ % 10 + 48;
Tempo [11] = secondo_ / 10 + 48;
Tempo [9] = minuto_ % 10 + 48;
Tempo [8] = minuto_ / 10 + 48;
Tempo [6] = ora_ % 10 + 48;
Tempo [5] = hour_ / 10 + 48;
Data [5] = day_ / 10 + 48;
Data [6] = day_ % 10 + 48;
Data [8] = Month_ / 10 + 48;
Data [9] = Month_ % 10 + 48;
Data [13] = (anno_ / 10) % 10 + 48;
Data [14] = anno_ % 10 % 10 + 48;
Seriale.println (tempo); /*Stampa tempo sul monitor seriale*/
Seriale.println (data); /*Data di stampa sul monitor seriale*/
LCD.setCursor (0, 0); /*Imposta il cursore LCD*/
LCD.stampa (tempo); /*Time di visualizzazione su LCD*/
LCD.setCursor (0, 1); /*Imposta il cursore LCD*/
LCD.data di stampa); /*Data di visualizzazione su LCD*/
last_second = second_;
ritardo (200);
Utilizzando il codice sopra, possiamo ottenere il tempo NTP dal server. Per ottenere il tempo corretto su LCD devi apportare modifiche in base al fuso orario.
NTPClient TimeClient (NTPUDP, "Asia.piscina.ntp.org ", 18000, 60000);
Attualmente il paese in cui vivo è 5 ore avanti rispetto al tempo universale coordinato (tempo UTC). Quindi, devo convertire 5 ore in secondi.
+5 ore = 5x60x60 = 18.000 secondi
Cambia questo fuso orario in base alla tua posizione. Puoi usare Google per controllare il GMT compensato per il tuo paese.
Inoltre modifica la rete SSID e la password definite all'interno del codice.
Codice avviato chiamando le librerie installate. I2C LCD, ESP32 WiFi, NTPClient e Biblioteca di tempo.
Ntpclient.H La libreria collegherà ESP32 con il server NTP e Wifiudp.H invierà e riceverà messaggi UDP.
Per comunicare con il protocollo UDP NTP Time Server. Per ottenere tempo dal server Internet NTP, ci sono variabili dell'indirizzo del server NTP, l'offset NTP e l'intervallo NTP devono essere definiti.
NTPClient TimeClient (NTPUDP, "Asia.piscina.ntp.org ", 18000, 60000);
Il server NTP invia informazioni temporali a ESP32. Il tempo ricevuto è in Unix formato timestamp (unix epoch). La biblioteca del tempo convertirà il formato Unix Epoch Time to Minds, Ore e Day.
Next I2C Indirizzo (0x27) del LCD è definito. Inoltre, la dimensione dell'LCD 16 × 2 è anche configurata.
In ciclo continuo funzione Timeclient.aggiornamento() La funzione avrà tempo dal server NTP e la memorizzerà all'interno della variabile temporale.
Produzione
Sul monitor seriale, vedrai l'output di seguito:
Sul display LCD è possibile visualizzare un orologio con data e ora aggiornate.
Conclusione
ESP32 è una scheda IoT basata sul microcontrollore compatta. Questo articolo copre tutti i passaggi necessari per progettare un orologio basato su server NTP in tempo reale. L'output viene visualizzato sullo schermo LCD utilizzando il codice Arduino. Impostando il server NTP corretto, chiunque può progettare un orologio in base al proprio fuso utilizzando il codice ESP32 e Arduino.