转——SCAN_CODE模块

House

1 x' P5 p2 q. H' w* q% R  O3 o
4 q( E' }( Q6 c5 i+ L1 d' }; ~

转——SCAN_CODE模块

本篇主要基于上两篇ps2keyboard控制器和vga控制器的基础上增加了一个基于mips32指令集只有20条指令的单周期cpu模块。实现一个在屏幕上显示PS2键盘扫描码的功能。

特别声明：本篇涉及的代码全部来源于《计算机原理与设计—verilog HDL》以及该书作者李亚民老师。我做的工作是尽可能理解这些代码的意思，并且将之简单解释清楚，文中的插图和文字是我自己书写的真实感悟，并未抄袭任何其他资料。同时，对代码中涉及到的时序、接口信号衔接等问题我也做了细致的比对和验证，最终在DE1-SOC开发板上实现了这些功能。此外，我将在后续的文章中，基于本文的工作增添自己需要的功能如中断机制，定时器等），在这个基本的单周期cpu上做自己的升华。希望感兴趣的各位同仁也能联系我，我们一起把这个diysoc做得越来越好。

第一部分：CPU 介绍

( f8 C6 ]. ?9 g+ [# m6 p

1.20条整数指令介绍：

       add/sub/and/or/xor  rd, rs, rt                    #rd < - - rs op rt

       sll / srl / sra  rd, rt, sa                             # rd < -- rt shift sa

       lui rt, imm                                             #rt < -- imm<<16

       addi rt, rs ,imm                                      #rt < -- rs + imm(符号拓展)

       andi/ori/xori rt, rs, imm                           #rt< -- rs op imm(零拓展)

       lw rt,offset(rs)                                       # rt < -- memory[rs+offset]

       sw rt, offset(rs)                                     #memory[rs+offset] < -- rt

       beq rs, rt, label                                      #if (rs = = rs),PC< -- label

       bne rs, rt, label                                      #if (rs != rs),PC< -- label

       j target                                                #PC < --target      

       jal target                                              #r31 < -- PC+8 ; PC < -- target

       jr rs                                                    #PC < -- rs

5 k7 A. V4 R4 l* u

# S6 b, F2 g# _: {( }

1）MIPS是32位CPU，所以指令的长度，操作数，寄存器的位数都是32位的。

2）共有32个寄存器，即r0~r31;  r0的值恒为0x00000000，r31存返回地址。

3）rs, rt表示源操作寄存器， rd表示目标操作寄存器。例如 add r3,r4,r5 就是 (r4) &（r5）-- > r3， r4中的内容与r5中的内容赋值给r3这个寄存器。

4）sll/srl/sra r1,r2,8  # r2逻辑左移/逻辑右移/算数左移 8位赋值给r1  

5) lui r3, 0x4000  把0x4000左移16位赋值给r3，置高16位数据。

     通常后面跟一句 ori r3, r3,0x3476 马上做或运算。  两条运算拼起来就可以吧0x40003476这个数据完整赋值给r3了。

6) andi r1,r2,0x4768  立即数操作，操作数一个是如r2的寄存器号，一个是常数0x4768立即数。

7）lw r1,3(r4)   lw(load words)读外部存储器  把(r4中的内容+3)这个地址中的数据读到r1中。

8) sw r1,3(r4)  sw(store words) 写外部存储器  把r1的数据写到 ((r4)+3)这个地址中去。

9）beq r1,r3, loop1 如果r1等于r3,则程序调到loop1标号出的程序段。可以实现分支语句

10）bne r1,r3,loop1,同理，不相等则跳转。

11） j  loop1  直接跳转到loop1那个位置

12）jal  loop1 先把当前位置下一条指令的PC存到r31,然后跳转到loop1,然后如果在loop1程序段加一句 j  r31, 就可以实现执行完子程序后自动返回到跳转之前的下一条指令执行了。
( _: \6 t$ M% ~13）每一条汇编语句都对应了一条机器码，   

助记符 指令格式 示例 示例含义 操作及其解释 Bit # 31..26 25..21 20..16 15..11 10..6 5..0 1 j: M' y8 X$ W6 v R-type op rs rt rd shamt func add 000000 rs rt rd 00000 100000 add $1,$2,$3 $1=$2+$3 rd <- rs + rt   ；其中rs＝$2，rt=$3, rd=$1 addu 000000 rs rt rd 00000 100001 addu $1,$2,$3 $1=$2+$3 rd <- rs + rt   ；其中rs＝$2，rt=$3, rd=$1,无符号数 sub 000000 rs rt rd 00000 100010 sub $1,$2,$3 $1=$2-$3 rd <- rs - rt   ；其中rs＝$2，rt=$3, rd=$1 subu 000000 rs rt rd 00000 100011 subu $1,$2,$3 $1=$2-$3 rd <- rs - rt   ；其中rs＝$2，rt=$3, rd=$1,无符号数 and 000000 rs rt rd 00000 100100 and $1,$2,$3 $1=$2 & $3 rd <- rs & rt   ；其中rs＝$2，rt=$3, rd=$1 or 000000 rs rt rd 00000 100101 or $1,$2,$3 $1=$2 | $3 rd <- rs | rt   ；其中rs＝$2，rt=$3, rd=$1 xor 000000 rs rt rd 00000 100110 xor $1,$2,$3 $1=$2 ^ $3 rd <- rs xor rt   ；其中rs＝$2，rt=$3, rd=$1(异或） nor 000000 rs rt rd 00000 100111 nor $1,$2,$3 $1=~($2 | $3) rd <- not(rs | rt)   ；其中rs＝$2，rt=$3, rd=$1(或非） slt 000000 rs rt rd 00000 101010 slt $1,$2,$3 if($2<$3) 6 e- q/ R/ B0 O$ N& q5 ~( G  $1=1 else    $1=0 if (rs < rt) rd=1 else rd=0 ；其中rs＝$2，rt=$3, rd=$1 sltu 000000 rs rt rd 00000 101011 sltu $1,$2,$3 if($2<$3) , w: y, ^% q  b- f( H  $1=1 else    $1=0 if (rs < rt) rd=1 else rd=0 ；其中rs＝$2，rt=$3, rd=$1 ' J/ a) X" O7 k* i1 q& b& J  (无符号数） sll 000000 00000 rt rd shamt 000000 sll $1,$2,10 $1=$2<<10 rd <- rt << shamt  ；shamt存放移位的位数， 8 C3 [% E* _. {  也就是指令中的立即数，其中rt=$2, rd=$1 srl 000000 00000 rt rd shamt 000010 srl $1,$2,10 $1=$2>>10 rd <- rt >> shamt ；(logical) ，其中rt=$2, rd=$1 sra 000000 00000 rt rd shamt 000011 sra $1,$2,10 $1=$2>>10 rd <- rt >> shamt  ；(arithmetic) 注意符号位保留 其中rt=$2, rd=$1 sllv 000000 rs rt rd 00000 000100 sllv $1,$2,$3 $1=$2<<$3 rd <- rt << rs  ；其中rs＝$3，rt=$2, rd=$1 srlv 000000 rs rt rd 00000 000110 srlv $1,$2,$3 $1=$2>>$3 rd <- rt >> rs  ；(logical)其中rs＝$3，rt=$2, rd=$1 srav 000000 rs rt rd 00000 000111 srav $1,$2,$3 $1=$2>>$3 rd <- rt >> rs  ；(arithmetic) 注意符号位保留 其中rs＝$3，rt=$2, rd=$1 jr 000000 rs 00000 00000 00000 001000 jr $31 goto $31 PC <- rs I-type op rs rt immediate : T6 Q1 W$ h3 s4 `- l % q4 A/ P7 G2 ?8 a3 s7 `) ` addi 001000 rs rt immediate addi $1,$2,100 $1=$2+100 rt <- rs + (sign-extend)immediate ；其中rt=$1,rs=$2 addiu 001001 rs rt immediate addiu $1,$2,100 $1=$2+100 rt <- rs + (zero-extend)immediate ；其中rt=$1,rs=$2 andi 001100 rs rt immediate andi $1,$2,10 $1=$2 & 10 rt <- rs & (zero-extend)immediate ；其中rt=$1,rs=$2 ori 001101 rs rt immediate andi $1,$2,10 $1=$2 | 10 rt <- rs | (zero-extend)immediate ；其中rt=$1,rs=$2 xori 001110 rs rt immediate andi $1,$2,10 $1=$2 ^ 10 rt <- rs xor (zero-extend)immediate ；其中rt=$1,rs=$2 lui 001111 00000 rt immediate lui $1,100 $1=100*65536 rt <- immediate*65536 ；将16位立即数放到目标寄存器高16          位，目标寄存器的低16位填0 lw 100011 rs rt immediate lw $1,10($2) $1=memory[$2 +10] rt <- memory[rs + (sign-extend)immediate] ；rt=$1,rs=$2 sw 101011 rs rt immediate sw $1,10($2) memory[$2+10] =$1 memory[rs + (sign-extend)immediate] <- rt ；rt=$1,rs=$2 beq 000100 rs rt immediate beq $1,$2,10 if($1==$2)   . J# y7 Y" {  v; R; j5 y goto PC+4+40 if (rs == rt) PC <- PC+4 + (sign-extend)immediate<<2 bne 000101 rs rt immediate bne $1,$2,10 if($1!=$2) % Q0 e5 r  o9 B+ E5 R& T goto PC+4+40 if (rs != rt) PC <- PC+4 + (sign-extend)immediate<<2 slti 001010 rs rt immediate slti $1,$2,10 if($2<10)   $1=1 else ) [, c- p: o$ S. j- ^   $1=0 if (rs <(sign-extend)immediate) rt=1 else rt=0 ； ) W( f& z7 f+ k( t5 F) x, Q1 ^   其中rs＝$2，rt=$1 sltiu 001011 rs rt immediate sltiu $1,$2,10 if($2<10) 3 N0 @  Z+ H  _' w  $1=1 else   @# K! V4 q" C& p- _/ g   $1=0 if (rs <(zero-extend)immediate) rt=1 else rt=0 ； $ u9 p% p# A' Q1 @" f  其中rs＝$2，rt=$1 J-type op address 6 d; W- u; C, `9 p0 ` j 000010 address j 10000 goto 10000 PC <- (PC+4)[31..28],address,0,0   ；address=10000/4 jal 000011 address jal 10000 $31<-PC+4; # q5 r; U1 J7 A1 Z9 C; t  ]% i; A goto 10000 $31<-PC+4；PC <- (PC+4)[31..28],address,0,0    ；address=10000/4 , i* X4 \: ^: i. L# f  N

注意：因为MIPS16只有16个16位的寄存器，所以JAL指令中$31改成$15, 所有立即数均无需扩展，LUI指令直接就是将立即数付给RT寄存器。
2 J( ?4 ~- J7 V+ c1 ^$ V

这个格式会指导verilog编写的时候如何解析指令，进行操作。

2下面来讲讲cpu代码和功能实现

上图列出了基本模块。 CPU和指令存储器连在一起，发一个pc地址，马上获得inst 指令。CPU右边端口包括和地址映射有关的io_rdn, 外部存储器的读写数据段d_f_mem,d_t_mem, 外部存储器的写控制端，wvram, 和外部存储器的地址端m_addr。不过具体和PS2，vga_c如何连在一起，会在后面讲如何连接。现在这里主要讲cpu内部的结构。

// instruction format

    wire  [05:00] opcode = inst[31:26];

    wire  [04:00] rs         = inst[25:21];

    wire  [04:00] rt         = inst[20:16];

    wire  [04:00] rd        = inst[15:11];

    wire  [04:00] sa         = inst[10:06];

    wire  [05:00] func      = inst[05:00];

    wire  [15:00] imm       = inst[15:00];

    wire  [25:00] addr     = inst[25:00];

    wire          sign          = inst[15];

    wire  [31:00] offset   = {{14{sign}},imm,2'b00};

    wire  [31:00] j_addr = {pc_plus_4[31:28],addr,2'b00};

1）首先对inst进行解读，解析各个为的信息具体的是什么，存在具体的变量中。

// instruction decode

    wire i_add  = (opcode == 6'h00) & (func == 6'h20);  // add

    wire i_sub  = (opcode == 6'h00) & (func == 6'h22);  // sub

    wire i_and  = (opcode == 6'h00) & (func == 6'h24);  // and

    wire i_or   = (opcode == 6'h00) & (func == 6'h25);  // or

    wire i_xor  = (opcode == 6'h00) & (func == 6'h26);  // xor

    wire i_sll  = (opcode == 6'h00) & (func == 6'h00);  // sll

    wire i_srl  = (opcode == 6'h00) & (func == 6'h02);  // srl

    wire i_sra  = (opcode == 6'h00) & (func == 6'h03);  // sra

    wire i_jr   = (opcode == 6'h00) & (func == 6'h08);  // jr

    wire i_addi = (opcode == 6'h08);                    // addi

    wire i_andi = (opcode == 6'h0c);                    // andi

    wire i_ori  = (opcode == 6'h0d);                    // ori

    wire i_xori = (opcode == 6'h0e);                    // xori

    wire i_lw   = (opcode == 6'h23);                    // lw

    wire i_sw   = (opcode == 6'h2b);                    // sw

    wire i_beq  = (opcode == 6'h04);                    // beq

    wire i_bne  = (opcode == 6'h05);                    // bne

    wire i_lui  = (opcode == 6'h0f);                    // lui

    wire i_j    = (opcode == 6'h02);                    // j

    wire i_jal  = (opcode == 6'h03);                    // jal

2）解析操作码和功能码具体代表什么操作，赋值给操作指令的变量，i_add,i_sub之类的变量。如果i_add置1了，则说明指令希望cpu做加法操作。

always @(*) begin

        alu_out = 0;                                    // alu output

        dest_rn = rd;                                   // dest reg number

        wreg    = 0;                                    // write regfile

        wmem    = 0;                                    // write memory (sw)

        rmem    = 0;                                    // read  memory (lw)

        next_pc = pc_plus_4;

        case (1'b1)

            i_add: begin                                // add

                alu_out = a + b;

                wreg    = 1; end

            i_sub: begin                                // sub

                alu_out = a - b;

                wreg    = 1; end

            i_and: begin                                // and

                alu_out = a & b;

                wreg    = 1; end

            i_or: begin                                 // or

                alu_out = a | b;

                wreg    = 1; end

            i_xor: begin                                // xor

0 U; Y, H& A0 O8 P* Z

3）组合逻辑，一路Case下去，执行对应的操作，如果i_add置1，则做加法操作，令alu_out =a+b;

// data written to register file

    wire   [31:0] data_2_RF = i_lw ? d_f_mem : alu_out;

    // register file

    reg    [31:0] regfile [1:31];                       // $1 - $31

    wire   [31:0] a = (rs==0) ? 0 : regfile[rs];        // read port

    wire   [31:0] b = (rt==0) ? 0 : regfile[rt];        // read port

    always @ (posedge clk) begin

        if (wreg && (dest_rn != 0)) begin

            regfile[dest_rn] <= data_2_rf;              // write port

        end

    end

+ o+ {; m! d6 k% ~& N7 p

8 d* }; Q2 Z1 Y- x% @

4）r0~r31寄存器堆的读写。定义了1-31个regfile寄存器。如果wreg写寄存器信号1，且dest_rn目标寄存器号（即rd）不为0，则写入数据。data_2_rf一般情况都是alu_out。但在i_lw(从外部存储器取数)这条指令情况下，为外部存储器读到的数据。

% w) Q$ S, ]: y, b) w0 D

5)下面讲讲pc的变化。

reg [31:0] pc;

    always @ (posedge clk or negedge clrn) begin

        if (!clrn) pc <= 0;

        else         pc <= next_pc;

    end

一般情况pc=next_pc=pc+4;

在跳转指令的情况下，next_pc由具体inst指令计算得出

; b  D7 d- ]5 X: z' i. ?

i_bne: begin                                // bne

                if (a != b)

                  next_pc = pc_plus_4 + offset; end

(6)下面讲讲地址映射，与外部存储器和io相关的几个信号: m_addr,d_f_mem, d_t_mem, write,  io_rdn, io_wrn,rvram, wvram。这几个信号比较关键，如果以后大家需要应用这个cpu接自己的设备就需要在这几个信号上稍微做一些变化，就可以把自己的controller搭载到这套cpu机制上去啦。希望越来越多的人能够喜欢并且把这套机制运用起来。（ps: 虽然已经有nios, ARM之类现成的soc机制，但是如果能够自己用纯verilog实现soc并且慢慢堆积controller做大做强，这难道不是我们学习verilog是最初的梦想吗？haha）

5 {1 [3 K' e. h! j% h

向外部存储器写数据。涉及到d_t_mem, m_addr, wvram。就是数据信号，地址信号，写使能信号。（这些都是必须的）

涉及到的指令为sw, 如sw r1,4(r3)。 我们现在都知道它执行的操作时 r1-- >memory[r3+4]。

具体执行时是这样的，如果是sw指令，且r3+4的地址确实是有定义了的。则wvram置1，

m_addr是 r3+4的计算结果作为存储地址。 d_t_mem是r1中的数据，作为存储的数据。

0 M& ?) S. \* t$ k: n0 L5 x

m_addr

看下面，执行sw指令时，cpu先计算一下alu_out=r3+4算出地址。然后把alu_out告诉m_addr

i_sw: begin                                 // sw

                alu_out = a +{{16{sign}},imm};

                wmem    = 1; end

, B( y3 k* U: b+ D1 y) F& {

assign m_addr  =   alu_out;           // memory address

( x0 I) W9 M5 V+ t

wvram

有了地址后，外部有没有实际对应存储器呢？这个要看设计者，后面为了显示在显示器上，我们定义了一个vram(显存)，地址是0xc0000_0000 – 0xdfff_ffff。所以用一下代码，标识当地址最高三位为110时，也就是110x_xxxx, vr_space说明地址正确。

wire vr_space = alu_out[31] & alu_out[30] &~alu_out[29];             

当然，代码也可以写成

wire vr_space = (（alu_out <=32’hdfff_ffff)&& (alu_out>=32’hc000_0000))，

思路清楚，但略微费些逻辑资源。

9 s$ q; t" b! m# ^
0 V: Y' M" z( y; a' |+ ]! n

最后赋值给写使能信号wvram,下面这条说的是指令有些外部存储器操作（sw），且写的地址也对，那就把wvram置1吧。

assign wvram   =  wmem & vr_space;                // video ram write

! T- p9 |+ B* @# V+ q

d_t_mem

wire  [31:0] b = (rt==0) ? 0 : regfile[rt];     

assign d_t_mem =   b;         

d_t_mem就是rt寄存器中的数据，swr1,4(r3)这个例子中就是r1寄存器的数据啦。

! }& x) l3 k; }( L7 l
# h. l* E2 N1 K; Y

从外部存储器读数据。涉及到d_f_mem, m_addr, rvram。就是数据信号，地址信号，写使能信号。（这些都是必须的）

有了前面的基础，从外部存储器读也是一样的事情了。

涉及到的指令为lw, 如lw r1,4(r3)。 我们现在都知道它执行的操作时 memory[r3+4]-- > r1

具体执行时是这样的，如果检测到lw指令，且r3+4中的地址确实是有定义了的。则rvram置1，m_addr是 r3+4的计算结果作为存储地址。 d_f_mem赋值给r1，作为得到的外部数据。

    相关的代码为

rvram

wire  vr_space = alu_out[31]& alu_out[30] &~alu_out[29];

  i_lw: begin                                 // lw

                alu_out = a +{{16{sign}},imm};

                dest_rn = rt;

                rmem    = 1;

                wreg    = 1; end

  c) I# Q2 z, P8 W& u  `& C& F; S$ T

assign rvram   =   rmem & vr_space;   

m_addr:

       assignm_addr  =   alu_out;  

d_f_mem:

wire   [31:0] data_2_rf = i_lw? d_f_mem : alu_out;

8 j  Z4 O4 w. h; y$ l& n; e  X- v

插一句，操作外部设备时，有时候控制器的读写使能信号是低电平有效，比如我们的ps2_keyboard, 是rdn,所以cpu中的读写使能位要稍微变一下。

% E7 E- p! f' t+ W  k

assign io_rdn  = ~(rmem &io_space);                // i/o read

assignio_wrn  = ~(wmem & io_space);                // i/o write

8 \) L7 [+ B" c9 Z# {/ o

对于读写使能信号的操作，目前来说是把0x0000_0000 ~0xffff_ffff全地址分成一块一块，然后对应地址对应不同读写使能信号。也就是说有几个设备（存储器，i/o等）就要有几个读写使能位。将来，读者还可以把这个机制稍微封装一下，用总线来整体控制，这样效果会更好。

  Z) l7 a2 M1 l9 |% h

特别要讲一下时序！！！

   a)整个cpu部分代码，就只有两个地方有时序逻辑。第1处，每个时钟周期（20ns），pc更新一次。写寄存器堆时。寄存器堆的读写是同步写，异步读。写寄存器堆时，由于是时序逻辑，则这条指令中存的数据会在下条指令运行开始真正存入。但是由于读寄存器是组合逻辑，则下条指令如果要读上条指令的数据也完全没问题了。

第1处：

always @ (posedge clk or negedge clrn)begin

       if (!clrn) pc <= 0;

       else         pc <= next_pc;

end

0 [1 E6 S2 K. C& l. l7 A

第2处：

wire  [31:0] a = (rs==0) ? 0 : regfile[rs];        // read port

   wire   [31:0] b = (rt==0) ? 0 :regfile[rt];        // read port

   always @ (posedge clk) begin

       if (wreg && (dest_rn != 0)) begin

           regfile[dest_rn] <= data_2_rf;             // write port

       end

   end

% C) S# g# D( a8 ]: R

   b)读外部数据时

注意外部存储器的时钟的设置。

   写时钟：频率可以和系统时钟（50MHZ）一样。

   读时钟：可以是异步读。如果是同步读的话读时钟要么在系统时钟相移90度。要么频率大于系统时钟。读时钟如果和系统时钟一样，会导致有效数据卡死在门里面，无法正确进入寄存器堆。

   另外，ps2_keyboard controller的读比较特殊，是对fifo的读，不需要提供地址，本例中ps2_keyboard中的fifo是异步读的，所以完全可以满足cpu读数据的需求。

: B' B( t) d/ P! {& S
% P% [9 J- j9 F2 q
+ E2 q8 }& k8 c: ^; T

至此，cpu部分就介绍的差不多了。总结一下，该cpu实现了20条mips指令的功能。并且具有外部存储器和i/o设备的拓展能力。

4 U7 C2 U. N- w7 U6 v

第二部分：外部IO设备的挂接

$ `* P( G: Q0 A. l  ^

" c( @/ ~; n  @& n9 T

1. ps2键盘的外接。把io_rdn接入rdn;把data,ready拼接后连接至d_f_m (data from memory)。

定义ps2_keyboard的地址为0xa0000000。

即使用

   lui   $1, 0xa000      ($1和r1是一个意思)

  lw   $2,  0(r1)      

两句话就可以是io_rdn置低，并且读到fifo中的数据。读到之后判断ready为1时，才是有效的data数据，否则则舍去。

2 L( J8 Y( }( U9 O0 ?2 J

（这种要求cpu不断读数据才能知道是否有有有效数据的方法将在后面的文章中将被中断机制替代，即ready为1时自动触发中断，程序跳入中断服务程序）。

& q5 q, L5 r1 {

2. vga显示器的外接。在《VGA的图片显示》一文中已经提出了使用一个显示存储器的方法来保存需要处理的数据。为了在vga屏幕上显示字符。需要涉及到取模，和vga的字符显示模块设计。

. M8 Z4 y- d' ]. {

上图是这里用font_table和char_ram拼成一个vram显存空间。具体如下，640*480的vga显示空间，定义8*8点阵字库。

font_table模块

font_table中存入了每个ascii 字符对应的点阵数据:

输入信息为：ascii    ascii码

row： 字库行地址 0-7

col：字库列地址  0-7

输出信息为：0/1      0表示蓝色，1表示白色。为了减少存储器占用大小。

0 ]1 G; |7 E3 h, s2 q6 z

charram 是显存模块。字符形式下，vga上能显示80行60列字符数据。因此charram的大小为80*60=4800个地址，每个地址大小为7位，用于存ascii码数值。值得一提的是，为了满足cpu的读写时序，char ram这个存储器最好是“同步写，异步读”的存储器。如果实在不能做到（因为如果要使用片内memory bit只能通过同步写同步读的方式引用），也可以同步写同步读，只要把读时钟为系统时钟的2倍频就可以了。本例使用同步写，异步读的方式。

. f/ }9 v" d3 \& x

上图展示的是在正常情况下，vga_c向显存请求数据并显示的流程。注意char_ram和font_table都被定义为异步读，即组合逻辑。vga_c向显存提交要显示的地址row(0-479), col(0-639)。char_ram拿到row[8:3],col[9:3]并计算出线性排列后的地址

char_addr[12:0]=row[8:3]*80+col[9:3]，输出对应ascii码，font_table获得ascii码和row[2:0],col[2:0]字库地址后，输出1或0在该位显示的颜色值。交给vga_c显示。

0 p; `  Z  o: q) l
: Y3 S9 @7 v" A' E  Y

与cpu的对接：

* E1 H9 I9 [: ?$ }- X  j7 m( z

把wram写信号接到char_ram write端，把d_t_mem信号接入到data_in端。由于d_f_m的数据源有ps2和char ram两个，故此设置了一个数据选择器，用io_rdn作控制端。

char_ram的address信号也有连个源，平常情况下有vga_c提供地址，而在cpu需要写显存使由m_addr提供地址。故此处也设置了一个数据选择器，用wram来做控制信号。

定义char_ram的地址为：c0000000 – dfffffff

既可以通过类似如下代码：

lui   $3,  0xc000

addi $7,  $0,  0x7F    # del   

sw  $7, 0 ($3)        

来在屏幕第一个位置显示一个字符

6 K% E& J7 I9 t

至此，硬件部分全部设置好了。

7 a4 L  |2 M4 P" I7 A
9 z/ I7 D4 ~$ P1 B$ F! b
* p* g  Y' P( N3 `- @3 H

第三部分：ps2键盘显示扫描码的软件部分

.text                                      # code segment

main:

   lui   $3,  0xc000                      #显存首地址: c0000000 - dfffffff

   lui   $4,  0xa000                      # ps2键盘地址：a0000000

read_kbd:

   lw    $5,  0($4)                       # 读键盘数据 {0,ready,byte}

andi  $6, $5,  0x100                  # $6 =ready

   beq   $6,  $0, read_kbd               # if ready==0,继续read_kbd

andi  $6, $5,  0xff                   #如果ready=1,则令$6==data

srl   $5, $6,  4                      # $5=($6>>4)取高四位数据。

   addi  $7,  $5, -10                     #$7=$5-10

srl   $7, $7,  31                      #$7=($7>>31)

beq   $7, $0,  abcdef1  # $7=0，则表示数据大于10，肯定是字母。反之显示数字

   addi  $5,  $5, 0x30                   #加上0的ascii起始值

   j     print1

abcdef1:

   addi  $5,  $5, 0x37                   # 加上a的ascii起始值

print1:

   jal   display                          # 显示字符

   andi  $5,  $6, 0xf                    # 显示第二位

   addi  $7,  $5, -10

   srl   $7,  $7,  31

   beq   $7,  $0, abcdef2

   addi  $5,  $5, 0x30                   # to ascii[0-9]

   j     print2

abcdef2:

   addi  $5,  $5, 0x37                   # to ascii[a-f]

print2:

   jal   display                          # 显示第二为数据

   addi  $5,  $0, 0x20                   # 打印空格

print3:

   jal   display                          # display char

   j     read_kbd                         # check next

display:

   sw    $5,  0($3)                       #显示字符

   addi  $3,  $3,  4                                     #把地址加4

   jr    $ra                              #返回

.end

, Y" H6 q' K  {0 @* P1 j! ~4 Z0 b6 `/ f

最后通过汇编器得到机器码，并存到指令存储器中。即可得到最后效果。

第四部分：效果

scancode demo视频

http://pan.baidu.com/s/1mgxcH6K

8 j1 |/ b9 }4 ]- t% N9 ~) a

moveblock demo视频

http://pan.baidu.com/s/1i3J340X

在scancode软件的基础之上，我又自己写了一个可以用键盘控制移动小方块的程序，上面是演示视频。

9 Y% F( P/ Y) n  X2 M1 V
6 m( o9 s% F* K2 O, X

Demyar

谢谢楼主的整理