ucosII实验报告

实验1《任务得创建、删除、挂起、恢复》

实验学时: ２ 实验地点： 二综x203 实验日期: 2013/12/1３ 一、实验目得

１.实验环境得建立 2.任务得接口函数得应用 二、实验内容

1.设计一个只有一个任务Task1,当程序运行后任务得工作就就是每秒在显示器上显示一个字符“M”。

２． 在任务Taｓk1中在创建一个任务Taｓk2 。当程序运行后,任务Task1得工作在显示器上显示一个字符“M”;Tasｋ2 则就是在显示器上显示字符 “Y”。

3、 要求任务Tａsk2运行20次后，挂起任务Task1;任务Tasｋ2运行４0次后,恢复任务Task1。

4、 当任务Task1运行5次时，用函数OSSchedＬｏｃk()对调度器进行加锁;而当任务Ｔaｓk1运行到第10次时,再用函数ＯＳSchedＵnｌoｃk()对调度器进行解锁,并运行该程序。

5、 使任务Task１能删除任务Tasｋ２。 三、实验方法

包括实验方法、原理、技术、方案等。 四、实验步骤

1.将BC45文件夹拷贝到C分区根目录下。

2.将sofｔｗaｒe文件夹拷贝到任意分区根目录下。 3、 分别完成实验1、2、3、4、５ 五、实验结果

1、 DOS窗口每秒显示一个字符“Ｍ”。每行显示10个“M”字符,行与行得间隔就是一行。按ESＣ键程序退出

２、 DOS窗口交替显示字符＂Ｍ\"与“Y”,每隔一秒显示一次。每行显示10个字符，行与行之间得间隔就是一行。 按ＥSC键程序退出

3.DＯS窗口开始交替显示字符\"Ｍ\"与“Y”,显示２０次以后，Taｓｋ1挂起，只显示“Y”,当Tａsk2运行40次以后,Task1恢复,然后开始Ｔａsk1,Taｓk2交替运行。

4.DＯS窗口开始交题显示字符\"Ｍ\"与“Ｙ”,显示5次以后,Task1将任务调度器上锁,此时只有“Ｍ”打印,当Tａsk1运行10次后,Tａｓk1，Ｔaｓｋ２开始交替运行。

5.DＯS窗口开始交替显示字符“M”与“Y”,显示１0次后,只显示“Ｙ” 六、实验结论

对实验数据与结果进行分析描述,给出实验取得得成果与结论。

1、 程序:＊***＊

＊

ｃiｓe 2 - 1

* author: csu cheｎａn

* time: ２０1３ － 12 － 12 ＊*******／

#iｎclude \"iｎｃｌudes、h＂

＃defiｎe TASK_ＳTK_SIZE 2５６

OＳ_STK MyTasｋSｔk[TASK_ＳTK_SＩZE］; ＩNT16Ｓ keｙ;

INＴ8U ｘ = ０, y ＝ 0; void MyTask(void *pdata)｛

#if OＳ＿ＣRIＴＩＣAL_METHOD == 3 ﻩ ﻩ ﻩ

ＯS_CＰU_SR ﻩcpu_ｓr; pdata = pdａtａ;

ＯS＿ENTER_CRＩTICAL(); PC＿VｅctSet(0X08, OＳTicｋISR);

PＣ＿SetTiｃkRate（OS_TICKS_ＰＥR_ＳEC)； OS_EXIT＿CRITICAL（）; for(；;){

if(x > 1０){ ｘ ＝ 0; }

PC＿ＤispChar(x, y, *(ｃhar*)pｄａta,,DＩＳＰ_BGND_BLACK ＋ ＤISＰ_F

#ｅｎdｉf

Exeｒ／***

ﻩＯＳＳtatＩｎｉｔ()；

ﻩﻩｙ = y ＋ 2;

ＧNＤ_ＷHITＥ)；

x = ｘ + 1； ﻩ ﻩ ﻩ} }

ｉf(ＰC_ＧetKｅy(&kｅｙ) ＝= 1){ if（keｙ ＝= 0x１B)｛ ﻩPC＿DＯSRｅｔurn(); }

ﻩﻩOSＴimeＤｌyHMＳM（0,0,1,0);

｝

vｏｉｄ ｍaｉn（void){

cｈａr * ch = ＂M＂; PC_DOSSaveRetｕｒｎ();

PC_DiｓpClrScr(ＤＩＳP＿ＦGND_WHITE ＋ DISＰ_BGＮD＿ＢＬAＣK）; ﻩＯSIｎｉt();

ﻩPC_VｅｃtＳｅt(uCOS, OSCｔxＳw);

ﻩOSTａｓkＣreａte(MｙTａsk, ｃh, &MyＴaskSｔk[ＴＡＳK_STK_SＩZE-１], ０）; ﻩOSStａrt(); } ２、

程序源代码： /*******＊ * Exeｒcｉse 2 - 2 * autｈor: ｃsu ｃheｎan * tｉme: ２０１３ - 12 - 1３ ＊*＊＊****／

#iｎｃlude \"ｉnclｕｄes、h＂

#defｉne Ｍｙ_ＴASK1_STＫ_SIZE 256 ＃dｅｆine My_TAＳK2_STK_SIZE 2５6

OS_STK MyTask1Stk[My＿TAＳK1_SＴK_ＳＩＺE］； ＯS_STK MｙＴask2Sｔk[Ｍｙ_TAＳK２_ＳTＫ_SIＺE］; INＴ16Ｓ ｋeｙ；

ＩNT8U ｘ = ０， y = 0； void ＭyＴａｓk２(voｉd ＊pdata)｛ #if OS＿CRIＴICＡL_ＭETHOD ＝＝ 3 ﻩOＳ＿ＣＰU_ＳR cｐｕ＿sr;

#endif ﻩ ﻩ

ｐdata = pdata；

OS＿ENTER＿CRITICAＬ（)； ＰＣ_VecｔSet(0x80， OSTiｃkISR); OＳ_EXIT＿CRITIＣAＬ(); if(x > 1０){ ﻩ ﻩ ﻩ｝

PC_DispChar(x, y， ＊（char*)pdata, ＤＩSP_ＢＧＮD_BLACK ＋ DISP_FＧN

x = ０;

ｙ = y + ２；

ﻩPC_SｅｔTickRａtｅ(ＯS_TICKS_PER_SＥＣ)； ﻩfor(;；){

Ｄ＿WHＩＴE)；

ﻩﻩｘ = x + 1; ﻩﻩ ﻩ} }

voiｄ ＭyＴasｋ1(void *pdaｔａ）｛ #if OS＿CRITICAL＿MEＴHOＤ =＝ 3 ﻩＯS_CＰU_SＲ cｐｕ＿ｓr; #endｉf

ﻩchar *cｈ = \"Y\"; ﻩpdａtａ = ｐdatａ;

OＳ_EＮTER_CＲITIＣAＬ()； ﻩＰＣ_VecｔSet(0Ｘ08, ＯＳTickＩSＲ）; ﻩPＣ_SeｔTｉckＲate（OS_TIＣＫS_PER＿SEC）; 1], 1);

ｆor(;;）｛

ｘ = 0;

ﻩﻩif（x > １0){

OS_ＥXIT_ＣＲＩTICAL（); ＯSＳtatＩnｉt();

ﻩiｆ(PC_GｅtＫey（&keｙ) ＝＝ 1）{ ﻩ } ﻩ}

ﻩiｆ(key ＝= 0x1B){ ﻩＰC_DＯＳReｔurn(）;

ﻩﻩOＳＴimｅDlyHＭSM(0,0，1,0);

ﻩＯＳTaskCｒeaｔe(MyTasｋ２， ｃｈ, &MyTaｓk2Ｓtk[Ｍy＿TAＳK2＿STK_SＩZE -

ﻩﻩﻩy ＝ y ＋ ２; ﻩﻩ} ﻩ }

vｏid maｉn(voｉd）{ 0);

｝ 3、

OSStart()； cｈar * ch = \"M\"；

PC_DＯSSaveRｅｔｕrn（）;

PC_VｅctSｅt(uＣＯＳ, OＳCtxＳw）;

ＰC_ＤiｓｐClrSｃr（DIＳＰ_FＧND_WHITE + ＤＩＳＰ＿BGND_BLＡCK）; ﻩOSＩｎit（)；

ＰＣ_DiｓｐChar(x, y, ＊(ｃhar*）pdata, DISP_BＧND_BLAＣK ＋ DＩ

SP_FGNＤ_WHＩＴE);

ﻩｘ ＝ ｘ + 1; ﻩ}

ﻩOSTiｍｅDlyHＭSＭ(０,０,１,0); }

ｉf（PC_GｅｔＫｅy（＆keｙ) == 1)｛ ﻩ}

PC_ＤOＳReturn(）；

ﻩﻩif(ｋey ＝= 0x1B){

ﻩＯSTaｓkCreａtｅ（ＭyTａｓk1, cｈ, ＆MyTask1Ｓｔk[My_TＡSＫ1＿SＴK_ＳIZE-1],

程序: ／******** * Eｘeｒcise 2 - ３ * auｔhｏr： csu chenａn ＊ time: 2０13 - １２ － 13

**＊****＊/

＃iｎclｕｄe \"ｉnclｕdes、ｈ＂

#dｅｆine Ｍy_ＴＡSＫ1_STK_ＳＩZE 256 #defiｎe My_TＡSK2＿SＴＫ_SIZＥ 25６ OS_STK MyTaｓk1Ｓtk[Ｍy_TASK1_ＳTK_SIZE]; ＯＳ_STK ＭｙTask2Stk[My_TＡＳK2_ＳTK_SＩZＥ］; ＩＮT16S keｙ; ＩNT8Ｕ x = 0, ｙ = 0; INT1６U cnt = 0;

ｖｏid MｙＴａｓｋ2(void *pdata){ ＃if OＳ_ＣRＩTICＡL＿METHOD == 3 ﻩOS_CＰU_ＳＲ ｃｐｕ_sr; #endif

pdata = pｄata; ﻩｆｏｒ(;;）{ cnt += 1; ﻩﻩif（cnt =＝ 2０){

ＯSTaｓkSusｐeｎd（0)； ﻩ ﻩ ﻩ ﻩﻩﻩ} ﻩ ﻩ} ｝

void MyTasｋ1（void *pdata）｛

ﻩ}

OSTimｅＤlyHMSM（０,0,１,0）;

}

ﻩiｆ(cnｔ == 40){

}

OSＴaskReｓｕmｅ(0);

if(ｘ ＞ 1０){ ﻩﻩｘ ＝ ０; ﻩﻩｙ = y + 2; }

PC_DispChaｒ(x, y， *(cｈaｒ*)pｄata, DISP_ＢGNＤ_BＬＡＣK + DIＳＰ_FG ﻩ

x = x + １；

ｉｆ(PＣ_GetKey（&key) == 1){

if(kｅy ＝= 0x1Ｂ){ PC_ＤOSReｔｕｒn(）;

ＮD_WHITE);

ｃhaｒ ＊ ch2 = \"Y\";

＃ｉf ＯS_ＣRＩTＩCAL_MEＴＨＯD == ３

OS_ＣPU_SR ﻩｃpｕ_sr; #eｎdif ﻩpdata = pｄatａ; ﻩ ﻩﻩ ﻩ ﻩ ﻩ ﻩﻩ ﻩ ﻩﻩ} }

void main(vｏid）{ ﻩchar * ch = \"M\";

OSIniｔ();

ﻩPＣ_DOＳSaveRetｕｒn（);

ﻩＰC＿ＶeｃtSｅｔ（uＣＯS, OSCtxＳw); ０）；

OSStart();

PC＿DｉｓpClｒSｃr（ＤISP_ＦGND＿WＨIＴE ＋ ＤＩＳP＿BＧNＤ＿ＯSTasｋＣreate(ＭyTask１， ch, &MｙTask1Ｓtk［Mｙ_TＡＳＫ1_STK_SIZE-1],

BLACK);

ﻩcnt ＋+; }

ＯSＴｉmeDｌyHMSＭ(0,0,1,0)； OＳ_ＥNＴER_CRITICＡL()； PC＿VectSet（0Ｘ08, OＳTiｃkISR）； OＳ_EXIＴ＿CRＩTＩCAL(); OSＳtａtIｎit（);

OSTaskCreaｔe(ＭyTask2， ch2, &MyTａsk2Stｋ[My_TAＳK2_STK_ＳIZE-1］, 1);

if（x ＞ 10){ x = 0; }

ﻩPＣ_SeｔTickRate（OS_ＴIＣKS_PＥR_SEC);

ﻩfor(；;)｛

y = y + 2;

PＣ_DispＣｈar(x, y, *(ｃhaｒ*）pdaｔａ, DＩSP_BGNＤ_BLAＣK ＋ ﻩx = ｘ + 1；

if(PC_GetＫｅy（＆key) ＝= 1）{ ﻩif（keｙ == 0x1B){

ＰC_DＯＳReturn（)； ｝

DISP_FGND_WＨIＴE）；

｝ 4、

程序: /**＊*＊**＊

＊ Exｅrcｉse 2 － ３ * autｈor: csu ｃｈenan * ｔiｍｅ: 20１3 - 12 - 13 ＊*＊**＊*＊/

#iｎｃludｅ \"incｌudes、h\"

#ｄefine My_TASK1_SＴＫ_SIＺE 256 #deｆｉnｅ My_TAＳK２_STK＿SIZE 25６

OS＿STK MyTask1Stk[Ｍｙ_ＴASK1_ＳＴK_SＩZＥ]; OS_STK ＭｙＴasｋ2Ｓｔk[My_ＴASＫ2_STK_SIＺＥ]; ＩNＴ１6S kｅy； INT8Ｕ x = 0, y = 0; IＮT１6U cnｔ = 0;

ｖｏiｄ MyＴａsk2(vｏid ＊pdaｔa){ ＃ｉf OS_ＣRＩTＩCAＬ＿MＥＴHＯＤ == 3 ﻩOS_CPＵ_ＳR cpｕ＿ｓr； ＃eｎdif pdata = pdatａ; ﻩｆor(;；)｛

ｉf(x > １0){

ﻩﻩﻩx = 0;

ﻩ y = y + 2； ﻩ }

PC＿DisｐChａｒ(x, y, *(ｃhａｒ*)ｐｄata, DISP_BGND_ＢＬAＣK Ｐ_FGND_WHＩＴE);

ﻩﻩx ＝ x + １; if（ＰC＿GetＫｅy(&keｙ) ＝＝ 1){ ﻩｉf(kｅy =＝ 0x1B）｛

PC_DOSＲetｕrn()；

ﻩﻩﻩ｝ ﻩﻩ｝

ＯSＴimeＤlyＨMSM(0，0,1,0）;

ﻩ｝

}

+ DIS

voiｄ MyTaｓk１（void *pdata)｛ char ＊ ch2 = \"Y\"； #if OＳ＿CRＩTＩCＡL_METHOD == 3 ﻩOS＿CPＵ_ＳR #ｅndｉf

pｄａｔa = pｄａtａ; OS_ENTER＿CRＩＴＩCAL();

PＣ＿SetTｉcｋRａte(OS_TICKS_ＰER_SEC); OSＳtatInit(）;

ＯSTaｓｋCｒeａtｅ(MyTasｋ2, cｈ2, ＆MyTａsk2Ｓｔk[My＿TAＳK２_ＳTK_S

ｃｐu_sr;

ﻩPC_VeｃtSeｔ(０X08, ＯＳＴｉｃkISR); ﻩＯS_ＥＸIT_CRITIＣAＬ（);

ＩZE-1], １)；

ﻩfor(；；）{

cｎt = ｃnt + 1； if(ｃｎt == 5）｛ OSSchｅdＬock()； }

ｅlse ｉf（cｎｔ=＝１0）{ OSSchedUnlocｋ(); ｝

if(x ＞ 1０){ ﻩ x ＝ 0； ﻩ ｙ = y + 2;

ﻩﻩ}

ﻩﻩPC_DispChar（x, ｙ, *（cｈar*)ｐdaｔa， DISP_BGND_BＬＡＣＫ + ＤISP＿FGＮD＿WＨＩTE);

ﻩ x = x ＋ 1; ﻩ} }

void mａｉn(voiｄ){ ﻩchar ＊ ch = \"Ｍ＂；

ﻩiｆ(PC_GetＫeｙ(&key) =＝ １)｛ ﻩﻩif(kｅy ＝= 0ｘ1Ｂ){ ﻩ}

ＯSＴimｅDlｙHMSＭ(0,0,1,0)； ﻩ ＰC＿DOＳＲeｔurn(); }

ﻩ

０);

OSInit(）；

PC_DOＳSavｅReturｎ(）; PＣ_ＶeｃtSet(uCOS, OSＣtxSw）;

PＣ_DiｓpClｒScr(DISＰ_FGND_WHITE + DＩSP＿BGND_ＢLACＫ);

OSTaｓｋCｒeate（MyTask1, cｈ, ＆ＭyＴaｓｋ1Stｋ[My_TＡSK1_ＳTK_SIZE-1],

ﻩOSＳtａrｔ(); ｝ 5、

程序代码如下: ／*＊＊**＊＊* * Ｅｘeｒcise 2 - ３ * autｈor： ｃｓu chenan ＊ timｅ: 2０１３ - １2 - 1３ *＊******/

#include ＂ｉｎcｌｕdes、ｈ\"

#define Ｍy_ＴASK1_STK_SIZE 256 #ｄｅfｉｎｅ My_ＴASＫ2_STK＿ＳIZE 25６ OＳ_STK MyTａｓk1Stk[My_TASK１_STK_SIZE]; OS_ＳTK ＭｙTaｓk2Ｓtk[My_TＡSＫ2_STK_SＩZＥ]; ＩＮＴ16S kｅy；

ＩNT8Ｕ ｘ = 0, y = 0； ＩNT1６Ｕ ｃnｔ = 0；

voiｄ MyＴaｓk2(voｉｄ ＊ｐdaｔa){ ＃if ＯS＿ＣRＩTＩＣAＬ_ＭＥTHOD ＝= 3

OＳ＿CＰＵ＿SR cpｕ_ｓr; #endif

ﻩpdaｔａ = pdａta; ﻩfor(；;){

iｆ(OSＴaskDelＲeq(OS＿PRIO_ＳELＦ） == OＳ＿TASK_DEL_REＱ){ ＯＳTａskDel(ＯS_PRＩO_SEＬF); ｂreaｋ; }

iｆ(x > 1０){

ﻩﻩﻩx = 0； ﻩ ﻩｙ = y ＋ 2;

ﻩ}

ﻩﻩPＣ_DispCｈar（x, y, *(chaｒ*)ｐdａtａ, DISＰ＿BＧＮＤ_BＬACＫ ＋ DＩSP_ＦＧND_WＨIＴE);

ﻩﻩx ＝ x + 1;

ﻩﻩiｆ（PＣ＿ＧeｔＫｅy(&kｅy） =＝ 1)｛ ﻩﻩ ﻩﻩ }

voｉd MｙTask1（void ＊ｐdaｔａ）{ ｃhａｒ * ｃｈ2 = \"Y＂； ＃if OＳ＿CＲIＴICAL＿METHOD == 3 ﻩOS_ＣＰＵ_SR ﻩcpu_sr; #endif

ﻩｐdatａ = ｐdａｔa； ﻩＯS_EＮTER_ＣRITＩCAL();

ﻩPC_ＶectSeｔ（0Ｘ08, OSTiｃkISR); ﻩPC_SｅtTickRatｅ（ＯS_TICKS_PER＿SEC);

ＯＳ_EXＩT_CＲITＩCＡL();

ＯＳTaskCreate(MyTask2， ｃh2, &MyTask2Stk[My_TASK2_SＴK_SIＺE-1], 1); ﻩOSStaｔＩｎｉｔ(); ﻩｆoｒ(;;){

ｃnt ＝ cｎt + 1; iｆ(ｃｎt =＝ １0）{

wｈile(ＯSTaskDelReｑ(0) != OS_ＴASK＿ＮOT_EXＩＳT)｛ ＯＳTｉmeDｌｙ（１); } }

}

if(key == 0ｘ1Ｂ){ ﻩPC_ＤＯSＲeturn(）; }

ﻩﻩﻩ｝

ﻩﻩOSTimeDlyHMSＭ(０,0，1,0）;

ﻩﻩif(ｘ > 10){

ﻩ}

ﻩｘ = 0; ﻩﻩy ＝ ｙ + ２；

ﻩﻩPC_DiｓpChar(x, y, *（char*)ｐdatａ， ＤISＰ_BＧND_BLＡＣK + ＤＩSP_FＧND_WＨITＥ）;

ﻩx = x + 1;

ﻩﻩif（kｅｙ ＝= 0ｘ1B）{

}

ﻩﻩif(PC_GeｔKey(&key) == １){ ﻩﻩﻩﻩPＣ_DOＳReｔｕrｎ（); ﻩ ﻩﻩ}

ﻩﻩOSTiｍｅDlyＨMSM(0,0,1，0); ﻩ｝ }

ｖoid ｍaｉｎ(void){

chａr * cｈ = \"M\"; ﻩＯSInit（)；

ﻩPＣ_ＤOSＳaｖeRetｕｒn(); ﻩＰＣ_VｅcｔSｅｔ(uCOS, OSCtxSw); ０);

}

注:有程序得要求附上程序源代码,有图表得要有截图并有相应得文字说明与分析 七、实验小结

给出本次实验得体会,如学会了什么，遇到哪些问题,如何解决这些问题，存在哪些有待改进得地方。

OＳStart(）;

ＰC_DispClrＳcr（DＩSP＿ＦGND_WHＩＴＥ + DISP＿BＧNＤ_BLACK）;

ﻩOＳＴaskCreａte(MyTask1, ch, &MyTasｋ１Sｔk［My_TAＳＫ1_STK_SIZＥ－1]，

实验２《时钟节拍及时间管理函数》

实验学时： ２ 实验地点: 综合实验楼ｘ２01 实验日期: 2０1３/１2/15 一、实验目得

１.实验环境得建立

2．多任务环境下中断机制及时间ＡPI得应用 二、实验内容

1.在OS＿CＰU＿C、C文件中按如下代码定义函数ＯSTimeTicｋHｏok(),然后运行并查瞧运行结果。实现显示系统在每发生5０0次时钟中断期间,调度器进行任务调度得次数。

2、设计一个有3个任务得应用程序。这3个任务分别就是：ＭyＴask、YoｕTａsk、与ＩnterTaｓk。其中任务IｎterTaｓk就是在时钟节拍中断服务程序中用钩子函数ＯSTｉmeTickHook()中断了10000次时使用一个信号变量InteｒKey激活得。运行并分析由中断服务程序激活任务得工作特点。

3、 设计一个应用,在任务MyTａｓｋ中调用函数ＯＳTimeDlyRｅｓｕme()取消任务ＹoｕＴasｋ得延时。为了观察任务ＹoｕTask得延时时间得变化,在钩子函数OSTimｅTickHｏｏk()输出了任务YouTasｋ在延时时间到时得时钟节拍数。

4、 设计一个应用程序，在任务中调用OSTｉmｅＧet()函数获得并显示系统得时钟节拍数OSTime。当任务运行10s时,调用函数ＯSＴimeSｅt（）将OSTｉｍｅ得值设为10。

5、 在ＫＥＩＬ模拟开发环境下,将顺序执行得程序改为多任务运行，并跟踪程序或设置断点观察多任务系统执行流程。 三、实验方法

包括实验方法、原理、技术、方案等。 四、实验步骤

1.将ＢC45文件夹拷贝到C分区根目录下。 2.将software文件夹拷贝到任意分区根目录下。 3、 安装KＥIL2集成开发环境。 4、 分别完成实验１、2、3、４、5 五、实验结果

记录实验输出数据与结果。 1、 2、

3、

４、 5、

六、实验结论

对实验数据与结果进行分析描述，给出实验取得得成果与结论。 1、 OS_CPU＿C、ｃ

＃ｉf ＯＳ_CPＵ＿ＨOOＫS＿EＮ ＞ 0

IＮＴ16U ｄ=0; INT1６U ｄ1=０;

voiｄ ＯSTｉｍeTｉckHｏoｋ (vｏid) ｛

ｃhar* s0 = \"500\"; char* s1 = \"Peｒ＂；ﻩ

ｃｈaｒ＊ s２ ＝ ＂Tiｍｅs Inｔerｒupt Aｔtempeｒ Tｉmeｓ\"; ｃhar s[８]； if(d == 500) { ﻩ ﻩ

PC_DispＳｔr(14,4,s1，DＩSP_BGＮD_ＢLＡCK+DISP＿FGＮD_ＷＨITE); PＣ_DｉｓpSｔr(２2，4,s2,DISＰ_ＢGＮD＿BLACＫ＋DIＳP_FGND＿WHITE)；

sprintf(s,＂％ｄ\；

PC＿DｉspStr(31，ｄ1+５,s，DＩSP_BGND＿BLACK+DIＳP_FGNＤ_WHＩTE);

ﻩﻩＰC_DｉspStr(18,4,s０,DISP_BGND_BLACＫ＋DIＳP_ＦＧＮD_ＷＨIＴＥ)；

ﻩﻩｄ ＝ 0;

ﻩｄ1 += 1； } d += 1； ｝ #endif

＃inｃｌuｄe \"inclｕdes、h\"

#definｅ TＡSＫ_STK_SIZE 51２ OS_STK MｙTaｓkＳtk［TASK_STK_SＩＺＥ]; INT16S ﻩ ｋｅy; ＩNT8Ｕ ｘ=0,y＝0;ﻩ

ｖoiｄ ＭｙＴask（ｖoiｄ *ｄata); void mａin (void) ｛

cｈａr＊ s_Ｍ=＂M＂;

OＳInit(）; ／* Ｉｎitｉalize uC/OS-II *／

P

Ｃ

_D

Ｏ

Ｓ

Ｓ

a

ｖ

eR

ｅ

turn(

/＊ Savｅ ｅnvirｏnment to retuｒｎ to DＯS */

PC_ＶeｃtSeｔ(uＣOS, ＯSCｔxＳｗ); ／* Install ｕC/OS-ＩI＇s coｎｔext switch ｖecｔor ＊／

ＰC_DispClｒSｃｒ(DISP_FGＮD_WHＩTE + ＤIＳP_BGＮD_ＢLACK);

OSTaskCreａtｅ（MyTaｓｋ,ｓ_M， &MyTaskStｋ[TＡＳＫ_STK＿SIZE － 1], 0）;

）；

OSStarｔ(); ／* Start multｉtaｓking */ }

void ＭyTask（void *pdatａ) { #i

ｆ

OS_CRITICAL_

Ｍ

Ｅ

T

Ｈ

O

Ｄ

==

３

/* Allｏｃaｔe sｔorａｇe ｆoｒ ＣPＵ staｔus ｒegｉster */ OS_CPU_SR cpｕ_ｓr； #ｅndif

ｐｄata = pdata; /* Preｖeｎt ｐilｅｒ warning */ ＯS_ENTER＿ＣRIＴICAL();

PC＿VectSet(0x08， OSTiｃkISR); ＰC_SetTickＲaｔe（ＯS＿ＴIＣKS_PER＿SEC); OS＿ＥXIＴ_CRITICAL();

ＯＳStaｔIｎit(); for (;;) { ﻩif(x>1０) ﻩ}

PC_DｉspChar（x,ｙ,*(cｈaｒ*)pｄata,DISP＿BGNＤ_ＢＬAＣK＋DISＰ_FGＮx+=１;

D_WHITE)；

ﻩif（PC_GｅｔＫey(&keｙ) =＝ 1) {

ﻩﻩif（key == 0x1B） ﻩﻩ{ ﻩ} } }

2、程序:ＯS＿COPU＿C、c #iｆ OS＿CPU_HOOKS_EＮ > 0

OＳＴｉmｅDlyHＭＳＭ（０,0,1,0); ﻩ}

PC_ＤOSReturn()；

{

y+＝2;

ﻩﻩx＝0;

ｅxtern BOOLEＡN InterKeｙ; INＴ16Ｕ InｔerCｔr = 0;

void ＯSＴimeＴiｃkＨｏok (vｏｉd) ｛

iｆ(InteｒCｔr =＝ 100００) ｛

ＩｎｔerKｅy = １; }

ＩnterCｔr++; } ＃eｎdif Tｅsｔ、c

#inclｕde \"incｌudes、ｈ＂

#ｄefｉne ＴASＫ_ＳTK_ＳIZE ５12ﻩ ﻩ

//任务堆栈长度

OS_STK MｙTａskStk[TASK_STK＿SＩZＥ];ﻩﻩﻩ//定义任务堆栈区 ＯＳ_SＴK YouTasｋStｋ[TＡSＫ＿STK_SIZE］；ﻩ ﻩ//定义任务堆栈区 OS_STK InｔerTaｓkStk［TASK_STK＿SIZＥ］;ﻩ IＮT16S key; INT８U ｘ=0,y=0;

ﻩﻩ

ﻩ

/／字符显示位置

ﻩ／／声明任务

ﻩ//定义任务堆栈区

／/用于退出ｕCOS_II得键

BOOLEAN InterKｅy＝ＦＡLSＥ; voiｄ MｙTasｋ(vｏｉｄ *daｔａ）;

void ＹouTａsｋ(vｏｉd *dａta）;ﻩﻩ ﻩ／／声明任务 void IｎｔｅrＴasｋ(void ＊data); ﻩﻩﻩ//声明任务 void main (void) {

chａr* ｓ＿M=\"M\";ﻩﻩ OSＩnｉt（ )； ﻩ

//定义要显示得字符

ﻩﻩ//初始化uＣＯS_II

/／安装ｕCＯS＿II中断

ＰC_DOSSaｖeRetuｒn( )；ﻩﻩ ﻩ//保存Dos环境 PC_VｅctSeｔ(uＣOＳ， OSCtxSw); ﻩﻩ ＯSTasｋCreate( ﻩ

ﻩMｙTasｋ, s_M,

/／创建任务ＭyTask

//设置任务堆栈栈顶指针

ﻩ//给任务传递参数

PC_DiｓｐCｌrScｒ(DIＳP_FGＮD_WHITＥ + DISＰ＿ＢGND＿BＬAＣＫ);

ﻩ&ＭyＴaskStk［TASＫ＿STK_SIＺE - 1],

0ﻩﻩ ﻩﻩ／/任务得优先级别为0

ﻩ//启动多任务管理

ﻩﻩ); ﻩ }

OSStarｔ( )；ﻩﻩﻩ

voｉd MｙTaｓk (void *pdaｔa） ｛

chａｒ* ｓ_Y=\"Y\"； ﻩ

cｈar＊ ｓ_Ｈ=\"H\";

//定义要显示得字符

#if OS_CRＩＴIＣＡL_ＭETHOD == ３ ＯＳ_CPU_ＳR cpu＿sr; ＃ｅnｄｉf

pdata ＝ pdａta;

OS_EＮTER_CRＩTICＡL( )； ＰC_VeｃtＳet(０x0８， OSTickISR); OS＿EXIT_CRIＴICAL( ); OSStatIniｔ( );ﻩﻩﻩ OSＴaｓｋCｒｅate( ﻩﻩYouＴask, ﻩ ﻩ

ﻩﻩ//创建任务MyＴask

ﻩs_Y，ﻩﻩﻩﻩﻩ//给任务传递参数 １ ﻩ

/／ MyTask得优先级别为1

//初始化统计任务

ﻩ/／安装时钟中断向量

//设置时钟频率

PC_SｅｔTiｃkRａte（OS_TICＫS_ＰEＲ＿SEC); ﻩ

ﻩﻩ&YoｕTaｓkＳｔk［TAＳK_STK_SＩＺE - 1］,ﻩﻩ//设置任务堆栈栈顶指针 ﻩﻩ)；

ＯＳTaskCrｅａｔe(

ﻩ

InterＴaｓk, ﻩﻩ/／创建任务MｙＴasｋ

//给任务传递参数

ﻩﻩﻩs_H,

ﻩ&IntｅrTａｓkStk［TASK_STK_SIZE - 1］,/／设置任务堆栈栈顶指针 2ﻩﻩﻩﻩ// MyTaｓｋ得优先级别为2 ﻩ);

ｆor (;;) {

iｆ (ｘ>50） ﻩ

{ ﻩﻩx=0; ﻩ y+=2;

｝ PＣ_DｉｓpChａｒ(x， y,ﻩﻩﻩﻩ/／字符得显示位置 ﻩﻩ*(cｈar＊)pdａta, ﻩ

DIＳP_BＧND_BLACＫ＋DIＳＰ＿FGND_WHIＴＥ ）；

ﻩx ＋= 1;

ﻩﻩ//如果按下Esc键则退出ｕＣOS_IＩ ﻩﻩif (ＰＣ＿GetKey(＆key） == TRUＥ)

ﻩﻩ{

ｉf （ｋey == 0ｘ1B)

{

//恢复Ｄoｓ环境

}

ﻩPC＿DOSReｔuｒn( ）; ﻩ} } }

vｏid YoｕTask (ｖｏid ＊pdata) ｛

#iｆ OS_CRITICAL_ＭＥTＨOＤ == 3 OS＿ＣPU_ＳR cpu_sr; #endif

pdａtａ ＝ pｄata； for （;;) {

if (x>50) ﻩ｛ ﻩ x＝0;

ｙ+=2;

}

ﻩﻩ／/字符得显示位置

ＯSTimeDlｙHＭSM(0, 0, 3， ０）;ﻩﻩﻩ//等待3秒

ＰＣ_DisｐChａｒ( ﻩﻩx， y，

ﻩ*（char*)pdａta,

）；

/／等待1秒

ﻩﻩDＩSP_BGND＿BLACK+DＩSP_FGNＤ＿WＨITE ﻩx += 1;

OＳTimeDlｙHMSM(0, ０, 1, ０）； ｝ }

cｈar*s=＂Ｒuｎning a taｓk for interｒｕpt demaｎd: ＩｎterＴａsk＂； void InｔeｒTask (vｏid ＊pdａta） {

＃if ＯS_CRITＩCAＬ_ＭETＨＯD == 3 OS＿CPＵ_ＳＲ cpｕ＿ｓr; #ｅndif

pｄａｔａ ＝ pdata;

foｒ (；;) { ﻩ｛

ﻩﻩiｆ (x>50) ﻩ

{

y+=2;

ﻩ ﻩﻩx=０； ﻩ ﻩ ﻩ

ﻩ} PＣ_DisｐChar( ﻩ ﻩ);

ﻩPC_ＤispSｔr(5,６，s,DISP＿BＧND_BLACK+DIＳP＿FGND_WＨIＴE);

ｘ += 1；

}

//OＳIntNｅstiｎg--；

/／等待1秒

x, ｙ,ﻩﻩﻩ//字符得显示位置

DISP＿BGND_BLAＣK+DISＰ＿FGND_ＷHIＴE *(ｃhａr*)pｄata, ｉｆ(ＩnｔerKeｙ)

ﻩIｎｔｅrKey=ＦALSE;

OSTimeＤlyHMSＭ(0， 0， １, 0）; } } 3、 程序:

#iｆ OS_CPU＿HOOＫS_EＮ ＞ ０ INT８Ｕ d=０； INＴ８U l=0； ＩＮT１６U ｔt=1; chａr ｓ[5];

ｖoid OＳＴｉmeTｉckHoｏk (ｖoid) { ﻩ{ ﻩ

sprintf(s，\"%5d\ｔ);

ﻩＰC_DｉspSｔｒ(d,l＋4,s,ＤＩSP_BGND_ＢLAＣK＋DISP_FGND_ＷHIＴE）; ﻩd＋＝6;ﻩ ｝

ｉf(OSTCBＰrｉｏTbl[2]－>OＳＴCBＤlｙ ＝= 1)

ﻩtt+＝1;

｝ ＃endif Tesｔ、c

＃incｌude ＂iｎcludｅs、h＂

#ｄefinｅ TASK＿STK_ＳＩZE 5１2ﻩ

ﻩ//任务堆栈长度

／/定义任务堆栈区

OS_STK MｙTaskＳtk［TASK_SＴK_ＳＩZE];ﻩ INT１6S key;ﻩﻩ INT８Ｕﻩ x=０,y=0;

ﻩﻩ//用于退出uCOS_II得键ﻩ

ﻩﻩ／／字符显示位置

//声明任务 //声明任务

OS_ＳTK YouTaskＳtｋ[TASK_ＳＴK_SIZE］； ﻩ//定义任务堆栈区

void MyTａsk(vｏid *dａta）;ﻩ void YouTask(void *dａta)； ﻩ vｏid maｉn (void） ｛

cｈar* s＿Ｍ=＂M\";ﻩﻩ OSInit();ﻩﻩ

//定义要显示得字符

ﻩﻩ/／初始化uCOＳ_ＩI

／／安装uCOS_IＩ中断

ＰＣ_DOＳＳaveReｔurn();ﻩﻩ ﻩ/／保存Dos环境 ＰC＿VｅctSet(uCＯS, OSCtｘＳw）；ﻩﻩ OSTaskCreate(MyＴaｓk, ﻩﻩs＿M,ﻩ ﻩ ﻩ }

voｉｄ MyTask (voｉd *pdata) {

cｈａr＊ s_Ｙ=\"Y＂;ﻩﻩ

//定义要显示得字符

#if OＳ＿ＣRITICAL＿MＥTHOＤ ＝＝ 3 OS＿ＣＰU_SR cpu_ｓｒ; #endif

ｐdａta = pｄata； OS_ENTER_CRITICAＬ()；

PＣ＿VｅｃtＳet(0x08， OSＴiｃkIＳR);ﻩ OS_EXＩT_CRＩTIＣAL();

OSＳtatＩｎit(); ﻩﻩﻩ//初始化uCOS_ＩI得统计任务 ＯＳTaｓｋCrｅａte(ＹouTａｓk,ﻩﻩ ／/创建任务ＭyTaｓk

s_Ｙ,ﻩ

ﻩ//给任务传递参数

//安装ｕＣOS_ＩI时钟中断向量

PＣ_SetTickRate（OS＿TＩCKＳ＿PER_ＳEC）;ﻩﻩ//设置uＣOＳ＿IＩ时钟频率

ﻩ

PC_DispClrＳcｒ(DISP_FGＮD_ＷHITＥ ＋ DＩSＰ＿BGND_BLＡCK);

//创建任务MyTａsk

／／给任务传递参数

&ＭyTaskStk［TAＳK_STK_ＳIZE － 1］,／／设置任务堆栈栈顶指针 0); ﻩﻩﻩ//使任务MyTaｓk得优先级别为0

ﻩ//启动uCOS_II得多任务管理

ＯSStart()；ﻩﻩ

ﻩﻩ＆ＹouTaskStｋ[ＴASK_STK＿ＳIZＥ - 1]，ﻩ//设置任务堆栈栈顶指针

ﻩ２)；

／／使任务MyTasｋ得优先级别为2

for (;;） { iｆ (x>50) ﻩ{

x=0; ﻩ ｙ+=2； }

PＣ＿DｉｓｐCｈar（x, y,ﻩ ﻩﻩ*(ｃhar*)ｐｄatａ,

ﻩDIＳP＿BGND_BLＡCＫ+DISP_ＦＧＮD_ＷＨＩＴE );

x++;

ﻩ{

if (ｋeｙ == 0x1B)

{

PC_DＯSRetｕrｎ(）; } }

OSTｉmｅDly(３００);ﻩﻩ／／延时1０0个时钟节拍 } ｝

vｏid ＹｏuTasｋ （ｖｏid *pdａta) {

＃ｉf ＯS＿ＣＲITIＣAL＿MEＴHOD == 3 OS_CPＵ_SR cｐu_sｒ; #ｅndｉｆ

ｐdaｔa = pdaｔa; foｒ (;;) {

if （x>５0） ﻩ}

PC_DｉｓｐChar(x, ｙ,ﻩ

//显示字符得位置

｛ x=0； y+=2;

／/显示字符得位置

if(y>１) OSＴimeDｌｙResume(２); ﻩ /／取消ＹｏuＴasｋ任务得延时

ﻩｉf (PC_ＧeｔKey(＆ｋｅｙ) ＝= TＲＵE)

ﻩ*（cｈａr*)pｄａta,

ＤＩＳP_BGＮＤ＿BLACK+DIＳＰ_FＧND＿WHITＥ ）;

x ＋= 1;

} } 4、

OSTiｍeDly（50０); ﻩ／／延时500个时钟节拍

#ｉｎcluｄe \"inｃludes、h\"

#deｆine ＴＡSK_ＳTK_SＩZE 512ﻩ ＩNT１6S key; INT3２U stime; IＮT8U x=0；ﻩﻩ ﻩ

vｏid MyＴask(void *dａta); void ｍain （vｏid) ｛

ＯSIｎiｔ();

ﻩ

/／初始化uCＯS_IＩ

/／保存Dos环境

/／安装uCOS_II中断

PC＿ＤOSSaveReｔurn()； ﻩ

ﻩﻩ//声明一个任务

ﻩﻩﻩ//用于退出uCOS＿IＩ得键ﻩ

ﻩ//任务堆栈长度

ﻩ//定义任务堆栈区

OS＿STK TasｋSｔartSｔk[TASK_SＴK_SIＺE];

ＰC_VｅctSet(ｕＣOＳ, OSCｔxSｗ);

ＰC_DｉspClｒScｒ(DＩSP＿FGＮD_WHITE + DISＰ_BGNＤ_BＬACK)； OSTａskＣｒeate(MyTａsk, ﻩﻩ／/创建任务MyTask

ﻩ(voiｄ*)０，

ﻩﻩ

ﻩ//给任务传递参数

ﻩﻩ&ＴaskStarｔSｔk[TASK_ＳＴK_SIZE - 1]，//设置任务堆栈栈顶指针 ﻩﻩ0）; }

ｖoiｄ MyTaｓk (vｏｉd *pdata) ｛

chaｒ s[5];

＃if OS_ＣRITＩCＡＬ＿MＥＴHOD =＝ 3 OＳ＿CPU_SR cpu_sｒ; ＃ｅndif

pdａtａ = ｐdａtａ; OS_ＥＮＴER_CＲIＴICAL(); PＣ_VecｔＳet(0x0８, ＯSTｉckISR); ＯS_EXＩT_ＣRITICAＬ（);

OSＳtａｔＩnｉt();ﻩﻩﻩ//初始化ｕCOS_II得统计任务

／/安装uCOS_II时钟中断向量

PC_ＳetTickRａtｅ(ＯS＿ＴICKＳ_PER_SEＣ);ﻩ/／设置uＣOＳ＿II时钟频率

/／使任务ＭyＴasｋ得优先级别为0

／/启动uＣOＳ＿IＩ得多任务管理

OＳSｔａrt(）;ﻩﻩﻩ

foｒ (;;) {

iｆ (ｘ==1０) ﻩ{

ﻩ OSTｉmeＳｅt(１0); ﻩ｝ ﻩﻩs, ﻩ{

if （key == 0x1Ｂ)

{

ＰC_DOSReturn(）； } ｝

OSTｉmeＤlyHMＳM（0, ０, 1， ０)； ｝ } 5、

＃includｅ ＂incｌudes、h\" #inｃlｕde ＂serial、h\" #ｄefine MＡXＳTＫSIZＥ 5１２ ｖｏid TASK1(ｖoid *ppdａta）; void TAＳK2(void *ppdａｔa)； voiｄ TAＳＫ3（void ＊ppdaｔa);

OS_STK TＡSＫ１ＳTＫ[ＭAXSTＫＳＩZＥ]; OS_STＫ TＡSK2SＴＫ[ＭＡXＳTKSＩZE]； OS＿ＳTK TAＳK3SＴK［MＡXＳTKSIZE]； IＮT8U ｔｉmes=1; ｖoid main(ｖoid） ｛ ﻩOSInit();

InitTｉmer0（);

ﻩ

//运行次数

／／等待

ﻩＤＩSP_ＢGNＤ_BＬAＣK+DIＳP_FGND_WHITE ）; //如果按下Eｓc键则退出uＣOＳ＿IＩ if (PＣ_ＧetKｅy(&kｅy) ＝＝ TRUE) ﻩﻩｘ += １;

ｓｔime=OＳＴimeGet(）; PC_DispStｒ(5, 2,ﻩ

／／在x，ｙ位置显示s中得字符

ﻩsprintf(ｓ，\"%5d\ｓtime);

｝

InitSｅriaｌ（);ﻩﻩ

OＳTaｓkＣｒeａｔe(ＴASK1,(ｖoid *）0,&ＴASＫ１STK[0]，1）; OSTasｋCreate(TASK２,(void *)０,&TASK2ＳＴK［0］,2); ＯSTaskCreatｅ(TAＳK3,(voiｄ ＊)0，&TASＫ3STK［0],3);

ﻩ／/创建三个任务

ﻩOSStａrt();

ｖｏid TＡSＫ1（ｖoid *ｐpdａta) {

ﻩﻩpｐdatａ=ｐpdata; ﻩﻩ{

ﻩﻩﻩUａrt0_ｐrｉｎt（\"task1 is aｃtiｖed、\\n\");ﻩ ﻩ ﻩ }

ｖoid TＡＳK2(void *ppdatａ) { ﻩﻩ ﻩﻩ }

ｖｏｉd TASK3(voｉｄ ＊pｐdatａ) { ﻩ ﻩ

ﻩppdatａ = ppdata;

{

Ｕart０_priｎt(＂ｔask３ is actｉved、\\n\");

ﻩﻩfｏr(;；）

ﻩ ﻩ ﻩ｝

ｐpdata=ｐpdaｔa; ｆｏr（;；） {

ﻩ

Uart０＿ｐｒint(\"task2 is ａctｉｖｅd、\\ｎ\"); OSIｄleCtｒ=OSＩdｌeCtr;

ﻩﻩOSＩｄleCtr＝OSIdleＣｔｒ； }

OSTiｍeDlｙHMSM（0，０,１,0); ﻩET0=１； ﻩﻩfｏr(;；)

//Uart0＿printR（\"%d＼n\ （WORＤ)OSIdleＣtr); ＯSＴiｍeDlｙHMＳM（０，0，1,０);ﻩ

ﻩ／/Uaｒt0_ｐrinｔＲ(\"％d\\n\ＯRD)OＳIdleCｔr);

ＯSIｄleCｔr＝OSIｄleCtr; ﻩﻩＯSTimeDｌｙHMSM(0,０,1,０);

｝

}

七、实验小结

本次实验对中断得处理过程等有了更深一步得了解,对与uc/OS得中断机制有了比较详细得了解。实验中通过对uc/os时钟中断得使用，对uc／OS得时钟等有了比较深入得了解同时在做实验得过程中,对于UC／OS得工作原理有了很深得了解。对ＵC/OS得程序编写也更熟悉了。

实验3《信号量应用》

实验学时: 2 实验地点： 综二实验室x２01 实验日期: ２０13／12/16 一、实验目得

１.实验环境得建立

2.任务得通信机制之信号量应用及解决优先级反转 二、实验内容

1.设计应用程序中有2个用户任务:MyTask与YoｕＴasｋ。这两个任务都要访问同一个共享资源s，但YouTａsｋ访问s需要得时间长一些（本例中使用了一个循环来模拟访问得时间),而ＭｙＴask访问ｓ得时间要短一些，这样就不可避免得出现了在任务YoｕＴasｋ访问s期间,任务ＭyTasｋ也来访问s,从而出现了干扰,观察干扰现象，解释原因。

２、在应用程序中定义一个全局变量aｃ_keｙ来作为信号量,并根据该信号量得状态来访问共享资源s，以解决实验１中得冲突问题。

3、

在实验2中,把使用得信号量改为互斥型信号量,然后运行该程序并观察其运行

结果。(不做) 三、实验方法

包括实验方法、原理、技术、方案等。 四、实验步骤

1.将BC4５文件夹拷贝到Ｃ分区根目录下。 2.将softｗａrｅ文件夹拷贝到任意分区根目录下。 ３、 分别完成实验1、2、3。 五、实验结果

1、实验运行结果如下：

2、实验运

行结果如下:

3、实验运行结果如下:

六、实验结论

对实验数据与结果进行分析描述，给出实验取得得成果与结论。 １、核心代码如下:

/＊＊*＊＊****＊*＊****＊***＊＊**Test**＊*****＊*＊*＊*******＊＊*******＊＊*＊***/

#include ＂inclｕdes、h\"

＃defiｎｅ TASK_STＫ＿ＳIZＥ ５１2ﻩﻩﻩ//任务堆栈长度 OS_ＳTＫ MyTaｓkStk[ＴASＫ_ＳTＫ_SＩZE]; ＩNＴ１6Ｓ key; cｈar *s=\"\";

ﻩ ﻩ

//定义任务堆栈区

ＯS_STK ＹｏuTａskStk[TＡSＫ_STK_SIＺE];ﻩ//定义任务堆栈区

ﻩ／/用于退出uCOS_ＩI得键

//字符显示位置

//声明任务 ﻩ/／声明任务

INT8Uﻩ y１＝0,y2=0;ﻩ

ﻩ／/定义要显示得字符

void MyTａsk(voiｄ *ｄata）;ﻩﻩ

void ＹouＴaｓｋ(ｖｏid *data)；ﻩ ﻩ void mａin (ｖoｉd) {

OSIniｔ( );

ﻩ

/＊******＊**************＊＊主函数*＊********＊***＊****＊＊*************／

ﻩﻩ ﻩ/／初始化ｕＣOS_II

/／保存Dos环境

PC_DOSSaveReturn（ );ﻩﻩ

PC_VectSｅt(uCOS, OSCtｘＳw); ﻩﻩ／／安装uCOＳ＿II中断 ＰC＿DiｓpCｌrＳcr(DIＳP_FGNＤ_WHITＥ + DISP_ＢGNＤ_BLACK）; OSＴａskCｒeａte（MｙTask，

ﻩ ﻩ//创建任务ＭyTaｓk

ﻩ(ｖoｉｄ＊）0, ﻩ ﻩ ﻩ/／给任务传递参数

ﻩ ｝

ﻩ＆MyＴaｓkStk［TASＫ_ＳTK＿ＳIZE - 1］,ﻩ/／设置任务堆栈栈顶指针 0);

ﻩﻩ

//使任务得优先级别为0

ﻩﻩﻩ //启动多任务管理

OSStart( ); ﻩ

/*******＊＊***＊*＊***＊＊*＊*任务MyTaｓｋ****＊***********＊**＊***＊**＊*****/ ｖｏid MyTａsｋ (voｉd *pdatａ) {

#ｉf OＳ_CRＩTＩCAL_METHＯD =＝ 3 OS＿CPU_SR cpu_sr; #endif INT8U eｒr;

ｐdata = ｐdａｔa；

ＯＳ_EＮTER_CRＩＴICAＬ( )； PC＿ＶｅctSet(0x0８, ＯSTicｋISR); OS_EXＩT_ＣＲＩTICＡL( ）； OSSｔaｔIｎit（ ); ﻩﻩﻩﻩ ﻩﻩ(voｉｄ*）0,ﻩﻩ ﻩﻩ ﻩ

2); ﻩ

//初始化统计任务

ＯSＴａｓkCrｅａte(YouTaｓk, ﻩﻩﻩﻩ//创建任务ＹｏuTaｓk

／/给任务传递参数

ﻩ&YouTａskStk[TASK＿ＳTＫ＿SIZE - １],ﻩ／／设置任务堆栈栈顶指针

ﻩﻩ //使任务得优先级别为2

/／安装时钟中断向量

PC_SetＴｉcｋＲate（OS＿ＴICKS_PER_ＳEC);ﻩ//设置ｕＣＯS_II时钟频率

for （;;) {

s=\"MyTａｓk viｓit data s\"; ﻩ

ﻩPC_DiｓpStr(５, ＋＋y１, ﻩ ﻩ

ﻩ//显示字符串

ﻩﻩﻩs,

ＤISP_ＢGNＤ_ＢＬACK+DISP_FGND＿WＨＩＴＥ);

ﻩ//如果按下Esｃ键则退出uCOS_II

ﻩif (PC＿ＧｅtＫｅy(&ｋeｙ） == TRＵＥ) { ﻩ{

iｆ (ｋey == ０x1B) PＣ_DOSReturn( ); } ｝

OSTiｍｅDｌy(20０)； ｝ ｝

/**＊***＊*＊*********＊*****任务YｏuTａsk***＊**＊＊*******＊****＊＊**＊*****/ voｉd YoｕTask (void *pdata) {

#iｆ OS＿CRITICＡＬ_ＭETHOD == ３ OＳ_ＣPU_SR cpu_sr; #eｎdif

ﻩ

ﻩ//等待200个时钟节拍

INＴ８U err； ｐdata = ｐｄａta; for (;；)

{

s＝＂ＹoｕTask ｖｉsit ｄata s\"; ﻩ ﻩ ﻩ

ﻩPC_DispStｒ（２８, ++y2,ﻩﻩﻩﻩ//显示字符串

s,

//置OSTime为0

DISP_BＧNＤ_BLAＣK＋DIＳP_FGＮD_WHITE )；

ﻩOSTｉmｅSet(０);ﻩﻩ ﻩ ﻩ }ﻩ

{ ﻩ ﻩﻩﻩs,

ﻩ

ﻩ

ﻩﻩwhilｅ（OSTime<50０)

PC＿ＤispStr（5５, y2，ﻩ ﻩ//显示字符串

ＤＩSP_BＧND＿ＢLACＫ＋DISP_ＦGND＿ＹEＬＬOW );

／／等待10个时钟节拍

ＯSTimeDly(10); } }

／*********＊**＊**＊********End＊*＊＊**＊****＊***＊**＊******＊＊＊*＊****＊***/

2、实验核心代码如下:

/*＊********＊***＊******＊＊*Teｓt****＊**＊**＊**＊****＊**＊*＊********＊**＊＊*/

#inｃｌude ＂iｎcludes、h\"

＃ｄefｉｎe TＡSK＿STK_SＩZE ５12

ﻩ//任务堆栈长度

OS_STK MyTａskStk[TASK_ＳTK_SIＺＥ］;ﻩ／/定义任务堆栈区 OS_SＴK YoｕＴaskStk[ＴＡＳK＿STK_ＳIＺE]; //定义任务堆栈区 IＮT1６S kｅy;

ﻩﻩﻩﻩ／/用于退出uCＯS＿ＩＩ得键

ﻩ

／/字符显示位置

IＮT8U ｙ1=０,y２＝0;ﻩﻩﻩ

ＢOＯＬEAN ａc_keｙ;ﻩﻩﻩﻩ ﻩ/／定义信号量 cｈar* s=\"原始数据\"; ﻩﻩﻩﻩ /／定义要显示得字符 ｖoｉｄ MyTaｓk(ｖｏid *datａ)；ﻩ ｖｏiｄ ＹoｕＴasｋ(void *ｄata); ｖｏid maiｎ (ｖｏid) {

OSＩnit( ); ﻩﻩﻩﻩ ﻩﻩ/／初始化uＣＯＳ＿II aｃ_ｋｅy=1;

ﻩﻩ

／／设置信号量初值 ﻩ//保存Dos环境

ﻩ／/安装uCOS_II中断 /／创建任务ＭyTask

ＰC_ＤOSSavｅReturn( );ﻩ

ﻩﻩﻩ/／声明任务 ﻩ

ﻩ

／/声明任务

/＊*＊************＊＊**＊***＊主函数***＊****＊＊**＊**＊****＊**＊＊**＊*****/

PC_ＶecｔSet（uCOＳ， ＯSCtxＳw);ﻩ ＯＳＴａskCｒｅaｔｅ(MyTask, ﻩ

PC_DispClrScr(ＤISP＿FGND_ＷHITE + DISP_ＢGND_BＬＡCK)；

ﻩ

ﻩ(ｖoid*)０,

ﻩ

ﻩ//给任务传递参数

ﻩ&ＭyＴaskSｔｋ［ＴAＳK＿ＳTK_SＩＺE - １］，ﻩ//设置任务堆栈栈顶指针

}

ﻩ0); ﻩ ﻩ //使任务得优先级别为0

ﻩ//启动uCＯS_ＩＩ得多任务管理

OＳStart( )； ﻩﻩﻩ

/****＊*＊***＊***＊**＊***＊*任务MｙTasｋ*＊*＊*＊****＊**＊*＊＊*＊****＊＊*******／

ｖｏid MyTａsk (vｏid *pｄａta) {

＃if OＳ＿ＣＲITICＡＬ_METHOD =＝ 3 OS＿CPU_SR cpu＿sr; #ｅndif INＴ８U err；

pdａta = ｐdata;

OＳ＿ＥNＴER_CRITICAL（ ); PC_VectSet(0x08, OSTiｃkISR); ＯＳ_ＥXIT_CRITICＡL( )； OSSｔatInit（ )； ﻩ ﻩ

(voｉd*)0,

ﻩ

ﻩﻩ／／初始化uＣOS_II得统计任务 ﻩ

//创建任务MyTask

／/设置任务堆栈栈顶指针

OSTaskCreaｔe(YoｕＴａsｋ, ﻩ

ﻩ

／/安装uＣＯＳ_II时钟中断向量

PC_ＳeｔTicｋRate（OＳ_ＴIＣKS_PＥR_SEC); //设置uCOＳ_ＩＩ时钟频率

ﻩﻩﻩﻩ //给任务传递参数

&YｏｕTasｋＳtk[TASK_SＴK＿SIZE - 1]，

ﻩ//使任务得优先级别为2

2);ﻩ ﻩ

for （;；) { ﻩ

ﻩｉf(ａc_ｋｅy） ﻩ ﻩ ﻩ

{

ac_kｅy＝ＦＡＬＳE;

ﻩ／/使信号量无效

ﻩs=\"ＭyTask ｖｉsｉｔ datａ ｓ\";

PC_ＤispStr（5, +＋y１,ﻩ ﻩ//显示字符得位置

s，

ﻩＤISP＿BＧＮＤ＿ＢＬACK＋DISＰ_FGＮD＿WHITE)；

//发信号

ﻩﻩ ａc_key=ＴＲUＥ; ﻩ

ﻩﻩ}

ﻩ/／如果按下Esｃ键则退出uＣＯS_II ﻩ ﻩ

if (PＣ_GｅtKey(＆key） == ＴRＵE） {

ｉf (ｋey ＝= 0ｘ1B) ﻩ ﻩ｛

PC＿DOSＲetuｒｎ( ）; } }ﻩ

OＳTimeDｌy（２0）； ﻩ } }

/***＊**＊*＊*＊＊*****＊*＊*＊*＊任务ＹouＴask***＊＊＊*＊***＊*＊＊＊**********＊

ﻩ//等待20个时钟节拍

*／

void YouTask (void ＊pdata) ｛

＃ｉｆ OS_CRＩTICＡL_ＭETHＯD == ３ OS＿CPU_ＳＲ cｐu_sr; #eｎdif

IＮT8U ｅrr; pｄata = pｄata; for （;;) {

iｆ(ac_ｋey）

ﻩ

｛

ａc_kｅy＝FAＬSＥ； ﻩ

／/使信号量为无信号

ﻩs=\"YoｕTasｋ visit data ｓ\"; ﻩﻩﻩＰC_DiｓpStr（２8， ＋+y2, ﻩﻩ//显示字符串 ﻩ ﻩ ﻩ ﻩ ﻩ ﻩ ﻩﻩ}

OSTimeＤly(10); } }

/＊*＊*＊**＊＊＊************＊*Ｅｎd*******＊＊**＊＊**＊*＊****＊***＊＊********＊*/

ﻩﻩ ／／等待10个时钟节拍

ﻩ{ ﻩ

PC_DisｐStr(5５, y2, ﻩ//显示字符串

ﻩs，

ﻩs,

ﻩﻩDＩSP＿BGND_ＢLACK+ＤISＰ_FGND_WHIＴＥ );

OSTimeＳet（0);ﻩ

//置OＳTｉｍe为0

ﻩwhiｌe(OSＴｉｍｅ＜500)

ﻩﻩﻩ DISP＿BGＮD＿BＬＡCＫ＋DISP_FGND_WHITE );

}ﻩﻩ

ﻩﻩaｃ＿keｙ=TRUＥ;ﻩ ﻩﻩ//发信号

3、实验核心代码如下：

/*＊**＊******＊**＊****＊＊**＊Test＊＊＊*＊***＊＊*****＊*＊＊**＊**＊*********＊*＊／

#inｃｌude \"incluｄeｓ、ｈ\" #deｆine TASK_STK＿SIZE ５1２

ﻩﻩ//任务堆栈长度

//定义任务堆栈区

OＳ_ＳＴK StaｒｔTａskSｔk[TAＳK_SＴK_SIZE];ﻩ

ＯS_STＫ Taｓk1Ｓｔk[ＴASＫ_STK_SIZＥ］;ﻩﻩﻩ//定义任务堆栈区 OS_ＳTK Taｓｋ2Sｔk［TASK_SＴＫ_SＩＺE];ﻩ ﻩ//定义任务堆栈区 ＯS_ＳTK Task3Ｓtｋ[TAＳK_STK_ＳIZE]; IＮT1６Ｓ key;ﻩ ﻩ

ｃｈar＊s1=\"Tａsｋ1 ruｎning\"； chaｒ*s２=\"Ｔasｋ2 ｒunｎing＂； chaｒ*s3=\"Tａsk3 rｕnning\"；

ﻩ/／定义任务堆栈区

//用于退出得键

cｈａｒ*ss=＂Task1 deｓire ｓem\"; INT８U eｒｒ； INT8U y=0； ﻩ

ﻩ

ﻩ／/定义事件控制块

ﻩ／/声明起始任务

／/声明任务

ﻩﻩ／/字符显示位置

INT32U Tｉmes=0;ﻩﻩ ＯS＿EVENT *Muｔexp;ﻩ

vｏid StarｔTask（void *data); vｏｉｄ Task1(voｉd ＊data）； voｉd Task２(void *data);ﻩﻩﻩ

//声明任务

void Ｔasｋ3(ｖoid *ｄaｔa）； ﻩﻩﻩ/／声明任务

/****＊***＊**＊******＊**＊**主函数*＊****＊*****＊**＊******＊***＊*****＊/ vｏid main (vｏｉd） {

OSIｎit( )；

ﻩﻩ

//初始化uCＯS_II /／保存Dos环境

PC_DOSＳaｖeRｅｔurn( );ﻩ ﻩ

PＣ＿VeｃｔSｅｔ(uCOS, OＳCtxSｗ）；ﻩﻩﻩﻩ/／安装ｕCOS＿IＩ中断 PC_DispＣlrScr(DISP_FＧND_ＷHITＥ ＋ ＤＩＳP_BGＮＤ_BLACK); Mutexp = OSMｕtｅｘCｒｅate (１,&ｅrｒ);ﻩ OSTaskＣrｅaｔe（StarｔＴasｋ, ﻩ

(ｖoid*)0,ﻩ

／/给任务传递参数

ﻩ//定义信号量

ﻩ//创建任务StartTask

&StaｒtTaskSｔk[TASK_STＫ_SＩＺE - 1],ﻩﻩ/／设置任务堆栈栈顶

/／使任务得优先级别为0

ﻩ

//启动多任务管理

ﻩ０);ﻩﻩ }

OSSｔart( );

／********＊***＊*****＊***＊任务SｔartTasｋ*******＊＊＊*＊＊＊＊******＊**＊＊*＊＊**/

voｉd StartＴａsｋ (void ＊pdａta) ｛

＃iｆ OS＿CＲITIＣAL_METHＯD == ３ OS_CＰU_ＳR ｃpu_sr; #endiｆ

pdatａ = pdata； OS_ENTER_CRITICＡL( )；

PC_VecｔSet(0x08, ＯSTickISR); ＯS_EＸIT_CRITICAL( )； OＳStaｔInit( ）；ﻩﻩ

ﻩ//初始化统计任务

／/创建任务Taｓk1

//设置任务堆栈栈顶

OＳＴaｓkCｒeate(Tasｋ１, ﻩ

/／安装时钟中断向量

PＣ_SeｔＴicｋRate（OS_TICKS＿ＰER_SEＣ）;ﻩ /／设置uCOＳ_II时钟频率

(void＊)0,ﻩ ﻩ/／给任务传递参数

ﻩ&Tａsk１Stk[ＴASK_ＳＴK_SIＺE - 1]，

ﻩﻩ3);ﻩﻩﻩﻩ//使任务得优先级别为３

OSTａskＣrｅate(Ｔaｓｋ2,ﻩ ﻩﻩ／/创建任务Ｔask２ ﻩﻩ(vｏiｄ*）0, ﻩ

ﻩﻩ４)；ﻩﻩ

//给任务传递参数

ﻩ&Taｓk２Stｋ[TＡSＫ_STK_SＩZE - １］,ﻩ／／设置任务堆栈栈顶

//使任务得优先级别为4

ＯSＴaskCreａte（Task3，ﻩﻩ ﻩ//创建任务Task3

ﻩ(voｉd*)0， ﻩ

//给任务传递参数

ﻩﻩ&Task3Stk［TＡSＫ_ＳTK_ＳIＺE － 1]，ﻩ//设置任务堆栈栈顶 ﻩﻩ5）； ﻩﻩ //使任务得优先级别为5 fｏr （；;） { ﻩ

//如果按下Esc键则退出uＣOＳ_II {

if (ＰC＿GetKey(＆key） == TRＵE)

if (ｋey == ０x１Ｂ） ﻩ {

PC_DＯSReturn( ); ｝ }

ＯSＴimeDlyHＭSM（0, ０, 3， 0);ﻩ//等待3秒 } }

/**＊＊***＊***＊*＊**＊*******任务Tａｓk1**＊*******＊＊****＊*＊*＊**＊*＊*＊＊＊*／

ｖoiｄ Tasｋ1 (void *pｄａｔa） {

#ｉf OS_ＣRITICAL＿ＭETHOＤ == 3 ＯS_CPU＿ＳR cpu_sr; #ｅnｄif

pｄaｔa = pdaｔａ; fｏr (;；) { {

PC_DispStr（10,＋+y, ﻩﻩss,

ﻩﻩＤIＳP_BＧND＿ＢＬACK+DＩSP＿FＧNＤ_YELＬＯＷ ）；

OSMutｅｘPend(Ｍutexｐ,０，＆erｒ)；ﻩﻩ//请求信号量

PＣ＿DispStｒ(1０,＋＋ｙ， ﻩﻩs1,

ﻩﻩＤIＳP_BＧＮD_BＬACK+DISP＿FＧＮD_ＲED )； ﻩ OSMuteｘPoｓt(Muｔexp）；ﻩ //发送信号量 }

OSTｉmeDlyＨMSM(0, 0, 0, ２00);ﻩﻩ//等待２00毫秒 ｝ }

／*＊＊***＊*＊********＊＊**＊*＊任务Tａｓk2******＊******＊＊＊***********＊**/ vｏｉｄ Tａsｋ2 （ｖoid *pdata) ｛

OSTimeDlyHＭＳM(0， ０, 0, 3０0）; ﻩ//等待３0０毫秒

#iｆ ＯS＿CＲIＴIＣAL_MＥTHOＤ ＝= 3 OS＿CＰU_SR cpｕ_ｓr; #endｉf

ｐdata = ｐｄaｔa; ｆor (;;）

{ PＣ_DｉspStｒ（１0,++y, ﻩ

ｓ２,

DISP_BＧND_ＢLAＣＫ+DISＰ_ＦGNＤ_WＨITＥ );ﻩ

/／等待100毫秒

OＳTｉmeDｌyHMＳＭ(０， ０, 0, 100)； ｝ ｝

/＊*＊**＊******＊*＊*＊*＊***＊＊任务Task3＊*＊＊＊*＊*＊*＊****＊*＊*＊*******＊**/

ｖoiｄ Taｓk3 (vｏｉd *pdatａ) {

#iｆ OS＿CRITＩＣAL＿MＥTHOD =＝ 3 OS_ＣＰU_SR ｃpu_sr; #eｎdif

pdａta ＝ pdata； ｆor (;;)

｛ OSMutexPeｎｄ(Mｕtｅｘp,0,＆ｅrr）;ﻩ/／请求信号量 PC_DｉspStr(10,＋+y， ﻩ ﻩ ﻩ{

ﻩﻩＯS_Scheｄ（）;

}

Timeｓ＝0; s3，

DISＰ_ＢGND_ＢLACK+ＤISP_FGNＤ_WHＩTE );

ｆor(Times;Tiｍes＜2０0０0000；Timｅs+＋)

ﻩOSMuteｘPost（Mｕｔｅxｐ)；ﻩ //发送信号量

OSTimeDlyHMSＭ（0, 0, 0, １0０)；ﻩ//等待100毫秒 } }

/*＊**＊*＊*＊*****＊**＊****＊*End*********＊＊***＊＊＊＊*＊*＊**＊*＊＊**＊＊＊****＊/

七、实验小结

本次实验就是对任务之间得共享资源访问得方法。三个实验，循序渐进,第一个实验就是导出共享资源会导致得问题,数据不稳定,第二个实验用一个全局变量来解决了这个问题,第三个实验用互斥信号量解决问题。以前在操作系统得课上学习过信号量得相关知识,但就是没有这么具体,经过这三个实验，从发现问题到解决问题对以前得知识了解得更加具体,透彻了。通过实验对信号量得机制有了很深得理解，对信号量得操作也比较熟悉了

实验4《消息邮箱应用》

实验学时： ２ 实验地点: 201 实验日期: ２０1３／１2／13 一、实验目得

１.实验环境得建立

2．任务得通信机制之消息邮箱应用 二、实验内容

1.设计一个利用消息邮箱进行通信得例子：有两个任务MｙＴask与YouＴask。由于任务ＹouTａsｋ要向任务ＭｙTask发送消息,因此定义了一个全局得指针变量mｓｇ_ｐ作为邮箱来传递消息得指针。

2、

设计一个应用程序,该程序有两个任务MyＴask与YouTask。在任务MyTask中

用一个变量Times记录任务ＭyTａsk得运行次数,并将其作为消息用邮箱Str_Box发给任务ＹouTaｓk,且由任务YoｕTａsk显示出来。 三、实验方法

按照步骤进行运行 四、实验步骤

１.将ＢC45文件夹拷贝到C分区根目录下。 ２.将ｓoftware文件夹拷贝到任意分区根目录下。 3、 分别完成实验1、2 五、实验结果

1、实验运行结果如下：

２、实验运行结果如下： 六、实验结论 1、实验核心代码如下:

/*＊＊＊***＊*＊****＊*＊*＊**＊**Ｔｅｓｔ＊＊****＊*******＊*＊*＊******＊*****＊****＊/

＃include \"includｅs、ｈ\"

#dｅfine TＡSＫ_ＳＴＫ_SＩＺE 51２

//任务堆栈长度

ＯS_ＳTK ＳtartTaｓkStk[TＡSＫ_ＳTK_SIZＥ]； OS_STK ＹoｕTａskStk［TＡSK_ＳTK＿SIZE]; INT16S ｋｅy; ﻩ void *msg_ｐ;

ﻩ

ﻩ

ﻩ ﻩ

ＩNT8Uﻩ y1＝0,y2=0;ﻩ

ﻩﻩ

ﻩﻩ

ﻩ

ﻩ/／定义任务堆栈区

OS＿STＫ ＭyTaskＳｔk[ＴASK_STK_SIZＥ］;ﻩ ﻩﻩ//定义任务堆栈区

ﻩ//定义任务堆栈区

ﻩ／/用于退出得键

//字符显示位置

/／消息邮箱

ｖｏid StarｔTask(voiｄ *data）；ﻩ ﻩﻩ ／/声明起始任务 ｖｏiｄ MyＴａsk(ｖｏｉd *dａta);ﻩﻩ ﻩﻩﻩ//声明任务 voiｄ YｏｕTａsk(vｏid ＊ｄata);ﻩﻩﻩ void main (voiｄ) {

ＯSInｉt( );ﻩﻩﻩ

ﻩﻩ

/／初始化ｕCOS＿ＩI

//保存Dos环境

//安装uCＯS_II中断

ＰC＿DOＳSａvｅRetuｒn( );

／/声明任务

/*********＊*＊************主函数＊＊＊**＊******＊**＊****＊*＊***＊******／

ＰC_VectSet(ｕＣOS, OSCｔxSw）;ﻩﻩﻩ OSＴaskＣreate（StarｔTask,ﻩ ﻩﻩﻩﻩ(voiｄ＊）0,ﻩﻩﻩﻩ

ﻩ

ﻩﻩ 0);

ﻩﻩ ﻩ

ＰＣ＿DiｓpＣlrSｃr(DIＳP_FGＮＤ_ＷHITE + DIＳP_BGND_BLACK);

ﻩﻩﻩ //创建任务MyTasｋ

//给任务传递参数

／/使任务得优先级别为0 ﻩ

ﻩ

//启动多任务管理

&StａrtTaｓｋStｋ[TASK_ＳTK_ＳIＺＥ - 1]，／／设置任务堆栈栈顶

OＳSｔart（ );

｝

/**＊****＊*******＊****＊*＊任务StarｔTask*********＊***＊＊＊****＊＊＊＊*******/

voｉd StａrtＴａsｋ (void *pdata) ｛

#if OS_CRIＴＩCAL＿METHＯD ＝= 3 OＳ_CＰU_SR cpｕ_ｓr； #eｎdiｆ

pdata = pｄaｔａ;

ＯS_EＮTＥＲ＿ＣRＩＴICＡL( );

PC_VectSet(0x08， ＯSTiｃkＩSR）;ﻩ ﻩﻩ//安装时钟中断向量

PＣ_SetTicｋＲaｔe（ＯS_TＩCKＳ_PＥR_SＥＣ);ﻩﻩﻩ／／设置uＣOS_IＩ时钟频率 OS_ＥXIT_CＲITＩCAＬ( ); OSSｔatInｉｔ( ); ﻩ

ﻩﻩ ﻩ(voｉd*）0,ﻩ

ﻩﻩ

1);ﻩ ﻩﻩ

ﻩ

//初始化统计任务

OSTaskCｒｅate（MｙTask，ﻩ

ﻩ/／创建任务ＭｙTask

ﻩﻩﻩﻩ／/给任务传递参数 ﻩ ﻩ

//使任务得优先级别为1

//创建任务ＹｏｕＴａsk

/／给任务传递参数 ／/使任务得优先级别为2

&MyＴaskＳtk[TＡSＫ_ＳTＫ＿SIZE - 1],ﻩ//设置任务堆栈栈顶

OSTaskCrｅate（YoｕTask,ﻩ ﻩ ﻩﻩﻩﻩ(void*)0,ﻩﻩ ﻩﻩﻩﻩ2)；ﻩﻩﻩ ﻩ { ﻩ ﻩﻩ{

ﻩﻩﻩ &ＹouTaｓkＳtk[TＡSK_SＴK_SIZE - 1],ﻩ//设置任务堆栈栈顶 ｆor (；;)

／／如果按下Esc键则退出uCOS_II ｉf （PC_GｅｔKey（&key) == TRUE)

iｆ (keｙ ＝= ０ｘ1B)

{

PC_DOＳReturn( ); } }

OSTｉｍｅDlyＨMＳM(0, ０， ３, ０); ﻩ } }

／****＊*******************任务MyTasｋ**＊**＊**＊**********＊*＊*******＊＊/ void MｙTask (vｏid *pdata） {

#iｆ OS_CRIＴICAL_MEＴＨOD == 3 OS_CPU_SR cｐｕ_ｓr; #ｅndif

pdaｔa = pdata; ﻩｆor (;;)

{

／／等待3秒

ＰC_DｉｓpＳｔr（5, ＋+ｙ1， ﻩ ﻩ ﻩ ﻩ ﻩ ﻩ ﻩﻩ}

{ ﻩ ﻩ

PＣ_DiｓｐSｔr(15,y１, ﻩﻩmsg＿ｐ， ﻩ ﻩ＂MyTask\"，

ﻩ／/显示字符串

ﻩDＩSP_ＢGND_BLAＣK+DISP_FGND_WHITE );

if(ｍsｇ＿p!＝（voｉd＊) 0) ﻩﻩﻩ /／请求消息

ﻩﻩﻩﻩ//显示收到得消息

ﻩ

ﻩ

/／使消息邮箱为空

ﻩ//等待１秒

ﻩﻩﻩ ＤISP_BＧND_BLＡCＫ＋DISP_FGND_RＥＤ ）; msg_p=(void*) 0；

ＯSTimeＤlyHMＳM(０， 0， 1, 0);ﻩ } ｝

/****************＊*******任务ＹouTask**＊****＊***＊＊****＊*****＊***＊**/ void YouTask (void ＊pdaｔa) {

＃if ＯS_CRITＩＣＡＬ_MEＴHOD == 3 OS_CＰU_SＲ cｐu_sｒ； ＃endiｆ

chａr*s=\" ａ messａge fｒom YｏｕTask\"; pdａta = pdａta; foｒ (；;） {

ＰC_DisｐStr（40， +＋y2,

ﻩ

ﻩ\"YｏuTask\",

ﻩﻩﻩ //显示字符串

ﻩﻩﻩ／/定义消息

ﻩﻩ ﻩDIＳP_BGＮＤ＿ＢLＡＣK+DIＳP_FGND_WHＩTE ）； ｉf(OＳTiｍｅGet（ )>50０ && ｍsｇ_p==(void*) 0) ﻩ

ﻩ

{

msg_p=s；

ﻩ

ﻩ

ﻩ／/发送消息

PC_DispSｔr(5０,y2,

\"YouＴask send a messａge\",

ﻩﻩDISP_BＧＮＤ_ＢLＡCＫ＋DIＳP_FＧND＿RＥD )；

/／等待１秒

ﻩﻩ｝ ﻩﻩ

ＯSTiｍeＤlｙHMSM（0， 0， 2, 0）;ﻩﻩ ｝ }

/****＊**********＊********Eｎｄ*＊＊*******************************＊**＊/

2、核心代码如下:

/＊*****＊***＊*******＊**＊**Test＊******＊**＊***＊*************＊*＊*＊**＊*/ #ｉncｌｕde \"includｅs、h\"

#defiｎe TAＳK_STK_SIZE ５12 ﻩ

//任务堆栈长度

//定义任务堆栈区

／/定义任务堆栈区 //定义任务堆栈区

OS_SＴK StartTaskＳtｋ[TAＳK_STK_ＳＩZＥ]; ＯS＿STK MyTaskStk[ＴASK＿STK_SIZE]； ＯS_ＳTK YｏuTaskStk[TASK_STＫ_SIZＥ];

IＮＴ16S key;ﻩ chaｒ*s; chａr＊ss； INT8U ｅｒr; ﻩﻩ ＩNT8Ｕ y=0;

ﻩﻩﻩ //用于退出得键

ﻩﻩ

ﻩ

ﻩﻩ//声明起始任务

ﻩ

／/声明任务

//字符显示位置

INT3２U Timｅs=０;ﻩﻩﻩ OS_EVEＮT *Stｒ_Box;

vｏid ＳtartTask（voｉｄ *data);ﻩ vｏｉｄ ＹouTａsk(void *dａta); ｖoid main (voｉd） {

ＯＳIｎit( );ﻩ ﻩ

vｏｉd MｙＴasｋ（void *ｄata); ﻩﻩﻩ//声明任务

/*******＊*********＊*****＊主函数＊*******＊*****＊**＊*＊****＊＊*****＊*/

/／初始化ｕCOS_II

ﻩ／/保存Dos环境

/／安装ｕCOS_II中断

PＣ_ＤOSSaveReｔｕｒn( ）;ﻩ

PC_VectSｅｔ(ｕCOS, OSCtｘＳw）;ﻩﻩ

PＣ_DｉsｐCｌrScr(DＩＳP_FGNＤ＿WHITE + DＩＳP_BGND_BLACK)； Str_Box ＝ OSＭｂoxＣreatｅ ((ｖoid*)０）;ﻩﻩ //创建互斥型信号量 OＳTaｓkCｒeatｅ(ＳｔaｒｔTask,ﻩﻩﻩ ﻩ(ｖｏid*)0, ﻩﻩﻩ //给任务传递参数

ﻩ&StartＴａskStk[ＴASK＿STＫ＿SＩZE - 1], ﻩ//设置任务堆栈栈顶 ﻩ0)； ｝

/*＊＊＊＊**************＊*＊*任务ＳtaｒｔＴask*＊*******＊＊＊*＊＊**＊***＊*****＊*＊*/

voiｄ StartＴａsk （void *pdaｔa) {

#if OS＿CRIＴＩCAL＿METＨOＤ =＝ 3 ＯS＿CPU＿SＲ cｐu_sr； ＃endｉf

pdata = ｐｄata; OS_ENTER_CRITICAL( )；

ＰC_VｅctSeｔ（0x０8, OSTicｋＩＳＲ);ﻩﻩ//安装时钟中断向量

PC＿SｅtTｉcｋRate（ＯS＿TIＣKＳ＿PER_SEC);ﻩﻩ//设置uＣＯS＿II时钟频率 OS＿EXＩT_CＲＩTICAL（ );

OＳＳtatIniｔ( ); ﻩﻩ //初始化统计任务

OＳＴaskＣｒeａtｅ(MyTaｓｋ,ﻩﻩﻩ//创建任务MｙＴａsk

ﻩ(voｉｄ*)0,ﻩ

ﻩ

ﻩ//给任务传递参数

＆MyTaskStk[TASK＿STK_ＳIZE - １],ﻩ/／设置任务堆栈栈顶

//使任务得优先级别为3

／／给任务传递参数

ﻩﻩ ﻩ//使任务得优先级别为0

OSＳtａrt（ ); ﻩﻩﻩﻩﻩ／/启动多任务管理

／／创建任务StartＴask

ﻩﻩ３);

OＳTａsｋCreａte(YouTaｓｋ,ﻩﻩ //创建任务YouTａｓk ﻩﻩ（void*)０,

&ＹouTaskStk[TAＳK＿SＴK＿SＩZE - 1], //设置任务堆栈栈顶

ﻩﻩ4);ﻩ ｛

ﻩ//使任务得优先级别为4

for （;;）

//如果按下Eｓc键则退出ｕＣOＳ_IＩ { ｛

ﻩif (PC_GｅｔKｅｙ(&kｅy) == TRUE) ｉf (kｅｙ ＝= 0ｘ1B) PC_ＤOSReturｎ()； } ｝

OSＴｉmｅDｌyHMＳＭ（0, 0, ３, 0)； //等待3秒 } }

/*******＊*****＊*＊********任务MyTask＊**********＊**＊***＊*******＊**＊＊/ void ＭyTask （ｖoid *pｄatａ） {

#if OS_ＣRIＴICAＬ＿ＭETHOＤ == 3 ＯＳ＿CPU_ＳＲ cpu＿sr; ＃ｅndｉf

pdａta = pdａta; ｆor （;;） { ﻩ

sprintｆ(s,\"%d＂ ,Times);

ＯSMｂoxＰｏｓt（Str_Ｂox，s)； Str_Ｂox->ＯSEveｎtPtr,／/s,

DISP_BGND_ＢLAＣK+DISP_ＦGND＿WHITE ）;*/ Tｉmes++;

//发送消息

／*PC_DispStｒ(1０，++y,

OSＴimｅＤlｙHMSＭ（0， 0, 1, ０); ／/等待1秒 } }

／****＊＊*＊***＊＊*****＊*****任务YouTasｋ*＊＊*****＊*******＊*************/ ｖoiｄ YouTasｋ （ｖoｉｄ *pdata) {

#if OＳ_CRITICＡL_METHＯD == 3 OＳ_CＰU_SＲ cpu_sｒ； #endiｆ

ｐdata ＝ pdaｔa; ｆoｒ (；;) {

ss＝OSMboxPenｄ(Str＿Box,1０,＆err); PC_DisｐＳtr(１０,++y， ﻩﻩｓs,

DISP_BＧNＤ_BLACＫ+DIＳP＿FGND＿WHIＴE );ﻩ

OSTimeDｌyHMＳM（０， 0, 1, 0）;ﻩ /／等待1秒 } }

/**＊*****＊＊****＊**＊******Ｅnd***********＊********＊***＊***＊＊＊***＊＊**/

七、实验小结

ﻩ本次实验二个题目,对消息邮箱得应用,与信号量不同得就是传递得就是一个全局得指针变量,指针指向要传递得消息。其余没有太多不同。消息邮箱得操作与信号量得操作类似,用于任务间消息传递。

实验５《消息队列应用》

实验学时： 2 实验地点: ２０1 实验日期: 2013/１２/１5 一、实验目得

１.实验环境得建立

2.任务得通信机制之消息队列应用 二、实验内容

1.设计一个应用消息队列进行通信得应用程序,运行该程序并观察其运行结果。 2、 在KEＩL开发环境下,用多任务及某种事件机制实现按下键盘时可以控制对应得LED亮灭: 按下P3、2键盘时P1、0、Ｐ１、1对应得LEＤ点亮，按下Ｐ3、3键盘时P1、2、P１、3对应得LEＤ点亮，按下P3、4键盘时Ｐ1、4、P1、5对应得LＥＤ点亮,按下Ｐ3、5键盘时Ｐ1、6、P１、7对应得LＥD点亮,没有键盘按下时,LED全灭。 三、实验方法

按照步骤进行运行 四、实验步骤

1.将ＢC45文件夹拷贝到Ｃ分区根目录下。

２.将sofｔｗarｅ文件夹拷贝到任意分区根目录下。 3、 安装KEIＬ2集成开发环境及其插件。 4、 分别完成实验1、２ 五、实验结果

1、实验运行结果如下：

ﻩ2、实验运行结果如下:

ﻩ

六、实验结论 １、核心代码如下:

／*＊*＊＊＊*****＊＊***＊**＊*＊**Test*＊******＊****＊＊＊*＊*****＊*＊********＊＊*/

＃ｉnｃlude \"inclｕdeｓ、h＂

#ｄeｆｉne ＴAＳK_STK_ＳIＺE 512ﻩﻩﻩ //任务堆栈长度 #dｅfine Ｎ＿MESSAGES 1２８

ﻩ／/定义消息队列长度

ﻩ／/定义任务堆栈区

OＳ_STＫ StａrtTaskＳｔk[TASK_STK_SIZE];ﻩﻩ ／/定义任务堆栈区 OS＿ＳTK MｙＴａskStk[TＡＳK_STK＿SIZＥ]; ＯS_STＫ YoｕTaskStk[ＴAＳK＿STK_ＳＩZＥ];ﻩ INT16S key; ﻩ chａr*sｓ; char*s；

INＴ８U flag=１；

ｖoiｄ *MsgＧrp[N_MEＳSAＧEＳ];ﻩﻩ ＩNＴ８Ｕ erｒ； ＩNT8U y=0;

ﻩﻩ

IＮT8Ｕ tｉmes=０；

ﻩ

ﻩﻩ ﻩ

/／定义事件控制块

/／声明起始任务

ﻩ

//定义消息指针数组

ﻩ

//用于退出得键

ﻩ／/定义任务堆栈区

／/字符显示位置

ＯS＿EVENT *Ｓtr＿Q;ﻩ

void StａrtTasｋ（voｉd ＊daｔa)；ﻩ ﻩ void YouTaｓk(voｉd *data）;ﻩ void maｉn (void） {

OSIｎit( );

ﻩ

voｉd MｙＴａsk(voｉｄ ＊data）;ﻩ ﻩﻩ／/声明任务

ﻩ／/声明任务

/***********＊*****＊＊*＊*＊*主函数***＊*＊***＊＊*＊*****＊***＊*＊＊*＊**＊*＊／

ﻩﻩ//初始化uCOS_II

//保存Dos环境 ﻩﻩ／/安装uCOS_ＩI中断

PＣ_DOSＳaveＲetｕrn( )； ﻩ

PC_VｅctSet(uCOS, OSＣtｘSw）；ﻩ

PC_ＤｉspClrScr(DISP_FGND_WＨITＥ ＋ ＤＩＳP＿BGND_BLACK);

Str_Ｑ = OSＱCrｅaｔe (&MsgGｒｐ[0］，N＿MESSAGES);ﻩ ＯSＴaskCｒｅａte(ＳtarｔTaｓk, ﻩ(voiｄ*)0,ﻩﻩﻩ ﻩ0); }

ﻩﻩ

／/给任务传递参数

ﻩ/／创建任务ＳtartTask

//创建消息队列

ﻩ&StartTａｓkStｋ[TAＳK＿ＳTＫ_SIZＥ - 1],ﻩﻩ//设置任务堆栈栈顶

ﻩ／/使任务得优先级别为0

ﻩ

ﻩ／/启动多任务管理

OSStart( ）; ﻩ

/＊*＊**＊＊*＊*＊*＊****＊*****任务StaｒｔＴaｓｋ*＊**＊***＊**************＊**＊*＊**/ void StartTaｓk （void *ｐdａta) ｛

#if OS_CRITIＣAL＿MEＴHＯＤ ＝= ３ OＳ_CPＵ_ＳＲ cpu_sr; ＃endiｆ

ｐdaｔa = pｄａta; OS_EＮTＥR_CＲIＴICＡL( );

PC＿VectＳet(０x０8, OSTiｃｋＩSＲ); OＳ_EXIT_ＣＲIＴICＡL( ); ／/OＳＳtａｔInit（ ); ﻩ ﻩ

ﻩﻩﻩ/／初始化统计任务

ﻩ/／创建任务MyTask

OＳTaskCｒｅａｔe(MyTaｓk,

ﻩ（void*)0，ﻩ ﻩ//给任务传递参数

ﻩ&ＭyTaskStk[TASK_STK＿SIZE - １], //设置任务堆栈栈顶 3）;ﻩ

ﻩ//使任务得优先级别为3

ﻩ//创建任务ＹoｕＴask

ﻩ/／给任务传递参数

/／安装时钟中断向量

ＰC_SeｔTｉckＲaｔe（ＯS_TＩCKS＿PER_SＥC);ﻩﻩ//设置uＣOS_II时钟频率

OSTaskCreatｅ(YouTask，ﻩ

(ｖoｉd＊)0,

ﻩ&YouＴasｋStｋ［ＴASＫ＿STK＿SIＺE - 1],ﻩ／/设置任务堆栈栈顶

ﻩﻩ４)；ﻩﻩ ﻩ/／使任务得优先级别为４ OＳQFlｕsｈ(Str_Ｑ); for （;；） ｛ ﻩif(flag) ﻩ{

ﻩs＝\"this is 1 tｉme！\";

OSQPｏsｔFｒonｔ（Str_Q,s);ﻩ/／向消息队列插入一个消息

ﻩﻩs=\"ｔhｉｓ ｉs 2 ｔimｅ！＂；

ﻩﻩOSＱＰｏｓtFront(Ｓtr_Q,s); //向消息队列插入一个消息 ﻩ ﻩ ﻩ

ﻩs=\"ｔhiｓ is 3 tiｍｅ!＂;

ＯSＱＰosｔFroｎt(Str_Q,s);ﻩ//向消息队列插入一个消息 OSQPostFｒont(Str_Q,s）;ﻩ//向消息队列插入一个消息 ﻩｓ=＂this ｉs ５ time!\"；

ＯSQPostFｒｏnt(Stｒ＿Q，s）;ﻩ／/向消息队列插入一个消息

ﻩﻩs=\"ｔｈis is ４ ｔime!\"；

ﻩﻩｓ=\"ｔhiｓ iｓ 6 ｔime!\"；

ﻩﻩＯＳQPostFront(Stｒ_Q,s）; ／/向消息队列插入一个消息

ﻩ ﻩ

ﻩs=\"this iｓ ７ time!\";

OSＱPostFｒoｎt(Str＿Ｑ,ｓ)；ﻩ//向消息队列插入一个消息 flａg=０； ｝

ﻩ//如果按下Eｓｃ键则退出uCＯS_II ﻩif (PC_GeｔＫｅy（&keｙ) ＝= TRUＥ) ﻩ{

if （ｋeｙ == ０x1B）

{

ＰＣ_DOSReturｎ(); ｝ ｝

OSTiｍｅDlｙＨＭＳM(0, 0, 2, 0）;ﻩ//等待1秒 } }

/＊＊＊*＊*******＊****＊**＊***任务ＭｙTａsk*＊****＊****＊＊***＊*＊＊＊＊＊***＊****/ void MｙTaｓk （ｖoid *pｄata) {

#iｆ OS_CRITIＣAL_MEＴＨOD == 3 OS_CPU_SＲ cpu_sｒ; ＃endｉf

pdａｔa ＝ pｄaｔa； ｆoｒ （;;) ｛ ｝

/＊＊***＊＊***＊＊********＊***任务ＹouTａsｋ**＊***********＊*＊****＊*****＊**/ ｖｏid ＹouＴaｓｋ (void *pdａta) ｛

＃ｉf ＯS＿ＣＲＩTＩCAＬ_METHＯD ＝= 3 OS_CPＵ_SR cpu_ｓr; #endif

pdata = pdata； for (;;） { }

／*＊*******＊*＊*********＊**Eｎｄ****＊＊＊*＊******＊**＊**＊*＊****＊＊＊***＊

sｓ=OＳQPeｎｄ（Ｓtr_Q,０,＆err）; ﻩ//请求消息队列 OSTｉｍeＤｌｙHＭSM(０， ０, ２， 0)；ﻩ

／/等待1秒

ＰC＿DｉspSｔr(１0，++y,ｓs,ＤIＳＰ_BGND＿BLＡCK+DＩSP_FGND_ＧREEN ); }

ｓs＝OSQPｅｎｄ(Stｒ_Q,0，＆eｒr); ﻩ/／请求消息队列 ＯSＴｉmｅDｌyHMSＭ（０, ０, 2， 0）; //等待１秒

PC_DispStr(1０，＋+y,ss,DＩSＰ_ＢGND＿BLAＣK+DISP＿FGND_RＥD ）; ｝

＊*＊/

2、实验核心代码如下:

＃ｉｎｃlｕdｅ \"iｎcｌｕdｅｓ、ｈ\" ＃ｉnclｕde \"seｒiａｌ、h\" #defiｎe ＭAXSTKSIＺE 512 ｖoid TAＳK1(voiｄ *ppdata); voｉｄ TASK2(voｉd *ppdaｔa); ｖoiｄ TASK3(voｉｄ *ｐpdａta);

OS_ＳＴK TAＳK1STK［MAXＳTＫＳIZＥ］; OS_STK TASK2STK[ＭAXSTKSIZＥ]； //OS_ＳTK TAＳＫ３STＫ[MAXSTKＳIZE]; OS_EVENT *Ｓｔr_Boｘ； INT８U err； INT８Ｕ ｈｅlｌo;

vｏｉｄ Deｌay(unsｉｇned ｉｎt coｕnt) {

ﻩuｎｓｉgned ｃhar i; ﻩｗｈile(--counｔ != 0)

ﻩｆｏr（ｉ = 0； ｉ < １２5; i++)； ｝

ｖｏiｄ maiｎ(void) {

ﻩOSＩniｔ（）; }

voｉｄ TASK1(ｖoid ＊ppdａta） { ﻩ ﻩﻩ{

ﻩﻩﻩ/／P１=~0x０3；

ppdａｔa＝ppｄata;

ＥT０=1; IｎｉtＴiｍer０(）；

Str＿Box = OＳMboxCreate (（voiｄ*)0);

OSＴａｓkCreaｔe（TAＳＫ1,(ｖoid *)0，&TASK1STK[0],0); OSTａｓkCreaｔe(TＡＳK2,（vｏiｄ *)0，&TASK2STK[0］，1)； //OSTasｋＣreaｔe（TAＳK3,(voiｄ *）０,＆ＴASK３STK[０]，2）; InitSeｒial();

ﻩOSStａrt（）;

ﻩﻩfor(;;)

ﻩ ﻩ ﻩ }

P3 ＝ 0ｘＦF;

ｈｅllo ＝ P３ | 0xC３;

ﻩOSMbｏxＰosｔ(Ｓtr_Bｏx,&hello);

ﻩﻩUａrt0_priｎt(\"ｔａsｋ 1 ｉs ａctived、\\n\"); ＯＳTimｅDlyHＭSＭ（0,0,1,0）;

//ＯSTimeＤly(50); }

ｖｏid TASK２(vｏiｄ ＊ｐpdata） ｛ ﻩﻩ ﻩ ﻩ ﻩ ﻩ ﻩ ﻩ }

七、实验小结

ﻩ这次两个题目一个就是对消息队列得应用，互相传递多个消息得机制，多了一层指针。ﻩｐpdata＝ppdaｔａ; ﻩ ﻩﻩ ﻩﻩ ﻩﻩ ﻩ ﻩ ﻩ ﻩ

fｏｒ（;;) {

ﻩ//Ｐ1＝~0x18；ﻩ ﻩINT8U *ok; sｗitcｈ（*ok){

case 0ｘDF: ｂrｅａk； Ｐ1 = 0x3F; ﻩﻩｃａｓe 0xEＦ: Ｐ1 ＝ 0xCF; ﻩ

breaｋ； case ０xＦ7: ﻩﻩＰ1 = 0ｘＦ７; ﻩﻩﻩｂreａk; ﻩ

ﻩＰ１ = 0xFC；

ｏk = OSMｂｏxPｅnd(Str＿Ｂoｘ,20，＆erｒ);

ﻩﻩﻩ ｃａse 0ｘFB:

ﻩﻩﻩbreak; defaｕlt： ﻩ

ﻩＰ１ = 0xFF; }

ﻩUart０_print（\"task 2 is acｔivｅｄ、、\\n\");

ﻩOSTimeDｌyHMSM(0,0,1,０)；

}

而第二个实验综合性比较强，要涉及uart接口得读取,gpｉｏ接口得应用等,还有要想如何设计自己得任务,开始没有什么思路，最后在老师得启发下终于完成实验,熟悉了ｋeiｌ下得编程。

实验6《内存管理应用》

实验学时： ２ 实验地点: 2０1 实验日期: ２０13/１2/17 一、实验目得

1.实验环境得建立

2.多任务环境下内存管理方法 二、实验内容

１.设计一个含有一个任务得应用程序,该任务负责打印两个起始显示位置不同得相同字符串。要求在任务中申请一个内存块,并把存放字符串显示起始位置得数据变量定义在该内存块中。

2、 设计一个含有3个任务得应用程序,这３个任务分别就是MyTask、YｏuＴask与HｅrＴask。在应用程序中创建一个动态内存分区,该分区有8个内存块,每个内存块得长度为6个字节。应用程序得任务YｏuTａsk与HerTask都在任务运行后请求一个内存块,随后就释放它。任务MyTask也在任务运行后请求一个内存块,但就是要在任务ＭｙTaｓk运行6次后,才释放它所申请得内存块。 为了了解内存分区变化得情况,编写代码来观察分区头指针与已被使用内存块得个数。

3、设计一个有两个任务得应用程序，其中一个任务用来进行两个随机数得加法运算,另一个任务则用来显示结果,要求加法运算得与存放在动态内存中。 三、实验方法

ﻩ按照步骤进行运行 四、实验步骤

1.将ＢＣ4５文件夹拷贝到C分区根目录下。 ２.将soｆtwａre文件夹拷贝到任意分区根目录下。 3、 分别完成实验1、２、３ 五、实验结果

1、实验运行结果如下:

2、实验运行结果如下: 3、

实验运行结果如下: 六、实验结论 ﻩ１、实验核心代码如下: /***

*****＊***＊***＊*＊****＊Test＊＊****************＊＊****＊**＊*****＊

***/

#ｉｎｃｌｕde \"incｌudes、ｈ\"

#dｅfｉne TASK＿ＳＴK_SＩZE 512ﻩ ﻩ

//任务堆栈长度

//定义任务堆栈区

ＯS_ＳTK ＳｔartＴasｋStk［TAＳＫ＿STK_ＳＩZE]； ﻩ OS_MＥM ＊IntBuffer； INT8Ｕ IntPaｒｔ[50][]；

OS＿ＳＴK ＭｙTaskStｋ［TＡＳK_ＳＴK_SIZＥ]; ﻩﻩ//定义任务堆栈区

INT８U ＊IntBlkPtr;

INT1６S key； ﻩﻩﻩﻩ //用于退出得键 ｃｈａｒ*s1＝\"MyTaｓk is runｎinｇ\"; INＴ8U ｅrr;

ﻩﻩﻩﻩﻩ

ﻩ

ﻩ

//声明任务 ﻩﻩ/／声明起始任务

INT8U y=0;ﻩﻩﻩﻩﻩﻩ//字符显示位置ﻩ

voｉd StarｔＴaｓk(void *data); vｏid ＭｙTａsｋ(ｖoid *dａta)；ﻩ void maｉn (vｏiｄ) {

OSInｉｔ( );

ﻩ

/*********＊＊**＊＊***＊**＊**主函数*＊＊＊*＊＊***＊**＊*****＊*＊**＊*＊***＊＊*/

//初始化uＣOＳ_II

//保存Ｄoｓ环境

/／安装uＣOS＿II中断

ＰＣ_ＤOSＳａvｅRetｕrn( );

ＰC_VｅctSet(uCOS， OSCtｘSｗ）;ﻩ

ＰＣ_DｉspCｌrＳcr(DISＰ_FGND_ＷHＩTE + DＩSP_BＧND_BＬＡCK); ＩnｔＢｕｆfer ＝ OSMeｍCrｅａte（InｔＰaｒt,50,,&erｒ); OSＴaｓｋCreａte(ＳtarｔＴask，ﻩ

(ｖｏid*）0,

ﻩ ﻩ

ﻩ//创建任务ＳtarｔTaｓｋ

//设置任务堆栈栈顶

/／给任务传递参数

＆SｔartTaskSｔｋ[TＡSK_STK_SIZE - １],ﻩ

／/使任务得优先级别为0 ﻩﻩ

ﻩ//启动多任务管理

ﻩ０）;ﻩ }

OＳStart( ）;

/********＊***＊**＊**＊***＊任务StartTａｓk＊******＊**＊*****＊*******＊***＊*＊／ ｖoiｄ ＳtaｒtTaｓk （void ＊pdata) {

＃ｉf ＯＳ_ＣRIＴＩCＡL_METHOD ＝= 3 OS_CPＵ＿SR ｃpu＿sr； ＃endｉf

pｄatａ = ｐdａta; OS_ENTEＲ_CRITICAL( ); ＰC_ＶectSet(０x08, OSTicｋISR)； OＳ_EXIT_ＣRITＩＣＡL( ); OＳStaｔIｎit( ）;ﻩﻩ

ﻩ（void＊）0,

ﻩ//初始化统计任务

/／创建任务ＭyTａsk

//设置任务堆栈栈顶

ＯSＴaｓkCreaｔe(MyＴａｓk， ﻩ

ﻩ//给任务传递参数

ﻩ/／安装时钟中断向量

PＣ_SetＴickRate(OS_TICＫＳ_PER＿SEC）;ﻩ /／设置uCOS_ＩＩ时钟频率

＆MyTaｓkStk[TＡSK＿STK_SＩZE - 1],

ﻩﻩ3)；ﻩﻩﻩﻩ／／使任务得优先级别为３ ｆｏr (;;) {

//如果按下Eｓc键则退出ｕCOS_IＩ ﻩiｆ （ＰC_GetKｅｙ(&ｋey） == TRＵE)

{

{

if (kｅy ＝= 0x１B）

PC_ＤOＳReturｎ（ ）; } }

OSＴimeDlyHMSＭ(０, ０, ３， 0);ﻩ／/等待3秒 ｝ ｝

／***＊＊***＊**＊*********＊*＊任务MyＴask******＊**＊*******＊*＊＊*＊*＊*****＊/ vｏｉd MyTask (ｖoid *pdａta） {

＃iｆ OS_CRITIＣAＬ＿METHＯD =＝ ３ OS＿CPU＿SR cpu＿ｓｒ; ＃eｎｄｉf pdata = pdata; for (；;） ｛

IntBlｋPtr=OＳＭemGet ( ﻩﻩ

InｔBuffer, ﻩ );

//内存分区得指针

＆ｅrr

//错误信息

＊ＩｎtBｌkPｔr=1０； ﻩＰＣ_DiｓｐStr(＊IntＢlｋPtr,++ｙ， ﻩ ﻩﻩs1,

DISP_BＧND_BLＡCK+DIＳP_FGNＤ_BLUE );

//内存块所属内存分区得指针

OSMｅmPut (

ﻩ//待释放内存块得指针

/／等待1秒

s１,

ﻩＤＩＳＰ＿BGND_BＬACＫ+ＤISＰ_FGND＿ＧREEN )； *ＩｎtBlkPｔr=20； //ＩｎtBｌkPｔr+＋;

ﻩＰC＿ＤｉspＳtr（*IntBlkPtr,＋+y,

ﻩﻩIntBufｆer, ﻩ ﻩﻩIntBlｋPtrﻩ

ﻩ);

ＯＳＴimeＤlyＨMSM（０, 0, 1, 0); ｝ }

/＊************＊***＊*＊*＊**Ｅnd**＊**＊*＊＊**＊＊*****＊******＊**＊*＊******＊/

2、实验核心代码如下：

/*＊＊*********＊**********＊Tesｔ*＊***＊*＊***＊*＊******＊****＊***＊＊******/ #ｉｎclｕde \"ｉｎｃｌudes、h\"

#defiｎe TASK＿SＴK_SIＺE 512ﻩﻩﻩ

／／任务堆栈长度

ﻩ／／定义任务堆栈区 ﻩﻩ//定义任务堆栈区

//定义任务堆栈区

ＯＳ＿STK StartTａskＳtk［ＴASK_STＫ_SIＺＥ］;ﻩﻩﻩ／/定义任务堆栈区 OS_STK MyTaｓkStｋ[TASK_SＴＫ_ＳIZE]；ﻩ OＳ_STK YouTaskSｔｋ[TASK_ＳTK_SIZE］；

ＯS_STK HerＴａｓｋStｋ[TAＳK＿SＴＫ＿ＳIＺE];ﻩﻩ

IＮT１6S ｋey;ﻩﻩﻩﻩ ｃhaｒ*s;

//用于退出得键

ｃhａｒ*s1=＂ＭyＴaｓk\"; char*s2=\"YouTaｓk\"; chａr*s3=\"ＨerTａsｋ\"; INT8U err; ﻩ ﻩ

ﻩﻩ

IＮT8U y=0; ﻩﻩﻩﻩﻩ/／字符显示位置 INT８Ｕ Timｅs=0； OＳ_MEM *InｔBｕｆfer;ﻩﻩﻩ INT8Ｕ IntPaｒt[8]［６]; INT８U ＊ＩｎｔBlkＰtr;ﻩ OS_MＥＭ_ＤＡTＡ MemInfo;ﻩﻩ void StａrtTaｓk(void *data);

ﻩ

ﻩ//声明起始任务 //声明任务 ﻩ

//声明任务

//声明任务

ｖoiｄ MyＴasｋ(voｉd *daｔa);ﻩ ﻩ voiｄ YoｕTａｓk(voiｄ *daｔa);

／/定义内存控制块指针

//划分分区及内存块

vｏｉd HｅｒＴａｓｋ（voｉｄ *dａｔa)； ｖoid main (void) {

OSＩniｔ（ );ﻩﻩﻩﻩ ﻩ／/初始化ｕCＯS_II PＣ_ＤＯSＳaｖeReｔｕｒn( );ﻩﻩﻩ PC_VeｃtSｅｔ(uＣOS, OSCｔxSw)；

/**＊＊***************＊＊***主函数***＊***＊＊**＊**＊****＊＊****＊＊**＊**＊/

/／保存Dｏｓ环境

ﻩ

//安装uCＯS＿IＩ中断

PＣ＿DispClｒScr(DＩＳＰ_ＦGND_WHITE + ＤISP_BＧND_BLACK); IntBuffｅｒ = OSMemCreatｅ(IｎｔＰarｔ,8,６,&ｅrｒ)；ﻩﻩ/／创建内存分区 OSTaskCrｅatｅ(StａrtTask,

(ｖoid*)0，

ﻩ/／创建任务StartＴａｓk

ﻩ/／给任务传递参数

&StａrtTaskSｔk[TASＫ_STK_SIZE － 1],ﻩﻩ/／设置任务堆栈栈顶

ﻩﻩﻩ//使任务得优先级别为０

ﻩ

／/启动多任务管理

ﻩ0）;ﻩﻩ }

OSStart( );ﻩﻩ

／**＊＊************＊＊＊**＊*任务StartＴasｋ**********＊*******＊＊**＊＊＊*＊＊***/ ｖｏid StaｒtＴａｓk (void *ｐｄaｔa) {

#if ＯS_ＣRITICAＬ_METHOD ＝= 3 ＯS＿CPＵ＿SR cｐu_sr; #enｄiｆ

pdaｔa = ｐｄaｔa; ＯS_ENTER_ＣRIＴＩCＡＬ( )；

ＰC_ＶeｃｔSeｔ(0x０8， OＳTickISＲ)； ﻩ//安装时钟中断向量

ＰC_ＳｅtTｉckRaｔe（OS_TＩCKS＿ＰER_ＳEC);ﻩ ／/设置ｕＣＯS_II时钟频率 OS＿ＥXIT_ＣRITICＡＬ（ ); OSＳtatIｎit（ );

（vｏid*)0,

ﻩ

//初始化统计任务

ﻩ//创建任务ＭyＴａsk

ＯSTaｓkCrｅaｔｅ(MｙＴaｓk,

//给任务传递参数

ﻩﻩ&MｙTaskStk[TASＫ_ＳTＫ_ＳＩZE - １], //设置任务堆栈栈顶 ﻩ ﻩ

ﻩ３);

ﻩ//使任务得优先级别为3

／/创建任务YouＴask

OSTasｋＣreate(YouTask， ﻩ

（void*)0,ﻩﻩﻩ//给任务传递参数

ﻩﻩ/／使任务得优先级别为4

//给任务传递参数

＆YoｕTaskStk[TＡSK_STK_SIZＥ - 1］,ﻩ／/设置任务堆栈栈顶 4）;

OＳＴaskＣrｅaｔe(HerＴask, ﻩﻩ//创建任务HerTask ﻩﻩ(void*)0, ﻩ ﻩ

5);ﻩﻩ

&HerTaskStk[TＡＳＫ_STK_ＳIＺＥ - 1],ﻩ//设置任务堆栈栈顶

//使任务得优先级别为5

for (;;) {

ﻩ//如果按下Esｃ键则退出uCOS_ＩI

ﻩｉf (ＰＣ_GetKey(&kｅｙ） ＝= TRUE） ﻩ｛

if (ｋey ＝= 0x1Ｂ) ﻩ {

PC＿DOSＲetuｒn（ )； } }

ＯSTiｍｅDlyHMＳM(０, 0, 3, 0); } }

／***＊＊＊*＊＊＊*****＊*******＊任务ＭyＴａｓk＊＊**＊＊******＊*＊＊******＊******＊*/

ｖｏid MｙＴａsk (ｖｏid *pdａtａ) {

＃if OS＿CRＩTICAＬ_MEＴHOＤ == 3 OＳ＿CPU＿ＳR cpu＿sｒ; #enｄif

ｐdaｔa ＝ ｐdaｔa; for （;；) { ﻩ ﻩﻩ

ＰC＿DiｓpStr(10,+＋y,

s1,

DIＳＰ_BＧND＿ＢLACK+ＤISP_ＦGＮD＿RED ）;

//等待3秒

ﻩInｔＢlkPtr=ＯＳMemＧet ( ﻩﻩ//请求内存块

ﻩIntBｕffeｒ,ﻩ //内存分区得指针

／/错误信息

＆err

ﻩﻩﻩ);

ＯSMemQuerｙ ( ﻩﻩＩntＢｕffeｒ,

);

／/待查询得内存控制块得指针

&MeｍInｆo

ﻩsｐrinｔf（s,\"％ｄ\",MｅmInfo、OSＦｒeeＬｉst); ﻩ ﻩ ﻩ｝

Times++;

//等待1秒

OSTimeDｌyHMSM(０, ０, １， 0); ｝ }

/**＊*＊******＊***＊********任务YoｕTask＊＊**＊*＊*＊*************＊*******/ ｖoiｄ YoｕTask (ｖｏiｄ *pdatａ) {

#if OS_CRＩTICＡL_ＭEＴHOＤ =＝ ３ OS_CPU_ＳR cpu_sｒ； #endiｆ

pｄaｔa = pdａta; fｏｒ (;;） { ﻩﻩ ﻩﻩ ﻩ ﻩ ﻩﻩ）;

ｓｐrｉntf(ｓ,＂%d＂,MemInfo、ＯSＦrｅeList）;

ﻩPＣ_ＤispStｒ(3０,y,s,DISP_BＧNＤ_BＬAＣK+DISP_FGND_ＹELLOW ); ﻩsｐrintf（s，\"%d\"，ＭemInfo、OSNＵsed)；

PC＿ＤisｐSｔｒ(40，y,s,DIＳＰ_ＢGND_BLACK+ＤIＳP_FGND_YELLOW )；

//释放内存块 ﻩﻩ//内存分区得指针

IntBuｆfer, )； ﻩ

ﻩOSMｅmPｕｔ (ﻩ ﻩ

ＰC_ＤispSｔr(10，++ｙ,ｓ２,DISP_BGND_BＬＡCＫ+ＤISＰ_ＦGＮＤ_YＥLLＯW )； IntBｌｋＰtr=OSMｅmGeｔ ( ﻩ ＩntＢufｆeｒ,

)；

IntBｕffeｒ, ﻩ //待查询得内存控制块得指针 &MemIｎfo

&ｅｒrﻩ ﻩ//错误信息

/／请求内存块

/／内存分区得指针

PC_ＤispStr（30,y，s,ＤＩSＰ_BGND_BLACK+DISP_FＧND_REＤ ); ｓprintf(s,\"%d\"，MemInfo、OSＮＵsed);

PC_DispＳｔr(4０,y,s,DISP_ＢGＮD_BLACK+DＩSP_FGＮD_RＥD ); ｉf(Tｉmeｓ>4） {

OSMeｍPut (ﻩ

ﻩ//释放内存块 //内存分区得指针

ﻩﻩﻩIntBｕｆfer，ﻩﻩ

ﻩ）；

ﻩＩnｔBlｋPｔrﻩﻩﻩ//待释放内存块得指针

OSMｅmQuｅry (

IntBlｋPｔrﻩﻩ //待释放内存块得指针

OＳTimeDｌｙHMSＭ(０， ０, ２, ０）;ﻩﻩ//等待2秒 } ｝

/＊********＊******＊**＊＊*＊*任务HerTask*＊＊＊********＊＊＊****＊＊***＊*****/ void ＨerTask (void *pdata) {

#ｉf ＯS＿CＲITＩＣAL_METHＯD ＝= 3 OS_ＣPU_SR ｃpu＿sr; #endｉf

ｐdａta = ｐdata; for (；;) ｛ ﻩﻩ ﻩﻩ

ＰC＿DispStr(10，＋+y，s3,ＤISP＿BGND_BLACK＋DIＳP_FＧNＤ_GREEN ); IｎtBlｋＰtｒ=OＳMemGet ( ﻩﻩ/／请求内存块 &eｒrﻩ );

ﻩIntBuffer， ﻩ //待查询得内存控制块得指针 ﻩ＆MemInfｏ ﻩ）;

sｐriｎtf（s,\"%ｄ\"，MemInｆｏ、ＯＳFｒｅeList）;

PC＿DispStr(30,y,s,DISＰ＿ＢGND_BLACK+ＤISP_FGND_ＧREEN );

ﻩ//错误信息

ﻩﻩﻩＩntBuffer, ﻩ/／内存分区得指针

OSMemQuery (

ﻩspｒintｆ(s,\"%d\",MemInfo、ＯＳNUsed)；

ﻩPC_DispSｔr(40,ｙ,ｓ,DＩSＰ_BGND_BLACK＋ＤISP_FGND_ＧRＥEＮ )； ﻩ

OSMemPut （ InｔBufｆer,ﻩ

ﻩﻩ／／释放内存块 //内存分区得指针

ﻩﻩＩntBｌkＰtr ﻩ ／／待释放内存块得指针

ﻩﻩ);ﻩ } }

OSTimeＤlyHMＳM(０， 0, 1, 0）;ﻩ／／等待1秒

/**＊*******＊＊*＊**＊******＊End*＊＊*＊*＊＊*****＊*＊＊＊**＊＊*＊****＊***＊****＊/

３、实验核心代码如下:

/**＊****＊****＊***********Tｅｓt*********＊******＊*******＊*******＊****/ #ｉｎcｌude \"includｅｓ、h＂ #inｃｌｕde ＜ｓｔdio、h> #inclｕde #define ＴASK_STK_ＳＩＺE 512ﻩ

//任务堆栈长度

OS_SＴＫ StａrtTaskＳtｋ［ＴASＫ_STK_SIＺＥ];ﻩﻩ /／定义任务堆栈区 ＯS_ＳTK MyＴaskStk[TＡSK_ＳTＫ_SＩZE];ﻩﻩ //定义任务堆栈区 OS＿ＳTK YｏuTaskSｔk[TASＫ_STＫ_SIZE]; ﻩ INT16S key； char*s; ｉｎt ｉntﻩc2; ｉnt c3;

c1;

ﻩ

／／定义任务堆栈区

//用于退出得键

ＩNT8U err； ﻩﻩ ﻩﻩﻩ IＮT8U y＝0; ﻩﻩ INＴ8U Times=0;

ＯS_MEM *IｎtＢufｆｅｒ; ｉnt *IntBlkPtｒ；

ﻩ ﻩ

ﻩ／/定义内存控制块指针 //划分分区及内存块

ｉnｔ ＩnｔPart[８][6]; ﻩ OS_MEM_DATA MｅmInfo;ﻩﻩ

ｖｏid StartTask(vｏid *ｄata);ﻩﻩ ﻩ／/声明起始任务 void MyTａsk(vｏid *ｄatａ);

ﻩ

//声明任务

/／声明任务

void YouTask(vｏid ＊ｄａｔa); ｖｏid main (ｖoid） ｛

OSIｎit( );

ﻩ

//初始化ｕＣＯS_IＩ

//安装ｕCOS_ＩＩ中断

PC_DOSSaｖeRetｕrn( );ﻩﻩﻩ //保存Dos环境 PC_VectSet(uCOS, ＯＳCｔxSｗ); ﻩ

PＣ_DispClｒSｃr(DISP＿FGＮD_WHITE ＋ DIＳP_BＧND_BＬACK)； IntBｕffer ＝ OSＭｅmCreatｅ（InｔPaｒt，8,6,&err)；ﻩ //创建内存分区 OＳTaskCreate(StartTａsk， ﻩﻩ

(void*）0, ﻩﻩﻩ

//给任务传递参数

／/创建任务SｔarｔTask

ﻩ

/／字符显示位置

/*＊****＊**＊***＊****＊*＊＊＊*主函数**＊*＊********＊****＊*******＊**＊**＊／

ﻩ&StartTａskStk［TASＫ_STK_SIZE - １],ﻩﻩ／/设置任务堆栈栈顶 ﻩ0); ﻩﻩﻩﻩ //使任务得优先级别为0 ＯSStａrt（ )；ﻩﻩ ｝

/*****＊**＊***＊****＊*****任务StaｒｔＴask＊*＊＊＊******＊*＊********＊*****＊**/ vｏid StａrｔＴasｋ (void *ｐdatａ) {

＃ｉf ＯS_ＣRITIＣAＬ_METHOD == 3 OS＿CPＵ＿SＲ cｐu＿ｓr; #ｅndｉf

ｐｄａｔa ＝ pdａtａ; ＯS_ＥＮTER_ＣRITICAL（ )； PC_ＶectSet(0x08, ＯSＴicｋＩSR); OS_ＥＸIT_CRITICAL( );

ＯSSｔatIｎit( ); ﻩﻩﻩ//初始化统计任务 OSTaｓkCｒeａte（ＭｙTａsｋ, ﻩ ﻩ

（ｖoid＊)0，

ﻩ

//创建任务MyTasｋ

//给任务传递参数

ﻩ//安装时钟中断向量

／／设置uＣOS_II时钟频率

PC＿SeｔTickＲａte(OＳ＿TIＣKS_PEＲ＿SEC);ﻩ

//启动多任务管理

&MyＴaｓkStk[TASK_SＴＫ_SIZE - １],ﻩ//设置任务堆栈栈顶

/／使任务得优先级别为3

ﻩ

／/创建任务YouTaｓｋ

ﻩ/／给任务传递参数

ﻩﻩ3)；ﻩ ﻩ

OSＴaskＣｒeatｅ(ＹｏｕTask,

(void*)0， 4); ﻩﻩ

&YｏuTaskSｔk[TASK_SＴK_SIＺＥ - 1]， //设置任务堆栈栈顶

//使任务得优先级别为４

for (；；) ｛

ﻩ／／如果按下Ｅｓｃ键则退出ｕCOＳ＿II ﻩiｆ （PＣ_GetＫey（&key) == TＲUE)

{ {

if （ｋey == 0x1B)

PC_ＤＯＳＲetｕｒn( ）; } }

OSＴimｅDｌyHMSM(0, 0, 3, 0）;ﻩ//等待3秒 } ｝

/**＊*＊****＊*＊***********＊任务MyTａsk＊***＊*****＊**＊*****＊*＊*********/ voiｄ MyTａsk （void *pdata） {

＃if ＯＳ_CＲITIＣAL_MＥTHＯD ＝＝ 3 OS_CＰＵ_SR cｐｕ_ｓr; #eｎdif

ｐdata = pdata; for (;;) ｛ ﻩ ﻩ ﻩ

ﻩ

ﻩﻩPC_DispClrＳｃr(DISP_ＦＧND_WHIＴE + DISＰ_BGND_ＢLACK）;

／/请求内存块

/／内存分区得指针 ＆err ﻩﻩ／/错误信息

ﻩ ﻩ

ﻩﻩﻩ

ﻩ

InｔBuffer，

ﻩﻩ

ﻩﻩIntBlkPtr=OSMｅｍＧeｔ ( ﻩ

);

ﻩｃ１=rand(）; sprintf(s,\"%x\",c１）;

ＰC_DiｓpＳtr（35，10＋(ｙ+＋),s，ＤIＳＰ_ＢＧNＤ＿BLACK+DISＰ_ＦＧＮD_Ｒ

EＤ );ﻩ

ｃ2＝raｎｄ（）； sprinｔf(ｓ,\"%ｘ\"，ｃ2)；

PＣ_DiｓpStｒ（３5,1０+(y++),ｓ，DIＳP_ＢGNＤ_BLACK+DＩSP_ＦGＮD＿GＲEＥN ）;

c3=c1＋ｃ2; *IｎtBlkPtr = c３; } }

／**＊*＊＊*＊*****＊*****＊*＊*＊任务ＹouTaｓk*＊***＊***＊******＊＊*＊*＊**＊＊*＊**/

ｖoid ＹoｕTaｓk (void *pdata) {

OSＴｉmeDlｙHMSM(0, 0， 1, 0）;ﻩﻩ/／等待１秒

#if OＳ_ＣRITＩCAL_METHOＤ =＝ 3 OS_CPU_SR ｃpu_ｓr; #endｉf

pdatａ = pdatａ; fｏr (;;) { OW ）; ﻩﻩ

OSMｅmＰuｔ(IｎtBｕffeｒ,InｔBlkＰｔr);

//等待１秒

ﻩ ﻩy=0;

ﻩ OSＴimeＤlyHMＳＭ(0, 0, 1, 0); ｝ }

/*＊＊*＊********＊**＊＊******End*＊************＊＊＊＊*＊***＊＊*******＊****＊/

ｓｐrinｔf(s,\"％x＂，*ＩntBlkＰｔr);

PC_DｉspStｒ(３5,10+（y+＋),s,DISP_ＢＧND_BLACK+ＤISP_FGND_YELＬ

七、实验小结

ﻩ本次实验就是对于内存分区得操作,对于UC/OＳ得内存管理与信号量,消息队列以及消息邮箱得操作类似,UC/OS与c中得malloｃ分配内存方式不同,就是固定得区间,便于管理。经过此次实验对UＣ/os得内存分区操作有了进一步得了解。