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