SensorRtcHelper.cpp

Go to the documentation of this file.

 
#include "../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_RTC
 
#include "SensorRtcHelper.hpp"
 
SensorRtcHelper::DriverCreator SensorRtcHelper::driverCreators[SensorRtcHelper::driverCreatorMaxNum] = {
    nullptr,
#if !SENSORLIB_EXCLUDE_PCF85063
    []() -> std::unique_ptr<SensorRTC> { return std::make_unique<SensorPCF85063>(); },
#else
    nullptr,
#endif
#if !SENSORLIB_EXCLUDE_PCF8563
    []() -> std::unique_ptr<SensorRTC> { return std::make_unique<SensorPCF8563>(); },
#else
    nullptr,
#endif
};
 
SensorRtcHelper::SensorRtcHelper() : _drvType(RtcDrv_UNKNOWN), _drv(nullptr)
{
 
}
 
SensorRtcHelper::~SensorRtcHelper()
{
}
 
 
void SensorRtcHelper::setRtcDrvModel(SensorRTCType model)
{
    _drvType = model;
}
 
#if defined(ARDUINO)
bool SensorRtcHelper::begin(TwoWire &wire,  int sda, int scl)
{
    bool success = false;
    for (int i = (_drvType == RtcDrv_UNKNOWN) ? RtcDrv_PCF85063 : _drvType; i < driverCreatorMaxNum; ++i) {
        _drv = createDriver(static_cast<SensorRTCType>(i));
 
        if (_drv && _drv->begin(wire, sda, scl)) {
            _drvType = static_cast<SensorRTCType>(i);
            success = true;
            break;
        }
    }
    if (!success) {
        _drvType = RtcDrv_UNKNOWN;
    }
    return success;
}
 
#elif defined(ESP_PLATFORM)
 
#if defined(SENSORLIB_USE_I2C_LEGACY)
bool SensorRtcHelper::begin(i2c_port_t port_num,  int sda, int scl)
{
    bool success = false;
    for (int i = (_drvType == RtcDrv_UNKNOWN) ? RtcDrv_PCF85063 : _drvType; i < driverCreatorMaxNum; ++i) {
        _drv = createDriver(static_cast<SensorRTCType>(i));
 
        if (_drv && _drv->begin(port_num, sda, scl)) {
            _drvType = static_cast<SensorRTCType>(i);
            success = true;
            break;
        }
    }
    if (!success) {
        _drvType = RtcDrv_UNKNOWN;
    }
    return success;
}
 
#else
 
bool SensorRtcHelper::begin(i2c_master_bus_handle_t handle)
{
    bool success = false;
    for (int i = (_drvType == RtcDrv_UNKNOWN) ? RtcDrv_PCF85063 : _drvType; i < driverCreatorMaxNum; ++i) {
        _drv = createDriver(static_cast<SensorRTCType>(i));
 
        if (_drv && _drv->begin(handle)) {
            _drvType = static_cast<SensorRTCType>(i);
            success = true;
            break;
        }
    }
    if (!success) {
        _drvType = RtcDrv_UNKNOWN;
    }
    return success;
}
 
#endif  // ESP_PLATFORM
#endif  // ARDUINO
 
bool SensorRtcHelper::begin(SensorCommCustom::CustomCallback callback)
{
    bool success = false;
    for (int i = (_drvType == RtcDrv_UNKNOWN) ? RtcDrv_PCF85063 : _drvType; i < driverCreatorMaxNum; ++i) {
        _drv = createDriver(static_cast<SensorRTCType>(i));
        if (_drv && _drv->begin(callback)) {
            _drvType = static_cast<SensorRTCType>(i);
            success = true;
            break;
        }
    }
    if (!success) {
        _drvType = RtcDrv_UNKNOWN;
    }
    return success;
}
 
void SensorRtcHelper::setDateTime(RTC_DateTime datetime)
{
    _drv->setDateTime(datetime);
}
 
RTC_DateTime SensorRtcHelper::getDateTime()
{
    return _drv->getDateTime();
}
 
const char *SensorRtcHelper::getChipName()
{
    return _drv->getChipName();
}
 
std::unique_ptr<SensorRTC> SensorRtcHelper::createDriver(SensorRTCType type)
{
    if (type < sizeof(driverCreators) / sizeof(driverCreators[0])) {
        if (driverCreators[type]) {
            return driverCreators[type]();
        }
    }
    return nullptr;
}
 
#endif