From b5f191a1b769ddf3159e0f6829a7e088ddd570ed Mon Sep 17 00:00:00 2001 From: Konrad Rieck Date: Mon, 23 Jan 2023 21:18:28 +0100 Subject: Minor enhancements for the countdown face (#177) * minor enhancements for the countdown face * Changed usage of countdown timer. - Long button presses have been removed. - The light button is used to restore the last countdown as well as enter setting mode when pressed again. - The visual state has been removed from the display. - The internal states have been renamed to reflect the new logic. * restore time when countdown finished. * support for fast forward on long press (untested). * support for beeps similar to stop watch * fixed bug wiht display when fast forwarding --- movement/watch_faces/complication/countdown_face.c | 120 +++++++++++++++++---- movement/watch_faces/complication/countdown_face.h | 8 +- 2 files changed, 103 insertions(+), 25 deletions(-) diff --git a/movement/watch_faces/complication/countdown_face.c b/movement/watch_faces/complication/countdown_face.c index b2206b8f..60f0a5b0 100644 --- a/movement/watch_faces/complication/countdown_face.c +++ b/movement/watch_faces/complication/countdown_face.c @@ -1,6 +1,7 @@ /* * MIT License * + * Copyright (c) 2023 Konrad Rieck * Copyright (c) 2022 Wesley Ellis * * Permission is hereby granted, free of charge, to any person obtaining a copy @@ -30,15 +31,58 @@ #include "watch.h" #include "watch_utility.h" +/* + Slight extension of the original countdown face by Wesley Ellis. + + - Press the light button to enter setting mode and adjust the + countdown timer. + + - Start and pause the countdown using the alarm button, similar to the + stopwatch face. + + - When paused or terminated, press the light button to restore the + last entered countdown. +*/ #define CD_SELECTIONS 3 #define DEFAULT_MINUTES 3 +static bool quick_ticks_running; + +static void abort_quick_ticks(countdown_state_t *state) { + if (quick_ticks_running) { + quick_ticks_running = false; + if (state->mode == cd_setting) + movement_request_tick_frequency(4); + else + movement_request_tick_frequency(1); + } +} static inline int32_t get_tz_offset(movement_settings_t *settings) { return movement_timezone_offsets[settings->bit.time_zone] * 60; } +static inline void store_countdown(countdown_state_t *state) { + /* Store set countdown time */ + state->set_hours = state->hours; + state->set_minutes = state->minutes; + state->set_seconds = state->seconds; +} + +static inline void load_countdown(countdown_state_t *state) { + /* Load set countdown time */ + state->hours = state->set_hours; + state->minutes = state->set_minutes; + state->seconds = state->set_seconds; +} + +static inline void button_beep(movement_settings_t *settings) { + // play a beep as confirmation for a button press (if applicable) + if (settings->bit.button_should_sound) + watch_buzzer_play_note(BUZZER_NOTE_C7, 50); +} + static void start(countdown_state_t *state, movement_settings_t *settings) { watch_date_time now = watch_rtc_get_date_time(); @@ -55,25 +99,24 @@ static void draw(countdown_state_t *state, uint8_t subsecond) { uint32_t delta; div_t result; - uint8_t hour, min, sec; switch (state->mode) { case cd_running: delta = state->target_ts - state->now_ts; result = div(delta, 60); - sec = result.rem; + state->seconds = result.rem; result = div(result.quot, 60); - hour = result.quot; - min = result.rem; - - sprintf(buf, "CD %2d%02d%02d", hour, min, sec); + state->hours = result.quot; + state->minutes = result.rem; + sprintf(buf, "CD %2d%02d%02d", state->hours, state->minutes, state->seconds); break; - case cd_waiting: + case cd_reset: + case cd_paused: sprintf(buf, "CD %2d%02d%02d", state->hours, state->minutes, state->seconds); break; case cd_setting: sprintf(buf, "CD %2d%02d%02d", state->hours, state->minutes, state->seconds); - if (subsecond % 2) { + if (!quick_ticks_running && subsecond % 2) { switch(state->selection) { case 0: buf[4] = buf[5] = ' '; @@ -93,10 +136,17 @@ static void draw(countdown_state_t *state, uint8_t subsecond) { watch_display_string(buf, 0); } +static void pause(countdown_state_t *state) { + state->mode = cd_paused; + movement_cancel_background_task(); + watch_clear_indicator(WATCH_INDICATOR_BELL); +} + static void reset(countdown_state_t *state) { - state->mode = cd_waiting; + state->mode = cd_reset; movement_cancel_background_task(); watch_clear_indicator(WATCH_INDICATOR_BELL); + load_countdown(state); } static void ring(countdown_state_t *state) { @@ -131,6 +181,8 @@ void countdown_face_setup(movement_settings_t *settings, uint8_t watch_face_inde countdown_state_t *state = (countdown_state_t *)*context_ptr; memset(*context_ptr, 0, sizeof(countdown_state_t)); state->minutes = DEFAULT_MINUTES; + state->mode = cd_reset; + store_countdown(state); } } @@ -143,8 +195,10 @@ void countdown_face_activate(movement_settings_t *settings, void *context) { watch_set_indicator(WATCH_INDICATOR_BELL); } watch_set_colon(); -} + movement_request_tick_frequency(1); + quick_ticks_running = false; +} bool countdown_face_loop(movement_event_t event, movement_settings_t *settings, void *context) { (void) settings; @@ -155,12 +209,20 @@ bool countdown_face_loop(movement_event_t event, movement_settings_t *settings, draw(state, event.subsecond); break; case EVENT_TICK: + if (quick_ticks_running) { + if (watch_get_pin_level(BTN_ALARM)) + settings_increment(state); + else + abort_quick_ticks(state); + } + if (state->mode == cd_running) { state->now_ts++; } draw(state, event.subsecond); break; case EVENT_MODE_BUTTON_UP: + abort_quick_ticks(state); movement_move_to_next_face(); break; case EVENT_LIGHT_BUTTON_UP: @@ -168,16 +230,23 @@ bool countdown_face_loop(movement_event_t event, movement_settings_t *settings, case cd_running: movement_illuminate_led(); break; - case cd_waiting: + case cd_paused: + reset(state); + button_beep(settings); + break; + case cd_reset: state->mode = cd_setting; movement_request_tick_frequency(4); + button_beep(settings); break; case cd_setting: state->selection++; if(state->selection >= CD_SELECTIONS) { state->selection = 0; - state->mode = cd_waiting; + state->mode = cd_reset; + store_countdown(state); movement_request_tick_frequency(1); + button_beep(settings); } break; } @@ -186,12 +255,15 @@ bool countdown_face_loop(movement_event_t event, movement_settings_t *settings, case EVENT_ALARM_BUTTON_UP: switch(state->mode) { case cd_running: - reset(state); + pause(state); + button_beep(settings); break; - case cd_waiting: + case cd_reset: + case cd_paused: if (!(state->hours == 0 && state->minutes == 0 && state->seconds == 0)) { // Only start the timer if we have a valid time. start(state, settings); + button_beep(settings); } break; case cd_setting: @@ -200,19 +272,20 @@ bool countdown_face_loop(movement_event_t event, movement_settings_t *settings, } draw(state, event.subsecond); break; - case EVENT_BACKGROUND_TASK: - ring(state); - break; case EVENT_ALARM_LONG_PRESS: if (state->mode == cd_setting) { - state->hours = 0; - state->minutes = 0; - state->seconds = 0; - draw(state, event.subsecond); - break; + quick_ticks_running = true; + movement_request_tick_frequency(8); } break; + case EVENT_ALARM_LONG_UP: + abort_quick_ticks(state); + break; + case EVENT_BACKGROUND_TASK: + ring(state); + break; case EVENT_TIMEOUT: + abort_quick_ticks(state); movement_move_to_face(0); break; case EVENT_LOW_ENERGY_UPDATE: @@ -228,6 +301,7 @@ void countdown_face_resign(movement_settings_t *settings, void *context) { countdown_state_t *state = (countdown_state_t *)context; if (state->mode == cd_setting) { state->selection = 0; - state->mode = cd_waiting; + state->mode = cd_reset; + store_countdown(state); } } diff --git a/movement/watch_faces/complication/countdown_face.h b/movement/watch_faces/complication/countdown_face.h index f6c845d6..12bb1d1e 100644 --- a/movement/watch_faces/complication/countdown_face.h +++ b/movement/watch_faces/complication/countdown_face.h @@ -40,9 +40,10 @@ movement_schedule_background_task() while the timer is running. typedef enum { - cd_waiting, + cd_paused, cd_running, - cd_setting + cd_setting, + cd_reset } countdown_mode_t; typedef struct { @@ -51,6 +52,9 @@ typedef struct { uint8_t hours; uint8_t minutes; uint8_t seconds; + uint8_t set_hours; + uint8_t set_minutes; + uint8_t set_seconds; uint8_t selection; countdown_mode_t mode; } countdown_state_t; -- cgit v1.2.3