// Also note that this board has its INT1 pin wired to A1, which is not an external
// wake pin. Future accelerometer boards will wire interrupt pins to A2 and A4.
-void cb_light_pressed() {
+void cb_light_pressed(void) {
}
-void cb_mode_pressed() {
+void cb_mode_pressed(void) {
}
-void cb_alarm_pressed() {
+void cb_alarm_pressed(void) {
}
uint8_t interrupts = 0;
uint8_t ticks = 0;
char buf[13] = {0};
-void cb_interrupt_1() {
+void cb_interrupt_1(void) {
interrupts++;
}
-void cb_tick() {
+void cb_tick(void) {
if (++ticks == 30) {
last_interrupts = interrupts;
interrupts = 0;
}
}
-void app_init() {
+void app_init(void) {
gpio_set_pin_direction(A0, GPIO_DIRECTION_OUT);
gpio_set_pin_function(A0, GPIO_PIN_FUNCTION_OFF);
gpio_set_pin_level(A0, true);
watch_rtc_register_tick_callback(cb_tick);
}
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
}
-void app_setup() {
+void app_setup(void) {
}
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
}
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
}
-bool app_loop() {
+bool app_loop(void) {
sprintf(buf, "IN%2d%3d%3d", ticks, interrupts, last_interrupts);
watch_display_string(buf, 0);
uint8_t subsecond; // a value from 0 to (BEAT_REFRESH_FREQUENCY - 1) indicating the fractional second
} ApplicationState;
-void do_clock_mode();
-void do_beats_mode();
-void do_set_time_mode();
-void set_time_mode_handle_primary_button();
-void set_time_mode_handle_secondary_button();
+void do_clock_mode(void);
+void do_beats_mode(void);
+void do_set_time_mode(void);
+void set_time_mode_handle_primary_button(void);
+void set_time_mode_handle_secondary_button(void);
float clock2beats(uint16_t, uint16_t, uint16_t, int16_t);
-void cb_light_pressed();
-void cb_mode_pressed();
-void cb_alarm_pressed();
-void cb_tick();
-void cb_fast_tick();
+void cb_light_pressed(void);
+void cb_mode_pressed(void);
+void cb_alarm_pressed(void);
+void cb_tick(void);
+void cb_fast_tick(void);
ApplicationState application_state;
char buf[16] = {0};
/**
* @brief Zeroes out the application state struct.
*/
-void app_init() {
+void app_init(void) {
memset(&application_state, 0, sizeof(application_state));
}
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
// This app does not support BACKUP mode.
}
-void app_setup() {
+void app_setup(void) {
watch_enable_external_interrupts();
watch_register_interrupt_callback(BTN_MODE, cb_mode_pressed, INTERRUPT_TRIGGER_RISING);
watch_register_interrupt_callback(BTN_LIGHT, cb_light_pressed, INTERRUPT_TRIGGER_RISING);
watch_rtc_register_tick_callback(cb_tick);
}
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
}
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
}
-void update_tick_frequency() {
+static void update_tick_frequency(void) {
watch_rtc_disable_all_periodic_callbacks();
if (application_state.mode == MODE_BEATS) {
watch_rtc_register_periodic_callback(cb_fast_tick, BEAT_REFRESH_FREQUENCY);
}
}
-bool app_loop() {
+bool app_loop(void) {
// play a beep if the mode has changed in response to a user's press of the MODE button
if (application_state.mode_changed) {
// low note for nonzero case, high note for return to clock
return true;
}
-void do_clock_mode() {
+void do_clock_mode(void) {
watch_date_time date_time = watch_rtc_get_date_time();
const char months[12][3] = {"JA", "FE", "MR", "AR", "MA", "JN", "JL", "AU", "SE", "OC", "NO", "dE"};
}
-void do_beats_mode() {
+void do_beats_mode(void) {
watch_clear_colon();
watch_date_time date_time = watch_rtc_get_date_time();
return beats;
}
-void do_set_time_mode() {
+void do_set_time_mode(void) {
watch_date_time date_time = watch_rtc_get_date_time();
watch_display_string(" ", 0);
watch_set_pixel(1, 12); // required for T in position 1
}
-void set_time_mode_handle_primary_button() {
+void set_time_mode_handle_primary_button(void) {
application_state.page++;
if (application_state.page == 6) application_state.page = 0;
}
-void set_time_mode_handle_secondary_button() {
+void set_time_mode_handle_secondary_button(void) {
watch_date_time date_time = watch_rtc_get_date_time();
const uint8_t days_in_month[12] = {31, 28, 31, 30, 31, 30, 30, 31, 30, 31, 30, 31};
watch_rtc_set_date_time(date_time);
}
-void cb_mode_pressed() {
+void cb_mode_pressed(void) {
application_state.mode = (application_state.mode + 1) % NUM_MODES;
application_state.mode_changed = true;
application_state.mode_ticks = 300;
application_state.page = 0;
}
-void cb_light_pressed() {
+void cb_light_pressed(void) {
switch (application_state.mode) {
case MODE_SET:
set_time_mode_handle_secondary_button();
}
}
-void cb_alarm_pressed() {
+void cb_alarm_pressed(void) {
switch (application_state.mode) {
case MODE_SET:
set_time_mode_handle_primary_button();
}
}
-void cb_tick() {
+void cb_tick(void) {
if (application_state.light_ticks > 0) {
application_state.light_ticks--;
}
}
}
-void cb_fast_tick() {
+void cb_fast_tick(void) {
watch_date_time date_time = watch_rtc_get_date_time();
if (date_time.unit.second != application_state.last_second) {
application_state.last_second = date_time.unit.second;
ApplicationState application_state;
-void cb_alarm_pressed() {
+void cb_alarm_pressed(void) {
application_state.play = true;
}
-void app_init() {
+void app_init(void) {
memset(&application_state, 0, sizeof(application_state));
}
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
}
-void app_setup() {
+void app_setup(void) {
watch_register_extwake_callback(BTN_ALARM, cb_alarm_pressed, true);
watch_enable_display();
watch_enable_buzzer();
}
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
watch_display_string(" rains ", 2);
}
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
}
-bool app_loop() {
+bool app_loop(void) {
if (application_state.play) {
printf("Playing song...\n");
const BuzzerNote rains[] = {
struct io_descriptor *io;
struct spi_m_sync_descriptor SPI_0;
-void app_init() {
+void app_init(void) {
// SPI_0_CLOCK_init
hri_gclk_write_PCHCTRL_reg(GCLK, SERCOM3_GCLK_ID_CORE, CONF_GCLK_SERCOM3_CORE_SRC | (1 << GCLK_PCHCTRL_CHEN_Pos));
hri_gclk_write_PCHCTRL_reg(GCLK, SERCOM3_GCLK_ID_SLOW, CONF_GCLK_SERCOM3_SLOW_SRC | (1 << GCLK_PCHCTRL_CHEN_Pos));
spi_m_sync_enable(&SPI_0);
}
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
}
-void app_setup() {
+void app_setup(void) {
}
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
}
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
}
static uint8_t get_id_command[4] = {0x9F};
-bool app_loop() {
+bool app_loop(void) {
watch_set_pin_level(A3, false);
io_write(io, get_id_command, 1);
uint8_t buf[3] = {0};
//////////////////////////////////////////////////////////////////////////////////////////
// This section defines the callbacks for our button press events (implemented at bottom).
// Add any other callbacks you may need either here or in another file.
-void cb_light_pressed();
-void cb_mode_pressed();
-void cb_alarm_pressed();
+void cb_light_pressed(void);
+void cb_mode_pressed(void);
+void cb_alarm_pressed(void);
//////////////////////////////////////////////////////////////////////////////////////////
* @brief the app_init function is called before anything else. Use it to set up any
* internal data structures or application state required by your app.
*/
-void app_init() {
+void app_init(void) {
memset(&application_state, 0, sizeof(application_state));
}
*
* @see watch_enter_deep_sleep()
*/
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
// This app does not support BACKUP mode.
}
* also wiped out the system RAM. Note that when this is called after waking from sleep,
* the RTC will still be configured with the correct date and time.
*/
-void app_setup() {
+void app_setup(void) {
watch_enable_leds();
watch_enable_buzzer();
* In STANDBY mode, most peripherals are shut down, and no code will run until the watch receives
* an interrupt (generally either the 1Hz tick or a press on one of the buttons).
*/
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
}
/**
* @brief the app_wake_from_standby function is called after the watch wakes from STANDBY mode,
* but before your main app_loop.
*/
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
application_state.wake_count++;
}
* @brief the app_loop function is called once on app startup and then again each time the
* watch exits STANDBY mode.
*/
-bool app_loop() {
+bool app_loop(void) {
if (application_state.beep) {
watch_buzzer_play_note(BUZZER_NOTE_C7, 50);
application_state.beep = false;
//////////////////////////////////////////////////////////////////////////////////////////
// Implementations for our callback functions. Replace these with whatever functionality
// your app requires.
-void cb_light_pressed() {
+void cb_light_pressed(void) {
// always turn the light off when the pin goes low
if (watch_get_pin_level(BTN_LIGHT) == 0) {
application_state.light_on = false;
application_state.light_on = true;
}
-void cb_mode_pressed() {
+void cb_mode_pressed(void) {
application_state.mode = (application_state.mode + 1) % 2;
application_state.beep = true;
}
-void cb_alarm_pressed() {
+void cb_alarm_pressed(void) {
application_state.enter_sleep_mode = true;
}
return ((number << bits) | (uint32_t)(number >> (32-bits)));\r
}\r
\r
-void hashBlock() {\r
+void hashBlock(void) {\r
uint8_t i;\r
uint32_t a,b,c,d,e,t;\r
\r
}\r
}\r
\r
-void pad() {\r
+void pad(void) {\r
// Implement SHA-1 padding (fips180-2 ��5.1.1)\r
\r
// Pad with 0x80 followed by 0x00 until the end of the block\r
const char movement_valid_position_0_chars[] = " AaBbCcDdEeFGgHhIiJKLMNnOoPQrSTtUuWXYZ-='+\\/0123456789";
const char movement_valid_position_1_chars[] = " ABCDEFHlJLNORTtUX-='01378";
-void cb_mode_btn_interrupt();
-void cb_light_btn_interrupt();
-void cb_alarm_btn_interrupt();
-void cb_alarm_btn_extwake();
-void cb_alarm_fired();
-void cb_fast_tick();
-void cb_tick();
-
-static inline void _movement_reset_inactivity_countdown() {
+void cb_mode_btn_interrupt(void);
+void cb_light_btn_interrupt(void);
+void cb_alarm_btn_interrupt(void);
+void cb_alarm_btn_extwake(void);
+void cb_alarm_fired(void);
+void cb_fast_tick(void);
+void cb_tick(void);
+
+static inline void _movement_reset_inactivity_countdown(void) {
movement_state.le_mode_ticks = movement_le_inactivity_deadlines[movement_state.settings.bit.le_interval];
movement_state.timeout_ticks = movement_timeout_inactivity_deadlines[movement_state.settings.bit.to_interval];
}
-static inline void _movement_enable_fast_tick_if_needed() {
+static inline void _movement_enable_fast_tick_if_needed(void) {
if (!movement_state.fast_tick_enabled) {
movement_state.fast_ticks = 0;
watch_rtc_register_periodic_callback(cb_fast_tick, 128);
}
}
-static inline void _movement_disable_fast_tick_if_possible() {
+static inline void _movement_disable_fast_tick_if_possible(void) {
if ((movement_state.light_ticks == -1) &&
(movement_state.alarm_ticks == -1) &&
((movement_state.light_down_timestamp + movement_state.mode_down_timestamp + movement_state.alarm_down_timestamp) == 0)) {
}
}
-void _movement_handle_background_tasks() {
+static void _movement_handle_background_tasks(void) {
for(uint8_t i = 0; i < MOVEMENT_NUM_FACES; i++) {
// For each face, if the watch face wants a background task...
if (watch_faces[i].wants_background_task != NULL && watch_faces[i].wants_background_task(&movement_state.settings, watch_face_contexts[i])) {
watch_rtc_register_periodic_callback(cb_tick, freq);
}
-void movement_illuminate_led() {
+void movement_illuminate_led(void) {
if (movement_state.settings.bit.led_duration) {
watch_set_led_color(movement_state.settings.bit.led_red_color ? (0xF | movement_state.settings.bit.led_red_color << 4) : 0,
movement_state.settings.bit.led_green_color ? (0xF | movement_state.settings.bit.led_green_color << 4) : 0);
movement_state.next_watch_face = watch_face_index;
}
-void movement_move_to_next_face() {
+void movement_move_to_next_face(void) {
movement_move_to_face((movement_state.current_watch_face + 1) % MOVEMENT_NUM_FACES);
}
-void movement_play_signal() {
+void movement_play_signal(void) {
watch_buzzer_play_note(BUZZER_NOTE_C8, 75);
watch_buzzer_play_note(BUZZER_NOTE_REST, 100);
watch_buzzer_play_note(BUZZER_NOTE_C8, 100);
}
-void movement_play_alarm() {
+void movement_play_alarm(void) {
movement_state.alarm_ticks = 128 * 5 - 80; // 80 ticks short of 5 seconds, or 4.375 seconds (our beep is 0.375 seconds)
_movement_enable_fast_tick_if_needed();
}
-void app_init() {
+void app_init(void) {
memset(&movement_state, 0, sizeof(movement_state));
movement_state.settings.bit.led_green_color = 0xF;
_movement_reset_inactivity_countdown();
}
-void app_wake_from_backup() {
+void app_wake_from_backup(void) {
movement_state.settings.reg = watch_get_backup_data(0);
}
-void app_setup() {
+void app_setup(void) {
watch_store_backup_data(movement_state.settings.reg, 0);
static bool is_first_launch = true;
}
}
-void app_prepare_for_standby() {
+void app_prepare_for_standby(void) {
}
-void app_wake_from_standby() {
+void app_wake_from_standby(void) {
}
-bool app_loop() {
+bool app_loop(void) {
if (movement_state.watch_face_changed) {
if (movement_state.settings.bit.button_should_sound) {
// low note for nonzero case, high note for return to watch_face 0
return can_sleep && (movement_state.light_ticks == -1) && !movement_state.is_buzzing;
}
-movement_event_type_t _figure_out_button_event(bool pin_level, movement_event_type_t button_down_event_type, uint8_t *down_timestamp) {
+static movement_event_type_t _figure_out_button_event(bool pin_level, movement_event_type_t button_down_event_type, uint8_t *down_timestamp) {
// force alarm off if the user pressed a button.
if (movement_state.alarm_ticks) movement_state.alarm_ticks = 0;
}
}
-void cb_light_btn_interrupt() {
+void cb_light_btn_interrupt(void) {
bool pin_level = watch_get_pin_level(BTN_LIGHT);
_movement_reset_inactivity_countdown();
event.event_type = _figure_out_button_event(pin_level, EVENT_LIGHT_BUTTON_DOWN, &movement_state.light_down_timestamp);
}
-void cb_mode_btn_interrupt() {
+void cb_mode_btn_interrupt(void) {
bool pin_level = watch_get_pin_level(BTN_MODE);
_movement_reset_inactivity_countdown();
event.event_type = _figure_out_button_event(pin_level, EVENT_MODE_BUTTON_DOWN, &movement_state.mode_down_timestamp);
}
-void cb_alarm_btn_interrupt() {
+void cb_alarm_btn_interrupt(void) {
bool pin_level = watch_get_pin_level(BTN_ALARM);
_movement_reset_inactivity_countdown();
event.event_type = _figure_out_button_event(pin_level, EVENT_ALARM_BUTTON_DOWN, &movement_state.alarm_down_timestamp);
}
-void cb_alarm_btn_extwake() {
+void cb_alarm_btn_extwake(void) {
// wake up!
_movement_reset_inactivity_countdown();
}
-void cb_alarm_fired() {
+void cb_alarm_fired(void) {
movement_state.needs_background_tasks_handled = true;
}
-void cb_fast_tick() {
+void cb_fast_tick(void) {
movement_state.fast_ticks++;
if (movement_state.light_ticks > 0) movement_state.light_ticks--;
if (movement_state.alarm_ticks > 0) movement_state.alarm_ticks--;
if (movement_state.fast_ticks >= 1280) watch_rtc_disable_periodic_callback(128);
}
-void cb_tick() {
+void cb_tick(void) {
event.event_type = EVENT_TICK;
watch_date_time date_time = watch_rtc_get_date_time();
if (date_time.unit.second != movement_state.last_second) {
} movement_state_t;
void movement_move_to_face(uint8_t watch_face_index);
-void movement_move_to_next_face();
-void movement_illuminate_led();
+void movement_move_to_next_face(void);
+void movement_illuminate_led(void);
void movement_request_tick_frequency(uint8_t freq);
-void movement_play_signal();
-void movement_play_alarm();
+void movement_play_signal(void);
+void movement_play_alarm(void);
#endif // MOVEMENT_H_
watch_set_colon();
}
-bool world_clock_face_do_display_mode(movement_event_t event, movement_settings_t *settings, world_clock_state_t *state) {
+static bool world_clock_face_do_display_mode(movement_event_t event, movement_settings_t *settings, world_clock_state_t *state) {
char buf[11];
uint8_t pos;
return true;
}
-bool world_clock_face_do_settings_mode(movement_event_t event, movement_settings_t *settings, world_clock_state_t *state) {
+static bool _world_clock_face_do_settings_mode(movement_event_t event, movement_settings_t *settings, world_clock_state_t *state) {
switch (event.event_type) {
case EVENT_MODE_BUTTON_UP:
movement_move_to_next_face();
if (state->current_screen == 0) {
return world_clock_face_do_display_mode(event, settings, state);
} else {
- return world_clock_face_do_settings_mode(event, settings, state);
+ return _world_clock_face_do_settings_mode(event, settings, state);
}
}
#include "day_one_face.h"
#include "watch.h"
-uint32_t _day_one_face_juliandaynum(uint16_t year, uint16_t month, uint16_t day) {
+static uint32_t _day_one_face_juliandaynum(uint16_t year, uint16_t month, uint16_t day) {
// from here: https://en.wikipedia.org/wiki/Julian_day#Julian_day_number_calculation
return (1461 * (year + 4800 + (month - 14) / 12)) / 4 + (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12 - (3 * ((year + 4900 + (month - 14) / 12) / 100))/4 + day - 32075;
}
-void _day_one_face_update(day_one_state_t state) {
+static void _day_one_face_update(day_one_state_t state) {
char buf[14];
watch_date_time date_time = watch_rtc_get_date_time();
uint32_t julian_date = _day_one_face_juliandaynum(date_time.unit.year + WATCH_RTC_REFERENCE_YEAR, date_time.unit.month, date_time.unit.day);
// Pressing the alarm button enters the log mode, where the main display shows the number of interrupts detected in each of the last
// 24 hours (the hour is shown in the top right digit and AM/PM indicator, if the clock is set to 12 hour mode)
-void _lis2dh_logging_face_log_data(lis2dh_logger_state_t *logger_state) {
+static void _lis2dh_logging_face_log_data(lis2dh_logger_state_t *logger_state) {
watch_date_time date_time = watch_rtc_get_date_time();
date_time.unit.hour = (date_time.unit.hour + 23) % 24; // log this as the number of events in the previous hour
size_t pos = logger_state->data_points % LIS2DH_LOGGING_NUM_DATA_POINTS;
#include "voltage_face.h"
#include "watch.h"
-void _voltage_face_update_display() {
+static void _voltage_face_update_display(void) {
char buf[14];
float voltage = (float)watch_get_vcc_voltage() / 1000.0;
sprintf(buf, "BA %4.2f V", voltage);
#include "watch.h"
#include "watch_utility.h"
-void thermistor_driver_enable() {
+void thermistor_driver_enable(void) {
// Enable the ADC peripheral, which we'll use to read the thermistor value.
watch_enable_adc();
// Enable analog circuitry on the sense pin, which is tied to the thermistor resistor divider.
watch_set_pin_level(THERMISTOR_ENABLE_PIN, !THERMISTOR_ENABLE_VALUE);
}
-void thermistor_driver_disable() {
+void thermistor_driver_disable(void) {
// Disable the ADC peripheral.
watch_disable_adc();
// Disable analog circuitry on the sense pin to save power.
watch_disable_digital_output(THERMISTOR_ENABLE_PIN);
}
-float thermistor_driver_get_temperature() {
+float thermistor_driver_get_temperature(void) {
// set the enable pin to the level that powers the thermistor circuit.
watch_set_pin_level(THERMISTOR_ENABLE_PIN, THERMISTOR_ENABLE_VALUE);
// get the sense pin level
#define THERMISTOR_NOMINAL_RESISTANCE (10000.0)
#define THERMISTOR_SERIES_RESISTANCE (10000.0)
-void thermistor_driver_enable();
-void thermistor_driver_disable();
-float thermistor_driver_get_temperature();
+void thermistor_driver_enable(void);
+void thermistor_driver_disable(void);
+float thermistor_driver_get_temperature(void);
#endif // THERMISTOR_DRIVER_H_
#include "thermistor_driver.h"
#include "watch.h"
-void _thermistor_logging_face_log_data(thermistor_logger_state_t *logger_state) {
+static void _thermistor_logging_face_log_data(thermistor_logger_state_t *logger_state) {
thermistor_driver_enable();
watch_date_time date_time = watch_rtc_get_date_time();
size_t pos = logger_state->data_points % THERMISTOR_LOGGING_NUM_DATA_POINTS;
thermistor_driver_disable();
}
-void _thermistor_logging_face_update_display(thermistor_logger_state_t *logger_state, bool in_fahrenheit, bool clock_mode_24h) {
+static void _thermistor_logging_face_update_display(thermistor_logger_state_t *logger_state, bool in_fahrenheit, bool clock_mode_24h) {
int8_t pos = (logger_state->data_points - 1 - logger_state->display_index) % THERMISTOR_LOGGING_NUM_DATA_POINTS;
char buf[14];
#include "thermistor_driver.h"
#include "watch.h"
-void _thermistor_readout_face_update_display(bool in_fahrenheit) {
+static void _thermistor_readout_face_update_display(bool in_fahrenheit) {
thermistor_driver_enable();
float temperature_c = thermistor_driver_get_temperature();
char buf[14];
}
-void setup() {
+void setup(void) {
pinMode(13, OUTPUT);
Serial.begin(115200);
// while(!Serial) {
dap.dap_disconnect();
}
-void loop() {
+void loop(void) {
//blink led on the host to show we're done
digitalWrite(13, HIGH);
delay(500);
#include "lis2dh.h"
#include "watch.h"
-bool lis2dh_begin() {
+bool lis2dh_begin(void) {
if (lis2dh_get_device_id() != LIS2DH_WHO_AM_I_VAL) {
return false;
}
return true;
}
-uint8_t lis2dh_get_device_id() {
+uint8_t lis2dh_get_device_id(void) {
return watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_WHO_AM_I);
}
-bool lis2dh_have_new_data() {
+bool lis2dh_have_new_data(void) {
uint8_t retval = watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_STATUS);
return !!retval; // return true if any bit is set
}
-lis2dh_reading lis2dh_get_raw_reading() {
+lis2dh_reading lis2dh_get_raw_reading(void) {
uint8_t buffer[6];
uint8_t reg = LIS2DH_REG_OUT_X_L | 0x80; // set high bit for consecutive reads
lis2dh_reading retval;
watch_i2c_write8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL4, val | bits);
}
-lis2dh_range_t lis2dh_get_range() {
+lis2dh_range_t lis2dh_get_range(void) {
uint8_t retval = watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL4) & 0x30;
retval >>= 4;
return (lis2dh_range_t)retval;
watch_i2c_write8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL1, val | bits);
}
-lis2dh_data_rate_t lis2dh_get_data_rate() {
+lis2dh_data_rate_t lis2dh_get_data_rate(void) {
return watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL1) >> 4;
}
watch_i2c_write8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL5, val | latch ? LIS2DH_CTRL5_VAL_LIR_INT1 : 0);
}
-lis2dh_interrupt_state lis2dh_get_int1_state() {
+lis2dh_interrupt_state lis2dh_get_int1_state(void) {
return (lis2dh_interrupt_state) watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_INT1_SRC);
}
watch_i2c_write8(LIS2DH_ADDRESS, LIS2DH_REG_CTRL5, val | latch ? LIS2DH_CTRL5_VAL_LIR_INT2 : 0);
}
-lis2dh_interrupt_state lis2dh_get_int2_state() {
+lis2dh_interrupt_state lis2dh_get_int2_state(void) {
return (lis2dh_interrupt_state) watch_i2c_read8(LIS2DH_ADDRESS, LIS2DH_REG_INT2_SRC);
}
LIS2DH_INTERRUPT_STATE_X_LOW = 0b00000001, // X down
} lis2dh_interrupt_state;
-bool lis2dh_begin();
+bool lis2dh_begin(void);
-uint8_t lis2dh_get_device_id();
+uint8_t lis2dh_get_device_id(void);
-bool lis2dh_have_new_data();
+bool lis2dh_have_new_data(void);
-lis2dh_reading lis2dh_get_raw_reading();
+lis2dh_reading lis2dh_get_raw_reading(void);
lis2dh_acceleration_measurement lis2dh_get_acceleration_measurement(lis2dh_reading *out_reading);
void lis2dh_set_range(lis2dh_range_t range);
-lis2dh_range_t lis2dh_get_range();
+lis2dh_range_t lis2dh_get_range(void);
void lis2dh_set_data_rate(lis2dh_data_rate_t dataRate);
-lis2dh_data_rate_t lis2dh_get_data_rate();
+lis2dh_data_rate_t lis2dh_get_data_rate(void);
void lis2dh_configure_aoi_int1(lis2dh_interrupt_configuration configuration, uint8_t threshold, uint8_t duration, bool latch);
-lis2dh_interrupt_state lis2dh_get_int1_state();
+lis2dh_interrupt_state lis2dh_get_int1_state(void);
void lis2dh_configure_aoi_int2(lis2dh_interrupt_configuration configuration, uint8_t threshold, uint8_t duration, bool latch);
-lis2dh_interrupt_state lis2dh_get_int2_state();
+lis2dh_interrupt_state lis2dh_get_int2_state(void);
// Assumes SA0 is high; if low, its 0x18
#define LIS2DH_ADDRESS (0x19)
*/
#define DRIVER_VERSION 0x00000001u
-uint32_t io_get_version(void)
-{
- return DRIVER_VERSION;
-}
-
/**
* \brief I/O write interface
*/
#endif /* !(defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */
+void Default_Handler(void);
+
#endif /* _HPL_CORE_PORT_H_INCLUDED */
*/
#include <hpl_gclk_config.h>
+#include <hpl_gclk_base.h>
#include <hpl_init.h>
#include <utils_assert.h>
#include <compiler.h>
#include <hpl_mclk_config.h>
+#include <hpl_init.h>
/**
* \brief Initialize master clock generator
#include <hpl_time_measure.h>
#include <hpl_systick_config.h>
+#include <hpl_delay.h>
/**
* \brief Initialize system time module
void EXTERNAL_IRQ_0_init(void);
+void SEGMENT_LCD_0_PORT_init(void);
void SEGMENT_LCD_0_init(void);
#ifdef __cplusplus
}
}
-bool watch_is_battery_low() {
+bool watch_is_battery_low(void) {
return battery_is_low;
}
* the battery voltage has fallen to 2.5 volts, it will have probably less than 10% of its capacity remaining, and
* you can expect the voltage to drop relatively quickly as the battery dies.
*/
-bool watch_is_battery_low();
+bool watch_is_battery_low(void);
#endif /* WATCH_H_ */
\ No newline at end of file
#include "watch_adc.h"
-void _watch_sync_adc() {
+static void _watch_sync_adc(void) {
while (ADC->SYNCBUSY.reg);
}
-uint16_t _watch_get_analog_value(uint16_t channel) {
+static uint16_t _watch_get_analog_value(uint16_t channel) {
if (ADC->INPUTCTRL.bit.MUXPOS != channel) {
ADC->INPUTCTRL.bit.MUXPOS = channel;
_watch_sync_adc();
return ADC->RESULT.reg;
}
-void watch_enable_adc() {
+void watch_enable_adc(void) {
MCLK->APBCMASK.reg |= MCLK_APBCMASK_ADC;
GCLK->PCHCTRL[ADC_GCLK_ID].reg = GCLK_PCHCTRL_GEN_GCLK0 | GCLK_PCHCTRL_CHEN;
_watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_SCALEDCOREVCC);
}
-uint16_t watch_get_vcc_voltage() {
+uint16_t watch_get_vcc_voltage(void) {
// stash the previous reference so we can restore it when we're done.
uint8_t oldref = ADC->REFCTRL.bit.REFSEL;
gpio_set_pin_function(pin, GPIO_PIN_FUNCTION_OFF);
}
-inline void watch_disable_adc() {
+inline void watch_disable_adc(void) {
ADC->CTRLA.bit.ENABLE = 0;
_watch_sync_adc();
/** @brief Enables the ADC peripheral. You must call this before attempting to read a value
* from an analog pin.
*/
-void watch_enable_adc();
+void watch_enable_adc(void);
/** @brief Configures the selected pin for analog input.
* @param pin One of pins A0-A4.
* @note This function depends on INTREF being 1.024V. If you have changed it by poking at the supply
* controller's VREF.SEL bits, this function will return inaccurate values.
*/
-uint16_t watch_get_vcc_voltage();
+uint16_t watch_get_vcc_voltage(void);
/** @brief Disables the analog circuitry on the selected pin.
* @param pin One of pins A0-A4.
* have the default settings of 16 samples and 1 measurement cycle; if you customized these
* parameters, you will need to set them up again.
**/
-void watch_disable_adc();
+void watch_disable_adc(void);
/// @}
#endif
* anything else. Use it to set up any internal data structures or application state required by your app,
* but don't configure any peripherals just yet.
*/
-void app_init();
+void app_init(void);
/** @brief A function you will implement to wake from BACKUP mode, which wipes the system's RAM, and with it, your
* application's state. You may have chosen to store some important application state in the RTC's backup
* registers prior to entering this mode. You may restore that state here.
*/
-void app_wake_from_backup();
+void app_wake_from_backup(void);
/** @brief A function you will implement to set up your application. The app_setup function is like setup() in Arduino.
* It is called once when the program begins. You should set pin modes and enable any peripherals you want to
* @note If your app enters the ultra-low power BACKUP sleep mode, this function will be called again when it wakes
* from that deep sleep state. In this state, the RTC will still be configured with the correct date and time.
*/
-void app_setup();
+void app_setup(void);
/** @brief A function you will implement to serve as the app's main run loop. This method will be called repeatedly,
or if you enter STANDBY mode, as soon as the device wakes from sleep.
* so e.g. the I2C controller, if configured, will sleep in STANDBY. But you can use it again as soon as your
* app wakes up.
*/
-bool app_loop();
+bool app_loop(void);
/** @brief A function you will implement to prepare to enter STANDBY mode. The app_prepare_for_standby function is
* called after your app_loop function returns true, and just before the watch enters STANDBY mode. In this
* buzzer that could damage it if left in this state. If your app_loop does not prevent sleep during these
* activities, you should make sure to disable these outputs in app_prepare_for_standby.
*/
-void app_prepare_for_standby();
+void app_prepare_for_standby(void);
/** @brief A method you will implement to configure the app after waking from STANDBY mode.
*/
-void app_wake_from_standby();
+void app_wake_from_standby(void);
/// @}
#endif
#include "watch_buzzer.h"
- inline void watch_enable_buzzer() {
+ inline void watch_enable_buzzer(void) {
if (!hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) {
_watch_enable_tcc();
}
hri_tcc_write_PERBUF_reg(TCC0, period);
}
-void watch_disable_buzzer() {
+void watch_disable_buzzer(void) {
_watch_disable_tcc();
}
-inline void watch_set_buzzer_on() {
+inline void watch_set_buzzer_on(void) {
gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OUT);
gpio_set_pin_function(BUZZER, WATCH_BUZZER_TCC_PINMUX);
}
-inline void watch_set_buzzer_off() {
+inline void watch_set_buzzer_off(void) {
gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OFF);
gpio_set_pin_function(BUZZER, GPIO_PIN_FUNCTION_OFF);
}
/// @{
/** @brief Enables the TCC peripheral, which drives the buzzer.
*/
-void watch_enable_buzzer();
+void watch_enable_buzzer(void);
/** @brief Sets the period of the buzzer.
* @param period The period of a single cycle for the TCC peripheral. You can determine the period for
* @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.
*/
-void watch_disable_buzzer();
+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.
*/
-void watch_set_buzzer_on();
+void watch_set_buzzer_on(void);
/** @brief Turns the buzzer output off.
*/
-void watch_set_buzzer_off();
+void watch_set_buzzer_off(void);
/// @brief 87 notes for use with watch_buzzer_play_note
typedef enum BuzzerNote {
return 0;
}
-void _watch_disable_all_pins_except_rtc() {
+static void _watch_disable_all_pins_except_rtc(void) {
uint32_t config = RTC->MODE0.TAMPCTRL.reg;
uint32_t portb_pins_to_disable = 0xFFFFFFFF;
gpio_set_port_direction(1, portb_pins_to_disable, GPIO_DIRECTION_OFF);
}
-void _watch_disable_all_peripherals_except_slcd() {
+static void _watch_disable_all_peripherals_except_slcd(void) {
_watch_disable_tcc();
watch_disable_adc();
watch_disable_external_interrupts();
MCLK->APBCMASK.reg &= ~MCLK_APBCMASK_SERCOM3;
}
-void watch_enter_sleep_mode() {
+void watch_enter_sleep_mode(void) {
// disable all other peripherals
_watch_disable_all_peripherals_except_slcd();
app_wake_from_standby();
}
-void watch_enter_deep_sleep_mode() {
+void watch_enter_deep_sleep_mode(void) {
// identical to sleep mode except we disable the LCD first.
slcd_sync_deinit(&SEGMENT_LCD_0);
hri_mclk_clear_APBCMASK_SLCD_bit(SLCD);
watch_enter_sleep_mode();
}
-void watch_enter_backup_mode() {
+void watch_enter_backup_mode(void) {
watch_rtc_disable_all_periodic_callbacks();
_watch_disable_all_peripherals_except_slcd();
slcd_sync_deinit(&SEGMENT_LCD_0);
}
// deprecated
-void watch_enter_deep_sleep() {
+void watch_enter_deep_sleep(void) {
watch_register_extwake_callback(BTN_ALARM, NULL, true);
watch_enter_backup_mode();
}
* You can estimate the power consumption of this mode to be on the order of 30 microwatts
* (about 10 µA at 3 V).
*/
-void watch_enter_sleep_mode();
+void watch_enter_sleep_mode(void);
/** @brief enters Deep Sleep Mode by disabling all pins and peripherals except the RTC.
* @details Short of BACKUP mode, this is the lowest power mode you can enter while retaining your
* All notes from watch_enter_sleep_mode apply here, except for power consumption. You can estimate
* the power consumption of this mode to be on the order of 12 microwatts (about 4µA at 3 V).
*/
-void watch_enter_deep_sleep_mode();
+void watch_enter_deep_sleep_mode(void);
/** @brief Enters the SAM L22's lowest-power mode, BACKUP.
* @details This function does some housekeeping before entering BACKUP mode. It first disables all pins
* this function unless you have a device on the nine-pin connector with an external interrupt
* on pin A2 or A4 (i.e. an accelerometer with an interrupt pin).
*/
-void watch_enter_backup_mode();
+void watch_enter_backup_mode(void);
__attribute__((deprecated("Use watch_enter_sleep_mode or watch_enter_deep_sleep_mode instead")))
void watch_enter_shallow_sleep(bool display_on);
__attribute__((deprecated("Use watch_enter_backup_mode instead")))
-void watch_enter_deep_sleep();
+void watch_enter_deep_sleep(void);
/// @}
#endif
#include "watch_extint.h"
-void watch_enable_external_interrupts() {
+void watch_enable_external_interrupts(void) {
// Configure EIC to use GCLK3 (the 32.768 kHz crystal)
hri_gclk_write_PCHCTRL_reg(GCLK, EIC_GCLK_ID, GCLK_PCHCTRL_GEN_GCLK3_Val | (1 << GCLK_PCHCTRL_CHEN_Pos));
// Enable AHB clock for the EIC
ext_irq_init();
}
-void watch_disable_external_interrupts() {
+void watch_disable_external_interrupts(void) {
ext_irq_deinit();
hri_mclk_clear_APBAMASK_EIC_bit(MCLK);
}
watch_register_interrupt_callback(pin, callback, INTERRUPT_TRIGGER_RISING);
}
-inline void watch_enable_buttons() {
+inline void watch_enable_buttons(void) {
watch_enable_external_interrupts();
}
} watch_interrupt_trigger;
/// @brief Enables the external interrupt controller.
-void watch_enable_external_interrupts();
+void watch_enable_external_interrupts(void);
/// @brief Disables the external interrupt controller.
-void watch_disable_external_interrupts();
+void watch_disable_external_interrupts(void);
/** @brief Configures an external interrupt callback on one of the external interrupt pins.
* @details You can set one interrupt callback per pin, and you can monitor for a rising condition,
void watch_register_button_callback(const uint8_t pin, ext_irq_cb_t callback);
__attribute__((deprecated("Use watch_enable_external_interrupts instead")))
-void watch_enable_buttons();
+void watch_enable_buttons(void);
/// @}
#endif
struct io_descriptor *I2C_0_io;
-void watch_enable_i2c() {
+void watch_enable_i2c(void) {
I2C_0_init();
i2c_m_sync_get_io_descriptor(&I2C_0, &I2C_0_io);
i2c_m_sync_enable(&I2C_0);
}
-void watch_disable_i2c() {
+void watch_disable_i2c(void) {
i2c_m_sync_disable(&I2C_0);
hri_mclk_clear_APBCMASK_SERCOM1_bit(MCLK);
}
/// @{
/** @brief Enables the I2C peripheral. Call this before attempting to interface with I2C devices.
*/
-void watch_enable_i2c();
+void watch_enable_i2c(void);
/** @brief Disables the I2C peripheral.
*/
-void watch_disable_i2c();
+void watch_disable_i2c(void);
/** @brief Sends a series of values to a device on the I2C bus.
* @param addr The address of the device you wish to talk to.
#include "watch_led.h"
-void watch_enable_leds() {
+void watch_enable_leds(void) {
if (!hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) {
_watch_enable_tcc();
}
}
-void watch_disable_leds() {
+void watch_disable_leds(void) {
_watch_disable_tcc();
}
}
}
-void watch_set_led_red() {
+void watch_set_led_red(void) {
watch_set_led_color(255, 0);
}
-void watch_set_led_green() {
+void watch_set_led_green(void) {
watch_set_led_color(0, 255);
}
-void watch_set_led_yellow() {
+void watch_set_led_yellow(void) {
watch_set_led_color(255, 255);
}
-void watch_set_led_off() {
+void watch_set_led_off(void) {
watch_set_led_color(0, 0);
}
* 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.
*/
-void watch_enable_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.
*/
-void watch_disable_leds();
+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.
/** @brief Sets the red LED to full brightness, and turns the green LED off.
* @details Of the two LED's in the RG bi-color LED, the red LED is the less power-efficient one (~4.5 mA).
*/
-void watch_set_led_red();
+void watch_set_led_red(void);
/** @brief Sets the green LED to full brightness, and turns the red LED off.
* @details Of the two LED's in the RG bi-color LED, the green LED is the more power-efficient one (~0.44 mA).
* @note If your watch has a red/blue LED, this method will set the LED to blue.
*/
-void watch_set_led_green();
+void watch_set_led_green(void);
/** @brief Sets both red and green LEDs to full brightness.
* @details The total current draw between the two LED's in this mode will be ~5 mA, which is more than the
* watch draws in any other mode. Take care not to drain the battery.
* @note If your watch has a red/blue LED, this method will set the LED to pink.
*/
-void watch_set_led_yellow();
+void watch_set_led_yellow(void);
/** @brief Turns both the red and the green LEDs off. */
-void watch_set_led_off();
+void watch_set_led_off(void);
__attribute__((deprecated("Use watch_enable_leds instead")))
void watch_enable_led(bool unused);
#include "watch_private.h"
#include "tusb.h"
-void _watch_init() {
+void _watch_init(void) {
// disable the LED pin (it may have been enabled by the bootloader)
watch_disable_digital_output(RED);
a4_callback = NULL;
}
-void _watch_enable_tcc() {
+void _watch_enable_tcc(void) {
// clock TCC0 with the main clock (8 MHz) and enable the peripheral clock.
hri_gclk_write_PCHCTRL_reg(GCLK, TCC0_GCLK_ID, GCLK_PCHCTRL_GEN_GCLK0_Val | GCLK_PCHCTRL_CHEN);
hri_mclk_set_APBCMASK_TCC0_bit(MCLK);
gpio_set_pin_function(GREEN, WATCH_GREEN_TCC_PINMUX);
}
-void _watch_disable_tcc() {
+void _watch_disable_tcc(void) {
// disable all PWM pins
gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OFF);
gpio_set_pin_function(BUZZER, GPIO_PIN_FUNCTION_OFF);
hri_mclk_clear_APBCMASK_TCC0_bit(MCLK);
}
-void _watch_enable_usb() {
+void _watch_enable_usb(void) {
// disable USB, just in case.
hri_usb_clear_CTRLA_ENABLE_bit(USB);
}
// this method could be overridden to read stuff from the USB console? but no need rn.
-int _read() {
+int _read(void) {
return 0;
}
#include "watch.h"
/// Called by main.c while setting up the app. You should not call this from your app.
-void _watch_init();
+void _watch_init(void);
/// Initializes the real-time clock peripheral.
-void _watch_rtc_init();
+void _watch_rtc_init(void);
/// Called by buzzer and LED setup functions. You should not call this from your app.
-void _watch_enable_tcc();
+void _watch_enable_tcc(void);
/// Called by buzzer and LED teardown functions. You should not call this from your app.
-void _watch_disable_tcc();
+void _watch_disable_tcc(void);
/// Called by main.c if plugged in to USB. You should not call this from your app.
-void _watch_enable_usb();
+void _watch_enable_usb(void);
+
+// this function ends up getting called by printf to log stuff to the USB console.
+int _write(int file, char *ptr, int len);
+
+// this method could be overridden to read stuff from the USB console? but no need rn.
+int _read(void);
+
#endif
ext_irq_cb_t a2_callback;
ext_irq_cb_t a4_callback;
-bool _watch_rtc_is_enabled() {
+bool _watch_rtc_is_enabled(void) {
return RTC->MODE2.CTRLA.bit.ENABLE;
}
-void _sync_rtc() {
+static void _sync_rtc(void) {
while (RTC->MODE2.SYNCBUSY.reg);
}
-void _watch_rtc_init() {
+void _watch_rtc_init(void) {
MCLK->APBAMASK.reg |= MCLK_APBAMASK_RTC;
if (_watch_rtc_is_enabled()) return; // don't reset the RTC if it's already set up.
_sync_rtc();
}
-watch_date_time watch_rtc_get_date_time() {
+watch_date_time watch_rtc_get_date_time(void) {
watch_date_time retval;
_sync_rtc();
watch_rtc_register_periodic_callback(callback, 1);
}
-void watch_rtc_disable_tick_callback() {
+void watch_rtc_disable_tick_callback(void) {
watch_rtc_disable_periodic_callback(1);
}
RTC->MODE2.INTENCLR.reg = 1 << per_n;
}
-void watch_rtc_disable_all_periodic_callbacks() {
+void watch_rtc_disable_all_periodic_callbacks(void) {
RTC->MODE2.INTENCLR.reg = 0xFF;
}
RTC->MODE2.INTENSET.reg = RTC_MODE2_INTENSET_ALARM0;
}
-void watch_rtc_disable_alarm_callback() {
+void watch_rtc_disable_alarm_callback(void) {
RTC->MODE2.INTENCLR.reg = RTC_MODE2_INTENCLR_ALARM0;
}
/** @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();
+bool _watch_rtc_is_enabled(void);
/** @brief Sets the date and time.
* @param date_time The date and time you wish to set, with a year value from 0-63 representing 2020-2083.
* @return A watch_date_time 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.
*/
-watch_date_time watch_rtc_get_date_time();
+watch_date_time watch_rtc_get_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.
/** @brief Disables the alarm callback.
*/
-void watch_rtc_disable_alarm_callback();
+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
/** @brief Disables the tick callback for the given period.
*/
-void watch_rtc_disable_tick_callback();
+void watch_rtc_disable_tick_callback(void);
/** @brief Registers a callback that will be called at a configurable period.
* @param callback The function you wish to have called at the specified period. If you pass in NULL, the periodic
/** @brief Disables all periodic callbacks, including the once-per-second tick callback.
*/
-void watch_rtc_disable_all_periodic_callbacks();
+void watch_rtc_disable_all_periodic_callbacks(void);
/** @brief Sets the system date and time.
* @param date_time A struct representing the date and time you wish to set.
SLCD_SEGID(1, 10), // WATCH_INDICATOR_LAP
};
-void _sync_slcd() {
+static void _sync_slcd(void) {
while (SLCD->SYNCBUSY.reg);
}
-void watch_enable_display() {
+void watch_enable_display(void) {
SEGMENT_LCD_0_init();
slcd_sync_enable(&SEGMENT_LCD_0);
}
slcd_sync_seg_off(&SEGMENT_LCD_0, SLCD_SEGID(com, seg));
}
-void watch_clear_display() {
+void watch_clear_display(void) {
SLCD->SDATAL0.reg = 0;
SLCD->SDATAL1.reg = 0;
SLCD->SDATAL2.reg = 0;
}
-void watch_display_character(uint8_t character, uint8_t position) {
+static void watch_display_character(uint8_t character, uint8_t position) {
// special cases for positions 4 and 6
if (position == 4 || position == 6) {
if (character == '7') character = '&'; // "lowercase" 7
// printf("________\n %c%c %c%c\n%c%c %c%c %c%c\n--------\n", (position > 0) ? ' ' : string[0], (position > 1) ? ' ' : string[1 - position], (position > 2) ? ' ' : string[2 - position], (position > 3) ? ' ' : string[3 - position], (position > 4) ? ' ' : string[4 - position], (position > 5) ? ' ' : string[5 - position], (position > 6) ? ' ' : string[6 - position], (position > 7) ? ' ' : string[7 - position], (position > 8) ? ' ' : string[8 - position], (position > 9) ? ' ' : string[9 - position]);
}
-inline void watch_set_colon() {
+inline void watch_set_colon(void) {
slcd_sync_seg_on(&SEGMENT_LCD_0, SLCD_SEGID(1, 16));
}
-inline void watch_clear_colon() {
+inline void watch_clear_colon(void) {
slcd_sync_seg_off(&SEGMENT_LCD_0, SLCD_SEGID(1, 16));
}
slcd_sync_seg_off(&SEGMENT_LCD_0, IndicatorSegments[indicator]);
}
-void watch_clear_all_indicators() {
+void watch_clear_all_indicators(void) {
slcd_sync_seg_off(&SEGMENT_LCD_0, SLCD_SEGID(2, 17));
slcd_sync_seg_off(&SEGMENT_LCD_0, SLCD_SEGID(2, 16));
slcd_sync_seg_off(&SEGMENT_LCD_0, SLCD_SEGID(0, 17));
_sync_slcd();
}
-void watch_stop_blink() {
+void watch_stop_blink(void) {
SLCD->CTRLD.bit.FC0EN = 0;
SLCD->CTRLD.bit.BLINK = 0;
}
slcd_sync_start_animation(&SEGMENT_LCD_0, segs, 1, duration);
}
-bool watch_tick_animation_is_running() {
+bool watch_tick_animation_is_running(void) {
return hri_slcd_get_CTRLD_CSREN_bit(SLCD);
}
-void watch_stop_tick_animation() {
+void watch_stop_tick_animation(void) {
const uint32_t segs[] = { SLCD_SEGID(0, 2)};
slcd_sync_stop_animation(&SEGMENT_LCD_0, segs, 1);
watch_display_character(' ', 8);
/** @brief Enables the Segment LCD display.
* Call this before attempting to set pixels or display strings.
*/
-void watch_enable_display();
+void watch_enable_display(void);
/** @brief Sets a pixel. Use this to manually set a pixel with a given common and segment number.
* See <a href="segmap.html">segmap.html</a>.
/** @brief Clears all segments of the display, including incicators and the colon.
*/
-void watch_clear_display();
+void watch_clear_display(void);
/** @brief Displays a string at the given position, starting from the top left. There are ten digits.
A space in any position will clear that digit.
/** @brief Turns the colon segment on.
*/
-void watch_set_colon();
+void watch_set_colon(void);
/** @brief Turns the colon segment off.
*/
-void watch_clear_colon();
+void watch_clear_colon(void);
/** @brief Sets an indicator on the LCD. Use this to turn on one of the indicator segments.
* @param indicator One of the indicator segments from the enum. @see WatchIndicatorSegment
/** @brief Clears all indicator segments.
* @see WatchIndicatorSegment
*/
-void watch_clear_all_indicators();
+void watch_clear_all_indicators(void);
/** @brief Blinks a single character in position 7. Does not affect other positions.
* @details Six of the seven segments in position 7 (and only position 7) are capable of autonomous
/** @brief Stops and clears all blinking segments.
* @details This will stop all blinking in position 7, and clear all segments in that digit.
*/
-void watch_stop_blink();
+void watch_stop_blink(void);
/** @brief Begins a two-segment "tick-tock" animation in position 8.
* @details Six of the seven segments in position 8 (and only position 8) are capable of autonomous
/** @brief Checks if the tick animation is currently running.
* @return true if the animation is running; false otherwise.
*/
-bool watch_tick_animation_is_running();
+bool watch_tick_animation_is_running(void);
/** @brief Stops the tick/tock animation and clears all animating segments.
* @details This will stop the animation and clear all segments in position 8.
*/
-void watch_stop_tick_animation();
+void watch_stop_tick_animation(void);
/// @}
#endif
projects / sensor-watch.git / commitdiff