diff --git a/f4/usart/include/usart1.h b/f4/usart/include/usart1.h
index 94ad8f0787ef49a1cbf78370b6f8e3390471b559..155d8502804a8c38025c5672dc0ef9dd4a9780c6 100644
--- a/f4/usart/include/usart1.h
+++ b/f4/usart/include/usart1.h
@@ -6,8 +6,8 @@
 #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_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_set_baudrate(TComm *comm_dev,unsigned int baudrate);
 /* IRQ functions */
diff --git a/f4/usart/include/usart2.h b/f4/usart/include/usart2.h
index 162c39146373d643ab7646f4d41c5f2db8de0f83..97a280603ba9b14d6b6653a5a93b2ab0bb9ce5f9 100644
--- a/f4/usart/include/usart2.h
+++ b/f4/usart/include/usart2.h
@@ -6,8 +6,8 @@
 #include "comm.h"
 
 /* public functions */
-void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
-void usart2_config(TComm *comm_dev,UART_InitTypeDef *conf);
+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_set_baudrate(TComm *comm_dev,unsigned int baudrate);
 /* IRQ functions */
diff --git a/f4/usart/include/usart3.h b/f4/usart/include/usart3.h
index 4d96a995bda7b0b5c59712ea80eee3281750660d..09202c886ebc09ae575d86c756df8ced2ad3346b 100644
--- a/f4/usart/include/usart3.h
+++ b/f4/usart/include/usart3.h
@@ -6,8 +6,8 @@
 #include "comm.h"
 
 /* public functions */
-void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities);
-void usart3_config(TComm *comm_dev,UART_InitTypeDef *conf);
+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_set_baudrate(TComm *comm_dev,unsigned int baudrate);
 /* IRQ functions */
diff --git a/f4/usart/src/usart1.c b/f4/usart/src/usart1.c
index ca3e17cf23d42c943c3998fe9b15a4877338a20a..b16bb5e8036173acf041b51fbe7cb7669d4434e3 100644
--- a/f4/usart/src/usart1.c
+++ b/f4/usart/src/usart1.c
@@ -26,7 +26,7 @@
 #define     USART_DMA_RX_IRQHandler  DMA2_Stream2_IRQHandler
 
 // private variables
-UART_HandleTypeDef Uart1Handle;
+USART_HandleTypeDef Uart1Handle;
 DMA_HandleTypeDef usart1_hdma_tx;
 DMA_HandleTypeDef usart1_hdma_rx;
 TComm *usart1_comm_dev;
@@ -37,56 +37,56 @@ void USART_IRQHandler(void)
   unsigned char data,ret;
   uint32_t source;
 
-  if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_RXNE) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_RXNE) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_RXNE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_RXNE) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_RXNE);
+      __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_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);
+        __HAL_USART_DISABLE_IT(&Uart1Handle, USART_IT_RXNE);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_TC) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_TC) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_TC) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_TC) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
+      __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_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);
+        __HAL_USART_DISABLE_IT(&Uart1Handle, USART_IT_TC);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_PE) != RESET)// parity error
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_PE) != RESET)// parity error
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart1Handle, UART_IT_PE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_PE) !=RESET)
     {
-      __HAL_UART_CLEAR_PEFLAG(&Uart1Handle);
+      __HAL_USART_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
+  source=__HAL_USART_GET_IT_SOURCE(&Uart1Handle, USART_IT_ERR);
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_FE) != RESET)// frame error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_FEFLAG(&Uart1Handle);
+      __HAL_USART_CLEAR_FEFLAG(&Uart1Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_NE) != RESET)// noise error
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_NE) != RESET)// noise error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_NEFLAG(&Uart1Handle);
+      __HAL_USART_CLEAR_NEFLAG(&Uart1Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart1Handle, UART_FLAG_ORE) != RESET)// overrun error
+  if(__HAL_USART_GET_FLAG(&Uart1Handle, USART_FLAG_ORE) != RESET)// overrun error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_OREFLAG(&Uart1Handle);
+      __HAL_USART_CLEAR_OREFLAG(&Uart1Handle);
     }
   }
 }
@@ -168,7 +168,7 @@ void USART_DMA_RX_IRQHandler(void)
 }
 
 /* public functions*/
-void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart1_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
 {
   GPIO_InitTypeDef GPIO_InitStructure;
 
@@ -210,7 +210,7 @@ void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart1_hdma_tx);
 
-    /* Associate the initialized DMA handle to the UART handle */
+    /* Associate the initialized DMA handle to the USART handle */
     __HAL_LINKDMA(&Uart1Handle, hdmatx, usart1_hdma_tx);
 
     /* Configure the DMA handler for reception process */
@@ -227,7 +227,7 @@ void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart1_hdma_rx);
 
-    /* Associate the initialized DMA handle to the the UART handle */
+    /* Associate the initialized DMA handle to the the USART handle */
     __HAL_LINKDMA(&Uart1Handle, hdmarx, usart1_hdma_rx);
   }
   usart1_set_priorities(comm_dev,priorities);
@@ -252,16 +252,17 @@ void usart1_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
   usart1_comm_dev=comm_dev;
 }
 
-void usart1_config(TComm *comm_dev,UART_InitTypeDef *conf)
+void usart1_config(TComm *comm_dev,USART_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);
+  Uart1Handle.Init.CLKPolarity  = conf->CLKPolarity;
+  Uart1Handle.Init.CLKPhase     = conf->CLKPhase;
+  Uart1Handle.Init.CLKLastBit   = conf->CLKLastBit;
+  HAL_USART_Init(&Uart1Handle);
 }
 
 void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
@@ -280,14 +281,14 @@ void usart1_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
 void usart1_set_baudrate(TComm *comm_dev,unsigned int baudrate)
 {
   Uart1Handle.Init.BaudRate = baudrate;
-  HAL_UART_Init(&Uart1Handle);
+  HAL_USART_Init(&Uart1Handle);
 }
 
 /* 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);
+  __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_TC);
   Uart1Handle.Instance->DR=first_byte;
 
   return 0x00;
@@ -295,8 +296,8 @@ unsigned char usart1_send_irq(unsigned char first_byte)
 
 unsigned char usart1_enable_tx_irq(void)
 {
-  __HAL_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
-  __HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_TC);
 
   return 0x00;
 }
@@ -304,7 +305,7 @@ unsigned char usart1_enable_tx_irq(void)
 unsigned char usart1_receive_irq(void)
 {
   /* enable the rx interrupt */
-  __HAL_UART_ENABLE_IT(&Uart1Handle, UART_IT_RXNE);
+  __HAL_USART_ENABLE_IT(&Uart1Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -312,7 +313,7 @@ unsigned char usart1_receive_irq(void)
 unsigned char usart1_cancel_receive_irq(void)
 {
   /* disable the rx interrupt */
-  __HAL_UART_DISABLE_IT(&Uart1Handle, UART_IT_RXNE);
+  __HAL_USART_DISABLE_IT(&Uart1Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -322,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_UART_CLEAR_FLAG(&Uart1Handle,UART_FLAG_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart1Handle,USART_FLAG_TC);
   /* Enable the DMA transfer for transmit request by setting the DMAT bit
-     in the UART CR3 register */
+     in the USART 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 44190b812114be10d0d8540a5cee57a16a27007c..b2c26b6c0fab9b4e5ece7ca6fbe7280e2f44669f 100644
--- a/f4/usart/src/usart2.c
+++ b/f4/usart/src/usart2.c
@@ -26,7 +26,7 @@
 #define     USART_DMA_RX_IRQHandler  DMA1_Stream5_IRQHandler
 
 // private variables
-UART_HandleTypeDef Uart2Handle;
+USART_HandleTypeDef Uart2Handle;
 DMA_HandleTypeDef usart2_hdma_tx;
 DMA_HandleTypeDef usart2_hdma_rx;
 TComm *usart2_comm_dev;
@@ -37,56 +37,56 @@ void USART_IRQHandler(void)
   unsigned char data,ret;
   uint32_t source;
 
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_RXNE) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_RXNE) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_RXNE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_RXNE) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_RXNE);
+      __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_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_UART_DISABLE_IT(&Uart2Handle, UART_IT_RXNE);
+        __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_RXNE);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_TC) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_TC) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_TC) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_TC) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
+      __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
       ret=comm_do_irq_send(usart2_comm_dev,&data);
       if(ret==0x01)
         Uart2Handle.Instance->DR=data;
       else if(ret==0x00)
-        __HAL_UART_DISABLE_IT(&Uart2Handle, UART_IT_TC);
+        __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_TC);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_PE) != RESET)// parity error
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_PE) != RESET)// parity error
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_PE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_PE) !=RESET)
     {
-      __HAL_UART_CLEAR_PEFLAG(&Uart2Handle);
+      __HAL_USART_CLEAR_PEFLAG(&Uart2Handle);
     }
   }
-  source=__HAL_UART_GET_IT_SOURCE(&Uart2Handle, UART_IT_ERR);
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_FE) != RESET)// frame error
+  source=__HAL_USART_GET_IT_SOURCE(&Uart2Handle, USART_IT_ERR);
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_FE) != RESET)// frame error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_FEFLAG(&Uart2Handle);
+      __HAL_USART_CLEAR_FEFLAG(&Uart2Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_NE) != RESET)// noise error
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_NE) != RESET)// noise error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_NEFLAG(&Uart2Handle);
+      __HAL_USART_CLEAR_NEFLAG(&Uart2Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart2Handle, UART_FLAG_ORE) != RESET)// overrun error
+  if(__HAL_USART_GET_FLAG(&Uart2Handle, USART_FLAG_ORE) != RESET)// overrun error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_OREFLAG(&Uart2Handle);
+      __HAL_USART_CLEAR_OREFLAG(&Uart2Handle);
     }
   }
 }
@@ -168,7 +168,7 @@ void USART_DMA_RX_IRQHandler(void)
 }
 
 /* public functions*/
-void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart2_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
 {
   GPIO_InitTypeDef GPIO_InitStructure;
 
@@ -210,7 +210,7 @@ void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart2_hdma_tx);
 
-    /* Associate the initialized DMA handle to the UART handle */
+    /* Associate the initialized DMA handle to the USART handle */
     __HAL_LINKDMA(&Uart2Handle, hdmatx, usart2_hdma_tx);
 
     /* Configure the DMA handler for reception process */
@@ -227,7 +227,7 @@ void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart2_hdma_rx);
 
-    /* Associate the initialized DMA handle to the the UART handle */
+    /* Associate the initialized DMA handle to the the USART handle */
     __HAL_LINKDMA(&Uart2Handle, hdmarx, usart2_hdma_rx);
   }
   usart2_set_priorities(comm_dev,priorities);
@@ -252,16 +252,17 @@ void usart2_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
   usart2_comm_dev=comm_dev;
 }
 
-void usart2_config(TComm *comm_dev,UART_InitTypeDef *conf)
+void usart2_config(TComm *comm_dev,USART_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.HwFlowCtl    = conf->HwFlowCtl;
-  Uart2Handle.Init.OverSampling = conf->OverSampling;
-  HAL_UART_Init(&Uart2Handle);
+  Uart2Handle.Init.CLKPolarity  = conf->CLKPolarity;
+  Uart2Handle.Init.CLKPhase     = conf->CLKPhase;
+  Uart2Handle.Init.CLKLastBit   = conf->CLKLastBit;
+  HAL_USART_Init(&Uart2Handle);
 }
 
 void usart2_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
@@ -280,14 +281,14 @@ void usart2_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
 void usart2_set_baudrate(TComm *comm_dev,unsigned int baudrate)
 {
   Uart2Handle.Init.BaudRate = baudrate;
-  HAL_UART_Init(&Uart2Handle);
+  HAL_USART_Init(&Uart2Handle);
 }
 
 /* IRQ functions */
 unsigned char usart2_send_irq(unsigned char first_byte)
 {
-  __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
-  __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_TC);
   Uart2Handle.Instance->DR=first_byte;
 
   return 0x00;
@@ -295,8 +296,8 @@ unsigned char usart2_send_irq(unsigned char first_byte)
 
 unsigned char usart2_enable_tx_irq(void)
 {
-  __HAL_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
-  __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_TC);
 
   return 0x00;
 }
@@ -304,7 +305,7 @@ unsigned char usart2_enable_tx_irq(void)
 unsigned char usart2_receive_irq(void)
 {
   /* enable the rx interrupt */
-  __HAL_UART_ENABLE_IT(&Uart2Handle, UART_IT_RXNE);
+  __HAL_USART_ENABLE_IT(&Uart2Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -312,7 +313,7 @@ unsigned char usart2_receive_irq(void)
 unsigned char usart2_cancel_receive_irq(void)
 {
   /* disable the rx interrupt */
-  __HAL_UART_DISABLE_IT(&Uart2Handle, UART_IT_RXNE);
+  __HAL_USART_DISABLE_IT(&Uart2Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -322,9 +323,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_UART_CLEAR_FLAG(&Uart2Handle,UART_FLAG_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart2Handle,USART_FLAG_TC);
   /* Enable the DMA transfer for transmit request by setting the DMAT bit
-     in the UART CR3 register */
+     in the USART 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 5e5a6e38ca1a659005605b07f0465b5b055f70cb..2acf346216ade2742348ccd9183141e074b02005 100644
--- a/f4/usart/src/usart3.c
+++ b/f4/usart/src/usart3.c
@@ -26,7 +26,7 @@
 #define     USART_DMA_RX_IRQHandler  DMA1_Stream1_IRQHandler
 
 // private variables
-UART_HandleTypeDef Uart3Handle;
+USART_HandleTypeDef Uart3Handle;
 DMA_HandleTypeDef usart3_hdma_tx;
 DMA_HandleTypeDef usart3_hdma_rx;
 TComm *usart3_comm_dev;
@@ -37,56 +37,56 @@ void USART_IRQHandler(void)
   unsigned char data,ret;
   uint32_t source;
 
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_RXNE) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_RXNE) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_RXNE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_RXNE) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_RXNE);
+      __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_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_UART_DISABLE_IT(&Uart3Handle, UART_IT_RXNE);
+        __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_RXNE);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_TC) != RESET)
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_TC) != RESET)
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_TC) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_TC) !=RESET)
     {
-      __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
+      __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
       ret=comm_do_irq_send(usart3_comm_dev,&data);
       if(ret==0x01)
         Uart3Handle.Instance->DR=data;
       else if(ret==0x00)
-        __HAL_UART_DISABLE_IT(&Uart3Handle, UART_IT_TC);
+        __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_TC);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_PE) != RESET)// parity error
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_PE) != RESET)// parity error
   {
-    if(__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_PE) !=RESET)
+    if(__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_PE) !=RESET)
     {
-      __HAL_UART_CLEAR_PEFLAG(&Uart3Handle);
+      __HAL_USART_CLEAR_PEFLAG(&Uart3Handle);
     }
   }
-  source=__HAL_UART_GET_IT_SOURCE(&Uart3Handle, UART_IT_ERR);
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_FE) != RESET)// frame error
+  source=__HAL_USART_GET_IT_SOURCE(&Uart3Handle, USART_IT_ERR);
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_FE) != RESET)// frame error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_FEFLAG(&Uart3Handle);
+      __HAL_USART_CLEAR_FEFLAG(&Uart3Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_NE) != RESET)// noise error
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_NE) != RESET)// noise error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_NEFLAG(&Uart3Handle);
+      __HAL_USART_CLEAR_NEFLAG(&Uart3Handle);
     }
   }
-  if(__HAL_UART_GET_FLAG(&Uart3Handle, UART_FLAG_ORE) != RESET)// overrun error
+  if(__HAL_USART_GET_FLAG(&Uart3Handle, USART_FLAG_ORE) != RESET)// overrun error
   {
     if(source !=RESET)
     {
-      __HAL_UART_CLEAR_OREFLAG(&Uart3Handle);
+      __HAL_USART_CLEAR_OREFLAG(&Uart3Handle);
     }
   }
 }
@@ -168,7 +168,7 @@ void USART_DMA_RX_IRQHandler(void)
 }
 
 /* public functions*/
-void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
+void usart3_init(TComm *comm_dev,USART_InitTypeDef *conf,TUSART_IRQ_Priorities *priorities)
 {
   GPIO_InitTypeDef GPIO_InitStructure;
 
@@ -210,7 +210,7 @@ void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart3_hdma_tx);
 
-    /* Associate the initialized DMA handle to the UART handle */
+    /* Associate the initialized DMA handle to the USART handle */
     __HAL_LINKDMA(&Uart3Handle, hdmatx, usart3_hdma_tx);
 
     /* Configure the DMA handler for reception process */
@@ -227,7 +227,7 @@ void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
 
     HAL_DMA_Init(&usart3_hdma_rx);
 
-    /* Associate the initialized DMA handle to the the UART handle */
+    /* Associate the initialized DMA handle to the the USART handle */
     __HAL_LINKDMA(&Uart3Handle, hdmarx, usart3_hdma_rx);
   }
   usart3_set_priorities(comm_dev,priorities);
@@ -252,16 +252,17 @@ void usart3_init(TComm *comm_dev,UART_InitTypeDef *conf,TUSART_IRQ_Priorities *p
   usart3_comm_dev=comm_dev;
 }
 
-void usart3_config(TComm *comm_dev,UART_InitTypeDef *conf)
+void usart3_config(TComm *comm_dev,USART_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.HwFlowCtl    = conf->HwFlowCtl;
-  Uart3Handle.Init.OverSampling = conf->OverSampling;
-  HAL_UART_Init(&Uart3Handle);
+  Uart3Handle.Init.CLKPolarity  = conf->CLKPolarity;
+  Uart3Handle.Init.CLKPhase     = conf->CLKPhase;
+  Uart3Handle.Init.CLKLastBit   = conf->CLKLastBit;
+  HAL_USART_Init(&Uart3Handle);
 }
 
 void usart3_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
@@ -280,14 +281,14 @@ void usart3_set_priorities(TComm *comm_dev,TUSART_IRQ_Priorities *priorities)
 void usart3_set_baudrate(TComm *comm_dev,unsigned int baudrate)
 {
   Uart3Handle.Init.BaudRate = baudrate;
-  HAL_UART_Init(&Uart3Handle);
+  HAL_USART_Init(&Uart3Handle);
 }
 
 /* IRQ functions */
 unsigned char usart3_send_irq(unsigned char first_byte)
 {
-  __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
-  __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_TC);
   Uart3Handle.Instance->DR=first_byte;
 
   return 0x00;
@@ -295,8 +296,8 @@ unsigned char usart3_send_irq(unsigned char first_byte)
 
 unsigned char usart3_enable_tx_irq(void)
 {
-  __HAL_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
-  __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
+  __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_TC);
 
   return 0x00;
 }
@@ -304,7 +305,7 @@ unsigned char usart3_enable_tx_irq(void)
 unsigned char usart3_receive_irq(void)
 {
   /* enable the rx interrupt */
-  __HAL_UART_ENABLE_IT(&Uart3Handle, UART_IT_RXNE);
+  __HAL_USART_ENABLE_IT(&Uart3Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -312,7 +313,7 @@ unsigned char usart3_receive_irq(void)
 unsigned char usart3_cancel_receive_irq(void)
 {
   /* disable the rx interrupt */
-  __HAL_UART_DISABLE_IT(&Uart3Handle, UART_IT_RXNE);
+  __HAL_USART_DISABLE_IT(&Uart3Handle, USART_IT_RXNE);
 
   return 0x00;
 }
@@ -322,9 +323,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_UART_CLEAR_FLAG(&Uart3Handle,UART_FLAG_TC);
+  __HAL_USART_CLEAR_FLAG(&Uart3Handle,USART_FLAG_TC);
   /* Enable the DMA transfer for transmit request by setting the DMAT bit
-     in the UART CR3 register */
+     in the USART CR3 register */
   SET_BIT(Uart3Handle.Instance->CR3, USART_CR3_DMAT);
 
   return 0x00;