FreeRTOS内核详解----信号量

最新推荐文章于 2024-08-10 20:25:09 发布
最新推荐文章于 2024-08-10 20:25:09 发布
阅读量7.3k 收藏 10
点赞数 3
分类专栏： FreeRTOS内核 文章标签： 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hehao9051/article/details/51591792
版权

FreeRTOS内核详解—-信号量

信号量主要用来保护共享资源、任务之间或者任务与中断之间用来同步等。FreeRTOS有二值信号量、计数信号量、互斥锁和递归互斥锁。

  • 信号量实现总览
  • 二值信号量
  • 计数信号量
  • 互斥锁的创建
  • 递归互斥锁的创建
  • 通用发送信号量函数
  • 通用接收信号量函数
  • 递归信号量发送函数
  • 递归信号量接收函数

1.信号量实现总览

#define vSemaphoreCreateBinary( xSemaphore )                                                                                                    \
    {                                                                                                                                           \
        ( xSemaphore ) = xQueueGenericCreate( ( unsigned portBASE_TYPE ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE ); \
        if( ( xSemaphore ) != NULL )                                                                                                            \
        {                                                                                                                                       \
            xSemaphoreGive( ( xSemaphore ) );                                                                                                   \
        }                                                                                                                                       \
    }

#define xSemaphoreTake( xSemaphore, xBlockTime )        xQueueGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )
#define xSemaphoreGive( xSemaphore )        xQueueGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
#define xSemaphoreGiveRecursive( xMutex )   xQueueGiveMutexRecursive( ( xMutex ) )
#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )          xQueueGenericSendFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
#define xSemaphoreTakeRecursive( xMutex, xBlockTime )   xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
#define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )          xQueueReceiveFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )
#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
#define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )
#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
#define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( xQueueHandle ) ( xSemaphore ) )
#define xSemaphoreGetMutexHolder( xSemaphore ) xQueueGetMutexHolder( ( xSemaphore ) )

我们可以看到信号量都是通过对已有几个特定函数通过宏包装实现的，下面我们分别讲述一下。

2.二值信号量

二值信号量是一个队列项个数为1的队列，使用的创建函数队列的通用方法进行创建、发送和获取数据的，创建代码如下：

#define vSemaphoreCreateBinary( xSemaphore )                                                                                                    \
    {                                                                                                                                            \
        ( xSemaphore ) = xQueueGenericCreate( ( unsigned portBASE_TYPE ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE );    \
        if( ( xSemaphore ) != NULL )                                                                                                            \
        {                                                                                                                                        \
            xSemaphoreGive( ( xSemaphore ) );                                                                                                    \
        }                                                                                                                                        \
    }

我们可以看到队列长度为0，也就是二值信号量要不是满列，要不就是空列，而且不会存储数据。这也是二值信号量名字来源。同时我们可以看到二值信号量创建成功之后，会立即进行一次GIVE操作，也就是二值信号量创建完成之后，就有数据，就是一个满列，不明白这样做的意义是什么。

3.计数信号量

#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )

计数信号量创建由定义在queue中的函数 xQueueCreateCountingSemaphore ,函数如下：


    xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount )
    {
    xQueueHandle xHandle;

        // 队列长度等于计数值的最大值 队列项大小为0
        xHandle = xQueueGenericCreate( ( unsigned portBASE_TYPE ) uxCountValue, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );

        if( xHandle != NULL )
        {
            ( ( xQUEUE * ) xHandle )->uxMessagesWaiting = uxInitialCount;

            traceCREATE_COUNTING_SEMAPHORE();
        }
        else
        {
            traceCREATE_COUNTING_SEMAPHORE_FAILED();
        }

        configASSERT( xHandle );
        return xHandle;
    }

计数信号量是一个只存储当前有多少个数据不存储当前数据具体值的队列。我们可以看到计数信号量与二值信号量的区别就是，二值信号量只有两种状态 满 和 空 。而计数信号量也有两种状态 有数据 （包括满） 和 空 。这有什么作用呢？让我们看一个例子，假如有一个函数需要记录外部中断的个数。实现方法是在中断使用信号量发送函数，每进一次中断，发送一次；创建一个任务，每次收到信号量，就将计数值加1。这时候就可以使用计数信号量，因为假如外部中断发生频率非常高的时候，如果使用二值信号量，会出现任务还没有来的及更新计数值，又来了中断向信号量发送数据，导致统计最终不准确。

4.互斥锁的创建

#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

计数信号量创建由定义在queue中的函数 xQueueCreateMutex ,函数如下：


xQueueHandle xQueueCreateMutex( unsigned char ucQueueType )
    {
    xQUEUE *pxNewQueue;

        ( void ) ucQueueType;

        /* Allocate the new queue structure. */
        pxNewQueue = ( xQUEUE * ) pvPortMalloc( sizeof( xQUEUE ) );
        if( pxNewQueue != NULL )
        {
            pxNewQueue->pxMutexHolder = NULL;
            pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;

            // 不需要真的存储数据
            pxNewQueue->pcWriteTo = NULL;
            pxNewQueue->pcReadFrom = NULL;

            pxNewQueue->uxMessagesWaiting = ( unsigned portBASE_TYPE ) 0U;
            pxNewQueue->uxLength = ( unsigned portBASE_TYPE ) 1U;   //队列项个数为1
            pxNewQueue->uxItemSize = ( unsigned portBASE_TYPE ) 0U; //队列项长度为0
            pxNewQueue->xRxLock = queueUNLOCKED;
            pxNewQueue->xTxLock = queueUNLOCKED;

            #if ( configUSE_TRACE_FACILITY == 1 )
            {
                pxNewQueue->ucQueueType = ucQueueType;
            }
            #endif

            #if ( configUSE_QUEUE_SETS == 1 )
            {
                pxNewQueue->pxQueueSetContainer = NULL;
            }
            #endif

            /* Ensure the event queues start with the correct state. */
            vListInitialise( &( pxNewQueue->xTasksWaitingToSend ) );
            vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );

            traceCREATE_MUTEX( pxNewQueue );

            /* Start with the semaphore in the expected state. */
            xQueueGenericSend( pxNewQueue, NULL, ( portTickType ) 0U, queueSEND_TO_BACK );
        }
        else
        {
            traceCREATE_MUTEX_FAILED();
        }

        configASSERT( pxNewQueue );
        return pxNewQueue;
    }

互斥锁的创建，没有使用通用的队列创建函数，我们可以看到与普通队列创建，其中一个区别就是 

pxNewQueue->pxMutexHolder = NULL;
pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;

前一个是将当前信号量的持有者设置为NULL，也就是没有被任何任务持有。后一个是将队列类型设置为queueQUEUE_IS_MUTEX 。同时互斥量创建时也会进行一次GIVE操作，这样可以确保互斥信号量一创建好就可以，就可以被任务进行TAKE操作，也就是可以被任务获得。互斥信号量牵扯到一个优先级反转的问题的问题，优先级反转与FreeRTOS的解决方法，** FREERTOS 实时内核
实用指南 ** 这本书中讲述的很清楚，现抄录如下：

优先级反转

这里写图片描述

图 38 也展现出了采用互斥量提供互斥功能的潜在缺陷之一。在这种可能的执行流程描述中，高优先级的任务 2 竟然必须等待低优先级的任务 1 放弃对互斥量的持有权。高优先级任务被低优先级任务阻塞推迟的行为被称为”优先级反转”。这是一种不合理的行为方式，如果把这种行为再进一步放大,当高优先级任务正等待信号量的时候，一个介于两个任务优先之间的中等优先级任务开始执行——这就会导致一个高优先级任务在等待一个低优先级任务，而低优先级任务却无法执行！这种最坏的情形在图 39 中进行展示。

这里写图片描述

优先级反转可能会产生重大问题。但是在一个小型的嵌入式系统中，通常可以在设计阶段就通过规划好资源的访问方式避免出现这个问题。

优先级继承
FreeRTOS 中互斥量与二值信号量十分相似——唯一的区别就是互斥量自动提供了一个基本的”优先级继承”机制。优先级继承是最小化优先级反转负面影响的一种方案——其并不能修正优先级反转带来的问题，仅仅是减小优先级反转的影响。优先级继承使得系统行为的数学分析更为复杂，所以如果可以避免的话，并不建议系统实现对优先级继承有所依赖。优先级继承暂时地将互斥量持有者的优先级提升至所有等待此互斥量的任务所具有的最高优先级。持有互斥量的低优先级务”继承”了等待互斥量的任务的优先级。这种机制在图 40 中进行展示。互斥量持有者在归还互斥量时，优先级会自动设置为其原来的优先级。

这里写图片描述

由于最好是优先考虑避免优先级反转，并且因为 FreeRTOS 本身是面向内存有限的微控制器，所以只实现了最基本的互斥量的优先级继承机制，这种实现假定一个任务在任意时刻只会持有一个互斥量。

5.递归互斥锁的创建


xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )          xQueueGenericSendFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
#define xSemaphoreTakeFromISR

递归互斥信号量的创建方法与普通互斥信号量的创建方法相同，

6.通用发送信号量函数

#define xSemaphoreGive( xSemaphore )        xQueueGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

通用发送使用一个不带阻塞时间的队列发送函数，调用这个函数与普通队列的不同就是在调用 prvCopyDataToQueue 这个函数时，此函数处理不同，这个函数之前在将队列时讲述过，函数代码如下：

static void prvCopyDataToQueue( xQUEUE *pxQueue, const void *pvItemToQueue, portBASE_TYPE xPosition )
{
    if( pxQueue->uxItemSize == ( unsigned portBASE_TYPE ) 0 )
    {   //二值信号量 计数信号量等uxItemSize值为0 不进行数据的拷贝，这个是与普通队列的区别1
        #if ( configUSE_MUTEXES == 1 )
        {
            if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
            {
                vTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );//将优先级降到设置值
                pxQueue->pxMutexHolder = NULL;
            }
        }
        #endif
    }
    else if( xPosition == queueSEND_TO_BACK )
    {   //插入队列的结尾
        memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( unsigned ) pxQueue->uxItemSize );
        pxQueue->pcWriteTo += pxQueue->uxItemSize;  //更新下次写数据的位置指针
        if( pxQueue->pcWriteTo >= pxQueue->pcTail )
        {
            pxQueue->pcWriteTo = pxQueue->pcHead;   //如果写到了队列结尾则从头开始写
        }
    }
    else
    {   //插入到队列开头
        memcpy( ( void * ) pxQueue->pcReadFrom, pvItemToQueue, ( unsigned ) pxQueue->uxItemSize );
        pxQueue->pcReadFrom -= pxQueue->uxItemSize; //更新上次读数据位置
        if( pxQueue->pcReadFrom < pxQueue->pcHead )     
        {
            pxQueue->pcReadFrom = ( pxQueue->pcTail - pxQueue->uxItemSize );//如果读到了队列结尾则从头开始读
        }
    }

    ++( pxQueue->uxMessagesWaiting );   //更新当前队列数据个数 信号量只更新数据项个数
}

信号量的发送数据函数，并不会真的把数据存储到队列数据存储区中去，而且也没有数据存储区，它仅仅记录数据项的个数，而且这个发送函数没有阻塞时间，也就是一旦满了，任务就不能再向队列尝试添加数据，如果有任务尝试添加，会直接返回一个满列错误，而不会进入阻塞以便等到队列有空间时再将数据添加到队列中区。此函数不可用于递归互斥锁的操作。

上面有一个是互斥锁需要单独处理的，就是当任务不再拥有互斥锁时，将优先级的还原，就是如果发生了优先级继承，则要任务优先级还原成设定值，通过调用 vTaskPriorityDisinherit 函数实现，源码如下：


void vTaskPriorityDisinherit( xTaskHandle * const pxMutexHolder )
    {
    tskTCB * const pxTCB = ( tskTCB * ) pxMutexHolder;

        if( pxMutexHolder != NULL )
        {
            if( pxTCB->uxPriority != pxTCB->uxBasePriority )
            {
                // 将当前任务从当前优先级的任务就绪链表中移除
                if( uxListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) ) == 0 )
                {
                    taskRESET_READY_PRIORITY( pxTCB->uxPriority );
                }

                // 还原优先级 并且将任务加入到新优先级的就绪链表中
                traceTASK_PRIORITY_DISINHERIT( pxTCB, pxTCB->uxBasePriority );
                pxTCB->uxPriority = pxTCB->uxBasePriority;
                listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) pxTCB->uxPriority );
                prvAddTaskToReadyQueue( pxTCB );
            }
        }
    }

7.通用接收信号量函数

#define xSemaphoreTake( xSemaphore, xBlockTime )        xQueueGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )

通用接收信号量函数并不会尝试从队列中真的获取数据，而仅仅是产看队列是否为空，如果不为空，返回一个pdTRUE ,表明有信号量， 如果没有信号量，且设置了阻塞时间，则会将当前任务添加到等待接收链表中。此函数不可用于递归互斥量的操作。通用接收信号量函数牵涉到我们前面讲述的优先级反转的具体实现，通过函数vTaskPriorityInherit 源代码如下：

void vTaskPriorityInherit( xTaskHandle * const pxMutexHolder )
    {
    tskTCB * const pxTCB = ( tskTCB * ) pxMutexHolder;

        if( pxMutexHolder != NULL )
        {
            if( pxTCB->uxPriority < pxCurrentTCB->uxPriority )
            {   // 拥有此信号量的任务优先级比当前任务优先级低
                // 更新链表项的值 存储新的优先级值
                listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) pxCurrentTCB->uxPriority );


                if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )
                {   //将任务从当前优先级链表中移除
                    if( uxListRemove( ( xListItem * ) &( pxTCB->xGenericListItem ) ) == 0 )
                    {
                        taskRESET_READY_PRIORITY( pxTCB->uxPriority );
                    }

                    // 将拥有此信号量的任务优先级设置为与当前任务优先级一致
                    pxTCB->uxPriority = pxCurrentTCB->uxPriority;   
                    prvAddTaskToReadyQueue( pxTCB );        //加入就绪链表
                }
                else
                {
                    pxTCB->uxPriority = pxCurrentTCB->uxPriority;   // 将拥有此信号量的任务优先级设置为与当前任务优先级一致
                }

                traceTASK_PRIORITY_INHERIT( pxTCB, pxCurrentTCB->uxPriority );
            }
        }
    }

这个函数的作用就是假如拥有信号量的任务优先级比尝试TAKE信号量的任务优先级任务优先级低，则将其设置为等待TAKE信号量的任务相同。其他的都是更新与优先级相关的参数。

8.递归信号量发送函数


portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle xMutex )
    {
    portBASE_TYPE xReturn;
    xQUEUE *pxMutex;

        pxMutex = ( xQUEUE * ) xMutex;
        configASSERT( pxMutex );

        if( pxMutex->pxMutexHolder == xTaskGetCurrentTaskHandle() )
        {   //只有递归互斥量的拥有者才能进行GIVE操作
            traceGIVE_MUTEX_RECURSIVE( pxMutex );

            ( pxMutex->uxRecursiveCallCount )--;        //更新递归调用计数值

            /* Have we unwound the call count? */
            if( pxMutex->uxRecursiveCallCount == 0 )
            {
                // 当递归调用计数值为0 表明当前任务已经不再拥有此互斥量，进行一次SEND操作
                xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );
            }

            xReturn = pdPASS;
        }
        else
        {
            //只有递归互斥量的拥有者才能进GIVE操作，不是返回pdFAIL
            xReturn = pdFAIL;

            traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex );
        }

        return xReturn;
    }

通过上述函数，我们可以看到，递归互斥量可以被多个任务TAKE，但是只能只能被同一个任务进行多次TAKE。当 uxRecursiveCallCount = 0 时，则当前任务不再拥有此信号量。注意递归互斥量只能使用此函数GIVE。

9.递归信号量接收函数

portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle xMutex, portTickType xBlockTime )
    {
    portBASE_TYPE xReturn;
    xQUEUE *pxMutex;

        pxMutex = ( xQUEUE * ) xMutex;
        configASSERT( pxMutex );

        traceTAKE_MUTEX_RECURSIVE( pxMutex );

        if( pxMutex->pxMutexHolder == xTaskGetCurrentTaskHandle() )
        {
            ( pxMutex->uxRecursiveCallCount )++;    //更新递归调用计数值
            xReturn = pdPASS;
        }
        else
        {
            xReturn = xQueueGenericReceive( pxMutex, NULL, xBlockTime, pdFALSE );
            //之所以没有检测当前pxMutexHolder是否为空就进行上述操作，因为pxMutex是一个队列项目个数为1的队列，如果被其他任务拥有，则返回pdFAIL
            if( xReturn == pdPASS )
            {
                ( pxMutex->uxRecursiveCallCount )++;
            }
            else
            {
                traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex );
            }
        }

        return xReturn;
    }

递归互斥信号量的获取函数，只能被同一个任务TAKE且可以多次TAKE。注意递归互斥量只能使用此函数GIVE。

hehao9051
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS信号量
hqy450665101的博客
02-01 914
FreeRTOS信号量 信号量（Semaphore）是一种实现任务间通信的机制，可以实现任务之间同步或临界资源的互斥访问， 常用于协助一组相互竞争的任务来访问临界资源。在多任务系统中，各任务之间需要同步或互斥实现临界资源的保护，信号量功能可以为用户提供这方面的支持。抽象的来讲，信号量是一个非负整数，所有获取它的任务都会将该整数减一（获取它当然是为了使用资源），当该整数值为零时，所有试图获取它的任务都将处于阻塞状态。通常一个信号量的计数值用于对应有效的资源数，表示剩下的可被占用的互斥资源数。其值的含义分两种情
FreeRTOS-信号量详解
热门推荐
k666499436的博客
01-27 1万+
本文将详细全方位的讲解FreeRTOS的信量量，其实你学完了《FreeRTOS-消息队列详解》信号量的学习就非常简单了，因为所有的信号量的本质的都是特殊的队列(特殊在哪里：信号量只有队列头部，并没有后面的环形存储区，也就是说信号量只负责消息传递，并不传递数据)，当然这么多信号量也是有区别的，不同的信号量对应不同的应用场景，还是以源码分析为主，源码分析透了，这几种信号量的区别，或者特殊机制(互斥量的优先级继承)就一清二楚了。《FreeRTOS-消息队列详解》
FreeRTOS——信号量篇
顺顺崽的博客
07-09 554
在FreeRTOS中，信号量（Semaphore）是一种用于任务间同步或保护共享资源的机制。任务间同步：即确保一个任务在另一个任务执行到某个点后在执行。资源保护：即控制对共享资源的访问，防止多个任务同时访问资源导致数据不一致。
【FreeRtos信号量详解】
boybs的博客
05-17 585
FreeRtos信号量详解 文章目录FreeRtos信号量详解前言一、信号量介绍二、二值信号量2.1 二值信号量介绍2.2 二值信号量的创建2.3 二值信号量释放2.4 二值信号量获取2.5 二值信号量实验演示三、计数型信号量3.1 计数型信号量介绍3.2 计数型API函数3.3 计数型demo演示四、翻转信号量五、互斥信号量 前言 本次分享的内容是FreeRtos中信号量相关的知识点，会从将用的API函数进行介绍，到二值信号量，计数型信号量、翻转信号量、以及互斥信号进行实验演示。 一、信号量介绍 信
详解FreeRTOS中的信号量(semaphore)
闪耀大叔的博客
04-11 3636
在这种情况下，事件处理程序将在每次事件发生时“give”一个信号量——导致信号量的计数值在每次“give”时增加。可以将延迟处理任务的优先级设置最高，然后，在ISR中调用portYIELD_FROM_ISR()，ISR结束后会运行延迟处理的任务（因为它优先级最高）。当一个任务完成对资源的处理后，它将信号量的计数值向后递增“give”信号量。t1时Task1运行，Task2阻塞等待信号量，t2时发生中断，ISR执行，give一个信号量解除Task2的阻塞态，t3时Task2运行，结束后继续等待下一个信号量。
Freertos信号量
qq_39680190的博客
05-09 293
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
kendryte-freertos-sdk-0.5.0_kendryte_SDK_
10-04
此外，FreeRTOS还支持线程间通信，如信号量、互斥锁和消息队列，使得多任务间的协作变得简单而有效。 Kendryte SDK中的`kendryte-freertos-sdk-0.5.0`这个压缩包包含了SDK的源码、头文件、库文件以及相关的文档资料...
FreeRTOS 采样ADC-20200413.zip
05-04
其核心特性包括任务调度、信号量、互斥锁、邮箱、队列等，这些为实现复杂的多任务并行处理提供了基础。在STM32F103这样的MCU上集成FreeRTOS，可以显著提升系统的响应速度和执行效率。 STM32F103是ST公司推出的基于...
FreeRTOS实时内核详解(官方英文).zip
07-20
《FreeRTOS实时内核详解》是一本深入剖析FreeRTOS实时操作系统的权威教程，它通过实践指导的方式，帮助读者理解和掌握这个广泛使用的嵌入式系统内核。FreeRTOS是一款开源、轻量级、高效的实时操作系统内核，适用于...
阿波罗STM32F429-FreeRTOS-Lwip1.4移植.zip
08-14
它具有任务调度、信号量、互斥锁、队列等核心功能，能够实现多任务并行执行，保证任务的实时性和确定性。FreeRTOS的移植到STM32F429上，需要对硬件中断、内存管理、时钟配置等方面进行适配，确保操作系统能正确响应...
FreeRTOS学习记录--任务创建函数详解
「 虚幻私塾」
04-05 1239
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 开局一张图。一步一步分析就好。 （一）什么是任务？ 在多任务系统中，我们按照功能不同，把整个系统分割成一个个独立的，且无法返回的函数，这个函数我们称为任务；任务包含几个属性：任务堆栈，任务函数、任务控制块、任务优先级；下面主要介绍一下任务控制块，其他都比较容易理解
STM32F103 Freertos信号量
02-14
STM32F103 Freertos信号量
FreeRtos信号量
最新发布
wait123456000的博客
08-10 597
FreeRtos信号量包括二值信号量、计数型信号量、互斥信号量和递归互斥信号量。信号量用于实现任务间的同步或临界资源的互斥访问《相当于一个上，代码只有获得了这个锁的钥匙才能够执行。信号量类似于我们在裸机编写中断服务函数中给予标志位赋值的操作，然后根据标志位所对应的函数让其执行。当某个任务需要获得对应的指令才能开始执行时，因为主程序不可能一直等待对应指令的产生而不去执行其它的任务，这时信号量便可保证其它任务能够正常运行的同时也能兼顾到指令一旦发出对应程序能够立马执行。
FreeRTOS-信号量
咸鱼很渴的博客
09-09 6167
FreeRTOS-信号量 信号量其实就是队列的一种应用，信号量的各种操作都是在队列的基础上建立起来的。那么既然是在队列的基础上建立的，信号量一定具有和队列相同的属性。因此信号量也是为任务和任务、任务和中断之间通信做准备的，但是信号量一般用来进行资源管理和任务同步。因为信号量是一种共享资源，当它被创建之后，系统中所有任务和中断都能对信号量进行访问。同时也可以进行任务同步，即在一个任务(或中断)中告诉另一个任务它所等待的事件发生了，等到发生任务调度的时候，再切换到相应任务中，执行该事件发生的相关处理。Free
FreeRTOS - 信号量
欢迎光临
02-26 786
说信号量之前需要解释一下计算机系统中的资源的概念，这里所说的资源并不仅仅指CPU和内存，打印机、显示器、音响等都算是资源。只要是资源，就存在占用问题，例如如果有两个任务A、B在同一个时间段都想使用同一台打印机进行打印服务，如果系统不对A和B进行管理，两个任务同时向打印机发送数据，可能就会出现冲撞导致打印错误，如果系统先让A任务打印，然后再让B打印，这样就避免了任务之间的资源占用冲撞问题。 信号量...
FreeRTOS--信号量
m0_65737814的博客
05-01 1860
FreeRTOS--计数、二进制、互斥信号量
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值