devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Verilog刷题

作者：凡人多烦事01 | 2024-04-27 01:32:19

赞

踩

verilog刷题
  1. module data_driver(
  2.     input clk_a,
  3.     input rst_n,
  4.     input data_ack,
  5.     output reg [3:0]data,
  6.     output reg data_req
  7.     );
  8.     reg data_ack_reg_1;
  9.     reg data_ack_reg_2;
  10.     reg data_ack_reg_3;
  11.     reg [9:0] cnt;
  12.     always @ (posedge clk_a or negedge rst_n)
  13.         if (!rst_n) 
  14.         begin
  15.             data_ack_reg_1 <= 0;
  16.             data_ack_reg_2 <= 0;
  17.             data_ack_reg_3 <= 0;
  18.         end
  19.         else
  20.         begin
  21.             data_ack_reg_1 <= data_ack;
  22.             data_ack_reg_2 <= data_ack_reg_1;
  23.             data_ack_reg_3 <= data_ack_reg_2;
  24.         end
  25.          
  26.     always @ (posedge clk_a or negedge rst_n)
  27.         if (!rst_n) 
  28.         begin
  29.             data <= 0;
  30.         end
  31.         else if(data_ack_reg_2 && !data_ack_reg_3)
  32.         begin  
  33.             data <= data+1;
  34.         end
  35.         else begin
  36.             data <= data;
  37.         end
  38. //同时在data_ack有效之后，开始计数五个时钟，之后发送新的数据，也就是再一次拉高data_req.
  39.     always @ (posedge clk_a or negedge rst_n)
  40.         if (!rst_n) 
  41.             cnt <= 0;
  42.         else if (data_ack_reg_2 && !data_ack_reg_3)
  43.             cnt <= 0;
  44.         else if (data_req)
  45.             cnt <= cnt;
  46.         else 
  47.             cnt <= cnt+1;
  48.              
  49.     always @ (posedge clk_a or negedge rst_n)
  50.         if (!rst_n) 
  51.             data_req <= 0;
  52.         else if (cnt == 3'd4)  
  53.             data_req <= 1'b1;
  54.         else if (data_ack_reg_2 && !data_ack_reg_3)
  55.             data_req <= 1'b0;
  56.         else 
  57.             data_req <= data_req;
  58.  
  59. endmodule
  60.  
  61. module data_receiver(
  62.     input clk_b,
  63.     input rst_n,
  64.     output reg data_ack,
  65.     input [3:0]data,
  66.     input data_req
  67.     );
  68.      
  69.     reg [3:0]data_in_reg;
  70.     reg data_req_reg_1;
  71.     reg data_req_reg_2;
  72.     reg data_req_reg_3;
  73.     always @ (posedge clk_b or negedge rst_n)
  74.         if (!rst_n) 
  75.         begin
  76.             data_req_reg_1 <= 0;
  77.             data_req_reg_2 <= 0;
  78.             data_req_reg_3 <= 0;
  79.         end
  80.         else
  81.         begin
  82.             data_req_reg_1 <= data_req;
  83.             data_req_reg_2 <= data_req_reg_1;
  84.             data_req_reg_3 <= data_req_reg_2;
  85.         end
  86.  
  87.     always @ (posedge clk_b or negedge rst_n)
  88.         if (!rst_n)
  89.             data_ack <= 0;
  90.         else if (data_req_reg_1)
  91.             data_ack <= 1;
  92.         else  data_ack <=0 ;
  93.      
  94.     always @ (posedge clk_b or negedge rst_n)
  95.         if (!rst_n)
  96.             data_in_reg <= 0;
  97.         else if (data_req_reg_2 && !data_req_reg_3)
  98.             data_in_reg <= data;
  99.         else  data_in_reg <= data_in_reg ; 
  100.  
  101. endmodule

  • 序列产生

  1. 方法一（状态机）
  2. module sequence_generator(
  3.     input clk,
  4.     input rst_n,
  5.     output  data
  6.     );
  7.     
  8.     parameter S0 = 3'd0;
  9.     parameter S1 = 3'd1;
  10.     parameter S2 = 3'd2;
  11.     parameter S3 = 3'd3;
  12.     parameter S4 = 3'd4;
  13.     parameter S5 = 3'd5;
  14.  
  15.     reg [2:0] state;
  16.     reg [2:0] next_state;
  17.  
  18.     always @ (posedge clk or negedge rst_n) begin
  19.         if (rst_n == 1'b0) begin
  20.             state <= S0;    
  21.         end
  22.         else 
  23.             state <= next_state;
  24.     end
  25.  
  26.     reg [3:0]    data_reg;
  27.     always @ (*) begin
  28.         if (rst_n == 1'b0) begin
  29.             next_state = S0;
  30.             data_reg = 4'b0010;
  31.         end
  32.         else begin
  33.             case (state)
  34.                 S0 : begin
  35.                     next_state = S1;
  36.                     data_reg = 4'b0010;
  37.                 end
  38.                 S1 : begin
  39.                     next_state = S2;
  40.                     data_reg = 4'b0101;
  41.                 end
  42.                 S2 : begin
  43.                     next_state = S3;
  44.                     data_reg = 4'b1011;
  45.                 end
  46.                 S3 : begin
  47.                     next_state = S4;
  48.                     data_reg = 4'b0110;
  49.                 end
  50.                 S4 : begin
  51.                     next_state = S5;
  52.                     data_reg = 4'b1100;
  53.                 end
  54.                 S5 : begin
  55.                     next_state = S0;
  56.                     data_reg = 4'b1001;
  57.                 end
  58.                 default : begin
  59.                     next_state = S0;
  60.                     data_reg = 4'b0010;
  61.                 end
  62.             endcase
  63.         end
  64.     end
  65.     assign data = data_reg[3];
  66. endmodule
  67.  
  68. 方法二 移位寄存器
  69. module sequence_generator(
  70.     input clk,
  71.     input rst_n,
  72.     output reg data
  73.     );
  74.      
  75.     reg [5:0] q;
  76.      
  77.     always@(posedge clk or negedge rst_n)
  78.         if (!rst_n)
  79.             q <= 6'b001011;
  80.         else
  81.             q <= {q[4:0],q[5]};
  82.      
  83.     always@(posedge clk or negedge rst_n)
  84.         if (!rst_n)
  85.             data <= 1'd0;
  86.         else
  87.             data <= q[5];
  88. endmodule
  89.  
  90. 方法三 计数器加case语句
  91. module sequence_generator(
  92.     input clk,
  93.     input rst_n,
  94.     output  data
  95.     );
  96. reg [2:0] cnt;
  97.     always@(posedge clk or negedge rst_n)begin
  98.         if(!rst_n) cnt<=3'b0;
  99.         else begin
  100.             if(cnt==3'd5)
  101.                 cnt<=3'b0;
  102.             else    cnt<=cnt+1'b1;
  103.         end        
  104.     end
  105.     always@(posedge clk or negedge rst_n)begin
  106.         if(!rst_n) data<=1'b0;
  107.         else begin
  108.             case(cnt)
  109.                 3'd0:data<=1'b0;
  110.                 3'd1:data<=1'b0;
  111.                 3'd2:data<=1'b1;
  112.                 3'd3:data<=1'b0;
  113.                 3'd4:data<=1'b1;
  114.                 3'd5:data<=1'b1;
  115.                 default : data <= 1'b0;
  116.             endcase
  117.         end        
  118.     end
  119. endmodule

  • 序列检测 本次检测序列为10010

  1. 方法：画状态转移图采用状态机实现
  2. module sequential_detector(clk, reset, d, y);
  3.     //输入输出端口定义
  4.     input clk, reset, d;
  5.     output y;
  6.     
  7.     //内部寄存器及连线定义
  8.     reg [2 : 0] state;
  9.     wire y;
  10.     
  11.     //状态编码
  12.     parameter idle = 3'b000, s1 = 3'b001, s2 = 3'b010, s3 = 3'b011,
  13.               s4 = 3'b100, s5 = 3'b101, s6 = 3'b110, s7 = 3'b111;
  14.  
  15.     //状态机实现
  16.     always@(posedge clk or posedge reset)
  17.     begin
  18.         if(reset) state <= idle;
  19.         else
  20.         begin
  21.             casex(state)
  22.                 idle: begin
  23.                         if(d == 1) state <= s1;
  24.                         else state <= idle;
  25.                       end
  26.                 s1: begin
  27.                         if(d == 0) state <= s2;
  28.                         else state <= s1;
  29.                     end
  30.                 s2: begin
  31.                         if(d == 0) state <= s3;
  32.                         else state <= s7;
  33.                     end
  34.                 s3: begin
  35.                         if(d == 1) state <= s4;
  36.                         else state <= s6;
  37.                     end
  38.                 s4:    begin
  39.                         if(d == 0) state <= s5;
  40.                         else state <= s1;
  41.                     end
  42.                 s5: begin
  43.                         if(d == 1) state <= s1;
  44.                         else state <= s3;
  45.                     end
  46.                 s6: begin
  47.                         if(d == 1) state <= s7;
  48.                         else state <= s6;
  49.                     end
  50.                 s7: begin
  51.                         if(d == 1) state <= s1;
  52.                         else state <= s2;
  53.                     end
  54.                 default: state <= idle;
  55.             endcase
  56.         end
  57.     end
  58.     
  59.     //用组合逻辑实现输出
  60.     assign y = (state == s4 && d == 0) ? 1 : 0;
  61. endmodule

  1. 串转并

  1. 方法：移位寄存器
  2. module serial2paraller(
  3.     input       clk,
  4.     input       rst_n,
  5.     input       d,
  6.     output reg [3:0]q,
  7.     output reg q_valid
  8. );
  9. reg [3:0]data;
  10. always @(posedge clk or negedge rst_n)
  11. begin
  12.     if(!rst_n)
  13.         data <= 4'b0;
  14.     else 
  15.         data <= {data[2:0],d};
  16. end
  17.  
  18. reg [1:0] cnt;
  19. always @(posedge clk or negedge rst_n)
  20. begin
  21.     if(!rst_n)
  22.         cnt <= 2'd0;
  23.     else if (cnt == 2'd3)
  24.         cnt <= 2'd0;
  25.     else
  26.         cnt <= cnt + 1'b1;
  27. end
  28.  
  29. always @(posedge clk or negedge rst_n)
  30. begin
  31.     if(!rst_n)
  32.         q <= 4'b0;
  33.     else
  34.         q <= data;
  35. end
  36.  
  37. always @(posedge clk or negedge rst_n)
  38. begin
  39.     if(!rst_n)
  40.         q_valid <= 1'b0;
  41.     else if (cnt == 2'd3)
  42.         q_valid <= 1'b1;
  43.     else
  44.         q_valid <= 1'b0;
  45. end
  46.  
  47. endmodule

  1. 并转串

  1. 方法：移位寄存器
  2. module paraller2serial(
  3.     input clk,
  4.     input rst_n,
  5.     input [4:0]d,
  6.     input en,
  7.     output q
  8. );
  9. reg[4:0]data;
  10. always @(posedge clk or negedge rst_n)
  11. begin
  12.     if(!rst_n)
  13.         data <= 5'b0;
  14.     else if(en)
  15.         data <= d;
  16.     else 
  17.         data <= data << 1;
  18. end
  19. assign q = data[4];
  20. endmodule

  • glitch-free电路

第一种：两个时钟之间有倍数关系

  1. 方法：将sel信号分别在不同时钟信号下进行打拍同步
  2. module syn_clk_glitch_free(
  3.     input    wire    clk0    ,
  4.     input    wire    clk1    ,
  5.     input    wire    rst     ,
  6.     input    wire    sel     ,
  7.     output   wire    clk_out
  8. );
  9.     reg q0, q1;
  10.      
  11.     always@(negedge clk0 or negedge rst)
  12.         if(!rst)
  13.             q0 <= 0;
  14.         else
  15.             q0 <= ~sel & ~q1;
  16.      
  17.     always@(negedge clk1 or negedge rst)
  18.         if(!rst)
  19.             q1 <= 0;
  20.          else
  21.             q1 <= sel & ~q0;
  22.  
  23.     assign clk_out = (q0 & clk0) | (q1 & clk1);
  24.      
  25. endmodule

第一点：采用下降沿寄存器，下降沿寄存，可以保证下降沿到来之前输出端保持不变，这样就不会斩断当前时钟了

第二点：即使当前SELECT突然变化了，也必须等待到当前时钟的下降沿到来才能去使当前时钟无效，这一段时间就避免了毛刺

第二种：异步时钟

  1. 方法：将SEL信号与一个时钟域到另一个时钟域的反馈，进行打拍
  2. module asyn_clk_glitch_free(
  3.     input    wire    clk0    ,
  4.     input    wire    clk1    ,
  5.     input    wire    rst     ,
  6.     input    wire    sel     ,
  7.     output   wire    clk_out
  8. );
  9.     reg q0, q1, q2, q3;
  10.      
  11.     always @ (posedge clk0 or negedge rst)
  12.         if(!rst)
  13.             q0 <= 0;
  14.         else
  15.             q0 <= ~sel & ~q3;
  16.     
  17.     always@(negedge clk0 or negedge rst)
  18.         if(!rst)
  19.             q1 <= 0;
  20.         else
  21.             q1 <= q0;
  22.  
  23.     always @ (posedge clk1 or negedge rst)
  24.         if(!rst)
  25.             q2 <= 0;
  26.         else 
  27.             q2 <= sel & ~q1;
  28.      
  29.     always@(negedge clk1 or negedge rst)
  30.         if(!rst)
  31.             q3 <= 0;
  32.          else
  33.             q3 <= q2;
  34.  
  35.     assign clk_out = (q1 & clk0) | (q3 & clk1);
  36.      
  37. endmodule

同步时钟：两个同源时钟、两个同频（倍频）且同相或者两个同频（倍频）且有固定相位差

异步时钟：不同源、同源但频率比不是整数倍、同源虽频率比为整数倍但不满足时序要求

原理：利用公式1. Pi = ai ⊕ bi （可以写为ai + bi）2. Gi = aibi 3. Ci = Gi + Ci-1Pi 4. Si = Pi ⊕ Ci-1

  • 无损定点化

将小数部分一直乘2直到出现小数部分小于0.5的次数，该次数即为最小位数的无损量化位数

  • 计数器设计

数字电子技术基础（阎石）P100

  • 线与逻辑

OD门

  • verilog阻塞与非阻塞的定义与区别

阻塞语句在Verilog中使用=运算符进行编码，并在创建组合逻辑时使用。该运算符阻止模拟器执行后续语句，直到完成当前求值和赋值。

非阻塞语句在 Verilog 中使用 <= 运算符进行编码，在时钟进程中对触发器进行编码时始终使用。赋值将推迟到计算完所有后续语句。 这允许并行或并发执行语句

  • 格雷码转二级制码

  1. verilog中function的使用

函数只能在模块中定义，位置任意，并在模块的任何地方引用，作用范围也局限于此模块。

特点：

1）不含有任何延迟、时序或时序控制逻辑

2）至少有一个输入变量

3）只有一个返回值，且没有输出

4）不含有非阻塞赋值语句

5）函数可以调用其他函数，但是不能调用任务

6）函数不能单独作为一条语句出现，只能放在赋值语言的右端

函数在声明时，会隐式的声明一个宽度为 range、 名字为 function_id 的寄存器变量，函数的返回值通过这个变量进行传递。当该寄存器变量没有指定位宽时，默认位宽为 1。

在 Verilog 中，一般函数的局部变量是静态的，即函数的每次调用，函数的局部变量都会使用同一个存储空间。若某个函数在两个不同的地方同时并发的调用，那么两个函数调用行为同时对同一块地址进行操作，会导致不确定的函数结果。

Verilog 用关键字 automatic 来对函数进行说明，此类函数在调用时是可以自动分配新的内存空间的，也可以理解为是可递归的。因此，automatic 函数中声明的局部变量不能通过层次命名进行访问，但是 automatic 函数本身可以通过层次名进行调用。

阶乘例子：

  1. wire [31:0]          results3 = factorial(4);
  2. function automatic   integer         factorial ;
  3.     input integer     data ;
  4.     integer           i ;
  5.     begin
  6.         factorial = (data>=2)? data * factorial(data-1) : 1 ;
  7.     end
  8. endfunction // factorial

  1. verilog中task的使用

任务更像一个过程，不仅能完成函数的功能，还可以包含时序控制逻辑。

特点：

a）任务可以没有或者有多个输入，且端口声明可以为 inout 型

b）任务可以没有或者有多个输出

c）任务没有返回值

d）任务可以在非零时刻执行

e）任务不能出现 always 语句，但可以包含其他时序控制，如延时语句

f）任务可以调用函数和任务

g）任务可以作为一条单独的语句出现语句块中

进行任务的逻辑设计时，可以把 input 声明的端口变量看做 wire 型，把 output 声明的端口变量看做 reg 型。但是不需要用 reg 对 output 端口再次说明。

  1. task xor_oper_iner;
  2.     input [N-1:0]   numa;
  3.     input [N-1:0]   numb;
  4.     output [N-1:0]  numco ;
  5.     //output reg [N-1:0]  numco ; //无需再注明 reg 类型，虽然注明也可能没错
  6.     #3  numco = numa ^ numb ;
  7.     //assign #3 numco = numa ^ numb ; //不用assign，因为输出默认是reg
  8. endtask

输入端连接的模块内信号可以是 wire 型，也可以是 reg 型。输出端连接的模块内信号要求一定是 reg 型，这点需要注意。

  1. G = B ^ (B >>1)
  2. B[i-1] = G[i-1] ^ B[i]
  3. // 用function封装起来的gray to bin
  4. function [5:0] gray2bin;
  5. input [5:0]gray_in;
  6. reg [5:0]gray_code;
  7. reg [5:0]bin_code;
  8. integer i,j;
  9. reg tmp;
  10. begin
  11.     gray_code=gray_in;
  12.         for(i=0;i<=5;i=i+1)
  13.         begin
  14.           tmp=1’b0;
  15.           for(j=i;j<=5;j=j+1)
  16.             tmp=gray_code^tmp;
  17.           bin_code[i]=tmp;
  18.        end
  19.      gray2bin=bin_code;
  20. end
  21. endfunction
  22. assign data=gray2bin(gray_bin);   //调用
  23.  
  24. // 一种参数化格雷码转二进制码的方法
  25. module gray2bin (bin, gray);
  26.   parameter SIZE = 4;
  27.   output [SIZE-1:0] bin;
  28.   input  [SIZE-1:0] gray;
  29.   reg    [SIZE-1:0] bin;
  30.   integer           i;
  31.   always @(gray)
  32.     for (i=0; i<SIZE; i=i+1)
  33.       bin[i] = ^(gray>>i);
  34. endmodule

  • 同步fifo

  1. `timescale 1ns/1ns  
  2.  
  3. module syn_fifo#(
  4.   parameter  WIDTH = 8,
  5.   parameter   DEPTH = 16
  6. )(
  7.   input           clk    , 
  8.   input           rst_n  ,
  9.   input           winc  ,
  10.   input            rinc  ,
  11.   input     [WIDTH-1:0]  wdata  ,
  12.  
  13.   output reg        wfull  ,
  14.   output reg        rempty  ,
  15.   output wire [WIDTH-1:0]  rdata
  16. );
  17.   // 用localparam定义一个参数，可以在文件内使用
  18.     localparam ADDR_WIDTH = $clog2(DEPTH);
  19.  
  20.     reg [ADDR_WIDTH:0] waddr;
  21.     reg [ADDR_WIDTH:0] raddr;
  22.     //第一部分---写地址产生逻辑
  23.     always @ (posedge clk or negedge rst_n) begin
  24.         if(~rst_n) begin
  25.             waddr <= 'b0;
  26.         end 
  27.         else begin
  28.             if( winc && ~wfull ) begin
  29.                 waddr <= waddr + 1'b1;
  30.             end 
  31.             else begin
  32.                 waddr <= waddr;    
  33.             end 
  34.         end 
  35.     end 
  36.     // 第二部分---读地址产生逻辑
  37.     always @ (posedge clk or negedge rst_n) begin
  38.         if(~rst_n) begin
  39.             raddr <= 'b0;
  40.         end 
  41.         else begin
  42.             if( rinc && ~rempty ) begin
  43.                 raddr <= raddr + 1'b1;
  44.             end 
  45.             else begin
  46.                 raddr <= raddr;    
  47.             end 
  48.         end 
  49.     end 
  50.     
  51.     // 第三部分---读空以及写满信号产生 
  52.     always @ (posedge clk or negedge rst_n) begin
  53.         if(~rst_n) begin
  54.             wfull <= 'b0;
  55.             rempty <= 'b0;
  56.         end 
  57.         else begin
  58.             wfull <= (raddr == {~waddr[ADDR_WIDTH], waddr[ADDR_WIDTH-1:0]});
  59.             rempty <= (raddr == waddr);
  60.         end 
  61.     end 
  62.  
  63. // 带有 parameter 参数的例化格式    
  64. dual_port_RAM  
  65.     #(
  66.         .DEPTH(DEPTH),
  67.         .WIDTH(WIDTH)
  68.     )
  69.     dual_port_RAM_U0 
  70.     (
  71.         .wclk(clk),
  72.       .wenc(winc && ~wfull),
  73.         .waddr(waddr[ADDR_WIDTH-1:0]), 
  74.       .wdata(wdata),        
  75.       .rclk(clk),
  76.         .renc(rinc && ~rempty),
  77.         .raddr(raddr[ADDR_WIDTH-1:0]), 
  78.       .rdata(rdata)     
  79. );       
  80. endmodule
  81.  
  82. /**************RAM 子模块*************/
  83. // 该模块是一个简单双端口ram
  84. module dual_port_RAM #(parameter DEPTH = 16,
  85.              parameter WIDTH = 8)(
  86.    input wclk
  87.   ,input wenc
  88.   ,input [$clog2(DEPTH)-1:0] waddr  //深度对2取对数，得到地址的位宽。
  89.   ,input [WIDTH-1:0] wdata        //数据写入
  90.   ,input rclk
  91.   ,input renc
  92.   ,input [$clog2(DEPTH)-1:0] raddr  //深度对2取对数，得到地址的位宽。
  93.   ,output reg [WIDTH-1:0] rdata     //数据输出
  94. );
  95.  
  96. reg [WIDTH-1:0] RAM_MEM [0:DEPTH-1];
  97.  
  98. always @(posedge wclk) begin
  99.   if(wenc)
  100.     RAM_MEM[waddr] <= wdata;
  101. end 
  102.  
  103. always @(posedge rclk) begin
  104.   if(renc)
  105.     rdata <= RAM_MEM[raddr];
  106. end 
  107.  
  108. endmodule

  • RCA(行波进位加法器）

  • CSR（进位保存加法器）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/494133
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号