Merge pull request #98 from fpistm/prediv

harden prediv management and add parameter to set binary mode
stm32duino · Sep 25, 2023 · 5f53d03 · 5f53d03
2 parents a703c0f + 344114d
commit 5f53d03
Show file tree

Hide file tree

Showing 6 changed files with 301 additions and 217 deletions.
diff --git a/README.md b/README.md
@@ -31,11 +31,11 @@ _RTC hours mode (12 or 24)_
 
 _RTC clock source_
 * **`Source_Clock getClockSource(void)`** : get current clock source.
-* **`void setClockSource(Source_Clock source)`** : this function must be called before `begin()`.
+* **`void setClockSource(Source_Clock source, uint32_t predivA, uint32_t predivS)`** : set the clock source (`LSI_CLOCK`, `LSE_CLOCK` or `HSE_CLOCK`) and (a)synchronous prescaler values. This function must be called before `begin()`. Use `(PREDIVA_MAX + 1)` and `(PREDIVS_MAX +1)` to reset value and use computed ones. Those values have to match the following conditions: **_1Hz = RTC CLK source / ((predivA + 1) * (predivS + 1))_**
 
 _RTC Asynchronous and Synchronous prescaler_
-* **`void getPrediv(int8_t *predivA, int16_t *predivS)`** : get (a)synchronous prescaler values if set else computed ones for the current clock source.
-* **`void setPrediv(int8_t predivA, int16_t predivS)`** : set (a)synchronous prescaler values.  This function must be called before `begin()`. Use -1 to reset value and use computed ones. Those values have to match the following conditions: **_1Hz = RTC CLK source / ((predivA + 1) * (predivS + 1))_**
+* **`void getPrediv(uint32_t *predivA, uint32_t *predivS)`** : get (a)synchronous prescaler values if set else computed ones for the current clock source.
+* **`void setPrediv(uint32_t predivA, uint32_t predivS)`** : set (a)synchronous prescaler values.  This function must be called before `begin()`. Use `(PREDIVA_MAX + 1)` and `(PREDIVS_MAX +1)` to reset value and use computed ones. Those values have to match the following conditions: **_1Hz = RTC CLK source / ((predivA + 1) * (predivS + 1))_**
 
 _SubSeconds management_
 * **`uint32_t getSubSeconds(void)`**

diff --git a/examples/RTCReset/RTCReset.ino b/examples/RTCReset/RTCReset.ino
@@ -36,9 +36,9 @@ typedef struct {
   bool alarm_a;
 } cb_data_t;
 
-static cb_data_t atime = { 2222, true};
+static cb_data_t atime = { 2222, true };
 #ifdef RTC_ALARM_B
-static cb_data_t btime = { 3333, false};
+static cb_data_t btime = { 3333, false };
 #endif
 static byte seconds = 0;
 static byte minutes = 0;
@@ -64,7 +64,7 @@ static uint8_t conv2d(const char* p) {
 }
 
 // sample input: date = "Dec 26 2009", time = "12:34:56"
-void initDateTime (void) {
+void initDateTime(void) {
   Serial.printf("Build date & time %s, %s\n", mydate, mytime);
 
   year = conv2d(mydate + 9);
@@ -89,15 +89,15 @@ void initDateTime (void) {
   seconds = conv2d(mytime + 6);
 }
 
-void setup()
-{
+void setup() {
   pinMode(USER_BTN, INPUT_PULLUP);
   int32_t default_state = digitalRead(USER_BTN);
-
-  Serial.begin(9600);
-  while (!Serial);
+  Serial.begin(115200);
+  while (!Serial)
+    ;
   // Wait user input to start
-  while (digitalRead(USER_BTN) == default_state);
+  while (digitalRead(USER_BTN) == default_state)
+    ;
   // Convenient function to init date and time variables
   initDateTime();
 
@@ -110,7 +110,7 @@ void setup()
 #ifdef RTC_ALARM_B
   rtc.attachInterrupt(alarmMatch, &btime, STM32RTC::ALARM_B);
 #endif
-  rtc.begin(); // Initialize RTC 24H format
+  rtc.begin();  // Initialize RTC 24H format
   if (!rtc.isTimeSet()) {
     Serial.printf("RTC time not set\n Set it.\n");
     // Set the time
@@ -129,6 +129,10 @@ void setup()
   } else {
     // RTC already initialized
     time_t epoc, alarm_epoc;
+    rtc.getTime(&hours, &minutes, &seconds, &subSeconds, &period);
+    year = rtc.getYear();
+    month = rtc.getMonth();
+    day = rtc.getDay();
     if (rtc.isAlarmEnabled()) {
       rtc.enableAlarm(rtc.MATCH_DHHMMSS);
       alarm_epoc = rtc.getAlarmEpoch();
@@ -156,16 +160,28 @@ void setup()
 #endif
     Serial.printf("RTC time already set\n");
   }
-  Serial.printf("Alarm A enable status: %s\n", (rtc.isAlarmEnabled(STM32RTC::ALARM_A)) ? "True" : "False");
+  // For STM32F1xx series, alarm is always disabled after a reset.
+  bool alarmA = rtc.isAlarmEnabled(STM32RTC::ALARM_A);
+  Serial.printf("Alarm A enable status: %s\n", (alarmA) ? "True" : "False");
+  if (!alarmA) {
+    rtc.setAlarmDay(day);
+    rtc.setAlarmTime(hours, minutes, seconds + 5, 567);
+    rtc.enableAlarm(rtc.MATCH_DHHMMSS);
+  }
 #ifdef RTC_ALARM_B
-  Serial.printf("Alarm B enable status: %s\n", (rtc.isAlarmEnabled(STM32RTC::ALARM_B)) ? "True" : "False");
+  bool alarmB = rtc.isAlarmEnabled(STM32RTC::ALARM_B);
+  Serial.printf("Alarm B enable status: %s\n", (alarmB) ? "True" : "False");
+  if (!alarmB) {
+    rtc.setAlarmDay(day, STM32RTC::ALARM_B);
+    rtc.setAlarmTime(hours, minutes, seconds + 5, 567, STM32RTC::ALARM_B);
+    rtc.enableAlarm(rtc.MATCH_DHHMMSS, STM32RTC::ALARM_B);
+  }
 #else
   Serial.println("Alarm B not available.");
 #endif
 }
 
-void loop()
-{
+void loop() {
   rtc.getTime(&hours, &minutes, &seconds, &subSeconds, &period);
   // Print current date & time
   Serial.printf("\n%02d/%02d/%02d %02d:%02d:%02d.%03d\n", rtc.getDay(), rtc.getMonth(), rtc.getYear(), hours, minutes, seconds, subSeconds);
@@ -177,13 +193,12 @@ void loop()
   delay(1000);
 }
 
-void alarmMatch(void *data)
-{
+void alarmMatch(void* data) {
   time_t epoc;
   uint32_t epoc_ms;
   uint32_t sec = 0;
   uint32_t _millis = 1000;
-  cb_data_t cbdata = {.next = 1000, .alarm_a = true};
+  cb_data_t cbdata = { .next = 1000, .alarm_a = true };
   if (data != NULL) {
     cbdata.next = ((cb_data_t*)data)->next;
     cbdata.alarm_a = ((cb_data_t*)data)->alarm_a;
@@ -204,7 +219,7 @@ void alarmMatch(void *data)
   // Update epoch_ms - might need to add a second to epoch
   epoc_ms += _millis;
   if (epoc_ms >= 1000) {
-    sec ++;
+    sec++;
     epoc_ms -= 1000;
   }
 #endif

diff --git a/src/STM32RTC.cpp b/src/STM32RTC.cpp
@@ -63,6 +63,7 @@ void STM32RTC::begin(bool resetTime, Hour_Format format)
 
   _format = format;
   reinit = RTC_init((format == HOUR_12) ? HOUR_FORMAT_12 : HOUR_FORMAT_24,
+                    (_mode == MODE_MIX) ? ::MODE_BINARY_MIX : ((_mode == MODE_BIN) ? ::MODE_BINARY_ONLY : ::MODE_BINARY_NONE),
                     (_clockSource == LSE_CLOCK) ? ::LSE_CLOCK :
                     (_clockSource == HSE_CLOCK) ? ::HSE_CLOCK : ::LSI_CLOCK
                     , resetTime);
@@ -103,7 +104,7 @@ void STM32RTC::begin(bool resetTime, Hour_Format format)
   */
 void STM32RTC::end(void)
 {
-  RTC_DeInit();
+  RTC_DeInit(true);
   _timeSet = false;
 }
 
@@ -117,74 +118,77 @@ STM32RTC::Source_Clock STM32RTC::getClockSource(void)
 }
 
 /**
-  * @brief set the RTC clock source. By default LSI clock is selected. This
-  * method must be called before begin().
+  * @brief set the RTC clock source and user (a)synchronous prescalers values.
+  * @note  By default LSI clock is selected. This method must be called before begin().
   * @param source: clock source: LSI_CLOCK, LSE_CLOCK or HSE_CLOCK
+  * @param  predivA: Asynchronous prescaler value.
+  * @note   Reset value: RTC_AUTO_1_SECOND for STM32F1xx series, else (PREDIVA_MAX + 1)
+  * @param  predivS: Synchronous prescaler value.
+  * @note   Reset value: (PREDIVS_MAX + 1), not used for STM32F1xx series.
   * @retval None
   */
-void STM32RTC::setClockSource(Source_Clock source)
+void STM32RTC::setClockSource(Source_Clock source, uint32_t predivA, uint32_t predivS)
 {
   if (IS_CLOCK_SOURCE(source)) {
     _clockSource = source;
     RTC_SetClockSource((_clockSource == LSE_CLOCK) ? ::LSE_CLOCK :
                        (_clockSource == HSE_CLOCK) ? ::HSE_CLOCK : ::LSI_CLOCK);
   }
+  RTC_setPrediv(predivA, predivS);
 }
 
-#if defined(STM32F1xx)
 /**
-  * @brief  get user asynchronous prescaler value for the current clock source.
-  * @param  predivA: pointer to the current Asynchronous prescaler value
-  * @param  dummy : not used (kept for compatibility reason)
+  * @brief get the Binary Mode.
+  * @retval mode: MODE_BCD, MODE_BIN or MODE_MIX
+  */
+STM32RTC::Binary_Mode STM32RTC::getBinaryMode(void)
+{
+  return _mode;
+}
+
+/**
+  * @brief set the Binary Mode. By default MODE_BCD is selected. This
+  *        method must be called before begin().
+  * @param mode: the RTC mode: MODE_BCD, MODE_BIN or MODE_MIX
   * @retval None
   */
-void STM32RTC::getPrediv(uint32_t *predivA, int16_t *dummy)
+void STM32RTC::setBinaryMode(Binary_Mode mode)
 {
-  UNUSED(dummy);
-  RTC_getPrediv(predivA);
+  _mode = mode;
 }
-#else
+
 /**
   * @brief  get user (a)synchronous prescaler values if set else computed
   *         ones for the current clock source.
   * @param  predivA: pointer to the current Asynchronous prescaler value
-  * @param  predivS: pointer to the current Synchronous prescaler value
+  * @param  predivS: pointer to the current Synchronous prescaler value,
+  *         not used for STM32F1xx series.
   * @retval None
   */
-void STM32RTC::getPrediv(int8_t *predivA, int16_t *predivS)
+void STM32RTC::getPrediv(uint32_t *predivA, uint32_t *predivS)
 {
-  if ((predivA != nullptr) && (predivS != nullptr)) {
+  if ((predivA != nullptr)
+#if !defined(STM32F1xx)
+      && (predivS != nullptr)
+#endif /* STM32F1xx */
+     ) {
     RTC_getPrediv(predivA, predivS);
   }
 }
-#endif /* STM32F1xx */
 
-#if defined(STM32F1xx)
 /**
-  * @brief  set user asynchronous prescalers value.
+  * @brief  set user (a)synchronous prescalers values.
   * @note   This method must be called before begin().
-  * @param  predivA: Asynchronous prescaler value. Reset value: RTC_AUTO_1_SECOND
-  * @param  dummy : not used (kept for compatibility reason)
+  * @param  predivA: Asynchronous prescaler value.
+  * @note   Reset value: RTC_AUTO_1_SECOND for STM32F1xx series, else (PREDIVA_MAX + 1)
+  * @param  predivS: Synchronous prescaler value.
+  * @note   Reset value: (PREDIVS_MAX + 1), not used for STM32F1xx series.
   * @retval None
   */
-void STM32RTC::setPrediv(uint32_t predivA, int16_t dummy)
+void STM32RTC::setPrediv(uint32_t predivA, uint32_t predivS)
 {
-  UNUSED(dummy);
-  RTC_setPrediv(predivA);
+  setClockSource(_clockSource, predivA, predivS);
 }
-#else
-/**
-  * @brief  set user (a)synchronous prescalers value.
-  * @note   This method must be called before begin().
-  * @param  predivA: Asynchronous prescaler value. Reset value: -1
-  * @param  predivS: Synchronous prescaler value. Reset value: -1
-  * @retval None
-  */
-void STM32RTC::setPrediv(int8_t predivA, int16_t predivS)
-{
-  RTC_setPrediv(predivA, predivS);
-}
-#endif /* STM32F1xx */
 
 /**
   * @brief enable the RTC alarm.
@@ -827,7 +831,7 @@ void STM32RTC::setAlarmSubSeconds(uint32_t subSeconds, Alarm name)
 #ifdef RTC_ALARM_B
     if (name == ALARM_B) {
       _alarmBSubSeconds = subSeconds;
-    }
+    } else
 #else
     UNUSED(name);
 #endif
@@ -850,7 +854,7 @@ void STM32RTC::setAlarmSeconds(uint8_t seconds, Alarm name)
 #ifdef RTC_ALARM_B
     if (name == ALARM_B) {
       _alarmBSeconds = seconds;
-    }
+    } else
 #else
     UNUSED(name);
 #endif
@@ -873,7 +877,7 @@ void STM32RTC::setAlarmMinutes(uint8_t minutes, Alarm name)
 #ifdef RTC_ALARM_B
     if (name == ALARM_B) {
       _alarmBMinutes = minutes;
-    }
+    } else
 #else
     UNUSED(name);
 #endif

diff --git a/src/STM32RTC.h b/src/STM32RTC.h
@@ -85,6 +85,12 @@ class STM32RTC {
       PM = HOUR_PM
     };
 
+    enum Binary_Mode : uint8_t {
+      MODE_BCD = MODE_BINARY_NONE, /* not used */
+      MODE_BIN = MODE_BINARY_ONLY,
+      MODE_MIX = MODE_BINARY_MIX
+    };
+
     enum Alarm_Match : uint8_t {
       MATCH_OFF          = OFF_MSK,                          // Never
       MATCH_SS           = SS_MSK,                           // Every Minute
@@ -126,7 +132,12 @@ class STM32RTC {
     void end(void);
 
     Source_Clock getClockSource(void);
-    void setClockSource(Source_Clock source);
+    void setClockSource(Source_Clock source, uint32_t predivA = (PREDIVA_MAX + 1), uint32_t predivS = (PREDIVS_MAX + 1));
+    void getPrediv(uint32_t *predivA, uint32_t *predivS);
+    void setPrediv(uint32_t predivA, uint32_t predivS);
+
+    Binary_Mode getBinaryMode(void);
+    void setBinaryMode(Binary_Mode mode);
 
     void enableAlarm(Alarm_Match match, Alarm name = ALARM_A);
     void disableAlarm(Alarm name = ALARM_A);
@@ -212,13 +223,6 @@ class STM32RTC {
     void setAlarmEpoch(time_t ts, Alarm_Match match, Alarm name);
     void setAlarmEpoch(time_t ts, Alarm_Match match = MATCH_DHHMMSS, uint32_t subSeconds = 0, Alarm name = ALARM_A);
 
-#if defined(STM32F1xx)
-    void getPrediv(uint32_t *predivA, int16_t *dummy = nullptr);
-    void setPrediv(uint32_t predivA, int16_t dummy = 0);
-#else
-    void getPrediv(int8_t *predivA, int16_t *predivS);
-    void setPrediv(int8_t predivA, int16_t predivS);
-#endif /* STM32F1xx */
     bool isConfigured(void)
     {
       return RTC_IsConfigured();
@@ -232,11 +236,15 @@ class STM32RTC {
     friend class STM32LowPower;
 
   private:
-    STM32RTC(void): _clockSource(LSI_CLOCK) {}
+    STM32RTC(void): _mode(MODE_BCD), _clockSource(LSI_CLOCK)
+    {
+      setClockSource(_clockSource);
+    }
 
     static bool _timeSet;
 
     Hour_Format _format;
+    Binary_Mode _mode;
     AM_PM       _hoursPeriod;
     uint8_t     _hours;
     uint8_t     _minutes;