Skip to content
Snippets Groups Projects
Commit d8c292a0 authored by Sergi Hernandez's avatar Sergi Hernandez
Browse files

Added an implementation of a serial port with a pin remap for the F1 family.

Added an implementation of  aserial port for the F3 family.
parent fac9bbcf
No related branches found
No related tags found
No related merge requests found
#include "usart1.h"
#define USART USART1
#define USART_ENABLE_CLK __HAL_RCC_USART1_CLK_ENABLE()
#define USART_IRQn USART1_IRQn
#define USART_IRQHandler USART1_IRQHandler
#define USART_TX_PIN GPIO_PIN_6
#define USART_TX_GPIO_PORT GPIOB
#define USART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
#define USART_RX_PIN GPIO_PIN_7
#define USART_RX_GPIO_PORT GPIOB
#define USART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
/* DMA configuration */
#define USART_DMA DMA1
#define USART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
#define USART_TX_DMA_CHANNEL DMA1_Channel4
#define USART_RX_DMA_CHANNEL DMA1_Channel5
#define USART_DMA_TX_IRQn DMA1_Channel4_IRQn
#define USART_DMA_RX_IRQn DMA1_Channel5_IRQn
#define USART_DMA_TX_IRQHandler DMA1_Channel4_IRQHandler
#define USART_DMA_RX_IRQHandler DMA1_Channel5_IRQHandler
// private variables
UART_HandleTypeDef Uart1Handle;
DMA_HandleTypeDef usart1_hdma_tx;
DMA_HandleTypeDef usart1_hdma_rx;
TComm *usart1_comm_dev;
// interrupt handlers
void USART_IRQHandler(void)
{
unsigned char data,ret;
uint32_t source;
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_RXNE) != RESET)
{
if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_RXNE) !=RESET)
{
__HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_RXNE);
data=(uint8_t)(Uart1Handle.Instance->DR & (uint8_t)0x00FF);
// call the reception function
if(!comm_do_irq_receive(usart1_comm_dev,data))
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
}
}
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_TC) != RESET)
{
if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_TC) !=RESET)
{
__HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
ret=comm_do_irq_send(usart1_comm_dev,&data);
if(ret==0x01)
Uart1Handle.Instance->DR=data;
else if(ret==0x00)
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_TC);
}
}
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_PE) != RESET)// parity error
{
if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_PE) !=RESET)
{
__HAL_UART_CLEAR_PEFLAG(&Uart1Handle);
}
}
source=__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_ERR);
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_FE) != RESET)// frame error
{
if(source !=RESET)
{
__HAL_UART_CLEAR_FEFLAG(&Uart1Handle);
}
}
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_NE) != RESET)// noise error
{
if(source !=RESET)
{
__HAL_UART_CLEAR_NEFLAG(&Uart1Handle);
}
}
if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_ORE) != RESET)// overrun error
{
if(source !=RESET)
{
__HAL_UART_CLEAR_OREFLAG(&Uart1Handle);
}
}
}
void USART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_TE) != RESET)
{
/* Disable the transfer error interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_TE);
/* Clear the transfer error flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmatx));
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx,__HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_TC) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmatx));
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmatx);
// call the user function
comm_do_dma_send(usart1_comm_dev);
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_HT) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_HT);
/* Clear the half transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmatx));
}
}
}
void USART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_TE) != RESET)
{
/* Disable the transfer error interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_TE);
/* Clear the transfer error flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmarx));
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx,__HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_TC) != RESET)
{
/* Disable the transfer complete interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmarx));
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmarx);
// call the user function
comm_do_dma_receive(usart1_comm_dev);
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_HT) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_HT);
/* Clear the half transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmarx));
}
}
}
/* public functions*/
void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
USART_ENABLE_TX_GPIO_CLK;
USART_ENABLE_RX_GPIO_CLK;
USART_ENABLE_DMA_CLK;
// configure the GPIO pins
USART_ENABLE_CLK;
/* Configure USART Tx and Rx as alternate function push-pull */
GPIO_InitStructure.Pin = USART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Pin = USART_RX_PIN;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
__HAL_AFIO_REMAP_USART1_ENABLE();
Uart1Handle.Instance = USART;
usart1_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
usart1_hdma_tx.Instance = USART_TX_DMA_CHANNEL;
usart1_hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
usart1_hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
usart1_hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
usart1_hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
usart1_hdma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
usart1_hdma_tx.Init.Mode = DMA_NORMAL;
usart1_hdma_tx.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_Init(&usart1_hdma_tx);
/* Associate the initialized DMA handle to the UART handle */
__HAL_LINKDMA(&Uart1Handle, hdmatx, usart1_hdma_tx);
/* Configure the DMA handler for reception process */
usart1_hdma_rx.Instance = USART_RX_DMA_CHANNEL;
usart1_hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
usart1_hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
usart1_hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
usart1_hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
usart1_hdma_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
usart1_hdma_rx.Init.Mode = DMA_NORMAL;
usart1_hdma_rx.Init.Priority = DMA_PRIORITY_HIGH;
HAL_DMA_Init(&usart1_hdma_rx);
/* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&Uart1Handle, hdmarx, usart1_hdma_rx);
}
usart1_set_priorities(comm_dev,priorities);
/* Initialize the comm structure */
comm_dev->send_irq=usart1_send_irq;
comm_dev->enable_tx_irq=usart1_enable_tx_irq;
comm_dev->receive_irq=usart1_receive_irq;
comm_dev->cancel_receive_irq=usart1_cancel_receive_irq;
if(comm_dev->use_dma)
{
comm_dev->send_dma=usart1_send_dma;
comm_dev->receive_dma=usart1_receive_dma;
comm_dev->cancel_receive_dma=usart1_cancel_receive_dma;
}
comm_dev->irq_send_cb=0x00000000;
comm_dev->irq_receive_cb=0x00000000;
comm_dev->dma_send_cb=0x00000000;
comm_dev->dma_receive_cb=0x00000000;
/* initialize internal variables */
usart1_comm_dev=comm_dev;
}
void usart1_config(TComm *comm_dev,UART_InitTypeDef *conf)
{
Uart1Handle.Init.BaudRate = conf->BaudRate;
Uart1Handle.Init.WordLength = conf->WordLength;
Uart1Handle.Init.StopBits = conf->StopBits;
Uart1Handle.Init.Parity = conf->Parity;
Uart1Handle.Init.Mode = conf->Mode;
Uart1Handle.Init.HwFlowCtl = conf->HwFlowCtl;
Uart1Handle.Init.OverSampling = conf->OverSampling;
HAL_UART_Init(&Uart1Handle);
}
void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
{
HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
HAL_NVIC_EnableIRQ(USART_IRQn);
if(comm_dev->use_dma)
{
HAL_NVIC_SetPriority(USART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
HAL_NVIC_EnableIRQ(USART_DMA_TX_IRQn);
HAL_NVIC_SetPriority(USART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
HAL_NVIC_EnableIRQ(USART_DMA_RX_IRQn);
}
}
/* IRQ functions */
unsigned char usart1_send_irq(unsigned char first_byte)
{
__HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
Uart1Handle.Instance->DR=first_byte;
return 0x00;
}
unsigned char usart1_enable_tx_irq(void)
{
__HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
return 0x00;
}
unsigned char usart1_receive_irq(void)
{
/* enable the rx interrupt */
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
unsigned char usart1_cancel_receive_irq(void)
{
/* disable the rx interrupt */
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
/* DMA functions */
unsigned char usart1_send_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart1Handle.hdmatx,(uint32_t)data,(uint32_t)&Uart1Handle.Instance->DR,length);
/* Clear the TC flag in the SR register by writing 0 to it */
__HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
in the UART CR3 register */
SET_BIT(Uart1Handle.Instance->CR3, USART_CR3_DMAT);
return 0x00;
}
unsigned char usart1_receive_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart1Handle.hdmarx,(uint32_t)&Uart1Handle.Instance->DR,(uint32_t)data,length);
SET_BIT(Uart1Handle.Instance->CR3, USART_CR3_DMAR);
return 0x00;
}
unsigned char usart1_cancel_receive_dma(void)
{
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmarx);
return 0x00;
}
#ifndef USART1_F3_H
#define USART1_F3_H
#include "stm32f3xx_hal.h"
#include "usart_common.h"
#include "comm.h"
/* public functions */
void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
void usart1_config(TComm *comm_dev,UART_InitTypeDef *conf);
void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities);
/* IRQ functions */
unsigned char usart1_send_irq(unsigned char first_byte);
unsigned char usart1_enable_tx_irq(void);
unsigned char usart1_receive_irq(void);
unsigned char usart1_cancel_receive_irq(void);
/* DMA functions */
unsigned char usart1_send_dma(unsigned char *data,unsigned short int length);
unsigned char usart1_receive_dma(unsigned char *data,unsigned short int length);
unsigned char usart1_cancel_receive_dma(void);
#endif
#ifndef USART_COMMON_F3_H
#define USART_COMMON_F3_H
typedef struct
{
unsigned char irq_priority;
unsigned char irq_subpriority;
unsigned char dma_rx_priority;
unsigned char dma_rx_subpriority;
unsigned char dma_tx_priority;
unsigned char dma_tx_subpriority;
}TUSART_IRQ_Priorities;
#endif
#include "usart1.h"
#define USART USART1
#define USART_ENABLE_CLK __USART1_CLK_ENABLE()
#define USART_IRQn USART1_IRQn
#define USART_IRQHandler USART1_IRQHandler
#define USART_TX_PIN GPIO_PIN_4
#define USART_TX_GPIO_PORT GPIOC
#define USART_ENABLE_TX_GPIO_CLK __GPIOC_CLK_ENABLE()
#define USART_RX_PIN GPIO_PIN_5
#define USART_RX_GPIO_PORT GPIOC
#define USART_ENABLE_RX_GPIO_CLK __GPIOC_CLK_ENABLE()
/* DMA configuration */
#define USART_DMA DMA1
#define USART_ENABLE_DMA_CLK __DMA1_CLK_ENABLE()
#define USART_TX_DMA_CHANNEL DMA1_Channel4
#define USART_RX_DMA_CHANNEL DMA1_Channel5
#define USART_DMA_TX_IRQn DMA1_Channel4_IRQn
#define USART_DMA_RX_IRQn DMA1_Channel5_IRQn
#define USART_DMA_TX_IRQHandler DMA1_Channel4_IRQHandler
#define USART_DMA_RX_IRQHandler DMA1_Channel5_IRQHandler
// private variables
UART_HandleTypeDef Uart1Handle;
DMA_HandleTypeDef usart1_hdma_tx;
DMA_HandleTypeDef usart1_hdma_rx;
TComm *usart1_comm_dev;
// interrupt handlers
void USART_IRQHandler(void)
{
unsigned char data,ret;
/* USART parity error interrupt occured ------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_PE) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_PE) != RESET)
{
__HAL_USART_CLEAR_IT(&Uart1Handle, USART_IT_PE);
}
}
/* USART frame error interrupt occured -------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_FE) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_ERR) != RESET)
{
__HAL_USART_CLEAR_IT(&Uart1Handle, USART_IT_FE);
}
}
/* USART noise error interrupt occured -------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_NE) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_ERR) != RESET)
{
__HAL_USART_CLEAR_IT(&Uart1Handle, USART_IT_NE);
}
}
/* USART Over-Run interrupt occured ----------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_ORE) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_ERR) != RESET)
{
__HAL_USART_CLEAR_IT(&Uart1Handle, USART_IT_ORE);
}
}
/* USART in mode Receiver --------------------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_RXNE) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_RXNE) != RESET)
{
__HAL_USART_CLEAR_IT(&Uart1Handle, USART_IT_RXNE);
data=(uint8_t)(Uart1Handle.Instance->RDR & (uint8_t)0x00FF);
// call the reception function
if(!comm_do_irq_receive(usart1_comm_dev,data))
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
}
}
/* USART in mode Transmitter -----------------------------------------------*/
if(__HAL_USART_GET_IT(&Uart1Handle, USART_IT_TC) != RESET)
{
if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_TC) != RESET)
{
__HAL_UART_CLEAR_IT(&Uart1Handle,UART_IT_TC);
ret=comm_do_irq_send(usart1_comm_dev,&data);
if(ret==0x01)
Uart1Handle.Instance->TDR=data;
else if(ret==0x00)
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_TC);
}
}
}
void USART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_TE) != RESET)
{
/* Disable the transfer error interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_TE);
/* Clear the transfer error flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmatx));
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx,__HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_TC) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmatx));
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmatx);
// call the user function
comm_do_dma_send(usart1_comm_dev);
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmatx, DMA_IT_HT) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmatx, DMA_IT_HT);
/* Clear the half transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmatx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmatx));
}
}
}
void USART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_TE) != RESET)
{
/* Disable the transfer error interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_TE);
/* Clear the transfer error flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmarx));
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx,__HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_TC) != RESET)
{
/* Disable the transfer complete interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart1Handle.hdmarx));
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmarx);
// call the user function
comm_do_dma_receive(usart1_comm_dev);
}
}
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
if(__HAL_DMA_GET_IT_SOURCE(Uart1Handle.hdmarx, DMA_IT_HT) != RESET)
{
/* Disable the half transfer interrupt */
__HAL_DMA_DISABLE_IT(Uart1Handle.hdmarx, DMA_IT_HT);
/* Clear the half transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart1Handle.hdmarx, __HAL_DMA_GET_HT_FLAG_INDEX(Uart1Handle.hdmarx));
}
}
}
/* public functions*/
void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
USART_ENABLE_TX_GPIO_CLK;
USART_ENABLE_RX_GPIO_CLK;
USART_ENABLE_DMA_CLK;
// configure the GPIO pins
/* Configure USART Tx and Rx as alternate function push-pull */
GPIO_InitStructure.Pin = USART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
GPIO_InitStructure.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Pin = USART_RX_PIN;
HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
USART_ENABLE_CLK;
Uart1Handle.Instance = USART;
usart1_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
usart1_hdma_tx.Instance = USART_TX_DMA_CHANNEL;
usart1_hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
usart1_hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
usart1_hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
usart1_hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
usart1_hdma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
usart1_hdma_tx.Init.Mode = DMA_NORMAL;
usart1_hdma_tx.Init.Priority = DMA_PRIORITY_LOW;
HAL_DMA_Init(&usart1_hdma_tx);
/* Associate the initialized DMA handle to the UART handle */
__HAL_LINKDMA(&Uart1Handle, hdmatx, usart1_hdma_tx);
/* Configure the DMA handler for reception process */
usart1_hdma_rx.Instance = USART_RX_DMA_CHANNEL;
usart1_hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
usart1_hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
usart1_hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
usart1_hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
usart1_hdma_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
usart1_hdma_rx.Init.Mode = DMA_NORMAL;
usart1_hdma_rx.Init.Priority = DMA_PRIORITY_HIGH;
HAL_DMA_Init(&usart1_hdma_rx);
/* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&Uart1Handle, hdmarx, usart1_hdma_rx);
}
usart1_set_priorities(comm_dev,priorities);
/* Initialize the comm structure */
comm_dev->send_irq=usart1_send_irq;
comm_dev->enable_tx_irq=usart1_enable_tx_irq;
comm_dev->receive_irq=usart1_receive_irq;
comm_dev->cancel_receive_irq=usart1_cancel_receive_irq;
if(comm_dev->use_dma)
{
comm_dev->send_dma=usart1_send_dma;
comm_dev->receive_dma=usart1_receive_dma;
comm_dev->cancel_receive_dma=usart1_cancel_receive_dma;
}
comm_dev->irq_send_cb=0x00000000;
comm_dev->irq_receive_cb=0x00000000;
comm_dev->dma_send_cb=0x00000000;
comm_dev->dma_receive_cb=0x00000000;
/* initialize internal variables */
usart1_comm_dev=comm_dev;
}
void usart1_config(TComm *comm_dev,UART_InitTypeDef *conf)
{
Uart1Handle.Init.BaudRate = conf->BaudRate;
Uart1Handle.Init.WordLength = conf->WordLength;
Uart1Handle.Init.StopBits = conf->StopBits;
Uart1Handle.Init.Parity = conf->Parity;
Uart1Handle.Init.Mode = conf->Mode;
Uart1Handle.Init.HwFlowCtl = conf->HwFlowCtl;
Uart1Handle.Init.OverSampling = conf->OverSampling;
Uart1Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart1Handle);
}
void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
{
HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
HAL_NVIC_EnableIRQ(USART_IRQn);
if(comm_dev->use_dma)
{
HAL_NVIC_SetPriority(USART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
HAL_NVIC_EnableIRQ(USART_DMA_TX_IRQn);
HAL_NVIC_SetPriority(USART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
HAL_NVIC_EnableIRQ(USART_DMA_RX_IRQn);
}
}
/* IRQ functions */
unsigned char usart1_send_irq(unsigned char first_byte)
{
__HAL_UART_CLEAR_IT(&Uart1Handle,UART_IT_TC);
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
Uart1Handle.Instance->TDR=first_byte;
return 0x00;
}
unsigned char usart1_enable_tx_irq(void)
{
__HAL_UART_CLEAR_IT(&Uart1Handle,UART_IT_TC);
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
return 0x00;
}
unsigned char usart1_receive_irq(void)
{
/* enable the rx interrupt */
__HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
unsigned char usart1_cancel_receive_irq(void)
{
/* disable the rx interrupt */
__HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
/* DMA functions */
unsigned char usart1_send_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart1Handle.hdmatx,(uint32_t)data,(uint32_t)&Uart1Handle.Instance->TDR,length);
/* Clear the TC flag in the SR register by writing 0 to it */
__HAL_UART_CLEAR_IT(&Uart1Handle,UART_IT_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
in the UART CR3 register */
SET_BIT(Uart1Handle.Instance->CR3, USART_CR3_DMAT);
return 0x00;
}
unsigned char usart1_receive_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart1Handle.hdmarx,(uint32_t)&Uart1Handle.Instance->RDR,(uint32_t)data,length);
SET_BIT(Uart1Handle.Instance->CR3, USART_CR3_DMAR);
return 0x00;
}
unsigned char usart1_cancel_receive_dma(void)
{
CLEAR_BIT(Uart1Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
HAL_DMA_Abort(Uart1Handle.hdmarx);
return 0x00;
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment