2021-02-03 14:20:31 +00:00
|
|
|
|
/******************************************************************************
|
|
|
|
|
rv3028.cpp
|
|
|
|
|
Based on RV-3028-C7 Arduino Library by Constantin Koch, July 25, 2019
|
|
|
|
|
https://github.com/constiko/RV-3028_C7-Arduino_Library
|
|
|
|
|
|
|
|
|
|
This code is released under the [MIT License](http://opensource.org/licenses/MIT).
|
|
|
|
|
Please review the LICENSE file included with this example.
|
|
|
|
|
Distributed as-is; no warranty is given.
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
#include "rv3028.hpp"
|
|
|
|
|
|
|
|
|
|
//****************************************************************************//
|
|
|
|
|
//
|
|
|
|
|
// Settings and configuration
|
|
|
|
|
//
|
|
|
|
|
//****************************************************************************//
|
|
|
|
|
|
|
|
|
|
// Parse the __DATE__ predefined macro to generate date defaults:
|
|
|
|
|
// __Date__ Format: MMM DD YYYY (First D may be a space if <10)
|
|
|
|
|
// <MONTH>
|
|
|
|
|
#define BUILD_MONTH_JAN ((__DATE__[0] == 'J') && (__DATE__[1] == 'a')) ? 1 : 0
|
|
|
|
|
#define BUILD_MONTH_FEB (__DATE__[0] == 'F') ? 2 : 0
|
|
|
|
|
#define BUILD_MONTH_MAR ((__DATE__[0] == 'M') && (__DATE__[1] == 'a') && (__DATE__[2] == 'r')) ? 3 : 0
|
|
|
|
|
#define BUILD_MONTH_APR ((__DATE__[0] == 'A') && (__DATE__[1] == 'p')) ? 4 : 0
|
|
|
|
|
#define BUILD_MONTH_MAY ((__DATE__[0] == 'M') && (__DATE__[1] == 'a') && (__DATE__[2] == 'y')) ? 5 : 0
|
|
|
|
|
#define BUILD_MONTH_JUN ((__DATE__[0] == 'J') && (__DATE__[1] == 'u') && (__DATE__[2] == 'n')) ? 6 : 0
|
|
|
|
|
#define BUILD_MONTH_JUL ((__DATE__[0] == 'J') && (__DATE__[1] == 'u') && (__DATE__[2] == 'l')) ? 7 : 0
|
|
|
|
|
#define BUILD_MONTH_AUG ((__DATE__[0] == 'A') && (__DATE__[1] == 'u')) ? 8 : 0
|
|
|
|
|
#define BUILD_MONTH_SEP (__DATE__[0] == 'S') ? 9 : 0
|
|
|
|
|
#define BUILD_MONTH_OCT (__DATE__[0] == 'O') ? 10 : 0
|
|
|
|
|
#define BUILD_MONTH_NOV (__DATE__[0] == 'N') ? 11 : 0
|
|
|
|
|
#define BUILD_MONTH_DEC (__DATE__[0] == 'D') ? 12 : 0
|
|
|
|
|
#define BUILD_MONTH BUILD_MONTH_JAN | BUILD_MONTH_FEB | BUILD_MONTH_MAR | \
|
|
|
|
|
BUILD_MONTH_APR | BUILD_MONTH_MAY | BUILD_MONTH_JUN | \
|
|
|
|
|
BUILD_MONTH_JUL | BUILD_MONTH_AUG | BUILD_MONTH_SEP | \
|
|
|
|
|
BUILD_MONTH_OCT | BUILD_MONTH_NOV | BUILD_MONTH_DEC
|
|
|
|
|
// <DATE>
|
|
|
|
|
#define BUILD_DATE_0 ((__DATE__[4] == ' ') ? 0 : (__DATE__[4] - 0x30))
|
|
|
|
|
#define BUILD_DATE_1 (__DATE__[5] - 0x30)
|
|
|
|
|
#define BUILD_DATE ((BUILD_DATE_0 * 10) + BUILD_DATE_1)
|
|
|
|
|
// <YEAR>
|
|
|
|
|
#define BUILD_YEAR (((__DATE__[7] - 0x30) * 1000) + ((__DATE__[8] - 0x30) * 100) + \
|
|
|
|
|
((__DATE__[9] - 0x30) * 10) + ((__DATE__[10] - 0x30) * 1))
|
|
|
|
|
|
|
|
|
|
// Parse the __TIME__ predefined macro to generate time defaults:
|
|
|
|
|
// __TIME__ Format: HH:MM:SS (First number of each is padded by 0 if <10)
|
|
|
|
|
// <HOUR>
|
|
|
|
|
#define BUILD_HOUR_0 ((__TIME__[0] == ' ') ? 0 : (__TIME__[0] - 0x30))
|
|
|
|
|
#define BUILD_HOUR_1 (__TIME__[1] - 0x30)
|
|
|
|
|
#define BUILD_HOUR ((BUILD_HOUR_0 * 10) + BUILD_HOUR_1)
|
|
|
|
|
// <MINUTE>
|
|
|
|
|
#define BUILD_MINUTE_0 ((__TIME__[3] == ' ') ? 0 : (__TIME__[3] - 0x30))
|
|
|
|
|
#define BUILD_MINUTE_1 (__TIME__[4] - 0x30)
|
|
|
|
|
#define BUILD_MINUTE ((BUILD_MINUTE_0 * 10) + BUILD_MINUTE_1)
|
|
|
|
|
// <SECOND>
|
|
|
|
|
#define BUILD_SECOND_0 ((__TIME__[6] == ' ') ? 0 : (__TIME__[6] - 0x30))
|
|
|
|
|
#define BUILD_SECOND_1 (__TIME__[7] - 0x30)
|
|
|
|
|
#define BUILD_SECOND ((BUILD_SECOND_0 * 10) + BUILD_SECOND_1)
|
|
|
|
|
|
|
|
|
|
namespace pimoroni {
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::init() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
i2c_init(i2c, 400000);
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
gpio_set_function(sda, GPIO_FUNC_I2C);
|
|
|
|
|
gpio_pull_up(sda);
|
|
|
|
|
gpio_set_function(scl, GPIO_FUNC_I2C);
|
|
|
|
|
gpio_pull_up(scl);
|
|
|
|
|
|
|
|
|
|
if(interrupt != PIN_UNUSED) {
|
|
|
|
|
gpio_set_function(interrupt, GPIO_FUNC_SIO);
|
|
|
|
|
gpio_set_dir(interrupt, GPIO_IN);
|
|
|
|
|
gpio_pull_up(interrupt);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 15:24:35 +01:00
|
|
|
|
uint8_t chip_id = 0;
|
|
|
|
|
read_bytes(RV3028_ID, &chip_id, 1);
|
|
|
|
|
if(chip_id != (RV3028_CHIP_ID | RV3028_VERSION)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return true;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 09:38:51 +01:00
|
|
|
|
void RV3028::reset() {
|
|
|
|
|
set_bit(RV3028_CTRL2, CTRL2_RESET);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i2c_inst_t* RV3028::get_i2c() const {
|
|
|
|
|
return i2c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int RV3028::get_sda() const {
|
|
|
|
|
return sda;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int RV3028::get_scl() const {
|
|
|
|
|
return scl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int RV3028::get_int() const {
|
|
|
|
|
return interrupt;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::setup(bool set_24Hour, bool disable_TrickleCharge, bool set_LevelSwitchingMode) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
sleep_ms(1000);
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(set_24Hour) {
|
|
|
|
|
set_24_hour();
|
|
|
|
|
sleep_ms(1000);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(disable_TrickleCharge) {
|
|
|
|
|
disable_trickle_charge();
|
|
|
|
|
sleep_ms(1000);
|
|
|
|
|
}
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return ((set_LevelSwitchingMode ? set_backup_switchover_mode(3) : true) && write_register(RV3028_STATUS, 0x00));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_time(uint8_t sec, uint8_t min, uint8_t hour, uint8_t weekday, uint8_t date, uint8_t month, uint16_t year) {
|
|
|
|
|
times[TIME_SECONDS] = dec_to_bcd(sec);
|
|
|
|
|
times[TIME_MINUTES] = dec_to_bcd(min);
|
|
|
|
|
times[TIME_HOURS] = dec_to_bcd(hour);
|
|
|
|
|
times[TIME_WEEKDAY] = dec_to_bcd(weekday);
|
|
|
|
|
times[TIME_DATE] = dec_to_bcd(date);
|
|
|
|
|
times[TIME_MONTH] = dec_to_bcd(month);
|
|
|
|
|
times[TIME_YEAR] = dec_to_bcd(year - 2000);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
bool status = false;
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour()) {
|
|
|
|
|
set_24_hour();
|
|
|
|
|
status = set_time(times, TIME_ARRAY_LENGTH);
|
|
|
|
|
set_12_hour();
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
status = set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
return status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// setTime -- Set time and date/day registers of RV3028 (using data array)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_time(uint8_t * time, uint8_t len) {
|
|
|
|
|
if(len != TIME_ARRAY_LENGTH)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return write_multiple_registers(RV3028_SECONDS, time, len);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_seconds(uint8_t value) {
|
|
|
|
|
times[TIME_SECONDS] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_minutes(uint8_t value) {
|
|
|
|
|
times[TIME_MINUTES] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_hours(uint8_t value) {
|
|
|
|
|
times[TIME_HOURS] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_weekday(uint8_t value) {
|
|
|
|
|
times[TIME_WEEKDAY] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_date(uint8_t value) {
|
|
|
|
|
times[TIME_DATE] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_month(uint8_t value) {
|
|
|
|
|
times[TIME_MONTH] = dec_to_bcd(value);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_year(uint16_t value) {
|
|
|
|
|
times[TIME_YEAR] = dec_to_bcd(value - 2000);
|
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Takes the time from the last build and uses it as the current time
|
|
|
|
|
//Works very well as an arduino sketch
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_to_compiler_time() {
|
|
|
|
|
times[TIME_SECONDS] = dec_to_bcd(BUILD_SECOND);
|
|
|
|
|
times[TIME_MINUTES] = dec_to_bcd(BUILD_MINUTE);
|
|
|
|
|
times[TIME_HOURS] = dec_to_bcd(BUILD_HOUR);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Build_Hour is 0-23, convert to 1-12 if needed
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour()) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t hour = BUILD_HOUR;
|
|
|
|
|
|
|
|
|
|
bool pm = false;
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(hour == 0)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
hour += 12;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
else if(hour == 12)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
pm = true;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
else if(hour > 12) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
hour -= 12;
|
|
|
|
|
pm = true;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
times[TIME_HOURS] = dec_to_bcd(hour); //Load the modified hours
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(pm == true)
|
|
|
|
|
times[TIME_HOURS] |= (1 << HOURS_AM_PM); //Set AM/PM bit if needed
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Calculate weekday (from here: http://stackoverflow.com/a/21235587)
|
|
|
|
|
// 0 = Sunday, 6 = Saturday
|
|
|
|
|
uint16_t d = BUILD_DATE;
|
|
|
|
|
uint16_t m = BUILD_MONTH;
|
|
|
|
|
uint16_t y = BUILD_YEAR;
|
|
|
|
|
uint16_t weekday = (d += m < 3 ? y-- : y - 2, 23 * m / 9 + d + 4 + y / 4 - y / 100 + y / 400) % 7 + 1;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
times[TIME_WEEKDAY] = dec_to_bcd(weekday);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
times[TIME_DATE] = dec_to_bcd(BUILD_DATE);
|
|
|
|
|
times[TIME_MONTH] = dec_to_bcd(BUILD_MONTH);
|
|
|
|
|
times[TIME_YEAR] = dec_to_bcd(BUILD_YEAR - 2000); //! Not Y2K (or Y2.1K)-proof :(
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return set_time(times, TIME_ARRAY_LENGTH);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Move the hours, mins, sec, etc registers from RV-3028-C7 into the _time array
|
|
|
|
|
//Needs to be called before printing time or date
|
|
|
|
|
//We do not protect the GPx registers. They will be overwritten. The user has plenty of RAM if they need it.
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::update_time() {
|
|
|
|
|
if(read_multiple_registers(RV3028_SECONDS, times, TIME_ARRAY_LENGTH) == false)
|
|
|
|
|
return false; //Something went wrong
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour())
|
|
|
|
|
times[TIME_HOURS] &= ~(1 << HOURS_AM_PM); //Remove this bit from value
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns a pointer to array of chars that are the date in mm/dd/yyyy format because they're weird
|
2021-05-10 06:23:34 +01:00
|
|
|
|
char* RV3028::string_date_usa() {
|
2021-05-10 09:38:51 +01:00
|
|
|
|
static char date[11 + 3]; //Max of mm/dd/yyyy with \0 terminator (plus extra for worst case conversion)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
sprintf(date, "%02hhu/%02hhu/20%02hhu", bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_YEAR]));
|
|
|
|
|
return date;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns a pointer to array of chars that are the date in dd/mm/yyyy format
|
2021-05-10 06:23:34 +01:00
|
|
|
|
char* RV3028::string_date() {
|
2021-05-10 09:38:51 +01:00
|
|
|
|
static char date[11 + 3]; //Max of dd/mm/yyyy with \0 terminator (plus extra for worst case conversion)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
sprintf(date, "%02hhu/%02hhu/20%02hhu", bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_YEAR]));
|
|
|
|
|
return date;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns a pointer to array of chars that represents the time in hh:mm:ss format
|
|
|
|
|
//Adds AM/PM if in 12 hour mode
|
2021-05-10 06:23:34 +01:00
|
|
|
|
char* RV3028::string_time() {
|
2021-05-10 09:38:51 +01:00
|
|
|
|
static char time[11 + 3]; //Max of hh:mm:ssXM with \0 terminator (plus extra for worst case conversion)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour() == true) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
char half = 'A';
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_pm()) half = 'P';
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
sprintf(time, "%02hhu:%02hhu:%02hhu%cM", bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]), half);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2021-05-10 06:23:34 +01:00
|
|
|
|
sprintf(time, "%02hhu:%02hhu:%02hhu", bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return time;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
char* RV3028::string_time_stamp() {
|
2021-05-10 09:38:51 +01:00
|
|
|
|
static char time_stamp[25 + 4]; //Max of yyyy-mm-ddThh:mm:ss.ss with \0 terminator (plus extra for worst case conversion)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour() == true) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
char half = 'A';
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_pm()) half = 'P';
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 09:38:51 +01:00
|
|
|
|
sprintf(time_stamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu%cM", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]), half);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2021-05-10 09:38:51 +01:00
|
|
|
|
sprintf(time_stamp, "20%02hhu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu", bcd_to_dec(times[TIME_YEAR]), bcd_to_dec(times[TIME_MONTH]), bcd_to_dec(times[TIME_DATE]), bcd_to_dec(times[TIME_HOURS]), bcd_to_dec(times[TIME_MINUTES]), bcd_to_dec(times[TIME_SECONDS]));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 09:38:51 +01:00
|
|
|
|
return time_stamp;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_seconds() {
|
|
|
|
|
return bcd_to_dec(times[TIME_SECONDS]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_minutes() {
|
|
|
|
|
return bcd_to_dec(times[TIME_MINUTES]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_hours() {
|
|
|
|
|
return bcd_to_dec(times[TIME_HOURS]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_weekday() {
|
|
|
|
|
return bcd_to_dec(times[TIME_WEEKDAY]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_date() {
|
|
|
|
|
return bcd_to_dec(times[TIME_DATE]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::get_month() {
|
|
|
|
|
return bcd_to_dec(times[TIME_MONTH]);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint16_t RV3028::get_year() {
|
|
|
|
|
return bcd_to_dec(times[TIME_YEAR]) + 2000;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns true if RTC has been configured for 12 hour mode
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::is_12_hour() {
|
|
|
|
|
uint8_t controlRegister2 = read_register(RV3028_CTRL2);
|
|
|
|
|
return (controlRegister2 & (1 << CTRL2_12_24));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns true if RTC has PM bit set and 12Hour bit set
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::is_pm() {
|
|
|
|
|
uint8_t hourRegister = read_register(RV3028_HOURS);
|
|
|
|
|
if(is_12_hour() && (hourRegister & (1 << HOURS_AM_PM)))
|
|
|
|
|
return true;
|
|
|
|
|
return false;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Configure RTC to output 1-12 hours
|
|
|
|
|
//Converts any current hour setting to 12 hour
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::set_12_hour() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Do we need to change anything?
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour() == false) {
|
|
|
|
|
uint8_t hour = bcd_to_dec(read_register(RV3028_HOURS)); //Get the current hour in the RTC
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
//Set the 12/24 hour bit
|
|
|
|
|
uint8_t setting = read_register(RV3028_CTRL2);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
setting |= (1 << CTRL2_12_24);
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_CTRL2, setting);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Take the current hours and convert to 12, complete with AM/PM bit
|
|
|
|
|
bool pm = false;
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(hour == 0)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
hour += 12;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
else if(hour == 12)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
pm = true;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
else if(hour > 12) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
hour -= 12;
|
|
|
|
|
pm = true;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
hour = dec_to_bcd(hour); //Convert to BCD
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(pm == true) hour |= (1 << HOURS_AM_PM); //Set AM/PM bit if needed
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_HOURS, hour); //Record this to hours register
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Configure RTC to output 0-23 hours
|
|
|
|
|
//Converts any current hour setting to 24 hour
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::set_24_hour() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Do we need to change anything?
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(is_12_hour() == true) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Not sure what changing the CTRL2 register will do to hour register so let's get a copy
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t hour = read_register(RV3028_HOURS); //Get the current 12 hour formatted time in BCD
|
2021-02-03 14:20:31 +00:00
|
|
|
|
bool pm = false;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(hour & (1 << HOURS_AM_PM)) { //Is the AM/PM bit set?
|
2021-02-03 14:20:31 +00:00
|
|
|
|
pm = true;
|
|
|
|
|
hour &= ~(1 << HOURS_AM_PM); //Clear the bit
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Change to 24 hour mode
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t setting = read_register(RV3028_CTRL2);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
setting &= ~(1 << CTRL2_12_24); //Clear the 12/24 hr bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_CTRL2, setting);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Given a BCD hour in the 1-12 range, make it 24
|
2021-05-10 06:23:34 +01:00
|
|
|
|
hour = bcd_to_dec(hour); //Convert core of register to DEC
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(pm == true) hour += 12; //2PM becomes 14
|
|
|
|
|
if(hour == 12) hour = 0; //12AM stays 12, but should really be 0
|
|
|
|
|
if(hour == 24) hour = 12; //12PM becomes 24, but should really be 12
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
hour = dec_to_bcd(hour); //Convert to BCD
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_HOURS, hour); //Record this to hours register
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//ATTENTION: Real Time and UNIX Time are INDEPENDENT!
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_unix(uint32_t value) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t unix_reg[4];
|
|
|
|
|
unix_reg[0] = value;
|
|
|
|
|
unix_reg[1] = value >> 8;
|
|
|
|
|
unix_reg[2] = value >> 16;
|
|
|
|
|
unix_reg[3] = value >> 24;
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
return write_multiple_registers(RV3028_UNIX_TIME0, unix_reg, 4);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//ATTENTION: Real Time and UNIX Time are INDEPENDENT!
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint32_t RV3028::get_unix() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t unix_reg[4];
|
2021-05-10 06:23:34 +01:00
|
|
|
|
read_multiple_registers(RV3028_UNIX_TIME0, unix_reg, 4);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return ((uint32_t)unix_reg[3] << 24) | ((uint32_t)unix_reg[2] << 16) | ((uint32_t)unix_reg[1] << 8) | unix_reg[0];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
Set the alarm mode in the following way:
|
|
|
|
|
0: When minutes, hours and weekday/date match (once per weekday/date)
|
|
|
|
|
1: When hours and weekday/date match (once per weekday/date)
|
|
|
|
|
2: When minutes and weekday/date match (once per hour per weekday/date)
|
|
|
|
|
3: When weekday/date match (once per weekday/date)
|
|
|
|
|
4: When hours and minutes match (once per day)
|
|
|
|
|
5: When hours match (once per day)
|
|
|
|
|
6: When minutes match (once per hour)
|
|
|
|
|
7: All disabled <EFBFBD> Default value
|
|
|
|
|
If you want to set a weekday alarm (setWeekdayAlarm_not_Date = true), set 'date_or_weekday' from 0 (Sunday) to 6 (Saturday)
|
|
|
|
|
********************************/
|
2021-05-10 09:38:51 +01:00
|
|
|
|
void RV3028::enable_alarm_interrupt(uint8_t min, uint8_t hour, uint8_t date_or_weekday, bool set_weekday_alarm_not_date, uint8_t mode, bool enable_clock_output) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//disable Alarm Interrupt to prevent accidental interrupts during configuration
|
2021-05-10 06:23:34 +01:00
|
|
|
|
disable_alarm_interrupt();
|
|
|
|
|
clear_alarm_interrupt_flag();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//ENHANCEMENT: Add Alarm in 12 hour mode
|
2021-05-10 06:23:34 +01:00
|
|
|
|
set_24_hour();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Set WADA bit (Weekday/Date Alarm)
|
2021-05-10 09:38:51 +01:00
|
|
|
|
if(set_weekday_alarm_not_date)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_CTRL1, CTRL1_WADA);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
else
|
2021-05-10 06:23:34 +01:00
|
|
|
|
set_bit(RV3028_CTRL1, CTRL1_WADA);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Write alarm settings in registers 0x07 to 0x09
|
|
|
|
|
uint8_t alarmTime[3];
|
2021-05-10 06:23:34 +01:00
|
|
|
|
alarmTime[0] = dec_to_bcd(min); //minutes
|
|
|
|
|
alarmTime[1] = dec_to_bcd(hour); //hours
|
|
|
|
|
alarmTime[2] = dec_to_bcd(date_or_weekday); //date or weekday
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//shift alarm enable bits
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(mode > 0b111)
|
|
|
|
|
mode = 0b111; //0 to 7 is valid
|
|
|
|
|
|
|
|
|
|
if(mode & 0b001)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
alarmTime[0] |= 1 << MINUTESALM_AE_M;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(mode & 0b010)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
alarmTime[1] |= 1 << HOURSALM_AE_H;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(mode & 0b100)
|
2021-02-03 14:20:31 +00:00
|
|
|
|
alarmTime[2] |= 1 << DATE_AE_WD;
|
|
|
|
|
//Write registers
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_multiple_registers(RV3028_MINUTES_ALM, alarmTime, 3);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//enable Alarm Interrupt
|
2021-05-10 06:23:34 +01:00
|
|
|
|
enable_alarm_interrupt();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Clock output?
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(enable_clock_output)
|
|
|
|
|
set_bit(RV3028_INT_MASK, IMT_MASK_CAIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
else
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_INT_MASK, IMT_MASK_CAIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_alarm_interrupt() {
|
|
|
|
|
set_bit(RV3028_CTRL2, CTRL2_AIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Only disables the interrupt (not the alarm flag)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_alarm_interrupt() {
|
|
|
|
|
clear_bit(RV3028_CTRL2, CTRL2_AIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_alarm_interrupt_flag() {
|
|
|
|
|
return read_bit(RV3028_STATUS, STATUS_AF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_alarm_interrupt_flag() {
|
|
|
|
|
clear_bit(RV3028_STATUS, STATUS_AF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
Countdown Timer Interrupt
|
|
|
|
|
********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::set_timer(bool timer_repeat, uint16_t timer_frequency, uint16_t timer_value, bool set_interrupt, bool start_timer, bool enable_clock_output) {
|
|
|
|
|
disable_timer();
|
|
|
|
|
disable_timer_interrupt();
|
|
|
|
|
clear_timer_interrupt_flag();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_TIMERVAL_0, timer_value & 0xff);
|
|
|
|
|
write_register(RV3028_TIMERVAL_1, timer_value >> 8);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t ctrl1_val = read_register(RV3028_CTRL1);
|
|
|
|
|
if(timer_repeat) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1_val |= 1 << CTRL1_TRPT;
|
2021-05-10 09:38:51 +01:00
|
|
|
|
}
|
|
|
|
|
else {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1_val &= ~(1 << CTRL1_TRPT);
|
|
|
|
|
}
|
2021-05-10 09:38:51 +01:00
|
|
|
|
|
|
|
|
|
switch(timer_frequency) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
case 4096: // 4096Hz (default) // up to 122us error on first time
|
|
|
|
|
ctrl1_val &= ~3; // Clear both the bits
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 64: // 64Hz // up to 7.813ms error on first time
|
|
|
|
|
ctrl1_val &= ~3; // Clear both the bits
|
|
|
|
|
ctrl1_val |= 1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 1: // 1Hz // up to 7.813ms error on first time
|
|
|
|
|
ctrl1_val &= ~3; // Clear both the bits
|
|
|
|
|
ctrl1_val |= 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 60000: // 1/60Hz // up to 7.813ms error on first time
|
|
|
|
|
ctrl1_val |= 3; // Set both bits
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(set_interrupt) {
|
|
|
|
|
enable_timer_interrupt();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(start_timer) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1_val |= (1 << CTRL1_TE);
|
|
|
|
|
}
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_CTRL1, ctrl1_val);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Clock output?
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(enable_clock_output)
|
|
|
|
|
set_bit(RV3028_INT_MASK, IMT_MASK_CTIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
else
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_INT_MASK, IMT_MASK_CTIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 09:38:51 +01:00
|
|
|
|
uint16_t RV3028::get_timer_count() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
// Reads the number of remaining timer ticks
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t r0 = read_register(RV3028_TIMERSTAT_0);
|
2021-05-10 09:38:51 +01:00
|
|
|
|
return (r0 + (read_register(RV3028_TIMERSTAT_1) << 8));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_timer_interrupt() {
|
|
|
|
|
set_bit(RV3028_CTRL2, CTRL2_TIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_timer_interrupt() {
|
|
|
|
|
clear_bit(RV3028_CTRL2, CTRL2_TIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_timer_interrupt_flag() {
|
|
|
|
|
return read_bit(RV3028_STATUS, STATUS_TF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_timer_interrupt_flag() {
|
|
|
|
|
clear_bit(RV3028_STATUS, STATUS_TF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_timer() {
|
|
|
|
|
set_bit(RV3028_CTRL1, CTRL1_TE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_timer() {
|
|
|
|
|
clear_bit(RV3028_CTRL1, CTRL1_TE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
Periodic Time Update Interrupt
|
|
|
|
|
********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_periodic_update_interrupt(bool every_second, bool enable_clock_output) {
|
|
|
|
|
disable_periodic_update_interrupt();
|
|
|
|
|
clear_periodic_update_interrupt_flag();
|
|
|
|
|
|
2021-05-10 09:38:51 +01:00
|
|
|
|
if(every_second)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_CTRL1, CTRL1_USEL);
|
2021-05-10 09:38:51 +01:00
|
|
|
|
else // every minute
|
2021-05-10 06:23:34 +01:00
|
|
|
|
set_bit(RV3028_CTRL1, CTRL1_USEL);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
set_bit(RV3028_CTRL2, CTRL2_UIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Clock output?
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(enable_clock_output)
|
|
|
|
|
set_bit(RV3028_INT_MASK, IMT_MASK_CUIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
else
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_INT_MASK, IMT_MASK_CUIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_periodic_update_interrupt() {
|
|
|
|
|
clear_bit(RV3028_CTRL2, CTRL2_UIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_periodic_update_interrupt_flag() {
|
|
|
|
|
return read_bit(RV3028_STATUS, STATUS_UF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_periodic_update_interrupt_flag() {
|
|
|
|
|
clear_bit(RV3028_STATUS, STATUS_UF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
Enable the Trickle Charger and set the Trickle Charge series resistor (default is 15k)
|
|
|
|
|
TCR_3K = 3kOhm
|
|
|
|
|
TCR_5K = 5kOhm
|
|
|
|
|
TCR_9K = 9kOhm
|
|
|
|
|
TCR_15K = 15kOhm
|
|
|
|
|
*********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_trickle_charge(uint8_t tcr) {
|
|
|
|
|
if(tcr > 3)
|
|
|
|
|
return;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Read EEPROM Backup Register (0x37)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_backup = read_config_eeprom_ram_mirror(EEPROM_Backup_Register);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Set TCR Bits (Trickle Charge Resistor)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_backup &= EEPROMBackup_TCR_CLEAR; //Clear TCR Bits
|
|
|
|
|
eeprom_backup |= tcr << EEPROMBackup_TCR_SHIFT; //Shift values into EEPROM Backup Register
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write 1 to TCE Bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_backup |= 1 << EEPROMBackup_TCE_BIT;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_config_eeprom_ram_mirror(EEPROM_Backup_Register, eeprom_backup);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_trickle_charge() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Read EEPROM Backup Register (0x37)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_backup = read_config_eeprom_ram_mirror(EEPROM_Backup_Register);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write 0 to TCE Bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_backup &= ~(1 << EEPROMBackup_TCE_BIT);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_config_eeprom_ram_mirror(EEPROM_Backup_Register, eeprom_backup);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
0 = Switchover disabled
|
|
|
|
|
1 = Direct Switching Mode
|
|
|
|
|
2 = Standby Mode
|
|
|
|
|
3 = Level Switching Mode
|
|
|
|
|
*********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::set_backup_switchover_mode(uint8_t val) {
|
|
|
|
|
if(val > 3)
|
|
|
|
|
return false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
|
|
//Read EEPROM Backup Register (0x37)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_backup = read_config_eeprom_ram_mirror(EEPROM_Backup_Register);
|
|
|
|
|
if(eeprom_backup == 0xFF)
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Ensure FEDE Bit is set to 1
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_backup |= 1 << EEPROMBackup_FEDE_BIT;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Set BSM Bits (Backup Switchover Mode)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_backup &= EEPROMBackup_BSM_CLEAR; //Clear BSM Bits of EEPROM Backup Register
|
|
|
|
|
eeprom_backup |= val << EEPROMBackup_BSM_SHIFT; //Shift values into EEPROM Backup Register
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(!write_config_eeprom_ram_mirror(EEPROM_Backup_Register, eeprom_backup))
|
|
|
|
|
success = false;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
return success;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
Clock Out functions
|
|
|
|
|
********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_clock_out(uint8_t freq) {
|
|
|
|
|
if(freq > 7)
|
|
|
|
|
return; // check out of bounds
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Read EEPROM CLKOUT Register (0x35)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_clkout = read_config_eeprom_ram_mirror(EEPROM_Clkout_Register);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Ensure CLKOE Bit is set to 1
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_clkout |= 1 << EEPROMClkout_CLKOE_BIT;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Shift values into EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_clkout |= freq << EEPROMClkout_FREQ_SHIFT;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_config_eeprom_ram_mirror(EEPROM_Clkout_Register, eeprom_clkout);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::enable_interrupt_controlled_clockout(uint8_t freq) {
|
|
|
|
|
if(freq > 7)
|
|
|
|
|
return; // check out of bounds
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Read EEPROM CLKOUT Register (0x35)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_clkout = read_config_eeprom_ram_mirror(EEPROM_Clkout_Register);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Shift values into EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_clkout |= freq << EEPROMClkout_FREQ_SHIFT;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM Backup Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_config_eeprom_ram_mirror(EEPROM_Clkout_Register, eeprom_clkout);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Set CLKIE Bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
set_bit(RV3028_CTRL2, CTRL2_CLKIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::disable_clock_out() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Read EEPROM CLKOUT Register (0x35)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t eeprom_clkout = read_config_eeprom_ram_mirror(EEPROM_Clkout_Register);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Clear CLKOE Bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
eeprom_clkout &= ~(1 << EEPROMClkout_CLKOE_BIT);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write EEPROM CLKOUT Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_config_eeprom_ram_mirror(EEPROM_Clkout_Register, eeprom_clkout);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Clear CLKIE Bit
|
2021-05-10 06:23:34 +01:00
|
|
|
|
clear_bit(RV3028_CTRL2, CTRL2_CLKIE);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_clock_output_interrupt_flag() {
|
|
|
|
|
return read_bit(RV3028_STATUS, STATUS_CLKF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_clock_output_interrupt_flag() {
|
|
|
|
|
clear_bit(RV3028_STATUS, STATUS_CLKF);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Returns the status byte
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::status(void) {
|
|
|
|
|
return(read_register(RV3028_STATUS));
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_interrupts() { //Read the status register to clear the current interrupt flags
|
|
|
|
|
write_register(RV3028_STATUS, 0);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*********************************
|
|
|
|
|
FOR INTERNAL USE
|
|
|
|
|
********************************/
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::bcd_to_dec(uint8_t val) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return ((val / 0x10) * 10) + (val % 0x10);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// BCDtoDEC -- convert decimal to binary-coded decimal (BCD)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::dec_to_bcd(uint8_t val) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return ((val / 10) * 0x10) + (val % 10);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::read_register(uint8_t addr) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t b1[2];
|
2021-05-10 09:38:51 +01:00
|
|
|
|
if(1 == RV3028::read_bytes(addr, b1, 1))
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return b1[0];
|
2021-05-10 06:23:34 +01:00
|
|
|
|
else
|
|
|
|
|
return 0xFF; //Error
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::write_register(uint8_t addr, uint8_t val) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t b1[2];
|
|
|
|
|
b1[0] = val;
|
|
|
|
|
b1[1] = 0;
|
|
|
|
|
return(RV3028::write_bytes(addr, b1, 1));
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_multiple_registers(uint8_t addr, uint8_t *dest, uint8_t len) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return(RV3028::read_bytes(addr, dest, len));
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::write_multiple_registers(uint8_t addr, uint8_t *values, uint8_t len) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return(RV3028::write_bytes(addr, values, len));
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::write_config_eeprom_ram_mirror(uint8_t eeprom_addr, uint8_t val) {
|
|
|
|
|
bool success = wait_for_eeprom();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Disable auto refresh by writing 1 to EERD control bit in CTRL1 register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t ctrl1 = read_register(RV3028_CTRL1);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1 |= 1 << CTRL1_EERD;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
|
|
|
|
|
if(!write_register(RV3028_CTRL1, ctrl1))
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Write Configuration RAM Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(eeprom_addr, val);
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Update EEPROM (All Configuration RAM -> EEPROM)
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_EEPROM_CMD, EEPROMCMD_First);
|
|
|
|
|
write_register(RV3028_EEPROM_CMD, EEPROMCMD_Update);
|
|
|
|
|
|
|
|
|
|
if(!wait_for_eeprom())
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Reenable auto refresh by writing 0 to EERD control bit in CTRL1 register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
ctrl1 = read_register(RV3028_CTRL1);
|
|
|
|
|
if(ctrl1 == 0x00)
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1 &= ~(1 << CTRL1_EERD);
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_CTRL1, ctrl1);
|
|
|
|
|
|
|
|
|
|
if(!wait_for_eeprom())
|
|
|
|
|
success = false;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
return success;
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t RV3028::read_config_eeprom_ram_mirror(uint8_t eeprom_addr) {
|
|
|
|
|
bool success = wait_for_eeprom();
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
|
|
|
|
//Disable auto refresh by writing 1 to EERD control bit in CTRL1 register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
uint8_t ctrl1 = read_register(RV3028_CTRL1);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1 |= 1 << CTRL1_EERD;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(!write_register(RV3028_CTRL1, ctrl1))
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Read EEPROM Register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_EEPROM_ADDR, eeprom_addr);
|
|
|
|
|
write_register(RV3028_EEPROM_CMD, EEPROMCMD_First);
|
|
|
|
|
write_register(RV3028_EEPROM_CMD, EEPROMCMD_ReadSingle);
|
|
|
|
|
|
|
|
|
|
if(!wait_for_eeprom())
|
|
|
|
|
success = false;
|
|
|
|
|
|
|
|
|
|
uint8_t eeprom_data = read_register(RV3028_EEPROM_DATA);
|
|
|
|
|
if(!wait_for_eeprom())
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
//Reenable auto refresh by writing 0 to EERD control bit in CTRL1 register
|
2021-05-10 06:23:34 +01:00
|
|
|
|
ctrl1 = read_register(RV3028_CTRL1);
|
|
|
|
|
if(ctrl1 == 0x00)
|
|
|
|
|
success = false;
|
|
|
|
|
|
2021-02-03 14:20:31 +00:00
|
|
|
|
ctrl1 &= ~(1 << CTRL1_EERD);
|
2021-05-10 06:23:34 +01:00
|
|
|
|
write_register(RV3028_CTRL1, ctrl1);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
if(!success)
|
|
|
|
|
return 0xFF;
|
|
|
|
|
|
|
|
|
|
return eeprom_data;
|
2021-02-03 14:20:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//True if success, false if timeout occured
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::wait_for_eeprom() {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
// Timeout is number of loops round while - don't have access to millisecond counter
|
|
|
|
|
unsigned long timeout = 500;
|
2021-05-10 06:23:34 +01:00
|
|
|
|
while ((read_register(RV3028_STATUS) & 1 << STATUS_EEBUSY) && --timeout > 0);
|
2021-02-03 14:20:31 +00:00
|
|
|
|
return timeout > 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::set_bit(uint8_t reg_addr, uint8_t bit_num) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
RV3028::set_bits(reg_addr, bit_num, 0x01);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
void RV3028::clear_bit(uint8_t reg_addr, uint8_t bit_num) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
RV3028::clear_bits(reg_addr, bit_num, 0x01);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
bool RV3028::read_bit(uint8_t reg_addr, uint8_t bit_num) {
|
2021-02-03 14:20:31 +00:00
|
|
|
|
uint8_t value = RV3028::get_bits(reg_addr, bit_num, 0x01);
|
|
|
|
|
return value;
|
|
|
|
|
}
|
2021-05-10 09:38:51 +01:00
|
|
|
|
|
|
|
|
|
// i2c functions
|
|
|
|
|
int RV3028::write_bytes(uint8_t reg, uint8_t *buf, int len) {
|
|
|
|
|
uint8_t buffer[len + 1];
|
|
|
|
|
buffer[0] = reg;
|
|
|
|
|
for(int x = 0; x < len; x++) {
|
|
|
|
|
buffer[x + 1] = buf[x];
|
|
|
|
|
}
|
|
|
|
|
return i2c_write_blocking(i2c, address, buffer, len + 1, false);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int RV3028::read_bytes(uint8_t reg, uint8_t *buf, int len) {
|
|
|
|
|
i2c_write_blocking(i2c, address, ®, 1, true);
|
|
|
|
|
i2c_read_blocking(i2c, address, buf, len, false);
|
|
|
|
|
return len;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
uint8_t RV3028::get_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
|
|
|
|
uint8_t value;
|
|
|
|
|
read_bytes(reg, &value, 1);
|
|
|
|
|
return value & (mask << shift);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RV3028::set_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
|
|
|
|
uint8_t value;
|
|
|
|
|
read_bytes(reg, &value, 1);
|
|
|
|
|
value |= mask << shift;
|
|
|
|
|
write_bytes(reg, &value, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RV3028::clear_bits(uint8_t reg, uint8_t shift, uint8_t mask) {
|
|
|
|
|
uint8_t value;
|
|
|
|
|
read_bytes(reg, &value, 1);
|
|
|
|
|
value &= ~(mask << shift);
|
|
|
|
|
write_bytes(reg, &value, 1);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-10 06:23:34 +01:00
|
|
|
|
}
|