Verilog学习笔记——时序逻辑——有限状态机1 Finite State Machines

于 2023-06-19 17:29:32 发布
阅读量393 收藏
点赞数
文章标签： 学习 笔记 fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43911447/article/details/131283833
版权

1. Simple FSM 1(asynchronous reset)   异步复位的简单FSM

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)
            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

    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 == ...);
            assign out = ( state == B);

endmodule

 

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

	// Give state names and assignments. I'm lazy, so I like to use decimal numbers.
	// It doesn't really matter what assignment is used, as long as they're unique.
	parameter A=0, B=1;
	reg state;		// Ensure state and next are big enough to hold the state encoding.
	reg next;
    
    
    // A finite state machine is usually coded in three parts:
    //   State transition logic
    //   State flip-flops
    //   Output logic
    // It is sometimes possible to combine one or more of these blobs of code
    // together, but be careful: Some blobs are combinational circuits, while some
    // are clocked (DFFs).
    
    
    // Combinational always block for state transition logic. Given the current state and inputs,
    // what should be next state be?
    // Combinational always block: Use blocking assignments.
    always@(*) begin
		case (state)
			A: next = in ? A : B;
			B: next = in ? B : A;
		endcase
    end
    
    
    
    // Edge-triggered always block (DFFs) for state flip-flops. Asynchronous reset.
    always @(posedge clk, posedge areset) begin
		if (areset) state <= B;		// Reset to state B
        else state <= next;			// Otherwise, cause the state to transition
	end
		
		
		
	// Combinational output logic. In this problem, an assign statement is the simplest.
	// In more complex circuits, a combinational always block may be more suitable.
	assign out = (state==B);

	
endmodule

2. Simple FSM 1(synchronous reset)   同步复位

 

// 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;

    // Fill in state name declarations

    reg present_state, next_state;

    always @(posedge clk) begin
        if (reset) begin  
            // Fill in reset logic
            present_state <= 1'b1;
            out<=1'b1;
        end else begin
            case (present_state)
                // Fill in state transition logic
                1'b1:next_state = in ? 1'b1 : 1'b0 ;
                1'b0:next_state = in ? 1'b0 : 1'b1 ;
            endcase

            // State flip-flops
            present_state = next_state;   

            case (present_state)
                // Fill in output logic
                1'b1:out<=1'b1;
                1'b0:out<=1'b0;
            endcase
        end
    end

endmodule

3. Simple FSM 2 （asynchronous reset）

 

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
        // State transition logic
        case(state)
            OFF: next_state= j ? ON  : OFF;
            ON : next_state= k ? OFF : ON;
        endcase
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)
            state <= OFF;
        else
            state <= next_state;
    end

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

endmodule

4.Simple FSM 2 （synchronous reset）

 

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
        // State transition logic
        case(state)
            OFF: next_state= j ? ON  : OFF;
            ON : next_state= k ? OFF : ON;
        endcase
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(reset)
            state <= OFF;
        else
            state <= next_state;
    end

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

endmodule

5. Simple state transitions 3

 

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

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

    // State transition logic: next_state = f(state, in)
    always@(*)begin
        case(state)
            A: next_state = in ? B : A ;
            B: next_state = in ? B : C ;
            C: next_state = in ? D : A ;
            D: next_state = in ? B : C ;
        endcase
    end

    // Output logic:  out = f(state) for a Moore state machine
    assign out = (state==D);

endmodule

6. Simple one-hot state transition 3

 

 

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]&in;
    assign next_state[C] = (state[B]|state[D])&(~in);
    assign next_state[D] = state[C]&in;

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

endmodule

7.Simple FSM 3（asynchronous reset)

 

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

    // State transition logic
    parameter A=0,B=1,C=2,D=3;
    reg [1:0]state,next;
    always@(*)begin
        case(state)
            A: next = in ? B : A ;
            B: next = in ? B : C ;
            C: next = in ? D : A ;
            D: next = in ? B : C ;
        endcase
    end
     
    // State flip-flops with asynchronous reset
    always@(posedge clk, posedge areset)begin
        if(areset)
            state <= A;
        else state<=next;
    end

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

endmodule

8. Simple FSM 3（synchronous reset)

 

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

    // State transition logic
    parameter A=0,B=1,C=2,D=3;
    reg [1:0]state,next;
    always@(*)begin
        case(state)
            A: next = in ? B : A ;
            B: next = in ? B : C ;
            C: next = in ? D : A ;
            D: next = in ? B : C ;
        endcase
    end
     
    // State flip-flops with synchronous reset
    always@(posedge clk)begin
        if(reset)
            state <= A;
        else state<=next;
    end

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

endmodule

9. Design a Moore FSM

 

module top_module (
    input clk,
    input reset,
    input [3:1] s,
    output fr3,
    output fr2,
    output fr1,
    output dfr
); 
    //A表示Below S1，B1表示上升到Between S1 and S2，C1表示S1-S2上升到S2-S3，
    //D表示Above S3，B2表示下降到Between S1 and S2，C2表示D下降到S2-S3。
    parameter A=0,B1=1,C1=2,D=3,C2=4,B2=5;
    reg [2:0] state,next_state;
    
    always @(posedge clk) begin
        if(reset) state<=A;
        else state<=next_state;
    end
    always @(*) begin
        case(state)
            A: next_state=s[1]?(s[2]?(s[3]?D:C1):B1):A;
            B1: next_state=s[1]?(s[2]?(s[3]?D:C1):B1):A;
            C1: next_state=s[1]?(s[2]?(s[3]?D:C1):B2):A;
            D: next_state=s[1]?(s[2]?(s[3]?D:C2):B2):A;
            C2: next_state=s[1]?(s[2]?(s[3]?D:C2):B2):A;
            B2: next_state=s[1]?(s[2]?(s[3]?D:C1):B2):A;
        endcase
        /*
        本题也可以不用判断所有s信号
        case(state)
        	A: next_state=s[1]?B1:A;
        	B1: next_state=s[1]?(s[2]?C1:B1):A;
        	C1: next_state=s[2]?(s[3]?D:C1):B2;
        	D: next_state=s[3]?D:C2;
        	C2: next_state=s[2]?(s[3]?D:C2):B2;
        	B2: next_state=s[1]?(s[2]?C1:B2):A;
        endcase
        */
    end
    //根据表格可以写出fr3，fr2，fr1
	assign fr3=(state==A);
    assign fr2=(state==A|state==B1|state==B2);
    assign fr1=(state==A|state==B1|state==B2)|(state==C2|state==C1);
    //B2,C2状态分别由下降得到，所以当处于这两个状态时dfr为1,
    //A状态为水位最低的状态，dfr为1
    assign dfr=(state==B2)|(state==C2)|(state==A);
endmodule

 10.Lemmings 1

 

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    output walk_left,
    output walk_right); //  

    // parameter LEFT=0, RIGHT=1, ...
    parameter LEFT=0, RIGHT=1;
    reg state, next_state;

    always @(*) begin
        // State transition logic
        case(state)
            LEFT :next_state=bump_left ?RIGHT:LEFT;
            RIGHT:next_state=bump_right?LEFT :RIGHT;
            endcase       
    end

    always @(posedge clk, posedge areset) begin
        // State flip-flops with asynchronous reset
        if(areset)
            state<=LEFT;
        else state<=next_state;
    end

    // Output logic
    assign walk_left = (state == LEFT);
    assign walk_right = (state == RIGHT);

endmodule
module top_module (
	input clk,
	input areset,
	input bump_left,
	input bump_right,
	output walk_left,
	output walk_right
);

	// Give state names and assignments. I'm lazy, so I like to use decimal numbers.
	// It doesn't really matter what assignment is used, as long as they're unique.
	parameter WL=0, WR=1;
	reg state;
	reg next;
    
    
    // Combinational always block for state transition logic. Given the current state and inputs,
    // what should be next state be?
    // Combinational always block: Use blocking assignments.    
    always@(*) begin
		case (state)
			WL: next = bump_left  ? WR : WL;
			WR: next = bump_right ? WL : WR;
		endcase
    end
    
    
    // Combinational always block for state transition logic. Given the current state and inputs,
    // what should be next state be?
    // Combinational always block: Use blocking assignments.    
    always @(posedge clk, posedge areset) begin
		if (areset) state <= WL;
        else state <= next;
	end
		
		
	// Combinational output logic. In this problem, an assign statement are the simplest.
	// In more complex circuits, a combinational always block may be more suitable.		
	assign walk_left = (state==WL);
	assign walk_right = (state==WR);

	
endmodule

11.Lemmings 2

 

 

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    output walk_left,
    output walk_right,
    output aaah ); 
    
    //parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3
    reg [2:0]state,next;
    parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3;
    
    //state transition logic
    always@(*)begin
        case(state)
            LEFT:next=ground?(bump_left?RIGHT:LEFT):FALL_L;
            RIGHT:next=ground?(bump_right?LEFT:RIGHT):FALL_R;
            FALL_L:next=ground?(LEFT):FALL_L;
            FALL_R:next=ground?(RIGHT):FALL_R;
        endcase
    end
    
    //state flip_flops with asynchronous areset
    always@(posedge clk, posedge areset)begin
        if(areset) state<=LEFT;
        else state<=next;
    end
    
    //output logic
    assign walk_left=(state==LEFT);
    assign walk_right=(state==RIGHT);
    assign aaah=(state==FALL_L || state==FALL_R );

endmodule

12.Lemmings 3

 

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    input dig,
    output walk_left,
    output walk_right,
    output aaah,
    output digging ); 
    
    //parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3
    reg [2:0]state,next;
    parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3,dig_L=4, dig_R=5;
    
    //state transition logic
    always@(*)begin
        case(state)
            LEFT:next=ground?(dig?dig_L:(bump_left?RIGHT:LEFT)):FALL_L;
            RIGHT:next=ground?(dig?dig_R:(bump_right?LEFT:RIGHT)):FALL_R;
            FALL_L:next=ground?LEFT:FALL_L;
            FALL_R:next=ground?RIGHT:FALL_R;
            dig_L: next=ground?dig_L:FALL_L;
            dig_R: next=ground?dig_R:FALL_R;
        endcase
    end
    
    //state flip_flops with asynchronous areset
    always@(posedge clk, posedge areset)begin
        if(areset) state<=LEFT;
        else state<=next;
    end
    
    //output logic
    assign walk_left=(state==LEFT);
    assign walk_right=(state==RIGHT);
    assign aaah=(state==FALL_L || state==FALL_R );
    assign digging=(state==dig_L  || state==dig_R);

endmodule

13. Limmings 4

 

 

module top_module(
    input clk,
    input areset,    // Freshly brainwashed Lemmings walk left.
    input bump_left,
    input bump_right,
    input ground,
    input dig,
    output walk_left,
    output walk_right,
    output aaah,
    output digging ); 

    //parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3,dig_L=4, dig_R=5, splat=6
    reg [2:0]state,next;
    parameter LEFT=0, RIGHT=1, FALL_L=2, FALL_R=3,dig_L=4, dig_R=5, splat=6;
    reg [4:0]T;
    reg signal;
    
    //state transition logic
    always@(*)begin
        case(state)
            LEFT:next=ground?(dig?dig_L:(bump_left?RIGHT:LEFT)):FALL_L;
            RIGHT:next=ground?(dig?dig_R:(bump_right?LEFT:RIGHT)):FALL_R;
            dig_L: next=ground?dig_L:FALL_L;
            dig_R: next=ground?dig_R:FALL_R;
            splat: next=splat;
            FALL_L:begin
                if(signal)
                    next=ground?splat:FALL_L;
                else
                    next=ground?LEFT:FALL_L;
            end
            FALL_R:begin
                if(signal)
                    next=ground?splat:FALL_R;
                else
                    next=ground?RIGHT:FALL_R;
            end 
        endcase
    end
    
    //splat
    always@(posedge clk, posedge areset)begin
        if(areset) T<=0;
        else if(state==FALL_L||state==FALL_R)
            begin
                if(T==19)
                        signal<=1;
                    else
                        T<=T+1;
            end
        else begin
           signal<=0;
           T<=0;
        end
    end
    
    //state flip_flops with asynchronous areset
    always@(posedge clk, posedge areset)begin
        if(areset) state<=LEFT;
        else state<=next;
    end
    
    //output logic
    assign walk_left=(state==LEFT);
    assign walk_right=(state==RIGHT);
    assign aaah=(state==FALL_L || state==FALL_R );
    assign digging=(state==dig_L  || state==dig_R);

endmodule

14.One-hot FSM

 

module top_module(
    input in,
    input [9:0] state,
    output [9:0] next_state,
    output out1,
    output out2);
    
    //state trasitision logic
    assign next_state[0]= ~in&(state[0]|state[1]|state[2]|state[3]|state[4]|state[7]|state[8]|state[9]);
    assign next_state[1]= in&(state[0]|state[8]|state[9]);
    assign next_state[6:2]={in&state[5],in&state[4],in&state[3],in&state[2],in&state[1]};
    assign next_state[7]= in&(state[6]|state[7]);
    assign next_state[8]= ~in&state[5];
    assign next_state[9]=~in&state[6];

    //output logic
    assign out1=((state[8]==1)|| (state[9]==1));
    assign out2=((state[7]==1)|| (state[9]==1));
            

endmodule

15.PS/2 packet parser

 

module top_module(
    input clk,
    input [7:0] in,
    input reset,    // Synchronous reset
    output done); //
    
    parameter s0=0,s1=1,s2=2,s3=3;
    reg[1:0] state,next;

    // State transition logic (combinational)
    always@(*)begin
        case(state)
            s0: next=in[3]?s1:s0;
            s1: next=s2;
            s2: next=s3;
            s3: next=in[3]?s1:s0;
        endcase
    end

    // State flip-flops (sequential)
    always@(posedge clk)begin
        if(reset) state<=s0;
        else state<=next;
    end
 
    // Output logic
    assign done=(state==3);

endmodule

 16. PS/2 packet parser and datapath

 

module top_module(
    input clk,
    input [7:0] in,
    input reset,    // Synchronous reset
    output [23:0] out_bytes,
    output done); //
    
    parameter s0=0,s1=1,s2=2,s3=3;
    reg[1:0]state,next;
    
    // FSM from fsm_ps2    
    always@(*)begin
        case(state)
            s0: next=in[3]?s1:s0;
            s1: next=s2;
            s2: next=s3;
            s3: next=in[3]?s1:s0;
        endcase
    end
    
    always@(posedge clk)begin
        if(reset) state<=s0;
        else state<=next;
    end
    assign done=(state==s3);

    // New: Datapath to store incoming bytes.
    always@(posedge clk)begin
        case(state)
                s0: out_bytes[23:16]<=in;
                s1: out_bytes[15:8]<=in;
                s2: out_bytes[7:0]<=in;
                s3: out_bytes[23:16]<=in;
            endcase
    end

endmodule

 

weixin_43911447
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
状态机verilog例程
qiuzy__的博客
09-27 285
状态机，verilog实例
[Verilog]有限状态机设计举例
元直的博客
12-30 2548
有限状态机（FSM）是许多数字系统中用来控制系统和数据流路径行为的时序电路。FSM的实例包括控制单元和时序。 本实验介绍了两种类型的FSM（Mealy和Moore）的概念，以及开发此类状态机的建模方式。 请参阅Vivado教程，了解如何使用Vivado工具创建项目和验证数字电路。
4、FPGA设计-复位与状态机
qq_38686101的博客
05-24 627
1、系统复位 1.1、Recovery time：恢复时间 撤销复位时，恢复到非复位状态的电平必须在时钟有效沿来临之前的一段时间到来,才能保证有效地恢复到非复位状态，此段时间为 recovery time。类似于同步时钟的 setup time。 1.2、Removal time：去除时间 复位时，在时钟有效沿来临之后复位信号还需要保持的时间为去除时间 removal time。类似同步时钟 hold time。 1.3、复位电路设计时，总是建议使用异步复位。 (1)为了更有效地利用期间资源。 (2)异步复
vue Empty block statement.报错
woshishui099的博客
07-31 726
【代码】vueEmptyblockstatement.报错。
利用有限状态机进行复杂时序逻辑的设计
08-03
有限状态机（Finite State Machine，FSM）是一种常用的数字电路设计方法，它可以用来实现复杂的时序逻辑电路。在Verilog HDL硬件描述语言中，有限状态机的设计方法得到了进一步的发展。通过Verilog HDL提供的语句，...
基于Verilog的有限状态机编程方式及研究
07-05
采用Verilog语言编程可以简化有限状态机设计过程,并优化硬件资源配置。本方案首先介绍了利用Verilog设计有限状态机的流程和不同方式,其次从电路的容错性、延时、面积等因素进行考量,着重对编码方式进行比较,最后根据...
有限状态机与Verilog设计.pdf
05-24
有限状态机与Verilog设计.pdf
信号灯_verilog_有限状态机_
09-29
定时跳转状态的信号灯，有控制信号调节状态
Verilog HDL基础教程之：时序逻辑电路
08-05
Verilog HDL基础教程之时序逻辑电路 时序逻辑电路是数字电路设计中的一种基本电路结构， Verilog HDL语言提供了强大的时序逻辑电路设计能力。本文将详细介绍Verilog HDL的时序逻辑电路设计方法和技术。 一、时序...
empty block statement 报错解决
m0_49789433的博客
08-16 6147
empty block statement 这个错误是因为vue严格模式，vscode不会直接报红线，空格和空行，都会导致这个问题，如果写了if然后{}是空的也是这个错误
ISE/Vivado调试过程中经常遇到的几种warning，以及解决办法，一些verilog使用技巧
热门推荐
weiyunguan8611的博客
09-02 7万+
由于最近已经也刚刚接手项目，遇到特别多的问题，所以把遇到的问题记录一下，自己学习的同时，把过程分享出来，希望对大家有一定的帮助，共同进步。下面就是ISE调试过程中经常遇到的几种warning，以及解决办法，自己整理成文档，以供参考： 1、Redeclaration of ansi port XX is not allowed “不允许重新声明ansi端口XX”。 出现的原因是在程序中声明了两......
状态机详解（Verilog编写状态机）（一）
qq_42786948的博客
03-31 8375
verilog实现状态机背景问题：计数状态机的实现Verilog实现此状态机1. 代码如下2. 代码的说明3. 代码的仿真 背景 在学习spinalHDL的时候对他的状态机的实现有很多不懂的地方，特地使用了verilog编写了一个相同的状态机来学习其中的时序。 问题：计数状态机的实现 状态转移图如下图所示 stateA：直接跳转到stateB,同时赋值cnt = 2 stateB：判断cnt的值是否为6，若是则跳转到stateC，没有则继续执行stateB，同时cnt <= cnt + 1’b1
数字IC必修之Verilog知识点——模块建立及常用语法总结过程块中的语法(面试小白考试)
weixin_42664351的博客
08-04 465
Module module my_module(out1,…,inN) ; output out1,…,outM; input in1,…,inN; …// declarations …// description of f (maybe sequential) endmodule Continuous Assignments assign #de1 (net type) = expr; inside a module outside procedures(always可综合 initial不..
Verilog的状态机编程
m0_45188639的博客
04-09 1196
1、状态机的设计 状态机是一种设计思路，将一个事件分成多个完整的状态，每个状态通过输入和输出进入下一个状态，这就是状态机思维。 为什么要用状态机思维呢，因为这种思维可以清晰快速的将事情分成多个独立的小部分，将这些小部分分别编程，可以最大程度的节约资源和时间。很多复杂的东西，堆在一起没有头绪，但分成好多状态后就会发现，所谓的复杂，只不过是多个状态的叠加而已。 2、状态机的Verilog编程（以野火教程：FPGA Verilog开发实战指南 第23章状态机为例） 用Verilog构成状态机通常有五部分：
ANTLR4权威指南 - 第6章 尝试一些实际中的语法
NullPointerException
08-29 7679
第6章 尝试一些实际中的语法 在前一章，我们学习了通用词法结构和语法结构，并学习了如何用ANTLR的语法来表述这些结构。现在，是时候把我们学到的这些用来构建一些现实世界中的语法了。我们的主要目标是，怎样通过筛选引用手册，样例输入文件和现有的非ANTLR语法来构建一个完整语法。这一章，我们要实现五种语言，难度依次递增。现在，你不需要将它们全部都实现了，挑一个你最喜欢的实现，当你在实践过程中遇到问
C++语法总结,语法查询
-----------------------------不要在跟自己无关的事情上浪费时间
06-28 6万+
How to Program in C++ http://cs.fit.edu/~mmahoney/cse2050/how2cpp.html How to Program in C++ You may copy this file for noncommercial use. The latest version is located at cs.fit.edu/~m
Vue搭建项目时报错：error Empty block statement no-empty
飞翔的小白
01-07 1万+
创建项目时，控制台出现报错信息，页面中代码空格引起的，具体原因还是eslint校验： 报错信息： 先来看下Vue的版本： Vue4.0中安装使用eslint的两种方式： 1、使用npm安装 npm install eslint --save-dev 2、安装 vue 专门的 ESLint 规则插件@vue/cli-plugin-eslint npm i @vue/cli-plugin-eslint --save-dev 3、添加配置文件 配置文件常用的方法有两种: 3-1、.
【代码分析】Pytorch版YOLO V4代码分析
c20081052的专栏
05-08 2万+
YOLO V4出来也几天了，论文大致看了下，然后看到大量的优秀者实现了各个版本的YOLOV4了。 Yolo v4 论文: https://arxiv.org/abs/2004.10934 AB大神Darknet版本的源码实现: https://github.com/AlexeyAB/darknet 本文针对Pytorch版本实现的YOLOV4进行分析，感谢Tianxiaomo 分享的工程：P...
verilog 组合逻辑和时序逻辑分别是什么
最新发布
05-01
在 Verilog 中，组合逻辑和时序逻辑是两种不同类型的逻辑电路。 组合逻辑是指电路的输出仅取决于输入，而不依赖于任何时钟或存储元件。组合逻辑电路的输出只与输入值及其逻辑关系有关，不受时间影响。组合逻辑电路主要用于计算和控制电路中的数据处理。 时序逻辑是指电路的输出不仅取决于输入，还受到时钟信号的影响。时序逻辑电路将输入数据存储在存储元件中，并在时钟信号的作用下根据存储元件中的值生成输出。时序逻辑电路主要用于存储和处理电路中的数据。 在 Verilog 中，组合逻辑可以通过“always @(*)”语句来实现，而时序逻辑则需要使用“always @(posedge clk)”或“always @(negedge clk)”语句来实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值