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