HDLBits学习笔记：Sequential Logic

最新推荐文章于 2023-05-09 18:56:22 发布
最新推荐文章于 2023-05-09 18:56:22 发布
阅读量406 收藏 2
点赞数 1
分类专栏： veilog学习难点总结归纳 文章标签： verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmgotoac/article/details/115379842
版权

99. Four-bit binary counter

没什么说的

module top_module (
    input clk,
    input reset,      // Synchronous active-high reset
    output [3:0] q);
    initial q = 4'b0;
    always @(posedge clk)
        begin
            if(reset) q <= 4'h0;
            else
                begin
                    if(q == 4'hf) q = 4'h0;
                    else q = q + 1'b1;
                end
              
        end
endmodule

102. Count slow

if和else if

module top_module (
    input clk,
    input slowena,
    input reset,
    output [3:0] q);
    initial q = 4'h0;
    always @(posedge clk)
        begin
            if(reset) q <= 4'h0;
            else if(slowena)
                begin
                q <= q + 1'b1;
            	if(q == 4'd9) q <= 4'h0;
                end
        end
endmodule

103.Counter 1-12

错误代码：

module top_module (
    input clk,
    input reset,
    input enable,
    output [3:0] Q,
    output reg c_enable,
    output reg c_load,
    output reg [3:0] c_d
); 
    
    initial
        begin
            c_load = 1'b0;
            c_enable = 1'b1;
            Q = 4'd0;
        end
    always @(posedge clk)
        begin
            if(reset) 
                begin
                    c_load <= 1'b1;
                	c_d <= 4'd1;
                end
            else if(enable)
                begin

                        begin
                            c_load = 1'b0;
                            c_enable = 1'b1;
                        end
                end
            else
                c_enable = 1'b0;
        end
        count4 the_counter (clk, c_enable, c_load, c_d, Q);
endmodule

错误分析：总是滞后一个周期，是因为always在clk上升沿改变状态，因此下个上升沿才会改变the_counter状态。因此需要用assign 直接连接电路，实时改变状态，在第一个上升沿到来时就改变counter 状态。

正确代码：

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;
    assign c_load = reset | ((Q == 4'd12) && enable == 1'b1);
    assign c_d = c_load ? 4'd1 : 4'dz;
 
    count4 u_counter (clk, c_enable, c_load, c_d, Q);
 
endmodule

20210412:

104.Counter 1000

c_enable[1] , c_enable[2] 务必与低位相与。先画出想象中的4路Q输出，对应个十百千位，再写enable.

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

105.4-digital decimal counter

always中clk不写posedge会报错：

Error (23031): Evaluation of Tcl script /home/h/hdlbits/compile.tcl unsuccessful
Error: Quartus Prime Shell was unsuccessful. 1 error, 6 warnings

module top_module (
    input clk,
    input reset,   // Synchronous active-high reset
    output [3:1] ena,
    output [15:0] q);
    
    assign ena[1] = q[3] & q[0];
    assign ena[2] = (q[7] & q[4]) & ena[1];
    assign ena[3] = (q[11] & q[8]) & ena[2];
    
    cnt cnt0(clk, reset, 1'b1, q[3:0]);
    cnt cnt1(clk, reset, ena[1], q[7:4]);
    cnt cnt2(clk, reset, ena[2], q[11:8]);
    cnt cnt3(clk, reset, ena[3], q[15:12]);
    
endmodule

module cnt(
	input clk,
    input reset,
    input enable,
    output reg [3:0]q
);
    always@(posedge clk)
        begin
            if(reset) q = 4'd0;
            else if(enable)
                begin
                    if(q == 4'd9) q = 4'd0;
                    else q = q + 4'd1;
                end
        end
endmodule

20210413

106.12-hour clock

分秒和时针分开写，分秒：59-00；时针：01-09-12-01；因为是十六进制，用低四位高四位表示，进位信息作为输入。

module top_module(
    input clk,
    input reset,
    input ena,
    output pm,
    output [7:0] hh,
    output [7:0] mm,
    output [7:0] ss); 
    wire ena1, ena2, ena3, ena4;
    assign ena1 = (ss[3:0] == 4'h9) & ena;
    assign ena2 = (ss[7:4] == 4'h5) & ena1;
    assign ena3 = (mm[3:0] == 4'h9) & ena2;
    assign ena4 = (mm[7:4] == 4'h5) & ena3;
    cnt cnt0 (clk, reset, ena, 4'd0, 4'd0, 4'd9, ss[3:0]);
    cnt cnt1 (clk, reset, ena1, 4'd0, 4'd0, 4'd5, ss[7:4]);
    cnt cnt2 (clk, reset, ena2, 4'd0, 4'd0, 4'd9, mm[3:0]);
    cnt cnt3 (clk, reset, ena3, 4'd0, 4'd0, 4'd5, mm[7:4]);
    cnthh cnt4 (clk, reset, ena4, hh[7:0]);
    always@(posedge clk)
        begin
            if(reset) pm = 1'b0;
            else if(ena4 & (hh == 8'h11))
                pm = ~pm;
        end
endmodule

module cnt(
	input clk,
    input reset,
    input ena,
    input [3:0] start,
    input [3:0] renum,
    input [3:0] radix,
    output reg [3:0] q
);
    always@(posedge clk)
        begin
            if(reset) q = renum;
            else if(ena)
                begin
                    if(q == radix) q = start;
                    else q = q + 1'b1;
                end
        end
endmodule

module cnthh(
    input clk,
    input reset,
    input ena,
    output reg [7:0] q
);
    
    always@(posedge clk)
        begin
            if(reset) q = 8'h12;
            else if(ena)
                begin
                    if(q[7:4] == 0)
                        begin
                            if(q[3:0] == 4'd9) 
                                begin
                                    q[3:0] = 4'd0;
                                    q[7:4] = 4'd1;
                                end
                                
                            else q[3:0] = q[3:0] + 4'b1;
                        end
                    else
                        begin
                            if(q[3:0] == 4'd2) 
                                begin
                                    q[3:0] = 4'd1;
                                    q[7:4] = 4'd0;
                                end
                            else q[3:0] = q[3:0] + 4'b1;
                        end
                end
        end
endmodule

107.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)
        begin
            if(areset) q = 0;
            else if(load)
                q = data;
            else if(ena)
                begin
                    q = {1'b0, q[3], q[2], q[1]};
                end
        end
endmodule

108. 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)
        begin
            if(load) q = data;
            else
                begin
                    case (ena)
                        2'b01 : q = {q[0], q[99:1]};
                        2'b10 : q = {q[98:0], q[99]};
                        default;
                        endcase
                end
               
        end
endmodule

109.Left/right arthimetic shift by 1 or 8

算数右移保留符号位，移动后左侧全为符号位。

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) q = data;
            else if(ena)
                begin
                    case (amount)
                        2'b00 : q = {q[62:0], 1'b0};
                        2'b01 : q = {q[55:0], 8'd0};
                        2'b10 : q = {q[63], q[63:1]};
                        2'b11 : q = {{8{q[63]}}, q[63:8]};
                        default;
                    endcase
                end
               
        end
endmodule

110. 5-bit LFSR(linear feedback shift register )

module top_module(
    input clk,
    input reset,    // Active-high synchronous reset to 5'h1
    output [4:0] q
); 
    always@(posedge clk)
        begin
            if(reset) q = 5'h1;
            else 
                begin
                    q = {(q[0] ^ 1'b0), q[4], (q[3] ^ q[0]), q[2], q[1]};
                end
        end

endmodule

111. 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])
        begin
            if(KEY[1])
                LEDR = {SW};
            else
                LEDR = {LEDR[1] ^ LEDR[2], LEDR[0], LEDR[2]};
        end

endmodule

112. 32-bit LFSR

为什么右移？ position32指什么？

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

113.Shift register

module top_module (
    input clk,
    input resetn,   // synchronous reset
    input in,
    output out);
    reg q2, q1, q0;
    always@(posedge clk)
        begin
            if(!resetn)
                    {out, q2, q1, q0} = 4'b0;
            else
                    {out, q2, q1, q0} = {q2, q1, q0, in};
        end
endmodule

20210414

114.Shift register

module top_module (
    input [3:0] SW,
    input [3:0] KEY,
    output [3:0] LEDR
); //
    MUXDFF mux0(KEY[0], KEY[1], KEY[2], KEY[3], SW[3], LEDR[3]);
    MUXDFF mux1(KEY[0], KEY[1], KEY[2], LEDR[3], SW[2], LEDR[2]);
    MUXDFF mux2(KEY[0], KEY[1], KEY[2], LEDR[2], SW[1], LEDR[1]);
    MUXDFF mux3(KEY[0], KEY[1], KEY[2], LEDR[1], SW[0], LEDR[0]);
    
endmodule

module MUXDFF (
    input clk,
	input e,
    input l,
    input w,
    input r,
    output reg q
);
    always@(posedge clk)
        begin
            if(e)
                begin
                    if(l) q = r;
                    else q = w;
                end
            else
                begin
                    if(l) q = r;
                    else q = q;
                end
        end
endmodule

115. 3-input LUT( look-up-table 查找表)

分清楚组合电路和时序电路，其中Z的查找是组合电路，要么按笔者assign写，要么用always@(*)来写，切忌用clk边沿触发写组合电路，会出现延时。笔者刚开始就犯了这个错误。

module top_module (
    input clk,
    input enable,
    input S,
    input A, B, C,
    output Z ); 
    reg [7:0] q;
    always@(posedge clk)
        begin
            if(enable)
                    q <= {q[6:0], S};
            else q <= q;
        end
    assign Z = q[{A, B, C}];
endmodule

116. Rule90(元胞自动机)

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

116. Rule 110

这道题应该先卡诺图化简的，笔者做的比较繁琐。

module top_module(
    input clk,
    input load,
    input [511:0] data,
    output reg [511:0] q
); 
    integer i;
    always@(posedge clk)
        begin
            if(load) q = data;
            else
                begin
                    case ({q[1], q[0], 1'b0})
                        3'b000 : q[0] <= 1'b0;
                                3'b001 : q[0] <= 1'b1;
                                3'b010 : q[0] <= 1'b1;
                                3'b011 : q[0] <= 1'b1;
                                3'b100 : q[0] <= 1'b0;
                                3'b101 : q[0] <= 1'b1;
                                3'b110 : q[0] <= 1'b1;
                                3'b111 : q[0] <= 1'b0;
                                default;
            		endcase
                    case ({1'b0, q[511], q[510]})
                        3'b000 : q[511] <= 1'b0;
                        3'b001 : q[511] <= 1'b1;
                                3'b010 : q[511] <= 1'b1;
                                3'b011 : q[511] <= 1'b1;
                                3'b100 : q[511] <= 1'b0;
                                3'b101 : q[511] <= 1'b1;
                                3'b110 : q[511] <= 1'b1;
                                3'b111 : q[511] <= 1'b0;
                                default;
            		endcase
                    for(i = 1; i < 511; i = i + 1)
                        begin
                            case ({q[i + 1], q[i], q[i - 1]})
                                3'b000 : q[i] <= 1'b0;
                                3'b001 : q[i] <= 1'b1;
                                3'b010 : q[i] <= 1'b1;
                                3'b011 : q[i] <= 1'b1;
                                3'b100 : q[i] <= 1'b0;
                                3'b101 : q[i] <= 1'b1;
                                3'b110 : q[i] <= 1'b1;
                                3'b111 : q[i] <= 1'b0;
                                default;
            				endcase
                        end
                end
        end
endmodule

117. Game

抄的，处理好四边即可，数学运算。

module top_module(
    input clk,
    input load,
    input [255:0] data,
    output [255:0] q ); 
    
    reg [3:0]	sum;
    integer i;
 
    always@(posedge clk)begin
        if(load)begin
            q <= data;
        end
        else begin
            for(i = 0; i <= 255; i = i + 1)begin
                if(i == 0)begin
                    sum = q[255] + q[240] + q[241] + q[15] + q[1] + q[31] + q[16] + q[17];
                end
                else if(i == 15)begin
                    sum = q[254] + q[255] + q[240] + q[14] + q[0] + q[30] + q[31] + q[16];
                end
                else if(i == 240)begin
                    sum = q[239] + q[224] + q[225] + q[255] + q[241] + q[15] + q[0] + q[1];
                end
                else if(i == 255)begin
                    sum = q[238] + q[239] + q[224] + q[254] + q[240] + q[14] + q[15] + q[0];
                end
                else if(i > 0 && i < 15)begin
                    sum = q[i + 239] + q[i + 240] + q[i + 241] + q[i - 1] + q[i + 1] + q[i + 15] + q[i + 16] + q[i + 17];
                end
                else if(i > 240 && i < 255)begin
                    sum = q[i -17] + q[i - 16] + q[i - 15] + q[i - 1] + q[i + 1] + q[i - 241] + q[i - 240] + q[i - 239];
                end
                else if(i % 16 == 0)begin
                    sum = q[i -1] + q[i - 16] + q[i - 15] + q[i + 15] + q[i + 1] + q[i + 31] + q[i + 16] + q[i + 17];
                end
                else if(i % 16 == 15)begin
                    sum = q[i -17] + q[i - 16] + q[i - 31] + q[i - 1] + q[i - 15] + q[i + 15] + q[i + 16] + q[i + 1];
                end
                else begin
                    sum = q[i - 17] + q[i - 16] + q[i - 15] + q[i - 1] + q[i + 1] + q[i + 15] + q[i + 16] + q[i + 17];
                end
                case(sum)
                    4'd2:begin
                        q[i] <= q[i];
                    end
                    4'd3:begin
                        q[i] <= 1'b1;
                    end
                    default:begin
                        q[i] <= 1'b0;
                    end
                endcase
            end
        end
    end       
 
endmodule
acmgotoac
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tf2学习笔记
01-07
model = keras.models.Sequential() model.compile(loss=, optimizer=, metrics=) model.fit(x_train,y_train,validation_data = (x_valid_scaled,y_valid),epochs = 100,callbacks = callbacks) model.evaluate(x_...
quartus 编译报错修改方法
livercy
11-27 1万+
源代码： module adder( input [31:0] operand1, input [31:0] operand2, input cin, output [31:0] result, output cout ); assign {cout,result} = operand1 + operand2 + cout; endmodule 报错： Error (10170): Verilog HDL syntax error at Verilog1.v(8) near te
Quartus软件报错记录
qq_57320111的博客
12-15 3290
这是一个子模块的仿真，子模块中输出的O_LED_A位宽是4位，顶层中也输出的有一个O_LED_A位宽是7位，分配管脚是时候是对7位分配的。在对子模块进行仿真的时候，因为名称相同，位宽不同，所以分配管脚中还是7位，导致出现了这个错误！就算把顶层模块代码删掉，由于管脚分配仍然存在，所以还是会报错。唯二的方法就是更换子模块输出端口名称，另一个就是把引脚分配全部删除掉。
三、12【Verilog HDL】用户自定义原语（UDP）
ARM_qiao的博客
06-03 1670
参考书籍：《Verilog HDL 数字设计与综合》第二版，本文档为第12章的学习笔记。用户自定义原语（User-Defined Primitive，UDP），在UDP中不能调用（实例引用）其他模块或者其他原语，其调用方式和门级原语调用方式相同。UDP的类型：定义关键字：primitive开始，原语名称、输出输入端口，initial语句（用于初始化时许逻辑UDP的输出端口）。UDP状态表是UDP最终要的部分，以关键字table开始，endtable结束，状态表定义了输入状态和当前状态得到的输出值，可以是一个
Verilog HDL复习总结
jingyu_1的博客
06-27 2532
Verilog期末复习
HDLBits学习笔记
gakkif的博客
05-09 127
HDLBits学习笔记
NIOS II 常见问题总结
lrx2712的专栏
01-09 1557
 1. 怎样在TCL脚本分配管脚 source .tcl 有点问题：# source stratix_pin_assign.tcl couldnt read file "stratix_pin_assign.tcl": no such file or directory答： From the Tools menu select Tcl Scripts, and then
Keras中的两种模型:Sequential和Model用法
09-16
在深度学习框架Keras中，有两种主要的模型构建方式：Sequential模型和Model模型。它们各自有特定的用途和优势，适用于不同类型的神经网络架构。 **Sequential模型** 是Keras中最基础的模型类型，主要用于构建简单的...
粒子过滤器：Sequential Monte Carlo-matlab开发
05-29
用于估计高斯切换线性动态系统 (SLDS) 状态的粒子滤波器
数字逻辑设计及应用：chap7 Sequential Logic Design Principles.ppt
09-19
数字逻辑设计及应用：chap7 Sequential Logic Design Principles 基于本节课的内容，我们可以总结出以下几点重要的知识点： 一、顺序逻辑设计原则 * 顺序逻辑电路的设计原则是指在数字逻辑电路设计中，对于顺序...
HDL bits 网站刷题答案
11-08
这是HDL bits 刷题网站上的答案 大家可以参考下，里面的答案很全面，仅供参考，想要提升还是需要自己写，而不是嫖
HDLBits 系列（8）——Sequential Logic（Finite State Machines（一））
Bronceyang的博客
09-09 1031
目录 3.2 Sequential Logic 3.2.5 Finite State Machines 1.Simple FSM 1 (asynchronous reset) 2.Simple FSM 1 (synchronous reset) 3.Simple FSM 2 (asynchronous reset) 4.Simple FSM 2 (synchronous reset) 5.Simple state transitions 3 6.Simple one-hot st...
Mit6.004-05-Sequential Logic
热门推荐
code a better life~
06-09 19万+
1. 某些我们仍无法构建的 组合设备：输出仅取决于此时输入 灯开，按钮按下后，灯变关 灯关，按钮按下后，灯变开 输入：按钮，输出：灯，输出取决于设备当前状态以及输入 2. 数字状态：我们想要构建的 这种组合逻辑和内存组件组成的电路称为时序逻辑 本章主要目的是构建内存组件 3. 内存：使用电容 电压用来编码信息，电容用来存储电压 写：bitLine设置为要写入的电平，wordLine设高电平打开FET开关，让电容变为与bitLine一样的电压 读：bitLine预先设置为某个电压，wordLine设高电
FPGA工作原理
highhill520的专栏
11-03 3493
一.查找表（Look-Up-Table)的原理与结构采用这种结构的PLD芯片我们也可以称之为FPGA：如altera的ACEX,APEX系列,xilinx的Spartan,Virtex系列等。查找表（Look-Up-Table)简称为LUT，LUT本质上就是一个RAM。 目前FPGA中多使用4输入的LUT，所以每一个LUT可以看成一个有4位地址线的16x1的RAM。 当用户通过原理图或HD
时序分析基本概念介绍<Sequential logic>
Tao_ZT的博客
05-12 2228
今天我们要介绍的时序分析基本概念是Sequential logic。中文名，时序逻辑单元。时序逻辑单元是数字IC设计中另一类重要器件，它的特点是任意时刻的输出不仅取决于该...
Quartus II和Nios II使用时遇到的错误及解决方法总结
baidu_34971492的博客
08-17 1万+
问题1： nios烧写报错error code 8 base=0x211000 --epcs --sidp=0x212AA0 --id=0x0 --accept-bad-sysid --device=1 代码太大，超出了代码空间的大小 问题2: nios 调试时出现FAILED downloading ELFfailed ,Nios调试的时候出现downloadingELFprocess fai...
verilog异步复位jk触发器_Verilog（Sequential logic）
weixin_33831535的博客
01-04 5294
概念(sequential logic)时序逻辑：任意时刻输出不仅与当前时刻的输入，而且还取决于电路原来的状态。与组合逻辑不同，时序逻辑有时钟信号，复位信号类型①触发器 always @(posedge clk) begin // 通过时钟的上升沿进行赋值 q<=d; end 在 t0 时刻时，d 的值为 0，则 q 的值也为 0；在 t1 时刻 d 发生了变化，值为 1，那么...
HDLBits学习笔记（107~115)
Dspangpang的博客
11-15 982
HDLBits学习笔记（107~) 学习阶段：有问题发873727286@qq.com大家一起讨论。
Tcl - catch
dongyanxia1000的专栏
09-07 2649
catch -- 评估脚本，捕捉异常行为和返回 evaluate script and trap exceptional returns. catch script ?resultVarName? ?optionsVarName? 通过停止解析interpret命令来防止错误的发生。 The catch command calls the Tcl interpreter (解释程
q_net): Sequential
最新发布
06-05
这是一个Python语言中常用的神经网络模型构建方法。其中 `Sequential` 是一个神经网络模型的容器，可以通过向其中添加不同类型的神经网络层来构建一个完整的...通过对该网络进行训练，可以实现强化学习中的决策过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值