Merge branch 'main' into couch-2-5k

.github/workflows/build.yml

@@ -6,6 +6,9 @@ on:
     branches-ignore:
       - gh-pages
 
+env:
+  COLOR: BLUE
+
 jobs: 
   build:
     container:

make.mk

@@ -62,6 +62,7 @@ CFLAGS += -MD -MP -MT $(BUILD)/$(*F).o -MF $(BUILD)/$(@F).d
 LDFLAGS += -mcpu=cortex-m0plus -mthumb
 LDFLAGS += -Wl,--gc-sections
 LDFLAGS += -Wl,--script=$(TOP)/watch-library/hardware/linker/saml22j18.ld
+LDFLAGS += -Wl,--print-memory-usage
 
 LIBS += -lm
 
@@ -207,6 +208,10 @@ ifeq ($(LED), BLUE)
 CFLAGS += -DWATCH_IS_BLUE_BOARD
 endif
 
+ifndef COLOR
+$(error Set the COLOR variable to RED, BLUE, or GREEN depending on what board you have.)
+endif
+
 ifeq ($(COLOR), BLUE)
 CFLAGS += -DWATCH_IS_BLUE_BOARD
 endif

movement/make/Makefile

@@ -119,6 +119,8 @@ SRCS += \
   ../watch_faces/clock/decimal_time_face.c \
   ../watch_faces/clock/wyoscan_face.c \
   ../watch_faces/complication/couch_to_5k_face.c \
+  ../watch_faces/clock/minute_repeater_decimal_face.c \
+  ../watch_faces/complication/tuning_tones_face.c \
 # New watch faces go above this line.
 
 # Leave this line at the bottom of the file; it has all the targets for making your project.

movement/movement_faces.h

@@ -96,6 +96,8 @@
 #include "decimal_time_face.h"
 #include "wyoscan_face.h"
 #include "couch_to_5k_face.h"
+#include "minute_repeater_decimal_face.h"
+#include "tuning_tones_face.h"
 // New includes go above this line.
 
 #endif // MOVEMENT_FACES_H_

movement/watch_faces/clock/minute_repeater_decimal_face.c

@@ -0,0 +1,238 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Jonas Termeau - original repetition_minute_face
+ * Copyright (c) 2023 Brian Blakley - modified minute_repeater_decimal_face
+ *
+ * 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.
+ */
+
+/*
+ * This face, minute_repeater_decimal_face, is a modification of the original 
+ * repetition_minute_face by Jonas Termeau.
+ * 
+ * This version was created by BrianBinFL to use a decimal minute repeater pattern 
+ * (hours, tens, and minutes) instead of the traditional pattern (hours, quarters, 
+ * minutes).
+ *
+ * Also 500ms delays were added after the hours segment and after the tens segment
+ * to make it easier for the user to realize that the counting for the current 
+ * segment has ended.
+ *
+ */
+ 
+#include <stdlib.h>
+#include "minute_repeater_decimal_face.h"
+#include "watch.h"
+#include "watch_utility.h"
+#include "watch_private_display.h"
+
+void mrd_play_hour_chime(void) {
+        watch_buzzer_play_note(BUZZER_NOTE_C6, 75);
+        watch_buzzer_play_note(BUZZER_NOTE_REST, 500);
+}
+
+void mrd_play_tens_chime(void) {
+        watch_buzzer_play_note(BUZZER_NOTE_E6, 75);
+        watch_buzzer_play_note(BUZZER_NOTE_REST, 150);
+        watch_buzzer_play_note(BUZZER_NOTE_C6, 75);
+        watch_buzzer_play_note(BUZZER_NOTE_REST, 750);
+}
+
+void mrd_play_minute_chime(void) {
+        watch_buzzer_play_note(BUZZER_NOTE_E6, 75);
+        watch_buzzer_play_note(BUZZER_NOTE_REST, 500);
+}
+
+static void _update_alarm_indicator(bool settings_alarm_enabled, minute_repeater_decimal_state_t *state) {
+    state->alarm_enabled = settings_alarm_enabled;
+    if (state->alarm_enabled) watch_set_indicator(WATCH_INDICATOR_SIGNAL);
+    else watch_clear_indicator(WATCH_INDICATOR_SIGNAL);
+}
+
+void minute_repeater_decimal_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(minute_repeater_decimal_state_t));
+        minute_repeater_decimal_state_t *state = (minute_repeater_decimal_state_t *)*context_ptr;
+        state->signal_enabled = false;
+        state->watch_face_index = watch_face_index;
+    }
+}
+
+void minute_repeater_decimal_face_activate(movement_settings_t *settings, void *context) {
+    minute_repeater_decimal_state_t *state = (minute_repeater_decimal_state_t *)context;
+
+    if (watch_tick_animation_is_running()) watch_stop_tick_animation();
+
+    if (settings->bit.clock_mode_24h) watch_set_indicator(WATCH_INDICATOR_24H);
+
+    // handle chime indicator
+    if (state->signal_enabled) watch_set_indicator(WATCH_INDICATOR_BELL);
+    else watch_clear_indicator(WATCH_INDICATOR_BELL);
+
+    // show alarm indicator if there is an active alarm
+    _update_alarm_indicator(settings->bit.alarm_enabled, state);
+
+    watch_set_colon();
+
+    // this ensures that none of the timestamp fields will match, so we can re-render them all.
+    state->previous_date_time = 0xFFFFFFFF;
+}
+
+bool minute_repeater_decimal_face_loop(movement_event_t event, movement_settings_t *settings, void *context) {
+    minute_repeater_decimal_state_t *state = (minute_repeater_decimal_state_t *)context;
+    char buf[11];
+    uint8_t pos;
+
+    watch_date_time date_time;
+    uint32_t previous_date_time;
+    switch (event.event_type) {
+        case EVENT_ACTIVATE:
+        case EVENT_TICK:
+        case EVENT_LOW_ENERGY_UPDATE:
+            date_time = watch_rtc_get_date_time();
+            previous_date_time = state->previous_date_time;
+            state->previous_date_time = date_time.reg;
+
+            // check the battery voltage once a day...
+            if (date_time.unit.day != state->last_battery_check) {
+                state->last_battery_check = date_time.unit.day;
+                watch_enable_adc();
+                uint16_t voltage = watch_get_vcc_voltage();
+                watch_disable_adc();
+                // 2.2 volts will happen when the battery has maybe 5-10% remaining?
+                // we can refine this later.
+                state->battery_low = (voltage < 2200);
+            }
+
+            // ...and set the LAP indicator if low.
+            if (state->battery_low) watch_set_indicator(WATCH_INDICATOR_LAP);
+
+            if ((date_time.reg >> 6) == (previous_date_time >> 6) && event.event_type != EVENT_LOW_ENERGY_UPDATE) {
+                // everything before seconds is the same, don't waste cycles setting those segments.
+                watch_display_character_lp_seconds('0' + date_time.unit.second / 10, 8);
+                watch_display_character_lp_seconds('0' + date_time.unit.second % 10, 9);
+                break;
+            } else if ((date_time.reg >> 12) == (previous_date_time >> 12) && event.event_type != EVENT_LOW_ENERGY_UPDATE) {
+                // everything before minutes is the same.
+                pos = 6;
+                sprintf(buf, "%02d%02d", date_time.unit.minute, date_time.unit.second);
+            } else {
+                // other stuff changed; let's do it all.
+                if (!settings->bit.clock_mode_24h) {
+                    // if we are in 12 hour mode, do some cleanup.
+                    if (date_time.unit.hour < 12) {
+                        watch_clear_indicator(WATCH_INDICATOR_PM);
+                    } else {
+                        watch_set_indicator(WATCH_INDICATOR_PM);
+                    }
+                    date_time.unit.hour %= 12;
+                    if (date_time.unit.hour == 0) date_time.unit.hour = 12;
+                }
+                pos = 0;
+                if (event.event_type == EVENT_LOW_ENERGY_UPDATE) {
+                    if (!watch_tick_animation_is_running()) watch_start_tick_animation(500);
+                    sprintf(buf, "%s%2d%2d%02d  ", watch_utility_get_weekday(date_time), date_time.unit.day, date_time.unit.hour, date_time.unit.minute);
+                } else {
+                    sprintf(buf, "%s%2d%2d%02d%02d", watch_utility_get_weekday(date_time), date_time.unit.day, date_time.unit.hour, date_time.unit.minute, date_time.unit.second);
+                }
+            }
+            watch_display_string(buf, pos);
+            // handle alarm indicator
+            if (state->alarm_enabled != settings->bit.alarm_enabled) _update_alarm_indicator(settings->bit.alarm_enabled, state);
+            break;
+        case EVENT_ALARM_LONG_PRESS:
+            state->signal_enabled = !state->signal_enabled;
+            if (state->signal_enabled) watch_set_indicator(WATCH_INDICATOR_BELL);
+            else watch_clear_indicator(WATCH_INDICATOR_BELL);
+            break;
+        case EVENT_BACKGROUND_TASK:
+            movement_play_signal();
+            break;
+        case EVENT_LIGHT_LONG_UP:
+            /*
+             * Howdy neighbors, this is the actual complication. Like an actual
+             * (very expensive) watch with a repetition minute complication it's
+             * boring at 00:00 or 1:00 and very quite musical at 23:59 or 12:59.
+             */
+
+            date_time = watch_rtc_get_date_time();
+            
+            
+            int hours = date_time.unit.hour;
+            int tens = date_time.unit.minute / 10;
+            int minutes = date_time.unit.minute % 10;
+
+            // chiming hours
+            if (!settings->bit.clock_mode_24h) {
+                hours = date_time.unit.hour % 12;                
+                if (hours == 0) hours = 12;
+            }
+            if (hours > 0) {
+                int count = 0;
+                for(count = hours; count > 0; --count) {          
+                    mrd_play_hour_chime();
+                }
+                // do a little pause before proceeding to tens
+                watch_buzzer_play_note(BUZZER_NOTE_REST, 500);
+            }
+
+            // chiming tens (if needed)
+            if (tens > 0) {
+                int count = 0;
+                for(count = tens; count > 0; --count) {          
+                    mrd_play_tens_chime();
+                }
+                // do a little pause before proceeding to minutes
+                watch_buzzer_play_note(BUZZER_NOTE_REST, 500);
+            }
+
+            // chiming minutes (if needed)
+            if (minutes > 0) {
+                int count = 0;
+                for(count = minutes; count > 0; --count) {          
+                    mrd_play_minute_chime();
+                }
+            }
+           
+            break; 
+        default:
+            return movement_default_loop_handler(event, settings);
+    }
+
+    return true;
+}
+
+void minute_repeater_decimal_face_resign(movement_settings_t *settings, void *context) {
+    (void) settings;
+    (void) context;
+}
+
+bool minute_repeater_decimal_face_wants_background_task(movement_settings_t *settings, void *context) {
+    (void) settings;
+    minute_repeater_decimal_state_t *state = (minute_repeater_decimal_state_t *)context;
+    if (!state->signal_enabled) return false;
+
+    watch_date_time date_time = watch_rtc_get_date_time();
+
+    return date_time.unit.minute == 0;
+}

movement/watch_faces/clock/minute_repeater_decimal_face.h

@@ -0,0 +1,84 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Jonas Termeau - original repetition_minute_face
+ * Copyright (c) 2023 Brian Blakley - modified minute_repeater_decimal_face
+ *
+ * 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 MINUTE_REPEATER_DECIMAL_FACE_H_
+#define MINUTE_REPEATER_DECIMAL_FACE_H_
+
+#include "movement.h"
+
+/*
+ * A hopefully useful complication for friendly neighbors in the dark
+ *
+ * Originating from 1676 from reverend and mechanician Edward Barlow, and
+ * perfected in 1820 by neighbor Abraham Breguet, a minute repeater or 
+ * "repetition minute" is a complication in a mechanical watch or clock that
+ * chimes the hours and often minutes at the press of a button. There are many
+ * types of repeater, from the simple repeater which merely strikes the number
+ * of hours, to the minute repeater which chimes the time down to the minute,
+ * using separate tones for hours, decimal hours, and minutes. They originated
+ * before widespread artificial illumination, to allow the time to be determined
+ * in the dark, and were also used by the visually impaired. 
+ *
+ *
+ * How to use it :
+ * 
+ * Long press the light button to get an auditive reading of the time like so :
+ * 0..23 (1..12 if 24-hours format isn't enabled) low beep(s) for the hours
+ * 0..9 low-high couple pitched beeps for the tens of minutes
+ * 0..9 high pitched beep(s) for the remaining minutes (ones of minutes)
+ *
+ * Prerequisite : a watch with a working buzzer
+ * 
+ * ~ Only in the darkness can you see the stars. - Martin Luther King ~
+ *
+ */
+
+typedef struct {
+    uint32_t previous_date_time;
+    uint8_t last_battery_check;
+    uint8_t watch_face_index;
+    bool signal_enabled;
+    bool battery_low;
+    bool alarm_enabled;
+} minute_repeater_decimal_state_t;
+
+void mrd_play_hour_chime(void);
+void mrd_play_tens_chime(void);
+void mrd_play_minute_chime(void);
+void minute_repeater_decimal_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr);
+void minute_repeater_decimal_face_activate(movement_settings_t *settings, void *context);
+bool minute_repeater_decimal_face_loop(movement_event_t event, movement_settings_t *settings, void *context);
+void minute_repeater_decimal_face_resign(movement_settings_t *settings, void *context);
+bool minute_repeater_decimal_face_wants_background_task(movement_settings_t *settings, void *context);
+
+#define minute_repeater_decimal_face ((const watch_face_t){ \
+    minute_repeater_decimal_face_setup, \
+    minute_repeater_decimal_face_activate, \
+    minute_repeater_decimal_face_loop, \
+    minute_repeater_decimal_face_resign, \
+    minute_repeater_decimal_face_wants_background_task, \
+})
+
+#endif // MINUTE_REPEATER_DECIMAL_FACE_H_

movement/watch_faces/complication/timer_face.c

@@ -30,7 +30,7 @@
 #include "watch.h"
 #include "watch_utility.h"
 
-static const uint16_t _default_timer_values[] = {0x200, 0x500, 0xA00, 0x1400, 0x2D02}; // default timers: 2 min, 5 min, 10 min, 20 min, 2 h 45 min
+static const uint32_t _default_timer_values[] = {0x000200, 0x000500, 0x000A00, 0x001400, 0x002D02}; // default timers: 2 min, 5 min, 10 min, 20 min, 2 h 45 min
 
 // sound sequence for a single beeping sequence
 static const int8_t _sound_seq_beep[] = {BUZZER_NOTE_C8, 3, BUZZER_NOTE_REST, 3, -2, 2, BUZZER_NOTE_C8, 5, BUZZER_NOTE_REST, 25, 0};
@@ -199,7 +199,7 @@ void timer_face_setup(movement_settings_t *settings, uint8_t watch_face_index, v
         timer_state_t *state = (timer_state_t *)*context_ptr;
         memset(*context_ptr, 0, sizeof(timer_state_t));
         state->watch_face_index = watch_face_index;
-        for (uint8_t i = 0; i < sizeof(_default_timer_values) / sizeof(uint16_t); i++) {
+        for (uint8_t i = 0; i < sizeof(_default_timer_values) / sizeof(uint32_t); i++) {
             state->timers[i].value = _default_timer_values[i];
         }
     }

movement/watch_faces/complication/tuning_tones_face.c

@@ -0,0 +1,140 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Per Waagø
+ *
+ * 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 <stdlib.h>
+#include <string.h>
+#include "tuning_tones_face.h"
+
+/*
+
+    This face plays a tone that can be used as a reference when tuning
+    musical instrument.
+
+    - The alarm button (short press) starts and stops the tone
+    - The light button (short press) changes which note is played. The name
+    of the note is shown in the display.
+
+*/
+
+typedef struct Note {
+    BuzzerNote note;
+    char * name;
+} Note;
+
+static Note notes[] = {
+    { .note = BUZZER_NOTE_C5, .name = "C " },
+    { .note = BUZZER_NOTE_C5SHARP_D5FLAT, .name = "Db" },
+    { .note = BUZZER_NOTE_D5, .name = "D " },
+    { .note = BUZZER_NOTE_D5SHARP_E5FLAT, .name = "Eb" },
+    { .note = BUZZER_NOTE_E5, .name = "E " },
+    { .note = BUZZER_NOTE_F5, .name = "F " },
+    { .note = BUZZER_NOTE_F5SHARP_G5FLAT, .name = "Gb" },
+    { .note = BUZZER_NOTE_G5, .name = "G " },
+    { .note = BUZZER_NOTE_G5SHARP_A5FLAT, .name = "Ab" },
+    { .note = BUZZER_NOTE_A5, .name = "A " },
+    { .note = BUZZER_NOTE_A5SHARP_B5FLAT, .name = "Bb" },
+    { .note = BUZZER_NOTE_B5, .name = "B " },
+};
+
+static size_t note_count = sizeof notes / sizeof *notes;
+
+static void draw(tuning_tones_state_t *state)
+{
+    watch_display_string(notes[state->note_ind].name, 8);
+}
+
+void tuning_tones_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr) {
+    (void) settings;
+    (void) watch_face_index;
+    if (*context_ptr == NULL) {
+        tuning_tones_state_t *state = malloc(sizeof *state);
+        memset(state, 0, sizeof *state);
+        state->note_ind = 9;
+        *context_ptr = state;
+    }
+}
+
+void tuning_tones_face_activate(movement_settings_t *settings, void *context) {
+    (void) settings;
+    (void) context;
+}
+
+static void update_buzzer(const tuning_tones_state_t *state)
+{
+    if (state->playing) {
+        watch_set_buzzer_off();
+        watch_set_buzzer_period(NotePeriods[notes[state->note_ind].note]);
+        watch_set_buzzer_on();
+    }
+}
+
+bool tuning_tones_face_loop(movement_event_t event, movement_settings_t *settings, void *context) {
+    tuning_tones_state_t *state = (tuning_tones_state_t *)context;
+
+    switch (event.event_type) {
+        case EVENT_ACTIVATE:
+            draw(state);
+            break;
+        case EVENT_TICK:
+            break;
+        case EVENT_LIGHT_BUTTON_DOWN:
+            state->note_ind++;
+            if (state->note_ind == note_count) {
+                state->note_ind = 0;
+            }
+            update_buzzer(state);
+            draw(state);
+            break;
+        case EVENT_LIGHT_BUTTON_UP:
+            break;
+        case EVENT_ALARM_BUTTON_DOWN:
+            state->playing = !state->playing;
+            if (!state->playing) {
+                watch_set_buzzer_off();
+            } else {
+                update_buzzer(state);
+            }
+        case EVENT_ALARM_BUTTON_UP:
+            break;
+        case EVENT_TIMEOUT:
+            movement_move_to_face(0);
+            break;
+        case EVENT_LOW_ENERGY_UPDATE:
+            break;
+        default:
+            return movement_default_loop_handler(event, settings);
+    }
+
+    return !state->playing;
+}
+
+void tuning_tones_face_resign(movement_settings_t *settings, void *context) {
+    (void) settings;
+    tuning_tones_state_t *state = (tuning_tones_state_t *)context;
+
+    if (state->playing) {
+        state->playing = false;
+        watch_set_buzzer_off();
+    }
+}

movement/watch_faces/complication/tuning_tones_face.h

@@ -0,0 +1,57 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Per Waagø
+ *
+ * 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 TUNING_TONES_FACE_H_
+#define TUNING_TONES_FACE_H_
+
+#include "movement.h"
+
+/*
+ * A DESCRIPTION OF YOUR WATCH FACE
+ *
+ * and a description of how use it
+ *
+ */
+
+typedef struct {
+    // Anything you need to keep track of, put it here!
+    bool playing;
+    size_t note_ind;
+} tuning_tones_state_t;
+
+void tuning_tones_face_setup(movement_settings_t *settings, uint8_t watch_face_index, void ** context_ptr);
+void tuning_tones_face_activate(movement_settings_t *settings, void *context);
+bool tuning_tones_face_loop(movement_event_t event, movement_settings_t *settings, void *context);
+void tuning_tones_face_resign(movement_settings_t *settings, void *context);
+
+#define tuning_tones_face ((const watch_face_t){ \
+    tuning_tones_face_setup, \
+    tuning_tones_face_activate, \
+    tuning_tones_face_loop, \
+    tuning_tones_face_resign, \
+    NULL, \
+})
+
+#endif // TUNING_TONES_FACE_H_
+

watch-library/shared/watch/watch_private_display.c

@@ -93,7 +93,7 @@ void watch_display_character(uint8_t character, uint8_t position) {
     }
 
     if (character == 'T' && position == 1) watch_set_pixel(1, 12); // add descender
-    else if (position == 0 && (character == 'B' || character == 'D')) watch_set_pixel(0, 15); // add funky ninth segment
+    else if (position == 0 && (character == 'B' || character == 'D' || character == '@')) watch_set_pixel(0, 15); // add funky ninth segment
     else if (position == 1 && (character == 'B' || character == 'D' || character == '@')) watch_set_pixel(0, 12); // add funky ninth segment
 }
 

watch-library/shared/watch/watch_utility.c

@@ -102,13 +102,81 @@ uint16_t watch_utility_days_since_new_year(uint16_t year, uint8_t month, uint8_t
     return (is_leap(year) && (month > 2) ? 1 : 0) + DAYS_SO_FAR[month - 1] + day;
 }
 
-uint32_t watch_utility_convert_to_unix_time(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint32_t utc_offset) {
+// Function taken from `src/time/__year_to_secs.c` of musl libc
-    uint32_t year_adj = year + 4800;
+// https://musl.libc.org
-    uint32_t leap_days = 1 + (year_adj / 4) - (year_adj / 100) + (year_adj / 400);
+static uint32_t __year_to_secs(uint32_t year, int *is_leap)
-    uint32_t days = 365 * year_adj + leap_days + watch_utility_days_since_new_year(year, month, day) - 1;
+{
-    days -= 2472692;  /* Adjust to Unix epoch. */
+	if (year-2ULL <= 136) {
+		int y = year;
+		int leaps = (y-68)>>2;
+		if (!((y-68)&3)) {
+			leaps--;
+			if (is_leap) *is_leap = 1;
+		} else if (is_leap) *is_leap = 0;
+		return 31536000*(y-70) + 86400*leaps;
+	}
 
-    uint32_t timestamp = days * 86400;
+	int cycles, centuries, leaps, rem;
+
+	if (!is_leap) is_leap = &(int){0};
+	cycles = (year-100) / 400;
+	rem = (year-100) % 400;
+	if (rem < 0) {
+		cycles--;
+		rem += 400;
+	}
+	if (!rem) {
+		*is_leap = 1;
+		centuries = 0;
+		leaps = 0;
+	} else {
+		if (rem >= 200) {
+			if (rem >= 300) centuries = 3, rem -= 300;
+			else centuries = 2, rem -= 200;
+		} else {
+			if (rem >= 100) centuries = 1, rem -= 100;
+			else centuries = 0;
+		}
+		if (!rem) {
+			*is_leap = 0;
+			leaps = 0;
+		} else {
+			leaps = rem / 4U;
+			rem %= 4U;
+			*is_leap = !rem;
+		}
+	}
+
+	leaps += 97*cycles + 24*centuries - *is_leap;
+
+	return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400;
+}
+
+// Function taken from `src/time/__month_to_secs.c` of musl libc
+// https://musl.libc.org
+static int __month_to_secs(int month, int is_leap)
+{
+	static const int secs_through_month[] = {
+		0, 31*86400, 59*86400, 90*86400,
+		120*86400, 151*86400, 181*86400, 212*86400,
+		243*86400, 273*86400, 304*86400, 334*86400 };
+	int t = secs_through_month[month];
+	if (is_leap && month >= 2) t+=86400;
+	return t;
+}
+
+// Function adapted from `src/time/__tm_to_secs.c` of musl libc
+// https://musl.libc.org
+uint32_t watch_utility_convert_to_unix_time(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint32_t utc_offset) {
+    int is_leap;
+
+    // POSIX tm struct starts year at 1900 and month at 0
+    // https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/time.h.html 
+    uint32_t timestamp = __year_to_secs(year - 1900, &is_leap);
+    timestamp += __month_to_secs(month - 1, is_leap);
+
+    // Regular conversion from musl libc
+    timestamp += (day - 1) * 86400;
     timestamp += hour * 3600;
     timestamp += minute * 60;
     timestamp += second;

watch-library/simulator/shell.html

@@ -37,12 +37,13 @@
     .highlight { fill: #fff !important; }
     #skinselect label {
       display: inline-block;
-      padding: 8px;
+      padding: 4px;
       background-color: black;
       color: white;
       border-radius: 8px;
       border: 2px solid #0e57a9;
       outline: 4px solid black;
+      margin: 4px;
       cursor: pointer;
     }
     #skinselect #a158wea-label {
@@ -50,13 +51,16 @@
       color: black;
       border-color: black;
       outline-color: #b68855ff;
-
+    }
+    h2 {
+      margin: 8px 0;
+      font-size: 1em;
     }
     </style>
 </head>
 <body>
 
-<div style="max-width: 800px; margin: 0 auto; display: flex; flex-direction: column; align-items: center;">
+<div style="max-width: 800px; min-width: 400px; margin: 0 auto; padding: 0 1em; display: flex; flex-direction: column; align-items: center;">
   <h1 style="text-align: center;">Sensor Watch Emulator</h1>
   <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1271 1311" width="320">
     <defs>
@@ -882,18 +886,40 @@
       </g>
     </g>
   </svg>
-  <table cellpadding="5"><tr><td id="skinselect">
-          <input type="radio" id="f91w" name="skin" value="f91w" onclick="toggleSkin()" checked><label for="f91w">F-91W</label>
-      <input type="radio" name="skin" id="a158wea" value="a158wea" onclick="toggleSkin()"><label id="a158wea-label" for="a158wea">A158WEA-9</label>
-  </td><td><a href="https://github.com/alexisphilip/Casio-F-91W">Original F-91W SVG</a> is &copy; 2020 Alexis Philip,<br>used here under the terms of the MIT license.</td></tr></table>
-</div>
 
-<button onclick="getLocation()">Set location register (will prompt for access)</button>
+  <div style="display: grid; grid-template-columns: 80px 1fr; align-items: center; margin: 8px 0">
-<br>
+    <h2>Skin</h2>
-<input id="input" style="width: 500px"></input>
+    <div id="skinselect">
-<button id="submit" onclick="sendText()">Send</button>
+      <input type="radio" name="skin" id="f91w" value="f91w" onclick="setSkin(this.value)" checked><label
-<br>
+        for="f91w">F-91W</label>
-<textarea id="output" rows="8" style="width: 100%"></textarea>
+      <input type="radio" name="skin" id="a158wea9" value="a158wea9" onclick="setSkin(this.value)"><label
+        id="a158wea-label" for="a158wea9">A158WEA-9</label>
+    </div>
+
+    <h2>Volume</h2>
+    <div>
+      <input id="volume" name="volume" type="range" min="0" max="100" step="1" oninput="setVolume(this.value)" />
+    </div>
+
+    <h2>Location</h2>
+    <div>
+      <button onclick="getLocation()">Set register (will prompt for access)</button>
+    </div>
+  </div>
+
+  <div style="display: flex; flex-direction: column; width: 100%">
+    <textarea id="output" rows="8" style="width: 100%"></textarea>
+    <div style="display: flex">
+      <input id="input" placeholder="Filesystem command (see filesystem.c)" style="flex-grow: 1"></input>
+      <button id="submit" onclick="sendText()">Send</button>
+    </div>
+  </div>
+
+  <p>
+    <a href="https://github.com/alexisphilip/Casio-F-91W">Original F-91W SVG</a> is &copy; 2020 Alexis Philip, used here
+    under the terms of the MIT license.
+  </p>
+</div>
 
 <script type='text/javascript'>
   var outputElement = document.getElementById('output');
@@ -967,20 +993,52 @@
     }
   }
 
-  function toggleSkin() {
+  const validSkins = ["f91w", "a158wea9"];
-    var isBlack = document.getElementById('f91w').checked;
+  function setSkin(chosenSkin) {
-    Array.from(document.getElementsByClassName("f91w")).forEach(
+    setLocalPref("skin", chosenSkin);
-        function(element, index, array) {
+    validSkins.forEach(function(skin) {
-            element.setAttribute('style', 'display:' + (isBlack ? 'inline':'none') + ';');
+      Array.from(document.getElementsByClassName(skin)).forEach(
+        function(element) {
+          element.setAttribute('style', 'display:' + (skin == chosenSkin ? 'inline':'none') + ';');
         }
-    );
+      );
-    Array.from(document.getElementsByClassName("a158wea9")).forEach(
+    });
-        function(element, index, array) {
-            element.setAttribute('style', 'display:' + (isBlack ? 'none':'inline') + ';');
-        }
-    );
   }
-  toggleSkin();
+
+  // emulator runs on localhost:8000 which could very well be used by other
+  // things, so we'll scope our localStorage keys with a prefix
+  const localStoragePrefix = "sensorwatch_";
+  function setLocalPref(key, val) {
+    localStorage.setItem(localStoragePrefix+key, val);
+  }
+  function getLocalPref(key, dfault) {
+    let pref = localStorage.getItem(localStoragePrefix+key);
+    if (pref === null) return dfault;
+    return pref;
+  }
+
+  volumeGain = 0.1;
+  function setVolume(vol) {
+    setLocalPref("volume", vol);
+    volumeGain = Math.pow(100, (vol / 100) - 1) - 0.01;
+  }
+
+  function loadPrefs() {
+    let vol = +getLocalPref("volume", "50");
+    if (isNaN(vol) || vol < 0 || vol > 100) {
+      vol = 50;
+    }
+    document.getElementById("volume").value = vol;
+    setVolume(vol);
+
+    let skin = getLocalPref("skin", "f91w");
+    if (!validSkins.includes(skin)) {
+      skin = "f91w";
+    }
+    document.getElementById(skin).checked = true;
+    setSkin(skin);
+  }
+  loadPrefs();
 </script>
 {{{ SCRIPT }}}
 

watch-library/simulator/watch/watch_buzzer.c

@@ -152,7 +152,7 @@ void watch_set_buzzer_on(void) {
         }
 
         audioContext._oscillator.frequency.value = 1e6/$0;
-        audioContext._gain.gain.value = 1;
+        audioContext._gain.gain.value = volumeGain;
     }, buzzer_period);
 }
 

watch-library/simulator/watch/watch_rtc.c

@@ -97,8 +97,7 @@ void watch_rtc_register_periodic_callback(ext_irq_cb_t callback, uint8_t frequen
     // 0x01 (1 Hz) will have 7 leading zeros for PER7. 0xF0 (128 Hz) will have no leading zeroes for PER0.
     uint8_t per_n = __builtin_clz(tmp);
 
-    // this also maps nicely to an index for our list of tick callbacks.
+    double interval = 1000.0 / frequency; // in msec
-    double interval = 1000 / frequency; // in msec
 
     if (tick_callbacks[per_n] != -1) emscripten_clear_interval(tick_callbacks[per_n]);
     tick_callbacks[per_n] = emscripten_set_interval(watch_invoke_periodic_callback, interval, (void *)callback);
@@ -115,7 +114,7 @@ void watch_rtc_disable_periodic_callback(uint8_t frequency) {
 
 void watch_rtc_disable_matching_periodic_callbacks(uint8_t mask) {
     for (int i = 0; i < 8; i++) {
-        if (tick_callbacks[i] != -1 && (mask & (1 << (7 - i))) != 0) {
+        if (tick_callbacks[i] != -1 && (mask & (1 << i)) != 0) {
             emscripten_clear_interval(tick_callbacks[i]);
             tick_callbacks[i] = -1;
         }