实时操作系统实验报告
专业：通信工程
学号：---------
姓名：--------
指导老师： ------
实验一任务编程实验
实验目的：
●理解任务管理的基本原理，了解任务的各个基本状态及其变迁过程；
●掌握μC/OS-II系统的编程方法，包括main函数的书写方法，任务组成、
创建、启动和时间函数，主要包括：
?OSInit; OSStart; OSTaskCreate;PC_DispStr;PC_GetKey;
OSTimeDlyHMSM;OSTimeDly;OSTimeGet等。
实验要求与思路：
创建3个任务task1、task2、task3.task1完成利用OSTimeGet（或PC_GetDateTime）实现时间的获取，同时利用PC_DispStr实现时间的显示。Task2和task3各自完成一个动画显示的任务——在屏幕上依次输出字符“|”、“\”、“—”、“/”而产生一个向左转动和向右转动的动画标志。同时需要编写一个启动任务实现对时间任务的启动。
实验程序：
#include "includes.h"
#define TASK_STK_SIZE 512
#define TASK_START_PRIO 2
#define TASK_1_PRIO 4
#define TASK_2_PRIO 5
#define TASK_3_PRIO 6
OS_STK TaskStartStk[TASK_STK_SIZE];
OS_STK Task1Stk[TASK_STK_SIZE];
OS_STK Task2Stk[TASK_STK_SIZE];
OS_STK Task3Stk[TASK_STK_SIZE];
void TaskStart(void *pdata);
void Task1(void *pdata);
void Task2(void *pdata);
void Task3(void *pdata);
void TaskStartDispInit (void);
void main(void)
{
OSInit();
PC_DOSSaveReturn();
PC_VectSet(uCOS,OSCtxSw);
OSTaskCreate(TaskStart,0,&TaskStartStk[TASK_STK_SIZE-1],TASK_START_PRIO);
OSStart();
}
void TaskStart(void *pdata)
{
INT16S key=0;
INT8U err;
pdata=pdata;
TaskStartDispInit();
OS_ENTER_CRITICAL();
PC_VectSet(0x08,OSTickISR);
PC_SetTickRate(OS_TICKS_PER_SEC);
OS_EXIT_CRITICAL();
OSStatInit();
err=OSTaskCreate(Task1,0,&Task1Stk[TASK_STK_SIZE-1],TASK_1_PRIO);
err=OSTaskCreate(Task2,0,&Task2Stk[TASK_STK_SIZE-1],TASK_2_PRIO);
err=OSTaskCreate(Task3,0,&Task3Stk[TASK_STK_SIZE-1],TASK_3_PRIO);
for(;;){
if(PC_GetKey(&key)){
if(key==0x1B){
PC_DOSReturn();
}
}
OSCtxSwCtr=0;
OSTimeDly(OS_TICKS_PER_SEC);
}
}
void TaskStartDispInit (void)
{
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
PC_DispStr( 0, 0, " uC/OS-II, The Real-Time Kernel
", DISP_FGND_WHITE + DISP_BGND_RED + DISP_BLINK);
PC_DispStr( 0, 1, " Jean J. Labrosse
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 2, "
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 3, " EXAMPLE #2
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 4, "
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 5, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 6, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 7, "
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 8, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 9, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 10, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 11, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 12, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 13, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 14, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 15, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 16, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 17, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 18, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 19, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 20, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 21, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 22, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 23, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 24, " <-PRESS 'ESC' TO QUIT-> ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY + DISP_BLINK);
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
}
void Task1 (void *pdata)
{char s[40];
pdata = pdata;
for (;;) {
PC_GetDateTime(s);
PC_DispStr(30,15,s,DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC); /* Delay for 100 mS */ }
}
void Task2 (void *pdata)
{
pdata = pdata;
for (;;) {PC_DispChar(60,15,'|',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/5);
PC_DispChar(60,15,'/',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/5);
PC_DispChar(60,15,'-',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/5);
PC_DispChar(60,15,'\\',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/5); /* Delay for 100 mS */ }
}
void Task3 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispChar(65,16,'|',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/10);
PC_DispChar(65,16,'\\',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/10);
PC_DispChar(65,16,'-',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/10);
PC_DispChar(65,16,'/',
DISP_FGND_YELLOW+DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC/10); /* Delay for 100 mS */
}
}
实验截图：
图2-1
实验感想：
通过一阶段的理论知识的学习，对嵌入式实时操作系统有了一定的了解。但是在上机操作的时候还是存在很多的问题，没有一个完整的概念，不知道自己能做些什么、这么样才能达到老师布置的实验要求。
经过老师耐心的指导，慢慢的找到了门路，有了信心，对着书上的相关程序，在老师的指导下一遍一遍的编译、运行、修改错误，最终达到了实验要求，理解了任务管理的基本原理，了解了务的各个基本状态及其变迁过程；
掌握了μC/OS-II系统的编程方法等
实验二任务管理实验
实验目的：
1.理解任务管理的基本原理，了解任务的各个基本状态及其变迁过程；
2.掌握μC/OS-II 中任务管理的基本方法（挂起、解挂）；
3.熟练使用μC/OS-II 任务管理的基本系统调用。
实验要求与思路：
为了体现任务的各个基本状态及其变迁过程task1、task2、task3、task4、task5、task6，六个任务，让task1、task2、task3、都被挂起；task4、task5、task6分别执行一个运行时其他两个被挂起。
说明：
在系统完成初始化后，可以先创建并启动优先级最低的TaskStart，由它创
建其他6 个应用任务，之后整个系统的运行流程如下：
1）根据优先级高低依次开始执行， task1、task2、task3分别挂起自己；
2）然后系统调度选中task4开始执行，之后task4 挂起自己；
3）接着系统调度选中task5,之后唤醒task4；
4）如此循环
实验程序:
#include "includes.h"
#define TASK_STK_SIZE 512
#define TASK_START_PRIO 2
#define TASK_1_PRIO 4
#define TASK_2_PRIO 5
#define TASK_3_PRIO 6
#define TASK_4_PRIO 7
#define TASK_5_PRIO 8
#define TASK_6_PRIO 9
OS_STK TaskStartStk[TASK_STK_SIZE];
OS_STK Task1Stk[TASK_STK_SIZE];
OS_STK Task2Stk[TASK_STK_SIZE];
OS_STK Task3Stk[TASK_STK_SIZE];
OS_STK Task4Stk[TASK_STK_SIZE];
OS_STK Task5Stk[TASK_STK_SIZE];
OS_STK Task6Stk[TASK_STK_SIZE];
void TaskStart(void *pdata);
void Task1(void *pdata);
void Task2(void *pdata);
void Task3(void *pdata);
void Task4(void *pdata);
void Task5(void *pdata);
void Task6(void *pdata);
void TaskStartDispInit (void);
void main(void)
{
OSInit();
PC_DOSSaveReturn();
PC_VectSet(uCOS,OSCtxSw);
OSTaskCreate(TaskStart,0,&TaskStartStk[TASK_STK_SIZE-1],TASK_START_PRIO);
OSStart();
}
void TaskStart(void *pdata)
{
INT16S key=0;
INT8U err;
pdata=pdata;
TaskStartDispInit();
OS_ENTER_CRITICAL();
PC_VectSet(0x08,OSTickISR);
PC_SetTickRate(OS_TICKS_PER_SEC);
OS_EXIT_CRITICAL();
OSStatInit();
err=OSTaskCreate(Task1,0,&Task1Stk[TASK_STK_SIZE-1],TASK_1_PRIO);
err=OSTaskCreate(Task2,0,&Task2Stk[TASK_STK_SIZE-1],TASK_2_PRIO);
err=OSTaskCreate(Task3,0,&Task3Stk[TASK_STK_SIZE-1],TASK_3_PRIO);
err=OSTaskCreate(Task4,0,&Task4Stk[TASK_STK_SIZE-1],TASK_4_PRIO);
err=OSTaskCreate(Task5,0,&Task5Stk[TASK_STK_SIZE-1],TASK_5_PRIO);
err=OSTaskCreate(Task6,0,&Task6Stk[TASK_STK_SIZE-1],TASK_6_PRIO);
OSTaskSuspend(8);
OSTaskSuspend(9);
for(;;){
if(PC_GetKey(&key)){
if(key==0x1B){
PC_DOSReturn();
}
}
OSCtxSwCtr=0;
OSTimeDly(OS_TICKS_PER_SEC);
}
}
void TaskStartDispInit (void)
{
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
PC_DispStr( 0, 0, " uC/OS-II, The Real-Time Kernel ", DISP_FGND_WHITE + DISP_BGND_RED + DISP_BLINK);
PC_DispStr( 0, 1, " Jean J. Labrosse ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 2, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 3, " EXAMPLE #2 ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 4, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 5, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 6, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 7, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 8, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 9, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 10, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 11, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 12, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 13, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 14, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 15, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 16, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 17, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 18, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 19, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 20, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 21, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 22, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 23, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 24, " <-PRESS 'ESC' TO QUIT-> ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY + DISP_BLINK);
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
}
void Task1 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(30,15,"Suspend Task1",DISP_FGND_YELLOW + DISP_BGND_BLUE);
OSTaskSuspend(4);
OSTimeDly(OS_TICKS_PER_SEC);
}
}
void Task2 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(30,16,"Suspend Task2",DISP_FGND_YELLOW + DISP_BGND_BLUE);
OSTaskSuspend(5);
OSTimeDly(OS_TICKS_PER_SEC); /* Delay for 100 mS
*/
}
}
void Task3 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(30,17,"Suspend Task3",DISP_FGND_YELLOW + DISP_BGND_BLUE);
OSTaskSuspend(6);
OSTimeDly(OS_TICKS_PER_SEC); /* Delay for 100 mS
*/
}
}
void Task4 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(40,20,"Resume Task4",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,21,"Suspend Task5",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,22,"Suspend Task6",DISP_FGND_YELLOW + DISP_BGND_BLUE); OSTimeDly(OS_TICKS_PER_SEC);
OSTaskResume(8);
OSTaskSuspend(7);
}
}
void Task5 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(40,20,"Suspend Task4",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,21,"Resume Task5",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,22,"Suspend Task6",DISP_FGND_YELLOW + DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC);
OSTaskResume(9);
OSTaskSuspend(8);
}
}
void Task6 (void *pdata)
{
pdata = pdata;
for (;;) {
PC_DispStr(40,20,"Suspend Task4",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,21,"Suspend Task5",DISP_FGND_YELLOW + DISP_BGND_BLUE); PC_DispStr(40,22,"Resume Task6",DISP_FGND_YELLOW + DISP_BGND_BLUE);
OSTimeDly(OS_TICKS_PER_SEC);
OSTaskResume(7);
OSTaskSuspend(9);
}
}
实验截图：
实验感想
通过这次实验中的任务创建使我掌握μC/OS-II 中任务管理的基本方法（挂起、解挂），理解了任务管理的基本原理，了解任务的各个基本状态及其变迁过程；掌握μC/OS-II 中任务管理的基本方法（挂起、解挂）；熟练使用μC/OS-II 任务管理的基本系统调用。
实验三信号量编程实验
实验目的：
●理解信号量的作用，特别是互斥操作和同步操作；
●掌握利用信号量操作函数实现简单的生产者/消费者问题；
●掌握下列信号量操作函数及其使用方法：
?OSSemCreate、OSSemPend、OSSemPost
?
实验要求与思路：
创建两个任务task1、task2，在task1完成对信号量的请求，task2发送task1请求的信号量，起初task1每1s钟请求一次信号量，task2每1s钟发送一次信号量，5s以后，task1每1s请求一次信号量而task2每2s发送一次信号量。
实验程序
#include "includes.h"
#define TASK_STK_SIZE 512
#define TASK_START_PRIO 2
#define TASK_1_PRIO 4
#define TASK_2_PRIO 5
char *s1="Task1";
char *s2="Task2";
INT8U err;
INT8U y=0;
INT16S key;
OS_EVENT *Fun_Semp;
OS_STK TaskStartStk[TASK_STK_SIZE];
OS_STK Task1Stk[TASK_STK_SIZE];
OS_STK Task2Stk[TASK_STK_SIZE];
void Fun(INT8U x,INT8U y);
void TaskStart(void *pdata);
void Task1(void *pdata);
void Task2(void *pdata);
void TaskStartDispInit (void);
void main(void)
{
OSInit();
Fun_Semp=OSSemCreate(3);
PC_DOSSaveReturn();
PC_VectSet(uCOS,OSCtxSw);
OSTaskCreate(TaskStart,0,&TaskStartStk[TASK_STK_SIZE-1],TASK_START_PRIO);
OSStart();
}
void TaskStart(void *pdata)
{
INT16S key=0;
INT8U err;
pdata=pdata;
OS_ENTER_CRITICAL();
TaskStartDispInit();
OS_ENTER_CRITICAL();
PC_VectSet(0x08,OSTickISR);
PC_SetTickRate(OS_TICKS_PER_SEC);
OS_EXIT_CRITICAL();
OSStatInit();
err=OSTaskCreate(Task1,0,&Task1Stk[TASK_STK_SIZE-1],TASK_1_PRIO);
err=OSTaskCreate(Task2,0,&Task2Stk[TASK_STK_SIZE-1],TASK_2_PRIO);
for(;;){
if(PC_GetKey(&key)){
if(key==0x1B){
PC_DOSReturn();
}
}
OSCtxSwCtr=0;
OSTimeDly(OS_TICKS_PER_SEC);
}
}
void TaskStartDispInit (void)
{
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
PC_DispStr( 0, 0, " uC/OS-II, The Real-Time Kernel ", DISP_FGND_WHITE + DISP_BGND_RED + DISP_BLINK);
PC_DispStr( 0, 1, " Jean J. Labrosse ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 2, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 3, " EXAMPLE #2 ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 4, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 5, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 6, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 7, "
", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 8, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 9, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 10, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 11, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 12, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 13, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 14, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 15, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 16, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 17, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 18, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 19, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 20, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 21, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 22, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 23, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 24, " <-PRESS 'ESC' TO QUIT-> ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY + DISP_BLINK);
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
}
void Task1 (void *pdata)
{
pdata = pdata;
for (;;) {
OSSemPend(Fun_Semp,0,&err);
PC_DispStr(0,++y,s1,DISP_BGND_BLACK+DISP_FGND_WHITE);
OSTimeDly(OS_TICKS_PER_SEC); /* Delay for 100 mS */
}
}
void Task2 (void *pdata)
{
pdata = pdata;
OSTimeDly(OS_TICKS_PER_SEC*5);
for (;;) {
PC_DispStr(0,++y,s2,DISP_BGND_BLACK+DISP_FGND_WHITE);
OSSemPost(Fun_Semp);
OSTimeDly(OS_TICKS_PER_SEC*2); /* Delay for 100 mS */
}
}
实验截图：
图
实验感想：
通过本次实验，我深刻理解了信号量的作用，特别是互斥操作和同步操作；掌握了利用信号量操作函数实现简单的生产者/消费者问题；
掌握下列信号量操作函数及其使用方法：OSSemCreate、OSSemPend、OSSemPost ；
这次实验的信号量的声明、函数的声明以及定义过程中我发现我对以往学习的C语言知识基础并不牢固，简单的声明和定义都会引发一系列的错误，在今后的学习中药注意完善、
巩固所学的知识。
实验四消息编程实验
实验目的：
●掌握消息编程方法，主要函数包括：
?OSQCreate 创建消息队列
?OSQPend 接收消息
?OSQPostFront，OSQPost 发送消息
实验要求与思路：
建议一个能存放6条消息的消息队列，在此基础上创建Task1和Task3，向该消息队列发送消息，而创建任务Task2，从消息队列中获取消息。考虑消息队列满和空的情况。(设Task1使用OSQPost，Task3使用OSQPostFront)
实验程序：
#include "includes.h"
#define TASK_STK_SIZE 512
#define N_MESSAGES 10
#define TASK_START_PRIO 2
#define TASK_1_PRIO 4
#define TASK_2_PRIO 5
#define TASK_3_PRIO 6
void * MsgGrp[N_MESSAGES];
INT8U err;
INT8U y=0;
INT32U Times=0;
OS_EVENT * Str_Q;
OS_STK TaskStartStk[TASK_STK_SIZE];
OS_STK Task1Stk[TASK_STK_SIZE];
OS_STK Task2Stk[TASK_STK_SIZE];
OS_STK Task3Stk[TASK_STK_SIZE];
void TaskStart(void *pdata);
void Task1(void *pdata);
void Task2(void *pdata);
void Task3(void *pdata);
void TaskStartDispInit (void);
void main(void)
{
OSInit();
PC_DOSSaveReturn();
PC_VectSet(uCOS,OSCtxSw);
Str_Q=OSQCreate(&MsgGrp[0],N_MESSAGES);
OSTaskCreate(TaskStart,0,&TaskStartStk[TASK_STK_SIZE-1],TASK_START_PRIO);
OSStart();
}
void TaskStart(void *pdata)
{
INT16S key=0;
INT8U err;
pdata=pdata;
TaskStartDispInit();
OS_ENTER_CRITICAL();
PC_VectSet(0x08,OSTickISR);
PC_SetTickRate(OS_TICKS_PER_SEC);
OS_EXIT_CRITICAL();
OSStatInit();
err=OSTaskCreate(Task1,0,&Task1Stk[TASK_STK_SIZE-1],TASK_1_PRIO);
err=OSTaskCreate(Task2,0,&Task2Stk[TASK_STK_SIZE-1],TASK_2_PRIO);
err=OSTaskCreate(Task3,0,&Task3Stk[TASK_STK_SIZE-1],TASK_3_PRIO);
for(;;){
if(PC_GetKey(&key)){
if(key==0x1B){
PC_DOSReturn();
}
}
OSCtxSwCtr=0;
OSTimeDly(OS_TICKS_PER_SEC);
}
}
void TaskStartDispInit (void)
{
/* 1111111111222222222233333333334444444444555555555566666666667777777777 */
/* 01234567890123456789012345678901234567890123456789012345678901234567890123456789 */
PC_DispStr( 0, 0, " uC/OS-II, The Real-Time Kernel ", DISP_FGND_WHITE + DISP_BGND_RED + DISP_BLINK);
PC_DispStr( 0, 1, " Jean J. Labrosse ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 2, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 3, " EXAMPLE #2 ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 4, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 5, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
PC_DispStr( 0, 6, " ", DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
中南大学信息科学与工程学院实验报告 姓名：安磊 班级：计科0901 学号： 0909090310
指导老师：宋虹
目录 课程设计内容 ----------------------------------- 3 uC/OS操作系统简介 ------------------------------------ 3 uC/OS操作系统的组成 ------------------------------ 3 uC/OS操作系统功能作用 ---------------------------- 4 uC/OS文件系统的建立 ---------------------------- 6 文件系统设计的原则 ------------------------------6 文件系统的层次结构和功能模块 ---------------------6 文件系统的详细设计 -------------------------------- 8 文件系统核心代码 --------------------------------- 9 课程设计感想 ------------------------------------- 11 附录-------------------------------------------------- 12
课程设计内容 在uC/OS操作系统中增加一个简单的文件系统。 要求如下： (1)熟悉并分析uc/os操作系统 (2)设计并实现一个简单的文件系统 (3)可以是存放在内存的虚拟文件系统，也可以是存放在磁盘的实际文件系统 (4)编写测试代码，测试对文件的相关操作：建立，读写等 课程设计目的 操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。 本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。 I．uC/OS操作系统简介 μC/OS-II是一种可移植的，可植入ROM的，可裁剪的，抢占式的，实时多任务操作系统内核。它被广泛应用于微处理器、微控制器和数字信号处理器。 μC/OS 和μC/OS-II 是专门为计算机的嵌入式应用设计的，绝大部分代码是用C语言编写的。CPU 硬件相关部分是用汇编语言编写的、总量约200行的汇编语言部分被压缩到最低限度，为的是便于移植到任何一种其它的CPU 上。用户只要有标准的ANSI 的C交叉编译器，有汇编器、连接器等软件工具，就可以将μC/OS-II嵌入到开发的产品中。μC/OS-II 具有执行效率高、占用空间小、实时性能优良和可扩展性强等特点，最小内核可编译至2KB 。μC/OS-II 已经移植到了几乎所有知名的CPU 上。 严格地说uC/OS-II只是一个实时操作系统内核，它仅仅包含了任务调度，任务管理，时间管理，内存管理和任务间的通信和同步等基本功能。没有提供输入输出管理，文件系统，网络等额外的服务。但由于uC/OS-II良好的可扩展性和源码开放，这些非必须的功能完全 可以由用户自己根据需要分别实现。 uC/OS-II目标是实现一个基于优先级调度的抢占式的实时内核，并在这个内核之上提供最基本的系统服务，如信号量，邮箱，消息队列，内存管理，中断管理等。 uC/OS操作系统的组成 μC/OS-II可以大致分成核心、任务处理、时间处理、任务同步与通信，CPU的移植等5个部分。如下图：
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
实时操作系统课程实验报告 专业：通信1001 学号：3100601025 姓名：陈治州 完成时间：2013年6月11日
实验简易电饭煲的模拟 一．实验目的： 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，基于多任务的模式的编程方法。锻炼综合应用多任务机制，任务间的通信机制，内存管理等的能力。 二．实验要求： 1.按“S”开机，系统进入待机状态，时间区域显示当前北京时间，默认模式“煮饭”; 2.按“C”选择模式，即在“煮饭”、“煮粥”和“煮面”模式中循环选择； 3.按“B”开始执行模式命令，“开始”状态选中，时间区域开始倒计时，倒计时完成后进入“保温”状态，同时该状态显示选中，时间区域显示保温时间； 4.按“Q”取消当前工作状态，系统进入待机状态，时间区域显示北京时间，模式为当前模式； 5.按“X”退出系统，时间区域不显示。 6.煮饭时长为30，煮粥时长为50，煮面时长为40. 三．实验设计： 1.设计思路： 以老师所给的五个程序为基础，看懂每个实验之后，对borlandc的操作有了大概的认识，重点以第五个实验Task_EX为框架，利用其中界面显示与按键扫描以及做出相应的响应，对应实现此次实验所需要的功能。 本次实验分为界面显示、按键查询与响应、切换功能、时钟显示与倒计时模块，综合在一起实验所需功能。 2.模块划分图： （1）界面显示： Main（） Taskstart（） Taskstartdispinit（） 在TaskStartDispInit()函数中，使用PC_DispStr()函数画出界面。
（2）按键查询与响应： Main（） Taskstart（） 在TaskStart()函数中，用if (PC_GetKey(&key) == TRUE)判断是否有按键输入。然后根据key 的值，判断输入的按键是哪一个；在响应中用switch语句来执行对应按键的响应。 （3）切换功能： l计数“C”按 键的次数 M=l%3 Switch(m) M=0，1，2对应于煮饭，煮粥，煮面，然后使用PC_DispStr()函数在选择的选项前画上“@”指示，同时，在其余两项钱画上“”以“擦出”之前画下的“@”，注意l自增。 四.主要代码： #include "stdio.h" #include "includes.h" #include "time.h" #include "dos.h" #include "sys/types.h" #include "stdlib.h" #define TASK_STK_SIZE 512 #define N_TASKS 2 OS_STK TaskStk[N_TASKS][TASK_STK_SIZE]; OS_STK TaskStartStk[TASK_STK_SIZE]; INT8U TaskData[N_TASKS];
John Lee
John Lee
第一章操作系统引论 1.操作系统定义：操作系统是配置在计算机硬件上的第一层软件，是对硬件功能的首次扩充。 2.操作系统的基本类型：批处理系统，分时系统，实时系统 3.脱机技术：主机与IO设备脱离的技术 4.多道程序技术：在内存中同时有多个程序并存的技术 5.操作系统的基本特性：并发性，共享性，异步性，虚拟技术 6.操作系统的五大功能：处理机管理功能，存储器管理功能，设备管理功能，文件管理功能，用户交流界面（人机接口） 第二章进程管理 1.进程的概念：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位。 2.状态转换图 3.进程控制块PCB，在进程的整个生命周期中，系统总是通过PCB对进程进行控制，因此PCB是进程存在的唯一标志。 4.原语是由若干条指令组成的，用于完成一定功能的一个过程。它与一般过程的区别在于：它们是“原子操作”。所谓原子操作，是指一个操作中的所有动作要么全做，要么全不做。 5.进程同步的主要任务是对多个相关进程在执行持续上进行协调，已使并发执行的诸进程之间能有效的共享资源和互相合作，从而使程序执行具有可再现性。 6.临界资源、临界区、信号的概念、同步、互斥问题的解决方法 临界资源：Critical Resouce 诸进程间应采取互斥方式，实现对这种资源的共享，如打印机，磁带机等。
临界区：人们把在每个进程中访问临界资源的那段代码称为临界区（critical section） 信号： 同步合作直接 互斥竞争间接 7.进程通信的三种类型：共享存储器系统、消息传递系统、管道通信系统 8.线程的概念和两种类型： 线程：被称为轻型进程或进程元，通常一个进程拥有若干个线程。 两种类型：用户级线程和内核支持线程 第三章处理机调度与死锁 1.调度三个层次：高级调度，中级调度，低级调度 2.调度算法： FCFS先来先服务 SPF段作业优先调度 RR时间片轮转法 3.死锁的概念，在多个进程在运行过程中因为争夺资源而造成的一种僵局，当进程处于这种僵局状态时，若无外力作用，他们都将无法再向前推进。 4.死锁的原因和条件 原因：资源不足（根本原因），进程推进顺序非法 必要条件：互斥条件、请求和保持条件、不剥夺条件，环路等待条件。 5.死锁解决的三种方案：摒弃“请求和保持”条件、摒弃“不剥夺”条件、摒弃“环路等待”
实时操作系统期末总结报告 一、实时操作系统的概述 实时操作系统（RTOS）是指当外界事件或数据产生时，能够接受并以足够快的速度予以处理，其处理的结果又能在规定的时间之内来控制生产过程或对处理系统做出快速响应，并控制所有实时任务协调一致运行的操作系统。因而，提供及时响应和高可靠性是其主要特点。实时操作系统有硬实时和软实时之分，硬实时要求在规定的时间内必须完成操作，这是在操作系统设计时保证的；软实时则只要按照任务的优先级，尽可能快地完成操作即可。我们通常使用的操作系统在经过一定改变之后就可以变成实时操作系统。 1.1.实时操作系统的相关概念 （1）实时操作系统的定义 实时操作系统是保证在一定时间限制内完成特定功能的操作系统。例如人驾驶的汽车中的系统，需要一个比较稳定的实时操作系统。在“硬”实时操作系统中，如果不能在允许时间内完成使物体可达的计算，操作系统将因错误结束。在“软”实时操作系统中，比如汽车不能很快的识别人的操作指令，那么它可能造成严重的事故（如：汽车的瞬时刹车；公交车，它能准确的报站，这其实就是一个实时操作系统的具体体现；其次，车上的GPS导航仪，其实质也是一个比较精确实时操作系统的产物，如果不能实时，那么导航仪将失效，结果不能正确的指导司机驾驶的方向，同时这种实时操作系统的及时性必须达到一定的程度:ms级）。一些实时操作系统是为特定的应用
设计的，另一些是通用的。一些通用目的的操作系统称自己为实时操作系统。但某种程度上，大部分通用目的的操作系统，如微软的Windows NT或IBM的OS/390有实时系统的特征。这就是说，即使一个操作系统不是严格的实时系统，它们也能解决一部分实时应用问题。 （2）实时操作系统中的一些重要的概念 代码临界段：指处理时不可分割的代码。一旦这部分代码开始执行则不允许中断打入； 资源：任何为任务所占用的实体； 共享资源：可以被一个以上任务使用的资源； 任务：也称作一个线程，是一个简单的程序。每个任务被赋予一定的优先级，有它自己的一套CPU寄存器和自己的栈空间。典型地，每个任 务都是一个无限的循环，每个任务都处在以下五个状态下：休眠 态，就绪态，运行态，挂起态，被中断态； 任务切换：将正在运行任务的当前状态（CPU寄存器中的全部内容）保存在任务自己的栈区，然后把下一个将要运行的任务的当前状态从该任 务的栈中重新装入CPU的寄存器，并开始下一个任务的运行； 内核：负责管理各个任务，为每个任务分配CPU时间，并负责任务之间通讯。分为不可剥夺型内核和可剥夺型内核； 调度：内核的主要职责之一，决定轮到哪个任务运行。一般基于优先级调度法； （3）及时性 关于实时操作系统的及时性，我将从如下两个方面进行介绍：实时操作系统的时间限和实时操作系统的应用相关。 时间限：对一些实时性要求较高的系统，它们要求的时间限一般是毫秒级（ms），但是通常的实时操作系统，一般是秒级（s）或是在
四种实时操作系统特性进行分析和比较 https://www.doczj.com/doc/8e18683367.html,2006年11月18日21:55ChinaByte 本文对四种实时操作系统(RTOS)特性进行分析和比较。它们是:Lynx实时系统公司的LynxOS、QNX软件系统有限公司的QNX以及两种具有代表性的实时Linux——新墨西哥工学院的RT-Linux和堪萨斯大学的KURT-Linux。 近年来，实时操作系统在多媒体通信、在线事务处理、生产过程控制、交通控制等各个领域得到广泛的应用，因而越来越引起人们的重视。 基本特征概述 *QNX是一个分布式、嵌入式、可规模扩展的实时操作系统。它遵循POSIX.1 (程序接口)和POSIX.2(Shell和工具)、部分遵循POSIX.1b(实时扩展)。它最早开发于1980年，到现在已相当成熟。 *LynxOS是一个分布式、嵌入式、可规模扩展的实时 操作系统，它遵循POSIX.1a、POSIX.1b和POSIX.1c标准。它最早开发于1988年。 *RT-Linux是一个嵌入式硬实时操作系统，它部分支持POSIX.1b标准。 *KURT-Linux不是为嵌入式应用设计的，不同于硬(hard)实时/软(soft)实时应用，他们提出“严格(firm)”实时应用的概念，如一些多媒体应用和ATM网络应用，KURT是为这样一些应用设计的“严格的”实时系统。 体系结构异同 实时系统的实现多为微内核体系结构，这使得核心小巧而可靠，易于ROM固化，并可模块化扩展。微内核结构系统中，OS服务模块在独立的地址空间运行，所以，不同模块的内存错误便被隔离开来。但它也有弱点，进程间通信和上下文切换的开销大大增加。相对于大型集成化内核系统来说，它必须靠更多地进行系统调用来完成相同的任务。 *QNX是一个微内核实时操作系统，其核心仅提供4种服务:进程调度、进程间通信、底层网络通信和中断处理，其进程在独立的地址空间运行。所有其它OS服务，都实现为协作的用户进程，因此QNX核心非常小巧(QNX4.x大约为12Kb)而且运行速度极快。 *LynxOS目前还不是一个微内核结构的操作系统，但它计划使用所谓的“Galaxy”技术将其从大型集成化内核改造成微内核，这一技术将在LynxOS 3.0中引入。新的28Kb微内核提供以下服务:核心启动和停止、底层内存管理、出错处理、中断处理、多任务、底层同步和互斥支持。
第一章 ★1.操作系统的概念：通常把操作系统定义为用以控制和管理计算机系统资源方便用户使用的程序和数据结构的集合。★2.操作系统的基本类型：批处理操作系统、分时操作系统、实时操作系统、个人计算机操作系统、网络操作系统、分布式操作系统。 ①批处理操作系统 特点： 用户脱机使用计算机 成批处理 多道程序运行 优点： 由于系统资源为多个作业所共享，其工作方式是作业之间自动调度执行。并在运行过程中用户不干预自己的作业，从而大大提高了系统资源的利用率和作业吞吐量。 缺点： 无交互性，用户一旦提交作业就失去了对其运行的控制能力；而且是批处理的，作业周转时间长，用户使用不方便。 批处理系统中作业处理及状态 ②分时操作系统(Time Sharing OS) 分时操作系统是一个联机的多用户交互式的操作系统，如UNIX是多用户分时操作系统。 分时计算机系统：由于中断技术的使用，使得一台计算机能连接多个用户终端，用户可通过各自的终端使用和控制计算机，我们把一台计算机连接多个终端的计算机系统称为分时计算机系统，或称分时系统。 分时技术：把处理机的响应时间分成若于个大小相等（或不相等）的时间单位，称为时间片（如100毫秒），每个终端用户获得CPU，就等于获得一个时间片，该用户程序开始运行，当时间片到（用完），用户程序暂停运行，等待下一次运行。 特点： 人机交互性好：在调试和运行程序时由用户自己操作。 共享主机：多个用户同时使用。 用户独立性：对每个用户而言好象独占主机。 ③实时操作系统(real-time OS) 实时操作系统是一种联机的操作系统，对外部的请求，实时操作系统能够在规定的时间内处理完毕。 特点： 有限等待时间 有限响应时间 用户控制 可靠性高 系统出错处理能力强 设计实时操作系统要考虑的一些因素： （1）实时时钟管理 （2）连续的人—机对话 （3）过载 (4) 高度可靠性和安全性需要采取冗余措施。 ④通用操作系统 同时兼有多道批处理、分时、实时处理的功能，或其中两种以上的功能。 ⑤个人计算机上的操作系统
嵌入式实时操作系统实验报告 任务间通信机制的建立 系别计算机与电子系 专业班级***** 学生姓名****** 指导教师 ****** 提交日期 2012 年 4 月 1 日
一、实验目的 掌握在基于嵌入式实时操作系统μC/OS-II的应用中，任务使用信号量的一般原理。掌握在基于优先级的可抢占嵌入式实时操作系统的应用中，出现优先级反转现象的原理及解决优先级反转的策略——优先级继承的原理。 二、实验内容 1.建立并熟悉Borland C 编译及调试环境。 2.使用课本配套光盘中第五章的例程运行（例5-4,例5-5，例5-6），观察运行结果，掌握信号量的基本原理及使用方法，理解出现优先级反转现象的根本原因并提出解决方案。 3.试编写一个应用程序，采用计数器型信号量（初值为2），有3个用户任务需要此信号量，它们轮流使用此信号量，在同一时刻只有两个任务能使用信号量，当其中一个任务获得信号量时向屏幕打印“TASK N get the signal”。观察程序运行结果并记录。 4. 试编写一个应用程序实现例5-7的内容，即用优先级继承的方法解决优先级反转的问题，观察程序运行结果并记录。 5.在例5-8基础上修改程序增加一个任务HerTask,它和YouTask一样从邮箱Str_Box里取消息并打印出来，打印信息中增加任务标识，即由哪个任务打印的；MyTask发送消息改为当Times为5的倍数时才发送，HerTask接收消息采用无等待方式，如果邮箱为空，则输出“The mailbox is empty”, 观察程序运行结果并记录。 三、实验原理 1. 信号量 μC/OS-II中的信号量由两部分组成：一个是信号量的计数值，它是一个16位的无符号整数（0 到65,535之间）；另一个是由等待该信号量的任务组成的等待任务表。用户要在OS_CFG.H中将OS_SEM_EN开关量常数置成1，这样μC/OS-II 才能支持信号量。
计算机操作系统学习总结一填空： 1．操作系统为用户提供三种类型的使用接口，它们是命令方式和系统调用和图形用户界面。 2．进程在执行过程中，因时间片用完将进入就绪状态。 3．在响应比最高者优先的作业调度算法中，当各个作业等待时间相同时，运行时间短的作业将得到优先调度；当各个作业要求运行的时间相同时，等待时间长的作业得到优先调度。 4．当一个进程独占处理器顺序执行时，具有两个特性：封闭性和可再现性。5．程序经编译或汇编以后形成目标程序，其指令的顺序都是以零作为参考地址，这些地址称为逻辑地址。 6．文件的逻辑结构分流式文件和记录式文件二种。 7．进程由程序、数据和进程控制块（PCB）组成。 8．对信号量S的操作只能通过原语操作进行，对应每一个信号量设置了一个等待队列。 9．操作系统是运行在计算机裸机系统上的最基本的系统软件。 10．虚拟设备是指采用SPOOLING技术，将某个独享设备改进为供多个用户使用的的共享设备。 11．在分时系统中，时间片给定，用户数越多，响应时间越长。 12．段式管理中，以段为单位，每段分配一个连续区。由于各段长度不同，所以这些存储区的大小不一，而且同一进程的各段之间不要求连续。 13．逻辑设备表（LUT）的主要功能是实现设备独立性。
14在采用请求分页式存储管理的系统中，地址变换过程可能会因为缺页和越界等原因而产生中断。 的调度分为高级、中级和低级三种，其中低级调度是指进程调度。 17．文件的物理结构分为顺序文件、索引文件和索引顺序文件。 18．所谓设备控制器，是一块能控制一台或多台外围设备与CPU并行工作的硬件。 19.?利用文件目录实现文件共享，文件系统必须设置一个基本文件目录。20分页管理储管理方式能使存储碎片尽可能少，而且使内存利用率较高，管理开销小。20.?计算机操作系统是方便用户、管理和控制计算机软硬件资源的系统软件。 21.?操作系统目前有五大类型：批处理操作系统、分时操作系统、实时操作系统、网络操作系统和分布式操作系统。 22.按文件的逻辑存储结构分，文件分为有结构文件，又称为记录式文件和无结构文件，又称流式文件。 23.航空订票系统属于实时操作系统。 24、在设备管理中，为了克服独占设备速度较慢、降低设备资源利用率的缺点，引入了虚拟分配技术，即用共享设备模拟独占设备。 25、常用的内存管理方法有分区管理、页式管理、段式管理和段页式管理。 26、CPU交替执行系统内核程序和用户程序，这种CPU的不同工作模式称为管态和目态 。 27、在存储管理中常用虚拟存储器方式来摆脱主存容量的限制。 28、在请求页式管理中，当硬件变换机构发现所需的页不在内存时，产生缺页中断信号，中断处理程序作相应的处理。 29、碎片现象的存在使得内存空间利用率降低。
???VxWorks 偠 ? Laboratory Tutorial for Embedded Real ˉtime Operating System VxWorks ?? ? ? ? ? ? ? 2003 10
???VxWorks 偠 ? ? 1 ???? (1) 1.1 ?? (1) 1.2 ??? (7) 2 ? MPC860 (16) 3 ???VxWorks ? ? Tornado (25) 3.1 ???VxWorks (25) 3.2 Tornado? ? (43) 4 VxWorks?BootRom (48) 5 偠 (55) 5.1 偠??Tornado??? (55) 5.2 偠?? ??? ? ? (74) 5.3 偠?? ? ? ?? (78) 5.4 偠 ?? ??? (101) 5.5 偠?? ?????? ?? (110) 5.6 偠 ? ?????? ?? (116) ? A hwa-xpc860 偠 (120)
1 ???? ?? ?? 催? ?? ??? ?? ? ? ?? ??Ё?????? ? ?? ?? ? ? ?? ?? (Embebdded computer) Ё??? ?? ? ??? ⑤?20??60 ?? ????? ? ????? ? 1.1.1 ???? ??? ?? ? Н? ??? ????? ?? ?? ???? ???? ?? ?? ?? ?? ???? ??? ????? ? ?????BIOS? ? ? ???? ?催 ? ? ? ㄝ???? ? ??? ? ? ? ?????????? ???? ?? ? ? ? ? ???? ?? ? ? ???? ?ㄝ???? ???? ??? ? ? ??? ? ???? ? ? ?? ㄝ ?? ? ??? ? ?? ? (control)???Mointer) ??(Managemet)ㄝ ?? 1.1.2 ? ?????? ? ? 1.1. 2.1 ? ?? ? ?? ??4?? ? 1? ? ? ? ?? ? ? ???Ё ????? ???? ?? ? ? ?? ?2? ? ??? ?? ?????? ? ????? ??? П? ??? ??????? ? ?? ???? ? 3? ? ? ? ????? ?? ? 催 ? ? ? 4? ? 乏 ? ?? ?? ? ? ? ??? ? ? Ё??∴??? ?? ?? ?? ? mW??uW??1.1.2.2 ? ???? ???? ?? ?? ? ? ?? ? ??? ?? ? ? ? ? ???1000 ??????? 30 ?? ?
实时操作系统实验报告 专业：11通信工程 学号：20110306136 姓名: 王帅 指导老师：申屠浩
实验二 任务管理实验 实验目的： 1、理解任务管理的基本原理，了解任务的各个基本状态及其变迁过程； 2、掌握μC/OS -II 中任务管理的基本方法（挂起、解挂）； 3、熟练使用μC/OS -II 任务管理的基本系统调用。 实验要求与思路： 为了体现任务的各个基本状态及其变迁过程，本实验设计了T0、T1和T3三个任务，它们交替运行，如图2-2所示。 T0 T1 T2 T3 T4 T5 T6 T7 T8 图2-2 注意： 图中的栅格并不代表严格的时间刻度，而仅仅表现各任务启动和执行的相对先后关系。 说明： 在系统完成初始化后，可以先创建并启动优先级最低的TaskStart ，由它创建其他3个应用任务T0、T1和T2，之后整个系 T0 T2 T1 T0 T1 T2 T1 T0
统的运行流程如下： 1）优先级最高的T0开始执行，之后T0挂起自己； 2）然后系统调度选中T1开始执行，之后T1挂起自己； 3）接着系统调度选中T2,之后唤醒T0； 4）如此循环 实现提示： 在启动任务中创建三个任务后，应挂起任务1和任务2。 在每个任务恢复其它任务并挂起自己之前，显示当前三个任务的状态，并延时1秒。 函数说明： void PC_GetDateTime (char *s)； 获取"YYYY-MM-DD HH:MM:SS"格式的时间字串存放在字符串s中，s的长度最少为21字节。 void PC_DispStr (INT8U x, INT8U y, INT8U *s, INT8U color)； 在y行x列以color颜色值显示字串s，注意color由背景色和前景色两种颜色构成。 INT8U OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)； 按时、分、秒、毫秒设置进行延时。 void OSTimeDly (INT16U ticks) 按ticks值进行延时，1 ticks一般为10ms。 INT32U OSTimeGet (void)
一．什么是真正的实时操作系统 做嵌入式系统开发有一段时间了，做过用于手机平台的嵌入式Linux，也接触过用于交换机、媒体网关平台的VxWorks，实际应用后回过头来看理论，才发现自己理解的肤浅，也发现CSDN 上好多同学们都对实时、嵌入式这些概念似懂非懂，毕竟如果不做类似的产品，平时接触的机会很少，即使做嵌入式产品开发，基本也是只管调用Platformteam封装好的API。所以在此总结一下这些概念，加深自己的理解，同时也给新手入门，欢迎大家拍砖，争取写个连载，本文先总结一下实时的概念，什么是真正的实时操作系统？ 1. 首先说一下实时的定义及要求： 参见 Donal Gillies 在 Realtime Computing FAQ 中提出定义：实时系统指系统的计算正确性不仅取决于计算的逻辑正确性，还取决于产生结果的时间。如果未满足系统的时间约束，则认为系统失效。
一个实时操作系统面对变化的负载（从最小到最坏的情况）时必须确定性地保证满足时间要求。请注意，必须要满足确定性，而不是要求速度足够快！例如，如果使用足够强大的CPU，Windows在CPU空闲时可以提供非常短的典型中断响应，但是，当某些后台任务正在运行时，有时候响应会变得非常漫长，以至于某一个简单的读取文件的任务会长时间无响应，甚至直接挂死。这是一个基本的问题：并不是Windows不够快或效率不够高，而是因为它不能提供确定性，所以，Windows不是一个实时操作系统。 根据实际应用，可以选择采用硬实时操作系统或软实时操作系统，硬实时当然比软实时好，但是，如果你的公司正在准备开发一款商用软件，那请你注意了，业界公认比较好的VxWorks(WindRiver开发)，会花光你本来就很少的银子，而软实时的操作系统，如某些实时Linux，一般是开源免费的，我们公司本来的产品就是基于VxWorks的，现在业界都在CostReduction，为了响应号召，正在调研如何把平台换成免费的嵌入式实时Linux。同学们，如何选择，自己考虑吧:-)
计算机操作系统期末简答题总结 1、什么是进程,什么是线程,进程与线程有何区别, 答:(1)进程是具有独立功能程序在某个数据集合上的一次执行过程。(2分) (2)线程是进程内的一个执行实体或执行单元。(2分) (3)进程和线程的区别:(a)不同进程的地址空间是独立的，而同一进程内的线程共享同一地址空间。一个进程的线程在另一个进程内是不可见的。(b) 在引入线程的操作系统中，进程是资源分配和调度的单位，线程是处理机调度和分配的单位，资源是分配给进程的，线程只拥有很少资源，因而切换代价比进程切换低。(2分) 2、什么是死锁,产生死锁的原因和必要条件是什么, 答:(1)在多道程序系统中，当一组进程中的每个进程均无限期地等待被改组进程中的另一进程所占有且永远不会释放的资源，此时的系统处于死锁状态，简称死锁。(2分) (2)死锁产生的原因:(a)系统提供的资源有限;(b)进程推进顺序不当。(2分) (3)产生死锁的必要条件:互斥条件、不可剥夺条件、请求和保持条件、循环等待条件。 3、说明作业调度，中级调度和进程调度的区别，并分析下述问题应由哪一级调度程序负责。 (1) 在可获得处理机时，应将它分给哪个就绪进程; (2) 在短期繁重负载下，应将哪个进程暂时挂起。 答:(1) 作业调度用于决定把外存中处于后备队列中的哪些作业调入内存，并为它们创建进程，分配资源，然后将新创建进程插入就绪队列;中级调度负责将内存中暂时不具备运行条件的进程换到外存交换区存放，但内存空闲时，又将外存中
具备运行条件的进程重新换入内存;进程调度决定将处理机分配给就绪进程队列的 哪个进程。(4分) (2)进程调度、中级调度(2分) 4.什么是操作系统,它的主要功能有哪些, 操作系统是一组控制和管理计算机硬件和软件资源，合理的对各类作业进行调度，以及方便用户使用的程序的集合。它包含四种功能:处理机管理、内存管理、 设备管理和文件管理 5.什么是处理机的三级调度，它们在什么条件下发生, 高级调度、中级调度和低级调度 高级调度:当系统决定选择一个后备作业调入内存运行时; 中级调度:在内存紧张不能满足需要时; 低级调度:选择一个就绪进程投入运行时。 6.比较分段式与分页式存储管理方式的主要差别。 (1)页是物理单位目的是提高内存的使用率,段式逻辑单位目的是方便用户使用; (2)页的大小是固定的由系统决定;段的大小不固定且由用户决定; (3)分页作业的地址空间是一维的;分段作业的地址空间是二维的; 7. 什么是多道程序设计?为什么要采用多道程序设计? 多道程序设计是一种软件技术，该技术使同时进入计算机主存的几个相互独立 的程序在管理程序控制之下相互交替地运行。引入多道程序设计，可具有以下好处:(1)可提高CPU的利用率;(2)可提高主存和I/O设备利用率;(3)可增加系统吞吐量; 8.简述死锁的防止与死锁的避免的区别。 死锁的防止是系统预先确定一些资源分配策略，进程按规定申请资源，系统按 预先规 定的策略进行分配，从而防止死锁的发生。
操作系统实验心得 每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美，但是我总是很投入的去研究去学习。所以在这两周的课设中，熬了2个通宵，生物钟也严重错乱了。但是每完成一个任务我都兴奋不已。一开始任务是任务，到后面任务就成了自己的作品了。总体而言我的课设算是达到了老师的基本要求。总结一下有以下体会。 1、网络真的很强大，用在学习上将是一个非常高效的助手。几乎所有的资料都能够在网上找到。从linux虚拟机的安装，到linux的各种基本命令操作，再到gtk的图形函数，最后到文件系统的详细解析。这些都能在网上找到。也因为这样，整个课程设计下来，我浏览的相关网页已经超过了100个（不完全统计）。当然网上的东西很乱很杂，自己要能够学会筛选。不能决定对或错的，有个很简单的方法就是去尝试。就拿第二个实验来说，编译内核有很多项小操作，这些小操作错了一项就可能会导致编译的失败，而这又是非常要花时间的，我用的虚拟机，编译一次接近3小时。所以要非常的谨慎，尽量少出差错，节省时间。多找个几个参照资料，相互比较，慢慢研究，最后才能事半功倍。 2、同学间的讨论，这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。能和学长学姐讨论当然再好不过了，没有这个机会的话，和自己班上同学讨论也是能够受益匪浅的。
大家都在研究同样的问题，讨论起来，更能够把思路理清楚，相互帮助，可以大大提高效率。 3、敢于攻坚，越是难的问题，越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的，毕竟有了精力才能够打持久战。但是做课设一定要有状态，能够在吃饭，睡觉，上厕所都想着要解决的问题，这样你不成功都难。 4、最好在做课设的过程中能够有记录的习惯，这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到的段错误的问题，让我都不知道从何下手。在经过大量的资料查阅之后，我对段错误有了一定的了解，并且能够用相应的办法来解决。 在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的 1)访问系统数据区，尤其是往系统保护的内存地址写数据，最常见就是给一个指针以0地址 2)内存越界(数组越界，变量类型不一致等) 访问到不属于你的内存区域 3）其他 例如： <1>定义了指针后记得初始化，在使用的时候记得判断是否为 null <2>在使用数组的时候是否被初始化，数组下标是否越界，数组元素是否存在等 <3>在变量处理的时候变量的格式控制是否合理等
Ch1 1. 操作系统的定义（填空题、选择题、简答题） 操作系统是配置在计算机硬件上的第一层软件，是对硬件系统的首次扩充。操作系统是控制和管理计算机硬件和软件资源，合理的组织计算机的工作流程，以及方便用户的程序集合。 2. 从资源管理的角度看，操作系统的主要功能。（填空题） 处理机管理：用于分配和控制处理机 存储器管理：主要负责内存的分配和回收 i/o设备管理：负责i/o设备的分配和操纵 文件管理：负责文件的存取，共享和保护 3. 理解操作系统的主要特性：并发性、共享性和异步性。（选择 题） 并发性：是指两个或两个以上的事件或活动在同一时间间隔内发生。 共享性：指系统中的资源可供内存中多个并发执行的进程共同使用，而不是被一个进程所独占，相应的，把这种资源共同使用称为资源共享，或资源复用。 异步性：在多道程序环境中，允许多个进程并发执行，由于资源有限而进程众多，多数情况，进程的执行不是一贯到底，而是“走走停停”的方式运行。 虚拟技术：指通过某种技术把一个物理实体变为若干个逻辑上的对应物。时分复用技术，空分复用技术。 4. 理解操作系统的基本类型：批处理操作系统、分时操作系统和 实时操作系统。（选择题） 单道批处理系统：自动性，顺序性，单道性。 多道批处理系统：可以进一步提高资源的利用率和系统吞吐量。优点：资源利用率高、系统吞吐量大；缺点：平均周转时间长、无交互能力。好处：1.提高CPU的利用率2.提高内存和i/o设备利用率3.增加系统吞吐量。 分时操作系统：能很好的将一台计算机提供给多个用户同时使用，提高计算机的利用率。它被经常应用于查询系统，满足许多查询用户的需要。 实时操作系统：指系统能及时响应外部事件的请求，在规定事件内完成对事件的处理，并控制所有实时任务协调一致的运行。 5. 用户与操作系统之间的接口：系统调用和操作命令。（填空 题） 用户接口：它是提供给用户使用的接口，用户可通过该接口取得操作系
实验报告 实验课程名称：操作系统 实验地点：南主楼七楼机房 2018—2019学年（一）学期 2018年 9月至 2019 年 1 月 专业： 班级： 学号： 姓名： 指导老师：刘一男
实验一 实验项目：分时系统模拟 实验学时：2实验日期： 2018-10-25 成绩： 实验目的利用程序设计语言模拟分时系统中多个进程按时间片轮转调度算法进行进程调度的过程； 假设有五个进程A，B，C，D，E，它们的到达时间及要求服务的时间分别为：进程名 A B C D E 到达时间0 1 2 3 4 服务时间 4 3 4 2 4 时间片大小为1，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：BDACE
（1）修改时间片大小为2，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间。 轮转调度：ADBCE （2）修改时间片大小为4，利用程序模拟A，B，C，D，E五个进程按时间片轮转的调度及执行过程并计算各进程的周转时间及带权周转时间.
顺序：ABCDE 1、思考 时间片的大小对调度算法产生什么影响？对计算机的性能产生什么影响？答：通过对时间片轮转调度算法中进程最后一次执行时间片分配的优化,提出了一种改进的时间片轮转调度算法,该算法具有更好的实时性,同时减少了任务调度次数和进程切换次数,降低了系统开销,提升了CPU的运行效率,使操作系统的性能得到了一定的提高。 A B C D E 时间片为1 周转时间12 9 14 8 13 3 3 3.5 4 3.25 带权周转 时间 时间片为2 周转时间8 12 13 7 13 2 4 3.25 3.5 3.25 带权周转 时间 时间片为4 周转时间 4 6 9 10 13 1 2 2.25 5 3.25 带权周转 时间