Add alarm.pin that wakes on pin level

Fixes #3787

Author: tannewt

main.c

@@ -260,10 +260,10 @@ STATIC void print_code_py_status_message(safe_mode_t safe_mode) {
 STATIC bool run_code_py(safe_mode_t safe_mode) {
     bool serial_connected_at_start = serial_connected();
     #if CIRCUITPY_AUTORELOAD_DELAY_MS > 0
-    if (serial_connected_at_start) {
-        serial_write("\n");
-        print_code_py_status_message(safe_mode);
-    }
+    serial_write("\n");
+    print_code_py_status_message(safe_mode);
+    print_safe_mode_message(safe_mode);
+    serial_write("\n");
     #endif
 
     pyexec_result_t result;
@@ -307,16 +307,14 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
         if (result.return_code & PYEXEC_FORCED_EXIT) {
             return reload_requested;
         }
-    }
-
-    // Program has finished running.
 
-    // Display a different completion message if the user has no USB attached (cannot save files)
-    if (!serial_connected_at_start) {
+        // Display a different completion message if the user has no USB attached (cannot save files)
         serial_write_compressed(translate("\nCode done running. Waiting for reload.\n"));
     }
 
-    bool serial_connected_before_animation = false;
+    // Program has finished running.
+
+    bool serial_connected_before_animation = serial_connected();
     #if CIRCUITPY_DISPLAYIO
     bool refreshed_epaper_display = false;
     #endif

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

@@ -42,16 +42,19 @@
 
 #include "esp_sleep.h"
 
+#include "components/soc/soc/esp32s2/include/soc/rtc_cntl_reg.h"
+#include "components/driver/include/driver/uart.h"
+
 // Singleton instance of SleepMemory.
 const alarm_sleep_memory_obj_t alarm_sleep_memory_obj = {
     .base = {
         .type = &alarm_sleep_memory_type,
     },
 };
 
-
 void alarm_reset(void) {
     alarm_time_timealarm_reset();
+    alarm_pin_pin_alarm_reset();
     alarm_sleep_memory_reset();
     esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_ALL);
 }
@@ -60,6 +63,9 @@ STATIC esp_sleep_wakeup_cause_t _get_wakeup_cause(void) {
     if (alarm_time_timealarm_woke_us_up()) {
         return ESP_SLEEP_WAKEUP_TIMER;
     }
+    if (alarm_pin_pin_alarm_woke_us_up()) {
+        return ESP_SLEEP_WAKEUP_GPIO;
+    }
 
     return esp_sleep_get_wakeup_cause();
 }
@@ -69,14 +75,16 @@ bool alarm_woken_from_sleep(void) {
 }
 
 STATIC mp_obj_t _get_wake_alarm(size_t n_alarms, const mp_obj_t *alarms) {
-    switch (_get_wakeup_cause()) {
+    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_EXT0: {
-            // TODO: implement pin alarm wake.
-            break;
+        case ESP_SLEEP_WAKEUP_GPIO:
+        case ESP_SLEEP_WAKEUP_EXT0:
+        case ESP_SLEEP_WAKEUP_EXT1: {
+            return alarm_pin_pin_alarm_get_wakeup_alarm(n_alarms, alarms);
         }
 
         case ESP_SLEEP_WAKEUP_TOUCHPAD:
@@ -98,24 +106,8 @@ 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) {
-    bool time_alarm_set = false;
-    alarm_time_time_alarm_obj_t *time_alarm = MP_OBJ_NULL;
-
-    for (size_t i = 0; i < n_alarms; i++) {
-        if (MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pin_alarm_type)) {
-            mp_raise_NotImplementedError(translate("PinAlarm not yet implemented"));
-        } else if (MP_OBJ_IS_TYPE(alarms[i], &alarm_time_time_alarm_type)) {
-            if (time_alarm_set) {
-                mp_raise_ValueError(translate("Only one alarm.time alarm can be set."));
-            }
-            time_alarm  = MP_OBJ_TO_PTR(alarms[i]);
-            time_alarm_set = true;
-        }
-    }
-
-    if (time_alarm_set) {
-        alarm_time_timealarm_set_alarm(time_alarm);
-    }
+    alarm_pin_pin_alarm_set_alarms(deep_sleep, n_alarms, alarms);
+    alarm_time_timealarm_set_alarms(deep_sleep, n_alarms, alarms);
 }
 
 STATIC void _idle_until_alarm(void) {
@@ -134,18 +126,24 @@ STATIC void _idle_until_alarm(void) {
 // Is it safe to do a light sleep? Check whether WiFi is on or there are
 // other ongoing tasks that should not be shut down.
 STATIC bool _light_sleep_ok(void) {
-    return !common_hal_wifi_radio_get_enabled(&common_hal_wifi_radio_obj) && !supervisor_workflow_active();
+    int64_t connecting_delay_ticks = CIRCUITPY_USB_CONNECTED_SLEEP_DELAY * 1024 - port_get_raw_ticks(NULL);
+    return !common_hal_wifi_radio_get_enabled(&common_hal_wifi_radio_obj) &&
+           !supervisor_workflow_active() &&
+           connecting_delay_ticks <= 0;
 }
 
 mp_obj_t common_hal_alarm_light_sleep_until_alarms(size_t n_alarms, const mp_obj_t *alarms) {
     _setup_sleep_alarms(false, n_alarms, alarms);
 
     // Light sleep can break some functionality so only do it when possible. Otherwise we idle.
     if (_light_sleep_ok()) {
+        // Flush the UART to complete the log line.
+        uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM);
         esp_light_sleep_start();
     } else {
         _idle_until_alarm();
     }
+
     mp_obj_t wake_alarm = _get_wake_alarm(n_alarms, alarms);
     alarm_reset();
     return wake_alarm;
@@ -156,6 +154,7 @@ void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *ala
 }
 
 void NORETURN alarm_enter_deep_sleep(void) {
+    alarm_pin_pin_alarm_prepare_for_deep_sleep();
     // 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();