ESP32 DS3231 / AT24C32 Real-Time Clock (RTC)
Overview
The DS3231 is a highly accurate I²C real-time clock with an integrated temperature-compensated crystal oscillator, providing precise timekeeping and calendar functions, along with programmable alarms and square-wave output, suitable for applications requiring reliable timekeeping.
About DS3231 / AT24C32 Real-Time Clock (RTC)
The DS3231 is an ultra-accurate I²C real-time clock (RTC) with a built-in temperature-compensated crystal oscillator (TCXO), ensuring stable timekeeping even under temperature fluctuations. It provides leap-year compensation up to 2100 and supports battery backup for uninterrupted operation.
⚡ Key Features
- High-Precision RTC – More accurate than the DS1307.
- Built-in Temperature Compensation – Ensures consistent timekeeping across temperature changes.
- Battery Backup Support – Keeps time even during power loss.
- I²C Communication – Simple integration with ESP32, Arduino, and other microcontrollers.
With its precision and reliability, the DS3231 is perfect for data logging, alarms, scheduling, and real-time event tracking. 🚀
Where to Buy
Starting from
3.50$ per unit
Prices are subject to change. We earn from qualifying purchases as an Amazon Associate.
Technical Specifications
Pinout Configuration
The VCC pin is used to supply power to the sensor, and it typically requires 3.3V or 5V (refer to the datasheet for specific voltage requirements). The GND pin is the ground connection and must be connected to the ground of your ESP32.
The DS3231 pinout is as follows:
- 32kHz: 32.768 kHz output (optional).
- VBAT: Backup battery input.
- INT/SQW: Interrupt or square-wave output.
- SCL: Serial Clock Line for I²C communication.
- GND: Ground connection.
- SDA: Serial Data Line for I²C communication.
- RST: Reset input/output.
- VCC: Power supply input (2.3V to 5.5V).
Wiring with ESP32
VCC to a 3.3V or 5V power supply, GND to ground, SDA to the microcontroller's I²C data pin, and SCL to the I²C clock pin. The VBAT pin can be connected to a backup battery to maintain timekeeping during power loss. The INT/SQW pin can be connected to a digital input on the microcontroller if interrupt or square-wave output functionality is required. The RST pin can be used for manual reset control if needed.Troubleshooting Guide
Common Issues
⏰ RTC Not Advancing Time Correctly
Issue: The DS3231 RTC module displays a constant time or advances time incorrectly.
Possible causes include insufficient power supply, incorrect wiring, or a defective module.
Solution: Ensure that the module is connected to a stable power source, with VCC connected to 5V and GND to ground. Verify that the SDA and SCL pins are correctly connected to the appropriate digital pins on the microcontroller. If the problem persists, consider replacing the DS3231 module, as some units, especially from unreliable sources, may be faulty.
📅 Incorrect or Corrupted Date and Time Display
Issue: The DS3231 module displays incorrect or corrupted date and time information.
Possible causes include improper initialization, incorrect data retrieval methods, or communication errors.
Solution: Ensure that the RTC is properly initialized in your code, disabling write protection and setting the clock to run mode. Use reliable libraries and functions to set and retrieve time data. Verify that the communication between the microcontroller and the RTC is functioning correctly, and consider implementing error-checking mechanisms to detect and handle communication issues.
🌡️ RTC Module Overheating
Issue: The DS3231 module becomes excessively hot during operation.
Possible causes include incorrect power connections, short circuits, or defective components.
Solution: Double-check all power connections to ensure they are correct, with VCC connected to the appropriate voltage and GND to ground. Inspect the module and wiring for any signs of short circuits or solder bridges. If the module continues to overheat, it may be defective and should be replaced.
🕐 Time Resets After Power Loss
Issue: The DS3231 RTC loses track of time after a power cycle.
Possible causes include a missing or depleted backup battery, or incorrect wiring of the backup power supply.
Solution: Install a backup battery (e.g., a CR2032 coin cell) to the VBAT pin to maintain timekeeping during power loss. Ensure that the battery is fresh and properly connected. Verify that the VCC pin is connected to the main power supply, and that the module is configured to switch to the backup battery when the main power is unavailable.
Debugging Tips
🔍 Serial Monitor
Use the Serial Monitor to check for error messages and verify the sensor's output. Add debug prints in your code to track the sensor's state.
⚡ Voltage Checks
Use a multimeter to verify voltage levels and check for continuity in your connections. Ensure the power supply is stable and within the sensor's requirements.
Additional Resources
Code Examples
Arduino Example
#include <Wire.h>
#include <RTClib.h>
RTC_DS3231 rtc;
void setup() {
Serial.begin(9600);
Wire.begin();
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
if (rtc.lostPower()) {
rtc.adjust(DateTime(2023, 12, 4, 14, 30, 0)); // Set initial date/time
}
}
void loop() {
DateTime now = rtc.now();
Serial.print("Time: ");
Serial.print(now.hour());
Serial.print(":");
Serial.print(now.minute());
Serial.print(":");
Serial.println(now.second());
Serial.print("Date: ");
Serial.print(now.year());
Serial.print("/");
Serial.print(now.month());
Serial.print("/");
Serial.println(now.day());
delay(1000);
}RTClib library. In the setup() function, the RTC is initialized, and if it has lost power, the date and time are set. The loop() function retrieves the current time and date from the RTC and prints them to the Serial Monitor every second.ESP-IDF Example
#include <stdio.h>
#include "driver/i2c.h"
#include "ds3231.h"
#define I2C_MASTER_SCL_IO 22
#define I2C_MASTER_SDA_IO 21
void app_main(void) {
i2c_config_t i2c_config = {
.mode = I2C_MODE_MASTER,
.sda_io_num = I2C_MASTER_SDA_IO,
.scl_io_num = I2C_MASTER_SCL_IO,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
.master.clk_speed = 100000
};
i2c_param_config(I2C_NUM_0, &i2c_config);
i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0);
ds3231_init(I2C_NUM_0);
ds3231_set_datetime(2023, 12, 4, 14, 30, 0);
while (1) {
ds3231_datetime_t now;
ds3231_get_datetime(&now);
printf("Time: %02d:%02d:%02d\n", now.hour, now.minute, now.second);
printf("Date: %04d/%02d/%02d\n", now.year, now.month, now.day);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}ds3231_set_datetime(). The current time and date are retrieved with ds3231_get_datetime() and displayed on the console every second.ESPHome Example
i2c:
sda: GPIO21
scl: GPIO22
time:
- platform: ds3231
id: ds3231_time
update_interval: 1s
sensor:
- platform: custom
lambda: |-
auto my_sensor = new DS3231Sensor(id(ds3231_time));
return {my_sensor};
sensors:
- name: "DS3231 Date and Time"time platform fetches the date and time at 1-second intervals. A custom sensor processes and displays the time and date in a human-readable format.PlatformIO Example
platformio.ini
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200PlatformIO Example Code
#include <Wire.h>
#include <RTClib.h>
RTC_DS3231 rtc;
void setup() {
Serial.begin(115200);
Wire.begin(21, 22); // SDA: GPIO21, SCL: GPIO22
if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}
if (rtc.lostPower()) {
rtc.adjust(DateTime(2023, 12, 4, 14, 30, 0)); // Set initial date/time
}
}
void loop() {
DateTime now = rtc.now();
Serial.print("Time: ");
Serial.print(now.hour());
Serial.print(":");
Serial.print(now.minute());
Serial.print(":");
Serial.println(now.second());
Serial.print("Date: ");
Serial.print(now.year());
Serial.print("/");
Serial.print(now.month());
Serial.print("/");
Serial.println(now.day());
delay(1000);
}loop() retrieves the current time and date and prints them every second.MicroPython Example
from machine import I2C, Pin
import time
# DS3231 I2C address
DS3231_ADDRESS = 0x68
def bcd_to_decimal(bcd):
return (bcd >> 4) * 10 + (bcd & 0x0F)
def decimal_to_bcd(decimal):
return ((decimal // 10) << 4) | (decimal % 10)
def set_time(i2c, year, month, day, hour, minute, second):
data = [decimal_to_bcd(second), decimal_to_bcd(minute), decimal_to_bcd(hour),
decimal_to_bcd(day), 0, decimal_to_bcd(month), decimal_to_bcd(year - 2000)]
i2c.writeto_mem(DS3231_ADDRESS, 0x00, bytes(data))
def get_time(i2c):
data = i2c.readfrom_mem(DS3231_ADDRESS, 0x00, 7)
second = bcd_to_decimal(data[0])
minute = bcd_to_decimal(data[1])
hour = bcd_to_decimal(data[2])
day = bcd_to_decimal(data[4])
month = bcd_to_decimal(data[5] & 0x1F)
year = bcd_to_decimal(data[6]) + 2000
return year, month, day, hour, minute, second
# Initialize I2C
i2c = I2C(0, scl=Pin(22), sda=Pin(21))
# Set initial time
set_time(i2c, 2023, 12, 4, 14, 30, 0)
# Loop to read time
while True:
year, month, day, hour, minute, second = get_time(i2c)
print(f"Time: {hour:02}:{minute:02}:{second:02}, Date: {year:04}/{month:02}/{day:02}")
time.sleep(1)set_time() function sets the date and time on the DS3231 by writing BCD-encoded values to its memory. The get_time() function reads the current date and time from the DS3231, decodes the BCD values into integers, and returns them in a human-readable format. The main loop continuously fetches the current time and date from the DS3231 and prints them every second.Conclusion
The ESP32 DS3231 / AT24C32 Real-Time Clock (RTC) is a powerful RTC sensor that offers excellent performance and reliability. With support for multiple development platforms including Arduino, ESP-IDF, ESPHome, PlatformIO, and MicroPython, it's a versatile choice for your IoT projects.
For optimal performance, ensure proper wiring and follow the recommended configuration for your chosen development platform.
Always verify power supply requirements and pin connections before powering up your project to avoid potential damage.
