usart.h

Go to the documentation of this file.

#pragma once
#include <inttypes.h>
#include <avr/io.h>
#include "gpio.h"
#include "circular_buffer.h"
 
namespace hal {
 
namespace usart {
 
constexpr uint16_t UART_BAUD_SELECT(uint32_t baudRate, uint32_t xtalCpu) {
    return (((double)(xtalCpu)) / (((double)(baudRate)) * 8.0) - 1.0 + 0.5);
}
 
class USART {
public:
    struct USART_TypeDef {
        volatile uint8_t UCSRxA;
        volatile uint8_t UCSRxB;
        volatile uint8_t UCSRxC;
        volatile uint8_t UCSRxD;
        volatile uint16_t UBRRx;
        volatile uint8_t UDRx;
    };
 
    struct USART_InitTypeDef {
        hal::gpio::GPIO_pin rx_pin;
        hal::gpio::GPIO_pin tx_pin;
        uint32_t baudrate;
    };
 
    uint8_t Peek() const {
        return rx_buf.front();
    }
    bool ReadEmpty() const {
        return rx_buf.empty();
    }
    uint8_t Read();
 
    void Write(uint8_t c);
    void WriteS(const char *str);
    void WriteS_P(const char *str_P);
 
    void puts(const char *str);
    void puts_P(const char *str_P);
    bool CanWrite() const {
        return !tx_buf.full();
    }
    void Flush();
 
    __attribute__((always_inline)) inline void rx_enable() { husart->UCSRxB |= (1 << RXEN1); };
 
    __attribute__((always_inline)) inline void Init(USART_InitTypeDef *const conf) {
        gpio::Init(conf->rx_pin, gpio::GPIO_InitTypeDef(gpio::Mode::input, gpio::Level::low));
        gpio::Init(conf->tx_pin, gpio::GPIO_InitTypeDef(gpio::Mode::output, gpio::Level::low));
        husart->UBRRx = UART_BAUD_SELECT(conf->baudrate, F_CPU);
        husart->UCSRxA |= (1 << U2X1); // Set double baudrate setting. Clear all other status bits/flags
        // husart->UCSRxC |= (1 << 3); // 2 stop bits. Preserve data size setting
        husart->UCSRxD = 0; // disable hardware flow control. Few avr MCUs have this feature, but this register is reserved on all AVR devices with USART, so we can disable it without consequences.
        husart->UCSRxB = (1 << TXEN1) | (1 << RXCIE1); // Turn on the transmission and reception circuitry and enable the RX interrupt
    }
 
    __attribute__((always_inline)) inline void ISR_RX() {
        if (husart->UCSRxA & (1 << FE1)) {
            (void)husart->UDRx;
        } else {
            rx_buf.push((uint8_t)husart->UDRx);
        }
    }
    __attribute__((always_inline)) inline void ISR_UDRE() {
        uint8_t c = 0;
        tx_buf.pop(c);
        husart->UDRx = c;
 
        // clear the TXC bit -- "can be cleared by writing a one to its bit
        // location". This makes sure flush() won't return until the bytes
        // actually got written
        husart->UCSRxA |= (1 << TXC1);
 
        if (tx_buf.empty())
            husart->UCSRxB &= ~(1 << UDRIE1); // disable UDRE interrupt
    }
 
    USART(USART_TypeDef *husart)
        : husart(husart) {};
 
private:
    // IO base address
    USART_TypeDef *husart;
    bool _written;
 
    CircularBuffer<uint8_t, uint_fast8_t, 32> tx_buf;
    CircularBuffer<uint8_t, uint_fast8_t, 32> rx_buf;
};
 
extern USART usart1;
 
} // namespace usart
} // namespace hal
 
#define USART1 ((hal::usart::USART::USART_TypeDef *)&UCSR1A)
 
namespace hu = hal::usart;