Extract RTC, implement fake RTC deepsleep

Author: hierophect

main.c

@@ -157,7 +157,7 @@ STATIC void start_mp(supervisor_allocation* heap) {
 
     #if CIRCUITPY_ALARM
     // Record which alarm woke us up, if any. An object may be created so the heap must be functional.
-    common_hal_alarm_save_wake_alarm();
+    shared_alarm_save_wake_alarm();
     // Reset alarm module only after we retrieved the wakeup alarm.
     common_hal_alarm_reset();
     #endif
@@ -301,8 +301,6 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
         }
         #endif
 
-        // TODO: on deep sleep, make sure display is refreshed before sleeping (for e-ink).
-
         cleanup_after_vm(heap);
 
         if (result.return_code & PYEXEC_FORCED_EXIT) {

ports/esp32s2/common-hal/alarm/__init__.c

@@ -126,7 +126,7 @@ STATIC void _idle_until_alarm(void) {
         // Allow ctrl-C interrupt.
         if (common_hal_alarm_woken_from_sleep()) {
             // This saves the return of common_hal_alarm_get_wake_alarm through Shared Bindings
-            common_hal_alarm_save_wake_alarm();
+            shared_alarm_save_wake_alarm();
             return;
         }
         port_idle_until_interrupt();

ports/stm/common-hal/alarm/__init__.c

@@ -45,7 +45,7 @@
 void common_hal_alarm_reset(void) {
     // alarm_sleep_memory_reset();
     alarm_pin_pinalarm_reset();
-    // alarm_time_timealarm_reset();
+    alarm_time_timealarm_reset();
     // alarm_touch_touchalarm_reset();
     // esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
 }
@@ -101,7 +101,7 @@ mp_obj_t common_hal_alarm_get_wake_alarm(void) {
 // Set up light sleep or deep sleep alarms.
 STATIC void _setup_sleep_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
     alarm_pin_pinalarm_set_alarms(deep_sleep, n_alarms, alarms);
-    // alarm_time_timealarm_set_alarms(deep_sleep, n_alarms, alarms);
+    alarm_time_timealarm_set_alarms(deep_sleep, n_alarms, alarms);
     // alarm_touch_touchalarm_set_alarm(deep_sleep, n_alarms, alarms);
 }
 
@@ -111,23 +111,20 @@ STATIC void _idle_until_alarm(void) {
         RUN_BACKGROUND_TASKS;
         // Allow ctrl-C interrupt.
         if (common_hal_alarm_woken_from_sleep()) {
-            common_hal_alarm_save_wake_alarm();
+            shared_alarm_save_wake_alarm();
             return;
         }
-        // port_idle_until_interrupt();
+        port_idle_until_interrupt();
     }
 }
 
 mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj_t *alarms) {
-    // if (supervisor_workflow_active()) {
-    //     mp_raise_NotImplementedError(translate("Cannot sleep with USB connected"));
-    // }
-    _setup_sleep_alarms(false, n_alarms, alarms);
-
     // If USB is active, only pretend to sleep. Otherwise, light sleep
     if (supervisor_workflow_active()) {
+        _setup_sleep_alarms(false, n_alarms, alarms);
         _idle_until_alarm();
     } else {
+        _setup_sleep_alarms(false, n_alarms, alarms);
         port_disable_tick();
         HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
         port_enable_tick();
@@ -144,13 +141,17 @@ void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *ala
 
 //#define NORETURN __attribute__((noreturn))
 void NORETURN common_hal_alarm_enter_deep_sleep(void) {
-    // alarm_pin_pinalarm_prepare_for_deep_sleep();
+    alarm_pin_pinalarm_prepare_for_deep_sleep();
+    //port_disable_tick();
     // alarm_touch_touchalarm_prepare_for_deep_sleep();
-    while(1);
+    // HAL_PWR_EnableBkUpAccess();
+    // __HAL_RCC_BACKUPRESET_FORCE();
+    // __HAL_RCC_BACKUPRESET_RELEASE();
 
-    // The ESP-IDF caches the deep sleep settings and applies them before sleep.
-    // We don't need to worry about resetting them in the interim.
-    // esp_deep_sleep_start();
+    HAL_PWR_EnterSTANDBYMode();
+
+    // Should never hit this
+    while(1);
 }
 
 void common_hal_alarm_gc_collect(void) {

ports/stm/common-hal/alarm/pin/PinAlarm.c

@@ -35,6 +35,7 @@
 STATIC bool woke_up;
 
 STATIC uint16_t alarm_pin_triggered;
+STATIC bool deep_wkup_enabled;
 
 STATIC void pin_alarm_callback(uint8_t num) {
     alarm_pin_triggered |= (1 << num);
@@ -112,17 +113,32 @@ void alarm_pin_pinalarm_reset(void) {
     woke_up = false;
 }
 
+// Deep sleep alarms don't actually make use of EXTI, but we pretend they're the same.
 void alarm_pin_pinalarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
     for (size_t i = 0; i < n_alarms; i++) {
         if (MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pinalarm_type)) {
             alarm_pin_pinalarm_obj_t *alarm  = MP_OBJ_TO_PTR(alarms[i]);
-            stm_peripherals_exti_enable(alarm->pin->number);
+
+            if (deep_sleep) {
+                // Deep sleep only wakes on a rising edge from one pin, WKUP (PA00)
+                if (alarm->pin != &pin_PA00) {
+                    mp_raise_ValueError(translate("Only the WKUP pin can be used to wake from Deep Sleep"));
+                }
+                HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);
+                __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
+                HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
+
+                deep_wkup_enabled = true;
+            } else {
+                stm_peripherals_exti_enable(alarm->pin->number);
+            }
         }
     }
 }
 
 void alarm_pin_pinalarm_reset_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
     alarm_pin_triggered = 0;
+    deep_wkup_enabled = false;
     for (size_t i = 0; i < n_alarms; i++) {
         if (MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pinalarm_type)) {
             alarm_pin_pinalarm_obj_t *alarm  = MP_OBJ_TO_PTR(alarms[i]);
@@ -131,6 +147,10 @@ void alarm_pin_pinalarm_reset_alarms(bool deep_sleep, size_t n_alarms, const mp_
     }
 }
 
+// If we don't have WKUP enabled, ensure it's disabled
+// TODO; is this really required?
 void alarm_pin_pinalarm_prepare_for_deep_sleep(void) {
-
+    if (!deep_wkup_enabled) {
+        HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);
+    }
 }

ports/stm/common-hal/alarm/time/TimeAlarm.c

@@ -28,6 +28,10 @@
 
 #include "shared-bindings/alarm/time/TimeAlarm.h"
 #include "shared-bindings/time/__init__.h"
+#include "supervisor/port.h"
+#include "peripherals/rtc.h"
+
+STATIC volatile bool woke_up;
 
 void common_hal_alarm_time_timealarm_construct(alarm_time_timealarm_obj_t *self, mp_float_t monotonic_time) {
     self->monotonic_time = monotonic_time;
@@ -37,42 +41,59 @@ mp_float_t common_hal_alarm_time_timealarm_get_monotonic_time(alarm_time_timeala
     return self->monotonic_time;
 }
 
-// mp_obj_t alarm_time_timealarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *alarms) {
-//     // First, check to see if we match
-//     for (size_t i = 0; i < n_alarms; i++) {
-//         if (MP_OBJ_IS_TYPE(alarms[i], &alarm_time_timealarm_type)) {
-//             return alarms[i];
-//         }
-//     }
-//     alarm_time_timealarm_obj_t *timer = m_new_obj(alarm_time_timealarm_obj_t);
-//     timer->base.type = &alarm_time_timealarm_type;
-//     // TODO: Set monotonic_time based on the RTC state.
-//     timer->monotonic_time = 0.0f;
-//     return timer;
-// }
+mp_obj_t alarm_time_timealarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *alarms) {
+    // First, check to see if we match
+    for (size_t i = 0; i < n_alarms; i++) {
+        if (MP_OBJ_IS_TYPE(alarms[i], &alarm_time_timealarm_type)) {
+            return alarms[i];
+        }
+    }
+    alarm_time_timealarm_obj_t *timer = m_new_obj(alarm_time_timealarm_obj_t);
+    timer->base.type = &alarm_time_timealarm_type;
+    // TODO: Set monotonic_time based on the RTC state.
+    timer->monotonic_time = 0.0f;
+    return timer;
+}
 
 // This is run in the timer task. We use it to wake the main CircuitPython task.
-// void timer_callback(void *arg) {
-//     (void) arg;
-//     woke_up = true;
-//     xTaskNotifyGive(circuitpython_task);
-// }
+STATIC void timer_callback(void) {
+    woke_up = true;
+}
 
 bool alarm_time_timealarm_woke_us_up(void) {
-    // return woke_up;
-    return false;
+    //mp_printf(&mp_plat_print,"Woke Up:%d\n",woke_up);
+    return woke_up;
 }
 
-// void alarm_time_timealarm_reset(void) {
-//     esp_timer_stop(pretend_sleep_timer);
-//     esp_timer_delete(pretend_sleep_timer);
-//     pretend_sleep_timer = NULL;
-//     woke_up = false;
-// }
+void alarm_time_timealarm_reset(void) {
+    // mp_printf(&mp_plat_print,"timealarm reset");
+    woke_up = false;
+}
 
 void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms) {
-    // HAL_RTCEx_SetWakeUpTimer_IT(&RTCHandle, 0xA017, RTC_WAKEUPCLOCK_RTCCLK_DIV16);
-    // HAL_RTCEx_SetWakeUpTimer_IT(&_hrtc, rtc_clock_frequency / 1024 / 2, RTC_WAKEUPCLOCK_RTCCLK_DIV2);
-    // HAL_NVIC_SetPriority(RTC_WKUP_IRQn, 1, 0U);
-    // HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);
+    // Search through alarms for TimeAlarm instances, and check that there's only one
+    bool timealarm_set = false;
+    alarm_time_timealarm_obj_t *timealarm = MP_OBJ_NULL;
+    for (size_t i = 0; i < n_alarms; i++) {
+        if (!MP_OBJ_IS_TYPE(alarms[i], &alarm_time_timealarm_type)) {
+            continue;
+        }
+        if (timealarm_set) {
+            mp_raise_ValueError(translate("Only one alarm.time alarm can be set."));
+        }
+        timealarm  = MP_OBJ_TO_PTR(alarms[i]);
+        timealarm_set = true;
+    }
+    if (!timealarm_set) {
+        return;
+    }
+
+    // Compute how long to actually sleep, considering the time now.
+    mp_float_t now_secs = uint64_to_float(common_hal_time_monotonic_ms()) / 1000.0f;
+    uint32_t wakeup_in_secs = MAX(0.0f, timealarm->monotonic_time - now_secs);
+    uint32_t wakeup_in_ticks = wakeup_in_secs * 1024;
+
+    // Use alarm B, since port reserves A
+    stm32_peripherals_rtc_assign_alarm_callback(PERIPHERALS_ALARM_B,timer_callback);
+    stm32_peripherals_rtc_set_alarm(PERIPHERALS_ALARM_B,wakeup_in_ticks);
 }

ports/stm/common-hal/alarm/time/TimeAlarm.h

@@ -32,9 +32,9 @@ typedef struct {
     mp_float_t monotonic_time;      // values compatible with time.monotonic_time()
 } alarm_time_timealarm_obj_t;
 
-// // Find the alarm object that caused us to wake up or create an equivalent one.
-// mp_obj_t alarm_time_timealarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *alarms);
-// // Check for the wake up alarm from pretend deep sleep.
+// Find the alarm object that caused us to wake up or create an equivalent one.
+mp_obj_t alarm_time_timealarm_get_wakeup_alarm(size_t n_alarms, const mp_obj_t *alarms);
+// Check for the wake up alarm from pretend deep sleep.
 bool alarm_time_timealarm_woke_us_up(void);
-// void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
-// void alarm_time_timealarm_reset(void);
+void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);
+void alarm_time_timealarm_reset(void);

ports/stm/peripherals/exti.c

@@ -32,7 +32,6 @@
 
 #include "peripherals/exti.h"
 
-
 STATIC bool stm_exti_reserved[STM32_GPIO_PORT_SIZE];
 STATIC void (*stm_exti_callback[STM32_GPIO_PORT_SIZE])(uint8_t num);