From: joeycastillo Date: Mon, 23 Sep 2024 02:26:59 +0000 (-0400) Subject: new preferences face with support for RGB LED X-Git-Url: https://git.earman.xyz/?a=commitdiff_plain;h=687f1d9f60421c09886fa32cde08941e1182e23c;p=sensor-watch.git new preferences face with support for RGB LED --- diff --git a/movement.c b/movement.c index 455acb7..d4c5feb 100644 --- a/movement.c +++ b/movement.c @@ -377,6 +377,22 @@ void app_init(void) { #endif movement_state.settings.bit.led_red_color = MOVEMENT_DEFAULT_RED_COLOR; movement_state.settings.bit.led_green_color = MOVEMENT_DEFAULT_GREEN_COLOR; +#if defined(WATCH_BLUE_TCC_CHANNEL) && !defined(WATCH_GREEN_TCC_CHANNEL) + // If there is a blue LED but no green LED, this is a blue Special Edition board. + // In the past, the "green color" showed up as the blue color on the blue board. + if (MOVEMENT_DEFAULT_RED_COLOR == 0 && MOVEMENT_DEFAULT_BLUE_COLOR == 0) { + // If the red color is 0 and the blue color is 0, we'll fall back to the old + // behavior, since otherwise there would be no default LED color. + movement_state.settings.bit.led_blue_color = MOVEMENT_DEFAULT_GREEN_COLOR; + } else { + // however if either the red or blue color is nonzero, we'll assume the user + // has used the new defaults and knows what color they want. this could be red + // if blue is 0, or a custom color if both are nonzero. + movement_state.settings.bit.led_blue_color = MOVEMENT_DEFAULT_BLUE_COLOR; + } +#else + movement_state.settings.bit.led_blue_color = MOVEMENT_DEFAULT_BLUE_COLOR; +#endif movement_state.settings.bit.button_should_sound = MOVEMENT_DEFAULT_BUTTON_SOUND; movement_state.settings.bit.to_interval = MOVEMENT_DEFAULT_TIMEOUT_INTERVAL; movement_state.settings.bit.le_interval = MOVEMENT_DEFAULT_LOW_ENERGY_INTERVAL; diff --git a/movement.h b/movement.h index 439ce62..b7d0da6 100644 --- a/movement.h +++ b/movement.h @@ -41,9 +41,7 @@ // This allows these preferences to be stored before entering BACKUP mode and and restored after waking from reset. // movement_settings_t contains global settings that cover watch behavior, including preferences around clock and unit -// display, time zones, buzzer behavior, LED color and low energy mode timeouts. These settings are stored in BKUP[0]. -// If your watch face changes one of these settings, you should store your changes in either your loop or resign -// function by calling `watch_store_backup_data(settings->reg, 0)`. Otherwise it may not persist after a reset event. +// display, time zones, buzzer behavior, LED color and low energy mode timeouts. typedef union { struct { bool button_should_sound : 1; // if true, pressing a button emits a sound. @@ -53,6 +51,7 @@ typedef union { uint8_t led_duration : 3; // how many seconds to shine the LED for (x2), 0 to shine only while the button is depressed, or all bits set to disable the LED altogether. uint8_t led_red_color : 4; // for general purpose illumination, the red LED value (0-15) uint8_t led_green_color : 4; // for general purpose illumination, the green LED value (0-15) + uint8_t led_blue_color : 4; // for general purpose illumination, the green LED value (0-15) uint8_t time_zone : 6; // an integer representing an index in the time zone table. // while Movement itself doesn't implement a clock or display units, it may make sense to include some @@ -61,8 +60,10 @@ typedef union { // altimeter to display feet or meters as easily as it tells a thermometer to display degrees in F or C. bool clock_mode_24h : 1; // indicates whether clock should use 12 or 24 hour mode. bool use_imperial_units : 1; // indicates whether to use metric units (the default) or imperial. + + /// TODO: for #SecondMovement: move alarm_enabled out of preferences bool alarm_enabled : 1; // indicates whether there is at least one alarm enabled. - uint8_t reserved : 6; // room for more preferences if needed. + uint8_t reserved : 1; // room for more preferences if needed. } bit; uint32_t reg; } movement_settings_t; diff --git a/movement/watch_faces/settings/preferences_face.c b/movement/watch_faces/settings/preferences_face.c deleted file mode 100644 index b913d8c..0000000 --- a/movement/watch_faces/settings/preferences_face.c +++ /dev/null @@ -1,204 +0,0 @@ -/* - * MIT License - * - * Copyright (c) 2022 Joey Castillo - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#include -#include "preferences_face.h" -#include "watch.h" - -#define PREFERENCES_FACE_NUM_PREFERENCES (7) -const char preferences_face_titles[PREFERENCES_FACE_NUM_PREFERENCES][11] = { - "CL ", // Clock: 12 or 24 hour - "BT Beep ", // Buttons: should they beep? - "TO ", // Timeout: how long before we snap back to the clock face? - "LE ", // Low Energy mode: how long before it engages? - "LT ", // Light: duration -#ifdef WATCH_IS_BLUE_BOARD - "LT blu ", // Light: blue component (for watches with blue LED) -#else - "LT grn ", // Light: green component -#endif - "LT red ", // Light: red component -}; - -void preferences_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr) { - (void) settings; - (void) watch_face_index; - if (*context_ptr == NULL) *context_ptr = malloc(sizeof(uint8_t)); -} - -void preferences_face_activate(movement_settings_t *settings, void *context) { - (void) settings; - *((uint8_t *)context) = 0; - movement_request_tick_frequency(4); // we need to manually blink some pixels -} - -bool preferences_face_loop(movement_event_t event, movement_settings_t *settings, void *context) { - uint8_t current_page = *((uint8_t *)context); - switch (event.event_type) { - case EVENT_TICK: - case EVENT_ACTIVATE: - // Do nothing; handled below. - break; - case EVENT_MODE_BUTTON_UP: - watch_set_led_off(); - movement_move_to_next_face(); - return false; - case EVENT_LIGHT_BUTTON_DOWN: - current_page = (current_page + 1) % PREFERENCES_FACE_NUM_PREFERENCES; - *((uint8_t *)context) = current_page; - break; - case EVENT_ALARM_BUTTON_UP: - switch (current_page) { - case 0: - settings->bit.clock_mode_24h = !(settings->bit.clock_mode_24h); - break; - case 1: - settings->bit.button_should_sound = !(settings->bit.button_should_sound); - break; - case 2: - settings->bit.to_interval = settings->bit.to_interval + 1; - break; - case 3: - settings->bit.le_interval = settings->bit.le_interval + 1; - break; - case 4: - settings->bit.led_duration = settings->bit.led_duration + 1; - if (settings->bit.led_duration > 3) { - settings->bit.led_duration = 0b111; - } - break; - case 5: - settings->bit.led_green_color = settings->bit.led_green_color + 1; - break; - case 6: - settings->bit.led_red_color = settings->bit.led_red_color + 1; - break; - } - break; - case EVENT_TIMEOUT: - movement_move_to_face(0); - break; - default: - return movement_default_loop_handler(event, settings); - } -#ifdef CLOCK_FACE_24H_ONLY - if (current_page == 0) current_page++; // Skips past 12/24HR mode -#endif - watch_display_string((char *)preferences_face_titles[current_page], 0); - - // blink active setting on even-numbered quarter-seconds - if (event.subsecond % 2) { - char buf[8]; - switch (current_page) { - case 0: - if (settings->bit.clock_mode_24h) watch_display_string("24h", 4); - else watch_display_string("12h", 4); - break; - case 1: - if (settings->bit.button_should_sound) watch_display_string("y", 9); - else watch_display_string("n", 9); - break; - case 2: - switch (settings->bit.to_interval) { - case 0: - watch_display_string("60 SeC", 4); - break; - case 1: - watch_display_string("2 n&in", 4); - break; - case 2: - watch_display_string("5 n&in", 4); - break; - case 3: - watch_display_string("30n&in", 4); - break; - } - break; - case 3: - switch (settings->bit.le_interval) { - case 0: - watch_display_string(" Never", 4); - break; - case 1: - watch_display_string("10n&in", 4); - break; - case 2: - watch_display_string("1 hour", 4); - break; - case 3: - watch_display_string("2 hour", 4); - break; - case 4: - watch_display_string("6 hour", 4); - break; - case 5: - watch_display_string("12 hr", 4); - break; - case 6: - watch_display_string(" 1 day", 4); - break; - case 7: - watch_display_string(" 7 day", 4); - break; - } - break; - case 4: - if (settings->bit.led_duration == 0) { - watch_display_string("instnt", 4); - } else if (settings->bit.led_duration == 0b111) { - watch_display_string("no LEd", 4); - } else { - sprintf(buf, " %1d SeC", settings->bit.led_duration * 2 - 1); - watch_display_string(buf, 4); - } - break; - case 5: - sprintf(buf, "%2d", settings->bit.led_green_color); - watch_display_string(buf, 8); - break; - case 6: - sprintf(buf, "%2d", settings->bit.led_red_color); - watch_display_string(buf, 8); - break; - } - } - - // on LED color select screns, preview the color. - if (current_page >= 5) { - watch_set_led_color(settings->bit.led_red_color ? (0xF | settings->bit.led_red_color << 4) : 0, - settings->bit.led_green_color ? (0xF | settings->bit.led_green_color << 4) : 0); - // return false so the watch stays awake (needed for the PWM driver to function). - return false; - } - - watch_set_led_off(); - return true; -} - -void preferences_face_resign(movement_settings_t *settings, void *context) { - (void) settings; - (void) context; - watch_set_led_off(); - watch_store_backup_data(settings->reg, 0); -} diff --git a/movement/watch_faces/settings/preferences_face.h b/movement/watch_faces/settings/preferences_face.h deleted file mode 100644 index c8f36d7..0000000 --- a/movement/watch_faces/settings/preferences_face.h +++ /dev/null @@ -1,94 +0,0 @@ -/* - * MIT License - * - * Copyright (c) 2022 Joey Castillo - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#ifndef PREFERENCES_FACE_H_ -#define PREFERENCES_FACE_H_ - -/* - * PREFERENCES face - * - * The Preferences watch face allows you to configure various options on your - * Sensor Watch. Like all other screens, you advance the field you’re setting - * with the Light button, and advance its value with the Alarm button. The - * Preferences watch face labels each setting with a two-letter code on the - * top row; the following list describes each setting and their options: - * - * CL - Clock mode. - * This setting allows you to select a 12-or 24-hour clock display. All - * watch faces that support displaying the time will respect this setting; - * for example, both Simple Clock, World Clock and Sunrise/Sunset will - * display the time in 24 hour format if the 24 hour clock is selected here. - * - * BT - Button tone. - * This setting is only relevant if you installed the buzzer connector, - * and it toggles the beep when changing modes. If Y, the buzzer will - * sound a tone when Mode is pressed. Change to N to make the Mode - * button silent. - * - * TO - Timeout. - * Sets the time until screens that time out (like Settings and Time Set) - * snap back to the first screen. 60 seconds is a good default for the - * stock firmware, but if you choose a custom firmware with faces that - * you’d like to keep on screen for longer, you can set that here. - * - * LE - Low Energy mode. - * Sets the time until the watch enters its low energy sleep mode. - * Options range from 1 hour to 7 days, or Never. The more often Sensor - * Watch goes to sleep, the longer its battery will last — but you will - * lose the seconds indicator while it is asleep. This setting allows - * you to make a tradeoff between the device’s responsiveness and its - * longevity. - * - * LT - Light. - * This setting has three screens. - * The first lets you choose how long the LED should stay lit when the - * LIGHT button is pressed. Options are 1 second, 3 seconds and 5 - * seconds, or “No LED” to disable the LED entirely. - * The second screen, titled “blu” or “grn”, sets the intensity of the - * blue or green LED depending on the target Sensor Board hardware. - * Values range from 0 (off) to 15 (full intensity). - * The third screen, “red”, sets the intensity of the red LED, again - * from 0 to 15. - * On the last two screens, the LED remains on so that you can see the - * effect of mixing the two LED colors. On the Special Edition boards, - * you’ll have red, blue and a variety of shades of pink and purple to - * experiment with! - */ - -#include "movement.h" - -void preferences_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr); -void preferences_face_activate(movement_settings_t *settings, void *context); -bool preferences_face_loop(movement_event_t event, movement_settings_t *settings, void *context); -void preferences_face_resign(movement_settings_t *settings, void *context); - -#define preferences_face ((const watch_face_t){ \ - preferences_face_setup, \ - preferences_face_activate, \ - preferences_face_loop, \ - preferences_face_resign, \ - NULL, \ -}) - -#endif // PREFERENCES_FACE_H_ diff --git a/movement_config.h b/movement_config.h index 9412690..e90efd4 100644 --- a/movement_config.h +++ b/movement_config.h @@ -29,6 +29,7 @@ const watch_face_t watch_faces[] = { simple_clock_face, + preferences_face, set_time_face, }; @@ -40,7 +41,7 @@ const watch_face_t watch_faces[] = { * Some folks also like to use this to hide the preferences and time set faces from the normal rotation. * If you don't want any faces to be excluded, set this to 0 and a long Mode press will have no effect. */ -#define MOVEMENT_SECONDARY_FACE_INDEX (MOVEMENT_NUM_FACES - 2) // or (0) +#define MOVEMENT_SECONDARY_FACE_INDEX (0) // (MOVEMENT_NUM_FACES - 2) /* Custom hourly chime tune. Check movement_custom_signal_tunes.h for options. */ #define SIGNAL_TUNE_DEFAULT @@ -48,8 +49,9 @@ const watch_face_t watch_faces[] = { /* Determines the intensity of the led colors * Set a hex value 0-15 with 0x0 being off and 0xF being max intensity */ -#define MOVEMENT_DEFAULT_GREEN_COLOR 0xF #define MOVEMENT_DEFAULT_RED_COLOR 0x0 +#define MOVEMENT_DEFAULT_GREEN_COLOR 0xF +#define MOVEMENT_DEFAULT_BLUE_COLOR 0x0 /* Set to true for 24h mode or false for 12h mode */ #define MOVEMENT_DEFAULT_24H_MODE false diff --git a/movement_faces.h b/movement_faces.h index 9e3f7cf..b7791f6 100644 --- a/movement_faces.h +++ b/movement_faces.h @@ -26,4 +26,5 @@ #include "simple_clock_face.h" #include "set_time_face.h" +#include "preferences_face.h" // New includes go above this line. diff --git a/watch-faces.mk b/watch-faces.mk index 14e4319..338c3b9 100644 --- a/watch-faces.mk +++ b/watch-faces.mk @@ -1,3 +1,4 @@ SRCS += \ ./watch-faces/clock/simple_clock_face.c \ ./watch-faces/settings/set_time_face.c \ + ./watch-faces/settings/preferences_face.c \ diff --git a/watch-faces/settings/preferences_face.c b/watch-faces/settings/preferences_face.c new file mode 100644 index 0000000..45f6e28 --- /dev/null +++ b/watch-faces/settings/preferences_face.c @@ -0,0 +1,245 @@ +/* + * MIT License + * + * Copyright (c) 2022-2024 Joey Castillo + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include +#include "preferences_face.h" +#include "watch.h" + +const char preferences_face_titles[PREFERENCES_PAGE_NUM_PREFERENCES][11] = { + "CL ", // Clock: 12 or 24 hour + "BT beep ", // Mode button: how loud should it beep? + "TO ", // Timeout: how long before we snap back to the clock face? + "LE ", // Low Energy mode: how long before it engages? + "LT ", // Light: duration + "LT red ", // Light: red component + "LT green", // Light: green component + "LT blue ", // Light: blue component (for watches with blue LED) +}; + +void preferences_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr) { + (void) settings; + (void) watch_face_index; + if (*context_ptr == NULL) { + *context_ptr = malloc(sizeof(preferences_state_t)); + preferences_state_t *state = (preferences_state_t *)*context_ptr; + for (int i = 0; i < PREFERENCES_PAGE_NUM_PREFERENCES; i++) { + state->setting_enabled[i] = true; + } +#ifdef CLOCK_FACE_24H_ONLY + state->setting_enabled[PREFERENCES_PAGE_CLOCK_MODE] = false; +#endif +#ifndef WATCH_RED_TCC_CHANNEL + state->setting_enabled[PREFERENCES_PAGE_LED_RED] = false; +#endif +#ifndef WATCH_GREEN_TCC_CHANNEL + state->setting_enabled[PREFERENCES_PAGE_LED_GREEN] = false; +#endif +#ifndef WATCH_BLUE_TCC_CHANNEL + state->setting_enabled[PREFERENCES_PAGE_LED_BLUE] = false; +#endif + + } +} + +void preferences_face_activate(movement_settings_t *settings, void *context) { + (void) settings; + preferences_state_t *state = (preferences_state_t *)context; + state->current_page = 0; + movement_request_tick_frequency(4); // we need to manually blink some pixels +} + +bool preferences_face_loop(movement_event_t event, movement_settings_t *settings, void *context) { + preferences_state_t *state = (preferences_state_t *)context; + + switch (event.event_type) { + case EVENT_TICK: + case EVENT_ACTIVATE: + // Do nothing; handled below. + break; + case EVENT_MODE_BUTTON_UP: + watch_set_led_off(); + movement_move_to_next_face(); + return false; + case EVENT_LIGHT_BUTTON_DOWN: + state->current_page = (state->current_page + 1) % PREFERENCES_PAGE_NUM_PREFERENCES; + while (!state->setting_enabled[state->current_page]) { + state->current_page = (state->current_page + 1) % PREFERENCES_PAGE_NUM_PREFERENCES; + } + break; + case EVENT_ALARM_BUTTON_UP: + switch (state->current_page) { + case PREFERENCES_PAGE_CLOCK_MODE: + settings->bit.clock_mode_24h = !settings->bit.clock_mode_24h; + break; + case PREFERENCES_PAGE_BUTTON_SOUND: + settings->bit.button_should_sound = !settings->bit.button_should_sound; + break; + case PREFERENCES_PAGE_TIMEOUT: + settings->bit.to_interval = settings->bit.to_interval + 1; + break; + case PREFERENCES_PAGE_LOW_ENERGY: + settings->bit.le_interval = settings->bit.le_interval + 1; + break; + case PREFERENCES_PAGE_LED_DURATION: + settings->bit.led_duration = settings->bit.led_duration + 1; + if (settings->bit.led_duration > 3) { + // set all bits to disable the LED + settings->bit.led_duration = 0b111; + } + break; + case PREFERENCES_PAGE_LED_RED: + settings->bit.led_red_color = settings->bit.led_red_color + 1; + break; + case PREFERENCES_PAGE_LED_GREEN: + settings->bit.led_green_color = settings->bit.led_green_color + 1; + break; + case PREFERENCES_PAGE_LED_BLUE: + settings->bit.led_blue_color = settings->bit.led_blue_color + 1; + break; + case PREFERENCES_PAGE_NUM_PREFERENCES: + // nothing to do here, just silencing the warning + break; + } + break; + case EVENT_TIMEOUT: + movement_move_to_face(0); + break; + default: + return movement_default_loop_handler(event, settings); + } + + watch_display_text(WATCH_POSITION_FULL, (char *)preferences_face_titles[state->current_page]); + watch_clear_all_indicators(); + watch_clear_colon(); + + // blink active setting on even-numbered quarter-seconds + if (event.subsecond % 2) { + char buf[8]; + switch (state->current_page) { + case PREFERENCES_PAGE_CLOCK_MODE: + if (settings->bit.clock_mode_24h) watch_display_text(WATCH_POSITION_BOTTOM, "24h"); + else watch_display_text(WATCH_POSITION_BOTTOM, "12h"); + break; + case PREFERENCES_PAGE_BUTTON_SOUND: + if (settings->bit.button_should_sound) { + watch_display_text(WATCH_POSITION_TOP_RIGHT, " Y"); + } else { + watch_display_text(WATCH_POSITION_TOP_RIGHT, " N"); + } + break; + case PREFERENCES_PAGE_TIMEOUT: + switch (settings->bit.to_interval) { + case 0: + watch_display_text(WATCH_POSITION_BOTTOM, "60 SeC"); + break; + case 1: + watch_display_text(WATCH_POSITION_BOTTOM, "2 n&in"); + break; + case 2: + watch_display_text(WATCH_POSITION_BOTTOM, "5 n&in"); + break; + case 3: + watch_display_text(WATCH_POSITION_BOTTOM, "30n&in"); + break; + } + break; + case PREFERENCES_PAGE_LOW_ENERGY: + switch (settings->bit.le_interval) { + case 0: + watch_display_text(WATCH_POSITION_BOTTOM, " Never"); + break; + case 1: + watch_display_text(WATCH_POSITION_BOTTOM, "10n&in"); + break; + case 2: + watch_display_text(WATCH_POSITION_BOTTOM, "1 hour"); + break; + case 3: + watch_display_text(WATCH_POSITION_BOTTOM, "2 hour"); + break; + case 4: + watch_display_text(WATCH_POSITION_BOTTOM, "6 hour"); + break; + case 5: + watch_display_text(WATCH_POSITION_BOTTOM, "12 hr"); + break; + case 6: + watch_display_text(WATCH_POSITION_BOTTOM, " 1 day"); + break; + case 7: + watch_display_text(WATCH_POSITION_BOTTOM, " 7 day"); + break; + } + break; + case PREFERENCES_PAGE_LED_DURATION: + if (settings->bit.led_duration == 0) { + watch_display_text(WATCH_POSITION_BOTTOM, "instnt"); + } else if (settings->bit.led_duration == 0b111) { + watch_display_text(WATCH_POSITION_BOTTOM, "no LEd"); + } else { + sprintf(buf, " %1d SeC", settings->bit.led_duration * 2 - 1); + watch_display_text(WATCH_POSITION_BOTTOM, buf); + } + break; + case PREFERENCES_PAGE_LED_RED: + sprintf(buf, "%2d", settings->bit.led_red_color); + watch_display_text(WATCH_POSITION_TOP_RIGHT, buf); + break; + break; + case PREFERENCES_PAGE_LED_GREEN: + sprintf(buf, "%2d", settings->bit.led_green_color); + watch_display_text(WATCH_POSITION_TOP_RIGHT, buf); + break; + break; + case PREFERENCES_PAGE_LED_BLUE: + sprintf(buf, "%2d", settings->bit.led_blue_color); + watch_display_text(WATCH_POSITION_TOP_RIGHT, buf); + break; + case PREFERENCES_PAGE_NUM_PREFERENCES: + // nothing to do here, just silencing the warning + break; + } + } + + // on LED color select screns, preview the color. + if (state->current_page == PREFERENCES_PAGE_LED_RED || + state->current_page == PREFERENCES_PAGE_LED_GREEN || + state->current_page == PREFERENCES_PAGE_LED_BLUE) { + watch_set_led_color_rgb(settings->bit.led_red_color ? (0xF | settings->bit.led_red_color << 4) : 0, + settings->bit.led_green_color ? (0xF | settings->bit.led_green_color << 4) : 0, + settings->bit.led_blue_color ? (0xF | settings->bit.led_blue_color << 4) : 0); + // return false so the watch stays awake (needed for the PWM driver to function). + return false; + } + + watch_set_led_off(); + return true; +} + +void preferences_face_resign(movement_settings_t *settings, void *context) { + (void) settings; + (void) context; + watch_set_led_off(); + watch_store_backup_data(settings->reg, 0); +} diff --git a/watch-faces/settings/preferences_face.h b/watch-faces/settings/preferences_face.h new file mode 100644 index 0000000..c9ab68f --- /dev/null +++ b/watch-faces/settings/preferences_face.h @@ -0,0 +1,113 @@ +/* + * MIT License + * + * Copyright (c) 2022-2024 Joey Castillo + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +/* + * PREFERENCES face + * + * The Preferences watch face allows you to configure various options on your + * Sensor Watch. Like all other screens, you advance the field you’re setting + * with the Light button, and advance its value with the Alarm button. The + * Preferences watch face labels each setting with a two-letter code on the + * top row; the following list describes each setting and their options: + * + * CL - Clock mode. + * This setting allows you to select a 12-or 24-hour clock display. All + * watch faces that support displaying the time will respect this setting; + * for example, both Simple Clock, World Clock and Sunrise/Sunset will + * display the time in 24 hour format if the 24 hour clock is selected here. + * + * MO - Mode button. + * This setting allows you to choose whether the Mode button should emit + * a beep when pressed, and if so, how loud it should be. Options are + * "-" (no beep), "L" (low volume) and "H" (high volume). + * + * MO - Mode button. + * This setting allows you to choose whether the Mode button should emit + * a beep when pressed, and if so, how loud it should be. Options are + * "-" (no beep), "L" (low volume) and "H" (high volume). + * + * TO - Timeout. + * Sets the time until screens that time out (like Settings and Time Set) + * snap back to the first screen. 60 seconds is a good default for the + * stock firmware, but if you choose a custom firmware with faces that + * you’d like to keep on screen for longer, you can set that here. + * + * LE - Low Energy mode. + * Sets the time until the watch enters its low energy sleep mode. + * Options range from 1 hour to 7 days, or Never. The more often Sensor + * Watch goes to sleep, the longer its battery will last — but you will + * lose the seconds indicator while it is asleep. This setting allows + * you to make a tradeoff between the device’s responsiveness and its + * longevity. + * + * LT - Light. + * This setting has three screens. + * The first lets you choose how long the LED should stay lit when the + * LIGHT button is pressed. Options are 1 second, 3 seconds and 5 + * seconds, or “No LED” to disable the LED entirely. + * The second screen, titled “blu” or “grn”, sets the intensity of the + * blue or green LED depending on the target Sensor Board hardware. + * Values range from 0 (off) to 15 (full intensity). + * The third screen, “red”, sets the intensity of the red LED, again + * from 0 to 15. + * On the last two screens, the LED remains on so that you can see the + * effect of mixing the two LED colors. On the Special Edition boards, + * you’ll have red, blue and a variety of shades of pink and purple to + * experiment with! + */ + +#include "movement.h" + +typedef enum { + PREFERENCES_PAGE_CLOCK_MODE = 0, + PREFERENCES_PAGE_BUTTON_SOUND, + PREFERENCES_PAGE_TIMEOUT, + PREFERENCES_PAGE_LOW_ENERGY, + PREFERENCES_PAGE_LED_DURATION, + PREFERENCES_PAGE_LED_RED, + PREFERENCES_PAGE_LED_GREEN, + PREFERENCES_PAGE_LED_BLUE, + PREFERENCES_PAGE_NUM_PREFERENCES, +} preferences_page_t; + + +typedef struct { + bool setting_enabled[PREFERENCES_PAGE_NUM_PREFERENCES]; + preferences_page_t current_page; +} preferences_state_t; + +void preferences_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr); +void preferences_face_activate(movement_settings_t *settings, void *context); +bool preferences_face_loop(movement_event_t event, movement_settings_t *settings, void *context); +void preferences_face_resign(movement_settings_t *settings, void *context); + +#define preferences_face ((const watch_face_t){ \ + preferences_face_setup, \ + preferences_face_activate, \ + preferences_face_loop, \ + preferences_face_resign, \ + NULL, \ +})