devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Verilog 进阶教程（个人总结）

作者：花生_TL007 | 2024-05-19 08:13:41

赞

踩

Verilog 进阶教程（个人总结）

Verilog 是一种广泛用于数字电路设计和验证的硬件描述语言。本教程将介绍 Verilog 的一些进阶主题，包括跨 Die、跨时钟域、双口 RAM、FIFO、仲裁和资源争用，以及一些常用技巧和区别。每个部分都将包括其作用、具体实例和操作步骤，并讨论常见的 FPGA 问题及解决方法。

1. 跨 Die 设计

作用

跨 Die 设计通常用于 3D IC 设计中，需要处理不同 Die 之间的信号通信和时序问题。这种设计可以提高系统性能和集成度。

示例：跨 Die 信号传输

假设我们有两个 Die，Die1 和 Die2，彼此之间通过信号 signal_d1_to_d2 通信。

  1. // Die1 模块
  2. module Die1 (
  3.     input wire clk,
  4.     input wire reset,
  5.     output reg signal_d1_to_d2
  6. );
  7.     always @(posedge clk or posedge reset) begin
  8.         if (reset) begin
  9.             signal_d1_to_d2 <= 0;
  10.         end else begin
  11.             signal_d1_to_d2 <= ~signal_d1_to_d2; // Example logic
  12.         end
  13.     end
  14. endmodule
  15.  
  16. // Die2 模块
  17. module Die2 (
  18.     input wire clk,
  19.     input wire reset,
  20.     input wire signal_d1_to_d2
  21. );
  22.     reg signal_d1_to_d2_sync;
  23.     
  24.     always @(posedge clk or posedge reset) begin
  25.         if (reset) begin
  26.             signal_d1_to_d2_sync <= 0;
  27.         end else begin
  28.             signal_d1_to_d2_sync <= signal_d1_to_d2; // Synchronize signal
  29.         end
  30.     end
  31.     
  32.     // Use signal_d1_to_d2_sync in Die2 logic
  33. endmodule

操作步骤

  1. 设计 Die1 模块，生成信号 signal_d1_to_d2。
  2. 设计 Die2 模块，同步接收信号 signal_d1_to_d2。
  3. 在顶层模块中实例化 Die1 和 Die2，完成跨 Die 信号传输。

2. 跨时钟域设计 (Clock Domain Crossing, CDC)

作用

跨时钟域设计用于处理不同时钟域之间的信号传输，主要关注时钟域同步问题，以避免时序错误和数据不一致。

示例：跨时钟域信号同步

  1. // Source domain
  2. module SourceDomain (
  3.     input wire src_clk,
  4.     input wire src_reset,
  5.     output reg src_signal
  6. );
  7.     always @(posedge src_clk or posedge src_reset) begin
  8.         if (src_reset) begin
  9.             src_signal <= 0;
  10.         end else begin
  11.             src_signal <= ~src_signal; // Example logic
  12.         end
  13.     end
  14. endmodule
  15.  
  16. // Destination domain
  17. module DestDomain (
  18.     input wire dest_clk,
  19.     input wire dest_reset,
  20.     input wire src_signal,
  21.     output reg dest_signal
  22. );
  23.     reg [1:0] sync_ff;
  24.     
  25.     always @(posedge dest_clk or posedge dest_reset) begin
  26.         if (dest_reset) begin
  27.             sync_ff <= 2'b00;
  28.             dest_signal <= 0;
  29.         end else begin
  30.             sync_ff <= {sync_ff[0], src_signal}; // 2-stage synchronizer
  31.             dest_signal <= sync_ff[1];
  32.         end
  33.     end
  34. endmodule

操作步骤

  1. 在源时钟域中生成信号 src_signal。
  2. 在目的时钟域中设计 2 级同步器，同步接收 src_signal。
  3. 在顶层模块中实例化 SourceDomain 和 DestDomain，完成跨时钟域信号传输。

3. 双口 RAM (Dual-Port RAM)

作用

双口 RAM 允许同时进行读写操作，非常适合于高速缓存和多处理器系统。

示例：双口 RAM 实现

  1. module DualPortRAM (
  2.     input wire clk,
  3.     input wire [3:0] addr_a,
  4.     input wire [3:0] addr_b,
  5.     input wire [7:0] data_in_a,
  6.     input wire [7:0] data_in_b,
  7.     input wire we_a,
  8.     input wire we_b,
  9.     output reg [7:0] data_out_a,
  10.     output reg [7:0] data_out_b
  11. );
  12.     reg [7:0] ram [15:0]; // 16x8 RAM
  13.  
  14.     always @(posedge clk) begin
  15.         if (we_a) begin
  16.             ram[addr_a] <= data_in_a;
  17.         end
  18.         data_out_a <= ram[addr_a];
  19.     end
  20.  
  21.     always @(posedge clk) begin
  22.         if (we_b) begin
  23.             ram[addr_b] <= data_in_b;
  24.         end
  25.         data_out_b <= ram[addr_b];
  26.     end
  27. endmodule

操作步骤

  1. 定义双口 RAM 模块，包括地址、数据输入输出、写使能等端口。
  2. 在时钟上升沿，根据写使能信号进行写操作，同时输出对应地址的数据。
  3. 在顶层模块中实例化双口 RAM，并验证读写操作。

4. FIFO (First-In-First-Out)

作用

FIFO 用于数据缓冲和流控，通常在跨时钟域设计中使用，以处理不同速度的数据流。

示例：异步 FIFO 实现

  1. module AsyncFIFO (
  2.     input wire wr_clk,
  3.     input wire wr_reset,
  4.     input wire [7:0] wr_data,
  5.     input wire wr_en,
  6.     output wire full,
  7.     input wire rd_clk,
  8.     input wire rd_reset,
  9.     output wire [7:0] rd_data,
  10.     input wire rd_en,
  11.     output wire empty
  12. );
  13.     parameter DEPTH = 16;
  14.     reg [7:0] fifo [DEPTH-1:0];
  15.     reg [3:0] wr_ptr = 0;
  16.     reg [3:0] rd_ptr = 0;
  17.     reg [4:0] wr_gray = 0;
  18.     reg [4:0] rd_gray = 0;
  19.  
  20.     // Write logic
  21.     always @(posedge wr_clk or posedge wr_reset) begin
  22.         if (wr_reset) begin
  23.             wr_ptr <= 0;
  24.             wr_gray <= 0;
  25.         end else if (wr_en && !full) begin
  26.             fifo[wr_ptr] <= wr_data;
  27.             wr_ptr <= wr_ptr + 1;
  28.             wr_gray <= (wr_ptr >> 1) ^ wr_ptr;
  29.         end
  30.     end
  31.  
  32.     // Read logic
  33.     always @(posedge rd_clk or posedge rd_reset) begin
  34.         if (rd_reset) begin
  35.             rd_ptr <= 0;
  36.             rd_gray <= 0;
  37.         end else if (rd_en && !empty) begin
  38.             rd_data <= fifo[rd_ptr];
  39.             rd_ptr <= rd_ptr + 1;
  40.             rd_gray <= (rd_ptr >> 1) ^ rd_ptr;
  41.         end
  42.     end
  43.  
  44.     // Status signals
  45.     assign full = (wr_gray == {~rd_gray[4], rd_gray[3:0]});
  46.     assign empty = (wr_gray == rd_gray);
  47. endmodule

操作步骤

  1. 定义异步 FIFO 模块，包括写时钟域和读时钟域的信号。
  2. 在写时钟域中，使用写指针和灰码编码写入数据。
  3. 在读时钟域中，使用读指针和灰码编码读取数据。
  4. 生成满信号和空信号，指示 FIFO 的状态。
  5. 在顶层模块中实例化 FIFO，并验证读写操作。

5. 仲裁 (Arbitration)

作用

仲裁用于解决多个信号或设备同时请求同一资源的问题，确保系统稳定性和公平性。

示例：轮询仲裁 (Round-Robin Arbiter)

  1. module RoundRobinArbiter (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire [3:0] request,
  5.     output reg [3:0] grant
  6. );
  7.     reg [1:0] pointer;
  8.     
  9.     always @(posedge clk or posedge reset) begin
  10.         if (reset) begin
  11.             pointer <= 0;
  12.             grant <= 0;
  13.         end else begin
  14.             case (pointer)
  15.                 2'b00: if (request[0]) grant <= 4'b0001; else pointer <= pointer + 1;
  16.                 2'b01: if (request[1]) grant <= 4'b0010; else pointer <= pointer + 1;
  17.                 2'b10: if (request[2]) grant <= 4'b0100; else pointer <= pointer + 1;
  18.                 2'b11: if (request[3]) grant <= 4'b1000; else pointer <= pointer + 1;
  19.             endcase
  20.         end
  21.     end
  22. endmodule

操作步骤

  1. 定义轮询仲裁器模块，包括请求信号 request 和授予信号 grant。
  2. 在时钟上升沿，根据指针 pointer 和请求信号进行仲裁，并更新授予信号。
  3. 在顶层模块中实例化轮询仲裁器，并验证仲裁逻辑。

6. 资源争用 (Resource Contention)

作用

资源争用处理多个模块或设备对共享资源（如总线、存储器）的竞争，确保系统在高负载下正常运行。

示例：总线争用控制

  1. module BusController (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire req_a,
  5.     input wire req_b,
  6.     output reg grant_a,
  7.     output reg grant_b
  8. );
  9.     reg [1:0] state;
  10.     typedef enum reg [1:0] {
  11.         IDLE,
  12.         GRANT_A,
  13.         GRANT_B
  14.     } state_t;
  15.  
  16.     always @(posedge clk or posedge reset) begin
  17.         if (reset) begin
  18.             state <= IDLE;
  19.             grant_a <= 0;
  20.             grant_b <= 0;
  21.         end else begin
  22.             case (state)
  23.                 IDLE: begin
  24.                     if (req_a) begin
  25.                         state <= GRANT_A;
  26.                         grant_a <= 1;
  27.                     end else if (req_b) begin
  28.                         state <= GRANT_B;
  29.                         grant_b <= 1;
  30.                     end
  31.                 end
  32.                 GRANT_A: begin
  33.                     if (!req_a) begin
  34.                         state <= IDLE;
  35.                         grant_a <= 0;
  36.                     end
  37.                 end
  38.                 GRANT_B: begin
  39.                     if (!req_b) begin
  40.                         state <= IDLE;
  41.                         grant_b <= 0;
  42.                     end
  43.                 end
  44.             endcase
  45.         end
  46.     end
  47. endmodule

操作步骤

  1. 定义总线控制器模块，包括请求信号 req_a 和 req_b 以及授予信号 grant_a 和 grant_b。
  2. 在时钟上升沿，根据当前状态和请求信号进行状态转换，并更新授予信号。
  3. 在顶层模块中实例化总线控制器，并验证资源争用控制逻辑。

7. 高级进阶技巧

多时钟域设计

多时钟域设计中，需要处理不同时钟域之间的信号交互。跨时钟域信号同步是关键。

示例：多时钟域设计
  1. module MultiClockDomain (
  2.     input wire clk1,
  3.     input wire clk2,
  4.     input wire reset,
  5.     input wire [7:0] data_in,
  6.     output reg [7:0] data_out
  7. );
  8.     reg [7:0] buffer;
  9.     reg [1:0] sync_ff;
  10.  
  11.     always @(posedge clk1 or posedge reset) begin
  12.         if (reset) begin
  13.             buffer <= 0;
  14.         end else begin
  15.             buffer <= data_in; // Capture data in clk1 domain
  16.         end
  17.     end
  18.  
  19.     always @(posedge clk2 or posedge reset) begin
  20.         if (reset) begin
  21.             sync_ff <= 0;
  22.             data_out <= 0;
  23.         end else begin
  24.             sync_ff <= {sync_ff[0], buffer}; // Synchronize data to clk2 domain
  25.             data_out <= sync_ff[1];
  26.         end
  27.     end
  28. endmodule

状态机设计

状态机用于实现复杂的控制逻辑，通过定义状态和状态转换来控制系统行为。

示例：状态机设计
  1. module StateMachine (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire start,
  5.     output reg done
  6. );
  7.     typedef enum reg [1:0] {
  8.         IDLE,
  9.         RUN,
  10.         DONE
  11.     } state_t;
  12.  
  13.     state_t state, next_state;
  14.  
  15.     always @(posedge clk or posedge reset) begin
  16.         if (reset) begin
  17.             state <= IDLE;
  18.         end else begin
  19.             state <= next_state;
  20.         end
  21.     end
  22.  
  23.     always @(*) begin
  24.         case (state)
  25.             IDLE: if (start) next_state = RUN; else next_state = IDLE;
  26.             RUN: next_state = DONE;
  27.             DONE: next_state = IDLE;
  28.             default: next_state = IDLE;
  29.         endcase
  30.     end
  31.  
  32.     always @(posedge clk or posedge reset) begin
  33.         if (reset) begin
  34.             done <= 0;
  35.         end else begin
  36.             done <= (state == DONE);
  37.         end
  38.     end
  39. endmodule

异步复位同步释放

异步复位同步释放用于处理异步复位信号，确保在时钟域内同步释放复位信号。

示例：异步复位同步释放
  1. module AsyncResetSyncRelease (
  2.     input wire clk,
  3.     input wire async_reset,
  4.     output reg sync_reset
  5. );
  6.     reg [1:0] sync_ff;
  7.  
  8.     always @(posedge clk or posedge async_reset) begin
  9.         if (async_reset) begin
  10.             sync_ff <= 2'b11;
  11.         end else begin
  12.             sync_ff <= {sync_ff[0], 1'b0};
  13.         end
  14.     end
  15.  
  16.     assign sync_reset = sync_ff[1];
  17. endmodule

竞争冒险和避免方法

竞争冒险是由于多个信号在同一时刻变化而导致的不确定性结果。通常在组合逻辑电路中发生。为了避免竞争冒险，可以采用以下方法：

  1. 引入适当的延时：确保所有信号在同一时刻变化。
  2. 使用同步电路：减少组合逻辑的深度，增加时序逻辑。
示例：避免竞争冒险
  1. module AvoidingRaceCondition (
  2.     input wire a,
  3.     input wire b,
  4.     input wire clk,
  5.     output reg y
  6. );
  7.     reg a_sync, b_sync;
  8.  
  9.     always @(posedge clk) begin
  10.         a_sync <= a;
  11.         b_sync <= b;
  12.     end
  13.  
  14.     always @(*) begin
  15.         y = a_sync & b_sync; // Use synchronized signals to avoid race conditions
  16.     end
  17. endmodule

常见 FPGA 问题及解决方案

问题1：时序违例

时序违例是指电路在规定的时间内无法完成信号传输，导致电路无法正常工作。

解决方案：

  • 优化逻辑，减少路径延迟。
  • 使用时钟使能信号，减少时钟负载。
示例：时序违例优化
  1. module TimingViolationFix (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire [7:0] a,
  5.     input wire [7:0] b,
  6.     output reg [7:0] sum
  7. );
  8.     reg [7:0] a_reg, b_reg;
  9.  
  10.     always @(posedge clk or posedge reset) begin
  11.         if (reset) begin
  12.             a_reg <= 0;
  13.             b_reg <= 0;
  14.         end else begin
  15.             a_reg <= a;
  16.             b_reg <= b;
  17.         end
  18.     end
  19.  
  20.     always @(posedge clk or posedge reset) begin
  21.         if (reset) begin
  22.             sum <= 0;
  23.         end else begin
  24.             sum <= a_reg + b_reg; // Reduced critical path
  25.         end
  26.     end
  27. endmodule
问题2：资源利用率过高

资源利用率过高会导致 FPGA 的资源不足，从而无法实现预期的功能。

解决方案：

  • 优化逻辑，减少资源消耗。
  • 使用更高密度的 FPGA 器件。
示例：资源优化
  1. module ResourceOptimization (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire [7:0] a,
  5.     input wire [7:0] b,
  6.     output reg [7:0] sum
  7. );
  8.     always @(posedge clk or posedge reset) begin
  9.         if (reset) begin
  10.             sum <= 0;
  11.         end else begin
  12.             sum <= a + b; // Simple combinational logic
  13.         end
  14.     end
  15. endmodule
问题3：功耗过高

FPGA 的功耗过高会导致设备过热，降低系统的可靠性和寿命。

解决方案：

  • 使用低功耗模式和时钟门控技术。
  • 优化电路设计，减少不必要的开关活动。
示例：功耗优化
  1. module PowerOptimization (
  2.     input wire clk,
  3.     input wire reset,
  4.     input wire [7:0] a,
  5.     input wire [7:0] b,
  6.     input wire enable,
  7.     output reg [7:0] sum
  8. );
  9.     always @(posedge clk or posedge reset) begin
  10.         if (reset) begin
  11.             sum <= 0;
  12.         end else if (enable) begin
  13.             sum <= a + b; // Clock gating to reduce power consumption
  14.         end
  15.     end
  16. endmodule

通过本教程，你已经了解了 Verilog 的进阶主题，包括跨 Die、跨时钟域、双口 RAM、FIFO、仲裁和资源争用，以及各种常用技巧和区别。每个部分都包括了具体的实例和操作步骤，并讨论了常见的 FPGA 问题及解决方法，希望这些内容能帮助你更好地进行 Verilog 编程和硬件设计。

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

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

  

闽ICP备14008679号