HDLbits 刷题笔记 P1

为什么要写这个

笔者之前有多次学习verilog的经历,但因为工作内容不涉及复杂的数字电路设计,因此水平限于入门,最近在一生一芯的学习中,在HDLbits上刷题,看到了很多对笔者来说比较陌生的语法,还有一些常用语法但其实并没有搞清细节。

这篇文章记录了我从 HDLbits 实战中挖出来的、速查表要么没写、要么写了也看不懂为什么有用的语法细节。


1. 操作符 位操作

1.1 位拼接 {}

只用一行 assign 实现 100 位全加器

// 100-bit ripple carry adder — 一行搞定进位链
assign sum = a ^ b ^ {c[98:0], cin};
assign c = (a & b) | ({c[98:0], cin} & (a ^ b));
assign cout = c[99];

{c[98:0], cin} 构造了一个 100 位的”进位向量”,低位进位 cin 被塞到第 0 位,高位进位 c[98:0] 依次左移。

没有 generate,没有 for 循环,没有 Full_adder 例化——纯连线和位拼接就把 ripple carry 写完了。

核心思想:{} 不止是拼接信号,更是在构造位宽匹配的中间向量。

1.2 复制运算符 {N{}}

// 将 8 位有符号数扩展为 32 位(符号位扩展)
assign out = { {24{in[7]}}, in };
//               ↑ 把 in[7] 复制 24 次,填满高 24 位

做补码转换:

// 加减法器核心:sub=1 时对 b 求补码
b[15:0] ^ {16{sub}}  //当 sub=1 => 按位取反,sub=0 => b 不变

More replication:

assign out = ~{ {5{a}}, {5{b}}, {5{c}}, {5{d}}, {5{e}} }
               ^ { {5{a, b, c, d, e}} };

第一眼完全不知道在干嘛。实际上是在算两个 25 位向量的 XNOR,这两个向量分别是”每个信号复制 5 次后拼接”和”5 个信号整体复制 5 次后拼接”。

1.3 缩减运算符(Reduction operators)

assign parity = ^in;     // in[7] ^ in[6] ^ ... ^ in[0],奇偶校验
assign all_zero = ~|in;  // 检测全 0
assign all_one = ∈    // 检测全 1

^in 等价于把 in 的每一位全部 XOR 起来。语法上它就是个单目运算符,不是双目。速查表会写”缩减运算符”几个字,但不会告诉你它在实际电路里就是用一串 XOR 树综合出来的,也不会告诉你 ~|in 是检测全 0 最简洁的写法。

1.4 索引部分选择 +: ——动态位宽切片

// 256-to-1 4-bit multiplexer
module top_module( 
    input [1023:0] in,
    input [7:0] sel,
    output [3:0] out
);
    assign out = in[sel*4 +: 4];
    //               ↑     ↑  ↑
    //             起始   ":固定宽度"  取 4 位
endmodule

等价写法:

assign out = {in[sel*4+3], in[sel*4+2], in[sel*4+1], in[sel*4+0]};

+: 让起始位置可以是一个变量(这里是 sel*4),而宽度 4 是编译期常量。如果没有 +: ,你只能用 generate 或者手写 256 个 case 分支。综合器会把它变成一棵 mux 树,而不是 1024 个选择器并联。

💡 同理还有 -::in[sel*4+3 -: 4] 从高位往下取。

这里的关键因素是编译器需要在编译阶段确定选择的总位宽,在for循环内如果符号是循环变量,则位宽也可以被确定,所以可以编译通过


2. 两种循环:for vs generate for——选错就出错

这是 HDLbits 到 Circuits 阶段最大的分水岭。速查表上两个都有,但什么时候用哪一个才是真问题。

2.1 for 循环——过程性循环,写在 always 里面

// 255-bit population count(数 1 的个数)
always @(*) begin
    count = 0;
    for (i = 0; i < 255; i = i + 1) begin
        if (in[i])
            count = count + 1;
    end
end

这个 for 不是”循环执行 255 次”,它在综合时被完全展开,等价于 255 个加法器排成加法树。always @(*) 里的 for 只是写代码方便,硬件上没有循环。

2.2 generate for——结构性循环,写在 module 级

// 100 位全加器,用 generate for 生成 100 个 assign
genvar i;
generate
    for (i = 0; i < 100; i = i + 1) begin: adder
        if (i == 0) begin: loop1
            assign {cout[i], sum[i]} = a[i] + b[i] + cin;
        end
        else begin: loop1
            assign {cout[i], sum[i]} = a[i] + b[i] + cout[i-1];
        end
    end
endgenerate

区别:

特性always 里的 forgenerate for
循环变量类型integergenvar(编译期常量)
展开时机综合时展开编译前展开(更早)
能生成什么块内逻辑module、assign、always 块
典型场景popcount、累加、移位例化 N 个模块、N 个 always
能否嵌套 if-else可以(if 在循环体内)可以(用 generate if)

💡 选型指南:

  • 只需要在一个 always 块里重复逻辑 → for in always
  • 需要生成多个独立的 always / module / assign → generate for
  • 需要条件编译(有些位用不同逻辑)→ generate for + generate if

2.3 begin: label_name 不是装饰

generate
    for (i = 0; i < 100; i = i + 1) begin: adder
        // generate 块必须有名字!
    end
endgenerate

没有 begin: adder 会产生编译错误。这个名字作用有二:

  1. 层次化引用:外部可以通过 adder[0].cout、adder[1].sum 引用内部信号
  2. 唯一标识:综合工具用它区分生成的 100 个实例

3. 实战硬核模式

3.1 双边沿触发器(Dual-edge triggered FF)

Verilog 没有 always @(posedge clk or negedge clk) 这种写法——至少对于时钟来说不行(那是异步复位语法)。

怎么办?

module top_module (
    input clk, input d, output q
);
    reg q1, q2;
    
    always @(posedge clk) q1 <= d;
    always @(negedge clk) q2 <= d;
    
    assign q = (clk & q1) | (~clk & q2);
    //          ↑ clk 高时取 q1,低时取 q2
endmodule

工作原理:在 clk 上升沿采一次 d 到 q1,下降沿采一次 d 到 q2,然后用 clk 电平做 mux 选择。clk=1 时输出 q1,clk=0 时输出 q2。这样每个时钟周期输出变化两次,等效双边沿触发。

综合后是 2 个 DFF + 1 个 2-to-1 mux,不是真正的”双边沿 DFF”(那个要定制库才有)。

3.2 边沿检测模式

检测信号的上升沿:

always @(posedge clk) begin
    temp <= in;          // 延迟一拍
    pedge <= in & ~temp; // in=1 且 上一拍=0 → 上升沿
end

检测信号的双边沿:

always @(posedge clk) begin
    temp <= in;
    anyedge <= in ^ temp; // 跟上一次不一样 → 有跳变
end

边沿捕获(捕获后保持,直到 reset):

always @(posedge clk) begin
    if (reset)
        out <= 32'h0;
    else
        out <= out | (~in & temp);
    //        ↑ 保持已捕获的 | 检测到下降沿
end
always @(posedge clk) begin
    temp <= in;  // 延迟一拍,供上面用
end

这个模式在中断控制器、按键消抖、通信协议解析里无处不在。

3.3 有符号数溢出检测

// 8-bit signed addition overflow
assign overflow = ~(a[7] ^ b[7]) & (a[7] ^ s[7]);
//                 ↑ 两加数符号相同    ↑ 和与加数符号不同

逻辑:两个正数相加得负数,或者两个负数相加得正数 → 溢出。

a[7]b[7]s[7]overflow含义
0000正+正=正 ✅
0011正+正=负 ❌ 溢出
1110负+负=负 ✅
1101负+负=正 ❌ 溢出
01X0异号相加不可能溢出

对比无符号数的进位检测(cout),有符号数的溢出要看你想要哪种保护。

3.4 边界绕回——Verilog 不会帮你自动 wrap

// 16×16 网格中计算邻居索引,边界绕回
wire [7:0] up = ((i == 0) ? 15 : i - 1) * 16 + j;
wire [7:0] down = ((i == 15) ? 0 : i + 1) * 16 + j;
wire [7:0] left = i * 16 + ((j == 0) ? 15 : j - 1);
// ...

C 语言里 array[-1] 会访问到数组前面一个位置(可能 crash),Verilog 里 in[-1] 直接给你 X。没有自动回绕,没有模运算——你必须显式处理边界。

正确做法:三目运算符做边界判断,或者用 (i - 1 + N) % N(记得先加 N 再取模,因为 Verilog 的 % 对负数结果是负数)。


4. 综合实战中才会摸到的模式

4.1 LFSR(Linear Feedback shift register)——伪随机数生成器

// 32-bit LFSR,多项式反馈
always @(posedge clk) begin
    if (reset)
        q <= 32'h1;              // 不能全 0,否则永远跳不出来
    else
        q <= {q[0], q[31:1]} ^ {1'b0, 9'b0, q[0], 19'b0, {2{q[0]}}};
        //   右移 1 位            XOR 反馈多项式
end

LFSR 只需要几个 XOR 门就能生成周期为 2^N − 1 的伪随机序列。它的关键参数是抽头多项式(taps),决定了最大周期。上面的 32-bit LFSR 使用的是 x^32 + x^22 + x^2 + x^1 + 1 多项式——这是 IEEE 标准里定义的。

对比二进制计数器的全加器进位链,LFSR 是时序逻辑中最省门的结构之一。

4.2 Conway’s Game of Life——generate 实战

generate 双层循环和 位宽不匹配边界绕回:

genvar i, j;
generate
    for (i = 0; i < 16; i = i + 1) begin : row
        for (j = 0; j < 16; j = j + 1) begin : col
            // 8 个邻居索引——每个都用三目做边界绕回
            wire [7:0] up = ((i == 0) ? 15 : i - 1) * 16 + j;
            wire [7:0] down = ((i == 15) ? 0 : i + 1) * 16 + j;
            wire [7:0] left = i * 16 + ((j == 0) ? 15 : j - 1);
            wire [7:0] right = i * 16 + ((j == 15) ? 0 : j + 1);
            
            assign neighbor_cnt[i*16+j] = 
                q[up] + q[down] + q[left] + q[right]
                + q[up_left] + q[up_right] + q[down_left] + q[down_right];
        end
    end
endgenerate

256 个 cell 并行计算邻居数量——generate 在这里做的是”在编译时展开 256 份并行的加法逻辑”,而不是循环执行。这是硬件思维的核心区别。

4.3 12-hour clock——模块化的边界案例

// pm 翻转逻辑
always @(posedge clk) begin
    if (reset)
        pm <= 0;
    else if (hhb == 7'd11 && mmb == 7'd59 && ssb == 7'd59)
        pm <= ena ? ~pm : pm;  // 11:59:59 → 翻 pm
end

时钟是状态机的一种特例:它绕回时间长,进位条件复杂(分到小时,小时到 pm,12→1 不是加 1),还要处理 ena 使能暂停。它还不得不做 BCD 输出——自己手写了一个 bin2bcd 查找表模块:

module bin2bcd_8bit_lut (
    input  wire [7:0] bin_in,
    output wire [7:0] bcd_out
);
    wire [3:0] tens = bin_in / 8'd10;    // ÷10 得十位
    wire [3:0] ones = bin_in % 8'd10;    // %10 得个位
    assign bcd_out = {tens, ones};
endmodule

注意这里用了除法器和取模器——综合工具会自动推断出查找表而不是真的放一个除法器,因为 0-59 的输入范围很小。这是可综合的除法和取模的有效案例。


写在最后

刷完 HDLbits 115 题后回头看,一个有趣的观察是:

最让人痛苦的不是那些复杂的概念(FSM、加法树),而是那些”我知道语法但没想过还能这样写”的模式。

  • in[sel*4 +: 4] — 一行代替 256 行 case
  • {q[0], q[99:1]} — 旋转器
  • in & ~temp — 边沿检测
  • ~(a[7]^b[7]) & (a[7]^s[7]) — 溢出检测

希望这份笔记能让你少走几个坑。

Related Posts