WebSVN – DashDisplay – Diff – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_usart.c

     not defined, the callback registration feature is not available
     and weak (surcharged) callbacks are used.
   @endverbatim
      [..]
-       (@) Additionnal remark: If the parity is enabled, then the MSB bit of the data written
+       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written
            in the data register is transmitted but is changed by the parity bit.
            Depending on the frame length defined by the M bit (8-bits or 9-bits),
            the possible USART frame formats are as listed in the following table:
     +-------------------------------------------------------------+
     |   M bit |  PCE bit  |            USART frame                 |
   * @param  Timeout Timeout duration.
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
+{
+  uint8_t  *ptxdata8bits;
-  uint16_t *tmp;
+  uint16_t *ptxdata16bits;
-  uint32_t tickstart = 0U;
+  uint32_t tickstart;
   if (husart->State == HAL_USART_STATE_READY)
+  {
     if ((pTxData == NULL) || (Size == 0))
+    {
     /* Init tickstart for timeout management */
     tickstart = HAL_GetTick();
     husart->TxXferSize = Size;
     husart->TxXferCount = Size;
+    /* In case of 9bits/No Parity transfer, pTxData needs to be handled as a uint16_t pointer */
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
+      ptxdata8bits  = NULL;
+      ptxdata16bits = (uint16_t *) pTxData;
+    }
+    else
+    {
+      ptxdata8bits  = pTxData;
+      ptxdata16bits = NULL;
+    }
     while (husart->TxXferCount > 0U)
+    {
-      husart->TxXferCount--;
+      /* Wait for TXE flag in order to write data in DR */
-      if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+      {
-        /* Wait for TC flag in order to write data in DR */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-        {
-          return HAL_TIMEOUT;
+        return HAL_TIMEOUT;
-        }
+      }
-        tmp = (uint16_t *) pTxData;
+      if (ptxdata8bits == NULL)
-        husart->Instance->DR = (*tmp & (uint16_t)0x01FF);
-        if (husart->Init.Parity == USART_PARITY_NONE)
-        {
+      {
-          pTxData += 2U;
+        husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
-        }
-        else
-        {
-          pTxData += 1U;
+        ptxdata16bits++;
-        }
+      }
       else
+      {
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+        husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
-        {
-          return HAL_TIMEOUT;
+        ptxdata8bits++;
-        }
-        husart->Instance->DR = (*pTxData++ & (uint8_t)0xFF);
+      }
+      husart->TxXferCount--;
+    }
     if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
+    {
       return HAL_TIMEOUT;
   * @param  Timeout Timeout duration.
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
+{
+  uint8_t  *prxdata8bits;
-  uint16_t *tmp;
+  uint16_t *prxdata16bits;
-  uint32_t tickstart = 0U;
+  uint32_t tickstart;
   if (husart->State == HAL_USART_STATE_READY)
+  {
     if ((pRxData == NULL) || (Size == 0))
+    {
     /* Init tickstart for timeout management */
     tickstart = HAL_GetTick();
     husart->RxXferSize = Size;
     husart->RxXferCount = Size;
+    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
+      prxdata8bits  = NULL;
+      prxdata16bits = (uint16_t *) pRxData;
+    }
+    else
+    {
+      prxdata8bits  = pRxData;
+      prxdata16bits = NULL;
+    }
     /* Check the remain data to be received */
     while (husart->RxXferCount > 0U)
+    {
+      /* Wait until TXE flag is set to send dummy byte in order to generate the
-      husart->RxXferCount--;
+      * clock for the slave to send data.
+      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
-      if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+      * can be written for all the cases. */
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+      {
-        /* Wait until TXE flag is set to send dummy byte in order to generate the clock for the slave to send data */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-        {
-          return HAL_TIMEOUT;
+        return HAL_TIMEOUT;
-        }
+      }
-        /* Send dummy byte in order to generate clock */
-        husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
+      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
-        /* Wait for RXNE Flag */
+      /* Wait until RXNE flag is set to receive the byte */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-        {
+      {
-          return HAL_TIMEOUT;
+        return HAL_TIMEOUT;
-        }
+      }
-        tmp = (uint16_t *) pRxData ;
-        if (husart->Init.Parity == USART_PARITY_NONE)
-        {
-          *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-          pRxData += 2U;
+      if (prxdata8bits == NULL)
-        }
-        else
-        {
+      {
-          *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
+        *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-          pRxData += 1U;
+        prxdata16bits++;
-        }
+      }
       else
+      {
-        /* Wait until TXE flag is set to send dummy byte in order to generate the clock for the slave to send data */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-        {
-          return HAL_TIMEOUT;
-        }
-        /* Send Dummy Byte in order to generate clock */
-        husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x00FF);
-        /* Wait until RXNE flag is set to receive the byte */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
-        {
-          return HAL_TIMEOUT;
-        }
-        if (husart->Init.Parity == USART_PARITY_NONE)
+        {
-          /* Receive data */
-          *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
+        }
         else
+        {
-          /* Receive data */
-          *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
+        }
+        prxdata8bits++;
+      }
+      husart->RxXferCount--;
+    }
     husart->State = HAL_USART_STATE_READY;
     /* Process Unlocked */
   * @param  Timeout Timeout duration
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
+{
+  uint8_t  *prxdata8bits;
+  uint16_t *prxdata16bits;
+  uint8_t  *ptxdata8bits;
+  uint16_t *ptxdata16bits;
-  uint16_t *tmp;
+  uint16_t rxdatacount;
-  uint32_t tickstart = 0U;
+  uint32_t tickstart;
   if (husart->State == HAL_USART_STATE_READY)
+  {
     if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
+    {
       return  HAL_ERROR;
+    }
+    /* In case of 9bits/No Parity transfer, pTxData and pRxData buffers provided as input parameter
+       should be aligned on a u16 frontier, as data to be filled into TDR/retrieved from RDR will be
+       handled through a u16 cast. */
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
+      if (((((uint32_t)pTxData) & 1U) != 0U) || ((((uint32_t)pRxData) & 1U) != 0U))
+      {
+        return  HAL_ERROR;
+      }
+    }
     /* Process Locked */
     __HAL_LOCK(husart);
     husart->ErrorCode = HAL_USART_ERROR_NONE;
     husart->State = HAL_USART_STATE_BUSY_RX;
     husart->RxXferSize = Size;
     husart->TxXferSize = Size;
     husart->TxXferCount = Size;
     husart->RxXferCount = Size;
+    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
+      prxdata8bits  = NULL;
+      ptxdata8bits  = NULL;
+      ptxdata16bits = (uint16_t *) pTxData;
+      prxdata16bits = (uint16_t *) pRxData;
+    }
+    else
+    {
+      prxdata8bits  = pRxData;
+      ptxdata8bits  = pTxData;
+      ptxdata16bits = NULL;
+      prxdata16bits = NULL;
+    }
     /* Check the remain data to be received */
+    /* rxdatacount is a temporary variable for MISRAC2012-Rule-13.5 */
+    rxdatacount = husart->RxXferCount;
-    while (husart->TxXferCount > 0U)
+    while ((husart->TxXferCount > 0U) || (rxdatacount > 0U))
+    {
-      husart->TxXferCount--;
+      if (husart->TxXferCount > 0U)
-      husart->RxXferCount--;
-      if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+      {
-        /* Wait for TC flag in order to write data in DR */
+        /* Wait for TXE flag in order to write data in DR */
         if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+        {
           return HAL_TIMEOUT;
+        }
-        tmp = (uint16_t *) pTxData;
-        husart->Instance->DR = (*tmp & (uint16_t)0x01FF);
-        if (husart->Init.Parity == USART_PARITY_NONE)
-        {
-          pTxData += 2U;
-        }
-        else
-        {
-          pTxData += 1U;
-        }
-        /* Wait for RXNE Flag */
+        if (ptxdata8bits == NULL)
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+        {
-          return HAL_TIMEOUT;
-        }
-        tmp = (uint16_t *) pRxData ;
-        if (husart->Init.Parity == USART_PARITY_NONE)
-        {
-          *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+          husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
-          pRxData += 2U;
+          ptxdata16bits++;
+        }
         else
+        {
-          *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
+          husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
-          pRxData += 1U;
+          ptxdata8bits++;
+        }
+        husart->TxXferCount--;
+      }
-      else
-      {
-        /* Wait for TC flag in order to write data in DR */
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-        {
-          return HAL_TIMEOUT;
-        }
-        husart->Instance->DR = (*pTxData++ & (uint8_t)0x00FF);
+      if (husart->RxXferCount > 0U)
+      {
         /* Wait for RXNE Flag */
         if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+        {
           return HAL_TIMEOUT;
+        }
-        if (husart->Init.Parity == USART_PARITY_NONE)
+        if (prxdata8bits == NULL)
+        {
-          /* Receive data */
-          *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+          *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+          prxdata16bits++;
+        }
         else
+        {
+          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+          {
+            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
+          }
-          /* Receive data */
+          else
+          {
-          *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
+          }
+          prxdata8bits++;
+        }
+        husart->RxXferCount--;
+      }
+      rxdatacount = husart->RxXferCount;
+    }
     husart->State = HAL_USART_STATE_READY;
     /* Process Unlocked */
     /* Disable the DMA transfer for the Transmit/receiver request by clearing the DMAT/DMAR bit
          in the USART CR3 register */
     CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
     CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-    husart->State = HAL_USART_STATE_READY;
     /* The USART state is HAL_USART_STATE_BUSY_RX */
     if (husart->State == HAL_USART_STATE_BUSY_RX)
+    {
 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
       /* Call registered Rx Complete Callback */
 #else
       /* Call legacy weak Tx Rx Complete Callback */
       HAL_USART_TxRxCpltCallback(husart);
 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+    }
+    husart->State = HAL_USART_STATE_READY;
+  }
   /* DMA circular mode */
   else
+  {
     if (husart->State == HAL_USART_STATE_BUSY_RX)
+{
   uint16_t *tmp;
   if (husart->State == HAL_USART_STATE_BUSY_TX)
+  {
-    if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
       tmp = (uint16_t *) husart->pTxBuffPtr;
       husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
-      if (husart->Init.Parity == USART_PARITY_NONE)
-      {
-        husart->pTxBuffPtr += 2U;
+      husart->pTxBuffPtr += 2U;
-      }
-      else
-      {
-        husart->pTxBuffPtr += 1U;
-      }
+    }
     else
+    {
       husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
+    }
   *                the configuration information for the specified USART module.
   * @retval HAL status
   */
 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
+{
+  uint8_t  *pdata8bits;
-  uint16_t *tmp;
+  uint16_t *pdata16bits;
   if (husart->State == HAL_USART_STATE_BUSY_RX)
+  {
-    if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
-      tmp = (uint16_t *) husart->pRxBuffPtr;
+      pdata8bits  = NULL;
-      if (husart->Init.Parity == USART_PARITY_NONE)
-      {
-        *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+      pdata16bits = (uint16_t *) husart->pRxBuffPtr;
-        husart->pRxBuffPtr += 2U;
-      }
-      else
-      {
-        *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
+      *pdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-        husart->pRxBuffPtr += 1U;
+      husart->pRxBuffPtr += 2U;
-      }
-      if (--husart->RxXferCount != 0x00U)
-      {
-        /* Send dummy byte in order to generate the clock for the slave to send the next data */
-        husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
-      }
+    }
     else
+    {
-      if (husart->Init.Parity == USART_PARITY_NONE)
+      pdata8bits = (uint8_t *) husart->pRxBuffPtr;
+      pdata16bits  = NULL;
+      if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+      {
-        *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+      }
       else
+      {
-        *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+      }
-      if (--husart->RxXferCount != 0x00U)
+      husart->pRxBuffPtr += 1U;
-      {
-        /* Send dummy byte in order to generate the clock for the slave to send the next data */
-        husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x00FF);
-      }
+    }
+    husart->RxXferCount--;
     if (husart->RxXferCount == 0U)
+    {
       /* Disable the USART RXNE Interrupt */
       CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
       HAL_USART_RxCpltCallback(husart);
 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
       return HAL_OK;
+    }
+    else
+    {
+      /* Send dummy byte in order to generate the clock for the slave to send the next data.
+      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
+      * can be written for all the cases. */
+      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
+    }
     return HAL_OK;
+  }
   else
+  {
     return HAL_BUSY;
   *                the configuration information for the specified USART module.
   * @retval HAL status
   */
 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
+{
+  uint8_t  *pdata8bits;
-  uint16_t *tmp;
+  uint16_t *pdata16bits;
   if (husart->State == HAL_USART_STATE_BUSY_TX_RX)
+  {
     if (husart->TxXferCount != 0x00U)
+    {
       if (__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
+      {
-        if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+        {
+          pdata8bits  = NULL;
-          tmp = (uint16_t *) husart->pTxBuffPtr;
+          pdata16bits = (uint16_t *) husart->pTxBuffPtr;
-          husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
+          husart->Instance->DR = (uint16_t)(*pdata16bits & (uint16_t)0x01FF);
-          if (husart->Init.Parity == USART_PARITY_NONE)
-          {
-            husart->pTxBuffPtr += 2U;
+          husart->pTxBuffPtr += 2U;
-          }
-          else
-          {
-            husart->pTxBuffPtr += 1U;
-          }
+        }
         else
+        {
           husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
+        }
         husart->TxXferCount--;
         /* Check the latest data transmitted */
         if (husart->TxXferCount == 0U)
+        {
     if (husart->RxXferCount != 0x00U)
+    {
       if (__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
+      {
-        if (husart->Init.WordLength == USART_WORDLENGTH_9B)
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+        {
-          tmp = (uint16_t *) husart->pRxBuffPtr;
+           pdata8bits  = NULL;
-          if (husart->Init.Parity == USART_PARITY_NONE)
-          {
-            *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+           pdata16bits = (uint16_t *) husart->pRxBuffPtr;
-            husart->pRxBuffPtr += 2U;
-          }
-          else
-          {
-            *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
+           *pdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-            husart->pRxBuffPtr += 1U;
+           husart->pRxBuffPtr += 2U;
-          }
+        }
         else
+        {
-          if (husart->Init.Parity == USART_PARITY_NONE)
+          pdata8bits = (uint8_t *) husart->pRxBuffPtr;
+          pdata16bits  = NULL;
+          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+          {
-            *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+            *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+          }
           else
+          {
-            *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+            *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+          }
+          husart->pRxBuffPtr += 1U;
+        }
         husart->RxXferCount--;
+      }
+    }
     /* Check the latest data received */

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_usart.c – Rev 56 → 61