hueso/Sensor-Watch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

refactor watch UART for gossamer

Browse Source
This commit is contained in:
joeycastillo 2024-10-08 17:23:08 -04:00
parent b7fbc7420b
commit cdcb612432
5 changed files with 54 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -70,6 +70,7 @@ SRCS += \
./watch-library/simulator/watch/watch_slcd.c \
./watch-library/simulator/watch/watch_storage.c \
./watch-library/simulator/watch/watch_tcc.c \
./watch-library/simulator/watch/watch_uart.c \
else
@ -87,6 +88,7 @@ SRCS += \
./watch-library/hardware/watch/watch_slcd.c \
./watch-library/hardware/watch/watch_storage.c \
./watch-library/hardware/watch/watch_tcc.c \
./watch-library/hardware/watch/watch_uart.c \
./watch-library/hardware/watch/watch_usb_descriptors.c \
./watch-library/hardware/watch/watch_usb_cdc.c \

119
watch-library/hardware/watch/watch_uart.c
View File

@ -1,7 +1,7 @@
/*
* MIT License
*
* Copyright (c) 2020 Joey Castillo
* Copyright (c) 2020-2024 Joey Castillo
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -23,96 +23,53 @@
*/
#include "watch_uart.h"
#include "uart.h"
#include "usb.h"
#include <string.h>
struct usart_sync_descriptor USART_0;
struct io_descriptor *uart_io;
void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud) {
uart_rxpo_t rxpo = UART_RXPO_NONE;
void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud) {
SERCOM_USART_CTRLA_Type ctrla;
SERCOM_USART_CTRLB_Type ctrlb;
ctrla.reg = SERCOM_USART_CTRLA_DORD | SERCOM_USART_CTRLA_MODE(1);
ctrlb.reg = SERCOM_USART_CTRLB_CHSIZE(0);
MCLK->APBCMASK.reg |= MCLK_APBCMASK_SERCOM3;
GCLK->PCHCTRL[SERCOM3_GCLK_ID_CORE].reg = GCLK_PCHCTRL_GEN(0) | GCLK_PCHCTRL_CHEN;
while (0 == (GCLK->PCHCTRL[SERCOM3_GCLK_ID_CORE].reg & GCLK_PCHCTRL_CHEN)) {
// wait
if (rx_pin == HAL_GPIO_A1_pin()) {
rxpo = UART_RXPO_3;
HAL_GPIO_A1_in();
HAL_GPIO_A1_pmuxen(HAL_GPIO_PMUX_SERCOM);
} else if (rx_pin == HAL_GPIO_A2_pin()) {
rxpo = UART_RXPO_0;
HAL_GPIO_A2_in();
HAL_GPIO_A2_pmuxen(HAL_GPIO_PMUX_SERCOM);
} else if (rx_pin == HAL_GPIO_A3_pin()) {
rxpo = UART_RXPO_1;
HAL_GPIO_A3_in();
HAL_GPIO_A3_pmuxen(HAL_GPIO_PMUX_SERCOM);
} else if (rx_pin == HAL_GPIO_A4_pin()) {
rxpo = UART_RXPO_2;
HAL_GPIO_A4_in();
HAL_GPIO_A4_pmuxen(HAL_GPIO_PMUX_SERCOM);
}
usart_sync_init(&USART_0, SERCOM3, (void *)NULL);
SERCOM3->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE;
switch (tx_pin) {
case A2:
gpio_set_pin_direction(tx_pin, GPIO_DIRECTION_OUT);
gpio_set_pin_function(tx_pin, PINMUX_PB02C_SERCOM3_PAD0);
ctrla.reg |= SERCOM_USART_CTRLA_TXPO(0);
ctrlb.reg |= SERCOM_USART_CTRLB_TXEN;
break;
case A4:
gpio_set_pin_direction(tx_pin, GPIO_DIRECTION_OUT);
gpio_set_pin_function(tx_pin, PINMUX_PB00C_SERCOM3_PAD2);
ctrla.reg |= SERCOM_USART_CTRLA_TXPO(1);
ctrlb.reg |= SERCOM_USART_CTRLB_TXEN;
break;
default:
break;
}
switch (rx_pin) {
case A1:
gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
gpio_set_pin_function(rx_pin, PINMUX_PB01C_SERCOM3_PAD3);
ctrla.reg |= SERCOM_USART_CTRLA_RXPO(3);
ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
break;
case A2:
gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
gpio_set_pin_function(rx_pin, PINMUX_PB02C_SERCOM3_PAD0);
ctrla.reg |= SERCOM_USART_CTRLA_RXPO(0);
ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
break;
case A3:
gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
gpio_set_pin_function(rx_pin, PINMUX_PB03C_SERCOM3_PAD1);
ctrla.reg |= SERCOM_USART_CTRLA_RXPO(1);
ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
break;
case A4:
gpio_set_pin_direction(rx_pin, GPIO_DIRECTION_IN);
gpio_set_pin_function(rx_pin, PINMUX_PB00C_SERCOM3_PAD2);
ctrla.reg |= SERCOM_USART_CTRLA_RXPO(2);
ctrlb.reg |= SERCOM_USART_CTRLB_RXEN;
break;
default:
break;
}
SERCOM3->USART.CTRLA.reg = ctrla.reg;
SERCOM3->USART.CTRLB.reg = ctrlb.reg;
if (hri_usbdevice_get_CTRLA_ENABLE_bit(USB)) {
uint64_t br = 65536 - ((65536 * 16.0f * baud) / 8000000);
SERCOM3->USART.BAUD.reg = (uint16_t)br;
if (tx_pin == HAL_GPIO_A2_pin()) {
uart_init_instance(3, UART_TXPO_0, rxpo, baud);
HAL_GPIO_A2_pmuxen(HAL_GPIO_PMUX_SERCOM);
} else if (tx_pin == HAL_GPIO_A4_pin()) {
uart_init_instance(3, UART_TXPO_2, rxpo, baud);
HAL_GPIO_A4_pmuxen(HAL_GPIO_PMUX_SERCOM);
} else {
uint64_t br = 65536 - ((65536 * 16.0f * baud) / 4000000);
SERCOM3->USART.BAUD.reg = (uint16_t)br;
uart_init_instance(3, UART_TXPO_NONE, rxpo, baud);
}
SERCOM3->USART.CTRLA.reg |= SERCOM_USART_CTRLA_ENABLE;
usart_sync_enable(&USART_0);
usart_sync_get_io_descriptor(&USART_0, &uart_io);
uart_enable_instance(3);
}
void watch_uart_puts(char *s) {
io_write(uart_io, (uint8_t *)s, strlen(s));
void watch_uart_puts(uint8_t *s) {
uart_write_instance(3, s, strlen((const char *)s));
}
char watch_uart_getc(void) {
uint8_t retval;
io_read(uart_io, &retval, 1);
return retval;
size_t watch_uart_gets(uint8_t *data, size_t max_length) {
return uart_read_instance(3, data, max_length);
}
void irq_handler_sercom3(void);
void irq_handler_sercom3(void) {
uart_irq_handler(3);
}

2
watch-library/shared/watch/watch.h
View File

@ -69,7 +69,7 @@ typedef void (*watch_cb_t)(void);
#include "watch_gpio.h"
// #include "watch_i2c.h"
// #include "watch_spi.h"
// #include "watch_uart.h"
#include "watch_uart.h"
#include "watch_storage.h"
#include "watch_deepsleep.h"

18
watch-library/shared/watch/watch_uart.h
View File

@ -25,6 +25,7 @@
#define _WATCH_UART_H_INCLUDED
////< @file watch_uart.h
#include <stddef.h>
#include "watch.h"
/** @addtogroup uart UART
@ -32,25 +33,26 @@
**/
/// @{
/** @brief Initializes the debug UART.
/** @brief Initializes the UART.
* @param tx_pin The pin the watch will use to transmit, or 0 for a receive-only UART.
* If specified, must be either A2 or A4.
* If specified, must be either HAL_GPIO_A2_pin() or HAL_GPIO_A4_pin().
* @param rx_pin The pin the watch will use to receive, or 0 for a transmit-only UART.
* If specified, must be A1, A2, A3 or A4 (pin A0 cannot receive UART data).
* @param baud The baud rate for the UART. A typical value is 19200.
*/
void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud);
void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud);
/** @brief Transmits a string of bytes on the UART's TX pin.
* @param s A null-terminated string containing the bytes you wish to transmit.
*/
void watch_uart_puts(char *s);
void watch_uart_puts(uint8_t *s);
/** @brief Receives a single byte from the UART's RX pin.
* @return the received byte.
* @note This method will block until a byte is received!
/** @brief Returns a string of bytes received on the UART's RX pin.
* @param data A pointer to a buffer where the received bytes will be stored.
* @param max_length The maximum number of bytes to receive.
* @return The number of bytes actually received into the buffer.
*/
char watch_uart_getc(void);
size_t watch_uart_gets(uint8_t *data, size_t max_length);
/// @}
#endif

7
watch-library/simulator/watch/watch_uart.c
View File

@ -23,23 +23,22 @@
*/
#include "watch_uart.h"
#include "peripheral_clk_config.h"
static bool tx_enable = false;
static bool rx_enable = false;
void watch_enable_uart(const uint8_t tx_pin, const uint8_t rx_pin, uint32_t baud) {
void watch_enable_uart(const uint16_t tx_pin, const uint16_t rx_pin, uint32_t baud) {
tx_enable = !!tx_pin;
rx_enable = !!rx_pin;
}
void watch_uart_puts(char *s) {
void watch_uart_puts(uint8_t *s) {
if (tx_enable) {
// TODO: hook up to UI
}
}
char watch_uart_getc(void) {
size_t watch_uart_gets(uint8_t *data, size_t max_length) {
if (rx_enable) {
// TODO: hook up to UI
}