30天自制操作系统学习-第12天

最新推荐文章于 2023-03-03 21:52:17 发布
最新推荐文章于 2023-03-03 21:52:17 发布
阅读量404 收藏 1
点赞数 1
分类专栏： 30天制作操作系统学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq511714326/article/details/83006320
版权

 定时器

定时器的原理：每隔一段时间往CPU发送中断信号，因此CPU才不用自己去计量时间。在处理一些程序的时候，我们对程序设定一个时间，程序运行后，我们

nasfunc.nas中定时器的中断:

_asm_inthandler20:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler20
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

dsctbl.c中需要注册这一中断函数：

void init_gdtidt(void)
{
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
	struct GATE_DESCRIPTOR    *idt = (struct GATE_DESCRIPTOR    *) ADR_IDT;
	int i;

	/* GDT初始化 */
	for (i = 0; i <= LIMIT_GDT / 8; i++) {
		set_segmdesc(gdt + i, 0, 0, 0);
	}
	set_segmdesc(gdt + 1, 0xffffffff,   0x00000000, AR_DATA32_RW);
	set_segmdesc(gdt + 2, LIMIT_BOTPAK, ADR_BOTPAK, AR_CODE32_ER);
	load_gdtr(LIMIT_GDT, ADR_GDT);

	/* IDT初始化 */
	for (i = 0; i <= LIMIT_IDT / 8; i++) {
		set_gatedesc(idt + i, 0, 0, 0);
	}
	load_idtr(LIMIT_IDT, ADR_IDT);

	/* IDT设置*/
	set_gatedesc(idt + 0x20, (int) asm_inthandler20, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);

	return;
}

我们在注册完计时器的中断后，我们新建一个timer.c文件，用于处理时间方面的问题：

/* 定时器 */

#include "bootpack.h"

#define PIT_CTRL	0x0043
#define PIT_CNT0	0x0040

struct TIMERCTL timerctl;

#define TIMER_FLAGS_ALLOC 1 /* 已配置状态 */
#define TIMER_FLAGS_USING 2 /* 定时器运行中 */

void init_pit(void)
{
	int i;
	io_out8(PIT_CTRL, 0x34);
	io_out8(PIT_CNT0, 0x9c);
	io_out8(PIT_CNT0, 0x2e);
	timerctl.count = 0;
	timerctl.next = 0xffffffff; /* 因为最初没有正在运行的定时器 */
	timerctl.using = 0;
	for (i = 0; i < MAX_TIMER; i++) {
	timerctl.timers0[i].flags = 0; /* 未使用 */
	}
	return;
}

struct TIMER *timer_alloc(void)
{
	int i;
	for (i = 0; i < MAX_TIMER; i++) {
		if (timerctl.timers0[i].flags == 0) {
			timerctl.timers0[i].flags = TIMER_FLAGS_ALLOC;
			return &timerctl.timers0[i];
		}
	}
	return 0; /* 没找到 */
}

void timer_free(struct TIMER *timer)
{
	timer->flags = 0; /* 未使用 */
	return;
}

void timer_init(struct TIMER *timer, struct FIFO8 *fifo, unsigned char data)
{
	timer->fifo = fifo;
	timer->data = data;
	return;
}

void timer_settime(struct TIMER *timer, unsigned int timeout)
{
	int e, i, j;
	timer->timeout = timeout + timerctl.count;
	timer->flags = TIMER_FLAGS_USING;
	e = io_load_eflags();
	io_cli();
	/* 搜索注册位置 */
	for (i = 0; i < timerctl.using; i++) {
		if (timerctl.timers[i]->timeout >= timer->timeout) {
			break;
		}
	}
	/* i号之后全部后移一位 */
	for (j = timerctl.using; j > i; j--) {
		timerctl.timers[j] = timerctl.timers[j - 1];
	}
	timerctl.using++;
	/* 插入到空位上 */
	timerctl.timers[i] = timer;
	timerctl.next = timerctl.timers[0]->timeout;
	io_store_eflags(e);
	return;
}

void inthandler20(int *esp)
{
	int i, j;
	io_out8(PIC0_OCW2, 0x60); /* 把IRQ-00信号接收完了的信息通知给PIC */
	timerctl.count++;
	if (timerctl.next > timerctl.count) {
		return; /* 还不到下一个时刻，所以结束*/
	}
	timerctl.next = 0xffffffff;
	for (i = 0; i < timerctl.using; i++) {
		/* timers的定时器都处于动作中，所以不确认flags */
		if (timerctl.timers[i]->timeout > timerctl.count) {
			break;
		}
		/* 超时*/
		timerctl.timers[i]->flags = TIMER_FLAGS_ALLOC;
		fifo8_put(timerctl.timers[i]->fifo, timerctl.timers[i]->data);
	}
	/* 正好有i个定时器超时了。其余的进行移位。 */
	timerctl.using -= i;
	for (j = 0; j < timerctl.using; j++) {
		timerctl.timers[j] = timerctl.timers[i + j];
	}
	if (timerctl.using > 0) {
		timerctl.next = timerctl.timers[0]->timeout;
	} else {
		timerctl.next = 0xffffffff;
	}
	return;
}

其中bootpack.h中timer.c中的声明：

/* timer.c */
#define MAX_TIMER 500/*最大计时器个数*/
struct TIMER {
	unsigned int timeout, flags;/*标志计时器的状态*/
	struct FIFO8 *fifo;
	unsigned char data;
};
struct TIMERCTL {
	unsigned int count, next, using;
	struct TIMER *timers[MAX_TIMER];
	struct TIMER timers0[MAX_TIMER];
};
extern struct TIMERCTL timerctl;

void init_pit(void);
struct TIMER *timer_alloc(void);
void timer_free(struct TIMER *timer);
void timer_init(struct TIMER *timer, struct FIFO8 *fifo, unsigned char data);
void timer_settime(struct TIMER *timer, unsigned int timeout);
void inthandler20(int *esp);

bootpack.c:

/* bootpack*/

#include "bootpack.h"
#include <stdio.h>

void make_window8(unsigned char *buf, int xsize, int ysize, char *title);

void HariMain(void)
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	struct FIFO8 timerfifo, timerfifo2, timerfifo3;
	char s[40], keybuf[32], mousebuf[128], timerbuf[8], timerbuf2[8], timerbuf3[8];
	struct TIMER *timer, *timer2, *timer3;
	int mx, my, i;
	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;
	unsigned char *buf_back, buf_mouse[256], *buf_win;

	init_gdtidt();
	init_pic();
	io_sti(); /* IDT/PIC的初始化已经完成，于是开放CPU的中断 */
	fifo8_init(&keyfifo, 32, keybuf);
	fifo8_init(&mousefifo, 128, mousebuf);
	init_pit();
	io_out8(PIC0_IMR, 0xf8); /* PIT和PIC1和键盘设置为许可(11111000) */
	io_out8(PIC1_IMR, 0xef); /* 开放鼠标中断(11101111) */

	fifo8_init(&timerfifo, 8, timerbuf);
	timer = timer_alloc();
	timer_init(timer, &timerfifo, 1);
	timer_settime(timer, 1000);
	fifo8_init(&timerfifo2, 8, timerbuf2);
	timer2 = timer_alloc();
	timer_init(timer2, &timerfifo2, 1);
	timer_settime(timer2, 300);
	fifo8_init(&timerfifo3, 8, timerbuf3);
	timer3 = timer_alloc();
	timer_init(timer3, &timerfifo3, 1);
	timer_settime(timer3, 50);

	init_keyboard();
	enable_mouse(&mdec);
	memtotal = memtest(0x00400000, 0xbfffffff);
	memman_init(memman);
	memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff */
	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, 160 * 52);
	sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); /* 没有透明色 */
	sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99); /* 透明色号99 */
	sheet_setbuf(sht_win, buf_win, 160, 52, -1); /* 没有透明色 */
	init_screen8(buf_back, binfo->scrnx, binfo->scrny);
	init_mouse_cursor8(buf_mouse, 99); /* 背景色号99 */
	make_window8(buf_win, 160, 52, "counter");
	sheet_slide(sht_back, 0, 0);
	mx = (binfo->scrnx - 16) / 2; /* 按显示在画面中央来计算坐标 */
	my = (binfo->scrny - 28 - 16) / 2;
	sheet_slide(sht_mouse, mx, my);
	sheet_slide(sht_win, 80, 72);
	sheet_updown(sht_back,  0);
	sheet_updown(sht_win,   1);
	sheet_updown(sht_mouse, 2);
	sprintf(s, "(%3d, %3d)", mx, my);
	putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
	sprintf(s, "memory %dMB   free : %dKB",
			memtotal / (1024 * 1024), memman_total(memman) / 1024);
	putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
	sheet_refresh(sht_back, 0, 0, binfo->scrnx, 48); /* 刷新文字 */

	for (;;) {
		sprintf(s, "%010d", timerctl.count);
		boxfill8(buf_win, 160, COL8_C6C6C6, 40, 28, 119, 43);
		putfonts8_asc(buf_win, 160, 40, 28, COL8_000000, s);
		sheet_refresh(sht_win, 40, 28, 120, 44); /* 到这里结束 */

		io_cli();
		if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) + fifo8_status(&timerfifo)
				+ fifo8_status(&timerfifo2) + fifo8_status(&timerfifo3) == 0) {
			io_sti(); /* 不做HLT */
		} else {
			if (fifo8_status(&keyfifo) != 0) {
				i = fifo8_get(&keyfifo);
				io_sti();
				sprintf(s, "%02X", i);
				boxfill8(buf_back, binfo->scrnx, COL8_008484,  0, 16, 15, 31);
				putfonts8_asc(buf_back, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
				sheet_refresh(sht_back, 0, 16, 16, 32); /* 刷新文字 */
			} else if (fifo8_status(&mousefifo) != 0) {
				i = fifo8_get(&mousefifo);
				io_sti();
				if (mouse_decode(&mdec, i) != 0) {
					/* 3字节都凑齐了，所以把它们显示出来*/
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
					if ((mdec.btn & 0x01) != 0) {
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
					putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
					sheet_refresh(sht_back, 32, 16, 32 + 15 * 8, 32);  /* 刷新文字 */
					/* 移动光标 */
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 1) {
						mx = binfo->scrnx - 1;
					}
					if (my > binfo->scrny - 1) {
						my = binfo->scrny - 1;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0, 79, 15); /* 消坐标 */
					putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s); /* 写坐标 */
					sheet_refresh(sht_back, 0, 0, 80, 16); /* 刷新文字 */
					sheet_slide(sht_mouse, mx, my); /* 包含sheet_refresh含sheet_refresh */
				}
			} else if (fifo8_status(&timerfifo) != 0) {
				i = fifo8_get(&timerfifo); /* 首先读入（为了设定起始点） */
				io_sti();
				putfonts8_asc(buf_back, binfo->scrnx, 0, 64, COL8_FFFFFF, "10[sec]");
				sheet_refresh(sht_back, 0, 64, 56, 80);
			} else if (fifo8_status(&timerfifo2) != 0) {
				i = fifo8_get(&timerfifo2); /* 首先读入（为了设定起始点） */
				io_sti();
				putfonts8_asc(buf_back, binfo->scrnx, 0, 80, COL8_FFFFFF, "3[sec]");
				sheet_refresh(sht_back, 0, 80, 48, 96);
			} else if (fifo8_status(&timerfifo3) != 0) {
				i = fifo8_get(&timerfifo3); /* 首先读入（为了设定起始点） */
				io_sti();
				if (i != 0) {
					timer_init(timer3, &timerfifo3, 0); /* 然后设置0 */
					boxfill8(buf_back, binfo->scrnx, COL8_FFFFFF, 8, 96, 15, 111);
				} else {
					timer_init(timer3, &timerfifo3, 1); /* 然后设置1 */
					boxfill8(buf_back, binfo->scrnx, COL8_008484, 8, 96, 15, 111);
				}
				timer_settime(timer3, 50);
				sheet_refresh(sht_back, 8, 96, 16, 112);
			}
		}
	}
}

void make_window8(unsigned char *buf, int xsize, int ysize, char *title)
{
	static char closebtn[14][16] = {
		"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, 0,         0,         xsize - 1, 0        );
	boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         xsize - 2, 1        );
	boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         0,         ysize - 1);
	boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         1,         ysize - 2);
	boxfill8(buf, xsize, COL8_848484, xsize - 2, 1,         xsize - 2, ysize - 2);
	boxfill8(buf, xsize, COL8_000000, xsize - 1, 0,         xsize - 1, ysize - 1);
	boxfill8(buf, xsize, COL8_C6C6C6, 2,         2,         xsize - 3, ysize - 3);
	boxfill8(buf, xsize, COL8_000084, 3,         3,         xsize - 4, 20       );
	boxfill8(buf, xsize, COL8_848484, 1,         ysize - 2, xsize - 2, ysize - 2);
	boxfill8(buf, xsize, COL8_000000, 0,         ysize - 1, xsize - 1, ysize - 1);
	putfonts8_asc(buf, xsize, 24, 4, COL8_FFFFFF, title);
	for (y = 0; y < 14; y++) {
		for (x = 0; x < 16; 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[(5 + y) * xsize + (xsize - 21 + x)] = c;
		}
	}
	return;
}

运行结果：

 

qq511714326
关注
专栏目录
《30天自制操作系统》学习笔记——第十二天
文行知的专栏
02-24 1246
好的，来进入今天的新内容吧！                                                            今天的内容是定时器。什么是定时器呢？就从功能上来说，其实很简单，就好像微波炉一样，你设定一个时间，然后从现在开始计时，到那个时间的时候提醒你。那我们要这样的功能干什么呢？可以实现鼠标的光标闪烁。有没有高级一点的？有，而且至关重要，在后面会讲到，
《30天自制操作系统》学习笔记——第十天
文行知的专栏
02-22 1200
来到第十天，很高兴啊，已经完成了大概三分之一的内容了！感觉写这个笔记，对自己还是很有用的。平日里看这种书，难免赶进度，草草浏览过。但是也因为要写笔记的因素，看得会相对认真一点。在回顾的时候看看自己以前的笔记，就会更快理清思路。                                               今天一开始，还是要继续昨天的内存管理内容。说来，对于内存管理这块，我还是
《30天自制操作系统》学习笔记--第12天
Tony的博客
12-05 1708
昨天一直在搭建环境，想在mac下实现书上制作镜像和编译连接相关文件的功能，无奈，弄了一天还是不太好用，看到另外一个微博上的童鞋用Linux完成了相关操作，想试一下，但os x上没有objcopy等命令，而且gcc好像也是改版的，而且现在被我折腾的连命令行下使用command line tools 都有问题，所以，我还是回来把笔记补上。一会儿再去弄，争取放假之前能把环境搞定，这样寒假就可以专心研制自
30天自制操作系统 第12、13天日志
人间烟火的博客
02-09 696
30天自制操作系统 day12\13一、 实验主要内容定时器（1）1、 内容1：使用定时器2、 内容2：计量时间3、 内容3：超时功能4、 内容4：设定多个定时器5、 内容5：加快中断处理（1）6、 内容6：加快中断处理（2）7、 内容7：加快中断处理（3）定时器（2）1、 内容1：简化字符串显示2、 内容2：重新调整FIFO缓冲区（1）3、 内容3：测试性能4、 内容4：重新调整FIFO缓冲区（2）5、 内容5：加快中断处理（4）6、 内容6：使用哨兵简化程序二、遇到的问题及解决方法1、 描述问题1：2、
30天自制操作系统之第12天 定时器（1）
08-09 2285
定时器的中断处理程序要保证高效率，需要进行一些优化，这里介绍优化的方法。对于一个操作系统来说，会有多个定时器，假设该操作系统维护了500个定时器，当每一次定时中断发生时（这里我们设定1秒发生100次中断），调用中断处理程序，中断处理程序会对这500个定时器进行if判断，看哪些正在被使用，这样1秒内，就会有500X100=10000次if判断，而中断处理程序最讲究节省时间。实际上，我们不必每发生一次
30天自制操作系统第12天harib09b
Loong_Matrix_World的博客
04-22 172
计量时间 harib09b 准备材料（windows环境） VMware Workstation Visual Studio Code 程序和源代码：https://pan.baidu.com/s/1bFGAYgnA0m9KB7tzFrMD5g 提取码：d210 Makefile windows 批处理 开始实验 在tolset文件夹下创建子文件侠harib09b。 打开记事本，输入以...
《30天自制操作系统》学习笔记——第十四天
文行知的专栏
02-27 1271
来开始第14 天的内容吧。                                                                          今天一上来就要提高分辨率了，真是激动人心呀，提高之前：                                提高之后：                                   是不是一
操作系统实验--30天自制操作系统第综合设计及工程文件
qq_49327751的博客
01-13 2815
一、实验目的 通过对操作系统启动过程的模拟，以及软件功能设计与实现，进一步理解和掌握《操作系统实验》课程中学习到的各个功能模块的原理和用法，提高自己的系统设计能力。 二、实验环境 硬件环境：计算机，无特殊配置要求 软件环境：QEMU虚拟机、批处理文件、相关编译工具等 语言环境：C语言、汇编语言 三、功能介绍及运行效果截图 编程实现一台计算机从启动到输入密码进入桌面，到双击打开一个软件并实现该软件相关功能的整个过程。 开机动画： 首相上下放层层推进出背景颜色，然后五环从5个方向向中心移动，最终到达屏幕中央，随
30天自制操作系统——第二十天保护操作系统
mint1993的专栏
09-18 1779
在实现保护操作系统之前，我们先来实现两个功能。一个是使用API显示字符串，另一个是用C语言编写应用程序。 使用API显示字符串 显示字符串有两种方法，一种是显示一串字符，当遇到字符编码0时结束。另一种是先指定要显示的字符串的长度，然后进行显示。 实现方式如下： console.c节选： void cons_putstr0(struct CONSOLE *cons, char *s) { for (; *s != 0; s++) { cons_putchar(cons, *s, 1); } retu
30天自制操作系统——第一天制作一个Hello word操作系统
mint1993的专栏
08-07 5968
入手一本《30天自制操作系统》，内容诙谐有趣，很适合对操作系统一窍不通的新手。 据作者所言，这本书的最终目标是从零开始编写一个五脏俱全的图形操作系统，不用什么基础，而且只需30天！！ 没有看错，只需30天，看着真的心动了。编写一个操作系统应该是很多程序员的梦想吧，可能很多人想都不敢想，觉得太难了。 但是作者却说这是一件很简单的事，那么挑战一次也未尝不可吧。 那么就正式开始第一天—— 顺便一提，文中用到的软件、文件都在文章最后的网盘连接里，可以直接下载。 一、制作软盘映像文件helloos.img 首先要用到
30天自制操作系统第1天 - Hello World
Ghosind
04-28 589
通过NASM汇编的DB等指令实现制作hello world程序的软盘镜像文件，并通过qemu模拟器运行。
30天自制操作系统第12、13天
xiaoana_139的博客
01-05 1067
操作系统实验日志12 13 第12、13天：定时器 30天自制操作系统第12、13天操作系统实验日志12 13一、实验主要内容1、 内容1：使用定时器2、 内容2：计量时间3、 内容3：超时功能4、 内容4：使用多个定时器5、 内容5：加快中断处理16、 内容6：加快中断处理27、 内容7：加快中断处理38、内容8：简化字符串显示9、内容9：重新调整fifo缓冲区110、内容10：测...
《30day自制操作系统》学习笔记06
最新发布
m0_47577813的博客
03-03 88
引入头文件声明函数和宏定义，“”表示文件在同一个文件夹里，表示头文件位于i按一起所提供的文件夹里。makefile中引入一般规则，类似有.*导入python包。
《30天自制操作系统》从入门到放弃
wxkhturfun的博客
09-12 1万+
30天自制操作系统 01day 1.0写在前面的话 关于01day~03day，可以完全参考下述链接（下述内容部分也是来源此链接）： https://www.cnblogs.com/yucloud/category/1472969.html 1.1手打img 在下面这条链接中下载填制编辑软件 https://www.jb51.net/softs/601421.html#downintro2 （其实我不并推荐这种编辑器，使用vscode即可：https://www.cnblogs.com/baby123/p/
自制操作系统——第一周
大数据精读周刊
01-29 1263
文章目录第一周第一天-从计算机结构到汇编程序入门HelloWorld引入汇编添加注释第二天-汇编语言学习与Makefile入门文本编辑器初识汇编寄存器数据大小指令制作启动区第三天-进入32位模式并导入C语言制作IPL磁盘显示导入c语言实现HLT第四天-C语言与画面显示白屏线条屏RGB屏幕桌面雏形第5天：结构体、文字显示与GDT/IDT初始化接受启动信息试用结构体显示字符显示字符串显示变量显示指针第六天-分割编译和中断处理分割源文件第七天-FIFO鼠标控制鼠标解读加快中断制作FIFO缓冲区 第一周 我感觉肯定
《30天自制操作系统》学习笔记（七）
qq_35041101的博客
07-09 1555
一、代码执行顺序（前内容六天的内容） ipl10.nas-->asmhead.nas-->boopack.c 二、代码阅读 1.ipl10.nas（将软盘内容拷贝到内存中） ; haribote-ipl ; TAB=4 ; 读取软盘内容到内存中，然后跳转到0xc200开始执行，就是asmhead.nas文件 CYLS EQU 10 ; CYLS=10 读取是10个柱面
30天自制操作系统学习-第1天
热门推荐
qq511714326的博客
09-18 1万+
                                                                  第一天  1 批处理文件:直接由DOS命令行解释执行的文件,通常后缀名为.bat或.cmd。  2 镜像文件:.img后缀的文件,可用于制作操作系统文件,一个3.5英寸的软盘容量为1440k。  3 nask:作者自己制作的汇编代码编译器,代码与nasm代码相差...
30天自制操作系统学习-第2天
qq511714326的博客
10-01 3432
第二天主要学习汇编语言与Makefile入门 1：继续开发 在这里先给出作者在第二天使用nask编写代码中涉及到的寄存器概念:  AX--accumulator,累加寄存器  CX--counter,计数寄存器  DX--data,数据寄存器  BX--base,基址寄存器  这四个为通用寄存器,其中AX16位寄存器可以拆分为AH8位寄存器和AL8位寄存器使用,CX,DX,BX同理 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值