Am făcut deja un tutorial despre Interfața DS1307 cu modulul ESP32 . Astăzi vom discuta elementele de bază ale senzorului DS3231 RTC și vom verifica cum se poate interfața cu placa ESP32.
Cuprins:
2. Cum să interfați DS3231 cu ESP32
6. Cum să afișați ora RTC DS3231 pe un ecran OLED utilizând ESP32
1. Ce este modulul DS3231 RTC
Modulul DS3231 oferă o cronometrare foarte precisă. Include un oscilator cu cristal compensat de temperatură (TCXO) integrat pentru a ne oferi timp cu mare precizie. Modulul funcționează pe protocolul I2C folosind configurația Master-Slave. Poate păstra ora și data cu o baterie de rezervă chiar și atunci când nu există alimentare principală. Este folosit în mod obișnuit în dispozitivele care depind de oră și dată.
DS3231 ține cont de secunde, minute și ore. De asemenea, poate ține o evidență a datelor și a zilelor lucrătoare. Când se ocupă de anii bisecți, acesta ajustează automat timpul în consecință. De asemenea, poate afișa timpul atât în format de 12 ore, cât și în format de 24 de ore, complet cu un indicator AM/PM.
1.1. DS3231 vs DS1307
Atât DS3231, cât și DS1307 sunt module de menținere a timpului cu suport pentru baterie de rezervă. Cu toate acestea, DS3231 este mai precis decât DS1307. Motivul principal este că DS1307 depinde de un cristal extern de 32 kHz pentru cronometrarea.
Cu toate acestea, RTC DS3231 dispune de un oscilator cu cristal compensat cu temperatură (TCXO). Acest lucru îl face mai puțin afectat de temperatura externă și, prin urmare, are un avantaj de precizie de câteva minute pe an decât DS1307.
1.2. Pinout DS3231
DS3231 funcționează folosind protocolul I2C. În centrul acestui modul RTC, avem cipul RTC precis proiectat de Maxim. Acest cip gestionează toate funcțiile de timp și comunică folosind I2C cu ESP32 sau placa Arduino.
Pinii principali ai modulelor RTC DS3231 sunt:
- VCC: Conectați acest pin la borna pozitivă a sursei de alimentare.
- GND: Conexiune la pământ.
- SDA: Pin de date seriale (utilizat pentru comunicarea I2C).
- SCL: Pin Serial Clock (care face parte și din interfața I2C).
- QW: Pin de ieșire unde pătrate (poate genera un semnal periodic, de exemplu, pentru alarme sau alte scopuri de sincronizare).
- 32K: Ieșire oscilator 32KHz (utilă pentru aplicații precise de sincronizare).
Următoarele sunt principalele componente integrate ale modulului RTC DS3231:
- Suport de baterie: Permite modulului să continue să funcționeze atunci când alimentarea externă este absentă.
- Chip RTC: Acest cip menține ora și data.
- AT24C32 EEPROM: Oferă stocare nevolatilă pentru înregistrarea datelor și alte scopuri cu 1.000.000 de cicluri de scriere.
- TCXO: Oscilator compensat cu temperatură pentru a oferi timpul corect pentru o gamă variată de temperaturi.
- Senzor de temperatura: Preia citiri de temperatură și le furnizează ca parte a caracteristicii modulului.
2. Cum să interfați DS3231 cu ESP32
Pentru a interfața DS3231 cu ESP32, trebuie să instalați biblioteca RTClib primul. După instalarea acestei biblioteci Adafruit RTC, vă puteți conecta placa ESP32 la DS3231 folosind protocolul I2C. Pentru a conecta ESP32 I2C cu modulul RTC DS3231, puteți utiliza pinii ESP32 D21 și D22.
2.1. Schema de cablare a ESP32 cu RTC DS3231
În primul rând, trebuie să conectați ESP32 cu modulul dumneavoastră I2C RTC DS3231. Urmați configurația de pin dată mai jos pentru cablare:
După conectarea ESP32 la RTC DS3231, schema de cablare ar trebui să arate astfel. De asemenea, puteți alimenta DS3231 de la pinul VIN al ESP32. Tensiunile de funcționare ale DS3231 sunt de 3,3 până la 5,5 VDC.
2.2. Instalarea bibliotecilor necesare
Odată ce circuitul este gata, următorul pas este configurați-vă placa ESP32 cu Arduino IDE . Pentru interfața DS3231, va trebui să instalați biblioteca RTClib . Îl puteți instala utilizând managerul de bibliotecă Arduino IDE.
3. Hardware
Veți avea nevoie de următorul hardware pentru proiectarea ceasului RTC bazat pe DS3231 cu ESP32:
- Placa de dezvoltare ESP32
- Modul RTC DS3231
- baterie CR2032
- Fire jumper
- Breadboard
4. Cod
După instalarea bibliotecii RTC, următoarea parte este să scrieți codul pentru DS3231 și să îl încărcați pe placa ESP32. Mai întâi, trebuie să scrieți codul pentru a vă seta ora curentă. După ce setați ora în DS3231, acesta își va aminti ora și va continua să funcționeze chiar dacă placa ESP32 este oprită.
Acum deschideți Arduino IDE, compilați și scrieți codul pe placa ESP32.
#include#include
RTC_DS3231 rtc ; // Inițializați o instanță a clasei RTC_DS3231
vid înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
Sârmă. ÎNCEPE ( ) ;
dacă ( ! rtc. ÎNCEPE ( ) ) {
Serial. println ( „RTC nu a fost detectat” ) ;
in timp ce ( 1 ) ; // Se suspendă la nesfârșit dacă RTC nu este găsit
}
//Anulați comentariile din rândul de mai jos pentru a seta data și ora inițiale
//rtc.adjust(DateTime(__DATE__, __TIME__));
}
gol buclă ( ) {
// Citiți ora curentă de la senzor (DS3231)
DateTime acum = rtc. acum ( ) ;
// Tipăriți data și ora pe aceeași linie cu două cifre pentru ore, minute și secunde
Serial. imprimare ( 'Data curenta: ' ) ;
Serial. imprimare ( acum. an ( ) , DEC ) ;
Serial. imprimare ( '/' ) ;
printTwoDigits ( acum. lună ( ) ) ;
Serial. imprimare ( '/' ) ;
printTwoDigits ( acum. zi ( ) ) ;
Serial. imprimare ( ' Ora curentă: ' ) ;
printTwoDigits ( acum. ora ( ) ) ;
Serial. imprimare ( ':' ) ;
printTwoDigits ( acum. minut ( ) ) ;
Serial. imprimare ( ':' ) ;
printTwoDigits ( acum. al doilea ( ) ) ;
Serial. println ( ) ;
întârziere ( 1000 ) ; // Actualizați la fiecare 1 secundă
}
gol printTwoDigits ( int număr ) {
dacă ( număr < 10 ) {
Serial. imprimare ( '0' ) ; // Adăugați un zero înainte pentru numerele cu o singură cifră
}
Serial. imprimare ( număr ) ;
}
4.1. Explicația codului
Codul începe prin inițializarea comunicației seriale I2C cu ajutorul unei biblioteci de fire. După aceea, am inclus biblioteca RTC de la Adafruit pentru interfața cu modulul DS3231. Această bibliotecă oferă o funcție pentru a interacționa cu modulul RTC DS3231.
În înființat partea, magistrala I2C este pornită și verificată pentru dispozitivele I2C disponibile. Dacă nu este găsit, programul se blochează pe termen nelimitat. Rata baud este, de asemenea, definită, astfel încât să puteți verifica ieșirea pe monitorul serial Arduino IDE.
Setarea ceasului pentru prima dată
Când programați DS3231, trebuie să faceți acest lucru decomentează această linie . Acest lucru va obține ora sistemului și o va stoca în memoria RTC. Procedând astfel, ceasul modulului RTC se sincronizează cu ceasul sistemului dumneavoastră.
//rtc.adjust(DateTime(__DATE__, __TIME__)); 
După setarea orei, trebuie să reîncărcați codul de mai sus, dar de data aceasta trebuie să faceți acest lucru comentați linia funcției rtc.adjust(). . În caz contrar, aceasta va suprascrie ora setată anterior și când ESP32 este oprit, RTC va porni din nou din momentul în care ați încărcat codul.
Procedând astfel, timpul dumneavoastră va rămâne prezent în fundalul modulului RTC atâta timp cât modulul RTC are putere în celula CR2032.
În buclă parte, data și ora curente sunt citite din modulul DS3231 folosind funcția rtc.now(). Componentele de dată și oră sunt extrase, iar data formatată este tipărită pe monitorul serial Arduino IDE la fiecare secundă.
5. Ieșire
După ce ați încărcat codul pe placa ESP32, veți vedea că ora va începe tipărirea pe monitorul serial Arduino IDE.
6. Cum să afișați ora RTC DS3231 pe ecranul OLED utilizând ESP32
De asemenea, puteți face un pas mai departe și puteți afișa ora pe ecranul OLED după ce ați citit-o de pe DS3231. Pentru aceasta, trebuie să instalați Biblioteca Adafruit GFX SSD1306 în IDE-ul Arduino.
Odată instalat, conectați ESP32 cu modulul OLED și RTC în următoarea configurație.
După conectarea senzorului, veți vedea că circuitul arată ca schema de mai jos.
Acum încărcați următorul cod DS3231 pe placa ESP32.
#include#include
#include
#include „RTClib.h”
RTC_DS3231 rtc ;
char zile [ 7 ] [ 12 ] = { 'Duminică' , 'Luni' , 'Marţi' , 'Miercuri' , 'Joi' , 'Vineri' , 'Sâmbătă' } ;
Afișaj Adafruit_SSD1306 = Adafruit_SSD1306 ( 128 , 64 , & Sârmă , - 1 ) ;
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
afişa. ÎNCEPE ( SSD1306_SWITCHCAPVCC , 0x3C ) ;
dacă ( ! rtc. ÎNCEPE ( ) ) {
Serial. println ( 'Nu s-a putut găsi RTC! Verificați circuitul.' ) ;
in timp ce ( 1 ) ;
}
//decomentați linia de mai jos în timp ce setați ora pentru prima dată
//rtc.adjust(DateTime(__DATE__, __TIME__));
afişa. clearDisplay ( ) ;
afişa. setTextColor ( ALB ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 0 , douăzeci ) ;
afişa. imprimare ( „CEAS RTC” ) ;
afişa. afişa ( ) ;
întârziere ( 5000 ) ;
}
gol buclă ( ) {
DateTime acum = rtc. acum ( ) ;
afişa. clearDisplay ( ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 75 , 0 ) ;
afişa. println ( acum. al doilea ( ) , DEC ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 25 , 0 ) ;
afişa. println ( ':' ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 65 , 0 ) ;
afişa. println ( ':' ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 40 , 0 ) ;
afişa. println ( acum. minut ( ) , DEC ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 0 , 0 ) ;
afişa. println ( acum. ora ( ) , DEC ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 0 , 25 ) ;
afişa. println ( acum. zi ( ) , DEC ) ;
afişa. imprimare ( zile [ acum. zi a săptămânii ( ) ] ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( douăzeci , 25 ) ;
afişa. println ( '-' ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 35 , 25 ) ;
afişa. println ( acum. lună ( ) , DEC ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 60 , 25 ) ;
afişa. println ( '-' ) ;
afişa. setTextSize ( 2 ) ;
afişa. setCursor ( 75 , 25 ) ;
afişa. println ( acum. an ( ) , DEC ) ;
afişa. afişa ( ) ;
}
Explicația codului
Codul a început cu câteva biblioteci importante care sunt necesare pentru ecranele RTC și OLED. Ecranul OLED este configurat folosind biblioteca Adafruit SSD1306.
În partea buclă, data și ora curente sunt obținute folosind rtc.now(). După aceea, ecranul OLED este șters și componentele de timp sunt afișate într-un format de ceas digital. De asemenea, puteți modifica codul pentru a ajusta formatul de dată și oră.
Odată ce codul este încărcat pe placa dvs., veți primi ora curentă pe ecranul OLED.
Notă: Codul de mai sus folosește 0x3C Adresă I2C pentru OLED. Aceasta este cea mai comună adresă I2C disponibilă pe ecranele OLED SSD1306. Dacă doriți să găsiți adresa I2C pentru ecranul dvs. OLED, puteți rula Cod scaner I2C .
Concluzie
DS3231 este un senzor RTC care poate fi folosit pentru cronometrarea. Are o baterie de rezervă care poate păstra timpul exact chiar dacă placa de microcontroler este oprită. Pentru a interfața ESP2 cu DS3231, trebuie să instalați biblioteca RTClib în IDE-ul dvs. Arduino. După aceea, trebuie să conectați modulul RTC prin protocolul I2C folosind pinul digital al ESP32. Odată conectat, pur și simplu încărcați codul și reglați ora. Acum, senzorul RTC va păstra timpul și îl puteți citi pe monitorul serial pentru proiecte bazate pe timp de proiectare.