|
STM32L486xx HAL User Manual
|
00001 /** 00002 ****************************************************************************** 00003 * @file stm32l4xx_hal_smartcard.h 00004 * @author MCD Application Team 00005 * @brief Header file of SMARTCARD HAL module. 00006 ****************************************************************************** 00007 * @attention 00008 * 00009 * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> 00010 * 00011 * Redistribution and use in source and binary forms, with or without modification, 00012 * are permitted provided that the following conditions are met: 00013 * 1. Redistributions of source code must retain the above copyright notice, 00014 * this list of conditions and the following disclaimer. 00015 * 2. Redistributions in binary form must reproduce the above copyright notice, 00016 * this list of conditions and the following disclaimer in the documentation 00017 * and/or other materials provided with the distribution. 00018 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00019 * may be used to endorse or promote products derived from this software 00020 * without specific prior written permission. 00021 * 00022 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00023 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00024 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00025 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00026 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00027 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00028 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00029 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00030 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00031 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00032 * 00033 ****************************************************************************** 00034 */ 00035 00036 /* Define to prevent recursive inclusion -------------------------------------*/ 00037 #ifndef __STM32L4xx_HAL_SMARTCARD_H 00038 #define __STM32L4xx_HAL_SMARTCARD_H 00039 00040 #ifdef __cplusplus 00041 extern "C" { 00042 #endif 00043 00044 /* Includes ------------------------------------------------------------------*/ 00045 #include "stm32l4xx_hal_def.h" 00046 00047 /** @addtogroup STM32L4xx_HAL_Driver 00048 * @{ 00049 */ 00050 00051 /** @addtogroup SMARTCARD 00052 * @{ 00053 */ 00054 00055 /* Exported types ------------------------------------------------------------*/ 00056 /** @defgroup SMARTCARD_Exported_Types SMARTCARD Exported Types 00057 * @{ 00058 */ 00059 00060 /** 00061 * @brief SMARTCARD Init Structure definition 00062 */ 00063 typedef struct 00064 { 00065 uint32_t BaudRate; /*!< Configures the SmartCard communication baud rate. 00066 The baud rate register is computed using the following formula: 00067 Baud Rate Register = ((usart_ker_ckpres) / ((hsmartcard->Init.BaudRate))) 00068 where usart_ker_ckpres is the USART input clock divided by a prescaler */ 00069 00070 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 00071 This parameter @ref SMARTCARD_Word_Length can only be set to 9 (8 data + 1 parity bits). */ 00072 00073 uint32_t StopBits; /*!< Specifies the number of stop bits. 00074 This parameter can be a value of @ref SMARTCARD_Stop_Bits. */ 00075 00076 uint16_t Parity; /*!< Specifies the parity mode. 00077 This parameter can be a value of @ref SMARTCARD_Parity 00078 @note The parity is enabled by default (PCE is forced to 1). 00079 Since the WordLength is forced to 8 bits + parity, M is 00080 forced to 1 and the parity bit is the 9th bit. */ 00081 00082 uint16_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled. 00083 This parameter can be a value of @ref SMARTCARD_Mode */ 00084 00085 uint16_t CLKPolarity; /*!< Specifies the steady state of the serial clock. 00086 This parameter can be a value of @ref SMARTCARD_Clock_Polarity */ 00087 00088 uint16_t CLKPhase; /*!< Specifies the clock transition on which the bit capture is made. 00089 This parameter can be a value of @ref SMARTCARD_Clock_Phase */ 00090 00091 uint16_t CLKLastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted 00092 data bit (MSB) has to be output on the SCLK pin in synchronous mode. 00093 This parameter can be a value of @ref SMARTCARD_Last_Bit */ 00094 00095 uint16_t OneBitSampling; /*!< Specifies whether a single sample or three samples' majority vote is selected. 00096 Selecting the single sample method increases the receiver tolerance to clock 00097 deviations. This parameter can be a value of @ref SMARTCARD_OneBit_Sampling. */ 00098 00099 uint8_t Prescaler; /*!< Specifies the SmartCard Prescaler. 00100 This parameter can be any value from 0x01 to 0x1F. Prescaler value is multiplied 00101 by 2 to give the division factor of the source clock frequency */ 00102 00103 uint8_t GuardTime; /*!< Specifies the SmartCard Guard Time applied after stop bits. */ 00104 00105 uint16_t NACKEnable; /*!< Specifies whether the SmartCard NACK transmission is enabled 00106 in case of parity error. 00107 This parameter can be a value of @ref SMARTCARD_NACK_Enable */ 00108 00109 uint32_t TimeOutEnable; /*!< Specifies whether the receiver timeout is enabled. 00110 This parameter can be a value of @ref SMARTCARD_Timeout_Enable*/ 00111 00112 uint32_t TimeOutValue; /*!< Specifies the receiver time out value in number of baud blocks: 00113 it is used to implement the Character Wait Time (CWT) and 00114 Block Wait Time (BWT). It is coded over 24 bits. */ 00115 00116 uint8_t BlockLength; /*!< Specifies the SmartCard Block Length in T=1 Reception mode. 00117 This parameter can be any value from 0x0 to 0xFF */ 00118 00119 uint8_t AutoRetryCount; /*!< Specifies the SmartCard auto-retry count (number of retries in 00120 receive and transmit mode). When set to 0, retransmission is 00121 disabled. Otherwise, its maximum value is 7 (before signalling 00122 an error) */ 00123 00124 #if defined(USART_PRESC_PRESCALER) 00125 uint32_t ClockPrescaler; /*!< Specifies the prescaler value used to divide the USART clock source. 00126 This parameter can be a value of @ref SMARTCARD_ClockPrescaler. */ 00127 #endif 00128 00129 } SMARTCARD_InitTypeDef; 00130 00131 /** 00132 * @brief SMARTCARD advanced features initalization structure definition 00133 */ 00134 typedef struct 00135 { 00136 uint32_t AdvFeatureInit; /*!< Specifies which advanced SMARTCARD features is initialized. Several 00137 advanced features may be initialized at the same time. This parameter 00138 can be a value of @ref SMARTCARDEx_Advanced_Features_Initialization_Type */ 00139 00140 uint32_t TxPinLevelInvert; /*!< Specifies whether the TX pin active level is inverted. 00141 This parameter can be a value of @ref SMARTCARD_Tx_Inv */ 00142 00143 uint32_t RxPinLevelInvert; /*!< Specifies whether the RX pin active level is inverted. 00144 This parameter can be a value of @ref SMARTCARD_Rx_Inv */ 00145 00146 uint32_t DataInvert; /*!< Specifies whether data are inverted (positive/direct logic 00147 vs negative/inverted logic). 00148 This parameter can be a value of @ref SMARTCARD_Data_Inv */ 00149 00150 uint32_t Swap; /*!< Specifies whether TX and RX pins are swapped. 00151 This parameter can be a value of @ref SMARTCARD_Rx_Tx_Swap */ 00152 00153 uint32_t OverrunDisable; /*!< Specifies whether the reception overrun detection is disabled. 00154 This parameter can be a value of @ref SMARTCARD_Overrun_Disable */ 00155 00156 uint32_t DMADisableonRxError; /*!< Specifies whether the DMA is disabled in case of reception error. 00157 This parameter can be a value of @ref SMARTCARD_DMA_Disable_on_Rx_Error */ 00158 00159 uint32_t MSBFirst; /*!< Specifies whether MSB is sent first on UART line. 00160 This parameter can be a value of @ref SMARTCARD_MSB_First */ 00161 00162 uint16_t TxCompletionIndication; /*!< Specifies which transmission completion indication is used: before (when 00163 relevant flag is available) or once guard time period has elapsed. 00164 This parameter can be a value of @ref SMARTCARDEx_Transmission_Completion_Indication. */ 00165 } SMARTCARD_AdvFeatureInitTypeDef; 00166 00167 /** 00168 * @brief HAL SMARTCARD State structures definition 00169 * @note HAL SMARTCARD State value is a combination of 2 different substates: gState and RxState. 00170 * - gState contains SMARTCARD state information related to global Handle management 00171 * and also information related to Tx operations. 00172 * gState value coding follow below described bitmap : 00173 * b7-b6 Error information 00174 * 00 : No Error 00175 * 01 : (Not Used) 00176 * 10 : Timeout 00177 * 11 : Error 00178 * b5 IP initilisation status 00179 * 0 : Reset (IP not initialized) 00180 * 1 : Init done (IP not initialized. HAL SMARTCARD Init function already called) 00181 * b4-b3 (not used) 00182 * xx : Should be set to 00 00183 * b2 Intrinsic process state 00184 * 0 : Ready 00185 * 1 : Busy (IP busy with some configuration or internal operations) 00186 * b1 (not used) 00187 * x : Should be set to 0 00188 * b0 Tx state 00189 * 0 : Ready (no Tx operation ongoing) 00190 * 1 : Busy (Tx operation ongoing) 00191 * - RxState contains information related to Rx operations. 00192 * RxState value coding follow below described bitmap : 00193 * b7-b6 (not used) 00194 * xx : Should be set to 00 00195 * b5 IP initilisation status 00196 * 0 : Reset (IP not initialized) 00197 * 1 : Init done (IP not initialized) 00198 * b4-b2 (not used) 00199 * xxx : Should be set to 000 00200 * b1 Rx state 00201 * 0 : Ready (no Rx operation ongoing) 00202 * 1 : Busy (Rx operation ongoing) 00203 * b0 (not used) 00204 * x : Should be set to 0. 00205 */ 00206 typedef enum 00207 { 00208 HAL_SMARTCARD_STATE_RESET = 0x00U, /*!< Peripheral is not initialized 00209 Value is allowed for gState and RxState */ 00210 HAL_SMARTCARD_STATE_READY = 0x20U, /*!< Peripheral Initialized and ready for use 00211 Value is allowed for gState and RxState */ 00212 HAL_SMARTCARD_STATE_BUSY = 0x24U, /*!< an internal process is ongoing 00213 Value is allowed for gState only */ 00214 HAL_SMARTCARD_STATE_BUSY_TX = 0x21U, /*!< Data Transmission process is ongoing 00215 Value is allowed for gState only */ 00216 HAL_SMARTCARD_STATE_BUSY_RX = 0x22U, /*!< Data Reception process is ongoing 00217 Value is allowed for RxState only */ 00218 HAL_SMARTCARD_STATE_BUSY_TX_RX = 0x23U, /*!< Data Transmission and Reception process is ongoing 00219 Not to be used for neither gState nor RxState. 00220 Value is result of combination (Or) between gState and RxState values */ 00221 HAL_SMARTCARD_STATE_TIMEOUT = 0xA0U, /*!< Timeout state 00222 Value is allowed for gState only */ 00223 HAL_SMARTCARD_STATE_ERROR = 0xE0U /*!< Error 00224 Value is allowed for gState only */ 00225 } HAL_SMARTCARD_StateTypeDef; 00226 00227 /** 00228 * @brief SMARTCARD handle Structure definition 00229 */ 00230 typedef struct __SMARTCARD_HandleTypeDef 00231 { 00232 USART_TypeDef *Instance; /*!< USART registers base address */ 00233 00234 SMARTCARD_InitTypeDef Init; /*!< SmartCard communication parameters */ 00235 00236 SMARTCARD_AdvFeatureInitTypeDef AdvancedInit; /*!< SmartCard advanced features initialization parameters */ 00237 00238 uint8_t *pTxBuffPtr; /*!< Pointer to SmartCard Tx transfer Buffer */ 00239 00240 uint16_t TxXferSize; /*!< SmartCard Tx Transfer size */ 00241 00242 __IO uint16_t TxXferCount; /*!< SmartCard Tx Transfer Counter */ 00243 00244 uint8_t *pRxBuffPtr; /*!< Pointer to SmartCard Rx transfer Buffer */ 00245 00246 uint16_t RxXferSize; /*!< SmartCard Rx Transfer size */ 00247 00248 __IO uint16_t RxXferCount; /*!< SmartCard Rx Transfer Counter */ 00249 00250 #if defined(USART_CR1_FIFOEN) 00251 uint16_t NbRxDataToProcess; /*!< Number of data to process during RX ISR execution */ 00252 00253 uint16_t NbTxDataToProcess; /*!< Number of data to process during TX ISR execution */ 00254 00255 uint32_t FifoMode; /*!< Specifies if the FIFO mode will be used. 00256 This parameter can be a value of @ref SMARTCARDEx_FIFO_mode. */ 00257 #endif 00258 00259 void (*RxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Rx IRQ handler */ 00260 00261 void (*TxISR)(struct __SMARTCARD_HandleTypeDef *huart); /*!< Function pointer on Tx IRQ handler */ 00262 00263 DMA_HandleTypeDef *hdmatx; /*!< SmartCard Tx DMA Handle parameters */ 00264 00265 DMA_HandleTypeDef *hdmarx; /*!< SmartCard Rx DMA Handle parameters */ 00266 00267 HAL_LockTypeDef Lock; /*!< Locking object */ 00268 00269 __IO HAL_SMARTCARD_StateTypeDef gState; /*!< SmartCard state information related to global Handle management 00270 and also related to Tx operations. 00271 This parameter can be a value of @ref HAL_SMARTCARD_StateTypeDef */ 00272 00273 __IO HAL_SMARTCARD_StateTypeDef RxState; /*!< SmartCard state information related to Rx operations. 00274 This parameter can be a value of @ref HAL_SMARTCARD_StateTypeDef */ 00275 00276 uint32_t ErrorCode; /*!< SmartCard Error code */ 00277 00278 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 00279 void (* TxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Tx Complete Callback */ 00280 00281 void (* RxCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Rx Complete Callback */ 00282 00283 void (* ErrorCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Error Callback */ 00284 00285 void (* AbortCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Complete Callback */ 00286 00287 void (* AbortTransmitCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Transmit Complete Callback */ 00288 00289 void (* AbortReceiveCpltCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Abort Receive Complete Callback */ 00290 00291 void (* RxFifoFullCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Rx Fifo Full Callback */ 00292 00293 void (* TxFifoEmptyCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Tx Fifo Empty Callback */ 00294 00295 00296 void (* MspInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp Init callback */ 00297 00298 void (* MspDeInitCallback)(struct __SMARTCARD_HandleTypeDef *hsmartcard); /*!< SMARTCARD Msp DeInit callback */ 00299 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 00300 00301 } SMARTCARD_HandleTypeDef; 00302 00303 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 00304 /** 00305 * @brief HAL SMARTCARD Callback ID enumeration definition 00306 */ 00307 typedef enum 00308 { 00309 HAL_SMARTCARD_TX_COMPLETE_CB_ID = 0x00U, /*!< SMARTCARD Tx Complete Callback ID */ 00310 HAL_SMARTCARD_RX_COMPLETE_CB_ID = 0x01U, /*!< SMARTCARD Rx Complete Callback ID */ 00311 HAL_SMARTCARD_ERROR_CB_ID = 0x02U, /*!< SMARTCARD Error Callback ID */ 00312 HAL_SMARTCARD_ABORT_COMPLETE_CB_ID = 0x03U, /*!< SMARTCARD Abort Complete Callback ID */ 00313 HAL_SMARTCARD_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x04U, /*!< SMARTCARD Abort Transmit Complete Callback ID */ 00314 HAL_SMARTCARD_ABORT_RECEIVE_COMPLETE_CB_ID = 0x05U, /*!< SMARTCARD Abort Receive Complete Callback ID */ 00315 HAL_SMARTCARD_RX_FIFO_FULL_CB_ID = 0x06U, /*!< SMARTCARD Rx Fifo Full Callback ID */ 00316 HAL_SMARTCARD_TX_FIFO_EMPTY_CB_ID = 0x07U, /*!< SMARTCARD Tx Fifo Empty Callback ID */ 00317 00318 HAL_SMARTCARD_MSPINIT_CB_ID = 0x08U, /*!< SMARTCARD MspInit callback ID */ 00319 HAL_SMARTCARD_MSPDEINIT_CB_ID = 0x09U /*!< SMARTCARD MspDeInit callback ID */ 00320 00321 } HAL_SMARTCARD_CallbackIDTypeDef; 00322 00323 /** 00324 * @brief HAL SMARTCARD Callback pointer definition 00325 */ 00326 typedef void (*pSMARTCARD_CallbackTypeDef)(SMARTCARD_HandleTypeDef *hsmartcard); /*!< pointer to an SMARTCARD callback function */ 00327 00328 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 00329 00330 /** 00331 * @brief SMARTCARD clock sources 00332 */ 00333 typedef enum 00334 { 00335 SMARTCARD_CLOCKSOURCE_PCLK1 = 0x00, /*!< PCLK1 clock source */ 00336 SMARTCARD_CLOCKSOURCE_PCLK2 = 0x01, /*!< PCLK2 clock source */ 00337 SMARTCARD_CLOCKSOURCE_HSI = 0x02, /*!< HSI clock source */ 00338 SMARTCARD_CLOCKSOURCE_SYSCLK = 0x04, /*!< SYSCLK clock source */ 00339 SMARTCARD_CLOCKSOURCE_LSE = 0x08, /*!< LSE clock source */ 00340 SMARTCARD_CLOCKSOURCE_UNDEFINED = 0x10 /*!< undefined clock source */ 00341 } SMARTCARD_ClockSourceTypeDef; 00342 00343 /** 00344 * @} 00345 */ 00346 00347 /* Exported constants --------------------------------------------------------*/ 00348 /** @defgroup SMARTCARD_Exported_Constants SMARTCARD Exported Constants 00349 * @{ 00350 */ 00351 00352 /** @defgroup SMARTCARD_Error_Definition SMARTCARD Error Code Definition 00353 * @{ 00354 */ 00355 #define HAL_SMARTCARD_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */ 00356 #define HAL_SMARTCARD_ERROR_PE ((uint32_t)0x00000001U) /*!< Parity error */ 00357 #define HAL_SMARTCARD_ERROR_NE ((uint32_t)0x00000002U) /*!< Noise error */ 00358 #define HAL_SMARTCARD_ERROR_FE ((uint32_t)0x00000004U) /*!< frame error */ 00359 #define HAL_SMARTCARD_ERROR_ORE ((uint32_t)0x00000008U) /*!< Overrun error */ 00360 #define HAL_SMARTCARD_ERROR_DMA ((uint32_t)0x00000010U) /*!< DMA transfer error */ 00361 #define HAL_SMARTCARD_ERROR_RTO ((uint32_t)0x00000020U) /*!< Receiver TimeOut error */ 00362 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 00363 #define HAL_SMARTCARD_ERROR_INVALID_CALLBACK ((uint32_t)0x00000040U) /*!< Invalid Callback error */ 00364 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 00365 /** 00366 * @} 00367 */ 00368 00369 /** @defgroup SMARTCARD_Word_Length SMARTCARD Word Length 00370 * @{ 00371 */ 00372 #define SMARTCARD_WORDLENGTH_9B USART_CR1_M0 /*!< SMARTCARD frame length */ 00373 /** 00374 * @} 00375 */ 00376 00377 /** @defgroup SMARTCARD_Stop_Bits SMARTCARD Number of Stop Bits 00378 * @{ 00379 */ 00380 #define SMARTCARD_STOPBITS_0_5 USART_CR2_STOP_0 /*!< SMARTCARD frame with 0.5 stop bit */ 00381 #define SMARTCARD_STOPBITS_1_5 USART_CR2_STOP /*!< SMARTCARD frame with 1.5 stop bits */ 00382 /** 00383 * @} 00384 */ 00385 00386 /** @defgroup SMARTCARD_Parity SMARTCARD Parity 00387 * @{ 00388 */ 00389 #define SMARTCARD_PARITY_EVEN USART_CR1_PCE /*!< SMARTCARD frame even parity */ 00390 #define SMARTCARD_PARITY_ODD (USART_CR1_PCE | USART_CR1_PS) /*!< SMARTCARD frame odd parity */ 00391 /** 00392 * @} 00393 */ 00394 00395 /** @defgroup SMARTCARD_Mode SMARTCARD Transfer Mode 00396 * @{ 00397 */ 00398 #define SMARTCARD_MODE_RX USART_CR1_RE /*!< SMARTCARD RX mode */ 00399 #define SMARTCARD_MODE_TX USART_CR1_TE /*!< SMARTCARD TX mode */ 00400 #define SMARTCARD_MODE_TX_RX (USART_CR1_TE |USART_CR1_RE) /*!< SMARTCARD RX and TX mode */ 00401 /** 00402 * @} 00403 */ 00404 00405 /** @defgroup SMARTCARD_Clock_Polarity SMARTCARD Clock Polarity 00406 * @{ 00407 */ 00408 #define SMARTCARD_POLARITY_LOW 0x00000000U /*!< SMARTCARD frame low polarity */ 00409 #define SMARTCARD_POLARITY_HIGH USART_CR2_CPOL /*!< SMARTCARD frame high polarity */ 00410 /** 00411 * @} 00412 */ 00413 00414 /** @defgroup SMARTCARD_Clock_Phase SMARTCARD Clock Phase 00415 * @{ 00416 */ 00417 #define SMARTCARD_PHASE_1EDGE 0x00000000U /*!< SMARTCARD frame phase on first clock transition */ 00418 #define SMARTCARD_PHASE_2EDGE USART_CR2_CPHA /*!< SMARTCARD frame phase on second clock transition */ 00419 /** 00420 * @} 00421 */ 00422 00423 /** @defgroup SMARTCARD_Last_Bit SMARTCARD Last Bit 00424 * @{ 00425 */ 00426 #define SMARTCARD_LASTBIT_DISABLE 0x00000000U /*!< SMARTCARD frame last data bit clock pulse not output to SCLK pin */ 00427 #define SMARTCARD_LASTBIT_ENABLE USART_CR2_LBCL /*!< SMARTCARD frame last data bit clock pulse output to SCLK pin */ 00428 /** 00429 * @} 00430 */ 00431 00432 /** @defgroup SMARTCARD_OneBit_Sampling SMARTCARD One Bit Sampling Method 00433 * @{ 00434 */ 00435 #define SMARTCARD_ONE_BIT_SAMPLE_DISABLE 0x00000000U /*!< SMARTCARD frame one-bit sample disabled */ 00436 #define SMARTCARD_ONE_BIT_SAMPLE_ENABLE USART_CR3_ONEBIT /*!< SMARTCARD frame one-bit sample enabled */ 00437 /** 00438 * @} 00439 */ 00440 00441 00442 /** @defgroup SMARTCARD_NACK_Enable SMARTCARD NACK Enable 00443 * @{ 00444 */ 00445 #define SMARTCARD_NACK_DISABLE 0x00000000U /*!< SMARTCARD NACK transmission disabled */ 00446 #define SMARTCARD_NACK_ENABLE USART_CR3_NACK /*!< SMARTCARD NACK transmission enabled */ 00447 /** 00448 * @} 00449 */ 00450 00451 /** @defgroup SMARTCARD_Timeout_Enable SMARTCARD Timeout Enable 00452 * @{ 00453 */ 00454 #define SMARTCARD_TIMEOUT_DISABLE 0x00000000U /*!< SMARTCARD receiver timeout disabled */ 00455 #define SMARTCARD_TIMEOUT_ENABLE USART_CR2_RTOEN /*!< SMARTCARD receiver timeout enabled */ 00456 /** 00457 * @} 00458 */ 00459 00460 #if defined(USART_PRESC_PRESCALER) 00461 /** @defgroup SMARTCARD_ClockPrescaler Clock Prescaler 00462 * @{ 00463 */ 00464 #define SMARTCARD_PRESCALER_DIV1 0x00000000U /*!< fclk_pres = fclk */ 00465 #define SMARTCARD_PRESCALER_DIV2 0x00000001U /*!< fclk_pres = fclk/2 */ 00466 #define SMARTCARD_PRESCALER_DIV4 0x00000002U /*!< fclk_pres = fclk/4 */ 00467 #define SMARTCARD_PRESCALER_DIV6 0x00000003U /*!< fclk_pres = fclk/6 */ 00468 #define SMARTCARD_PRESCALER_DIV8 0x00000004U /*!< fclk_pres = fclk/8 */ 00469 #define SMARTCARD_PRESCALER_DIV10 0x00000005U /*!< fclk_pres = fclk/10 */ 00470 #define SMARTCARD_PRESCALER_DIV12 0x00000006U /*!< fclk_pres = fclk/12 */ 00471 #define SMARTCARD_PRESCALER_DIV16 0x00000007U /*!< fclk_pres = fclk/16 */ 00472 #define SMARTCARD_PRESCALER_DIV32 0x00000008U /*!< fclk_pres = fclk/32 */ 00473 #define SMARTCARD_PRESCALER_DIV64 0x00000009U /*!< fclk_pres = fclk/64 */ 00474 #define SMARTCARD_PRESCALER_DIV128 0x0000000AU /*!< fclk_pres = fclk/128 */ 00475 #define SMARTCARD_PRESCALER_DIV256 0x0000000BU /*!< fclk_pres = fclk/256 */ 00476 00477 /** 00478 * @} 00479 */ 00480 #endif 00481 00482 /** @defgroup SMARTCARD_Tx_Inv SMARTCARD advanced feature TX pin active level inversion 00483 * @{ 00484 */ 00485 #define SMARTCARD_ADVFEATURE_TXINV_DISABLE 0x00000000U /*!< TX pin active level inversion disable */ 00486 #define SMARTCARD_ADVFEATURE_TXINV_ENABLE USART_CR2_TXINV /*!< TX pin active level inversion enable */ 00487 /** 00488 * @} 00489 */ 00490 00491 /** @defgroup SMARTCARD_Rx_Inv SMARTCARD advanced feature RX pin active level inversion 00492 * @{ 00493 */ 00494 #define SMARTCARD_ADVFEATURE_RXINV_DISABLE 0x00000000U /*!< RX pin active level inversion disable */ 00495 #define SMARTCARD_ADVFEATURE_RXINV_ENABLE USART_CR2_RXINV /*!< RX pin active level inversion enable */ 00496 /** 00497 * @} 00498 */ 00499 00500 /** @defgroup SMARTCARD_Data_Inv SMARTCARD advanced feature Binary Data inversion 00501 * @{ 00502 */ 00503 #define SMARTCARD_ADVFEATURE_DATAINV_DISABLE 0x00000000U /*!< Binary data inversion disable */ 00504 #define SMARTCARD_ADVFEATURE_DATAINV_ENABLE USART_CR2_DATAINV /*!< Binary data inversion enable */ 00505 /** 00506 * @} 00507 */ 00508 00509 /** @defgroup SMARTCARD_Rx_Tx_Swap SMARTCARD advanced feature RX TX pins swap 00510 * @{ 00511 */ 00512 #define SMARTCARD_ADVFEATURE_SWAP_DISABLE 0x00000000U /*!< TX/RX pins swap disable */ 00513 #define SMARTCARD_ADVFEATURE_SWAP_ENABLE USART_CR2_SWAP /*!< TX/RX pins swap enable */ 00514 /** 00515 * @} 00516 */ 00517 00518 /** @defgroup SMARTCARD_Overrun_Disable SMARTCARD advanced feature Overrun Disable 00519 * @{ 00520 */ 00521 #define SMARTCARD_ADVFEATURE_OVERRUN_ENABLE 0x00000000U /*!< RX overrun enable */ 00522 #define SMARTCARD_ADVFEATURE_OVERRUN_DISABLE USART_CR3_OVRDIS /*!< RX overrun disable */ 00523 /** 00524 * @} 00525 */ 00526 00527 /** @defgroup SMARTCARD_DMA_Disable_on_Rx_Error SMARTCARD advanced feature DMA Disable on Rx Error 00528 * @{ 00529 */ 00530 #define SMARTCARD_ADVFEATURE_DMA_ENABLEONRXERROR 0x00000000U /*!< DMA enable on Reception Error */ 00531 #define SMARTCARD_ADVFEATURE_DMA_DISABLEONRXERROR USART_CR3_DDRE /*!< DMA disable on Reception Error */ 00532 /** 00533 * @} 00534 */ 00535 00536 /** @defgroup SMARTCARD_MSB_First SMARTCARD advanced feature MSB first 00537 * @{ 00538 */ 00539 #define SMARTCARD_ADVFEATURE_MSBFIRST_DISABLE 0x00000000U /*!< Most significant bit sent/received first disable */ 00540 #define SMARTCARD_ADVFEATURE_MSBFIRST_ENABLE USART_CR2_MSBFIRST /*!< Most significant bit sent/received first enable */ 00541 /** 00542 * @} 00543 */ 00544 00545 /** @defgroup SMARTCARD_Request_Parameters SMARTCARD Request Parameters 00546 * @{ 00547 */ 00548 #define SMARTCARD_RXDATA_FLUSH_REQUEST USART_RQR_RXFRQ /*!< Receive data flush request */ 00549 #define SMARTCARD_TXDATA_FLUSH_REQUEST USART_RQR_TXFRQ /*!< Transmit data flush request */ 00550 /** 00551 * @} 00552 */ 00553 00554 /** @defgroup SMARTCARD_Interruption_Mask SMARTCARD interruptions flags mask 00555 * @{ 00556 */ 00557 #define SMARTCARD_IT_MASK 0x001FU /*!< SMARTCARD interruptions flags mask */ 00558 /** 00559 * @} 00560 */ 00561 00562 /** 00563 * @} 00564 */ 00565 00566 /* Exported macros -----------------------------------------------------------*/ 00567 /** @defgroup SMARTCARD_Exported_Macros SMARTCARD Exported Macros 00568 * @{ 00569 */ 00570 00571 /** @brief Reset SMARTCARD handle states. 00572 * @param __HANDLE__ SMARTCARD handle. 00573 * @retval None 00574 */ 00575 #if USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1 00576 #define __HAL_SMARTCARD_RESET_HANDLE_STATE(__HANDLE__) do{ \ 00577 (__HANDLE__)->gState = HAL_SMARTCARD_STATE_RESET; \ 00578 (__HANDLE__)->RxState = HAL_SMARTCARD_STATE_RESET; \ 00579 (__HANDLE__)->MspInitCallback = NULL; \ 00580 (__HANDLE__)->MspDeInitCallback = NULL; \ 00581 } while(0U) 00582 #else 00583 #define __HAL_SMARTCARD_RESET_HANDLE_STATE(__HANDLE__) do{ \ 00584 (__HANDLE__)->gState = HAL_SMARTCARD_STATE_RESET; \ 00585 (__HANDLE__)->RxState = HAL_SMARTCARD_STATE_RESET; \ 00586 } while(0U) 00587 #endif /*USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 00588 00589 /** @brief Flush the Smartcard Data registers. 00590 * @param __HANDLE__ specifies the SMARTCARD Handle. 00591 * @retval None 00592 */ 00593 #define __HAL_SMARTCARD_FLUSH_DRREGISTER(__HANDLE__) \ 00594 do{ \ 00595 SET_BIT((__HANDLE__)->Instance->RQR, SMARTCARD_RXDATA_FLUSH_REQUEST); \ 00596 SET_BIT((__HANDLE__)->Instance->RQR, SMARTCARD_TXDATA_FLUSH_REQUEST); \ 00597 } while(0U) 00598 00599 /** @brief Clear the specified SMARTCARD pending flag. 00600 * @param __HANDLE__ specifies the SMARTCARD Handle. 00601 * @param __FLAG__ specifies the flag to check. 00602 * This parameter can be any combination of the following values: 00603 * @arg @ref SMARTCARD_CLEAR_PEF Parity error clear flag 00604 * @arg @ref SMARTCARD_CLEAR_FEF Framing error clear flag 00605 * @arg @ref SMARTCARD_CLEAR_NEF Noise detected clear flag 00606 * @arg @ref SMARTCARD_CLEAR_OREF OverRun error clear flag 00607 * @arg @ref SMARTCARD_CLEAR_IDLEF Idle line detected clear flag 00608 * @arg @ref SMARTCARD_CLEAR_TCF Transmission complete clear flag 00609 * @arg @ref SMARTCARD_CLEAR_TCBGTF Transmission complete before guard time clear flag 00610 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 00611 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 00612 * @arg @ref SMARTCARD_CLEAR_TXFECF TXFIFO empty Clear flag 00613 * @retval None 00614 */ 00615 #define __HAL_SMARTCARD_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__)) 00616 00617 /** @brief Clear the SMARTCARD PE pending flag. 00618 * @param __HANDLE__ specifies the SMARTCARD Handle. 00619 * @retval None 00620 */ 00621 #define __HAL_SMARTCARD_CLEAR_PEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_PEF) 00622 00623 00624 /** @brief Clear the SMARTCARD FE pending flag. 00625 * @param __HANDLE__ specifies the SMARTCARD Handle. 00626 * @retval None 00627 */ 00628 #define __HAL_SMARTCARD_CLEAR_FEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_FEF) 00629 00630 /** @brief Clear the SMARTCARD NE pending flag. 00631 * @param __HANDLE__ specifies the SMARTCARD Handle. 00632 * @retval None 00633 */ 00634 #define __HAL_SMARTCARD_CLEAR_NEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_NEF) 00635 00636 /** @brief Clear the SMARTCARD ORE pending flag. 00637 * @param __HANDLE__ specifies the SMARTCARD Handle. 00638 * @retval None 00639 */ 00640 #define __HAL_SMARTCARD_CLEAR_OREFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_OREF) 00641 00642 /** @brief Clear the SMARTCARD IDLE pending flag. 00643 * @param __HANDLE__ specifies the SMARTCARD Handle. 00644 * @retval None 00645 */ 00646 #define __HAL_SMARTCARD_CLEAR_IDLEFLAG(__HANDLE__) __HAL_SMARTCARD_CLEAR_FLAG((__HANDLE__), SMARTCARD_CLEAR_IDLEF) 00647 00648 /** @brief Check whether the specified Smartcard flag is set or not. 00649 * @param __HANDLE__ specifies the SMARTCARD Handle. 00650 * @param __FLAG__ specifies the flag to check. 00651 * This parameter can be one of the following values: 00652 * @arg @ref SMARTCARD_FLAG_TCBGT Transmission complete before guard time flag (when flag available) 00653 * @arg @ref SMARTCARD_FLAG_REACK Receive enable acknowledge flag 00654 * @arg @ref SMARTCARD_FLAG_TEACK Transmit enable acknowledge flag 00655 * @arg @ref SMARTCARD_FLAG_BUSY Busy flag 00656 * @arg @ref SMARTCARD_FLAG_EOBF End of block flag 00657 * @arg @ref SMARTCARD_FLAG_RTOF Receiver timeout flag 00658 * @arg @ref SMARTCARD_FLAG_TXE Transmit data register empty flag 00659 * @arg @ref SMARTCARD_FLAG_TXFNF TXFIFO not full flag 00660 * @arg @ref SMARTCARD_FLAG_TC Transmission complete flag 00661 * @arg @ref SMARTCARD_FLAG_RXNE Receive data register not empty flag 00662 * @arg @ref SMARTCARD_FLAG_RXFNE RXFIFO not empty flag 00663 * @arg @ref SMARTCARD_FLAG_IDLE Idle line detection flag 00664 * @arg @ref SMARTCARD_FLAG_ORE Overrun error flag 00665 * @arg @ref SMARTCARD_FLAG_NE Noise error flag 00666 * @arg @ref SMARTCARD_FLAG_FE Framing error flag 00667 * @arg @ref SMARTCARD_FLAG_PE Parity error flag 00668 * @arg @ref SMARTCARD_FLAG_TXFE TXFIFO Empty flag 00669 * @arg @ref SMARTCARD_FLAG_RXFF RXFIFO Full flag 00670 * @arg @ref SMARTCARD_FLAG_RXFT SMARTCARD RXFIFO threshold flag 00671 * @arg @ref SMARTCARD_FLAG_TXFT SMARTCARD TXFIFO threshold flag 00672 * @retval The new state of __FLAG__ (TRUE or FALSE). 00673 */ 00674 #define __HAL_SMARTCARD_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__)) 00675 00676 /** @brief Enable the specified SmartCard interrupt. 00677 * @param __HANDLE__ specifies the SMARTCARD Handle. 00678 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to enable. 00679 * This parameter can be one of the following values: 00680 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 00681 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 00682 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 00683 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 00684 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 00685 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 00686 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 00687 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 00688 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 00689 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 00690 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 00691 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 00692 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 00693 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 00694 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 00695 * @retval None 00696 */ 00697 #define __HAL_SMARTCARD_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 00698 ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 00699 ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 00700 00701 /** @brief Disable the specified SmartCard interrupt. 00702 * @param __HANDLE__ specifies the SMARTCARD Handle. 00703 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to disable. 00704 * This parameter can be one of the following values: 00705 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 00706 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 00707 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 00708 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 00709 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 00710 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 00711 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 00712 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 00713 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 00714 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 00715 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 00716 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 00717 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 00718 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 00719 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 00720 * @retval None 00721 */ 00722 #define __HAL_SMARTCARD_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 &= ~ (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 00723 ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 &= ~ (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK))): \ 00724 ((__HANDLE__)->Instance->CR3 &= ~ (1U << ((__INTERRUPT__) & SMARTCARD_IT_MASK)))) 00725 00726 00727 /** @brief Check whether the specified SmartCard interrupt has occurred or not. 00728 * @param __HANDLE__ specifies the SMARTCARD Handle. 00729 * @param __INTERRUPT__ specifies the SMARTCARD interrupt to check. 00730 * This parameter can be one of the following values: 00731 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 00732 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 00733 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 00734 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 00735 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 00736 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 00737 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 00738 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 00739 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 00740 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 00741 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 00742 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 00743 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 00744 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 00745 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 00746 * @retval The new state of __INTERRUPT__ (SET or RESET). 00747 */ 00748 #define __HAL_SMARTCARD_GET_IT(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->ISR & (0x01U << ((__INTERRUPT__)>> 0x08U))) != RESET) ? SET : RESET) 00749 00750 /** @brief Check whether the specified SmartCard interrupt source is enabled or not. 00751 * @param __HANDLE__ specifies the SMARTCARD Handle. 00752 * @param __INTERRUPT__ specifies the SMARTCARD interrupt source to check. 00753 * This parameter can be one of the following values: 00754 * @arg @ref SMARTCARD_IT_EOB End of block interrupt 00755 * @arg @ref SMARTCARD_IT_RTO Receive timeout interrupt 00756 * @arg @ref SMARTCARD_IT_TXE Transmit data register empty interrupt 00757 * @arg @ref SMARTCARD_IT_TXFNF TX FIFO not full interruption 00758 * @arg @ref SMARTCARD_IT_TC Transmission complete interrupt 00759 * @arg @ref SMARTCARD_IT_TCBGT Transmission complete before guard time interrupt (when interruption available) 00760 * @arg @ref SMARTCARD_IT_RXNE Receive data register not empty interrupt 00761 * @arg @ref SMARTCARD_IT_RXFNE RXFIFO not empty interruption 00762 * @arg @ref SMARTCARD_IT_IDLE Idle line detection interrupt 00763 * @arg @ref SMARTCARD_IT_PE Parity error interrupt 00764 * @arg @ref SMARTCARD_IT_ERR Error interrupt(frame error, noise error, overrun error) 00765 * @arg @ref SMARTCARD_IT_RXFF RXFIFO full interruption 00766 * @arg @ref SMARTCARD_IT_TXFE TXFIFO empty interruption 00767 * @arg @ref SMARTCARD_IT_RXFT RXFIFO threshold reached interruption 00768 * @arg @ref SMARTCARD_IT_TXFT TXFIFO threshold reached interruption 00769 * @retval The new state of __INTERRUPT__ (SET or RESET). 00770 */ 00771 #define __HAL_SMARTCARD_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((uint8_t)(__INTERRUPT__)) >> 0x05U) == 0x01U)? (__HANDLE__)->Instance->CR1 : \ 00772 (((((uint8_t)(__INTERRUPT__)) >> 0x05U) == 0x01U)? (__HANDLE__)->Instance->CR2 : \ 00773 (__HANDLE__)->Instance->CR3)) & (0x01U << (((uint16_t)(__INTERRUPT__)) & SMARTCARD_IT_MASK))) != RESET) ? SET : RESET) 00774 00775 00776 /** @brief Clear the specified SMARTCARD ISR flag, in setting the proper ICR register flag. 00777 * @param __HANDLE__ specifies the SMARTCARD Handle. 00778 * @param __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set 00779 * to clear the corresponding interrupt. 00780 * This parameter can be one of the following values: 00781 * @arg @ref SMARTCARD_CLEAR_PEF Parity error clear flag 00782 * @arg @ref SMARTCARD_CLEAR_FEF Framing error clear flag 00783 * @arg @ref SMARTCARD_CLEAR_NEF Noise detected clear flag 00784 * @arg @ref SMARTCARD_CLEAR_OREF OverRun error clear flag 00785 * @arg @ref SMARTCARD_CLEAR_IDLEF Idle line detection clear flag 00786 * @arg @ref SMARTCARD_CLEAR_TXFECF TXFIFO empty Clear Flag 00787 * @arg @ref SMARTCARD_CLEAR_TCF Transmission complete clear flag 00788 * @arg @ref SMARTCARD_CLEAR_TCBGTF Transmission complete before guard time clear flag (when flag available) 00789 * @arg @ref SMARTCARD_CLEAR_RTOF Receiver timeout clear flag 00790 * @arg @ref SMARTCARD_CLEAR_EOBF End of block clear flag 00791 * @retval None 00792 */ 00793 #define __HAL_SMARTCARD_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR |= (uint32_t)(__IT_CLEAR__)) 00794 00795 /** @brief Set a specific SMARTCARD request flag. 00796 * @param __HANDLE__ specifies the SMARTCARD Handle. 00797 * @param __REQ__ specifies the request flag to set 00798 * This parameter can be one of the following values: 00799 * @arg @ref SMARTCARD_RXDATA_FLUSH_REQUEST Receive data flush Request 00800 * @arg @ref SMARTCARD_TXDATA_FLUSH_REQUEST Transmit data flush Request 00801 * 00802 * @retval None 00803 */ 00804 #define __HAL_SMARTCARD_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__)) 00805 00806 /** @brief Enable the SMARTCARD one bit sample method. 00807 * @param __HANDLE__ specifies the SMARTCARD Handle. 00808 * @retval None 00809 */ 00810 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT) 00811 00812 /** @brief Disable the SMARTCARD one bit sample method. 00813 * @param __HANDLE__ specifies the SMARTCARD Handle. 00814 * @retval None 00815 */ 00816 #define __HAL_SMARTCARD_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT)) 00817 00818 /** @brief Enable the USART associated to the SMARTCARD Handle. 00819 * @param __HANDLE__ specifies the SMARTCARD Handle. 00820 * @retval None 00821 */ 00822 #define __HAL_SMARTCARD_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE) 00823 00824 /** @brief Disable the USART associated to the SMARTCARD Handle 00825 * @param __HANDLE__ specifies the SMARTCARD Handle. 00826 * @retval None 00827 */ 00828 #define __HAL_SMARTCARD_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE) 00829 00830 /** 00831 * @} 00832 */ 00833 00834 /* Private macros -------------------------------------------------------------*/ 00835 /** @defgroup SMARTCARD_Private_Macros SMARTCARD Private Macros 00836 * @{ 00837 */ 00838 00839 /** @brief Report the SMARTCARD clock source. 00840 * @param __HANDLE__ specifies the SMARTCARD Handle. 00841 * @param __CLOCKSOURCE__ output variable. 00842 * @retval the SMARTCARD clocking source, written in __CLOCKSOURCE__. 00843 */ 00844 #if defined (STM32L432xx) || defined (STM32L442xx) 00845 #define SMARTCARD_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 00846 do { \ 00847 if((__HANDLE__)->Instance == USART1) \ 00848 { \ 00849 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 00850 { \ 00851 case RCC_USART1CLKSOURCE_PCLK2: \ 00852 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK2; \ 00853 break; \ 00854 case RCC_USART1CLKSOURCE_HSI: \ 00855 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 00856 break; \ 00857 case RCC_USART1CLKSOURCE_SYSCLK: \ 00858 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 00859 break; \ 00860 case RCC_USART1CLKSOURCE_LSE: \ 00861 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 00862 break; \ 00863 default: \ 00864 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 00865 break; \ 00866 } \ 00867 } \ 00868 else if((__HANDLE__)->Instance == USART2) \ 00869 { \ 00870 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 00871 { \ 00872 case RCC_USART2CLKSOURCE_PCLK1: \ 00873 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK1; \ 00874 break; \ 00875 case RCC_USART2CLKSOURCE_HSI: \ 00876 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 00877 break; \ 00878 case RCC_USART2CLKSOURCE_SYSCLK: \ 00879 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 00880 break; \ 00881 case RCC_USART2CLKSOURCE_LSE: \ 00882 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 00883 break; \ 00884 default: \ 00885 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 00886 break; \ 00887 } \ 00888 } \ 00889 } while(0) 00890 #else 00891 #define SMARTCARD_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 00892 do { \ 00893 if((__HANDLE__)->Instance == USART1) \ 00894 { \ 00895 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 00896 { \ 00897 case RCC_USART1CLKSOURCE_PCLK2: \ 00898 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK2; \ 00899 break; \ 00900 case RCC_USART1CLKSOURCE_HSI: \ 00901 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 00902 break; \ 00903 case RCC_USART1CLKSOURCE_SYSCLK: \ 00904 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 00905 break; \ 00906 case RCC_USART1CLKSOURCE_LSE: \ 00907 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 00908 break; \ 00909 default: \ 00910 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 00911 break; \ 00912 } \ 00913 } \ 00914 else if((__HANDLE__)->Instance == USART2) \ 00915 { \ 00916 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 00917 { \ 00918 case RCC_USART2CLKSOURCE_PCLK1: \ 00919 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK1; \ 00920 break; \ 00921 case RCC_USART2CLKSOURCE_HSI: \ 00922 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 00923 break; \ 00924 case RCC_USART2CLKSOURCE_SYSCLK: \ 00925 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 00926 break; \ 00927 case RCC_USART2CLKSOURCE_LSE: \ 00928 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 00929 break; \ 00930 default: \ 00931 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 00932 break; \ 00933 } \ 00934 } \ 00935 else if((__HANDLE__)->Instance == USART3) \ 00936 { \ 00937 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 00938 { \ 00939 case RCC_USART3CLKSOURCE_PCLK1: \ 00940 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_PCLK1; \ 00941 break; \ 00942 case RCC_USART3CLKSOURCE_HSI: \ 00943 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_HSI; \ 00944 break; \ 00945 case RCC_USART3CLKSOURCE_SYSCLK: \ 00946 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_SYSCLK; \ 00947 break; \ 00948 case RCC_USART3CLKSOURCE_LSE: \ 00949 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_LSE; \ 00950 break; \ 00951 default: \ 00952 (__CLOCKSOURCE__) = SMARTCARD_CLOCKSOURCE_UNDEFINED; \ 00953 break; \ 00954 } \ 00955 } \ 00956 } while(0) 00957 #endif /* STM32L432xx || STM32L442xx */ 00958 00959 /** @brief Check the Baud rate range. 00960 * @note The maximum Baud Rate is derived from the maximum clock on L4 (120 MHz) 00961 * divided by the oversampling used on the SMARTCARD (i.e. 16). 00962 * @param __BAUDRATE__ Baud rate set by the configuration function. 00963 * @retval Test result (TRUE or FALSE) 00964 */ 00965 #define IS_SMARTCARD_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 7500001U) 00966 00967 /** @brief Check the block length range. 00968 * @note The maximum SMARTCARD block length is 0xFF. 00969 * @param __LENGTH__ block length. 00970 * @retval Test result (TRUE or FALSE) 00971 */ 00972 #define IS_SMARTCARD_BLOCKLENGTH(__LENGTH__) ((__LENGTH__) <= 0xFFU) 00973 00974 /** @brief Check the receiver timeout value. 00975 * @note The maximum SMARTCARD receiver timeout value is 0xFFFFFF. 00976 * @param __TIMEOUTVALUE__ receiver timeout value. 00977 * @retval Test result (TRUE or FALSE) 00978 */ 00979 #define IS_SMARTCARD_TIMEOUT_VALUE(__TIMEOUTVALUE__) ((__TIMEOUTVALUE__) <= 0xFFFFFFU) 00980 00981 /** @brief Check the SMARTCARD autoretry counter value. 00982 * @note The maximum number of retransmissions is 0x7. 00983 * @param __COUNT__ number of retransmissions. 00984 * @retval Test result (TRUE or FALSE) 00985 */ 00986 #define IS_SMARTCARD_AUTORETRY_COUNT(__COUNT__) ((__COUNT__) <= 0x7U) 00987 00988 /** 00989 * @brief Ensure that SMARTCARD frame length is valid. 00990 * @param __LENGTH__ SMARTCARD frame length. 00991 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 00992 */ 00993 #define IS_SMARTCARD_WORD_LENGTH(__LENGTH__) ((__LENGTH__) == SMARTCARD_WORDLENGTH_9B) 00994 00995 /** 00996 * @brief Ensure that SMARTCARD frame number of stop bits is valid. 00997 * @param __STOPBITS__ SMARTCARD frame number of stop bits. 00998 * @retval SET (__STOPBITS__ is valid) or RESET (__STOPBITS__ is invalid) 00999 */ 01000 #define IS_SMARTCARD_STOPBITS(__STOPBITS__) (((__STOPBITS__) == SMARTCARD_STOPBITS_0_5) ||\ 01001 ((__STOPBITS__) == SMARTCARD_STOPBITS_1_5)) 01002 01003 /** 01004 * @brief Ensure that SMARTCARD frame parity is valid. 01005 * @param __PARITY__ SMARTCARD frame parity. 01006 * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid) 01007 */ 01008 #define IS_SMARTCARD_PARITY(__PARITY__) (((__PARITY__) == SMARTCARD_PARITY_EVEN) || \ 01009 ((__PARITY__) == SMARTCARD_PARITY_ODD)) 01010 01011 /** 01012 * @brief Ensure that SMARTCARD communication mode is valid. 01013 * @param __MODE__ SMARTCARD communication mode. 01014 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid) 01015 */ 01016 #define IS_SMARTCARD_MODE(__MODE__) ((((__MODE__) & 0xFFF3U) == 0x00U) && ((__MODE__) != 0x00U)) 01017 01018 /** 01019 * @brief Ensure that SMARTCARD frame polarity is valid. 01020 * @param __CPOL__ SMARTCARD frame polarity. 01021 * @retval SET (__CPOL__ is valid) or RESET (__CPOL__ is invalid) 01022 */ 01023 #define IS_SMARTCARD_POLARITY(__CPOL__) (((__CPOL__) == SMARTCARD_POLARITY_LOW) || ((__CPOL__) == SMARTCARD_POLARITY_HIGH)) 01024 01025 /** 01026 * @brief Ensure that SMARTCARD frame phase is valid. 01027 * @param __CPHA__ SMARTCARD frame phase. 01028 * @retval SET (__CPHA__ is valid) or RESET (__CPHA__ is invalid) 01029 */ 01030 #define IS_SMARTCARD_PHASE(__CPHA__) (((__CPHA__) == SMARTCARD_PHASE_1EDGE) || ((__CPHA__) == SMARTCARD_PHASE_2EDGE)) 01031 01032 /** 01033 * @brief Ensure that SMARTCARD frame last bit clock pulse setting is valid. 01034 * @param __LASTBIT__ SMARTCARD frame last bit clock pulse setting. 01035 * @retval SET (__LASTBIT__ is valid) or RESET (__LASTBIT__ is invalid) 01036 */ 01037 #define IS_SMARTCARD_LASTBIT(__LASTBIT__) (((__LASTBIT__) == SMARTCARD_LASTBIT_DISABLE) || \ 01038 ((__LASTBIT__) == SMARTCARD_LASTBIT_ENABLE)) 01039 01040 /** 01041 * @brief Ensure that SMARTCARD frame sampling is valid. 01042 * @param __ONEBIT__ SMARTCARD frame sampling. 01043 * @retval SET (__ONEBIT__ is valid) or RESET (__ONEBIT__ is invalid) 01044 */ 01045 #define IS_SMARTCARD_ONE_BIT_SAMPLE(__ONEBIT__) (((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_DISABLE) || \ 01046 ((__ONEBIT__) == SMARTCARD_ONE_BIT_SAMPLE_ENABLE)) 01047 01048 /** 01049 * @brief Ensure that SMARTCARD NACK transmission setting is valid. 01050 * @param __NACK__ SMARTCARD NACK transmission setting. 01051 * @retval SET (__NACK__ is valid) or RESET (__NACK__ is invalid) 01052 */ 01053 #define IS_SMARTCARD_NACK(__NACK__) (((__NACK__) == SMARTCARD_NACK_ENABLE) || \ 01054 ((__NACK__) == SMARTCARD_NACK_DISABLE)) 01055 01056 /** 01057 * @brief Ensure that SMARTCARD receiver timeout setting is valid. 01058 * @param __TIMEOUT__ SMARTCARD receiver timeout setting. 01059 * @retval SET (__TIMEOUT__ is valid) or RESET (__TIMEOUT__ is invalid) 01060 */ 01061 #define IS_SMARTCARD_TIMEOUT(__TIMEOUT__) (((__TIMEOUT__) == SMARTCARD_TIMEOUT_DISABLE) || \ 01062 ((__TIMEOUT__) == SMARTCARD_TIMEOUT_ENABLE)) 01063 01064 #if defined(USART_PRESC_PRESCALER) 01065 /** 01066 * @brief Ensure that SMARTCARD clock Prescaler is valid. 01067 * @param __CLOCKPRESCALER__ SMARTCARD clock Prescaler value. 01068 * @retval SET (__CLOCKPRESCALER__ is valid) or RESET (__CLOCKPRESCALER__ is invalid) 01069 */ 01070 #define IS_SMARTCARD_CLOCKPRESCALER(__CLOCKPRESCALER__) (((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV1) || \ 01071 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV2) || \ 01072 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV4) || \ 01073 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV6) || \ 01074 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV8) || \ 01075 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV10) || \ 01076 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV12) || \ 01077 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV16) || \ 01078 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV32) || \ 01079 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV64) || \ 01080 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV128) || \ 01081 ((__CLOCKPRESCALER__) == SMARTCARD_PRESCALER_DIV256)) 01082 #endif 01083 01084 /** 01085 * @brief Ensure that SMARTCARD advanced features initialization is valid. 01086 * @param __INIT__ SMARTCARD advanced features initialization. 01087 * @retval SET (__INIT__ is valid) or RESET (__INIT__ is invalid) 01088 */ 01089 #define IS_SMARTCARD_ADVFEATURE_INIT(__INIT__) ((__INIT__) <= (SMARTCARD_ADVFEATURE_NO_INIT | \ 01090 SMARTCARD_ADVFEATURE_TXINVERT_INIT | \ 01091 SMARTCARD_ADVFEATURE_RXINVERT_INIT | \ 01092 SMARTCARD_ADVFEATURE_DATAINVERT_INIT | \ 01093 SMARTCARD_ADVFEATURE_SWAP_INIT | \ 01094 SMARTCARD_ADVFEATURE_RXOVERRUNDISABLE_INIT | \ 01095 SMARTCARD_ADVFEATURE_DMADISABLEONERROR_INIT | \ 01096 SMARTCARD_ADVFEATURE_MSBFIRST_INIT)) 01097 01098 /** 01099 * @brief Ensure that SMARTCARD frame TX inversion setting is valid. 01100 * @param __TXINV__ SMARTCARD frame TX inversion setting. 01101 * @retval SET (__TXINV__ is valid) or RESET (__TXINV__ is invalid) 01102 */ 01103 #define IS_SMARTCARD_ADVFEATURE_TXINV(__TXINV__) (((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_DISABLE) || \ 01104 ((__TXINV__) == SMARTCARD_ADVFEATURE_TXINV_ENABLE)) 01105 01106 /** 01107 * @brief Ensure that SMARTCARD frame RX inversion setting is valid. 01108 * @param __RXINV__ SMARTCARD frame RX inversion setting. 01109 * @retval SET (__RXINV__ is valid) or RESET (__RXINV__ is invalid) 01110 */ 01111 #define IS_SMARTCARD_ADVFEATURE_RXINV(__RXINV__) (((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_DISABLE) || \ 01112 ((__RXINV__) == SMARTCARD_ADVFEATURE_RXINV_ENABLE)) 01113 01114 /** 01115 * @brief Ensure that SMARTCARD frame data inversion setting is valid. 01116 * @param __DATAINV__ SMARTCARD frame data inversion setting. 01117 * @retval SET (__DATAINV__ is valid) or RESET (__DATAINV__ is invalid) 01118 */ 01119 #define IS_SMARTCARD_ADVFEATURE_DATAINV(__DATAINV__) (((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_DISABLE) || \ 01120 ((__DATAINV__) == SMARTCARD_ADVFEATURE_DATAINV_ENABLE)) 01121 01122 /** 01123 * @brief Ensure that SMARTCARD frame RX/TX pins swap setting is valid. 01124 * @param __SWAP__ SMARTCARD frame RX/TX pins swap setting. 01125 * @retval SET (__SWAP__ is valid) or RESET (__SWAP__ is invalid) 01126 */ 01127 #define IS_SMARTCARD_ADVFEATURE_SWAP(__SWAP__) (((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_DISABLE) || \ 01128 ((__SWAP__) == SMARTCARD_ADVFEATURE_SWAP_ENABLE)) 01129 01130 /** 01131 * @brief Ensure that SMARTCARD frame overrun setting is valid. 01132 * @param __OVERRUN__ SMARTCARD frame overrun setting. 01133 * @retval SET (__OVERRUN__ is valid) or RESET (__OVERRUN__ is invalid) 01134 */ 01135 #define IS_SMARTCARD_OVERRUN(__OVERRUN__) (((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_ENABLE) || \ 01136 ((__OVERRUN__) == SMARTCARD_ADVFEATURE_OVERRUN_DISABLE)) 01137 01138 /** 01139 * @brief Ensure that SMARTCARD DMA enabling or disabling on error setting is valid. 01140 * @param __DMA__ SMARTCARD DMA enabling or disabling on error setting. 01141 * @retval SET (__DMA__ is valid) or RESET (__DMA__ is invalid) 01142 */ 01143 #define IS_SMARTCARD_ADVFEATURE_DMAONRXERROR(__DMA__) (((__DMA__) == SMARTCARD_ADVFEATURE_DMA_ENABLEONRXERROR) || \ 01144 ((__DMA__) == SMARTCARD_ADVFEATURE_DMA_DISABLEONRXERROR)) 01145 01146 /** 01147 * @brief Ensure that SMARTCARD frame MSB first setting is valid. 01148 * @param __MSBFIRST__ SMARTCARD frame MSB first setting. 01149 * @retval SET (__MSBFIRST__ is valid) or RESET (__MSBFIRST__ is invalid) 01150 */ 01151 #define IS_SMARTCARD_ADVFEATURE_MSBFIRST(__MSBFIRST__) (((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_DISABLE) || \ 01152 ((__MSBFIRST__) == SMARTCARD_ADVFEATURE_MSBFIRST_ENABLE)) 01153 01154 /** 01155 * @brief Ensure that SMARTCARD request parameter is valid. 01156 * @param __PARAM__ SMARTCARD request parameter. 01157 * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid) 01158 */ 01159 #define IS_SMARTCARD_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == SMARTCARD_RXDATA_FLUSH_REQUEST) || \ 01160 ((__PARAM__) == SMARTCARD_TXDATA_FLUSH_REQUEST)) 01161 01162 /** 01163 * @} 01164 */ 01165 01166 /* Include SMARTCARD HAL Extended module */ 01167 #include "stm32l4xx_hal_smartcard_ex.h" 01168 01169 01170 /* Exported functions --------------------------------------------------------*/ 01171 /** @addtogroup SMARTCARD_Exported_Functions 01172 * @{ 01173 */ 01174 01175 /* Initialization and de-initialization functions ****************************/ 01176 /** @addtogroup SMARTCARD_Exported_Functions_Group1 01177 * @{ 01178 */ 01179 01180 HAL_StatusTypeDef HAL_SMARTCARD_Init(SMARTCARD_HandleTypeDef *hsmartcard); 01181 HAL_StatusTypeDef HAL_SMARTCARD_DeInit(SMARTCARD_HandleTypeDef *hsmartcard); 01182 void HAL_SMARTCARD_MspInit(SMARTCARD_HandleTypeDef *hsmartcard); 01183 void HAL_SMARTCARD_MspDeInit(SMARTCARD_HandleTypeDef *hsmartcard); 01184 01185 #if (USE_HAL_SMARTCARD_REGISTER_CALLBACKS == 1) 01186 /* Callbacks Register/UnRegister functions ***********************************/ 01187 HAL_StatusTypeDef HAL_SMARTCARD_RegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, HAL_SMARTCARD_CallbackIDTypeDef CallbackID, pSMARTCARD_CallbackTypeDef pCallback); 01188 HAL_StatusTypeDef HAL_SMARTCARD_UnRegisterCallback(SMARTCARD_HandleTypeDef *hsmartcard, HAL_SMARTCARD_CallbackIDTypeDef CallbackID); 01189 #endif /* USE_HAL_SMARTCARD_REGISTER_CALLBACKS */ 01190 01191 /** 01192 * @} 01193 */ 01194 01195 /* IO operation functions *****************************************************/ 01196 /** @addtogroup SMARTCARD_Exported_Functions_Group2 01197 * @{ 01198 */ 01199 01200 HAL_StatusTypeDef HAL_SMARTCARD_Transmit(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, uint32_t Timeout); 01201 HAL_StatusTypeDef HAL_SMARTCARD_Receive(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size, uint32_t Timeout); 01202 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 01203 HAL_StatusTypeDef HAL_SMARTCARD_Receive_IT(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 01204 HAL_StatusTypeDef HAL_SMARTCARD_Transmit_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 01205 HAL_StatusTypeDef HAL_SMARTCARD_Receive_DMA(SMARTCARD_HandleTypeDef *hsmartcard, uint8_t *pData, uint16_t Size); 01206 /* Transfer Abort functions */ 01207 HAL_StatusTypeDef HAL_SMARTCARD_Abort(SMARTCARD_HandleTypeDef *hsmartcard); 01208 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit(SMARTCARD_HandleTypeDef *hsmartcard); 01209 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive(SMARTCARD_HandleTypeDef *hsmartcard); 01210 HAL_StatusTypeDef HAL_SMARTCARD_Abort_IT(SMARTCARD_HandleTypeDef *hsmartcard); 01211 HAL_StatusTypeDef HAL_SMARTCARD_AbortTransmit_IT(SMARTCARD_HandleTypeDef *hsmartcard); 01212 HAL_StatusTypeDef HAL_SMARTCARD_AbortReceive_IT(SMARTCARD_HandleTypeDef *hsmartcard); 01213 01214 void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsmartcard); 01215 void HAL_SMARTCARD_TxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01216 void HAL_SMARTCARD_RxCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01217 void HAL_SMARTCARD_ErrorCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01218 void HAL_SMARTCARD_AbortCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01219 void HAL_SMARTCARD_AbortTransmitCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01220 void HAL_SMARTCARD_AbortReceiveCpltCallback(SMARTCARD_HandleTypeDef *hsmartcard); 01221 01222 /** 01223 * @} 01224 */ 01225 01226 /* Peripheral State and Error functions ***************************************/ 01227 /** @addtogroup SMARTCARD_Exported_Functions_Group4 01228 * @{ 01229 */ 01230 01231 HAL_SMARTCARD_StateTypeDef HAL_SMARTCARD_GetState(SMARTCARD_HandleTypeDef *hsmartcard); 01232 uint32_t HAL_SMARTCARD_GetError(SMARTCARD_HandleTypeDef *hsmartcard); 01233 01234 /** 01235 * @} 01236 */ 01237 01238 /** 01239 * @} 01240 */ 01241 01242 /** 01243 * @} 01244 */ 01245 01246 /** 01247 * @} 01248 */ 01249 01250 #ifdef __cplusplus 01251 } 01252 #endif 01253 01254 #endif /* __STM32L4xx_HAL_SMARTCARD_H */ 01255 01256 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
1.7.6.1