merge from upstream + wip

adafruit · jepler · Dec 3, 2020 · Oct 25, 2020 · Oct 25, 2020 · Oct 26, 2020
commit ef0830bfe241b544b05bd3081f5bba03af57fe0d
diff --git a/locale/circuitpython.pot b/locale/circuitpython.pot
@@ -8,7 +8,11 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
+<<<<<<< HEAD
 "POT-Creation-Date: 2020-11-25 15:08-0500\n"
+=======
+"POT-Creation-Date: 2020-11-11 16:30+0530\n"
+>>>>>>> adafruit/main
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[email protected]>\n"

diff --git a/main.c b/main.c
@@ -66,6 +66,7 @@
 
 #include "boards/board.h"
 
+// REMOVE ***********
 #include "esp_log.h"
 
 #if CIRCUITPY_ALARM
@@ -97,8 +98,8 @@
 #include "common-hal/canio/CAN.h"
 #endif
 
-// How long to wait for host to enumerate (secs).
-#define CIRCUITPY_USB_ENUMERATION_DELAY 5
+// How long to wait for host to start connecting..
+#define CIRCUITPY_USB_CONNECTING_DELAY 1
 
 // How long to flash errors on the RGB status LED before going to sleep (secs)
 #define CIRCUITPY_FLASH_ERROR_PERIOD 10
@@ -258,6 +259,17 @@ STATIC void print_code_py_status_message(safe_mode_t safe_mode) {
     }
 }
 
+// Should we go into deep sleep when program finishes?
+// Normally we won't deep sleep if there was an error or if we are connected to a host
+// but either of those can be enabled.
+// It's ok to deep sleep if we're not connected to a host, but we need to make sure
+// we're giving enough time for USB to start to connect
+STATIC bool deep_sleep_allowed(void) {
+    return
+        (ok || supervisor_workflow_get_allow_deep_sleep_on_error()) &&
+        !supervisor_workflow_connecting()
+        (supervisor_ticks_ms64() > CIRCUITPY_USB_CONNECTING_DELAY * 1024);
+
 STATIC bool run_code_py(safe_mode_t safe_mode) {
     bool serial_connected_at_start = serial_connected();
     #if CIRCUITPY_AUTORELOAD_DELAY_MS > 0
@@ -307,7 +319,7 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
     // Program has finished running.
 
     // Display a different completion message if the user has no USB attached (cannot save files)
-    if (!serial_connected_at_start) {
+    if (!serial_connected_at_start && !deep_sleep_allowed()) {
         serial_write_compressed(translate("\nCode done running. Waiting for reload.\n"));
     }
 
@@ -318,32 +330,16 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
     rgb_status_animation_t animation;
     bool ok = result.return_code != PYEXEC_EXCEPTION;
 
-    ESP_LOGI("main", "common_hal_alarm_enable_deep_sleep_alarms()");
     #if CIRCUITPY_ALARM
     // Enable pin or time alarms before sleeping.
-    // If immediate_wake is true, then there's alarm that would trigger immediately,
+    // If immediate_wake is true, then there's an alarm that would trigger immediately,
     // so don't sleep.
     bool immediate_wake = !common_hal_alarm_enable_deep_sleep_alarms();
     #endif
 
-
     prep_rgb_status_animation(&result, found_main, safe_mode, &animation);
     while (true) {
-        // Normally we won't deep sleep if there was an error or if we are connected to a host
-        // but either of those can be enabled.
-        // It's ok to deep sleep if we're not connected to a host, but we need to make sure
-        // we're giving enough time for USB enumeration to happen.
-        bool deep_sleep_allowed =
-            !immediate_wake &&
-            (ok || supervisor_workflow_get_allow_deep_sleep_on_error()) &&
-            (!supervisor_workflow_active() || supervisor_workflow_get_allow_deep_sleep_when_connected()) &&
-            (supervisor_ticks_ms64() > CIRCUITPY_USB_ENUMERATION_DELAY * 1024);
-
-        ESP_LOGI("main", "ok %d", deep_sleep_allowed);
-        ESP_LOGI("main", "...on_error() %d", supervisor_workflow_get_allow_deep_sleep_on_error());
-        ESP_LOGI("main", "supervisor_workflow_active() %d", supervisor_workflow_active());
-        ESP_LOGI("main", "...when_connected() %d", supervisor_workflow_get_allow_deep_sleep_when_connected());
-        ESP_LOGI("main", "supervisor_ticks_ms64() %lld", supervisor_ticks_ms64());
+
         RUN_BACKGROUND_TASKS;
         if (reload_requested) {
             supervisor_set_run_reason(RUN_REASON_AUTO_RELOAD);
@@ -365,7 +361,7 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
                 print_code_py_status_message(safe_mode);
             }
             // We won't be going into the REPL if we're going to sleep.
-            if (!deep_sleep_allowed) {
+            if (!deep_sleep_allowed()) {
                 print_safe_mode_message(safe_mode);
                 serial_write("\n");
                 serial_write_compressed(translate("Press any key to enter the REPL. Use CTRL-D to reload."));
@@ -385,15 +381,19 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
 
         bool animation_done = false;
 
-        if (deep_sleep_allowed && ok) {
+        if (deep_sleep_allowed() && ok) {
             // Skip animation if everything is OK.
             animation_done = true;
         } else {
             animation_done = tick_rgb_status_animation(&animation);
         }
         // Do an error animation only once before deep-sleeping.
         if (animation_done) {
-            if (deep_sleep_allowed) {
+            if (immediate_wake) {
+                // Don't sleep, we are already supposed to wake up.
+                return true;
+            }
+            if (deep_sleep_allowed()) {
                 common_hal_mcu_deep_sleep();
                 // Does not return.
             }
@@ -402,10 +402,10 @@ STATIC bool run_code_py(safe_mode_t safe_mode) {
             if (!ok) {
                 port_interrupt_after_ticks(CIRCUITPY_FLASH_ERROR_PERIOD * 1024);
             } else {
-                int64_t remaining_enumeration_wait =
-                    CIRCUITPY_USB_ENUMERATION_DELAY * 1024 - supervisor_ticks_ms64();
-                if (remaining_enumeration_wait > 0) {
-                    port_interrupt_after_ticks(remaining_enumeration_wait);
+                int64_t remaining_connecting_wait =
+                    CIRCUITPY_USB_CONNECTING_DELAY * 1024 - supervisor_ticks_ms64();
+                if (remaining_connecting_wait > 0) {
+                    port_interrupt_after_ticks(remaining_connecting_wait);
                 }
                 port_sleep_until_interrupt();
             }

diff --git a/ports/esp32s2/common-hal/alarm/__init__.c b/ports/esp32s2/common-hal/alarm/__init__.c
@@ -31,10 +31,11 @@
 
 #include "shared-bindings/alarm/__init__.h"
 #include "shared-bindings/alarm/pin/PinAlarm.h"
-#include "shared-bindings/alarm/time/MonotonicTimeAlarm.h"
+#include "shared-bindings/alarm/time/TimeAlarm.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/time/__init__.h"
 
+#include "esp_log.h"
 #include "esp_sleep.h"
 
 STATIC mp_obj_tuple_t *_deep_sleep_alarms;
@@ -51,8 +52,8 @@ mp_obj_t common_hal_alarm_get_wake_alarm(void) {
     switch (esp_sleep_get_wakeup_cause()) {
         case ESP_SLEEP_WAKEUP_TIMER: {
             // Wake up from timer.
-            alarm_time_monotonic_time_alarm_obj_t *timer = m_new_obj(alarm_time_monotonic_time_alarm_obj_t);
-            timer->base.type = &alarm_time_monotonic_time_alarm_type;
+            alarm_time_time_alarm_obj_t *timer = m_new_obj(alarm_time_time_alarm_obj_t);
+            timer->base.type = &alarm_time_time_alarm_type;
             return timer;
         }
 
@@ -86,7 +87,7 @@ void common_hal_alarm_set_deep_sleep_alarms(size_t n_alarms, const mp_obj_t *ala
         if (MP_OBJ_IS_TYPE(alarms[i], &alarm_pin_pin_alarm_type)) {
             mp_raise_NotImplementedError(translate("PinAlarm deep sleep not yet implemented"));
         }
-        else if (MP_OBJ_IS_TYPE(alarms[i], &alarm_time_monotonic_time_alarm_type)) {
+        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."));
             }
@@ -106,15 +107,15 @@ bool common_hal_alarm_enable_deep_sleep_alarms(void) {
             // TODO: handle pin alarms
             mp_raise_NotImplementedError(translate("PinAlarm deep sleep not yet implemented"));
         }
-        else if (MP_OBJ_IS_TYPE(alarm, &alarm_time_monotonic_time_alarm_type)) {
-            alarm_time_monotonic_time_alarm_obj_t *monotonic_time_alarm = MP_OBJ_TO_PTR(alarm);
-            mp_float_t now = uint64_to_float(common_hal_time_monotonic());
-            // Compute a relative time in the future from now.
-            mp_float_t duration_secs = now - monotonic_time_alarm->monotonic_time;
-            if (duration_secs <= 0.0f) {
+        else if (MP_OBJ_IS_TYPE(alarm, &alarm_time_time_alarm_type)) {
+            alarm_time_time_alarm_obj_t *time_alarm = MP_OBJ_TO_PTR(alarm);
+            mp_float_t now_secs = uint64_to_float(common_hal_time_monotonic_ms()) / 1000.0f;
+            // Compute how long to actually sleep, considering hte time now.
+            mp_float_t wakeup_in_secs = time_alarm->monotonic_time - now_secs;
+            if (wakeup_in_secs <= 0.0f) {
                 return false;
             }
-            esp_sleep_enable_timer_wakeup((uint64_t) (duration_secs * 1000000));
+            esp_sleep_enable_timer_wakeup((uint64_t) (wakeup_in_secs * 1000000));
         }
     }
     return true;

diff --git a/...ommon-hal/alarm/time/MonotonicTimeAlarm.c → ...esp32s2/common-hal/alarm/time/TimeAlarm.c b/...ommon-hal/alarm/time/MonotonicTimeAlarm.c → ...esp32s2/common-hal/alarm/time/TimeAlarm.c
@@ -28,12 +28,12 @@
 
 #include "py/runtime.h"
 
-#include "shared-bindings/alarm/time/MonotonicTimeAlarm.h"
+#include "shared-bindings/alarm/time/TimeAlarm.h"
 
-void common_hal_alarm_time_monotonic_time_alarm_construct(alarm_time_monotonic_time_alarm_obj_t *self, mp_float_t monotonic_time) {
+void common_hal_alarm_time_time_alarm_construct(alarm_time_time_alarm_obj_t *self, mp_float_t monotonic_time) {
     self->monotonic_time = monotonic_time;
 }
 
-mp_float_t common_hal_alarm_time_monotonic_time_alarm_get_monotonic_time(alarm_time_monotonic_time_alarm_obj_t *self) {
+mp_float_t common_hal_alarm_time_time_alarm_get_monotonic_time(alarm_time_time_alarm_obj_t *self) {
     return self->monotonic_time;
 }
diff --git a/...ommon-hal/alarm/time/MonotonicTimeAlarm.h → ...esp32s2/common-hal/alarm/time/TimeAlarm.h b/...ommon-hal/alarm/time/MonotonicTimeAlarm.h → ...esp32s2/common-hal/alarm/time/TimeAlarm.h
@@ -30,4 +30,4 @@
 typedef struct {
     mp_obj_base_t base;
     mp_float_t monotonic_time;      // values compatible with time.monotonic_time()
-} alarm_time_monotonic_time_alarm_obj_t;
+} alarm_time_time_alarm_obj_t;
diff --git a/ports/esp32s2/common-hal/time/__init__.c b/ports/esp32s2/common-hal/time/__init__.c
@@ -28,7 +28,7 @@
 
 #include "tick.h"
 
-uint64_t common_hal_time_monotonic(void) {
+uint64_t common_hal_time_monotonic_ms(void) {
     return supervisor_ticks_ms64();
 }
 

diff --git a/ports/esp32s2/mpconfigport.mk b/ports/esp32s2/mpconfigport.mk
@@ -22,8 +22,7 @@ CIRCUITPY_COUNTIO = 1
 CIRCUITPY_FREQUENCYIO = 1
 CIRCUITPY_I2CPERIPHERAL = 0
 CIRCUITPY_ROTARYIO = 1
-CIRCUITPY_NVM = 0
-
+CIRCUITPY_NVM = 1
 # We don't have enough endpoints to include MIDI.
 CIRCUITPY_USB_MIDI = 0
 CIRCUITPY_WIFI = 1

diff --git a/ports/litex/common-hal/time/__init__.c b/ports/litex/common-hal/time/__init__.c
@@ -28,7 +28,7 @@
 
 #include "tick.h"
 
-uint64_t common_hal_time_monotonic(void) {
+uint64_t common_hal_time_monotonic_ms(void) {
     return supervisor_ticks_ms64();
 }
 

diff --git a/py/circuitpy_defns.mk b/py/circuitpy_defns.mk
@@ -303,7 +303,7 @@ SRC_COMMON_HAL_ALL = \
 	_pew/__init__.c \
 	alarm/__init__.c \
 	alarm/pin/PinAlarm.c \
-	alarm/time/MonotonicTimeAlarm.c \
+	alarm/time/TimeAlarm.c \
 	analogio/AnalogIn.c \
 	analogio/AnalogOut.c \
 	analogio/__init__.c \

diff --git a/shared-bindings/alarm/__init__.c b/shared-bindings/alarm/__init__.c
@@ -29,7 +29,7 @@
 
 #include "shared-bindings/alarm/__init__.h"
 #include "shared-bindings/alarm/pin/PinAlarm.h"
-#include "shared-bindings/alarm/time/MonotonicTimeAlarm.h"
+#include "shared-bindings/alarm/time/TimeAlarm.h"
 
 //| """Power-saving light and deep sleep. Alarms can be set to wake up from sleep.
 //|
@@ -42,12 +42,9 @@
 //| peripherals, such as I2C, are left on.
 //|
 //| Deep sleep shuts down power to nearly all of the chip including the CPU and RAM. This can save
-//| a more significant amount of power, but CircuitPython must start ``code.py`` from the beginning when woken
-//| up. If the board is not actively connected to a host computer (usually via USB),
-//| CircuitPython will enter deep sleep automatically when the current program finishes its last statement
-//| or calls ``sys.exit()``.
-//| If the board is connected, the board will not enter deep sleep unless `supervisor.exit_and_deep_sleep()`
-//| is called explicitly.
+//| a more significant amount of power, but CircuitPython must start ``code.py`` from the beginning when
+//| awakened.
+
 //|
 //| An error includes an uncaught exception, or sys.exit() called with a non-zero argument
 //|
@@ -60,16 +57,16 @@
 void validate_objs_are_alarms(size_t n_args, const mp_obj_t *objs) {
     for (size_t i = 0; i < n_args; i++) {
         if (MP_OBJ_IS_TYPE(objs[i], &alarm_pin_pin_alarm_type) ||
-            MP_OBJ_IS_TYPE(objs[i], &alarm_time_monotonic_time_alarm_type)) {
+            MP_OBJ_IS_TYPE(objs[i], &alarm_time_time_alarm_type)) {
             continue;
         }
         mp_raise_TypeError_varg(translate("Expected an alarm"));
     }
 }
 
 //| def sleep_until_alarms(*alarms: Alarm) -> Alarm:
-//|     """Performs a light sleep until woken by one of the alarms. The alarm caused the wake-up
-//|        is returned, and is also available as `alarm.wake_alarm`
+//|     """Go into a light sleep until awakened one of the alarms. The alarm causing the wake-up
+//|        is returned, and is also available as `alarm.wake_alarm`.
 //|     """
 //|     ...
 //|
@@ -80,26 +77,26 @@ STATIC mp_obj_t alarm_sleep_until_alarms(size_t n_args, const mp_obj_t *args) {
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(alarm_sleep_until_alarms_obj, 1, MP_OBJ_FUN_ARGS_MAX, alarm_sleep_until_alarms);
 
-//| def set_deep_sleep_alarms(*alarms: Alarm) -> None:
-//|     """Set one or more alarms to wake up from a deep sleep.
+//| def exit_and_deep_sleep_until_alarms(*alarms: Alarm) -> None:
+//|     """Exit the program and go into a deep sleep, until awakened by one of the alarms.
 //|
-//|     When awakened, the microcontroller will restart and run ``boot.py`` and ``code.py``
+//|     When awakened, the microcontroller will restart and will run ``boot.py`` and ``code.py``
 //|     from the beginning.
 //|
 //|     An alarm equivalent to the one that caused the wake-up is available as `alarm.wake_alarm`.
 //|     Its type and/or attributes may not correspond exactly to the original alarm.
-//|     For time-base alarms, currently, an `alarm.time.MonotonicTimeAlarm()` is created.
+//|     For time-base alarms, currently, an `alarm.time.TimeAlarm()` is created.
 //|
-//|     If you call this routine more than once, only the last set of alarms given will be used.
+//|     If no alarms are specified, the microcontroller will deep sleep until reset.
 //|     """
 //|     ...
 //|
-STATIC mp_obj_t alarm_set_deep_sleep_alarms(size_t n_args, const mp_obj_t *args) {
+STATIC mp_obj_t alarm_exit_and_deep_sleep_until_alarms(size_t n_args, const mp_obj_t *args) {
     validate_objs_are_alarms(n_args, args);
-    common_hal_alarm_set_deep_sleep_alarms(n_args, args);
+    common_hal_exit_and_deep_sleep_until_alarms(n_args, args);
     return mp_const_none;
 }
-MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(alarm_set_deep_sleep_alarms_obj, 1, MP_OBJ_FUN_ARGS_MAX, alarm_set_deep_sleep_alarms);
+MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(alarm_exit_and_deep_sleep_until_alarms_obj, 1, MP_OBJ_FUN_ARGS_MAX, alarm_exit_and_deep_sleep_until_alarms);
 
 //| """The `alarm.pin` module contains alarm attributes and classes related to pins.
 //| """
@@ -123,7 +120,7 @@ STATIC const mp_obj_module_t alarm_pin_module = {
 STATIC const mp_map_elem_t alarm_time_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_time) },
 
-    { MP_ROM_QSTR(MP_QSTR_MonotonicTimeAlarm), MP_OBJ_FROM_PTR(&alarm_time_monotonic_time_alarm_type) },
+    { MP_ROM_QSTR(MP_QSTR_TimeAlarm), MP_OBJ_FROM_PTR(&alarm_time_time_alarm_type) },
 };
 
 STATIC MP_DEFINE_CONST_DICT(alarm_time_globals, alarm_time_globals_table);
@@ -140,7 +137,8 @@ STATIC mp_map_elem_t alarm_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_wake_alarm), mp_const_none },
 
     { MP_ROM_QSTR(MP_QSTR_sleep_until_alarms), MP_OBJ_FROM_PTR(&alarm_sleep_until_alarms_obj) },
-    { MP_ROM_QSTR(MP_QSTR_set_deep_sleep_alarms), MP_OBJ_FROM_PTR(&alarm_set_deep_sleep_alarms_obj) },
+    { MP_ROM_QSTR(MP_QSTR_exit_and_deep_sleep_until_alarms),
+                                               MP_OBJ_FROM_PTR(&alarm_exit_and_deep_sleep_until_alarms_obj) },
 
     { MP_ROM_QSTR(MP_QSTR_pin), MP_OBJ_FROM_PTR(&alarm_pin_module) },
     { MP_ROM_QSTR(MP_QSTR_time), MP_OBJ_FROM_PTR(&alarm_time_module) }