verilog(二) HDLBits

最新推荐文章于 2022-10-11 22:34:55 发布
最新推荐文章于 2022-10-11 22:34:55 发布
阅读量173 收藏 1
点赞数 1
分类专栏： verilog HDLBits 文章标签： verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aap6666666/article/details/115705376
版权

文章目录

Circuits

Combinational Logic

Multiplexers

4.14****************************

Mux256to1v
module top_module( 
    input [1023:0] in,
    input [7:0] sel,
    output [3:0] out );
    assign out = in[sel*4+3 -: 4];

endmodule


不能写成 assign = out[sel*4+3 : sel*4]，右限不能是变量
使用 -: ,+: 
-:      变量[结束地址 -: 数据位宽] <–等价于–> 变量[结束地址：(结束地址-数据位宽+1)]
+: 	变量[起始地址 +: 数据位宽] <–等价于–> 变量[(起始地址+数据位宽-1)：起始地址]

Arithmetic Circuits

xxx adder

都可以用以下：

assign {cout,sum} = a+b+cin;
3-bit binary adder
module top_module( 
    input [2:0] a, b,
    input cin,
    output [2:0] cout,
    output [2:0] sum );
    assign {cout[0],sum[0]} = a[0]+b[0]+cin;
    assign {cout[1],sum[1]} = a[1]+b[1]+cout[0];
    assign {cout[2],sum[2]} = a[2]+b[2]+cout[1];       
endmodule
Adder
module top_module (
    input [3:0] x,
    input [3:0] y, 
    output [4:0] sum);
    wire [2:0] cout;
    assign {cout[0],sum[0]} = x[0]+y[0];
    assign {cout[1],sum[1]} = x[1]+y[1]+cout[0];
    assign {cout[2],sum[2]} = x[2]+y[2]+cout[1];  
    assign {sum[4],sum[3]} = x[3]+y[3]+cout[2];
    
endmodule
Signed addition overflow
module top_module( 
    input [99:0] a, b,
    input cin,
    output cout,
    output [99:0] sum );
    wire [99:0] mid_cout;
    
    fulladder fulladder_0(a[0],b[0],cin,mid_cout[0],sum[0]);
    
    genvar i;
    generate 
        for(i=1;i<100;i++) begin:fulladder
            fulladder fulladder_i(a[i],b[i],mid_cout[i-1],mid_cout[i],sum[i]);
        end      
    endgenerate
    
    assign cout = mid_cout[99];

endmodule

module fulladder(a,b,cin,cout,sum);
    input a,b,cin;
    output cout,sum;
    assign {cout,sum} = a+b+cin;
    
endmodule
4-digit BCD adder
module top_module( 
    input [15:0] a, b,
    input cin,
    output cout,
    output [15:0] sum );
    
    wire [3:0] mid_cout;
    
    bcd_fadd bcd_fadd_0(a[3:0],b[3:0],cin,mid_cout[0],sum[3:0]);
                                 
    assign cout = mid_cout[3];
    genvar i;
    generate
        for(i=1;i<4;i++)
            begin:bcd_fadd
                bcd_fadd bcd_fadd_i(a[4*i+3 -: 4],b[4*i+3 -: 4],mid_cout[i-1],mid_cout[i],sum[4*i+3 -: 4]);
            end           
    endgenerate
      
endmodule

Karnaugh Map to Circuit

3-variable
module top_module(
    input a,
    input b,
    input c,
    output out  ); 
    wire [2:0] mid;
    assign mid = {a,b,c};
    assign out = (mid==0)? 0:1;   	

endmodule
4-variable
module top_module(
    input a,
    input b,
    input c,
    input d,
    output out  ); 
    wire [3:0] mid;
    assign mid={a,b,c,d};
    always@(*)
        case(mid)
            4'b1100:out=0;
            4'b1101:out=0;
            4'b0011:out=0;
            4'b0101:out=0;
            4'b1110:out=0;
            4'b1010:out=0;
            default:out=1;
        endcase
            
endmodule

***********4.16

K-map implemented with a multiplexer
module top_module (
    input c,
    input d,
    output [3:0] mux_in
    
); 
    wire [1:0] cd;
    assign cd = {c,d};
    always@(*)
        begin
        case(cd)
            0:mux_in = 0100;
            1:mux_in = 0001;
            2:mux_in = 0101;
            3:mux_in = 1001;
            default:mux_in = 0100;
        endcase
        end

endmodule

Sequential Logic

Latches and Flip-Flops

DDF 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 == 0)
                q<={8{1'b0}};
            else 
                begin
                if(byteena[1])
                    q[15:8]<= d[15:8];
            	if(byteena[0])
                    q[7:0]<= d[7:0];
                end
        end
           
endmodule
Mux and DFF
module top_module (
	input clk,
	input L,
	input r_in,
	input q_in,
	output reg Q);
    
    always@(posedge clk)
        begin
            case(L)
                0:Q <= q_in;
                1:Q <= r_in;
                default:Q <= 0;
            endcase
        end

endmodule
Mux and DFF
module top_module (
    input clk,
    input w, R, E, L,
    output Q
);
    always@(posedge clk)
        begin
            case(L)
                0:case(E)
                    0:Q <= Q;
                    1:Q <= w;
                    default:Q <= 0;
                endcase
                1:Q <= R;
                default:Q <= 0;
            endcase
        end
        

endmodule

*************4.17

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
Create circuit from truth table
module top_module (
    input clk,
    input j,
    input k,
    output Q);
    wire [1:0] jk;
    assign jk = {j,k};
    always@(posedge clk)
        begin
            case(jk)
                0:Q <= Q;
                1:Q <= 0;
                2:Q <= 1;
                3:Q <= ~Q;
                default:Q <= 0;
            endcase
        end

endmodule
Detect an edge
always 块结束后，统一赋值

module top_module (
    input clk,
    input [7:0] in,
    output [7:0] pedge    
);
    integer i;
    reg [7:0] in_tmp;
    always@(posedge clk)
        begin
        	in_tmp <= in;
            for(i=0;i<=7;i++)
                begin
                    if(in_tmp[i]==0 && in[i]==1)
                        pedge[i]=1;
                    else 
                        pedge[i]=0;
                end
        end
    
endmodule
Detect both edges
module top_module (
    input clk,
    input [7:0] in,
    output [7:0] anyedge
);

    integer i;
    reg [7:0] in_tmp;
    always@(posedge clk)
        begin
            in_tmp <= in;
            for(i=0;i<=7;i++)
                begin
                    if(in_tmp[i]^in[i])
                        anyedge[i]=1;
                    else
                        anyedge[i]=0;
                end
        end
    
endmodule
Edge capture register
module top_module (
    input clk,
    input reset,
    input [31:0] in,
    output [31:0] out
);
    reg [31:0] in_last;//the input in the last clk
integer i;
    always@( posedge clk )
	begin
        in_last <= in;
		if(reset)
		out<={32{1'b0}};
		else
			begin

				for(i=0;i<=31;i++)
					begin
                        if(in_last[i]==1 && in[i]==0) 
                        //下降沿out <= out |(in_last & ~in);
							out[i] <= 1;   

					end
			end
	end
endmodule
Dual-edge
module top_module (
    input clk,
    input d,
    output q
);
    reg [1:0] status;
    
    always @(posedge clk) begin
        status[0] <= d;
    end
    
    always @(negedge clk) begin
        status[1] <= d; 
    end
    
    assign q = (clk) ? status[0] : status[1];
    
endmodule

*****2021.5.21

Counters

Counter
module top_module (
    input clk,
    input reset,
    output OneHertz,
    output [2:0] c_enable
); //
    wire [3:0] Q0,Q1,Q2;
    assign c_enable[0] = 1;
    assign c_enable[1] = (Q0=='d9);
    assign c_enable[2] = (Q0=='d9 && Q1=='d9);
    assign OneHertz = (Q0=='d9 && Q1=='d9 && Q2=='d9);
    bcdcount counter0 (clk, reset,c_enable[0], Q0);
    bcdcount counter1 (clk, reset,c_enable[1], Q1);
    bcdcount counter2 (clk, reset,c_enable[2],Q2);


endmodule
4-digit decimal counter
使用组合的形式

module top_module (
    input clk,
    input reset,   // Synchronous active-high reset
    output [3:1] ena,
    output [15:0] q);
    
    //always@(posedge clk)
    assign ena[1] = (q[3:0]=='d9);
    assign ena[2] = (q[3:0]=='d9 && q[7:4] =='d9);
    assign ena[3] = (q[3:0]=='d9 && q[7:4] =='d9 && q[11:8] == 'd9);
    
    
    ten_counters t1(q[3:0],1,clk,reset);
    ten_counters t2(q[7:4],ena[1],clk,reset);
    ten_counters t3(q[11:8],ena[2],clk,reset);
    ten_counters t4(q[15:12],ena[3],clk,reset);
endmodule

module ten_counters(
    output [3:0] q,
	input enable,
    input clk,
	input reset
);
    always @(posedge clk)
        if(reset)
            q <= 0;
    	else
            if(enable)
                begin
                if(q == 'd9)
                    begin
                    q <= 0;
                 //   ena <= 1;
                    end
                else
                    begin
                    q <= q + 1;
                 //   ena <= 0;
                    end
                end
endmodule

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

    
    assign ena1 = (ss == {4'b0101,4'b1001});
    assign ena2 = (ss == {4'b0101,4'b1001} && mm =={4'b0101,4'b1001});
    assign pm =(ss == {4'b0101,4'b1001} && mm =={4'b0101,4'b1001} && hh=={4'b0001,4'b0001} )? !pm:pm;
    //always @(posedge clk)
        //  if(ss =='d59 & &&   == 59)
    
    counters_60 counter_s(ss,reset,clk,ena);
    counters_60 counter_m(mm,reset,clk,ena1);
    counters_12 counter_h(hh,reset,clk,ena2);
    
    

endmodule




module counters_10( //10进制
    output [3:0] q,
    input reset,
    input clk,
    input ena
);
    always@(posedge clk)
        if(reset)
            q <= 'd00;
    	else
            if(ena)
                if(q == 'd9)
                    q <= 0;
    			else
                    q <= q+1;
endmodule

module counters_6( 
    output [3:0] q,
    input reset,
    input clk,
    input ena
);
    always@(posedge clk)
        if(reset)
            q <= 'd0;
    	else
            if(ena)
                if(q == 'd5)
                    q <= 0;
    			else
                    q <= q+1;
endmodule


module counters_12( 
    output [7:0] qq,
    input reset,
    input clk,
    input ena
);
    initial qq =8'h0;
    wire [3:0] q;
    always@(posedge clk)
        if(reset)
            q <= 4'h12;
    	else
            if(ena)
                if(q == 4'h12)
                    q <= 1;
    			else
                    q <= q+1;
    
    always@(*)
        if(q < 4'h10)
            qq = q;
    	else
            case(q)
                4'h10:qq = {4'h1,4'h0};
                4'h11:qq = {4'h1,4'h1};
                4'h12:qq = 8'b00010010;
                //default: qq ='h0;
        	endcase
endmodule

module counters_60(
    output [7:0] q,
    input reset,
    input clk,
    input ena);
    wire ena1;
    assign ena1 = (q[3:0]=='d9);
    counters_6(q[7:4],reset,clk,ena1);
    counters_10(q[3:0],reset,clk,ena);
    
endmodule

******5.2

Shift Registers

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 or posedge areset)
        if(areset)
            q <= 4'h0;
    	else
            begin
            if(load)
                q <= data;
                else 
                    if(ena)
                   		 q <={{1'b0},q[3:1]};                    
           end                
endmodule
Left/right rotator
module top_module(
    input clk,
    input load,
    input [1:0] ena,
    input [99:0] data,
    output reg [99:0] q); 
    always@(posedge clk)
        if(load)
            q <= data;
    	else begin
            case(ena)
                2'd1:q<={q[0],q[99:1]};//shift right
                2'd2:q<={q[98:0],q[99]};//shift left
                default: q <= q;
            endcase
        end
endmodule
Left/right arithmetic shift by 1 or 8（算术移位）
一、对于有符号数 int
正数，左移直接丢弃最高位，在低位补对应个数的0；
正数，右移直接丢弃最低位，在高位补对应个数的0；
负数，左移直接丢弃最高位，在低位补对应个数的0；
负数，右移直接丢弃最低位，在高位补对应个数的1
二、对于无符号数 unsigned int
左移直接丢弃最高位，在低位补对应个数的0；
右移直接丢弃最低位，在高位补对应个数的0，即使最高位原来是1；

三、总结
算术右移：最高位填充符号位。正数填充0，负数填充1
逻辑右移：最高位填充0
左移都是补0
refer:https://blog.csdn.net/vainfanfan/article/details/87541575

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)
        if(load)
            q<=data;
    else if(ena) begin
        case(amount)
            2'b00:q<={q[62:0],1'b0};
            2'b01:q<={q[55:0],{8{1'b0}}};
            2'b10:q<={q[63],q[63:1]};
            2'b11:q<={{8{q[63]}},q[63:8]};
        endcase
    end
endmodule
5-bit LFSR
module top_module(
    input clk,
    input reset,    // Active-high synchronous reset to 5'h1
    output [4:0] q
); 
    always@(posedge clk)
        if(reset)
            q<=1;
    	else 
            q<={q[0]^1'b0,q[4],q[3]^q[0],q[2:1]};       
endmodule
3-bit LFSR
module top_module (
	input [2:0] SW,      // R
	input [1:0] KEY,     // L and clk
	output [2:0] LEDR);  // Q
    always@(posedge KEY[0])
        if(KEY[1])
            LEDR <= SW;
    	else begin
            LEDR <= {LEDR[1]^LEDR[2],LEDR[0],LEDR[2]};
        end

endmodule
32-bit LFSR (begin-end中的非阻塞赋值是并行的？)
module top_module(
    input clk,
    input reset,    // Active-high synchronous reset to 32'h1
    output [31:0] q
); 
    always@(posedge clk)
        if(reset)
            q<=32'h1;
    	else begin
            q<={q[0],q[31:1]};
            q[31]<=q[0]^1'b0;
            q[21]<=q[22]^q[0];
            q[1]<=q[2]^q[0];
            q[0]<=q[1]^q[0];
        end

endmodule
Shift register2
module top_module (
    input [3:0] SW,
    input [3:0] KEY,
    output [3:0] LEDR
); //


always@(posedge KEY[0])
    case(KEY[2])
        1:LEDR<=SW;
        0:begin
            case(KEY[1])
                1:LEDR<={KEY[3],LEDR[3:1]};
                default:;
            endcase
        end
        default:;
    endcase


endmodule
3-input LUT
module top_module (
    input clk,
    input enable,
    input S,
    input A, B, C,
    output Z ); 
    wire [7:0] Q;
    always@(posedge clk)
        if(enable)
            Q<={Q[6:0],S};
    	else
            ;
    
    always@(*)
        case({A,B,C})
            3'd0:Z = Q[0];
            3'd1:Z = Q[1];
            3'd2:Z = Q[2];
            3'd3:Z = Q[3];
            3'd4:Z = Q[4];
            3'd5:Z = Q[5];
            3'd6:Z = Q[6];
            3'd7:Z = Q[7];
            default: ;
        endcase
            
            

endmodule

More Circuits

Rule 90
module top_module(
    input clk,
    input load,
    input [511:0] data,
    output [511:0] q ); 
    integer i;
    always@(posedge clk)
        if(load)
            q<=data;
    else
        begin
            q[0]<=q[1];
            q[511]<=q[510];
        for(i=1;i<=510;i++)
            q[i] <= q[i-1] ^ q[i+1];
        end
    

endmodule
BlackDogv
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
verilog学习笔记（HDLbits基础篇）
qq_46198448的博客
10-06 2615
HDLbits（verilog练习网站） 拼接运算符 运算符号： {} 功能： 将两个或多个信号的某些为拼接起来。 {信号1的某几位，信号2的某几位……信号n的某几位} 如：{3{a,b}} = {{a,b},{a,b},{a,b}} = {a,b,a,b,a,b}; 图例： 代码实现： //非拼接运算附值办法 module top_module ( input a, input b, input c...
【Verilog题目练习】HDLBits题目集合
G1309183173的博客
03-27 2631
个人HDLBits练习
verilog学习 | HDLBits：在线学习答案
驚蟄的博客
07-01 9768
HDLBits 在提供 Verilog 基础语法教程的同时，还能够在线仿真 Verilog 模块。
HDLBits之Verilog学习记录 Day1
一只大憨憨的博客
06-21 369
1 Simple Wire Create a module with one input and one output that behaves like a wire. 注：、 1 Verilog 中的线（和其他信号）是有方向的。 2 在 Verilog 的“连续赋值”( assign left_side = right_side;) 中，右侧的信号值被驱动到左侧的导线上。赋值是“连续的”，因为即使右侧的值发生变化，赋值也会一直继续。连续分配不是一次性事件。 模块和端口声明创建了电路的黑色部分。通过添加
Verilog学习笔记之HDLBITS
m0_61597976的博客
10-11 135
首先是例化的括号里面，可以在信号后面加[]里面代表位数，并且没有的信号可以直接写1’b0;
HDLBits-Solutions-Verilog-master.rar
07-07
HDLBits-Solutions-Verilog-master.rar
Verilog-Practice:HDLBits网站实践与解决方案
05-28
Verilog实践 有一些做法。 并且所有这些都已经过验证。 我真的希望我的实践可以帮助您了解Verilog的工作原理。 2020.4.22-6:09:54：所有问题都解决了。 还有我的。 最后，生活真是太棒了。
HDLBits学习笔记.docx
04-07
在Verilog语言中，HDLBits是一个非常有用的资源，提供了许多简单而有意义的例子来帮助学习者理解和掌握Verilog的关键概念。下面将详细讨论文档中提到的两个重要知识点：隐含网（Implicit Nets）和未打包与打包数组...
HDLBits（答案）
09-01
1.里面为HDLBits的答案，包含个人的理解以及部分大佬的学习理解。 2.题目已经全部翻译成中文，附上图观看方便 3.文件类型为markdown文件
HDLBits:https
03-16
高密度脂蛋白 此存储库包含上述网站中给出的问题集的解决方案。
HDLBits——More Circuits
LoneJade_的博客
12-26 2202
HDLBits——More Circuits Problem 115 Rule90 Requirement： Rule90 是一道根据一些有趣的规则来生成一维序列的题目。 规则很简单：一维序列中元素有 1、0 两种状态，分别对应开、关状态。在每个时钟边沿到来时刻，元素的下一个状态为元素相邻两个元素的异或。下表更详细地给出了跳变的规则（可以视为状态转移表），元素下一个状态可以视作输出，输入为元素本身的状态与相应两个相邻元素的当前状态。 （“Rule90” 这个名字来自表中 “next state 下一状态”
Verilog学习笔记 HDLBits——Getting Started
bigRr的博客
07-12 256
HDLBits是一个Verilog在线学习网站，你可以直接在网站上编辑代码（Write your solution here框里），并进行综合仿真（点Submit，支持Quartus和Modelsim），查看波形图等（提交后会在下方显示）。Practice: Build a circuit with no inputs and one output. That output should always drive 1 (or logic high). 翻译:建立一个输出为1的电路。 Solution（不唯一
Hdlbits 之Module fadd（Add2）
qq_42409785的博客
03-15 426
之前写这道题的时候，可能网页翻译不太行，结果自己写了一个add16，原来题目已经定义过add16，只需要你定义add1即可，正确结果如下： module top_module ( input [31:0] a, input [31:0] b, output [31:0] sum ); reg link; add16 add16_inst1(.a(a[15:0]),.b(b[15:0]),.cin(0),.sum(sum[15:0]),.cout(link)); ad...
Verilog语法基础HDL Bits训练 01
qq_52450571的博客
07-17 954
在我学习FPGA之前，看过好多up主讲解怎样学习FPGA，在他们的视频中，总是能不约而同地能看到一个网站的名字HDLBits，这是一个训练Verilog语法的网站，可以对语法基础起到很正向的作用，因此我在今天开始，每天都会将HDLBits中的练习题整理出来，并附上一些自己的理解，如有表述错误，请敬请见谅，并且在评论区告诉我~...
HDLBits学习笔记（107~115)
Dspangpang的博客
11-15 981
HDLBits学习笔记（107~) 学习阶段：有问题发873727286@qq.com大家一起讨论。
VerilogHDL学习教程-HDLBits网站
DoCtorHe的博客
08-24 1700
这是一个HDL网站学习的汇总文章
HDLBits 题目打卡module fadd、module cseladd
weixin_44157994的博客
02-02 2511
HDLBits 题目打卡 寒假准备学习Verilog，使用HDLBits刷题，为了监督自己并做好一些记录决定在CSDN上留下我的题目解答。 题目1module fadd： 即实例化两个16位全加器实现一个不带进位输出的32位加法器功能，同时完成一位全加器module。 解答代码如下： module top_module ( input [31:0] a, input [31:0] b, output [31:0] sum );// wire cout1,cout2; add16 in
Verilog:HDLBits（Modules篇）
weixin_55831197的博客
06-26 239
2.3.1、Modules Module Solution: module top_module ( input a, input b, output out ); //模块名+例化名 （按顺序写出I/O口） //mod_a mod (a, b, out); //模块名+例化名 (.例化名称(例化地址), .(例化名称(例化地址))) mod_a mod (.in1(a), .in2(b), .out(out)); endmodule Submit: .
HDLBits在线Verilog编程练习
Harriet的博客
04-15 483
文章目录一、门电路相关练习1.非门2.与门3.或非门二、组合逻辑相关练习1.2对1多路复用器2.全加器3.卡诺地图三、时序逻辑相关练习1.D 触发器2.D锁存器3.1～12的计数器四、参考资料 一、门电路相关练习 1.非门 问题描述 参考下面链接 https://hdlbits.01xz.net/wiki/Notgate 问题解决代码 module top_module( input in, output out ); assign out=~in; endmodule 仿真结果 2.与门 问题描述
二verilog二选一
最新发布
08-26
对于 Verilog，你可以选择使用 Verilog HDL（硬件描述语言）或者 SystemVerilog（扩展版的 Verilog）。这两种语言都可以用来描述硬件电路，并且在数字系统设计中广泛使用。具体选择哪种语言取决于你的项目需求和个人...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值