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

miaozhuang

3 u" `5 E$ K- b  m  O! e* R
http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

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

3 T9 W1 t5 {2 J% v0 O6 D) Z$ {
6 v9 e; z* _3 N# G5 S9 s' N上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。

& B( [0 {/ S' i& g. M. I为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：

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

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

我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
- T: x) M0 [6 z; e* X- B
. k% [7 j3 R, K% ~) q' D% l+ {到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。

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

先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
. g5 V8 S  o5 E9 I" h) c( A6 @
轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。

特写，80C49
! C9 A1 K! G0 l; y
8 A4 R; v' e! O' MLED部分，使用了一片D触发器锁存指示灯状态.

暴力破坏，将80C49拆掉
( H9 C* \$ N8 q) P) `# T) Q
, D2 V  Q3 S8 L' B拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。
: `$ }0 x( A; M
焊好元件后的板子，准备替换80C49

- o9 T& v/ X" J( `用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

( L8 L0 q0 `' u, B这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

) |! X- y4 p7 ~# D开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。
6 m% D( X0 Z& B  W* ]' i6 ?. F
/ e* e+ l" r; D  g/ T' F我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。

主键区键帽就位
, V9 j: S: e/ k5 L
, D' `* K' y& M编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
' k( q% P9 \7 ^+ P; M7 Y2 I) U
3 q/ \* F( U* o* E( h* l' Z最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
# R. I7 q% P$ G3 o( ]0 T6 A* n( t; L6 `; r

: l3 t' W4 `2 s2 {2 f& _4 Z----------------------------------------------------- 分割线 --------------------------------------------------

8 F6 ~7 H; G$ j8 C# V: B0 f5 I8 n
5 I+ V4 E6 b* j( O+ k
+ l2 I; R" c$ Q( m4 s




( Z. M! f4 E, i8 ~


# w6 C7 y4 j/ Q, n5 v) m

miaozhuang

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

# H: O7 d- f# K( ^) B
: P! y3 R, w# H  v& @3 V* R' T其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)

2 r7 v( W8 R  P3 g5 n
; z8 N) e! S' ?扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。
- P- `5 C3 E0 [+ u: X/ V9 s' w1 ~
0 D" Q) c9 x9 h. ]* [这是我设计的电路图：
4 v5 S' a  q' L7 g1 V5 f

2 o/ r7 {9 i7 ~" APCB Layout:
7 l7 u! W" s7 A; v. e

, ?+ F6 T* f4 P; f$ o& j6 }不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.

miaozhuang

( u4 C& y$ Q$ a
' ~9 e% M; H' q/ u8 K0 t软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
9 _5 W! D2 d0 y$ S
: G1 @6 x% [4 z# J4 O! B总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：
# v  c4 c9 K- Q2 }% i7 F9 a

其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
& E, {6 y9 L5 A" {) a
USB的中断ISR，bare metal哦

% u3 i8 f9 Q* {+ N! f% kvoid USB_IRQHandler(void)
. j5 N5 ]3 {) H" ]9 n7 K- o9 T{
    if(USB->ISTR & USB_ISTR_CTR)
6 [8 H0 A* [3 U1 s    {
        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
% V  A" k% y" `* d% Z        {
0 @) R2 c, a4 R* ]8 |9 B4 s            switch(ep0_state)
            {
0 V! ^8 }, e# e7 O( e4 v+ o                case 0: ep0_state |= 0x80;
. {5 A; v2 N, j                        break;
* f0 s$ s% ~9 _4 F; {                case 1: if(USB->EP0R & USB_EP_CTR_TX)
* f* ~" o- l/ P                        {
                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
! z$ Q4 M9 @% N6 @' ]% j                            ep0_state=3;
                            return;
                        }
0 D) K' ^) G, N! M! q1 f                        else
                            ep0_state=0;
( M/ L7 w- s( s" a0 u: G( |                        break;
/ q7 n7 L) F& Z8 ?                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
                        else
                            ep0_state=0;
                        break;
9 s3 Y# {. `8 U                case 3: ep0_state=0;
; g  l& f, e' I6 G/ h! W                        break;
                case 4: ep0_state=0;
                        break;
* X" L) B! e, P1 I# ?- e/ j                default:ep0_state=0;
                        break;
' n6 M" ]3 l: l! y5 A. \            }
& R, q& c4 g. d6 G            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
        }
% F0 R' U8 L% T" j        else    // EP_ID can be 1
        {
6 V9 [+ H7 f# R7 p            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
" r7 `( _$ n  ^            ep1_wait=0;
            return;
        }
: `3 p- m7 S4 P  \1 o    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
1 k3 s; C* G7 ^% k  d" W3 M) R4 S        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
# g  J/ q: R& |) J. A    if(USB->ISTR & USB_ISTR_ERR)
    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
; v/ V. c! q. G( L& u7 p    }
    if(USB->ISTR & USB_ISTR_WKUP)
    {
/ [; Y" P1 Q" \5 \9 U        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
+ J" L9 g7 G  y, G        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
* F0 d& ^: N1 w2 U, F    }
    if(USB->ISTR & USB_ISTR_SUSP)
    {
. C% G# t1 Y) f# Q4 Z        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
        USB->CNTR |= USB_CNTR_LPMODE;   // low power
        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
8 r: p( @  m; M& @, [    }
    if(USB->ISTR & USB_ISTR_RESET)
7 j: w  Y2 `4 _; }! F/ L) R+ R    {
- c3 r  z2 l* L        USB->BTABLE = 0;    // buffer table at bottom of PMA
        USB_PMA[0]=128; //ADDR0_TX
        USB_PMA[1]=0;   //COUNT0_TX
) }( L) r( y7 w( }2 Z( Y        USB_PMA[2]=256; //ADDR0_RX
        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
& E" F+ L/ S7 D0 O7 i+ f        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
+ u# ]( t6 t# ^        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
        ep1_wait=0;
, b: V; |- p4 ], N8 r) V! H; s        USB->DADDR = USB_DADDR_EF;      // enable function
        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SOF)
    {
2 ?. }2 c9 P. A, J  q        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
}

3 {8 j4 p2 A3 u4 k' @+ w2 R# `+ [因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
6 c. z; `4 F6 \% S1 |; F
主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
/ z/ W! P& I3 z) Y: T8 \1 T( O. Y
    while(1)
/ u+ D+ B2 C7 y7 v( N- ?    {
        static char row=0;
+ s& @% j! B$ f" a& ~. s        __WFI();
' i: A8 M+ Y$ J; {. z8 @        if(ep0_state & 0x80)    // request data processing
        {
$ r$ P" _, U0 q% I            if(ep0_state==0x80) // SETUP phase
            {
                if(!setup_packet_service())
                {
, n$ |' p; s# N0 w. N0 e                    ep0_state=0;
                    // not supported
2 u4 A/ S2 o$ R& z0 B) d5 T                }
; [, a6 w1 m7 o( c7 u7 O                // ep0_state should be set to 1 or 2, if processed
; F$ P. Z# {, `! w0 T* U            }
            else    // OUT phase
            {
4 I# W# R2 t8 ?! _                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
$ Z2 D" i6 o9 `. ?5 l# K                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
: w0 @8 q1 |$ x& a5 G                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
: A1 D9 Z! N$ T1 b- ?% H- d) z- P+ q6 b        }
7 g  q4 n6 `9 r5 p/ h; Q, q        else
        {
            if(usb_address && ep0_state==0)
            {
                USB->DADDR = USB_DADDR_EF|usb_address;
4 ?( O6 \5 ]' ]% ?* l* a                usb_address=0;
            }
        }
        if(row!=scan_row)   // new scan line
        {
" e" V# ]; _. U0 ^3 Y* Z( @            if(key_state[row]!=prev_key_state[row])
% K& j3 ?1 Q1 T- [+ N            {
                uint8_t test=0x80;
                uint8_t diff=key_state[row]^prev_key_state[row];
                for(i=0;i<8;i++)
                {
; S+ W- D- A1 Q/ e; d" l  S# P                    if(diff & test)
3 p% I: b. x) x/ ~' |* t3 n2 F                        update_key_matrix(row,i,key_state[row]&test);
. O) Y$ G" o. O& V                    test>>=1;
                }
            }
            row=scan_row;
/ C9 e! F, l4 g: [  B        }
) ^7 Y5 R# [- S& H    }


4 G# ~4 W* D; Y0 HEP0的控制传输，把用到的请求处理一下
+ ]( m/ t1 \: ~& q4 u% h2 S1 xchar setup_packet_service(void)
{
& K, P2 Q# y; X! a    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
        switch(ep0_std_req->bRequest)
8 F! ~( [! k8 b        {
            case REQ_GET_REPORT: break;
4 z/ ^+ c' E: l, q            case REQ_GET_IDLE:
0 `% Y' w, x7 p; U                USB_PMA[64]=0xfa;   // return 1 byte
                USB_PMA[1]=1;
9 }( k" d3 m2 p                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
$ K' x' V' i+ o7 n7 A                ep0_state=1;
                return 1;
                break;
# G# L  Q% ]0 f: X3 Z$ o  |. P            case REQ_SET_REPORT:
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
" l3 R( x! X9 E9 e" ?# I: D3 N; i                return 1;
                break;
            case REQ_SET_IDLE:
& B7 t/ S! p0 H                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
! K5 `+ @5 K, S, U1 X                ep0_state=4;
                return 1;
% b  Q3 u& n$ J. y3 _+ s                break;
( t  O) O) G, k* I6 }        }
$ B% _4 v0 P& m* c9 L6 J8 E2 ?, L        return 0;
( K) p  Z& T  X* m" h3 U' n+ L    }
    else    // standard
    {
, H: a" h! b% q. V        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_DESCRIPTOR:
% u! e/ c$ [+ m% {) _) [6 G; {                return descriptor_service();
                break;
            case REQ_SET_ADDRESS:
. w6 S; f/ d# m1 t, M" ]                if(ep0_std_req->bmRequestType!=0x00)
3 l' f) d8 U9 K1 I8 A                    return 0;
; Q* ^1 y$ u. ^$ D2 O# C% W" V. u                usb_address=ep0_std_req->wValue;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
9 y. v2 t: w% @, ?) J! a                USB_PMA[1]=0;       // Zero length DATA0
1 N5 g6 ]2 S, r+ y                ep0_state=4;    // No Data phase
                return 1;
            case REQ_SET_CONFIGURATION:
                if(ep0_std_req->bmRequestType!=0x00)
  C: z; q# c- |  S                    return 0;
                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
, P6 w1 ]- @( b                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;   // Zero DATA
  w$ c' y9 l- f3 J" A& E                ep0_state=4;    // No DATA phase
; U( A; \8 I6 \8 [! S                return 1;
            default: return 0;
% Y# H& ]$ m5 Y+ w3 C9 q        }
7 G4 V2 o% U4 }2 ?% y4 ?    }
6 B/ B9 [; C, w, I}
) v( c0 x# ]/ N6 x2 L
' P: r+ D  k: |6 M% P  N8 s! I; O

7 K3 X) h6 o* A* I. S

miaozhuang

各种描述符，是USB开发首先要处理的
+ s* Y  T% Z+ u5 O/ t" E. H2 ?' vchar descriptor_service(void)
, R, j; F& a$ \  V2 p$ N{
' h7 U+ j7 z- u$ A$ V3 \    switch((ep0_std_req->wValue)>>8)
% E. U# q8 B7 l) `" s1 ^    {
        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
            break;
        case DESC_TYPE_CONFIG:
4 I& u  a' H& w2 G- E            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
2 j% [9 Y% \8 X+ i            else
! `; X- o  i$ @  t# l; C0 N                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
5 c$ v" U, s' P* |            break;
4 O$ e& [" n. E. h        case DESC_TYPE_STRING:
# h; J- X2 v2 w4 J% i4 f            switch(ep0_std_req->wValue &0xff)
, c# P  C- _6 R            {
. }0 w' u3 P4 [8 f- T5 H! @                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
, t  Z& {6 d" R1 n: `" \" ?& L* N                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
6 K: g% a1 z- U5 U  j                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
                default: return 0;
            }
! l9 M1 u% O2 b            break;
        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
6 g) b) t" `( f+ ^# R2 O- K) V        default:
5 @% U6 L+ w5 Q6 d% F& k            return 0;
& l+ w, ]1 R) ~! W; |# j    }
. V3 k$ a* O+ j0 @7 b! |}
, G1 Q) X; p% h6 t6 O/ l下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
0 ?# z0 W& y5 q4 i! H- mvoid TIM6_DAC_IRQHandler(void)
{
; a6 i8 O' B2 E" `    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);
9 ~5 m  y3 o/ [( k  h: Z

" W/ G1 _  x& `9 d; n    TIM6->SR &= ~TIM_SR_UIF;
    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
% Q3 n' m" B7 S- H6 m( q3 c: c    switch(scan_row)
    {
        case 13: // next row PB14
" s' v, O5 V$ A1 E. r1 z. M                GPIOC->MODER = GPIOC_DEFAULT;
% a* Z* o/ n' q8 m' O                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
        case  0: // next row PB15
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
- d5 w5 D. [& k" X& F) s: y                break;
        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
                break;
# I5 w: J& c( O" G" X6 N, m4 \9 w        case  2: // next row PB4
( `& {8 h4 {0 i+ k/ W3 V                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
                break;
        case  3: // next row PB5
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
                break;
        case  4: // next row PB6
( u+ q- }0 u2 |3 u                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
) u) B' [2 c4 U0 W1 q3 s$ H                break;
( v3 N+ k. |) t' z( Z        case  5: // next row PB7
; H2 }" q- c3 {                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
6 l8 s4 |7 C6 u9 K% M                break;
& s' J% m- M* Z$ ~7 S5 M        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
( |# A- u$ |: ~3 q* T6 x                break;
        case  8: // next row PA8
6 }1 e" r! L; \) r* |9 M                GPIOB->MODER = GPIOB_DEFAULT;
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
* t  C/ v7 w" P- R3 ]. m                break;
        case  9: // next row PA9
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
/ h$ z* K; @8 f- ]$ Y" ^8 ?4 [                break;
: a) J. D: D& v2 t        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
4 W* f$ e& `/ a, f, D                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
4 D' t6 Z% o. u8 ?" o) M        case 12: // next row PC13
$ x3 t5 R$ h- h4 e/ _1 N                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
- x+ l: {! Q5 D3 L3 L# l/ [                break;
& P8 {- z, t8 `5 y    }
    if(scan_row<13)
8 J# w& B' K- c2 h7 k8 u        scan_row++;
0 z' _3 l' X0 M) C* g. z    else
        scan_row=0;
}

4 \) _+ c% I( B  ^8 x8 x4 U, V8 e
" d7 g3 M# O* r4 y" Z

miaozhuang

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

; A) O$ ~* N4 f( y' Z" d4 |要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：
+ o$ ?# c  b& @3 g
3 [5 \, Z* o7 ]3 R6 n$ e* j6 A
const char hid_keymap_qwerty[14][8]={
    {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},
    {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},
" j  E7 c" ~% T3 i0 U$ W2 n  B' P    {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},
8 w0 R7 o4 Q1 E. `    {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},
( `4 {/ v  d  e- U8 l    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
: D7 E0 u- w* A7 P) \    {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},
' _( L1 W( F& l( P    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
9 X8 x9 X. A7 E! d  w8 K! D* }' h: I};


const char hid_keymap_dvorak[14][8]={
    {HK_RShift, HK_NONE, HK_NONE, HK_A, HK_P, HK_7, HK_F9, HK_Esc},
1 ^  B, P/ r2 W1 b3 A+ T    {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},
3 f: M- Q8 l% j/ V  X    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
  i. C% |; b# P    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
* `: ?9 x+ q8 a+ \, P    {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},
6 @; f: _' j: S5 D1 d    {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},
6 J, d: x1 O8 J  B' Z) v8 f    {HK_Z, HK_X, HK_Delete, HK_T, HK_Slash, HK_Comma, HK_5, HK_F7},
3 W& |( P* g0 p7 ^! z    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};


2 U2 h  C$ x; ]5 [1 i" _- U  |上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
# M' b5 e- ^+ _$ W( y
# v. T3 g% p0 Y2 D1 Y0 rHID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：

void update_key_matrix(char row, char col, char onoff)
{
' a7 z0 E! t% q7 J& b5 H6 X    static uint16_t hid_report[4]={0,0,0,0};
6 [; ]8 r5 u% q4 |    static char (*hid_keymap)[8]=hid_keymap_dvorak;
; B* @$ r" p0 }0 S. `6 \) ~" @
0 L6 m+ ^6 f9 t3 C! y
  h& T* h4 e7 Y! Q    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
! M/ m/ C) |! D  T$ w    char i;


/ H0 _, W& F) W" n    if(key==HK_MODE)
2 a5 l+ A  {. z& C4 E& V    {
        if(!onoff)
; H; `; \8 }" M8 f! j        {
            if(hid_keymap==hid_keymap_dvorak)
            {
# _% b3 B3 s6 v                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
: P+ K3 ]3 M. P            }
' d& y, e# b6 r& K            else
4 K) y: G- w/ K" h/ y- N            {
                hid_keymap=hid_keymap_dvorak;
                GPIOB->BRR = (1<<2);
            }
        }
        return;
    }

2 e4 b6 u) D' Z7 y* s
    if(key>=0x80)   // Alt, Ctrl, Shift
! W2 e- x1 E$ a( S! j" q$ b    {
        uint8_t bitset = 1<<(key&7);
        if(onoff)   // non-zero is key up
            report[0] &= (~bitset);
        else
" R% k+ }  Q% k: j/ f: T+ k$ t            report[0] |= bitset;
+ Z+ _2 T% v  c    }
9 _$ x/ l  P  J; O: e1 D    else
    {
& d8 |8 a6 K% T! J3 T        if(onoff)   // non-zero is key up
+ R! ?- @2 I0 I* f" b+ j9 U4 ~$ {" l        {
            for(i=2;i<8;i++)
            {
                if(report==key)
( T7 A, o' ~) d! L5 K                {
+ o# |1 R- U9 S1 q8 d# \% x0 j8 P                    report=0;
                    break;
                }
% o! j, I$ r5 \% t            }
& }) _: `! [' l5 G6 c# M7 T+ Y        }
        else
        {
            for(i=2;i<8;i++)
            {
0 ^0 o! v$ N! l* D6 N+ [5 }                if(report==key)
                    break;
9 }( j# ?0 S% E0 `- w                if(report==0)
9 U6 [* Z. B* G                {
; [+ o2 b0 E: l8 [+ U                    report=key;
                    break;
- u0 q3 s6 v9 o2 F' F                }
& S1 I" G1 O; P+ ^. K" m1 _            }
        }
* m8 C( e$ x) l3 v# x6 K    }
( E/ h- h8 k3 G  {    for(i=0;i<4;i++)
: S" W9 M* B5 S( o( F& }+ o, ^        USB_PMA[192+i]=hid_report;
  h3 g6 n. ~/ {0 N7 @! U, q, @* K    USB_PMA[5]=8;   //COUNT1_TX
    if(ep1_wait==0)
. u, w( r5 n, J$ M" B    {
4 S' i+ H; H+ B4 D        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
' ~" w( C* g7 X5 A2 x        ep1_wait=1;
9 m/ u8 y/ {) r5 n2 M- b5 P    }
2 Y0 V1 r: [# f+ g}


完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6617)

2016-9-21 21:01 上传

点击文件名下载附件

% L, o4 c! f8 W# R  s3 [" N
2 D+ `$ I6 H6 b4 ]' E! q
% J6 ^' D' i/ Q0 G" \

miaozhuang

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

网络孤客

刚开始我以为要把打字机改造成电脑键盘
5 C* p0 I  ^; Q- C  f/ ^不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
- c- X6 B0 o* j8 X刚开始我以为要把打字机改造成电脑键盘
+ ?9 k! E% W" u不过楼主也很厉害！

哈哈  是有点像奥

Mr.Prince

很厉害
' M+ Y. ]3 n5 T. d

thermoer

这个看着真硬核