ds3231.c

Go to the documentation of this file.

 
#include "ds3231.h"
 
#include "driver/i2c_master.h"
#include "esp_check.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "i2c_bus.h"
 
static const char *TAG = "ds3231";
 
#define DS3231_I2C_ADDR         0x68
 
/* Регистры времени */
#define DS3231_REG_SECONDS      0x00
#define DS3231_REG_MINUTES      0x01
#define DS3231_REG_HOURS        0x02
#define DS3231_REG_DAY          0x03
#define DS3231_REG_DATE         0x04
#define DS3231_REG_MONTH        0x05
#define DS3231_REG_YEAR         0x06
 
/* Управляющие / служебные */
#define DS3231_REG_CONTROL      0x0E
#define DS3231_REG_STATUS       0x0F
#define DS3231_REG_TEMP_MSB     0x11
#define DS3231_REG_TEMP_LSB     0x12
 
#define DS3231_STATUS_OSF       (1U << 7)
#define DS3231_HOURS_12H        (1U << 6)
 
#define DS3231_YEAR_BASE        2000U
 
static i2c_master_dev_handle_t s_dev;
static bool s_initialized;
 
static uint8_t bcd_to_bin(uint8_t bcd)
{
    return (uint8_t)(((bcd >> 4) * 10U) + (bcd & 0x0FU));
}
 
static uint8_t bin_to_bcd(uint8_t bin)
{
    return (uint8_t)(((bin / 10U) << 4) | (bin % 10U));
}
 
static esp_err_t ds3231_write_regs(uint8_t reg, const uint8_t *data, size_t len)
{
    uint8_t buf[1 + 7];
 
    ESP_RETURN_ON_FALSE(data != NULL && len > 0 && len <= 7, ESP_ERR_INVALID_ARG,
                        TAG, "bad write args");
 
    buf[0] = reg;
    for (size_t i = 0; i < len; i++) {
        buf[1 + i] = data[i];
    }
    return i2c_master_transmit(s_dev, buf, 1 + len, I2C_BUS_TIMEOUT_MS);
}
 
static esp_err_t ds3231_read_regs(uint8_t reg, uint8_t *data, size_t len)
{
    ESP_RETURN_ON_FALSE(data != NULL && len > 0, ESP_ERR_INVALID_ARG, TAG, "bad read args");
    return i2c_master_transmit_receive(s_dev, &reg, 1, data, len, I2C_BUS_TIMEOUT_MS);
}
 
static esp_err_t ds3231_validate_datetime(const ds3231_datetime_t *dt)
{
    ESP_RETURN_ON_FALSE(dt != NULL, ESP_ERR_INVALID_ARG, TAG, "null dt");
    ESP_RETURN_ON_FALSE(dt->year >= DS3231_YEAR_BASE && dt->year <= DS3231_YEAR_BASE + 99U,
                        ESP_ERR_INVALID_ARG, TAG, "year out of range");
    ESP_RETURN_ON_FALSE(dt->month >= 1 && dt->month <= 12, ESP_ERR_INVALID_ARG, TAG, "month");
    ESP_RETURN_ON_FALSE(dt->date >= 1 && dt->date <= 31, ESP_ERR_INVALID_ARG, TAG, "date");
    ESP_RETURN_ON_FALSE(dt->weekday >= 1 && dt->weekday <= 7, ESP_ERR_INVALID_ARG, TAG, "weekday");
    ESP_RETURN_ON_FALSE(dt->hour <= 23, ESP_ERR_INVALID_ARG, TAG, "hour");
    ESP_RETURN_ON_FALSE(dt->minute <= 59, ESP_ERR_INVALID_ARG, TAG, "minute");
    ESP_RETURN_ON_FALSE(dt->second <= 59, ESP_ERR_INVALID_ARG, TAG, "second");
    return ESP_OK;
}
 
esp_err_t ds3231_init(void)
{
    uint8_t status = 0;
    esp_err_t err = ESP_OK;
    int attempt;
 
    if (s_initialized) {
        return ESP_OK;
    }
 
    ESP_RETURN_ON_ERROR(i2c_bus_init(), TAG, "shared bus init failed");
    ESP_RETURN_ON_ERROR(i2c_bus_add_device(DS3231_I2C_ADDR, &s_dev), TAG, "add device failed");
 
    /* Несколько попыток: после включения питания модуль может ответить не с первого раза */
    for (attempt = 1; attempt <= 3; attempt++) {
        err = ds3231_read_regs(DS3231_REG_STATUS, &status, 1);
        if (err == ESP_OK) {
            break;
        }
        ESP_LOGW(TAG, "probe 0x%02X attempt %d/3 failed: %s",
                 DS3231_I2C_ADDR, attempt, esp_err_to_name(err));
        vTaskDelay(pdMS_TO_TICKS(20));
    }
 
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "DS3231 not responding at 0x%02X (%s). Check wiring/power/pull-ups",
                 DS3231_I2C_ADDR, esp_err_to_name(err));
        (void)i2c_master_bus_rm_device(s_dev);
        s_dev = NULL;
        return err;
    }
 
    s_initialized = true;
    ESP_LOGI(TAG, "DS3231 at 0x%02X, status=0x%02X%s",
             DS3231_I2C_ADDR, status,
             (status & DS3231_STATUS_OSF) ? " (OSF: time may be invalid)" : "");
    return ESP_OK;
}
 
esp_err_t ds3231_get_time(ds3231_datetime_t *dt)
{
    uint8_t raw[7];
 
    ESP_RETURN_ON_FALSE(s_initialized, ESP_ERR_INVALID_STATE, TAG, "not initialized");
    ESP_RETURN_ON_FALSE(dt != NULL, ESP_ERR_INVALID_ARG, TAG, "null dt");
 
    ESP_RETURN_ON_ERROR(ds3231_read_regs(DS3231_REG_SECONDS, raw, sizeof(raw)),
                        TAG, "read time failed");
 
    dt->second = bcd_to_bin(raw[0] & 0x7FU);
    dt->minute = bcd_to_bin(raw[1] & 0x7FU);
 
    /* Всегда читаем как 24h; если чип в 12h — конвертируем */
    if (raw[2] & DS3231_HOURS_12H) {
        uint8_t hour12 = bcd_to_bin(raw[2] & 0x1FU);
        bool pm = (raw[2] & (1U << 5)) != 0;
        if (hour12 == 12) {
            dt->hour = pm ? 12 : 0;
        } else {
            dt->hour = (uint8_t)(pm ? hour12 + 12 : hour12);
        }
    } else {
        dt->hour = bcd_to_bin(raw[2] & 0x3FU);
    }
 
    dt->weekday = bcd_to_bin(raw[3] & 0x07U);
    dt->date = bcd_to_bin(raw[4] & 0x3FU);
    dt->month = bcd_to_bin(raw[5] & 0x1FU);
    dt->year = (uint16_t)(DS3231_YEAR_BASE + bcd_to_bin(raw[6]));
 
    return ESP_OK;
}
 
esp_err_t ds3231_set_time(const ds3231_datetime_t *dt)
{
    uint8_t raw[7];
 
    ESP_RETURN_ON_FALSE(s_initialized, ESP_ERR_INVALID_STATE, TAG, "not initialized");
    ESP_RETURN_ON_ERROR(ds3231_validate_datetime(dt), TAG, "invalid datetime");
 
    raw[0] = bin_to_bcd(dt->second);
    raw[1] = bin_to_bcd(dt->minute);
    raw[2] = bin_to_bcd(dt->hour); /* бит 6 = 0 → 24-часовой режим */
    raw[3] = bin_to_bcd(dt->weekday);
    raw[4] = bin_to_bcd(dt->date);
    raw[5] = bin_to_bcd(dt->month);
    raw[6] = bin_to_bcd((uint8_t)(dt->year - DS3231_YEAR_BASE));
 
    ESP_RETURN_ON_ERROR(ds3231_write_regs(DS3231_REG_SECONDS, raw, sizeof(raw)),
                        TAG, "write time failed");
 
    /* После установки времени OSF сбрасываем */
    return ds3231_clear_osf();
}
 
esp_err_t ds3231_get_temperature(float *temp_c)
{
    uint8_t raw[2];
 
    ESP_RETURN_ON_FALSE(s_initialized, ESP_ERR_INVALID_STATE, TAG, "not initialized");
    ESP_RETURN_ON_FALSE(temp_c != NULL, ESP_ERR_INVALID_ARG, TAG, "null temp");
 
    ESP_RETURN_ON_ERROR(ds3231_read_regs(DS3231_REG_TEMP_MSB, raw, sizeof(raw)),
                        TAG, "read temp failed");
 
    /* MSB — целая часть (signed), LSB[7:6] — дробная с шагом 0.25 °C */
    int8_t whole = (int8_t)raw[0];
    float frac = (float)((raw[1] >> 6) & 0x03U) * 0.25f;
    *temp_c = (float)whole + frac;
    return ESP_OK;
}
 
esp_err_t ds3231_is_oscillator_stopped(bool *stopped)
{
    uint8_t status = 0;
 
    ESP_RETURN_ON_FALSE(s_initialized, ESP_ERR_INVALID_STATE, TAG, "not initialized");
    ESP_RETURN_ON_FALSE(stopped != NULL, ESP_ERR_INVALID_ARG, TAG, "null stopped");
 
    ESP_RETURN_ON_ERROR(ds3231_read_regs(DS3231_REG_STATUS, &status, 1),
                        TAG, "read status failed");
    *stopped = (status & DS3231_STATUS_OSF) != 0;
    return ESP_OK;
}
 
esp_err_t ds3231_clear_osf(void)
{
    uint8_t status = 0;
 
    ESP_RETURN_ON_FALSE(s_initialized, ESP_ERR_INVALID_STATE, TAG, "not initialized");
 
    ESP_RETURN_ON_ERROR(ds3231_read_regs(DS3231_REG_STATUS, &status, 1),
                        TAG, "read status failed");
    status &= (uint8_t)~DS3231_STATUS_OSF;
    return ds3231_write_regs(DS3231_REG_STATUS, &status, 1);
}