检查MS-DOS(C/C ）中的键是否关闭

#ifndef KEYBOARD_H_INCLUDED
#define KEYBOARD_H_INCLUDED
#include "keyboard_scan_codes.h"
unsigned char   KeyboardGetKey(unsigned int scanCode);
void            KeyboardClearKeys();
void            KeyboardInstallDriver();
void            KeyboardUninstallDriver();
void            KeyboardDumpScancodeLog();
#endif // KEYBOARD_H_INCLUDED

键盘

#define MAX_SCAN_CODES 256
#define KEYBOARD_CONTROLLER_OUTPUT_BUFFER 0x60
#define KEYBOARD_CONTROLLER_STATUS_REGISTER 0x64
#define KEY_PRESSED 1
#define KEY_RELEASED 0
#define PIC_OPERATION_COMMAND_PORT 0x20
#define KEYBOARD_INTERRUPT_VECTOR 0x09
// PPI stands for Programmable Peripheral Interface (which is the Intel 8255A chip)
// The PPI ports are only for IBM PC and XT, however port A is mapped to the same
// I/O address as the Keyboard Controller's (Intel 8042 chip) output buffer for compatibility.
#define PPI_PORT_A 0x60
#define PPI_PORT_B 0x61
#define PPI_PORT_C 0x62
#define PPI_COMMAND_REGISTER 0x63
#include <dos.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include "keyboard.h"
void interrupt (*oldKeyboardIsr)() = (void *)0;
unsigned char keyStates[MAX_SCAN_CODES];
unsigned char keyCodeLog[256] = {0};
unsigned char keyCodeLogPosition = 0;
static unsigned char isPreviousCodeExtended = 0;
unsigned char KeyboardGetKey(unsigned int scanCode)
{
    // Check for the extended code
    if(scanCode >> 8 == 0xE0)
    {
        // Get rid of the extended code
        scanCode &= 0xFF;
        return keyStates[scanCode + 0x7F];
    }
    else
    {
        return keyStates[scanCode];
    }
}
void KeyboardClearKeys()
{
    memset(&keyStates[0], 0, MAX_SCAN_CODES);
}
void interrupt far KeyboardIsr()
{
    static unsigned char scanCode;
    unsigned char ppiPortB;
    _asm {
        cli // disable interrupts
    };
    /* The keyboard controller, by default, will send scan codes
    // in Scan Code Set 1 (reference the IBM Technical References
    // for a complete list of scan codes).
    //
    // Scan codes in this set come as make/break codes. The make
    // code is the normal scan code of the key, and the break code
    // is the make code bitwise "OR"ed with 0x80 (the high bit is set).
    //
    // On keyboards after the original IBM Model F 83-key, an 0xE0
    // is prepended to some keys that didn't exist on the original keyboard.
    //
    // Some keys have their scan codes affected by the state of
    // the shift, and num-lock keys. These certain
    // keys have, potentially, quite long scan codes with multiple
    // possible 0xE0 bytes along with other codes to indicate the
    // state of the shift, and num-lock keys.
    //
    // There are two other Scan Code Sets, Set 2 and Set 3. Set 2
    // was introduced with the IBM PC AT, and Set 3 with the IBM
    // PS/2. Set 3 is by far the easiest and most simple set to work
    // with, but not all keyboards support it.
    //
    // Note:
    // The "keyboard controller" chip is different depending on
    // which machine is being used. The original IBM PC uses the
    // Intel 8255A-5, while the IBM PC AT uses the Intel 8042 (UPI-42AH).
    // On the 8255A-5, port 0x61 can be read and written to for various
    // things, one of which will clear the keyboard and disable it or
    // re enable it. There is no such function on the AT and newer, but
    // it is not needed anyways. The 8042 uses ports 0x60 and 0x64. Both
    // the 8255A-5 and the 8042 give the scan codes from the keyboard
    // through port 0x60.
    // On the IBM PC and XT and compatibles, you MUST clear the keyboard
    // after reading the scancode by reading the value at port 0x61,
    // flipping the 7th bit to a 1, and writing that value back to port 0x61.
    // After that is done, flip the 7th bit back to 0 to re-enable the keyboard.
    //
    // On IBM PC ATs and newer, writing and reading port 0x61 does nothing (as far
    // as I know), and using it to clear the keyboard isn't necessary.*/
    scanCode = 0;
    ppiPortB = 0;
    ppiPortB = inp(PPI_PORT_B); // get the current settings in PPI port B
    scanCode = inp(KEYBOARD_CONTROLLER_OUTPUT_BUFFER); // get the scancode waiting in the output buffer
    outp(PPI_PORT_B, ppiPortB | 0x80); // set the 7th bit of PPI port B (clear keyboard)
    outp(PPI_PORT_B, ppiPortB); // clear the 7th bit of the PPI (enable keyboard)
    // Log scancode
    keyCodeLog[keyCodeLogPosition] = scanCode;
    if(keyCodeLogPosition < 255)
    {
        ++keyCodeLogPosition;
    }

    // Check to see what the code was.
    // Note that we have to process the scan code one byte at a time.
    // This is because we can't get another scan code until the current
    // interrupt is finished.
    switch(scanCode)
    {
    case 0xE0:
        // Extended scancode
        isPreviousCodeExtended = 1;
        break;
    default:
        // Regular scancode
        // Check the high bit, if set, then it's a break code.
        if(isPreviousCodeExtended)
        {
            isPreviousCodeExtended = 0;
            if(scanCode & 0x80)
            {
                scanCode &= 0x7F;
                keyStates[scanCode + 0x7F] = KEY_RELEASED;
            }
            else
            {
                keyStates[scanCode + 0x7F] = KEY_PRESSED;
            }
        }
        else if(scanCode & 0x80)
        {
            scanCode &= 0x7F;
            keyStates[scanCode] = KEY_RELEASED;
        }
        else
        {
            keyStates[scanCode] = KEY_PRESSED;
        }
        break;
    }
    // Send a "Non Specific End of Interrupt" command to the PIC.
    // See Intel 8259A datasheet for details.
    outp(PIC_OPERATION_COMMAND_PORT, 0x20);
    _asm
    {
        sti // enable interrupts
    };
}
void KeyboardInstallDriver()
{
    // Make sure the new ISR isn't already in use.
    if(oldKeyboardIsr == (void *)0)
    {
        oldKeyboardIsr = _dos_getvect(KEYBOARD_INTERRUPT_VECTOR);
        _dos_setvect(KEYBOARD_INTERRUPT_VECTOR, KeyboardIsr);
    }
}
void KeyboardUninstallDriver()
{
    // Make sure the new ISR is in use.
    if(oldKeyboardIsr != (void *)0)
    {
        _dos_setvect(KEYBOARD_INTERRUPT_VECTOR, oldKeyboardIsr);
        oldKeyboardIsr = (void *)0;
    }
}
void KeyboardDumpScancodeLog()
{
    FILE *keyLogFile = fopen("keylog.hex", "w+b");
    if(!keyLogFile)
    {
        printf("ERROR: Couldn't open file for key logging!n");
    }
    else
    {
        int i;
        for(i = 0; i < 256; ++i)
        {
            fputc(keyCodeLog[i], keyLogFile);
        }

        fclose(keyLogFile);
    }
}

键盘_scan_codes.h （只需将所有scancodes定义为qwerty按钮布局）

#ifndef KEYBOARD_SCAN_CODES_H_INCLUDED
#define KEYBOARD_SCAN_CODES_H_INCLUDED

// Original 83 Keys from the IBM 83-key Model F keyboard
#define SCAN_NONE              0x00
#define SCAN_ESC               0x01
#define SCAN_1                 0x02
#define SCAN_2                 0x03
#define SCAN_3                 0x04
#define SCAN_4                 0x05
#define SCAN_5                 0x06
#define SCAN_6                 0x07
#define SCAN_7                 0x08
#define SCAN_8                 0x09
#define SCAN_9                 0x0A
#define SCAN_0                 0x0B
#define SCAN_MINUS             0x0C
#define SCAN_EQUALS            0x0D
#define SCAN_BACKSPACE         0x0E
#define SCAN_TAB               0x0F
#define SCAN_Q                 0x10
#define SCAN_W                 0x11
#define SCAN_E                 0x12
#define SCAN_R                 0x13
#define SCAN_T                 0x14
#define SCAN_Y                 0x15
#define SCAN_U                 0x16
#define SCAN_I                 0x17
#define SCAN_O                 0x18
#define SCAN_P                 0x19
#define SCAN_LEFT_BRACE        0x1A
#define SCAN_RIGHT_BRACE       0x1B
#define SCAN_ENTER             0x1C
#define SCAN_LEFT_CONTROL      0x1D
#define SCAN_A                 0x1E
#define SCAN_S                 0x1F
#define SCAN_D                 0x20
#define SCAN_F                 0x21
#define SCAN_G                 0x22
#define SCAN_H                 0x23
#define SCAN_J                 0x24
#define SCAN_K                 0x25
#define SCAN_L                 0x26
#define SCAN_SEMICOLON         0x27
#define SCAN_APOSTROPHE        0x28
#define SCAN_ACCENT            0x29
#define SCAN_TILDE             0x29 // Duplicate of SCAN_ACCENT with popular Tilde name.
#define SCAN_LEFT_SHIFT        0x2A
#define SCAN_BACK_SLASH        0x2B
#define SCAN_Z                 0x2C
#define SCAN_X                 0x2D
#define SCAN_C                 0x2E
#define SCAN_V                 0x2F
#define SCAN_B                 0x30
#define SCAN_N                 0x31
#define SCAN_M                 0x32
#define SCAN_COMMA             0x33
#define SCAN_PERIOD            0x34
#define SCAN_FORWARD_SLASH     0x35
#define SCAN_RIGHT_SHIFT       0x36
#define SCAN_KP_STAR           0x37
#define SCAN_KP_MULTIPLY       0x37 // Duplicate of SCAN_KP_STAR
#define SCAN_LEFT_ALT          0x38
#define SCAN_SPACE             0x39
#define SCAN_CAPS_LOCK         0x3A
#define SCAN_F1                0x3B
#define SCAN_F2                0x3C
#define SCAN_F3                0x3D
#define SCAN_F4                0x3E
#define SCAN_F5                0x3F
#define SCAN_F6                0x40
#define SCAN_F7                0x41
#define SCAN_F8                0x42
#define SCAN_F9                0x43
#define SCAN_F10               0x44
#define SCAN_NUM_LOCK          0x45
#define SCAN_SCROLL_LOCK       0x46
#define SCAN_KP_7              0x47
#define SCAN_KP_8              0x48
#define SCAN_KP_9              0x49
#define SCAN_KP_MINUS          0x4A
#define SCAN_KP_4              0x4B
#define SCAN_KP_5              0x4C
#define SCAN_KP_6              0x4D
#define SCAN_KP_PLUS           0x4E
#define SCAN_KP_1              0x4F
#define SCAN_KP_2              0x50
#define SCAN_KP_3              0x51
#define SCAN_KP_0              0x52
#define SCAN_KP_PERIOD         0x53
// Extended keys for the IBM 101-key Model M keyboard.
#define SCAN_RIGHT_ALT         0xE038
#define SCAN_RIGHT_CONTROL     0xE01D
#define SCAN_LEFT_ARROW        0xE04B
#define SCAN_RIGHT_ARROW       0xE04D
#define SCAN_UP_ARROW          0xE048
#define SCAN_DOWN_ARROW        0xE050
#define SCAN_NUMPAD_ENTER      0xE01C
#define SCAN_INSERT            0xE052
#define SCAN_DELETE            0xE053
#define SCAN_HOME              0xE047
#define SCAN_END               0xE04F
#define SCAN_PAGE_UP           0xE049
#define SCAN_PAGE_DOWN         0xE051
#define SCAN_KP_FORWARD_SLASH  0xE035
#define SCAN_PRINT_SCREEN      0xE02AE037
#endif // KEYBOARD_SCAN_CODES_H_INCLUDED