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

miaozhuang

- x, s) Z. E, l% V, i
http://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
. s0 G* [! |3 D; \4 m% |6 i这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。
1 d8 Y: g9 J: }- t+ M
- O+ W7 Y- e, N5 P: ]在看这个帖子的诸位一定都在用计算机键盘吧。键盘上的数字键是1到9从左至右排列，或者是右小键盘区那样三个一排有序排列，反正规律很明显。但是字母键却不是A,B,C...到Z这么按字母序有规律地排下来的。我刚接触电脑(其实还是学习机)的时候，没在意这个问题，觉得是要盲打嘛，反正对两手的手指头来说，按字母序排列并没有什么好处。于是用多了这些排列也就记住了，从来不管它为什么要这样。其实，PC的键盘键位排布上是延用了打字机的键盘，这是设备演变过程中很自然的一个延续。打字机的历史就要早很多了，我没有亲见过打字机长什么样，而且，咱们汉字是铅字打上去的，和英文打字机方式完全不同。

1 U; M; A) L, S
上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。

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

其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
Dvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：
/ n' q: A8 l; k
+ @+ F+ b" [! u% T! t# Y; n( tDvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。

我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
1 H/ E7 r6 I& W- w9 r* C- U: D
1 ]7 u& ^$ v/ S+ D! y2 W4 ^到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。

* @4 Y6 U( I8 h  G2 [+ X1 V6 S机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：
& ]0 g8 s& x* N/ w) c; j# W* d4 s
: e. ?) \4 l! G. N----------------------------------------------------  分割线 ----------------------------------------------------------

2 r8 m; v3 M9 I) W* ?6 b先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
& m1 D; V9 C  N: ?& c' {( H
( D1 j; d/ Q! `4 R. y轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
( m# a4 m, ^7 _
特写，80C49

LED部分，使用了一片D触发器锁存指示灯状态.
8 W. l8 J6 A( u8 D9 z
暴力破坏，将80C49拆掉
3 v% j$ }( t& J' L8 X* t
# {& ~; t# l* r) P0 P& ~拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

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

0 n2 e- f( m, S/ h  F( l4 Q用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。

# c6 P8 F' L" v# t9 y: N( a这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.
: O- ]! p; V7 ~# v) Z
, q# [: |$ N# n' l开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。

我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
6 c& ]5 m; X1 t
主键区键帽就位
7 N$ {4 R% b7 A/ I2 s
4 U, A  N1 ?( ^$ }/ Y8 @! d" Y编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。

最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
# X2 d2 z( j! ~2 \
) v* P% W' @2 C  J3 F- s* k( g1 C
/ ]5 s  u# a, R3 ^& n* u* r8 w4 r----------------------------------------------------- 分割线 --------------------------------------------------

! @! G. [# p3 X+ E% E' F, F5 }
- U6 {3 y( R6 H( n( N/ e
. \, Z5 p/ X- d) }% @3 ]) `

: ^7 p8 x! H. X3 P" p- v% w





/ f: ~3 _/ l* t

miaozhuang

DIY过程直播完了，下面说硬件的设计。
  _6 c" N, j* n) m80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：

% T/ I1 V- y2 v8 K/ \2 h( T+ g9 ~
2 `7 ^9 K& |' W: {其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)
- o) B7 m$ J- \
9 w" e! T6 j6 N- Q
扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。

2 v1 ]% P$ o+ @6 o5 D/ G这是我设计的电路图：

! b( v3 L  c# t0 o& [) e1 B
PCB Layout:
/ W) V( C/ c; a' N7 W7 {+ A! J- S

不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
/ `; f4 A! X) ?' d( y  e9 z
/ X  \/ v$ B  z5 y3 L0 |

miaozhuang

! u5 o, T( O8 ~- B* v! i8 W( v, N
& j) N6 `. q& I' y  q  A  v, Z. P软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。

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

其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
; k3 i6 z5 D1 U
USB的中断ISR，bare metal哦

void USB_IRQHandler(void)
7 L! U4 W$ V. U5 |, P# o{
5 E/ p, ], M  K4 I! e    if(USB->ISTR & USB_ISTR_CTR)
( ?5 l8 o5 k' S! A3 `  x    {
        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
" D' V, ^. j1 `7 @6 T        {
! @6 {% l- b6 m- S3 Z            switch(ep0_state)
            {
                case 0: ep0_state |= 0x80;
6 ]; W% |0 [7 J' X* k                        break;
, I( k* S7 U  q2 M, [) \                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
. E4 N2 x3 D# n1 p                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
; n" c3 |' t6 t8 D% ^3 z                            ep0_state=3;
9 b7 P. \2 E' s0 R                            return;
0 `) D/ K* t0 Y1 G4 ^                        }
                        else
6 J3 O( v4 q0 D% f2 e8 p  p6 G+ A                            ep0_state=0;
* {, n# G. w" N3 w# L                        break;
& E* M* \% _; V; N* B# w' ]                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
                            ep0_state |= 0x80;
                        else
9 m+ J2 S# s: F6 |* Y, q                            ep0_state=0;
                        break;
) t' {9 j& A  R9 c  X4 [+ d                case 3: ep0_state=0;
                        break;
( ^3 w* p# Q. B                case 4: ep0_state=0;
- l* G4 {7 ^: l1 q; j* R2 j1 h  q                        break;
3 B4 S2 m, B! ^( Q. a9 A                default:ep0_state=0;
# V2 c; I" s# Q) H5 l- l( ~                        break;
            }
" D& j, y) ]6 u/ m4 h            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
1 m6 L4 U* V% H& I$ \. m, E6 w        }
        else    // EP_ID can be 1
! m5 X7 M/ y* O$ c, {, n6 V9 m( N! S        {
8 {( _& V. s' o+ S* x            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
            return;
        }
2 R" _+ Y( C# t( z    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
    if(USB->ISTR & USB_ISTR_ERR)
6 @9 p. H0 ~7 b% ]. y0 E    {
; J; P& v- u7 @        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
- u' Z: `" z* k: O    }
    if(USB->ISTR & USB_ISTR_WKUP)
" F3 X5 s* M) S$ g    {
        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
6 c# X" I# O; ~. K        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SUSP)
    {
! C- x& }# `' W7 {, \5 m        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
$ ?5 V; {! Y, h9 {- Y        USB->CNTR |= USB_CNTR_LPMODE;   // low power
' l* L+ ^7 O: ~) E        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
    }
4 L4 \, X0 H& ~. |& |8 G    if(USB->ISTR & USB_ISTR_RESET)
    {
2 x+ ~8 e, Q5 f) h8 L$ h0 ]        USB->BTABLE = 0;    // buffer table at bottom of PMA
        USB_PMA[0]=128; //ADDR0_TX
% w4 s0 a0 _1 Y* r' n        USB_PMA[1]=0;   //COUNT0_TX
0 z) g) ^( I$ z( m) I        USB_PMA[2]=256; //ADDR0_RX
        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
3 T% y+ I, Y. B% Z6 t! @( L        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
        USB_PMA[4]=384; //ADDR1_TX
/ R' l6 r3 Y0 r! ]  z/ n9 S        USB_PMA[5]=0;   //COUNT1_TX
- X, E( Z8 C# V        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
+ Z* H6 w; Q/ I4 G% ?- Y7 j2 B    }
" c8 G+ N: N5 F/ E  L0 x# G    if(USB->ISTR & USB_ISTR_SOF)
; y+ A1 `$ J5 ?' l/ x    {
        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
- n  h% t# a! a+ E& @( y/ D    }
$ M/ \' ~6 |+ u& H; _# l}
' r- P2 `0 l! ^8 p+ D: S
因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
( e, K5 Z2 w( }+ o& P; F1 H  N/ Y. V
2 e6 G: D$ u" d+ B! D主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。

7 o1 C; t" ~5 G" }, t    while(1)
  k7 z" p3 P' K( k& ?    {
        static char row=0;
        __WFI();
: Z0 ?5 S1 T8 P% g; ^        if(ep0_state & 0x80)    // request data processing
' A# ~/ `8 L+ Z5 m! D: ~# `        {
, N! Q' \9 @6 @7 J- `' s  H            if(ep0_state==0x80) // SETUP phase
* Q/ H- |  Z. d9 f" M2 q3 R            {
& h2 v3 r  `( h+ X                if(!setup_packet_service())
8 Z& j' V. P. b5 f3 n( b                {
                    ep0_state=0;
                    // not supported
8 A& l+ |/ i9 v2 S3 X3 o+ c9 }                }
" U; ?% Y! C) @$ P0 d  e$ D3 @                // ep0_state should be set to 1 or 2, if processed
7 g% ?( \# C5 D0 R7 o0 r+ }            }
            else    // OUT phase
            {
; k; c0 j, w# \3 [                // process data
& \1 N# n8 x6 t2 F7 L. F$ ~                show_LED(*(uint8_t *)(USB_PMA+128));
4 B) _. `% V2 r2 h5 |% @4 w                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
        }
        else
        {
            if(usb_address && ep0_state==0)
. ^5 G, q+ W+ U$ p$ o            {
/ Z* r7 t% x' c$ F* ~3 j! y  q                USB->DADDR = USB_DADDR_EF|usb_address;
8 L# `% Y( k  X. v                usb_address=0;
- H' Q! A" T& y' E* X8 ?            }
        }
        if(row!=scan_row)   // new scan line
7 i1 b5 s" N* D6 h1 P        {
% B" k! S2 B2 V4 s* g; Q  P% v            if(key_state[row]!=prev_key_state[row])
            {
: `- d9 {  Q* C' F                uint8_t test=0x80;
: l1 E4 r- }7 J$ y. U: ], c                uint8_t diff=key_state[row]^prev_key_state[row];
                for(i=0;i<8;i++)
                {
3 c) f; ~" h% j' ^6 h                    if(diff & test)
3 U1 B  u" n' l7 G: t0 x7 y% P/ ~                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
                }
            }
$ m1 g; I3 Q3 _5 M1 Z1 T            row=scan_row;
" V. ^% O. _. x, L3 L        }
: V& r* F# w! E; j( g    }
6 K4 b- I! g5 C! ~$ `

, M# F* P; X( T' iEP0的控制传输，把用到的请求处理一下
. K) `' k1 ~$ [! L2 k* fchar setup_packet_service(void)
; ], @; ~# R  m{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
+ `, I& i. y: Q$ h6 l        switch(ep0_std_req->bRequest)
        {
6 d" r8 j5 Y& j            case REQ_GET_REPORT: break;
; k4 E, O! y* K5 u. e            case REQ_GET_IDLE:
- y% q( b3 E+ e                USB_PMA[64]=0xfa;   // return 1 byte
  m! g3 x$ v- U  a- y                USB_PMA[1]=1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
" r) P( r" i* ^, f                ep0_state=1;
                return 1;
                break;
            case REQ_SET_REPORT:
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
4 ]1 ]9 L- f/ q- P                return 1;
                break;
            case REQ_SET_IDLE:
                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
+ N$ e6 }8 {8 i* q" g                ep0_state=4;
                return 1;
                break;
6 J5 @$ t3 B0 r' W# A        }
/ H1 i0 t1 E' L+ g% X9 E- j+ t0 v        return 0;
    }
9 o3 U4 O& V3 F1 J2 ?3 V- E    else    // standard
( V7 l6 H. M2 y: D; g# ]    {
        switch(ep0_std_req->bRequest)
7 y/ g9 F2 G" {3 x1 k3 @        {
4 k' N" Y$ p5 B# u5 c            case REQ_GET_DESCRIPTOR:
                return descriptor_service();
                break;
            case REQ_SET_ADDRESS:
) o  h( F9 m8 ^: V  |3 x                if(ep0_std_req->bmRequestType!=0x00)
5 v: M# R) m4 r# x                    return 0;
% {. q/ }& h& T% l9 P                usb_address=ep0_std_req->wValue;
                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;
            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;
8 S: ^+ D# [4 a6 d$ o- x& ~/ p                USB_PMA[1]=0;   // Zero DATA
  n" ]' O' A. D! U, X8 x" h                ep0_state=4;    // No DATA phase
1 B2 n- _" U& Y2 p" p/ P                return 1;
            default: return 0;
        }
/ l; J; n/ X! j4 I% n3 x6 ~- E    }
! e, R+ ^! n3 d5 E( Z}


1 L" w' B9 g, t
4 F: D& O8 o( }0 @4 v8 ]0 V

miaozhuang

各种描述符，是USB开发首先要处理的
1 I: }6 R: i  Y5 ?1 i3 gchar descriptor_service(void)
{
    switch((ep0_std_req->wValue)>>8)
    {
- O/ b' y% o: S+ p! C        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
7 J/ E: f# N5 c9 [+ a            break;
        case DESC_TYPE_CONFIG:
9 ?- Q% [# [5 u  r: n            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
5 S8 ]( _) C) K; j. g) v3 o            else
- ^/ E# l% M! t' X& X+ B                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
            break;
        case DESC_TYPE_STRING:
            switch(ep0_std_req->wValue &0xff)
            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
6 c9 Y- l6 R8 z# n: i                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
                default: return 0;
            }
$ m0 @, t: Y0 n            break;
        case REPORT_DESC_TYPE:
0 o' y% ]0 ]* ^; z7 z! E7 L, [8 b            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
/ E/ o" l, f+ F! @5 q, |5 @9 o            return 0;
    }
}
下面说下我对键盘的处理。因为有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);

, e- w' D$ u5 M# q! S
    TIM6->SR &= ~TIM_SR_UIF;
    prev_key_state[scan_row]=key_state[scan_row];
: Q3 r: I5 r% O3 }( r5 x0 N    key_state[scan_row]= *PA_IDR;   // update key states
7 O5 Q, R$ H9 l" a' i6 F    switch(scan_row)
$ p7 \, ^7 ?1 R1 a2 G0 h8 f6 G    {
        case 13: // next row PB14
* s+ S& Z. o9 q/ D; o. W/ I2 ~                GPIOC->MODER = GPIOC_DEFAULT;
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
0 X8 X+ r7 B" H! V8 Z7 W  G                break;
        case  0: // next row PB15
$ K: D$ a/ Y* B                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
: t9 @/ U& S6 g( m                break;
        case  1: // next row PB3
: @# v$ ~/ r$ \) H" S' b                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
                break;
        case  2: // next row PB4
0 a3 J% L4 {2 p" i, s                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
% w* I; K# M) u; ^' F5 R* o                break;
3 ]' G  X2 ]+ W$ [, _; _9 W        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;
# e; Z- l! t8 S" F* i                break;
        case  5: // next row PB7
* h5 A$ {" R! W; x                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
                break;
        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
- L& w' A- m2 Q% W                break;
/ ]8 h" L5 G+ g9 q3 E        case  7: // next row PB9
0 V2 Z9 d# Y' @9 |                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
        case  8: // next row PA8
                GPIOB->MODER = GPIOB_DEFAULT;
0 V- |) z9 {) Z* d) {9 E                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
9 l3 h6 ]7 M8 \7 `" A  L& q        case  9: // next row PA9
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
0 D0 p: s  ~' r6 t! c+ G3 Q' [                break;
        case 10: // next row PA10
* i# M' w. d# ]2 S  f+ `0 J                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case 12: // next row PC13
                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
                break;
    }
+ P" @! z; y# u& r. M0 ^8 e1 Q9 s/ F    if(scan_row<13)
, C2 g+ E; Y' C! s7 r        scan_row++;
" Y& ^, s) e8 C" E    else
        scan_row=0;
}
7 f; J% H3 c% K

" I3 Y) L: W- x. U

miaozhuang

: l$ ?6 O; p  l" j' x+ y% q扫描的状态被Timer 6 ISR记录在 key_state[] 数组当中，上一次的状态保存为 prev_key_state[]. 这样在主程序中只要比较这两个数组，就知道是否键盘的状态有变化了。有变化（按下或者抬起）的时候，再调用 update_key_matrix() 函数去生成USB HID报告。
2 r& T* b; k" R" O% c0 U* U
要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

- B" _# }. ^6 B1 O
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},
4 P+ n$ p& s5 ]/ G4 d    {HK_Period, HK_V, HK_BSlash, HK_J, HK_P, HK_Q, HK_4, HK_F6},
% e  v6 J5 t: I" u' N" F# z    {HK_Comma, HK_C, HK_Quote, HK_H, HK_O, HK_Equal, HK_3, HK_F5},
8 h& B4 S* b! C" u: M    {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},
, \; I1 {! R( t$ ^2 A    {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},
5 B( O- i; S: s    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
% y1 z: v0 A" ?* }# j1 n. C) }7 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},
) c5 x* d$ V; R) K    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};
  ^2 T; [6 q7 s
( M/ ?( E4 h) h
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},
    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
& J- l$ A0 t5 N0 @7 ^' X0 z    {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},
" @0 n6 N7 @8 y    {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},
    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
* e5 S& j" y) j) c7 N    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
% D4 |% y/ ]  f; H1 w    {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},
    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
. ?5 F' W( T  u$ b6 E};
2 c6 s9 U6 T; C; I8 A
% |; i. O) L( B- {# L) }
上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
3 \! K% Z+ O# w7 I0 w
HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：

- E3 q( a) t+ I' x: [void update_key_matrix(char row, char col, char onoff)
{
    static uint16_t hid_report[4]={0,0,0,0};
3 r) @+ V2 J, i! h" d    static char (*hid_keymap)[8]=hid_keymap_dvorak;
3 \" x/ x6 V: {* S/ x

    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
8 Y3 L+ M4 a& e: k: N4 {0 I    char i;
3 n- w2 e, G# V: h! L' D
8 k# W3 N' b' F. Z; @2 R( A3 d
( t  f. i  z4 U# ~2 _2 N% W5 ~# ~  k    if(key==HK_MODE)
* T6 v( e+ Z5 J    {
        if(!onoff)
        {
" @1 r! ]4 Q5 Q7 m' [            if(hid_keymap==hid_keymap_dvorak)
2 c9 f' f! \$ B. y            {
" h! S; o/ ^' X+ p! r& c2 l                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
7 v: B- l% b* a            }
7 e4 L  j( w6 I  f/ w            else
) @" A$ i* A. J$ t$ s  R% K            {
                hid_keymap=hid_keymap_dvorak;
                GPIOB->BRR = (1<<2);
; @; K2 o( L0 D. h3 M            }
6 ~# K1 n/ P) Z6 g( G        }
        return;
9 B1 t6 a5 q) L' I% j4 k& B    }
/ H/ K: m. c  F) F7 k  O5 K
# O/ A! n6 }* s% E
% F; A4 o$ h- [& I5 a- L4 P5 o0 g    if(key>=0x80)   // Alt, Ctrl, Shift
    {
        uint8_t bitset = 1<<(key&7);
0 G" x: M7 @. H; Q( |- o7 L; {) ~        if(onoff)   // non-zero is key up
7 ?# G% w- _) \/ ^8 ^            report[0] &= (~bitset);
        else
7 `% e+ ~1 z  [* q  r/ @6 @            report[0] |= bitset;
    }
  R0 z" m% G9 ^# S/ B) L* ?    else
    {
        if(onoff)   // non-zero is key up
5 s5 O( W: u# c" {, }        {
2 _2 Y+ \  q: e2 O- u0 m: M            for(i=2;i<8;i++)
            {
                if(report==key)
/ T" P1 l& P, X/ Z. s5 G/ T6 {                {
- T: C6 O' X) y) q% h6 N$ ?                    report=0;
+ r5 l0 Y) r' J; K: \                    break;
                }
            }
2 D& T- p4 X( v1 P        }
        else
6 `, ~2 M3 [7 t        {
            for(i=2;i<8;i++)
1 P* N& U0 V: p" [8 H            {
- K) @% e- ]7 f* k2 ~                if(report==key)
                    break;
                if(report==0)
                {
8 J. g- N$ L# [                    report=key;
! f- L- a3 k( t' e: {# ]                    break;
+ X5 _; t) _( U% c) k                }
' B1 d$ R  r+ u/ p" r) N! i            }
        }
    }
. k8 t8 T( u" ^3 M7 c    for(i=0;i<4;i++)
8 P; e1 i# P$ W  V        USB_PMA[192+i]=hid_report;
    USB_PMA[5]=8;   //COUNT1_TX
9 I5 L! [& L0 n& U5 d    if(ep1_wait==0)
    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
        ep1_wait=1;
  o3 w# n5 L$ w7 h2 k: K$ D8 M; E    }
}
1 _( @5 ~( N, Z* ]2 e* W2 Y: b
8 v: I6 L% @0 I1 ?5 \$ o
完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6582)

2016-9-21 21:01 上传

点击文件名下载附件

) d' T  M; x, P, f! {

& l; B2 }' ?2 x: z
: h/ z) T( ^% \

miaozhuang

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

网络孤客

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

miaozhuang

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

) T, u3 u5 U8 Z/ W: L1 _哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核