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

miaozhuang

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

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

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

为什么得到这样一个字母排列？在当时的确经过了多次的优化改进，因为打字机是机械的动作，要尽量避免连续的击键引起冲突。结果是因为商业上的成功，QWERTY这个布局也跟着被越来越多的制造商吸收采用。在非英语语言的键盘上，个别键位可能不同，属大同小异了。最早的IBM PC键盘：
6 q, y1 v( r2 T! V7 h, g/ U3 i
/ H/ R" R4 q3 ^" h/ E其实在电传动打字机问世之后，打字键盘的键位布局就可以自由了。但是QWERTY的流行没有被改变——习惯的力量是强大的。虽然是大众所接受，QWERTY也有被人诟病的地方，比如说左右手分配不平衡，在英语里面单独用左手能打出来的单词远比单独用右手的多。那么，除了QWERTY还能用啥？在ANSI标准里面还有另外一个键盘布局，叫做DVORAK.
Dvorak(德沃夏克)布局，是以其发明人之一: August Dvorak 的姓命名的。在20世纪30年代，Dvorak 和 Dealey 在他们多年的研究工作基础上发明了Dvorak布局，目标是减少打字出错几率、提高速度和减少手的疲劳。最初发明的布局是这个样子：
. \! Y. D1 i* Z8 f1 G0 y
( Q8 Z+ M! J. Y, r4 ~Dvorak布局的最明显特征是让使用频率最高的键安排在中间的一排(Home row)，这样手指不用移动就触得到。当然还有左右手均衡的设计等等。尽管不是所有人都同意Dvorak布局能够比QWERTY布局提高键盘输入的效率，最快打字速度的记录的确是在Dvorak键盘上创造的。
. J/ L, {' i3 d' J; G! Z
) v0 g3 _- Q: F* v- s我是经常要写代码的人，对键盘要求比较高，一定要顺手。从1998年拥有电脑开始，第一块键盘用了5年，实在是塑料结构磨损严重了才换了。第二块键盘用了大概也有5年，第三块是淘宝买到的和第二块同样的。除了手感，我对键盘还有个挑剔是要大回车键(老键盘惯出来的)。到了用上笔记本电脑，键盘问题只能忍忍了。我最后买的一块Benq的”轻指飞扬"绝版键盘因为是USB，作为笔记本键盘替补一直保留到现在。
3 w' r0 B. @0 J' r
到2012年下半年，我在淘宝发现了有“机械键盘”这东东，认识了Cherry MX轴。然后到2013年农历年后，我花一百多一点买了一块老旧的国产青轴机械键盘，虽然很陈旧状态也差了，敲了一会儿我就发现：这就是我要的手感啊，一比起来用了多年的薄膜键盘简直太委屈手指了。我后来花了更多的钱买了新的轴(就是机械键盘的开关)来更换修复，使之成为上班工作用。

$ Q0 H2 _* Z6 H/ C机械键盘用着爽，后来我发现手指别扭的地方了，跟QWERTY键盘布局有关系。了解了Dvorak布局之后，我下定决心，换用Dvorak. 这个过程很漫长，大约是一年以后才抛开了QWERTY根深蒂固的影响。到如今两年多，我也没有肯定我的输入速度是否达到自己曾经QWERTY时候最快的水平，不过可以肯定的是换了Dvorak，手指头是舒服了。借个图说明两种布局的差别：
, M6 F. x9 g5 M+ Q/ C1 t' f/ E
----------------------------------------------------  分割线 ----------------------------------------------------------

! f5 {0 w- P# c7 J! B+ E先是改造的对象，主角: 这已经是拆解出机械键盘中的PCB板+钢板，并且拆掉了全部的键轴之后的样子。这块键盘买来时的成色相当差，很脏，惟有键帽还不错，但原本的轴已进灰，状态差。
5 C, k4 b) J" ~# G/ R8 Q5 K
轴全部拆下来之后才能将钢板和PCB分离，不然是被卡住的。原来键盘里面的灰比照片上还多得多。注意到这块DIP40的芯片，就是键盘的主控。
4 K  [! Q) r  Y4 ]5 O8 p$ {
3 L4 z* Y- l2 w/ C- n( {特写，80C49
8 N, B6 S" X" X  g* {
LED部分，使用了一片D触发器锁存指示灯状态.
; p# t5 z$ a) ~) S: m' a
暴力破坏，将80C49拆掉

拆掉原来的键盘主控，我用什么顶替呢？没有引脚全兼容的单片机了，而且我要制作USB键盘，所以……STM32F072，做块一样大小的PCB. 因为主要是使用原有的键盘扫描矩阵，有些引脚是不需要连的。

4 S' B" n. q7 X. c焊好元件后的板子，准备替换80C49

用剪下的电阻腿作连接吧，对好位把引脚都焊上。STM32F0的SWD接口务必要留出来下载程序的。
/ J  Y$ Z1 c* y: }
$ V0 ]3 D5 {$ M这是在软件开发当中调试的场景。USB线需要飞线，因为原来的键盘PCB上就没有USB.

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

% ^1 p* I$ ]" \6 R8 H4 F' c* c我设计的MCU PCB要在键盘PCB和钢板之间。除了SWD的引脚，把UART飞线出来供调试的不时之需。
# B- n3 s0 v  W0 F4 f: |* }8 v
主键区键帽就位
3 \) b# {1 K) C6 m
编辑键区也安装好，确认这里替换后不会有冲突。调试用的线和针脚以后是要拆掉的。

/ Y; K# V2 p0 C* W# Z% a最后的组装，USB线，以及切换键盘布局的附加按钮。部分键轴还没有装，低优先级的。

- q$ N5 t/ R. w9 B4 P8 G" O. n/ w+ b
' D6 |7 I( @+ V----------------------------------------------------- 分割线 --------------------------------------------------
3 t* C7 W; m, X5 o/ x
+ S7 F; Z2 o+ |" j# R
& P- J9 Z2 k9 S0 h7 |

9 r5 T$ u0 \' C8 Q6 h1 }7 d
. ^' i; g9 W9 {


+ j' U" L) H) j0 d/ E# P/ i
1 O: [8 v  g, M2 n: g. \

miaozhuang

DIY过程直播完了，下面说硬件的设计。
9 s% |: o4 i: ?- X+ H: E: d80C49是块MCU，貌似也就在PS/2键盘上面用。搜到其datasheet对引脚的定义：

$ F' p. t( c$ ~8 Y/ q. E3 c! M
其实最关心的还是键盘矩阵怎么接的，这个我就靠人肉了，在的PCB背面寻着每条扫描行或列线找，记录在草稿纸上。最终整理出来的结果是这样的：(最上边和最右边铅笔写的数字是引脚编号)


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

7 J; Y9 u1 }$ R3 ^- _这是我设计的电路图：
( s$ b, e9 F# \, q( d

PCB Layout:
6 |* k! s% K8 S' M* C
* j) Y. Z' Q4 O' e+ M$ f5 p
5 Q! o8 m% e! T不从80C49引脚上走的信号包括: SWD接口，USB D+/D-，USART TX/RX，额外两个可用I/O.
  v7 z1 V" g1 J0 w1 m

' S8 d$ j2 ?& v: J

miaozhuang

6 K- d& n/ }; \
& A+ B- e5 _6 W, E1 q# `% _软件上的工作比硬件多得多。因为想改造成USB键盘，不得不把USB HID的实现稍微看懂一下。PS/2模式硬件上也是保留的，暂时我还没去写软件。
( A# i) o8 \9 {$ u5 u1 Q2 K
+ P: y- X1 {" b4 w; b! L总结一下，USB HID键盘需要使用两种HID报告：一是从设备到主机的，按键状态的报告，8字节；二是主机到设备的，指示灯状态的报告，1字节。第一个报告我使用EP1(Endpoint 1, 端点1)来发送，中断传输；第二个报告就使用默认的EP0，控制传输。USB的描述符，可以从现有的USB键盘上修改而来。下面是用USBTreeView这个工具查看到的的我的这个键盘的描述符：


) l6 ^2 f8 A& ?1 o7 Q6 i! c其中USB报告描述符我没完全看懂，copy了现成的（这个也没必要自己重新写嘛）

, E* z/ y2 B/ q9 @& }USB的中断ISR，bare metal哦
, {$ W( {' U. h; R
/ }9 j; M2 m3 s; z* H# l6 B$ R  [void USB_IRQHandler(void)
{
3 _8 m: N! h2 U; |( d% V( Q    if(USB->ISTR & USB_ISTR_CTR)
    {
        if((USB->ISTR & 0x0f)==0)   // EP_ID==0
" x' b  E5 ^/ z( W        {
0 W4 O. @4 z; E- x' S5 u2 h            switch(ep0_state)
            {
: Y/ H  Y' [, G$ V+ H                case 0: ep0_state |= 0x80;
2 h) H/ F  }- |% K6 p" e% _                        break;
                case 1: if(USB->EP0R & USB_EP_CTR_TX)
                        {
2 }; B+ B6 u- B# a5 x: a                            USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                            ep0_state=3;
* N1 n/ U. T& h: S2 E                            return;
1 x( L. P! [5 r! ]: O8 k1 j                        }
* y4 \$ v+ t- }  c% I                        else
                            ep0_state=0;
0 R+ U9 o. B8 G  z  P                        break;
1 ?6 G$ u! ]% I; T                case 2: if((USB->EP0R & USB_EP_SETUP)==0)   // OUT packet
: ^- |5 r  f$ r3 H. a: ]$ w; g                            ep0_state |= 0x80;
                        else
2 C' L) R' k/ d3 C" ]# u                            ep0_state=0;
                        break;
0 c4 ]8 m. G8 x( Q" v/ K4 x: v                case 3: ep0_state=0;
$ `4 i  M( x1 g                        break;
                case 4: ep0_state=0;
& }0 W( x. e+ D! j9 M                        break;
                default:ep0_state=0;
                        break;
            }
0 z- g! h4 {; F            USB->EP0R = USB_EP_TYPE_CONTROL; // just clear flag
5 g! O9 N5 h  D            return;
; ~3 R& P# p# F4 g        }
7 \& r) X* A- x, U        else    // EP_ID can be 1
        {
6 C: e: `  _* ~# f; {, a. e; ~2 n            USB->EP1R = USB_EP_TYPE_INTERRUPT|1; // just clear flag
            ep1_wait=0;
            return;
% D) V) u  i0 ^* W; c) k        }
1 [" I* D+ D6 _  N    }
    if(USB->ISTR & USB_ISTR_PMAOVR)
7 m3 p2 \: H) N0 S( G    {
        USB->ISTR = ~USB_ISTR_PMAOVR;
    }
2 g3 }0 L& K+ \4 V% P    if(USB->ISTR & USB_ISTR_ERR)
0 W& f# S1 ^! X$ t" [    {
        USB->ISTR = ~USB_ISTR_ERR;  // write 0 to clear
  X! [& p+ _0 r    }
    if(USB->ISTR & USB_ISTR_WKUP)
# v6 ]. H% ?3 o' G! d8 ~    {
$ R5 ~. L+ R+ G2 i+ B) W        USB->CNTR &= ~USB_CNTR_FSUSP;   // no suspend
7 F" b5 N8 ^0 H6 y9 M        USB->ISTR = ~USB_ISTR_WKUP; // write 0 to clear
    }
3 @7 j  W, t/ v" W8 c. h( m$ {5 n; m    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
/ W5 [& q% U6 k6 C- P; P    }
1 [! l& P" R* U0 z; Z    if(USB->ISTR & USB_ISTR_RESET)
    {
+ O/ h$ g9 U/ ^        USB->BTABLE = 0;    // buffer table at bottom of PMA
6 x" N* j2 p5 s6 f! D1 U        USB_PMA[0]=128; //ADDR0_TX
5 e, t1 x8 n5 n. F# E" Z. u- p. y        USB_PMA[1]=0;   //COUNT0_TX
        USB_PMA[2]=256; //ADDR0_RX
6 A7 P" \$ g3 h& U! d) z        USB_PMA[3]=0x8000|(3<<10);  //RX buffer 128 bytes
        USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX1;
        ep0_state=0;
7 h! I/ p3 t0 C. J# W0 [3 A; v8 O        USB_PMA[4]=384; //ADDR1_TX
$ z+ z1 F5 a, V4 z  G/ p        USB_PMA[5]=0;   //COUNT1_TX
: y+ o5 `( g4 ]6 w        USB->EP1R = USB_EP_TYPE_INTERRUPT|1;    // EP1 type
        ep1_wait=0;
        USB->DADDR = USB_DADDR_EF;      // enable function
$ C+ r/ i# Z7 }3 a6 t7 X( j        USB->ISTR = ~USB_ISTR_RESET;    // write 0 to clear
    }
    if(USB->ISTR & USB_ISTR_SOF)
" E8 {/ f9 u  r0 _. W1 H    {
        USB->ISTR = ~USB_ISTR_SOF;  // write 0 to clear
    }
& |2 L2 d" R7 s% w0 n2 t" F# N9 g}
/ z$ N; `  H) n
因为只有两个EP需要管，数据量也很小，STM32F0的PMA(Packet Memory Area)固定分配好就不动了，读写数据都直接在PMA上读写。在USB Reset中断的时候，把PMA和EP都重新初始化。
# P, B/ N! L3 o, q2 H0 P
, S  z, z, @4 j8 d主程序中用一个无限循环，每次中断过后处理一下USB请求，以及来自键盘扫描的检测。
; X  s* g: j$ C8 T+ Q8 _
- v/ f" e/ M5 {$ `& a3 f* n3 t    while(1)
) d8 D$ x9 r& U* m5 l, {    {
        static char row=0;
' J( G& ]: N( u, A/ U  @        __WFI();
        if(ep0_state & 0x80)    // request data processing
% p, R# \$ s) D4 P$ h: w        {
# ^- j% \, ?, u3 E; w' [            if(ep0_state==0x80) // SETUP phase
            {
                if(!setup_packet_service())
, I) K/ f9 ^% k& w; F: p                {
                    ep0_state=0;
                    // not supported
                }
                // ep0_state should be set to 1 or 2, if processed
            }
% z2 ~( I, @6 w- x# T7 \, I            else    // OUT phase
            {
; f0 |) i( \8 f! P  T2 K7 `                // process data
                show_LED(*(uint8_t *)(USB_PMA+128));
                ep0_state=4;
                USB_PMA[1]=0;       // Zero length DATA0
+ i  e) u" N) e$ v                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
            }
8 Z+ D7 c5 n$ S% M3 t* |        }
        else
        {
7 E' _' v6 _8 a- |2 M) k$ u1 M            if(usb_address && ep0_state==0)
            {
                USB->DADDR = USB_DADDR_EF|usb_address;
# ]0 J* B- E; Z# o1 S8 p- I                usb_address=0;
            }
6 w- V' Y* {+ t# C        }
        if(row!=scan_row)   // new scan line
        {
            if(key_state[row]!=prev_key_state[row])
            {
                uint8_t test=0x80;
                uint8_t diff=key_state[row]^prev_key_state[row];
  o& L: a# S) Q' }2 z                for(i=0;i<8;i++)
                {
                    if(diff & test)
: {1 }( W3 m- q& z- b                        update_key_matrix(row,i,key_state[row]&test);
                    test>>=1;
& C( o$ h% U3 T) ]) i0 i& N( Q- j' A                }
7 s2 _. s% S- E: @; g  m% C. K/ x            }
, z8 s  c8 c, H+ D9 O0 o  E, \            row=scan_row;
. V! O8 `5 B) u$ b1 n        }
6 R# c8 R. T* m" U8 s4 m/ R# x    }
) p0 }1 @! o! S! Q- n# _
& g5 _4 R: n; Z5 }; c' k9 G( Y
EP0的控制传输，把用到的请求处理一下
% i  K5 y" n8 @7 `9 nchar setup_packet_service(void)
{
    if(ep0_std_req->bmRequestType & 0x20)   // class-specific
( Y/ d# J7 z: L    {
8 o* n1 B: s- S7 D. I        switch(ep0_std_req->bRequest)
        {
# k0 L& }! H- a            case REQ_GET_REPORT: break;
7 }+ F; W+ M) t. @. ]1 n            case REQ_GET_IDLE:
0 G" n% w- x& t. [                USB_PMA[64]=0xfa;   // return 1 byte
8 p( B  N0 s0 d9 b9 M5 ?1 J% j                USB_PMA[1]=1;
! _# K2 [- r0 N- T                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
, b* [0 x9 J/ \8 O                ep0_state=1;
                return 1;
9 D4 Q4 ]  u# p* x                break;
/ Q% }" D0 |5 k0 d; Q: H  b1 R, t7 [            case REQ_SET_REPORT:
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_RX0;
                ep0_state=2;
                return 1;
                break;
            case REQ_SET_IDLE:
                USB_PMA[1]=0;   // Zero DATA
                USB->EP0R = USB_EP_TYPE_CONTROL|USB_EP_STAT_TX0;
                ep0_state=4;
                return 1;
# \' V. p' V7 r0 k) G6 ]$ ]8 Z# `                break;
        }
        return 0;
    }
    else    // standard
! V$ S' Z: ?: H! H% U' \* }2 `    {
        switch(ep0_std_req->bRequest)
        {
" e! e6 w$ M- u( S2 v            case REQ_GET_DESCRIPTOR:
: c, k. ]# e5 M4 Y; U  x% [' ?4 o; r/ B  p                return descriptor_service();
- V' X$ p) h* r9 F) c6 b+ {                break;
% o) }2 p# I( l; z& P" ~5 V            case REQ_SET_ADDRESS:
) @. Y9 A& a, B& h' z7 m+ X                if(ep0_std_req->bmRequestType!=0x00)
                    return 0;
                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;
* w2 c8 ^; t/ }6 s2 O6 m  U9 O            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 ~2 J3 `& Z; E7 p8 e                USB_PMA[1]=0;   // Zero DATA
4 {: i! y9 d! A7 \& m" |7 [                ep0_state=4;    // No DATA phase
                return 1;
            default: return 0;
) b& ~; a$ M' X1 s        }
7 y' Q" }& Z$ |$ W+ ]    }
& a3 O; T$ }3 r1 A% `$ G}

% j! d& V+ i/ p' Q. v" l

- a9 Y% P( k! r; m: ?

miaozhuang

各种描述符，是USB开发首先要处理的
char descriptor_service(void)
# q  B: P. q. Z: K; C{
5 h7 c( P: f- z5 s    switch((ep0_std_req->wValue)>>8)
( ~; a( e* |; `5 b: h1 m# G    {
3 n. P+ q0 j2 l$ Q9 t4 d# G        case DESC_TYPE_DEVICE:
            return ep0_preparedata(&DevDesc, sizeof(DevDesc));
            break;
3 W/ Q/ z4 T, J& L% K- x        case DESC_TYPE_CONFIG:
- }* D3 s4 E, r: f" i% ^0 r            if(sizeof(ConfigDescData)>ep0_std_req->wLength)
                return ep0_preparedata(&ConfigDescData, ep0_std_req->wLength);
            else
                return ep0_preparedata(&ConfigDescData, sizeof(ConfigDescData));
            break;
) v9 E, S( R0 R3 t! F        case DESC_TYPE_STRING:
) s- N: S- M! ~$ \0 m            switch(ep0_std_req->wValue &0xff)
8 K. _2 |9 \: f3 [            {
# q$ w7 P' }. S, o$ R                case 0 : return ep0_preparedata(&LangIDDesc, sizeof(LangIDDesc));
# ^/ K6 ?+ s" V) f- L- S                case 1 : return ep0_preparedata(&UnicodeVendorDesc, sizeof(UnicodeVendorDesc));
                case 2 : return ep0_preparedata(&UnicodeProdDesc, sizeof(UnicodeProdDesc));
5 h& X2 Y  u( z                default: return 0;
" t) O- N1 A  ]5 g, i) ?/ Z            }
            break;
        case REPORT_DESC_TYPE:
            return ep0_preparedata(&HidReportDesc, sizeof(HidReportDesc));
        default:
. W1 k" k$ K( m& X' k0 ^  F. G: ]# c            return 0;
3 i: b' v* |: C0 A    }
}
下面说下我对键盘的处理。因为有14+8条线，其中8条一组我称为列，用PA0~7读取；另外14条我称为行，在一个时刻只有1条为低电平(输出)，其它13条为高阻。在列扫描线上加上上拉，因此没有键按下的时候，PA0~7都是高电平的。若某键被按下，当在所在的行被扫描时，对应的列就会变成低。我用了Timer6中断，每0.5ms切换一次扫描线，这样扫描一遍矩阵键盘用7ms.
* m5 b& `7 A, w" B+ [  Z  t* f' Mvoid TIM6_DAC_IRQHandler(void)
0 A5 D7 r$ h# q{
    __IO uint8_t *PA_IDR = (uint8_t *)&(GPIOA->IDR);

* I9 C2 F3 A* C' O: }* e) n
0 D9 D7 p  `0 `2 o! p4 z& ~    TIM6->SR &= ~TIM_SR_UIF;
5 q1 C% g! I* l5 E, @$ U9 ?    prev_key_state[scan_row]=key_state[scan_row];
    key_state[scan_row]= *PA_IDR;   // update key states
$ i7 r0 ]1 D; a  w    switch(scan_row)
/ N. H& Q9 B7 S3 B& |3 i4 R* W    {
        case 13: // next row PB14
4 s9 r1 Y  [" d) i                GPIOC->MODER = GPIOC_DEFAULT;
4 _+ d4 I2 [: t" l                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER14_0;
                break;
9 x1 H  g% \$ A& I4 S& ]        case  0: // next row PB15
7 g; o3 E, f( m$ i- x/ ^" H, Y' T                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER15_0;
9 V3 R7 Y0 z: |! _4 ~# P' K# g& W1 g$ m1 u                break;
. W/ |' C4 h- N        case  1: // next row PB3
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER3_0;
& z* V3 D3 J2 b; a! z                break;
+ \. E4 w2 c5 [5 X        case  2: // next row PB4
                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
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER6_0;
                break;
! S, M" @* f0 w' o$ T; z1 {7 W        case  5: // next row PB7
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER7_0;
6 U- H- z) e. [$ i: W                break;
        case  6: // next row PB8
2 ^( A+ _& N( U( h( N4 i$ q; G- `% I                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER8_0;
8 F+ }* o4 ]5 p/ g8 x4 _  C; _5 H                break;
/ W# ]' ]1 k0 k7 W0 o        case  7: // next row PB9
                GPIOB->MODER = GPIOB_DEFAULT|GPIO_MODER_MODER9_0;
                break;
; V7 v! C( ?1 ]; G: o        case  8: // next row PA8
                GPIOB->MODER = GPIOB_DEFAULT;
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER8_0;
                break;
3 J7 g& k/ g( s! n, ~        case  9: // next row PA9
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER9_0;
+ v4 f# ]- Q! V( Q* w" B                break;
3 {, _3 [  i+ |8 ^        case 10: // next row PA10
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER10_0;
                break;
        case 11: // next row PA15
                GPIOA->MODER = GPIOA_DEFAULT|GPIO_MODER_MODER15_0;
                break;
        case 12: // next row PC13
% N: V( r1 Y1 V/ Z. ?                GPIOA->MODER = GPIOA_DEFAULT;
                GPIOC->MODER = GPIOC_DEFAULT|GPIO_MODER_MODER13_0;
2 S% o0 u1 a( g, q                break;
    }
& g; s: k! W- B: P    if(scan_row<13)
        scan_row++;
    else
        scan_row=0;
}

% `) Y: o. u# N; [& ?( h) B

miaozhuang

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

6 e9 F5 I2 Q- f0 @! ^4 H- D* o8 u要从键盘的扫描行、列坐标得到按键的编码（此处不是ASCII，也不是PS/2的键盘扫描码，而是USB HID定义的键盘Usage ID），需要用到查找表。我需要切换Dvorak和QWERTY两个布局，因此需要准备两个查找表：

  A% l/ s+ v! ~; f' S% g) r
1 x8 [0 v: q/ }1 S  i+ kconst char hid_keymap_qwerty[14][8]={
2 {) _" U8 u  }  ]2 \1 O" U6 e' c    {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 Y2 `1 K; s0 j7 L7 S5 l0 f6 k, O    {HK_Period, HK_V, HK_BSlash, HK_J, HK_P, HK_Q, HK_4, HK_F6},
    {HK_Comma, HK_C, HK_Quote, HK_H, HK_O, HK_Equal, HK_3, HK_F5},
    {HK_M, HK_X, HK_Colon, HK_G, HK_I, HK_Minus, HK_2, HK_F4},
4 F. L/ H6 y) \0 V6 ^' f    {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},
# \: R4 y' y. d, g- 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},
    {HK_Right, HK_Down, HK_Left, HKR_Num, HKR_Plus, HK_NONE, HK_NONE, HK_NONE},
4 H) u3 }) g. H    {HK_PgDn, HK_End, HK_F11, HKR_9, HKR_Minus, HKR_8, HKR_7, HK_NONE},
2 e% k- i' m$ ^; F, M2 C! w    {HK_Space, HK_N, HK_Z, HK_L, HK_RBr, HK_E, HK_6, HK_F8},
    {HK_Slash, HK_B, HK_Delete, HK_K, HK_LBr, HK_W, HK_5, HK_F7},
    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
};

! u3 |! c0 l! w( W* w+ l4 }" s! o; w
, r  `; f% n" v8 u) p+ d/ Xconst char hid_keymap_dvorak[14][8]={
- ]3 ~2 m" [$ G% X8 u    {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},
$ h9 J- N6 U9 @! T0 o    {HK_V, HK_K, HK_BSlash, HK_H, HK_L, HK_Quote, HK_4, HK_F6},
- Z- m2 D" W. @" q, {: x    {HK_W, HK_J, HK_Minus, HK_D, HK_R, HK_RBr, HK_3, HK_F5},
4 ^4 i% w: L' o  P9 u    {HK_M, HK_Q, HK_S, HK_I, HK_C, HK_LBr, HK_2, HK_F4},
3 \6 b8 c4 K! s' h9 l4 f& r    {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},
- \! t+ t3 j- w7 C9 P$ m5 G* s    {HK_NONE, HK_RAlt, HK_LCtrl, HK_O, HK_Y, HK_8, HK_Enter, HK_F1},
/ w6 }2 v/ z: `8 R3 ^    {HK_PgUp, HK_Home, HK_Insert, HKR_5, HKR_6, HKR_4, HK_F10, HKR_Dot},
# M! P( T7 O$ i3 D2 J    {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},
' X% F1 T0 T! {) `    {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},
  Q  ?: C- F5 Y* {    {HK_Pause, HK_Tab, HK_PrtScr, HKR_2, HKR_3, HKR_1, HKR_0, HK_MODE}
. m- M; O3 X9 p1 u% R};

" L% v( Y/ Y% W: V8 t
上面的宏定义另写在 translate.h 头文件中。HK_NONE是没有实际按键的位置，HK_MODE是我另外加的一个键，用来切换两个键盘布局。这个“一键切换”的键加装，可以用原来键盘上的AT/XT开关，也可以用我预留的User I/O，做到后来发现用键盘矩阵的空闲位置更方便。
. l8 ?+ @% H) n" I7 v7 A
HID报告的8个字节，第一个是8个特殊键的状态(Shift, Alt, Ctrl, GUI)，第二个保留，后6个每个非0值是一个按下的键的Usage ID. 产生HID报告的子程序：
: S2 Y- a, T" C5 @
void update_key_matrix(char row, char col, char onoff)
{
6 g" F2 O: O: Q7 U    static uint16_t hid_report[4]={0,0,0,0};
8 [( W8 v* A: R1 f+ k. y. l4 Q    static char (*hid_keymap)[8]=hid_keymap_dvorak;


. z8 M$ M) @0 E    unsigned char key=hid_keymap[row][col];
5 e( \7 _. _3 e+ ~+ @8 |    unsigned char *report =(unsigned char *)hid_report;
" B" ^+ S# |; U8 J* ~1 e    char i;


: u* x7 q& G/ @9 l2 |+ z: k+ N    if(key==HK_MODE)
    {
* x0 x: H" \8 p, m1 d        if(!onoff)
        {
& ?: _6 y& B) g: {) K: m5 J            if(hid_keymap==hid_keymap_dvorak)
            {
& p( Q5 a6 e9 G( I1 I                hid_keymap=hid_keymap_qwerty;
                GPIOB->BSRR = (1<<2);
            }
& u$ S' B  i: N8 p8 x% v            else
            {
                hid_keymap=hid_keymap_dvorak;
4 L1 H& n3 C0 Z. F" g# R                GPIOB->BRR = (1<<2);
6 @/ d' C' s- G3 [            }
        }
" V3 U4 ~9 G* t        return;
    }
) A2 L! ]( ~9 ^9 @5 V

( F+ X% k; V6 t% m3 x    if(key>=0x80)   // Alt, Ctrl, Shift
) d7 Y2 J$ T3 H1 A4 `) L4 ^    {
        uint8_t bitset = 1<<(key&7);
        if(onoff)   // non-zero is key up
# q5 _) I2 R, v            report[0] &= (~bitset);
        else
! c! V0 \2 b6 Y, o            report[0] |= bitset;
    }
    else
    {
        if(onoff)   // non-zero is key up
$ r2 |6 u9 B; w. U' v        {
9 t6 y. x" P9 i            for(i=2;i<8;i++)
            {
                if(report==key)
                {
# E% k) A; F" K; o$ U, J                    report=0;
2 ?7 f0 m3 X; S) g; J' h                    break;
- P/ [1 P) o: B                }
            }
6 y% c0 A) C' ~( M, ?        }
        else
        {
0 N3 k& J. O* ^1 |# P/ R# f            for(i=2;i<8;i++)
            {
8 \0 s' h, S% V+ E                if(report==key)
                    break;
                if(report==0)
                {
                    report=key;
# ~7 E% h. r% o! a) H                    break;
                }
            }
        }
- u3 f/ H( ~6 a* ?    }
6 Q1 u) F3 [3 I1 M1 N0 \# u, U    for(i=0;i<4;i++)
+ b- i8 R+ z. H6 F$ m- j        USB_PMA[192+i]=hid_report;
* D6 W9 c! k, K0 _9 J+ h9 U9 t    USB_PMA[5]=8;   //COUNT1_TX
' I4 w9 a& k. u8 u5 t! r! i) ?    if(ep1_wait==0)
: b8 h( K- h' @0 Q3 P0 }3 n    {
        USB->EP1R = USB_EP_TYPE_INTERRUPT|USB_EP_STAT_TX0|1;
' ^. m: ]* W: l# O' P" n+ W        ep1_wait=1;
$ P8 C1 K5 e% v! P    }
/ N  ~& i! i9 r' ?3 a}

1 m- N9 p( ^6 x6 P( w/ R
. E# b& ^1 h: \  \完整的程序在附件中。我这个程序没有使用任何USB的库函数，完全是从底层操作，这样对USB的工作细节可以了解得比较清楚，当然，也费了很多工夫啦。
keyboard.zip (8.7 KB, 下载次数: 6420)

2016-9-21 21:01 上传

点击文件名下载附件

: n/ V; g3 ^$ E# e1 d
$ g: |9 p: ?( \% [
  y2 o* c" O( \: b# c

% j) Z0 F8 x  n. H: E  {

miaozhuang

在电子论坛上看到的，这对于改造键盘的小伙伴来说，提供了很大的帮助，步骤很详细，拆解换主控，设计pcb板，编写固件，看的是很过瘾。
+ e/ d5 h( c& e+ q7 A% c4 G# k, Q

网络孤客

刚开始我以为要把打字机改造成电脑键盘
, t* ]% E6 ~( P2 H& P+ |不过楼主也很厉害！

miaozhuang

网络孤客 发表于 2016-9-22 13:48
0 a- e) q8 l' N5 V5 [% G刚开始我以为要把打字机改造成电脑键盘
/ V3 H) }5 ]# Z8 m& I  H不过楼主也很厉害！

哈哈  是有点像奥

Mr.Prince

很厉害
; h$ u& v! ]! N7 b

thermoer

这个看着真硬核