前言
>_<" 这里仿照窗口管理的方式将任务管理也修改成相应的管理模式，这样可以灵活的添加多个任务，而不必每次都要修改任务切换函数；此外还在任务休眠做了尝试，通过将任务挂起和唤醒从而加快运行速度~
一、任务管理自动化
>_<" 为了仿照窗口管理模式对任务进行管理，于是在bootpack.h里做如下定义：
/* mtask.c 任务切换相关*/
#define MAX_TASKS 1000 /* 最大任务数量 */
#define TASK_GDT0 3 /* 定义从GDT的几号开始分配给TSS */ struct TSS32 {//task status segment 任务状态段
int backlink, esp0, ss0, esp1, ss1, esp2, ss2, cr3;//保存的不是寄存器的数据，而是与任务设置相关的信息，在执行任务切换的时候这些成员不会被写入（backlink除外，某些情况下会被写入）
int eip, eflags, eax, ecx, edx, ebx, esp, ebp, esi, edi;//32位寄存器
int es, cs, ss, ds, fs, gs;//16位寄存器
int ldtr, iomap;//有关任务设置部分
};
struct TASK {
int sel, flags; /* sel用来存放GDT的编号 */
struct TSS32 tss;
};
struct TASKCTL {
int running; /* 正在运行的任务量数 */
int now; /* 这个变量用来记录当前正在运行的任务是哪一个 */
struct TASK *tasks[MAX_TASKS];
struct TASK tasks0[MAX_TASKS];
};
extern struct TIMER *task_timer;
struct TASK *task_init(struct MEMMAN *memman);//初始化任务控制
struct TASK *task_alloc(void);//分配一个任务
void task_run(struct TASK *task);//将task添加到tasks的末尾，然后running加1
void task_switch(void);//running为1的时候不用进行任务切换，函数直接结束，当running大于2的时候，先把now加1
//再把now代表的任务切换成当前的任务，最后再将末尾的任务移到开头
PS：可以看出和窗口管理很相似，TASK是一个任务，TASKCTL是任务管理结构体
>_<" 下面是对应的任务管理.c文件，其中task_init函数是初始化任务控制，task_alloc是分配一个任务函数，task_run其实就相当于唤醒，task_switch任务切换
/* 任务管理相关程序 */ #include "bootpack.h" struct TASKCTL *taskctl;
struct TIMER *task_timer; /////////////////////////////////////////////////////////////////////////////////////
//功能：初始化任务控制
//参数：
//返回：返回一个内存地址，意思是现在正在运行这个程序，已经变成一个任务
struct TASK *task_init(struct MEMMAN *memman)
{
int i;
struct TASK *task;
struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof (struct TASKCTL));//TASKCTL是个很大的结构体，所以要申请一个内存空间
for (i = ; i < MAX_TASKS; i++) {
taskctl->tasks0[i].flags = ;
taskctl->tasks0[i].sel = (TASK_GDT0 + i) * ;
set_segmdesc(gdt + TASK_GDT0 + i, , (int) &taskctl->tasks0[i].tss, AR_TSS32);//定义在gdt的号，段长限制为103字节
}
task = task_alloc();
task->flags = ; /* 活动中标志 */
taskctl->running = ;
taskctl->now = ;
taskctl->tasks[] = task;
load_tr(task->sel);
//向TR寄存器写入这个值，因为刚才把当前运行任务的GDT定义为3号，TR寄存器是让CPU记住当前正在运行哪一个任务
//每当进行任务切换时，TR寄存器的值也会自动变换，task register
//每次给TR赋值的时候，必须把GDT的编号乘以8
task_timer = timer_alloc();
timer_settime(task_timer, );
return task;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：任务分配[遍历所有的任务，发现任务处于空闲状态的进行初始化]
//参数：
struct TASK *task_alloc(void)
{
int i;
struct TASK *task;
for (i = ; i < MAX_TASKS; i++) {
if (taskctl->tasks0[i].flags == ) {
task = &taskctl->tasks0[i];
task->flags = ; /* 正在使用标志 */
task->tss.eflags = 0x00000202; /* IF = 1; */
task->tss.eax = ; /* 这里先设置为0 */
task->tss.ecx = ;
task->tss.edx = ;
task->tss.ebx = ;
task->tss.ebp = ;
task->tss.esi = ;
task->tss.edi = ;
task->tss.es = ;
task->tss.ds = ;
task->tss.fs = ;
task->tss.gs = ;
task->tss.ldtr = ;//先这样设置
task->tss.iomap = 0x40000000;
return task;
}
}
return ; /* 全部都正在使用 */
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：将task添加到tasks的末尾，然后running加1
//参数：
void task_run(struct TASK *task)
{
task->flags = ; /* 活动中标志 */
taskctl->tasks[taskctl->running] = task;
taskctl->running++;
return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：running为1的时候不用进行任务切换，函数直接结束，当running大于2的时候，先把now加1
//再把now代表的任务切换成当前的任务，最后再将末尾的任务移到开头
//参数：
void task_switch(void)
{
timer_settime(task_timer, );
if (taskctl->running >= ) {
taskctl->now++;
if (taskctl->now == taskctl->running) {
taskctl->now = ;
}
farjmp(, taskctl->tasks[taskctl->now]->sel);
}
return;
}
- 第17行，因为任务管理结构体很大，所以要提前分配内存
- 第18~22行，是初始化所有任务的flags,sel,以及定义每个任务的GDT
- 第23~34行，是生成一个基础的任务，并进行任务切换时钟设置
- 第39~65行，是遍历所有的任务，发现当前有没有使用的任务对其进行初始化并返回，实现任务分配的功能
- 第69~75行，是任务唤醒函数
- 第80~91行，是任务切换函数，当running=1时不进行切换，当running>2时，把now+1,然后把now所代表的当前任务进行切换，其中第85~87行的判断是当now跑到末尾时，让其跑到开头
二、任务休眠
>_<" 如果仅仅是采用上述方式，只能实现每个任务分配大约相同的时间，这样会导致过于平均而不是很优的策略~与其让一个任务空闲着不如直接让其挂起，将自己多出的时间都分配给另一些需要大量时间的任务来执行。这里就要用到休眠：即，将一个任务从tasks中删除。不过，当一个任务休眠时，当FIFO有数据传过来时还要让其唤醒，使其再具有数据处理能力~下面是mtask.c中的任务休眠函数：
/////////////////////////////////////////////////////////////////////////////////////
//功能：任务休眠，从任务数组中删除该任务，如果处于正在运行的任务，就让其休眠
//参数：
void task_sleep(struct TASK *task)
{
int i;
char ts = ;
if (task->flags == ) { /* 如果指定任务处于唤醒状态 */
if (task == taskctl->tasks[taskctl->now]) {
ts = ; /* 让自己休眠的话，稍后需要进行任务切换 */
}
/* 寻找task所在的位置 */
for (i = ; i < taskctl->running; i++) {
if (taskctl->tasks[i] == task) {
break;
}
}
taskctl->running--;//当前正在运行的任务数量减1
if (i < taskctl->now) {//欲休眠的任务在当前任务前，因为想删除该任务，所以当前任务标号要减1
taskctl->now--; /* 需要移动成员，所以做相应的处理 */
}
/* 移动成员 */
for (; i < taskctl->running; i++) {
taskctl->tasks[i] = taskctl->tasks[i + ];
}
task->flags = ; /* 不做工作的状态 */
if (ts != ) {
/* 任务切换 */
if (taskctl->now >= taskctl->running) {
/* now值越界进行让其变为开始 */
taskctl->now = ;
}
farjmp(, taskctl->tasks[taskctl->now]->sel);
}
}
return;
}
PS: 整个过程就类似于从数组中删除一个数据~就这么简单
>_<" 要实现唤醒功能，就要在FIFO结构体中加入用于记录唤醒任务的成员信息，如下：bootpack.h里的FIFO结构体
/* fifo.c */
struct FIFO32 {//FIFO缓冲区数据结构
int *buf;//缓冲区
int p, q, size, free, flags;//下一个数据的写入地址，下一个数据的读出地址，缓冲区的大小，free是缓冲区没有数据的字节数，flag是是否溢出
struct TASK *task;//当FIFO中写数据的时候将任务唤醒，用于记录要唤醒任务的信息
}; void fifo32_init(struct FIFO32 *fifo, int size, int *buf, struct TASK *task);//缓冲区结构体指针，大小，缓冲区开始位置，有数据写入的时候要唤醒任务的任务
int fifo32_put(struct FIFO32 *fifo, int data);//往缓冲区内插入一个数据，当有任务处于休眠的时候要唤醒S
int fifo32_get(struct FIFO32 *fifo);
int fifo32_status(struct FIFO32 *fifo);
>_<" 然后还要修改fifo32_init函数，其中最后一个参数就是指定的一个任务，如果不想使用任务自动唤醒功能，就将task置为0即可！
>_<" 接着要修改fifo32_put函数，实现向FIFO中写数据时，唤醒某个任务的功能~
int fifo32_put(struct FIFO32 *fifo, int data)
{
if (fifo->free == ) {//溢出
fifo->flags |= FLAGS_OVERRUN;
return -;
}
fifo->buf[fifo->p] = data;
fifo->p++;
if (fifo->p == fifo->size) {//当插入位置到达最后时再返回第一个位置
fifo->p = ;
}
fifo->free--;
if(fifo->task!=){//如果设置了有唤醒任务就唤醒
if(fifo->task->flags!=){//如果处于休眠状态
task_run(fifo->task);//将任务唤醒
}
}
return ;
}
/* bootpack */ #include "bootpack.h"
#include <stdio.h> void make_window8(unsigned char *buf, int xsize, int ysize, char *title);
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l);//字符串显示
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c);
void task_b_main(struct SHEET *sht_back); void HariMain(void)
{
struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
struct FIFO32 fifo;//定时器FIFO
char s[];
int fifobuf[];
struct TIMER *timer,*timer2,*timer3;//3个定时器
int mx, my, i ,cursor_x, cursor_c;//cursor_x是记录光标位置的变量，cursor_c表示光标现在的颜色
unsigned int memtotal;
struct MOUSE_DEC mdec;
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct SHTCTL *shtctl;//图层管理
struct SHEET *sht_back, *sht_mouse, *sht_win;//3个图层
unsigned char *buf_back, buf_mouse[], *buf_win;
static char keytable[0x54] = {//键盘映射表
, , '', '', '', '', '', '', '', '', '', '', '-', '^', , ,
'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', , , 'A', 'S',
'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', , , ']', 'Z', 'X', 'C', 'V',
'B', 'N', 'M', ',', '.', '/', , '*', , ' ', , , , , , ,
, , , , , , , '', '', '', '-', '', '', '', '+', '',
'', '', '', '.'
}; struct TASK *task_a , *task_b;//建立任务 init_gdtidt();//在dsctbl.c中，负责分区和中断分区初始化[包括键盘和鼠标中断设定]
init_pic();//在int.c中，负责中断初始化（硬件）
io_sti();//在naskfunc.nas中，仅仅执行STI指令，是CLI的逆指令，前者是开中断，后者是禁止中断
/*
同一占用一个fifo,这里：
0~1 光标闪烁用定时器
3 3秒定时器
10 10秒定时器
256~511 键盘输入（从键盘控制器读入的值再加上256)
512~767 鼠标输入（从键盘控制器读入的值再加上512)
*/
fifo32_init(&fifo, , fifobuf,);//初始化fifo，先让最后一个task参数为0，我们现在还没有初始化完成a任务
init_pit();//负责计时器初始化100hz
init_keyboard(&fifo, );//初始化键盘控制电路//在fifo.c中，负责缓冲区初始化（缓冲区结构体，大小，缓冲区首址）
enable_mouse(&fifo, , &mdec);//使能鼠标
/*这里IMR是(interrupt mask register),意思是“中断屏蔽寄存器”，是8位寄存器，分别对应8路IRQ信号，如果一路是1则该路被屏蔽，因为键盘中断是IRQ1,鼠标中断是IRQ12,且PIC分主从2个，从PIC连接主PIC的IRQ2,所以想要有鼠标和键盘中断，要PIC0的IRQ1和IRQ2，和PIC1的IRQ4*/
io_out8(PIC0_IMR, 0xf8); /* (11111000) *///PIT,PIC1,键盘许可
io_out8(PIC1_IMR, 0xef); /* (11101111) */ timer = timer_alloc();//4个定时器
timer_init(timer, &fifo, );
timer_settime(timer, );
timer2 = timer_alloc();
timer_init(timer2, &fifo, );
timer_settime(timer2, );
timer3 = timer_alloc();
timer_init(timer3, &fifo, );
timer_settime(timer3, ); //memman需要32KB内存
memtotal = memtest(0x00400000, 0xbfffffff);//计算总量memtatal
memman_init(memman);
memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff 将现在不用的字节以0x1000个字节为单位注册到memman里*/
memman_free(memman, 0x00400000, memtotal - 0x00400000); init_palette();//调色板
shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);//图层初始化函数
sht_back = sheet_alloc(shtctl);//分配一个背景窗口
sht_mouse = sheet_alloc(shtctl);//分配一个鼠标窗口
sht_win = sheet_alloc(shtctl);//分配一个小窗口
buf_back = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);//为背景窗口和普通小窗口分配缓存空间
buf_win = (unsigned char *) memman_alloc_4k(memman, * );
sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -); /* 设定涂层缓冲区的大小和透明色的函数 */
sheet_setbuf(sht_mouse, buf_mouse, , , );
sheet_setbuf(sht_win, buf_win, , , -); /* 设定涂层缓冲区的大小和透明色的函数 */
init_screen8(buf_back, binfo->scrnx, binfo->scrny);//初始化屏幕，画矩形，形成最初的窗口界面
init_mouse_cursor8(buf_mouse, );//准备鼠标指针(16*16),99是窗口背景颜色
make_window8(buf_win, , , "WINDOW");//就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
make_textbox8(sht_win, , , , , COL8_FFFFFF);//窗口上的文件编辑部分
cursor_x = ;
cursor_c = COL8_FFFFFF;
sheet_slide(sht_back, , );//上下左右移动窗口,即移动窗口至0,0
mx = (binfo->scrnx - ) / ; /* 计算鼠标初始位置 */
my = (binfo->scrny - - ) / ;
sheet_slide(sht_mouse, mx, my);//移动鼠标窗口
sheet_slide(sht_win, , );//移动消息窗口
sheet_updown(sht_back, );//设置窗口对的高度，背景在最下面
sheet_updown(sht_win, );
sheet_updown(sht_mouse, );
sprintf(s, "(%3d, %3d)", mx, my);//显示鼠标位置
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, );
sprintf(s, "memory %dMB free : %dKB",
memtotal / ( * ), memman_total(memman) / );
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, ); task_a = task_init(memman);//初始化任务管理器，task_init会返回自己的构造地址，我们将这个地址存入fifo.task
fifo.task = task_a;//记录休眠任务名
task_b = task_alloc();//分配一个任务b
task_b->tss.esp = memman_alloc_4k(memman, * ) + * - ;//给任务B分配栈空间
//要为任务B专门分配栈，直接用任务A的栈就会乱成一团糟
//这里任务B的函数式是带参数的，这里采用汇编函数参数传递的思想，传进任务B函数的参数其实就在[ESP+4]
//这里用申请的内存+64*1024要减8因为*((int *) (task_b_esp + 4)) = (int) sht_back;这句将sht_back写入task_b_esp + 4
//从这个地址开始向后写4字节的sht_back的值，正好在分配的内存范围
task_b->tss.eip = (int) &task_b_main;//任务B的入口函数
task_b->tss.es = * ;
task_b->tss.cs = * ;
task_b->tss.ss = * ;
task_b->tss.ds = * ;
task_b->tss.fs = * ;
task_b->tss.gs = * ;
*((int *) (task_b->tss.esp + )) = (int) sht_back;//任务B函数的参数
task_run(task_b);//运行任务B 将task添加到tasks的末尾，然后running加1 for (;;) {
io_cli();
if (fifo32_status(&fifo) == ) {
task_sleep(task_a);//应该在中断屏蔽的时候进入休眠状态
io_sti();
} else {
i = fifo32_get(&fifo);
io_sti();
if ( <= i && i <= ) {//键盘数据
sprintf(s, "%02X", i - );//减去256
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, );//清，显，刷
if (i < 0x54 + ) {
if (keytable[i - ] != && cursor_x < ) {//一般字符
/* 显示一次就前移一次光标 */
s[] = keytable[i - ];
s[] = ;
putfonts8_asc_sht(sht_win, cursor_x, , COL8_000000, COL8_FFFFFF, s, );
cursor_x += ;//记录光标位置
}
}
if (i == + 0x0e && cursor_x > ) { /* 退格键 */
/* 用空格键把光标消去后，后移1次光标 */
putfonts8_asc_sht(sht_win, cursor_x, , COL8_000000, COL8_FFFFFF, " ", );
cursor_x -= ;
}
/* 光标再显示 */
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, , cursor_x + , );
sheet_refresh(sht_win, cursor_x, , cursor_x + , );
}else if ( <= i && i <= ) {//鼠标数据
//已经收集了3字节的数据，所以显示出来
if (mouse_decode(&mdec, i - ) != ) {
sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
if ((mdec.btn & 0x01) != ) {
s[] = 'L';
}
if ((mdec.btn & 0x02) != ) {
s[] = 'R';
}
if ((mdec.btn & 0x04) != ) {
s[] = 'C';
}
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, );//清，显，刷
/* 移动鼠标 */
mx += mdec.x;
my += mdec.y;
if (mx < ) {
mx = ;
}
if (my < ) {
my = ;
}
if (mx > binfo->scrnx - ) {
mx = binfo->scrnx - ;
}
if (my > binfo->scrny - ) {
my = binfo->scrny - ;
}
sprintf(s, "(%3d, %3d)", mx, my);
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, );//清，显，刷
sheet_slide(sht_mouse, mx, my);
//移动窗口计算
if((mdec.btn & 0x01)!=){
sheet_slide(sht_win,mx-,my-);
}//按下左键移动sht_win
}
}else if(i==){//10s定时
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, "10[sec]", );//清，显，刷、
}else if (i == ) { //3秒定时器
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, "3[sec]", );
}else if (i<=) { //光标用定时器
if (i != ) {
timer_init(timer3, &fifo, ); /* 師偼0傪 */
cursor_c = COL8_000000;
} else {
timer_init(timer3, &fifo, ); /* 師偼1傪 */
cursor_c = COL8_FFFFFF;
}
timer_settime(timer3, );
boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, , cursor_x + , );
sheet_refresh(sht_win, cursor_x, , cursor_x + , );
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：就像制作背景和鼠标一样，先准备一张图，然后在图层内描绘一个貌似窗口的图就可以了
//参数：
void make_window8(unsigned char *buf, int xsize, int ysize, char *title)
{
static char closebtn[][] = {
"OOOOOOOOOOOOOOO@",
"OQQQQQQQQQQQQQ$@",
"OQQQQQQQQQQQQQ$@",
"OQQQ@@QQQQ@@QQ$@",
"OQQQQ@@QQ@@QQQ$@",
"OQQQQQ@@@@QQQQ$@",
"OQQQQQQ@@QQQQQ$@",
"OQQQQQ@@@@QQQQ$@",
"OQQQQ@@QQ@@QQQ$@",
"OQQQ@@QQQQ@@QQ$@",
"OQQQQQQQQQQQQQ$@",
"OQQQQQQQQQQQQQ$@",
"O$$$$$$$$$$$$$$@",
"@@@@@@@@@@@@@@@@"
};
int x, y;
char c;
boxfill8(buf, xsize, COL8_C6C6C6, , , xsize - , );
boxfill8(buf, xsize, COL8_FFFFFF, , , xsize - , );
boxfill8(buf, xsize, COL8_C6C6C6, , , , ysize - );
boxfill8(buf, xsize, COL8_FFFFFF, , , , ysize - );
boxfill8(buf, xsize, COL8_848484, xsize - , , xsize - , ysize - );
boxfill8(buf, xsize, COL8_000000, xsize - , , xsize - , ysize - );
boxfill8(buf, xsize, COL8_C6C6C6, , , xsize - , ysize - );
boxfill8(buf, xsize, COL8_000084, , , xsize - , );
boxfill8(buf, xsize, COL8_848484, , ysize - , xsize - , ysize - );
boxfill8(buf, xsize, COL8_000000, , ysize - , xsize - , ysize - );
putfonts8_asc(buf, xsize, , , COL8_FFFFFF, title);
for (y = ; y < ; y++) {
for (x = ; x < ; x++) {
c = closebtn[y][x];
if (c == '@') {
c = COL8_000000;
} else if (c == '$') {
c = COL8_848484;
} else if (c == 'Q') {
c = COL8_C6C6C6;
} else {
c = COL8_FFFFFF;
}
buf[( + y) * xsize + (xsize - + x)] = c;
}
}
return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：先图上背景颜色，再显示字符，最后完成刷新
//参数：图层，位置，字体颜色，背景颜色，字符串，字符串长度
void putfonts8_asc_sht(struct SHEET *sht, int x, int y, int c, int b, char *s, int l)
{
boxfill8(sht->buf, sht->bxsize, b, x, y, x + l * - , y + );
putfonts8_asc(sht->buf, sht->bxsize, x, y, c, s);
sheet_refresh(sht, x, y, x + l * , y + );
return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：描绘文字输入背景的
//参数：
void make_textbox8(struct SHEET *sht, int x0, int y0, int sx, int sy, int c)
{
int x1 = x0 + sx, y1 = y0 + sy;
boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - , y0 - , x1 + , y0 - );
boxfill8(sht->buf, sht->bxsize, COL8_848484, x0 - , y0 - , x0 - , y1 + );
boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x0 - , y1 + , x1 + , y1 + );
boxfill8(sht->buf, sht->bxsize, COL8_FFFFFF, x1 + , y0 - , x1 + , y1 + );
boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - , y0 - , x1 + , y0 - );
boxfill8(sht->buf, sht->bxsize, COL8_000000, x0 - , y0 - , x0 - , y1 + );
boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x0 - , y1 + , x1 + , y1 + );
boxfill8(sht->buf, sht->bxsize, COL8_C6C6C6, x1 + , y0 - , x1 + , y1 + );
boxfill8(sht->buf, sht->bxsize, c, x0 - , y0 - , x1 + , y1 + );
return;
}
/////////////////////////////////////////////////////////////////////////////////////
//功能：任务b的函数
//参数：
//附加：这里所使用的变量名和HariMain里面一样的，不过别担心，计算机会把他们当成不同的变量来处理
//这里，在每个任务重，当farjmp返回的时候，我们都将定时器设定到0.02s之后，以便让程序在返回0.02s之后再次执行任务切换
//这里的带参数传递采用了汇编函数的思想，
void task_b_main(struct SHEET *sht_back)
{
struct FIFO32 fifo;
struct TIMER *timer_put, *timer_1s;//2个定时器
int i, fifobuf[], count = , count0 = ;
char s[]; fifo32_init(&fifo, , fifobuf,);//B任务不需要再让FIFO唤醒
timer_put = timer_alloc();
timer_init(timer_put, &fifo, );//0.01s
timer_settime(timer_put, );
timer_1s = timer_alloc();//1s
timer_init(timer_1s, &fifo, );
timer_settime(timer_1s, ); for(;;){
count++;
io_cli();
if(fifo32_status(&fifo)==){
io_sti();
}else{
i=fifo32_get(&fifo);
io_sti();
if(i==){//0.01s刷新一次计数器显示用来加快速度
sprintf(s,"%11d",count);
putfonts8_asc_sht(sht_back,,,COL8_FFFFFF,COL8_008484,s,);
timer_settime(timer_put,);
}else if(i==){//1s刷新一次，计算1s内计数量
sprintf(s, "%11d", count - count0);
putfonts8_asc_sht(sht_back, , , COL8_FFFFFF, COL8_008484, s, );
count0 = count;
timer_settime(timer_1s, );
}
}
}
}
本次bootpack.c
三、效果展示
>_<" 可见比上一节讲的多任务要快很多，这主要是采用休眠的的结果~
aaarticlea/png;base64,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*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" alt="" width="432" height="341" />
四、相关链接
- 任务管理自动化链接13a:http://pan.baidu.com/s/1gdkpZsn
- 任务休眠链接13b:http://pan.baidu.com/s/1gd3mMrh