FreeRTOS之xLIST

已于 2022-05-01 07:51:25 修改
阅读量1.3k 收藏
点赞数
分类专栏： STM32 FreeRTOS 文章标签： stm32
于 2022-05-01 07:49:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglianzhu_91/article/details/124522349
版权

基础结构决定上层建筑。FreeRTOS作为实时操作系统，首先作为操作系统肯定重要任务就是任务调度。那么任务调度就涉及到多种任务状态的管理。比如：挂起的任务、就绪的任务、正在执行的任务。那么这些任务的管理就需要数据结构。可以采用数组来管理，但是任务是频繁在挂起、就绪、运行状态切换。因此数组需要来回移动元素，太低效了。同时每个任务列表的大小也不好定，定义大了浪费空间，定义小了空间不够还得拷贝数组。

要理解FreeRTOS的任务调度就必须先理解FreeRTOS的列表实现。下图为空List初始化状态，和插入第一个列表项状态及第二个列表项状态。

对应执行方法（开始直接理解插入列表项有点费解，画图就明白了）:

void vListInitialise(List_t * const pxList)
void vListInsertEnd(List_t * const pxList,ListItem_t * const pxNewListItem)
void vListInsertEnd(List_t * const pxList,ListItem_t * const pxNewListItem)

在这里插入图片描述

为此需要为OS内核调度量身定做一种列表数据结构。该结构采用双向指针的链表结构。每个列表项有一个列表项指针指向前一个列表项。和一个列表项指针指向下一个列表项。同时每个列表项可以指向所属的列表或者指向空指针。这样在任务切换状态时候只要改列表项的所属列表指向就完成列表项移动。

首先申明列表的结构（因为列表项要指向所属列表）

//申明列表结构
struct xLIST;

然后定义列表结构体

//定义列表项结构
struct xLIST_ITEM
{
  //检测位点
  listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
  //列表项的值，告诉编译器不要优化，随时可能变化	
  configLIST_VOLATILE TickType_t xItemValue;  
  //指向下一个列表项	
  struct xLIST_ITEM * configLIST_VOLATILE pxNext;   
  //指向前一个列表项  
  struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; 
  //指向所属对象，主要指列表项所在的tcb
  void * pvOwner;
  //指向所属列表	
  struct xLIST * configLIST_VOLATILE pxContainer;    
  //检测位点
  listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE          
};
typedef struct xLIST_ITEM ListItem_t;

在这里插入图片描述

再定义一个Mini的列表项结构体，这是给列表的End节点用的。Mini列表项没有所属对象和所属列表，节省8字节空间。

//定义列表项结构迷你版。End节点不需要所属对象指针和所属列表。为了少8个字节设计的
struct xMINI_LIST_ITEM
{
  //检测位点
  listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE 
  //列表项的值，默认设置类型最大值
  configLIST_VOLATILE TickType_t xItemValue;
  //指向下一个列表项	
  struct xLIST_ITEM * configLIST_VOLATILE pxNext;
  //指向前一个列表项  
  struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
};
typedef struct xMINI_LIST_ITEM MiniListItem_t;

在这里插入图片描述

然后定义列表结构体

//定义列表结构体，调度器基于该结构进行调度实现
typedef struct xLIST
{
  //检测位点
  listFIRST_LIST_INTEGRITY_CHECK_VALUE
  //该列表的元素个数	
  volatile UBaseType_t uxNumberOfItems;
  //通过他遍历列表。指向一个列表节点或终结点
  ListItem_t * configLIST_VOLATILE pxIndex;
  //终结点	
  MiniListItem_t xListEnd;                 
  //检测位点  
  listSECOND_LIST_INTEGRITY_CHECK_VALUE    
} List_t;

在这里插入图片描述

列表结构定义就是以上三个结构体。然后实现一下列表操作的api供操作列表。

//设置列表项所属对象。通常指向tcb
#define listSET_LIST_ITEM_OWNER(pxListItem, pxOwner)
//得到列表项所属，通常是得到列表所在的tcb
#define listGET_LIST_ITEM_OWNER(pxListItem) `
//得到列表项的值
#define listGET_LIST_ITEM_VALUE(pxListItem) 
//得到列表头部第一项的值
#define listGET_ITEM_VALUE_OF_HEAD_ENTRY(pxList)
//得到列表头部第一项
#define listGET_HEAD_ENTRY(pxList)
//得到当前列表项的下一项
#define listGET_NEXT(pxListItem)
//得到列表的终结点
#define listGET_END_MARKER(pxList)
//得到列表是否为空
#define listLIST_IS_EMPTY(pxList)
//得到列表项目个数
#define listCURRENT_LIST_LENGTH(pxList)
//得到下一个tcb
#define listGET_OWNER_OF_NEXT_ENTRY(pxTCB,pxList)
//把列表项从列表里面移除，返回列表数量
//pxItemToRemove:要异常的列表项
#define listREMOVE_ITEM(pxItemToRemove)

//用宏定义的把列表项插入列表结尾
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
#define listINSERT_END( pxList, pxNewListItem ) 


//得到列表第一项
#define listGET_OWNER_OF_HEAD_ENTRY( pxList )
//检测列表项是否在列表里
#define listIS_CONTAINED_WITHIN( pxList, pxListItem )
//得到列表项的容器对象
#define listLIST_ITEM_CONTAINER( pxListItem )
//检测列表的End节点是否设置为最大值
#define listLIST_IS_INITIALISED( pxList )
//初始化列表，列表在使用前必须被初始化
void vListInitialise( List_t * const pxList )
//初始化列表项目，列表项目使用前也要初始化
void vListInitialiseItem( ListItem_t * const pxItem )
//往列表里插入列表项，按值排序
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsert( List_t * const pxList,ListItem_t * const pxNewListItem )

//往列表结尾加入列表项元素
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsertEnd( List_t * const pxList,ListItem_t * const pxNewListItem )

//把列表项从列表里面移除，返回列表数量
//pxItemToRemove:要异常的列表项
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )

list.h的完整头文件

/*
	任务调度的基础数据结构，很重要。任务调度都依赖该列表操作。
*/

#ifndef LIST_H
#define LIST_H

#ifndef INC_FREERTOS_H
    #error "FreeRTOS.h must be included before list.h"
#endif

#ifndef configLIST_VOLATILE
    #define configLIST_VOLATILE
#endif 

//C++相关
#ifdef __cplusplus
    extern "C" {
#endif


//检测列表用的
#if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
    /* Define the macros to do nothing. */
    #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
    #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
    #define listFIRST_LIST_INTEGRITY_CHECK_VALUE
    #define listSECOND_LIST_INTEGRITY_CHECK_VALUE
    #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
    #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
    #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
    #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
    #define listTEST_LIST_ITEM_INTEGRITY( pxItem )
    #define listTEST_LIST_INTEGRITY( pxList )
#else /* if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 ) */
    /* Define macros that add new members into the list structures. */
    #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE     TickType_t xListItemIntegrityValue1;
    #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE    TickType_t xListItemIntegrityValue2;
    #define listFIRST_LIST_INTEGRITY_CHECK_VALUE          TickType_t xListIntegrityValue1;
    #define listSECOND_LIST_INTEGRITY_CHECK_VALUE         TickType_t xListIntegrityValue2;

/* Define macros that set the new structure members to known values. */
    #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )     ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
    #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )    ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
    #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )              ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
    #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )              ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE

/* Define macros that will assert if one of the structure members does not
 * contain its expected value. */
    #define listTEST_LIST_ITEM_INTEGRITY( pxItem )                      configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
    #define listTEST_LIST_INTEGRITY( pxList )                           configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
#endif /* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES */


//申明列表结构
struct xLIST;

//定义列表项结构
struct xLIST_ITEM
{
	//检测位点
  listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
  //列表项的值，告诉编译器不要优化，随时可能变化	
  configLIST_VOLATILE TickType_t xItemValue;  
  //指向下一个列表项	
  struct xLIST_ITEM * configLIST_VOLATILE pxNext;   
  //指向前一个列表项  
  struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; 
	//指向所属对象，主要指列表项所在的tcb
  void * pvOwner;
  //指向所属列表	
  struct xLIST * configLIST_VOLATILE pxContainer;    
  //检测位点
	listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE          
};
typedef struct xLIST_ITEM ListItem_t;                   

//定义列表项结构迷你版。End节点不需要所属对象指针和所属列表。为了少8个字节设计的
struct xMINI_LIST_ITEM
{
  //检测位点
  listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE 
	//列表项的值，默认设置类型最大值
  configLIST_VOLATILE TickType_t xItemValue;
	//指向下一个列表项	
  struct xLIST_ITEM * configLIST_VOLATILE pxNext;
	//指向前一个列表项  
  struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
};
typedef struct xMINI_LIST_ITEM MiniListItem_t;

//定义列表结构体，调度器基于该结构进行调度实现
typedef struct xLIST
{
	//检测位点
  listFIRST_LIST_INTEGRITY_CHECK_VALUE
  //该列表的元素个数	
  volatile UBaseType_t uxNumberOfItems;
	//通过他遍历列表。指向一个列表节点或终结点
  ListItem_t * configLIST_VOLATILE pxIndex;
  //终结点	
  MiniListItem_t xListEnd;                 
  //检测位点  
	listSECOND_LIST_INTEGRITY_CHECK_VALUE    
} List_t;

//设置列表项所属对象。通常指向tcb
#define listSET_LIST_ITEM_OWNER(pxListItem, pxOwner)    (( pxListItem )->pvOwner = (void *)(pxOwner))

//得到列表项所属，通常是得到列表所在的tcb
#define listGET_LIST_ITEM_OWNER(pxListItem)             ((pxListItem)->pvOwner )

//设置列表项的值
#define listSET_LIST_ITEM_VALUE(pxListItem, xValue)     ((pxListItem)->xItemValue = (xValue))

//得到列表项的值
#define listGET_LIST_ITEM_VALUE(pxListItem)             ((pxListItem)->xItemValue)

//得到列表头部第一项的值
#define listGET_ITEM_VALUE_OF_HEAD_ENTRY(pxList)        (((pxList)->xListEnd).pxNext->xItemValue )

//得到列表头部第一项
#define listGET_HEAD_ENTRY(pxList)                      (((pxList)->xListEnd).pxNext)

//得到当前列表项的下一项
#define listGET_NEXT(pxListItem)                        ((pxListItem )->pxNext)

//得到列表的终结点
#define listGET_END_MARKER(pxList)                      ((ListItem_t const *) (&((pxList )->xListEnd)))

//得到列表是否为空
#define listLIST_IS_EMPTY(pxList)                       (((pxList)->uxNumberOfItems == (UBaseType_t )0) ? pdTRUE : pdFALSE)

//得到列表项目个数
#define listCURRENT_LIST_LENGTH(pxList)                 ((pxList)->uxNumberOfItems)

//得到下一个tcb
#define listGET_OWNER_OF_NEXT_ENTRY(pxTCB,pxList)                                           \
    {                                                                                       \
        List_t * const pxConstList = (pxList);                                              \
			  /*移动指针到下一个元素*/                                                             \
        (pxConstList)->pxIndex = (pxConstList)->pxIndex->pxNext;                            \
			   /*移动到最后了*/                                                                    \
        if((void *) (pxConstList)->pxIndex ==(void *) &((pxConstList)->xListEnd))           \
        {                                                                                   \
            (pxConstList)->pxIndex=(pxConstList)->pxIndex->pxNext;                          \
        }                                                                                   \
				/*得到TCB*/                                                                         \
        (pxTCB)=(pxConstList)->pxIndex->pvOwner;                                            \
    }

//把列表项从列表里面移除，返回列表数量
//pxItemToRemove:要异常的列表项
#define listREMOVE_ITEM(pxItemToRemove)                                                    \
    {                                                                                      \
        /*得到要移除列表项指向的列表指针*/                                                   \
        List_t * const pxList = (pxItemToRemove)->pxContainer;                             \
                                                                                           \
			  /*要移除列表项的后面节点的前一项指针指向要移除节点的前一个节点*/                       \
        ( pxItemToRemove)->pxNext->pxPrevious = (pxItemToRemove)->pxPrevious;              \
			  /*要移除列表项前一个节点的后一项指针指向要移除节点后一项*/                             \
        ( pxItemToRemove)->pxPrevious->pxNext = (pxItemToRemove)->pxNext;                  \
        /*确保索引指向一个有效的项目*/                                                       \
        if(pxList->pxIndex == (pxItemToRemove))                                            \
        {                                                                                  \
            pxList->pxIndex = (pxItemToRemove)->pxPrevious;                                \
        }                                                                                  \
        /*把要移除项的所属设置空指针,不属于任何列表*/                                         \
        (pxItemToRemove)->pxContainer = NULL;                                              \
				/*列表数量减1*/                                                                     \
        (pxList->uxNumberOfItems)--;                                                       \
    }

//用宏定义的把列表项插入列表结尾
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
#define listINSERT_END( pxList, pxNewListItem )                           \
    {                                                                     \
			 ListItem_t * const pxIndex = (pxList)->pxIndex;                    \
       listTEST_LIST_INTEGRITY((pxList));                                 \
       listTEST_LIST_ITEM_INTEGRITY((pxNewListItem));                     \
       (pxNewListItem)->pxNext = pxIndex;                                 \
       (pxNewListItem)->pxPrevious = pxIndex->pxPrevious;                 \
                                                                          \
       pxIndex->pxPrevious->pxNext = (pxNewListItem);                     \
       pxIndex->pxPrevious = (pxNewListItem);                             \
                                                                          \
       (pxNewListItem)->pxContainer = (pxList);                           \
                                                                          \
       ((pxList)->uxNumberOfItems)++;                                     \
    }

//得到列表第一项
#define listGET_OWNER_OF_HEAD_ENTRY( pxList )            ( ( &( ( pxList )->xListEnd ) )->pxNext->pvOwner )

//检测列表项是否在列表里
#define listIS_CONTAINED_WITHIN( pxList, pxListItem )    ( ( ( pxListItem )->pxContainer == (pxList)) ? (pdTRUE) : (pdFALSE))

//得到列表项的容器对象
#define listLIST_ITEM_CONTAINER( pxListItem )            ( ( pxListItem )->pxContainer )

//检测列表的End节点是否设置为最大值
#define listLIST_IS_INITIALISED( pxList )                ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )

//初始化列表，列表在使用前必须被初始化
void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION;

//初始化列表项目，列表项目使用前也要初始化
void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION;

//往列表里插入列表项，按值排序
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsert( List_t * const pxList,ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;

//往列表结尾加入列表项元素
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsertEnd( List_t * const pxList,ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;

//把列表项从列表里面移除，返回列表数量
//pxItemToRemove:要异常的列表项
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) PRIVILEGED_FUNCTION;

//C++相关
#ifdef __cplusplus
    }
#endif

#endif

list.c的实现

/*列表作为FreeRTOS内核的基础数据结构，主要为进程调度量身定做的数据结构
  用列表存储就绪任务、延迟任务等。列表设计为双向指针的列表，移除插入元素
	比数组高效。任务调度时候频繁涉及到任务在就绪、延迟等列表中移动
*/

#include <stdlib.h>

/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
 * all the API functions to use the MPU wrappers.  That should only be done when
 * task.h is included from an application file. */
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE

#include "FreeRTOS.h"
#include "list.h"

/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
 * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be
 * defined for the header files above, but not in this file, in order to
 * generate the correct privileged Vs unprivileged linkage and placement. */
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE 


//初始化列表方法
//pxList:列表指针
void vListInitialise(List_t * const pxList)
{
	  //pxIndex指向xListEnd
    pxList->pxIndex = (ListItem_t * ) &( pxList->xListEnd); 

	  //设置结束元素的值为最大值
    pxList->xListEnd.xItemValue = portMAX_DELAY;

	  //结束元素的下一个元素指向自己
    pxList->xListEnd.pxNext = (ListItem_t *) &(pxList->xListEnd);    
    //结束元素的前一个元素也指向自己
		pxList->xListEnd.pxPrevious = (ListItem_t *) &( pxList->xListEnd);
		//设置列表元素数量为0
    pxList->uxNumberOfItems = (UBaseType_t) 0U;

    //写入固定值，检测用的位点，目前不关注
    listSET_LIST_INTEGRITY_CHECK_1_VALUE(pxList);
    listSET_LIST_INTEGRITY_CHECK_2_VALUE(pxList);
}

/*-----------------------------------------------------------*/
//初始化列表像
//pxItem:列表项常量指针
void vListInitialiseItem(ListItem_t * const pxItem)
{
	  //设置列表项所属为空指针，不属于任何列表
    pxItem->pxContainer = NULL;

    //写入固定值，检测用的位点，目前不关注
    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem);
    listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem);
}

/*-----------------------------------------------------------*/
//往列表结尾加入列表项元素
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsertEnd(List_t * const pxList,ListItem_t * const pxNewListItem)
{
	  //pxIndex指向放入常量
    ListItem_t * const pxIndex = pxList->pxIndex;

    //测试用的位点，目前不关注
    listTEST_LIST_INTEGRITY(pxList);
    listTEST_LIST_ITEM_INTEGRITY(pxNewListItem);

	  //新项目下一个元素指向xListEnd形成闭环
    pxNewListItem->pxNext = pxIndex;
	  //由于xListEnd的pxPrevious一直指向最后一个元素
	  //所以这个的意思就是新元素的前一个元素指向XList最后一个元素
    pxNewListItem->pxPrevious = pxIndex->pxPrevious;

    //测试用的位点，目前不关注
    mtCOVERAGE_TEST_DELAY();
    //当前最后一个元素的下一个元素知道新元素
    pxIndex->pxPrevious->pxNext = pxNewListItem;
		//xListEnd的pxPrevious重新执行新加的最后一个元素
    pxIndex->pxPrevious = pxNewListItem;

    //新项目的所属执行xList
    pxNewListItem->pxContainer = pxList;
		//XList的项目数加1
    (pxList->uxNumberOfItems)++;
}

/*-----------------------------------------------------------*/
//往列表里插入列表项，按值排序
//pxList:列表常量指针
//pxNewListItem:要插入的新列表项指针
void vListInsert(List_t * const pxList,ListItem_t * const pxNewListItem)
{
    ListItem_t * pxIterator;
	  //要插入的列表项的值
    const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;

    //测试用的位点，目前不关注
    listTEST_LIST_INTEGRITY(pxList);
    listTEST_LIST_ITEM_INTEGRITY(pxNewListItem);

		//按值大小排序插入新项目到列表里。如果有相同值的项目，那么放在相同值项目后面。确保TCB相同值共享CPU
    if(xValueOfInsertion == portMAX_DELAY)
    {
        pxIterator = pxList->xListEnd.pxPrevious;
    }
    else
    {
				//从xListEnd节点开始。一直找到值大于新插入项值的节点
        for( pxIterator = (ListItem_t *) &(pxList->xListEnd); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext) 
        {
            
        }
    }
    //新节点执行目标节点下一个节点
    pxNewListItem->pxNext = pxIterator->pxNext;
		//目标节点下一个节点的前一个节点指向新节点。这两步把新节点和目标节点下一个节点双向连好了
    pxNewListItem->pxNext->pxPrevious = pxNewListItem;
		//新节点前一个节点指向目标节点。
    pxNewListItem->pxPrevious = pxIterator;
		//前一个节点的下一个节点指向新节点。这两步把新节点和目标节点双向连好了
    pxIterator->pxNext = pxNewListItem;

    //新节点所属指向列表
    pxNewListItem->pxContainer = pxList;
		//列表数量加1
    (pxList->uxNumberOfItems)++;
}

/*-----------------------------------------------------------*/
//把列表项从列表里面移除，返回列表数量
//pxItemToRemove:要异常的列表项
UBaseType_t uxListRemove(ListItem_t * const pxItemToRemove)
{
	  //得到要移除列表项指向的列表指针
		List_t * const pxList = pxItemToRemove->pxContainer;
		//要移除列表项的后面节点的前一项指针指向要移除节点的前一个节点
    pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
	  //要移除列表项前一个节点的后一项指针指向要移除节点后一项
    pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;

    //测试用的位点，暂时不关注
    mtCOVERAGE_TEST_DELAY();

    //确保索引指向一个有效的项目
    if(pxList->pxIndex == pxItemToRemove)
    {
        pxList->pxIndex = pxItemToRemove->pxPrevious;
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
		//把要移除项的所属设置空指针，不属于任何列表
    pxItemToRemove->pxContainer = NULL;
		//列表数量减1
    (pxList->uxNumberOfItems)--;
		//返回列表数量
    return pxList->uxNumberOfItems;
}
/*-----------------------------------------------------------*/
小乌鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
xlist
sweetliteli的博客
08-15 3319
package a16.erin.unit14_xlist_http; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.support.v7.app.AppCompatActivity; import com.google.gson.Gso
FreeRtos源码库
01-19
FreeRTOS（Free Real-Time Operating System）是一个开源的嵌入式实时操作系统(RTOS)，它专为微控制器和其他资源受限的设备设计。FreeRTOS的核心是任务调度器，它管理多个并发执行的任务，确保了系统的实时性。这个...
XlistView view包
09-11
XListView 下拉刷新 上拉分页加载更多 布局文件 XListView中我们经常用的就是下拉刷新和上拉加载这两个功能，我们可以在此基础上进行扩展和自定义。它的实现原理也比较简单，在此也感谢这位大神给我们提供的这个开源的ListView，使我们在开发中节省了不少时间。 下面分别分析其下拉刷新与上拉加载的实现过程。
框架学习二：ListView的下拉刷新+上拉加载
热门推荐
mwj_88的专栏
09-10 3万+
一、XListView 1、下载 gitHub的地址。或者从这儿下。 2、用法
Xlist
zh15001187361的博客
08-23 3033
/** * @file XFooterView.java * @create Mar 31, 2012 9:33:43 PM * @author Maxwin * @description XListView's footer */ package com.example.day09_2; import android.content.Context; import android.
FreeRTOS（13）---FreeRTOS 列表和列表项
InfiniteYuan
10-11 1248
FreeRTOS 列表和列表项FreeRTOS 列表和列表项初始化列表初始化列表项将列表项插入到列表中，列表项所在的位置取决于列表项的列表项值（xItemValue）。将列表项插入到列表末端 FreeRTOS 列表和列表项 FreeRTOS内核调度大量使用了列表（list）和列表项（list item）数据结构。我们如果想一探FreeRTOS背后的运行机制，首先遇到的拦路虎就是列表和列表项。对于F...
FreeRTOS2022版本
04-12
FreeRTOS 是一个实时操作系统（RTOS）内核，专为微控制器和嵌入式系统设计，强调高效、小巧和可移植性。2022版本的发布带来了最新的改进和功能更新，旨在提供更好的性能和更多的兼容性。以下是 FreeRTOS 2022 版本中...
GD32F470 FreeRTOS
03-03
GD32F470 FreeRTOS 是一个基于FreeRTOS实时操作系统在GD32F470微控制器上的实现。FreeRTOS是一款轻量级、开源的实时操作系统，它为嵌入式系统提供了任务调度、时间管理、中断处理和内存管理等功能，以支持复杂的应用...
基于GD32F1x0手动编程实现简易FreeRtos之任务阻塞
04-17
FreeRTOS是一款轻量级、实时操作系统（RTOS），它为微控制器提供多任务调度、内存管理等核心功能。本主题将深入探讨如何在GD32F1x0上手动编程实现基于FreeRTOS的任务阻塞延时功能。 首先，理解任务阻塞是FreeRTOS中...
FreeRTOS移植模板
最新发布
04-19
FreeRTOS是一种轻量级、高效的实时操作系统（RTOS），主要用于嵌入式系统，尤其适用于资源有限的微控制器。Keil是一款广泛使用的嵌入式开发工具，它集成了编译器、调试器和IDE，使得开发者可以方便地进行C/C++代码...
FreeRTOS学习第一篇——FreeRTOS的列表和列表项
Eevey的博客
02-25 1201
声明：本文为博主的学习篇章，欢迎大家指错，共同学习 在FreeRTOS中最最最主要的部分就是任务，而任务创建的过程中会遇到有关于列表和列表项的问题，所有我首先要解决的就是列表和列表项的问题。 FreeRTOS中使用指针指向列表项。一个列表可能包含多个列表项，并且每个列表项都有一个指针指向列表。具体是什么样子如下图： 在FreeRTOS中的列表项有两张形式：xLIST_ITEM和xMINI_LIST_ITEM。xMINI_LIST_ITEM是xLIST_ITEM的迷你版。 struct xLIST_ITEM
【FreeRTOS】FreeRTOS 源码学习笔记 （4） 任务创建xTaskCreate + 常用结构体TCB、xLIST
YoYo的桃子树
04-19 1633
1. 引言 经过上一节移植，我们已经拿到了一个可以用的工程，接下来就可以单步跟踪了。 使用FreeRTOS，首先要新建一个任务，我们可以单步跟一下它的运行流程，在调试之前，还是要先把最重要的几个结构体整理一下。 （本文初版为2020.4.12，FreeRTOS的代码版本为FreeRTOS Kernel V10.3.1） 2. 重要结构体 2.1 TCB 做FreeRTOS肯定首先要把大名鼎鼎的TC...
Xlistview
S743835413的博客
08-26 467
适配器package com.guo.adapter;import java.util.List;import com.guo.activity.R; import com.guo.bean.DataBean; import com.guo.bean.ImageList; import com.guo.bean.LargeImageList; import com.nostra13.univ
xlistv
hongfuqiang的博客
09-13 264
package com.example.xlistviewlx; import android.os.Handler; import android.os.Message; import android.support.v4.widget.DrawerLayout; import android.support.v7.app.AppCompatActivity; import a
Xlist加载数据
Liquor2的博客
09-16 941
XListView的介绍和使用
forwardyzk的专栏
04-27 1万+
在开发的过程中，wo'm
Xlist的下拉刷新、上拉加载
Wang__Yk的博客
11-08 1016
XList主页面一些操作— package com.example.myapplication; import android.os.Bundle; import android.os.Handler; import android.support.v7.app.AppCompatActivity; import android.text.format.DateFormat; import com...
XListView 的使用及源码分析
Vitamin陈的专栏
11-05 1183
完事开头难，终于要开始写csdn上的第一篇博客了。其实之前在印象笔记里也写了一些，但是因为是只供自己记录，所以写的毕竟比较随意。写博客的话，还是希望对读者尽量表达的清楚，那对自己的要求也会高一些。好了废话不说，第一篇先从一个比较简单，但也很实用的XListView的使用及源码分析开始吧。 XListView 是Github上一个比较流行的下拉刷新的组件，虽然现在已经停止维护，但是在项目中用到了，
xlist下拉刷新
wyhskt的博客
08-18 607
package com.liulailin.day12_viewpager; import android.os.Handler; import android.os.Message; import android.support.v4.view.ViewPager; import android.support.v7.app.AppCompatActivity; import an
freertos组件之cjson库
09-29
它适用于嵌入式系统，特别是在FreeRTOS实时操作系统中使用。 cjson库是一个简单且易于使用的库，因此它在FreeRTOS中得到了广泛的应用。它提供了一组函数，可以将JSON字符串解析为一个C语言中的对象，或者将C语言...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小乌鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值