hoo2
/
STM32F10x_Std_Lib
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
A bundled STM32F10x Std Periph and CMSIS library
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
2.1 MiB
 
 
 
 
 
Tree: c21da4388c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c21da4388c'
${ noResults }
STM32F10x_Std_Lib/STM32F10x_StdPeriph_Driver/inc/stm32f10x_usart.h

414 lines
16 KiB
Raw Blame History 

  1. /**

  2.   ******************************************************************************

  3.   * @file    stm32f10x_usart.h

  4.   * @author  MCD Application Team

  5.   * @version V3.5.0

  6.   * @date    11-March-2011

  7.   * @brief   This file contains all the functions prototypes for the USART 

  8.   *          firmware library.

  9.   ******************************************************************************

  10.   * @attention

  11.   *

  12.   * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS

  13.   * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE

  14.   * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY

  15.   * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING

  16.   * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE

  17.   * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.

  18.   *

  19.   * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>

  20.   ******************************************************************************

  21.   */

  22. 

  23. /* Define to prevent recursive inclusion -------------------------------------*/

  24. #ifndef __STM32F10x_USART_H

  25. #define __STM32F10x_USART_H

  26. 

  27. #ifdef __cplusplus

  28. extern "C" {

  29. #endif

  30. 

  31. /* Includes ------------------------------------------------------------------*/

  32. #include "stm32f10x.h"

  33. #include "stm32f10x_assert.h"

  34. 

  35. /** @addtogroup STM32F10x_StdPeriph_Driver

  36.   * @{

  37.   */

  38. 

  39. /** @addtogroup USART

  40.   * @{

  41.   */ 

  42. 

  43. /** @defgroup USART_Exported_Types

  44.   * @{

  45.   */ 

  46. 

  47. /** 

  48.   * @brief  USART Init Structure definition  

  49.   */ 

  50.   

  51. typedef struct

  52. {

  53.   uint32_t USART_BaudRate;            /*!< This member configures the USART communication baud rate.

  54.                                            The baud rate is computed using the following formula:

  55.                                             - IntegerDivider = ((PCLKx) / (16 * (USART_InitStruct->USART_BaudRate)))

  56.                                             - FractionalDivider = ((IntegerDivider - ((u32) IntegerDivider)) * 16) + 0.5 */

  57. 

  58.   uint16_t USART_WordLength;          /*!< Specifies the number of data bits transmitted or received in a frame.

  59.                                            This parameter can be a value of @ref USART_Word_Length */

  60. 

  61.   uint16_t USART_StopBits;            /*!< Specifies the number of stop bits transmitted.

  62.                                            This parameter can be a value of @ref USART_Stop_Bits */

  63. 

  64.   uint16_t USART_Parity;              /*!< Specifies the parity mode.

  65.                                            This parameter can be a value of @ref USART_Parity

  66.                                            @note When parity is enabled, the computed parity is inserted

  67.                                                  at the MSB position of the transmitted data (9th bit when

  68.                                                  the word length is set to 9 data bits; 8th bit when the

  69.                                                  word length is set to 8 data bits). */

  70.  

  71.   uint16_t USART_Mode;                /*!< Specifies wether the Receive or Transmit mode is enabled or disabled.

  72.                                            This parameter can be a value of @ref USART_Mode */

  73. 

  74.   uint16_t USART_HardwareFlowControl; /*!< Specifies wether the hardware flow control mode is enabled

  75.                                            or disabled.

  76.                                            This parameter can be a value of @ref USART_Hardware_Flow_Control */

  77. } USART_InitTypeDef;

  78. 

  79. /** 

  80.   * @brief  USART Clock Init Structure definition  

  81.   */ 

  82.   

  83. typedef struct

  84. {

  85. 

  86.   uint16_t USART_Clock;   /*!< Specifies whether the USART clock is enabled or disabled.

  87.                                This parameter can be a value of @ref USART_Clock */

  88. 

  89.   uint16_t USART_CPOL;    /*!< Specifies the steady state value of the serial clock.

  90.                                This parameter can be a value of @ref USART_Clock_Polarity */

  91. 

  92.   uint16_t USART_CPHA;    /*!< Specifies the clock transition on which the bit capture is made.

  93.                                This parameter can be a value of @ref USART_Clock_Phase */

  94. 

  95.   uint16_t USART_LastBit; /*!< Specifies whether the clock pulse corresponding to the last transmitted

  96.                                data bit (MSB) has to be output on the SCLK pin in synchronous mode.

  97.                                This parameter can be a value of @ref USART_Last_Bit */

  98. } USART_ClockInitTypeDef;

  99. 

  100. /**

  101.   * @}

  102.   */ 

  103. 

  104. /** @defgroup USART_Exported_Constants

  105.   * @{

  106.   */ 

  107.   

  108. #define IS_USART_ALL_PERIPH(PERIPH) (((PERIPH) == USART1) || \

  109.                                      ((PERIPH) == USART2) || \

  110.                                      ((PERIPH) == USART3) || \

  111.                                      ((PERIPH) == UART4) || \

  112.                                      ((PERIPH) == UART5))

  113. 

  114. #define IS_USART_123_PERIPH(PERIPH) (((PERIPH) == USART1) || \

  115.                                      ((PERIPH) == USART2) || \

  116.                                      ((PERIPH) == USART3))

  117. 

  118. #define IS_USART_1234_PERIPH(PERIPH) (((PERIPH) == USART1) || \

  119.                                       ((PERIPH) == USART2) || \

  120.                                       ((PERIPH) == USART3) || \

  121.                                       ((PERIPH) == UART4))

  122. /** @defgroup USART_Word_Length 

  123.   * @{

  124.   */ 

  125.   

  126. #define USART_WordLength_8b                  ((uint16_t)0x0000)

  127. #define USART_WordLength_9b                  ((uint16_t)0x1000)

  128.                                     

  129. #define IS_USART_WORD_LENGTH(LENGTH) (((LENGTH) == USART_WordLength_8b) || \

  130.                                       ((LENGTH) == USART_WordLength_9b))

  131. /**

  132.   * @}

  133.   */ 

  134. 

  135. /** @defgroup USART_Stop_Bits 

  136.   * @{

  137.   */ 

  138.   

  139. #define USART_StopBits_1                     ((uint16_t)0x0000)

  140. #define USART_StopBits_0_5                   ((uint16_t)0x1000)

  141. #define USART_StopBits_2                     ((uint16_t)0x2000)

  142. #define USART_StopBits_1_5                   ((uint16_t)0x3000)

  143. #define IS_USART_STOPBITS(STOPBITS) (((STOPBITS) == USART_StopBits_1) || \

  144.                                      ((STOPBITS) == USART_StopBits_0_5) || \

  145.                                      ((STOPBITS) == USART_StopBits_2) || \

  146.                                      ((STOPBITS) == USART_StopBits_1_5))

  147. /**

  148.   * @}

  149.   */ 

  150. 

  151. /** @defgroup USART_Parity 

  152.   * @{

  153.   */ 

  154.   

  155. #define USART_Parity_No                      ((uint16_t)0x0000)

  156. #define USART_Parity_Even                    ((uint16_t)0x0400)

  157. #define USART_Parity_Odd                     ((uint16_t)0x0600) 

  158. #define IS_USART_PARITY(PARITY) (((PARITY) == USART_Parity_No) || \

  159.                                  ((PARITY) == USART_Parity_Even) || \

  160.                                  ((PARITY) == USART_Parity_Odd))

  161. /**

  162.   * @}

  163.   */ 

  164. 

  165. /** @defgroup USART_Mode 

  166.   * @{

  167.   */ 

  168.   

  169. #define USART_Mode_Rx                        ((uint16_t)0x0004)

  170. #define USART_Mode_Tx                        ((uint16_t)0x0008)

  171. #define IS_USART_MODE(MODE) ((((MODE) & (uint16_t)0xFFF3) == 0x00) && ((MODE) != (uint16_t)0x00))

  172. /**

  173.   * @}

  174.   */ 

  175. 

  176. /** @defgroup USART_Hardware_Flow_Control 

  177.   * @{

  178.   */ 

  179. #define USART_HardwareFlowControl_None       ((uint16_t)0x0000)

  180. #define USART_HardwareFlowControl_RTS        ((uint16_t)0x0100)

  181. #define USART_HardwareFlowControl_CTS        ((uint16_t)0x0200)

  182. #define USART_HardwareFlowControl_RTS_CTS    ((uint16_t)0x0300)

  183. #define IS_USART_HARDWARE_FLOW_CONTROL(CONTROL)\

  184.                               (((CONTROL) == USART_HardwareFlowControl_None) || \

  185.                                ((CONTROL) == USART_HardwareFlowControl_RTS) || \

  186.                                ((CONTROL) == USART_HardwareFlowControl_CTS) || \

  187.                                ((CONTROL) == USART_HardwareFlowControl_RTS_CTS))

  188. /**

  189.   * @}

  190.   */ 

  191. 

  192. /** @defgroup USART_Clock 

  193.   * @{

  194.   */ 

  195. #define USART_Clock_Disable                  ((uint16_t)0x0000)

  196. #define USART_Clock_Enable                   ((uint16_t)0x0800)

  197. #define IS_USART_CLOCK(CLOCK) (((CLOCK) == USART_Clock_Disable) || \

  198.                                ((CLOCK) == USART_Clock_Enable))

  199. /**

  200.   * @}

  201.   */ 

  202. 

  203. /** @defgroup USART_Clock_Polarity 

  204.   * @{

  205.   */

  206.   

  207. #define USART_CPOL_Low                       ((uint16_t)0x0000)

  208. #define USART_CPOL_High                      ((uint16_t)0x0400)

  209. #define IS_USART_CPOL(CPOL) (((CPOL) == USART_CPOL_Low) || ((CPOL) == USART_CPOL_High))

  210. 

  211. /**

  212.   * @}

  213.   */ 

  214. 

  215. /** @defgroup USART_Clock_Phase

  216.   * @{

  217.   */

  218. 

  219. #define USART_CPHA_1Edge                     ((uint16_t)0x0000)

  220. #define USART_CPHA_2Edge                     ((uint16_t)0x0200)

  221. #define IS_USART_CPHA(CPHA) (((CPHA) == USART_CPHA_1Edge) || ((CPHA) == USART_CPHA_2Edge))

  222. 

  223. /**

  224.   * @}

  225.   */

  226. 

  227. /** @defgroup USART_Last_Bit

  228.   * @{

  229.   */

  230. 

  231. #define USART_LastBit_Disable                ((uint16_t)0x0000)

  232. #define USART_LastBit_Enable                 ((uint16_t)0x0100)

  233. #define IS_USART_LASTBIT(LASTBIT) (((LASTBIT) == USART_LastBit_Disable) || \

  234.                                    ((LASTBIT) == USART_LastBit_Enable))

  235. /**

  236.   * @}

  237.   */ 

  238. 

  239. /** @defgroup USART_Interrupt_definition 

  240.   * @{

  241.   */

  242.   

  243. #define USART_IT_PE                          ((uint16_t)0x0028)

  244. #define USART_IT_TXE                         ((uint16_t)0x0727)

  245. #define USART_IT_TC                          ((uint16_t)0x0626)

  246. #define USART_IT_RXNE                        ((uint16_t)0x0525)

  247. #define USART_IT_IDLE                        ((uint16_t)0x0424)

  248. #define USART_IT_LBD                         ((uint16_t)0x0846)

  249. #define USART_IT_CTS                         ((uint16_t)0x096A)

  250. #define USART_IT_ERR                         ((uint16_t)0x0060)

  251. #define USART_IT_ORE                         ((uint16_t)0x0360)

  252. #define USART_IT_NE                          ((uint16_t)0x0260)

  253. #define USART_IT_FE                          ((uint16_t)0x0160)

  254. #define IS_USART_CONFIG_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \

  255.                                ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \

  256.                                ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \

  257.                                ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ERR))

  258. #define IS_USART_GET_IT(IT) (((IT) == USART_IT_PE) || ((IT) == USART_IT_TXE) || \

  259.                             ((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \

  260.                             ((IT) == USART_IT_IDLE) || ((IT) == USART_IT_LBD) || \

  261.                             ((IT) == USART_IT_CTS) || ((IT) == USART_IT_ORE) || \

  262.                             ((IT) == USART_IT_NE) || ((IT) == USART_IT_FE))

  263. #define IS_USART_CLEAR_IT(IT) (((IT) == USART_IT_TC) || ((IT) == USART_IT_RXNE) || \

  264.                                ((IT) == USART_IT_LBD) || ((IT) == USART_IT_CTS))

  265. /**

  266.   * @}

  267.   */

  268. 

  269. /** @defgroup USART_DMA_Requests 

  270.   * @{

  271.   */

  272. 

  273. #define USART_DMAReq_Tx                      ((uint16_t)0x0080)

  274. #define USART_DMAReq_Rx                      ((uint16_t)0x0040)

  275. #define IS_USART_DMAREQ(DMAREQ) ((((DMAREQ) & (uint16_t)0xFF3F) == 0x00) && ((DMAREQ) != (uint16_t)0x00))

  276. 

  277. /**

  278.   * @}

  279.   */ 

  280. 

  281. /** @defgroup USART_WakeUp_methods

  282.   * @{

  283.   */

  284. 

  285. #define USART_WakeUp_IdleLine                ((uint16_t)0x0000)

  286. #define USART_WakeUp_AddressMark             ((uint16_t)0x0800)

  287. #define IS_USART_WAKEUP(WAKEUP) (((WAKEUP) == USART_WakeUp_IdleLine) || \

  288.                                  ((WAKEUP) == USART_WakeUp_AddressMark))

  289. /**

  290.   * @}

  291.   */

  292. 

  293. /** @defgroup USART_LIN_Break_Detection_Length 

  294.   * @{

  295.   */

  296.   

  297. #define USART_LINBreakDetectLength_10b      ((uint16_t)0x0000)

  298. #define USART_LINBreakDetectLength_11b      ((uint16_t)0x0020)

  299. #define IS_USART_LIN_BREAK_DETECT_LENGTH(LENGTH) \

  300.                                (((LENGTH) == USART_LINBreakDetectLength_10b) || \

  301.                                 ((LENGTH) == USART_LINBreakDetectLength_11b))

  302. /**

  303.   * @}

  304.   */

  305. 

  306. /** @defgroup USART_IrDA_Low_Power 

  307.   * @{

  308.   */

  309. 

  310. #define USART_IrDAMode_LowPower              ((uint16_t)0x0004)

  311. #define USART_IrDAMode_Normal                ((uint16_t)0x0000)

  312. #define IS_USART_IRDA_MODE(MODE) (((MODE) == USART_IrDAMode_LowPower) || \

  313.                                   ((MODE) == USART_IrDAMode_Normal))

  314. /**

  315.   * @}

  316.   */ 

  317. 

  318. /** @defgroup USART_Flags 

  319.   * @{

  320.   */

  321. 

  322. #define USART_FLAG_CTS                       ((uint16_t)0x0200)

  323. #define USART_FLAG_LBD                       ((uint16_t)0x0100)

  324. #define USART_FLAG_TXE                       ((uint16_t)0x0080)

  325. #define USART_FLAG_TC                        ((uint16_t)0x0040)

  326. #define USART_FLAG_RXNE                      ((uint16_t)0x0020)

  327. #define USART_FLAG_IDLE                      ((uint16_t)0x0010)

  328. #define USART_FLAG_ORE                       ((uint16_t)0x0008)

  329. #define USART_FLAG_NE                        ((uint16_t)0x0004)

  330. #define USART_FLAG_FE                        ((uint16_t)0x0002)

  331. #define USART_FLAG_PE                        ((uint16_t)0x0001)

  332. #define IS_USART_FLAG(FLAG) (((FLAG) == USART_FLAG_PE) || ((FLAG) == USART_FLAG_TXE) || \

  333.                              ((FLAG) == USART_FLAG_TC) || ((FLAG) == USART_FLAG_RXNE) || \

  334.                              ((FLAG) == USART_FLAG_IDLE) || ((FLAG) == USART_FLAG_LBD) || \

  335.                              ((FLAG) == USART_FLAG_CTS) || ((FLAG) == USART_FLAG_ORE) || \

  336.                              ((FLAG) == USART_FLAG_NE) || ((FLAG) == USART_FLAG_FE))

  337.                               

  338. #define IS_USART_CLEAR_FLAG(FLAG) ((((FLAG) & (uint16_t)0xFC9F) == 0x00) && ((FLAG) != (uint16_t)0x00))

  339. #define IS_USART_PERIPH_FLAG(PERIPH, USART_FLAG) ((((*(uint32_t*)&(PERIPH)) != UART4_BASE) &&\

  340.                                                   ((*(uint32_t*)&(PERIPH)) != UART5_BASE)) \

  341.                                                   || ((USART_FLAG) != USART_FLAG_CTS)) 

  342. #define IS_USART_BAUDRATE(BAUDRATE) (((BAUDRATE) > 0) && ((BAUDRATE) < 0x0044AA21))

  343. #define IS_USART_ADDRESS(ADDRESS) ((ADDRESS) <= 0xF)

  344. #define IS_USART_DATA(DATA) ((DATA) <= 0x1FF)

  345. 

  346. /**

  347.   * @}

  348.   */ 

  349. 

  350. /**

  351.   * @}

  352.   */ 

  353. 

  354. /** @defgroup USART_Exported_Macros

  355.   * @{

  356.   */ 

  357. 

  358. /**

  359.   * @}

  360.   */ 

  361. 

  362. /** @defgroup USART_Exported_Functions

  363.   * @{

  364.   */

  365. 

  366. void USART_DeInit(USART_TypeDef* USARTx);

  367. void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);

  368. void USART_StructInit(USART_InitTypeDef* USART_InitStruct);

  369. void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct);

  370. void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct);

  371. void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);

  372. void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);

  373. void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState);

  374. void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address);

  375. void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp);

  376. void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  377. void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength);

  378. void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  379. void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

  380. uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

  381. void USART_SendBreak(USART_TypeDef* USARTx);

  382. void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime);

  383. void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler);

  384. void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  385. void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  386. void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  387. void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState);

  388. void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState);

  389. void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode);

  390. void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState);

  391. FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);

  392. void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG);

  393. ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);

  394. void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

  395. 

  396. #ifdef __cplusplus

  397. }

  398. #endif

  399. 

  400. #endif /* __STM32F10x_USART_H */

  401. /**

  402.   * @}

  403.   */ 

  404. 

  405. /**

  406.   * @}

  407.   */ 

  408. 

  409. /**

  410.   * @}

  411.   */ 

  412. 

  413. /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/