1 /** 2 ****************************************************************************** 3 * @file stm32l1xx_hal_smartcard.h 4 * @author MCD Application Team 5 * @version V1.2.0 6 * @date 01-July-2016 7 * @brief This file contains all the functions prototypes for the SMARTCARD 8 * firmware library. 9 ****************************************************************************** 10 * @attention 11 * 12 * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2> 13 * 14 * Redistribution and use in source and binary forms, with or without modification, 15 * are permitted provided that the following conditions are met: 16 * 1. Redistributions of source code must retain the above copyright notice, 17 * this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright notice, 19 * this list of conditions and the following disclaimer in the documentation 20 * and/or other materials provided with the distribution. 21 * 3. Neither the name of STMicroelectronics nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 31 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 32 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 33 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35 * 36 ****************************************************************************** 37 */ 38 39 /* Define to prevent recursive inclusion -------------------------------------*/ 40 #ifndef __STM32L1xx_HAL_SMARTCARD_H 41 #define __STM32L1xx_HAL_SMARTCARD_H 42 43 #ifdef __cplusplus 44 extern "C" { 45 #endif 46 47 /* Includes ------------------------------------------------------------------*/ 48 #include "stm32l1xx_hal_def.h" 49 50 /** @addtogroup STM32L1xx_HAL_Driver 51 * @{ 52 */ 53 54 /** @addtogroup SMARTCARD 55 * @{ 56 */ 57 58 /* Exported types ------------------------------------------------------------*/ 59 /** @defgroup SMARTCARD_Exported_Types SMARTCARD Exported Types 60 * @{ 61 */ 62 63 64 /** 65 * @brief SMARTCARD Init Structure definition 66 */ 67 typedef struct 68 { 69 uint32_t BaudRate; /*!< This member configures the SmartCard communication baud rate. 70 The baud rate is computed using the following formula: 71 - IntegerDivider = ((PCLKx) / (16 * (hsmartcard->Init.BaudRate))) 72 - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */ 73 74 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 75 This parameter can be a value of @ref SMARTCARD_Word_Length */ 76 77 uint32_t StopBits; /*!< Specifies the number of stop bits transmitted. 78 This parameter can be a value of @ref SMARTCARD_Stop_Bits */ 79 80 uint32_t Parity; /*!< Specifies the parity mode. 81 This parameter can be a value of @ref SMARTCARD_Parity 82 @note When parity is enabled, the computed parity is inserted 83 at the MSB position of the transmitted data (9th bit when 84 the word length is set to 9 data bits; 8th bit when the 85 word length is set to 8 data bits).*/ 86 87 uint32_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled. 88 This parameter can be a value of @ref SMARTCARD_Mode */ 89 90 uint32_t CLKPolarity; /*!< Specifies the steady state of the serial clock. 91 This parameter can be a value of @ref SMARTCARD_Clock_Polarity */ 92 93 uint32_t CLKPhase; /*!< Specifies the clock transition on which the bit capture is made. 94 This parameter can be a value of @ref SMARTCARD_Clock_Phase */ 95 96 uint32_t CLKLastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted 97 data bit (MSB) has to be output on the SCLK pin in synchronous mode. 98 This parameter can be a value of @ref SMARTCARD_Last_Bit */ 99 100 uint32_t Prescaler; /*!< Specifies the SmartCard Prescaler value used for dividing the system clock 101 to provide the smartcard clock. The value given in the register 102 (5 significant bits) is multiplied by 2 to give the division factor of 103 the source clock frequency; 104 This parameter can be a value of @ref SMARTCARD_Prescaler */ 105 106 uint32_t GuardTime; /*!< Specifies the SmartCard Guard Time value in terms of number 107 of baud clocks */ 108 109 uint32_t NACKState; /*!< Specifies the SmartCard NACK Transmission state 110 This parameter can be a value of @ref SMARTCARD_NACK_State */ 111 }SMARTCARD_InitTypeDef; 112 113 /** 114 * @brief HAL State structures definition 115 */ 116 typedef enum 117 { 118 HAL_SMARTCARD_STATE_RESET = 0x00, /*!< Peripheral is not yet Initialized */ 119 HAL_SMARTCARD_STATE_READY = 0x01, /*!< Peripheral Initialized and ready for use */ 120 HAL_SMARTCARD_STATE_BUSY = 0x02, /*!< an internal process is ongoing */ 121 HAL_SMARTCARD_STATE_BUSY_TX = 0x12, /*!< Data Transmission process is ongoing */ 122 HAL_SMARTCARD_STATE_BUSY_RX = 0x22, /*!< Data Reception process is ongoing */ 123 HAL_SMARTCARD_STATE_BUSY_TX_RX = 0x32, /*!< Data Transmission and Reception process is ongoing */ 124 HAL_SMARTCARD_STATE_TIMEOUT = 0x03, /*!< Timeout state */ 125 HAL_SMARTCARD_STATE_ERROR = 0x04 /*!< Error */ 126 }HAL_SMARTCARD_StateTypeDef; 127 128 129 /** 130 * @brief SMARTCARD handle Structure definition 131 */ 132 typedef struct 133 { 134 USART_TypeDef *Instance; /*!< USART registers base address */ 135 136 SMARTCARD_InitTypeDef Init; /*!< SmartCard communication parameters */ 137 138 uint8_t *pTxBuffPtr; /*!< Pointer to SmartCard Tx transfer Buffer */ 139 140 uint16_t TxXferSize; /*!< SmartCard Tx Transfer size */ 141 142 uint16_t TxXferCount; /*!< SmartCard Tx Transfer Counter */ 143 144 uint8_t *pRxBuffPtr; /*!< Pointer to SmartCard Rx transfer Buffer */ 145 146 uint16_t RxXferSize; /*!< SmartCard Rx Transfer size */ 147 148 uint16_t RxXferCount; /*!< SmartCard Rx Transfer Counter */ 149 150 DMA_HandleTypeDef *hdmatx; /*!< SmartCard Tx DMA Handle parameters */ 151 152 DMA_HandleTypeDef *hdmarx; /*!< SmartCard Rx DMA Handle parameters */ 153 154 HAL_LockTypeDef Lock; /*!< Locking object */ 155 156 __IO HAL_SMARTCARD_StateTypeDef State; /*!< SmartCard communication state */ 157 158 __IO uint32_t ErrorCode; /*!< SmartCard Error code */ 159 }SMARTCARD_HandleTypeDef; 160 161 /** 162 * @} 163 */ 164 165 /* Exported constants --------------------------------------------------------*/ 166 /** @defgroup SMARTCARD_Exported_Constants SMARTCARD Exported constants 167 * @{ 168 */ 169 170 /** @defgroup SMARTCARD_Error_Codes SMARTCARD Error Codes 171 * @{ 172 */ 173 #define HAL_SMARTCARD_ERROR_NONE ((uint32_t)0x00) /*!< No error */ 174 #define HAL_SMARTCARD_ERROR_PE ((uint32_t)0x01) /*!< Parity error */ 175 #define HAL_SMARTCARD_ERROR_NE ((uint32_t)0x02) /*!< Noise error */ 176 #define HAL_SMARTCARD_ERROR_FE ((uint32_t)0x04) /*!< frame error */ 177 #define HAL_SMARTCARD_ERROR_ORE ((uint32_t)0x08) /*!< Overrun error */ 178 #define HAL_SMARTCARD_ERROR_DMA ((uint32_t)0x10) /*!< DMA transfer error */ 179 180 /** 181 * @} 182 */ 183 184 185 /** @defgroup SMARTCARD_Word_Length SMARTCARD Word Length 186 * @{ 187 */ 188 #define SMARTCARD_WORDLENGTH_9B ((uint32_t)USART_CR1_M) 189 190 /** 191 * @} 192 */ 193 194 /** @defgroup SMARTCARD_Stop_Bits SMARTCARD Number of Stop Bits 195 * @{ 196 */ 197 #define SMARTCARD_STOPBITS_0_5 ((uint32_t)USART_CR2_STOP_0) 198 #define SMARTCARD_STOPBITS_1_5 ((uint32_t)(USART_CR2_STOP_0 | USART_CR2_STOP_1)) 199 /** 200 * @} 201 */ 202 203 /** @defgroup SMARTCARD_Parity SMARTCARD Parity 204 * @{ 205 */ 206 #define SMARTCARD_PARITY_EVEN ((uint32_t)USART_CR1_PCE) 207 #define SMARTCARD_PARITY_ODD ((uint32_t)(USART_CR1_PCE | USART_CR1_PS)) 208 /** 209 * @} 210 */ 211 212 /** @defgroup SMARTCARD_Mode SMARTCARD Mode 213 * @{ 214 */ 215 #define SMARTCARD_MODE_RX ((uint32_t)USART_CR1_RE) 216 #define SMARTCARD_MODE_TX ((uint32_t)USART_CR1_TE) 217 #define SMARTCARD_MODE_TX_RX ((uint32_t)(USART_CR1_TE |USART_CR1_RE)) 218 /** 219 * @} 220 */ 221 222 /** @defgroup SMARTCARD_Clock_Polarity SMARTCARD Clock Polarity 223 * @{ 224 */ 225 #define SMARTCARD_POLARITY_LOW ((uint32_t)0x00000000) 226 #define SMARTCARD_POLARITY_HIGH ((uint32_t)USART_CR2_CPOL) 227 /** 228 * @} 229 */ 230 231 /** @defgroup SMARTCARD_Clock_Phase SMARTCARD Clock Phase 232 * @{ 233 */ 234 #define SMARTCARD_PHASE_1EDGE ((uint32_t)0x00000000) 235 #define SMARTCARD_PHASE_2EDGE ((uint32_t)USART_CR2_CPHA) 236 /** 237 * @} 238 */ 239 240 /** @defgroup SMARTCARD_Last_Bit SMARTCARD Last Bit 241 * @{ 242 */ 243 #define SMARTCARD_LASTBIT_DISABLE ((uint32_t)0x00000000) 244 #define SMARTCARD_LASTBIT_ENABLE ((uint32_t)USART_CR2_LBCL) 245 /** 246 * @} 247 */ 248 249 /** @defgroup SMARTCARD_OneBit_Sampling SMARTCARD One Bit Sampling Method 250 * @{ 251 */ 252 #define SMARTCARD_ONE_BIT_SAMPLE_DISABLE ((uint32_t)0x00000000) 253 #define SMARTCARD_ONE_BIT_SAMPLE_ENABLE ((uint32_t)USART_CR3_ONEBIT) 254 /** 255 * @} 256 */ 257 258 /** @defgroup SMARTCARD_NACK_State SMARTCARD NACK State 259 * @{ 260 */ 261 #define SMARTCARD_NACK_ENABLE ((uint32_t)USART_CR3_NACK) 262 #define SMARTCARD_NACK_DISABLE ((uint32_t)0x00000000) 263 /** 264 * @} 265 */ 266 267 /** @defgroup SMARTCARD_DMA_Requests SMARTCARD DMA requests 268 * @{ 269 */ 270 271 #define SMARTCARD_DMAREQ_TX ((uint32_t)USART_CR3_DMAT) 272 #define SMARTCARD_DMAREQ_RX ((uint32_t)USART_CR3_DMAR) 273 274 /** 275 * @} 276 */ 277 278 /** @defgroup SMARTCARD_Prescaler SMARTCARD Prescaler 279 * @{ 280 */ 281 #define SMARTCARD_PRESCALER_SYSCLK_DIV2 ((uint32_t)0x00000001) /*!< SYSCLK divided by 2 */ 282 #define SMARTCARD_PRESCALER_SYSCLK_DIV4 ((uint32_t)0x00000002) /*!< SYSCLK divided by 4 */ 283 #define SMARTCARD_PRESCALER_SYSCLK_DIV6 ((uint32_t)0x00000003) /*!< SYSCLK divided by 6 */ 284 #define SMARTCARD_PRESCALER_SYSCLK_DIV8 ((uint32_t)0x00000004) /*!< SYSCLK divided by 8 */ 285 #define SMARTCARD_PRESCALER_SYSCLK_DIV10 ((uint32_t)0x00000005) /*!< SYSCLK divided by 10 */ 286 #define SMARTCARD_PRESCALER_SYSCLK_DIV12 ((uint32_t)0x00000006) /*!< SYSCLK divided by 12 */ 287 #define SMARTCARD_PRESCALER_SYSCLK_DIV14 ((uint32_t)0x00000007) /*!< SYSCLK divided by 14 */ 288 #define SMARTCARD_PRESCALER_SYSCLK_DIV16 ((uint32_t)0x00000008) /*!< SYSCLK divided by 16 */ 289 #define SMARTCARD_PRESCALER_SYSCLK_DIV18 ((uint32_t)0x00000009) /*!< SYSCLK divided by 18 */ 290 #define SMARTCARD_PRESCALER_SYSCLK_DIV20 ((uint32_t)0x0000000A) /*!< SYSCLK divided by 20 */ 291 #define SMARTCARD_PRESCALER_SYSCLK_DIV22 ((uint32_t)0x0000000B) /*!< SYSCLK divided by 22 */ 292 #define SMARTCARD_PRESCALER_SYSCLK_DIV24 ((uint32_t)0x0000000C) /*!< SYSCLK divided by 24 */ 293 #define SMARTCARD_PRESCALER_SYSCLK_DIV26 ((uint32_t)0x0000000D) /*!< SYSCLK divided by 26 */ 294 #define SMARTCARD_PRESCALER_SYSCLK_DIV28 ((uint32_t)0x0000000E) /*!< SYSCLK divided by 28 */ 295 #define SMARTCARD_PRESCALER_SYSCLK_DIV30 ((uint32_t)0x0000000F) /*!< SYSCLK divided by 30 */ 296 #define SMARTCARD_PRESCALER_SYSCLK_DIV32 ((uint32_t)0x00000010) /*!< SYSCLK divided by 32 */ 297 #define SMARTCARD_PRESCALER_SYSCLK_DIV34 ((uint32_t)0x00000011) /*!< SYSCLK divided by 34 */ 298 #define SMARTCARD_PRESCALER_SYSCLK_DIV36 ((uint32_t)0x00000012) /*!< SYSCLK divided by 36 */ 299 #define SMARTCARD_PRESCALER_SYSCLK_DIV38 ((uint32_t)0x00000013) /*!< SYSCLK divided by 38 */ 300 #define SMARTCARD_PRESCALER_SYSCLK_DIV40 ((uint32_t)0x00000014) /*!< SYSCLK divided by 40 */ 301 #define SMARTCARD_PRESCALER_SYSCLK_DIV42 ((uint32_t)0x00000015) /*!< SYSCLK divided by 42 */ 302 #define SMARTCARD_PRESCALER_SYSCLK_DIV44 ((uint32_t)0x00000016) /*!< SYSCLK divided by 44 */ 303 #define SMARTCARD_PRESCALER_SYSCLK_DIV46 ((uint32_t)0x00000017) /*!< SYSCLK divided by 46 */ 304 #define SMARTCARD_PRESCALER_SYSCLK_DIV48 ((uint32_t)0x00000018) /*!< SYSCLK divided by 48 */ 305 #define SMARTCARD_PRESCALER_SYSCLK_DIV50 ((uint32_t)0x00000019) /*!< SYSCLK divided by 50 */ 306 #define SMARTCARD_PRESCALER_SYSCLK_DIV52 ((uint32_t)0x0000001A) /*!< SYSCLK divided by 52 */ 307 #define SMARTCARD_PRESCALER_SYSCLK_DIV54 ((uint32_t)0x0000001B) /*!< SYSCLK divided by 54 */ 308 #define SMARTCARD_PRESCALER_SYSCLK_DIV56 ((uint32_t)0x0000001C) /*!< SYSCLK divided by 56 */ 309 #define SMARTCARD_PRESCALER_SYSCLK_DIV58 ((uint32_t)0x0000001D) /*!< SYSCLK divided by 58 */ 310 #define SMARTCARD_PRESCALER_SYSCLK_DIV60 ((uint32_t)0x0000001E) /*!< SYSCLK divided by 60 */ 311 #define SMARTCARD_PRESCALER_SYSCLK_DIV62 ((uint32_t)0x0000001F) /*!< SYSCLK divided by 62 */ 312 /** 313 * @} 314 */ 315 316 317 318 /** @defgroup SMARTCARD_Flags SMARTCARD Flags 319 * Elements values convention: 0xXXXX 320 * - 0xXXXX : Flag mask in the SR register 321 * @{ 322 */ 323 324 #define SMARTCARD_FLAG_TXE ((uint32_t)USART_SR_TXE) 325 #define SMARTCARD_FLAG_TC ((uint32_t)USART_SR_TC) 326 #define SMARTCARD_FLAG_RXNE ((uint32_t)USART_SR_RXNE) 327 #define SMARTCARD_FLAG_IDLE ((uint32_t)USART_SR_IDLE) 328 #define SMARTCARD_FLAG_ORE ((uint32_t)USART_SR_ORE) 329 #define SMARTCARD_FLAG_NE ((uint32_t)USART_SR_NE) 330 #define SMARTCARD_FLAG_FE ((uint32_t)USART_SR_FE) 331 #define SMARTCARD_FLAG_PE ((uint32_t)USART_SR_PE) 332 /** 333 * @} 334 */ 335 336 /** @defgroup SMARTCARD_Interrupt_definition SMARTCARD Interrupts Definition 337 * Elements values convention: 0xY000XXXX 338 * - XXXX : Interrupt mask (16 bits) in the Y register 339 * - Y : Interrupt source register (4 bits) 340 * - 0001: CR1 register 341 * - 0010: CR3 register 342 343 * 344 * @{ 345 */ 346 347 #define SMARTCARD_IT_PE ((uint32_t)(SMARTCARD_CR1_REG_INDEX << 28 | USART_CR1_PEIE)) 348 #define SMARTCARD_IT_TXE ((uint32_t)(SMARTCARD_CR1_REG_INDEX << 28 | USART_CR1_TXEIE)) 349 #define SMARTCARD_IT_TC ((uint32_t)(SMARTCARD_CR1_REG_INDEX << 28 | USART_CR1_TCIE)) 350 #define SMARTCARD_IT_RXNE ((uint32_t)(SMARTCARD_CR1_REG_INDEX << 28 | USART_CR1_RXNEIE)) 351 #define SMARTCARD_IT_IDLE ((uint32_t)(SMARTCARD_CR1_REG_INDEX << 28 | USART_CR1_IDLEIE)) 352 #define SMARTCARD_IT_ERR ((uint32_t)(SMARTCARD_CR3_REG_INDEX << 28 | USART_CR3_EIE)) 353 354 /** 355 * @} 356 */ 357 358 /** 359 * @} 360 */ 361 362 363 /* Exported macro ------------------------------------------------------------*/ 364 /** @defgroup SMARTCARD_Exported_Macros SMARTCARD Exported Macros 365 * @{ 366 */ 367 368 369 /** @brief Reset SMARTCARD handle state 370 * @param __HANDLE__: specifies the SMARTCARD Handle. 371 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 372 * @retval None 373 */ 374 #define __HAL_SMARTCARD_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_SMARTCARD_STATE_RESET) 375 376 /** @brief Flush the Smartcard DR register 377 * @param __HANDLE__: specifies the SMARTCARD Handle. 378 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 379 * @retval None 380 */ 381 #define __HAL_SMARTCARD_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR) 382 383 /** @brief Check whether the specified Smartcard flag is set or not. 384 * @param __HANDLE__: specifies the SMARTCARD Handle. 385 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 386 * @param __FLAG__: specifies the flag to check. 387 * This parameter can be one of the following values: 388 * @arg SMARTCARD_FLAG_TXE: Transmit data register empty flag 389 * @arg SMARTCARD_FLAG_TC: Transmission Complete flag 390 * @arg SMARTCARD_FLAG_RXNE: Receive data register not empty flag 391 * @arg SMARTCARD_FLAG_IDLE: Idle Line detection flag 392 * @arg SMARTCARD_FLAG_ORE: OverRun Error flag 393 * @arg SMARTCARD_FLAG_NE: Noise Error flag 394 * @arg SMARTCARD_FLAG_FE: Framing Error flag 395 * @arg SMARTCARD_FLAG_PE: Parity Error flag 396 * @retval The new state of __FLAG__ (TRUE or FALSE). 397 */ 398 #define __HAL_SMARTCARD_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__)) 399 400 /** @brief Clear the specified Smartcard pending flags. 401 * @param __HANDLE__: specifies the SMARTCARD Handle. 402 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 403 * @param __FLAG__: specifies the flag to check. 404 * This parameter can be any combination of the following values: 405 * @arg SMARTCARD_FLAG_TC: Transmission Complete flag. 406 * @arg SMARTCARD_FLAG_RXNE: Receive data register not empty flag. 407 * @retval None 408 * 409 * @note PE (Parity error), FE (Framing error), NE (Noise error) and ORE (OverRun 410 * error) flags are cleared by software sequence: a read operation to 411 * USART_SR register followed by a read operation to USART_DR register. 412 * @note RXNE flag can be also cleared by a read to the USART_DR register. 413 * @note TC flag can be also cleared by software sequence: a read operation to 414 * USART_SR register followed by a write operation to USART_DR register. 415 * @note TXE flag is cleared only by a write to the USART_DR register. 416 * 417 * @retval None 418 */ 419 #define __HAL_SMARTCARD_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__)) 420 421 /** @brief Clear the SMARTCARD PE pending flag. 422 * @param __HANDLE__: specifies the USART Handle. 423 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 424 * @retval None 425 */ 426 #define __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) \ 427 do{ \ 428 __IO uint32_t tmpreg; \ 429 tmpreg = (__HANDLE__)->Instance->SR; \ 430 tmpreg = (__HANDLE__)->Instance->DR; \ 431 UNUSED(tmpreg); \ 432 }while(0) 433 434 435 436 /** @brief Clear the SMARTCARD FE pending flag. 437 * @param __HANDLE__: specifies the USART Handle. 438 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 439 * @retval None 440 */ 441 #define __HAL_SMARTCARD_CLEAR_FEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) 442 443 /** @brief Clear the SMARTCARD NE pending flag. 444 * @param __HANDLE__: specifies the USART Handle. 445 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 446 * @retval None 447 */ 448 #define __HAL_SMARTCARD_CLEAR_NEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) 449 450 /** @brief Clear the SMARTCARD ORE pending flag. 451 * @param __HANDLE__: specifies the USART Handle. 452 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 453 * @retval None 454 */ 455 #define __HAL_SMARTCARD_CLEAR_OREFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) 456 457 /** @brief Clear the SMARTCARD IDLE pending flag. 458 * @param __HANDLE__: specifies the USART Handle. 459 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 460 * @retval None 461 */ 462 #define __HAL_SMARTCARD_CLEAR_IDLEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) 463 464 /** @brief Enable the specified SmartCard interrupt. 465 * @param __HANDLE__: specifies the SMARTCARD Handle. 466 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 467 * @param __INTERRUPT__: specifies the SMARTCARD interrupt to enable. 468 * This parameter can be one of the following values: 469 * @arg SMARTCARD_IT_TXE: Transmit Data Register empty interrupt 470 * @arg SMARTCARD_IT_TC: Transmission complete interrupt 471 * @arg SMARTCARD_IT_RXNE: Receive Data register not empty interrupt 472 * @arg SMARTCARD_IT_IDLE: Idle line detection interrupt 473 * @arg SMARTCARD_IT_PE: Parity Error interrupt 474 * @arg SMARTCARD_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 475 * @retval None 476 */ 477 #define __HAL_SMARTCARD_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == SMARTCARD_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & SMARTCARD_IT_MASK)): \ 478 ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & SMARTCARD_IT_MASK))) 479 480 /** @brief Disable the specified SmartCard interrupts. 481 * @param __HANDLE__: specifies the SMARTCARD Handle. 482 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 483 * @param __INTERRUPT__: specifies the SMARTCARD interrupt to disable. 484 * This parameter can be one of the following values: 485 * @arg SMARTCARD_IT_TXE: Transmit Data Register empty interrupt 486 * @arg SMARTCARD_IT_TC: Transmission complete interrupt 487 * @arg SMARTCARD_IT_RXNE: Receive Data register not empty interrupt 488 * @arg SMARTCARD_IT_IDLE: Idle line detection interrupt 489 * @arg SMARTCARD_IT_PE: Parity Error interrupt 490 * @arg SMARTCARD_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 491 */ 492 #define __HAL_SMARTCARD_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28) == SMARTCARD_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & SMARTCARD_IT_MASK)): \ 493 ((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & SMARTCARD_IT_MASK))) 494 495 /** @brief Check whether the specified SmartCard interrupt has occurred or not. 496 * @param __HANDLE__: specifies the SMARTCARD Handle. 497 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 498 * @param __IT__: specifies the SMARTCARD interrupt source to check. 499 * This parameter can be one of the following values: 500 * @arg SMARTCARD_IT_TXE: Transmit Data Register empty interrupt 501 * @arg SMARTCARD_IT_TC: Transmission complete interrupt 502 * @arg SMARTCARD_IT_RXNE: Receive Data register not empty interrupt 503 * @arg SMARTCARD_IT_IDLE: Idle line detection interrupt 504 * @arg SMARTCARD_IT_ERR: Error interrupt 505 * @arg SMARTCARD_IT_PE: Parity Error interrupt 506 * @retval The new state of __IT__ (TRUE or FALSE). 507 */ 508 #define __HAL_SMARTCARD_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28) == SMARTCARD_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1: (__HANDLE__)->Instance->CR3) & (((uint32_t)(__IT__)) & SMARTCARD_IT_MASK)) 509 510 /** @brief Enables the SMARTCARD one bit sample method 511 * @param __HANDLE__: specifies the SMARTCARD Handle. 512 * @retval None 513 */ 514 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) (SET_BIT((__HANDLE__)->Instance->CR3, (USART_CR3_ONEBIT))) 515 516 /** @brief Disables the SMARTCARD one bit sample method 517 * @param __HANDLE__: specifies the SMARTCARD Handle. 518 * @retval None 519 */ 520 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) (CLEAR_BIT((__HANDLE__)->Instance->CR3, (USART_CR3_ONEBIT))) 521 522 /** @brief Enable the USART associated to the SMARTCARD Handle 523 * @param __HANDLE__: specifies the SMARTCARD Handle. 524 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 525 * @retval None 526 */ 527 #define __HAL_SMARTCARD_ENABLE(__HANDLE__) (SET_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE)) 528 529 /** @brief Disable the USART associated to the SMARTCARD Handle 530 * @param __HANDLE__: specifies the SMARTCARD Handle. 531 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 532 * @retval None 533 */ 534 #define __HAL_SMARTCARD_DISABLE(__HANDLE__) (CLEAR_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE)) 535 536 /** @brief Enable the SmartCard DMA request. 537 * @param __HANDLE__: specifies the SmartCard Handle. 538 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 539 * @param __REQUEST__: specifies the SmartCard DMA request. 540 * This parameter can be one of the following values: 541 * @arg SMARTCARD_DMAREQ_TX: SmartCard DMA transmit request 542 * @arg SMARTCARD_DMAREQ_RX: SmartCard DMA receive request 543 * @retval None 544 */ 545 #define __HAL_SMARTCARD_DMA_REQUEST_ENABLE(__HANDLE__, __REQUEST__) (SET_BIT((__HANDLE__)->Instance->CR3, (__REQUEST__))) 546 547 /** @brief Disable the SmartCard DMA request. 548 * @param __HANDLE__: specifies the SmartCard Handle. 549 * SMARTCARD Handle selects the USARTx peripheral (USART availability and x value depending on device). 550 * @param __REQUEST__: specifies the SmartCard DMA request. 551 * This parameter can be one of the following values: 552 * @arg SMARTCARD_DMAREQ_TX: SmartCard DMA transmit request 553 * @arg SMARTCARD_DMAREQ_RX: SmartCard DMA receive request 554 * @retval None 555 */ 556 #define __HAL_SMARTCARD_DMA_REQUEST_DISABLE(__HANDLE__, __REQUEST__) (CLEAR_BIT((__HANDLE__)->Instance->CR3, (__REQUEST__))) 557 558 559 /** 560 * @} 561 */ 562 563 564 /* Private macros --------------------------------------------------------*/ 565 /** @defgroup SMARTCARD_Private_Macros SMARTCARD Private Macros 566 * @{ 567 */ 568 569 #define SMARTCARD_CR1_REG_INDEX 1 570 #define SMARTCARD_CR3_REG_INDEX 3 571 572 #define SMARTCARD_DIV(__PCLK__, __BAUD__) (((__PCLK__)*25)/(4*(__BAUD__))) 573 #define SMARTCARD_DIVMANT(__PCLK__, __BAUD__) (SMARTCARD_DIV((__PCLK__), (__BAUD__))/100) 574 #define SMARTCARD_DIVFRAQ(__PCLK__, __BAUD__) (((SMARTCARD_DIV((__PCLK__), (__BAUD__)) - (SMARTCARD_DIVMANT((__PCLK__), (__BAUD__)) * 100)) * 16 + 50) / 100) 575 /* UART BRR = mantissa + overflow + fraction 576 = (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0F) */ 577 #define SMARTCARD_BRR(_PCLK_, _BAUD_) (((SMARTCARD_DIVMANT((_PCLK_), (_BAUD_)) << 4) + \ 578 (SMARTCARD_DIVFRAQ((_PCLK_), (_BAUD_)) & 0xF0)) + \ 579 (SMARTCARD_DIVFRAQ((_PCLK_), (_BAUD_)) & 0x0F)) 580 581 /** Check the Baud rate range. 582 * The maximum Baud Rate is derived from the maximum clock on APB (i.e. 32 MHz) 583 * divided by the smallest oversampling used on the USART (i.e. 16) 584 * __BAUDRATE__: Baud rate set by the configuration function. 585 * Return : TRUE or FALSE 586 */ 587 #define IS_SMARTCARD_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 2000001) 588 589 #define IS_SMARTCARD_WORD_LENGTH(LENGTH) ((LENGTH) == SMARTCARD_WORDLENGTH_9B) 590 591 #define IS_SMARTCARD_STOPBITS(STOPBITS) (((STOPBITS) == SMARTCARD_STOPBITS_0_5) || \ 592 ((STOPBITS) == SMARTCARD_STOPBITS_1_5)) 593 594 #define IS_SMARTCARD_PARITY(PARITY) (((PARITY) == SMARTCARD_PARITY_EVEN) || \ 595 ((PARITY) == SMARTCARD_PARITY_ODD)) 596 597 #define IS_SMARTCARD_MODE(MODE) ((((MODE) & (~((uint32_t)SMARTCARD_MODE_TX_RX))) == 0x00) && \ 598 ((MODE) != (uint32_t)0x00000000)) 599 600 #define IS_SMARTCARD_POLARITY(CPOL) (((CPOL) == SMARTCARD_POLARITY_LOW) || ((CPOL) == SMARTCARD_POLARITY_HIGH)) 601 602 #define IS_SMARTCARD_PHASE(CPHA) (((CPHA) == SMARTCARD_PHASE_1EDGE) || ((CPHA) == SMARTCARD_PHASE_2EDGE)) 603 604 #define IS_SMARTCARD_LASTBIT(LASTBIT) (((LASTBIT) == SMARTCARD_LASTBIT_DISABLE) || \ 605 ((LASTBIT) == SMARTCARD_LASTBIT_ENABLE)) 606 607 #define IS_SMARTCARD_ONE_BIT_SAMPLE(ONEBIT) (((ONEBIT) == SMARTCARD_ONE_BIT_SAMPLE_DISABLE) || \ 608 ((ONEBIT) == SMARTCARD_ONE_BIT_SAMPLE_ENABLE)) 609 610 #define IS_SMARTCARD_NACK_STATE(NACK) (((NACK) == SMARTCARD_NACK_ENABLE) || \ 611 ((NACK) == SMARTCARD_NACK_DISABLE)) 612 613 #define IS_SMARTCARD_PRESCALER(PRESCALER) (((PRESCALER) >= SMARTCARD_PRESCALER_SYSCLK_DIV2) && \ 614 ((PRESCALER) <= SMARTCARD_PRESCALER_SYSCLK_DIV62) ) 615 616 /** SMARTCARD interruptions flag mask 617 * 618 */ 619 #define SMARTCARD_IT_MASK ((uint32_t) USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE | USART_CR1_RXNEIE | \ 620 USART_CR1_IDLEIE | USART_CR3_EIE ) 621 622 623 /** 624 * @} 625 */ 626 627 628 /* Exported functions --------------------------------------------------------*/ 629 630 /** @addtogroup SMARTCARD_Exported_Functions SMARTCARD Exported Functions 631 * @{ 632 */ 633 634 /** @addtogroup SMARTCARD_Exported_Functions_Group1 Initialization and de-initialization functions 635 * @{ 636 */ 637 638 /* Initialization/de-initialization functions **********************************/ 639 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsc); 640 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsc); 641 void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsc); 642 void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsc); 643 644 /** 645 * @} 646 */ 647 648 /** @addtogroup SMARTCARD_Exported_Functions_Group2 IO operation functions 649 * @{ 650 */ 651 652 /* IO operation functions *******************************************************/ 653 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout); 654 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size, uint32_t Timeout); 655 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size); 656 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size); 657 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size); 658 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsc, uint8_t *pData, uint16_t Size); 659 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc); 660 void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsc); 661 void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsc); 662 void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsc); 663 664 /** 665 * @} 666 */ 667 668 /** @addtogroup SMARTCARD_Exported_Functions_Group3 Peripheral State and Errors functions 669 * @{ 670 */ 671 672 /* Peripheral State and Errors functions functions *****************************/ 673 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsc); 674 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsc); 675 676 /** 677 * @} 678 */ 679 680 /** 681 * @} 682 */ 683 684 /** 685 * @} 686 */ 687 688 /** 689 * @} 690 */ 691 692 #ifdef __cplusplus 693 } 694 #endif 695 696 #endif /* __STM32L1xx_HAL_SMARTCARD_H */ 697 698 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 699