1 /** 2 ****************************************************************************** 3 * @file stm32wlxx_hal_smartcard.h 4 * @author MCD Application Team 5 * @brief Header file of SMARTCARD HAL module. 6 ****************************************************************************** 7 * @attention 8 * 9 * Copyright (c) 2020 STMicroelectronics. 10 * All rights reserved. 11 * 12 * This software is licensed under terms that can be found in the LICENSE file 13 * in the root directory of this software component. 14 * If no LICENSE file comes with this software, it is provided AS-IS. 15 * 16 ****************************************************************************** 17 */ 18 19 /* Define to prevent recursive inclusion -------------------------------------*/ 20 #ifndef STM32WLxx_HAL_SMARTCARD_H 21 #define STM32WLxx_HAL_SMARTCARD_H 22 23 #ifdef __cplusplus 24 extern "C" { 25 #endif 26 27 /* Includes ------------------------------------------------------------------*/ 28 #include "stm32wlxx_hal_def.h" 29 30 /** @addtogroup STM32WLxx_HAL_Driver 31 * @{ 32 */ 33 34 /** @addtogroup SMARTCARD 35 * @{ 36 */ 37 38 /* Exported types ------------------------------------------------------------*/ 39 /** @defgroup SMARTCARD_Exported_Types SMARTCARD Exported Types 40 * @{ 41 */ 42 43 /** 44 * @brief SMARTCARD Init Structure definition 45 */ 46 typedef struct 47 { 48 uint32_t BaudRate; /*!< Configures the SmartCard communication baud rate. 49 The baud rate register is computed using the following formula: 50 Baud Rate Register = ((usart_ker_ckpres) / ((hsmartcard->Init.BaudRate))) 51 where usart_ker_ckpres is the USART input clock divided by a prescaler */ 52 53 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 54 This parameter @ref SMARTCARD_Word_Length can only be set to 9 (8 data + 1 parity bits). */ 55 56 uint32_t StopBits; /*!< Specifies the number of stop bits. 57 This parameter can be a value of @ref SMARTCARD_Stop_Bits. */ 58 59 uint16_t Parity; /*!< Specifies the parity mode. 60 This parameter can be a value of @ref SMARTCARD_Parity 61 @note The parity is enabled by default (PCE is forced to 1). 62 Since the WordLength is forced to 8 bits + parity, M is 63 forced to 1 and the parity bit is the 9th bit. */ 64 65 uint16_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled. 66 This parameter can be a value of @ref SMARTCARD_Mode */ 67 68 uint16_t CLKPolarity; /*!< Specifies the steady state of the serial clock. 69 This parameter can be a value of @ref SMARTCARD_Clock_Polarity */ 70 71 uint16_t CLKPhase; /*!< Specifies the clock transition on which the bit capture is made. 72 This parameter can be a value of @ref SMARTCARD_Clock_Phase */ 73 74 uint16_t CLKLastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted 75 data bit (MSB) has to be output on the SCLK pin in synchronous mode. 76 This parameter can be a value of @ref SMARTCARD_Last_Bit */ 77 78 uint16_t OneBitSampling; /*!< Specifies whether a single sample or three samples' majority vote is selected. 79 Selecting the single sample method increases the receiver tolerance to clock 80 deviations. This parameter can be a value of @ref SMARTCARD_OneBit_Sampling. */ 81 82 uint8_t Prescaler; /*!< Specifies the SmartCard Prescaler. 83 This parameter can be any value from 0x01 to 0x1F. Prescaler value is multiplied 84 by 2 to give the division factor of the source clock frequency */ 85 86 uint8_t GuardTime; /*!< Specifies the SmartCard Guard Time applied after stop bits. */ 87 88 uint16_t NACKEnable; /*!< Specifies whether the SmartCard NACK transmission is enabled 89 in case of parity error. 90 This parameter can be a value of @ref SMARTCARD_NACK_Enable */ 91 92 uint32_t TimeOutEnable; /*!< Specifies whether the receiver timeout is enabled. 93 This parameter can be a value of @ref SMARTCARD_Timeout_Enable*/ 94 95 uint32_t TimeOutValue; /*!< Specifies the receiver time out value in number of baud blocks: 96 it is used to implement the Character Wait Time (CWT) and 97 Block Wait Time (BWT). It is coded over 24 bits. */ 98 99 uint8_t BlockLength; /*!< Specifies the SmartCard Block Length in T=1 Reception mode. 100 This parameter can be any value from 0x0 to 0xFF */ 101 102 uint8_t AutoRetryCount; /*!< Specifies the SmartCard auto-retry count (number of retries in 103 receive and transmit mode). When set to 0, retransmission is 104 disabled. Otherwise, its maximum value is 7 (before signalling 105 an error) */ 106 107 uint32_t ClockPrescaler; /*!< Specifies the prescaler value used to divide the USART clock source. 108 This parameter can be a value of @ref SMARTCARD_ClockPrescaler. */ 109 110 } SMARTCARD_InitTypeDef; 111 112 /** 113 * @brief SMARTCARD advanced features initialization structure definition 114 */ 115 typedef struct 116 { 117 uint32_t AdvFeatureInit; /*!< Specifies which advanced SMARTCARD features is initialized. Several 118 advanced features may be initialized at the same time. This parameter 119 can be a value of @ref SMARTCARDEx_Advanced_Features_Initialization_Type */ 120 121 uint32_t TxPinLevelInvert; /*!< Specifies whether the TX pin active level is inverted. 122 This parameter can be a value of @ref SMARTCARD_Tx_Inv */ 123 124 uint32_t RxPinLevelInvert; /*!< Specifies whether the RX pin active level is inverted. 125 This parameter can be a value of @ref SMARTCARD_Rx_Inv */ 126 127 uint32_t DataInvert; /*!< Specifies whether data are inverted (positive/direct logic 128 vs negative/inverted logic). 129 This parameter can be a value of @ref SMARTCARD_Data_Inv */ 130 131 uint32_t Swap; /*!< Specifies whether TX and RX pins are swapped. 132 This parameter can be a value of @ref SMARTCARD_Rx_Tx_Swap */ 133 134 uint32_t OverrunDisable; /*!< Specifies whether the reception overrun detection is disabled. 135 This parameter can be a value of @ref SMARTCARD_Overrun_Disable */ 136 137 uint32_t DMADisableonRxError; /*!< Specifies whether the DMA is disabled in case of reception error. 138 This parameter can be a value of @ref SMARTCARD_DMA_Disable_on_Rx_Error */ 139 140 uint32_t MSBFirst; /*!< Specifies whether MSB is sent first on UART line. 141 This parameter can be a value of @ref SMARTCARD_MSB_First */ 142 143 uint16_t TxCompletionIndication; /*!< Specifies which transmission completion indication is used: before (when 144 relevant flag is available) or once guard time period has elapsed. 145 This parameter can be a value of @ref SMARTCARDEx_Transmission_Completion_Indication. */ 146 } SMARTCARD_AdvFeatureInitTypeDef; 147 148 /** 149 * @brief HAL SMARTCARD State definition 150 * @note HAL SMARTCARD State value is a combination of 2 different substates: gState and RxState (see @ref SMARTCARD_State_Definition). 151 * - gState contains SMARTCARD state information related to global Handle management 152 * and also information related to Tx operations. 153 * gState value coding follow below described bitmap : 154 * b7-b6 Error information 155 * 00 : No Error 156 * 01 : (Not Used) 157 * 10 : Timeout 158 * 11 : Error 159 * b5 Peripheral initialization status 160 * 0 : Reset (Peripheral not initialized) 161 * 1 : Init done (Peripheral initialized. HAL SMARTCARD Init function already called) 162 * b4-b3 (not used) 163 * xx : Should be set to 00 164 * b2 Intrinsic process state 165 * 0 : Ready 166 * 1 : Busy (Peripheral busy with some configuration or internal operations) 167 * b1 (not used) 168 * x : Should be set to 0 169 * b0 Tx state 170 * 0 : Ready (no Tx operation ongoing) 171 * 1 : Busy (Tx operation ongoing) 172 * - RxState contains information related to Rx operations. 173 * RxState value coding follow below described bitmap : 174 * b7-b6 (not used) 175 * xx : Should be set to 00 176 * b5 Peripheral initialization status 177 * 0 : Reset (Peripheral not initialized) 178 * 1 : Init done (Peripheral initialized) 179 * b4-b2 (not used) 180 * xxx : Should be set to 000 181 * b1 Rx state 182 * 0 : Ready (no Rx operation ongoing) 183 * 1 : Busy (Rx operation ongoing) 184 * b0 (not used) 185 * x : Should be set to 0. 186 */ 187 typedef uint32_t HAL_SMARTCARD_StateTypeDef; 188 189 /** 190 * @brief SMARTCARD handle Structure definition 191 */ 192 typedef struct __SMARTCARD_HandleTypeDef 193 { 194 USART_TypeDef *Instance; /*!< USART registers base address */ 195 196 SMARTCARD_InitTypeDef Init; /*!< SmartCard communication parameters */ 197 198 SMARTCARD_AdvFeatureInitTypeDef AdvancedInit; /*!< SmartCard advanced features initialization parameters */ 199 200 const uint8_t *pTxBuffPtr; /*!< Pointer to SmartCard Tx transfer Buffer */ 201 202 uint16_t TxXferSize; /*!< SmartCard Tx Transfer size */ 203 204 __IO uint16_t TxXferCount; /*!< SmartCard Tx Transfer Counter */ 205 206 uint8_t *pRxBuffPtr; /*!< Pointer to SmartCard Rx transfer Buffer */ 207 208 uint16_t RxXferSize; /*!< SmartCard Rx Transfer size */ 209 210 __IO uint16_t RxXferCount; /*!< SmartCard Rx Transfer Counter */ 211 212 uint16_t NbRxDataToProcess; /*!< Number of data to process during RX ISR execution */ 213 214 uint16_t NbTxDataToProcess; /*!< Number of data to process during TX ISR execution */ 215 216 uint32_t FifoMode; /*!< Specifies if the FIFO mode will be used. 217 This parameter can be a value of @ref SMARTCARDEx_FIFO_mode. */ 218 219 void (*RxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Rx IRQ handler */ 220 221 void (*TxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Tx IRQ handler */ 222 223 DMA_HandleTypeDef *hdmatx; /*!< SmartCard Tx DMA Handle parameters */ 224 225 DMA_HandleTypeDef *hdmarx; /*!< SmartCard Rx DMA Handle parameters */ 226 227 HAL_LockTypeDef Lock; /*!< Locking object */ 228 229 __IO HAL_SMARTCARD_StateTypeDef gState; /*!< SmartCard state information related to global Handle management 230 and also related to Tx operations. 231 This parameter can be a value of @ref HAL_SMARTCARD_StateTypeDef */ 232 233 __IO HAL_SMARTCARD_StateTypeDef RxState; /*!< SmartCard state information related to Rx operations. 234 This parameter can be a value of @ref HAL_SMARTCARD_StateTypeDef */ 235 236 __IO uint32_t ErrorCode; /*!< SmartCard Error code */ 237 238 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 239 void (* TxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Tx Complete Callback */ 240 241 void (* RxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Rx Complete Callback */ 242 243 void (* ErrorCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Error Callback */ 244 245 void (* AbortCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Complete Callback */ 246 247 void (* AbortTransmitCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Transmit Complete Callback */ 248 249 void (* AbortReceiveCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Receive Complete Callback */ 250 251 void (* RxFifoFullCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Rx Fifo Full Callback */ 252 253 void (* TxFifoEmptyCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Tx Fifo Empty Callback */ 254 255 void (* MspInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp Init callback */ 256 257 void (* MspDeInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp DeInit callback */ 258 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 259 260 } SMARTCARD_HandleTypeDef; 261 262 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 263 /** 264 * @brief HAL SMARTCARD Callback ID enumeration definition 265 */ 266 typedef enum 267 { 268 HAL_SMARTCARD_TX_COMPLETE_CB_ID = 0x00U, /*!< SMARTCARD Tx Complete Callback ID */ 269 HAL_SMARTCARD_RX_COMPLETE_CB_ID = 0x01U, /*!< SMARTCARD Rx Complete Callback ID */ 270 HAL_SMARTCARD_ERROR_CB_ID = 0x02U, /*!< SMARTCARD Error Callback ID */ 271 HAL_SMARTCARD_ABORT_COMPLETE_CB_ID = 0x03U, /*!< SMARTCARD Abort Complete Callback ID */ 272 HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x04U, /*!< SMARTCARD Abort Transmit Complete Callback ID */ 273 HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID = 0x05U, /*!< SMARTCARD Abort Receive Complete Callback ID */ 274 HAL_SMARTCARD_RX_FIFO_FULL_CB_ID = 0x06U, /*!< SMARTCARD Rx Fifo Full Callback ID */ 275 HAL_SMARTCARD_TX_FIFO_EMPTY_CB_ID = 0x07U, /*!< SMARTCARD Tx Fifo Empty Callback ID */ 276 277 HAL_SMARTCARD_MSPINIT_CB_ID = 0x08U, /*!< SMARTCARD MspInit callback ID */ 278 HAL_SMARTCARD_MSPDEINIT_CB_ID = 0x09U /*!< SMARTCARD MspDeInit callback ID */ 279 280 } HAL_SMARTCARD_CallbackIDTypeDef; 281 282 /** 283 * @brief HAL SMARTCARD Callback pointer definition 284 */ 285 typedef void (*pSMARTCARD_CallbackTypeDef)(SMARTCARD_HandleTypeDef *hsmartcard); /*!< pointer to an SMARTCARD callback function */ 286 287 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 288 289 /** 290 * @brief SMARTCARD clock sources 291 */ 292 typedef enum 293 { 294 SMARTCARD_CLOCKSOURCE_PCLK1 = 0x00U, /*!< PCLK1 clock source */ 295 SMARTCARD_CLOCKSOURCE_PCLK2 = 0x01U, /*!< PCLK2 clock source */ 296 SMARTCARD_CLOCKSOURCE_HSI = 0x02U, /*!< HSI clock source */ 297 SMARTCARD_CLOCKSOURCE_SYSCLK = 0x04U, /*!< SYSCLK clock source */ 298 SMARTCARD_CLOCKSOURCE_LSE = 0x08U, /*!< LSE clock source */ 299 SMARTCARD_CLOCKSOURCE_UNDEFINED = 0x10U /*!< undefined clock source */ 300 } SMARTCARD_ClockSourceTypeDef; 301 302 /** 303 * @} 304 */ 305 306 /* Exported constants --------------------------------------------------------*/ 307 /** @defgroup SMARTCARD_Exported_Constants SMARTCARD Exported Constants 308 * @{ 309 */ 310 311 /** @defgroup SMARTCARD_State_Definition SMARTCARD State Code Definition 312 * @{ 313 */ 314 #define HAL_SMARTCARD_STATE_RESET 0x00000000U /*!< Peripheral is not initialized 315 Value is allowed for gState and RxState */ 316 #define HAL_SMARTCARD_STATE_READY 0x00000020U /*!< Peripheral Initialized and ready for use 317 Value is allowed for gState and RxState */ 318 #define HAL_SMARTCARD_STATE_BUSY 0x00000024U /*!< an internal process is ongoing 319 Value is allowed for gState only */ 320 #define HAL_SMARTCARD_STATE_BUSY_TX 0x00000021U /*!< Data Transmission process is ongoing 321 Value is allowed for gState only */ 322 #define HAL_SMARTCARD_STATE_BUSY_RX 0x00000022U /*!< Data Reception process is ongoing 323 Value is allowed for RxState only */ 324 #define HAL_SMARTCARD_STATE_BUSY_TX_RX 0x00000023U /*!< Data Transmission and Reception process is ongoing 325 Not to be used for neither gState nor RxState. 326 Value is result of combination (Or) between gState and RxState values */ 327 #define HAL_SMARTCARD_STATE_TIMEOUT 0x000000A0U /*!< Timeout state 328 Value is allowed for gState only */ 329 #define HAL_SMARTCARD_STATE_ERROR 0x000000E0U /*!< Error 330 Value is allowed for gState only */ 331 /** 332 * @} 333 */ 334 335 /** @defgroup SMARTCARD_Error_Definition SMARTCARD Error Code Definition 336 * @{ 337 */ 338 #define HAL_SMARTCARD_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */ 339 #define HAL_SMARTCARD_ERROR_PE ((uint32_t)0x00000001U) /*!< Parity error */ 340 #define HAL_SMARTCARD_ERROR_NE ((uint32_t)0x00000002U) /*!< Noise error */ 341 #define HAL_SMARTCARD_ERROR_FE ((uint32_t)0x00000004U) /*!< frame error */ 342 #define HAL_SMARTCARD_ERROR_ORE ((uint32_t)0x00000008U) /*!< Overrun error */ 343 #define HAL_SMARTCARD_ERROR_DMA ((uint32_t)0x00000010U) /*!< DMA transfer error */ 344 #define HAL_SMARTCARD_ERROR_RTO ((uint32_t)0x00000020U) /*!< Receiver TimeOut error */ 345 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 346 #define HAL_SMARTCARD_ERROR_INVALID_CALLBACK ((uint32_t)0x00000040U) /*!< Invalid Callback error */ 347 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 348 /** 349 * @} 350 */ 351 352 /** @defgroup SMARTCARD_Word_Length SMARTCARD Word Length 353 * @{ 354 */ 355 #define SMARTCARD_WORDLENGTH_9B USART_CR1_M0 /*!< SMARTCARD frame length */ 356 /** 357 * @} 358 */ 359 360 /** @defgroup SMARTCARD_Stop_Bits SMARTCARD Number of Stop Bits 361 * @{ 362 */ 363 #define SMARTCARD_STOPBITS_0_5 USART_CR2_STOP_0 /*!< SMARTCARD frame with 0.5 stop bit */ 364 #define SMARTCARD_STOPBITS_1_5 USART_CR2_STOP /*!< SMARTCARD frame with 1.5 stop bits */ 365 /** 366 * @} 367 */ 368 369 /** @defgroup SMARTCARD_Parity SMARTCARD Parity 370 * @{ 371 */ 372 #define SMARTCARD_PARITY_EVEN USART_CR1_PCE /*!< SMARTCARD frame even parity */ 373 #define SMARTCARD_PARITY_ODD (USART_CR1_PCE | USART_CR1_PS) /*!< SMARTCARD frame odd parity */ 374 /** 375 * @} 376 */ 377 378 /** @defgroup SMARTCARD_Mode SMARTCARD Transfer Mode 379 * @{ 380 */ 381 #define SMARTCARD_MODE_RX USART_CR1_RE /*!< SMARTCARD RX mode */ 382 #define SMARTCARD_MODE_TX USART_CR1_TE /*!< SMARTCARD TX mode */ 383 #define SMARTCARD_MODE_TX_RX (USART_CR1_TE |USART_CR1_RE) /*!< SMARTCARD RX and TX mode */ 384 /** 385 * @} 386 */ 387 388 /** @defgroup SMARTCARD_Clock_Polarity SMARTCARD Clock Polarity 389 * @{ 390 */ 391 #define SMARTCARD_POLARITY_LOW 0x00000000U /*!< SMARTCARD frame low polarity */ 392 #define SMARTCARD_POLARITY_HIGH USART_CR2_CPOL /*!< SMARTCARD frame high polarity */ 393 /** 394 * @} 395 */ 396 397 /** @defgroup SMARTCARD_Clock_Phase SMARTCARD Clock Phase 398 * @{ 399 */ 400 #define SMARTCARD_PHASE_1EDGE 0x00000000U /*!< SMARTCARD frame phase on first clock transition */ 401 #define SMARTCARD_PHASE_2EDGE USART_CR2_CPHA /*!< SMARTCARD frame phase on second clock transition */ 402 /** 403 * @} 404 */ 405 406 /** @defgroup SMARTCARD_Last_Bit SMARTCARD Last Bit 407 * @{ 408 */ 409 #define SMARTCARD_LASTBIT_DISABLE 0x00000000U /*!< SMARTCARD frame last data bit clock pulse not output to SCLK pin */ 410 #define SMARTCARD_LASTBIT_ENABLE USART_CR2_LBCL /*!< SMARTCARD frame last data bit clock pulse output to SCLK pin */ 411 /** 412 * @} 413 */ 414 415 /** @defgroup SMARTCARD_OneBit_Sampling SMARTCARD One Bit Sampling Method 416 * @{ 417 */ 418 #define SMARTCARD_ONE_BIT_SAMPLE_DISABLE 0x00000000U /*!< SMARTCARD frame one-bit sample disabled */ 419 #define SMARTCARD_ONE_BIT_SAMPLE_ENABLE USART_CR3_ONEBIT /*!< SMARTCARD frame one-bit sample enabled */ 420 /** 421 * @} 422 */ 423 424 /** @defgroup SMARTCARD_NACK_Enable SMARTCARD NACK Enable 425 * @{ 426 */ 427 #define SMARTCARD_NACK_DISABLE 0x00000000U /*!< SMARTCARD NACK transmission disabled */ 428 #define SMARTCARD_NACK_ENABLE USART_CR3_NACK /*!< SMARTCARD NACK transmission enabled */ 429 /** 430 * @} 431 */ 432 433 /** @defgroup SMARTCARD_Timeout_Enable SMARTCARD Timeout Enable 434 * @{ 435 */ 436 #define SMARTCARD_TIMEOUT_DISABLE 0x00000000U /*!< SMARTCARD receiver timeout disabled */ 437 #define SMARTCARD_TIMEOUT_ENABLE USART_CR2_RTOEN /*!< SMARTCARD receiver timeout enabled */ 438 /** 439 * @} 440 */ 441 442 /** @defgroup SMARTCARD_ClockPrescaler SMARTCARD Clock Prescaler 443 * @{ 444 */ 445 #define SMARTCARD_PRESCALER_DIV1 0x00000000U /*!< fclk_pres = fclk */ 446 #define SMARTCARD_PRESCALER_DIV2 0x00000001U /*!< fclk_pres = fclk/2 */ 447 #define SMARTCARD_PRESCALER_DIV4 0x00000002U /*!< fclk_pres = fclk/4 */ 448 #define SMARTCARD_PRESCALER_DIV6 0x00000003U /*!< fclk_pres = fclk/6 */ 449 #define SMARTCARD_PRESCALER_DIV8 0x00000004U /*!< fclk_pres = fclk/8 */ 450 #define SMARTCARD_PRESCALER_DIV10 0x00000005U /*!< fclk_pres = fclk/10 */ 451 #define SMARTCARD_PRESCALER_DIV12 0x00000006U /*!< fclk_pres = fclk/12 */ 452 #define SMARTCARD_PRESCALER_DIV16 0x00000007U /*!< fclk_pres = fclk/16 */ 453 #define SMARTCARD_PRESCALER_DIV32 0x00000008U /*!< fclk_pres = fclk/32 */ 454 #define SMARTCARD_PRESCALER_DIV64 0x00000009U /*!< fclk_pres = fclk/64 */ 455 #define SMARTCARD_PRESCALER_DIV128 0x0000000AU /*!< fclk_pres = fclk/128 */ 456 #define SMARTCARD_PRESCALER_DIV256 0x0000000BU /*!< fclk_pres = fclk/256 */ 457 /** 458 * @} 459 */ 460 461 /** @defgroup SMARTCARD_Tx_Inv SMARTCARD advanced feature TX pin active level inversion 462 * @{ 463 */ 464 #define SMARTCARD_ADVFEATURE_TXINV_DISABLE 0x00000000U /*!< TX pin active level inversion disable */ 465 #define SMARTCARD_ADVFEATURE_TXINV_ENABLE USART_CR2_TXINV /*!< TX pin active level inversion enable */ 466 /** 467 * @} 468 */ 469 470 /** @defgroup SMARTCARD_Rx_Inv SMARTCARD advanced feature RX pin active level inversion 471 * @{ 472 */ 473 #define SMARTCARD_ADVFEATURE_RXINV_DISABLE 0x00000000U /*!< RX pin active level inversion disable */ 474 #define SMARTCARD_ADVFEATURE_RXINV_ENABLE USART_CR2_RXINV /*!< RX pin active level inversion enable */ 475 /** 476 * @} 477 */ 478 479 /** @defgroup SMARTCARD_Data_Inv SMARTCARD advanced feature Binary Data inversion 480 * @{ 481 */ 482 #define SMARTCARD_ADVFEATURE_DATAINV_DISABLE 0x00000000U /*!< Binary data inversion disable */ 483 #define SMARTCARD_ADVFEATURE_DATAINV_ENABLE USART_CR2_DATAINV /*!< Binary data inversion enable */ 484 /** 485 * @} 486 */ 487 488 /** @defgroup SMARTCARD_Rx_Tx_Swap SMARTCARD advanced feature RX TX pins swap 489 * @{ 490 */ 491 #define SMARTCARD_ADVFEATURE_SWAP_DISABLE 0x00000000U /*!< TX/RX pins swap disable */ 492 #define SMARTCARD_ADVFEATURE_SWAP_ENABLE USART_CR2_SWAP /*!< TX/RX pins swap enable */ 493 /** 494 * @} 495 */ 496 497 /** @defgroup SMARTCARD_Overrun_Disable SMARTCARD advanced feature Overrun Disable 498 * @{ 499 */ 500 #define SMARTCARD_ADVFEATURE_OVERRUN_ENABLE 0x00000000U /*!< RX overrun enable */ 501 #define SMARTCARD_ADVFEATURE_OVERRUN_DISABLE USART_CR3_OVRDIS /*!< RX overrun disable */ 502 /** 503 * @} 504 */ 505 506 /** @defgroup SMARTCARD_DMA_Disable_on_Rx_Error SMARTCARD advanced feature DMA Disable on Rx Error 507 * @{ 508 */ 509 #define SMARTCARD_ADVFEATURE_DMA_ENABLEONRXERROR 0x00000000U /*!< DMA enable on Reception Error */ 510 #define SMARTCARD_ADVFEATURE_DMA_DISABLEONRXERROR USART_CR3_DDRE /*!< DMA disable on Reception Error */ 511 /** 512 * @} 513 */ 514 515 /** @defgroup SMARTCARD_MSB_First SMARTCARD advanced feature MSB first 516 * @{ 517 */ 518 #define SMARTCARD_ADVFEATURE_MSBFIRST_DISABLE 0x00000000U /*!< Most significant bit sent/received first disable */ 519 #define SMARTCARD_ADVFEATURE_MSBFIRST_ENABLE USART_CR2_MSBFIRST /*!< Most significant bit sent/received first enable */ 520 /** 521 * @} 522 */ 523 524 /** @defgroup SMARTCARD_Request_Parameters SMARTCARD Request Parameters 525 * @{ 526 */ 527 #define SMARTCARD_RXDATA_FLUSH_REQUEST USART_RQR_RXFRQ /*!< Receive data flush request */ 528 #define SMARTCARD_TXDATA_FLUSH_REQUEST USART_RQR_TXFRQ /*!< Transmit data flush request */ 529 /** 530 * @} 531 */ 532 533 /** @defgroup SMARTCARD_Interruption_Mask SMARTCARD interruptions flags mask 534 * @{ 535 */ 536 #define SMARTCARD_IT_MASK 0x001FU /*!< SMARTCARD interruptions flags mask */ 537 #define SMARTCARD_CR_MASK 0x00E0U /*!< SMARTCARD control register mask */ 538 #define SMARTCARD_CR_POS 5U /*!< SMARTCARD control register position */ 539 #define SMARTCARD_ISR_MASK 0x1F00U /*!< SMARTCARD ISR register mask */ 540 #define SMARTCARD_ISR_POS 8U /*!< SMARTCARD ISR register position */ 541 /** 542 * @} 543 */ 544 545 /** 546 * @} 547 */ 548 549 /* Exported macros -----------------------------------------------------------*/ 550 /** @defgroup SMARTCARD_Exported_Macros SMARTCARD Exported Macros 551 * @{ 552 */ 553 554 /** @brief Reset SMARTCARD handle states. 555 * @param __HANDLE__ SMARTCARD handle. 556 * @retval None 557 */ 558 #if USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1 559 #define __HAL_SMARTCARD_RESET_HANDLE_STATE(__HANDLE__) do{ \ 560 (__HANDLE__)->gState = HAL_SMARTCARD_STATE_RESET; \ 561 (__HANDLE__)->RxState = HAL_SMARTCARD_STATE_RESET; \ 562 (__HANDLE__)->MspInitCallback = NULL; \ 563 (__HANDLE__)->MspDeInitCallback = NULL; \ 564 } while(0U) 565 #else 566 #define __HAL_SMARTCARD_RESET_HANDLE_STATE(__HANDLE__) do{ \ 567 (__HANDLE__)->gState = HAL_SMARTCARD_STATE_RESET; \ 568 (__HANDLE__)->RxState = HAL_SMARTCARD_STATE_RESET; \ 569 } while(0U) 570 #endif /*USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 571 572 /** @brief Flush the Smartcard Data registers. 573 * @param __HANDLE__ specifies the SMARTCARD Handle. 574 * @retval None 575 */ 576 #define __HAL_SMARTCARD_FLUSH_DRREGISTER(__HANDLE__) \ 577 do{ \ 578 SET_BIT((__HANDLE__)->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST); \ 579 SET_BIT((__HANDLE__)->Instance->RQR, SMARTCARD_TXDATA_FLUSH_REQUEST); \ 580 } while(0U) 581 582 /** @brief Clear the specified SMARTCARD pending flag. 583 * @param __HANDLE__ specifies the SMARTCARD Handle. 584 * @param __FLAG__ specifies the flag to check. 585 * This parameter can be any combination of the following values: 586 * @arg @ref SMARTCARD_CLEAR_PEF Parity error clear flag 587 * @arg @ref SMARTCARD_CLEAR_FEF Framing error clear flag 588 * @arg @ref SMARTCARD_CLEAR_NEF Noise detected clear flag 589 * @arg @ref SMARTCARD_CLEAR_OREF OverRun error clear flag 590 * @arg @ref SMARTCARD_CLEAR_IDLEF Idle line detected clear flag 591 * @arg @ref SMARTCARD_CLEAR_TCF Transmission complete clear flag 592 * @arg @ref SMARTCARD_CLEAR_TCBGTF Transmission complete before guard time clear flag 593 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 594 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 595 * @arg @ref SMARTCARD_CLEAR_TXFECF TXFIFO empty Clear flag 596 * @retval None 597 */ 598 #define __HAL_SMARTCARD_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__)) 599 600 /** @brief Clear the SMARTCARD PE pending flag. 601 * @param __HANDLE__ specifies the SMARTCARD Handle. 602 * @retval None 603 */ 604 #define __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_PEF) 605 606 /** @brief Clear the SMARTCARD FE pending flag. 607 * @param __HANDLE__ specifies the SMARTCARD Handle. 608 * @retval None 609 */ 610 #define __HAL_SMARTCARD_CLEAR_FEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_FEF) 611 612 /** @brief Clear the SMARTCARD NE pending flag. 613 * @param __HANDLE__ specifies the SMARTCARD Handle. 614 * @retval None 615 */ 616 #define __HAL_SMARTCARD_CLEAR_NEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_NEF) 617 618 /** @brief Clear the SMARTCARD ORE pending flag. 619 * @param __HANDLE__ specifies the SMARTCARD Handle. 620 * @retval None 621 */ 622 #define __HAL_SMARTCARD_CLEAR_OREFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_OREF) 623 624 /** @brief Clear the SMARTCARD IDLE pending flag. 625 * @param __HANDLE__ specifies the SMARTCARD Handle. 626 * @retval None 627 */ 628 #define __HAL_SMARTCARD_CLEAR_IDLEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_IDLEF) 629 630 /** @brief Check whether the specified Smartcard flag is set or not. 631 * @param __HANDLE__ specifies the SMARTCARD Handle. 632 * @param __FLAG__ specifies the flag to check. 633 * This parameter can be one of the following values: 634 * @arg @ref SMARTCARD_FLAG_TCBGT Transmission complete before guard time flag (when flag available) 635 * @arg @ref SMARTCARD_FLAG_REACK Receive enable acknowledge flag 636 * @arg @ref SMARTCARD_FLAG_TEACK Transmit enable acknowledge flag 637 * @arg @ref SMARTCARD_FLAG_BUSY Busy flag 638 * @arg @ref SMARTCARD_FLAG_EOBF End of block flag 639 * @arg @ref SMARTCARD_FLAG_RTOF Receiver timeout flag 640 * @arg @ref SMARTCARD_FLAG_TXE Transmit data register empty flag 641 * @arg @ref SMARTCARD_FLAG_TC Transmission complete flag 642 * @arg @ref SMARTCARD_FLAG_RXNE Receive data register not empty flag 643 * @arg @ref SMARTCARD_FLAG_IDLE Idle line detection flag 644 * @arg @ref SMARTCARD_FLAG_ORE Overrun error flag 645 * @arg @ref SMARTCARD_FLAG_NE Noise error flag 646 * @arg @ref SMARTCARD_FLAG_FE Framing error flag 647 * @arg @ref SMARTCARD_FLAG_PE Parity error flag 648 * @arg @ref SMARTCARD_FLAG_TXFNF TXFIFO not full flag 649 * @arg @ref SMARTCARD_FLAG_RXFNE RXFIFO not empty flag 650 * @arg @ref SMARTCARD_FLAG_TXFE TXFIFO Empty flag 651 * @arg @ref SMARTCARD_FLAG_RXFF RXFIFO Full flag 652 * @arg @ref SMARTCARD_FLAG_RXFT SMARTCARD RXFIFO threshold flag 653 * @arg @ref SMARTCARD_FLAG_TXFT SMARTCARD TXFIFO threshold flag 654 * @retval The new state of __FLAG__ (TRUE or FALSE). 655 */ 656 #define __HAL_SMARTCARD_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__)) 657 658 /** @brief Enable the specified SmartCard interrupt. 659 * @param __HANDLE__ specifies the SMARTCARD Handle. 660 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to enable. 661 * This parameter can be one of the following values: 662 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 663 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 664 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 665 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 666 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 667 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 668 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 669 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 670 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 671 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 672 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 673 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 674 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 675 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 676 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 677 * @retval None 678 */ 679 #define __HAL_SMARTCARD_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 1U)? ((__HANDLE__)->Instance->CR1 |= ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 680 ((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 2U)? ((__HANDLE__)->Instance->CR2 |= ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 681 ((__HANDLE__)->Instance->CR3 |= ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 682 683 /** @brief Disable the specified SmartCard interrupt. 684 * @param __HANDLE__ specifies the SMARTCARD Handle. 685 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to disable. 686 * This parameter can be one of the following values: 687 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 688 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 689 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 690 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 691 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 692 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 693 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 694 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 695 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 696 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 697 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 698 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 699 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 700 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 701 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 702 * @retval None 703 */ 704 #define __HAL_SMARTCARD_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 1U)? ((__HANDLE__)->Instance->CR1 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 705 ((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 2U)? ((__HANDLE__)->Instance->CR2 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 706 ((__HANDLE__)->Instance->CR3 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 707 708 /** @brief Check whether the specified SmartCard interrupt has occurred or not. 709 * @param __HANDLE__ specifies the SMARTCARD Handle. 710 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to check. 711 * This parameter can be one of the following values: 712 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 713 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 714 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 715 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 716 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 717 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 718 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 719 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 720 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 721 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 722 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 723 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 724 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 725 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 726 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 727 * @retval The new state of __INTERRUPT__ (SET or RESET). 728 */ 729 #define __HAL_SMARTCARD_GET_IT(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->ISR\ 730 & ((uint32_t)0x01U << (((__INTERRUPT__) & SMARTCARD_ISR_MASK)>> SMARTCARD_ISR_POS))) != 0U) ? SET : RESET) 731 732 /** @brief Check whether the specified SmartCard interrupt source is enabled or not. 733 * @param __HANDLE__ specifies the SMARTCARD Handle. 734 * @param __INTERRUPT__ specifies the SMARTCARD interrupt source to check. 735 * This parameter can be one of the following values: 736 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 737 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 738 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 739 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 740 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 741 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 742 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 743 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 744 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 745 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 746 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 747 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 748 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 749 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 750 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 751 * @retval The new state of __INTERRUPT__ (SET or RESET). 752 */ 753 #define __HAL_SMARTCARD_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 0x01U)? (__HANDLE__)->Instance->CR1 : \ 754 (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >> SMARTCARD_CR_POS) == 0x02U)? (__HANDLE__)->Instance->CR2 : \ 755 (__HANDLE__)->Instance->CR3)) & ((uint32_t)0x01U << (((uint16_t)(__INTERRUPT__)) & SMARTCARD_IT_MASK))) != 0U) ? SET : RESET) 756 757 /** @brief Clear the specified SMARTCARD ISR flag, in setting the proper ICR register flag. 758 * @param __HANDLE__ specifies the SMARTCARD Handle. 759 * @param __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set 760 * to clear the corresponding interrupt. 761 * This parameter can be one of the following values: 762 * @arg @ref SMARTCARD_CLEAR_PEF Parity error clear flag 763 * @arg @ref SMARTCARD_CLEAR_FEF Framing error clear flag 764 * @arg @ref SMARTCARD_CLEAR_NEF Noise detected clear flag 765 * @arg @ref SMARTCARD_CLEAR_OREF OverRun error clear flag 766 * @arg @ref SMARTCARD_CLEAR_IDLEF Idle line detection clear flag 767 * @arg @ref SMARTCARD_CLEAR_TXFECF TXFIFO empty Clear Flag 768 * @arg @ref SMARTCARD_CLEAR_TCF Transmission complete clear flag 769 * @arg @ref SMARTCARD_CLEAR_TCBGTF Transmission complete before guard time clear flag (when flag available) 770 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 771 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 772 * @retval None 773 */ 774 #define __HAL_SMARTCARD_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR |= (uint32_t)(__IT_CLEAR__)) 775 776 /** @brief Set a specific SMARTCARD request flag. 777 * @param __HANDLE__ specifies the SMARTCARD Handle. 778 * @param __REQ__ specifies the request flag to set 779 * This parameter can be one of the following values: 780 * @arg @ref SMARTCARD_RXDATA_FLUSH_REQUEST Receive data flush Request 781 * @arg @ref SMARTCARD_TXDATA_FLUSH_REQUEST Transmit data flush Request 782 * @retval None 783 */ 784 #define __HAL_SMARTCARD_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__)) 785 786 /** @brief Enable the SMARTCARD one bit sample method. 787 * @param __HANDLE__ specifies the SMARTCARD Handle. 788 * @retval None 789 */ 790 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT) 791 792 /** @brief Disable the SMARTCARD one bit sample method. 793 * @param __HANDLE__ specifies the SMARTCARD Handle. 794 * @retval None 795 */ 796 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3\ 797 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT)) 798 799 /** @brief Enable the USART associated to the SMARTCARD Handle. 800 * @param __HANDLE__ specifies the SMARTCARD Handle. 801 * @retval None 802 */ 803 #define __HAL_SMARTCARD_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE) 804 805 /** @brief Disable the USART associated to the SMARTCARD Handle 806 * @param __HANDLE__ specifies the SMARTCARD Handle. 807 * @retval None 808 */ 809 #define __HAL_SMARTCARD_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE) 810 811 /** 812 * @} 813 */ 814 815 /* Private macros -------------------------------------------------------------*/ 816 /** @defgroup SMARTCARD_Private_Macros SMARTCARD Private Macros 817 * @{ 818 */ 819 820 /** @brief Report the SMARTCARD clock source. 821 * @param __HANDLE__ specifies the SMARTCARD Handle. 822 * @param __CLOCKSOURCE__ output variable. 823 * @retval the SMARTCARD clocking source, written in __CLOCKSOURCE__. 824 */ 825 #define SMARTCARD_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 826 do { \ 827 if((__HANDLE__)->Instance == USART1) \ 828 { \ 829 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 830 { \ 831 case RCC_USART1CLKSOURCE_PCLK2: \ 832 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK2; \ 833 break; \ 834 case RCC_USART1CLKSOURCE_HSI: \ 835 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 836 break; \ 837 case RCC_USART1CLKSOURCE_SYSCLK: \ 838 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 839 break; \ 840 case RCC_USART1CLKSOURCE_LSE: \ 841 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 842 break; \ 843 default: \ 844 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 845 break; \ 846 } \ 847 } \ 848 else if((__HANDLE__)->Instance == USART2) \ 849 { \ 850 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 851 { \ 852 case RCC_USART2CLKSOURCE_PCLK1: \ 853 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK1; \ 854 break; \ 855 case RCC_USART2CLKSOURCE_HSI: \ 856 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 857 break; \ 858 case RCC_USART2CLKSOURCE_SYSCLK: \ 859 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 860 break; \ 861 case RCC_USART2CLKSOURCE_LSE: \ 862 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 863 break; \ 864 default: \ 865 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 866 break; \ 867 } \ 868 } \ 869 else \ 870 { \ 871 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 872 } \ 873 } while(0U) 874 875 /** @brief Check the Baud rate range. 876 * @note The maximum Baud Rate is derived from the maximum clock on WB (48 MHz) 877 * divided by the oversampling used on the SMARTCARD (i.e. 16). 878 * @param __BAUDRATE__ Baud rate set by the configuration function. 879 * @retval Test result (TRUE or FALSE) 880 */ 881 #define IS_SMARTCARD_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 3000001U) 882 883 /** @brief Check the block length range. 884 * @note The maximum SMARTCARD block length is 0xFF. 885 * @param __LENGTH__ block length. 886 * @retval Test result (TRUE or FALSE) 887 */ 888 #define IS_SMARTCARD_BLOCKLENGTH(__LENGTH__) ((__LENGTH__) <= 0xFFU) 889 890 /** @brief Check the receiver timeout value. 891 * @note The maximum SMARTCARD receiver timeout value is 0xFFFFFF. 892 * @param __TIMEOUTVALUE__ receiver timeout value. 893 * @retval Test result (TRUE or FALSE) 894 */ 895 #define IS_SMARTCARD_TIMEOUT_VALUE(__TIMEOUTVALUE__) ((__TIMEOUTVALUE__) <= 0xFFFFFFU) 896 897 /** @brief Check the SMARTCARD autoretry counter value. 898 * @note The maximum number of retransmissions is 0x7. 899 * @param __COUNT__ number of retransmissions. 900 * @retval Test result (TRUE or FALSE) 901 */ 902 #define IS_SMARTCARD_AUTORETRY_COUNT(__COUNT__) ((__COUNT__) <= 0x7U) 903 904 /** @brief Ensure that SMARTCARD frame length is valid. 905 * @param __LENGTH__ SMARTCARD frame length. 906 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 907 */ 908 #define IS_SMARTCARD_WORD_LENGTH(__LENGTH__) ((__LENGTH__) == SMARTCARD_WORDLENGTH_9B) 909 910 /** @brief Ensure that SMARTCARD frame number of stop bits is valid. 911 * @param __STOPBITS__ SMARTCARD frame number of stop bits. 912 * @retval SET (__STOPBITS__ is valid) or RESET (__STOPBITS__ is invalid) 913 */ 914 #define IS_SMARTCARD_STOPBITS(__STOPBITS__) (((__STOPBITS__) == SMARTCARD_STOPBITS_0_5) ||\ 915 ((__STOPBITS__) == SMARTCARD_STOPBITS_1_5)) 916 917 /** @brief Ensure that SMARTCARD frame parity is valid. 918 * @param __PARITY__ SMARTCARD frame parity. 919 * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid) 920 */ 921 #define IS_SMARTCARD_PARITY(__PARITY__) (((__PARITY__) == SMARTCARD_PARITY_EVEN) || \ 922 ((__PARITY__) == SMARTCARD_PARITY_ODD)) 923 924 /** @brief Ensure that SMARTCARD communication mode is valid. 925 * @param __MODE__ SMARTCARD communication mode. 926 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid) 927 */ 928 #define IS_SMARTCARD_MODE(__MODE__) ((((__MODE__) & 0xFFF3U) == 0x00U) && ((__MODE__) != 0x00U)) 929 930 /** @brief Ensure that SMARTCARD frame polarity is valid. 931 * @param __CPOL__ SMARTCARD frame polarity. 932 * @retval SET (__CPOL__ is valid) or RESET (__CPOL__ is invalid) 933 */ 934 #define IS_SMARTCARD_POLARITY(__CPOL__) (((__CPOL__) == SMARTCARD_POLARITY_LOW)\ 935 || ((__CPOL__) == SMARTCARD_POLARITY_HIGH)) 936 937 /** @brief Ensure that SMARTCARD frame phase is valid. 938 * @param __CPHA__ SMARTCARD frame phase. 939 * @retval SET (__CPHA__ is valid) or RESET (__CPHA__ is invalid) 940 */ 941 #define IS_SMARTCARD_PHASE(__CPHA__) (((__CPHA__) == SMARTCARD_PHASE_1EDGE) || ((__CPHA__) == SMARTCARD_PHASE_2EDGE)) 942 943 /** @brief Ensure that SMARTCARD frame last bit clock pulse setting is valid. 944 * @param __LASTBIT__ SMARTCARD frame last bit clock pulse setting. 945 * @retval SET (__LASTBIT__ is valid) or RESET (__LASTBIT__ is invalid) 946 */ 947 #define IS_SMARTCARD_LASTBIT(__LASTBIT__) (((__LASTBIT__) == SMARTCARD_LASTBIT_DISABLE) || \ 948 ((__LASTBIT__) == SMARTCARD_LASTBIT_ENABLE)) 949 950 /** @brief Ensure that SMARTCARD frame sampling is valid. 951 * @param __ONEBIT__ SMARTCARD frame sampling. 952 * @retval SET (__ONEBIT__ is valid) or RESET (__ONEBIT__ is invalid) 953 */ 954 #define IS_SMARTCARD_ONE_BIT_SAMPLE(__ONEBIT__) (((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_DISABLE) || \ 955 ((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_ENABLE)) 956 957 /** @brief Ensure that SMARTCARD NACK transmission setting is valid. 958 * @param __NACK__ SMARTCARD NACK transmission setting. 959 * @retval SET (__NACK__ is valid) or RESET (__NACK__ is invalid) 960 */ 961 #define IS_SMARTCARD_NACK(__NACK__) (((__NACK__) == SMARTCARD_NACK_ENABLE) || \ 962 ((__NACK__) == SMARTCARD_NACK_DISABLE)) 963 964 /** @brief Ensure that SMARTCARD receiver timeout setting is valid. 965 * @param __TIMEOUT__ SMARTCARD receiver timeout setting. 966 * @retval SET (__TIMEOUT__ is valid) or RESET (__TIMEOUT__ is invalid) 967 */ 968 #define IS_SMARTCARD_TIMEOUT(__TIMEOUT__) (((__TIMEOUT__) == SMARTCARD_TIMEOUT_DISABLE) || \ 969 ((__TIMEOUT__) == SMARTCARD_TIMEOUT_ENABLE)) 970 971 /** @brief Ensure that SMARTCARD clock Prescaler is valid. 972 * @param __CLOCKPRESCALER__ SMARTCARD clock Prescaler value. 973 * @retval SET (__CLOCKPRESCALER__ is valid) or RESET (__CLOCKPRESCALER__ is invalid) 974 */ 975 #define IS_SMARTCARD_CLOCKPRESCALER(__CLOCKPRESCALER__) (((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV1) || \ 976 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV2) || \ 977 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV4) || \ 978 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV6) || \ 979 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV8) || \ 980 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV10) || \ 981 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV12) || \ 982 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV16) || \ 983 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV32) || \ 984 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV64) || \ 985 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV128) || \ 986 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV256)) 987 988 /** @brief Ensure that SMARTCARD advanced features initialization is valid. 989 * @param __INIT__ SMARTCARD advanced features initialization. 990 * @retval SET (__INIT__ is valid) or RESET (__INIT__ is invalid) 991 */ 992 #define IS_SMARTCARD_ADVFEATURE_INIT(__INIT__) ((__INIT__) <= (SMARTCARD_ADVFEATURE_NO_INIT | \ 993 SMARTCARD_ADVFEATURE_TXINVERT_INIT | \ 994 SMARTCARD_ADVFEATURE_RXINVERT_INIT | \ 995 SMARTCARD_ADVFEATURE_DATAINVERT_INIT | \ 996 SMARTCARD_ADVFEATURE_SWAP_INIT | \ 997 SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT | \ 998 SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT | \ 999 SMARTCARD_ADVFEATURE_MSBFIRST_INIT)) 1000 1001 /** @brief Ensure that SMARTCARD frame TX inversion setting is valid. 1002 * @param __TXINV__ SMARTCARD frame TX inversion setting. 1003 * @retval SET (__TXINV__ is valid) or RESET (__TXINV__ is invalid) 1004 */ 1005 #define IS_SMARTCARD_ADVFEATURE_TXINV(__TXINV__) (((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_DISABLE) || \ 1006 ((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_ENABLE)) 1007 1008 /** @brief Ensure that SMARTCARD frame RX inversion setting is valid. 1009 * @param __RXINV__ SMARTCARD frame RX inversion setting. 1010 * @retval SET (__RXINV__ is valid) or RESET (__RXINV__ is invalid) 1011 */ 1012 #define IS_SMARTCARD_ADVFEATURE_RXINV(__RXINV__) (((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_DISABLE) || \ 1013 ((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_ENABLE)) 1014 1015 /** @brief Ensure that SMARTCARD frame data inversion setting is valid. 1016 * @param __DATAINV__ SMARTCARD frame data inversion setting. 1017 * @retval SET (__DATAINV__ is valid) or RESET (__DATAINV__ is invalid) 1018 */ 1019 #define IS_SMARTCARD_ADVFEATURE_DATAINV(__DATAINV__) (((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_DISABLE) || \ 1020 ((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_ENABLE)) 1021 1022 /** @brief Ensure that SMARTCARD frame RX/TX pins swap setting is valid. 1023 * @param __SWAP__ SMARTCARD frame RX/TX pins swap setting. 1024 * @retval SET (__SWAP__ is valid) or RESET (__SWAP__ is invalid) 1025 */ 1026 #define IS_SMARTCARD_ADVFEATURE_SWAP(__SWAP__) (((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_DISABLE) || \ 1027 ((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_ENABLE)) 1028 1029 /** @brief Ensure that SMARTCARD frame overrun setting is valid. 1030 * @param __OVERRUN__ SMARTCARD frame overrun setting. 1031 * @retval SET (__OVERRUN__ is valid) or RESET (__OVERRUN__ is invalid) 1032 */ 1033 #define IS_SMARTCARD_OVERRUN(__OVERRUN__) (((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_ENABLE) || \ 1034 ((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_DISABLE)) 1035 1036 /** @brief Ensure that SMARTCARD DMA enabling or disabling on error setting is valid. 1037 * @param __DMA__ SMARTCARD DMA enabling or disabling on error setting. 1038 * @retval SET (__DMA__ is valid) or RESET (__DMA__ is invalid) 1039 */ 1040 #define IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(__DMA__) (((__DMA__) == SMARTCARD_ADVFEATURE_DMA_ENABLEONRXERROR) || \ 1041 ((__DMA__) == SMARTCARD_ADVFEATURE_DMA_DISABLEONRXERROR)) 1042 1043 /** @brief Ensure that SMARTCARD frame MSB first setting is valid. 1044 * @param __MSBFIRST__ SMARTCARD frame MSB first setting. 1045 * @retval SET (__MSBFIRST__ is valid) or RESET (__MSBFIRST__ is invalid) 1046 */ 1047 #define IS_SMARTCARD_ADVFEATURE_MSBFIRST(__MSBFIRST__) (((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_DISABLE) || \ 1048 ((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_ENABLE)) 1049 1050 /** @brief Ensure that SMARTCARD request parameter is valid. 1051 * @param __PARAM__ SMARTCARD request parameter. 1052 * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid) 1053 */ 1054 #define IS_SMARTCARD_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == SMARTCARD_RXDATA_FLUSH_REQUEST) || \ 1055 ((__PARAM__) == SMARTCARD_TXDATA_FLUSH_REQUEST)) 1056 1057 /** 1058 * @} 1059 */ 1060 1061 /* Include SMARTCARD HAL Extended module */ 1062 #include "stm32wlxx_hal_smartcard_ex.h" 1063 1064 /* Exported functions --------------------------------------------------------*/ 1065 /** @addtogroup SMARTCARD_Exported_Functions 1066 * @{ 1067 */ 1068 1069 /* Initialization and de-initialization functions ****************************/ 1070 /** @addtogroup SMARTCARD_Exported_Functions_Group1 1071 * @{ 1072 */ 1073 1074 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard); 1075 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard); 1076 void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard); 1077 void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard); 1078 1079 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 1080 /* Callbacks Register/UnRegister functions ***********************************/ 1081 HAL_StatusTypeDef HAL_SMARTCARD_RegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, 1082 HAL_SMARTCARD_CallbackIDTypeDef CallbackID, pSMARTCARD_CallbackTypeDef pCallback); 1083 HAL_StatusTypeDef HAL_SMARTCARD_UnRegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, 1084 HAL_SMARTCARD_CallbackIDTypeDef CallbackID); 1085 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 1086 1087 /** 1088 * @} 1089 */ 1090 1091 /* IO operation functions *****************************************************/ 1092 /** @addtogroup SMARTCARD_Exported_Functions_Group2 1093 * @{ 1094 */ 1095 1096 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size, 1097 uint32_t Timeout); 1098 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, 1099 uint32_t Timeout); 1100 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size); 1101 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1102 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsmartcard, const uint8_t *pData, uint16_t Size); 1103 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1104 /* Transfer Abort functions */ 1105 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsmartcard); 1106 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsmartcard); 1107 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsmartcard); 1108 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1109 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1110 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1111 1112 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard); 1113 void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1114 void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1115 void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1116 void HAL_SMARTCARD_AbortCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1117 void HAL_SMARTCARD_AbortTransmitCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1118 void HAL_SMARTCARD_AbortReceiveCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1119 1120 /** 1121 * @} 1122 */ 1123 1124 /* Peripheral State and Error functions ***************************************/ 1125 /** @addtogroup SMARTCARD_Exported_Functions_Group4 1126 * @{ 1127 */ 1128 1129 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(const SMARTCARD_HandleTypeDef *hsmartcard); 1130 uint32_t HAL_SMARTCARD_GetError(const SMARTCARD_HandleTypeDef *hsmartcard); 1131 1132 /** 1133 * @} 1134 */ 1135 1136 /** 1137 * @} 1138 */ 1139 1140 /** 1141 * @} 1142 */ 1143 1144 /** 1145 * @} 1146 */ 1147 1148 #ifdef __cplusplus 1149 } 1150 #endif 1151 1152 #endif /* STM32WLxx_HAL_SMARTCARD_H */ 1153 1154