Merge pull request #1347 from jonny5532/feature/use-millis64-to-avoid-overflow

Add a 64-bit millis64() function to avoid rollover issues

Software/Software.ino

@@ -47,7 +47,6 @@ const char* version_number = "9.0.experimental";
 volatile unsigned long currentMillis = 0;
 unsigned long previousMillis10ms = 0;
 unsigned long previousMillisUpdateVal = 0;
-unsigned long lastMillisOverflowCheck = 0;
 #ifdef FUNCTION_TIME_MEASUREMENT
 // Task time measurement for debugging
 MyTimer core_task_timer_10s(INTERVAL_10_S);
@@ -347,15 +346,6 @@ void init_serial() {
 #endif  // DEBUG_VIA_USB
 }
 
-void update_overflow(unsigned long currentMillis) {
-  // Check if millis overflowed
-  if (currentMillis < lastMillisOverflowCheck) {
-    // We have overflowed, increase rollover count
-    datalayer.system.status.millisrolloverCount++;
-  }
-  lastMillisOverflowCheck = currentMillis;
-}
-
 void check_interconnect_available() {
   if (datalayer.battery.status.voltage_dV == 0 || datalayer.battery2.status.voltage_dV == 0) {
     return;  // Both voltage values need to be available to start check
@@ -543,8 +533,6 @@ void update_calculated_values() {
       datalayer.battery.status.reported_remaining_capacity_Wh = datalayer.battery2.status.remaining_capacity_Wh;
     }
   }
-
-  update_overflow(currentMillis);  // Update millis rollover count
 }
 
 void check_reset_reason() {
@@ -602,9 +590,3 @@ void check_reset_reason() {
       break;
   }
 }
-
-uint64_t get_timestamp(unsigned long currentMillis) {
-  update_overflow(currentMillis);
-  return (uint64_t)datalayer.system.status.millisrolloverCount * (uint64_t)std::numeric_limits<uint32_t>::max() +
-         (uint64_t)currentMillis;
-}

Software/src/datalayer/datalayer.h

@@ -253,8 +253,6 @@ typedef struct {
 } DATALAYER_SYSTEM_INFO_TYPE;
 
 typedef struct {
-  /** Millis rollover count. Increments every 49.7 days. Used for keeping track on events */
-  uint8_t millisrolloverCount = 0;
 #ifdef FUNCTION_TIME_MEASUREMENT
   /** Core task measurement variable */
   int64_t core_task_max_us = 0;

Software/src/devboard/utils/events.cpp

@@ -397,8 +397,6 @@ EVENTS_LEVEL_TYPE get_event_level(void) {
   return events.level;
 }
 
-uint64_t get_timestamp(unsigned long currentMillis);
-
 /* Local functions */
 
 static void set_event(EVENTS_ENUM_TYPE event, uint8_t data, bool latched) {
@@ -417,7 +415,7 @@ static void set_event(EVENTS_ENUM_TYPE event, uint8_t data, bool latched) {
   }
 
   // We should set the event, update event info
-  events.entries[event].timestamp = get_timestamp(millis());
+  events.entries[event].timestamp = millis64();
   events.entries[event].data = data;
   // Check if the event is latching
   events.entries[event].state = latched ? EVENT_STATE_ACTIVE_LATCHED : EVENT_STATE_ACTIVE;

Software/src/devboard/utils/events.h

@@ -2,6 +2,7 @@
 #define __EVENTS_H__
 
 #include <WString.h>
+#include <src/devboard/utils/millis64.h>
 #include <src/devboard/utils/types.h>
 #include <stdint.h>
 

Software/src/devboard/utils/millis64.cpp

@@ -0,0 +1,12 @@
+#include <Arduino.h>
+#include "esp_timer.h"
+
+uint64_t ARDUINO_ISR_ATTR millis64() {
+  // ESP32's esp_timer_get_time() returns time in microseconds, we convert to
+  // milliseconds by dividing by 1000.
+
+  // This is almost identical to the existing Arduino millis() function, except
+  // we return a 64-bit value which won't roll over for 600k years.
+
+  return esp_timer_get_time() / 1000ULL;
+}

Software/src/devboard/utils/millis64.h

@@ -0,0 +1,11 @@
+#include <stdint.h>
+
+/**
+ * @brief Return ESP32's high-resolution timer in milliseconds, as a 64 bit value.
+ * 
+ * @param[in] void
+ * 
+ * @return uint64_t Timestamp in milliseconds
+ * 
+ */
+extern uint64_t millis64(void);

Software/src/devboard/webserver/events_html.cpp

@@ -2,6 +2,7 @@
 #include <limits>
 #include "../../datalayer/datalayer.h"
 #include "../../devboard/utils/logging.h"
+#include "../../devboard/utils/millis64.h"
 
 const char EVENTS_HTML_START[] = R"=====(
 <style>body{background-color:#000;color:#fff}.event-log{display:flex;flex-direction:column}.event{display:flex;flex-wrap:wrap;border:1px solid #fff;padding:10px}.event>div{flex:1;min-width:100px;max-width:90%;word-break:break-word}</style><div style="background-color:#303e47;padding:10px;margin-bottom:10px;border-radius:25px"><div class="event-log"><div class="event" style="background-color:#1e2c33;font-weight:700"><div>Event Type</div><div>Severity</div><div>Last Event</div><div>Count</div><div>Data</div><div>Message</div></div>
@@ -17,8 +18,6 @@ button:hover { background-color: #3A4A52; }</style>
 </script>
 )=====";
 
-uint64_t get_timestamp(unsigned long currentMillis);
-
 static std::vector<EventData> order_events;
 
 String events_processor(const String& var) {
@@ -40,7 +39,7 @@ String events_processor(const String& var) {
     }
     // Sort events by timestamp
     std::sort(order_events.begin(), order_events.end(), compareEventsByTimestampDesc);
-    uint64_t current_timestamp = get_timestamp(millis());
+    uint64_t current_timestamp = millis64();
 
     // Generate HTML and debug output
     for (const auto& event : order_events) {

Software/src/lib/YiannisBourkelis-Uptime-Library/src/uptime.cpp

@@ -36,25 +36,16 @@
  * https://github.com/YiannisBourkelis/
  */
 
-#include <Arduino.h> //for millis()
+#include "../../../devboard/utils/millis64.h"
 #include "uptime.h"
 
 //private variabes for converting milliseconds to total seconds,minutes,hours and days
 //after each call to millis()
-unsigned long uptime::m_milliseconds;
-unsigned long uptime::m_seconds;
-unsigned long uptime::m_minutes;
-unsigned long uptime::m_hours;
-unsigned long uptime::m_days;
-
-//in case of millis() overflow, we store in these private variables
-//the existing time passed until the moment of the overflow
-//so that we can add them on the next call to compute the time passed
-unsigned long uptime::m_last_milliseconds = 0;   
-unsigned long uptime::m_remaining_seconds = 0;
-unsigned long uptime::m_remaining_minutes = 0;
-unsigned long uptime::m_remaining_hours = 0;
-unsigned long uptime::m_remaining_days = 0;
+uint64_t uptime::m_milliseconds;
+uint64_t uptime::m_seconds;
+uint64_t uptime::m_minutes;
+uint64_t uptime::m_hours;
+uint64_t uptime::m_days;
 
 //private variables that in combination hold the actual time passed
 //Use the coresponding uptime::get_.... to read these private variables
@@ -90,26 +81,13 @@ unsigned long uptime::getDays()
 //and store them in their static variables
 void uptime::calculateUptime()
 {
-  uptime::m_milliseconds = millis();
-  
-  if (uptime::m_last_milliseconds > uptime::m_milliseconds){
-    //in case of millis() overflow, store existing passed seconds,minutes,hours and days
-    uptime::m_remaining_seconds = uptime::m_mod_seconds;
-    uptime::m_remaining_minutes = uptime::m_mod_minutes;
-    uptime::m_remaining_hours   = uptime::m_mod_hours;
-    uptime::m_remaining_days    = uptime::m_days;
-  }
-  //store last millis(), so that we can detect on the next call
-  //if there is a millis() overflow ( millis() returns 0 )
-  uptime::m_last_milliseconds = uptime::m_milliseconds;
+  uptime::m_milliseconds = millis64();
 
   //convert passed millis to total seconds, minutes, hours and days.
-  //In case of overflow, the uptime::m_remaining_... variables contain the remaining time before the overflow.
-  //We add the remaining time, so that we can continue measuring the time passed from the last boot of the device.
-  uptime::m_seconds      = (uptime::m_milliseconds / 1000) + uptime::m_remaining_seconds;
-  uptime::m_minutes      = (uptime::m_seconds      / 60)   + uptime::m_remaining_minutes;
-  uptime::m_hours        = (uptime::m_minutes      / 60)   + uptime::m_remaining_hours;
-  uptime::m_days         = (uptime::m_hours        / 24)   + uptime::m_remaining_days;
+  uptime::m_seconds      = (uptime::m_milliseconds / 1000);
+  uptime::m_minutes      = (uptime::m_seconds      / 60);
+  uptime::m_hours        = (uptime::m_minutes      / 60);
+  uptime::m_days         = (uptime::m_hours        / 24);
 
   //calculate the actual time passed, using modulus, in milliseconds, seconds and hours.
   //The days are calculated allready in the previous step. 

Software/src/lib/YiannisBourkelis-Uptime-Library/src/uptime.h

@@ -53,21 +53,15 @@ class uptime
     static unsigned long getDays();
       
   private:
-    static unsigned long m_milliseconds;
-    static unsigned long m_seconds;
-    static unsigned long m_minutes;
-    static unsigned long m_hours;
-    static unsigned long m_days;
+    static uint64_t m_milliseconds;
+    static uint64_t m_seconds;
+    static uint64_t m_minutes;
+    static uint64_t m_hours;
+    static uint64_t m_days;
 
     static unsigned long m_mod_milliseconds;
     static uint8_t m_mod_seconds;
     static uint8_t m_mod_minutes;
     static uint8_t m_mod_hours;
-    
-    static unsigned long m_last_milliseconds;  
-    static unsigned long m_remaining_seconds;
-    static unsigned long m_remaining_minutes;
-    static unsigned long m_remaining_hours;
-    static unsigned long m_remaining_days;
 };
 #endif