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

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

void taskA(void* param) {
	while(1) {
		ESP_LOGI("main", "打印logs");
		vTaskDelay(pdMS_TO_TICKS(500));
	}
}

void app_main(void){
	xTaskCreatePinnedToCore(taskA, "taskName", 2048, NULL, 3, NULL, NULL);
}

 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

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

QueueHandle_t Queue_handle = NULL;

typedef struct 
{
    int value;
} queue_data_t;


void TaskA(void* param) {
    queue_data_t data;
    while(1) {
        if(pdTRUE ==xQueueReceive(Queue_handle, &data, 100)) {
            ESP_LOGI("queue","res");
        } 
    }
}

void TaskB(void* param) {
    queue_data_t data;
    memset(&data, 0,sizeof(queue_data_t));
    while(1) {
        xQueueSend(Queue_handle, &data, 100);
        vTaskDelay(1000);
        data.value++;
    }
}

void app_main(void)
{
    // num , size
    Queue_handle = xQueueCreate(10,sizeof(queue_data_t));
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 3, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 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

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

SemaphoreHandle_t bin_sem;

void TaskA(void* param) {
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        ESP_LOGI("bin", "TaskA: giving semaphore");
        xSemaphoreGive(bin_sem); // 释放信号量，通知TaskB
    }
}

void TaskB(void* param) {
    while(1) {
        // 等待信号量（阻塞直到被Give）
        if(xSemaphoreTake(bin_sem, portMAX_DELAY) == pdTRUE) {
            ESP_LOGI("bin", "TaskB: took semaphore and is running!");
        }
    }
}

void app_main(void)
{
    bin_sem = xSemaphoreCreateBinary();
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 4, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 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 <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

SemaphoreHandle_t buffer_sem;

// 模拟“使用资源”的任务
void TaskWorker(void* param) {
    int id = (int)param;
    while(1) {
        // 等待获取一个缓冲区
        if(xSemaphoreTake(buffer_sem, portMAX_DELAY) == pdTRUE) {
            ESP_LOGI("Worker", "Task %d got a buffer, processing...", id);
            vTaskDelay(pdMS_TO_TICKS(1000)); // 模拟处理1秒
            ESP_LOGI("Worker", "Task %d released buffer", id);
            xSemaphoreGive(buffer_sem); // 用完归还
        }
    }
}

void app_main(void)
{
    // 创建计数信号量：最多5个缓冲区，初始全部可用
    buffer_sem = xSemaphoreCreateCounting(5, 5);

    // 创建3个任务竞争5个缓冲区
    xTaskCreate(TaskWorker, "W1", 2048, (void*)1, 3, NULL);
    xTaskCreate(TaskWorker, "W2", 2048, (void*)2, 3, NULL);
    xTaskCreate(TaskWorker, "W3", 2048, (void*)3, 3, NULL);

    // 系统运行，3个任务共享5个缓冲区，不会冲突
}

 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

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

SemaphoreHandle_t mutex_sem;

void TaskA(void* param) {
    while(1) {
        xSemaphoreTake(mutex_sem, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));
        xSemaphoreGive(mutex_sem);
    }
}

void TaskB(void* param) {
    while(1) {
        xSemaphoreTake(mutex_sem, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(1000));
        xSemaphoreGive(mutex_sem);
    }
}

void app_main(void)
{
    mutex_sem = xSemaphoreCreateMutex();
    xTaskCreatePinnedToCore(TaskB, "B", 2048, NULL, 4, NULL, 1);
    xTaskCreatePinnedToCore(TaskA, "A", 2048, NULL, 3, NULL, 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 <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_log.h"

// 定义事件位（推荐用宏，清晰易读）
#define BIT_WIFI_READY    (1 << 0)   // bit 0
#define BIT_SENSOR_READY  (1 << 1)   // bit 1
#define BIT_USER_CONFIRM  (1 << 2)   // bit 2

EventGroupHandle_t event_group;

// 模拟网络任务：5秒后设置 Wi-Fi 就绪
void TaskWiFi(void* param) {
    vTaskDelay(pdMS_TO_TICKS(5000));
    ESP_LOGI("WiFi", "Connected to Wi-Fi!");
    xEventGroupSetBits(event_group, BIT_WIFI_READY);
    vTaskDelete(NULL);
}

// 模拟传感器任务：3秒后设置传感器就绪
void TaskSensor(void* param) {
    vTaskDelay(pdMS_TO_TICKS(3000));
    ESP_LOGI("Sensor", "Sensor initialized!");
    xEventGroupSetBits(event_group, BIT_SENSOR_READY);
    vTaskDelete(NULL);
}

// 模拟用户按键任务：8秒后模拟用户确认
void TaskUserKey(void* param) {
    vTaskDelay(pdMS_TO_TICKS(8000));
    ESP_LOGI("User", "User pressed CONFIRM!");
    xEventGroupSetBits(event_group, BIT_USER_CONFIRM);
    vTaskDelete(NULL);
}

// 主任务：等待所有事件到位
void TaskMain(void* param) {
    EventBits_t bits;

    ESP_LOGI("Main", "Waiting for all conditions...");

    // 等待所有位都被设置：使用 xWaitForAllBits = pdTRUE
    bits = xEventGroupWaitBits(
        event_group,                // 事件组句柄
        BIT_WIFI_READY | BIT_SENSOR_READY | BIT_USER_CONFIRM, // 等待这些位
        pdTRUE,                     // 退出时自动清除这些位（可选）
        pdTRUE,                     // 等待 ALL 位（不是任意一个）
        portMAX_DELAY               // 无限等待
    );

    ESP_LOGI("Main", "All conditions met! System ready.");
    // 此处可以启动主逻辑：如开始采集、上传数据等
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(2000));
        ESP_LOGI("Main", "System running...");
    }
}

void app_main(void)
{
    event_group = xEventGroupCreate();

    // 创建各个任务
    xTaskCreate(TaskWiFi, "WiFi", 2048, NULL, 3, NULL);
    xTaskCreate(TaskSensor, "Sensor", 2048, NULL, 3, NULL);
    xTaskCreate(TaskUserKey, "UserKey", 2048, NULL, 3, NULL);
    xTaskCreate(TaskMain, "Main", 2048, NULL, 4, NULL); // 主任务优先级高些
}

 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

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

TaskHandle_t task_b_handle; // 用于向 TaskB 发送通知

void TaskA(void* param) {
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(1000));
        // 直接通知 TaskB（相当于 Give 信号量）
        xTaskNotifyGive(task_b_handle); // 等价于对 TaskB 的通知值 +1
        ESP_LOGI("TaskA", "Sent notification to TaskB");
    }
}

void TaskB(void* param) {
    while(1) {
        // 等待通知（相当于 Take 信号量），阻塞直到收到
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY); // pdTRUE = 清除通知计数
        ESP_LOGI("TaskB", "Received notification!");
    }
}

void app_main(void)
{
    // 先创建 TaskB，拿到它的句柄
    xTaskCreate(TaskB, "TaskB", 2048, NULL, 3, &task_b_handle);
    xTaskCreate(TaskA, "TaskA", 2048, NULL, 2, NULL);
}

1
2
3
4
5
6
7
8
9

c       char
S       int16_t, short
l       int32_t, long
x       BaseType_t, 其他非标准类型
u       unsigned
p       指针
uc      uint8_t, unsigned char
pc      char 指针
p...    对应的指针

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

// 原型
typedef struct HeapRegion
{
    uint8_t * pucStartAddress; // 起始地址
    size_t xSizeInBytes;       // 大小
} HeapRegion_t;

// 定义堆地址
HeapRegion_t xHeapRegions[] =
{
  { ( uint8_t * ) 0x80000000UL, 0x10000 }, // 起始地址0x80000000，大小0x10000
  { ( uint8_t * ) 0x90000000UL, 0xa0000 }, // 起始地址0x90000000，大小0xa0000
  { NULL, 0 } // 表示数组结束
 };

// 注册堆地址
 void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions );

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

void * pvPortMalloc( size_t xWantedSize )vPortDefineHeapRegions
{
    ......
    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
        {
            if( pvReturn == NULL )
            {
                extern void vApplicationMallocFailedHook( void );
                vApplicationMallocFailedHook();
            }
        }
    #endif
    
    return pvReturn;        
}

1
2
3
4
5
6

BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, // 函数指针, 任务函数
                        const char * const pcName, // 任务的名字
                        const configSTACK_DEPTH_TYPE usStackDepth, // 栈大小,单位为word,10表示40字节
                        void * const pvParameters, // 调用任务函数时传入的参数
                        UBaseType_t uxPriority,    // 优先级
                        TaskHandle_t * const pxCreatedTask ); // 任务句柄, 以后使用它来操作这个任务

1

vTaskDelete(xSoundTaskHandle);

1
2
3
4

vTaskDelay(2);  // 等待2个Tick，假设configTICK_RATE_HZ=100, Tick周期时10ms, 等待20ms

// 还可以使用pdMS_TO_TICKS宏把ms转换为tick
vTaskDelay(pdMS_TO_TICKS(100));  // 等待100ms

1
2
3
4
5
6

// 获得任务的优先级
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );

// 设置任务的优先级
void vTaskPrioritySet( TaskHandle_t xTask,
                       UBaseType_t uxNewPriority );

1
2
3
4
5
6
7
8

// 进入暂停状态
// 参数xTaskToSuspend表示要暂停的任务，如果为NULL，表示暂停自己。

/**要退出暂停状态，只能由别人来操作：
别的任务调用：vTaskResume
中断程序调用：xTaskResumeFromISR
**/
void vTaskSuspend( TaskHandle_t xTaskToSuspend );

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

// vTaskDelay：至少等待指定个数的Tick Interrupt才能变为就绪状态
// vTaskDelayUntil：等待到指定的绝对时刻，才能变为就绪态。
void vTaskDelay( const TickType_t xTicksToDelay ); /* xTicksToDelay: 等待多少给Tick */

/* pxPreviousWakeTime: 上一次被唤醒的时间
 * xTimeIncrement: 要阻塞到(pxPreviousWakeTime + xTimeIncrement)
 * 单位都是Tick Count
 */
BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
                            const TickType_t xTimeIncrement );

// 获取当前时间
TickType_t xLastWakeTime = xTaskGetTickCount();

 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

// 创建
QueueHandle_t xQueueCreateStatic(*
                    UBaseType_t uxQueueLength,*
                    UBaseType_t uxItemSize,*
                    uint8_t *pucQueueStorageBuffer,*
                    StaticQueue_t *pxQueueBuffer*
                 );

// 列恢复为初始状态
BaseType_t xQueueReset( QueueHandle_t pxQueue);

// 删除
void vQueueDelete( QueueHandle_t xQueue );


/* 等同于xQueueSendToBack
 * 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSend(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );

/* 
 * 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSendToBack(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );


/* 
 * 往队列尾部写入数据，此函数可以在中断函数中使用，不可阻塞
 */
BaseType_t xQueueSendToBackFromISR(
                                      QueueHandle_t xQueue,
                                      const void *pvItemToQueue,
                                      BaseType_t *pxHigherPriorityTaskWoken
                                   );

/* 
 * 往队列头部写入数据，如果没有空间，阻塞时间为xTicksToWait
 */
BaseType_t xQueueSendToFront(
                                QueueHandle_t    xQueue,
                                const void       *pvItemToQueue,
                                TickType_t       xTicksToWait
                            );

/* 
 * 往队列头部写入数据，此函数可以在中断函数中使用，不可阻塞
 */
BaseType_t xQueueSendToFrontFromISR(
                                      QueueHandle_t xQueue,
                                      const void *pvItemToQueue,
                                      BaseType_t *pxHigherPriorityTaskWoken
                                   );


// 读队列
BaseType_t xQueueReceive( QueueHandle_t xQueue,
                          void * const pvBuffer,
                          TickType_t xTicksToWait );

BaseType_t xQueueReceiveFromISR(
                                    QueueHandle_t    xQueue,
                                    void             *pvBuffer,
                                    BaseType_t       *pxTaskWoken
                                );

// 查询
/*
 * 返回队列中可用数据的个数
 */
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );

/*
 * 返回队列中可用空间的个数
 */
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );

1
2
3
4
5
6
7
8

// 队列集长度，最多能存放多少个数据(队列句柄)  
QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )

// 把队列加入队列集
BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,QueueSetHandle_t xQueueSet );

// 读取队列集
QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,TickType_t const xTicksToWait );

 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

/* 创建一个二进制信号量，返回它的句柄。
 * 此函数内部会分配信号量结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateBinary( void );

/* 创建一个二进制信号量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer );

/* 创建一个计数型信号量，返回它的句柄。
 * 此函数内部会分配信号量结构体 
 * uxMaxCount: 最大计数值
 * uxInitialCount: 初始计数值
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount);

/* 创建一个计数型信号量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * uxMaxCount: 最大计数值
 * uxInitialCount: 初始计数值
 * pxSemaphoreBuffer: StaticSemaphore_t结构体指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer );


/*
 * xSemaphore: 信号量句柄，你要删除哪个信号量
 */
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore );

BaseType_t xSemaphoreGiveFromISR(SemaphoreHandle_t xSemaphore,BaseType_t *pxHigherPriorityTaskWoken);

BaseType_t xSemaphoreTake(
                   SemaphoreHandle_t xSemaphore,
                   TickType_t xTicksToWait
               );

BaseType_t xSemaphoreTakeFromISR(
                        SemaphoreHandle_t xSemaphore,
                        BaseType_t *pxHigherPriorityTaskWoken
                    );

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

// 需要定义
#define configUSE_MUTEXES 1

/* 创建一个互斥量，返回它的句柄。
 * 此函数内部会分配互斥量结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateMutex( void );

/* 创建一个互斥量，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticSemaphore_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer );

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

/* 创建一个递归锁，返回它的句柄。*

 * 此函数内部会分配互斥量结构体* 

 * 返回值: 返回句柄，非NULL表示成功*

 */

SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void );

// 释放

BaseType_t xSemaphoreGiveRecursive( SemaphoreHandle_t xSemaphore );

// 获得

BaseType_t xSemaphoreTakeRecursive(

         SemaphoreHandle_t xSemaphore,

         TickType_t xTicksToWait

        );

 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

/* 创建一个事件组，返回它的句柄。
 * 此函数内部会分配事件组结构体 
 * 返回值: 返回句柄，非NULL表示成功
 */
EventGroupHandle_t xEventGroupCreate( void );

/* 创建一个事件组，返回它的句柄。
 * 此函数无需动态分配内存，所以需要先有一个StaticEventGroup_t结构体，并传入它的指针
 * 返回值: 返回句柄，非NULL表示成功
 */
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer );

/*
 * xEventGroup: 事件组句柄，你要删除哪个事件组
 */
void vEventGroupDelete( EventGroupHandle_t xEventGroup )


/* 设置事件组中的位
 * xEventGroup: 哪个事件组
 * uxBitsToSet: 设置哪些位? 
 *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1
 *              可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0
 * 返回值: 返回原来的事件值(没什么意义, 因为很可能已经被其他任务修改了)
 */
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                                    const EventBits_t uxBitsToSet );

/* 设置事件组中的位
 * xEventGroup: 哪个事件组
 * uxBitsToSet: 设置哪些位? 
 *              如果uxBitsToSet的bitX, bitY为1, 那么事件组中的bitX, bitY被设置为1
 *              可以用来设置多个位，比如 0x15 就表示设置bit4, bit2, bit0
 * pxHigherPriorityTaskWoken: 有没有导致更高优先级的任务进入就绪态? pdTRUE-有, pdFALSE-没有
 * 返回值: pdPASS-成功, pdFALSE-失败
 */
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
                                      const EventBits_t uxBitsToSet,
                                      BaseType_t * pxHigherPriorityTaskWoken );

EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
                                 const EventBits_t uxBitsToWaitFor,
                                 const BaseType_t xClearOnExit,
                                 const BaseType_t xWaitForAllBits,
                                 TickType_t xTicksToWait );

1
2
3
4

EventBits_t xEventGroupSync(    EventGroupHandle_t xEventGroup,
                                const EventBits_t uxBitsToSet,
                                const EventBits_t uxBitsToWaitFor,
                                TickType_t xTicksToWait );

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

typedef struct tskTaskControlBlock
{
    ......
    /* configTASK_NOTIFICATION_ARRAY_ENTRIES = 1 */
    volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    ......
} tskTCB;

// 任务没有在等待通知
##define taskNOT_WAITING_NOTIFICATION              ( ( uint8_t ) 0 )  /* 也是初始状态 */

// 任务在等待通知
##define taskWAITING_NOTIFICATION                  ( ( uint8_t ) 1 )
// 任务接收到了通知，也被称为pending
##define taskNOTIFICATION_RECEIVED                 ( ( uint8_t ) 2 )

1
2
3
4
5

BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );

BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify,
                               uint32_t ulValue, 
                               eNotifyAction eAction, 
                               BaseType_t *pxHigherPriorityTaskWoken );

BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, 
                            uint32_t ulBitsToClearOnExit, 
                            uint32_t *pulNotificationValue, 
                            TickType_t xTicksToWait );

  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
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

/* 使用动态分配内存的方法创建定时器
 * pcTimerName:定时器名字, 用处不大, 尽在调试时用到
 * xTimerPeriodInTicks: 周期, 以Tick为单位
 * uxAutoReload: 类型, pdTRUE表示自动加载, pdFALSE表示一次性
 * pvTimerID: 回调函数可以使用此参数, 比如分辨是哪个定时器
 * pxCallbackFunction: 回调函数
 * 返回值: 成功则返回TimerHandle_t, 否则返回NULL
 */
TimerHandle_t xTimerCreate( const char * const pcTimerName, 
                            const TickType_t xTimerPeriodInTicks,
                            const UBaseType_t uxAutoReload,
                            void * const pvTimerID,
                            TimerCallbackFunction_t pxCallbackFunction );

/* 使用静态分配内存的方法创建定时器
 * pcTimerName:定时器名字, 用处不大, 尽在调试时用到
 * xTimerPeriodInTicks: 周期, 以Tick为单位
 * uxAutoReload: 类型, pdTRUE表示自动加载, pdFALSE表示一次性
 * pvTimerID: 回调函数可以使用此参数, 比如分辨是哪个定时器
 * pxCallbackFunction: 回调函数
 * pxTimerBuffer: 传入一个StaticTimer_t结构体, 将在上面构造定时器
 * 返回值: 成功则返回TimerHandle_t, 否则返回NULL
 */
TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
                                 TickType_t xTimerPeriodInTicks,
                                 UBaseType_t uxAutoReload,
                                 void * pvTimerID,
                                 TimerCallbackFunction_t pxCallbackFunction,
                                 StaticTimer_t *pxTimerBuffer );


/* 删除定时器
 * xTimer: 要删除哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"删除命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
*/
BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 启动定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"启动命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 启动定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"启动命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStartFromISR(   TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );

/* 停止定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"停止命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 停止定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"停止命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerStopFromISR(    TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );


/* 复位定时器
 * xTimer: 哪个定时器
 * xTicksToWait: 超时时间
 * 返回值: pdFAIL表示"复位命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );

/* 复位定时器(ISR版本)
 * xTimer: 哪个定时器
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"停止命令"无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerResetFromISR(   TimerHandle_t xTimer,
                                 BaseType_t *pxHigherPriorityTaskWoken );

/* 修改定时器的周期
 * xTimer: 哪个定时器
 * xNewPeriod: 新周期
 * xTicksToWait: 超时时间, 命令写入队列的超时时间 
 * 返回值: pdFAIL表示"修改周期命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerChangePeriod(   TimerHandle_t xTimer,
                                 TickType_t xNewPeriod,
                                 TickType_t xTicksToWait );

/* 修改定时器的周期
 * xTimer: 哪个定时器
 * xNewPeriod: 新周期
 * pxHigherPriorityTaskWoken: 向队列发出命令使得守护任务被唤醒,
 *                            如果守护任务的优先级比当前任务的高,
 *                            则"*pxHigherPriorityTaskWoken = pdTRUE",
 *                            表示需要进行任务调度
 * 返回值: pdFAIL表示"修改周期命令"在xTicksToWait个Tick内无法写入队列
 *        pdPASS表示成功
 */
BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
                                      TickType_t xNewPeriod,
                                      BaseType_t *pxHigherPriorityTaskWoken );

/* 获得定时器的ID
 * xTimer: 哪个定时器
 * 返回值: 定时器的ID
 */
void *pvTimerGetTimerID( TimerHandle_t xTimer );

/* 设置定时器的ID
 * xTimer: 哪个定时器
 * pvNewID: 新ID
 * 返回值: 无
 */
void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );

 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

/* 在任务中，当前时刻中断是使能的
 * 执行这句代码后，屏蔽中断
 */
taskENTER_CRITICAL();

/* 访问临界资源 */

/* 重新使能中断 */
taskEXIT_CRITICAL();

void vAnInterruptServiceRoutine( void )
{
    /* 用来记录当前中断是否使能 */
    UBaseType_t uxSavedInterruptStatus;
    
    /* 在ISR中，当前时刻中断可能是使能的，也可能是禁止的
     * 所以要记录当前状态, 后面要恢复为原先的状态
     * 执行这句代码后，屏蔽中断
     */
    uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
    
    /* 访问临界资源 */

    /* 恢复中断状态 */
    taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
    /* 现在，当前ISR可以被更高优先级的中断打断了 */
}

/* 暂停调度器 */
void vTaskSuspendAll( void );

/* 恢复调度器
 * 返回值: pdTRUE表示在暂定期间有更高优先级的任务就绪了
 *        可以不理会这个返回值
 */
BaseType_t xTaskResumeAll( void );