Extract EXTI, create base sleep framework

Author: hierophect

main.c

@@ -157,9 +157,9 @@ 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.
-    alarm_save_wake_alarm();
+    common_hal_alarm_save_wake_alarm();
     // Reset alarm module only after we retrieved the wakeup alarm.
-    alarm_reset();
+    common_hal_alarm_reset();
     #endif
 
     #if CIRCUITPY_NETWORK
@@ -357,7 +357,7 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
         // an alarm alerts faster than our USB delay or if we pretended to deep
         // sleep.
         #if CIRCUITPY_ALARM
-        if (asleep && alarm_woken_from_sleep()) {
+        if (asleep && common_hal_alarm_woken_from_sleep()) {
             serial_write_compressed(translate("Woken up by alarm.\n"));
             board_init();
             supervisor_set_run_reason(RUN_REASON_STARTUP);
@@ -409,7 +409,7 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
                 if (!supervisor_workflow_active()) {
                     // Enter true deep sleep. When we wake up we'll be back at the
                     // top of main(), not in this loop.
-                    alarm_enter_deep_sleep();
+                    common_hal_alarm_enter_deep_sleep();
                     // Does not return.
                 } else {
                     serial_write_compressed(translate("Pretending to deep sleep until alarm, CTRL-C or file write.\n"));

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

@@ -54,7 +54,7 @@ const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
     },
 };
 
-void alarm_reset(void) {
+void common_hal_alarm_reset(void) {
     alarm_sleep_memory_reset();
     alarm_pin_pinalarm_reset();
     alarm_time_timealarm_reset();
@@ -75,10 +75,12 @@ STATIC esp_sleep_wakeup_cause_t _get_wakeup_cause(void) {
     return esp_sleep_get_wakeup_cause();
 }
 
-bool alarm_woken_from_sleep(void) {
+bool common_hal_alarm_woken_from_sleep(void) {
     return _get_wakeup_cause() != ESP_SLEEP_WAKEUP_UNDEFINED;
 }
 
+// When called to populate the global dict, the module functions create new alarm objects.
+// Otherwise, they scan the existing alarms for matches.
 STATIC mp_obj_t _get_wake_alarm(size_t n_alarms, const mp_obj_t *alarms) {
     esp_sleep_wakeup_cause_t cause = _get_wakeup_cause();
     switch (cause) {
@@ -104,6 +106,8 @@ STATIC mp_obj_t _get_wake_alarm(size_t n_alarms, const mp_obj_t *alarms) {
     return mp_const_none;
 }
 
+// This function is used to create a new alarm object for the global dict after deep sleep,
+// rather than finding an existing one during runtime.
 mp_obj_t common_hal_alarm_get_wake_alarm(void) {
     return _get_wake_alarm(0, NULL);
 }
@@ -120,8 +124,9 @@ STATIC void _idle_until_alarm(void) {
     while (!mp_hal_is_interrupted()) {
         RUN_BACKGROUND_TASKS;
         // Allow ctrl-C interrupt.
-        if (alarm_woken_from_sleep()) {
-            alarm_save_wake_alarm();
+        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();
             return;
         }
         port_idle_until_interrupt();
@@ -139,15 +144,15 @@ mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj
     }
 
     mp_obj_t wake_alarm = _get_wake_alarm(n_alarms, alarms);
-    alarm_reset();
+    alarm_pin_pinalarm_reset_alarms(n_alarms, alarms);
     return wake_alarm;
 }
 
 void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *alarms) {
     _setup_sleep_alarms(true, n_alarms, alarms);
 }
 
-void NORETURN alarm_enter_deep_sleep(void) {
+void NORETURN common_hal_alarm_enter_deep_sleep(void) {
     alarm_pin_pinalarm_prepare_for_deep_sleep();
     alarm_touch_touchalarm_prepare_for_deep_sleep();
 

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

@@ -31,6 +31,6 @@
 
 const alarm_sleep_memory_obj_t alarm_sleep_memory_obj;
 
-extern void alarm_reset(void);
+extern void common_hal_alarm_reset(void);
 
 #endif // MICROPY_INCLUDED_ESP32S2_COMMON_HAL_ALARM__INIT__H

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

@@ -220,6 +220,8 @@ SRC_C += \
 	boards/$(BOARD)/board.c \
 	boards/$(BOARD)/pins.c \
 	peripherals/timers.c \
+	peripherals/exti.c \
+	peripherals/rtc.c \
 	peripherals/stm32$(MCU_SERIES_LOWER)/clocks.c \
 	peripherals/stm32$(MCU_SERIES_LOWER)/$(MCU_VARIANT_LOWER)/pins.c \
 	peripherals/stm32$(MCU_SERIES_LOWER)/$(MCU_VARIANT_LOWER)/gpio.c \

ports/stm/Makefile

@@ -37,3 +37,6 @@ bool board_requests_safe_mode(void) {
 void reset_board(void) {
 
 }
+
+void board_deinit(void) {
+}

ports/stm/boards/feather_stm32f405_express/board.c

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Lucian Copeland for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/runtime.h"
+#include "common-hal/alarm/SleepMemory.h"
+
+void alarm_sleep_memory_reset(void) {
+
+}
+
+uint32_t common_hal_alarm_sleep_memory_get_length(alarm_sleep_memory_obj_t *self) {
+    return 0;
+}
+
+bool common_hal_alarm_sleep_memory_set_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, const uint8_t* values, uint32_t len) {
+    return false;
+}
+
+void common_hal_alarm_sleep_memory_get_bytes(alarm_sleep_memory_obj_t *self, uint32_t start_index, uint8_t* values, uint32_t len) {
+    return;
+}

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

@@ -0,0 +1,38 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Lucian Copeland for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_STM32_COMMON_HAL_ALARM_SLEEPMEMORY_H
+#define MICROPY_INCLUDED_STM32_COMMON_HAL_ALARM_SLEEPMEMORY_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+} alarm_sleep_memory_obj_t;
+
+extern void alarm_sleep_memory_reset(void);
+
+#endif // MICROPY_INCLUDED_STM32_COMMON_HAL_ALARM_SLEEPMEMORY_H

ports/stm/common-hal/alarm/SleepMemory.h

@@ -0,0 +1,158 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Lucian Copeland for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/gc.h"
+#include "py/obj.h"
+#include "py/objtuple.h"
+#include "py/runtime.h"
+#include "lib/utils/interrupt_char.h"
+
+#include "shared-bindings/alarm/__init__.h"
+#include "shared-bindings/alarm/pin/PinAlarm.h"
+#include "shared-bindings/alarm/time/TimeAlarm.h"
+
+#include "shared-bindings/microcontroller/__init__.h"
+
+#include "supervisor/port.h"
+#include "supervisor/shared/workflow.h"
+
+#define STM_WAKEUP_GPIO     1
+#define STM_WAKEUP_TIMER    2
+
+void common_hal_alarm_reset(void) {
+    // alarm_sleep_memory_reset();
+    alarm_pin_pinalarm_reset();
+    // alarm_time_timealarm_reset();
+    // alarm_touch_touchalarm_reset();
+    // esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
+}
+
+STATIC uint8_t _get_wakeup_cause(void) {
+    if (alarm_pin_pinalarm_woke_us_up()) {
+        return STM_WAKEUP_GPIO;
+    }
+    if (alarm_time_timealarm_woke_us_up()) {
+        return STM_WAKEUP_TIMER;
+    }
+    return 0;
+}
+
+bool common_hal_alarm_woken_from_sleep(void) {
+    return _get_wakeup_cause() != 0;
+}
+
+STATIC mp_obj_t _get_wake_alarm(size_t n_alarms, const mp_obj_t *alarms) {
+    if (alarm_pin_pinalarm_woke_us_up()) {
+        return alarm_pin_pinalarm_get_wakeup_alarm(n_alarms, alarms);
+    }
+    // esp_sleep_wakeup_cause_t cause = _get_wakeup_cause();
+    // switch (cause) {
+    //     case ESP_SLEEP_WAKEUP_TIMER: {
+    //         return alarm_time_timealarm_get_wakeup_alarm(n_alarms, alarms);
+    //     }
+
+    //     case ESP_SLEEP_WAKEUP_GPIO:
+    //     case ESP_SLEEP_WAKEUP_EXT0:
+    //     case ESP_SLEEP_WAKEUP_EXT1: {
+    //         return alarm_pin_pinalarm_get_wakeup_alarm(n_alarms, alarms);
+    //     }
+
+    //     case ESP_SLEEP_WAKEUP_TOUCHPAD: {
+    //         return alarm_touch_touchalarm_get_wakeup_alarm(n_alarms, alarms);
+    //     }
+
+    //     case ESP_SLEEP_WAKEUP_UNDEFINED:
+    //     default:
+    //         // Not a deep sleep reset.
+    //         break;
+    // }
+    // return mp_const_none;
+    return mp_const_none;
+}
+
+mp_obj_t common_hal_alarm_get_wake_alarm(void) {
+    //return _get_wake_alarm(0, NULL);
+    return mp_const_none;
+}
+
+// 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_touch_touchalarm_set_alarm(deep_sleep, n_alarms, alarms);
+}
+
+STATIC void _idle_until_alarm(void) {
+    // Poll for alarms.
+    while (!mp_hal_is_interrupted()) {
+        RUN_BACKGROUND_TASKS;
+        // Allow ctrl-C interrupt.
+        if (common_hal_alarm_woken_from_sleep()) {
+            common_hal_alarm_save_wake_alarm();
+            return;
+        }
+        // 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()) {
+        _idle_until_alarm();
+    } else {
+        port_disable_tick();
+        HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
+        port_enable_tick();
+    }
+
+    mp_obj_t wake_alarm = _get_wake_alarm(n_alarms, alarms);
+    common_hal_alarm_reset();
+    return wake_alarm;
+}
+
+void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *alarms) {
+    _setup_sleep_alarms(true, n_alarms, alarms);
+}
+
+//#define NORETURN __attribute__((noreturn))
+void NORETURN common_hal_alarm_enter_deep_sleep(void) {
+    // alarm_pin_pinalarm_prepare_for_deep_sleep();
+    // alarm_touch_touchalarm_prepare_for_deep_sleep();
+    while(1);
+
+    // 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();
+}
+
+void common_hal_alarm_gc_collect(void) {
+    gc_collect_ptr(common_hal_alarm_get_wake_alarm());
+}