FreeRTOS学习篇六：互斥量

最新推荐文章于 2024-05-02 21:17:26 发布
最新推荐文章于 2024-05-02 21:17:26 发布
阅读量377 收藏
点赞数
分类专栏： 我学FreeRTOS 文章标签： 学习 stm32 软件工程 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45647341/article/details/132813278
版权

FreeRTOS学习篇六：互斥量

1.理解基本概念

①互斥量：互斥量是特殊的二值信号量，其主要特殊之处在于有一个优先级继承机制，互斥量以锁的形式存在，可以用线程中的锁的角度去理解。

②互斥量的两种状态：开锁和闭锁。

③互斥量的三个特性：

  • 互斥量所有权：互斥量被任务持有时，互斥量处于闭锁状态，任务获得互斥量的所有权，直到任务释放，互斥量开锁，所有权释放。
  • 递归访问：一个任务获取互斥量后，可以再次获取到互斥量，而不是获取不到而进入阻塞状态形成死锁。可以理解为，互斥量被任务获取，那么这个互斥量的作用域就是在这个任务中，只要不是释放后被其它任务获取了，就能在这个任务中继续获取到互斥量而不用进入阻塞状态。（递归互斥量才有的特性）
  • 防止优先级翻转。

④优先级翻转与优先级继承机制：

要知道优先级继承作何用，就得先知道优先级翻转的问题。

优先级翻转，简而言之就是低优先级的比高优先级的任务先执行，为什么会发生这种情况呢？在某些情况下，可访问的资源只有一个并且同一时间内只能被一个任务所访问，当低优先级的先访问了这个资源，此时如果出现从阻塞态醒来了的更高优先级的任务也要访问这个资源，可是由于资源已经被霸占了（被锁了），高优先级的这个任务只能进入阻塞状态等待低优先级的将资源释放，就出现了低优先级的任务先于高优先级的任务运行的情况。
那这有什么问题呢？如果只有这两个任务那当然没什么问题；但是，如果在这个低优先级的任务执行过程中出现了一个比其优先级高的任务，那么其也就被打断了，直到这个出现的高优先级的执行完，其继续执行直到释放资源，这个过程将会导致原来那个等待访问被锁资源的高优先级任务的阻塞时间变长。如果高优先级的阻塞时间变长了，那就会有因处理不及时而出现问题的风险，一旦出现，对于系统来说可是致命的。而优先级继承机制正是将这种危害降到最低的一种解决方法。

高优先级的任务代表着需要尽快地被执行。优先级继承机制，是用来确保高优先级任务进入阻塞状态的时间尽可能短的，比如确保优先级翻转时高优先级的阻塞时间不会过长。那是如何实现的？思路也很简单，那就把占用资源的那个低优先级任务的优先级临时提高，等执行完后再恢复到原来的优先级。这样就能极大地使得这个低优先级任务尽快执行完成以释放保护资源，将高优先级任务的阻塞延时降到最低。

⑥FreeRTOS的互斥量的运作机制：任务获取互斥量后，互斥量立刻被变成闭锁状态，互斥量释放后才变为开锁状态，闭锁状态下，任何试图获取互斥量的都将进入阻塞状态。

⑦注意：互斥量不能在中断服务函数中使用，因为其特有的优先级继承机制只在普通任务中起作用，在中断的上下文环境毫无意义。

2.应用场景

应用场景：有优先级翻转的情况或需要递归访问的场景。

多任务环境下往往存在多个任务竞争同一临界资源的应用场景，互斥量可被用于对临界资源的保护从而实现独占式访问。另外，互斥量可以降低信号量存在的优先级翻转问题带来的影响。
比如有两个任务需要对串口进行发送数据，其硬件资源只有一个，那么两个任务肯定不能同时发送，不然会导致数据错误，那么，就可以用互斥量对串口资源进行保护，当一个任务正在使用串口的时候，另一个任务则无法使用串口，等到任务使用串口完毕之后，另外一个任务才能获得串口的使用权。

《FreeRTOS内核实现与应用开发实战——基于STM32》 P281

3.常用互斥量操作函数

①创建

1、创建互斥量 —— xSemaphoreCreateMutex()：

/* 创建互斥量 */
#if(configSUPPORT_DYNAMIC_ALLOCATION == 1)
	#define xSemaphoreCreateMutex() xQueueCreateMutex(queueQUEUE_TYPE_MUTEX)
#endif
/* 互斥量，其类型就是 queueQUEUE_TYPE_MUTEX */
/* 无形参，返回值为互斥量句柄或者NULL */

必须在 FreeRTOSConfig.h 中把宏 configSUPPORT_DYNAMIC_ALLOCATION 定义为 1，即开启动态内存分配；还要将将宏configUSE_MUTEXES 定义为 1，即使用互斥量。

2、创建递归互斥量 —— xSemaphoreCreateRecursiveMutex()：

/* 创建递归互斥量 */
#if((configSUPPORT_DYNAMIC_ALLOCATION==1) && (configUSE_RECURSIVE_MUTEXES ==1))
	#define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex(queueQUEUE_TYPE_RECURSIVE_MUTEX)
#endif
/* 无形参，返回值为递归互斥量句柄或者NULL */

必须在 FreeRTOSConfig.h 中把宏 configSUPPORT_DYNAMIC_ALLOCATION 定义为 1，即开启动态内存分配；还要将configUSE_RECURSIVE_MUTEXES定义为1，即使用递归互斥量。

/* 使用示例 */
SemaphoreHandle_t xMutex;
void vATask( void * pvParameters )
{
	/* 创建一个递归互斥量 */
	xMutex = xSemaphoreCreateRecursiveMutex();
	if ( xMutex != NULL ) {
	/* 递归互斥量创建成功 */
}

②删除

调用vSemaphoreDelete()函数，传入互斥量句柄进行删除即可，与二值信号量、计数信号量的删除操作一样。

③获取

1、获取互斥量 —— xSemaphoreTake()：

/* 获取互斥量 */
#define xSemaphoreTake(xSemaphore, xBlockTime) \
xQueueGenericReceive((QueueHandle_t) (xSemaphore),NULL,(xBlockTime ), pdFALSE)
  • 形参：传入互斥量句柄以及阻塞超时时间。
  • 返回值：pdTRIE、errQUEUE_EMPTY 。

2、获取递归互斥量 —— xSemaphoreTakeRecursive()：

/* 获取递归互斥量 */
#if(configUSE_RECURSIVE_MUTEXES == 1)
#define xSemaphoreTakeRecursive(xMutex, xBlockTime)
xQueueTakeMutexRecursive((xMutex), (xBlockTime))
#endif
  • 形参：信号量句柄和阻塞超时时间。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为portMAX_DELAY ， 则任务将一直阻塞在该递归互斥量上（即没有超时时间）。
  • 返回值：获取成功则返回 pdTRUE， 在超时之前没有获取成功则返回errQUEUE_EMPTY。

注意：在任务中，获取递归信号量多少次，就要释放递归信号量多少次。

④释放

1、释放互斥量 —— xSemaphoreGive()：

/* 释放互斥量 */
#define xSemaphoreGive(xSemaphore) \
xQueueGenericSend((QueueHandle_t)(xSemaphore), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK)
  • 形参：互斥量句柄。
  • 返回值：pdTRUE、errQUEUE_EMPTY。

2、释放递归互斥量 —— xSemaphoreGiveRecursive()：

/* 释放递归互斥量 */
#if(configUSE_RECURSIVE_MUTEXES == 1)
#define xSemaphoreGiveRecursive(xMutex) xQueueGiveMutexRecursive((xMutex))
#endif
  • 形参：互斥量句柄。
  • 返回值：pdTRUE、errQUEUE_EMPTY。

使用 xSemaphoreTakeRecursive() 函数成功获取几次递归互斥量，就要使用 xSemaphoreGiveRecursive()函数返还几次。

/* 使用示例 */
SemaphoreHandle_t xMutex = NULL;
void vATask(void* pvParameters)
{
    /* 创建一个递归互斥量用于保护共享资源 */
	xMutex = xSemaphoreCreateRecursiveMutex();
}
void vAnotherTask(void* pvParameters)
{
	if ( xMutex != NULL ) {
		/* 尝试获取递归互斥量，如果不可用则等待 10 个 ticks */
		if(xSemaphoreTakeRecursive(xMutex,( TickType_t ) 10 )== pdTRUE) {
			/* 获取到递归信号量，可以访问共享资源 */
			/* ... 其他功能代码 */

			/* 重复获取递归互斥量 */
			xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
			xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );

			/* 释放递归互斥量，获取了多少次就要释放多少次 */
			xSemaphoreGiveRecursive( xMutex );
			xSemaphoreGiveRecursive( xMutex );
			xSemaphoreGiveRecursive( xMutex );

			/* 现在递归互斥量可以被其他任务获取 */
		} else {
			/* 没能成功获取互斥量，所以不能安全的访问共享资源 */
		}
	}
}

4.模拟优先级翻转现象

思路：
在 FreeRTOS 中创建了三个任务与一个二值信号量， 任务分别是高优先级任务、中优先级任务、低优先级任务， 用于模拟产生优先级翻转。低优先级任务在获取信号量后，被中优先级打断，中优先级的任务执行时间较长，因为此时低优先级还未释放信号量，所以高优级任务也就无法取得信号量继续运行，此时就发生了任务优先级翻转。任务在运行中，使用串口打印出相关信息。

结果显示：
在这里插入图片描述
代码：

0、在FreeRTOSConfig.h配置文件中添加以下：

#define configSUPPORT_DYNAMIC_ALLOCATION 1

1、STM32F103C8_BSP.c：

#include "stm32f10x.h"                  // Device header

void USART1_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    USART_InitTypeDef USART_InitStruct;
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_Init(USART1, &USART_InitStruct);
    
    USART_Cmd(USART1, ENABLE);
    
}
void KEY_GPIO_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPD;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_2;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
}

void USART1_SendByte(uint8_t byte){
    USART_SendData(USART1, byte);
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}
void USART1_SendString(char* str)
{
    uint16_t i;
    for(i = 0; str[i] != '\0'; i++){
        USART1_SendByte(*(str+i));
    }
}

2、main.c：

#include "stm32f10x.h"                  // Device header
#include "FreeRTOS.h"
#include "task.h"
#include "STM32F103C8_BSP.h"
#include "semphr.h"

static void STM32F103_Init(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    USART1_Init();
}
/* 定义二值信号量句柄 */
SemaphoreHandle_t BinarySem_Handle = NULL;

/* 声明任务 */
void LowPriority_Task(void);
void MiddlePriority_Task(void);
void HighPriority_Task(void);

int main(void) 
{
    STM32F103_Init();
    taskENTER_CRITICAL();
    /* 二值信号量 */
    BinarySem_Handle = xSemaphoreCreateBinary();
    xSemaphoreGive(BinarySem_Handle);
    /* 创建任务 */
    xTaskCreate((TaskFunction_t)LowPriority_Task, "LowPriority_Task",512, NULL, 2, NULL);
    xTaskCreate((TaskFunction_t)MiddlePriority_Task, "MiddlePriority_Task",512, NULL, 3, NULL);
    xTaskCreate((TaskFunction_t)HighPriority_Task, "HighPriority_Task",512, NULL, 4, NULL);
    vTaskStartScheduler();
    taskEXIT_CRITICAL();
    while(1);
}

void LowPriority_Task(void)
{
    static uint32_t i;
    BaseType_t xReturn = pdPASS;
    while(1){
        USART1_SendString("LowPriority_Task ======> Obtaining semaphores.\n");
        xReturn = xSemaphoreTake(BinarySem_Handle, portMAX_DELAY);
        /* 获取信号量成功，则任务开始执行后续处理 */
        if ( xReturn == pdTRUE )
            USART1_SendString("LowPriority_Task Runing\n\n");
        /* 模拟低优先级任务占用信号量, 发起任务调度 */
        for (i=0; i < 2000000; i++){ 
            taskYIELD();
        }
        USART1_SendString("LowPriority_Task ======> Release Semaphore.\n");
        xReturn = xSemaphoreGive(BinarySem_Handle);
        vTaskDelay(500);
    }
}

void MiddlePriority_Task(void)
{
    while(1){
        USART1_SendString("MiddlePriority_Task Runing\n\n");
        vTaskDelay(500);
    }
}
void HighPriority_Task(void)
{
    BaseType_t xReturn = pdTRUE;
    while(1){
        USART1_SendString("HighPriority_Task ======> Obtaining semaphores.\n");
        xReturn = xSemaphoreTake(BinarySem_Handle, portMAX_DELAY);
        /* 获取信号量成功，则任务开始执行后续处理 */
        if (xReturn == pdTRUE)
            USART1_SendString("HighPriority_Task Runing\n\n");
        /* 释放二值信号量 */
        xReturn = xSemaphoreGive( BinarySem_Handle );
        vTaskDelay(500);
    }
}

5.互斥量使用示例

示例： 基于优先级翻转，测试互斥量的优先级继承释放有效。

最终结果：
在这里插入图片描述
代码：

0、在FreeRTOSConfig.h配置文件中添加以下：

#define configSUPPORT_DYNAMIC_ALLOCATION 1
#define configUSE_MUTEXES 1

1、STM32F103C8_BSP.c：和上面一样。

2、main.c：与上面的差不多，将二值信号量改为互斥量即可。

#include "stm32f10x.h"                  // Device header
#include "FreeRTOS.h"
#include "task.h"
#include "STM32F103C8_BSP.h"
#include "semphr.h"

static void STM32F103_Init(void)
{
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    USART1_Init();
}
/* 定义互斥量句柄 */
SemaphoreHandle_t MuxSem_Handle = NULL;

/* 声明任务 */
void LowPriority_Task(void);
void MiddlePriority_Task(void);
void HighPriority_Task(void);

int main(void) 
{
    STM32F103_Init();
    taskENTER_CRITICAL();
    /* 互斥量 */
    MuxSem_Handle = xSemaphoreCreateMutex();
    xSemaphoreGive(MuxSem_Handle);
    /* 创建任务 */
    xTaskCreate((TaskFunction_t)LowPriority_Task, "LowPriority_Task",512, NULL, 2, NULL);
    xTaskCreate((TaskFunction_t)MiddlePriority_Task, "MiddlePriority_Task",512, NULL, 3, NULL);
    xTaskCreate((TaskFunction_t)HighPriority_Task, "HighPriority_Task",512, NULL, 4, NULL);
    vTaskStartScheduler();
    taskEXIT_CRITICAL();
    while(1);
}

void LowPriority_Task(void)
{
    static uint32_t i;
    BaseType_t xReturn = pdPASS;
    while(1){
        USART1_SendString("LowPriority_Task ======> Obtaining semaphores.\n");
        xReturn = xSemaphoreTake(MuxSem_Handle, portMAX_DELAY);
        /* 获取信号量成功，则任务开始执行后续处理 */
        if ( xReturn == pdTRUE )
            USART1_SendString("LowPriority_Task Runing\n\n");
        /* 模拟低优先级任务占用信号量, 发起任务调度 */
        for (i=0; i < 2000000; i++){ 
            taskYIELD();
        }
        USART1_SendString("LowPriority_Task ======> Release Semaphore.\n");
        xReturn = xSemaphoreGive(MuxSem_Handle);
        vTaskDelay(1000);
    }
}

void MiddlePriority_Task(void)
{
    while(1){
        USART1_SendString("MiddlePriority_Task Runing\n\n");
        vTaskDelay(1000);
    }
}
void HighPriority_Task(void)
{
    BaseType_t xReturn = pdTRUE;
    while(1){
        USART1_SendString("HighPriority_Task ======> Obtaining semaphores.\n");
        xReturn = xSemaphoreTake(MuxSem_Handle, portMAX_DELAY);
        /* 获取信号量成功，则任务开始执行后续处理 */
        if (xReturn == pdTRUE)
            USART1_SendString("HighPriority_Task Runing\n\n");
        /* 释放二值信号量 */
        xReturn = xSemaphoreGive(MuxSem_Handle);
        vTaskDelay(1000);
    }
}

END

不似年少
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS学习资料FreeRTOS系列教程基础篇文档资料.zip
01-19
FreeRTOS学习资料FreeRTOS系列教程基础篇文档资料： 10、 FreeRTOS系列第10篇---FreeRTOS任务创建和删除.docx 11、 FreeRTOS系列第11篇---FreeRTOS任务控制.docx 12、 FreeRTOS系列第12篇---FreeRTOS任务应用函数.docx 13、FreeRTOS系列第13篇---FreeRTOS内核控制.docx 14、 FreeRTOS系列第14篇---FreeRTOS任务通知.docx 15、FreeRTOS系列第15篇---使用任务通知实现命令行解释器.docx 16、 FreeRTOS系列第16篇---可视化追踪调试.docx 17、FreeRTOS系列第17篇---FreeRTOS队列.docx 18、 FreeRTOS系列第18篇---FreeRTOS队列API函数.docx 19、FreeRTOS系列第19篇---FreeRTOS信号量.docx 1、 FreeRTOS系列第1篇---为什么选择FreeRTOS？.docx 20、FreeRTOS系列第20篇---FreeRTOS信号量API函数.doc
FreeRTOS——互斥量
weixin_44567318的博客
07-21 1754
FreeRTOS——互斥量互斥量 互斥量 互斥量是包含优先级继承机制的二进制信号量。二进制信号量是实现同步（任务之间或任务与中断之间）的更好选择，而互斥量是实现简单互斥的更好选择。 当用于互斥时，互斥量就像一个用于保护资源的令牌。当任务希望访问资源时，它必须首先获得（“获取”）令牌。当它完成资源的使用后，它必须“释放”令牌——允许其他任务有机会访问相同的资源。 互斥量与信号量使用相同的访问 API 函数，因此也允许指定阻塞时间。阻塞时间表示如果互斥量不是立即可用的，则在尝试“获取”互斥量时，任务应进入阻塞状
FreeRTOS 信号量(五) ------ 递归互斥信号量
Bit_Dong的博客
04-29 1519
递归互斥信号量可以看作是一个特殊的互斥信号量，已经获取了互斥信号量的任务就不能再次获取这个互斥信号量，但是递归互斥信号量不同，已经获取了递归互斥信号量的任务可以再次获取这个递归互斥信号量，而且次数不限！一个任务使用函数 xSemaphoreTakeRecursive()成功的获取了多少次递归互斥信号量就得使用函数 xSemaphoreGiveRecursive()释放多少次！比如某个任务成功的获取了 5 次递归信号量，那么这个任务也得同样的释放 5 次递归信号量。
FreeRTOS中，二进制信号量和互斥锁的区别
二向无常的博客
03-14 362
能够暂时地将互斥量持有者的优先级提升至所有等待此互斥量的任务所具有的最高优先级。持有互斥量的低优先级的任务"继承"了等待互斥量的任务的优先级。机制，但二进制信号量没有。因此，二进制信号量是实现同步的更好选择，而互斥锁是实现简单互斥的更好选择。-- FreeRTOS官网->内核->开发者文档->FreeRTOS互斥锁。补充：二进制信号量，也称为二值信号量，即只具有0和1两种状态的信号量。--FreeRTOS实时内核使用指南->互斥量（及二值信号量）互斥量，也称互斥锁。
FreeRTOS学习笔记（5）——互斥量
Leung的博客
11-23 5319
一、头文件 #include "FreeRTOS.h" #include "semphr.h" 二、互斥量 2.1 基本概念 互斥量又称互斥信号量（本质是信号量），是一种特殊的二值信号量，它和信号量不同的是，它支持互斥量所有权、递归访问以及防止优先级翻转的特性，用于实现对临界资源的独占式处理。 任意时刻互斥量的状态只有两种，开锁或闭锁。当互斥量被任务持有时，该互斥量处于闭锁状态，这个任务获得互斥量的所有权。当该任务释放这个互斥量时，该互斥量处于开锁状态，任务失去该互斥量的所有权。当一个任务持有互斥量时，
【FreeRTOS】互斥锁的使用
凉开水白菜的博客
11-04 4136
可以看到互斥量的api和信号量的api是一样的，因为互斥量的本质是一个特殊信号量，但是需要注意互斥量不能在ISR中使用；互斥量的使用场景一般是在多个任务中操作同一个变量的时候会出现使用；互斥量是一种特殊的二进制信号量,使用互斥量时，先创建、然后去获得、释放它。：pdTRUE表示成功,如果二进制信号量的计数值已经是1，再次调用此函数则返回失败；如果计数型信号量的计数值已经是最大值，再次调用此函数则返回失败；: 返回句柄，非NULL表示成功。：信号量句柄，释放哪个信号量。：信号量句柄，释放哪个信号量。
FreeRTOS（5）----互斥量
weixin_63032791的博客
05-20 1626
优先级继承算法指的是暂时提高某个占用某种资源的低优先级的任务，使得在等待该资源的任务中优先级最高的任务优先级相等，当原本占有资源的任务释放了资源后，优先级恢复为原来的设定值。在系统中，一般高优先级的任务就代表了这个任务越重要，越要优先执行，但在互斥访问中，高优先级任务访问的资源被上锁，导致变为挂起态，在freertos中，紧急的任务无法得到快速处理，则会对系统产生很大的危害。】，此时优先级的继承机制就要发挥作用了，把当前占用资源的低优先级的任务提升到和高优先级任务一样的优先级。·任务L正常运行，占用资源。
FreeRTOS的互斥量
嵌入式之斋
04-03 321
例如，创建一个互斥量可以使用函数xSemaphoreCreateMutex()，获取互斥量可以使用函数xSemaphoreTake()，释放互斥量可以使用函数xSemaphoreGive()。由于互斥量的特性，同一时刻只有一个任务能够获得该互斥量，从而保证了对临界资源的独占式访问。支持防止优先级翻转：当一个低优先级任务持有互斥量时，高优先级任务不能获取该互斥量，从而避免了优先级翻转的问题。支持互斥量所有权：一个任务可以持有一个互斥量并防止其他任务获取它，只有持有互斥量的任务才能访问临界资源。
FreeRTOS个人笔记-互斥量
weixin_47077788的博客
07-25 1444
根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。配套资料FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
【Freertos基础入门】深入浅出freertos互斥量
m0_62599305的博客
08-20 627
FreeRTOS是一款开源的实时操作系统，提供了许多基本的内核对象，其中包括互斥锁（Mutex）。互斥锁是一种常用的同步机制，用于确保在同一时间内只有一个任务可以访问共享资源，防止竞态条件等并发问题。本文将介绍FreeRTOS中的互斥锁的使用方法和注意事项。互斥锁是FreeRTOS提供的一个重要的同步机制，用于控制对共享资源的访问。通过仔细使用互斥锁，可以防止并发问题如竞态条件、死锁等的发生。本文简要介绍了在FreeRTOS中使用互斥锁的基本方法，包括创建、获取、释放和处理错误。
FreeRTOS篇章之互斥量
夏沫的杂物间
02-25 3020
写在前面： 本文章旨在总结备份、方便以后查询，由于是个人总结，如有不对，欢迎指正；另外，内容大部分来自网络、书籍、和各类手册，如若侵权请告知，马上删帖致歉。 一、与二值量区别及应用 互斥量是一种特殊的二值信号量，用于控制在两个或多个任务间访问共享资源 在用于互斥的场合，互斥量从概念上可看作是与共享资源关联的令牌。一个任务想要合法地访问资源，其必须先成功地得到(Take)该资源对应的令牌...
NXP i.MX RT1052 FreeRTOS实战：互斥量
12-01
NXP i.MX RT1052 FreeRTOS实战。 NXP i.MX RT1052驱动程序。 资源代码可直接编译、运行。
FreeRTOS递归互斥信号量（含IAR和MDK）.rar
05-16
任务 Task1 运行的过程需要调用函数 printf，发现任务 Task3 正在调用，任务 Task1 会被挂起，等待 Task3 释放函数 printf。 在调度器的作用下，任务 Task3 得到运行，Task3 运行的过程中，由于任务 Task2 就绪，抢占了 Task3的运行。 优先级翻转问题 就出在这里了，从任务执行的现象上看，任务 Task1 需要等待 Task2 执行完毕才有机会得到执行，这个与抢占式调度正好反了，正常情 况下应该是高优先级任务抢占低优先级任务的执行，这里成了高优先级任务 Task1 等待低优先级任务 Task2 完成。 所以这种情况被称之为 优先级翻转问题。 任务 Task2 执行完毕后，任务 Task3 恢复执行，Task3 释放互斥资源后，任务 Task1 得到互斥资源，从而可以继续执行。上面就是一 个产生优先级翻转问题的现象。
STM32F429 FreeRTOS实战：实现FreeRTOS互斥信号量操作【支持STM32F42X系列单片机】.zip
12-15
STM32F429 FreeRTOS实战。 项目支持STM32F42X系列单片机调测和移植。 项目代码可直接编译、运行。
多线程freertos互斥锁
10-03
app可快速进行应用无需烦锁的创建
JAVA 学习·泛型（二）——通配泛型
最新发布
wr114514的博客
05-02 651
介绍了Java泛型中的重要知识点——通配泛型及其应用。
限流的学习
weixin_43675252的博客
05-01 260
限流算法：滑动窗口算法滑动日志算法漏桶算法令牌桶算法。
Build a Large Language Model (From Scratch) 从头开始构建大型语言模型(第二章)学习笔记
Czi.的博客
04-29 1004
LLM需要将文本数据转换为数值向量，称为嵌入，因为它们无法处理原始文本。嵌入将离散数据（如单词或图像）转换为连续向量空间，使它们与神经网络操作兼容。第一步，将原始文本分解为tokens，这些tokens可以是单词或字符。然后，tokens被转换为整数表示形式，称为token IDs。可以添加特殊tokens（例如和）来增强模型的理解并处理各种上下文，例如未知单词或标记(marking)不相关文本之间的边界。
力扣数据库题库学习（4.28日）--1587. 银行账户概要 II
Jesse_Kyrie的博客
04-28 235
对于力扣题1587. 银行账户概要 II的解答，提供解题思路与解题方法，知识点为:1. GROUP BY 2. SUM 3. LEFT JOIN 4. HAVING
freeRTOS互斥量
11-23
FreeRTOS中的互斥量是一种二进制信号量的变种，用于保护共享资源不被多个任务同时访问。在使用互斥量时，需要在头文件FreeRTOSConfig.h中将configUSE_MUTEXES设置为1。互斥量和信号量的主要区别在于，互斥量只能被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值