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

miaozhuang

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

在看这个帖子的诸位一定都在用计算机键盘吧。键盘上的数字键是1到9从左至右排列，或者是右小键盘区那样三个一排有序排列，反正规律很明显。但是字母键却不是A,B,C...到Z这么按字母序有规律地排下来的。我刚接触电脑(其实还是学习机)的时候，没在意这个问题，觉得是要盲打嘛，反正对两手的手指头来说，按字母序排列并没有什么好处。于是用多了这些排列也就记住了，从来不管它为什么要这样。其实，PC的键盘键位排布上是延用了打字机的键盘，这是设备演变过程中很自然的一个延续。打字机的历史就要早很多了，我没有亲见过打字机长什么样，而且，咱们汉字是铅字打上去的，和英文打字机方式完全不同。
6 v& h( _' }/ O8 C; n9 _
- m% e. I# {7 w$ f. d* B) G1 v- ]2 `
( |9 |, A. N8 H上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。

/ c/ ]* m9 q/ I" }为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：
% {! j9 U0 X5 P0 {9 ~. w5 n( N
其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
7 k, K: O3 Q* FDvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：

Dvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。
: ?4 n2 n( ?4 `. j9 v6 i1 x
( T/ M/ @  Y, v9 @& }我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。

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

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

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

先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
; [4 {  i  Y+ I' s& d$ O, ^' ?
轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
  o1 {6 l4 z# J# r
. V% x  Z  k: S6 T6 Z特写，80C49

LED部分，使用了一片D触发器锁存指示灯状态.

( n; X( S% z3 [1 n# K) Z5 G暴力破坏，将80C49拆掉
; r9 [5 s# I9 ~+ v8 y7 N
拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

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

用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。
# P7 g, k# Q( R7 H/ B. ?5 o& o7 w
这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。
* {6 M: I- d: C
  Z: s- a" Z/ m$ O6 [9 ^9 ]我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。

1 [9 t( h" l) ~) n主键区键帽就位

编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
' F1 \/ B# [: E* C
5 c5 |9 G7 @! ^1 b# Y最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。

0 C; }! x+ p: u; c4 D/ J
1 ]; Z& s- S, l# ]& j& p& T+ C4 H----------------------------------------------------- 分割线 --------------------------------------------------


. m4 ?' {. R9 ?: T7 ^: K- @

; x! j7 Y( O! l; Y/ _( i* x9 r) i
; M& v: u4 Z3 P) ?. U4 a
; [3 n; i$ S: n
) K3 G6 w! {) p5 S# A/ I- K

( V" s$ e* ]& t$ N& ?. c/ b* Q
. G6 f3 o8 Z3 Q5 X! G  W
6 `6 q3 i7 F3 X/ `9 P/ V

miaozhuang

DIY过程直播完了，下面说硬件的设计。
- L# s7 U. d4 X- [) t3 s* V80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：
& {- D! ^# F# D
. S0 }" J5 x9 t7 y4 g' n# D
其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)


扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。
' g6 A1 T4 K. m# j2 ?" M+ P
这是我设计的电路图：


PCB Layout:
; G& S# f0 d6 J+ O; n
8 c( f- D3 L% p
不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
/ [" h3 P; @! I
/ H6 s  D4 P8 T! `
$ U) h, e2 u% k  O

miaozhuang

6 x7 r8 {' n2 f" [: l3 z# f' G
3 a8 a: p* J( V  o- W: D1 }  z软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
4 W5 V9 r$ j: ^& |; H" A
总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：
8 i% d( N) H8 ~
/ e- D) R2 k( B2 r$ ^: d* @
! I! y( ~- E- |) f其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）

USB的中断ISR，bare metal哦
4 u' ?9 n( c$ |) E* ]9 v$ j
void USB_IRQHandler(void)
! e7 e3 F; J- F{
: ^4 C# v8 Q: z8 `2 q' e$ i+ ]    if(USB->ISTR & USB_ISTR_CTR)
" T: z: x+ V* h* M    {
6 G" D6 Z9 @9 R+ @        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
        {
4 }3 a; w/ w& n- D$ r            switch(ep0_state)
- R( |2 O% v* h" J6 o8 }9 A            {
                case 0: ep0_state |= 0x80;
                        break;
                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
9 C# ~  v' b3 n' t. b; P                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                            ep0_state=3;
                            return;
                        }
) H7 R7 t& q3 Y/ g6 v                        else
2 t6 N" L2 I& {1 y/ X; i                            ep0_state=0;
                        break;
: p/ ?8 }1 R5 }( C& d                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
                        else
                            ep0_state=0;
- b- w! r2 O. a9 m' W* E                        break;
                case 3: ep0_state=0;
                        break;
; [3 E1 B6 i( J- x8 ]! q                case 4: ep0_state=0;
                        break;
* @2 `5 c% I* ?                default:ep0_state=0;
$ Z( _7 J, Q# d4 q5 W: {, Y  M                        break;
. L" [0 W! h: i6 P& O. _0 d: C  F0 u            }
3 ]2 V- P# {: q- W! Z            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
) z& m. U1 D  o( l1 D- \            return;
        }
        else    // EP_ID can be 1
        {
            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
  N3 j% N# c; C9 x/ U            return;
        }
    }
7 d& G5 r( U: X6 S' [, W' I; w6 S    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
" s! }( h2 H) p3 _$ q0 X: z1 ~        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
; M4 _+ v1 n' S+ U    if(USB->ISTR & USB_ISTR_ERR)
    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
    }
" }5 l4 s8 L6 z) Q' _, ~    if(USB->ISTR & USB_ISTR_WKUP)
    {
# b1 Z2 x2 I* `9 V        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
. W9 u* x( E) ?" g9 y- G        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
' m' J3 t4 G/ s7 d0 S' J    }
! }4 k4 Z2 K3 A8 E! ?* }( c    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
6 [" \9 `+ }9 A; s7 p- u    }
- O( `5 K( X8 t7 d) _! y* o    if(USB->ISTR & USB_ISTR_RESET)
    {
        USB->BTABLE = 0;    // buffer table at bottom of PMA
        USB_PMA[0]=128; //ADDR0_TX
        USB_PMA[1]=0;   //COUNT0_TX
- f' _; L8 W( E+ t# ?& `6 [        USB_PMA[2]=256; //ADDR0_RX
$ P6 {- H$ c* I) Q7 Q        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
0 k+ v5 _0 }1 B; o6 K& S/ k2 C/ W        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
( i5 J; @5 U2 ^        USB_PMA[4]=384; //ADDR1_TX
; z' ~. j* w$ [) s3 |- A$ I7 o: b        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
    }
2 c7 G% \# m# a# T    if(USB->ISTR & USB_ISTR_SOF)
    {
2 h7 N  h! ]3 ?, z" w        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
}

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

6 H1 g# a1 N- S% J主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
4 @) L* U- O1 C
. f- }. F" _9 r1 Z$ i; G    while(1)
    {
4 d( s# ~, ~3 y, d' b, t- l$ j* s7 S        static char row=0;
        __WFI();
        if(ep0_state & 0x80)    // request data processing
        {
            if(ep0_state==0x80) // SETUP phase
            {
: W( G: d2 F4 w8 c5 ]0 ?                if(!setup_packet_service())
/ k. S! A6 I) |1 p9 h                {
                    ep0_state=0;
: C+ R0 }1 P2 |: J& c                    // not supported
& ^( @, ~, x/ g4 _- }                }
                // ep0_state should be set to 1 or 2, if processed
            }
            else    // OUT phase
            {
4 e; y! W2 i) \- k/ _" g* `                // process data
, I' V  P6 S% ~                show_LED(*(uint8_t *)(USB_PMA+128));
8 j* B3 f, p6 p0 a0 c                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
        }
# q. K  `7 }& n2 V6 w$ b$ @9 p( f        else
        {
            if(usb_address && ep0_state==0)
/ L1 _5 l3 m0 F$ H$ z            {
! n% ]* T0 R8 P8 Q                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
            }
        }
        if(row!=scan_row)   // new scan line
" H: @/ |* \3 x. [/ f7 p$ |        {
( Q3 z/ d, k. E# J( h            if(key_state[row]!=prev_key_state[row])
            {
$ a% ^6 J  f  c+ Q$ o                uint8_t test=0x80;
                uint8_t diff=key_state[row]^prev_key_state[row];
                for(i=0;i<8;i++)
( H; K. [% f# ?  O, v+ d                {
" v$ Y+ ]+ A, v+ k                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
- i  n! N# m7 A4 b5 `- I2 H# ~! C                }
            }
3 w9 F" C! i! a, |( f; z  N            row=scan_row;
9 t' i5 E+ k( E* i4 [( K1 l/ D6 E        }
    }
( H2 ~# F4 t6 ~$ k; \9 ^* z
" l) j7 W  c* u, n5 V
$ z& R0 s$ ?) g+ wEP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
0 y2 B9 \* S/ E0 g7 Z& T        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_REPORT: break;
            case REQ_GET_IDLE:
  x. S% p# g8 E. n, X- T, q" L                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
/ T+ V, v5 O/ z                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
$ @1 C( R4 b: r0 Y* V                ep0_state=1;
3 ]3 X  V0 h/ b/ X+ ~( f                return 1;
% F+ A4 u% b- G+ I; o$ r6 m& Q# ~; w                break;
: h  y& g% V- w& l            case REQ_SET_REPORT:
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
+ A  C1 O+ s# C, ~6 e. F7 c$ E% Z                ep0_state=2;
4 F3 P. Z: r. v                return 1;
6 b- z* l' @; X                break;
* X. P7 e4 l8 \            case REQ_SET_IDLE:
% H& \5 k8 s# u, B5 @                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
; Y+ f3 C2 l5 T- W2 G' s+ Z- L: r; f                return 1;
7 H7 y* I$ E$ N                break;
        }
8 b- H+ A7 I7 S        return 0;
    }
    else    // standard
    {
8 K0 y- z* R  _0 N! J" T        switch(ep0_std_req->bRequest)
        {
' o" `  T* [8 Y' t( `. S6 ?            case REQ_GET_DESCRIPTOR:
# T0 Q" L9 t( Q# k! R& T8 w                return descriptor_service();
" P3 o' l. P6 P0 M                break;
            case REQ_SET_ADDRESS:
                if(ep0_std_req->bmRequestType!=0x00)
1 }, f0 ^) }; _; s                    return 0;
/ ~% D" P: u( i7 K: M! f; O4 J                usb_address=ep0_std_req->wValue;
. U5 b! n' ]% G* {: n1 r+ C                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
) F0 q$ F6 j4 |, X/ X( A9 u                USB_PMA[1]=0;       // Zero length DATA0
, V% w7 I" j" ^: b                ep0_state=4;    // No Data phase
8 M: v8 |$ E' `8 K( s                return 1;
            case REQ_SET_CONFIGURATION:
                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
" p% P$ |9 a+ h2 L1 @5 y  w                USB_PMA[1]=0;   // Zero DATA
; \  D* d) j9 z2 f                ep0_state=4;    // No DATA phase
                return 1;
            default: return 0;
6 j# j' ?  {7 M/ P: b        }
( U& F1 q" {' ?' x% a    }
. t) _& a2 t, T5 e}



) T2 I  M: _3 O

miaozhuang

各种描述符，是USB开发首先要处理的
char descriptor_service(void)
{
    switch((ep0_std_req->wValue)>>8)
) J. n4 P5 y: P- ^6 N( L6 a: q/ i    {
, e' l* d: p9 W: k( r        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
1 g; j( v9 o* F# w/ |3 A6 E            break;
        case DESC_TYPE_CONFIG:
; n+ E: L: \2 M8 A; {            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
- O5 {: \& Q" |/ m                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
            else
, t/ H. w( ~4 e9 d" t8 M, b                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
; s9 n4 O8 N5 k            break;
        case DESC_TYPE_STRING:
5 T2 h2 b5 j5 U7 F. l2 L1 R            switch(ep0_std_req->wValue &0xff)
  T7 m8 c! j' z. o: k1 Y            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
. v! ^8 q' ^' h% X                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
4 b6 d- i" z8 q# \5 H                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
                default: return 0;
5 ^" Q1 n6 L1 A* T& }            }
            break;
# l  A2 i7 s1 i  a# B! J        case REPORT_DESC_TYPE:
1 c7 ^  N; a7 M+ H- x/ \  q+ ~            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
+ K; c3 [2 K0 D8 L  \& T        default:
1 `0 H4 H* Y  F& H1 Y9 W            return 0;
+ a# P% G% y  e( H    }
4 j$ ]; @: f8 W0 U" z3 v: E3 O}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
{
) k" w/ ]6 \6 w3 m    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);


    TIM6->SR &= ~TIM_SR_UIF;
    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
) G, a( o5 d# k2 e    switch(scan_row)
: E: T8 I! n: O1 {3 R    {
, h5 p& ~" {! v1 t' O        case 13: // next row PB14
4 @. z. {+ J* y- q                GPIOC->MODER = GPIOC_DEFAULT;
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
$ s: h* ^( U0 A. ~0 ~4 z                break;
        case  0: // next row PB15
  r) L& T) ]  B/ I/ o4 C; [" K" G; F                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
                break;
- ^+ ?  J! s  ~7 G3 N* T# C        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
/ b: _1 c( c* W: e/ r2 A                break;
        case  2: // next row PB4
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
8 _7 d$ a+ B; N                break;
) U5 Q1 G5 U7 t7 O0 R, C        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
                break;
" h/ s; c$ a$ k# w+ h( x        case  4: // next row PB6
  i+ [6 S/ C! N7 Y$ T( ]* l" _, u3 o8 o                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
+ Z8 F/ y- |2 A                break;
& P6 Y+ ~- y3 Q- H        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
                break;
        case  7: // next row PB9
) _  T. _5 i; T/ |$ T, k                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
+ z& o. v: l2 j* M# [# `" o5 M4 s; H                break;
! V. g3 J: b0 g        case  8: // next row PA8
! Y  d4 }: ?+ X4 Y* [4 L2 Z' }/ a                GPIOB->MODER = GPIOB_DEFAULT;
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
$ Q2 y! I/ i* T' D% Z0 W  |                break;
" C- x4 v( p- ~2 @        case  9: // next row PA9
+ Y; y" W) B# X0 u5 T- i                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
" ], L4 ~7 X/ T# k                break;
! z8 j  b7 z% v8 ~+ ]& r        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
$ H/ w, C/ m& {0 {4 e2 t                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
1 I$ l9 m0 D: k) ]; r3 r                break;
+ |8 S( V) R/ V! M# l0 k9 W* b        case 12: // next row PC13
                GPIOA->MODER = GPIOA_DEFAULT;
+ ^+ g; q+ U: X# ^$ Z: j6 i) }                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
- R( f) ^6 ~3 {                break;
- w+ Q2 s" Y7 m; _9 }' n    }
    if(scan_row<13)
( |- m) W. W4 z+ g  q: I8 j  b$ G7 T        scan_row++;
, P- w/ W6 k7 K& M3 L6 ]    else
1 L! [" S+ s6 w5 i& h        scan_row=0;
}

9 v- ]) M9 {9 l$ ?
* O7 Q2 x) l/ }: k$ o2 {4 s

miaozhuang

; w1 t+ B* T- `- ^7 t" @/ f
$ N3 r5 \/ G5 x9 z# B扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。

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

& L- a/ n' H0 b4 b1 z; {
1 G* m4 @8 |8 q% S1 z, g4 Iconst char hid_keymap_qwerty[14][8]={
/ u0 m1 O$ D5 m( k    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_R, HK_7, HK_F9, HK_Esc},
    {HK_F12, HK_BS, HK_Up, HKR_Slash, HKR_Aster, HK_NONE, HKR_Enter, HK_NONE},
3 N% z1 k! L+ N0 A+ ?. w    {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},
" H' ~: p% @4 `    {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},
6 N2 _$ i* u2 ]8 x8 m. H    {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},
    {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},
" K4 o! f: x  b1 S1 h$ b3 ^    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
1 a: z. X% f. ]    {HK_Space, HK_N, HK_Z, HK_L, HK_RBr, HK_E, HK_6, HK_F8},
7 @& O( \1 o: W    {HK_Slash, HK_B, HK_Delete, HK_K, HK_LBr, HK_W, HK_5, HK_F7},
/ B+ }/ n% n9 D+ h. }( G+ l    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};

- O9 m  k% n7 c9 i" [/ p. v
6 L3 \8 |; k7 m: j" D" y1 yconst 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},
0 S+ g& ]  ], M. r1 v    {HK_V, HK_K, HK_BSlash, HK_H, HK_L, HK_Quote, HK_4, HK_F6},
    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
! h3 `& F* o( R0 `# c    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
    {HK_LShift, HK_NONE, HK_Caps, HK_U, HK_G, HK_0, HK_1, HK_F3},
& I: x1 A1 i* Z/ P+ V    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_E, HK_F, HK_9, HK_BQuote, HK_F2},
+ P7 J* k) o9 b5 S* ^    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
1 v' A# \9 t: v: m    {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},
4 _/ H5 C( z# W9 u0 `0 m    {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},
) I9 m+ |. b! l' i% \  v' q    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};


, i( q& `4 I( Q! H上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
! E' ~- x8 X( E: U5 b
HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
3 ?$ t" ~2 c! {: Y, A# O
' _; h' l0 ~$ K1 K6 C9 B8 E8 ^void update_key_matrix(char row, char col, char onoff)
, P. D/ x8 k/ h6 g1 N: `{
' S" V& q" v6 O3 Q) z/ k# Q6 U    static uint16_t hid_report[4]={0,0,0,0};
    static char (*hid_keymap)[8]=hid_keymap_dvorak;
. s# p0 n# E  g. S4 ?" [

- N1 w* X9 K* _7 N    unsigned char key=hid_keymap[row][col];
$ G* g0 p' I" m    unsigned char *report =(unsigned char *)hid_report;
    char i;
! ?) c8 }, x5 ]( x

    if(key==HK_MODE)
; S6 x& Q# Y: T) @    {
! y8 L7 x; l: D8 X3 G9 ?8 \9 {$ }        if(!onoff)
' |: _( P! S# R9 u9 q1 c        {
' H2 Q- x3 _/ p; ?: g* Y2 D            if(hid_keymap==hid_keymap_dvorak)
            {
                hid_keymap=hid_keymap_qwerty;
  J  h$ Y; a% K& U                GPIOB->BSRR = (1<<2);
3 j. h" L* B: u2 b, f$ ?6 F            }
            else
: H7 {! ^" m/ p8 \            {
5 W" p( ~1 e3 n4 g. z1 U; \- P4 C                hid_keymap=hid_keymap_dvorak;
  A) h0 Y, U8 @                GPIOB->BRR = (1<<2);
. s* B  A9 ^+ `5 z' C. w; B            }
' Y3 U. l6 ]5 j9 s1 H( A        }
4 z4 J0 F. e, h: T: F8 l, S9 d        return;
    }


# o! S7 s, B2 h3 a9 q    if(key>=0x80)   // Alt, Ctrl, Shift
    {
% U3 _6 F5 v9 i        uint8_t bitset = 1<<(key&7);
! V4 l1 j4 y+ c8 |+ j        if(onoff)   // non-zero is key up
) v2 ~; f% T, ~0 m: S7 t            report[0] &= (~bitset);
; r# B6 K6 b: @/ z+ ~6 r        else
) v* v. V: Q+ C+ v/ ~) `! [            report[0] |= bitset;
    }
    else
    {
$ ?2 k! b. J1 H* e$ |        if(onoff)   // non-zero is key up
6 `, L' Z, f% ?1 t$ \8 P        {
            for(i=2;i<8;i++)
            {
0 R$ k, ?; o3 r% ~/ ^0 r" ?                if(report==key)
4 V4 U) W4 z$ W( B6 W6 Q                {
                    report=0;
                    break;
                }
6 x8 Y& c- [2 l: W; l2 j            }
, `" ^% X+ M0 x0 P6 g, m        }
        else
        {
( \* p4 B* t6 D4 m            for(i=2;i<8;i++)
& {8 ]- V8 D& ~2 F% x            {
                if(report==key)
8 P3 C# E3 m5 B3 W: R                    break;
                if(report==0)
                {
0 {) z/ B, a2 \/ s                    report=key;
                    break;
- R/ R& R/ _; {9 w                }
            }
! l: L( W" F% r& H) j        }
    }
+ I% e  t' k* l! q" e& C, z    for(i=0;i<4;i++)
8 f3 ?. x& L( {. T        USB_PMA[192+i]=hid_report;
    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
& R& v) X( E; n( U, ^6 _. E    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
: W1 s& y: R: e& H, q        ep1_wait=1;
' J8 u0 s$ w& c7 O4 w0 w    }
}
1 D2 W( A/ R- F& D  Y/ k2 ?6 p* J* Z( M
7 S3 R& p& d( O7 t
9 b. c1 X( d# z* L* B完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
! ?/ v2 P' w- Q/ L6 F keyboard.zip (8.7 KB, 下载次数: 6209)

2016-9-21 21:01 上传

点击文件名下载附件

" c( w' [  C0 v  ^

miaozhuang

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

网络孤客

刚开始我以为要把打字机改造成电脑键盘
. ^+ y0 p/ `7 p4 d: d* i不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
/ z$ L8 ]' o' s/ G5 i( K4 P刚开始我以为要把打字机改造成电脑键盘
不过楼主也很厉害！

) [; v) Y& K6 z/ q1 l哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核