ucosII实验报告

更新时间：2024-02-29 14:57:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

ucosii实验报告总结推荐度：
相关推荐

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

实验学时： 2 实验地点：二综x203 实验日期： 2013/12/13

一、实验目的

1．实验环境的建立 2．任务的接口函数的应用二、实验内容

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

2．在任务Task1中在创建一个任务Task2 。当程序运行后，任务Task1的工作在显示器上显示一个字符“M”；Task2 则是在显示器上显示字符 “Y”。

3. 要求任务Task2运行20次后，挂起任务Task1；任务Task2运行40次后，恢复任务Task1。

4. 当任务Task1运行5次时，用函数OSSchedLock()对调度器进行加锁；而当任务Task1运行到第10次时，再用函数OSSchedUnlock()对调度器进行解锁，并运行该程序。

5. 使任务Task1能删除任务Task2。三、实验方法

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

1．将BC45文件夹拷贝到C分区根目录下。 2．将software文件夹拷贝到任意分区根目录下。 3. 分别完成实验1、2、3、4、5 五、实验结果

1. DOS窗口每秒显示一个字符“M”。每行显示10个“M”字符，行与行的间隔是一行。按ESC键程序退出

2. DOS窗口交替显示字符\和“Y”，每隔一秒显示一次。每行显示10个字符，行与行之间的间隔是一行。按ESC键程序退出

3.DOS窗口开始交替显示字符\和“Y”，显示20次以后，Task1挂起，只显示“Y”，当Task2运行40次以后，Task1恢复，然后开始Task1,Task2交替运行。

4.DOS窗口开始交题显示字符\和“Y”,显示5次以后，Task1将任务调度器上锁，此时只有“M”打印，当Task1运行10次后，Task1,Task2开始交替运行。

5.DOS窗口开始交替显示字符“M”和“Y”，显示10次后，只显示“Y” 六、实验结论

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

程序：/******** * Exercise 2 - 1 * author: csu chenan * time: 2013 - 12 - 12 ********/

#include \

#define TASK_STK_SIZE 256

OS_STK MyTaskStk[TASK_STK_SIZE]; INT16S key; INT8U x = 0, y = 0;

void MyTask(void *pdata){ #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

OS_ENTER_CRITICAL(); PC_VectSet(0X08, OSTickISR); PC_SetTickRate(OS_TICKS_PER_SEC); OS_EXIT_CRITICAL(); OSStatInit(); for(;;){ if(x > 10){ x = 0; y = y + 2;

}

PC_DispChar(x, y,

*(char*)pdata,,DISP_BGND_BLACK

DISP_FGND_WHITE);

x = x + 1;

if(PC_GetKey(&key) == 1){

}

if(key == 0x1B){ }

PC_DOSReturn();

OSTimeDlyHMSM(0,0,1,0);

void main(void){ } 2.

OSStart();

OSTaskCreate(MyTask, ch, &MyTaskStk[TASK_STK_SIZE-1], 0); PC_DOSSaveReturn(); PC_VectSet(uCOS, OSCtxSw);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK); OSInit(); char * ch = \

程序源代码： /******** * Exercise 2 - 2 * author: csu chenan

* time: 2013 - 12 - 13 ********/

#include \

#define My_TASK1_STK_SIZE 256 #define My_TASK2_STK_SIZE 256

OS_STK MyTask1Stk[My_TASK1_STK_SIZE]; OS_STK MyTask2Stk[My_TASK2_STK_SIZE];

INT16S key; INT8U x = 0, y = 0;

void MyTask2(void *pdata){ #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

OS_ENTER_CRITICAL(); PC_VectSet(0x80, OSTickISR);

PC_SetTickRate(OS_TICKS_PER_SEC); OS_EXIT_CRITICAL(); for(;;){ if(x > 10){ x = 0; y = y + 2;

}

PC_DispChar(x, y,

*(char*)pdata,

DISP_FGND_WHITE);

x = x + 1;

if(PC_GetKey(&key) == 1){ if(key == 0x1B){ PC_DOSReturn();

}

DISP_BGND_BLACK

}

OSTimeDlyHMSM(0,0,1,0);

}

void MyTask1(void *pdata){ #if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

char *ch = \ pdata = pdata;

OS_ENTER_CRITICAL(); PC_VectSet(0X08, OSTickISR); PC_SetTickRate(OS_TICKS_PER_SEC); OS_EXIT_CRITICAL();

OSStatInit();

OSTaskCreate(MyTask2, ch, &MyTask2Stk[My_TASK2_STK_SIZE - 1], 1); for(;;){ if(x > 10){ x = 0; y = y + 2;

}

PC_DispChar(x, y,

*(char*)pdata,

DISP_BGND_BLACK

DISP_FGND_WHITE);

x = x + 1;

if(PC_GetKey(&key) == 1){ if(key == 0x1B){ PC_DOSReturn();

}

OSTimeDlyHMSM(0,0,1,0);

}

六、实验结论

对实验数据和结果进行分析描述，给出实验取得的成果和结论。 1. OS_CPU_C.c

#if OS_CPU_HOOKS_EN > 0

INT16U d=0; INT16U d1=0;

void OSTimeTickHook (void) {

char* s0 = \ char* s1 = \

char* s2 = \ char s[8];

if(d == 500) {

PC_DispStr(14,4,s1,DISP_BGND_BLACK+DISP_FGND_WHITE); PC_DispStr(18,4,s0,DISP_BGND_BLACK+DISP_FGND_WHITE); PC_DispStr(22,4,s2,DISP_BGND_BLACK+DISP_FGND_WHITE); sprintf(s,\

PC_DispStr(31,d1+5,s,DISP_BGND_BLACK+DISP_FGND_WHITE); d = 0; d1 += 1;

} d += 1; } #endif

#include \

#define TASK_STK_SIZE 512 OS_STK MyTaskStk[TASK_STK_SIZE]; INT16S key; INT8U x=0,y=0; void main (void) {

char* s_M=\*/

PC_DOSSaveReturn(); /* Save environment to return to DOS */

PC_VectSet(uCOS, OSCtxSw); /* Install uC/OS-II's context switch vector */

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK); OSTaskCreate(MyTask,s_M, &MyTaskStk[TASK_STK_SIZE - 1], 0); */ }

void MyTask(void *pdata) {

#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr; #endif

void MyTask(void *data);

OSInit(); /* Initialize uC/OS-II

OSStart(); /* Start multitasking

pdata = pdata; /* Prevent compiler warning */

OS_ENTER_CRITICAL();

PC_VectSet(0x08, OSTickISR); PC_SetTickRate(OS_TICKS_PER_SEC); OS_EXIT_CRITICAL();

OSStatInit(); for (;;) { } }

2.程序：OS_COPU_C.c #if OS_CPU_HOOKS_EN > 0

extern BOOLEAN InterKey; INT16U InterCtr = 0;

void OSTimeTickHook (void)

if(x>10) { }

PC_DispChar(x,y,*(char*)pdata,DISP_BGND_BLACK+DISP_FGND_WHITE); x+=1;

if(PC_GetKey(&key) == 1) { }

OSTimeDlyHMSM(0,0,1,0);

if(key == 0x1B) { }

PC_DOSReturn(); x=0; y+=2;

{

if(InterCtr == 10000) { }

InterCtr++; } #endif Test.c

#include \

#define TASK_STK_SIZE 512

//任务堆栈长度

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

OS_STK MyTaskStk[TASK_STK_SIZE]; OS_STK YouTaskStk[TASK_STK_SIZE]; OS_STK InterTaskStk[TASK_STK_SIZE]; INT16S key;

INT8U x=0,y=0;

InterKey = 1;

//用于退出uCOS_II的键 //字符显示位置 //声明任务 //声明任务 //声明任务

BOOLEAN InterKey=FALSE; void MyTask(void *data); void YouTask(void *data); void InterTask(void *data); void main (void) {

char* s_M=\ OSInit( );

//定义要显示的字符 //保存Dos环境

//安装uCOS_II中断

//初始化uCOS_II

PC_DOSSaveReturn( );

PC_VectSet(uCOS, OSCtxSw); OSTaskCreate( }

void MyTask (void *pdata)

MyTask, s_M, 0 );

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);

//创建任务MyTask //给任务传递参数

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

&MyTaskStk[TASK_STK_SIZE - 1],

//任务的优先级别为0

//启动多任务管理

OSStart( );

OSTimeDly(300); } }

void YouTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;) { if (x>50)

{ x=0; y+=2; }

//显示字符的位置 //延时100个时钟节拍

PC_DispChar(x, y,

*(char*)pdata,

DISP_BGND_BLACK+DISP_FGND_WHITE );

x += 1;

//延时500个时钟节拍

} } 4.

OSTimeDly(500);

#include \

#define TASK_STK_SIZE 512 INT16S key; INT32U stime; INT8U x=0; void main (void) {

OSInit();

//初始化uCOS_II

//声明一个任务

//用于退出uCOS_II的键

//任务堆栈长度

//定义任务堆栈区

OS_STK TaskStartStk[TASK_STK_SIZE];

void MyTask(void *data);

PC_DOSSaveReturn();

//保存Dos环境

//安装uCOS_II中断

PC_VectSet(uCOS, OSCtxSw); OSTaskCreate(MyTask, }

void MyTask (void *pdata) { char s[5];

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

OS_ENTER_CRITICAL();

(void*)0, 0);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);

//创建任务MyTask

//给任务传递参数

//使任务MyTask的优先级别为0

//启动uCOS_II的多任务管理

&TaskStartStk[TASK_STK_SIZE - 1],//设置任务堆栈栈顶指针

OSStart();

PC_VectSet(0x08, OSTickISR); //安装uCOS_II时钟中断向量 PC_SetTickRate(OS_TICKS_PER_SEC); //设置uCOS_II时钟频率 OS_EXIT_CRITICAL(); OSStatInit(); for (;;) {

if (x==10)

{

OSTimeSet(10); }

stime=OSTimeGet(); sprintf(s,\ PC_DispStr(5, 2,

DISP_BGND_BLACK+DISP_FGND_WHITE );

x += 1;

//在x，y位置显示s中的字符

//初始化uCOS_II的统计任务

//如果按下Esc键则退出uCOS_II if (PC_GetKey(&key) == TRUE) {

if (key == 0x1B)

{

PC_DOSReturn(); } }

OSTimeDlyHMSM(0, 0, 1, 0); } } 5.

#include \#include \

#define MAXSTKSIZE 512

void TASK1(void *ppdata); void TASK2(void *ppdata); void TASK3(void *ppdata);

OS_STK TASK1STK[MAXSTKSIZE]; OS_STK TASK2STK[MAXSTKSIZE]; OS_STK TASK3STK[MAXSTKSIZE];

INT8U times=1;

void main(void) {

InitTimer0();

OSStart();

InitSerial();

//创建三个任务

OSTaskCreate(TASK1,(void *)0,&TASK1STK[0],1); OSTaskCreate(TASK2,(void *)0,&TASK2STK[0],2); OSTaskCreate(TASK3,(void *)0,&TASK3STK[0],3);

OSInit();

//运行次数

//等待

}

void TASK1(void *ppdata) { }

void TASK2(void *ppdata) { }

void TASK3(void *ppdata) {

ppdata = ppdata; for(;;) {

Uart0_print(\

//Uart0_printR(\OSIdleCtr=OSIdleCtr; OSTimeDlyHMSM(0,0,1,0);

ppdata=ppdata; for(;;) { }

Uart0_print(\

//Uart0_printR(\OSIdleCtr=OSIdleCtr; OSTimeDlyHMSM(0,0,1,0);

for(;;) { }

Uart0_print(\ OSIdleCtr=OSIdleCtr; OSTimeDlyHMSM(0,0,1,0); ppdata=ppdata; ET0=1;

}

七、实验小结

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

实验3《信号量应用》

实验学时： 2 实验地点：综二实验室x201 实验日期： 2013/12/16

一、实验目的

1．实验环境的建立

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

1．设计应用程序中有2个用户任务：MyTask和YouTask。这两个任务都要访问同一个共享资源s，但YouTask访问s需要的时间长一些（本例中使用了一个循环来模拟访问的时间），而MyTask访问s的时间要短一些，这样就不可避免的出现了在任务YouTask访问s期间，任务MyTask也来访问s，从而出现了干扰，观察干扰现象，解释原因。

2.3.

访问共享资源s，以解决实验1中的冲突问题。果。(不做) 三、实验方法

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

1．将BC45文件夹拷贝到C分区根目录下。 2．将software文件夹拷贝到任意分区根目录下。 3. 分别完成实验1、2、3。五、实验结果

1.实验运行结果如下：

在应用程序中定义一个全局变量ac_key来作为信号量，并根据该信号量的状态来在实验2中，把使用的信号量改为互斥型信号量，然后运行该程序并观察其运行结

2.实验运行结果如下：

3.实验运行结果如下：

六、实验结论

对实验数据和结果进行分析描述，给出实验取得的成果和结论。 1.核心代码如下：

/************************Test************************************/ #include \

#define TASK_STK_SIZE 512

OS_STK MyTaskStk[TASK_STK_SIZE]; //定义任务堆栈区 OS_STK YouTaskStk[TASK_STK_SIZE]; //定义任务堆栈区 INT16S key; INT8U char *s=\;

//用于退出uCOS_II的键 //字符显示位置

y1=0,y2=0;

//任务堆栈长度

//定义要显示的字符

void MyTask(void *data);

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

void YouTask(void *data); void main (void) {

OSInit( );

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

//初始化uCOS_II

PC_DOSSaveReturn( ); //保存Dos环境 //安装uCOS_II中断 //创建任务MyTask

//给任务传递参数

PC_VectSet(uCOS, OSCtxSw); OSTaskCreate(MyTask, }

(void*)0, 0);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);

&MyTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶指针

//使任务的优先级别为0 //启动多任务管理

OSStart( );

/***********************任务MyTask********************************/

void MyTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

INT8U err;

pdata = pdata; OS_ENTER_CRITICAL( );

PC_VectSet(0x08, OSTickISR); OS_EXIT_CRITICAL( ); OSStatInit( );

(void*)0, 2);

//初始化统计任务 //创建任务YouTask //给任务传递参数

OSTaskCreate(YouTask,

//安装时钟中断向量 //设置uCOS_II时钟频率

PC_SetTickRate(OS_TICKS_PER_SEC);

&YouTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶指针

//使任务的优先级别为2

for (;;) {

s=\;

PC_DispStr(5, ++y1,

DISP_BGND_BLACK+DISP_FGND_WHITE);

//显示字符串

//如果按下Esc键则退出uCOS_II

if (PC_GetKey(&key) == TRUE) {

if (key == 0x1B)

{

PC_DOSReturn( ); } } } }

/************************任务YouTask******************************/ void YouTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

INT8U err; pdata = pdata; for (;;)

{

s=\;

PC_DispStr(28, ++y2,

DISP_BGND_BLACK+DISP_FGND_WHITE );

//置OSTime为0

//显示字符串

//等待200个时钟节拍

OSTimeDly(200);

OSTimeSet(0); { }

while(OSTime<500)

PC_DispStr(55, y2,

DISP_BGND_BLACK+DISP_FGND_YELLOW );

//等待10个时钟节拍

//显示字符串

OSTimeDly(10); } }

/************************End**************************************/

2.实验核心代码如下：

/************************Test**************************************/ #include \

#define TASK_STK_SIZE 512

OS_STK MyTaskStk[TASK_STK_SIZE]; //定义任务堆栈区 OS_STK YouTaskStk[TASK_STK_SIZE]; //定义任务堆栈区 INT16S key; INT8U

//用于退出uCOS_II的键 //字符显示位置

y1=0,y2=0;

//任务堆栈长度

BOOLEAN ac_key; //定义信号量

char* s=\原始数据\;

//定义要显示的字符

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

void MyTask(void *data);

void YouTask(void *data); void main (void) {

OSInit( ); ac_key=1;

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

//初始化uCOS_II

//设置信号量初值 //保存Dos环境 //安装uCOS_II中断 //创建任务MyTask

//给任务传递参数

PC_DOSSaveReturn( );

PC_VectSet(uCOS, OSCtxSw); OSTaskCreate(MyTask,

OSStart( ); }

(void*)0, 0);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);

&MyTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶指针

//使任务的优先级别为0 //启动uCOS_II的多任务管理

/***********************任务MyTask********************************/

void MyTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif INT8U err;

pdata = pdata; OS_ENTER_CRITICAL( );

PC_VectSet(0x08, OSTickISR); OS_EXIT_CRITICAL( ); OSStatInit( );

(void*)0, 2);

//初始化uCOS_II的统计任务 //创建任务MyTask //给任务传递参数

OSTaskCreate(YouTask,

//安装uCOS_II时钟中断向量 //设置uCOS_II时钟频率

PC_SetTickRate(OS_TICKS_PER_SEC);

&YouTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶指针

//使任务的优先级别为2

for (;;) {

if(ac_key)

{

ac_key=FALSE;

//使信号量无效 //显示字符的位置

s=\;

PC_DispStr(5, ++y1,

DISP_BGND_BLACK+DISP_FGND_WHITE); ac_key=TRUE;

//发信号

}

if (PC_GetKey(&key) == TRUE) {

//如果按下Esc键则退出uCOS_II

if (key == 0x1B)

{

PC_DOSReturn( ); } } } }

/************************任务YouTask****************************/ void YouTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

INT8U err; pdata = pdata; for (;;) {

if(ac_key)

{ }

//等待10个时钟节拍

ac_key=FALSE;

//使信号量为无信号 //显示字符串

//等待20个时钟节拍

OSTimeDly(20);

s=\;

PC_DispStr(28, ++y2,

DISP_BGND_BLACK+DISP_FGND_WHITE );

//置OSTime为0

OSTimeSet(0); { }

while(OSTime<500)

PC_DispStr(55, y2,

DISP_BGND_BLACK+DISP_FGND_WHITE );

//发信号

//显示字符串

ac_key=TRUE;

OSTimeDly(10); } }

/************************End**************************************/

3.实验核心代码如下：

/************************Test*************************************/ #include \ #define TASK_STK_SIZE 512

//任务堆栈长度

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

OS_STK StartTaskStk[TASK_STK_SIZE]; OS_STK Task1Stk[TASK_STK_SIZE]; OS_STK Task2Stk[TASK_STK_SIZE]; OS_STK Task3Stk[TASK_STK_SIZE]; INT16S key;

char*s1=\; char*s2=\; char*s3=\; char*ss=\; INT8U err; INT8U y=0;

//字符显示位置

//定义事件控制块

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

//用于退出的键

INT32U Times=0; OS_EVENT *Mutexp;

void StartTask(void *data); void Task1(void *data); void Task2(void *data); void Task3(void *data); void main (void) {

OSInit( );

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

//初始化uCOS_II //保存Dos环境

//安装uCOS_II中断

//定义信号量

PC_DOSSaveReturn( );

PC_VectSet(uCOS, OSCtxSw);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK); Mutexp = OSMutexCreate (1,&err); OSTaskCreate(StartTask, }

/***********************任务StartTask*******************************/ void StartTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

(void*)0, 0);

//创建任务StartTask

//设置任务堆栈栈顶

//给任务传递参数

&StartTaskStk[TASK_STK_SIZE - 1],

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

//启动多任务管理

OSStart( );

pdata = pdata; OS_ENTER_CRITICAL( );

PC_VectSet(0x08, OSTickISR); OS_EXIT_CRITICAL( );

OSStatInit( );

(void*)0, 3);

//初始化统计任务

//创建任务Task1

//设置任务堆栈栈顶

OSTaskCreate(Task1,

//安装时钟中断向量

//设置uCOS_II时钟频率

PC_SetTickRate(OS_TICKS_PER_SEC);

//给任务传递参数

&Task1Stk[TASK_STK_SIZE - 1],

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

//创建任务Task2

//设置任务堆栈栈顶

//给任务传递参数

OSTaskCreate(Task2,

(void*)0, 4);

&Task2Stk[TASK_STK_SIZE - 1],

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

//创建任务Task3

//设置任务堆栈栈顶

//给任务传递参数

OSTaskCreate(Task3,

(void*)0, 5);

&Task3Stk[TASK_STK_SIZE - 1],

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

for (;;) {

//如果按下Esc键则退出uCOS_II

if (PC_GetKey(&key) == TRUE) {

if (key == 0x1B)

{

PC_DOSReturn( ); } }

OSTimeDlyHMSM(0, 0, 3, 0); } }

/************************任务Task1*******************************/ void Task1 (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;) {

OSTimeDlyHMSM(0, 0, 0, 300); {

//等待300毫秒 //等待3秒

PC_DispStr(10,++y,

ss,

DISP_BGND_BLACK+DISP_FGND_YELLOW );

//请求信号量

OSMutexPend(Mutexp,0,&err);

PC_DispStr(10,++y,

s1,

DISP_BGND_BLACK+DISP_FGND_RED );

OSMutexPost(Mutexp); //发送信号量

//等待200毫秒

}

OSTimeDlyHMSM(0, 0, 0, 200); } }

/************************任务Task2******************************/ void Task2 (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;)

{ PC_DispStr(10,++y,

s2,

DISP_BGND_BLACK+DISP_FGND_WHITE );

//等待100毫秒

OSTimeDlyHMSM(0, 0, 0, 100); } }

/************************任务Task3******************************/ void Task3 (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;)

{

OSMutexPend(Mutexp,0,&err); //请求信号量 PC_DispStr(10,++y,

s3,

DISP_BGND_BLACK+DISP_FGND_WHITE );

for(Times;Times<20000000;Times++)

{ } Times=0;

OSMutexPost(Mutexp);

//发送信号量

OS_Sched();

OSTimeDlyHMSM(0, 0, 0, 100); //等待100毫秒 } }

/************************End**************************************/

七、实验小结

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

实验4《消息邮箱应用》

实验学时： 2 实验地点： 201 实验日期： 2013/12/13

一、实验目的

1．实验环境的建立

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

1．设计一个利用消息邮箱进行通信的例子：有两个任务MyTask和YouTask。由于任务YouTask要向任务MyTask发送消息，因此定义了一个全局的指针变量msg_p作为邮箱来传递消息的指针。

设计一个应用程序，该程序有两个任务MyTask和YouTask。在任务MyTask中用一

个变量Times记录任务MyTask的运行次数，并将其作为消息用邮箱Str_Box发给任务YouTask，且由任务YouTask显示出来。三、实验方法

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

1．将BC45文件夹拷贝到C分区根目录下。 2．将software文件夹拷贝到任意分区根目录下。 3. 分别完成实验1、2 五、实验结果

1.实验运行结果如下：

2.实验运行结果如下：

六、实验结论 1.实验核心代码如下：

/************************Test*************************************/

#include \ #define TASK_STK_SIZE 512

//任务堆栈长度

//定义任务堆栈区 //定义任务堆栈区 //定义任务堆栈区 //用于退出的键 //字符显示位置

OS_STK StartTaskStk[TASK_STK_SIZE]; OS_STK MyTaskStk[TASK_STK_SIZE]; OS_STK YouTaskStk[TASK_STK_SIZE]; INT16S key; INT8U void *msg_p;

y1=0,y2=0;

//消息邮箱 //声明起始任务

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

void StartTask(void *data); void MyTask(void *data); void YouTask(void *data); void main (void) {

OSInit( );

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

//初始化uCOS_II //安装uCOS_II中断 //创建任务MyTask //给任务传递参数

PC_DOSSaveReturn( ); //保存Dos环境

PC_VectSet(uCOS, OSCtxSw); OSTaskCreate(StartTask,

(void*)0,

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);

&StartTaskStk[TASK_STK_SIZE - 1],//设置任务堆栈栈顶

}

0);

//使任务的优先级别为0 //启动多任务管理

OSStart( );

/***********************任务StartTask*******************************/ void StartTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata; OS_ENTER_CRITICAL( );

PC_VectSet(0x08, OSTickISR); OS_EXIT_CRITICAL( );

OSStatInit( );

//初始化统计任务 //给任务传递参数 //使任务的优先级别为1 //创建任务YouTask //给任务传递参数 //使任务的优先级别为2

OSTaskCreate(MyTask,

(void*)0, 1);

//创建任务MyTask

//安装时钟中断向量

//设置uCOS_II时钟频率

PC_SetTickRate(OS_TICKS_PER_SEC);

&MyTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶

OSTaskCreate(YouTask,

(void*)0, 2);

&YouTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶

for (;;) {

//如果按下Esc键则退出uCOS_II

if (PC_GetKey(&key) == TRUE) {

if (key == 0x1B)

{

PC_DOSReturn( ); } }

OSTimeDlyHMSM(0, 0, 3, 0); } }

/************************任务MyTask*******************************/ void MyTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

//等待3秒

for (;;)

//显示字符串

{ PC_DispStr(5, ++y1,

if(msg_p!=(void*) 0) { }

//等待1秒

PC_DispStr(15,y1,

msg_p,

//显示收到的消息

DISP_BGND_BLACK+DISP_FGND_RED );

//使消息邮箱为空

//请求消息

DISP_BGND_BLACK+DISP_FGND_WHITE );

msg_p=(void*) 0;

OSTimeDlyHMSM(0, 0, 1, 0); } }

/************************任务YouTask******************************/ void YouTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

char*s=\; pdata = pdata; for (;;) {

PC_DispStr(40, ++y2,

if(OSTimeGet( )>500 && msg_p==(void*) 0)

{

msg_p=s;

//发送消息

PC_DispStr(50,y2,

\, DISP_BGND_BLACK+DISP_FGND_RED );

//等待1秒

DISP_BGND_BLACK+DISP_FGND_WHITE );

//显示字符串

//定义消息

}

OSTimeDlyHMSM(0, 0, 2, 0); } }

/************************End**************************************/

2.核心代码如下：

/************************Test*************************************/

#include \ #define TASK_STK_SIZE 512

//任务堆栈长度

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

OS_STK StartTaskStk[TASK_STK_SIZE]; OS_STK MyTaskStk[TASK_STK_SIZE]; OS_STK YouTaskStk[TASK_STK_SIZE]; INT16S key; char*s; char*ss; INT8U err; INT8U y=0;

//字符显示位置

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

//用于退出的键

INT32U Times=0; OS_EVENT *Str_Box;

void StartTask(void *data); void MyTask(void *data);

void YouTask(void *data); void main (void) {

OSInit( );

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

//初始化uCOS_II //保存Dos环境

//安装uCOS_II中断

//创建互斥型信号量

PC_DOSSaveReturn( );

PC_VectSet(uCOS, OSCtxSw);

PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK); Str_Box = OSMboxCreate ((void*)0); OSTaskCreate(StartTask, }

/***********************任务StartTask*******************************/ void StartTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata; OS_ENTER_CRITICAL( );

PC_VectSet(0x08, OSTickISR); OS_EXIT_CRITICAL( );

OSStatInit( );

(void*)0,

//初始化统计任务 //创建任务MyTask

OSTaskCreate(MyTask,

//安装时钟中断向量

//设置uCOS_II时钟频率

PC_SetTickRate(OS_TICKS_PER_SEC);

(void*)0, 0);

//创建任务StartTask

//设置任务堆栈栈顶

//给任务传递参数

&StartTaskStk[TASK_STK_SIZE - 1],

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

//启动多任务管理

OSStart( );

//给任务传递参数

&MyTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶 3);

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

//创建任务YouTask

//给任务传递参数

OSTaskCreate(YouTask,

(void*)0, 4);

&YouTaskStk[TASK_STK_SIZE - 1], //设置任务堆栈栈顶

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

for (;;) {

//如果按下Esc键则退出uCOS_II if (PC_GetKey(&key) == TRUE) { {

if (key == 0x1B) PC_DOSReturn(); } }

OSTimeDlyHMSM(0, 0, 3, 0); } }

/************************任务MyTask*******************************/ void MyTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3 OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;) {

sprintf(s,\ ,Times); OSMboxPost(Str_Box,s);

Str_Box->OSEventPtr,//s,

DISP_BGND_BLACK+DISP_FGND_WHITE );*/

//等待1秒 //发送消息

//等待3秒

/*PC_DispStr(10,++y,

Times++;

OSTimeDlyHMSM(0, 0, 1, 0); } }

/************************任务YouTask******************************/ void YouTask (void *pdata) {

#if OS_CRITICAL_METHOD == 3

OS_CPU_SR cpu_sr; #endif

pdata = pdata;

for (;;) {

ss=OSMboxPend(Str_Box,10,&err);

ss,

DISP_BGND_BLACK+DISP_FGND_WHITE );

//等待1秒

PC_DispStr(10,++y,

OSTimeDlyHMSM(0, 0, 1, 0); } }

/************************End**************************************/

七、实验小结

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

实验5《消息队列应用》

实验学时： 2 实验地点： 201 实验日期： 2013/12/15

一、实验目的

1．实验环境的建立

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

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

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

1．将BC45文件夹拷贝到C分区根目录下。 2．将software文件夹拷贝到任意分区根目录下。 3. 安装KEIL2集成开发环境及其插件。 4. 分别完成实验1、2 五、实验结果

1.实验运行结果如下：

2.实验运行结果如下：

六、实验结论 1.核心代码如下：

/************************Test*************************************/ #include \

#define TASK_STK_SIZE 512 #define N_MESSAGES 128

//任务堆栈长度 //定义消息队列长度

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

OS_STK StartTaskStk[TASK_STK_SIZE]; OS_STK MyTaskStk[TASK_STK_SIZE]; INT16S key; char*ss; char*s; INT8U flag=1;

void *MsgGrp[N_MESSAGES]; INT8U err; INT8U y=0;

INT8U times=0;