二、IAR for ARM中STM32项目创建及其启动文件分析-世界杯第四名-2023年女足世界杯_乒乓世界杯

IAR for ARM

STM32F10X官方固件库：

链接: https://pan.baidu.com/s/1U6vfGqp9IhhkvVuDXcxTtQ

提取码: 9mcx

IAR for ARM项目文件

下面是我自己写整理创建的IAR for ARM项目文件

链接: https://pan.baidu.com/s/189WZVhEDhhO98BA3I2Jfeg

提取码: m5fu

启动文件及一些重要标准库的分析

启动文件

在按照网上的教程创建IAR的STM32项目时，网上的教程都要求在项目文件中放入启动文件startup_stm32f10x_xx.s，可我在编译时发现，即使把启动文件去掉，IAR还是可以正常编译并下载Hex到芯片中并调试，所以我猜测这个启动文件应该是由IAR自动集成到Hex中的，在IAR主界面，右键左边的项目名称 -> Options... -> General Options -> Target -> Device - > 选择ST STM32F103RC，IAR大概会根据你选择的不同的Device，写入不同的启动文件汇编代码。

2019-6-6更新

最新发现，官方库的启动文件虽然不能加断点，但却包含中断服务的声明，如果没有包含官方库的启动文件，中断服务将不会启用，所以最终我还是将startup_stm32f10x_hd.s文件加入到startup目录中，这样就可以写中断服务了

接下来解析的启动文件，在固件库的【/STM32F10x_StdPeriph_Lib_V3.5.0/Libraries/CMSIS/CM3/DeviceSupport/ST/STM32F10x/startup/iar/】路径中

因为不能给启动文件加断点，以下解析都是基于自己的理解和网上相关教程的解析：

启动文件的引导地址可以自己定义，如果使用默认的配置，IAR在编译时，将会使用IAR自己的系统库作为引导

__iar_program_start 这个入口函数就是IAR内部提供的入口函数，这个函数不能加断点，似乎只能通过反汇编的形式来分析，我在IAR程序目录搜索了一边，真的有很多cstartup.s文件，IAR提供了很多系列芯片的cstartup.s文件

;* 文件名： : startup_stm32f10x_md.s

;* 作者 : MCD Application Team

;* 版本 : V3.5.0

;* 日期 : 2011年3月11日

;* 描述 : STM32F10x是EWARM工具链中的中等容量像量表

;* : 这个模块执行了

;* : - 设置初始化SP（堆栈寄存器）

;* : - 配置时钟系统

;* : - 设置IAR程序的入口函数

;* : - 设置异常中断服务像量表的入口地址

;* After Reset the Cortex-M3 processor is in Thread mode,

;* priority is Privileged, and the Stack is set to Main.

;********************************************************************************

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

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

;* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,

;* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE

;* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING

;* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.

;*******************************************************************************

;

; The modules in this file are included in the libraries, and may be replaced

; by any user-defined modules that define the PUBLIC symbol _program_start or

; a user defined start symbol.

; To override the cstartup defined in the library, simply add your modified

; version to the workbench project.

;

; The vector table is normally located at address 0.

; When debugging in RAM, it can be located in RAM, aligned to at least 2^6.

; The name "__vector_table" has special meaning for C-SPY:

; it is where the SP start value is found, and the NVIC vector

; table register (VTOR) is initialized to this address if != 0.

;

; Cortex-M version

;

MODULE ?cstartup ; // 定义模块名称

;; Forward declaration of sections.

SECTION CSTACK:DATA:NOROOT(3)

SECTION .intvec:CODE:NOROOT(2)

EXTERN __iar_program_start ; // IAR程序暴露的入口地址名称

EXTERN SystemInit ; // 系统初始化时调用的地址

PUBLIC __vector_table ; // 中断向量表地址

DATA ; // 定义数据段的数据

__vector_table ; 压入中断向量表名称，以下只截取的部分内容，DCD指令是ARM指令集中的一个压栈的指令

DCD sfe(CSTACK)

DCD Reset_Handler ; Reset Handler

DCD NMI_Handler ; NMI Handler

............................................ 省略 ....................................................

DCD USBWakeUp_IRQHandler ; USB Wakeup from suspend

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;; Default interrupt handlers. ; // 定义默认的中断函数，这里只是弱定义，可以被用户自己定义的中断向量函数覆盖

;;

THUMB ; // 进入THUMB模式（THUMB-2指令集）

PUBWEAK Reset_Handler

SECTION .text:CODE:REORDER(2)

Reset_Handler

LDR R0, =SystemInit

BLX R0

LDR R0, =__iar_program_start

BX R0

PUBWEAK NMI_Handler

SECTION .text:CODE:REORDER(1)

NMI_Handler

B NMI_Handler

PUBWEAK HardFault_Handler

SECTION .text:CODE:REORDER(1)

.................................... 省略 .......................................

USBWakeUp_IRQHandler

B USBWakeUp_IRQHandler

END

stm32f10x_it 【异常中断服务】

以下是固件库提供的默认异常中断函数

// NMI中断，即不可屏蔽中断，不可屏蔽中断请求信号NMI用来通知CPU，发生了“灾难性”的事件，如电源掉电、存储器读写出错、总线奇偶位出错等。NMI线上中断请求是不可屏蔽的（即无法禁止的）、而且立即被CPU锁存。因此NMI是边沿触发，不需要电平触发。

void NMI_Handler(void);

// 硬件错误中断

void HardFault_Handler(void);

// 内存管理异常中断

void MemManage_Handler(void);

// 总线异常

void BusFault_Handler(void);

// 使用中异常

void UsageFault_Handler(void);

// 系统调用异常，SVC异常是必须立即得到响应的

void SVC_Handler(void);

// This function handles Debug Monitor exception. 调试监视异常

void DebugMon_Handler(void);

// 也是系统调用异常，但PendSV是为系统设备而设的“可悬挂请求”（pendable request），PendSV 的典型使用场合是在上下文切换时（在不同任务之间切换）

void PendSV_Handler(void);

// 系统定时器中断

void SysTick_Handler(void);

stm32f10x_rcc【复位与时钟控制器】

// 复位时钟

void RCC_DeInit(void);

// 配置外部告诉时钟

void RCC_HSEConfig(uint32_t RCC_HSE);

// 等待外部高速时钟启动

ErrorStatus RCC_WaitForHSEStartUp(void);

// 调整内部高速时钟（HSI）到指定的值

void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue);

// 启用或禁用内部高速时钟

void RCC_HSICmd(FunctionalState NewState);

// 配置PLL（锁相环）的时钟源和倍频因子

void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul);

// 启用或禁用PLL

void RCC_PLLCmd(FunctionalState NewState);

// 配置PREDIV1分频因子

#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL) || defined (STM32F10X_CL)

void RCC_PREDIV1Config(uint32_t RCC_PREDIV1_Source, uint32_t RCC_PREDIV1_Div);

#endif

#ifdef STM32F10X_CL

void RCC_PREDIV2Config(uint32_t RCC_PREDIV2_Div);

void RCC_PLL2Config(uint32_t RCC_PLL2Mul);

void RCC_PLL2Cmd(FunctionalState NewState);

void RCC_PLL3Config(uint32_t RCC_PLL3Mul);

void RCC_PLL3Cmd(FunctionalState NewState);

#endif /* STM32F10X_CL */

// 配置系统时钟源

void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource);

// 获取系统时钟源

uint8_t RCC_GetSYSCLKSource(void);

// 配置AHB总线时钟源

void RCC_HCLKConfig(uint32_t RCC_SYSCLK);

// 配置低速APB时钟源

void RCC_PCLK1Config(uint32_t RCC_HCLK);

// 配置高速APB时钟源

void RCC_PCLK2Config(uint32_t RCC_HCLK);

// 启用或禁用RCC中断

void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState);

// 配置USB或者OTG时钟源

#ifndef STM32F10X_CL

void RCC_USBCLKConfig(uint32_t RCC_USBCLKSource);

#else

void RCC_OTGFSCLKConfig(uint32_t RCC_OTGFSCLKSource);

#endif /* STM32F10X_CL */

// 配置ADC时钟源

void RCC_ADCCLKConfig(uint32_t RCC_PCLK2);

// 配置I2S2时钟源

#ifdef STM32F10X_CL

void RCC_I2S2CLKConfig(uint32_t RCC_I2S2CLKSource);

void RCC_I2S3CLKConfig(uint32_t RCC_I2S3CLKSource);

#endif /* STM32F10X_CL */

// 配置外部低速时钟源

void RCC_LSEConfig(uint8_t RCC_LSE);

// 启用或禁用内部低速时钟

void RCC_LSICmd(FunctionalState NewState);

// 配置RTC时钟源

void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource);

// 启用或禁用RTC时钟

void RCC_RTCCLKCmd(FunctionalState NewState);

// 获取各个片上的时钟频率

void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks);

// 启用或禁用AHB外设时钟

void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);

// 启用或禁用AHB2外设时钟

void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);

// 启用或禁用APB1外设时钟

void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);

// 对外设端口进行复位

#ifdef STM32F10X_CL

void RCC_AHBPeriphResetCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);

#endif /* STM32F10X_CL */

// 复位高速APB（APB2）外设

void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState);

// 复位低速APB（APB1）外设

void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState);

// 启用或禁用备份域

void RCC_BackupResetCmd(FunctionalState NewState);

// 启用或禁用时钟安全系统

void RCC_ClockSecuritySystemCmd(FunctionalState NewState);

// 选择MCO引脚输出的时钟源

void RCC_MCOConfig(uint8_t RCC_MCO);

// 根据给定的标志位来获取一些RCC一些设置的状态

FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG);

// 清除RCC标志位的状态

void RCC_ClearFlag(void);

// 获取RCC中断的状态

ITStatus RCC_GetITStatus(uint8_t RCC_IT);

// 清除中断挂起

void RCC_ClearITPendingBit(uint8_t RCC_IT);

stm32f10x_tim 【定时器】

可能是因为STM32时钟太多了，用于管理时钟的函数竟有差不多上百个

// 复位指定的通用定时器

void TIM_DeInit(TIM_TypeDef* TIMx);

// 初始化指定的通用定时器，设置基础频率

void TIM_TimeBaseInit(TIM_TypeDef* TIMx, TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);

// 初始化比较电平（不是很理解，以后在开发过程中理解了再补充注释）

void TIM_OC1Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);

void TIM_OC2Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);

void TIM_OC3Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);

void TIM_OC4Init(TIM_TypeDef* TIMx, TIM_OCInitTypeDef* TIM_OCInitStruct);

// 初始化外设定时器

void TIM_ICInit(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);

// 配置PWM输出信号

void TIM_PWMIConfig(TIM_TypeDef* TIMx, TIM_ICInitTypeDef* TIM_ICInitStruct);

void TIM_BDTRConfig(TIM_TypeDef* TIMx, TIM_BDTRInitTypeDef *TIM_BDTRInitStruct);

void TIM_TimeBaseStructInit(TIM_TimeBaseInitTypeDef* TIM_TimeBaseInitStruct);

void TIM_OCStructInit(TIM_OCInitTypeDef* TIM_OCInitStruct);

void TIM_ICStructInit(TIM_ICInitTypeDef* TIM_ICInitStruct);

void TIM_BDTRStructInit(TIM_BDTRInitTypeDef* TIM_BDTRInitStruct);

void TIM_Cmd(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_CtrlPWMOutputs(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_ITConfig(TIM_TypeDef* TIMx, uint16_t TIM_IT, FunctionalState NewState);

void TIM_GenerateEvent(TIM_TypeDef* TIMx, uint16_t TIM_EventSource);

void TIM_DMAConfig(TIM_TypeDef* TIMx, uint16_t TIM_DMABase, uint16_t TIM_DMABurstLength);

void TIM_DMACmd(TIM_TypeDef* TIMx, uint16_t TIM_DMASource, FunctionalState NewState);

void TIM_InternalClockConfig(TIM_TypeDef* TIMx);

void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource);

void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource,

uint16_t TIM_ICPolarity, uint16_t ICFilter);

void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity,

uint16_t ExtTRGFilter);

void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler,

uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);

void TIM_ETRConfig(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity,

uint16_t ExtTRGFilter);

void TIM_PrescalerConfig(TIM_TypeDef* TIMx, uint16_t Prescaler, uint16_t TIM_PSCReloadMode);

void TIM_CounterModeConfig(TIM_TypeDef* TIMx, uint16_t TIM_CounterMode);

void TIM_SelectInputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource);

void TIM_EncoderInterfaceConfig(TIM_TypeDef* TIMx, uint16_t TIM_EncoderMode,

uint16_t TIM_IC1Polarity, uint16_t TIM_IC2Polarity);

void TIM_ForcedOC1Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);

void TIM_ForcedOC2Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);

void TIM_ForcedOC3Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);

void TIM_ForcedOC4Config(TIM_TypeDef* TIMx, uint16_t TIM_ForcedAction);

void TIM_ARRPreloadConfig(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_SelectCOM(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_SelectCCDMA(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_CCPreloadControl(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_OC1PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);

void TIM_OC2PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);

void TIM_OC3PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);

void TIM_OC4PreloadConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPreload);

void TIM_OC1FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);

void TIM_OC2FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);

void TIM_OC3FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);

void TIM_OC4FastConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCFast);

void TIM_ClearOC1Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);

void TIM_ClearOC2Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);

void TIM_ClearOC3Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);

void TIM_ClearOC4Ref(TIM_TypeDef* TIMx, uint16_t TIM_OCClear);

void TIM_OC1PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);

void TIM_OC1NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);

void TIM_OC2PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);

void TIM_OC2NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);

void TIM_OC3PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);

void TIM_OC3NPolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCNPolarity);

void TIM_OC4PolarityConfig(TIM_TypeDef* TIMx, uint16_t TIM_OCPolarity);

void TIM_CCxCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCx);

void TIM_CCxNCmd(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_CCxN);

void TIM_SelectOCxM(TIM_TypeDef* TIMx, uint16_t TIM_Channel, uint16_t TIM_OCMode);

void TIM_UpdateDisableConfig(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_UpdateRequestConfig(TIM_TypeDef* TIMx, uint16_t TIM_UpdateSource);

void TIM_SelectHallSensor(TIM_TypeDef* TIMx, FunctionalState NewState);

void TIM_SelectOnePulseMode(TIM_TypeDef* TIMx, uint16_t TIM_OPMode);

void TIM_SelectOutputTrigger(TIM_TypeDef* TIMx, uint16_t TIM_TRGOSource);

void TIM_SelectSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_SlaveMode);

void TIM_SelectMasterSlaveMode(TIM_TypeDef* TIMx, uint16_t TIM_MasterSlaveMode);

void TIM_SetCounter(TIM_TypeDef* TIMx, uint16_t Counter);

void TIM_SetAutoreload(TIM_TypeDef* TIMx, uint16_t Autoreload);

void TIM_SetCompare1(TIM_TypeDef* TIMx, uint16_t Compare1);

void TIM_SetCompare2(TIM_TypeDef* TIMx, uint16_t Compare2);

void TIM_SetCompare3(TIM_TypeDef* TIMx, uint16_t Compare3);

void TIM_SetCompare4(TIM_TypeDef* TIMx, uint16_t Compare4);

void TIM_SetIC1Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);

void TIM_SetIC2Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);

void TIM_SetIC3Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);

void TIM_SetIC4Prescaler(TIM_TypeDef* TIMx, uint16_t TIM_ICPSC);

void TIM_SetClockDivision(TIM_TypeDef* TIMx, uint16_t TIM_CKD);

uint16_t TIM_GetCapture1(TIM_TypeDef* TIMx);

uint16_t TIM_GetCapture2(TIM_TypeDef* TIMx);

uint16_t TIM_GetCapture3(TIM_TypeDef* TIMx);

uint16_t TIM_GetCapture4(TIM_TypeDef* TIMx);

uint16_t TIM_GetCounter(TIM_TypeDef* TIMx);

uint16_t TIM_GetPrescaler(TIM_TypeDef* TIMx);

FlagStatus TIM_GetFlagStatus(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);

void TIM_ClearFlag(TIM_TypeDef* TIMx, uint16_t TIM_FLAG);

ITStatus TIM_GetITStatus(TIM_TypeDef* TIMx, uint16_t TIM_IT);

void TIM_ClearITPendingBit(TIM_TypeDef* TIMx, uint16_t TIM_IT);

stm32f10x_usart 【串口通信】

// 复位USART

void USART_DeInit(USART_TypeDef* USARTx);

// 填充指定的USART到默认值

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

// 填充USART_InitTypeDef结构体到默认值

void USART_StructInit(USART_InitTypeDef* USART_InitStruct);

// 填充指定外设的USART的USART_ClockInitTypeDef结构体到默认值

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

// 填充USART_ClockInitStruct到默认值

void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct);

void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);

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

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

void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address);

void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp);

void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength);

void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);

uint16_t USART_ReceiveData(USART_TypeDef* USARTx);

void USART_SendBreak(USART_TypeDef* USARTx);

void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime);

void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler);

void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState);

void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode);

void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState);

FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);

void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG);

ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);

void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

stm32f10x_gpio 【通用输入输出】

void GPIO_DeInit(GPIO_TypeDef* GPIOx);

void GPIO_AFIODeInit(void);

void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);

void GPIO_StructInit(GPIO_InitTypeDef* GPIO_InitStruct);

uint8_t GPIO_ReadInputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

uint16_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx);

uint8_t GPIO_ReadOutputDataBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

uint16_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx);

void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, BitAction BitVal);

void GPIO_Write(GPIO_TypeDef* GPIOx, uint16_t PortVal);

void GPIO_PinLockConfig(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

void GPIO_EventOutputConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource);

void GPIO_EventOutputCmd(FunctionalState NewState);

void GPIO_PinRemapConfig(uint32_t GPIO_Remap, FunctionalState NewState);

void GPIO_EXTILineConfig(uint8_t GPIO_PortSource, uint8_t GPIO_PinSource);

void GPIO_ETH_MediaInterfaceConfig(uint32_t GPIO_ETH_MediaInterface);