介绍 FPGA 实现 CAN 总线的原理与 Verilog 代码。涵盖物理层差分信号、协议层帧结构与仲裁机制。核心模块包括位时序生成、CRC 计算、发送与接收逻辑。提供基于 50MHz 时钟的 Verilog 实现示例，含全局参数定义及顶层模块整合。最后说明硬件连接（TJA1050）与验证步骤，强调时序精确性与终端电阻的重要性，适用于高实时性通信场景。
CAN（Controller Area Network，控制器局域网）是一种，核心特点是，广泛应用于汽车电子、工业控制、智能家居等领域。FPGA 实现 CAN 接口的核心是通过模拟 CAN 协议的，再配合 CAN 收发器（如 TJA1050）实现物理层连接。以下从四方面详细说明：
CAN 的位时间由**多个时间量子（TQ）**组成，标准位时序划分（以 500kHz 波特率为例）：
CAN 帧分为数据帧、远程帧、错误帧、过载帧，最常用的是标准数据帧，结构如下：
| 字段 | 长度（位） | 描述 |
|---|---|---|
| 帧起始（SOF） | 1 | 显性电平（0），标志帧开始； |
| 仲裁场 | 11+1 | 11 位标准 ID（优先级：ID 越小优先级越高）+ RTR 位（0 = 数据帧，1 = 远程帧）； |
| 控制场 | 6 | IDE 位（0 = 标准帧，1 = 扩展帧）+ R0 位（保留）+ 4 位 DLC（数据长度 0~8）； |
| 数据场 | 0~64 | 数据长度由 DLC 决定（1 字节 = 8 位）； |
| CRC 场 | 15+1 | 15 位 CRC 校验码 + 1 位 CRC 界定符（隐性电平）； |
| ACK 场 | 2 | 1 位 ACK 位（接收方拉低为应答）+ 1 位 ACK 界定符（隐性电平）； |
| 帧结束（EOF） | 7 | 7 位隐性电平，标志帧结束。 |
FPGA 实现 CAN 接口需拆解为物理层接口、位时序模块、发送模块、接收模块、错误处理模块、控制模块，再通过顶层模块整合：
// CAN 参数配置
parameter CLK_FREQ = 50_000_000; // 系统时钟频率（50MHz）
parameter CAN_BAUD = 500_000; // CAN 目标波特率（500kHz）
parameter TQ_COUNT = 10; // 每位包含的 TQ 数量（10TQ/位，2μs/位）
parameter SYNC_SEG = 1; // 同步段（1TQ）
parameter PROP_SEG = 3; // 传播段（3TQ）
parameter PHASE_SEG1 = 3; // 相位缓冲段 1（3TQ）
parameter PHASE_SEG2 = 3; // 相位缓冲段 2（3TQ）
parameter SJW = 2; // 重同步跳转宽度（2TQ）
// CAN 帧字段参数
parameter STD_ID_LEN = 11; // 标准 ID 长度（11 位）
parameter DLC_LEN = 4; // DLC 长度（4 位）
parameter DATA_MAX_LEN = 8; // 最大数据长度（8 字节）
parameter CRC_LEN = 15; // CRC 长度（15 位）
// 状态定义
typedef enum {IDLE, SYNC, ARBITRATION, CONTROL, DATA, CRC, ACK, EOF} can_state_t;
功能：生成 TQ 时钟（位时间的最小单位），实现位同步和相位调整。
module can_bit_timing(
input logic clk, // 系统时钟（50MHz）
input logic rst_n, // 复位信号（低电平有效）
input logic can_rx, // CAN 接收信号（来自收发器）
output logic tq_clk, // TQ 时钟（5MHz）
output logic sync_seg, // 同步段标志
output logic prop_seg, // 传播段标志
output logic phase_seg1, // 相位缓冲段 1 标志
output logic phase_seg2, // 相位缓冲段 2 标志
output logic bit_start, // 位开始标志
output logic bit_end // 位结束标志
);
logic [3:0] tq_cnt = 4'd0; // TQ 计数器（0~TQ_COUNT-1）
logic [3:0] bit_cnt = 4'd0; // 位计数器（0~TQ_COUNT-1）
logic sync_detected = 1'b0; // 同步检测标志
// 生成 TQ 时钟（5MHz）
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
tq_cnt <= 4'd0;
tq_clk <= 1'b0;
end else begin
if (tq_cnt == DIVISOR/2 - 1) begin // 50% 占空比
tq_clk <= ~tq_clk;
tq_cnt <= tq_cnt + 1'b1;
end else if (tq_cnt == DIVISOR - 1) begin
tq_clk <= ~tq_clk;
tq_cnt <= 4'd0;
end else begin
tq_cnt <= tq_cnt + 1'b1;
end
end
end
// 位时序分段
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
bit_cnt <= 4'd0;
sync_seg <= 1'b0;
prop_seg <= 1'b0;
phase_seg1 <= 1'b0;
phase_seg2 <= 1'b0;
bit_start <= 1'b0;
bit_end <= 1'b0;
sync_detected <= 1'b0;
end else begin
// 同步检测（检测 CAN_RX 电平跳变）
if (can_rx != can_rx_prev) begin
sync_detected <= 1'b1;
bit_cnt <= 4'd0; // 同步时重置位计数器
end
// 位计数器递增
if (bit_cnt == TQ_COUNT - 1) begin
bit_cnt <= 4'd0;
bit_end <= 1'b1;
end else begin
bit_cnt <= bit_cnt + 1'b1;
bit_end <= 1'b0;
end
// 时序分段标志
sync_seg <= (bit_cnt < SYNC_SEG) ? 1'b1 : 1'b0;
prop_seg <= (bit_cnt >= SYNC_SEG && bit_cnt < SYNC_SEG + PROP_SEG) ? 1'b1 : 1'b0;
phase_seg1 <= (bit_cnt >= SYNC_SEG + PROP_SEG && bit_cnt < SYNC_SEG + PROP_SEG + PHASE_SEG1) ? 1'b1 : 1'b0;
phase_seg2 <= (bit_cnt >= SYNC_SEG + PROP_SEG + PHASE_SEG1 && bit_cnt < TQ_COUNT) ? 1'b1 : 1'b0;
// 位开始标志（同步段开始时）
bit_start <= (bit_cnt == 4'd0) ? 1'b1 : 1'b0;
// 同步检测标志清零
if (sync_seg) begin
sync_detected <= 1'b0;
end
end
end
logic can_rx_prev;
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
can_rx_prev <= 1'b1; // CAN 空闲时为隐性电平（1）
end else begin
can_rx_prev <= can_rx;
end
end
endmodule
功能：计算 CAN 帧（从 SOF 到数据场）的 15 位 CRC 校验码。
module can_crc(
input logic clk, // 系统时钟（50MHz）
input logic rst_n, // 复位信号（低电平有效）
input logic crc_en, // CRC 计算使能
input logic data_bit, // 输入数据位
output logic [CRC_LEN-1:0] crc_out, // CRC 输出
output logic crc_done // CRC 计算完成
);
logic [CRC_LEN:0] crc_reg = {CRC_LEN+1{1'b1}}; // CRC 初始值为全 1
logic [3:0] bit_cnt = 4'd0;
logic total_bits; // 需计算 CRC 的总位数（SOF(1) + ID(11) + RTR(1) + IDE(1) + R0(1) + DLC(4) + 数据位 (8*DLC)）
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
crc_reg <= {CRC_LEN+1{1'b1}};
bit_cnt <= 4'd0;
crc_done <= 1'b0;
end else if (crc_en) begin
// CRC 计算逻辑（CAN CRC-15 多项式：x^15 + x^14 + x^10 + x^8 + x^7 + x^4 + x^3 + 1）
crc_reg[0] <= data_bit ^ crc_reg[CRC_LEN];
crc_reg[1] <= crc_reg[0];
crc_reg[2] <= crc_reg[1];
crc_reg[3] <= crc_reg[2] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[4] <= crc_reg[3] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[5] <= crc_reg[4];
crc_reg[6] <= crc_reg[5];
crc_reg[7] <= crc_reg[6] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[8] <= crc_reg[7] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[9] <= crc_reg[8];
crc_reg[10] <= crc_reg[9] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[11] <= crc_reg[10];
crc_reg[12] <= crc_reg[11];
crc_reg[13] <= crc_reg[12];
crc_reg[14] <= crc_reg[13] ^ data_bit ^ crc_reg[CRC_LEN];
crc_reg[15] <= crc_reg[14] ^ data_bit ^ crc_reg[CRC_LEN];
// 计数到总位数后完成
if (bit_cnt == total_bits - 1) begin
crc_done <= 1'b1;
bit_cnt <= 4'd0;
end else begin
bit_cnt <= bit_cnt + 1'b1;
crc_done <= 1'b0;
end
end else begin
crc_done <= 1'b0;
end
end
// 计算需 CRC 的总位数（标准数据帧）
always_comb begin
total_bits = 1 + STD_ID_LEN + 1 + 1 + 1 + DLC_LEN + (8 * dlc); // SOF + ID + RTR + IDE + R0 + DLC + 数据
end
input logic [DLC_LEN-1:0] dlc; // 数据长度（来自控制模块）
endmodule
功能：构建标准数据帧，实现位填充、CRC 计算、仲裁逻辑。
module can_transmitter(
input logic clk, // 系统时钟（50MHz）
input logic rst_n, // 复位信号（低电平有效）
input logic tq_clk, // TQ 时钟
input logic sync_seg, // 同步段标志
input logic phase_seg1, // 相位缓冲段 1 标志
input logic phase_seg2, // 相位缓冲段 2 标志
input logic bit_end, // 位结束标志
input logic can_rx, // CAN 接收信号（用于仲裁）
input logic tx_en, // 发送使能
input logic [STD_ID_LEN-1:0] std_id, // 标准 ID
input logic rtr, // 远程帧请求（0=数据帧，1=远程帧）
input logic [DLC_LEN-1:0] dlc, // 数据长度
input logic [DATA_MAX_LEN*8-1:0] data,// 发送数据
output logic can_tx, // CAN 发送信号（到收发器）
output logic tx_done, // 发送完成标志
output logic tx_error // 发送错误标志
);
can_state_t state = IDLE;
logic [3:0] bit_cnt = 4'd0; // 字段内位计数器
logic [7:0] data_byte = 8'd0; // 当前发送的数据字节
logic [CRC_LEN-1:0] crc_val; // CRC 值
logic crc_en; // CRC 使能
logic crc_done; // CRC 完成
logic [5:0] stuff_cnt = 6'd0; // 位填充计数器
logic stuff_bit = 1'b0; // 填充位
// 实例化 CRC 模块
can_crc u_crc(
.clk(clk),
.rst_n(rst_n),
.crc_en(crc_en),
.data_bit(data_bit),
.crc_out(crc_val),
.crc_done(crc_done),
.dlc(dlc)
);
// 状态机控制
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
state <= IDLE;
bit_cnt <= 4'd0;
data_byte <= 8'd0;
can_tx <= 1'b1; // 空闲时为隐性电平（1）
tx_done <= 1'b0;
tx_error <= 1'b0;
stuff_cnt <= 6'd0;
stuff_bit <= 1'b0;
crc_en <= 1'b0;
end else begin
case (state)
IDLE: begin
tx_done <= 1'b0;
tx_error <= 1'b0;
stuff_cnt <= 6'd0;
if (tx_en) begin
state <= SYNC;
bit_cnt <= 4'd0; // 准备发送 SOF（显性电平 0）
can_tx <= 1'b0; // 启动 CRC 计算（SOF 为第一个数据位）
crc_en <= 1'b1;
data_bit <= 1'b0;
end else begin
can_tx <= 1'b1;
end
end
SYNC: begin
if (bit_end) begin
state <= ARBITRATION;
bit_cnt <= 4'd0; // 发送 ID 的最高位
can_tx <= std_id[STD_ID_LEN-1 - bit_cnt];
data_bit <= std_id[STD_ID_LEN-1 - bit_cnt];
// 仲裁：检测总线电平是否与发送电平一致
if (can_rx != can_tx) begin
// 仲裁失败，转为接收
state <= IDLE;
tx_error <= 1'b1;
end
end else begin
// 位填充检测
if (can_tx == stuff_bit_prev) begin
stuff_cnt <= stuff_cnt + 1'b1;
if (stuff_cnt == 5'd5) begin
// 连续 5 个相同电平，插入填充位（相反电平）
can_tx <= ~can_tx;
stuff_cnt <= 6'd0;
stuff_bit <= 1'b1;
crc_en <= 1'b0; // 填充位不参与 CRC
end
end else begin
stuff_cnt <= 6'd0;
stuff_bit <= 1'b0;
crc_en <= 1'b1;
end
end
end
// 后续状态（ARBITRATION、CONTROL、DATA、CRC、ACK、EOF）类似，按帧结构发送对应字段
// 此处省略详细状态跳转，核心逻辑：按帧字段顺序发送，位填充，仲裁检测，CRC 计算
// ...
EOF: begin
if (bit_end) begin
state <= IDLE;
tx_done <= 1'b1;
end
end
default: state <= IDLE;
endcase
end
end
logic stuff_bit_prev;
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
stuff_bit_prev <= 1'b1;
end else begin
stuff_bit_prev <= can_tx;
end
end
logic data_bit; // 输入到 CRC 的数据位
always_comb begin
case (state)
SYNC: data_bit <= 1'b0; // SOF
ARBITRATION: data_bit <= std_id[STD_ID_LEN-1 - bit_cnt]; // ID 位
CONTROL: data_bit <= (bit_cnt == 0) ? 1'b0 : (bit_cnt == 1) ? 1'b0 : (bit_cnt >= 2 && bit_cnt < 2+DLC_LEN) ? dlc[DLC_LEN-1 - (bit_cnt-2)] : 1'b0; // IDE=0，R0=0，DLC 位
DATA: data_bit <= data_byte[7 - (bit_cnt % 8)]; // 数据位
default: data_bit <= 1'b0;
endcase
end
endmodule
功能：解析 CAN 帧，实现位同步、位填充解除、CRC 校验、应答检测。
module can_receiver(
input logic clk, // 系统时钟（50MHz）
input logic rst_n, // 复位信号（低电平有效）
input logic tq_clk, // TQ 时钟
input logic sync_seg, // 同步段标志
input logic phase_seg1, // 相位缓冲段 1 标志
input logic phase_seg2, // 相位缓冲段 2 标志
input logic bit_end, // 位结束标志
input logic can_rx, // CAN 接收信号（来自收发器）
output logic rx_done, // 接收完成标志
output logic rx_error, // 接收错误标志
output logic [STD_ID_LEN-1:0] rx_std_id, // 接收标准 ID
output logic rx_rtr, // 接收 RTR 位
output logic [DLC_LEN-1:0] rx_dlc, // 接收 DLC
output logic [DATA_MAX_LEN*8-1:0] rx_data // 接收数据
);
can_state_t state = IDLE;
logic [3:0] bit_cnt = 4'd0; // 字段内位计数器
logic [7:0] data_byte = 8'd0; // 当前接收的数据字节
logic [CRC_LEN-1:0] crc_val; // 接收的 CRC 值
logic [CRC_LEN-1:0] calc_crc; // 计算的 CRC 值
logic crc_en; // CRC 计算使能
logic crc_done; // CRC 完成
logic [5:0] stuff_cnt = 6'd0; // 位填充计数器
logic stuff_bit = 1'b0; // 填充位标志
// 实例化 CRC 模块（用于校验）
can_crc u_crc(
.clk(clk),
.rst_n(rst_n),
.crc_en(crc_en),
.data_bit(can_rx),
.crc_out(calc_crc),
.crc_done(crc_done),
.dlc(rx_dlc)
);
// 状态机控制
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
state <= IDLE;
bit_cnt <= 4'd0;
data_byte <= 8'd0;
rx_done <= 1'b0;
rx_error <= 1'b0;
rx_std_id <= {STD_ID_LEN{1'b0}};
rx_rtr <= 1'b0;
rx_dlc <= {DLC_LEN{1'b0}};
rx_data <= {DATA_MAX_LEN*8{1'b0}};
stuff_cnt <= 6'd0;
stuff_bit <= 1'b0;
crc_en <= 1'b0;
end else begin
case (state)
IDLE: begin
rx_done <= 1'b0;
rx_error <= 1'b0;
stuff_cnt <= 6'd0;
// 检测 SOF（显性电平 0）
if (can_rx == 1'b0 && sync_seg) begin
state <= SYNC;
bit_cnt <= 4'd0; // 启动 CRC 计算（SOF 为第一个数据位）
crc_en <= 1'b1;
end
end
SYNC: begin
if (bit_end) begin
state <= ARBITRATION;
bit_cnt <= 4'd0;
end
// 位填充解除：检测连续 5 个相同电平，跳过第 6 个填充位
if (can_rx == stuff_bit_prev) begin
stuff_cnt <= stuff_cnt + 1'b1;
if (stuff_cnt == 5'd5) begin
stuff_bit <= 1'b1; // 标记填充位，下一位跳过
stuff_cnt <= 6'd0;
end
end else begin
stuff_cnt <= 6'd0;
stuff_bit <= 1'b0;
end
end
ARBITRATION: begin
if (bit_end && !stuff_bit) begin
if (bit_cnt == STD_ID_LEN - 1) begin
// 接收完 ID，下一位是 RTR
rx_std_id[STD_ID_LEN-1 - bit_cnt] <= can_rx;
state <= CONTROL;
bit_cnt <= 4'd0;
end else begin
rx_std_id[STD_ID_LEN-1 - bit_cnt] <= can_rx;
bit_cnt <= bit_cnt + 1'b1;
end
end else if (stuff_bit) begin
stuff_bit <= 1'b0; // 跳过填充位
end
// CRC 继续计算（ID 位）
crc_en <= !stuff_bit;
end
// 后续状态（CONTROL、DATA、CRC、ACK、EOF）类似，按帧结构接收对应字段，位填充解除，CRC 校验
// ...
EOF: begin
if (bit_end) begin
state <= IDLE;
rx_done <= 1'b1; // CRC 校验
if (calc_crc != crc_val) begin
rx_error <= 1'b1;
end
end
end
default: state <= IDLE;
endcase
end
end
logic stuff_bit_prev;
always_ff @(posedge tq_clk or negedge rst_n) begin
if (!rst_n) begin
stuff_bit_prev <= 1'b1;
end else begin
stuff_bit_prev <= can_rx;
end
end
endmodule
功能：整合位时序、发送、接收模块，提供与 CAN 收发器的物理接口和外部配置接口。
module can_top(
input logic clk, // 系统时钟（50MHz）
input logic rst_n, // 复位信号（低电平有效）
input logic tx_en, // 发送使能
input logic [STD_ID_LEN-1:0] std_id, // 发送标准 ID
input logic rtr, // 发送 RTR 位
input logic [DLC_LEN-1:0] dlc, // 发送 DLC
input logic [DATA_MAX_LEN*8-1:0] data,// 发送数据
output logic can_tx, // CAN 发送信号（到 TJA1050 TXD）
input logic can_rx, // CAN 接收信号（来自 TJA1050 RXD）
output logic tx_done, // 发送完成标志
output logic tx_error, // 发送错误标志
output logic rx_done, // 接收完成标志
output logic rx_error, // 接收错误标志
output logic [STD_ID_LEN-1:0] rx_std_id, // 接收标准 ID
output logic rx_rtr, // 接收 RTR 位
output logic [DLC_LEN-1:0] rx_dlc, // 接收 DLC
output logic [DATA_MAX_LEN*8-1:0] rx_data // 接收数据
);
// 中间信号
logic tq_clk;
logic sync_seg;
logic prop_seg;
logic phase_seg1;
logic phase_seg2;
logic bit_start;
logic bit_end;
// 实例化位时序模块
can_bit_timing u_bit_timing(
.clk(clk),
.rst_n(rst_n),
.can_rx(can_rx),
.tq_clk(tq_clk),
.sync_seg(sync_seg),
.prop_seg(prop_seg),
.phase_seg1(phase_seg1),
.phase_seg2(phase_seg2),
.bit_start(bit_start),
.bit_end(bit_end)
);
// 实例化发送模块
can_transmitter u_transmitter(
.clk(clk),
.rst_n(rst_n),
.tq_clk(tq_clk),
.sync_seg(sync_seg),
.phase_seg1(phase_seg1),
.phase_seg2(phase_seg2),
.bit_end(bit_end),
.can_rx(can_rx),
.tx_en(tx_en),
.std_id(std_id),
.rtr(rtr),
.dlc(dlc),
.data(data),
.can_tx(can_tx),
.tx_done(tx_done),
.tx_error(tx_error)
);
// 实例化接收模块
can_receiver u_receiver(
.clk(clk),
.rst_n(rst_n),
.tq_clk(tq_clk),
.sync_seg(sync_seg),
.phase_seg1(phase_seg1),
.phase_seg2(phase_seg2),
.bit_end(bit_end),
.can_rx(can_rx),
.rx_done(rx_done),
.rx_error(rx_error),
.rx_std_id(rx_std_id),
.rx_rtr(rx_rtr),
.rx_dlc(rx_dlc),
.rx_data(rx_data)
);
endmodule
can_tx → TJA1050 的 TXD；can_rx → TJA1050 的 RXD；VCC（3.3V）→ TJA1050 的 VCC；GND → TJA1050 的 GND；CAN_H → CAN 总线 CAN_H；CAN_L → CAN 总线 CAN_L；tx_en 信号，FPGA 生成 CAN 标准数据帧并发送到总线；can_tx 直接连接到 can_rx（回环测试），FPGA 接收自己发送的数据，通过 rx_done 和 rx_data 确认接收正确；rx_error 是否能检测到 CRC 错误。FPGA 实现 CAN 接口的核心是严格遵循 CAN 协议的时序和帧结构，通过硬件逻辑实现位时序生成、帧构建与解析、仲裁、错误处理等功能。相比单片机的 CAN 控制器，FPGA 的硬件实现具有实时性强、可定制性高、并行处理能力强的优势，适用于对通信速率和可靠性要求较高的场景。实际应用中，可根据需求扩展扩展帧、ID 过滤、多帧收发等功能，适配复杂的 CAN 总线系统。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online