【花雕学编程】Arduino RTOS 之互斥锁与共享数据结构

Arduino是一个开放源码的电子原型平台，它可以让你用简单的硬件和软件来创建各种互动的项目。Arduino的核心是一个微控制器板，它可以通过一系列的引脚来连接各种传感器、执行器、显示器等外部设备。Arduino的编程是基于C/C++语言的，你可以使用Arduino IDE（集成开发环境）来编写、编译和上传代码到Arduino板上。Arduino还有一个丰富的库和社区，你可以利用它们来扩展Arduino的功能和学习Arduino的知识。

Arduino的特点是：
1、开放源码：Arduino的硬件和软件都是开放源码的，你可以自由地修改、复制和分享它们。
2、易用：Arduino的硬件和软件都是为初学者和非专业人士设计的，你可以轻松地上手和使用它们。
3、便宜：Arduino的硬件和软件都是非常经济的，你可以用很低的成本来实现你的想法。
4、多样：Arduino有多种型号和版本，你可以根据你的需要和喜好来选择合适的Arduino板。
5、创新：Arduino可以让你用电子的方式来表达你的创意和想象，你可以用Arduino来制作各种有趣和有用的项目，如机器人、智能家居、艺术装置等。

Arduino FreeRTOS是一个结合了Arduino平台和FreeRTOS实时操作系统（RTOS）的概念。为了全面详细地解释这个概念，我们可以从以下几个方面进行阐述：

一、Arduino平台
Arduino是一个开源的硬件和软件平台，旨在简化电子设备的原型设计和开发。它包含了一系列基于易用硬件和软件的微控制器，以及一个用于编写和上传代码的集成开发环境（IDE）。Arduino平台以其简洁的编程接口和丰富的扩展功能，成为了电子爱好者、设计师、工程师和艺术家们的首选工具。

二、FreeRTOS实时操作系统（RTOS）
FreeRTOS是一个开源的、轻量级的实时操作系统内核，专为嵌入式设备设计。它提供了任务管理、时间管理、信号量、消息队列、内存管理、软件定时器等一系列功能，以满足较小系统的需求。FreeRTOS以其源码公开、可移植、可裁减和调度策略灵活的特点，受到了广大嵌入式开发者的青睐。

三、Arduino FreeRTOS
1、定义：Arduino FreeRTOS是指在Arduino平台上运行FreeRTOS实时操作系统的解决方案。它允许开发者在Arduino设备上实现多任务并行处理，从而提高程序的灵活性和响应性。

2、功能：
多任务处理：使用FreeRTOS，开发者可以在Arduino上同时运行多个任务，每个任务独立执行不同的操作。这有助于将复杂的项目分解为多个并发执行的部分，从而提高开发效率。
实时性要求高的应用：FreeRTOS能够确保任务按照预定的时间约束执行，满足实时性要求。通过设置任务的优先级和时间片轮转调度策略，开发者可以控制任务的执行顺序和频率。
通信与同步：FreeRTOS提供了多种通信和同步机制，如队列、信号量、互斥锁等。这些机制有助于在不同的任务之间进行数据交换和同步操作，实现任务之间的协作。
低功耗应用：FreeRTOS提供了休眠和唤醒机制，有助于优化功耗。开发者可以将某些任务设置为休眠状态，在需要时唤醒它们来执行操作，从而减少功耗。

3、优势：
提高程序的复杂性和功能：通过多任务并行处理，Arduino FreeRTOS允许开发者实现更复杂的软件架构和更高效的代码执行。
增强实时性：FreeRTOS确保了任务的实时响应，这对于需要精确时间控制的应用至关重要。
简化编程：将复杂的逻辑分解为多个任务，使得代码更易于理解和维护。
移植性：FreeRTOS支持多种微控制器平台，使得基于FreeRTOS的项目在不同硬件间的移植变得更加容易。

4、注意事项：
虽然FreeRTOS带来了多任务的优势，但也会增加编程难度和调试工作。因此，在选择是否使用FreeRTOS时，开发者需要权衡利弊。
在使用FreeRTOS时，开发者需要注意任务堆栈大小、优先级设置等参数，以确保系统的稳定性和可靠性。
综上所述，Arduino FreeRTOS是一个结合了Arduino平台和FreeRTOS实时操作系统的强大解决方案。它允许开发者在Arduino设备上实现多任务并行处理，提高程序的复杂性和功能，同时保持代码的可读性和可靠性。

一、主要特点
（一）互斥锁
互斥访问保障
互斥锁是一种同步原语，其主要功能是确保在任何时刻只有一个任务（线程）能够访问共享资源。例如，在一个多任务的 Arduino RTOS 环境中，如果多个任务都需要访问一个硬件资源（如传感器或通信接口），互斥锁可以防止这些任务同时访问，避免数据冲突和硬件操作混乱。
它通过 “锁定” 和 “解锁” 机制来实现互斥访问。当一个任务获取（锁定）互斥锁后，其他任务试图获取该锁时会被阻塞，直到锁被释放。这种机制就像一个房间的钥匙，只有拿到钥匙的任务才能进入房间（访问共享资源），其他任务只能等待钥匙被归还（锁被解锁）。
简单的实现原理
互斥锁的实现原理相对直观。在底层，它通常是基于一个标志位来表示锁的状态（锁定或解锁）。当一个任务请求获取互斥锁时，系统会检查这个标志位。如果标志位表示锁是解锁状态，任务可以成功获取锁，并将标志位设置为锁定；如果标志位是锁定状态，任务会进入等待队列，直到锁被释放。这种简单的实现方式使得互斥锁在概念上易于理解，并且在大多数操作系统中都有高效的实现。
（二）共享数据结构
数据共享的便利性
共享数据结构允许不同的任务之间共享数据。在 Arduino RTOS 中，这可以是各种数据类型，如数组、链表、结构体等。例如，一个用于存储传感器数据的数组可以被数据采集任务和数据处理任务共享。数据采集任务将新获取的传感器数据存入数组，数据处理任务从数组中读取数据进行分析，这种共享机制提高了数据的利用率和系统的协同性。
它能够促进任务之间的通信。通过共享数据结构，任务可以传递信息、状态和指令。例如，在一个智能家居控制系统中，一个任务负责接收用户的指令并将其存储在共享的结构体中，另一个任务负责读取这个结构体中的指令并控制相应的家电设备，实现了任务间的有效沟通。
数据一致性维护挑战
由于多个任务可以访问共享数据结构，因此需要确保数据的一致性。当一个任务正在修改共享数据结构中的数据时，如果其他任务同时读取或修改这些数据，可能会导致数据不一致或错误。例如，在一个共享的计数器变量中，如果两个任务同时对其进行加 1 操作，可能会导致计数器的值只增加了 1 而不是预期的 2，这就需要合适的同步机制来维护数据的一致性。

二、应用场景
（一）传感器数据采集与处理
避免数据冲突
在一个物联网设备中，可能有多个任务分别负责采集不同传感器的数据（如温度、湿度、光照等），并且还有一个任务负责对这些数据进行综合处理。互斥锁可以用于保护传感器数据的存储区域（共享数据结构），确保在数据写入和读取过程中不会发生冲突。例如，当温度传感器采集任务正在将新的数据写入共享的传感器数据数组时，互斥锁会阻止其他传感器采集任务或数据处理任务对该数组进行访问，直到写入操作完成。
这样可以保证数据的完整性和准确性。在处理敏感的传感器数据（如医疗设备中的生理数据）时，数据的准确性至关重要，互斥锁和共享数据结构的正确使用可以防止数据损坏或错误解读，从而保障系统的可靠性。
（二）多任务设备控制
资源协调
在智能家居系统或工业自动化系统中，多个设备可能需要通过 Arduino RTOS 进行控制。例如，一个智能家庭系统中有智能灯、智能窗帘和智能空调等设备，不同的任务负责控制这些设备的不同功能。互斥锁可以用于协调对共享设备状态数据结构的访问，确保设备状态的一致性。例如，当一个任务正在更新智能灯的亮度状态时，其他任务不能同时修改这个状态，避免了设备状态的混乱。
共享数据结构可以用于存储设备的控制指令和状态信息。例如，一个共享的命令队列数据结构可以存储用户对各个设备的控制指令，不同的控制任务从这个队列中获取指令并执行相应的操作，实现了对多个设备的有序控制。
（三）网络通信与数据传输
数据共享与同步
在网络通信应用中，数据的接收和发送任务可能需要共享数据缓冲区（共享数据结构）。互斥锁可以防止接收任务和发送任务同时对缓冲区进行操作，避免数据丢失或混乱。例如，在一个 Wi - Fi 通信模块的数据处理过程中，接收任务将接收到的数据存入共享缓冲区，发送任务从缓冲区中取出数据进行发送，互斥锁确保了这个过程的有序进行。
对于多连接的网络设备，共享数据结构还可以用于存储连接状态和客户端信息。不同的任务可以通过访问这些共享数据来管理网络连接，如检查连接是否活跃、获取客户端请求等，同时互斥锁保证了在多任务处理网络连接相关事务时的数据安全。

三、需要注意的事项
（一）死锁风险
死锁产生的原因
在使用互斥锁时，一个主要的风险是死锁。死锁通常发生在多个任务相互等待对方释放互斥锁的情况下。例如，任务 A 获取了互斥锁 1，任务 B 获取了互斥锁 2，然后任务 A 试图获取互斥锁 2，任务 B 试图获取互斥锁 1，这样两个任务就会陷入无限等待，导致系统死锁。
这种情况可能在复杂的任务嵌套或循环等待互斥锁的场景中出现。例如，在一个多层嵌套的函数调用中，如果不同层次的函数分别获取不同的互斥锁，并且顺序不当，就很容易引发死锁。
死锁的预防措施
为了避免死锁，需要遵循一定的互斥锁获取顺序。在系统设计阶段，确定所有任务获取互斥锁的顺序，并确保所有任务都按照这个顺序获取锁。另外，可以采用超时机制，当一个任务等待互斥锁的时间过长时，释放已经获取的其他互斥锁，以避免死锁的持续。
（二）性能开销
互斥锁操作的成本
互斥锁的获取和释放操作会带来一定的性能开销。每次获取或释放互斥锁都需要进行系统调用和内核操作，这会消耗一定的 CPU 时间和系统资源。在资源有限的 Arduino 设备上，频繁的互斥锁操作可能会影响系统的整体性能。例如，在一个对实时性要求很高的任务中，如果频繁地等待互斥锁，可能会导致任务响应延迟。
共享数据结构的大小和复杂性也会影响性能。较大的数据结构在进行数据访问和修改时可能需要更多的时间和资源，特别是在多任务同时访问的情况下。例如，一个大型的共享数组在进行元素更新时，如果没有合理的同步机制，可能会导致较长的等待时间和系统开销。
性能优化策略
为了减少性能开销，可以尽量缩小互斥锁的作用范围。只在真正需要保护共享资源的关键代码段使用互斥锁，避免不必要的锁操作。对于共享数据结构，可以采用更高效的数据访问方式，如使用合适的数据结构来减少数据查找和修改的时间，或者采用缓存机制来提高数据访问效率。
（三）数据竞争和不一致性
数据竞争的危害
当多个任务在没有适当同步机制的情况下访问共享数据结构时，会出现数据竞争。这可能导致数据的不一致性、错误的值或不可预测的系统行为。例如，在一个共享的计数器变量中，如果没有互斥锁保护，多个任务同时对其进行读写操作，可能会导致计数器的值出现错误，进而影响整个系统的逻辑和功能。
数据不一致性还可能在任务中断或异常情况下出现。例如，一个任务在修改共享数据结构的过程中被中断，另一个任务在中断期间访问了这个未完成修改的数据结构，就会导致数据不一致。
数据一致性维护策略
为了维护数据一致性，除了使用互斥锁外，还可以采用其他同步机制，如信号量、条件变量等。在修改共享数据结构时，尽量采用原子操作（不可被中断的操作），或者在关键操作前后进行数据备份和恢复，以确保数据的完整性。同时，在任务设计中，要考虑到可能出现的中断和异常情况，对共享数据结构的访问进行合理的保护。

1、基础互斥锁使用

#include <Arduino_FreeRTOS.h>

SemaphoreHandle_t mutex;
int sharedData = 0; // 共享数据

void task1(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY); // 获取互斥锁
        sharedData += 1; // 修改共享数据
        Serial.print("Task 1: ");
        Serial.println(sharedData);
        xSemaphoreGive(mutex); // 释放互斥锁
        vTaskDelay(500 / portTICK_PERIOD_MS); // 延迟
    }
}

void task2(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY); // 获取互斥锁
        sharedData += 2; // 修改共享数据
        Serial.print("Task 2: ");
        Serial.println(sharedData);
        xSemaphoreGive(mutex); // 释放互斥锁
        vTaskDelay(300 / portTICK_PERIOD_MS); // 延迟
    }
}

void setup() {
    Serial.begin(9600);
    mutex = xSemaphoreCreateMutex(); // 创建互斥锁
    xTaskCreate(task1, "Task 1", 100, NULL, 1, NULL);
    xTaskCreate(task2, "Task 2", 100, NULL, 1, NULL);
}

void loop() {
    // 主循环为空
}

2、多个任务读取共享数据

#include <Arduino_FreeRTOS.h>

SemaphoreHandle_t mutex;
int sharedData = 0; // 共享数据

void producerTask(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        sharedData += 1; // 生产数据
        Serial.print("Producer: ");
        Serial.println(sharedData);
        xSemaphoreGive(mutex);
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}

void consumerTask(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        Serial.print("Consumer read: ");
        Serial.println(sharedData); // 读取共享数据
        xSemaphoreGive(mutex);
        vTaskDelay(300 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(9600);
    mutex = xSemaphoreCreateMutex(); // 创建互斥锁
    xTaskCreate(producerTask, "Producer", 100, NULL, 1, NULL);
    xTaskCreate(consumerTask, "Consumer", 100, NULL, 1, NULL);
}

void loop() {
    // 主循环为空
}

3、共享数据结构与互斥锁

#include <Arduino_FreeRTOS.h>

SemaphoreHandle_t mutex;

struct SharedData {
    int counter;
    float value;
};

SharedData sharedData; // 共享数据结构

void taskIncrement(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        sharedData.counter += 1; // 修改共享数据
        Serial.print("Increment Task: ");
        Serial.println(sharedData.counter);
        xSemaphoreGive(mutex);
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}

void taskUpdate(void *pvParameters) {
    for (;;) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        sharedData.value += 0.1; // 修改共享数据
        Serial.print("Update Task: ");
        Serial.println(sharedData.value);
        xSemaphoreGive(mutex);
        vTaskDelay(300 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(9600);
    mutex = xSemaphoreCreateMutex(); // 创建互斥锁
    sharedData.counter = 0;
    sharedData.value = 0.0;

    xTaskCreate(taskIncrement, "Increment Task", 100, NULL, 1, NULL);
    xTaskCreate(taskUpdate, "Update Task", 100, NULL, 1, NULL);
}

void loop() {
    // 主循环为空
}

要点解读
互斥锁的基本概念: 互斥锁用于保护共享数据，确保在同一时刻只有一个任务可以访问共享数据。在所有案例中，使用 xSemaphoreTake() 和 xSemaphoreGive() 函数来获取和释放互斥锁，确保数据访问的安全性。
共享数据的安全访问: 所有案例展示了如何在多个任务间安全地访问共享数据。通过互斥锁，避免了竞争条件，使得 sharedData 在修改时不会被其他任务干扰，保持数据的一致性。
任务间的数据交互: 案例 2 中的生产者-消费者模型展示了如何在多个任务间进行数据的生产和消费。生产者任务增加共享数据，而消费者任务读取该数据，利用互斥锁确保操作的原子性。
共享数据结构: 案例 3 中引入了一个结构体 SharedData，展示了如何在 RTOS 中使用复杂的数据结构。通过互斥锁保护整个结构体的数据字段，允许多个任务同时对不同字段进行操作，提高了代码的可扩展性。
任务调度与实时性: 使用 RTOS 可以实现任务的优先级管理，确保关键任务能够及时执行。互斥锁的使用虽然会引入一些延迟（因需要等待锁），但仍然能够在多任务环境中保持良好的实时性和响应性。

4、基本的互斥锁与共享计数器

#include <Arduino.h>
#include <FreeRTOS.h>

SemaphoreHandle_t xMutex;
volatile int sharedCounter = 0; // 共享计数器

void TaskIncrement(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            sharedCounter++;
            Serial.print("计数器增加到: ");
            Serial.println(sharedCounter);
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void TaskDecrement(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            sharedCounter--;
            Serial.print("计数器减少到: ");
            Serial.println(sharedCounter);
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(150 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(115200);
    xMutex = xSemaphoreCreateMutex(); // 创建互斥锁
    xTaskCreate(TaskIncrement, "Increment", 100, NULL, 1, NULL);
    xTaskCreate(TaskDecrement, "Decrement", 100, NULL, 1, NULL);
}

void loop() {
    vTaskDelay(portMAX_DELAY);
}

要点解读
互斥锁的创建：使用xSemaphoreCreateMutex()创建一个互斥锁，确保对共享资源的互斥访问。
共享数据结构：定义一个共享计数器sharedCounter，在多个任务中进行增减操作。
安全访问共享资源：每个任务在访问共享计数器前先获取互斥锁，操作后释放锁，确保数据一致性。
任务调度：通过vTaskDelay()控制任务的执行频率，避免过度占用CPU资源。
串口输出：实时输出计数器的当前值，便于观察任务的执行效果。

5、互斥锁与共享缓冲区

#include <Arduino.h>
#include <FreeRTOS.h>

#define BUFFER_SIZE 5
int buffer[BUFFER_SIZE];
int count = 0;

SemaphoreHandle_t xMutex, xEmpty, xFull;

void TaskProducer(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xEmpty, portMAX_DELAY)) {
            if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
                buffer[count++] = random(100); // 生产随机数
                Serial.print("生产: ");
                Serial.println(buffer[count - 1]);
                xSemaphoreGive(xMutex);
            }
            xSemaphoreGive(xFull); // 增加满缓冲区信号
        }
        vTaskDelay(100 / portTICK_PERIOD_MS);
    }
}

void TaskConsumer(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xFull, portMAX_DELAY)) {
            if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
                int value = buffer[--count]; // 消费数据
                Serial.print("消费: ");
                Serial.println(value);
                xSemaphoreGive(xMutex);
            }
            xSemaphoreGive(xEmpty); // 增加空缓冲区信号
        }
        vTaskDelay(150 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(115200);
    xMutex = xSemaphoreCreateMutex(); // 创建互斥锁
    xEmpty = xSemaphoreCreateCounting(BUFFER_SIZE, BUFFER_SIZE); // 空缓冲区信号
    xFull = xSemaphoreCreateCounting(BUFFER_SIZE, 0); // 满缓冲区信号
    xTaskCreate(TaskProducer, "Producer", 1000, NULL, 1, NULL);
    xTaskCreate(TaskConsumer, "Consumer", 1000, NULL, 1, NULL);
}

void loop() {
    vTaskDelay(portMAX_DELAY);
}

要点解读
共享缓冲区：定义一个固定大小的缓冲区buffer，用于在生产者和消费者之间传递数据。
互斥锁与信号量结合：使用互斥锁保护对缓冲区的访问，同时使用空和满信号量控制生产者和消费者的同步。
生产者-消费者模型：实现一个经典的生产者-消费者问题，生产者生成数据，消费者消费数据，确保两者协调运行。
任务调度控制：通过vTaskDelay()控制任务的执行频率，确保系统的稳定性和可控性。
串口监控：实时输出生产和消费的结果，便于调试和验证程序的正确性。

6、互斥锁与共享状态管理

#include <Arduino.h>
#include <FreeRTOS.h>

SemaphoreHandle_t xMutex;
struct SharedData {
    int value;
    bool ready;
} sharedData;

void TaskSetValue(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            sharedData.value = random(100); // 设置随机值
            sharedData.ready = true; // 标记状态为准备就绪
            Serial.print("设置值: ");
            Serial.println(sharedData.value);
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void TaskPrintValue(void *pvParameters) {
    for (;;) {
        if (xSemaphoreTake(xMutex, portMAX_DELAY)) {
            if (sharedData.ready) {
                Serial.print("读取值: ");
                Serial.println(sharedData.value);
                sharedData.ready = false; // 重置状态
            }
            xSemaphoreGive(xMutex);
        }
        vTaskDelay(150 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(115200);
    xMutex = xSemaphoreCreateMutex(); // 创建互斥锁
    sharedData.value = 0;
    sharedData.ready = false;
    xTaskCreate(TaskSetValue, "SetValue", 1000, NULL, 1, NULL);
    xTaskCreate(TaskPrintValue, "PrintValue", 1000, NULL, 1, NULL);
}

void loop() {
    vTaskDelay(portMAX_DELAY);
}

要点解读
共享状态管理：定义一个结构体SharedData，包含一个值和一个状态标志，表示是否准备就绪。
互斥锁保护共享资源：使用互斥锁确保对共享数据的安全访问，防止数据竞争。
任务间的状态同步：通过状态标志ready控制数据的读取与写入，提高任务之间的协调性。
灵活的任务调度：结合vTaskDelay()实现任务的时间控制，保证系统的稳定。
串口输出监控：通过串口输出设置和读取的值，便于观察任务的执行情况和调试。

注意，以上案例只是为了拓展思路，仅供参考。它们可能有错误、不适用或者无法编译。您的硬件平台、使用场景和Arduino版本可能影响使用方法的选择。实际编程时，您要根据自己的硬件配置、使用场景和具体需求进行调整，并多次实际测试。您还要正确连接硬件，了解所用传感器和设备的规范和特性。涉及硬件操作的代码，您要在使用前确认引脚和电平等参数的正确性和安全性。