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

miaozhuang

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

上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。
; b* o6 f# \. P7 b2 e! @
% O; @/ J6 y" M( y为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：
  y: K* q2 i1 H$ Q" ]
5 @9 H' t! P" [( e其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
4 U0 M) U0 r& i/ ~$ v9 DDvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：
: {4 V1 O3 P5 H+ }! w/ I6 o. P
Dvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。

我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
& s3 [; I* o1 c' K$ @
到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。
) [% D& E. u; f+ R( Y! x1 J9 d  o. _
机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：

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

先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
3 B1 P7 p) {  q) K3 G# T1 o6 `! g/ ]6 N
$ m, v% ?5 S$ l6 s  o, v轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
# U8 o& ]/ }) v) E9 u$ m
特写，80C49

$ \( k7 P! g& [: p" {6 G& o: N5 }LED部分，使用了一片D触发器锁存指示灯状态.

( C# o  @0 m. r( q% H7 h3 F3 |2 W暴力破坏，将80C49拆掉
; F3 y/ o: t, b% g
拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。
' r6 n" B2 K) d. A- @
4 i& f  B6 p' Q" F+ q+ w# ]  Z+ V焊好元件后的板子，准备替换80C49

" m6 ?3 N8 D: S7 Q' v- p用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

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

! k4 t/ n( z4 g开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。
0 J, I9 ?. W4 s* a. {
我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。

$ q+ z  s0 N2 V2 ]& ^7 a# U. a主键区键帽就位

编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。

2 D# t6 c% A. \, t" S最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。

5 r! m, o1 N: N/ d
4 v" _7 b( b- b9 T----------------------------------------------------- 分割线 --------------------------------------------------

" D4 |1 x% G- E; R2 i4 P& D
! Q- K* q* z- U/ v1 \3 X6 \# `

) h9 j* M9 s# w; r# P) T& `


9 y+ X1 c6 a/ V. {+ t" p  P4 V% H

6 ~0 Q, [& L  ~3 P5 f

miaozhuang

DIY过程直播完了，下面说硬件的设计。
# ~8 [% y8 `% @' L80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：
7 y3 c/ H( x: K  u* D6 G# B

  d( X( g$ B' Q4 c6 l8 E! J其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)
# q6 d$ t* `+ g5 I5 g
2 r$ m& }7 n$ t$ i6 N
扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。

1 O5 m5 m% {# a9 h这是我设计的电路图：
( C; B4 t: Y7 x6 n5 z" j
6 x% v; g. F: Y( _. R& b" \
. g3 n1 }0 G0 e1 @& J: HPCB Layout:

' R( o" |/ E9 C* Y5 S' G
4 u3 U# Q/ o+ D不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
4 j4 F. q- t% E6 ^: z
1 H" X1 m: Q7 [3 I

miaozhuang

7 o: o1 ?$ \9 v8 |. S; |  R软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。

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


, j0 z( O' M2 Q9 b4 _; ]其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）

USB的中断ISR，bare metal哦

void USB_IRQHandler(void)
{
    if(USB->ISTR & USB_ISTR_CTR)
  S5 b* F% d: W$ ]7 m, w    {
        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
        {
) i( ^% P+ R$ T8 x            switch(ep0_state)
8 h# \! n& o* u& @( W            {
                case 0: ep0_state |= 0x80;
. d5 \  Q/ l% B( E' ?                        break;
                case 1: if(USB->EP0R & USB_EP_CTR_TX)
; l+ w! ^5 A6 T9 i# T6 e                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                            ep0_state=3;
: t6 ?5 k  L& ^                            return;
- o; l. s* H& q$ k5 p0 w                        }
                        else
7 z' I' l" M7 ?3 u% H; P" Y                            ep0_state=0;
% l1 j, X9 R* i  X0 a0 D- u                        break;
0 f& P' h% v* U& W& o                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
                        else
+ O1 y9 |: T9 _3 ?2 S# @                            ep0_state=0;
) @# `$ H9 y4 v- l) E6 l% r                        break;
) k- r7 E. Z* z+ S5 |                case 3: ep0_state=0;
7 |9 h' l3 d. Z3 y                        break;
  w/ g$ s" [/ n: v; N7 A; b' Z                case 4: ep0_state=0;
' f% g# h4 e4 n) h                        break;
9 Q% y8 n& J# {7 b0 s                default:ep0_state=0;
$ H. b/ M) I0 w5 o                        break;
            }
            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
4 f( @: d6 h& g            return;
        }
3 `! P$ k! i) J7 T8 _; ~) z" w        else    // EP_ID can be 1
. ]* b) T3 J; J/ u9 e        {
4 n% H+ E' c9 e" b6 A" B  G2 d            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
2 Q- c( ~4 r5 t' w4 y, ?            return;
/ p( P  a" H, h0 ?        }
& @4 W+ M: o+ q5 q1 u    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
4 m  n$ x6 N7 @) `; c5 \    }
    if(USB->ISTR & USB_ISTR_ERR)
( U9 I/ H' S9 o; g2 J    {
! ^- ~& c* ~8 x4 c; R        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
    }
% j/ ?% ]( m0 h; G* Z% E    if(USB->ISTR & USB_ISTR_WKUP)
' s: \2 v1 b2 t0 k" m# U7 \    {
6 E  q6 W7 Q9 g* Z0 L        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
+ O. h5 J& G7 N        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SUSP)
    {
* ?5 d1 g7 o: K        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
, {. `* j( Z- o8 ?        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_RESET)
    {
9 J# O8 {. G) S        USB->BTABLE = 0;    // buffer table at bottom of PMA
        USB_PMA[0]=128; //ADDR0_TX
        USB_PMA[1]=0;   //COUNT0_TX
        USB_PMA[2]=256; //ADDR0_RX
% C1 |% _. l, R& ?        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
        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
1 g, ]& ^7 P/ V$ b' _) \    }
- e/ N/ H( e# \  w+ X# B    if(USB->ISTR & USB_ISTR_SOF)
( H. T+ L& O! f    {
3 k2 ?' o# x$ F; b9 i2 O        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
- E! j$ w+ a, k' c7 n, N    }
}

) `9 @7 J* ~' X2 F$ y' q# L; x因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
. O9 `- ~& o; P; C
. e) P' ]0 L" r0 v$ `5 C+ B主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。

6 i9 d) u( Q3 q9 n    while(1)
2 N+ u  m. _+ {4 B0 [/ ]    {
        static char row=0;
        __WFI();
/ k# P; q' x" H* G8 J0 h, ]        if(ep0_state & 0x80)    // request data processing
& f, z* u2 o: [0 I9 r" Z3 U( @) `        {
$ k. @4 ]5 D0 U) r: [& Y            if(ep0_state==0x80) // SETUP phase
6 t0 D( F: o5 u8 ?3 X            {
9 n- x( v8 k! j5 ^                if(!setup_packet_service())
                {
                    ep0_state=0;
( X& L8 K/ x# n/ o, j9 }9 G+ u                    // not supported
                }
                // ep0_state should be set to 1 or 2, if processed
            }
            else    // OUT phase
5 W; h* {/ t8 z# e1 y- O! V/ E            {
                // process data
: x# y4 s3 J! x                show_LED(*(uint8_t *)(USB_PMA+128));
) o0 G2 z9 r6 w2 Q; K: c" m, d% N                ep0_state=4;
2 C% E) b$ O' _, k/ P                USB_PMA[1]=0;       // Zero length DATA0
; ?5 f  z- \- D+ N6 M, x                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
" M& u" N- U9 e7 e) D9 t  Y            }
  u9 V2 ?8 E- h  S  x: |        }
9 Q/ j8 s  N# H3 u$ q        else
& R, {5 j$ o/ L7 O7 I6 t        {
3 s+ o! |+ Y& y6 b2 H) h) Q            if(usb_address && ep0_state==0)
; B& H2 [, s/ Y5 v2 [) d6 X+ h            {
, K; @# L$ v1 [9 P                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
% z  s9 j) N3 E8 e7 \1 m            }
* c3 w. w* d( f/ K        }
7 t3 w" t$ A$ f/ m+ s- N        if(row!=scan_row)   // new scan line
        {
            if(key_state[row]!=prev_key_state[row])
8 D/ h6 n6 ^1 u  V. I% ?            {
                uint8_t test=0x80;
) P3 P4 u/ M2 m* ?; U& R' U4 G                uint8_t diff=key_state[row]^prev_key_state[row];
                for(i=0;i<8;i++)
& v$ x7 w9 [! O6 f9 ]( n  O                {
) _4 b0 m9 b# p5 Y  D5 K                    if(diff & test)
+ P+ B4 v9 K; r( A9 K& z$ K                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
                }
) d- W: [: g7 T: `) u* X6 D$ l            }
: B' j; a% q, j/ q: q! [4 a+ \            row=scan_row;
        }
) i9 G! O" V& L) Y+ ?* W    }

9 H( J' x! D5 F# \. N5 v# [
EP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
- ^! A5 U$ i$ f/ j4 r{
3 v- _7 {& x2 T$ @: u2 V    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
: k* w% Z/ v) |4 K        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_REPORT: break;
- n% w0 R! f3 d3 E1 H            case REQ_GET_IDLE:
8 w8 v; }$ ]/ h8 S" _4 ^) H                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
& ?5 F, m3 {  k6 p- v- W                ep0_state=1;
2 a0 S$ _" }( Z0 @                return 1;
                break;
% ~- N% J( }. x$ K2 L/ F            case REQ_SET_REPORT:
# b4 i+ c8 t6 \6 a                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
                return 1;
# a' m' k1 W9 q& _5 X, X                break;
. G6 \- {$ B2 ^9 {( H            case REQ_SET_IDLE:
1 }0 W1 i8 d% m' _/ I0 N                USB_PMA[1]=0;   // Zero DATA
. z( t8 i4 Z" y$ Z; a                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
- R8 O" g: U( S9 s& R                return 1;
                break;
        }
        return 0;
+ }" f( g0 B% G, e8 A$ z5 k    }
9 D6 S; G3 \& j3 d5 }# \    else    // standard
( o# D, w5 E* j/ X* m/ {; y" b    {
        switch(ep0_std_req->bRequest)
        {
" n8 t2 k! m' r% T/ H1 ?8 c            case REQ_GET_DESCRIPTOR:
                return descriptor_service();
                break;
            case REQ_SET_ADDRESS:
: a6 v  X& a6 v- t2 B( v! ?                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
' E2 @) O$ I3 f) b: u" ~                usb_address=ep0_std_req->wValue;
0 c+ B- g: V) K! j0 h5 e; _7 r* N" O; }                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;       // Zero length DATA0
                ep0_state=4;    // No Data phase
                return 1;
5 C+ }2 t0 P$ v( h/ i& _6 U/ G            case REQ_SET_CONFIGURATION:
. P+ @' R" V* L9 i) |3 ~                if(ep0_std_req->bmRequestType!=0x00)
2 H9 U& A4 U; x9 E% w% I; O7 C                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
0 x  }. r2 ]: Y, w5 t  y                USB_PMA[1]=0;   // Zero DATA
                ep0_state=4;    // No DATA phase
2 r, D" A, r& u, j+ }1 q# t                return 1;
( Q: f, R. |6 e) W9 a5 K# i            default: return 0;
- e. `6 T4 @; `5 Y: c        }
! X% }: b3 z1 [6 W5 R! p: g* K    }
}
& f' E: p9 K7 i( s: Y* n' q

miaozhuang

各种描述符，是USB开发首先要处理的
  D; x& H! y/ {char descriptor_service(void)
{
    switch((ep0_std_req->wValue)>>8)
' X! A; m% O. M- x5 p* m+ H    {
        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
            break;
        case DESC_TYPE_CONFIG:
            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
            else
7 n- e; D  z4 I0 o4 X4 P5 P5 D                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
            break;
% [; I' T, L6 x0 y3 a/ G! a9 V        case DESC_TYPE_STRING:
            switch(ep0_std_req->wValue &0xff)
            {
& Q+ }0 D/ \9 V" n# Y                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
. p/ p: m* T1 `# }* @                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
; t' v& Z8 g8 q3 W                default: return 0;
5 Q1 q% @% E: }$ Q            }
            break;
        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
$ |& p! u- S) K0 ]$ W; W6 ~0 W7 Y            return 0;
    }
}
- W+ V% z! M$ ]- I* E3 p: y& ]下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
{
2 c8 n( q  ^1 S& H2 a    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);
6 G8 ~0 V7 E' O
( i) ]6 V. [) Z) ?
5 G) e9 N& W. U    TIM6->SR &= ~TIM_SR_UIF;
    prev_key_state[scan_row]=key_state[scan_row];
- {+ g. v) M3 L  y7 ^    key_state[scan_row]= *PA_IDR;   // update key states
    switch(scan_row)
' k1 k; r7 v7 h    {
        case 13: // next row PB14
                GPIOC->MODER = GPIOC_DEFAULT;
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
        case  0: // next row PB15
$ \& \/ r5 T. W9 ^9 W1 S' H                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case  1: // next row PB3
4 r- {- q% }6 R- L& |                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
2 N/ `$ v- B8 i8 J5 z                break;
* J% B# F- ]! Q0 [+ z2 i4 ]- ~9 c        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
! _2 p' v  F% s4 c% l                break;
        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
/ G7 b# a5 w# ^4 ~                break;
' Q5 ^8 c" v5 e: o' t! r* Q        case  4: // next row PB6
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
                break;
        case  5: // next row PB7
* |4 K) [+ A3 d0 ]# b                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
                break;
  F6 R9 z/ S' k) T1 Y6 W        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
! O9 h" M  V& H        case  8: // next row PA8
1 o+ w+ ]9 \+ C6 i, _/ o                GPIOB->MODER = GPIOB_DEFAULT;
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
- A  ~8 l" _# \5 `                break;
        case  9: // next row PA9
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
                break;
        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
- F1 |! P+ R9 y7 q4 V        case 12: // next row PC13
                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
2 l/ N. e) D( `, g5 o/ |3 n5 g9 ]9 N                break;
    }
% M8 z1 |) u; i1 Q6 `    if(scan_row<13)
! H7 O% r! \' z1 ]0 k. m        scan_row++;
- \: `9 j. f' x- b    else
# {& f( x) w  X, P9 x' M        scan_row=0;
  t5 p8 I+ O& a, c  `3 o4 {}
& v; k/ i7 L1 F* A/ H/ G; l

miaozhuang

! a3 q9 U: o; ?/ @# N5 b0 C  A' x% I$ Q扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。
: ^& G( }6 u5 U( C' R9 s. P
要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

$ ?; J0 [3 h4 |5 \* s* h4 c7 w# P- O
+ E# ^' C, |4 X' r( Y$ Lconst char hid_keymap_qwerty[14][8]={
% S2 Z; K% }. u# o3 a8 i    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
  z1 Y" ?0 v. x4 f: a7 ?% t+ m    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
2 ~" E& h4 q  o; s    {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},
" P" v. ~3 V3 e3 V( h    {HK_LShift, HK_NONE, HK_Caps, HK_F, HK_U, HK_0, HK_1, HK_F3},
/ f9 s& b0 M% k6 C9 n( p/ _    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_D, HK_Y, HK_9, HK_BQuote, HK_F2},
  v( U  q8 X+ l# X' [" P    {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},
2 N) _7 p% H+ E: W    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
4 s' u1 G! m1 A1 B0 D, X    {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}
};

2 m, T' v9 L' t
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},
    {HK_V, HK_K, HK_BSlash, HK_H, HK_L, HK_Quote, HK_4, HK_F6},
0 z( V0 ~6 a* F% [3 V    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
$ Y! C+ b: n) c& u& f! N: S& \, C' L    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
) `+ W6 \1 j8 R0 R% J    {HK_LShift, HK_NONE, HK_Caps, HK_U, HK_G, HK_0, HK_1, HK_F3},
) {/ }- {% E1 m' S) V1 N0 V    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_E, HK_F, HK_9, HK_BQuote, HK_F2},
! K8 k# S8 u4 q9 t% H    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
6 m+ j& _5 P9 j    {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_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},
2 v5 z' n5 F+ Z' v: p9 b( k# L    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
$ g5 A2 Q7 M: Y, p6 {4 H: A7 m};
, k! M7 s4 k2 S$ _$ r+ p* m. j
# r* z, `" }' `- v
/ Z5 {, L( U( A/ Q3 P6 }上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
. }' E# p: H% A# Q, i' D
" C  x2 ?4 n  @$ ^1 Y6 KHID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
9 y  o9 `! [2 a8 [
+ v& k0 a5 O( V. e4 I' v3 @# Kvoid update_key_matrix(char row, char col, char onoff)
{
* V% l' y: {3 m. I+ p    static uint16_t hid_report[4]={0,0,0,0};
- I) M' I( c& x! ?    static char (*hid_keymap)[8]=hid_keymap_dvorak;
5 F( ^7 h# L. j1 y
2 n: ^" P. o- p2 w/ ^/ d7 w. h
    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
    char i;
" d1 s' r0 k1 q# o- {* T* F# E0 n
7 {9 o  U% S) l2 S3 a8 {+ R
    if(key==HK_MODE)
    {
        if(!onoff)
        {
            if(hid_keymap==hid_keymap_dvorak)
            {
: p3 \4 p& P, S2 r0 R                hid_keymap=hid_keymap_qwerty;
  C% |/ i, r: _9 h4 `                GPIOB->BSRR = (1<<2);
  h* f* ?  q+ L+ K- {* ^3 v% F            }
8 e5 P0 K0 w' A3 i& e0 d% X            else
            {
: ]& E( v" @8 D1 B9 i: L                hid_keymap=hid_keymap_dvorak;
9 T4 |- G5 w/ v                GPIOB->BRR = (1<<2);
            }
) a0 A. Q$ x2 ]        }
        return;
/ G! p9 ^7 m$ w- {1 v3 W! g# R6 t5 c    }


7 d* t3 t7 H4 H+ K    if(key>=0x80)   // Alt, Ctrl, Shift
! k% w6 R7 ~8 L" W  w    {
        uint8_t bitset = 1<<(key&7);
$ N! n; a9 b+ a        if(onoff)   // non-zero is key up
8 p5 N& w! ?% B. E" @9 x6 [            report[0] &= (~bitset);
, o/ h6 f, L8 x) I3 D        else
! y  \" o1 N6 E9 @! B- L: |" q7 a            report[0] |= bitset;
4 L( o8 Q1 K) H  a: \    }
    else
' _7 D( e9 s# t( e" g    {
  H0 h: o# r. o  @6 w        if(onoff)   // non-zero is key up
        {
. r  n' z5 Y8 _" F            for(i=2;i<8;i++)
2 X2 J: e) o2 ]; ^            {
                if(report==key)
                {
                    report=0;
$ d7 K$ H* D+ v, X) r                    break;
                }
            }
, D% u5 j- z/ d) c        }
        else
% u- M: m, K1 y        {
            for(i=2;i<8;i++)
            {
0 q& V0 \4 ^  f' |' y) O2 j' X                if(report==key)
8 N: {, W( Z& X. ?                    break;
2 K2 _9 p, Q; F. F: [/ b/ A  K4 S                if(report==0)
                {
- v5 W. N: a5 }" _                    report=key;
                    break;
                }
6 C: C3 \+ q. y' l            }
/ ?3 P) w$ L* w1 Z$ T+ ~        }
1 o* l- U. z# h  a    }
    for(i=0;i<4;i++)
& p7 V# D; q5 U' `9 s: g- g4 f        USB_PMA[192+i]=hid_report;
7 N, P% E* M. @" k8 Y" @    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
8 q5 m: k& b5 E" ^) X3 R$ m    {
: y4 Y; D$ w7 M3 @4 E4 s        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
; e, R2 s: |$ a" S* f        ep1_wait=1;
6 g) q  k) ~* o' @& C( w# E    }
}
$ m5 e5 e# p% Z
( W0 z. `+ e9 i( _# i
  G8 g! t. ?4 O& F7 a) K完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6377)

2016-9-21 21:01 上传

点击文件名下载附件

' c* C  m" l$ f, f! }

miaozhuang

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

网络孤客

刚开始我以为要把打字机改造成电脑键盘
* o) q; d" Q1 ?1 P6 S不过楼主也很厉害！

miaozhuang

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

+ G' i, a6 Q9 Q6 N% k哈哈  是有点像奥

Mr.Prince

很厉害
+ m' Y) _8 k  X8 A$ x4 t

thermoer

这个看着真硬核