STM32F1+HAL库+FreeTOTS学习18——任务通知

STM32F1+HAL库+FreeTOTS学习18——任务通知

  • 1. 任务通知
    • 1.1 任务通知的引入
    • 1.2 任务通知简介
    • 1.3 任务通知的优缺点
  • 2. 任务相关API函数
    • 2.1 发送任务通知
      • 2.1.1 xTaskGenericNotify()
      • 2.1.2 xTaskNotifyGive()和xTaskNotifyGiveIndexed()
      • 2.1.2 xTaskNotify()和xTaskNotifyIndexed()
      • 2.1.2 xTaskNotifyAndQuery()和xTaskNotifyAndQueryIndexed()
    • 2.2 在中断中发送任务通知
    • 2.3 接收任务通知
      • 2.3.1 ulTaskNotifyTake()和ulTaskNotifyTakeIndexed()
      • 2.3.1 xTaskNotifyWait ()和xTaskNotifyWaitIndexed()
    • 2.4 清除任务通知
      • 2.4.1 xTaskNotifyStateClear()和xTaskNotifyStateClearIndexed()
      • 2.4.2 ulTaskNotifyValueClear()和ulTaskNotifyValueClearIndexed()
  • 3. 任务通知操作示例
    • 3.1任务通知模拟信号量(二值信号量和数值信号量)
      • 3.1.1 代码实现
      • 3.1.2 运行结果
    • 3.2 任务通知模拟队列
      • 3.2.1 代码实现
      • 3.2.2 运行结果
    • 3.3 任务通知模拟事件标志组
      • 3.2.1 代码实现
      • 3.2.2 运行结果

上一期我们学习了FreeRTOS中的事件标志组,这一期我们开始学习任务通知

1. 任务通知

1.1 任务通知的引入

在之前的篇章中,我们介绍了队列、信号量和事件标志组等内容,它们都是为了实现RTOS中任务的消息同步、适应不同的使用场景而引入的,但是他们都存在一个问题,任务与任务之间的消息同步需要使用到一个中间的对象(这个对象可以是队列、事件标志组、信号量),信号量的释放、获取;队列的写入和读出、事件标志组的置位、清除等操作都是间接的操作这个中间对量来完成。

在这里插入图片描述

实际上,这种方式会导致任务之间的消息同步变慢。有没有办法能够提高任务之间消息同步的速度提升呢?当然有,那就是引入任务通知。

【注】:任务通知在早期的FreeRTOS版本中并不存在,只在V8.2.0之后的版本才有,下面我们来介绍一下任务通知。

1.2 任务通知简介

  • 在 FreeRTOS 中,每一个任务都有两个用于任务通知功能的数组,分别为任务通知数组任务通知状态数组。其中任务通知数组中的每一个元素都是一个 32 位无符号类型的通知值;而任务通知状态数组中的元素则表示与之对应的任务通知的状态。
  • 任务通知数组任务通知状态数组在任务创建的时候就已经存在了,可以通过任务的任务控制块(任务句柄)访问。
  • 每个任务都会有这两个数组,数组的长度由宏 configTASK_NOTIFICATION_ARRAY_ENTRIES 决定,默认长度为1,且数组初始化之后默认值为0。

在这里插入图片描述

下面为相关源代码:

/* 宏定义:定义任务通知相关数组的长度,默认长度为1 */
#define configTASK_NOTIFICATION_ARRAY_ENTRIES           1                       /* 定义任务通知数组的大小, 默认: 1 */

/* 任务控制块结构体定义,只展示任务通知相关数组,其他部分省略 */
typedef struct tskTaskControlBlock       /* The old naming convention is used to prevent breaking kernel aware debuggers. */
{
	/* 、、以上代码省略、、 */
	
  #if ( configUSE_TASK_NOTIFICATIONS == 1 )
        volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
        volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    #endif
    
    /* 、、以下代码省略、、 */
    
} tskTCB;

/* 任务创建函数,里面会调用prvInitialiseNewTask()函数,完成**任务通知数组**和**任务通知状态数组**的初始化 */
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

    BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
                            const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                            const configSTACK_DEPTH_TYPE usStackDepth,
                            void * const pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t * const pxCreatedTask )
    {
    
	/* 、、以上代码省略、、 */
	
	 prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL 		);
	 
	/* 、、以下代码省略、、 */

  	 }
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

/* prvInitialiseNewTask()函数,完成**任务通知数组**和**任务通知状态数组**的初始化 */
static void prvInitialiseNewTask( TaskFunction_t pxTaskCode,
                                  const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                                  const uint32_t ulStackDepth,
                                  void * const pvParameters,
                                  UBaseType_t uxPriority,
                                  TaskHandle_t * const pxCreatedTask,
                                  TCB_t * pxNewTCB,
                                  const MemoryRegion_t * const xRegions )
{

	/* 、、以上代码省略、、 */
	
	/* 初始任务相关数组为0 */
	#if ( configUSE_TASK_NOTIFICATIONS == 1 )
    {
          memset( ( void * ) &( pxNewTCB->ulNotifiedValue[ 0 ] ), 0x00, sizeof( pxNewTCB->ulNotifiedValue ) );
          memset( ( void * ) &( pxNewTCB->ucNotifyState[ 0 ] ), 0x00, sizeof( pxNewTCB->ucNotifyState ) );
     }
    #endif
	
	/* 、、以下代码省略、、 */

}

  • 任务通知数组中存放的是通知的内容,我们称之为“通知值”,当通知值为0时,表示没有任务通知,当通知值不为0时,表示有任务通知,通知的内容就是通知值。
  • 任务通知状态数组中存放任务通知的状态,任务通知有三种状态:未等待任务通知状态(默认状态);等待通知状态(接收方已经准备好,调用了接收任务通知函数,等待发送方发送通知);等待接收状态(发送方已经发送任务通知,调用了发送任务通知函数,等待接收方接收)。
  • 任务通知状态相关定义如下:
/* Values that can be assigned to the ucNotifyState member of the TCB. */
#define taskNOT_WAITING_NOTIFICATION              ( ( uint8_t ) 0 ) 		/* 任务未等待通知状态 */
#define taskWAITING_NOTIFICATION                  ( ( uint8_t ) 1 )			/* 等待通知状态 */
#define taskNOTIFICATION_RECEIVED                 ( ( uint8_t ) 2 )			/* 等待接收状态 */

1.3 任务通知的优缺点

优点:

  1. 效率更高:使用任务通知向任务发送事件或数据比使用队列、事件标志组或信号量快得多
  2. 使用内存更小:使用其他方法时都要先创建对应的结构体,使用任务通知时无需额外创建结构体

缺点:

  1. 无法发送数据给中断:ISR没有任务结构体,所以无法给ISR发送数据。但是ISR可以使用任务通知的功能,发数据给任务。
  2. 只能点对点通信:任务通知只能是被指定的一个任务接收并处理
  3. 无法缓存多个数据:任务通知是通过更新任务通知值来发送数据的,任务结构体中只有一个任务通知值,只能保持一个数据(无法像队列那样入队和读出,只能保存一个通知值)。
  4. 发送不支持阻塞:发送方无法进入阻塞状态等待

2. 任务相关API函数

FreeRTOS 提供了任务通知的一些相关操作函数,其中任务通知相关 API 函数,如下两表:

我们前面提到:

  • 每一个任务都有两个用于任务通知功能的数组,分别为任务通知数组任务通知状态数组
  • 任务通知数组任务通知状态数组在任务创建的时候就已经存在了,可以通过任务的任务控制块(任务句柄)访问。
  • 每个任务都会有这两个数组,数组的长度由宏 configTASK_NOTIFICATION_ARRAY_ENTRIES 决定,默认长度为1,且数组初始化之后默认值为0。
  • 在数组的长度为1的情况下(默认情况),对应的我们会使用表1中的函数完成任务通知的相关操作。
  • 在数组的长度大于1的情况下,需要通过数组成员的下表进行索引,所有我们会使用表2中的函数。

【注】:表1和表2中的函数功能是一一对应的,只是表2中的函数是应对任务通知数组长度大于1的情况,增加了索引,本质上是一样的。在接下来的内容中,我们重点接收表1中相关API函数,表2中会稍微带过一下。

表1

函数描述
xTaskNotify()发送任务通知,带有通知值
xTaskNotifyAndQuery()发送任务通知,带有通知值 ,且保留接收任务原来的通知值
xTaskNotifyGive()发送任务通知,不带通知值
xTaskNotifyFromISR()中断中发送任务通知,带有通知值
xTaskNotifyAndQueryFromISR()中断中发送任务通知,带有通知值 ,且保留接收任务原来的通知值
vTaskNotifyGiveFromISR()中断中发送任务通知,不带通知值
ulTaskNotifyTake()接收任务通知,作为信号量使用,获取信号量
xTaskNotifyWait()接收任务通知,作为队列和事件标志组使用,读取消息
xTaskNotifyStateClear()清除任务通知状态
ulTaskNotifyValueClear()清除任务通知值

表2

函数描述
xTaskNotifyIndexed()发送任务通知,带有通知值
xTaskNotifyAndQueryIndexed()发送任务通知,带有通知值 ,且保留接收任务原来的通知值
xTaskNotifyGiveIndexed()发送任务通知,不带通知值
xTaskNotifyIndexedFromISR()中断中发送任务通知,带有通知值
xTaskNotifyAndQueryIndexedFromISR()中断中发送任务通知,带有通知值 ,且保留接收任务原来的通知值
vTaskNotifyGiveIndexedFromISR()中断中发送任务通知,不带通知值
ulTaskNotifyTakeIndexed()接收任务通知,作为信号量使用,获取信号量
xTaskNotifyWaitIndexed()接收任务通知,作为队列和事件标志组使用,读取消息
xTaskNotifyStateClearIndexed()清除任务通知状态
ulTaskNotifyValueClearIndexed()清除任务通知值

2.1 发送任务通知

为了实现任务通知模拟信号量、队列、事件标志组这三种对象的通信,满足不同场景下的需求,FreeRTOS分别提供了三个发送任务通知的函数,他们分别是:

表1.1 默认情况下的:

函数描述
xTaskNotifyGive()发送任务通知,不带通知值
xTaskNotify()发送任务通知,带有通知值
xTaskNotifyAndQuery()发送任务通知,带有通知值 ,且保留接收任务原来的通知值

表1.2 带有索引值的

函数描述
xTaskNotifyGiveIndexed()发送任务通知,不带通知值
xTaskNotifyIndexed()发送任务通知,带有通知值
xTaskNotifyAndQueryIndexed()发送任务通知,带有通知值 ,且保留接收任务原来的通知值

但是实际上这些函数都是宏定义,在FreeRTOS的源码“task.h”中有定义,源码如下:

/* 发送任务通知,带有通知值 */
#define xTaskNotifyGive( xTaskToNotify ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( 0 ), eIncrement, NULL )
#define xTaskNotifyGiveIndexed( xTaskToNotify, uxIndexToNotify ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( 0 ), eIncrement, NULL )

/* 发送任务通知,不带通知值 */
#define xTaskNotify( xTaskToNotify, ulValue, eAction ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL )
#define xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, ulValue, eAction ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL )

/* 发送任务通知,带有通知值 ,且保留接收任务原来的通知值  */
#define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
#define xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotifyValue ) \
    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )

可以看到,上述所有函数都是调用了同一个函数xTaskGenericNotify(),那么我们先来学习xTaskGenericNotify()函数,上述的所有函数也就迎刃而解了。

2.1.1 xTaskGenericNotify()

我们先来看一下函数原型:

typedef enum
{
    eNoAction = 0,            /* 不修改通知值,只会标记任务通知为等待接收状态 */
    eSetBits,                 /* 设置通知值特定的位. */
    eIncrement,               /* 通知值加1 */
    eSetValueWithOverwrite,   /* 覆写通知值 */
    eSetValueWithoutOverwrite /* 覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败 */
} eNotifyAction;

/* xTaskGenericNotify()函数参数列表中的通知方式为枚举类型,定义如上👆 */
/**
 * @函数名:       xTaskGenericNotify:发送任务通知函数
 * @参数1:        xTaskToNotify:接收任务通知的任务句柄(任务控制块)
 * @参数1:        uxIndexToNotify:任务通知的相关数组索引,表1.1中的函数无该参数,默认为0。
 * @参数1:        ulValue:通知值							 
 * @参数1:        eAction:通知方式,为枚举类型,在定义在上面 
 * @参数1:        pulPreviousNotificationValue:用于获取发送通知前的通知值
 * @retval      返回值为NULL,表示创建失败,其他值表示为创建事件标志组的句柄
 */
BaseType_t xTaskGenericNotify(	 TaskHandle_t xTaskToNotify,
								 UBaseType_t uxIndexToNotify,
								 uint32_t ulValue,
								 eNotifyAction eAction,
								 uint32_t * pulPreviousNotificationValue);

了解了函数原型,我们来看一下具体怎么实现的:

/* 判断是否开启了任务通知 */
#if ( configUSE_TASK_NOTIFICATIONS == 1 )
	
	/* 函数定义 */
    BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
                                   UBaseType_t uxIndexToNotify,
                                   uint32_t ulValue,
                                   eNotifyAction eAction,
                                   uint32_t * pulPreviousNotificationValue )
    {
    	/* 创建任务控制块,返回值,任务通知状态 */
        TCB_t * pxTCB;
        BaseType_t xReturn = pdPASS;
        uint8_t ucOriginalNotifyState;

		/* 断言:确保索引值小于数组的有效长度 */
        configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );
        configASSERT( xTaskToNotify );
        pxTCB = xTaskToNotify;
		
		/* 进入临界区 */
        taskENTER_CRITICAL();
        {
       		 /* pulPreviousNotificationValue 不等于NULL,说明需要获取发送通知之前的通知值 */
            if( pulPreviousNotificationValue != NULL )
            {
              	/* 获取发送通知之前的通知值 */
                *pulPreviousNotificationValue = pxTCB->ulNotifiedValue[ uxIndexToNotify ];
            }
			
			/* 在发送任务通知之前获取任务通知状态 */
            ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ];
			
			/* 将任务通知的状态改成等待接收状态,以便于调用接收任务通知函数,判断是否有待接收的任务通知
			  如果没有任务通知,那就进入阻塞或者退出 */
            pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED;

			/* 根据通知方式的不同,执行对应的操作 */
            switch( eAction )
            {
           		 /* 设置特定的位 */
                case eSetBits:
                    pxTCB->ulNotifiedValue[ uxIndexToNotify ] |= ulValue;
                    break;
                    
				/* 通知值加1 */
                case eIncrement:
                    ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++;
                    break;

				/* 覆写通知值 */
                case eSetValueWithOverwrite:
                    pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;
                    break;
				
				/* 覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败 */
                case eSetValueWithoutOverwrite:

					/* 任务不处于等待接收通知状态,可以覆写 */
                    if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
                    {
                        pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;
                    }
                    /* 否则返回失败 */
                    else
                    {
                        /* The value could not be written to the task. */
                        xReturn = pdFAIL;
                    }

                    break;

				/* 不修改通知值,只会标记任务通知为等待接收状态 */
                case eNoAction:

                    /* The task is being notified without its notify value being
                     * updated. */
                    break;
                    
				/* 正常不会存在这个情况 */
                default:

                    /* Should not get here if all enums are handled.
                     * Artificially force an assert by testing a value the
                     * compiler can't assume is const. */
                    configASSERT( xTickCount == ( TickType_t ) 0 );

                    break;
            }

			/* 用于调试 */
            traceTASK_NOTIFY( uxIndexToNotify );

            /* 如果在此之前任务因为等待通知而被阻塞,那么就解除阻塞 */
            if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
            {
          		  /* 将任务从阻塞列表移除 */
                listREMOVE_ITEM( &( pxTCB->xStateListItem ) );
				/* 添加任务到就绪列表 */
                prvAddTaskToReadyList( pxTCB );

                /* 任务是因为等待任务通知而被阻塞的,所以不应该在任何一个事件列表中,这个是断言,. */
                configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );

				/* 低功耗相关 */
                #if ( configUSE_TICKLESS_IDLE != 0 )
                    {
                        /* If a task is blocked waiting for a notification then
                         * xNextTaskUnblockTime might be set to the blocked task's time
                         * out time.  If the task is unblocked for a reason other than
                         * a timeout xNextTaskUnblockTime is normally left unchanged,
                         * because it will automatically get reset to a new value when
                         * the tick count equals xNextTaskUnblockTime.  However if
                         * tickless idling is used it might be more important to enter
                         * sleep mode at the earliest possible time - so reset
                         * xNextTaskUnblockTime here to ensure it is updated at the
                         * earliest possible time. */
                        prvResetNextTaskUnblockTime();
                    }
                #endif

				/* 判断是否需要进行任务切换 */
                if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
                {
                    /* The notified task has a priority above the currently
                     * executing task so a yield is required. */
                    taskYIELD_IF_USING_PREEMPTION();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        taskEXIT_CRITICAL();

        return xReturn;
    }

#endif /* configUSE_TASK_NOTIFICATIONS */

上述就是 xTaskGenericNotify() 的所有定义,可以看到主要的内容可以分为下面几步:

  1. 判断是否需要保存原来的任务通知值,要的话保存,否则不保存
  2. 记录目标任务先前的通知状态,然后赋值新的状态
  3. 根据传入的参数不同,选择不同的通知值更新方式
  4. 根据先前的通知状态,判断是否需要进行解除目标任务的阻塞状态,是否需要进行任务切换。

有了上面的基础,我们接着来看发送任务通知函数的使用。

2.1.2 xTaskNotifyGive()和xTaskNotifyGiveIndexed()

此函数用于发送任务通知,通知方式为不带通知值,而是通知值加1,常用来模拟二值信号量和数字信号量。在task.h中有定义。函数原型如下:

/**
 * @brief       xTaskNotifyGive:发送任务通知,通知方式为不带通知值,而是通知值加1
 * @param       xTaskToNotify : 需要被发送任务通知的目标任务句柄(任务控制块)
 * @retval      返回值默认都是pdPASS,没有实际用处
 */
 BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

/**
 * @brief       xTaskNotifyGiveIndexed:发送任务通知,通知方式为不带通知值,而是通知值加1
 * @param       xTaskToNotify : 需要被发送任务通知的目标任务句柄(任务控制块)
 * @param       uxIndexToNotify : 任务通知相关的数组成员索引值
 * @retval      返回值默认都是pdPASS,没有实际用处
 */
 BaseType_t xTaskNotifyGiveIndexed( TaskHandle_t xTaskToNotify, 
                                    UBaseType_t uxIndexToNotify );

2.1.2 xTaskNotify()和xTaskNotifyIndexed()

此函数用于发送任务通知,发送通知的方法如下:

  • 写入一个32位数字的通知值 (这种方法可以用来模拟队列)
  • 通知值+1 (用来模拟信号量)
  • 设置通知值中的一个或多个位(模拟事件标志组)
  • 保持通知值不变,只标记任务通知状态为等待接收状态。

在task.h中有定义。函数原型如下:

/**
 * @brief       xTaskNotify:发送任务通知,带有通知值,且不保存原来的通知值
 * @param       xTaskToNotify: 需要被发送任务通知的目标任务句柄(任务控制块)
 * @param       ulValue: 需要写入的通知值
 * @param       eAction : 需要写入的方式
 * @retval      返回值默认都是pdPASS,为其他值时表示写入方式为:覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败
 */
 BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify,
                         uint32_t ulValue,
                         eNotifyAction eAction );

/**
 * @brief       xTaskNotify:发送任务通知,带有通知值,且不保存原来的通知值
 * @param       xTaskToNotify: 需要被发送任务通知的目标任务句柄(任务控制块)
 * @param       uxIndexToNotify: 任务通知相关的数组成员索引值
 * @param       ulValue: 需要写入的通知值
 * @param       eAction : 需要写入的方式
 * @retval      返回值默认都是pdPASS,为其他值时表示写入方式为:覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败
 */
 BaseType_t xTaskNotifyIndexed( TaskHandle_t xTaskToNotify,
                                UBaseType_t uxIndexToNotify,
                                uint32_t ulValue,
                                eNotifyAction eAction );

下面是不同的写入方式与通知值之间的对应关系:

  • eNoAction :目标任务接收事件,但其通知值不会更新。在这种情况下, 不会使用 ulValue。
  • eSetBits : 目标任务的通知值将与 ulValue 进行按位“或”操作。
  • eIncrement:目标任务的通知值将增加 1,相当于调用 xTaskNotifyGive()。在这种情况下, 不会使用 ulValue。
  • eSetValueWithOverwrite :目标任务的通知值无条件设置为 ulValue
  • eSetValueWithoutOrwrite : 如果目标任务当前没有挂起的通知,则其通知值将设置为 ulValue。如果目标任务已有挂起的通知,则其通知值不会更新, 以免之前的值在使用前被覆盖。在这种情况下,调用 xTaskNotify() 会失败, 返回 pdFALSE。通过这种方式,可以模拟长度为1的队列写入消息。

2.1.2 xTaskNotifyAndQuery()和xTaskNotifyAndQueryIndexed()

此函数和 xTaskNotify用法上是一样的,只不过多了一个参数存放原来的通知值。具体使用方法可以参照 2.1.2 xTaskNotify()和xTaskNotifyIndexed()
我们这里只展示函数原型:

```c
/**
 * @brief       xTaskNotifyAndQuery:发送任务通知,带有通知值,且保存原来的通知值
 * @param       xTaskToNotify: 需要被发送任务通知的目标任务句柄(任务控制块)
 * @param       ulValue: 需要写入的通知值
 * @param       eAction : 需要写入的方式
 * @param       pulPreviousNotifyValue : 保存上一次通知值的地址
 * @retval      返回值默认都是pdPASS,为其他值时表示写入方式为:覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败
 */
 BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify,
                                 uint32_t ulValue,
                                 eNotifyAction eAction,
                                 uint32_t *pulPreviousNotifyValue );
/**
 * @brief       xTaskNotify:发送任务通知,带有通知值,且不保存原来的通知值
 * @param       xTaskToNotify: 需要被发送任务通知的目标任务句柄(任务控制块)
 * @param       uxIndexToNotify: 任务通知相关的数组成员索引值
 * @param       ulValue: 需要写入的通知值
 * @param       eAction : 需要写入的方式
 * @param       pulPreviousNotifyValue : 保存上一次通知值的地址
 * @retval      返回值默认都是pdPASS,为其他值时表示写入方式为:覆写前判断是否处于等待接收状态,如果是,则不覆写,返回失败
 */
 BaseType_t xTaskNotifyAndQueryIndexed( TaskHandle_t xTaskToNotify,
                                        UBaseType_t uxIndexToNotify,
                                        uint32_t ulValue,
                                        eNotifyAction eAction,
                                        uint32_t *pulPreviousNotifyValue );

2.2 在中断中发送任务通知

和2.1内容类似,FreeRTOS中提供了中断中发送任务通知的API函数,如下表

表1.1 默认情况下的:

函数描述(默认都是中断中使用)
vTaskNotifyGiveFromISR ()发送任务通知,不带通知值
xTaskNotifyFromISR ()发送任务通知,带有通知值
xTaskNotifyAndQueryFromISR()发送任务通知,带有通知值 ,且保留接收任务原来的通知值

表1.2 带有索引值的

函数描述(默认都是中断中使用)
vTaskNotifyGiveIndexedFromISR()发送任务通知,不带通知值
xTaskNotifyIndexedFromISR()发送任务通知,带有通知值
xTaskNotifyAndQueryIndexedFromISR()发送任务通知,带有通知值 ,且保留接收任务原来的通知值

但是实际上这些函数都是宏定义,在FreeRTOS的源码“task.h”中有定义,源码如下:

/* 发送任务通知,带有通知值 */
#define vTaskNotifyGiveFromISR( xTaskToNotify, pxHigherPriorityTaskWoken ) \
    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( pxHigherPriorityTaskWoken ) );
#define vTaskNotifyGiveIndexedFromISR( xTaskToNotify, uxIndexToNotify, pxHigherPriorityTaskWoken ) \
    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( pxHigherPriorityTaskWoken ) );

/* 发送任务通知,不带通知值 */
#define xTaskNotifyFromISR( xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
#define xTaskNotifyIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )

/* 发送任务通知,带有通知值 ,且保留接收任务原来的通知值  */
#define xTaskNotifyAndQueryIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) \
    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )
#define xTaskNotifyAndQueryFromISR( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) \
    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )

可以看到,上述所有函数都是调用了同一个函数xTaskGenericNotifyFromISR(),但是xTaskGenericNotifyFromISR和2.1中的xTaskGenericNotify()函数实现方法基本一致,只不过是增加了是否需要任务切换的判断,由于篇幅问题,我们这里就不做过多的赘述,内部实现的使用方法,请参照 2.1发送任务通知 中的内容

如果有疑问的地方,可以参照官网内容:RTOS任务通知

2.3 接收任务通知

在接收任务通知中,我们使用到的API函数只有两个,没有中断中使用的接收任务通知函数,如下表:

表3.1 默认情况下的:

函数描述
ulTaskNotifyTake()接收任务通知,作为信号量使用,获取信号量
xTaskNotifyWait()接收任务通知,作为队列和事件标志组使用,读取消息

表3.2 带有索引值的

函数描述(默认都是中断中使用)
ulTaskNotifyTakeIndexed()接收任务通知,作为信号量使用,获取信号量
xTaskNotifyWaitIndexed()接收任务通知,作为队列和事件标志组使用,读取消息

2.3.1 ulTaskNotifyTake()和ulTaskNotifyTakeIndexed()

ulTaskNotifyTake()和ulTaskNotifyTakeIndexed()用来 接收任务通知,作为信号量使用,获取信号量 ,在FreeRTOS提供源码的task.h中有定义:

#define ulTaskNotifyTake( xClearCountOnExit, xTicksToWait ) \
    ulTaskGenericNotifyTake( ( tskDEFAULT_INDEX_TO_NOTIFY ), ( xClearCountOnExit ), ( xTicksToWait ) )
#define ulTaskNotifyTakeIndexed( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait ) \
    ulTaskGenericNotifyTake( ( uxIndexToWaitOn ), ( xClearCountOnExit ), ( xTicksToWait ) )

可以看到,ulTaskNotifyTake()和ulTaskNotifyTakeIndexed()都是宏定义,实际上都是调用了ulTaskGenericNotifyTake()函数,所以我们先来看一下ulTaskGenericNotifyTake()的函数原型,再来理解这两个函数:

/**
 * @brief       ulTaskGenericNotifyTake:获取任务的通知值,并将通知-1或者清零
 * @param       uxIndexToWaitOn : 任务通知相关的数组成员索引值
 * @param       xClearCountOnExit : 设置为pdTRUE,则在函数退出之前,会将通知值清零,为pdFALSE则通知值减1
 * @param       xTicksToWait : 阻塞等待时间
 * @retval      被递减或清除之前的任务通知值的值
 */
 uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWait,
                                      BaseType_t xClearCountOnExit,
                                      TickType_t xTicksToWait );

下面是函数定义:

/* 必须先开启任务通知, */
#if ( configUSE_TASK_NOTIFICATIONS == 1 )

    uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWait,
                                      BaseType_t xClearCountOnExit,
                                      TickType_t xTicksToWait )
    {
    	/* 定义返回值 */
        uint32_t ulReturn;

		/* 索引值需要小于任务通知相关数字的长度,否则为数组越界访问,不允许出现 */
        configASSERT( uxIndexToWait < configTASK_NOTIFICATION_ARRAY_ENTRIES );

		/* 进入临界区 */
        taskENTER_CRITICAL();
        {
            /* 判断通知值是否为0 */
            if( pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] == 0UL )
            {
                /* 通知值为0,表示没有消息,设置任务通知状态为等待通知状态 */
                pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskWAITING_NOTIFICATION;

				/* 判断是否允许阻塞等待任务通知 */
                if( xTicksToWait > ( TickType_t ) 0 )
                {
                	/* 阻塞当前任务 */
                    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
					/* 用于调试,不必理会 */
                    traceTASK_NOTIFY_TAKE_BLOCK( uxIndexToWait );

                    /* All ports are written to allow a yield in a critical
                     * 挂起PendSV,进行任务切换,阻塞当前任务 */
                    portYIELD_WITHIN_API();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        /* 退出临界区 */
        taskEXIT_CRITICAL();

		/* 进入临界区,阻塞时间到达,从此开始执行 */
        taskENTER_CRITICAL();
        {
        	/* 用于调试 */
            traceTASK_NOTIFY_TAKE( uxIndexToWait );
            
            /* 获取任务通知的通知值 */
            ulReturn = pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ];

			/* 通知值不为0,则通知值有意义, */
            if( ulReturn != 0UL )
            {
            	/* 需要清零通知值 */
                if( xClearCountOnExit != pdFALSE )
                {
                    pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] = 0UL;
                }
                /* 通知值减1 */
                else
                {
                    pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] = ulReturn - ( uint32_t ) 1;
                }
            }
            /* 通知值无意义 */
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
			
			/* 无论接收通知值成功或失败,都将通知值标记为未等待通知状态 */
            pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskNOT_WAITING_NOTIFICATION;
        }
        /* 退出临界区 */
        taskEXIT_CRITICAL();

		/* 返回清零或减一之前的通知值 */
        return ulReturn;
    }

#endif /* configUSE_TASK_NOTIFICATIONS */

上述就是 ulTaskGenericNotifyTake() 的所有定义,可以看到主要的内容可以分为下面几步:

  1. 判断通知值是否为0,如果为0的话,表示还没有任务通知,将当前任务通知状态赋值为等待通知状态,然后判断是否需要阻塞,看情况阻塞或者直接退出
  2. 如果通知值不为0,表示已经有任务通知,根据传入参数对通知值减一或者清零,然后将任务通知状态设置为未等待通知状态。

了解了ulTaskGenericNotifyTake()函数干了什么,我们来总结以下ulTaskNotifyTake()和ulTaskNotifyTakeIndexed()这两个函数:

/**
 * @brief       ulTaskNotifyTake:获取任务的通知值,并将通知-1
 * @param       xClearCountOnExit : 设置为pdTRUE,则在函数退出之前,会将通知值清零,为pdFALSE则通知值减1
 * @param       xTicksToWait : 阻塞等待时间
 * @retval      被递减或清除之前的任务通知值的值
 */
 uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit,
                           TickType_t xTicksToWait );
/**
 * @brief       ulTaskNotifyTakeIndexed:获取任务的通知值,并将通知-1
 * @param       uxIndexToWaitOn : 任务通知相关的数组成员索引值
 * @param       xClearCountOnExit : 设置为pdTRUE,则在函数退出之前,会将通知值清零,为pdFALSE则通知值减1
 * @param       xTicksToWait : 阻塞等待事件
 * @retval      被递减或清除之前的任务通知值的值
 */
uint32_t ulTaskNotifyTakeIndexed( UBaseType_t uxIndexToWaitOn, 
                                  BaseType_t xClearCountOnExit, 
                                  TickType_t xTicksToWait );

2.3.1 xTaskNotifyWait ()和xTaskNotifyWaitIndexed()

xTaskNotifyWait ()和xTaskNotifyWaitIndexed()用来接收任务通知,作为队列和事件标志组使用,读取消息,在FreeRTOS提供源码的task.h中有定义:

#define xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
    xTaskGenericNotifyWait( tskDEFAULT_INDEX_TO_NOTIFY, ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )
#define xTaskNotifyWaitIndexed( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
    xTaskGenericNotifyWait( ( uxIndexToWaitOn ), ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )

可以看到,xTaskNotifyWait ()和xTaskNotifyWaitIndexed()都是宏定义,实际上都是调用了xTaskGenericNotifyWait()函数,所以我们先来看一下xTaskGenericNotifyWait()的函数原型,再来理解这两个函数:

xTaskGenericNotifyWait()函数用于等待通知值中的特定比特位被置1,在等待任务通知前和成功等待任务通知之后将通知值的特点位清零,获取等待超时后的任务通知值,等操作,可用来解决队列消息的读出和时间标志组的获取等操作。

/**
 * @brief       xTaskGenericNotifyWait:获取任务的通知值,等待通知值中的特定比特位被置1
 * @param       uxIndexToWaitOn: 任务通知相关的数组成员索引值
 * @param       ulBitsToClearOnEntry: 调用 xTaskNotifyWait() 时,如果通知已挂起,则在进入 xTaskNotifyWait() 函数(即任务等待新通知之						  
 * 				前)时,ulBitsToClearOnEntry 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除 。
 *																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * 
 * @param       ulBitsToClearOnExit: 如果在调用 xTaskNotifyWait() 函数时收到了通知,则在 xTaskNotifyWait() 函数退出之前	
 * 				ulBitsToClearOnExit 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除。
 * 																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * @param       pulNotificationValue: 上一次通知值(上一次指的是通过ulBitsToClearOnExit清除之前的通知值)保存的地方,如果不需要此功能,传入NULL即可
 * @param       xTicksToWait : 等待阻塞时间
 * @retval      返回值为pdTRUE,表示等待任务通知成功,返回值为pdFLASE,表示等待任务通知失败
 */
BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
                                   uint32_t ulBitsToClearOnEntry,
                                   uint32_t ulBitsToClearOnExit,
                                   uint32_t * pulNotificationValue,
                                   TickType_t xTicksToWait );

【注】:当任务的通知被“挂起”时,实际上是指任务在等待一个通知的过程中处于阻塞状态。因此通知挂起,说明还没有通知值,这个时候ulBitsToClearOnEntry才能起作用。

了解了xTaskGenericNotifyWait()的函数原型,我们来看一下具体的定义和如何实现的:

/* 开启任务通知的宏定义 */
#if ( configUSE_TASK_NOTIFICATIONS == 1 )

	/* xTaskGenericNotifyWait()函数定义 */
    BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWait,
                                       uint32_t ulBitsToClearOnEntry,
                                       uint32_t ulBitsToClearOnExit,
                                       uint32_t * pulNotificationValue,
                                       TickType_t xTicksToWait )
    {
    	/* 返回值 */
        BaseType_t xReturn;

		/* 确保索引值小于任务通知相关数组的长度。这是个断言 */
        configASSERT( uxIndexToWait < configTASK_NOTIFICATION_ARRAY_ENTRIES );

		/* 进入临界区 */
        taskENTER_CRITICAL();
        {
            /* 判断任务通知状态是否不为等待通知状态,如果是,说明没有任务通知 */
            if( pxCurrentTCB->ucNotifyState[ uxIndexToWait ] != taskNOTIFICATION_RECEIVED )
            {
                /* 开始前清零任务通知值的特定位*/
                pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] &= ~ulBitsToClearOnEntry;

                /* 修改任务通知状态为等待通知状态 */
                pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskWAITING_NOTIFICATION;
				
				/* 此时还没有任务通知,那就判断是否要进入阻塞,进行任务切换 */
                if( xTicksToWait > ( TickType_t ) 0 )
                {
                    /* 把当前任务添加到阻塞列表 */
                    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
					/* 用来调试 */
                    traceTASK_NOTIFY_WAIT_BLOCK( uxIndexToWait );

                   /* 挂起PendSV中断,任务切换 */
                    portYIELD_WITHIN_API();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        /* 退出临界区 */
        taskEXIT_CRITICAL();

		/* 如果任务阻塞时间到来,下次就会从这里执行,开始进入临界区 */
        taskENTER_CRITICAL();
        {
        	/* 用于调试 */
            traceTASK_NOTIFY_WAIT( uxIndexToWait );

			/* 判断是否需要保存任务通知值 */
            if( pulNotificationValue != NULL )
            {
                /* 保存清除特定位之前的通知值,即上一次通知值 */
                *pulNotificationValue = pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ];
            }

            /*再次判断任务是否不为等待接收通知状态,即是否还是没有通知,如果还没有就返回pdFLASE,接收失败*/
            if( pxCurrentTCB->ucNotifyState[ uxIndexToWait ] != taskNOTIFICATION_RECEIVED )
            {
                /* A notification was not received. */
                xReturn = pdFALSE;
            }
            /* 否则说明接收到了通知,将通知值的指定位清零 */
            else
            {
                /* A notification was already pending or a notification was
                 * received while the task was waiting. */
                pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] &= ~ulBitsToClearOnExit;
                xReturn = pdTRUE;
            }

			/* 无论接收是否成功或者失败,都将任务通知状态标记为等待通知状态 */
            pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskNOT_WAITING_NOTIFICATION;
        }
        /* 退出临界区 */
        taskEXIT_CRITICAL();

		/* 返回接收成功还是失败 */
        return xReturn;
    }

#endif /* configUSE_TASK_NOTIFICATIONS */

上述就是 xTaskGenericNotifyWait() 的所有定义,可以看到主要的内容可以分为下面几步:

  1. 判断任务有没有通知值,如果没有的话,根据参数ulBitsToClearOnEntry将通知值的特定位清零,更新任务通知状态为等待通知状态,判断是否需要阻塞,切换任务
  2. 如果有通知值,或者在阻塞时间内等到了任务通知的通知值,则先判断是否需要保存通知值,根据需要选择保存或不保存,如何根据参数ulBitsToClearOnExit将通知值的特定位清零。如果没通知值,且阻塞时间到了也没等到任务通知值,那么跳过通知值清零这一步,
  3. 最后不管成功接收与否,都将任务通知状态标记为未等待通知状态。

了解了xTaskGenericNotifyWait()函数干了什么,我们来总结以下xTaskNotifyWait ()和xTaskNotifyWaitIndexed()这两个函数:

/**
 * @brief       xTaskNotifyWait:获取任务的通知值,等待通知值中的特定比特位被置1,不带索引值
 * @param       ulBitsToClearOnEntry: 调用 xTaskNotifyWait() 时,如果通知已挂起,则在进入 xTaskNotifyWait() 函数(即任务等待新通知之						  
 * 				前)时,ulBitsToClearOnEntry 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除 。
 *																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * 
 * @param       ulBitsToClearOnExit: 如果在调用 xTaskNotifyWait() 函数时收到了通知,则在 xTaskNotifyWait() 函数退出之前	
 * 				ulBitsToClearOnExit 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除。
 * 																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * @param       pulNotificationValue: 上一次通知值(上一次指的是通过ulBitsToClearOnExit清除之前的通知值)保存的地方,如果不需要此功能,传入NULL即可
 * @param       xTicksToWait : 等待阻塞时间
 * @retval      返回值为pdTRUE,表示等待任务通知成功,返回值为pdFLASE,表示等待任务通知失败
 */
 BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,
                             uint32_t ulBitsToClearOnExit,
                             uint32_t *pulNotificationValue,
                             TickType_t xTicksToWait );
/**
 * @brief       xTaskNotifyWaitIndexed:获取任务的通知值,等待通知值中的特定比特位被置1,带有索引值
 * @param       uxIndexToWaitOn: 任务通知相关的数组成员索引值
 * @param       ulBitsToClearOnEntry: 调用 xTaskNotifyWait() 时,如果通知已挂起,则在进入 xTaskNotifyWait() 函数(即任务等待新通知之						  
 * 				前)时,ulBitsToClearOnEntry 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除 。
 *																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * 
 * @param       ulBitsToClearOnExit: 如果在调用 xTaskNotifyWait() 函数时收到了通知,则在 xTaskNotifyWait() 函数退出之前	
 * 				ulBitsToClearOnExit 中设置的任何位都会在调用 RTOS 任务的通知值中 被清除。
 * 																		 传入0x00000000表示不清零通知值
 * 																		 传入0x00000001表示清零通知值的第0位
 * 																	     传入0x00000003表示清零通知值的第0位和第1位
 * @param       pulNotificationValue: 上一次通知值(上一次指的是通过ulBitsToClearOnExit清除之前的通知值)保存的地方,如果不需要此功能,传入NULL即可
 * @param       xTicksToWait : 等待阻塞时间
 * @retval      返回值为pdTRUE,表示等待任务通知成功,返回值为pdFLASE,表示等待任务通知失败
 */
 BaseType_t xTaskNotifyWaitIndexed( UBaseType_t uxIndexToWaitOn,
                                    uint32_t ulBitsToClearOnEntry,
                                    uint32_t ulBitsToClearOnExit,
                                    uint32_t *pulNotificationValue,
                                    TickType_t xTicksToWait );

2.4 清除任务通知

在清除任务通知中,我们使用到的API函数只有两个,没有中断中使用的接收任务通知函数,如下表:

表3.1 默认情况下的:

函数描述
xTaskNotifyStateClear()清除任务通知状态
ulTaskNotifyValueClear()清除任务通知值

表3.2 带有索引值的

函数描述(默认都是中断中使用)
xTaskNotifyStateClearIndexed()清除任务通知状态
ulTaskNotifyValueClearIndexed()清除任务通知值

由于这个内容的函数使用相对简单,所以我下面直接展示函数原型,内部实现不做介绍。

2.4.1 xTaskNotifyStateClear()和xTaskNotifyStateClearIndexed()

xTaskNotifyStateClear()和xTaskNotifyStateClearIndexed()用来 清除任务通知的状态,在FreeRTOS提供源码的task.h中有定义,函数原型如下:

/**
 * @brief       xTaskNotifyStateClear:清除任务通知的状态,不带索引值
 * @param       xTask : 需要被清除任务状态的任务句柄
 * @retval      返回值为pdTRUE,表示清除成功,返回值为pdFLASE,表示清除失败
 */
BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );
/**
 * @brief       xTaskNotifyStateClearIndexed:清除任务通知的状态,带有索引值
 * @param       xTask : 需要被清除任务状态的任务句柄
 * @param       uxIndexToClear : 任务通知相关的数组成员索引值
 * @retval      返回值为pdTRUE,表示清除成功,返回值为pdFLASE,表示清除失败
 */
BaseType_t xTaskNotifyStateClearIndexed( TaskHandle_t xTask, 
                                         UBaseType_t uxIndexToClear );

2.4.2 ulTaskNotifyValueClear()和ulTaskNotifyValueClearIndexed()

ulTaskNotifyValueClear()和ulTaskNotifyValueClearIndexed()用来 清除任务通知的通知值,在FreeRTOS提供源码的task.h中有定义,函数原型如下:

/**
 * @brief       ulTaskNotifyValueClear:清除任务通知的值,带有索引值
 * @param       xTask : 需要被清除任务通知值的任务句柄
 * @param       ulBitsToClear : 需要被清除的通知值特定为,传入0xffffffff时,表示全部清零,传入0时,可用来查询当前的任务通知值
 * @retval      返回值未清零前的任务通知值
 */
uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, 
                                 uint32_t ulBitsToClear );
/**
 * @brief       ulTaskNotifyValueClearIndexed:清除任务通知的值,带有索引值
 * @param       xTask : 需要被清除任务通知值的任务句柄
 * @param       uxIndexToClear : 任务通知相关的数组成员索引值
 * @param       ulBitsToClear : 需要被清除的通知值特定为,传入0xffffffff时,表示全部清零,传入0时,可用来查询当前的任务通知值
 * @retval      返回值未清零前的任务通知值
 */
uint32_t ulTaskNotifyValueClearIndexed( TaskHandle_t xTask, 
                                        UBaseType_t uxIndexToClear,
                                        uint32_t ulBitsToClear );

以上就是所有FreeRTOS官方文档中提到的任务通知相关API函数的介绍了,下面我们来看一下实际的任务通知模拟信号量、队列、时间标志组的具体应用。

3. 任务通知操作示例

为了避免篇幅过长,我们下面就直接展示关键部分的代码,包括创建的任务、按键处理以及具体会用到的代码,其他部分的代码,可以参照往期的内容,话不多说,我这里先展示以下公告会用到的部分代码。

任务配置相关部分

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 
 */
#define TASK1_PRIO      1                  /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1Task_Handler;  /* 任务句柄 */
void task1(void *pvParameters);					/*任务函数*/

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 
 */
#define TASK2_PRIO      2                  /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);					/*任务函数*/
 
/******************************************************************************************************/

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{

	taskENTER_CRITICAL();           /* 进入临界区,关闭中断,此时停止任务调度*/

    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1Task_Handler);
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);

    taskEXIT_CRITICAL();            /* 退出临界区,重新开启中断,开启任务调度 */
    vTaskStartScheduler();		//开启任务调度
}

按键扫描部分

void Key_One_Scan(uint8_t KeyName ,void(*OnKeyOneUp)(void), void(*OnKeyOneDown)(void))
{
   static uint8_t Key_Val[Key_Name_Max];    //按键值的存放位置
   static uint8_t Key_Flag[Key_Name_Max];   //KEY0~2为0时表示按下,为1表示松开,WKUP反之
    
   Key_Val[KeyName] = Key_Val[KeyName] <<1;  //每次扫描完,将上一次扫描的结果左移保存
   
    switch(KeyName)
    {
        case Key_Name_Key0:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY0_GPIO_Port, KEY0_Pin));    //读取Key0按键值
            break;
        case Key_Name_Key1:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin));   //读取Key1按键值
            break;
        case Key_Name_Key2:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY2_GPIO_Port, KEY2_Pin));   //读取Key2按键值
            break;
//        case Key_Name_WKUP:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(WKUP_GPIO_Port, WKUP_Pin));   //读取WKUP按键值
//            break; 
        default:
            break;
    }
//    if(KeyName == Key_Name_WKUP)     //WKUP的电路图与其他按键不同,所以需要特殊处理
//    {
//        //WKUP特殊情况
//        //当按键标志为1(松开)是,判断是否按下,WKUP按下时为0xff
//        if(Key_Val[KeyName] == 0xff && Key_Flag[KeyName] == 1)
//        {
//            (*OnKeyOneDown)();
//           Key_Flag[KeyName] = 0;
//        }
//        //当按键标志位为0(按下),判断按键是否松开,WKUP松开时为0x00
//        if(Key_Val[KeyName] == 0x00 && Key_Flag[KeyName] == 0)
//        {
//            (*OnKeyOneUp)();
//           Key_Flag[KeyName] = 1;
//        } 
//    }
//    else                               //Key0~2按键逻辑判断
//    {
        //Key0~2常规判断
          //当按键标志为1(松开)是,判断是否按下
        if(Key_Val[KeyName] == 0x00 && Key_Flag[KeyName] == 1)
        {
            (*OnKeyOneDown)();
           Key_Flag[KeyName] = 0;
        }
        //当按键标志位为0(按下),判断按键是否松开
        if(Key_Val[KeyName] == 0xff && Key_Flag[KeyName] == 0)
        {
            (*OnKeyOneUp)();
           Key_Flag[KeyName] = 1;
        }  
//    }
     
   
}

下面是具体的实验代码。

3.1任务通知模拟信号量(二值信号量和数值信号量)

在STM32F103RCT6上运行FreeRTOS,通过按键控制,控制任务通知模拟二值信号量和数值信号量,具体要求如下:

  • 创建两个任务,分别为任务1和任务2
  • 任务1:按键0按下,发送任务通知给任务2的通知值[0],发送方式为通知值加1,并且不获取发送任务通知前任务通知的通知值;按键1按下,发送任务通知给任务2的通知值[1],发送方式为通知值加1,并且不获取发送任务通知前任务通知的通知值
  • 任务2:接收任务通知,并且在接收到任务通知之后,把任务通知的通知值减一/清零:ulTaskNotifyTake()函数的第一个参数为pdTRUE表示通知值清零,为pdFLASE表示通知值清零。
    【注】:我们这里是同时模拟二值信号量和数值信号量,因此任务通知相关的数值长度为2,但是默认长度是1,需要修改,且调用的函数也需要使用带有索引值的。

3.1.1 代码实现

  • 由于本期内容涉及到按键扫描,会用到: STM32框架之按键扫描新思路 ,这里不做过多介绍。我们直接来看代码:
  1. 任务处理部分
#define configTASK_NOTIFICATION_ARRAY_ENTRIES           2                       /* 定义任务通知数组的大小, 默认: 1 ,这里被我修改成了2,用来同时使用二值信号量和计数信号量*/

/**
* @brief       task1:用于按键扫描,按键0按下,发送任务通知给任务2的通知值[0],发送方式为通知值加1,并且不获取发送任务通知前任务通知的通知值
* @brief                           按键1按下,发送任务通知给任务2的通知值[1],发送方式为通知值加1,并且不获取发送任务通知前任务通知的通知值
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task1(void *pvParameters)
{
    
    while(1)
    {
		Key_One_Scan(Key_Name_Key0,Key0_Up_Task,Key0_Down_Task);
		Key_One_Scan(Key_Name_Key1,Key1_Up_Task,Key1_Down_Task);
		vTaskDelay(10);
    }
}	
/**
* @brief       task2:接收任务通知,并且在接收到任务通知之后,把任务通知的通知值减一/清零:ulTaskNotifyTake()函数的第一个参数为pdTRUE表示通知值清零,为pdFLASE表示通知值清零
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task2(void *pvParameters)	
{	
	uint32_t notifyVal = 0;
	
	while(1)
    {	
		notifyVal = ulTaskNotifyTakeIndexed(Task2NotifyIndex_BinarySemaphore,pdTRUE,0);
		/* 返回值为被递减或清除之前的任务通知值的值,不为0表示获取成功,为0表示获取失败  */
		
		// notifyVal = ulTaskNotifyTake( pdTRUE, 0 );	/* 二值信号量的获取也可以使用这个函数,因为我们这是二值信号量的索引值为0,但是数值信号量不可以,只能使用ulTaskNotifyTakeIndexed()函数 */
		
		if(notifyVal != 0)
		{
			
			printf("任务通知模拟二值信号量获取成功\r\n");
		}
		
		notifyVal = ulTaskNotifyTakeIndexed(Task2NotifyIndex_CountingSemaphore,pdFALSE,0);
		/* 返回值为被递减或清除之前的任务通知值的值,不为0表示获取成功,为0表示获取失败  */
		if(notifyVal != 0)
		{
			
			printf("任务通知模拟计数信号量获取成功,当前计数值为:%d\r\n",notifyVal - 1);
		}
		vTaskDelay(1000);
    }

}
  1. 按键处理部分
/* 这里我们修改了"FreeRTOSConfig.h" 中的 configTASK_NOTIFICATION_ARRAY_ENTRIES 宏,
   使得通知值数组长度变成了2,第一个存放二值信号量,第二个存放计数信号量*/
#define Task2NotifyIndex_BinarySemaphore  (0)
#define Task2NotifyIndex_CountingSemaphore  (1)

void Key0_Down_Task(void)
{
	if(Task2Task_Handler != NULL)
	{
		printf("\r\n按键0按下\r\n\r\n");
		/* 向任务2发送任务通知给通知值[0] */
		printf("任务通知模拟二值信号量释放成功!\r\n");
		xTaskNotifyGiveIndexed(Task2Task_Handler,Task2NotifyIndex_BinarySemaphore);
		
		// xTaskNotifyGive(Task2Task_Handler);  	/* 二值信号量的获取也可以使用这个函数,因为我们这是二值信号量的索引值为0,但是数值信号量不可以,只能使用 xTaskNotifyGiveIndexed()函数 */
	}

}

void Key1_Down_Task(void)
{
	if(Task2Task_Handler != NULL)
	{
		printf("\r\n按键1按下\r\n\r\n");
		/* 向任务2发送任务通知给通知值[0] */
		printf("任务通知模拟计数信号量释放成功!\r\n");
		xTaskNotifyGiveIndexed(Task2Task_Handler,Task2NotifyIndex_CountingSemaphore);
	}
	
}

3.1.2 运行结果

在这里插入图片描述

3.2 任务通知模拟队列

在STM32F103RCT6上运行FreeRTOS,通过按键控制,控制任务通知模拟队列,具体要求如下:

  • 创建两个任务,分别为任务1和任务2
  • 任务1:按键0按下,发送任务通知给任务2,发送方式为通知值覆写,发送数据为按键0的键值;按键1按下,发送任务通知给任务2,发送方式为通知值覆写,发送数据为按键1的键值。
  • 任务2:接收任务通知,并且在接收到任务通知之后,读出通知值存放到keyVal中,然后清零通知值,随后在串口打印消息。

3.2.1 代码实现

  • 由于本期内容涉及到按键扫描,会用到: STM32框架之按键扫描新思路 ,这里不做过多介绍。我们直接来看代码:
  1. 任务处理部分
/**
* @brief       task1:用于按键扫描,按键0按下,发送任务通知给任务2,发送方式为通知值覆写,发送数据为按键0的键值,并且不获取发送任务通知前任务通知的通知值
* @brief                           按键1按下,发送任务通知给任务2,发送方式为通知值覆写,发送数据为按键1的键值,并且不获取发送任务通知前任务通知的通知值
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task1(void *pvParameters)
{
    
    while(1)
    {
		Key_One_Scan(Key_Name_Key0,Key0_Up_Task,Key0_Down_Task);
		Key_One_Scan(Key_Name_Key1,Key1_Up_Task,Key1_Down_Task);
		vTaskDelay(10);
    }
}	
/**
* @brief       task2:接收任务通知,并且在接收到任务通知之后,读出通知值存放到keyVal中,然后清零通知值,随后在串口打印消息。
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task2(void *pvParameters)	
{	
	uint32_t keyVal = 0;
	
	while(1)
    {	
		xTaskNotifyWait(0x00000000,0xffffffff,&keyVal,portMAX_DELAY);
		
		if(keyVal)
		{
				printf("任务通知模拟消息队列,收到的消息为:%d\r\n",keyVal);
				keyVal = 0;
		}
    }

}
  1. 按键处理部分
typedef enum
 {
     Key_Name_Key0 = 0x01,
     Key_Name_Key1,
     Key_Name_Key2,
     Key_Name_WKUP,
     Key_Name_Max
 }EnumKeyO

void Key1_Down_Task(void)
{
	printf("\r\n按键1按下\r\n\r\n");
	if(Task2Task_Handler != NULL)
	{
		/* 向任务2发送任务通知给通知值,发送方式为覆写,模拟队列的消息写入*/
		printf("任务通知模拟队列写入消息成功,写入的消息为:%d\r\n",Key_Name_Key1);
		
		xTaskNotify(Task2Task_Handler,Key_Name_Key1,eSetValueWithOverwrite);
	}
}extern TaskHandle_t   	Task2Task_Handler;  /* 任务2句柄 */

void Key0_Down_Task(void)
{
	printf("\r\n按键0按下\r\n\r\n");
	if(Task2Task_Handler != NULL)
	{
		/* 向任务2发送任务通知给通知值,发送方式为覆写,模拟队列的消息写入*/
		printf("任务通知模拟队列写入消息成功,写入的消息为:%d\r\n",Key_Name_Key0);
		
		xTaskNotify(Task2Task_Handler,Key_Name_Key0,eSetValueWithOverwrite);

	}
}

3.2.2 运行结果

在这里插入图片描述

3.3 任务通知模拟事件标志组

在STM32F103RCT6上运行FreeRTOS,通过按键控制,控制任务通知模拟事件标志组,具体要求如下:

  • 创建两个任务,分别为任务1和任务2
  • 任务1:按键0按下,将通知值第0位置1;按键1按下,将通知值第1位置1。按键按下,打印相关信息,开启LED指示。
  • 任务2:当按键1和0的事件标志组位都被置1,打印相关信息,并关闭相应的LED指示。

3.2.1 代码实现

  • 由于本期内容涉及到按键扫描,会用到: STM32框架之按键扫描新思路 ,这里不做过多介绍。我们直接来看代码:
  1. 任务处理部分
/**
* @brief       task1:用于按键扫描,按键0或1按下,自动置位事件标志组,并开启相应的LED指示
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task1(void *pvParameters)
{
    
    while(1)
    {
		Key_One_Scan(Key_Name_Key0,Key0_Up_Task,Key0_Down_Task);
		Key_One_Scan(Key_Name_Key1,Key1_Up_Task,Key1_Down_Task);
		vTaskDelay(10);
    }
}	
/**
* @brief       task2:当按键1和0的事件标志组位都被置1,打印相关信息,并关闭相应的LED指示
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task2(void *pvParameters)	
{	
	uint32_t NotifyVal = 0;
	while(1)
    {	
		
		/* 等待按键0和1的事件标志位,同时不清清除通知值 */
		xTaskNotifyWait( 0x00000000, 0x00000000, &NotifyVal, portMAX_DELAY );
		
		/* 当按键0和按键1的对应标志位都为1的情况下,清零通知值,然后打印相关信息 */
		if( (NotifyVal & Key0_EventBit) && (NotifyVal & Key1_EventBit) )
		{
			/* 清零通知值 */
			ulTaskNotifyValueClear(NULL,0xffffffff);
			/* 打印相关信息 */
			printf("等待到的事件标志为:%#x\r\n",NotifyVal);
			
			/* 关闭LED指示 */
			HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,LED_OFF);
			HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,LED_OFF);
		}

		vTaskDelay(50);
    }

}
  1. 按键处理部分
/*  因为这两个宏在 freertos_demo.c 文件中有使用,所以需要放在key.h中,而不是放在key.c中 */
#define Key0_EventBit (0x01 << 0)			/*key0对应标志组的bit0*/
#define Key1_EventBit (0x01 << 1)			/*key1对应标志组的bit1*/

void Key0_Down_Task(void)
{
	printf("\r\n按键0按下\r\n\r\n");
	/* 设置事件标志位 */
	HAL_GPIO_WritePin(LED0_GPIO_Port,LED0_Pin,LED_ON);
	
	/* 开启LED指示 */
	 xTaskNotify( Task2Task_Handler,Key0_EventBit,eSetBits );
	
}

void Key1_Down_Task(void)
{
	printf("\r\n按键1按下\r\n\r\n");
	/* 设置事件标志位 */
	HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,LED_ON);
	
	/* 开启LED指示 */
	xTaskNotify( Task2Task_Handler,Key1_EventBit,eSetBits );

}

3.2.2 运行结果

在这里插入图片描述

以上就是本期的所有内容,不能说是很多,只能说是非常多,创造不易,点个关注再走呗。

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/896664.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【LeetCode:910. 最小差值 II + 模拟 + 思维】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…

低功耗4G模组的小秘密:RSA算法示例驾到,通通闪开...

在实际应用中&#xff0c;低功耗4G模组的RSA算法示例具有重要的价值&#xff0c;所以今天我们学习合宙低功耗4G模组Air780EP_LuatOS_rsa示例&#xff1a; 1.简介 RSA算法的安全性基于&#xff1a;将两个大质数相乘很容易&#xff0c;但是想要将其乘积分解成原始的质数因子却非…

微信小程序广告组件被驳回之后怎么重新提交广告组件?

有时候遇到广告组件被退回的问题 这时需要重新提交一次程序代码&#xff0c;然后提交审核然后发布新版本之后&#xff0c;找到广告管理&#xff0c;即可看到广告组件是在正在审核状态中

CANoe_数据回放功能功能介绍_时间段(区间)选择

CANoe的日志回放功能&#xff0c;可以选择时间段回放&#xff0c;这样可以在数据量很大的时候快速定位分析数据问题点 CANoe日志回放功能概述 CANoe的日志回放功能允许用户重现和分析已记录的CAN总线或其他网络总线数据。这些日志文件通常以CANoe自己的日志格式&#xff08;.b…

C#学习笔记(一)

C#学习笔记&#xff08;一&#xff09; 简介第一章 上位机开发环境之 VS 使用和.NET 平台基础一、安装软件二、创建项目三、第一个Hello world四、解决方案与项目五、Debug 和 Release 的区别六、代码的生产过程七、CLR的其它功能 简介 C# .NET工控上位机开发 在工控领域&…

【AI 大模型】智能时代的核心驱动力

1. 引言&#x1f4dc;1.1 AI大模型的崛起与影响力&#x1f31f;1.2 本文的研究目的与结构&#x1f9d0; 2. AI大模型的基础概念与技术原理&#x1f4da;2.1 定义与核心特征&#x1f3af;2.2 深度学习架构基础&#x1f9e0;2.3 大规模数据训练的重要性&#x1f4ca;2.4 模型优化…

15分钟学Go 实战项目一:命令行工具

实战项目一&#xff1a;命令行工具 1. 引言 命令行工具是开发者常用的工具之一&#xff0c;它可以帮助用户通过命令行界面对程序进行控制和交互。在这节中&#xff0c;我们将创建一个简单的命令行工具&#xff0c;以帮助你理解Go语言的基本语法和如何处理命令行输入。在这个过…

HarmonyOS NEXT 应用开发实战(六、组件导航Navigation使用详解)

在鸿蒙应用开发中&#xff0c;Navigation 组件是实现界面间导航的重要工具。本文将介绍如何使用 Navigation 组件实现页面跳转及参数传递&#xff0c;确保你能轻松构建具有良好用户体验的应用。 当前HarmonyOS支持两套路由机制&#xff08;Navigation和Router&#xff09;&…

Dongle Sentinal在Jenkins下访问不了的问题

背景&#xff1a; 工作站部署的jenkins的脚本无法正常打包&#xff0c;定位后发现是本地获取不了license&#xff0c;但是使用usb over network的远程license都能获取并正常打包 分析&#xff1a; 获取不了license的原因是本地无法识别dongle。根据提供信息&#xff0c;之前…

力扣76~80题

题76&#xff08;困难&#xff09;&#xff1a; 分析&#xff1a; 这道题其实不难&#xff0c;但是是我做最久的了&#xff0c;我居然去用res去接所有可能得值&#xff0c;然后再求长度导致空间暴力&#xff0c;我还以为是我queue的问题。。。 最后用暴力求解解的&#xff0c…

Apache Seata Raft模式配置中心

本文来自 Apache Seata官方文档&#xff0c;欢迎访问官网&#xff0c;查看更多深度文章。 本文来自 Apache Seata官方文档&#xff0c;欢迎访问官网&#xff0c;查看更多深度文章。 Apache Seata Raft模式配置中心 title: Seata Raft模式配置中心 author: 蒋奕晨-清华大学&…

Vue是一套构建用户界面的渐进式框架,常用于构建单页面应用

学习总结 1、掌握 JAVA入门到进阶知识(持续写作中……&#xff09; 2、学会Oracle数据库入门到入土用法(创作中……&#xff09; 3、手把手教你开发炫酷的vbs脚本制作(完善中……&#xff09; 4、牛逼哄哄的 IDEA编程利器技巧(编写中……&#xff09; 5、面经吐血整理的 面试技…

HCIE-Datacom题库_11_IPsecVPN【17道题】

一、单选题 1.IPsecSA(SecurityAssociation&#xff0c;安全联盟)有两种生成方式&#xff0c;分别是手工方式和IKE自动协商方式&#xff0c;以下关于这两种方式的描述中&#xff0c;错误的是哪一项? 手工方式和IKE方式建立的SA都支持动态刷新 IKE方式建立的SA,其生存周期由…

传奇架设GEE引擎数据库服务器提示:拒绝未授权ip连接服务器的解决办法

今天一个新手GM遇到一个问题&#xff0c;他有一个GEE引擎的传奇版本&#xff0c;数据库服务器提示&#xff1a;拒绝未授权ip连接服务器&#xff1a;222.186.50.212、111.162.159.87 1.189.121.156、14.204.122.13、1.189.141.27等等&#xff0c;出于担心服务器是否有异常&#…

【VUE安装本地自定义capacitor插件以及打包成安卓APK过程】

capacitor插件创建使用过程 1. 初始化一个vue项目2.安装capacitor依赖3.自动化创建插件4. 实现功能后构建插件,插件目录下生成dist文件夹5. vue项目中安装插件6. vue项目中使用接口7. 构建vue项目8.构建为安卓项目9.打包APK1. 初始化一个vue项目 过程省略,本案例用的vue3+ty…

AI编译器与TVM

由于AI芯片的特殊性和高度定制化&#xff0c;为了兼容硬件的多样性&#xff0c;AI模型必须能被高效地映射到各种AI芯片上。AI编译器将深度学习框架描述的AI模型作为输入&#xff0c;将为各种AI芯片生成的优化代码作为输出。AI编译器的目标是通过编译优化的方法将深度学习框架产…

onlyoffice docker启用jwt并生成jwt

一、说明 本文是docker教程&#xff0c;linux/win的安装版本也类似&#xff0c;只需要修改配置文件中的secrt就可以了【Configuring JWT for ONLYOFFICE Docs - ONLYOFFICE】 二、正文开始 docker启动时候如果不想使用jwt&#xff0c;加上参数-e JWT_ENABLEDfalse就可以了&…

AI驱动的支持截图或线框图快速生成网页应用的开源项目

Napkins.dev是什么 Napkins.dev是一个创新的开源项目&#xff0c;基于AI技术将用户的截图或线框图快速转换成可运行的网页应用程序。项目背后依托于Meta的Llama 3.1 405B大型语言模型和Llama 3.2 Vision视觉模型&#xff0c;结合Together.ai的推理服务&#xff0c;实现从视觉设…

Centos7安装ZLMediaKit

https://github.com/ZLMediaKit/ZLMediaKit 一 获取代码 git clone https://gitee.com/xia-chu/ZLMediaKit cd ZLMediaKit git submodule update --init git submodule update --init 命令用于初始化和更新 Git 仓库中的子模块&#xff08;submodules&#xff09;。这个命令…

AI劳动力崛起:人将面临失业危机?

场景 第一眼看到这个网站的时候&#xff0c;AI员工官网&#xff08;好像是部署在美国&#xff09;&#xff0c;我觉得很好奇&#xff0c;真的可以让AI替代人类完成工作吗&#xff1f;替代到什么程度呢&#xff1f;能以自然语言直接驱动吗&#xff1f; 正好手上在做爬虫项目&am…