嵌入式报告打印.docx

嵌入式报告打印.docx

《嵌入式报告打印.docx》由会员分享，可在线阅读，更多相关《嵌入式报告打印.docx（20页珍藏版）》请在冰豆网上搜索。

嵌入式报告打印

本科实验报告

课程名称：

嵌入式操作系统

实验项目：

实验一：

任务的基本管理

实验地点：

学科楼506实验室

专业班级：

计Z1101学号：

2011001488

学生姓名：

郭晓云

指导教师：

张兴忠

2014年04月15日

太原理工大学学生实验报告

学院名称

计算机科学与技术

专业班级

计Z1101

学号

2011001488

学生姓名

郭晓云

实验日期

2014-04-15

成绩

课程名称

嵌入式操作系统

实验题目

任务的基本管理

一、实验目的和要求

（1）理解任务管理的基本原理，了解任务的各个基本状态及其变迁过程；

（2）掌握µC/OS-II中任务管理的基本方法（创建、启动、挂起、解挂任务）；

（3）熟练使用µC/OS-II任务管理的基本系统调用。

二、实验器材（设备、元器件）：

硬件环境：

PC计算机；软件环境：

WIN98/2000/XP、BC4.5（BorlandC++4.5）、tasm.exe；

三、实验内容

可剥夺型内核，基于优先级调度。

操作系统总是使处于就绪态的优先级最高的任务首先获得CPU的使用权。

通过使用系统提供的函数控制任务实现各种功能。

为了展现任务的各种基本状态及其变迁过程，本实验设计Task0、Task1两个任务：

任务Task0不断地挂起自己，再被任务Task1解挂，两个任务不断地切换执行。

通过本实验，可以清晰地了解到任务在各个时刻的状态以及状态变迁的原因。

注意：

图中的栅格并不代表严格的时间刻度，而仅仅表现各任务启动和执行的相对先后关系。

四、实验步骤

整个应用的运行流程如图所示，其描述如下：

（1）系统经历一系列的初始化过程后进入boot_card（）函数，在其中调用ucBsp_init（）进行板级初始化后，调用main（）函数；

（2）main（）函数调用OSInit（）函数对µC/OS-II内核进行初始化，调用OSTaskCreate创建起始任务TaskStart；

（3）main（）函数调用函数OSStart（）启动µC/OS-II内核的运行，开始多任务的调度，执行当前优先级最高的就绪任务TaskStart；

（4）TaskStart完成如下工作：

a、安装时钟中断并初始化时钟，创建2个应用任务；

b、挂起自己（不再被其它任务唤醒），系统切换到当前优先级最高的就绪任务Task0。

之后整个系统的运行流程如下：

t1时刻，Task0开始执行，它运行到t2时刻挂起自己；

t2时刻，系统调度处于就绪状态的优先级最高任务Task1执行，它在t3时刻唤醒Task0，后者由于优先级较高而抢占CPU；

Task0执行到t4时刻又挂起自己，内核调度Task1执行；

Task1运行至t5时刻再度唤醒Task0；

……

系统启动后，经历一系列的初始化过程，进入main（）函数，这是我们编写实现应用程序的起点。

首先需要在main（）函数里创建起始任务TaskStart：

OSTaskCreate（TaskStart,（void*）0,&TaskStartStk[TASK_STK_SIZE-1],4）;

TaskStart任务

TaskStart任务负责安装操作系统的时钟中断服务例程、初始化操作系统时钟，并创建所有的应用任务：

ucos_x86_idt_set_handler（0x20,（void*）OSTickISR,0x8e00）;

/*InstalluC/OS-II'sclocktickISR*/

ucos_timer_init（）;/*Timer初始化*/

TaskStartCreateTasks（）;/*Createalltheapplicationtasks*/

OSTaskSuspend（OS_PRIO_SELF）;

具体负责应用任务创建的TaskStartCreateTasks函数代码如下，它创建了两个应用任务Task0和Task1：

staticvoidTaskStartCreateTasks（void）

{

INT8Ui;

for（i=0;i

TaskData[i]=i;/*Eachtaskwilldisplayitsownletter*/

}

OSTaskCreate（Task0,（void*）&TaskData[i],&TaskStk[i][TASK_STK_SIZE-1],5）;

OSTaskCreate（Task1,（void*）&TaskData[i],&TaskStk[1][TASK_STK_SIZE-1],6）;

}

TaskStart任务完成上述操作后将自己挂起，操作系统将调度当前优先级最高的应用任务Task0运行。

应用任务Task0运行后将自己挂起，之后操作系统就会调度处于就绪状态的优先级最高的任务，具体代码如下：

voidTask0（void*pdata）

{

INT8Ui;

INT8Uerr;

i=*（int*）pdata;

for（;;）{

……/*此处为输出信息,显示任务运行的状态*/

err=OSTaskSuspend（5）;/*suspenditself*/

}

}

应用任务Task1运行后将Task0唤醒，使其进入到就绪队列中：

voidTask1（void*pdata）

{

INT8Ui;

INT8Uerr;

i=*（int*）pdata;

for（;;）{

OSTimeDly（150）;

……/*此处为输出信息,显示任务运行的状态*/

OSTimeDly（150）;

err=OSTaskResume（5）;/*resumetask0*/

}

}

5、实验结果

实验地点

学科楼506实验室

指导教师

张兴忠

本科实验报告

课程名称：

嵌入式操作系统

实验项目：

实验二：

中断与系统时钟实验

实验地点：

博学馆506实验室

专业班级：

计Z1101学号：

2011001488

学生姓名：

郭晓云

指导教师：

张兴忠

2014年04月15日

太原理工大学学生实验报告

学院名称

计算机科学与技术

专业班级

计Z1101

学号

2011001488

学生姓名

郭晓云

实验日期

2014-04-15

成绩

课程名称

嵌入式操作系统

实验题目

中断与系统时钟实验

一、实验目的和要求

掌握嵌入式实时操作系统µC/OS中中断的使用情况。

二、实验器材（设备、元器件）：

硬件环境：

PC计算机；软件环境：

WIN98/2000/XP、BC4.5（BorlandC++4.5）、tasm.exe；三、实验内容和原理

在本实验中，设计了三个任务Task1、Task2、Task3，创建了一个信号量InterruptSem。

Task1和Task2获得信号量InterruptSem后延时，Task1延时200Tick，Task2延时500Tick，利用Task3输出的次数来对Task1和Task2的延时计数，Task3每100Tick产生一次输出。

4、操作方法与实验步骤

整个系统的运行流程如下：

1）系统初始化，在TaskStart任务中，创建并启动任务Task1、Task2、Task3，优先级分别为12,13,14。

2）在TaskStart任务中创建一个信号量InterruptSem（初值为1）。

3）任务在TaskStart任务中挂起自己，操作系统实施调度，进入Task1运行；

4）任务Task1睡眠100ticks；

5）任务Task2开始执行,任务Task2获得信号量InterruptSem；

6）任务Task2睡眠500tick，任务Task3投入运行，打印输出语句后延时，任务Task1睡眠时间到继续投入运行，它申请信号量InterruptSem失败被阻塞；

7）任务Task3投入运行，循环地打印输出语句。

期间时钟中断不断产生，在中断处理程序中对任务Task2的睡眠时间进行计数；

8）Task2睡眠时间到后恢复运行，并释放信号量InterruptSem；

9）Task1获得信号量InterruptSem后抢占Task2运行；

10）Task1使用完信号量InterruptSem后释放该信号量；

11）系统从步骤4重复执行，一直运行下去……

五、实验代码及结果：

voidTask1（void*pdata）

{

INT8Uerr;

pdata=pdata;

for（;;）

{

OSTimeDly（100）;

printk（"\nTask1istrytogetsemaphore.\n\n"）;/*task1delay100clockticks*/

OSSemPend（InterruptSem,0,&err）;/*Acquiresemaphoretogetintotheroom*/

printk（"Task1hasSucceedtoobtainsemaphore.\n"）;

printk（"Task1isdelayed.\n\n"）;

OSTimeDly（200）;

printk（"\nThedelayofTask1finished.\n"）;

printk（"Task1releasesemaphore.\n"）;

OSSemPost（InterruptSem）;/*Releasesemaphore*/

OSTimeDly（200）;

}

}

voidTask2（void*pdata）

{INT8Uerr;

pdata=pdata;

for（;;）

{

printk（"\nTask2istrytogetsemaphore.\n"）;

OSSemPend（InterruptSem,0,&err）;/*Acquiresemaphoretogetintotheroom*/

printk（"Task2hasSucceedtoobtainsemaphore.\n"）;

printk（"Task2isdelayed.\n\n"）;

OSTimeDly（500）;/*task2delay500clockticks*/

printk（"\nThedelayofTask2finished.\n"）;

printk（"Task2releasesemaphore.\n"）;

OSSemPost（InterruptSem）;/*Releasesemaphore*/

OSTimeDly（200）;

}

}

voidTask3（void*pdata）

{

pdata=pdata;

for（;;）

{

printk（"Task3hasgottheCPU:

|||||||||||||||||||||||||||||||||||||\n"）;

OSTimeDly（100）;

}

}

本科实验报告

课程名称：

嵌入式操作系统

实验项目：

实验三：

信号量测试

实验地点：

博学馆506实验室

专业班级：

计Z1101学号：

2011001488

学生姓名：

郭晓云

指导教师：

张兴忠

2014年04月15日

太原理工大学学生实验报告

学院名称

计算机科学与技术

专业班级

计Z1101

学号

2011001488

学生姓名

郭晓云

实验日期

2014-04-15

成绩

课程名称

嵌入式操作系统

实验题目

信号量实验

一、实验目的和要求

掌握在基于嵌入式实时操作系统µC/OS-II的应用中，任务使用信号量的一般原理。

通过实验，了解如何利用信号量来对共享资源进行互斥访问。

二、实验器材（设备、元器件）：

硬件环境：

PC计算机；软件环境：

WIN98/2000/XP、BC4.5（BorlandC++4.5）、tasm.exe；

三、实验内容

假设有共享资源R，允许2个任务分时访问R，那么信号量的值应设置为2，系统中有3个用户任务访问资源R，分别为任务A、B、C，优先级分别为7、6、5。

任务A运行后创建信号量，并访问R，访问完成后任务A将自己阻塞1000个时钟周期。

任务B先阻塞300个时钟周期，然后操作步骤同任务A。

任务C先阻塞400个时钟周期然后操作步骤同任务A。

假设3个任务操作资源R需要的时间都是1000个时钟周期，对资源R的操作用延时语句虚拟完成。

4、操作方法与实验步骤

实验代码：

voidUserTaskSemA（void*pParam）

{

/*任务SemA创建信号量，然后周期性访问资源R*/

/*创建信号量*/

INT8U*perr;

INT8Uerr;

//INT8Ui;

OS_SEM_DATAmySemData;

err=0;

perr=&err;

MyEventSem=OSSemCreate

（2）;

if（MyEventSem==（OS_EVENT*）0）

{

printf（"任务A创建信号量失败！

\n"）;

OSTaskDel（OS_PRIO_SELF）;

return;

}

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务A创建信号量。

当前信号量值=%d\n",OSTimeGet（）,mySemData.OSCnt）;

while

（1）

{

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务A开始请求信号量！

当前信号量值=%d\n",OSTimeGet（）,mySemData.OSCnt）;

OSSemPend（MyEventSem,0,perr）;

if（err!

=OS_ERR_NONE）

{

printf（"任务A请求信号量失败\n"）;

printf（"错误号%d\n",err）;

continue;

}

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务A获得信号量。

当前信号量值=%d，任务A开始对R操作\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;/*模拟操作资源,需要10秒，1000个时钟嘀嗒*/

printf（"时间:

%d，任务A结束资源操作，提交信号量！

\n",OSTimeGet（））;

OSSemPost（MyEventSem）;

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务A提交信号量完成，当前信号量值=%d,任务A将延时阻塞1000嘀嗒\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;

}

}

voidUserTaskSemB（void*pParam）

{

/*任务SemA创建信号量，然后周期性访问资源R*/

INT8U*perr;

INT8Uerr;

OS_SEM_DATAmySemData;

err=0;

perr=&err;

printf（"时间:

%d,任务B开始延时300个时钟嘀嗒",OSTimeGet（））;

OSTimeDly（300）;/*任务B先延时3秒*/

if（MyEventSem==（OS_EVENT*）0）

{

printf（"任务A创建信号量失败！

\n"）;

OSTaskDel（OS_PRIO_SELF）;

return;

}

while

（1）

{

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务B开始请求信号量！

当前信号量值=%d\n",OSTimeGet（）,mySemData.OSCnt）;

OSSemPend（MyEventSem,0,perr）;

if（err!

=OS_ERR_NONE）

{

printf（"任务B请求信号量失败\n"）;

printf（"错误号%d\n",err）;

continue;

}

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务B获得信号量。

当前信号量值=%d，任务B开始对R操作,需1000个时钟嘀嗒\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;/*模拟操作资源,需要10秒，1000个时钟嘀嗒*/

printf（"时间:

%d，任务B结束资源操作，提交信号量！

\n",OSTimeGet（））;

OSSemPost（MyEventSem）;

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务B提交信号量完成，当前信号量值=%d,任务B将延时阻塞1000嘀嗒\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;

}

}

voidUserTaskSemC（void*pParam）

{

/*任务SemA创建信号量，然后周期性访问资源R*/

INT8U*perr;

INT8Uerr;

INT8Ui;

OS_SEM_DATAmySemData;

err=0;

perr=&err;

printf（"时间:

%d,任务C开始延时400个时钟嘀嗒",OSTimeGet（））;

OSTimeDly（400）;/*任务C先延时4秒*/

if（MyEventSem==（OS_EVENT*）0）

{

printf（"任务A创建信号量失败！

\n"）;

OSTaskDel（OS_PRIO_SELF）;

return;

}

while

（1）

{

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务C开始请求信号量！

当前信号量值=%d\n",OSTimeGet（）,mySemData.OSCnt）;

OSSemPend（MyEventSem,0,perr）;

if（err!

=OS_ERR_NONE）

{

printf（"任务C请求信号量失败\n"）;

printf（"错误号%d\n",err）;

continue;

}

OSSemQuery（MyEventSem,&mySemData）;

printf（"时间:

%d,任务C获得信号量。

当前信号量值=%d，任务C开始对R操作,需1000个时钟嘀嗒\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;/*模拟操作资源,需要10秒，1000个时钟嘀嗒*/

printf（"时间:

%d，任务C结束资源操作，提交信号量！

\n",OSTimeGet（））;

OSSemPost（MyEventSem）;

printf（"时间:

%d,任务C提交信号量完成，当前信号量值=%d,任务C将延时阻塞1000嘀嗒\n",OSTimeGet（）,mySemData.OSCnt）;

OSTimeDly（1000）;

}

}

5、实验数据记录和处理

本科实验报告

课程名称：

嵌入式操作系统

实验项目：

实验四：

内存管理

实验地点：

博学馆506实验室

专业班级：

计Z1101学号：

2011001488

学生姓名：

郭晓云

指导教师：

张兴忠

2014年4月15日

太原理工大学学生实验报告

学院名称

计算机科学与技术

专业班级

计Z1101

学号

2011001488

学生姓名

郭晓云

实验日期

2014-04-15

成绩

课程名称

嵌入式操作系统

实验题目

内存管理实验

二、实验目的和要求

掌握嵌入式实时操作系统µC/OS-II内存管理中内存分配和回收的功能。

2、实验器材（设备、元器件）：

硬件环境：

PC计算机；软件环境：

WIN98/2000/XP、BC4.5（BorlandC++4.5）、tasm.exe；

三、实验内容和原理

内存管理的核心是内存的动态分配和释放。

在该实验中，首先创建一个内存分区，该分区包含3个块，申请3次后，第4次申请失败；释放过程也是这样，当内存已经满了，就不可能再释放内存块给内存了。

四、操作方法与实验步骤

实验代码：

voidTaskM（void*pParam）

{

INT8U*perr;

INT8Uerr,i;

OS_MEM*pmyMem;//MCB块地址

INT8UmyMem[3][20];//用来做内存分区

void*pblk[10];//内存块地址数组

BOOLEANrequire;

OS_MEM_DATAmem_data;//用于查询内存块信息

err=OS_ERR_NONE;

perr=&err;

require=1;

pmyMem=OSMemCreate（myMem,3,20,perr）;/*创建内存分区，10个块,每个块20个字节*/

if（pmyMem==（OS_EVENT*）0）/*检查是否创建成功*/

{

printf（"时间:

%d，TaskM创建内存分区失败\n",OSTimeGet（））;

OSTaskDel（OS_PRIO_SELF）;/*不成功则删除本任务*/

return;

}

printf（"时间:

%d，TaskM创建内存分区成功，包含10个块,每个块20个字节\n",OSTimeGet（））;

i=0;

while

（1）

{

if（i>5）

{

i=0;

require=!

require;

}

//printf（"时间:

%d，i=%d\n",OSTimeGet（）,i）;

OSTimeDly（100）;/*延时1秒*/

if（require）

{

printf（"时间:

%d，任务TaskM准备请求一个块->",OSTimeGet（））;

pblk[i++]=OSMemGet（pmyMem,perr）;/