Vi har redan gjort en tutorial på DS1307 gränssnitt med ESP32-modulen . Idag kommer vi att diskutera grunderna för DS3231 RTC-sensorn och kolla hur man kan koppla den till ESP32-kortet.
Innehållsförteckning:
2. Hur man gränssnitt DS3231 med ESP32
6. Hur man visar RTC DS3231-tiden på en OLED-skärm med ESP32
1. Vad är DS3231 RTC-modulen
DS3231-modulen ger mycket exakt tidtagning. Den innehåller en integrerad temperaturkompenserad kristalloscillator (TCXO) för att ge oss tid med stor precision. Modulen arbetar på I2C-protokollet med Master-Slave-konfigurationen. Den kan hålla tid och datum med ett reservbatteri även när det inte finns någon huvudström. Det används ofta i enheter som är tids- och datumberoende.
DS3231 håller koll på sekunder, minuter och timmar. Den kan också hålla ett register över datum och veckodagar. När det gäller skottår anpassar den automatiskt tiden därefter. Den kan också visa tid i både 12-timmars- och 24-timmarsformat, komplett med en AM/PM-indikator.
1.1. DS3231 mot DS1307
Både DS3231 och DS1307 är tidshållningsmoduler med stöd för batteribackup. DS3231 är dock mer exakt än DS1307. Den främsta anledningen är att DS1307 är beroende av extern 32kHz kristall för tidtagning.
RTC DS3231 har dock en intern temperaturkompenserad kristalloscillator (TCXO). Detta gör att den påverkas mindre av yttre temperatur och som ett resultat har den en precisionsfördel på några minuter per år än DS1307.
1.2. DS3231 Pinout
DS3231 fungerar med I2C-protokollet. I hjärtat av denna RTC-modul har vi det exakta RTC-chippet designat av Maxim. Detta chip hanterar alla tidsfunktioner och kommunicerar med I2C med ESP32 eller Arduino-kort.
Huvudstiften för RTC DS3231-moduler är:
- VCC: Anslut detta stift till den positiva polen på din strömkälla.
- GND: Jordförbindelse.
- SDA: Seriell datastift (används för I2C-kommunikation).
- SCL: Seriell klockstift (också en del av I2C-gränssnittet).
- QW: Square Wave-utgångsstift (kan generera en periodisk signal, t.ex. för larm eller andra tidsändamål).
- 32K: 32KHz oscillatorutgång (användbart för exakta timingapplikationer).
Följande är huvudkomponenterna i RTC DS3231-modulen:
- Batteri hållare: Det gör att modulen kan fortsätta köras när den externa strömmen saknas.
- RTC-chip: Detta chip upprätthåller tid och datum.
- AT24C32 EEPROM: Den tillhandahåller icke-flyktig lagring för dataloggning och andra ändamål med 1 000 000 skrivcykler.
- TCXO: Temperaturkompenserad oscillator för att ge rätt tid för ett varierande temperaturområde.
- Temperatursensor: Den tar temperaturavläsningar och tillhandahåller dem som en del av modulens funktion.
2. Hur man gränssnitt DS3231 med ESP32
För att ansluta DS3231 till ESP32 måste du installera RTClib-bibliotek först. Efter att du har installerat detta Adafruit RTC-bibliotek kan du ansluta ditt ESP32-kort med DS3231 med I2C-protokollet. För att ansluta ESP32 I2C med RTC DS3231-modulen kan du använda stiften ESP32 D21 och D22.
2.1. Kopplingsschema för ESP32 med RTC DS3231
Först måste du koppla ESP32 till din I2C RTC DS3231-modul. Följ nedanstående stiftkonfiguration för kabeldragning:
Efter att ha anslutit ESP32 med RTC DS3231 bör ditt kopplingsschema se ut så här. Du kan också driva DS3231 från VIN-stiftet på ESP32. Driftspänningarna för DS3231 är 3,3 till 5,5 VDC.
2.2. Installera de nödvändiga biblioteken
När kretsen är klar är nästa steg att konfigurera ditt ESP32-kort med Arduino IDE . För gränssnitt DS3231 måste du installera RTClib-bibliotek . Du kan installera det genom att använda Arduino IDE-bibliotekshanteraren.
3. Hårdvara
Du behöver följande hårdvara för att designa den DS3231-baserade RTC-klockan med ESP32:
- ESP32 utvecklingskort
- RTC DS3231-modul
- CR2032 batteri
- Bygeltrådar
- Bakbord
4. Kod
Efter installation av RTC-biblioteket är nästa del att skriva koden för DS3231 och ladda upp den till ESP32-kortet. Först måste du skriva koden för att ställa in din aktuella tid. När du har ställt in tiden i DS3231 kommer den att komma ihåg tiden och fortsätta köra även om ditt ESP32-kort stängs av.
Öppna nu Arduino IDE, kompilera och bränn koden till ESP32-kortet.
#include#include
RTC_DS3231 rtc ; // Initiera en instans av klassen RTC_DS3231
tomhet uppstart ( ) {
Serie. Börja ( 115200 ) ;
Tråd. Börja ( ) ;
om ( ! rtc. Börja ( ) ) {
Serie. println ( 'RTC inte upptäckt' ) ;
medan ( 1 ) ; // Häng på obestämd tid om RTC inte hittas
}
//Avkommentera raden nedan för att ställa in första datum och tid
//rtc.adjust(DateTime(__DATE__, __TIME__));
}
tomhet slinga ( ) {
// Läs aktuell tid från sensorn (DS3231)
DateTime nu = rtc. nu ( ) ;
// Skriv ut datum och tid på samma rad med två siffror för timmar, minuter och sekunder
Serie. skriva ut ( 'Dagens datum: ' ) ;
Serie. skriva ut ( nu. år ( ) , DEC ) ;
Serie. skriva ut ( '/' ) ;
printTwoDigits ( nu. månad ( ) ) ;
Serie. skriva ut ( '/' ) ;
printTwoDigits ( nu. dag ( ) ) ;
Serie. skriva ut ( ' Aktuell tid: ' ) ;
printTwoDigits ( nu. timme ( ) ) ;
Serie. skriva ut ( ':' ) ;
printTwoDigits ( nu. minut ( ) ) ;
Serie. skriva ut ( ':' ) ;
printTwoDigits ( nu. andra ( ) ) ;
Serie. println ( ) ;
dröjsmål ( 1000 ) ; // Uppdatera var 1:e sekund
}
tomhet printTwoDigits ( int siffra ) {
om ( siffra < 10 ) {
Serie. skriva ut ( '0' ) ; // Lägg till en inledande nolla för ensiffriga tal
}
Serie. skriva ut ( siffra ) ;
}
4.1. Kodförklaring
Koden börjar med att initiera den seriella I2C-kommunikationen med hjälp av ett trådbibliotek. Efter det inkluderade vi RTC-biblioteket från Adafruit för gränssnitt med DS3231-modulen. Detta bibliotek tillhandahåller en funktion för att interagera med RTC DS3231-modulen.
I den uppstart del, startas I2C-bussen och kontrolleras för tillgängliga I2C-enheter. Om det inte hittas hänger programmet på obestämd tid. Baudhastigheten är också definierad så att du kan kontrollera utdata på Arduino IDE seriell monitor.
Ställa klockan för första gången
När du programmerar DS3231 måste du avkommentera denna rad . Detta kommer att få din systemtid och lagra den i RTC-minnet. Genom att göra detta synkroniseras RTC-modulens klocka med din systemklocka.
//rtc.adjust(DateTime(__DATE__, __TIME__)); 
När tiden är inställd måste du ladda upp ovanstående kod igen, men den här gången måste du kommentera funktionsraden rtc.adjust(). . Annars kommer detta att skriva över din tidigare inställda tid och när din ESP32 stängs av startar RTC igen från det att du laddade upp koden.
Genom att göra detta kommer din tid att förbli närvarande i RTC-modulens bakgrund så länge som RTC-modulen har ström i sin CR2032-cell.
I den slinga del läses det aktuella datumet och tiden från DS3231-modulen med hjälp av funktionen rtc.now(). Datum- och tidskomponenterna extraheras och det formaterade datumet skrivs ut på Arduino IDE seriell monitor varannan sekund.
5. Utgång
Efter att ha laddat upp koden till ESP32-kortet kommer du att se att tiden börjar skrivas ut på Arduino IDE seriell monitor.
6. Hur man visar RTC DS3231-tiden på OLED-skärmen med ESP32
Du kan också gå ett steg längre och visa tiden på din OLED-skärm efter att ha läst den från DS3231. För detta måste du installera Adafruit GFX SSD1306 bibliotek i Arduino IDE.
När den är installerad, anslut ESP32 med OLED- och RTC-modulen i följande konfiguration.
Efter att ha anslutit din sensor kommer du att se kretsen se ut som nedanstående schematiska diagram.
Ladda nu upp följande DS3231-kod till ESP32-kortet.
#include#include
#include
#include 'RTClib.h'
RTC_DS3231 rtc ;
röding dagar [ 7 ] [ 12 ] = { 'söndag' , 'måndag' , 'tisdag' , 'onsdag' , 'torsdag' , 'Fredag' , 'lördag' } ;
Adafruit_SSD1306-skärm = Adafruit_SSD1306 ( 128 , 64 , & Tråd , - 1 ) ;
tomhet uppstart ( ) {
Serie. Börja ( 115200 ) ;
visa. Börja ( SSD1306_SWITCHCAPVCC , 0x3C ) ;
om ( ! rtc. Börja ( ) ) {
Serie. println ( 'Kunde inte hitta RTC! Kontrollera kretsen.' ) ;
medan ( 1 ) ;
}
//avkommentera raden nedan när du ställer in tiden för första gången
//rtc.adjust(DateTime(__DATE__, __TIME__));
visa. clearDisplay ( ) ;
visa. setTextColor ( VIT ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 0 , tjugo ) ;
visa. skriva ut ( 'RTC CLOCK' ) ;
visa. visa ( ) ;
dröjsmål ( 5 000 ) ;
}
tomhet slinga ( ) {
DateTime nu = rtc. nu ( ) ;
visa. clearDisplay ( ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 75 , 0 ) ;
visa. println ( nu. andra ( ) , DEC ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 25 , 0 ) ;
visa. println ( ':' ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 65 , 0 ) ;
visa. println ( ':' ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 40 , 0 ) ;
visa. println ( nu. minut ( ) , DEC ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 0 , 0 ) ;
visa. println ( nu. timme ( ) , DEC ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 0 , 25 ) ;
visa. println ( nu. dag ( ) , DEC ) ;
visa. skriva ut ( dagar [ nu. veckodag ( ) ] ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( tjugo , 25 ) ;
visa. println ( '-' ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 35 , 25 ) ;
visa. println ( nu. månad ( ) , DEC ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 60 , 25 ) ;
visa. println ( '-' ) ;
visa. setTextSize ( 2 ) ;
visa. setCursor ( 75 , 25 ) ;
visa. println ( nu. år ( ) , DEC ) ;
visa. visa ( ) ;
}
Kodförklaring
Koden började med några viktiga bibliotek som krävs för RTC- och OLED-skärmar. OLED-skärmen ställs in med Adafruit SSD1306-biblioteket.
I loopdelen erhålls aktuellt datum och tid med hjälp av rtc.now(). Därefter rensas OLED-skärmen och tidskomponenterna visas i digitalt klockformat. Du kan också ändra koden för att justera datum- och tidsformatet.
När koden har laddats upp till din tavla får du aktuell tid på OLED-skärmen.
Notera: Ovanstående kod använder 0x3C I2C-adress för OLED. Detta är den vanligaste I2C-adressen som finns tillgänglig på SSD1306 OLED-skärmar. Om du vill hitta I2C-adressen för din OLED-skärm kan du köra I2C-skannerkod .
Slutsats
DS3231 är en RTC-sensor som kan användas för tidtagning. Den har en batteribackup som kan hålla tiden korrekt även om ditt mikrokontrollkort är avstängt. För att ansluta ESP2 till DS3231 måste du installera RTClib-biblioteket i din Arduino IDE. Efter det måste du ansluta RTC-modulen över I2C-protokollet med det digitala stiftet på ESP32. När du är ansluten laddar du bara upp koden och justerar tiden. Nu kommer RTC-sensorn att hålla tiden, och du kan läsa den på din seriella monitor på designtidsbaserade projekt.