08连续赋值语句
Verilog连续赋值语句详解
📑 目录
1. 概述
1.1 定义
连续赋值语句（Continuous Assignment）是Verilog HDL中实现数据流建模的核心语句，用于描述组合逻辑电路的行为。它能够实时反映输入信号的变化，是描述纯组合逻辑的主要方法。
1.2 核心特征
- 实时响应: 右侧表达式任何信号变化立即反映到左侧
- 并行执行: 所有连续赋值语句并行工作
- 无时钟依赖: 不需要时钟信号驱动
- 组合逻辑: 主要用于实现组合逻辑电路
1.3 应用场景
graph TD
A[连续赋值应用] --> B[组合逻辑设计]
A --> C[数据流建模]
A --> D[接口信号连接]
B --> B1[逻辑门实现]
B --> B2[译码器设计]
B --> B3[多路选择器]
C --> C1[算术运算]
C --> C2[位操作]
C --> C3[条件表达式]
D --> D1[模块间连接]
D --> D2[信号重命名]
D --> D3[总线分割]
2. 基本语法
2.1 基本格式
assign [延时] 目标信号 = 表达式;
2.2 语法要素
| 要素 | 说明 | 示例 |
|---|---|---|
assign |
关键字，声明连续赋值 | assign |
[延时] |
可选的时延控制 | #5, #(2:3:4) |
目标信号 |
左侧赋值目标 | output_signal |
= |
赋值操作符 | = |
表达式 |
右侧驱动表达式 | a & b | c |
2.3 基本示例
// 简单逻辑门
assign y = a & b; // 与门
assign z = x | y; // 或门
assign out = ~in; // 非门
// 复合表达式
assign result = (a & b) | (c & d);
// 条件表达式
assign output = select ? input1 : input2;
// 多位操作
assign [3:0] sum = a[3:0] + b[3:0];
3. 连续赋值的特点
3.1 实时响应特性
module continuous_demo(
input wire a, b, c,
output wire result
);
// 任何输入变化都会立即更新result
assign result = (a & b) | c;
endmodule
时序图示例:
时间: 0 1 2 3 4 5 6
a : 0 1 1 0 0 1 1
b : 0 0 1 1 0 0 1
c : 0 0 0 0 1 1 0
result: 0 0 1 0 1 1 1
3.2 并行执行
module parallel_assign(
input wire [3:0] data,
output wire [3:0] inverted,
output wire parity,
output wire [1:0] count
);
// 这些赋值语句并行执行
assign inverted = ~data; // 取反
assign parity = ^data; // 奇偶校验
assign count = data[1:0]; // 低2位提取
endmodule
3.3 多驱动冲突检测
// ❌ 错误：多个连续赋值驱动同一信号
assign wire_signal = input1;
assign wire_signal = input2; // 冲突！
// ✅ 正确：使用三态逻辑
assign wire_signal = enable1 ? input1 : 1'bz;
assign wire_signal = enable2 ? input2 : 1'bz;
4. 赋值目标与表达式
4.1 左侧目标（LHS）限制
4.1.1 允许的目标类型
wire [7:0] bus;
wire single_bit;
wire [3:0] nibble;
// ✅ 允许的赋值目标
assign single_bit = data_in; // 单个wire
assign bus = {upper[3:0], lower[3:0]}; // 向量wire
assign nibble = bus[7:4]; // 部分选择
assign {carry, sum[3:0]} = a[3:0] + b[3:0]; // 拼接
4.1.2 禁止的目标类型
reg [7:0] register;
integer int_var;
real real_var;
// ❌ 错误：不能赋值给寄存器类型
assign register = data_in; // 错误！
assign int_var = count; // 错误！
assign real_var = voltage; // 错误！
4.2 右侧表达式（RHS）
4.2.1 支持的表达式类型
wire [7:0] a, b, c;
wire [3:0] sel;
reg [7:0] reg_data;
// 常量表达式
assign const_out = 8'hFF;
// 变量表达式
assign var_out = a;
// 算术表达式
assign arith_out = a + b - c;
// 逻辑表达式
assign logic_out = a & b | c;
// 关系表达式
assign comp_out = (a > b);
// 条件表达式
assign cond_out = (sel[0]) ? a : b;
// 函数调用
assign func_out = $signed(a) + $signed(b);
// 寄存器也可以作为右侧
assign mixed_out = reg_data + a;
4.2.2 复杂表达式示例
module complex_expressions(
input wire [7:0] a, b, c,
input wire [2:0] sel,
input wire enable,
output wire [7:0] result1,
output wire [7:0] result2,
output wire [7:0] result3
);
// 多级条件表达式
assign result1 = sel[2] ? (sel[1] ? a : b) : (sel[0] ? c : 8'h00);
// 算术与逻辑混合
assign result2 = enable ? ((a + b) & 8'hF0) | (c & 8'h0F) : 8'hZZ;
// 位拼接与选择
assign result3 = {a[3:0], b[7:4]} + {2'b00, c[5:0]};
endmodule
5. 时延控制
5.1 时延类型概述
| 时延类型 | 语法 | 特点 | 应用场景 |
|---|---|---|---|
| 普通时延 | assign #5 y = a & b; |
固定延时 | 简单时序模拟 |
| 最小/典型/最大时延 | assign #(2:3:5) y = a; |
三值时延 | 工艺角分析 |
| 隐式时延 | assign y = #5 (a & b); |
表达式内延时 | 精确建模 |
| 声明时延 | wire #5 y; |
声明时指定 | 网表级建模 |
5.2 普通时延
module delay_examples(
input wire a, b,
output wire y1, y2, y3
);
// 固定时延
assign #5 y1 = a & b; // 5个时间单位延时
assign #10 y2 = a | b; // 10个时间单位延时
assign #2.5 y3 = a ^ b; // 2.5个时间单位延时
endmodule
5.3 最小/典型/最大时延
module triple_delay(
input wire a, b,
output wire slow_and, fast_or
);
// 三值时延：最小值:典型值:最大值
assign #(1:2:3) slow_and = a & b;
assign #(0.5:1:1.5) fast_or = a | b;
endmodule
5.4 隐式时延
module implicit_delay(
input wire [3:0] a, b,
output wire [3:0] sum,
output wire carry
);
// 表达式级别的时延
assign sum = #3 (a + b); // 加法运算有3个时间单位延时
assign carry = #1 (a + b > 4'hF); // 比较运算有1个时间单位延时
endmodule
5.5 声明时延
module declaration_delay(
input wire a, b,
output wire result
);
// 在线网声明时指定延时
wire #5 delayed_a;
wire #3 delayed_b;
assign delayed_a = a;
assign delayed_b = b;
assign result = delayed_a & delayed_b;
endmodule
6. 实际应用案例
6.1 全加器实现
module full_adder(
input wire A, B, Cin,
output wire Sum, Cout
);
// 使用连续赋值实现全加器逻辑
assign Sum = A ^ B ^ Cin; // 异或实现和
assign Cout = (A & B) | (Cin & (A ^ B)); // 进位逻辑
// 等价的布尔表达式
// assign Cout = (A & B) | (A & Cin) | (B & Cin);
endmodule
真值表验证:
| A | B | Cin | Sum | Cout |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 1 | 0 |
| 0 | 1 | 0 | 1 | 0 |
| 0 | 1 | 1 | 0 | 1 |
| 1 | 0 | 0 | 1 | 0 |
| 1 | 0 | 1 | 0 | 1 |
| 1 | 1 | 0 | 0 | 1 |
| 1 | 1 | 1 | 1 | 1 |
6.2 4位行波进位加法器
module ripple_carry_adder_4bit(
input wire [3:0] A, B,
input wire Cin,
output wire [3:0] Sum,
output wire Cout
);
wire C1, C2, C3; // 中间进位信号
// 使用连续赋值实现4个全加器
assign {C1, Sum[0]} = A[0] + B[0] + Cin;
assign {C2, Sum[1]} = A[1] + B[1] + C1;
assign {C3, Sum[2]} = A[2] + B[2] + C2;
assign {Cout, Sum[3]} = A[3] + B[3] + C3;
endmodule
6.3 多路选择器系列
// 2选1多路选择器
module mux_2to1 #(parameter WIDTH = 8)(
input wire [WIDTH-1:0] data0, data1,
input wire sel,
output wire [WIDTH-1:0] out
);
assign out = sel ? data1 : data0;
endmodule
// 4选1多路选择器
module mux_4to1 #(parameter WIDTH = 8)(
input wire [WIDTH-1:0] data0, data1, data2, data3,
input wire [1:0] sel,
output wire [WIDTH-1:0] out
);
assign out = (sel == 2'b00) ? data0 :
(sel == 2'b01) ? data1 :
(sel == 2'b10) ? data2 :
data3;
endmodule
// 8选1多路选择器
module mux_8to1 #(parameter WIDTH = 8)(
input wire [WIDTH-1:0] data [0:7],
input wire [2:0] sel,
output wire [WIDTH-1:0] out
);
assign out = data[sel]; // 简洁的数组索引方式
endmodule
6.4 译码器设计
// 3-8译码器
module decoder_3to8(
input wire [2:0] addr,
input wire enable,
output wire [7:0] out
);
// 使用条件表达式实现译码逻辑
assign out[0] = enable & (addr == 3'b000);
assign out[1] = enable & (addr == 3'b001);
assign out[2] = enable & (addr == 3'b010);
assign out[3] = enable & (addr == 3'b011);
assign out[4] = enable & (addr == 3'b100);
assign out[5] = enable & (addr == 3'b101);
assign out[6] = enable & (addr == 3'b110);
assign out[7] = enable & (addr == 3'b111);
// 更简洁的实现方式
// assign out = enable ? (1'b1 << addr) : 8'b0;
endmodule
6.5 优先级编码器
module priority_encoder_8to3(
input wire [7:0] data_in,
output wire [2:0] addr_out,
output wire valid
);
// 优先级编码：高位优先
assign addr_out = data_in[7] ? 3'b111 :
data_in[6] ? 3'b110 :
data_in[5] ? 3'b101 :
data_in[4] ? 3'b100 :
data_in[3] ? 3'b011 :
data_in[2] ? 3'b010 :
data_in[1] ? 3'b001 :
data_in[0] ? 3'b000 : 3'bxxx;
assign valid = |data_in; // 任何位为1则有效
endmodule
6.6 奇偶校验生成器
module parity_generator(
input wire [7:0] data,
output wire even_parity,
output wire odd_parity
);
// 偶校验：使总的1的个数为偶数
assign even_parity = ^data;
// 奇校验：使总的1的个数为奇数
assign odd_parity = ~(^data);
endmodule
7. 最佳实践
7.1 代码组织原则
7.1.1 逻辑分组
module good_organization(
input wire [7:0] a, b, c,
input wire [2:0] ctrl,
output wire [7:0] result,
output wire [2:0] status
);
// === 中间信号声明 ===
wire [7:0] sum, diff, product;
wire overflow, underflow, zero;
// === 算术运算组 ===
assign sum = a + b;
assign diff = a - b;
assign product = a * c;
// === 状态检测组 ===
assign overflow = (sum < a) | (sum < b); // 加法溢出检测
assign underflow = (a < b) & (diff > a); // 减法下溢检测
assign zero = (result == 8'h00); // 零检测
// === 输出选择组 ===
assign result = (ctrl[1:0] == 2'b00) ? sum :
(ctrl[1:0] == 2'b01) ? diff :
(ctrl[1:0] == 2'b10) ? product :
8'h00;
assign status = {overflow, underflow, zero};
endmodule
7.1.2 命名规范
module naming_convention(
input wire clk, // 时钟信号
input wire rst_n, // 低有效复位
input wire [7:0] data_in, // 输入数据
input wire valid_in, // 输入有效信号
output wire [7:0] data_out, // 输出数据
output wire valid_out, // 输出有效信号
output wire error_flag // 错误标志
);
// 中间信号使用有意义的名称
wire [7:0] processed_data; // 处理后的数据
wire parity_error; // 校验错误
wire data_ready; // 数据就绪
// 功能相关的连续赋值
assign processed_data = data_in ^ 8'hAA; // 数据处理
assign parity_error = ^data_in; // 奇偶校验
assign data_ready = valid_in & ~parity_error; // 就绪条件
// 输出信号赋值
assign data_out = data_ready ? processed_data : 8'h00;
assign valid_out = data_ready;
assign error_flag = parity_error;
endmodule
7.2 性能优化技巧
7.2.1 减少关键路径延时
// ❌ 不好：长的组合逻辑链
assign long_path = ((((a & b) | c) & d) | e) & f;
// ✅ 更好：使用中间信号分段
wire stage1, stage2;
assign stage1 = (a & b) | c;
assign stage2 = (stage1 & d) | e;
assign short_path = stage2 & f;
7.2.2 避免不必要的计算
module optimization_example(
input wire [7:0] a, b,
input wire enable,
output wire [7:0] result
);
// ❌ 不好：总是计算，浪费功耗
wire [7:0] sum = a + b;
assign result = enable ? sum : 8'h00;
// ✅ 更好：条件计算
assign result = enable ? (a + b) : 8'h00;
endmodule
7.3 可读性提升
7.3.1 使用参数化设计
module parameterized_mux #(
parameter DATA_WIDTH = 8,
parameter SEL_WIDTH = 2,
parameter NUM_INPUTS = 2**SEL_WIDTH
)(
input wire [DATA_WIDTH-1:0] data_in [0:NUM_INPUTS-1],
input wire [SEL_WIDTH-1:0] sel,
output wire [DATA_WIDTH-1:0] data_out
);
assign data_out = data_in[sel];
endmodule
7.3.2 添加详细注释
module well_commented_alu(
input wire [7:0] operand_a, // 操作数A
input wire [7:0] operand_b, // 操作数B
input wire [2:0] op_code, // 操作码：000=ADD, 001=SUB, 010=AND...
output wire [7:0] result, // 运算结果
output wire zero_flag, // 零标志位
output wire carry_flag // 进位标志位
);
// 内部计算信号
wire [8:0] add_result; // 9位加法结果（含进位）
wire [7:0] sub_result; // 减法结果
wire [7:0] and_result; // 逻辑与结果
wire [7:0] or_result; // 逻辑或结果
// === 各种运算实现 ===
assign add_result = operand_a + operand_b; // 加法运算
assign sub_result = operand_a - operand_b; // 减法运算
assign and_result = operand_a & operand_b; // 按位与
assign or_result = operand_a | operand_b; // 按位或
// === 结果选择 ===
assign result = (op_code == 3'b000) ? add_result[7:0] : // 加法
(op_code == 3'b001) ? sub_result : // 减法
(op_code == 3'b010) ? and_result : // 与
(op_code == 3'b011) ? or_result : // 或
8'h00; // 默认
// === 标志位生成 ===
assign zero_flag = (result == 8'h00); // 结果为零标志
assign carry_flag = (op_code == 3'b000) ? add_result[8] : 1'b0; // 进位标志
endmodule
8. 常见错误与调试
8.1 语法错误类型
8.1.1 赋值目标错误
// ❌ 错误示例
reg [7:0] register_var;
integer int_var;
assign register_var = data_in; // 错误：不能赋值给reg类型
assign int_var = count; // 错误：不能赋值给integer
// ✅ 正确方法
wire [7:0] wire_var;
assign wire_var = data_in; // 正确：赋值给wire类型
8.1.2 位宽不匹配
// ❌ 容易出错的位宽匹配
wire [7:0] wide_signal;
wire [3:0] narrow_signal;
assign wide_signal = narrow_signal; // 隐式扩展，可能不是期望的
// ✅ 明确的位宽处理
assign wide_signal = {4'b0000, narrow_signal}; // 显式零扩展
assign wide_signal = {{4{narrow_signal[3]}}, narrow_signal}; // 符号扩展
8.1.3 多驱动冲突
// ❌ 错误：多个驱动源
wire conflict_wire;
assign conflict_wire = source1;
assign conflict_wire = source2; // 冲突！
// ✅ 正确：使用三态或选择逻辑
assign conflict_wire = enable1 ? source1 : 1'bz;
assign conflict_wire = enable2 ? source2 : 1'bz;
// 或者使用多路选择
assign conflict_wire = select ? source1 : source2;
8.2 逻辑错误诊断
8.2.1 优先级错误
// ❌ 可能的优先级错误
assign result = a & b | c & d; // 可能不是期望的优先级
// ✅ 明确的优先级
assign result = (a & b) | (c & d); // 清晰的逻辑分组
8.2.2 条件表达式错误
// ❌ 不完整的条件覆盖
assign output = (sel == 2'b00) ? input0 :
(sel == 2'b01) ? input1 :
(sel == 2'b10) ? input2; // 缺少sel==2'b11的情况
// ✅ 完整的条件覆盖
assign output = (sel == 2'b00) ? input0 :
(sel == 2'b01) ? input1 :
(sel == 2'b10) ? input2 :
input3; // 包含所有情况
8.3 调试技巧
8.3.1 添加调试信号
module debug_example(
input wire [7:0] a, b,
input wire [1:0] op,
output wire [7:0] result
);
// 调试信号：中间计算结果
wire [7:0] add_temp, sub_temp, and_temp, or_temp;
assign add_temp = a + b;
assign sub_temp = a - b;
assign and_temp = a & b;
assign or_temp = a | b;
// 主要逻辑
assign result = (op == 2'b00) ? add_temp :
(op == 2'b01) ? sub_temp :
(op == 2'b10) ? and_temp :
or_temp;
// 调试信息输出（仿真时使用）
`ifdef DEBUG
always @(*) begin
$display("Time=%0t: a=%h, b=%h, op=%b", $time, a, b, op);
$display(" add=%h, sub=%h, and=%h, or=%h",
add_temp, sub_temp, and_temp, or_temp);
$display(" result=%h", result);
end
`endif
endmodule
8.3.2 分段验证
module step_by_step_debug(
input wire [3:0] a, b, c,
output wire [3:0] final_result
);
// 分步骤验证中间结果
wire [3:0] step1, step2, step3;
assign step1 = a & b; // 第一步：与运算
assign step2 = step1 | c; // 第二步：或运算
assign step3 = ~step2; // 第三步：取反
assign final_result = step3; // 最终结果
// 每个步骤都可以独立验证
endmodule
9. 与其他赋值方式的比较
9.1 连续赋值 vs 过程赋值
| 特性 | 连续赋值 (assign) | 阻塞赋值 (=) | 非阻塞赋值 (<=) |
|---|---|---|---|
| 使用位置 | 模块内部 | always块内 | always块内 |
| 目标类型 | wire类型 | reg类型 | reg类型 |
| 执行方式 | 并行，连续 | 顺序，瞬时 | 并行，延迟 |
| 应用场景 | 组合逻辑 | 组合逻辑 | 时序逻辑 |
| 综合结果 | 组合电路 | 组合电路 | 时序电路 |
9.2 代码对比示例
9.2.1 组合逻辑实现对比
// 方法1：连续赋值（推荐用于纯组合逻辑）
module combo_assign(
input wire a, b, c,
output wire result
);
assign result = (a & b) | c;
endmodule
// 方法2：过程赋值
module combo_always(
input wire a, b, c,
output reg result
);
always @(*) begin
result = (a & b) | c;
end
endmodule
9.2.2 复杂组合逻辑对比
// 连续赋值版本：简洁直观
module mux_assign(
input wire [7:0] data0, data1, data2, data3,
input wire [1:0] sel,
output wire [7:0] out
);
assign out = (sel == 2'b00) ? data0 :
(sel == 2'b01) ? data1 :
(sel == 2'b10) ? data2 :
data3;
endmodule
// 过程赋值版本：更多控制
module mux_always(
input wire [7:0] data0, data1, data2, data3,
input wire [1:0] sel,
output reg [7:0] out
);
always @(*) begin
case (sel)
2'b00: out = data0;
2'b01: out = data1;
2'b10: out = data2;
2'b11: out = data3;
default: out = 8'hxx; // 可以明确指定默认值
endcase
end
endmodule
9.3 选择原则
9.3.1 使用连续赋值的场景
- ✅ 简单的组合逻辑
- ✅ 数据流建模
- ✅ 接口信号连接
- ✅ 位操作和拼接
- ✅ 条件表达式
9.3.2 使用过程赋值的场景
- ✅ 复杂的组合逻辑
- ✅ 需要case语句的场合
- ✅ 时序逻辑设计
- ✅ 需要局部变量的算法
- ✅ 复杂的控制流程
10. 进阶主题
10.1 强制和释放
10.1.1 基本概念
module force_release_demo;
wire a, b, y;
reg test_a, test_b;
assign a = test_a;
assign b = test_b;
assign y = a & b;
initial begin
test_a = 0; test_b = 0;
#10;
// 强制信号为特定值（用于测试）
force y = 1'b1;
#10;
// 释放强制，恢复正常连接
release y;
#10;
$finish;
end
endmodule
10.2 分辨率函数
10.2.1 多驱动源处理
// 用户定义的分辨率函数
`include "resolution_functions.v"
module multi_driver_example;
wire resolved_signal;
// 多个驱动源
assign resolved_signal = driver1_enable ? driver1_value : 1'bz;
assign resolved_signal = driver2_enable ? driver2_value : 1'bz;
assign resolved_signal = driver3_enable ? driver3_value : 1'bz;
// Verilog的默认分辨率函数处理冲突
endmodule
10.3 门级建模与连续赋值
10.3.1 等价转换
// 连续赋值实现
assign y1 = a & b;
assign y2 = c | d;
assign y3 = ~e;
// 等价的门级实现
and gate1(y1, a, b);
or gate2(y2, c, d);
not gate3(y3, e);
10.4 综合注意事项
10.4.1 可综合性检查
module synthesis_friendly(
input wire clk, rst_n,
input wire [7:0] data_in,
output wire [7:0] data_out
);
// ✅ 可综合的连续赋值
assign data_out = data_in ^ 8'hAA;
// ❌ 不可综合的延时
// assign #5 data_out = data_in;
// ❌ 不可综合的实数运算
// real voltage = 3.3;
// assign analog_out = voltage * data_in;
endmodule
10.4.2 资源使用优化
module resource_optimization(
input wire [31:0] a, b,
input wire sel,
output wire [31:0] result
);
// ✅ 资源友好：避免大的多路选择器
assign result = sel ? a : b;
// ❌ 资源消耗大：复杂的算术运算
// assign result = sel ? (a * b + a) : (a + b * 2);
// ✅ 更好的方法：分解复杂运算
wire [31:0] product, sum1, sum2;
assign product = a * b;
assign sum1 = product + a;
assign sum2 = a + (b << 1); // 乘2用移位代替
assign result = sel ? sum1 : sum2;
endmodule
🎯 总结
核心要点
- 连续赋值是Verilog数据流建模的基础，适用于组合逻辑设计
- 实时响应特性使其非常适合描述硬件的并行行为
- 只能驱动wire类型信号，不能用于reg类型
- 表达式可以很复杂，支持算术、逻辑、关系和条件运算
- 时延控制主要用于仿真，通常不可综合
浙公网安备 33010602011771号