fern/sensor-watch
1
0
Fork 0
mirror of https://github.com/firewalkwithm3/Sensor-Watch.git synced 2024-11-22 19:20:30 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Alex Maestas 2024-01-09 16:24:11 -05:00 committed by Wesley Aptekar-Cassels
parent 50dccd07d3
commit aa3a1eeeef
1 changed files with 36 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
movement/movement.c
View file

@ -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;
}