esp32的freertos使用记录

任务创建

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

void taskA(void* param)
{
    while(1)
    {
        ESP_LOGI("main", "Hello World!");
        vTaskDelay(pdMS_TO_TICKS(500)); //延时函数，延时时间为芯片tick（系统节拍）时间*参数
        //pdMS_TO_TICK函数将需要延时的ms值转换为系统节拍数
    }

}

void app_main(void)
{
	//创建任务函数，
	/* param
	* 任务函数指针
	* 任务函数名称（打印用）
	* 任务堆栈空间大小
	* 任务参数
	* 任务优先级
	* 任务句柄
	* 指定执行任务内核
	*/
    xTaskCreatePinnedToCore(taskA, "HelloWorld", 2048, NULL, 3, NULL, 0);
}

队列

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "esp_log.h"
#include <string.h>

QueueHandle_t queueHandle = NULL;

typedef struct
{
    int value;
}queue_data_t;

void taskA(void* param)
{
    //从队列中接收数据并打印
    queue_data_t data;
    while(1)
    {
        if (pdTRUE == xQueueReceive(queueHandle, &data, 100)) //最后参数为等待时间（系统节拍数）
        {
            ESP_LOGI("queue", "receive queeu Value:%d", data.value);
        }
    }

}

void taskB(void* param)
{
    //每隔一秒向队列发送一个数据
    queue_data_t data;
    memset(&data, 0, sizeof(queue_data_t));
    while(1)
    {
        xQueueSend(queueHandle, &data, 100);
        data.value++;
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void)
{
    queueHandle = xQueueCreate(10, sizeof(queue_data_t)); //创建队列，参数为队列最大容量和每个数据大小

    xTaskCreatePinnedToCore(taskA, "taskA", 2048, NULL, 3, NULL, 0);
    xTaskCreatePinnedToCore(taskB, "taskB", 2048, NULL, 3, NULL, 0);

}

信号量

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "esp_log.h"


SemaphoreHandle_t bin_sem;

void taskA(void* param)
{
    //释放信号量
    while(1)
    {
        xSemaphoreGive(bin_sem);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void taskB(void* param)
{
    //等待信号量
    while(1)
    {
        if (pdTRUE == xSemaphoreTake(bin_sem, portMAX_DELAY)) //第二个参数为等待时间，设置为最大值
        {
            ESP_LOGI("bin", "task B take binsem success");
        }
    }
}

void app_main(void)
{
    bin_sem = xSemaphoreCreateBinary(); //创建二值信号量（即信号量最大值为1）
    xTaskCreatePinnedToCore(taskA, "taskA", 2048, NULL, 3, NULL, 0);
    xTaskCreatePinnedToCore(taskB, "taskB", 2048, NULL, 4, NULL, 0);
}

互斥锁

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "esp_log.h"


SemaphoreHandle_t mutex;
int cnt = 0;

void taskA(void* param)
{
    while(1)
    {
        vTaskDelay(pdMS_TO_TICKS(500));
        xSemaphoreTake(mutex, portMAX_DELAY); //等待获取锁

        cnt++;
        vTaskDelay(pdMS_TO_TICKS(10));
        ESP_LOGI("taskA", "cnt:%d", cnt);

        xSemaphoreGive(mutex); //释放锁
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void taskB(void* param)
{
    while(1)
    {
        vTaskDelay(pdMS_TO_TICKS(500));
        xSemaphoreTake(mutex, portMAX_DELAY);

        cnt++;
        vTaskDelay(pdMS_TO_TICKS(10));
        ESP_LOGI("taskB", "cnt:%d", cnt);

        xSemaphoreGive(mutex);
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

void app_main(void)
{
    mutex = xSemaphoreCreateMutex(); //创建互斥锁
    xTaskCreatePinnedToCore(taskA, "taskA", 2048, NULL, 3, NULL, 0);
    xTaskCreatePinnedToCore(taskB, "taskB", 2048, NULL, 3, NULL, 0);
}

事件组

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"
#include "esp_log.h"


#define NUM0_BIT BIT0
#define NUM1_BIT BIT1

static EventGroupHandle_t test_event;

void taskA(void* param)
{
    //定时设置不同事件位
    while(1)
    {
        xEventGroupSetBits(test_event, NUM0_BIT);
        vTaskDelay(pdMS_TO_TICKS(1000));
         xEventGroupSetBits(test_event, NUM1_BIT);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void taskB(void* param)
{
    //等待事件位
    EventBits_t ev;
    while(1)
    {
        ev = xEventGroupWaitBits(test_event, NUM0_BIT | NUM1_BIT, pdTRUE, pdFALSE, pdMS_TO_TICKS(5000));
        //第三个参数为是否自动清除事件位，第四个参数为是否等待所有标志位
        //第五个参数为最大阻塞时间，返回值为24位事件组情况

        if (ev & NUM0_BIT)
        {
            ESP_LOGI("ev", "get BIT0 event");
        }

        if (ev & NUM1_BIT)
        {
            ESP_LOGI("ev", "get BIT1 event");
        }

    }
}


void app_main(void)
{
    test_event = xEventGroupCreate();
    xTaskCreatePinnedToCore(taskA, "taskA", 2048, NULL, 3, NULL, 0);
    xTaskCreatePinnedToCore(taskB, "taskB", 2048, NULL, 3, NULL, 0);
}

直达任务通知

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"
#include "esp_log.h"


static TaskHandle_t taskAHandle;
static TaskHandle_t taskBHandle;

void taskA(void* param)
{
    //定时发送一个任务通知值
    uint32_t value = 0;
    while(1)
    {
        xTaskNotify(taskBHandle, value, eSetValueWithOverwrite);
        //参数依次为任务句柄、通知值、执行的操作（见下表）
        vTaskDelay(pdMS_TO_TICKS(1000));
        value++;
    }
}

void taskB(void* param)
{
    //接收任务通知值并打印
    uint32_t value;
    while(1)
    {
        xTaskNotifyWait(0x00, ULONG_MAX, &value, portMAX_DELAY);
        //参数依次为进入函数清除的通知值位、退出函数清除的通知值位、通知值、等待时长
        ESP_LOGI("ev", "notify wait value:%lu", value);

    }
}


void app_main(void)
{
    xTaskCreatePinnedToCore(taskB, "taskB", 2048, NULL, 3, &taskBHandle, 0);
    xTaskCreatePinnedToCore(taskA, "taskA", 2048, NULL, 3, &taskAHandle, 0);
}