Vi har allerede laget en opplæring om DS1307 grensesnitt med ESP32-modulen . I dag skal vi diskutere det grunnleggende om DS3231 RTC-sensoren og sjekke hvordan man kan koble den til ESP32-kortet.
Innholdsfortegnelse:
2. Hvordan grensesnitt DS3231 med ESP32
6. Hvordan vise RTC DS3231-tiden på en OLED-skjerm ved hjelp av ESP32
1. Hva er DS3231 RTC-modulen
DS3231-modulen gir svært nøyaktig tidtaking. Den inkluderer en integrert temperaturkompensert krystalloscillator (TCXO) for å gi oss tid med stor presisjon. Modulen opererer på I2C-protokollen ved å bruke Master-Slave-konfigurasjonen. Den kan holde tid og dato med et reservebatteri selv når det ikke er noen hovedinngangsstrøm. Det brukes ofte i enheter som er avhengig av tid og dato.
DS3231 holder øye med sekunder, minutter og timer. Den kan også holde oversikt over datoer og ukedager. Når det gjelder skuddår, justerer den automatisk tiden deretter. Den kan også vise tid i både 12-timers eller 24-timers format, komplett med en AM/PM-indikator.
1.1. DS3231 vs DS1307
Både DS3231 og DS1307 er tidsregistreringsmoduler med batteristøtte. Imidlertid er DS3231 mer nøyaktig enn DS1307. Hovedårsaken er at DS1307 er avhengig av ekstern 32kHz krystall for tidtaking.
Imidlertid har RTC DS3231 en intern temperaturkompensert krystalloscillator (TCXO). Dette gjør den mindre påvirket av ytre temperatur og som et resultat har den en nøyaktighetsfordel på noen få minutter per år enn DS1307.
1.2. DS3231 Pinout
DS3231 fungerer med I2C-protokollen. I hjertet av denne RTC-modulen har vi den nøyaktige RTC-brikken designet av Maxim. Denne brikken håndterer alle tidsfunksjoner og kommuniserer ved hjelp av I2C med ESP32 eller Arduino-kort.
Hovedpinnene til RTC DS3231-moduler er:
- VCC: Koble denne pinnen til den positive polen på strømkilden.
- GND: Jordforbindelse.
- SDA: Seriell datapinne (brukes til I2C-kommunikasjon).
- SCL: Serial Clock pin (også en del av I2C-grensesnittet).
- QW: Square Wave utgangspinne (kan generere et periodisk signal, f.eks. for alarmer eller andre timingformål).
- 32K: 32KHz oscillatorutgang (nyttig for presise timingapplikasjoner).
Følgende er hovedkomponentene i RTC DS3231-modulen:
- Batteriholder: Det lar modulen fortsette å kjøre når den eksterne strømmen mangler.
- RTC-brikke: Denne brikken opprettholder klokkeslett og dato.
- AT24C32 EEPROM: Den gir ikke-flyktig lagring for datalogging og andre formål med 1 000 000 skrivesykluser.
- TCXO: Temperaturkompensert oscillator for å gi riktig tid for et varierende temperaturområde.
- Temperatur sensor: Den tar temperaturavlesninger og gir dem som en del av modulens funksjon.
2. Hvordan grensesnitt DS3231 med ESP32
For å koble DS3231 til ESP32, må du installere RTClib-bibliotek først. Etter å ha installert dette Adafruit RTC-biblioteket, kan du koble ESP32-kortet til DS3231 ved å bruke I2C-protokollen. For å koble ESP32 I2C med RTC DS3231-modulen, kan du bruke ESP32 D21 og D22 pinnene.
2.1. Koblingsskjema for ESP32 med RTC DS3231
Først må du koble ESP32 til I2C RTC DS3231-modulen. Følg den nedenfor gitte pinnekonfigurasjonen for kabling:
Etter å ha koblet ESP32 til RTC DS3231, skal koblingsskjemaet ditt se slik ut. Du kan også drive DS3231 fra VIN-pinnen til ESP32. Driftsspenningene til DS3231 er 3,3 til 5,5 VDC.
2.2. Installere de nødvendige bibliotekene
Når kretsen er klar, er neste trinn å konfigurer ESP32-kortet ditt med Arduino IDE . For grensesnitt DS3231, må du installere RTClib-bibliotek . Du kan installere den ved å bruke Arduino IDE-bibliotekbehandling.
3. Maskinvare
Du trenger følgende maskinvare for å designe den DS3231-baserte RTC-klokken med ESP32:
- ESP32 utviklingskort
- RTC DS3231-modul
- CR2032 batteri
- Jumper ledninger
- Brødbrett
4. Kode
Etter å ha installert RTC-biblioteket, er neste del å skrive koden for DS3231 og laste den opp til ESP32-kortet. Først må du skrive koden for å stille inn gjeldende tid. Etter at du har stilt inn tiden i DS3231, vil den huske tiden og fortsette å kjøre selv om ESP32-kortet blir slått av.
Åpne nå Arduino IDE, kompiler og brenn koden til ESP32-kortet.
#include#include
RTC_DS3231 rtc ; // Initialiser en forekomst av RTC_DS3231-klassen
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
Metalltråd. begynne ( ) ;
hvis ( ! rtc. begynne ( ) ) {
Seriell. println ( 'RTC ikke oppdaget' ) ;
samtidig som ( 1 ) ; // Heng på ubestemt tid hvis RTC ikke blir funnet
}
//Fjern kommentarfeltet under for å angi den første datoen og klokkeslettet
//rtc.adjust(DateTime(__DATE__, __TIME__));
}
tomrom Løkke ( ) {
// Les gjeldende tid fra sensoren (DS3231)
DatoTid nå = rtc. nå ( ) ;
// Skriv ut dato og klokkeslett på samme linje med to sifre for timer, minutter og sekunder
Seriell. skrive ut ( 'Dagens dato: ' ) ;
Seriell. skrive ut ( nå. år ( ) , DES ) ;
Seriell. skrive ut ( '/' ) ;
printToDigits ( nå. måned ( ) ) ;
Seriell. skrive ut ( '/' ) ;
printToDigits ( nå. dag ( ) ) ;
Seriell. skrive ut ( ' Nåværende tid: ' ) ;
printToDigits ( nå. time ( ) ) ;
Seriell. skrive ut ( ':' ) ;
printToDigits ( nå. minutt ( ) ) ;
Seriell. skrive ut ( ':' ) ;
printToDigits ( nå. sekund ( ) ) ;
Seriell. println ( ) ;
forsinkelse ( 1000 ) ; // Oppdater hvert 1. sekund
}
tomrom printToDigits ( int Antall ) {
hvis ( Antall < 10 ) {
Seriell. skrive ut ( '0' ) ; // Legg til en innledende null for enkeltsifrede tall
}
Seriell. skrive ut ( Antall ) ;
}
4.1. Kodeforklaring
Koden starter med å initialisere den serielle I2C-kommunikasjonen ved hjelp av et ledningsbibliotek. Etter det inkluderte vi RTC-biblioteket av Adafruit for grensesnitt med DS3231-modulen. Dette biblioteket har en funksjon for å samhandle med RTC DS3231-modulen.
I oppsett del, startes I2C-bussen og sjekkes for tilgjengelige I2C-enheter. Hvis det ikke blir funnet, henger programmet på ubestemt tid. Baudraten er også definert slik at du kan sjekke utgangen på Arduino IDE seriell monitor.
Stille klokken for første gang
Når du programmerer DS3231, må du avkommenter denne linjen . Dette vil få systemet tid og lagre det i RTC-minnet. Ved å gjøre dette blir RTC-modulklokken synkronisert med systemklokken.
//rtc.adjust(DateTime(__DATE__, __TIME__)); 
Etter at tiden er satt, må du laste opp koden ovenfor på nytt, men denne gangen må du kommenter funksjonslinjen rtc.adjust(). . Ellers vil dette overskrive den forrige innstilte tiden din, og når ESP32-en din er slått av, vil RTC-en starte på nytt fra det tidspunktet du lastet opp koden.
Ved å gjøre dette vil tiden din forbli tilstede i RTC-modulbakgrunnen så lenge RTC-modulen har strøm i CR2032-cellen.
I Løkke del, leses gjeldende dato og klokkeslett fra DS3231-modulen ved å bruke funksjonen rtc.now(). Dato- og tidskomponentene trekkes ut og den formaterte datoen skrives ut på Arduino IDE-serieskjermen hvert sekund.
5. Utgang
Etter å ha lastet opp koden til ESP32-kortet, vil du se at tiden begynner å skrives ut på Arduino IDE-serieskjermen.
6. Hvordan vise RTC DS3231-tiden på OLED-skjermen ved hjelp av ESP32
Du kan også gå ett skritt videre og vise tiden på OLED-skjermen etter å ha lest den fra DS3231. For dette må du installere Adafruit GFX SSD1306-bibliotek i Arduino IDE.
Når den er installert, kobler du ESP32 til OLED- og RTC-modulen i følgende konfigurasjon.
Etter å ha koblet til sensoren, vil du se kretsen se ut som det skjematiske diagrammet nedenfor.
Last nå opp følgende DS3231-kode til ESP32-kortet.
#include#include
#include
#include 'RTClib.h'
RTC_DS3231 rtc ;
røye dager [ 7 ] [ 12 ] = { 'Søndag' , 'Mandag' , 'Tirsdag' , 'Onsdag' , 'Torsdag' , 'Fredag' , 'Lørdag' } ;
Adafruit_SSD1306-skjerm = Adafruit_SSD1306 ( 128 , 64 , & Metalltråd , - 1 ) ;
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
vise. begynne ( SSD1306_SWITCHCAPVCC , 0x3C ) ;
hvis ( ! rtc. begynne ( ) ) {
Seriell. println ( 'Kunne ikke finne RTC! Sjekk krets.' ) ;
samtidig som ( 1 ) ;
}
//kommenter linjen under mens du angir tid for første gang
//rtc.adjust(DateTime(__DATE__, __TIME__));
vise. klardisplay ( ) ;
vise. sett tekstfarge ( HVIT ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 0 , tjue ) ;
vise. skrive ut ( 'RTC CLOCK' ) ;
vise. vise ( ) ;
forsinkelse ( 5000 ) ;
}
tomrom Løkke ( ) {
DatoTid nå = rtc. nå ( ) ;
vise. klardisplay ( ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 75 , 0 ) ;
vise. println ( nå. sekund ( ) , DES ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 25 , 0 ) ;
vise. println ( ':' ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 65 , 0 ) ;
vise. println ( ':' ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 40 , 0 ) ;
vise. println ( nå. minutt ( ) , DES ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 0 , 0 ) ;
vise. println ( nå. time ( ) , DES ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 0 , 25 ) ;
vise. println ( nå. dag ( ) , DES ) ;
vise. skrive ut ( dager [ nå. ukedag ( ) ] ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( tjue , 25 ) ;
vise. println ( '-' ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 35 , 25 ) ;
vise. println ( nå. måned ( ) , DES ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 60 , 25 ) ;
vise. println ( '-' ) ;
vise. settTekststørrelse ( 2 ) ;
vise. setMarkør ( 75 , 25 ) ;
vise. println ( nå. år ( ) , DES ) ;
vise. vise ( ) ;
}
Kodeforklaring
Koden startet med noen viktige biblioteker som kreves for RTC- og OLED-skjermer. OLED-skjermen er satt opp ved hjelp av Adafruit SSD1306-biblioteket.
I løkkedelen hentes gjeldende dato og klokkeslett ved å bruke rtc.now(). Etter det tømmes OLED-skjermen og tidskomponentene vises i digitalt klokkeformat. Du kan også endre koden for å justere dato- og klokkeslettformatet.
Når koden er lastet opp til brettet ditt, vil du få gjeldende tid på OLED-skjermen.
Merk: Koden ovenfor bruker 0x3C I2C-adresse for OLED. Dette er den vanligste I2C-adressen som er tilgjengelig på SSD1306 OLED-skjermer. Hvis du vil finne I2C-adressen for OLED-skjermen din, kan du kjøre I2C skannerkode .
Konklusjon
DS3231 er en RTC-sensor som kan brukes til tidtaking. Den har en batteribackup som kan holde tiden nøyaktig selv om mikrokontrollerkortet er slått av. For å koble ESP2 til DS3231, må du installere RTClib-biblioteket i din Arduino IDE. Etter det må du koble til RTC-modulen over I2C-protokollen ved å bruke den digitale pinnen til ESP32. Når du er koblet til, laster du bare opp koden og justerer tiden. Nå vil RTC-sensoren holde tid, og du kan lese den på din serielle monitor på designtidsbaserte prosjekter.