1、程序的书写结构 虽然书写格式并不会影响生成的代码质量，但是在实际编写程序时还是应该遵循一定的书写规则，一个书写清晰、明了的程序，有利于以后的维护。 在书写程序时，特别是对于While、for、do…while、if…else、switch…case 等语句或这些语句嵌套组合时，应采用“缩格”的书写形式。 2、标识符 程序中使用的用户标识符除要遵循标识符的命名规则以外，一般不要用代数符号(如a、b、x1、y1)作为变量名，应选取具有相关含义的英文单词(或缩写)或汉语拼音作为标识符，以增加程序的可读性，如：count、number1、red、work 等。 3、程序结构 C 语言是一种高级程序设计语言，提供了十分完备的规范化流程控制结构。因此在采用C 语言设计单片机应用系统程序时，首先要注意尽可能采用结构化的程序设计方法，这样可使整个应用系统程序结构清晰，便于调试和维护。 对于一个较大的应用程序，通常将整个程序按功能分成若干个模块，不同模块完成不同的功能。 各个模块可以分别编写，甚至还可以由不同的程序员编写，一般单个模块完成的功能较为简单，设计和调试也相对容易一些。在C 语言中，一个函数就可以认为是一个模块。 所谓程序模块化，不仅是要将整个程序划分成若干个功能模块，更重要的是，还应该注意保持各个模块之间变量的相对独立性，即保持模块的独立性，尽量少使用全局变量等。对于一些常用的功能模块，还可以封装为一个应用程序库，以便需要时可以直接调用。 但是在使用模块化时，如果将模块分成太细太小，又会导致程序的执行效率变低(进入和退出一个函数时保护和恢复寄存器占用了一些时间)。 4、定义常数 在程序化设计过程中，对于经常使用的一些常数，如果将它直接写到程序中去，一旦常数的数值发生变化，就必须逐个找出程序中所有的常数，并逐一进行修改，这样必然会降低程序的可维护性。因此，应尽量当采用预处理命令方式来定义常数，而且还可以避免输入错误。 5、减少判断语句 能够使用条件编译(ifdef)的地方就使用条件编译而不使用if 语句，有利于减少编译生成的代码的长度。 6、表达式 对于一个表达式中各种运算执行的优先顺序不太明确或容易混淆的地方，应当采用圆括号明确指定它们的优先顺序。一个表达式通常不能写得太复杂，如果表达式太复杂，时间久了以后，自己也不容易看得懂，不利于以后的维护。 7、函数 对于程序中的函数，在使用之前，应对函数的类型进行说明，对函数类型的说明必须保证它与原来定义的函数类型一致，对于没有参数和没有返回值类型的函数应加上“void”说明。如果需要缩短代码的长度，可以将程序中一些公共的程序段定义为函数。 如果需要缩短程序的执行时间，在程序调试结束后，将部分函数用宏定义来代替。注意，应该在程序调试结束后再定义宏，因为大多数编译系统在宏展开之后才会报错，这样会增加排错的难度。 8、尽量少用全局变量，多用局部变量 因为全局变量是放在数据存储器中，定义一个全局变量，MCU 就少一个可以利用的数据存储器空间，如果定义了太多的全局变量，会导致编译器无足够的内存可以分配；而局部变量大多定位于MCU 内部的寄存器中，在绝大多数MCU 中，使用寄存器操作速度比数据存储器快，指令也更多更灵活，有利于生成质量更高的代码，而且局部变量所能占用的寄存器和数据存储器在不同的模块中可以重复利用。 9、设定合适的编译程序选项 许多编译程序有几种不同的优化选项，在使用前应理解各优化选项的含义，然后选用最合适的一种优化方式。通常情况下一旦选用最高级优化，编译程序会近乎病态地追求代码优化，可能会影响程序的正确性，导致程序运行出错。 因此应熟悉所使用的编译器，应知道哪些参数在优化时会受到影响，哪些参数不会受到影响。 代码的优化 1、选择合适的算法和数据结构 应熟悉算法语言。将比较慢的顺序查找法用较快的二分查找法或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，这样可以大大提高程序执行的效率。 选择一种合适的数据结构也很重要，比如在一堆随机存放的数据中使用了大量的插入和删除指令，比使用链表要快得多。数组与指针具有十分密切的关系，一般来说指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。 但是在Keil 中则相反，使用数组比使用的指针生成的代码更短。 2、使用尽量小的数据类型 能够使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；能够使用整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就不要使用浮点型变量。 当然，在定义变量后不要超过变量的作用范围，如果超过变量的范围赋值，C 编译器并不报错，但程序运行结果却错了，而且这样的错误很难发现。 3、使用自加、自减指令 通常使用自加、自减指令和复合赋值表达式(如a-=1 及a+=1 等)都能够生成高质量的程序代码，编译器通常都能够生成inc 和dec 之类的指令，而使用a=a+1 或a=a-1之类的指令，有很多C 编译器都会生成2~3个字节的指令。 4、减少运算的强度 可以使用运算量小但功能相同的表达式替换原来复杂的的表达式。如下： (1)求余运算 a=a%8; 可以改为： a=a&7; 说明：位操作只需一个指令周期即可完成，而大部分的C 编译器的“%”运算均是调用子程序来完成，代码长、执行速度慢。通常，只要求是求2n 方的余数，均可使用位操作的方法来代替。 (2)平方运算 a=pow(a,2.0); 可以改为： a=a*a; 说明：在有内置硬件乘法器的单片机中(如51 系列)，乘法运算比求平方运算快得多，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的AVR 单片机中，如ATMega163 中，乘法运算只需2 个时钟周期就可以完成。 即使是在没有内置硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。如果是求3 次方，如： a=pow(a,3.0); 更改为： a=a*a*a； 则效率的改善更明显。 (3)用移位实现乘除法运算 a=a*4; b=b/4; 可以改为： a=a<<2; b=b>>2; 说明：通常如果需要乘以或除以2n，都可以用移位的方法代替。在ICCAVR 中，如果乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。 用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以用移位的方法得到结果，如： a=a*9 可以改为： a=(a<<3)+a 5、循环 (1)循环语对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作全部集合在一起，放到一个init 的初始化程序中进行。 (2)延时函数 通常使用的延时函数均采用自加的形式： void delay (void){unsigned int i;for (i=0;i<1000;i++); }将其改为自减延时函数：void delay (void){unsigned int i;for (i=1000;i>0;i--); } 两个函数的延时效果相似，但几乎所有的C 编译对后一种函数生成的代码均比前一种代码少1~3 个字节，因为几乎所有的MCU 均有为0转移的指令，采用后一种方式能够生成这类指令。在使用while 循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少1~3 个字母。 但是在循环中有通过循环变量“i”读写数组的指令时，使用预减循环时有可能使数组超界，要引起注意。 (3)while 循环和do…while 循环 用while 循环时有以下两种循环形式： unsigned int i;i=0;while (i<1000){i++; //用户程序}或：unsigned int i;i=1000;do{i--; //用户程序}while (i>0); 在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。 6、查表 在程序中一般不进行非常复杂的运算，如浮点数的乘除及开方等，以及一些复杂的数学模型的插补运算，对这些即消耗时间又消费资源的运算，应尽量使用查表的方式，并且将数据表置于程序存储区。 如果直接生成所需的表比较困难，也尽量在启动时先计算，然后在数据存储器中生成所需的表，后面在程序运行直接查表就可以了，减少了程序执行过程中重复计算的工作量。 7、其它 比如使用在线汇编及将字符串和一些常量保存在程序存储器中，均有利于优化。 乘除法优化 目前单片机的市场竞争很激烈，许多应用出于性价比的考虑，选择使用程序存储空间较小（如1K，2K）的小资源8位MCU芯片进行开发。一般情况下，这类MCU没有硬件乘法、除法指令，在程序必须使用乘除法运算时，如果单纯依靠编译器调用内部函数库来实现，常常会有代码量偏大、执行效率偏低的缺点。 上海晟矽微电子推出的MC30、MC32系列MCU，采用了RISC架构，在小资源8位MCU领域有广大的用户群和广泛的应用，本文就以晟矽微电的这两个系列产品的指令集为例，结合汇编与C编译平台，给大家介绍一种既省时又节约资源的乘除法算法。 1、乘法篇 单片机中的乘法是二进制的乘法，也就是把乘数的各个位与被乘数相乘，然后再相加得出，因为乘数和被乘数都是二进制，所以实际编程时每一步的乘法可以用移位实现。 例如：乘数R3=01101101，被乘数R4=11000101，乘积R1R0。步骤如下： 1、清空乘积R1R0； 2、乘数的第0位是1，那被乘数R4需要乘上二进制数1，也就是左移0位，加到R1R0里; 3、乘数的第1位是0，忽略； 4、乘数的第2位是1，那被乘数R4需要乘上二进制数100，也就是左移2位，加到R1R0里； 5、乘数的第3位是1，那被乘数R4需要乘上二进制数1000，也就是左移3位，加到R1R0里； 6、乘数的第4位是0，忽略； 7、乘数的第5位是1，那被乘数R4需要乘上二进制数100000，也就是左移5位，加到R1R0里； 8、乘数的第6位是1，那被乘数R4需要乘上二进制数1000000，也就是左移6位，加到R1R0里； 9、乘数的第7位是0，忽略； 10、这时候R1R0里的值就是最后的乘积，至此算法完成。 以上例子运算结果： R1R0 = R3 * R4= (R4<<6)+(R4<<5)+(R4<<3)+(R4<<2)+R4 = 101001111100001 实际运算流程图见下图： 在实际的程序设计过程中，程序优化有两个目标，提高程序运行效率，和减少代码量。我们来看下本文提供的汇编算法和普通C语言编程的效率和代码量对比。 表1.1是程序运行效率的对比数据（可能会有小的偏差），很明显汇编编译出来的运行时间要比C语言减少很多。 汇编（时钟周期） C语言（时钟周期） 8*8位乘法 79-87 184-190 16*8位乘法 201-210 362-388 16*16位乘法 234-379 396-468 表1.1 乘法运算时钟周期对比表 表1.2是程序代码量的对比数据（可能会有小的偏差），汇编占用的程序空间也要比C语言小很多。 汇编（Byte） C语言（Byte） 8*8位乘法 15 34 16*8位乘法 19 96 16*16位乘法 31 96 表1.2 乘法运算ROM空间使用情况对比表 综上两点，本文介绍的乘法算法各方面使用情况都要比C编译好很多。如果大家在使用过程中，原有的程序不能满足应用需求，例如遇到程序空间不够或者运行时间太久等问题，都可以按照以上方式进行优化。 汇编语言最接近机器语言的。在汇编语言中可以直接操作寄存器，调整指令执行顺序。由于汇编语言直接面对硬件平台，而不同的硬件平台的指令集及指令周期均有较大差异，这样会对程序的移植和维护造成一定的不便，所以我们针对精简指令集做了乘法运算的例程，便于大家的移植和理解。 2、除法篇 单片机中的除法也是二进制的除法，和现实中数学的除法类似，是从被除数的高位开始，按位对除数进行相除取余的运算，得出的余数再和之后的被除数一起再进行新的相除取余的运算，直到除不尽为止，因为单片机中的除法是二进制的，每个步骤除出来的商最大只有1，所以我们实际编程时可以把每一步的除法看作减法运算。 例如：被除数R3R4=1100110001101101，除数R5=11000101，商R1R0，余数R2。步骤如下： 1、清空商R1R0，余数R2；2、被除数放开最高位，第15位，为1，1比除数小，商为0，余数R2为1；3、上一步余数并上被除数次高位，第14位，得11，11仍然比除数小，商为0，余数R2为114、直到放开第8位后，得11001100，比除数大，商得1，余数R2为111；5、上一步余数并上被除数第7位，得1110，没有除数大，商为0，余数R2为1110；6、上一步余数并上被除数第6位，得11101，没有除数大，商为0，余数R2为11101；7、按照以上步骤，直到放开了被除数得第3位，得11101101，比除数大，商为1，余数R2为101000；8、上一步余数并上被除数第2位，得1010001，没有除数大，商为0，余数R2为1010001；9、上一步余数并上被除数第1位，得10100010，没有除数大，商为0，余数R2为10100010；10、上一步余数并上被除数第0位，得101000101，比除数大，商为1，余数R2为10000000；11、然后把以上所有步骤中得商从左至右依次排列就是最后的商100001001，余数为最后算得的余数10000000。 以上例子运算结果：R1R0 = R3R4 / R5 = 100001001 ；R2 = R3R4 % R5 = 10000000 实际运算流程图见下图： 除法运算的效率，代码量见以下表格 表2.1是程序运行效率和代码量的对比数据（可能会有小的偏差），很明显本文提供的汇编算法要优化的很多。 16/8位除法 汇编 C语言 时钟周期 287-321 740-804 使用空间（Byte） 35 142 表2.1 除法运算时钟周期对比表 所以对于除法运算，本文提供的方法也是相对较优的。 以下是针对精简指令集做的除法运算，16/8位的例程，便于大家的移植和理解。
Bootloader是一个用于引导嵌入式系统的软件程序，通常存储在芯片的非易失性存储器中，如闪存。Bootloader的主要功能是在系统上电后，负责初始化系统硬件并加载操作系统或应用程序到内存中执行。 下面是一个简要的介绍Bootloader的工作流程和主要功能： 硬件初始化：Bootloader首先负责初始化处理器、时钟、内存和外设等硬件资源，确保系统处于合适的状态以便后续的操作。 引导设备选择：Bootloader可能需要检测可用的引导设备，例如闪存、外部存储器或串口等，并选择其中一个作为加载操作系统或应用程序的来源。 加载操作系统或应用程序：Bootloader根据预定义的引导策略，从选定的引导设备中读取操作系统镜像或应用程序，并将其加载到内存中。 执行加载的程序：一旦程序加载到内存中，Bootloader会跳转到该程序的入口点，启动执行。对于操作系统，这意味着将控制权移交给操作系统内核，而对于应用程序，它将开始执行应用程序的主函数。 错误处理和回滚：Bootloader通常包含错误处理机制，以便在发生错误时执行相应的操作，例如跳转到备用引导设备或者恢复到出厂设置状态。 升级支持：一些Bootloader还提供了固件升级的支持，允许通过特定的接口或协议更新系统固件，而无需物理访问设备。 总的来说，Bootloader在嵌入式系统中扮演着关键的角色，负责启动和管理系统的引导过程，同时提供了灵活性和可靠性，以适应不同的应用需求。 当我面对一个有一定规模、 稍显复杂的嵌入式项目时, 我通常并不会直接专注于主要功能的实现, 而是会做一些磨刀不误砍柴工的工作———设计一个 Bootloader(以下简称 BL) 以及构建一个Shell 框架。可能有人会觉得它们很高深, 实则不难, 正所谓“会者不难, 难者不会”。 本章就针对 BL 进行详细的讲解, 希望让大家可以体会到它的重要性。 1. 烧录方式的更新迭代 1.1 古老的烧录方式 单片机诞生于20 世纪80 年代, 以51 为代表开始广泛应用于工业控制、 家电等很多行业中。起初对于单片机的烧录, 也就是将可执行的程序写入到其内部的 ROM 中, 这不是一件容易的事情, 而且成本不低, 因为需要依赖于专门的烧录设备。而且受到半导体技术与工艺的限制, 对于 ROM 的烧写大多需要高压。这种境况一直持续到2000 年左右( 我上大学的时候还曾用过这种专门的烧录器),： 1.2 ISP 与ICP 烧录方式 随着低压电可擦写 ROM 的成熟, 单片机开始集成可通过数字电平直接读写的存储介质。其最大的优势在于可实现在系统或在电路直接烧录程序, 而无须像以前一样把单片机芯片从电路中拿出来, 放到编程器上, 这种烧录方式就是ISP(In System Programming) 或ICP (In Circuit Programming), 如图7.2 所示。 有人问过这样一个问题:“ISP 和ICP 我都听说过, 都说是可以在电路板上直接烧录程序,而无须拿下芯片, 那ISP 和ICP 有什么区别?”从广义上来说, 两者没有区别, 平时我们把其意义混淆也毫无问题。非要刨根问底的话, 那可以这样来理解:ISP 要求单片机中驻留有专门的程序, 用以与上位机进行通信, 接收固件数据并烧录到自身的 ROM 中, 很显然ISP 的单片机是需要可运行的, 即要具备基本的最小系统电路(时钟和复位); 而ICP 可以理解为 MCU 就是一块可供外部读写的存储电路, 它不需要预置任何程序, 也不需要单片机芯片处于可运行的状态。 支持ISP 或ICP 的芯片, 以 AT89S51 最为经典, 当时从 AT89C51 换成 S51 , 多少人曾因此不再依赖烧录器而大呼爽哉。这种并口下载线非常流行, 如图7.3 所示, 网上还有各种ISP小软件, 可以说它降低了很多人入门单片机的门槛, 让单片机变得喜闻乐见。一台电脑、一个S51 最小系统板、 一条并口ISP 下载线, 齐了! 1.3 更方便的ISP 烧录方式 1. 串口ISP 但是后来我们发现带有并口的电脑越来越少。那是在2005 年前后,STC 单片机开始大量出现, 在功能上其实与S51 相差无几, 甚至比同期的一些高端51 单片机还要逊色。但是它凭借一个优势让人们对它爱不释手, 进一步降低了单片机的学习门槛。这个优势就是———串口ISP, 这是真正意义上的ISP, 如图7.4 和图7.5 所示。再后来,9 针串口都很少见了, 只有 USB。这促使一个烧录和调试神器炙手可热———USB-TTL 串口。这下232 转换芯片省掉了, 直接通过 USB 进行烧录。这种方式造福了无数的单片机学习者和工程师。我本人虽然已经搞了近20 年单片机和嵌入式, USB 串口依然是不可或缺的调试工具。 多年来, 在串口与单片机的交互上, 我动了很多脑筋, 这也是我乐于开发 Bootloader 的一个原因。我希望“USB 串口在手, 一切全有!” STC 并不是第一个使用串口ISP 烧录程序的, 但它是最成功和最深入人心的。与之同期的很多单片机, 包括时至今日仍然应用最广泛的 STM32 全系列也都支持了串口ISP, 它成了一种标配的、 非常普遍的程序烧录手段。 2. 各种 USBISP 串口ISP 固然方便, 但是下载速度是它的硬伤, 当固件体积比较大的时候, 比如一些大型嵌入式项目的固件动辄几百 KB, 甚至几 MB, 再用串口ISP 就未免太慢了。所以一些单片机配有专门的 USBISP 下载器。以下列举几种比较主流的单片机及其 USBISP 下载器。 (1) AVR AVR 单片机曾经盛极一时, 但经历了2016 年的缺芯风波之后, 加之 STM32 的冲击, 开始变得一蹶不振, 鲜有人用了。与之配套的 USBISP 下载器非常多样, 有些是官方发布的, 更多的是爱好者开源项目的成果, 如图7.6 所示。 (2) C8051F( 见图7.7) (3) MSP430( 见图7.8) 我们会发现, 一个具有良好生态的主流单片机, 一定有配套的高效便捷的烧录下载工具。可见一种好的烧录方式, 对单片机开发是多么重要。 不论是串口ISP 还是各种专用的ISP 下载器, 都有一些共同的弊端。 依赖于专门的上位机或下载器硬件, 不能做到统型; 下载器价格仍然比较高, 尤其是原厂的, 这也是为什么有些单片机催生出很多第三方的下载器, 比如 AVR; 下载的时候通常需要附加额外的操作, 比如 STC 要重新上电、STM32 需要设置BOOT 引脚电平等。 这些额外的操作都增加了烧录的复杂性。尤其是在产品形态下要去重新烧录程序, 比如嵌入式升级, 就要打开外壳, 或将附加信号引出到壳外。 这都是非常不高效, 不友好的做法。如果有一种烧录方法, 对于任何一种单片机: 通信方式统一(比如一律都用串口); 提供一个友好的操作界面(比如命令行方式); 高效快速, 没有附加操作, 最好一键自动化烧录; 另外再增加一些嵌入式固件管理的功能(比如固件版本管理)。 这一定会让我们事半功倍。Bootloader 就能实现上述的这一切! 2. 关于Bootloader 2.1 Bootloader 的基本形态 直接看图7.9: 可以看到 BL 就是一段存储在 ROM 中的程序, 它主要实现4 个功能: 通过某种途径获取要烧录的固件数据; 将固件数据写入到 ROM 的 APP 区中; 跳转到 APP 区运行, 将烧录进去的用户程序引导起来; 在此过程中, 提供必要而友好的人机交互界面。这么说可能不好理解, 我们还是通过实例来进行讲解。 2.2 Bootloader 的两个设计实例 下面的两个实例, 用于说明 BL 的实际应用形态, 不涉及具体的实现细节, 旨在让大家了解 BL 实际是如何运行的。 1. 带Shell 命令行的串口BL 基本的操作逻辑如下: 通过超级终端、SecureCRT 或 Xshell 之类的串口终端输入命令program; BL 接收到命令后, 开始等待接收固件文件数据; 串口终端通过某种文件数据传输协议将固件数据传给 BL; BL 将固件数据写入到 ROM 的 APP 区中; BL 将 APP 区中的程序引导运行起来。更具体的示意如图7.10 所示。这里把操作逻辑说得很简单, 实际实现起来却并不容易, 我们放在后面去细究其具体实现。 2. 插SD 卡即烧录的BL 基本的操作逻辑如下: 将待烧录的固件拷贝到SD 卡中; 将SD 卡插入到卡槽中; BL 检测到SD 卡插入, 搜索卡中 BIN 文件; 将 BIN 文件数据读出写入到 ROM 的 APP 区中; BL 将 APP 区中的程序引导运行起来。 如图7.11 所示。通过这两个设计实例, 大家应该已经了解BL 是什么了吧。有没有感受到BL 是比ISP 烧录器更通用、 更灵活、 更友好、 功能更强大的固件烧录和管理手段呢? 有人可能知道 Linux 下的 Uboot, 它就是一个强大的 BL, 它提供非常强大的刷机(烧录操作系统镜像) 的功能以及完备而灵活的Shell 界面, 如图7.12 所示。其实我们电脑的 BIOS 也是一种广义的 BL。 那如何实现一个 BL 呢? 别急, 要实现 BL 是需要满足一些基本要求的。 2.3 BL 实现的要点 首先要说, 并不是任何一个单片机都可以实现 BL 的, 要满足几个要点。 1. 芯片体系架构要支持 来看图7.13 。 我们知道单片机程序的最开头是中断向量表, 包含了程序栈顶地址以及 Reset 程序入口,通过它才能把程序运行起来。很显然在从 BL 向 APP 跳转的时候,APP 程序必须有自己的中断向量表。而且单片机体系架构上要允许中断向量表的重定向。 传统51 单片机的中断向量表只允许放到 ROM 开头, 而不能有偏移量, 所以传统51单片机是不能支持 BL 的。有人要问“你这不是自相矛盾吗? 你前面说 STC 的51 单片机是支持串口ISP 的, 那它应该内置有ISP 程序, 我理解它应该和BL 是一个道理。”没错, 它内置的ISP程序就是一种 BL。STC 之所以可以实现 BL 功能, 是因为宏晶半导体公司对它的硬件架构进行了改进, 请看图7.14 可以看到,STC51 单片机多出了一块专门存放 BL 的 ROM, 称为 BOOTROM。 网上有一位叫 shaoziyang 的网友为 AVR 单片机写了一个 BL, 还配套开发了 一 款 叫AVRUBD 的上位机, 如图7.15 (AVRUBD 是很有用的, 本章后面会介绍, 它可以让我们实现隔空烧录) 所示, 实现了 AVR 单片机的串口烧录, 让很多人摆脱了对 USBISP 之类ISP 下载器的依赖(虽然ISP 下载器已经很方便了, 但它毕竟还需要银子嘛)。 AVR 在硬件架构上与STC51 是一个套路, 如图7.16 所示。 通过配置 AVR 的熔丝位可以控制复位入口地址以及 BOOT 区的大小和开始地址, 如图7.17 所示。 讲到这里, 有人会说:“那有没有一种单片机, 程序放在 ROM 的任何位置都可以运行起来, 也就是中断向量表可以重定位?”当然有, 这种单片机还很多, 其中最典型的就是 STM32。它的程序之所以可以放之各地皆可运行, 是因为在它的 NVIC 控制器中提供了中断向量表偏移量的相关配置, 这个后面我们再详细说。 2. ROM 要支持IAP 这也是需要单片机硬件支持的。很好理解, 在 BL 获取到固件数据之后, 需要将它写入到ROM 的 APP 区中, 所以说单片机需要支持IAP 操作, 所谓IAP 就是 In Application Programming, 即在应用烧录。也就是在程序运行过程中, 可以对自身 ROM 进行擦除和编程操作 。 大家仔细想想是不是这样? 似乎支持串口ISP 的单片机都支持IAP 功能。STC 还把这一功能包装成了它的一大特色, 可以用内部 ROM 来充当 EEPROM 的功能, 可以在运行时记录一些掉电不丢失的参数信息。 STM32 的 ROM 擦写在配套的固件库(标准库或 HAL 库) 中已经有实现, 大家可以参考或直接使用。 3. APP 程序的配套修改 为了让 BL 可以顺利地将 APP 程序引导运行起来, APP 程序在开发的时候需要配合 BL做出相应的修改。最重要的就是 APP 程序的开始地址(即中断向量表的开始地址) 以及对中断控制器的相应配置。 对于51 、AVR 这类单片机 APP 程序不用修改, 具体原因大家应该明白。这里主要对STM32 APP 程序如何修改进行详细讲解。 我们依然是结合实例, 如图7.18 所示。 假设我们所使用的STM32 的 ROM 总大小为128KB,BL 程序的体积是16KB,APP 程序紧邻 BL, 那么 APP 区的开始地址为0X08004000, 也就是 APP 程序的中断向量表偏移地址为0X4000。 如果我们使用 MDK 作为开发环境的话, 需要修改这里, 如图7.19 所示。 而如果我们使用的是gcc 的话, 则需要对link.ld 链接文件进行修改, 如图7.20 所示。 然后我们还需要对 NVIC 的中断向量表相关参数进行配置, 主要是中断向量表的偏移量,如下代码: #define VECT_TAB_OFFSET 0x4000 OK, 经过修改后的程序, 我们把它放到 ROM 的0X08004000 开始地址上, 然后再让 BL跳转到这个地址, 我们的程序就能运行起来了。 有人又会问:“BL 中的跳转代码怎么写?”别急, 这是我们要讲的下一个要点 4. BL 中的跳转代码 跳转代码是 BL 要点中的关键, 直接关系到 APP 程序能否正常运行, 如图7.21 所示。我直接给出STM32 的 jump _app 函数代码。 typedef void ( * iapfun)(void); iapfun jump2app; void MSR_MSP(u32 addr) { __ASM volatile("MSR MSP, r0" ); //set Main Stack value __ASM volatile("BX r14" ); } void load_app(u32 appxaddr) { if((( * (vu32* )appxaddr)&0x2FFE0000) ==0x20000000) //检查栈顶地址合法 { //用户代码区第二个字为程序开始地址(复位地址) jump2app= (iapfun) * (vu32* )(appxaddr+4); //初始化APP 堆栈指针(用户代码区的第一个字用于存放栈顶地址) MSR_MSP( * (vu32* )appxaddr); jump2app(); //跳转到APP. } } 这段代码大家自行研究, 如果展开讲就属于赘述了。到这里 BL 相关的要点就介绍完了, 大家应该有能力去完成一个简单的 BL 了。我基于STM32 设计了一个小实验, 大家有兴趣可以小试牛刀一下, 如图7.22 所示。 我们将 BL 程序用Jlink 烧录到0X08000000 位置, 而把 APP 程序烧录到0X08002000 开始位置, 然后复位, 如果串口打印了hello world 或流水灯亮起来了, 就说明我们的BL 成功了。 3. 把Bootloader 玩出花 上面我所讲的都是 BL 最基础的一些内容, 是我们实现 BL 所必须了解的。BL 真正的亮点在于多种多样的固件数据获取方式。 3.1 BL 的实现与延伸(串口传输固件) 前面我讲到过两个 BL 应用的实例, 一个是串口传输固件文件, 一个是 SD 卡拷贝固件文件。它们是在实际工程中经常被用到的两种 BL 形式。 这里着重对前一个实例的实现细节进行讲解剖析, 因为它非常具有典型意义, 如图7.23 所示。 这个流程图提出了3 个问题: 串口通信协议是如何实现的? 为什么获取到上位机传来的固件数据,不是直接写入到 APP 区,而是先暂存,还要校验? 对固件数据是如何实现校验的? 串口通信协议以及文件传输实现的相关内容略显繁杂, 在本书《 大话文件传输》一章中会专门进行讲解。 第二个问题: 经过串口传输最终由单片机接收到的固件数据是可能出现差错的, 而有错误的固件冒然直接写入到 APP 区, 是一定运行不起来的。所以, 我们要对数据各帧进行暂存, 等全部传输完成后, 对其进行整体校验, 以保证固件数据的绝对正确。 针对第三个问题, 我们要着重探讨一下。 一个文件从发送方传输到接收方, 如何确定它是否存在错误? 通常的做法在文件中加入校验码, 接收方对数据按照相同的校验码计算方法计算得到校验码, 将之与文件中的校验码进行对比, 一致则说明传输无误, 如图7.24 所示。 图7.24 是对固件文件的补齐以及追加校验码的示意。为什么要对文件补齐? 嵌入式程序经过交叉编译生成的可烧录文件, 比如 BIN, 多数情况下都不是128、256 、512 或1024 的整数倍。这就会导致在传输的时候, 最后一帧数据的长度不足整帧, 就会产生一个数据尾巴。取整补齐是解决数据尾巴最直接的方法。这一操作是在上位机上完成的, 通常是编写一个小软件来实现。这个小软件同时会将校验码追加到固件文件末尾。这个校验码可以使用校验和(CheckSum) 或者 CRC, 一般是16 位或32 位, 如图7.25 所示。 又有人会问:“要把整个固件暂存下来, 再作校验, 那得需要额外的存 储 空 间 吧, 外 扩ROM(FlashROM 或 EEPROM)?”是的。如果想节省成本, 我们也可以不暂存, 传输时直接烧写到 APP 区。这是有风险的, 但是一般来说问题不大(STC 和 STM32 的串口ISP 其实也都是实时烧写, 并不暂存)。因为在传输的过程中, 传输协议对数据的正确性是有一定保障的, 它会对每一帧数据进行校验, 失败的话会有重传, 连续失败可能会直接终止传输。所以说, 一般只要传输能够完成, 基本上数据正确性不会有问题。但是仍然建议对固件进行整体校验, 在成本允许的情况下适当扩大 ROM 容量。同时, 固件暂存还有一个另外的好处, 在 APP 区中的固件受到损坏的时候, 比如固件意外丢失或IAP 时不小心擦除了 APP 区, 此时我们还可以从暂存固件恢复回来(完备的 BL 会包含固件恢复的功能)。 其实也不必非要外扩 ROM, 如果固件体积比较小的话, 我们可以把单片机的片上 ROM砍成两半来用, 用后一半来作固件暂存。 如图7.26 所示, 我们将片上 ROM 划分为3 部分, 分别用于存储 BL、APP 固件以及暂存固件。比如 我 们 使 用 STM32F103RBT6 , 它 一 共 有 128 KB 的 ROM, 可 以 划 分 为 16 KB/ 56 KB/56 KB。 有些 产 品 对 成 本 极 为 敏 感。我 就 有 过 这 样 的 开 发 经 历, 当 时 使 用 的 单 片 机 是STM32F103C8T6 , 片上 ROM 总容量为64 KB, 固件大小为48 KB,BL 为12 KB。在通过BL进行固件烧写时根本没有多余的 ROM 进行固件暂存。我使用了一招“狗尾续貂”, 如图7.27所示。 我无意中了解到 STM32F103C8T6 与 RBT6 的晶元是同一个。只 是 因 为 有 些 芯 片 后64 KB 的 ROM 性能不佳或有瑕疵, 而被限制使用了。我实际测试了一下, 确实如此。但是后64 KB ROM 的使用是有前提的, 也就是需要事先对其好坏进行验证。如果是好的, 则暂存校验, 再写入 APP 区; 而如果是坏的, 那么就直接在固件传输时实时写入 APP 区(这个办法我屡试不爽, 还没有发现后64KB 有坏的)。 以上所介绍的是一种“骚操作”, 根本上还是有一定的风险的,ST 官方有声明过, 对后64K ROM 的质量不作保证, 所以还是要慎用。 3.2 10 米之内隔空烧录 OTA (On the Air) 这个“隔空烧录”源于我的一个IoT 项目, 它是对空调的外机进行工况监测。大家知道,空调外机的安装那可不是一般人能干的, 它要不就在楼顶, 要不就在悬窗上。这给硬件升级嵌入式程序带来很大的困难。所以, 我实现了“隔空烧录”的功能, 其实它就是串口 BL 应用的一个延伸, 如图7.28 所示。 “隔空烧录确实牛, 但是总要抱着一个电脑, 这不太方便吧。”确实是! 还记得前面我提过的 AVRUBD 通信协议吗? (详见“大话文件传输”一章) 它的上位机软件是有手机版的。这样我们只要有手机, 就能“隔空烧录”了, 如图7.29 所示。 “哪个 APP? 快告诉我名字”, 别急, 蓝牙串口助手安卓版, 图 7.30 是正在传输固件的界面。 AVRUBD 其实是对 Xmodem 协议的改进, 这个我们放在专门的章节进行详细讲解。 3.3 BL 的分散烧录 我们知道 BL 的核心功能其实就是程序烧录。那你有没有遇到过比较复杂的情况, 如图7.31 所示。 这种情况是有可能遇到的。主 MCU+CPLD+ 通信协处理器+ 采集协处理器就是典型的复杂系统架构。这种产品在批量生产阶段, 烧录程序是非常烦琐的。首先需要维护多个固件, 再就是需要一个个给每一个部件进行烧写, 烧写方式可能还不尽相同。所以我引入了一个机制, 叫“BL 的分散烧录”。 首先我们将所有的固件拼装成一个大固件(依次数据拼接), 并将这个大固件预先批量烧录到外扩 ROM 中, 比如spiFlash; 再将主 MCU 预先烧录好 BL; 然后进行SMT 焊接。PCBA生产出来之后, 只要一上测试工装(首次上电),BL 会去外扩 ROM 中读取大固件, 并从中分离出各个小固件, 分别以相应的接口烧录到各个部件中去。配合工装的测试命令, 直接进行自检。这样做, 批量化生产是非常高效的。当然, 这个 BL 开发起来也会有一定难度, 最大问题可能还是各个部件烧录接口的实现( 有些部件的烧录协 议 是 比 较 复 杂 的, 比 如 STM32 的SWD 或者 ESP8266 的SLIP)。 OK, 上面对一些 BL 实例的实现和应用场景进行了介绍。还有一些实例没有介绍, 比如通过 CAN 总线或SPI 进行文件传输, 这个我们还是放到专门的章节去详细讲解。当然, 各位读者可以在此基础上衍生出更多有特色而又实用的 BL 来。 BL 没有最好的, 只有最适合自己的。通常来说, 我们并不会把 BL 设计得非常复杂, 原则上它应该尽量短小精炼, 以便为 APP 区节省出更多的 ROM 空间。毕竟不能喧宾夺主, APP才是产品的主角。 4. 不走寻常路的BL 4.1 Bootpatcher 我来问大家一个问题:“Bootloader 在 ROM 中的位置一定是在 APP 区前面吗?”很显然不是,AVR 就是最好的例子。那如果我们限定是STM32 呢? 似乎是的。上电复位一定是从0X08000000 位置开始运行的, 而且 BL 一定是先于 APP 运行的。 在某些特殊的情况下, 如果 APP 必须要放在0X08000000 位置上的话, 请问还有办法实现 BL 串口烧录吗? 要知道 APP 在运行的时候, 是不能IAP 自己的程序存储器的(就是自己不能擦除自己来烧录新固件), 如图7.32 所示。 APP 运行时, 想要重新烧录自身, 它可以直接跳转到后面的BL 上,BL 运行起来之后开始接收固件文件, 暂存校验 OK 之后, 将固件写入到前面的 APP 区。然后跳转到0X08000000, 或者直接重启。这样新的 APP 就运行起来了。这个位于 APP 后面的 BL, 我们称之为 Bootpatcher(意为启动补丁)。但是这种做法是有风险的, 一旦 APP 区烧录失败, 那产品就变砖了。所以这种方法一般不用。 4.2 APP 反烧BL 前面我们都是在讲 BL 烧录 APP, 那如果 BL 需要升级怎么办呢? 用JLINK。不错, 不过有更直接的方法, 如图7.33 所示。 这是一种逆向思维, 我们在 APP 程序中也实现接收固件文件, 暂存校验, 然后将其烧录到BL 区。这种做法与 Bootpatcher 同理, 也是有一定风险的, 但一般都没有问题。
一、深入理解IO 1、什么是操作系统IO I/O，即输入（input）和输出（output），也可以理解为读（Read）和写（Write）； I/O模式可以划分为本地IO，模型（内存、磁盘）和网络IO模型； I/O关系到用户空间和内核空间的转换，也称为用户缓冲区和内核缓冲区； 用户态的应用程序不能直接操作内核空间，需要将数据从内核空间拷贝到用户空间才能使用。 read和write操作，都只能在内核空间里执行，磁盘IO和网络IO请求都是先放在内核空间，然后加载到用户态内存的数据。 2、IO读写性能差距实操 # dd用于指定大小的块，拷贝一个文件，并在拷贝的同时进行转换。# if=文件名：输入文件名，缺省为标准输入，即指定源文件# of=文件名：输出文件名，缺省为标准输出，即指定目的文件# bs=bytes：同时设置读入/输出的块大小为bytes个字节# count=blocks：仅拷贝blocks个块，块大小等于指定的字节数# bs是每次读或写的大小，即一个块的大小，count是读写块的数量。 # 释放所有缓存echo 3 > /proc/sys/vm/drop_caches # 操作一dd if=/dev/zero of=xdclass_testio1 bs=1M count=1024echo 3 > /proc/sys/vm/drop_caches # 操作二dd if=/dev/zero of=xdclass_testio2 bs=1M count=1024 oflag=directecho 3 > /proc/sys/vm/drop_caches# 操作三dd if=/dev/zero of=xdclass_testio3 bs=1M count=1024 oflag=sync 我们可以发现，参数的不同，会导致磁盘IO速度的不同： 没有oflag参数时，文件复制速度是oflag=direct的数倍：默认是buffered I/O，数据写到缓存层便返回，所以速度最快。 oflag=direct的速度比oflag=sync快一些：数据写到磁盘缓存便返回，但是速度比buffered I/O慢一些。 oflag=sync的速度最慢：写入的数据全部落盘才返回，所以速度比上面的仅写到磁盘缓存慢。 物理磁盘也会带有缓存disk cache，用于提高I/O速度，一般磁盘中带有电容，断电也能把缓存数据刷写到磁盘中。 3、什么是文件系统 （1）简介 在Linux系统中，一切皆是文件，文件系统管理磁盘上的全部文件，文件管理组织方式多种多样，所以文件系统存在多样化。 系统把文件持久化存储在磁盘上，文件系统就会实现文件数据的查询和存储。 文件系统是管理数据，而存储数据的物理设备有硬盘、U盘、SD卡、网络存储设备等。 不同的存储设备其物理结构不同，不同的物理结构就需要不同的文件系统去管理。 比如说，Windows有FAT12、FAT16、FAT32、NTFS、exFAT等文件系统；Linux有Ext2、Ext3、Ext4、tmpfs、NFS等文件系统。 # 查询系统用了哪些文件系统 [root@localhost test]# df -h -TFilesystem Type Size Used Avail Use% Mounted ondevtmpfs devtmpfs 1.9G 0 1.9G 0% /devtmpfs tmpfs 1.9G 0 1.9G 0% /dev/shmtmpfs tmpfs 1.9G 8.7M 1.9G 1% /runtmpfs tmpfs 1.9G 0 1.9G 0% /sys/fs/cgroup/dev/sda1 xfs 40G 22G 19G 54% /tmpfs tmpfs 379M 0 379M 0% /run/user/0overlay overlay 40G 22G 19G 54% /var/lib/docker/overlay2/6cce6b0ef229cb98e74ac34161938ffb11333b4f4fd26c298a53e8cc714e2d55/mergedoverlay overlay 40G 22G 19G 54% /var/lib/docker/overlay2/ae42c3f3e656cc8e13fe70723172f0756769edf4ac89fe2b8d1afe34f293718d/merged （2）索引节点和目录项 索引节点（index）： 简称inode，记录文件的元信息，比如文件大小、访问权限、修改日期、数据存储位置等； 索引节点也需要持久化存储，占用磁盘空间。 目录项（directory entry）： 简称为dentry，记录目录结构，比如文件的名字、索引节点和其他目录项的关联关系登，树状结构居多； 存储在内存中，也叫目录项缓存。 （3）什么是虚拟文件系统VFS（Virtual File System） 操作系统上有那么多的文件系统和物理存储介质，就是靠着虚拟文件系统为各类文件系统提供统一的接口进行交互，应用程序调用读写位于不同物理介质上的不同文件系统。 虚拟文件系统在应用程序和具体的文件系统之间引入了一个抽象层，开发者不用关心底层的存储介质和文件系统类型就可以使用。 （4）Linux的IO存储栈 https://www.thomas-krenn.com/en/wiki/Linux_Storage_Stack_Diagram 上面的总图实在太复杂，简单总结一下： 平时调用write的时候，数据是从应用写入到了C标准库的IO Buffer（用户态），这个Buffer在应用内存中，应用挂了，数据就没了； 在关闭流之前调用flush，通过flush将数据主动写入到内核的Page Cache中，应用挂了，数据也安全（内核态），但是系统挂了数据就没了； 将内核中的Page Cache中的数据写入到磁盘（缓存）中，系统挂了，数据也不丢失，需要调用fsync（持久化介质）。 总体来说，这就是操作系统的多级缓存和数据的可用性。操作系统也是程序，靠着多线程、异步、多级缓存实现高性能。 我们日常的业务开发，也可以借鉴这种思想。 需要C/C++ Linux服务器架构师学习资料加qun812855908获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享 二、深入理解磁盘 1、机械硬盘 （1）结构 机械硬盘（HDD）组成结构很多，重点关注磁盘、磁头臂、磁头，每个硬盘的正反两面都有对应的磁头。 数据存储在盘片的环状磁道中，最小读写单位是扇区（sector），一般大小为512字节，这样的话读写单位太小，性能不高。 文件系统把连续的扇区组成逻辑块（block），以逻辑块为最小单元来管理数据。 一般逻辑块大小为4KB，是由连续的8个扇区组成。 （2）如何读取数据 磁臂摆动+盘片转动（耗时大所以导致慢，随机在硬盘上找一个数据，需要8-14ms），定位到目标扇区读取数据； 磁臂在一定范围内摆动，来找到目标扇区，靠磁头把某个扇区的数据传输到总线上； 磁臂摆动范围有限，触达不到比较远的扇区，靠转轴来转动盘片，比如磁盘转速有7200转/分，1秒就是120圈； 常规1秒可以做100次随机IO，所以高并发业务单靠磁盘是扛不住的，基本都要结合缓存； 机械硬盘想要优化，就不能用随机IO，要用顺序IO，节省大量的物理耗时，比如Kafka、RockerMQ都是使用顺序IO。 2、磁盘读写常见指标 （1）IOPS（Input/Output Operations per Second） 指每秒能处理的I/O个数，表示块存储处理读写（输出/输入）的能力，单位为次，有顺序IOPS和随机IOPS。 阿里云盘性能参考： 高效云盘：2120 IOPS； ESSD云盘：2280 IOPS； SSD云盘：3000IOPS。 （2）吞吐量/带宽（Throughput） 是指单位时间内可以成功传输的数据数量，单位为MB/s。 比如一个硬盘的读写IO是1MB，硬盘的IOPS是100，那么硬盘总的吞吐率就是100MB/S，带宽=IOPS*IO大小。 如果需要部署大量顺序读写的应用，例如Hadoop离线计算型业务等典型场景，需要关注吞吐量。 （3）访问时延（Latency） 是指IO请求从发出到收到响应的间隔时间，常以毫秒（ms）或者微秒（us）为单位； 硬盘响应时间 = 硬盘访问时间 + IO排队延迟； 过高的时延会导致应用性能下降或报错； 如果应用对高时延比较敏感，例如数据库应用，建议使用ESSD AutoPL云盘、SSD云盘或本地SSD盘类产品； 普通的HDD磁盘，随机IO读写延迟是10毫秒，IO带宽大约100MB/秒，随机IOPS一般在100左右。 （4）容量（Capacity） 是指存储空间大小，单位为TiB、GiB、Mib、Kib，块存储容量按照二进制单位计算： 1B（byte字节）=8bit 1KB（Kilobyte千字节） = 1024B 1MB（Megabyte兆字节，简称兆） = 1024KB 1GB（Gigabyte吉字节，简称“千兆”） = 1024MB 1TB（Terabyte万亿字节，简称“太字节”） = 1024GB 1PB（Petabyte千万亿字节，简称“拍字节”） = 1024TB 1EB（Exabyte百亿亿字节，简称“艾字节”） = 1024PB # 查看容量[root@localhost test]# df -hFilesystem Size Used Avail Use% Mounted ondevtmpfs 1.9G 0 1.9G 0% /devtmpfs 1.9G 0 1.9G 0% /dev/shmtmpfs 1.9G 8.7M 1.9G 1% /runtmpfs 1.9G 0 1.9G 0% /sys/fs/cgroup/dev/sda1 40G 22G 19G 54% /tmpfs 379M 0 379M 0% /run/user/0 （5）使用率（Utilization） 指磁盘处理I/O的时间百分比，过高的使用率，常规字段Utilization-缩写%util表示； 如果超过80%意味着磁盘I/O存在性能瓶颈。 （6）IO等待队列长度（Queue Length） 表示等待处理的I/O请求的数目，如果I/O请求压力持续超出磁盘处理能力，就会增大队列长度。 （7）饱和度 指磁盘处理I/O的繁忙程度，过高的饱和度说明磁盘存在严重的性能瓶颈。 当饱和度为100%时，磁盘无法接受新的IO请求。 注意，使用率和饱和度是完全不同的，使用率只考虑有没有IO，不考虑IO的大小；当使用率是100%时，磁盘也可能接收新的IO请求。 3、磁盘IOPS性能测试 （1）安装fio yum install -y fio （2）使用 参数 说明 filename 待测试的文件或块设备 如果是文件，则是测试文件系统的性能；例：-filename=/work/fstest/fio.img 如果是块设备，则是测试裸设备的性能；例：-filename=/dev/vda1（容易损坏磁盘） ioengin IO引擎fio支持多种引擎，例如：cpuio、mmap、sync、psync、filecreate、libaio等 常用libaio是Linux异步读写IO（Linuxnative asynchronous I/O） iodepth 表示使用AIO时，同时发出I/O数的上限为128 direct 是否采用直接IO（direct IO）方式进行读写 如果采用直接IO，则取值-direct=1，否则取值-direct=0 一般是用直接IO写此时，测试结果更加真实 rw 读写模式 read：顺序读测试，使用方式-rw=read write：顺序写测试，使用方式-rw=write randread：随机读测试，使用方式-rw=randread randwrite：随机写测试，使用方式-rw=randwrite randrw：随机读写，-rw=randrw；默认比率为5:5 numjobs 测试进程的并发数，比如-numjobs=16 bs 单次IO的大小，比如-bs=4k size 测试文件的大小，比如-size=1G sync 设置同步模式，同步-sync=1，异步-sync=0 runtime 设置测试运行的时间，单位秒，比如-runtime=100 group_reporting 结果把多线程汇总输出 # 随机读fio -direct=1 -iodepth=128 -rw=randread -ioengine=libaio -bs=4k -size=1G -runtime=10 -filename=iotest1 -name=iotest1 # 随机写fio -direct=1 -iodepth=128 -rw=randwrite -ioengine=libaio -bs=4k -size=1G -runtime=10 -filename=iotest2 -name=iotest2 # 顺序读fio -direct=1 -iodepth=128 -rw=read -ioengine=libaio -bs=4k -size=1G -runtime=10 -filename=iotest3 -name=iotest3 # 顺序写fio -direct=1 -iodepth=128 -rw=write -ioengine=libaio -bs=4k -size=1G -runtime=10 -filename=iotest4 -name=iotest4 # 随机读fio -direct=1 -iodepth=128 -rw=randrw -ioengine=libaio -bs=4k -size=1G -runtime=10 -filename=iotest5 -name=iotest5 4、固态硬盘SSD （1）结构 固态硬盘由固态电子元器组成，没有盘片、磁臂等机械部件，不需要磁道寻址，靠电容存储数据。 某块区域存在数据，机械硬盘写入可以直接覆盖，而固态硬盘需要先擦除，再写入，block块擦的越多寿命越短，业务数据高频更新，则不太建议使用固态硬盘。 最小读写单位是页，通常大小是4KB、8KB。 性能高，IOPS可以达到几万以上，价格比机械硬盘贵，寿命较短。 固态硬盘由多个裸片叠加组成，一个裸片有多个块，一个块有很多的页，一个页的大小通常是4KB。 （2）磁盘数据的擦写 SSD里面最小读写单位是page，但是最小擦除单位是block。 一个块上的某些页的数据被标记删除，不能直接擦除这些的页，除非整个块上的页都被标记删除； 块还有其他有效数据，当有新数据只能写入白色区域，并不能利用红色区域，时间越长，不能被使用的碎片越多。 GC（Garbagecollection）垃圾回收： 有一套标记整理机制程序，“有效”页数据复制到一个“空白”块里，然后把这个块完全擦除； 那些被移动出数据的块上面的页要么没数据，要么是标记删除的数据，直接对这个块进行擦除； 擦除数据类似JVM的GC，使用标记整理算法Mark Compact。（先对对象进行一个标记，看看哪些对象是垃圾；整理会在清除的过程中，把可用的对象向前移动，让内存更为紧凑，避免内存碎片的产生；整理之后发现内存更紧凑，连续的空间更多，就不会造成内存碎片的问题） 5、磁盘分区 （1）概念 计算机中存放信息的主要存储设备就是硬盘，但是硬盘不能直接使用，必须对硬盘进行分割成一块块的硬盘区域就是磁盘分区。 磁盘分区（比如windows的C、D、E盘），方便管理、提升系统的效率和做好存储空间隔离分配： 将系统中的程序数据按不同的使用分为几类，将不同类型的数据分别存放在不同的磁盘分区中； 在每个分区上存放的都是相似的数据或程序，这样管理和维护就容易多； 分区可以提升系统的效率，系统读写磁盘时，磁头移动的距离缩短了，即搜寻的范围小了； 如果不运用分区，每次在硬盘上寻找信息时可能要寻找整个硬盘，所以速度会很慢。 磁盘分区，允许在一个磁盘上有多个文件系统，每个分区可以分配不同的文件系统； 从而使操作系统可以识别每个分区的文件系统，从而实现文件的存储和管理； 创建硬盘分区后，还不能立即使用，还需要创建文件系统，即格式化； 格式化后常见的磁盘格式有：FAT（FAT16）、FAT32、NTFS、ext2、ext3等。 （2）硬盘分区类型 不同类型磁盘支持分区的数量有限制。 主分区：主直接在硬盘上划分的，一个硬盘可以有1到3个主分区和1个扩展分区。 扩展分区：是一个概念，实际在硬盘中是看不到的，也无法直接使用扩展分区，在扩展分区中建立逻辑分区。 （3）容量 硬盘的容量 = 主分区的容量 + 扩展分区的容量 扩展分区的容量 = 各个逻辑分区的容量之和 （4）Linux系统下磁盘分区设备名称 设备 介绍 设备在Linux中的文件名 IDE硬盘Hard Disk Integrated Drive Electronics电子集成驱动器 /dev/hd是IDE接口硬盘分区，一般用于普通桌面和服务器 /dev/hd[字母递增][数字递增] SCSI光盘Solid Disk Small Computer System Interface 小型计算机系统接口 /dev/sd是SCSI接口硬盘分区，一般用于服务器 /dev/sd[字母递增][数字递增] virtio虚拟磁盘Virtual Disk /dev/vd虚拟磁盘分区，一般用于在虚拟机上扩展存储空间 /dev/vd[字母递增][数字递增] 注：字母表示硬盘，数字代表硬盘的分区 比如：/dev/hda1表示第一块硬盘的第一个分区 （5）管理磁盘分区 # 分区管理[root@localhost test]# fdisk -l # 只有一块磁盘/dev/sdaDisk /dev/sda: 42.9 GB, 42949672960 bytes, 83886080 sectorsUnits = sectors of 1 * 512 = 512 bytesSector size (logical/physical): 512 bytes / 512 bytesI/O size (minimum/optimal): 512 bytes / 512 bytesDisk label type: dosDisk identifier: 0x0009ef1a# 只有一个分区/dev/sda1 Device Boot Start End Blocks Id System/dev/sda1 * 2048 83886079 41942016 83 Linux # 查看容量、占用空间、剩余空间[root@localhost test]# df -h -TFilesystem Type Size Used Avail Use% Mounted ondevtmpfs devtmpfs 1.9G 0 1.9G 0% /devtmpfs tmpfs 1.9G 0 1.9G 0% /dev/shmtmpfs tmpfs 1.9G 8.7M 1.9G 1% /runtmpfs tmpfs 1.9G 0 1.9G 0% /sys/fs/cgroup/dev/sda1 xfs 40G 23G 18G 57% /tmpfs tmpfs 379M 0 379M 0% /run/user/0 6、磁盘高可用：磁盘冗余阵列 （1）简介 磁盘阵列高可用方案 - 独立磁盘冗余阵列（RAID - Redundant Array of Independent Disks）。 是一种提供高可用性和数据容错性的数据存储技术，把几块硬盘组成一个阵列，并将它们的数据分布在不同的磁盘上。 在磁盘发生故障时保护数据，还可以提高I/O性能，使系统能够更快地完成任务。 简单来说，就是把相同的数据存储在多个硬盘的不同的地方，储存冗余数据增加了容错性。 根据性能、容量、可靠性，有多个级别，比如RAID0、RAID1、RAID5、RAID10。 （2）RAID0磁盘阵列 至少需要两块硬盘，磁盘越多，读写速度越快，读写速度约等于一个磁盘的吞吐量 * 磁盘数，没有冗余。 这种方案磁盘利用率100%，安全性最低，一块硬盘出现故障就会导致数据损坏。 读写性能好。 （类似redis、mongodb的数据分片存储） （3）RAID1镜像阵列 全部数据都分别复制到多块硬盘上，当其中一块硬盘出现故障时，另一块硬盘的数据可以被立即使用，从而保证数据的安全性。 每次写入数据时都会同时写入镜像盘，读写性能较低，只能用两块硬盘，一块硬盘冗余，磁盘利用率为50%。 优点是数据冗余性高，缺点是读写性能比一般硬盘差。 适合服务器、数据库存储等领域。 （4）RAID5条带阵列 至少需要3块磁盘，一块磁盘冗余，是将多块磁盘按特定顺序组合起来，是最通用流行的配置方式。 在每块磁盘上都会存储1份数据和1份校验信息，1块硬盘出现故障时，根据另外2块磁盘的校验信息可以恢复数据。 这种存储方式只允许有一块硬盘出现故障，出现故障时需要尽快更换。 综合了RAID0和RAID1的优点和缺点，是RAID0和RAID1的折中方案。 适合需要安全和成本兼顾的领域，性能要求稍高，比如金融数据库存储。 （5）RAID10、RAID50 安全性和读写性能高，但是价格昂贵。 7、磁盘IO性能分析 （1）iostat sysstat提供了Linux性能监控的工具集，包括iostat、mpstat、pidstat、sar等。 iostat查看系统综合的磁盘IO情况 # -c 仅显示CPU状态统计信息# -d 仅显示磁盘统计信息# -k 或 -m 以Kb或Mb为单位显示，常用-h可读性高# -p 指定显示IO的设备，ALL表示显示所有# -x 显示详细信息 字段 说明 【重要】r/s 每秒发送给磁盘的读请求次数，r/s+w/s 是磁盘 IOPS 【重要】w/s 每秒发送给磁盘的写请求次数，r/s+w/s 是磁盘IOPS 【重要】rkB/s 每秒从磁盘读取的数据量，rkB/s+wkB/s 是吞吐量 【重要】wkB/s 每秒向磁盘写入的数据量，rkB/s+wkB/s 是吞吐量 【重要】r_await 读请求处理完成等待时间，包括在队列中的等待时间和设备实际处理时间 rawait+w_await，是RT响应时间 【重要】w_await 写请求处理完成等待时间，包括在队列中的等待时间和设备实际处理时间 r_await+w_await，是RT响应时间 【重要】aqu-sz 平均请求队列长度 rareq-Sz 平均读请求大小 wareg-Sz 平均写请求大小 【重要】%util 磁盘处理I/O的时间百分比，表示的是磁盘的忙碌情况;如果>80%就是磁盘可能处于忙碌状态 -秒中有百分之多少的时间用于I/O操作，或者说一秒中有多少时间I/O队列是非空的 （2）iotop 参数： -o：只显示正在读写磁盘的程序 -d：跟一个数值，表示iotop命令刷新时间 三、深入理解操作系统IO底层 1、DMA（Direct Memory Access） （1）应用程序从磁盘读写数据的时序图（未用DMA技术） 我们发现，应用程序如果想从磁盘读取数据，CPU会发生两次上下文的切换，并且数据会进行两次拷贝。 （2）使用DMA（Direct Memory Access）直接内存访问 直接内存访问，直接内存访问是计算机科学中的一种内存访问技术。 DMA之前，要把外设的数据读入内存或把内存的数据传送到外设，一般都要通过CPU控制完成，利用中断技术。 DMA允许某些硬件系统能够独立于CPU直接读写操作系统的内存，不需要CPU介入处理。 数据传输操作在一个DMA控制器（DMAC）的控制下进行，在传输过程中CPU可以继续进行其它的工作。 在大部分时间CPU和I/O操作都处于并行状态，系统的效率更高。 此时，如果是读数据： 1、操作系统检查内核缓冲区读取，如果存在则直接把内核空间的数据copy到用户空间（CPU处理），应用程序即可使用。 2、如果内核缓冲区没数据，则从磁盘中读取文件数据到内核缓冲区（DMA处理），再把内核空间的数据copy到用户空间（CPU处理），应用程序即可使用。 3、硬盘 ->内核缓冲区 ->用户缓冲区。 写操作： 根据操作系统的写入方式不一样，buffer IO和direct IO，写入磁盘时机不一样。 buffer IO：应用程序把数据从用户空间copy到内核空间的缓冲区（CPU处理），再把内核缓冲区的数据写到磁盘（DMA处理）。 direct IO：应用程序把数据直接从用户态地址空间写入到磁盘中，直接跳过内核空间缓冲区，减少操作系统缓冲区和用户地址空间的拷贝次数，降低了CPU和内存开销。 读网络数据： 网卡Socket（类似磁盘）中读取客户端发送的数据到内核空间（DMA处理），再把内核空间的数据copy到用户空间（CPU处理），然后应用程序使用。 写网络数据： 用户缓冲区中的数据copy到内核缓冲区的Socket Buffer中（CPU处理），再将内核空间中的Socket BUffer拷贝到Socket协议栈（网卡设备）进行传输（DMA处理）。 （3）DMA技术里面的损耗 （读）从磁盘的缓冲区到内核缓冲区的拷贝工作； （读）从网卡设备到内核的socket buffer的拷贝工作； （写）从内核缓冲区到磁盘缓冲区的拷贝工作； （写）从内核的socket buffer到网卡设备的拷贝工作。 所以，内核缓冲区到用户缓冲区之间的拷贝工作仍然由CPU负责。 以下是应用程序从磁盘读取文件到发送到网络的流程，程序先read数据，然后write网络，其中包含四次内核态和用户态的切换、四次缓冲区的拷贝： DMA技术虽然能提高一部分性能，但是仍然有一些不必要的资源损耗，其中包括CPU的用户态和内核态的切换、CPU内存拷贝的消耗。 2、零拷贝 （1）概念 零拷贝旨在减少不必要的内核缓冲区跟用户缓冲区之间的拷贝工作，从而减少CPU的开销和减少了kernel和user模式的上下文切换，提升性能。 从磁盘中读取文件通过网络发送出去，只需要拷贝2/3次和2/4的内核态和用户态的切换即可。 ZeroCopy技术实现有两种（内核态和用户态切换次数不一样）： 方式一：mmap + write； 方式二：sendfile。 （2）mmap实现 mmap+write是ZeroCopy的实现方式之一。 操作系统都使用虚拟内存，虚拟地址通过多级页表来映射物理地址，多个虚拟内存可以指向同一个物理地址，虚拟内存的总空间远大于物理内存空间。 如果把内核空间和用户空间的虚拟地址映射到同一个物理地址，就不需要来回复制数据了。 mmap系统调用函数会直接把内核缓冲区里的数据映射到用户空间，这样内核空间和用户空间就不需要进行数据拷贝操作，节省了CPU开销。 相关函数（C）：mmap()读取，write()写出。 还是以应用程序从磁盘读取文件到发送到网络的流程为例，步骤： 1、应用程序先调用mmap()方法，将数据从磁盘拷贝到内核缓冲区，返回结束（DMA负责）； 2、再调用write()，内核缓冲区的数据直接拷贝到内核socket buffer（CPU负责）； 3、然后把内核缓冲区的Socket Buffer直接拷贝给Socket协议栈，即网卡设备中，返回结束（DMA负责）。 没用零拷贝时，发生4次CPU上下文切换和4次数据拷贝。 使用mmap，CPU用户态和内核态上下文切换仍然是4次，和3次数据拷贝（2次DMA拷贝，1次CPU拷贝）。 减少了1次CPU拷贝（只有内核之间有一次拷贝。） （3）sendfile实现 sendfile是ZeroCopy的另一种实现方式。 Linux kernal 2.1新增了一个发送文件的系统调用函数sendfile()。 替代read()和write()两个系统调用，减少一次系统调用，即减少2次CPU上下文切换的开销。 调用sendfile()，从磁盘读取数据到内核缓冲区，然后直接把内核缓冲区的数据拷贝到socket buffer缓冲区里，再把内核缓冲区的Socket Buffer直接拷贝给Socket协议栈，即网卡设备中（DMA负责）。 相关函数（C）：sendfile() 还是以应用程序从磁盘读取文件到发送到网络的流程为例，步骤： 1、应用程序先调用sendfile()方法，将数据从磁盘拷贝到内核缓冲区（DMA负责）； 2、然后把内核缓冲区的数据直接拷贝到内核socket buffer（CPU负责）； 3、然后把内核缓冲区的Socket Buffer直接拷贝给Socket协议栈，即网卡设备中，返回结束（DMA负责）。 没用零拷贝时，发生4次CPU上下文切换和4次数据拷贝。 使用sendfile()，CPU用户态和内核态上下文切换是2次，3次数据拷贝（2次DMA拷贝，1次CPU拷贝）。 （4）改进的sendfile linux2.4+版本之后改进了sendfile，利用DMA Gather（带有收集功能的DMA），变成了真正的零拷贝（没有CPU Copy）。 还是以应用程序从磁盘读取文件到发送到网络的流程为例，步骤： 1、应用程序先调用sendfile()方法，将数据从磁盘拷贝到内核缓冲区（DMA负责）； 2、把内存地址、偏移量的缓冲区fd描述符 拷贝到Socket Buffer中去，（拷贝很少的数据，可忽略，本质和虚拟内存的解决方法思路一样，就是内存地址的记录）； 3、然后把内核缓冲区的Socket Buffer直接拷贝给Socket协议栈，即网卡设备中，返回结束（DMA负责）。 （5）splice Linux 从 2.6.17 支持 splice。 数据从磁盘读取到 OS 内核缓冲区后，在内核缓冲区直接可将其转成内核空间其他数据buffer，而不需要拷贝到用户空间。 如下图所示，从磁盘读取到内核 buffer 后，在内核空间直接与 socket buffer 建立 pipe管道。 和 sendfile()不同的是，splice()不需要硬件支持。 注意 splice 和 sendfile 的不同，sendfile 是 DMA 硬件设备不支持的情况下将磁盘数据加载到 kernel buffer 后，需要一次 CPU copy，拷贝到 socket buffer。 而 splice 是更进一步，连这个 CPU copy 也不需要了，直接将两个内核空间的 buffer 进行 pipe。 splice 会经历 2 次拷贝: 0 次 cpu copy 2 次 DMA copy； 以及 2 次上下文切换 3、总结 （1）零拷贝的目标 解放CPU，避免CPU做太多事情； 减少内存带宽占用； 减少用户态和内核态上下文切换过多； 在文件较小的时候mmap用时更短，文件较大时sendfile方式最优。 （2）零拷贝方式对比 sendfile： 无法在调用过程中修改数据，只适用于应用程序不需要对所访问数据进行处理修改情况； 比如静态文件传输、MQ的Broker发送消息给消费者； 想要在传输过程中修改数据，可以使用mmap系统调用； 文件大小：适合大文件传输； 切换和拷贝：2次上下文切换，最少2次数据拷贝。 mmap： mmap调用可以在应用程序中直接修改Page Cache中的数据，使用的是mmap+write两步； 调用比sendfile成本高，但优于传统I/O的零拷贝实现方式，虽然比sendfile多了上下文切换； 用户空间与内核空间并不需要数据拷贝，在正确使用情况下并不比sendfile效率差； 适用于多个线程以只读的方式同时访问同一个文件，mmap机制下多线程共享同一物理内存，节约内存； 文件大小：适合小数据量读写； 切换和拷贝：4次上下文切换,3次数据拷贝。
在刚开始接触STM32的时候，使用的keil作为IDE，由于在这之前，使用过VS， 使用过eclipse，因而在使用keil之后，实在难以忍受keil编辑器简陋的功能，可以说是极其糟糕的写代码体验。 之后，尝试过各种IDE，使用eclipse+keil，结果发现eclipse对C语言的支持也是鸡肋，使用emBits+gcc，需要和其他人协同的话就比较麻烦，之后发现了platformIO，也是使用gcc作为编译器，不过只支持HAL库，而且还有一个重要的原因，同事都是用的keil，如果我使用gcc，就不能协同工作了。 最后，通过使用VS Code + keil的方式，完美解决了写代码的体验问题，以及工程协作问题，其实网上使用VS Code作为编辑器，keil作为编译器的教程很多，不过基本都是需要在VS Code中编辑，然后在keil中编译，下载，调试，本文就要实现编辑，编译，下载，调试，全部使用VS Code。 Part1环境 （1）VS Code； （2）keil；python； （3）GNU Arm Embedded Toolchain（arm gcc工具链）； （4）C/C++(VS Code 插件)； （5）Cortex-Debug(VS Code 插件)； （6）其他VS Code插件(提升体验)。 Part2前提 正式写代码之前，首先需要建立好一个工程，这个需要使用keil完成，包括工程配置，文件添加… Part3编辑 在安装好VS Code插件之后，VS Code编写C代码本身体验就已经很好了， 但是，因为我们使用的是keil环境，所以需要配置头文件包含，宏定义等，在工程路径的.vscode文件夹下打开c_cpp_properties.json文件，没有自己新建一个，内容配置如下： { "configurations": [ { "name": "STM32", "includePath": [ "D:/Program Files/MDK5/ARM/ARMCC/**", "${workspaceFolder}/**", "" ], "browse": { "limitSymbolsToIncludedHeaders": true, "databaseFilename": "${workspaceRoot}/.vscode/.browse.c_cpp.db", "path": [ "D:/Program Files/MDK5/ARM/ARMCC/**", "${workspaceFolder}/**", "" ] }, "defines": [ "_DEBUG", "UNICODE", "_UNICODE", "__CC_ARM", "USE_STDPERIPH_DRIVER", "STM32F10X_MD" ], "intelliSenseMode": "msvc-x64" } ], "version": 4 } 其中，需要在includePath和path中添加头文件路径，${workspaceFolder}/**是工程路径，不用改动，额外需要添加的是keil的头文件路径， 然后在defines中添加宏，也就是在keil的Options for Target的C++选项卡中配置的宏，然后就可以体验VS Code强大的代码提示，函数跳转等功能了（甩keil的编辑器一整个时代）。 Part4编译、烧录 编译和烧录通过VS Code的Task功能实现，通过Task，使用命令行的方式调用keil进行编译和烧录。 keil本身就支持命令行调用，具体可以参考keil的手册，这里就不多说了，但是问题在于，使用命令行调用keil，不管是什么操作，他的输出都不会输出到控制台上！！！(要你这命令行支持有何用) 不过好在，keil支持输出到文件中，那我们就只能利用这个做点骚操作了。一边执行命令，一边读取文件内容并打印到控制台，从而就实现了输出在控制台上，我们就能直接在VS Code中看到编译过程了 为此，我编写了一个Python脚本，实现keil的命令行调用并同时读取文件输出到控制台。 #!/usr/bin/python # -*- coding:UTF-8 -*- import os import threading import sys runing = True def readfile(logfile): with open(logfile, 'w') as f: pass with open(logfile, 'r') as f: while runing: line = f.readline(1000) if line != '': line = line.replace('\\', '/') print(line, end = '') if __name__ == '__main__': modulePath = os.path.abspath(os.curdir) logfile = modulePath + '/build.log' cmd = '\"D:/Program Files/MDK5/UV4/UV4.exe\" ' for i in range(1, len(sys.argv)): cmd += sys.argv[i] + ' ' cmd += '-j0 -o ' + logfile thread = threading.Thread(target=readfile, args=(logfile,)) thread.start() code = os.system(cmd) runing = False thread.join() sys.exit(code) 此脚本需要结合VS Code的Task运行，通过配置Task，我们还需要匹配输出中的错误信息(编译错误)，实现在keil中，点击错误直接跳转到错误代码处，具体如何配置请参考VS Code的文档，这里给出我的Task。 { // See https://go.microsoft.com/fwlink/?LinkId=733558 // for the documentation about the tasks.json format "version": "2.0.0", "tasks": [ { "label": "build", "type": "shell", "command": "py", "args": [ "-3", "${workspaceFolder}/scripts/build.py", "-b", "${config:uvprojxPath}" ], "group": { "kind": "build", "isDefault": true }, "problemMatcher": [ { "owner": "c", "fileLocation": [ "relative", "${workspaceFolder}/Project" ], "pattern": { "regexp": "^(.*)\\((\\d+)\\):\\s+(warning|error):\\s+(.*):\\s+(.*)$", "file": 1, "line": 2, "severity": 3, "code": 4, "message": 5 } } ] }, { "label": "rebuild", "type": "shell", "command": "py", "args": [ "-3", "${workspaceFolder}/scripts/build.py", "-r", "${config:uvprojxPath}" ], "group": "build", "problemMatcher": [ { "owner": "c", "fileLocation": [ "relative", "${workspaceFolder}/Project" ], "pattern": { "regexp": "^(.*)\\((\\d+)\\):\\s+(warning|error):\\s+(.*):\\s+(.*)$", "file": 1, "line": 2, "severity": 3, "code": 4, "message": 5 } } ] }, { "label": "download", "type": "shell", "command": "py", "args": [ "-3", "E:\\Work\\Store\\MyWork\\STM32F1\\FreeModbus_M3\\scripts\\build.py", "-f", "${config:uvprojxPath}" ], "group": "test" }, { "label": "open in keil", "type": "process", "command": "${config:uvPath}", "args": [ "${config:uvprojxPath}" ], "group": "test" } ] } 对于使用ARM Compiler 6编译的工程，build和rebuild中的problemMatcher应该配置为： "problemMatcher": [ { "owner": "c", "fileLocation": ["relative", "${workspaceFolder}/MDK-ARM"], "pattern": { "regexp": "^(.*)\\((\\d+)\\):\\s+(warning|error):\\s+(.*)$", "file": 1, "line": 2, "severity": 3, "message": 4, } } ] 文件中的config:uvPath和config:uvprojxPath分别为keil的UV4.exe文件路径和工程路径(.uvprojx)，可以直接修改为具体路径，或者在VS Code的setting.json中增加对应的项，至此，我们已经完美实现了在VS Code中编辑，编译，下载了。 编译输出： 有错误时输出： 错误匹配： Part5调试 调试需要使用到Cortex-Debug插件，以及arm gcc工具链，这部分可以参考Cortex-Debug的文档，说的比较详细； 首先安装Cortex-Debug插件和arm gcc工具链，然后配置好环境路径，如果使用Jlink调试，需要下载Jlink套件，安转好之后，找到JLinkGDBServerCL.exe这个程序，在VS Code的设置中添加"cortex-debug.JLinkGDBServerPath": "C:/Program Files (x86)/SEGGER/JLink/JLinkGDBServerCL.exe"，后面的路径是你自己的路径。 这里补充一下arm gcc工具链的配置："cortex-debug.armToolchainPath": "D:\\Program Files (x86)\\GNU Arm Embedded Toolchain\\9 2020-q2-update\\bin",后面的路径是你自己的路径。如果使用STLink调试，需要下载stutil工具，在GitHub上搜索即可找到，同样配置好路径即可。 以上步骤弄好之后，可以直接点击VS Code的调试按钮，此时会新建luanch.json文件，这个文件就是VS Code的调试配置文件，可参考我的文件进行配置。 { // 使用 IntelliSense 了解相关属性。 // 悬停以查看现有属性的描述。 // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 "version": "0.2.0", "configurations": [ { "name": "Cortex Debug(JLINK)", "cwd": "${workspaceRoot}", "executable": "${workspaceRoot}/Project/Objects/Demo.axf", "request": "attach", "type": "cortex-debug", "servertype": "jlink", "device": "STM32F103C8", "svdFile": "D:\\Program Files\\ARM\\Packs\\Keil\\STM32F1xx_DFP\\2.3.0\\SVD\\STM32F103xx.svd", "interface": "swd", "ipAddress": null, "serialNumber": null }, { "name": "Cortex Debug(ST-LINK)", "cwd": "${workspaceRoot}", "executable": "${workspaceRoot}/Project/Objects/Demo.axf", "request": "attach", "type": "cortex-debug", "servertype": "stutil", "svdFile": "D:\\Program Files\\ARM\\Packs\\Keil\\STM32F1xx_DFP\\2.3.0\\SVD\\STM32F103xx.svd", "device": "STM32F103C8", "v1": false } ] } 注意其中几个需要修改的地方，executable修改为你的工程生成的目标文件，也就是工程的.axf文件，svdFile用于对MCU外设的监控，该文件可以在keil的安装路径中找到，可以参考我的路径去找，配置完成后，再次点击调试按钮即可进行调试。 相比keil自己的调试功能，VS Code还支持条件断点，可以设置命中条件，次数等，可以极大的方便调试。 总结 通过以上的配置，我们基本上，除了建立工程和往工程中添加文件，其他完全不需要打开keil，所以也无妨说一句，再见，智障keil！
你是否曾经遇到过在linux系统中出现的各种内存问题？比如内存泄漏、内存碎片等等。这些问题都可以通过深入理解linux内存模型得到解决。 一、前言 在linux内核中支持3中内存模型，分别是flat memory model，Discontiguous memory model和sparse memory model。所谓memory model，其实就是从cpu的角度看，其物理内存的分布情况，在linux kernel中，使用什么的方式来管理这些物理内存。另外，需要说明的是：本文主要focus在share memory的系统，也就是说所有的CPUs共享一片物理地址空间的。 本文的内容安排如下：为了能够清楚的解析内存模型，我们对一些基本的术语进行了描述，这在第二章。第三章则对三种内存模型的工作原理进行阐述，最后一章是代码解析，代码来自4.4.6内核，对于体系结构相关的代码，我们采用ARM64进行分析。 二、和内存模型相关的术语 1、什么是page frame？ 操作系统最重要的作用之一就是管理计算机系统中的各种资源，做为最重要的资源：内存，我们必须管理起来。在linux操作系统中，物理内存是按照page size来管理的，具体page size是多少是和硬件以及linux系统配置相关的，4k是最经典的设定。因此，对于物理内存，我们将其分成一个个按page size排列的page，每一个物理内存中的page size的内存区域我们称之page frame。我们针对每一个物理的page frame建立一个struct page的数据结构来跟踪每一个物理页面的使用情况：是用于内核的正文段？还是用于进程的页表？是用于各种file cache还是处于free状态…… 每一个page frame有一个一一对应的page数据结构，系统中定义了page_to_pfn和pfn_to_page的宏用来在page frame number和page数据结构之间进行转换，具体如何转换是和memory modle相关，我们会在第三章详细描述linux kernel中的3种内存模型。 2、什么是PFN？ 对于一个计算机系统，其整个物理地址空间应该是从0开始，到实际系统能支持的最大物理空间为止的一段地址空间。在ARM系统中，假设物理地址是32个bit，那么其物理地址空间就是4G，在ARM64系统中，如果支持的物理地址bit数目是48个，那么其物理地址空间就是256T。当然，实际上这么大的物理地址空间并不是都用于内存，有些也属于I/O空间（当然，有些cpu arch有自己独立的io address space）。因此，内存所占据的物理地址空间应该是一个有限的区间，不可能覆盖整个物理地址空间。不过，现在由于内存越来越大，对于32位系统，4G的物理地址空间已经无法满足内存的需求，因此会有high memory这个概念，后续会详细描述。 PFN是page frame number的缩写，所谓page frame，就是针对物理内存而言的，把物理内存分成一个个的page size的区域，并且给每一个page 编号，这个号码就是PFN。假设物理内存从0地址开始，那么PFN等于0的那个页帧就是0地址（物理地址）开始的那个page。假设物理内存从x地址开始，那么第一个页帧号码就是（x>>PAGE_SHIFT）。 3、什么是NUMA？ 在为multiprocessors系统设计内存架构的时候有两种选择：一种就是UMA（Uniform memory access），系统中的所有的processor共享一个统一的，一致的物理内存空间，无论从哪一个processor发起访问，对内存地址的访问时间都是一样的。NUMA（Non-uniform memory access）和UMA不同，对某个内存地址的访问是和该memory与processor之间的相对位置有关的。例如，对以某个节点（node）上的processor而言，访问local memory要比访问那些remote memory花的时间长。 三、Linux 内核中的三种memory model 1、什么是FLAT memory model？ 如果从系统中任意一个processor的角度来看，当它访问物理内存的时候，物理地址空间是一个连续的，没有空洞的地址空间，那么这种计算机系统的内存模型就是Flat memory。这种内存模型下，物理内存的管理比较简单，每一个物理页帧都会有一个page数据结构来抽象，因此系统中存在一个struct page的数组（mem_map），每一个数组条目指向一个实际的物理页帧（page frame）。在flat memory的情况下，PFN（page frame number）和mem_map数组index的关系是线性的（有一个固定偏移，如果内存对应的物理地址等于0，那么PFN就是数组index）。因此从PFN到对应的page数据结构是非常容易的，反之亦然，具体可以参考page_to_pfn和pfn_to_page的定义。此外，对于flat memory model，节点（struct pglist_data）只有一个（为了和Discontiguous Memory Model采用同样的机制）。下面的图片描述了flat memory的情况： 需要强调的是struct page所占用的内存位于直接映射（directly mapped）区间，因此操作系统不需要再为其建立page table。 2、什么是Discontiguous Memory Model？ 如果cpu在访问物理内存的时候，其地址空间有一些空洞，是不连续的，那么这种计算机系统的内存模型就是Discontiguous memory。一般而言，NUMA架构的计算机系统的memory model都是选择Discontiguous Memory，不过，这两个概念其实是不同的。NUMA强调的是memory和processor的位置关系，和内存模型其实是没有关系的，只不过，由于同一node上的memory和processor有更紧密的耦合关系（访问更快），因此需要多个node来管理。Discontiguous memory本质上是flat memory内存模型的扩展，整个物理内存的address space大部分是成片的大块内存，中间会有一些空洞，每一个成片的memory address space属于一个node（如果局限在一个node内部，其内存模型是flat memory）。下面的图片描述了Discontiguous memory的情况： 因此，这种内存模型下，节点数据（struct pglist_data）有多个，宏定义NODE_DATA可以得到指定节点的struct pglist_data。而，每个节点管理的物理内存保存在struct pglist_data 数据结构的node_mem_map成员中（概念类似flat memory中的mem_map）。这时候，从PFN转换到具体的struct page会稍微复杂一点，我们首先要从PFN得到node ID，然后根据这个ID找到对于的pglist_data 数据结构，也就找到了对应的page数组，之后的方法就类似flat memory了。 3、什么是Sparse Memory Model？ Memory model也是一个演进过程，刚开始的时候，使用flat memory去抽象一个连续的内存地址空间（mem_maps[]），出现NUMA之后，整个不连续的内存空间被分成若干个node，每个node上是连续的内存地址空间，也就是说，原来的单一的一个mem_maps[]变成了若干个mem_maps[]了。一切看起来已经完美了，但是memory hotplug的出现让原来完美的设计变得不完美了，因为即便是一个node中的mem_maps[]也有可能是不连续了。其实，在出现了sparse memory之后，Discontiguous memory内存模型已经不是那么重要了，按理说sparse memory最终可以替代Discontiguous memory的，这个替代过程正在进行中，4.4的内核仍然是有3中内存模型可以选择。 为什么说sparse memory最终可以替代Discontiguous memory呢？实际上在sparse memory内存模型下，连续的地址空间按照SECTION（例如1G）被分成了一段一段的，其中每一section都是hotplug的，因此sparse memory下，内存地址空间可以被切分的更细，支持更离散的Discontiguous memory。此外，在sparse memory没有出现之前，NUMA和Discontiguous memory总是剪不断，理还乱的关系：NUMA并没有规定其内存的连续性，而Discontiguous memory系统也并非一定是NUMA系统，但是这两种配置都是multi node的。有了sparse memory之后，我们终于可以把内存的连续性和NUMA的概念剥离开来：一个NUMA系统可以是flat memory，也可以是sparse memory，而一个sparse memory系统可以是NUMA，也可以是UMA的。 下面的图片说明了sparse memory是如何管理page frame的（配置了SPARSEMEM_EXTREME）： （注意：上图中的一个mem_section指针应该指向一个page，而一个page中有若干个struct mem_section数据单元） 整个连续的物理地址空间是按照一个section一个section来切断的，每一个section内部，其memory是连续的（即符合flat memory的特点），因此，mem_map的page数组依附于section结构（struct mem_section）而不是node结构了（struct pglist_data）。当然，无论哪一种memory model，都需要处理PFN和page之间的对应关系，只不过sparse memory多了一个section的概念，让转换变成了PFNSectionpage。 我们首先看看如何从PFN到page结构的转换：kernel中静态定义了一个mem_section的指针数组，一个section中往往包括多个page，因此需要通过右移将PFN转换成section number，用section number做为index在mem_section指针数组可以找到该PFN对应的section数据结构。找到section之后，沿着其section_mem_map就可以找到对应的page数据结构。顺便一提的是，在开始的时候，sparse memory使用了一维的memory_section数组（不是指针数组），这样的实现对于特别稀疏（CONFIG_SPARSEMEM_EXTREME）的系统非常浪费内存。此外，保存指针对hotplug的支持是比较方便的，指针等于NULL就意味着该section不存在。上面的图片描述的是一维mem_section指针数组的情况（配置了SPARSEMEM_EXTREME），对于非SPARSEMEM_EXTREME配置，概念是类似的，具体操作大家可以自行阅读代码。 从page到PFN稍微有一点麻烦，实际上PFN分成两个部分：一部分是section index，另外一个部分是page在该section的偏移。我们需要首先从page得到section index，也就得到对应的memory_section，知道了memory_section也就知道该page在section_mem_map，也就知道了page在该section的偏移，最后可以合成PFN。对于page到section index的转换，sparse memory有2种方案，我们先看看经典的方案，也就是保存在page->flags中（配置了SECTION_IN_PAGE_FLAGS）。这种方法的最大的问题是page->flags中的bit数目不一定够用，因为这个flag中承载了太多的信息，各种page flag，node id，zone id现在又增加一个section id，在不同的architecture中无法实现一致性的算法，有没有一种通用的算法呢？这就是CONFIG_SPARSEMEM_VMEMMAP。具体的算法可以参考下图： （上面的图片有一点问题，vmemmap只有在PHYS_OFFSET等于0的情况下才指向第一个struct page数组，一般而言，应该有一个offset的，不过，懒得改了，哈哈） 对于经典的sparse memory模型，一个section的struct page数组所占用的内存来自directly mapped区域，页表在初始化的时候就建立好了，分配了page frame也就是分配了虚拟地址。但是，对于SPARSEMEM_VMEMMAP而言，虚拟地址一开始就分配好了，是vmemmap开始的一段连续的虚拟地址空间，每一个page都有一个对应的struct page，当然，只有虚拟地址，没有物理地址。因此，当一个section被发现后，可以立刻找到对应的struct page的虚拟地址，当然，还需要分配一个物理的page frame，然后建立页表什么的，因此，对于这种sparse memory，开销会稍微大一些（多了个建立映射的过程）。 四、代码分析 我们的代码分析主要是通过include/asm-generic/memory_model.h展开的。 1、flat memory。代码如下： #define __pfn_to_page(pfn) (mem_map + ((pfn) - ARCH_PFN_OFFSET)) #define __page_to_pfn(page) ((unsigned long)((page) - mem_map) + ARCH_PFN_OFFSET) 由代码可知，PFN和struct page数组（mem_map）index是线性关系，有一个固定的偏移就是ARCH_PFN_OFFSET，这个偏移是和估计的architecture有关。对于ARM64，定义在arch/arm/include/asm/memory.h文件中，当然，这个定义是和内存所占据的物理地址空间有关（即和PHYS_OFFSET的定义有关）。 2、Discontiguous Memory Model。代码如下： #define __pfn_to_page(pfn) ({ unsigned long __pfn = (pfn); unsigned long __nid = arch_pfn_to_nid(__pfn); NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid); }) #define __page_to_pfn(pg) ({ const struct page *__pg = (pg); struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg)); (unsigned long)(__pg - __pgdat->node_mem_map) + __pgdat->node_start_pfn; }) Discontiguous Memory Model需要获取node id，只要找到node id，一切都好办了，比对flat memory model进行就OK了。因此对于__pfn_to_page的定义，可以首先通过arch_pfn_to_nid将PFN转换成node id，通过NODE_DATA宏定义可以找到该node对应的pglist_data数据结构，该数据结构的node_start_pfn记录了该node的第一个page frame number，因此，也就可以得到其对应struct page在node_mem_map的偏移。__page_to_pfn类似，大家可以自己分析。 3、Sparse Memory Model。经典算法的代码我们就不看了，一起看看配置了SPARSEMEM_VMEMMAP的代码，如下： #define __pfn_to_page(pfn) (vmemmap + (pfn)) #define __page_to_pfn(page) (unsigned long)((page) - vmemmap) 简单而清晰，PFN就是vmemmap这个struct page数组的index啊。对于ARM64而言，vmemmap定义如下： #define vmemmap ((struct page *)VMEMMAP_START - SECTION_ALIGN_DOWN(memstart_addr >> PAGE_SHIFT)) 毫无疑问，我们需要在虚拟地址空间中分配一段地址来安放struct page数组（该数组包含了所有物理内存跨度空间page），也就是VMEMMAP_START的定义。 总之，Linux内存模型是一个非常重要的概念，可以帮助你更好地理解Linux系统中的内存管理。
一定有很多人都听说过嵌入式和单片机，但在刚开始接触时，不知道大家有没有听说过嵌入式就是单片机这样的说法，其实嵌入式和单片机还是有区别的。单片机与嵌入式到底有什么关系？ 下面我们就来说说嵌入式和单片机之间的联系和区别吧。 01 什么是单片机？ 首先，我们来了解一下到底什么是单片机。 嵌入式系统的核心是嵌入式处理器。嵌入式处理器一般可以分为以下几种类型： 嵌入式微控制器MCU（Micro Control Unit） 嵌入式DSP处理器（Digital Signal Processor） 嵌入式微处理器MPU（Micro Processor Unit） 嵌入式片上系统SoC（System on Chip） 可编程片上系统SoPC（System on a Programmable Chip） 我们的单片机属于嵌入式微控制器MCU（Micro Control Unit） MCU内部集成ROM/RAM、总线逻辑、定时/计数器、看门狗、I/O、串口、A/D、D/A、FLASH等。典型代表如8051、8096、C8051F等。 单片机就是在一个芯片（Chip）上集成了CPU、SRAM、Flash及其他需要模块，在一个Chip上实现一个微型计算机系统，所以就叫Single Chip Microcomputer，也就是单片机了。 它其实就是一种集成电路芯片，是通过超大规模集成电路技术，将CPU、RAM、ROM、输入输出和中断系统、定时器/计数器等功能，塞进一块硅片上，变成一个超小型的计算机。 这么说来，单片机不就是一个嵌入式系统？ 别急，我们往下看。 “单片机”其实是一种古老的叫法。在那个年代半导体工艺还在起步阶段，集成能力很差，往往是CPU一个芯片，SRAM一个芯片，Flash一个芯片，需要中断的话又得有个专门处理中断的芯片，所以一个完整可用的计算机系统是很多个芯片（Chip）做在一个PCB板上构成的。 不同的功能无法做进一个芯片（Chip），所以会有多片机。现在半导体技术早已非常发达，所以不存在多片机。但是，“单片机”的叫法却一直延用至今。 单片机技术从上世纪70年代末诞生，早期的时候是4位，后来发展为8位，16位，32位。它真正崛起，是在8位时代。8位单片机功能很强，被广泛应用于工业控制、仪器仪表、家电汽车等领域。 我们在研究单片机的时候，经常会听到一个词——51单片机。让我们来了解一下它究竟是什么。 51单片机，其实就是一系列单片机的统称。该系列单片机，兼容Intel 8031指令系统。它们的始祖，是Intel（英特尔）的8004单片机。 注意，51单片机并不全是英特尔公司产品。包括ATMEL（艾德梅尔）、Philips（飞利浦）、华邦Dallas（达拉斯）、Siemens（西门子）、STC（国产宏晶等公司，也有很多产品属于51单片机系列。 ATMEL公司的51单片机，AT89C51这是一个51单片机的开发板，中间那个芯片才是51单片机 51单片机曾经在很长时间里都是市面上最主流、应用最广泛的单片机，占据大量的市场份额。 51单片机其实放在现在毫无技术优势，是一种很老的技术。之所以它的生命力顽强，除了它曾经很流行之外，还有一个原因，就是英特尔公司彻底开放了51内核的版权。 所以，无论任何单位或个人，都可以毫无顾忌地使用51单片机，不用付费，也不用担心版权风险，所以很多学校也都在用这个。 此外，51单片机拥有雄厚的存量基础和群众基础。很多老项目都是用的51单片机，出于成本的考虑，有时候只能继续沿用51单片机的技术进行升级。 而且，很多老一辈的工程师，都精通51单片机开发技术。 所以，51单片机的生命力得以不断延续。 02 什么是嵌入式？ 嵌入式系统是一种专用的计算机系统，作为装置或设备的一部分。通常，嵌入式系统是一个控制程序存储在ROM中的嵌入式处理器控制板。 事实上，所有带有数字接口的设备，如手表、微波炉、录像机、汽车等，都使用嵌入式系统，有些嵌入式系统还包含操作系统，但大多数嵌入式系统都是由单个程序实现整个控制逻辑。 从应用对象上加以定义，嵌入式系统是软件和硬件的综合体，还可以涵盖机械等附属装置。国内普遍认同的嵌入式系统定义为： 以应用为中心，以计算机技术为基础，软硬件可裁剪，适应应用系统对功能、可靠性、成本、体积、功耗等严格要求的专用计算机系统。 嵌入式系统具体应用于哪些“专用”方向呢？ 举例如下： 办公自动化：打印机，复印机、传真机 军事及航天类产品：无人机、雷达、作战机器人 家电类产品：数字电视、扫地机器人、智能家电 医疗电子类产品：生化分析仪血液分析仪、CT 汽车电子类产品：引擎控制、安全系统、汽车导航与娱乐系统 网络通信类产品：通信类交换设备、网络设备 (交换机、路由器、网络安全) 通信与娱乐：手机、数码相机、音乐播放器、可穿戴电子产品、PSP游戏机 工业控制类产品：工控机交互式终端 (POS、ATM)、安全监控、数据采集与传输、仪器仪表 上述这些领域，都使用了嵌入式系统。这还只是冰山一角。 可以说，嵌入式系统完完全全地融入了我们，时刻影响着我们的工作和生活。 嵌入式系统，既然是一个计算机系统，那么肯定离不开硬件和软件。 一个嵌入式系统的典型架构如下： 这里最重要的就是嵌入式操作系统和嵌入式微处理器。 从硬件角度来看，嵌入式系统就是以处理器（CPU）为核心，依靠总线（Bus）进行连接的多模块系统： 其实大家不难看出和个人PC是一样的方式。 单片机是有清晰定义的，就是单个片（chip）上的计算机系统。而不同的单片机虽然配置不同，性能不同，厂家不同，甚至指令集和开发方式不同，但是都是在一个片上的完整的计算机系统，这个定义不会错。 而嵌入式就是个不清晰的定义了，并没有非常明确的关于“嵌入式”这个词的定义。他也不像单片机一样，是个确定的“物”的名字。 03 单片机是不是嵌入式？ 那么单片机到底是不是嵌入式呢？ 简单来说：是。 因为很多嵌入式产品中被嵌入的计算机系统就是单片机，譬如空调中嵌入的控制板其实核心就是个单片机。实际上大部分家电产品中嵌入的计算机系统都是单片机。 因为单片机足够简单便宜而且够用，所以使用单片机是最划算最适合的。 而单片机现在出货量最大的领域也就是家电产品了，当然未来IOT类的应用会越来越多，会成为单片机的很大的增量市场。 04 广义和狭义的嵌入式 嵌入式这个概念实际上很泛化，现在讲嵌入式这个词的人，可能想表达的意思并不相同。咱们上面讲的嵌入式的概念是嵌入式本来的定义，也就是所谓广义上的嵌入式。 而狭义的嵌入式，其实是“嵌入式linux系统”的简称。 这种狭义的嵌入式最初指的是运行了linux系统的嵌入式计算机系统。后来也包括运行了和linux同级别的其他嵌入式系统（譬如WinCE、Vxworks、Android等）的计算机。 看过上面的介绍之后你就知道到底单片机是不是嵌入式了，其实这两者之间的联系有很深，总之，不管你是准备学习嵌入式或是单片机，都要自己想好了再做决定。 05 嵌入式和单片机的区别 说到这里，我们来看看，嵌入式和单片机的区别到底是什么。 从前文的介绍来看，嵌入式系统是一个大类，单片机是其中一个重要的子类。嵌式系统像是一个完整的计算机，而单片机更像是一个没有外设的计算机。 以前单片机包括的东西并不算多，两者的硬件区别较为明显。 但是，随着半导体技术的突飞猛进，现在各种硬件功能都能被做进单片机之中。所以，嵌入式系统和单片机之间的硬件区别越来越小，分界线也越来越模糊。 于是，人们倾向于在软件上进行区分。 从软件上，行业里经常把芯片中不带MMU（memory management unit，内存管理单元）从而不支持虚拟地址，只能裸奔或运行RTOS（实时操作系统，例如ucos、华为LiteOS、RT-Thread、freertos等）的system，叫做单片机（如STM32、NXP LPC系列、NXP imxRT1052系列等）。 同时，把芯片自带MMU可以支持虚拟地址，能够跑Linux、Vxworks、WinCE、Android这样的“高级”操作系统的system，叫做嵌入式。 在某些时候，单片机本身已经足够强大，可以作为嵌入式系统使用。它的成本更低，开发和维护的难度相对较小，尤其是针对一些针对性更强的应用。而嵌入式系统理论上性能更强，应用更广泛，但复杂度高，开发难度大。 06 我们为什么要学习嵌入式和单片机 今天我也只是给大家简单地介绍了一下单片机和嵌入式以及他们之间的关系和区别，虽然嵌入式系统已经有30多年的历史，但其实一直隐藏在背后的，自从物联网上升为国家战略后，嵌入式系统也渐渐从后台走到前台。 嵌入式和单片机并不是纯“硬件”类方向。如果你想学好嵌入式和单片机，只懂数字电路和微机接口这样的硬件知识是不够的，你更需要学习的，是汇编、C/C++语言、数据结构和算法知识。拥有软硬结合的能力，远远比单纯掌握某种程序开发语言更有价值。 其次，嵌入式和单片机拥有广泛的应用场景，在各个领域都有项目需求和人才需求。而且我们国家现在正在大力发展芯片产业，也会带动嵌入式人才的就业，提升待遇。 随着5G建设的深入，整个社会正在向“万物互联”的方向变革。 物联网技术也将迎来前所未有的历史机遇。嵌入式和单片机技术是物联网技术的重要组成部分，也将进入快速发展的时代。 技术越难，过程越苦，越有利于构建竞争壁垒。大学里很多同学都热衷于学习各种编程语言，往往忽视了这一块，可以说在嵌入式开发这一块的人才我们国家还是比较欠缺的。因此，我觉得大家非常值得投入时间去学习嵌入式开发的技能。原文：https://www.zhihu.com/question/315310041/answer/2179945564
嵌入式开发，特别是单片机os-less的程序，最易范的错误是全局变量满天飞。 这个现象在早期汇编转型过来的程序员以及初学者中常见，这帮家伙几乎把全局变量当作函数形参来用。 在.h文档里面定义许多杂乱的结构体，extern一堆令人头皮发麻的全局变量，然后再这个模块里边赋值123，那个模块里边判断123分支决定做什么。 每当看到这种程序，我总要戚眉变脸而后拍桌怒喝。没错，就是怒喝。 不否认全局变量的重要性，但我认为要十分谨慎地使用它，滥用全局变量会带来其它更为严重的结构性系统问题。 为什么全局变量要越少越好？ 它会造成不必要的常量频繁使用，特别当这个常量没有用宏定义“正名”时，代码阅读起来将万分吃力。 它会导致软件分层的不合理，全局变量相当于一条快捷通道，它容易使程序员模糊了“设备层”和“应用层”之间的边界。写出来的底层程序容易自作多情地关注起上层的应用。 这在软件系统的构建初期的确效率很高，功能调试进度一日千里，但到了后期往往bug一堆，处处“补丁”，雷区遍布。说是度日如年举步维艰也不为过。 由于软件的分层不合理，到了后期维护，哪怕仅是增加修改删除小功能，往往要从上到下掘地三尺地修改，涉及大多数模块， 而原有的代码注释却忘了更新修改，这个时候，交给后来维护者的系统会越来越像一个“泥潭”，注释的唯一作用只是使泥潭上方再加一些迷烟瘴气。 全局变量大量使用，少不了有些变量流连忘返于中断与主回圈程序之间。 这个时候如果处理不当，系统的bug就是随机出现的，无规律的，这时候初步显示出病入膏肓的特征来了，没有大牛来力挽狂澜，注定慢性死亡。 无需多言，您已经成功得到一个畸形的系统，它处于一个神秘的稳定状态！ 你看着这台机器，机器也看着你，相对无言，心中发毛。你不确定它什么时候会崩溃，也不晓得下一次投诉什么时候道理。 全局变量大量使用有什么后果？ “老人”气昂昂，因为系统离不开他，所有“雷区”只有他了然于心。当出现紧急的bug时，只有他能够搞定。你不但不能辞退他，还要给他加薪。 新人见光死，但凡招聘来维护这个系统的，除了改出更多的bug外，基本上一个月内就走人，到了外面还宣扬这个公司的软件质量有够差够烂。 随着产品的后续升级，几个月没有接触这个系统的原创者会发现，很多雷区他本人也忘记了，于是每次的产品升级维护周期越来越长， 因为修改一个功能会冒出很多bug，而按下一个bug，会弹出其他更多的bug。在这期间，又会产生更多的全局变量。 终于有一天他告诉老板，不行啦不行啦，资源不够了，ram或者flash空间太小了，升级升级。 客户投诉不断，售后也快崩溃了，业务员也不敢推荐此产品了，市场份额越来越小，公司形象越来越糟糕。 要问对策，只有两个原则 能不用全局变量尽量不用，我想除了系统状态和控制参数、通信处理和一些需要效率的模块，其他的基本可以靠合理的软件分层和编程技巧来解决。 如果不可避免需要用到，那能藏多深就藏多深。 如果只有某.c文件用，就static到该文件中，顺便把结构体定义也收进来； 如果只有一个函数用，那就static到函数里面去； 如果非要开放出去让人读取，那就用函数return出去，这样就是只读属性了； 如果非要遭人蹂躏赋值，好吧，我开放函数接口让你传参赋值； 实在非要extern侵犯我，我还可以严格控制包含我.h档的对象，而不是放到公共的includes.h中被人围观，丢人现眼。 如此，你可明白我对全局变量的感悟有多深刻，悲催的我，已经把当年那些“老人”交给我维护的那些案子加班全部重新翻写了。 最后补充 全局变量是不可避免要用到的，每一个设备底层几乎都需要它来记录当前状态，控制时序，起承转合。但是尽量不要用来传递参数，这个很忌讳的。 尽量把变量的作用范围控制在使用它的模块里面，如果其他模块要访问，就开个读或写函数接口出来，严格控制访问范围。 这一点，C++的private属性就是这么干的，这对将来程序的调试也很有好处。 C语言之所以有++版本，很大原因就是为了控制它的灵活性，要说面向对象的思想，C语言早已有之，亦可实现。 当一个模块里面的全局变量超过3个(含)时，就用结构体包起来吧，要归0便一起归0，省得丢三落四的。 在函数里面开个静态的全局变量，全局数组，是不占用栈空间的，只是有些编译器对于大块的全局数组，会放到和一般变量不同的地址区。 若是在keil C51，因为是静态编译，栈爆掉了会报警，所以大可以尽情驰骋，注意交通规则就是了。 单片机的os-less系统中，只有栈没有堆的用法，那些默认对堆分配空间的“startup.s”，可以大胆的把堆空间干掉。 程序模型？如何分析抽象出来呢，从哪个角度进行模型构建呢？很愿意聆听网友的意见。 本人一直以来都是从两个角度分析系统，事件--状态机迁移图 和 数据流图，前者分析控制流向，完善UI，后者可知晓系统数据的缘起缘灭。 这些理论，院校的《软件工程》教材都有，大家不妨借鉴下。只不过那些理论，终究是起源于大型系统软件管理的，牛刀杀鸡，还是要裁剪一下的。
【前面的话】在近几年的嵌入式社区中，流传着不少关于面相Cortex-M的Bootloader科普文章，借助这些文章，一些较为经典的代码片断和技巧得到了广泛的传播。 在从Bootloader跳转到用户APP的过程中，使用函数指针而非传统的汇编代码则成了一个家喻户晓的小技巧。相信类似下面 JumpToApp() 函数，你一定不会感到陌生： typedef void (*pFunction)(void); void JumpToApp(uint32_t addr){ pFunction Jump_To_Application; __IO uint32_t StackAddr; __IO uint32_t ResetVector; __IO uint32_t JumpMask; JumpMask = ~((MCU_SIZE-1)|0xD000FFFF); if (((*(__IO uint32_t *)addr) & JumpMask ) == 0x20000000) //�ж�SPָ��λ�� { StackAddr = *(__IO uint32_t*)addr; ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); }} 为了读懂这段代码，需要一些从事Cortex-M开发所需的“热知识”： 向量表是一个由 32bit 数据构成的数组 数组的第一个元素是 uintptr_t 类型的指针，保存着复位后主栈顶指针（MSP）的初始值。 从数组第二个元素开始，保存的是 (void (*)(void)) 类型的异常处理程序地址（BIT0固定为1，表示异常处理程序使用Thumb指令集进行编码） 数组的第二个元素保存的是复位异常处理程序的地址（Reset_Handler） 从理论上说，要想保证APP能正常执行，Bootloader通常要在跳转前“隐藏自己存在过的事实”——需要“对房间进行适度的清理”，并模拟芯片硬件的一些行为——假装芯片复位后是直接从APP开始执行的。 总结来说，Bootloader在跳转到App之前需要做两件事： 1. 清理房间——仿佛Bootloader从未执行过一样 2. 模拟处理器的硬件的一些复位行为——假装芯片从复位开始就直接从APP开始执行 一般来说，做到上述两点，就可以实现App将Bootloader视作黑盒子的效果，从而带来极高的兼容性。甚至在App注入了“跳床（trumpline）”的情况下，实现App既可以独立开发、调试和运行，也可以不经修改的与Bootloader一起工作的奇效。 如何在App中加入“跳床（trumpline）”值得专门再写一篇独立的文章，不是本文所需关注的重点，请允许我暂且略过。 这里，“清理房间”的步骤与Bootloader具体“弄脏了什么”（或者说使用了什么资源）有关；而“模拟处理器硬件的一些复位行为”就较为简单和具体：即，从Bootloader跳转到App前的最后两个步骤为： 从APP的向量表中读取MSP的初始值并以此来初始化MSP寄存器； 从APP的向量表中读取Reset_Handler的值，并跳转到其中去执行——完成从Bootloader到APP的权利交接。 结合前面的例子代码，值得我们关注的部分是： 1. 使用自定义的函数指针类型 pFunction 定义一个局部变量： pFunction Jump_To_Application; 2. 根据向量表的首地址 addr 读取第一个元素——作为MSP的初始值暂时保存在局部变量 StackAddr 中： StackAddr = *(__IO uint32_t*)addr; 3. 根据向量表的首地址 addr 读取第二个元素——将Reset_Handler的首地址保存到局部变量 ResetVector 中： ResetVector = *(__IO uint32_t *)(addr + 4); 4. 设置栈顶指针MSP寄存器： __set_MSP(StackAddr); 5. 通过函数指针完成从Bootloader到App的跳转： Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); 其实，无论具体的代码如何，只要实现步骤与上述类似，就存在一个隐藏较深的漏洞，而漏洞的“触发与否”则完全“看脸”——简单来说： 只要你是按照上述方法来实现从Bootloader到App的跳转的，那么就一定存在问题——而“似乎可以正常工作”就只是你运气较好，或者“由此引发的问题暂时未能引发注意”罢了。 在你试图争辩“老子代码已经量产了也没有什么不妥”之前，我们先来看看漏洞的原理是什么——在知其所以然后，如何评估风险就是你们自己的事情了。 【C语言基础设施是什么】 嵌入式系统的信息安全（Security）建立在基础设施安全（Safety）的基础之上。 由于“确保信息安全的很多机制”本质上是一套建立在“基础设施能够正常工作”这一前提之上的规则和逻辑，因此很多针对信息安全的攻击往往会绕开信息安全的“马奇诺防线”，转而攻击基础设施。芯片数字逻辑的基础设施是时钟源、供电、总线时序、复位时序等等，因此，针对硬件基础设施的攻击通常也就是针对时钟源、电源、总线时序和复位时序的攻击。此时，好奇的小伙伴会产生疑问：固件一般由C语言进行编写，那么C语言所依赖的基础设施又是什么呢？ 对C语言编译器来说，栈的作用是无可替代的： 函数调用 函数间的参数传递 分配局部变量 暂时保存通用寄存器中的内容 …… 可以说，离开了栈C语言寸步难行。因此对很多芯片来说，复位后为了执行用户使用C语言编译的代码，第一个步骤就是要实现栈的初始化。 作为一个有趣的“冷知识”，Cortex-M在宣传中一直强调自己“支持完全使用C语言进行开发”，这让很多人“丈二和尚摸不着头脑”甚至觉得“非常可笑”——因为这年月连51都支持用户使用C语言进行开发了，你这里说的“Cortex-M支持使用C语言进行开发”有什么意义呢？ 其实门道就在这里： 由于Cortex-M处理器会在复位时由硬件完成对C语言基础设施（也就是栈顶指针MSP）的初始化，因此无论是理论上还是实践中，从复位异常处理程序Reset_Handler开始用户就可以完全可以使用C语言进行开发了，而整个启动代码（startup）也可以全然不涉及任何汇编； 由于Cortex-M的向量表是一个完全由 32位整数（uintptr_t）构成的数组——保存的都是地址而非具体代码，可以使用C语言的数据结构直接进行描述——因此也完全不需要汇编语言的介入。 这种从复位一开始就完全不需要汇编介入的友好环境才是Cortex-M声称自己“支持完全使用C语言进行开发”的真实意义和底气。从这一角度出发，只要某个芯片架构复位后必须要通过软件来初始化栈顶指针，就不符合“从出生的那一刻就可以使用C语言”的基本要求。 【C语言编译器的约定】 栈对C语言来说如此重要，以至于编译器一直有一条默认的约定，即： 栈必须完全交由C语言编译器进行管理（或者用户对栈的操作必须符合对应平台所提供的调用规约，比如Arm的AAPCS规约）。 简而言之，如果你“偷偷摸摸”的修改了栈顶指针，C语言编译器是会“假装”完全不知道的，而此时所产生的后果C语言编译器会默认自己完全不用负责。 回头再看这段代码： StackAddr = *(__IO uint32_t*)addr; ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); 虽然我们觉得自己“正大光明”的使用了 __set_MSP() 来修改了栈顶指针，但它实际上是一段C语言编译器并不理解其具体功能的在线汇编——在编译器看来，无论是谁提供的 __set_MSP()，只要是在线汇编，这就算是用户代码——是编译器管不到的地带。 /** \brief Set Priority Mask \details Assigns the given value to the Priority Mask Register. \param [in] priMask Priority Mask */__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask){ __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");} 或者说：C语言编译器一般情况下会默认你“无论如何都不会修改栈顶指针”——它不仅管不着，也不想管。 从这点来看，上述代码的确打破了这份约定。即便如此，很多小伙伴会心理倔强的认为：我就这么改了，怎么DE了吧？！ 【问题的分析】 从原理上说，开篇那个典型的Bootloader跳转代码所存在的问题已经昭然若揭： typedef void (*pFunction)(void); void JumpToApp(uint32_t addr){ pFunction Jump_To_Application; __IO uint32_t StackAddr; __IO uint32_t ResetVector; __IO uint32_t JumpMask; JumpMask = ~((MCU_SIZE-1)|0xD000FFFF); if (((*(__IO uint32_t *)addr) & JumpMask ) == 0x20000000) //�ж�SPָ��λ�� { StackAddr = *(__IO uint32_t*)addr; ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); }} 我们不妨结合上述代码反汇编的结果进行深入解析： AREA ||i.JumpToApp||, CODE, READONLY, ALIGN=2 JumpToApp PROC000000 b082 SUB sp,sp,#8000002 4909 LDR r1,|L2.40|000004 9100 STR r1,[sp,#0]000006 6802 LDR r2,[r0,#0]000008 400a ANDS r2,r2,r100000a 2101 MOVS r1,#100000c 0749 LSLS r1,r1,#2900000e 428a CMP r2,r1000010 d107 BNE |L2.34|000012 6801 LDR r1,[r0,#0]000014 9100 STR r1,[sp,#0]000016 6840 LDR r0,[r0,#4]000018 f3818808 MSR MSP,r100001c 9001 STR r0,[sp,#4]00001e b002 ADD sp,sp,#8000020 4700 BX r0 |L2.34|000022 b002 ADD sp,sp,#8000024 4770 BX lr ENDP 000026 0000 DCW 0x0000 |L2.40| DCD 0x2fff0000 注意这里，StackAddr、ResetVector是两个局部变量，由编译器在栈中进行分配。汇编指令将SP指针向栈底挪动8个字节就是这个意思： 000000 b082 SUB sp,sp,#8 虽然 JumpMask 也是局部变量，但编译器根据自己判断认为它“命不久矣”，因此直接将它分配到了通用寄存器r2中，并配合r1和sp完成了后续运算。这里： __IO uint32_t JumpMask; JumpMask = ~((MCU_SIZE-1)|0xD000FFFF); if (((*(__IO uint32_t *)addr) & JumpMask ) == 0x20000000) //�ж�SPָ��λ�� { ... } 对应： 000002 4909 LDR r1,|L2.40|000004 9100 STR r1,[sp,#0]000006 6802 LDR r2,[r0,#0]000008 400a ANDS r2,r2,r100000a 2101 MOVS r1,#100000c 0749 LSLS r1,r1,#2900000e 428a CMP r2,r1000010 d107 BNE |L2.34|...|L2.34|000022 b002 ADD sp,sp,#8000024 4770 BX lrENDP 000026 0000 DCW 0x0000|L2.40|DCD 0x2fff0000 考虑到JumpMask的内容与本文无关，不妨暂且跳过。 接下来就是重头戏了： 编译器按照用户的指示读取栈顶指针MSP的初始值，并保存在StackAddr中： StackAddr = *(__IO uint32_t*)addr; 对应的汇编是： 000012 6801 LDR r1,[r0,#0]000014 9100 STR r1,[sp,#0] 根据Arm的AAPCS调用规约，编译器在调用函数时会使用R0~R3来传递前4个符合条件的参数（这里的条件可以简单理解为每个参数的宽度要小于等于32bit）。根据函数原型 void JumpToApp(uint32_t addr); 可知，r0 中保存的就是形参 addr 的值。所以第一句汇编的意思就是：根据 （addr + 0）作为地址读取一个uint32_t型的数据保存到r1中。 第二句汇编中，栈顶指针sp此时实际上指向局部变量 StackAddr，因此其含义就是将通用寄存器r1中的值保存到局部变量 StackAddr 中。 对于局部变量 ResetVector 的读取操作，编译器的处理如出一辙： ResetVector = *(__IO uint32_t *)(addr + 4); 对应： 000016 6840 LDR r0,[r0,#4]00001c 9001 STR r0,[sp,#4] 其实就是从 (addr + 4) 的位置读取 32bit 整数，然后保存到r0里，并随即保存到sp所指向的局部变量 ResetVector 中。到这里，细心地小伙伴会立即跳起来说“不对啊，原文不是这样的！”。是的，这也是最有趣的地方。实际的汇编原文如下： 000016 6840 LDR r0,[r0,#4]000018 f3818808 MSR MSP,r100001c 9001 STR r0,[sp,#4] 作为提醒，它对应的C代码如下： ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); 后面的 __set_MSP(StackAddr) 所对应的汇编代码 MSR MSR,r1 居然插入到了ResetVector赋值语句的中间？！ “C语言编译器这么自由的么？” “在我使用sp之前把栈顶指针更新了？！” 先别激动，还记得我们和C语言编译器之间的约定么？C语言编译器默认我们在任何时候都不应该修改栈顶指针。因此在他看来，“你 MSR 指令操作的是r1，关我sp和r0啥事”？“我就算随意更改顺序应该对你一毛钱影响都没有！（因为我不关心、也没法知道用户线汇编语句的具体效果，因此我只关心涉事的通用寄存器是否存在冲突）” 上述“骚操作”的后果是：保存在r0中的Reset_Handler地址值被保存到了新栈中（MSP + 4）的位置。这立即带来两个潜在后果： 由于MSP指向的是栈存储器的末尾（栈是从数值较大的地址向数值较小的地址生长），因此 (MSP+4）实际上已经超出栈的合法范围了。 这一操作与其说是会覆盖栈后续的存储空间，倒不如说风险主要体现在BusFault上——因为相当一部分人习惯将栈放到SRAM的最末尾，而MSP+4直接超出SRAM的有效范围。 我们以为的ResetVector其实已经不在原本C编译器所安排的地址上了。 精彩的还在后面： Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); 对应的翻译是： 00001e b002 ADD sp,sp,#8000020 4700 BX r0 通过前面的分析，我们知道，此时r0中保存的是Reset_Handler的地址，因此 BX r0 能够成功完成从Bootloader到APP的跳转——也许你会松一口气——好像局部变量ResetVector的错位也没引起严重的后果嘛。 看似如此，但真正吓人的是C语言编译器随后对局部变量的释放： 00001e b002 ADD sp,sp,#8 它与一开始局部变量的分配形成呼应： 000000 b082 SUB sp,sp,#8...00001e b002 ADD sp,sp,#8 好借好还，再借不难。但此sp非彼sp了呀！ 这里由于JumpToApp没有加上__NO_RETURN的修饰，因此C编译器并不知道这个函数是有去无回的，因此仍然会像往常一样在函数退出时释放局部变量。 就像刚才分析的那样：由于MSP指向的是栈存储器的末尾（栈是从数值较大的地址向数值较小的地址生长），因此 (MSP+8）实际上已经超出栈存储空间的合法范围了。 考虑到相当一部分人习惯将栈放到SRAM的最末尾，而MSP+8直接超出SRAM的有效范围，即便刚跳转到APP的时候还不会有事，但凡APP用了任何压栈操作，（无论是BusFault还是地址空间绕回）就很有可能产生灾难性的后果。 【宏观分析】 就事论事的讲，单从汇编分析来看，上述代码所产生的风险似乎是可控的，甚至某些人会觉得可以“忽略不计”。但最可怕的也就在这里，原因如下： 从原理上说，将关键信息保存在依赖栈的局部变量中，然后在编译器不知情的情况下替换了栈所在的位置，此后只要产生对相关局部变量的访问就有可能出现“刻舟求剑”的数据错误。这种问题是“系统性的”、“原理性的”。 （此图由GorgonMeducer借助GPT4进行一系列关键词调校、配上台词后获得） 不同编译器、同一编译器的不同版本、同一版本的不同优化选项都有可能对同一段C语言代码产生不同的编译结果，因此哪怕我们经过上述分析得出某一段汇编代码似乎不会产生特别严重的后果，在严谨的工程实践上，这也只能算做是“侥幸”，是埋下了一颗不知道什么时候以什么方式引爆的定时炸弹。 根据用户Bootloader代码在修改 MSP 前后对局部变量的使用情况不同、考虑到用户APP行为的不确定性、由上述缺陷代码所产生的Bootloader与APP之间配合问题的组合多种多样、由于涉及到用户栈顶指针位置的不确定性以及新的栈存储器空间中内容的随机性，最终体现出来的现象也是完全随机的。用人话说就是，经常性的“活见鬼” 【解决方案】 既然我们知道不能对上述缺陷代码抱有侥幸心理，该如何妥善解决呢？第一个思路：既然问题是由栈导致的，那么直接让编译器用通用寄存器来保存关键局部变量不就行了？修改代码为： typedef void (*pFunction)(void); void JumpToApp(uint32_t addr){ pFunction Jump_To_Application; register uint32_t StackAddr; register uint32_t ResetVector; register uint32_t JumpMask; JumpMask = ~((MCU_SIZE-1)|0xD000FFFF); if (((*(__IO uint32_t *)addr) & JumpMask ) == 0x20000000) //�ж�SPָ��λ�� { StackAddr = *(__IO uint32_t*)addr; ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); }} 相同编译环境下得出的结果为： AREA ||i.JumpToApp||, CODE, READONLY, ALIGN=2 JumpToApp PROC 000002 6801 LDR r1,[r0,#0]000004 4011 ANDS r1,r1,r2000006 2201 MOVS r2,#1000008 0752 LSLS r2,r2,#2900000a 4291 CMP r1,r200000c d104 BNE |L2.24| 00000e 6801 LDR r1,[r0,#0]000010 6840 LDR r0,[r0,#4]000012 f3818808 MSR MSP,r1 000016 4700 BX r0 |L2.24|000018 4770 BX lr ENDP 00001a 0000 DCW 0x0000 |L2.28| DCD 0x2fff0000 可见，上述汇编中半个 sp 的影子都没看到，问题算是得到了解决。 然而，需要注意的是 register 关键字对编译器来说只是一个“建议”，它听不听你的还不一定。加之上述例子代码本身相当简单，涉及到的局部变量数量有限，因此问题似乎得到了解决。 倘若编译器发现你大量使用 register 关键字导致实际可用的通用寄存器数量入不敷出，大概率还是会用栈来进行过渡的——此时，哪些局部变量用栈，哪些用通用寄存器就完全看编译器的心情了。 进一步的，不同编译器、不同版本、不同优化选项又会带来大量不可控的变数。 因此就算使用 register 修饰关键局部变量的方法可以救一时之疾（“只怪老板催我催得紧，莫怪我走后洪水滔天”），也算不得妥当。 第二个思路：既然问题出在局部变量上，我用静态（或者全局）变量不就可以了？修改源代码为： #include "cmsis_compiler.h" typedef void (*pFunction)(void); __NO_RETURNvoid JumpToApp(uint32_t addr){ pFunction Jump_To_Application; static uint32_t StackAddr; static uint32_t ResetVector; register uint32_t JumpMask; JumpMask = ~((MCU_SIZE-1)|0xD000FFFF); if (((*(__IO uint32_t *)addr) & JumpMask ) == 0x20000000) //�ж�SPָ��λ�� { StackAddr = *(__IO uint32_t*)addr; ResetVector = *(__IO uint32_t *)(addr + 4); __set_MSP(StackAddr); Jump_To_Application = (pFunction)ResetVector; Jump_To_Application(); }} 这种方法看似稳如老狗，实际效果可能也不差，但还是存在隐患，因为它“没有完全杜绝编译器会使用栈的情况”，只要我们还会通过 __set_MSP() 在C语言编译器不知道的情况下更新栈顶指针，风险自始至终都是存在的。 对某些连warning都要全数消灭的团队来说，上述方案多半也是不可容忍的。 第三个思路：完全用汇编来处理从Bootloader到App的最后步骤。对此我只想说：稳定可靠，正解。 只不过需要注意的是：这里整个函数都需要用纯汇编打造，而不只是在C函数内容使用在线汇编。 原因很简单：既然我们已经下定决心要追求极端确定性，就不应该使用线汇编这种与C语言存在某些“暧昧交互”的方式——因为它仍然会引入一些意想不到的不确定性。 本着一不做二不休的态度，完全使用汇编代码来编写跳转代码才是万全之策。 【说在后面的话】 在使用栈的情况下，on-fly 的修改栈顶指针就好比在飞行途中更换引擎——不是不行，只是要求有亿点点高。 我在微信群中帮读者分析各类Bootloader的见鬼故障时，经常在大费周章的一通分析和调试后，发现问题的罪魁祸首就是跳转代码。可怕的是，几乎每个故障的具体现象都各不相同，表现出的随机性也常常让人怀疑是不是硬件本身存在问题，亦或是产品工作现场的电磁环境较为恶劣。最要命的当数那种“偶尔出现”而复现条件颇为玄学的情形，甚至在办公室环境下完全无法重现的也大有人在。同样的问题出的多了，我几乎在每次帮人调试Bootloader时都会习惯性的先要求检查跳转代码——虽然不会每次都能猜个正着，但也有个恐怖的十之七八。这也许是某种幸存者偏差吧——毕竟大部分普通问题大家自己总能解决，到我这里的多半就是“驱鬼”了。见得多了，我突然发现，出问题的代码大多使用函数指针来实现跳转——而用局部变量来保存函数指针又成了大家自然而然的选择。加之此前很多文章都曾大规模科普上述技巧，甚至是直接包含一些存在缺陷的Bootloader范例代码，实际受影响的范围真是“细思恐极”。特此撰文，为您解惑。
都说MCU本身不算什么高级东西，在MCU开发过程中，需要按照一定的标准化来执行，比如对变量，函数的定义，要确定他的生命周期，调用范围，访问条件等；常用的通信协议读写的协议往往应该抽象化，规定固定的输入输出，方便产品移植。 但实际上，很多时候，针对同一个需求其实有多种实现方案，但总有一个最优解。所以在这个过程中，总会有一些“脑洞大开”的操作，为人提供很多思路，今天就举几个例子给大家作为参考。 那些很惊艳的用法 当需要通过串口接收一串不定长数据时，可以使用串口空闲中断；这样就可以避免每接收到一个字符就需要进入中断进行处理，可以减少程序进入中断次数从而提高效率。 当需要测量一个波形的频率时，很多人会选择外部中断，其实通过定时器的外部时钟输入计数波形边沿，然后定时读取计数值计算频率的方式可以大大减少中断触发频率，提高程序执行效率。 在处理复杂的多任务场景时，可以利用实时操作系统（RTOS）来管理任务调度，提高系统的响应性和资源利用率。 对于需要低功耗运行的场景，可以采用动态电压频率调整（DVFS）技术，根据系统负载实时调整 MCU 的工作电压和频率，以降低功耗。 在进行数据存储时，采用闪存的磨损均衡算法，延长闪存的使用寿命。 利用硬件加密模块（如 AES 加密引擎）来保障数据的安全性和保密性，而不是通过软件实现加密，提高加密效率和安全性。 对于传感器数据的处理，采用数字滤波算法（如卡尔曼滤波），提高数据的准确性和稳定性。 当需要与多个设备进行通信时，采用总线仲裁机制和优先级设置，确保通信的高效和稳定。 在进行电源管理时，通过监测电源电压和电流，实现智能的电源管理策略，例如在低电量时进入低功耗模式。 对于实时性要求极高的控制任务，采用硬件直接触发中断，而不是通过软件轮询，减少响应延迟。 在单片机上跑的任何非线性系统的动态控制，都是高级用法。 用单片机去实现某种特殊的运动控制，赚很多钱，就是高级用法。 GPIO模拟一切 名为ShiinaKaze的网友，就非常“勇”，做了一个很折磨的事。 他用STM32F1利用GPIO模拟摄像头接口驱动OV2640摄像头模块。他表示，这是一个很折磨人的过程，我最多优化到了 1.5 FPSQ，所以选型一定要选好，不要折磨自己。设备采用STM32F103C8T6，OV2640，实现效果如下： OV2640实际时序图： 这个项目难点在于： 1.SCCB 模拟:SCCB 是12C-bus 的改版，主要是 OV2640 模块没有上拉电阻，无法进行通信，花了好长时间才发现这个问题； 2.并行接口的模拟:如果使用 IO 模拟的话，只能达到1FPS，但是使用了 Timer 和 DMA，就可以达到 1.5～2 FPS。 关于 image sensor 的数据接收和处理的问题背景：现有 ov2640 image sensor，接口为 DCMI（并行接口）问题：现有 STM32H7 想获取 OV2640 的 mjpeg 流数据，并通过传输数据到 PC 软件 1.采用 USART 还是 USB？ 2.接收数据选择哪种中断，Line interrupt 还是 Frame interrupt ？ 3.DCMI 通过 DMA 将数据转到 RAM 中的 Buffer，那么 Buffer 该如何设计，是设置一块大的连续 buffer？还是需要做一个 ring buffer，避免数据覆盖和数据顺乱？ 4.触发中断后，是否关闭 DCMI 和 DMA ？ 嵌入式软件架构挺重要的，特别是大型项目。这是 STM32 的软件架构，不知道各位还有没有其他架构。 有网友吐槽，你要是在学校，我敬你是条汉子，你要是在工作岗位上干这鸟事，那你们的架构也太坏了。而他也表示——“我错了，再也不模拟了。” 关于MCU不一样的观点 虽然如此，很多人还是认为，MCU不高级，使用单片机也不高级。高级的内容都是可以发论文的，使用单片机发不了论文。但使用单片机解决指定的任务，这很高级。 尤其是上面所说的一些例子，确实是MCU外设的一些高端玩法。只不过，这些机制可能只是一种标准用法。名为lion187的网友就表示，毕竟许多硬件机制有实际需求后才添加进来的，比如接收不定长数据，最初没有超时中断的情况下只能软件实现，极大的浪费了CPU的效率，所以才设计了超时中断来减少软件工作量，进而形成了一种标准使用方法。 当然，这也是芯片设计和制造工艺的提升带来的红利，早期芯片设计和工艺无法满足复杂外设电路时，谁也不敢会去想用硬件来实现这么复杂的功能，任何产品的开发，都离不开具体业务需求，MCU也不例外， 对产品来说，MCU外设的驱动只是完成开发的基本要素，更多的工作是围绕着业务逻辑展开的应用程序的开发。这时候数据结构与算法，各种控制算法和数值计算方法，设计模式，软件工程和设计理念成了高级的东西。 比如说，Linux 内核中的各驱动子系统的设计，设备对象和驱动对象这些沿用了 C++ 面向对象编程的思路，其实也可以沿用到 MCU的开发中，将设备与驱动分离，就可以使用同一套驱动算法来实现同类设备的不同驱动方法， 比如:同一个 UART 驱动可以根据配置的不同来驱动 UARTO，也可以驱动 UART1，而且波特率也可以不同(只要为 UART 类创建不同的实例对象就可以了，用 C 语言就行)，这就是 C++ 中方法与属性分离带来的好处。 同样在业务应用部分，单件模式、工厂模式等设计模式，状态机模型的使用也会给开发带来很多便利，使系统结构清晰，有效减少Bug数量，且易于维护和扩展。 当然，也有人认为，论高级还得是FPGA。就比如AMD（赛灵思）的ZYNQ，当你需要通过串口接收一串不定长数据时，可以直接用Programmable Logic部分写一个专用的，最终结果放到DRAM里，发个信号通知ARM处理器来读就好了；当你需要测量一个波形的频率时，可以直接用Programmable Logic部分写一个专用的，实时不间断测量。这就很高级。 所以，对此你有什么看法，你有什么很“高级”的用法想要分享？
扫码关注面包板社区
