mirror/second-movement
3
0
Fork 0
mirror of https://github.com/joeycastillo/second-movement.git synced 2026-02-04 06:25:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #65 from alesgenova/rtc-counter32

Browse Source 
Make movement use the hardware RTC in COUNTER32 mode and other improvements
This commit is contained in:
Joey Castillo
2026-01-03 09:37:59 +08:00
committed by GitHub
parent a1a255cd2a f6fad64eeb
commit 84c119559d
41 changed files with 2730 additions and 1055 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -20,6 +20,9 @@ TINYUSB_CDC=1
# Now we're all set to include gossamer's make rules.
include $(GOSSAMER_PATH)/make.mk
# Don't add gossamer's rtc.c since we are using our own rtc32.c
SRCS := $(filter-out $(GOSSAMER_PATH)/peripherals/rtc.c,$(SRCS))
CFLAGS+=-D_POSIX_C_SOURCE=200112L
define n
@ -136,6 +139,7 @@ INCLUDES += \
-I./watch-library/hardware/watch \
SRCS += \
./watch-library/hardware/watch/rtc32.c \
./watch-library/hardware/watch/watch.c \
./watch-library/hardware/watch/watch_adc.c \
./watch-library/hardware/watch/watch_deepsleep.c \

4
legacy/watch_faces/sensor/accelerometer_data_acquisition_face.c
View File

@ -448,13 +448,13 @@ static void start_reading(accelerometer_data_acquisition_state_t *state) {
state->records[state->pos++] = record;
lis2dw_fifo_t fifo;
lis2dw_read_fifo(&fifo); // dump the fifo, this starts a fresh round of data in continue_reading
lis2dw_read_fifo(&fifo, LIS2DW_FIFO_TIMEOUT); // dump the fifo, this starts a fresh round of data in continue_reading
}
static void continue_reading(accelerometer_data_acquisition_state_t *state) {
printf("Continue reading\n");
lis2dw_fifo_t fifo;
lis2dw_read_fifo(&fifo);
lis2dw_read_fifo(&fifo, LIS2DW_FIFO_TIMEOUT);
fifo.count = min(fifo.count, 25); // hacky, but we need a consistent data rate; if we got a 26th data point, chuck it.
uint8_t offset = 4 * (25 - fifo.count); // also hacky: we're sometimes short at the start. align to beginning of next second.

973
movement.c
View File

File diff suppressed because it is too large Load Diff

64
movement.h
View File

@ -2,6 +2,7 @@
* MIT License
*
* Copyright (c) 2022 Joey Castillo
* Copyright (c) 2025 Alessandro Genova
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -120,20 +121,43 @@ typedef enum {
EVENT_LIGHT_BUTTON_UP, // The light button was pressed for less than half a second, and released.
EVENT_LIGHT_LONG_PRESS, // The light button was held for over half a second, but not yet released.
EVENT_LIGHT_LONG_UP, // The light button was held for over half a second, and released.
EVENT_LIGHT_REALLY_LONG_PRESS, // The light button was held for more than 1.5 second, note yet released.
// EVENT_LIGHT_REALLY_LONG_UP, // The light button was held for more than 1.5 second, and released.
EVENT_MODE_BUTTON_DOWN, // The mode button has been pressed, but not yet released.
EVENT_MODE_BUTTON_UP, // The mode button was pressed for less than half a second, and released.
EVENT_MODE_LONG_PRESS, // The mode button was held for over half a second, but not yet released.
EVENT_MODE_LONG_UP, // The mode button was held for over half a second, and released. NOTE: your watch face will resign immediately after receiving this event.
EVENT_MODE_REALLY_LONG_PRESS, // The mode button was held for more than 1.5 second, note yet released.
// EVENT_MODE_REALLY_LONG_UP, // The mode button was held for more than 1.5 second, and released.
EVENT_ALARM_BUTTON_DOWN, // The alarm button has been pressed, but not yet released.
EVENT_ALARM_BUTTON_UP, // The alarm button was pressed for less than half a second, and released.
EVENT_ALARM_LONG_PRESS, // The alarm button was held for over half a second, but not yet released.
EVENT_ALARM_LONG_UP, // The alarm button was held for over half a second, and released.
EVENT_ALARM_REALLY_LONG_PRESS, // The alarm button was held for more than 1.5 second, note yet released.
// EVENT_ALARM_REALLY_LONG_UP, // The alarm button was held for more than 1.5 second, and released.
EVENT_ACCELEROMETER_WAKE, // The accelerometer has detected motion and woken up.
EVENT_SINGLE_TAP, // Accelerometer detected a single tap. This event is not yet implemented.
EVENT_DOUBLE_TAP, // Accelerometer detected a double tap. This event is not yet implemented.
} movement_event_type_t;
// Each different timeout type will use a different index when invoking watch_rtc_register_comp_callback
typedef enum {
LIGHT_BUTTON_TIMEOUT = 0, // Light button longpress timeout
MODE_BUTTON_TIMEOUT, // Mode button longpress timeout
ALARM_BUTTON_TIMEOUT, // Alarm button longpress timeout
LED_TIMEOUT, // LED off timeout
RESIGN_TIMEOUT, // Resign active face timeout
SLEEP_TIMEOUT, // Low-energy begin timeout
MINUTE_TIMEOUT, // Top of the Minute timeout
} movement_timeout_index_t;
typedef enum {
BUZZER_PRIORITY_BUTTON = 0, // Buzzer priority for button beeps (lowest priority).
BUZZER_PRIORITY_SIGNAL, // Buzzer priority for hourly chime (medium priority).
BUZZER_PRIORITY_ALARM, // Buzzer priority for hourly chime (highest priority).
} movement_buzzer_priority_t;
typedef struct {
uint8_t event_type;
uint8_t subsecond;
@ -249,37 +273,16 @@ typedef struct {
int16_t current_face_idx;
int16_t next_face_idx;
bool watch_face_changed;
bool fast_tick_enabled;
int16_t fast_ticks;
// LED stuff
int16_t light_ticks;
// alarm stuff
int16_t alarm_ticks;
bool is_buzzing;
watch_buzzer_note_t alarm_note;
// button tracking for long press
uint16_t light_down_timestamp;
uint16_t mode_down_timestamp;
uint16_t alarm_down_timestamp;
bool light_on;
// background task handling
bool woke_from_alarm_handler;
bool has_scheduled_background_task;
bool needs_wake;
// low energy mode countdown
int32_t le_mode_ticks;
// app resignation countdown (TODO: consolidate with LE countdown?)
int16_t timeout_ticks;
// stuff for subsecond tracking
uint8_t tick_frequency;
uint8_t last_second;
uint8_t subsecond;
uint8_t tick_pern;
// backup register stuff
uint8_t next_available_backup_register;
@ -296,6 +299,10 @@ typedef struct {
lis2dw_data_rate_t accelerometer_background_rate;
// threshold for considering the wearer is in motion
uint8_t accelerometer_motion_threshold;
// signal and alarm volumes
watch_buzzer_volume_t signal_volume;
watch_buzzer_volume_t alarm_volume;
} movement_state_t;
void movement_move_to_face(uint8_t watch_face_index);
@ -324,9 +331,11 @@ void movement_cancel_background_task_for_face(uint8_t watch_face_index);
void movement_request_sleep(void);
void movement_request_wake(void);
void movement_play_note(watch_buzzer_note_t note, uint16_t duration_ms);
void movement_play_signal(void);
void movement_play_alarm(void);
void movement_play_alarm_beeps(uint8_t rounds, watch_buzzer_note_t alarm_note);
void movement_play_sequence(int8_t *note_sequence, movement_buzzer_priority_t priority);
uint8_t movement_claim_backup_register(void);
@ -339,8 +348,11 @@ void movement_set_timezone_index(uint8_t value);
watch_date_time_t movement_get_utc_date_time(void);
watch_date_time_t movement_get_local_date_time(void);
watch_date_time_t movement_get_date_time_in_zone(uint8_t zone_index);
uint32_t movement_get_utc_timestamp(void);
void movement_set_utc_date_time(watch_date_time_t date_time);
void movement_set_local_date_time(watch_date_time_t date_time);
void movement_set_utc_timestamp(uint32_t timestamp);
bool movement_button_should_sound(void);
void movement_set_button_should_sound(bool value);
@ -348,6 +360,12 @@ void movement_set_button_should_sound(bool value);
watch_buzzer_volume_t movement_button_volume(void);
void movement_set_button_volume(watch_buzzer_volume_t value);
watch_buzzer_volume_t movement_signal_volume(void);
void movement_set_signal_volume(watch_buzzer_volume_t value);
watch_buzzer_volume_t movement_alarm_volume(void);
void movement_set_alarm_volume(watch_buzzer_volume_t value);
movement_clock_mode_t movement_clock_mode_24h(void);
void movement_set_clock_mode_24h(movement_clock_mode_t value);

14
movement_config.h
View File

@ -32,13 +32,13 @@ const watch_face_t watch_faces[] = {
world_clock_face,
sunrise_sunset_face,
moon_phase_face,
stopwatch_face,
fast_stopwatch_face,
countdown_face,
alarm_face,
temperature_display_face,
voltage_face,
settings_face,
set_time_face
set_time_face,
};
#define MOVEMENT_NUM_FACES (sizeof(watch_faces) / sizeof(watch_face_t))
@ -49,7 +49,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 - 4)
#define MOVEMENT_SECONDARY_FACE_INDEX (MOVEMENT_NUM_FACES - 5)
/* Custom hourly chime tune. Check movement_custom_signal_tunes.h for options. */
#define SIGNAL_TUNE_DEFAULT
@ -68,6 +68,8 @@ const watch_face_t watch_faces[] = {
#define MOVEMENT_DEFAULT_BUTTON_SOUND true
#define MOVEMENT_DEFAULT_BUTTON_VOLUME WATCH_BUZZER_VOLUME_SOFT
#define MOVEMENT_DEFAULT_SIGNAL_VOLUME WATCH_BUZZER_VOLUME_LOUD
#define MOVEMENT_DEFAULT_ALARM_VOLUME WATCH_BUZZER_VOLUME_LOUD
/* Set the timeout before switching back to the main watch face
* Valid values are:
@ -100,4 +102,10 @@ const watch_face_t watch_faces[] = {
*/
#define MOVEMENT_DEFAULT_LED_DURATION 1
/* Optionally debounce button presses (disable by default).
* A value of 4 is a good starting point if you have issues
* with multiple button presses firing.
*/
#define MOVEMENT_DEBOUNCE_TICKS 0
#endif // MOVEMENT_CONFIG_H_

1
movement_faces.h
View File

@ -79,4 +79,5 @@
#include "lander_face.h"
#include "simon_face.h"
#include "ping_face.h"
#include "rtccount_face.h"
// New includes go above this line.

1
watch-faces.mk
View File

@ -22,6 +22,7 @@ SRCS += \
./watch-faces/demo/character_set_face.c \
./watch-faces/demo/light_sensor_face.c \
./watch-faces/demo/peek_memory_face.c \
./watch-faces/demo/rtccount_face.c \
./watch-faces/sensor/accelerometer_status_face.c \
./watch-faces/sensor/temperature_display_face.c \
./watch-faces/sensor/temperature_logging_face.c \

20
watch-faces/complication/advanced_alarm_face.c
View File

@ -202,9 +202,16 @@ static void _alarm_update_alarm_enabled(alarm_state_t *state) {
static void _alarm_play_short_beep(uint8_t pitch_idx) {
// play a short double beep
watch_buzzer_play_note(_buzzer_notes[pitch_idx], 50);
watch_buzzer_play_note(BUZZER_NOTE_REST, 50);
watch_buzzer_play_note(_buzzer_notes[pitch_idx], 70);
static int8_t beep_sequence[] = {
0, 4,
BUZZER_NOTE_REST, 4,
0, 6,
0
};
beep_sequence[0] = _buzzer_notes[pitch_idx];
beep_sequence[4] = _buzzer_notes[pitch_idx];
movement_play_sequence(beep_sequence, 0);
}
static void _alarm_indicate_beep(alarm_state_t *state) {
@ -437,14 +444,7 @@ bool advanced_alarm_face_loop(movement_event_t event, void *context) {
// play alarm
if (state->alarm[state->alarm_playing_idx].beeps == 0) {
// short beep
if (watch_is_buzzer_or_led_enabled()) {
_alarm_play_short_beep(state->alarm[state->alarm_playing_idx].pitch);
} else {
// enable, play beep and disable buzzer again
watch_enable_buzzer();
_alarm_play_short_beep(state->alarm[state->alarm_playing_idx].pitch);
watch_disable_buzzer();
}
} else {
// regular alarm beeps
movement_play_alarm_beeps((state->alarm[state->alarm_playing_idx].beeps == (ALARM_MAX_BEEP_ROUNDS - 1) ? 20 : state->alarm[state->alarm_playing_idx].beeps),

24
watch-faces/complication/deadline_face.c
View File

@ -82,26 +82,36 @@ static inline int _days_in_month(int16_t month, int16_t year)
/* Play beep sound based on type */
static inline void _beep(beep_type_t beep_type)
{
static int8_t beep_sequence[] = {
0, 4,
0, 6,
0, 6,
0
};
if (!movement_button_should_sound())
return;
switch (beep_type) {
case BEEP_BUTTON:
watch_buzzer_play_note_with_volume(BUZZER_NOTE_C7, 50, movement_button_volume());
beep_sequence[0] = BUZZER_NOTE_C7;
beep_sequence[2] = 0;
break;
case BEEP_ENABLE:
watch_buzzer_play_note_with_volume(BUZZER_NOTE_G7, 50, movement_button_volume());
watch_buzzer_play_note(BUZZER_NOTE_REST, 75);
watch_buzzer_play_note_with_volume(BUZZER_NOTE_C8, 50, movement_button_volume());
beep_sequence[0] = BUZZER_NOTE_G7;
beep_sequence[2] = BUZZER_NOTE_REST;
beep_sequence[4] = BUZZER_NOTE_C8;
break;
case BEEP_DISABLE:
watch_buzzer_play_note_with_volume(BUZZER_NOTE_C8, 50, movement_button_volume());
watch_buzzer_play_note(BUZZER_NOTE_REST, 75);
watch_buzzer_play_note_with_volume(BUZZER_NOTE_G7, 50, movement_button_volume());
beep_sequence[0] = BUZZER_NOTE_C8;
beep_sequence[2] = BUZZER_NOTE_REST;
beep_sequence[4] = BUZZER_NOTE_G7;
break;
}
movement_play_sequence(beep_sequence, 0);
}
/* Change tick frequency */

473
watch-faces/complication/fast_stopwatch_face.c
View File

@ -2,6 +2,7 @@
* MIT License
*
* Copyright (c) 2022 Andreas Nebinger
* Copyright (c) 2025 Alessandro Genova
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -24,11 +25,13 @@
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "fast_stopwatch_face.h"
#include "watch.h"
#include "watch_common_display.h"
#include "watch_utility.h"
#include "watch_rtc.h"
#include "slcd.h"
/*
This watch face implements the original F-91W stopwatch functionality
@ -40,173 +43,247 @@
turns on on each button press or it doesn't.
*/
#if __EMSCRIPTEN__
#include <emscripten.h>
#include <emscripten/html5.h>
#else
#include "tc.h"
#endif
// distant future for background task: January 1, 2083
static const watch_date_time_t distant_future = {
.unit = {0, 0, 0, 1, 1, 63}
};
static uint32_t _ticks;
static uint32_t _lap_ticks;
static uint8_t _blink_ticks;
static uint32_t _old_seconds;
static uint8_t _old_minutes;
static uint8_t _hours;
static bool _colon;
static bool _is_running;
#if __EMSCRIPTEN__
static long _em_interval_id = 0;
void em_cb_handler(void *userData) {
// interrupt handler for emscripten 128 Hz callbacks
(void) userData;
_ticks++;
}
static void _cb_initialize() { }
static inline void _cb_stop() {
emscripten_clear_interval(_em_interval_id);
_em_interval_id = 0;
_is_running = false;
}
static inline void _cb_start() {
// initiate 128 hz callback
_em_interval_id = emscripten_set_interval(em_cb_handler, (double)(1000/128), (void *)NULL);
}
#else
static inline void _cb_start() {
// start the TC1 timer
tc_enable(1);
_is_running = true;
}
static inline void _cb_stop() {
// stop the TC1 timer
tc_disable(1);
_is_running = false;
}
static void _cb_initialize() {
tc_init(1, GENERIC_CLOCK_3, TC_PRESCALER_DIV4);
tc_set_counter_mode(1, TC_COUNTER_MODE_8BIT);
tc_set_run_in_standby(1, true);
_cb_stop();
tc_count8_set_period(1, 1); // 1024 Hz divided by 4 divided by 2 results in a 128 Hz interrupt
/// FIXME: #SecondMovement, we need a gossamer wrapper for interrupts.
TC1->COUNT8.INTENSET.bit.OVF = 1;
NVIC_ClearPendingIRQ(TC1_IRQn);
NVIC_EnableIRQ (TC1_IRQn);
}
void irq_handler_tc1(void);
void irq_handler_tc1(void) {
// interrupt handler for TC1 (globally!)
_ticks++;
TC1->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF;
}
#endif
// Loosely implement the watch as a state machine
typedef enum {
SW_STATUS_IDLE = 0,
SW_STATUS_RUNNING,
SW_STATUS_RUNNING_LAPPING,
SW_STATUS_STOPPED,
SW_STATUS_STOPPED_LAPPING
} stopwatch_status_t;
static inline void _button_beep() {
// play a beep as confirmation for a button press (if applicable)
if (movement_button_should_sound()) watch_buzzer_play_note_with_volume(BUZZER_NOTE_C7, 50, movement_button_volume());
}
// How quickly should the elapsing time be displayed?
// This is just for looks, timekeeping is always accurate to 128Hz
static const uint8_t DISPLAY_RUNNING_RATE = 32;
static const uint8_t DISPLAY_RUNNING_RATE_SLOW = 2;
/// @brief Display minutes, seconds and fractions derived from 128 Hz tick counter
/// on the lcd.
/// @param ticks
static void _display_ticks(uint32_t ticks) {
char buf[14];
static void _display_elapsed(fast_stopwatch_state_t *state, uint32_t ticks) {
char buf[3];
if (state->slow_refresh && (state->status == SW_STATUS_RUNNING || state->status == SW_STATUS_IDLE)) {
watch_display_character_lp_seconds(' ', 8);
watch_display_character_lp_seconds(' ', 9);
} else {
uint8_t sec_100 = (ticks & 0x7F) * 100 / 128;
watch_display_character_lp_seconds('0' + sec_100 / 10, 8);
watch_display_character_lp_seconds('0' + sec_100 % 10, 9);
}
uint32_t seconds = ticks >> 7;
uint32_t minutes = seconds / 60;
if (_hours) {
sprintf(buf, "%2u", _hours);
watch_display_text(WATCH_POSITION_TOP_RIGHT, buf);
} else {
watch_display_text(WATCH_POSITION_TOP_RIGHT, " ");
if (seconds == state->old_display.seconds) {
return;
}
sprintf(buf, "%02lu%02lu%02u", minutes, (seconds % 60), sec_100);
watch_display_text(WATCH_POSITION_BOTTOM, buf);
}
state->old_display.seconds = seconds;
/// @brief Displays the current stopwatch time on the LCD (more optimized than _display_ticks())
static void _draw() {
if (_lap_ticks == 0) {
char buf[14];
uint8_t sec_100 = (_ticks & 0x7F) * 100 / 128;
if (_is_running) {
uint32_t seconds = _ticks >> 7;
if (seconds != _old_seconds) {
// seconds have changed
_old_seconds = seconds;
uint8_t minutes = seconds / 60;
seconds %= 60;
if (minutes != _old_minutes) {
// minutes have changed, draw everything
_old_minutes = minutes;
minutes %= 60;
if (_hours) {
// with hour indicator
sprintf(buf, "%2u", _hours);
watch_display_text(WATCH_POSITION_TOP_RIGHT, buf);
} else {
// no hour indicator
watch_display_text(WATCH_POSITION_TOP_RIGHT, " ");
}
sprintf(buf, "%02u%02lu%02u", minutes, seconds, sec_100);
watch_display_text(WATCH_POSITION_BOTTOM, buf);
} else {
// just draw seconds
sprintf(buf, "%02lu", seconds);
// note that we're drawing the seconds in the "minutes" position, since this
// watch face uses the "seconds" position for hundredths of seconds
sprintf(buf, "%02lu", seconds % 60);
watch_display_text(WATCH_POSITION_MINUTES, buf);
watch_display_character_lp_seconds('0' + sec_100 / 10, 8);
watch_display_character_lp_seconds('0' + sec_100 % 10, 9);
uint32_t minutes = seconds / 60;
if (minutes == state->old_display.minutes) {
return;
}
state->old_display.minutes = minutes;
sprintf(buf, "%02lu", minutes % 60);
watch_display_text(WATCH_POSITION_HOURS, buf);
uint32_t hours = (minutes / 60) % 24;
if (hours == state->old_display.hours) {
return;
}
state->old_display.hours = hours;
if (hours) {
sprintf(buf, "%2lu", hours);
watch_display_text(WATCH_POSITION_TOP_RIGHT, buf);
} else {
// only draw 100ths of seconds
watch_display_character_lp_seconds('0' + sec_100 / 10, 8);
watch_display_character_lp_seconds('0' + sec_100 % 10, 9);
}
} else {
_display_ticks(_ticks);
}
}
if (_is_running) {
// blink the colon every half second
uint8_t blink_ticks = ((_ticks >> 6) & 1);
if (blink_ticks != _blink_ticks) {
_blink_ticks = blink_ticks;
_colon = !_colon;
if (_colon) watch_set_colon();
else watch_clear_colon();
}
watch_display_text(WATCH_POSITION_TOP_RIGHT, " ");
}
}
static inline void _update_lap_indicator() {
if (_lap_ticks) watch_set_indicator(WATCH_INDICATOR_LAP);
else watch_clear_indicator(WATCH_INDICATOR_LAP);
}
static void _draw_indicators(fast_stopwatch_state_t *state, movement_event_t event, uint32_t elapsed) {
uint8_t subsecond;
bool tock;
static inline void _set_colon() {
switch (state->status) {
case SW_STATUS_RUNNING:
subsecond = elapsed & 127;
tock = subsecond >= 64;
watch_clear_indicator(WATCH_INDICATOR_LAP);
if (tock) {
watch_clear_colon();
} else {
watch_set_colon();
_colon = true;
}
return;
case SW_STATUS_RUNNING_LAPPING:
tock = event.subsecond > 0;
if (tock) {
watch_clear_indicator(WATCH_INDICATOR_LAP);
watch_clear_colon();
} else {
watch_set_indicator(WATCH_INDICATOR_LAP);
watch_set_colon();
}
return;
case SW_STATUS_STOPPED_LAPPING:
watch_set_indicator(WATCH_INDICATOR_LAP);
watch_set_colon();
return;
case SW_STATUS_STOPPED:
case SW_STATUS_IDLE:
default:
watch_clear_indicator(WATCH_INDICATOR_LAP);
watch_set_colon();
return;
}
}
static uint8_t get_refresh_rate(fast_stopwatch_state_t *state) {
switch (state->status) {
case SW_STATUS_RUNNING:
if (state->slow_refresh) {
return DISPLAY_RUNNING_RATE_SLOW;
} else {
return DISPLAY_RUNNING_RATE;
}
case SW_STATUS_RUNNING_LAPPING:
return 2;
case SW_STATUS_STOPPED:
case SW_STATUS_IDLE:
default:
return 1;
}
}
static void state_transition(fast_stopwatch_state_t *state, rtc_counter_t counter, movement_event_type_t event_type) {
switch (state->status) {
case SW_STATUS_IDLE:
switch (event_type) {
case EVENT_ALARM_BUTTON_DOWN:
state->status = SW_STATUS_RUNNING;
state->start_counter = counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_LONG_PRESS:
state->slow_refresh = !state->slow_refresh;
return;
default:
return;
}
case SW_STATUS_RUNNING:
switch (event_type) {
case EVENT_ALARM_BUTTON_DOWN:
state->status = SW_STATUS_STOPPED;
state->stop_counter = counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_BUTTON_DOWN:
state->status = SW_STATUS_RUNNING_LAPPING;
state->lap_counter = counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
default:
return;
}
case SW_STATUS_RUNNING_LAPPING:
switch (event_type) {
case EVENT_ALARM_BUTTON_DOWN:
state->status = SW_STATUS_STOPPED_LAPPING;
state->stop_counter = counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_BUTTON_DOWN:
state->status = SW_STATUS_RUNNING;
state->lap_counter = counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_LONG_PRESS:
state->status = SW_STATUS_RUNNING;
state->slow_refresh = !state->slow_refresh;
movement_request_tick_frequency(get_refresh_rate(state));
return;
default:
return;
}
case SW_STATUS_STOPPED_LAPPING:
switch (event_type) {
case EVENT_ALARM_BUTTON_DOWN:
state->status = SW_STATUS_RUNNING_LAPPING;
state->start_counter = counter - state->stop_counter + state->start_counter;
state->lap_counter = counter - state->stop_counter + state->lap_counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_BUTTON_DOWN:
state->status = SW_STATUS_STOPPED;
return;
default:
return;
}
case SW_STATUS_STOPPED:
switch (event_type) {
case EVENT_ALARM_BUTTON_DOWN:
state->status = SW_STATUS_RUNNING;
state->start_counter = counter - state->stop_counter + state->start_counter;
movement_request_tick_frequency(get_refresh_rate(state));
return;
case EVENT_LIGHT_BUTTON_DOWN:
state->status = SW_STATUS_IDLE;
return;
default:
return;
}
default:
return;
}
}
static uint32_t elapsed_time(fast_stopwatch_state_t *state, rtc_counter_t counter) {
switch (state->status) {
case SW_STATUS_IDLE:
return 0;
case SW_STATUS_RUNNING:
return counter - state->start_counter;
case SW_STATUS_RUNNING_LAPPING:
case SW_STATUS_STOPPED_LAPPING:
return state->lap_counter - state->start_counter;
case SW_STATUS_STOPPED:
return state->stop_counter - state->start_counter;
default:
return 0;
}
}
void fast_stopwatch_face_setup(uint8_t watch_face_index, void ** context_ptr) {
@ -215,114 +292,54 @@ void fast_stopwatch_face_setup(uint8_t watch_face_index, void ** context_ptr) {
*context_ptr = malloc(sizeof(fast_stopwatch_state_t));
memset(*context_ptr, 0, sizeof(fast_stopwatch_state_t));
fast_stopwatch_state_t *state = (fast_stopwatch_state_t *)*context_ptr;
_ticks = _lap_ticks = _blink_ticks = _old_minutes = _old_seconds = _hours = 0;
_is_running = _colon = false;
state->light_on_button = true;
}
if (!_is_running) {
// prepare the 128 Hz callback source
_cb_initialize();
state->start_counter = 0;
state->stop_counter = 0;
state->lap_counter = 0;
state->status = SW_STATUS_IDLE;
}
}
void fast_stopwatch_face_activate(void *context) {
(void) context;
if (_is_running) {
// The background task will keep the watch from entering low energy mode while the stopwatch is on screen.
movement_schedule_background_task(distant_future);
}
fast_stopwatch_state_t *state = (fast_stopwatch_state_t *) context;
// force full re-draw
state->old_display.seconds = UINT_MAX;
state->old_display.minutes = UINT_MAX;
state->old_display.hours = UINT_MAX;
movement_request_tick_frequency(get_refresh_rate(state));
}
bool fast_stopwatch_face_loop(movement_event_t event, void *context) {
fast_stopwatch_state_t *state = (fast_stopwatch_state_t *)context;
// handle overflow of fast ticks
while (_ticks >= (128 * 60 * 60)) {
_ticks -= (128 * 60 * 60);
_hours++;
if (_hours >= 24) _hours -= 24;
// initiate a re-draw
_old_minutes = 59;
}
rtc_counter_t counter = watch_rtc_get_counter();
state_transition(state, counter, event.event_type);
rtc_counter_t elapsed = elapsed_time(state, counter);
switch (event.event_type) {
case EVENT_ACTIVATE:
_set_colon();
watch_display_text_with_fallback(WATCH_POSITION_TOP_LEFT, "STW", "ST");
_update_lap_indicator();
if (_is_running) movement_request_tick_frequency(16);
_display_ticks(_lap_ticks ? _lap_ticks : _ticks);
break;
case EVENT_TICK:
_draw();
break;
case EVENT_LIGHT_LONG_PRESS:
// kind od hidden feature: long press toggles light on or off
state->light_on_button = !state->light_on_button;
if (state->light_on_button) movement_illuminate_led();
else watch_set_led_off();
_draw_indicators(state, event, elapsed);
_display_elapsed(state, elapsed);
break;
case EVENT_ALARM_BUTTON_DOWN:
_is_running = !_is_running;
if (_is_running) {
// start or continue stopwatch
movement_request_tick_frequency(16);
// register 128 hz callback for time measuring
_cb_start();
// schedule the keepalive task when running
movement_schedule_background_task(distant_future);
} else {
// stop the stopwatch
_cb_stop();
movement_request_tick_frequency(1);
_set_colon();
// cancel the keepalive task
movement_cancel_background_task();
}
_draw();
_button_beep();
break;
case EVENT_LIGHT_BUTTON_DOWN:
if (state->light_on_button) movement_illuminate_led();
if (_is_running) {
if (_lap_ticks) {
// clear lap and continue running
_lap_ticks = 0;
movement_request_tick_frequency(16);
} else {
// set lap ticks and stop updating the display
_lap_ticks = _ticks;
movement_request_tick_frequency(2);
_set_colon();
}
} else {
if (_lap_ticks) {
// clear lap and show running stopwatch
_lap_ticks = 0;
} else if (_ticks) {
// reset stopwatch
_ticks = _lap_ticks = _blink_ticks = _old_minutes = _old_seconds = _hours = 0;
case EVENT_LIGHT_LONG_PRESS:
_button_beep();
}
}
_display_ticks(_ticks);
_update_lap_indicator();
break;
case EVENT_TIMEOUT:
if (!_is_running) movement_move_to_face(0);
break;
case EVENT_LOW_ENERGY_UPDATE:
_draw();
// fall through
case EVENT_TICK:
_draw_indicators(state, event, elapsed);
_display_elapsed(state, elapsed);
break;
default:
movement_default_loop_handler(event);
break;
}
return true;
}
void fast_stopwatch_face_resign(void *context) {
(void) context;
// cancel the keepalive task
movement_cancel_background_task();
movement_request_tick_frequency(1);
}

17
watch-faces/complication/fast_stopwatch_face.h
View File

@ -55,7 +55,16 @@
#include "movement.h"
typedef struct {
bool light_on_button; // determines whether the light button actually triggers the led
rtc_counter_t start_counter; // rtc counter when the stopwatch was started
rtc_counter_t lap_counter; // rtc counter when the stopwatch was lapped
rtc_counter_t stop_counter; // rtc counter when the stopwatch was stopped
uint8_t status; // the status the stopwatch is in (idle, running, stopped)
bool slow_refresh; // update the display slowly (same 128Hz timekeeping accuracy)
struct {
rtc_counter_t seconds;
rtc_counter_t minutes;
rtc_counter_t hours;
} old_display; // the digits currently being displayed on screen
} fast_stopwatch_state_t;
void fast_stopwatch_face_setup(uint8_t watch_face_index, void ** context_ptr);
@ -63,12 +72,6 @@ void fast_stopwatch_face_activate(void *context);
bool fast_stopwatch_face_loop(movement_event_t event, void *context);
void fast_stopwatch_face_resign(void *context);
#if __EMSCRIPTEN__
void em_cb_handler(void *userData);
#else
void TC2_Handler(void);
#endif
#define fast_stopwatch_face ((const watch_face_t){ \
fast_stopwatch_face_setup, \
fast_stopwatch_face_activate, \

3
watch-faces/complication/interval_face.c
View File

@ -96,8 +96,7 @@ static inline void _inc_uint8(uint8_t *value, uint8_t step, uint8_t max) {
static uint32_t _get_now_ts() {
// returns the current date time as unix timestamp
watch_date_time_t now = watch_rtc_get_date_time();
return watch_utility_date_time_to_unix_time(now, 0);
return movement_get_utc_timestamp();
}
static inline void _button_beep() {

18
watch-faces/complication/simon_face.c
View File

@ -119,30 +119,22 @@ static void _simon_play_note(SimonNote note, simon_state_t *state, bool skip_res
switch (note) {
case SIMON_LED_NOTE:
if (!state->lightOff) watch_set_led_yellow();
if (state->soundOff)
if (!state->soundOff) watch_buzzer_play_note(BUZZER_NOTE_D3, _delay_beep);
delay_ms(_delay_beep);
else
watch_buzzer_play_note(BUZZER_NOTE_D3, _delay_beep);
break;
case SIMON_MODE_NOTE:
if (!state->lightOff) watch_set_led_red();
if (state->soundOff)
if (!state->soundOff) watch_buzzer_play_note(BUZZER_NOTE_E4, _delay_beep);
delay_ms(_delay_beep);
else
watch_buzzer_play_note(BUZZER_NOTE_E4, _delay_beep);
break;
case SIMON_ALARM_NOTE:
if (!state->lightOff) watch_set_led_green();
if (state->soundOff)
if (!state->soundOff) watch_buzzer_play_note(BUZZER_NOTE_C3, _delay_beep);
delay_ms(_delay_beep);
else
watch_buzzer_play_note(BUZZER_NOTE_C3, _delay_beep);
break;
case SIMON_WRONG_NOTE:
if (state->soundOff)
if (!state->soundOff) watch_buzzer_play_note(BUZZER_NOTE_A1, 800);
delay_ms(800);
else
watch_buzzer_play_note(BUZZER_NOTE_A1, 800);
break;
}
watch_set_led_off();
@ -150,7 +142,7 @@ static void _simon_play_note(SimonNote note, simon_state_t *state, bool skip_res
if (note != SIMON_WRONG_NOTE) {
_simon_clear_display(state);
if (!skip_rest) {
watch_buzzer_play_note(BUZZER_NOTE_REST, (_delay_beep * 2)/3);
delay_ms((_delay_beep * 2)/3);
}
}
}

22
watch-faces/complication/tally_face.c
View File

@ -110,6 +110,12 @@ static bool tally_face_should_move_back(tally_state_t *state) {
bool tally_face_loop(movement_event_t event, void *context) {
tally_state_t *state = (tally_state_t *)context;
static bool using_led = false;
static int8_t beep_sequence[] = {
0, 2,
BUZZER_NOTE_REST, 3,
0, 2,
0
};
if (using_led) {
if(!HAL_GPIO_BTN_MODE_read() && !HAL_GPIO_BTN_LIGHT_read() && !HAL_GPIO_BTN_ALARM_read())
@ -148,9 +154,11 @@ bool tally_face_loop(movement_event_t event, void *context) {
state->tally_idx = _tally_default[state->tally_default_idx]; // reset tally index
_init_val = true;
//play a reset tune
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_G6, 30);
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_REST, 30);
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_E6, 30);
if (movement_button_should_sound()) {
beep_sequence[0] = BUZZER_NOTE_G6;
beep_sequence[4] = BUZZER_NOTE_E6;
movement_play_sequence(beep_sequence, 0);
}
print_tally(state, movement_button_should_sound());
}
break;
@ -168,9 +176,11 @@ bool tally_face_loop(movement_event_t event, void *context) {
if (TALLY_FACE_PRESETS_SIZE() > 1 && _init_val){
state->tally_default_idx = (state->tally_default_idx + 1) % TALLY_FACE_PRESETS_SIZE();
state->tally_idx = _tally_default[state->tally_default_idx];
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_E6, 30);
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_REST, 30);
if (movement_button_should_sound()) watch_buzzer_play_note(BUZZER_NOTE_G6, 30);
if (movement_button_should_sound()) {
beep_sequence[0] = BUZZER_NOTE_E6;
beep_sequence[4] = BUZZER_NOTE_G6;
movement_play_sequence(beep_sequence, 0);
}
print_tally(state, movement_button_should_sound());
}
else{

3
watch-faces/complication/totp_face.c
View File

@ -36,7 +36,6 @@
#include <string.h>
#include "totp_face.h"
#include "watch.h"
#include "watch_utility.h"
#include "TOTP.h"
#include "base32.h"
@ -159,7 +158,7 @@ static void totp_generate_and_display(totp_state_t *totp_state) {
}
static inline uint32_t totp_compute_base_timestamp() {
return watch_utility_date_time_to_unix_time(movement_get_utc_date_time(), 0);
return movement_get_utc_timestamp();
}
void totp_face_setup(uint8_t watch_face_index, void ** context_ptr) {

3
watch-faces/complication/totp_lfs_face.c
View File

@ -30,7 +30,6 @@
#include "base32.h"
#include "watch.h"
#include "watch_utility.h"
#include "filesystem.h"
#include "totp_lfs_face.h"
@ -253,7 +252,7 @@ void totp_lfs_face_activate(void *context) {
}
#endif
totp_state->timestamp = watch_utility_date_time_to_unix_time(movement_get_utc_date_time(), 0);
totp_state->timestamp = movement_get_utc_timestamp();
totp_face_set_record(totp_state, 0);
}

204
watch-faces/demo/rtccount_face.c Normal file
View File

@ -0,0 +1,204 @@
/*
* MIT License
*
* Copyright (c) 2025 Alessandro Genova
*
* 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 "rtccount_face.h"
#include "watch.h"
#include "sam.h"
#include "watch_utility.h"
#include "watch_common_display.h"
#include "watch_rtc.h"
typedef enum {
RTCCOUNT_STATUS_COUNTER = 0,
RTCCOUNT_STATUS_COUNTER_SUB,
RTCCOUNT_STATUS_MINUTES,
RTCCOUNT_STATUS_MINUTES_DIFF,
RTCCOUNT_STATUS_NUMBER
} rtccount_face_status_t;
typedef struct {
rtccount_face_status_t status;
uint8_t frequency;
uint32_t n_top_of_minute;
uint32_t ref_timestamp;
} rtccount_state_t;
static const uint32_t COUNTER_MASK = (1 << 19) - 1;
static void _rtccount_face_display_string(char* string, uint8_t pos) {
// watch_display_string is deprecated, but there is no alternative for this use-case
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
watch_display_string(string, pos);
#pragma GCC diagnostic pop
}
static void _rtccount_face_draw(movement_event_t event, rtccount_state_t* state) {
uint32_t counter = watch_rtc_get_counter();
char buf[11] = " 000000\0";
switch (state->status) {
case RTCCOUNT_STATUS_COUNTER: {
buf[0] = 'C';
break;
}
case RTCCOUNT_STATUS_COUNTER_SUB: {
buf[0] = 'S';
break;
}
case RTCCOUNT_STATUS_MINUTES: {
buf[0] = 'M';
break;
}
case RTCCOUNT_STATUS_MINUTES_DIFF: {
buf[0] = 'D';
break;
}
default:
break;
}
_rtccount_face_display_string(buf, 0);
snprintf(buf, sizeof(buf), "%u", event.subsecond);
uint32_t len = strlen(buf);
_rtccount_face_display_string(buf, 4 - len);
switch (state->status) {
case RTCCOUNT_STATUS_COUNTER: {
snprintf(buf, sizeof(buf), "%lu", counter & COUNTER_MASK);
size_t len = strlen(buf);
_rtccount_face_display_string(buf, 10 - len);
break;
}
case RTCCOUNT_STATUS_COUNTER_SUB: {
snprintf(buf, sizeof(buf), "%lu", counter & 127);
size_t len = strlen(buf);
_rtccount_face_display_string(buf, 10 - len);
break;
}
case RTCCOUNT_STATUS_MINUTES: {
snprintf(buf, sizeof(buf), "%lu", state->n_top_of_minute & COUNTER_MASK);
size_t len = strlen(buf);
_rtccount_face_display_string(buf, 10 - len);
break;
}
case RTCCOUNT_STATUS_MINUTES_DIFF: {
uint32_t elapsed_minutes = (movement_get_utc_timestamp() - state->ref_timestamp) / 60;
snprintf(buf, sizeof(buf), "%lu", (elapsed_minutes - state->n_top_of_minute) & COUNTER_MASK);
size_t len = strlen(buf);
_rtccount_face_display_string(buf, 10 - len);
break;
}
default:
break;
}
}
void rtccount_face_setup(uint8_t watch_face_index, void ** context_ptr) {
(void) watch_face_index;
if (*context_ptr == NULL) {
*context_ptr = malloc(sizeof(rtccount_state_t));
memset(*context_ptr, 0, sizeof(rtccount_state_t));
rtccount_state_t *state = (rtccount_state_t *) *context_ptr;
state->status = RTCCOUNT_STATUS_COUNTER;
state->frequency = 1;
state->n_top_of_minute = 0;
rtc_date_time_t datetime = movement_get_utc_date_time();
state->ref_timestamp = movement_get_utc_timestamp() - datetime.unit.second;
}
}
void rtccount_face_activate(void *context) {
rtccount_state_t* state = (rtccount_state_t*)context;
movement_request_tick_frequency(state->frequency);
}
bool rtccount_face_loop(movement_event_t event, void *context) {
rtccount_state_t* state = (rtccount_state_t*)context;
switch (event.event_type) {
case EVENT_BACKGROUND_TASK:
state->n_top_of_minute += 1;
break;
case EVENT_ALARM_BUTTON_UP:
if (state->frequency == 128) {
state->frequency = 1;
} else {
state->frequency *= 2;
}
movement_request_tick_frequency(state->frequency);
break;
case EVENT_ALARM_LONG_PRESS:
state->n_top_of_minute = 0;
rtc_date_time_t datetime = movement_get_utc_date_time();
state->ref_timestamp = movement_get_utc_timestamp() - datetime.unit.second;
break;
case EVENT_LIGHT_BUTTON_DOWN:
state->status = (state->status + 1) % RTCCOUNT_STATUS_NUMBER;
_rtccount_face_draw(event, state);
break;
case EVENT_ACTIVATE:
case EVENT_TICK:
_rtccount_face_draw(event, state);
break;
default:
movement_default_loop_handler(event);
break;
}
return true;
}
void rtccount_face_resign(void *context) {
(void) context;
movement_request_tick_frequency(1);
}
movement_watch_face_advisory_t rtccount_face_advise(void *context) {
(void) context;
movement_watch_face_advisory_t retval = { 0 };
retval.wants_background_task = true;
return retval;
}

47
watch-faces/demo/rtccount_face.h Normal file
View File

@ -0,0 +1,47 @@
/*
* MIT License
*
* Copyright (c) 2025 Alessandro Genova
*
* 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
/*
* RTCCOUNT FACE
*
* A test face to inspect some metrics of the rtc-counter32 mode.
*/
#include "movement.h"
void rtccount_face_setup(uint8_t watch_face_index, void ** context_ptr);
void rtccount_face_activate(void *context);
bool rtccount_face_loop(movement_event_t event, void *context);
void rtccount_face_resign(void *context);
movement_watch_face_advisory_t rtccount_face_advise(void *context);
#define rtccount_face ((const watch_face_t){ \
rtccount_face_setup, \
rtccount_face_activate, \
rtccount_face_loop, \
rtccount_face_resign, \
rtccount_face_advise, \
})

148
watch-faces/io/chirpy_demo_face.c
View File

@ -47,9 +47,6 @@ typedef struct {
// Selected program
chirpy_demo_program_t program;
// Helps us handle 1/64 ticks during transmission; including countdown timer
chirpy_tick_state_t tick_state;
// Used by chirpy encoder during transmission
chirpy_encoder_state_t encoder_state;
@ -150,46 +147,10 @@ static void _cdf_update_lcd(chirpy_demo_state_t *state) {
}
}
static void _cdf_quit_chirping(chirpy_demo_state_t *state) {
state->mode = CDM_CHOOSE;
watch_set_buzzer_off();
watch_clear_indicator(WATCH_INDICATOR_BELL);
movement_request_tick_frequency(1);
}
static void _cdf_scale_tick(void *context) {
chirpy_demo_state_t *state = (chirpy_demo_state_t *)context;
chirpy_tick_state_t *tick_state = &state->tick_state;
// Scale goes in 200Hz increments from 700 Hz to 12.3 kHz -> 58 steps
if (tick_state->seq_pos == 58) {
_cdf_quit_chirping(state);
return;
}
uint32_t freq = 700 + tick_state->seq_pos * 200;
uint32_t period = 1000000 / freq;
watch_set_buzzer_period_and_duty_cycle(period, 25);
watch_set_buzzer_on();
++tick_state->seq_pos;
}
static void _cdf_data_tick(void *context) {
chirpy_demo_state_t *state = (chirpy_demo_state_t *)context;
uint8_t tone = chirpy_get_next_tone(&state->encoder_state);
// Transmission over?
if (tone == 255) {
_cdf_quit_chirping(state);
return;
}
uint16_t period = chirpy_get_tone_period(tone);
watch_set_buzzer_period_and_duty_cycle(period, 25);
watch_set_buzzer_on();
}
static uint8_t *curr_data_ptr;
static uint16_t curr_data_ix;
static uint16_t curr_data_len;
static chirpy_demo_state_t *curr_state;
static uint8_t _cdf_get_next_byte(uint8_t *next_byte) {
if (curr_data_ix == curr_data_len)
@ -199,25 +160,46 @@ static uint8_t _cdf_get_next_byte(uint8_t *next_byte) {
return 1;
}
static void _cdf_countdown_tick(void *context) {
chirpy_demo_state_t *state = (chirpy_demo_state_t *)context;
chirpy_tick_state_t *tick_state = &state->tick_state;
// Countdown over: start actual broadcast
if (tick_state->seq_pos == 8 * 3) {
tick_state->tick_compare = 3;
tick_state->tick_count = -1;
tick_state->seq_pos = 0;
// We'll be chirping out a scale
if (false) { // state->program == CDP_CLEAR) {
tick_state->tick_fun = _cdf_scale_tick;
static void _cdf_on_chirping_done(void) {
if (curr_state) {
curr_state->mode = CDM_CHOOSE;
}
// We'll be chirping out data
else {
// Set up the encoder
chirpy_init_encoder(&state->encoder_state, _cdf_get_next_byte);
tick_state->tick_fun = _cdf_data_tick;
watch_clear_indicator(WATCH_INDICATOR_BELL);
}
static bool _cdm_raw_source_fn(uint16_t position, void* userdata, uint16_t* period, uint16_t* duration) {
// Beep countdown
if (position < 6) {
if (position % 2) {
*period = WATCH_BUZZER_PERIOD_REST;
*duration = 56;
} else {
*period = NotePeriods[BUZZER_NOTE_A5];
*duration = 8;
}
return false;
}
chirpy_demo_state_t *state = (chirpy_demo_state_t *)userdata;
uint8_t tone = chirpy_get_next_tone(&state->encoder_state);
// Transmission over?
if (tone == 255) {
return true;
}
*period = chirpy_get_tone_period(tone);
*duration = 3;
return false;
}
static void _cdm_start_transmission(chirpy_demo_state_t *state) {
watch_set_indicator(WATCH_INDICATOR_BELL);
state->mode = CDM_CHIRPING;
// Set up the data
curr_state = state;
curr_data_ix = 0;
if (state->program == CDP_INFO_SHORT) {
curr_data_ptr = short_data;
@ -229,29 +211,9 @@ static void _cdf_countdown_tick(void *context) {
curr_data_ptr = activity_buffer;
curr_data_len = activity_buffer_size;
}
}
return;
}
// Sound or turn off buzzer
if ((tick_state->seq_pos % 8) == 0) {
watch_set_buzzer_period_and_duty_cycle(NotePeriods[BUZZER_NOTE_A5], 25);
watch_set_buzzer_on();
} else if ((tick_state->seq_pos % 8) == 1) {
watch_set_buzzer_off();
}
++tick_state->seq_pos;
}
static void _cdm_setup_chirp(chirpy_demo_state_t *state) {
// We want frequent callbacks from now on
movement_request_tick_frequency(64);
watch_set_indicator(WATCH_INDICATOR_BELL);
state->mode = CDM_CHIRPING;
// Set up tick state; start with countdown
state->tick_state.tick_count = -1;
state->tick_state.tick_compare = 8;
state->tick_state.seq_pos = 0;
state->tick_state.tick_fun = _cdf_countdown_tick;
chirpy_init_encoder(&state->encoder_state, _cdf_get_next_byte);
watch_buzzer_play_raw_source(_cdm_raw_source_fn, state, _cdf_on_chirping_done);
}
bool chirpy_demo_face_loop(movement_event_t event, void *context) {
@ -261,12 +223,7 @@ bool chirpy_demo_face_loop(movement_event_t event, void *context) {
case EVENT_ACTIVATE:
_cdf_update_lcd(state);
break;
case EVENT_MODE_BUTTON_UP:
// Do not exit face while we're chirping
if (state->mode != CDM_CHIRPING) {
movement_move_to_next_face();
}
break;
case EVENT_LIGHT_BUTTON_DOWN:
case EVENT_LIGHT_BUTTON_UP:
// We don't do light.
break;
@ -286,10 +243,6 @@ bool chirpy_demo_face_loop(movement_event_t event, void *context) {
state->program = CDP_CLEAR;
_cdf_update_lcd(state);
}
// If chirping: stoppit
else if (state->mode == CDM_CHIRPING) {
_cdf_quit_chirping(state);
}
break;
case EVENT_ALARM_LONG_PRESS:
// If in choose mode: start chirping
@ -299,16 +252,7 @@ bool chirpy_demo_face_loop(movement_event_t event, void *context) {
movement_force_led_off();
movement_move_to_next_face();
} else {
_cdm_setup_chirp(state);
}
}
break;
case EVENT_TICK:
if (state->mode == CDM_CHIRPING) {
++state->tick_state.tick_count;
if (state->tick_state.tick_count == state->tick_state.tick_compare) {
state->tick_state.tick_count = 0;
state->tick_state.tick_fun(context);
_cdm_start_transmission(state);
}
}
break;
@ -317,14 +261,12 @@ bool chirpy_demo_face_loop(movement_event_t event, void *context) {
if (state->mode != CDM_CHIRPING) {
movement_move_to_face(0);
}
// fall through
default:
movement_default_loop_handler(event);
break;
}
// Return true if the watch can enter standby mode. False needed when chirping.
if (state->mode == CDM_CHIRPING)
return false;
else
return true;
}

2
watch-faces/sensor/lis2dw_monitor_face.c
View File

@ -420,7 +420,7 @@ static void _monitor_update(lis2dw_monitor_state_t *state)
lis2dw_fifo_t fifo;
float x = 0, y = 0, z = 0;
lis2dw_read_fifo(&fifo);
lis2dw_read_fifo(&fifo, LIS2DW_FIFO_TIMEOUT / DISPLAY_FREQUENCY);
if (fifo.count == 0) {
return;
}

23
watch-faces/settings/finetune_face.c
View File

@ -27,7 +27,6 @@
#include <math.h>
#include "finetune_face.h"
#include "nanosec_face.h"
#include "watch_utility.h"
#include "delay.h"
extern nanosec_state_t nanosec_state;
@ -51,7 +50,7 @@ void finetune_face_activate(void *context) {
}
static float finetune_get_hours_passed(void) {
uint32_t current_time = watch_utility_date_time_to_unix_time(watch_rtc_get_date_time(), 0);
uint32_t current_time = movement_get_utc_timestamp();
return (current_time - nanosec_state.last_correction_time) / 3600.0f;
}
@ -64,7 +63,7 @@ static void finetune_update_display(void) {
if (finetune_page == 0) {
watch_display_text_with_fallback(WATCH_POSITION_TOP_LEFT, "FTU", "FT");
watch_date_time_t date_time = watch_rtc_get_date_time();
watch_date_time_t date_time = movement_get_utc_date_time();
sprintf(buf, "%04d%02d", abs(total_adjustment), date_time.unit.second);
watch_display_text(WATCH_POSITION_BOTTOM, buf);
@ -106,17 +105,9 @@ static void finetune_adjust_subseconds(int delta) {
watch_rtc_enable(false);
delay_ms(delta);
if (delta > 500) {
watch_date_time_t date_time = watch_rtc_get_date_time();
date_time.unit.second = (date_time.unit.second + 1) % 60;
if (date_time.unit.second == 0) { // Overflow
date_time.unit.minute = (date_time.unit.minute + 1) % 60;
if (date_time.unit.minute == 0) { // Overflow
date_time.unit.hour = (date_time.unit.hour + 1) % 24;
if (date_time.unit.hour == 0) // Overflow
date_time.unit.day++;
}
}
watch_rtc_set_date_time(date_time);
uint32_t timestamp = movement_get_utc_timestamp();
timestamp += 1;
movement_set_utc_timestamp(timestamp);
}
watch_rtc_enable(true);
}
@ -126,7 +117,7 @@ static void finetune_update_correction_time(void) {
nanosec_state.freq_correction += roundf(nanosec_get_aging() * 100);
// Remember when we last corrected time
nanosec_state.last_correction_time = watch_utility_date_time_to_unix_time(watch_rtc_get_date_time(), 0);
nanosec_state.last_correction_time = movement_get_utc_timestamp();
nanosec_save();
movement_move_to_face(0); // Go to main face after saving settings
}
@ -146,7 +137,7 @@ bool finetune_face_loop(movement_event_t event, void *context) {
// We flash green LED once per minute to measure clock error, when we are not on first screen
if (finetune_page!=0) {
watch_date_time_t date_time;
date_time = watch_rtc_get_date_time();
date_time = movement_get_utc_date_time();
if (date_time.unit.second == 0) {
watch_set_led_green();
#ifndef __EMSCRIPTEN__

5
watch-faces/settings/finetune_face.h
View File

@ -44,11 +44,6 @@
* worry about aging only on second/third years of watch calibration (if you
* are really looking at less than 10 seconds per year of error).
*
* Warning, do not use at the first second of a month, as you might stay at
* the same month and it will surprise you. Just wait 1 second...We are not
* fully replicating RTC timer behavior when RTC is off.
* Simulating months and years is... too much complexity.
*
* For full usage instructions, please refer to the wiki:
* https://www.sensorwatch.net/docs/watchfaces/nanosec/
*/

10
watch-faces/settings/nanosec_face.c
View File

@ -27,7 +27,6 @@
#include <math.h>
#include "nanosec_face.h"
#include "filesystem.h"
#include "watch_utility.h"
int16_t freq_correction_residual = 0; // Dithering 0.1ppm correction, does not need to be configured.
int16_t freq_correction_previous = -30000;
@ -44,8 +43,7 @@ const float voltage_coefficient = 0.241666667 * dithering; // 10 * ppm/V. Nomina
static void nanosec_init_profile(void) {
nanosec_changed = true;
nanosec_state.correction_cadence = 10;
watch_date_time_t date_time = watch_rtc_get_date_time();
nanosec_state.last_correction_time = watch_utility_date_time_to_unix_time(date_time, 0);
nanosec_state.last_correction_time = movement_get_utc_timestamp();
// init data after changing profile - do that once per profile selection
switch (nanosec_state.correction_profile) {
@ -265,8 +263,8 @@ static void nanosec_next_edit_screen(void) {
float nanosec_get_aging() // Returns aging correction in ppm
{
watch_date_time_t date_time = watch_rtc_get_date_time();
float years = (watch_utility_date_time_to_unix_time(date_time, 0) - nanosec_state.last_correction_time) / 31536000.0f; // Years passed since finetune
uint32_t timestamp = movement_get_utc_timestamp();
float years = (timestamp - nanosec_state.last_correction_time) / 31536000.0f; // Years passed since finetune
return years*nanosec_state.aging_ppm_pa/100.0f;
}
@ -377,7 +375,7 @@ movement_watch_face_advisory_t nanosec_face_advise(void *context) {
// No need for background correction if we are on profile 0 - static hardware correction.
if (nanosec_state.correction_profile != 0) {
watch_date_time_t date_time = watch_rtc_get_date_time();
watch_date_time_t date_time = movement_get_utc_date_time();
retval.wants_background_task = date_time.unit.minute % nanosec_state.correction_cadence == 0;
}

6
watch-faces/settings/set_time_face.c
View File

@ -108,10 +108,6 @@ bool set_time_face_loop(movement_event_t event, void *context) {
case EVENT_ALARM_LONG_UP:
_abort_quick_ticks();
break;
case EVENT_MODE_BUTTON_UP:
_abort_quick_ticks();
movement_move_to_next_face();
return false;
case EVENT_LIGHT_BUTTON_DOWN:
current_page = (current_page + 1) % SET_TIME_FACE_NUM_SETTINGS;
*((uint8_t *)context) = current_page;
@ -187,6 +183,6 @@ bool set_time_face_loop(movement_event_t event, void *context) {
void set_time_face_resign(void *context) {
(void) context;
watch_set_led_off();
movement_store_settings();
movement_request_tick_frequency(1);
}

70
watch-faces/settings/settings_face.c
View File

@ -77,6 +77,64 @@ static void beep_setting_advance(void) {
}
}
static void signal_setting_display(uint8_t subsecond) {
watch_display_text_with_fallback(WATCH_POSITION_TOP_LEFT, "SIG", "SI");
watch_display_text(WATCH_POSITION_BOTTOM, "SIGNAL");
if (subsecond % 2) {
if (movement_signal_volume() == WATCH_BUZZER_VOLUME_LOUD) {
// H for HIGH
watch_display_text(WATCH_POSITION_TOP_RIGHT, " H");
}
else {
// L for LOW
watch_display_text(WATCH_POSITION_TOP_RIGHT, " L");
}
}
}
static void signal_setting_advance(void) {
if (movement_signal_volume() == WATCH_BUZZER_VOLUME_SOFT) {
// was soft. make it loud.
movement_set_signal_volume(WATCH_BUZZER_VOLUME_LOUD);
} else {
// was loud. make it soft.
movement_set_signal_volume(WATCH_BUZZER_VOLUME_SOFT);
}
signal_setting_display(1);
movement_play_signal();
}
static void alarm_setting_display(uint8_t subsecond) {
watch_display_text_with_fallback(WATCH_POSITION_TOP_LEFT, "ALM", "AL");
watch_display_text(WATCH_POSITION_BOTTOM, "ALARM ");
if (subsecond % 2) {
if (movement_alarm_volume() == WATCH_BUZZER_VOLUME_LOUD) {
// H for HIGH
watch_display_text(WATCH_POSITION_TOP_RIGHT, " H");
}
else {
// L for LOW
watch_display_text(WATCH_POSITION_TOP_RIGHT, " L");
}
}
}
static void alarm_setting_advance(void) {
if (movement_alarm_volume() == WATCH_BUZZER_VOLUME_SOFT) {
// was soft. make it loud.
movement_set_alarm_volume(WATCH_BUZZER_VOLUME_LOUD);
} else {
// was loud. make it soft.
movement_set_alarm_volume(WATCH_BUZZER_VOLUME_SOFT);
}
alarm_setting_display(1);
movement_play_alarm();
}
static void timeout_setting_display(uint8_t subsecond) {
watch_display_text_with_fallback(WATCH_POSITION_TOP, "TMOUt", "TO");
if (subsecond % 2) {
@ -235,7 +293,7 @@ void settings_face_setup(uint8_t watch_face_index, void ** context_ptr) {
settings_state_t *state = (settings_state_t *)*context_ptr;
int8_t current_setting = 0;
state->num_settings = 5; // baseline, without LED settings
state->num_settings = 7; // baseline, without LED settings
#ifdef BUILD_GIT_HASH
state->num_settings++;
#endif
@ -256,6 +314,12 @@ void settings_face_setup(uint8_t watch_face_index, void ** context_ptr) {
state->settings_screens[current_setting].display = beep_setting_display;
state->settings_screens[current_setting].advance = beep_setting_advance;
current_setting++;
state->settings_screens[current_setting].display = signal_setting_display;
state->settings_screens[current_setting].advance = signal_setting_advance;
current_setting++;
state->settings_screens[current_setting].display = alarm_setting_display;
state->settings_screens[current_setting].advance = alarm_setting_advance;
current_setting++;
state->settings_screens[current_setting].display = timeout_setting_display;
state->settings_screens[current_setting].advance = timeout_setting_advance;
current_setting++;
@ -322,7 +386,7 @@ bool settings_face_loop(movement_event_t event, void *context) {
case EVENT_MODE_BUTTON_UP:
movement_force_led_off();
movement_move_to_next_face();
return false;
return true;
case EVENT_ALARM_BUTTON_UP:
state->settings_screens[state->current_page].advance();
break;
@ -339,7 +403,7 @@ bool settings_face_loop(movement_event_t event, void *context) {
movement_force_led_on(color.red | color.red << 4,
color.green | color.green << 4,
color.blue | color.blue << 4);
return false;
return true;
} else {
movement_force_led_off();
return true;

6
watch-faces/settings/settings_face.h
View File

@ -45,6 +45,12 @@
* a beep when pressed, and if so, how loud it should be. Options are
* "Y" for yes and "N" for no.
*
* SI / SIG - Signal beep.
* This setting allows you to choose the hourly chime buzzer volume.
*
* AL / ALM - Alarm beep.
* This setting allows you to choose the alarm buzzer volume.
*
* TO / Tmout - 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

136
watch-library/hardware/watch/rtc32.c Normal file
View File

@ -0,0 +1,136 @@
/*
* MIT License
*
* Copyright (c) 2022 Joey Castillo
* Copyright (c) 2025 Alessandro Genova
*
* 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 <stddef.h>
#include "rtc32.h"
#include "sam.h"
rtc_cb_t _rtc_callback = NULL;
#if defined(_SAMD21_) || defined(_SAMD11_)
#define CTRLREG (RTC->MODE0.CTRL)
#define MODE_SETTING (RTC_MODE0_CTRL_MODE_COUNT32_Val) // Mode 0 Count32
#define PRESCALER_SETTING (RTC_MODE0_CTRL_PRESCALER_DIV8_Val)
#else
#define CTRLREG (RTC->MODE0.CTRLA)
#define MODE_SETTING (RTC_MODE0_CTRLA_MODE_COUNT32_Val) // Mode 0 Count32
#define PRESCALER_SETTING (RTC_MODE0_CTRLA_PRESCALER_DIV8_Val)
#endif
bool rtc_is_enabled(void) {
return CTRLREG.bit.ENABLE;
}
static void _rtc_sync(void) {
#if defined(_SAMD21_) || defined(_SAMD11_)
while (RTC->MODE0.STATUS.bit.SYNCBUSY);
#else
while (RTC->MODE0.SYNCBUSY.reg & RTC_MODE0_SYNCBUSY_MASK);
#endif
}
void rtc_init(void) {
#if defined(_SAMD21_) || defined(_SAMD11_)
// enable the RTC
PM->APBAMASK.reg |= PM_APBAMASK_RTC;
// clock RTC with GCLK3 (prescaled 1024 Hz output from the external crystal)
GCLK->CLKCTRL.reg = GCLK_CLKCTRL_GEN(3) | GCLK_CLKCTRL_ID(RTC_GCLK_ID) | GCLK_CLKCTRL_CLKEN;
#else
MCLK->APBAMASK.reg |= MCLK_APBAMASK_RTC;
#endif
if (rtc_is_enabled()) return; // don't reset the RTC if it's already set up.
_rtc_sync();
CTRLREG.bit.SWRST = 1;
_rtc_sync();
CTRLREG.bit.MODE = MODE_SETTING;
CTRLREG.bit.PRESCALER = PRESCALER_SETTING;
#if defined(_SAML21_) || defined(_SAML22_) || defined(_SAMD51_)
CTRLREG.bit.COUNTSYNC = 1;
#endif
RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_OVF;
}
void rtc_enable(void) {
if (rtc_is_enabled()) return;
CTRLREG.bit.ENABLE = 1;
_rtc_sync();
}
void rtc_set_counter(rtc_counter_t counter) {
// // syncing before and after was found to increase reliability on Sensor Watch
_rtc_sync();
RTC->MODE0.COUNT.reg = counter;
_rtc_sync();
}
rtc_counter_t rtc_get_counter(void) {
rtc_counter_t counter;
#if defined(_SAML21_) || defined(_SAML22_) || defined(_SAMD51_)
CTRLREG.bit.COUNTSYNC = 1;
#endif
_rtc_sync();
counter = RTC->MODE0.COUNT.reg;
return counter;
}
void rtc_enable_compare_interrupt(uint32_t compare_time) {
RTC->MODE0.COMP[0].reg = compare_time;
_rtc_sync();
RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_CMP0;
// NVIC_ClearPendingIRQ(RTC_IRQn);
// NVIC_EnableIRQ(RTC_IRQn);
}
void rtc_configure_callback(rtc_cb_t callback) {
_rtc_callback = callback;
}
void rtc_disable_compare_interrupt(void){
RTC->MODE0.INTENCLR.reg = RTC_MODE0_INTENCLR_CMP0;
// NVIC_ClearPendingIRQ(RTC_IRQn);
// NVIC_DisableIRQ(RTC_IRQn);
}
void irq_handler_rtc(void);
void irq_handler_rtc(void) {
uint16_t int_cause = (uint16_t)RTC->MODE0.INTFLAG.reg;
RTC->MODE0.INTFLAG.reg = RTC_MODE0_INTFLAG_MASK;
(void)RTC->MODE0.INTFLAG.reg;
/* Invoke registered Callback function */
if (_rtc_callback != NULL) {
_rtc_callback(int_cause);
}
// NVIC_ClearPendingIRQ(RTC_IRQn);
}

25
watch-library/hardware/watch/watch_deepsleep.c
View File

@ -41,7 +41,7 @@ void sleep(const uint8_t mode) {
}
void watch_register_extwake_callback(uint8_t pin, watch_cb_t callback, bool level) {
uint32_t config = RTC->MODE2.TAMPCTRL.reg;
uint32_t config = RTC->MODE0.TAMPCTRL.reg;
if (pin == HAL_GPIO_BTN_ALARM_pin()) {
HAL_GPIO_BTN_ALARM_in();
@ -71,22 +71,22 @@ void watch_register_extwake_callback(uint8_t pin, watch_cb_t callback, bool leve
}
// disable the RTC
RTC->MODE2.CTRLA.bit.ENABLE = 0;
while (RTC->MODE2.SYNCBUSY.bit.ENABLE); // wait for RTC to be disabled
RTC->MODE0.CTRLA.bit.ENABLE = 0;
while (RTC->MODE0.SYNCBUSY.bit.ENABLE); // wait for RTC to be disabled
// update the configuration
RTC->MODE2.TAMPCTRL.reg = config;
RTC->MODE0.TAMPCTRL.reg = config;
// re-enable the RTC
RTC->MODE2.CTRLA.bit.ENABLE = 1;
RTC->MODE0.CTRLA.bit.ENABLE = 1;
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_EnableIRQ(RTC_IRQn);
RTC->MODE2.INTENSET.reg = RTC_MODE2_INTENSET_TAMPER;
RTC->MODE0.INTENSET.reg = RTC_MODE0_INTENSET_TAMPER;
}
void watch_disable_extwake_interrupt(uint8_t pin) {
uint32_t config = RTC->MODE2.TAMPCTRL.reg;
uint32_t config = RTC->MODE0.TAMPCTRL.reg;
if (pin == HAL_GPIO_BTN_ALARM_pin()) {
btn_alarm_callback = NULL;
@ -101,14 +101,14 @@ void watch_disable_extwake_interrupt(uint8_t pin) {
}
// disable the RTC
RTC->MODE2.CTRLA.bit.ENABLE = 0;
while (RTC->MODE2.SYNCBUSY.bit.ENABLE); // wait for RTC to be disabled
RTC->MODE0.CTRLA.bit.ENABLE = 0;
while (RTC->MODE0.SYNCBUSY.bit.ENABLE); // wait for RTC to be disabled
// update the configuration
RTC->MODE2.TAMPCTRL.reg = config;
RTC->MODE0.TAMPCTRL.reg = config;
// re-enable the RTC
RTC->MODE2.CTRLA.bit.ENABLE = 1;
RTC->MODE0.CTRLA.bit.ENABLE = 1;
}
void watch_store_backup_data(uint32_t data, uint8_t reg) {
@ -151,7 +151,8 @@ static void _watch_disable_all_pins_except_rtc(void) {
}
static void _watch_disable_all_peripherals_except_slcd(void) {
_watch_disable_tcc();
watch_disable_leds();
watch_disable_buzzer();
watch_disable_adc();
watch_disable_external_interrupts();

243
watch-library/hardware/watch/watch_rtc.c
View File

@ -2,6 +2,7 @@
* MIT License
*
* Copyright (c) 2020 Joey Castillo
* Copyright (c) 2025 Alessandro Genova
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -23,11 +24,36 @@
*/
#include <stddef.h>
#include <limits.h>
#include "watch_rtc.h"
#include "watch_private.h"
#include "watch_utility.h"
static const uint32_t RTC_OSC_DIV = 10;
static const uint32_t RTC_OSC_HZ = 1 << RTC_OSC_DIV; // 2^10 = 1024
static const uint32_t RTC_PRESCALER_DIV = 3;
static const uint32_t RTC_CNT_HZ = RTC_OSC_HZ >> RTC_PRESCALER_DIV; // 1024 / 2^3 = 128
static const uint32_t RTC_CNT_SUBSECOND_MASK = RTC_CNT_HZ - 1;
static const uint32_t RTC_CNT_DIV = RTC_OSC_DIV - RTC_PRESCALER_DIV; // 7
static const uint32_t RTC_CNT_TICKS_PER_MINUTE = RTC_CNT_HZ * 60;
static const uint32_t RTC_COMP_GRACE_PERIOD = 4;
static const int TB_BKUP_REG = 7;
#define WATCH_RTC_N_COMP_CB 8
typedef struct {
volatile uint32_t counter;
volatile watch_cb_t callback;
volatile bool enabled;
} comp_cb_t;
volatile uint32_t scheduled_comp_counter;
watch_cb_t tick_callbacks[8];
comp_cb_t comp_callbacks[WATCH_RTC_N_COMP_CB];
watch_cb_t alarm_callback;
watch_cb_t btn_alarm_callback;
watch_cb_t a2_callback;
@ -46,14 +72,77 @@ void _watch_rtc_init(void) {
#endif
rtc_enable();
rtc_configure_callback(watch_rtc_callback);
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
comp_callbacks[index].counter = 0;
comp_callbacks[index].callback = NULL;
comp_callbacks[index].enabled = false;
}
scheduled_comp_counter = 0;
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_EnableIRQ(RTC_IRQn);
}
void watch_rtc_set_date_time(rtc_date_time_t date_time) {
rtc_set_date_time(date_time);
watch_rtc_set_unix_time(watch_utility_date_time_to_unix_time(date_time, 0));
}
rtc_date_time_t watch_rtc_get_date_time(void) {
return rtc_get_date_time();
static struct {
unix_timestamp_t timestamp;
rtc_date_time_t datetime;
} cached_date_time = {.datetime.reg=0, .timestamp=0};
unix_timestamp_t timestamp = watch_rtc_get_unix_time();
if (timestamp != cached_date_time.timestamp) {
cached_date_time.timestamp = timestamp;
cached_date_time.datetime = watch_utility_date_time_from_unix_time(timestamp, 0);
}
return cached_date_time.datetime;
}
void watch_rtc_set_unix_time(unix_timestamp_t unix_time) {
/* unix_time = time_backup + counter / RTC_CNT_HZ - 0.5
*
* Because of the way the hardware is designed, the periodic interrupts fire at the subsecond tick values
* according to the table below (for a 128Hz counter).
* since the 1Hz periodic interrupt is the most important, we shift the conversion from counter to timestamp by 64 ticks,
* so that the second changes at the top of the 1Hz interrupt. Hence the 0.5 factor in the equation above.
* 1Hz: 64
* 2Hz: 32, 96
* 4Hz: 16, 48, 80, 112
* 8Hz: 8, 24, 40, 56, 72, 88, 104, 120
* 16Hz: 4, 12, 20, ..., 124
* 32Hz: 2, 6, 10, ..., 126
* 64Hz: 1, 3, 5, ..., 127
* 128Hz: 0, 1, 2, ..., 127
*/
rtc_counter_t counter = rtc_get_counter();
unix_timestamp_t tb = unix_time - (counter >> RTC_CNT_DIV) - ((counter & RTC_CNT_SUBSECOND_MASK) >> (RTC_CNT_DIV - 1)) + 1;
watch_store_backup_data(tb, TB_BKUP_REG);
}
unix_timestamp_t watch_rtc_get_unix_time(void) {
// unix_time = time_backup + counter / RTC_CNT_HZ - 0.5
rtc_counter_t counter = rtc_get_counter();
unix_timestamp_t tb = watch_get_backup_data(TB_BKUP_REG);
return tb + (counter >> RTC_CNT_DIV) + ((counter & RTC_CNT_SUBSECOND_MASK) >> (RTC_CNT_DIV - 1)) - 1;
}
rtc_counter_t watch_rtc_get_counter(void) {
return rtc_get_counter();
}
uint32_t watch_rtc_get_frequency(void) {
return RTC_CNT_HZ;
}
uint32_t watch_rtc_get_ticks_per_minute(void) {
return RTC_CNT_TICKS_PER_MINUTE;
}
rtc_date_time_t watch_get_init_date_time(void) {
@ -103,57 +192,123 @@ void watch_rtc_register_periodic_callback(watch_cb_t callback, uint8_t frequency
// this also maps nicely to an index for our list of tick callbacks.
tick_callbacks[per_n] = callback;
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_EnableIRQ(RTC_IRQn);
RTC->MODE2.INTENSET.reg = 1 << per_n;
// NVIC_ClearPendingIRQ(RTC_IRQn);
// NVIC_EnableIRQ(RTC_IRQn);
RTC->MODE0.INTENSET.reg = 1 << per_n;
}
void watch_rtc_disable_periodic_callback(uint8_t frequency) {
if (__builtin_popcount(frequency) != 1) return;
uint8_t per_n = __builtin_clz((frequency & 0xFF) << 24);
RTC->MODE2.INTENCLR.reg = 1 << per_n;
RTC->MODE0.INTENCLR.reg = 1 << per_n;
}
void watch_rtc_disable_matching_periodic_callbacks(uint8_t mask) {
RTC->MODE2.INTENCLR.reg = mask;
RTC->MODE0.INTENCLR.reg = mask;
}
void watch_rtc_disable_all_periodic_callbacks(void) {
watch_rtc_disable_matching_periodic_callbacks(0xFF);
}
void watch_rtc_register_alarm_callback(watch_cb_t callback, rtc_date_time_t alarm_time, rtc_alarm_match_t mask) {
RTC->MODE2.Mode2Alarm[0].ALARM.reg = alarm_time.reg;
RTC->MODE2.Mode2Alarm[0].MASK.reg = mask;
RTC->MODE2.INTENSET.reg = RTC_MODE2_INTENSET_ALARM0;
alarm_callback = callback;
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_EnableIRQ(RTC_IRQn);
RTC->MODE2.INTENSET.reg = RTC_MODE2_INTENSET_ALARM0;
void watch_rtc_schedule_next_comp(void) {
rtc_counter_t curr_counter = watch_rtc_get_counter();
// We want to ensure we never miss any registered callbacks,
// so if a callback counter has just passed but didn't fire, give it a chance to fire.
rtc_counter_t lax_curr_counter = curr_counter - RTC_COMP_GRACE_PERIOD;
bool schedule_any = false;
rtc_counter_t comp_counter;
rtc_counter_t min_diff = UINT_MAX;
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
if (comp_callbacks[index].enabled) {
rtc_counter_t diff = comp_callbacks[index].counter - lax_curr_counter;
if (diff <= min_diff) {
min_diff = diff;
comp_counter = comp_callbacks[index].counter;
schedule_any = true;
}
}
}
if (schedule_any) {
// If we are changing the comp counter at the front of the line, don't schedule a comp interrupt for a counter that is too close to now
if (comp_counter != scheduled_comp_counter) {
rtc_counter_t earliest_comp_counter = curr_counter + RTC_COMP_GRACE_PERIOD;
if ((earliest_comp_counter - lax_curr_counter) > (comp_counter - lax_curr_counter)) {
comp_counter = earliest_comp_counter;
}
scheduled_comp_counter = comp_counter;
rtc_enable_compare_interrupt(comp_counter);
}
} else {
scheduled_comp_counter = lax_curr_counter - RTC_COMP_GRACE_PERIOD;
rtc_disable_compare_interrupt();
}
}
void watch_rtc_disable_alarm_callback(void) {
RTC->MODE2.INTENCLR.reg = RTC_MODE2_INTENCLR_ALARM0;
void watch_rtc_register_comp_callback(watch_cb_t callback, rtc_counter_t counter, uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
comp_callbacks[index].counter = counter;
comp_callbacks[index].callback = callback;
comp_callbacks[index].enabled = true;
watch_rtc_schedule_next_comp();
}
void watch_rtc_callback(uint16_t interrupt_status) {
uint16_t interrupt_enabled = RTC->MODE2.INTENSET.reg;
void watch_rtc_register_comp_callback_no_schedule(watch_cb_t callback, rtc_counter_t counter, uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
if ((interrupt_status & interrupt_enabled) & RTC_MODE2_INTFLAG_PER_Msk) {
comp_callbacks[index].counter = counter;
comp_callbacks[index].callback = callback;
comp_callbacks[index].enabled = true;
}
void watch_rtc_disable_comp_callback(uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
comp_callbacks[index].enabled = false;
watch_rtc_schedule_next_comp();
}
void watch_rtc_disable_comp_callback_no_schedule(uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
comp_callbacks[index].enabled = false;
}
void watch_rtc_callback(uint16_t interrupt_cause) {
// First read all relevant registers, to ensure no changes occurr during the callbacks
rtc_counter_t curr_counter = watch_rtc_get_counter();
uint16_t interrupt_enabled = (uint16_t)RTC->MODE0.INTENSET.reg;
if ((interrupt_cause & interrupt_enabled) & RTC_MODE0_INTFLAG_PER_Msk) {
// handle the tick callback first, it's what we do the most.
// start from PER7, the 1 Hz tick.
for(int8_t i = 7; i >= 0; i--) {
if ((interrupt_status & interrupt_enabled) & (1 << i)) {
if ((interrupt_cause & interrupt_enabled) & (1 << i)) {
if (tick_callbacks[i] != NULL) {
tick_callbacks[i]();
}
RTC->MODE2.INTFLAG.reg = 1 << i;
// break; Uncertain if this fix is requried. We were discussing in discord. Might slightly increase power consumption.
}
}
} else if ((interrupt_status & interrupt_enabled) & RTC_MODE2_INTFLAG_TAMPER) {
}
if ((interrupt_cause & interrupt_enabled) & RTC_MODE0_INTFLAG_TAMPER) {
// handle the extwake interrupts next.
uint8_t reason = RTC->MODE2.TAMPID.reg;
uint8_t reason = RTC->MODE0.TAMPID.reg;
if (reason & RTC_TAMPID_TAMPID2) {
if (btn_alarm_callback != NULL) btn_alarm_callback();
} else if (reason & RTC_TAMPID_TAMPID1) {
@ -161,25 +316,36 @@ void watch_rtc_callback(uint16_t interrupt_status) {
} else if (reason & RTC_TAMPID_TAMPID0) {
if (a4_callback != NULL) a4_callback();
}
RTC->MODE2.TAMPID.reg = reason;
RTC->MODE2.INTFLAG.reg = RTC_MODE2_INTFLAG_TAMPER;
} else if ((interrupt_status & interrupt_enabled) & RTC_MODE2_INTFLAG_ALARM0) {
// finally handle the alarm.
if (alarm_callback != NULL) {
alarm_callback();
RTC->MODE0.TAMPID.reg = reason;
}
RTC->MODE2.INTFLAG.reg = RTC_MODE2_INTFLAG_ALARM0;
if ((interrupt_cause & interrupt_enabled) & RTC_MODE0_INTFLAG_CMP0) {
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
if (comp_callbacks[index].enabled &&
(curr_counter - comp_callbacks[index].counter) < (RTC_COMP_GRACE_PERIOD * 4)
) {
comp_callbacks[index].enabled = false;
comp_callbacks[index].callback();
}
}
watch_rtc_schedule_next_comp();
}
if ((interrupt_cause & interrupt_enabled) & RTC_MODE0_INTFLAG_OVF) {
// Handle the overflow of the counter. All we need to do is reset the reference time.
unix_timestamp_t tb = watch_get_backup_data(TB_BKUP_REG);
watch_store_backup_data(tb + (UINT_MAX >> RTC_CNT_DIV), TB_BKUP_REG);
}
}
void watch_rtc_enable(bool en) {
// Writing it twice - as it's quite dangerous operation.
// If write fails - we might hang with RTC off, which means no recovery possible
while (RTC->MODE2.SYNCBUSY.reg);
RTC->MODE2.CTRLA.bit.ENABLE = en ? 1 : 0;
while (RTC->MODE2.SYNCBUSY.reg);
RTC->MODE2.CTRLA.bit.ENABLE = en ? 1 : 0;
while (RTC->MODE2.SYNCBUSY.reg);
while (RTC->MODE0.SYNCBUSY.reg);
RTC->MODE0.CTRLA.bit.ENABLE = en ? 1 : 0;
while (RTC->MODE0.SYNCBUSY.reg);
RTC->MODE0.CTRLA.bit.ENABLE = en ? 1 : 0;
while (RTC->MODE0.SYNCBUSY.reg);
}
void watch_rtc_freqcorr_write(int16_t value, int16_t sign) {
@ -188,8 +354,7 @@ void watch_rtc_freqcorr_write(int16_t value, int16_t sign) {
data.bit.VALUE = value;
data.bit.SIGN = sign;
RTC->MODE2.FREQCORR.reg = data.reg; // Setting correction in single write operation
RTC->MODE0.FREQCORR.reg = data.reg; // Setting correction in single write operation
// We do not sycnronize. We are not in a hurry
}

275
watch-library/hardware/watch/watch_tcc.c
View File

@ -27,14 +27,30 @@
#include "tcc.h"
#include "tc.h"
void _watch_enable_tcc(void);
void cb_watch_buzzer_seq(void);
static void _watch_enable_tcc(void);
static void _watch_disable_tcc(void);
static void _watch_maybe_enable_tcc(void);
static void _watch_maybe_disable_tcc(void);
static void _watch_enable_led_pins(void);
static void _watch_disable_led_pins(void);
static void (*_cb_tc0)(void) = NULL;
static void cb_watch_buzzer_seq(void);
static void cb_watch_buzzer_raw_source(void);
static uint16_t _seq_position;
static int8_t _tone_ticks, _repeat_counter;
static bool _callback_running = false;
static int8_t *_sequence;
static watch_buzzer_raw_source_t _raw_source;
static void* _userdata;
static uint8_t _volume;
static void (*_cb_finished)(void);
static watch_cb_t _cb_start_global = NULL;
static watch_cb_t _cb_stop_global = NULL;
static volatile bool _led_is_active = false;
static volatile bool _buzzer_is_active = false;
static volatile uint8_t _current_led_color[3] = {0, 0, 0};
static void _watch_set_led_duty_cycle(uint32_t period, uint8_t red, uint8_t green, uint8_t blue);
static void _tcc_write_RUNSTDBY(bool value) {
// enables or disables RUNSTDBY of the tcc
@ -46,13 +62,11 @@ static void _tcc_write_RUNSTDBY(bool value) {
static inline void _tc0_start() {
// start the TC0 timer
tc_enable(0);
_callback_running = true;
}
static inline void _tc0_stop() {
// stop the TC0 timer
tc_disable(0);
_callback_running = false;
}
static void _tc0_initialize() {
@ -68,19 +82,30 @@ static void _tc0_initialize() {
}
void watch_buzzer_play_sequence(int8_t *note_sequence, void (*callback_on_end)(void)) {
if (_callback_running) _tc0_stop();
watch_buzzer_play_sequence_with_volume(note_sequence, callback_on_end, WATCH_BUZZER_VOLUME_LOUD);
}
void watch_buzzer_play_sequence_with_volume(int8_t *note_sequence, void (*callback_on_end)(void), watch_buzzer_volume_t volume) {
// Abort any previous sequence
watch_buzzer_abort_sequence();
if (_cb_start_global) {
_cb_start_global();
}
watch_enable_buzzer();
watch_set_buzzer_off();
_sequence = note_sequence;
_cb_finished = callback_on_end;
_volume = volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25;
_seq_position = 0;
_tone_ticks = 0;
_repeat_counter = -1;
// prepare buzzer
watch_enable_buzzer();
_cb_tc0 = cb_watch_buzzer_seq;
// setup TC0 timer
_tc0_initialize();
// TCC should run in standby mode
_tcc_write_RUNSTDBY(true);
// start the timer (for the 64 hz callback)
_tc0_start();
}
@ -110,51 +135,156 @@ void cb_watch_buzzer_seq(void) {
// read note
watch_buzzer_note_t note = _sequence[_seq_position];
if (note != BUZZER_NOTE_REST) {
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], 25);
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], _volume);
watch_set_buzzer_on();
} else watch_set_buzzer_off();
// set duration ticks and move to next tone
_tone_ticks = _sequence[_seq_position + 1];
_tone_ticks = _sequence[_seq_position + 1] - 1;
_seq_position += 2;
} else {
// end the sequence
watch_buzzer_abort_sequence();
if (_cb_finished) _cb_finished();
}
} else _tone_ticks--;
}
void watch_buzzer_play_raw_source(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end) {
watch_buzzer_play_raw_source_with_volume(raw_source, userdata, callback_on_end, WATCH_BUZZER_VOLUME_LOUD);
}
void watch_buzzer_play_raw_source_with_volume(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end, watch_buzzer_volume_t volume) {
// Abort any previous sequence
watch_buzzer_abort_sequence();
if (_cb_start_global) {
_cb_start_global();
}
watch_enable_buzzer();
watch_set_buzzer_off();
_raw_source = raw_source;
_userdata = userdata;
_cb_finished = callback_on_end;
_volume = volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25;
_seq_position = 0;
_tone_ticks = 0;
// prepare buzzer
_cb_tc0 = cb_watch_buzzer_raw_source;
// setup TC0 timer
_tc0_initialize();
// start the timer (for the 64 hz callback)
_tc0_start();
}
void cb_watch_buzzer_raw_source(void) {
// callback for reading the note sequence
uint16_t period;
uint16_t duration;
bool done;
if (_tone_ticks == 0) {
done = _raw_source(_seq_position, _userdata, &period, &duration);
if (done || duration == 0) {
// end the sequence
watch_buzzer_abort_sequence();
} else {
if (period == WATCH_BUZZER_PERIOD_REST) {
watch_set_buzzer_off();
} else {
watch_set_buzzer_period_and_duty_cycle(period, _volume);
watch_set_buzzer_on();
}
// set duration ticks and move to next tone
_tone_ticks = duration - 1;
_seq_position += 1;
}
} else {
_tone_ticks--;
}
}
void watch_buzzer_abort_sequence(void) {
// ends/aborts the sequence
if (_callback_running) _tc0_stop();
if (!_buzzer_is_active) {
return;
}
_tc0_stop();
watch_set_buzzer_off();
// disable standby mode for TCC
_tcc_write_RUNSTDBY(false);
// disable TCC
watch_disable_buzzer();
if (_cb_stop_global) {
_cb_stop_global();
}
if (_cb_finished) {
_cb_finished();
}
}
void watch_buzzer_register_global_callbacks(watch_cb_t cb_start, watch_cb_t cb_stop) {
_cb_stop_global = cb_start;
_cb_stop_global = cb_stop;
}
void irq_handler_tc0(void) {
// interrupt handler for TC0 (globally!)
cb_watch_buzzer_seq();
if (_cb_tc0) {
_cb_tc0();
}
TC0->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF;
}
bool watch_is_buzzer_or_led_enabled(void){
return tcc_is_enabled(0);
void _watch_maybe_enable_tcc(void) {
if (!_buzzer_is_active && !_led_is_active) {
return;
}
if (!tcc_is_enabled(0)) {
// tcc_set_run_in_standby(0, true);
_watch_enable_tcc();
// TCC should run in standby mode
_tcc_write_RUNSTDBY(true);
}
}
inline void watch_enable_buzzer(void) {
if (!tcc_is_enabled(0)) {
_watch_enable_tcc();
void _watch_maybe_disable_tcc(void) {
if (_buzzer_is_active || _led_is_active) {
return;
}
if (tcc_is_enabled(0)) {
_tcc_write_RUNSTDBY(false);
_watch_disable_tcc();
}
}
void watch_enable_buzzer(void) {
_buzzer_is_active = true;
_watch_maybe_enable_tcc();
}
void watch_disable_buzzer(void) {
_buzzer_is_active = false;
watch_set_buzzer_off();
_watch_maybe_disable_tcc();
}
void watch_set_buzzer_period_and_duty_cycle(uint32_t period, uint8_t duty) {
tcc_set_period(0, period, true);
tcc_set_cc(0, (WATCH_BUZZER_TCC_CHANNEL) % 4, period / (100 / duty), true);
}
void watch_disable_buzzer(void) {
_watch_disable_tcc();
// The buzzer determines the period, which means that if the LED was active before it will flicker
// Update the LED duty cycle to match the new period required by the buzzer.
if (_led_is_active) {
_watch_set_led_duty_cycle(period, _current_led_color[0], _current_led_color[1], _current_led_color[2]);
}
}
inline void watch_set_buzzer_on(void) {
@ -172,14 +302,17 @@ void watch_buzzer_play_note(watch_buzzer_note_t note, uint16_t duration_ms) {
}
void watch_buzzer_play_note_with_volume(watch_buzzer_note_t note, uint16_t duration_ms, watch_buzzer_volume_t volume) {
if (note == BUZZER_NOTE_REST) {
watch_set_buzzer_off();
} else {
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25);
watch_set_buzzer_on();
}
delay_ms(duration_ms);
watch_set_buzzer_off();
static int8_t single_note_sequence[3];
single_note_sequence[0] = note;
// 64 ticks per second for the tc0
// Each tick is approximately 15ms
uint16_t duration = duration_ms / 15;
if (duration > 127) duration = 127;
single_note_sequence[1] = (int8_t)duration;
single_note_sequence[2] = 0;
watch_buzzer_play_sequence_with_volume(single_note_sequence, NULL, volume);
}
void _watch_enable_tcc(void) {
@ -220,21 +353,6 @@ void _watch_enable_tcc(void) {
tcc_set_cc(0, (WATCH_BLUE_TCC_CHANNEL) % 4, 0, false);
#endif
// enable LED PWM pins (the LED driver assumes if the TCC is on, the pins are enabled)
HAL_GPIO_RED_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_RED_drvstr(1);
HAL_GPIO_RED_out();
#ifdef WATCH_GREEN_TCC_CHANNEL
HAL_GPIO_GREEN_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_GREEN_drvstr(1);
HAL_GPIO_GREEN_out();
#endif
#ifdef WATCH_BLUE_TCC_CHANNEL
HAL_GPIO_BLUE_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_BLUE_drvstr(1);
HAL_GPIO_BLUE_out();
#endif
// Enable the TCC
tcc_enable(0);
}
@ -257,13 +375,45 @@ void _watch_disable_tcc(void) {
}
void watch_enable_leds(void) {
if (!tcc_is_enabled(0)) {
_watch_enable_tcc();
}
_led_is_active = true;
_watch_enable_led_pins();
_watch_maybe_enable_tcc();
}
void watch_disable_leds(void) {
_watch_disable_tcc();
_led_is_active = false;
_watch_disable_led_pins();
_watch_maybe_disable_tcc();
}
void _watch_enable_led_pins(void) {
// enable LED PWM pins (the LED driver assumes if the TCC is on, the pins are enabled)
HAL_GPIO_RED_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_RED_drvstr(1);
HAL_GPIO_RED_out();
#ifdef WATCH_GREEN_TCC_CHANNEL
HAL_GPIO_GREEN_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_GREEN_drvstr(1);
HAL_GPIO_GREEN_out();
#endif
#ifdef WATCH_BLUE_TCC_CHANNEL
HAL_GPIO_BLUE_pmuxen(HAL_GPIO_PMUX_TCC_ALT);
HAL_GPIO_BLUE_drvstr(1);
HAL_GPIO_BLUE_out();
#endif
}
void _watch_disable_led_pins(void) {
HAL_GPIO_RED_pmuxdis();
HAL_GPIO_RED_off();
#ifdef WATCH_GREEN_TCC_CHANNEL
HAL_GPIO_GREEN_pmuxdis();
HAL_GPIO_GREEN_off();
#endif
#ifdef WATCH_BLUE_TCC_CHANNEL
HAL_GPIO_BLUE_pmuxdis();
HAL_GPIO_BLUE_off();
#endif
}
void watch_set_led_color(uint8_t red, uint8_t green) {
@ -274,9 +424,7 @@ void watch_set_led_color(uint8_t red, uint8_t green) {
#endif
}
void watch_set_led_color_rgb(uint8_t red, uint8_t green, uint8_t blue) {
if (tcc_is_enabled(0)) {
uint32_t period = tcc_get_period(0);
static void _watch_set_led_duty_cycle(uint32_t period, uint8_t red, uint8_t green, uint8_t blue) {
tcc_set_cc(0, (WATCH_RED_TCC_CHANNEL) % 4, ((period * (uint32_t)red * 1000ull) / 255000ull), true);
#ifdef WATCH_GREEN_TCC_CHANNEL
tcc_set_cc(0, (WATCH_GREEN_TCC_CHANNEL) % 4, ((period * (uint32_t)green * 1000ull) / 255000ull), true);
@ -288,6 +436,23 @@ void watch_set_led_color_rgb(uint8_t red, uint8_t green, uint8_t blue) {
#else
(void) blue; // silence warning
#endif
}
void watch_set_led_color_rgb(uint8_t red, uint8_t green, uint8_t blue) {
bool turning_on = (red | green | blue) != 0;
if (turning_on) {
_current_led_color[0] = red;
_current_led_color[1] = green;
_current_led_color[2] = blue;
watch_enable_leds();
uint32_t period = tcc_get_period(0);
_watch_set_led_duty_cycle(period, red, green, blue);
} else {
if (tcc_is_enabled(0)) {
_watch_set_led_duty_cycle(1, red, green, blue);
}
watch_disable_leds();
}
}

49
watch-library/shared/driver/lis2dw.c
View File

@ -277,20 +277,26 @@ inline void lis2dw_disable_fifo(void) {
#endif
}
bool lis2dw_read_fifo(lis2dw_fifo_t *fifo_data) {
bool lis2dw_read_fifo(lis2dw_fifo_t *fifo_data, uint32_t timeout) {
// timeout is in terms of 1/RTC_CNT_HZ seconds (likely 128 timeouts is one second)
#ifdef I2C_SERCOM
uint8_t temp = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_FIFO_SAMPLE);
bool overrun = !!(temp & LIS2DW_FIFO_SAMPLE_OVERRUN);
fifo_data->count = temp & LIS2DW_FIFO_SAMPLE_COUNT;
rtc_counter_t timeout_counter = watch_rtc_get_counter() + timeout;
for(int i = 0; i < fifo_data->count; i++) {
if (watch_rtc_get_counter() > timeout_counter) {
break;
}
fifo_data->readings[i] = lis2dw_get_raw_reading();
}
return overrun;
#else
(void) fifo_data;
(void) timeout;
return false;
#endif
}
@ -411,6 +417,33 @@ void lis2dw_configure_int2(uint8_t sources) {
#endif
}
void lis2dw12_int_notification_set(lis2dw12_lir_t val) {
#ifdef I2C_SERCOM
uint8_t configuration = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL3);
if (val == LIS2DW12_INT_LATCHED) {
configuration |= LIS2DW_CTRL3_VAL_LIR;
} else {
configuration &= ~LIS2DW_CTRL7_VAL_DRDY_PULSED;
}
watch_i2c_write8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL3, configuration);
#else
(void)val;
#endif
}
lis2dw12_lir_t lis2dw12_int_notification_get(void) {
#ifdef I2C_SERCOM
uint8_t configuration = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL3);
if (configuration & LIS2DW12_INT_LATCHED) {
return LIS2DW12_INT_LATCHED;
} else {
return LIS2DW12_INT_PULSED;
}
#else
return LIS2DW12_INT_PULSED;
#endif
}
void lis2dw_enable_interrupts(void) {
#ifdef I2C_SERCOM
uint8_t configuration = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL7);
@ -425,6 +458,20 @@ void lis2dw_disable_interrupts(void) {
#endif
}
void lis2dw_pulsed_drdy_interrupts(void) {
#ifdef I2C_SERCOM
uint8_t configuration = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL7);
watch_i2c_write8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL7, configuration | LIS2DW_CTRL7_VAL_DRDY_PULSED);
#endif
}
void lis2dw_latched_drdy_interrupts(void) {
#ifdef I2C_SERCOM
uint8_t configuration = watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL7);
watch_i2c_write8(LIS2DW_ADDRESS, LIS2DW_REG_CTRL7, configuration & ~LIS2DW_CTRL7_VAL_DRDY_PULSED);
#endif
}
lis2dw_wakeup_source_t lis2dw_get_wakeup_source() {
#ifdef I2C_SERCOM
return (lis2dw_wakeup_source_t) watch_i2c_read8(LIS2DW_ADDRESS, LIS2DW_REG_WAKE_UP_SRC);

18
watch-library/shared/driver/lis2dw.h
View File

@ -92,6 +92,12 @@ typedef enum {
LIS2DW_FILTER_HIGH_PASS = 1,
} lis2dw_filter_t;
typedef enum
{
LIS2DW12_INT_PULSED = 0,
LIS2DW12_INT_LATCHED = 1,
} lis2dw12_lir_t;
typedef enum {
LIS2DW_RANGE_16_G = 0b11, // +/- 16g
LIS2DW_RANGE_8_G = 0b10, // +/- 8g
@ -295,6 +301,8 @@ typedef enum {
#define LIS2DW_CTRL7_VAL_HP_REF_MODE 0b00000010
#define LIS2DW_CTRL7_VAL_LPASS_ON6D 0b00000001
#define LIS2DW_FIFO_TIMEOUT 100 // timeout is in terms of 1/RTC_CNT_HZ seconds (likely 128 timeouts is one second)
bool lis2dw_begin(void);
uint8_t lis2dw_get_device_id(void);
@ -339,7 +347,7 @@ void lis2dw_enable_fifo(void);
void lis2dw_disable_fifo(void);
bool lis2dw_read_fifo(lis2dw_fifo_t *fifo_data);
bool lis2dw_read_fifo(lis2dw_fifo_t *fifo_data, uint32_t timeout);
void lis2dw_clear_fifo(void);
@ -367,6 +375,10 @@ void lis2dw_configure_tap_threshold(uint8_t threshold_x, uint8_t threshold_y, ui
void lis2dw_configure_tap_duration(uint8_t latency, uint8_t quiet, uint8_t shock);
void lis2dw12_int_notification_set(lis2dw12_lir_t val);
lis2dw12_lir_t lis2dw12_int_notification_get(void);
void lis2dw_configure_int1(uint8_t sources);
void lis2dw_configure_int2(uint8_t sources);
@ -375,6 +387,10 @@ void lis2dw_enable_interrupts(void);
void lis2dw_disable_interrupts(void);
void lis2dw_pulsed_drdy_interrupts(void);
void lis2dw_latched_drdy_interrupts(void);
lis2dw_interrupt_source_t lis2dw_get_interrupt_source(void);
lis2dw_wakeup_source_t lis2dw_get_wakeup_source(void);

98
watch-library/shared/watch/rtc32.h Normal file
View File

@ -0,0 +1,98 @@
////< @file rtc32.h
/*
* MIT License
*
* Copyright (c) 2020 Joey Castillo
* Copyright (c) 2025 Alessandro Genova
*
* 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
#include <stdint.h>
#include <stdbool.h>
/**
* @addtogroup rtc Real-Time Clock
* @brief Functions for configuring and using the Real-Time Clock peripheral.
* @details This is the rtc implementation for MODE0 (counter32)
* @{
*/
#define RTC_REFERENCE_YEAR (2020)
typedef union {
struct {
uint32_t second : 6; // 0-59
uint32_t minute : 6; // 0-59
uint32_t hour : 5; // 0-23
uint32_t day : 5; // 1-31
uint32_t month : 4; // 1-12
uint32_t year : 6; // 0-63 (representing 2020-2083)
} unit;
uint32_t reg; // the bit-packed value as expected by the RTC peripheral's CLOCK register.
} rtc_date_time_t;
typedef enum rtc_alarm_match_t {
ALARM_MATCH_DISABLED = 0,
ALARM_MATCH_SS,
ALARM_MATCH_MMSS,
ALARM_MATCH_HHMMSS,
} rtc_alarm_match_t;
typedef uint32_t rtc_counter_t;
typedef void (*rtc_cb_t)(uint16_t intflag);
/** @brief Initializes the RTC.
* @details Configures the RTC for COUNT32 mode, with a 1 Hz
* tick derived from the 1024 Hz clock on GCLK3 (for SAM D devices)
* or OSC32KCTRL's most accurate 1024 Hz output (for SAM L devices).
*/
void rtc_init(void);
/** @brief Enables the RTC.
*/
void rtc_enable(void);
/** @brief Checks if the RTC is enabled.
* @return true if the RTC is enabled; false if not.
*/
bool rtc_is_enabled(void);
/** @brief Set the value of the counter register.
*/
void rtc_set_counter(rtc_counter_t counter);
/** @brief Returns the value of the counter register.
*/
rtc_counter_t rtc_get_counter(void);
/** @brief Configures the RTC alarm callback.
* @param callback The function to call when an RTC interrupt occurs. The callback
* will be passed a bitmask of the interrupt flags, the full contents
* of the RTC peripheral's INTFLAG register.
*/
void rtc_configure_callback(rtc_cb_t callback);
void rtc_enable_compare_interrupt(uint32_t compare_time);
void rtc_disable_compare_interrupt(void);
/** @} */

98
watch-library/shared/watch/watch_rtc.h
View File

@ -27,7 +27,7 @@
////< @file watch_rtc.h
#include "watch.h"
#include "rtc.h"
#include "rtc32.h"
/** @addtogroup rtc Real-Time Clock
* @brief This section covers functions related to the SAM L22's real-time clock peripheral, including
@ -42,17 +42,20 @@
extern watch_cb_t btn_alarm_callback;
extern watch_cb_t a2_callback;
extern watch_cb_t a4_callback;
extern watch_cb_t comp_callback;
#define WATCH_RTC_REFERENCE_YEAR (2020)
#define watch_date_time_t rtc_date_time_t
typedef rtc_counter_t watch_counter_t;
typedef uint32_t unix_timestamp_t;
/** @brief Called by main.c to check if the RTC is enabled.
* You may call this function, but outside of app_init, it should always return true.
*/
bool _watch_rtc_is_enabled(void);
/** @brief Sets the date and time.
/** @brief Sets the date and time. Calls watch_rtc_set_unix_time internally.
* @param date_time The date and time you wish to set, with a year value from 0-63 representing 2020-2083.
* @note The SAM L22 stores the year as six bits representing a value from 0 to 63. It treats this as a year
* offset from a reference year, which must be a leap year. Since 2020 was a leap year, and it allows
@ -62,7 +65,7 @@ bool _watch_rtc_is_enabled(void);
*/
void watch_rtc_set_date_time(rtc_date_time_t date_time);
/** @brief Returns the date and time.
/** @brief Returns the date and time. Calls watch_rtc_get_unix_time internally.
* @return A rtc_date_time_t with the current date and time, with a year value from 0-63 representing 2020-2083.
* @see watch_rtc_set_date_time for notes about how the year is stored.
*/
@ -73,26 +76,79 @@ rtc_date_time_t watch_rtc_get_date_time(void);
*/
rtc_date_time_t watch_get_init_date_time(void);
/** @brief Registers an alarm callback that will be called when the RTC time matches the target time, as masked
* by the provided mask.
* @param callback The function you wish to have called when the alarm fires. If this value is NULL, the alarm
* interrupt will still be enabled, but no callback function will be called.
* @param alarm_time The time that you wish to match. The date is currently ignored.
* @param mask One of the values in rtc_alarm_match_t indicating which values to check.
* @details The alarm interrupt is a versatile tool for scheduling events in the future, especially since it can
* wake the device from all sleep modes. The key to its versatility is the mask parameter.
* Suppose we set an alarm for midnight, 00:00:00.
* * if mask is ALARM_MATCH_SS, the alarm will fire every minute when the clock ticks to seconds == 0.
* * with ALARM_MATCH_MMSS, the alarm will once an hour, at the top of each hour.
* * with ALARM_MATCH_HHMMSS, the alarm will fire at midnight every day.
* In theory the SAM L22's alarm function can match on days, months and even years, but I have not had
* success with this yet; as such, I am omitting these options for now.
/** @brief Set the current UTC date and time using a unix timestamp
*/
void watch_rtc_register_alarm_callback(watch_cb_t callback, rtc_date_time_t alarm_time, rtc_alarm_match_t mask);
void watch_rtc_set_unix_time(unix_timestamp_t unix_time);
/** @brief Get the current UTC date and time using a unix timestamp
*/
unix_timestamp_t watch_rtc_get_unix_time(void);
/** @brief Get the current value of the internal hardware counter
* @details The counter starts at 0 and it increases at a 128Hz rate until it overflows and starts over.
* We never manually set the counter. Doing so allows us to calculate absolute elapsed and more.
* When the user sets the time, what is modified is the reference time (i.e. the date and time when
* the counter is 0).
*/
rtc_counter_t watch_rtc_get_counter(void);
/** @brief Get the RTC counter frequency.
*/
uint32_t watch_rtc_get_frequency(void);
/** @brief Get how many counter ticks are in one minute.
*/
uint32_t watch_rtc_get_ticks_per_minute(void);
/** @brief Registers a callback that will be called when the RTC counter matches the target counter.
* @param callback The function you wish to have called when the target counter is reached. If this value is NULL, the comp
* interrupt will still be enabled, but no callback function will be called.
* @param counter The time that you wish to match. The date is currently ignored.
* @param index We can have up to 8 active callbacks at a time. This parameter specifies which of the 8 callbacks should be set.
* @details The hardware RTC provides us with single interrupt that fires when the RTC counter matches a target counter COMP0.
* With a little bit of logic, we can provide multiple active compare callbacks. Every time a comp callback is
* registered/disabled/fired we iterate over all the active comp callbacks and set the hardware COMP0 counter
* to the next occurring one.
* With this very simple API, movement can implement one-shot timers to turn off the led and determine button longpresses
* as well as the inactivity timeouts for resigning and sleeping, as well as emulating the top of the minute alarm.
*/
void watch_rtc_register_comp_callback(watch_cb_t callback, rtc_counter_t counter, uint8_t index);
/** @brief Just like watch_rtc_register_comp_callback but doesn't actually schedule the callback
*
* Useful if you need register multiple callbacks at once, avoids multiple calls to the expensive watch_rtc_schedule_next_comp:
* Usage:
* watch_rtc_register_comp_callback_no_schedule(cb0, counter0, index0);
* watch_rtc_register_comp_callback_no_schedule(cb1, counter1, index1);
* watch_rtc_schedule_next_comp();
*/
void watch_rtc_register_comp_callback_no_schedule(watch_cb_t callback, rtc_counter_t counter, uint8_t index);
/** @brief Disables the specified comp callback.
*/
void watch_rtc_disable_comp_callback(uint8_t index);
/** @brief Just like watch_rtc_disable_comp_callback but doesn't actually schedule the callback
*
* Useful if you need disable multiple callbacks at once, avoids multiple calls to the expensive watch_rtc_schedule_next_comp:
* Usage:
* watch_rtc_disable_comp_callback_no_schedule(index0);
* watch_rtc_disable_comp_callback_no_schedule(index1);
* watch_rtc_schedule_next_comp();
*/
/** @brief Disables the specified comp callback.
*/
void watch_rtc_disable_comp_callback_no_schedule(uint8_t index);
/** @brief Determines the first comp callback that should fire and schedule it with the RTC
*
* You would never need to call this manually, unless you used the 'no_schedule' functions above.
*/
void watch_rtc_schedule_next_comp(void);
/** @brief Disables the alarm callback.
*/
void watch_rtc_disable_alarm_callback(void);
// void watch_rtc_disable_alarm_callback(void);
/** @brief Registers a "tick" callback that will be called once per second.
* @param callback The function you wish to have called when the clock ticks. If you pass in NULL, the tick
@ -117,10 +173,6 @@ void watch_rtc_disable_tick_callback(void);
* tick at 16 or 32 Hz to update the screen more quickly. Just remember that the more frequent the tick, the more
* power your app will consume. Ideally you should enable the fast tick only when the user requires it (i.e. in
* response to an input event), and move back to the slow tick after some time.
*
* Also note that the RTC peripheral does not have sub-second resolution, so even if you set a 2 or 4 Hz interval,
* the system will not have any way of telling you where you are within a given second; watch_rtc_get_date_time
* will return the exact same timestamp until the second ticks over.
*/
void watch_rtc_register_periodic_callback(watch_cb_t callback, uint8_t frequency);

99
watch-library/shared/watch/watch_tcc.h
View File

@ -126,12 +126,9 @@ typedef enum {
BUZZER_NOTE_REST ///< no sound
} watch_buzzer_note_t;
/** @brief Returns true if either the buzzer or the LED driver is enabled.
* @details Both the buzzer and the LED use the TCC peripheral to drive their behavior. This function returns true if that
* peripheral is enabled. You can use this function to determine whether you need to call the watch_enable_leds or
* or watch_enable_buzzer functions before using these peripherals.
*/
bool watch_is_buzzer_or_led_enabled(void);
#define WATCH_BUZZER_PERIOD_REST 0
typedef bool (*watch_buzzer_raw_source_t)(uint16_t position, void* userdata, uint16_t* period, uint16_t* duration);
/** @addtogroup tcc Buzzer and LED Control (via the TCC peripheral)
* @brief This section covers functions related to Timer Counter for Control peripheral, which drives the piezo buzzer
@ -151,15 +148,13 @@ void watch_enable_buzzer(void);
*/
void watch_set_buzzer_period_and_duty_cycle(uint32_t period, uint8_t duty);
/** @brief Disables the TCC peripheral that drives the buzzer.
* @note If you are using PWM to set custom LED colors, this method will also disable the LED PWM driver,
* since the buzzer and LED both make use of the same peripheral to drive their PWM behavior.
/** @brief Disables the TCC peripheral that drives the buzzer (if LED not active).
*/
void watch_disable_buzzer(void);
/** @brief Turns the buzzer output on. It will emit a continuous sound at the given frequency.
* @note The TCC peripheral that drives the buzzer does not run in standby mode; if you wish for buzzer
* output to continue, you should prevent your app from going to sleep.
* @note The TCC peripheral that drives the buzzer does run in standby mode; if you wish for buzzer
* output to continue, you don't need to prevent your app from going to sleep.
*/
void watch_set_buzzer_on(void);
@ -170,8 +165,6 @@ void watch_set_buzzer_off(void);
/** @brief Plays the given note for a set duration at the loudest possible volume.
* @param note The note you wish to play, or BUZZER_NOTE_REST to disable output for the given duration.
* @param duration_ms The duration of the note.
* @note Note that this will block your UI for the duration of the note's play time, and it will
* after this call, the buzzer period will be set to the period of this note.
*/
void watch_buzzer_play_note(watch_buzzer_note_t note, uint16_t duration_ms);
@ -179,8 +172,6 @@ void watch_buzzer_play_note(watch_buzzer_note_t note, uint16_t duration_ms);
* @param note The note you wish to play, or BUZZER_NOTE_REST to disable output for the given duration.
* @param duration_ms The duration of the note.
* @param volume either WATCH_BUZZER_VOLUME_SOFT or WATCH_BUZZER_VOLUME_LOUD
* @note This will block your UI for the duration of the note's play time, and after this call, the
* buzzer will stop sounding, but the TCC period will remain set to the period of this note.
*/
void watch_buzzer_play_note_with_volume(watch_buzzer_note_t note, uint16_t duration_ms, watch_buzzer_volume_t volume);
@ -202,10 +193,69 @@ extern const uint16_t NotePeriods[108];
*/
void watch_buzzer_play_sequence(int8_t *note_sequence, void (*callback_on_end)(void));
/** @brief Plays the given sequence of notes in a non-blocking way.
* @param note_sequence A pointer to the sequence of buzzer note & duration tuples, ending with a zero. A simple
* RLE logic is implemented: a negative number instead of a buzzer note means that the sequence
* is rewound by the given number of notes. The byte following a negative number determines the number
* of loops. I.e. if you want to repeat the last three notes of the sequence one time, you should provide
* the tuple -3, 1. The repeated notes must not contain any other repeat markers, or you will end up with
* an eternal loop.
* @param callback_on_end A pointer to a callback function to be invoked when the sequence has finished playing.
* @param volume either WATCH_BUZZER_VOLUME_SOFT or WATCH_BUZZER_VOLUME_LOUD
*/
void watch_buzzer_play_sequence_with_volume(int8_t *note_sequence, void (*callback_on_end)(void), watch_buzzer_volume_t volume);
/** @brief Plays the given raw buzzer source function in a non-blocking way.
*
* @details This function plays audio data generated by a raw source callback function,
* allowing for precise control over buzzer timing and frequency. The raw source
* function is called repeatedly to generate audio samples, each containing a
* period and duration for the buzzer tone.
* Useful for applications such as chirpy, so that they won't need to allocate a
* long note sequence, and we will also take care of all the timing logic.
*
* @param raw_source Pointer to the callback function that generates raw buzzer data.
* The function should take a position parameter and return true if
* more data is available, false if end of sequence is reached.
* Parameters:
* - position: Current position in the audio sequence (0-based)
* - userdata: User-provided data passed through to the callback
* - period: Pointer to store the period (in microseconds) for the tone
* - duration: Pointer to store the duration (in microseconds) for the tone
* @param userdata Pointer to user data that will be passed to the raw_source callback
* @param callback_on_end A pointer to a callback function to be invoked when the sequence has finished playing.
*/
void watch_buzzer_play_raw_source(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end);
/** @brief Plays the given raw buzzer source function in a non-blocking way.
*
* @details This function plays audio data generated by a raw source callback function,
* allowing for precise control over buzzer timing and frequency. The raw source
* function is called repeatedly to generate audio samples, each containing a
* period and duration for the buzzer tone.
* Useful for applications such as chirpy, so that they won't need to allocate a
* long note sequence, and we will also take care of all the timing logic.
*
* @param raw_source Pointer to the callback function that generates raw buzzer data.
* The function should take a position parameter and return true if
* more data is available, false if end of sequence is reached.
* Parameters:
* - position: Current position in the audio sequence (0-based)
* - userdata: User-provided data passed through to the callback
* - period: Pointer to store the period (in microseconds) for the tone
* - duration: Pointer to store the duration (in microseconds) for the tone
* @param userdata Pointer to user data that will be passed to the raw_source callback
* @param callback_on_end A pointer to a callback function to be invoked when the sequence has finished playing.
* @param volume either WATCH_BUZZER_VOLUME_SOFT or WATCH_BUZZER_VOLUME_LOUD
*/
void watch_buzzer_play_raw_source_with_volume(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end, watch_buzzer_volume_t volume);
/** @brief Aborts a playing sequence.
*/
void watch_buzzer_abort_sequence(void);
void watch_buzzer_register_global_callbacks(watch_cb_t cb_start, watch_cb_t cb_stop);
#ifndef __EMSCRIPTEN__
void irq_handler_tc0(void);
#endif
@ -223,26 +273,17 @@ void irq_handler_tc0(void);
* so that watch_set_led_red sets the red LED, and watch_set_led_green sets the blue one.
*/
/// @{
/** @brief Enables the bi-color LED.
* @note The TCC peripheral that drives the LEDs does not run in STANDBY mode — but the outputs do! This
* means that if you set either red, green or both LEDs to full power, they will shine even when
* your app is asleep. If, however, you set a custom color using watch_set_led_color, the color will
* not display correctly in STANDBY mode. You will need to keep your app running while the LED is on.
/** @brief Enables the TCC peripheral, which drives the LEDs.
*/
void watch_enable_leds(void);
/** @brief Disables the LEDs.
* @note This method will also disable the buzzer, since the buzzer and LED both make use of the same
* peripheral to drive their PWM behavior.
/** @brief Disables the TCC peripheral that drives the LEDs (if buzzer not active).
*/
void watch_disable_leds(void);
/** @brief Sets the LED to a custom color by modulating each output's duty cycle.
* @param red The red value from 0-255.
* @param green The green value from 0-255. If your watch has a red/blue LED, this will be the blue value.
* @note If you are displaying a custom color, you will need to prevent your app from going to sleep
* while the LED is on; otherwise, the color will not display correctly. You can do this by
* returning false in your app_loop method.
*/
void watch_set_led_color(uint8_t red, uint8_t green);
@ -250,9 +291,6 @@ void watch_set_led_color(uint8_t red, uint8_t green);
* @param red The red value from 0-255.
* @param green The green value from 0-255.
* @param blue The blue value from 0-255.
* @note If you are displaying a custom color, you will need to prevent your app from going to sleep
* while the LED is on; otherwise, the color will not display correctly. You can do this by
* returning false in your app_loop method.
*/
void watch_set_led_color_rgb(uint8_t red, uint8_t green, uint8_t blue);
@ -277,9 +315,6 @@ void watch_set_led_yellow(void);
/** @brief Turns both the red and the green LEDs off. */
void watch_set_led_off(void);
/** @brief Disables the TCC peripheral. Should only be called internally. */
void _watch_disable_tcc(void);
/// @brief An array of periods for all the notes on a piano, corresponding to the names in watch_buzzer_note_t.
extern const uint16_t NotePeriods[108];

4
watch-library/shared/watch/watch_utility.c
View File

@ -278,6 +278,10 @@ watch_date_time_t watch_utility_date_time_convert_zone(watch_date_time_t date_ti
return watch_utility_date_time_from_unix_time(timestamp, destination_utc_offset);
}
uint32_t watch_utility_unix_time_convert_zone(uint32_t timestamp, uint32_t origin_utc_offset, uint32_t destination_utc_offset) {
return timestamp - origin_utc_offset + destination_utc_offset;
}
watch_duration_t watch_utility_seconds_to_duration(uint32_t seconds) {
watch_duration_t retval;

10
watch-library/shared/watch/watch_utility.h
View File

@ -144,6 +144,16 @@ bool watch_utility_convert_to_12_hour(watch_date_time_t *date_time);
*/
watch_date_time_t watch_utility_date_time_convert_zone(watch_date_time_t date_time, uint32_t origin_utc_offset, uint32_t destination_utc_offset);
/** @brief Converts a unix time from a given time zone to another time zone.
* @param timestamp The unix time that you wish to convert
* @param origin_utc_offset The number of seconds from UTC in the origin time zone
* @param destination_utc_offset The number of seconds from UTC in the destination time zone
* @return A unix time for the given UNIX timestamp and UTC offset.
* @note Adapted from MIT-licensed code from musl, Copyright © 2005-2014 Rich Felker, et al.:
* https://github.com/esmil/musl/blob/1cc81f5cb0df2b66a795ff0c26d7bbc4d16e13c6/src/time/__secs_to_tm.c
*/
uint32_t watch_utility_unix_time_convert_zone(uint32_t timestamp, uint32_t origin_utc_offset, uint32_t destination_utc_offset);
/** @brief Returns a temperature in degrees Celsius for a given thermistor voltage divider circuit.
* @param value The raw analog reading from the thermistor pin (0-65535)
* @param highside True if the thermistor is connected to VCC and the series resistor is connected

4
watch-library/simulator/watch/watch.c
View File

@ -1,9 +1,5 @@
#include "watch.h"
bool watch_is_buzzer_or_led_enabled(void) {
return false;
}
bool watch_is_usb_enabled(void) {
return true;
}

2
watch-library/simulator/watch/watch_private.c
View File

@ -51,8 +51,6 @@ int _gettimeofday(struct timeval *tv, void *tzvp) {
return 0;
}
void _watch_disable_tcc(void) {}
void _watch_enable_usb(void) {}
void watch_disable_TRNG() {}

343
watch-library/simulator/watch/watch_rtc.c
View File

@ -21,6 +21,7 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <limits.h>
#include "watch_rtc.h"
#include "watch_main_loop.h"
@ -29,8 +30,28 @@
#include <emscripten.h>
#include <emscripten/html5.h>
static const uint32_t RTC_CNT_HZ = 128;
static const uint32_t RTC_CNT_SUBSECOND_MASK = RTC_CNT_HZ - 1;
static const uint32_t RTC_CNT_DIV = 7;
static const uint32_t RTC_CNT_TICKS_PER_MINUTE = RTC_CNT_HZ * 60;
static uint32_t counter_interval;
static uint32_t counter;
static uint32_t reference_timestamp;
#define WATCH_RTC_N_COMP_CB 8
typedef struct {
volatile uint32_t counter;
volatile watch_cb_t callback;
volatile bool enabled;
} comp_cb_t;
static double time_offset = 0;
static long tick_callbacks[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
watch_cb_t tick_callbacks[8];
comp_cb_t comp_callbacks[WATCH_RTC_N_COMP_CB];
static uint32_t scheduled_comp_counter;
static long alarm_interval_id = -1;
static long alarm_timeout_id = -1;
@ -40,41 +61,73 @@ watch_cb_t btn_alarm_callback;
watch_cb_t a2_callback;
watch_cb_t a4_callback;
static void _watch_increase_counter(void *userData);
static void _watch_process_periodic_callbacks(void);
static void _watch_process_comp_callbacks(void);
bool _watch_rtc_is_enabled(void) {
return true;
return counter_interval;
}
void _watch_rtc_init(void) {
#if EMSCRIPTEN
// Shifts the timezone so our local time is converted to UTC and set
for (uint8_t index = 0; index < 8; ++index) {
tick_callbacks[index] = NULL;
}
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
comp_callbacks[index].counter = 0;
comp_callbacks[index].callback = NULL;
comp_callbacks[index].enabled = false;
}
scheduled_comp_counter = 0;
counter = 0;
counter_interval = 0;
watch_rtc_set_date_time(watch_get_init_date_time());
watch_rtc_enable(true);
}
void watch_rtc_set_date_time(rtc_date_time_t date_time) {
watch_rtc_set_unix_time(watch_utility_date_time_to_unix_time(date_time, 0));
}
rtc_date_time_t watch_rtc_get_date_time(void) {
return watch_utility_date_time_from_unix_time(watch_rtc_get_unix_time(), 0);
}
void watch_rtc_set_unix_time(unix_timestamp_t unix_time) {
// unix_time = time_backup + counter / RTC_CNT_HZ - 0.5
rtc_counter_t counter = watch_rtc_get_counter();
reference_timestamp = unix_time - (counter >> RTC_CNT_DIV) - ((counter & RTC_CNT_SUBSECOND_MASK) >> (RTC_CNT_DIV - 1)) + 1;
}
unix_timestamp_t watch_rtc_get_unix_time(void) {
// unix_time = time_backup + counter / RTC_CNT_HZ - 0.5
rtc_counter_t counter = watch_rtc_get_counter();
return reference_timestamp + (counter >> RTC_CNT_DIV) + ((counter & RTC_CNT_SUBSECOND_MASK) >> (RTC_CNT_DIV - 1)) - 1;
}
rtc_counter_t watch_rtc_get_counter(void) {
return counter;
}
uint32_t watch_rtc_get_frequency(void) {
return RTC_CNT_HZ;
}
uint32_t watch_rtc_get_ticks_per_minute(void) {
return RTC_CNT_TICKS_PER_MINUTE;
}
rtc_date_time_t watch_get_init_date_time(void) {
rtc_date_time_t date_time = {0};
int32_t time_zone_offset = EM_ASM_INT({
return -new Date().getTimezoneOffset() * 60;
return new Date().getTimezoneOffset() * 60 * 1000; // ms
});
#endif
#ifdef BUILD_YEAR
watch_date_time_t date_time = watch_get_init_date_time();
#else
watch_date_time_t date_time = watch_rtc_get_date_time();
#endif
watch_rtc_set_date_time(watch_utility_date_time_convert_zone(date_time, time_zone_offset, 0));
}
void watch_rtc_set_date_time(watch_date_time_t date_time) {
time_offset = EM_ASM_DOUBLE({
const year = 2020 + (($0 >> 26) & 0x3f);
const month = ($0 >> 22) & 0xf;
const day = ($0 >> 17) & 0x1f;
const hour = ($0 >> 12) & 0x1f;
const minute = ($0 >> 6) & 0x3f;
const second = $0 & 0x3f;
const date = new Date(year, month - 1, day, hour, minute, second);
return date - Date.now();
}, date_time.reg);
}
watch_date_time_t watch_rtc_get_date_time(void) {
watch_date_time_t retval;
retval.reg = EM_ASM_INT({
date_time.reg = EM_ASM_INT({
const date = new Date(Date.now() + $0);
return date.getSeconds() |
(date.getMinutes() << 6) |
@ -82,27 +135,16 @@ watch_date_time_t watch_rtc_get_date_time(void) {
(date.getDate() << 17) |
((date.getMonth() + 1) << 22) |
((date.getFullYear() - 2020) << 26);
}, time_offset);
return retval;
}
rtc_date_time_t watch_get_init_date_time(void) {
rtc_date_time_t date_time = {0};
}, time_zone_offset);
#ifdef BUILD_YEAR
date_time.unit.year = BUILD_YEAR;
#else
date_time.unit.year = 5;
#endif
#ifdef BUILD_MONTH
date_time.unit.month = BUILD_MONTH;
#else
date_time.unit.month = 1;
#endif
#ifdef BUILD_DAY
date_time.unit.day = BUILD_DAY;
#else
date_time.unit.day = 1;
#endif
#ifdef BUILD_HOUR
date_time.unit.hour = BUILD_HOUR;
@ -122,12 +164,72 @@ void watch_rtc_disable_tick_callback(void) {
watch_rtc_disable_periodic_callback(1);
}
static void watch_invoke_periodic_callback(void *userData) {
watch_cb_t callback = userData;
callback();
static void _watch_increase_counter(void *userData) {
(void) userData;
counter += 1;
// Fire the periodic callbacks that match this counter
_watch_process_periodic_callbacks();
// Fire the comp callbacks that match this counter
_watch_process_comp_callbacks();
resume_main_loop();
}
static void _watch_process_periodic_callbacks(void) {
/* It looks weird but it follows the way the hardware triggers periodic interrupts.
* For 128hz counter periodic interrupts fire at these tick values:
* 1Hz: 64
* 2Hz: 32, 96
* 4Hz: 16, 48, 80, 112
* 8Hz: 8, 24, 40, 56, 72, 88, 104, 120
* 16Hz: 4, 12, 20, ..., 124
* 32Hz: 2, 6, 10, ..., 126
* 64Hz: 1, 3, 5, ..., 127
* 128Hz: 0, 1, 2, ..., 127
*
* Which means that only one periodic interrupt can fire for a given counter value
* (except 128Hz which can always fire)
*/
uint32_t freq = watch_rtc_get_frequency();
uint32_t subsecond_mask = freq - 1;
uint32_t subseconds = counter & subsecond_mask;
// Find the firs non-zero bit in the counter, which can be used to determine the appropriate period (see table above).
uint8_t per_n = 0;
for (uint8_t i = 0; i < 7; i++) {
if (subseconds & (1 << i)) {
per_n = i + 1;
break;
}
}
if (tick_callbacks[per_n]) {
tick_callbacks[per_n]();
}
// 128Hz is always a match
if (per_n != 0 && tick_callbacks[0]) {
tick_callbacks[0]();
}
}
static void _watch_process_comp_callbacks(void) {
// In hardware the interrupt fires one tick after the matching counter
if (counter == (scheduled_comp_counter + 1)) {
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
if (comp_callbacks[index].enabled && scheduled_comp_counter == comp_callbacks[index].counter) {
comp_callbacks[index].enabled = false;
comp_callbacks[index].callback();
}
}
watch_rtc_schedule_next_comp();
}
}
void watch_rtc_register_periodic_callback(watch_cb_t callback, uint8_t frequency) {
// we told them, it has to be a power of 2.
if (__builtin_popcount(frequency) != 1) return;
@ -138,26 +240,19 @@ void watch_rtc_register_periodic_callback(watch_cb_t callback, uint8_t frequency
// 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);
double interval = 1000.0 / 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);
tick_callbacks[per_n] = callback;
}
void watch_rtc_disable_periodic_callback(uint8_t frequency) {
if (__builtin_popcount(frequency) != 1) return;
uint8_t per_n = __builtin_clz((frequency & 0xFF) << 24);
if (tick_callbacks[per_n] != -1) {
emscripten_clear_interval(tick_callbacks[per_n]);
tick_callbacks[per_n] = -1;
}
tick_callbacks[per_n] = NULL;
}
void watch_rtc_disable_matching_periodic_callbacks(uint8_t mask) {
for (int i = 0; i < 8; i++) {
if (tick_callbacks[i] != -1 && (mask & (1 << i)) != 0) {
emscripten_clear_interval(tick_callbacks[i]);
tick_callbacks[i] = -1;
if (tick_callbacks[i] && (mask & (1 << i)) != 0) {
tick_callbacks[i] = NULL;
}
}
}
@ -166,81 +261,95 @@ void watch_rtc_disable_all_periodic_callbacks(void) {
watch_rtc_disable_matching_periodic_callbacks(0xFF);
}
static void watch_invoke_alarm_interval_callback(void *userData) {
if (alarm_callback) alarm_callback();
}
static void watch_invoke_alarm_callback(void *userData) {
if (alarm_callback) alarm_callback();
alarm_interval_id = emscripten_set_interval(watch_invoke_alarm_interval_callback, alarm_interval, NULL);
}
void watch_rtc_register_alarm_callback(watch_cb_t callback, watch_date_time_t alarm_time, rtc_alarm_match_t mask) {
watch_rtc_disable_alarm_callback();
switch (mask) {
case ALARM_MATCH_DISABLED:
void watch_rtc_register_comp_callback(watch_cb_t callback, rtc_counter_t counter, uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
case ALARM_MATCH_SS:
alarm_interval = 60 * 1000;
break;
case ALARM_MATCH_MMSS:
alarm_interval = 60 * 60 * 1000;
break;
case ALARM_MATCH_HHMMSS:
alarm_interval = 60 * 60 * 60 * 1000;
break;
}
double timeout = EM_ASM_DOUBLE({
const now = Date.now();
const date = new Date(now);
comp_callbacks[index].counter = counter;
comp_callbacks[index].callback = callback;
comp_callbacks[index].enabled = true;
const hour = ($0 >> 12) & 0x1f;
const minute = ($0 >> 6) & 0x3f;
const second = $0 & 0x3f;
if ($1 == 1) { // SS
if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1);
date.setSeconds(second);
} else if ($1 == 2) { // MMSS
if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1);
if (minute < date.getMinutes()) date.setHours(date.getHours() + 1);
date.setMinutes(minute, second);
} else if ($1 == 3) { // HHMMSS
if (second < date.getSeconds()) date.setMinutes(date.getMinutes() + 1);
if (minute < date.getMinutes()) date.setHours(date.getHours() + 1);
if (hour < date.getHours()) date.setDate(date.getDate() + 1);
date.setHours(hour, minute, second);
} else {
throw 'Invalid alarm match mask';
}
return date - now;
}, alarm_time.reg, mask);
alarm_callback = callback;
alarm_timeout_id = emscripten_set_timeout(watch_invoke_alarm_callback, timeout, NULL);
watch_rtc_schedule_next_comp();
}
void watch_rtc_disable_alarm_callback(void) {
alarm_callback = NULL;
alarm_interval = 0;
if (alarm_timeout_id != -1) {
emscripten_clear_timeout(alarm_timeout_id);
alarm_timeout_id = -1;
void watch_rtc_register_comp_callback_no_schedule(watch_cb_t callback, rtc_counter_t counter, uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
if (alarm_interval_id != -1) {
emscripten_clear_interval(alarm_interval_id);
alarm_interval_id = -1;
comp_callbacks[index].counter = counter;
comp_callbacks[index].callback = callback;
comp_callbacks[index].enabled = true;
}
void watch_rtc_disable_comp_callback(uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
comp_callbacks[index].enabled = false;
watch_rtc_schedule_next_comp();
}
void watch_rtc_disable_comp_callback_no_schedule(uint8_t index) {
if (index >= WATCH_RTC_N_COMP_CB) {
return;
}
comp_callbacks[index].enabled = false;
}
void watch_rtc_schedule_next_comp(void) {
rtc_counter_t curr_counter = watch_rtc_get_counter();
// If there is already a pending comp interrupt for this very tick, let it fire
// And this function will be called again as soon as the interrupt fires.
if (curr_counter == scheduled_comp_counter) {
return;
}
// The soonest we can schedule is the next tick
curr_counter +=1;
bool schedule_any = false;
rtc_counter_t comp_counter;
rtc_counter_t min_diff = UINT_MAX;
for (uint8_t index = 0; index < WATCH_RTC_N_COMP_CB; ++index) {
// rtc_counter_t diff =
if (comp_callbacks[index].enabled) {
rtc_counter_t diff = comp_callbacks[index].counter - curr_counter;
if (diff <= min_diff) {
min_diff = diff;
comp_counter = comp_callbacks[index].counter;
schedule_any = true;
}
}
}
if (schedule_any) {
scheduled_comp_counter = comp_counter;
} else {
scheduled_comp_counter = curr_counter - 2;
}
}
void watch_rtc_enable(bool en)
{
//Not simulated
// Nothing to do cases
if ((en && counter_interval) || (!en && !counter_interval)) {
return;
}
if (en) {
// Very bad way to keep time, but okay way to emulates the hardware.
double ms = 1000.0 / (double)RTC_CNT_HZ; // in msec
counter_interval = emscripten_set_interval(_watch_increase_counter, ms, NULL);
} else {
emscripten_clear_interval(counter_interval);
counter_interval = 0;
}
}
void watch_rtc_freqcorr_write(int16_t value, int16_t sign)

146
watch-library/simulator/watch/watch_tcc.c
View File

@ -28,18 +28,23 @@
#include <emscripten.h>
#include <emscripten/html5.h>
static bool buzzer_enabled = false;
static volatile bool buzzer_enabled = false;
static uint32_t buzzer_period;
void cb_watch_buzzer_seq(void *userData);
void cb_watch_buzzer_raw_source(void *userData);
static uint16_t _seq_position;
static int8_t _tone_ticks, _repeat_counter;
static long _em_interval_id = 0;
static volatile long _em_interval_id = 0;
static int8_t *_sequence;
static watch_buzzer_raw_source_t _raw_source;
static void* _userdata;
static uint8_t _volume;
static void (*_cb_finished)(void);
void _watch_enable_tcc(void) {}
static watch_cb_t _cb_start_global = NULL;
static watch_cb_t _cb_stop_global = NULL;
static volatile bool _buzzer_is_active = false;
static inline void _em_interval_stop() {
emscripten_clear_interval(_em_interval_id);
@ -47,15 +52,28 @@ static inline void _em_interval_stop() {
}
void watch_buzzer_play_sequence(int8_t *note_sequence, void (*callback_on_end)(void)) {
if (_em_interval_id) _em_interval_stop();
watch_buzzer_play_sequence_with_volume(note_sequence, callback_on_end, WATCH_BUZZER_VOLUME_LOUD);
}
void watch_buzzer_play_sequence_with_volume(int8_t *note_sequence, void (*callback_on_end)(void), watch_buzzer_volume_t volume) {
watch_buzzer_abort_sequence();
// prepare buzzer
watch_enable_buzzer();
watch_set_buzzer_off();
_buzzer_is_active = true;
if (_cb_start_global) {
_cb_start_global();
}
_sequence = note_sequence;
_cb_finished = callback_on_end;
_volume = volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25;
_seq_position = 0;
_tone_ticks = 0;
_repeat_counter = -1;
// prepare buzzer
watch_enable_buzzer();
// initiate 64 hz callback
_em_interval_id = emscripten_set_interval(cb_watch_buzzer_seq, (double)(1000/64), (void *)NULL);
}
@ -88,32 +106,115 @@ void cb_watch_buzzer_seq(void *userData) {
if (note == BUZZER_NOTE_REST) {
watch_set_buzzer_off();
} else {
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], 25);
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], _volume);
watch_set_buzzer_on();
}
// set duration ticks and move to next tone
_tone_ticks = _sequence[_seq_position + 1];
_tone_ticks = _sequence[_seq_position + 1] - 1;
_seq_position += 2;
} else {
// end the sequence
watch_buzzer_abort_sequence();
if (_cb_finished) _cb_finished();
}
} else _tone_ticks--;
}
void watch_buzzer_play_raw_source(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end) {
watch_buzzer_play_raw_source_with_volume(raw_source, userdata, callback_on_end, WATCH_BUZZER_VOLUME_LOUD);
}
void watch_buzzer_play_raw_source_with_volume(watch_buzzer_raw_source_t raw_source, void* userdata, watch_cb_t callback_on_end, watch_buzzer_volume_t volume) {
watch_buzzer_abort_sequence();
// prepare buzzer
watch_enable_buzzer();
watch_set_buzzer_off();
_buzzer_is_active = true;
if (_cb_start_global) {
_cb_start_global();
}
_raw_source = raw_source;
_userdata = userdata;
_cb_finished = callback_on_end;
_volume = volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25;
_seq_position = 0;
_tone_ticks = 0;
// initiate 64 hz callback
_em_interval_id = emscripten_set_interval(cb_watch_buzzer_raw_source, (double)(1000/64), (void *)NULL);
}
void cb_watch_buzzer_raw_source(void *userData) {
// callback for reading the note sequence
(void) userData;
uint16_t period;
uint16_t duration;
bool done;
if (_tone_ticks == 0) {
done = _raw_source(_seq_position, _userdata, &period, &duration);
if (done || duration == 0) {
// end the sequence
watch_buzzer_abort_sequence();
} else {
if (period == WATCH_BUZZER_PERIOD_REST) {
watch_set_buzzer_off();
} else {
watch_set_buzzer_period_and_duty_cycle(period, _volume);
watch_set_buzzer_on();
}
// set duration ticks and move to next tone
_tone_ticks = duration - 1;
_seq_position += 1;
}
} else {
_tone_ticks--;
}
}
void watch_buzzer_abort_sequence(void) {
// ends/aborts the sequence
if (_em_interval_id) _em_interval_stop();
watch_set_buzzer_off();
watch_disable_buzzer();
if (!_buzzer_is_active) {
return;
}
_buzzer_is_active = false;
if (_cb_stop_global) {
_cb_stop_global();
}
if (_cb_finished) {
_cb_finished();
}
}
void watch_buzzer_register_global_callbacks(watch_cb_t cb_start, watch_cb_t cb_stop) {
_cb_stop_global = cb_start;
_cb_stop_global = cb_stop;
}
void watch_enable_buzzer(void) {
watch_buzzer_abort_sequence();
buzzer_enabled = true;
buzzer_period = NotePeriods[BUZZER_NOTE_A4];
EM_ASM({
// "It's recommended to create one AudioContext and reuse it instead of initializing a new one each time."
// https://developer.mozilla.org/en-US/docs/Web/API/AudioContext
if (!Module['audioContext']) {
Module['audioContext'] = new (window.AudioContext || window.webkitAudioContext)();
}
});
}
@ -126,13 +227,6 @@ void watch_set_buzzer_period_and_duty_cycle(uint32_t period, uint8_t duty_cycle)
void watch_disable_buzzer(void) {
buzzer_enabled = false;
buzzer_period = NotePeriods[BUZZER_NOTE_A4];
EM_ASM({
if (Module['audioContext']) {
Module['audioContext'].close();
Module['audioContext'] = null;
}
});
}
void watch_set_buzzer_on(void) {
@ -175,15 +269,17 @@ void watch_buzzer_play_note(watch_buzzer_note_t note, uint16_t duration_ms) {
}
void watch_buzzer_play_note_with_volume(watch_buzzer_note_t note, uint16_t duration_ms, watch_buzzer_volume_t volume) {
if (note == BUZZER_NOTE_REST) {
watch_set_buzzer_off();
} else {
watch_set_buzzer_period_and_duty_cycle(NotePeriods[note], volume == WATCH_BUZZER_VOLUME_SOFT ? 5 : 25);
watch_set_buzzer_on();
}
static int8_t single_note_sequence[3];
main_loop_sleep(duration_ms);
watch_set_buzzer_off();
single_note_sequence[0] = note;
// 64 ticks per second for the tc0
// Each tick is approximately 15ms
uint16_t duration = duration_ms / 15;
if (duration > 127) duration = 127;
single_note_sequence[1] = (int8_t)duration;
single_note_sequence[2] = 0;
watch_buzzer_play_sequence_with_volume(single_note_sequence, NULL, volume);
}
void watch_enable_leds(void) {}