movement: Use LE mode code to keep buzzer awake, instead of sleeping.

diff --git a/movement/movement.c b/movement/movement.c
index 0e40d46282531ac7f9355c4b1a23ea7a94f9358a..2f4bec7f148a919cd9fdb35c6dfe0a091615d191 100644 (file)
--- a/movement/movement.c
+++ b/movement/movement.c
@@ -293,31 +293,31 @@ void movement_request_wake() {
     _movement_reset_inactivity_countdown();
 }
 
+void end_buzzing() {
+    movement_state.is_buzzing = false;
+}
+
+void end_buzzing_and_disable_buzzer(void) {
+    end_buzzing();
+    watch_disable_buzzer();
+}
+
 void movement_play_signal(void) {
-    watch_enable_buzzer();
-    watch_buzzer_play_sequence(signal_tune, watch_disable_buzzer);
+    void *maybe_disable_buzzer = end_buzzing_and_disable_buzzer;
+    if (watch_is_buzzer_or_led_enabled()) {
+        maybe_disable_buzzer = end_buzzing;
+    } else {
+        watch_enable_buzzer();
+    }
+    movement_state.is_buzzing = true;
+    watch_buzzer_play_sequence(signal_tune, maybe_disable_buzzer);
     if (movement_state.le_mode_ticks == -1) {
-       // This is somewhat of a hack. In order to play a sequence, we need to
-       // be awake. We should ideally be able to tell movement that we need to
-       // be awake for a given amount of time, but there's no good way to do
-       // this, so we block instead. This might be bad in the case that a
-       // watch face has housekeeping to do after calling this, since it could
-       // in theory do that housekeeping concurrently, but alas.
-       //
-       // You might wonder, why not just put the instruction to go back to
-       // sleep in the callback? It's a good idea, but I can't figure out how
-       // to get it to work - you're basically kicking the can down the road,
-       // since at some point movement will be done doing what it's doing and
-       // have to wait. At that point, you're delaying anyways, but it's
-       // harder to figure out how much time to delay for, since you don't
-       // know how much time has elapsed since starting the sequence. I'd
-       // rather this block than have to read from the RTC to figure that
-       // out.
-       //
-       // Don't ask me what the +50ms is doing. The sequence gets cut short
-       // with the exact time, I have no idea why. 50 extra millisecons seems
-       // like a safe value.
-        delay_ms(sequence_length(signal_tune) * 1000 / 64 + 50);
+        // the watch is asleep. wake it up for "1" round through the main loop.
+        // the sleep_mode_app_loop will notice the is_buzzing and note that it
+        // only woke up to beep and then it will spinlock until the callback
+        // turns off the is_buzzing flag.
+        movement_state.needs_wake = true;
+        movement_state.le_mode_ticks = 1;
     }
 }
 
@@ -450,6 +450,7 @@ static void _sleep_mode_app_loop(void) {
 }
 
 bool app_loop(void) {
+    bool woke_up_for_buzzer = false;
     if (movement_state.watch_face_changed) {
         if (movement_state.settings.bit.button_should_sound) {
             // low note for nonzero case, high note for return to watch_face 0
@@ -493,7 +494,11 @@ bool app_loop(void) {
         // _sleep_mode_app_loop takes over at this point and loops until le_mode_ticks is reset by the extwake handler,
         // or wake is requested using the movement_request_wake function.
         _sleep_mode_app_loop();
-        // as soon as _sleep_mode_app_loop returns, we reactivate ourselves.
+        // as soon as _sleep_mode_app_loop returns, we prepare to reactivate
+        // ourselves, but first, we check to see if we woke up for the buzzer:
+        if (movement_state.is_buzzing) {
+            woke_up_for_buzzer = true;
+        }
         event.event_type = EVENT_ACTIVATE;
         // this is a hack tho: waking from sleep mode, app_setup does get called, but it happens before we have reset our ticks.
         // need to figure out if there's a better heuristic for determining how we woke up.
@@ -575,8 +580,13 @@ bool app_loop(void) {
     // if the watch face changed, we can't sleep because we need to update the display.
     if (movement_state.watch_face_changed) can_sleep = false;
 
-    // if the buzzer or the LED is on, we need to stay awake to keep the TCC running.
-    if (movement_state.is_buzzing || movement_state.light_ticks != -1) can_sleep = false;
+    // if we woke up for the buzzer, stay awake until it's finished.
+    if (woke_up_for_buzzer) {
+        while(watch_is_buzzer_or_led_enabled());
+    }
+
+    // if the LED is on, we need to stay awake to keep the TCC running.
+    if (movement_state.light_ticks != -1) can_sleep = false;
 
     return can_sleep;
 }