键盘驱动程序设计(下)

已于 2022-04-02 16:53:50 修改
阅读量230 收藏 1
点赞数 1
分类专栏： 操作系统 文章标签： 操作系统
于 2021-12-24 11:14:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/122123351
版权

问题

如何判断键盘是属于数字小键盘？数字小键盘上的按键有什么特殊之处？

数字小键盘键位判断

 因为数字小键盘上的键位功能并不唯一，所以需要配合完整的扫描码进行判断。

编码前的考虑

Shift 键：同一个键位可能表示不同功能

Caps Lock 键：默认字母大小写控制

Num Lock 键：小数字键盘启动控制

数字小键盘的特殊之处

默认情况下，Num Lock 处于关闭状态 

默认情况下按键不代表特殊字符，代表特殊功能

Num Lock 打开后，可使用 Shift 控制键位意义

数字按键键位编码

普通键位编码

键盘键位编码

keyboard.h


#ifndef KEYBOARD_H
#define KEYBOARD_H

#include "type.h"

#define Dim(a)    (sizeof((a)) / sizeof((*a)))

void PutScanCode(byte sc);
uint FetchKeyCode();

#endif

keyboard.c


#include "keyboard.h"
#include "screen.h"
#include "utility.h"

typedef struct
{
	byte ascii1;   // no shift code
    byte ascii2;   // shift code
    byte scode;    // scan code
    byte kcode;    // key code
} KeyCode;

enum
{
	KeyRelease = 0,
	KeyPress = 0x1000000
};

static const KeyCode gKeyMap[] = 
{
/* 0x00 - none      */ {  0,        0,        0,         0   },
/* 0x01 - ESC       */ {  0,        0,       0x01,      0x1B },
/* 0x02 - '1'       */ { '1',      '!',      0x02,      0x31 },
/* 0x03 - '2'       */ { '2',      '@',      0x03,      0x32 },
/* 0x04 - '3'       */ { '3',      '#',      0x04,      0x33 },
/* 0x05 - '4'       */ { '4',      '$',      0x05,      0x34 },
/* 0x06 - '5'       */ { '5',      '%',      0x06,      0x35 },
/* 0x07 - '6'       */ { '6',      '^',      0x07,      0x36 },
/* 0x08 - '7'       */ { '7',      '&',      0x08,      0x37 },
/* 0x09 - '8'       */ { '8',      '*',      0x09,      0x38 },
/* 0x0A - '9'       */ { '9',      '(',      0x0A,      0x39 },
/* 0x0B - '0'       */ { '0',      ')',      0x0B,      0x30 },
/* 0x0C - '-'       */ { '-',      '_',      0x0C,      0xBD },
/* 0x0D - '='       */ { '=',      '+',      0x0D,      0xBB },
/* 0x0E - BS        */ {  0,        0,       0x0E,      0x08 },
/* 0x0F - TAB       */ {  0,        0,       0x0F,      0x09 },
/* 0x10 - 'q'       */ { 'q',      'Q',      0x10,      0x51 },
/* 0x11 - 'w'       */ { 'w',      'W',      0x11,      0x57 },
/* 0x12 - 'e'       */ { 'e',      'E',      0x12,      0x45 },
/* 0x13 - 'r'       */ { 'r',      'R',      0x13,      0x52 },
/* 0x14 - 't'       */ { 't',      'T',      0x14,      0x54 },
/* 0x15 - 'y'       */ { 'y',      'Y',      0x15,      0x59 },
/* 0x16 - 'u'       */ { 'u',      'U',      0x16,      0x55 },
/* 0x17 - 'i'       */ { 'i',      'I',      0x17,      0x49 },
/* 0x18 - 'o'       */ { 'o',      'O',      0x18,      0x4F },
/* 0x19 - 'p'       */ { 'p',      'P',      0x19,      0x50 },
/* 0x1A - '['       */ { '[',      '{',      0x1A,      0xDB },
/* 0x1B - ']'       */ { ']',      '}',      0x1B,      0xDD },
/* 0x1C - CR/LF     */ {  0,        0,       0x1C,      0x0D },
/* 0x1D - l. Ctrl   */ {  0,        0,       0x1D,      0x11 },
/* 0x1E - 'a'       */ { 'a',      'A',      0x1E,      0x41 },
/* 0x1F - 's'       */ { 's',      'S',      0x1F,      0x53 },
/* 0x20 - 'd'       */ { 'd',      'D',      0x20,      0x44 },
/* 0x21 - 'f'       */ { 'f',      'F',      0x21,      0x46 },
/* 0x22 - 'g'       */ { 'g',      'G',      0x22,      0x47 },
/* 0x23 - 'h'       */ { 'h',      'H',      0x23,      0x48 },
/* 0x24 - 'j'       */ { 'j',      'J',      0x24,      0x4A },
/* 0x25 - 'k'       */ { 'k',      'K',      0x25,      0x4B },
/* 0x26 - 'l'       */ { 'l',      'L',      0x26,      0x4C },
/* 0x27 - ';'       */ { ';',      ':',      0x27,      0xBA },
/* 0x28 - '\''      */ { '\'',     '\"',     0x28,      0xDE },
/* 0x29 - '`'       */ { '`',      '~',      0x29,      0xC0 },
/* 0x2A - l. SHIFT  */ {  0,        0,       0x2A,      0x10 },
/* 0x2B - '\'       */ { '\\',     '|',      0x2B,      0xDC },
/* 0x2C - 'z'       */ { 'z',      'Z',      0x2C,      0x5A },
/* 0x2D - 'x'       */ { 'x',      'X',      0x2D,      0x58 },
/* 0x2E - 'c'       */ { 'c',      'C',      0x2E,      0x43 },
/* 0x2F - 'v'       */ { 'v',      'V',      0x2F,      0x56 },
/* 0x30 - 'b'       */ { 'b',      'B',      0x30,      0x42 },
/* 0x31 - 'n'       */ { 'n',      'N',      0x31,      0x4E },
/* 0x32 - 'm'       */ { 'm',      'M',      0x32,      0x4D },
/* 0x33 - ','       */ { ',',      '<',      0x33,      0xBC },
/* 0x34 - '.'       */ { '.',      '>',      0x34,      0xBE },
/* 0x35 - '/'       */ { '/',      '?',      0x35,      0xBF },
/* 0x36 - r. SHIFT  */ {  0,        0,       0x36,      0x10 },
/* 0x37 - '*'       */ { '*',      '*',      0x37,      0x6A },
/* 0x38 - ALT       */ {  0,        0,       0x38,      0x12 },
/* 0x39 - ' '       */ { ' ',      ' ',      0x39,      0x20 },
/* 0x3A - CapsLock  */ {  0,        0,       0x3A,      0x14 },
/* 0x3B - F1        */ {  0,        0,       0x3B,      0x70 },
/* 0x3C - F2        */ {  0,        0,       0x3C,      0x71 },
/* 0x3D - F3        */ {  0,        0,       0x3D,      0x72 },
/* 0x3E - F4        */ {  0,        0,       0x3E,      0x73 },
/* 0x3F - F5        */ {  0,        0,       0x3F,      0x74 },
/* 0x40 - F6        */ {  0,        0,       0x40,      0x75 },
/* 0x41 - F7        */ {  0,        0,       0x41,      0x76 },
/* 0x42 - F8        */ {  0,        0,       0x42,      0x77 },
/* 0x43 - F9        */ {  0,        0,       0x43,      0x78 },
/* 0x44 - F10       */ {  0,        0,       0x44,      0x79 },
/* 0x45 - NumLock   */ {  0,        0,       0x45,      0x90 },
/* 0x46 - ScrLock   */ {  0,        0,       0x46,      0x91 },
/* 0x47 - Home      */ {  0,        0,       0x47,      0x24 },
/* 0x48 - Up        */ {  0,        0,       0x48,      0x26 },
/* 0x49 - PgUp      */ {  0,        0,       0x49,      0x21 },
/* 0x4A - '-'       */ {  0,        0,       0x4A,      0x6D },
/* 0x4B - Left      */ {  0,        0,       0x4B,      0x25 },
/* 0x4C - MID       */ {  0,        0,       0x4C,      0x0C },
/* 0x4D - Right     */ {  0,        0,       0x4D,      0x27 },
/* 0x4E - '+'       */ {  0,        0,       0x4E,      0x6B },
/* 0x4F - End       */ {  0,        0,       0x4F,      0x23 },
/* 0x50 - Down      */ {  0,        0,       0x50,      0x28 },
/* 0x51 - PgDown    */ {  0,        0,       0x51,      0x22 },
/* 0x52 - Insert    */ {  0,        0,       0x52,      0x2D },
/* 0x53 - Del       */ {  0,        0,       0x53,      0x2E },
/* 0x54 - Enter     */ {  0,        0,       0x54,      0x0D },
/* 0x55 - ???       */ {  0,        0,        0,         0   },
/* 0x56 - ???       */ {  0,        0,        0,         0   },
/* 0x57 - F11       */ {  0,        0,       0x57,      0x7A },  
/* 0x58 - F12       */ {  0,        0,       0x58,      0x7B },
/* 0x59 - ???       */ {  0,        0,        0,         0   },
/* 0x5A - ???       */ {  0,        0,        0,         0   },
/* 0x5B - Left Win  */ {  0,        0,       0x5B,      0x5B },	
/* 0x5C - Right Win */ {  0,        0,       0x5C,      0x5C },
/* 0x5D - Apps      */ {  0,        0,       0x5D,      0x5D }
};

static uint IsShift(byte sc)
{
	return (sc == 0x2A) || (sc == 0x36);
}

static uint IsCapsLock(byte sc)
{
	return (sc == 0x3A);
}

static uint IsNumLock(byte sc)
{
	return (sc == 0x45);
}

static uint IsNumPadKey(byte sc, byte E0)
{
	static const byte cNumScanCode[]            = {0x52, 0x53, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47, 0x48, 0x49, 0x35, 0x37, 0x4A, 0x4E, 0x1C};  
    static const byte cNumE0[Dim(cNumScanCode)] = {0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    1,    0,    0,    0,    1   };
    
    uint ret = 0;
    uint i = 0;
    
    for(i = 0; i < Dim(cNumScanCode); i++)
    {
    	byte* pc = AddrOff(cNumScanCode, i);
    	byte* pe = AddrOff(cNumE0, i);
    	
    	if((sc == *pc) && (*pe == E0))
    	{
    		ret = 1;
    		
    		break;
    	}
    }
    
    return ret;
}

static uint MakeNumCode(KeyCode* pkc, int shift, int num)
{
	static const KeyCode cNumKeyMap[] = 
    {
        { '0',       0,       0x52,     0x2D },
        { '.',       0,       0x53,     0x2E },
        { '1',       0,       0x4F,     0x23 },
        { '2',       0,       0x50,     0x28 },
        { '3',       0,       0x51,     0x22 },
        { '4',       0,       0x4B,     0x25 },
        { '5',       0,       0x4C,     0x0C },
        { '6',       0,       0x4D,     0x27 },
        { '7',       0,       0x47,     0x24 },
        { '8',       0,       0x48,     0x26 },
        { '9',       0,       0x49,     0x21 },
        { '/',      '/',      0x35,     0x6F },
        { '*',      '*',      0x37,     0x6A },
        { '-',      '-',      0x4A,     0x6D },
        { '+',      '+',      0x4E,     0x6B },
        {  0,        0,       0x1C,     0x0D },
        {  0,        0,        0,        0   }
    };
    
    uint ret = 0;
    int i = 0;
    KeyCode* nkc = NULL;
    
    for(i = 0; i < Dim(cNumKeyMap); i++)
	{
		KeyCode* tmp = AddrOff(cNumKeyMap, i);
		
		if(tmp->scode == pkc->scode)
		{
			nkc = tmp;
			break;
		}
	}
	
	if(nkc != NULL)
	{
		if(!num)
		{
			ret = (nkc->scode << 16) | (nkc->kcode << 8) | nkc->ascii2;
		}
		else
		{
			if(!shift)
			{
				ret = (nkc->scode << 16) | (nkc->kcode << 8) | nkc->ascii1;
			}
			else
			{
				ret = (nkc->scode << 16) | (nkc->kcode << 8) | nkc->ascii2;
			}
		}
	}
	
	return ret;
}

static uint MakeNormalCode(KeyCode* pkc, int shift, int caps)
{
	uint ret = 0;
	
	if(!caps)
	{
		if(!shift)
		{
			ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii1;
		}
		else
		{
			ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii2;
		}
	}
	else
	{
		if((pkc->ascii1 >= 'a') && (pkc->ascii1 <= 'z'))
		{
			if(!shift)
			{
				ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii2;
			}
			else
			{
				ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii1;
			}
		}
		else
		{
			if(!shift)
			{
				ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii1;
			}
			else
			{
				ret = (pkc->scode << 16) | (pkc->kcode << 8) | pkc->ascii2;
			}
		}
	}
	
	return ret;
}

static uint MakeCode(KeyCode* pkc, int shift, int caps, int num, int E0)
{
	uint ret = 0;
	
	if(IsNumPadKey(pkc->scode, E0))
	{
		ret = MakeNumCode(pkc, shift, num);
	}
	else
	{
		ret = MakeNormalCode(pkc, shift, caps);
	}
	
	return ret;
}

static uint KeyType(byte sc)
{
	uint ret = KeyPress;
	
	if(sc & 0x80)
	{
		ret = KeyRelease;
	}
	
	return ret;
}

static uint PauseHandler(byte sc)
{
	uint ret = 0;
	
	
	return ret;
}

static uint KeyHandler(byte sc)
{
	uint ret = 0;
	
	static uint cShift = 0;
	static uint cCapsLock = 0;
	static uint cNumLock = 0;
	static uint E0 = 0;
	
	if(sc == 0xE0)
	{
		E0 = 1;
		ret = 1;
	}
	else
	{
		uint pressed = KeyType(sc);
		KeyCode* pkc = NULL;
		
		if(!pressed)
		{
			sc -= 0x80;
		}
		
		pkc = (KeyCode*)AddrOff(gKeyMap, sc);
		
		if(ret = !!pkc->scode)
		{
			uint code = 0;
			
			if(IsShift(sc))
			{
				cShift = pressed;
			}
			else if(IsCapsLock(sc) && pressed)
			{
				cCapsLock = !cCapsLock;
			}
			else if(IsNumLock(sc) && pressed)
			{
				cNumLock = !cNumLock;
			}
			
			code = pressed | MakeCode(pkc, cShift, cCapsLock, cNumLock, E0);
			
			if(pressed)
			{
				PrintChar((char)code);
			}
			
			E0 = 0;
		}
	}
	
	return ret;
}

void PutScanCode(byte sc)
{
	if(PauseHandler(sc))
	{
		/* Pause Key */
	}
	else if(KeyHandler(sc))
	{
		/* Normal Key */
	}
	else
	{
		/* Uknown Key */
	}
}

uint FetchKeyCode()
{
	uint ret = 0;
	
	
	return ret;
}

ihandler.c

void KeyboardHandler()
{
	byte sc = ReadPort(0x60);
	
	// PrintIntHex(sc);
	// PrintString("  ");

	PutScanCode(sc);

	SendEOI(MASTER_EOI_PORT);
}

MakeCode 函数根据按键的区域，对不同区域的按键调用不同的按键编码函数。

我们打印获得 code 的低8位，也就是 ASCII 值。

根据 Shift、Caps Lock 和 Num Lock 的组合，屏幕上打印了相应按键的 ASCII 值。 

思考

内核对按键事件进行编码后，如何处理？

qq_52484093
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
拍档KB68V101编程键盘
07-20
拍档KB68编程键盘版本号1.01.
计算机键盘驱动,修改键盘驱动程序_基本计算机知识_IT /计算机_信息
weixin_29832179的博客
07-27 3331
修改键盘驱动程序：通过“我的电脑”打开系统属性，选择硬件选项卡：打开设备管理器，我们发现在中文Windows XP操作系统下，默认键盘驱动程序为“标准101/102键”或Microsoft自然的PS / 2键盘”。1.右键单击并选择更新驱动程序，然后将出现硬件更新向导：选择“从列表或特定位置安装(高级)”，单击“下一步”，然后选择“不搜索。我将选择要安装的驱动程序。”单击“下一步”进入“选择要为此...
键盘驱动程序设计(上)
qq_52484093的博客
12-20 1375
问题 计算机已经接入了键盘，为啥按键没反应啊？ 因为键盘是外设，当按键被按下是会向处理器发送中断，而我们并没有编写相应的中断处理函数。 键盘的本质 键盘是一种计算机外部设备 键盘与计算机的通信 (数据交互) 需要借助中断完成 键盘的中断引脚接在 主8259A 的 IRQ1 引脚上。 键盘驱动步骤 1. 使能 8259A 引脚 IRQ1 (启用键盘中断) 2. 编写中断服务程序，并注册到中断向量表 (0x21号中断) 键盘中断 interrupt.c void..
如何编写键盘驱动程序
秦超的学习笔记
09-30 8524
1.  指定USB键盘驱动所需的头文件: #include/*内核头文件，含有内核一些常用函数的原型定义*/   #include/*定义内存分配的一些函数*/   #include/*模块编译必须的头文件*/   #include/*输入设备相关函数的头文件*/
键盘驱动程序设计(中)
qq_52484093的博客
12-22 1541
问题 键盘扫描码可以直接使用吗？扫描码代表键位上的字符吗？ 键盘扫描码不可以直接使用，扫描码不代表键位上的字符。 常用编码区别 扫描码(Scan Code) 与键盘厂商有关，不同厂商的扫描码肯能不同 虚拟键码(Key Code) 键盘按键统一标准编码 (键盘厂商无关) ASCII 码 常用字符的统一编码 (键盘按键无关) 键盘驱动设计 建立扫描码，虚拟键码，ASCII 码之间的映射 解析扫描码，处理常用组合键 (Shift，Caps lock，等) 用4字节表示键盘操作结果：动作
键盘过滤驱动程序设计.pdf
08-26
键盘过滤驱动程序设计 (1) 想DIY DDK驱动 键盘过滤驱动程序设计.pdf (433.08 KB, 下载次数: 51 )
ps2标准键盘驱动程序.zip
03-11
标题中的“ps2标准键盘驱动程序.zip”表明这是一个包含了PS/2（个人系统/2）标准键盘驱动程序的压缩文件，适用于Windows操作系统。驱动程序是操作系统与硬件设备之间的重要桥梁，它允许操作系统识别并有效控制硬件...
事件驱动程序设计
02-25
运行java图形用户界面程序时,程序与用户进行交互,事件驱动程序的执行.事件(event)可以定义为程序发生了某些事情的信号.外部用户动作和内部程序动作都可以触发事件,外部用户动作的例子有移动鼠标,点击按钮和敲击键盘...
1代苹果蓝牙键盘驱动程序64位，windows7/10/11可用（Del键可用）
12-17
苹果蓝牙键盘驱动程序是专为苹果的无线蓝牙键盘设计的，尤其是一代产品，它使得这款键盘能够在Windows操作系统上正常工作。驱动程序是操作系统与硬件设备之间的重要桥梁，没有合适的驱动，硬件设备往往无法被系统...
键盘按键控制程序的简单案例
anpi8314的博客
02-26 825
# -*- coding: utf-8 -*- """ Created on Tue Feb 26 12:29:57 2019 @author: 车路历程 """ from tkinter import * def Advance(event): print("前进") def Retreat(event): print("后退") ...
4*4键盘驱动程序.txt
12-05
4*4键盘驱动程序，在做单片机开发的时候往往会用到4*4键盘，这就是它的驱动程序，已测试，好用的！
LabVIEW虚拟键盘程序的设计与应用
最新发布
ZkHIny3的博客
09-11 727
尽管该程序不支持输入法的切换，但作者发布的另一个键盘程序可实现中文输入法的切换，进一步丰富了虚拟键盘的功能。虚拟键盘程序是LabVIEW编程中的一个重要应用，它可以在触摸屏电脑系统上模拟实际键盘的输入操作，方便用户进行字符和数字的输入。同时，作者发布的另一个支持中文输入法切换的键盘程序进一步扩展了虚拟键盘的应用范围，为用户提供了更多选择和便利。虽然该程序不支持输入法的切换，但作者发布的另一个键盘程序可支持切换中文输入法来输入汉字，扩大了虚拟键盘的应用范围。分两个键盘，一个是输入数字的，一个是输入字符串的。
单片机 键盘程序+仿真
小玉甘甘的博客
11-17 488
#include<reg51.h> #define uchar unsigned char #define uint unsigned int sbit jia1=P3^3; sbit jian1=P3^4; sbit jia10=P1^0; sbit jian10=P1^1; uchar count=0; uchar code Tab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}; void delay(uint del) { ui
矩阵键盘驱动程序
学习ing.........
09-22 1233
#ifndef _KEY_H_ #include #include "./delay/delay.h" #define _KEY_H_ #define KEYPORT P0 extern unsigned char ker_scan(void); extern unsigned char key_pro(void); #endif #include "key.h" /
虚拟键盘驱动程序
国产开源 GUI 引擎 AWTK
09-13 8852
虚拟键盘驱动程序Saturday, September 12th, 2009 | Author: admin转载时请注明出处和作者联系方式文章出处：http://www.limodev.cn/blog作者联系方式：李先静 前段时间写一个程序，要向系统中注入按键事件，我又不想信赖于具体的GUI，就写一个虚拟键盘设备驱动程序，感觉挺好用的，不过后来发现linux其实有一个u
怎么解决计算机键盘驱动,解决键盘失灵、安装更新键盘驱动方法
热门推荐
weixin_36235398的博客
07-26 1万+
怎样重新安装电脑键盘驱动第一步：点击打开“我的电脑”属性选项，选择硬件标签，打开设备管理器，点击打开“键盘选项”默认的键盘驱动是“标准101/102键或Microsoft自然PS/2键盘”。 右键...如何重装键盘驱动操作系统装好之后默认已经装好通用键盘驱动程序了，所以很多用户以为键盘无需驱动。可以在设备管理器中查看键盘驱动程序，如有可能备份一下，必要时会用得上。...怎样重新安装键盘驱动程序键盘...
如何在Linux下模拟键盘输入 利用驱动程序实现
sdgaojian的专栏
12-29 919
分类： LINUX 参考:http://blog.csdn.net/absurd/archive/2009/09/13/4549514.aspx 驱动程序: #include linux/module.h> #include linux/moduleparam.h> #include linux/init.h> #include linux/
嵌入式驱动编写-按键驱动程序
joshua_love的博客
11-06 5366
 今天,写出开发板上的最简单的按键驱动程序,首先需要阅读开发板的原理图和芯片手册. GPG3  GPG11  GPF0  GPF2四个引脚控制按键. 由原理图可知,需要将GPG3  GPG11  GPF0  GPF2设为输入引脚. 1 编写驱动程序 #include #inclu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值