未来计算的革命：探索存算一体芯片的潜力与挑战

前言

本文学习自：存算一体芯片深度产业报告——作者：量子位

报告链接：存算一体是啥新趋势？值得教授学者纷纷下海造芯 | 附报告下载 - 知乎 (zhihu.com)，侵删！

存算一体技术概述

“存算一体”技术的起因在于传统冯诺依曼架构芯片无法满足不断提升的算力与低功耗需求。随着晶体管的体积越来越小，摩尔定律逐渐失效（会引发量子隧穿等反应），导致存储器与处理器之间的数据传输成为 CPU 性能的瓶颈，相对较长时间的数据搬运导致算力受限。

为了解决这个问题，我们需要新的芯片架构。主要有三种解决方式：

1. 近存计算：缩短处理器芯片与存储器芯片的距离，减少数据搬运损耗。
2. 内存储计算：处理器和存储器位于同一芯片的不同电路单元中。
3. 内存执行计算：通过在存储器颗粒上嵌入算法，由存储器芯片内部的存储单元完成计算操作。

产业分析

存算一体芯片落地的优势在于在算力提高的同时，芯片体积的减小和数据传输功耗的减少，使得芯片良率、成本、功耗等都有所改善。然而，实际应用的挑战主要在于评估市场需求和客户转换成本。重要的考量是，大规模采用新型芯片是否能够在成本和能耗方面带来足够的改进，以证明其经济效益；新架构芯片的先进生产工艺制造能力；客户对低功耗和高算力的需求；以及封装、测试、工具链、EDA 等相辅相成的产业链生态仍缺乏相应的研发公司。

当下大多数初创公司的思路是先聚焦特定场景，在垂直领域内站稳脚跟后技术外溢到更丰富的应用场景。主要的应用场景包括小算力低功耗场景（知存科技、九天睿芯和闪易半导体等）和大算力场景（千芯科技，后摩智能等）。

目前已知的商业模式主要分为三种：IP授权，定制/联合开发以及自主SoC芯片。

当前国内外存算一体技术发展特征如下：

• 成立时间不同会影响技术路线选择，国内外实现产品化的公司数量不多，离规模化还有一定距离
• 技术路线：大公司选择最容易落地的，初创公司在确保技术先进性基础上选择最容易落地的
• 国外已形成完整的自研技术链，大规模量产上国内外均未实现突破
• 不同的业务场景均已呈现出各自的优势，在商业模式上国内外都处在探索阶段
• 虽然业内尚未形成完整的生态，产业链部分环节已经出现针对存算一体进行技术研发的公司

未来展望

为了推动存算一体技术的未来发展，重点应放在解决关键技术难题上，并且寻找适合快速应用推广的场景。随着新型存储器技术，尤其是RRAM和MRAM的不断进步，预计将大幅推进存算一体架构的发展。这些技术的应用，尤其是在终端推理和物联网领域，预示着存算一体技术将在这些领域发挥重要作用。为了实现从初步商业化到大规模商业化的转变，技术创新与产业发展必须紧密协同，共同推动这一技术的成熟和应用普及。

个人感悟

作为一名物联网工程专业的大学生，深入了解存算一体技术让我领略了科技创新的魅力及其在未来应用的广阔前景。虽然我尚缺乏商业模式和产品上市的实践经验，但这次学习经历让我认识到理论与实践结合的重要性，以及跨学科知识对于技术创新的贡献。

通过研究这一技术，我明白了在物联网设备设计中，如何有效融合硬件和软件来提高性能同时降低能耗的重要性。这一认识不仅提升了我的专业技能，也激发了我对如何将技术创新转化为实际应用的深入思考。

此外，我也看到了自己在商业知识和市场分析方面的不足，这提示我在未来的学习中需更多关注这些领域。我期待将这次学习的感悟转化为动力，在未来的学习和工作中不断探索、学习和创新，为智能化世界贡献我的力量。

前言

博主开始探索嵌入式以来，其实很早就开始玩 stm32 了。但是学了一段时间之后总是感觉还是很没有头绪，不知道在学什么。前前后后分别尝试了江协科技、正点原子、野火霸天虎三次 stm32 的课程学习。江协科技的 stm32f103c8t6 课程看了一段时间，感觉对一些外设的调用方法有一个基础的认知了，但是没有很明白到底在学什么；正点原子则是有点听不懂，半字也借给同学了就有一段时间没学，感觉自认为 stm32 学的有两把刷子了。后来听前辈说江协科技的 stm32 课程不如 51 单片机的质量好，其实课程讲的一般，我就想：是不是应该重新好好学一下 stm32 课程了。

这次选择的是野火的 F407 霸天虎课程，第一是听大家说，入门选野火或者正点最好。第二是野火的大师进阶篇的一些内容，涉及到一些原理等的学习讲解，我觉得对我会非常有帮助，因此正好就买了这款开发板从入门到中级到大师原理一起学习了。

本系列博文笔记主要基于野火相应课程，b站地址：野火F407开发板-霸天虎视频-【入门篇】_哔哩哔哩_bilibili ，仅供学习参考不做任何商业用途使用，侵删！

调试器介绍

我选择的是高速版，支持 SW 和 JTAG 两种连接方式。SW 模式则只需要连接 VREF（3V3）, TMS（数据）, TCK, RESET, GND 五个引脚。

程序烧录配置

芯片型号：STM32F407ZGTX。

DAP 仿真烧录自然非常简单。

串口一键下载 ISP 下载速度慢，不能调试，但是成本很低。可以使用 FlyMcu 等软件。

2023.11.2 补充。

警告，建议如果 flymcu 不能烧录，就不要尝试这种玩法了，看看课学学得了。因为我自己乱捣鼓一通后把开发板锁了。

下面的内容我不太清楚具体是哪一步出现了锁死 flash 的问题，总之不要尝试！学习一下理论得啦。

如果和我一样锁死了，请见野火大师篇程序，里面有一个解除写保护的代码，运行一下。

ISP 下载方式：允许我们不拆下芯片来下载。对于上个世纪嵌入式学习来说这是一个很大的突破，因为当时是要把芯片拆下来烧录编程的。

ISP 厂商出产的时候就选定了一种串行外设对芯片内部 FLASH 进行编程，我们不能修改。常用串口下载方式，成本低，但是不能调试仿真。

普通 ISP 需要手动配置 boot loader，一键 ISP 不用，硬件电路和上位机配合达到一键下载的效果（手动配置：00是用户闪存启动，10是系统 SRAM/ISP 启动，普通 ISP 要手动改跳线帽）。

一键下载电路的具体原理流程如下：

1. RTS 低电平，Q1 是一个 PNP 三极管，导通，BOOT0 拉高。
2. DTS 高电平，Q2 NPN 导通，U18 是一个由 EN 控制开关的模拟开关，2 脚被导通为低电平，连接1脚拉低 NRST 复位。程序下载执行。
3. U18 模拟开关的作用是稳定电路。开发板复位的时候 DTR RTS 是不稳定的状态，如果没有这个模拟开关，DTR RTS 可能进入 ISP 状态，复位，进入 ISP 状态，复位，进入……一直运行不起来了。模拟开关右侧电容使得 VCC 需要花一点时间充电给 EN，而不是立刻激活 EN（EN 1.8V 左右）。这时候 DTR RTS 已经稳定了，可以导通 U18 12 引脚来给 NRST 复位了。

不过 FlyMcu 实际配置方式是反过来的，因为他的协议是 232（+3+15 是 0，-3-15 是 1），和 TTL（3.3v 是1,0v 是0）正相反。

但是实际操作的时候可能遇到一种状况：部分开发板无法使用 FlyMcu 写入。我就碰到了。解决办法是使用 stm32 cube programmer 烧录程序。

配置如下：开发板上 boot 连接 3v3，RTS DTR=0，选中 read unprotect，建立连接后再烧录程序。

但是不知道是波特率或者校验位的问题，我每次能成功烧录进去，然后过一会就显示断开找不到设备了。可能是因为波特率没有76800的选项。

STM32 介绍

正点原子网课：单片机和电脑的类比：内存是 SRAM，硬盘是 FLASH，主板是外设。

st：意法半导体公司，SoC 厂商。

m：微控制器。微控制器和微处理器相比性能比较拉一点，主频低，微处理器能跑一些大 os（linux）。

32：32位微控制器。

正点原子网课：8051，X86 属于 CISC；ARM, MIPS, RISC-V 属于 RISC.

冯诺依曼和哈佛结构的主要区别：程序存储器和数据存储器是否分开存储。不分开是冯诺依曼，分开是哈佛。哈佛执行效率更高，冯诺伊曼资源占据更少。

CORTEX-M 系列介绍
ARM 公司（做精简指令集计算机的）只设计内核架构和授权知识产权，不参与设计芯片，给其他合作公司授权设计芯片。半导体厂商再根据架构完善周边电路并制作芯片。现在95%手机、平板都是 ARM 架构的， ARM 公司是真的牛。

其优点在于低功耗低成本高性能，且支持16/32位双指令集。

ARM 有9个版本，从 v6 开始出现 cortex 的命名。

随着需求不断发展，stm32 在一众 8/16位 MCU 中脱颖而出。

stm32 自带许多通信接口，如 spi i2c uart 等；扫地机，无人机，手环等都可以是 stm32 的作品。

如何选型？以下是几大类 stm32 的特点。

本课程学习使用的开发板命名方式：

选型：满足项目需求的前提下，尽可能选便宜的，比如主频低，功耗低，引脚少，flash 少。

引脚分配：

看手册的重点：

外设资源，芯片功能，引脚，引脚大致分类，内存，封装……

哎想起前两天面试被问，如果选型 MCU 我应该看哪些因素。我只想到了外设和内存hhh。属于是只会写代码的笨比了。这也是我开始重新看野火课程的原因之一。

寄存器

虽然正式编程没有必要用寄存器编程，通常都是库函数或者 hal 库。但是还是有必要学一下原理的。

寄存器映射

芯片视图如下。

丝印：芯片上印的信息。型号，内核，生产批次等。

引脚：左上角是有小圆点的，从左上-左下-右下-右上逆时针看。或者如果没有小圆点，把丝印方向摆正，从左上角开始看。

芯片内部组成：

寄存器映射：32位，2^32^=4GB，因此所有程序都需要通过内存 4GB 去映射访问。

block7：M4 芯片内外设，比如一些通信总线这些都算外设。

block1：内存。

block0：代码。不过实际上由于设计工艺的问题，block0 block1 都只用了很少的一部分来存代码或者作为内存。

外设寄存器放在 block2 中。根据不同块速度不一样，又具体分为不同速度的外设（AHB APB）。

总线速度：AHB>APB2>APB1. APB1 是较低速的外设，包括 I2C UART SPI 看门狗等。

我们想要操作特定的外设，其实就是控制他的寄存器。控制寄存器就要找到寄存器相应的地址往里面写入数据，寄存器地址就是内存中的地址映射。

比如 GPIOF 我们想让其端口全部输出高电平。我们查找 stm32f407 手册，发现 GPIOF 的地址是 0x40021400，GPIOF 的 ODR（output data register）相对起始地址的偏移地址是14，则我们需要给 0x40021414 的地址写入数据 0xFFFF.

51 单片机库函数中封装的 reg51.h 中，利用 sfr 定义寄存器地址；而 stm32 库函数中使用宏定义，这些就是寄存器映射操作。对芯片里一个特殊功能的内存单元起别名的过程就是寄存器映射。 给这个地址再分配一个地址交重映射，stm32 中不咋常用。

C语言对寄存器的封装

这样逐个地址，哪怕已经进行了寄存器映射，还是很复杂。

c 语言库函数实际进行的封装操作是使用结构体批量定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/* GPIO 外设基地址 */
#define GPIOA_BASE (AHB1PERIPH_BASE + 0x0000)
#define GPIOB_BASE (AHB1PERIPH_BASE + 0x0400)
#define GPIOC_BASE (AHB1PERIPH_BASE + 0x0800)
#define GPIOD_BASE (AHB1PERIPH_BASE + 0x0C00)
#define GPIOE_BASE (AHB1PERIPH_BASE + 0x1000)
#define GPIOF_BASE (AHB1PERIPH_BASE + 0x1400)
#define GPIOG_BASE (AHB1PERIPH_BASE + 0x1800)
#define GPIOH_BASE (AHB1PERIPH_BASE + 0x1C00)

/* GPIO 寄存器列表 */
typedef struct {
    uint32_t MODER; /*GPIO 模式寄存器 地址偏移: 0x00 */
    uint32_t OTYPER; /*GPIO 输出类型寄存器 地址偏移: 0x04 */
    uint32_t OSPEEDR; /*GPIO 输出速度寄存器 地址偏移: 0x08 */
    uint32_t PUPDR; /*GPIO 上拉/下拉寄存器 地址偏移: 0x0C */
    uint32_t IDR; /*GPIO 输入数据寄存器 地址偏移: 0x10 */
    uint32_t ODR; /*GPIO 输出数据寄存器 地址偏移: 0x14 */
    uint16_t BSRRL; /*GPIO 置位/复位寄存器低 16 位部分 地址偏移: 0x18 */
    uint16_t BSRRH; /*GPIO 置位/复位寄存器高 16 位部分 地址偏移: 0x1A */
    uint32_t LCKR; /*GPIO 配置锁定寄存器 地址偏移: 0x1C */
	uint32_t AFR[2]; /*GPIO 复用功能配置寄存器 地址偏移: 0x20-0x24 */
} GPIO_TypeDef;

/* 使用 GPIO_TypeDef 把地址强制转换成指针 */
#define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
#define GPIOB ((GPIO_TypeDef *) GPIOB_BASE)
#define GPIOC ((GPIO_TypeDef *) GPIOC_BASE)
#define GPIOD ((GPIO_TypeDef *) GPIOD_BASE)
#define GPIOE ((GPIO_TypeDef *) GPIOE_BASE)
#define GPIOF ((GPIO_TypeDef *) GPIOF_BASE)
#define GPIOG ((GPIO_TypeDef *) GPIOG_BASE)
#define GPIOH ((GPIO_TypeDef *) GPIOH_BASE)

所有外设都是如此，首先定义总线 APB AHB 地址，然后每个外设在其基础上进行偏移，每个外设的不同部分再在该外设基址上进行偏移。

新建工程

寄存器方式

要命啊，一看名字我就不想试。寄存器新建不得麻烦死。

哎算了为了学习原理，干了。

我们尝试自己写一个寄存器的库函数来引用。

首先我们需要引用 st 官方启动文件 stmf4xx.s，具体用途后面章节再展开讲解。然后我们自己新建一个 stm32f4xx.h 文件来映射寄存器。不过只是把这个文件包含进项目，编译会报错：

1

.\Objects\led_reg.axf: Error: L6218E: Undefined symbol SystemInit (referred from startup_stm32f40xx.o).

进入启动文件后，可以看到这么一个函数：

1
2
3
4
5
6
7
8
9
10
11

; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]
        IMPORT  SystemInit
        IMPORT  __main

                 LDR     R0, =SystemInit
                 BLX     R0
                 LDR     R0, =__main
                 BX      R0
                 ENDP

import 的作用相当于 extern，所以没有找到这个函数的定义，需要我们自己去定义。这就是为什么简单引入了启动文件会报错。

而 __main 是当我们定义了 main() 函数后，编译器会自动链接一些c语言库定义好的函数，用于初始化堆栈并且调用我们的 main().

注意，如果想要生成 __main 函数，必须勾选下面这一项。

野火你讲的是真好啊。我之前草草学了学 stm32 单片机用法，比赛的时候自己想移植代码，改了启动文件也不好使，就是报错。原来是这个原因。

那么我们只需要定义这么一个函数，哪怕内容是空都无所谓。

最终我们定义的初步项目框架如下：

stm32f4xx.h：内容为空，有这么个东西就行。

main.c：

1
2
3
4
5
6
7
8
9
10
11

#include "stm32f4xx.h"

int main(){
	while(1){
		
	}
}

void SystemInit(){
	
}

好了，这个程序可以烧录到板子上的。烧录成功之后没有任何反应（因为本来程序也没做什么哈哈），但是这就是一个大进步了。

点灯——51单片机版

51单片机版就是引用 reg51.h 头文件，在其中声明了各个引脚的地址。我们只需要直接给引脚赋值即可。

调用代码：

1
2
3
4
5
6
7
8

#include "reg51.h"

#ifdef 0 
void main(){
	PA0=0xFE;
	while(1){}
}
#endif

接下来我们需要定义 LED 灯的寄存器位置。阅读原理图如下：

大致可以看出，板子上的这个 RGB LED 通过三个引脚来控制 RGB 亮度。输出低电平则导通点亮。

具体输出方式是通过 ODR 进行输出。查找 stm32f4xx 中文参考手册可见：

那么我们就要给 0x4002 1400 +14 的地址赋值，让 1<<6 1<<7 1<<8 的位分别赋值为低电平.

1
2
3
4
5
6

int main(){
	 *(unsigned int *)(0x40021400+14)&=~(1<<6); 
	while(1){
		
	}
}

然而这样也不亮。亮就怪了，stm32 寄存器是需要先做初始化配置的。

点灯——stm32 版

首先我们要设置 GPIO 模式。

想点灯 输出高低电平，是 01 通用输出模式。

1
2

*(unsigned int *)(0x40021400+0)&=~(3<<(6*2)); 
*(unsigned int *)(0x40021400+0)|=(1<<(6*2)); 

意思是先把 PF6 模式位置为00，然后赋值为01通用输出。

配置完模式之后，还需要配置时钟，stm32 每个外设都需要配置时钟。

前面提到过 GPIO 是在 AHB1.

全部代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include "stm32f4xx.h"

int main(){
    //RCC
    *(unsigned int *)(0x40023800+0x30)|=(1<<5); 
    
    //Mode
    *(unsigned int *)(0x40021400+0)&=~(3<<(6*2)); 
    *(unsigned int *)(0x40021400+0)|=(1<<(6*2)); 
    
    
    *(unsigned int *)(0x40021400+0x14)&=~(1<<6); 
    while(1){
		
	}
}

void SystemInit(){
	
}

接下来，我们把这几个地址值提取出来，宏定义映射寄存器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

//stm32f4xx.h
/* 用来存放寄存器映射相关的代码 */
#define RCC_AHB1_ENR    *(unsigned int *)(0x40023800+0x30)
#define GPIOF_MODER     *(unsigned int *)(0x40021400+0)
#define GPIOF_ODR       *(unsigned int *)(0x40021400+0x14)

//main.c
#include "stm32f4xx.h"

int main(){
    //RCC
    RCC_AHB1_ENR|=(1<<5); 
    
    //Mode
    GPIOF_MODER&=~(3<<(6*2)); 
    GPIOF_MODER|=(1<<(6*2)); 
    
    
    GPIOF_ODR&=~(1<<6); 
    while(1){
		
	}
}

void SystemInit(){
	
}

点灯——流水灯闪烁

利用软件延时实现 RGB 流水灯闪烁。很简单，前面已经看了3个 LED 通道 PF678 了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include "stm32f4xx.h"

void delay_ms(int time);

int main(){
    //RCC
    RCC_AHB1_ENR|=(1<<5); 
    
    //Mode
    GPIOF_MODER&=~(3<<(6*2)); 
    GPIOF_MODER|=(1<<(6*2)); 
    GPIOF_MODER&=~(3<<(7*2)); 
    GPIOF_MODER|=(1<<(7*2)); 
    GPIOF_MODER&=~(3<<(8*2));   
    GPIOF_MODER|=(1<<(8*2)); 
    
    while(1){
        GPIOF_ODR|=(7<<6);
        GPIOF_ODR&=~(1<<6);
        delay_ms(1000);
        GPIOF_ODR|=(7<<6);
        GPIOF_ODR&=~(1<<7); 
        delay_ms(1000);
        GPIOF_ODR|=(7<<6);
        GPIOF_ODR&=~(1<<8);
        delay_ms(1000);
	}
}

void SystemInit(){
	
}

//毫秒级的延时
void delay_ms(int time)
{    
   int i=0;  
   while(time--)
   {
      i=4000;
      while(i--) ;    
   }
}

点灯——GPIO 具体功能框图对应

GPIO：通用输入输出引脚。我们可以通过编程来输出或者读取数据。大部分 GPIO 是已经连接、定义好了一些功能（比如上面尝试过的 PF6 LED），有的引脚有多个功能支持重新映射。

STM32 GPIO 除了 adc 是 3.3v，其他 GPIO 都是 5v 容忍。

GPIO 框图（重点）如下：

先从输出开始看。最右侧的 IO 引脚是连接在芯片周围一圈的144个引脚之一。除了 IO 引脚，此图中其他所有部分都是封装在芯片内部我们看不到的。

往左有两个保护二极管。当电压大于 5V，电流会往上 VDD_FT 走。当电压为负电压，电流会由 VSS 往 IO 引脚走。

上下拉电阻：比武外接一个低电平工作的设备，但是我们不希望一上电外设就工作，可以设置上拉电阻，稳定一段时间。

GPIO 输出的数据来源：复位寄存器 BSRR，或者 ODR 设置（图中的3下路部分）。复位寄存器高16位复位（写1置0）低16位置位（写1置1），置位优先级更高。

配置 GPIO 模式（输入/输出，选择哪一路）通过前面用过的 MODER 配置。

输出模式（图中输出控制部分）配置端口输出类型寄存器 OTYPER，比如推挽输出，开漏输出。

推挽输出：有直接驱动能力，输出0就是低电平，输出1就输出可以工作的高电平。原理是采用了一个放大的电路？

输入（INT）为高电平时，反向后 PMOS 导通，输出高电平。输入为低电平时，反向后 NMOS 导通，输出低电平。我们可以用一个小电流去驱动出来一个大电流。

开漏输出：自己本身没有输出高电平的手段。低电平可以接地，高电平没有 PMOS 管，是浮空状态。需要外接一个电阻。

stm32 输出 5V 电压的方法就是开漏输出外接电阻。通过接两个三极管的方式反向。

框图中的模拟部分输入输出则不用配置这些模式信息，直接由外设接到保护二极管再接到输出引脚。

框图中的输入部分经过保护电压后，还需要施密特触发器调整一下。比如原来电压的数值并非精确的0或 3.3V，施密特触发器将高于 1.8V 的全部视作1，低于的全部视作0后输入芯片。模拟部分则不需要经过施密特触发器。

因此配置 GPIO 输出的步骤如下：

1. GPIO 功能，通用输出、复用功能、模拟输入等 MODER；
2. 输出推挽 or 开漏 OTYPER；
3. 输出速度 OSPEEDR；
4. 上下拉电阻是否需要开启 PUPDR；
5. 具体输出内容 BSRR or ODR.

输入部分后面输入实验介绍~

按整个流程重新串一遍代码，如下：（其实和前面差不多，就是重新按照流程串了一遍）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/* 用来存放寄存器映射相关的代码 */
#define RCC_BASE    (unsigned int *)    0x40023800
#define GPIOF_BASE  (unsigned int *)    0x40021400
    
#define RCC_AHB1ENR         *(RCC_BASE+0x30)
    
#define GPIOF_MODER         *(GPIOF_BASE+0x00)
#define GPIOF_OSPEEDR       *(GPIOF_BASE+0x08)
#define GPIOF_PUPDR         *(GPIOF_BASE+0x0C)
#define GPIOF_ODR           *(GPIOF_BASE+0x14)
#define GPIOF_BSRR          *(GPIOF_BASE+0x18)

//main.c
#include "stm32f4xx.h"

int main()
{
    RCC_AHB1ENR |= (1<<5);
    GPIOF_MODER &= ~(3<<(6*2));
    GPIOF_MODER |= (1<<(6*2));
    while (1)
    {
    }
}

void SystemInit()
{
}

烧录前记得勾选：use MicroLib.

构建库方式

点灯——自己尝试构建库函数版

寄存器方法了解到这里就好，野火课程主要是库函数写代码。首先我们自己尝试构建一下库函数。

还是基于上次实验代码修改即可。首先对 .h 文件做一些修改：

1
2
3
4

#ifndef __STM32F4XX_H__
#define __STM32F4XX_H__

#endif

这个是防止多次引用头文件重复定义。

然后，像之前一条条定义太麻烦了。其实我们注意到每个寄存器都是4字节，我们可以用固定大小的结构体定义。比如 GPIO ABCDEF 结构都一样，我们只需要统一定义结构体和各自的基址即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include<stdint.h>	// 包含了 uint32_t uint16_t
/* GPIO寄存器列表 */
typedef struct
{
    uint32_t MODER;    /*GPIO模式寄存器						地址偏移: 0x00      */
    uint32_t OTYPER;   /*GPIO输出类型寄存器				地址偏移: 0x04      */
    uint32_t OSPEEDR;  /*GPIO输出速度寄存器				地址偏移: 0x08      */
    uint32_t PUPDR;    /*GPIO上拉/下拉寄存器			地址偏移: 0x0C      		*/
    uint32_t IDR;      /*GPIO输入数据寄存器				地址偏移: 0x10      		*/
    uint32_t ODR;      /*GPIO输出数据寄存器				地址偏移: 0x14      		*/
    uint16_t BSRRL;    /*GPIO置位/复位寄存器 低16位部分	地址偏移: 0x18 	*/
    uint16_t BSRRH;    /*GPIO置位/复位寄存器 高16位部分	地址偏移: 0x1A  */
    uint32_t LCKR;     /*GPIO配置锁定寄存器				地址偏移: 0x1C      */
    uint32_t AFR[2];   /*GPIO复用功能配置寄存器		地址偏移: 0x20-0x24 		*/
} GPIO_TypeDef;

# define GPIOF ((GPIO_TypeDef *)GPIOF_BASE)

main.c 中可以把对应寄存器替换为 GPIOF->寄存器名了。

然后我们直接对寄存器做操作，还是有点直接了，最好是我们不需要关注寄存器有哪些，直接调用一个 GPIO 设置函数即可使用，封装性可移植性都会好很多。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//stm32f4xx_gpio.c
void GPIO_SetBits(GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin){
    GPIOx->BSRRL=GPIO_Pin;
}

void GPIO_ResetBits(GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin){
    GPIOx->BSRRH=GPIO_Pin;
}

//stm32f4xx_gpio.h
#include "stm32f4xx.h"

#ifndef __STM32F4XX_GPIO_H__
#define __STM32F4XX_GPIO_H__

void GPIO_SetBits(GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin);
void GPIO_ResetBits(GPIO_TypeDef * GPIOx, uint16_t GPIO_Pin);

#endif

比如首先我们简单写了这样一个置位函数，使用方法为 GPIO_SetBits(GPIOF_Base,1<<6) .

以及我们可以在 stm32f4xx_gpio.h 里批量定义：

1
2
3

#define GPIO_Pin_6          (uint16_t)(1<<6)
#define GPIO_Pin_7          (uint16_t)(1<<7)
#define GPIO_Pin_8          (uint16_t)(1<<8)

这样 GPIO 使用用 Set Reset 函数已经非常规范了。那么初始化操作我们也可以封装成一个函数。

初始化需要设置 MODER PUPDR OSPEEDR OTYPER，我们可以定义一个结构体用于存储这些初始化变量，初始化的时候新建一个这样的结构体并赋值，传入初始化函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//stm32f4xx_gpio.h
//每个模块具体的值可以定义一个枚举类型。
typedef enum
{
    GPIO_Mode_IN=0x00;
    GPIO_Mode_OUT=0x01;
    GPIO_Mode_AF=0x02;
    GPIO_Mode_AN=0x03;
}GPIOMode_TypeDef;

typedef struct
{
    uint16_t GPIO_Pin;
    GPIOMode_TypeDef MODER;
    GPIOPuPd_TypeDef PUPDR;
    GPIOOType_TypeDef OTYPER;
    GPIOOSpeed_TypeDef OSPEEDR;
}GPIO_InitTypeDef;

具体使用的时候首先我们初始化一个 GPIO_InitTypeDef 变量，并且给其中的每一个子元素都赋值。然后传入 GPIO_Init 函数中，里面就是一系列根据手册而来的位操作，这里我感觉前面原理懂差不多就不用非跟着敲了。

分析 stm32 固件库函数

前面基本上都是了解固件库编程，从51过渡到 stm32. 后面所有固件编程固件库的使用方法都和前面的 GPIO 类似。

固件是什么？其实就是程序，固化到 EEPROM 或 FLASH 中，操作最底层的设备。不是具体的应用，而是只操作最底层的设备。比如点灯算应用，给应用工程师提供库函数的工作是固件工程师的。

stm32 官方 stmf4 固件库下载地址：

STM32标准外设软件库: 相关产品

1
2
3
4
5
6
7
8
9
10
11

$ ls
Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         2023/11/8     22:16                Libraries
d-----         2023/11/8     22:16                Project
d-----         2023/11/8     22:17                Utilities
d-----         2023/11/8     22:17                _htmresc
-ar---         2023/11/8     22:15          88007 Package_license.html
-ar---         2023/11/8     22:15          19611 Package_license.md
-ar---         2023/11/8     22:15         152599 Release_Notes.html
-ar---         2023/11/8     22:15       37185187 stm32f4xx_dsp_stdperiph_lib_um.chm

.chm：使用帮助文档。

.html .md：一些版本更新，包许可证相关信息。

Utilities：一些第三方其他软件。

Project：样例，模板。

Libraries：库，CMSIS 是一些 ARM 公司的标准，Driver 是固件。inc 是头文件，src 是c文件。

我们根据上节课写的项目来进行库函数文件功能分析。

1. startupxxxx.s：启动文件。
2. stm32f4xx.h：外设寄存器映射。
3. 跳到 system_Init 函数，这个函数当时我们为了执行只写了一个空函数，而 stm32 官方固件库模板里面是有的，在 system_stm32f4xx.c 里，初始化系统时钟。
4. stm32f4xx.c：具体外设驱动，比如上节课写的 gpio。
5. core_cm4.h：内核寄存器映射。
6. misc：中断。

构建库函数

创建一个通用的模板，后面写程序直接使用这个模板。

1
2
3
4
5
6
7
8
9

$ ls
Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         2023/11/8     23:27                Libraries
d-----         2023/11/8     23:27                Listing
d-----         2023/11/8     23:27                Output
d-----         2023/11/8     23:27                Project
d-----         2023/11/8     23:27                User
-a----         2020/2/27     13:45            401 keilkill.bat

前面都是新建的文件夹，keilkill.bat 是从 keil 编译程序中复制出来的一个脚本，可以删掉中间文件。

把固件库 Lib 里的 CMSIS 和 Driver 文件拷贝到 Libraries 文件夹中。CMSIS 中只保留 Device Include 文件夹。Device 中包含外设相关（比如 stm32f4xx.h system_stm32f4xx），Include 中只包含内核相关。

把 main.c stm32f4xx_it.c / stm32f4xx_it.h stm32f4xx_conf.h 拷贝到 User 文件夹中。

在 Project 文件夹里可以包含多给项目文件，不光只有 Keil 的。比如 IAR 的我们新建一个 IAR 文件夹，Keil 我们新建一个 RVMDK(uv5) 文件夹。RealView 是包含不止 MDK 的开发工具集合的称呼，MDK 是 MCU 开发工具集成包，uVersion 是 IDE，Keil 是公司名字。

uVision 里新建工程，新建在 RVMDK(uv5) 文件夹下。

新建组、添加文件如下：

STM32F4xx_StdPeriph_Driver 添加 STM32F4xx_StdPeriph_Driver/src 下的所有文件，屏蔽掉 dma2d fmc ltdc，后两个是 sd 和 lcd 屏幕组件。

头文件如下：

宏定义如下：

USE_STDPERIPH_DRIVER,STM32F40_41xxx

我现在好想明白为什么宏定义在这里了，这样后面换单片机型号的时候可以直接修改这个宏定义。

PS：我下载的是 1.8.1 版本 stm32f4xx.h 库函数，里面出现了一段重复定义导致编译产生了200多个 warning。我把下面那一段删掉了就好了。

Output 里设置 Output 文件夹，不然都在 Proj 里太乱。

记得勾选 MicroLib。

点灯——官方库函数版

在 User 文件夹中新建 LED 文件夹，里面新建 bsp_led.c，代表板级支持包 LED 代码，也就是只针对我们当前这一款开发板的点灯程序。

1. 设置时钟：rcc 时钟，在 stm32f4xx_rcc.c 中：

2. ```c
   /**

   • @brief Enables or disables the AHB1 peripheral clock.
   • @note After reset, the peripheral clock (used for registers read/write access)

   •     is disabled and the application software has to enable this clock before 
     

   •     using it.   
     

   • @param RCC_AHBPeriph: specifies the AHB1 peripheral to gates its clock.

   •      This parameter can be any combination of the following values:
     

   •        @arg RCC_AHB1Periph_GPIOA:       GPIOA clock
     

   •        @arg RCC_AHB1Periph_GPIOB:       GPIOB clock 
     

   •        @arg RCC_AHB1Periph_GPIOC:       GPIOC clock
     

   •        @arg RCC_AHB1Periph_GPIOD:       GPIOD clock
     

   •        @arg RCC_AHB1Periph_GPIOE:       GPIOE clock
     

   •        @arg RCC_AHB1Periph_GPIOF:       GPIOF clock
     

   •        @arg RCC_AHB1Periph_GPIOG:       GPIOG clock
     

   •        @arg RCC_AHB1Periph_GPIOG:       GPIOG clock
     

   •        @arg RCC_AHB1Periph_GPIOI:       GPIOI clock
     

   •        @arg RCC_AHB1Periph_GPIOJ:       GPIOJ clock (STM32F42xxx/43xxx devices) 
     

   •        @arg RCC_AHB1Periph_GPIOK:       GPIOK clock (STM32F42xxx/43xxx devices)  
     

   •        @arg RCC_AHB1Periph_CRC:         CRC clock
     

   •        @arg RCC_AHB1Periph_BKPSRAM:     BKPSRAM interface clock
     

   •        @arg RCC_AHB1Periph_CCMDATARAMEN CCM data RAM interface clock
     

   •        @arg RCC_AHB1Periph_DMA1:        DMA1 clock
     

   •        @arg RCC_AHB1Periph_DMA2:        DMA2 clock
     

   •        @arg RCC_AHB1Periph_DMA2D:       DMA2D clock (STM32F429xx/439xx devices)  
     

   •        @arg RCC_AHB1Periph_ETH_MAC:     Ethernet MAC clock
     

   •        @arg RCC_AHB1Periph_ETH_MAC_Tx:  Ethernet Transmission clock
     

   •        @arg RCC_AHB1Periph_ETH_MAC_Rx:  Ethernet Reception clock
     

   •        @arg RCC_AHB1Periph_ETH_MAC_PTP: Ethernet PTP clock
     

   •        @arg RCC_AHB1Periph_OTG_HS:      USB OTG HS clock
     

   •        @arg RCC_AHB1Periph_OTG_HS_ULPI: USB OTG HS ULPI clock
     

   • @param NewState: new state of the specified peripheral clock.

   •      This parameter can be: ENABLE or DISABLE.
     

   • @retval None
     */
     void RCC_AHB1PeriphClockCmd(uint32_t RCC_AHB1Periph, FunctionalState NewState)

     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

     其他部分基本也是参照库函数（主要是 stm32f4xx_gpio.h）最终呈现如下： ```c #include "bsp_led.h" void LED_GPIO_Config(void){ //RCC set function in stm32f4xx_rcc.h RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF,ENABLE); { //Init structure GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType=GPIO_OType_PP; GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6; GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP; GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //init function GPIO_Init(GPIOF,&GPIO_InitStructure); } }

   置位可以使用 GPIO_SetBits 或 GPIO_ResetBits。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   int main() { int i; LED_GPIO_Config(); *(unsigned int *)(0x40021400+0x14)&=~(1<<6); while (1) { GPIO_ResetBits(GPIOF,GPIO_Pin_6); i=12000000; while(i--); GPIO_SetBits(GPIOF,GPIO_Pin_6); i=12000000; while(i--); } }

   没有上下拉的时候推挽输出会直接被 ODR 值所影响，哪怕没有赋值其中本来的值也会影响。所以推挽输出无上下拉，不置位 LED 也会被点亮，因为 ODR 默认值0.

输入——按键点灯

开发板按键电路如下：

按键未按下接地，按下后为高电平。电容起到消抖作用，软件处理就不需要手动延时消抖了。

编程没啥难度，就是改了一下输入模式。使用 ReadInputDataBits 读取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//bsp_button.c
#include "bsp_button.h"

void Button_GPIO_Config(void){
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    {
        GPIO_InitTypeDef GPIOInitStruct;
        GPIOInitStruct.GPIO_Mode=GPIO_Mode_IN;
        GPIOInitStruct.GPIO_Pin=GPIO_Pin_0;
        GPIOInitStruct.GPIO_OType=GPIO_OType_PP;
        GPIOInitStruct.GPIO_Speed=GPIO_Speed_50MHz;
        GPIOInitStruct.GPIO_PuPd=GPIO_PuPd_NOPULL;
        
        GPIO_Init(GPIOA,&GPIOInitStruct);
    }
}

//main.c
#include "stm32f4xx.h"

#include "bsp_led.h"
#include "bsp_button.h"

int main()
{
    //RCC
    LED_GPIO_Config();
    Button_GPIO_Config();
    while (1)
    {
        if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0))GPIO_SetBits(GPIOF, GPIO_Pin_6);
        else GPIO_ResetBits(GPIOF, GPIO_Pin_6);
    }
}

实现按键按下后翻转：

1
2
3
4
5
6
7
8
9
10
11
12
13

int main()
{
    //RCC
    LED_GPIO_Config();
    Button_GPIO_Config();
    while (1)
    {
        if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)==Bit_SET){
            while(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_0)==Bit_SET);
            GPIO_ToggleBits(GPIOF, GPIO_Pin_6);
        }
    }
}

要等到按键松开的时候再翻转，轮询直到松开。

位带操作

之前51单片机常见位定义。比如 PA 引脚有8个 IO 口，我们可以定义 sbit LED1=PA^0 这样单独操作某一位。

stm32 里没有直接的位定义方式。一种解决办法是我们利用与或操作不影响其他位的同时操作特定位；另一种就是位带操作。

stm32 里有一部分别名区域，用于映射外设、SRAM 中特定的位带区，我们操作这一部分别名区域时就可以实现对外设、SRAM 位带区与的位操作。

片上外设位带区：0X4000 00000X400F 0000，别名区：0X4200 00000X43FF FFFF，包含 APB12，AHB1 外设。

SRAM 位带区：0X2000 00000X200F 0000，别名区：0X2200 00000X23FF FFFF

外设地址 A 别名地址为：AliasAddr= =0x42000000+ (A-0x40000000)84 +n*4 （n是位序号）

SRAM 地址 A 别名地址为：AliasAddr= =0x22000000+ (A-0x20000000)84 +n*4

扩大了32倍，可以对32位寄存器中的每一位进行操作。

统一公式：\#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x02000000+((addr & 0x000FFFFF)<<5)+(bitnum<<2))

使用：比如我们操作一个 GPIO 的位操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x02000000+((addr & 0x000FFFFF)<<5)+(bitnum<<2))
// 把一个地址转换成一个指针
#define MEM_ADDR(addr) *((volatile unsigned long *)(addr))
// 把位带别名区地址转换成指针
#define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum))

// GPIO ODR 和 IDR 寄存器地址映射
#define GPIOF_ODR_Addr (GPIOF_BASE+20)
#define GPIOF_IDR_Addr (GPIOF_BASE+16)

// 单独操作 GPIO 的某一个 IO 口，n(0,1,2...15),
// n 表示具体是哪一个 IO 口
#define PFout(n) BIT_ADDR(GPIOF_ODR_Addr,n) //输出
#define PFin(n) BIT_ADDR(GPIOF_IDR_Addr,n) //输入

//使用示例
PFout(6)= 0;

这个概念学学就好，好像实际应用没啥意义。我们微处理器考试也考过hh。

前言

最近电脑还是升级到 win11 了。我之前采用的美化方案是桌面上的图标全部移到 win10 开始菜单里的全屏菜单上，用磁贴贴一排。每次要访问文件的时候都去开始菜单里找，而不是放在桌面上，这样桌面也可以空出来欣赏壁纸。参考配置链接：如何让Windows 10系统桌面变得更好看？ - 知乎 (zhihu.com)

但是升级到 win11 对我而言影响最大的就是压根没有全屏桌面和磁贴功能了。因此我搜了很多解决方案，加上一些自己的改进，最终把桌面磁贴恢复成如上图所示。一个自己喜欢看的桌面还是会对生产力的提高有很大帮助的。

软件安装：start11

首先，恢复开始菜单这一操作最离不开的就是 start11 这款软件。他让 win11 的开始菜单又有了全屏菜单选项，也支持了自定义磁贴在上面。虽然调整磁贴位置的时候偶尔会花几秒重启，但大多数时候还是没问题的。

正版软件是免费试用的，欢迎付费支持原作者。或采用博主的同款方案：

链接：https://pan.baidu.com/s/1HY0WuV7ynlXdBI7qfuWZzg?pwd=1fru
提取码：1fru
–来自百度网盘超级会员V2的分享

start11 配置

首先如果是按博主的磁贴方法配置，就要选“win10配置”。或者你觉得其他风格也还不错都可以选。并且 ENABLE start11.

点击“配置菜单”，进行如下配置：

在“自定义菜单视觉外观”里，可以设置全屏菜单的颜色、透明度等，比如我使用的是有一定透明度的毛玻璃的样式。

然后在“控制”栏里设定如何打开 start11，确保可以打开：

接着，点击 win 图标就可以打开全屏菜单了。

磁贴配置

对于大部分软件，只要右键-固定到开始屏幕/固定到 start11，就可以在全屏菜单里看到刚刚贴上的磁贴了。

如果贴失败，可以尝试以下的方法：

• 右键快捷方式，点击“打开文件所在位置”，再尝试把该文件的 .exe 文件固定到开始屏幕。
• 反复尝试，因为可能有一定的延迟。可以取消固定再次固定，等待一会看开始菜单是否出现。

然后可以手动分组磁贴（把他们移到临近的位置），调整磁贴背景色，调整磁贴大小（有小正方形，中正方形，长方形，大正方形四种可以选择），调整磁贴布局位置。

图片磁贴配置

这里是最自由发挥的部分。高情商：自由发挥。低情商：都要自己做很麻烦。

之前 win10 是有一款快捷工具可以输入自定义图片，按自己想要的格式裁剪并自动在全屏菜单中输出的，叫 Tile Genie.

但是它好像并不能在 start11 中使用。我尝试了一下导出的都是不能显示的图片块，所以只能放弃这种方法。如果读者的 Tile Genie 是没有问题可以正常显示图片那再好不过了，后面的内容都可以不用看了。

如果导出失败……我采用的方法是手动裁剪固定图片。很笨，但是有结果。

首先，自行裁剪图片，计算公式为：中正方形 150*150，长方形 306*150，大正方形 306*306，边界线是6（像素）.

我采用的图像裁剪方法是：免费在线裁剪图像文件 (iloveimg.com)

然后把导出图片找一个合适的地方存储起来，注意贴上磁贴之后就不能再移动修改这些图片了。

在全屏菜单中右键-固定文件，选定文件路径添加。

刚固定上是这种形式：

然后右键-调整大小，调整为想要的大小。

最后一步，右键-图标-选择自定义磁贴图像，再次选择此文件，然后他就被当做图标全屏显示了。

学习官网参考：Compiling a New C/C++ Module to WebAssembly - WebAssembly | MDN (mozilla.org)

报错信息

形如：

1
2

Error: Downloading URL 'https://storage.googleapis.com/webassembly/emscripten-releases-builds/linux/b90507fcf011da61bacfca613569d882f7749552/wasm-binaries.tbz2': <urlopen error [Errno 104] Connection reset by peer>
error: installation failed!

OS：

1
2

$ uname -a
Linux jingqing 5.19.0-35-generic #36~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Feb 17 15:17:25 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

产生错误原因分析

emsdk install latest报错（因为从谷歌中下载，cmd中命令形式访问不到google）
版权声明：本文为CSDN博主「小白啥时候能进阶成功」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34754747/article/details/103815349

非常感谢博主的答疑解惑，不过我没有看得太懂原文中的解决方案，网上搜到的大多数方案也是 windows 环境下的解决方案，因此我决定自己写一个 ubuntu 系统下的补安装。

解决方案

说白了就是我自己复制链接到浏览器里，下载安装这几个包，放到 emsdk 的指定位置。

这里有两个要注意的点，这一部分主要是分析，不想看的同学可以直接跳到具体步骤处：

1. emsdk install 的默认安装规则是：不管你有没有安装过这些包，我 install latest 都是重新安装，保证最新版本。但是现在问题是 install latest 有问题，我要手动安装包放进去。
   我们打开 emsdk.py 通过搜索关键词可以找到报错信息的位置：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

   # ./emsdk.py:675 # On success, returns the filename on the disk pointing to the destination file that was produced # On failure, returns None. def download_file(url, dstpath, download_even_if_exists=False, filename_prefix=''): debug_print('download_file(url=' + url + ', dstpath=' + dstpath + ')') file_name = get_download_target(url, dstpath, filename_prefix) if os.path.exists(file_name) and not download_even_if_exists: print("File '" + file_name + "' already downloaded, skipping.") return file_name try: u = urlopen(url) mkdir_p(os.path.dirname(file_name)) with open(file_name, 'wb') as f: file_size = get_content_length(u) if file_size > 0: print("Downloading: %s from %s, %s Bytes" % (file_name, url, file_size)) else: print("Downloading: %s from %s" % (file_name, url)) file_size_dl = 0 # Draw a progress bar 80 chars wide (in non-TTY mode) progress_max = 80 - 4 progress_shown = 0 block_sz = 256 * 1024 if not TTY_OUTPUT: print(' [', end='') while True: buffer = u.read(block_sz) if not buffer: break file_size_dl += len(buffer) f.write(buffer) if file_size: percent = file_size_dl * 100.0 / file_size if TTY_OUTPUT: status = r" %10d [%3.02f%%]" % (file_size_dl, percent) print(status, end='\r') else: while progress_shown < progress_max * percent / 100: print('-', end='') sys.stdout.flush() progress_shown += 1 if not TTY_OUTPUT: print(']') sys.stdout.flush() except Exception as e: errlog("Error: Downloading URL '" + url + "': " + str(e)) if "SSL: CERTIFICATE_VERIFY_FAILED" in str(e) or "urlopen error unknown url type: https" in str(e): errlog("Warning: Possibly SSL/TLS issue. Update or install Python SSL root certificates (2048-bit or greater) supplied in Python folder or https://pypi.org/project/certifi/ and try again.") rmfile(file_name) return None except KeyboardInterrupt: rmfile(file_name) exit_with_error("aborted by user, exiting") return file_name

   大致一看能看明白逻辑，如果 download_even_if_exists = True 那么无论包是否已经存在都要安装，否则为 False 就只安装不存在的包，我们需要为 False。

   搜索函数名查看在哪里使用了这个函数：

   1 2 3

   # ./emsdk.py:1411 received_download_target = download_file(url, download_dir, not KEEP_DOWNLOADS, filename_prefix)

   这个 KEEP_DOWNLOADS 是一个环境变量，默认为0，我们需要他为1，传入函数的参数则为0（False），即已存在文件不再重复下载。

   在终端输入 ./emsdk --help 可以看到提示信息如下：

   1 2 3 4 5

   Environment: EMSDK_KEEP_DOWNLOADS=1 - if you want to keep the downloaded archives. EMSDK_NOTTY=1 - override isatty() result (mainly to log progress). EMSDK_NUM_CORES=n - limit parallelism to n cores. EMSDK_VERBOSE=1 - very verbose output, useful for debugging.

   也就是说只要安装时单独指定此变量值为1即可。

2. 第二步就是如何下载文件了。下载什么文件？放到哪个目录下？

   这里大家可以通过 download_file 的 print debug 调试来查看他校验文件是否存在是去哪里校验的，我就不再具体展开讲调试步骤了，结论就是：他在 emsdk/downloads/ 目录下先查找一下待下载的压缩包是否存在，那么我们复制报错信息中的 url 下载文件到这个 downloads 文件夹下即可（没有就新建）。

具体步骤

1. 首先要安装所缺的所有包，一个个安装，报错信息里提示什么安装什么。比如文章开头的报错信息中下载链接是：https://storage.googleapis.com/webassembly/emscripten-releases-builds/linux/b90507fcf011da61bacfca613569d882f7749552/wasm-binaries.tbz2，就先安装这个。

   node: https://storage.googleapis.com/webassembly/emscripten-releases-builds/linux/b90507fcf011da61bacfca613569d882f7749552/wasm-binaries.tbz2

   wasm-binaries: https://storage.googleapis.com/webassembly/emscripten-releases-builds/linux/b90507fcf011da61bacfca613569d882f7749552/wasm-binaries.tbz2

   安装完成后要重命名 b90507fcf011da61bacfca613569d882f7749552-wasm-binaries.tbz2。

2. 移入 emsdk/downloads 文件夹下，不用解压。

3. 执行 EMSDK_KEEP_DOWNLOADS=1 变量赋值。

4. 执行 ./emsdk install latest 。

1
2
3
4
5
6
7

jingqing3948@jingqing:~/Webassembly/emsdk$ ./emsdk install latest
Resolving SDK alias 'latest' to '3.1.44'
Resolving SDK version '3.1.44' to 'sdk-releases-b90507fcf011da61bacfca613569d882f7749552-64bit'
Installing SDK 'sdk-releases-b90507fcf011da61bacfca613569d882f7749552-64bit'..
Skipped installing node-16.20.0-64bit, already installed.
Skipped installing releases-b90507fcf011da61bacfca613569d882f7749552-64bit, already installed.
All SDK components already installed: 'sdk-releases-b90507fcf011da61bacfca613569d882f7749552-64bit'.

好哎，看来是自己单独安装的文件包都可以用，他会自己解压文件包后提示 All SDK components already installed。

接下来就是下一步：./emsdk activate latest.

最后是 source ./emsdk_env.sh 配置好环境变量。

[TOC]

主要围绕提纲里的所有问题展开，没有拓展内容，Exam oriented Study。

关注微信公众号：灰海宽松，回复 “RFID” 可获取本文pdf格式。

RFID

1. Introduction

Comparison of different automatic identification technologies

首先明确一下比较对象。human identification（cost too high）是人力识别就不用说了。

fingerprint identification:

• stability 稳定，精确度高；
• high speed, 快速匹配；
• security issues: 容易被复制。

face recognition:

• easy to be influenced by surroundings, hair, age…

speech recognition:

• easy to use and accept by user;
• not involve privacy;
• due to international standards, is hard to promoting

1d barcode:

• limit storage capacity, 点线组合少;
• need to combine with database;
• barcode size is large;
• poor fault tolerance, 本来就需要摄像头可见，如果被污损遮挡很容易就无法识别;

2d barcode recognition:

• larger storage capacity;
• high information density;
• powerful fault tolerance;
• support for encryption 容量大了就支持更多编码解码等安全措施了。

rfid：

• low cost;
• low power consumption;
• high accuracy;
• non-contract, fast speed; 不用接触（哪怕是visual，薄纱条码）
• certain computing and storage capabilities;

主要考虑各个的缺点，人脸和声音特征点多速度慢，而且人脸容易被影响，声音由于国际标准技术难以提升；条码需要视觉可见；指纹容易被盗取。

The main features of RFID

• Non-contact automatic and rapid identification 快速薄纱复杂的人脸和声音，无接触薄纱条码和指纹

• Permanently store a certain amount of data 永久存储一定量数据

• Simple logical processing 其包含的简单逻辑电路允许做一定的逻辑处理，比如安全协议、算法

• Reflection signal strength is affected by the distance and other factors significantly 信号受到距离，读写器功率，其他信号，其他标签的干扰

• Low cost, can be deployed at a large scale

Constraints of RFID technology

Core technologies of RFID

Anti-collision mechanism：rfid并不支持传统的cmsa/ca无线通信协议，需要采取一些措施防碰撞（reader-reader, tag-reader, tag-tag)

Efficient information storage, retrieval and mining: 尽量节能的信息存储，检索，挖掘

Make full use of the attenuation laws of backscatter signal to assist in positioning and mobile behavior sensing: 我们知道rfid信号会随着距离衰减。反之我们也可以利用这一点来定位物体位置和移动行为感知。

Security certification and privacy protection: 如何利用逻辑门电路校验安全性。

The advantage of RFID in IoT, and the development trend

充电方式：Backscatter, small node and indefinitely time of endurance. but rely on reader, one to many centralized communication 利用无线电 ratio signal 充电的方式

ptp communication: 建立 channel awareness technologies 使得支持被动点对点通信来建立分布式系统

Combine with Sensors: 开发更多应用方式。

RFID and IoT:

• embed intelligence in the physical object, so that simple physical objects can also “say”.
• allows a physical object to be uniquely identified in a way similar to the “IP address” of a computing node in the Internet.
• provides a low-cost communication way to achieve effective communication between nodes.
• makes the physical objects in a passive environment achieve “passive intelligence“, providing fundamental guarantee for the “thing-thing connection”

2. Identification

简单说RFID就是物体上贴tag，用reader上的antenna去读取，这三个是主要组成。

Reader’s function

Energy supply: 比如有的标签自身不带能量需要reader提供信号中蕴含的能量

Communication: 最基本的功能，和tag识别，通信

Security Assurance: 比如加密解密

扩展功能：比如自组网 ad-hoc, 管理天线 antenna management 中间件接口 interface of middle components 连接外设 connecting peripherals

Reader’s classification

按频率：LF HF算低频，UHF和SHF算高频（ultra super)，高频数据传输速度快，距离远，但是衰减快 signal attenuation，收到障碍物影响大 sensitive to obstacles。

按外观：

• Fixed 固定有线的，高度集成，快速启动 set up
• portable 可移动的像手持手机一样，small, charging battery, easy to move
• Industrial 为工厂目的而生，比如集成其他 sensor

Influencing factors of R&W range

许多东西都有说明书，规范，来提醒我们怎么不把东西玩坏比如手机提示不要放水里玩。

RFID的R&W range是其中一种。影响因素如下：

• The way that antenna is coupled 天线耦合方式，比如把两个天线绑一起太近互相干扰。

• The output power of the reader’s RF signal 功率，太低可能无法激发tags

• The frequency of RF carrier signal 合适的频率

• Antenna direction 天线，读取器天线和标签天线极性方向 polarization 相匹配时识别范围最大

• Operation environment condition

• Movement speed of tags

Reader’s components and their functions

Signal Processing and Control Module: 主要是控制功能，协调一些本地计算

• Communicate with upper computer, and execute command from it
• Control communication process with tags
• Encode and decode signal
• Perform anti-collision algorithm
• Encrypt and decrypt the data transferred between reader and tag
• Identity certification between reader and tag

Inductively Coupled RF Module: 主要是产生能量和调制发送信号功能

• Generate high frequency send energy, activate RF tags and provide energy (passive RF tags)
• Modulate signal to sent, transferring data to RF tags
• Receive and demodulate RF signal from RF tags.

Tag’s functions

• data storage
• energy harvesting 吸收能量，与reader的 energy supply 对应
• contactless with R&W 不用接触就能通信，与 reader 的 communication with tags 对应
• Security Encryption 与 reader 的 Security Assurance 对应
• Collision Concessions 碰撞让步

Tag classification: by package form, by power source, by work frequency, by R&W capability

Package form 也就是外观上的分类：

• card-like
• label-like
• Implantable, 比如动物植物体内
• Accessories-like 附件类标签，比如纽扣型的，这一类主要是方便携带

By Power Source 按能源供应方式分类：

• active 自己有电池供电
• passive 依靠 carrier signal 读取器发来的载波信号获取能量
• semi-passive 有电池作为后备隐藏能源，平时主要是passive 方式

By Work Frequency

LF HF UHF。UHF读写性能，距离最好，更多会使用 active 型。

By R&W Capability

read-only 和 R&W 两种，结构复杂度也有所不同

Two work modes of RFID middleware

interactive, independent。

交互模式大概就是一直接收主机的命令，你让我读我就读，读完把结果还给你。

独立模式是可以不接收主机命令自行按预设的程序和读取到的结果信息循环执行指令，并将结果返回给主机。

3. Wireless Communication Principle of RFID

Different work principles of different carrier frequency

不同频率载波也适用不同的工作原则。

前面已经有所涉及，比如LF HF适用于近距离，UHF SHF适合远距离。

前者适用 Inductively Coupled RF Module 电感耦合，通过感应方式获取能量。

后者适用 Electromagnetic Backscatter Coupled RF Module 电磁反向散射耦合，持续不断发送射频信号来供给能量。backscatter 指的是接收机信号调制后通过发送机天线产生可被识别的信号。

两者的能量消耗都和距离平方成正比 squared distance

Signal voltage and energy: dB, dBm，重点：如何计算

变化的电压通常用 $V(t)=v_0cos(\omega t)$ 表示。

功率P=VI=V^2/R这不用多说。平均功率 $=\frac{v_0^2}{2R}$ 很简单推因为正余弦平均就是/根2.

相对变化 The relative change，这是一个比较新鲜的而且信号变化中比较重要的指标。

$G_{dB}=10log_{10}\frac{P2}{P1}$

参考功率 referenced power $dBm=10log_{10}\frac{P}{10^{-3}}$

dBm单位是功率的W，GdB单位是dB，代表一个比值。

Modulation of reader signal: OOK and its problem, solution: PIE; Tag encoding: FM0

一些阅读器通过调制使得正弦电压信号携带信息的方法。

OOK：on off keying，高功率1低功率0.

问题在于，低功率0的部分标签没法被激活，也无法正常工作。也就是说0信号标签压根启动不了，没法接收0信号。

PIE解决方法：长高功率是1，短高功率是0.

然后涉及到tags对reader发来的信号进行解码。空间中的信号发过来是有方向的矢量叠加，tags如何通过编码机制识别信号？

FM0编码方式：位窗起始处翻转信号表示1，中间翻转表示0.

FM0属于 FSK frequent shift key 通过信号变化频率来识别的机制。

Link budget (重点)

Link budget: forward link budget and backward link budget 发射过程中能量增减的总和

reader transmit energy(+) path loss(-) tag activate energy(-)

• pass loss: 读取器天线向360度的发送能量。其中只有一部分区域可以被tags antenna读取到，这一部分被称作 Effective Aperture (Ae) of the tag antenna。能量=有效面积*密度 $P_t=\rho A_e$ 。总共发送的能量比收到的能量就等于总表面积比有效面积 $\frac{P_{TX}}{P_{RX}}=\frac{A_e}{4\pi r^2}$

来看上例，发送方30dBm对应1W，tag接收到-10dBm对应10^-4W. 然后5dB的衰减到-15dBm。这个5dB衰减就是两个dBm做差得到的。

所以，dBm相当于对功率P的另一种衡量方式，为什么这么麻烦的要用log来表示？因为两个dBm的差值就是分贝（放大系数），所以由一个dBm能量转到另一个只需要加减两者间差的分贝即可，很方便。

从tags反射回来的信号 reflection link 和路径四次方成反比 inversely proportional. $P_{RX,back}:\frac{1}{r^4}$

Antenna gain and polarization, EIRP

antenna gain: 输入条件相同情况下，实际情况某一点能量密度/理想条件下的密度单元。反应了天线 concentrates the input power 的能力。就比如把阅读器放中间，标签围一圈，360度去读取周围标签对能量消耗就大，可能因此传输距离也近；但是如果把标签集中放在一块区域，周围放置的 reader 利用定向天线 Directional antenna，固定读取某一个角度范围内的tags能量利用效率就高。

Polarization：事物在一定条件下发生极化 polarization，使得其表现的和原有状态不一样 its properties deviate from the original state。

EIRP, Equivalent Isotropic Radiated Power: 天线在所指方向上获得最大增益效果 maximum gain effect 所需要的能量。

For example, FCC regulations in the United States, a non-irradiated transmitter can transmit 1W of energy signals, and can use 6dBi antenna; antenna gain increased by 1dB, transmission energy needs to be reduced by 1dB. In fact, FCC is not more than 36dBm(30dBm+6dBi).

Effects of antenna gain，重点：分析 link budget，几个计算公式

directional gain: radiation density of one direction d / average value in all direction

power gain: radiation efficiency of that direction G

平面角：单位rad，比如圆周180度单位角=2pi rad

立体角：单位sr，比如球面立体角=4pi sr

能量增益G的计算方法是4pi/立体角大小。比如波束宽度72°也就是2pi/5大概是1.25rad， $G=\frac{4\pi}{1.25^2}$

dipole antenna: 垂直于轴沿各个方向发送信号，比全向天线 omnidirectional antenna 小2.2dB。

Effective aperture $A=G\frac{\lambda ^2}{4\pi}$

$P_{RX}=P_{TX}G_{RX}G_{TX}(\frac{\lambda}{4\pi r})^2$

$R_{forward}=\frac{\lambda}{4\pi}\sqrt{\frac{P_{TX,reader}T_bG_{reader}G_{tag}}{P_{min,tag}}}$

$R_{reverse}=\frac{\lambda}{4\pi}\sqrt[4]{\frac{P_{TX,reader}T_bG_{reader}^2G_{tag}^2}{P_{min,reader}}}$

4. Tag Identification Protocol

Checksum procedure: parity checks, LRC, CRC

奇偶校验不多说，查1的个数，poor error recognition。电路通过所有位异或是偶校验，结果为1说明有错误；再取反是奇校验。

LRC longitudinal redundancy check (LRC) procedure 循环冗余检测，所有字节进行异或运算，得到的结果是LRC校验码。也就是说数据发送到终点后，所有字节（数据和LRC）进行字节异或运算结果应该为0. 也有一些错误无法纠正，主要用于小的数据块校验。

CRC (cyclic redundancy check) procedure

接收方计算原数据+CRC数据拼接起来的CRC数据值，应该为0. 不能纠错，不过检错效率很高。

ASK, FSK, PSK

amplitude Shift Keying: 幅度调制，y轴上的调制。

计算方法2：duty factor: $m=1-\frac{u_1}{u_0}$

$U_{ASK}(t) =(m·u_{code}(t)+1−m)·u_{HF}(t)$

Frequency shift keying: 频率上的改变。

Phase shift keying: 频率相位翻转180.

Difficulty of traditional anti-collision algorithms for solving collision detection between RFID tags

Compared with the reader, limited by hardware resources, tags have very limited storage capacity and computing.

标签受制于硬件资源，存储容量和计算能力都不高。

TDMA, FDMA, CSMA

首先主要有两种方式，一个是reader broadcast 广播到诸多 tags，一个是多个 tags Multi-access 每个tags单独访问reader。

TDMA FDMA是multi-access, CSMA是broadcast

FDMA: 多个频率通道 several frequency channels 传输数据。

TDMA:

ALOHA based protocols: pure ALOHA, S-ALOHA, FSA, DFSA, Q 算法。重点：性能分析、执行过程

Pure ALOHA algorithm：收到成功确认 ack 后就不再发送。否则一直随机等待后继续发送。简单但是通道利用率 channel utilization 低，poor performance.

offered load G：单位时间 tau 里同时发送的应答器数量

s-aloha: 规定时间片 slot，一个时间片只能发一次，冲突就下一次时间片去发。channel utilization 几乎是 pure 的两倍。

$S = G × e^{-G}$ G=1最大

frame S-ALOHA: 规定一个周期 frame，包含若干个 slots，会更加有组织有秩序。reader 广播一个 frame length，tags 自己选择组织时间片（0~f-1），每个时间片开始 reader 轮询一下tag里sn信号是不是0，是0就发送，不是0就-1.

conflict slot, single slot, idle slot（空）

逻辑，电路设计，内存都比较简单，但是 frame length 长度不固定。tags 远远多于 frame length 冲突时间片就太多，tags 太少空时间片太多太浪费。负载 G=1 也就是 length=tags 利用率最好。

DFSA：利用以前的 frame 冲突反馈结果，和一些机器学习算法推测合适的 frame length。

EPC Global（第五章介绍）规范里使用了一种Q算法。简单说就是如果冲突太多了，当前 frame 就别继续了，中断，新开一个大容量 frame. 同理 空闲太多了就新开一个小 frame。

Qfp是指定的初始值。每次先取整，然后发起 query。

没有回复：Qfp-C C是一个参数，比如0.1.

有冲突>1：+C。注意有上下限。

ALOHA 算法公平。但是可能发生饥饿 ，比如有一个 tag 每次都是有冲突的 slot，一直没有办法被处理。

Binary tree based protocols: BT, QT, 重点：执行过程

第二种算法，基于二进制数。就像二叉树不断拆分冲突的结点变为两个结点，直到节点里只有一个 tag。

random binary tree BT：随机。

binary query tree QT：排序，查询。

每一个 tag 需要有一个计数器来记录自己的状态。

每一个tag都会被识别，不会饥饿，但是需要存储每个tag的状态。

比如看下面的例子：

首先 tag1234 随机选一个数，比如选了0010，SN分别加自己选的数。

找SN=0的，发现有是有，但是他们几个都冲突了。那么继续分，比如1011，SN=1021

2的SN=0而且不冲突，把2读取了之后2不再继续参与。然后当有tag读取后，所有其他SN-=1

=0的是14，但是他俩冲突。然后再重新划分一下，比如011, SN=0021

然后处理1，其他-=1，处理4，其他-=1，处理3.

QT 不需要存储状态，如何实现？读取tag的序列号比较。

不会饿死，也不需要一个可以读写的cnt，识别的时间和 tag id 有关。

Binary search: Manchester code instead of NRZ code, 重点：执行过程

具体分辨哪一位有冲突。1代表冲突。

NRZ混合没法检测错误。

曼彻斯特可以，一个上升一个下降，合起来是0或者1.

查询的流程：

• request：发送一个序列号给tags的transponder，如果tags的序列号小于给定序列号返回。
• select：给定一个特定序列号，返回等序列号的tag。
• read_data：返回所选tag的信息。
• unselect：读取完data了，这个tag退出选择流程。

第一次迭代：返回uplink是所有transponder的id的共同信息（通过曼彻斯特编码找出没有冲突的位）。046位冲突了（从右往左），8个可能。

第二次迭代：限定 bit6 为0的request。发现有3个还是冲突04位（最高位冲突位=0，其他冲突位=1，如果range是大于等于，则正好相反）。

第三次迭代：限定bit4为0的request……

长度 L(N)=log2(N)+1

Dynamic binary search, 重点：执行过程

Binary Search 是每次都传输完整二进制字符串. 其实我们只需要动态改变的部分.

比如我们查询1010 1111 1111, 那返回值前面一定是1010呀, 就不用传输了. 前缀叫 NVB, Number of Valid Bits

每次请求发送的信息: Request+NVB=4+1010

Advantages and disadvantages of ALOHA based anti-collision algorithm

simple

good identification performance

results can be statistically analyzed 结果可以被统计化分析

缺点就是可能 starvation 饥饿，delay trend to ∞

Advantages and disadvantages of binary tree based anti-collision algorithm

simple

intermediate state variables 不需要存储中间状态变量（QT）

缺点：查询时间受到 tags id 和 长度限制，比如二叉树沿着一个方向一直偏。

5. EPCglobal Standard & protocol

Concept of EPC global network

EPCglobal Network: a technology that

• allows trading partners to document and determine the location of individual goods
• if possible in real time
• additional information: such as 生产使用日期，能否被贸易伙伴交换

Five basic services of EPC global network, interaction of different components of EPCglobal network

Electronic product code (EPC)

The identification system

EPCglobal Middleware

Discovery Service (DS)

EPC Information Services (EPCIS)

EPC码是唯一标识对象的代码。识别系统包括对象上的可被读取的包含EPC码的transponder和读取器reader可以识别EPC，然后通过EPCglobal Middleware传到网上，通过DS在 EPCglobal network 查找EPC码的相关信息（包括object naming service）。可以通过EPCIS和其他贸易伙伴交换EPC相关信息。

这其中的交互：

transponder and reader : data acquisition

Middleware

Discovery services

EPC Information Services : access to EPC-related data

EPC code 组成

Domain Manager Number + Object Class Number + Serial Number

Basic procedures of the EPC Network

EPC码用于标识对应对象

all information about the object 在EPCGlobal Network里注册 administer

each company in the EPCglobal Network: 各个公司管理数据集和数据对象

access rights to object data: 包含在EPCIS里，指明了trading partners 之间访问权限

1. the manufacturer：把transponder和product绑定

2. all data assigned to the product：在EPCIS里

3. EPCIS registers the entries with EPC Discovery Services：注册了DS之后方能找得到EPCIS

4. product：卖给零售商 retailer

5. At the retailer’s goods-in point 数据存储在零售商EPCIS中

6. registered by EPCIS with EPC Discovery Services

7. The company prefix send to root EPCIS

8. root -> local -> the EPCIS

Binary tree based variant algorithm for EPCglobal Class 0

这种tag是只读的，制造商赋值。

EPCglobal C1 G1: PingID; C1G2: four commands (是什么，分别干什么用的), two types of performance trade-offs

EPC C1G1：查询tags EPC的一种标准。

被动标签，支持kill和lock两种操作。

pingID：掩码，用于查询tag EPC

EPC C1G2 有 OSI 的七层模型，两条数据链路（R-T）

上电 ready

发 query 命令，aribtrate 仲裁。选择随机数生成时间片。

slot=0 的开始 reply

tag 发 ack 给 reader，acknowledged 状态。

tag 收到 reader 的命令后进入 open，校验后进入 secured，完成 killed。

4个识别 tags 的命令：Select command, Query command, QueryRep command, QueryAdjust command

select 指明要查哪些 tags 的集合。

query 启动新的识别过程。

Rep 开启下一轮 slot 查询，标签 SN–，到0时读取。

Adjust 调整时隙数，选择新的时隙计数器等。

两大性能问题：

• Build a set of tags involved in the recognition process，如何建立正确的tags集合来查询（select 和 query 负责）
• Select the way of data encoding, for the readerto-tag, the tag-to-reader, the reader itself and the tag itself 根据环境调整编码方式

[TOC]

主要围绕提纲里的所有问题展开，没有拓展内容，Exam oriented Study。

关注微信公众号：灰海宽松，回复 “微处理器” 可获取本文pdf格式。

Introduction-随便聊

嵌入式系统是什么？专用的计算机系统。为专门功能可能对计算机架构，外设等做出一些取舍。

通常的限制：Cost（比如大量部署传感器节点），Size and weight limits（特定应用场景，比如下水道流量检测系统，需要体积小的节点），Power and energy limits（比如部署在极端环境下，喜马拉雅山顶采集节点，不方便去充电），Environment（防水，防高温等）

MCU MPU两种嵌入式系统区别：focus on 控制 还是 处理。控制比如点灯，机械臂，电机这些都是。处理比如摄像头采集到的数据进行图像处理。

编程语言：靠近计算机底层，主要使用汇编和c。

OS：嵌入式系统里不一定有操作系统结构。操作系统这个东西说白了就是更好地帮助管理计算机资源调度用的。现在我们来分析一下我们lab2的代码主函数：

1
2
3
4
5
6
7
8
9
10

void main(){
    //background
    while(1){
        
    }
}

void IRQ_Handler(){
    //interrupt handler function, frontground
}

后台部分：一个循环，重复去执行要做的任务。

这种方法乍一看也没啥问题。但是想想这样的计算机能做什么，只能按顺序执行一遍又一遍所有任务，甚至没法变顺序。

前台部分：中断处理，我们lab2里的uart_rx_isr函数，一般也用IRQ_Handler（实际上如果对lab2里的uart_rx_isr溯源一下，就会发现其实他也是被IRQ_Handler调用的，这个方法在启动对应中断时，触发中断就会自动调用）。

前后台合起来的系统还是一个裸机无os系统，只不过加了中断之后允许我们用中断的任务去打断后台轮询，改变一下执行顺序。比如串口中断发个数过来，CPU把手头后台的事情放下，去处理一下前台中断，处理完了再回来。

我们课程仅限于裸机开发的内容。

计算机系统简要介绍

Von Neumann Architecture

运算器控制器 (合在CPU中) 存储器 main memory 输入设备输出设备 IO，以及三条传输总线：数据，控制，地址 data bus / control bus / address bus.

前面介绍过MPU重点在于数据计算处理，MCU则是控制，因此MPU不需要一些外设去控制外接的组件。

Harvard Architecture

和冯诺依曼区别就是在于指令和数据分开存储。这样寻指取指取数效率高。

Stored Program Concept

主要两个部分：RAM存储程序和数据，ROM存储不变只读的程序和数据。

cpu执行指令就是三个步骤的重复执行：fetch decode execute 取指解码执行

assembly

如果高级语言相当于人话翻译给计算机，汇编语言相当于计算机语言翻译给我们。更贴近底层，因此运行效率也更高，而且可以直接操作硬件。

1
2
3

ADD r3, r1, r2 	;r3 = r1 + r2
SUB r3, r0, r3 
MOV r2, r1 		;r2 = r1

; 是注释。变量r123是寄存器register，是可以操纵硬件的部分，我们可以通过对其赋值来操作硬件。

高级语言通过 compiler 翻译为汇编语言，汇编语言通过 assembler翻译为二进制机器语言。

ARM架构

ARM是一个指令集，前面讲的几个汇编指令这些都算做指令。

ARM公司有意思的地方是，他们不做ARM设备，他们只设计指令集架构，然后授权（知识产权核，IP核）给其他半导体厂商做。

A：application，主打高性能，手机电脑有许多就是ARM架构的。

R：realtime，主打实时，比如车联网对实时性要求很高。

M：microcontroller，应用于小型嵌入式系统，我们使用的板子。

m系列有m0到m7（简单说就是性能逐渐增加？），而且向下兼容即m7兼容m0~m6.

SoC

我们的板子上有一个黑色的小芯片，上面写着stm32blabla一串字符。这个就是整个板子的核心，相当于囊括了上文提到的计算机架构的芯片结构，system on chips。

设计soc规则：首先选用IP核，设计ARM处理器，外加一系列存储、IO外设结构，全部集成在黑芯片上。

ARM处理器 processor 是 architecture 的具体涵盖，多了很多新内容比如定时器。

我们主要学习m4架构。

只看非optional大概了解即可，处理器核访问代码，数据接口。

register

前面我们已经简单介绍了register。事实上如果想对内存中数据做处理，也要先拿到处理器核中的寄存器里做运算，然后返回回去。

arm register 如下：

通用寄存器：临时变量，可以存储计算数据之类的。

SP：栈顶指针寄存器，指向栈顶。

LR：函数返回用，保存返回地址。比如要调用函数了，把PC的值存入LR，然后PC跳转到函数起始位置；函数返回的时候LR的值还给PC。

PC：指向程序当前执行到的位置（下一个要执行的指令的地址）程序计数器。每条指令取了之后PC自动加一条指令，比如32位指令集PC+=4B。

PSR系列是状态寄存器，指明当前程序状态。比如当前是用户模式还是内核模式？IPSR指明当前是否允许中断？等。

xPSR包括：

• APSR：计算用，如标志是否进位，结果是否为0，是否为负，是否溢出等。
• IPSR：中断处理相关。
• EPSR：执行相关，指明指令集，中断是否继续等信息。

Memory Map

m4有4g的内存空间默认映射到一片空间中，用户也可以根据自己喜好修改。有存储代码的code region，存储数据的sram region，存储外设的peripheral region，external ram region，external device region，Internal Private Peripheral Bus (PPB)。

Bit-band Operations

位带操作。

如果我们要读写32位数据中的某一位，比如第三位（从左往右是31:0，第三位是右边第4个），有的寄存器允许我们直接获取r[3]，但是大多数是不允许直接获取的。

如何处理？如果写入1，那么r|0000 0000 0000 0000 0000 0000 0000 1000.

如果写入0，那么 r & 1111 1111 1111 1111 1111 1111 1111 0111.

读取：看 r & 0000 0000 0000 0000 0000 0000 0000 1000 结果是否为0.

这样很麻烦，比如我们要给0x2000 0000处的数据第3位写1，详细汇编代码：

LDR是把后面的数据加载到前面的寄存器中，[R1]是把R1的值当做一个地址，取得其中存储的数据。

这样挺麻烦的，但是因为有内存映射我们可以直接写入和获取“位带别名地址”中的数据。

0x2000 0000处的第0位到第31位分别是：

0x2200 0000

0x2200 0004

0x2200 0008

0x2200 000c……

0x2200 007c

所以直接获取，修改0x2200 000c的数据即可。

0x2000 0000映射到0x2200 0000是 sram 区域映射，0x4000 0000映射到0x4200 0000是外设 peripheral 区域映射。

操作更快，指令更少，而且只访问一位更安全，比如刚取出0x2000 0000的32位数据，这时候中断修改了0x2000 0000的数据，这时我们取得的数据就是旧的错误数据了，修改完第3位再写回去，相当于中断白改了。

Program Image

vector：向量表，存储比如main堆栈的地址（MSP），异常的地址等信息。

start-up：板子上电或rst时的启动代码。

program code：我们烧进去的程序代码。

c lib code：库函数代码。

复位时，先读取 msp 地址找到 main 在哪。然后读取 reset vector 执行 BIOS 初始化代码，再开始读取第一条，第二条指令……

Endianness

两种存储规范。

比如十进制数字，1234，一千二百三十四。然后我们记录到数据库中，地址从低到高存储为4321，权值大的位1存在地址最高处，这就是大端存储 Big endian。否则，权值大的位存在地址低处，1234地址从低到高，就是小端存储 Little endian。m4两种方法都支持。

术语“little endian(小端)”和“big endian(大端)”出自Jonathan Swift的《格列佛游记》（Gulliver’s Trabels）一书，其中交战的两个派别无法就应该从哪一端（小端还是大端）打开一个半熟的鸡蛋达成一致。

一下是Jonathan Swift在1726年关于大小端之争历史的描述：

“……下面要告诉你的是，Lilliput和Blefuscu这两大强国在过去36个月里一直在苦战。战争开始是由于以下的原因：我们大家都认为，吃鸡蛋前，原始的方法是打破鸡蛋较大的一端，可是当今皇帝的祖父小时候吃鸡蛋，一次按古法打鸡蛋是碰巧将一个手指弄破了，因此他的父亲，当时的皇帝，就下了一道敕令，命令全体臣民吃鸡蛋时打破鸡蛋较小的一端，违令者重罚。老百姓们对这项命令极为反感。历史告诉我们，由此曾发生过六次叛乱，其中一个皇帝送了命，另一个丢了王位。这些叛乱大多都是由Blefuscu的国王大臣们煽动起来的。叛乱平息后，流亡的人总是逃到那个帝国去寻救避难。据估计，先后几次有11000人情愿受死也不肯去打破鸡蛋较小的一端。关于这一争端，曾出版过几百本大部著作，不过大端派的书一直是受禁的，法律也规定该派的任何人不得做官。”（此段译文摘自网上蒋剑锋译的 《格列佛游记》第一卷第4章。）

在他那个时代，Swift是在讽刺英国（Lilliput）和法国（Blefuscu）之间的持续的冲突。Danny Cohen，一位网络协议的早期开创者，第一次使用这两个术语来指代字节顺序，后来这个术语被广泛接纳了.

大端、小端基础知识 - 知乎 (zhihu.com)

Instruction Set

指令集。早期arm指令集32位，性能好能实现的功能强大。但是太长了处理效率低。

thumb-1 指令集16位，处理效率高了，性能也降了。早期arm架构如果是支持两种指令集的，就要频繁切换模式，效率低。

后来thumb-2指令集包含早期16位和新的32位，和arm指令集的混合指令集性能没减太多，代码量和处理效率还高了。

Assembly

汇编语法。

顺序结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

label							; 可省略，用于跳转到此位置
	助记符 operand1, operand2, … ; Comments
	
MOV r1, #0x01					; 数据0x01放入r1
MOV r1, #'A'					; 数据A的ascii码放入r1
MOV R0, R1 						; move R1 into R0
MOVS R0, R1 					; move R1 into R0, 并且更新APSR的状态

LDR R1, [R0]					; R0存的是一个地址值如0x2000 0000, 这个指令是取出R0代表的地址中的数据存入R1
STR R1, [R0]					; 写回去
LDR R0, =0x12345678 			; Set R0 to 0x12345678
; 等效于：
; LDR R0, [PC, #offset] 
; ...
; DCD 0x12345678
; 也就是先在文档末尾的一条指令里写入数据0x12345678，然后编译器自动计算PC+多少offset到达DCD的位置，把其值返给R0
; DCD是声明一个字 32bit，DCB是声明一个Byte
; 如果多个数值的声明可以用标签声明
LDR R3, =MY_NUMBER

ALIGN 4 ; 字要先用这个声明，代表停止长度
MY_NUMBER DCD 0x2000ABCC
HELLO_TEXT DCB “Hello\n”, 0 ; Null terminated string


LDRB R1, [R0]					; B: 只写8位，就是说R0地址处的数据写入R1后，R1高24位清零
SDRH R1, [R0]					; H: 只写16位

LDRSH R1, [R0]					; 视作signed有符号数，写16位

LDRB R0, [R1, #0x3]				; 从R1+3读取一个字节给R0
LDR R3, [R0, R2, LSL #2]		; 从R0+（R2<<2)读取一个字节给R3
LDR R0, [R1], #4				; 赋完值后，令R1=R1+4

ADD R0, R0, R1
ADDS R0, R0, R1					; 加完更新APSR状态，比如有溢出或者进位则更新
ADC R0, R1, R2					; R1+R2还要+APSR的carry位

; SUB SBC类似

MUL R0, R1, R2
UDIV R0, R1, R2
SDIV R0, R1, R2					; signed

例题：应该是因为有可能减成负的所以signed

指令有1字长，半字长的。hw1是指明功能用的，hw2是一些拓展比如立即数。

地址从低到高分别是：4F F0 0A 00 0A 68 10 44……

PC每次取到半个字 hw，就+2B跳转到下一个hw。

选择结构

1
2
3
4
5
6
7
8
9
10

	CMP R0, R1						; 相当于if，比较后更新APSR。EQ= LT< GT> LE<= GE >=
	BEQ BRANCH_1					; B是跳转，BL是跳转到函数执行完后返回，BX是根据地址最低位判断目标地址是arm还是thumb在决定跳转到整字还是半字。bx操作数不能是立即数，必须是寄存器
	B BRANCH_2
	
BRANCH_1
	...
	B IFEND							; 不写这个就继续执行BRANCH_2了，像switch的break
BRANCH_2
	...
B IFEND

循环结构

1
2
3
4
5
6
7
8

WHILE_BEGIN 
	UDIV R2, R0, R1 ; R2 = n / x
	MUL R3, R2, R1 ; R3 = R2 * x
	CMP R0, R3 ; n == (n / x) * x
	BEQ WHILE_END
	SUBS R1, R1, #1 ; x--
	B WHILE_BEGIN ; loop back
WHILE_END

Stack

内存中有一片内存空间类似栈的数据结构。SP指针指向栈顶。

这个栈地址是从高到低的，也就是存入数据 SP–，取出数据 SP++，类似一个翻转过来的，倒着的书堆。

满堆栈：sp指针指向最后一个栈顶数据。

空堆栈：指向最后一个数据的下一个要放入数据的空位置。

我们的课程中使用空堆栈，指向下一个空位置，存数据就先存入再SP-4，取数据就先SP+4再出栈。不过这两条指令都不需要我们手动执行，有专门的指令：

1
2

PUSH {R0, R4-R7} 	; Push r0, r4, r5, r6, r7
POP {R2-R3, R5} 	; Pop to r2, r3, r5。入栈出栈顺序不是按照书写顺序而是自动根据寄存器地址，高地址值给高地址寄存器

存入5个数据和取出3个数据。

Functions

BL先保存当前PC值到LR，然后PC跳转到函数地址，

BX LR跳转到LR中的地址用于函数返回。

Architecture Procedure Call Standard (AAPCS) ：规范定义哪些寄存器主函数和函数通用，哪些是独有的。

arm AAPCS规定：r0-r3是通用寄存器（类似全局变量），但main和函数的R4 – R8, R10-R11不通用（类似临时变量，到了函数里这些值就变了，不是原函数的），要压入栈保存。函数调用和返回的时候要保存和恢复通用寄存器值。这些由调用原函数的子函数 callee-procedure 执行。

简单的参数的函数调用：传参给R0-R3作为函数参数，R4-R11压入栈，然后跳转到函数处。

Program Memory Use

ROM里都是只读数据，比如常量常数。

const, static, volatile

貌似是不会过多涉及具体代码实现的部分，就先简单介绍一下了。

const 就是定义常量变量，定义后无法再次修改。

static 通常定义静态函数，静态函数里的值是通用的，也就是每次调用该函数其值都是接着上次调用该函数的值继续。

volatile：一个在嵌入式里挺重要的东西，软考题里出现过几次。大概就是禁止编译器优化该变量来防止不必要的错误。

比如编译器优化num变量，这样每次修改num变量的值的时候都不会立刻写入内存中，可能会先把修改时的值写入寄存器，函数返回时写回内存。

现在比如我们在main中num+=5, 修改值后的num暂时存在寄存器里。然后我们调用中断，从内存中读取当前num的值并+1.但是内存中值还没改，还是原值。返回后，main再把自己手中的num值写回内存，最后内存中num值只+5，而不是我们期望的+6.

volatile 声明后的变量不会做这样的优化，值改变了就立刻写回内存，虽然可能效率低但是安全。

Interrupts

比如我们程序的逻辑是按键按下的时候点亮小灯。第一种做法是 Polling 轮询，一直看：按键按下了吗？没有。按下了吗？没。按下了吗？……

这样主要是效率低浪费CPU资源，如果为了节约资源轮询间隔大了，又不能及时响应。

中断允许CPU专心处理background的事情，触发中断的时候先放下后台处理前台。对于无os的裸机也能实现简单的多线程切换。

异常处理流程

1. 结束当前正在执行的指令。

2. 当前模式寄存器值压栈保存。

   

3. 切换模式。

4. PC LR更新（根据异常处理器提供的值）。PC去查中断向量表，看要跳到哪里，EXC_RETURN Code赋值给LR。

5. 更新IPSR状态。

6. 开始执行异常代码。

7. 退出，BX LR把 EXC_RETURN Code 值返回给PC。

8. 出栈。

Timing

中断执行也是耗时的，需要一定的时间保存源程序状态，执行中断，恢复。

FMax_Int：最大中断执行频率，即：单位时间内最多执行几次中断。

F_CPU：CPU频率，即：单位时间内CPU有多少次指令周期。

C_ISR：执行中断内容需要多少周期。

C_Overhd：中断保存、恢复数据等准备工作用多少周期。

中断一次执行所需周期：C_Overhd+C_ISR

因此， $F_{Max_Int=}F_{CPU}/(C_{ISR}+C_{Overhd})$

U_int：中断处理实际消耗的利用率，上面那个毕竟是最大值。

$U_{int}=F_{Int}/F_{Max_Int}$

中断执行速度（和频率一样）：F_Int

非中断执行速度：(1-U_Int)*F_Int

GPIO

General Purpose Input Output,

Memory-Mapped IO

把设备，控制等寄存器映射到内存里。好处就是访问设备方式和内存一样，也不用设计复杂的IO电路，便捷；缺点在于占用了内存空间。

Peripheral-Mapped IO

IO有一块专门的存储区域，和内存不一样，也有专门的不同的电路指令去访问IO。好处就是节省内存空间，也能清晰的知道什么时候发生IO了；缺点在于开发、设计上的造价增加。

GPIO

通用IO可以判断引脚高低电平，可以给引脚赋值高低电平进行控制。

stm32有几组GPIO，每个有16个Pin，可以配置为input output pullin pullup等模式，以及定时器、串口、中断等功能。

什么是上下拉模式？如果不设置为上下拉，引脚浮空的时候（没有设置输入为高或低电平的时候）浮空引脚可能收到电磁波干扰等等问题导致输入状态不确定，有0有1的，容易造成错误。

下拉：三极管控制默认接地，无输入的时候默认低电平。

上拉：三极管控制默认接Vdd 芯片工作电压。

大多数引脚是这两个功能都有的，我们初始化GPIO的时候选用一个，寄存器根据值控制接通相应电路。

输入输出信号真的可以被称为“信号”。输入规定为0-0.5视作低电平，0.5-Vdd视作高电平，范围以外的值无效。输出电流也只有5mA左右是没有能力直接驱动一些设备的，我们可以通过一些电路比如三极管，放大器等，电路接收到信号得知”需要输出驱动电流了“然后输出大电流。

Control

每个GPIO口有：

4 * 32bit configuration registers: 配置相关信息，比如in/out，上啦下拉，开漏输出或推挽输出，输出频率等。

• 推挽输出 push-pull：能输出高低电平。
• 开漏输出 open-drain：没有能力输出高电平，想输出高电平需要设置上拉电路来输出。

2 * 32bit data registers: 输入输出数据寄存器。

1 * 32bit set/reset registers: 设置或复位寄存器。

1 * 32bit locking registers: 锁定寄存器。

2 * 32bit alternate function selection register.

Mode

如图，32个Pin，每个两位来设置4种模式（in out 可选 模拟）。

Pull

只有3种模式（无pull，上拉，下拉）。

data

输入输出数据寄存器分开的。

CMSIS

先说一下考试定义：

CMSIS transforms memory mapped registers into C structs

1

#define PORT0 ((struct PORT*)0x2000030)

再说一下和一些嵌入式前辈讨论的理解，以下内容不许考试写：

李肯老师：arm-M推出的一系列API和软件组件，包括核心功能、DSP库、RTOS支持和调试接口等。

李肯老师：如果芯片厂不想再多一层，CMSIS就够用；但有的厂商会再在上面封一层，可能叫driver层。

李肯老师：另外CMSIS有个限定，就是ARM的ARM Cortex-M处理器；虽然它很常见，但并不是所有的处理器都是这个内核；这个需要注意。

榊：这种与内核相关的文件，比如启动文件，内核文件是CMSIS规定。

榊：对比STM32F103和GD32E23的启动文件，我们会发现是一样的：

榊：而芯片厂商要做的是根据这个arm规定的接口二次开发库函数。

李肯老师c站账号：架构师李肯的博客_CSDN博客-程序人生,粉丝福利领域博主

榊老师c站账号：风正豪的博客_CSDN博客-C语言,MSP430F5529,Linux领域博主

平时李肯老师的交流群会讨论很多嵌入式相关问题，欢迎有兴趣的同学来学习[Doge]

以上内容感兴趣的看个乐呵。

例：

1
2
3
4
5
6
7
8
9
10
11
12

typedef enum {
Reset, //!< Resets the pin-mode to the default value.
Input, //!< Sets the pin as an input with no pull-up or pull-down.
Output, //!< Sets the pin as a low impedance output.
PullUp, //!< Enables the internal pull-up resistor and sets as input.
PullDown //!< Enables the internal pull-down resistor and sets as input.
} PinMode;

gpio_set_mode(P1_10, Input);
gpio_set_mode(P2_8, Output);
int PBstatus=gpio_get(P1_10); 
gpio_set(P2_8, 1);

以上代码是老师提供的driver，大意就是选定pin，传入特定参数，即可设置模式，设置输出。

感兴趣可以看看我的这篇文章，如果使用arm定义的cmsis直接去开发也是可以的：

STM32 学习笔记_4 GPIO：LED，蜂鸣器，按键，传感器的使用_灰海宽松的博客-CSDN博客

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include "stm32f10x.h"
int main(void){
    /* 控制gpio需要三个步骤：开启rcc时钟，初始化，输入输出函数控制 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_SetBits(GPIOA,GPIO_Pin_0);
    while(1){}
}

drivers二次开发，可以帮助简化。

当然这一段都是题外话了。考试就理解为“cmsis是变量宏定义直接映射到寄存器上；drivers是对其添加进一步行为”即可。

Serial Communication

串口通信，一种发送消息的通信方式。

串，指的是发数据的方式：一位一位串行发，并行是可能有多路通道，每路同时发一个数据，多路同时到达。

串口通信有单工 Simplex，半双工 Half Duplex，全双工 Full Duplex。

两种传输方式：同步 Synchronous，共用一个时钟；异步 Asynchronous，有各自的时钟。

同步很简单，发送方接收方比如都规定时钟信号下降沿收发。

异步：需要通过异步通讯协议 Asynchronous Comm. Protocol 来协调。

1位起始位标志开始传输，7/8/9位数据位，1位可选奇偶校验位，1位停止位。

RT两方需要有相同的波特率。

当然这只是最简单的串口通信因为只有双方。如果更多方通信我们需要校验地址来判断是哪个发给哪个；数据需要更复杂的校验方式。

异步通信不需要同步时钟之类电路，开销小，但是开发起来难度大一些因为需要起始结束位啥的。

RS232

异步通信，Reversed Polarity 标准电压（-3-15是1,315是0.还有一些其他标准比如TTL是+5为1，-5为0.）

发送数据有两种类型，ascii码和二进制，都得转化为二进制传输。

uart

针对stm32f401.

全双工异步串口。

为了处理RT缓冲数据（因为发收数据需要时间）我们可以通过缓冲区数组，头指针表示已经发到的位置，尾指针表示要发的数据的结尾。增加新数据，尾指针++；发一个数据，头指针++直到碰到尾。

原来发送方一直是发高电平，start frame 起始帧是1帧低电平来表示开始发数据了。

如何判断是1帧低电平？通过在这一帧里多次采样判断是不是真的是一帧低电平。

为什么多次采样？因为异步两个信号有一定的偏移，多次采样准，能确定是不是真的一整帧都低电平。

采样是有一定采样率的，不是说真的能像模拟信号一样一直采。

采样率 oversampling=16: 这个是最大可以达到的采样频率而不是真的一帧采了16次。

接收方首先第一次检测到0位，开始怀疑：有可能是串口有消息。这是start frame的第一次采样。

然后每隔一帧检测一次，3 5 7检测3次，如果2个都是0，说明确实有可能。

然后连着检测8910，如果还是2个0，说明确实是start frame。

8采样率因为采样间隔长了，更容易碰到左右边界的高电平，所以容错率低。但是速度更快。

计算

波特率计算：

$T_x/R_x(baud)=\frac{f_{PCLK}}{8*(2-OVER8)*USARTDIV}$

OVER8是过采样率，fPCLK是时钟频率。

USARTDIV是一个浮点数

USARTDIV浮点数怎么存储？通过算法转化为十六进制。

小数部分用一个16进制位表示，比如例1是C也就是12，转换后即为12/16也就是0.75.

例2转换为一位16进制，就是0.62*16约等于10也就是A。

整数部分直接转换十六进制即可，例2的25转为19，例1的27转为1B。

然后整数小数部分拼接起来（最多3个整数位，1个小数位，32位寄存器）。

Timer

想让程序定时运行，比如led 1s闪烁一次。如何做到？

第一种方法是愚蠢的delay延时，我自己估算一下：嗯，delay(2000)差不多1s。然后在程序中delay，点亮，delay，熄灭……

太浪费资源了。

第二种方法，32是有定时器中断的。

定时器中断大概原理是，32上有时钟晶振按固定频率周期输出0101010……定时器里有一个cnt，收到一个时钟晶振就++。

我们可以设置定时器溢出值，比如溢出值是1000，cnt加到1000会自动触发定时器中断。然后归0，继续++。

执行周期数量：1+1+1+1+(0xFFFFFFFF一直-1-1-1直到变为0x00FFFFFF的循环次数)+(r0+1的执行次数，1次)

定时器也有一些扩展方法，比如我们可以设定++还是–；可以设定信号源是时钟或者外部输入的方波信号；可以读取计数值……

我们课件常用方法好像是–到0触发中断，然后恢复初值。

PWM

PWM这个东西是什么？

PWM（Pulse Width Modulation）脉冲宽度调制，在具有惯性的系统中，可以通过对一系列脉冲的宽度进行调制，来等效地获得所需要的模拟参量，常应用于电机控速等领域。

就好比说，你骑自行车速度只能是100和0，模拟电信号只能输出高低。

但是呢，你骑自行车是有惯性的，以100速度蹬一脚，以0速度蹬1脚，100速度蹬一脚……

整体来看你的自行车平均速度是50（我们假设加速度不需要时间哈）

这个应用场景有很多，比如设定led闪烁频率：高低高低高低……，因为频率极高，我们肉眼看不出来在闪，给我们呈现的视觉效果就是以一半的亮度在亮。高低低高低低就是1/3亮度。

比如电机通过这个方式调速度。

那么他有什么应用场景。第一，输入捕获 Input capture。

对于一个这种有惯性的系统，我们也可以反过来读取其波形来判断其速度。比如电机放一个转速检测传感器，把输入波形作为定时器的时钟源信号，定时器一直++：检测上升下降沿时记录cnt值，通过差值比较计算时间间隔。

第二，输出比较 output compare。

定时器一直++，与预先设定好的阈值比较，如果相等触发中断输出。

这就是PWM。占空比相当好算。

Low Power Timer

我们目前假设的是CPU一直运作的，只是在后台和前台之间切换。有一种低功耗定时器使得没有发生定时器中断的时候CPU被置为低功耗状态，只有发生定时器中断的时候才启动。（使用 __WFI() wait for instruction 指令）

SysTick

M系列自带的一个系统时钟，使用处理器时钟或者参考时钟作为时钟源。

有四位寄存器：

每次赋值是load，一直–到0时重新load赋值。ctrl是控制启用系统时钟。这个是CMSIS有提供的数据结构和相关操作函数的时钟处理部分。

init 参数是中断间隔的毫秒数。timer_set_callback() 里跟一个可以是自己定义的函数，使得触发定时器中断时该函数被执行。以上代码意思是每隔100ms LED灯翻转一次，且 CPU 常态下处于低功耗状态。

I2C

连接多个模块的传输方案：I2C，使用两根总线。

两根总线分别是时钟总线 SCL 和数据总线 SDA。

通信过程

现在我们串一遍I2C上一个模块（master）要给另一个模块（slave）发消息的过程。

1. MCU 使用一定的方法标识自己开始传输了。
2. MCU 发送 LCD slave 的地址+一位读写位，其他模块接收到发现地址不是自己的，就不做处理。
3. LCD 接收到后知道目标是自己，于是返回 ack。
4. MCU 收到 ACK 后发送一帧数据。
5. 发送完 MCU 等着 ACK，收到 ACK 后继续发送下一帧数据。
6. 一直发送到发送停止位 stop 结束。

数据长度可以设置，比如789.

总线上的器件是开漏输出的半双工通信。

默认总线是上拉电阻拉成高电平。

当器件输出 out 为低电平时，总线导通到接地，总线被拉低（整条总线都被拉低）。江协科技老师举的例子很好，就像公交车上的一根横杆，有人拉住横杆拽下来，整条横杆都被拉低了，其他人都知道“横杆被一个人拉低了，说明有人正在使用总线”。

然后是总线传输数据的方式，SCL SDA 两根总线在何种情况下表示 start stop 0 1 bit?

首先都是 SCL 为高电平时 SDA 的数值才有意义。

SDA 从高到低，表示 start 位。从低到高，表示 stop 位。

start 位后，SDA 高电平表示1，低电平表示0.

发送完 1byte 数据后，总线保持拉高状态。如果接收方把总线拉低了，发送方发现总线1→0了（不是发送方自己拉的，是接收方给他拉下来的，但是发送方能察觉到），说明接收方成功接收了并且拉了拉总线以示“收到”。如果 SDA 还是保持在高电平，说明接收方没有成功收到或者成功发送 ACK。

问题处理

I2C 是一种很简单的主从通信协议了，但是局限性也很多，比如7 bit 的地址线只允许 2^7 个设备；一次顶多两个设备主从通信；一个设备的快慢会影响到整条总线的通信等。

问题1：从设备处理速度太慢了，赶不及在下一个时钟周期接收新数据帧怎么办？

方法：clock stretching, 拉低一段时间 SCL 假装下一个时钟周期还没到。

问题2：多个设备同时发数据冲突了怎么办？

方法：Bus Aribitation，前面我们知道总线被一个设备拉低了，所有设备都能接收到总线拉低的信号。因此如果两个设备同时开始发信息，前面数据一致都无所谓，等到第一次数据不一致的时候，一个设备发送数据0，一个发送数据1，这时 SDA 总线被 DATA2 的0拉低了。

发送 DATA1 数据的设备就明白了：有人同时在和我一起发数据，因此总线不是我预期的1而是被他拉低为0了。那我 quit，你发吧。然后就只有 DATA2 发送的数据了。

问题3：以上发送的数据每次都是 1byte 8bits 很正好。那如果要发送的地址不是 8bits 呢？

方法：少于 8bits 用一些固定的额外的 start 位填充，多于 8bits 的地址用两个 bytes，不够的也是用额外的 start 位填充。

问题3：如果我 master 发完数据，想紧接着再收数据，变成 slave，可行吗？

方法：通过一个 sr 信号，也就是 repeat start 重发 start 位，来标识自己是 read 而不再是 write 了重新开始通信。

编址格式

slave 地址编址有一些固定格式。

0000 000 0：广播，对所有 slave 结点讲话。如果 slave 无视（NACK），就不会参与广播。如果返回 ACK 就参与进来了。不过多个 slave 都返回 ACK 的话 master 是不知道都有谁回应了的。

第二个 byte 发送一些行为相关，比如：start，clear，reset software

编程应用

slave mode:

• I2C 设备默认工作在 slave mode。
• 外设时钟在 I2C_CR2 寄存器中编程。频率介于 2kHz~100kHz。
• 硬件自动等待发过来的 start 和 addr 信息。
• 如果 addr 信息和 OAR1 中存储的地址相同，说明目标是自己。如果 ACK 位为1，则发送 ack pulse。
• 设置 ADDR 位，1表示匹配。
• 如果 ITEVFEN 就是中断事件 flag 为1，则生成中断。
• TRA 位标明 slave 是 R 还是 T 模式（收 or 发）。
• BTF 位标识收没收完。

这么说起来还是有点混乱 I2C 到底经历了哪些才顺利发送了数据？

首先，从主模式的概念。master 主模式驱动时钟信号，发起传输；slave 从模式响应传输。

主模式

发送：

所有 EV 事件都会拉低 SCL，直到相应软件序列执行完成。

S：start 事件。比如CR2 寄存器中设置外设时钟，配置时钟寄存器，上升时钟寄存器，使能 CR1 来启用时钟，CR1 中设置 start 位，等待总线被拉低表示就绪，发送启动信号，并切换为主模式。

EV5：启动事件成功进行，设置 SB 寄存器=1. SB 寄存器=1后才可以进行地址阶段，执行完地址阶段会自动清除 SB 和 EV5 事件。

Address：地址阶段。传输7位地址+1位读写位，然后等待从机的 ack。收到 ack 进入 EV6.

EV6：设置 addr 位=1代表地址阶段顺利执行， master 收到 ack了。清除 EV6 后自动进入 EV8.

EV8：设置 TxE ，准备写入主机要传入的数据。TxE 表示数据寄存器为空可以写入。每次数据写入 DR 都会清空 TxE 和 EV8 事件。写完数据数据传过去了，主机收到 ack 后继续传输。以 BTF=1 表示数据传输的结尾。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

void i2c_write(uint8_t address, uint8_t *buffer, int buff_len) {
	int i = 0;
    // Send in sequence: Start bit, Contents of buffer 0..buff_len, Stop
    while (((I2C1->SR2>>1)&1)); // wait until I2C1 is not busy anymore
    I2C_GenerateSTART(I2C1, ENABLE); // Send I2C1 START condition
    // wait for I2C1 EV5 --> Slave has acknowledged start condition
    while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
    // Send slave Address for write then wait for EV6
    I2C_Send7bitAddress(I2C1, address, I2C_Direction_Transmitter);
    while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
    while (i < buff_len){
        I2C_SendData(I2C1, buffer[i]); // send data then wait for EV8_2
        while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
        i++;
    }
    I2C_GenerateSTOP(I2C1, ENABLE); // send stop bit
}

接收：

前面和 master transmit 都一样。

TxE 改为 RxE 了，=1标识接收到了数据。

master 自己设置 stop 事件后（发送 NACK）停止接收。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

void i2c_read(uint8_t address, uint8_t *buffer, int buff_len) {
    int i = 0;
    // Start bit, Contents of buffer from 0..buff_len, sending a NACK
    // for the last item and an ACK otherwise, Stop bit
    I2C_GenerateSTART(I2C1, ENABLE);
    while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)); //EV5
    // Send slave Address for write then wait for EV6
    I2C_Send7bitAddress(I2C1, address, I2C_Direction_Receiver);
    while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
    I2C_AcknowledgeConfig(I2C1, ENABLE); // going to send ACK
    while (i < buff_len - 1){
        while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)); //EV7
        buffer[i] = I2C_ReceiveData(I2C1); // get data byte
        i++;
    }
    I2C_AcknowledgeConfig(I2C1, DISABLE); // going to send NACK
    while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)); //EV7
    buffer[i] = I2C_ReceiveData(I2C1); // get the last byte
    I2C_GenerateSTOP(I2C1, ENABLE); // send stop
}

从模式

发送：

start 启动事件由 master 发起。从机校验地址并决定是否发送 ack 位。

EV1：设置 addr 位表示地址匹配。

EV3-1：设置 TxE 位，开始传入数据。一直到主机返回 NACK 表示不想再要数据了，或者 AF=1 说明 ack 失败了为止。

接收：

前面到 EV1 和 slave transmit 都一样。

1. 数据从 DR 寄存器中读。
2. 读入一个 byte 后，如果 ack 位已经设置，则返回 ack 信息。
3. RxE 位是接收数据的状态寄存器。
4. 主机生成停止条件时停止。

异常情况：

总线错误，NACK，仲裁失败，时钟异常超时。

前言

这回参加的是csdn李肯老师的攻城狮计划，简单说就是我白嫖板子，输出学习笔记。

板子是瑞萨的CPK_RA2E1，还有触摸元件，看起来很有意思hh。

环境搭建

一开始决定采取vscode搭建的方式。后期进行到最后一步——cmake build的时候一直显示语法错误，肯哥表示是环境配置不全，但是我反反复复根据官网和其他博主的文章检查了不下10遍都不知道问题何在。最终决定还是老老实实用keil。

1. keil导入瑞萨包。官网下载地址：Arm Keil | Renesas

2. 下载rasc软件。对于这个东西我的理解是类似stm32cubemx，可以快速初始化项目的软件。该软件可以在瑞萨官网下载：https://www2.renesas.cn/kr/en/software-tool/ra-smart-configurator

3. 接下来我们尝试新建编译一个项目。这是我第一次没有跟着一块有完整开发流程的板子的视频课，而几乎完全是自己检索资料探索尝试的项目构建，因此碰到了很多弯路。首先rasc软件我们新建一个项目。

   

   板子型号这里是根据我的学习板设置的。IDE一定记得改为keil。

   

后两页选择 no rtos 和 minimal 即可，因为我们现在的目的只是尝试编译通过一个项目。

4. 添加完成后，点击generate code 生成相关的项目代码。然后用keil打开，尝试编译。

5. 我第一次遇到的问题是报了19个错。我还以为是pack导入的不对，但是后来搜了一下发现不是那么回事，是编译方式选错了。参考文章：keil出现大量未知语法错误（系统移植）_portforce_inline_IT小生lkc的博客-CSDN博客

   

6. 于是我把编译器改为version5，编译到一半，再次报错：error: A3903U: Argument ‘Cortex-M7.fp.sp’ not permitted for option cpu’.。这个问题原因是因为编译器版本太低，于是我又去下载了新的keil5.

7. 再次编译的时候提示我，不能用version5，新版本已经不支持了。于是我又改为version6进行编译。这次非常顺利！

下载

终于考完试了，然而攻城狮的截止期限也快到了QAQ，得尽快水（划掉）写几篇文章了！

先争取可以成功下载一个空的程序。

先对上一篇文章下载 DFP 也就是 keil MDK Software Packs 做一个补充。我们要下载的是 RA_DFP，下载地址为：Arm Keil | Renesas RA_DFP

至于版本我看到有前辈使用 3.5.0 的版本可以成功运行，而我下载的是4+的版本也可以。只不过在选择 device 的时候会有一点不同：

可以看到 4.1.0 的版本无法细化选择到 R7FA2E1A92DFM，只能选择大类 A9. 不过经过下面的烧录尝试，是没有问题的。

流程：基于上次的空项目，用keil打开，编译，下载成功。

一直到编译的步骤前面都做完了。下载主要需要以下几个步骤：

1. 引入项目的 src 文件夹。在 options for target - c/c++ 里引入即可很简单。
2. debug 模式设置为 jlink 模式。设置完之后插上板子设置配置，这里因为我的jlink版本太低出现了一个报错：unkown to this version of the jlink software。解决办法就是在官网上下载了一个新版本的jlink（官网链接：https://www.segger.com/downloads/jlink，我选择的是 windows 版本），下载好后直接会提示“检测到你电脑里的 keil 环境，请问是否更新其 jlink 调试器”，更新后重新启动就没有问题了。
3. 上一步参考文章: keil识别不到芯片，提示unkown to this version of the jlink software_keil识别不到单片机_王小琪0712的博客-CSDN博客 里面也有如果没有提示自动更新 jlink 调试器的选项如何手动进行更新的步骤，建议多多支持原作者。
4. 只是选择了 jlink 调试器也并不算设置完成。如果这个时候点击下载，会提示“找不到 flash”，也就是还没有配置完成，需要设置闪存。首先确保插上了板子，然后打开 jlink 的setting：
5. 如果显示下图说明板子被正常识别。如果没有显示这些数据，可能是 jlink 的版本还是过低，或者线坏了，或者还未下载对应 rcsa 包。
6. 接下来我们配置 flash download. 打开这个页面后点击 add，添加图中所示的这款型号芯片，然后 start 和 size 应该就会自动配置成和图中一样的情形，这样就算成功了。
7. 点击 load，如果显示如下信息说明成功下载程序。

刚插上板子的时候板子上是有白色的 power 指示灯和一个红蓝交替闪烁灯。下载空程序之后，应该只有电源指示灯还在亮。

点亮LED

本文主要参考文章：【致敬未来的攻城狮计划】— 连续打卡第十一天：FSP固件库开发点亮第一个灯。_嵌入式up的博客-CSDN博客

在32阶段我们已经接触过类似做法了。初始化引脚模式（可以手动库函数，或者在工具包图形化界面里配置），设置引脚输出值。

设置 FSP Smart Configurator

像上次一样创建一个项目。

首先我们翻一下RA2E1的数据手册看看led在哪。

如图所示，一红一蓝，502 501，输出高电平亮。

因此 configurator 里的pin如图所示设置501 502为output initial high

配置完成后点击右上角 generate project content，输出更新配置到该项目中。

Keil代码编写

接下来就是编写keil里，驱动两个led灯输出高电平的部分了。

hal_entry.c 是相当于 main.c 的入口函数。其他都是 configurator 提供的配置函数。

引脚设置已经设置好了。我们打开 pin_data.c 可以看到：

这就代表确实初始化配置加进代码里了。

然后在 hal_entry.c 里是通过这个 open 函数在 warm_start 里初始化了。

接下来我们需要一个写入位函数。在 r_ioport.c 里。

参数1：固定参数，传入 &p_ctrl。

参数2：引脚，老方法 goto the definition

参数3：电平。

然后就简单了，只需要在主函数里调用write函数写亮led。

1
2
3
4
5
6
7
8
9
10
11
12
13

void hal_entry(void)
{
    /* TODO: add your own code here */
		while(1){
				 R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_01, BSP_IO_LEVEL_HIGH);
				 R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_02, BSP_IO_LEVEL_HIGH);
		}

#if BSP_TZ_SECURE_BUILD
    /* Enter non-secure code */
    R_BSP_NonSecureEnter();
#endif
}

实验结果

按键模块

后台轮询

按键也是一个比较简单的模块，主要是为了学习IO输入模式。

查看RA2E1电路图可见：

按键相关引脚是004引脚，默认上拉高电平，按下接地为低电平。

首先第一步还是设置对应引脚。类似上一期设置LED的方式，只不过Mode改为Input mode。

设置好之后仍然是记得generate。

然后就是程序编写。首先还是明确一下开发流程。首先我们尝试后台轮询的按键检测。在while里不断检测按键电平，如果为高点亮蓝灯，如果为低点亮红灯。

点亮好写，上一次已经尝试过write函数。那么我们接下来再去看类似的read函数。

第一个参数还是传入固定的&g_ioport_ctrl。第二个是引脚。第三个是存放我们要存储的读取按键的值。比如传入变量state的地址 &state，函数执行结束后state的值就是读取的按键电平。

主函数编写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void hal_entry(void)
{
	bsp_io_level_t state;
    /* TODO: add your own code here */
		while(1){
			R_IOPORT_PinRead(&g_ioport_ctrl, BSP_IO_PORT_00_PIN_04,&state);
			if(state==BSP_IO_LEVEL_HIGH){
				R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_01, BSP_IO_LEVEL_HIGH);
				R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_02, BSP_IO_LEVEL_LOW);
			}
			else{
				R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_01, BSP_IO_LEVEL_LOW);
				R_IOPORT_PinWrite(&g_ioport_ctrl, BSP_IO_PORT_05_PIN_02, BSP_IO_LEVEL_HIGH);
			}
		}

#if BSP_TZ_SECURE_BUILD
    /* Enter non-secure code */
    R_BSP_NonSecureEnter();
#endif
}

实现效果：

活动总结

一转眼攻城狮计划就已经到了最后一天了。
5月我还处在一个迷茫期，那时候刚刚入坑嵌入式，只学了几款电子积木，对整个体系也不是很清楚，也不知道应该学些什么。因为刚刚转到硬件领域，也缺少相关经历和能力证明，科研实习面试都失败了。

一开始得到的少许鼓励来源于C站推荐的一系列交流会活动。我去参加了RTThread的学习营，第一次尝试在单片机开发中加入RTOS系统，也算是跳脱出自己当时缓慢的按部就班学习路线，如井底之蛙般弹出脑袋窥探了一眼外面的风景。

后来偶然收到李肯老师的攻城狮活动邀请。虽然因为选在了期末周，自己又比较懒，基本没更几篇文章hh。但是借助李肯老师的交流活动认识了很多嵌入式领域的前辈，同伴，从每天的交流话题中也能学到很多。

现如今，虽然学到的知识相比之前可能没有太多，但是整个系统的框架，从硬件到ISA，操作系统解释器等系统软件，汇编语言和机器语言的转化等……确实见识到了很多。

再聊到本次活动。虽然自己没有做过多的尝试，但是因为之前我也只尝试过51和32的库函数开发，rcsa的configurator配置本身对我来说就是一种新奇的开发模式。与32的hal库对比更能让我体会到这些driver的便捷之处，也开始适应这种开发方式。

非常感谢给予这次机会的李肯老大！也期望自己能保持这股热情继续学下去~

[TOC]

软件下载

开发：Keil。如果想要没乱码的中文注释，那么设置编码方式为 UTF8 或 GB2312。

程序文件下载到单片机：STC/普中（STC需要冷启动，先点击下载再开启单片机电源）

介绍

Micro Controller Unit, MCU 单片机，其中包含了CPU RAM ROM 输入输出设备 等一系列电脑硬件常用功能。

功能：通过传感器采集数据，通过CPU处理数据，控制硬件。

可以说是一个性能低的小电脑，是了解计算机原理的很好的学习方法。

右上角的跳线帽使用数码管时跳到VCC，使用点阵时跳到GND。

STC89C52RC 命名规则

STC：芯片为 STC 公司生产的产品。

8：该芯片为 8051 内核芯片。

9：表示内部含有 Flash EEPROM 存储器，还有如 80C51 中 0 表内部含有 MaskROM（掩模 ROM）存储器；如 87C51 中 7 表示内部含有 EPROM（紫外线可擦除 ROM）存储器。

C–表示该器件为 CMOS 产品。还有如 89LV52 和 89LE58 中的 LV 和 LE 都表示 该芯片为低电压产品（通常为 3.3V 电压供电）；而 89S52 中 S 表示该芯片含有 可串行下载功能的 Flash 存储器，即具有 ISP 可在线编程功能。

5–固定不变。

2：表示该芯片内部程序存储（FLASH）空间大小，1 为 4KB，2 为 8KB，3 为 12KB，即该数乘以 4KB 就是芯片内部的程序存储空间大小。程序空间大小决定了 一个芯片所能装入执行代码的多少。一般来说，程序存储空间越大，芯片价格也 越高，所以我们再选择芯片的时候要根据自己需求选择合适芯片。 RC–STC 单片机内部 RAM（随机读写存储器）为 512B。还有如 RD+表示内部 RAM 为 1280B。还有芯片会省略此部分

芯片介绍

芯片在 PDIP 里。黑色的部分 PDIP 是一种封装方式，可能还有 LQFP 等（一个正方形的形状）封装方式。

8051 内核基本上都是中间绿色块的样子，只是外设、封装等方式不同。

管脚图：

Vcc 是电源，XTAL 管时钟，RST 是复位，等等。

整个是一个总线结构，所有外设都挂在上面。如最下面一行左边是晶振，右边是外部引脚。

只有这一个单片机是不能运行的，看我们的开发板上面还外接了好多好多外设呢。能让单片机运行的最小应用系统如下：

三角是正极，三线符号是负极。

首先需要 Vcc 接正，GND 接负。

然后需要接晶振。没有晶振单片机程序无法一条条往下执行，有了晶振按照固定的周期才能一条条往下执行。晶振就是板子上银色的椭圆形的一个东西，频率写在上面，一般是有12MHz和11.多MHz的两种（有的芯片自带晶振。不过很明显我们的芯片并不自带）。

然后还有复位电路，让程序回到第一条的位置。

开发板介绍

中间黑色的是刚刚介绍的单片机。拉起拉杆，可以取下单片机，但放回时一定不能放反。单片机有缺口的一端左侧从01开始，逆时针逐渐增大到40。

右侧中间有8个 LED 灯，我是点灯大师！

下面是一个矩阵按键，用户可以通过按按键输入。

最下面一行右侧有个红外接收传感器，接收红外线的。

左边无线模块，8个插孔的，做无线模块（如2.4G）用的。

再左边四个独立按键。

最左下是 USB 自动下载模块，插上 USB 线后按开关就会自动下载程序，不用了解。

DS1302 时钟芯片，可以做一个小时钟，读取时间。

红色按钮是 RST 按钮。

AD/DA 模数转换器，使单片机在数字与模拟领域之间转化。

74H595 可以扩展出更多的 IO 口。

步进电机可以精确控制脚步（转一圈、转半圈）。比如空调会用。

超声波模块可以测距。

蜂鸣器模块可以放歌。但我（）（）（）（）。

138译码器控制数码管，也可以扩展 IO 口。

24c02 也是一种 ROM，还是 EEP ROM（掉电不丢失）。其实单片机自带的 Flash ROM 更先进，但是只能用来存储程序。

温度传感器可以用来检测温度。

74HC245 可以驱动数码管（我的单片机是 HC138）。

左上角的电位器和排座用于接显示屏。电位器可以调整显示屏的亮度。

最大的黑色方阵是一个 LED 点阵。可以点亮8*8的方阵，甚至用来做动画。

之后的课程中还会详细介绍每一个模块，以及对应的电路图。

逻辑运算

&与，|或，!非，⊙同或（相同结果才=1），异或⊕（不同结果才为1）

C语言语法

int 16位，char 8位。

基本语法其他的都好说，再复习一下位运算。

左右移补0.

位运算符也可以参与成为复合赋值运算符，如^=, <<=

逗号运算符=最后一个表达式的值

函数在C语言基础上做的拓展

重入函数

在函数形参括号后加修饰符 reentrant，代表这个函数是重入函数，可以被递归调用，但这样就不能有bit变量，也不能进行位运算。

中断函数

在函数形参括号后加修饰符 interrupt m，系统编译时把对应函数转化为中断函数，自动加上程序头段和尾段，并按 51 系 统中断的处理方式自动把它安排在程序存储器中的相应位置。

在该修饰符中，m 的取值为 0~31，对应的中断情况如下：

0——外部中断 0

1——定时/计数器 T0

2——外部中断 1

3——定时/计数器 T1

4——串行口中断

5——定时/计数器 T2

其它值预留。

外部函数

如果要调用的函数不在本文件内，在其他文件内，定义函数时函数开头要加 extern 修饰符。

sfr sbit

用于定义特殊功能寄存器或特殊位。

1
2

sfr P0=0x80;//把地址 0x80 处的寄存器定义为 P0
sbit P0_1=P0^1;//取第一位定义为 P0_1

其实头文件 regx52.h 中都有。

能不能给位单独赋值要看是不是可位寻址。因为物理地址有限，每8个寄存器只能有一个可位寻址。

51单片机最小系统组成

• 晶振电路，提供时钟，相当于心脏
• 复位电路，系统运行不正常时可以重启
• 电源电路，注意单片机的供电电压要求
• 下载电路，烧入程序

另外注意，单片机的P0口是漏级开路，输出高电平会导致高阻态，因此输出高电平时要接上拉电阻，通常选择 4.7K~10K 阻值。

程序编写前言

新建项目 new μversion project

选择 CPU 型号：Keil 中没有完全对应的 STC89C52 版本，用Atmel 中的 AT89C52 即可，不用把8051启动文件添加到工程中。

AT 和 STC 是两种型号的单片机。有的 STC 单片机上面还有 AT 接口，AT 使用那个接口烧录程序。STC 就用 USB 下载。

新建好后有一个文件夹：source group，代码文件都在其中。

选中该文件夹，右键新建new item，新建c语言文件。可以选c/cpp/asm

在魔术棒 Output 选项中添加 “ create HEX file”.

程序框架

1
2
3
4
5
6
7

#include "reg52.h"
void main()
{
    while(1)
    {
    }
}

编译：translate按钮

建立：build按钮，也有编译的作用，只编译发生变动的文件。

重新建立：rebuild，编译所有文件（速度慢不建议）。

报错如果显示：缺少root segment根段，即没有找到主函数。

头文件作用

#include<reg52.h>和`#include “reg52.h”都可以。区别在于<>直接去软件安装处搜索头文件，而””先在该项目下查找头文件，找不到再去软件安装处，再找不到就报错。

查看头文件可以在左侧的结构树对应的c文件目录下打开，或者右键“reg52.h” open 打开。

该头文件中定义了52单片机内部所有功能寄存器，把地址值如0x80赋值给P0等端口。

程序烧录

程序编译建立没有错误，也开启了魔术棒创建 HEX 文件选项，那么 build 后就会在对应路径中找到生成的 HEX 文件。

在 STC-ISP 中选定单片机型号、串口、晶振频率（可以直接看开发板上的晶振上面有写），选择对应的 HEX 文件，先断电开发板，再点击下载，再开机，就可以查看呈现在开发板上的效果。

HELLO WORLD——LED部分

LED 发光二极管。

下面两个黑色的方块就是8个电阻。电阻是限流作用，防止电流过大烧毁 LED。

电阻上面写着小小的“102”，代表10*10^2，即1kΩ。

每个 LED 正极是一定通电流的，如果负极接地，那么这个 LED 被点亮。否则两头都是高电平点不亮（这里的电平是 TTL 电平，高5低0）。

单片机如何驱动高低电平？在 MCU 内，CPU 接到指令（如P2^0口赋1，即高电平）CPU 把数据写入寄存器，寄存器数据通过驱动器放大后变为5V/0V 电平输出。

点亮 LED

GPIO（general purpose input output) 即通用输入输出端口，可以通过软件控制其输入和输出.

• 电源引脚： Vcc， GND
• 晶振引脚：XTAL1 2
• 复位引脚：RST VPD，不做其他功能。
• 下载引脚：TXD RXD
• GPIO引脚：Px.x的都是 GPIO 引脚，大致分为P0 P1 P2 P3，每组8个IO，P3还有附加功能，比如串口、外部中 断、计数器等。每个引脚每次只能使用一个功能。

1
2
3
4
5
6
7
8
9
10
11

#include "reg52.h"
sbit LED1=P2^0; //将 P2.0 管脚定义为 LED1
//我们也可以直接给P2整个赋值。比如P2=0xFE，即1111 1110，就只会点亮最后一个 LED 灯，和 P2^0=0 效果是一样的。
//另，我们的这种做法只是寻找特殊寄存器P2的第几位。而头文件 REGX52.H 中是真正包含所有引脚信息的，如P2_0 就是2.0引脚，也能起到一样的效果。
void main()
{
    LED1=0; //LED1 端口设置为低电平，就会被点亮
    while(1)//单片机默认不断执行主程序。如果没有这个死循环，单片机就会不断点亮点亮点亮点亮……不如点亮一次之后无限延时。
    {
    }
}

编译结果里面的几个数据的意义：

code：表示程序所占用 FLASH 的大小。

data：数据储存器内部 RAM 占用大小。

xdata：数据储存器外部 RAM 占用大小。

LED 闪烁

只需要点亮——延时——熄灭——延时循环即可。

单片机频率单位是 MHz 兆赫兹，所以只是单纯的亮灭亮灭肉眼看不出亮灭的效果。所以需要延时。

延时可以写一个这样的函数：

1
2
3
4

typedef unsigned int u16
void delay(u16 ten_us){
    while(ten_us--);
}

u16 代表16位的无符号整型数据。这是一个比较常用的定义，unsigned char 定义为 u8, unsigned int 定义为 u16。当 ten_us 超出 u16 的范围后，跳出 while 循环。

然后就LED1=0;delay(50000);LED1=1;delay(50000);循环即可.

但是，STC-ISP 可以根据晶振频率和要延时的时间生成延时函数，真的牛！不过注意软件上标明的适用系列版本。

其中 _nop_() 函数包括在 INTRINS.H 头文件中，是一个空语句，就只会产生延时的效果。

不过 STC-ISP 只能生成固定时长的延时函数。如果想要像自己写的那个 delay() 函数一样传入参数，延时对应长度的毫秒/微秒呢？

很简单，我们先生成延时1毫秒/微秒的函数，然后把函数中的内容重复执行传入参数遍。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void Delay1ms(unsigned int xms)		//@11.0592MHz
{
	unsigned char i, j;
 	while(xms--){//这里是修改过的
        _nop_();
        _nop_();
        _nop_();
        i = 11;
        j = 190;
        do
        {
            while (--j);
        } while (--i);
     }
}

Keil 软件仿真

使用仿真功能查看 LED 闪烁案例中的实际延时时间。

1. 点击魔术棒，选择 Target 选项卡，设置 Xtal 为12M或11.0592M，根据开发板晶振修改对应值。
2. 点击黑色放大镜中有红色d的仿真按钮，进入仿真页面

我们要关注的参数是sec。

3. 点击RST按钮重新复位系统参数，sec 变为0。然后在要调试的行前双击，就会出现红色块的断点，点击8运行时就会直接运行到断点处。再次点击就会运行到下一处断点处。
4. 点击红色标记8运行，运行到36行时显示用时：0.00039s，再次点击运行到37行，用时：0.45s
5. 可见delay花费时间约为0.45s

LED 流水灯

学会了点亮和延时，流水灯的原理就很好懂了。就是给P2的所有端口赋值为：1111 1110，每次只有一个为0即点亮，这个点亮的0从最高位逐渐降到最低位。

取反后即为：

1000 0000

0100 0000

0010 0000

0001 0000

0000 1000

0000 0100

0000 0010

0000 0001

也就是一个移位运算，0x01<<i的循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include "reg52.h"
# define LED P2
void delay(unsigned int i){
	while(i--){}
}
void main()
{
    while(1)
    {
			int i=0;
			for(i;i<8;i++){
				LED=~(0x01<<i);
				delay(50000);
			}
    }
}

移位函数

位运算的移位操作只能补0，但是 Keil C51 软件内有对应的移位库函数，左移_crol_()，右移_cror_()，包含在 intrins.h 库中。

移位函数会把移出去的位补到空位，一个循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include "reg52.h"
#include "intrins.h"
# define LED P2
void delay(unsigned int i){
	while(i--){}
}
void main()
{
    LED=~(0x01);
	delay(50000);
    while(1)
    {
			LED=_crol_(LED,1);
			delay(50000);
    }
}

蜂鸣器实验

蜂鸣器简单地说，就是电磁线圈和磁铁对振动膜的作用。

单片机的是无源蜂鸣器，不能一直充电，需要外部控制器发送震荡信号，可以改变频率产生不同的音色、音调。

大多数有源蜂鸣器则没有这个效果，有源蜂鸣器外观与之相同，内部自带震荡源，接上电就能响，但不能改变频率。

我们知道三极管的作用是不用单片机自己直接驱动单片机。

另一种方法是步进电机。

ULN 2003，高电压 高电流驱动器，给信号就被驱动。IN 取反输出 OUT。

简谱

首先整个谱大概分为几个区。大字组、小字组、小字1组、小字2组。每个组之间差8度，每相邻的两个键（如黑白）差半音，相邻的两个同色键差一个全音。

几个白键的表示方法就是下面的简谱，差半音的黑键用左上角的#表示升半音，b表示降半音。

演奏两大要素：音高和时值。

谱上一个数字是1/4 音符，二分是其两倍，数字加个横线 - 。全音符就是（2 - - -）。这个线叫增时线。

八分是其1/2，数字下加一条线（2）.再/2就再加一条，叫减时线。

试着识一个完整的谱：

4/4：以四分音符为一拍，每小节有四拍。

第二节 $\dot{1}$ · 上面的点我们知道代表高音，后面的点代表：前一位音符延长1/2长度，即四分音符+1/2的四分音符。也就是3/8哈哈哈。

看第一节，一般连着两个八分音符就把 underline 连起来。但是这种哪怕是一个音，中间也要先断开再重响。比如右上角的3 3。

升音和降音在本小节中有效。如第三行的 7 #4 4 7 ，两个4都是升音。

不过如果顶端画了延音线，就是连起来的不用断开。如中间的 $\widehat{7 7}$，拆开写是为了好读谱。

接下来就是如何把谱转化为单片机代码。左上角 1=c 说明是c调的。d大调会出现黑键，c调只有白键。

音具体是怎么定义的？首先以中音a为基准，高音a是其2倍，低音a是其1/2。

中间每次升音都是等比数列递增的，即*2的1/12次方

使用蜂鸣器

响起来很简单：不断反转 P1^5 口（是不是这个口得看自己的板子型号）。

1
2
3
4
5
6
7
8
9
10
11
12
13

void main()
{
	u16 i=2000;//决定时值
	while(1){
		while(i--)
		{
			BEEP=!BEEP;
			delay10Us(100);//决定音高
		}
        i=2000;
        BEEP=0;
	}
}

时值还好确认，音高怎么说？

首先我们有上图的音符与频率对照表。我们把频率转化为周期，即1/频率。这里周期单位是us。

然后周期时长转化为机器周期，即记一个数需要的时间。我们看看需要多少机器周期。

1机器周期=12时钟周期，时钟周期=1/单片机晶振。比如对于我的11.0592MHZ 晶振，机器周期=12/11.0592MHZ （单位：us）。

据此把“需要切换的周期时长”转化为“需要切换的周期需要执行几次指令”。即周期/机器周期。如果是12MHZ 晶振这一步相当于没有。

然后电平从低到高，从高到低才是一个周期。所以实际电平反转一次的周期是周期的一半。

我们知道定时器原理是 TH TL 加至65536触发中断。因此重装载值（定时器初值）=65536-取整值。

使用方法：TH=重装载值/256，TL=重装载值%256.

音高从低到高逐位响起代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include "reg52.h"
#include "Delay.h"
#include "Timer0.h"
sbit beep=P1^5;

unsigned int beep_table[]={//可以加个0代表不响的0
	63777,63872,63969,64054,64140,64216,64291,64360,64426,64489,64547,64603,
	64655,64704,64751,64795,64837,64876,64913,64948,64981,65012,65042,65070,
	65095,65120,65144,65166,65186,65206,65225,65242,65259,65274,65289,65303	
};

unsigned char beep_select=0;

void main(){																	 
	unsigned char i;
	timer0Init();
	while(1){
		beep_select++;
		delayMs(50);//时值		
	}
}

void timer0Interrupt() interrupt 1
{
    TH0 = beep_table[beep_select]/256; // 因为触发中断时，TH TL 归零，所以记得赋初值！
    TL0 = beep_table[beep_select]%256;
	beep=!beep;
}

编曲：

根据乐谱写一个数组。

1
2
3
4
5
6
7
8
9
10
11
12
13

unsigned int little_star[]={12, 12, 19, 19,
                            21, 21, 19,    //增时线
                            17, 17, 16, 16,
                            14, 14, 12,
                            19, 19, 17, 17,
                            16, 16, 14,
                            19, 19, 17, 17,
                            16, 16, 14,
                            12, 12, 19, 19,
                            21, 21, 19, 
                            17, 17, 16, 16,
                            14, 14, 12
                           };

遍历数组，得到的音高再去 beep_table 中获取重装载值。

1
2

TH0 = beep_table[little_star[beep_select]]/256; // 因为触发中断时，TH TL 归零，所以记得赋初值！
TL0 = beep_table[little_star[beep_select]]%256;

但是播放起来都是连着的，听起来效果并不好。可以每次播完一个音先关闭中断并延时一段时间，再继续播放。

1
2
3
4
5
6
7

while(1){
		beep_select++;
		delayMs(50);
		TR0=0;
		delayUs(1);
		TR0=1;		
	}

増时线如何处理？中间是不断开一直想的，因此需要几个特定的音符delay时间更长一些。怎么区分哪些音符加长哪些不加呢？

最好还是存储乐谱时搞一个二维数组（逻辑上物理上都可以），既能存储音高，也能存储时值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

unsigned int little_star[]={12, 4,
                            12, 4,
                            19, 4,
                            19, 4,
                            21, 4,
                            21, 4,
                            19, 8,  //增时线
                            17, 4,
                            17, 4,
                            16, 4,
                            16, 4,
                            14, 4,
                            14, 4,
                            12, 8,
                            19, 4,
                            19, 4,
                            17, 4,
                            17, 4,
                            16, 4,
                            16, 4,
                            14, 8,
                            19, 4,
                            19, 4,
                            17, 4,
                            17, 4,
                            16, 4,
                            16, 4,
                            14, 8,
                            12, 4,
                            12, 4,
                            19, 4,
                            19, 4,
                            21, 4,
                            21, 4,
                            19, 8,
                            17, 4,
                            17, 4,
                            16, 4,
                            16, 4,
                            14, 4,
                            14, 4,
                            12, 8,
                            0xFF,4//终止标志防越界
                           };

如果数组大小超限，在魔术棒-Target-Memory Model 中选择第三个。不过这只是治标不治本，因为 RAM 只有512字节所以存不下太长。可以在定义数组时加上关键词 code 来存在 ROM 8K 的闪存中。不过这样的数组是只读的。

当然这样找索引比较麻烦。最好是索引全部重新宏定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

//音符与索引对应表，P：休止符，L：低音，M：中音，H：高音，下划线：升半音符号#
#define P	0
#define L1	1
#define L1_	2
#define L2	3
#define L2_	4
#define L3	5
#define L4	6
#define L4_	7
#define L5	8
#define L5_	9
#define L6	10
#define L6_	11
#define L7	12
#define M1	13
#define M1_	14
#define M2	15
#define M2_	16
#define M3	17
#define M4	18
#define M4_	19
#define M5	20
#define M5_	21
#define M6	22
#define M6_	23
#define M7	24
#define H1	25
#define H1_	26
#define H2	27
#define H2_	28
#define H3	29
#define H4	30
#define H4_	31
#define H5	32
#define H5_	33
#define H6	34
#define H6_	35
#define H7	36

数码管

动态数码管原理是什么？首先我们知道每个数码管都有 abcdefg 七个段。

8个数码管那我们按理来说是需要8*7个引脚，很浪费。

于是设计了动态数码管。首先所有数码管是共阴极的。然后我们选中哪一个数码管阴极赋0，就会启动哪一个数码管，传入的 abcdefg 就会点亮该数码管的对应段。

然后8个数码管像流水灯一样，以极高频率依次点亮，肉眼看到的就是8个数码管都被点亮且呈现出不同的图案。

开发板上的数码管是共阴极数码管，所有位共接一个阴极，给对应ABCDEF输入高电平点亮。

直接引脚：

74译码器使用3位 bit 输入表示8种状态，调整 LED1~8 哪一个输出低电平，代表要启动8个数码管的哪一个的公共端。

输入的三位从最低位到最高位分别是P2^2, P2^3, P2^4，代表数码管从左到右的第几位是输入取反。

比如P2^4=1, P2^3=1, P2^2=0, 输入就是110，取反后就是001，就是从左到右第1位数码管（从第0位开始）。

VCC 和 GND 是使能，接到译码器上一上电就工作。

P00P07 代表控制当前数码管的 ag 显示形式，接到 74HC245 缓冲器上而不是直接接到数码管上，使得单片机不用直接驱动数码管，Ai 连到 Bi 上。

OE 是使能，接地工作不接地不工作的原理。

DIR 是规定方向，高电平从左边读取数据传输到右边。低电平从右边读数据到左边。开发板上有个 J21 跳线帽，可以调整是 GND 与 LE 相连还是 VCC 与 LE 相连，也就是高电平输入 DIR 还是低电平输入 DIR。

数码管上面的 COM 是公共端，选中哪一个公共端（使得其=0，因为是共阴极）就是调整哪一个数码管的点亮方式。

点亮一位数码管代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include "reg52.h"
#define Display P0 
unsigned char display_code[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
/*具体显示什么图案是怎么推算出来的呢？首先 abcdefg 和 dp 小数点段一共有8个要控制的段。
比如我们要呈现数字6，就是 acdefg 亮，b和小数点不亮。
因为数码管是共阴极，所以我们想让哪个段亮哪个段就输入高电平，和 LED 相反。
所以P00~P07 的输入应该是 1011 1110
然后我们直接给 P0 赋值的话，是 P0_7 在最高位，P0_0 在最低位，所以输入应该正好反过来，0111 1101，即0x7d。*/
void main()
{
    Display=display_code[0];
    while(1)
    {}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#define SMG_A_DP_PORT P0 //使用宏定义数码管段码口
sbit LSA=P2^2;
sbit LSB=P2^3;
sbit LSC=P2^4;

for(i=0;i<8;i++){
    //这个程序是从左到右显示12345678.当然完全也可以把确定哪一位数码管和确定要显示的数字封装成一个函数，点亮会更方便。
		switch(i){
			case 0: LSC=1;LSB=1;LSA=1;break;//从左往右第0个数码管
			case 1: LSC=1;LSB=1;LSA=0;break;
			case 2: LSC=1;LSB=0;LSA=1;break;
			case 3: LSC=1;LSB=0;LSA=0;break;
			case 4: LSC=0;LSB=1;LSA=1;break;
			case 5: LSC=0;LSB=1;LSA=0;break;
			case 6: LSC=0;LSB=0;LSA=1;break;
			case 7: LSC=0;LSB=0;LSA=0;break;
			break;
		}
		SMG_A_DP_PORT=gsmg_code[i];
		delay_10us(100);
		SMG_A_DP_PORT=0x00;//消影
    //为什么要消影？ 不延时的话动态数码管会反复重复 位选 段选 位选 段选……位选之后不一定及时段选，可能前一位的位选就会赋给后一位。因此需要消影。
}

我们这种动态数码管扫描方式是单片机直接扫描，硬件会简单很多，但是会占据大量的 CPU 时间。有的动态数码管自带显存和扫描电路，只要告诉他要显示什么他会自动扫描显示。

按键

内部有一个金属片，按下后电路接通。

和学习 LED 时类似，所有 IO 口一开始都是高电平，我们给其接地就变成低电平了。

按下按键后一段时间内电平会高低抖动。

1，先设置 IO 口为高电平（由于开发板 IO 都有上拉电阻，所以默认 IO 为高 电平）。

2，读取 IO 口电平确认是否有按键按下。

3，如有 IO 电平为低电平后，延时几个毫秒。

4，再读取该 IO 电平，如果仍然为低电平，说明按键按下。

5，执行按键控制程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include "reg52.h"
typedef unsigned int u16; //对系统默认数据类型进行重定义
typedef unsigned char u8;
//定义独立按键控制脚
sbit KEY1=P3^1;
sbit KEY2=P3^0;
sbit KEY3=P3^2;
sbit KEY4=P3^3;
//定义 LED1 控制脚
sbit LED1=P2^0;
sbit LED2=P2^1;
sbit LED3=P2^2;
sbit LED4=P2^3;
//使用宏定义独立按键按下的键值
#define KEY1_PRESS 1
#define KEY2_PRESS 2
#define KEY3_PRESS 3
#define KEY4_PRESS 4
#define KEY_UNPRESS 0

void delay_10us(u16 ten_us)
{
while(ten_us--);
}

u8 key_scan(u8 mode)
{
	static u8 key=1;
	if(mode)key=1;//连续扫描按键
	if(key==1&&(KEY1==0||KEY2==0||KEY3==0||KEY4==0))//任意按键按下
	{
		delay_10us(1000);//10ms 消抖
        /*另一种消抖的方法：
        if(KEY==0){
        	delay_ms(20);
        	while(KEY==0);
        	delay(20ms);
        }
        这个是针对按下按钮又抬起按钮之后的执行。*/
		key=0;
		if(KEY1==0)
		return KEY1_PRESS;
		else if(KEY2==0)
		return KEY2_PRESS;
		else if(KEY3==0)
		return KEY3_PRESS;
		else if(KEY4==0)
		return KEY4_PRESS;
	}
	else if(KEY1==1&&KEY2==1&&KEY3==1&&KEY4==1) //无按键按下
	{
		key=1;
	}
	return KEY_UNPRESS;
}
void main()
{
	u8 key=0;
	while(1)
	{
		key=key_scan(0);
		if(key==KEY1_PRESS)//检测按键 K1 是否按下
		LED1=!LED1;//LED1 状态翻转
		if(key==KEY2_PRESS)//检测按键 K2 是否按下
		LED2=!LED2;//LED1 状态翻转
		if(key==KEY3_PRESS)//检测按键 K3 是否按下
		LED3=!LED3;//LED1 状态翻转
		if(key==KEY4_PRESS)//检测按键 K4 是否按下
		LED4=!LED4;//LED1 状态翻转
	}
}

矩阵按键

为了减少 IO 口的占用，用4个 IO 口代表行，4个 IO 口代表列。

类似动态数码管快速扫描实现几乎同时点亮的效果，矩阵键盘也是快速扫描。

主要有两种扫描方法

行列式扫描法：每次给某一列赋值为0，然后检测这一列有无按钮按下。

​ 按行扫描：通过设置 P17 16 15 14 中的一个为低电平来选择扫描哪一行。根据 P10 P11 P12 P13 的输入判断是哪一列。但是 P15 口是蜂鸣器，不断反转会响。所以最好还是用按列扫描。

线翻转扫描方法：给所有列赋1，给所有行赋0，先判断在哪一行；然后用同样的方法判断在哪一列。

这里有一点问题就是：本单片机是准双向口输出，每个口既能做输入也能做输出而不用重新配置口线输出状态。其实这样相当于单片机一个引脚输出高电平，直接与另一个为低电平的引脚相连接。不会短路吗？

单片机的处理方法是这样的：内部 VCC 电源还附带一个下拉电阻。低电平的驱动力比高电平强，高电平直接接低电平就会被变为低电平，而不会短路。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116