UART Functions

Functions
void	sd_usart1_init (void)
	USART 1 Initialization.
void	sd_usart2_init (void)
	USART 2 Initialization.
void	sd_usart3_init (void)
	USART 3 Initialization.
void	HAL_UART_MspInit (UART_HandleTypeDef *huart)
void	HAL_UART_MspDeInit (UART_HandleTypeDef *huart)
enum sd_uart_err	sd_uart_rx_init (struct sd_uart_dev *dev, struct sd_cbuf *rx_buff)
	UART Receive Interrupt Initialization Enable and prepare the UART to receive on interrupt. More...
void	sd_uart_irqhandler (struct sd_uart_dev *dev)
	UART Interrupt Handler Handle interrupt events on the UART peripheral. More...
enum sd_uart_err	sd_uart_transmit (struct sd_uart_dev *dev, uint8_t *buf, uint32_t len, uint32_t timeout)
	Transmit Data In Blocking Mode. More...

Detailed Description

Function Documentation

HAL_UART_MspInit()

void HAL_UART_MspInit

(

UART_HandleTypeDef *

huart

)

#include <Src/sd_uart.c>

USART 1 GPIO Configuration

Pin/Port	Signal –——
PB7	USART1_RX
PB6	USART1_TX

USART 2 GPIO Configuration

Pin/Port	Signal --——
PD5	USART2_TX
PD6	USART2_RX
PD4	USART2_RTS
PD3	USART2_CTS

USART 2 GPIO Configuration

Pin/Port	Signal -----—
PC4	USART3_TX
PC5	USART3_RX

{
    GPIO_InitTypeDef GPIO_InitStruct;
    
    if (huart->Instance == USART1) {
        /* Peripheral clock enable */
        __USART1_CLK_ENABLE();
  
  
        GPIO_InitStruct.Pin = ZYNQ_CONSOLE_TX_Pin|ZYNQ_CONSOLE_RX_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_PULLUP;
        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
        GPIO_InitStruct.Alternate = GPIO_AF0_USART1;
        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

        /* Peripheral interrupt init*/
        HAL_NVIC_SetPriority(USART1_IRQn, 1, 0);
        HAL_NVIC_EnableIRQ(USART1_IRQn);
        
    } else if (huart->Instance == USART2) {
        /* Peripheral clock enable */
        __USART2_CLK_ENABLE();
  
        GPIO_InitStruct.Pin = BT_HCI_RX_Pin|BT_HCI_TX_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_PULLUP;
        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
        GPIO_InitStruct.Alternate = GPIO_AF0_USART2;
        HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = BT_HCI_CTS_Pin|BT_HCI_RTS_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
        GPIO_InitStruct.Alternate = GPIO_AF0_USART2;
        HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

        /* Peripheral interrupt init*/
        HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(USART2_IRQn);

    } else if (huart->Instance == USART3) {
        /* Peripheral clock enable */
        __USART3_CLK_ENABLE();
  
        GPIO_InitStruct.Pin =  WL_RS232_TX_Pin |  WL_RS232_RX_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
        GPIO_InitStruct.Pull = GPIO_PULLUP;
        GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
        GPIO_InitStruct.Alternate = GPIO_AF0_USART3;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

        /* Peripheral interrupt init*/
        HAL_NVIC_SetPriority(USART3_4_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(USART3_4_IRQn);
    }
}

sd_uart_irqhandler()

void sd_uart_irqhandler

(

struct sd_uart_dev *

dev

)

#include <Src/sd_uart.c>

UART Interrupt Handler Handle interrupt events on the UART peripheral.

Parameters

dev	UART device that triggered the interrupt

Return values

None

{
    UART_HandleTypeDef *huart = dev->uart;
  
    /* Check for errors and store them in the device error state */
    if ((dev->error |= __SD_UART_ERROR_IT(huart))) {
        __SD_UART_CLEAR_ERROR_IT(huart);    /* Clear the error flags */
        sd_uart_err_cb(dev);            /* Execute error callback */
        dev->error = SD_UART_ERROR_NONE;    /* Clear the error */
        return;                     /* Return without reading or writing */
    }

    /* Receive Interrupt */
    if ((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && 
        (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET)) {
        sd_uart_rx_isr(dev);
        /* Clear RXNE interrupt flag */
        __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);
    }
       
    /* Transmit Interrupt */
    if ((__HAL_UART_GET_IT(huart, UART_IT_TXE) != RESET) &&
        (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE) != RESET)) {
        UART_Transmit_IT(huart);
    }

    /* Transmit End Interrupt */
    if ((__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) &&
        (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET)) {
        UART_EndTransmit_IT(huart);
    }  
}

sd_uart_rx_init()

enum sd_uart_err sd_uart_rx_init	(	struct sd_uart_dev *	dev,
		struct sd_cbuf *	rx_buff
	)

#include <Src/sd_uart.c>

UART Receive Interrupt Initialization Enable and prepare the UART to receive on interrupt.

Note

This function expects that the UART peripheral and the buffer have already been inititialized and are ready to be used.

Parameters

uart_dev	Device to initialize UART and buffer with
huart	UART peripheral handle
rx_buff	Buffer to use for UART receive function

Return values

SD_UART_SUCCESS

on success, error state otherwise

{
    UART_HandleTypeDef *huart = dev->uart;
    
    if ((huart == NULL) || (rx_buff == NULL))
        return SD_UART_ERROR;
                        
    dev->rx_buff = rx_buff;    /* Set the RX buffer pointer */
       
    /* Process Locked */            
    if (huart->Lock == HAL_LOCKED) 
        return SD_UART_LOCKED;
    else
        huart->Lock = HAL_LOCKED;

    /* Computation of UART mask to apply to RDR register */
    UART_MASK_COMPUTATION(huart);

    huart->ErrorCode = HAL_UART_ERROR_NONE;

    /* Enable the UART Parity Error Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_PE);

    /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);

    /* Process Unlocked */
    huart->Lock = HAL_UNLOCKED;

    /* Enable the UART Data Register not empty Interrupt */
    __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);

    return SD_UART_SUCCESS;
}

sd_uart_transmit()

enum sd_uart_err sd_uart_transmit ( struct sd_uart_dev *  dev, uint8_t *  buf, uint32_t  len, uint32_t  timeout  )

inline

#include <Src/sd_uart.c>

Transmit Data In Blocking Mode.

Parameters

dev	The UART peripheral to trasmit over
buf	Buffer data to trasmit
len	Length of buffer data
timeout	Timeout for transmission activity

Return values

SD_UART_SUCCESS

on success, error status otherwise

{
    if (HAL_UART_Transmit(dev->uart, buf, len, timeout) == HAL_OK)
        return SD_UART_SUCCESS;
    
    return SD_UART_ERROR;
}