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

miaozhuang

* `+ f# ]6 U' F  R+ u
( S9 A& r  h* ]1 {7 A$ Ihttp://bbs.eeworld.com.cn/forum. ... digest%26digest%3D1
/ v6 ]2 u2 _8 [4 f这个DIY项目的想法已经有很久了，如今终于达到了的设计的初衷。要体现“任性”的特点，先介绍背景吧。

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


8 Z1 a& ?) e2 ^% @( o- O# n上面这个照片(来自wikipedia)，是"Sholes and Glidden Type-Writer."，第一个获得成功的商用打字机(1873)。请注意它的键盘字母键排列。

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

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

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

) r$ A4 ?5 _7 W) }/ K----------------------------------------------------  分割线 ----------------------------------------------------------

先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
) d4 p3 w& L2 [7 `  }: b
轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
2 X. h  J/ H* @
特写，80C49
' v0 F) A& Q2 b+ |7 [& p# }
LED部分，使用了一片D触发器锁存指示灯状态.
) }" f. b; ?- s" I4 V
  T+ O* }0 q+ J' I/ H0 c, _/ \7 i暴力破坏，将80C49拆掉
& z7 m! g" J  T9 T# W
& B# d: j  c0 a2 N. T拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

1 b& ~. C; D6 t- R  `, n焊好元件后的板子，准备替换80C49
$ t7 g" t( N$ n1 D8 }( \) {+ h5 z
用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。
: X+ K& P! r( e4 u
这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

开始安装钢板，主键区焊上全新的Cherry MX茶轴(2.5 RMB一颗)。F区暂且空着，因为使用频率不高，换新轴就显得浪费了，等下再把部分旧轴清洗一下装回去。

我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
- j) k, k* L; m! r0 U
0 I2 r: U* ?1 |6 w: w9 V主键区键帽就位
+ c2 Z, j/ J* J4 y8 W
编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。
9 g; C3 `- E8 E# t5 M" O4 _' Z
% d# f3 N0 O: j8 F6 E) Y8 A4 n$ N最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。
) p6 a- U2 c! ~1 `' p$ F
6 n. Q; W7 {' d4 S: F* Z
# [3 _) \# W* P! {( w/ k& E----------------------------------------------------- 分割线 --------------------------------------------------
) N  T- E  Y, q0 S5 X
" a$ w8 B; s9 r+ S- Y6 ^


' |9 k0 y; |* v- J6 y) @
. q! j8 A% j/ Z5 N- r+ ]/ V

# l4 p6 [  h* I


% [4 C& c) o: v( d- |* [

miaozhuang

DIY过程直播完了，下面说硬件的设计。
7 z, v: I) Q8 [7 Y80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：


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

  k0 G& X; i' b2 K8 ^2 P5 _扫描矩阵是8x14的，最多可以支持112个按键，实际上只有101个键，空出了一些。对照上面那个引脚定义，可以把用到的I/O口确定了。除了电源引脚，剩下还有几个引脚使用到：PS/2的CLK和DATA占用2个，状态指示LED的电路占用1个，AT/XT开关使用了一个。我用STM32F072C8，有48个引脚刚好是够的，富余的I/O就飞线引出了。
! u- T: U" E1 J' {: {6 }
4 r6 l& B& {0 G' Y这是我设计的电路图：

8 |4 ^/ I# r+ C# x: B# c6 a4 E# ~: }
& s+ }' X& e3 M1 d7 H( APCB Layout:
- b( l" l. G2 ?8 \* S

6 N) [% _. O7 `1 y, D2 N不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
4 N. D; @+ ?" G: I. P9 I: _

miaozhuang

软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。

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


$ p& N, p3 W( ^+ t8 s其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）
: z' f% q7 H4 ]: b! k- }% _2 z
USB的中断ISR，bare metal哦

void USB_IRQHandler(void)
) ~8 F6 ]$ N" a+ i% n{
    if(USB->ISTR & USB_ISTR_CTR)
5 U5 L5 W7 ]; I8 x9 D    {
! I1 e( t  b2 Z( P        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
9 M, `) N# l6 u/ w$ h& y& P+ _        {
/ u; |6 }7 S3 }9 d3 ^; v            switch(ep0_state)
            {
& U2 k5 e! N" S! Y! A                case 0: ep0_state |= 0x80;
& V7 w' |! C8 s4 c9 y                        break;
9 _% c4 L2 E) e5 C' v( f% e                case 1: if(USB->EP0R & USB_EP_CTR_TX)
. \  q- p, J+ c/ y                        {
* \& h/ h& L; X: O2 g                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
1 {- i8 d9 J- K1 d9 m; Z* C                            ep0_state=3;
8 L# d: u# p6 k/ J! a: X                            return;
                        }
                        else
                            ep0_state=0;
                        break;
! r3 C4 P" \1 p                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
2 l5 {$ L  `) h4 c0 `1 l* @0 i. E                            ep0_state |= 0x80;
/ b7 S% x5 [- `5 K2 i                        else
                            ep0_state=0;
* R8 w, _2 A: n2 ~1 H2 t: o                        break;
                case 3: ep0_state=0;
                        break;
                case 4: ep0_state=0;
                        break;
5 {9 H' b% S& a, t6 g0 D5 w                default:ep0_state=0;
                        break;
            }
% q: P9 L3 p. s) [, o4 C3 g. {; G: b            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
            return;
        }
) u* _7 ]! m3 k: z, q( d  t        else    // EP_ID can be 1
        {
            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
6 T' g) E0 b  `7 I  B0 |& j9 W& n            ep1_wait=0;
            return;
9 m7 [' [0 }0 y+ Q, t+ e9 Z2 B        }
    }
; a. h  V) s5 H; \4 ?    if(USB->ISTR & USB_ISTR_PMAOVR)
    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
0 N7 m2 f' ^" l' a0 D2 s    }
; H4 z2 _5 d# S1 }5 Y8 g    if(USB->ISTR & USB_ISTR_ERR)
- x; j5 B% C8 h, b; x    {
( i* v8 u! V0 b, y" s- ~% Z, ]" L        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
* Y+ p* G$ n) m; c4 M1 |5 z    }
    if(USB->ISTR & USB_ISTR_WKUP)
    {
; D" d. n8 R& ~0 K4 r4 F. K        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
& y  ^' h7 m/ ^4 t    }
    if(USB->ISTR & USB_ISTR_SUSP)
  ]7 H9 T# g+ a( k- I    {
8 h' D6 U& v+ z; U- J& x' C' l+ c        USB->CNTR |= USB_CNTR_FSUSP;    // force suspend
; G/ Q" b0 s+ i0 l* R3 J6 l        USB->CNTR |= USB_CNTR_LPMODE;   // low power
2 _1 X/ ~) r; T        USB->ISTR = ~USB_ISTR_SUSP; // write 0 to clear
0 Q  \" O2 \" E% c4 W    }
    if(USB->ISTR & USB_ISTR_RESET)
0 ]9 s: A$ J" S- x    {
        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
        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
* b2 `+ e* d  r) y5 e4 {( [        ep0_state=0;
        USB_PMA[4]=384; //ADDR1_TX
        USB_PMA[5]=0;   //COUNT1_TX
        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
3 y2 y- N% }9 {' }) D+ g( x        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
) c' _* C7 ~" ?9 @        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
    }
3 p" q2 u, C) S- l5 b. A- v( }    if(USB->ISTR & USB_ISTR_SOF)
    {
        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
. m6 F! b/ m: {/ f& z& c}

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

9 M$ D9 _( r/ P! W8 w主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。

1 B  Q) _0 I, V8 l" r" \    while(1)
    {
        static char row=0;
        __WFI();
        if(ep0_state & 0x80)    // request data processing
        {
! J# F& _* w# E8 J* z- X) g7 d            if(ep0_state==0x80) // SETUP phase
            {
/ B5 t& w1 A$ ]4 B0 Y/ o                if(!setup_packet_service())
4 \5 u: q% Y: h/ C: J: G& ~4 ?' W                {
8 n# N: E7 e! z, v* ]                    ep0_state=0;
                    // not supported
: j; H. a& e/ q. A3 o                }
                // ep0_state should be set to 1 or 2, if processed
5 q) W+ c) t1 t/ v            }
  `; U! F( z, d/ L  z! g            else    // OUT phase
/ R2 d' B4 L) f$ p8 r, H5 {            {
$ U" b( g% ^2 C3 ]# O3 K% H7 r                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
* o5 S$ d5 N" l2 ^9 u3 L                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
        }
        else
! E  i# T9 Z0 ?1 w' ^1 h        {
            if(usb_address && ep0_state==0)
! C% f; L! t2 c            {
+ G8 W0 X/ g3 r* {                USB->DADDR = USB_DADDR_EF|usb_address;
                usb_address=0;
            }
" K4 @# t) h* c/ N8 |/ e, F! K# }        }
, H8 ^# [- V1 f( G+ C        if(row!=scan_row)   // new scan line
' Z# W6 i8 [% \' C7 o  ^- k        {
            if(key_state[row]!=prev_key_state[row])
1 c2 M' x" \5 y3 g9 I8 x5 Q            {
                uint8_t test=0x80;
( c6 s/ Q! H5 T* n: U1 J! n                uint8_t diff=key_state[row]^prev_key_state[row];
& U7 U" Z, f! r$ n9 \                for(i=0;i<8;i++)
                {
/ V( _  t; M, f2 h                    if(diff & test)
                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
, n5 q2 b  B2 M* `; ~                }
            }
            row=scan_row;
        }
    }

, Q" e+ s' c& W* ]: h1 F
EP0的控制传输，把用到的请求处理一下
char setup_packet_service(void)
. g* S  r7 H2 l" M; e{
# J: V- q# b% H/ {1 R    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
    {
7 _+ X+ O& ~1 ]# x% D        switch(ep0_std_req->bRequest)
        {
# P; ]' t& [8 d. r# y" n- |            case REQ_GET_REPORT: break;
            case REQ_GET_IDLE:
                USB_PMA[64]=0xfa;   // return 1 byte
- \! {& S0 s: q" a% x                USB_PMA[1]=1;
8 L( A. ^+ v( v& g5 @' J3 `7 I* ?                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
, m+ ~+ _) d5 z3 I1 E                ep0_state=1;
" V: Z9 O1 x: a' ^- `4 r6 u                return 1;
                break;
7 u: w) z3 l2 e5 M7 a" a            case REQ_SET_REPORT:
+ ~. d2 E: g( C# l; s                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
4 @4 r' P' i, m( }  F4 F                ep0_state=2;
! t* n1 T% }9 p                return 1;
                break;
) e. A0 U$ u# R" d0 n; f$ x- E            case REQ_SET_IDLE:
# L# [& i- y* Z0 E4 X& W) v                USB_PMA[1]=0;   // Zero DATA
% ~9 \# n+ }* m2 L# _                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
6 @4 g/ Z! X0 \$ y3 e6 d                return 1;
7 x/ @# }+ I% @$ O* p                break;
        }
, {! J! C, m% V1 ~        return 0;
    }
6 D0 J( I, p- ]    else    // standard
4 o# T, f2 T+ w' H9 L+ W    {
        switch(ep0_std_req->bRequest)
        {
            case REQ_GET_DESCRIPTOR:
% h4 J; j0 b4 {& k  Z7 F                return descriptor_service();
3 F7 M8 o7 D0 k. l3 H                break;
  b7 k. b6 C' V1 @" b( I) K' S$ W            case REQ_SET_ADDRESS:
                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
# K' b( D, f* `) U% n# m                usb_address=ep0_std_req->wValue;
" y5 v2 |+ X1 r9 F9 x/ l: V; Y                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;       // Zero length DATA0
) C( h8 y/ X  E3 o7 H                ep0_state=4;    // No Data phase
                return 1;
8 t/ L+ Y  H- n0 Y/ h            case REQ_SET_CONFIGURATION:
0 i  G8 {/ S) z4 |$ i                if(ep0_std_req->bmRequestType!=0x00)
+ ^' `0 K0 C+ f6 T. F                    return 0;
( m' c6 d9 B' d) n1 i% o; o                USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX1|1;
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                USB_PMA[1]=0;   // Zero DATA
                ep0_state=4;    // No DATA phase
                return 1;
            default: return 0;
        }
  f8 b8 T: \) r; I" w6 E    }
}


0 F* K& n  r5 W) u

miaozhuang

各种描述符，是USB开发首先要处理的
char descriptor_service(void)
3 N3 m3 F9 U' |7 _- `5 G3 N% o{
! b$ v. T$ @& J" U- D% e. V7 m    switch((ep0_std_req->wValue)>>8)
    {
        case DESC_TYPE_DEVICE:
% ~" L) B, U; Y3 h            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
, G" [/ i" R' V3 D# l            break;
5 W) G  b$ L4 e8 Z3 o        case DESC_TYPE_CONFIG:
, V: T, h0 N" e# `            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
. P( B6 F: \0 b# Q                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
8 I, R6 e, S% B8 t7 B            else
9 b1 w" y) U  Q/ J) P2 U                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
; M$ Z- N& y: }' G; d            break;
        case DESC_TYPE_STRING:
            switch(ep0_std_req->wValue &0xff)
3 n& l/ {9 i( Z9 o2 s$ X            {
                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
2 b( _# r( `: w, _; S$ E9 \                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
$ g7 \9 D! w+ v                default: return 0;
            }
            break;
1 _5 `& x# ]- D1 J" E9 k) i        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
- u# D& @, U3 |5 t            return 0;
: l) R" j. D, B+ V9 i- M$ X( P    }
. B5 I  @8 B! R& A}
1 g$ r2 A4 t$ w; U! P下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
void TIM6_DAC_IRQHandler(void)
: ^' O" V+ H' H3 O4 s, d: C{
    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);
( S+ @! L& D/ c1 s
5 o; E# g  ~& M8 j( D% W4 q) Y
5 l$ J+ R2 e  Q" ^    TIM6->SR &= ~TIM_SR_UIF;
& q) {' {, z/ l; @    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
& \' c$ B1 T+ d4 a    switch(scan_row)
    {
. g4 L4 S/ c8 p$ R% T3 |( ^        case 13: // next row PB14
1 ^1 O: e. e* c3 L7 K& Y/ k; e$ F                GPIOC->MODER = GPIOC_DEFAULT;
2 e0 p; ]# P# l# }8 F& N$ x                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
/ O7 l" P0 x5 H1 V# p) f: o* }                break;
! V! L/ ?9 I* D  o% L% Y        case  0: // next row PB15
/ y# E) _9 L6 g+ b; w2 ?3 B                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
                break;
        case  2: // next row PB4
/ J/ J- ?* ^& w                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER4_0;
                break;
        case  3: // next row PB5
: L0 ~5 R8 O8 d                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER5_0;
, T$ o$ A; ~) I% U4 D" M                break;
8 _" x  V/ g. L- A4 r0 o8 \        case  4: // next row PB6
7 f: H8 ?/ @+ Q# O$ \                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
                break;
3 k; n; X; \" [9 D, C        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
6 s' P* t: e' A8 q5 j1 [2 d3 F                break;
- I' Z. x7 o& r7 U        case  6: // next row PB8
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
                break;
% S3 x* n  r6 k0 T& @        case  7: // next row PB9
2 r) ~8 \+ o& N                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
        case  8: // next row PA8
                GPIOB->MODER = GPIOB_DEFAULT;
* d8 B' O$ a; m  ?# v                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
        case  9: // next row PA9
' W( C) p, w9 I3 K  h                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
1 S" G" O& S$ i                break;
        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
% j9 e7 {' E# p! f+ ]/ b) G                break;
4 \! K9 K/ B- k* q- l2 l$ {) N        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
( B( \) P9 z1 v                break;
        case 12: // next row PC13
" u. c& L! v2 |                GPIOA->MODER = GPIOA_DEFAULT;
/ ]' [$ |& ?! z2 y& S8 }: W                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
- [1 t) E# B7 e1 @  W                break;
3 c- u6 h; a5 m+ ^0 R6 J    }
6 b3 G) Y! P: @5 d% w    if(scan_row<13)
6 _" d/ P+ n. P$ @        scan_row++;
    else
: n5 c8 o. B/ V5 e        scan_row=0;
}


7 m/ A3 L; C% X7 Y$ S1 a) s

miaozhuang

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

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

: k2 i2 E9 G" ^9 q4 `$ o1 g
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},
5 T' N8 |; d" Z: J9 `' M    {HK_Period, HK_V, HK_BSlash, HK_J, HK_P, HK_Q, HK_4, HK_F6},
: b6 p0 V% l+ k2 V# F    {HK_Comma, HK_C, HK_Quote, HK_H, HK_O, HK_Equal, HK_3, HK_F5},
    {HK_M, HK_X, HK_Colon, HK_G, HK_I, HK_Minus, HK_2, HK_F4},
    {HK_LShift, HK_NONE, HK_Caps, HK_F, HK_U, HK_0, HK_1, HK_F3},
3 P0 W! P& v/ \+ O% `! C3 r% f    {HK_Scroll, HK_LAlt, HK_RCtrl, HK_D, HK_Y, HK_9, HK_BQuote, HK_F2},
3 i: ~! |1 ~5 a' o% d% g( Z    {HK_NONE, HK_RAlt, HK_LCtrl, HK_S, HK_T, HK_8, HK_Enter, HK_F1},
( D& ^7 v0 P0 j+ X  B. c3 c! }    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
. h" p! s4 Z1 r& k* g0 r8 `# [& K    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
' g/ G% C0 T8 o    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
( m2 U  ]2 G8 S    {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},
; e5 M6 }( S5 p$ K; z9 {    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};


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},
4 r& r1 d! C1 e% g; t/ S. `    {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},
    {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},
    {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},
4 E: \! |  W+ X7 k2 ]" @: U/ m% Z    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
2 U4 F/ j  M( p& k; i    {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},
3 q  S2 [! W& P. L, ~    {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}
( A2 S: S& R1 w" ^$ X0 Y& C/ d};

7 }1 ?) w. b. ]! B$ q3 l; H
上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
' i4 g" Y$ r! ^' q: r- A
HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
% t4 C# R3 H# m9 c6 i: j! e( V; R
void update_key_matrix(char row, char col, char onoff)
{
    static uint16_t hid_report[4]={0,0,0,0};
- u0 t# }! K! ^) {    static char (*hid_keymap)[8]=hid_keymap_dvorak;


    unsigned char key=hid_keymap[row][col];
    unsigned char *report =(unsigned char *)hid_report;
" J; C4 V! o& _    char i;

  y8 j' l; T+ x
3 ]1 B( q: G8 c- w# W; z    if(key==HK_MODE)
& [9 y9 l: _4 F& y    {
        if(!onoff)
        {
            if(hid_keymap==hid_keymap_dvorak)
            {
8 y) G/ W, W$ r! X                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
            }
            else
            {
' W2 I8 ?  k$ Q                hid_keymap=hid_keymap_dvorak;
                GPIOB->BRR = (1<<2);
            }
        }
        return;
5 W% m3 b' x7 j$ e: D1 J, K    }
# c1 ^& x; P  n7 a

    if(key>=0x80)   // Alt, Ctrl, Shift
    {
        uint8_t bitset = 1<<(key&7);
        if(onoff)   // non-zero is key up
: Q) ]$ t& p; w  ~7 ~            report[0] &= (~bitset);
  ?" J2 G, G# i: o        else
            report[0] |= bitset;
  [+ m& o, n  U8 `& G    }
    else
    {
        if(onoff)   // non-zero is key up
        {
            for(i=2;i<8;i++)
# H/ _5 G; i1 M) I4 d1 i            {
                if(report==key)
                {
3 o! K7 t" E" x+ s! S, V                    report=0;
                    break;
8 o+ N7 y+ ~) e+ F' a* `& @" L                }
            }
        }
) A) M+ J+ @# |3 @) S        else
2 q( w/ Z$ m! _% p        {
            for(i=2;i<8;i++)
            {
                if(report==key)
% Z( z0 r1 O; K                    break;
0 s, v  e1 z) h                if(report==0)
" j& Z# n1 \- g" c0 }' J3 U5 g                {
0 @" ?( B( o6 B/ C$ ]  {% i                    report=key;
  Q- S; M$ F/ _  d/ ?& |& s) @1 N                    break;
                }
            }
        }
    }
4 d4 {/ L+ ^7 ^# u! Y  c" I4 N    for(i=0;i<4;i++)
        USB_PMA[192+i]=hid_report;
9 c4 I/ f, k( [* S2 V+ f  Z0 s    USB_PMA[5]=8;   //COUNT1_TX
9 J) {9 K, x6 G& m/ E* |5 G6 K    if(ep1_wait==0)
    {
5 n! {0 I  U2 Q1 O' W& a, E- }) L        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
        ep1_wait=1;
    }
}
2 z' C) w9 A/ P+ |- o" o

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

2016-9-21 21:01 上传

点击文件名下载附件

+ g: \& a5 O, ]; c! C' b" A, O5 ^
) A9 [2 A! s2 Q- F8 M
9 }5 O1 |  e) u/ }  n1 z8 Y* U

miaozhuang

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

网络孤客

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

miaozhuang

网络孤客 发表于 2016-9-22 13:48
4 \2 X5 S! l6 P+ |5 _4 }# W刚开始我以为要把打字机改造成电脑键盘
8 _) E' Q/ \9 D: L" q1 C不过楼主也很厉害！

* [2 K2 R7 Z- z# S! F4 O5 S8 ^哈哈  是有点像奥

Mr.Prince

很厉害

thermoer

这个看着真硬核