stm32l4xx_hal_uart_ex.h

00001 /**
00002   ******************************************************************************
00003   * @file    stm32l4xx_hal_uart_ex.h
00004   * @author  MCD Application Team
00005   * @version V1.1.0
00006   * @date    16-September-2015
00007   * @brief   Header file of UART HAL Extended module.
00008   ******************************************************************************
00009   * @attention
00010   *
00011   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
00012   *
00013   * Redistribution and use in source and binary forms, with or without modification,
00014   * are permitted provided that the following conditions are met:
00015   *   1. Redistributions of source code must retain the above copyright notice,
00016   *      this list of conditions and the following disclaimer.
00017   *   2. Redistributions in binary form must reproduce the above copyright notice,
00018   *      this list of conditions and the following disclaimer in the documentation
00019   *      and/or other materials provided with the distribution.
00020   *   3. Neither the name of STMicroelectronics nor the names of its contributors
00021   *      may be used to endorse or promote products derived from this software
00022   *      without specific prior written permission.
00023   *
00024   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00025   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00026   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00027   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00028   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00029   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00030   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00031   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00032   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00033   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034   *
00035   ******************************************************************************
00036   */
00037 
00038 /* Define to prevent recursive inclusion -------------------------------------*/
00039 #ifndef __STM32L4xx_HAL_UART_EX_H
00040 #define __STM32L4xx_HAL_UART_EX_H
00041 
00042 #ifdef __cplusplus
00043  extern "C" {
00044 #endif
00045 
00046 /* Includes ------------------------------------------------------------------*/
00047 #include "stm32l4xx_hal_def.h"
00048 
00049 /** @addtogroup STM32L4xx_HAL_Driver
00050   * @{
00051   */
00052 
00053 /** @addtogroup UARTEx
00054   * @{
00055   */
00056 
00057 /* Exported types ------------------------------------------------------------*/
00058 /** @defgroup UARTEx_Exported_Types UARTEx Exported Types
00059   * @{
00060   */
00061 
00062 /**
00063   * @brief  UART wake up from stop mode parameters
00064   */
00065 typedef struct
00066 {
00067   uint32_t WakeUpEvent;        /*!< Specifies which event will activat the Wakeup from Stop mode flag (WUF).
00068                                     This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.
00069                                     If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must
00070                                     be filled up. */
00071 
00072   uint16_t AddressLength;      /*!< Specifies whether the address is 4 or 7-bit long.
00073                                     This parameter can be a value of @ref UARTEx_WakeUp_Address_Length.  */
00074 
00075   uint8_t Address;             /*!< UART/USART node address (7-bit long max). */
00076 } UART_WakeUpTypeDef;
00077 
00078 /**
00079   * @}
00080   */
00081 
00082 /* Exported constants --------------------------------------------------------*/
00083 /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants
00084   * @{
00085   */
00086 
00087 /** @defgroup UARTEx_Word_Length UART Word Length
00088   * @{
00089   */
00090 #define UART_WORDLENGTH_7B                  ((uint32_t)USART_CR1_M1)   /*!< 7-bit long UART frame */
00091 #define UART_WORDLENGTH_8B                  ((uint32_t)0x00000000)     /*!< 8-bit long UART frame */
00092 #define UART_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M0)   /*!< 9-bit long UART frame */
00093 /**
00094   * @}
00095   */
00096 
00097 /** @defgroup UARTEx_WakeUp_Address_Length UART Extended WakeUp Address Length
00098   * @{
00099   */
00100 #define UART_ADDRESS_DETECT_4B              ((uint32_t)0x00000000)       /*!< 4-bit long wake-up address */
00101 #define UART_ADDRESS_DETECT_7B              ((uint32_t)USART_CR2_ADDM7)  /*!< 7-bit long wake-up address */
00102 /**
00103   * @}
00104   */
00105 
00106 /**
00107   * @}
00108   */
00109 
00110 /* Exported macros -----------------------------------------------------------*/
00111 /* Exported functions --------------------------------------------------------*/
00112 /** @addtogroup UARTEx_Exported_Functions
00113   * @{
00114   */
00115 
00116 /** @addtogroup UARTEx_Exported_Functions_Group1
00117   * @{
00118   */
00119 
00120 /* Initialization and de-initialization functions  ****************************/
00121 HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime);
00122 
00123 /**
00124   * @}
00125   */
00126 
00127 /* IO operation functions *****************************************************/
00128 
00129 /** @addtogroup UARTEx_Exported_Functions_Group3
00130   * @{
00131   */
00132 
00133 /* Peripheral Control functions  **********************************************/
00134 HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
00135 HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
00136 HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
00137 HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
00138 void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
00139 
00140 /**
00141   * @}
00142   */
00143 
00144 /**
00145   * @}
00146   */
00147 
00148 /* Private macros ------------------------------------------------------------*/
00149 /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
00150   * @{
00151   */
00152 
00153 /** @brief  Report the UART clock source.
00154   * @param  __HANDLE__: specifies the UART Handle.
00155   * @param  __CLOCKSOURCE__: output variable.
00156   * @retval UART clocking source, written in __CLOCKSOURCE__.
00157   */
00158 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
00159   do {                                                        \
00160     if((__HANDLE__)->Instance == USART1)                      \
00161     {                                                         \
00162        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
00163        {                                                      \
00164         case RCC_USART1CLKSOURCE_PCLK2:                       \
00165           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \
00166           break;                                              \
00167         case RCC_USART1CLKSOURCE_HSI:                         \
00168           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00169           break;                                              \
00170         case RCC_USART1CLKSOURCE_SYSCLK:                      \
00171           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00172           break;                                              \
00173         case RCC_USART1CLKSOURCE_LSE:                         \
00174           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00175           break;                                              \
00176         default:                                              \
00177           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00178           break;                                              \
00179        }                                                      \
00180     }                                                         \
00181     else if((__HANDLE__)->Instance == USART2)                 \
00182     {                                                         \
00183        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
00184        {                                                      \
00185         case RCC_USART2CLKSOURCE_PCLK1:                       \
00186           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
00187           break;                                              \
00188         case RCC_USART2CLKSOURCE_HSI:                         \
00189           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00190           break;                                              \
00191         case RCC_USART2CLKSOURCE_SYSCLK:                      \
00192           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00193           break;                                              \
00194         case RCC_USART2CLKSOURCE_LSE:                         \
00195           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00196           break;                                              \
00197         default:                                              \
00198           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00199           break;                                              \
00200        }                                                      \
00201     }                                                         \
00202     else if((__HANDLE__)->Instance == USART3)                 \
00203     {                                                         \
00204        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
00205        {                                                      \
00206         case RCC_USART3CLKSOURCE_PCLK1:                       \
00207           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
00208           break;                                              \
00209         case RCC_USART3CLKSOURCE_HSI:                         \
00210           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00211           break;                                              \
00212         case RCC_USART3CLKSOURCE_SYSCLK:                      \
00213           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00214           break;                                              \
00215         case RCC_USART3CLKSOURCE_LSE:                         \
00216           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00217           break;                                              \
00218         default:                                              \
00219           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00220           break;                                              \
00221        }                                                      \
00222     }                                                         \
00223     else if((__HANDLE__)->Instance == UART4)                  \
00224     {                                                         \
00225        switch(__HAL_RCC_GET_UART4_SOURCE())                   \
00226        {                                                      \
00227         case RCC_UART4CLKSOURCE_PCLK1:                        \
00228           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
00229           break;                                              \
00230         case RCC_UART4CLKSOURCE_HSI:                          \
00231           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00232           break;                                              \
00233         case RCC_UART4CLKSOURCE_SYSCLK:                       \
00234           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00235           break;                                              \
00236         case RCC_UART4CLKSOURCE_LSE:                          \
00237           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00238           break;                                              \
00239         default:                                              \
00240           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00241           break;                                              \
00242        }                                                      \
00243     }                                                         \
00244     else if ((__HANDLE__)->Instance == UART5)                 \
00245     {                                                         \
00246        switch(__HAL_RCC_GET_UART5_SOURCE())                   \
00247        {                                                      \
00248         case RCC_UART5CLKSOURCE_PCLK1:                        \
00249           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
00250           break;                                              \
00251         case RCC_UART5CLKSOURCE_HSI:                          \
00252           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00253           break;                                              \
00254         case RCC_UART5CLKSOURCE_SYSCLK:                       \
00255           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00256           break;                                              \
00257         case RCC_UART5CLKSOURCE_LSE:                          \
00258           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00259           break;                                              \
00260         default:                                              \
00261           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00262           break;                                              \
00263        }                                                      \
00264     }                                                         \
00265     else if((__HANDLE__)->Instance == LPUART1)                \
00266     {                                                         \
00267        switch(__HAL_RCC_GET_LPUART1_SOURCE())                 \
00268        {                                                      \
00269         case RCC_LPUART1CLKSOURCE_PCLK1:                      \
00270           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
00271           break;                                              \
00272         case RCC_LPUART1CLKSOURCE_HSI:                        \
00273           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
00274           break;                                              \
00275         case RCC_LPUART1CLKSOURCE_SYSCLK:                     \
00276           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
00277           break;                                              \
00278         case RCC_LPUART1CLKSOURCE_LSE:                        \
00279           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
00280           break;                                              \
00281         default:                                              \
00282           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
00283           break;                                              \
00284        }                                                      \
00285     }                                                         \
00286   } while(0)
00287 
00288 /** @brief  Report the UART mask to apply to retrieve the received data
00289   *         according to the word length and to the parity bits activation.
00290   * @note   If PCE = 1, the parity bit is not included in the data extracted
00291   *         by the reception API().
00292   *         This masking operation is not carried out in the case of
00293   *         DMA transfers.
00294   * @param  __HANDLE__: specifies the UART Handle.
00295   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
00296   */
00297 #define UART_MASK_COMPUTATION(__HANDLE__)                             \
00298   do {                                                                \
00299   if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)            \
00300   {                                                                   \
00301      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \
00302      {                                                                \
00303         (__HANDLE__)->Mask = 0x01FF ;                                 \
00304      }                                                                \
00305      else                                                             \
00306      {                                                                \
00307         (__HANDLE__)->Mask = 0x00FF ;                                 \
00308      }                                                                \
00309   }                                                                   \
00310   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)       \
00311   {                                                                   \
00312      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \
00313      {                                                                \
00314         (__HANDLE__)->Mask = 0x00FF ;                                 \
00315      }                                                                \
00316      else                                                             \
00317      {                                                                \
00318         (__HANDLE__)->Mask = 0x007F ;                                 \
00319      }                                                                \
00320   }                                                                   \
00321   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)       \
00322   {                                                                   \
00323      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \
00324      {                                                                \
00325         (__HANDLE__)->Mask = 0x007F ;                                 \
00326      }                                                                \
00327      else                                                             \
00328      {                                                                \
00329         (__HANDLE__)->Mask = 0x003F ;                                 \
00330      }                                                                \
00331   }                                                                   \
00332 } while(0)
00333 
00334 
00335 /**
00336   * @brief Ensure that UART frame length is valid.
00337   * @param __LENGTH__: UART frame length. 
00338   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
00339   */
00340 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
00341                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \
00342                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
00343 
00344 /**
00345   * @brief Ensure that UART wake-up address length is valid.
00346   * @param __ADDRESS__: UART wake-up address length. 
00347   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
00348   */
00349 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
00350                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
00351 
00352 /**
00353   * @}
00354   */
00355 
00356 /* Private functions ---------------------------------------------------------*/
00357 
00358 /**
00359   * @}
00360   */
00361 
00362 /**
00363   * @}
00364   */
00365 
00366 #ifdef __cplusplus
00367 }
00368 #endif
00369 
00370 #endif /* __STM32L4xx_HAL_UART_EX_H */
00371 
00372 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
00373