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

miaozhuang

8 U) W3 G; p. P  q5 r- @9 L
http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

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

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

4 s/ P( d' g: M3 \8 c1 BDvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。

7 ~% @5 E) {; f) U9 M" u3 E; G: m我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。

5 c' E0 h" P* b/ r# e0 x$ X' H3 J到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。
3 D$ R" `0 B0 a7 t; H4 [4 t
1 b) k, y$ V# K: C+ Q机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：

  z" a1 t3 x) ~  n8 Y# a, u1 V----------------------------------------------------  分割线 ----------------------------------------------------------

& \. U) E2 w8 ~3 N% G% u先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。

7 c7 ?$ _! H+ s7 v5 h轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。

特写，80C49
2 q. x! X# C* y- `
LED部分，使用了一片D触发器锁存指示灯状态.

暴力破坏，将80C49拆掉
$ g5 A. ]4 y, }7 F$ T3 u  f
拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。
2 W* t5 P  y. w8 {' u6 K
  h- S+ E, S" b+ B- L焊好元件后的板子，准备替换80C49

8 W( F- f0 f# g1 x% {5 S用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。
) _6 @  z3 t- n
这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.
  X% k9 F0 M! u5 ]  W3 \, U0 u" M
开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。
2 E. f" j  T7 n6 \  \* B
8 q$ k  _% [* h  d1 i  V. H: C我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
, O. P3 G: D. e3 b  T3 d7 r
- u# ]& C6 s2 G  \1 C主键区键帽就位
- k$ t; R- C+ P+ H' P$ _( n
编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
) m9 f% s. C& U+ X
最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。


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

! I8 B+ Q( o7 O8 Y% r1 E




& _0 O: o: w  A
! p$ y" l& w' V. b8 r. L8 P. N



" h9 c5 O& w$ k$ |3 P

miaozhuang

DIY过程直播完了，下面说硬件的设计。
% _/ ~  h9 d: p# b( s/ x80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：
  P4 [3 m; Z/ T" U5 w# x2 u8 M2 v

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


$ q7 F% `# o4 c4 Z$ X+ \1 o0 e扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。

2 t$ V( {6 j7 t( J* E0 T3 i- p4 n* h这是我设计的电路图：
8 M8 v$ X* i: S6 p9 ^: U5 }

; H; `- I' t2 ?* x% q2 ]0 UPCB Layout:
# i7 F" A) y5 S" W  b+ Y! @
) J4 W5 H8 {# L( w$ n# w+ }- I
不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
. r/ g2 O8 o' X- v: o
* |8 {/ Q% q# J0 r* M9 h

miaozhuang

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

总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：
; F2 i3 l) b2 }/ U- O6 J
/ e! D7 K% w: F+ f$ q
/ e2 q9 X6 [3 q' q. {- [其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
1 d1 S% n9 L- y( B: `
. y1 l0 |: [4 X$ rUSB的中断ISR，bare metal哦

# C* D6 T- H$ X8 i; T7 g* fvoid USB_IRQHandler(void)
! r7 q( P2 j; `; z6 u{
4 v7 y0 b1 _$ Z0 ^' V8 n    if(USB->ISTR & USB_ISTR_CTR)
% d$ [' a+ j5 [4 n  Q3 p/ S  A    {
% v4 W6 y- I9 Q! q        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
% O- @! l" C" i3 E) K/ \' l        {
            switch(ep0_state)
            {
                case 0: ep0_state |= 0x80;
& m  ]- }0 n  T8 |& o                        break;
6 ?1 a: e5 \" B: |; F8 R8 s                case 1: if(USB->EP0R & USB_EP_CTR_TX)
0 d" `7 K# {6 `5 i% n. {5 k$ J' y; @5 W                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
) `# P8 h% D& A8 L- U; _: Y                            ep0_state=3;
" C; U7 ]# b7 v$ R9 Q, b. r                            return;
                        }
6 z" y# }0 ]/ A6 F1 J. u+ h' Y                        else
                            ep0_state=0;
% i4 [# E7 p: [* B9 L; C                        break;
                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
9 _/ ]& q/ d! o) v9 x                        else
                            ep0_state=0;
; o5 w3 Y- l/ B1 `* B3 u0 y                        break;
                case 3: ep0_state=0;
                        break;
9 j3 k9 e) t8 @+ U( [" M                case 4: ep0_state=0;
                        break;
                default:ep0_state=0;
$ p1 w0 z3 z5 p                        break;
5 X2 u2 x6 p# n. k7 Z# T            }
. J. i7 a& o& H, b# p% |            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
        }
9 V/ q5 c( L! I8 H! E        else    // EP_ID can be 1
& E& B0 b+ F0 J3 H9 Q        {
            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
            return;
6 E- u* h7 }, W4 Q+ _2 \  g        }
& t' {0 e' m- M    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
5 J0 M0 N; Q) l4 m        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
    if(USB->ISTR & USB_ISTR_ERR)
    {
. Z* t/ m" i0 F) [$ N        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
. e: l. g! o  h0 g0 G) K    }
* N( T3 N; ~" F: o0 U& z    if(USB->ISTR & USB_ISTR_WKUP)
  d0 m( h; o$ O( ]7 x8 ]- o    {
        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
4 h  G1 }! n% y/ X/ R% R% h( I    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
    }
0 ~! {9 F% N% z5 }    if(USB->ISTR & USB_ISTR_RESET)
    {
        USB->BTABLE = 0;    // buffer table at bottom of PMA
( |: x7 ~; M, y2 t        USB_PMA[0]=128; //ADDR0_TX
        USB_PMA[1]=0;   //COUNT0_TX
% T! T+ d" q# t        USB_PMA[2]=256; //ADDR0_RX
        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
4 |% S* {' C0 j9 E        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
        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
) v# }+ K) j2 `1 c5 y! I        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
3 d5 b- ?; A* m; u    }
- N+ O7 s( {/ g2 |    if(USB->ISTR & USB_ISTR_SOF)
: t8 `$ ~& |0 {' I" n: ^& \    {
/ F4 I3 I% |+ H, I; o        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
}
' ]# K2 C. K% f- z6 d4 b) a
因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
$ @4 p9 ^  m7 n* Q0 y0 e* T
; N6 {* o  \8 X. e2 T8 c$ B主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。

6 o, L. u( [( }) D    while(1)
0 R; Z+ x* K) f5 y$ [    {
% q9 t" N& ~* G' x        static char row=0;
        __WFI();
4 L# T3 a5 x# H# ~1 ]9 {        if(ep0_state & 0x80)    // request data processing
        {
            if(ep0_state==0x80) // SETUP phase
            {
/ v- j  R) h! {                if(!setup_packet_service())
                {
                    ep0_state=0;
7 L% `% r6 c3 ]5 i/ o4 u+ z0 q0 k                    // not supported
                }
                // ep0_state should be set to 1 or 2, if processed
            }
2 g8 N: i9 p- ^            else    // OUT phase
9 v) q& u! L! c: Y0 l6 Y) v            {
' B& M* l- V! C                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
1 j- v* \0 W# C' _( O0 ?                ep0_state=4;
. i+ T( i5 p. x+ l' |* l                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
$ B4 W2 S. M1 e% N        }
1 q. @! o6 f+ @' |) u  O/ }, G- U7 H) i        else
. z8 b2 t9 k- e3 A        {
; X" b, H# J/ r            if(usb_address && ep0_state==0)
            {
                USB->DADDR = USB_DADDR_EF|usb_address;
, A& f- h5 U$ ]                usb_address=0;
* E8 v8 g/ d/ R; `. z# D& j3 |            }
* I) X! z& K, x9 b& y1 {. m" `) m        }
4 z: K! L- m& |& z# ^' S1 K+ t& i        if(row!=scan_row)   // new scan line
        {
            if(key_state[row]!=prev_key_state[row])
            {
. d( I' s# E/ e+ R                uint8_t test=0x80;
8 i& O* u7 V5 m! x5 l, @( q. s& ]                uint8_t diff=key_state[row]^prev_key_state[row];
                for(i=0;i<8;i++)
. N0 h* K! Z& Z& ~8 d' z* N                {
                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
                }
            }
. U0 j2 `- z6 Q- ]1 H( t- M            row=scan_row;
5 ^3 x9 R3 y' S% X9 W8 ~# H) e        }
! `" s; b2 V# b  ^    }

% _% Q7 L! h; i* w. K( |# P8 S
$ d) k0 T* `3 H; r' @7 U1 ?- R& Z3 {5 REP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
% K/ A& ]1 n1 Y2 _    {
        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_REPORT: break;
' c' f8 c/ p2 L! I% I' P3 k6 X3 [            case REQ_GET_IDLE:
+ n% R; f+ c5 I2 g( F/ _& \9 `5 f                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
% t" Q( v; u' I1 G/ N                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
2 l7 L$ r/ E. q  m; i! _3 O) D3 t                ep0_state=1;
                return 1;
                break;
) O6 L, r0 H# D: s( v# f: h            case REQ_SET_REPORT:
! t2 ]2 z  u) O: n                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
                return 1;
                break;
            case REQ_SET_IDLE:
                USB_PMA[1]=0;   // Zero DATA
- f/ w# i0 e  Z4 u$ {- x                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
( b# z5 [, |; ~, u' j# N4 `$ s: s# Y                ep0_state=4;
+ |- e& |+ G6 F+ S6 V+ U  ^- ^+ \/ \                return 1;
                break;
        }
- V7 g& p7 Y; e' Z6 g6 ?' ]& Q7 A7 A# t: y        return 0;
, X2 H+ _# `( g! A7 D; r    }
    else    // standard
. o' ^; P! N7 k) o; Z9 t, [& x5 j* N    {
. R  ], [! n: r4 @        switch(ep0_std_req->bRequest)
        {
: E% A1 q( J) \  o+ j* Q! X            case REQ_GET_DESCRIPTOR:
) f  _; F8 O& k$ p/ i& e                return descriptor_service();
; W* b9 [+ @6 s$ T, Y3 S0 _( ~                break;
            case REQ_SET_ADDRESS:
) C/ S* P. n! h                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
- a. v# B1 l8 r                usb_address=ep0_std_req->wValue;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
) ?" n: c6 S* R- `                USB_PMA[1]=0;       // Zero length DATA0
7 K1 r7 z% t, X; w; i                ep0_state=4;    // No Data phase
                return 1;
; ]0 G! m& M) W9 _4 J  B" w            case REQ_SET_CONFIGURATION:
: h% p$ S6 y7 a" o2 c. y4 w. |                if(ep0_std_req->bmRequestType!=0x00)
7 `( w. L) h  I0 u" G2 R9 y. W                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
3 e2 O/ x6 R  d8 ]$ L. m                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;   // Zero DATA
5 J2 R- r  ^' _) J$ o3 D# X+ y                ep0_state=4;    // No DATA phase
' T, o' E  E% Q' }. E. X" y# Z, y                return 1;
+ K% O# u  y+ t/ T' o% j) [) J0 q) R            default: return 0;
% O) j" s6 [* F        }
6 ?4 m3 d  a$ I    }
) r0 K# \0 M' X( [9 r* g}


0 @# I' [8 X2 H
+ X) d! l' t8 n' Z/ K# d

miaozhuang

各种描述符，是USB开发首先要处理的
4 W  D, D* m( m0 P: ~char descriptor_service(void)
9 W3 B! b+ T1 ~, n& a* o1 B{
% z+ R- c: D! V    switch((ep0_std_req->wValue)>>8)
    {
. p4 M8 s1 p- ]        case DESC_TYPE_DEVICE:
- S/ e9 ^+ o) y; w            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
9 ?4 A& w* K3 g0 {; g8 F9 M            break;
" j* Z! e) k" v9 F; D7 B        case DESC_TYPE_CONFIG:
            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
* G: q- I- B/ r9 R8 p            else
                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
. T0 I) b+ T+ J* C            break;
! p# W8 N4 r& Z( w( R; p, ~, T' Z  f        case DESC_TYPE_STRING:
7 F( a, |, p- N# J            switch(ep0_std_req->wValue &0xff)
) [2 f/ d. s; X8 y            {
4 B9 o8 C, k! o4 m! j- L                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
% N, c  U$ u' K/ {) p# Y                default: return 0;
            }
5 ~: z$ Y. i+ {1 f+ _            break;
        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
, o* c  E; d* {+ N        default:
. O$ j7 _6 l* b            return 0;
# V5 }& N. j9 u    }
* C3 Y. @3 s: t' V}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
" l$ j5 R1 f) U9 P0 K& xvoid TIM6_DAC_IRQHandler(void)
{
4 Z1 Z  [& _! k3 @7 R: i    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);
4 L9 S" j. }* ^
5 M9 v% r6 T1 }' J+ F
    TIM6->SR &= ~TIM_SR_UIF;
1 S. }9 q  G& O# _; P    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
4 v( ]! X: O4 n2 @+ l; _    switch(scan_row)
    {
( `, K9 L+ A. c$ _- I        case 13: // next row PB14
- |3 L8 r6 i. a% n  k7 x                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;
) O, K- R* K( R) @. U        case  1: // next row PB3
7 `2 M* z1 r& z' _( \# J                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
( P; r7 K8 l/ ]! l                break;
  a" l2 G( R9 W5 v# v        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
4 D- e8 ?& o8 J1 K. c7 C                break;
        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
- V2 ?, r1 K& p$ E3 `9 }                break;
  q/ i4 ?* m) a6 `: t        case  4: // next row PB6
1 h/ M& r1 E% `) [8 p# m) m# a                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
                break;
        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
  m$ ~! p+ V5 e9 o! d) S. I7 b, H                break;
        case  6: // next row PB8
( I2 \1 z; H+ I: `9 U' [0 L3 s4 @                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
' _) L& e4 e( ]# |' g' V5 h7 \7 K                break;
3 D# r6 X2 u) i8 |* q        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
+ Z# R/ w  z: b0 y                break;
        case  8: // next row PA8
0 E0 r  a+ v2 Q! C( e2 z                GPIOB->MODER = GPIOB_DEFAULT;
, W: ^8 f- L' ?4 w6 I+ l: z                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
9 \* a8 ^" R: }2 ]6 S                break;
        case  9: // next row PA9
; D. ^; _% m0 k4 t4 c+ p/ k                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
                break;
3 D! e" O7 [  m9 W, B3 {        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
/ C) a, h5 o% n# E4 }) q7 Z$ L                break;
3 A8 t% h  s4 j        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case 12: // next row PC13
% B- h0 o' e5 E: a                GPIOA->MODER = GPIOA_DEFAULT;
( T. L- ]5 y+ z                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
& ^1 C9 A5 t1 m                break;
+ q+ b. b* w2 m% r% b    }
8 i4 E. f+ j2 K% j% \& N# S& {    if(scan_row<13)
        scan_row++;
    else
0 V% o9 U  r) R0 c5 e0 m# ]* k/ N( Y        scan_row=0;
1 `9 _: H; C9 N$ _# r}
+ Y' [5 f( V( m9 C

& \! k; O1 k% U1 ~

miaozhuang

, ?% @5 e- q7 o" \- \& _
  H7 E8 H4 P# k% D! ^8 k. h扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。

要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

/ H3 \. C' F$ u* P, F% _; R
. ~. ?$ q7 X& X1 xconst char hid_keymap_qwerty[14][8]={
, K4 I% M" L9 L4 Y& m' t    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
4 e3 W$ y* ?& ?    {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},
! q' \1 _9 o: X; ^    {HK_Comma, HK_C, HK_Quote, HK_H, HK_O, HK_Equal, HK_3, HK_F5},
    {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},
* G4 V' E5 W- q    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_D, HK_Y, HK_9, HK_BQuote, HK_F2},
    {HK_NONE, HK_RAlt, HK_LCtrl, HK_S, HK_T, HK_8, HK_Enter, HK_F1},
5 x+ k# B. T- ?  ^3 Y+ N    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
- x3 X( p2 h' H    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
4 V0 Y% C7 Z& j- G! _    {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},
- R5 S# ^! P9 Z3 c    {HK_Slash, HK_B, HK_Delete, HK_K, HK_LBr, HK_W, HK_5, HK_F7},
( X% H+ g3 V" b+ v1 ]    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};
% h. C/ F5 _9 C' l8 q% p
4 p0 G( H) f1 m* Q9 I. A. @
const char hid_keymap_dvorak[14][8]={
    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_P, HK_7, HK_F9, HK_Esc},
1 s6 _, o! F4 U& e$ K    {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},
2 R% m' `+ D+ u1 c& t, [# t% ]8 h    {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},
. p  o* k1 @" f5 @( v    {HK_LShift, HK_NONE, HK_Caps, HK_U, HK_G, HK_0, HK_1, HK_F3},
; {' ?5 e) ~" O- j  e) e( D6 q    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_E, HK_F, HK_9, HK_BQuote, HK_F2},
" H, _2 h1 D/ \2 ]    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
: E" O# q* U3 j% [$ M. s; }8 j) F    {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 C9 s( |2 X- q: P" _. x& [# {    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
) E6 Z$ ?# Z' F8 O7 W" |5 n# O    {HK_Space, HK_B, HK_Colon, HK_N, HK_Equal, HK_Period, HK_6, HK_F8},
) H8 {( E$ I) B$ Y/ Z    {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}
+ `& E4 J7 V2 E; ~& S};
+ l4 `( a0 A, P
+ H$ V+ |4 r* p9 q. h% B) ]: F5 p/ }
上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。

HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
8 I7 p; R* j# s
/ ?2 u" @9 e( y( x- J* F4 {void update_key_matrix(char row, char col, char onoff)
4 B9 Y# h0 u/ {( U{
7 p& n( d$ A& o, u( O8 y$ Z    static uint16_t hid_report[4]={0,0,0,0};
    static char (*hid_keymap)[8]=hid_keymap_dvorak;

7 Q9 I% W- ]) e2 ]: {2 ?
    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
    char i;

4 d: r5 C  R' v. k9 H$ v
    if(key==HK_MODE)
    {
        if(!onoff)
( v* l" s3 Z5 j' K: A% g1 ~* [! Z        {
5 Q' D/ S, p9 k0 O# u            if(hid_keymap==hid_keymap_dvorak)
. b0 |6 d1 L& I            {
9 W  j! y3 L$ k+ h$ E9 Q8 E6 \                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
5 o# i( E3 A2 Q( v            }
            else
& W4 E+ n4 _, }7 L; r! M+ c$ f; ^/ P+ x# W            {
2 \! Z" p. P% G% k                hid_keymap=hid_keymap_dvorak;
. S; v' ]4 s* e; K' B3 D- ?' a! \                GPIOB->BRR = (1<<2);
            }
* m# Z) g8 B+ U8 p8 \9 @* S5 J. c        }
        return;
    }
! `- u5 \, x* i3 a

  |  ^. k3 m) V    if(key>=0x80)   // Alt, Ctrl, Shift
* u1 Q# _  p2 f" R9 d    {
" {0 N: ]# p1 p) n( p        uint8_t bitset = 1<<(key&7);
- u+ {; z2 v3 J" p; S' B        if(onoff)   // non-zero is key up
            report[0] &= (~bitset);
; c5 j9 B( b. ^7 h0 J0 p        else
- v3 x4 H( X* a$ \            report[0] |= bitset;
    }
/ u8 A7 E$ d" @4 F' y5 B    else
7 ]$ G* E5 X* Z4 Y. f- [    {
        if(onoff)   // non-zero is key up
/ g% Q- h: o, o5 u2 \) y; s* o        {
            for(i=2;i<8;i++)
            {
                if(report==key)
                {
                    report=0;
0 H# k% _6 U; m1 o/ N                    break;
                }
            }
  B( K: ~4 B7 F        }
# z2 q, d8 `5 G5 v3 P        else
6 y  Z. C3 x( e, Y        {
2 M- i2 B# p- Z) C. e( X$ B1 p            for(i=2;i<8;i++)
, a5 Y2 w) e0 A9 O' t' }/ J            {
                if(report==key)
                    break;
                if(report==0)
6 H, V5 A1 n* [; y, Q5 a                {
                    report=key;
                    break;
                }
            }
+ H& O; S4 p4 Q2 F# }" O        }
" v/ n- c( c% {/ B    }
  f0 g4 |6 {  d( A5 `$ w! e    for(i=0;i<4;i++)
( U  z& Q7 ^/ c5 y1 y        USB_PMA[192+i]=hid_report;
) p% k! H- b) T- n, T6 L& z' d    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
    {
) V' Z( y2 T' |$ b        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
+ w: k2 `) n) A7 \) q. ^) z        ep1_wait=1;
    }
}

8 p. z* S. |. S2 A
7 M6 w" H# C2 a- _7 o; u完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
6 s" v- g3 K! b keyboard.zip (8.7 KB, 下载次数: 6330)

2016-9-21 21:01 上传

点击文件名下载附件

3 j/ d6 V! M  l% E3 A" b
  b* N* u. x9 G5 x# R

' `, N9 r/ {9 w# v
# B: K! U6 Q6 n, k& \9 A

miaozhuang

在电子论坛上看到的，这对于改造键盘的小伙伴来说，提供了很大的帮助，步骤很详细，拆解换主控，设计pcb板，编写固件，看的是很过瘾。
+ r7 e. U, Y& j% B. T) ?

网络孤客

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

miaozhuang

网络孤客 发表于 2016-9-22 13:48
' D" |- T; z' y3 C. o& d) x刚开始我以为要把打字机改造成电脑键盘
/ t7 h& V* S( x) j+ `不过楼主也很厉害！

: R7 \5 D# P3 g哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核