存储块的删除与状态查询

设计实现

• 存储块的删除（清空过程中可能有任务就绪，需执行一次调度）
• 存储块的状态查询（当前存储块的计数、允许的最大计数、每个存储块的大小、当前等待的任务计数）

tMemBlock.c

#include "tinyOS.h"

/* 存储块初始化函数 */
//参数：存储块，存储块分配空间的起始地址，存储块的大小，存储块的数量
void tMemBlockInit(tMemBlock *memBlock, uint8_t *memStart, uint32_t blockSize, uint32_t blockCnt)
{
uint8_t *memBlockStart = (uint8_t *)memStart;//存储空间的起始地址
uint8_t *memBlockEnd = memBlockStart + blockSize * blockCnt;//存储空间的结束地址

//对存储空间进行划分时，划分的每一个存储块的大小会作为链表的结点插入链表中，这个链表结点会占用存储块开始的一部分空间，所以要求blockSize不能小于结点大小
if(blockSize < sizeof(tNode))
{
return;
}

tEventInit(&memBlock->event, tEventTypeMemBlock);
memBlock->memStart = memStart;
memBlock->blockSize = blockSize;
memBlock->maxCount = blockCnt;

tListInit(&memBlock->blockList);//初始化存放存储块的链表
//从存储区的起始地址，依次划分各个存储块
while(memBlockStart < memBlockEnd)//从开始去找到尾部
{
tNodeInit((tNode *)memBlockStart);//对每一个存储块是要它最开始的存储区作为一个结点，进行初始化
tListAddLast(&memBlock->blockList, (tNode *)memBlockStart);//将存储块加到存储块链表中

memBlockStart += blockSize;//指针前移
}
}

/* 存储块获取函数 */
//参数：存储块，用于获取存储块时将存储块存入其中的指针，最大的等待计数
uint32_t tMemBlockWait(tMemBlock *memBlock, uint8_t **mem, uint32_t waitTicks)
{
uint32_t status = tTaskEnterCritical();

if(tListCount(&memBlock->blockList) > 0)//是否有空闲存储块
{
*mem = (uint8_t *)tListRemoveFirst(&memBlock->blockList);//从列表头部移出一个存储块
tTaskExitCritical(status);
return tErrorNoError;//返回没有错误
}
else
{
tEventWait(&memBlock->event, currentTask, (void *)0, tEventTypeMemBlock, waitTicks);//任务在事件控制块上等待
tTaskExitCritical(status);

tTaskSched();//切换到其他任务运行

*mem = currentTask->eventMsg;//取出分配到的存储块
return currentTask->waitEventResult;//返回等待结果
}
}

/* 存储块无等待获取函数 */
uint32_t tMemBlockWaitGet(tMemBlock *memBlock, void **mem)
{
uint32_t status = tTaskEnterCritical();

if(tListCount(&memBlock->blockList) > 0)
{
*mem = (uint8_t *)tListRemoveFirst(&memBlock->blockList);
tTaskExitCritical(status);
return tErrorNoError;
}
else
{
tTaskExitCritical(status);
return tErrorResourceUnavailable;//返回资源不可用
}
}

/* 存储块释放函数 */
void tMemBlockNotify(tMemBlock *memBlock, uint8_t *mem)
{
uint32_t status = tTaskEnterCritical();

if(tEventWaitCount(&memBlock->event) > 0)//是否有任务在事件控制块上等待
{
tTask *task = tEventWakeUp(&memBlock->event, (void *)mem, tErrorNoError);//移出一个任务
if(task->prio < currentTask->prio)//判断优先级
{
tTaskSched();
}
}
else
{
tListAddLast(&memBlock->blockList, (tNode *)mem);//将存储块插入空闲存储块列表
}
tTaskExitCritical(status);
}

/* 存储块状态查询函数 */
void tMemBlockGetInfo(tMemBlock *memBlock, tMemBlockInfo *info)
{
uint32_t status = tTaskEnterCritical();

info->count = tListCount(&memBlock->blockList);
info->maxCount = memBlock->maxCount;
info->blockSize = memBlock->blockSize;
info->taskCount = tEventWaitCount(&memBlock->event);

tTaskExitCritical(status);
}

/* 存储块删除函数 */
uint32_t tMemBlockDestroy(tMemBlock *memBlock)
{
uint32_t status = tTaskEnterCritical();
uint32_t count = tEventRemoveAll(&memBlock->event, (void *)0, tErrorDel);
tTaskExitCritical(status);

if(count > 0)//判断是否有任务就绪
{
tTaskSched();
}

return count;
}

tMemBlock.h

#ifndef __TMEMBOLCK_H
#define __TMEMBOLCK_H

#include "tEvent.h"

/* 存储块结构 */
typedef struct _tMemBlock
{
tEvent event;//事件控制块
void *memStart;//存储区的起始地址
uint32_t blockSize;//每个存储块的大小
uint32_t maxCount;//最大存储块数量
tList blockList;//存储块列表
}tMemBlock;

/* 存储块状态查询结构 */
typedef struct _tMemBlockInfo
{
uint32_t count;//当前存储块的计数
uint32_t maxCount;//允许的最大计数
uint32_t blockSize;//每个存储块的大小
uint32_t taskCount;//当前等待的任务计数
}tMemBlockInfo;

void tMemBlockInit(tMemBlock *memBlock, uint8_t *memStart, uint32_t blockSize, uint32_t blockCnt);
uint32_t tMemBlockWait(tMemBlock *memBlock, uint8_t **mem, uint32_t waitTicks);
uint32_t tMemBlockWaitGet(tMemBlock *memBlock, void **mem);
void tMemBlockNotify(tMemBlock *memBlock, uint8_t *mem);
void tMemBlockGetInfo(tMemBlock *memBlock, tMemBlockInfo *info);
uint32_t tMemBlockDestroy(tMemBlock *memBlock);

#endif

app.c

#include "tinyOS.h"
#include "string.h"

//定义任务，分别为它们配备独立的堆栈空间
tTask tTask1;
tTask tTask2;
tTask tTask3;
tTask tTask4;
tTaskStack task1Env[1024];
tTaskStack task2Env[1024];
tTaskStack task3Env[1024];
tTaskStack task4Env[1024];

uint8_t mem1[20][100];//20个存储块，每个块是100字节
tMemBlock memBlock1;

//定义任务要执行的功能
int task1Flag;
void task1Entry(void *param)
{
uint8_t *mem;
tMemBlockInfo info;

tSetSysTickPeriod(10);//初始化

tMemBlockInit(&memBlock1, (uint8_t *)mem1, 100, 20);
tMemBlockGetInfo(&memBlock1, &info);
for(int i = 0; i <20; i++)
{
tMemBlockWait(&memBlock1, (uint8_t **)&mem, 0);
}
tMemBlockWait(&memBlock1, (uint8_t **)&mem, 0);

for(;;)//任务里是for的死循环
{
task1Flag = 0; 
tTaskDelay(1);
task1Flag = 1;
tTaskDelay(1);
}
}

int task2Flag;
void task2Entry(void *param)
{
int destroy = 0;
for(;;)
{
task2Flag = 0;
tTaskDelay(1);
task2Flag = 1;
tTaskDelay(1);

if(!destroy)
{
tMemBlockDestroy(&memBlock1);
destroy = 1;
}
}
}
int task3Flag;
void task3Entry(void *param)
{
for(;;)
{
task3Flag = 0;
tTaskDelay(1);
task3Flag = 1;
tTaskDelay(1);
}
}
int task4Flag;
void task4Entry(void *param)
{
for(;;)
{
task4Flag = 0;
tTaskDelay(1);
task4Flag = 1;
tTaskDelay(1);
}
}

/* 应用任务初始化函数 */
void tInitApp(void)
{
//最后一个参数：传堆栈末端地址，因为堆栈是向下生长的，初始堆栈地址是堆栈空间最后一个单元地址的末端
tTaskInit(&tTask1, task1Entry, (void *)0x11111111, 0, &task1Env[1024]);
tTaskInit(&tTask2, task2Entry, (void *)0x22222222, 1, &task2Env[1024]);
tTaskInit(&tTask3, task3Entry, (void *)0x22222222, 1, &task3Env[1024]);
tTaskInit(&tTask4, task4Entry, (void *)0x22222222, 1, &task4Env[1024]);
}