从0开始的操作系统手搓教程24——完成我们的键盘驱动子系统

所以，我们现来说说转义字符

我们需要如何处理扫描码

当键入的是双字符键时

当键入的是字母键时

我们下面来看看我们的键盘驱动子系统是一个怎么个事情。

驱动程序，你可以认为是对硬件的一层封装。我们按照手册规格的规定姿势，封装好一套一套的流程，我们上层的软件想要使用这个硬件，就直接找这个驱动接口，一个调用完事。这就是一个驱动。

所以，我们现来说说转义字符

我们下面呢，就是要准备讨论一个重要的东西：叫转义字符。因为我们编写键盘驱动程序，就必须要理解键盘如何处理一部分不可见字符的。

我的意思是——我们的字符集中的字符，分为两个大类：可见的字符和不可见的字符。可见的字符太好说了，abcdefg....，不可见的字符，则是一些输入控制字符。我们如何输入控制字符呢？啊哈，转义字符嘛！

在 C 语言中有三种转义字符。

一般转义字符，'+单个字母'的形式。
八进制转义字符，'\0+三位八进制数字表示的 ASCII 码'的形式。
十六进制转义字符，'\x+两位十六进制数字表示的 ASCII 码'的形式。

我们实际上，就是将我们的字符的通码，转换成可见的ASCII字符，发送到上面需要的子程序。这样就完事了。

我们需要如何处理扫描码

当按下的键是可见字符时，屏幕上都会将其显示出来，比如按下了 a 键，屏幕上应该输出字符'a'，给用户一个反馈，这样用户才觉得自己没按错，这是为打造好的用户体验最起码的素质。当按下的键是控制字符时，我们应该做出相应的控制行为，并在屏幕上展现出这种行为，比如按下了backspace 键，咱们也应该在屏幕上让用户觉得光标所在处前面的字符被删掉了。

如果是一些用于操作方面的控制键，简称操作控制键，如<shift>、<ctrl>、<caps lock>，它通常是组合键，需要与其他键一起考虑，然后做出具体的行为展现，在键盘驱动中完成处理。如果是一些用于字符方面的键，无论是可见字符，或是字符方面的控制键（简称字符控制键），如<backspace>，统统交给字符处理程序完成，比如咱们的 __ccos_putchar。还记得吗？__ccos_putchar能够处理 <backspace>，也就是'\b'。

所以，我们需要做的就是将操作控制键，转化成正确的含义传递给字符处理程序。也就是正确的ASCII码给我们的 __ccos_putchar。

我们首先定义一下keymap，不然的话

#ifndef KEYBOARD_MAPPINGS_H
#define KEYBOARD_MAPPINGS_H
#include "include/device/configs/keyboard_ascii.h"

// Key mappings table
static char keymap[[maybe_unused]][][2]  = {
    /* ---------------------------------- */
    /* 0x00 */  {0, 0},     
    /* 0x01 */  {ESC,   ESC},       
    /* 0x02 */  {'1',   '!'},       
    /* 0x03 */  {'2',   '@'},       
    /* 0x04 */  {'3',   '#'},       
    /* 0x05 */  {'4',   '$'},       
    /* 0x06 */  {'5',   '%'},       
    /* 0x07 */  {'6',   '^'},       
    /* 0x08 */  {'7',   '&'},       
    /* 0x09 */  {'8',   '*'},       
    /* 0x0A */  {'9',   '('},       
    /* 0x0B */  {'0',   ')'},       
    /* 0x0C */  {'-',   '_'},       
    /* 0x0D */  {'=',   '+'},       
    /* 0x0E */  {BACKSPACE, BACKSPACE}, 
    /* 0x0F */  {TAB,   TAB},       
    /* 0x10 */  {'q',   'Q'},       
    /* 0x11 */  {'w',   'W'},       
    /* 0x12 */  {'e',   'E'},       
    /* 0x13 */  {'r',   'R'},       
    /* 0x14 */  {'t',   'T'},       
    /* 0x15 */  {'y',   'Y'},       
    /* 0x16 */  {'u',   'U'},       
    /* 0x17 */  {'i',   'I'},       
    /* 0x18 */  {'o',   'O'},       
    /* 0x19 */  {'p',   'P'},       
    /* 0x1A */  {'[',   '{'},       
    /* 0x1B */  {']',   '}'},       
    /* 0x1C */  {ENTER,  ENTER},
    /* 0x1D */  {CTRL_L_CHAR, CTRL_L_CHAR},
    /* 0x1E */  {'a',   'A'},       
    /* 0x1F */  {'s',   'S'},       
    /* 0x20 */  {'d',   'D'},       
    /* 0x21 */  {'f',   'F'},       
    /* 0x22 */  {'g',   'G'},       
    /* 0x23 */  {'h',   'H'},       
    /* 0x24 */  {'j',   'J'},       
    /* 0x25 */  {'k',   'K'},       
    /* 0x26 */  {'l',   'L'},       
    /* 0x27 */  {';',   ':'},       
    /* 0x28 */  {'\'',  '"'},       
    /* 0x29 */  {'`',   '~'},       
    /* 0x2A */  {SHIFT_L_CHAR, SHIFT_L_CHAR},   
    /* 0x2B */  {'\\',  '|'},       
    /* 0x2C */  {'z',   'Z'},       
    /* 0x2D */  {'x',   'X'},       
    /* 0x2E */  {'c',   'C'},       
    /* 0x2F */  {'v',   'V'},       
    /* 0x30 */  {'b',   'B'},       
    /* 0x31 */  {'n',   'N'},       
    /* 0x32 */  {'m',   'M'},       
    /* 0x33 */  {',',   '<'},       
    /* 0x34 */  {'.',   '>'},       
    /* 0x35 */  {'/',   '?'},
    /* 0x36 */  {SHIFT_R_CHAR, SHIFT_R_CHAR},   
    /* 0x37 */  {'*',   '*'},       
    /* 0x38 */  {ALT_L_CHAR, ALT_L_CHAR},
    /* 0x39 */  {' ',   ' '},       
    /* 0x3A */  {CAPS_LOCK_CHAR, CAPS_LOCK_CHAR}
};
#endif

这个keymap，更多定义的是是否又跟shift进行组合的Keymap表，我的意思是——当我们只是嗯下A这个键的时候，正常出来的就是keymap[0x1e][0]，然后，就是嗯下Shift的时候，我们正确的索引就是keymap[0x1e][1]，这个没啥毛病，出来的是A。

在keyboard_ascii.h的中（当时名字取得不太好），存放的是我们的键盘控制相关的定义，请看下文

#ifndef KEYBOARD_ASCII_H
#define KEYBOARD_ASCII_H

/* Port and interrupt number for keyboard input */
#define KEYBOARD_BUF_PORT       (0x60)  // I/O port for keyboard buffer
#define KEYBOARD_INTERRUPT_N    (0x21)  // Keyboard interrupt number

/* ASCII control characters */
#define ESC         ('\x1b')  // Escape key
#define BACKSPACE   ('\b')    // Backspace key
#define TAB         ('\t')    // Tab key
#define ENTER       ('\r')    // Enter (carriage return)
#define DELETE      ('\x7f')  // Delete key

/* Invisible control characters (do not produce a visible output) */
#define INVISIBLE          (0)   // Represents an invisible keypress
#define CTRL_L_CHAR        INVISIBLE  // Left Control key
#define CTRL_R_CHAR        INVISIBLE  // Right Control key
#define SHIFT_L_CHAR       INVISIBLE  // Left Shift key
#define SHIFT_R_CHAR       INVISIBLE  // Right Shift key
#define ALT_L_CHAR         INVISIBLE  // Left Alt key
#define ALT_R_CHAR         INVISIBLE  // Right Alt key
#define CAPS_LOCK_CHAR     INVISIBLE  // Caps Lock key

/* Make codes for modifier keys (sent when key is pressed) */
#define SHIFT_L_MAKE       (0x2A)   // Left Shift key make code
#define SHIFT_R_MAKE       (0x36)   // Right Shift key make code
#define ALT_L_MAKE         (0x38)   // Left Alt key make code
#define ALT_R_MAKE         (0xE038) // Right Alt key make code (extended)
#define CTRL_L_MAKE        (0x1D)   // Left Control key make code
#define CTRL_R_MAKE        (0xE01D) // Right Control key make code (extended)
#define CAPS_LOCK_MAKE     (0x3A)   // Caps Lock key make code

/* Break codes for modifier keys (sent when key is released) */
#define ALT_R_BREAK        (0xE0B8) // Right Alt key break code (extended)
#define CTRL_R_BREAK       (0xE09D) // Right Control key break code (extended)

#endif

为了薄记我们的控制摁键的状态，笔者抽象了一个这样的结构体：

/* Defines a structure to record the status of special keys */
static struct {
    bool ctrl_status;      // Indicates whether the Ctrl key is pressed
    bool shift_status;     // Indicates whether the Shift key is pressed
    bool alt_status;       // Indicates whether the Alt key is pressed
    bool caps_lock_status; // Indicates whether Caps Lock is active
    bool ext_scancode;     // Indicates if the scancode starts with 0xe0
} key_state;

上面的结构体就是用来处理我们的键盘的状态用的。上面的注释上我说的很清楚了。

下面，让我们仔细瞧瞧看！我们改造后的键盘中断处理程序是如何的。

static void keyboard_intr_handler(void)
{
    // fetch the recordings
    bool prev_shift_down = key_state.shift_status;
    bool prev_caps_lock = key_state.caps_lock_status;

    bool break_code;
    uint16_t scancode = inb(KEYBOARD_BUF_PORT);

    if (scancode == SCANCODE_EXT) {
        key_state.ext_scancode = true;
        return;
    }

我们首先读取8042上的缓存的键盘扫描码，我们第一件事，就是看看我们的这一次是不是e0，是e0说明我们的键盘产生了多个扫描码，马上结束中断，准备好薄记。退出中断处理子程序

    if(key_state.ext_scancode){
        scancode = ((0xe000) | scancode);
        key_state.ext_scancode = false;
    }

我们判断是不是发生过0xe0的收到，收到的话，我们就要合并上一次的0xe0：scancode = ((0xe000) | scancode);，然后关闭标记，方便我们接受下一次的0xe0.

我们下一步就是判断，这一次是断码还是通码。我们检查一下字节的最高位：

// get break code
break_code = ((scancode & 0x0080) != 0);

如果，我们收到的是一个断码，就要准备处理这个字符了（用户结束了输入，我们准备好清理一部分状态）

    if (break_code) {
        // Extract the make code by masking the break code bit
        uint16_t make_code = (scancode &= 0xff7f);

        // Update the status of control keys if they are released
        if (make_code == CTRL_L_MAKE || make_code == CTRL_R_MAKE) {
            key_state.ctrl_status = false;
        } else if (make_code == SHIFT_L_MAKE || make_code == SHIFT_R_MAKE) {
            key_state.shift_status = false;
        } else if (make_code == ALT_L_MAKE || make_code == ALT_R_MAKE) {
            key_state.alt_status = false;
        }

        // Caps Lock does not toggle on release, so no update is needed here
        return;
    }

我们把最高位的1一清走，就得到了通码，为什么看通码呢？上一节想一想你松开Ctrl + A的Ctrl的，显然你就要结束全选全文了。那么，我们自然需要薄记——用户松开了Ctrl，不需要全选了。我们就要清理我们用来薄记的key_state的结构体的状态

我们的键盘上支支持到0x3a上，为了防止越界（其实更好的办法是取出来这个结构体的数组的大小做限制，但是笔者这里偷懒了，你可以自行尝试封装一个更好的判断）

走到下面，我们先要判断这个字符是不是非法的——我们看看，首先，我们要求这个扫描码必须在外面的处理范围内（还可以包含右ALT和右Ctrl键）

    // Handle make codes for defined keys
    if (
        (scancode > 0x00 && scancode < 0x3b) || (scancode == ALT_R_MAKE) || (scancode == CTRL_R_MAKE) ){
        // handling inside
    }else{
        ccos_puts("unknown key\n"); // Handle undefined keys
    }

那些不是的，我们直接给一个提示就好了，你可以啥也不做，这取决于你。

下面准备处理了：主键盘区主要就是数字键和字母键，因此现在要考虑的是之前是否按下了<shift>键和<capslock>键，大伙儿知道，主键盘区中部分键有两个意义，当与 shift 配合使用时，表示键中上面的字符，为方便讨论，暂称它们为双字符键。（因为不是shift的时候，表达的是其他的含义——举个例子，可能是1，2，3等等，这个你仔细看看你的键盘，凡是一个键盘上面挤着两个字符的都是双字字符）<shift>键和<capslock>键对双字符键和字母键的影响是不一样的.

当键入的是双字符键时

如果同时按下了<shift>键，则应该转换为数字键上面的那个符号，比如当前按下的是数字2，之前若按下 shift 未松手的话，现在应该将其转换为字符'@'。 <capslock>键是否开启，对双字符键无影响。

当键入的是字母键时

如果之前开启了<caps lock>键，则应该转换为大写字母。如果之前同时按下了<shift>键不松手，但没有按下<capslock>键，则也应该转换为大写字母。若之前同时按下了<capslock>键和<shift>键，<shift>键将<capslock>键的功能抵消，因此键入的是字母键应该转换为小写字母。

嗯，那这样说来，我们最终可以统一到shift键的处理上（别太麻烦，将大写锁定的作用也归结到shift变量上，这样事情简单一些）。所以请出一个变量叫shift。

若 shift 为 false，则表示 shift 为 0，这表示一维数组中第 0 个元素，即 keymap[通码][0]。
若 shift 为 true，则表示 shift 为 1，这表示一维数组中第 1 个元素，即 keymap[通码][1]。

        bool shift =
            false; // Used to index characters from keymap based on Shift status

之后，我们处理这些双字字符：

数字 0～9、字符'-'、字符'='的通码是< 0x0e。
字符'`'的通码是 0x29。
字符'['的通码是 0x1a。
字符']'的通码是 0x1b。
字符'\'的通码是 0x2b。
字符';'的通码是 0x27。
字符'''的通码是 0x28。
字符','的通码是 0x33。
字符'.'的通码是 0x34。
字符'/'的通码是 0x35

        // Special key ranges that require Shift to access additional characters
        if ((scancode < 0x0e) || (scancode == 0x29) || (scancode == 0x1a) ||
            (scancode == 0x1b) || (scancode == 0x2b) || (scancode == 0x27) ||
            (scancode == 0x28) || (scancode == 0x33) || (scancode == 0x34) ||
            (scancode == 0x35))
        {
            if (prev_shift_down) {
                shift = true;
            }	
        }
		else{
            // handling special keys
        }

如果是这些双字符键，并且按下了<shift>，那说明就是准备触发了第二列的索引，我们后面直接keymap[index][shift]的时候shift就是1嘛！

让我们看看else下的handling special keys的部分，实际上就是这个代码

           // For alphabetic keys, Shift and Caps Lock together cancel each
            // other
            if (prev_shift_down && prev_caps_lock) {
                shift = false;
            } else if (prev_shift_down || prev_caps_lock) {
                shift = true;
            } else {
                shift = false;
            }

我们如果if (shift_down_last && caps_lock_last)，说明我们同时嗯下了shift和caps lock，那就抵消了。

如果其中任何一个被嗯下，那事情就很简单了: shift = true;，余下的情况就是啥也没嗯下，

准备爬表！我们获取表的offset，办法就是直接提取低8位。剩下的位都已经在上面的判断处理干净了

scancode &= 0x00ff;
char cur_char = keymap[scancode][shift]; // Retrieve the character from the keymap

如果我们是可见的字符（参考keyboard.ascii.h，笔者对一切不可见字符直接塞上了0，这个时候，如果我们键入了一个不可见的字符，cur_char索引的结果就是0）

        // Add the character to the buffer if it is not null
        if (cur_char) {
            __ccos_putchar(cur_char);
            return;
        }

直接输出这个字符！

当然，如果是控制不可见字符，我们就是准备薄记状态了，请看：

        // Update the status of control keys for the next input
        if (scancode == CTRL_L_MAKE || scancode == CTRL_R_MAKE) {
            key_state.ctrl_status = true;
        } else if (scancode == SHIFT_L_MAKE || scancode == SHIFT_R_MAKE) {
            key_state.shift_status = true;
        } else if (scancode == ALT_L_MAKE || scancode == ALT_R_MAKE) {
            key_state.alt_status = true;
        } else if (scancode == CAPS_LOCK_MAKE) {
            // Toggle Caps Lock status on each press
            key_state.caps_lock_status = !key_state.caps_lock_status;
        }

完事！直接上电看看情况。

非常好！

代码

CCOperateSystem/Documentations/9_Boost_BasicInputSubsystem/9.2_finish_input_subsystem_1_code at main · Charliechen114514/CCOperateSystemhttps://github.com/Charliechen114514/CCOperateSystem/tree/main/Documentations/9_Boost_BasicInputSubsystem/9.2_finish_input_subsystem_1_code

从0开始的操作系统手搓教程25：使用环状缓冲区来让我们的键盘驱动真正的有作用起来-CSDN博客然而，上面的驱动程序，我相信不少朋友发现毛病了——那就是他是处理完一个字符之后，就迅速的扔掉，没法找到了。换而言之，我们需要一个缓冲区，让我们可以记住用户之前输入了什么。这不，环状缓冲区就来了。缓冲区就是为了解决生产者和消费者问题而存在的，想象一下。https://blog.csdn.net/charlie114514191/article/details/146105601