HDLBits150~176（状态转移图-仿真结果-testbench）

已于 2022-05-14 19:16:59 修改
阅读量377 收藏 1
点赞数
文章标签： verilog
于 2022-04-26 10:11:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41624212/article/details/124297691
版权

接下来的练习记录

150 Exams/review2015 count1k

module top_module (
    input clk,
    input reset,
    output [9:0] q);
    
    parameter count = 999;
    
    always@(posedge clk) begin
        if(reset) begin
            q <= 10'b0;
        end
        else if(q == count)
            q <= 10'b0;
        else
            q <= q + 1;
    end

endmodule

151 Exams/review2015 shiftcount

module top_module (
    input clk,
    input shift_ena,
    input count_ena,
    input data,
    output [3:0] q);
    
    always@(posedge clk)begin
        if(shift_ena)begin
            q <= {q[2:0],data};
        end
        else if(count_ena)begin
            q <= q -1;
        end        
    end

endmodule

152 exams/review2015_fsmseq

  序列检测自动机
在这里插入图片描述

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    output start_shifting);
    
	parameter RESET = 0,A =1,B =2,C=3,D=4;
    
    reg [4:0] state,next_state;
    always@(posedge clk) begin
        if(reset)
            state <= RESET;
        else
            state <= next_state;
    end
    
    always@(*) begin
        if(reset)
            next_state <= RESET;
        else begin
            case(state)
                RESET:next_state <= (data)?A:RESET;
                A:next_state <=(data)?B:RESET;
                B:next_state <=(data)?B:C;
                C:next_state <= (data)?D:RESET;
                D:next_state <= D;
            endcase
        end
    end
    assign start_shifting = (state == D);
    
        
endmodule

153 Exams/review2015 fsmshift

  这道题我使用两个标志位加计数器的方式完成，但第二种思路我觉得很好。可以借鉴一下。

module top_module (
    input clk,
    input reset,      // Synchronous reset
    output shift_ena);
    
    reg [2:0] count;
    reg count_flag;
    reg reset_flag;
    
    always@(*) begin
        if(reset)
            count_flag <= 1'b0;
        else if(count == 3'b100)
            count_flag <= 1'b0;
        else if(count >= 0 && count < 3'b100)
            count_flag <= 1'b1;
        else
            count_flag <= 1'b0;
    end
    
    always@(posedge clk) begin
        if(reset)
            count <= 3'b00;
        else if(count == 3'b100)
            count <= 3'b111;
        else if(count_flag == 1'b1)
            count <= count + 1'b1;
    end
    
    always@(posedge clk) begin
        if(reset)
            reset_flag <= 1'b1;
        else
            reset_flag <= 1'b0;
    end
    
    assign shift_ena = count_flag  | reset_flag ;

endmodule

  另外一种思路

module top_module (
    input clk,
    input reset,      // Synchronous reset
    output shift_ena);
    
    //记录时钟周期
    reg [2:0]cnt ;
    
    always @(posedge clk)
        begin
            if(reset)
                cnt <= 0;
            else if(cnt >= 4)
                cnt <= 4;
            else
                cnt = cnt + 1;
        end
    assign shift_ena = (cnt == 0 | cnt == 1 | cnt == 2 | cnt == 3);

endmodule

154 Exams/review2015 fsmshift

  本题的题意主体要完成的是序列监测，以及根据后面的信号输入进行后续的状态转移，我这里犯了一个错误就是S2在接收到1时的错误，看来做序列监测的时候还是不能大意，导致我仿真看了一下波形图，找到问题，下面依次是状态转移图，解答，仿真图，testbench。
在这里插入图片描述

module top_module (
    input clk,
    input reset,      // Synchronous reset
    input data,
    input ack,
    input done_counting,
    output shift_ena,
    output counting,
    output done
    );
    
    parameter RESET = 8'b11111111 ,S1 = 8'b00000001 ,S2 = 8'b00000010,S3 = 8'b00000100,S4 = 8'b00001000,
    							   S5 = 8'b00010000 ,S6 = 8'b00100000,S7 = 8'b01000000,S8 = 8'b10000000;
    
    reg [7:0] state , next_state;
    reg [1:0] count;
    
    always@(posedge clk) begin
        if(reset)
            state <= RESET;
        else
            state <= next_state;
    end
    
    always@(posedge clk)begin
        if(reset)
            count <= 2'b00;
        else if(state == S4 && count != 2'b11)
            count <= count + 1'b1;
        else
            count <= 2'b00; 
    end
    
    always@(*) begin
        if(reset)
            next_state <= RESET;
        else begin
            case(state)
                RESET:next_state <= (!reset & data == 1'b1)?S1:RESET;
                S1:   next_state <= (data)?S2:RESET;
                S2:   next_state <= (data)?S2:S3;
                S3:   next_state <= (data)?S4:RESET;
                S4:	  next_state <= (count == 2'b11)?S5:S4;
                S5:   next_state <= (done_counting)?S6:S5;
                S6:   next_state <= (ack)?RESET:S6;
                default:next_state <= RESET;
            endcase  
        end
    end
    
    assign shift_ena = (state==  S4);
    assign counting = (state == S5);
    assign done = (state == S6);
    

endmodule

  仿真时序图
在这里插入图片描述

//testbench
module tb_top_module_154();
    reg  clk;
    reg  reset;      // Synchronous reset
    reg  data;
    reg  ack;
    reg  done_counting;
    wire shift_ena;
    wire counting;
    wire done;

    initial begin
        clk <= 1;
        reset <= 1'b0;
    end

    always begin
        #2 clk = ~clk;
    end

    initial begin
        #4
        data <= 1'b1;
        #2
        data <= 1'b0;
        #6
        data <= 1'b1;
        #2
        data <= 1'b0;
        #8
        data <= 1'b1;
        #4
        data <= 1'b0;
        #2
        data <= 1'b1;
        #4
        data <= 1'b0;
        #2
        data <= 1'b1;
        #8
        data <= 1'b0;
        #2
        data <= 1'b1;
        #14
        data <= 1'b0;
        #2
        data <= 1'b1;
        #4;
    end

    initial begin
        done_counting <= 1'b0;
        #48
        done_counting <= 1'b1;
        #2
        done_counting <= 1'b0;
        #14;
    end

    initial begin
        ack <= 1'b0;
        #6;
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #14
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #22
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #16;
    end

    top_module_154 tb_top_module_inst(
        .clk(clk),
        .reset(reset),
        .data(data),
        .ack(ack),
        .done_counting(done_counting),
        .shift_ena(shift_ena),
        .counting(counting),
        .done(done)
    );

    

endmodule

155 Exams/review2015 fsm

  155的状态转移图大体没有变动，需要改变的就是S5到S6的转变，然后其中在S4时要记录移位得到的数据count，然后我用round信号记录需要计数几轮，assign round <= count + 1’b1，这样更加好判断。
  还需要注意的点是，在计数时，我刚开始想通过for循环来完成计数，但是我之前看过在verilog中要避免写for循环，所有通过 判断语句来写循环。

module top_module_155 (
    input clk,
    input reset,      // Synchronous reset
    input data,
    input ack,
    output [3:0] count,
    output counting,
    output done
   );
	
    parameter thousand = 1000;
    parameter RESET = 8'b11111111 ,S1 = 8'b00000001 ,S2 = 8'b00000010,S3 = 8'b00000100,S4 = 8'b00001000,
    							   S5 = 8'b00010000 ,S6 = 8'b00100000,S7 = 8'b01000000,S8 = 8'b10000000;
    
    reg [7:0] state , next_state;
    reg [1:0] num;
    reg [9:0] i;
    wire [3:0] round;


    assign round = count + 1'b1;
    always@(posedge clk) begin
        if(reset)
            state <= RESET;
        else
            state <= next_state;
    end
    
    always@(posedge clk)begin
        if(reset)
           	count <= 4'b0;
        else if(state == S4)
            count <= {count[2:0],data};
        else if(state == S5 && i == thousand -1'b1 && count != 0 )
            count <= count - 1'b1;
        else if(next_state == S6)
            count <= 4'b0;
        else
            count <= count;
    end
   
    
    always@(posedge clk)begin
        if(reset)
            num <= 2'b00;
        else if(state == S4 && num != 2'b11)
            num <= num + 1'b1;
        else
            num <= 2'b00; 
    end
    
    always@(posedge clk)begin
        if(reset) begin
            i <= 10'b0;
        end
        else if(state == S5) begin
            if(i == thousand -1'b1) begin
                i <= 10'b0;
            end
            else begin
                i <= i +1'b1;
            end
        end
    end
            
    
    always@(*) begin
        if(reset)
            next_state <= RESET;
        else begin
            case(state)
                RESET:next_state <= (!reset & data == 1'b1)?S1:RESET;
                S1:   next_state <= (data)?S2:RESET;
                S2:   next_state <= (data)?S2:S3;
                S3:   next_state <= (data)?S4:RESET;
                S4:	  next_state <= (num == 2'b11)?S5:S4;
                S5:   next_state <= (i == thousand -1'b1 && round == 1'b1)?S6:S5;
                S6:   next_state <= (ack)?RESET:S6;
                default:next_state <= RESET;
            endcase  
        end
    end
    
    assign counting = (state == S5);
    assign done = (state == S6);
endmodule

  前几个状态的仿真图
在这里插入图片描述
  155的testbench

module tb_top_module_155();
    reg  clk;
    reg  reset;      // Synchronous reset
    reg  data;
    reg  ack;
    wire  [3:0] count;
    wire counting;
    wire done;

    initial begin
        clk <= 1;
        reset <= 1'b1;
        #4;
        reset <= 1'b0;
    end

    always begin
        #2 clk = ~clk;
    end

    initial begin
        data <= 1'b0;
        #4
        data <= 1'b1;
        #4
        data <= 1'b0;
        #8
        data <= 1'b1;
        #8
        data <= 1'b0;
        #4
        data <= 1'b1;
        #4
        data <= 1'b0;
        #12
        data <= 1'b1;
        #4
        data <= 1'b0;
    end


    initial begin
        ack <= 1'b0;
        #6;
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #14
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #22
        ack <= 1'b1;
        #2
        ack <= 1'b0;
        #16;
    end

    top_module_155 tb_top_module_inst(
        .clk(clk),
        .reset(reset),
        .data(data),
        .ack(ack),
        .count(count),
        .counting(counting),
        .done(done)
    );

endmodule

156 Exams/review2015 fsmonehot

module top_module(
    input  d,
    input  done_counting,
    input  ack,
    input  [9:0] state,    // 10-bit one-hot current state
    output B3_next,
    output S_next,
    output S1_next,
    output Count_next,
    output Wait_next,
    output done,
    output counting,
    output shift_ena
); 
    //

    // You may use these parameters to access state bits using e.g., state[B2] instead of state[6].
    parameter S=0, S1=1, S11=2, S110=3, B0=4, B1=5, B2=6, B3=7, Count=8, Wait=9;

    
    assign B3_next = state[B2];
    assign S_next = (((state[S] || state[S1] ||state[S110]) && d == 1'b0 )|| state[Wait] && ack == 1'b1);
    assign S1_next = (state[S] && d == 1'b1);
    assign Count_next = state[B3] || (state[Count] && done_counting == 1'b0);
    assign Wait_next = (state[Wait] && ack == 1'b0) || (state[Count]&& done_counting == 1'b1);
    assign done = state[Wait];
    assign counting = state[Count];
    assign shift_ena = state[B0] ||state[B1] ||state[B2] ||state[B3];
    
endmodule

157-161 Finding bugs in code

//157
module top_module (
    input  sel,
    input  [7:0] a,
    input  [7:0] b,
    output [7:0] out  );   //修改这里

    assign out = sel?a:b ;  //使用这个逻辑更加好理解

endmodule

//158
module top_module (input a, input b, input c, output out);//
	reg outq;
    assign out = ~outq;
    andgate inst1 (
        .a(a),
        .b(b),
        .c(c),
        .d(1'b1),
        .e(1'b1),
        .out(outq)
    );

endmodule

//159
module top_module (
    input [1:0] sel,
    input [7:0] a,
    input [7:0] b,
    input [7:0] c,
    input [7:0] d,
    output [7:0] out  ); //

    wire [7:0] mux0,mux1;
    mux2 mux0_inst ( sel[0],    a,    b, mux0 );
    mux2 mux1_inst ( sel[0],    c,    d, mux1 );
    mux2 mux2_inst ( sel[1], mux0, mux1,  out );

endmodule

/160
// synthesis verilog_input_version verilog_2001
module top_module ( 
    input do_sub,
    input [7:0] a,
    input [7:0] b,
    output reg [7:0] out,
    output result_is_zero
);
	
    always @(*) begin
        case (do_sub)
          0: out = a+b;
          1: out = a-b;
        endcase
    end   
    
    assign result_is_zero = (out == 8'b0)?1:0;
endmodule
//161
module top_module (
    input [7:0] code,
    output reg [3:0] out,
    output reg valid=1 );//

    always @(*) begin
        case (code)
            8'h45: begin
                out = 0;
                valid <= 1'b1;
            end
            8'h16: begin
                out = 1;
                valid <= 1'b1;
            end 
            8'h1e: begin
                out = 2;
                valid <= 1'b1;
            end
            8'h26: begin
                out = 3;  //修改
                valid <= 1'b1;
            end
            8'h25: begin
                out = 4;
                valid <= 1'b1;
            end
            8'h2e: begin
                out = 5;
                valid <= 1'b1;
            end
            8'h36: begin
                out = 6;
                valid <= 1'b1;
            end
            8'h3d: begin
                out = 7;
                valid <= 1'b1;
            end
            8'h3e: begin
                out = 8;
                valid <= 1'b1;
            end  
            8'h46: begin
                out = 9;  //修改
                valid <= 1'b1;
            end  
            default: begin
                out <= 0;
                valid <= 0;
            end
        endcase
    end

endmodule

162- 171 Sim/circuit1

//162
module top_module (
    input a,
    input b,
    output q );//

    assign q = a&b; // Fix me
endmodule

//163
//同或 也就是 异或非
    assign q = !(a^b^c^d); // Fix me
//164
//卡诺图如下图所示：
    assign q = (a|b)&(c|d); // Fix me
//165
   assign q = b|c; // Fix me
//166
   module top_module (
    input [3:0] a,
    input [3:0] b,
    input [3:0] c,
    input [3:0] d,
    input [3:0] e,
    output [3:0] q );
    
    always@(*) begin
        if(c >= 4'b0 && c <= 4'b0011) begin
            case(c)
                4'b0000: q <= b;
                4'b0001: q <= e;
                4'b0010: q <= a;
                4'b0011: q <= d;
                default: q <= 4'b1111; 
            endcase
        end
        else
            q <= 4'b1111;
    end

endmodule
//167
module top_module (
    input [2:0] a,
    output [15:0] q ); 
    always@(*)begin
        case(a)
            3'b000:q <= 16'h1232;
            3'b001:q <= 16'haee0;
            3'b010:q <= 16'h27d4;
            3'b011:q <= 16'h5a0e;
            3'b100:q <= 16'h2066;
            3'b101:q <= 16'h64ce;
            4'b110:q <= 16'hc526;
            4'b111:q <= 16'h2f19;
            default:q <= 16'h0000;
        endcase
    end

endmodule
//168
module top_module (
    input clk,
    input a,
    output q );
    always@(posedge clk) begin
        q <= !a;
    end

endmodule
//169
module top_module (
    input clock,
    input a,
    output p,
    output q );
    
    always@(*)begin
        if(clock)
            p <= a;
        else
            p <= p;
    end
    
    always@(negedge clock)begin
        q <= a;
    end
endmodule
//170
//a是复位信号
module top_module (
    input clk,
    input a,
    output [3:0] q);
    
    always@(posedge clk)begin
        if(a)
            q <= 4'b0100;
        else begin
            if(q == 4'b0110)
                q <= 4'b0;
        	else
                q <= q + 1'b1;
        end
    end
endmodule

//171
module top_module (
    input clk,
    input a,
    input b,
    output q,
    output state  );
    reg next_state;
    parameter A=1'b0,B=1'b1;
    always @(*)begin
        case(state)
        	A:next_state = a&b?B:A;
            B:next_state = ((a|b)==1'b0)?A:B;
        endcase
    end
    always @ (posedge clk) begin
        state <= next_state;
    end
    
    assign q = ((state == A)&(a^b))|((state == B)& (~(a^b)));
endmodule

在这里插入图片描述

Testbench

172-176

//172
`timescale 1ps / 1ps
module top_module ( );
    reg clk;
    
    dut inst_dut(
        .clk	(clk)
    );
    
    initial begin
        clk = 1'b0;
    end
    
    always begin
        #5
        clk = ~clk;
    end

endmodule
//173
module top_module ( output reg A, output reg B );//
    initial begin
        A <= 1'b0;
        #10
        A <=1'b1;
        #10
        A <= 1'b0;
    end
    
    initial begin
        B <= 1'b0;
        #15
        B <=1'b1;
        #25
        B <= 1'b0;
    end

endmodule

//174
`timescale 1ps / 1ps
module top_module();
    reg [1:0] in;
    wire        out;
    
    andgate inst_andgate(
        .in(in),
        .out(out)
    );
    
    initial begin
        in = 2'b00;
        #10;
        in = 2'b01;
        #10;
        in = 2'b10;
        #10;
        in  = 2'b11;
    end
endmodule

//175
//testbench我喜欢分信号写
module top_module();
    reg clk;
    reg in;
    reg [2:0] s;
    wire out;
    
    q7 inst_q7(
        .clk(clk),
        .in(in),
        .s(s),
        .out(out)
    );
    
    
    
    initial begin
        clk = 1'b0;
    end
    
    always begin
        #5
        clk = ~clk;
    end
    
    initial begin
        in <= 1'b0;
        #20;
        in <= 1'b1;
        #10;
        in <= 1'b0;
        #10
        in <= 1'b1;
        #30;
        in <= 1'b0;
    end
        
    
    initial begin
        s <= 3'b010;
        #10;
        s <= 3'b110;
        #10
        s <= 3'b010;
        #10
        s <= 3'b111;
        #10
        s <= 3'b000;
    end
        

endmodule

//176
module top_module ();
    reg clk;
    reg reset;
    reg t;
    wire q;
    
    tff tff_inst(
        .clk(clk),
        .reset(reset),
        .t(t),
        .q(q)
    );
    
    initial begin
        clk = 1'b0;
    end
    always begin
        #5
        clk = ~clk;
    end
    
    initial begin
        reset <= 1'b0;
        t <= 1'b0;
        #10;
        reset <= 1'b1;
        #10;
        reset <= 1'b0;
        #10
        t <= 1'b1;     
    end
    

endmodule
竖条你要听话
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HDLBits学习------Problem 138~150
xyx0610的博客
11-22 568
参考链接：HDLBits导学 Problem 138Q8: Design a Mealy FSM 问题：实现一个Mealy类型的有限状态机，识别序列“101”，输入信号为x 。您的 FSM 应该有一个输出信号z，当检测到“101”序列时，该信号输出逻辑 1。您的 FSM 还应该有一个低电平有效的异步复位。您的状态机中可能只有 3 个状态。您的 FSM 应该识别重叠序列 解决： module top_module ( input clk, input...
hdlbits 练习汇总
学渣的博客
04-22 8334
最近发现一个很有意思的网站，可以在线提交 verilog 代码以完成一些任务，并且还能得到仿真结果对比。可以利用零碎时间提交一些代码，练习verilog基础知识。 网址如下： https://hdlbits.01xz.net/wiki/ 从 basics 开始对提交的答案进行汇总。（本博客会不断更新） //03_Wire.v module top_module( input in, output...
（1）HDLBits-Verilog Language-Basics
m0_58077663的博客
03-15 80
本文为本人在HDLBits-Verilog Language-Basics的学习记录。
top命令输出解释以及load average 详解及排查思路
zhangchenglikecc的博客
08-03 7万+
昨天nagios报警warning，没来得及留下报警截图，nagios值设定的值是 当1分钟多于15个进程等待,5分钟多于10个,15分钟多于5个则为warning状态 当1分钟多于30个进程等待,5分钟多于25个,15分钟多于20个则为critical状态 -------------------------------------------------------------
序列检测器：状态转移图+Morrer状态机（三段式）+Modelsim仿真 
踏雪的专栏
05-19 1万+
序列检测器：状态转移图+Morrer状态机（三段式）+Modelsim仿真 目录     -1、绘制状态转移图         -1.1、在Sublime 中用Graphviz绘制状态转移图         -1.2、在Notepad++ 中用Graphviz绘制状态转移图         -1.2、Morrer与Mealy型状态机的状态转移图对比     -2、Morrer状态机代码     -3、仿真T...
AXIS-interconnect-testbench.zip
01-13
xilinx AXI4-Stream-interconnect 仿真testbench文件，包含 AXI4-Stream traffic generator文件，自定义随机帧长，随机报文等，仅供学习参考。
异步复位同步释放(verilog代码-Testbench-仿真结果-综合电路)
06-02
这里，我们主要探讨的是使用Verilog语言实现这一功能，并通过Testbench进行仿真验证以及综合电路的过程。 异步复位（Asynchronous Reset）通常是一个非阻塞的信号，它能够在任何时刻立即对系统进行复位，不依赖于...
8-3编码器实验实例Modelsim仿真工程文包括testbench+verilog源码.rar
05-10
8-3编码器实验实例Modelsim仿真工程文包括testbench+verilog源码 module ENCODE_8_3_tb; reg [7:0] DATA; wire [2:0] CODE; //Instance DUT. ENCODE_8_3 I_ENCODE_8_3 ( .DATA (DATA), .CODE (CODE) ); /...
边沿检测（上升沿检测、下降沿检测、双边沿检测-verilog代码-Testbench-RTL电路图-仿真结果）
最新发布
06-02
本资源包着重介绍了边沿检测的三种基本类型：上升沿检测、下降沿检测和双边沿检测，并提供了Verilog语言实现的代码示例、Testbench测试平台、RTL电路图以及仿真结果，对于理解和应用这些概念非常有帮助。 1. **上升...
数字分频器设计（偶数分频、奇数分频、小数分频、半整数分频、状态机分频-verilog代码-Testbench-仿真结果）
06-02
本资源包详细介绍了五种不同的分频方式：偶数分频、奇数分频、小数分频、半整数分频以及状态机分频，并提供了Verilog代码实现，同时包含了Testbench测试平台和仿真的结果，这对于理解和学习FPGA设计，特别是数字集成...
HDLBits答案(18)_Verilog有限状态机(5)
谦豫
02-07 5033
Verilog有限状态机(5) HDLBits链接 前言 今天继续更新状态机小节的习题。 题库 题目描述1： 第一道题目比较容易，题目中的in信号包含了一个起始位（0），8个数据位和一个停止位（1），开始in为1，也就是IDLE状态，当in为0时，进入START状态，然后经过8个周期，如果in为1，则进入STOP状态，接着如果in为0，进入第二轮START状态，否则进入IDLE状态。 这里我用了很多个状态，实际上可以用计数器来代替中间的8个状态，这里是8个周期，如果是100个、200个周期，那么需要10
linux打印jvm内存堆栈_java命令--jstack 工具 查看JVM堆栈信息
weixin_30013175的博客
02-07 4182
介绍jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或corefile或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式：jstack [-l] pid主要分为两个功能：a． 针对活着的进程做本地的或远程的线程dump；b． 针对core文件做线程dum...
使用ModelSim自动生成状态机FSM的状态转换图
彬彬有礼的专栏
09-01 2万+
HDL代码设计中重要的内容之一就是设计程序的状态机FSM，状态转换控制着整个程序的流程，为了理解程序，我们经常需要把状态机的状态转换图画出来，这样看起来很直观，但是，有没有办法自动生成状态转换图呢？ 在ISE或者ModelSim中有没有这样的工具呢？ 答案是肯定的，ModelSim中即有这样的工具，下面以ISE13.4和ModelSim6.5为例，使用一段最简单的状态机代码说明如何操作来自动生
Linux mem 1.2 用户态进程空间布局 --- mmap()详解
pwl999的博客
10-20 3171
mmap系统调用 Author: pwl Date: 2020-10-20 文章目录mmap系统调用1. 原理介绍1.1 映射1.2 vma管理1.3 mmap1.4 缺页异常1.5 layout1.6 brk2. 代码详解2.1 关键数据结构2.2 mmap()2.2.1 mm->mmap_base(mmap基地址)2.2.2 get_unmapped_area()2.2.2.1 arch_get_unmapped_area()2.2.2.2 arch_get_unmapped_area_t
matlab种状态机,使用ModelSim自动生成状态机FSM的状态转换图
weixin_32493541的博客
03-17 1067
核心提示：HDL代码设计中重要的内容之一就是设计程序的状态机FSM，状态转换控制着整个程序的流程，为了理解程序，我们经常需要把状态机的状态转换图画出来，这样看起来很直观，但是，有没有办法自动生成状态转换图呢？在...HDL代码设计中重要的内容之一就是设计程序的状态机FSM，状态转换控制着整个程序的流程，为了理解程序，我们经常需要把状态机的状态转换图画出来，这样看起来很直观，但是，有没有办法自动生成...
Verilog专题（三十五）其他状态机题目
Andy_ICer的博客
08-01 1786
Verilog专题（三十五）其他状态机题目
pywinauto教程
热门推荐
weixin_40161673的博客
10-22 8万+
** 一、环境安装 ** 1.命令行安装方法 pip install pywinauto 2.手动安装方法 安装包下载链接： pyWin32: python调用windows api的库 https://sourceforge.net/projects/pywin32/files/pywin32/Build 220/ comtypes： COM接口的调度https://github.com/en...
jvm工具-jstack使用
菜鸟腾飞
04-10 4580
一、介绍 jstack是java虚拟机自带的一种堆栈跟踪工具。jstack用于打印出给定的java进程ID或core&nbsp;file或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项”-J-d64”，Windows的jstack使用方式只支持以下的这种方式： jstack [-l] pid &nbsp; 主要分为两个功能：&nbsp; a．&nbsp; 针对活着的进程做本地的...
Verilog编程练习
qq_43643118的博客
04-16 1453
Verilog编程巩固记录一、HDLBits网站练习1.门电路2.组合电路3.时序电路二、7天学好Robei 一、HDLBits网站练习 进入HDLBits网址练习 总的参考链接：在这里 1.门电路 练习题目链接 与门 and gate module top_module( input a, input b, output out ); assign out=a&b; endmodule 或非门 nor gate 或门的输出取反。 module t
FPGA modelsim仿真入门：testbench编写详解与激励信号设置
本文档是一份关于FPGA模型仿真中testbench编写的基础教程。在进行modelsim中的FPGA测试，testbench至关重要，它用于驱动和监控模块的行为。以下几点是文章的核心知识点： 1. **端口映射**： - 在编写testbench时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值