diff options
Diffstat (limited to 'watch-library/watch')
| -rw-r--r-- | watch-library/watch/tusb_config.h | 91 | ||||
| -rw-r--r-- | watch-library/watch/watch_buzzer.c | 24 | ||||
| -rw-r--r-- | watch-library/watch/watch_buzzer.h | 33 | ||||
| -rw-r--r-- | watch-library/watch/watch_extint.h | 2 | ||||
| -rw-r--r-- | watch-library/watch/watch_gpio.c | 6 | ||||
| -rw-r--r-- | watch-library/watch/watch_gpio.h | 5 | ||||
| -rw-r--r-- | watch-library/watch/watch_led.c | 46 | ||||
| -rw-r--r-- | watch-library/watch/watch_led.h | 9 | ||||
| -rw-r--r-- | watch-library/watch/watch_private.c | 313 | ||||
| -rw-r--r-- | watch-library/watch/watch_private.h | 9 | ||||
| -rw-r--r-- | watch-library/watch/watch_uart.c | 2 |
11 files changed, 477 insertions, 63 deletions
diff --git a/watch-library/watch/tusb_config.h b/watch-library/watch/tusb_config.h new file mode 100644 index 00000000..a22b2b99 --- /dev/null +++ b/watch-library/watch/tusb_config.h @@ -0,0 +1,91 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _TUSB_CONFIG_H_ +#define _TUSB_CONFIG_H_ + +#ifdef __cplusplus + extern "C" { +#endif + +//-------------------------------------------------------------------- +// COMMON CONFIGURATION +//-------------------------------------------------------------------- + +// defined by board.mk +#define CFG_TUSB_MCU OPT_MCU_SAML22 + +#define BOARD_DEVICE_RHPORT_NUM 0 +#define BOARD_DEVICE_RHPORT_SPEED OPT_MODE_FULL_SPEED +#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_FULL_SPEED) + +#define CFG_TUSB_OS OPT_OS_NONE + +// disable TinyUSB debug. our printf method prints stuff to the USB console, so you just get infinite noise. +// if you need to debug tinyUSB issues, use the alternate _write function in watch_private.c to echo to the UART. +#define CFG_TUSB_DEBUG 0 + +/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment. + * Tinyusb use follows macros to declare transferring memory so that they can be put + * into those specific section. + * e.g + * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") )) + * - CFG_TUSB_MEM_ALIGN : __attribute__ ((aligned(4))) + */ +#ifndef CFG_TUSB_MEM_SECTION +#define CFG_TUSB_MEM_SECTION +#endif + +#ifndef CFG_TUSB_MEM_ALIGN +#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) +#endif + +//-------------------------------------------------------------------- +// DEVICE CONFIGURATION +//-------------------------------------------------------------------- + +#ifndef CFG_TUD_ENDPOINT0_SIZE +#define CFG_TUD_ENDPOINT0_SIZE 64 +#endif + +//------------- CLASS -------------// +#define CFG_TUD_CDC 1 +#define CFG_TUD_MSC 0 +#define CFG_TUD_HID 0 +#define CFG_TUD_MIDI 0 +#define CFG_TUD_VENDOR 0 + +// CDC FIFO size of TX and RX +#define CFG_TUD_CDC_RX_BUFSIZE (64) +#define CFG_TUD_CDC_TX_BUFSIZE (64) + +// CDC Endpoint transfer buffer size, more is faster +#define CFG_TUD_CDC_EP_BUFSIZE (64) + +#ifdef __cplusplus + } +#endif + +#endif /* _TUSB_CONFIG_H_ */ diff --git a/watch-library/watch/watch_buzzer.c b/watch-library/watch/watch_buzzer.c index 04746416..c6c89a0e 100644 --- a/watch-library/watch/watch_buzzer.c +++ b/watch-library/watch/watch_buzzer.c @@ -23,28 +23,38 @@ */ inline void watch_enable_buzzer() { - PWM_1_init(); + if (!hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + _watch_enable_tcc(); + } } - inline void watch_set_buzzer_period(uint32_t period) { - pwm_set_parameters(&PWM_1, period, period / 2); + hri_tcc_write_PERBUF_reg(TCC0, period); +} + +void watch_disable_buzzer() { + _watch_disable_tcc(); } inline void watch_set_buzzer_on() { - pwm_enable(&PWM_1); + gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OUT); + gpio_set_pin_function(BUZZER, PINMUX_PA27F_TCC0_WO5); } inline void watch_set_buzzer_off() { - pwm_disable(&PWM_1); + gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OFF); + gpio_set_pin_function(BUZZER, GPIO_PIN_FUNCTION_OFF); } -const uint16_t NotePeriods[108] = {31047, 29301, 27649, 26079, 24617, 23224, 21923, 20683, 19515, 18418, 17377, 16399, 15477, 14603, 13780, 13004, 12272, 11580, 10926, 10311, 9730, 9181, 8664, 8175, 7714, 7280, 6869, 6483, 6117, 5772, 5447, 5140, 4850, 4577, 4319, 4076, 3846, 3629, 3425, 3232, 3050, 2878, 2715, 2562, 2418, 2282, 2153, 2032, 1917, 1809, 1707, 1611, 1520, 1435, 1354, 1277, 1205, 1137, 1073, 1013, 956, 902, 851, 803, 758, 715, 675, 637, 601, 567, 535, 505, 476, 450, 424, 400, 378, 357, 336, 317, 300, 283, 267, 252, 238, 224, 212, 200, 188, 178, 168, 158, 149, 141, 133, 125, 118, 112, 105, 99, 94, 89, 84, 79, 74, 70, 66, 63}; +// note: the buzzer uses a 1 MHz clock. these values were determined by dividing 1,000,000 by the target frequency. +// i.e. for a 440 Hz tone (A4 on the piano), 1MHz/440Hz = 2273 +const uint16_t NotePeriods[108] = {18182,17161,16197,15288,14430,13620,12857,12134,11453,10811,10204,9631,9091,8581,8099,7645,7216,6811,6428,6068,5727,5405,5102,4816,4545,4290,4050,3822,3608,3405,3214,3034,2863,2703,2551,2408,2273,2145,2025,1911,1804,1703,1607,1517,1432,1351,1276,1204,1136,1073,1012,956,902,851,804,758,716,676,638,602,568,536,506,478,451,426,402,379,358,338,319,301,284,268,253,239,225,213,201,190,179,169,159,150,142,134,127}; void watch_buzzer_play_note(BuzzerNote note, uint16_t duration_ms) { if (note == BUZZER_NOTE_REST) { watch_set_buzzer_off(); } else { - pwm_set_parameters(&PWM_1, NotePeriods[note], NotePeriods[note] / 2); + hri_tcc_write_PERBUF_reg(TCC0, NotePeriods[note]); + hri_tcc_write_CCBUF_reg(TCC0, 1, NotePeriods[note] / 2); watch_set_buzzer_on(); } delay_ms(duration_ms); diff --git a/watch-library/watch/watch_buzzer.h b/watch-library/watch/watch_buzzer.h index 75b30a79..995e059a 100644 --- a/watch-library/watch/watch_buzzer.h +++ b/watch-library/watch/watch_buzzer.h @@ -32,11 +32,17 @@ void watch_enable_buzzer(); /** @brief Sets the period of the buzzer. - * @param period The period of a single cycle for the PWM peripheral. You can use the following formula to - * convert a desired frequency to a period for this function: period = 513751 * (freq^−1.0043) + * @param period The period of a single cycle for the TCC peripheral. You can determine the period for + * a desired frequency with the following formula: period = 1000000 / freq */ void watch_set_buzzer_period(uint32_t period); +/** @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. + */ +void watch_disable_buzzer(); + /** @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. @@ -47,29 +53,8 @@ void watch_set_buzzer_on(); */ void watch_set_buzzer_off(); -/// @brief 108 notes for use with watch_buzzer_play_note +/// @brief 87 notes for use with watch_buzzer_play_note typedef enum BuzzerNote { - BUZZER_NOTE_C0 = 0, ///< 16.35 Hz - BUZZER_NOTE_C0SHARP_D0FLAT, ///< 17.32 Hz - BUZZER_NOTE_D0, ///< 18.35 Hz - BUZZER_NOTE_D0SHARP_E0FLAT, ///< 19.45 Hz - BUZZER_NOTE_E0, ///< 20.60 Hz - BUZZER_NOTE_F0, ///< 21.83 Hz - BUZZER_NOTE_F0SHARP_G0FLAT, ///< 23.12 Hz - BUZZER_NOTE_G0, ///< 24.50 Hz - BUZZER_NOTE_G0SHARP_A0FLAT, ///< 25.96 Hz - BUZZER_NOTE_A0, ///< 27.50 Hz - BUZZER_NOTE_A0SHARP_B0FLAT, ///< 29.14 Hz - BUZZER_NOTE_B0, ///< 30.87 Hz - BUZZER_NOTE_C1, ///< 32.70 Hz - BUZZER_NOTE_C1SHARP_D1FLAT, ///< 34.65 Hz - BUZZER_NOTE_D1, ///< 36.71 Hz - BUZZER_NOTE_D1SHARP_E1FLAT, ///< 38.89 Hz - BUZZER_NOTE_E1, ///< 41.20 Hz - BUZZER_NOTE_F1, ///< 43.65 Hz - BUZZER_NOTE_F1SHARP_G1FLAT, ///< 46.25 Hz - BUZZER_NOTE_G1, ///< 49.00 Hz - BUZZER_NOTE_G1SHARP_A1FLAT, ///< 51.91 Hz BUZZER_NOTE_A1, ///< 55.00 Hz BUZZER_NOTE_A1SHARP_B1FLAT, ///< 58.27 Hz BUZZER_NOTE_B1, ///< 61.74 Hz diff --git a/watch-library/watch/watch_extint.h b/watch-library/watch/watch_extint.h index d1265119..e3084371 100644 --- a/watch-library/watch/watch_extint.h +++ b/watch-library/watch/watch_extint.h @@ -73,7 +73,7 @@ void watch_disable_external_interrupts(); */ void watch_register_interrupt_callback(const uint8_t pin, ext_irq_cb_t callback, watch_interrupt_trigger trigger); -__attribute__((deprecated("Use watch_register_interrupt_callback instead"))) +__attribute__((deprecated("Use watch_register_interrupt_callback or watch_register_extwake_callback instead"))) void watch_register_button_callback(const uint8_t pin, ext_irq_cb_t callback); __attribute__((deprecated("Use watch_enable_external_interrupts instead"))) diff --git a/watch-library/watch/watch_gpio.c b/watch-library/watch/watch_gpio.c index 460a38df..a9bc139d 100644 --- a/watch-library/watch/watch_gpio.c +++ b/watch-library/watch/watch_gpio.c @@ -27,6 +27,12 @@ gpio_set_pin_function(pin, GPIO_PIN_FUNCTION_OFF); } +void watch_disable_digital_input(const uint8_t pin) { + gpio_set_pin_direction(pin, GPIO_DIRECTION_OFF); + gpio_set_pin_pull_mode(pin, GPIO_PULL_OFF); + gpio_set_pin_function(pin, GPIO_PIN_FUNCTION_OFF); +} + void watch_enable_pull_up(const uint8_t pin) { gpio_set_pin_pull_mode(pin, GPIO_PULL_UP); } diff --git a/watch-library/watch/watch_gpio.h b/watch-library/watch/watch_gpio.h index f7678f6f..640686e0 100644 --- a/watch-library/watch/watch_gpio.h +++ b/watch-library/watch/watch_gpio.h @@ -32,6 +32,11 @@ */ void watch_enable_digital_input(const uint8_t pin); +/** @brief Disables any digital input, along with any pull-up or pull-down configuration. + * @param pin The pin that you wish to disable. + */ +void watch_disable_digital_input(const uint8_t pin); + /** @brief Enables a pull-up resistor on the selected pin. * @param pin The pin that you wish to configure. */ diff --git a/watch-library/watch/watch_led.c b/watch-library/watch/watch_led.c index 01f59fc4..4f9898d8 100644 --- a/watch-library/watch/watch_led.c +++ b/watch-library/watch/watch_led.c @@ -22,45 +22,39 @@ * SOFTWARE. */ - bool PWM_0_enabled = false; void watch_enable_led(bool pwm) { if (pwm) { - if (PWM_0_enabled) return; - - PWM_0_init(); - pwm_set_parameters(&PWM_0, 10000, 0); - pwm_enable(&PWM_0); - - PWM_0_enabled = true; + if (!hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + _watch_enable_tcc(); + } } else { watch_enable_digital_output(RED); watch_enable_digital_output(GREEN); + watch_set_led_off(); } - watch_set_led_off(); } void watch_disable_led(bool pwm) { if (pwm) { - if (!PWM_0_enabled) return; - pwm_disable(&PWM_0); - PWM_0_enabled = false; + _watch_disable_tcc(); + } else { + watch_disable_digital_output(RED); + watch_disable_digital_output(GREEN); } - - watch_disable_digital_output(RED); - watch_disable_digital_output(GREEN); } -void watch_set_led_color(uint16_t red, uint16_t green) { - if (PWM_0_enabled) { - TC3->COUNT16.CC[0].reg = red; - TC3->COUNT16.CC[1].reg = green; +void watch_set_led_color(uint8_t red, uint8_t green) { + if (hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + uint32_t period = hri_tcc_get_PER_reg(TCC0, TCC_PER_MASK); + hri_tcc_write_CCBUF_reg(TCC0, 2, ((period * red * 1000ull) / 255000ull)); + hri_tcc_write_CCBUF_reg(TCC0, 3, ((period * green * 1000ull) / 255000ull)); } } void watch_set_led_red() { - if (PWM_0_enabled) { - watch_set_led_color(65535, 0); + if (hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + watch_set_led_color(255, 0); } else { watch_set_pin_level(RED, true); watch_set_pin_level(GREEN, false); @@ -68,8 +62,8 @@ void watch_set_led_red() { } void watch_set_led_green() { - if (PWM_0_enabled) { - watch_set_led_color(65535, 0); + if (hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + watch_set_led_color(0, 255); } else { watch_set_pin_level(RED, false); watch_set_pin_level(GREEN, true); @@ -77,8 +71,8 @@ void watch_set_led_green() { } void watch_set_led_yellow() { - if (PWM_0_enabled) { - watch_set_led_color(65535, 65535); + if (hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { + watch_set_led_color(255, 255); } else { watch_set_pin_level(RED, true); watch_set_pin_level(GREEN, true); @@ -86,7 +80,7 @@ void watch_set_led_yellow() { } void watch_set_led_off() { - if (PWM_0_enabled) { + if (hri_tcc_get_CTRLA_reg(TCC0, TCC_CTRLA_ENABLE)) { watch_set_led_color(0, 0); } else { watch_set_pin_level(RED, false); diff --git a/watch-library/watch/watch_led.h b/watch-library/watch/watch_led.h index 04b6e5fa..5dedadf3 100644 --- a/watch-library/watch/watch_led.h +++ b/watch-library/watch/watch_led.h @@ -43,15 +43,16 @@ void watch_enable_led(bool pwm); /** @brief Disables the LEDs. * @param pwm if true, disables the PWM output. If false, disables the digital outputs. + * @note If pwm is true, 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_led(bool pwm); /** @brief Sets the LED to a custom color by modulating each output's duty cycle. - * @param red The red value. - * @param green The green value. - * @note still working on this, 0-65535 works now but these values may change. + * @param red The red value from 0-255. + * @param green The green value from 0-255. */ -void watch_set_led_color(uint16_t red, uint16_t green); +void watch_set_led_color(uint8_t red, uint8_t green); /** @brief Sets the red LED to full brightness, and turns the green LED off. * @note Of the two LED's in the RG bi-color LED, the red LED is the less power-efficient one (~4.5 mA). diff --git a/watch-library/watch/watch_private.c b/watch-library/watch/watch_private.c index cd9c2baa..a4e2f72c 100644 --- a/watch-library/watch/watch_private.c +++ b/watch-library/watch/watch_private.c @@ -22,6 +22,8 @@ * SOFTWARE. */ +#include "tusb.h" + void _watch_init() { // disable the LED pin (it may have been enabled by the bootloader) watch_disable_digital_output(RED); @@ -42,3 +44,314 @@ void _watch_init() { a2_callback = NULL; a4_callback = NULL; } + +void _watch_enable_tcc() { + // 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); + // disable and reset TCC0. + hri_tcc_clear_CTRLA_ENABLE_bit(TCC0); + hri_tcc_wait_for_sync(TCC0, TCC_SYNCBUSY_ENABLE); + hri_tcc_write_CTRLA_reg(TCC0, TCC_CTRLA_SWRST); + hri_tcc_wait_for_sync(TCC0, TCC_SYNCBUSY_SWRST); + // have prescaler divide our 8 MHz clock down to 1 MHz. + hri_tcc_write_CTRLA_reg(TCC0, TCC_CTRLA_PRESCALER_DIV8); + // We're going to use normal PWM mode, which means period is controlled by PER, and duty cycle is controlled by + // each compare channel's value: + // * Buzzer tones are set by setting PER to the desired period for a given frequency, and CC[1] to half of that + // period (i.e. a square wave with a 50% duty cycle). + // * LEDs on CC[2] and CC[3] can be set to any value from 0 (off) to PER (fully on). + hri_tcc_write_WAVE_reg(TCC0, TCC_WAVE_WAVEGEN_NPWM); + // The buzzer will set the period depending on the tone it wants to play, but we have to set some period here to + // get the LED working. Almost any period will do, tho it should be below 20000 (i.e. 50 Hz) to avoid flickering. + hri_tcc_write_PER_reg(TCC0, 4096); + // Set the duty cycle of all pins to 0: LED's off, buzzer not buzzing. + hri_tcc_write_CC_reg(TCC0, 1, 0); + hri_tcc_write_CC_reg(TCC0, 2, 0); + hri_tcc_write_CC_reg(TCC0, 3, 0); + // Enable the TCC + hri_tcc_set_CTRLA_ENABLE_bit(TCC0); + hri_tcc_wait_for_sync(TCC0, TCC_SYNCBUSY_ENABLE); + + // enable LED PWM pins (the LED driver assumes if the TCC is on, the pins are enabled) + gpio_set_pin_direction(RED, GPIO_DIRECTION_OUT); + gpio_set_pin_function(RED, PINMUX_PA20F_TCC0_WO6); + gpio_set_pin_direction(GREEN, GPIO_DIRECTION_OUT); + gpio_set_pin_function(GREEN, PINMUX_PA21F_TCC0_WO7); +} + +void _watch_disable_tcc() { + // disable all PWM pins + gpio_set_pin_direction(BUZZER, GPIO_DIRECTION_OFF); + gpio_set_pin_function(BUZZER, GPIO_PIN_FUNCTION_OFF); + gpio_set_pin_direction(RED, GPIO_DIRECTION_OFF); + gpio_set_pin_function(RED, GPIO_PIN_FUNCTION_OFF); + gpio_set_pin_direction(GREEN, GPIO_DIRECTION_OFF); + gpio_set_pin_function(GREEN, GPIO_PIN_FUNCTION_OFF); + + // disable the TCC + hri_tcc_clear_CTRLA_ENABLE_bit(TCC0); + hri_mclk_clear_APBCMASK_TCC0_bit(MCLK); +} + +void _watch_enable_usb() { + // disable USB, just in case. + hri_usb_clear_CTRLA_ENABLE_bit(USB); + + // reset flags and disable DFLL + OSCCTRL->INTFLAG.reg = OSCCTRL_INTFLAG_DFLLRDY; + OSCCTRL->DFLLCTRL.reg = 0; + while (!(OSCCTRL->STATUS.reg & OSCCTRL_STATUS_DFLLRDY)); + + // set the coarse and fine values to speed up frequency lock. + uint32_t coarse =(*((uint32_t *)NVMCTRL_OTP5)) >> 26; + OSCCTRL->DFLLVAL.reg = OSCCTRL_DFLLVAL_COARSE(coarse) | + OSCCTRL_DFLLVAL_FINE(0x200); + // set coarse and fine steps, and multiplier (48 MHz = 32768 Hz * 1465) + OSCCTRL->DFLLMUL.reg = OSCCTRL_DFLLMUL_CSTEP( 1 ) | + OSCCTRL_DFLLMUL_FSTEP( 1 ) | + OSCCTRL_DFLLMUL_MUL( 1465 ); + // set closed loop mode, chill cycle disable and USB clock recovery mode, and enable the DFLL. + OSCCTRL->DFLLCTRL.reg = OSCCTRL_DFLLCTRL_MODE | OSCCTRL_DFLLCTRL_CCDIS | OSCCTRL_DFLLCTRL_ONDEMAND | OSCCTRL_DFLLCTRL_RUNSTDBY | OSCCTRL_DFLLCTRL_USBCRM | OSCCTRL_DFLLCTRL_ENABLE; + while (!(OSCCTRL->STATUS.reg & OSCCTRL_STATUS_DFLLRDY)); + + // assign DFLL to GCLK1 + GCLK->GENCTRL[1].reg = GCLK_GENCTRL_SRC(GCLK_GENCTRL_SRC_DFLL48M) | GCLK_GENCTRL_DIV(1) | GCLK_GENCTRL_GENEN;// | GCLK_GENCTRL_OE; + while (GCLK->SYNCBUSY.bit.GENCTRL1); + + // assign GCLK1 to USB + hri_gclk_write_PCHCTRL_reg(GCLK, USB_GCLK_ID, GCLK_PCHCTRL_GEN_GCLK1_Val | GCLK_PCHCTRL_CHEN); + hri_mclk_set_AHBMASK_USB_bit(MCLK); + hri_mclk_set_APBBMASK_USB_bit(MCLK); + + // USB Pin Init + gpio_set_pin_direction(PIN_PA24, GPIO_DIRECTION_OUT); + gpio_set_pin_level(PIN_PA24, false); + gpio_set_pin_pull_mode(PIN_PA24, GPIO_PULL_OFF); + gpio_set_pin_direction(PIN_PA25, GPIO_DIRECTION_OUT); + gpio_set_pin_level(PIN_PA25, false); + gpio_set_pin_pull_mode(PIN_PA25, GPIO_PULL_OFF); + + gpio_set_pin_function(PIN_PA24, PINMUX_PA24G_USB_DM); + gpio_set_pin_function(PIN_PA25, PINMUX_PA25G_USB_DP); + + // before we init TinyUSB, we are going to need a periodic callback to handle TinyUSB tasks. + // TC2 and TC3 are reserved for devices on the 9-pin connector, so let's use TC0. + // clock TC0 with the 8 MHz clock on GCLK0. + hri_gclk_write_PCHCTRL_reg(GCLK, TC0_GCLK_ID, GCLK_PCHCTRL_GEN_GCLK0_Val | GCLK_PCHCTRL_CHEN); + // and enable the peripheral clock. + hri_mclk_set_APBCMASK_TC0_bit(MCLK); + // disable and reset TC0. + hri_tc_clear_CTRLA_ENABLE_bit(TC0); + hri_tc_wait_for_sync(TC0, TC_SYNCBUSY_ENABLE); + hri_tc_write_CTRLA_reg(TC0, TC_CTRLA_SWRST); + hri_tc_wait_for_sync(TC0, TC_SYNCBUSY_SWRST); + // configure the TC to overflow 1,000 times per second + hri_tc_write_CTRLA_reg(TC0, TC_CTRLA_PRESCALER_DIV64 | // divide the 8 MHz clock by 64 to count at 125 KHz + TC_CTRLA_MODE_COUNT8 | // count in 8-bit mode + TC_CTRLA_RUNSTDBY); // run in standby, just in case we figure that out + hri_tccount8_write_PER_reg(TC0, 125); // 125000 Hz / 125 = 1,000 Hz + // set an interrupt on overflow; this will call TC0_Handler below. + hri_tc_set_INTEN_OVF_bit(TC0); + NVIC_ClearPendingIRQ(TC0_IRQn); + NVIC_EnableIRQ (TC0_IRQn); + + // now we can init TinyUSB + tusb_init(); + // and start the timer that handles USB device tasks. + hri_tc_set_CTRLA_ENABLE_bit(TC0); +} + +// this function ends up getting called by printf to log stuff to the USB console. +int _write(int file, char *ptr, int len) { + (void)file; + if (hri_usbdevice_get_CTRLA_ENABLE_bit(USB)) { + tud_cdc_n_write(0, (void const*)ptr, len); + tud_cdc_n_write_flush(0); + return len; + } + + return 0; +} + +// this method could be overridden to read stuff from the USB console? but no need rn. +int _read() { + return 0; +} + +// Alternate function that outputs to the debug UART. useful for debugging USB issues. +// int _write(int file, char *ptr, int len) { +// (void)file; +// int pos = 0; +// while(pos < len) watch_debug_putc(ptr[pos++]); + +// return 0; +// } + +void USB_Handler(void) { + tud_int_handler(0); +} + +void TC0_Handler(void) { + tud_task(); + TC0->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF; +} + + +// USB Descriptors and tinyUSB callbacks follow. + +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * 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 "tusb.h" + +/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug. + * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC. + * + * Auto ProductID layout's Bitmap: + * [MSB] HID | MSC | CDC [LSB] + */ +#define _PID_MAP(itf, n) ( (CFG_TUD_##itf) << (n) ) +#define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \ + _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) ) + +//--------------------------------------------------------------------+ +// Device Descriptors +//--------------------------------------------------------------------+ +tusb_desc_device_t const desc_device = +{ + .bLength = sizeof(tusb_desc_device_t), + .bDescriptorType = TUSB_DESC_DEVICE, + .bcdUSB = 0x0200, + + // Use Interface Association Descriptor (IAD) for CDC + // As required by USB Specs IAD's subclass must be common class (2) and protocol must be IAD (1) + .bDeviceClass = TUSB_CLASS_MISC, + .bDeviceSubClass = MISC_SUBCLASS_COMMON, + .bDeviceProtocol = MISC_PROTOCOL_IAD, + + .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE, + + .idVendor = 0xCafe, + .idProduct = USB_PID, + .bcdDevice = 0x0100, + + .iManufacturer = 0x01, + .iProduct = 0x02, + .iSerialNumber = 0x03, + + .bNumConfigurations = 0x01 +}; + +// Invoked when received GET DEVICE DESCRIPTOR +// Application return pointer to descriptor +uint8_t const * tud_descriptor_device_cb(void) { + return (uint8_t const *) &desc_device; +} + +//--------------------------------------------------------------------+ +// Configuration Descriptor +//--------------------------------------------------------------------+ + +enum { + ITF_NUM_CDC = 0, + ITF_NUM_CDC_DATA, + ITF_NUM_TOTAL +}; + +#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN) + +#define EPNUM_CDC_NOTIF 0x81 +#define EPNUM_CDC_OUT 0x02 +#define EPNUM_CDC_IN 0x82 + + +uint8_t const desc_fs_configuration[] = { + // Config number, interface count, string index, total length, attribute, power in mA + TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100), + + // Interface number, string index, EP notification address and size, EP data address (out, in) and size. + TUD_CDC_DESCRIPTOR(ITF_NUM_CDC, 4, EPNUM_CDC_NOTIF, 8, EPNUM_CDC_OUT, EPNUM_CDC_IN, 64), +}; + +// Invoked when received GET CONFIGURATION DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const * tud_descriptor_configuration_cb(uint8_t index) { + (void) index; // for multiple configurations + return desc_fs_configuration; +} + +//--------------------------------------------------------------------+ +// String Descriptors +//--------------------------------------------------------------------+ + +// array of pointer to string descriptors +char const* string_desc_arr [] = +{ + (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409) + "TinyUSB", // 1: Manufacturer + "TinyUSB Device", // 2: Product + "123456", // 3: Serials, should use chip ID + "TinyUSB CDC", // 4: CDC Interface +}; + +static uint16_t _desc_str[32]; + +// Invoked when received GET STRING DESCRIPTOR request +// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete +uint16_t const* tud_descriptor_string_cb(uint8_t index, uint16_t langid) +{ + (void) langid; + + uint8_t chr_count; + + if ( index == 0) { + memcpy(&_desc_str[1], string_desc_arr[0], 2); + chr_count = 1; + } else { + // Note: the 0xEE index string is a Microsoft OS 1.0 Descriptors. + // https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/microsoft-defined-usb-descriptors + + if ( !(index < sizeof(string_desc_arr)/sizeof(string_desc_arr[0])) ) return NULL; + + const char* str = string_desc_arr[index]; + + // Cap at max char + chr_count = strlen(str); + if ( chr_count > 31 ) chr_count = 31; + + // Convert ASCII string into UTF-16 + for(uint8_t i=0; i<chr_count; i++) + { + _desc_str[1+i] = str[i]; + } + } + + // first byte is length (including header), second byte is string type + _desc_str[0] = (TUSB_DESC_STRING << 8 ) | (2*chr_count + 2); + + return _desc_str; +} diff --git a/watch-library/watch/watch_private.h b/watch-library/watch/watch_private.h index 99171126..abee085a 100644 --- a/watch-library/watch/watch_private.h +++ b/watch-library/watch/watch_private.h @@ -24,3 +24,12 @@ /// Called by main.c while setting up the app. You should not call this from your app. void _watch_init(); + +/// Called by buzzer and LED setup functions. You should not call this from your app. +void _watch_enable_tcc(); + +/// Called by buzzer and LED teardown functions. You should not call this from your app. +void _watch_disable_tcc(); + +/// Called by main.c if plugged in to USB. You should not call this from your app. +void _watch_enable_usb(); diff --git a/watch-library/watch/watch_uart.c b/watch-library/watch/watch_uart.c index 4cbac89b..a747e71b 100644 --- a/watch-library/watch/watch_uart.c +++ b/watch-library/watch/watch_uart.c @@ -53,7 +53,7 @@ #include "peripheral_clk_config.h" void watch_enable_debug_uart(uint32_t baud) { - uint64_t br = (uint64_t)65536 * (CONF_CPU_FREQUENCY - 16 * baud) / CONF_CPU_FREQUENCY; + uint64_t br = (uint64_t)65536 * ((CONF_CPU_FREQUENCY * 4) - 16 * baud) / (CONF_CPU_FREQUENCY * 4); gpio_set_pin_direction(D1, GPIO_DIRECTION_IN); gpio_set_pin_function(D1, PINMUX_PB00C_SERCOM3_PAD2); |