HDLBits_刷题_持续更新中

一、Getting Started

1.1Getting Started

1.1.1 编译后提示的意思

当你把代码写完然后编译之后，会给出相应的提示：

• 如果语言的编译和线路的仿真都正确，并且符合题目要求，则会提示Success!
• 编译错误，则会提示Compile Error
• 电路仿真错误，则会提示Simulation Error
• 如果语言的编译和线路的仿真都正确，但是不符合题目要求，则会提示Incorrect
• 可以在My Stats 查看或者分享我们写题目的进度，可以理解为自动存档哈。如图1.1所示。
  

1.1.2 网站的几个重要的板块

见下图即可。

1.1.3 问题的翻译与解答

意思：创建一个没有输入只有一个输出的电路，且输出总是为1。
解题代码如下：

module top_module( output one );
// Insert your code here
    assign one = 1'b1;
endmodule

1.2Output Zero

网站相关介绍也在第一节介绍之后将主要进行问题的翻译与解答。

1.2.1题目与解答

意思：创建一个没有输入，一个输出且输出为0的电路。
代码如下：

module top_module(
    output zero
);// Module body starts after semicolon
	assign zero=1'b0;
endmodule

二 、Verilog Language

2.1 Basics

2.1.1 Simple wire

题目:创建一个模块，将输入与输出像一根线一样连接起来。
代码如下：

module top_module( input in, output out );
	assign out = in ;
endmodule

2.1.2 Four wires

题目：创建一个3输入4输出的模块，用线实现如图所示的连接。
代码如下：

module top_module( 
    input a,b,c,
    output w,x,y,z );
    
	assign w=a,x=b,y=b,z=c;
    
endmodule

2.1.3 Inverter

题目：创建一个实现非门的模块。
代码如下：

module top_module( input in, output out );

    assign out = ~in;
endmodule

2.1.4 AND gate

题目：创建一个实现与门的模块。
代码如下：

module top_module( 
    input a, 
    input b, 
    output out );
    
	assign out = a & b;
endmodule

2.1.5 NOR gate

题目：创建一个实现或非门的模块。
代码如下：

module top_module( 
    input a, 
    input b, 
    output out );

    assign out = ~(a|b);
endmodule

2.1.6 XNOR gate

题目：创建一个实现同或门的模块。
代码如下：

module top_module( 
    input a, 
    input b, 
    output out );
    
    assign out = ~(a^b);
endmodule

2.1.7 Declaring wires

这个小节出现了线网数据类型wire，当内部结构越来越复杂时，一个模块的输入输出并非直接连接时，声明一个线网数据类型的变量（相当于中间变量）。

题目：实现如图所示的电路。创建两条中间线网（取任何你想取的名字）去连接与门和或门，
代码如下：

module top_module(
    input a,
    input b,
    input c,
    input d,
    output out,
    output out_n   ); 
    //这两个线网类型的变量，在没有器件连接时为高阻态Z 
	wire temp1,temp2; 
    assign temp1 = a&b;
    assign temp2 = c&d;
    assign out = temp1|temp2;
    assign out_n = ~out;
endmodule

2.1.8 7458 chip

代码如下：

module top_module ( 
    input p1a, p1b, p1c, p1d, p1e, p1f,
    output p1y,
    input p2a, p2b, p2c, p2d,
    output p2y );

    assign p1y = (p1a&p1c&p1b) | (p1d&p1f&p1e);
    assign p2y = (p2a&p2b) | (p2c&p2d);
endmodule

2.2 Vectors

2.2.1 Vectors

可以一次性初始化许多条线，注意维度应该在变量名字的前面。
规则：type [upper:lower] vector_name;
eg. wire [99:0] my_vector;

代码如下：

module top_module ( 
    input wire [2:0] vec,
    output wire [2:0] outv,
    output wire o2,
    output wire o1,
    output wire o0  ); // Module body starts after module declaration
	
    assign outv[2:0]= vec[2:0];
    assign o0 = vec[0],o1 = vec[1],o2 = vec[2];
endmodule

2.2.2 Vectors in more detail

题目：构建一个组合电路，将输入的16位分割成低8位和高8位。
代码如下：

module top_module( 
    input wire [15:0] in,
    output wire [7:0] out_hi,
    output wire [7:0] out_lo );

    assign out_hi[7:0] = in[15:8];
    assign out_lo[7:0] = in[7:0];
endmodule

2.2.3 Vector part select

题目：就是把四个字节的容器里的每个字节调换位置。
代码如下：

module top_module( 
    input [31:0] in,
    output [31:0] out );

    assign out[31:24] = in[7:0];
    assign out[23:16] = in[15:8];
    assign out[15:8]  = in[23:16];
    assign out[7:0]   = in[31:24];
    
endmodule

2.2.4 Bitwise operators

题目：如图所示，注out_not[5:0]]高3位是b。
代码如下：

module top_module( 
    input [2:0] a,
    input [2:0] b,
    output [2:0] out_or_bitwise,
    output out_or_logical,
    output [5:0] out_not
);
    
    assign out_or_bitwise[2:0] = a[2:0]|b[2:0]; //a[2:0]和b[2:0]可以直接写成a和b
    assign out_or_logical = a[2:0]||b[2:0];
    //assign out_not[5:3] =  ~b[2:0]; 这种方法也可以
    //assign out_not[2:0] =  ~a[2:0];
    assign out_not[5:0] = {{~b[2:0]},{~a[2:0]}};
    
endmodule

2.2.5 Four-input gates

代码如下：

module top_module( 
    input [3:0] in,
    output out_and,
    output out_or,
    output out_xor
);

    assign out_and = ∈ //每一位相与
    assign out_or  = |in;
    assign out_xor = ^in;
    
endmodule

2.2.6 Vector concatenation operator

拼接符{}
用法：

{3’b111, 3’b000} => 6’b111000
{1’b1, 1’b0, 3’b101} => 5’b10101
{4’ha, 4’d10} => 8’b10101010

题目：如图所示。
代码如下：

module top_module (
    input [4:0] a, b, c, d, e, f,
    output [7:0] w, x, y, z );
    
    assign {w,x,y,z} = {a,b,c,d,e,f,{2'b11}};
    
endmodule

2.2.7 Vector reversal 1

题目：将输入的每个位翻转。
代码如下：
方法一：

module top_module( 
    input [7:0] in,
    output [7:0] out
);
    always @(*) begin	//组合逻辑电路
        for (integer i=0; i<8; i++)	
			out[i] = in[8-i-1];
	end
endmodule

方法二：

module top_module( 
    input [7:0] in,
    output [7:0] out
);
    assign out[7:0]={ in[0],in[1],in[2],in[3],
                     in[4],in[5],in[6],in[7] };
endmodule

2.2.8 Replication operator

题目：将8位的一个数据扩展成32位的数据，要求复制符号位来增加数据的位数
代码如下：

module top_module (
    input [7:0] in,
    output [31:0] out );
    assign out[31:0] ={{24{in[7]}} ,{in[7:0]}};
endmodule

2.2.9 More replication

题目：（XNOR 为同或的意思）将图示数据全部同或，再并入到一个25位的容器里。
代码如下：

module top_module (
    input a, b, c, d, e,
    output [24:0] out );//

    assign out = {  {~{5{a}}^{a,b,c,d,e}},
                  	{~{5{b}}^{a,b,c,d,e}},
                 	{~{5{c}}^{a,b,c,d,e}},
                 	{~{5{d}}^{a,b,c,d,e}},
                  	{~{5{e}}^{a,b,c,d,e}} };
endmodule

2.3 Modules:Hierarchy

本小节就进入了模块化设计，也就是模块的例化。例化的方式有两种，按照位置例化或名字例化。为了代码的可读性一般使用名字例化。具体如何使用看下面的练习。

2.3.1 Modules

题目：mod_a模块已经给出，把他按上图所示，与顶层模块进行例化。
代码如下：
一、按名字的方式例化。（更加推荐）

module top_module ( input a, input b, output out );
    mod_a temp_mod( //这里的temp_mod模块名字随便取，主要是为了区分多个不同的例化。
        .in1(a),    //in1是mod_a模块的输入，a是top_module的输入
        .in2(b),
        .out(out)   //这种例化的方式可以清晰的看到与引脚之间的连接。
    ); 
    
endmodule

二、按位置的方式例化。

module top_module ( input a, input b, output out );
    
    mod_a temp_mod(a,b,out); //这种例化的方式看不出引脚之间的连接，但是他更加简便
    
endmodule

2.3.2 Connecting ports by position

题目：mod_a 模块已经给出，要求使用位置例化
代码如下：

module top_module ( 
    input a, 
    input b, 
    input c,
    input d,
    output out1,
    output out2
);
    mod_a temp_mod (out1,out2,a,b,c,d);
endmodule

2.3.3 Connecting ports by name

题目：mod_a 模块已经给出，要求使用名字例化
代码如下：

module top_module ( 
    input a, 
    input b, 
    input c,
    input d,
    output out1,
    output out2
);
    mod_a temp_mod 
    (
        .in1(a),
        .in2(b),
        .in3(c),
        .in4(d),
        .out1(out1),
        .out2(out2)
    );  //注意括号内的是顶层模块引脚
endmodule

2.3.4 Three modules

题目：my_dff 模块已经给出，该模块具有两个输入和一个输出(它实现了 D 触发器)。将它例化出三个模块，然后将它们连接在一起，形成一个3位的移位寄存器。clk 端口需要连接到所有例化出来的模块。my_diff 模块如图红线已经框出
代码如下：

module top_module ( input clk, input d, output q );
    
	wire temp_wire_left; //线网类型数据，作为第一，二个模块连接的线。
    wire temp_wire_right;//线网类型数据，作为第二，三个模块连接的线。
    my_dff mod_1         //例化出模块1
    (
        .clk(clk),
        .d(d),
        .q(temp_wire_left)
    );
    my_dff mod_2 		//例化出模块2
    (
        .clk(clk),
        .d(temp_wire_left),
        .q(temp_wire_right)
    );
    my_dff mod_3		//例化出模块3
    (
        .clk(clk),
        .d(temp_wire_right),
        .q(q)
    );
endmodule

2.3.5 Module and vectors

题目：提供的模块如图所示。
代码如下（详解看注释）：

module top_module ( 
    input clk, 
    input [7:0] d, 
    input [1:0] sel, 
    output [7:0] q 
);
//module my_dff8 ( input clk, input [7:0] d, output [7:0] q );
    //线网类型数据，作为第一，二个模块连接的线。
    wire [7:0] temp_wire_left; 
   //线网类型数据，作为第二，三个模块连接的线。
    wire [7:0] temp_wire_right;
    //线网类型数据，作为第三个模块输出。
    wire [7:0] temp_mod_out;
    //下面是三个例化
    my_dff8 mod_1
    (
        .clk(clk),
        .d(d),
        .q(temp_wire_left)
    );
    my_dff8 mod_2
    (
        .clk(clk),
        .d(temp_wire_left),
        .q(temp_wire_right)
    );
    my_dff8 mod_3
    (
        .clk(clk),
        .d(temp_wire_right),
        .q(temp_mod_out)
    );
    //这里是一个数据选择器
    always @(*)
    begin
        case (sel)
            //组合逻辑所以阻塞赋值（=），注意不要用连续赋值关键词assign
            2'b00: q = d;  
            2'b01: q = temp_wire_left;
            2'b10: q = temp_wire_right;
            2'b11: q = temp_mod_out;
            default:;
        endcase
    end
endmodule

注意阻塞赋值与非阻塞赋值的不同（具体可以去看仿真的波形）：

(1) 阻塞赋值(=) : 写在前面的语句先执行，写在后面的语句后执行，也就是说，它是顺序执行的，一般用于组合逻辑电路。

(2) 非阻塞赋值(<=) :写在前面的语句与后面的语句同时执行，也就是说，它是并行执行的，跟书写顺序没有关系，一般用于时序逻辑电路。

2.3.6 Adder 1

题目：提供了一个16位加法器模块名为add16，创建一个32位的加法器。
代码如下（详解看注释）：

module top_module(
    input [31:0] a,
    input [31:0] b,
    output [31:0] sum
);
    //题目中摆放在上面模块的sum输出连接的线
    wire [15:0] sum_up_out;
    //题目中摆放在上面模块的cout输出连接的线
    wire [15:0] cout_up_out;
    //题目中摆放在下面模块的cout输出连接的线
    wire [15:0] sum_down_out;
    //实例化
    add16 add16_up
    (
        .a(a[15:0]),
        .b(b[15:0]),
        .cin(0),
        .sum(sum_up_out),
        .cout(cout_up_out)
    );
    add16 add16_down
    (
        .a(a[31:16]),
        .b(b[31:16]),
        .cin(cout_up_out),
        .sum(sum_down_out),
        //输出没有连接则直接不写
        .cout()      
    );
    //注意题目中摆放再下面模块的sum输出是高位
    assign sum = {sum_down_out,sum_up_out};
endmodule

2.3.7 Adder 2

题目：这里要求我们自己写出1位全加器的模块，16为加法器就是通过例化这个1位全加器得来，因此不写就会报错。注意：不要求我们自己写出16位加法器模块，题目已经提供。
代码如下：

module top_module (
    input [31:0] a,
    input [31:0] b,
    output [31:0] sum
);
    //这部分与2.3.6小结一样
    wire [15:0] mod_2_sum,mod_1_sum;
    wire [15:0] mod_1_cout;
	add16 mod_1
    (
        .a(a[15:0]),
        .b(b[15:0]),
        .cin(0),
        .cout(mod_1_cout),
        .sum(mod_1_sum)
    );
	add16 mod_2
    (
        .a(a[31:16]),
        .b(b[31:16]),
        .cin(mod_1_cout),
        .cout(),
        .sum(mod_2_sum)
    );
    assign sum = {mod_2_sum,mod_1_sum};
endmodule

module add1 ( input a, input b, input cin,   output sum, output cout );

    //根据真值表和卡诺图得来，过程见下图。
    assign sum = (~cin&a&(~b))|(cin&(~a)&(~b))
                      |(~cin&(~a)&b)|(cin&a&b);
    assign cout =(a&b)|(cin&b)|(cin&a);
    
endmodule

真值表与卡诺图如下：

2.3.8 Carry-select adder

前几个小节练习的进位加法器，只有前一个加法器加完之后才能进行后续的相加，这样使得数据相加很慢，可以用进位选择加法器来加快加法运算的速度。

题目：已经提供了模块add16 模块。数据选择器并不是要算出一位选择一位，而是把高位全部算好了，低位的进位一算出，则数据相加的结果就直接出来了。
代码如下：

module top_module(
    input [31:0] a,
    input [31:0] b,
    output [31:0] sum
);
    wire [15:0] mod_1_cout;
    wire [15:0] mod_up_sum,mod_mid_sum,mod_down_sum;
    wire [15:0] mod_mid_down_sum;
	add16 mod_up
    (
        .a(a[15:0]),
        .b(b[15:0]),
        .cin(0),
        .cout(mod_1_cout),
        .sum(mod_up_sum)
    );
	add16 mod_mid
    (
        .a(a[31:16]),
        .b(b[31:16]),
        .cin(0),
        .cout(),
        .sum(mod_mid_sum)
    );
    add16 mod_down
    (
        .a(a[31:16]),
        .b(b[31:16]),
        .cin(1),
        .cout(),
        .sum(mod_down_sum)
    );
    always @(*)
    begin
        case(mod_1_cout)
            1'b0: mod_mid_down_sum = mod_mid_sum;
            1'b1: mod_mid_down_sum = mod_down_sum;
            default:;
        endcase;
    end
    assign sum={mod_mid_down_sum,mod_up_sum};
endmodule

2.3.9 Adder-subtractor

加/减法器，当sub为0时为为加法器，为1时为减法器。这个也比较好理解，二进制的减法就是加上补码（一个数的补码就是，取反再低位加1）
一个数异或0就是本身，异或1就是取反。

代码如下：

module top_module(
    input [31:0] a,
    input [31:0] b,
    input sub,
    output [31:0] sum
);
    wire [15:0] mod_1_cout;
    
	add16 mod_up
    (
        .a(a[15:0]),
        //一个16位的数和一个1位的数无法进行异或，因此用拼接符增加数据位数到16位
        .b(b[15:0]^{16{sub}}),
        .cin(sub),
        .cout(mod_1_cout),
        .sum(sum[15:0])
    );
	add16 mod_mid
    (
        .a(a[31:16]),
        .b(b[31:16]^{16{sub}}),
        .cin(mod_1_cout),
        .cout(),
        .sum(sum[31:16])
    );
endmodule

2.4 Procedures

2.4.1 Always blocks（combination）

组合逻辑always块是等价于assign的，但是语法上有不同。

注意：
always 是过程赋值语句，数据类型一定要是 寄存器（reg）类型。
assign 是连续赋值语句，数据类型一定要是线网（wire）类型。

代码如下：

module top_module(
    input a, 
    input b,
    output wire out_assign,
    output reg out_alwaysblock
);
	assign out_assign = a & b;
    always @(*)
    begin
        out_alwaysblock = a & b;
    end
endmodule

2.4.2 Always blocks（clocked）

组合逻辑中，使用阻塞赋值，时序逻辑中使用非阻塞赋值。

题目：用三种当时构建异或门。
代码如下：

module top_module(
    input clk,
    input a,
    input b,
    output wire out_assign,
    output reg out_always_comb,
    output reg out_always_ff   );
    //连续赋值
	assign out_assign = a^b;
    //组合过程赋值
    always @(*)
    begin
        out_always_comb = a^b;
    end
    always @(posedge clk)
    begin
        out_always_ff <= a^b;
    end
    
endmodule

2.4.3 If statement

终于来到了我们熟悉的if else了0.0！！！！安排。
代码如下：

module top_module(
    input a,
    input b,
    input sel_b1,
    input sel_b2,
    output wire out_assign,
    output reg out_always   ); 
    
    
    assign out_assign = (sel_b1 & sel_b2)? b:a;
    
    always @(*)
    begin
        if(sel_b1 & sel_b2)
        begin
        	 out_always = b;
        end
        else  begin
             out_always = a;   
        end          
    end
endmodule

2.4.4 If statement latches

（1）在组合逻辑中，我们要防止锁存器的产生。因为我们组合逻辑不花里胡哨输入变，输出直接跟着变，不保存状态。那怎么避免呢，就是把所有情况都写出来，if else 还有 case default 成双成对出现。
（2）在时序逻辑中，即使不把所有情况都列出，也不会产生锁存器。

代码如下：

module top_module (
    input      cpu_overheated,
    output reg shut_off_computer,
    input      arrived,
    input      gas_tank_empty,
    output reg keep_driving  ); //

    always @(*) begin
        //cpu过热
        if (cpu_overheated)
        //关机
           shut_off_computer = 1;
        else
           shut_off_computer = 0;
            
    end

    always @(*) begin
        if (~arrived)
             //还没到达目的地，油箱没空就保持行驶
           keep_driving = ~gas_tank_empty;
        else
           //到了就不行驶了
           keep_driving = 0;
    end

endmodule

2.4.5 Case statement

case 很熟悉了，不多说，注意case语法即可。
代码如下：

module top_module ( 
    input [2:0] sel, 
    input [3:0] data0,
    input [3:0] data1,
    input [3:0] data2,
    input [3:0] data3,
    input [3:0] data4,
    input [3:0] data5,
    output reg [3:0] out   );

    always@(*) begin  // This is a combinational circuit
        case(sel) 
            //注意这里不需要begin
        	3'b000: out=data0; 
            3'b001: out=data1;
            3'b010: out=data2;   
            3'b011: out=data3;   
            3'b100: out=data4;   
            3'b101: out=data5;   
            default:out=0;
        endcase
    end

endmodule

2.4.6 Priority encoder

优先编码器，使用case语句即可。
代码如下：

module top_module (
    input [3:0] in,
    output reg [1:0] pos  );
    
    always@(*) begin
    	case (in)
            4'b0000:pos=2'b00;
			4'b0001:pos=2'b00;
            4'b0010:pos=2'b01;
            4'b0011:pos=2'b00;
            4'b0100:pos=2'b10;
			4'b0101:pos=2'b00;
            4'b0110:pos=2'b01;
            4'b0111:pos=2'b00;
			4'b1000:pos=2'b11;
            4'b1001:pos=2'b00;
            4'b1010:pos=2'b01;
            4'b1011:pos=2'b00;
			4'b1100:pos=2'b10;
            4'b1101:pos=2'b00;
            4'b1110:pos=2'b01;
            4'b1111:pos=2'b00;
        	default:pos=2'b00;
    	endcase
    end
endmodule

2.4.7 Priority encoder with casez

（1）假如case语句中想要使用z来表示，不在乎这一位数据是什么的话，就要使用casez语句。
（2）casex也是类似的使用，把z换成x即可，在casex语句下可以使用z，但是casez下不可以使用x**
（3）通常情况下用casez比用casex更好一些，因为×的存在可能会导致仿真出现令人误解和混乱的结果。
（4）在casex和 casez声明的标号中用?来代替z比较好，因为这样做比较清楚，是一个无关项，而不是一个高阻项。

题目：8位优先编码器。
代码如下：
方法一、casez

  module top_module (
    input [7:0] in,
    output reg [2:0] pos  );
    always @(*) begin
        casez(in)
            8'b0000_0000:pos=3'd0;
            8'bzzzz_zzz1:pos=3'd0;
            8'bzzzz_zz10:pos=3'd1;
            8'bzzzz_z100:pos=3'd2;
            8'bzzzz_1000:pos=3'd3;
            8'bzzz1_0000:pos=3'd4;
            8'bzz10_0000:pos=3'd5;
            8'bz100_0000:pos=3'd6;
            8'b1000_0000:pos=3'd7;
            default:pos=0;
        endcase
    end
endmodule

方法二、casex

  module top_module (
    input [7:0] in,
    output reg [2:0] pos  );
    always @(*) begin
        casex(in) //使用casex
            8'b0000_0000:pos=3'd0;
            8'bzzzz_zzz1:pos=3'd0;
            8'bzzzz_zz10:pos=3'd1;
            8'bzzzz_z100:pos=3'd2;
            8'bzzzz_1000:pos=3'd3;
            8'bzzz1_0000:pos=3'd4;
            8'bzz10_0000:pos=3'd5;
            8'bz100_0000:pos=3'd6;
            8'b1000_0000:pos=3'd7;
            default:pos=0;
        endcase  //都是endcase
    end
endmodule

方法三、用问号来替代z或x

 module top_module (
    input [7:0] in,
    output reg [2:0] pos  );
    always @(*) begin
        casez(in)
            8'b0000_0000:pos=3'd0;
            8'b????_???1:pos=3'd0;
            8'b????_??10:pos=3'd1;
            8'b????_?100:pos=3'd2;
            8'b????_1000:pos=3'd3;
            8'b???1_0000:pos=3'd4;
            8'b??10_0000:pos=3'd5;
            8'b?100_0000:pos=3'd6;
            8'b1000_0000:pos=3'd7;
            default:pos=0;
        endcase
    end
endmodule

2.4.8 Avoiding laches

还是那句话，case语句中default不能少！！！
代码如下：

  module top_module (
    input [15:0] scancode,
    output reg left,
    output reg down,
    output reg right,
    output reg up  ); 
    always @(*)  begin
        //初始化
        up = 1'b0;down = 1'b0; left = 1'b0;right = 1'b0;
        case (scancode) 
        	16'he06b:left = 1'b1;
        	16'he072:down = 1'b1;
        	16'he074:right= 1'b1;
        	16'he075:up =   1'b1;   
        default:begin
            up = 1'b0;down = 1'b0; left = 1'b0;right = 1'b0;
        end
        endcase   
    end
endmodule
  

2.5 More Verilog Features

2.5.1 Conditional ternary operator

题目：使用条件运算符从四个无符号数据中找到最小的数据。
代码如下：

module top_module (
    input [7:0] a, b, c, d,
    output [7:0] min);//
    
    wire [7:0] temp_min1,temp_min2;
    assign temp_min1=(a<b)?a:b;
    assign temp_min2=(c<d)?c:d;
    assign min =(temp_min1<temp_min2)?temp_min1:temp_min2;
endmodule

2.5.2 Reduction operators

使用方式如下图所示：

题目：用精简算子，给一个8位的数据，做一个偶校验。
代码如下：

module top_module (
    input [7:0] in,
    output parity); 
    
	assign parity = ^in;
    
endmodule
  

2.5.3 Reduction：Even wider gates

代码如下：

module top_module( 
    input [99:0] in,
    output out_and,
    output out_or,
    output out_xor 
);
	assign out_and=∈
    assign out_or =|in;
    assign out_xor=^in;
endmodule

2.5.4 Vector 100r

题目：翻转一下所给数据位的顺序。
代码如下：

module top_module( 
    input [99:0] in,
    output [99:0] out
);
    always @(*)
    begin
        for(int i=0;i<100;i=i+1) begin
            out[i] =in[99-i]; 
        end
    end
endmodule

2.5.5 Combination for-loop：255-bit population count

题目：统计一个255位的数据，有多少个位是1。
代码如下：

module top_module( 
    input [254:0] in,
    output [7:0] out );
    always @ ( * )
    begin
        //初始化
        out=0;
        for(int i=0;i<255;i=i+1) begin
            if(in[i]==1'b1)begin
                out=out+1;
            end
            else
                out=out;
        end
    end 
endmodule

2.5.6 Generate for-loop：100-bit binary adder 2

这里使用了generate 关键词注意语法，具体看代码注释。

题目：创建一个100位的二进制加法器
代码如下：

module top_module( 
    input [99:0] a, b,
    input cin,
    output [99:0] cout,
    output [99:0] sum );
    //generate 用于循环例化，用法如下
	generate
        //generate 专用数据类型
        //!!!!!这里不可以给i赋值，如i=0 是错误的
        genvar i ; 
        for(i=0;i<100;i=i+1) begin:add_100 //整个循环例化出整体模块的名称
            if(i==0) begin      //第一个例化的cin用于接顶层模块cin
                adder_full add100(
                    .a(a[i]),
                    .b(b[i]),
                    .cin(cin),
                    .cout(cout[i]),
                    .sum(sum[i])
                );
            end
            else begin
               adder_full add100(
                    .a(a[i]),
                    .b(b[i]),
                    .cin(cout[i-1]),
                    .cout(cout[i]),
                    .sum(sum[i])
                );
                end
        end       
    endgenerate
endmodule

//全加器模块的设计
module adder_full(
	input a,b,cin,
    output cout,sum
);
    //用真值表和卡诺图做的
    //方法一
    //assign sum = (~cin&a&(~b))|(cin&(~a)&(~b))
    //                  |(~cin&(~a)&b)|(cin&a&b);
    //assign cout =(a&b)|(cin&b)|(cin&a);
    //方法二
    //更加简便
    assign {cout,sum}=a+b+cin;
endmodule

2.5.7 Generate for-loop：100-bit BCD adder

BCD加法器就是用4个二进制表示一个十进制数的加法器。
代码如下：

module top_module( 
    input [399:0] a, b,
    input cin,
    output cout,
    output [399:0] sum );

    wire [99:0] cout_temp;
    
    generate
        genvar i;
        for(i=0;i<100;i++)begin:add10
            if(i==0) begin 
                bcd_fadd add(a[4*i+3:4*i],b[4*i+3:4*i],cin,cout_temp[i],sum[4*i+3:4*i]);
            end
            else begin
                bcd_fadd add(a[4*i+3:4*i],b[4*i+3:4*i],cout_temp[i-1],cout_temp[i],sum[4*i+3:4*i]);
            end
        end
    endgenerate
    assign cout = cout_temp[99];    
endmodule

三、Circuits

3.1 Combinational Logic

3.1.1Basic Gates

3.1.1.1 Wire

代码如下：

module top_module (
    input in,
    output out);

    assign out = in;
endmodule

3.1.1.2 GND

代码如下：

module top_module (
    output out);
 	
    assign out=1'b0;
endmodule

3.1.1.3 NOR

代码如下：

module top_module (
    input in1,
    input in2,
    output out);
    
    assign out = ~( in1|in2 );
endmodule

3.1.1.4 Another gate

代码如下：

module top_module (
    input in1,
    input in2,
    output out);

    assign out = in1 & (~in2);
        
endmodule

3.1.1.5 Two gate

module top_module (
    input in1,
    input in2,
    input in3,
    output out);

    wire temp_one;
    
    assign temp_one=~(in1^in2);
    assign out = temp_one ^ in3;
    
endmodule

3.1.1.6 More logic gates

代码如下：

module top_module( 
    input a, b,
    output out_and,
    output out_or,
    output out_xor,
    output out_nand,
    output out_nor,
    output out_xnor,
    output out_anotb
);

    assign out_and   = a&b;
    assign out_or    = a|b;
    assign out_xor   = a^b;     //异或
    assign out_nand  = ~(a&b);
    assign out_nor   = ~(a|b);
    assign out_xnor  = ~(a^b); //同或
    assign out_anotb = a&~b;
    
endmodule

3.1.1.7 7420 chip

代码如下：

module top_module ( 
    input p1a, p1b, p1c, p1d,
    output p1y,
    input p2a, p2b, p2c, p2d,
    output p2y );
	
    assign p1y = ~(p1a & p1b & p1c & p1d);
    assign p2y = ~(p2a & p2b & p2c & p2d);
endmodule

3.1.1.8 Truth tables

真值表如图所示：

利用真值表画卡诺图即可。
代码如下：

module top_module( 
    input x3,
    input x2,
    input x1,  // three inputs
    output f   // one output
);

    assign f= ~x3&x2 | x3&x1;
    
endmodule

3.1.1.9Two-bit equality

代码如下：

module top_module ( input [1:0] A, input [1:0] B, output z ); 

    assign z =(A==B)?1:0;
    
endmodule

3.1.1.10 Simple circut A

module top_module (input x, input y, output z);

    assign z = (x^y) & x;
    
endmodule

3.1.1.11 Simple circut B

列出真值表即可得出答案。
代码如下：

module top_module ( input x, input y, output z );
    assign z=~(x^y);
    
endmodule

3.1.1.12 Combine circuts A and B

注意他这里的AB模块没有提供。
代码如下：

module top_module (input x, input y, output z);

    wire temp1,temp2,temp3,temp4;
    wire temp_12,temp_34;
    A IA1(x,y,temp1);
    B IB1(x,y,temp2);
    A IA2(x,y,temp3);
    B IB2(x,y,temp4);
    
    assign temp_12 = temp1 | temp2;
    assign temp_34 = temp3 & temp4;
    assign z = temp_12^temp_34;
endmodule

module A (input x, input y, output z);

    assign z = (x^y) & x;
    
endmodule
module B ( input x, input y, output z );
    assign z=~(x^y);
    
endmodule

3.1.1.13 Ring or vibrate

题目：如果ring=1的情况下，要么闹铃要么震动，但是两者不会同时发生。当vibrate_mode=1 时，震动否则闹铃。
代码如下：

module top_module (
    input ring,
    input vibrate_mode,
    output ringer,       // Make sound
    output motor         // Vibrate
);

    assign motor = ring & vibrate_mode;
    assign ringer= ring & ~vibrate_mode ;
endmodule

3.1.1.14 Thermostat

列出真值表，如下：
卡诺图如下：

代码如下：

module top_module (
    input too_cold,
    input too_hot,
    input mode,
    input fan_on,
    output heater,
    output aircon,
    output fan
); 

  	assign  heater = mode & too_cold;
  	assign  aircon = ~mode & too_hot;
    assign  fan =( ~mode&too_hot )|fan_on|(mode&too_cold);
    
endmodule

3.1.1.15 3-bit population count

题目：计一个Vector里1的个数。
代码如下：

module top_module( 
    input [2:0] in,
    output [1:0] out );
	
    reg [1:0] temp;
    always @(*)
    begin
        temp=0;
        for(int i=0;i<3;i=i+1) begin
            if(in[i]==1'b1)begin
            	temp=temp+1;    
            end
            else begin
                temp=temp;
            end
        end
        out=temp;
    end
endmodule

3.1.1.16 Gates and vexctors

直接见代码：

module top_module( 
    input [3:0] in,
    output [2:0] out_both,
    output [3:1] out_any,
    output [3:0] out_different );
    
    assign out_both =in[2:0]&in[3:1];         //与左边的位进行与运算 
    assign out_any  =in[3:1]|in[2:0];         //与右边的位进行或运算
    assign out_different =in ^{in[0],in[3:1]};//与左边的位进行异或
endmodule

3.1.1.17 Even longer vectors

与上一题一样，注意使用verctor的移位即可。
代码如下：

module top_module( 
    input [99:0] in,
    output [98:0] out_both,
    output [99:1] out_any,
    output [99:0] out_different );

    assign out_both =in[98:0]&in[99:1];         //与左边的位进行与运算 
    assign out_any  =in[99:1]|in[98:0];         //与右边的位进行或运算
    assign out_different =in ^{in[0],in[99:1]};//与左边的位进行异或
endmodule

3.1.2 Multiplexer

3.1.2.1 2-to-1 multiplexer

代码如下：

module top_module( 
    input a, b, sel,
    output out ); 

    assign out = (sel==0)? a:b ;
    
endmodule

3.1.2.2 2-to-1 bus multiplexer

代码如下：

module top_module( 
    input [99:0] a, b,
    input sel,
    output [99:0] out );

    assign out = (sel==0)? a:b ;
endmodule

3.1.2.3 9-to-1 multiplexer

代码如下：

module top_module( 
    input [15:0] a, b, c, d, e, f, g, h, i,
    input [3:0] sel,
    output [15:0] out );

    always @(*)
    begin
        case (sel) 
            4'b0000:out=a;
            4'b0001:out=b;
            4'b0010:out=c;
            4'b0011:out=d;
            4'b0100:out=e;
            4'b0101:out=f;
            4'b0110:out=g;
            4'b0111:out=h;
            4'b1000:out=i;
            default:out=16'b1111_1111_1111_1111;	
        endcase
    end
endmodule

3.1.2.4 256-to-1 multiplexer

代码如下：

module top_module( 
    input [255:0] in,
    input [7:0] sel,
    output out );
    
    assign out=in[sel];
    
endmodule

3.1.2.5 256-to-1 4-bit multiplexer

代码如下：

module top_module( 
    input [1023:0] in,
    input [7:0] sel,
    output [3:0] out );
	//经典的错误标准的零分,因为verilog没有这个语法
    //assign out = in[sel*4+3:sel*4];
    //正确的做法
    assign out = in[sel*4+3-:4];
endmodule

3.1.3 Arithmetic Circuit

3.1.3.1 Half adder

代码如下：

module top_module( 
    input a, b,
    output cout, sum );

    assign {cout,sum} = a+b;
    
endmodule

3.1.3.2 Full adder

module top_module( 
    input a, b, cin,
    output cout, sum );

    assign {cout ,sum } = a+b+cin;
         
endmodule

3.1.3.3 3-bit binary adder

module top_module( 
    input [2:0] a, b,
    input cin,
    output [2:0] cout,
    output [2:0] sum );

    full_add add1(a[0],b[0],cin,    cout[0],sum[0]);    
    full_add add2(a[1],b[1],cout[0],cout[1],sum[1]);   
    full_add add3(a[2],b[2],cout[1],cout[2],sum[2]);  
    
endmodule

module full_add( 
    input a, b, cin,
    output cout, sum );

    assign {cout ,sum } = a+b+cin;
         
endmodule

3.1.3.4 Adder

module top_module (
    input [3:0] x,
    input [3:0] y, 
    output [4:0] sum);

    wire [3:0] temp;
    full_add add1(x[0],y[0],       ,temp[0],sum[0]);
    full_add add2(x[1],y[1],temp[0],temp[1],sum[1]);
    full_add add3(x[2],y[2],temp[1],temp[2],sum[2]);
    full_add add4(x[3],y[3],temp[2],temp[3],sum[3]);
    assign sum[4]=temp[3];
    //还可以直接 sum = x + y;
endmodule

module full_add( 
    input a, b, cin,
    output cout, sum );

    assign {cout ,sum } = a+b+cin;
         
endmodule

3.1.3.5 Signed addition overflow

有符号的运算，考虑溢出情况（见下图）；

代码如下：

module top_module (
    input [7:0] a,
    input [7:0] b,
    output [7:0] s,
    output overflow
); //
 
    assign s = a+b;
    assign overflow = (a[7]&b[7]&~s[7]) | (~a[7]&~b[7]&s[7]) ;

endmodule

3.1.3.6 100-bit binary adder

前面有写过需要例化很多模块时可以使用generate关键字来解决，这里我们有一个更加简单的方法来解决，那就是行为描述。
代码如下：

module top_module( 
    input [99:0] a, b,
    input cin,
    output cout,
    output [99:0] sum );

    assign {cout,sum}=a+b+cin;
    
endmodule

3.1.3.7 4-digit BCD adder

module top_module ( 
    input [15:0] a, b,
    input cin,
    output cout,
    output [15:0] sum );

    wire [3:0] temp;
    generate
        genvar i;
        for(i=0;i<4;i=i+1)begin :add_bcd
            if(i==0)
                bcd_fadd add10(a[4*i+3:4*i],b[4*i+3:4*i],cin,      temp[i],sum[4*i+3:4*i]); 
            else
                bcd_fadd add10(a[4*i+3:4*i],b[4*i+3:4*i],temp[i-1],temp[i],sum[4*i+3:4*i]); 
        end
    endgenerate
    assign cout=temp[3];
    
endmodule

3.1.4 Karnaugh Map to Circuit

卡诺图走起！！！！！

3.1.4.1 3-variable

module top_module(
    input a,
    input b,
    input c,
    output out  ); 
	
    assign out= a | c | b;
    
endmodule

3.1.4.2 4-variable

代码如下：

module top_module(
    input a,
    input b,
    input c,
    input d,
    output out  ); 
    //               1           2         3          4
    assign out = (~d & ~a) | (~c & ~b) | (c&d&b) | (d&a&~b);
endmodule

3.1.4.3 4-variable

代码如下：
注意其中的d代表不在乎他为1还是0。

module top_module(
    input a,
    input b,
    input c,
    input d,
    output out  ); 

    assign out = a | (c & ~b );
    
endmodule

3.1.4.4 4-variable

直接硬刚吧！！！没法化简。
代码如下：

module top_module(
    input a,
    input b,
    input c,
    input d,
    output out  ); 

    assign out = (~a&b&~c&~d)|(a&~b&~c&~d)|(~a&~b&~c&d)|(a&b&~c&d)
        			|(~a&b&c&d)|(a&~b&c&d)|(~a&~b&c&~d)|(a&b&c&~d  );
endmodule

3.1.4.5 Minimum SOP and POS

SOP (与或），POS（或与）

解题过程如下图：

代码如下：

module top_module (
    input a,
    input b,
    input c,
    input d,
    output out_sop,
    output out_pos
); 

    assign out_sop = (c&d) | (~a&~b&c);
    assign out_pos = c & (~b|d) & (~a|b);
endmodule

3.1.4.6 Karnaugh map

代码如下：

module top_module (
    input [4:1] x, 
    output f );

    assign f=(~x[1]&x[3]) | (x[2]&x[4]);
endmodule

3.1.4.7 Karnaugh map

代码如下：

module top_module (
    input [4:1] x,
    output f
); 

    assign f = (~x[4]&~x[2]) | (&x[4:2]) | (~x[1]&x[3]);
    
endmodule

3.1.4.8 K-map implemented with a multiplexer

代码如下：

module top_module (
    input c,
    input d,
    output [3:0] mux_in
); 

    //注意不能用逻辑门
    //只能用选择器
    //ab=2'b00;
    assign mux_in[0]=c?1:(d?1:0);
    //ab=2'b01;
    assign mux_in[1]=0;
    //ab=2'b11;
    assign mux_in[3]=c?(d?1:0):0;
    //ab=2'b10;
    assign mux_in[2]=c?(d?0:1):(d?0:1);
    
endmodule

3.2 Sequential Logic

3.2.1 Latches and Flip-Flops

(1) D flip-flop
代码如下：

module top_module (
    input clk,    // Clocks are used in sequential circuits
    input d,
    output reg q );//
    //D 触发器 上升沿有效
    always @(posedge clk)
    begin
        q<=d;
    end
endmodule

(2) D flip-flops
8位的D触发器，与单个触发器设计一样。
代码如下：

module top_module (
    input clk,
    input [7:0] d,
    output [7:0] q
);

    always @(posedge clk)
    begin
        q<=d;
    end
endmodule

(3) DFF with reset

代码如下：

module top_module (
    input clk,
    input reset,            // Synchronous reset
    input [7:0] d,
    output [7:0] q
);
    //同步复位
    always @(posedge clk)
    begin
        //注意这里是高电平有效
        if(reset)
            q<=8'b0;
		else
            q<=d;
    end
endmodule

(4) DFF with reset value
代码如下：

module top_module (
    input clk,
    input reset,
    input [7:0] d,
    output [7:0] q
);
    //时钟下降沿有效
    always @(negedge clk)
    begin
        //注意这里是高电平有效
        if(reset)
            q<=8'h34;
		else
            q<=d;
    end
endmodule

(5) DFF with asynchronous reset

代码如下：

module top_module (
    input clk,
    input areset,   // active high asynchronous reset
    input [7:0] d,
    output [7:0] q
);
    //时钟上升沿有效
    always @(posedge clk or posedge areset )
    begin
        if(areset)
            q<=8'b0;
		else
            q<=d;
    end
endmodule

(6) DFF with byte enable

代码如下：

module top_module (
    input clk,
    input resetn,
    input [1:0] byteena,
    input [15:0] d,
    output [15:0] q
);

    always @(posedge clk)
    begin
        if(!resetn)
            q<=16'b0;
        else begin
            q[15:8] <= byteena[1]?d[15:8]:q[15:8];
            q[7:0]  <= byteena[0]?d[7:0] :q[7:0 ];
        end
 			
    end
endmodule

(7) D Latch

module top_module (
    input d, 
    input ena,
    output q);

    always @ (*)
    begin
        if(ena)
            q=d;
        else
            q=q;
    end
endmodule

(8) DFF

异步复位
代码如下：

module top_module (
    input clk,
    input d, 
    input ar,   // asynchronous reset
    output q);
    always @ (posedge clk or posedge ar)
    begin
        if(ar)
            q<=0;
        else
            q<=d;
    end

endmodule

(9) DFF

代码如下：

module top_module (
    input clk,
    input d, 
    input r,   // synchronous reset
    output q);
    always @ (posedge clk)
    begin
        if(r)
            q<=0;
        else
            q<=d;
    end
endmodule

(10) DFF + gate

代码如下：

module top_module (
    input clk,
    input in, 
    output out);

    always @ (posedge clk)
    begin
		out<=in^out;
    end
endmodule

(11) MUX and DFF

注意这里一定要审题：不要把整个图都给他搞出来了
代码如下：

module top_module (
	input clk,
	input L,
	input r_in,
	input q_in,
	output reg Q);

    always @(posedge clk)
    begin
        Q<=L?r_in:q_in;
    end
endmodule

(12) MUX and DFF

代码如下：

module top_module (
    input clk,
    input w, R, E, L,
    output Q
);

    always @(posedge clk)
    begin
        Q<=L?R:(E?w:Q);
    end
endmodule

(13) DFFs and gates

//正确代码

module top_module (
    input clk,
    input x,
    output z
); 
    
    reg [2:0]	Q;
    always@(posedge clk)begin
        Q[0] <= Q[0] ^ x;
        Q[1] <= ~Q[1] & x;
        Q[2] <= ~Q[2] | x;
    end
    
    assign z = ~(| Q);
 
endmodule

错误代码：
提交之后一直显示错误,目前没有发现错误原因

module top_module (
    input clk,
    input x,
    output z
); 
    
	wire D0,D1,D2;
	wire Q0,Q1,Q2;
    
    assign D0 = x ^  Q0;
    assign D1 = x & !Q1;
    assign D2 = x | !Q2;
   
    DFF aff1(clk,D0,Q0);
    DFF aff2(clk,D1,Q1);
    DFF aff3(clk,D2,Q2);
    
    assign z = !(Q0 | Q1 | Q2);
    
endmodule

module DFF (
	input clk,
    input d,
    output reg q);
    
always@(posedge clk)
    q <= d;
endmodule

(14) Creat circuit from trurh table

代码如下：

module top_module (
    input clk,
    input j,
    input k,
    output Q); 

    always @(posedge clk)
    begin
        Q <=j? (k?~Q:1):(k?0:Q);
    end
endmodule

(15) Detect an egde

题目：检测上升沿
代码如下：

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] pedge
);
	//in_temp为in上一个cycle的值!!!!
    //假如in=1，in_temp=0；则为检测到了一个上升沿
    reg [7:0] in_temp;
    //检测in的上升沿，检测到之后给pedge一个脉冲
    always @ (posedge clk)
    begin
        in_temp <= in;
        pedge   <= in & ~in_temp; 
    end
endmodule

(15) Detect both egde

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] anyedge
);
	//in_temp为in上一个cycle的值!!!!
    //假如in=1，in_temp=0；则为检测到了一个上升沿
    //in=0,in_temp=1;则为下降沿，都符合本题意
    reg [7:0] in_temp;
    always @ (posedge clk)
    begin
        in_temp <= in;
        //便于理解写出了两种情况
        // pedge   <= (in & ~in_temp) & (~in & in_temp); 
        //更加简洁的写法
        anyedge   <= in ^ in_temp; 
    end
endmodule

(16) Egde capture register

module top_module (
    input clk,
    input reset,
    input [31:0] in,
    output [31:0] out
);
	//捕获下降沿
    reg [31:0] in_temp;
    always @(posedge clk)   
    begin
        in_temp <= in;
        //每一位都要检测
        for(int i=0;i<32;i=i+1)
        begin
            //这里的case条件用到了拼接运算符
            //当然这里使用if语句也完全ok
            case ({in_temp[i] & ~in[i] ,reset})
                2'b01:out[i] = 1'b0;
                2'b10:out[i] = 1'b1;
                //reset的优先级更加高一些
                2'b11:out[i] = 1'b0;
                default : out[i]=out[i];
             endcase
        end
    end
    
endmodule

(17) Dual-edge rtiggered flip-flop
双沿触发器

module top_module (
    input clk,
    input d,
    output q
);

    reg P_q,N_q;
    always @ (posedge clk)
    begin
        P_q<=d;
    end
    always @ (negedge clk)
    begin
        N_q<=d;
    end
    assign q = clk ? P_q:N_q;
endmodule

3.2.2 Counters

（1）Four-bit binnary counter

代码如下：

module top_module (
    input clk,
    input reset,      // Synchronous active-high reset
    output [3:0] q);

    always @ (posedge clk) begin
        if(reset)
            q<=4'b0;
        else if(q==4'b1111)
            q<=4'b0;
        else
            q<=q+1'b1;
    end
endmodule

（2）Decade counter

代码如下：

module top_module (
    input clk,
    input reset,        // Synchronous active-high reset
    output [3:0] q);

    always @ (posedge clk) begin
        if(reset)
            q<=4'b0;
        else if(q>=4'b1001)
            q<=4'b0;
        else
            q<=q+1'b1;
    end
endmodule

（3）Decade counter again

代码如下：

module top_module (
    input clk,
    input reset,
    output [3:0] q);

        always @ (posedge clk) begin
        if(reset)
            q<=4'b0001;
            else if(q>=4'b1010)
            q<=4'b1;
        else
            q<=q+1'b1;
    end
endmodule

**（4）Slow decade counter **
注意这里在普通的计数器加了一个控制（slowena），当他为1时计数器才加1；

代码如下：

module top_module (
    input clk,
    input slowena,
    input reset,
    output [3:0] q);

    always @ (posedge clk) begin
        if(reset)
            q<=4'b0;
        else if (slowena)begin
            if(q>=4'b1001)
            	q<=4'b0;
        	else
            	q<=q+1'b1;
    	end
        else
            q<=q;
    end
endmodule

（5）Counter 1-12

已给4位计数器模块：

题目：用所给模块例化一个1~12 的计数器。

module top_module (
    input clk,
    input reset,
    input enable,
    output [3:0] Q,
    output c_enable,
    output c_load,
    output [3:0] c_d
); 
	//使能端
	assign c_enable = enable; 
	//重新装载值
	//当复位或者工作状态下计数值到达12时，装载值设为1
    assign c_load = reset | ((Q==4'd12) && (enable == 1'b1)); 
    assign c_d = c_load;
    //例化
    count4 the_counter (clk, c_enable, c_load, c_d ,Q );

endmodule

（6）Counter 1000

题目：1000Hz分频成1Hz

module top_module (
    input clk,
    input reset,
    output OneHertz,
    output [2:0] c_enable
); //
    //one： 个位 ten： 十位 hundred：百位
    wire [3:0] one, ten, hundred;
    //                  [2]                         [1]           [0]   
    assign c_enable = {one == 4'd9 && ten == 4'd9 ,one == 4'd9 , 1'b1};
    //1000hz 计数1000次时为1秒即1hz
    assign OneHertz = (one == 4'd9 && ten == 4'd9 && hundred == 4'd9);
    
    bcdcount counter0 (clk, reset, c_enable[0],one);
    bcdcount counter1 (clk, reset, c_enable[1],ten);
    bcdcount counter2 (clk, reset, c_enable[2],hundred);

endmodule

（7）4-digit decimal counter

题目：构建4个十进制计数器，每个十进制数用四位表示

module top_module (
    input clk,
    input reset,   // Synchronous active-high reset
    output [3:1] ena,
    output [15:0] q);
    
    reg [3:0] one,ten,hundred,thousand;
    //个位递增
    always @(posedge clk) begin
        if(reset || one == 4'd9) begin
            one <= 4'd0;
        end else begin
            one<= one + 1'b1;
        end   
    end
    //十位递增
    always @(posedge clk) begin
        if(reset || ((one==4'd9) && (ten==4'd9))) begin
            ten <= 4'd0;
        end else if(ena[1]) begin
            ten <= ten +1'b1;
        end
    end
    //百位递增
    always @(posedge clk) begin
        if(reset || ((one==4'd9) && (ten ==4'd9) && (hundred==4'd9))) begin
            hundred <= 4'd0;
        end else if (ena[2])begin
            hundred <= hundred +1'b1;
        end
    end
    //千位递增
    always @(posedge clk) begin
        if(reset || ((one==4'd9)&& (ten ==4'd9) && (hundred==4'd9) && (thousand == 4'd9))) begin
            thousand <= 4'd0;
        end else if (ena[3])begin
            thousand <= thousand + 1'b1;
        end
    end
    assign q = {thousand,hundred,ten,one};
    //十位应该增加
    assign ena[1] = (one == 4'd9)?1'b1:1'b0;
    //百位应该增加
    assign ena[2] = ((one == 4'd9) && (ten == 4'd9))?1'b1:1'b0;
    //千位应该增加
    assign ena[3] = ((one == 4'd9) && (ten == 4'd9) && (hundred == 4'd9))?1'b1:1'b0;
    
endmodule

（8）12-hour counter

难点在各种繁杂临界点判断

module top_module(
    input clk,
    input reset,
    input ena,
    output pm,
    output [7:0] hh,
    output [7:0] mm,
    output [7:0] ss); 

    /*
     *组合逻辑用wire变量类型
     *时序逻辑用reg 变量类型
     */
    wire ss_en,ss_60_en;/*秒个位进十位的进位脉冲；秒计满60秒的进位脉冲*/
    reg [3:0] ss_one,ss_ten;/*秒的个位和十位*/
    
    wire mm_en,mm_60_en;/*分个位进十位的进位脉冲；分计满60分钟的进位脉冲*/
    reg [3:0] mm_one,mm_ten;/*分的个位和十位*/
    
    wire hh_en,pm_en;/*时个位进十位的进位脉冲；产生AM PM转换脉冲*/
    reg [3:0] hh_one,hh_ten;/*时的个位和十位*/
    
    /*
     * 真实的输出
     */
    assign ss = {ss_ten,ss_one};
    assign mm = {mm_ten,mm_one};
    assign hh = {hh_ten,hh_one};
    /*
     * 秒的个位
     */
    always @(posedge clk) begin
        if(reset) begin/*reset的优先级高于enable，并且复位后时钟为12：00 AM*/
            ss_one <= 4'b0;
        end
        else if(ena) begin
            if(ss_one == 4'd9) begin
                ss_one <= 4'b0;
            end
            else
                ss_one <= ss_one +1'b1;
        end
    end
    /*
     * 秒的十位
     */
    assign ss_en = (ss_one==4'd9 && ena) ? 1'b1:1'b0; /*秒个位进十位的脉冲信号*/
    always @(posedge clk) begin
        if(reset) begin/*reset的优先级高于enable，并且复位后时钟为12：00：00 AM*/
            ss_ten <= 4'b0;
        end
        else if(ss_en) begin
            if(ss_one == 4'd9 && ss_ten == 4'd5) begin
                ss_ten <= 4'b0;
            end
            else
                ss_ten <= ss_ten + 1'b1;
        end
    end
     /*
     * 分的个位
     */
    assign ss_60_en = (ss_one==4'd9 && ss_ten == 4'd5 && ena) ? 1'b1:1'b0; /*秒计时60秒时，向分进位的脉冲*/
    always @(posedge clk) begin
        if(reset) begin/*reset的优先级高于enable，并且复位后时钟为12：00 ：00 AM*/
            mm_one <= 4'b0;
        end
        else if(ss_60_en) begin
            if(mm_one==4'd9) begin
                mm_one <= 4'b0;
            end
            else
                mm_one <= mm_one + 1'b1;
        end
    end
    /*
     * 分的十位
     */
    assign mm_en = (mm_one == 4'd9 && ena && ss_one == 4'd9 && ss_ten ==4'd5)? 1'b1:1'b0;
    always @(posedge clk) begin
        if(reset) begin/*reset的优先级高于enable，并且复位后时钟为12：00：00 AM*/
            mm_ten <= 4'b0;
        end
        else if(mm_en) begin
            if(mm_one == 4'd9 && mm_ten == 4'd5 && ss_one == 4'd9 && ss_ten == 4'd5) begin
                mm_ten <= 4'b0;
            end
            else
                mm_ten <= mm_ten + 1'b1;
        end
    end
    /* 
     * 时的个位
     */
    assign mm_60_en = (mm_one == 4'd9 && mm_ten == 4'd5 && ss_one == 4'd9 && ss_ten == 4'd5)?1'b1:1'b0;
	 always @(posedge clk) begin
        if(reset) begin/*reset的优先级高于enable，并且复位后时钟为12：00：00 AM*/
            hh_one <= 4'd2;
        end
         else if(mm_60_en) begin /*注意判断0点和9点这两个临界条件*/
             //12:59:59
             if(hh_one==4'd2 && hh_ten==4'd1 && mm_one == 4'd9 && mm_ten == 4'd5 && ss_one == 4'd9 && ss_ten == 4'd5) begin
                hh_one <= 4'b1; /*12点过后就是1点了*/
             end
             //9:59:59
             else if(hh_one==4'd9 && hh_ten==4'd0 && mm_one == 4'd9 && mm_ten == 4'd5 && ss_one == 4'd9 && ss_ten == 4'd5)begin
                hh_one <=4'b0; /*9点之后是10点*/
             end
             else 
                hh_one <= hh_one + 1'b1;
        end
    end
    /* 
     * 时的十位
     */
    assign hh_en = (hh_one==4'd9 && hh_ten==4'd0 && mm_one == 4'd9 && mm_ten == 4'd5 && ss_one == 4'd9 && ss_ten == 4'd5)?1'b1:1'b0;
    always @(posedge clk) begin
    	if (reset) begin
        	hh_ten <= 4'b1;
    	end
    	else if ((hh_one == 4'd2) && (hh_ten == 4'd1) && (mm_one == 4'd9) && (mm_ten == 4'd5) && ena && (ss_one == 4'd9) && (ss_ten == 4'd5)) begin
        	hh_ten <= 4'd0;
    	end   
    	else if(hh_en) begin
        	hh_ten <= 4'd1;
    	end
    end
    //11:59:59 AM-> PM
    assign pm_en = ((hh_one == 4'd1) && (hh_ten == 4'd1) && (mm_one == 4'd9) && (mm_ten == 4'd5) && ena && (ss_one == 4'd9) && (ss_ten == 4'd5))?1'b1:1'b0;
    always @(posedge clk) begin
        if(reset) begin
            pm <= 1'b0;
        end
        else if(pm_en) begin
            pm <= ~pm;
        end
    end
endmodule

3.2.3 Shift Registers

(1) 4-bit shift register

module top_module(
    input clk,
    input areset,  // async active-high reset to zero
    input load,
    input ena,
    input [3:0] data,
    output reg [3:0] q); 

    always @(posedge clk,posedge areset) begin /*异步复位，因此要添加areset */
        if(areset) begin /* 如果复位为1，则输出全部置零*/
            q <= 4'b0000;
        end
        else if(load) begin/*load 比ena的优先级更加高*/
            q <= data[3:0];/*load有效时，输出装载data里的值*/ 
        end
        else if(ena) begin
            q <= {1'b0,{q[3:1]}};/*q[3] becomes zero, q[0] is shifted out and disappears*/
        end
        else
            q <= q;
    end
endmodule

(2) Left/right rotator

module top_module(
input clk,
input load,
input [1:0] ena,
input [99:0] data,
output reg [99:0] q);

    //1.建立一个一百位可左移可右移的寄存器，同步置位和使能
    //2.这个寄存器移入的位来自另一个寄存器的移出位
    //3.不像上一题的移入位是0，移出位舍弃
    //4.如果使能，这寄存器的每一位不会被修改或者舍弃，而是一直循环
    always @(posedge clk) begin
        if(load) begin /*load 优先级更高*/
            q <= data;
        end
        else begin
            case (ena) 
                2'b00:q<=q;/*保持*/
                2'b01:q<={q[0],q[99:1]};/*向右移一位*/
                2'b10:q<={q[98:0],q[99]};/*向左移一位*/
                2'b11:q<=q;/*保持*/
                default:q<=q;
            endcase
        end
    end
endmodule

(3) Left/right arithmetic shift by 1 or 8

逻辑移位：寄存器中整组数据进行移位，空位补0，只有数字位置的变化，无数量的变化。

算术移位：寄存器中带符号数的移位，移位时，符号位保持不变，仅数量变化。

module top_module(
    input clk,
    input load,
    input ena,
    input [1:0] amount,
    input [63:0] data,
    output reg [63:0] q); 
    
    always @(posedge clk) begin
        if( load )begin
            q <= data;
        end else if(ena) begin
            case (amount)
                2'b00:q <= {q[62:0],1'b0};
                2'b01:q <= {q[55:0],8'b0};
                2'b10:q <= {q[63],q[63:1]};
                2'b11:q <= {{8{q[63]}},q[63:8]};
            endcase
        end else
            q <= q;
    end
endmodule

(4) 5-bit LFSR

Galois LFSR 就是在正常的移位寄存器中加入一些抽头（异或门）从而实现有效状态（不会有全零状态）最大化（2^n - 1）。

module top_module(
	input clk,
	input reset,
	output [4:0] q
);
    always @(posedge clk) begin
     	if(reset)
            q <= 5'h1;
        else
            q <= {q[0],q[4],{q[3]^q[0]},q[2],q[1]};
    end
endmodule

(5) 3-bit LFSR

1.图中r0,r1,r2分别连接SW[0], SW[1], SW[2。]
2.Clock 连接KEY[0], L连接KEY[1]。
3.Q连接LEDR

注意：模块化会使代码更加简洁
代码如下：

module top_module (
	input [2:0] SW,      // R
	input [1:0] KEY,     // L and clk
	output [2:0] LEDR);  // Q
    
	//例化左边第一个
    dff_plus inst_left(
        .clk(KEY[0]),
        .in_1(SW[0]),
        .in_0(LEDR[2]),
        .sel(KEY[1]),
        .q(LEDR[0])
    );
    //例化中间那个
    dff_plus inst_mid(
        .clk(KEY[0]),
        .in_1(SW[1]),
        .in_0(LEDR[0]),
        .sel(KEY[1]),
        .q(LEDR[1])
    );
    //例化右边那个
    dff_plus inst_right(
        .clk(KEY[0]),
        .in_1(SW[2]),
        .in_0(LEDR[1]^LEDR[2]), //抽头
        .sel(KEY[1]),
        .q(LEDR[2])
    );
endmodule
//实现电路图中的一个模块
module dff_plus(
	input clk,
    input in_0,
    input in_1,
    input sel,
    output q
);
    //数据选择器输入
    wire in_temp;
    assign in_temp = sel ? in_1 : in_0;
    
    reg q_temp = 0;
    always @(posedge clk) begin
        q_temp <= in_temp;
    end
    assign q = q_temp;
endmodule

(6) 32-bit LFSR

题目：建立一个 32-bit Galois LFSR 抽头的位置放在32, 22, 2, 和 1.

module top_module(
    input clk,
    input reset,    // Active-high synchronous reset to 32'h1
    output [31:0] q
); 
    always @(posedge clk) begin
        if(reset)
            q <= 32'h1;
        else //tap 32                   22                    2          1
            q <= {q[0],{q[31:23]},{q[22]^q[0]},{q[21:3]},{q[2]^q[0]},{q[1]^q[0]}};
    end
endmodule

(6) Shift register

module top_module (
    input clk,
    input resetn,   // synchronous reset
    input in,
    output out);
    
    wire [2:0] qtemp;//输出中间态
	//例化左边第一个
    dff_res dff1(
        .clk(clk),
        .re_n(resetn),
        .in_temp(in),
        .q(qtemp[0])
    );
    //例化左边第二个
    dff_res dff2(
        .clk(clk),
        .re_n(resetn),
        .in_temp(qtemp[0]),
        .q(qtemp[1])
    );
     //例化左边第三个
    dff_res dff3(
        .clk(clk),
        .re_n(resetn),
        .in_temp(qtemp[1]),
        .q(qtemp[2])
    );
     //例化左边第四个
    dff_res dff4(
        .clk(clk),
        .re_n(resetn),
        .in_temp(qtemp[2]),
        .q(out)
    );  
endmodule

module dff_res(
    input clk,
    input re_n,
    input in_temp,
    output q
);
    always @(posedge clk) begin //同步
        if(!re_n) //低有效
            q <= 1'b0;
        else
            q <= in_temp;
    end
endmodule

(7) Shift register

module top_module (
    input [3:0] SW,
    input [3:0] KEY,
    output [3:0] LEDR
); //
    MUXDFF dff3(
        .clk(KEY[0]),
        .wData(KEY[3]),
        .ena(KEY[1]),
        .r_tmp(SW[3]),
        .l_tmp(KEY[2]),
        .q(LEDR[3])
    );
    
     MUXDFF dff2(
        .clk(KEY[0]),
        .wData(LEDR[3]),
        .ena(KEY[1]),
        .r_tmp(SW[2]),
        .l_tmp(KEY[2]),
         .q(LEDR[2])
    );
     MUXDFF dff1(
        .clk(KEY[0]),
        .wData(LEDR[2]),
        .ena(KEY[1]),
        .r_tmp(SW[1]),
        .l_tmp(KEY[2]),
        .q(LEDR[1])
    );
    MUXDFF dff0(
        .clk(KEY[0]),
        .wData(LEDR[1]),
        .ena(KEY[1]),
        .r_tmp(SW[0]),
        .l_tmp(KEY[2]),
        .q(LEDR[0])
    );
    
endmodule

module MUXDFF (
    input clk,
	input wData,
    input ena,
    input r_tmp,
    input l_tmp,
    output q
);
    wire [1:0] tmp;
    //组合逻辑
    assign tmp[0] = ena ? wData : q;
    assign tmp[1] = l_tmp ? r_tmp : tmp[0];
    //时序逻辑块
    always @(posedge clk) begin
        q <= tmp[1];
    end
endmodule

(8) 3-input LUT

可以解决组合逻辑使用门电路带来的延时的不确定性，LUT（查找表）相当于SRAM，把输入当成地址，输出当成该地址上的值。

module top_module (
    input clk,
    input enable,
    input S,
    input A, B, C,
    output Z ); 
    reg [7:0] q;
    //第一、建立一个8bit移位寄存器，且是将S移入第0位，最高位舍弃。
    always @(posedge clk) begin
        if(enable)begin
            q <= {q[6:0],S};
        end
        else begin
            q <= q;
        end
    end
    //A,B,C 为000 时 Z = q[0],,,
    assign Z = q[{A,B,C}]; //此处的{A,B,C}为3bit 3‘b000 = 3'd0;以此类推
endmodule

3.2.4 More Circuits

(1)Rule 90

题目：输出为旁边两位的异或，并且data【-1】和data【512】为0；

module top_module(
    input clk,
    input load,
    input [511:0] data,
    output [511:0] q ); 
    
    always @(posedge clk) begin
        if(load) begin
            q <= data;
        end else begin
            //     错位相异或即可得到输出
            //     q[512]       and          q[-1] are both zero            
            q <= {1'b0,q[511:1]}^{q[510:0],1'b0};
        end
    end
endmodule

(2)Rule 110

一维细胞自动机

题目与上一题一样，但是真值表不一样，直接看也看不出来，因此使用了卡诺图化简（数电的基础知识）。

再表述出来即可。

module top_module(
    input clk,
    input load,
    input [511:0] data,
    output [511:0] q
);
    //left -- A ;center -- B ;right -- C ;
    reg [511:0] A,B,C;
    //左边那一位
    assign A  = {1'b0,q[511:1]};
    //中间位
    assign B  = q;
    //右边那一位
    assign C  = {q[510:0],1'b0};
    always @(posedge clk)begin
        if(load)begin
        	q <= data;
        end
        else begin
            //根据题中给的真值表，卡诺图化简得来
            q <= ~B&C | ~A&B | B&~C;
        end
    end
endmodule

(3)Conway’s Game of Life 16*16

二维细胞自动机

举例（0，0）边界的邻居：

假设棋盘是这样的：下图举例了q[0]邻居位置，同理可以推测出棋盘上每一个位置的邻居

module top_module(
    input clk,
    input load,
    input [255:0] data,
    output [255:0] q ); 
	//用于记录邻居存活的个数
    reg [3:0] sum;
    //下一个状态
    reg [255:0] q_next;
    always @(posedge clk) begin
        if(load)
            q <= data;
        else begin
            for(integer i=0;i<256;i++) begin
                if(i==0)//左上角
                    sum = q[1]+q[16]+q[17]+q[240]+q[241]+q[15]+q[31]+q[255];
           	    else if(i==15)//右上角
                    sum = q[14]+q[16]+q[0]+q[240]+q[254]+q[30]+q[31]+q[255];
                else if(i==240)//左下角
                    sum = q[0]+q[15]+q[239]+q[241]+q[1]+q[224]+q[225]+q[255];
                else if(i==255)//右下角
                    sum = q[0]+q[15]+q[14]+q[224]+q[238]+q[240]+q[239]+q[254];
                else if(0<i & i<15)//上边界 //注意这里的书写不可以是0<i<15
                    sum = q[i-1]+q[i+1]+q[i+15]+q[i+16]+q[i+17]+q[i+239]+q[i+240]+q[i+241];
                else if(i%16==0)//左边界
                    sum = q[i-1]+q[i+1]+q[i+15]+q[i+16]+q[i+17]+q[i-16]+q[i-15]+q[i+31];
                else if(i%16==15)//右边界
                    sum = q[i-1]+q[i+1]+q[i+15]+q[i+16]+q[i-17]+q[i-16]+q[i-15]+q[i-31];
                else if(240<i & i<255)//下边界
                    sum = q[i-1]+q[i+1]+q[i-17]+q[i-16]+q[i-15]+q[i-239]+q[i-240]+q[i-241];
                else //非边界
                    sum = q[i-1]+q[i+1]+q[i-17]+q[i-16]+q[i-15]+q[i+15]+q[i+16]+q[i+17];
                //判断规则见本题第一个图
                case (sum)
                    2:q_next[i]=q[i];    //周围有两个则不变
                    3:q_next[i]=1;       //有三个则繁衍
                    default:q_next[i]=0; //其余情况都减员
                endcase
            end
            q <= q_next;
        end
    end
endmodule

3.2.5 Finite State Machines

(1)Simple FSM1

module top_module(
    input clk,
    input areset,    // Asynchronous reset to state B
    input in,
    output out);//  
	//状态编码
    parameter A=0, B=1; 
    reg state, next_state;
    always @(*) begin    // This is a combinational always block
        // State transition logic
        case (state)
            B: begin
            	//看状态图 输入为1则下一个状态也是B
                if(in == 1'b1)
                    next_state = B;
                else
                    next_state = A;
            end
            A: begin
                if(in == 1'b1)
                    next_state = A;
                else
                    next_state = B;
            end
        endcase
    end
	//异步所以要包含areset的敏感列表
    always @(posedge clk, posedge areset) begin    // This is a sequential always block
        // State flip-flops with asynchronous reset
        if(areset)
            state <= B;
        else
            state <= next_state;
    end
    // Output logic
    assign out = (state == B);
endmodule

(2)Simple FSM1s

与（1）一致 不过是同步复位了

// Note the Verilog-1995 module declaration syntax here:
module top_module(clk, reset, in, out);
    input clk;
    input reset;    // Synchronous reset to state B
    input in;
    output out;//  
    reg out;
    
    parameter A = 0, B = 1;
    reg present_state, next_state;
    always @(posedge clk) begin //同步复位
        if (reset) begin  
            present_state <= B;
        end
        else
            present_state <= next_state;
    end
    always @(*) begin
        case(present_state)
            A:begin
                if(in == 1'b1)
                    next_state = A;
                else
                    next_state = B;
            end
            B:begin
                if(in == 1'b1)
                    next_state = B;
                else
                    next_state = A;
            end
        endcase
    end
    
    assign out = (present_state == B);
endmodule

(3)Simple FSM2

2输入1输出的异步复位状态机；

module top_module(
    input clk,
    input areset,    // Asynchronous reset to OFF
    input j,
    input k,
    output out); //  

    parameter OFF=0, ON=1; 
    reg state, next_state;

    always @(*) begin
        case(state)
            OFF: begin
                if(j== 1'b1)
                    next_state = ON;
                else
                    next_state = OFF;
            end
            ON : begin
                if(k == 1'b1)
                    next_state = OFF;
                else
                    next_state = ON;
            end
        endcase
    end

    always @(posedge clk, posedge areset) begin
        if(areset)
            state <= OFF;
        else begin
            state <= next_state;
        end
    end

    // Output logic
    assign out = (state == ON);

endmodule

(3)Simple FSM2 S

module top_module(
    input clk,
    input reset,    // Synchronous reset to OFF
    input j,
    input k,
    output out); //  

    parameter OFF=0, ON=1; 
    reg state, next_state;
    always @(*) begin
        // State transition logic
        case(state)
            OFF: begin
                if(j== 1'b1)
                    next_state = ON;
                else
                    next_state = OFF;
            end
            ON : begin
                if(k == 1'b1)
                    next_state = OFF;
                else
                    next_state = ON;
            end
        endcase
    end
    always @(posedge clk) begin
        // State flip-flops with synchronous reset
        if(reset)
            state <= OFF;
        else begin
            state <= next_state;
        end
    end
    // Output logic
     assign out = (state == ON);
endmodule

(4)Simple state transitions 3

module top_module(
    input in,
    input [1:0] state,
    output [1:0] next_state,
    output out); //
    //状态编码A=2'b00, B=2'b01, C=2'b10, D=2'b11.
    parameter A=0, B=1, C=2, D=3;

    // State transition logic: next_state = f(state, in)
    always @ (*)begin
        case (state)
            A: begin
                if(in == 1'b1)
					next_state = B;
                else
                    next_state = A;
            end
           B: begin
                if(in == 1'b1)
					next_state = B;
                else
                    next_state = C;
            end
           C: begin
                if(in == 1'b1)
					next_state = D;
                else
                    next_state = A;
            end
           D: begin
                if(in == 1'b1)
					next_state = B;
                else
                    next_state = C;
            end
        endcase
    end
    // Output logic:  out = f(state) for a Moore state machine
    always @(*) begin
        case (state)
            A:out = 0;
            B:out = 0;
            C:out = 0;
            D:out = 1;
        endcase
    end
endmodule

(5)Simple one-hot state transitions 3

（1）one-hot 编码：这种编码方式所用的D触发器比递增二进制编码多，状态数就等于触发器的数量，这使得译码电路就比较简单，因此他的速度非常快。
（2）格雷编码：能够避免进入错误状态，常用于高可靠性设计。
（3）递增二进制编码：效率高，但是会导致很大的组合逻辑。
ps：编码方式见下图：

module top_module(
    input in,
    input [3:0] state,
    output [3:0] next_state,
    output out); //

    parameter A=0, B=1, C=2, D=3;

    // State transition logic: Derive an equation for each state flip-flop.
    assign next_state[A] = state[A]&(~in)  | state[C]&(~in);
    assign next_state[B] = state[A]&in | state[B]&in | state[D]∈
    assign next_state[C] = state[B]&(~in) | state[D]&(~in);
    assign next_state[D] = state[C]∈

    // Output logic: 
    assign out = state[D];

endmodule