华盛顿大学-CSE474-嵌入式系统笔记-全-

华盛顿大学 CSE474 嵌入式系统笔记(全)

001:课程概述

在本节课中,我们将学习嵌入式系统导论课程的整体框架、学习目标、课程结构以及所需的实验设备。我们将了解嵌入式系统的定义、核心概念,以及如何通过本课程的学习成为一名专业的嵌入式软件工程师。

课程简介与目标

我是Blake Hanford,是华盛顿大学电气与计算机工程系的教员。我曾多次教授这门课程的早期版本,虽然最近一次是在大约12年前,但嵌入式系统的核心知识在过去几十年中变化不大。这是因为计算机的基本架构,从几十年前的大型机到今天廉价的微控制器,其底层原理是相通的。

本课程将围绕Arduino硬件生态系统展开。虽然Arduino因其易用性而广为人知,甚至高中生也能用它快速搭建项目,但本课程的目标远不止于此。我们将学习如何从低成本设备中榨取高性能,确保软件高效运行,并满足严格的实时性要求。

课程核心内容

上一节我们介绍了课程的整体目标,本节中我们来看看我们将要学习的核心技能和概念。

以下是本课程将涵盖的关键主题:

  • C语言编程:重点是从Java等语言过渡到C,掌握指针等高级概念。
  • 进程与上下文:理解操作系统的基础,特别是在单核上实现多任务。
  • 调度器:学习如何让计算机决定在特定时刻应该执行哪个任务。
  • 中断与中断服务例程:掌握硬件事件如何高效地触发软件响应。
  • 底层I/O设备控制:超越digitalWrite()这样的高级函数,学习如何直接通过硬件寄存器控制特定的I/O引脚。例如,设置端口D的第3位为高电平的代码可能类似于 PORTD |= (1 << PD3);。
  • 实验室仪器使用:虽然不强制要求示波器等设备,但会介绍如何在家完成实验。

成功学习指南

了解了核心内容后,掌握正确的学习方法同样重要。本节将提供一些确保你在本课程中取得成功的建议。

以下是成功学习本课程的建议:

  • 掌握高级C语言概念:如指针和二进制位操作。
  • 合理管理时间:实验任务具有连续性,前期落后会影响后期进度。
  • 有效团队合作:实验以两人小组进行,需要明确分工和良好沟通。
  • 重视实验报告:清晰沟通是工程师的核心技能,请认真完成实验报告。
  • 充分利用资源:遇到困难时,及时向教师和助教寻求帮助。
  • 坚持阅读与预习:跟上课程进度,提前准备。

实验安排与评分

本课程的学习成果主要通过实验来体现。本节我们将了解实验的具体安排、团队合作方式以及评分标准。

实验部分是本课程的重中之重。我们将完成四个实验,它们会逐步增加复杂度:

  1. 实验一:Arduino开发环境入门,控制LED和蜂鸣器。(个人完成)
  2. 实验二:硬件数字I/O与输出时序。
  3. 后续实验将引入更复杂的实时调度和系统集成。

实验以两人小组形式进行(实验一除外)。评分基于扁平积分制:完美完成所有任务可获得450分,对应4.0的绩点。教师保留根据整体学习情况对最终成绩进行微调的权利,以确保评分公平地反映学习成果。

示例项目:酸奶机温度控制器

为了让大家对嵌入式系统的实际应用有一个直观感受,我将分享一个自己构建的项目——酸奶机温度控制器。

我每周需要制作一加仑酸奶。传统方法繁琐,因此我设计了一个基于Arduino的自动温度控制器。该系统需要让牛奶经历三个阶段:

  1. 加热阶段:全功率(250W)加热至95°C。
  2. 冷却阶段:关闭加热,自然冷却至40°C。
  3. 发酵阶段:使用PID控制器和脉宽调制技术,将温度精确维持在40°C。

PID控制器的输出u(t)由误差e(t)(设定温度与实际温度之差)决定,其公式为:
u(t) = Kp * e(t) + Ki * ∫e(t)dt + Kd * de(t)/dt
其中Kp、Ki、Kd是需要调节的参数。系统通过继电器控制加热器通断,利用热敏电阻测量温度,并在LCD屏上显示状态。

这个项目涵盖了本课程的许多核心概念,如底层I/O控制、定时、传感器数据读取和算法实现。虽然其时间尺度较慢(以分钟或小时计),但我们在课程中将处理毫秒甚至微秒级的硬实时任务。

总结与设备准备

本节课中我们一起学习了嵌入式系统导论课程的概貌、核心学习目标、实验安排以及一个生动的实际应用案例。

我们了解到,本课程旨在培养专业的嵌入式软件开发技能,重点在于底层硬件控制、实时系统设计和高效C语言编程。实验是课程的核心,需要团队协作和持续投入。

关于实验设备,课程将提供详细的物料清单。核心是Arduino Mega 2560开发板。此外,建议准备数字万用表、22 AWG实芯导线、剥线钳等工具。如果存在经济困难,可以联系教师获取部件支持。我们将在下节课详细讨论设备清单。

下节课我们将更深入地探讨实验室的具体细节和所需设备。现在,课程结束。

002:C编程导论

在本节课中,我们将要学习C语言编程的核心概念,特别是理解数据在计算机内存中的表示方式,以及如何使用指针来操作内存地址。这对于嵌入式系统编程至关重要,因为我们需要直接与硬件寄存器进行交互。

概述:数据在内存中的表示

上一节我们介绍了课程的基本信息。本节中,我们来看看C语言如何将我们编写的代码转换为计算机内存中实际的0和1。理解这一点是掌握C语言高级特性,尤其是其与硬件交互能力的关键。

与解释型语言不同,在C语言中,像 int x = 5; 这样的语句,不仅声明了一个变量,还决定了在内存的特定位置存储哪些二进制位。当我们进行嵌入式系统编程,控制像Arduino Mega 2560这样的硬件时,我们实际上是在操作芯片内部寄存器中的一个个“开关”(即0和1),以开启、关闭或配置硬件功能。

整数与字符的存储示例

假设我们声明一个16位的整数:

int c_int_variable = 17;

在内存中,这个变量会占据两个字节(16位)。数字17的二进制表示为 0000 0000 0001 0001(16 + 1)。

接下来,我们声明一个字符数组(字符串):

char char_array[] = “OK”;

C编译器会将字符‘O’和‘K’转换为它们对应的8位ASCII(或UTF-8)码,并顺序存储在内存中。需要注意的是,在C语言中,一个真正的字符串必须以空字符(\0,即8位全0)结尾,这样函数才知道字符串在哪里结束。

内存中的每个字节都有一个唯一的地址,就像房子有门牌号一样。变量名通过符号表与这些地址关联起来。

指针:内存地址的抽象

理解了内存地址后,我们来看看指针。指针是C语言中一个强大且必要的工具,它允许我们直接操作内存地址,这对于访问硬件寄存器尤为重要。

指针的声明与赋值

声明一个整型指针:

int *my_int_ptr; // 声明一个指向整数的指针,未初始化

这个指针变量本身用于存储一个内存地址,而不是一个整数值。我们可以让它指向之前定义的整数变量:

my_int_ptr = &c_int_variable; // & 是“取地址”运算符

现在,my_int_ptr 中存储的是变量 c_int_variable 的内存地址,而不是数字17。

解引用指针

解引用操作是使用指针获取其指向地址中存储的值:

int x = *my_int_ptr; // * 在这里是“解引用”运算符

如果 my_int_ptr 指向存储着17的内存,那么 x 的值就是17。解引用运算符 * 与声明指针时的 * 含义不同,前者是操作符,后者是类型说明符。

指针算术运算

指针可以进行加减运算,但其增减的单位取决于它所指向的数据类型的大小。

int *pa = (int*)0x3000; // 假设这是一个有效的整型地址
pa++; // 指针递增

如果 int 类型占4个字节,那么 pa++ 会使地址值增加4,指向下一个整数所在的内存位置,而不是下一个字节。这种特性使得遍历数组变得非常方便。

实践:通过代码理解指针

为了巩固概念,我们运行了一段示例代码来探索指针和类型转换。

  • sizeof 运算符:用于获取数据类型或变量在内存中所占的字节数。
  • 指针值的打印:指针本身的值(地址)可以打印出来。需要注意的是,直接打印可能得到负数,这是因为系统将高位解释为符号位。将其转换为无符号整数(unsigned int)可以正确显示地址值。
  • 类型转换(Casting):我们可以改变数据的解释方式。例如,将指针强制转换为整数类型,就可以看到其地址的数值。
  • 运算优先级:(int)pa + 1 和 (int)(pa + 1) 的结果截然不同。前者先将地址值转为整数再加1;后者先将指针移动一个int单位,再将新地址转为整数。

数组与指针的关系

在C语言中,数组和指针关系密切。数组名在很多情况下可以当作指向其第一个元素的指针来使用。

int arr[3] = {5, 6, 7};
int *ap = arr; // 等价于 int *ap = &arr[0];

我们可以通过指针算术来访问数组元素:*(ap + 2) 等价于 arr[2]。

高级指针概念

通用(Void)指针

通用指针(void *)是一种可以指向任何数据类型的指针,但它不能直接进行解引用操作,因为编译器不知道它指向的数据类型。在使用前,必须将其转换为具体的指针类型。

void *generic_ptr;
int value = 3;
generic_ptr = &value; // 合法
// int y = *generic_ptr; // 错误!不能解引用void指针
int y = *((int*)generic_ptr); // 合法,先进行类型转换

空指针

空指针(NULL)是一个不指向任何有效内存地址的指针,通常定义为0。在函数中使用指针前检查它是否为 NULL 是一种良好的错误预防实践。

if (input_ptr != NULL) {
    // 安全地使用指针
} else {
    // 错误处理
}

函数指针

指针甚至可以指向函数。这在嵌入式系统中非常有用,例如,可以根据不同的系统状态(如白天、夜晚、雾天)动态选择要执行的任务函数。

int some_function(int arg) { return arg * 2; }
int (*func_ptr)(int); // 声明一个函数指针
func_ptr = &some_function; // 指向函数
int result = (*func_ptr)(5); // 通过指针调用函数,result 为 10
// 简写方式:int result = func_ptr(5);

我们将在实时操作系统的任务调度中广泛使用函数指针。

总结

本节课中我们一起学习了C语言编程的核心基础。我们从数据在内存中的二进制表示开始,深入探讨了指针的概念——包括指针的声明、赋值、解引用和算术运算。我们还了解了数组与指针的紧密联系,以及通用指针、空指针和函数指针这些高级但重要的概念。掌握这些知识,特别是理解内存地址和指针操作,是进行高效、强大的嵌入式系统开发的基石。在接下来的课程中,我们将把这些概念应用到实际的Arduino硬件编程环境中。

003:C语言中的指针

在本节课中,我们将深入学习C语言中一个核心且强大的概念:指针。我们将探讨指针的声明、赋值、算术运算,并通过代码示例来巩固理解。

概述

指针是C语言中用于存储内存地址的变量。理解指针对于高效地进行内存操作、数组处理和函数调用至关重要。本节我们将从基础概念开始,逐步深入到指针算术和函数指针等高级主题。

指针声明与赋值

指针的声明需要指定它所指向的数据类型。例如,int *ptr; 声明了一个指向整数的指针。指针的赋值则是将一个内存地址赋给它。

以下是声明和赋值指针的示例:

int *intPtr = NULL; // 声明一个整数指针并初始化为NULL
int value = 10;
intPtr = &value; // 将value的地址赋给intPtr

函数指针

上一节我们介绍了普通指针,本节中我们来看看一种特殊的指针:函数指针。函数指针指向一个函数,其声明包含了函数的返回类型和参数列表。

声明一个函数指针的语法如下:

int (*funcPtr)(); // 指向返回int且无参数的函数的指针
double (*anotherPtr)(int, char); // 指向返回double,参数为(int, char)的函数的指针

以下是函数指针的赋值和调用示例:

int realFunction() {
    return 42;
}
int (*funcPtr)() = NULL; // 初始化为NULL
funcPtr = &realFunction; // 赋值
int result = (*funcPtr)(); // 调用函数,等价于 result = funcPtr();

指针算术

指针算术允许我们对指针地址进行加减运算,这在遍历数组时非常有用。允许的操作包括:

  • 给指针加/减一个整数。
  • 两个指针相减(得到它们之间的元素距离)。

不允许的操作包括:

  • 两个指针相加。
  • 指针与指针相乘或相除。
  • 指针与浮点数进行算术运算。

以下是一个使用指针算术寻找数组中点的例子:

#define SIZE 100
int buffer[SIZE];
int *start = buffer; // 指向数组起始
int *end = buffer + SIZE; // 指向数组末尾(最后一个元素之后)
int length = end - start; // 数组长度(元素个数)
int *midpoint = start + (length / 2); // 指向数组中点

指针比较

我们可以使用比较运算符(如 ==, !=, <, >)来比较两个指针。这通常用于判断两个指针是否指向同一内存位置,或者比较它们在内存中的相对位置(地址高低)。

代码实验与互动

为了加深理解,我们将通过一些实际的代码片段进行实验。以下是几个关键概念的演示:

字符数组与字符指针的等价性

在C语言中,字符数组和字符指针在初始化字符串时常常可以互换使用。

char *name1 = "Blake Hanford";
char name2[] = "Blake Hanford";
// 上述两种方式在效果上通常是等价的

字符串复制与缓冲区操作

以下代码演示了如何手动将一个字符串复制到缓冲区,并强调了字符串以空字符\0结尾的重要性。

char buffer[100] = {0}; // 初始化缓冲区为0
char *source = "Kamala H.";
int i;
for (i = 0; source[i] != '\0'; i++) {
    buffer[i] = source[i];
}
buffer[i] = '\0'; // 手动添加字符串终止符
printf("%s\n", buffer); // 正确打印 "Kamala H."

指针算术实践

通过以下互动问题,我们可以测试对指针算术的理解:

char data[] = "hello, my name is Joe";
char *ptr = &data[0];
// 问题1: *(ptr + 5) 的值是什么?
// 答案:',' (因为从'h'开始,向后移动5个字符)
// 问题2: *(ptr + 6) 的值是什么?
// 答案:' ' (空格字符)

实验一介绍

在课程的后半部分,我们简要介绍了第一个实验(Lab 1)的目标。该实验要求你:

  1. 安装并设置Arduino IDE开发环境。
  2. 构建并运行一个基本的示例程序(如让板载LED闪烁的Blink程序)。
  3. 修改该程序(例如改变LED闪烁的频率),并演示其功能。

实验的重点是熟悉嵌入式开发的基本流程和工具链。

总结

本节课我们一起深入学习了C语言中的指针。我们从指针的基本声明和赋值开始,探讨了函数指针的用法,并详细讲解了指针算术的规则与限制。通过实际的代码示例和互动练习,我们巩固了如何通过指针操作数组和字符串。理解这些概念是进行高效C语言编程和后续嵌入式系统开发的重要基础。

004:数字表示与位运算符

在本节课中,我们将学习C语言中数字的表示方法,以及如何使用位运算符直接操作数据的二进制位。这对于嵌入式系统编程至关重要,因为我们需要与硬件寄存器进行精确的交互。

概述:数字表示基础

上一节我们介绍了C语言的基本结构,本节中我们来看看计算机如何表示数字。计算机内部使用二进制(0和1)来存储和处理所有数据。为了便于人类阅读和编写,我们通常使用十六进制或八进制来表示这些二进制数。

  • 二进制:基数为2,每位是0或1。例如,1011₂。
  • 十六进制:基数为16,用数字0-9和字母A-F表示。在C语言中,以0x为前缀,例如 0x2DA。
  • 八进制:基数为8,用数字0-7表示。在C语言中,以0为前缀,例如 023。

转换示例:0x2F 的十进制值为 2 * 16 + 15 = 47。

使用符号常量提高代码可读性

在代码中直接使用“魔数”(如 0x2DA)会降低可读性和可维护性。专业的做法是使用 #define 预处理器指令定义符号常量。

代码示例:

#define CDROM_CONTROL_REG 0x2DA
#define CDROM_DOOR_OPEN 0x10
io_reg_set(CDROM_CONTROL_REG, CDROM_DOOR_OPEN);

这种方式使代码意图更清晰。如果硬件地址改变,只需修改 #define 一处即可。

位运算符

C语言提供了直接操作整数中各个二进制位的运算符,这对于控制硬件寄存器中的特定位非常有用。

以下是主要的位运算符:

  • 按位与 (&):两个操作数对应位都为1时,结果位才为1。常用于“掩码”操作,检查或清除特定位。
    • 公式:result_bit = a_bit & b_bit
  • 按位或 (|):两个操作数对应位有一个为1时,结果位就为1。常用于设置特定位。
    • 公式:result_bit = a_bit | b_bit
  • 按位取反 (~):将操作数的每一位取反(0变1,1变0)。
  • 按位异或 (^):两个操作数对应位不同时,结果位为1。
  • 左移 (<<):将操作数的所有位向左移动指定的位数,右侧空位补0。左移n位相当于乘以2ⁿ。
    • 示例:x << 2 将 x 的二进制位左移两位。
  • 右移 (>>):将操作数的所有位向右移动指定的位数。对于无符号数,左侧空位补0;对于有符号数,行为可能依赖于编译器(算术右移或逻辑右移)。右移n位通常相当于除以2ⁿ(向下取整)。

代码示例:

unsigned int x = 0x0B; // 二进制 1011
unsigned int y = 011;  // 八进制,二进制 1001
unsigned int bit3 = 0x08; // 二进制 1000

unsigned int z = x << 2;   // z = 101100 (二进制)
unsigned int check_bit = y & bit3; // check_bit = 0 (检查y的bit3是否为1)
z = z | 0x10; // 设置z的bit4为1

注意:区分逻辑运算符(&&, ||, !)和位运算符(&, |, ~)。逻辑运算符用于布尔表达式,返回真(1)或假(0);位运算符对整数的每一位进行运算,返回一个新的整数。

整数类型:有符号与无符号

在C语言中,整数类型的大小(位数)取决于编译目标平台。例如,在Arduino上,int 通常是16位,而在现代PC上是32位或64位。

  • 无符号整数 (unsigned int):所有位都用于表示数值大小。范围是 0 到 2ⁿ - 1(n为位数)。例如,16位无符号整数的范围是0到65535。
  • 有符号整数 (int):最高位(最左侧的位)用作符号位(0表示正,1表示负),其余位表示数值大小。范围是 -2ⁿ⁻¹ 到 2ⁿ⁻¹ - 1。例如,16位有符号整数的范围是-32768到32767。

选择正确的类型很重要,它影响数值范围、溢出行为以及某些位运算的结果。

二进制补码表示法

计算机使用二进制补码来表示有符号整数。这种方式使加法和减法运算可以使用同一套硬件电路。

将一个数转换为它的二进制补码(即取其负数)的规则是:

  1. 按位取反所有位。
  2. 将结果加1。

公式:-x = ~x + 1

示例:用8位表示 -23。

  1. +23的二进制:00010111
  2. 按位取反:11101000
  3. 加1:11101001 这就是 -23 的二进制补码表示。

这种表示法的优点是,x + (-x) 会自然溢出为0(在有限的位数内),并且减法 a - b 可以计算为 a + (-b)。

打印二进制值的函数

C标准库的 printf 没有直接打印二进制的格式符。我们可以自己编写一个函数,利用位运算符来逐位检查并打印。

代码示例:

void bin_display(unsigned int x) {
    int i, j;
    for (i = 0; i < 16; i++) { // 假设处理16位
        j = 1 << (15 - i); // 创建一个只在第(15-i)位为1的掩码
        if (x & j) {
            printf("1");
        } else {
            printf("0");
        }
    }
    printf("\n");
}

这个函数从最高位到最低位,依次检查并打印每一位是0还是1。

总结

本节课中我们一起学习了C语言中数字的底层表示和操作。我们回顾了二进制、十六进制和八进制系统,强调了使用 #define 定义符号常量以提高代码质量的重要性。我们深入探讨了强大的位运算符(&, |, ~, <<, >>),它们允许我们直接操控数据的特定位,这是嵌入式系统编程的核心技能。我们还区分了有符号和无符号整数类型,并解释了计算机如何使用二进制补码高效地表示和处理负数。最后,我们了解了如何编写函数来显示整数的二进制形式。掌握这些概念是进行底层硬件编程和优化性能的关键基础。

005:硬件与机器组织 🖥️

在本节课中,我们将要学习计算机硬件的基本组织架构,特别是冯·诺依曼架构的核心组件。我们将了解CPU、寄存器、总线如何协同工作,并通过一个有趣的“修复《2001太空漫游》中舱门故障”的编程示例,学习如何通过C语言直接操作硬件寄存器。

计算机基本组织架构

上一节我们介绍了嵌入式系统的基本概念,本节中我们来看看计算机硬件的核心组织方式。

寄存器与总线

寄存器是用于存储一组比特的硬件单元。与内存不同,寄存器通常与系统其他部分有直接的硬件连接,其值可以直接控制或反映硬件状态。一个寄存器可以由多个D触发器构成,在时钟信号触发时,输入值被锁存到输出端。

公式示例: 一个D触发器的行为可以描述为:Q(t+1) = D(t),其中Q是输出,D是输入,t代表时钟周期。

总线是CPU内部或CPU与外部设备之间传输数据的通道。一个典型的系统包含三种总线:

  1. 地址总线:由CPU驱动,指定要访问的内存或设备位置。
  2. 数据总线:双向传输,用于在CPU和选定位置之间传递数据。
  3. 控制总线:传输同步和控制信号,协调读写操作。

地址比较器是总线系统中的关键组件。它持续监控地址总线上的值,当该值与预设的设备地址匹配时,会输出一个信号,从而“选中”该设备进行后续的数据读写操作。

总线时序与三态逻辑

CPU通过精确的时序与设备通信。在一个写周期中,CPU先将地址和数据放到总线上,待信号稳定后,发出一个控制脉冲(如写使能信号)。地址匹配的设备会在此脉冲下锁存数据总线上的值。

在一个读周期中,CPU先发出地址和读脉冲。被选中的设备随后将数据放到数据总线上,供CPU读取。

多个设备共享同一条数据总线时,需要解决输出冲突问题。这通过三态逻辑门实现。除了输出高电平(1)和低电平(0),三态门还有第三种状态:高阻抗状态(High-Z)。在此状态下,输出端相当于断开连接,不会影响总线。通过控制逻辑确保同一时刻只有一个设备输出有效数据,其他设备处于高阻态,即可实现总线的共享。

代码示例: 在C语言中,我们通过读写特定内存地址来模拟对硬件寄存器的操作,这背后就是通过总线周期实现的。

中央处理器内部结构

了解了外部通信方式,现在我们深入CPU内部,看看指令是如何被执行的。

一个简化的CPU包含以下核心部件:

  • 算术逻辑单元:执行加、减、比较、移位等运算。
  • 参数寄存器:为ALU提供操作数。
  • 结果寄存器:存储ALU运算的结果。
  • 通用寄存器:用于高速存储中间计算结果。
  • 程序计数器:指向下一条要执行的指令地址。
  • 指令寄存器:存放当前正在执行的机器指令。
  • 解码与控制单元:解析指令,生成控制信号来协调所有部件工作。

执行一条简单的C语句 c = a + b; 需要多个步骤:CPU先从内存中读取变量a和b的值到参数寄存器,然后ALU执行加法,结果存回内存中变量c的位置。每一步都对应着特定的机器指令。

机器指令与汇编语言

机器指令是二进制代码,由操作码和操作数组成。操作码指定要执行的操作(如加、减、移动数据),操作数指定操作涉及的数据或数据位置。

汇编语言是机器指令的文本助记符形式,比二进制更易于人类编写和阅读。不同的寻址模式(如直接寻址、间接寻址、变址寻址)提供了灵活的数据访问方式。

代码示例: 实现 c = a + b 的汇编伪代码可能如下:

MOVE [address_of_a], A1  ; 将内存中a的值移到ALU参数寄存器1
MOVE [address_of_b], A2  ; 将内存中b的值移到ALU参数寄存器2
ADD                      ; ALU执行加法
MOVE R, [address_of_c]   ; 将结果寄存器的值存回内存c的位置

输入/输出编程模型

CPU需要与外部世界交互。主要有两种I/O编程模型:

  1. 独立I/O:拥有独立的I/O地址空间和专用的IN/OUT指令。Intel处理器常用此模型。
  2. 内存映射I/O:将硬件设备的寄存器映射到内存地址空间中。读写这些特定地址就相当于操作硬件寄存器。Arduino采用的正是这种模型,它简化了编程,在C语言中可以通过指针直接访问设备寄存器。

实战:操作硬件寄存器

现在,我们将运用所学知识,为一个虚构的“太空舱舱门控制系统”编写驱动代码。假设我们有三个8位硬件寄存器来控制舱门A、B、C。

以下是控制寄存器A的位定义示例:

位 名称 功能
1:0 DMode_A 设置舱门A模式 (00:保持, 01:自动关闭, 10:自动开启, 11:紧急停止)
3:2 DMode_B 设置舱门B模式
5:4 DMode_C 设置舱门C模式

我们的任务是编写一个函数,可靠地打开指定舱门并返回。关键在于不能影响寄存器中其他控制其他舱门或功能的位。

位操作技巧

直接给寄存器赋值(如 PBD_CR = 0x02;)会覆盖所有位,这是错误的。正确的方法是使用位操作,只修改目标位。

我们需要编写一个辅助函数,用于安全地设置和清除特定位:

代码示例: 一个安全的位设置/清除函数

unsigned char bit_set_clear_8(unsigned char hw_register, unsigned char set_val, unsigned char clear_val) {
    unsigned char temp_val = hw_register; // 读取当前值
    temp_val |= set_val;                  // 设置set_val中为1的位
    temp_val &= ~clear_val;               // 清除clear_val中为1的位
    // 注意:此处set_val和clear_val中用1标记要操作的位
    return temp_val; // 返回新值,需要写回寄存器
}

使用这个函数,我们可以精确地设置舱门A为“自动开启”模式(设置bit1,清除bit0),而不影响其他位。

打开舱门函数的逻辑步骤如下:

  1. 使用bit_set_clear_8函数,将目标舱门的模式位设置为“自动开启”。
  2. 设置对应舱门的“启动”位,触发动作。
  3. 循环读取舱门状态寄存器,等待“正在移动”位变为0(表示移动停止)。
  4. 检查舱门密封状态位,确认已完全打开并密封。
  5. 返回成功代码。如果等待超时,则返回错误代码。

总结

本节课中我们一起学习了计算机硬件的核心组织架构,包括寄存器、总线和CPU的基本工作原理。我们重点掌握了内存映射I/O模型,并学习了如何通过C语言进行精确的位操作来安全地控制硬件寄存器,而不影响其他无关位。这是嵌入式系统编程的基础技能,在后续课程中操作定时器、串口等具体硬件时将会反复运用。通过修复“舱门故障”的趣味示例,我们将抽象的理论与实践联系了起来。

006:第6讲 - 串行通信与USB

在本节课中,我们将学习嵌入式系统中两种关键的通信方式:传统的串行通信(RS-232)和现代的通用串行总线(USB)。我们将了解它们的工作原理、协议细节以及在实际应用中的差异。

概述:从比特到字节的旅程

通信是嵌入式系统的核心。系统很少孤立运行,通常需要与其他设备交换数据。我们将从最基本的一位一位发送数据的串行通信开始,逐步深入到更复杂、更高效的USB协议。

串行通信基础:RS-232标准

上一节我们概述了通信的重要性,本节中我们来看看最经典的串行通信标准——RS-232。它虽然古老,但其核心思想影响了后续许多通信协议。

RS-232通过改变导线上的电压来发送信号。逻辑0和逻辑1由特定的电压范围定义:

  • 逻辑0(Space):+3V 至 +15V
  • 逻辑1(Mark):-3V 至 -15V

这种较大的电压摆幅提供了良好的抗噪声能力。线路空闲时,保持在Mark状态(负电压)。

数据帧格式

一个完整的数据帧包含以下部分,按顺序发送:

  1. 起始位:一个逻辑0(Space)位,标志数据传输开始。
  2. 数据位:通常是8位数据,从最低有效位(LSB)开始发送。
  3. 奇偶校验位:一个用于错误检测的位(可选)。
  4. 停止位:1或2个逻辑1(Mark)位,标志帧结束。

接收器检测到起始位的边沿后,会等待半个时钟周期,然后在每个位时间的中心进行采样,以确保读取的稳定性。这种通信是异步的,意味着数据帧可以在任何时间开始,接收端需要自行同步时钟。

奇偶校验:简单的错误检测

奇偶校验位用于检测传输过程中的单比特错误。发送端计算数据位中“1”的个数:

  • 如果“1”的个数为奇数,则奇偶校验位设置为 1(奇校验)。
  • 如果“1”的个数为偶数,则奇偶校验位设置为 0(偶校验)。

接收端重新计算接收到的数据位的奇偶性,并与接收到的奇偶校验位比较。如果不匹配,则表明传输过程中可能发生了错误。其核心是一个对数据位进行异或运算的过程。

公式:Parity = D0 XOR D1 XOR D2 ... XOR D7

奇偶校验只能检测奇数个比特错误,无法纠正错误,也无法检测偶数个比特错误。

通信参数与模式

以下是配置串行通信时需要协商的几个关键参数:

  • 波特率:数据传输速率,单位是比特每秒(bps)。例如,9600波特率意味着每秒传输9600比特。
  • 通信模式:
    • 单工:数据只能单向传输。
    • 半双工:数据可以双向传输,但不能同时进行。
    • 全双工:数据可以同时双向传输。

传统的RS-232使用DB-9或DB-25连接器,涉及许多控制信号线(如RTS、CTS用于硬件流控制),配置复杂。现代系统通常简化为只使用TX(发送)、RX(接收)和GND(地)三根线。

高级错误控制与数据包

对于更可靠的数据传输,仅靠奇偶校验是不够的。通常会将多个字节组合成数据包,并采用更强大的错误检测方法:

  • 校验和:将数据包中所有字节的值相加,取结果的低8位或低16位作为校验值。
  • 循环冗余校验:一种基于多项式除法的更强大的错误检测码。

一个典型的数据包结构包括:

  1. 包起始标识符
  2. 地址/类型字段
  3. 数据长度字段
  4. 数据载荷
  5. 错误校验码(如CRC)

为了确保数据可靠送达,通常使用自动重传请求协议:接收方校验数据包后,会向发送方回复ACK(确认)或NAK(否认)。发送方只有在收到ACK后才会发送下一个数据包,如果收到NAK或超时未收到回复,则会重传当前数据包。

现代标准:通用串行总线

了解了串行通信的基础后,我们来看看为解决RS-232复杂性问题而设计的现代标准——USB。USB的设计目标是易于使用、低成本、高速度且高度标准化。

USB系统架构

USB采用主机-设备的树形拓扑结构:

  • 主机:通常是计算机的CPU,负责管理整个USB总线。
  • 集线器:用于扩展USB端口。
  • 功能设备:提供具体功能的设备,如鼠标、键盘、打印机。

一个功能设备可以包含多个端点,每个端点是设备上一个独立的数据发送或接收点。例如,一个鼠标可能有分别传输X轴移动、Y轴移动和按钮状态的端点。

USB通信协议

USB通信是基于时间片的。主机以1毫秒为周期发送帧起始包,来同步总线上的所有设备。通信由主机完全控制,采用轮询机制。主机向特定设备的特定端点发送包含PID(包标识符)、地址和端点号的请求包,然后设备响应数据。

USB定义了四种数据传输类型,以适应不同需求:

  • 控制传输:用于设备配置、命令和状态查询。优先级最高。
  • 批量传输:用于大容量、非实时数据(如打印机、扫描仪)。无带宽和延迟保证,但数据可靠。
  • 中断传输:用于需要保证延迟的小数据量传输(如键盘、鼠标)。保证在指定时间内得到服务。
  • 等时传输:用于需要恒定带宽和低延迟的实时数据(如音频、视频流)。有带宽保证,但数据出错不重传。

USB的物理与电气特性

USB连接非常简单,仅使用4根线:

  • VBUS:+5V电源
  • D+:差分数据线正极
  • D-:差分数据线负极
  • GND:地线

数据采用差分信号传输,即D+和D-线上的电压相反。这种方式抗共模噪声能力极强。USB使用NRZI编码和比特填充技术来确保数据流中有足够的电平跳变,以便接收端能够恢复时钟信号。

设备枚举与驱动

USB的一大优点是即插即用。当设备插入时,会触发以下过程:

  1. 主机检测到新设备,并为其复位。
  2. 主机为设备分配一个唯一的地址。
  3. 主机读取设备的描述符信息,包括厂商ID、产品ID、设备类、端点配置等。
  4. 主机根据设备类信息,加载或提示安装相应的驱动程序。
  5. 设备进入配置状态,可以开始正常工作。

USB设备采用分层类结构,同一类设备(如“大容量存储设备”、“人机接口设备”)使用标准化的驱动接口,大大简化了驱动开发。

USB的发展:USB 2.0/3.0

  • USB 2.0:将速度提升至480 Mbps(高速模式),并保持对USB 1.1的向后兼容。
  • USB 3.0及以后:速度进一步提升(如5 Gbps、10 Gbps),采用额外的数据线对实现全双工通信,并大幅提高了供电能力。

总结

本节课中我们一起学习了嵌入式系统的两种核心通信技术。我们从经典的RS-232串行通信开始,理解了其异步通信、帧结构、奇偶校验等基本原理,也看到了它在配置复杂性和速度上的局限性。随后,我们深入探讨了USB,了解了其基于主机控制的轮询架构、四种数据传输类型、差分信号物理层以及即插即用的设备枚举过程。USB通过高度的标准化和复杂的协议设计,在易用性、速度和可靠性上实现了巨大飞跃,成为现代嵌入式系统和计算机外设互联的基石。理解这些通信协议的工作原理,对于设计和调试嵌入式系统至关重要。

007:ATMega入门与位操作实践

在本节课中,我们将深入学习嵌入式系统中的位操作,并开始探索ATmega2560微控制器的官方文档。我们将通过具体的代码示例来巩固位设置和位清除的概念,并了解如何组织一个专业的C语言项目。


项目结构与代码组织

上一节我们介绍了位操作的基本概念。本节中,我们来看看如何在一个结构化的C语言项目中实现这些功能。

一个专业的C语言项目通常会将代码分离到不同的文件中,以提高可读性和可维护性。标准做法是使用头文件(.h)来声明函数原型,而将函数的具体实现放在源文件(.c)中。

以下是项目文件结构的一个示例:

  • main.c: 包含程序的入口点 main() 函数,用于测试和演示其他功能。
  • binary_utils.h: 头文件,包含所有工具函数的声明(函数原型)。
  • binary_utils.c: 源文件,包含工具函数的具体实现。

在 main.c 中,我们通过 #include "binary_utils.h" 来包含头文件。C预处理器会将该文件的内容复制到此处,这样编译器就知道这些函数的存在及其参数类型。链接器随后会在 binary_utils.c 中找到这些函数的实际定义。

尖括号 < > 用于包含系统库的头文件(如 stdio.h),编译器会在标准路径中查找。引号 " " 用于包含项目自定义的头文件,编译器首先在当前目录中查找。

二进制工具函数

为了更方便地处理二进制数,我们编写了几个工具函数。以下是这些函数的简要介绍:

  • string_binary_to_char: 将一个8位的二进制字符串(如 "11001010")转换成一个对应的 unsigned char 数值。
  • binary_to_string8: 将一个8位的 unsigned char 数值转换回其二进制字符串表示,便于打印输出。
  • bitset_and_clear8: 核心函数,用于对给定的8位数值执行位设置和位清除操作。

位设置与清除函数详解

现在,让我们深入看看 bitset_and_clear8 函数是如何工作的。该函数接收三个参数:原始数据、设置掩码和清除掩码。

函数逻辑如下:

  1. 错误检查:首先检查设置掩码和清除掩码是否有重叠位(即同一位上都是1)。这是无意义的操作,通常意味着程序有逻辑错误。如果发现重叠,函数会报错并退出。
  2. 设置位:使用按位或操作符 |= 将设置掩码中为1的位在原始数据中设为1。公式为:temp |= set_mask。
  3. 清除位:使用按位与操作符 &= 将清除掩码中为1的位在原始数据中设为0。这里需要先将清除掩码取反。公式为:temp &= ~clear_mask。
  4. 返回结果:返回处理后的数值。

以下是一个函数调用示例:

unsigned char result = bitset_and_clear8(input_byte, set_mask, set_mask);

通过这个函数,我们可以精确地控制寄存器中的特定位,而不影响其他位,这是控制硬件外设的关键。

ATmega2560 微控制器概览

掌握了位操作这一核心技能后,我们转向本节课的另一个重点:了解我们使用的硬件——ATmega2560微控制器。其官方文档虽然庞大,但包含了我们所需的一切信息。

ATmega2560是一款功能丰富的8位AVR微控制器,以下是其主要特性:

  • 丰富的I/O引脚:提供54至86个可编程I/O引脚,具体数量因封装而异。
  • 大容量存储器:相比常见的Arduino Uno,它具有更大的Flash和SRAM。
  • 多个定时器/计数器:包括8位和16位定时器,用于精确计时和产生PWM信号。
  • 模数转换器(ADC):用于将模拟信号(如传感器读数)转换为数字值。
  • 多种通信接口:如UART(通用异步收发器)、SPI(串行外设接口)和TWI(I²C)。
  • 看门狗定时器:一个独立的硬件计时器,可在软件崩溃时自动重启系统,提高系统可靠性。
  • 低功耗特性:支持多种睡眠模式,适用于电池供电设备。

I/O端口内部结构

微控制器的每个I/O引脚都不是一个简单的开关,其内部结构相当复杂。理解其简化原理图对正确使用至关重要。

一个典型的I/O引脚内部包含以下部分:

  • 保护二极管:防止引脚电压过高或过低而损坏内部电路。
  • 可编程上拉电阻:当引脚配置为输入时,可以通过软件启用内部上拉电阻。这在连接按钮或开关时非常有用:开关断开时,引脚通过上拉电阻读到高电平(1);开关闭合到地时,引脚读到低电平(0)。
  • 数据方向寄存器(DDR):决定引脚是输入(读取外部信号)还是输出(驱动外部电路)。
  • 数据寄存器(PORT):当引脚为输出时,向此寄存器写入值可以控制引脚输出高电平或低电平。当引脚为输入且上拉电阻启用时,向此寄存器写1可启用上拉。
  • 输入引脚寄存器(PIN):读取此寄存器可以获取引脚当前的逻辑电平值。

在C语言中,操作这些寄存器非常简单。例如,读取B端口所有引脚的状态只需:i = PINB;。

定时器/计数器简介

定时器/计数器是嵌入式系统的核心部件之一。ATmega2560拥有多个8位和16位定时器。

一个定时器的基本组成部分包括:

  • 时钟源:可以是微控制器内部系统时钟(如16MHz),也可以是外部引脚输入的信号。
  • 预分频器:将时钟源分频,以降低计数速度,获取更长的定时周期。
  • 计数器寄存器(TCNT):其值随着每个时钟脉冲递增(或递减)。
  • 输出比较寄存器(OCR):用户可以设置一个比较值。
  • 比较匹配逻辑:当计数器值(TCNT)与比较寄存器值(OCR)相等时,触发“比较匹配”事件。
  • 控制逻辑:根据配置,比较匹配事件可以自动清零计数器、改变计数方向、触发中断,或者控制一个输出引脚的电平翻转。

通过灵活配置定时器的工作模式,我们可以实现精确延时、测量脉冲宽度、生成PWM(脉冲宽度调制)信号以控制电机速度或LED亮度等多种功能。16位定时器相比8位定时器,提供了更宽的计数范围(0-65535),可以实现更精确或更长时间的定时。

使用芯片文档的技巧

ATmega2560的数据手册长达数百页,但无需通读。以下是一些高效使用文档的技巧:

  1. 善用目录和搜索:PDF阅读器的目录和搜索(Ctrl+F)功能是找到特定寄存器或功能说明的最快方式。
  2. 关注寄存器摘要:文档末尾的寄存器摘要列出了所有寄存器及其每一位的含义,是编程时的速查手册。
  3. 理解引脚复用:芯片引脚通常具有多种功能(如GPIO、ADC输入、定时器输出等)。数据手册中的引脚说明表会列出所有替代功能,设计电路时需要根据需求选择。
  4. 由需求驱动阅读:根据项目需要(例如,要使用ADC),直接定位到相关章节进行精读,而不是从头开始浏览。

本节课中我们一起学习了如何通过结构化的C代码进行精确的位操作,这是底层硬件编程的基石。同时,我们也初步探索了ATmega2560微控制器的强大功能和其官方文档的结构,为后续具体的实验(如控制定时器、读取ADC)打下了坚实的基础。记住,在面对复杂硬件时,数据手册是你最好的朋友。

008:16位定时器详解 ⏱️

在本节课中,我们将深入学习Arduino系统(实际上是ATmega芯片)中用于下一个实验的16位定时器。我们将深入硬件细节,学习如何通过配置控制寄存器来操作定时器,以生成恒定频率的信号。

概述

我们将从定时器的基本结构开始,介绍其核心组件,如计数器、比较器和波形发生器。接着,我们会探讨不同的工作模式,特别是我们将要使用的CTC(比较匹配时清零定时器)模式和快速PWM(脉冲宽度调制)模式。最后,我们将讲解如何通过编写代码来初始化和配置定时器,以生成所需的波形。

定时器核心结构

上一节我们介绍了定时器的基本概念,本节中我们来看看16位定时器的具体硬件结构。

定时器包含一个16位计数器、多个输出比较通道(A、B、C)以及相关的控制逻辑。每个通道几乎是相同的,这意味着你可以用同一个定时器基准生成最多三个独立的波形。

核心公式:

  • 计数器范围:从 0(底部)到 65535(0xFFFF,最大值)。
  • TOP值:一个可设置在 0 到 65535 之间的值,用于定义计数器的上限。

定时器的工作由三个8位控制寄存器(TCCRnA, TCCRnB, TCCRnC)管理。对于本实验,我们推荐使用定时器4(Timer 4),因此在代码中 n 应替换为 4。

输出比较引脚(如 OC4A, OC4B, OC4C)直接连接到芯片的特定引脚,进而连接到Arduino的引脚。当发生“输出比较匹配”事件(即计数器值与比较寄存器值相等)时,可以控制这些引脚的电平变化(置位、清零或翻转)。

时钟与预分频器

定时器的计数时钟可以来自内部CPU时钟(16 MHz)或外部信号。为了获得更灵活的计数频率,我们可以对内部时钟进行“预分频”。

以下是可用的预分频因子及其对16位定时器的影响:

预分频因子 计数频率 计数周期 最大计数时间(到65535) 备注
1 (无分频) 16 MHz 62.5 ns ~4.1 ms 最高频率,最精细分辨率
8 2 MHz 500 ns ~32.8 ms
64 250 kHz 4 µs ~262.1 ms
256 62.5 kHz 16 µs ~1.05 s
1024 15.625 kHz 64 µs ~4.2 s 最低频率,最长周期

核心概念:

  • 时钟越快,能输出的最低频率越高(因为计数器更快达到最大值)。
  • 预分频让你能够用同一个定时器生成频率范围更广的信号。
  • 在生成音调时,需要根据目标频率选择合适的预分频值。

定时器工作模式

定时器有多种模式,由波形生成模式位(WGMn3:0)控制。以下是两种最常用且与本实验相关的模式。

普通模式(Normal Mode)

这是最简单的模式。计数器从0向上计数,达到最大值(65535)后溢出归零,并重新开始。你可以通过读取计数器值来测量时间,但需要处理溢出以计算更长时间。

CTC模式(Clear Timer on Compare Match)🎯

在CTC模式下,计数器向上计数,但达到我们设定的TOP值(存储在输出比较寄存器OCRnA中)时,立即清零并重新开始。同时会触发“比较匹配”事件。

工作流程:

  1. 计数器从0开始递增。
  2. 当 TCNTn == OCRnA (TOP) 时,发生比较匹配。
  3. 计数器 TCNTn 自动复位为0。
  4. 如果输出比较模式设置为“翻转”(Toggle),则对应的输出引脚 OCnA 电平会在此事件发生时翻转(1变0或0变1)。

核心公式:
输出信号的频率由以下因素决定:
输出频率 = (CPU时钟频率 / 预分频因子) / (2 * (1 + OCRnA))

  • OCRnx: 输出比较寄存器的值(即TOP值)。
  • 除以2: 因为在“翻转”模式下,一个完整的波形周期需要两次比较匹配事件(一次从低到高,一次从高到低)。

通过改变 OCRnA 的值,可以改变输出信号的频率,而无需改变时钟基准。

快速PWM模式(Fast PWM)📈

PWM是一种通过快速开关来模拟模拟信号的技术。在快速PWM模式下,计数器从0计数到最大值(或某个TOP值),然后复位。

工作流程:

  1. 在计数器复位时(周期开始),输出引脚置为高电平(1)。
  2. 当计数器值与输出比较寄存器 OCRnx 匹配时,输出引脚清零为低电平(0)。
  3. 计数器继续计数到TOP后复位,输出再次置高,开始下一个周期。

核心概念:

  • 周期: 由计数器的TOP值决定,固定不变。
  • 占空比: 高电平时间占整个周期的百分比,由比较寄存器 OCRnx 的值决定。OCRnx 值越大,高电平时间越长,占空比越大。
  • 应用: 常用于LED调光、电机速度控制、简单的数模转换等。

编程配置步骤

了解了理论之后,本节我们来看看如何通过代码配置定时器。

以下是配置定时器(以Timer 4, CTC模式, 翻转输出为例)的一般步骤:

  1. 设置引脚为输出模式:
    首先,需要将你计划使用的输出比较引脚(如 OC4A 对应的Arduino引脚)配置为输出模式。这通过数据方向寄存器(如 DDRx)完成。

  2. 配置波形生成模式(WGM):
    需要设置 TCCR4A 和 TCCR4B 寄存器中的 WGM43:0 位,以选择CTC模式。具体的位组合需要查阅数据手册。

  3. 配置比较输出模式(COM):
    在 TCCR4A 寄存器中,设置对应通道(如 COM4A1:0)的模式。对于生成方波音调,通常设置为“翻转”模式。

  4. 配置时钟预分频(CS):
    在 TCCR4B 寄存器中,设置 CS42:0 位,以选择所需的预分频因子(如8, 64, 256, 1024)。

  5. 设置输出比较寄存器(OCR):
    向 OCR4A 寄存器写入一个16位的值,这个值决定了CTC模式下的TOP值,从而决定了输出频率。

  6. (可选)中断设置:
    如果需要,可以启用比较匹配中断,并编写中断服务例程(ISR)。本实验初期可能不需要。

示例代码框架:

void setupTimer4() {
    // 1. 设置 OC4A 引脚为输出 (例如 Arduino Pin 6)
    DDRD |= (1 << DDD6); // 假设OC4A对应PD6

    // 2. & 3. 设置模式为 CTC, 输出比较A模式为翻转
    TCCR4A = (1 << COM4A0); // 翻转 OC4A
    // WGM42 位在 TCCR4B 中设置

    // 4. 设置预分频因子为 64, 并确认WGM模式为CTC (WGM42=1)
    TCCR4B = (1 << WGM42) | (1 << CS41) | (1 << CS40); // 分频64

    // 5. 设置初始频率, 例如 1000 Hz (需根据公式计算OCR4A值)
    OCR4A = 124; // 示例值, 16MHz/64/2/(1+124) ≈ 1000Hz
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/5b16509eb0f218c24b933d66ce6d9ad0_7.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/5b16509eb0f218c24b933d66ce6d9ad0_9.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/5b16509eb0f218c24b933d66ce6d9ad0_11.png)

// 在loop中可以通过改变OCR4A来改变频率
void changeFrequency(unsigned int ocrValue) {
    OCR4A = ocrValue;
}

总结

本节课中我们一起深入学习了ATmega微控制器的16位定时器。

  • 我们了解了定时器的核心结构,包括计数器、输出比较单元和波形发生器。
  • 我们探讨了时钟预分频的原理及其对定时范围的影响。
  • 我们重点学习了CTC模式和快速PWM模式的工作原理与应用场景。
  • 最后,我们梳理了通过C代码配置定时器以生成特定频率波形或PWM信号的关键步骤。

掌握这些硬件级编程知识,将使你能够更高效、更精确地控制嵌入式系统的时间相关功能,为后续更复杂的实验和应用打下坚实基础。

009:任务、线程、调度与中断

在本节课中,我们将学习嵌入式系统中的核心概念:任务、线程、调度和中断。我们将探讨如何高效地管理CPU资源,让多个程序片段(任务)能够看似同时运行,并理解硬件中断如何使系统能够及时响应外部事件。

概述:从简单循环到任务调度

到目前为止,在实验一中,我们主要编写了基于循环的程序,就像标准的Arduino loop() 函数那样。这种方式虽然简单,但效率不高。例如,当使用 delay(50) 等待50毫秒时,CPU在这段时间内完全空闲,无法执行其他工作。为了构建能够执行复杂任务(如控制火星直升机或医疗设备)的实时嵌入式系统,我们需要更系统的方法来利用CPU。这就是调度器的作用。

调度器就像制定课程表或安排教室一样,它将CPU这个资源随时间进行分配。我们将要放入“课程表”的“课程”就是任务、进程和线程。

任务、进程与线程

任务、进程和线程是相似但有关键区别的概念。它们都代表需要CPU执行的工作单元。

处理器状态(上下文)

理解这些概念,首先要理解处理器的状态或上下文。这就像一架飞机的状态(速度、高度、航向)决定了它未来的行为。处理器的状态是数字化的,主要包括:

  • 程序计数器:指向下一条要执行的指令地址。
  • CPU寄存器:存储当前计算中的临时数据。
  • 处理器状态标志:记录上一条操作的结果(如是否为负、是否溢出)。
  • 栈指针:指向内存中栈的当前位置,用于保存临时数据和上下文。

上下文切换是指从一个任务切换到另一个任务的过程,包含三个步骤:

  1. 保存当前任务的上下文。
  2. 恢复要运行的任务的先前保存的上下文。
  3. 开始运行新任务。

任务的定义与类型

一个任务(或进程)是一段代码及其相关数据的集合,由一个处理器状态来描述。例如,“通过通信链路发送一个字节”或“每分钟从热敏电阻读取并校准温度”都可以是一个任务。

根据时间特性,任务可以分为几类:

1. 周期性任务
这类任务在确定的时间周期内重复运行,常见于硬实时控制系统(如核电站控制、汽车巡航控制)和多媒体处理(如音频采样)。我们用以下参数描述一个周期性任务:

  • 周期:任务重复执行的时间间隔。
  • 计算时间:任务每次执行所需的CPU时间。
  • 截止时间:任务必须在周期开始后的某个时间点前完成。

公式表示:对于一个任务,其计算时间 C 必须小于或等于其截止时间 D,而 D 通常小于或等于其周期 P。

2. 间歇性任务
这类任务偶尔发生,时间不可预测。例如,检测到电源故障时保存数据并关机,或系统启动时校准一次传感器。它们也有计算时间和截止时间的要求。

3. 后台任务
这类任务没有严格的时间要求,只在CPU空闲时运行。例如,在火星着陆器上,高优先级的实时控制任务运行时,后台任务可以处理压缩图片。它们只需要知道计算时间。

线程

线程是比任务更小的执行单元。一个进程(如一个Web服务器程序)内部可以包含多个线程(如每个用户连接由一个线程处理)。这些线程共享进程的代码和大部分数据,但各自拥有独立的执行上下文(如程序计数器、寄存器)。这种设计使得上下文切换更快,并能更好地利用I/O等待时间,提高CPU利用率。

CPU调度

调度是操作系统的核心工作:当有多个任务就绪时,决定接下来运行哪一个。

调度指标

在讨论调度算法前,我们先了解几个关键指标:

  • CPU利用率:CPU忙碌时间占总时间的比例。实时系统通常不会追求100%利用率,以留出安全余量应对突发情况。
  • 响应时间:从任务就绪到开始执行的时间。这对交互式系统和实时系统至关重要。
  • 截止时间满足率:对于实时系统,能否始终满足任务的截止时间是衡量调度算法好坏的关键。

调度算法示例

我们将通过一个例子来图解几种简单的调度策略。假设有三个任务:

  • 任务A:周期=1ms, 计算时间=0.2ms
  • 任务B:周期=2ms, 计算时间=0.2ms
  • 任务C:周期=2ms, 计算时间=0.2ms

1. 简单循环调度
就像最初的Arduino loop(),依次执行任务A、B、C,然后重复。这种方法无法满足不同任务的周期要求,任务B和C会被执行得过快。

2. 同步循环调度
在每轮循环结束后,等待下一个时钟“滴答”再开始新一轮。任务内部通过逻辑判断是否到了自己的执行周期。这种方法能更好地满足周期要求,但编程复杂,且依赖任务主动“让出”CPU(合作式调度)。

3. 抢占式调度
这是更强大和常用的方式。操作系统可以主动中断正在运行的任务(抢占),保存其上下文,然后切换到另一个任务。这使得编写任务代码更简单(开发者无需操心何时让出CPU),并且调度器能更精确地控制执行时序,保证实时性。

中断

中断是实现抢占和及时响应外部事件的关键硬件机制。

中断的概念

中断是由外部硬件事件(如按钮按下、网络数据包到达、定时器到期)触发的一种特殊上下文切换。当中断发生时,CPU会:

  1. 自动保存当前执行环境的上下文(通常是压入栈中)。
  2. 根据中断向量表跳转到对应的中断服务程序执行。
  3. ISR执行完毕后,恢复之前保存的上下文,继续执行被中断的程序。

栈

上下文保存和恢复依赖于栈这种数据结构。栈是一种“后进先出”的存储区,有两个基本操作:

  • 压栈:将数据放入栈顶。
  • 出栈:从栈顶取出数据。

代码示例:在汇编或底层C中,栈操作可能如下所示(假设栈向下增长):

// 压栈操作:将寄存器R1的值存入栈顶,然后栈指针SP递减
*SP = R1;
SP--;

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/1bb6e64a23fc8571152d88ed943a362d_28.png)

// 出栈操作:先递增栈指针SP,然后从栈顶取出值到寄存器R1
SP++;
R1 = *SP;

函数调用和中断处理都隐式地使用了栈来保存返回地址和寄存器状态。

中断处理流程

  1. 硬件中断发生:外部设备发出信号。
  2. 保存上下文:CPU硬件自动将程序计数器、状态寄存器等压入当前任务的栈中。
  3. 获取ISR地址:CPU根据中断号查询中断向量表,找到对应的中断服务程序入口地址。
  4. 执行ISR:跳转到ISR代码执行,处理中断事件(如读取设备数据)。
  5. 恢复上下文:ISR执行完毕后,通过特定指令(如RETI)恢复之前保存的上下文,CPU返回到被中断的任务继续执行。

总结

本节课我们一起学习了嵌入式系统多任务管理的核心概念。

  • 我们首先区分了任务、进程和线程,理解了处理器上下文是任务切换的基础。
  • 接着,我们探讨了不同类型的任务(周期性、间歇性、后台任务)及其时间参数。
  • 然后,我们介绍了CPU调度的概念,并通过示例比较了简单循环、同步循环和抢占式调度的区别,认识到抢占式调度的优越性。
  • 最后,我们深入了解了中断机制,它是实现抢占和实时响应的硬件基础,并学习了栈在上下文保存和函数调用中的关键作用。

理解这些概念是设计复杂、高效且可靠的嵌入式系统的基石。在接下来的课程和实验中,我们将实际应用这些知识来构建我们自己的调度系统。

010:调度II

概述

在本节课中,我们将深入探讨如何构建一个更高级的任务调度器。我们将学习如何使用函数指针、任务控制块(TCB)来管理多个并发任务,并实现非阻塞延迟和任务状态控制。此外,我们还将通过一个可视化练习来理解任务调度的时序分析。


实验二回顾与硬件操作

上一节我们介绍了任务调度的基本概念。本节中,我们首先回顾实验二的核心内容,并学习如何直接操作硬件寄存器。

实验二的目标是将多个功能整合并使其同时运行。我们需要学习如何直接操作输出位,而不是使用Arduino的 pinMode 和 digitalWrite 函数。虽然这些函数很好用,但理解其底层工作原理很重要。

以下是实现这一目标的关键步骤:

  1. 引脚映射:需要将Arduino板上的连接器引脚映射到微控制器芯片上的具体引脚。这通常需要参考原理图和数据手册来完成。
  2. 直接寄存器操作:通过直接设置或清除微控制器端口寄存器中的特定位来控制引脚,这比调用库函数更高效、更直接。
  3. 定时器配置:设置硬件定时器以自动生成特定频率的信号,例如用于驱动扬声器播放音符。

关于实验中的扬声器驱动,建议在扬声器回路中串联一个电阻(例如几百欧姆)。这有三个好处:防止过电流损坏扬声器、减少方波谐波使音色更平滑、以及避免因驱动过强而产生杂音。

实验二包含四个主要部分:

  • 任务A:控制三个LED依次闪烁,形成流水灯效果。
  • 任务B:使用定时器产生音频输出(如播放《玛丽有只小羊羔》的旋律)。
  • 任务C:一个控制任务,负责按特定模式(如运行A任务2秒,B任务4秒)启停任务A和B。
  • 交互式显示:使用摇杆控制一个8x8 LED点阵。需要读取摇杆的两个模拟输入值,将其映射到点阵的行和列坐标,并点亮对应的LED。

对于8x8 LED点阵,有两种常见类型:共阳极和共阴极。必须根据型号确定其原理图,并使用万用表验证引脚排列。部分点阵模块集成了驱动芯片以减少连线。接线时,合理规划Arduino的I/O引脚以保持布线整洁。

摇杆本质上是一个双轴电位器。使用 analogRead() 函数读取其电压值(范围0-1023),然后将其映射到点阵的行列索引(如0-7)。

实验的附加挑战是在点阵保持快速响应的同时,使用调度器让音乐播放任务也同步运行。


构建高级调度器

现在,让我们深入探讨如何构建一个功能更完善的调度器,以支持非阻塞延迟和动态任务管理。

从简单循环到基于定时器的调度

在实验一中,我们可能使用了类似以下的简单循环:

void loop() {
  taskA();
  taskB();
  taskC();
  delay(someInterval); // 阻塞延迟
}

这种方法的问题是 delay() 会阻塞所有其他任务。为了精确控制时间间隔并避免阻塞,我们可以使用硬件定时器。例如,设置一个16位定时器,使其每1毫秒(即操作系统“滴答”)产生一次溢出中断。这样,我们可以用一个等待定时器溢出的函数替代 delay(),从而确保循环周期严格为1毫秒,且任务执行时间的微小差异不会影响整体节奏。

引入函数指针

为了动态管理任务(如启动、停止),我们需要使用函数指针。函数指针允许我们将函数作为参数传递或存储在数组中。

函数指针的声明语法如下:

returnType (*pointerName)(argumentTypes);

例如,一个指向无参数、无返回值函数的指针:

void (*taskPtr)(void);

我们可以创建一个函数指针数组来管理我们的任务列表。

任务状态与列表管理

一个任务可以有多种状态,例如:就绪(READY)、运行(RUNNING)、等待/睡眠(WAITING)、停止(INACTIVE)。我们可以维护不同的列表(数组)来存放处于不同状态的任务函数指针。

一种简单的设计是维护三个列表:readyTasks(就绪)、waitingTasks(等待)、haltedTasks(停止)。调度器只执行 readyTasks 列表中的任务。当任务调用 haltMe() 时,将其从 readyTasks 移到 haltedTasks。当任务调用 sleep(delay) 时,将其从 readyTasks 移到 waitingTasks,并记录其剩余的延迟时间。每个系统滴答,调度器会减少所有 waitingTasks 的延迟值,当延迟为零时,再将任务移回 readyTasks。

任务控制块(TCB)方法

更常用的方法是使用任务控制块(TCB)。TCB是一个结构体,包含一个任务的所有相关信息。

一个TCB的伪代码定义如下:

typedef struct {
    void (*taskPtr)(void*); // 函数指针
    void* argPtr;           // 任务参数指针(通用类型)
    short state;            // 任务状态(如READY, WAITING, INACTIVE)
    unsigned int delay;     // 剩余延迟时间(若在等待状态)
} TCB;

然后,我们可以创建一个TCB数组 taskList[MAX_TASKS] 来管理所有任务。这种方法将所有数据封装在一起,比维护多个独立数组更清晰。

以下是使用TCB初始化任务的伪代码示例:

TCB taskList[10];
int j = 0;

// 初始化任务A
taskList[j].taskPtr = &taskA;
taskList[j].argPtr = NULL; // 无参数
taskList[j].state = INACTIVE;
taskList[j].delay = 0;
j++;

// 初始化任务B(假设需要一个整数参数)
int period = 56;
taskList[j].taskPtr = &taskB;
taskList[j].argPtr = (void*)&period; // 将int指针转换为void指针
taskList[j].state = READY;
taskList[j].delay = 0;
j++;

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/698053f8fc1180b32d4f92e2d731fa79_28.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/698053f8fc1180b32d4f92e2d731fa79_30.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/698053f8fc1180b32d4f92e2d731fa79_32.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/698053f8fc1180b32d4f92e2d731fa79_34.png)

// 标记列表结束
taskList[j].taskPtr = NULL;

基于TCB的调度器伪代码框架如下:

void scheduler() {
    for (int i = 0; i < MAX_TASKS && taskList[i].taskPtr != NULL; i++) {
        if (taskList[i].state == READY) {
            // 执行任务
            taskList[i].taskPtr(taskList[i].argPtr);
        } else if (taskList[i].state == WAITING) {
            // 减少延迟,如果为0则唤醒(状态改为READY)
            if (taskList[i].delay > 0) {
                taskList[i].delay--;
                if (taskList[i].delay == 0) {
                    taskList[i].state = READY;
                }
            }
        }
        // INACTIVE状态的任务被跳过
    }
}

关键函数伪代码:

  • haltMe(): 将当前任务的TCB状态设置为 INACTIVE。调用该函数的任务应立即返回,确保其停止执行。
  • startTask(int taskID): 将 taskList[taskID] 的状态设置为 READY。
  • sleep(unsigned int d): 将当前任务的TCB状态设置为 WAITING,并将 delay 字段设置为 d。调用该函数的任务也应立即返回。

调度时序分析

理解调度器行为的一个有效方法是进行时序图表分析。这有助于验证一组任务在给定的时间约束下是否可调度。

假设系统滴答为1毫秒。我们定义三个任务:

  • 任务A: 计算时间C=0.3ms,周期P=1ms。
  • 任务B: C=0.3ms,P=1ms。
  • 任务C: C=0.15ms,P=3ms(即运行一次后睡眠2ms)。

我们可以绘制一个时间线,以毫秒为单位,展示每个任务何时执行、何时睡眠。通过这种分析,我们可以直观地看到CPU时间是否被充分利用,以及所有任务的截止时间是否都能得到满足。这种分析在硬实时系统中至关重要。


总结

本节课我们一起学习了构建嵌入式系统调度器的进阶知识。我们从回顾直接硬件操作和实验二开始,然后深入探讨了如何利用函数指针和任务控制块来实现一个支持非阻塞延迟和动态任务管理的调度器。我们比较了多列表和TCB两种管理方式,并了解了关键函数(haltMe, startTask, sleep)的实现思路。最后,我们介绍了通过时序图表分析任务调度可行性的方法。掌握这些概念对于设计高效、可靠的并发嵌入式系统至关重要。

011:调度III

在本节课中,我们将通过一个实际的Arduino示例,学习如何实现一个简单的多任务调度系统。我们将编写代码让两个LED以不同频率闪烁,并探讨如何测量和调整任务执行时间,以确保调度的准确性。最后,我们会讨论更高级的调度概念,如抢占式调度和任务休眠。

概述与演示准备

上一节我们介绍了多种调度概念。本节中,我们来看看如何将这些概念付诸实践。我们将从一个简单的双任务调度示例开始。

首先,教授强调了在Piazza上提问的重要性,并鼓励大家将问题设为公开,以便整个班级都能从问答中受益。接着,他提到为了帮助那些仍在为多任务协同运行而困惑的同学,将展示一个具体的Arduino示例。

简单的双任务调度示例

我们将创建两个简单的任务:一个以10Hz频率闪烁板载LED,另一个以1Hz频率闪烁外部LED。目标是演示如何在不使用复杂操作系统的情况下,让多个任务“同时”运行。

以下是代码的核心部分,包括定义和设置:

// 引脚定义
#define INTERNAL_LED_PIN 13 // 板载LED对应引脚
#define EXTERNAL_LED_PIN 10 // 外部LED对应引脚

// 寄存器定义(针对ATmega328P)
#define LED_PORT PORTB
#define LED_DDR DDRB
#define INTERNAL_LED_BIT 7 // PORTB bit 7
#define EXTERNAL_LED_BIT 4 // PORTB bit 4

void setup() {
    // 设置LED引脚为输出模式
    LED_DDR |= (1 << INTERNAL_LED_BIT) | (1 << EXTERNAL_LED_BIT);
}

在loop函数中,我们将依次调用两个任务函数,然后延迟1毫秒。这构成了我们调度器的基本周期。

void loop() {
    taskA(); // 执行任务A
    taskB(); // 执行任务B
    delay(1); // 延迟1毫秒,构成调度周期
}

每个任务函数内部使用static变量来在多次调用之间保持状态,从而模拟一个独立运行的计时器。

void taskA() {
    static unsigned long time = 0; // 静态变量,在调用间保持值
    time++; // 每次调用增加1,代表时间流逝

    if (time == 50) {
        // 50毫秒后点亮LED(10Hz周期的一半)
        LED_PORT |= (1 << INTERNAL_LED_BIT);
    }
    if (time == 100) {
        // 100毫秒后熄灭LED,并重置计时器
        LED_PORT &= ~(1 << INTERNAL_LED_BIT);
        time = 0;
    }
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/7da695834909deee38ddac8086a3ff97_16.png)

void taskB() {
    static unsigned long time = 0;
    time++;

    if (time == 500) {
        // 500毫秒后点亮LED(1Hz周期的一半)
        LED_PORT |= (1 << EXTERNAL_LED_BIT);
    }
    if (time == 1000) {
        // 1000毫秒后熄灭LED,并重置计时器
        LED_PORT &= ~(1 << EXTERNAL_LED_BIT);
        time = 0;
    }
}

这个方案基于一个关键假设:taskA和taskB的执行时间接近于零。如果任务执行时间过长,会破坏整个调度周期。

测量与调整任务执行时间

为了验证我们的假设并提高调度精度,我们需要测量循环的实际执行时间。

我们添加一个“循环位”到引脚12,并在每次循环中翻转它。通过示波器测量该引脚输出的方波频率,可以推算出循环的实际周期。

#define LOOP_BIT_PIN 12
#define LOOP_DDR DDRB
#define LOOP_BIT 4 // 假设使用PORTB bit 4,需根据实际连接调整

void setup() {
    // ... 其他设置 ...
    LOOP_DDR |= (1 << LOOP_BIT); // 设置循环位引脚为输出
}

void loop() {
    static uint8_t temp = 0;
    taskA();
    taskB();
    // 翻转循环位
    temp ^= 1; // 使用异或操作翻转最低位
    digitalWrite(LOOP_BIT_PIN, temp & 0x01);
    delayMicroseconds(985); // 调整后的延迟,使总周期接近1ms
}

初始测量显示频率约为488Hz,而非理想的500Hz(对应1ms周期)。这表明taskA、taskB和位翻转操作总共消耗了约15微秒。因此,我们将延迟从1000微秒减少到985微秒,使总循环时间接近1毫秒,测量频率随之改善到约498Hz。

这个调整过程揭示了简单调度器的局限性:它依赖于对任务执行时间的精确估计,并且对代码变更非常敏感。

关于全局变量与局部静态变量的讨论

有同学提问为何不使用全局变量来跟踪时间。教授指出,虽然使用全局变量(如unsigned long globalTime)并让所有任务参考它是可行的,但这会引入复杂性。

每个任务需要计算相对于自身上次动作的时间差,而不是简单地检查一个本地计数器是否达到特定值。使用局部静态变量让每个任务管理自己的周期计时器,逻辑更清晰、更独立。全局变量更适用于需要绝对时间同步的复杂场景,但在本例中,本地计时已足够。

从协作式调度到抢占式调度

我们目前实现的是一种“协作式”调度。每个任务必须主动、快速地返回控制权给调度器。任务不能调用像delay()这样的阻塞函数,否则会冻结整个系统。

更先进的调度方式是“抢占式”调度。在这种模式下,操作系统(或调度器)使用硬件中断强制暂停正在运行的任务,保存其状态,然后恢复运行另一个任务。这使得程序员可以编写更自然、可能包含阻塞调用的代码,而不会影响其他任务。现代桌面和移动操作系统都使用抢占式调度。

实现任务休眠(Sleep)

为了向更实用的系统迈进,我们可以实现一个非阻塞的sleep函数。任务可以调用sleep(ms)来请求暂停一段时间,在此期间调度器可以运行其他就绪的任务。

这通常通过为每个任务维护一个软件计数器来实现。调度器在每个时钟节拍递减所有休眠任务的计数器,当某个任务的计数器减到零时,就将其状态设置为就绪。

以下是这种模式的任务示例:

// 假设存在一个非阻塞的 sleep_ms 函数
void taskB_new() {
    doComputation(); // 执行一些计算,耗时233微秒
    sleep_ms(3000);  // 休眠3000毫秒,但不会阻塞其他任务
    // 任务醒来后,周期性地重复此过程
}

在这种模型下,任务的周期由自身的“计算 + 休眠”逻辑决定,并且通常是调度器时钟周期的整数倍。这更贴近实际嵌入式系统的编程模式,例如一个电机控制器可能每20毫秒(50Hz)更新一次。

实际系统的调度考量

在实际的实时系统中,设计者非常关注“可调度性”分析。即,在给定的任务集(每个任务有计算时间C、周期P、截止时间D)和调度算法下,是否能保证所有任务总能满足其截止时间。

任务的实际执行时间可能会有波动。因此,将调度表安排得过于紧凑是危险的。需要留出一定的空闲时间或“余量”,以应对最坏情况下的执行时间,确保系统在最繁忙时也能满足所有实时要求。

总结与实验室建议

本节课我们一起学习了如何实现一个简单的协作式多任务调度器。我们从让两个LED闪烁的示例开始,演示了如何使用静态变量管理任务状态,以及如何测量和调整调度周期以提高精度。

我们讨论了全局变量与局部变量的选择,并引出了更强大的抢占式调度概念。最后,我们探讨了实现非阻塞任务休眠的方法,以及在实际嵌入式系统设计中考虑可调度性和时间余量的重要性。

对于正在进行的实验,请记住:

  1. 从简单的任务开始测试你的调度器。
  2. 避免在任务中使用阻塞式delay()。
  3. 利用示波器(如果有)或通过听觉(对于发声任务)来验证定时是否大致正确。
  4. 仔细查阅硬件(如LED点阵)的数据手册,并使用万用表的二极管测试档来验证引脚连接。

通过Piazza继续提问和讨论,并尽量将问题公开以惠及全班。

012:读取模拟数据及中断入门

在本节课中,我们将要学习中断服务程序(ISR)的基本概念与设置方法,并介绍一个用于自动生成代码文档的专业工具 Doxygen。我们还将回顾任务调度的核心概念,为后续的编程实践打下基础。

概述:中断与文档工具

上一节我们介绍了定时器和任务调度的基础。本节中,我们来看看如何利用硬件中断来实现更精确的定时控制,并引入 Doxygen 工具来规范我们的代码文档。

首先,我们介绍一个在 Lab 3 和 Lab 4 中需要使用的专业文档工具:Doxygen。

Doxygen 工具介绍

Doxygen 是一个广泛使用的软件工程工具,它能自动分析你的代码和特定格式的注释,并生成结构清晰的 HTML 文档。这消除了手动编写详细描述代码的重复工作。

以下是使用 Doxygen 的基本步骤:

  1. 安装 Doxygen:根据你的操作系统(Windows、Mac 或 Linux)进行标准安装。
  2. 编写带标签的注释:在你的 C 代码中,使用特定的 Doxygen 标签来注释函数、参数和返回值。
  3. 运行 Doxygen:对源代码运行 Doxygen,它将自动生成一个包含所有文档的 HTML 文件夹。
  4. 提交文档:将这个生成的文件夹包含在你的作业压缩文件中一并提交。

Doxygen 生成的文档包含模块列表、函数详细说明、参数描述,并且可以直接链接到源代码,非常便于管理和阅读。

中断核心概念详解

现在,让我们回到嵌入式系统的核心话题:中断。中断是让 CPU 暂停当前任务,转去处理紧急事件,之后再恢复原任务的一种机制。

以下是中断相关的核心概念:

  • 中断服务程序:这是当中断发生时,CPU 要去执行的那段特定代码。
  • 中断使能与禁止:可以通过设置特定的控制位来全局或局部地开启或关闭中断响应。
  • 内部与外部中断:
    • 内部中断源自芯片内部,如定时器溢出。
    • 外部中断由芯片引脚上的电平变化触发。
  • 中断优先级:当多个中断同时发生时,高优先级的中断可以打断低优先级中断的服务程序。
  • 中断向量表:这是内存中一个固定的区域,存放着各个中断对应的服务程序的入口地址。当中断发生时,硬件会根据中断号查找这个表并跳转到相应的地址。

在我们的 Arduino (ATmega2560) 芯片中,中断向量表定义在数据手册的特定位置。例如,定时器1的比较匹配 A 中断对应向量表中的特定槽位。

设置中断服务程序的步骤

为了使用中断,我们需要按照特定顺序进行软件设置。以下是主要步骤:

  1. 配置外设:例如,设置定时器的控制寄存器,使其在特定条件(如比较匹配)下产生中断请求。
  2. 编写 ISR:使用 ISR() 宏来定义你的中断服务程序。这个宏能确保在进入和退出你的代码时,正确处理上下文保存与恢复。
    ISR(TIMER1_COMPA_vect) {
        // 你的中断处理代码放在这里
    }
    
  3. 使能中断:
    • 在外设级别使能特定中断(如定时器的比较匹配中断使能位)。
    • 在系统级别,通过设置状态寄存器(SREG)中的全局中断使能位来开启中断。
    sei(); // 设置全局中断使能位
    
  4. 保持 ISR 简洁:中断服务程序应尽可能短小高效,避免执行复杂操作或长时间阻塞,以免影响其他中断或系统功能。

任务调度深入分析

接下来,我们再次审视任务调度,通过图示分析来理解调度器在不同情况下的决策逻辑。

考虑一个包含三个任务(A, B, C)的系统,我们使用非抢占式调度器。通过绘制时间线图,我们可以分析:

  • 当任务执行时间接近或超过系统节拍时会发生什么。
  • 调度器指针移动策略(每拍从头开始 vs. 继续循环)对任务执行的影响。
  • 如何判断一个任务是否应该在当前节拍执行,以避免错过其他任务的关键唤醒时机。

这种分析揭示了编写健壮调度器时必须考虑的边界情况,例如计算任务最坏执行时间、处理所有任务都处于“休眠”的状态等。这也引出了抢占式调度的优势:它允许高优先级任务立即打断低优先级任务,从而更灵活地满足实时性要求。

I/O 请求与调度

最后,我们简要介绍涉及 I/O 操作的任务调度。当任务需要访问慢速外设(如磁盘、网络)时,它需要等待 I/O 操作完成。

在这种情况下,调度器可以将该任务置为“等待”状态,并切换到其他就绪任务去执行。当 I/O 操作完成后(通常通过中断通知),原来的任务可以再次被标记为就绪状态。这种机制极大地提高了 CPU 的利用率。

总结

本节课中我们一起学习了以下内容:

  1. 如何使用 Doxygen 工具自动生成专业的代码文档。
  2. 中断机制的核心概念,包括 ISR、向量表、优先级和使能控制。
  3. 设置定时器中断服务程序的具体步骤和最佳实践。
  4. 通过图表深入分析了非抢占式任务调度中的复杂情况和设计考量。
  5. 了解了在任务中进行 I/O 操作时的调度策略。

掌握中断是嵌入式编程从入门到精通的关键一步,它将帮助你构建出时序更精确、响应更及时的系统。请务必仔细阅读提供的文档,并在实验中进行实践。

013:I2C 与 SPI 通信

在本节课中,我们将深入学习嵌入式系统中的任务调度。我们将通过编写代码来模拟几种主要的调度器,并回顾实验三的作业内容。

概述

本节课我们将深入探讨任务调度的核心概念,并通过代码模拟几种调度器。我们还将回顾实验三的作业要求,为接下来的实践做好准备。

调度基础回顾

上一节我们介绍了基本的调度循环。本节中,我们来看看如何实现更灵活的调度机制。

最基本的调度器就是一个循环。循环体中的代码会被重复执行。我们可能需要一些延迟机制来确保每个循环周期,例如,恰好是1毫秒。

现在,我们希望实现一些暂停和延迟功能。例如,最简单的任务是让一个LED灯亮20毫秒,然后灭80毫秒,这就需要精确计时。

函数指针

为了实现灵活的调度,我们需要回顾函数指针的概念。函数指针允许我们将函数作为参数传递或存储在数组中。

函数指针的通用声明格式如下:

返回类型 (*指针名称)(参数列表);

以下是一个更具体的例子,声明了一个指向特定类型函数的指针:

int (*fp)(char, int, double);

这个指针 fp 指向一个函数,该函数返回一个 int 类型,并接受 char、int 和 double 三个参数。

在我们的简单案例中,任务函数通常没有返回值(void)且没有参数,这使得函数指针的声明更简洁:

void (*task_ptr)();

我们可以编写一个函数来启动由函数指针指示的任何任务:

void start_task(void (*task_ptr)()) {
    task_ptr();
}

虽然直接调用函数也能实现,但将函数指针存储在列表中并遍历执行会更有趣。

模拟调度器

为了演示调度概念,我们构建了一个简单的Arduino模拟器。它通过全局变量模拟硬件状态,并在终端输出结果。

以下是模拟器的核心全局变量,用于模拟时间、LED状态和IO引脚:

int sim_time = 0;
int led_state = 0;
int io_pin_states[10];

模拟器提供了设置引脚、读取引脚状态和输出当前状态等基本功能。

基础任务循环

我们首先实现一个基础的任务循环,其中硬编码了两个任务。

任务A每10个时间单位翻转一次引脚3的状态:

void task_a() {
    if (sim_time % 10 == 0) {
        flag_a ^= 1;
    }
    if (flag_a) {
        set_pin(3);
    } else {
        clear_pin(3);
    }
}

任务B每3个时间单位翻转一次LED状态:

void task_b() {
    if (sim_time % 3 == 0) {
        flag_b ^= 1;
    }
    if (flag_b) {
        led_output(LED_ON);
    } else {
        led_output(LED_OFF);
    }
}

主循环中依次调用这些任务,并模拟时间流逝。

使用函数指针列表

为了使调度更灵活,我们使用函数指针数组来管理任务。

首先,声明一个函数指针数组并初始化:

#define NUM_TASKS 2
void (*task_list[NUM_TASKS])();

void setup() {
    task_list[0] = task_a;
    task_list[1] = task_b;
}

然后,修改主循环,遍历并执行数组中的每个任务:

void loop() {
    for (int i = 0; i < NUM_TASKS; i++) {
        task_list[i]();
    }
    sim_time++;
    // 延迟以便观察输出
    delay(1000);
}

实现任务延迟

接下来,我们实现一个 sleep 功能,允许任务主动延迟执行。

我们引入一个延迟数组 task_delays 来记录每个任务的剩余延迟时间。还需要一个全局变量 active_task 来标识当前正在执行的任务索引。

async_sleep 函数将当前任务的延迟值设置到数组中:

void async_sleep(int delay_time) {
    if (delay_time > 0) {
        task_delays[active_task] = delay_time;
    }
}

在调度循环中,我们检查每个任务的延迟状态。只有当延迟为0时,才执行该任务;否则,减少其延迟值:

for (int i = 0; i < NUM_TASKS; i++) {
    active_task = i;
    if (task_list[i] != NULL && task_delays[i] <= 0) {
        task_list[i]();
    } else if (task_delays[i] > 0) {
        task_delays[i]--;
    }
}

现在,任务A可以重构为使用 async_sleep 来实现周期性行为,代码更清晰:

void task_a() {
    flag_a ^= 1;
    if (flag_a) {
        set_pin(3);
    } else {
        clear_pin(3);
    }
    async_sleep(4); // 睡眠4个周期
}

实验三作业预览

在实验三中,你们将把这些调度概念应用到真实的Arduino上。主要目标包括:

  1. 实现不同的调度器:提供不同精度和编程便利性的任务调度。
  2. 使用定时器中断实现同步定时:利用芯片内部的定时器,每毫秒产生一次中断,用于精确调度。
  3. 控制四位数码管(7段显示器):显示计数或频率信息。
  4. 播放一段旋律:使用定时器生成特定频率的方波,不使用Arduino的 tone 函数。
  5. 实现任务管理:包括任务的启动、停止和状态切换。

实验将要求你们组合不同的任务和调度器进行演示。例如,使用轮询调度器同时运行任务1和任务2,或者使用中断驱动的同步调度器运行另一组任务。

核心提示:考虑将复杂任务(如驱动数码管)分解为多个子任务(如数字转换、段选、位扫描),这会使调度和代码结构更清晰。

总结

本节课我们一起学习了嵌入式系统中任务调度的核心机制。我们从最简单的循环调度开始,逐步引入了函数指针、任务列表和延迟执行功能,模拟了调度器的基本工作原理。这些概念是完成实验三的重要基础。在实验三中,你们将在真实的硬件上应用这些知识,实现更复杂、更精确的多任务系统。

014:期中复习

在本节课中,我们将深入学习中断和中断服务程序(ISR)的核心概念。这是本课程最重要的内容之一,也是完成实验三的关键。我们将通过理论回顾和实际代码演示,帮助你掌握如何配置和使用中断。

概述:中断与ISR基础

上一节我们介绍了中断的基本理论。本节中,我们将通过实际代码示例,看看如何配置硬件定时器来产生中断,并编写相应的ISR来响应这些中断。

中断是嵌入式系统中实现异步事件处理的核心机制。它允许处理器在执行主程序的同时,响应来自硬件(如定时器、传感器)的即时请求。

中断配置与ISR编写

要使用中断,我们的软件必须按顺序完成以下步骤。以下是具体流程:

  1. 配置设备:首先,我们需要配置一个硬件设备(如定时器)来在特定条件下(例如,每毫秒)产生中断。
  2. 编写ISR:接着,我们需要编写中断服务程序(ISR),即当中断发生时自动执行的代码块。
  3. 启用中断:最后,我们需要启用该设备的中断功能,并确保全局中断使能位已打开。

在Arduino环境(使用AVR-GCC编译器)中,我们使用一个特殊的宏来定义ISR。这不是一个普通的函数,因为编译器会自动在它的开头和结尾插入保存和恢复处理器状态的汇编代码。

代码示例:定义一个简单的ISR

ISR(TIMER4_COMPA_vect) {
    // 当中断发生时,这里面的代码会被执行
    isr_flag = 0; // 例如,清除一个标志位
}

其中,TIMER4_COMPA_vect 是“中断向量”,它告诉系统这个ISR对应的是定时器4的“比较匹配A”事件。

关键概念:volatile关键字

在中断编程中,volatile 关键字至关重要。它告诉编译器,某个变量的值可能会被程序本身以外的因素(如ISR)改变,因此编译器不应对该变量的访问进行优化。

公式/概念:volatile 修饰的变量,编译器每次都会从内存中读取其值,而不是使用寄存器中可能已过期的缓存值。

例如,如果主循环在等待一个由ISR清除的标志位,而这个标志位没有用 volatile 声明,编译器可能会优化掉循环中的检查,导致程序永远等待下去。

编写高效ISR的最佳实践

为了确保系统稳定可靠,编写ISR时应遵循以下原则。以下是核心要点:

  • 保持简短:ISR应尽可能短小精悍,只完成最必要的操作(如设置标志、更新计数),复杂的逻辑应放到主循环中处理。
  • 避免阻塞调用:绝对不要在ISR中使用 delay()、Serial.print() 等函数。这些函数执行时间很长或可能自身产生中断,会导致系统混乱甚至崩溃。
  • 使用硬件调试:使用LED闪烁是调试ISR是否触发的简单有效方法。也可以配置中断以较慢的速率触发,以便肉眼观察。
  • 注意临界区:如果主循环和ISR会访问共享的全局变量,需要考虑通过暂时关闭中断等方式来保护这些“临界区”,防止数据竞争(本节课暂不深入)。

实战演示:一个简单的中断调度器

现在,我们来看一个将中断用于任务调度的最小示例。目标是创建一个精确的1毫秒调度节拍。

核心思路:

  1. 配置一个定时器(如Timer4),使其每1毫秒产生一次中断。
  2. ISR中仅清除一个全局标志位(isr_flag)。
  3. 主循环中,任务执行完毕后,会等待这个标志位被ISR清除,从而实现与1毫秒时钟的同步。

代码框架示意:

volatile int isr_flag = 1; // 必须声明为volatile

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/a80001397d2800ac6b8687ad50a70c9c_18.png)

ISR(TIMER4_COMPA_vect) {
    isr_flag = 0; // 每毫秒清除一次标志
}

void sync_with_scheduler() {
    while (isr_flag == 1) {
        // 空循环,等待中断
    }
    isr_flag = 1; // 为下一次等待重置标志
}

void loop() {
    run_task_a(); // 运行任务A
    run_task_b(); // 运行任务B
    sync_with_scheduler(); // 等待下一个1毫秒周期
}

通过这种方式,只要所有任务的总执行时间小于1毫秒,loop() 就能以精确的1毫秒周期循环执行。

总结

本节课中我们一起学习了嵌入式系统的中断编程。我们回顾了中断的配置流程,学习了如何使用 ISR() 宏编写中断服务程序,并理解了 volatile 关键字在共享变量中的关键作用。通过实际演示,我们看到了一个基于中断的简单调度器如何工作,也了解了编写高效、稳定ISR的最佳实践(保持简短、避免阻塞)。掌握这些知识,是完成后续实验和构建复杂嵌入式系统的坚实基础。

015:实验3导论

在本节课中,我们将学习两种关键的串行通信协议(I²C和SPI),并介绍一个用于嵌入式系统的实时操作系统(FreeRTOS)。这些知识对于理解现代嵌入式设备如何高效通信和管理任务至关重要。

串行通信协议:I²C与SPI

上一节我们介绍了串行数据传输的基本概念。本节中,我们来看看两种在现代嵌入式系统中广泛应用的串行总线协议:I²C和SPI。

I²C总线

I²C(Inter-Integrated Circuit)总线由飞利浦公司(现NXP)开发,仅使用两根线进行通信:

  • SCL:串行时钟线
  • SDA:串行数据线

这种设计极大地减少了芯片引脚数量和电路板布线空间。在I²C通信中,一个设备作为协调者(原称Master),其他设备作为响应者(原称Slave)。总线空闲时,两条线均为高电平。

通信以一个起始条件开始:当SCL为高电平时,SDA线产生一个从高到低的跳变。随后,协调者发送7位设备地址和1位读写方向位。地址匹配的响应者会回复一个确认(ACK)信号。之后,数据字节在协调者和响应者之间传输,最后由协调者发出停止条件(SCL为高时,SDA从低跳变到高)结束通信。

I²C的一个限制是只有128个(7位)地址。为了解决地址冲突,通常使用额外的使能引脚来选择不同的设备。

SPI总线

SPI(Serial Peripheral Interface)总线由摩托罗拉公司开发,使用四根线:

  • SCK:串行时钟
  • MOSI:协调者输出,响应者输入
  • MISO:协调者输入,响应者输出
  • SS:片选信号

SPI没有地址概念,它通过片选信号来选择特定的响应者设备。数据通过移位寄存器在协调者和被选中的响应者之间同时进行全双工传输。SPI的另一种连接方式是菊花链,所有设备共用一根片选线,数据依次通过每个设备。这种方式节省引脚,但要求软件清楚了解拓扑结构,并且访问单个设备可能变慢。

在我们的Arduino Mega 2560开发板上,有专门的硬件模块支持SPI和I²C(在数据手册中称为TWI,即两线接口),可以自动处理数据传输,减轻CPU负担。

除了使用硬件模块,也可以通过位敲击的方式,用普通GPIO引脚模拟这些总线协议。这种方式具有更好的移植性,但速度较慢且会完全占用CPU。

实时操作系统:FreeRTOS

理解了任务调度器的工作原理后,本节我们来看一个功能更强大的实时操作系统——FreeRTOS。这是一个开源的、专为微控制器设计的小型操作系统。

FreeRTOS概述

FreeRTOS的核心是一个基于优先级的抢占式调度器。这意味着高优先级任务可以中断正在运行的低优先级任务。这与我们之前编写的协作式调度器有本质区别,允许程序员更自然地编写任务代码(例如使用 while(1) 循环)。

FreeRTOS还提供了用于任务间通信的队列等机制,可以安全地传递数据块。

FreeRTOS的调度器节拍默认最快为15毫秒,它通常使用芯片的看门狗定时器来产生周期性中断,而不是占用用户可用的通用定时器。

看门狗定时器

看门狗定时器是嵌入式系统中一个重要的可靠性组件。其原理是:软件需要定期“喂狗”(即重置定时器),如果软件因故障(如死循环)未能按时喂狗,看门狗定时器将超时并触发系统复位。这可以防止系统因软件错误而永久挂起,在汽车、医疗等安全关键系统中广泛应用。

FreeRTOS任务示例

以下是使用FreeRTOS创建和运行任务的基本代码结构:

#include <Arduino_FreeRTOS.h>

// 任务函数1:闪烁LED
void TaskBlink(void *pvParameters) {
    pinMode(LED_BUILTIN, OUTPUT);
    while(1) {
        digitalWrite(LED_BUILTIN, HIGH);
        vTaskDelay(200 / portTICK_PERIOD_MS); // 延迟约200毫秒
        digitalWrite(LED_BUILTIN, LOW);
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

// 任务函数2:计数器
void TaskCounter(void *pvParameters) {
    static int count = 0;
    while(1) {
        count++;
        if(count > 9999) count = 0;
        // 此处可添加更新显示的代码
        vTaskDelay(50); // 延迟50个调度节拍(约750毫秒)
    }
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/3fe3db080d806f2c710d921dd4f374c2_8.png)

void setup() {
    // 创建任务
    xTaskCreate(TaskBlink, "Blink", 128, NULL, 3, NULL);
    xTaskCreate(TaskCounter, "Counter", 128, NULL, 2, NULL);
    // 启动调度器
    vTaskStartScheduler();
}

void loop() {
    // FreeRTOS运行时,loop函数应保持为空
}

在 xTaskCreate 函数中,我们需要指定任务函数指针、任务名、堆栈大小、参数指针、优先级和任务句柄。启动调度器后,任务将根据其优先级自动运行。

实验3任务说明

关于实验3中的任务5,其核心是作为一个控制任务,管理其他任务的启动和停止。它需要按照特定顺序和时序来调度任务1、2、4。请注意,任务5专为DDS(动态截止期调度器)设计,应利用该调度器提供的特性(如 task_delay、kill_self)来实现控制逻辑,而不是在任务5内部再实现一个调度循环。

总结

本节课中我们一起学习了:

  1. I²C和SPI串行总线协议:它们如何用极少的连线实现芯片间通信,以及各自的优缺点和典型应用。
  2. FreeRTOS实时操作系统:其抢占式、基于优先级的调度模型,以及看门狗定时器的原理和重要性。
  3. 实验3的要点澄清:特别是任务5的实现思路,应充分利用DDS调度器的功能进行任务管理。

掌握这些通信和系统管理的基础,对于构建复杂的嵌入式应用至关重要。

016:UART串行通信与RTOS进程间通信

在本节课中,我们将学习实时操作系统(RTOS)中进程间通信(IPC)的核心概念,特别是生产者-消费者模型、共享资源保护以及临界区。我们将探讨如何使用信号量等机制来安全地在任务间传递数据,并了解相关的潜在问题,如优先级反转。


概述:生产者-消费者模型与数据传递

上一节我们介绍了RTOS的任务调度。本节中,我们来看看任务之间如何安全、高效地共享数据。一个经典的模式是生产者-消费者模型:一个任务(生产者)生成数据,另一个任务(消费者)使用这些数据。

共享缓冲区实现

以下是实现该模型的一种简单伪代码,使用一个环形缓冲区(大小=5)来暂存数据。

#define BUFFER_SIZE 5
Item buffer[BUFFER_SIZE];
int in = 0; // 生产者指针
int out = 0; // 消费者指针
int count = 0; // 缓冲区中当前项目数

// 生产者任务
void producer() {
    while (1) {
        while (count >= BUFFER_SIZE) {
            ; // 等待,直到缓冲区有空间
        }
        // 生产一个项目
        Item new_item = produce_item();
        buffer[in] = new_item;
        in = (in + 1) % BUFFER_SIZE;
        count++;
    }
}

// 消费者任务
void consumer() {
    while (1) {
        while (count == 0) {
            ; // 等待,直到缓冲区有数据
        }
        // 消费一个项目
        Item consumed_item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        count--;
        consume_item(consumed_item);
    }
}

核心思想:生产者检查缓冲区是否有空间(count < BUFFER_SIZE),有则放入数据并移动指针。消费者检查缓冲区是否有数据(count > 0),有则取出数据并移动指针。指针到达末尾后回绕到开头,形成环形缓冲区。


进程间通信机制

除了直接共享内存(如全局变量或缓冲区),操作系统通常提供更高级、更安全的通信机制。

以下是几种常见的IPC方式:

  • 消息传递:任务通过操作系统提供的API(如send_message(process_id, message))直接发送消息给另一个任务。接收方通过类似receive_message()的调用等待并获取消息。
  • 邮箱:可以看作一个命名的消息队列。发送方post_message(mailbox_name, data),接收方pend_on_mailbox(mailbox_name)等待数据到达。
  • 队列:FreeRTOS中的核心机制。允许消息按顺序排队,发送方和接收方通过队列句柄进行操作。当队列满时,发送方可能被阻塞;当队列空时,接收方被阻塞。

这些机制的优势在于,操作系统负责底层的同步和缓冲区管理,应用程序代码更简洁,且减少了因直接操作共享数据而引入错误的风险。


临界区与资源保护

在抢占式RTOS中,当一个任务正在检查并准备操作共享资源(如上述的count变量)时,它可能被高优先级任务打断。如果另一个任务也操作同一资源,就会导致数据不一致或逻辑错误。

临界区的定义是:一段必须原子化执行(即不可被中断)的简短代码。例如,上面伪代码中count++或count--及其前后的检查操作,共同构成了临界区。

保护临界区的方案

有多种方法可以保护临界区,防止因任务切换导致的问题。

方案一:全局中断屏蔽

最直接的方法是进入临界区前关闭所有中断,退出时再打开。

void access_shared_resource() {
    OS_interrupt_mask(); // 屏蔽所有中断
    // 临界区代码开始
    if (data_available) {
        process_buffer();
        set_flags();
    }
    // 临界区代码结束
    OS_interrupt_enable(); // 启用中断
}
  • 优点:实现简单、快速。
  • 缺点:过于粗暴。它会阻塞所有中断,即使那些与当前共享资源无关的中断(如定时器、串口)也被延迟,严重影响系统实时性。

方案二:测试与置位指令

某些处理器提供特殊的原子指令,如Test-and-Set。它在一条指令内完成“测试变量值”和“设置变量值”两个操作,中间不可中断。

; 伪汇编代码示例
TAS X ; 测试并设置变量X
JNZ WAIT ; 如果X不为0,跳转到WAIT循环等待
; 否则,进入临界区
... ; 临界区代码
MOV X, #0 ; 退出临界区,释放资源
  • 优点:非常高效,只针对特定资源进行保护。
  • 缺点:依赖硬件特性,编程较底层。

方案三:信号量

信号量是操作系统提供的一种同步原语,是保护临界区和实现任务同步的标准且推荐的方法。可以将其理解为一个资源的计数器或一把钥匙。

在FreeRTOS中,常用的二进制信号量操作如下:

SemaphoreHandle_t xSemaphore;

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/a4bf4163983f4383713db818e20d01d1_16.png)

// 任务A(获取资源)
void taskA(void *pvParameters) {
    while (1) {
        // 尝试获取信号量(等待钥匙)
        if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
            // 进入临界区,安全地访问共享资源
            access_shared_resource();
            // 离开临界区,释放信号量(归还钥匙)
            xSemaphoreGive(xSemaphore);
        }
    }
}

// 任务B(获取资源)
void taskB(void *pvParameters) {
    while (1) {
        if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
            access_shared_resource();
            xSemaphoreGive(xSemaphore);
        }
    }
}
  • 优点:
    • 专业化:为每个共享资源创建独立的信号量,阻塞粒度小。
    • 高效:操作系统仅在管理信号量队列的极短时间内屏蔽中断。
    • 标准化:广泛使用,可读性和可维护性强。
  • 缺点:使用不当可能引发优先级反转。

优先级反转问题

优先级反转是使用信号量时可能遇到的一个经典问题。

问题描述:

  1. 低优先级任务C获取了某个共享资源的信号量。
  2. 高优先级任务A尝试获取同一信号量,但必须等待C释放,因此A被阻塞。
  3. 此时,中优先级任务B(不需求该资源)就绪。由于B优先级高于C,它开始运行。
  4. 结果:中优先级任务B实际上阻塞了高优先级任务A,因为B阻止了C运行,而C不运行就无法释放信号量,A也就无法继续。

解决方案:

  • 优先级继承:当低优先级任务持有高优先级任务所需的信号量时,操作系统临时将低优先级任务的优先级提升到与等待它的最高优先级任务相同。这样,它就能尽快执行并释放资源。
  • 优先级天花板协议:为信号量设置一个“天花板优先级”,任何获取该信号量的任务都将自动提升到此优先级。


实践示例:FreeRTOS多任务与LCD显示

我们将创建一个FreeRTOS示例,包含多个任务,并演示如何安全共享数据。

以下是核心任务框架:

// 共享变量
volatile int adc_value = 0;
volatile int blinker_pin = OFFBOARD_LED_PIN;

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/a4bf4163983f4383713db818e20d01d1_24.png)

// 任务1:闪烁LED
void blink_task(void *pvParameters) {
    pinMode(blinker_pin, OUTPUT);
    while (1) {
        digitalWrite(blinker_pin, HIGH);
        vTaskDelay(250 / portTICK_PERIOD_MS);
        digitalWrite(blinker_pin, LOW);
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/a4bf4163983f4383713db818e20d01d1_26.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/uwash-cse474-embsys-prog/img/a4bf4163983f4383713db818e20d01d1_28.png)

// 任务2:读取模拟输入并更新共享变量
void analog_read_task(void *pvParameters) {
    while (1) {
        adc_value = analogRead(ANALOG_PIN); // 写入共享变量
        Serial.println(adc_value); // 通过串口打印
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}

// 任务3:在LCD上显示ADC值
void lcd_display_task(void *pvParameters) {
    lcd_init(); // 初始化LCD
    while (1) {
        lcd_clear();
        lcd_set_cursor(0, 0);
        lcd_print("ADC: ");
        lcd_print(adc_value); // 读取共享变量
        vTaskDelay(300 / portTICK_PERIOD_MS);
    }
}

// 任务4:通过中断计数切换LED引脚
volatile int isr_count = 0;
void change_blink_task(void *pvParameters) {
    while (1) {
        while (isr_count < 110) {
            vTaskDelay(1); // 等待中断发生
        }
        isr_count = 0;
        // 切换LED引脚
        blinker_pin = (blinker_pin == ONBOARD_LED_PIN) ? OFFBOARD_LED_PIN : ONBOARD_LED_PIN;
    }
}

// 定时器中断服务程序
ISR(TIMER5_OVF_vect) {
    isr_count++; // 在ISR中更新计数
}

关键点:

  1. 共享变量:adc_value和blinker_pin被多个任务访问。对于在ISR中修改的变量(如isr_count),必须声明为volatile。
  2. 任务优先级:需要谨慎设置。不合理的优先级可能导致任务饥饿或系统死锁(如之前演示的优先级反转现象)。
  3. 串口通信:对于Arduino Mega等拥有多个硬件串口的设备,驱动外设(如串口LCD)时应优先使用硬件串口(如Serial1、Serial2、Serial3),其效率远高于软件模拟的SoftwareSerial库。

总结

本节课中我们一起学习了RTOS中进程间通信的核心知识。

我们首先分析了生产者-消费者模型及其基于环形缓冲区的实现。接着,探讨了操作系统提供的消息传递、邮箱、队列等高级IPC机制。然后,我们深入理解了在抢占式RTOS中,共享资源可能因任务切换而被破坏,从而引出了临界区的概念。

为了保护临界区,我们介绍了三种方案:简单但影响系统性能的全局中断屏蔽、高效的硬件级测试与置位指令,以及最通用和推荐的信号量机制。同时,我们也指出了信号量可能引发的优先级反转问题及其解决方案(优先级继承)。

最后,通过一个多任务FreeRTOS实践示例,我们综合运用了这些概念,演示了如何创建任务、安全共享变量、处理中断,并利用硬件串口驱动外设。请记住,在构建复杂的多任务系统时,合理设计任务优先级和正确使用同步原语(如信号量)是确保系统稳定可靠的关键。

017:FreeRTOS 进阶应用与考试说明

在本节课中,我们将学习FreeRTOS中更高级的应用,特别是如何将中断服务程序(ISR)与任务调度结合,以及如何使用队列(Queue)进行任务间通信。同时,我们也会详细介绍期末考试的安排和形式。

考试与课程评分更新

首先,我们来更新一下课程评分结构和期末考试的相关信息。

根据本学期的实际情况,我们对评分结构进行了调整。具体变化如下:

  • 取消了课堂参与分。
  • 实验四(Lab 4)的总分增加到100分。其中,第一部分(4.1)将获得额外的5分,第二部分(4.2)增加了15分,这些分数将用于评估项目实现的创新性和挑战性。
  • 期末考试的分值调整为50分。
  • 课程总分仍保持为450分不变。

接下来是关于期末考试的详细信息。

考试将在华盛顿大学官方安排的考试时间进行,具体时间请查看MyUW日程表。考试形式为线上进行,大家需要在指定时间登录Zoom。

考试将分为两部分,这两部分会同时开放,你可以按任意顺序完成。

  • 考试开始时间为下午2:30,结束时间为下午4:20。
  • 第一部分是Canvas平台上的选择题测验,预计占10到15分。
  • 第二部分是书面问答题,占总分的其余部分。

对于书面考试,你有多种提交方式:

  • 使用白纸手写答案,注明题目编号,然后通过扫描仪或手机扫描应用生成PDF。
  • 直接在文档中键入答案并保存为PDF。
  • 在平板设备上书写并生成PDF。
  • 请注意,我们不接受直接拍摄的照片,因为其质量通常难以保证。我们会推荐一些经过测试的免费手机扫描应用。

考试规则如下:

  • 独立完成,禁止查阅互联网。
  • 闭卷考试,但允许使用一张“小抄”(crib sheet)。你可以从任何笔记、视频或材料中总结信息并制作这张小抄以供考试时使用。

考试涵盖的主题大致如下:

  • C语言编程:可能需要编写小型函数或程序(无需运行)。
  • 微控制器架构:关于处理器工作原理的简答题或选择题。
  • 数据手册阅读理解:所有问题都会附上数据手册的摘录,你无需记忆,但需要根据提供的信息回答问题。
  • 调度概念与分析:涉及轮转调度、同步、任务控制块、抢占式调度等,可能需要绘制调度图。
  • 串行数据通信:包括USB等主题。
  • 临界区与信号量:主要是课堂和阅读材料中讨论过的内容。

此外,我会在考试准备就绪后,发布针对性的复习材料。由于课程内容与往年有所不同,我会专门整理贴合本次考试的资料供大家学习。

以上就是关于考试的主要信息。现在,让我们回到FreeRTOS的主题上。

FreeRTOS任务与中断服务程序(ISR)的整合

上一节我们介绍了FreeRTOS的基本任务创建和调度。本节中,我们来看看如何将硬件中断与FreeRTOS的任务系统优雅地结合。

我们之前有一个驱动七段数码管显示的例子,它作为一个FreeRTOS任务运行。但存在一个问题:显示闪烁严重。这是因为任务中使用了 vTaskDelay(1) 进行延时,而FreeRTOS的最小时间片(tick)是15毫秒,这个时间对于扫描显示来说太长了。

解决方案是:将显示扫描的代码移到一个定时器中断服务程序(ISR)中。这样我们就可以以更高的频率(例如1毫秒)来驱动显示,从而消除闪烁。

以下是实现此方案的核心代码结构。首先,我们设置一个定时器以1kHz(每秒1000次)的频率触发中断:

// 设置定时器4,产生1000Hz的中断
setupTimer4For1kHzInterrupt();
// 启用中断
enableTimer4Interrupt();

然后,在ISR中实现显示扫描逻辑。我们使用一个静态计数器 isr_count 来跟踪时间,而不是依赖操作系统的tick:

ISR(TIMER4_COMPA_vect) {
    static volatile int isr_count = 0;
    static int digit_pos = 0;

    if (isr_count == 0) {
        // 点亮当前位
        turnOnDigit(digit_pos);
        // 获取该位要显示的数字并转换为段码
        lightSegmentsForDigit(digits[digit_pos]);
    } else if (isr_count == DIGIT_ON_MS) { // 例如 3 毫秒后
        // 关闭当前位
        turnOffDigit(digit_pos);
        clearAllSegments();
    } else if (isr_count == (DIGIT_ON_MS + DIGIT_OFF_MS)) { // 例如 4 毫秒后
        // 准备扫描下一位
        digit_pos = (digit_pos + 1) % 4;
        isr_count = -1; // 将在末尾加回0
    }
    isr_count++;
}

通过这种方式,每个数字显示3毫秒,关闭1毫秒,整个扫描周期为4毫秒,远快于15毫秒的操作系统tick,从而实现了稳定无闪烁的显示。

一个重要提示:在编写ISR时,必须确保中断向量名称的拼写完全正确(包括大小写)。例如,TIMER4_COMPA_vect 如果写错,编译器可能不会报错,但中断将无法正常工作,导致程序卡死。

使用队列进行任务间通信

在之前的例子中,我们使用了全局变量在任务间共享数据。虽然可行,但这并非最佳实践。FreeRTOS提供了队列(Queue)机制,可以更安全、更高效地在任务与任务、或任务与ISR之间传递消息。

队列就像一个先入先出(FIFO)的缓冲区。一个任务可以发送消息到队列,另一个任务可以从队列中接收消息。如果队列为空,接收任务可以被自动挂起,直到有数据到来,这能有效节省CPU资源。

以下是队列的基本使用方法。

首先,在程序初始化时(例如 setup() 函数中)创建队列:

// 创建一个队列,可容纳2个元素,每个元素是一个整数(int)
QueueHandle_t qWhichLed = xQueueCreate(2, sizeof(int));

然后,在发送任务中,将数据放入队列:

void taskChangeLed(void *pvParameters) {
    int pinToUse = LED_OFFBOARD_PIN;
    while(1) {
        // 将引脚编号发送到队列尾部
        xQueueSendToBack(qWhichLed, &pinToUse, 0);
        vTaskDelay(2000 / portTICK_PERIOD_MS); // 延迟2秒

        pinToUse = (pinToUse == LED_OFFBOARD_PIN) ? LED_ONBOARD_PIN : LED_OFFBOARD_PIN;
    }
}

在接收任务中,从队列中取出数据:

void taskBlink(void *pvParameters) {
    int ledPinMessage;
    while(1) {
        // 尝试从队列接收数据,等待时间为0(不阻塞)
        if(xQueueReceive(qWhichLed, &ledPinMessage, 0) == pdTRUE) {
            // 成功收到新的引脚编号,更新用于闪烁的引脚
            currentBlinkPin = ledPinMessage;
        }
        // 执行闪烁逻辑...
        digitalWrite(currentBlinkPin, HIGH);
        vTaskDelay(350 / portTICK_PERIOD_MS);
        digitalWrite(currentBlinkPin, LOW);
        vTaskDelay(350 / portTICK_PERIOD_MS);
    }
}

在中断服务程序中使用队列

需要注意的是,在ISR内部不能直接使用普通的队列函数(如 xQueueSendToBack),因为ISR需要快速执行,且不能调用可能引起阻塞的函数。FreeRTOS提供了专用于ISR的“FromISR”版本API。

例如,如果要在ISR中向队列发送数据,应使用 xQueueSendToBackFromISR:

ISR(SOME_INTERRUPT_VECTOR) {
    int dataToSend = readSomeData();
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    // 从ISR内部发送数据到队列
    xQueueSendToBackFromISR(qDataFromIsr, &dataToSend, &xHigherPriorityTaskWoken);

    // 如果发送操作唤醒了更高优先级的任务,可能需要触发一次上下文切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

同样,如果要在ISR中从队列接收数据,则应使用 xQueueReceiveFromISR。这些 FromISR 函数是设计用于中断上下文的安全版本。

总结

本节课中我们一起学习了FreeRTOS的两个进阶主题。首先,我们探讨了如何利用中断服务程序(ISR)来处理对时间要求苛刻的操作(如显示扫描),以绕过操作系统调度器的粒度限制。其次,我们介绍了使用队列(Queue)进行任务间通信的最佳实践,它比全局变量更安全、更高效,并了解了在ISR中使用队列的特殊方法。最后,我们详细说明了本学期期末考试的更新安排、形式和内容范围。希望大家能运用这些知识完善实验,并为考试做好准备。

018:关键部分与信号量导论

在本节课中,我们将学习如何管理嵌入式系统中的共享资源,特别是通过信号量来保护关键部分。我们还将了解课程的最新安排,包括实验4的评分调整和期末考试的准备。

课程与实验更新

上一节我们介绍了多任务系统的基本概念,本节中我们来看看课程的最新安排。

首先,关于实验4的评分标准,我们进行了一些调整,以更全面地评估项目的技术价值、创造性和挑战性。

以下是更新后的评分因素:

  • 项目技术价值:项目是否满足原始实验说明中列出的标准。此部分增加了5分。
  • 项目创造性:项目的创新性和雄心程度。此部分增加了5分。
  • 问题解决:项目是否至少从概念上解决了用户的某个实际问题。此部分保持5分不变。
  • 项目挑战等级:项目的难度级别。这是一个新的类别,占10分。
  • 技术沟通:实验报告的清晰度和完整性。此部分保持10分不变。

因此,实验的总分提高到了100分。这些调整旨在鼓励更具挑战性和创新性的项目。

关于期末考试,我将尽快发布一份学习指南。我的目标是让学习指南与考试题目有实质性的重叠,使其真正成为备考工具。我计划在考试前一周的周末发布学习指南的答案,以便大家有充足的时间独立练习和思考。

实验代码示例解析

现在,让我们回到一个具体的代码示例,它展示了如何在中断服务程序(ISR)中使用队列进行任务间通信。

这个系统包含两个主要任务:一个闪烁LED的任务和一个递增计数的任务。计数任务将其计数值通过队列发送给一个专门负责更新七段数码管显示的中断服务程序。

核心代码片段:

// 创建队列,用于传递4个整型数字(代表4位数)
xQueueDisplay = xQueueCreate(10, sizeof(int) * 4);

// 计数任务将数字放入队列
xQueueSend(xQueueDisplay, digits, portMAX_DELAY);

// 显示ISR从队列中获取数字
xQueueReceiveFromISR(xQueueDisplay, displayDigits, &xHigherPriorityTaskWoken);

之前代码无法工作的原因是我忘记声明队列句柄(QueueHandle_t)变量,并且移除了一个全局指针,但没有在相关函数中将其定义为静态变量。修复这些问题后,代码即可正常运行。

这个示例的关键在于,将显示刷新放在一个高频定时器中断中,而不是在任务中。因为FreeRTOS的任务调度器节拍通常是15毫秒,这对于无闪烁的显示来说太慢了。通过将中断频率设置为1000赫兹,我们获得了稳定、无闪烁的显示效果。

此外,我们还测试了系统处理队列消息的能力。当计数任务以每秒10次的速度发送消息时,系统表现良好。但当速度提高到每秒100次时,显示开始出现异常。这表明我们需要测试系统的极限,以确保在实际应用中有足够的安全裕度。

FreeRTOS任务通知简介

上一节我们使用了队列进行通信,本节中我们来看看FreeRTOS提供的另一种轻量级同步机制:任务通知。

任务通知可以被用作信号量的轻量级替代品,尤其适用于保护关键部分。它的开销通常比传统的信号量更小。

基本使用步骤:

  1. 获取任务句柄:在创建任务时,需要获取一个TaskHandle_t类型的句柄。

    TaskHandle_t xTaskHandle;
    xTaskCreate(vTaskFunction, "TaskName", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY, &xTaskHandle);
    
  2. 发送通知:一个任务或中断可以使用xTaskNotifyGive()或vTaskNotifyGiveFromISR()向另一个任务发送通知。

    xTaskNotifyGive(xTaskHandle); // 在任务中发送
    vTaskNotifyGiveFromISR(xTaskHandle, &xHigherPriorityTaskWoken); // 在ISR中发送
    
  3. 接收通知:任务可以调用ulTaskNotifyTake()来等待通知。这个函数会阻塞任务,直到收到通知或超时。

    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
    

    其中,第一个参数pdTRUE表示在退出时将通知值清零(适用于二值信号量场景);第二个参数是等待的最大时间(以系统节拍为单位),portMAX_DELAY表示无限期等待。

任务通知机制允许任务高效地等待事件,并且在等待时不消耗CPU时间,调度器可以运行其他任务。

项目构思问答与建议

在课程的最后互动环节,同学们提出了一些关于最终项目的构思,并获得了一些扩展建议。

项目构思1:密码锁

  • 核心想法:使用矩阵键盘输入密码,在LCD上显示,若密码正确则驱动舵机打开锁。
  • 建议:基础功能略显简单。可以增加需要高速处理的模块,例如:
    • 用拇指摇杆录入并识别手势密码。
    • 将LCD替换为需要更高刷新率的七段数码管。
    • 增加红外光束,一旦被触发立即锁死。

项目构思2:火灾报警系统

  • 核心想法:读取温度传感器数据,超过阈值则触发蜂鸣器报警、LCD显示警告并启动风扇。
  • 建议:核心逻辑(读取-判断-响应)较为直接。建议在基础上增加层次:
    • 添加RFID读卡器,刷卡后才能关闭警报。
    • 加入后台任务,例如对传感器数据进行FFT分析,显示主要频率成分,做成一个频谱仪。
    • 考虑使用两个Arduino板进行通信,构建分布式系统。

通用建议:

  • 从简单核心开始:先实现一个稳定可靠的基本功能,再逐步添加更复杂、更具挑战性的特性。
  • 利用串口通信:实现Arduino与电脑的串口通信是一个有价值的新技术点,可以用于配置、监控或数据交换。
  • 思考实际应用:项目最好能解决一个可以直观描述的问题(例如“这是一个智能车锁”),而不仅仅是组件的简单堆砌。
  • 探索低功耗(进阶):如果有条件,可以尝试优化系统功耗,探索如何让设备在电池供电下运行更长时间。

总结

本节课中我们一起学习了几个重要内容。首先,我们了解了实验4评分标准的更新,强调了项目的挑战性和创新性。接着,我们通过一个代码示例,深入探讨了如何使用队列和中断服务程序来实现高效、无闪烁的显示更新,并测试了系统的通信负载能力。然后,我们介绍了FreeRTOS的任务通知机制,它是一种轻量级的任务同步方法,可以作为信号量的高效替代方案。最后,通过项目构思问答,我们探讨了如何设计并扩展一个具有足够深度和复杂度的嵌入式系统项目。希望这些知识能帮助大家顺利完成最终项目并为期末考试做好准备。

posted @ 2026-03-29 09:38  布客飞龙I  阅读(34)  评论(0)    收藏  举报