/*
* 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
*/
#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
- }
-
- 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;
+ 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);
}
- 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);
+}
\ No newline at end of file
#define _WATCH_UART_H_INCLUDED
////< @file watch_uart.h
+#include <stddef.h>
#include "watch.h"
/** @addtogroup uart UART
**/
/// @{
-/** @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
projects / sensor-watch.git / commitdiff