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

miaozhuang

$ E: |3 Q8 C% I3 k# y9 L
) u: A! w5 }( g- |http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

在看这个帖子的诸位一定都在用计算机键盘吧。键盘上的数字键是1到9从左至右排列，或者是右小键盘区那样三个一排有序排列，反正规律很明显。但是字母键却不是A,B,C...到Z这么按字母序有规律地排下来的。我刚接触电脑(其实还是学习机)的时候，没在意这个问题，觉得是要盲打嘛，反正对两手的手指头来说，按字母序排列并没有什么好处。于是用多了这些排列也就记住了，从来不管它为什么要这样。其实，PC的键盘键位排布上是延用了打字机的键盘，这是设备演变过程中很自然的一个延续。打字机的历史就要早很多了，我没有亲见过打字机长什么样，而且，咱们汉字是铅字打上去的，和英文打字机方式完全不同。
) L, W7 `* k" C; Z

上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。

为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：

1 r( a% {' D+ G: `: n5 v其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
Dvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：

# o% D4 D1 m" G0 l" S9 s( U2 rDvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。
0 x! E5 e2 D( [8 l/ A) d
5 \6 o  W! j& z/ P" p, i我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。

到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。

  x8 @% l9 c; T: }机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：

' ?1 [  n1 \: f$ b----------------------------------------------------  分割线 ----------------------------------------------------------

先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
* z# L6 q* l* v/ W! W
轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
5 ]: O7 q8 w% y% H
* g% }) \) N/ U# [3 K5 s4 `特写，80C49
+ S8 h/ V$ b1 I' f
$ y8 l6 Y2 u+ `5 v# |LED部分，使用了一片D触发器锁存指示灯状态.
6 c8 G% i8 V' J. b/ E
  i3 m; j3 P- f# ^) p8 v; x* W/ U暴力破坏，将80C49拆掉

拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

焊好元件后的板子，准备替换80C49
- _# y  X. F+ F1 P1 B4 W
用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。

我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
3 o  T* S& I. f' D5 g, s' V# H
主键区键帽就位
# r6 h* |8 }1 }
2 \7 T# z+ \* c编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
: j9 o" }  E4 `/ `0 P
7 r( b8 P) |$ W- r最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
" e4 A- p# e0 S8 W0 v

----------------------------------------------------- 分割线 --------------------------------------------------
- e9 m5 C* Z2 f# c



' B  q. b4 }. \# Y) K9 [

5 J! h* C5 Z0 A6 O: K1 H" b

# l, K) o/ W% k3 S" i$ K
- z  K9 Q; T; d9 W8 K2 M# P# A- }

5 l% I) n/ _# F+ y/ i2 F3 l

miaozhuang

DIY过程直播完了，下面说硬件的设计。
80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：
  V% L: e) _6 F) M3 p& g

6 Q- U7 P0 V9 _1 V: u其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)
: a, z& f+ r6 L0 K. U$ G" q
+ \3 M! n& `1 X7 x
4 m, F* B2 e7 X" ?5 N9 z扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。

这是我设计的电路图：
9 Q7 S% j7 o; [" Q: L
7 ]% j" n' v* B  O9 l; x# V- f
, T' z# ~8 U1 o+ ]' O) |PCB Layout:
6 x% {' G1 @# R; U9 a
% P2 c( z# |7 R' ]" E5 ?4 @
" C' o: l- v+ o, i! R不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.


$ P$ Y/ I  R9 Y

miaozhuang

软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。

总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：

9 O) p, a; ?# u5 \# f
4 ^- [, }, y2 a( P5 V% k$ K# }其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
% m+ F. b- |$ _8 B
! g7 B. I4 @! Z1 Z9 G" aUSB的中断ISR，bare metal哦
1 `% b/ h* N  b9 L2 ?
void USB_IRQHandler(void)
% R1 G3 X4 V. C{
/ C, ~3 L0 _- l$ g/ r: g6 g- c    if(USB->ISTR & USB_ISTR_CTR)
    {
! \6 r$ s' l. h" w& ~0 M5 S        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
, k6 r: M" s& V( |8 m" T  {        {
            switch(ep0_state)
            {
3 W3 y! j0 ~! F  C                case 0: ep0_state |= 0x80;
                        break;
' ?0 j  v& P7 w0 J                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
( |* M" e& J( ]9 [' [                            ep0_state=3;
8 I% M. f% j. K1 [0 o/ A                            return;
                        }
                        else
9 g- C/ X  B% O6 C, Y0 o6 X0 J                            ep0_state=0;
- W- R, _' E. D) R' D! p                        break;
                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
0 b8 U6 r1 ]! x7 V9 E. ^                            ep0_state |= 0x80;
                        else
                            ep0_state=0;
9 g) g0 E% Q% g  n+ {3 j                        break;
                case 3: ep0_state=0;
                        break;
2 ]# x' F* f5 r5 F- {2 j* C! n) x  ?                case 4: ep0_state=0;
+ b% e9 Q: O4 f% \" I                        break;
                default:ep0_state=0;
- a! Z. |: D* e, w. I2 B( D+ l, Y                        break;
            }
            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
, I$ m1 ?3 Z: S        }
        else    // EP_ID can be 1
        {
+ Y5 \: X4 D& W; ~. B. t3 Z            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
! ^! T1 A+ n3 Z            return;
: `, d/ k1 K. I4 `4 J2 E        }
  _- ~) x; _' H! L4 [    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
! S# L3 M7 |; O2 G" z' i& t    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
% Q( f; j7 L) u6 H9 [    if(USB->ISTR & USB_ISTR_ERR)
    {
) c, ^& G1 B& O& U; V        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_WKUP)
5 C3 C0 r' ]( s/ N4 F    {
0 M/ l6 }  {% X6 r5 v        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
. Q; [3 W, \( c) [2 l% U        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
, h  v4 m3 C  K7 Y, i8 [    }
$ `/ c8 k: ]+ H- a    if(USB->ISTR & USB_ISTR_SUSP)
    {
$ l# g- r$ n/ Q3 r' k        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
) f! d6 Y  s2 y; [        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
/ ]9 \9 B. t7 Y2 Y% b    }
    if(USB->ISTR & USB_ISTR_RESET)
- }! S" Y1 e9 p/ A0 J! ]0 Q    {
        USB->BTABLE = 0;    // buffer table at bottom of PMA
2 t$ G' x4 p+ v; s- z" i# d        USB_PMA[0]=128; //ADDR0_TX
        USB_PMA[1]=0;   //COUNT0_TX
' o* K6 s4 R$ W  D        USB_PMA[2]=256; //ADDR0_RX
0 V$ u# J( r/ R        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
" S' f' Y; S8 l/ J0 |        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
2 K" ], e, r' |  U: n        USB_PMA[4]=384; //ADDR1_TX
        USB_PMA[5]=0;   //COUNT1_TX
* R& Y8 R2 t# ~- f& g        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
        ep1_wait=0;
6 u, T: F) U( p. [" V        USB->DADDR = USB_DADDR_EF;      // enable function
" }& |) ^9 q9 z3 s7 C2 Q& z: d7 `& Y        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
1 E9 v! I6 u6 Z. p' ~    }
* {; a. h/ }2 u    if(USB->ISTR & USB_ISTR_SOF)
5 ~- J. {) O, j3 X    {
        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
4 a' {6 i5 Z: T; n    }
}

因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
9 V- H6 T0 h! r: q
主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。

0 ?9 o! m" D; Y2 Q# P/ [    while(1)
    {
# V- {+ ~# X3 T% C8 |6 `. H8 K        static char row=0;
        __WFI();
5 _% F) ~# [$ r* |        if(ep0_state & 0x80)    // request data processing
        {
            if(ep0_state==0x80) // SETUP phase
: M' M% g0 C, ]# Z& U$ z            {
! Y4 q$ ?3 ^8 h- G7 \5 {9 t                if(!setup_packet_service())
& \5 Q( S$ r! `: x6 \, n' B3 |7 Y1 Q1 Q. H                {
                    ep0_state=0;
                    // not supported
                }
2 B' N0 ?8 s0 v  v                // ep0_state should be set to 1 or 2, if processed
; I) [' p% h/ P/ P2 q6 ?            }
: M4 p1 ]' H) V( ?            else    // OUT phase
6 b4 _; n' Q" x" b( Y6 r) y5 W; s, H            {
/ x: D9 K  N# P" _+ r8 G) H5 g                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
3 \) _( y, k4 W1 N+ t% ~( `* \, l                ep0_state=4;
) B. c% E% `, s+ X- }                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
9 _3 u/ l4 C, j$ [            }
        }
, z# `+ @) O0 b" M: |- ^! X        else
7 T+ I; M0 z' W/ j        {
. O/ e# ^" r! r9 v            if(usb_address && ep0_state==0)
; b' [5 Y- I( q            {
                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
/ |' b) w' M+ Q            }
: R/ F1 R  s5 ]. c2 q# x        }
7 }$ u0 |( A6 m: u        if(row!=scan_row)   // new scan line
        {
- u7 o5 V" ]  G! R5 O# @            if(key_state[row]!=prev_key_state[row])
            {
/ L7 H9 l4 r: ]* I2 B                uint8_t test=0x80;
                uint8_t diff=key_state[row]^prev_key_state[row];
" |, p9 x- j/ I' o) @9 i- ?                for(i=0;i<8;i++)
; _) [. f. |$ d$ I& A: k                {
                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
4 {1 A5 k0 Y7 y: U                    test>>=1;
8 i3 v3 C/ A3 t( a: r9 D' @' M                }
            }
            row=scan_row;
        }
& J* i" @2 L" X: s4 x5 T: K    }


EP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_REPORT: break;
            case REQ_GET_IDLE:
8 V9 a6 n7 A9 U# m  S1 w; R                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
1 J* }2 F* L/ \, O3 B& ?                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
# e6 y0 t3 s8 {                ep0_state=1;
                return 1;
8 y% P- Y5 B. b; q' D                break;
( k$ b0 c! [/ C3 @, C$ q5 G% R) t            case REQ_SET_REPORT:
9 j' f" C: r5 s# r7 q5 N% |                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
                return 1;
& {- T9 `0 p" x  F) D                break;
            case REQ_SET_IDLE:
                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
$ f3 {9 i# K3 y0 n* j5 D. N                return 1;
, j( H3 e! W  x, P! }* I3 f2 L" q                break;
        }
6 p8 g. q+ A2 D* z        return 0;
! m1 z' A- S" c    }
, d! m" U6 H5 @3 t    else    // standard
# V$ x5 n3 }+ |- o) J    {
        switch(ep0_std_req->bRequest)
0 |- ^6 J  E* k* R) N, G        {
            case REQ_GET_DESCRIPTOR:
, d- o" ^1 c  Q- N                return descriptor_service();
                break;
            case REQ_SET_ADDRESS:
5 g) y/ |+ F( i) q6 ]1 T, d4 ~                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
. H$ r8 l6 U1 x, m3 |' Z                usb_address=ep0_std_req->wValue;
2 s+ `- G0 ]4 r: }                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
1 @# ^( l: e' G8 \+ p# Q& s                USB_PMA[1]=0;       // Zero length DATA0
                ep0_state=4;    // No Data phase
& t6 ^, r/ U3 C! n9 D$ Z                return 1;
2 s9 R) O! r2 t) B( t  t            case REQ_SET_CONFIGURATION:
( K/ ~# {9 C+ P. b8 `) [                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
2 `- r; p2 }: V' w2 h                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;   // Zero DATA
) Q- s( @- M% A$ r7 v                ep0_state=4;    // No DATA phase
                return 1;
/ q7 ?# b) Z, G            default: return 0;
        }
! R+ M  [$ f* B8 e+ ~& ?    }
) R- X3 m! l6 g5 U; t9 S; E}



. N3 x% H! M: {7 o) V

miaozhuang

各种描述符，是USB开发首先要处理的
7 X" f" m: q- M( ]7 Q) Z' Gchar descriptor_service(void)
# E" l, X( p0 d5 E/ ]% B( |& }{
) `  V! K' D, C    switch((ep0_std_req->wValue)>>8)
    {
        case DESC_TYPE_DEVICE:
+ _0 n, E9 D9 P  B6 Z            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
6 c% a1 f2 a0 |- b# v3 I            break;
        case DESC_TYPE_CONFIG:
. b$ I( p& @3 L' J/ ]7 r. a6 p            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
. e' ]  N/ i' B/ g            else
                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
% {6 t- x3 v6 {9 {            break;
# [; r( J' u3 z0 R/ }8 f        case DESC_TYPE_STRING:
+ V6 a% V. r* G7 T- e6 o0 p            switch(ep0_std_req->wValue &0xff)
            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
" X8 Q5 R/ ^% {+ e; ~# y                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
0 c$ |' \2 K; K$ F9 I                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
; s7 `& |- E. ]* Z, H' _4 h                default: return 0;
6 v8 Y4 }# J  |$ n            }
            break;
5 ~6 R/ R& R+ m  \" w        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
) p4 n# A" Y: M1 _9 e        default:
# }% _& h. }2 a( A. [1 g2 p            return 0;
    }
}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
{
    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);
7 q- e& q% T6 D* O
! x$ g5 a# |% W& L: _3 V
    TIM6->SR &= ~TIM_SR_UIF;
- W# p; U/ h- ^4 U- M7 ?    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
% l' u& u  [: ]2 I    switch(scan_row)
. r1 {! `- _1 x4 {1 A; k/ ]* C    {
; n2 E6 k) V8 b        case 13: // next row PB14
# Q3 p, q9 f* ?9 ~4 m6 N7 ]                GPIOC->MODER = GPIOC_DEFAULT;
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
        case  0: // next row PB15
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case  1: // next row PB3
( l& f" U3 E6 O+ |" P                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
5 ?2 j0 E9 u% n" [                break;
        case  2: // next row PB4
7 q1 m8 g9 y* V/ @                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
" t8 ?( O( q& L9 h% s$ _0 t' U                break;
        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
. u! m  D( B! S& B8 s" h                break;
        case  4: // next row PB6
6 d( f- Z: V; J6 M$ M                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
- v1 H- j4 ?# |' {1 C                break;
        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
' C8 k# [8 d9 N" M) \                break;
        case  6: // next row PB8
: z# k: |" J' l; I# ^9 x                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
! |: @- S0 _2 j# }  D0 K6 _5 s                break;
6 X4 t, s" K+ J' \' X% V        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
6 L& ?# o( }. L* o+ }( f* O+ ~* w        case  8: // next row PA8
. |3 R6 j6 `9 L- y7 y, b4 j. L2 S                GPIOB->MODER = GPIOB_DEFAULT;
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
        case  9: // next row PA9
) e& t+ p1 Y- g6 w3 S1 `                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
                break;
$ B+ i! {2 ]5 |' u; P        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
0 j6 h. Z3 Q' y        case 11: // next row PA15
) b1 n  K) [7 [* X- z7 R- J* Q; D5 Y                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
: d3 m$ G" K8 W4 i/ ]                break;
        case 12: // next row PC13
9 |' u1 Z$ R7 l                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
                break;
    }
    if(scan_row<13)
' C+ f8 U3 i$ \/ z7 |        scan_row++;
, G0 m! t- ]  p8 y7 t' s    else
        scan_row=0;
0 e+ U2 ^) t) K2 ~8 H9 u}
( v. h2 b* W, m' @% b
( d7 I2 x% Q6 ~8 E+ X1 }
7 ?5 H/ P: Q! o& C8 G

miaozhuang

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

1 F$ T0 n/ l' Q5 `) i
const char hid_keymap_qwerty[14][8]={
% l/ j# p6 w- n0 `6 p6 K9 [    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
6 X# X9 l& E. y. Y8 T, M    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
    {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},
$ J2 t2 k" [( X4 t- ?! X, K    {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},
: C$ p: v+ ^4 |8 V0 o) e    {HK_NONE, HK_RAlt, HK_LCtrl, HK_S, HK_T, HK_8, HK_Enter, HK_F1},
: ^* r( F( T* g6 h4 A' D& K$ |6 ~, }    {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},
    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
    {HK_Space, HK_N, HK_Z, HK_L, HK_RBr, HK_E, HK_6, HK_F8},
    {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}
5 e7 k" \1 p0 U/ D};


const char hid_keymap_dvorak[14][8]={
    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_P, HK_7, HK_F9, HK_Esc},
    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
5 v, P4 S% \) z: C6 N    {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},
' M; h" V2 K, A& J: w# G" `# ]) P    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
# v: b3 N* g* Z5 s5 H! W) _    {HK_LShift, HK_NONE, HK_Caps, HK_U, HK_G, HK_0, HK_1, HK_F3},
2 I% |) D% g, n    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_E, HK_F, HK_9, HK_BQuote, HK_F2},
, k3 O% [4 i8 B" ]; |    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
0 _8 E; [1 u3 s0 G1 F; T( O    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
2 q/ e$ X& X" J4 B: n  d! W0 l    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
    {HK_Space, HK_B, HK_Colon, HK_N, HK_Equal, HK_Period, HK_6, HK_F8},
    {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}
};


上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
# K( n# N+ r# i
7 o0 j$ M3 K# s+ K( [- qHID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
( [4 O  C5 Y% N" P5 |" y' [
9 H* P8 T, _4 g3 N; \+ L, }void update_key_matrix(char row, char col, char onoff)
7 |/ M+ e, M9 s3 z5 d2 s7 {{
    static uint16_t hid_report[4]={0,0,0,0};
    static char (*hid_keymap)[8]=hid_keymap_dvorak;

# L6 ~# O) o. k* ~" Q7 H% j" k
8 U" i- T5 d+ j    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
    char i;


    if(key==HK_MODE)
; o2 S1 _6 x* z1 c- o    {
# D/ L7 ]4 K0 t" |$ e- g        if(!onoff)
        {
            if(hid_keymap==hid_keymap_dvorak)
            {
8 J, H: G9 j' F. j4 u                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
- @% f0 G2 V0 k1 n: }            }
            else
: _  C8 M( I7 \' q4 o            {
                hid_keymap=hid_keymap_dvorak;
( k3 ^3 ]) h) ^" n! D9 [3 ~7 [                GPIOB->BRR = (1<<2);
8 c" e" E0 [/ p9 y$ L            }
* s3 H. ^, ~! q- g! d) B        }
4 j$ \3 J) K) F- D' S! q        return;
% K' D  B$ t( ?8 v* s! G    }


    if(key>=0x80)   // Alt, Ctrl, Shift
7 a2 V7 V' v9 t  `* A& q    {
: @' ?  V6 k7 ]3 {0 s2 M3 C        uint8_t bitset = 1<<(key&7);
        if(onoff)   // non-zero is key up
            report[0] &= (~bitset);
8 B* O, b" s, i& [        else
: Z0 g* q  Z0 w3 h9 i1 \  B9 \            report[0] |= bitset;
    }
. q) r% c7 y1 r1 J3 i% i    else
% v, z( h3 d. j    {
& Z. R4 @3 l( c" l+ T$ A9 T7 M# ]/ k        if(onoff)   // non-zero is key up
        {
            for(i=2;i<8;i++)
            {
' w% [7 g5 A' e  k- a                if(report==key)
                {
* L9 ?( S& ?4 V+ s3 u2 `( ]                    report=0;
                    break;
                }
4 i4 C$ E' h9 m5 w9 M8 f. d            }
        }
9 _( |; I) |) Z& E- E        else
        {
            for(i=2;i<8;i++)
. X* b9 ]9 w  q  p1 q5 a            {
( O: p% e  y9 O6 x" ~: p                if(report==key)
) v  b4 v0 {5 H' n2 _# m2 {$ u                    break;
                if(report==0)
2 L  J% q6 c& p6 r4 E1 b3 J                {
' Q6 j+ ~9 E3 C! r: R                    report=key;
                    break;
                }
            }
" a0 A7 p% ~; K0 q/ D6 C        }
    }
& Z2 V; w3 W# M5 C$ M# Y8 Q    for(i=0;i<4;i++)
* O, @4 U8 I" F+ \        USB_PMA[192+i]=hid_report;
  }# ?0 d- `, i6 Q, e( C    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
        ep1_wait=1;
. U2 u. b: I6 y. C* W' d    }
}
$ Q2 O, {* E' R+ @+ H0 I' d* L; M2 t

完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
0 G. D- Y* n/ t0 h/ c$ M  c keyboard.zip (8.7 KB, 下载次数: 6036)

2016-9-21 21:01 上传

点击文件名下载附件

: [' Y9 M8 j* Z; A

! F0 y8 N+ T' `6 N+ G

3 Y6 j: {* v" o* K' C# J9 W5 I

miaozhuang

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

网络孤客

刚开始我以为要把打字机改造成电脑键盘
不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
- H' Y0 }6 L) B. \刚开始我以为要把打字机改造成电脑键盘
7 q0 a& Z3 D  D' Z6 l; X不过楼主也很厉害！

哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核