Add mgos_uptime_micros(), fix sleep issues on CC32x and STM32

`mgos_uptime_micros()` provides a reliable, microsecond-accurate monotonic counter on all our supported platforms:

 * On ESP32 we have esp_timer_get_time()
 * On ESP8266 we have system_get_time() (plus overflow handling)
 * On ARM-based platforms we use FreeRTOS xTaskGetTickCount() + SYSTICK for fractional ticks

CL: Add mgos_uptime_micros(), fix sleep issues on CC32x and STM32

PUBLISHED_FROM=fb548dc351b24de0f0ceb1b0f974be3b495264d3

Author: Deomid Ryabkov

fw/include/mgos_time.h

@@ -37,6 +37,9 @@ struct timezone;
 /* Get number of seconds since last reboot */
 double mgos_uptime(void);
 
+/* Get number of microseconds since last reboot */
+int64_t mgos_uptime_micros(void);
+
 /*
  * Format `time` according to a `strftime()`-conformant format.
  * Write the result into the `s,size` buffer. Return resulting string length.

fw/platforms/cc32xx/src/cc32xx_hal.c

@@ -31,14 +31,6 @@
 #include "mgos_hal.h"
 #include "mgos_mongoose.h"
 
-/* TODO(rojer): make accurate to account for vTaskDelay inaccuracy */
-void mgos_usleep(uint32_t usecs) {
-  int ticks = usecs / (1000000 / configTICK_RATE_HZ);
-  int remainder = usecs % (1000000 / configTICK_RATE_HZ);
-  if (ticks > 0) vTaskDelay(ticks);
-  if (remainder > 0) MAP_UtilsDelay(remainder * (SYS_CLK / 1000000) / 3);
-}
-
 void mgos_msleep(uint32_t msecs) {
   mgos_usleep(msecs * 1000);
 }

fw/platforms/esp32/src/esp32_hal.c

@@ -58,14 +58,6 @@ void mgos_msleep(uint32_t msecs) {
   mgos_usleep(msecs * 1000);
 }
 
-IRAM void mgos_usleep(uint32_t usecs) {
-  uint64_t threshold = esp_timer_get_time() + (uint64_t) usecs;
-  int ticks = usecs / (1000000 / configTICK_RATE_HZ);
-  if (ticks > 0) vTaskDelay(ticks);
-  while (esp_timer_get_time() < threshold) {
-  }
-}
-
 void mgos_wdt_feed(void) {
   esp_task_wdt_reset();
 }

fw/platforms/esp8266/src/esp_hal.c

@@ -73,23 +73,6 @@ void mgos_msleep(uint32_t msecs) {
   mgos_usleep(msecs * 1000);
 }
 
-#ifdef RTOS_SDK
-IRAM void mgos_usleep(uint32_t usecs) {
-/*
- * configTICK_RATE_HZ is 100, implying 10 ms ticks.
- * But we run CPU at 160 and tick timer is not updated, hence / 2 below.
- * https://github.com/espressif/ESP8266_RTOS_SDK/issues/90
- */
-#define USECS_PER_TICK (1000000 / configTICK_RATE_HZ / 2)
-  uint32_t ticks = usecs / USECS_PER_TICK;
-  usecs = usecs % USECS_PER_TICK;
-  if (ticks > 0) vTaskDelay(ticks);
-  os_delay_us(usecs);
-}
-#else
-/* Provided by linker script as an alias to ets_delay_us */
-#endif
-
 IRAM void mgos_ints_disable(void) {
   __asm volatile("rsil a2, 3" : : : "a2");
 }

fw/platforms/esp8266/src/esp_libc.c

@@ -30,6 +30,7 @@
 #endif
 
 #include "mgos_hal.h"
+#include "mgos_time.h"
 #include "fw/platforms/esp8266/src/esp_features.h"
 
 #if MGOS_ENABLE_HEAP_LOG
@@ -134,23 +135,21 @@ void _exit(int status) {
  * At least Mongoose poll queries time, so we're covered.
  */
 
-static int64_t get_time64_micros(void) {
+IRAM int64_t mgos_uptime_micros(void) {
   static uint32_t prev_time = 0;
   static uint32_t num_overflows = 0;
-  mgos_ints_disable();
   uint32_t time = system_get_time();
   int64_t time64 = time;
   if (prev_time > 0 && time < prev_time) num_overflows++;
   time64 += (((uint64_t) num_overflows) * (1ULL << 32));
   prev_time = time;
-  mgos_ints_enable();
   return time64;
 }
 
 static int64_t sys_time_adj = 0;
 
 int _gettimeofday_r(struct _reent *r, struct timeval *tv, struct timezone *tz) {
-  int64_t time64 = get_time64_micros() + sys_time_adj;
+  int64_t time64 = mgos_uptime_micros() + sys_time_adj;
   tv->tv_sec = time64 / 1000000ULL;
   tv->tv_usec = time64 % 1000000ULL;
   return 0;
@@ -159,7 +158,7 @@ int _gettimeofday_r(struct _reent *r, struct timeval *tv, struct timezone *tz) {
 }
 
 int settimeofday(const struct timeval *tv, const struct timezone *tz) {
-  int64_t time64_cur = get_time64_micros();
+  int64_t time64_cur = mgos_uptime_micros();
   int64_t time64_new = tv->tv_sec * 1000000LL + tv->tv_usec;
   sys_time_adj = (time64_new - time64_cur);
   (void) tz;

fw/platforms/stm32/include/stm32_system.h

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -26,6 +28,8 @@ void stm32_clock_config(void);
 void stm32_flush_caches(void);
 void stm32_set_int_handler(int irqn, void (*handler)(void));
 
+extern uint32_t SystemCoreClockMHZ;
+
 #ifdef __cplusplus
 }
 #endif

fw/platforms/stm32/src/stm32_hal.c

@@ -71,26 +71,6 @@ void mgos_msleep(uint32_t msecs) {
 
 void HAL_Delay(__IO uint32_t ms) __attribute__((alias("mgos_msleep")));
 
-static void delay_cycles(unsigned long n) {
-  __asm(
-      "dcy: subs    %0, #1\n"
-      "     bne     dcy\n"
-      : /* output */
-      : /* input */ "r"(n)
-      : /* scratch */);
-}
-
-void mgos_usleep(uint32_t usecs) {
-#ifndef MGOS_BOOT_BUILD
-  int ticks = usecs / (1000000 / configTICK_RATE_HZ);
-  int remainder = usecs % (1000000 / configTICK_RATE_HZ);
-  if (ticks > 0) vTaskDelay(ticks);
-#else
-  uint32_t remainder = usecs;
-#endif
-  if (remainder > 0) delay_cycles(remainder * (SystemCoreClock / 1000000));
-}
-
 /* Note: PLL must be enabled for RNG to work */
 int mg_ssl_if_mbed_random(void *ctx, unsigned char *buf, size_t len) {
   RCC->AHB2ENR |= RCC_AHB2ENR_RNGEN;

fw/platforms/stm32/src/stm32_libc.c

@@ -26,33 +26,17 @@
 
 #include "mgos_debug.h"
 #include "mgos_system.h"
+#include "mgos_time.h"
 
+#include "stm32_system.h"
 #include "stm32_uart_internal.h"
 
 #include <stm32_sdk_hal.h>
 
-/*
- * This will prevent counter wrap if time is read regularly.
- * At least Mongoose poll queries time, so we're covered.
- */
-static int64_t get_time64_micros(void) {
-  static uint32_t prev_time = 0;
-  static uint32_t num_overflows = 0;
-  mgos_ints_disable();
-  uint32_t time = xTaskGetTickCount();
-  int64_t time64 = time;
-  time64 *= (portTICK_PERIOD_MS * 1000);
-  if (prev_time > 0 && time < prev_time) num_overflows++;
-  time64 += (((uint64_t) num_overflows) * (1ULL << 32));
-  prev_time = time;
-  mgos_ints_enable();
-  return time64;
-}
-
 static int64_t sys_time_adj = 0;
 
 int _gettimeofday_r(struct _reent *r, struct timeval *tv, struct timezone *tz) {
-  int64_t time64 = get_time64_micros() + sys_time_adj;
+  int64_t time64 = mgos_uptime_micros() + sys_time_adj;
   tv->tv_sec = time64 / 1000000ULL;
   tv->tv_usec = time64 % 1000000ULL;
   return 0;
@@ -61,7 +45,7 @@ int _gettimeofday_r(struct _reent *r, struct timeval *tv, struct timezone *tz) {
 }
 
 int settimeofday(const struct timeval *tv, const struct timezone *tz) {
-  int64_t time64_cur = get_time64_micros();
+  int64_t time64_cur = mgos_uptime_micros();
   int64_t time64_new = tv->tv_sec * 1000000LL + tv->tv_usec;
   sys_time_adj = (time64_new - time64_cur);
   (void) tz;

fw/platforms/stm32/src/stm32_main.c

@@ -106,14 +106,15 @@ enum mgos_init_result mgos_hal_freertos_pre_init() {
   return MGOS_INIT_OK;
 }
 
-extern void mgos_nsleep100_cal();
-
+uint32_t SystemCoreClockMHZ = 0;
 uint32_t mgos_bitbang_n100_cal = 0;
+extern void mgos_nsleep100_cal();
 
 void SystemCoreClockUpdate(void) {
   uint32_t presc =
       AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> RCC_CFGR_HPRE_Pos)];
   SystemCoreClock = HAL_RCC_GetSysClockFreq() >> presc;
+  SystemCoreClockMHZ = SystemCoreClock / 1000000;
   mgos_nsleep100_cal();
 }
 

fw/src/mgos_hal_freertos.c

@@ -35,6 +35,7 @@
 #ifdef MGOS_HAVE_OTA_COMMON
 #include "mgos_ota.h"
 #endif
+#include "mgos_system.h"
 #include "mgos_uart_internal.h"
 #include "mgos_utils.h"
 
@@ -333,4 +334,55 @@ IRAM void mgos_rlock_destroy(struct mgos_rlock_type *l) {
   if (l == NULL) return;
   vSemaphoreDelete((SemaphoreHandle_t) l);
 }
+
+#if CS_PLATFORM == CS_P_ESP32
+
+IRAM int64_t mgos_uptime_micros(void) {
+  return (int64_t) esp_timer_get_time();
+}
+
+#else /* All the ARM cores have SYSTICK */
+
+#if defined(__arm__) || defined(__TI_COMPILER_VERSION__)
+#define SYSTICK_VAL (*((volatile uint32_t *) 0xe000e018))
+#define SYSTICK_RLD (*((volatile uint32_t *) 0xe000e014))
+#else
+#error Does not look like an ARM processor to me. Help!
+#endif
+
+#if CS_PLATFORM == CS_P_CC3200 || CS_PLATFORM == CS_P_CC3220
+#define SystemCoreClockMHZ (SYS_CLK / 1000000)
+#else
+extern uint32_t SystemCoreClockMHZ;
+#endif
+
+IRAM int64_t mgos_uptime_micros(void) {
+  static uint8_t num_overflows = 0;
+  static uint32_t prev_tc = 0;
+  uint32_t tc, frac;
+  do {
+    tc = xTaskGetTickCount();
+    frac = (SYSTICK_RLD - SYSTICK_VAL);
+    // If a tick happens in between, fraction calculation may be wrong.
+  } while (xTaskGetTickCount() != tc);
+  if (tc < prev_tc) num_overflows++;
+  prev_tc = tc;
+  return ((((int64_t) num_overflows) << 32) + tc) * portTICK_PERIOD_MS * 1000 +
+         (int64_t)(frac / SystemCoreClockMHZ);
+}
+
+#endif /* CS_P_ESP32 */
+
+IRAM void mgos_usleep(uint32_t usecs) {
+  if (usecs < (1000000 / configTICK_RATE_HZ)) {
+    (*mgos_nsleep100)(usecs * 10);
+  } else {
+    int64_t threshold = mgos_uptime_micros() + (int64_t) usecs;
+    int ticks = usecs / (1000000 / configTICK_RATE_HZ);
+    if (ticks > 0) vTaskDelay(ticks);
+    while (mgos_uptime_micros() < threshold) {
+    }
+  }
+}
+
 #endif /* MGOS_BOOT_BUILD */