1 /** 2 ****************************************************************************** 3 * @file stm32l1xx_hal_uart.h 4 * @author MCD Application Team 5 * @brief This file contains all the functions prototypes for the UART 6 * firmware library. 7 ****************************************************************************** 8 * @attention 9 * 10 * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> 11 * 12 * Redistribution and use in source and binary forms, with or without modification, 13 * are permitted provided that the following conditions are met: 14 * 1. Redistributions of source code must retain the above copyright notice, 15 * this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright notice, 17 * this list of conditions and the following disclaimer in the documentation 18 * and/or other materials provided with the distribution. 19 * 3. Neither the name of STMicroelectronics nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 29 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 30 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 * 34 ****************************************************************************** 35 */ 36 37 /* Define to prevent recursive inclusion -------------------------------------*/ 38 #ifndef __STM32L1xx_HAL_UART_H 39 #define __STM32L1xx_HAL_UART_H 40 41 #ifdef __cplusplus 42 extern "C" { 43 #endif 44 45 /* Includes ------------------------------------------------------------------*/ 46 #include "stm32l1xx_hal_def.h" 47 48 /** @addtogroup STM32L1xx_HAL_Driver 49 * @{ 50 */ 51 52 /** @addtogroup UART 53 * @{ 54 */ 55 56 /* Exported types ------------------------------------------------------------*/ 57 /** @defgroup UART_Exported_Types UART Exported Types 58 * @{ 59 */ 60 61 62 /** 63 * @brief UART Init Structure definition 64 */ 65 typedef struct 66 { 67 uint32_t BaudRate; /*!< This member configures the UART communication baud rate. 68 The baud rate is computed using the following formula: 69 - IntegerDivider = ((PCLKx) / (8 * (OVR8+1) * (huart->Init.BaudRate))) 70 - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 8 * (OVR8+1)) + 0.5 71 Where OVR8 is the "oversampling by 8 mode" configuration bit in the CR1 register. */ 72 73 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 74 This parameter can be a value of @ref UART_Word_Length */ 75 76 uint32_t StopBits; /*!< Specifies the number of stop bits transmitted. 77 This parameter can be a value of @ref UART_Stop_Bits */ 78 79 uint32_t Parity; /*!< Specifies the parity mode. 80 This parameter can be a value of @ref UART_Parity 81 @note When parity is enabled, the computed parity is inserted 82 at the MSB position of the transmitted data (9th bit when 83 the word length is set to 9 data bits; 8th bit when the 84 word length is set to 8 data bits). */ 85 86 uint32_t Mode; /*!< Specifies wether the Receive or Transmit mode is enabled or disabled. 87 This parameter can be a value of @ref UART_Mode */ 88 89 uint32_t HwFlowCtl; /*!< Specifies wether the hardware flow control mode is enabled 90 or disabled. 91 This parameter can be a value of @ref UART_Hardware_Flow_Control */ 92 93 uint32_t OverSampling; /*!< Specifies wether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8). 94 This parameter can be a value of @ref UART_Over_Sampling */ 95 }UART_InitTypeDef; 96 97 /** 98 * @brief HAL UART State structures definition 99 */ 100 typedef enum 101 { 102 HAL_UART_STATE_RESET = 0x00, /*!< Peripheral is not initialized */ 103 HAL_UART_STATE_READY = 0x01, /*!< Peripheral Initialized and ready for use */ 104 HAL_UART_STATE_BUSY = 0x02, /*!< an internal process is ongoing */ 105 HAL_UART_STATE_BUSY_TX = 0x12, /*!< Data Transmission process is ongoing */ 106 HAL_UART_STATE_BUSY_RX = 0x22, /*!< Data Reception process is ongoing */ 107 HAL_UART_STATE_BUSY_TX_RX = 0x32, /*!< Data Transmission and Reception process is ongoing */ 108 HAL_UART_STATE_TIMEOUT = 0x03, /*!< Timeout state */ 109 HAL_UART_STATE_ERROR = 0x04 /*!< Error */ 110 }HAL_UART_StateTypeDef; 111 112 /** 113 * @brief UART handle Structure definition 114 */ 115 typedef struct 116 { 117 USART_TypeDef *Instance; /*!< UART registers base address */ 118 119 UART_InitTypeDef Init; /*!< UART communication parameters */ 120 121 uint8_t *pTxBuffPtr; /*!< Pointer to UART Tx transfer Buffer */ 122 123 uint16_t TxXferSize; /*!< UART Tx Transfer size */ 124 125 uint16_t TxXferCount; /*!< UART Tx Transfer Counter */ 126 127 uint8_t *pRxBuffPtr; /*!< Pointer to UART Rx transfer Buffer */ 128 129 uint16_t RxXferSize; /*!< UART Rx Transfer size */ 130 131 uint16_t RxXferCount; /*!< UART Rx Transfer Counter */ 132 133 DMA_HandleTypeDef *hdmatx; /*!< UART Tx DMA Handle parameters */ 134 135 DMA_HandleTypeDef *hdmarx; /*!< UART Rx DMA Handle parameters */ 136 137 HAL_LockTypeDef Lock; /*!< Locking object */ 138 139 __IO HAL_UART_StateTypeDef State; /*!< UART communication state */ 140 141 __IO uint32_t ErrorCode; /*!< UART Error code */ 142 143 }UART_HandleTypeDef; 144 145 /** 146 * @} 147 */ 148 149 /* Exported constants --------------------------------------------------------*/ 150 /** @defgroup UART_Exported_Constants UART Exported constants 151 * @{ 152 */ 153 154 /** @defgroup UART_Error_Codes UART Error Codes 155 * @{ 156 */ 157 158 #define HAL_UART_ERROR_NONE (0x00U) /*!< No error */ 159 #define HAL_UART_ERROR_PE (0x01U) /*!< Parity error */ 160 #define HAL_UART_ERROR_NE (0x02U) /*!< Noise error */ 161 #define HAL_UART_ERROR_FE (0x04U) /*!< frame error */ 162 #define HAL_UART_ERROR_ORE (0x08U) /*!< Overrun error */ 163 #define HAL_UART_ERROR_DMA (0x10U) /*!< DMA transfer error */ 164 165 /** 166 * @} 167 */ 168 169 /** @defgroup UART_Word_Length UART Word Length 170 * @{ 171 */ 172 #define UART_WORDLENGTH_8B (0x00000000U) 173 #define UART_WORDLENGTH_9B ((uint32_t)USART_CR1_M) 174 /** 175 * @} 176 */ 177 178 /** @defgroup UART_Stop_Bits UART Number of Stop Bits 179 * @{ 180 */ 181 #define UART_STOPBITS_1 (0x00000000U) 182 #define UART_STOPBITS_2 ((uint32_t)USART_CR2_STOP_1) 183 /** 184 * @} 185 */ 186 187 /** @defgroup UART_Parity UART Parity 188 * @{ 189 */ 190 #define UART_PARITY_NONE (0x00000000U) 191 #define UART_PARITY_EVEN ((uint32_t)USART_CR1_PCE) 192 #define UART_PARITY_ODD ((uint32_t)(USART_CR1_PCE | USART_CR1_PS)) 193 /** 194 * @} 195 */ 196 197 /** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control 198 * @{ 199 */ 200 #define UART_HWCONTROL_NONE (0x00000000U) 201 #define UART_HWCONTROL_RTS ((uint32_t)USART_CR3_RTSE) 202 #define UART_HWCONTROL_CTS ((uint32_t)USART_CR3_CTSE) 203 #define UART_HWCONTROL_RTS_CTS ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE)) 204 /** 205 * @} 206 */ 207 208 /** @defgroup UART_Mode UART Transfer Mode 209 * @{ 210 */ 211 #define UART_MODE_RX ((uint32_t)USART_CR1_RE) 212 #define UART_MODE_TX ((uint32_t)USART_CR1_TE) 213 #define UART_MODE_TX_RX ((uint32_t)(USART_CR1_TE |USART_CR1_RE)) 214 215 /** 216 * @} 217 */ 218 219 /** @defgroup UART_State UART State 220 * @{ 221 */ 222 #define UART_STATE_DISABLE (0x00000000U) 223 #define UART_STATE_ENABLE ((uint32_t)USART_CR1_UE) 224 /** 225 * @} 226 */ 227 228 /** @defgroup UART_Over_Sampling UART Over Sampling 229 * @{ 230 */ 231 #define UART_OVERSAMPLING_16 (0x00000000U) 232 #define UART_OVERSAMPLING_8 ((uint32_t)USART_CR1_OVER8) 233 /** 234 * @} 235 */ 236 237 /** @defgroup UART_LIN_Break_Detection_Length UART LIN Break Detection Length 238 * @{ 239 */ 240 #define UART_LINBREAKDETECTLENGTH_10B (0x00000000U) 241 #define UART_LINBREAKDETECTLENGTH_11B ((uint32_t)USART_CR2_LBDL) 242 /** 243 * @} 244 */ 245 246 /** @defgroup UART_WakeUp_functions UART Wakeup Functions 247 * @{ 248 */ 249 #define UART_WAKEUPMETHOD_IDLELINE (0x00000000U) 250 #define UART_WAKEUPMETHOD_ADDRESSMARK ((uint32_t)USART_CR1_WAKE) 251 /** 252 * @} 253 */ 254 255 /** @defgroup UART_Flags UART FLags 256 * Elements values convention: 0xXXXX 257 * - 0xXXXX : Flag mask in the SR register 258 * @{ 259 */ 260 #define UART_FLAG_CTS ((uint32_t)USART_SR_CTS) 261 #define UART_FLAG_LBD ((uint32_t)USART_SR_LBD) 262 #define UART_FLAG_TXE ((uint32_t)USART_SR_TXE) 263 #define UART_FLAG_TC ((uint32_t)USART_SR_TC) 264 #define UART_FLAG_RXNE ((uint32_t)USART_SR_RXNE) 265 #define UART_FLAG_IDLE ((uint32_t)USART_SR_IDLE) 266 #define UART_FLAG_ORE ((uint32_t)USART_SR_ORE) 267 #define UART_FLAG_NE ((uint32_t)USART_SR_NE) 268 #define UART_FLAG_FE ((uint32_t)USART_SR_FE) 269 #define UART_FLAG_PE ((uint32_t)USART_SR_PE) 270 /** 271 * @} 272 */ 273 274 /** @defgroup UART_Interrupt_definition UART Interrupt Definitions 275 * Elements values convention: 0xY000XXXX 276 * - XXXX : Interrupt mask (16 bits) in the Y register 277 * - Y : Interrupt source register (2bits) 278 * - 0001: CR1 register 279 * - 0010: CR2 register 280 * - 0011: CR3 register 281 * 282 * @{ 283 */ 284 285 #define UART_IT_PE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_PEIE)) 286 #define UART_IT_TXE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_TXEIE)) 287 #define UART_IT_TC ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_TCIE)) 288 #define UART_IT_RXNE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_RXNEIE)) 289 #define UART_IT_IDLE ((uint32_t)(UART_CR1_REG_INDEX << 28 | USART_CR1_IDLEIE)) 290 291 #define UART_IT_LBD ((uint32_t)(UART_CR2_REG_INDEX << 28 | USART_CR2_LBDIE)) 292 293 #define UART_IT_CTS ((uint32_t)(UART_CR3_REG_INDEX << 28 | USART_CR3_CTSIE)) 294 #define UART_IT_ERR ((uint32_t)(UART_CR3_REG_INDEX << 28 | USART_CR3_EIE)) 295 296 /** 297 * @} 298 */ 299 300 /** 301 * @} 302 */ 303 304 305 /* Exported macro ------------------------------------------------------------*/ 306 /** @defgroup UART_Exported_Macros UART Exported Macros 307 * @{ 308 */ 309 310 311 /** @brief Reset UART handle state 312 * @param __HANDLE__: specifies the UART Handle. 313 * UART Handle selects the USARTx or UARTy peripheral 314 * (USART,UART availability and x,y values depending on device). 315 * @retval None 316 */ 317 #define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_UART_STATE_RESET) 318 319 /** @brief Flush the UART DR register 320 * @param __HANDLE__: specifies the UART Handle. 321 * UART Handle selects the USARTx or UARTy peripheral 322 * (USART,UART availability and x,y values depending on device). 323 */ 324 #define __HAL_UART_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR) 325 326 /** @brief Check whether the specified UART flag is set or not. 327 * @param __HANDLE__: specifies the UART Handle. 328 * UART Handle selects the USARTx or UARTy peripheral 329 * (USART,UART availability and x,y values depending on device). 330 * @param __FLAG__: specifies the flag to check. 331 * This parameter can be one of the following values: 332 * @arg UART_FLAG_CTS: CTS Change flag (not available for UART4 and UART5) 333 * @arg UART_FLAG_LBD: LIN Break detection flag 334 * @arg UART_FLAG_TXE: Transmit data register empty flag 335 * @arg UART_FLAG_TC: Transmission Complete flag 336 * @arg UART_FLAG_RXNE: Receive data register not empty flag 337 * @arg UART_FLAG_IDLE: Idle Line detection flag 338 * @arg UART_FLAG_ORE: OverRun Error flag 339 * @arg UART_FLAG_NE: Noise Error flag 340 * @arg UART_FLAG_FE: Framing Error flag 341 * @arg UART_FLAG_PE: Parity Error flag 342 * @retval The new state of __FLAG__ (TRUE or FALSE). 343 */ 344 #define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__)) 345 346 /** @brief Clear the specified UART pending flag. 347 * @param __HANDLE__: specifies the UART Handle. 348 * UART Handle selects the USARTx or UARTy peripheral 349 * (USART,UART availability and x,y values depending on device). 350 * @param __FLAG__: specifies the flag to check. 351 * This parameter can be any combination of the following values: 352 * @arg UART_FLAG_CTS: CTS Change flag (not available for UART4 and UART5). 353 * @arg UART_FLAG_LBD: LIN Break detection flag. 354 * @arg UART_FLAG_TC: Transmission Complete flag. 355 * @arg UART_FLAG_RXNE: Receive data register not empty flag. 356 * 357 * @note PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun 358 * error) and IDLE (Idle line detected) flags are cleared by software 359 * sequence: a read operation to USART_SR register followed by a read 360 * operation to USART_DR register. 361 * @note RXNE flag can be also cleared by a read to the USART_DR register. 362 * @note TC flag can be also cleared by software sequence: a read operation to 363 * USART_SR register followed by a write operation to USART_DR register. 364 * @note TXE flag is cleared only by a write to the USART_DR register. 365 * 366 * @retval None 367 */ 368 #define __HAL_UART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__)) 369 370 /** @brief Clear the UART PE pending flag. 371 * @param __HANDLE__: specifies the UART Handle. 372 * UART Handle selects the USARTx or UARTy peripheral 373 * (USART,UART availability and x,y values depending on device). 374 * @retval None 375 */ 376 #define __HAL_UART_CLEAR_PEFLAG(__HANDLE__) \ 377 do{ \ 378 __IO uint32_t tmpreg; \ 379 tmpreg = (__HANDLE__)->Instance->SR; \ 380 tmpreg = (__HANDLE__)->Instance->DR; \ 381 UNUSED(tmpreg); \ 382 }while(0) 383 384 385 386 /** @brief Clear the UART FE pending flag. 387 * @param __HANDLE__: specifies the UART Handle. 388 * UART Handle selects the USARTx or UARTy peripheral 389 * (USART,UART availability and x,y values depending on device). 390 * @retval None 391 */ 392 #define __HAL_UART_CLEAR_FEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__) 393 394 /** @brief Clear the UART NE pending flag. 395 * @param __HANDLE__: specifies the UART Handle. 396 * UART Handle selects the USARTx or UARTy peripheral 397 * (USART,UART availability and x,y values depending on device). 398 * @retval None 399 */ 400 #define __HAL_UART_CLEAR_NEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__) 401 402 /** @brief Clear the UART ORE pending flag. 403 * @param __HANDLE__: specifies the UART Handle. 404 * UART Handle selects the USARTx or UARTy peripheral 405 * (USART,UART availability and x,y values depending on device). 406 * @retval None 407 */ 408 #define __HAL_UART_CLEAR_OREFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__) 409 410 /** @brief Clear the UART IDLE pending flag. 411 * @param __HANDLE__: specifies the UART Handle. 412 * UART Handle selects the USARTx or UARTy peripheral 413 * (USART,UART availability and x,y values depending on device). 414 * @retval None 415 */ 416 #define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__) 417 418 /** @brief Enable the specified UART interrupt. 419 * @param __HANDLE__: specifies the UART Handle. 420 * UART Handle selects the USARTx or UARTy peripheral 421 * (USART,UART availability and x,y values depending on device). 422 * @param __INTERRUPT__: specifies the UART interrupt source to enable. 423 * This parameter can be one of the following values: 424 * @arg UART_IT_CTS: CTS change interrupt 425 * @arg UART_IT_LBD: LIN Break detection interrupt 426 * @arg UART_IT_TXE: Transmit Data Register empty interrupt 427 * @arg UART_IT_TC: Transmission complete interrupt 428 * @arg UART_IT_RXNE: Receive Data register not empty interrupt 429 * @arg UART_IT_IDLE: Idle line detection interrupt 430 * @arg UART_IT_PE: Parity Error interrupt 431 * @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 432 * @retval None 433 */ 434 #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \ 435 (((__INTERRUPT__) >> 28) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \ 436 ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK))) 437 438 439 /** @brief Disable the specified UART interrupt. 440 * @param __HANDLE__: specifies the UART Handle. 441 * UART Handle selects the USARTx or UARTy peripheral 442 * (USART,UART availability and x,y values depending on device). 443 * @param __INTERRUPT__: specifies the UART interrupt source to disable. 444 * This parameter can be one of the following values: 445 * @arg UART_IT_CTS: CTS change interrupt 446 * @arg UART_IT_LBD: LIN Break detection interrupt 447 * @arg UART_IT_TXE: Transmit Data Register empty interrupt 448 * @arg UART_IT_TC: Transmission complete interrupt 449 * @arg UART_IT_RXNE: Receive Data register not empty interrupt 450 * @arg UART_IT_IDLE: Idle line detection interrupt 451 * @arg UART_IT_PE: Parity Error interrupt 452 * @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 453 * @retval None 454 */ 455 #define __HAL_UART_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & UART_IT_MASK)): \ 456 (((__INTERRUPT__) >> 28) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 &= ~((__INTERRUPT__) & UART_IT_MASK)): \ 457 ((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & UART_IT_MASK))) 458 459 /** @brief Check whether the specified UART interrupt has occurred or not. 460 * @param __HANDLE__: specifies the UART Handle. 461 * UART Handle selects the USARTx or UARTy peripheral 462 * (USART,UART availability and x,y values depending on device). 463 * @param __IT__: specifies the UART interrupt source to check. 464 * This parameter can be one of the following values: 465 * @arg UART_IT_CTS: CTS change interrupt (not available for UART4 and UART5) 466 * @arg UART_IT_LBD: LIN Break detection interrupt 467 * @arg UART_IT_TXE: Transmit Data Register empty interrupt 468 * @arg UART_IT_TC: Transmission complete interrupt 469 * @arg UART_IT_RXNE: Receive Data register not empty interrupt 470 * @arg UART_IT_IDLE: Idle line detection interrupt 471 * @arg UART_IT_ERR: Error interrupt 472 * @retval The new state of __IT__ (TRUE or FALSE). 473 */ 474 #define __HAL_UART_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28) == UART_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1:(((((uint32_t)(__IT__)) >> 28) == UART_CR2_REG_INDEX)? \ 475 (__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & (((uint32_t)(__IT__)) & UART_IT_MASK)) 476 477 /** @brief macros to enables or disables the UART's one bit sampling method 478 * @param __HANDLE__: specifies the UART Handle. 479 * This parameter can be USARTx with x: 1, 2 or 3, or UARTy with y:4 or 5 to select the USART or 480 * UART peripheral (availability depending on device for UARTy). 481 * @retval None 482 */ 483 #define __HAL_UART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT) 484 #define __HAL_UART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_ONEBIT)) 485 486 /** @brief Enable CTS flow control 487 * This macro allows to enable CTS hardware flow control for a given UART instance, 488 * without need to call HAL_UART_Init() function. 489 * As involving direct access to UART registers, usage of this macro should be fully endorsed by user. 490 * @note As macro is expected to be used for modifying CTS Hw flow control feature activation, without need 491 * for USART instance Deinit/Init, following conditions for macro call should be fulfilled : 492 * - UART instance should have already been initialised (through call of HAL_UART_Init() ) 493 * - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__)) 494 * and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). 495 * @param __HANDLE__: specifies the UART Handle. 496 * This parameter can be any USARTx (supporting the HW Flow control feature). 497 * It is used to select the USART peripheral (USART availability and x value depending on device). 498 * @retval None 499 */ 500 #define __HAL_UART_HWCONTROL_CTS_ENABLE(__HANDLE__) \ 501 do{ \ 502 SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \ 503 (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_CTSE; \ 504 } while(0) 505 506 /** @brief Disable CTS flow control 507 * This macro allows to disable CTS hardware flow control for a given UART instance, 508 * without need to call HAL_UART_Init() function. 509 * As involving direct access to UART registers, usage of this macro should be fully endorsed by user. 510 * @note As macro is expected to be used for modifying CTS Hw flow control feature activation, without need 511 * for USART instance Deinit/Init, following conditions for macro call should be fulfilled : 512 * - UART instance should have already been initialised (through call of HAL_UART_Init() ) 513 * - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__)) 514 * and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). 515 * @param __HANDLE__: specifies the UART Handle. 516 * This parameter can be any USARTx (supporting the HW Flow control feature). 517 * It is used to select the USART peripheral (USART availability and x value depending on device). 518 * @retval None 519 */ 520 #define __HAL_UART_HWCONTROL_CTS_DISABLE(__HANDLE__) \ 521 do{ \ 522 CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \ 523 (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_CTSE); \ 524 } while(0) 525 526 /** @brief Enable RTS flow control 527 * This macro allows to enable RTS hardware flow control for a given UART instance, 528 * without need to call HAL_UART_Init() function. 529 * As involving direct access to UART registers, usage of this macro should be fully endorsed by user. 530 * @note As macro is expected to be used for modifying RTS Hw flow control feature activation, without need 531 * for USART instance Deinit/Init, following conditions for macro call should be fulfilled : 532 * - UART instance should have already been initialised (through call of HAL_UART_Init() ) 533 * - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__)) 534 * and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). 535 * @param __HANDLE__: specifies the UART Handle. 536 * This parameter can be any USARTx (supporting the HW Flow control feature). 537 * It is used to select the USART peripheral (USART availability and x value depending on device). 538 * @retval None 539 */ 540 #define __HAL_UART_HWCONTROL_RTS_ENABLE(__HANDLE__) \ 541 do{ \ 542 SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE); \ 543 (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_RTSE; \ 544 } while(0) 545 546 /** @brief Disable RTS flow control 547 * This macro allows to disable RTS hardware flow control for a given UART instance, 548 * without need to call HAL_UART_Init() function. 549 * As involving direct access to UART registers, usage of this macro should be fully endorsed by user. 550 * @note As macro is expected to be used for modifying RTS Hw flow control feature activation, without need 551 * for USART instance Deinit/Init, following conditions for macro call should be fulfilled : 552 * - UART instance should have already been initialised (through call of HAL_UART_Init() ) 553 * - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__)) 554 * and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). 555 * @param __HANDLE__: specifies the UART Handle. 556 * This parameter can be any USARTx (supporting the HW Flow control feature). 557 * It is used to select the USART peripheral (USART availability and x value depending on device). 558 * @retval None 559 */ 560 #define __HAL_UART_HWCONTROL_RTS_DISABLE(__HANDLE__) \ 561 do{ \ 562 CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE);\ 563 (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_RTSE); \ 564 } while(0) 565 566 567 /** @brief Enable UART 568 * @param __HANDLE__: specifies the UART Handle. 569 * UART Handle selects the USARTx or UARTy peripheral 570 * (USART,UART availability and x,y values depending on device). 571 * @retval None 572 */ 573 #define __HAL_UART_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE) 574 575 /** @brief Disable UART 576 * UART Handle selects the USARTx or UARTy peripheral 577 * (USART,UART availability and x,y values depending on device). 578 * @retval None 579 */ 580 #define __HAL_UART_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE) 581 582 /** 583 * @} 584 */ 585 586 587 /* Private macros --------------------------------------------------------*/ 588 /** @defgroup UART_Private_Macros UART Private Macros 589 * @{ 590 */ 591 592 #define UART_CR1_REG_INDEX 1 593 #define UART_CR2_REG_INDEX 2 594 #define UART_CR3_REG_INDEX 3 595 596 #define UART_DIV_SAMPLING16(_PCLK_, _BAUD_) (((_PCLK_)*25)/(4*(_BAUD_))) 597 #define UART_DIVMANT_SAMPLING16(_PCLK_, _BAUD_) (UART_DIV_SAMPLING16((_PCLK_), (_BAUD_))/100) 598 #define UART_DIVFRAQ_SAMPLING16(_PCLK_, _BAUD_) (((UART_DIV_SAMPLING16((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) * 100)) * 16 + 50) / 100) 599 /* UART BRR = mantissa + overflow + fraction 600 = (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0F) */ 601 #define UART_BRR_SAMPLING16(_PCLK_, _BAUD_) (((UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) << 4) + \ 602 (UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0xF0)) + \ 603 (UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0x0F)) 604 #define UART_DIV_SAMPLING8(_PCLK_, _BAUD_) (((_PCLK_)*25)/(2*(_BAUD_))) 605 #define UART_DIVMANT_SAMPLING8(_PCLK_, _BAUD_) (UART_DIV_SAMPLING8((_PCLK_), (_BAUD_))/100) 606 #define UART_DIVFRAQ_SAMPLING8(_PCLK_, _BAUD_) (((UART_DIV_SAMPLING8((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) * 100)) * 8 + 50) / 100) 607 /* UART BRR = mantissa + overflow + fraction 608 = (UART DIVMANT << 4) + ((UART DIVFRAQ & 0xF8) << 1) + (UART DIVFRAQ & 0x07) */ 609 #define UART_BRR_SAMPLING8(_PCLK_, _BAUD_) (((UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) << 4) + \ 610 ((UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0xF8) << 1)) + \ 611 (UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0x07)) 612 #define IS_UART_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B) || \ 613 ((LENGTH) == UART_WORDLENGTH_9B)) 614 #define IS_UART_LIN_WORD_LENGTH(LENGTH) ((LENGTH) == UART_WORDLENGTH_8B) 615 616 #define IS_UART_STOPBITS(STOPBITS) (((STOPBITS) == UART_STOPBITS_1) || \ 617 ((STOPBITS) == UART_STOPBITS_2)) 618 619 #define IS_UART_PARITY(PARITY) (((PARITY) == UART_PARITY_NONE) || \ 620 ((PARITY) == UART_PARITY_EVEN) || \ 621 ((PARITY) == UART_PARITY_ODD)) 622 623 #define IS_UART_HARDWARE_FLOW_CONTROL(CONTROL)\ 624 (((CONTROL) == UART_HWCONTROL_NONE) || \ 625 ((CONTROL) == UART_HWCONTROL_RTS) || \ 626 ((CONTROL) == UART_HWCONTROL_CTS) || \ 627 ((CONTROL) == UART_HWCONTROL_RTS_CTS)) 628 629 #define IS_UART_MODE(MODE) ((((MODE) & (~((uint32_t)UART_MODE_TX_RX))) == 0x00U) && \ 630 ((MODE) != 0x00000000U)) 631 632 #define IS_UART_STATE(STATE) (((STATE) == UART_STATE_DISABLE) || \ 633 ((STATE) == UART_STATE_ENABLE)) 634 635 #define IS_UART_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16) || \ 636 ((SAMPLING) == UART_OVERSAMPLING_8)) 637 #define IS_UART_LIN_OVERSAMPLING(SAMPLING) ((SAMPLING) == UART_OVERSAMPLING_16) 638 639 #define IS_UART_LIN_BREAK_DETECT_LENGTH(LENGTH) (((LENGTH) == UART_LINBREAKDETECTLENGTH_10B) || \ 640 ((LENGTH) == UART_LINBREAKDETECTLENGTH_11B)) 641 642 #define IS_UART_WAKEUPMETHOD(WAKEUP) (((WAKEUP) == UART_WAKEUPMETHOD_IDLELINE) || \ 643 ((WAKEUP) == UART_WAKEUPMETHOD_ADDRESSMARK)) 644 645 646 /** Check UART Baud rate 647 * __BAUDRATE__: Baudrate specified by the user 648 * The maximum Baud Rate is derived from the maximum clock on APB (i.e. 32 MHz) 649 * divided by the smallest oversampling used on the USART (i.e. 8) 650 * Return : TRUE or FALSE 651 */ 652 #define IS_UART_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 4000001) 653 654 /** Check UART Node Address 655 * __ADDRESS__: UART Node address specified by the user 656 * UART Node address is used in Multi processor communication for wakeup 657 * with address mark detection. 658 * This parameter must be a number between Min_Data = 0 and Max_Data = 15 659 * Return : TRUE or FALSE 660 */ 661 #define IS_UART_ADDRESS(__ADDRESS__) ((__ADDRESS__) <= 0xF) 662 663 /** UART interruptions flag mask 664 */ 665 #define UART_IT_MASK ((uint32_t) USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE | USART_CR1_RXNEIE | \ 666 USART_CR1_IDLEIE | USART_CR2_LBDIE | USART_CR3_CTSIE | USART_CR3_EIE ) 667 668 /** 669 * @} 670 */ 671 672 /* Exported functions --------------------------------------------------------*/ 673 674 /** @addtogroup UART_Exported_Functions UART Exported Functions 675 * @{ 676 */ 677 678 /** @addtogroup UART_Exported_Functions_Group1 Initialization and de-initialization functions 679 * @{ 680 */ 681 682 /* Initialization and de-initialization functions ****************************/ 683 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); 684 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart); 685 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength); 686 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod); 687 HAL_StatusTypeDef HAL_UART_DeInit (UART_HandleTypeDef *huart); 688 void HAL_UART_MspInit(UART_HandleTypeDef *huart); 689 void HAL_UART_MspDeInit(UART_HandleTypeDef *huart); 690 691 /** 692 * @} 693 */ 694 695 /** @addtogroup UART_Exported_Functions_Group2 IO operation functions 696 * @{ 697 */ 698 699 /* IO operation functions *****************************************************/ 700 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); 701 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); 702 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); 703 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); 704 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); 705 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); 706 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart); 707 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart); 708 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart); 709 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart); 710 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); 711 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart); 712 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); 713 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart); 714 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart); 715 716 /** 717 * @} 718 */ 719 720 /** @addtogroup UART_Exported_Functions_Group3 Peripheral Control functions 721 * @{ 722 */ 723 724 /* Peripheral Control functions ************************************************/ 725 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart); 726 HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart); 727 HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart); 728 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart); 729 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart); 730 731 /** 732 * @} 733 */ 734 735 /** @addtogroup UART_Exported_Functions_Group4 Peripheral State and Errors functions 736 * @{ 737 */ 738 739 /* Peripheral State and Errors functions **************************************************/ 740 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart); 741 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart); 742 743 /** 744 * @} 745 */ 746 747 /** 748 * @} 749 */ 750 751 /** 752 * @} 753 */ 754 755 /** 756 * @} 757 */ 758 759 #ifdef __cplusplus 760 } 761 #endif 762 763 #endif /* __STM32L1xx_HAL_UART_H */ 764 765 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 766
