Már készítettünk egy bemutatót DS1307 interfész az ESP32 modullal . Ma megvitatjuk a DS3231 RTC érzékelő alapjait, és megvizsgáljuk, hogyan lehet csatlakoztatni az ESP32 kártyához.
Tartalomjegyzék:
2. A DS3231 interfésze az ESP32-vel
6. Az RTC DS3231 idő megjelenítése OLED képernyőn ESP32 használatával
1. Mi az a DS3231 RTC modul?
A DS3231 modul rendkívül pontos időmérést biztosít. Tartalmaz egy integrált hőmérséklet-kompenzált kristályoszcillátort (TCXO), amely nagy pontossággal időt ad nekünk. A modul az I2C protokollon működik, Master-Slave konfigurációval. Tartalék akkumulátorral képes megtartani az időt és a dátumot akkor is, ha nincs fő bemeneti táp. Általában idő- és dátumfüggő eszközökben használják.
A DS3231 nyomon követi a másodperceket, perceket és órákat. A dátumokat és a hétköznapokat is rögzítheti. Szökőévek esetén automatikusan ennek megfelelően állítja be az időt. Ezenkívül az időt 12 órás vagy 24 órás formátumban is képes megjeleníteni, kiegészítve egy AM/PM jelzővel.
1.1. DS3231 vs DS1307
Mind a DS3231, mind a DS1307 időmérő modul, akkumulátoros tartalék támogatással. A DS3231 azonban pontosabb, mint a DS1307. Ennek fő oka az, hogy a DS1307 külső 32 kHz-es kristálytól függ az időméréshez.
Az RTC DS3231 azonban rendelkezik egy belső hőmérséklet-kompenzált kristályoszcillátorral (TCXO). Ezáltal kevésbé befolyásolja a külső hőmérséklet, és ennek eredményeként évi néhány perc pontossági előnnyel rendelkezik, mint a DS1307.
1.2. DS3231 Pinout
A DS3231 az I2C protokollt használja. Ennek az RTC-modulnak a középpontjában a Maxim által tervezett pontos RTC chip áll. Ez a chip kezeli az összes időfunkciót, és az I2C-n keresztül kommunikál ESP32 vagy Arduino kártyával.
Az RTC DS3231 modulok fő érintkezői a következők:
- VCC: Csatlakoztassa ezt a tűt az áramforrás pozitív kivezetéséhez.
- GND: Föld csatlakozás.
- SDA: Soros adat érintkező (I2C kommunikációhoz használatos).
- SCL: Serial Clock pin (szintén az I2C interfész része).
- QW: Square Wave kimeneti láb (időszakos jelet generálhat, például riasztásokhoz vagy egyéb időzítési célokra).
- 32K: 32KHz-es oszcillátor kimenet (pontos időzítési alkalmazásokhoz hasznos).
A következők az RTC DS3231 modul fő fedélzeti összetevői:
- Akkumulátor tartó: Lehetővé teszi, hogy a modul tovább működjön, ha a külső táp hiányzik.
- RTC chip: Ez a chip megtartja az időt és a dátumot.
- AT24C32 EEPROM: Nem felejtő tárhelyet biztosít adatnaplózáshoz és egyéb célokra 1 000 000 írási ciklussal.
- TCXO: Hőmérséklet-kompenzált oszcillátor, amely a megfelelő időt biztosítja a változó hőmérséklet-tartományokhoz.
- Hőmérséklet szenzor: Hőmérséklet-leolvasásokat vesz, és a modul szolgáltatásának részeként biztosítja.
2. A DS3231 és az ESP32 összekapcsolása
A DS3231 és az ESP32 összekapcsolásához telepítenie kell a RTClib könyvtár első. Az Adafruit RTC könyvtár telepítése után az I2C protokoll használatával csatlakoztathatja ESP32 kártyáját a DS3231-hez. Az ESP32 I2C és az RTC DS3231 modul összekapcsolásához használhatja az ESP32 D21 és D22 érintkezőket.
2.1. Az ESP32 és az RTC DS3231 bekötési rajza
Először is össze kell kötnie az ESP32-t az I2C RTC DS3231 modullal. Kövesse az alábbi érintkező-konfigurációt a huzalozáshoz:
Miután csatlakoztatta az ESP32-t az RTC DS3231-hez, a kapcsolási rajznak így kell kinéznie. A DS3231 tápellátását az ESP32 VIN érintkezőjéről is megteheti. A DS3231 üzemi feszültsége 3,3-5,5 VDC.
2.2. A szükséges könyvtárak telepítése
Ha az áramkör készen áll, a következő lépés az konfigurálja az ESP32 kártyát az Arduino IDE-vel . A DS3231 interfészhez telepítenie kell a RTClib könyvtár . Telepítheti az Arduino IDE könyvtárkezelővel.
3. Hardver
A következő hardverre lesz szüksége a DS3231 alapú RTC óra ESP32-vel történő megtervezéséhez:
- ESP32 fejlesztő tábla
- RTC DS3231 modul
- CR2032 elem
- Jumper vezetékek
- Kenyértábla
4. Kód
Az RTC könyvtár telepítése után a következő rész a DS3231 kódjának megírása és az ESP32 kártyára való feltöltése. Először is meg kell írnia a kódot az aktuális idő beállításához. Miután beállította az időt a DS3231-ben, megjegyzi az időt, és akkor is tovább fut, ha az ESP32 kártyát kikapcsolják.
Most nyissa meg az Arduino IDE-t, fordítsa le, és írja be a kódot az ESP32 kártyára.
#include#include
RTC_DS3231 rtc ; // Inicializálja az RTC_DS3231 osztály egy példányát
üres beállít ( ) {
Sorozatszám. kezdődik ( 115200 ) ;
Huzal. kezdődik ( ) ;
ha ( ! rtc. kezdődik ( ) ) {
Sorozatszám. println ( 'RTC nem észlelve' ) ;
míg ( 1 ) ; // Határozatlan ideig lefagy, ha az RTC nem található
}
//A kezdeti dátum és idő beállításához törölje a megjegyzéseket az alábbi sorból
//rtc.adjust(DateTime(__DATE__, __TIME__));
}
üres hurok ( ) {
// Az aktuális idő leolvasása az érzékelőről (DS3231)
DateTime most = rtc. Most ( ) ;
// A dátum és az idő kinyomtatása ugyanabba a sorba, két számjeggyel óra, perc és másodperc értékben
Sorozatszám. nyomtatás ( 'Mostani dátum: ' ) ;
Sorozatszám. nyomtatás ( Most. év ( ) , DECEMBER ) ;
Sorozatszám. nyomtatás ( '/' ) ;
printTwoDigits ( Most. hónap ( ) ) ;
Sorozatszám. nyomtatás ( '/' ) ;
printTwoDigits ( Most. nap ( ) ) ;
Sorozatszám. nyomtatás ( ' Aktuális idő: ' ) ;
printTwoDigits ( Most. óra ( ) ) ;
Sorozatszám. nyomtatás ( ':' ) ;
printTwoDigits ( Most. perc ( ) ) ;
Sorozatszám. nyomtatás ( ':' ) ;
printTwoDigits ( Most. második ( ) ) ;
Sorozatszám. println ( ) ;
késleltetés ( 1000 ) ; // Frissítés 1 másodpercenként
}
üres printTwoDigits ( int szám ) {
ha ( szám < 10 ) {
Sorozatszám. nyomtatás ( '0' ) ; // Kezdő nulla hozzáadása az egyjegyű számokhoz
}
Sorozatszám. nyomtatás ( szám ) ;
}
4.1. Kód magyarázata
A kód a soros I2C kommunikáció inicializálásával kezdődik egy vezetékes könyvtár segítségével. Ezt követően beépítettük az Adafruit RTC könyvtárát a DS3231 modullal való interfészhez. Ez a könyvtár funkciót biztosít az RTC DS3231 modullal való interakcióhoz.
Ban,-ben beállít részben elindul az I2C busz, és ellenőrzi az elérhető I2C eszközöket. Ha nem található, a program határozatlan ideig lefagy. Az adatátviteli sebesség is meg van határozva, így ellenőrizheti a kimenetet az Arduino IDE soros monitoron.
Az óra első beállítása
A DS3231 programozásakor muszáj törölje ezt a sort . Ez lekéri a rendszeridőt, és tárolja azt az RTC memóriában. Ezzel az RTC modul órája szinkronizálódik a rendszer órájával.
//rtc.adjust(DateTime(__DATE__, __TIME__)); 
Az idő beállítása után újra fel kell töltenie a fenti kódot, de ezúttal muszáj kommentálja az rtc.adjust() függvénysort . Ellenkező esetben ez felülírja az előzőleg beállított időt, és amikor az ESP32 ki van kapcsolva, az RTC újraindul a kód feltöltésének időpontjától.
Ezáltal az Ön ideje jelen marad az RTC modul hátterében mindaddig, amíg az RTC modul tápellátása van a CR2032 cellában.
Ban,-ben hurok részben az aktuális dátumot és időt a DS3231 modulból olvassa ki az rtc.now() függvény segítségével. A dátum és az idő összetevők kibontásra kerülnek, és a formázott dátum másodpercenként kinyomtatásra kerül az Arduino IDE soros monitoron.
5. Kimenet
Miután feltöltötte a kódot az ESP32 kártyára, látni fogja, hogy az idő elkezdődik a nyomtatás az Arduino IDE soros monitoron.
6. Az RTC DS3231 idő megjelenítése az OLED képernyőn ESP32 használatával
Egy lépéssel tovább is léphet, és megjelenítheti az időt az OLED-képernyőn, miután elolvasta a DS3231-ről. Ehhez telepítenie kell a Adafruit GFX SSD1306 könyvtár az Arduino IDE-ben.
A telepítés után csatlakoztassa az ESP32-t az OLED és az RTC modulhoz a következő konfigurációban.
Az érzékelő csatlakoztatása után látni fogja, hogy az áramkör az alábbi kapcsolási rajz szerint néz ki.
Most töltse fel a következő DS3231 kódot az ESP32 kártyára.
#include#include
#include
#include 'RTClib.h'
RTC_DS3231 rtc ;
char napok [ 7 ] [ 12 ] = { 'Vasárnap' , 'Hétfő' , 'Kedd' , 'Szerda' , 'Csütörtök' , 'Péntek' , 'Szombat' } ;
Adafruit_SSD1306 kijelző = Adafruit_SSD1306 ( 128 , 64 , & Huzal , - 1 ) ;
üres beállít ( ) {
Sorozatszám. kezdődik ( 115200 ) ;
kijelző. kezdődik ( SSD1306_SWITCHCAPVCC , 0x3C ) ;
ha ( ! rtc. kezdődik ( ) ) {
Sorozatszám. println ( 'Nem található az RTC! Ellenőrizze az áramkört.' ) ;
míg ( 1 ) ;
}
//törölje az alábbi sor megjegyzését az idő első beállításánál
//rtc.adjust(DateTime(__DATE__, __TIME__));
kijelző. clearDisplay ( ) ;
kijelző. setTextColor ( FEHÉR ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 0 , húsz ) ;
kijelző. nyomtatás ( 'RTC ÓRA' ) ;
kijelző. kijelző ( ) ;
késleltetés ( 5000 ) ;
}
üres hurok ( ) {
DateTime most = rtc. Most ( ) ;
kijelző. clearDisplay ( ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 75 , 0 ) ;
kijelző. println ( Most. második ( ) , DECEMBER ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 25 , 0 ) ;
kijelző. println ( ':' ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 65 , 0 ) ;
kijelző. println ( ':' ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 40 , 0 ) ;
kijelző. println ( Most. perc ( ) , DECEMBER ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 0 , 0 ) ;
kijelző. println ( Most. óra ( ) , DECEMBER ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 0 , 25 ) ;
kijelző. println ( Most. nap ( ) , DECEMBER ) ;
kijelző. nyomtatás ( napok [ Most. a hét napja ( ) ] ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( húsz , 25 ) ;
kijelző. println ( '-' ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 35 , 25 ) ;
kijelző. println ( Most. hónap ( ) , DECEMBER ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 60 , 25 ) ;
kijelző. println ( '-' ) ;
kijelző. setTextSize ( 2 ) ;
kijelző. setCursor ( 75 , 25 ) ;
kijelző. println ( Most. év ( ) , DECEMBER ) ;
kijelző. kijelző ( ) ;
}
Kód magyarázata
A kód néhány fontos könyvtárral kezdődött, amelyek az RTC és OLED képernyőkhöz szükségesek. Az OLED-kijelző az Adafruit SSD1306 könyvtár használatával van beállítva.
A ciklusrészben az aktuális dátumot és időt az rtc.now() segítségével kapjuk meg. Ezt követően az OLED képernyő törlődik, és az időkomponensek digitális óraformátumban jelennek meg. A kód módosításával is módosíthatja a dátum és az idő formátumát.
A kód feltöltése után az OLED képernyőn megjelenik az aktuális idő.
Jegyzet: A fenti kód a 0x3C I2C cím az OLED-hez. Ez az SSD1306 OLED kijelzőkön elérhető leggyakoribb I2C-cím. Ha meg szeretné találni az OLED képernyő I2C-címét, futtassa a I2C szkenner kódja .
Következtetés
A DS3231 egy RTC érzékelő, amely időmérésre használható. Akkumulátorral rendelkezik, amely még akkor is pontosan tudja tartani az időt, ha a mikrokontroller kártya ki van kapcsolva. Az ESP2 és a DS3231 összekapcsolásához telepítenie kell az RTClib könyvtárat az Arduino IDE-be. Ezt követően az RTC modult az I2C protokollon keresztül kell csatlakoztatnia az ESP32 digitális tűjével. Csatlakozás után egyszerűen töltse fel a kódot, és állítsa be az időt. Most az RTC érzékelő tartja az időt, és leolvashatja a soros monitoron a tervezési időalapú projektek során.