UART.hh

Go to the documentation of this file.

#ifndef COSA_UART_HH
#define COSA_UART_HH

// Default reciever buffer size
#ifndef COSA_UART_RX_BUFFER_MAX
# if defined(BOARD_ATTINY)
#   define COSA_UART_RX_BUFFER_MAX 16
# else
#   define COSA_UART_RX_BUFFER_MAX 32
# endif
#endif

// Default transmitter buffer size
#ifndef COSA_UART_TX_BUFFER_MAX
# if defined(BOARD_ATTINY)
#   define COSA_UART_TX_BUFFER_MAX 16
# else
#   define COSA_UART_TX_BUFFER_MAX 32
# endif
#endif

#if defined(BOARD_ATTINY)
#include "Cosa/Soft/UART.hh"
// Default is serial output only
// extern Soft::UART uart;
extern Soft::UAT uart;
#else

#include "Cosa/Types.h"
#include "Cosa/Serial.hh"
#include "Cosa/IOStream.hh"
#include "Cosa/Board.hh"

class UART : public Serial {
public:
  static const uint16_t RX_BUFFER_MAX = COSA_UART_RX_BUFFER_MAX;
  static const uint16_t TX_BUFFER_MAX = COSA_UART_TX_BUFFER_MAX;

  UART(uint8_t port, IOStream::Device* ibuf, IOStream::Device* obuf) :
    Serial(),
    m_port(port),
    m_sfr(Board::UART(port)),
    m_ibuf(ibuf),
    m_obuf(obuf),
    m_idle(true)
  {
    uart[port] = this;
  }

  virtual int available()
  {
    return (m_ibuf->available());
  }

  virtual int room()
  {
    return (m_obuf->room());
  }

  virtual int putchar(char c);

  virtual int peekchar()
  {
    return (m_ibuf->peekchar());
  }

  virtual int peekchar(char c)
  {
    return (m_ibuf->peekchar(c));
  }

  virtual int getchar()
  {
    return (m_ibuf->getchar());
  }

  virtual int flush();

  virtual void empty()
  {
    m_ibuf->empty();
  }

  virtual bool begin(uint32_t baudrate = DEFAULT_BAUDRATE,
                     uint8_t format = DEFAULT_FORMAT);

  virtual bool end();

  virtual void powerup();

  virtual void powerdown();

protected:
  uint8_t m_port;                       
  volatile uint8_t* const m_sfr;        
  IOStream::Device* m_ibuf;             
  IOStream::Device* m_obuf;             
  bool m_idle;                          

  static UART* uart[Board::UART_MAX];

  volatile uint8_t* UCSRnA() const
  {
    return (m_sfr);
  }

  volatile uint8_t* UCSRnB() const
  {
    return (m_sfr + 1);
  }

  volatile uint8_t* UCSRnC() const
  {
    return (m_sfr + 2);
  }

  volatile uint16_t* UBRRn() const
  {
    return ((volatile uint16_t*) (m_sfr + 4));
  }

  volatile uint8_t* UDRn() const
  {
    return (m_sfr + 6);
  }

  virtual void on_udre_interrupt();

  virtual void on_rx_interrupt();

  virtual void on_tx_interrupt() {}

  // Interrupt Service Routines are friends
#if defined(USART_UDRE_vect)
  friend void USART_UDRE_vect(void);
  friend void USART_RX_vect(void);
  friend void USART_TX_vect(void);
#endif
#if defined(USART1_UDRE_vect)
  friend void USART1_UDRE_vect(void);
  friend void USART1_RX_vect(void);
  friend void USART1_TX_vect(void);
#endif
#if defined(USART2_UDRE_vect)
  friend void USART2_UDRE_vect(void);
  friend void USART2_RX_vect(void);
  friend void USART2_TX_vect(void);
#endif
#if defined(USART3_UDRE_vect)
  friend void USART3_UDRE_vect(void);
  friend void USART3_RX_vect(void);
  friend void USART3_TX_vect(void);
#endif
};

#if defined(USBCON)
#include "Cosa/CDC.hh"
#define uart cdc
#else
extern UART uart;
#endif
#endif
#endif