最终成绩：87 分
考试说明：闭卷形式，选择题 + 程序填空题 + 计算题 + 简答题

CH1 嵌入式系统概述

1、嵌入式系统的定义

以应用为中心，以计算机技术为基础，软硬件可裁剪，适应应用系统对功能、可靠性、安全性、成本、体积、重量、功耗、环境等方面有严格要求的专用计算机系统。

2、嵌入式系统和通用计算机系统的比较（共同点和不同点）、嵌入式系统的特点

共同点：都属于计算机系统，由硬件和软件组成；工作原理相同，都属存储程序机制；从硬件上看，嵌入式系统和通用计算机系统都是由 CPU、存储器、I/O 接口和中断系统等部件组成；从软件上看，嵌入式系统软件和通用计算机软件都可以划分为系统软件和应用软件两类。

不同点：形态，功能，资源，价值，功耗，开发方式。

特点：专用性强、可裁剪性、实时性好、可靠性高、生命周期长、不易被垄断

3、嵌入式系统的架构：冯･诺依曼结构和哈佛结构

冯･诺依曼结构：采用二进制逻辑、程序存储执行以及计算机由五个部分组成（运算器、控制器、存储器、输入设备、输出设备）

哈佛结构（存储器结构）：程序存储器和数据存储器是两个独立的存储器，每个存储器独立编址、独立访问。

4、嵌入式系统处理器：MPU、MCU、DSP、SoC

分别为微处理器 (MPU)、微控制器（MCU，俗称单片机）、数字信号处理器 (DSP) 和嵌入式片上系统（System on Chip ，简称 SoC）

MCU 的特点是集成度高、控制能力强、可靠性强、低功耗、性价比高、系统设计周期短。最大特点是单片化，体积大大减小，从而使功耗和成本下降，可靠性提高。

5、MCU 的基本组成：CPU、时钟、存储器、通用 I/O、定时器/计数器、外设等

单片机的 CPU 由运算器和控制器组成，有运算和控制的功能。单片机的指令代码就是通过 CPU 执行的。

时钟时钟本质上就是固定频率的脉冲信号，为 MCU 工作提供基准时序。时钟频率直接决定了 MCU 的执行速度。

单片机的存储器包括存放代码指令的 ROM（或 Flash），以及存放变量、数据的 SRAM。

通用 I/O 口 (GPIO) 可以当作输入或输出接口。大部分单片机为了减少引脚数量，I/O 口还复用作为其它特殊功能引脚，比如 PWM 输出、捕获输入、串行通信、外部中断输入等。

定时器 / 计数器能够提供精确定时，或者对外部事件进行计数。内部硬件本质是计数器，当计数器脉冲来源是固定频率脉冲时，可通过计数来实现计时。

MCU 常用的外设模块有：模数转换模块 (ADC)、PWM 模块、捕获模块 (CAP)、通信模块等等。不同芯片有不同的外设配置

6、CPU 功能

CPU 有运算和控制的功能。单片机另外增设了 “面向控制” 的处理功能，如位处理、查表、跳转、乘除法运算、状态检测、中断处理等，增强了实用性。

7、总线 BUS：地址总线、数据总线、控制总线

总线是一组相关逻辑信号的集合。不同芯片有不同的总线标准。

地址总线 (Address Bus, AB)：单向，用于传递地址信息。地址线的数目决定了可寻址的存储空间。一根地址线有两种状态，即可以区分两个不同的存储单元，或者说可以寻址两个存储单元；如果有 $n$ 根地址线，则可以寻址 $2n$ 个存储单元。

数据总线 (Data Bus, DB)：一般为双向，用于 CPU 与存储器、CPU 与外设、或外设与外设之间传送数据信息。我们平常说的 8 位、16 位或 32 位单片机，指的就是 CPU 一次能够处理的数据位数，这也决定了单片机数据总线的根数（宽度）。

控制总线 (Control Bus, CB)：是单片机系统中所有控制信号线的总称，用来传递控制信息。

CH2 C2000 系列微控制器及硬件平台

1、F28027 主要资源

32 位 CPU、时钟（40MHz/50MHz/60MHz）、哈佛总线架构、3.3V 单电源供电、外设资源（GPIO、中断 PIE、CPU 定时器、ePWM、eCAP、ADC、SCI、SPI、I2C）

2、引脚。功能复用、引脚有效符号等

F28027 的引脚按其功能进行分类，可以分为 JTAG 接口、Flash、时钟信号、复位引脚、ADC 模拟输入信号、CPU 和 I/O 电源引脚、电压调节控制引脚、GPIO 和外设信号。

3、MCU 硬件功能概述

F28027 有一个 32 位的 CPU 内核（TMS320C28x），主频高达 60MHz，同时它具有 GPIO、模数转换器 ADC、增强型 PWM 模块、增强型捕获模块、串口通信接口、串行外设接口等外设。功能丰富强大，用户可以方便地用它来开发高性能的微控制系统。片内集成了 Flash 存储器，程序可以直接烧写到 Flash 中，实现脱机运行。

4、内存映射（数据空间 / 地址空间，空间大小与地址的转换）

M0 SARAM 和 M1 SARAM 大小均为 1K×16 位，地址范围分别为0x000000 ~ 0x0003FF、0x000400 ~ 0x0007FF。当复位后，堆栈指针指向 M1 块的起始地址，堆栈指针向上生长。M0、M1 可以映射到程序区和数据区。

0x000800 ~ 0x0001FFF 对应外设帧 0，为寄存器映射空间，该空间直接通过 CPU 内存总线访问。

0x006000 ~ 0x0006FFF 对应外设帧 1，为寄存器映射空间，该空间通过 32 位外设总线访问。

L0 SARAM 的大小为 4K×16 位，即可以映射到程序区，也可以映射到数据区。L0 SRAM 地址为双映射，可以映射到0x008000 ~ 0x008FFF，也可以映射到0x03F8000 ~ 0x3F8FFF。

用户 OTP 区的大小为 1K×16 位，地址范围为 0x3D7800 ~ 0x3D7BFF，即可以映射到程序区，也可以映射到数据区。

0x3D7C80 ~ 0x3D7CBF 为内部振荡器和 ADC 模块的校正数据空间。由厂家进行编程，用户不可编程。

0x3D7CC0 ~ 0x3D7CDF 该存储空间保存 MCU 工作模式引导程序。在 MCU 初始化引导时调用引导程序进入相应模式。

0x3D7E80 ~ 0x3D7EAF 预留给 TMX/TMP 系列芯片使用。

0x3D7FFF 保存设备相关信息，对于 TI 28027PT 读取值为 0x00CF。

0x3F0000 ~ 0x3F7FF7 闪存分为四个扇区，每个扇区 8K×16，分别是扇区 D、扇区 C、扇区 B、扇区 A。如果使用代码安全模式，Flash 空间 0x3F7F80 - 0x3F7FF5不能用来保存程序代码或数据，必须将这些区域编程为 0。如果不使用代码安全模式，可以用来保存程序或数据，但是 0x3F7FF0 ~ 0x3F7FF5 s 只能用于保存数据，不能用于保存程序代码。

0x3F7FF8 ~ 0x3F7FFF 128 位密码区。密钥由用户编程时写入闪存。

0x3FE000 ~ 0x3FFFFF BOOT ROM 用于保存 TI 的引导装载程序和 IQ 数学表，在芯片出厂时已经编程好。包含 IQ 数学表、IQ 数学函数、Bootloader 函数、Flash 应用程序接口库、ROM 版本和 ROM 校验和、复位向量和 CPU 向量表几个部分。

0x3FE000 ~ 0x3FFFFF F28027 的 CPU 向量表。在 CPU 向量表中，唯一可以直接使用的是位于0x3FFFC0的复位向量，复位向量保存着 InitBoot 函数的入口地址。

5、时钟信号 SYSCLKOUT

由锁相环模块输出。为了达到节能目的，TI 对时钟提供一种管理机制，每个外设模块都可以对时钟输入进行使能或禁止（CLK ENABLE），只对需要工作的模块提供时钟信号，不工作的模块不提供时钟信号。系统时钟可以再次被处理，生成低速时钟信号 LSPCLK，用于低速外设模块，如 SCI 模块和 SPI 模块。

F28027 提供了四种时钟来源。包括：1、提供外接晶振的接口来实现内部振荡电路的工作；2、直接用外接时钟信号 XCLKIN；3、内部振荡器 Internal OSC1；4、内部振荡器 Internal OSC2。内部振荡器的工作频率是 10MHz，单片机上电复位后默认的时钟来源是 Internal OSC1。

6、看门狗电路（本质是定时器，“喂狗”：0x55AA）

F28027 提供了看门狗模块。该模块本质上是一个计数器，在计数器溢出时，它会产生一个复位信号，来复位 CPU 或者产生看门狗中断。为了不让它产生复位信号，那就需要在计数器溢出前对它清零，俗称 “喂狗”。

时钟源 OSCCLK 经过 512 分频后再进行可编程的预分频 (Watchdog Prescaler)，输出脉冲作为看门狗计数器（Watchdog Counter）的计数脉冲。Watchdog 55+AA Key Detector 是看门狗的 “喂狗” 操作。“喂狗” 时，需要先写入数据 “55” 给寄存器 WDKEY，接着写入 “AA” 给寄存器 WDKEY，硬件就会发出有效的信号 Good Key，用于复位看门狗计数器。

当程序运行出现问题，比如 “死机” 或进入 “死循环”，那么设定的 “喂狗” 程序将无法执行，看门狗计数器将溢出并发出触发信号，通过 Generate Output Pulse 模块输出 512 个时钟周期的低电平信号。

7、片内上电复位 / 欠电压复位

上电复位电路（POR）的目的是在整个上电过程，对器件产生一个有效的复位信号。器件上电过程结束后，欠压复位电路（BOR）对 VDDIO 进行监测，如果使能片内电压稳压器，还对 VDD 进行监测。POR 的电压保护点比 BOR 低。当电压低于相应的保护点时，复位电路把 XRS 拉至低电平引起复位过程。

CH3 微控制器程序设计基础

1、编程语言

机器语言就是用二进制代码表示的计算机能直接识别和执行的一种机器指令集合，每一条机器指令在计算机内部都有相应的电路来完成它，是唯一的计算机能够直接识别和执行的语言。CPU 的所有指令集构成该计算机的指令系统。

汇编语言是面向机器的程序设计语言。由汇编语言编写的程序，计算机无法直接识别，需把汇编语言翻译成机器语言，这种具有翻译功能的程序叫做汇编程序。汇编程序把汇编语言翻译成机器语言的过程称为汇编。汇编语言的指令一般都由操作码和操作数组成，操作码也被称为指令助记符。

机器语言和汇编语言都是低级语言。高级语言是一种贴合人类逻辑思维、便于直观理解的计算机语言，高级语言既接近自然语言又可以使用数学表达式，并且相对独立于计算机，可以跨计算机使用。编译的程序代码通常比用汇编语言设计的程序代码更长、执行更慢。

2、CPU 执行指令 5 个过程：取指令、指令译码、取操作数、执行指令、结果写回

取指令：将指令从程序存储器取出。程序计数器 PC 中的数值指示当前指令在程序存储器中的位置。当一条指令被取出后，PC 中的数值将根据指令长度自动递增，指向下一条指令。

指令译码：指令译码器按照预定的指令格式，对取回的指令进行译码，识别出不同的指令类别以及各种获取操作数的方法。

取操作数：从存储器或者 CPU 寄存器中获取操作数。操作数指出了参与运算的数据或数据所在的地址，而如何得到就由芯片的寻址方式决定。C28x 支持四种基本寻址方式：直接寻址方式、间接寻址方式、堆栈寻址方式、寄存器寻址方式。同时，C28x 还支持一些特殊寻址方式，如数据/程序/IO 空间寻址方式、程序空间间接寻址方式等。

执行指令：完成指令所规定的操作，实现指令的功能。为此，CPU 的不同部分被连接起来，以执行所需的操作。

结果写回：把执行指令阶段的运行结果数据写回到存储器或 CPU 寄存器。

在结果数据写回之后，当条指令执行完毕。CPU 从程序计数器 PC 中取得下一条指令地址，开始新一轮的循环。

为了提高效率，C28x 采用 8 个独立阶段来完成以上 5 个过程。指令以流水线方式执行，在任何时候，最多可以执行八个指令，每个指令处于不同的完成阶段。

3、嵌入式 C 语言：几个特殊保留字（volatile、interrupt）

嵌入式 C 语言的四大要素就是数据及其处理、程序流程控制、函数与中断服务程序以及指针。

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

1
2
3
4
5

volatile int i=10;
int a = i;
...
// 其他代码，并未明确告诉编译器，对 i 进行过操作
int b = i;

interrupt/__interrupt 为编译器扩展的保留字，用于声明中断服务函数（ISR）。ISR 函数必须定义为 void 返回类型，且没有参数。例如：__interrupt void int_handler(void)。编译器会在编译时执行特殊的操作：自动保存和恢复寄存器；生成特殊的中断返回指令 IRET。

CH4 软件架构与 CCS 集成开发环境

1、如何使用结构体指针操作寄存器

结构体指针的定义：

• 第一步：声明结构体类型，结构体类型名为GPIO_Obj。
  结构体成员包含了 GPIO 模块的所有寄存器，结构体成员严格按照寄存器的地址顺序排列，并保留没有用到的地址空间，
• 第二步：声明结构体指针类型，结构体指针类型名为GPIO_Handle。
  typedef GPIO_Obj * GPIO_Handle;
• 第三步：定义结构体指针变量 myGpio。
  GPIO_Handle myGpio;
• 第四步：结构体指针变量初始化。
  myGpio = (void*)GPIO_BASE_ADDR; //GPIO_BASE_ADDR为GPIO模块所有寄存器的首地址0x0000 6F80

接下来，以 GPADAT 寄存器为例介绍寄存器的读写操作方法。

1
2

myGpio->GPADAT = 5; // GPADAT寄存器值设置为5
data = myGpio->GPADAT; // 读取GPADAT寄存器值当前的值,保存到变量data中

2、寄存器位操作

寄存器位操作一般都是通过逻辑 “与” 和逻辑 “或” 来实现的。在对某个位操作的同时不能影响到寄存器的其他位。例如，对GPADAT的GPIO2这个位进行写和读操作：

1
2
3
4
5

myGpio ->GPADAT &= (~((uint32_t)1 << 2)); // 待操作位清零，其他位保持不变
myGpio ->GPADAT |= (uint32_t)1<< 2; // GPIO2位写1
// myGpio ->GPADAT |= (uint32_t)0<< 2; // GPIO2位写0

Bitdata= ((myGpio -> GPADAT >> 2) & 0x0001)；// GPIO2位值保存到Bitdata变量中。

3、软件架构

分为主程序层、应用层、用户模块层和芯片模块层。

TI 公司为各系列 MCU 提供了丰富的固件库函数和技术支持。固件库是一个固件函数包，它由程序、数据结构和宏组成，包括 MCU 所有系统级和外设标准驱动函数 (接口)。对于初学者而言，可以直接调用这些驱动函数，快速实现需要的应用。

用户模块层对 MCU 驱动函数进行封装，完成具体的功能操作。

应用层对用户函数进行封装。

主程序层主要是对 MCU 的初始化配置和应用层功能函数的调用，实现复杂的 MCU 功能。初始化部分包含系统和外设模块配置函数和初始化函数。

CH5 通用输入输出口

1、GPIO 基础知识

GPIO 是微控制器的数字输入输出模块，可以实现微控制器与外部设备的数字交换。数字输入功能主要是将外部设备的开关量信号转换成 CPU 可读取的数字信号 “1”、“0”，从而获知外部设备的运行状态；数字输出功能则是将 CPU 的数字控制信号 “1”、“0” 转换成引脚高、低电平信号，从而实现对外部设备运行状态控制。

GPIO 输出驱动器主要由多路选择器、输出控制和 MOS 管组成。

多路选择器根据用户配置决定该引脚是用于通用 GPIO 还是复用功能输出。通用输出时，该引脚的输出信号来自于 GPIO 输出数据寄存器。复用功能输出时，该引脚输出信号来自于片上外设，并且一个引脚输出可能来自多个不同外设。同一时刻，一个引脚只能使用一种输出功能。

根据数字电路输出电平的 “强弱”，可将 IO 输出分为图腾柱输出（推挽输出 / 推拉输出）、开漏输出、下拉电阻输出 3 种。

图腾柱输出电路输出为强 1，强 0 或高阻态。推挽输出既提高电路的负载能力，又提高开关速度，适用于输出 0V 和 VDD 的场合。输出强 1：上管导通，下管截止，OUTPUT 输出高电平；输出强 0：上管截止，下管导通，OUTPUT 输出低电平；高阻状态：上管截止，下管截止，无影响

开漏输出：与图腾柱方式相比，只有下管受控，上管断开或没有上管。对于与 Vss 相连的 MOS 管来说，其漏级是开路的。当内部输出 “0” 时，下管导通，引脚相当于接地，外部输出低电平；当内部输出 “1” 时，下管截止，由于上管也截止，外部输出既不是高电平，也不是低电平，而是高阻态。如果想要外部输出高电平，必须接有上拉电阻。上拉电阻输出电路为强 0 弱 1 电路。

下拉电阻输出电路为强 1 弱 0 电路。与图腾柱方式相比，只有上管受控，没有下管。

2、C2000 的 GPIO 模块（概述、软件架构）

F28027 有 22 个 GPIO（DIO）、6 个 AIO（与 AD 采样通道共用引脚）；GPIO 引脚分组管理，分为端口 A（由 GPIO0 - GPIO31 组成）、端口 B（由 GPIO32-GPIO38 组成）。

GPIO 引脚与最多 3 种外设功能引脚共用，使用前需要先进行模式选择。

GPIO 引脚可工作在上拉模式或推挽模式。

GPIO 引脚的电气特性：输入时，低电平电压范围为：（Vss-0.3）V ~ 0.8V，高电平电压范围为：2V ~（VDD+0.3）V。输出时，逻辑 “1” 输出的电压最低为 2.4V，逻辑 “0” 输出的电压最高为 0.4V。

CPU 对输入引脚的信号确认有 3 种方式。非同步（异步输入）方式、同步时钟方式、采样窗方式。默认情况下，所有输入引脚信号被设置为同步于系统时钟 SYSCLKOUT。

采样窗方式下，输入信号首先被同步到系统时钟 SYSCLKOUT，然后输入信号状态持续时间达到指定数量周期数时，输入状态才允许改变。

为了限定信号，在固定的周期进行输入信号采样。用户指定采样周期（也称采样间隔时间）是相对于系统时钟（SYSCLKOUT）而言的。

采样的次数可以选择为 3 次采样或者 6 次采样，通过寄存器 GPAQSEL1、GPAQSEL2、GPBQSEL1 和 GPBQSEL2 来设置。当连续 3 次或 6 次信号状态一样，输入状态的改变才会被确认

采样窗口就是输入信号被确认的时间长度。为了让输入限定能够检测到输入的变化，信号电平必须在采样窗口或者更长的时间内保持稳定。GPIO 引脚的输入信号经过限定器后输出信号就对小毛刺 A 进行了滤波。

3、软件思维导图：配置 GPIO 控制 LED 和按键

GPIO 的硬件初始化配置都需要通过 GPIO 的寄存器实现，包括 GPIO 控制寄存器（GPIO Control Registers）和 GPIO 中断
和低功耗唤醒选择寄存器（GPIO Interrupt and Low Power Mode Select Registers）。GPIO 的读写操作通过 GPIO 数据寄存器操作（GPIO Data Registers）。

由于引脚功能的复用性，使用前需要根据硬件系统的资源需求，统筹考虑把引脚当作 GPIO 或其他外设功能。优先考虑并预留外设功能的需求。

步骤 1：配置引脚功能 (GPIO_setMode)。
步骤 2：使能 / 禁止内部上拉电阻 (GPIO_setPullUp)。
步骤 3：配置输入限定 (GPIO_setQualification、GPIO_setQualificationPeriod)。
步骤 4：配置引脚方向 (GPIO_setDirection)。
步骤 5：低功耗唤醒模式唤醒源 (GPIO_lpmSelect)。
步骤 6：选择外部中断源（GPIO_setExtInt）。

CH6 中断系统

1、中断基础知识（中断概念、中断处理过程、中断嵌套）

单片机的中断系统能够加强 CPU 对多任务事件的处理能力。中断是 CPU 对系统发生的某个事件作出的一种反应。引起中断的事件称为中断源。中断源向 CPU 提出处理的请求称为中断请求。发生中断时被打断程序的暂停点称为断点。CPU 暂停现行程序而转去响应中断请求的过程称为中断响应。中断响应的程序称为中断处理程序。CPU 执行有关的中断处理程序称为中断处理。而返回断点的过程称为中断返回。中断的实现通过软件和硬件综合完成，硬件部分叫做硬件装置，软件部分称为软件处理程序。

根据来源不同，中断可分为硬件中断（Hardware Interrupt）和软件中断（Software Interrupt）；根据中断请求能否被屏蔽，中断可分为可屏蔽中断（Maskable Interrupt）和非可屏蔽中断（Non-Maskable Interrupt，NMI）

中断服务程序的入口地址称为中断向量

中断的优先级主要用来描述不同事件的重要程度。如果在执行一个中断时又被另一个更重要的事件打断，暂停该中断处理过程转而去处理这个更重要的事件，处理完毕后再继续处理本中断的过程称为中断的嵌套

程序设计人员可以通过设置相应的中断屏蔽位，禁止 CPU 响应某个中断，从而实现中断屏蔽。但值得注意的是，尽管某个中断源可以被屏蔽，但一旦该中断发生，不管该中断屏蔽与否，它的中断标志位都会被置位，而且只要该中断标志位不被清除，它就一直有效。

MCU 的中断处理过程包括中断请求、中断响应、中断服务、中断返回四个步骤。当外设发出中断请求时，如果从外设到 CPU 的中断使能被允许，那么进入中断响应阶段。由于 CPU 执行完中断处理程序之后要返回被中断的地方继续执行原来程序，因此在执行中断服务程序之前，要把断点处地址和现场进行保护。

单一中断请求时，CPU 暂停正在运行的主程序转而运行中断服务程序，中断处理完毕后运行原程序。当多个中断请求同时挂起且不允许中断嵌套时，CPU 首先处理高优先级中断事件，然后再处理低优先级中断事件，最后返回执行主程序。允许中断嵌套时，大多数 MCU 高优先级中断可以中断低优先级中断服务程序，低优先级中断不能中断高优先级中断服务程序

2、C2000 的中断系统

中断资源包含 1 个非可屏蔽中断 NMI 和 16 个可屏蔽中断（INT1-INT14、RTOSINT、DLOGINT）

可屏蔽中断（INT1～INT12）采用外设中断扩展（PeripheralInterrupt Expansion，PIE）来进行协助管理，定时器 1、2 对应的 INT13、INT14 中断和 NMI 不经过 PIE，直接与 CPU 相连。

PIE 模块参与管理的中断有以下四类：

• TINT0：定时器 0 中断，可屏蔽中断；
• 外部中断：XINT1、XINT2、XINT3；
• 唤醒中断：WAKEINT，包括看门狗和低功耗唤醒；
• 外设中断：SPI、SCI、I2C、EPWM、HRPWM、ECAP、ADC 等。

PIE 最多可管理 96 个独立中断源，这 96 个中断源分成 12 组、每组 8 个，分别对应 CPU 级 12 个可屏蔽中断（INT1～INT12）。96 个中断源具有独立的中断向量，均存储在专用 RAM 中，用户可以修改这些中断向量。

3、PIE 三级中断管理机制

F28027 的中断采用的是 3 级中断管理机制，分别是外设级、PIE 级和 CPU 级。对于某一个具体的外设中断请求，任意一级的不许可，CPU 最终都不会响应该外设中断。

外设模块产生中断事件时，相应外设模块寄存器的中断标志位 IF 被置位，如果对应的外设中断允许位 IE 被使能，则外设就向 PIE 发送一个中断请求。如果外设中断允许位 IE 未被使能，则该中断被屏蔽，不会向 PIE 发送中断请求。外设模块的中断标志位有的会在中断响应后自动清除，有的需要通过软件来清除。外部中断比较特殊，没有中断标志位，如果中断使能允许，外部中断请求信号直接送达 PIE。

PIE 控制器将每 8 个外设或外部中断汇集成 1 个 CPU 级中断。这样对于 96 个外设中断源，就被分成 12 组，分别是 PIE1～PIE12，每一组对应一个 CPU 级中断，即 PIE1 对应 INT1，PIE12 对应 INT12。一旦中断请求被送到 PIE 模块，相应的 PIE 中断标志位 PIEIFRx.y 被置位。如果对应的中断使能位PIEIERx.y=1，那么 PIE 模块将检查相应的 PIE 应答位PIEACKx，确认 CPU 是否准备好响应这个组的中断。如果这个组的 PIE 应答位PIEACKx=0，则 PIE 将该中断请求送至 CPU。如果 PIE 应答位PIEACKx=1，中断请求不会被 PIE 发送给 CPU，直到PIEACKx=0且该中断请求还存在时，PIE 才会将挂起的中断请求发送给 CPU。

软件清除中断应答位PIEACKx；而 CPU 响应 PIE 级中断后，自动清除相应的中断标志位PIEIFRx.y，后者不可通过软件进行清除。

当中断请求从 PIE 发送到 CPU 时，CPU 级的中断标志寄存器IFRx被置位，中断应答位PIEACKx被置位，同组的其他中断请求被挂起。如果IERx=1且中断总开关INTM=0，那么 CPU 将响应这个中断请求并自动清零对应的IFRx标志位

CPU 响应中断请求后，要去处理中断服务程序，这个中断响应过程包括现场保护（中断返回地址、相关寄存器等入栈）和中断服务子程序地址的获取。其中，中断服务子程序地址保存在 MCU 内存单元，这部分内存单元也称为中断向量表。

CH7 CPU 定时器

1、定时器基础知识（本质是计数器、计数方式、定时时间计算）

定时器本质上是一个计数器，该计数器能对固定频率的脉冲进行计数，把时间的计量转化为对脉冲的计数。根据计数方向不同，有增计数、减计数、增减计数三种模式

增计数的工作模式是计数器按加 1 计数，也就是计数器在时钟脉冲的触发下连续加 1。当计数值与预先设置的周期值 PRD 相等时，计数器重新从 0 开始计数，由于计数是从 0 开始的，因此实际的计数周期要多加 1。

减计数的计数方式与增计数相反，计数器从某个初始值开始减 1，减到 0 时回到初始值重新开始。

增、减计数工作模式下定时器的定时时间 T 为：$T=T_{clk} × (PDR+1)$

增减计数模式的计数方向由定时器自动设置，当计数器的值增加到周期值时，计数方向由增计数自动改为减计数，同样，当计数值减到 0 时，计数方向由减计数自动改为加计数。这种工作模式下定时器的定时时间 T 为：$T=T_{clk} × (PDR×2)$

2、C2000 的定时器（3 个定时器、时钟基准 SYSCLKOUT、减计数方式、预分频、周期、定时时间计算）

F28027 有 3 个 32 位的定时器 TIMER0、TIMER1 和 TIMER2，三个定时器均采用减计数工作模式。TIMER0 和 TIMER1 提供给用户使用，TIMER2 提供给实时操作系统使用。时钟基准默认为系统时钟 SYSCLKOUT。

预分频计数器（PSCH:PSC）的触发信号是系统时钟信号（SYSCLKOUT）。每个时钟周期 PSCH:PSC 的值减 1，当 PSCH:PSC 值为 0 后的一个时钟周期，发出脉冲信号（Borrow），该信号作为计数器（TIMH:TIM）的时钟信号，同时触发寄存器 TDDRH:TDDR 的值重新装载到寄存器 PSCH:PSC。

定时器的工作流程是：每经过 (TDDRH:TDDR+1) 个时钟周期计数器（TIMH:TIM）减 1，当计数器 TIMH:TIM 减到 0 后将产生一次中断请求信号送给 CPU。

定时时间：$T=(TDDRH:TDDR+1)×(TIMH:TIM+1)×T_{clk}$

CH8 增强型捕获模块

1、捕获模块基础知识

捕获模块可以捕获 MCU 引脚的电平跳变（上升沿、下降沿），并记录电平跳变的时刻。捕获模块也有对时间的处理，也是通过计数器来实现的。捕获模块可以用于外部事件的精确时间测量。只要被检测信号能够转换为脉冲信号，捕获模块就可以对该脉冲信号进行捕获。

2、计数器工作模式：增计数

3、C2000 的 eCAP（概述、功能（预分频、边沿极性、连续 / 单次模式、事件决策、捕获寄存器、中断控制）

单触发捕获模式：捕获 1-4 个事件后停止捕获
连续捕获模式：循环进行 1-4 个事件的捕获
中断功能：4 个捕获事件都可以触发中断
捕获模式不使用时，eCAP 模块可以配置为单通道 PWM 输出

预分频器可以对输入脉冲信号进行预分频（2-62 分频，2 的倍数），或者直接旁路，不经过预分频器。

边沿极性可以选择上升沿捕获或下降沿捕获。eCAP 模块有 4 个独立的边沿极性选择，每一个分别对应一个捕获事件。

Modulo 4 counter：事件触发计数器，由捕获事件触发计数。计数值只能是 0、1、2、3。

输入信号经过事件预分频（Event prescale）、极性选择（Polarity select）后到达事件决策模块（Event qualifier）。事件决策模块根据捕获模式（Continuous/Oneshot Capture Control）的配置，产生装载捕获寄存器的触发信号（LD1~LD4），把捕获计数器（TSCTR）的当前值 CTR 装载到捕获寄存器中（CAP1、CAP2、CAP3、CAP4）。根据复位配置（CTRRSTx）可输出信号（Delta mode）复位捕获计数器。捕获事件（Capture events）可发出捕获事件中断信号（CEVT）给 PIE。另外，eCAP1~ eCAP4 可通过时钟同步信号（SYNCIn）进行计数器初始值（CTRPHS）的装载。

捕获事件 1 设置为上升沿触发，差分模式，当上升沿捕获时，计数器清 0，开始新的周期计数；捕获事件 2 设置为下降沿触发，绝对值模式，这样 CAP2 即对应高电平的周期值；CAP1 的值对应波形周期值。

eCAP 捕获模式时有 5 个中断事件，即捕获事件 1（CEVT1）、捕获事件 2（CEVT2）、捕获事件 3（CEVT3）、捕获事件 4（CEVT4）、TSCTR 计数器溢出（CTROVF）（计数值从 FFFFFFFF 回到 00000000）。

CH9 增强型脉宽调制模块

1、PWM 基础知识

PWM 是 Pulse Width Modulation 的缩写，即脉冲宽度调制，也就是宽度可调节的方波脉冲。相关的参数：周期、频率和占空比

• 周期 T：输出一次脉冲，即输出一次完整的高低电平的时间
• 频率 f：周期的倒数，即 $f=\frac{1}{T}$
• 占空比 D：一个周期内，脉冲高电平时间与周期的比值（$D=\frac{T_{high}}{T}$）

PWM 信号有两种产生方法：模拟电子方法和数字化方法。

模拟电子方法：由三角波或锯齿波发生器产生高频调制波，经比较器产生 PWM 信号。三角波或锯齿波与可调直流电源比较，产生占空比可调的 PWM 信号；与正弦基波比较，产生占空比按正弦规律变化的 SPWM 信号。

数字化方法（主流）：与硬件构成 PWM 信号类似，数字逻辑将锯齿波发生器等效为一个计数器 Count，将可调直流电源等效为比较点 Compare。数字控制产生 PWM 需要 3 个寄存器：计数器、周期值和比较值。通过配置周期值和比较值就能够产生任意频率、占空比的 PWM 信号。

2、C2000 的 ePWM（TB 子模块、CC 子模块、AQ 子模块、ET 子模块）

时基子模块（TB）功能：每个 ePWM 单元都有一个独立的时基单元，用来决定该 ePWM 模块相关的事件时序。通过同步输入信号可以将所有的 ePWM 工作在同一时基信号下，即所有的 ePWM 级联在一起，处于同步状态，可以看成一个整体。

TB 模块的主要功能：

1. 预分频功能（Clock Prescale）
2. PWM 周期值（TBPRD）
3. 时基计数器 TBCTR
4. 时基时钟同步
5. 时基计数器相位控制

系统时钟预分频后作为 TB 子模块的时钟信号，分频系数由寄存器TBCTL[HSPCLKDIV]和TBCTL[CLKDIV]决定。HSPCLKDIV的值为 x，则如果 x 为 0，则分频系数为 1，如果 x 不为 0，则分频系数为 2x；如果CLKDIV的值为 y，则分频系数为 2y。

PWM 周期值 TBPRD 有两个寄存器：影子寄存器（Period Shadow）和活动寄存器（PeriodActive）。它们具有相同物理地址。由TBCTL[PRDLD]位控制周期寄存器的工作模式：影子寄存器模式 (=0) 或立即加载模式 (=1)。默认情况下 TBPRD 采用影子寄存器模式。在影子寄存器模式下，对 TBPRD 的读写操作是对影子寄存器进行的，只有当 TBCTR=0 时，影子寄存器的值加载到工作寄存器。

时基计数器的计数模式有三种模式，分别是：增计数模式、减计数模式和增减计数模式。在这三种计数模式中，一个有效的 TBCLK，时基计数器变化率为 1。

每个 ePWM 模块的时基时钟 TBCLK 是独立的，它们都是由系统时钟信号 SYSCLKOUT 分频得到。在 CLK 模块中，提供一个同步开关 TBCLKSYNC，当这个开关有效（置位）时，所有工作的 ePWM 模块的时基计数器 TBCTR 同步于 TBCLK 的第一个上升沿。每个 ePWM 模块的分频必须设置一样。

每个 ePWM 模块拥有一个同步信号输入 (EPWMxSYNCI) 和一个同步信号输出 (EPWMxSYNCO)。第一个 ePWM 模块（ePWM1）的同步输入信号是来自芯片的引脚。同步信号还控制关联的捕获（eCAP）模块。同步脉冲信号实现不同 ePWM 模块的同步，而且通过 TBPHS 实现各 ePWM 模块的相位超前和滞后的控制。当同步输入信号发生时，时基相位 TBPHS 装载到时基计数器 TBCTR，装载时刻一致，同步实现。如果 ePWM 模块的 TBPHS 不为零，那么在同步信号作用下，TBPHS 的值就装载进 TBCTR，各个 ePWM 模块就存在计数初值的不同，也就是存在相位差。

CC 子模块主要功能是对 TB 子模块的计数器值 TBCTR 与给定的比较值进行比较，产生比较相等的事件，该事件作为后续 AQ 子模块的触发事件。有两个比较寄存器 CMPA 和 CMPB

它们分别有两个寄存器：影子寄存器和工作寄存器。影子寄存器和工作寄存器具有相同的物理地址。由CMPCTL[SHDWAMODE]或CMPCTL[SHDWBMODE]位控制比较值寄存器的工作模式：影子寄存器模式或立即加载模式。对 CMPA 的写操作是对影子寄存器进行的。在设置的特殊时刻，影子寄存器的值加载到工作寄存器。加载的特殊时刻由CMCTRL[LOADMODE]决定，可以在 CTR=0 时刻、CTR=PRD 时刻或两者都可以。

比较功能子模块可以产生两个独立的比较事件，对于增计数或减计数，在一个 PWM 周期内，比较事件只发生一次。对于增减计数模式，在一个 PWM 周期内，如果比较寄存器的值在 0~TBPRD 之间，在一个 PWM 周期内，比较事件发生两次。

AQ 子模块决定了相应事件发生时应该输出什么样的电平。该模块是基于事件驱动的，可以认为该子模块输入的就是事件，输出的是动作。每个子模块有两路独立输出 EPWMA 和 EPWMB

AQ 子模块的输入事件有 4 种，事件发生时触发 AQ 子模块，分别是：

1. CTR = PRD，计数器寄存器 TBCTR 的值与周期寄存器 TBPRD 相等时；
2. CTR = Zero，计数器寄存器 TBCTR 的值等于 0 时；
3. CTR = CMPA，计数器寄存器 TBCTR 的值等于比较寄存器 CMPA；
4. CTR = CMPB，计数器寄存器 TBCTR 的值等于比较寄存器 CMPB

将计数方向输入给 AQ 子模块，能够把计数比较事件细分为增计数情形的计数比较事件（CAU 和 CBU）和减计数情形的计数比较事件（CAD 和 CBD）。除了以上外部事 件外，还可以用软件强制触发。通过设置寄存器 AQSFRC、AQCSFRC，产生一个软件强制事件。该软件强制事件可以是单次作用，也可以是连续作用。

AQ 子模块控制在触发事件产生时，2 路 PWM 输出 EPWMxA 和 EPWMxB 表现出何种行为。PWM 输出 EPWMxA 和 EPWMxB 可以设置为以下的动作：

1. 置高，EPWMxA 或 EPWMxB 输出高电平；
2. 置低，EPWMxA 或 EPWMxB 输出低电平；
3. 翻转，EPWMxA 或 EPWMxB 输出电平与之前的电平相反；
4. 无动作，EPWMxA 或 EPWMxB 的输出状态不变。

AQ 在硬件上也设计有事件的优先级。在众多事件中，软件强制的优先级始终是最高的。在增减计数下，CTR = CMPB 优先于 CTR = CMPA；增计数方向上，增事件优先于减事件，CTR = Zero 在中间；减计数方向上，减事件优先于增事件，CTR = PRD 在中间

如果是增/减计数，那么就排除减/增计数方向和减/增事件。

死区，通常叫死区时间（dead time），用于避免功率开关控制信号翻转时发生误触发的情况。死区子模块 (DB) 就是起到延时导通的作用。实现的功能有：死区发生器时钟选择、死区时间的设置、输入源选择（DBCTL[IN_MODE]）、极性选择（DBCTL[POLSEL]）、输出模式（DBCTL[OUT-MODE])

死区发生器产生波形上升沿延时 RED 和下降沿延时 FED，它是通过 10 位计数器来实现的。计数器时钟 DBCLK 可以选择为：

• fDBCLK=fTBCLK，即与 TBCLK 同频，称为周期时钟
• fDBCLK= 2×fTBCLK，即为 TBCLK 的 2 倍频，称为半周期时钟

死区时延时间计算公式为：
$FED = DBFED × TTBCLK$
$RED = DBRED × TTBCLK$
其中$TTBCLK$ 是时基时钟 TBCLK 的周期。如果选择半周期时钟，则$TTBCLK$ 也取半。

通过对应开关控制，死区子模块的输入信号是动作限定子模块的输出信号，记为 EPWMxA in 和 EPWMxB in。信号源可以设置为：

• EPWMxA in 作为上降沿和下升沿延时的信号源，该模式是缺省模式。
• EPWMxA in 作为上降沿延时的信号源，EPWMxB 作为下升沿延时的信号源。
• EPWMxA in 作为下升沿延时的信号源，EPWMxB 作为上降沿延时的信号源。
• EPWMxB in 作为上降沿和下升沿延时的信号源。

事件触发与中断管理 (ET) 子模块主要功能有：

• 管理由时基子模块、比较子模块所产生的事件，这些事件可用于产生 PIE 中断 EPWMxINT 和 ADC 转换启动信号 EPWMxSOCA 和 EPWMxSOCB
• 允许软件强制触发中断和启动 ADC 转换
• 通过事件分频机制，灵活设置输出触发事件的频度

可用于 ET 子模块的输入事件信号有：

• CTR=Zero：计数器寄存器的值为 0，TBCTR =0
• CTR=PRD：计数器寄存器的值为 PRD，TBCTR =PRD
• CTR=Zero 或 CTR=PRD：TBCTR = 0 或 TBCTR = period
• CTRU=CMPA：在计数器增计数时，TBCTR=CMPA，CTR_dir=1
• CTRD=CMPA：在计数器减计数时，TBCTR=CMPA，CTR_dir=0
• CTRU=CMPB：在计数器增计数时，TBCTR=CMPB，CTR_dir=1
• CTRD=CMPB：在计数器减计数时，TBCTR=CMPB，CTR_dir=0
• 软件产生的强制事件信号

每个 ePWM 的 ET 子模块拥有的输出事件信号有：

• 1 路 PIE 中断，EPWMxINT
• 2 路 ADC 启动信号，EPWMxSOCA 和 EPWMxSOCB

PWM 周期：$T=(N + 1)×T_{clk}$

占空比与比较值：$T_{high} = CMP + T_{clk}$

3、软件思维导图

引脚配置：

1. 配置引脚功能（GPIO_setMode）
2. 配置引脚方向（GPIO_setDirection）
3. 使能 / 禁止内部上拉电阻（GPIO_setPullUp）
4. 输入配置为异步系统时钟（GPIO_setQualification）

功能配置：

5. PWM 时基时钟关闭（CLK_disableTbClockSync (myClk)
6. PWM 时钟设置（PWM_setHighSpeedClkDiv、PWM_setClkDiv）
7. PWM 计数模式设置（PWM_setCounterMode）
8. PWM 动作限定设置（AQ 模块）
9. 计算 PWM 的周期、周期设置（PWM_setPeriod）
10. 计算 PWM 的占空比、占空比设置（CC 模块）
11. 设置 PWM 死区（DB 模块, 可选项）
12. 设置 PWM 斩波（PC 模块，可选项）
13. 设置 PWM 故障联防（TZ 模块，可选项）
14. PWM 时基时钟开启（CLK_enableTbClockSync）
15. PWM 事件触发与中断管理（ET 模块）

中断事件配置：

16. 中断入口地址注册（PIE_registerPieIntHandler）
17. PWMx 事件中断使能（PWM_enableInt）
18. PIE 级中断使能（PIE_enableInt）
19. CPU 级中断使能（CPU_enableInt）

中断服务程序：

20. 在 PWM 中断服务程序里完成比较点的更新或其他任务
21. 清除 PWM 中断标志位和对应的 PIE 中断应答位 PIEACKx。

CH10 模 / 数转换器

1、ADC 基础知识

模拟数字转换器（Analog to Digital Converter, ADC），也称模数转换器，是将连续变化的模拟信号转换为离散的数字信号的电子器件。因为 CPU 只能处理数字量，所以需要把外部待测量的模拟量转换为数字量

输出量为待测量的电压、电流、温度、压力、流量、速度等物理量，这些物理量先经过传感器变换为电信号，再调制成符合 ADC 模块输入电压范围的电压模拟量，最后送给 ADC 模块转换为数字量，实时控制系统可以对该数字量进行处理

输入的模拟信号在时间上是连续的，而输出的数字信号是离散的。将连续的模拟量转换为离散的数字量通常要经过 3 个步骤：采样保持、量化、编码。

1. 采样是将随时间变化的模拟量转换为在时间上离散的模拟量，保持则将所采样的模拟信号值保持一段时间，以使得后续的量化编码过程中信号值不发生变化。
2. 采样后每个脉冲的幅度仍然是连续的，必须对每个脉冲的幅度进行离散化处理。将采样保持电路输出的电平转换为量化单位的整数倍的过程称为量化。
3. 把量化的结果用二进制表示出来叫做编码。

ADC 的主要性能参数有量程、分辨率、精度、转换时间、量化误差、偏移误差等。除此之外，其他指标还有：绝对精度、相对精度、微分非线性、单调性和无错码、总谐波失真和积分非线性等等。

量程是指 ADC 所能转换的模拟输入电压的范围，分为单极性和双极性两种类型。

量化时需要把电平转换为量化单位的整数倍，因为模拟电压是连续的，它不一定能被量化单位整除，因而不可避免地会存在量化误差。AD 分辨率越高，量化误差越小。一般是 1 个或 0.5 个最小数字量的模拟变化量，表示为 1LSB 或 0.5LSB

分辨率（Resolution）：指 ADC 能分辨的最小模拟输入量。从理论上来讲，n 位输出的 ADC 能区分 2n 个不同等级的输入模拟电压，能区分输入电压的最小值为满量程输入的$\frac{1}{2^n}$。

精度（Accuracy）：精度是指对于 ADC 的数字输出（二进制代码），其实际需要的模拟输入值与理论上要求的模拟输入值之差。

转换时间（Conversion time）：ADC 完成一次 AD 转换所需要的时间，是指从启动 ADC 开始到获得相应数据所需要的时间。一般来讲，ADC 的分辨率越高，转换时间就越长。

偏移误差（Offset Error）：模拟量输入信号为零时，数字量输出不为零的值。

增益误差（Gain Error）：满刻度输出时对应的模拟输入量与理想的模拟输入量之差。

ADC 的主要类型：

• 逐次逼近型 ADC 属于直接式 ADC，其原理可理解为将输入模拟量逐次与 UREF/2、UREF/4、UREF/8、…、UREF/2N-1 作比较，模拟量大于比较值取 1（并减去比较值），否则取 0。逐次逼近型 ADC 转换精度高，速度较快，价格适中，是目前种类最多、应用最广的 AD 转换器

• 积分型 ADC 是一种间接式 ADC，其原理是将输入模拟量和基准量通过积分器积分，转换为时间，再对时间计数，计数值即为数字量。优点是转换精度高，缺点是转换时间较长。

• 并行比较型 ADC 的主要原理是将参考电压分为 $2^N-1$ 个等级（对于 $N$ 位的 ADC），通过 $2^N-1$ 个比较器和输入模拟电压进行比较，比较器的输出状态由触发器存储，经编码器编码，得到数字量输出。速度快，但其分辨率不高。

• 压频变换型 ADC 是一种间接式 ADC，其原理是将模拟量转换为频率信号，再对频率信号计数，转换为数字量。精度高，功耗较低，抗干扰能力强，便于长距离传送，但转换速度较低。

• ∑-Δ 型 ADC 又称为过采样型 ADC，是目前分辨率最高的 ADC。它主要由采样 / 保持电路、模拟低通滤波器、DAC 及数字滤波器构成。大多数的模块都是由数字电路搭建，一些噪声对其的影响很小。

• 流水线型 ADC 的原理是将多级比较网络级联在一起，每一级得到一位数字码。如果需要的是 n 位数字码，则需要比较 n 次。每次输入的信号必须从头传到尾才算完成了一次量化编码。其优点是高速、高精度，低功耗，芯片面积小，同时具有优异的动态特性。

2、C2000 的 ADC（12 位 ADC 内核、量程、SOC）

具有内置双采样保持 (S/H) 的 12 位 ADC 内核

ADC 内核包含一个 12 位转换器，转换器为部分逐次逼近型、部分流水线型。转换器的模拟参考电平可以配置为外部电压基准 (VREFHI/VREFLO)，也可以配置为内部电压基准。

全范围模拟输入：0V 至 3.3V，或者 VREFLO 到 VREFHI

F28027 有 13 个 ADC 引脚可以与外部模拟量相连，分为两组，包括 ADCINA（ADCINA7、ADCINA6、ADCINA4、ADCINA3、ADCINA2、ADCINA1、ADCINA0 等 7 个引脚）和 ADCINB（ADCINB7、ADCINB6、ADCINB4、ADCINB3、ADCINB2、ADCINB1 等 6 个引脚）。在芯片内部，内置温度传感器占用 A5 输入，参考电压 VREFLO 占用 B5 输入，ADCINA5、ADCINB5 和 ADCINB0 没有外接引脚。

ADC 的工作是基于 SOC 控制的，SOC 信号送到 ADC 采样决策辑模块（ADC Sample Generation Logic）进行决策，产生相应的控制信号：通道选择（CHSEL）、采样窗设置（ACQPS）和开始转换触发信号（SOC）。

每个 SOC 可以独立配置：转换的通道、采样窗宽度和选择开始转换的触发源。转换方式灵活：用同一个触发源对不同的通道进行采样；用不同的触发源对不同的通道进行采样；也可以用一个触发源对同一个采样通道进行多次采样的过采样。

输入电路包括通道选择和采样 / 保持电路。ADC 模块输入的通道有 16 个（F28027 只有 13 个，见概述说明），分为 A 组和 B 组，各 8 个。当使用外部参考电平时，电平 VREFHI 占用 ADCINA0 引脚，ADCINA0 不能当作采样输入口。

采样窗的配置信号 ACQPS 来自采样决策模块。ADC 的采样保持电路必须快速准确地跟踪被采样的信号 ADCIN。AD 处理总的时间等于采样时间和转换时间之和。

ADC 触发源用于启动 SOC 配置的通道开始 AD 转换。每个 SOC 的触发源可以配置为以下任意一个事件：

• 软件立即触发
• ePWM 1-4 的 SOCA 和 SOCB
• 外部中断 2，GPIO XINT2
• CPU 定时器 0/1/2 中断
• ADCINT1/2。用 ADC 转换结束中断信号作为触发事件，
• 可以用于通道的连续转换控制。

ADC 转换的结果保存在结果寄存器 ADCRESULTx 中。保存方式是：顺序采样时，SOCx 触发的通道转换结果保存在对应的 ADCRESULTx 中，序号一一对应。对于同步采样，通常只用偶数的 SOCx，该 SOCx 配置的一对通道转换后结果保存在 ADCRESULTx 和 ADCRESULT（x+1）中，分别对应 A 组和 B 组的转换结果。

当多个 SOC 被同时触发时，需要通过优先级来决定哪个 SOC 对应的通道优先被转换。采样优先级有两种模式：Round Robin 模式和具有高优先级的 Round Robin 模式。

• Round Robin 模式：是由 SOC0~SOC15 组成的一个头尾相接，方向固定的循环闭环。优先级由循环指针 RRPOINTER 决定。当前 RRPOINTER 的值表示上一次被转换的 SOC，那么它的下一个 SOC 具有最高的优先级。ADC 模块复位后，RRPOINTER=20h，表示没有 SOC 被转换，那么 SOC0 具有最高优先级。

• 具有高优先级的 Round Robin 模式：该模式可以设置某些 SOC 具有高优先级，这些高优先级的 SOC 可以打断 Round Robin 的循环顺序，优先进行转换。多个高优先级的 SOC，序号低的优先级高。

对应于 16 个独立的 SOCx，有相应的 16 个采样结束信号 EOCx。ADC 模块有 9 个中断输出信号，即 ADCINT1~ADCINT9。任意一个 EOCx 脉冲都可以配置为 ADCINTx 的触发源。

CH11 串行通信接口

1、串行通信的基础知识

MCU 通信的数据是以字节为单位进行传输，其中每个字节包括多个数据位，根据数据位传输方式的不同，MCU 通信可分为串行通信和并行通信。

串行通信定义：字节中的数据一位一位依次传送的通信方式，具有传输信号线少、传输距离远等优点，但传输速度慢。

并行通信定义：字节中的所有数据位同时传送的通信方式，传输速度快，但是所需传输信号线多，适用于近距离通信。

SCI 串行通信仅需接收和发送两根信号线，8 位并行通信则需 8 根信号线。这两种通信方式除了信号线外，还需一根零电位参考线。

根据电平与数据对应的不同形成不同的编码方式，可分成 RZ 编码（Return Zero Code）、NRZ (Not Return Zero Code) 和 NRZI（Not Return Zero Inverted Code）等。

在 RZ 编码中，正电平代表逻辑 1，负电平代表逻辑 0，并且每传输完一位数据信号返回到零电平

与 RZ 编码不同的是，NRZ 编码电平不需要归零，因此只需采用高、低两种电平即可进行数据传输。

NRZI 编码使用信号的翻转代表一种逻辑，信号保持不变代表另外一种逻辑，如 “0” 对应电平翻转，“1” 电平保持不变。

数据在信号线上传输时需要满足一定的规范，才能使得通信双方正确地收发数据。通常以帧（frame）为单位进行数据传输。

从开始位到结束位的时间间隔称为一帧，通常一帧数据包括 1 位开始位、8 位数据位、1 到 2 位的停止位。

异步串行通信过程中，通信双方的发送和接收步调要一致才能保证传输数据的正确接收。因此，通过波特率（Boad Rate）来实现通信双方的步调一致，波特率是用来描述数据传输的速率。常用的波特率有 600、2400、4800、9600、19200、38400、57600、115200、128000 等。通信距离越长的时候通常选用越低的波特率。

在一帧数据中增加一位奇偶校验位用于错误检测。奇校验时，如果数据位 1 的个数是奇数，则校验位为 0；如果 1 的个数为偶数，则校验位为 1。偶校验时，如果数据位 1 的个数是奇数，则校验位为 1；如果 1 的个数为偶数，则校验位为 0。

串行通信根据接线的不同，有单工、半双工、全双工三种传输方式。

• 单工通信：数据传输是单向的，除了地线外，只有一根数据线。
• 半双工通信：数据传输是双向的，但是只有一根数据线，发送和接收不能同时进行。
• 全双工通信：数据传输是双向的，有两根独立的数据线，发送和接收可以同时进行。

2、C2000 的 SCI（波特率、数据帧）

SCI 的波特率由时钟 LSPCLK 和波特率配置寄存器控制。LSPCLK 由系统时钟模块的低速外设时钟预分频寄存器配置，波特率选择寄存器为 16 位寄存器，有 65536 种不同的波特率选择。

假设 16 位波特率配置寄存器配置值为 BRR，则对应的波特率计算方法为：

$Baud=\frac{LSPCLK}{(BRR+1)*8}, 1≤BRR≤65535$
$Baud=\frac{LSPCLK}{16}, BRR=0$

帧格式配置：

• 1 位开始位；
• 1-8 位数据位；
• 1 位地址和数据的识别位（针对地址位方式的多机模式）
• 1 位可选的奇偶校验位
• 1 或 2 位停止位

需要学会画出帧的波形表示。

CH12 实验

总共 4 次实验，代码运行结果需要给老师测试。实验代码可以参考文字辅导材料、视频教程（CCS 软件开发 ---F28027）和 AI。由于是小组形式，因此可以组内外私下交流。老师一般不会要求你解释代码功能，只会让你向他展示运行结果。

建议早测试早结束。大部分人都是将测试积压到后面的课时，导致组内和组间需要竞争测试机会——一次课只有一个半小时，还不算理论教授时间。最极端的情况下，你可能需要和老师单独约定时间测试。

注意基础配置：什么文件在哪个文件夹，各类初始化在哪个文件。在考试中需要回忆得起来，因为有程序填空题。

最终成绩：76 分

考试流程

考试时间 100 分钟，前 60 分钟为论述题回答时间，后 40 分钟为选择题回答时间。选择题使用超星学习通系统，论述题回答结束后也上传一份电子档至学习通。

答题纸左侧为第 1 题答题区域，右侧为第 2 题答题区域。论述题回答时间内，不得使用手机。论述题回答结束时，将回答结果拍照上传至学习通，5 分钟内提交答题纸。

问答题

Q1 什么是马克思主义中国化时代化？

（定义）马克思主义中国化时代化，就是立足中国国情和时代特点，坚持把马克思主义基本原理同中国具体实际相结合、同中华优秀传统文化相结合，深入研究和解决中国革命、建设、改革不同历史时期的实际问题，真正搞懂面临的时代课题，不断吸收新的时代内容，科学回答时代提出的重大理论和实践课题，创造新的理论成果。

（内涵）运用马克思主义的立场、观点、方法，观察时代，把握时代，引领时代，解决中国革命、建设、改革中面临的实际问题；总结和提炼中国实践经验，并上升为理论，以指导新的实践，赋予马克思主义新的时代内涵和实践要求；运用中国人民喜闻乐见的民族语言来阐述马克思主义、使其植根于中华优秀传统文化的土壤之中, 具有中国特色、中国风格、中国气派。准确把握马克思主义中国化时代化的科学内涵，要做到坚持马克思主义和发展马克思主义相统一，要做到同中国具体实际、同中国优秀传统文化相结合。

Q2 如何理解马克思主义中国化时代化是 “一脉相承又与时俱进的关系”？（已考）

一脉相承：都坚持马克思主义基本原理，都立足中国实际
与时俱进：每个理论都回答了不同历史时期面临的主要问题；后一个理论都是对前一个理论的继承、丰富和发展

一方面，毛泽东思想所蕴含的马克思主义的立场、观点和方法，为中国特色社会主义理论体系提供了基本遵循。另一方面，中国特色社会主义理论体系在新的历史条件下进一步丰富和发展了毛泽东思想。

（举一个例子，建议从 “实事求是、群众路线、独立自主” 中选。比如群众路线 -> “三个有利于”（邓）-> “三个代表”（江）-> 科学发展观（胡）-> 习近平思想，论述后面发展的理论如何传承毛泽东思想中的 “群众路线”）

Q3 为什么新民主主义革命属于资产阶级民主主义革命？

近代中国半殖民地半封建社会的性质和中国革命的历史任务，决定了新民主主义革命的性质是资产阶级民主主义革命。新民主主义革命在政治上争取和联合民族资产阶级，在经济上保护民族工商业。它要建立的是无产阶级领导的各革命阶级的联合专政，而不是无产阶级专政。

Q4 说明新旧民主主义革命的区别（“新” 在哪里？）

新民主主义革命处于世界无产阶级社会主义革命的时代，是世界无产阶级社会革命的一部分；革命的领导力量是中国无产阶级及其先锋队——中国共产党；革命的指导思想是马克思列宁主义；革命的前途是社会主义而不是资本主义。

Q5 为什么说 “新民主主义社会是一个过渡性的社会”？（已考）

新民主主义社会不是一个独立的社会形态，而是由新民主主义转变到社会主义的过渡性的社会。

（生产力）新民主主义社会中存在着五种经济成分，其中主要的经济成分是三种：社会主义经济、个体经济和资本主义经济。通过没收官僚资本而形成的社会主义的国营经济，掌握了主要经济命脉，居于领导地位；而以农业和手工业为主体的个体经济，则在国民经济中占绝对优势。新民主主义社会要继续向前发展，就要不断扩大国营经济，同时逐步将资本主义经济和个体经济转变为社会主义经济，使社会主义经济逐步成为我国的经济基础。

（基本纲领）

• 政治上：推翻帝国主义、封建主义和官僚资本主义的反动统治，建立无产阶级领导的，以工农联盟为基础的，各革命阶级联合专政的新民主主义国家。这是过渡形式。
• 经济上：没收封建地主阶级的土地归农民所有，没收官僚资产阶级的垄断资本归新民主主义国家所有，保护民族工商业。
• 文化上：是无产阶级领导的人民大众的反帝反封建的文化，是民族的、科学的、大众的文化。

（主要矛盾）土地改革完成后，工人阶级和资产阶级的矛盾逐渐成为我国社会的主要矛盾。只有解决了这一矛盾，才能使中国社会实现向社会主义的转变。

新民主主义社会是属于社会主义体系的，是逐步过渡到社会主义社会的过渡性质的社会。为了促进社会生产力的进一步发展，为了实现国家富强、民族复兴、人民幸福，我国新民主主义社会必须适时地逐步过渡到社会主义社会。

Q6 为什么进行社会主义改造？

1. 我国有极其广大的个体农业和手工业及在国民经济中占很大一部分比重的资本主义工商业，要求一个相当长的时期改造它们。
2. 经过 1949 年到 1952 年三年的努力，我国已经有了相对强大和迅速发展的社会主义国营经济。这为党提出向社会主义过渡的总路线提供了物质基础。
3. 国内的资本主义力量弱小，发展困难，不可能成为中国工业起飞的基础。
4. 党总结在国民经济恢复时期在老解放区大力推广农业互助组和初级合作社的经验。这也为党提出向社会主义过渡的总路线提供了重要依据。
5. 新中国成立初期，国家在利用和限制资本主义工商业的过程中所积累的经验，成为对资本主义经济进行社会主义改造的最初步骤。
6. 当时的国际形势也有利于中国向社会主义过渡。苏联社会主义的发展已经显示出相对于资本主义的优越性，对我国有重要的借鉴作用。

Q7 为什么不是走资本主义工业化，而是走社会主义工业化道路？

从历史上看，实现工业化有两条道路：一条是资本主义工业化道路，另一条是社会主义工业化道路。

“资本主义道路，也可增产，但时间要长，而且是痛苦的道路。我们不搞资本主义，这是定了的。”——毛泽东

三个 “不”：

• 等不起：资本主义工业化开始于 18 世纪 60 年代英国的产业革命，至 19 世纪后期，主要资本主义国家先后完成了工业化。我国和资本主义国家有上百年的发展差距，不是短时间内可以弥补的。当时的中国必须在比较短的时间内实现自身实力的提升。
• 玩不起：资本主义通过剥削、掠夺实现资本原始积累。我国不可能选择对外侵略，必须依靠自身力量实现工业化。
• 走不起：以美国为首的西方资本主义阵营对我国实施长期封锁、禁运和军事威胁；与之同时，苏联等社会主义国家向我国提供了援助和宝贵经验。当时的时代条件和国际环境的新特点促使中国人民选择走社会主义道路。

Q8 如何理解改革开放前后历史时期关系？

1. 前 30 年在重大挫折中取得了巨大成就，全盘否定前 30 年的历史是极端错误的。毛泽东等开国元勋带领全国人民进行社会主义革命和建设，取得了巨大成绩；前 30 年属于探索时期，出现错误在所难免。
2. 改革开放前后时期是探索、铺垫与继承、发展的关系。改革开放前的社会主义实践探索为改革开放后的社会主义实践探索积累了经验并准备了条件，改革开放后的社会主义实践探索是对前一个时期探索的坚持、改革、发展。
3. 对改革开放前的社会主义实践探索，要坚持实事求是，分清主流和支流，坚持真理，修正错误，发扬经验，吸取教训。

Q9 如何理解国内改革和国外开放的关系？

开放也是改革。对外开放是建设中国特色社会主义的一项基本国策。对外开放之所以重要，是因为历史经验一再告诉我们，关起门来搞建设是不行的，把自己孤立于世界之外是不利的。对外开放，包括对发达国家的开放，也包括对发展中国家的开放，是对世界所有国家的开放。它不仅是经济领域的开放，还包括科技、教育、文化等领域的开放。

改革是开放的基础与内因，国内制度完善、市场统一和营商环境优化，决定了对外开放的深度与能级，为高水平开放提供制度支撑。开放是改革的催化剂与压力测试，通过对接国际高标准经贸规则，引入外部竞争，倒逼国内体制机制创新，破除利益固化藩篱，实现 “以开放促改革”。

Q10 如何理解社会主义市场经济制度中政府和市场的关系？

“计划经济不等于社会主义，资本主义也有计划；市场经济不等于资本主义，社会主义也有市场。”——邓小平

社会主义市场经济理论的要点：一是计划经济和市场经济不是划分社会制度的标志，计划经济不等于社会主义，市场经济也不等于资本主义；二是计划和市场都是经济手段，对经济活动的调节各有优势和长处，社会主义实行市场经济要把两者结合起来；三是市场经济作为资源配置的一种方式本身不具有制度属性，可以和不同的社会制度结合，从而表现出不同的性质。

Q11 为什么说 “改革是中国的第二次革命”？

所谓第二次革命，是与中国共产党领导的第一次革命相对而言的。中国共产党领导的第一次革命把一个半殖民地半封建的旧中国变成了一个社会主义新中国；中国共产党领导的第二次革命，将把一个经济文化比较落后的社会主义中国变成一个现代化的社会主义国家。没有改革，就不可能走出一条建设中国特色社会主义的正确道路，我们的事业就不可能顺利前进。

改革作为一次新的革命，不是也不允许否定和抛弃我们建立起来的社会主义基本制度，它是社会主义制度的自我完善和发展。

现在我们带你讲解一下一个汇编语言程序是怎么写的。x86 汇编语言由语句 (statement) 构成，一条语句可能有以下元素：

7.1 常量整数和常量整数表达式

一个常量整数表示为 [{ + | - }] 数字 { 基数字符 }，例如 -10、11010011b、0A3h。

标识说明：

• [] 的内容是可选的
• { A | B } 说明必须在 A 和 B 中选择一项

基数字符说明了此整数使用的数制，如下表所示：

如果一个十六进制值以字母开头，如 A4，则必须加上前缀 0 以免和变量名混淆。

整数字面量间的运算使用以下运算符：

每个表达式的计算结果必须为可存储为 32 位的整型（0 ~ FFFFFFFF），此结果在编译时确定，运行时不可变。

EQU 指令可以设置符号整数常量，相当于 C 中的 #define，格式为 标识符 EQU 常量整数表达式。EQU 定义的常量在汇编时直接替换为字面量，因此运行时固定不可变。更宽松的版本是 = 指令，允许常量重定义，但依然是汇编时确定，运行时不可更改。

7.2 其他常量

常量实数表示为 [{ + | - }]数字.[数字][指数]，其中[指数]为科学记数法中的 $×10^{n}$ 部分，表示为 E[{ + | - }]integer。2.、-44.2E+05、26.E5 都是合法的十进制实数。常量实数按照 IEEE 浮点数格式转换存储。

编码实数 (encoded real) 以十六进制表示，用 r 结尾。对应的十六进制从 IEEE 浮点数格式的二进制数转换得到，如 +1.0 的 IEEE 浮点数格式为 0011 1111 1000 0000 0000 0000 0000 0000，编码实数表示为 3F800000r

字符和字符串常量以 ''/"" 包围，按照 ASCII 码存储。

7.3 保留字

保留字主要有以下类型：

• 指令助记符，如 mov、add、mul 等
• 寄存器名称
• 汇编器指令
• 类型属性，如 byte 和 word
• 运算符
• 预定义的符号

保留字大小写不敏感，如 MOV 和 mov 是一样的，但预定义符号除外。

7.4 标识符

标识符用于标识变量、常量、函数、标签，有以下规则：

• 长度在 1 ~ 247 之间
• 大小写不敏感（通过汇编器的 -Cp 选项可使之大小写敏感）
• 首字符必须是字母、下划线、@、? 或 $，后续的字符才可以取数字。
  作为建议，请尽量不要以下划线或者 @ 开头，减少违反下一条规则的概率。
• 不能和保留字撞名

7.5 指令

指令在汇编时转换成运行时可执行的语句（机器语言字节）。一条指令包含四个部分：[标签:] [助记符] [操作数] [;注释]

• 标签
  标签用于标识数据 / 代码的位置。

• 助记符
  助记符标识指令功能。

• 操作数
  操作数用于指令数据的输入输出。操作数可以是寄存器 (reg)、内存地址 (mem) 或者整数表达式 (imm)。一条指令可以有 0 到 3 个操作数。
  对于有两个操作数的指令，第一个操作数作为目标操作数 (dest)，第二个操作数作为源操作数 (src)。指令一般修改的是目标操作数。
  对于有三个操作数的指令，后两个操作数作为源操作数执行指令，结果存储到目标操作数。
  常见助记符及其操作数：

  助记符	操作数	说明
  MOV	dest, src	src 的值赋值到 dest
  ADD	dest, src	dest = dest + src
  INC	op	op 递增 1
  DEC	op	op 递减 1
  SUB	dest, src	dest = dest - src
  MUL	op	无符号乘法，结果储存在主寄存器中，即 EAX = EAX * op
  IMUL	dest, src1, src2	有符号乘法，dest = src1 * src2
  JMP	label	无条件跳转至标签位置
  CALL	func	调用函数
  NOP	无	无操作指令，占用 1 字节，常被汇编器用于字节对齐

  Note

  无论何时，我们都建议优先以寄存器作为操作数，然后是常量值，最后才是内存地址标识，因为它们的读取效率是依次递减的。

• 注释
  单行注释以 ; 开头
  多行注释使用 COMMENT 指令，语法为 COMMENT 结束符。从 COMMENT 到第一个结束符之间的代码块将被忽略。

7.6 段式存储

正如 4.2 所述，x86 处理器底层依然属于段式存储模型。在大部分操作系统上，采用的模型和各位在 C/C++ 学的内存布局是一样的。

现在这个阶段，需要我们设置的内存段只有 .data（数据段）和 .code（代码段）。

7.7 示例 1

下面是一个进行加减运算的 MASM 汇编程序，操作数是写死在程序中的。

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

INCLUDE Irvine32.inc

.code
main PROC

a:
mov eax,30000h; EAX = 10000h
add eax,80000h; EAX = 50000h
sub eax,20000h; EAX = 30000h
; jmp a           ; jump to label 'a'
call DumpRegs

exit
main ENDP
END main

我们详细分析一下这个程序。第一部分是汇编器指令：

• INCLUDE Irvine32.inc 调用了教学用库 Irvine32.inc

接下来是代码区，我们在这里写函数代码：

• .code 表示下面的所有代码均属于代码段的内容
• main PROC 定义 main 过程（Procedure，即函数）
• a: 定义了一个标签 a，指向 mov eax, 30000h
• mov eax, 30000h 将十六进制值 30000h 赋值给 eax
• add eax, 80000h 将 80000h 和 eax 的值相加，结果保存到 eax。
• call DumpRegs 调用 Irvine32.inc 的 DumpRegs 函数，作用是打印当前的寄存器数值
• jmp a 表示无条件跳转到 a 指向的代码。由于有个 bug 故注释，注意到了么？
• exit 是系统调用 (system call)，表示程序的退出。注意不要对主函数使用 ret，因为 ret 需要显式调用方
• main ENDP 表示结束此过程的定义
• END main 表示整个源文件结束，并且指定了入口点函数 main。

7.8 数据类型与数据操作

MASM 内建以下数据类型：BYTE, SBYTE（有符号字节）, WORD, SWORD, DWORD, SDWORD, FWORD（六字节）, QWORD, TBYTE（十字节）。主要使用 BYTE, WORD, DWORD, QWORD 类型，可分别简写为 db, dw, dd, dq。

使用 TYPEDEF 可以定义新的类型，包括指针，语法为 类型名 TYPEDEF [PTR] 已注册的类型。已注册的类型包括内建类型和已使用 TYPEDEF 注册过的类型，例如：

1
2

CHAR    TYPEDEF BYTE
PCHAR   TYPEDEF PTR CHAR

使用数据类型在 .data 段定义数据的语法为 [标识符] 类型 [初始化值, ...]

1
2

count dword 114514
homo  word  ?

数据定义时必须有至少一个初始化值，如果不想自己设定，可以使用 ? 表示随机赋值。所有的初始化值，无论其格式，都会被汇编器转换为二进制数据。如果初始化值是有规律重复的，可以使用 DUP (Duplicate) 命令：

1
2
3

BYTE 20 DUP(0) ; 20 字节，均初始化为 0
BYTE 20 DUP(?) ; 20 字节，均随机初始化
BYTE 4 DUP("STACK") ; 20 字节，一个字符串："STACKSTACKSTACKSTACK"

可以有多个初始化值，这实际上就声明了一个数组：

1
2

list  byte  10,20,30,40
      byte  50,60,70,80

数据 10 位于 list 的偏移 0 位置，以此类推。

字符串也是一种数组，但作为例外，每个字节间不都需要逗号分隔。正如各位在 C 中所学的那样，所有的字符串都需要加一个 \0 终止符（当然，是手动的，没有编译器兜底了）。对于多行字符串，只需要一整块字符串的末尾终止即可，如果需要换行，需要使用 0dh, 0ah (CR/LF)：

1
2
3
4

greeting1 BYTE "Welcome to the Encryption Demo program "
          BYTE "created by Kip Irvine.",0dh,0ah
          BYTE "If you wish to modify this program, please "
          BYTE "send me a copy.",0dh,0ah,0

计算数组长度可以使用 $ - Array，例如：

1
2

list BYTE 10,20,30,40
ListSize = ($ - list) ; ListSize = 4

如果是字符串长度，需要减去使用的转义字符的长度：

1
2

hello BYTE "Hello",0
StringSize = ($ - hello) - 1 ; StringSize = 5

注意采用这种方式计算的，表达式必须紧跟在数组之后，因为 ($ - list) 的语义是当前地址 ($) 减去 list 的地址。数据在段内是连续的，因此可以用偏移值计算元素个数。如果中间再插入了其他数据，偏移值就计算错误了。

BYTE 只占 1 字节，因此偏移值 = 元素数。如果是 WORD 等更大的数据类型，就需要除以它的单位长度，例如：

1
2

data WORD 1,1,4,5,1,4
dataSize = ($ - data) / 2 ; $ - data = 12, dataSize = 6

可以在代码段中间夹杂数据段。数据的作用域从声明位置开始：

1
2
3
4
5
6

.code
mov eax,ebx
.data
temp DWORD ?
.code
mov temp,eax

在进行数据的转移时，数据的宽度必须匹配目标寄存器的宽度。由于寄存器的宽度可以 “分割”，会出现数值覆盖 (Overlapping Values) 的情况：

1
2
3
4
5
6
7
8
9
10
11

.data
oneByte BYTE 78h
oneWord WORD 1234h
oneDword DWORD 12345678h

.code
mov eax,0 ; EAX = 00000000h
mov al,oneByte ; EAX = 00000078h
mov ax,oneWord ; EAX = 00001234h
mov eax,oneDword ; EAX = 12345678h
mov ax,0 ; EAX = 12340000h

数值仅覆盖对应位数，而其他位不变。对于有符号数，这种情况更加复杂：

1
2
3
4
5

.data
signedVal SWORD -16 ; FFF0h (-16)
.code
mov ecx,0
mov cx,signedVal ; ECX = 0000FFF0h (+65,520)

明明存储的是负数，结果读 ECX 的时候却读出了正数！除了尽量保证使用 CX，我们也可以先将 ECX 赋值为 FFFFFFFFh，这样数值就是正确的 FFFFFFF0h 了，这被称为符号位扩展 (Sign Extension)。为了简便较小宽度的数据向较大宽度的寄存器的转移， x86 设计了两个指令：

• MOVZX (Move with Zero eXtension)

适用于无符号数，将扩展的位数设置为 0。

• MOVSX (Move with Sign eXtension)

适用于有符号数，将扩展的位数设置为 1。

1
2
3
4
5

.data
byteVal BYTE 10001111b
.code
movzx ax,byteVal ; AX = 0000000010001111b
movsx bx,byteVal ; BX = 1111111110001111b

1
2
3

reg32, reg/mem8
reg32, reg/mem16
reg16, reg/mem8

1

10 00 00 00 30 00

1

10 20 00 00 00 00

你如果还记得 C 语言的话，估计会把交换数据写成三个存储位置的中转交换，但 x86 提供了 XCHG (eXchange data)，可以直接交换数据：

1
2
3

XCHG reg,reg
XCHG reg,mem
XCHG mem,reg

对于两个内存数据的交换，需要使用寄存器中转：

1
2
3

mov ax,val1
xchg ax,val2
mov val1,ax

7.9 操作数和寻址方式

正如我们在 7.5 所述，操作数可以是寄存器、内存地址或者整数表达式。我们将这些操作数分类为：立即数、寄存器和内存，由此得到几种寻址模式：

• 立即数寻址

立即数就是内存中的字面量，因此立即数可以直接写在指令中：

1
2
3
4

mov eax, 10h

; View in Hex:
; B8 10000000

• 直接内存寻址

地址需要解引用以访问对应数据。不过相比直接写地址值，我们一般都使用变量名，因为变量名携带了相对与段基地址的偏移信息。

1
2
3
4
5

mov eax, var1

; Suppose var1 were located at offset 10400h
; View in Hex:
; A1 00040100

1
2

mov eax, var1
mov var2, eax

• 直接寄存器寻址

7.10 示例 2

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

INCLUDE Irvine32.inc

.data
greeting byte "Hello, World!", 0

.code
main PROC
mov  edx, OFFSET greeting
call WriteString

exit
main ENDP
END  main

此处我调用了 Irvine32.inc 的 WriteString 函数。它以 edx 作为参数，接受字符串地址，将含终止符的字符串打印到标准输出。

7.11 基本运算

基本运算指令分为算术运算和逻辑运算。所有运算都会同步修改标志寄存器。

7.11.1 加减运算

INC 和 DEC 指令的作用是对寄存器 / 内存的值递增 (Increase) 和递减 (Decrease) 1，操作数就一个，运算结果保存到操作数上。

ADD 和 SUB 指令分别为加法 (Add) 和减法 (Substraction)，操作数是 dest,src，运算结果保存到 dest，不修改 src

NEG 是取反 (Negate) 指令，就是将寄存器 / 内存的值的符号位取反。

7.11.2 乘除运算

MUL 是无符号数乘法 (unsigned Multiply)，只有一个操作数。AX 寄存器作为被乘数，操作数作为乘数。结果写回低位寄存器，若位数不足则溢出至高位寄存器 (AH / DX)。两个操作数的位数和是结果的位数。

CF 标志用于检查高位进位。

1
2
3

mov al,5h
mov bl,10h
mul bl ; AX = 0050h, CF = 0

IMUL 是有符号乘法 (signed multiply)，可选 1、2、3 个操作数。

一个操作数时，行为类似 MUL；两个操作数时，第一个操作数作为被乘数和目标，第二个操作数作为乘数；三个操作数时，第一个操作数作为目标，第二个操作数作为被乘数，第三个操作数作为乘数。

IMUL 需要注意 CF 和 OF 标志。如果结果的高位不能解释为低位的符号扩展，那么 OF = 1

DIV 是无符号数除法 (unsigned Divide)。除法比较特殊——带余数的整除法。

DIV 只有一个操作数。DX 和 AX 作为被除数，操作数为除数。结果中，商写回低位寄存器，余数写回高位寄存器 (AH / DX)。两个操作数的位数差是结果的位数。

7.11.3 位运算

8. 分支与循环程序设计

默认情况下，CPU 按顺序加载和执行程序。但条件指令会根据 CPU 状态标志的值（Zero、Sign、Carry 等）将控制权转移到程序中的新位置。控制转移分为两种：无条件转移和条件转移。

循环在这里视为分支，因为它也可以使用条件转移指令实现。

8.1 无条件转移

使用 JMP 指令：

1

JMP label

CPU 将自动将 label 转换成偏移值，赋值给 IP 以在新位置执行代码。

JMP 是创建循环的最简单方法，结合标签可以形成一个无限循环：

1
2
3

top:
  ; ...
  jmp top

8.2 条件转移

只有判断标志寄存器的值满足条件时，条件指令才跳转。由于标志寄存器不能直接设定，因此需要搭配 cmp (compare) 或 test 指令使用。

cmp 的底层逻辑是 A - B，用于判断两个数的大小。test 的底层逻辑是 A & B，用于检查特定位数的状态（test A,A 可以判断 A 是否为 0）。两个指令均只修改 FLAGS 寄存器而不破坏元数据。

常见条件转移指令：

其实记忆这些指令并不难，因为它们都是 JMP + 条件缩写的形式。

条件转移可以形成一个有限循环：

1
2
3
4
5
6
7
8
9
10

; ...
mov ecx, a_len
copy:
    mov eax, a[esi]
    mov b[esi], eax
    add esi, 4
    dec ecx
    cmp ecx, 0
    jne copy
; ...

有一个专门的指令 LOOP 同样实现了有限循环，以 ECX 作为循环次数，当其数值减少到 0 时，LOOP 指令就会停止，继续执行下面的指令。

1
2
3
4
5
6
7
8

; ...
mov ecx, a_len
copy:
    mov eax, a[esi]
    mox b[esi], eax
    add esi, 4
    loop copy
; ...

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

.data
count dword ?
.code
mov ecx,100 ; set outer loop count
L1:
mov count,ecx ; save outer loop count
mov ecx,20 ; set inner loop count
L2:
; ...
loop L2

mov ecx,count ; restore outer loop count
loop L1

9. 函数

通俗地说，我们可以将函数（Procedure，本义为过程，有人也称为子程序）定义为一个返回语句结束的语句块。函数是使用 PROC 与 ENDP 指令声明的。它必须被赋予一个合法的标识符。

对于非入口点函数（即 main），使用 RET 作为返回语句：

1
2
3
4

sample PROC
; ...
ret
sample ENDP

函数内标签的作用域仅限于此函数内，这主要影响跳转与循环指令。虽然可以通过标签名后标识 :: 来声明一个全局标签，但这样做容易破坏程序的运行时栈 (Runtime Stack)。关于运行时栈我们会更详细地介绍。

这是一个简单的加法函数，约定参数和返回值都通过寄存器传递，比较简单：

1
2
3
4
5

SumOf PROC
    add eax,ebx
    add eax,ecx
    ret
SumOf ENDP

现在你可以使用 CALL 指令调用函数了！Irvine32.inc 实现了一些简单的输入输出函数。你可以直接打开此文件查看此库声明了哪些函数。

9.1 运行时栈

运行时栈用于存储函数执行期间的必要的临时信息。和数据结构中的 “栈” 一样，运行时栈同样遵循 LIFO 规则。运行时栈通过 ESP 寄存器管理地址。一般来讲，我们不会直接修改 ESP，而是通过 CALL、RET、PUSH 和 POP 指令间接修改。

ESP 永远指向最后一个压入栈的值，即栈顶。这里需要注意一下，在操作系统中，栈是 “向下生长” 的，即栈的地址是从高到低的。每当我们 PUSH 一个值进入栈，ESP 的值会递减，然后将操作数复制到栈里。一个 16 bits 操作数会使 ESP 递减 2，32 bits 则递减 4。PUSH 的操作数可以是寄存器、内存地址或立即数。

POP 会将 ESP 指向的栈内容复制到操作数中，然后递增 ESP。POP 的操作数可以是寄存器或内存地址。

9.2 函数调用

CALL 指令可以让 CPU 跳转到函数内存位置以执行指令。与之配套的是函数内的 RET 语句。

具体来讲，CALL 将返回地址压入栈中，然后将目标函数地址赋值给 EIP。返回地址指向 CALL 的下一条语句。当函数 RET 时，栈中存放的返回地址赋值给 EIP，之后弹出。

因此，对于一个正常的程序，其调用函数前后的堆栈是平衡的，即在 RET 时 ESP 的值应该和 CALL 时返回地址压入后的 ESP 值相等，这样 RET 才能将正确的返回地址写入 EIP。

对于函数的嵌套调用同样如此。每 CALL 一个子函数，对应的返回地址就会压入栈中；系统在同一时间内只会执行位于运行时栈栈顶的那个函数；然后 RET 时不断 “溯源”，直到返回主函数。

9.3 保存和恢复寄存器

现在我们准备写一个更复杂的函数：

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

;----------------------------------------------------
; ArraySum 
;  
; Calculates the sum of an array of 32-bit integers. 
; Receives: ESI = the array offset 
;           ECX = number of elements in the array 
; Returns: EAX = sum of the array elements 
;----------------------------------------------------
ArraySum PROC
push esi ; save ESI, ECX
push ecx
mov eax,0 ; set the sum to zero
L1:
  add eax,[esi] ; add each integer to sum
  add esi,TYPE DWORD ; point to next integer
loop L1

pop ecx ; restore ECX, ESI
pop esi
ret

ArraySum ENDP

此函数通过寄存器传递参数和返回值，不使用特定标识符以提高兼容性。

不过我们不是想聊这个。看这个程序的开头，它将 ESI 和 ECX 的值压入栈中，而返回前又将其 POP 出来。这是大多数修改寄存器的函数的典型做法：始终保存并恢复被函数修改的寄存器，以确保调用者自身的寄存器值不会被覆盖。该规则的一个例外是用作返回值的寄存器，一般是 EAX。

你可以通过 USES 指令让汇编器自动生成这类代码：

1
2
3
4
5
6
7
8
9
10

ArraySum PROC USES esi ecx
mov eax,0 ; set the sum to zero
L1:
  add eax,[esi] ; add each integer to sum
  add esi,TYPE DWORD ; point to next integer
loop L1

ret

ArraySum ENDP

USES 紧跟在 PROC 之后，寄存器列表中间无逗号。

1
2
3
4

ArraySum PROC USES esi ecx
push ebp
mov  ebp,esp
; ...

1
2
3
4
5

push esi
push ecx
push ebp
mov  ebp,esp
; ...

或者使用 pushad 和 popad （ad 代表 All Double）将所有的通用寄存器都 push/pop。

9.4 用栈传递参数

本节开头我们展示了如何用寄存器传递参数。然而，大多数现代语言中函数参数是通过堆栈传递的：在 32 位下，Windows API 的参数也通过栈传递。因此，必须学会如何用栈传递参数。

9.4.1 栈帧

当函数被调用时，运行时栈会预留一块区域，称为栈帧（Stack Frame，或活动记录 Activation Record）。栈帧存放着函数的实参、返回地址、局部变量和保存的寄存器。一个栈帧由以下步骤建立：

1. 传递的实参被压入堆栈。
2. 调用函数，使函数返回地址被推送到栈上。
3. 当函数开始执行时，EBP 会被推送到堆栈上。
4. EBP 设置成和 ESP 相等。从此，EBP 作为函数形参的基址参考。
5. 如果存在局部变量，需要递减 ESP 以预留堆栈上的变量空间。
6. 需要保护的寄存器被推送到堆栈中。

汇编的传参形式有两种：值传参和引用传参。

数组必定使用引用传参，因为值传参代表它需要将每个元素都压入栈。使用 OFFSET 指令。

9.4.2 栈参数的调用和清理

现在我们来一个示例：

1
2
3
4
5
6
7
8

AddTwo PROC
  push ebp
  mov  ebp,esp
  mov  eax,[ebp + 12]
  add  eba,[ebp + 8]
  pop  ebp
  ret
AddTwo ENDP

使用栈传参时，需要将 EBP 压入栈，ESP 由系统自动管理，不需要我们操心。

如果我们调用了 AddTwo(5,6)，即：

1
2
3

push 6
push 5
call AddTwo

那么它的栈结构大概长这样：

如果我们想访问参数，那么用相对寻址。像 [ebp + 12] 这样用表达式引用实参的，我们称为显式栈参数 (Explicit Stack Parameter)。

有一个问题不知道你发现了没有：既然返回地址在实参下面，而当返回地址被弹出时，函数也退出了，那么剩下的实参怎么处理？

很遗憾，操作系统并不会在程序运行过程中自动回收它们。忽略它们？如果只用一层调用还好，但如果是嵌套调用呢？内层函数残留的栈实参在外层函数返回地址的下面，而 ESP 会读取实参作为地址！还记得我们在 C/C++ 所说的吗？标准结局就是内存访问冲突。

清理的理由有了，但怎么清理？POP 可不能把立即数 POP 出去啊。那么，既然栈实参不能物理移除，可不可以直接跳过它呢……

9.4.3 调用约定

调用约定 (Calling Convention) 确定了函数传参的传参形式、压栈顺序、返回值存储和清除栈方式。在 x86 Windows 下有两个主要的调用约定：C 调用约定 (CDECL) 和 STDCALL 调用约定。

C 调用约定和 STDCALL 的压栈顺序一致，即从右到左倒序压栈。而清除栈方式不一样：

• C 调用约定是调用者清除 (Caller Cleanup)，在调用函数 CALL 的下一行对 ESP 进行加法，其值等于被调用函数参数的总大小。
• STDCALL 是被调用者清除 (Callee Cleanup)，给予被调用函数 RET 一个操作数，其值等于被调用函数参数的总大小。此时系统会自动向 ESP 增加值。

STDCALL 可以确保调用者不会忘记清理栈，而 C 调用约定允许可变数量参数。

FASTCALL 使用 ECX 和 EDX 传递前两个参数，之后的参数使用栈传递。

所有调用约定的整数返回值均通过 EAX 返回。

如果压栈参数在寄存器里，将寄存器压入栈，那么由调用者恢复寄存器：

1
2
3
4
5
6

mov ecx,eax
push ecx
push OFFSET Array
call some_func
add esp,4
pop ecx

压栈的参数长度必须为 4 字节（32 bit 下）。如果值传参发现参数长度不是 4 字节，则应该换用引用传参。

9.5 引用传参的使用

引用参数通常使用间接寻址访问。比如将一个数组的引用传递给 ESI：

1
2
3
4
5
6

mov esi,[ebp+12] ; offset of array
mov ecx,[ebp+8] ; array length
; ...
mov [esi],ax ; insert value in array
add esi,TYPE WORD ; move to next element
; ...

9.6 综合示例

对于计科的同学，课程要求就到这里。

函数调用时的具体步骤如下：

1. 主调函数将被调函数所要求的参数，根据相应的函数调用约定，保存在运行时栈中。该操作会改变程序的栈指针。
2. 主调函数将控制权移交给被调函数（使用 CALL 指令）。函数的返回地址（待执行的下条指令地址）保存在程序栈中（压栈操作隐含在 CALL 指令中）。
3. 被调函数会设置帧基指针 ESP
4. 被调函数通过修改栈顶指针的值，为自己的局部变量在运行时栈中分配内存空间，并从帧基指针的位置处向低地址方向存放被调函数的局部变量和临时变量。
5. 如有必要，被调函数会保存希望调用前后保持不变的寄存器值。
6. 被调函数执行自己任务，此时可能需要访问由主调函数传入的参数。若被调函数返回一个值，该值通常保存在一个指定寄存器中 (如 EAX)。
7. 一旦被调函数完成操作，为该函数局部变量分配的栈空间将被释放。这通常是步骤 4 的逆向执行。
8. 恢复步骤 3 中保存的寄存器值，包含主调函数的帧基指针寄存器。
9. 被调函数将控制权交还主调函数 (使用 ret 指令)。根据使用的函数调用约定，该操作也可能从程序栈上清除先前传入的参数。
10. 主调函数再次获得控制权后，可能需要将先前的参数从栈上清除。在这种情况下，对栈的修改需要将帧基指针值恢复到步骤 1 之前的值。

步骤 3 与步骤 4 在函数调用之初常一同出现，统称为函数序 (prologue)；步骤 6 到步骤 8 在函数调用的最后常一同出现，统称为函数跋 (epilogue)。

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

; lab5_2.asm - Watermelonabc 2026/4/18
; 本程序用于求给定有符号数列中，绝对值比目标数 X 更大的最小负奇数
; 若存在，输出此数的绝对值；若不存在，输出 0

include Irvine32.inc

.data
TAB dword 5 dup(?)
datSize = ($ - TAB)/4
X dword 9
Min dword ?

.code

; dword _cdecl getMin(dword* src,dword goal,dword leng) [ebp+8,ebp+12,ebp+16]
; src 地址、goal 和 leng 通过堆栈传参
; 返回值通过 eax 返回，表示 Min 的绝对值

getMin PROC
    push ebp
    mov ebp,esp
    push esi
    push edx
    push ebx
    mov esi,[ebp+8]
    mov ebx,[ebp+12]
    mov ecx,[ebp+16]
    mov eax,0
    mov edx,0
    isMin:
        mov edx,[esi]
        cmp edx,0
        jge notMin ; is below 0?
        and edx,1h
        cmp edx,1
        jne notMin ; is odd number？
        mov edx,[esi]
        neg edx
        cmp edx,ebx
        jle notMin ; is bigger than X?
        cmp eax,edx
        jg notMin ; is bigger than current Min?
        mov eax,edx
        notMin:
        add esi,4
    loop isMin
    pop ebx
    pop edx
    pop esi
    pop ebp
    ret
getMin ENDP

main PROC
    mov esi,OFFSET TAB
    mov ecx,datSize
    input:
        call ReadInt ; read a signed 32 bits integer from console and put into EAX
        mov [esi],eax
        add esi,4
    loop input
    push datSize ; leng
    push X       ; goal
    push OFFSET TAB ; *src
    call getMin
    add esp,12
    mov Min,eax
    call WriteDec ; get an unsigned 32 bits integer from EAX and write to console
    exit
main ENDP

END main

9.7 局部变量

和参数不一样，局部变量是顺序 “入栈” 的。局部变量的值不是 PUSH 入栈的，而是先在栈上用 ESP 预留空间，然后直接向预留的栈空间写入局部变量。比如，一个 C 函数：

1
2
3
4
5

void MySub()
{
  int X = 10;
  int Y = 20;
}

在 x86 汇编中呈现为：

1
2
3
4
5
6
7
8
9
10

MySub PROC
push ebp
mov  ebp,esp
sub  esp,8 ; reserve space for locals in stack
mov  dword PTR [ebp-4],10 ; X
mov  dword PTR [ebp-8],20 ; Y
mov  esp,ebp ; remove locals from stack
pop  ebp
ret
MySub ENDP

栈帧大致表现为：

注意此处由于只保存了 ebp 寄存器，而它又属于栈底，因此直接将 esp 移到 ebp 就好了。如果你还使用了其他寄存器，那么还请你手动清理，再移动。

LEAVE 指令等效于清理局部变量的那两条指令。

如果是一个数组呢？同样预留空间，但是预留的空间应该符合字节对齐，宜大不宜小。并且用 LEA (Load Effective Address) 指令获取地址。OFFSET 对栈上地址没有用：

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

makeArray PROC
  push ebp
  mov  ebp,esp
  sub  esp,32
  lea  esi,[ebp-30] ; load address of myString
  mov  ecx,30
  L1:
    mov BYTE PTR [esi],'*'
    inc esi
  loop L1
  add  esp,32 ; remove the array (restore ESP)
  pop  ebp
  ret
makeArray ENDP

同样有 ENTER 和 LEAVE 指令可以为我们预留局部变量的栈空间。

ENTER 会 push EBP、设置 EBP 和 ESP 相等并减少 ESP 以预留栈空间。它有两个操作数：numbytes, nestinglevel。numbytes 是你希望预留的字节数，nestinglevel 决定了从前一帧复制到新栈帧中的栈帧指针数量。

在这里，我们将 nestinglevel 固定为 0，只修改 numbytes。

LEAVE 没有操作数，它将 ESP 设置为和 EBP 相等并弹出 EBP 以恢复栈。

而 MASM 提供了一个 ENTER 的上位替代指令：LOCAL。它更接近我们使用的参数表：

1
2
3

LOCAL temp:DWORD, SwapFlag:BYTE ; Two locals var: temp and SwapFlag
LOCAL pArray:PTR WORD ; A pointer to a 16 bits integer
LOCAL TempArray[10]:DWORD ; An array of 10 DWORD

AP. CTF 中常见汇编知识

了解了一些基本的汇编指令后，下面我们来看看 CTF 中常见的一些指令：

1. loop 循环指令：

1
2
3
4
5
6
7

mov rax,0
mov rcx,236
s:
add rax,123
loop s
leave
ret

上面的指令执行的是对 123 累加 236 次，从以上代码中我们可以看到，rcx 寄存器保存的是循环次数，loop 指令每执行一次，rcx 的数值就会减少 1，当其数值减少到 0 时，loop 指令就会停止，继续执行下面的指令。

2. 无条件跳转指令：

1
2
3
4

lable:
mov edx,0

jmp lable

无条件跳转指令为 jmp，其意思从字面上就可以看出来，只要是执行到 jmp 这里，无论什么情况，都会直接跳转到 lable 的代码块中继续往下执行指令。

3. 条件跳转：

1
2
3
4
5

lable:
mov ebx,1

cmp ebx,0
je lable

以上代码将 ebx 的值与 0 对比，如果相等，则会跳转到 lable 处，条件跳转指令 je 代表相等则跳转，还有其他与之条件不一样的条件跳转指令，一般条件跳转指令是与 cmp、test 指令混在一起用的。以上代码也可以用 test 来写：

1
2
3
4
5

lable:
mov ebx,1

test ebx,0
jnz lable

test 是逻辑与指令，以上代表的即为 ebx&0，jnz 代表标志位为 0 就跳转，其实现效果与 cmp 相同。

下面是一些常见的条件跳转指令：

下面是一些常见的位运算指令：

• AND：与运算，AND AX,BX 将 AX 与 BX 进行逻辑与运算，并将结果保存到 AX 寄存器中
• OR：或运算，OR AX,BX 将 AX 与 BX 进行逻辑或运算，并将结果保存到 AX 寄存器中
• XOR：异或运算，XOR AX,BX 将 AX 与 BX 进行异或运算，并将结果保存到 AX 寄存器中
• NOT：取反操作，NOT CX 将 CX 进行取反，并将结果保存到 CX 寄存器中
• TEST：逻辑与运算，TEST AX,BX 将 AX 与 BX 进行与运算，并设置标志位，结果不保存

4. 函数传参：

在汇编中，我们有时候需要知道参数被保存在那个寄存器里，这里我列举一般情况：

通常函数的返回值保存在 ax 寄存器里，比如 eax，rax 等； 函数的参数一般按顺序保存在 cx、dx、si 中，在 64 位汇编中，一般按 rcx, rdx, r8, r9, r10, r11, ... 的顺序保存参数。

有时候根据函数调用约定以及编译器和平台的不同，这个储存规律也会发生改变，我们需要根据当时情况动态调整。

5. lea 地址加载：

其使用格式为 lea rdx,[my_var]，将 my_var 的地址而不是内容赋值给 rdx 寄存器。

6. xchg 数值交换指令：

其使用格式为 xchg ax,bx 将 ax 和 bx 的数值交换。

在广外的大学城校区比赛！体育场比 FZU 大太多了，而且貌似别的学校也有类似的规模的体育场所？！太羡慕了

被 Web 学长和 Pwn 队友带飞的一集，我这个 Re 手还是太 fw 了 QAQ

最终没有 AK 零食……

不过居然是一等奖！好欸！^-

基础数据结构

数组 (Array) 占据一块连续的内存，索引和遍历速度快 ($O(1)$)，但其他操作就慢了（插入、删除的时间复杂度是 $O(n)$），大小也不能伸缩

动态数组 (Dynamic Array) 可以随着数据量的增加而扩展（但理论上不能缩小），C++ 的 vector<T> 实现了这个数据结构。但是插入和删除依然很慢。

链表 (linked List) 基于节点 (node) 组成，在内存中一般不连续，C++ 的 list<T> 实现了这个数据结构（双向链表）。链表可以在 $O(1)$ 复杂度下实现插入和删除操作，但访问操作又退化到 $O(n)$ 了，所以很多时候也挺慢 😦

1
2
3
4
5
6

struct Node
{
int data;
Node* pNext;
Node* pPrev;
};

数组的下标只能是非负整数，而散列表 (Hash Table) 可以以任意标识访问元素，因为它是键值对 (key-value pair) 组成的。散列表的查询、插入和删除速度都很快 (理论上是 $O(1)$)。C++ 的 unordered_map<T, P> 和 unordered_set<T> 实现了这个数据结构。两者的不同在于 map 有键值对，是标准的散列表；而 set 没有，更像数学中的 “集合” 概念（既然是集合，那么 set 中的元素都是不重复的）。

注意到 “unordered” 了吗？散列表是不能排序的

先考虑最简单的情况，仅用一个数组来实现哈希表。在哈希表中，我们将数组中的每个空位称为桶 (bucket)，每个桶可存储一个键值对。因此，查询操作就是找到 key 对应的桶，并在桶中获取 value。

如何基于 key 定位对应的桶呢？这是通过散列函数 (hash function) 实现的。换句话说，我们通过散列函数为每个 key 分配（唯一的）桶位。

1
2
3
4

size_t hash(int key)
{
return key % n; // n 为桶的数量
}

散列函数本身也是有运行成本的！

使用上面的散列函数，我们很快遇到一个问题：有好几个 key 指向同一个桶位！我们称之为散列冲突 (Hash Collision)。

散列冲突的一个解决方法是链式地址 (separate chaining)。我们将冲突的键值对通过链表（有时也用 vector<T>）连接起来，输入 key 后先遍历桶，再遍历桶下的冲突链。

队列 (Queue) 和栈 (Stack) 都是关于 push（推入）和 pop（弹出）的数组 / 队列，区别在于队列是先进先出 (FIFO) 的，栈是后进先出 (LIFO) 的。C++ 分别用 queue<T> 和 stack<T> 实现

二叉树 (Binary Tree) 是一个树状数据结构，用于快速搜索、插入和删除。它经常作为散列表的替代，速度稍慢 ($O(\log{N})$)，但使用时是排序好的

堆 (Heap) 是一种二叉树的特例，用数组实现，常用于优先队列 (priority queue)

实践部分

有些算法和数据结构可以直接用标准库的，毕竟这篇是 “功利性质” 的，就没有重复造轮子的必要了。

注意 “数据保证 XX”，这说明我们不需要考虑判断输入的数据是否符合 XX 条件，因为已经保证它符合这个 XX 条件了（系统不会在酒吧里点炒饭的）

考 FZU DS 原题，分为栈、队列、排序、二叉搜索树以及图和路径

CPP “万能” 文件头：<bits/stdc++.h>

下面是 DS 题目与配套的 AC 代码（感谢 LuminaryDawn 整理提供 😃）

另附 .pbs 文件，你可以导入小熊猫 C++ 实现本地自动判题：FZU DS.pbs

如果你想 “背诵”，建议背关键算法的描述，除非你认为自己真的能像背课文那样把一行行代码背下来

实际考试为了降低难度，较简单题的分数是比较高的。
注意 PTA 的补全提示很少，复习时不要依赖 IDE 的补全
如果想通过，总分应该在 50 分以上

表

亚克星上的军队

★实验任务

亚克星上住着许多神奇的生物。其中有聪慧的人族、优雅的精灵、彪悍的野蛮猪、粗鲁的首任驻….有一天，住在湛蓝球上的恶魔们突破空间的封锁入侵这个美丽的星球。为了保卫共同的家园，亚克星各族不得不摒弃前嫌，组成联盟。为了更有利的反击恶魔们的入侵，他们建立了统一的军事指挥中心。在前期，指挥中心会不停的发布军队调动命令，可是，麻烦来了。为了更好的做出决策，指挥中心必须迅速了解己方的各地区的军事力量详情。你能否帮帮这些可怜的种族呢？

每个地区有一个编号（从 1 到 N），如果一个地区有军队的话，这些军队将组成一个军团。指挥中心将发布的命令如下：

U a b:将 b 地区军团的调到 a 地区，从而组成一个新的军团。为了便于管理，每次新加入的军队将按顺序加入到 a 军团后面。数据保证 a 与 b 不相同。

I a x:将一支人数为 x 的军队调到 a 地区。为了便于管理，每次新加入的军队将加入到 a 军团前面。

D a x:将 a 地区中军队人数为 x 的调走。若不存在，则不执行。

Q a：询问 a 地区的具体军事信息（即按顺序输出该军团中每个军队的人数）。

★数据输入

输入第一行为两个正整数 N ,M (2 <= N,M <= 1000)。

接下来 N 行，每行第一个数 K 表示该地区军队的个数 K (1<=K<=100)，接下来 K 个数, 表示各个军队的人数信息 (0<=a_i<2^31)。

接下来 M 行，每行一个操作。

★数据输出

对于每个询问操作，输出一行表示 a 地区具体军事信息，每两个数之间空格隔开，行末无空格。若 a 内无元素，输出 -1。

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

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int main() {
// 基于流的 I/O 优化
// std::cin.tie(nullptr); // 解除关联
// std::ios::sync_with_stdio(false); // 关闭同步

ll n,m; // n: 区域数；m: 操作数
cin >> n >> m;

vector<list<ll>> listt(n); // 存储各区域的军事信息

for (ll i = 0; i < n; i++) {
ll t;
cin >> t; // t: 军队个数
for (ll j = 0; j < t; j++) {
ll temp;
cin >> temp; // temp: 各军队人数
listt[i].push_back(temp);
}
}

for (ll i = 0; i < m; i++) {
char type;
cin >> type;

if (type == 'U') {
ll a,b;
cin >> a >> b;
a--;
b--; // 编号从 1 到 N，减 1 和数组下标对齐
listt[a].splice(listt[a].end(), listt[b]); // splice(a, b) 将 b 的内容转移到 this*，位置为 a
}
else if (type == 'I') {
ll a,x;
cin >> a >> x;
a--;
listt[a].push_front(x); // list 的向前插入
}
else if (type == 'D') {
ll a,x;
cin >> a >> x;
a--;
listt[a].remove(x); // remove() 移除符合特定条件的元素
}
else if (type == 'Q') {
ll y;
cin >> y;
y--;

if (listt[y].empty()) {
cout << "-1\n";
}
else {
bool first = true;
for (auto j : listt[y]) {
if (!first) cout << " ";
cout << j;
first = false;
}
cout << "\n";
}
}
}

return 0;
}

洗盘子

★实验任务

猪妈妈有很多小猪仔，每次吃完饭洗盘子是一个很大的问题。这天猪妈妈想出了一个方法。她让小猪们排成一队，从 2 开始给他们编号。每次排在最前面的不用洗盘子（假设它的编号是 i ），但是，排在它后面的第 i 只 ，2 i 只，3 i 只… 的小猪要洗盘子。让排在最前面以及要洗盘子的小猪出队，然后重复上述过程。那些不用洗盘子的小猪被称为幸运猪（lucky pigs），把它们的编号从小到大排序，现在要问第 n 个幸运猪的编号是多少。

比如说一开始，在最前面的小猪编号是 2，那么它不用洗盘子，出队。在它后面的第 2 只小猪，就是编号为 4 的小猪要洗盘子，编号为 6, 8, 10… 的小猪都要洗盘子，然后它们都出队。其中编号为 2 的小猪就是第一只幸运猪了。接下排在最前面的小猪编号是 3，它是幸运猪，出队。在它后面的第 3 只，就是编号为 9 的小猪要洗盘子，出队。以此类推。

★数据输入

输入第一行为 T ，代表接下去有 T 个询问， 0 < T <=300

接下去有 T 行，每行一个数 n ，0 < n <=3000

★数据输出

对于每个询问输出一行，为第 n 个幸运猪的编号。

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

#include <iostream>
#include <vector>

using namespace std;

int main() {
int T;
cin >> T;

vector<int> luckyPigs;
vector<int> pigs;

for (int i = 2; i <= 100000; i++) {
pigs.push_back(i); // 初始化猪仔编号向量
}

while (luckyPigs.size() < 3000 && !pigs.empty()) { // 限制求解规模
int lucky = pigs[0]; // 每次排在最前面的不用洗盘子
luckyPigs.push_back(lucky); // 编号推入 luckyPigs 向量

vector<int> keep; // 没被叫去洗盘子

for (int j = 1; j < pigs.size(); j++) {
if ((j % lucky) != 0) {
keep.push_back(pigs[j]);
}
}

pigs = keep;
}

while (T--) {
int n;
cin >> n;
cout << luckyPigs[n - 1] << endl;
}

return 0;
}

队列

Rescue the princess

★实验任务

有一天，公主被一个魔王抓走关在一个城堡里面，城堡可以用 N * M 的矩阵来描述，1 < N, M <= 200。监狱由 N * M 个方格组成，每个方格中可能为墙壁，空地，怪物，公主或者是勇士。

现在勇士想去营救公主。他的任务是找到公主。约定，“找到公主” 的意思是到达公主被关的位置。如果勇士想到达某个方格，但方格中有怪物，那么必须杀死怪物，才能到达这个方格。假设勇士只能向上，下，左，右四个方向移动一步。移动一步的需要花费 1 个单位的时间，杀死怪物也需要一个单位的时间。

试着计算勇士找到公主需要多长时间。只能上，下，左，右移动，而且墙壁不能通过。

★数据输入

输入第一行包含 2 个整数 N，M，接下来 N 行，每行 M 个字符：. 代表空地，a” 表示公主，r 表示勇士， # 代表墙壁， x 表示怪物。（测试数据中 a 和 r 只有一个）。

★数据输出

输出一个整数，表示找到公主所需要最短的时间。如果无法找到公主，输出 -1。

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

#include <bits/stdc++.h>

using namespace std;

struct Node {
int x, y, time;
// 重载大于运算符，比较两个 Node 等价于比较两个 Node.time
bool operator>(const Node& other) const {
return time > other.time;
}
};

int main()
{
int n, m;
cin >> n >> m;
vector<string> grid(n);
int start_x=-1, start_y =-1, end_x=-1, end_y=-1;

// 读入地图，初始化坐标
for(int i=0;i< n;i++){
cin >> grid[i];
for(int j=0;j<m;j++){
if(grid[i][j] == 'r'){
start_x = i;
start_y = j;
}
if(grid[i][j] == 'a'){
end_x = i;
end_y = j;
}
}
}

// 方向向量，表示移动方式
int dx[4] = {0, 0, 1, -1}; // 上：-1，下：1
int dy[4] = {1, -1, 0, 0}; // 左：-1，右：1

// 每个格子相对于起点的路径距离（时间成本），初始化为“无穷大”
vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
dist[start_x][start_y] = 0;

// 定义最小堆，堆顶元素必定最小。great 表示大于队尾元素的插入元素进入队尾，否则插入队尾元素之前。最大堆用 less
    // 存储待探索的点，按距离升序排序
priority_queue<Node, vector<Node>, greater<Node>> pq;

// 起点作为第一个待探索点
pq.push({start_x, start_y, 0});

while(!pq.empty())
{
Node curr = pq.top(); // 当前位置
pq.pop(); // 将该点弹出待探索堆。之后此点不再探索
int x = curr.x;
int y = curr.y;
int time = curr.time;
        // 剪枝。这说明你是从较远路径来到这个点的，而根据我们的走法，已经有“人”探索接下来的路了，因此不要重复探索。
if(time > dist[x][y]){
continue;
}
// 向 4 个方向探索
for(int i=0;i<4;i++){
int nx = x + dx[i];
int ny = y + dy[i];
// 探测边界和墙壁
if(nx < 0 || nx >= n || ny < 0 || ny > m || grid[nx][ny] == '#'){
continue;
}
int new_time = time + 1; // 前进 1 步
// 遇怪增加时间
if(grid[nx][ny] == 'x'){
new_time ++;
}
// 如果找到更短路径，则更新路径距离
if(new_time < dist[nx][ny]){
dist[nx][ny] = new_time;
pq.push({nx, ny, new_time}); // 把点推入待探索堆中
}
}
}
if(dist[end_x][end_y] != INT_MAX){
cout << dist[end_x][end_y] << "\n";
}
else
{
cout << "-1" << "\n";
}
}

交易

考了

★实验任务

作为炉石传说的发牌员，你的任务就是发牌。从上到下有 n 张牌，编号 1~n。因为你和选手进行了一次 “交易”，所以当至少还剩两张牌时，发出最上面的牌，第二张牌放到最下面，重复这个过程直到只剩下一张牌。输出发牌的序列和最后剩下的牌。

★数据输入

第一行 1 个正整数 n (1=<n<1000)

★数据输出

输出一行为发牌的序列，一行为最后剩下的牌。两个数字之间用空格隔开，末尾没有空格。

★Hint

第一个样例 n=1, 只输出一行。

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

#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
queue<int> card;
    // 初始化牌堆
for(int i=1;i<=n;i++){
card.push(i);
}
bool isFirst = true;
do
{
if(!isFirst){
cout << " ";
}
        // 输出第一张牌
cout << card.front();
card.pop();
isFirst = false;
        // 第二张牌排到队尾
if(!card.empty()){
int second = card.front();
card.pop();
card.push(second);
}
}
while(card.size() >= 2);
cout << endl;
if(!card.empty()){
cout << card.front();
}
}