STM32 深入浅出 （新手必看） (www.ourdev.cn)

STM32学前班教程之一：为什么是它
经过几天的学习，基本掌握了STM32的调试环境和一些基本知识。想拿出来与大家共享，笨教程本着最大限度简化删减STM32入门的过程的思想，会把我的整个入门前的工作推荐给大家。就算是给网上的众多教程、笔记的一种补充吧，所以叫学前班教程。其中涉及产品一律隐去来源和品牌，以防广告之嫌。全部汉字内容为个人笔记。所有相关参考资料也全部列出。:lol
教程会分几篇，因为太长啦。今天先来说说为什么是它——我选择STM32的原因。
我对未来的规划是以功能性为主的，在功能和面积之间做以平衡是我的首要选择，而把运算放在第二位，这根我的专业有关系。里面的运算其实并不复杂，在入门阶段想尽量减少所接触的东西。
不过说实话，对DSP的外设并和开发环境不满意，这是为什么STM32一出就转向的原因。下面是我自己做过的两块DSP28的全功能最小系统板，在做这两块板子的过程中发现要想尽力缩小DSP的面积实在不容易（目前只能达到50mm×45mm，这还是没有其他器件的情况下），尤其是双电源的供电方式和1.9V的电源让人很头疼。
后来因为一个项目，接触了LPC2148并做了一块板子，发现小型的ARM7在外设够用的情况下其实很不错，于是开始搜集相关芯片资料，也同时对小面积的AVR和51都进行了大致的比较，这个时候发现了CortexM3的STM32，比2148拥有更丰富和灵活的外设，性能几乎是2148两倍（按照MIPS值计算）。正好2148我还没上手，就直接转了这款STM32F103。
与2811相比较（核心1.8V供电情况下），135MHz×1MIPS。现在用STM32F103，72MHz×1.25MIPS，性能是DSP的66%，STM32F103R型（64管脚）芯片面积只有2811的51%，STM32F103C型（48管脚）面积是2811的25%，最大功耗是DSP的20%，单片价格是DSP的30%。且有更多的串口，CAP和PWM，这是有用的。高端型号有SDIO，理论上比SPI速度快。
由以上比较，准备将未来的拥有操作系统的高端应用交给DSP的新型浮点型单片机28335，而将所有紧凑型小型、微型应用交给STM32。
的STM32学前班教程：怎么开发
sw笨笨的STM32学前班教程之二：怎么开发目前手头的入门阶段使用的开发器概述
该产品为简易STM32调试器和DEMO板一体化的调试学习设备，价格在一百多块。
2、硬件配置
仿真部分：USB口，reset，指示灯，JTAG
DEMO部分：4按键（IO），4LED（IO），一个串口，启动方式跳线，所有引脚的焊盘（可自行焊接插针进行扩展）
DEMO芯片：STM32F103C8T6（程序空间64K）
参数和扩展：
注：学习的目标芯片是STM32F103CBT6（7×7mm，128K flash，16K RAM）以及STM32F103RET6（10×10mm，512K flash，64K RAM）。
STM32-SK的硬件连接方法（用板载调试器调试板载DEMO）：
JP3、JP5 须全部短接
USB通过电缆连接至PC的USB
串口连接至PC的串口或者通过USB转串口电缆连接（力特Z-TEC，USB2.0与RS232转接电缆）
WindowsXP自动安装驱动
安装完成后如果DEMO板里面有程序就会自动运行了。这是ST-Link-II的通用连接方法
以上是学习阶段比较方便的仿真器，进入工程阶段后准备换J-Link V7的仿真器进行开发。目前比较满意的产品：JLink v7+USB转串口：
购买后所需的改造：打开壳体，将USB的+5V供电跟JTAG20针的第二脚Vsupply飞线，提供目标板5V500mA的供电。看中的特点：集成串口，拥有20针JTAG可以改造Vspply为供电接口，小巧好带，便宜。
常见的用于STM32单片机的仿真器分类
a) Ulink2：之前常用的仿真器。Keil公司产品，之前专用于ARM7，现扩展到CortexM3，调试接口支持JTAG和SWD，连接到PC主机的USB。现在这种调试器已经用的越来越少了。
b) ST-Link-II：ST公司的仿真接口，支持IAR EWARM，USB 1.1全速，USB电源供电，自适应目标系统JTAG电平3.3V-5V，可向目标系统提供不大于5V/200mA电源。这种调试器不多见，但是许多调试器与目标板一体设计的学习板上常见。
c) J-Link V6/V7：SEGGER公司产品，调试接口支持JTAG和SWV（V7速度是V6的12倍），USB 2.0接口，通过USB供电，下载速度达到720k byte/s， 与IAR WEARM无缝集成，宽目标板电压范围：1.2V-3.3V（V7支持5V），多核调试，给目标板提供3.3V50mA电源。这种调试器现在出现的越来越多，兼容性比较好（主要是指能够与IAR WEARM无缝集成这点），国内山寨货和各种变种也很多。
6、目标板主要分为一体化设计（与调试器、供电整合）和单独设计两类，详细产品比较见豆皮的《如何选择STM32开发板》。
STM32学前班教程之三：让PC工作
开发软件的选择
1、 软件与版本的选择
需求：支持STLink2或未来的Jlink V7调试接口（因为STM32-SK使用这个接口），能够找到去除软件限制的方法，最好具有中文版帮助和界面，最好带有纯软件仿真
选择：RealView MDK 3.23RPC或者IAR EWARM 4.42A（5版本观望一下）。
2、 RealView MDK 3.23RPC（中国版）安装与去除限制
第一步：执行安装程序完成基本安装，最后选项选择加入虚拟硬件，便于纯软件调试。
第二步：执行软件，点击File-->Licence Manager，复制CID的数据到破解器的CID，其他选项如下图，然后点击Generate。
第三步：复制LIC0的数据到软件的LIC框里面，点击Add LIC。注意添加序列号后Licence Manager会算出这个号对应的有效期，如果到期会显示为红色，需要重新点击破解软件的Generate，再算一个填进去就行了。
第四步：将ST-LINKII-KEIL Driver所需的文件（两个DLL）拷贝到\Keil\ARM\BIN下，替换原有文件。
第五步：打开Keil安装目录下的TOOLS.INI文件，在[ARM]、[ARMADS]、[KARM]项目下添加TDRV7=BIN\ST-LINKII-KEIL.dll("ST LinkII Debugger")行，并保存修改。
第六步：打开MDK，在项目的options设置的Debug选项中选择ST LINKII Debugger，同时在Utilities的选项中选择ST LINKII Debugger。
完成以上步骤，就完成了ST-LINKII的相关配置，可以作为调试器开始使用。注意：目前ST-LINKII不支持Flash菜单中的Download和Erase命令，程序在使用Start/Stop Debug Session时自动载入flash中供调试。
3、 IAR EWARM 4.42A安装与破解
第一步：开始/运行…/CMD显示DOS界面，执行iarid.exe>>ID.TXT得到本机ID码，复制这个ID码，再执行iarkg.exe ID码>>Lic422A.TXT，得到一组注册码。
第二步：使用EWARM-EV-WEB-442A.exe（30天限制版，其他版本无法使用第一步中的注册码），执行安装程序完成基本安装，过程中需要添入第一步里面算出来的注册码，可以取消时间限制，但是那一组当中只有一个有效，需要实验。
4、 链接硬件调试程序
RealView MDK：找到一个STM32-SK的基础程序，最好是只关于IO的且与当前板子程序不同，这样在板上就可以看到结果，点击Project/open project。例如GPIO、TIMER（另两个例程是关于串口的，需要连接串口才能够看到运行结果）。
使用“Open Project”打开，然后设置Option里面的linker和Utilities里面的项目为“ST LinkII Debuger”。
编译程序，再使用“Start/Stop Debug Session”来写入程序。
IAR EWARM：与以上相同，找到一个符合条件的例程。打开一个eww工程文件，右键选取Option，在Debuger里面选择“Third-Party Driver”,在“Third-Party Driver”里面添上“$PROJ_DIR$\..\ddl\STM32Driver.dll”。
使用“Make”或“Rebuild All”来编译程序，点“Debug”就烧写进Flash。使用调试栏里面的“go”等等运行程序。
注：由于目前版本MDK与我手头的ST-LINK-II编程器不兼容，所以后面的所有工作均改用IAR。
STM32学前班教程之四：打好基础建立模板
1、 新建目录Project_IAR4，按照自己的顺序重新组织dll（驱动）；inc、src函数库；settings，其他所有文件全部放这个新建的目录下。
2、 双击打开Project.eww，继续更改内部设置。
3、 需更改的内容列表：
位置和项目 目标 说明
Project\Edir confignations 新建基于STM3210B的配置 编译目标和过程文件存放
Project\Option\General Option\Target ST STM32F10x 选择芯片类型
Project\Option\ C/C++ Compiler\Preprocessor\Additional include directories $PROJ_DIR$\
$PROJ_DIR$\inc 头文件相对位置，需要包括“map/lib/type”的位置
Project\Option\ C/C++ Compiler\Preprocessor\Defined symbols  空 空白是在Flash里面调试程序，VECT_TAB_RAM是在RAM里调试程序
Project\Option\ C/C++ Compiler\Optimizations\Size 最终编译一般选择High
调试可选None None,Low,Medium,High是不同的代码优化等级
Project\Option\ Linker\Output 去掉Overrride default 输出格式使用默认
Project\Option\ Linker\Extra Output 打开General Extra Output去掉Overrride default 厂家要求
Project\Option\ Linker\Config 打开Overrride default
$PROJ_DIR$\lnkarm_flash.xcl 使用Flash调试程序，如果需要使用RAM调试则改为lnkarm_RAM.xcl
Project\Option\ Debugger\Setup\Driver  Third-Party Driver 使用第三方驱动连接单片机
Project\Option\ Debugger\ Download Use flash loader 下载到flash所需的设置
Project\Option\ Debugger\ Third-Party Driver\ Third-Party Driver\IAR debugger driver $PROJ_DIR$\ddl\STM32Driver.dll 驱动文件路径
注1：所有跟路径相关的设置需要根据实际情况编写，相对路径的编写——“$PROJ_DIR$”代表eww文件所在文件夹，“..”代表向上一层。
注2：其他设置使用库函数里面的工程文件的默认选项即可，初学不用了解太多。
4、 需要重新删除并重新添加Project下“FWLib”和“User”的所有文件，为了删减外设模块方便需要在“USER”额外添加“stm32f10x_conf.h”（不添加也可以，需要展开main.c找到它）。然后执行Project\Rebuid All，通过则设置完毕。
5、 完成以上步骤，第一个自己习惯的程序库就建立完毕了，以后可以从“stm32f10x_conf.h”中删减各种库文件，从“stm32f10x_it.c”编辑中断，从“main.c”编写得到自己的程序。最后需要将这个库打包封存，每次解压缩并修改主目录名称即可。
6、 我的程序库特点：
a) 默认兼容ST-LINK-II，IAR EWARM 4.42A，Flash调试，其他有可能需要更改设置
b) 为操作方便减少了目录的层次
c) 为学习方便使用网友汉化版2.0.2固件，主要是库函数中c代码的注释。
后面随着学习深入将在我的模板里面加入如下内容：
d) 加入必用的flash（读取优化），lib（debug），nvic（中断位置判断、开中断模板），rcc（时钟管理模板，开启外设时钟模板），gpio（管脚定义模板）的初始化代码，所有模板代码用到的时候只要去掉前面的注释“//”，根据需求填入相应值就可以了。
e) 因为自己记性不好，所以main函数中的代码做到每行注释，便于自己以后使用。
f) 集成Print_U函数简单串口收发函数代码，便于调试，改变使用Printf函数的调试习惯。
g) 集成使用systick的精确延时函数delay。
h) 集成时钟故障处理代码。
i) 集成电压监控代码。
j) 集成片上温度检测代码。
k) 逐步加入所有外设的初始化模块
一、编写程序所需的步骤
1、解压缩，改目录名称，和eww文件名，以便跟其他程序区分。
2、更改设置：在“stm32f10x_conf.h”关闭不用的外设（在其声明函数前面加注释符号“//”）。并根据外部晶振速度更改其中“HSE_Value”的数值，其单位是Hz。
3、完成各种头文件的包含（#include "xxx.h";），公共变量的声明（static 数据类型 变量名称;），子程序声明（void 函数名称(参数);）……C语言必须的前置工作。
4、改写我的程序库里面所预设的模板，再进行其他模块的初始化子程序代码的编写，并在程序代码的开始部分调用。注意：必须记住所有外设的使用需要考虑4个问题：
a)     开时钟RCC（在RCC初始化中）；
b)     自身初始化；
c)     相关管脚配置（在GPIO初始化中）；
d)     是否使用中断（在NVIC初始化中）
5、编写main.c中的主要代码和各种子函数。
6、在“stm32f10x_it.c”填写各种中断所需的执行代码，如果用不到中断的简单程序则不用编写此文件。
7、编译生成 “bin”的方法：Project\Option\ Linker\Output\Format，里面选择“Other”，在下面的“Output”选 “raw-binary”生成bin。
8、编译生成“hex”的方法：Project\Option\ Linker\Output\Format，里面选择“Other”，在下面的“Output”选“intel-extended”，生成a79直接改名成为hex或者选中上面的“Output Flie”在“Overrride default”项目里面改扩展名为hex。
使用软件界面的Debug烧写并按钮调试程序。注意，ST-Link-II是直接将程序烧写进Flash进行调试，而不是使用RAM的方式。
STM32学前班教程之五：给等待入门的人一点点建议
入门必须阅读的相关文档
1、 几个重要官方文档的功能：
a) Datasheet——芯片基本数据，功能参数封装管脚定义和性能规范。
b) 固件函数库用户手册——函数库功能，库函数的定义、功能和用法。
c) 参考手册——各种功能的具体描述，使用方法，原理，相关寄存器。
d) STM32F10xxx硬件开发：使用入门——相关基础硬件设计
e) STM32F10XXX的使用限制：芯片内部未解决的硬件设计bug，开发需要注意绕开。
f) 一本简单的C语言书，相信我，不用太复杂。
2、 其他的有用文档，对初学帮助很大
a) 如何使用STM32的软件库在IAR的EWARM下进行应用开发——IAR基础设置。
b) 轻松进入STM32+Cortex-M3世界.ppt——开发板和最小系统设计需求。
c) 如何选择STM32开发板.pdf——各种开发板介绍和功能比较。
d) MXCHIP的系列视频教程——全部芯片基础及其外设的教程，使用函数库编程的话就不用看每个视频后半段的关于寄存器的介绍了。
e) STM32_Technical_Slide(常见问题)——一些优化设计方案。
3、 关于参考书，买了两本但是基本对学习没什么帮助，如果凑齐以上资料，建议慎重买书，不如留着那n个几十块钱，攒到一起买开发板。
我自己的学习过程
1、 一共24个库，不可能都学，都学也没用。按照我的工作需求必须学的有16个，这16个也不是全学。主要学习来源是各种例程代码、“固件函数库用户手册”和“参考手册”。
具体学习方法是通读不同来源的程序，在程序中找到相关的函数库的应用，然后再阅读相关文档，有条件的实验。对于内容的选择方面，根据入门内容和未来应用，将所涉及的范围精简到最低，但是对所选择的部分的学习则力求明确。以下是我按照自己的需求对程序库函数排列的学习顺序：
a) 绝大部分程序都要涉及到的库——flash，lib，nvic，rcc，只学基础的跟最简单应用相关必用的部分，其他部分后期再返回头学。
b) 各种程序通用但不必用的库——exti，MDA，systic，只通读理解其作用。
c) DEMO板拥有的外设库——gpio，usart，编写代码实验。
d) 未来需要用到的外设的库——tim，tim1，adc，i2c，spi，先理解等待有条件后实验。
e) 开发可靠性相关库——bkp，iwdg，wwdg，pwr，参考其他例程的做法。
f) 其他，根据兴趣来学。
STM32学前班教程之六：这些代码大家都用得到
2、 阅读flash： 芯片内部存储器flash操作函数
我的理解——对芯片内部flash进行操作的函数，包括读取，状态，擦除，写入等等，可以允许程序去操作flash上的数据。
基础应用1，FLASH时序延迟几个周期，等待总线同步操作。推荐按照单片机系统运行频率，0—24MHz时，取Latency=0；24—48MHz时，取Latency=1；48~72MHz时，取Latency=2。所有程序中必须的
用法：FLASH_SetLatency(FLASH_Latency_2);
位置：RCC初始化子函数里面，时钟起振之后。
基础应用2，开启FLASH预读缓冲功能，加速FLASH的读取。所有程序中必须的
用法：FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
位置：RCC初始化子函数里面，时钟起振之后。
3、 阅读lib：调试所有外设初始化的函数。
我的理解——不理解，也不需要理解。只要知道所有外设在调试的时候，EWRAM需要从这个函数里面获得调试所需信息的地址或者指针之类的信息。
基础应用1，只有一个函数debug。所有程序中必须的。
用法： #ifdef DEBUG
debug();
#endif
位置：main函数开头，声明变量之后。
4、 阅读nvic：系统中断管理。
我的理解——管理系统内部的中断，负责打开和关闭中断。
基础应用1，中断的初始化函数，包括设置中断向量表位置，和开启所需的中断两部分。所有程序中必须的。
用法： void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;//中断管理恢复默认参数
#ifdef  VECT_TAB_RAM
//如果C/C++ Compiler\Preprocessor\Defined symbols中的定义了VECT_TAB_RAM（见程序库更改内容的表格）
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); //则在RAM调试
#else        //如果没有定义VECT_TAB_RAM
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);//则在Flash里调试
#endif        //结束判断语句
//以下为中断的开启过程，不是所有程序必须的。
//NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//设置NVIC优先级分组，方式。
//注：一共16个优先级，分为抢占式和响应式。两种优先级所占的数量由此代码确定，NVIC_PriorityGroup_x可以是0、1、2、3、4，分别代表抢占优先级有1、2、4、8、16个和响应优先级有16、8、4、2、1个。规定两种优先级的数量后，所有的中断级别必须在其中选择，抢占级别高的会打断其他中断优先执行，而响应级别高的会在其他中断执行完优先执行。
//NVIC_InitStructure.NVIC_IRQChannel = 中断通道名;
//开中断，中断名称见函数库
//NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
//抢占优先级
//NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
//响应优先级
//NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//启动此通道的中断
//NVIC_Init(&NVIC_InitStructure);     //中断初始化
}
5、 阅读rcc：单片机时钟管理。
我的理解——管理外部、内部和外设的时钟，设置、打开和关闭这些时钟。
基础应用1：时钟的初始化函数过程——
用法：void RCC_Configuration(void)    //时钟初始化函数
{
ErrorStatus HSEStartUpStatus;     //等待时钟的稳定
RCC_DeInit();         //时钟管理重置
RCC_HSEConfig(RCC_HSE_ON);      //打开外部晶振
HSEStartUpStatus = RCC_WaitForHSEStartUp(); //等待外部晶振就绪
if (HSEStartUpStatus == SUCCESS)
{
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
//flash读取缓冲，加速
FLASH_SetLatency(FLASH_Latency_2); //flash操作的延时
RCC_HCLKConfig(RCC_SYSCLK_Div1); //AHB使用系统时钟
RCC_PCLK2Config(RCC_HCLK_Div2);  //APB2（高速）为HCLK的一半
RCC_PCLK1Config(RCC_HCLK_Div2);  //APB1（低速）为HCLK的一半
//注：AHB主要负责外部存储器时钟。PB2负责AD，I/O，高级TIM，串口1。APB1负责DA，USB，SPI，I2C，CAN，串口2345，普通TIM。
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
//PLLCLK = 8MHz * 9 = 72 MHz
RCC_PLLCmd(ENABLE);     //启动PLL
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){}
//等待PLL启动
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
//将PLL设置为系统时钟源
while (RCC_GetSYSCLKSource() != 0x08){}
//等待系统时钟源的启动
}
//RCC_AHBPeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE);
//启动AHP设备
//RCC_APB2PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE);
//启动ABP2设备
//RCC_APB1PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE);
//启动ABP1设备
}
1、阅读exti：外部设备中断函数
我的理解——外部设备通过引脚给出的硬件中断，也可以产生软件中断，19个上升、下降或都触发。EXTI0～EXTI15连接到管脚，EXTI线16连接到PVD（VDD监视），EXTI线17连接到RTC（闹钟），EXTI线18连接到USB（唤醒）。
基础应用1，设定外部中断初始化函数。按需求，不是必须代码。
用法： void EXTI_Configuration(void)
{
EXTI_InitTypeDef EXTI_InitStructure; //外部设备中断恢复默认参数
EXTI_InitStructure.EXTI_Line = 通道1|通道2;
//设定所需产生外部中断的通道，一共19个。
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //产生中断
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
//上升下降沿都触发
EXTI_InitStructure.EXTI_LineCmd = ENABLE; //启动中断的接收
EXTI_Init(&EXTI_InitStructure);           //外部设备中断启动
}
2、阅读dma：通过总线而越过CPU读取外设数据
我的理解——通过DMA应用可以加速单片机外设、存储器之间的数据传输，并在传输期间不影响CPU进行其他事情。这对于入门开发基本功能来说没有太大必要，这个内容先行跳过。
3、阅读systic：系统定时器
我的理解——可以输出和利用系统时钟的计数、状态。
基础应用1，精确计时的延时子函数。推荐使用的代码。
用法：
static vu32 TimingDelay;//全局变量声明
void SysTick_Config(void)//systick初始化函数
{
SysTick_CounterCmd(SysTick_Counter_Disable);//停止系统定时器
SysTick_ITConfig(DISABLE);                //停止systick中断
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);
//systick使用HCLK作为时钟源，频率值除以8。
SysTick_SetReload(9000);//重置时间1毫秒（以72MHz为基础计算）
SysTick_ITConfig(ENABLE);//开启systic中断
}
void Delay (u32 nTime) //延迟一毫秒的函数
{
SysTick_CounterCmd(SysTick_Counter_Enable);   //systic开始计时
TimingDelay = nTime;               //计时长度赋值给递减变量
while(TimingDelay != 0);           //检测是否计时完成
SysTick_CounterCmd(SysTick_Counter_Disable);  //关闭计数器
SysTick_CounterCmd(SysTick_Counter_Clear);    //清除计数值
}
void TimingDelay_Decrement(void)
//递减变量函数，函数名由“stm32f10x_it.c”中的中断响应函数定义好了。
{
if (TimingDelay != 0x00)               //检测计数变量是否达到0
{
TimingDelay--;                     //计数变量递减
}
}
注：建议熟练后使用，所涉及知识和设备太多，新手出错的可能性比较大。新手可用简化的延时函数代替：
void Delay(vu32 nCount)//简单延时函数
{
for(; nCount != 0; nCount--);（循环变量递减计数）
}
当延时较长，又不需要精确计时的时候可以使用嵌套循环：
void Delay(vu32 nCount)        //简单的长时间延时函数
{int i;                         //声明内部递减变量
for(; nCount != 0; nCount--)  //递减变量计数
{for (i=0; i<0xffff; i++)}  //内部循环递减变量计数
}
4、阅读gpio：I/O设置函数
我的理解——所有输入输出管脚模式设置，可以是上下拉、浮空、开漏、模拟、推挽模式，频率特性为2M，10M，50M。也可以向该管脚直接写入数据和读取数据。
基础应用1，gpio初始化函数。所有程序必须。
用法：void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;   //GPIO状态恢复默认参数
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_标号 | GPIO_Pin_标号 ;
//管脚位置定义，标号可以是NONE、ALL、0至15。
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;//输出速度2MHz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入模式
GPIO_Init(GPIOC, &GPIO_InitStructure);        //C组GPIO初始化
//注：以上四行代码为一组，每组GPIO属性必须相同，默认的GPIO参数为：ALL，2MHz，FLATING。如果其中任意一行与前一组相应设置相同，那么那一行可以省略，由此推论如果前面已经将此行参数设定为默认参数（包括使用GPIO_InitTypeDef GPIO_InitStructure代码），本组应用也是默认参数的话，那么也可以省略。以下重复这个过程直到所有应用的管脚全部被定义完毕。
……
}
基础应用2，向管脚写入0或1
用法：GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
STM32笔记之七：让它跑起来，基本硬件功能的建立
0、        实验之前的准备
a)        接通串口转接器
b)        下载IO与串口的原厂程序，编译通过保证调试所需硬件正常。
1、        flash，lib，nvic，rcc和GPIO，基础程序库编写
a)        这几个库函数中有一些函数是关于芯片的初始化的，每个程序中必用。为保障程序品质，初学阶段要求严格遵守官方习惯。注意，官方程序库例程中有个platform_config.h文件，是专门用来指定同类外设中第几号外设被使用，就是说在main.c里面所有外设序号用x代替，比如USARTx，程序会到这个头文件中去查找到底是用那些外设，初学的时候参考例程别被这个所迷惑住。
b)        全部必用代码取自库函数所带例程，并增加逐句注释。
c)        习惯顺序——Lib（debug），RCC（包括Flash优化），NVIC，GPIO
d)        必用模块初始化函数的定义：
void RCC_Configuration(void);        //定义时钟初始化函数
void GPIO_Configuration(void);        //定义管脚初始化函数
void NVIC_Configuration(void);        //定义中断管理初始化函数
void Delay(vu32 nCount);                        //定义延迟函数
e)        Main中的初始化函数调用：
RCC_Configuration();                //时钟初始化函数调用
NVIC_Configuration();        //中断初始化函数调用
GPIO_Configuration();        //管脚初始化函数调用
f)        Lib注意事项：
属于Lib的Debug函数的调用，应该放在main函数最开始，不要改变其位置。
g)        RCC注意事项：
Flash优化处理可以不做，但是两句也不难也不用改参数……
根据需要开启设备时钟可以节省电能
时钟频率需要根据实际情况设置参数
h)        NVIC注意事项
注意理解占先优先级和响应优先级的分组的概念
i)        GPIO注意事项
注意以后的过程中收集不同管脚应用对应的频率和模式的设置。
作为高低电平的I/O，所需设置：RCC初始化里面打开RCC_APB2
PeriphClockCmd(RCC_APB2Periph_GPIOA);GPIO里面管脚设定：IO输出（50MHz，Out_PP）；IO输入（50MHz，IPU）；
j)        GPIO应用
GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_RESET);//重置
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) ;//读入IO
k)        简单Delay函数
void Delay(vu32 nCount)//简单延时函数
{for(; nCount != 0; nCount--);}
实验步骤：
RCC初始化函数里添加：RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB , ENABLE);
不用其他中断，NVIC初始化函数不用改
GPIO初始化代码：
//IO输入，GPIOB的2、10、11脚输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;//管脚号
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //输出速度
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //输入输出模式
GPIO_Init(GPIOB, &GPIO_InitStructure);              //初始化
简单的延迟函数：
void Delay(vu32 nCount)                     //简单延时函数
{ for (; nCount != 0; nCount--);}           //循环计数延时
完成之后再在main.c的while里面写一段：
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
Delay（0xffff）;
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
Delay（0xffff）;
就可以看到连接在PB2脚上的LED闪烁了，单片机就跑起来了。
STM32笔记之八：来跟PC打个招呼，基本串口通讯
a)        目的：在基础实验成功的基础上，对串口的调试方法进行实践。硬件代码顺利完成之后，对日后调试需要用到的printf重定义进行调试，固定在自己的库函数中。
b)        初始化函数定义：
void USART_Configuration(void);        //定义串口初始化函数
c)        初始化函数调用：
void UART_Configuration(void);        //串口初始化函数调用
初始化代码：
void USART_Configuration(void)                        //串口初始化函数
{
//串口参数初始化
USART_InitTypeDef USART_InitStructure;              //串口设置恢复默认参数
//初始化参数设置
USART_InitStructure.USART_BaudRate = 9600;                                     //波特率9600
USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长8位
USART_InitStructure.USART_StopBits = USART_StopBits_1;                 //1位停止字节
USART_InitStructure.USART_Parity = USART_Parity_No;                      //无奇偶校验
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//打开Rx接收和Tx发送功能
USART_Init(USART1, &USART_InitStructure);                                         //初始化
USART_Cmd(USART1, ENABLE);                                                          //启动串口
}
RCC中打开相应串口
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
GPIO里面设定相应串口管脚模式
//串口1的管脚初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                        //管脚9
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;       //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure);                               //TX初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                    //管脚10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);                             //RX初始化
d)        简单应用：
发送一位字符
USART_SendData(USART1, 数据);                //发送一位数据
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}                                                                                        //等待发送完毕
接收一位字符
while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET){}                                                                                        //等待接收完毕
变量= (USART_ReceiveData(USART1));        //接受一个字节
发送一个字符串
先定义字符串：char rx_data[250];
然后在需要发送的地方添加如下代码
int i;                                                                     //定义循环变量
while(rx_data!='\0')                                           //循环逐字输出，到结束字'\0'
{USART_SendData(USART1, rx_data);            //发送字符
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待字符发送完毕
i++;}
e)        USART注意事项：
发动和接受都需要配合标志等待。
只能对一个字节操作，对字符串等大量数据操作需要写函数
使用串口所需设置：RCC初始化里面打开RCC_APB2PeriphClockCmd
(RCC_APB2Periph_USARTx);GPIO里面管脚设定：串口RX（50Hz，IN_FLOATING）；串口TX（50Hz，AF_PP）；
f)        printf函数重定义（不必理解，调试通过以备后用）
（1）        需要c标准函数：
#include "stdio.h"
（2）        粘贴函数定义代码
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  //定义为putchar应用
（3）        RCC中打开相应串口
（4）        GPIO里面设定相应串口管脚模式
（6）        增加为putchar函数。
int putchar(int c)                                              //putchar函数
{
if (c == '\n'){putchar('\r');}                                //将printf的\n变成\r
USART_SendData(USART1, c);                                    //发送字符
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待发送结束
return c;                                                     //返回值
}
（8）        通过，试验成功。printf使用变量输出:%c字符，%d整数，%f浮点数,%s字符串，/n或/r为换行。注意：只能用于main.c中。
3、        NVIC串口中断的应用
a)        目的：利用前面调通的硬件基础，和几个函数的代码，进行串口的中断输入练习。因为在实际应用中，不使用中断进行的输入是效率非常低的，这种用法很少见，大部分串口的输入都离不开中断。
b)        初始化函数定义及函数调用：不用添加和调用初始化函数，在指定调试地址的时候已经调用过，在那个NVIC_Configuration里面添加相应开中断代码就行了。
c)        过程：
i.        在串口初始化中USART_Cmd之前加入中断设置：
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//TXE发送中断，TC传输完成中断，RXNE接收中断，PE奇偶错误中断，可以是多个。
ii.        RCC、GPIO里面打开串口相应的基本时钟、管脚设置
iii.        NVIC里面加入串口中断打开代码：
NVIC_InitTypeDef NVIC_InitStructure;//中断默认参数
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;//通道设置为串口1中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;   //中断占先等级0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;              //中断响应优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //打开中断
NVIC_Init(&NVIC_InitStructure);                                                //初始化
iv.        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数，在其中添入执行代码。一般最少三个步骤：先使用if语句判断是发生那个中断，然后清除中断标志位，最后给字符串赋值，或做其他事情。
void USART1_IRQHandler(void)                              //串口1中断
{
char RX_dat;                                                          //定义字符变量
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //判断发生接收中断
{USART_ClearITPendingBit(USART1,  USART_IT_RXNE);          //清除中断标志
GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)0x01);             //开始传输
RX_dat=USART_ReceiveData(USART1) & 0x7F;                       //接收数据，整理除去前两位
USART_SendData(USART1, RX_dat);                                       //发送数据
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}//等待发送结束
}
}
d)        中断注意事项：
可以随时在程序中使用USART_ITConfig(USART1, USART_IT_TXE, DISABLE);来关闭中断响应。
NVIC_InitTypeDef NVIC_InitStructure定义一定要加在NVIC初始化模块的第一句。
全局变量与函数的定义：在任意.c文件中定义的变量或函数，在其它.c文件中使用extern+定义代码再次定义就可以直接调用了。
STM32笔记之九：打断它来为我办事，EXIT (外部I/O中断)应用
a)        目的：跟串口输入类似，不使用中断进行的IO输入效率也很低，而且可以通过EXTI插入按钮事件，本节联系EXTI中断。
b)        初始化函数定义：
void EXTI_Configuration(void); //定义IO中断初始化函数
c)        初始化函数调用：
EXTI_Configuration();//IO中断初始化函数调用简单应用：
d)        初始化函数：
void EXTI_Configuration(void)
{
EXTI_InitTypeDef EXTI_InitStructure;        //EXTI初始化结构定义
EXTI_ClearITPendingBit(EXTI_LINE_KEY_BUTTON);//清除中断标志
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3);//管脚选择
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource4);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource6);
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//事件选择
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//触发模式
EXTI_InitStructure.EXTI_Line = EXTI_Line3 | EXTI_Line4; //线路选择
EXTI_InitStructure.EXTI_LineCmd = ENABLE;//启动中断
EXTI_Init(&EXTI_InitStructure);//初始化
}
e)        RCC初始化函数中开启I/O时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
GPIO初始化函数中定义输入I/O管脚。
//IO输入，GPIOA的4脚输入
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         //上拉输入
GPIO_Init(GPIOA, &GPIO_InitStructure);                //初始化
f)        在NVIC的初始化函数里面增加以下代码打开相关中断：
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;        //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//占先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                        //响应级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //启动
NVIC_Init(&NVIC_InitStructure);                                                                //初始化
g)        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数，在其中添入执行代码。一般最少三个步骤：先使用if语句判断是发生那个中断，然后清除中断标志位，最后给字符串赋值，或做其他事情。
if(EXTI_GetITStatus(EXTI_Line3) != RESET)                                  //判断中断发生来源
{ EXTI_ClearITPendingBit(EXTI_Line3);                                          //清除中断标志
USART_SendData(USART1, 0x41);                                              //发送字符“a”
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_2)));//LED发生明暗交替
}
h)        中断注意事项：
中断发生后必须清除中断位，否则会出现死循环不断发生这个中断。然后需要对中断类型进行判断再执行代码。
使用EXTI的I/O中断，在完成RCC与GPIO硬件设置之后需要做三件事：初始化EXTI、NVIC开中断、编写中断执行代码。
STM32笔记之十：工作工作，PWM输出
a)        目的：基础PWM输出，以及中断配合应用。输出选用PB1，配置为TIM3_CH4，是目标板的LED6控制脚。
b)        对于简单的PWM输出应用，暂时无需考虑TIM1的高级功能之区别。
c)        初始化函数定义：
void TIM_Configuration(void);  //定义TIM初始化函数
d)        初始化函数调用：
TIM_Configuration();  //TIM初始化函数调用
e)        初始化函数，不同于前面模块，TIM的初始化分为两部分——基本初始化和通道初始化：
void TIM_Configuration(void)//TIM初始化函数
{
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;//定时器初始化结构
TIM_OCInitTypeDef  TIM_OCInitStructure;//通道输出初始化结构
//TIM3初始化
TIM_TimeBaseStructure.TIM_Period = 0xFFFF;        //周期0～FFFF
TIM_TimeBaseStructure.TIM_Prescaler = 5;          //时钟分频
TIM_TimeBaseStructure.TIM_ClockDivision = 0;      //时钟分割
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);   //基本初始化
TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);//打开中断，中断需要这行代码
//TIM3通道初始化
TIM_OCStructInit(& TIM_OCInitStructure);                                                //默认参数
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                    //工作状态
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;         //设定为输出，需要PWM输出才需要这行代码
TIM_OCInitStructure.TIM_Pulse = 0x2000;                                 //占空长度
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;                 //高电平
TIM_OC4Init(TIM3, &TIM_OCInitStructure);                                 //通道初始化
TIM_Cmd(TIM3, ENABLE);                                                                        //启动TIM3
}
f)        RCC初始化函数中加入TIM时钟开启：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
g)        GPIO里面将输入和输出管脚模式进行设置。信号：AF_PP，50MHz。
h)        使用中断的话在NVIC里添加如下代码：
//打开TIM2中断
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;  //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;//占先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;           //响应级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         //启动
NVIC_Init(&NVIC_InitStructure);                                            //初始化
中断代码：
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)       //判断中断来源
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);            //清除中断标志
GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_11)));//变换LED色彩
IC4value = TIM_GetCapture4(TIM2);                   //获取捕捉数值
}
}
i)        简单应用：
//改变占空比
TIM_SetCompare4(TIM3, 变量);
j)        注意事项：
管脚的IO输出模式是根据应用来定，比如如果用PWM输出驱动LED则应该将相应管脚设为AF_PP，否则单片机没有输出。
STM32笔记之十一：捕捉精彩瞬间，脉冲方波长度捕获
a)        目的：基础PWM输入也叫捕获，以及中断配合应用。使用前一章的输出管脚PB1（19脚），直接使用跳线连接输入的PA3（13脚），配置为TIM2_CH4，进行实验。
b)        对于简单的PWM输入应用，暂时无需考虑TIM1的高级功能之区别，按照目前我的应用目标其实只需要采集高电平宽度，而不必知道周期，所以并不采用PWM输入模式，而是普通脉宽捕获模式。
c)        初始化函数定义：
void TIM_Configuration(void);  //定义TIM初始化函数
d)        初始化函数调用：
TIM_Configuration();  //TIM初始化函数调用
e)        初始化函数，不同于前面模块，TIM的CAP初始化分为三部分——计时器基本初始化、通道初始化和时钟启动初始化：
void TIM_Configuration(void)//TIM2的CAP初始化函数
{
TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;//定时器初始化结构
TIM_ICInitTypeDef TIM_ICInitStructure;         //通道输入初始化结构
//TIM2输出初始化
TIM_TimeBaseStructure.TIM_Period = 0xFFFF;     //周期0～FFFF
TIM_TimeBaseStructure.TIM_Prescaler = 5;       //时钟分频
TIM_TimeBaseStructure.TIM_ClockDivision = 0;   //时钟分割
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);//基本初始化
//TIM2通道的捕捉初始化
TIM_ICInitStructure.TIM_Channel = TIM_Channel_4;//通道选择
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;//下降沿
TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;//管脚与寄存器对应关系
TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;//分频器
TIM_ICInitStructure.TIM_ICFilter = 0x4;        //滤波设置，经历几个周期跳变认定波形稳定0x0～0xF
TIM_ICInit(TIM2, &TIM_ICInitStructure);        //初始化
TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2);   //选择时钟触发源
TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Reset);//触发方式
TIM_SelectMasterSlaveMode(TIM2, TIM_MasterSlaveMode_Enable); //启动定时器的被动触发
TIM_ITConfig(TIM2, TIM_IT_CC4, ENABLE);        //打开中断
TIM_Cmd(TIM2, ENABLE);                         //启动TIM2
}
f)        RCC初始化函数中加入TIM时钟开启：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
g)        GPIO里面将输入和输出管脚模式进行设置。IN_FLOATING，50MHz。
h)        使用中断的话在NVIC里添加如下代码：
//打开TIM中断（与前一章相同）
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
i)        简单应用：
变量 = TIM_GetCapture4(TIM2);
j)        注意事项：
i.        由于我的需求只跟高电平宽度有关，所以避免了使用PWM输入模式，这样可以每个管脚捕捉一路信号。如果使用PWM模式，每一路需要占用两个寄存器，所以一个定时器只能同时使用两路PWM输入。
ii.        由于捕捉需要触发启动定时器，所以PWM输出与捕捉不容易在同一个TIM通道上实现。如果必须的话只能增加计数溢出的相关代码。
iii.        有些程序省略了捕捉通道的初始化代码，这是不对的
iv.        在基本计时器初始化代码里面注意选择适当的计数器长度，最好让波形长度不要长于一个计数周期，否则需要增加溢出代码很麻烦。一个计数周期的长度计算跟如下几个参数有关：
（1）        RCC初始化代码里面的RCC_PCLKxConfig，这是TIM的基础时钟源与系统时钟的关系。
（2）        TIM初始化的TIM_Period，这是计数周期的值
（3）        TIM初始化的TIM_Prescaler，这是计数周期的倍频计数器，相当于调节计数周期，可以使TIM_Period尽量大，提高计数精度。
STM32笔记之十二：时钟不息工作不止，systic时钟应用
a)        目的：使用系统时钟来进行两项实验——周期执行代码与精确定时延迟。
b)        初始化函数定义：
void SysTick_Configuration(void);
c)        初始化函数调用：
SysTick_Configuration();
d)        初始化函数：
void SysTick_Configuration(void)
{
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);//时钟除8
SysTick_SetReload(250000);                                                    //计数周期长度
SysTick_CounterCmd(SysTick_Counter_Enable);                   //启动计时器
SysTick_ITConfig(ENABLE);                                                     //打开中断
}
e)        在NVIC的初始化函数里面增加以下代码打开相关中断：
NVIC_SystemHandlerPriorityConfig(SystemHandler_SysTick, 1, 0);//中断等级设置，一般设置的高一些会少受其他影响
f)        在stm32f10x_it.c文件中找到void SysTickHandler 函数
void SysTickHandler(void)
{
执行代码
}
g)        简单应用：精确延迟函数，因为systic中断往往被用来执行周期循环代码，所以一些例程中使用其中断的启动和禁止来编写的精确延时函数实际上不实用，我自己编写了精确计时函数反而代码更精简，思路更简单。思路是调用后，变量清零，然后使用时钟来的曾变量，不断比较变量与延迟的数值，相等则退出函数。代码和步骤如下：
i.        定义通用变量：u16 Tic_Val=0; //变量用于精确计时
ii.        在stm32f10x_it.c文件中相应定义：
extern u16 Tic_Val;//在本文件引用MAIN.c定义的精确计时变量
iii.        定义函数名称：void Tic_Delay(u16 Tic_Count);//精确延迟函数
iv.        精确延时函数：
void Tic_Delay(u16 Tic_Count)               //精确延时函数
{         Tic_Val=0;                           //变量清零
while(Tic_Val != Tic_Count){printf("");}//计时
}
v.        在stm32f10x_it.c文件中void SysTickHandler 函数里面添加
Tic_Val++;//变量递增
vi.        调用代码：Tic_Delay(10);   //精确延时
vii.                            疑问：如果去掉计时行那个没用的printf("");函数将停止工作，这个现象很奇怪
STM32笔记之十三：恶搞，两只看门狗
a)        目的：
了解两种看门狗（我叫它：系统运行故障探测器和独立系统故障探测器，新手往往被这个并不形象的象形名称搞糊涂）之间的区别和基本用法。
b)        相同：
都是用来探测系统故障，通过编写代码定时发送故障清零信号（高手们都管这个代码叫做“喂狗”），告诉它系统运行正常。一旦系统故障，程序清零代码（“喂狗”）无法执行，其计数器就会计数不止，直到记到零并发生故障中断（狗饿了开始叫唤），控制CPU重启整个系统（不行啦，开始咬人了，快跑……）。
c)        区别：
独立看门狗Iwdg——我的理解是独立于系统之外，因为有独立时钟，所以不受系统影响的系统故障探测器。（这条狗是借来的，见谁偷懒它都咬！）主要用于监视硬件错误。
窗口看门狗wwdg——我的理解是系统内部的故障探测器，时钟与系统相同。如果系统时钟不走了，这个狗也就失去作用了。（这条狗是老板娘养的，老板不干活儿他不管！）主要用于监视软件错误。
d)        初始化函数定义：鉴于两只狗作用差不多，使用过程也差不多初始化函数栓一起了，用的时候根据情况删减。
void WDG_Configuration(void);
e)        初始化函数调用：
WDG_Configuration();
f)        初始化函数
void WDG_Configuration()                //看门狗初始化
{
//软件看门狗初始化
WWDG_SetPrescaler(WWDG_Prescaler_8); //时钟8分频4ms
// (PCLK1/4096)/8= 244 Hz (~4 ms)
WWDG_SetWindowValue(65);                    //计数器数值
WWDG_Enable(127);                   //启动计数器，设置喂狗时间
// WWDG timeout = ~4 ms * 64 = 262 ms
WWDG_ClearFlag();                   //清除标志位
WWDG_EnableIT();                    //启动中断
//独立看门狗初始化
IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);//启动寄存器读写
IWDG_SetPrescaler(IWDG_Prescaler_32);//40K时钟32分频
IWDG_SetReload(349);                 //计数器数值
IWDG_ReloadCounter();                //重启计数器
IWDG_Enable();                       //启动看门狗
}
g)        RCC初始化：只有软件看门狗需要时钟初始化，独立看门狗有自己的时钟不需要但是需要systic工作相关设置。
RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
h)        独立看门狗使用systic的中断来喂狗，所以添加systic的中断打开代码就行了。软件看门狗需要在NVIC打开中断添加如下代码：
NVIC_InitStructure.NVIC_IRQChannel = WWDG_IRQChannel; //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先中断等级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;      //响应中断优先级
NVIC_Init(&NVIC_InitStructure);                        //打开中断
i)        中断程序，软件看门狗在自己的中断中喂狗，独立看门狗需要使用systic的定时中断来喂狗。以下两个程序都在stm32f10x_it.c文件中。
void WWDG_IRQHandler(void)
{
WWDG_SetCounter(0x7F);          //更新计数值
WWDG_ClearFlag();               //清除标志位
}
void SysTickHandler(void)
{  IWDG_ReloadCounter();         //重启计数器（喂狗）
}
j)        注意事项：
i.        有狗平常没事情可以不理，但是千万别忘了喂它，否则死都不知道怎么死的！
ii.        初始化程序的调用一定要在systic的初始化之后。
iii.        独立看门狗需要systic中断来喂，但是systic做别的用处不能只做这件事，所以我写了如下几句代码，可以不影响systic的其他应用，其他systic周期代码也可参考：
第一步：在stm32f10x_it.c中定义变量
int Tic_IWDG;           //喂狗循环程序的频率判断变量
第二步：将SysTickHandler中喂狗代码改为下面：
Tic_IWDG++;             //变量递增
if(Tic_IWDG>=100)       //每100个systic周期喂狗
{  IWDG_ReloadCounter();//重启计数器（喂狗）
Tic_IWDG=0;          //变量清零
}
STM32笔记之十四：基本问题，来讨论一下软件架构
网上大家都在讨论和学习，但是对于架构这个基本问题却没几个人讨论。个人认为有个好的架构是写好代码的基础，可以使后期的调式工作事半功倍！！
1、        架构组成：我的程序代码分为四种结构
a)        顺序执行代码
定义：按照顺序逐行执行的代码
优点：是思路简单，代码可靠不易被干扰。
缺点：占用资源
用途：只用来各种变量、函数的定义，硬件的初始化程序
位置：main.c的开始一直到main函数的while函数之前
b)        空闲执行代码
定义：在CPU空闲的时候才执行的代码
优点：不占用资源
缺点：执行的实时性不能保证
用途：非实时任务，调试信息输出，不重要的状态指示
位置：main.c的main函数的while函数内部
c)        中断执行代码
定义：由软硬件事件打断整个程序而执行的代码
优点：可以保证实时性，各种中断可以安排优先顺序
缺点：关系相对复杂，互相之间容易干扰
用途：触发性的代码，比如接收数据，响应外部设备，按钮的相应
位置：stm32f10x_it.c内部
d)        循环执行代码
定义：按照时间周期执行的代码
优点：定期自动执行
缺点：实时性不好
用途：需要周期执行的任务，状态检查及相关信息输出，数据记录
位置：stm32f10x_it.c的SysTickHandler内部
e)        DMA自动代码
定义：不需要主程序干预，外设自动执行
优点：自动刷新数据，不占用CPU资源
缺点：不能控制
用途：数据通信存储，AD转换
位置：不需要
2、架构执行顺序图
下载 (51.33 KB)
2009-4-22 15:39
STM32学习笔记之十五——IAR4的最后疯狂，笨笨的开发模板下载
准备大换血了，包括开发环境升级和固件升级，那个需要一定过程，吧之前完成的模板跟大家共享一下。
我的程序库特点：
a)        默认兼容ST-LINK-II，IAR EWARM 4.42A，Flash调试，使用串口1，GPIOA的3、4、
5、6脚输入，GPIOB的1、2、10、11脚输出，其他有可能需要更改设置
b)        为操作方便减少了目录的层次
c)        为学习方便使用网友汉化版2.0.2固件，主要是库函数中c代码的注释。
d)        加入必用的flash（读取优化），nvic（RAM与Flash调试选择），rcc（时钟管理模
板，开启外设时钟模板），gpio（管脚定义模板）的初始化代码，所有模板代码用到的
时候只要去掉前面的注释"//"，根据需求填入相应值就可以了。
e)        因为自己记性不好，所以main函数中的代码做到每行注释，便于自己以后使用。
f)        列出常见应用代码模板与ASCII常用列表。
g)        集成putchar字符输出和Printf的重定义到串口的代码，便于调试。
h)        集成NVIC中断管理模板，EXTI外部I/O中断模板
i)      针对自己情况集成PWM输出模板和CAP脉宽捕捉模板，并全部注释。
j)      集成系统循环时钟的初始化函数模板
k)      集成自己编写精确延时代码，不会影响systic的周期代码的执行。
l)      集成两种看门狗的使用代码，小心使用
M)      集成hex生成设置命令，位置在编译目录（STM32F103C8）的Exe下，集成ISP软件便
于脱离仿真器的串口调试STMISP.exe。
由于注释写的太多，还加入自己编程以来的许多格式习惯，所以许多人会觉得混乱不堪，在
此声明，此程序库仅仅为个人学习之用！
STM32学习笔记之十六——题外话，自己做块工程板
一、我的学习计划将STM32单片机的硬件设计工作：
第一步——用STM32F103CBT6的48脚芯片，为光电平台的简单控制为目标，实现基本外围硬件、PWM、串口、I/O。将SPI、I2C留插针。
第二步——为集成传感器应用为目标，在第一步硬件基础上制作功能性的套版，两板连接实现AD、SPI、I2C、RTC等等功能。
二、硬件规划
选用STM32F103CBT6，面积7×7mm，128K flash，16K RAM，4个16bit PWM，12个12bit PWM或CAP，2个SPI，2个I2C，3个串口，1个CAN，1个USB，），12ADC。
管脚分配目标1如图，之后的功能包括：4个AD，3个串口（1个与I2C复用），1个SPI，8个（两组）PWM输入输出，1个USB，1个I/O，1个MCO。
三、管脚分配：
下载 (32.83 KB)
2009-4-26 16:14
四、ALTIUM DESIGNER 6（Protel的第六个版本）操作笔记
之所以选择这个软件三个理由：1、界面习惯兼容Protel。2、操作习惯于Windows类似方便。3、可输出igs用于结构设计。
软件使用笔记如下：
a)        流程：新建工程，添加原理图，添加SCH库，画原理图，添加PCB库，设定封装，添加PCB，布线，检查，导出生产文件。
b)        新建工程：最好使用自己以前的同版本文档设置，会包含各种库省去大量工作
c)        添加器件到SCH，可使用复制粘贴的办法，注意管脚，有些需要外壳接地的器件把外壳的焊点画出来。完成后点击放置，改动后再器件名称点击右键更改。
d)        画原理图：操作类似其他windows软件，会自动检查错误连接和重复硬件。
e)        添加器件到PCB库，最好使用拷贝粘贴的办法，最好有官方的焊点图。没有的话可以按照封装的型号直接去http://www.***search.com/搜索封装型号（不是器件型号），也有封装的相关尺寸和焊点图。
f)        双击原理图的器件，在右下角改封装名称。
g)        添加新的PCB到工程：
“设计/规则”改线宽、线距、器件距离……；
“设计/板子形状/重新定义板子形状”改工作区域大小，然后左键点击前置Keepout层，画电路板外形；
“设计/板参数选项”改网格大小，器件和走线中鼠标捕捉的间隔大小……；
“设计/Import changes From……”引入原理图的器件和连接方式，包括改动（出现对match提示选择继续就可以了）；
“查看/切换单位”改公制和英制；
“工具/取消布线”取消已经布好的线；
“自动布线”计算机自动布线，功能比Protel增强不少；
“报告/测量距离”测量实际距离；
在层标签单击，前置这个层。右键有隐藏层和显示层比较常用。
屏幕中点击右键菜单中“设计/规则”、“选项/板参数选项”、 “选项/层叠管理”（添加和删除层）、“选项/显示掩藏”（针对各种类型进行显示和隐藏，查找未布的线就使用此功能后在操作框中点击“所有最终”然后点击“Apply”，再手工点击所有的选项为“隐藏的”再点“Apply”就能看到未布线的连线了）
快捷键：空格键旋转器件，TAB键切换线宽和放置过孔。左键单击选择，左键按住移动器件（多个重叠会有列表选择，未松开时右键取消操作），左键双击改器件属性（所在层、位置……），右键按住移动鼠标平移视野，滚轮上下移动，滚轮按住移动鼠标放大缩小
五、基本电路原理设计
抛弃复杂设计，专注于可独立调式的CPU板设计。计划设计模块包括：供电、JTAG、晶振、RTC（电池引出）。
注：未使用标准JTAG设计，原因有三：
1、原设计太占管脚，这个尺寸实在难实现
2、这只是CPU板具体应用会再做功能套版，上面可以连接标准JTAG
3、有可能向USB烧写和SW双线调式方向转变，所以以后不一定会使用标准JTAG
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/feiniao_lql/archive/2010/06/21/5684074.aspx
STM32 GPIO应用笔记
1           STM32的输入输出管脚有下面8种可能的配置：（4输入+2输出+2复用输出）
① 浮空输入_IN_FLOATING
② 带上拉输入_IPU
③ 带下拉输入_IPD
④ 模拟输入_AIN
⑤ 开漏输出_OUT_OD
⑥ 推挽输出_OUT_PP
⑦ 复用功能的推挽输出_AF_PP
⑧ 复用功能的开漏输出_AF_OD
1.1         I/O口的输出模式下，有3种输出速度可选(2MHz、10MHz和50MHz)，这个速度是指I/O口驱动电路的响应速度而不是输出信号的速度，输出信号的速度与程序有关（芯片内部在I/O口的输出部分安排了多个响应速度不同的输出驱动电路，用户可以根据自己的需要选择合适的驱动电路）。通过选择速度来选择不同的输出驱动模块，达到最佳的噪声控制和降低功耗的目的。高频的驱动电路，噪声也高，当不需要高的输出频率时，请选用低频驱动电路，这样非常有利于提高系统的EMI性能。当然如果要输出较高频率的信号，但却选用了较低频率的驱动模块，很可能会得到失真的输出信号。
关键是GPIO的引脚速度跟应用匹配（推荐10倍以上？）。比如：
1.1.1       对于串口，假如最大波特率只需115.2k，那么用2M的GPIO的引脚速度就够了，既省电也噪声小。
1.1.2       对于I2C接口，假如使用400k波特率，若想把余量留大些，那么用2M的GPIO的引脚速度或许不够，这时可以选用10M的GPIO引脚速度。
1.1.3       对于SPI接口，假如使用18M或9M波特率，用10M的GPIO的引脚速度显然不够了，需要选用50M的GPIO的引脚速度。
1.2         GPIO口设为输入时，输出驱动电路与端口是断开，所以输出速度配置无意义。
1.3         在复位期间和刚复位后，复用功能未开启，I/O端口被配置成浮空输入模式。
1.4         所有端口都有外部中断能力。为了使用外部中断线，端口必须配置成输入模式。
1.5         GPIO口的配置具有上锁功能，当配置好GPIO口后，可以通过程序锁住配置组合，直到下次芯片复位才能解锁。
2           在STM32中如何配置片内外设使用的IO端口
首先，一个外设经过 ①配置输入的时钟和 ②初始化后即被激活(开启)；③如果使用该外设的输入输出管脚，则需要配置相应的GPIO端口（否则该外设对应的输入输出管脚可以做普通GPIO管脚使用）；④再对外设进行详细配置。
对应到外设的输入输出功能有下述三种情况：
一、外设对应的管脚为输出：需要根据外围电路的配置选择对应的管脚为复用功能的推挽输出或复用功能的开漏输出。
二、外设对应的管脚为输入：则根据外围电路的配置可以选择浮空输入、带上拉输入或带下拉输入。
三、ADC对应的管脚：配置管脚为模拟输入。
如果把端口配置成复用输出功能，则引脚和输出寄存器断开，并和片上外设的输出信号连接。将管脚配置成复用输出功能后，如果外设没有被激活，那么它的输出将不确定。
3           通用IO端口（GPIO）初始化：
3.1            GPIO初始化
3.1.1       RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | B | C, ENABLE)：使能APB2总线外设时钟
3.1.2       RCC_ APB2PeriphResetCmd (RCC_APB2Periph_GPIOA | B | C, DISABLE)：释放GPIO复位
3.2            配置各个PIN端口（模拟输入_AIN、输入浮空_IN_FLOATING、输入上拉_IPU、输入下拉_IPD、开漏输出_OUT_OD、推挽式输出_OUT_PP、推挽式复用输出_AF_PP、开漏复用输出_AF_OD）
3.3            GPIO初始化完成
下面我就在做个抛砖引玉，根据ST手册上的内容，简单地综述一下GPIO的功能：
一、共有8种模式，可以通过编程选择：
1. 浮空输入
2. 带上拉输入
3. 带下拉输入
4. 模拟输入
5. 开漏输出——(此模式可实现hotpower说的真双向IO)
6. 推挽输出
7. 复用功能的推挽输出
8. 复用功能的开漏输出
模式7和模式8需根据具体的复用功能决定。
二、专门的寄存器(GPIOx_BSRR和GPIOx_BRR)实现对GPIO口的原子操作，即回避了设置或清除I/O端口时的“读-修改-写”操作，使得设置或清除I/O端口的操作不会被中断处理打断而造成误动作。
三、每个GPIO口都可以作为外部中断的输入，便于系统灵活设计。
四、I/O口的输出模式下，有3种输出速度可选(2MHz、10MHz和50MHz)，这有利于噪声控制。
五、所有I/O口兼容CMOS和TTL，多数I/O口兼容5V电平。
六、大电流驱动能力：GPIO口在高低电平分别为0.4V和VDD-0.4V时，可以提供或吸收8mA电流；如果把输入输出电平分别放宽到1.3V和VDD-1.3V时，可以提供或吸收20mA电流。
七、具有独立的唤醒I/O口。
八、很多I/O口的复用功能可以重新映射。
九、GPIO口的配置具有上锁功能，当配置好GPIO口后，可以通过程序锁住配置组合，直到下次芯片复位才能解锁。此功能非常有利于在程序跑飞的情况下保护系统中其他的设备，不会因为某些I/O口的配置被改变而损坏——如一个输入口变成输出口并输出电流。
STM32第一个例子
//**********************************************************************
// 作者：YYYtech
// 时间：2007/12/14
//***********************************************************************
/***********************************************************************
main文件，GPIO操作，完成最简单的IO操作实验，就是控制LED灯
4个LED分别对应PC的6、7、8、9引脚。4个LED流水显示
**************************************************************************/
#include "stm32f10x_lib.h"
GPIO_InitTypeDef GPIO_InitStructure;
void LED_Init(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
}
void LED_TurnOn(u8 led)
{
}
void Delay(vu32 nCount)
{
for(; nCount != 0; nCount--);
}
main()
{
//RCC_Configuration();
LED_Init();
while(1)
{
GPIO_SetBits(GPIOC, GPIO_Pin_9);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_9);
Delay(0x8ffff);
GPIO_SetBits(GPIOC, GPIO_Pin_10);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_10);
Delay(0x8ffff);
GPIO_SetBits(GPIOC, GPIO_Pin_11);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_11);
Delay(0x8ffff);
GPIO_SetBits(GPIOC, GPIO_Pin_12);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_12);
Delay(0x8ffff);
}
}
注意：在这里用到了RCC和GPIO的库函数，所以必须把这两个函数加入工程。
关于固件库函数在文件夹：C:\Keil\ARM\RV31\LIB\ST\STM32F10x
为了不在操作过程中避免改变KEIL文件夹下的库函数，可以固件函数库放到其他文件夹下，如：E:\jy\work\STM\WxlStm32\LAB\library
其中stm32f10x_lib.c文件是整个库的一些定义，是必须要的。
加入后的工程为：
GPIO库函数简单说明：
函数名称 功能描述
GPIO_DeInit 重新初始化外围设备GPIOx相关寄存器到它的默认复位值
GPIO_AFIODeInit 初始化交错功能(remap, event control和 EXTI 配置) 寄存器
GPIO_Init 根据GPIO_初始化结构指定的元素初始化外围设备GPIOx
GPIO_StructInit 填充GPIO_初始化结构（GPIO_InitStruct）内的元素为复位值
GPIO_ReadInputDataBit 读指定端口引脚输入数据
GPIO_ReadInputData 读指定端口输入数据
GPIO_ReadOtputDataBit 读指定端口引脚输出数据
GPIO_ReadOtputData 读指定端口输出数据
GPIO_SetBits 置1指定的端口引脚
GPIO_ResetBits 清0指定的端口引脚
GPIO_WriteBit 设置或清除选择的数据端口引脚
GPIO_Write 写指定数据到GPIOx端口寄存器
GPIO_ANAPinConfig 允许或禁止 GPIO 4 模拟输入模式
GPIO_PinLockConfig 锁定GPIO引脚寄存器
GPIO_EventOutputConfig 选择GPIO引脚作为事件输出
GPIO_EventOutputCmd 允许或禁止事件输出
GPIO_PinRemapConfig 改变指定引脚的影射
GPIO_EMIConfig 允许或禁止GPIO 8 和 9 的EMI 模式
拓展实验：
在上面LED灯流水显示的基础之上加上按键程序，首先来看看按键的原理图：
当然这个原理图也是相当之简单的，不用读解释了，唯一注意的是OK键与其他三个键的区别是按下为高电平，其余三个按下为低电平。
加入后的完整清单如下：
//**********************************************************************
// 作者：JingYong
// 时间：2008/4/24
//***********************************************************************
/***********************************************************************
GPIO操作，完成最简单的IO操作实验，用按键控制LED灯闪烁
**************************************************************************/
#include "stm32f10x_lib.h"
GPIO_InitTypeDef GPIO_InitStructure;
//键盘定义
#define    KEY_OK     GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define    KEY_DOWN    GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1)
#define    KEY_UP     GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2)
#define    KEY_ESC    GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_3)
//LED初始化
void LED_Init(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
}
//按键初始化
void KEY_Init (void)
{
GPIO_InitTypeDef gpio_init;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
gpio_init.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &gpio_init);
}
//延迟函数
void Delay(vu32 nCount)
{
for(; nCount != 0; nCount--);
}
//主函数
main()
{
//RCC_Configuration();
LED_Init();
KEY_Init ();
while(1)
{
if(!KEY_ESC)
{
while(!KEY_ESC) ;
GPIO_SetBits(GPIOC, GPIO_Pin_9);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_9);
Delay(0x8ffff);
}
else if(!KEY_UP)
{
while(!KEY_UP) ;
GPIO_SetBits(GPIOC, GPIO_Pin_10);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_10);
Delay(0x8ffff);
}
else if(!KEY_DOWN)
{
while(!KEY_DOWN) ;
GPIO_SetBits(GPIOC, GPIO_Pin_11);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_11);
Delay(0x8ffff);
}
else if(KEY_OK)
{
while(KEY_OK) ;
GPIO_SetBits(GPIOC, GPIO_Pin_12);
Delay(0x8ffff);
GPIO_ResetBits(GPIOC, GPIO_Pin_12);
Delay(0x8ffff);
}
}
}
该例子是按下不同的按键，闪烁对应的LED灯。
STM32的GPIO口的输出:开漏输出和推挽输出 收藏
推挽输出与开漏输出的区别:
>>推挽输出:可以输出高,低电平,连接数字器件
>>开漏输出:输出端相当于三极管的集电极. 要得到高电平状态需要上拉电阻才行. 适合于做电流型的驱动,其吸收电流的能力相对强(一般20ma以内).
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////          三极管的开漏输出有什么特性，和推挽是不是一回事，
问题：
很多芯片的供电电压不一样，有3.3v和5.0v，需要把几种IC的不同口连接在一起，是不是直接连接就可以了？实际上系统是应用在I2C上面。
简答：
1、部分3.3V器件有5V兼容性，可以利用这种容性直接连接
2、应用电压转换器件，如TPS76733就是5V输入，转换成3.3V、1A输出。
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
开漏电路特点及应用
在电路设计时我们常常遇到开漏（open drain）和开集（open collector）的概念。所谓开漏电路概念中提到的“漏”就是指MOSFET的漏极。同理，开集电路中的“集”就是指三极管的集电极。开漏电路就是指以MOSFET的漏极为输出的电路。一般的用法是会在漏极外部的电路添加上拉电阻。完整的开漏电路应该由开漏器件和开漏上拉电阻组成。
组成开漏形式的电路有以下几个特点：
1. 利用 外部电路的驱动能力，减少IC内部的驱动。当IC内部MOSFET导通时，驱动电流是从外部的VCC流经R pull-up ，MOSFET到GND。IC内部仅需很下的栅极驱动电流。如图1。
2. 可以将多个开漏输出的Pin，连接到一条线上。形成 “与逻辑” 关系。如图1，当PIN_A、PIN_B、PIN_C任意一个变低后，开漏线上的逻辑就为0了。这也是I2C，SMBus等总线判断总线占用状态的原理。
3. 可以利用改变上拉电源的电压，改变传输电平。如图2, IC的逻辑电平由电源Vcc1决定，而输出高电平则由Vcc2决定。这样我们就可以用低电平逻辑控制输出高电平逻辑了。
4. 开漏Pin不连接外部的上拉电阻，则只能输出低电平(因此对于经典的51单片机的P0口而言，要想做输入输出功能必须加外部上拉电阻，否则无法输出高电平逻辑)。
5. 标准的开漏脚一般只有输出的能力。添加其它的判断电路，才能具备双向输入、输出的能力。
应用中需注意：
1.   开漏和开集的原理类似，在许多应用中我们利用开集电路代替开漏电路。例如，某输入Pin要求由开漏电路驱动。则我们常见的驱动方式是利用一个三极管组成开集电路来驱动它，即方便又节省成本。如图3。
2. 上拉电阻R pull-up的 阻值 决定了 逻辑电平转换的沿的速度 。阻值越大，速度越低功耗越小。反之亦然。
Push-Pull输出就是一般所说的推挽输出，在CMOS电路里面应该较CMOS输出更合适，应为在CMOS里面的push－pull输出能力不可能做得双极那么大。输出能力看IC内部输出极N管P管的面积。和开漏输出相比，push－pull的高低电平由IC的电源低定，不能简单的做逻辑操作等。 push－pull是现在CMOS电路里面用得最多的输出级设计方式。
at91rm9200 GPIO 模拟I2C接口时注意！！
一.什么是OC、OD
集电极开路门(集电极开路 OC 或源极开路OD)
open-drain是漏极开路输出的意思，相当于集电极开路(open-collector)输出，即ttl中的集电极开路（oc）输出。一般用于线或、线与，也有的用于电流驱动。
open-drain是对mos管而言，open-collector是对双极型管而言，在用法上没啥区别。
开漏形式的电路有以下几个特点：
1.利用外部电路的驱动能力，减少IC内部的驱动。 或驱动比芯片电源电压高的负载.
2. 可以将多个开漏输出的Pin，连接到一条线上。通过一只上拉电阻，在不增加任何器件的情况下，形成“与逻辑”关系。这也是I2C，SMBus等总线判断总线占用状态的原理。如果作为图腾输出必须接上拉电阻。接容性负载时，下降延是芯片内的晶体管，是有源驱动，速度较快；上升延是无源的外接电阻，速度慢。如果要求速度高电阻选择要小，功耗会大。所以负载电阻的选择要兼顾功耗和速度。
3.可以利用改变上拉电源的电压，改变传输电平。例如加上上拉电阻就可以提供TTL/CMOS电平输出等。
4.开漏Pin不连接外部的上拉电阻，则只能输出低电平。一般来说，开漏是用来连接不同电平的器件，匹配电平用的。
5.正常的CMOS输出级是上、下两个管子，把上面的管子去掉就是OPEN-DRAIN了。这种输出的主要目的有两个：电平转换和线与。
6.由于漏级开路，所以后级电路必须接一上拉电阻，上拉电阻的电源电压就可以决定输出电平。这样你就可以进行任意电平的转换了。
7.线与功能主要用于有多个电路对同一信号进行拉低操作的场合，如果本电路不想拉低，就输出高电平，因为OPEN-DRAIN上面的管子被拿掉，高电平是靠外接的上拉电阻实现的。（而正常的CMOS输出级，如果出现一个输出为高另外一个为低时，等于电源短路。）
8.OPEN-DRAIN提供了灵活的输出方式，但是也有其弱点，就是带来上升沿的延时。因为上升沿是通过外接上拉无源电阻对负载充电，所以当电阻选择小时延时就小，但功耗大；反之延时大功耗小。所以如果对延时有要求，则建议用下降沿输出。
二.什么是线或逻辑与线与逻辑？
在一个结点(线)上, 连接一个上拉电阻到电源 VCC 或 VDD 和 n 个 NPN 或 NMOS 晶体管的集电极 C 或漏极 D, 这些晶体管的发射极 E 或源极 S 都接到地线上, 只要有一个晶体管饱和, 这个结点(线)就被拉到地线电平上.
因为这些晶体管的基极注入电流(NPN)或栅极加上高电平(NMOS), 晶体管就会饱和, 所以这些基极或栅极对这个结点(线)的关系是或非 NOR 逻辑. 如果这个结点后面加一个反相器, 就是或 OR 逻辑.
注：个人理解：线与，接上拉电阻至电源。(~A)&(~B)=~(A+B)，由公式较容易理解线与此概念的由来 ；
如果用下拉电阻和 PNP 或 PMOS 管就可以构成与非 NAND 逻辑, 或用负逻辑关系转换与/或逻辑.
注：线或，接下拉电阻至地。(~A)+(~B)=~(AB);
这些晶体管常常是一些逻辑电路的集电极开路 OC 或源极开路 OD 输出端. 这种逻辑通常称为线与/线或逻辑, 当你看到一些芯片的 OC 或 OD 输出端连在一起, 而有一个上拉电阻时, 这就是线或/线与了, 但有时上拉电阻做在芯片的输入端内.
顺便提示如果不是 OC 或 OD 芯片的输出端是不可以连在一起的, 总线 BUS 上的双向输出端连在一起是有管理的, 同时只能有一个作输出, 而其他是高阻态只能输入.
三.什么是推挽结构
一般是指两个三极管分别受两互补信号的控制,总是在一个三极管导通的时候另一个截止.要实现线与需要用OC(open collector)门电路 .如果输出级的有两个三极管，始终处于一个导通、一个截止的状态，也就是两个三级管推挽相连，这样的电路结构称为推拉式电路或图腾柱（Totem- pole）输出电路（可惜，图无法贴上）。当输出低电平时，也就是下级负载门输入低电平时，输出端的电流将是下级门灌入T4；当输出高电平时，也就是下级负载门输入高电平时，输出端的电流将是下级门从本级电源经 T3、D1 拉出。这样一来，输出高低电平时，T3 一路和 T4 一路将交替工作，从而减低了功耗，提高了每个管的承受能力。又由于不论走哪一路，管子导通电阻都很小，使RC常数很小，转变速度很快。因此，推拉式输出级既提高电路的负载能力，又提高开关速度。供你参考。
推挽电路是两个参数相同的三极管或MOSFET,以推挽方式存在于电路中,各负责正负半周的波形放大任务,电路工作时，两只对称的功率开关管每次只有一个导通，所以导通损耗小效率高。
输出既可以向负载灌电流，也可以从负载抽取电流
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/feiniao_lql/archive/2010/06/13/5668585.aspx
STM32时钟控制RCC
对于单片机系统来说，CPU和总线以及外设的时钟设置是非常重要的，因为没有时钟就没有时序，组合电路能干什么想必各位心里都清楚。其实时钟的学习这部分应该提前一些，但由于一开始时间比较短，有些急于求成，所以直接使用了万利给的例程，姑且跳过了这一步。介于下面我计划要学习的任务都涉及到兆级的高速传输，例如全速USB，DMA等等，所以不能再忽略时钟啦，必须要仔细研究一下。
我学习RCC的参考资料：
技术文档0427及其中文翻译版STM32F10xxx_Library_Manual_ChineseV2的第十五章和RM0008_CH参考手册。
准备知识：
片上总线标准种类繁多，而由ARM公司推出的AMBA片上总线受到了广大IP开发商和SoC系统集成者的青睐，已成为一种流行的工业标准片上结构。AMBA规范主要包括了AHB(Advanced High performance Bus)系统总线和APB(Advanced Peripheral Bus)外围总线。二者分别适用于高速与相对低速设备的连接。
由于时钟是一个由内而外的东西，具体设置要从寄存器开始。
RCC 寄存器结构，RCC_TypeDeff，在文件“stm32f10x_map.h”中定义如下：
typedef struct
{
vu32 CR;
vu32 CFGR;
vu32 CIR;
vu32 APB2RSTR;
vu32 APB1RSTR;
vu32 AHBENR;
vu32 APB2ENR;
vu32 APB1ENR;
vu32 BDCR;
vu32 CSR;
} RCC_TypeDef;
这些寄存器的具体定义和使用方式参见芯片手册，在此不赘述，因为C语言的开发可以不和他们直接打交道，当然如果能够加以理解和记忆，无疑是百利而无一害。
相信细心的朋友早就发现板子上只有8Mhz的晶振，而增强型最高工作频率为72Mhz，显然需要用PLL倍频9倍，这些设置都需要在初始化阶段完成。为了方便说明，我借用一下例程的RCC设置函数，并用中文注释的形式加以说明：
/*******************************************************************************
* Function Name : Set_System
* Description    : Configures Main system clocks & power
* Input          : None.
* Return         : None.
*******************************************************************************/
//在此指出上面的注释头应该是复制过来的，写错了...不过没关系，反正没参数需要说明，重要的是函数体。
static void RCC_Config(void)
{
/* 这里是重置了RCC的设置，类似寄存器复位 */
RCC_DeInit();
/* 使能外部高速晶振 */
RCC_HSEConfig(RCC_HSE_ON);
/* 等待高速晶振稳定 */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* 使能flash预读取缓冲区 */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* 令Flash处于等待状态，2是针对高频时钟的，这两句跟RCC没直接关系，可以暂且略过 */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK 设置高速总线时钟=系统时钟*/
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK 设置低速总线2时钟=高速总线时钟*/
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 设置低速总线1的时钟=高速时钟的二分频*/
RCC_PCLK1Config(RCC_HCLK_Div2);
/* ADCCLK = PCLK2/6 设置ADC外设时钟=低速总线2时钟的六分频*/
RCC_ADCCLKConfig(RCC_PCLK2_Div6);
/* Set PLL clock output to 72MHz using HSE (8MHz) as entry clock */
//上面这句例程中缺失了，但却很关键
/* 利用锁相环讲外部8Mhz晶振9倍频到72Mhz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
/* Enable PLL 使能锁相环*/
RCC_PLLCmd(ENABLE);
/* Wait till PLL is ready 等待锁相环输出稳定*/
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{}
/* Select PLL as system clock source 将锁相环输出设置为系统时钟 */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source 等待校验成功*/
while (RCC_GetSYSCLKSource() != 0x08)
{}
}
/* Enable FSMC, GPIOD, GPIOE, GPIOF, GPIOG and AFIO clocks */
//使能外围接口总线时钟，注意各外设的隶属情况，不同芯片的分配不同，到时候查手册就可以
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE |
RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG |
RCC_APB2Periph_AFIO, ENABLE);
}
由上述程序可以看出系统时钟的设定是比较复杂的，外设越多，需要考虑的因素就越多。同时这种设定也是有规律可循的，设定参数也是有顺序规范的，这是应用中应当注意的，例如PLL的设定需要在使能之前，一旦PLL使能后参数不可更改。
经过此番设置后，由于我的电路板上是8Mhz晶振，所以系统时钟为72Mhz，高速总线和低速总线2都为72Mhz，低速总线1为36Mhz，ADC时钟为12Mhz，USB时钟经过1.5分频设置就可以实现48Mhz的数据传输。
一般性的时钟设置需要先考虑系统时钟的来源，是内部RC还是外部晶振还是外部的振荡器，是否需要PLL。然后考虑内部总线和外部总线，最后考虑外设的时钟信号。遵从先倍频作为CPU时钟，然后在由内向外分频，下级迁就上级的原则有点儿类似PCB制图的规范化要求，在这里也一样。

(原文件名:STM32系统时钟框图.gif) 引用图片
STM32的时钟系统分析
在STM32中，有五个时钟源，为HSI、HSE、LSI、LSE、PLL。
①、HSI是高速内部时钟，RC振荡器，频率为8MHz。
②、HSE是高速外部时钟，可接石英/陶瓷谐振器，或者接外部时钟源，频率范围为4MHz~16MHz。
③、LSI是低速内部时钟，RC振荡器，频率为40kHz。
④、LSE是低速外部时钟，接频率为32.768kHz的石英晶体。
⑤、PLL为锁相环倍频输出，其时钟输入源可选择为HSI/2、HSE或者HSE/2。倍频可选择为2~16倍，但是其输出频率最大不得超过72MHz。
其中40kHz的LSI供独立看门狗IWDG使用，另外它还可以被选择为实时时钟RTC的时钟源。另外，实时时钟RTC的时钟源还可以选择LSE，或者是HSE的128分频。RTC的时钟源通过RTCSEL[1:0]来选择。
STM32中有一个全速功能的USB模块，其串行接口引擎需要一个频率为48MHz的时钟源。该时钟源只能从PLL输出端获取，可以选择为1.5分频或者1分频，也就是，当需要使用USB模块时，PLL必须使能，并且时钟频率配置为48MHz或72MHz。
另外，STM32还可以选择一个时钟信号输出到MCO脚(PA8)上，可以选择为PLL输出的2分频、HSI、HSE、或者系统时钟。
系统时钟SYSCLK，它是供STM32中绝大部分部件工作的时钟源。系统时钟可选择为PLL输出、HSI或者HSE。系统时钟最大频率为72MHz，它通过AHB分频器分频后送给各模块使用，AHB分频器可选择1、2、4、8、16、64、128、256、512分频。其中AHB分频器输出的时钟送给5大模块使用：
①、送给AHB总线、内核、内存和DMA使用的HCLK时钟。
②、通过8分频后送给Cortex的系统定时器时钟。
③、直接送给Cortex的空闲运行时钟FCLK。
④、送给APB1分频器。APB1分频器可选择1、2、4、8、16分频，其输出一路供APB1外设使用(PCLK1，最大频率36MHz)，另一路送给定时器(Timer)2、3、4倍频器使用。该倍频器可选择1或者2倍频，时钟输出供定时器2、3、4使用。
⑤、送给APB2分频器。APB2分频器可选择1、2、4、8、16分频，其输出一路供APB2外设使用(PCLK2，最大频率72MHz)，另一路送给定时器(Timer)1倍频器使用。该倍频器可选择1或者2倍频，时钟输出供定时器1使用。另外，APB2分频器还有一路输出供ADC分频器使用，分频后送给ADC模块使用。ADC分频器可选择为2、4、6、8分频。
在以上的时钟输出中，有很多是带使能控制的，例如AHB总线时钟、内核时钟、各种APB1外设、APB2外设等等。当需要使用某模块时，记得一定要先使能对应的时钟。
需要注意的是定时器的倍频器，当APB的分频为1时，它的倍频值为1，否则它的倍频值就为2。
连接在APB1(低速外设)上的设备有：电源接口、备份接口、CAN、USB、I2C1、I2C2、UART2、UART3、SPI2、窗口看门狗、Timer2、Timer3、Timer4。注意USB模块虽然需要一个单独的48MHz时钟信号，但它应该不是供USB模块工作的时钟，而只是提供给串行接口引擎(SIE)使用的时钟。USB模块工作的时钟应该是由APB1提供的。
连接在APB2(高速外设)上的设备有：UART1、SPI1、Timer1、ADC1、ADC2、所有普通IO口(PA~PE)、第二功能IO口。
/*******************************************************************************
* Function Name : RCC_Configuration
* Description    : Configures the different system clocks.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void RCC_Configuration(void)
{
ErrorStatus HSEStartUpStatus;
/* RCC system reset(for debug purpose) */
// RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if(HSEStartUpStatus == SUCCESS)
{
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* ADCCLK = PCLK2/6 */
RCC_ADCCLKConfig(RCC_PCLK2_Div6);
/* Flash 2 wait state */
FLASH_SetLatency(FLASH_Latency_2);
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* PLLCLK = 8MHz * 9 = 72 MHz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);//Pll在最后设置
/* Enable PLL */
RCC_PLLCmd(ENABLE);
/* Wait till PLL is ready */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while(RCC_GetSYSCLKSource() != 0x08)
{
}
}
/* Enable GPIOA, GPIOB, GPIOC, GPIOD, GPIOE and AFIO clocks */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |RCC_APB2Periph_GPIOC
| RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE | RCC_APB2Periph_AFIO, ENABLE);
/* TIM2 clocks enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
/* CAN Periph clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN, ENABLE);
}
STM32的学习心得之TIMx（通用定时器）
基本的配置定时器的基本设置
1、TIM_TimeBaseStructure.TIM_Prescaler = 0x0;//时钟预分频数 例如：时钟频率=72/(时钟预分频+1)
2、TIM_TimeBaseStructure.TIM_CounterMode = TIM1_CounterMode_Up; //定时器模式 向上计数
3、TIM_TimeBaseStructure.TIM_Period = 0xFFFF; // 自动重装载寄存器周期的值(定时时间) 累计 0xFFFF个频率后产生个更新或者中断(也是说定时时间到)
4、TIM_TimeBaseStructure.TIM_ClockDivision = 0x0; //时间分割值
5、TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);//初始化定时器2
6、TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); //打开中断 溢出中断
7、TIM_Cmd(TIM2, ENABLE);//打开定时器
此外要记住一定要打开定时器的时钟(RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);),定时器的频率的可以编程的，有对应的模式设置和中断处理。
STM32学习笔记之 串口通讯
主要功能是把PC机发送的数据接收后再返回给PC机参数9600,8,1,N。
/************************************************************************
Copyright (c) 2008 wormchen
All rights reserved
文 件 名: main.c
说    明: 串口发送接收数据 将PC端发来的数据返回给PC
主要硬件: EMSTM32V1+miniSTMV100(外部8MRC)
编译环境: MDK3.10
当前版本: 1.0
************************************************************************/
#include
void RCC_Config(void);
void GPIO_Config(void);
void USART_Config(void);
void Put_String(u8 *p);
int main(void)
{
RCC_Config();
GPIO_Config();
USART_Config();
Put_String("\r\n请发送数据_\r\n");
while(1)
{
while(1)
{
if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == SET)
{
USART_SendData(USART2, USART_ReceiveData(USART2));
}
}
}
}
/*************************************************
函数: void RCC_Config(void)
功能: 配置系统时钟
参数: 无
返回: 无
**************************************************/
void RCC_Config(void)
{
ErrorStatus HSEStartUpStatus;//定义外部高速晶体启动状态枚举变量
RCC_DeInit();//复位RCC外部设备寄存器到默认值
RCC_HSEConfig(RCC_HSE_ON); //打开外部高速晶振
HSEStartUpStatus = RCC_WaitForHSEStartUp();//等待外部高速时钟准备好
if(HSEStartUpStatus == SUCCESS)//外部高速时钟已经准别好
{
RCC_HCLKConfig(RCC_SYSCLK_Div1);//配置AHB(HCLK)时钟等于==SYSCLK
RCC_PCLK2Config(RCC_HCLK_Div1); //配置APB2(PCLK2)钟==AHB时钟
RCC_PCLK1Config(RCC_HCLK_Div2);//配置APB1(PCLK1)钟==AHB1/2时钟
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
//配置PLL时钟 == 外部高速晶体时钟*9
RCC_PLLCmd(ENABLE);//使能PLL时钟
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) //等待PLL时钟就绪
{
}
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);//配置系统时钟 = PLL时钟
while(RCC_GetSYSCLKSource() != 0x08) //检查PLL时钟是否作为系统时钟
{
}
}
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_AFIO, ENABLE);
//打开GPIOD和AFIO时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);//使能串口2时钟
}
/*************************************************
函数: void GPIO_Config(void）
功能: GPIO配置
参数: 无
返回: 无
**************************************************/
void GPIO_Config(void)
{
//设置RTS(PD.04),Tx(PD.05)为推拉输出模式
GPIO_InitTypeDef GPIO_InitStructure; //定义GPIO初始化结构体
GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);//使能GPIO端口映射USART2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5;//选择PIN4 PIN5
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //引脚频率50M
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//引脚设置推拉输出
GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化GPIOD
//配置CTS (PD.03),USART2 Rx (PD.06)为浮点输入模式
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOD, &GPIO_InitStructure);
}
/*************************************************
函数: void USART_Config(void)
功能: USART配置
参数: 无
返回: 无
**************************************************/
void USART_Config(void)
{
USART_InitTypeDef USART_InitStructure; //定义串口初始化结构体
USART_InitStructure.USART_BaudRate = 9600;//波特率9600
USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据
USART_InitStructure.USART_StopBits = USART_StopBits_1;//1个停止位
USART_InitStructure.USART_Parity = USART_Parity_No ; //无校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//禁用RTSCTS硬件流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//使能发送接收
USART_InitStructure.USART_Clock = USART_Clock_Disable; //串口时钟禁止
USART_InitStructure.USART_CPOL = USART_CPOL_Low; //时钟下降沿有效
USART_InitStructure.USART_CPHA = USART_CPHA_2Edge;//数据在第二个时钟沿捕捉
USART_InitStructure.USART_LastBit = USART_LastBit_Disable;
//最后数据位的时钟脉冲不输出到SCLK引脚
USART_Init(USART2, &USART_InitStructure);//初始化串口2
USART_Cmd(USART2, ENABLE);//串口2使能
}
/*************************************************
函数: void Put_String(void)
功能: 向串口输出字符串
参数: 无
返回: 无
**************************************************/
void Put_String(u8 *p)
{
while(*p)
{
USART_SendData(USART2, *p++);
while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET)
{
}
}
}
基于STM32的PWM输出
) 初始化函数定义：
void TIM_Configuration(void);   //定义TIM初始化函数
d) 初始化函数调用：
TIM_Configuration();   //TIM初始化函数调用
e) 初始化函数，不同于前面模块，TIM的初始化分为两部分——基本初始化和通道初始化：
void TIM_Configuration(void)//TIM初始化函数
{
TIM_TimeBaseInitTypeDef   TIM_TimeBaseStructure;//定时器初始化结构
TIM_OCInitTypeDef   TIM_OCInitStructure;//通道输出初始化结构
//TIM3初始化
TIM_TimeBaseStructure.TIM_Period = 0xFFFF;        //周期0～FFFF
TIM_TimeBaseStructure.TIM_Prescaler = 5;       //时钟分频
TIM_TimeBaseStructure.TIM_ClockDivision = 0;    //时钟分割
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //基本初始化
TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);//打开中断，中断需要这行代码
//TIM3通道初始化
TIM_OCStructInit(& TIM_OCInitStructure);                                              //默认参数
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                    //工作状态
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;       //设定为输出，需要PWM输出才需要这行代码
TIM_OCInitStructure.TIM_Pulse = 0x2000;                   //占空长度
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;                 //高电平
TIM_OC4Init(TIM3, &TIM_OCInitStructure);                   //通道初始化
TIM_Cmd(TIM3, ENABLE);                                                                      //启动TIM3
}
f) RCC初始化函数中加入TIM时钟开启：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
g) GPIO里面将输入和输出管脚模式进行设置。信号：AF_PP，50MHz。
h) 使用中断的话在NVIC里添加如下代码：
//打开TIM2中断
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;   //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;//占先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;           //响应级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       //启动
NVIC_Init(&NVIC_InitStructure);                                            //初始化
中断代码：
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)    //判断中断来源
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);          //清除中断标志
GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_11)));//变换LED色彩
IC4value = TIM_GetCapture4(TIM2);                //获取捕捉数值
}
}
i) 简单应用：
//改变占空比
TIM_SetCompare4(TIM3, 变量);
j) 注意事项：
管脚的IO输出模式是根据应用来定，比如如果用PWM输出驱动LED则应该将相应管脚设为AF_PP，否则单片机没有输出。
STM32资料一（转载）
注：下面是一些常用的代码，网上很多但是大多注释不全。高手看没问题，对于我们这些新手就费劲了……所以我把这些代码集中，进行了逐句注释，希望对新手们有价值。
flash： 芯片内部存储器flash操作函数
我的理解——对芯片内部flash进行操作的函数，包括读取，状态，擦除，写入等等，可以允许程序去操作flash上的数据。
基础应用1，FLASH时序延迟几个周期，等待总线同步操作。推荐按照单片机系统运行频率，0—24MHz时，取Latency=0；24—48MHz时，取Latency=1；48~72MHz时，取Latency=2。所有程序中必须的
用法：FLASH_SetLatency(FLASH_Latency_2);
位置：RCC初始化子函数里面，时钟起振之后。
基础应用2，开启FLASH预读缓冲功能，加速FLASH的读取。所有程序中必须的
用法：FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
位置：RCC初始化子函数里面，时钟起振之后。
3、         lib：调试所有外设初始化的函数。
我的理解——不理解，也不需要理解。只要知道所有外设在调试的时候，EWRAM需要从这个函数里面获得调试所需信息的地址或者指针之类的信息。
基础应用1，只有一个函数debug。所有程序中必须的。
用法：        #ifdef DEBUG
debug();
#endif
位置：main函数开头，声明变量之后。
4、         nvic：系统中断管理。
我的理解——管理系统内部的中断，负责打开和关闭中断。
基础应用1，中断的初始化函数，包括设置中断向量表位置，和开启所需的中断两部分。所有程序中必须的。
用法：        void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;                   //中断管理恢复默认参数
#ifdef   VECT_TAB_RAM   //如果C/C++ Compiler\Preprocessor\Defined symbols中的定义了VECT_TAB_RAM（见程序库更改内容的表格）
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); //则在RAM调试
#else                                                                   //如果没有定义VECT_TAB_RAM
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);//则在Flash里调试
#endif                                                                   //结束判断语句
//以下为中断的开启过程，不是所有程序必须的。
//NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//设置NVIC优先级分组，方式。
//注：一共16个优先级，分为抢占式和响应式。两种优先级所占的数量由此代码确定，NVIC_PriorityGroup_x可以是0、1、2、3、4，分别代表抢占优先级有1、2、4、8、16个和响应优先级有16、8、4、2、1个。规定两种优先级的数量后，所有的中断级别必须在其中选择，抢占级别高的会打断其他中断优先执行，而响应级别高的会在其他中断执行完优先执行。
//NVIC_InitStructure.NVIC_IRQChannel = 中断通道名; //开中断，中断名称见函数库
//NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级
//NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //响应优先级
//NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //启动此通道的中断
//NVIC_Init(&NVIC_InitStructure);                                     //中断初始化
}
5、         rcc：单片机时钟管理。
我的理解——管理外部、内部和外设的时钟，设置、打开和关闭这些时钟。
基础应用1：时钟的初始化函数过程——
用法：void RCC_Configuration(void)                                //时钟初始化函数
{
ErrorStatus HSEStartUpStatus;                                     //等待时钟的稳定
RCC_DeInit();                                                                //时钟管理重置
RCC_HSEConfig(RCC_HSE_ON);                                  //打开外部晶振
HSEStartUpStatus = RCC_WaitForHSEStartUp();          //等待外部晶振就绪
if (HSEStartUpStatus == SUCCESS)
{
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
//flash读取缓冲，加速
FLASH_SetLatency(FLASH_Latency_2);                      //flash操作的延时
RCC_HCLKConfig(RCC_SYSCLK_Div1);                       //AHB使用系统时钟
RCC_PCLK2Config(RCC_HCLK_Div2);                          //APB2（高速）为HCLK的一半
RCC_PCLK1Config(RCC_HCLK_Div2);                          //APB1（低速）为HCLK的一半
//注：AHB主要负责外部存储器时钟。PB2负责AD，I/O，高级TIM，串口1。APB1负责DA，USB，SPI，I2C，CAN，串口2345，普通TIM。
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); //PLLCLK = 8MHz * 9 = 72 MH
RCC_PLLCmd(ENABLE);                                              //启动PLL
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){}     //等待PLL启动
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); //将PLL设置为系统时钟源
while (RCC_GetSYSCLKSource() != 0x08){}     //等待系统时钟源的启动
}
//RCC_AHBPeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE); //启动AHP设备
//RCC_APB2PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE);//启动ABP2设备
//RCC_APB1PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE); //启动ABP1设备
}
6、        exti：外部设备中断函数
我的理解——外部设备通过引脚给出的硬件中断，也可以产生软件中断，19个上升、下降或都触发。EXTI0～EXTI15连接到管脚，EXTI线16连接到PVD（VDD监视），EXTI线17连接到RTC（闹钟），EXTI线18连接到USB（唤醒）。
基础应用1，设定外部中断初始化函数。按需求，不是必须代码。
用法： void EXTI_Configuration(void)
{
EXTI_InitTypeDef EXTI_InitStructure;                               //外部设备中断恢复默认参数
EXTI_InitStructure.EXTI_Line = 通道1|通道2; //设定所需产生外部中断的通道，一共19个。
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;     //产生中断
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //上升下降沿都触发
EXTI_InitStructure.EXTI_LineCmd = ENABLE;             //启动中断的接收
EXTI_Init(&EXTI_InitStructure);             //外部设备中断启动
}
7、        dma：通过总线而越过CPU读取外设数据
我的理解——通过DMA应用可以加速单片机外设、存储器之间的数据传输，并在传输期间不影响CPU进行其他事情。这对于入门开发基本功能来说没有太大必要，这个内容先行跳过。
8、        systic：系统定时器
我的理解——可以输出和利用系统时钟的计数、状态。
基础应用1，精确计时的延时子函数。推荐使用的代码。
用法：
static vu32 TimingDelay;                                                                               //全局变量声明
void SysTick_Config(void)                                                                            //systick初始化函数
{
SysTick_CounterCmd(SysTick_Counter_Disable);                                  //停止系统定时器
SysTick_ITConfig(DISABLE); //停止systick中断
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //systick使用HCLK作为时钟源，频率值除以8。
SysTick_SetReload(9000);                                                                       //重置时间1毫秒（以72MHz为基础计算）
SysTick_ITConfig(ENABLE);                                                                   //开启systic中断
}
void Delay (u32 nTime)                                                                                   //延迟一毫秒的函数
{
SysTick_CounterCmd(SysTick_Counter_Enable);                      //systic开始计时
TimingDelay = nTime;                      //计时长度赋值给递减变量
while(TimingDelay != 0); //检测是否计时完成
SysTick_CounterCmd(SysTick_Counter_Disable);                                       //关闭计数器
SysTick_CounterCmd(SysTick_Counter_Clear);                      //清除计数值
}
void TimingDelay_Decrement(void) //递减变量函数，函数名由“stm32f10x_it.c”中的中断响应函数定义好了。
{
if (TimingDelay != 0x00) //检测计数变量是否达到0
{ TimingDelay--; //计数变量递减
}
}
注：建议熟练后使用，所涉及知识和设备太多，新手出错的可能性比较大。新手可用简化的延时函数代替：
void Delay(vu32 nCount)                                                                               //简单延时函数
{
for(; nCount != 0; nCount--);                                                                          //循环变量递减计数
}
当延时较长，又不需要精确计时的时候可以使用嵌套循环：
void Delay(vu32 nCount)                      //简单的长时间延时函数
{int i; //声明内部递减变量
for(; nCount != 0; nCount--)                                                             //递减变量计数
{for (i=0; i<0xffff; i++)}                                                                                  //内部循环递减变量计数
}
9、        gpio：I/O设置函数
我的理解——所有输入输出管脚模式设置，可以是上下拉、浮空、开漏、模拟、推挽模式，频率特性为2M，10M，50M。也可以向该管脚直接写入数据和读取数据。
基础应用1，gpio初始化函数。所有程序必须。
用法：void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;                      //GPIO状态恢复默认参数
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_标号 | GPIO_Pin_标号 ; //管脚位置定义，标号可以是NONE、ALL、0至15。
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;//输出速度2MHz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; //模拟输入模式
GPIO_Init(GPIOC, &GPIO_InitStructure); //C组GPIO初始化
//注：以上四行代码为一组，每组GPIO属性必须相同，默认的GPIO参数为：ALL，2MHz，FLATING。如果其中任意一行与前一组相应设置相同，那么那一行可以省略，由此推论如果前面已经将此行参数设定为默认参数（包括使用GPIO_InitTypeDef GPIO_InitStructure代码），本组应用也是默认参数的话，那么也可以省略。以下重复这个过程直到所有应用的管脚全部被定义完毕。
……
}
基础应用2，向管脚写入0或1
用法：GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);    //写入1
基础应用3，从管脚读入0或1
用法：GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6)
让它跑起来，基本硬件功能的建立
0、 实验之前的准备
a) 接通串口转接器
b) 下载IO与串口的原厂程序，编译通过保证调试所需硬件正常。
1、 flash，lib，nvic，rcc和GPIO，基础程序库编写
a) 这几个库函数中有一些函数是关于芯片的初始化的，每个程序中必用。为保障程序品质，初学阶段要求严格遵守官方习惯。注意，官方程序库例程中有个platform_config.h文件，是专门用来指定同类外设中第几号外设被使用，就是说在main.c里面所有外设序号用x代替，比如USARTx，程序会到这个头文件中去查找到底是用那些外设，初学的时候参考例程别被这个所迷惑住。
b) 全部必用代码取自库函数所带例程，并增加逐句注释。
c) 习惯顺序——Lib（debug），RCC（包括Flash优化），NVIC，GPIO
d) 必用模块初始化函数的定义：
void RCC_Configuration(void); //定义时钟初始化函数
void GPIO_Configuration(void); //定义管脚初始化函数
void NVIC_Configuration(void); //定义中断管理初始化函数
void Delay(vu32 nCount); //定义延迟函数
e) Main中的初始化函数调用：
RCC_Configuration(); //时钟初始化函数调用
NVIC_Configuration(); //中断初始化函数调用
GPIO_Configuration(); //管脚初始化函数调用
f) Lib注意事项：
属于Lib的Debug函数的调用，应该放在main函数最开始，不要改变其位置。
g) RCC注意事项：
Flash优化处理可以不做，但是两句也不难也不用改参数……
根据需要开启设备时钟可以节省电能
时钟频率需要根据实际情况设置参数
h) NVIC注意事项
注意理解占先优先级和响应优先级的分组的概念
i) GPIO注意事项
注意以后的过程中收集不同管脚应用对应的频率和模式的设置。
作为高低电平的I/O，所需设置：RCC初始化里面打开RCC_APB2
PeriphClockCmd(RCC_APB2Periph_GPIOA);GPIO里面管脚设定：IO输出（50MHz，Out_PP）；IO输入（50MHz，IPU）；
j) GPIO应用
GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_RESET);//重置
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) ;//读入IO
k) 简单Delay函数
void Delay(vu32 nCount)//简单延时函数
{for(; nCount != 0; nCount--);}
实验步骤：
RCC初始化函数里添加：RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB , ENABLE);
不用其他中断，NVIC初始化函数不用改
GPIO初始化代码：
//IO输入，GPIOB的2、10、11脚输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;//管脚号
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //输出速度
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //输入输出模式
GPIO_Init(GPIOB, &GPIO_InitStructure);              //初始化
简单的延迟函数：
void Delay(vu32 nCount)                   //简单延时函数
{ for (; nCount != 0; nCount--);}           //循环计数延时
完成之后再在main.c的while里面写一段：
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
Delay（0xffff）;
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
Delay（0xffff）;
就可以看到连接在PB2脚上的LED闪烁了，单片机就跑起来了。
STM32笔记之八：来跟PC打个招呼，基本串口通讯
a) 目的：在基础实验成功的基础上，对串口的调试方法进行实践。硬件代码顺利完成之后，对日后调试需要用到的printf重定义进行调试，固定在自己的库函数中。
b) 初始化函数定义：
void USART_Configuration(void);        //定义串口初始化函数
c) 初始化函数调用：
void UART_Configuration(void); //串口初始化函数调用
初始化代码：
void USART_Configuration(void)                      //串口初始化函数
{
//串口参数初始化
USART_InitTypeDef USART_InitStructure;              //串口设置恢复默认参数
//初始化参数设置
USART_InitStructure.USART_BaudRate = 9600;                                  //波特率9600
USART_InitStructure.USART_WordLength = USART_WordLength_8b; //字长8位
USART_InitStructure.USART_StopBits = USART_StopBits_1;                 //1位停止字节
USART_InitStructure.USART_Parity = USART_Parity_No;                   //无奇偶校验
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//打开Rx接收和Tx发送功能
USART_Init(USART1, &USART_InitStructure);                                         //初始化
USART_Cmd(USART1, ENABLE);                                                       //启动串口
}
RCC中打开相应串口
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
GPIO里面设定相应串口管脚模式
//串口1的管脚初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                      //管脚9
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure);                            //TX初始化
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                    //管脚10
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure);                             //RX初始化
d) 简单应用：
发送一位字符
USART_SendData(USART1, 数据); //发送一位数据
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待发送完毕
接收一位字符
while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET){} //等待接收完毕
变量= (USART_ReceiveData(USART1)); //接受一个字节
发送一个字符串
先定义字符串：char rx_data[250];
然后在需要发送的地方添加如下代码
int i;                                                                   //定义循环变量
while(rx_data!='\0')                                        //循环逐字输出，到结束字'\0'
{USART_SendData(USART1, rx_data);          //发送字符
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待字符发送完毕
i++;}
e) USART注意事项：
发动和接受都需要配合标志等待。
只能对一个字节操作，对字符串等大量数据操作需要写函数
使用串口所需设置：RCC初始化里面打开RCC_APB2PeriphClockCmd
(RCC_APB2Periph_USARTx);GPIO里面管脚设定：串口RX（50Hz，IN_FLOATING）；串口TX（50Hz，AF_PP）；
f) printf函数重定义（不必理解，调试通过以备后用）
（1） 需要c标准函数：
#include "stdio.h"
（2） 粘贴函数定义代码
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)   //定义为putchar应用
（3） RCC中打开相应串口
（4） GPIO里面设定相应串口管脚模式
（6） 增加为putchar函数。
int putchar(int c)                                           //putchar函数
{
if (c == '\n'){putchar('\r');}                                //将printf的\n变成\r
USART_SendData(USART1, c);                                  //发送字符
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待发送结束
return c;                                                     //返回值
}
（8） 通过，试验成功。printf使用变量输出:%c字符，%d整数，%f浮点数,%s字符串，/n或/r为换行。注意：只能用于main.c中。
3、 NVIC串口中断的应用
a) 目的：利用前面调通的硬件基础，和几个函数的代码，进行串口的中断输入练习。因为在实际应用中，不使用中断进行的输入是效率非常低的，这种用法很少见，大部分串口的输入都离不开中断。
b) 初始化函数定义及函数调用：不用添加和调用初始化函数，在指定调试地址的时候已经调用过，在那个NVIC_Configuration里面添加相应开中断代码就行了。
c) 过程：
i. 在串口初始化中USART_Cmd之前加入中断设置：
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//TXE发送中断，TC传输完成中断，RXNE接收中断，PE奇偶错误中断，可以是多个。
ii. RCC、GPIO里面打开串口相应的基本时钟、管脚设置
iii. NVIC里面加入串口中断打开代码：
NVIC_InitTypeDef NVIC_InitStructure;//中断默认参数
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;//通道设置为串口1中断
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //中断占先等级0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;              //中断响应优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;          //打开中断
NVIC_Init(&NVIC_InitStructure);                                              //初始化
iv. 在stm32f10x_it.c文件中找到void USART1_IRQHandler函数，在其中添入执行代码。一般最少三个步骤：先使用if语句判断是发生那个中断，然后清除中断标志位，最后给字符串赋值，或做其他事情。
void USART1_IRQHandler(void)                            //串口1中断
{
char RX_dat;                                                       //定义字符变量
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)   //判断发生接收中断
{USART_ClearITPendingBit(USART1,   USART_IT_RXNE);       //清除中断标志
GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)0x01);          //开始传输
RX_dat=USART_ReceiveData(USART1) & 0x7F;                       //接收数据，整理除去前两位
USART_SendData(USART1, RX_dat);                                     //发送数据
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}//等待发送结束
}
}
d) 中断注意事项：
可以随时在程序中使用USART_ITConfig(USART1, USART_IT_TXE, DISABLE);来关闭中断响应。
NVIC_InitTypeDef NVIC_InitStructure定义一定要加在NVIC初始化模块的第一句。
全局变量与函数的定义：在任意.c文件中定义的变量或函数，在其它.c文件中使用extern+定义代码再次定义就可以直接调用了。
STM32笔记之九：打断它来为我办事，EXIT (外部I/O中断)应用
a) 目的：跟串口输入类似，不使用中断进行的IO输入效率也很低，而且可以通过EXTI插入按钮事件，本节联系EXTI中断。
b) 初始化函数定义：
void EXTI_Configuration(void); //定义IO中断初始化函数
c) 初始化函数调用：
EXTI_Configuration();//IO中断初始化函数调用简单应用：
d) 初始化函数：
void EXTI_Configuration(void)
{ EXTI_InitTypeDef EXTI_InitStructure; //EXTI初始化结构定义
EXTI_ClearITPendingBit(EXTI_LINE_KEY_BUTTON);//清除中断标志
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3);//管脚选择
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource4);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource6);
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//事件选择
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//触发模式
EXTI_InitStructure.EXTI_Line = EXTI_Line3 | EXTI_Line4; //线路选择
EXTI_InitStructure.EXTI_LineCmd = ENABLE;//启动中断
EXTI_Init(&EXTI_InitStructure);//初始化
}
e) RCC初始化函数中开启I/O时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
GPIO初始化函数中定义输入I/O管脚。
//IO输入，GPIOA的4脚输入
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;       //上拉输入
GPIO_Init(GPIOA, &GPIO_InitStructure);             //初始化
f) 在NVIC的初始化函数里面增加以下代码打开相关中断：
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel; //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//占先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //响应级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //启动
NVIC_Init(&NVIC_InitStructure); //初始化
g) 在stm32f10x_it.c文件中找到void USART1_IRQHandler函数，在其中添入执行代码。一般最少三个步骤：先使用if语句判断是发生那个中断，然后清除中断标志位，最后给字符串赋值，或做其他事情。
if(EXTI_GetITStatus(EXTI_Line3) != RESET)                               //判断中断发生来源
{ EXTI_ClearITPendingBit(EXTI_Line3);                                        //清除中断标志
USART_SendData(USART1, 0x41);                                           //发送字符“a”
GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_2)));//LED发生明暗交替
}
h) 中断注意事项：
中断发生后必须清除中断位，否则会出现死循环不断发生这个中断。然后需要对中断类型进行判断再执行代码。
使用EXTI的I/O中断，在完成RCC与GPIO硬件设置之后需要做三件事：初始化EXTI、NVIC开中断、编写中断执行代码。
STM32笔记之十：工作工作，PWM输出
a) 目的：基础PWM输出，以及中断配合应用。输出选用PB1，配置为TIM3_CH4，是目标板的LED6控制脚。
b) 对于简单的PWM输出应用，暂时无需考虑TIM1的高级功能之区别。
c) 初始化函数定义：
void TIM_Configuration(void);   //定义TIM初始化函数
d) 初始化函数调用：
TIM_Configuration();   //TIM初始化函数调用
e) 初始化函数，不同于前面模块，TIM的初始化分为两部分——基本初始化和通道初始化：
void TIM_Configuration(void)//TIM初始化函数
{
TIM_TimeBaseInitTypeDef   TIM_TimeBaseStructure;//定时器初始化结构
TIM_OCInitTypeDef   TIM_OCInitStructure;//通道输出初始化结构
//TIM3初始化
TIM_TimeBaseStructure.TIM_Period = 0xFFFF;        //周期0～FFFF
TIM_TimeBaseStructure.TIM_Prescaler = 5;       //时钟分频
TIM_TimeBaseStructure.TIM_ClockDivision = 0;    //时钟分割
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //基本初始化
TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);//打开中断，中断需要这行代码
//TIM3通道初始化
TIM_OCStructInit(& TIM_OCInitStructure);                                              //默认参数
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                    //工作状态
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;       //设定为输出，需要PWM输出才需要这行代码
TIM_OCInitStructure.TIM_Pulse = 0x2000;                   //占空长度
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;                 //高电平
TIM_OC4Init(TIM3, &TIM_OCInitStructure);                   //通道初始化
TIM_Cmd(TIM3, ENABLE);                                                                      //启动TIM3
}
f) RCC初始化函数中加入TIM时钟开启：
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
g) GPIO里面将输入和输出管脚模式进行设置。信号：AF_PP，50MHz。
h) 使用中断的话在NVIC里添加如下代码：
//打开TIM2中断
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;   //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;//占先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;           //响应级
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       //启动
NVIC_Init(&NVIC_InitStructure);                                            //初始化
中断代码：
void TIM2_IRQHandler(void)
{
if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)    //判断中断来源
{
TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);          //清除中断标志
GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_11)));//变换LED色彩
IC4value = TIM_GetCapture4(TIM2);                //获取捕捉数值
}
}
i) 简单应用：
//改变占空比
TIM_SetCompare4(TIM3, 变量);
j) 注意事项：
管脚的IO输出模式是根据应用来定，比如如果用PWM输出驱动LED则应该将相应管脚设为AF_PP，否则单片机没有输出
我的测试程序可以发出不断循环三种波长并捕获，对比结果如下：
捕捉的稳定性很好，也就是说，同样的方波捕捉到数值相差在一两个数值。
捕捉的精度跟你设置的滤波器长度有关，在这里
TIM_ICInitStructure.TIM_ICFilter = 0x4;        //滤波设置，经历几个周期跳变认定波形稳定0x0～0xF
这个越长就会捕捉数值越小，但是偏差几十个数值，下面是0、4、16个周期滤波的比较，out是输出的数值，in是捕捉到的。
现在有两个疑问：
1、在TIM2的捕捉输入通道初始化里面这句
TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2); //选择时钟触发源
按照硬件框图，4通道应该对应TI4FP4。可是实际使用TI1FP1，TI2FP2都行，其他均编译错误未注册。这是为什么？
2、关闭调试器和IAR程序，直接供电跑出来的结果第一个周期很正常，当输出脉宽第二次循环变小后捕捉的数值就差的远了。不知道是为什么
时钟不息工作不止，systic时钟应用
a) 目的：使用系统时钟来进行两项实验——周期执行代码与精确定时延迟。
b) 初始化函数定义：
void SysTick_Configuration(void);
c) 初始化函数调用：
SysTick_Configuration();
d) 初始化函数：
void SysTick_Configuration(void)
{
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);//时钟除8
SysTick_SetReload(250000);                                                 //计数周期长度
SysTick_CounterCmd(SysTick_Counter_Enable);                //启动计时器
SysTick_ITConfig(ENABLE);                                                     //打开中断
}
e) 在NVIC的初始化函数里面增加以下代码打开相关中断：
NVIC_SystemHandlerPriorityConfig(SystemHandler_SysTick, 1, 0);//中断等级设置，一般设置的高一些会少受其他影响
f) 在stm32f10x_it.c文件中找到void SysTickHandler 函数
void SysTickHandler(void)
{
执行代码
}
g) 简单应用：精确延迟函数，因为systic中断往往被用来执行周期循环代码，所以一些例程中使用其中断的启动和禁止来编写的精确延时函数实际上不实用，我自己编写了精确计时函数反而代码更精简，思路更简单。思路是调用后，变量清零，然后使用时钟来的曾变量，不断比较变量与延迟的数值，相等则退出函数。代码和步骤如下：
i. 定义通用变量：u16 Tic_Val=0; //变量用于精确计时
ii. 在stm32f10x_it.c文件中相应定义：
extern u16 Tic_Val;//在本文件引用MAIN.c定义的精确计时变量
iii. 定义函数名称：void Tic_Delay(u16 Tic_Count);//精确延迟函数
iv. 精确延时函数：
void Tic_Delay(u16 Tic_Count)             //精确延时函数
{ Tic_Val=0;                         //变量清零
while(Tic_Val != Tic_Count){printf("");}//计时
}
v. 在stm32f10x_it.c文件中void SysTickHandler 函数里面添加
Tic_Val++;//变量递增
vi. 调用代码：Tic_Delay(10); //精确延时
vii. 疑问：如果去掉计时行那个没用的printf("");函数将停止工作，这个现象很奇怪
C语言功底问题。是的，那个“注意事项”最后的疑问的原因就是这个
Tic_Val应该改为vu16
while(Tic_Val != Tic_Count){printf("");}//计时
就可以改为：
while(Tic_Val != Tic_Count);              //检查变量是否计数到位
STM32笔记之十三：恶搞，两只看门狗
a) 目的：
了解两种看门狗（我叫它：系统运行故障探测器和独立系统故障探测器，新手往往被这个并不形象的象形名称搞糊涂）之间的区别和基本用法。
b) 相同：
都是用来探测系统故障，通过编写代码定时发送故障清零信号（高手们都管这个代码叫做“喂狗”），告诉它系统运行正常。一旦系统故障，程序清零代码（“喂狗”）无法执行，其计数器就会计数不止，直到记到零并发生故障中断（狗饿了开始叫唤），控制CPU重启整个系统（不行啦，开始咬人了，快跑……）。
c) 区别：
独立看门狗Iwdg——我的理解是独立于系统之外，因为有独立时钟，所以不受系统影响的系统故障探测器。（这条狗是借来的，见谁偷懒它都咬！）主要用于监视硬件错误。
窗口看门狗wwdg——我的理解是系统内部的故障探测器，时钟与系统相同。如果系统时钟不走了，这个狗也就失去作用了。（这条狗是老板娘养的，老板不干活儿他不管！）主要用于监视软件错误。
d) 初始化函数定义：鉴于两只狗作用差不多，使用过程也差不多初始化函数栓一起了，用的时候根据情况删减。
void WDG_Configuration(void);
e) 初始化函数调用：
WDG_Configuration();
f) 初始化函数
void WDG_Configuration()             //看门狗初始化
{
//软件看门狗初始化
WWDG_SetPrescaler(WWDG_Prescaler_8); //时钟8分频4ms
// (PCLK1/4096)/8= 244 Hz (~4 ms)
WWDG_SetWindowValue(65);             //计数器数值
WWDG_Enable(127);                //启动计数器，设置喂狗时间
// WWDG timeout = ~4 ms * 64 = 262 ms
WWDG_ClearFlag();                //清除标志位
WWDG_EnableIT();                    //启动中断
//独立看门狗初始化
IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);//启动寄存器读写
IWDG_SetPrescaler(IWDG_Prescaler_32);//40K时钟32分频
IWDG_SetReload(349);                 //计数器数值
IWDG_ReloadCounter();             //重启计数器
IWDG_Enable();                       //启动看门狗
}
g) RCC初始化：只有软件看门狗需要时钟初始化，独立看门狗有自己的时钟不需要但是需要systic工作相关设置。
RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
h) 独立看门狗使用systic的中断来喂狗，所以添加systic的中断打开代码就行了。软件看门狗需要在NVIC打开中断添加如下代码：
NVIC_InitStructure.NVIC_IRQChannel = WWDG_IRQChannel; //通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先中断等级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;    //响应中断优先级
NVIC_Init(&NVIC_InitStructure);                      //打开中断
i) 中断程序，软件看门狗在自己的中断中喂狗，独立看门狗需要使用systic的定时中断来喂狗。以下两个程序都在stm32f10x_it.c文件中。
void WWDG_IRQHandler(void)
{
WWDG_SetCounter(0x7F);       //更新计数值
WWDG_ClearFlag();             //清除标志位
}
void SysTickHandler(void)
{   IWDG_ReloadCounter();       //重启计数器（喂狗）
}
j) 注意事项：
i. 有狗平常没事情可以不理，但是千万别忘了喂它，否则死都不知道怎么死的！
ii. 初始化程序的调用一定要在systic的初始化之后。
iii. 独立看门狗需要systic中断来喂，但是systic做别的用处不能只做这件事，所以我写了如下几句代码，可以不影响systic的其他应用，其他systic周期代码也可参考：
第一步：在stm32f10x_it.c中定义变量
int Tic_IWDG;           //喂狗循环程序的频率判断变量
第二步：将SysTickHandler中喂狗代码改为下面：
Tic_IWDG++;          //变量递增
if(Tic_IWDG>=100)    //每100个systic周期喂狗
{   IWDG_ReloadCounter();//重启计数器（喂狗）
Tic_IWDG=0;       //变量清零
}