fern/sensor-watch
1
0
Fork 0
mirror of https://github.com/firewalkwithm3/Sensor-Watch.git synced 2024-11-22 19:20:30 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'usb-improvements' into advanced

Browse source 
- Change newline prints to also send carriage return
 - Introduce shell module for serial shell with argument parsing
 - Introduce shell command list for compile time command registration
 - Refactor file system commands for shell subsystem
 - Introduce new shell commands:
   - 'help' command
   - 'flash' command to reset into bootloader
   - 'stress' tests CDC serial writes of various lengths
     - optional delay parameter
 - Harden USB handling
   - Hangs less
   - Drops fewer inputs
 - Circular buffers for both reads and writes

Reported-by: Edward Shin <contact@edwardsh.in>
Tested-by: Edward Shin <contact@edwardsh.in>
Tested-by: Matheus Afonso Martins Moreira <matheus.a.m.moreira@gmail.com>
Tested-on-hardware-by: Matheus Afonso Martins Moreira <matheus.a.m.moreira@gmail.com>
Reviewed-by: James Haggerty <james@gruemail.com>
Reviewed-by: Wesley Aptekar-Cassels <me@wesleyac.com>
Reviewed-by: Matheus Afonso Martins Moreira <matheus.a.m.moreira@gmail.com>
Signed-off-by: Matheus Afonso Martins Moreira <matheus.a.m.moreira@gmail.com>
GitHub-Pull-Request: https://github.com/joeycastillo/Sensor-Watch/pull/344
This commit is contained in:
Matheus Afonso Martins Moreira 2024-03-05 01:05:31 -03:00
parent 592e18bf0e 5b762d0168
commit 35c0a4be87
15 changed files with 816 additions and 156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
make.mk
View file

@ -121,6 +121,7 @@ SRCS += \
$(TOP)/watch-library/hardware/watch/watch_storage.c \
$(TOP)/watch-library/hardware/watch/watch_deepsleep.c \
$(TOP)/watch-library/hardware/watch/watch_private.c \
$(TOP)/watch-library/hardware/watch/watch_private_cdc.c \
$(TOP)/watch-library/hardware/watch/watch.c \
$(TOP)/watch-library/hardware/hal/src/hal_atomic.c \
$(TOP)/watch-library/hardware/hal/src/hal_delay.c \

121
movement/filesystem.c
View file

@ -100,7 +100,7 @@ static int filesystem_ls(lfs_t *lfs, const char *path) {
printf("%4ld bytes ", info.size);
printf("%s\n", info.name);
printf("%s\r\n", info.name);
}
err = lfs_dir_close(lfs, &dir);
@ -117,11 +117,11 @@ bool filesystem_init(void) {
// reformat if we can't mount the filesystem
// this should only happen on the first boot
if (err < 0) {
printf("Ignore that error! Formatting filesystem...\n");
printf("Ignore that error! Formatting filesystem...\r\n");
err = lfs_format(&lfs, &cfg);
if (err < 0) return false;
err = lfs_mount(&lfs, &cfg) == LFS_ERR_OK;
printf("Filesystem mounted with %ld bytes free.\n", filesystem_get_free_space());
printf("Filesystem mounted with %ld bytes free.\r\n", filesystem_get_free_space());
}
return err == LFS_ERR_OK;
@ -139,7 +139,7 @@ bool filesystem_rm(char *filename) {
if (filesystem_file_exists(filename)) {
return lfs_remove(&lfs, filename) == LFS_ERR_OK;
} else {
printf("rm: %s: No such file\n", filename);
printf("rm: %s: No such file\r\n", filename);
return false;
}
}
@ -197,13 +197,13 @@ static void filesystem_cat(char *filename) {
char *buf = malloc(info.size + 1);
filesystem_read_file(filename, buf, info.size);
buf[info.size] = '\0';
printf("%s\n", buf);
printf("%s\r\n", buf);
free(buf);
} else {
printf("\n");
printf("\r\n");
}
} else {
printf("cat: %s: No such file\n", filename);
printf("cat: %s: No such file\r\n", filename);
}
}
@ -223,59 +223,60 @@ bool filesystem_append_file(char *filename, char *text, int32_t length) {
return lfs_file_close(&lfs, &file) == LFS_ERR_OK;
}
void filesystem_process_command(char *line) {
printf("$ %s", line);
char *command = strtok(line, " \n");
if (strcmp(command, "ls") == 0) {
char *directory = strtok(NULL, " \n");
if (directory == NULL) {
filesystem_ls(&lfs, "/");
} else {
printf("usage: ls\n");
}
} else if (strcmp(command, "cat") == 0) {
char *filename = strtok(NULL, " \n");
if (filename == NULL) {
printf("usage: cat file\n");
} else {
filesystem_cat(filename);
}
} else if (strcmp(command, "df") == 0) {
printf("free space: %ld bytes\n", filesystem_get_free_space());
} else if (strcmp(command, "rm") == 0) {
char *filename = strtok(NULL, " \n");
if (filename == NULL) {
printf("usage: rm file\n");
} else {
filesystem_rm(filename);
}
} else if (strcmp(command, "echo") == 0) {
char *text = malloc(248);
memset(text, 0, 248);
size_t pos = 0;
char *word = strtok(NULL, " \n");
while (strcmp(word, ">") && strcmp(word, ">>")) {
sprintf(text + pos, "%s ", word);
pos += strlen(word) + 1;
word = strtok(NULL, " \n");
if (word == NULL) break;
}
text[strlen(text) - 1] = 0;
char *filename = strtok(NULL, " \n");
if (filename == NULL) {
printf("usage: echo text > file\n");
} else if (strchr(filename, '/') || strchr(filename, '\\')) {
printf("subdirectories are not supported\n");
} else if (!strcmp(word, ">")) {
filesystem_write_file(filename, text, strlen(text));
filesystem_append_file(filename, "\n", 1);
} else if (!strcmp(word, ">>")) {
filesystem_append_file(filename, text, strlen(text));
filesystem_append_file(filename, "\n", 1);
}
free(text);
int filesystem_cmd_ls(int argc, char *argv[]) {
if (argc >= 2) {
filesystem_ls(&lfs, argv[1]);
} else {
printf("%s: command not found\n", command);
filesystem_ls(&lfs, "/");
}
return 0;
}
int filesystem_cmd_cat(int argc, char *argv[]) {
(void) argc;
filesystem_cat(argv[1]);
return 0;
}
int filesystem_cmd_df(int argc, char *argv[]) {
(void) argc;
(void) argv;
printf("free space: %ld bytes\r\n", filesystem_get_free_space());
return 0;
}
int filesystem_cmd_rm(int argc, char *argv[]) {
(void) argc;
filesystem_rm(argv[1]);
return 0;
}
int filesystem_cmd_echo(int argc, char *argv[]) {
(void) argc;
char *line = argv[1];
size_t line_len = strlen(line);
if (line[0] == '"' || line[0] == '\'') {
line++;
line_len -= 2;
line[line_len] = '\0';
}
if (strchr(argv[3], '/')) {
printf("subdirectories are not supported\r\n");
return -2;
}
if (!strcmp(argv[2], ">")) {
filesystem_write_file(argv[3], line, line_len);
filesystem_append_file(argv[3], "\n", 1);
} else if (!strcmp(argv[2], ">>")) {
filesystem_append_file(argv[3], line, line_len);
filesystem_append_file(argv[3], "\n", 1);
} else {
return -2;
}
return 0;
}

9
movement/filesystem.h
View file

@ -96,9 +96,10 @@ bool filesystem_write_file(char *filename, char *text, int32_t length);
*/
bool filesystem_append_file(char *filename, char *text, int32_t length);
/** @brief Handles the interactive file browser when Movement is plugged in to USB.
* @param line The command that the user typed into the serial console.
*/
void filesystem_process_command(char *line);
int filesystem_cmd_ls(int argc, char *argv[]);
int filesystem_cmd_cat(int argc, char *argv[]);
int filesystem_cmd_df(int argc, char *argv[]);
int filesystem_cmd_rm(int argc, char *argv[]);
int filesystem_cmd_echo(int argc, char *argv[]);
#endif // FILESYSTEM_H_

2
movement/make/Makefile
View file

@ -49,6 +49,8 @@ SRCS += \
../../littlefs/lfs_util.c \
../movement.c \
../filesystem.c \
../shell.c \
../shell_cmd_list.c \
../watch_faces/clock/simple_clock_face.c \
../watch_faces/clock/world_clock_face.c \
../watch_faces/clock/beats_face.c \

26
movement/movement.c
View file

@ -33,6 +33,7 @@
#include "watch.h"
#include "filesystem.h"
#include "movement.h"
#include "shell.h"
#ifndef MOVEMENT_FIRMWARE
#include "movement_config.h"
@ -561,30 +562,9 @@ bool app_loop(void) {
}
}
// if we are plugged into USB, handle the file browser tasks
// if we are plugged into USB, handle the serial shell
if (watch_is_usb_enabled()) {
char line[256] = {0};
#if __EMSCRIPTEN__
// This is a terrible hack; ideally this should be handled deeper in the watch library.
// Alas, emscripten treats read() as something that should pop up an input box, so I
// wasn't able to implement this over there. I sense that this relates to read() being
// the wrong way to read data from USB (like we should be using fgets or something), but
// until I untangle that, this will have to do.
char *received_data = (char*)EM_ASM_INT({
var len = lengthBytesUTF8(tx) + 1;
var s = _malloc(len);
stringToUTF8(tx, s, len);
return s;
});
memcpy(line, received_data, min(255, strlen(received_data)));
free(received_data);
EM_ASM({
tx = "";
});
#else
read(0, line, 256);
#endif
if (strlen(line)) filesystem_process_command(line);
shell_task();
}
event.subsecond = 0;

220
movement/shell.c Normal file
View file

@ -0,0 +1,220 @@
/*
* MIT License
*
* Copyright (c) 2023 Edward Shin
*
* 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 "shell.h"
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#if __EMSCRIPTEN__
#include <emscripten.h>
#endif
#include "watch.h"
#include "shell_cmd_list.h"
extern shell_command_t g_shell_commands[];
extern const size_t g_num_shell_commands;
#define NEWLINE "\r\n"
#define SHELL_BUF_SZ (256)
#define SHELL_MAX_ARGS (16)
#define SHELL_PROMPT "swsh> "
static char s_buf[SHELL_BUF_SZ] = {0};
static size_t s_buf_len = 0;
// Pointer to the first invalid byte after the end of input.
static char *const s_buf_end = s_buf + SHELL_BUF_SZ;
static char *prv_skip_whitespace(char *c) {
while (c >= s_buf && c < s_buf_end) {
if (*c == 0) {
return NULL;
}
if (!isspace((int) *c) != 0) {
return c;
}
c++;
}
return NULL;
}
static char *prv_skip_non_whitespace(char *c) {
bool in_quote = false;
char quote_char;
while (c >= s_buf && c < s_buf_end) {
if (*c == 0) {
return NULL;
}
// Basic handling of quoted arguments.
// Can't handle recursive quotes. :(
if (in_quote || *c == '"' || *c == '\'') {
if (!in_quote) {
quote_char = *c;
in_quote = true;
} else if (*c == quote_char) {
in_quote = false;
}
} else {
if (isspace((int) *c) != 0) {
return c;
}
}
c++;
}
return NULL;
}
static int prv_handle_command() {
char *argv[SHELL_MAX_ARGS] = {0};
int argc = 0;
char *c = &s_buf[0];
s_buf[SHELL_BUF_SZ - 1] = '\0';
while (argc < SHELL_MAX_ARGS) {
// Skip contiguous whitespace
c = prv_skip_whitespace(c);
if (c == NULL) {
// Reached end of buffer
break;
}
// We hit non-whitespace, set argv and argc for this upcoming argument
argv[argc++] = c;
// Skip contiguous non-whitespace
c = prv_skip_non_whitespace(c);
if (c == NULL) {
// Reached end of buffer
break;
}
// NULL-terminate this arg string and then increment.
*(c++) = '\0';
}
if (argc == 0) {
return -1;
}
// Match against the command list
for (size_t i = 0; i < g_num_shell_commands; i++) {
if (!strcasecmp(g_shell_commands[i].name, argv[0])) {
// If argc isn't valid for this command, display its help instead.
if (((argc - 1) < g_shell_commands[i].min_args) ||
((argc - 1) > g_shell_commands[i].max_args)) {
if (g_shell_commands[i].help != NULL) {
printf(NEWLINE "%s" NEWLINE, g_shell_commands[i].help);
}
return -2;
}
// Call the command's callback
if (g_shell_commands[i].cb != NULL) {
printf(NEWLINE);
int ret = g_shell_commands[i].cb(argc, argv);
if (ret == -2) {
printf(NEWLINE "%s" NEWLINE, g_shell_commands[i].help);
}
return ret;
}
}
}
return -1;
}
void shell_task(void) {
#if __EMSCRIPTEN__
// This is a terrible hack; ideally this should be handled deeper in the watch library.
// Alas, emscripten treats read() as something that should pop up an input box, so I
// wasn't able to implement this over there. I sense that this relates to read() being
// the wrong way to read data from USB (like we should be using fgets or something), but
// until I untangle that, this will have to do.
char *received_data = (char*)EM_ASM_INT({
var len = lengthBytesUTF8(tx) + 1;
var s = _malloc(len);
stringToUTF8(tx, s, len);
return s;
});
s_buf_len = min((SHELL_BUF_SZ - 2), strlen(received_data));
memcpy(s_buf, received_data, s_buf_len);
free(received_data);
s_buf[s_buf_len++] = '\n';
s_buf[s_buf_len++] = '\0';
prv_handle_command();
EM_ASM({
tx = "";
});
#else
// Read one character at a time until we run out.
while (true) {
if (s_buf_len >= (SHELL_BUF_SZ - 1)) {
printf(NEWLINE "Command too long, clearing.");
printf(NEWLINE SHELL_PROMPT);
s_buf_len = 0;
break;
}
int c = getchar();
if (c < 0) {
// Nothing left to read, we're done.
break;
}
if (c == '\b') {
// Handle backspace character.
// We need to emit a backspace, overwrite the character on the
// screen with a space, and then backspace again to move the cursor.
if (s_buf_len > 0) {
printf("\b \b");
s_buf_len--;
}
continue;
} else if (c != '\n' && c != '\r') {
// Print regular characters to the screen.
putchar(c);
}
s_buf[s_buf_len] = c;
if (c == '\n' || c == '\r') {
// Newline! Handle the command.
s_buf[s_buf_len+1] = '\0';
(void) prv_handle_command();
s_buf_len = 0;
printf(NEWLINE SHELL_PROMPT);
break;
} else {
s_buf_len++;
}
}
#endif
}

34
movement/shell.h Normal file
View file

@ -0,0 +1,34 @@
/*
* MIT License
*
* Copyright (c) 2023 Edward Shin
*
* 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 SHELL_H_
#define SHELL_H_
/** @brief Called periodically from the app loop to handle shell commands.
* When a full command is complete, parses and executes its matching
* callback.
*/
void shell_task(void);
#endif

159
movement/shell_cmd_list.c Normal file
View file

@ -0,0 +1,159 @@
/*
* MIT License
*
* Copyright (c) 2023 Edward Shin
*
* 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 "shell_cmd_list.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "filesystem.h"
#include "watch.h"
static int help_cmd(int argc, char *argv[]);
static int flash_cmd(int argc, char *argv[]);
static int stress_cmd(int argc, char *argv[]);
shell_command_t g_shell_commands[] = {
{
.name = "?",
.help = "print command list",
.min_args = 0,
.max_args = 0,
.cb = help_cmd,
},
{
.name = "help",
.help = "print command list",
.min_args = 0,
.max_args = 0,
.cb = help_cmd,
},
{
.name = "flash",
.help = "reboot to UF2 bootloader",
.min_args = 0,
.max_args = 0,
.cb = flash_cmd,
},
{
.name = "ls",
.help = "usage: ls [PATH]",
.min_args = 0,
.max_args = 1,
.cb = filesystem_cmd_ls,
},
{
.name = "cat",
.help = "usage: cat <PATH>",
.min_args = 1,
.max_args = 1,
.cb = filesystem_cmd_cat,
},
{
.name = "df",
.help = "print filesystem free space",
.min_args = 0,
.max_args = 0,
.cb = filesystem_cmd_df,
},
{
.name = "rm",
.help = "usage: rm [PATH]",
.min_args = 1,
.max_args = 1,
.cb = filesystem_cmd_rm,
},
{
.name = "echo",
.help = "usage: echo TEXT {>,>>} FILE",
.min_args = 3,
.max_args = 3,
.cb = filesystem_cmd_echo,
},
{
.name = "stress",
.help = "test CDC write; usage: stress [LEN] [DELAY_MS]",
.min_args = 0,
.max_args = 2,
.cb = stress_cmd,
},
};
const size_t g_num_shell_commands = sizeof(g_shell_commands) / sizeof(shell_command_t);
static int help_cmd(int argc, char *argv[]) {
(void) argc;
(void) argv;
printf("Command List:\r\n");
for (size_t i = 0; i < g_num_shell_commands; i++) {
printf(" %s\t%s\r\n",
g_shell_commands[i].name,
(g_shell_commands[i].help) ? g_shell_commands[i].help : ""
);
}
return 0;
}
static int flash_cmd(int argc, char *argv[]) {
(void) argc;
(void) argv;
watch_reset_to_bootloader();
return 0;
}
#define STRESS_CMD_MAX_LEN (512)
static int stress_cmd(int argc, char *argv[]) {
char test_str[STRESS_CMD_MAX_LEN+1] = {0};
int max_len = 512;
int delay = 0;
if (argc >= 2) {
if ((max_len = atoi(argv[1])) == 0) {
return -1;
}
if (max_len > 512) {
return -1;
}
}
if (argc >= 3) {
delay = atoi(argv[2]);
}
for (int i = 0; i < max_len; i++) {
snprintf(&test_str[i], 2, "%u", (i+1)%10);
printf("%u:\t%s\r\n", (i+1), test_str);
if (delay > 0) {
delay_ms(delay);
}
}
return 0;
}

38
movement/shell_cmd_list.h Normal file
View file

@ -0,0 +1,38 @@
/*
* MIT License
*
* Copyright (c) 2023 Edward Shin
*
* 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 SHELL_CMD_LIST_H_
#define SHELL_CMD_LIST_H_
#include <stdint.h>
typedef struct {
const char *name; // Name used to invoke the command
const char *help; // Help string
int8_t min_args; // Minimum number of arguments (_excluding_ the command name)
int8_t max_args; // Maximum number of arguments (_excluding_ the command name)
int (*cb)(int argc, char *argv[]); // Callback for the command
} shell_command_t;
#endif

1
watch-library/hardware/main.c
View file

@ -79,7 +79,6 @@ int main(void) {
while (1) {
bool usb_enabled = hri_usbdevice_get_CTRLA_ENABLE_bit(USB);
bool can_sleep = app_loop();
if (can_sleep && !usb_enabled) {
app_prepare_for_standby();
sleep(4);

145
watch-library/hardware/watch/watch_private.c
View file

@ -23,6 +23,7 @@
*/
#include "watch_private.h"
#include "watch_private_cdc.h"
#include "watch_utility.h"
#include "tusb.h"
@ -185,6 +186,87 @@ void _watch_disable_tcc(void) {
// disable the TCC
hri_tcc_clear_CTRLA_ENABLE_bit(TCC0);
hri_mclk_clear_APBCMASK_TCC0_bit(MCLK);
}
void _watch_enable_tc0(void) {
// 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);
hri_tc_write_CTRLA_reg(TC0, TC_CTRLA_PRESCALER_DIV1024 | // divide the 8 MHz clock by 1024 to count at 7812.5 Hz
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, 10); // 7812.5 Hz / 10 = 781.125 Hz
// set an interrupt on overflow; this will call TC0_Handler below.
hri_tc_set_INTEN_OVF_bit(TC0);
// set priority higher than TC1
NVIC_SetPriority(TC0_IRQn, 5);
NVIC_ClearPendingIRQ(TC0_IRQn);
NVIC_EnableIRQ(TC0_IRQn);
// Start the timer
hri_tc_set_CTRLA_ENABLE_bit(TC0);
}
void _watch_disable_tc0(void) {
NVIC_DisableIRQ(TC0_IRQn);
NVIC_ClearPendingIRQ(TC0_IRQn);
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);
}
void _watch_enable_tc1(void) {
hri_gclk_write_PCHCTRL_reg(GCLK, TC1_GCLK_ID, GCLK_PCHCTRL_GEN_GCLK0_Val | GCLK_PCHCTRL_CHEN);
// and enable the peripheral clock.
hri_mclk_set_APBCMASK_TC1_bit(MCLK);
// disable and reset TC1.
hri_tc_clear_CTRLA_ENABLE_bit(TC1);
hri_tc_wait_for_sync(TC1, TC_SYNCBUSY_ENABLE);
hri_tc_write_CTRLA_reg(TC1, TC_CTRLA_SWRST);
hri_tc_wait_for_sync(TC1, TC_SYNCBUSY_SWRST);
hri_tc_write_CTRLA_reg(TC1, TC_CTRLA_PRESCALER_DIV1024 | // divide the 8 MHz clock by 1024 to count at 7812.5 Hz
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(TC1, 20); // 7812.5 Hz / 50 = 156.25 Hz
// set an interrupt on overflow; this will call TC1_Handler below.
hri_tc_set_INTEN_OVF_bit(TC1);
// set priority lower than TC0
NVIC_SetPriority(TC1_IRQn, 6);
NVIC_ClearPendingIRQ(TC1_IRQn);
NVIC_EnableIRQ(TC1_IRQn);
// Start the timer
hri_tc_set_CTRLA_ENABLE_bit(TC1);
}
void _watch_disable_tc1(void) {
NVIC_DisableIRQ(TC1_IRQn);
NVIC_ClearPendingIRQ(TC1_IRQn);
hri_tc_clear_CTRLA_ENABLE_bit(TC1);
hri_tc_wait_for_sync(TC1, TC_SYNCBUSY_ENABLE);
hri_tc_write_CTRLA_reg(TC1, TC_CTRLA_SWRST);
hri_tc_wait_for_sync(TC1, TC_SYNCBUSY_SWRST);
}
void TC0_Handler(void) {
tud_task();
TC0->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF;
}
void TC1_Handler(void) {
cdc_task();
TC1->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF;
}
void _watch_enable_usb(void) {
@ -231,76 +313,17 @@ void _watch_enable_usb(void) {
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);
_watch_enable_tc0();
// 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;
}
static char buf[256] = {0};
int _read(int file, char *ptr, int len) {
(void)file;
int actual_length = strlen(buf);
if (actual_length) {
memcpy(ptr, buf, min(len, actual_length));
return actual_length;
}
return 0;
_watch_enable_tc1();
}
void USB_Handler(void) {
tud_int_handler(0);
}
static void cdc_task(void) {
if (tud_cdc_n_available(0)) {
tud_cdc_n_read(0, buf, sizeof(buf));
} else {
memset(buf, 0, 256);
}
}
void TC0_Handler(void) {
tud_task();
cdc_task();
TC0->COUNT8.INTFLAG.reg |= TC_INTFLAG_OVF;
}
// USB Descriptors and tinyUSB callbacks follow.
/*

160
watch-library/hardware/watch/watch_private_cdc.c Normal file
View file

@ -0,0 +1,160 @@
/*
* MIT License
*
* Copyright (c) 2020 Joey Castillo
* Copyright (c) 2023 Edward Shin
*
* 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 "watch_private_cdc.h"
#include <stddef.h>
#include "watch_utility.h"
#include "tusb.h"
/*
* Implement a circular buffer for the USB CDC Serial read buffer.
* The size of the buffer must be a power of two for this circular buffer
* implementation to work.
*/
// Size of the circular buffer. Must be a power of two.
#define CDC_WRITE_BUF_SZ (1024)
// Macro function to perform modular arithmetic on an index.
// eg. (63 + 2) & (64 - 1) -> 1
#define CDC_WRITE_BUF_IDX(x) ((x) & (CDC_WRITE_BUF_SZ - 1))
static char s_write_buf[CDC_WRITE_BUF_SZ] = {0};
static size_t s_write_buf_pos = 0;
static size_t s_write_buf_len = 0;
#define CDC_READ_BUF_SZ (256)
#define CDC_READ_BUF_IDX(x) ((x) & (CDC_READ_BUF_SZ - 1))
static char s_read_buf[CDC_READ_BUF_SZ] = {0};
static size_t s_read_buf_pos = 0;
static size_t s_read_buf_len = 0;
// Mask TC1 interrupts, preventing calls to cdc_task()
static inline void prv_critical_section_enter(void) {
NVIC_DisableIRQ(TC1_IRQn);
}
// Unmask TC1 interrupts, allowing calls to cdc_task()
static inline void prv_critical_section_exit(void) {
NVIC_EnableIRQ(TC1_IRQn);
}
int _write(int file, char *ptr, int len) {
(void) file;
if (ptr == NULL || len <= 0) {
return -1;
}
int bytes_written = 0;
prv_critical_section_enter();
for (int i = 0; i < len; i++) {
s_write_buf[s_write_buf_pos] = ptr[i];
s_write_buf_pos = CDC_WRITE_BUF_IDX(s_write_buf_pos + 1);
if (s_write_buf_len < CDC_WRITE_BUF_SZ) {
s_write_buf_len++;
}
bytes_written++;
}
prv_critical_section_exit();
return bytes_written;
}
int _read(int file, char *ptr, int len) {
(void) file;
prv_critical_section_enter();
if (ptr == NULL || len <= 0 || s_read_buf_len == 0) {
prv_critical_section_exit();
return -1;
}
// Clamp to the length of the read buffer
if ((size_t) len > s_read_buf_len) {
len = s_read_buf_len;
}
// Calculate the start of the circular buffer, and iterate from there
const size_t start_pos = CDC_READ_BUF_IDX(s_read_buf_pos - len);
for (size_t i = 0; i < (size_t) len; i++) {
const size_t idx = CDC_READ_BUF_IDX(start_pos + i);
ptr[i] = s_read_buf[idx];
s_read_buf[idx] = 0;
}
// Update circular buffer position and length
s_read_buf_len -= len;
s_read_buf_pos = CDC_READ_BUF_IDX(s_read_buf_pos - len);
prv_critical_section_exit();
return len;
}
static void prv_handle_reads(void) {
while (tud_cdc_available()) {
int c = tud_cdc_read_char();
if (c < 0) {
continue;
}
s_read_buf[s_read_buf_pos] = c;
s_read_buf_pos = CDC_READ_BUF_IDX(s_read_buf_pos + 1);
if (s_read_buf_len < CDC_READ_BUF_SZ) {
s_read_buf_len++;
}
}
}
static void prv_handle_writes(void) {
if (s_write_buf_len > 0) {
const size_t start_pos =
CDC_WRITE_BUF_IDX(s_write_buf_pos - s_write_buf_len);
for (size_t i = 0; i < (size_t) s_write_buf_len; i++) {
const size_t idx = CDC_WRITE_BUF_IDX(start_pos + i);
if (tud_cdc_available() > 0) {
// If we receive data while doing a large write, we need to
// fully service it before continuing to write, or the
// stack will crash.
prv_handle_reads();
}
if (tud_cdc_write_available()) {
tud_cdc_write(&s_write_buf[idx], 1);
}
s_write_buf[idx] = 0;
s_write_buf_len--;
}
tud_cdc_write_flush();
}
}
void cdc_task(void) {
prv_handle_reads();
prv_handle_writes();
}

33
watch-library/hardware/watch/watch_private_cdc.h Normal file
View file

@ -0,0 +1,33 @@
/*
* MIT License
*
* Copyright (c) 2020 Joey Castillo
* Copyright (c) 2023 Edward Shin
*
* 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 _WATCH_PRIVATE_CDC_H_INCLUDED
#define _WATCH_PRIVATE_CDC_H_INCLUDED
int _write(int file, char *ptr, int len);
int _read(int file, char *ptr, int len);
void cdc_task(void);
#endif

4
watch-library/shared/watch/watch.h
View file

@ -88,6 +88,10 @@ bool watch_is_usb_enabled(void);
*/
void watch_reset_to_bootloader(void);
/** @brief Call periodically from app main loop to service CDC RX/TX.
*/
void cdc_task(void);
/** @brief Reads up to len bytes from the USB serial.
* @param file ignored, you can pass in 0
* @param ptr pointer to a buffer of at least len bytes

19
watch-library/shared/watch/watch_private.h
View file

@ -38,14 +38,19 @@ 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);
/// Enable USB task timer. Called by USB enable routine in main(). You should not call this from your app.
void _watch_enable_tc0(void);
/// Disable USB task timer. You should not call this from your app.
void _watch_disable_tc0(void);
/// Enable CDC task timer. Called by USB enable routine in main(). You should not call this from your app.
void _watch_enable_tc1(void);
/// Disable CDC task timer. You should not call this from your app.
void _watch_disable_tc1(void);
/// Called by main.c if plugged in to USB. You should not call this from your app.
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);
// i thought this would be called by gets but it doesn't? anyway it does get called by read()
// so that's our mechanism for reading data from the USB serial console.
int _read(int file, char *ptr, int len);
#endif