一、內存分配：

1.1 申請一塊內存大小定義：

#define MEM_0_SIZE (8) //8字節(jié)

#define MEM_1_SIZE (16) //16字節(jié)

#define MEM_2_SIZE (32)

#define MEM_3_SIZE (64)

#define MEM_4_SIZE (128)

#define MEM_5_SIZE (256)

1.2 設定SIZE大小內存可申請到的內存塊最大個數定義：

#define MEM_0_COUNT (16) //最大16個內存塊

#define MEM_1_COUNT (16)

#define MEM_2_COUNT (32)

#define MEM_3_COUNT (32)

#define MEM_4_COUNT (32)

#define MEM_5_COUNT (16)

1.3 內存數組定義

static u8 g_8bytesmem[MEM_0_COUNT*MEM_0_SIZE];

static u8 g_16bytesmem[MEM_1_COUNT*MEM_1_SIZE];

static u8 g_32bytesmem[MEM_2_COUNT*MEM_2_SIZE];

static u8 g_64bytesmem[MEM_3_COUNT*MEM_3_SIZE];

static u8 g_128bytesmem[MEM_4_COUNT*MEM_4_SIZE];

static u8 g_256bytesmem[MEM_5_COUNT*MEM_5_SIZE];

1.4 內存管理結構體定義

typedef struct _mem_t

{

//控制標記

u32 flag;//每種內存最多32塊

/*每塊內存的大小*/

u16 size;

/*內存塊個數*/

u16 count;

/*內存開始指針*/

u8 *buf;

}mem_t;

1.5 內存分配設計思想：

　　我們設置動態(tài)內存分配的初衷在于：有些單片機系統內存資源比較少，便顯得特別珍貴，因此我們要實現內存的反復利用，好像就像一個池子一樣，我們要循環(huán)利用池子里的水資源。比如說洗澡時，如果是噴頭式的，這樣如果不去回收水便會浪費；而如果是在澡池子里洗澡，每次利用完水后，水資源便會重新回到池子，可循環(huán)的利用起來。我們設置動態(tài)內存分配也是這個原理，使用之前先去申請，使用結束后便釋放，下次便可繼續(xù)申請該內存，循環(huán)利用內存池里的資源。

我們先定義6個數組，各個數組大小為XXX_SIZE * XXX_COUNT，XXX_SIZE是每個內存塊大小，XXX_COUNT是內存塊的個數。將各數組的首地址賦給g_mem_mngt[i].buf（i：0-5）m_mngt[i].buf便分別指向每個數組的首地址。我們申請某一長度len的內存時，通過計算選定匹配的內存塊大小，然后從對應內存池首地址去查找空閑的內存塊，找到即停止查找，將該內存塊起始地址取出便為我們申請到的內存塊，申請到后將該地址標記，表示已被占用，下次不能再申請到。

釋放內存，首先根據內存節(jié)點所在的起始地址與各個內存池起始地址和結束地址，判斷內存節(jié)點所有所在的內存池，然后從該內存池首地址開始查找，定位該內存落在的內存塊控制區(qū)域，找到后則停止查找，并將該內存塊標記位清零，表示該內存塊已空閑，下次可申請使用。

1.6 各個內存塊初始化，申請的起始地址、內存塊個數、字節(jié)大小、標志位定義

void mem_init(void)

{

g_mem_mngt[0].buf = g_8bytesmem;

g_mem_mngt[0].count = MEM_0_COUNT;

g_mem_mngt[0].size = MEM_0_SIZE;

g_mem_mngt[0].flag = 0;

g_mem_mngt[1].buf = g_16bytesmem;

g_mem_mngt[1].count = MEM_1_COUNT;

g_mem_mngt[1].size = MEM_1_SIZE;

g_mem_mngt[1].flag = 0;

g_mem_mngt[2].buf = g_32bytesmem;

g_mem_mngt[2].count = MEM_2_COUNT;

g_mem_mngt[2].size = MEM_2_SIZE;

g_mem_mngt[2].flag = 0;

g_mem_mngt[3].buf = g_64bytesmem;

g_mem_mngt[3].count = MEM_3_COUNT;

g_mem_mngt[3].size = MEM_3_SIZE;

g_mem_mngt[3].flag = 0;

g_mem_mngt[4].buf = g_128bytesmem;

g_mem_mngt[4].count = MEM_4_COUNT;

g_mem_mngt[4].size = MEM_4_SIZE;

g_mem_mngt[4].flag = 0;

g_mem_mngt[5].buf = g_256bytesmem;

g_mem_mngt[5].count = MEM_5_COUNT;

g_mem_mngt[5].size = MEM_5_SIZE;

g_mem_mngt[5].flag = 0;

#ifdef MEM_DEBUG

memset(g_count, 0, sizeof(g_count));

#endif

#if CODE_REDUN

mem_fail = 0;

#endif

}

1.7 內存塊申請

　　查找可申請內存起始地址，返回值為內存塊起始地址。該類型函數有void * mem_alloc(u8 size)和void *mem_isr_alloc(u8 size)兩種函數定義，文章中只附加在非中斷模式下代碼。在非中斷模式下，申請內存塊之前要先關閉中斷，申請結束后再打開中斷通知將申請到的內存地址標志位置1，表示已申請，這樣做比較安全。在中斷模式下，不必做此操作，其他寫法都一致。

void * mem_alloc(u8 size)

{

u8 i, j;

mem_t * memptr = NULL;

u8 * ptr = NULL;

/*先找到內存適合的控制塊所在控制頭*/

for(i = 0; i < MEM_TYPE_COUNT; i++)

{

if(size <= g_mem_mngt[i].size)

{

memptr = &g_mem_mngt[i];

//找到空閑的控制塊

ptr = memptr->buf;

for(j = 0; j < memptr->count; j++, ptr += memptr->size)

{

__disable_irq();

if(!(memptr->flag & (1<

{

//標記占用

memptr->flag |= (1<

__enable_irq();

return ptr;

}

__enable_irq();

}

#ifdef MEM_DEBUG

//內存不足,記錄一下

MEM_STATIC_INC(i);

#endif

}

}

#if CODE_REDUN

mem_fail++;

#endif

return NULL;

}

1.8 內存的釋放

　　釋放內存，即將表示該內存的占有標志位清零，釋放后下次便可申請該內存。釋放內存函數分為void mem_free(void * ptr)和void mem_isr_free(void * ptr)兩種，一種是在非中斷模式下，一種是在中斷模式下。在非中斷模式下釋放之前應先關閉總中斷，防止被打斷，釋放結束后再打開總中斷。在中斷模式下則不必處理該操作。

void mem_free(void * ptr)

{

u8 i;

mem_t * memp = NULL;

u8 * optr = ptr;

u8 j;

u8 * p;

for(i = 0; i < MEM_TYPE_COUNT; i++)

{

memp = &g_mem_mngt[i];

//定位該內存指針落在哪個控制區(qū)域

if(optr >= memp->buf && optr < memp->buf + memp->size*memp->count)

{

for(p = memp->buf, j=0; j < memp->count; p += memp->size, j++)

{

if((optr >= p) && (optr < p + memp->size))

{

__disable_irq();

memp->flag &= ~(1<

#if PRINTF_ON

stmprintf("free size:%d,j:%drn",memp->size, j);

#endif

__enable_irq();

return;

}

}

}

}

}

二、任務調度

/*鏈表的定義,list_head g_idlelist表示空閑可用任務節(jié)點鏈表，list_head g_runlist表示即將使用的任務節(jié)點鏈表。*/

static struct list_head g_runlist;

static struct list_head g_idlelist;

/*任務節(jié)點*/

typedef struct node

{

struct list_head next; //雙向鏈表定義

handle callback; //任務操作函數指針

u8 *para; //任務操作函數參數

u8 flag; //,標志字段，當前用來表示任務優(yōu)先級

}task_node_t; //任務節(jié)點

/*任務優(yōu)先級*/

#define PRIO_HIGH (0x1) //優(yōu)先級最高

#define PRIO_NORMAL (0x2) //次優(yōu)先級

#define PRIO_LOW (0x4) //最低優(yōu)先級

2.1 任務調度，該算法思想為：

分別建立g_idlelist和g_runlist兩個雙向鏈表，在任務初始化時，為各個任務控制塊節(jié)點申請內存，將各個任務節(jié)點掛載到g_idlelist鏈表上，表示目前空閑可用的任務節(jié)點，當有我們要申請任務時，要從鏈表g_idlelist上取下任務節(jié)點，同時將節(jié)點掛載到g_runlist鏈表上，表示即將使用的任務節(jié)點，掛載時是有優(yōu)先級的，當g_runlist為空鏈表時，我們直接掛載上去，當g_runlist不為空鏈表時，便要考慮優(yōu)先級的問題，任務優(yōu)先級高的任務節(jié)點掛載在最前面。然后按照優(yōu)先級順序執(zhí)行對應的任務，等任務執(zhí)行結束后將任務節(jié)點又掛載到g_idlelist鏈表最后面。等待下次的調用。

2.2 任務節(jié)點初始化，為任務節(jié)點申請內存，并將任務節(jié)點掛載到g_idlelist鏈表上，表示未使用的任務節(jié)點。

void task_queue_init(void)

{

u8 i;

task_node_t * task;

list_init_head(&g_runlist);

list_init_head(&g_idlelist);

for(i =