《30天自制操作系统》17_day_学习笔记

最新推荐文章于 2024-07-12 16:56:54 发布
最新推荐文章于 2024-07-12 16:56:54 发布
阅读量101 收藏
点赞数
文章标签： 操作系统 数据结构与算法
原文链接：http://www.cnblogs.com/pengfeiz/p/5848586.html
版权

harib14a：

　　接着上一天的内容，我们来思考一个问题：当所有的LEVEL中都没有任务的时候怎么办？采用前面定时器链表中加入“哨兵”的思路，我们加入一个idle任务，去执行HLT。接下来我们只需要将这个闲置任务idle放在最下层的LEVEL就行了。之后修改一下HariMain测试一下结果。

void task_idle(void)//限制任务idle
{
    for (;;) {
        io_hlt();//让CPU不断的HLT等待中断的到来
    }
}
struct TASK *task_init(struct MEMMAN *memman)
{
    struct TASK *task, *idle;
    //.....
    idle = task_alloc();//为dile分配空间
    idle->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024;
    idle->tss.eip = (int) &task_idle;//dile任务做的事，执行这个函数
    idle->tss.es = 1 * 8;
    idle->tss.cs = 2 * 8;
    idle->tss.ss = 1 * 8;
    idle->tss.ds = 1 * 8;
    idle->tss.fs = 1 * 8;
    idle->tss.gs = 1 * 8;
    //idle放在最后一层，FLAG置1
    task_run(idle, MAX_TASKLEVELS - 1, 1);
    return task;
}

harib14b：
　　这里我们尝试创建一个命令行窗口。首先对任务B的程序进行一些修改，并将任务A的一部分融合进去，把计数代码从任务B中删除；然后单独创建一个新的任务

void HariMain(void)
{    //.....
    /* sht_cons */
    sht_cons = sheet_alloc(shtctl);//命令行窗口图层、缓冲区
    buf_cons = (unsigned char *) memman_alloc_4k(memman, 256 * 165);
    sheet_setbuf(sht_cons, buf_cons, 256, 165, -1);/* 设置缓冲区，将CMD窗口图层写到缓冲区中 */
    make_window8(buf_cons, 256, 165, "console", 0);//用CMD缓冲区的内容画窗口
    make_textbox8(sht_cons, 8, 28, 240, 128, COL8_000000);//CMD图层下的文本框
    task_cons = task_alloc();　　　　　　　　　　　　 //CMD窗口的任务、分配空间
    task_cons->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 8;
    task_cons->tss.eip = (int) &console_task;　　  //任务执行的函数（内容）
    task_cons->tss.es = 1 * 8;
    task_cons->tss.cs = 2 * 8;
    task_cons->tss.ss = 1 * 8;
    task_cons->tss.ds = 1 * 8;
    task_cons->tss.fs = 1 * 8;
    task_cons->tss.gs = 1 * 8;
    *((int *) (task_cons->tss.esp + 4)) = (int) sht_cons;//将CMD图层地址放到CMD任务块首部
    task_run(task_cons, 2, 2); 　　/* 设置LEVEL和优先级level=2, priority=2 */
    //.....
    sheet_slide(sht_back,  0,  0);//图层开始显示的位置
    sheet_slide(sht_cons, 32,  4);
    sheet_slide(sht_win,  64, 56);
    sheet_slide(sht_mouse, mx, my);
    sheet_updown(sht_back,  0);　　//设置图层的高度
    sheet_updown(sht_cons,  1);
    sheet_updown(sht_win,   2);
    sheet_updown(sht_mouse, 3);
    //.....
}
void console_task(struct SHEET *sheet)
{
    struct FIFO32 fifo;　　　　　　　//闪烁定时器缓冲区
    struct TIMER *timer;　　　　　　 //闪烁定时器
    struct TASK *task = task_now();//当前运行中任务地址

    int i, fifobuf[128], cursor_x = 8, cursor_c = COL8_000000;
    fifo32_init(&fifo, 128, fifobuf, task);//当前任务写到缓冲区

    timer = timer_alloc();　　　　　　　　　　//闪烁定时器设置
    timer_init(timer, &fifo, 1);
    timer_settime(timer, 50);

    for (;;) {
        io_cli();　　　　　　　//禁止中断
        if (fifo32_status(&fifo) == 0) {
            task_sleep(task);//缓冲区没有内容，让当前运行中的任务睡眠
            io_sti();允许中断
        } else {
            i = fifo32_get(&fifo);
            io_sti();
            if (i <= 1) { /* 光标闪烁定时器超时 */
                if (i != 0) {
                    timer_init(timer, &fifo, 0);  /* i=1;此时重新设置光标定时器，写入FIFO中改为0 */
                    cursor_c = COL8_FFFFFF;　　　　//黑色背景
                } else {
                    timer_init(timer, &fifo, 1);  /* i=1;此时重新设置光标定时器，写入FIFO中改为0 */
                    cursor_c = COL8_000000;　　　　//白色背景
                }
                timer_settime(timer, 50);　　　　　//50个count计数的时间、文本显示框
                boxfill8(sheet->buf, sheet->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
                sheet_refresh(sheet, cursor_x, 28, cursor_x + 8, 44);//刷新显示
            }
        }
    }
}

harib14c：
　　到这里我们已经有两个窗口了，下面我们一步一步实现按下TAB的时候切换输入的窗口的功能，这里我们先修改窗口标题栏的颜色
　　1、改写make_windows8（）

//我们将描绘窗口标题栏的代码和描绘窗口文本框的代码区分开来
void make_window8(unsigned char *buf, int xsize, int ysize, char *title, char act)
{   //这一部分是描绘窗口输入文本框的代码
    //第一步：将设置的文本框的信息写到缓存中
    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_848484, 1,         ysize - 2, xsize - 2, ysize - 2);
    boxfill8(buf, xsize, COL8_000000, 0,         ysize - 1, xsize - 1, ysize - 1);
    //第二步：调用这个函数，将缓存中的内容写到VRAM中
    make_wtitle8(buf, xsize, title, act);
    return;
}
void make_wtitle8(unsigned char *buf, int xsize, char *title, char act)
{   //这里是描绘窗口标题栏的代码，这里没有什么可讲的。
    //就是把两部分代码区分开，便于设置标题的颜色（用ACT参数）
    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, tc, tbc;
    if (act != 0) {
        tc = COL8_FFFFFF;
        tbc = COL8_000084;
    } else {
        tc = COL8_C6C6C6;
        tbc = COL8_848484;
    }
    boxfill8(buf, xsize, tbc, 3, 3, xsize - 4, 20);
    putfonts8_asc(buf, xsize, 24, 4, tc, 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;
}

　　2、修改HariMain

//加入TAB键的判断，调用make_wtitle8并修改两个窗口标题的颜色
void HariMain(void)
{    　　　　　　　　　　　　　　　 //.....i为从FIFO中获得中断的数据
    if (256 <= i && i <= 511) { /* 如果获得的是键盘中断的数据 */
        //......
        if (i == 256 + 0x0f) {  /* 键盘中断的键值是TAB键 */
            if (key_to == 0) {  //这里的原理和光标闪烁是一样的
                key_to = 1;　　 //发送到CMD窗口
                make_wtitle8(buf_win,  sht_win->bxsize,  "task_a",  0);
                make_wtitle8(buf_cons, sht_cons->bxsize, "console", 1);
            } else {
                key_to = 0;　　 //发送到任务A
                make_wtitle8(buf_win,  sht_win->bxsize,  "task_a",  1);
                make_wtitle8(buf_cons, sht_cons->bxsize, "console", 0);
            }　　　　　　　　　　 //接着刷新CMD和窗口图层
            sheet_refresh(sht_win,  0, 0, sht_win->bxsize,  21);
            sheet_refresh(sht_cons, 0, 0, sht_cons->bxsize, 21);
        }
    }
    //.....
}

harib14d：
　　我们虽然让窗口的颜色从灰色变成了蓝色，下面我们实现向CMD窗口中输入字符串。只要在键盘被按下的时候，往CMD任务的FIFO中发送数据即可。考虑到很多任务都需要用到缓冲区，我们将FIFO加到任务结构体TASK中。
　　1、将FIFO加到任务结构体TASK中。

struct TASK {
    int sel, flags; /* sel表示GDT的编号 */
    int level, priority;
    struct FIFO32 fifo;//任务的缓冲区
    struct TSS32 tss;//任务段的内容
};

　　2、修改HariMain

//判断key_to的值，并向FIFO发送数据。
void HariMain(void)
{    //....
    for (;;) {
        //...
            if (256 <= i && i <= 511) { 　　  /* 键盘数据 */
                sprintf(s, "%02X", i - 256); //在背景图层显示按下的 键值
                putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
                if (i < 0x54 + 256 && keytable[i - 256] != 0) { /* 在keytable表中找到一般字符 */
                    if (key_to == 0) {    　　/* 把获得的字符发送给任务A的缓冲区 */
                        if (cursor_x < 128) {//窗口的最大长度128像素
                            /* 每输入一个字符，光标向后移动8个像素 */
                            s[0] = keytable[i - 256];
                            s[1] = 0;
                            //在窗口（任务A）图层显示字符
                            putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
                            cursor_x += 8;
                        }
                    } else {/* 发送到CMD窗口（任务）的缓冲区 */
                        fifo32_put(&task_cons->fifo, keytable[i - 256] + 256);
                    }
                }
                if (i == 256 + 0x0e) {    /* Backspace键 */
                    if (key_to == 0) {    /* 发送信息到A任务 */
                        if (cursor_x > 8) {
                           　　　　　　　　 /* 闪烁光标向左移动8个像素 */
                            putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
                            cursor_x -= 8;
                        }
                    } else {    　　　　　　/* 发送到任务CMD窗口 */
                        fifo32_put(&task_cons->fifo, 8 + 256);
                    }
                }
        //......
        }
    }
    //...
}

harib14e：
　　这里我们来实现“！”和“%”的输入，我们先来看看Shift键的编码:
　　　　　　　　 按下 　　 抬起
　　左Shift 　　0x2a 　　0xaa
　　右Shift 　　0x36 　　0xb6
　　因此我们准备一个key_shift变量，当左Shift按下时置为1，当右Shift按下时置为2，两个都不按时置为0，两个都按下的时候就置为3。当key_shift为0时，我们用keytable0[]进行字符编码转换，当key_shift不为0时，我们使用keytable1[]进行转换。

void HariMain(void)
{
    static char keytable0[0x80] = {
        0,   0,   '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '^', 0,   0,
        'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '@', '[', 0,   0,   'A', 'S',
        'D', 'F', 'G', 'H', 'J', 'K', 'L', ';', ':', 0,   0,   ']', 'Z', 'X', 'C', 'V',
        'B', 'N', 'M', ',', '.', '/', 0,   '*', 0,   ' ', 0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   '7', '8', '9', '-', '4', '5', '6', '+', '1',
        '2', '3', '0', '.', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0x5c, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0x5c, 0,  0
    };
    static char keytable1[0x80] = {
        0,   0,   '!', 0x22, '#', '$', '%', '&', 0x27, '(', ')', '~', '=', '~', 0,   0,
        'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '`', '{', 0,   0,   'A', 'S',
        'D', 'F', 'G', 'H', 'J', 'K', 'L', '+', '*', 0,   0,   '}', 'Z', 'X', 'C', 'V',
        'B', 'N', 'M', '<', '>', '?', 0,   '*', 0,   ' ', 0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   '7', '8', '9', '-', '4', '5', '6', '+', '1',
        '2', '3', '0', '.', 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        0,   0,   0,   '_', 0,   0,   0,   0,   0,   0,   0,   0,   0,   '|', 0,   0
    };
    //.....
    for (;;) {
            //......
            if (256 <= i && i <= 511) { /* 获得的是键盘的数据 */
                sprintf(s, "%02X", i - 256);
                putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
                if (i < 0x80 + 256) { /* 按照键盘的编码进行转换 */
                    if (key_shift == 0) {
                        s[0] = keytable0[i - 256];
                    } else {
                        s[0] = keytable1[i - 256];
                    }
                } else {
                    s[0] = 0;
                }
                if (s[0] != 0) { /* 一般字符 */
                    if (key_to == 0) {    /* 想任务A中写 */
                        if (cursor_x < 128) {
                            /* 光标后移 */
                            s[1] = 0;
                            putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
                            cursor_x += 8;
                        }
                    } else {    /* 向CMD窗口中写 */
                        fifo32_put(&task_cons->fifo, s[0] + 256);
                    }
                }
                //........
                if (i == 256 + 0x2a) {    /* 左shift ON */
                    key_shift |= 1;
                }
                if (i == 256 + 0x36) {    /* 右shift ON */
                    key_shift |= 2;
                }
                if (i == 256 + 0xaa) {    /* 左shift OFF */
                    key_shift &= ~1;
                }
                if (i == 256 + 0xb6) {    /* 右shift OFF */
                    key_shift &= ~2;
                }
            //./.....
            }
        }
    }//.....
}

harib14f：
　　接下来我们要实现大写、小写字母的输入，要区分字母的大小写，我们必须同时判断Shift键的状态以及CapsLock的状态。这里笔者总结出小写字母的条件：Shift和CapsLock的状态相同（同为ON或者OFF）我们从BIOS中获取CapsLock的状态
　　　　binfo->leds的第四位->ScrollLock的状态
　　　　binfo->leds的第五位->NumLock 的状态
　　　　binfo->leds的第六位->CapsLock 的状态
　　我们使用上述的数据和规则来处理大小写字母的输入问题：

void HariMain(void)
{    //......这里只取binfo->leds4-6位的数据。
    int key_to = 0, key_shift = 0, key_leds = (binfo->leds >> 4) & 7;
    //......
    if ('A' <= s[0] && s[0] <= 'Z') {    /* 大写字母A-Z之间 */
        if (((key_leds & 4) == 0 && key_shift == 0) ||  //自行在草稿纸上推算
                ((key_leds & 4) != 0 && key_shift != 0)) {
            s[0] += 0x20;    /* 字符值0x20变为小写字母的值 */
        }
    }
    //......
}

harib14g：
　　对键盘上锁定键的支持，我们在上面已经实现了锁定键的切换，但是有时候指示灯并不进行相应的切换，下面我们来解决这个问题。先来看看常用三个锁定键的键值：
　　　　　　0x3a : CapsLock
　　　　　　0x45 : NumLock
　　　　　　0x46 : ScrollLock
　　对于键盘上锁定键LED的控制，可采用以下方法想键盘发送指令和数据;

    1. 读取状态寄存器，等待bit1的值变为0
    2. 向数据输出（0060）写入要发送的1个字节的数据
    3. 等待键盘返回1个字节的信息，这和等待键盘输入采用的方法相同(用IRQ等待或者用轮询状态寄存器bit1的值知道变为0都可以）
    4. 返回的信息如果是0xfa，表示1个字节的数据已经成功发送给键盘了。如果为0xfe则表示发送失败，返回 1 步重新发送

　　要控制LED的状态，需要按照上述方法执行两次，向键盘发送EDxx数据，其中，xx的bit0（ScrollLock）bit1(NumLock)bit2(CapsLock),0表示熄灭，1表示点亮。

void HariMain(void)
{

    struct FIFO32 fifo, keycmd;
    int fifobuf[128], keycmd_buf[32];
    //keycmd_wait表示键盘向控制器发送数据的状态。
    // ==-1：通常状态可以发送指令
    //！=-1：键盘控制器正在等待发送的数据（保存在keycmd_wait）
    //key_leds设置指示灯的状态，这个数据是要送到键盘控制器的
    

    int key_to = 0, key_shift = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1;
    //初始化KEYCMD任务A想键盘发送数据的缓冲区
    fifo32_put(&keycmd, KEYCMD_LED);
    fifo32_put(&keycmd, key_leds);
    //.....
    for (;;) {
        if (fifo32_status(&keycmd) > 0 && keycmd_wait < 0) {
            /* 如果存在想键盘控制器发送的数据，则发送它 */
            keycmd_wait = fifo32_get(&keycmd);//从KEYCMD缓冲区中获得要向键盘发送的数据
            wait_KBC_sendready();　　　　　　　　//等待ACK；等待键盘准备好
            io_out8(PORT_KEYDAT, keycmd_wait);//将keycmd_wait的值送到键盘控制器
        }
        io_cli();
        if (fifo32_status(&fifo) == 0) {
            task_sleep(task_a);　　//任务A中没有信息，没有从键盘接收的数据，休眠
            io_sti();
        } else {   　　　　　　　　 //任务A有信息
            i = fifo32_get(&fifo);//从任务A的缓冲区得到信息
            io_sti();
            if (256 <= i && i <= 511) {/* 得到键盘数据 */
                //.....
                if (i == 256 + 0x3a) { /* CapsLock */
                    key_leds ^= 4;　　 //设置CapsLock指示灯亮（ley_leds的第2位为1）
                    fifo32_put(&keycmd, KEYCMD_LED);//先送入默认的KEYCMD_LED是为了下一次获得ACK（0xfa)
                    fifo32_put(&keycmd, key_leds);  //接着再送入设置的指示灯状态信息
                }
                if (i == 256 + 0x45) {    　　　　　　/* NumLock */
                    key_leds ^= 2;    　　　　　　　　//设置NumLock 指示灯亮（ley_leds的第1位为1）
                    fifo32_put(&keycmd, KEYCMD_LED);//同上
                    fifo32_put(&keycmd, key_leds);
                }
                if (i == 256 + 0x46) {    　　　　　　/* ScrollLock */
                    key_leds ^= 1;    　　　　　　　　//设置ScrollLock 指示灯亮（ley_leds的第0位为1）
                    fifo32_put(&keycmd, KEYCMD_LED);//同上
                    fifo32_put(&keycmd, key_leds);
                }
                if (i == 256 + 0xfa) {    　　　　　　/* 键盘成功接收数据返回一个ACK（0xfa） */
                    keycmd_wait = -1;　　　　　　　　 //这是又可以继续向键盘控制器发送数据了
                }
                if (i == 256 + 0xfe) {    　　　　　　/* 键盘接收数据失败返回ACK（0xfe) */
                    wait_KBC_sendready();　　　　　　　//等着（0xfa)键盘准备好
                    io_out8(PORT_KEYDAT, keycmd_wait);//重新把keycmd_wait的值发送到键盘控制器
                }
                //.......
            }
        }
    }
}

转载于:https://www.cnblogs.com/pengfeiz/p/5848586.html

weixin_30414155
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
30天自制操作系统
lln_lln的博客
09-27 441
os系统颜色模式及色号 Bit-深度 色彩数 1 2 (monochrome) 2 4 (CGA) 4 16 (EGA) 8 256 (VGA) 16 65,536 (High Color, XGA) 24 16,777,216 (True Color/真彩色, ...
30天自制操作系统day17
吃烧饼的专栏
07-21 473
创建命令行窗口创建一个带窗口的任务，需要在主程序中创建窗口，再通过参数传给这个任务的main函数。因为要处理窗口重叠关系等，需要在统一的地方进行管理。 如果有多个任务能够接受键盘输入，则应该创建一个变量key_to，表示输入到哪个任务中。 为了让每个任务都能够接受键盘输入，可以把FIFO放在TASK结构中。在主程序的for循环中，根据key_to的值将键盘数据传到指定的FIFO中。然后在这个任务
30天自制操作系统之第17天 命令行窗口
10-11 3513
我们把命令行窗口单独做成一个新的任务。 要实现字符输入，只要在键盘被按下的时候向console_task（命令行窗口任务）的FIFO发送数据即可。但要发送数据必须要知道struct FIFO的内存地址才行。 把 struct FIFO 放到 struct TASK里面。基本上没有什么任务是完全用不到FIFO的，因此我们把它们绑定起来。struct TASK { int sel, fl
【操作系统】30天自制操作系统--(17)命令行窗口2
sinat_33408502的博客
05-05 638
本章承接上一章命令行窗口，完善了命令行的一些基本功能，诸如切换窗口光标闪烁、回车换行以及一些简单的命令反馈。 一 光标闪烁 对于主任务，按下TAB之后，需要对光标处理，使其不闪烁。 那么对于命令行任务，该如何通过HariMain来告知console_task需不需要让光标闪烁呢？这边采取的做法就是像按键编码一样，通过FIFO缓冲区来传递参数。 在主函数中，如果需要切换，将光标闪烁的参数（闪烁为2，不闪为3）传递给命令行任务： if (i == ...
30天自制操作系统（第17天）
Amnesiac_seven的博客
02-20 790
将make_window8中描绘窗口标题栏的代码（make_wtitle8），和描绘窗口剩余部分的代码（make_window8）区分开来，以便在按下TAB按键后标题栏的颜色进行变化，达到窗口切换的视觉要求。在for循环的开头，当keycmd中有数据，且keycmd_wait为-1时，向键盘发送1个字节的数据，在开始发送数据的同时，keycmd_wait变为非-1的值。到这里，已经实现了锁定键模式的切换，不过现在还是有一个问题，模式是可以切换了，但是键盘上面的指示灯却不会发生变化。思路就是在按照之前的。
Day_five.rar_day_five_学习计划_日程安排系统_日程管理
09-24
标题中的“Day_five.rar_day_five_学习计划_日程安排系统_日程管理”提示我们这是一个关于日程管理的学习资源，可能是一个项目或教程的第五天内容，涉及到创建或使用日程安排系统的知识。描述进一步确认了这个系统是...
eq_data_30_day_m1.rar
06-21
在实际操作中，你可能首先会解压"eq_data_30_day_m1.rar"，然后使用Python读取并加载"eq_data_30_day_m1.json"文件，接着对数据进行预处理，最后进行分析和可视化。这个过程将涵盖Python编程的多个核心领域，对于...
ajax-day01.rar_达内开发学习笔记
09-20
在“ajax-day01.rar_达内开发学习笔记”这个压缩包中，包含了第一天学习Ajax的基础内容，旨在帮助初学者理解并掌握Ajax的核心概念和使用方法。** **一、Ajax简介** Ajax并不是一种单一的技术，而是一组技术的组合，...
eq_data_30_day_m1.json
03-16
30天全球地震数据集
proj.rar_Day By Day
09-21
Give date of birth and which month You were born.Then by running this project you can get which day U born.
如果需要修改main.c函数的入口为Main(默认是HariMain)只需要修改haribote.rul文件
10-27 1021
30dayMakeOS-master\z_tools\haribote\haribote.rul
30天自制操作系统-30days diy os
方极客
10-10 3067
30days_diy_os 30days_diy_os-head.pdf30days_diy_os-0.pdf30days_diy_os-1.pdf30days_diy_os-2.pdf30days_diy_os-3.pdf30days_diy_os-4.pdf30days_diy_os-5.pdf30days_diy_os-6.pdf30days_diy_os-7.pdf30days_
30天自制操作系统-4
weixin_34234829的博客
06-08 84
首先啊，今天的内容比较多，但大家可以直接看书最后面，一想到做完后就能看到这个界面上有我们画上去的东西就开心纳，朝着这个尽头，开始吧。 首先就是用C语言写内存，如果用汇编写的话，就是用[]这种来进行内存读写，其实我们就是要在汇编里封装一些函数让C去调用。这里突然想起了，做手游，为了热更新，也是这个套路。 _write_mem8: ...
30天自制操作系统 （一个操作系统的实现）
热门推荐
小风筝
06-01 1万+
自制操作系统 （一个操作系统的实现）
《操作系统30天》-合川秀实-学习日志day5
菜????一只
01-16 216
结构体 接收启动区信息：从asmhead.nas中用指针获取VRam的地址（0xa0000），xsize,ysize等值；把前一天的背景显示部分（最后绿色的矩阵图）做成一个函数独立出来（init_screen）。 void init_screen(char *vram, int x, int y) void HariMain(void) { char *vram; int xsize, y...
看ros的某个节点发出的信息的linux指令
嵌入式行业打工人，不定期更新博客。
07-11 313
在ROS (Robot Operating System) 中，如果你想查看某个特定节点发布到某个话题上的消息，你可以使用。命令，但是这将显示关于节点的一般信息，而不是它发布的消息数据。请记住，为了使用这些命令，你需要确保你的ROS环境已经被正确设置，通常是通过运行。这个命令可以让你实时地看到一个话题上发布的消息数据。确保替换上述命令中的路径为你实际的ROS工作空间路径。如果你不确定消息的类型，可以先用。如果你知道消息的类型，也可以加上。此外，如果你想查看节点的日志信息，可以使用。假设你想要查看由节点。
jar服务注册为windows的服务
最新发布
myskybeyond
07-12 227
NSSM是一个免费的开源工具，用于将任何应用程序注册为Windows服务。
【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第一篇 嵌入式Linux入门篇-第二十六章 安装超级终端软件
BeiJingXunWei的博客
07-11 498
USB 转串口，也叫‘U 转串’，可以把没有串口的电脑虚拟一个串口出来，这样就让电脑具备了串口的功能，从而可以使得开发板和 PC 之间通过串口通讯了。（这里需要提醒一下，用户插入的 USB 接口不一样，显示的端口号也会不一样，大家只需要关注‘USB 转串口’插入后，增加的那一个串口号，这个增加的串口号需要大家记住，在超级终端的设置中会用到。首先使用串口线连接到开发板的串口（红色箭头指的地方），串口线的另一端连接U转串口，然后连接到电脑usb口上，连接方式如图所示，图片上连接的串口是调试串口。
透明加密软件核心技术分享|十款好用的透明加密软件分享
2401_83058349的博客
07-09 671
透明加密软件的核心技术在于其能够自动、实时地对文件进行加密和解密，而这个过程对最终用户来说是无感的。4.Vormetric Transparent Encryption：企业级数据加密解决方案，支持文件和数据库加密，提供详细的日志和监控。选择透明加密软件时，应根据自己的具体需求和操作系统环境来决定，同时考虑软件的易用性、成本和供应商的技术支持水平。7.大黄蜂加密软件：专注于视频加密，采用高级别的加密原理，如视频逐帧转码加密。1.安企神软件：专注于图纸和源代码的加密，具有强大的权限管理和审计功能。
使用python标识trade_day的前30天
06-11
trade_day_30_days_ago = calendar.loc[calendar['date'] >= thirty_days_ago, 'date'].tolist() print(trade_day_30_days_ago) ``` 这段代码将打印出最近30个交易日的日期列表。请确保替换`calendar.csv`为你的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值