diff --git a/f4/usart/include/usart1.h b/f4/usart/include/usart1.h
index 155d8502804a8c38025c5672dc0ef9dd4a9780c6..c220abc9422cdad21a67c21e63023d496bdd16a4 100644
--- a/f4/usart/include/usart1.h
+++ b/f4/usart/include/usart1.h
@@ -1,14 +1,14 @@
-#ifndef USART1_F4_H
-#define USART1_F4_H
+#ifndef UART1_F4_H
+#define UART1_F4_H
#include "stm32f4xx_hal.h"
#include "usart_common.h"
#include "comm.h"
/* public functions */
-void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
-void usart1_config(TComm *comm_dev,USART_InitTypeDef *conf);
-void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities);
+void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities);
+void usart1_config(TComm *comm_dev,UART_InitTypeDef *conf);
+void usart1_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities);
void usart1_set_baudrate(TComm *comm_dev,unsigned int baudrate);
/* IRQ functions */
unsigned char usart1_send_irq(unsigned char first_byte);
diff --git a/f4/usart/include/usart2.h b/f4/usart/include/usart2.h
index 97a280603ba9b14d6b6653a5a93b2ab0bb9ce5f9..5ce337b90441237d310b87542343e6cd0c9678a3 100644
--- a/f4/usart/include/usart2.h
+++ b/f4/usart/include/usart2.h
@@ -1,14 +1,14 @@
-#ifndef USART2_F4_H
-#define USART2_F4_H
+#ifndef UART2_F4_H
+#define UART2_F4_H
#include "stm32f4xx_hal.h"
#include "usart_common.h"
#include "comm.h"
/* public functions */
-void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
-void usart2_config(TComm *comm_dev,USART_InitTypeDef *conf);
-void usart2_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities);
+void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities);
+void usart2_config(TComm *comm_dev,UART_InitTypeDef *conf);
+void usart2_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities);
void usart2_set_baudrate(TComm *comm_dev,unsigned int baudrate);
/* IRQ functions */
unsigned char usart2_send_irq(unsigned char first_byte);
diff --git a/f4/usart/include/usart3.h b/f4/usart/include/usart3.h
index 09202c886ebc09ae575d86c756df8ced2ad3346b..cef7e32149e1ff6d92043942a7f26e33417634b5 100644
--- a/f4/usart/include/usart3.h
+++ b/f4/usart/include/usart3.h
@@ -1,14 +1,14 @@
-#ifndef USART3_F4_H
-#define USART3_F4_H
+#ifndef UART3_F4_H
+#define UART3_F4_H
#include "stm32f4xx_hal.h"
#include "usart_common.h"
#include "comm.h"
/* public functions */
-void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
-void usart3_config(TComm *comm_dev,USART_InitTypeDef *conf);
-void usart3_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities);
+void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities);
+void usart3_config(TComm *comm_dev,UART_InitTypeDef *conf);
+void usart3_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities);
void usart3_set_baudrate(TComm *comm_dev,unsigned int baudrate);
/* IRQ functions */
unsigned char usart3_send_irq(unsigned char first_byte);
diff --git a/f4/usart/include/usart4.h b/f4/usart/include/usart4.h
index 21370af9e17c4e1b78906f7fc36a4eb63a3f16c4..6367a1ec3922073787417357e692f32206f398f6 100644
--- a/f4/usart/include/usart4.h
+++ b/f4/usart/include/usart4.h
@@ -1,14 +1,14 @@
-#ifndef USART4_F4_H
-#define USART4_F4_H
+#ifndef UART4_F4_H
+#define UART4_F4_H
#include "stm32f4xx_hal.h"
#include "usart_common.h"
#include "comm.h"
/* public functions */
-void usart4_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
+void usart4_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities);
void usart4_config(TComm *comm_dev,UART_InitTypeDef *conf);
-void usart4_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities);
+void usart4_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities);
void usart4_set_baudrate(TComm *comm_dev,unsigned int baudrate);
/* IRQ functions */
unsigned char usart4_send_irq(unsigned char first_byte);
diff --git a/f4/usart/include/usart_common.h b/f4/usart/include/usart_common.h
index 3e1148cef26ab1991285908be9bec2b42597eb0f..ab2ac42dfc39e5befcd91f9707f2b47e61c52a5e 100644
--- a/f4/usart/include/usart_common.h
+++ b/f4/usart/include/usart_common.h
@@ -1,5 +1,5 @@
-#ifndef USART_COMMON_F4_H
-#define USART_COMMON_F4_H
+#ifndef UART_COMMON_F4_H
+#define UART_COMMON_F4_H
typedef struct
{
@@ -9,6 +9,6 @@ typedef struct
unsigned char dma_rx_subpriority;
unsigned char dma_tx_priority;
unsigned char dma_tx_subpriority;
-}TUSART_IRQ_Priorities;
+}TUART_IRQ_Priorities;
#endif
diff --git a/f4/usart/src/usart1.c b/f4/usart/src/usart1.c
index b16bb5e8036173acf041b51fbe7cb7669d4434e3..f288027322a9e2c8b3c1ba56b10f59fbde6d0f50 100644
--- a/f4/usart/src/usart1.c
+++ b/f4/usart/src/usart1.c
@@ -1,97 +1,97 @@
#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 UART USART1
+#define UART_ENABLE_CLK __HAL_RCC_USART1_CLK_ENABLE()
+#define UART_IRQn USART1_IRQn
+#define UART_IRQHandler USART1_IRQHandler
-#define USART_TX_PIN GPIO_PIN_9
-#define USART_TX_GPIO_PORT GPIOA
-#define USART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
+#define UART_TX_PIN GPIO_PIN_9
+#define UART_TX_GPIO_PORT GPIOA
+#define UART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
-#define USART_RX_PIN GPIO_PIN_10
-#define USART_RX_GPIO_PORT GPIOA
-#define USART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
+#define UART_RX_PIN GPIO_PIN_10
+#define UART_RX_GPIO_PORT GPIOA
+#define UART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
/* DMA configuration */
-#define USART_DMA_CHANNEL DMA_CHANNEL_4
-#define USART_ENABLE_DMA_CLK __HAL_RCC_DMA2_CLK_ENABLE()
+#define UART_DMA_CHANNEL DMA_CHANNEL_4
+#define UART_ENABLE_DMA_CLK __HAL_RCC_DMA2_CLK_ENABLE()
-#define USART_TX_DMA_STREAM DMA2_Stream7
-#define USART_RX_DMA_STREAM DMA2_Stream2
+#define UART_TX_DMA_STREAM DMA2_Stream7
+#define UART_RX_DMA_STREAM DMA2_Stream2
-#define USART_DMA_TX_IRQn DMA2_Stream7_IRQn
-#define USART_DMA_RX_IRQn DMA2_Stream2_IRQn
-#define USART_DMA_TX_IRQHandler DMA2_Stream7_IRQHandler
-#define USART_DMA_RX_IRQHandler DMA2_Stream2_IRQHandler
+#define UART_DMA_TX_IRQn DMA2_Stream7_IRQn
+#define UART_DMA_RX_IRQn DMA2_Stream2_IRQn
+#define UART_DMA_TX_IRQHandler DMA2_Stream7_IRQHandler
+#define UART_DMA_RX_IRQHandler DMA2_Stream2_IRQHandler
// private variables
-USART_HandleTypeDef Uart1Handle;
+UART_HandleTypeDef Uart1Handle;
DMA_HandleTypeDef usart1_hdma_tx;
DMA_HandleTypeDef usart1_hdma_rx;
TComm *usart1_comm_dev;
// interrupt handlers
-void USART_IRQHandler(void)
+void UART_IRQHandler(void)
{
unsigned char data,ret;
uint32_t source;
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_RXNE) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_RXNE) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_RXNE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_RXNE) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_RXNE);
+ __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_USART_DISABLE_IT(&Uart1Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
}
}
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_TC) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_TC) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_TC) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_TC) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
+ __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_USART_DISABLE_IT(&Uart1Handle, USART_IT_TC);
+ __HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_TC);
}
}
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_PE) != RESET)// parity error
+ if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_PE) != RESET)// parity error
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_PE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_PE) !=RESET)
{
- __HAL_USART_CLEAR_PEFLAG(&Uart1Handle);
+ __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);
}
}
- source=__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_ERR);
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_FE) != RESET)// frame error
+ 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_USART_CLEAR_FEFLAG(&Uart1Handle);
+ __HAL_UART_CLEAR_FEFLAG(&Uart1Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_NE) != RESET)// noise error
+ if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_NE) != RESET)// noise error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_NEFLAG(&Uart1Handle);
+ __HAL_UART_CLEAR_NEFLAG(&Uart1Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_ORE) != RESET)// overrun error
+ if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_ORE) != RESET)// overrun error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_OREFLAG(&Uart1Handle);
+ __HAL_UART_CLEAR_OREFLAG(&Uart1Handle);
}
}
}
-void USART_DMA_TX_IRQHandler(void)
+void UART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmatx)) != RESET)
{
@@ -129,7 +129,7 @@ void USART_DMA_TX_IRQHandler(void)
}
}
-void USART_DMA_RX_IRQHandler(void)
+void UART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart1Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart1Handle.hdmarx)) != RESET)
{
@@ -168,37 +168,37 @@ void USART_DMA_RX_IRQHandler(void)
}
/* public functions*/
-void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
- USART_ENABLE_TX_GPIO_CLK;
- USART_ENABLE_RX_GPIO_CLK;
- USART_ENABLE_DMA_CLK;
+ UART_ENABLE_TX_GPIO_CLK;
+ UART_ENABLE_RX_GPIO_CLK;
+ UART_ENABLE_DMA_CLK;
// configure the GPIO pins
- /* Configure USART Tx and Rx as alternate function push-pull */
- GPIO_InitStructure.Pin = USART_TX_PIN;
+ /* Configure UART Tx and Rx as alternate function push-pull */
+ GPIO_InitStructure.Pin = UART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_LOW;
GPIO_InitStructure.Alternate = GPIO_AF7_USART1;
- HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
+ HAL_GPIO_Init(UART_TX_GPIO_PORT, &GPIO_InitStructure);
- GPIO_InitStructure.Pin = USART_RX_PIN;
- HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
+ GPIO_InitStructure.Pin = UART_RX_PIN;
+ HAL_GPIO_Init(UART_RX_GPIO_PORT, &GPIO_InitStructure);
- USART_ENABLE_CLK;
+ UART_ENABLE_CLK;
- Uart1Handle.Instance = USART;
+ Uart1Handle.Instance = UART;
usart1_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
- usart1_hdma_tx.Instance = USART_TX_DMA_STREAM;
- usart1_hdma_tx.Init.Channel = USART_DMA_CHANNEL;
+ usart1_hdma_tx.Instance = UART_TX_DMA_STREAM;
+ usart1_hdma_tx.Init.Channel = UART_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;
@@ -210,12 +210,12 @@ void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart1_hdma_tx);
- /* Associate the initialized DMA handle to the USART handle */
+ /* 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_STREAM;
- usart1_hdma_rx.Init.Channel = USART_DMA_CHANNEL;
+ usart1_hdma_rx.Instance = UART_RX_DMA_STREAM;
+ usart1_hdma_rx.Init.Channel = UART_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;
@@ -227,7 +227,7 @@ void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart1_hdma_rx);
- /* Associate the initialized DMA handle to the the USART handle */
+ /* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&Uart1Handle, hdmarx, usart1_hdma_rx);
}
usart1_set_priorities(comm_dev,priorities);
@@ -252,43 +252,43 @@ void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
usart1_comm_dev=comm_dev;
}
-void usart1_config(TComm *comm_dev,USART_InitTypeDef *conf)
+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.CLKPolarity = conf->CLKPolarity;
- Uart1Handle.Init.CLKPhase = conf->CLKPhase;
- Uart1Handle.Init.CLKLastBit = conf->CLKLastBit;
- HAL_USART_Init(&Uart1Handle);
+ 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)
+void usart1_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities)
{
- HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
- HAL_NVIC_EnableIRQ(USART_IRQn);
+ HAL_NVIC_SetPriority(UART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
+ HAL_NVIC_EnableIRQ(UART_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);
+ HAL_NVIC_SetPriority(UART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_TX_IRQn);
+ HAL_NVIC_SetPriority(UART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_RX_IRQn);
}
}
void usart1_set_baudrate(TComm *comm_dev,unsigned int baudrate)
{
Uart1Handle.Init.BaudRate = baudrate;
- HAL_USART_Init(&Uart1Handle);
+ HAL_UART_Init(&Uart1Handle);
}
/* IRQ functions */
unsigned char usart1_send_irq(unsigned char first_byte)
{
- __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
Uart1Handle.Instance->DR=first_byte;
return 0x00;
@@ -296,8 +296,8 @@ unsigned char usart1_send_irq(unsigned char first_byte)
unsigned char usart1_enable_tx_irq(void)
{
- __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
return 0x00;
}
@@ -305,7 +305,7 @@ unsigned char usart1_enable_tx_irq(void)
unsigned char usart1_receive_irq(void)
{
/* enable the rx interrupt */
- __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_RXNE);
+ __HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
@@ -313,7 +313,7 @@ unsigned char usart1_receive_irq(void)
unsigned char usart1_cancel_receive_irq(void)
{
/* disable the rx interrupt */
- __HAL_USART_DISABLE_IT(&Uart1Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
return 0x00;
}
@@ -323,9 +323,9 @@ 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_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
- in the USART CR3 register */
+ in the UART CR3 register */
SET_BIT(Uart1Handle.Instance->CR3, USART_CR3_DMAT);
return 0x00;
diff --git a/f4/usart/src/usart2.c b/f4/usart/src/usart2.c
index b2c26b6c0fab9b4e5ece7ca6fbe7280e2f44669f..f6226e2c6eadb0f2ef2c0b67c4f73ae9ee1325c4 100644
--- a/f4/usart/src/usart2.c
+++ b/f4/usart/src/usart2.c
@@ -1,97 +1,97 @@
#include "usart2.h"
-#define USART USART2
-#define USART_ENABLE_CLK __HAL_RCC_USART2_CLK_ENABLE()
-#define USART_IRQn USART2_IRQn
-#define USART_IRQHandler USART2_IRQHandler
+#define UART USART2
+#define UART_ENABLE_CLK __HAL_RCC_USART2_CLK_ENABLE()
+#define UART_IRQn USART2_IRQn
+#define UART_IRQHandler USART2_IRQHandler
-#define USART_TX_PIN GPIO_PIN_2
-#define USART_TX_GPIO_PORT GPIOA
-#define USART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
+#define UART_TX_PIN GPIO_PIN_2
+#define UART_TX_GPIO_PORT GPIOA
+#define UART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
-#define USART_RX_PIN GPIO_PIN_3
-#define USART_RX_GPIO_PORT GPIOA
-#define USART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
+#define UART_RX_PIN GPIO_PIN_3
+#define UART_RX_GPIO_PORT GPIOA
+#define UART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOA_CLK_ENABLE()
/* DMA configuration */
-#define USART_DMA_CHANNEL DMA_CHANNEL_4
-#define USART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
+#define UART_DMA_CHANNEL DMA_CHANNEL_4
+#define UART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
-#define USART_TX_DMA_STREAM DMA1_Stream6
-#define USART_RX_DMA_STREAM DMA1_Stream5
+#define UART_TX_DMA_STREAM DMA1_Stream6
+#define UART_RX_DMA_STREAM DMA1_Stream5
-#define USART_DMA_TX_IRQn DMA1_Stream6_IRQn
-#define USART_DMA_RX_IRQn DMA1_Stream5_IRQn
-#define USART_DMA_TX_IRQHandler DMA1_Stream6_IRQHandler
-#define USART_DMA_RX_IRQHandler DMA1_Stream5_IRQHandler
+#define UART_DMA_TX_IRQn DMA1_Stream6_IRQn
+#define UART_DMA_RX_IRQn DMA1_Stream5_IRQn
+#define UART_DMA_TX_IRQHandler DMA1_Stream6_IRQHandler
+#define UART_DMA_RX_IRQHandler DMA1_Stream5_IRQHandler
// private variables
-USART_HandleTypeDef Uart2Handle;
+UART_HandleTypeDef Uart2Handle;
DMA_HandleTypeDef usart2_hdma_tx;
DMA_HandleTypeDef usart2_hdma_rx;
TComm *usart2_comm_dev;
// interrupt handlers
-void USART_IRQHandler(void)
+void UART_IRQHandler(void)
{
unsigned char data,ret;
uint32_t source;
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_RXNE) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_RXNE) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_RXNE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_RXNE) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_RXNE);
+ __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_RXNE);
data=(uint8_t)(Uart2Handle.Instance->DR & (uint8_t)0x00FF);
// call the reception function
if(!comm_do_irq_receive(usart2_comm_dev,data))
- __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart2Handle, UART_IT_RXNE);
}
}
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_TC) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_TC) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_TC) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_TC) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
ret=comm_do_irq_send(usart2_comm_dev,&data);
if(ret==0x01)
Uart2Handle.Instance->DR=data;
else if(ret==0x00)
- __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_TC);
+ __HAL_UART_DISABLE_IT(&Uart2Handle, UART_IT_TC);
}
}
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_PE) != RESET)// parity error
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_PE) != RESET)// parity error
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_PE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_PE) !=RESET)
{
- __HAL_USART_CLEAR_PEFLAG(&Uart2Handle);
+ __HAL_UART_CLEAR_PEFLAG(&Uart2Handle);
}
}
- source=__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_ERR);
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_FE) != RESET)// frame error
+ source=__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_ERR);
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_FE) != RESET)// frame error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_FEFLAG(&Uart2Handle);
+ __HAL_UART_CLEAR_FEFLAG(&Uart2Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_NE) != RESET)// noise error
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_NE) != RESET)// noise error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_NEFLAG(&Uart2Handle);
+ __HAL_UART_CLEAR_NEFLAG(&Uart2Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_ORE) != RESET)// overrun error
+ if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_ORE) != RESET)// overrun error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_OREFLAG(&Uart2Handle);
+ __HAL_UART_CLEAR_OREFLAG(&Uart2Handle);
}
}
}
-void USART_DMA_TX_IRQHandler(void)
+void UART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart2Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart2Handle.hdmatx)) != RESET)
{
@@ -129,7 +129,7 @@ void USART_DMA_TX_IRQHandler(void)
}
}
-void USART_DMA_RX_IRQHandler(void)
+void UART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart2Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart2Handle.hdmarx)) != RESET)
{
@@ -168,37 +168,37 @@ void USART_DMA_RX_IRQHandler(void)
}
/* public functions*/
-void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
- USART_ENABLE_TX_GPIO_CLK;
- USART_ENABLE_RX_GPIO_CLK;
- USART_ENABLE_DMA_CLK;
+ UART_ENABLE_TX_GPIO_CLK;
+ UART_ENABLE_RX_GPIO_CLK;
+ UART_ENABLE_DMA_CLK;
// configure the GPIO pins
- /* Configure USART Tx and Rx as alternate function push-pull */
- GPIO_InitStructure.Pin = USART_TX_PIN;
+ /* Configure UART Tx and Rx as alternate function push-pull */
+ GPIO_InitStructure.Pin = UART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_LOW;
GPIO_InitStructure.Alternate = GPIO_AF7_USART2;
- HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
+ HAL_GPIO_Init(UART_TX_GPIO_PORT, &GPIO_InitStructure);
- GPIO_InitStructure.Pin = USART_RX_PIN;
- HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
+ GPIO_InitStructure.Pin = UART_RX_PIN;
+ HAL_GPIO_Init(UART_RX_GPIO_PORT, &GPIO_InitStructure);
- USART_ENABLE_CLK;
+ UART_ENABLE_CLK;
- Uart2Handle.Instance = USART;
+ Uart2Handle.Instance = UART;
usart2_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
- usart2_hdma_tx.Instance = USART_TX_DMA_STREAM;
- usart2_hdma_tx.Init.Channel = USART_DMA_CHANNEL;
+ usart2_hdma_tx.Instance = UART_TX_DMA_STREAM;
+ usart2_hdma_tx.Init.Channel = UART_DMA_CHANNEL;
usart2_hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
usart2_hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
usart2_hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
@@ -210,12 +210,12 @@ void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart2_hdma_tx);
- /* Associate the initialized DMA handle to the USART handle */
+ /* Associate the initialized DMA handle to the UART handle */
__HAL_LINKDMA(&Uart2Handle, hdmatx, usart2_hdma_tx);
/* Configure the DMA handler for reception process */
- usart2_hdma_rx.Instance = USART_RX_DMA_STREAM;
- usart2_hdma_rx.Init.Channel = USART_DMA_CHANNEL;
+ usart2_hdma_rx.Instance = UART_RX_DMA_STREAM;
+ usart2_hdma_rx.Init.Channel = UART_DMA_CHANNEL;
usart2_hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
usart2_hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
usart2_hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
@@ -227,7 +227,7 @@ void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart2_hdma_rx);
- /* Associate the initialized DMA handle to the the USART handle */
+ /* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&Uart2Handle, hdmarx, usart2_hdma_rx);
}
usart2_set_priorities(comm_dev,priorities);
@@ -252,43 +252,42 @@ void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
usart2_comm_dev=comm_dev;
}
-void usart2_config(TComm *comm_dev,USART_InitTypeDef *conf)
+void usart2_config(TComm *comm_dev,UART_InitTypeDef *conf)
{
Uart2Handle.Init.BaudRate = conf->BaudRate;
Uart2Handle.Init.WordLength = conf->WordLength;
Uart2Handle.Init.StopBits = conf->StopBits;
Uart2Handle.Init.Parity = conf->Parity;
Uart2Handle.Init.Mode = conf->Mode;
- Uart2Handle.Init.CLKPolarity = conf->CLKPolarity;
- Uart2Handle.Init.CLKPhase = conf->CLKPhase;
- Uart2Handle.Init.CLKLastBit = conf->CLKLastBit;
- HAL_USART_Init(&Uart2Handle);
+ Uart2Handle.Init.HwFlowCtl = conf->HwFlowCtl;
+ Uart2Handle.Init.OverSampling = conf->OverSampling;
+ HAL_UART_Init(&Uart2Handle);
}
-void usart2_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
+void usart2_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities)
{
- HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
- HAL_NVIC_EnableIRQ(USART_IRQn);
+ HAL_NVIC_SetPriority(UART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
+ HAL_NVIC_EnableIRQ(UART_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);
+ HAL_NVIC_SetPriority(UART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_TX_IRQn);
+ HAL_NVIC_SetPriority(UART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_RX_IRQn);
}
}
void usart2_set_baudrate(TComm *comm_dev,unsigned int baudrate)
{
Uart2Handle.Init.BaudRate = baudrate;
- HAL_USART_Init(&Uart2Handle);
+ HAL_UART_Init(&Uart2Handle);
}
/* IRQ functions */
unsigned char usart2_send_irq(unsigned char first_byte)
{
- __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_TC);
Uart2Handle.Instance->DR=first_byte;
return 0x00;
@@ -296,8 +295,8 @@ unsigned char usart2_send_irq(unsigned char first_byte)
unsigned char usart2_enable_tx_irq(void)
{
- __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_TC);
return 0x00;
}
@@ -305,7 +304,7 @@ unsigned char usart2_enable_tx_irq(void)
unsigned char usart2_receive_irq(void)
{
/* enable the rx interrupt */
- __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_RXNE);
+ __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_RXNE);
return 0x00;
}
@@ -313,7 +312,7 @@ unsigned char usart2_receive_irq(void)
unsigned char usart2_cancel_receive_irq(void)
{
/* disable the rx interrupt */
- __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart2Handle, UART_IT_RXNE);
return 0x00;
}
@@ -323,9 +322,9 @@ unsigned char usart2_send_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart2Handle.hdmatx,(uint32_t)data,(uint32_t)&Uart2Handle.Instance->DR,length);
/* Clear the TC flag in the SR register by writing 0 to it */
- __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
- in the USART CR3 register */
+ in the UART CR3 register */
SET_BIT(Uart2Handle.Instance->CR3, USART_CR3_DMAT);
return 0x00;
diff --git a/f4/usart/src/usart3.c b/f4/usart/src/usart3.c
index 2acf346216ade2742348ccd9183141e074b02005..b828ff7aa1189e82594cf557958e7c0a145d95b0 100644
--- a/f4/usart/src/usart3.c
+++ b/f4/usart/src/usart3.c
@@ -1,97 +1,97 @@
#include "usart3.h"
-#define USART USART3
-#define USART_ENABLE_CLK __HAL_RCC_USART3_CLK_ENABLE()
-#define USART_IRQn USART3_IRQn
-#define USART_IRQHandler USART3_IRQHandler
+#define UART USART3
+#define UART_ENABLE_CLK __HAL_RCC_USART3_CLK_ENABLE()
+#define UART_IRQn USART3_IRQn
+#define UART_IRQHandler USART3_IRQHandler
-#define USART_TX_PIN GPIO_PIN_10
-#define USART_TX_GPIO_PORT GPIOB
-#define USART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
+#define UART_TX_PIN GPIO_PIN_10
+#define UART_TX_GPIO_PORT GPIOB
+#define UART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
-#define USART_RX_PIN GPIO_PIN_11
-#define USART_RX_GPIO_PORT GPIOB
-#define USART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
+#define UART_RX_PIN GPIO_PIN_11
+#define UART_RX_GPIO_PORT GPIOB
+#define UART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOB_CLK_ENABLE()
/* DMA configuration */
-#define USART_DMA_CHANNEL DMA_CHANNEL_4
-#define USART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
+#define UART_DMA_CHANNEL DMA_CHANNEL_4
+#define UART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
-#define USART_TX_DMA_STREAM DMA1_Stream3
-#define USART_RX_DMA_STREAM DMA1_Stream1
+#define UART_TX_DMA_STREAM DMA1_Stream3
+#define UART_RX_DMA_STREAM DMA1_Stream1
-#define USART_DMA_TX_IRQn DMA1_Stream3_IRQn
-#define USART_DMA_RX_IRQn DMA1_Stream1_IRQn
-#define USART_DMA_TX_IRQHandler DMA1_Stream3_IRQHandler
-#define USART_DMA_RX_IRQHandler DMA1_Stream1_IRQHandler
+#define UART_DMA_TX_IRQn DMA1_Stream3_IRQn
+#define UART_DMA_RX_IRQn DMA1_Stream1_IRQn
+#define UART_DMA_TX_IRQHandler DMA1_Stream3_IRQHandler
+#define UART_DMA_RX_IRQHandler DMA1_Stream1_IRQHandler
// private variables
-USART_HandleTypeDef Uart3Handle;
+UART_HandleTypeDef Uart3Handle;
DMA_HandleTypeDef usart3_hdma_tx;
DMA_HandleTypeDef usart3_hdma_rx;
TComm *usart3_comm_dev;
// interrupt handlers
-void USART_IRQHandler(void)
+void UART_IRQHandler(void)
{
unsigned char data,ret;
uint32_t source;
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_RXNE) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_RXNE) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_RXNE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_RXNE) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_RXNE);
+ __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_RXNE);
data=(uint8_t)(Uart3Handle.Instance->DR & (uint8_t)0x00FF);
// call the reception function
if(!comm_do_irq_receive(usart3_comm_dev,data))
- __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart3Handle, UART_IT_RXNE);
}
}
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_TC) != RESET)
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_TC) != RESET)
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_TC) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_TC) !=RESET)
{
- __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
ret=comm_do_irq_send(usart3_comm_dev,&data);
if(ret==0x01)
Uart3Handle.Instance->DR=data;
else if(ret==0x00)
- __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_TC);
+ __HAL_UART_DISABLE_IT(&Uart3Handle, UART_IT_TC);
}
}
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_PE) != RESET)// parity error
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_PE) != RESET)// parity error
{
- if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_PE) !=RESET)
+ if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_PE) !=RESET)
{
- __HAL_USART_CLEAR_PEFLAG(&Uart3Handle);
+ __HAL_UART_CLEAR_PEFLAG(&Uart3Handle);
}
}
- source=__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_ERR);
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_FE) != RESET)// frame error
+ source=__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_ERR);
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_FE) != RESET)// frame error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_FEFLAG(&Uart3Handle);
+ __HAL_UART_CLEAR_FEFLAG(&Uart3Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_NE) != RESET)// noise error
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_NE) != RESET)// noise error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_NEFLAG(&Uart3Handle);
+ __HAL_UART_CLEAR_NEFLAG(&Uart3Handle);
}
}
- if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_ORE) != RESET)// overrun error
+ if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_ORE) != RESET)// overrun error
{
if(source !=RESET)
{
- __HAL_USART_CLEAR_OREFLAG(&Uart3Handle);
+ __HAL_UART_CLEAR_OREFLAG(&Uart3Handle);
}
}
}
-void USART_DMA_TX_IRQHandler(void)
+void UART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart3Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart3Handle.hdmatx)) != RESET)
{
@@ -129,7 +129,7 @@ void USART_DMA_TX_IRQHandler(void)
}
}
-void USART_DMA_RX_IRQHandler(void)
+void UART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart3Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart3Handle.hdmarx)) != RESET)
{
@@ -168,37 +168,37 @@ void USART_DMA_RX_IRQHandler(void)
}
/* public functions*/
-void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
- USART_ENABLE_TX_GPIO_CLK;
- USART_ENABLE_RX_GPIO_CLK;
- USART_ENABLE_DMA_CLK;
+ UART_ENABLE_TX_GPIO_CLK;
+ UART_ENABLE_RX_GPIO_CLK;
+ UART_ENABLE_DMA_CLK;
// configure the GPIO pins
- /* Configure USART Tx and Rx as alternate function push-pull */
- GPIO_InitStructure.Pin = USART_TX_PIN;
+ /* Configure UART Tx and Rx as alternate function push-pull */
+ GPIO_InitStructure.Pin = UART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_LOW;
GPIO_InitStructure.Alternate = GPIO_AF7_USART3;
- HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
+ HAL_GPIO_Init(UART_TX_GPIO_PORT, &GPIO_InitStructure);
- GPIO_InitStructure.Pin = USART_RX_PIN;
- HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
+ GPIO_InitStructure.Pin = UART_RX_PIN;
+ HAL_GPIO_Init(UART_RX_GPIO_PORT, &GPIO_InitStructure);
- USART_ENABLE_CLK;
+ UART_ENABLE_CLK;
- Uart3Handle.Instance = USART;
+ Uart3Handle.Instance = UART;
usart3_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
- usart3_hdma_tx.Instance = USART_TX_DMA_STREAM;
- usart3_hdma_tx.Init.Channel = USART_DMA_CHANNEL;
+ usart3_hdma_tx.Instance = UART_TX_DMA_STREAM;
+ usart3_hdma_tx.Init.Channel = UART_DMA_CHANNEL;
usart3_hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
usart3_hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
usart3_hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
@@ -210,12 +210,12 @@ void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart3_hdma_tx);
- /* Associate the initialized DMA handle to the USART handle */
+ /* Associate the initialized DMA handle to the UART handle */
__HAL_LINKDMA(&Uart3Handle, hdmatx, usart3_hdma_tx);
/* Configure the DMA handler for reception process */
- usart3_hdma_rx.Instance = USART_RX_DMA_STREAM;
- usart3_hdma_rx.Init.Channel = USART_DMA_CHANNEL;
+ usart3_hdma_rx.Instance = UART_RX_DMA_STREAM;
+ usart3_hdma_rx.Init.Channel = UART_DMA_CHANNEL;
usart3_hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
usart3_hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
usart3_hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
@@ -227,7 +227,7 @@ void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
HAL_DMA_Init(&usart3_hdma_rx);
- /* Associate the initialized DMA handle to the the USART handle */
+ /* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&Uart3Handle, hdmarx, usart3_hdma_rx);
}
usart3_set_priorities(comm_dev,priorities);
@@ -252,43 +252,42 @@ void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *
usart3_comm_dev=comm_dev;
}
-void usart3_config(TComm *comm_dev,USART_InitTypeDef *conf)
+void usart3_config(TComm *comm_dev,UART_InitTypeDef *conf)
{
Uart3Handle.Init.BaudRate = conf->BaudRate;
Uart3Handle.Init.WordLength = conf->WordLength;
Uart3Handle.Init.StopBits = conf->StopBits;
Uart3Handle.Init.Parity = conf->Parity;
Uart3Handle.Init.Mode = conf->Mode;
- Uart3Handle.Init.CLKPolarity = conf->CLKPolarity;
- Uart3Handle.Init.CLKPhase = conf->CLKPhase;
- Uart3Handle.Init.CLKLastBit = conf->CLKLastBit;
- HAL_USART_Init(&Uart3Handle);
+ Uart3Handle.Init.HwFlowCtl = conf->HwFlowCtl;
+ Uart3Handle.Init.OverSampling = conf->OverSampling;
+ HAL_UART_Init(&Uart3Handle);
}
-void usart3_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
+void usart3_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities)
{
- HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
- HAL_NVIC_EnableIRQ(USART_IRQn);
+ HAL_NVIC_SetPriority(UART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
+ HAL_NVIC_EnableIRQ(UART_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);
+ HAL_NVIC_SetPriority(UART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_TX_IRQn);
+ HAL_NVIC_SetPriority(UART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_RX_IRQn);
}
}
void usart3_set_baudrate(TComm *comm_dev,unsigned int baudrate)
{
Uart3Handle.Init.BaudRate = baudrate;
- HAL_USART_Init(&Uart3Handle);
+ HAL_UART_Init(&Uart3Handle);
}
/* IRQ functions */
unsigned char usart3_send_irq(unsigned char first_byte)
{
- __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_TC);
Uart3Handle.Instance->DR=first_byte;
return 0x00;
@@ -296,8 +295,8 @@ unsigned char usart3_send_irq(unsigned char first_byte)
unsigned char usart3_enable_tx_irq(void)
{
- __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
- __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
+ __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_TC);
return 0x00;
}
@@ -305,7 +304,7 @@ unsigned char usart3_enable_tx_irq(void)
unsigned char usart3_receive_irq(void)
{
/* enable the rx interrupt */
- __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_RXNE);
+ __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_RXNE);
return 0x00;
}
@@ -313,7 +312,7 @@ unsigned char usart3_receive_irq(void)
unsigned char usart3_cancel_receive_irq(void)
{
/* disable the rx interrupt */
- __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_RXNE);
+ __HAL_UART_DISABLE_IT(&Uart3Handle, UART_IT_RXNE);
return 0x00;
}
@@ -323,9 +322,9 @@ unsigned char usart3_send_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart3Handle.hdmatx,(uint32_t)data,(uint32_t)&Uart3Handle.Instance->DR,length);
/* Clear the TC flag in the SR register by writing 0 to it */
- __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
+ __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
- in the USART CR3 register */
+ in the UART CR3 register */
SET_BIT(Uart3Handle.Instance->CR3, USART_CR3_DMAT);
return 0x00;
diff --git a/f4/usart/src/usart4.c b/f4/usart/src/usart4.c
index 12413be95528c422f84d7de56fee0f3852b3b90a..93d59baf8aaef7f937019367ad31bc1dd2e0161e 100644
--- a/f4/usart/src/usart4.c
+++ b/f4/usart/src/usart4.c
@@ -1,29 +1,29 @@
#include "usart4.h"
-#define USART UART4
-#define USART_ENABLE_CLK __HAL_RCC_UART4_CLK_ENABLE()
-#define USART_IRQn UART4_IRQn
-#define USART_IRQHandler UART4_IRQHandler
+#define UART UART4
+#define UART_ENABLE_CLK __HAL_RCC_UART4_CLK_ENABLE()
+#define UART_IRQn UART4_IRQn
+#define UART_IRQHandler UART4_IRQHandler
-#define USART_TX_PIN GPIO_PIN_10
-#define USART_TX_GPIO_PORT GPIOC
-#define USART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOC_CLK_ENABLE()
+#define UART_TX_PIN GPIO_PIN_10
+#define UART_TX_GPIO_PORT GPIOC
+#define UART_ENABLE_TX_GPIO_CLK __HAL_RCC_GPIOC_CLK_ENABLE()
-#define USART_RX_PIN GPIO_PIN_11
-#define USART_RX_GPIO_PORT GPIOC
-#define USART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOC_CLK_ENABLE()
+#define UART_RX_PIN GPIO_PIN_11
+#define UART_RX_GPIO_PORT GPIOC
+#define UART_ENABLE_RX_GPIO_CLK __HAL_RCC_GPIOC_CLK_ENABLE()
/* DMA configuration */
-#define USART_DMA_CHANNEL DMA_CHANNEL_4
-#define USART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
+#define UART_DMA_CHANNEL DMA_CHANNEL_4
+#define UART_ENABLE_DMA_CLK __HAL_RCC_DMA1_CLK_ENABLE()
-#define USART_TX_DMA_STREAM DMA1_Stream4
-#define USART_RX_DMA_STREAM DMA1_Stream2
+#define UART_TX_DMA_STREAM DMA1_Stream4
+#define UART_RX_DMA_STREAM DMA1_Stream2
-#define USART_DMA_TX_IRQn DMA1_Stream4_IRQn
-#define USART_DMA_RX_IRQn DMA1_Stream2_IRQn
-#define USART_DMA_TX_IRQHandler DMA1_Stream4_IRQHandler
-#define USART_DMA_RX_IRQHandler DMA1_Stream2_IRQHandler
+#define UART_DMA_TX_IRQn DMA1_Stream4_IRQn
+#define UART_DMA_RX_IRQn DMA1_Stream2_IRQn
+#define UART_DMA_TX_IRQHandler DMA1_Stream4_IRQHandler
+#define UART_DMA_RX_IRQHandler DMA1_Stream2_IRQHandler
// private variables
UART_HandleTypeDef Uart4Handle;
@@ -32,7 +32,7 @@ DMA_HandleTypeDef usart4_hdma_rx;
TComm *usart4_comm_dev;
// interrupt handlers
-void USART_IRQHandler(void)
+void UART_IRQHandler(void)
{
unsigned char data,ret;
uint32_t source;
@@ -91,7 +91,7 @@ void USART_IRQHandler(void)
}
}
-void USART_DMA_TX_IRQHandler(void)
+void UART_DMA_TX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart4Handle.hdmatx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart4Handle.hdmatx)) != RESET)
{
@@ -111,7 +111,7 @@ void USART_DMA_TX_IRQHandler(void)
__HAL_DMA_DISABLE_IT(Uart4Handle.hdmatx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart4Handle.hdmatx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart4Handle.hdmatx));
- CLEAR_BIT(Uart4Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
+ CLEAR_BIT(Uart4Handle.Instance->CR3, (UART_CR3_DMAT | UART_CR3_DMAR));
HAL_DMA_Abort(Uart4Handle.hdmatx);
// call the user function
comm_do_dma_send(usart4_comm_dev);
@@ -129,7 +129,7 @@ void USART_DMA_TX_IRQHandler(void)
}
}
-void USART_DMA_RX_IRQHandler(void)
+void UART_DMA_RX_IRQHandler(void)
{
if(__HAL_DMA_GET_FLAG(Uart4Handle.hdmarx,__HAL_DMA_GET_TE_FLAG_INDEX(Uart4Handle.hdmarx)) != RESET)
{
@@ -149,7 +149,7 @@ void USART_DMA_RX_IRQHandler(void)
__HAL_DMA_DISABLE_IT(Uart4Handle.hdmarx, DMA_IT_TC);
/* Clear the transfer complete flag */
__HAL_DMA_CLEAR_FLAG(Uart4Handle.hdmarx, __HAL_DMA_GET_TC_FLAG_INDEX(Uart4Handle.hdmarx));
- CLEAR_BIT(Uart4Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
+ CLEAR_BIT(Uart4Handle.Instance->CR3, (UART_CR3_DMAT | UART_CR3_DMAR));
HAL_DMA_Abort(Uart4Handle.hdmarx);
// call the user function
comm_do_dma_receive(usart4_comm_dev);
@@ -168,37 +168,37 @@ void USART_DMA_RX_IRQHandler(void)
}
/* public functions*/
-void usart4_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart4_init(TComm *comm_dev,UART_InitTypeDef *conf,TUART_IRQ_Priorities *priorities)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
- USART_ENABLE_TX_GPIO_CLK;
- USART_ENABLE_RX_GPIO_CLK;
- USART_ENABLE_DMA_CLK;
+ UART_ENABLE_TX_GPIO_CLK;
+ UART_ENABLE_RX_GPIO_CLK;
+ UART_ENABLE_DMA_CLK;
// configure the GPIO pins
- /* Configure USART Tx and Rx as alternate function push-pull */
- GPIO_InitStructure.Pin = USART_TX_PIN;
+ /* Configure UART Tx and Rx as alternate function push-pull */
+ GPIO_InitStructure.Pin = UART_TX_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Pull = GPIO_PULLUP;
GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStructure.Alternate = GPIO_AF8_UART4;
- HAL_GPIO_Init(USART_TX_GPIO_PORT, &GPIO_InitStructure);
+ HAL_GPIO_Init(UART_TX_GPIO_PORT, &GPIO_InitStructure);
- GPIO_InitStructure.Pin = USART_RX_PIN;
- HAL_GPIO_Init(USART_RX_GPIO_PORT, &GPIO_InitStructure);
+ GPIO_InitStructure.Pin = UART_RX_PIN;
+ HAL_GPIO_Init(UART_RX_GPIO_PORT, &GPIO_InitStructure);
- USART_ENABLE_CLK;
+ UART_ENABLE_CLK;
- Uart4Handle.Instance = USART;
+ Uart4Handle.Instance = UART;
usart4_config(comm_dev,conf);
if(comm_dev->use_dma)
{
// configure the DMA channels
- usart4_hdma_tx.Instance = USART_TX_DMA_STREAM;
- usart4_hdma_tx.Init.Channel = USART_DMA_CHANNEL;
+ usart4_hdma_tx.Instance = UART_TX_DMA_STREAM;
+ usart4_hdma_tx.Init.Channel = UART_DMA_CHANNEL;
usart4_hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
usart4_hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
usart4_hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
@@ -214,8 +214,8 @@ void usart4_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
__HAL_LINKDMA(&Uart4Handle, hdmatx, usart4_hdma_tx);
/* Configure the DMA handler for reception process */
- usart4_hdma_rx.Instance = USART_RX_DMA_STREAM;
- usart4_hdma_rx.Init.Channel = USART_DMA_CHANNEL;
+ usart4_hdma_rx.Instance = UART_RX_DMA_STREAM;
+ usart4_hdma_rx.Init.Channel = UART_DMA_CHANNEL;
usart4_hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
usart4_hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
usart4_hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
@@ -264,16 +264,16 @@ void usart4_config(TComm *comm_dev,UART_InitTypeDef *conf)
HAL_UART_Init(&Uart4Handle);
}
-void usart4_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
+void usart4_set_priorities(TComm *comm_dev,TUART_IRQ_Priorities *priorities)
{
- HAL_NVIC_SetPriority(USART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
- HAL_NVIC_EnableIRQ(USART_IRQn);
+ HAL_NVIC_SetPriority(UART_IRQn, priorities->irq_priority,priorities->irq_subpriority);
+ HAL_NVIC_EnableIRQ(UART_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);
+ HAL_NVIC_SetPriority(UART_DMA_TX_IRQn, priorities->dma_tx_priority,priorities->dma_tx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_TX_IRQn);
+ HAL_NVIC_SetPriority(UART_DMA_RX_IRQn, priorities->dma_rx_priority,priorities->dma_rx_subpriority);
+ HAL_NVIC_EnableIRQ(UART_DMA_RX_IRQn);
}
}
@@ -325,7 +325,7 @@ unsigned char usart4_send_dma(unsigned char *data,unsigned short int length)
__HAL_UART_CLEAR_FLAG(&Uart4Handle,UART_FLAG_TC);
/* Enable the DMA transfer for transmit request by setting the DMAT bit
in the UART CR3 register */
- SET_BIT(Uart4Handle.Instance->CR3, USART_CR3_DMAT);
+ SET_BIT(Uart4Handle.Instance->CR3, UART_CR3_DMAT);
return 0x00;
}
@@ -333,14 +333,14 @@ unsigned char usart4_send_dma(unsigned char *data,unsigned short int length)
unsigned char usart4_receive_dma(unsigned char *data,unsigned short int length)
{
HAL_DMA_Start_IT(Uart4Handle.hdmarx,(uint32_t)&Uart4Handle.Instance->DR,(uint32_t)data,length);
- SET_BIT(Uart4Handle.Instance->CR3, USART_CR3_DMAR);
+ SET_BIT(Uart4Handle.Instance->CR3, UART_CR3_DMAR);
return 0x00;
}
unsigned char usart4_cancel_receive_dma(void)
{
- CLEAR_BIT(Uart4Handle.Instance->CR3, (USART_CR3_DMAT | USART_CR3_DMAR));
+ CLEAR_BIT(Uart4Handle.Instance->CR3, (UART_CR3_DMAT | UART_CR3_DMAR));
HAL_DMA_Abort(Uart4Handle.hdmarx);
return 0x00;