wip

Author: dhalbert

main.c

@@ -132,7 +132,7 @@ static void reset_devices(void) {
     #endif
 }
 
-STATIC void start_mp(supervisor_allocation *heap, bool first_run) {
+STATIC void start_mp(supervisor_allocation *heap) {
     supervisor_workflow_reset();
 
     // Stack limit should be less than real stack size, so we have a chance
@@ -176,14 +176,6 @@ STATIC void start_mp(supervisor_allocation *heap, bool first_run) {
     mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
 
     mp_obj_list_init((mp_obj_list_t *)mp_sys_argv, 0);
-
-    #if CIRCUITPY_ALARM
-    // Record which alarm woke us up, if any. An object may be created so the heap must be functional.
-    // There is no alarm if this is not the first time code.py or the REPL has been run.
-    shared_alarm_save_wake_alarm(first_run ? common_hal_alarm_create_wake_alarm() : mp_const_none);
-    // Reset alarm module only after we retrieved the wakeup alarm.
-    alarm_reset();
-    #endif
 }
 
 STATIC void stop_mp(void) {
@@ -373,7 +365,7 @@ STATIC void print_code_py_status_message(safe_mode_t safe_mode) {
     }
 }
 
-STATIC bool run_code_py(safe_mode_t safe_mode, bool first_run, bool *simulate_reset) {
+STATIC bool run_code_py(safe_mode_t safe_mode, bool *simulate_reset) {
     bool serial_connected_at_start = serial_connected();
     bool printed_safe_mode_message = false;
     #if CIRCUITPY_AUTORELOAD_DELAY_MS > 0
@@ -409,8 +401,8 @@ STATIC bool run_code_py(safe_mode_t safe_mode, bool first_run, bool *simulate_re
 
         supervisor_allocation *heap = allocate_remaining_memory();
 
-        // Prepare the VM state. Includes an alarm check/reset for sleep.
-        start_mp(heap, first_run);
+        // Prepare the VM state.
+        start_mp(heap);
 
         #if CIRCUITPY_USB
         usb_setup_with_vm();
@@ -853,12 +845,12 @@ STATIC void __attribute__ ((noinline)) run_boot_py(safe_mode_t safe_mode) {
     #endif
 }
 
-STATIC int run_repl(bool first_run) {
+STATIC int run_repl(void) {
     int exit_code = PYEXEC_FORCED_EXIT;
     stack_resize();
     filesystem_flush();
     supervisor_allocation *heap = allocate_remaining_memory();
-    start_mp(heap, first_run);
+    start_mp(heap);
 
     #if CIRCUITPY_USB
     usb_setup_with_vm();
@@ -968,6 +960,12 @@ int __attribute__((used)) main(void) {
         safe_mode = NO_CIRCUITPY;
     }
 
+    #if CIRCUITPY_ALARM
+    // Record which alarm woke us up, if any.
+    // common_hal_alarm_record_wake_alarm() should return a static, non-heap object
+    shared_alarm_save_wake_alarm(common_hal_alarm_record_wake_alarm());
+    #endif
+
     // Reset everything and prep MicroPython to run boot.py.
     reset_port();
     // Port-independent devices, like CIRCUITPY_BLEIO_HCI.
@@ -1001,20 +999,18 @@ int __attribute__((used)) main(void) {
     // Boot script is finished, so now go into REPL or run code.py.
     int exit_code = PYEXEC_FORCED_EXIT;
     bool skip_repl = true;
-    bool first_run = true;
-    bool simulate_reset;
+    bool simulate_reset = true;
     for (;;) {
-        simulate_reset = false;
         if (!skip_repl) {
-            exit_code = run_repl(first_run);
+            exit_code = run_repl();
             supervisor_set_run_reason(RUN_REASON_REPL_RELOAD);
         }
         if (exit_code == PYEXEC_FORCED_EXIT) {
-            if (!first_run) {
+            if (!simulate_reset) {
                 serial_write_compressed(translate("soft reboot\n"));
             }
             if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
-                skip_repl = run_code_py(safe_mode, first_run, &simulate_reset);
+                skip_repl = run_code_py(safe_mode, &simulate_reset);
             } else {
                 skip_repl = false;
             }
@@ -1025,7 +1021,11 @@ int __attribute__((used)) main(void) {
         // Either the REPL or code.py has run and finished.
         // If code.py did a fake deep sleep, pretend that we are running code.py for
         // the first time after a hard reset. This will preserve any alarm information.
-        first_run = simulate_reset;
+        if (!simulate_reset) {
+            #if CIRCUITPY_ALARM
+            shared_alarm_save_wake_alarm(mp_const_none);
+            #endif
+        }
     }
     mp_deinit();
     return 0;

ports/atmel-samd/common-hal/alarm/__init__.c

@@ -48,6 +48,13 @@ const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
     },
 };
 
+// Static alarm object recording alarm (if any) that woke up CircuitPython after light or deep sleep.
+// This object lives across VM instantiations, so none of these objects can contain references to the heap.
+static union {
+    alarm_pin_pinalarm_obj_t pin_alarm;
+    alarm_time_timealarm_obj_t time_alarm;
+} wake_alarm;
+
 void alarm_reset(void) {
     // Reset the alarm flag
     alarm_pin_pinalarm_reset();
@@ -57,7 +64,7 @@ void alarm_reset(void) {
 void alarm_get_wakeup_cause(void) {
     // Called from rtc_init, just before SWRST of RTC.  It is called
     // at an early stage of main(), to save TAMPID from SWRST.  Later,
-    // common_hal_alarm_create_wake_alarm is called to make a wakeup
+    // common_hal_alarm_record_wake_alarm is called to make a wakeup
     // alarm from the deep sleep.
 
     TAMPID = RTC->MODE0.TAMPID.reg;
@@ -67,7 +74,7 @@ bool common_hal_alarm_woken_from_sleep(void) {
     return alarm_pin_pinalarm_woke_this_cycle() || alarm_time_timealarm_woke_this_cycle();
 }
 
-mp_obj_t common_hal_alarm_create_wake_alarm(void) {
+mp_obj_t common_hal_alarm_record_wake_alarm(void) {
     // Called from main.c on the first start up, just before alarm_reset.
     // Return a copy of wakeup alarm from deep sleep / fake deep sleep.
     // In case of fake sleep, status should be left in TimeAlarm/PinAlarm.
@@ -76,13 +83,13 @@ mp_obj_t common_hal_alarm_create_wake_alarm(void) {
     if (alarm_pin_pinalarm_woke_this_cycle()) {
         TAMPID = RTC->MODE0.TAMPID.reg;
         RTC->MODE0.TAMPID.reg = TAMPID;         // clear register
-        return alarm_pin_pinalarm_create_wakeup_alarm(TAMPID);
+        return alarm_pin_pinalarm_record_wakeup_alarm(&wake_alarm.pin_alarm, TAMPID);
     }
     if (alarm_time_timealarm_woke_this_cycle() || (true_deep && TAMPID == 0)) {
-        return alarm_time_timealarm_create_wakeup_alarm();
+        return alarm_time_timealarm_record_wakeup_alarm(&wake_alarm.time_alarm);
     }
     if (true_deep) {
-        return alarm_pin_pinalarm_create_wakeup_alarm(TAMPID);
+        return alarm_pin_pinalarm_record_wakeup_alarm(&wake_alarm.pin_alarm, TAMPID);
     }
     return mp_const_none;
 }

ports/atmel-samd/common-hal/alarm/pin/PinAlarm.c

@@ -128,12 +128,11 @@ mp_obj_t alarm_pin_pinalarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t
     return mp_const_none;
 }
 
-mp_obj_t alarm_pin_pinalarm_create_wakeup_alarm(uint32_t TAMPID) {
+mp_obj_t alarm_pin_pinalarm_record_wakeup_alarm(alarm_pin_pinalarm_obj_t *alarm, uint32_t TAMPID) {
     // Create tamper alarm that caused wakeup from deep sleep
 
     for (samd_tamper_pin_t *t = TAMPER_PINS; t->n >= 0; t++) {
         if (TAMPID & (1 << t->n)) {
-            alarm_pin_pinalarm_obj_t *alarm = m_new_obj(alarm_pin_pinalarm_obj_t);
             alarm->base.type = &alarm_pin_pinalarm_type;
             alarm->pin = t->pin;
             return alarm;

ports/atmel-samd/common-hal/alarm/pin/PinAlarm.h

@@ -39,7 +39,7 @@ typedef struct {
 } alarm_pin_pinalarm_obj_t;
 
 mp_obj_t alarm_pin_pinalarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t *alarms);
-mp_obj_t alarm_pin_pinalarm_create_wakeup_alarm(uint32_t TAMPID);
+mp_obj_t alarm_pin_pinalarm_record_wakeup_alarm(alarm_pin_pinalarm_obj_t *alarm, uint32_t TAMPID);
 
 void pin_alarm_callback(uint8_t num);
 void alarm_pin_pinalarm_reset(void);

ports/atmel-samd/common-hal/alarm/time/TimeAlarm.c

@@ -58,13 +58,12 @@ mp_obj_t alarm_time_timealarm_find_triggered_alarm(size_t n_alarms, const mp_obj
     return mp_const_none;
 }
 
-mp_obj_t alarm_time_timealarm_create_wakeup_alarm(void) {
-    alarm_time_timealarm_obj_t *timer = m_new_obj(alarm_time_timealarm_obj_t);
-    timer->base.type = &alarm_time_timealarm_type;
+mp_obj_t alarm_time_timealarm_record_wakeup_alarm(alarm_time_timealarm_obj_t *alarm) {
+    alarm->base.type = &alarm_time_timealarm_type;
     // TODO: Set monotonic_time based on the RTC state.
     //       Or don't, most of the other ports don't have this either.
-    timer->monotonic_time = 0.0f;
-    return timer;
+    alarm->monotonic_time = 0.0f;
+    return alarm;
 }
 
 void time_alarm_callback(void) {

ports/atmel-samd/common-hal/alarm/time/TimeAlarm.h

@@ -35,7 +35,7 @@ typedef struct {
 } alarm_time_timealarm_obj_t;
 
 mp_obj_t alarm_time_timealarm_find_triggered_alarm(size_t n_alarms, const mp_obj_t *alarms);
-mp_obj_t alarm_time_timealarm_create_wakeup_alarm(void);
+mp_obj_t alarm_time_timealarm_record_wakeup_alarm(alarm_time_timealarm_obj_t *alarm);
 void time_alarm_callback(void);
 bool alarm_time_timealarm_woke_this_cycle(void);
 void alarm_time_timealarm_set_alarms(bool deep_sleep, size_t n_alarms, const mp_obj_t *alarms);

ports/atmel-samd/supervisor/port.c

@@ -385,6 +385,10 @@ safe_mode_t port_init(void) {
 }
 
 void reset_port(void) {
+    #if CIRCUITPY_ALARM
+    alarm_reset();
+    #endif
+
     #if CIRCUITPY_BUSIO
     reset_sercoms();
     #endif

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

@@ -58,6 +58,15 @@ const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
     },
 };
 
+// Static alarm object recording alarm (if any) that woke up CircuitPython after light or deep sleep.
+// This object lives across VM instantiations, so none of these objects can contain references to the heap.
+static union {
+    alarm_pin_pinalarm_obj_t pin_alarm;
+    alarm_time_timealarm_obj_t time_alarm;
+    alarm_touch_touchalarm_obj_t touch_alarm;
+    alarm_coproc_coprocalarm_obj_t coproc_alarm;
+} wake_alarm;
+
 void alarm_reset(void) {
     alarm_sleep_memory_reset();
     alarm_pin_pinalarm_reset();
@@ -90,27 +99,27 @@ bool common_hal_alarm_woken_from_sleep(void) {
     return _get_wakeup_cause() != ESP_SLEEP_WAKEUP_UNDEFINED;
 }
 
-mp_obj_t common_hal_alarm_create_wake_alarm(void) {
+mp_obj_t common_hal_alarm_record_wake_alarm(void) {
     // If woken from deep sleep, create a copy alarm similar to what would have
     // been passed in originally. Otherwise, just return none
     esp_sleep_wakeup_cause_t cause = _get_wakeup_cause();
     switch (cause) {
         case ESP_SLEEP_WAKEUP_TIMER: {
-            return alarm_time_timealarm_create_wakeup_alarm();
+            return alarm_time_timealarm_record_wakeup_alarm(&wake_alarm.time_alarm);
         }
 
         case ESP_SLEEP_WAKEUP_GPIO:
         case ESP_SLEEP_WAKEUP_EXT0:
         case ESP_SLEEP_WAKEUP_EXT1: {
-            return alarm_pin_pinalarm_create_wakeup_alarm();
+            return alarm_pin_pinalarm_record_wakeup_alarm(&wake_alarm.pin_alarm);
         }
 
         case ESP_SLEEP_WAKEUP_TOUCHPAD: {
-            return alarm_touch_touchalarm_create_wakeup_alarm();
+            return alarm_touch_touchalarm_record_wakeup_alarm(&wake_alarm.touch_alarm);
         }
 
         case ESP_SLEEP_WAKEUP_ULP: {
-            return alarm_coproc_coprocalarm_create_wakeup_alarm();
+            return alarm_coproc_coprocalarm_record_wakeup_alarm(&wake_alarm.coproc_alarm);
         }
 
         case ESP_SLEEP_WAKEUP_UNDEFINED:

ports/espressif/common-hal/alarm/coproc/CoprocAlarm.c

@@ -47,9 +47,7 @@ mp_obj_t alarm_coproc_coprocalarm_find_triggered_alarm(const size_t n_alarms, co
     return mp_const_none;
 }
 
-mp_obj_t alarm_coproc_coprocalarm_create_wakeup_alarm(void) {
-    // Create CoprocAlarm object.
-    alarm_coproc_coprocalarm_obj_t *alarm = m_new_obj(alarm_coproc_coprocalarm_obj_t);
+mp_obj_t alarm_coproc_coprocalarm_record_wakeup_alarm(alarm_coproc_coprocalarm_obj_t *alarm) {
     alarm->base.type = &alarm_coproc_coprocalarm_type;
     return alarm;
 }
@@ -111,7 +109,7 @@ mp_obj_t alarm_coproc_coprocalarm_find_triggered_alarm(const size_t n_alarms, co
     return mp_const_none;
 }
 
-mp_obj_t alarm_coproc_coprocalarm_create_wakeup_alarm(void) {
+mp_obj_t alarm_coproc_coprocalarm_record_wakeup_alarm(void) {
     return mp_const_none;
 }
 

ports/espressif/common-hal/alarm/coproc/CoprocAlarm.h

@@ -38,7 +38,7 @@ typedef struct {
 } alarm_coproc_coprocalarm_obj_t;
 
 mp_obj_t alarm_coproc_coprocalarm_find_triggered_alarm(const size_t n_alarms, const mp_obj_t *alarms);
-mp_obj_t alarm_coproc_coprocalarm_create_wakeup_alarm(void);
+mp_obj_t alarm_coproc_coprocalarm_record_wakeup_alarm(void);
 
 void alarm_coproc_coprocalarm_prepare_for_deep_sleep(void);
 void alarm_coproc_coprocalarm_reset(void);