usart.h

Go to the documentation of this file.

#ifndef _USART_H
#define _USART_H

#include <hal_types.h>
#include "ring_buffer.h"

/*
 * Devices
 */

#ifndef USART_RX_BUF_SIZE
#define USART_RX_BUF_SIZE               512
#endif

#ifndef USART_TX_BUF_SIZE
#define USART_TX_BUF_SIZE               1024
#endif

typedef void (* usart_cb)();

typedef struct usart_state {
    Handler callback;

    uint8_t txbusy;

    uint8_t rx_buf[USART_RX_BUF_SIZE];
    uint8_t tx_buf[USART_TX_BUF_SIZE];

    uint8_t is_used; // flag that USART is used

} usart_state;

typedef struct usart_dev {
    USART_TypeDef* USARTx;             
    uint32_t clk;
    IRQn_Type irq;
    uint8_t rx_pin;
    uint8_t tx_pin;
    uint8_t gpio_af;
    usart_state *state;
    ring_buffer *rxrb;                 
    ring_buffer *txrb;                 
} usart_dev;


extern const usart_dev * const UARTS[];

#ifdef __cplusplus
  extern "C" {
#endif

extern const usart_dev * const _USART1;
extern const usart_dev * const _USART2; 
extern const usart_dev * const _USART3;
extern const usart_dev * const _UART4;
extern const usart_dev * const _UART5;
extern const usart_dev * const _USART6;

#define USART_F_RXNE 0x20
#define USART_F_TXE  0x80
#define USART_F_ORE  0x8

#define USART_MASK_IDLEIE 0x10
#define USART_MASK_RXNEIE 0x20
#define USART_MASK_TCEIE  0x40
#define USART_MASK_TXEIE  0x80
#define USART_MASK_PEIE   0x100

#define USART_MASK2_LBDIE  0x40

#define USART_MASK3_CTSIE  0x400
#define USART_MASK3_EIE  0x1

#define UART_Mode_Rx      (0x0004)
#define UART_Mode_Tx      (0x0008)

#define UART_HardwareFlowControl_None       (0x0000)
#define UART_HardwareFlowControl_RTS        (0x0100)
#define UART_HardwareFlowControl_CTS        (0x0200)
#define UART_HardwareFlowControl_RTS_CTS    (0x0300)

#define UART_Word_8b                  ((uint16_t)0x0000)
#define UART_Word_9b                  ((uint16_t)0x1000)

void usart_init(const usart_dev *dev);

 
/*
    USART_Word_Length 
    -----------------
    USART_WordLength_8b
    USART_WordLength_9b  

    USART_Stop_Bits
    ---------------
    USART_StopBits_1
    USART_StopBits_0_5
    USART_StopBits_2
    USART_StopBits_1_5   

    USART_Parity
    ------------
    USART_Parity_No
    USART_Parity_Even
    USART_Parity_Odd 

    USART_Mode
    ----------
    USART_Mode_Rx
    USART_Mode_Tx  

    USART_Hardware_Flow_Control
    ---------------------------
    USART_HardwareFlowControl_None
    USART_HardwareFlowControl_RTS
    USART_HardwareFlowControl_CTS
    USART_HardwareFlowControl_RTS_CTS  
*/

void usart_setup(const usart_dev *dev, 
                 uint32_t  baudRate, 
                 uint16_t  wordLength, 
                 uint16_t  stopBits, 
                 uint16_t  parity, 
                 uint16_t  mode, 
                 uint16_t  hardwareFlowControl);

static inline void usart_enable(const usart_dev *dev)
{
    dev->state->is_used=true;

    /* Check the parameters */
    assert_param(IS_USART_ALL_PERIPH(dev->USARTx));

    /* Enable USART */
//    USART_Cmd(dev->USARTx, ENABLE);
    
    dev->USARTx->CR1 |= USART_CR1_UE; /* Enable the selected USART by setting the UE bit in the CR1 register */

}


static inline uint8_t usart_is_used(const usart_dev *dev)
{
    return dev->state->is_used;
}


static inline void usart_disable(const usart_dev *dev){
    /* Disable the selected USART by clearing the UE bit in the CR1 register */
    dev->USARTx->CR1 &= (uint16_t)~((uint16_t)USART_CR1_UE);
    
    /* Clean up buffer */
    dev->state->is_used=false;
}

void usart_foreach(void (*fn)(const usart_dev*));


static inline uint32_t usart_txfifo_nbytes(const usart_dev *dev) {
    return rb_full_count(dev->txrb);
}
static inline uint32_t usart_txfifo_freebytes(const usart_dev *dev) {
        uint32_t used = rb_full_count(dev->txrb);
        if(used >= USART_TX_BUF_SIZE/2) return 0; // leave half for dirty writes without check - thanks s_s
    return (USART_TX_BUF_SIZE/2-used);
}
static inline void usart_disable_all(void) {
    usart_foreach(usart_disable);
}

uint32_t usart_tx(const usart_dev *dev, const uint8_t *buf, uint32_t len);

void usart_putudec(const usart_dev *dev, uint32_t val);

static inline uint32_t usart_putc(const usart_dev* dev, uint8_t bt) {
    //uint32_t ret=0;
    //uint32_t cnt=0;
    //if (!usart_tx(dev, &byte, 1))
    //;
    return usart_tx(dev, &bt, 1);
}

static inline void usart_putstr(const usart_dev *dev, const char* str) {
    uint32_t i = 0;
    uint8_t c;
    while ( (c=str[i++]) )  usart_putc(dev, c);
    
}

static inline uint8_t usart_getc(const usart_dev *dev) {
    return rb_remove(dev->rxrb);
}

static inline uint32_t usart_data_available(const usart_dev *dev) {
    return rb_full_count(dev->rxrb);
}


static inline void usart_reset_rx(const usart_dev *dev) {
    rb_reset(dev->rxrb);
}

static inline void usart_reset_tx(const usart_dev *dev) {
    rb_reset(dev->txrb);
    dev->state->txbusy = 0;
}

static inline void usart_set_callback(const usart_dev *dev, Handler cb)
{
    dev->state->callback = cb;
}


void USART1_IRQHandler(void);
void USART2_IRQHandler(void);
void USART3_IRQHandler(void);
void USART4_IRQHandler(void);
void USART5_IRQHandler(void);
void USART6_IRQHandler(void);

void UART4_IRQHandler(void);
void UART5_IRQHandler(void);


#ifdef __cplusplus
  }
#endif

#endif