【灌水无罪】老机械键盘改造USB，QWERTY/Dvorak一键切换

miaozhuang

0 K1 ]& |5 U  s) t( l# Phttp://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。
' M% D) K' Q/ q" H0 b
- v1 |1 u' g, `: i8 }在看这个帖子的诸位一定都在用计算机键盘吧。键盘上的数字键是1到9从左至右排列，或者是右小键盘区那样三个一排有序排列，反正规律很明显。但是字母键却不是A,B,C...到Z这么按字母序有规律地排下来的。我刚接触电脑(其实还是学习机)的时候，没在意这个问题，觉得是要盲打嘛，反正对两手的手指头来说，按字母序排列并没有什么好处。于是用多了这些排列也就记住了，从来不管它为什么要这样。其实，PC的键盘键位排布上是延用了打字机的键盘，这是设备演变过程中很自然的一个延续。打字机的历史就要早很多了，我没有亲见过打字机长什么样，而且，咱们汉字是铅字打上去的，和英文打字机方式完全不同。

- N7 L* Z2 i1 r( x" X& g- _
上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。
" V- F3 T: ?0 O# F5 i8 K
) Q+ B/ w) E$ ]' ^! m为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：
) A8 e( U2 ?3 b7 F) w
0 a; o8 f- a) H9 f  ]其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
9 Z  B% p( S# O+ L. ^6 Z# ODvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：

Dvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。
4 k( N. q! C4 H# o. K
我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
$ p# _0 F6 l9 X6 C3 V1 e; Y
到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。

5 n0 ?0 V( [& q0 M, j& N机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：
  i: k8 S9 v1 c( ]
+ {! q. Q+ z: J! w----------------------------------------------------  分割线 ----------------------------------------------------------

9 S. B( W6 X6 A* E5 p3 t" D: `* X先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。

轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
2 P* d1 n# p: P. i
特写，80C49

* t) d( Y0 i1 L+ p( z% u# k' \LED部分，使用了一片D触发器锁存指示灯状态.

暴力破坏，将80C49拆掉

4 g- P- u' F# w5 ?拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。
; j2 G' B# e* p  |1 G. K
焊好元件后的板子，准备替换80C49

用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.
. D% y3 v! I9 r8 a& a; ?. @& v) F( I4 A
开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。

我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
% N  n; i1 r6 j5 ~2 W' N# O: h
主键区键帽就位

1 O0 }2 m# c; ^& C编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。

最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
, y! \2 {! e# g* p' c
% }0 ~: |' e: s8 d  F& r5 A. T& O
----------------------------------------------------- 分割线 --------------------------------------------------
) j9 P; |- u) U, E


) P# r0 |5 r3 ?, a4 c. G) B
3 ]8 M/ R9 O2 |, ^' Y5 N- F
! j1 D; I" R& T: n
# E" B- O& }' b
* @  |2 b, A- S% o/ [/ \2 v

' N1 Z# ?& @7 A' H3 T. q4 D, a, X& c
1 W+ p5 E- Y7 f; T7 `4 D

miaozhuang

DIY过程直播完了，下面说硬件的设计。
: X. o7 g/ ?2 z+ v: u, F' e. N80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：


其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)
+ z; C+ W% L( u9 e# w! h% H
0 ?6 D. ~1 b+ N% t
+ g4 R* o( s- y# p: ?2 R扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。

4 w. E2 m" W8 ]" l0 j4 \! b这是我设计的电路图：
/ Y0 M# s2 C% F! r- r- U
) [, Y7 t0 c, Z' V6 d$ m) Z* m
PCB Layout:

. |# Z9 c# k' Z( N  y0 D$ W7 _
5 c2 t& q, F: G( J8 U不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.

miaozhuang

软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
; }' x$ n9 ~% q6 J5 t5 y/ H& X9 w
总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：

! a7 d* @7 v( \/ B: @$ Y
其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）

USB的中断ISR，bare metal哦

void USB_IRQHandler(void)
( j: ]7 F! Q$ \& _  f1 m8 B{
    if(USB->ISTR & USB_ISTR_CTR)
0 A( L9 V+ \/ P# d4 }- B" K" Y    {
        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
2 T7 D+ K2 B9 }/ i4 @        {
9 W* c) V& ^. J            switch(ep0_state)
3 E  h: b& b5 X* b9 v/ O            {
: V& A6 r7 q1 K! X                case 0: ep0_state |= 0x80;
                        break;
                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                            ep0_state=3;
                            return;
2 v" t8 K: ?5 Q" |4 G+ B( i1 K                        }
0 z! n$ T, u" z1 Z" H                        else
                            ep0_state=0;
                        break;
                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
                        else
0 J3 t9 ]$ R- F; T1 z                            ep0_state=0;
5 A. Q1 s& @; `) Z7 A                        break;
! N2 g) J8 T2 K/ W                case 3: ep0_state=0;
, ?4 g8 y/ q! Q' p& M) U1 _4 L                        break;
4 z9 i; B7 s7 ^# ?                case 4: ep0_state=0;
: [0 I! ^1 p% R+ P. E6 Q6 ?                        break;
                default:ep0_state=0;
                        break;
            }
            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
8 T% w: r) J" x0 X4 }        }
        else    // EP_ID can be 1
( z; ^* D$ L- g! i, ^* h        {
+ }" C. w; N3 B( C8 M, g            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
            return;
        }
    }
2 y( C2 y6 m& L0 H3 z( R" U    if(USB->ISTR & USB_ISTR_PMAOVR)
0 W& U* K" G' S: b' n8 b    {
7 r6 n7 A7 {1 R2 M1 s' ^8 E' k        USB->ISTR = ~USB_ISTR_PMAOVR;
" T* I; x2 J9 w+ n8 b6 O) U    }
4 g5 @9 b/ m2 B1 D; M% ]: D( X    if(USB->ISTR & USB_ISTR_ERR)
1 ~! f) q3 x1 l  B4 S2 x    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
1 b6 D7 t! P% ^7 L    }
; J1 R$ S. T4 w4 h; @    if(USB->ISTR & USB_ISTR_WKUP)
    {
+ j3 e  L6 N) L& i* y$ F3 }+ @        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
/ x7 A+ a: ?7 N1 V* ]; I        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SUSP)
    {
        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
    }
$ R0 A# v+ g+ E2 @( f8 v    if(USB->ISTR & USB_ISTR_RESET)
    {
! [1 n( Y: m8 U. a        USB->BTABLE = 0;    // buffer table at bottom of PMA
( o2 J6 g  A% R+ ?5 g& d& Z, s0 }        USB_PMA[0]=128; //ADDR0_TX
9 E3 M  O. z3 b+ a        USB_PMA[1]=0;   //COUNT0_TX
        USB_PMA[2]=256; //ADDR0_RX
, F- q$ P+ Z  {* ~& b% v        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
        USB_PMA[4]=384; //ADDR1_TX
4 E8 T9 w) j0 M" B& x8 L        USB_PMA[5]=0;   //COUNT1_TX
        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
6 c# `" @! n: w0 U* `        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
' q; V8 D: M5 C' d        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
# N1 Z' ^3 F# X' L    }
    if(USB->ISTR & USB_ISTR_SOF)
3 `( x+ `  O1 V* V- ?3 u    {
! X$ V( x6 {1 K' o. y        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
, d3 j0 L, S' b& }2 P' d) n    }
8 g% q, O9 d. b}
# _; H" g; E6 Z# @$ Y
" a1 [, P/ B' e6 @8 T8 b" [因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。

主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
+ f# {$ J, j) ]. W7 g: _0 m  x
    while(1)
    {
0 |: s' s; R: b9 f" e5 U        static char row=0;
        __WFI();
        if(ep0_state & 0x80)    // request data processing
- k! W' ?# G% O8 m1 }% B        {
            if(ep0_state==0x80) // SETUP phase
            {
7 v' e+ [2 P! }0 S                if(!setup_packet_service())
                {
                    ep0_state=0;
                    // not supported
% M* p5 }7 d* v) G                }
( Q0 b" v% T* m/ K8 @" p* ]) x                // ep0_state should be set to 1 or 2, if processed
# Y* B  X3 K% c. {% v            }
            else    // OUT phase
            {
                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
                ep0_state=4;
1 b* `- M7 }- j" S# I' a. Y" v                USB_PMA[1]=0;       // Zero length DATA0
; P! X3 {+ T. X+ a4 o$ I$ T                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
) K4 }2 [& n7 C4 X% e) M3 ?; |! U/ o' A        }
) W$ W  b2 K9 E9 \" y" y        else
) C) t( I( d1 X  b8 W8 g+ o        {
2 F4 @; ~, X$ @. ]  B* \            if(usb_address && ep0_state==0)
/ Z2 h- [/ n- x4 ~            {
                USB->DADDR = USB_DADDR_EF|usb_address;
6 l* x: s" n7 \. l                usb_address=0;
3 N* X/ c+ ?! ?  V3 v            }
        }
6 o: R  ]6 f; _        if(row!=scan_row)   // new scan line
: o0 q& e6 p5 s1 q6 r) C; {' l* y3 q        {
            if(key_state[row]!=prev_key_state[row])
4 {- v6 V$ C1 P# }* i            {
) d& B2 L0 B, D5 W+ w                uint8_t test=0x80;
  a* n" C7 T  B, S7 x                uint8_t diff=key_state[row]^prev_key_state[row];
7 c$ A' i( ]5 c# i( V  k% i                for(i=0;i<8;i++)
+ L* t: i7 G, M* r' _+ b7 C' l, z                {
                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
! s0 r& r) l6 F                }
* s- d- v( h+ ^# o            }
2 h$ z) D; k' r; a7 L! Z0 w            row=scan_row;
  U3 W! k6 A( R, L" H0 C        }
    }


( G0 b6 P0 G9 Z$ i" S5 ^EP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
: c* r$ t8 x2 ^5 ], n8 ]{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
0 f: |$ w5 D. s6 u% N! e        switch(ep0_std_req->bRequest)
7 E+ L# I/ t, X2 `+ S( j$ w        {
            case REQ_GET_REPORT: break;
            case REQ_GET_IDLE:
- L- y1 a. u+ G  J3 }$ [: X                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
% h, H1 t6 _( I. T5 y6 M                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=1;
                return 1;
8 }* f! B/ S) e" r3 q                break;
4 P( H! K( c6 f3 b* ~            case REQ_SET_REPORT:
' M. c, R7 {9 b7 h1 H& g1 V                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
3 n# V+ H+ N& a$ L% J                ep0_state=2;
) l5 c- U5 \9 Y9 ?9 k+ H                return 1;
. I- C; q2 i) Y6 d5 K3 w8 e7 v6 }                break;
            case REQ_SET_IDLE:
/ E8 v3 ]& |# j+ x; m, G# [7 Q                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
- `0 O  i$ w# E: X# Y( g                return 1;
                break;
        }
6 E- j6 @- M+ J, L, m        return 0;
5 D+ |0 a# V6 i  L    }
    else    // standard
6 y9 T/ `0 l( F9 B/ s" V    {
        switch(ep0_std_req->bRequest)
        {
$ w& ?$ `$ e% h7 s1 {+ b            case REQ_GET_DESCRIPTOR:
, M# Q5 g2 o9 u9 L7 s                return descriptor_service();
                break;
& O4 R- x) G  n8 x            case REQ_SET_ADDRESS:
7 i  L' n* h. _# _  K+ j% ^9 A0 l                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
4 P& f1 z0 X/ f' ?                usb_address=ep0_std_req->wValue;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;       // Zero length DATA0
$ R/ R" Y2 T# J) P7 M# H) F% x                ep0_state=4;    // No Data phase
                return 1;
9 m0 W; k. \8 {- C2 T3 `! X            case REQ_SET_CONFIGURATION:
0 Y* ]0 @  _7 d# _                if(ep0_std_req->bmRequestType!=0x00)
/ f2 a2 G( e5 |( ^3 x' j0 n                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;   // Zero DATA
                ep0_state=4;    // No DATA phase
                return 1;
0 w) f" E8 Y9 }- x) K            default: return 0;
        }
7 H$ S3 z! q7 U* {# I    }
}

3 p8 f( Y0 H6 [" C: q- j4 n8 x

miaozhuang

各种描述符，是USB开发首先要处理的
char descriptor_service(void)
4 {0 W- k# H+ [% ]4 ?8 F# e5 I{
    switch((ep0_std_req->wValue)>>8)
    {
( ]4 h" F1 Y6 n% C4 |, V        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
            break;
0 {7 ?9 U2 {3 p" C' `% a" I0 }        case DESC_TYPE_CONFIG:
            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
            else
                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
            break;
/ w8 i- n% w% x! X3 A/ A$ K8 @        case DESC_TYPE_STRING:
            switch(ep0_std_req->wValue &0xff)
7 }  g6 N, J  s8 V  c: m            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
. M  e' c) C- d& ]4 v                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
# a+ g% M0 J' P! o8 Y: C                default: return 0;
/ e! m- ~- Z7 q) R8 g: L8 j  M            }
4 b# @; ~% I% b3 O! s! E: C" k: p            break;
, K. Z- u( P0 [+ ]9 n7 S% W: n        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
- T" y2 g) K7 w            return 0;
    }
}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
$ d) U. J- w: p: C{
    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);

! _/ K  k9 h' d) `6 L  x7 `* `
1 u* {3 O8 n' g0 }, h9 R    TIM6->SR &= ~TIM_SR_UIF;
3 \5 Z# p( _6 J+ ~    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
    switch(scan_row)
  i7 h$ M. o: P0 O) }    {
        case 13: // next row PB14
8 S9 R. L. n- f5 f) z! U% `* K                GPIOC->MODER = GPIOC_DEFAULT;
" v. \' m/ w( N  q                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
        case  0: // next row PB15
) K6 S" F) R) q                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
4 Y9 Y* G) n* j2 F  ?                break;
  ]" ^+ G7 C; H        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
. @# v& Z0 ?, \& \- S4 B                break;
& [0 \7 S+ A8 w( i7 V        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
& I  V$ s5 p' g, |                break;
% e1 |& w1 ^: v. V3 g        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
                break;
        case  4: // next row PB6
. i+ y4 I& e1 x  i                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
                break;
        case  5: // next row PB7
1 C! a4 }- b2 S" v                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
) `! {8 E7 H3 o3 g* I                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
                break;
6 w9 G8 r: x( J        case  7: // next row PB9
& w  ^% E! S. A6 ]/ n! N. O                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
  a" `6 |" b2 S8 N6 C                break;
. }, @% T% c+ S4 a( \        case  8: // next row PA8
; v+ c. _0 y/ P                GPIOB->MODER = GPIOB_DEFAULT;
; w' M) C5 h( N) l6 m                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
        case  9: // next row PA9
" p, _" t9 u% w! k' A2 r! }                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
6 Y, ^! l9 n& m" ~  @' R6 z/ y                break;
        case 10: // next row PA10
+ ^  s8 d3 q$ U. \, i' w                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
' A4 @! Y% R( a6 Y1 ~) B: m5 w" I                break;
; n) f( |5 B: M6 x        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case 12: // next row PC13
                GPIOA->MODER = GPIOA_DEFAULT;
* Y% W. B: G: f% p! x+ V+ I/ ]                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
. b5 I( p' h+ Y& t2 ]0 @+ F                break;
    }
' n7 t# T4 x/ F" e! g6 R& M    if(scan_row<13)
        scan_row++;
3 O, i* N$ O1 N& w- e( k& [    else
/ a' C7 B: k$ _( g# k) k        scan_row=0;
}

4 j/ R. S1 P; d, o6 Z' p

miaozhuang

扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。
% U8 d4 |$ l' i5 c7 `
, @( n2 |+ `3 k; n+ l' W要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

* l5 z" V8 \# q, x- g
+ D7 ~3 e4 T% U# ]- rconst char hid_keymap_qwerty[14][8]={
& Y$ [4 H( G: ?& p  @& H, c    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
: t5 o9 `3 z; P% ~    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
. ?- ]5 {1 \7 B# [" b8 W    {HK_Period, HK_V, HK_BSlash, HK_J, HK_P, HK_Q, HK_4, HK_F6},
    {HK_Comma, HK_C, HK_Quote, HK_H, HK_O, HK_Equal, HK_3, HK_F5},
7 E+ y& |3 y; G, U    {HK_M, HK_X, HK_Colon, HK_G, HK_I, HK_Minus, HK_2, HK_F4},
    {HK_LShift, HK_NONE, HK_Caps, HK_F, HK_U, HK_0, HK_1, HK_F3},
    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_D, HK_Y, HK_9, HK_BQuote, HK_F2},
5 ?( m& y4 e; @* b" i    {HK_NONE, HK_RAlt, HK_LCtrl, HK_S, HK_T, HK_8, HK_Enter, HK_F1},
    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
, I3 k. B  O. v7 }    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
& c: B: O5 b. P+ l, }( `' V    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
6 ~  y7 r6 n: |8 @7 D$ }( n    {HK_Space, HK_N, HK_Z, HK_L, HK_RBr, HK_E, HK_6, HK_F8},
1 O' o4 m9 h9 |    {HK_Slash, HK_B, HK_Delete, HK_K, HK_LBr, HK_W, HK_5, HK_F7},
    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};


1 Y0 x, Y# r+ i$ Qconst char hid_keymap_dvorak[14][8]={
+ c9 V' r+ _8 Z3 r    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_P, HK_7, HK_F9, HK_Esc},
* G3 `$ K; x9 X2 Z2 M7 h    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
1 c. |5 v1 @( e    {HK_V, HK_K, HK_BSlash, HK_H, HK_L, HK_Quote, HK_4, HK_F6},
    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
    {HK_LShift, HK_NONE, HK_Caps, HK_U, HK_G, HK_0, HK_1, HK_F3},
    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_E, HK_F, HK_9, HK_BQuote, HK_F2},
    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
( R, A9 o6 b+ P% o  R( U; r    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
) t  [* i* v- A: n# I' l3 x2 y1 i    {HK_Space, HK_B, HK_Colon, HK_N, HK_Equal, HK_Period, HK_6, HK_F8},
( Z- R- ]& P/ w. M) K' [    {HK_Z, HK_X, HK_Delete, HK_T, HK_Slash, HK_Comma, HK_5, HK_F7},
    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};
5 [' e8 `( M+ a3 [+ }6 B
' l! j/ [* o& n0 I; \
; T$ o8 d3 s/ M/ G7 y( D上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
4 k7 K' ~$ t2 ^7 O9 Y
6 E+ ^2 t" _6 g( ~9 NHID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
: y. F+ U4 h* q0 |* a
' X8 x* n$ a, o; L# q- b4 hvoid update_key_matrix(char row, char col, char onoff)
8 u) z& g  P% m( f8 t$ D# L' D{
+ d# d6 ?( Z, J+ g    static uint16_t hid_report[4]={0,0,0,0};
    static char (*hid_keymap)[8]=hid_keymap_dvorak;
8 G6 N7 ?' J3 e+ ]- k- }
2 r# D( D! r9 F. y
( h$ v7 e4 ?, b& E; t( ~3 o; Z9 ^    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
3 ]& i  K" T/ Z5 |4 l    char i;
) V& ^: K* [6 ?. h5 W
0 \' H: D6 \5 V- B  {1 e0 ?7 q
4 \, U) b; B8 n    if(key==HK_MODE)
% Y6 I; F* x, _# h; c  b    {
5 Q" l% s8 j$ N* h8 b, R8 N        if(!onoff)
! G" g1 Z% Z7 Y        {
, D$ k) g5 }8 H7 n  j            if(hid_keymap==hid_keymap_dvorak)
5 O: V. j' k7 `            {
                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
            }
( u# P# C% v$ D' e$ h: h            else
4 Y, C5 w5 u( k            {
+ S8 Y& d; v. n                hid_keymap=hid_keymap_dvorak;
+ B9 l1 @9 ~- t                GPIOB->BRR = (1<<2);
. U4 K" W! x4 V' k  G* V            }
2 Z) J/ \+ y0 U# I" z* Q        }
        return;
    }
4 x. C$ ]$ z6 \9 j' {7 ^

    if(key>=0x80)   // Alt, Ctrl, Shift
    {
; I5 _) |, D1 K+ M        uint8_t bitset = 1<<(key&7);
! J' D) b/ I# A4 K7 P6 X+ z        if(onoff)   // non-zero is key up
            report[0] &= (~bitset);
        else
/ |2 c* i+ W$ [& x1 I5 j            report[0] |= bitset;
8 {/ {6 e* ]5 E4 Q* {1 d7 ?: L    }
- a( e; }" _% @+ D: p" O8 V7 ?    else
+ u0 j4 T- M4 o) J( h4 {* Z5 n2 x    {
! q- }  G9 p: t+ n        if(onoff)   // non-zero is key up
/ _* k8 }# S1 ~7 m        {
" R" u! i+ ?5 P( o9 s" L- L0 l            for(i=2;i<8;i++)
8 ^  g) I1 v3 g8 |6 X3 `% Z            {
7 x$ {! M& n; v% E) l                if(report==key)
                {
                    report=0;
2 G. C' z. W; y4 b) o                    break;
1 ^! `% A: v" E% n: f* u" V7 b                }
            }
: e, V  h" T  b/ ?. C        }
        else
        {
, i& M9 L1 o7 ]2 q& O' l. H            for(i=2;i<8;i++)
            {
                if(report==key)
                    break;
0 e4 i# P8 `  z1 a. [* f5 w2 k                if(report==0)
2 p3 I) f* X: K                {
                    report=key;
                    break;
$ a. ?+ i& L- O/ w" M                }
            }
        }
    }
    for(i=0;i<4;i++)
        USB_PMA[192+i]=hid_report;
    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
( A' a1 _0 L- Y/ [/ k% s- O3 Q# ~3 @    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
/ k1 x1 M  x; y$ v  H        ep1_wait=1;
8 ^' Z( a) w1 H- N+ m8 [$ t    }
1 {$ K5 w% d8 O( v; Y}

. D6 M  N$ W8 j2 j% ?/ O# l- }/ N
完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
) Y. ?6 d& X( Y  X, ]- l keyboard.zip (8.7 KB, 下载次数: 6011)

2016-9-21 21:01 上传

点击文件名下载附件

* |+ A6 ]( b+ E0 x' e1 K; x

- _$ N% Z+ v9 v) n/ E3 C

miaozhuang

在电子论坛上看到的，这对于改造键盘的小伙伴来说，提供了很大的帮助，步骤很详细，拆解换主控，设计pcb板，编写固件，看的是很过瘾。

网络孤客

刚开始我以为要把打字机改造成电脑键盘
$ Z* J5 e6 Y- M; W1 x0 e不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
刚开始我以为要把打字机改造成电脑键盘
不过楼主也很厉害！

哈哈  是有点像奥

Mr.Prince

很厉害
6 T$ y: z3 f" h3 c, P: r/ Z

thermoer

这个看着真硬核