Internett -klokke med ESPTOP 10 & LCD -skjerm ved hjelp av NTP -klient og Arduino -kode
Å sette opp en ESP32 NTP-klokke er relativt grei, ettersom ESP32 har innebygd støtte for NTP og det er mange biblioteker tilgjengelig for å hjelpe til med LCD-skjermen. Når den er konfigurert, kan ESP32 NTP -klokken brukes til å holde oversikt over tiden med høy nøyaktighet, selv når du er koblet fra Internett.
Nå skal vi designe en NTP -basert klokke ved hjelp av ESP32.
Komponenter som kreves
For å designe en NTP-internettbasert klokke ved bruk av ESP32, er det nødvendig med komponenter:
- ESP32 Board
- 16x2 I2C LCD -skjerm
- Koble til ledninger
- Brødbrett
Introduksjon til NTP (Network Time Protocol)
Network Time Protocol (NTP) er en nettverksprotokoll for klokkesynkronisering mellom datasystemer. Det brukes til å sikre at klokkene på forskjellige enheter er synkronisert med hverandre, selv om de er i forskjellige deler av verden.
NTP fungerer ved å bruke et hierarki av tidsservere, med hver server synkronisering av klokken med en mer nøyaktig tidskilde. Dette gjør at enheter kan synkronisere klokkene sine med høyt nøyaktighetsnivå, vanligvis innen noen få millisekunder.
NTP er en viktig protokoll for mange applikasjoner, inkludert datanettverk, økonomiske transaksjoner og vitenskapelig forskning. Det brukes også til å synkronisere tiden som vises på digitale klokker og andre enheter.
Hvordan fungerer NTP?
Network Time Protocol (NTP) fungerer ved å sende og motta tidsstempler mellom servere og klienter, ved å bruke en kombinasjon av gjeldende tid og tiden som er tatt for meldingen som skal sendes og mottas.
NTP-serveren opprettholder en referanseklokke med høy presisjon og bruker denne klokken for å justere klokkene på andre enheter. NTP-klienten sender en forespørsel til serveren, og serveren svarer med gjeldende tid og andre data, for eksempel tur-returtiden for forespørselen og serverens nåværende tid. Klienten bruker deretter denne informasjonen for å justere sin egen klokke og opprettholde nøyaktig tid.
NTP -klienten justerer sin lokale klokke med den elektroniske NTP -serveren ved hjelp av koblingsforsinkelsen og lokal forskyvning definert inne i Arduino -koden.
Internett -klokke med ESP32 & LCD -skjerm ved hjelp av NTP -klient
Å designe en sanntid NTP-serverbasert klokke ved hjelp av ESP32 har mange fordeler. Ettersom det ikke er avhengig av den interne RTC -modulen, slik at vi kan få nøyaktig tid ved å bruke NTP -serveren. For å designe denne klokken først må vi installere noen nødvendige biblioteker i Arduino IDE.
Installere de nødvendige bibliotekene
For å lage ESP32 Internett -klokke ved hjelp av NTP -serveren og vise tiden på LCD -skjermen, må vi installere følgende biblioteker:
- Last ned NTPClient -biblioteket
- Last ned tidsbibliotek
- Last ned I2C LCD -biblioteket
Klikk på lenken for å laste ned NTPClient -biblioteket.
For å laste ned Time Library Åpne lenken og klikk Last ned zip.
Etter å ha lastet ned begge bibliotekene Open IDE og gå til: Skisse> Inkluder bibliotek> Legg til .Zip Library.
Installer begge bibliotekene en etter en. Nå for å vise tid på LCD -skjermen, åpne Library Manager og installere Liquidcrystal I2C bibliotek av Oppriktig.
Etter å ha installert nødvendige biblioteker nå, kan vi integrere ESP32 med en LCD -skjerm.
Kabler LCD til ESP32
Det er mulig å koble en LCD -skjerm med en ESP32 via I2C -pinnene. SDA PIN er på D21 og SCL/SCK er på D22. Koble ESP32 med LCD som vist under bildet under:
Følgende er forbindelsene:
| I2C LCD | ESP32 |
|---|---|
| VCC | Vin |
| GND | GND |
| SDA | D21 |
| SCL | D22 |
Få I2C LCD -adressen
Etter å ha koblet til I2C LCD med ESP32, er det viktig å sjekke I2C -adressen. I tilfelle hvis man bruker mer enn en enhet på samme I2C -buss, vil ESP32 ikke kunne kommunisere med begge deler.
Bruk alltid enheter med forskjellige I2C -adresser. For å få I2C -adressen vil vi bruke Metalltråd bibliotek. For mer detaljert-på Arduino-kode, les artikkelen Få I2C-adresse i ESP32 ved hjelp av Arduino IDE.
Her har LCD vi bruker en I2C -adresse 0x27.
Kode for ESP32 Internett -klokke
Åpne IDE og laste opp kode for å koble til en NTP -server. Når ESP32 er koblet til NTP -serveren ved å bruke WiFi -tilkoblingen definert inne i koden, vil Arduino Serial Monitor og I2C LCD vise sanntid.
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
int lcd_columns = 16; /*definere LCD -størrelse*/
int lcd_rows = 2;
LiquidCrystal_I2C LCD (0x27, LCD_COLUMNS, LCD_ROWS); /*0x27 I2C -adresse for LCD*/
const char *ssid = "ssid"; /*Bytt ut med nettverket ditt SSID*/
const char *passord = "passord"; /*Erstatt med nettverkspassord*/
Wifiudp ntpudp;
NTPClient TimeClient (NTPUDP, "Tid.nist.Gov ", 18000, 60000);
Char Time [] = "Tid: 00: 00: 00";
Char Dato [] = "Dato: 00/00/2000";
byte last_second, andre_, minutt_, time_, dag_, måned_;
int år_;
void setup ()
Serie.Begin (115200);
LCD.i det(); /*Initialiser LCD -skjerm*/
LCD.bakgrunnsbelysning (); /*På LCD -bakgrunnsbelysning*/
LCD.setcursor (0, 0); /*Sett markøren*/
LCD.print ("tid"); /*Skriv ut tid på LCD*/
LCD.setcursor (0, 1); /*Sett LCD -markøren*/
LCD.utskrift (dato); /*Skriv ut dato*/
Wifi.Begynn (SSID, passord); /*Begynn wifi*/
Serie.trykk ("Tilkobling.");
mens (wifi.status() != Wl_connected)
forsinkelse (500);
Serie.skrive ut(".");
Serie.println ("tilkoblet");
tidsklient.begynne();
forsinkelse (1000);
LCD.klar(); /*klar LCD -skjerm*/
void loop ()
tidsklient.Oppdater();
usignert lang UNIX_EPOCH = TimeClient.getepochtime (); // Få Unix Epoch Time fra NTP -serveren
Second_ = Second (UNIX_EPOCH);
if (last_second != andre_)
minutt_ = minutt (Unix_epoch);
time_ = time (unix_epoch);
DAG_ = DAG (UNIX_EPOCH);
måned_ = måned (UNIX_EPOCH);
år_ = år (UNIX_EPOCH);
Tid [12] = andre_ % 10 + 48;
Tid [11] = andre_ / 10 + 48;
Tid [9] = minutt_ % 10 + 48;
Tid [8] = minutt_ / 10 + 48;
Tid [6] = time_ % 10 + 48;
Tid [5] = time_ / 10 + 48;
Dato [5] = dag_ / 10 + 48;
Dato [6] = dag_ % 10 + 48;
Dato [8] = måned_ / 10 + 48;
Dato [9] = måned_ % 10 + 48;
Dato [13] = (år_ / 10) % 10 + 48;
Dato [14] = år_ % 10 % 10 + 48;
Serie.println (tid); /*Skriver ut tid på seriell skjerm*/
Serie.println (dato); /*Skriv ut dato på seriell skjerm*/
LCD.setcursor (0, 0); /*Sett LCD -markøren*/
LCD.trykk (tid); /*Visetid på LCD*/
LCD.setcursor (0, 1); /*Sett LCD -markøren*/
LCD.utskrift (dato); /*Visningsdato på LCD*/
last_second = andre_;
forsinkelse (200);
Ved hjelp av koden ovenfor kan vi få NTP -tid fra serveren. For å få riktig tid på LCD må du gjøre endringer i henhold til tidssonen din.
NTPClient TimeClient (NTPUDP, "Asia.basseng.ntp.org ", 18000, 60000);
For tiden er landet der jeg bor 5 timer foran koordinert universell tid (UTC -tid). Så jeg må konvertere 5 timer til sekunder.
+5 timer = 5x60x60 = 18.000 sekunder
Endre denne tidssonen i henhold til din beliggenhet. Du kan bruke Google for å sjekke Gmt offset for landet ditt.
Endre i tillegg nettverket SSID og passord definert i koden.
Kode startet med å ringe de installerte bibliotekene. I2C LCD, ESP32 WiFi, NTPClient og Time Library.
NtpClient.h Bibliotek vil koble ESP32 med NTP -server og Wifiudp.h vil sende og motta UDP -meldinger.
For å kommunisere med NTP Time Server UDP -protokoll brukes. For å få tid fra NTP Internet Server, må variabler NTP -serveradresse, NTP -forskyvning og NTP -intervall defineres.
NTPClient TimeClient (NTPUDP, "Asia.basseng.ntp.org ", 18000, 60000);
NTP -serveren sender tidsinformasjon til ESP32. Mottatt tid er i Unix Timestamp (UNIX Epoch) -format. Tidsbibliotek vil konvertere Unix Epoch Tid til minutter, timer og dagformat.
Neste I2C -adresse (0x27) av LCD er definert. I tillegg er størrelsen på LCD 16 × 2 også konfigurert.
I Løkke funksjon tidsklient.Oppdater() Funksjonen vil få tid fra NTP -serveren og lagre den i tidsvariabelen.
Produksjon
På seriemonitoren vil du se utgangen nedenfor:
På LCD -skjermen kan en klokke med oppdatert dato og klokkeslett sees.
Konklusjon
ESP32 er et kompakt mikrokontrollerbasert IoT -brett. Denne artikkelen dekker alle trinn som trengs for å designe en sanntids NTP-serverbasert klokke. Utgangen vises på LCD -skjermen ved hjelp av Arduino -koden. Ved å angi riktig NTP -server kan alle designe en klokke basert på tidssonen deres ved hjelp av ESP32 og Arduino -koden.