FPGA 实现 CAN 总线：原理与 Verilog 代码详解

二、FPGA 实现 CAN 的核心模块

FPGA 实现 CAN 接口需拆解为物理层接口、位时序模块、发送模块、接收模块、错误处理模块、控制模块，再通过顶层模块整合：

1. 物理层接口：连接 CAN 收发器（TJA1050），处理 TX/RX 信号；
2. 位时序模块：生成 CAN 位时间的 TQ 时钟，实现位同步和相位调整；
3. 发送模块：构建 CAN 帧（标准数据帧），实现位填充、CRC 计算、仲裁逻辑；
4. 接收模块：解析 CAN 帧，实现位同步、位填充解除、CRC 校验、应答检测；
5. 错误处理模块：检测总线错误，发送错误帧，管理节点错误状态；
6. 控制模块：协调各模块工作，提供外部配置接口（如波特率、ID、数据长度等）。

三、Verilog 代码实现（以 50MHz 时钟、500kHz 波特率为例）

这里我们基于 50MHz 系统时钟设计，为了保证分频精度，选择 500kHz 波特率，每位包含 10 个 TQ。

1. 全局参数定义

首先定义系统时钟、波特率及帧结构相关的参数，方便后续修改。

// 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;

2. 位时序模块（CAN Bit Timing Generator）

这个模块负责生成 TQ 时钟（位时间的最小单位），并实现位同步和相位调整。注意这里的分频系数计算，确保 TQ 时钟是整数倍关系。

module can_bit_timing(
    input logic clk,              // 系统时钟（50MHz）
    input logic rst_n,            // 复位信号（低电平有效）
    input logic can_rx,           // CAN 接收信号（来自收发器）
    output logic tq_clk,          // TQ 时钟（1TQ=200ns，500kHz*10=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;   // 同步检测标志
    logic can_rx_prev = 1'b1;     // 上一拍 RX 值

    // 生成 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 == 9) begin // DIVISOR = 50e6 / 5e6 = 10
                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

    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

3. CRC 计算模块（CAN CRC Generator）

功能：计算 CAN 帧（从 SOF 到数据场）的 15 位 CRC 校验码。CAN 使用的多项式是 x^15 + x^14 + x^10 + x^8 + x^7 + x^4 + x^3 + 1。

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;

    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 计算逻辑
            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

4. 发送模块（CAN Transmitter）

功能：构建标准数据帧，实现位填充、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;       // 填充位
    logic stuff_bit_prev = 1'b1;  // 上一拍填充位

    // 实例化 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;
                        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;
                        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

    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

5. 接收模块（CAN Receiver）

功能：解析 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;       // 填充位标志
    logic stuff_bit_prev = 1'b1;  // 上一拍 RX 值

    // 实例化 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_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

    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

6. 顶层模块（CAN Top Module）

功能：整合位时序、发送、接收模块，提供与 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

四、硬件验证

1. 硬件连接

• FPGA ↔ CAN 收发器（TJA1050）：
  • FPGA 的 can_tx → TJA1050 的 TXD；
  • FPGA 的 can_rx → TJA1050 的 RXD；
  • FPGA 的 VCC（3.3V）→ TJA1050 的 VCC；
  • FPGA 的 GND → TJA1050 的 GND；
• CAN 收发器 ↔ CAN 总线：
  • TJA1050 的 CAN_H → CAN 总线 CAN_H；
  • TJA1050 的 CAN_L → CAN 总线 CAN_L；
  • CAN 总线两端接 120Ω 终端电阻；
• 其他：FPGA 需提供 50MHz 时钟和复位信号（可通过按键或外部电路实现）。

2. 验证步骤

1. 参数配置：通过 FPGA 的配置接口（如 JTAG）设置发送参数（ID=0x001，DLC=2，数据 = 0x1234，波特率 = 500kHz）；
2. 发送数据：触发 tx_en 信号，FPGA 生成 CAN 标准数据帧并发送到总线；
3. 接收验证：
   • 若总线上有其他 CAN 节点（如 CANoe 仿真节点、另一块 FPGA 开发板），可接收并解析该帧，验证 ID、数据、DLC 是否正确；
   • 若只有一块 FPGA，可将 can_tx 直接连接到 can_rx（回环测试），FPGA 接收自己发送的数据，通过 rx_done 和 rx_data 确认接收正确；
4. 错误测试：故意修改发送数据，验证 rx_error 是否能检测到 CRC 错误。

五、关键注意事项与扩展功能

1. 注意事项

• 时序精确性：CAN 位时序对传输可靠性至关重要，需严格按照协议规范设计 TQ 时钟和位段划分，避免非整数分频导致的时序误差；
• 位填充与解除：发送时需正确插入填充位，接收时需准确解除填充，否则会导致帧解析错误；
• 仲裁机制：多节点通信时，需确保仲裁逻辑正确，避免总线冲突；
• 收发器匹配：CAN 收发器的电平需与 FPGA 的 IO 电平匹配（通常为 3.3V），否则需添加电平转换电路；
• 终端电阻：CAN 总线必须接终端电阻，否则信号反射会导致通信失败。

2. 扩展功能

• 扩展帧支持：在帧结构中添加 29 位扩展 ID，修改仲裁场和控制场的处理逻辑；
• 多帧发送 / 接收：添加 FIFO 缓冲区，支持连续多帧数据的收发，避免数据丢失；
• ID 过滤：接收模块添加 ID 过滤逻辑，只接收特定 ID 的帧，减少无效数据处理；
• 错误管理：完善错误处理模块，支持错误计数器管理和总线关闭恢复；
• 波特率自适应：设计波特率检测逻辑，支持自动识别总线波特率。

六、总结

FPGA 实现 CAN 接口的核心是严格遵循 CAN 协议的时序和帧结构，通过硬件逻辑实现位时序生成、帧构建与解析、仲裁、错误处理等功能。相比单片机的 CAN 控制器，FPGA 的硬件实现具有实时性强、可定制性高、并行处理能力强的优势，适用于对通信速率和可靠性要求较高的场景。实际应用中，可根据需求扩展扩展帧、ID 过滤、多帧收发等功能，适配复杂的 CAN 总线系统。