江科大STM32 下

ADC数模转换器

那对于GPIO来说，它只能读取引脚的高低电平,要么是高电平，要么是低电平，只有两个值，而使用了ADC之后，我们就可以对这个高电平和低电平之间的任意电压进行量化，最终用一个变量来表示，读取这个变量，就可以知道引脚的具体电压到底是多少了。所以ADC其实就是一个电压表，把引脚的电压值测出来，放在一个变量里，这就是ADC的作用。

逐次逼近型这是这个ADC的工作模式。然后12位和1us的转换时间，这里就涉及到ADC的两个关键参数了，第一个是分辨率，一般用多少位来表示，12位AD值，它的表示范围就是0-2^12-1，就是量化结果的范围是0~4095。位数越高，量化结果就越精细，对应分辨率就越高；第二个是转换时间，就是转换频率，AD转换是需要花一小段时间的，这里1us就表示从AD转换开始到产生结果，需要花1us的时间，对应AD转换的频率就是1MHz，这个就是STM32 ADC的最快转换频率。如果你需要转换一个频率非常高的信号，那就要考虑一下这个转换频率是不是够用，如果你的信号频率比较低，那这个最大1MHz的转换频率也完全够用了。

外部信号源就是16个GPIO口，在引脚上直接接模拟信号就行了，不需要任何额外的电路，引脚就直接能测电压。2个内部信号源是内部温度传感器和内部参考电压。温度传感器可以测量CPU的温度，比如你电脑可以显示一个CPU温度，就可以用ADC读取这个温度传感器来测量；内部参考电压是一个1.2V左右的基淮电压，这个基准电压是不随外部供电电压变化而变化的，所以如果你芯片的供电不是标准的3.3V，那测量外部引脚的电压可能就不对，这时就可以读取这个基准电压进行校准，这样就能得到正确的电压值了。

规则组和注入组两个转换单元，这个就是STM32 ADC的增强功能了。普通的AD转换流程是，启动一次转换、读一次值，然后再启动、再读值，这样的流程。但是STM32的ADC就比较高级，可以列一个组，一次性启动一个组，连续转换多个值。并且有两个组，一个是用于常规使用的规则组，一个是用于突发事件的注入组。

模拟看门狗自动监测输入电压范围，这个ADC，一般可以用于测量光线强度、温度这些值，并且经常会有个需求，就是如果光线高于某个阈值、低于某个阈值或者温度高于某个阈值、低于某个阈值时，执行一些操作。这个高于某个阈值、低于某个阈值的判断，就可以用模拟看门狗来自动执行。模拟看门狗可以监测指定的某些通道，当AD值高于它设定的上阈值或者低于下阈值时，它就会申请中断，你就可以在中断函数里执行相应的操作，这样你就不用不断地手动读值，再用if进行判断了。

ADC可以将模拟信号转换为数字信号，是模拟电路到数字电路的桥梁。那反过来，有模拟到数字的桥梁，那肯定就有数字到模拟的桥梁。这就是DAC，数字模拟转换器，使用DAC就可以将数字变量转化为模拟电压。
不过在上一节，我们还学到了一个数字到模拟的桥梁，PWM。上一节我们使用PWM来控制LED的亮度、电机的速度，这就是DAC的功能，同时PWM只有完全导通和完全断开两种状态，在这两种状态上都没有功率损耗。所以在直流电机调速这种大功率的应用场景，使用PWM来等效模拟量，是比DAC更好的选择，并且PWM电路更加简单，更加常用。所以可以看出PWM还是挤占了DAC的很多应用空间。
目前DAC的应用主要是在波形生成这些领域，比如信号发生器、音频解码芯片等，这些领域PWM还是不好替代的。

接下来我们来了解一下这个逐次逼近型ADC到底是怎么测电压的,我们看一下这个图，这就是逐次逼近型ADC的内部结构。了解这个结构对你学习STM32的ADC有很大帮助，因为STM32的ADC原理和这个是一样的，但是STM32只画了一个框表示ADC，并没有描述内部结构，所以我们先介绍一下这个结构，这样再理解STM32的ADC就会简单一些了。
我们来看一下，这个图是ADCO809的内部结构图，它是一个独立的8位逐次逼近型ADC芯片。在以前单片性能不太好的时候，是通过外挂一个ADC芯片才能进行AD转换，这个ADCO809就是一款比较经典的ADC芯片。随着单片机的性能和集成度都有很大的提升，很多单片机内部就已经集成了ADC外设。

输入选择部分：

首先左边这里INO~IN7，是8路输入通道，通过通道选择开关，选中一路，输入到所标点进行转换。
下面这里是地址锁存和译码，就是你想选中哪个通道，就把通道号放在这三个脚（ADD…）上，然后给一个锁存信号(ALU)，上面这里对应的通路开关就可以自动拨好了。这部分就相当于一个可以通过模拟信号的数据选择器。
因为ADC转换是一个很快的过程，你给个开始信号，过几个us就转换完成了。所以说如果你想转换多路信号，那不必设计多个AD转换器，只需要一个AD转换器，然后加一个多路选择开关，想转换哪一路，就先拨一下开关，选中对应通道，然后再开始转换就行了。这就是这个输入通道选择的部分，这个ADC0809只有8个输入通道，我们STM32内部的ADC是有18个输入通道的，所以对应输入电路，就是一个18路输入的多路开关

核心结构：
那然后输入信号选好了，到这里（所标红点）来，怎么才能知道这个电压对应的编码数据是多少呢？这就需要我们用逐次逼近的方法来——比较了

首先这是一个电压比较器，它可以判断两个输入信号电压的大小关系，输出一个高低电平指示谁大谁小。它的两个输入端，一个是待测的电压，另一个是这里DAC的电压输出端，DAC是数模转换器。我们之前说过了，给它一个数据，它就可以输出数据对应的电压，DAC内部是使用加权电阻网络来实现的转换，具体可以江科大51单片机教程里的AD/DA那一节。
那现在，我们有了一个外部通道输入的未知编码的电压，和一个DAC输出的已知编码的电压。它俩同时输入到电压比较器，进行大小判断，如果DAC输出的电压比较大，我就调小DAC数据;如果DAC输出的电压比较小，我就增大DAC数据，直到DAC输出的电压和外部通道输入的电压近似相等 ，这样DAC输入的数据就是外部电压的编码数据了，这就是DAC的实现原理。这个电压调节的过程就是这个逐次逼近SAR来完成的。

为了最快找到未知电压的编码，通常我们会使用二分法进行寻找。比如这里是8位的ADC，那编码就是从0~255。第一次比较的时候，我们就给DAC输入255的一半，进行比较，那就是128，然后看看谁大谁小，如果DAC电压大了；第二次比较的时候，再就给128的一半，64，如果还大，第三次比较的时候就给32，如果这次DAC电压小了，那第四次就给32到64中间的值，然后继续，这样依次进行下去，就能最快地找到未知电压的编码。并且这个过程，如果你用二进制来表示的话，你会发现，128、64、32这些数据，正好是二进制每一位的位权，这个判断过程就相当于是，对二进制从高位到低位依次判断是1还是0的过程，这就是逐次逼近型名字的来源。**那对于8位的ADC，从高位到低位依次判断8次就能找到未知电压的编码了，对于12位的ADC，就需要依次判断12次，**这就是逐次逼近的过程。

那然后，AD转换结束后，DAC的输入数据，就是未知电压的编码，通过右边电路进行输出，8位就有8根线，12位就有12根线。

好，到这里，相信你对逐次逼近型ADC就已经了解差不多了，接下来，我们就来看看STM32的逐次逼近型ADC，看看STM32的ADC和这个相比，有什么更高级的变化,那我们看一下STM32的这个ADC框图。

STM(32逐次逼近型)ADC电路图详解
总图：

核心的大概工作流程：

注入规则组和规则通道组：

比喻解释注入组和规则组：
这有什么作用呢？举个例子，这就像是你去餐厅点菜，普通的ADC是，你指定一个菜，老板给你做，然后做好了送给你；这里就是，你指定一个菜单，这个菜单最多可以填16个菜，然后你直接递个菜单给老板，老板就按照菜单的顺序依次做好，一次性给你端上菜，这样的话就可以大大提高效率。当然，你的菜单也可以只写一个菜，这样这个菜单就简化成了普通的模式了。
那对于这个菜单呢,也有两种，一种是规则组菜单,可以同时上16个菜，但是它有个尴尬的地方。就是这个规则组只有一个数据寄存器，就是这个桌子比较小，最多只能放一个菜，你如果上16个菜，那不好意思，前15个菜都会被挤掉些，你只能得到第16个菜。所以对于规则组转换来说，如果使用这个菜单的话，最好配合DMA来实现。DMA是一个数据转运小帮手，它可以在每上一个菜之后，把这个菜挪到其他地方去,防止被覆盖。这个DMA我们下一节就会讲，现在先大概了解一下，那现在我们就知道了，这个规则组虽然可以同时转换16个通道，但是数据寄存器只能存一个结果，如果不想之前的结果被覆盖，那在转换完成之后，就要尽快把结果拿走。
接着我们看一下注入组，这个组就比较高级了，它相当于是餐厅的VIP座位，在这个座位上，一次性最多可以点4个菜，并且这里数据寄存器有4个，是可以同时上4个菜的。对于注入组而言，就不用担心数据覆盖的问题了，这就是规则组和注入组的介绍。
一般情况下，我们使用规则组就完全足够了，如果要使用规则组的菜单，那就再配合DMA转运数据，这样就不用担心数据覆盖的问题了。所以接下来就只讲规则组的操作，注入组涉及的不多，大家可以看手册自行了解。

那我们接着继续看这个模数转换器外围的一些线路

首先，左下角这里是触发转换的部分,也就是这里的START信号，开始转换。那对于STM32的ADC，触发ADC开始转换的信号有两种，一种是软件触发，就是你在程序中手动调用一条代码，就可以启动转换了；另一种是硬件触发，就是这里的这些触发源。上面这些是注入组的触发源，下面这些是规则组的触发源，这些触发源主要是来自于定时器，有定时器的各个通道，还有TRGO定时器主模式的输出，这个之前讲定时器的时候也介绍过。定时器可以通向ADC、 DAC这些外设，用于触发转换。那因为ADC经常需要过一个固定时间段转换一次。比如每隔1ms转换一次，正常的思路就是,用定时器,每隔1ms申请一次中断，在中断里手动开始一次转换，这样也是可以的。但是频繁进中断对我们的程序是有一定影响的，比如你有很多中断都需要频繁进入，那肯定会影响主程序的执行，并且不同中断之间，由于优先级的不同，也会导致某些中断不能及时得到响应。如果触发ADC的中断不能及时响应，那我们ADC的转换频率就肯定会产生影响了。所以对于这种需要频繁进中断，并且在中断里只完成了简单工作的情况，一般都会有硬件的支持。

比如这里，就可以给TIM3定个1ms的时间，并且把TIM3的更新事件选择为TRGO输出，然后在ADC这里，选择开始触发信号为TIM3的TRGO，这样TIM3的更新事件就能通过硬件自动触发ADC转换了。整个过程不需要进中断，节省了中断资源，这就是这里定时器触发的作用。当然这里还可以选择外部中断引脚来触发转换，都可以在程序中配置。这就是触发转化的部分。

然后接着看，左上角这里是VREF+、VREF-、VDDA和VSSA。上面两个是ADC的参考电压，决定了ADC输入电压的范围；下面两个是ADC的供电引脚。一般情况下，VREF+要接VDDA，VREF-要接VSSA，在我们这个芯片上，没有VREF+和VREF-的引脚，它在内部就已经和VDDA和VSSA接在一起了。VDDA和VSSA是内部模拟部分的电源，比如ADC、RC振荡器、锁相环等。在这里VDDA接3.3V, VSSA接GND,所以ADC的输入电压范围就是0~3.3V。

然后继续看 右边这里是ADCCLK是ADC的时钟，也就是这里的CLOCK，是用于驱动内部逐次比较的时钟。这个ADCCLK是来自ADC预分频器，而ADC预分频器是来源于RCC的。

APB2时钟72MHZ，然后通过ADC预分频器进行分频，得到ADCCLK，ADCCLK最大是14MHZ，所以这个预分频器就有点尴尬。它可以选择2、4、6、8分频，如果选择2分频，72M/2=36M，超出允许范围了；4分频之后是18M，也超了，所以对于ADC预分频器只能选择6分频，结果是12M和8分频，结果是9M，这两个值。这个在程序里要注意一下

继续看上面这里是DMA请求，这个就是用于触发DMA进行数据转运的，我们下节再讲。

好，有关ADC的这个框图，我们就介绍完了。

ADC基本结构
那接下来就来看一下我这里总结的一个ADC基本结构图，再来回忆一下。

左边是输入通道，16个GPIO口，外加两个内部的通道，然后进入AD转换器。AD转换器里有两个组，一个是规则组，一个是注入组，规则组最多可以选中16个通道，注入组最多可以选择4个通道。然后转换的结果可以存放在AD数据寄存器里，其中规则组只有1个数据寄存器，注入组有4个。
然后下面这里有触发控制，提供了开始转换这个START信号，触发控制可以选择软件触发和硬件触发。硬件触发主要是来自于定时器，当然也可以选择外部中断的引脚，右边这里是来自于RCC的ADC时钟CLOCK，ADC逐次比较的过程就是由这个时钟推动的。
然后上面，可以布置一个模拟看门狗用于监测转换结果的范围，如果超出设定的阈值，就通过中断输出控制，向NVIC申请中断，另外，规则组和注入组转换完成后会有个EOC信号，它会置一个标志位，当然也可以通向NVIC。最后右下角这里还有个开关控制，在库函数中，就是ADC_Cmd函数，用于给ADC上电的，那这些，就是STM32 ADC的内部结构了。

接下来我们再了解一些细节的问题，这些就是ADC通道和引脚复用的关系，这个对应关系也可以通过引脚定义表看出来。另外由于我们这个芯片没有PC0~PC5，所以这些通道也就没有了。

ADC1和ADC2的引脚全都是相同的，既然都相同，那要ADC2还有啥用呢。这个就要再说一个ADC的高级功能了，就是双ADC模式，,这个模式比较复杂。这里只简单介绍一下，不需要掌握。双ADC模式就是ADC1和ADC2一起工作，它俩可以配合组成同步模式、交叉模式等等模式。比如交叉模式，ADC1和ADC2交叉地对一个通道进行采样，这样就可以进一步提高采样率。

规则组的4种转换模式
接下来，我们再来了解一下规则组的4种转换模式，分别是单次转换，非扫描模式和连续转换，扫描模式。那在我们ADC初始化的结构体里，会有两个参数，一个是选择单次转换还是连续转换的，另一个是选择扫描模式还是非扫描模式的，这两个参数组合起来，就有这4种转换方式。我们来逐一看一下。

第一种，单次转换，非扫描模式，这里我画了一个列表，这个表就是规则组里的菜单，有16个空位，分别是序列1到序列16，你可以在这里“点菜”，就是写入你要转换的通道，在非扫描的模式下，这个菜单就只有第一个序列1的位置有效，这时，菜单同时选中一组的方式就退化为简单地选中一个的方式了。在这里我们可以在序列1的位置指定我们想转换的通道，比如通道2，写到这个位置。然后，我们就可以触发转换，ADC就会对这个通道2进行模数转换，过一小段时间后，转换完成，转换结果放在数据寄存器里，同时给EOC标志位置1，整个转换过程就结束了。我们判断这个EOC标志位，如果转换完了， 那我们就可以在数据寄存器里读取结果了。如果我们想再启动一次转换，那就需要再触发一次，转换结束，置EOC标志位，读结果。如果想换一个通道转换，那在转换之前，把第一个位置的通道2改成其他通道，然后再启动转换，这样就行了。这就是单次转换，非扫描的转换模式。没有用到这个菜单列表，也是比较简单的一种模式

接下来我们看一下连续转换，非扫描模式。首先，它还是非扫描模式，所以菜单列表就只用第一个，然后它与上一种单次转换不同的是，它在一次转换结束后不会停止，而是立刻开始下一轮的转换，然后一直持续下去。这样就只需要最开始触发一次，之后就可以一直转换了。这个模式的好处就是，开始转换之后不需要等待一段时间的，因为它直都在转换，所以你就不需要手动开始转换了，也不用判断是否结束的，想要读AD值的时候，直接从数据寄存器取就是了。这就是连续转换，非扫描的模式

然后继续看，单次转换，扫描模式。这个模式也是单次转换，所以每触发一次，转换结束后，就会停下来，下次转换就得再触发才能开始。然后它是扫描模式，这就会用到这个菜单列表了，你可以在这个菜单里点菜，比如第一个菜是通道2，第二个菜是通道5，等等等等，这里每个位置是通道几可以任意指定，并且也是可以重复的，然后初始化结构体里还会有个参数，就是通道数目。因为这16个位置你可以不用完，只用前几个，那你就需要再给一个通道数目的参数，告诉它，我有几个通道。比如这里指定通道数目为7，那它就只看前7个位置，然后每次触发之后，它就依次对这前7个位置进行AD转换，转换结果都放在数据寄存器里，这里为了防止数据被覆盖，就需要用DMA及时将数据挪走。那7个通道转换完成之后，产生EOC信号，转换结束，然后再触发下一次，就又开始新一轮的转换，这就是单次转换，扫描模式的工作流程。

那最后再看一下连续转换，扫描模式。它就是在上一个模式的基础上，变了一点，就是一次转换完成后，立刻开始下一次的转换。和上面这里非扫描模式的单次和连续是一个套路，这就是连续转换，扫描模式。

当然在扫描模式的情况下，还可以有一种模式，叫间断模式。它的作用是，在扫描的过程中，每隔几个转换，就暂停一次，需要再次触发，才能继续。这个模式没有列出来，要不然模式太多了。大家了解一下就可以了，暂时不需要掌握，好，这些就是STM32 ADC的4种转换模式。

几个小知识点|细节：
触发控制

这个表就是规则组的触发源，也就是ADC总框图中的ADC。在这个表里，有来自定时器的信号；还有这个来自引脚或定时器的信号，这个具体是引脚还是定时器，需要用AFIO重映射来确定；最后是软件控制位，也就是我们之前说的软件触发。这些触发信号怎么选择，可以通过设置右边这个寄存器来完成，当然使用库函数的话，直接给一个参数就行了，这就是触发控制。

数据对齐

转换时间

这个大概讲一下，不过转换时间这个参数，我们一般不太敏感，因为一般AD转换都很快，如果不需要非常高速的转换频率，那转换时间就可以忽略了。
我们来看一下，之前我们说了，AD转换是需要一小段时间的，就像厨子做菜一样，也是需要等一会儿才能上菜的，那AD转换的时候都有哪些步骤需要花时间呢？AD转换的步骤，有4步，分别是采样，保持，量化，编码，其中采样保持可以放在一起，量化编码可以放在一起，总共是这两大步。量化编码好理解，就是我们之前讲过的，ADC逐次比较的过程，这个是要花一段时间的，一般位数越多，花的时间就越长。
那采样保持是干啥的呢？这个我们前面这里并没有涉及，为什么需要采样保持呢？这是因为，我们的AD转换，就是后面的量化编码，是需要一小段时间的，如果在这一小段时间里，输入的电压还在不断变化，那就没法定位输入电压到底在哪了，所以在量化编码之前，我们需要设置一个采样开关。先打开采样开关，收集一下外部的电压，比如可以用一个小容量的电容存储一下这个电压，存储好了之后，断开采样开关，再进行后面的AD转换。这样在量化编码的期间，电压始终保持不变，这样才能精确地定位未知电压的位置，这就是采样保持电路。
那采样保持的过程，需要闭合采样开关，过一段时间再断开，这里就会产生一个采样时间。那回到这里，我们就得到了第二条，STM32 ADC的总转换时间为TCONV=采样时间+12.5个ADC周期，采样时间是采样保持花费的时间，这个可以在程序中进行配置，采样时间越大，越能避兔一些毛刺信号的干扰，不过转换时间也会相应延长。12.5个ADC周期是量化编码花费的时间，因为是12位的ADC，所以需要花费12个周期，这里多了半个周期，可能是做其他一些东西花的时间。ADC周期就是从RCC分频过来的ADCCLK，这个ADCCLK最大是14MHz。
所以下面有个例子，这里就是最快的转换时间，当ADCCLK=14MHz，采样时间为1.5个ADC周期，TCONV = 1.5 +12.5 = 14个ADC周期，在14MHz ADCCLK的情况下就 = 1us，这就是转化时间最快1us时间的来源。如果你采样周期再长些，它就达不到1us了；另外你也可以把ADCCLK的时钟设置超过14MHz，这样的话ADC就是在超频了，那转换时间可以比1us还短，不过这样稳定性就没法保证了。

校准

这个看上去挺复杂，但是我们不需要理解，这个校准过程是固定的。我们只需要在ADC初始化的最后，加几条代码就行了，至于怎么计算、怎么校准的，我们不需要管。

ADC外围电路设计
对于ADC的外围电路，我们应该怎么设计呢？

如果你想采集5V，10V这些电压的话，可以使用这个电压转换电路,但是如果你电压再高一些，就不建议使用这个电路了，那可能会比较危险高电压采集最好使用一些专用的采集芯片，比如隔离放大器等等，做好高低电压的隔离，保证电路的安全。

手册粗讲

代码实战：AD单通道+AD多通道

7-1 AD单通道
程序现象：在面包板的中间，也就是芯片左边接了一个电位器，就是滑动变阻器。用这个电位器产生一个0~3.3V连续变化的模拟电压信号。然后接到STM32的PA0口上，之后用STM32内部的ADC读取电压数据，显示在屏幕上。这里屏幕第一行显示的是AD转换后的原始数据，第二行是经过处理后实际的电压值。电位器往左拧，AD值减小，电压值也减小，AD值最小是0，对应的电压就是0V；反之同理STM32的ADC是12位的，所以AD结果最大值是4095，也就是2^12-1，对应的电压是3.3V。

第一步，开启RCC时钟，包括ADC和GPIO的时钟，另外这里ADCCLK的分频器，也服务器托管网需要配置一下

第二步，配置GPIO。把需要用的GPIO配置成模拟输入的模式

第三步，配置这里的多路开关。把左边的通道接入到右边的规则组列表里。这个过程就是我们之前说的点菜，把各个通道的菜，列在菜单里

第四步，就是配置ADC转换器了。在库函数里，是用结构体来配置的，可以配置这一大块电路的参数。包括ADC是单次转换还是连续转换、扫描还是非扫描、有几个通道，触发源是什么，数据对齐是左对齐还是右对齐。

如果你需要模拟看门狗，那会有几个函数用来配置阈值和监测通道的
如果你想开启中断，那就在中断输出控制里用ITConfig函数开启对应的中断输出，然后再在NVIC里，配置一下优先级，这样就能触发中断了。
不过这一块，模拟看门狗和中断，我们本节暂时不用，如果你需要的话，可以自己配置试一下

接下来，就是开关控制，调用一下ADC_Cmd函数，开启ADC,这样ADC就配置完成了，就能正常工作了。

当然，在开启ADC之后，根据手册里的建议，我们还可以对ADC进行一下校准，这样可以减小误差，那在ADC工作的时候，

这里有四个函数，对应校准的四个步骤：第一步，调用第一个函数ADC_ResetCalibration，复位校准；第二步，调用第二个函数ADC_GetResetCalibrationStatus，等待复位校准完成；第三步，调用第三个函数ADC_StartCalibration，开始校准；第四步，调用第四个函数ADC_GetCalibrationStatus，等待校准完成。

如果想要软件触发转换，那会有函数可以触发。如果想读取转换结果，那也会有函数可以读取结果，这个等会儿介绍库函数的时候就可以看到了。好，这些就是我们程序的大概思路了。
首先，软件触发转换；然后等待转换完成，也就是等待EOC标志位置1；最后，读取ADC数据寄存器，就完事了。

7-1 AD单通道
程序现象：在这里分别接了光敏电阻、热敏电阻和反射红外模块三个传感器模块。把它们的AO、模拟电压输出端，分别接在了A1、A2、A3引脚，加上刚才的电位器，总共4个输出通道。然后测出来的4个AD数据分别显示在屏幕上

现象：这里AD值的末尾会有些抖动，这是正常的波动，如果你想对这个值进行判断，再执行一些操作。比如光线的AD值小于某一阈值，就开灯，大于某一阈值，就关灯，那可能会存在这样的情况：比如光线逐渐变暗，AD值逐渐变小，但是由于波动，AD值会在判断阈值附近来回跳变，这会导致输出产生抖动，反复开关灯。

那如何避兔这种情况呢？有很多种方法，比如可以使用迟滞比较的方法来完成，设置两个阈值，低于下阈值时，开灯，这就可以避免输出抖动的问题了。另外，如果你觉得数据跳变太厉害，还可以采取滤波的方法，让AD值平滑一些，比如均值滤波，就是读10个或20个值，取平均值，作为滤波的AD值；或者还可以裁剪分辨率，把数据的尾数去掉。

7-2 AD多通道
如何实现多通道呢？
我们首先想到的应该是后面这两种扫描模式（连续转换、扫描模式和单次转换、扫描模式），但如果想要用扫描模式实现多通道，最好要配合DMA来实现，来解决数据覆盖的问题。
那你可能会问，我们一个通道转换完成之后，你启动列表之后，它里面每一个单独的通道转换完成之后，不会产生任何的标志位，也不会触发中断，你不知道某一个通道是不是转换完了。它只有在整个列表都转换完成之后，才会产生一次EOC标志位，才能触发中断，而这时，前面的数据就已经覆盖丢失了。其次，AD转化时很快的，如果你不能在几us的时间内把数据转运走，那数据就会丢失，这对我们程序手动转运数据，要求就比较高了.
所以在扫描模式下，手动转运数据是比较困难的,不过比较困难也不是说手动转运不可行，我们可以使用间断模式，在扫描的时候，每转换一个通道就暂停一次，等我们手动把数据转运走之后，10再继续触发，继续下一次转换。但是由于单个通道转换完成之后，没有标志位。所以启动转换之后，只能通过Delay延时的方式，延迟足够长的时间，才能保证转换完成。这种方式既不能让我们省心，也不能提高效率，所以我暂时不推荐使用。

我们可以使用上面的这个单次转换、非扫描的模式，来实现多通道。只需要在每次触发转换之前，手动更改一下列表第一个位置的通道就行了

DMA直接存储器存取

所以存储器到存储器的数据转运，我们一般使用软件触发,外设到存储器的数据转运，我们一般使用硬件触发。

我们来看一下STM32的存储器映像，既然DMA是在存储器之间进行数据转运的，那我们就应该要了解一下，STM32中都有哪些存储器，这些存储器又是被安排到了哪些地址上，这就是存储器映像的内容。

在这个表里，无论是Flash，还是SRAM，还是外设寄存器，它们都是存储器的一种，包括外设寄存器，实际上也是存储器。在DMA简介中，我们说的是外设到存储器，存储器到存储器，本质上其实都是存储器之间的数据转运，说成外设到存储器，只不过是STM32他特别指定了可以转运外设的存储器而已。

DMA框图讲解

左上角这里是Cortex-M3内核，里面包含了CPU和内核外设等等，剩下的这所有东西，你都可以把它看成是存储器，所以总共就是CPU和存储器两个东西。Flash是主闪存，SRAM是运行内存，各个外设，都可以看成是寄存器，也是一种SRAM存储器。
奇存器是一种特殊的存储器，一方面，CPU可以对奇存器进行读写，就像读写运行内存一样，另一方面，寄存器的每一位背后，都连接了一根导线，这些导线可以用于控制外设电路的状态，比如置引脚的高低电平、导通和断开开关、切换数据选择器，或者多位组合起来，当做计数器、数据寄存器等等。所以，寄存器是连接软件和硬件的桥梁，软件读写寄存器，就相当于在控制硬件的执行。
回到这里，既然外设就是寄存器，寄存器就是存储器，那使用DMA进行数据转运，就都可以归为一类问题了。就是从某个地址取内容，再放到另一个地址去。

我们看图，为了高效有条理地访问存储器，这里设计了一个总线矩阵，总线矩阵的左端，是主动单元，也就是拥有存储器的访问杈，右边这些，是被动单元，它们的存储器只能被左边的主动单元读写。主动单元这里，内核有DCode和系统总线，可以访问右边的存储器，其中DCode总线是专门访问Flash的，系统总线是访问其他东西的，另外，由于DMA要转运数据，所以DMA也必须要有访问的主动权。那主动单元，除了内核CPU，剩下的就是DMA总线了。这里DMA1有一条DMA总线，DMA2也有一条DMA总线，下面这还有一条DMA总线，这是以太网外设自己私有的DMA，这个可以不用管的。
在DMA1和DMA2里面，可以看到，DMA1有7个通道，DMA2有5个通道，各个通道可以分别设置它们转运数据的源地址和目的地址，这样它们就可以各自独立地工作了。

接着下面这里有个仲裁器，这个是因为，虽然多个通道可以独立转运数据，但是最终DMA总线只有一条，所以所有的通道都只能分时复用这一条DMA总线。如果产生了冲突，那就会由仲裁器，根据通道的优先级来决定谁来使用。另外在总线矩阵这里，也会有个仲裁器，如果DMA和CPU都要访问同一个目标，那么DMA就会暂停CPU的访问，以防止冲突。不过总线仲裁器，仍然会保证CPU得到一半的总线带宽，使CPU也能正常的工作。

下面这里是AHB从设备，也就是DMA自身的寄存器，因为DMA作为一个外设，它自己也会有相应的配置寄存器，这里连接在了总线右边的AHB总线上，所以DMA，即是总线矩阵的主动单元，可以读写各种存储器，也是AHB总线上的被动单元。CPU通过这一条线路，就可以对DMA进行配置了。

接着继续看这里，是DMA请求，请求就是触发的意思，这条线路右边的触发源，是各个外设，所以这个DMA请求就是DMA的硬件触发源。比如ADC转换完成、串口接收到数据，需要触发DMA转运数据的时候，就会通过这条线路，向DMA发出硬件触发信号，之后DMA就可以执行数据转运的工作了。这就是DMA请求的作用

到这里，有关DMA的结构就讲的差不多了，其中包括：用于访问各个存储器的DMA总线；内部的多个通道，可以进行独立的数据转运；仲裁器，用于调度各个通道，防止产生冲突；AHB从设备，用于配置DMA参数；DMA请求，用于硬件触发DMA的数据转运，这就是这个DMA的各个部分和作用。

注意一下：就是这里的Flash，它是ROM只读存储器的一种，如果通过总线直接访问的话，无论是CPU，还是DMA，都是只读的，只能读取数据，而不能写入，如果你DMA的目的地址，填了Flash的区域，那转运时，就会出错。当然Flash也不是绝对的不可写入，我们可以配置这个Flash接口控制器，对Flash进行写入，这个流程就比较麻烦了，要先对Flash按页进行擦除，再写入数据。总之就是CPU或者DMA直接访问Flash的话，是只可以读而不可以写的，然后SRAM是运行内存，可以任意读写，没有问题，外设寄存器的话，得看参考手册里面的描述。

DMA基本结构

刚才这个框图只是一个笼统的结构图，对于DMA内部的执行细节，它还是没体现出来，所以我们再来分析一下这个图，看看DMA具体是怎么工作的。

这就是外设站点和存储器站点各自的3个参数了。
在STM32手册里，所说的存储器，一般是特指Flash和SRAM，不包含外设寄存器。外设寄存器，他一般直接称作外设，所以就是外设到存储器，存储器到存储器，这样来描述。虽然我们刚才说了，寄存器也是存储器的一种，但是STM32还是使用了外设和存储器来作为区分，这个注意一下描述方法的不同。那在这里可以看到，
这就是外设站点和存储器站点各自的3个参数了。

传输计数器和自动重装器：

触发控制部分：

然后最后，就是开关控制了，也就是DMA_Cmd函数.当给DMA使能后，DMA就准备就绪，可以进行转运了。

基于DMA基本结构的一些问题
问题1：那如何进行存储器到存储器的数据转运，方向反过来可以吗？
如果要进行存储器到存储器的数据转运。那我们就需要把其中一个存储器的地址，放在外设的这个站点，这样就能进行存储器到存储器的转运了。只要你在外设起始地址里写Flash或者SRAM的地址，那它就会去Flash或SRAM找数据。这个站点虽然叫外设寄存器，但是它就只是个名字而已。甚至你可以在外设站点写存储器的地址，存储器站点写外设的地址，然后方向参数给反过来，这样也是可以的，只是ST公司给它起了这样的名字而已。你也可以把它叫做站点A、站点B,从A到B或者从B到A转运数据。

问题2：在DMA中软件触发的执行逻辑？和外部中断、ADC的软件触发有什么区别？
这个软件触发并不是调用某个函数一次，触发一次，它这个软件触发的执行逻辑是，以最快的速度，连续不断地触发DMA，争取早日把传输计数器清零，完成这一轮的转换。所以这里的软件触发，和我们之前外部中断和ADC的软件触发可能不太一样，你可以把它理解成连续触发，那这个软件触发和（自动重装器）循环模式，不能同时用。因为软件触发就是想把传输计数器清零，循环模式是清零后自动重装，如果同时用的话，那DMA就停不下来了，这就是软件触发。

问题3：DMA的转运条件？
DMA进行转运，有几个条件，第一，就是开关控制，DMA_Cmd必须使能；第二，就是传输计数器必须大于0；第三，就是触发源，必须有触发信号。触发一次，转运一次，传输计数器自减一次，当传输计数器等于0，且没有自动重装时。这时无论是否触发，DMA都不会再进行转运了，此时就需要DMA_Cmd，给DISABLE，关闭DMA,再为传输计数器写入一个大于0的数,再DMA_Cmd，给ENABLE，开启DMA，DMA才能继续工作。
注意一下，写传输计数器时，必须要先关闭DMA，再进行，不能在DMA开启时，写传输计数器，这是手册里的规定。

几个小知识点|细节：
DMA请求

数据宽度与对齐
细节讲解
DMA数据转运的两个站点，都有一个数据宽度的参数，如果数据宽度都一样，那就是正常的一个个转运，如果数据宽度不一样，那会怎么处理呢？
这个表就是来说明问题的，

总之一这个表的意思就是如果你把小的数据转到大的里面去,高位就会补0；如果把大的数据转到小的里面去高位，就会舍弃掉；如果数据宽度一样，那就没事。

那最后，我们再来看两个例子，看看在这些实际的任务下，DMA是如何工作的。这两个例子和程序例子对应的。

数据转运＋DMA

这个例子的任务是将SRAM里的数组DataA，转运到另一个数组DataB中，我们看一下这种情况下，这个基本结构里的各个参数该如何配置。
首先是外设站点和存储器站点的起始地址、数据宽度、地址是否自增这三个参数。那在这个任务里，外设地址显然应该填DataA数组的首地址，存储器地址，给DataB数组的首地址，然后数据宽度，两个数组的类型都是uint8_t，所以数据宽度都是按8位的字节传输。之后地址是否自增，在中间可以看到，我们想要的效果是DataA[０]转到DataB[０]，DataA[1]转到DataB[1]，等等。所以转运完DataA[0]和DataB[0]之后，两个站点的地址都应该自增，都移动到下一个数据的位置，继续转运DataA[1]和DataB[1]，这样来进行。
之后，这里的方向参数，那显然就是外设站点转运到存储器站点了，当然如果你想把DataB的数据转运到DataA，那可以把方向参数换过来，这样就是方向转运了。
然后是传输计数器和是否要自动重装，在这里，显然要转运7次，所以传输计数器给7，自动重装暂时不需要，之后触发选择部分，这里，我们要使用软件触发。因为这是存储器到存储器的数据转运，是不需要等待硬件时机的，尽快转运完成就行了。
那最后，调用DMA_Cmd，给DMA使能，这样数据就会从DataA转运到DataB了。转运7次之后，传输计数器自减到0，DMA停止，转运完成。这里的数据转运是一种复制转运，转运完成后DataA的数据并不会消失，这个过程相当于是把DataA的数据复制到了DataB的位置。

ADC扫描模式+DMA
讲解细节，精彩！

左边是ADC扫描模式的执行流程，在这里有7个通道，触发一次后，7个通道依次进行AD转换，然后转换结果都放到ADC_DR数据寄存器里面。那我们要做的就是，在每个单独的通道转换完成后，进行一个DMA数据转运，并且目的地址进行自增，这样数据就不会被覆盖了。所以在这里DMA的配置就是，外设地址，写入ADC_DR这个寄存器的地址；存储器的地址，可以在SRAM中定义一个数组ADValue，然后把ADValue的地址当做存储器的地址。
之后数据宽度，因为ADC_DR和SRAM数组，我们要的都是uint16_t的数据，所以数据宽度都是16位的半字传输。
接着判断地址是否自增，那从这个图里，显然是外设地址不自增，存储器地址自增；传输方向，是外设站点到存储器站点；传输计数器，这里通道有7个，所以计数7次；计数器是否自动重装，这里可以看ADC的配置，ADC如果是单次扫描，那DMA的传输计数器可以不自动重装，转换一轮就停止，如果ADC是连续扫描，那DMA就可以使用自动重装，在ADC启动下一轮转换的时候，DMA也启动下一轮的转运，ADC和DMA同步工作。
最后是触发选择，这里ADC_DR的值是在ADC单个通道转换完成后才会有效，所以DMA转运的时机，需要和ADC单个通道转换完成同步，所以DMA的触发要选择ADC的硬件触发。
最后硬件触发这里要说明一下，我们上一节说了，ADC扫描模式，在每个单独的通道转换完成后，没有任何标志位，也不会触发中断。所以我们程序不太好判断，某一个通道转换完成的时机是什么时候。但是根据UP主的研究，虽然单个通道转换完成后，不产生任何标志位和中断，但是它应该会产生DMA请求，去触发DMA转运，这部分内容，手册里并没有详细描述，根据我实际实验，单个通道的DMA请求肯定是有的。
这些就是ADC扫描模式和DMA配合使用的流程。一般来说，DMA最常见的用途就是配合ADC的扫描模式，因为ADC扫描模式有个数据覆盖的特征，这个缺陷使ADC和DMA成为了最常见的伙伴。

手册

代码实战： DMA数据转运&&DMA+AD多通道

验证存储器映像的内容

8-1 DMA数据转运
也就是把一个数组里面的数据，复制到另一个数组里

这就是我们第一个代码的任务定义一下，DMA转运的源端数组和目的数组，初始化DMA，然后让DMA把这里DataA的数据，转运到DataB里面去。

初始化第一步，RCC开启DMA的时钟
注意：这里开启DMA时钟的时候，根据型号不同开启时钟参数也不同

第二步，就可以直接调用DMA_Init，初始化这里的各个参数了,包括外设和存储器站点的起始地址、数据宽度、地址是否自增，方向、传输计数器、是否需要自动重装、选择触发源、通道优先级，那这所有的参数，通过一个结构体，就可以配置好了

例：

/* Initialize the DMA Channel1 according to the DMA_InitStructure 
members */ 
DMA_InitTypeDef DMA_InitStructure; 
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40005400; 
DMA_InitStructure.DMA_MemoryBaseAddr = 0x20000100; 
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; 
DMA_InitStructure.DMA_BufferSize = 256; 
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; 
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; 
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; 
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; 
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; 
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; 
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; 
DMA_Init(DMA_Channel1, &DMA_InitStructure); 

之后，就可以进行开关控制，DMA_Cmd，给指定的通道使能，就完成了。那在这里，如果你选择的是硬件触发不要忘了在对应的外设调用一下XXX_DMACmd，开启一下触发信号的输出；如果你需要DMA的中断，那就调用DMA_ITConfig，开启中断输出，再在NVIC里，配置相应的中断通道，然后写中断函数就行了

最后，在运行的过程中，如果转运完成，传输计数器清0了。这时想再给传输计数器赋值的话，就DMA失能、写传输计数器、DMA使能，这样就行了。

MyDMA部分：

mian.c:

8-2 DMA+AD多通道
用ADC的扫描模式来实现多通道采集，然后使用DMA来进行数据转运

AD+DMA部分：

main.c部分：

模块篇
按键

旋转编码器
31:05开始介绍了编码器

舵机

如果单独供电的话,供电的负极要和STM32共地，然后正极接在5V供电引脚上。不同的电源需要共地

可以看出，舵机其实并不是一种单独的电机，它的内部是由直流电机驱动的，它里面还有一个控制电路板，是一个电机的控制系统。大概的执行逻辑是：PWM信号输入到控制板，给控制板一个指定的目标角度，然后，这个电位器检测输出轴的当前角度。如果大于目标角度，电机就会反转；如果小于目标角度，电机就会正转，最终使输出轴固定在指定角度，这就是舵机的内部工作流程。
棕色是电源负，红色是电源正，橙色是信号线

直流电机

补充篇
参考资料：
电路分析基础（6）-总说电路的“地”

关于在外设接线中注意的问题——共地
这是因为，在实际中，各处的零电位实际上是不太相同的，将地线接在一起是为了统一零电位，以保证各处的电压，即电势差有统一的关系。

C语言基础
C语言

区分：串口，COM口，UART，USART
https://blog.csdn.net/qq_26904271/article/details/79829363请跳转这个链接去看，这个博主写的挺好的。

图片内容为：[1]潘南红,黄连帅,莫秋燕.基于STM32的USART串口异步通信及应用实验设计[J].信息与电脑(理论版),2021,33(19):217-219.

UART和IrDA、LIN的关系
UART和IrDA、LIN的关系

printf函数重定向
USART串口中提到，真的牛掰！

前置知识

相当于专有名词解释

串行与并行
数字数据通信接口可以分为两大类：串行接口和并行接口。

串行通信，又称为逐位传输（Bit-by-Bit Transmission），是指按顺序逐个传输数据位的通信方式。在串行通信中，数据位按照顺序逐一传输，通过传输线进行数据传输。虽然传输速度较慢，但实现简单。串行通信常用于短距离的数据传输，如串口、USB接口等。
  

并行通信是一种同时传输多个数据位的通信方式，也称为同时传输多个数据位（Word-by-Word Transmission）。在并行通信中，数据被分成多个并行传输，同时通过多个传输线进行数据传输。虽然传输速度快，但实现起来较为复杂。并行通信常用于短距离的数据传输，如计算机内部数据总线等。

并行数据传输，可以将一个完整的字节(单词或更大的数据)一下子从发送器传输到了接收器。如你所料，并行接口比串行接口快得多，因为并行-串行和串行-并行的解/译码步骤被省略了。而并行传输的缺点是：需要足够数量的传输线(导线)来传输单独的数字。
  

同步与异步通讯

根据通讯的数据同步方式，又分为同步和异步两种，可以根据通讯过程中是否有使用到时钟信号进行简单的区分。

在同步通讯中，收发设备双方会使用一根信号线表示时钟信号，在时钟信号的驱动下双方进行协调， 同步数据，见图 同步通讯 。 通讯中通常双方会统一规定在时钟信号的上升沿或下降沿对数据线进行采样。

同步通信的数据帧组成一般是：同步信号+若干数据。在最前面是个同步信号，接收端接收数据分析出同步信号之后，就认为后边的数据都是实际传输的数据了。理论上来说同步通信一个数据帧里面的若干数据的位数是不受限制的。

同步通信中，数据之间是不能有间隔的，因为双方在同一个时钟下工作，这边接收的，必然是另一边发送的。在同步信号之后，认为所有的数据都是实际数据，所以当没有信息要传输是，同步信号要填上空字符。
  

异步通信是一种常用的通信方式，发送字符之间的时间间隔可以是任意的。在异步通讯中不使用时钟信号进行数据同步，它们直接在数据信号中穿插一些同步用的信号位，或者把主体数据进行打包， 以数据帧的格式传输数据，某些通讯中还需要双方约定数据的传输速率，以便更好地同步。

异步通信在发送字符时，所发送的字符之间的时间间隔可以是任意的。因为每一帧的数据都有开始和停止位，他们之间的数据位才是实际数据。所以接收方评判数据是否为完整的一帧数据的方式就是分析这一堆数据中的开始位和停止位。发送端可以在任意时刻开始发送字符，接收端必须时刻做好接收的准备。因为每传输一个数据帧都会有一个开始位和一个停止位，实际数据一般只占到5-8位，这就导致了异步通信的传输效率较低。

同步与异步通信区别：

1.同步通信要求接收端和发送端时钟频率一致，而异步通信不要求时钟同步。
2.同步通信效率高，异步通信效率较低。
3.同步通信较复杂，时钟允许误差较小，而异步通信相对简单，时钟可允许一定误差。
4.同步通信可用于点对多点，而异步通信只适用于点对点。

补充：I2C和SPI由于具有独立的时钟线，因此它们是同步的。在时钟信号的指引下，接收方可以采样数据。然而，串口、CAN和USB没有时钟线，因此需要双方约定一个采样频率，这就是异步通信。为了对齐采样位置，还需要添加一些帧头和帧尾等标识。
同步靠时钟线，异步靠比特率

通讯速率

衡量通讯性能的一个非常重要的参数就是通讯速率，通常以**比特率(Bitrate)**来表示，即每秒钟传输的二进制位数， 单位为比特每秒(bit/s)。

容易与比特率混淆的概念是“波特率”(Baudrate)，它表示每秒钟传输了多少个码元。 而码元是通讯信号调制的概念，通讯中常用时间间隔相同的符号来表示一个二进制数字，这样的信号称为码元。 如常见的通讯传输中，用0V表示数字0，5V表示数字1，那么一个码元可以表示两种状态0和1，所以一个码元等于一个二进制比特位， 此时波特率的大小与比特率一致；如果在通讯传输中，有0V、2V、4V以及6V分别表示二进制数00、01、10、11， 那么每个码元可以表示四种状态，即两个二进制比特位，所以码元数是二进制比特位数的一半，这个时候的波特率为比特率的一半。

因为很多常见的通讯中一个码元都是表示两种状态，人们常常直接以波特率来表示比特率，虽然严格来说没什么错误，但希望您能了解它们的区别。

在计算机科学里，大部分复杂的问题都可以通过分层来简化。如芯片被分为内核层和片上外设；STM32标准库则是在寄存器与用户代码之间的软件层。 对于通讯协议，我们也以分层的方式来理解，最基本的是把它分为物理层和协议层 。物理层规定通讯系统中具有机械、电子功能部分的特性， 确保原始数据在物理媒体的传输。协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准。 简单来说物理层规定我们用嘴巴还是用肢体来交流，协议层则规定我们用中文还是英文来交流。

USART串口

注意：在串口助手的接收模式中有文本模式和HEX模式两种模式，那么它们有什么区别？

文本模式和Hex模式是两种不同的文件编辑或浏览模式，不是完全相同的概念。文本模式通常是指以ASCII编码格式表示文本文件的编辑或浏览模式。在文本模式下，文本文件的内容以可读的字符形式显示，包括字母、数字、符号等，这些字符被转换为计算机能够识别和处理的二进制编码。而Hex模式则是指以十六进制编码格式显示文件内容的编辑或浏览模式。在Hex模式下，文件的内容以16进制数值的形式显示，每个字节（byte）用两个十六进制数表示，从0x00到0xFF，可以查看文件的二进制编码，包括数据、指令、标志位等信息。因此，虽然文本模式和Hex模式都是用于文件编辑或浏览的模式，但它们的显示和处理方式不同，用途也不同。
  

STM32如何才能获取到陀螺仪、蓝牙器等这些外挂模的数据呢？

这就需要我们在这两个设备之间，连接上一根或多根通信线，通过通信线路发送或者接收数据，完成数据交换，从而实现控制外挂模块和读取外挂模块数据的目的。所以在这里，通信的目的是，将一个设备的数据传送到另一个设备，单片机有了通信的功能，就能与众多别的模块互联，极大地扩展了硬件系统。

下面我们分别对串口通讯协议的物理层及协议层进行讲解。

物理层

串口通讯的物理层有很多标准及变种，我们主要讲解RS-232标准 ，RS-232标准主要规定了信号的用途、通讯接口以及信号的电平标准。

使用RS-232标准的串口设备间常见的通讯结构见图 串口通讯结构图 。
  

在上面的通讯方式中，两个通讯设备的“DB9接口”之间通过串口信号线建立起连接，串口信号线中使用“RS-232标准”传输数据信号。 由于RS-232电平标准的信号不能直接被控制器直接识别，所以这些信号会经过一个“电平转换芯片”转换成控制器能识别的“TTL标准”的电平信号，才能实现通讯。
  

电平标准

根据通讯使用的电平标准不同，串口通讯可分为TTL标准及RS-232标准，见表 TTL电平标准与RS232电平标准 。
  

使用RS232与TTL电平校准表示同一个信号时的对比见图 RS-232与TTL电平标准下表示同一个信号 。
  

因为控制器一般使用TTL电平标准，所以常常会使用MAX3232芯片对TTL及RS-232电平的信号进行互相转换。

RS-232信号线

在最初的应用中，RS-232串口标准常用于计算机、路由与调制调解器(MODEN，俗称“猫”)之间的通讯 ，在这种通讯系统中， 设备被分为数据终端设备DTE(计算机、路由)和数据通讯设备DCE(调制调解器)。我们以这种通讯模型讲解它们的信号线连接方式及各个信号线的作用。

在旧式的台式计算机中一般会有RS-232标准的COM口(也称DB9接口)，见图 电脑主板上的COM口及串口线.
  

其中接线口以针式引出信号线的称为公头，以孔式引出信号线的称为母头。在计算机中一般引出公头接口，而在调制调解器设备中引出的一般为母头，使用上图中的串口线即可把它与计算机连接起来。通讯时，串口线中传输的信号就是使用前面讲解的RS-232标准调制的。

在这种应用场合下，DB9接口中的公头及母头的各个引脚的标准信号线接法见图 DB9标准的公头及母头接法 及表 DB9信号线说明 。

上表中的是计算机端的DB9公头标准接法，由于两个通讯设备之间的收发信号(RXD与TXD)应交叉相连， 所以调制调解器端的DB9母头的收发信号接法一般与公头的相反，两个设备之间连接时，只要使用“直通型”的串口线连接起来即可， 见图 计算机与调制调解器的信号线连接 。
  

串口线中的RTS、CTS、DSR、DTR及DCD信号，使用逻辑 1表示信号有效，逻辑0表示信号无效。 例如，当计算机端控制DTR信号线表示为逻辑1时，它是为了告知远端的调制调解器，本机已准备好接收数据，0则表示还没准备就绪。

在目前的其它工业控制使用的串口通讯中，一般只使用RXD、TXD以及GND三条信号线， 直接传输数据信号，而RTS、CTS、DSR、DTR及DCD信号都被裁剪掉了。

协议层

串口通讯的数据包由发送设备通过自身的TXD接口传输到接收设备的RXD接口。在串口通讯的协议层中， 规定了数据包的内容，它由启始位、主体数据、校验位以及停止位组成，通讯双方的数据包格式要约定一致才能正常收发数据， 其组成见图 串口数据包的基本组成 。
  

串口中，每一个字节都装载在一个数据帧里面，每个数据帧都由起始位、数据位和停止位组成.

波特率

本章中主要讲解的是串口异步通讯，异步通讯中由于没有时钟信号(如前面讲解的DB9接口中是没有时钟信号的)， 所以两个通讯设备之间需要约定好波特率，即每个码元的长度，以便对信号进行解码， 图 串口数据包的基本组成中用虚线分开的每一格就是代表一个码元。常见的波特率为4800、9600、115200等。

例如，如果每隔1秒发送一位，那么接收方也必须每隔1秒接收一位。如果接收方过早接收，则可能会重复接收某些位；如果接收方过晚接收，则可能会错过某些位。因此，发送方和接收方必须约定好传输速率，这个速率参数，就是波特率。那反应到波形上，比如我们双方规定波特率为1000bps，那就表示，1s要发1000位，每一位的时间就是1ms，发送方每隔1ms发送一位，接收方每隔1ms接收一位，这就是波特率，它决定了每隔多久发送一位。

通讯的起始和停止信号

起始位，它是标志一个数据帧的开始，固定为低电平。首先，串口的空闲状态是高电平，也就是没有数据传输的时候，然后需要传输的时候，必须要先发送一个起始位，这个起始位必须是低电平，来打破空闲状态的高电平，产生一个下降沿。这个下降沿，就告诉接收设备，这一帧数据要开始了。如果没有起始位，那当我发送8个1的时候，是不是数据线就一直都是高电平，没有任何波动，对吧。这样，接收方怎么知道我发送数据了呢。

同理，在一个字节数据发送完成后，必须要有一个停止位，这个停止位的作用是，用于数据帧间隔，固定为高电平。同时这个停止位，也是为下一个起始位做准备的，如果没有停止位，那当我数据最后一位是0的时候，下次再发送新的一帧，是不是就没法产生下降沿了，对吧。这就是起始位和停止位的作用。起始位固定为0，产生下降沿，表示传输开始；停止位固定为1，把引脚恢复成高电平，方便下一次的下降沿，如果没有数据了，正好引脚也为高电平，代表空闲状态。

数据位：

这里数据位表示数据帧的有效载荷，1为高电平，0为低电平，低位先行。比如我要发送一个字节，是0x0F，那就首先把0F转换为二进制，就是0000 1111，然后低位先行，所以数据要从低位开始发送，也就是1111 0000，像这样，依次放在发送引脚上。所以说如果你想发0x0F这一个字节数据，那就按照波特率要求，定时翻转引脚电平，产生一个这样的波形就行了。
有效数据

在数据包的起始位之后紧接着的就是要传输的主体数据内容，也称为有效数据，有效数据的长度常被约定为5、6、7或8位长。

数据校验

最后看一下校验位，它的用途是，用于数据验证，是根据数据位计算得来的。这里串口，使用的是一种叫奇偶校验的数据验证方法，奇偶校验可以判断数据传输是不是出错了。如果数据出错了，可以选择丢弃或者要求重传，校验可以选择3种方式，无校验、奇校验和偶校验。无校验，就是不需要校验位，波形就是左边这个，起始位、数据位、停止位，总共3个部分。

奇校验要求有效数据和校验位中“1”的个数为奇数，比如一个8位长的有效数据为：01101001，此时总共有4个“1”， 为达到奇校验效果，校验位为“1”，最后传输的数据将是8位的有效数据加上1位的校验位总共9位。

偶校验与奇校验要求刚好相反，要求帧数据和校验位中“1”的个数为偶数， 比如数据帧：11001010，此时数据帧“1”的个数为4个，所以偶校验位为“0”。

0校验是不管有效数据中的内容是什么，校验位总为“0”，1校验是校验位总为“1”。

当然奇偶校验的检出率并不是很高，比如如果有两位数据同时出错。奇偶特性不变，那就校验不出来了，所以奇偶校验只能保证一定程度上的数据校验。如果想要更高的检出率，可以了解一下CRC校验，这个校验会更加好用，当然也会更复杂。我们这个STM32内部也有CRC的外设，可以了解一下，那到这里，串口的时序我们就了解了。

说明：我们这里的数据位，有两种表示方法，一种是把校验位作为数据位的一部分，分为8位数据和9位数据，其中9位数据，就是8位有效载荷和1位校验位；另一种就是把数据位和校验位独立开，数据位就是有效载荷，校验位就是独立的1位，像我这上面的描述，就是把数据位和校验位分开描述了，在串口助手里也是分开描述，总之，无论是合在一起，还是分开描述，描述的都是同一个东西，这个应该也好理解。

串口时序

总结一下就是，TX引脚输出定时翻转的高低电平，RX引脚定时读取引脚的高低电平。每个字节的数据加上起始位、停止位、可选的校验位，打包为数据帧，依次输出在TX引脚，另一端RX引脚依次接收，这样就完成了字节数据的传递，这就是串口通信。

STM32的USART串口

另外我们经常还会遇到串口，叫UART，少了个S，就是通用异步收发器，一般我们串口很少使用这个同步功能，所以USART和UART使用起来，也没有什么区别。其实这个STM32的USART同步模式，只是多了个时钟输出而已，它只支持时钟输出，不支持时钟输入，所以这个同步模式更多的是为了，兼容别的协议或者特殊用途而设计的，并不支持两个USART之间进行同步通信。所以我们学习串口，主要还是异步通信。
  

串行通信一般是以帧格式传输数据，即是一帧一帧的传输，每帧包含有起始信号、数据信息、停止信息， 可能还有校验信息。USART就是对这些传输参数有具体规定，当然也不是只有唯一一个参数值，很多参数值都可以自定义设置，只是增强它的兼容性。

我们之前学习了串口的协议，串口主要就是靠收发这样的、约定好的波形来进行通信的，那这个USART外设，就是串口通信的硬件支持电路。
  

这个同步模式，就是多了个时钟CLK的输出；硬件流控制，比如A设备的TX脚向B设备的RX脚发送数据，A设备一直在发，发的太快了，B处理不过来，如果没有硬件流控制，那B就只能抛弃新数据或者覆盖原数据了。如果有硬件流控制，在硬件电路上，会多出一根线，如果B没准备好接收，就置高电平，如果准备好了，就置低电平。A接收到了B反馈的准备信号，就只会在B准备好的时候，才发数据，如果B没准备好，那数据就不会发送出去。这就是硬件流控制，可以防止因为B处理慢而导致数据丢失的问题；之后DMA，是这个串口支持DMA进行数据转运，可以使用DMA转运数据，减轻CPU的负担；最后，智能卡、IrDA、LIN，这些是其他的一些协议。因为这些协议和串口是非常的像，所以STM32就对USART加了一些小改动，就能兼容这么多协议了，不过我们一般不用，像这些协议，Up主也都没用过。

USART框图详解

引脚部分：

TX： 发送数据输出引脚。

RX： 接收数据输入引脚。

SCLK： 发送器时钟输出引脚。这个引脚仅适用于同步模式。

下面这里的SWRX、IRDA_OUT/IN这些是智能卡和IrDA通信的引脚，我们不用这些协议，所以这些引脚就不用管的。

SW_RX： 数据接收引脚，只用于单线和智能卡模式，属于内部引脚，没有具体外部引脚。
nRTS： 请求以发送(Request To Send)，n表示低电平有效。如果使能RTS流控制，当USART接收器准备好接收新数据时就会将nRTS变成低电平； 当接收寄存器已满时，nRTS将被设置为高电平。该引脚只适用于硬件流控制。

nCTS： 清除以发送(Clear To Send)，n表示低电平有效。如果使能CTS流控制，发送器在发送下一帧数据之前会检测nCTS引脚， 如果为低电平，表示可以发送数据，如果为高电平则在发送完当前数据帧之后停止发送。该引脚只适用于硬件流控制。

数据寄存器：

USART_DR包含了已发送的数据或者接收到的数据。USART_DR实际是包含了两个寄存器，一个专门用于发送的可写TDR， 一个专门用于接收的可读RDR。这两个寄存器占用同一个地址在程序上，只表现为一个寄存器。当进行发送操作时，往USART_DR写入数据会自动存储在TDR内；当进行读取操作时，向USART_DR读取数据会自动提取RDR数据。

USART数据寄存器(USART_DR)只有低9位有效，并且第9位数据是否有效要取决于USART控制寄存器1(USART_CR1)的M位设置， 当M位为0时表示8位数据字长，当M位为1表示9位数据字长，我们一般使用8位数据字长。

TDR和RDR都是介于系统总线和移位寄存器之间。串行通信是一个位一个位传输的，发送时把TDR内容转移到发送移位寄存器， 然后把移位寄存器数据每一位发送出去，接收时把接收到的每一位顺序保存在接收移位寄存器内然后才转移到RDR。

USART支持DMA传输，可以实现高速数据传输，具体DMA使用将在DMA章节讲解。

移位寄存器：

然后往下看，下面是两个移位寄存器，一个用于发送，一个用于接收。发送移位寄存器的作用就是，把一个字节的数据一位一位地移出去，正好对应串口协议的波形的数据位。
这两个寄存器是怎么工作的呢？（图中主要讲的是发送寄存器）

注意一下，当TXE标志位置1时，数据其实还没有发送出去，只要数据从TDR转移到发送移位寄存器了，TXE就会置1，我们就可以写入新的数据了。【就是发送数据寄存器里一直有数据，而发送移位寄存器里的数据一旦移位完成，那么发送数据寄存器里的数据就会立刻传输进入发送移位寄存器里再次传输】

看一下接收端这里，也是类似的。数据从RX引脚通向接收移位寄存器，在接收器控制的驱动下，一位一位地读取RX电平，先放在最高位，然后向右移，移位8次之后，就能接收一个字节了。同样，因为串口协议规定是低位先行，所以接收移位寄存器是从高位往低位这个方向移动的。之后，当一个字节移位完成之后，这一个字节的数据就会整体地，一下子转移到接收数据寄存器RDR里来，在转移的过程中，也会置一个标志位叫RXNE （RXNot Empty），接收数据寄存器非空，当我们检测到RXNE置1之后，就可以把数据读走了。同样，这里也是两个寄存器进行缓存，当数据从移位寄存器转移到RDR时，就可以直接移位接收下一帧数据了。

这就是USART外设整个的工作流程，其实讲到这里，这个外设的主要功能就差不多了。大体上，就是数据寄存器和移位寄存器，发送移位寄存器往TX引脚移位，接收移位寄存器从RX引脚移位。当然发送还需要加上帧头帧尾，接收还需要剔除帧头帧尾，这些操作，它内部有电路会自动执行。我们知道有硬件帮我们做了这些工作就行了

接着我们继续看一下下面的控制部分和一些其他的增强功能

硬件流控：

下面这里是发送器控制，它就是用来控制发送移位寄存器的工作的；接收器控制，用来控制接收移位寄存器的工作；然后左边这里，有一个硬件数据流控，也就是硬件流控制，简称流控。

这里流控有两个引脚，一个是nRTS，一个是nCTS。nRTS（Request To Send）是请求发送，是输出脚，也就是告诉别人，我当前能不能接收；nCTS （Clear To Send）是清除发送，是输入脚，也就是用于接收别人nRTS的信号的。
  

这里前面加个n意思是低电平有效，那这两个脚上怎么玩的呢？

首先，我们需要找到一个支持流控的串口，并将它的TX连接到我们的RX。同时，我们的RTS需要输出一个接收反馈信号，并将其连接到对方的CTS。当我们可以接收数据时，RTS会置为低电平，请求对方发送。对方的CTS接收到信号后，就可以继续发送数据。如果处理不过来，比如接收数据寄存器未及时读取，导致新数据无法接收，此时RTS会置为高电平，对方的CTS接收到信号后，就会暂停发送，直到接收数据寄存器被读取，RTS重新置为低电平，数据才会继续发送。

当我们的TX向对方发送数据时，对方的RTS会连接到我们的CTS，用于判断对方是否可以接收数据。TX和CTS是一对对应的信号，RX和RTS也是一对对应的信号。此外，CTS和RTS之间也需要交叉连接，这就是流控的工作模式。然而，我们一般不使用流控，因此只需要了解一下即可。（少用原因应该是多消耗两根通信线）

SCLK控制：

接着继续看右边这个模块，这部分电路用于产生同步的时钟信号，它是配合发送移位寄存器输出的，发送寄存器每移位一次，同步时钟电平就跳变一个周期。时钟告诉对方，我移出去一位数据，你看要不要让我这个时钟信号来指导你接收一下？当然这个时钟只支持输出，不支持输入，所以两个USART之间，不能实现同步的串口通信。

那这个时钟信号有什么用呢？
兼容别的协议。比如串口加上时钟之后，就跟SPI协议特别像,所以有了时钟输出的串口，就可以兼容SPI。另外这个时钟也可以做自适应波特率，比如接收设备不确定发送设备给的什么波特率，然后再计算得到波特率，不过这就需要另外写程序来实现这个功能了。这个时钟功能，我们一般不用，所以也是了解一下就行

唤醒单元：

这部分的作用是实现串口挂载多设备。我们之前说，串口一般是点对点的通信（只支持两个设备互相通信）。而多设备，在一条总线上，可以接多个从设备，每个设备分配一个地址，我想跟某个设备通信，就先进行寻址，确定通信对象。那回到这里，这个唤醒单元就可以用来实现多设备的功能，在这里可以给串口分配一个地址，当你发送指定地址时，此设备唤醒开始工作，当你发送别的设备地址时，别的设备就唤醒工作，这个设备没收到地址，就会保持沉默。这样就可以实现多设备的串口通信了，这部分功能我们一般不用。

中断输出控制：

中断申请位，就是状态寄存器这里的各种标志位，状态寄存器这里，有两个标志位比较重要，一个是TXE发送寄存器空，另一个是RXNE接收寄存器非空，这两个是判断发送状态和接收状态的必要标志位，剩下的标志位，了解一下就行。中断输出控制这里，就是配置中断是不是能通向NVIC，这个应该好理解

波特率发生器部分：

波特率发生器其实就是分频器，APB时钟进行分频，得到发送和接收移位的时钟。看一下，这里时钟输入是fPCLKx（x=1或2），（USART1挂载在APB2，所以就是PCLK2的时钟，一般是72M；其他的USART都挂载在APB1，所以是PCLK1的时钟，一般是36M）之后这个时钟进行一个分频，除一个USARTDIV的分频系数，并且分为了整数部分和小数部分，因为有些波特率，用72M除一个整数的话，可能除不尽，会有误差。所以这里分频系数是支持小数点后4位的，分频就更加精准，之后分频完之后，还要再除个16，得到发送器时钟和接收器时钟，通向控制部分。然后右边这里，如果TE (TX Enable）为1，就是发送器使能了，发送部分的波特率就有效；如果RE（RX Enable）为1，就是接收器使能了，接收部分的波特率就有效。

然后剩下还有一些寄存器的指示
比如各个CR控制寄存器的哪一位控制哪一部分电路，SR状态寄存器都有哪些标志位，这些可以自己看看手册里的寄存器描述，那里的描述比这里清晰很多

引脚定义表，这里复用功能这一栏，就给出了每个USART它的各个引脚都是复用在了哪个GPIO上的。

这些引脚都必须按照引脚定义里的规定来，或者看一下重映射这里，有没有重映射，这里有USART1的重映射，所以有机会换一次口，剩下引脚，就没有机会作为USART1的接口了。

USART基本结构

那到这里，USART的基本结构就讲完了。

几个小细节
数据帧：
这个图，是在程序中配置8位字长和9位字长的波形对比。这里的字长，就是我们前面说的数据位长度。他这里的字长，是包含校验位的，是这种描述方式。

总的来说，这里有4种选择，9位字长，有校验或无校验；8位字长，有校验或无校验。但我们最好选择9位字长 有校验，或8位字长 无校验，这两种，这样每一帧的有效载荷都是1字节，这样才舒服。

配置停止位：
那最后这些时钟什么的，和上面也都是类似的
接下来我们继续来看这个数据帧，看一下不同停止位的波形变化。STM32的串口，可以配置停止位长度为0.5、1、1.5、2，这四种。

这四种参数的区别，就是停止位的时长不一样。第一个是1个停止位，这时停止位的时长就和数据位的一位，时长一样；然后是1.5个停止位，这时的停止位就是数据位一位，时长的1.5倍；2个停止位，那停止位时长就是2倍；0.5个停止位，时长就是0.5倍。这个也好理解，就是控制停止位时长的，一般选择1位停止位就行了，其他的参数不太常用。这个是停止位。

起始位侦测和数据采样：

那之后，我们继续来看一些细节问题，这两个图展示的是USART电路输入数据的一些策略。对于串口来说，根据我们前面的介绍，可以想到，串口的输出TX应该是比输入RX简单很多，输出你就定时翻转TX引脚高低电平就行了。但是输入，就复杂一些。你不仅要保证，输入的采样频率和波特率一致，还要保证每次输入采样的位置，【要正好处于每一位的正中间，只有在每一位的正中间采样，这样高低电平读进来，才是最可靠的，如果你采样点过于靠前或靠后，那有可能高低电平还正在翻转，电平还不稳定，或者稍有误差，数据就采样错了】。另外，输入最好还要对噪声有一定的判断能力，如果是噪声，最好能置个标志位提醒我一下，这些就是输入数据所面临的问题。
那我们来看一下STM32是如何来设计输入电路的呢？

第一个图展示了USART的起始位侦测。当输入电路侦测到数据帧的起始位后，将以波特率的频率连续采样一帧数据。同时，从起始位开始，采样位置要对齐到位的正中间。只要第一位对齐了，后面就都是对齐的。

为了实现这些功能，输入电路对采样时钟进行了细分，以波特率的16倍频率进行采样。在一位的时间里，可以进行16次采样。比如最开始时，空闲状态为高电平，采样一直是1。在某个位置突然采到0，说明两次采样之间出现了下降沿，如果没有噪声，那之后就应该是起始位了。在起始位，会进行连续16次采样，没有噪声的话，这16次采样肯定都是0。但是实际电路还是会存在一些噪声，所以这里即使出现下降沿了，后续也要再采样几次以防万一。

根据手册描述，接收电路在下降沿之后的第3次、5次、7次进行一批采样，在第8次、9次、10次再进行一批采样。这两批采样都要求每3位里面至少应有2个0。如果没有噪声，那肯定全是0，满足情况；如果有一些轻微的噪声导致3位里面只有两个0，另一个是1，那也算是检测到了起始位（但是在状态寄存器里会置一个NE（Noise Error），提醒你数据收到了但是有噪声，你悠着点用）；如果3位里面只有1个0，那就不算检测到了起始位，可能前面那个下降沿是噪声导致的，这时电路就忽略前面的数据重新开始捕捉下降沿。

这就是STM32的串口在接收过程中对噪声的处理。如果通过了这个起始位侦测那接收状态就由空闲变为接收起始位同时第8、9、10次采样的位置就正好是起始位的正中间。之后接收数据位时就在第8、9、10次进行采样这样就能保证采样位置在位的正中间了。这就是起始位侦测和采样位置对齐的策略。

那紧跟着，我们就可以看这个数据采样的流程了。

这里，从1到16，是一个数据位的时间长度，在一个数据位，有16个采样时钟，由于起始位侦测已经对齐了采样时钟，所以，这里就直接在第8、9、10次采样数据位。为了保证数据的可靠性，这里是连续采样3次，没有噪声的理想情况下，这3次肯定全为1或者全为0，全为1，就认为收到了1，全为0，就认为收到了0；如果有噪声，导致3次采样不是全为1或者全为0，那它就按照2：1的规则来，2次为1，就认为收到了1，2次为0，就认为收到了0，在这种情况下，噪声标志位NE也会置1，告诉你，我收到数据了，但是有噪声，你悠着点用，这就是检测噪声的数据采样，可见STM32对这个电路的设计考虑还是很充分的

波特率发生器：
那最后，我们再来看一下波特率发生器

为什么这里公式有个16，因为它内部还有一个16倍波特率的采样时钟，所以这里输入时钟/DV要等于16倍的波特率，最终计算波特率，自然要多除一个16了。

举个例子，比如我要配置USART1为9600的波特率，那如何配置这个BRR寄存器呢？
我们代入公式，就是9600等于 USART1的时钟是72M 除 16倍的DIV，解得，DIV=72M/9600/16，最终等于468.75，则二进制数是11101 0100.11v。所以最终写到这个寄存器就是整数部分为11101 0100，前面多出来的补0，小数部分为11，后面多出来的补0。这就是根据波特率写BRR寄存器的方法，了解一下，不过，我们用库函数配置的话，就非常方便，需要多少波特率，直接写就行了，库函数会自动帮我们算。

手册讲解
USB转串口模块的内部电路图

代码实战：串口发送&&串口发送+接受

9-1串口发送：

下面这个是我们的USB转串口的模块，这里有个跳线帽，上节也说过，要插在VCC和3V3这两个脚上，选择通信的TTL电平为3.3V，然后通信引脚，TXD和RXD，要接在STM32的PA9和PA10口。为什么是这两个口呢，我们看一下引脚定义表就知道USART1的TX是PA9, RX是PA10，我们计划用USART1进行通信，所以就选这两个脚。TX和RX交叉连接，这边一定要注意，别接错了。然后，两个设备之间要把负极接在一起，进行共地，一般多个系统之间互连，都要进行共地。最后，这个串口模块和STLINK都要插在电脑上，这样，STM32和串口模块都有独立供电，所以这里通信的电源正极就不需要接了。
  

当然我们第一个代码，只有STM32发送的部分，所以，通信线只有这个发送的有用，另一根线，第一个代码没有用到，暂时可以不接，在我们下一个串口发送+接收的代码，两根通信线就都需要接了。所以我们把这两根通信线一起都接上吧，这样两个代码的接线图是一模一样的。

老规矩，上来先写一个初始化函数

第一步，开启时钟，把需要用的USART和GPIO的时钟打开
第二步，GPIO初始化，把TX配置成复用输出，RX配置成输入
第三步，配置USART，直接使用一个结构体,就可以把这里所有的参数都配置好了
第四步，如果你只需要发送的功能，就直接开启USART，初始化就结束了。如果你需要接收的功能，可能还需要配置中断，那就在开启USART之前，再加上ITConfig和NVIC的代码就行了。
那初始化完成之后，如果要发送数据，调用一个发送函数就行了；如果要接收数据，就调用接收的函数；如果要获取发送和接收的状态，就调用获取标志位的函数，这就是USART外设的使用思路。

Serial.c部分：

#include "stm32f10x.h"                  // Device header
#include 
#include 

/**
  * 函    数：串口初始化
  * 参    数：无
  * 返 回 值：无
  */
void Serial_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA9引脚初始化为复用推挽输出
	
	/*USART初始化*/
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 9600;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx;			//模式，选择为发送模式
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART1, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	/*USART使能*/
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i  Length; i ++)		//遍历数组
	{
		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != ''; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：次方函数（内部使用）
  * 返 回 值：返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

/**
  * 函    数：串口发送数字
  * 参    数：Number 要发送的数字，范围：0~4294967295
  * 参    数：Length 要发送数字的长度，范围：0~10
  * 返 回 值：无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i  Length; i ++)		//根据数字长度遍历数字的每一位
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	//依次调用Serial_SendByte发送每位数字
	}
}

/**
  * 函    数：使用printf需要重定向的底层函数
  * 参    数：保持原始格式即可，无需变动
  * 返 回 值：保持原始格式即可，无需变动
  */
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

/**
  * 函    数：自己封装的prinf函数
  * 参    数：format 格式化字符串
  * 参    数：... 可变的参数列表
  * 返 回 值：无
  */
void Serial_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Serial_SendString(String);		//串口发送字符数组（字符串）
}

mian.c部分：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"

int main(void)
{
	/*模块初始化*/
	OLED_Init();						//OLED初始化
	
	Serial_Init();						//串口初始化
	
	/*串口基本函数*/
	Serial_SendByte(0x41);				//串口发送一个字节数据0x41
	
	uint8_t MyArray[] = {0x42, 0x43, 0x44, 0x45};	//定义数组
	Serial_SendArray(MyArray, 4);		//串口发送一个数组
	
	Serial_SendString("rnNum1=");		//串口发送字符串
	
	Serial_SendNumber(111, 3);			//串口发送数字
	
	/*下述3种方法可实现printf的效果*/
	
	/*方法1：直接重定向printf，但printf函数只有一个，此方法不能在多处使用*/
	printf("rnNum2=%d", 222);			//串口发送printf打印的格式化字符串
										//需要重定向fputc函数，并在工程选项里勾选Use MicroLIB
	
	/*方法2：使用sprintf打印到字符数组，再用串口发送字符数组，此方法打印到字符数组，之后想怎么处理都可以，可在多处使用*/
	char String[100];					//定义字符数组
	sprintf(String, "rnNum3=%d", 333);//使用sprintf，把格式化字符串打印到字符数组
	Serial_SendString(String);			//串口发送字符数组（字符串）
	
	/*方法3：将sprintf函数封装起来，实现专用的printf，此方法就是把方法2封装起来，更加简洁实用，可在多处使用*/
	Serial_Printf("rnNum4=%d", 444);	//串口打印字符串，使用自己封装的函数实现printf的效果
	Serial_Printf("rn");
	
	while (1)
	{
		
	}
}

9-2 串口发送+接受

Serial.c部分：

#include "stm32f10x.h"                  // Device header
#include 
#include 

uint8_t Serial_RxData;		//定义串口接收的数据变量
uint8_t Serial_RxFlag;		//定义串口接收的标志位变量

/**
  * 函    数：串口初始化
  * 参    数：无
  * 返 回 值：无
  */
void Serial_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA9引脚初始化为复用推挽输出
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA10引脚初始化为上拉输入
	
	/*USART初始化*/
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 9600;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	//模式，发送模式和接收模式均选择
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART1, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	/*中断输出配置*/
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			//开启串口接收数据的中断
	
	/*NVIC中断分组*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			//配置NVIC为分组2
	
	/*NVIC配置*/
	NVIC_InitTypeDef NVIC_InitStructure;					//定义结构体变量
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		//选择配置NVIC的USART1线
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//指定NVIC线路使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		//指定NVIC线路的抢占优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		//指定NVIC线路的响应优先级为1
	NVIC_Init(&NVIC_InitStructure);							//将结构体变量交给NVIC_Init，配置NVIC外设
	
	/*USART使能*/
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i  Length; i ++)		//遍历数组
	{
		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != ''; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：次方函数（内部使用）
  * 返 回 值：返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

/**
  * 函    数：串口发送数字
  * 参    数：Number 要发送的数字，范围：0~4294967295
  * 参    数：Length 要发送数字的长度，范围：0~10
  * 返 回 值：无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i  Length; i ++)		//根据数字长度遍历数字的每一位
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	//依次调用Serial_SendByte发送每位数字
	}
}

/**
  * 函    数：使用printf需要重定向的底层函数
  * 参    数：保持原始格式即可，无需变动
  * 返 回 值：保持原始格式即可，无需变动
  */
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

/**
  * 函    数：自己封装的prinf函数
  * 参    数：format 格式化字符串
  * 参    数：... 可变的参数列表
  * 返 回 值：无
  */
void Serial_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Serial_SendString(String);		//串口发送字符数组（字符串）
}

/**
  * 函    数：获取串口接收标志位
  * 参    数：无
  * 返 回 值：串口接收标志位，范围：0~1，接收到数据后，标志位置1，读取后标志位自动清零
  */
uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)			//如果标志位为1
	{
		Serial_RxFlag = 0;
		return 1;					//则返回1，并自动清零标志位
	}
	return 0;						//如果标志位为0，则返回0
}

/**
  * 函    数：获取串口接收的数据
  * 参    数：无
  * 返 回 值：接收的数据，范围：0~255
  */
uint8_t Serial_GetRxData(void)
{
	return Serial_RxData;			//返回接收的数据变量
}

/**
  * 函    数：USART1中断函数
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数为中断函数，无需调用，中断触发后自动执行
  *           函数名为预留的指定名称，可以从启动文件复制
  *           请确保函数名正确，不能有任何差异，否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)		//判断是否是USART1的接收事件触发的中断
	{
		Serial_RxData = USART_ReceiveData(USART1);				//读取数据寄存器，存放在接收的数据变量
		Serial_RxFlag = 1;										//置接收标志位变量为1
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);			//清除USART1的RXNE标志位
																//读取数据寄存器会自动清除此标志位
																//如果已经读取了数据寄存器，也可以不执行此代码
	}
}

main.c部分：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"

uint8_t RxData;			//定义用于接收串口数据的变量

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	
	/*显示静态字符串*/
	OLED_ShowString(1, 1, "RxData:");
	
	/*串口初始化*/
	Serial_Init();		//串口初始化
	
	while (1)
	{
		if (Serial_GetRxFlag() == 1)			//检查串口接收数据的标志位
		{
			RxData = Serial_GetRxData();		//获取串口接收的数据
			Serial_SendByte(RxData);			//串口将收到的数据回传回去，用于测试
			OLED_ShowHexNum(1, 8, RxData, 2);	//显示串口接收的数据
		}
	}
}

USART串口数据包
先来看两张图，是关于我规定的数据包格式，一种是HEX数据包，一种是文本数据包，之后两个图，展示的就是接收数据包的思路。

接着我们来研究几个问题：

第一个问题：包头包尾和数据载荷重复的问题，这里定义FF为包头，FE为包尾，如果我传输的数据本身就是FF和FE怎么办呢？那这个问题确实存在，如果数据和包头包尾重复，可能会引起误判。对应这个问题我们有如下几种解决方法：第一种，限制载荷数据的范围。如果可以的话，我们可以在发送的时候，对数据进行限幅，比如XYZ，3个数据，变化范围都可以是0~100 那就好办了，我们可以在载荷中只发送0-100的数据，这样就不会和包头包尾重复了；第二种，如果无法避免载荷数据和包头包尾重复，那我们就尽量使用固定长度的数据包。这样由于载荷数据是固定的，只要我们通过包头包尾对齐了数据，我们就可以严格知道，哪个数据应该是包头包尾，哪个数据应该是载荷数据。在接收载荷数据的时候，我们并不会判断它是否是包头包尾，而在接收包头包尾的时候，我们会判断它是不是确实是包头包尾，用于数据对齐。这样，在经过几个数据包的对齐之后，剩下的数据包应该就不会出现问题了；第三种，增加包头包尾的数量，并且尽量让它呈现出载荷数据出现不了的状态。比如我们使用FF、FE作为包头，FD、FC作为包尾，这样也可以避免载荷数据和包头包尾重复的情况发生

第二个问题：这个包头包尾并不是全部都需要的，比如我们可以只要一个包头，把包尾删掉，这样数据包的格式就是，一个包头FF，加4个数据，这样也是可以的。当检测到FF，开始接收，收够4个字节后，置标志位，一个数据包接收完成，这样也可以。不过这样的话，载荷和包头重复的问题会更严重一些，比如最严重的情况下，我载荷全是FF，包头也是FF，那你肯定不知道哪个是包头了，而加上了FE作为包尾，无论数据怎么变化，都是可以分辨出包头包尾的。

第三个问题：固定包长和可变包长的选择问题，对应HEX数据包来说,如果你的载荷会出现和包头包尾重复的情况,那就最好选择固定包长,这样可以避免接收错误,如果你又会重复，又选择可变包长那数据很容易就乱套了；如果载荷不会和包头包尾重复，那可以选择可变包长，数据长度，像这样，4位、3位、等等，1位、10位，来回任意变，肯定都没问题。因为包头包尾是唯一的，只要出现包头，就开始数据包，只要出现包尾，就结束数据包，这样就非常灵活了，这就是固定包长和可变包长选择的问题。

最后一个问题：各种数据转换为字节流的问题。这里数据包都是一个字节一个字节组成的，如果你想发送16位的整型数据、32位的整型数据，float、double，甚至是结构体，其实都没问题，因为它们内部其实都是由一个字节一个字节组成的，只需要用一个uint8_t的指针指向它，把它们当做一个字节数组发送就行了。

好，有关HEX数据包定义的内容，就讲这么多，接下来看一下文本数据包。

文本数据包和HEX数据包分别对应了文本模式和HEX模式。在HEX数据包中，数据以原始字节形式呈现。而在文本数据包中，每个字节经过了一层编码和译码，最终以文本格式呈现。实际上，每个文本字符背后都有一个字节的HEX数据。

综上所述，我们需要根据实际场景来选择和设计数据包格式。在需要直接传输和简单解析原始数据的情况下，HEX数据包是更好的选择。而在需要输入指令进行人机交互的场合，文本数据包则更为适用。

好，数据包格式的定义讲完了，接下来我们就来学一下数据包的收发流程。

首先，发送数据包的过程相对简单。在发送HEX数据包时，可以通过定义一个数组，填充数据，然后使用之前我们写过的SendArray函数发送即可。在发送文本数据包时，可以通过写一个字符串，然后调用SendString函数发送。因此，发送数据包的过程是可控的，我们可以根据需要发送任何类型的数据包。相比之下，接收数据包的过程较为复杂。

那接下来，接收一个数据包，这就比较复杂了，我们来学习一下，我这里演示了固定包长HEX数据包的接收方法，和可变包长文本数据包的接收方法，其他的数据包也都可以套用这个形式，等会儿我们写程序就会根据这里面的流程来。

我们先看一下如何来接收这个固定包长的HEX数据包。要接收固定包长的HEX数据包，我们需要设计一个状态机来处理。根据之前的代码，我们知道每当收到一个字节，程序会进入中断。在中断函数里，我们可以获取这个字节，但获取后需要退出中断。因此，每个收到的数据都是独立的过程，而数据包则具有前后关联性，包括包头、数据和包尾。为了处理这三种状态，我们需要设计一个能够记住不同状态的机制，并在不同状态下执行不同的操作，同时进行状态合理转移。这种程序设计思维就是“状态机”。
  

这就是使用状态机接收数据包的思路。这个状态机其实是一种很广泛的编程思路，在很多地方都可以用到，使用的基本步骤是，先根据项目要求定义状态，画几个圈，然后考虑好各个状态在什么情况下会进行转移，如何转移，画好线和转移条件，最后根据这个图来进行编程，这样思维就会非常清晰了。
  
那接下来继续，我们来看一下这个可变包长、文本数据包的接收流程。
  

好，到这里，我们这个数据包的，定义、分类、优缺点和注意事项，就讲完了，接下来，我们就来写程序，验证一下刚才所学的内容吧。

代码实战：串口收发HEX数据包&&串口收发文本数据包

9-3 串口收发HEX数据包

Serial.c部分：

#include "stm32f10x.h"                  // Device header
#include 
#include 

uint8_t Serial_TxPacket[4];				//定义发送数据包数组，数据包格式：FF 01 02 03 04 FE
uint8_t Serial_RxPacket[4];				//定义接收数据包数组
uint8_t Serial_RxFlag;					//定义接收数据包标志位

/**
  * 函    数：串口初始化
  * 参    数：无
  * 返 回 值：无
  */
void Serial_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA9引脚初始化为复用推挽输出
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA10引脚初始化为上拉输入
	
	/*USART初始化*/
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 9600;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	//模式，发送模式和接收模式均选择
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART1, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	/*中断输出配置*/
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			//开启串口接收数据的中断
	
	/*NVIC中断分组*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			//配置NVIC为分组2
	
	/*NVIC配置*/
	NVIC_InitTypeDef NVIC_InitStructure;					//定义结构体变量
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		//选择配置NVIC的USART1线
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//指定NVIC线路使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		//指定NVIC线路的抢占优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		//指定NVIC线路的响应优先级为1
	NVIC_Init(&NVIC_InitStructure);							//将结构体变量交给NVIC_Init，配置NVIC外设
	
	/*USART使能*/
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i  Length; i ++)		//遍历数组
	{
		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != ''; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：次方函数（内部使用）
  * 返 回 值：返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

/**
  * 函    数：串口发送数字
  * 参    数：Number 要发送的数字，范围：0~4294967295
  * 参    数：Length 要发送数字的长度，范围：0~10
  * 返 回 值：无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i  Length; i ++)		//根据数字长度遍历数字的每一位
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	//依次调用Serial_SendByte发送每位数字
	}
}

/**
  * 函    数：使用printf需要重定向的底层函数
  * 参    数：保持原始格式即可，无需变动
  * 返 回 值：保持原始格式即可，无需变动
  */
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

/**
  * 函    数：自己封装的prinf函数
  * 参    数：format 格式化字符串
  * 参    数：... 可变的参数列表
  * 返 回 值：无
  */
void Serial_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Serial_SendString(String);		//串口发送字符数组（字符串）
}

/**
  * 函    数：串口发送数据包
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，Serial_TxPacket数组的内容将加上包头（FF）包尾（FE）后，作为数据包发送出去
  */
void Serial_SendPacket(void)
{
	Serial_SendByte(0xFF);
	Serial_SendArray(Serial_TxPacket, 4);
	Serial_SendByte(0xFE);
}

/**
  * 函    数：获取串口接收数据包标志位
  * 参    数：无
  * 返 回 值：串口接收数据包标志位，范围：0~1，接收到数据包后，标志位置1，读取后标志位自动清零
  */
uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)			//如果标志位为1
	{
		Serial_RxFlag = 0;
		return 1;					//则返回1，并自动清零标志位
	}
	return 0;						//如果标志位为0，则返回0
}

/**
  * 函    数：USART1中断函数
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数为中断函数，无需调用，中断触发后自动执行
  *           函数名为预留的指定名称，可以从启动文件复制
  *           请确保函数名正确，不能有任何差异，否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;		//定义表示当前状态机状态的静态变量
	static uint8_t pRxPacket = 0;	//定义表示当前接收数据位置的静态变量
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)		//判断是否是USART1的接收事件触发的中断
	{
		uint8_t RxData = USART_ReceiveData(USART1);				//读取数据寄存器，存放在接收的数据变量
		
		/*使用状态机的思路，依次处理数据包的不同部分*/
		
		/*当前状态为0，接收数据包包头*/
		if (RxState == 0)
		{
			if (RxData == 0xFF)			//如果数据确实是包头
			{
				RxState = 1;			//置下一个状态
				pRxPacket = 0;			//数据包的位置归零
			}
		}
		/*当前状态为1，接收数据包数据*/
		else if (RxState == 1)
		{
			Serial_RxPacket[pRxPacket] = RxData;	//将数据存入数据包数组的指定位置
			pRxPacket ++;				//数据包的位置自增
			if (pRxPacket >= 4)			//如果收够4个数据
			{
				RxState = 2;			//置下一个状态
			}
		}
		/*当前状态为2，接收数据包包尾*/
		else if (RxState == 2)
		{
			if (RxData == 0xFE)			//如果数据确实是包尾部
			{
				RxState = 0;			//状态归0
				Serial_RxFlag = 1;		//接收数据包标志位置1，成功接收一个数据包
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);		//清除标志位
	}
}

main.c部分：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "Key.h"

uint8_t KeyNum;			//定义用于接收按键键码的变量

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	Key_Init();			//按键初始化
	Serial_Init();		//串口初始化
	
	/*显示静态字符串*/
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	
	/*设置发送数据包数组的初始值，用于测试*/
	Serial_TxPacket[0] = 0x01;
	Serial_TxPacket[1] = 0x02;
	Serial_TxPacket[2] = 0x03;
	Serial_TxPacket[3] = 0x04;
	
	while (1)
	{
		KeyNum = Key_GetNum();			//获取按键键码
		if (KeyNum == 1)				//按键1按下
		{
			Serial_TxPacket[0] ++;		//测试数据自增
			Serial_TxPacket[1] ++;
			Serial_TxPacket[2] ++;
			Serial_TxPacket[3] ++;
			
			Serial_SendPacket();		//串口发送数据包Serial_TxPacket
			
			OLED_ShowHexNum(2, 1, Serial_TxPacket[0], 2);	//显示发送的数据包
			OLED_ShowHexNum(2, 4, Serial_TxPacket[1], 2);
			OLED_ShowHexNum(2, 7, Serial_TxPacket[2], 2);
			OLED_ShowHexNum(2, 10, Serial_TxPacket[3], 2);
		}
		
		if (Serial_GetRxFlag() == 1)	//如果接收到数据包
		{
			OLED_ShowHexNum(4, 1, Serial_RxPacket[0], 2);	//显示接收的数据包
			OLED_ShowHexNum(4, 4, Serial_RxPacket[1], 2);
			OLED_ShowHexNum(4, 7, Serial_RxPacket[2], 2);
			OLED_ShowHexNum(4, 10, Serial_RxPacket[3], 2);
		}
	}
}

9-4 串口收发文本数据包

Serial.c部分：

#include "stm32f10x.h"                  // Device header
#include 
#include 

char Serial_RxPacket[100];				//定义接收数据包数组，数据包格式"@MSGrn"
uint8_t Serial_RxFlag;					//定义接收数据包标志位

/**
  * 函    数：串口初始化
  * 参    数：无
  * 返 回 值：无
  */
void Serial_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	//开启USART1的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA9引脚初始化为复用推挽输出
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);					//将PA10引脚初始化为上拉输入
	
	/*USART初始化*/
	USART_InitTypeDef USART_InitStructure;					//定义结构体变量
	USART_InitStructure.USART_BaudRate = 9600;				//波特率
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;	//硬件流控制，不需要
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	//模式，发送模式和接收模式均选择
	USART_InitStructure.USART_Parity = USART_Parity_No;		//奇偶校验，不需要
	USART_InitStructure.USART_StopBits = USART_StopBits_1;	//停止位，选择1位
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;		//字长，选择8位
	USART_Init(USART1, &USART_InitStructure);				//将结构体变量交给USART_Init，配置USART1
	
	/*中断输出配置*/
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);			//开启串口接收数据的中断
	
	/*NVIC中断分组*/
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);			//配置NVIC为分组2
	
	/*NVIC配置*/
	NVIC_InitTypeDef NVIC_InitStructure;					//定义结构体变量
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		//选择配置NVIC的USART1线
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//指定NVIC线路使能
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;		//指定NVIC线路的抢占优先级为1
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;		//指定NVIC线路的响应优先级为1
	NVIC_Init(&NVIC_InitStructure);							//将结构体变量交给NVIC_Init，配置NVIC外设
	
	/*USART使能*/
	USART_Cmd(USART1, ENABLE);								//使能USART1，串口开始运行
}

/**
  * 函    数：串口发送一个字节
  * 参    数：Byte 要发送的一个字节
  * 返 回 值：无
  */
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1, Byte);		//将字节数据写入数据寄存器，写入后USART自动生成时序波形
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);	//等待发送完成
	/*下次写入数据寄存器会自动清除发送完成标志位，故此循环后，无需清除标志位*/
}

/**
  * 函    数：串口发送一个数组
  * 参    数：Array 要发送数组的首地址
  * 参    数：Length 要发送数组的长度
  * 返 回 值：无
  */
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
	uint16_t i;
	for (i = 0; i  Length; i ++)		//遍历数组
	{
		Serial_SendByte(Array[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：串口发送一个字符串
  * 参    数：String 要发送字符串的首地址
  * 返 回 值：无
  */
void Serial_SendString(char *String)
{
	uint8_t i;
	for (i = 0; String[i] != ''; i ++)//遍历字符数组（字符串），遇到字符串结束标志位后停止
	{
		Serial_SendByte(String[i]);		//依次调用Serial_SendByte发送每个字节数据
	}
}

/**
  * 函    数：次方函数（内部使用）
  * 返 回 值：返回值等于X的Y次方
  */
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;	//设置结果初值为1
	while (Y --)			//执行Y次
	{
		Result *= X;		//将X累乘到结果
	}
	return Result;
}

/**
  * 函    数：串口发送数字
  * 参    数：Number 要发送的数字，范围：0~4294967295
  * 参    数：Length 要发送数字的长度，范围：0~10
  * 返 回 值：无
  */
void Serial_SendNumber(uint32_t Number, uint8_t Length)
{
	uint8_t i;
	for (i = 0; i  Length; i ++)		//根据数字长度遍历数字的每一位
	{
		Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');	//依次调用Serial_SendByte发送每位数字
	}
}

/**
  * 函    数：使用printf需要重定向的底层函数
  * 参    数：保持原始格式即可，无需变动
  * 返 回 值：保持原始格式即可，无需变动
  */
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);			//将printf的底层重定向到自己的发送字节函数
	return ch;
}

/**
  * 函    数：自己封装的prinf函数
  * 参    数：format 格式化字符串
  * 参    数：... 可变的参数列表
  * 返 回 值：无
  */
void Serial_Printf(char *format, ...)
{
	char String[100];				//定义字符数组
	va_list arg;					//定义可变参数列表数据类型的变量arg
	va_start(arg, format);			//从format开始，接收参数列表到arg变量
	vsprintf(String, format, arg);	//使用vsprintf打印格式化字符串和参数列表到字符数组中
	va_end(arg);					//结束变量arg
	Serial_SendString(String);		//串口发送字符数组（字符串）
}

/**
  * 函    数：USART1中断函数
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数为中断函数，无需调用，中断触发后自动执行
  *           函数名为预留的指定名称，可以从启动文件复制
  *           请确保函数名正确，不能有任何差异，否则中断函数将不能进入
  */
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;		//定义表示当前状态机状态的静态变量
	static uint8_t pRxPacket = 0;	//定义表示当前接收数据位置的静态变量
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)	//判断是否是USART1的接收事件触发的中断
	{
		uint8_t RxData = USART_ReceiveData(USART1);			//读取数据寄存器，存放在接收的数据变量
		
		/*使用状态机的思路，依次处理数据包的不同部分*/
		
		/*当前状态为0，接收数据包包头*/
		if (RxState == 0)
		{
			if (RxData == '@' && Serial_RxFlag == 0)		//如果数据确实是包头，并且上一个数据包已处理完毕
			{
				RxState = 1;			//置下一个状态
				pRxPacket = 0;			//数据包的位置归零
			}
		}
		/*当前状态为1，接收数据包数据，同时判断是否接收到了第一个包尾*/
		else if (RxState == 1)
		{
			if (RxData == 'r')			//如果收到第一个包尾
			{
				RxState = 2;			//置下一个状态
			}
			else						//接收到了正常的数据
			{
				Serial_RxPacket[pRxPacket] = RxData;		//将数据存入数据包数组的指定位置
				pRxPacket ++;			//数据包的位置自增
			}
		}
		/*当前状态为2，接收数据包第二个包尾*/
		else if (RxState == 2)
		{
			if (RxData == 'n')			//如果收到第二个包尾
			{
				RxState = 0;			//状态归0
				Serial_RxPacket[pRxPacket] = '';			//将收到的字符数据包添加一个字符串结束标志
				Serial_RxFlag = 1;		//接收数据包标志位置1，成功接收一个数据包
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);		//清除标志位
	}
}

mian.c部分：

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"
#include "string.h"

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	LED_Init();			//LED初始化
	Serial_Init();		//串口初始化
	
	/*显示静态字符串*/
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	
	while (1)
	{
		if (Serial_RxFlag == 1)		//如果接收到数据包
		{
			OLED_ShowString(4, 1, "                ");
			OLED_ShowString(4, 1, Serial_RxPacket);				//OLED清除指定位置，并显示接收到的数据包
			
			/*将收到的数据包与预设的指令对比，以此决定将要执行的操作*/
			if (strcmp(Serial_RxPacket, "LED_ON") == 0)			//如果收到LED_ON指令
			{
				LED1_ON();										//点亮LED
				Serial_SendString("LED_ON_OKrn");				//串口回传一个字符串LED_ON_OK
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "LED_ON_OK");				//OLED清除指定位置，并显示LED_ON_OK
			}
			else if (strcmp(Serial_RxPacket, "LED_OFF") == 0)	//如果收到LED_OFF指令
			{
				LED1_OFF();										//熄灭LED
				Serial_SendString("LED_OFF_OKrn");			//串口回传一个字符串LED_OFF_OK
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "LED_OFF_OK");			//OLED清除指定位置，并显示LED_OFF_OK
			}
			else						//上述所有条件均不满足，即收到了未知指令
			{
				Serial_SendString("ERROR_COMMANDrn");			//串口回传一个字符串ERROR_COMMAND
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "ERROR_COMMAND");			//OLED清除指定位置，并显示ERROR_COMMAND
			}
			
			Serial_RxFlag = 0;			//处理完成后，需要将接收数据包标志位清零，否则将无法接收后续数据包
		}
	}
}

I2C(mpu6050陀螺仪和加速度计)

I2C通信协议（正在改动）
注：通信协议的设计背景 3:00~10:13

I2C 通讯协议(Inter－Integrated Circuit)是由Phiilps公司开发的，由于它引脚少，硬件实现简单，可扩展性强， 不需要USART、CAN等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。
  I2C总线是一种用于芯片之间进行通信的串行总线。它由两条线组成：串行时钟线（SCL）和串行数据线（SDA）。这种总线允许多个设备在同一条总线上进行通信。

物理层
I2C通讯设备之间的常用连接方式见图

I2C通信协议是一种通用的总线协议。I2C通信协议有以下特征：

(1) 它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个I2C通讯总线中， 可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机。
(2) 一个I2C总线只使用两条总线线路，一条双向串行数据线(SDA) ， 一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。
(3) 每个连接到总线的设备都有一个独立的地址， 主机可以利用这个地址进行不同设备之间的访问。
(4) 总线通过上拉电阻接到电源。当I2C设备空闲时，会输出高阻态， 而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。
(5) 多个主机同时使用总线时，为了防止数据冲突， 会利用仲裁方式决定由哪个设备占用总线。
(6) 具有三种传输模式：标准模式传输速率为100kbit/s ，快速模式为400kbit/s ， 高速模式下可达 3.4Mbit/s，但目前大多I2C设备尚不支持高速模式。
(7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制
SDA数据线在每个SCL的时钟周期传输一位数据，SCL为高电平的时候SDA表示的数据有效。
应答信号和非应答信号I2C的数据和地址传输都带响应。

一主多从是指单片机作为主机，主导I2C总线的运行。挂在I2C总线上的所有外部模块都是从机，只有被主机点名后才能控制I2C总线，不能在未经允许的情况下访问I2C总线，以防止冲突。这就像在课堂上，老师是主机，学生是从机。未经点名允许，学生不能发言，但可以被动地听老师讲课。
  另外，I2C还支持多主多从模型，即多个主机。在多主多从模型中，总线上任何一个模块都可以主动跳出来说，接下来我就是主机，你们都得听我的。这就像在教室里，老师正在讲课，突然一个学生站起来说，打断一下，接下来让我来说，所有同学听我指挥。但是，同一个时间只能有一个人说话，这时就相当于发生了总线冲突。在总线冲突时，I2C协议会进行仲裁，仲裁胜利的一方取得总线控制权，失败的一方自动变回从机。由于时钟线也由主机控制，所以在多主机的模型下还要进行时钟同步。多主机的情况下，协议是比较复杂的。本课程仅使用一主多从模型。
以上是有关I2C的设计背景和基本功能。接下来我们将详细分析I2C如何实现这些功能。  作为一个通信协议，I2C必须在硬件和软件上作出规定。硬件上的规定包括电路的连接方式、端口的输入输出模式等；软件上的规定包括时序的定义、字节的传输方式、高位先行还是低位先行等。这些硬件和软件的规定结合起来构成了一个完整的通信协议。
协议层
  I2C的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。

1.I2C基本读写过程
先看看I2C通讯过程的基本结构，它的通讯过程见图

接下来我们先看一下12C的硬件规定，也就是I2C的硬件电路

I2C的硬件电路

这个图就是I2C的典型电路模型，这个模型采用了一主多从的结构。在左侧，我们可以看到CPU作为主设备，控制着总线并拥有很大的权利。其中，主机对SCL线拥有完全的控制权，无论何时何地，主机都负责掌控SCL线。在空闲状态下，主机还可以主动发起对SDA的控制。但是，从机发送数据或应答时，主机需要将SDA的控制权转交给从机。
接下来，我们看到了一系列被控IC，它们是挂载在12C总线上的从机设备，如姿态传感器、OLED、存储器、时钟模块等。这些从机的权利相对较小。对于SCL时钟线，它们在任何时刻都只能被动的读取，不允许控制SCL线；对于SDA数据线，从机也不允许主动发起控制，只有在主机发送读取从机的命令后，或从机应答时，从机才能短暂地取得SDA的控制权。这就是一主多从模型中协议的规定。
然后我们来看接线部分。所有I2C设备的SCL和SDA都连接在一起。主机的SCL线拉出来，所有从机的SCL都接在这上面。主机的SDA线也是一样，拉出来，所有从机的SDA接在这上面。这就是SCL和SDA的接线方式。
那到现在，我们先不继续往后看了，先忽略这两个电阻，那到现在，假设我们就这样连接，那如何规定每个设备SCL和SDA的输入输出模式呢？
由于现在是一主多从结构，主机拥有SCL的绝对控制权，因此主机的SCL可以配置成推挽输出，所有从机的SCL都配置成浮空输入或上拉输入。数据流向为主机发送、所有从机接收。但是到SDA线这里就比较复杂了，因为这是半双工协议，所以主机的SDA在发送时是输出，在接收时是输入。同样地，从机的SDA也会在输入和输出之间反复切换。如果能够协调好输入输出的切换时机就没有问题。但是这样做的话，如果总线时序没有协调好，就极有可能发生两个引脚同时处于输出的状态。如果此时一个引脚输出高电平，一个引脚输出低电平，就会造成电源短路的情况，这是要极力避免的。
为了避免这种情况的发生，I2C的设计规定所有设备不输出强上拉的高电平，而是采用外置弱上拉电阻加开漏输出的电路结构。这两点规定对应于前面提到的“设备的SCL和SDA均要配置成开漏输出模式”以及“SCL和SDA各添加一个上拉电阻，阻值一般为4.7K左右”。对应上面这个图。

所有的设备，包括CPU和被控IC，它们的引脚内部结构都如上图所示。图左侧展示的是SCL的结构，其中SClk代表SCL；右侧则是SDA的结构，其中DATA代表SDA。引脚的信号输入都可以通过一个数据缓冲器或施密特触发器进行，因为输入对电路无影响，所以任何设备在任何时刻都可以输入。然而，在输出部分，采用的是开漏输出的配置。

正常的推挽输出方式如下：上面一个开关管连接正极，下面一个开关管连接负极。当上面导通时，输出高电平；下面导通时，输出低电平。因为这是通过开关管直接连接到正负极的，所以这是强上拉和强下拉的模式。
而开漏输出呢，就是去掉这个强上拉的开关管，输出低电平时，下管导通，是强下拉，输出高电平时，下管断开，但是没有上管了，此时引脚处于浮空的状态，这就是开漏输出。

和这里图示是一样的，输出低电平，这个开关管导通，引脚直接接地，是强下拉，输出高电平，这个开关管断开，引脚什么都不接，处于浮空状态，这样的话，所有的设备都只能输出低电平而不能输出高电平，为了避免高电平造成的引脚浮空，这时就需要在总线外面，SCL和SDA各外置一个上拉电阻，这是通过一个电阻拉到高电平的，所以这是一个弱上拉。
UP主用弹簧和杆子的模型解释这一段硬件电路设计
这样做的好处是：

第一，完全杜绝了电源短路现象，保证电路的安全。你看所有人无论怎么拉杆子或者放手，杆子都不会处于一个被同时强拉和强推的状态，即使有多个人同时往下拉杆子，也没问题
第二，避免了引脚模式的频繁切换。开漏加弱上拉的模式，同时兼具了输入和输出的功能，你要是想输出，就去拉杆子或放手，操作杆子变化就行了，你要是想输入，就直接放手，然后观察杆子高低就行了，因为开漏模式下，输出高电平就相当于断开引脚，所以在输入之前，可以直接输出高电平，不需要再切换成输入模式了。
第三，就是这个模式会有一个“线与”的现象。就是只要有任意一个或多个设备输出了低电平，总线就处于低电平，只有所有设备都输出高电平，总线才处于高电平。I2C可以利用这个电路特性执行多主机模式下的时钟同步和总线仲裁，所以这里SCL虽然在一主多从模式下可以用推挽输出，但是它仍然采用了开漏加上拉输出的模式，因为在多主机模式下会利用到这个特征。
好，以上就是I2C的硬件电路设计，那接下来，我们就要来学习软件，也就是时序的设计了。

I2C时序设计
首先我们来学习一下I2C规定的一些时序基本单元。

起始和终止条件

起始条件是指SCL高电平期间，SDA从高电平切换到低电平。在I2C总线处于空闲状态时，SCL和SDA都处于高电平状态，由外挂的上拉电阻保持。当主机需要数据收发时，会首先产生一个起始条件。这个起始条件是，SCL保持高电平，然后把SDA拉低，产生一个下降沿。当从机捕获到这个SCL高电平，SDA下降沿信号时，就会进行自身的复位，等待主机的召唤。之后，主机需要将SCL拉低。这样做一方面是占用这个总线，另一方面也是为了方便这些基本单元的拼接。这样，除了起始和终止条件，每个时序单元的SCL都是以低电平开始，低电平结束。

终止条件是，SCL高电平期间，SDA从低电平切换到高电平。SCL先放开并回弹到高电平，SDA再放开并回弹高电平，产生一个上升沿。这个上升沿触发终止条件，同时终止条件之后，SCL和SDA都是高电平，回归到最初的平静状态。这个起始条件和终止条件就类似串口时序里的起始位和停止位。一个完整的数据帧总是以起始条件开始、终止条件结束。另外，起始和终止都是由主机产生的。因此，从机必须始终保持双手放开，不允许主动跳出来去碰总线。如果允许从机这样做，那么就会变成多主机模型，不在本节的讨论范围之内。这就是起始条件和终止条件的含义。

发送一个字节
接着继续看，在起始条件之后，这时就可以紧跟着一个发送一个字节的时序单元，如何发送一个字节呢？

就这样的流程，主机拉低SCL，把数据放在SDA上，主机松开SCL，从机读取SDA的数据，在SCL的同步下，依次进行主机发送和从机接收，循环8次，就发送了8位数据，也就是一个字节，另外注意，这里是高位先行，所以第一位是一个字节的最高位B7，然后依次是次高位B6…

接收一个字节

那我们再继续看最后两个基本单元，就是应答机制的设计。

发送应答和接收应答

发一字节收一位，收一字节发一位

应用：
I2C从机地址
12C的完整时序，主要有指定地址写,当前地址读和指定地址读这3种。
首先注意的是，我们这个12C是一主多从的模型，主机可以访问总线上的任何一个设备，那如何发出指令，来确定要访问的是哪个设备呢？
为了解决这个问题，我们需要为每个从设备分配一个唯一的设备地址。这些地址就像是每个设备的名字，主机通过发送这些地址来确定要与哪个设备通信。

当主机发送一个地址时，所有的从设备都会收到这个地址。但是，只有与发送的地址匹配的设备会响应主机的读写操作。
在I2C总线中，每个挂载的设备的地址必须是唯一的，否则当主机发送一个地址时，多个设备响应，就会导致混乱。
在12C协议标准中，从机设备地址分为7位和10位两种。我们今天主要讨论7位地址，因为它们相对简单且应用广泛。

每个I2C设备在出厂时都会被分配一个7位的地址。例如，MPU6050的7位地址是1101 000，而AT24C02的7位地址是1010 000。不同型号的芯片地址是不同的，但相同型号的芯片地址是相同的。
如果多个相同型号的芯片挂载在同一条总线上，我们可以通过调整地址的最后几位来解决这个问题。例如，MPU6050的地址可以通过ADO引脚来改变，而AT24C02的地址可以通过A0、A1、A2引脚来改变。这样，即使相同型号的芯片，挂载在同一个总线上，也可以通过切换地址低位的方式，保证每个设备的地址都是唯一的。这就是12C设备的从机地址。

下面时序讲解详情
注意：时序里面的RA是接收从机的应答位(Receive Ack, RA)

指定地址写

(Slve Address + R/W) 中最后一位 0=W（写），根据协议规定，紧跟着的单元，就得是接收从机的应答位（Receive Ack， RA），在这个时刻，主机要释放SDA，
所以如果单看主机的波形，应该是这样，

释放SDA之后，引脚电平回弹到高电平，但是根据协议规定，从机要在这个位拉低SDA，所以单看从机的波形，应该是这样（绿色线）

该应答的时候，从机立刻拽住SDA，然后应答结束之后，从机再放开SDA，那现在综合两者的波形，结合线与的特性，在主机释放SDA之后，由于SDA也被从机拽住了，所以主机松手后，SDA并没有回弹高电平，这个过程，就代表从机产生了应答。最终高电平期间，主机读取SDA，发现是0，就说明，我进行寻址，有人给我应答了。如果主机读取SDA，发现是1，就说明，我进行寻址，应答位期间，我松手了，但是没人拽住它，没人给我应答，那就直接产生停止条件吧，并提示一些信息，这就是应答位。
然后这个上升沿，就是应答位结束后，从机释放SDA产生的，从机交出了SDA的控制权，因为从机要在低电平尽快变换数据，所以这个上升沿和SCL的下降沿，几乎是同时发生的。

当前地址读

指定地址读
指定地址读=指定地址写+当前地址读

Sr (Start Repeat)的意思就是重复起始条件，因为指定读写标志位只能是跟着起始条件的第一个字节，所以如果想切换读写方向，只能再来个起始条件。然后起始条件后，重新寻址并且指定读写标志位

代码实战：10-1 软件I2C读写MPU6050

由于我们这个代码使用的是软件I2C，就是用普通的GPIO口，手动翻转电平实现的协议，它并不需要STM32内部的外设资源支持，所以这里的端口（SDA，SCL），其实可以任意指定，不局限于这两个端口，你也可以SCL接PAO，SDA接PB12，或者SCL接PA8,SDA接PA9看，等等等等，接在任意的两个普通的GPIO口就可以。
软件I2C，只需要用gpio的读写函数就行了，就不用I2C的库函数了。

程序的整体框架：

MyI2C.h

#ifndef __MYI2C_H
#define __MYI2C_H

void MyI2C_Init(void);
void MyI2C_Start(void);
void MyI2C_Stop(void);
void MyI2C_SendByte(uint8_t Byte);
uint8_t MyI2C_ReceiveByte(void);
void MyI2C_SendAck(uint8_t AckBit);
uint8_t MyI2C_ReceiveAck(void);

#endif

MyI2C.C

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

/*引脚配置层*/

/**
  * 函    数：I2C写SCL引脚电平
  * 参    数：BitValue 协议层传入的当前需要写入SCL的电平，范围0~1
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SCL为低电平，当BitValue为1时，需要置SCL为高电平
  */
void MyI2C_W_SCL(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)BitValue);		//根据BitValue，设置SCL引脚的电平
	Delay_us(10);												//延时10us，防止时序频率超过要求
}

/**
  * 函    数：I2C写SDA引脚电平
  * 参    数：BitValue 协议层传入的当前需要写入SDA的电平，范围0~0xFF
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SDA为低电平，当BitValue非0时，需要置SDA为高电平
  */
void MyI2C_W_SDA(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)BitValue);		//根据BitValue，设置SDA引脚的电平，BitValue要实现非0即1的特性
	Delay_us(10);												//延时10us，防止时序频率超过要求
}

/**
  * 函    数：I2C读SDA引脚电平
  * 参    数：无
  * 返 回 值：协议层需要得到的当前SDA的电平，范围0~1
  * 注意事项：此函数需要用户实现内容，当前SDA为低电平时，返回0，当前SDA为高电平时，返回1
  */
uint8_t MyI2C_R_SDA(void)
{
	uint8_t BitValue;
	BitValue = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11);		//读取SDA电平
	Delay_us(10);												//延时10us，防止时序频率超过要求
	return BitValue;											//返回SDA电平
}

/**
  * 函    数：I2C初始化
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，实现SCL和SDA引脚的初始化
  */
void MyI2C_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	//开启GPIOB的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);					//将PB10和PB11引脚初始化为开漏输出
	
	/*设置默认电平*/
	GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11);			//设置PB10和PB11引脚初始化后默认为高电平（释放总线状态）
}

/*协议层*/

/**
  * 函    数：I2C起始
  * 参    数：无
  * 返 回 值：无
  */
void MyI2C_Start(void)
{
	MyI2C_W_SDA(1);							//释放SDA，确保SDA为高电平
	MyI2C_W_SCL(1);							//释放SCL，确保SCL为高电平
	MyI2C_W_SDA(0);							//在SCL高电平期间，拉低SDA，产生起始信号
	MyI2C_W_SCL(0);							//起始后把SCL也拉低，即为了占用总线，也为了方便总线时序的拼接
}

/**
  * 函    数：I2C终止
  * 参    数：无
  * 返 回 值：无
  */
void MyI2C_Stop(void)
{
	MyI2C_W_SDA(0);							//拉低SDA，确保SDA为低电平
	MyI2C_W_SCL(1);							//释放SCL，使SCL呈现高电平
	MyI2C_W_SDA(1);							//在SCL高电平期间，释放SDA，产生终止信号
}

/**
  * 函    数：I2C发送一个字节
  * 参    数：Byte 要发送的一个字节数据，范围：0x00~0xFF
  * 返 回 值：无
  */
void MyI2C_SendByte(uint8_t Byte)
{
	uint8_t i;
	for (i = 0; i  8; i ++)				//循环8次，主机依次发送数据的每一位
	{
		MyI2C_W_SDA(Byte & (0x80 >> i));	//使用掩码的方式取出Byte的指定一位数据并写入到SDA线
		MyI2C_W_SCL(1);						//释放SCL，从机在SCL高电平期间读取SDA
		MyI2C_W_SCL(0);						//拉低SCL，主机开始发送下一位数据
	}
}

/**
  * 函    数：I2C接收一个字节
  * 参    数：无
  * 返 回 值：接收到的一个字节数据，范围：0x00~0xFF
  */
uint8_t MyI2C_ReceiveByte(void)
{
	uint8_t i, Byte = 0x00;					//定义接收的数据，并赋初值0x00，此处必须赋初值0x00，后面会用到
	MyI2C_W_SDA(1);							//接收前，主机先确保释放SDA，避免干扰从机的数据发送
	for (i = 0; i  8; i ++)				//循环8次，主机依次接收数据的每一位
	{
		MyI2C_W_SCL(1);						//释放SCL，主机机在SCL高电平期间读取SDA
		if (MyI2C_R_SDA() == 1){Byte |= (0x80 >> i);}	//读取SDA数据，并存储到Byte变量
														//当SDA为1时，置变量指定位为1，当SDA为0时，不做处理，指定位为默认的初值0
		MyI2C_W_SCL(0);						//拉低SCL，从机在SCL低电平期间写入SDA
	}
	return Byte;							//返回接收到的一个字节数据
}

/**
  * 函    数：I2C发送应答位
  * 参    数：Byte 要发送的应答位，范围：0~1，0表示应答，1表示非应答
  * 返 回 值：无
  */
void MyI2C_SendAck(uint8_t AckBit)
{
	MyI2C_W_SDA(AckBit);					//主机把应答位数据放到SDA线
	MyI2C_W_SCL(1);							//释放SCL，从机在SCL高电平期间，读取应答位
	MyI2C_W_SCL(0);							//拉低SCL，开始下一个时序模块
}

/**
  * 函    数：I2C接收应答位
  * 参    数：无
  * 返 回 值：接收到的应答位，范围：0~1，0表示应答，1表示非应答
  */
uint8_t MyI2C_ReceiveAck(void)
{
	uint8_t AckBit;							//定义应答位变量
	MyI2C_W_SDA(1);							//接收前，主机先确保释放SDA，避免干扰从机的数据发送
	MyI2C_W_SCL(1);							//释放SCL，主机机在SCL高电平期间读取SDA
	AckBit = MyI2C_R_SDA();					//将应答位存储到变量里
	MyI2C_W_SCL(0);							//拉低SCL，开始下一个时序模块
	return AckBit;							//返回定义应答位变量
}

函数逻辑：

void MyI2C_Start(void)

如果起始条件之前SCL和SDA已经是高电平了，那先释放哪一个是一样的效果，但是在指定地址读中，为了改变读写标志位，我们这个Start还要兼容这里的重复起始条件Sr。

Sr最开始，SCL是低电平，SDA电平不敢确定，所以保险起见，我们趁SCL是低电平，先确保释放SDA，再释放SCL，这时SDA和SCL都是高电平，然后再拉低SDA、拉低SCL，这样这个Start就可以兼容起始条件和重复起始条件了。
【如果先释放SCL，在SCL高电平期间再释放SDA会被误以为是终止条件；这里Sr是需要重新生成一个开始条件即SCL高电平期间，SDA从高变低。如果不先拉低SDA，就容易造成。SCL高电平期间，SDA从低变高。变成结束信号了。】

void MyI2C_Stop(void)

在这里，如果Stop开始时，那就先释放SCL，再释放SDA就行了，但是在这个时序单元开始时，SDA并不一定是低电平，所以为了确保之后释放SDA能产生上升沿，我们要在时序单元开始时，先拉低SDA，然后再释放SCL、释放SDA。

void MyI2C_SendByte(uint8_t Byte)

发送一个字节时序开始时，SCL是低电平,实际上，除了终止条件，SCL以高电平结束,所有的单元我们都会保证SCL以低电平结束，这样方便各个单元的拼接。
补充：
Byte & 0x80 就是用按位与的方式，取出数据的某一位或某几位，感觉这里准确的讲是检查位是否为1，而不是取出最高位

…

MPU6050_Reg.h

#ifndef __MPU6050_REG_H
#define __MPU6050_REG_H

#define	MPU6050_SMPLRT_DIV		0x19
#define	MPU6050_CONFIG			0x1A
#define	MPU6050_GYRO_CONFIG		0x1B
#define	MPU6050_ACCEL_CONFIG	0x1C

#define	MPU6050_ACCEL_XOUT_H	0x3B
#define	MPU6050_ACCEL_XOUT_L	0x3C
#define	MPU6050_ACCEL_YOUT_H	0x3D
#define	MPU6050_ACCEL_YOUT_L	0x3E
#define	MPU6050_ACCEL_ZOUT_H	0x3F
#define	MPU6050_ACCEL_ZOUT_L	0x40
#define	MPU6050_TEMP_OUT_H		0x41
#define	MPU6050_TEMP_OUT_L		0x42
#define	MPU6050_GYRO_XOUT_H		0x43
#define	MPU6050_GYRO_XOUT_L		0x44
#define	MPU6050_GYRO_YOUT_H		0x45
#define	MPU6050_GYRO_YOUT_L		0x46
#define	MPU6050_GYRO_ZOUT_H		0x47
#define	MPU6050_GYRO_ZOUT_L		0x48

#define	MPU6050_PWR_MGMT_1		0x6B
#define	MPU6050_PWR_MGMT_2		0x6C
#define	MPU6050_WHO_AM_I		0x75

#endif

MPU6050.h

#ifndef __MPU6050_H
#define __MPU6050_H

void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
uint8_t MPU6050_ReadReg(uint8_t RegAddress);

void MPU6050_Init(void);
uint8_t MPU6050_GetID(void);
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);

#endif

MPU6050.c

#include "stm32f10x.h"                  // Device header
#include "MyI2C.h"
#include "MPU6050_Reg.h"

#define MPU6050_ADDRESS		0xD0		//MPU6050的I2C从机地址

/**
  * 函    数：MPU6050写寄存器
  * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
  * 参    数：Data 要写入寄存器的数据，范围：0x00~0xFF
  * 返 回 值：无
  */
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
	MyI2C_Start();						//I2C起始
	MyI2C_SendByte(MPU6050_ADDRESS);	//发送从机地址，读写位为0，表示即将写入
	MyI2C_ReceiveAck();					//接收应答
	MyI2C_SendByte(RegAddress);			//发送寄存器地址
	MyI2C_ReceiveAck();					//接收应答
	MyI2C_SendByte(Data);				//发送要写入寄存器的数据
	MyI2C_ReceiveAck();					//接收应答
	MyI2C_Stop();						//I2C终止
}

/**
  * 函    数：MPU6050读寄存器
  * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
  * 返 回 值：读取寄存器的数据，范围：0x00~0xFF
  */
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
	uint8_t Data;
	
	MyI2C_Start();						//I2C起始
	MyI2C_SendByte(MPU6050_ADDRESS);	//发送从机地址，读写位为0，表示即将写入
	MyI2C_ReceiveAck();					//接收应答
	MyI2C_SendByte(RegAddress);			//发送寄存器地址
	MyI2C_ReceiveAck();					//接收应答
	
	MyI2C_Start();						//I2C重复起始
	MyI2C_SendByte(MPU6050_ADDRESS | 0x01);	//发送从机地址，读写位为1，表示即将读取
	MyI2C_ReceiveAck();					//接收应答
	Data = MyI2C_ReceiveByte();			//接收指定寄存器的数据
	MyI2C_SendAck(1);					//发送应答，给从机非应答，终止从机的数据输出
	MyI2C_Stop();						//I2C终止
	
	return Data;
}

/**
  * 函    数：MPU6050初始化
  * 参    数：无
  * 返 回 值：无
  */
void MPU6050_Init(void)
{
	MyI2C_Init();									//先初始化底层的I2C
	
	/*MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);		//电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪
	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);		//电源管理寄存器2，保持默认值0，所有轴均不待机
	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);		//采样率分频寄存器，配置采样率
	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);			//配置寄存器，配置DLPF
	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);	//陀螺仪配置寄存器，选择满量程为2000/s
	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);	//加速度计配置寄存器，选择满量程为16g
}

/**
  * 函    数：MPU6050获取ID号
  * 参    数：无
  * 返 回 值：MPU6050的ID号
  */
uint8_t MPU6050_GetID(void)
{
	return MPU6050_ReadReg(MPU6050_WHO_AM_I);		//返回WHO_AM_I寄存器的值
}

/**
  * 函    数：MPU6050获取数据
  * 参    数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
  * 参    数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
  * 返 回 值：无
  */
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
{
	uint8_t DataH, DataL;								//定义数据高8位和低8位的变量
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);		//读取加速度计X轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);		//读取加速度计X轴的低8位数据
	*AccX = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);		//读取加速度计Y轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);		//读取加速度计Y轴的低8位数据
	*AccY = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);		//读取加速度计Z轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);		//读取加速度计Z轴的低8位数据
	*AccZ = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);		//读取陀螺仪X轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);		//读取陀螺仪X轴的低8位数据
	*GyroX = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);		//读取陀螺仪Y轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);		//读取陀螺仪Y轴的低8位数据
	*GyroY = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);		//读取陀螺仪Z轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);		//读取陀螺仪Z轴的低8位数据
	*GyroZ = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
}

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "MPU6050.h"

uint8_t ID;								//定义用于存放ID号的变量
int16_t AX, AY, AZ, GX, GY, GZ;			//定义用于存放各个数据的变量

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	MPU6050_Init();		//MPU6050初始化
	
	/*显示ID号*/
	OLED_ShowString(1, 1, "ID:");		//显示静态字符串
	ID = MPU6050_GetID();				//获取MPU6050的ID号
	OLED_ShowHexNum(1, 4, ID, 2);		//OLED显示ID号
	
	while (1)
	{
		MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);		//获取MPU6050的数据
		OLED_ShowSignedNum(2, 1, AX, 5);					//OLED显示数据
		OLED_ShowSignedNum(3, 1, AY, 5);
		OLED_ShowSignedNum(4, 1, AZ, 5);
		OLED_ShowSignedNum(2, 8, GX, 5);
		OLED_ShowSignedNum(3, 8, GY, 5);
		OLED_ShowSignedNum(4, 8, GZ, 5);
	}
}

那之前的课程我们用的是软件I2C，手动拉低或释放时钟线，然后再手动对每个数据位进行判断，拉低或释放数据线，这样来产生这个的波形，这是软件I2C。由于12C是同步时序，这每一位的持续时间要求不严格，或许中途暂停一下时序，影响都不大，所以2C是比较容易用软件模拟的。
在实际项目中，软件模拟的I2C也是非常常见的，但是作为一个协议标准，I2C通信，也是可以有硬件收发电路的。就像之前的串口通信一样，我们先讲了串口的时序波形，但是在程序中，我们并没有用软件去手动翻转电平来实现这个波形，这是因为串口是异步时序，每一位的时间要求很严格，不能过长也不能过短，所以串口时序虽然可以用软件模拟，但是操作起来比较困难。另外，由于串口的硬件收发器在单片机中的普及程度非常高，基本上每个单片机都有串口的硬件资源，而且硬件实现的串口使用起来还非常简单，所以，串口通信，我们基本都是借助硬件收发器来实现的。

I2C通信外设
硬件实现串口（USART）的使用流程：首先配置USART外设，然后写入数据寄存器DR，然后硬件收发器就会自动生成波形发送出去，最后我们等待发送完成的标志位即可。
回到I2C这里，I2C也可以有软件模拟和硬件收发器自动操作这两种异步时序，对于串口这样的异步时序，软件实现麻烦，硬件实现简单，所以串口的实现基本是全部倒向硬件。而对于I2C这样的同步时序来说，软件实现简单灵活，硬件实现麻烦，但可以节省软件资源、可以实现完整的多主机通信模型等，各有优缺点。

I2C框图

I2C基本结构

代码实战：10-2硬件I2C读写MPU6050
MPU6050.h

#ifndef __MPU6050_H
#define __MPU6050_H

void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data);
uint8_t MPU6050_ReadReg(uint8_t RegAddress);

void MPU6050_Init(void);
uint8_t MPU6050_GetID(void);
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ);

#endif

MPU6050_REG.h

#ifndef __MPU6050_REG_H
#define __MPU6050_REG_H

#define	MPU6050_SMPLRT_DIV		0x19
#define	MPU6050_CONFIG			0x1A
#define	MPU6050_GYRO_CONFIG		0x1B
#define	MPU6050_ACCEL_CONFIG	0x1C

#define	MPU6050_ACCEL_XOUT_H	0x3B
#define	MPU6050_ACCEL_XOUT_L	0x3C
#define	MPU6050_ACCEL_YOUT_H	0x3D
#define	MPU6050_ACCEL_YOUT_L	0x3E
#define	MPU6050_ACCEL_ZOUT_H	0x3F
#define	MPU6050_ACCEL_ZOUT_L	0x40
#define	MPU6050_TEMP_OUT_H		0x41
#define	MPU6050_TEMP_OUT_L		0x42
#define	MPU6050_GYRO_XOUT_H		0x43
#define	MPU6050_GYRO_XOUT_L		0x44
#define	MPU6050_GYRO_YOUT_H		0x45
#define	MPU6050_GYRO_YOUT_L		0x46
#define	MPU6050_GYRO_ZOUT_H		0x47
#define	MPU6050_GYRO_ZOUT_L		0x48

#define	MPU6050_PWR_MGMT_1		0x6B
#define	MPU6050_PWR_MGMT_2		0x6C
#define	MPU6050_WHO_AM_I		0x75

#endif

MPU6050.c

#include "stm32f10x.h"                  // Device header
#include "MPU6050_Reg.h"

#define MPU6050_ADDRESS		0xD0		//MPU6050的I2C从机地址

/**
  * 函    数：MPU6050等待事件
  * 参    数：同I2C_CheckEvent
  * 返 回 值：无
  */
void MPU6050_WaitEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
{
	uint32_t Timeout;
	Timeout = 10000;									//给定超时计数时间
	while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS)	//循环等待指定事件
	{
		Timeout --;										//等待时，计数值自减
		if (Timeout == 0)								//自减到0后，等待超时
		{
			/*超时的错误处理代码，可以添加到此处*/
			break;										//跳出等待，不等了
		}
	}
}

/**
  * 函    数：MPU6050写寄存器
  * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
  * 参    数：Data 要写入寄存器的数据，范围：0x00~0xFF
  * 返 回 值：无
  */
void MPU6050_WriteReg(uint8_t RegAddress, uint8_t Data)
{
	I2C_GenerateSTART(I2C2, ENABLE);										//硬件I2C生成起始条件
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);					//等待EV5
	
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);	//硬件I2C发送从机地址，方向为发送
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);	//等待EV6
	
	I2C_SendData(I2C2, RegAddress);											//硬件I2C发送寄存器地址
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING);			//等待EV8
	
	I2C_SendData(I2C2, Data);												//硬件I2C发送数据
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);				//等待EV8_2
	
	I2C_GenerateSTOP(I2C2, ENABLE);											//硬件I2C生成终止条件
}

/**
  * 函    数：MPU6050读寄存器
  * 参    数：RegAddress 寄存器地址，范围：参考MPU6050手册的寄存器描述
  * 返 回 值：读取寄存器的数据，范围：0x00~0xFF
  */
uint8_t MPU6050_ReadReg(uint8_t RegAddress)
{
	uint8_t Data;
	
	I2C_GenerateSTART(I2C2, ENABLE);										//硬件I2C生成起始条件
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);					//等待EV5
	
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Transmitter);	//硬件I2C发送从机地址，方向为发送
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);	//等待EV6
	
	I2C_SendData(I2C2, RegAddress);											//硬件I2C发送寄存器地址
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);				//等待EV8_2
	
	I2C_GenerateSTART(I2C2, ENABLE);										//硬件I2C生成重复起始条件
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);					//等待EV5
	
	I2C_Send7bitAddress(I2C2, MPU6050_ADDRESS, I2C_Direction_Receiver);		//硬件I2C发送从机地址，方向为接收
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);		//等待EV6
	
	I2C_AcknowledgeConfig(I2C2, DISABLE);									//在接收最后一个字节之前提前将应答失能
	I2C_GenerateSTOP(I2C2, ENABLE);											//在接收最后一个字节之前提前申请停止条件
	
	MPU6050_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED);				//等待EV7
	Data = I2C_ReceiveData(I2C2);											//接收数据寄存器
	
	I2C_AcknowledgeConfig(I2C2, ENABLE);									//将应答恢复为使能，为了不影响后续可能产生的读取多字节操作
	
	return Data;
}

/**
  * 函    数：MPU6050初始化
  * 参    数：无
  * 返 回 值：无
  */
void MPU6050_Init(void)
{
	/*开启时钟*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);		//开启I2C2的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);					//将PB10和PB11引脚初始化为复用开漏输出
	
	/*I2C初始化*/
	I2C_InitTypeDef I2C_InitStructure;						//定义结构体变量
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;				//模式，选择为I2C模式
	I2C_InitStructure.I2C_ClockSpeed = 50000;				//时钟速度，选择为50KHz
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;		//时钟占空比，选择Tlow/Thigh = 2
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;				//应答，选择使能
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;	//应答地址，选择7位，从机模式下才有效
	I2C_InitStructure.I2C_OwnAddress1 = 0x00;				//自身地址，从机模式下才有效
	I2C_Init(I2C2, &I2C_InitStructure);						//将结构体变量交给I2C_Init，配置I2C2
	
	/*I2C使能*/
	I2C_Cmd(I2C2, ENABLE);									//使能I2C2，开始运行
	
	/*MPU6050寄存器初始化，需要对照MPU6050手册的寄存器描述配置，此处仅配置了部分重要的寄存器*/
	MPU6050_WriteReg(MPU6050_PWR_MGMT_1, 0x01);				//电源管理寄存器1，取消睡眠模式，选择时钟源为X轴陀螺仪
	MPU6050_WriteReg(MPU6050_PWR_MGMT_2, 0x00);				//电源管理寄存器2，保持默认值0，所有轴均不待机
	MPU6050_WriteReg(MPU6050_SMPLRT_DIV, 0x09);				//采样率分频寄存器，配置采样率
	MPU6050_WriteReg(MPU6050_CONFIG, 0x06);					//配置寄存器，配置DLPF
	MPU6050_WriteReg(MPU6050_GYRO_CONFIG, 0x18);			//陀螺仪配置寄存器，选择满量程为2000/s
	MPU6050_WriteReg(MPU6050_ACCEL_CONFIG, 0x18);			//加速度计配置寄存器，选择满量程为16g
}


/**
  * 函    数：MPU6050获取ID号
  * 参    数：无
  * 返 回 值：MPU6050的ID号
  */
uint8_t MPU6050_GetID(void)
{
	return MPU6050_ReadReg(MPU6050_WHO_AM_I);		//返回WHO_AM_I寄存器的值
}

/**
  * 函    数：MPU6050获取数据
  * 参    数：AccX AccY AccZ 加速度计X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
  * 参    数：GyroX GyroY GyroZ 陀螺仪X、Y、Z轴的数据，使用输出参数的形式返回，范围：-32768~32767
  * 返 回 值：无
  */
void MPU6050_GetData(int16_t *AccX, int16_t *AccY, int16_t *AccZ, 
						int16_t *GyroX, int16_t *GyroY, int16_t *GyroZ)
{
	uint8_t DataH, DataL;								//定义数据高8位和低8位的变量
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_H);		//读取加速度计X轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_XOUT_L);		//读取加速度计X轴的低8位数据
	*AccX = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_H);		//读取加速度计Y轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_YOUT_L);		//读取加速度计Y轴的低8位数据
	*AccY = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_H);		//读取加速度计Z轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_ACCEL_ZOUT_L);		//读取加速度计Z轴的低8位数据
	*AccZ = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_XOUT_H);		//读取陀螺仪X轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_XOUT_L);		//读取陀螺仪X轴的低8位数据
	*GyroX = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_YOUT_H);		//读取陀螺仪Y轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_YOUT_L);		//读取陀螺仪Y轴的低8位数据
	*GyroY = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
	
	DataH = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_H);		//读取陀螺仪Z轴的高8位数据
	DataL = MPU6050_ReadReg(MPU6050_GYRO_ZOUT_L);		//读取陀螺仪Z轴的低8位数据
	*GyroZ = (DataH  8) | DataL;						//数据拼接，通过输出参数返回
}

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "MPU6050.h"

uint8_t ID;								//定义用于存放ID号的变量
int16_t AX, AY, AZ, GX, GY, GZ;			//定义用于存放各个数据的变量

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	MPU6050_Init();		//MPU6050初始化
	
	/*显示ID号*/
	OLED_ShowString(1, 1, "ID:");		//显示静态字符串
	ID = MPU6050_GetID();				//获取MPU6050的ID号
	OLED_ShowHexNum(1, 4, ID, 2);		//OLED显示ID号
	
	while (1)
	{
		MPU6050_GetData(&AX, &AY, &AZ, &GX, &GY, &GZ);		//获取MPU6050的数据
		OLED_ShowSignedNum(2, 1, AX, 5);					//OLED显示数据
		OLED_ShowSignedNum(3, 1, AY, 5);
		OLED_ShowSignedNum(4, 1, AZ, 5);
		OLED_ShowSignedNum(2, 8, GX, 5);
		OLED_ShowSignedNum(3, 8, GY, 5);
		OLED_ShowSignedNum(4, 8, GZ, 5);
	}
}

SPI协议

10.1 SPI简介

SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线
四根通信线：SCK（Serial Clock）、MOSI（Master Output Slave Input）、MISO（Master
Input Slave Output）、SS（Slave Select）有几个从机，就可以直接连接SS
同步，全双工
支持总线挂载多设备（一主多从）

硬件电路：
所有SPI设备的SCK、MOSI、MISO分别连在一起
主机另外引出多条SS控制线，分别接到各从机的SS引脚
输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入

移位示意图：

SPI时序基本单元：





模式0最常用

• 发送指令
• 向SS指定的设备，发送指令（0x06）
• 指令码(读写)+地址
  
  指定地址写
  向SS指定的设备，发送写指令（0x02），随后在指定地址（Address[23:0]）下，写入指定数据
  （Data）
  
  指定地址读
  向SS指定的设备，发送读指令（0x03），随后在指定地址（Address[23:0]）下，读取从机数据
  （Data）
  

W25Q64简介

W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储、字库存
储、固件程序存储等场景
存储介质：Nor Flash（闪存）
时钟频率：80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)
存储容量（24位地址）：

W25Q40：4Mbit / 512KByte
W25Q80：8Mbit / 1MByte
W25Q16：16Mbit / 2MByte
W25Q32：32Mbit / 4MByte
W25Q64：64Mbit / 8MByte
W25Q128：128Mbit / 16MByte
W25Q256：256Mbit / 32MByte

硬件电路：

W25Q64框图：

Flash操作注意事项：

写入操作时：

• 写入操作前，必须先进行写使能
• 每个数据位只能由1改写为0，不能由0改写为1
• 写入数据前必须先擦除，擦除后，所有数据位变为1
• 擦除必须按最小擦除单元进行(一个扇区4096 bytes) 可以先读出来再擦除再写入
• 连续写入多字节时，最多写入一页(256 bytes)的数据，超过页尾位置的数据，会回到页首覆盖写入
• 写入操作结束后，芯片进入忙状态，不响应新的读写操作busy = 1

读取操作时：

• 直接调用读取时序，无需使能，无需额外操作，没有页的限制，读取操作结束后不会进入忙状态，但不能在忙状态时读取

10.3 SPI软件读写W25Q64

接线图：


代码：
main.c

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"
uint8_t MID;
uint16_t DID;
uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];
int main(void)
{
    OLED_Init();
    W25Q64_Init();
    OLED_ShowString(1, 1, "MID:   DID:");
    OLED_ShowString(2, 1, "W:");
    OLED_ShowString(3, 1, "R:");
    W25Q64_ReadID(&MID, &DID);
    OLED_ShowHexNum(1, 5, MID, 2);
    OLED_ShowHexNum(1, 12, DID, 4);
    W25Q64_SectorErase(0x000000);
    W25Q64_PageProgram(0x000000, ArrayWrite, 4);
    W25Q64_ReadData(0x000000, ArrayRead, 4);
    OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
    OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
    OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
    OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
    OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
    OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
    OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
    OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
    while (1)
    {
    }
}

W25Q64.c

#include "stm32f10x.h"                 // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"
void W25Q64_Init(void)
{
    MySPI_Init();
}
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_JEDEC_ID); // 指定读取地址厂商ID，设备
    ID在这里0x9F 指令表
        *MID = MySPI_SwapBytes(W25Q64_DUMMY_BYTE); // 第一个时序先读到MID
    0xFF 用于去交换数据
        *DID = MySPI_SwapBytes(W25Q64_DUMMY_BYTE); // 第二个时序读到DID的高八位
    *DID  8;                                    // 将高八位移至高八位
    *DID |= MySPI_SwapBytes(W25Q64_DUMMY_BYTE);    // 将低八位移至低八位
    MySPI_Stop();
}
void W25Q64_WriteEnable(void)
{
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_WRITE_ENABLE);
    MySPI_Stop();
}
void W25Q64_WaitBusy(void)
{
    uint32_t Timeout;
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_READ_STATUS_REGISTER_1);
    Timeout = 100000;
    while ((MySPI_SwapBytes(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
    {
        Timeout--;
        if (Timeout == 0)
        {
            break;
        }
    }
    MySPI_Stop();
}
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
    uint16_t i;
    W25Q64_WriteEnable();
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_PAGE_PROGRAM);
    MySPI_SwapBytes(Address >> 16);
    MySPI_SwapBytes(Address >> 8);
    MySPI_SwapBytes(Address);
    for (i = 0; i  Count; i++)
    {
        MySPI_SwapBytes(DataArray[i]);
    }
    MySPI_Stop();
    W25Q64_WaitBusy();
}
void W25Q64_SectorErase(uint32_t Address)
{
    W25Q64_WriteEnable();
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_SECTOR_ERASE_4KB);
    MySPI_SwapBytes(Address >> 16);
    MySPI_SwapBytes(Address >> 8);
    MySPI_SwapBytes(Address);
    MySPI_Stop();
    W25Q64_WaitBusy();
}
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
    uint32_t i;
    MySPI_Start();
    MySPI_SwapBytes(W25Q64_READ_DATA);
    MySPI_SwapBytes(Address >> 16);
    MySPI_SwapBytes(Address >> 8);
    MySPI_SwapBytes(Address);
    for (i = 0; i  Count; i++)
    {
        DataArray[i] = MySPI_SwapBytes(W25Q64_DUMMY_BYTE);
    }
    MySPI_Stop();
}

10.4 SPI硬件读写W25Q64

SPI外设简介：

STM32内部集成了硬件SPI收发电路，可以由硬件自动执行时钟生成、数据收发等功能，减轻CPU
的负担
可配置8位/16位数据帧、高位先行/低位先行
时钟频率：fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)
支持多主机模型、主或从操作
可精简为半双工/单工通信
支持DMA
兼容I2S协议(数字音频传输协议)
STM32F103C8T6 硬件SPI资源：SPI1、SPI2

SPI框图：

SPI基本结构：

主模式全双工连续传输：

非连续传输：

软件/硬件波形对比：


接线图：

常用代码：

void SPI_I2S_DeInit(SPI_TypeDef *SPIx);
void SPI_Init(SPI_TypeDef *SPIx, SPI_InitTypeDef *SPI_InitStruct);
void I2S_Init(SPI_TypeDef *SPIx, I2S_InitTypeDef *I2S_InitStruct);
void SPI_StructInit(SPI_InitTypeDef *SPI_InitStruct);
void I2S_StructInit(I2S_InitTypeDef *I2S_InitStruct);
void SPI_Cmd(SPI_TypeDef *SPIx, FunctionalState NewState);
void I2S_Cmd(SPI_TypeDef *SPIx, FunctionalState NewState);
void SPI_I2S_ITConfig(SPI_TypeDef *SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState);
void SPI_I2S_DMACmd(SPI_TypeDef *SPIx, uint16_t SPI_I2S_DMAReq,
                    FunctionalState NewState);
void SPI_I2S_SendData(SPI_TypeDef *SPIx, uint16_t Data); // 写DR
uint16_t SPI_I2S_ReceiveData(SPI_TypeDef *SPIx);         // 读DR
// 状态标志
FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef *SPIx, uint16_t SPI_I2S_FLAG);
void SPI_I2S_ClearFlag(SPI_TypeDef *SPIx, uint16_t SPI_I2S_FLAG);
ITStatus SPI_I2S_GetITStatus(SPI_TypeDef *SPIx, uint8_t SPI_I2S_IT);
void SPI_I2S_ClearITPendingBit(SPI_TypeDef *SPIx, uint8_t SPI_I2S_IT);

代码:
main.c

#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"
uint8_t MID;
uint16_t DID;
uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];
int main(void)
{
    OLED_Init();
    W25Q64_Init();
    OLED_ShowString(1, 1, "MID:   DID:");
    OLED_ShowString(2, 1, "W:");
    OLED_ShowString(3, 1, "R:");
    W25Q64_ReadID(&MID, &DID);
    OLED_ShowHexNum(1, 5, MID, 2);
    OLED_ShowHexNum(1, 12, DID, 4);
    W25Q64_SectorErase(0x000000);
    W25Q64_PageProgram(0x000000, ArrayWrite, 4);
    W25Q64_ReadData(0x000000, ArrayRead, 4);
    OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
    OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
    OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
    OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
    OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
    OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
    OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
    OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
    while (1)
    {
    }
}

SPI.c

#include "stm32f10x.h"                 // Device header
void MySPI_W_SS(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}
void MySPI_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    // SS推挽输出
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    // SCK、MOSI复用推挽输出
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    SPI_InitTypeDef SPI_InitStructure;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
    // 128分频
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    // 模式0 0-0
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    // 第一个边沿采样
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    // 默认7
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    // 8位传输
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    // 全双工
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    // 高位先行
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    // 主模式
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    // 软件模拟NSS
    SPI_Init(SPI1, &SPI_InitStructure);
    SPI_Cmd(SPI1, ENABLE);
    MySPI_W_SS(0); // 模式0默认高电平，默认不选择从机
}
void MySPI_Start(void)
{
    MySPI_W_SS(0);
}
void MySPI_Stop(void)
{
    MySPI_W_SS(1);
}
// 四部交换数据（1个字节）不需要手动清除标志
uint8_t MySPI_SwapBytes(uint8_t ByteSend)
{
    // 1.等待TXE = 1 卡死的概率不大
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != SET)
        ;
    // 2.发送数据
    SPI_I2S_SendData(SPI1, ByteSend);
    // 3.等待RXNE = 1 代表传输完一个字节
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) != SET)
        ;
    // 4.接收数据
    return SPI_I2S_ReceiveData(SPI1);
}

BKP、RTC

11.0 Unix时间戳

• Unix 时间戳（Unix Timestamp）定义为从UTC/GMT的1970年1月1日0时0分0秒开始所经过的秒
  数，不考虑闰秒
• 时间戳存储在一个秒计数器中，秒计数器为32位/64位的整型变量
• 世界上所有时区的秒计数器相同，不同时区通过添加偏移来得到当地时间

UTC/GMT：

• GMT（Greenwich Mean Time）格林尼治标准时间是一种以地球自转为基础的时间计量系统。它
  将地球自转一周的时间间隔等分为24小时，以此确定计时标准
• UTC（Universal Time Coordinated）协调世界时是一种以原子钟为基础的时间计量系统。它规定
  铯133原子基态的两个超精细能级间在零磁场下跃迁辐射9,192,631,770周所持续的时间为1秒。当
  原子钟计时一天的时间与地球自转一周的时间相差超过0.9秒时，UTC会执行闰秒来保证其计时与
  地球自转的协调一致

时间戳转换：

• C语言的time.h模块提供了时间获取和时间戳转换的相关函数，可以方便地进行秒计数器、日期时
  间和字符串之间的转换
  
  
  time.h

#include 
#include 
#include 
// struct tm {
//     int tm_sec;   /* 秒，范围从0 到59       */
//     int tm_min;   /* 分，范围从0 到59       */
//     int tm_hour; /* 小时，范围从0 到23       */
//     int tm_mday; /* 一月中的第几天，范围从1 到31   */
//     int tm_mon;   /* 月，范围从0 到11       */
//     int tm_year; /* 自1900 年起的年数      */
//     int tm_wday; /* 一周中的第几天，范围从0 到6   */
//     int tm_yday; /* 一年中的第几天，范围从0 到365   */
//     int tm_isdst; /* 夏令时              */
// };
int main(int argc, char const *argv[])
{
      time_t Time; // 时间戳
      struct tm Date;
      // Time = time(NULL);
  time(&Time);
      printf("Time = %ldn", Time); // Time = 1695695610
      Date = *localtime(&Time);
      printf("%dn", Date.tm_year + 1900);
      printf("%dn", Date.tm_mon + 1);
      printf("%dn", Date.tm_mday);
      printf("%dn", Date.tm_hour);
      printf("%dn", Date.tm_min);
      printf("%dn", Date.tm_sec);
      printf("%dn", Date.tm_wday);
      printf("%dn", Date.tm_yday);
      printf("%sn", ctime(&Time));
      printf("%sn", asctime(&Time));
      puts(asctime(&Date));
      char t[50];
      strftime(t, 50, "%H-%M-%S", &Date);
      printf(t);
      return 0;
}

BKP检测：

• BKP（Backup Registers）备份寄存器
• BKP可用于存储用户应用程序数据。当VDD（2.03.6V）电源被切断，他们仍然由VBAT（1.8 3.6V）维持供电。当系统在待机模式下被唤醒，或系统复位或电源复位时，他们也不会被复位
• TAMPER引脚产生的侵入事件将所有备份寄存器内容清除
• RTC引脚输出RTC校准时钟、RTC闹钟脉冲或者秒脉冲
• 存储RTC时钟校准寄存器
• 用户数据存储容量：20字节（中容量和小容量）/ 84字节（大容量和互联型）

BKP基本结构：

TRC简介：

RTC（Real Time Clock）实时时钟
RTC是一个独立的定时器，可为系统提供时钟和日历的功能
RTC和时钟配置系统处于后备区域，系统复位时数据不清零，VDD（2.03.6V）断电后可借助VBAT
（1.8 3.6V）供电继续走时
32位的可编程计数器，可对应Unix时间戳的秒计数器
20位的可编程预分频器，可适配不同频率的输入时钟
可选择三种RTC时钟源：

LSI振荡器时钟（40KHz）

HSE时钟除以128（通常为8MHz/128）

LSE振荡器时钟（通常为32.768KHz）

RTC框图：

RTC基本结构：

RTC操作注意事项：

执行以下操作将使能对BKP和RTC的访问：
设置RCC_APB1ENR的PWREN和BKPEN，使能PWR和BKP时钟
设置PWR_CR的DBP，使能对BKP和RTC的访问

若在读取RTC寄存器时，RTC的APB1接口曾经处于禁止状态，则软件首先必须等待RTC_CRL寄存器
中的RSF位（寄存器同步标志）被硬件置1
必须设置RTC_CRL寄存器中的CNF位，使RTC进入配置模式后，才能写入RTC_PRL、RTC_CNT、
RTC_ALR寄存器
对RTC任何寄存器的写操作，都必须在前一次写操作结束后进行。可以通过查询RTC_CR寄存器中的
RTOFF状态位，判断RTC寄存器是否处于更新中。仅当RTOFF状态位是1时，才可以写入RTC寄存器

11.1 读写备份寄存器BKP

电源：

常用函数：

void BKP_DeInit(void); // 将所有配置清0
// 用于Tamper侵入检测功能
void BKP_TamperPinLevelConfig(uint16_t BKP_TamperPinLevel); // 配置有效电平高电平、低电平触发
void BKP_TamperPinCmd(FunctionalState NewState);            // 是否开启
void BKP_ITConfig(FunctionalState NewState);                // 配置中断
void BKP_RTCOutputConfig(uint16_t BKP_RTCOutputSource);     // 时钟输出功能的配置
void BKP_SetRTCCalibrationValue(uint8_t CalibrationValue);  // 设置RTC校准值
// 读写BKP
void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);
uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);
FlagStatus BKP_GetFlagStatus(void);
void BKP_ClearFlag(void);
ITStatus BKP_GetITStatus(void);
void BKP_ClearITPendingBit(void);

void PWR_DeInit(void);
void PWR_BackupAccessCmd(FunctionalState NewState); //备份寄存器访问使能
void PWR_PVDCmd(FunctionalState NewState);
void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel);
void PWR_WakeUpPinCmd(FunctionalState NewState);
void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry);
void PWR_EnterSTANDBYMode(void);
FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG);
void PWR_ClearFlag(uint32_t PWR_FLAG);

代码：
main.c

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
uint16_t Write[] = {0x1234, 0x5678};
uint16_t Read[2];
uint8_t KeyNum;
int main(void)
{
    OLED_Init();
    KEY_Init();
    OLED_ShowString(1, 1, "W:");
    OLED_ShowString(2, 1, "R:");
    // BKP初始化
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
    // 备份寄存器访问使能
    PWR_BackupAccessCmd(ENABLE);
    while (1)
    {
        KeyNum = Key_GetNum();
        if (KeyNum == 1)
        {
            BKP_WriteBackupRegister(BKP_DR1, Write[0]); // DR 1-10 c8t6
            BKP_WriteBackupRegister(BKP_DR2, Write[1]);
            Write[0]++;
            Write[1]++;
            OLED_ShowHexNum(1, 3, Write[0], 4);
            OLED_ShowHexNum(2, 3, Write[0], 4);
        }
        Read[0] = BKP_ReadBackupRegister(BKP_DR1);
        Read[1] = BKP_ReadBackupRegister(BKP_DR2);
        OLED_ShowHexNum(1, 3, Read[0], 4);
        OLED_ShowHexNum(2, 3, Read[1], 4);
    }
}

11.2 RTC实时时钟

常用函数：

void RCC_LSEConfig(uint8_t RCC_LSE);              // 启动LSE时钟
void RCC_LSICmd(FunctionalState NewState);        // 配置LSI内部低速时钟
void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource); // CLK时钟源数据选择器
void RCC_RTCCLKCmd(FunctionalState NewState);     // 启动RCCCLK
void RCC_GetClocksFreq(RCC_ClocksTypeDef *RCC_Clocks);
void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState
                                                       NewState);
void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState
                                                         NewState);
void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState
                                                         NewState);
FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG); // 获取标志位

void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState); // RTC中断
void RTC_EnterConfigMode(void);                               // 进入配置模式
RTC_CRL_CNF = 1 void RTC_ExitConfigMode(void);                // 退出
uint32_t RTC_GetCounter(void);                                // 获取计数器的值
void RTC_SetCounter(uint32_t CounterValue);                   // 写入计数器的值设置时间
void RTC_SetPrescaler(uint32_t PrescalerValue);               // PSC
void RTC_SetAlarm(uint32_t AlarmValue);                       服务器托管网// 闹钟
uint32_t RTC_GetDivider(void);                                // 余数寄存器
void RTC_WaitForLastTask(void);                               // 等待上一次操作完成
void RTC_WaitForSynchro(void);                                // 等待同步
FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);
void RTC_ClearFlag(uint16_t RTC_FLAG);
ITStatus RTC_GetITStatus(uint16_t RTC_IT);
void RTC_ClearITPendingBit(uint16_t RTC_IT);

代码：
main.c

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "RTC.h"
int main(void)
{
    OLED_Init();
    MyRTC_Init();
    OLED_ShowString(1, 1, "Date:XXXX-XX-XX");
    OLED_ShowString(2, 1, "Time:XX:XX:XX");
    OLED_ShowString(3, 1, "CNT :");
    OLED_ShowString(4, 1, "DIV :");
    while (1)
    {
        MyRTC_ReadTime();
        OLED_ShowNum(1, 6, MyRTC_Time[0], 4);
        OLED_ShowNum(1, 11, MyRTC_Time[1], 2);
        OLED_ShowNum(1, 14, MyRTC_Time[2], 2);
        OLED_ShowNum(2, 6, MyRTC_Time[3], 2);
        OLED_ShowNum(2, 9, MyRTC_Time[4], 2);
        OLED_ShowNum(2, 12, MyRTC_Time[5], 2);
        OLED_ShowNum(3, 6, RTC_GetCounter(), 10);
        OLED_ShowNum(4, 6, RTC_GetDivider(), 10);
        // 1s = 1000ms 这样计数就变成0-999 999为1s
        // OLED_ShowNum(4, 6, (32767 - RTC_GetDivider()) / 32767.0 * 999,10);
    }
}

RTC.c

#include "stm32f10x.h"                 // Device header
#include 
uint32_t MyRTC_Time[] = {2023, 9, 28, 10, 25, 59};
void MyRTC_SetTime(void);
void MyRTC_Init(void)
{
    // 1.初始化BKP
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
    PWR_BackupAccessCmd(ENABLE);
    // 判断主电源断开还是备用电源断开防止主电源断开也重置计数器
    if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
    {
        // 2.开启LSE时钟并等待开启完成
        RCC_LSEConfig(RCC_LSE_ON);
        while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) != SET)
            ;
        // 3.选择RCCCLK时钟源
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
        RCC_RTCCLKCmd(ENABLE);
        // 4.等待同步写入完成防止时钟不同步出现时钟bug 不写影响也不大
        RTC_WaitForSynchro();
        RTC_WaitForLastTask();
        // 5.配置PSC 对PRL寄存器写操作函数已经实现进入配置模式和退出配置模式不需要手写
        RTC_SetPrescaler(32768 - 1); // LSE时钟频率32.768KHz = 32768Hz进行32768分频= 1Hz
        RTC_WaitForLastTask();       // 写操作都需要等待一下
        // 6.设置初始时间
        MyRTC_SetTime();
        // 向BKPDR1写入设置的值备用电源断了则清空DR1
        BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
    }
    // 备用电源没有掉则只需要同步一下即可
    else
    {
        RTC_WaitForSynchro();
        RTC_WaitForLastTask();
    }
}
void MyRTC_SetTime(void)
{
    time_t time_cnt; // 时间戳
    struct tm time_date;
    time_date.tm_year = MyRTC_Time[0] - 1900;
    time_date.tm_mon = MyRTC_Time[1] - 1;
    time_date.tm_mday = MyRTC_Time[2];
    time_date.tm_hour = MyRTC_Time[3];
    time_date.tm_min = MyRTC_Time[4];
    time_date.tm_sec = MyRTC_Time[5];
    time_cnt = mktime(&time_date) - 8 * 60 * 60;
    RTC_SetCounter(time_cnt);
    RTC_WaitForLastTask();
}
void MyRTC_ReadTime(void)
{
    time_t time_cnt;
    struct tm time_date;
    time_cnt = RTC_GetCounter() + 8 * 60 * 60;
    time_date = *localtime(&time_cnt);
    MyRTC_Time[0] = time_date.tm_year + 1900;
    MyRTC_Time[1] = time_date.tm_mon + 1;
    MyRTC_Time[2] = time_date.tm_mday;
    MyRTC_Time[3] = time_date.tm_hour;
    MyRTC_Time[4] = time_date.tm_min;
    MyRTC_Time[5] = time_date.tm_sec;
}

十二、PWR

12.1 PWR简介

PWR（Power Control）电源控制
PWR负责管理STM32内部的电源供电部分，可以实现可编程电压监测器和低功耗模式的功能
可编程电压监测器（PVD）可以监控VDD电源电压，当VDD下降到PVD阀值以下或上升到PVD阀值
之上时，PVD会触发中断，用于执行紧急关闭任务
低功耗模式包括睡眠模式（Sleep）、停机模式（Stop）和待机模式（Standby），可在系统空闲
时，降低STM32的功耗，延长设备使用时间

电源框图：

上电复位和掉电复位：

可编程电压监测器：

低功耗模式：

模式选择：

睡眠模式：

执行完WFI/WFE指令后，STM32进入睡眠模式，程序暂停运行，唤醒后程序从暂停的地方继续运行
SLEEPONEXIT位决定STM32执行完WFI或WFE后，是立刻进入睡眠，还是等STM32从最低优先级的
中断处理程序中退出时进入睡眠
在睡眠模式下，所有的I/O引脚都保持它们在运行模式时的状态
WFI指令进入睡眠模式，可被任意一个NVIC响应的中断唤醒
WFE指令进入睡眠模式，可被唤醒事件唤醒

停机模式：
执行完WFI/WFE指令后，STM32进入停止模式，程序暂停运行，唤醒后程序从暂停的地方继续运行
1.8V供电区域的所有时钟都被停止，PLL、HSI和HSE被禁止，SRAM和寄存器内容被保留下来
在停止模式下，所有的I/O引脚都保持它们在运行模式时的状态
当一个中断或唤醒事件导致退出停止模式时，HSI被选为系统时钟
当电压调节器处于低功耗模式下，系统从停止模式退出时，会有一段额外的启动延时
WFI指令进入停止模式，可被任意一个EXTI中断唤醒
WFE指令进入停止模式，可被任意一个EXTI事件唤醒

待机模式：
执行完WFI/WFE指令后，STM32进入待机模式，唤醒后程序从头开始运行
整个1.8V供电区域被断电，PLL、HSI和HSE也被断电，SRAM和寄存器内容丢失，只有备份的寄存
器和待机电路维持供电
在待机模式下，所有的I/O引脚变为高阻态（浮空输入）
WKUP引脚的上升沿、RTC闹钟事件的上升沿、NRST引脚上外部复位、IWDG复位退出待机模式

12.2 修改主频

代码：

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
int main(void)
{
    OLED_Init();
    OLED_ShowString(1, 1, "SYSCLK:");
    OLED_ShowNum(1, 8, SystemCoreClock, 8);
    while (1)
    {
        OLED_ShowString(2, 1, "Running...");
        Delay_ms(500);
        OLED_ShowString(2, 1, "         ");
        Delay_ms(500);
    }
}

12.3 数据收发+睡眠模式

代码：

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"
uint8_t RxData;
uint8_t Pin_9, Pin_10;
int main(void)
{
    OLED_Init();
    Serial_Init();
    OLED_ShowString(1, 1, "RxData:");
    while (1)
    {
        if (Serial_GetRxFlag() == 1)
        {
            RxData = Serial_GetRxData();
            Serial_SendByte(RxData);
            OLED_ShowHexNum(1, 8, RxData, 2);
        }
        // 没有数据要发送但代码一直执行所以可以采用睡眠模式
        OLED_ShowString(2, 1, "Running...");
        Delay_ms(500);
        OLED_ShowString(2, 1, "         ");
        Delay_ms(500);
        __WFI(); // 中断唤醒
    }
}

12.4 停止模式

常用函数：

void PWR_DeInit(void);
void PWR_BackupAccessCmd(FunctionalState NewState); // 使能后备区域的访问
// 配置PVD使能电压
void PWR_PVDCmd(FunctionalState NewState);
void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel);
// 使能WKUP引脚唤醒功能在待机模式下使用
void PWR_WakeUpPinCmd(FunctionalState NewState);
// 进入停止模式
void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry);
// 进入待机模式
void PWR_EnterSTANDBYMode(void);
FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG);
void PWR_ClearFlag(uint32_t PWR_FLAG);

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "CountSensor.h" //红外对射式传感器
int main(void)
{
    OLED_Init();
    CountSensor_Init();
    OLED_ShowString(1, 1, "Count:");
    while (1)
    {
        OLED_ShowNum(1, 7, CountSensor_Get(), 5);
        OLED_ShowString(2, 1, "Running...");
        Delay_ms(500);
        OLED_ShowString(2, 1, "         ");
        Delay_ms(500);
        PWR_EnterSTOPMode(PWR_Regulator_ON, PWR_STOPEntry_WFI); // 进入停止模式中断唤醒
        SystemInit(); // 进入停止模式之后主频被修改为HSI时钟8MHz 需要恢复一下系统时钟
    }
}

12.5 待机模式：

实时时钟+待机

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "RTC.h"
int main(void)
{
    OLED_Init();
    MyRTC_Init();
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE); // 保证RTC在待机模式下能够正常执行不那么依赖MyRTC
    OLED_ShowString(1, 1, "CNT:");
    OLED_ShowString(2, 1, "ALR:");
    OLED_ShowString(3, 1, "ALRF:");
    PWR_WakeUpPinCmd(ENABLE); // WKUP接高电平也可以唤醒程序
    uint32_t Alarm = RTC_GetCounter() + 10;
    RTC_SetAlarm(Alarm);
    OLED_ShowNum(2, 6, Alarm, 10);
    while (1)
    {
        OLED_ShowNum(1, 6, RTC_GetCounter(), 10);
        OLED_ShowNum(3, 6, RTC_GetFlagStatus(RTC_FLAG_ALR), 1); // 闹钟标志位
        OLED_ShowString(4, 1, "Running...");
        Delay_ms(500);
        OLED_ShowString(4, 1, "         ");
        Delay_ms(500);
        OLED_ShowString(4, 9, "STANDBY...");
        Delay_ms(500);
        OLED_ShowString(4, 1, "         ");
        Delay_ms(500);
        // 一般用于极度省电模式把能关的外设都关闭
        OLED_Clear();
        PWR_EnterSTANDBYMode(); // 代码从头开始运行会自动调用System_Init()
    }
}

十三、看门狗WDG

13.1 WDG简介

WDG（Watchdog）看门狗
看门狗可以监控程序的运行状态，当程序因为设计漏洞、硬件故障、电磁干扰等原因，出现卡死或
跑飞现象时，看门狗能及时复位程序，避免程序陷入长时间的罢工状态，保证系统的可靠性和安全
性看门狗本质上是一个定时器，当指定时间范围内，程序没有执行喂狗（重置计数器）操作时，看门
狗硬件电路就自动产生复位信号
STM32内置两个看门狗
独立看门狗（IWDG）：独立工作，对时间精度要求较低
窗口看门狗（WWDG）：要求看门狗在精确计时窗口起作用

IWDG框图:

IWDG键寄存器:

键寄存器本质上是控制寄存器，用于控制硬件电路的工作
在可能存在干扰的情况下，一般通过在整个键寄存器写入特定值来代替控制寄存器写入一位的功
能，以降低硬件电路受到干扰的概率

IWDG超时时间:

13.2 窗口看门狗WWDG

WWDG工作特性:

递减计数器T[6:0]的值小于0x40时，WWDG产生复位
递减计数器T[6:0]在窗口W[6:0]外被重新装载时，WWDG产生复位
递减计数器T[6:0]等于0x40时可以产生早期唤醒中断（EWI），用于重装载计数器以避免WWDG复
位定期写入WWDG_CR寄存器（喂狗）以避免WWDG复位

WWDG超时时间:
超时时间：
TWWDG = TPCLK1 4096 WDGTB预分频系数 (T[5:0] + 1)
窗口时间：
TWIN = TPCLK1 4096 WDGTB预分频系数 (T[5:0] – W[5:0])
其中：TPCLK1 = 1 / FPCLK1

IWDG和WWDG对比:

1. 看门狗一旦启用就无法关闭，防止误操作
2. 烧入代码的时候需要按着复位键，再松开

13.3 实现IWDG

常用函数：

void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess); // 写使能控制
void IWDG_SetPrescaler(uint8_t IWDG_Prescaler);      // 写预分频器PR
void IWDG_SetReload(uint16_t Reload);                // 写重装值RLR
void IWDG_ReloadCounter(void);                       // 重新装载寄存器0xAAAA 喂狗
void IWDG_Enable(void);                              // 启用IWDG0xCCCC
FlagStatus IWDG_GetFlagStatus(uint16_t IWDG_FLAG);
// 查看看门狗标志位
FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG);
void RCC_ClearFlag(void);

代码：
修改oled

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
int main(void)
{
    OLED_Init();
    OLED_ShowString(1, 1, "IWDG TEST");
    if (RCC_GetFlagStatus(RCC_FLAG_IWDGRST) == SET)
    {
        OLED_ShowString(2, 1, "IWDGRST");
        Delay_ms(500);
        OLED_ShowString(2, 1, "       ");
        Delay_ms(100);
        RCC_ClearFlag();
    }
    else
    {
        OLED_ShowString(2, 1, "RST");
        Delay_ms(500);
        OLED_ShowString(2, 1, "       ");
        Delay_ms(100);
    }
    // 设置看门狗
    IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
    // 1000ms
    IWDG_SetPrescaler(IWDG_Prescaler_16);
    IWDG_SetReload(2499);
    // 开启前先喂一次狗
    IWDG_ReloadCounter();
    IWDG_Enable();
    while (1)
    {
        Key_GetNum();                  // 模拟卡死一直按着按键超时
        IWDG_ReloadCounter();          // 主循环需要一直喂狗
        OLED_ShowString(4, 1, "FEED"); // 表示feed
        Delay_ms(200);
        OLED_ShowString(4, 1, "   ");
        Delay_ms(200);
    }
}

13.4 实现WWDG

常用函数：

void WWDG_DeInit(void);
void WWDG_SetPrescaler(uint32_t WWDG_Prescaler);
void WWDG_SetWindowValue(uint8_t WindowValue);
void WWDG_EnableIT(void);
void WWDG_SetCounter(uint8_t Counter);
void WWDG_Enable(uint8_t Counter);
FlagStatus WWDG_GetFlagStatus(void);
void WWDG_ClearFlag(void);

#include "stm32f10x.h"                 // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
int main(void)
{
    OLED_Init();
    OLED_ShowString(1, 1, "IWDG TEST");
    if (RCC_GetFlagStatus(RCC_FLAG_WWDGRST) == SET)
    {
        OLED_ShowString(2, 1, "WWDGRST");
        Delay_ms(500);
        OLED_ShowString(2, 1, "       ");
        Delay_ms(100);
        RCC_ClearFlag();
    }
    else
    {
        OLED_ShowString(2, 1, "RST");
        Delay_ms(500);
        OLED_ShowString(2, 1, "       ");
        Delay_ms(100);
    }
    // 设置窗口看门狗
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
    WWDG_SetPrescaler(WWDG_Prescaler_8);
    WWDG_SetWindowValue(0x40 | 21); // 30ms
    WWDG_Enable(0x40 | 54);
        //|0x40是设置T6 50ms
        while (1)
    {
        Key_GetNum(); // 模拟卡死一直按着按键超时
        // WWDG_SetCounter(0x40 | 54); //主循环需要一直喂狗喂狗太早
        // OLED_ShowString(4,1,"FEED"); //表示feed
        // Delay_ms(20);
        // OLED_ShowString(4,1,"   ");
        // Delay_ms(20);
        Delay_ms(20);
        WWDG_SetCounter(0x40 | 54); // 放在40ms延时之后
    }
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: CF-937（D,E）

CF-937 在补题…… D 分析 我们发现这些因子都是二进制形式的十进制数，n的范围是$1e5$，16的二进制是$10000$,于是可以枚举1~16，把这些因子预处理出来，对于每个n就枚举因子再作除，看剩下的数每位是不是只有0与1 代码 #include u…