七个项目掌握freertos_freertos项目

1、闪烁LED：

最基本的示例项目，涉及到创建一个简单的任务，用于控制LED的闪烁。这个项目会教你如何初始化FreeRTOS并创建任务。

#include "FreeRTOS.h"
#include "task.h"
#define LED_PIN (某个GPIO引脚)
 
void vBlinkTask(void *pvParameters) {
    while(1) {
        // Toggle LED状态
        gpio_set_level(LED_PIN, !gpio_get_level(LED_PIN));
        
        // 500毫秒延时
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}
 
int main(void) {
    // 初始化硬件
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
 
    // 创建闪烁LED的任务
    xTaskCreate(vBlinkTask, "BlinkTask", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL);
    
    // 启动调度器
    vTaskStartScheduler();
 
    // 如果执行到这里，那么会有问题
    for( ;; );
}

2、任务通信：

创建两个任务，使用队列来在它们之间传递消息。这个项目可以帮助你理解FreeRTOS中的任务同步和通信机制。

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
 
QueueHandle_t xQueue;
 
void vSenderTask(void *pvParameters) {
    int32_t lValueToSend = 0;
    while(1) {
        // 发送一个值到队列中
        xQueueSend(xQueue, &lValueToSend, 0);
        lValueToSend++;
        
        // 间隔一秒
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
 
void vReceiverTask(void *pvParameters) {
    int32_t lReceivedValue;
    while(1) {
        // 从队列中接收数据
        if(xQueueReceive(xQueue, &lReceivedValue, portMAX_DELAY)) {
            // 成功接收到数据，lReceivedValue有新值
        }
    }
}
 
int main(void) {
    // 创建队列，长度为1，数据大小为int32_t
    xQueue = xQueueCreate(1, sizeof(int32_t));
    
    // 创建两个任务
    xTaskCreate(vSenderTask, "SenderTask", 1000, NULL, 1, NULL);
    xTaskCreate(vReceiverTask, "ReceiverTask", 1000, NULL, 1, NULL);
    
    // 启动调度器
    vTaskStartScheduler();
    
    return 0;
}

3、多任务管理：

创建多个任务，包括周期性任务和响应外部事件（如按钮按下）的任务。这有助于你学习任务优先级和调度。

#include "FreeRTOS.h"
#include "task.h"
 
void vTaskFunction(void *pvParameters) {
    for (;;) {
        // 任务具体的代码
 
        vTaskDelay(一个时间周期);
    }
}
 
int main(void) {
    xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(vTaskFunction, "Task2", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
 
    vTaskStartScheduler();
 
    return 0;
}

4、利用信号量控制资源访问：

用一个或多个任务来模拟资源（如串口）的访问，并使用信号量来同步对该资源的访问。

#include "FreeRTOS.h"
#include "semphr.h"
 
SemaphoreHandle_t xSemaphore;
 
void vTaskFunction(void *pvParameters) {
    for (;;) {
        // 获取信号量
        if (xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
            // 访问资源
 
            // 释放信号量
            xSemaphoreGive(xSemaphore);
        }
    }
}
 
int main(void) {
    xSemaphore = xSemaphoreCreateMutex();
    xTaskCreate(vTaskFunction, "Task1", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
    xTaskCreate(vTaskFunction, "Task2", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
 
    vTaskStartScheduler();
 
    return 0;
}

5、模拟温度监控系统：

创建任务来模拟温度传感器的读取，并通过队列将数据发送给数据处理任务。

#include "FreeRTOS.h"
#include "queue.h"
 
QueueHandle_t xQueue;
 
void vSensorTask(void *pvParameters) {
    float temperature;
 
    for (;;) {
        // 模拟读取温度传感器数据
        temperature = getTemperature();
 
        // 将数据放入队列
        xQueueSend(xQueue, &temperature, portMAX_DELAY);
    }
}
 
int main(void) {
    xQueue = xQueueCreate(10, sizeof(float));
 
    xTaskCreate(vSensorTask, "SensorTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
 
    vTaskStartScheduler();
 
    return 0;
}

6、FreeRTOS内存管理：

学习和实践FreeRTOS的内存分配和释放，理解不同内存管理方案的使用。

#include "FreeRTOS.h"
#include "task.h"
 
// 声明两个任务的函数原型
void vProducerTask(void *pvParameters);
void vConsumerTask(void *pvParameters);
 
// 定义全局队列句柄
QueueHandle_t xQueue;
 
int main(void) {
    // 创建一个队列，能够存储10个int类型的指针
    xQueue = xQueueCreate(10, sizeof(int *));
 
    if (xQueue != NULL) {
        // 创建任务
        xTaskCreate(vProducerTask, "Producer", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        xTaskCreate(vConsumerTask, "Consumer", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
 
        // 启动调度器
        vTaskStartScheduler();
    }
 
    // 在这里应该永远执行不到
    for (;;);
}
 
void vProducerTask(void *pvParameters) {
    int *piValue;
    while (1) {
        // 动态分配内存
        piValue = (int *) pvPortMalloc(sizeof(int));
        
        if (piValue != NULL) {
            // 在分配的内存中存储数值
            *piValue = rand() % 100;
 
            // 将内存指针发送到队列
            if(xQueueSend(xQueue, &piValue, portMAX_DELAY) != pdPASS) {
                // 如果发送失败则释放内存
                vPortFree(piValue);
            }
        }
 
        // 模拟生产者速率
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
 
void vConsumerTask(void *pvParameters) {
    int *piValue;
    while (1) {
        if (xQueueReceive(xQueue, &piValue, portMAX_DELAY) == pdPASS) {
            // 从队列中接收到内存指针, 处理数据
            processValue(*piValue);
            
            // 释放内存
            vPortFree(piValue);
        }
    }
}
 
void processValue(int value) {
    // 在这里实现数据处理
}

7、FreeRTOS软件定时器：

配置和使用FreeRTOS的软件定时器，进行周期性任务的调度。

#include "FreeRTOS.h"
#include "timers.h"
 
// 定时器的回调函数
void vTimerCallback(TimerHandle_t xTimer);
 
int main(void) {
    // 初始化硬件，根据具体平台进行相应初始化，例如GPIO、中断等。
 
    // 创建定时器
    TimerHandle_t xExampleTimer;
 
    // 定时器的ID，没有特殊用途时可以设置为NULL
    const uint32_t timerID = 0;
 
    // 创建软件定时器，设置定时500毫秒, 自动重载，timerID为定时器ID，vTimerCallback为回调函数
    xExampleTimer = xTimerCreate("Timer", pdMS_TO_TICKS(500), pdTRUE, (void *)timerID, vTimerCallback);
 
    // 启动定时器，定时器会在启动后的500毫秒后执行回调函数。0表示不等待命令发送到定时器命令队列。
    if (xExampleTimer != NULL) {
        xTimerStart(xExampleTimer, 0);
    }
 
    // 启动调度器，开始执行任务
    vTaskStartScheduler();
 
    // 如果程序执行到这里，那么可能是因为内存不足导致调度器无法启动。
    for (;;);
 
    return 0;
}
 
// 定义回调函数
void vTimerCallback(TimerHandle_t xTimer) {
    // 这里执行定时器到期时需要执行的代码
    // 比如Toggle一个LED的状态、读取传感器数据、或要发送一个心跳消息等。
 
    // TimerHandle_t可以用来获取定时器的ID
    uint32_t timerID = (uint32_t) pvTimerGetTimerID(xTimer);
 
    // 根据timerID进行相应的处理，若timerID没有用到，则可以忽略
}