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

miaozhuang

1 H* e) n$ E3 c/ U! ?. c' [+ U
http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
) u# I2 \; L  Q0 P3 i这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

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

) j0 ^1 X/ A9 P+ x/ `' t/ u上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。
+ A9 C1 a$ d2 S! {) k2 D! M( s
. v5 B3 T* l* c- i为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：

其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
# P) w! T* ^$ [% N7 PDvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：
* j1 D8 h  K) o+ ]- q
Dvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。
& r, R8 X; `7 P
我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
" l, X) ~9 f* W$ g9 {  ?
4 L* T1 k" C, y5 ]# F  j: k. C到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。
/ e2 ]" G2 x4 z0 B( R
+ T% U" c# F& P, y0 r  r& c  t机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：

# N( P* j& b, p+ c; b5 J----------------------------------------------------  分割线 ----------------------------------------------------------

9 n. D$ P; p6 a( u先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。

+ r" |# P9 v  r9 e9 }" j轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
% @+ K6 O- M  S/ p
6 t6 A( G9 p) }8 M! {特写，80C49

) p/ i$ s0 m* \LED部分，使用了一片D触发器锁存指示灯状态.

暴力破坏，将80C49拆掉
0 Q" q( |) F2 z$ _: o
拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

焊好元件后的板子，准备替换80C49

# z: P! B$ p8 ~1 H& Z. y用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

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

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

9 e: b) e5 q9 i* s% C我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
* U3 U$ m) B1 @+ S
主键区键帽就位

编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
$ M6 U, o' k, ^6 q3 b
最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。


----------------------------------------------------- 分割线 --------------------------------------------------

9 D' a- e  q) ~: e3 K
* S1 Z$ n' J. [3 P  ^8 a1 B
/ g* T1 J! O! g$ \
5 [- p3 a( A, [; C  y2 P8 ]/ [


1 n# `2 p1 \% G9 L, g* E' m
' Z( _% j% n- P# b* ?4 D! L! `. K6 ]


8 p  r3 @6 p) O7 Q, F+ r% I

miaozhuang

DIY过程直播完了，下面说硬件的设计。
/ f3 M3 }9 l+ a1 B80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：


其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)

. x" N  @# h9 w* F0 W% W5 N
& p% |0 f+ ^- H3 }3 [1 R6 Q扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。
( R% T6 Q" k. D/ f( Q1 z" S: ~" P
4 p5 O% B7 d; u: m! ]这是我设计的电路图：
) T* {, L' a0 V7 Z

. W+ h3 d6 M' D+ b2 F9 m9 FPCB Layout:


不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
( H* [1 \9 S! x( X8 S
) f! C( E3 F, o# B6 |
2 ^2 H2 Q9 g! q- D

miaozhuang

3 U9 i% W. y& F5 p( P) N软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
& G. t; t3 h# R0 y
1 ^, M# l& C* \" |+ R6 C总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：

$ N" A  ^1 O8 K# g0 o8 a
其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
8 W5 g6 ?9 \1 P$ s* s% N& Z
USB的中断ISR，bare metal哦
  I& ], G6 H$ k7 G
- `, g. O* D8 ~( Z- z) E6 ]void USB_IRQHandler(void)
{
3 r; a4 H' `! c    if(USB->ISTR & USB_ISTR_CTR)
& b" W: N' f# z' }# x! c5 }    {
: V7 E9 C6 F, ~2 S, b7 c. j        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
3 j! D+ ^5 j8 O9 M% p7 k        {
            switch(ep0_state)
            {
                case 0: ep0_state |= 0x80;
" k0 y, @& S) h4 z                        break;
/ h6 h. H6 w0 a6 {( O4 W5 E3 z                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
' A4 E3 Y5 w) z% l- L. W) T' ]: ?                            ep0_state=3;
: Y0 N' X! Y6 T' X- Z4 l                            return;
                        }
                        else
                            ep0_state=0;
7 j, e$ I, X! ~/ L3 b) }3 p  C- w                        break;
                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
+ ]1 P$ g& M& c  o' `5 |1 n: p                            ep0_state |= 0x80;
                        else
                            ep0_state=0;
# @) d: F  ]& Z0 N7 V# u& U                        break;
                case 3: ep0_state=0;
                        break;
                case 4: ep0_state=0;
3 ]+ x4 ~; `$ F$ h5 a' q& K3 Y                        break;
                default:ep0_state=0;
                        break;
! ?% u) G4 g+ x            }
            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
        }
0 f, g6 z" W, o/ L! ]$ }        else    // EP_ID can be 1
        {
8 Y8 o" _6 u6 A4 A            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
* N; d: y$ h/ l/ c            ep1_wait=0;
            return;
        }
& r: j# z2 v0 H! }    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
* d2 f3 c& c; c5 s  A' S# \    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
6 z  `5 }1 e5 V/ ?( o' E5 Q) C- {    }
1 n* |. v7 D8 h$ `, H& V- o    if(USB->ISTR & USB_ISTR_ERR)
    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_WKUP)
    {
        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
; W1 {/ }# {2 M% p, w& X9 ^$ b        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
+ a- I! y+ V1 i8 b9 i3 [; _- x    if(USB->ISTR & USB_ISTR_SUSP)
% h8 ~* m1 Q! F8 Z, o: e1 U& c    {
$ w- U, i$ x; s6 C        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
! C8 e0 \2 ?6 C( a' \+ y    }
    if(USB->ISTR & USB_ISTR_RESET)
. J! @- T' E' h) d8 f+ [    {
        USB->BTABLE = 0;    // buffer table at bottom of PMA
        USB_PMA[0]=128; //ADDR0_TX
) L( e% r% X# _7 T2 _2 u: h; y        USB_PMA[1]=0;   //COUNT0_TX
        USB_PMA[2]=256; //ADDR0_RX
* a( F# P0 Y+ b6 @+ i1 q! M: U        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
$ z. C9 G4 V. J6 t0 C/ Y& v6 Q0 N        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
        USB_PMA[4]=384; //ADDR1_TX
        USB_PMA[5]=0;   //COUNT1_TX
3 t. z* R! }0 J2 D! t, m        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SOF)
4 z  d( X/ K5 |    {
+ w% r6 ?( O: ]2 m+ R) n7 D4 j! F  Q        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
) D3 w& A, U& A) g}

因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。

! z4 I; ^8 G+ V9 {! F5 P6 e主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
6 G9 C* {2 b9 f' H# T
    while(1)
5 h+ J* \, @- e& j2 g- r: @    {
        static char row=0;
        __WFI();
        if(ep0_state & 0x80)    // request data processing
        {
6 O2 ]1 e7 F( |1 k9 u: ~9 h            if(ep0_state==0x80) // SETUP phase
4 y: l  Z( n5 ]# z% H( t* `8 W            {
9 R( g. A" A' I8 r2 S2 J( ]- w                if(!setup_packet_service())
' ]: \" k1 ]: R9 z" [# Y                {
                    ep0_state=0;
                    // not supported
- p& {! W1 A+ j" F                }
                // ep0_state should be set to 1 or 2, if processed
0 P& ?, K8 R& y- `            }
            else    // OUT phase
            {
! j, e3 i# G7 b6 g                // process data
5 N9 k# d3 f/ R( o3 J* `                show_LED(*(uint8_t *)(USB_PMA+128));
                ep0_state=4;
. O' f" Q: H4 z5 I' V                USB_PMA[1]=0;       // Zero length DATA0
8 i/ V8 p7 R, n5 V  n( g$ x/ |1 w                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
+ e8 N3 h/ X* t( B1 x3 i( o1 [            }
        }
4 v, ?  P7 A4 V0 N. m3 m9 Y5 h' Q        else
$ [1 w5 `) W8 ]$ G& [+ O        {
            if(usb_address && ep0_state==0)
            {
                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
            }
        }
        if(row!=scan_row)   // new scan line
        {
; E: I0 P: [$ l            if(key_state[row]!=prev_key_state[row])
            {
- d' y9 f, G+ s5 d- `                uint8_t test=0x80;
! s1 q! j0 R4 b7 T! L                uint8_t diff=key_state[row]^prev_key_state[row];
; p$ P& U5 d( d0 E' F0 Q                for(i=0;i<8;i++)
# v* {8 N0 Z: H+ q                {
% A2 M' q. B/ _) h" R: Y, F) [7 z                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
% Y% s% B+ O& ]1 ~                }
; N( X+ t* l% h9 Q  s            }
1 ^4 b' b, M, i            row=scan_row;
        }
    }

& M8 j- U6 q9 c4 x3 }
EP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
$ |# O2 _' E& P0 w. V4 w- y% P{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
9 _: G9 E) t: o' [2 _) V        switch(ep0_std_req->bRequest)
: R3 ?9 o6 y. J; n2 O" n' {. d        {
$ ]4 i( o1 h" R# A4 I6 C) }3 N            case REQ_GET_REPORT: break;
            case REQ_GET_IDLE:
                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
% v* v0 W2 o  X! b# t. W4 K                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
; M. q' \* j" B6 U                ep0_state=1;
! A. ~3 d6 t* N4 U. i                return 1;
                break;
            case REQ_SET_REPORT:
7 s8 a% P/ S7 U, p0 x+ F                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
0 [" r+ m( n5 t6 d0 H$ E                ep0_state=2;
                return 1;
                break;
            case REQ_SET_IDLE:
                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
                return 1;
                break;
        }
9 p% Q+ `! y4 N( R: X; e8 v( g        return 0;
, B% `3 j2 {1 c# ?8 Q    }
    else    // standard
8 O1 E3 y( f% I: c2 `- @( c8 L0 o    {
        switch(ep0_std_req->bRequest)
& k& _" J; f4 n7 P+ ]( }$ \* v+ A        {
            case REQ_GET_DESCRIPTOR:
                return descriptor_service();
2 e, Z' l2 j6 _                break;
            case REQ_SET_ADDRESS:
7 `3 f* e% z/ b! x5 l9 B                if(ep0_std_req->bmRequestType!=0x00)
9 l/ v# M& L0 \* C( Z                    return 0;
5 k2 P5 V$ C. \* t6 e                usb_address=ep0_std_req->wValue;
3 ]. g, d1 E% G3 c                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;       // Zero length DATA0
" S5 H! g- L% G% l0 `' ?                ep0_state=4;    // No Data phase
/ b: [7 X% b4 J/ C/ P                return 1;
. P- O. ^8 [5 W* Q5 X8 `# |) `- i* x) d            case REQ_SET_CONFIGURATION:
3 Q7 a) r/ r1 ^5 M5 e                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
4 d% H5 a+ f9 ~# J; a8 b' {                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
( {5 W0 u4 F$ r( M$ m# q                USB_PMA[1]=0;   // Zero DATA
                ep0_state=4;    // No DATA phase
- [4 o7 \! d: _: ^& Q2 F# j$ v' P8 Y                return 1;
            default: return 0;
7 ]* s9 Y* {) w3 M4 ~: W        }
    }
}
) J9 X- I0 t, J/ a* l

miaozhuang

各种描述符，是USB开发首先要处理的
9 u& Z3 h% X6 `  @# tchar descriptor_service(void)
{
& ?6 S7 d; A) L' G9 o& g, H    switch((ep0_std_req->wValue)>>8)
    {
        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
9 n. f  q4 j- R3 g9 v, ]* |            break;
- b* @# b  |3 Q& r# n        case DESC_TYPE_CONFIG:
            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
9 R& y  V* i  A  \) k. F* Q+ N            else
4 K& ~) y+ |6 d3 I  V+ g1 \9 J" X                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
+ a9 @( |1 y  F$ a# P: u  d            break;
        case DESC_TYPE_STRING:
6 I, {- J  ?/ c) P  x            switch(ep0_std_req->wValue &0xff)
            {
1 P9 z& D0 W  I4 n0 H& J' e( n3 i8 \                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
1 d7 @3 `* d9 v  j' l4 }  w8 W                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
, f7 x: n- T# j/ `' c' N% y) I                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
7 J1 T3 X! z: Y- N                default: return 0;
            }
            break;
$ z% P7 ~( l  f/ {" v        case REPORT_DESC_TYPE:
0 N% y; d! G$ ^2 B' q            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
7 {1 H, @# |" l5 t3 E: A9 M9 y$ C        default:
            return 0;
# Q4 z, W8 _. ^. P+ \: W9 f    }
- f& o# }$ ]# N}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
{
, J+ N0 U$ @4 s" s% X+ `7 y# Y    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);


: ?) ]  y3 ^% h. H  k5 l    TIM6->SR &= ~TIM_SR_UIF;
; \  [9 x- p. w, y. f+ k    prev_key_state[scan_row]=key_state[scan_row];
- N$ v4 l  Q$ s8 X    key_state[scan_row]= *PA_IDR;   // update key states
( V8 X( d' s6 n) P2 X3 o6 M4 v% }    switch(scan_row)
5 {* U& a3 i. {; k0 ^4 Z* D    {
        case 13: // next row PB14
' B4 J$ M6 Y' b                GPIOC->MODER = GPIOC_DEFAULT;
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
2 P) u$ [6 k* r- X" V: P* k                break;
. \- ?4 u' {6 U0 C( ^& P        case  0: // next row PB15
; B/ g/ l2 O7 O" Y4 m' X                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
6 u; e$ ]4 y$ w/ J                break;
" P. ~: Q, {* f1 v4 n5 W        case  1: // next row PB3
2 D6 h7 }7 E: m0 v$ D0 v                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
9 r( `# `+ m2 X5 V0 S1 ~1 G                break;
( Y1 ?1 C  v$ c9 Z0 b9 w        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
; n; W  p: Q% s' f0 s& E                break;
        case  3: // next row PB5
9 d/ w1 S1 ^, [+ W# f* C4 K$ Z                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
- z/ M- N7 X- v/ d0 ^                break;
        case  4: // next row PB6
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
# y& I1 x- u2 Y4 g3 _                break;
        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
" H. I, I4 b! A/ n, K                break;
  h6 ?5 R! X# a! y) e        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
                break;
% l" {- j5 B. r0 P/ h1 p        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
' h8 J% f# X5 j& {9 r        case  8: // next row PA8
                GPIOB->MODER = GPIOB_DEFAULT;
) \2 A  \, ~8 L$ v                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
8 j& r( _/ l, _. N                break;
        case  9: // next row PA9
4 L% A  p4 g! m- A, ]  R2 E/ ?                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
$ }0 T! ], W+ ]                break;
        case 10: // next row PA10
, I4 I" @9 ]# ?                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
  }$ V2 p% a' n% r7 W' ?7 x                break;
/ D1 D4 K; P' e. T% Z        case 12: // next row PC13
. f/ o" A$ S8 Y6 z# W                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
/ j7 `. p, D8 A! X                break;
* L, v! l5 a2 m- O" P; j* L/ i    }
    if(scan_row<13)
8 j, Q& `2 g+ O- ]1 A3 g5 X) Q        scan_row++;
3 B) ^% {- W2 b! ]! Z& d    else
, v1 J( R+ l) d        scan_row=0;
5 V: N% o8 x# m1 s( {1 S}
' |0 h2 S# a, W/ r6 w9 K
, B/ Q. _1 z& U1 }8 R5 I# h1 [- z, C

miaozhuang

! t7 A$ W3 W$ a* ?+ y扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。

1 @& v, G6 W$ [( S' W/ K) v0 Q" J要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

0 m+ W# C5 b$ R) L8 I" X6 a
const char hid_keymap_qwerty[14][8]={
    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
, D9 Y* g# D; F. ^0 L) W6 e    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
" ^% r: m- G1 i& q    {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},
; y! h, M4 v/ y    {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},
) P( M! K! ^7 @! X+ b6 o- ]! a( |    {HK_NONE, HK_RAlt, HK_LCtrl, HK_S, HK_T, HK_8, HK_Enter, HK_F1},
8 b$ _& p7 p& G$ L- q. |    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
' O# o7 A( }" Y9 O* @9 `  S    {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},
/ E! c5 c6 b; v+ e    {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},
$ {& L- t5 U0 S+ a# W& R    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
3 G( p+ `1 p$ S$ h4 [3 U" C};
0 x: V& a% p2 n% f# t3 Q* l
  v( [5 c/ h/ c& X( C* D$ K1 N  Q- }
% a5 g5 J. `6 ]2 ]! ]' gconst char hid_keymap_dvorak[14][8]={
9 E. E6 u( ], `8 a8 \3 E' w- x    {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},
    {HK_V, HK_K, HK_BSlash, HK_H, HK_L, HK_Quote, HK_4, HK_F6},
0 t  y/ |3 g1 d. i3 ^    {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},
) m2 A3 T% V( j) s% }) I    {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},
. i! d; z9 ^+ o' I( ?5 t& ?7 l    {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},
7 z& C' Y' |8 a/ L: z* l    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
, k3 o  _' T6 l, P    {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},
) b- |% D' X/ ~+ D    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};
$ X, c9 \% i* o) s1 u1 G- N

上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。

8 c3 M  b' b/ [" DHID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
- h: i9 f* u( b3 a. V
void update_key_matrix(char row, char col, char onoff)
{
1 Z( t! L2 L9 k5 a0 C, v    static uint16_t hid_report[4]={0,0,0,0};
7 A4 y* ?, H6 \$ a    static char (*hid_keymap)[8]=hid_keymap_dvorak;

& L; e7 `: ~7 g6 V. T5 L8 Y
0 m7 n4 n8 u' B7 r+ a& I+ r* E    unsigned char key=hid_keymap[row][col];
. {0 u2 Z( q  p7 H+ u    unsigned char *report =(unsigned char *)hid_report;
    char i;
: g9 D* g. f* g
0 x( Q8 t$ Q  B+ S* M. f" Y
) i$ v8 r  i. X* i" e. K    if(key==HK_MODE)
    {
# j# v) J* p0 D! T3 Z" p" ~        if(!onoff)
+ q. P5 q2 L1 K' z- A! [0 t7 ^/ d        {
# N# M; J, [) A0 L, m4 P$ Y; x: u9 J, A            if(hid_keymap==hid_keymap_dvorak)
            {
; t( W; z' U4 t/ ?/ @/ E                hid_keymap=hid_keymap_qwerty;
: V- u- H# y) [                GPIOB->BSRR = (1<<2);
; t$ t1 f7 V0 r! X            }
            else
$ V3 [4 \4 X8 n            {
7 w. J+ o: e# k0 J! b! @                hid_keymap=hid_keymap_dvorak;
                GPIOB->BRR = (1<<2);
* W$ ?8 m# z% u5 j. B" C            }
        }
        return;
    }
3 i9 L" x' l0 E, ]) C
, Z2 X$ K9 u3 @! o( Q/ S
    if(key>=0x80)   // Alt, Ctrl, Shift
    {
        uint8_t bitset = 1<<(key&7);
        if(onoff)   // non-zero is key up
            report[0] &= (~bitset);
* V/ B7 e% F3 c$ }        else
            report[0] |= bitset;
    }
    else
    {
        if(onoff)   // non-zero is key up
! |  u" R( i& ?1 l        {
+ z7 P8 L2 Z' ~7 `% k& e, x            for(i=2;i<8;i++)
7 y/ r# k. ?9 U            {
                if(report==key)
0 {& e2 Y/ B% a/ t( Z                {
                    report=0;
9 y( W8 v& r; c& ]; z                    break;
                }
            }
        }
- k/ v  Y" R* k9 T        else
        {
            for(i=2;i<8;i++)
            {
# i! I( V. ?4 l/ n                if(report==key)
0 H& Y2 T+ i% ~$ i3 O3 `7 ^0 m* P                    break;
# b, J0 q) o& }. }5 b                if(report==0)
                {
                    report=key;
                    break;
                }
            }
        }
    }
    for(i=0;i<4;i++)
& E5 M5 M3 p$ t4 y; l* ]        USB_PMA[192+i]=hid_report;
    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
        ep1_wait=1;
    }
1 j! |. t% Q! r' S& P}
3 F: B! C3 e# h* r, q( ?
- j3 R+ n  F/ e; A* G  c# U& t# M: G
7 _3 x( B2 i3 E# s完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6418)

2016-9-21 21:01 上传

点击文件名下载附件

' G; ^+ ?# @: I9 y# R2 A0 A

! W; M6 ~( e) V9 n

miaozhuang

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

网络孤客

刚开始我以为要把打字机改造成电脑键盘
, z6 c; `# L& t& I1 Z! T1 j不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
/ @" F' M6 x4 D刚开始我以为要把打字机改造成电脑键盘
+ P2 \4 F# y. _不过楼主也很厉害！

( T4 R: S  A: @2 |* c8 ]哈哈  是有点像奥

Mr.Prince

很厉害
; s9 _" g( }8 l. h( h# \  O# Y! ?

thermoer

这个看着真硬核