STM32F103C8T6 HAL UART

unsigned char CR=0x0D;
unsigned char LF=0x0A;
void UART_Write(unsigned char *pack)
{
    int a = strlen((unsigned char *)pack);
    HAL_UART_Transmit(&huart1,(unsigned char *)pack,a,10000);
    HAL_UART_Transmit(&huart1,&CR,1,10000);
    HAL_UART_Transmit(&huart1,&LF,1,10000);
}
...
UART_Write("AT+CGSN");

#define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__)   __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_IDLEF)

*            @arg UART_FLAG_RXNE:  Receive data register not empty flag

if (USORT_GetITStatus(USORTx, USORT_IT_RXNE) != RESET)
{
      USORT_ClearITPendingBit(USORTx, USORT_IT_RXNE);
      ....
      x = UARTx->DR;
}

if (USORTx->SR &USORT_FLAG_RXNE) != RESET)
{
      USORTx->SR &USORT_FLAG_RXNE) = RESET;
      ....
      x = UARTx->DR;
}

while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)==RESET){};

commit *
Author: Rius
Date:   Wed Jul 29 18:30:50 2015 +0500
 
    Добавлен обработчик для uart, реализующий функцию эха.
 
diff --git a/.settings/org.eclipse.core.runtime.prefs b/.settings/org.eclipse.core.runtime.prefs
deleted file mode 100644
index 5a0ad22..0000000
--- a/.settings/org.eclipse.core.runtime.prefs
+++ /dev/null
@@ -1,2 +0,0 @@
-eclipse.preferences.version=1
-line.separator=\n
diff --git a/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h b/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h
index 7d65ca5..f5794c0 100644
--- a/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h
+++ b/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h
@@ -693,6 +693,7 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
+void HAL_UART_RxIdleCallback(UART_HandleTypeDef *huart);
 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);
 
diff --git a/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c b/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
index 2c2bffd..05b0447 100644
--- a/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
+++ b/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
@@ -1238,6 +1238,15 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
     UART_EndTransmit_IT(huart);
   }  
 
+  tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE);
+  tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_IDLE);
+  /* UART in mode Receiver end (idle) ----------------------------------------*/
+  if((tmp_flag != RESET) && (tmp_it_source != RESET))
+  {
+    __HAL_UART_CLEAR_IDLEFLAG(huart);
+    HAL_UART_RxIdleCallback(huart);
+  }
+
   if(huart->ErrorCode != HAL_UART_ERROR_NONE)
   {
     /* Set the UART state ready to be able to start again the process */
@@ -1248,6 +1257,19 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
 }
 
 /**
+  * @brief  Rx Idle callbacks.
+  * @param  huart: Pointer to a UART_HandleTypeDef structure that contains
+  *                the configuration information for the specified UART module.
+  * @retval None
+  */
+__weak void HAL_UART_RxIdleCallback(UART_HandleTypeDef *huart)
+{
+ /* NOTE: This function should not be modified, when the callback is needed,
+          the HAL_UART_RxIdleCallback can be implemented in the user file
+  */
+}
+
+/**
   * @brief  Tx Transfer completed callbacks.
   * @param  huart: Pointer to a UART_HandleTypeDef structure that contains
   *                the configuration information for the specified UART module.
diff --git a/Src/freertos.cpp b/Src/freertos.cpp
index 4ca68c6..63be96b 100644
--- a/Src/freertos.cpp
+++ b/Src/freertos.cpp
@@ -38,6 +38,8 @@
 
 /* USER CODE BEGIN Includes */     
 #include "freertos_main.h"
+#include "stm32f1xx_hal.h"
+#include "../Application/application.h"
 /* USER CODE END Includes */
 
 /* Variables -----------------------------------------------------------------*/
@@ -46,7 +48,7 @@ osThreadId taskDisplayHandle;
 osThreadId taskKeyboardHandle;
 
 /* USER CODE BEGIN Variables */
-
+extern UART_HandleTypeDef huart1;
 /* USER CODE END Variables */
 
 /* Function prototypes -------------------------------------------------------*/
@@ -135,13 +137,26 @@ void taskKeyboardFunc(void const * argument)
   /* Infinite loop */
   for(;;)
   {
-    osDelay(1);
+    app.protocols()->process(&huart1);
   }
   /* USER CODE END taskKeyboardFunc */
 }
 
 /* USER CODE BEGIN Application */
-     
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+{
+  app.protocols()->callbackTxCompleted(huart);
+}
+
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
+{
+  app.protocols()->callbackRxCompleted(huart);
+}
+
+void HAL_UART_RxIdleCallback(UART_HandleTypeDef *huart)
+{
+  app.protocols()->callbackRxCompleted(huart);
+}
 /* USER CODE END Application */
 
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

commit *
Author: Rius
Date:   Thu Jan 21 18:04:40 2016 +0500
 
    Восстановлено завершение приёма по прерыванию IDLE
 
diff --git a/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c b/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
index a901f0a..128f5e5 100644
--- a/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
+++ b/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_uart.c
@@ -179,6 +179,7 @@ static void UART_SetConfig (UART_HandleTypeDef *huart);
 static HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart);
 static HAL_StatusTypeDef UART_EndTransmit_IT(UART_HandleTypeDef *huart);
 static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart);
+static HAL_StatusTypeDef UART_EndReceive_IT(UART_HandleTypeDef *huart);
 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
@@ -913,6 +914,9 @@ HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData,
     /* Enable the UART Data Register not empty Interrupt */
     __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
 
+    /* Enable the UART Idle line detection Interrupt */
+    __HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
+
     return HAL_OK;
   }
   else
@@ -1044,6 +1048,9 @@ HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData
     tmp = (uint32_t*)&pData;
     HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t*)tmp, Size);
 
+    /* Clear the IDLE flag in the SR register by writing 0 to it */
+    __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_IDLE);
+
     /* Enable the DMA transfer for the receiver request by setting the DMAR bit 
        in the UART CR3 register */
     SET_BIT(huart->Instance->CR3, USORT_CR3_DMAR);
@@ -1224,6 +1231,14 @@ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
     UART_Receive_IT(huart);
   }
   
+  tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE);
+  tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_IDLE);
+  /* UART in mode Receiver ---------------------------------------------------*/
+  if((tmp_flag != RESET) && (tmp_it_source != RESET))
+  {
+    UART_EndReceive_IT(huart);
+  }
+
   tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TXE);
   tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE);
   /* UART in mode Transmitter ------------------------------------------------*/
@@ -1856,6 +1871,44 @@ static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
   }
 }
 
+static HAL_StatusTypeDef UART_EndReceive_IT(UART_HandleTypeDef *huart)
+{
+  uint32_t tmp_state = 0;
+
+  /* Disable the UART RXNE Interrupt */
+  __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
+  /* Disable the UART Idle Interrupt */
+  __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);
+
+  tmp_state = huart->State;
+
+  if((tmp_state == HAL_UART_STATE_BUSY_RX) || (tmp_state == HAL_UART_STATE_BUSY_TX_RX))
+  {
+    /* Check if a transmit process is ongoing or not */
+    if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
+    {
+      huart->State = HAL_UART_STATE_BUSY_TX;
+    }
+    else
+    {
+      /* Disable the UART Parity Error Interrupt */
+      __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
+
+      /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
+      __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
+
+      huart->State = HAL_UART_STATE_READY;
+    }
+    HAL_UART_RxCpltCallback(huart);
+
+    return HAL_OK;
+  }
+  else
+  {
+    return HAL_BUSY;
+  }
+}
+
 /**
   * @brief  Configures the UART peripheral. 
   * @param  huart: Pointer to a UART_HandleTypeDef structure that contains

void ProtocolHandler::callbackTxCompleted(UART_HandleTypeDef *huart)
{
  osSemaphoreRelease(this->mSemSerialCommTxCompletedHandle);
}
 
void ProtocolHandler::callbackRxCompleted(UART_HandleTypeDef *huart)
{
  __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);
  osSemaphoreRelease(this->mSemSerialCommRxIdleHandle);
}
 
void ProtocolHandler::process(UART_HandleTypeDef *huart)
{
  while (true) {
    __HAL_UART_CLEAR_IDLEFLAG(huart);
    __HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
 
    this->mDirection485.set(Drivers::Direction::Receive);
 
    if (HAL_UART_Receive_DMA(huart, this->mRxBuffer, sizeof(this->mRxBuffer)) != HAL_OK) {
      // error
    }
 
    int retval = osSemaphoreWait(this->mSemSerialCommRxIdleHandle, osWaitForever);
    int rcvdCount = sizeof(this->mRxBuffer) - huart->hdmarx->Instance->CNDTR;
    HAL_UART_DMAStop(huart);
 
    int sendCount;
 
    if (this->processPacket(
          this->mRxBuffer,
          rcvdCount,
          this->mTxBuffer,
          sizeof(this->mTxBuffer) - ProtocolHandler::MinimamOutputPacketLength,
          &sendCount) == HandlerResult::Handled) {
      this->mDirection485.set(Drivers::Direction::Transmit);
 
      HAL_UART_Transmit_DMA(huart, this->mTxBuffer, sendCount);
      retval = osSemaphoreWait(this->mSemSerialCommTxCompletedHandle, osWaitForever);
      HAL_UART_DMAStop(huart);
    }
 
    osDelay(1);
  }
}