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