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

miaozhuang

: j( Y8 ?  K8 T' L. T( K
http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

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

* r& s4 X) k) i
3 O6 W7 t. G6 Q; s上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。
5 B4 Y7 G4 J( H/ @
为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：

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

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

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

+ |# j9 d1 W. l1 L到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。
, c. @- S, k7 I$ Y
机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：

% p* u! e2 C6 t. D----------------------------------------------------  分割线 ----------------------------------------------------------

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

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

特写，80C49
5 \. ~8 |+ |4 S, S. e& l  _1 d
* u8 p1 E  U# U' @6 w* qLED部分，使用了一片D触发器锁存指示灯状态.
& r* j6 a, O0 m. J
' _* _! A, j, w. h/ P9 w" P3 E, d3 q1 ^9 r暴力破坏，将80C49拆掉

/ S- m8 o2 @0 _0 j& e5 ]" F) \拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。
" P; k: d0 B: T8 x7 |/ F5 g
' |4 G; P, Z+ O/ L焊好元件后的板子，准备替换80C49

用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。
; J8 J4 A4 s$ c6 {5 F" W! Q: I
这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

2 j  N# R* h% p/ {: M3 _! A开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。
9 y& z$ @6 S+ I+ K
我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。

- M8 F/ M2 D# \( a9 k主键区键帽就位
% g4 `& e% Y% j6 U( e7 S  _5 q
; P8 }0 E0 Y/ f8 V/ R4 K编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。

; Q9 |' p. }& s' f: j' v0 M- f* e最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
4 `+ _; Q# T1 h$ k& `

5 `% \% o' u" ^; o, o6 l: H----------------------------------------------------- 分割线 --------------------------------------------------
; V" p$ l+ U$ y5 y, K5 [7 \
8 J! e' O5 E9 b1 L1 ^5 m) R
" N, t, `, Z, \, ]* S4 g5 q+ t1 ]% r
& j0 M! K$ E  B) b5 Z

5 M8 C4 Y, k9 v# y$ D. i
1 R  e; |6 h. Q6 [$ P. V! i1 }

9 I% `6 R" u& y3 i* }
! ^5 T0 q+ c6 \$ R' s! _
2 Y" e2 \9 k$ p/ g
7 w* |' P7 s# N2 P

miaozhuang

DIY过程直播完了，下面说硬件的设计。
" a) q: ?9 v# v! ]; [1 N80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：


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


9 H/ i8 t. x- ^; Q  R扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。
" B/ _" \4 a: g
, H0 x% [( O2 d2 D' O+ f这是我设计的电路图：


/ L3 t. m* Q7 g+ F; W/ L, K) \PCB Layout:


不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.

# Z1 w7 a# {2 I/ K! F

miaozhuang

( }/ m& V% ~+ _软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
5 n3 l( ]9 Y- a( g9 O1 S. Q
4 [4 p8 i8 Z1 B总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：
" ^. j; Q' h9 u2 w

8 f" h1 V4 h2 q& |/ T其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）

$ @& ^( t' B  I" K$ e$ _USB的中断ISR，bare metal哦

void USB_IRQHandler(void)
{
. @' m1 n* L: l% ^' v' p# q8 v7 t    if(USB->ISTR & USB_ISTR_CTR)
    {
2 u# E9 ]/ M' B. Q2 T7 C        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
        {
& U, H2 c2 @& ]$ q/ K/ x            switch(ep0_state)
: n* H1 {; W( y) ^0 ^            {
                case 0: ep0_state |= 0x80;
                        break;
: P& [5 A- b% }. C3 P                case 1: if(USB->EP0R & USB_EP_CTR_TX)
, h9 m& F: D5 v# Q+ R* q* b                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                            ep0_state=3;
                            return;
; b8 N* }4 |6 q8 N9 G                        }
                        else
( s, V7 }: ^% B- P, o+ c7 p8 O4 E                            ep0_state=0;
                        break;
4 e0 m9 c. O- A6 f  s* K% @  ^2 N                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
8 D1 O. e# x: O                        else
. R) M" f4 b* |) `) a                            ep0_state=0;
                        break;
                case 3: ep0_state=0;
                        break;
6 g( C% B: E, ~* P: T. P5 p+ V1 ?1 Q                case 4: ep0_state=0;
                        break;
, ~: P+ v+ M0 f% k$ a                default:ep0_state=0;
                        break;
: @. U: R7 L8 [5 m% h4 p            }
1 W* @8 t) p5 j: v            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
        }
        else    // EP_ID can be 1
) L* T  k0 j% c8 t5 O        {
  ]6 }+ w# i# M+ ^( U; |            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
6 }& h! B$ f$ F# }/ E            ep1_wait=0;
            return;
1 [0 D4 r5 o: G! l0 f8 S. C        }
    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
) I7 D  t, y0 ]  z; t, J* L    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
& d1 Q$ ^  j$ D6 R- n* u! c/ |    }
# ?; V; H( b4 Z6 K    if(USB->ISTR & USB_ISTR_ERR)
    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
+ G0 i5 S5 w( r7 X  |6 t    }
    if(USB->ISTR & USB_ISTR_WKUP)
$ \, D/ o+ ]/ d    {
5 N' J  \' w6 H. \7 y) Y9 H        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
' d# x9 |1 Q9 J6 b    }
    if(USB->ISTR & USB_ISTR_SUSP)
; M) |/ P5 H$ G" Z: P    {
  P) z' O$ x4 H! }7 O" E        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
; v( |) E: N. a) o+ ~$ B7 V        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
    }
& `5 f7 W% R$ D: `1 t9 o    if(USB->ISTR & USB_ISTR_RESET)
. m* k9 g* }! w, K# ~1 h6 c8 H0 _    {
        USB->BTABLE = 0;    // buffer table at bottom of PMA
% ]' ?) g4 J1 k  I5 i5 [        USB_PMA[0]=128; //ADDR0_TX
. Z  ~, @$ c: {        USB_PMA[1]=0;   //COUNT0_TX
        USB_PMA[2]=256; //ADDR0_RX
        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
        USB_PMA[5]=0;   //COUNT1_TX
        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
+ j+ d* p5 `- I% G        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
    }
9 R+ H$ h# z) y9 N7 K" v+ y    if(USB->ISTR & USB_ISTR_SOF)
6 _" y0 p* p# w7 L* ?    {
        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
}
7 G9 m+ A& B$ v, o+ M( f* s
因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。

/ c1 P8 Y' H3 `. r主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
. Q; t" T; G/ q6 U, q1 R
( S9 ?* t' L6 p$ W8 _    while(1)
    {
        static char row=0;
' J$ f5 \& b& I1 i3 O' [        __WFI();
' p9 f7 b6 E9 C1 W) Y" ~        if(ep0_state & 0x80)    // request data processing
1 ?: k7 [# v8 y        {
            if(ep0_state==0x80) // SETUP phase
* b  N1 a" e  Y2 s5 F+ ?# V            {
                if(!setup_packet_service())
1 o6 V5 u' V; I5 A2 w                {
' l" |( _4 R& Z3 a% k" b! S3 i                    ep0_state=0;
* J9 W8 v8 K' X( @- k) [                    // not supported
                }
5 `/ P# s1 E6 J3 I3 q) T/ ^                // ep0_state should be set to 1 or 2, if processed
            }
            else    // OUT phase
            {
                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
. T- B3 n8 g, \0 a5 N            }
        }
, g) z8 y7 N$ I$ O2 C        else
        {
            if(usb_address && ep0_state==0)
' ^! Y" s9 H5 h7 q            {
                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
6 ?% B( d, D) E7 z            }
) u: L6 C3 o: c3 o        }
: L6 T- {5 U1 |+ i" y! o. B0 v8 R        if(row!=scan_row)   // new scan line
        {
2 h3 ^1 \! W! z& B+ y2 [            if(key_state[row]!=prev_key_state[row])
            {
                uint8_t test=0x80;
* R3 g6 F$ B$ Q9 s4 `                uint8_t diff=key_state[row]^prev_key_state[row];
: Q1 K/ i: S' J7 W8 {9 }0 w! p                for(i=0;i<8;i++)
                {
" `( u4 z. l/ J  j! F                    if(diff & test)
- Q1 @- ?0 s0 R- p                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
                }
% m9 }5 [7 |. X" i1 O7 `            }
0 v7 j' a" R# T  L  d* V            row=scan_row;
        }
, Y* f1 b+ ?& e9 I    }

0 e. n3 w  U* F/ Z
EP0的控制传输，把用到的请求处理一下
( N3 D* [' J! ~9 t' t' S1 `char setup_packet_service(void)
{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
        switch(ep0_std_req->bRequest)
6 d# B! Z: T: m2 u; ~: ]        {
) G( s8 i6 ]1 B, ]            case REQ_GET_REPORT: break;
  P; ~* h( F3 D9 L6 Y% E            case REQ_GET_IDLE:
& Z4 H: J3 A  S4 I/ H5 ?2 [                USB_PMA[64]=0xfa;   // return 1 byte
& M2 z4 A' T3 k* }                USB_PMA[1]=1;
7 F6 e3 J6 U* c4 t& o/ S                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
/ ^* S" Z# F. ^/ D2 S7 C                ep0_state=1;
                return 1;
7 I0 y  Y- U/ R8 s( N! k. \/ @                break;
            case REQ_SET_REPORT:
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
# ^) }# A- F- t; P  k4 K* Z' c                ep0_state=2;
                return 1;
# t- D6 b/ n4 f2 e                break;
2 Y$ }. Y/ S4 C3 l( v( ^/ O( [9 }8 y            case REQ_SET_IDLE:
- e  G/ ?: `) Z$ z                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
8 _# I4 y) O; t' u' \* X                ep0_state=4;
                return 1;
                break;
, q/ a% E- i1 I2 Q& T/ |2 I        }
        return 0;
' |5 ]# |8 I  M; B3 W9 X7 H    }
$ x4 N0 _0 f* C* Z5 \5 s; A    else    // standard
    {
        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_DESCRIPTOR:
9 N4 i# L: R0 e% a                return descriptor_service();
                break;
- v6 g6 r) Q4 ?0 Q. u' ^7 P            case REQ_SET_ADDRESS:
3 T4 i* d  o: b  i( t/ {: U                if(ep0_std_req->bmRequestType!=0x00)
2 c+ N# Z; J% o$ n! {                    return 0;
                usb_address=ep0_std_req->wValue;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
( J7 i5 L) @" q- z: i) Q                USB_PMA[1]=0;       // Zero length DATA0
                ep0_state=4;    // No Data phase
                return 1;
            case REQ_SET_CONFIGURATION:
/ u9 {. u8 X, J- Z! s$ L                if(ep0_std_req->bmRequestType!=0x00)
9 a& x* F3 d  n3 M5 l) k# T                    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
" a% h2 [+ Z3 g) W1 u% j4 z( G8 `                return 1;
            default: return 0;
3 o& J! D  r6 y" D9 V  F' S        }
    }
}

' ]4 `% E/ @$ R5 i0 m
5 V( J, c- J2 d( g' `) F

miaozhuang

各种描述符，是USB开发首先要处理的
char descriptor_service(void)
, ?2 U# J& H4 h5 o2 x& v4 U{
% G/ I3 G' ?0 F8 H& T* x    switch((ep0_std_req->wValue)>>8)
    {
        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
( R% B2 W5 h3 D4 r% T6 d            break;
9 y6 i/ o+ Q( a        case DESC_TYPE_CONFIG:
            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
  M9 w" Y3 n$ s0 \                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
7 \7 ?6 ]' v; w" B) x5 T            else
                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
            break;
3 V2 t4 V0 S8 a; l! @: N        case DESC_TYPE_STRING:
" g4 G7 S( T" Z            switch(ep0_std_req->wValue &0xff)
            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
8 {9 B+ `7 T: y, a- q: ]( L                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
                default: return 0;
; M# n- E) |& c6 H" N# i( v8 {% L+ M            }
            break;
6 Z& Z" r4 Y! H: i$ q- m3 ]        case REPORT_DESC_TYPE:
, b' ^  o4 _5 Z( d3 W  c7 ?1 Y9 K            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
            return 0;
    }
}
. N2 E- i* _1 D9 F5 n下面说下我对键盘的处理。因为有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);

% M" ]9 [! Q; e5 X+ t7 n
3 B1 B$ O6 u4 x* n/ H7 {; R: q    TIM6->SR &= ~TIM_SR_UIF;
    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
    switch(scan_row)
    {
' M  n: ~& k% e8 K; r+ E) k        case 13: // next row PB14
4 a/ P& R  f3 f' U# ~/ k                GPIOC->MODER = GPIOC_DEFAULT;
3 }6 m0 C1 x& E# L                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
        case  0: // next row PB15
, Q7 C! [4 v- T! l/ L: b6 G/ L                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
3 Y2 g5 |/ W; u: H: M                break;
5 q9 d9 v7 t& M4 Q1 X3 n0 B- _        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
                break;
' V" u! E/ u, Y- z# P2 c3 V% C3 n        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
3 F9 d, r, M- Y9 b                break;
        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
                break;
        case  4: // next row PB6
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
! k( R; z/ x" M% o; N3 |                break;
# t& V" ^. y+ F0 [3 w        case  5: // next row PB7
& x( c$ J$ _: P8 e" ^+ E* ?: K+ q1 s( \                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
0 t9 \% y7 A2 J" O                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
7 I3 v1 x) `- J2 G* ]: K/ q6 l6 m                break;
5 ]3 j% z. H: {0 o) z8 q, U8 z        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
+ ]  A1 Z' U$ c) M. p+ o        case  8: // next row PA8
# N/ c6 W2 I3 m. x- {4 n                GPIOB->MODER = GPIOB_DEFAULT;
9 E& `: w# }* e0 Y4 i                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
6 W6 l0 y! e' r3 V: I( A/ x        case  9: // next row PA9
# t( }& ]  N) u$ R& F  q7 z                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
                break;
        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
7 }- p4 X; k/ w7 \( N# `                break;
( u+ z8 R! S# M- k% Y        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case 12: // next row PC13
                GPIOA->MODER = GPIOA_DEFAULT;
1 ]; Y( t1 U6 l5 ^5 ^5 Z                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
, x/ l; b0 B0 j' G! f' M# V, r                break;
    }
1 h. a5 D6 m+ F* l2 ~: L    if(scan_row<13)
        scan_row++;
3 Z0 m% ~+ P  T    else
        scan_row=0;
" e' S  \* L) g4 B, i- j4 A- F}
0 |7 Q: v8 X2 S. x" I! n6 R
7 M) V) l3 a* L/ O2 j7 N/ K
* F5 x6 r9 j  ^; `# l2 A

miaozhuang

( o; _$ T+ ^/ w9 o: L% c
& i* t7 E0 T" v. }扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。

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

4 w4 ], E% `6 `" K
const char hid_keymap_qwerty[14][8]={
3 I4 H1 D. [! B* M1 J+ A    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
3 u; C( @) s% o    {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},
    {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},
8 r* Q: G: w. N% {2 E* V    {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},
    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
2 j. o# v. T+ y    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
& D" Z9 v) K; n- M& h    {HK_Space, HK_N, HK_Z, HK_L, HK_RBr, HK_E, HK_6, HK_F8},
7 u7 a* n! A. I' p- Z    {HK_Slash, HK_B, HK_Delete, HK_K, HK_LBr, HK_W, HK_5, HK_F7},
* f6 `# Q+ E+ F* N8 Q! Q) }    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};
; f0 {% {" y3 @' i6 X0 u

const char hid_keymap_dvorak[14][8]={
, q2 X) m+ H6 ]+ U& l    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_P, HK_7, HK_F9, HK_Esc},
3 [# h" ?/ d+ Q( 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},
7 j7 j# Z  x* x- L1 i4 @    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
% T) o% `. v2 ], I) K* R    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
4 ]9 M9 c* b0 k7 D    {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},
# n4 ~! n8 X* X7 @* @- d6 D0 @- B    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
" S6 A* r8 ]& z8 @! ]1 e& e! r    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
; Q9 j2 Q3 w) }. L) G6 e! r    {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},
) y' e4 A/ z0 T+ X    {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}
# P6 [# c3 b4 `" J};
1 `& Z+ d$ d" `# A/ K# @( \4 r. H0 n
( r9 s5 Z* c, N5 C" Y
) W8 Z& @; p/ J' `) \上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。

HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：

- [9 Q/ o! y. Tvoid update_key_matrix(char row, char col, char onoff)
{
3 `5 N& V! K- t' V0 @3 q7 r    static uint16_t hid_report[4]={0,0,0,0};
    static char (*hid_keymap)[8]=hid_keymap_dvorak;
$ ]: K$ M; b" \% O  R$ k, L" C: B

  O/ V( v% T( B* I& N. @    unsigned char key=hid_keymap[row][col];
1 r) Y% j& V) {, u( \6 U# a: N' w    unsigned char *report =(unsigned char *)hid_report;
    char i;
2 l" H5 u; s/ @* I! r9 J
: p# N$ t4 T% F7 j+ s& s
% ?3 x$ u' Q3 A: Y' F3 p( t' L    if(key==HK_MODE)
+ p% b% z% U. C8 o+ c: n    {
) f2 ?- {; \3 v3 @        if(!onoff)
        {
            if(hid_keymap==hid_keymap_dvorak)
1 G+ |- O# \8 L. Y* q% z            {
                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
9 W6 y+ H' J( j            }
            else
            {
                hid_keymap=hid_keymap_dvorak;
. C9 D+ N8 S4 y# J! _                GPIOB->BRR = (1<<2);
! _4 W' F% D0 _& ]! \! O2 L4 N, B            }
( Y5 U5 ?( J1 Y" H/ _" g# J        }
5 A% y$ [: N' n8 H% K        return;
# {) h8 |; s! w9 M    }
; L- Z: o& }: s
7 ]* F8 h' ]8 p) a' N0 T! w/ T
    if(key>=0x80)   // Alt, Ctrl, Shift
9 a* n$ ~% y( s  {    {
        uint8_t bitset = 1<<(key&7);
* W) a. e. J* [% O        if(onoff)   // non-zero is key up
  E4 Z* m+ X9 Z+ T9 W& o7 K            report[0] &= (~bitset);
        else
! ^) J7 m8 e$ a7 Z! S$ l            report[0] |= bitset;
7 G" G# K" n6 }    }
3 d( q# M9 n7 Q( V( W. Y5 I7 `& i    else
, z! k- W& H; n5 @6 V2 @8 I- @+ n    {
" W) C: c$ D5 f) K+ U% M        if(onoff)   // non-zero is key up
        {
2 _1 B* @- e, q1 P; U8 w$ D            for(i=2;i<8;i++)
7 X# p3 e. s& l% \            {
0 Y$ H5 q  Q. F                if(report==key)
                {
" U1 p& n8 `+ B6 Z                    report=0;
                    break;
                }
: F4 o  D; d& J# P" f# x            }
        }
        else
! }8 j1 G9 `. K7 s$ l        {
+ H- D( M( Z6 i$ Z: ?  \            for(i=2;i<8;i++)
            {
                if(report==key)
                    break;
: c9 _3 O* A& @, B$ N                if(report==0)
                {
8 d, s  z" t) x9 ?$ @- a1 R9 h                    report=key;
                    break;
                }
: V) S' z3 y# f: K3 d4 ~" C3 o            }
        }
3 w" v. R9 w; g6 O& ]' t    }
    for(i=0;i<4;i++)
- ^) h4 n2 l# x/ q5 {8 G7 i: x! B3 P        USB_PMA[192+i]=hid_report;
    USB_PMA[5]=8;   //COUNT1_TX
* J6 b( Y) B& r    if(ep1_wait==0)
    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
; ]$ w( r# n& `$ C4 s/ W        ep1_wait=1;
    }
}

4 d. O- _" {* g" J2 t4 k. K
' Y1 `" x# u9 [8 d3 D9 n完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6043)

2016-9-21 21:01 上传

点击文件名下载附件

7 r+ p# `! D5 `7 F7 m. R! S
7 G$ u! x8 r. x+ Y6 J* [# [  M
+ a$ r( }$ I* o
( J+ C! n1 W) b- C8 ^+ s$ _

miaozhuang

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

网络孤客

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

miaozhuang

网络孤客 发表于 2016-9-22 13:48
1 e' {" p# y3 h: _/ B刚开始我以为要把打字机改造成电脑键盘
不过楼主也很厉害！

哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核