FPGA语法基础（一）：Verilog 数组清零方法详解

Verilog数组清零方法详解
原创 于 2025-11-12 13:44:18 发布 · 534 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga开发 #Verilog语法 #数组清零 #verilog数组清零

Verilog 中数组清零是数字电路设计中常见的操作。下面详细介绍各种清零方法及其适用场景。

1. 使用循环初始化（可综合）

方法1: for循环清零（推荐）

module array_clear_example (
    input wire clk,
    input wire rst_n,
    input wire clear_signal
);

// 定义数组
reg [7:0] data_array [0:15];  // 16个8位元素的数组
integer i;

// 方法1A: 同步复位清零
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // 复位时清零整个数组
        for (i = 0; i < 16; i = i + 1) begin
            data_array[i] <= 8'h00;
        end
    end else if (clear_signal) begin
        // 收到清零信号时清零
        for (i = 0; i < 16; i = i + 1) begin
            data_array[i] <= 8'h00;
        end
    end else begin
        // 正常操作
        // data_array <= ... 其他逻辑
    end
end

endmodule

方法2: 多周期清零（适用于大数组）

module multi_cycle_clear (
    input wire clk,
    input wire rst_n,
    input wire start_clear
);

// 定义大数组
reg [7:0] large_array [0:255];  // 256个元素
reg [7:0] clear_counter;        // 清零计数器
reg clearing;                   // 清零状态标志

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        clear_counter <= 8'h00;
        clearing <= 1'b0;
        // 复位时清零数组
        for (i = 0; i < 256; i = i + 1) begin
            large_array[i] <= 8'h00;
        end
    end else if (start_clear && !clearing) begin
        // 开始清零过程
        clearing <= 1'b1;
        clear_counter <= 8'h00;
    end else if (clearing) begin
        // 逐个元素清零
        if (clear_counter < 255) begin
            large_array[clear_counter] <= 8'h00;
            clear_counter <= clear_counter + 1;
        end else begin
            // 清零最后一个元素并结束
            large_array[clear_counter] <= 8'h00;
            clearing <= 1'b0;
        end
    end
end

// 清零完成信号
assign clear_done = (clearing && (clear_counter == 255));

endmodule

方法3: generate循环清零

module generate_clear_example (
    input wire clk,
    input wire rst_n,
    input wire clear
);

// 定义大数组
reg [7:0] memory_array [0:1023];  // 1KB内存

// 使用generate简化初始化
genvar i;
generate
    for (i = 0; i < 1024; i = i + 1) begin : array_init
        always @(posedge clk or negedge rst_n) begin
            if (!rst_n) begin
                memory_array[i] <= 8'h00;
            end else if (clear) begin
                memory_array[i] <= 8'h00;
            end
        end
    end
endgenerate

endmodule

2. 使用初始块（仅用于仿真）

module simulation_clear_example;

// 定义数组
reg [7:0] sim_array [0:15];
integer j;

// 方法4: initial块清零（仅仿真）
initial begin
    for (j = 0; j < 16; j = j + 1) begin
        sim_array[j] = 8'h00;
    end
    $display("Array initialized to zero in simulation");
end

// 方法5: 使用重复赋值（仅仿真）
reg [7:0] another_array [0:7];
initial begin
    // 使用位宽扩展
    another_array[0] = 8'h00;
    another_array[1] = 8'h00;
    // ... 或者使用循环
end

endmodule

3. 使用memory初始化文件

module memory_init_example (
    input wire clk,
    input wire rst_n,
    input wire [3:0] addr,
    output reg [7:0] data_out
);

// 定义内存数组
reg [7:0] memory_block [0:15];  // 16字节内存

// 方法6: 使用复位信号清零
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // 清零整个内存块
        for (integer k = 0; k < 16; k = k + 1) begin
            memory_block[k] <= 8'h00;
        end
        data_out <= 8'h00;
    end else begin
        data_out <= memory_block[addr];
    end
end

endmodule

4. 实际工程应用示例

FIFO清零实现

module fifo_with_clear #(
    parameter DATA_WIDTH = 8,
    parameter FIFO_DEPTH = 16
)(
    input wire clk,
    input wire rst_n,
    input wire clear,           // 清零信号
    input wire wr_en,
    input wire [DATA_WIDTH-1:0] wr_data,
    input wire rd_en,
    output wire [DATA_WIDTH-1:0] rd_data,
    output wire full,
    output wire empty
);

// FIFO内存
reg [DATA_WIDTH-1:0] fifo_mem [0:FIFO_DEPTH-1];
reg [3:0] wr_ptr, rd_ptr;
reg [4:0] count;  // 需要额外1位检测满状态

// 清零控制逻辑
reg clearing;
reg [3:0] clear_index;

// 清零状态机
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // 复位时清零FIFO
        for (integer i = 0; i < FIFO_DEPTH; i = i + 1) begin
            fifo_mem[i] <= {DATA_WIDTH{1'b0}};
        end
        wr_ptr <= 4'h0;
        rd_ptr <= 4'h0;
        count <= 5'h0;
        clearing <= 1'b0;
        clear_index <= 4'h0;
    end else if (clear && !clearing) begin
        // 开始清零过程
        clearing <= 1'b1;
        clear_index <= 4'h0;
        count <= 5'h0;  // 立即重置计数器
    end else if (clearing) begin
        // 逐个清零FIFO元素
        if (clear_index < FIFO_DEPTH-1) begin
            fifo_mem[clear_index] <= {DATA_WIDTH{1'b0}};
            clear_index <= clear_index + 1;
        end else begin
            // 清零最后一个元素
            fifo_mem[clear_index] <= {DATA_WIDTH{1'b0}};
            clearing <= 1'b0;
            wr_ptr <= 4'h0;
            rd_ptr <= 4'h0;
        end
    end else begin
        // 正常FIFO操作
        if (wr_en && !full) begin
            fifo_mem[wr_ptr] <= wr_data;
            wr_ptr <= wr_ptr + 1;
            count <= count + 1;
        end
        
        if (rd_en && !empty) begin
            rd_ptr <= rd_ptr + 1;
            count <= count - 1;
        end
    end
end

// FIFO状态信号
assign rd_data = fifo_mem[rd_ptr];
assign full = (count == FIFO_DEPTH);
assign empty = (count == 0);

endmodule

RAM清零控制器

module ram_clear_controller #(
    parameter RAM_DEPTH = 1024,
    parameter DATA_WIDTH = 32
)(
    input wire clk,
    input wire rst_n,
    input wire start_clear,
    input wire [DATA_WIDTH-1:0] clear_value,
    output reg clear_done,
    output reg [DATA_WIDTH-1:0] ram_data_out
);

// RAM内存
reg [DATA_WIDTH-1:0] ram [0:RAM_DEPTH-1];

// 清零控制
reg [9:0] clear_addr;  // 10位地址，支持1024深度
reg clearing;

// 清零状态机
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        clear_addr <= 10'h0;
        clearing <= 1'b0;
        clear_done <= 1'b1;  // 初始状态为完成
        
        // 复位时清零RAM
        for (integer i = 0; i < RAM_DEPTH; i = i + 1) begin
            ram[i] <= {DATA_WIDTH{1'b0}};
        end
    end else begin
        if (start_clear && !clearing) begin
            // 开始清零
            clearing <= 1'b1;
            clear_addr <= 10'h0;
            clear_done <= 1'b0;
        end else if (clearing) begin
            // 执行清零
            ram[clear_addr] <= clear_value;
            
            if (clear_addr == RAM_DEPTH-1) begin
                // 清零完成
                clearing <= 1'b0;
                clear_done <= 1'b1;
            end else begin
                clear_addr <= clear_addr + 1;
            end
        end
    end
end

// RAM数据输出
always @(*) begin
    ram_data_out = ram[clear_addr];
end

endmodule

缓存清零模块

module cache_clear_unit #(
    parameter CACHE_SIZE = 64,
    parameter DATA_WIDTH = 64
)(
    input wire clk,
    input wire rst_n,
    input wire flush_cache,
    output reg cache_clean
);

// 缓存行定义
reg [DATA_WIDTH-1:0] cache_data [0:CACHE_SIZE-1];
reg valid_bits [0:CACHE_SIZE-1];
reg dirty_bits [0:CACHE_SIZE-1];

// 清零控制
reg [5:0] clear_index;  // 6位支持64个条目
reg clearing;

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        clear_index <= 6'h0;
        clearing <= 1'b0;
        cache_clean <= 1'b1;
        
        // 复位时初始化缓存
        for (integer i = 0; i < CACHE_SIZE; i = i + 1) begin
            cache_data[i] <= {DATA_WIDTH{1'b0}};
            valid_bits[i] <= 1'b0;
            dirty_bits[i] <= 1'b0;
        end
    end else if (flush_cache && !clearing) begin
        // 开始缓存刷新
        clearing <= 1'b1;
        clear_index <= 6'h0;
        cache_clean <= 1'b0;
    end else if (clearing) begin
        // 逐个缓存行清零
        valid_bits[clear_index] <= 1'b0;
        dirty_bits[clear_index] <= 1'b0;
        // cache_data 可以保留，因为valid=0表示无效
        
        if (clear_index == CACHE_SIZE-1) begin
            // 刷新完成
            clearing <= 1'b0;
            cache_clean <= 1'b1;
        end else begin
            clear_index <= clear_index + 1;
        end
    end
end

endmodule

5. 条件清零方法

选择性清零

module conditional_clear (
    input wire clk,
    input wire rst_n,
    input wire [3:0] clear_mask,
    input wire clear_all
);

reg [7:0] data_banks [0:3];  // 4个数据bank

integer i;

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        for (i = 0; i < 4; i = i + 1) begin
            data_banks[i] <= 8'h00;
        end
    end else if (clear_all) begin
        // 清零所有bank
        for (i = 0; i < 4; i = i + 1) begin
            data_banks[i] <= 8'h00;
        end
    end else begin
        // 根据mask选择性清零
        for (i = 0; i < 4; i = i + 1) begin
            if (clear_mask[i]) begin
                data_banks[i] <= 8'h00;
            end
        end
    end
end

endmodule

带条件的部分清零

module partial_clear (
    input wire clk,
    input wire rst_n,
    input wire [7:0] threshold,
    input wire clear_above_threshold
);

reg [7:0] sensor_data [0:31];  // 32个传感器数据

integer i;

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        for (i = 0; i < 32; i = i + 1) begin
            sensor_data[i] <= 8'h00;
        end
    end else if (clear_above_threshold) begin
        // 只清零超过阈值的数据
        for (i = 0; i < 32; i = i + 1) begin
            if (sensor_data[i] > threshold) begin
                sensor_data[i] <= 8'h00;
            end
        end
    end
end

endmodule

6. 性能优化技巧

流水线清零

module pipelined_clear #(
    parameter ARRAY_SIZE = 256
)(
    input wire clk,
    input wire rst_n,
    input wire start_clear,
    output reg clear_complete
);

reg [7:0] target_array [0:ARRAY_SIZE-1];
reg [1:0] clear_pipeline [0:2];  // 3级流水线
reg [7:0] pipe_addr [0:2];

// 流水线清零实现
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        for (integer i = 0; i < ARRAY_SIZE; i = i + 1) begin
            target_array[i] <= 8'h00;
        end
        for (integer j = 0; j < 3; j = j + 1) begin
            clear_pipeline[j] <= 2'b00;
            pipe_addr[j] <= 8'h00;
        end
        clear_complete <= 1'b1;
    end else begin
        // 流水线推进
        clear_pipeline[0] <= start_clear ? 2'b01 : 2'b00;
        pipe_addr[0] <= 8'h00;
        
        for (integer k = 1; k < 3; k = k + 1) begin
            clear_pipeline[k] <= clear_pipeline[k-1];
            pipe_addr[k] <= pipe_addr[k-1];
        end
        
        // 执行清零（流水线第2级）
        if (clear_pipeline[1] == 2'b01) begin
            if (pipe_addr[1] < ARRAY_SIZE-1) begin
                target_array[pipe_addr[1]] <= 8'h00;
                pipe_addr[1] <= pipe_addr[1] + 1;
            end else begin
                clear_pipeline[1] <= 2'b10;  // 完成标记
            end
        end
        
        // 完成检测（流水线第3级）
        if (clear_pipeline[2] == 2'b10) begin
            clear_complete <= 1'b1;
        end else begin
            clear_complete <= 1'b0;
        end
    end
end

endmodule

总结

Verilog 数组清零的最佳实践：

  1. 小数组：使用单周期的 for 循环清零

  2. 大数组：使用多周期状态机避免时序问题

  3. 性能关键：考虑流水线清零提高吞吐率

  4. 资源优化：使用 generate 语句减少代码量

  5. 条件清零：结合条件语句实现选择性清零

方法选择指南：

数组大小推荐方法时钟周期资源消耗
< 16 元素单周期 for 循环1低
16-64 元素多周期清零n中
> 64 元素流水线清零n/pipeline_depth高
条件清零带条件的 for 循环1中

根据具体的设计需求和约束选择合适的清零策略。

FPGA开发指南：Verilog基本语法详解
code_welike的博客
08-03 244
上述代码表示，在时钟上升沿触发时，如果reset信号有效，则将count变量清零，否则如果enable信号有效，则将count变量加1。Verilog支持多种基本数据类型，包括整型、实数型、布尔型等，其中最常用的是整型。需要注意的是，方括号中的数字表示该变量的位宽，冒号前的数字表示最高位编号，冒号后的数字表示最低位编号。其中，adder是被实例化的模块名称，adder_inst是该实例化的名称，圆点后的内容是连接端口。需要注意的是，Verilog中有些运算符的优先级需要注意，可以使用括号来明确运算次序。
8.Verilog的for循环语句使用
FPGA/MATLAB学习教程/源码/项目合作开发
02-05 1万+
在Verilog中，对于循环功能的实现，主要通过for语句来实现。 在verilog中，for循环的主要功能用于赋值和延迟两个功能，下面对这两个功能的实现进行介绍。 1.赋值功能 首先来看一个例子： `timescale 1ns / 1ps module count( input i_clk, input i_rst, output reg[9:0]o_count1, output reg[9:0]o_count2, output reg[9:0]o_count3 ); reg[7:0]t
【个人向】Verilog基础：模块代码、Testbench详解与仿真图
Captain_FEI_NTU的博客
12-19 2289
个人学习总结2 - Verilog最基本模块与Testbench仿真。 个人向！ 参考：数字逻辑基础与Verilog设计（英文原书第3版）McGrawHill Education。 参考：机械工业出版社中文翻译版 - 国外电子与电气工程技术丛书。 软件：Quartus_II，Vivado，ChatGPT。 此文章包括Verilog基本模块代码，Testbench代码，Tb语句讲解，仿真结果与分析！ 个人NTU在读，欢迎指正基本的语法见上一篇文章 :) 状态机电Tb及仿真详见下一篇文章，本篇篇幅太长了 :)
【verilog】verilog 中for循环的使用
weixin_47730622的博客
09-09 3万+
【verilog】verilog 中for循环的使用
verilog语法-008—几种可综合的for循环语句
IC小鸽的博客
09-04 1万+
本文讲解了SystemVerilog中可以用于综合的几种for循环设计
verilog中的for 循环
luoai_2666的博客
09-19 1万+
例1. module test( output reg [8:0] sumx , input [4:0] x ); parameter n = 3'd3; integer i ; always @ (*) begin sumx = 1 ; for( i=0; i<n; i=i+1 ) sumx = sumx + x ; end endmodule 令x=3，仿真结果 综合结果： for循环n次代表有n个相似的电路模块存在；代码上的“循环反馈”结构在阻塞赋值时代表前后
Verilog循环语句
jk_101的博客
03-31 1万+
while循环的每次迭代之前都会判断指定条件是否满足，如果为真，就执行条件内的循环代码块；注意注意，for循环在正式FPGA设计中部分情况下可综合，其余几个循环语句均不可综合，主要用于testbench。本文主要介绍verilog常用的循环语句，循环语句的用途，主要是可以多次执行相同的代码或逻辑。创建一个从 0 到 3 的integer型变量，然后在循环的每次迭代中打印这个变量的值。verilog 中的forever循环会创建一个连续执行的代码块，并无限循环。repeat循环执行指定次数的循环代码块。
【Verilog数组操作详解】：存储与处理数据的5大高效策略
![【Verilog数组操作详解】：存储与...本章将介绍Verilog数组操作的基础知识，让读者建立起对数组操作的初步理解，并为后续章节深入探讨数组声明、存储策略、处理方法及高级应用打下坚实的基础。 Verilog数组是一组相
【FPGA项目实战】：Verilog在实际应用中的硬件描述语言技巧
本文深入探讨了Verilog在硬件设计中的应用，涵盖了从基础语法到高级设计技巧的全面内容。文章首先介绍了Verilog的核心特性，包括基本语法、行为级建模和结构级建模，为读者提供了坚实的设计基础。接着，文章转入FPGA...
FPGA学习笔记七：使用Verilog语言设计一个较大规模的复杂计数器（HDLBits第151-156题）
m0_51272018的博客
03-04 1208
目录????前言一、设计要求与模块功能二、各个底层模块的设计（一）千进制计数器（二）四位右移位寄存计数器（三）1101序列识别模块（四）计数使能状态机（五）复杂计数器完整状态机模块三、顶层模块的设计1.顶层的设计要点及优化(1)状态转移逻辑的设计思路(2)例化模块及其端口描述总结 前言 本文基于HDdLBits题目中的最后一个难点部分，也就是第151-156题。在学习完之前章节的各类语法、组合逻辑电路、时序逻辑电路以及状态机的设计之后，我们应该有一定的能力去设计一个更加复杂的电路。本次博客所讲述的是一个
Verilog for 循环
whik1194的博客
03-12 3万+
文章目录语法示例#1：基本循环控制示例#2：8位左移移位寄存器的实现 语法 for(<initial_condition>;<condition>;<step_assignment>) begin //statements end 执行过程如下： 指定初始循环变量值 条件是否为真，条件为假则跳出循环 若条件为真则执行控制语句 循环变量迭代更新 示例#1：基本循环控制 module my_design; integer i; initial begin
verilog for循环的使用
热门推荐
m0_47137431的博客
09-17 3万+
Verilog 中重复的内容可以使用for循环来完成，目前总结的注意点如下： 1、always 内部用for循环，需要定义interger类型变量，否则有些仿真工具会报错 2、异步复位时序逻辑always@下面第一行必须是异步复位，不能有for循环，否则综合工具会报错 3、for语句在always 外部，或者使用for循环例化模块，需要定义genvar变量，否则有些仿真工具会报错。 ...
verilog中for循环的转化使用
IT荻的博客
09-01 9272
参考总结自Verilog那些事。。。 转摘自：http://blog.chinaaet.com/lincoding/p/5100050055/* 单个for循环 */ ` for ( i=0; i<10; i++ ){Act++; }//1、时序实现case ( i )0: begin if ( x == C1 ) begin
Verilog教程----循环语句（十二）
2301_78841466的博客
04-06 1183
Verilog中存在4种循环语句，用来控制语句的执行次数① for：有条件的循环语句② repeat：连续执行一次语句n次③ while：执行一条语句知道某个条件不满足④ forever：连续的执行语句；多用在initial块中，以生成时钟等周期性波形。
Verilog | for语句的理解与使用
qq_45776815的博客
11-07 9798
for语句在硬件里的使用并不频繁，一方面是因为for语句循环几次，就是将相同的电路复制几次，因此循环次数越多，占用面积越大， 综合就越慢，for语句的使用就很占用硬件资源，另一方面是因为在设计中往往是采用时序逻辑设计用到for循环的地方不多。通过流水线乘法的示例对for语句进行理解。
Verilog语法：for循环的使用心得
最新发布
qq_53805942的博客
07-17 1581
Verilog之for循环的常见用法，总计3种用法，提供了相关代码和结果展示。
verilog中的3种for循环的写法
aaa23d1的博客
03-01 2万+
verilog中的3种for循环的写法
同步清零FPGA十进制加法计数器详解
然后，文中给出了一个使用Verilog HDL（硬件描述语言）编写的模块代码示例，这是FPGA设计中的常见工具。模块名为`example_4_10`，包含输入(clr和clk)、输出(cnt和out)以及内部寄存器。在always块中，通过条件语句...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FPGA_小田老师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值