1 /** 2 ****************************************************************************** 3 * @file stm32f0xx_hal_smartcard.h 4 * @author MCD Application Team 5 * @brief Header file of SMARTCARD HAL module. 6 ****************************************************************************** 7 * @attention 8 * 9 * <h2><center>© Copyright (c) 2016 STMicroelectronics. 10 * All rights reserved.</center></h2> 11 * 12 * This software component is licensed by ST under BSD 3-Clause license, 13 * the "License"; You may not use this file except in compliance with the 14 * License. You may obtain a copy of the License at: 15 * opensource.org/licenses/BSD-3-Clause 16 * 17 ****************************************************************************** 18 */ 19 20 /* Define to prevent recursive inclusion -------------------------------------*/ 21 #ifndef STM32F0xx_HAL_SMARTCARD_H 22 #define STM32F0xx_HAL_SMARTCARD_H 23 24 #ifdef __cplusplus 25 extern "C" { 26 #endif 27 #if !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC) 28 /* Includes ------------------------------------------------------------------*/ 29 #include "stm32f0xx_hal_def.h" 30 31 /** @addtogroup STM32F0xx_HAL_Driver 32 * @{ 33 */ 34 35 /** @addtogroup SMARTCARD 36 * @{ 37 */ 38 39 /* Exported types ------------------------------------------------------------*/ 40 /** @defgroup SMARTCARD_Exported_Types SMARTCARD Exported Types 41 * @{ 42 */ 43 44 /** 45 * @brief SMARTCARD Init Structure definition 46 */ 47 typedef struct 48 { 49 uint32_t BaudRate; /*!< Configures the SmartCard communication baud rate. 50 The baud rate register is computed using the following formula: 51 Baud Rate Register = ((usart_ker_ckpres) / ((hsmartcard->Init.BaudRate))) 52 where usart_ker_ckpres is the USART input clock divided by a prescaler */ 53 54 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 55 This parameter @ref SMARTCARD_Word_Length can only be 56 set to 9 (8 data + 1 parity bits). */ 57 58 uint32_t StopBits; /*!< Specifies the number of stop bits. 59 This parameter can be a value of @ref SMARTCARD_Stop_Bits. */ 60 61 uint16_t Parity; /*!< Specifies the parity mode. 62 This parameter can be a value of @ref SMARTCARD_Parity 63 @note The parity is enabled by default (PCE is forced to 1). 64 Since the WordLength is forced to 8 bits + parity, M is 65 forced to 1 and the parity bit is the 9th bit. */ 66 67 uint16_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled. 68 This parameter can be a value of @ref SMARTCARD_Mode */ 69 70 uint16_t CLKPolarity; /*!< Specifies the steady state of the serial clock. 71 This parameter can be a value of @ref SMARTCARD_Clock_Polarity */ 72 73 uint16_t CLKPhase; /*!< Specifies the clock transition on which the bit capture is made. 74 This parameter can be a value of @ref SMARTCARD_Clock_Phase */ 75 76 uint16_t CLKLastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted 77 data bit (MSB) has to be output on the SCLK pin in synchronous mode. 78 This parameter can be a value of @ref SMARTCARD_Last_Bit */ 79 80 uint16_t OneBitSampling; /*!< Specifies whether a single sample or three samples' majority vote 81 is selected. Selecting the single sample method increases 82 the receiver tolerance to clock deviations. This parameter can be a value 83 of @ref SMARTCARD_OneBit_Sampling. */ 84 85 uint8_t Prescaler; /*!< Specifies the SmartCard Prescaler. 86 This parameter can be any value from 0x01 to 0x1F. Prescaler value is 87 multiplied by 2 to give the division factor of the source clock frequency */ 88 89 uint8_t GuardTime; /*!< Specifies the SmartCard Guard Time applied after stop bits. */ 90 91 uint16_t NACKEnable; /*!< Specifies whether the SmartCard NACK transmission is enabled 92 in case of parity error. 93 This parameter can be a value of @ref SMARTCARD_NACK_Enable */ 94 95 uint32_t TimeOutEnable; /*!< Specifies whether the receiver timeout is enabled. 96 This parameter can be a value of @ref SMARTCARD_Timeout_Enable*/ 97 98 uint32_t TimeOutValue; /*!< Specifies the receiver time out value in number of baud blocks: 99 it is used to implement the Character Wait Time (CWT) and 100 Block Wait Time (BWT). It is coded over 24 bits. */ 101 102 uint8_t BlockLength; /*!< Specifies the SmartCard Block Length in T=1 Reception mode. 103 This parameter can be any value from 0x0 to 0xFF */ 104 105 uint8_t AutoRetryCount; /*!< Specifies the SmartCard auto-retry count (number of retries in 106 receive and transmit mode). When set to 0, retransmission is 107 disabled. Otherwise, its maximum value is 7 (before signalling 108 an error) */ 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 146 of @ref SMARTCARDEx_Transmission_Completion_Indication. */ 147 } SMARTCARD_AdvFeatureInitTypeDef; 148 149 /** 150 * @brief HAL SMARTCARD State definition 151 * @note HAL SMARTCARD State value is a combination of 2 different substates: 152 * gState and RxState (see @ref SMARTCARD_State_Definition). 153 * - gState contains SMARTCARD state information related to global Handle management 154 * and also information related to Tx operations. 155 * gState value coding follow below described bitmap : 156 * b7-b6 Error information 157 * 00 : No Error 158 * 01 : (Not Used) 159 * 10 : Timeout 160 * 11 : Error 161 * b5 Peripheral initialization status 162 * 0 : Reset (Peripheral not initialized) 163 * 1 : Init done (Peripheral initialized. HAL SMARTCARD Init function already called) 164 * b4-b3 (not used) 165 * xx : Should be set to 00 166 * b2 Intrinsic process state 167 * 0 : Ready 168 * 1 : Busy (Peripheral busy with some configuration or internal operations) 169 * b1 (not used) 170 * x : Should be set to 0 171 * b0 Tx state 172 * 0 : Ready (no Tx operation ongoing) 173 * 1 : Busy (Tx operation ongoing) 174 * - RxState contains information related to Rx operations. 175 * RxState value coding follow below described bitmap : 176 * b7-b6 (not used) 177 * xx : Should be set to 00 178 * b5 Peripheral initialization status 179 * 0 : Reset (Peripheral not initialized) 180 * 1 : Init done (Peripheral initialized) 181 * b4-b2 (not used) 182 * xxx : Should be set to 000 183 * b1 Rx state 184 * 0 : Ready (no Rx operation ongoing) 185 * 1 : Busy (Rx operation ongoing) 186 * b0 (not used) 187 * x : Should be set to 0. 188 */ 189 typedef uint32_t HAL_SMARTCARD_StateTypeDef; 190 191 /** 192 * @brief SMARTCARD handle Structure definition 193 */ 194 typedef struct __SMARTCARD_HandleTypeDef 195 { 196 USART_TypeDef *Instance; /*!< USART registers base address */ 197 198 SMARTCARD_InitTypeDef Init; /*!< SmartCard communication parameters */ 199 200 SMARTCARD_AdvFeatureInitTypeDef AdvancedInit; /*!< SmartCard advanced features initialization parameters */ 201 202 uint8_t *pTxBuffPtr; /*!< Pointer to SmartCard Tx transfer Buffer */ 203 204 uint16_t TxXferSize; /*!< SmartCard Tx Transfer size */ 205 206 __IO uint16_t TxXferCount; /*!< SmartCard Tx Transfer Counter */ 207 208 uint8_t *pRxBuffPtr; /*!< Pointer to SmartCard Rx transfer Buffer */ 209 210 uint16_t RxXferSize; /*!< SmartCard Rx Transfer size */ 211 212 __IO uint16_t RxXferCount; /*!< SmartCard Rx Transfer Counter */ 213 214 215 void (*RxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Rx IRQ handler */ 216 217 void (*TxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Tx IRQ handler */ 218 219 DMA_HandleTypeDef *hdmatx; /*!< SmartCard Tx DMA Handle parameters */ 220 221 DMA_HandleTypeDef *hdmarx; /*!< SmartCard Rx DMA Handle parameters */ 222 223 HAL_LockTypeDef Lock; /*!< Locking object */ 224 225 __IO HAL_SMARTCARD_StateTypeDef gState; /*!< SmartCard state information related to global 226 Handle management and also related to Tx operations. 227 This parameter can be a value 228 of @ref HAL_SMARTCARD_StateTypeDef */ 229 230 __IO HAL_SMARTCARD_StateTypeDef RxState; /*!< SmartCard state information related to Rx operations. 231 This parameter can be a value 232 of @ref HAL_SMARTCARD_StateTypeDef */ 233 234 __IO uint32_t ErrorCode; /*!< SmartCard Error code */ 235 236 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 237 void (* TxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Tx Complete Callback */ 238 239 void (* RxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Rx Complete Callback */ 240 241 void (* ErrorCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Error Callback */ 242 243 void (* AbortCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Complete Callback */ 244 245 void (* AbortTransmitCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Transmit Complete Callback */ 246 247 void (* AbortReceiveCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Receive Complete Callback */ 248 249 void (* MspInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp Init callback */ 250 251 void (* MspDeInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp DeInit callback */ 252 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 253 254 } SMARTCARD_HandleTypeDef; 255 256 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 257 /** 258 * @brief HAL SMARTCARD Callback ID enumeration definition 259 */ 260 typedef enum 261 { 262 HAL_SMARTCARD_TX_COMPLETE_CB_ID = 0x00U, /*!< SMARTCARD Tx Complete Callback ID */ 263 HAL_SMARTCARD_RX_COMPLETE_CB_ID = 0x01U, /*!< SMARTCARD Rx Complete Callback ID */ 264 HAL_SMARTCARD_ERROR_CB_ID = 0x02U, /*!< SMARTCARD Error Callback ID */ 265 HAL_SMARTCARD_ABORT_COMPLETE_CB_ID = 0x03U, /*!< SMARTCARD Abort Complete Callback ID */ 266 HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x04U, /*!< SMARTCARD Abort Transmit Complete Callback ID */ 267 HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID = 0x05U, /*!< SMARTCARD Abort Receive Complete Callback ID */ 268 269 HAL_SMARTCARD_MSPINIT_CB_ID = 0x08U, /*!< SMARTCARD MspInit callback ID */ 270 HAL_SMARTCARD_MSPDEINIT_CB_ID = 0x09U /*!< SMARTCARD MspDeInit callback ID */ 271 272 } HAL_SMARTCARD_CallbackIDTypeDef; 273 274 /** 275 * @brief HAL SMARTCARD Callback pointer definition 276 */ 277 typedef void (*pSMARTCARD_CallbackTypeDef)(SMARTCARD_HandleTypeDef *hsmartcard); /*!< pointer to an SMARTCARD callback function */ 278 279 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 280 281 /** 282 * @brief SMARTCARD clock sources 283 */ 284 typedef enum 285 { 286 SMARTCARD_CLOCKSOURCE_PCLK1 = 0x00U, /*!< PCLK1 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_TCBGTF Transmission complete before guard time clear flag 572 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 573 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 574 * @retval None 575 */ 576 #define __HAL_SMARTCARD_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__)) 577 578 /** @brief Clear the SMARTCARD PE pending flag. 579 * @param __HANDLE__ specifies the SMARTCARD Handle. 580 * @retval None 581 */ 582 #define __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_PEF) 583 584 /** @brief Clear the SMARTCARD FE pending flag. 585 * @param __HANDLE__ specifies the SMARTCARD Handle. 586 * @retval None 587 */ 588 #define __HAL_SMARTCARD_CLEAR_FEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_FEF) 589 590 /** @brief Clear the SMARTCARD NE pending flag. 591 * @param __HANDLE__ specifies the SMARTCARD Handle. 592 * @retval None 593 */ 594 #define __HAL_SMARTCARD_CLEAR_NEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_NEF) 595 596 /** @brief Clear the SMARTCARD ORE pending flag. 597 * @param __HANDLE__ specifies the SMARTCARD Handle. 598 * @retval None 599 */ 600 #define __HAL_SMARTCARD_CLEAR_OREFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_OREF) 601 602 /** @brief Clear the SMARTCARD IDLE pending flag. 603 * @param __HANDLE__ specifies the SMARTCARD Handle. 604 * @retval None 605 */ 606 #define __HAL_SMARTCARD_CLEAR_IDLEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_IDLEF) 607 608 /** @brief Check whether the specified Smartcard flag is set or not. 609 * @param __HANDLE__ specifies the SMARTCARD Handle. 610 * @param __FLAG__ specifies the flag to check. 611 * This parameter can be one of the following values: 612 * @arg @ref SMARTCARD_FLAG_TCBGT Transmission complete before guard time flag (when flag available) 613 * @arg @ref SMARTCARD_FLAG_REACK Receive enable acknowledge flag 614 * @arg @ref SMARTCARD_FLAG_TEACK Transmit enable acknowledge flag 615 * @arg @ref SMARTCARD_FLAG_BUSY Busy flag 616 * @arg @ref SMARTCARD_FLAG_EOBF End of block flag 617 * @arg @ref SMARTCARD_FLAG_RTOF Receiver timeout flag 618 * @arg @ref SMARTCARD_FLAG_TXE Transmit data register empty flag 619 * @arg @ref SMARTCARD_FLAG_TC Transmission complete flag 620 * @arg @ref SMARTCARD_FLAG_RXNE Receive data register not empty flag 621 * @arg @ref SMARTCARD_FLAG_IDLE Idle line detection flag 622 * @arg @ref SMARTCARD_FLAG_ORE Overrun error flag 623 * @arg @ref SMARTCARD_FLAG_NE Noise error flag 624 * @arg @ref SMARTCARD_FLAG_FE Framing error flag 625 * @arg @ref SMARTCARD_FLAG_PE Parity error flag 626 * @retval The new state of __FLAG__ (TRUE or FALSE). 627 */ 628 #define __HAL_SMARTCARD_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__)) 629 630 /** @brief Enable the specified SmartCard interrupt. 631 * @param __HANDLE__ specifies the SMARTCARD Handle. 632 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to enable. 633 * This parameter can be one of the following values: 634 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 635 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 636 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 637 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 638 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before 639 * guard time interrupt (when interruption available) 640 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 641 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 642 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 643 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 644 * @retval None 645 */ 646 #define __HAL_SMARTCARD_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 647 SMARTCARD_CR_POS) == 1U)?\ 648 ((__HANDLE__)->Instance->CR1 |= (1UL <<\ 649 ((__INTERRUPT__) & SMARTCARD_IT_MASK))):\ 650 ((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 651 SMARTCARD_CR_POS) == 2U)?\ 652 ((__HANDLE__)->Instance->CR2 |= (1UL <<\ 653 ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 654 ((__HANDLE__)->Instance->CR3 |= (1UL <<\ 655 ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 656 657 /** @brief Disable the specified SmartCard interrupt. 658 * @param __HANDLE__ specifies the SMARTCARD Handle. 659 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to disable. 660 * This parameter can be one of the following values: 661 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 662 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 663 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 664 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 665 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard 666 * 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 * @retval None 672 */ 673 #define __HAL_SMARTCARD_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 674 SMARTCARD_CR_POS) == 1U)?\ 675 ((__HANDLE__)->Instance->CR1 &= ~ (1U <<\ 676 ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 677 ((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 678 SMARTCARD_CR_POS) == 2U)?\ 679 ((__HANDLE__)->Instance->CR2 &= ~ (1U <<\ 680 ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 681 ((__HANDLE__)->Instance->CR3 &= ~ (1U <<\ 682 ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 683 684 /** @brief Check whether the specified SmartCard interrupt has occurred or not. 685 * @param __HANDLE__ specifies the SMARTCARD Handle. 686 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to check. 687 * This parameter can be one of the following values: 688 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 689 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 690 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 691 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 692 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time 693 * interrupt (when interruption available) 694 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 695 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 696 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 697 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 698 * @retval The new state of __INTERRUPT__ (SET or RESET). 699 */ 700 #define __HAL_SMARTCARD_GET_IT(__HANDLE__, __INTERRUPT__) (\ 701 (((__HANDLE__)->Instance->ISR & (0x01UL << (((__INTERRUPT__)\ 702 & SMARTCARD_ISR_MASK)>> SMARTCARD_ISR_POS)))!= 0U)\ 703 ? SET : RESET) 704 705 /** @brief Check whether the specified SmartCard interrupt source is enabled or not. 706 * @param __HANDLE__ specifies the SMARTCARD Handle. 707 * @param __INTERRUPT__ specifies the SMARTCARD interrupt source to check. 708 * This parameter can be one of the following values: 709 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 710 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 711 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 712 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 713 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time 714 * interrupt (when interruption available) 715 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 716 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 717 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 718 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 719 * @retval The new state of __INTERRUPT__ (SET or RESET). 720 */ 721 #define __HAL_SMARTCARD_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 722 SMARTCARD_CR_POS) == 0x01U)?\ 723 (__HANDLE__)->Instance->CR1 : \ 724 (((((__INTERRUPT__) & SMARTCARD_CR_MASK) >>\ 725 SMARTCARD_CR_POS) == 0x02U)?\ 726 (__HANDLE__)->Instance->CR2 : \ 727 (__HANDLE__)->Instance->CR3)) &\ 728 (0x01UL << (((uint16_t)(__INTERRUPT__))\ 729 & SMARTCARD_IT_MASK))) != 0U)\ 730 ? SET : RESET) 731 732 /** @brief Clear the specified SMARTCARD ISR flag, in setting the proper ICR register flag. 733 * @param __HANDLE__ specifies the SMARTCARD Handle. 734 * @param __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set 735 * to clear the corresponding interrupt. 736 * This parameter can be one of the following values: 737 * @arg @ref SMARTCARD_CLEAR_PEF Parity error clear flag 738 * @arg @ref SMARTCARD_CLEAR_FEF Framing error clear flag 739 * @arg @ref SMARTCARD_CLEAR_NEF Noise detected clear flag 740 * @arg @ref SMARTCARD_CLEAR_OREF OverRun error clear flag 741 * @arg @ref SMARTCARD_CLEAR_IDLEF Idle line detection clear flag 742 * @arg @ref SMARTCARD_CLEAR_TCF Transmission complete clear flag 743 * @arg @ref SMARTCARD_CLEAR_TCBGTF Transmission complete before guard time clear flag (when flag available) 744 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 745 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 746 * @retval None 747 */ 748 #define __HAL_SMARTCARD_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR |= (uint32_t)(__IT_CLEAR__)) 749 750 /** @brief Set a specific SMARTCARD request flag. 751 * @param __HANDLE__ specifies the SMARTCARD Handle. 752 * @param __REQ__ specifies the request flag to set 753 * This parameter can be one of the following values: 754 * @arg @ref SMARTCARD_RXDATA_FLUSH_REQUEST Receive data flush Request 755 * @arg @ref SMARTCARD_TXDATA_FLUSH_REQUEST Transmit data flush Request 756 * @retval None 757 */ 758 #define __HAL_SMARTCARD_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__)) 759 760 /** @brief Enable the SMARTCARD one bit sample method. 761 * @param __HANDLE__ specifies the SMARTCARD Handle. 762 * @retval None 763 */ 764 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT) 765 766 /** @brief Disable the SMARTCARD one bit sample method. 767 * @param __HANDLE__ specifies the SMARTCARD Handle. 768 * @retval None 769 */ 770 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3\ 771 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT)) 772 773 /** @brief Enable the USART associated to the SMARTCARD Handle. 774 * @param __HANDLE__ specifies the SMARTCARD Handle. 775 * @retval None 776 */ 777 #define __HAL_SMARTCARD_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE) 778 779 /** @brief Disable the USART associated to the SMARTCARD Handle 780 * @param __HANDLE__ specifies the SMARTCARD Handle. 781 * @retval None 782 */ 783 #define __HAL_SMARTCARD_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE) 784 785 /** 786 * @} 787 */ 788 789 /* Private macros -------------------------------------------------------------*/ 790 /** @defgroup SMARTCARD_Private_Macros SMARTCARD Private Macros 791 * @{ 792 */ 793 794 795 /** @brief Check the Baud rate range. 796 * @note The maximum Baud Rate is derived from the maximum clock on F0 (48 MHz) 797 * divided by the oversampling used on the SMARTCARD (i.e. 16). 798 * @param __BAUDRATE__ Baud rate set by the configuration function. 799 * @retval Test result (TRUE or FALSE) 800 */ 801 #define IS_SMARTCARD_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 6000000U) 802 803 /** @brief Check the block length range. 804 * @note The maximum SMARTCARD block length is 0xFF. 805 * @param __LENGTH__ block length. 806 * @retval Test result (TRUE or FALSE) 807 */ 808 #define IS_SMARTCARD_BLOCKLENGTH(__LENGTH__) ((__LENGTH__) <= 0xFFU) 809 810 /** @brief Check the receiver timeout value. 811 * @note The maximum SMARTCARD receiver timeout value is 0xFFFFFF. 812 * @param __TIMEOUTVALUE__ receiver timeout value. 813 * @retval Test result (TRUE or FALSE) 814 */ 815 #define IS_SMARTCARD_TIMEOUT_VALUE(__TIMEOUTVALUE__) ((__TIMEOUTVALUE__) <= 0xFFFFFFU) 816 817 /** @brief Check the SMARTCARD autoretry counter value. 818 * @note The maximum number of retransmissions is 0x7. 819 * @param __COUNT__ number of retransmissions. 820 * @retval Test result (TRUE or FALSE) 821 */ 822 #define IS_SMARTCARD_AUTORETRY_COUNT(__COUNT__) ((__COUNT__) <= 0x7U) 823 824 /** @brief Ensure that SMARTCARD frame length is valid. 825 * @param __LENGTH__ SMARTCARD frame length. 826 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 827 */ 828 #define IS_SMARTCARD_WORD_LENGTH(__LENGTH__) ((__LENGTH__) == SMARTCARD_WORDLENGTH_9B) 829 830 /** @brief Ensure that SMARTCARD frame number of stop bits is valid. 831 * @param __STOPBITS__ SMARTCARD frame number of stop bits. 832 * @retval SET (__STOPBITS__ is valid) or RESET (__STOPBITS__ is invalid) 833 */ 834 #define IS_SMARTCARD_STOPBITS(__STOPBITS__) (((__STOPBITS__) == SMARTCARD_STOPBITS_0_5) ||\ 835 ((__STOPBITS__) == SMARTCARD_STOPBITS_1_5)) 836 837 /** @brief Ensure that SMARTCARD frame parity is valid. 838 * @param __PARITY__ SMARTCARD frame parity. 839 * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid) 840 */ 841 #define IS_SMARTCARD_PARITY(__PARITY__) (((__PARITY__) == SMARTCARD_PARITY_EVEN) || \ 842 ((__PARITY__) == SMARTCARD_PARITY_ODD)) 843 844 /** @brief Ensure that SMARTCARD communication mode is valid. 845 * @param __MODE__ SMARTCARD communication mode. 846 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid) 847 */ 848 #define IS_SMARTCARD_MODE(__MODE__) ((((__MODE__) & 0xFFF3U) == 0x00U) && ((__MODE__) != 0x00U)) 849 850 /** @brief Ensure that SMARTCARD frame polarity is valid. 851 * @param __CPOL__ SMARTCARD frame polarity. 852 * @retval SET (__CPOL__ is valid) or RESET (__CPOL__ is invalid) 853 */ 854 #define IS_SMARTCARD_POLARITY(__CPOL__) (((__CPOL__) == SMARTCARD_POLARITY_LOW)\ 855 || ((__CPOL__) == SMARTCARD_POLARITY_HIGH)) 856 857 /** @brief Ensure that SMARTCARD frame phase is valid. 858 * @param __CPHA__ SMARTCARD frame phase. 859 * @retval SET (__CPHA__ is valid) or RESET (__CPHA__ is invalid) 860 */ 861 #define IS_SMARTCARD_PHASE(__CPHA__) (((__CPHA__) == SMARTCARD_PHASE_1EDGE) || ((__CPHA__) == SMARTCARD_PHASE_2EDGE)) 862 863 /** @brief Ensure that SMARTCARD frame last bit clock pulse setting is valid. 864 * @param __LASTBIT__ SMARTCARD frame last bit clock pulse setting. 865 * @retval SET (__LASTBIT__ is valid) or RESET (__LASTBIT__ is invalid) 866 */ 867 #define IS_SMARTCARD_LASTBIT(__LASTBIT__) (((__LASTBIT__) == SMARTCARD_LASTBIT_DISABLE) || \ 868 ((__LASTBIT__) == SMARTCARD_LASTBIT_ENABLE)) 869 870 /** @brief Ensure that SMARTCARD frame sampling is valid. 871 * @param __ONEBIT__ SMARTCARD frame sampling. 872 * @retval SET (__ONEBIT__ is valid) or RESET (__ONEBIT__ is invalid) 873 */ 874 #define IS_SMARTCARD_ONE_BIT_SAMPLE(__ONEBIT__) (((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_DISABLE) || \ 875 ((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_ENABLE)) 876 877 /** @brief Ensure that SMARTCARD NACK transmission setting is valid. 878 * @param __NACK__ SMARTCARD NACK transmission setting. 879 * @retval SET (__NACK__ is valid) or RESET (__NACK__ is invalid) 880 */ 881 #define IS_SMARTCARD_NACK(__NACK__) (((__NACK__) == SMARTCARD_NACK_ENABLE) || \ 882 ((__NACK__) == SMARTCARD_NACK_DISABLE)) 883 884 /** @brief Ensure that SMARTCARD receiver timeout setting is valid. 885 * @param __TIMEOUT__ SMARTCARD receiver timeout setting. 886 * @retval SET (__TIMEOUT__ is valid) or RESET (__TIMEOUT__ is invalid) 887 */ 888 #define IS_SMARTCARD_TIMEOUT(__TIMEOUT__) (((__TIMEOUT__) == SMARTCARD_TIMEOUT_DISABLE) || \ 889 ((__TIMEOUT__) == SMARTCARD_TIMEOUT_ENABLE)) 890 891 /** @brief Ensure that SMARTCARD advanced features initialization is valid. 892 * @param __INIT__ SMARTCARD advanced features initialization. 893 * @retval SET (__INIT__ is valid) or RESET (__INIT__ is invalid) 894 */ 895 #define IS_SMARTCARD_ADVFEATURE_INIT(__INIT__) ((__INIT__) <= (SMARTCARD_ADVFEATURE_NO_INIT | \ 896 SMARTCARD_ADVFEATURE_TXINVERT_INIT | \ 897 SMARTCARD_ADVFEATURE_RXINVERT_INIT | \ 898 SMARTCARD_ADVFEATURE_DATAINVERT_INIT | \ 899 SMARTCARD_ADVFEATURE_SWAP_INIT | \ 900 SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT | \ 901 SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT | \ 902 SMARTCARD_ADVFEATURE_MSBFIRST_INIT)) 903 904 /** @brief Ensure that SMARTCARD frame TX inversion setting is valid. 905 * @param __TXINV__ SMARTCARD frame TX inversion setting. 906 * @retval SET (__TXINV__ is valid) or RESET (__TXINV__ is invalid) 907 */ 908 #define IS_SMARTCARD_ADVFEATURE_TXINV(__TXINV__) (((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_DISABLE) || \ 909 ((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_ENABLE)) 910 911 /** @brief Ensure that SMARTCARD frame RX inversion setting is valid. 912 * @param __RXINV__ SMARTCARD frame RX inversion setting. 913 * @retval SET (__RXINV__ is valid) or RESET (__RXINV__ is invalid) 914 */ 915 #define IS_SMARTCARD_ADVFEATURE_RXINV(__RXINV__) (((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_DISABLE) || \ 916 ((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_ENABLE)) 917 918 /** @brief Ensure that SMARTCARD frame data inversion setting is valid. 919 * @param __DATAINV__ SMARTCARD frame data inversion setting. 920 * @retval SET (__DATAINV__ is valid) or RESET (__DATAINV__ is invalid) 921 */ 922 #define IS_SMARTCARD_ADVFEATURE_DATAINV(__DATAINV__) (((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_DISABLE) || \ 923 ((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_ENABLE)) 924 925 /** @brief Ensure that SMARTCARD frame RX/TX pins swap setting is valid. 926 * @param __SWAP__ SMARTCARD frame RX/TX pins swap setting. 927 * @retval SET (__SWAP__ is valid) or RESET (__SWAP__ is invalid) 928 */ 929 #define IS_SMARTCARD_ADVFEATURE_SWAP(__SWAP__) (((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_DISABLE) || \ 930 ((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_ENABLE)) 931 932 /** @brief Ensure that SMARTCARD frame overrun setting is valid. 933 * @param __OVERRUN__ SMARTCARD frame overrun setting. 934 * @retval SET (__OVERRUN__ is valid) or RESET (__OVERRUN__ is invalid) 935 */ 936 #define IS_SMARTCARD_OVERRUN(__OVERRUN__) (((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_ENABLE) || \ 937 ((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_DISABLE)) 938 939 /** @brief Ensure that SMARTCARD DMA enabling or disabling on error setting is valid. 940 * @param __DMA__ SMARTCARD DMA enabling or disabling on error setting. 941 * @retval SET (__DMA__ is valid) or RESET (__DMA__ is invalid) 942 */ 943 #define IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(__DMA__) (((__DMA__) == SMARTCARD_ADVFEATURE_DMA_ENABLEONRXERROR) || \ 944 ((__DMA__) == SMARTCARD_ADVFEATURE_DMA_DISABLEONRXERROR)) 945 946 /** @brief Ensure that SMARTCARD frame MSB first setting is valid. 947 * @param __MSBFIRST__ SMARTCARD frame MSB first setting. 948 * @retval SET (__MSBFIRST__ is valid) or RESET (__MSBFIRST__ is invalid) 949 */ 950 #define IS_SMARTCARD_ADVFEATURE_MSBFIRST(__MSBFIRST__) (((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_DISABLE) || \ 951 ((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_ENABLE)) 952 953 /** @brief Ensure that SMARTCARD request parameter is valid. 954 * @param __PARAM__ SMARTCARD request parameter. 955 * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid) 956 */ 957 #define IS_SMARTCARD_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == SMARTCARD_RXDATA_FLUSH_REQUEST) || \ 958 ((__PARAM__) == SMARTCARD_TXDATA_FLUSH_REQUEST)) 959 960 /** 961 * @} 962 */ 963 964 /* Include SMARTCARD HAL Extended module */ 965 #include "stm32f0xx_hal_smartcard_ex.h" 966 967 /* Exported functions --------------------------------------------------------*/ 968 /** @addtogroup SMARTCARD_Exported_Functions 969 * @{ 970 */ 971 972 /* Initialization and de-initialization functions ****************************/ 973 /** @addtogroup SMARTCARD_Exported_Functions_Group1 974 * @{ 975 */ 976 977 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard); 978 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard); 979 void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard); 980 void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard); 981 982 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 983 /* Callbacks Register/UnRegister functions ***********************************/ 984 HAL_StatusTypeDef HAL_SMARTCARD_RegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, 985 HAL_SMARTCARD_CallbackIDTypeDef CallbackID, 986 pSMARTCARD_CallbackTypeDef pCallback); 987 HAL_StatusTypeDef HAL_SMARTCARD_UnRegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, 988 HAL_SMARTCARD_CallbackIDTypeDef CallbackID); 989 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 990 991 /** 992 * @} 993 */ 994 995 /* IO operation functions *****************************************************/ 996 /** @addtogroup SMARTCARD_Exported_Functions_Group2 997 * @{ 998 */ 999 1000 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, 1001 uint32_t Timeout); 1002 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, 1003 uint32_t Timeout); 1004 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1005 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1006 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1007 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 1008 /* Transfer Abort functions */ 1009 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsmartcard); 1010 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsmartcard); 1011 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsmartcard); 1012 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1013 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1014 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsmartcard); 1015 1016 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard); 1017 void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1018 void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1019 void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1020 void HAL_SMARTCARD_AbortCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1021 void HAL_SMARTCARD_AbortTransmitCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1022 void HAL_SMARTCARD_AbortReceiveCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 1023 1024 /** 1025 * @} 1026 */ 1027 1028 /* Peripheral State and Error functions ***************************************/ 1029 /** @addtogroup SMARTCARD_Exported_Functions_Group4 1030 * @{ 1031 */ 1032 1033 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsmartcard); 1034 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsmartcard); 1035 1036 /** 1037 * @} 1038 */ 1039 1040 /** 1041 * @} 1042 */ 1043 1044 /** 1045 * @} 1046 */ 1047 1048 /** 1049 * @} 1050 */ 1051 #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC) */ 1052 #ifdef __cplusplus 1053 } 1054 #endif 1055 1056 #endif /* STM32F0xx_HAL_SMARTCARD_H */ 1057 1058 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 1059
