如何通过Nios V处理器在FPGA上实现数组乘法及数据交互？

整体思路 #

以Nios V作为主机端，FPGA逻辑作为设备端，采用Avalon-MM内存映射总线（Intel FPGA生态下更适配）实现通信，流程类比GPU主机-设备模型：

1. 主机（Nios V）将输入数组写入设备（FPGA）的映射地址空间
2. 主机触发设备运算核启动
3. 设备完成运算后，主机读取结果数组

1. Nios V 数组传递至FPGA的实现 #

核心是通过内存映射地址直接读写FPGA端的存储模块，无需额外通信协议。

FPGA端硬件设计（Verilog） #

FPGA端需要实现Avalon-MM Slave接口、存储数组的寄存器组/双端口RAM，以及地址解码逻辑：

module array_mult_ip (
    // Avalon-MM Slave接口
    input wire        clk,
    input wire        reset_n,
    input wire [31:0] address,
    input wire        write,
    input wire [31:0] writedata,
    input wire [3:0]  byteenable,
    input wire        read,
    output reg [31:0] readdata,
    output reg        readdatavalid,
    // 运算控制信号
    output reg        start,
    input wire        done
);

// 内存映射地址偏移（基地址由Quartus分配，示例为0x10000000）
localparam ADDR_A_BASE = 8'h00;  // A数组起始偏移
localparam ADDR_B_BASE = 8'h20;  // B数组起始偏移（8个32位元素，占32字节）
localparam ADDR_C_BASE = 8'h40;  // C数组起始偏移
localparam ADDR_CTRL   = 8'h60;  // 控制寄存器偏移

// 存储数组（8个32位元素示例）
reg [31:0] A_FPGA [7:0];
reg [31:0] B_FPGA [7:0];
reg [31:0] C_FPGA [7:0];
reg [31:0] ctrl_reg;  // 控制寄存器：bit0=启动位，bit1=完成标志

// Avalon-MM读写逻辑
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        readdata <= 32'h0;
        readdatavalid <= 1'b0;
        start <= 1'b0;
        ctrl_reg <= 32'h0;
    end else begin
        readdatavalid <= 1'b0;
        start <= 1'b0;
        
        // 写操作处理
        if (write) begin
            case(address[7:0])
                ADDR_CTRL: begin
                    ctrl_reg <= writedata;
                    if (writedata[0]) start <= 1'b1;  // 写入启动位触发运算
                end
                default: begin
                    // 写入A数组
                    if (address[7:0] >= ADDR_A_BASE && address[7:0] < ADDR_B_BASE) begin
                        A_FPGA[(address[7:0] - ADDR_A_BASE)/4] <= writedata;
                    end
                    // 写入B数组
                    else if (address[7:0] >= ADDR_B_BASE && address[7:0] < ADDR_C_BASE) begin
                        B_FPGA[(address[7:0] - ADDR_B_BASE)/4] <= writedata;
                    end
                end
            endcase
        end
        
        // 读操作处理
        if (read) begin
            readdatavalid <= 1'b1;
            case(address[7:0])
                ADDR_CTRL: readdata <= ctrl_reg;
                default: begin
                    if (address[7:0] >= ADDR_A_BASE && address[7:0] < ADDR_B_BASE) begin
                        readdata <= A_FPGA[(address[7:0] - ADDR_A_BASE)/4];
                    end else if (address[7:0] >= ADDR_B_BASE && address[7:0] < ADDR_C_BASE) begin
                        readdata <= B_FPGA[(address[7:0] - ADDR_B_BASE)/4];
                    end else if (address[7:0] >= ADDR_C_BASE && address[7:0] < ADDR_CTRL) begin
                        readdata <= C_FPGA[(address[7:0] - ADDR_C_BASE)/4];
                    end
                end
            endcase
        end
        
        // 运算完成后更新标志位
        if (done) begin
            ctrl_reg[1] <= 1'b1;
        end
    end
end

// 数组乘法运算核（组合逻辑示例，实际可改为流水线优化）
reg calc_done;
always @(*) begin
    calc_done = 1'b0;
    for (int i=0; i<8; i++) begin
        C_FPGA[i] = A_FPGA[i] * B_FPGA[i];
    end
    calc_done = 1'b1;
end
assign done = calc_done;

endmodule

Nios V端C代码数据传递 #

通过volatile指针直接访问FPGA的内存映射地址，写入输入数组：

#include <stdint.h>

// FPGA乘法核基地址（需与Quartus分配地址一致）
#define MULT_IP_BASE    0x10000000

// 地址偏移定义（与FPGA端对应）
#define ADDR_A_OFFSET   0x00
#define ADDR_B_OFFSET   0x20
#define ADDR_C_OFFSET   0x40
#define ADDR_CTRL_OFFSET 0x60

// 映射指针定义
volatile uint32_t *mult_ctrl = (volatile uint32_t *)(MULT_IP_BASE + ADDR_CTRL_OFFSET);
volatile uint32_t *mult_A = (volatile uint32_t *)(MULT_IP_BASE + ADDR_A_OFFSET);
volatile uint32_t *mult_B = (volatile uint32_t *)(MULT_IP_BASE + ADDR_B_OFFSET);
volatile uint32_t *mult_C = (volatile uint32_t *)(MULT_IP_BASE + ADDR_C_OFFSET);

int main() {
    uint32_t A[8] = {1,2,3,4,5,6,7,8};
    uint32_t B[8] = {2,3,4,5,6,7,8,9};
    uint32_t C[8];
    
    // 将A、B数组写入FPGA
    for (int i=0; i<8; i++) {
        mult_A[i] = A[i];
        mult_B[i] = B[i];
    }
    
    // 后续运算触发与结果读取见下文
    return 0;
}

2. Nios V 调用FPGA运算函数的实现 #

通过控制寄存器实现运算触发与状态查询，以下为轮询方式（简单易实现）的完整流程：

Nios V端C代码完整实现 #

#include <stdint.h>

// FPGA乘法核基地址（需与Quartus分配地址一致）
#define MULT_IP_BASE    0x10000000

// 地址偏移定义（与FPGA端对应）
#define ADDR_A_OFFSET   0x00
#define ADDR_B_OFFSET   0x20
#define ADDR_C_OFFSET   0x40
#define ADDR_CTRL_OFFSET 0x60

// 控制寄存器位定义
#define CTRL_START_BIT  (1 << 0)
#define CTRL_DONE_BIT   (1 << 1)

// 映射指针定义
volatile uint32_t *mult_ctrl = (volatile uint32_t *)(MULT_IP_BASE + ADDR_CTRL_OFFSET);
volatile uint32_t *mult_A = (volatile uint32_t *)(MULT_IP_BASE + ADDR_A_OFFSET);
volatile uint32_t *mult_B = (volatile uint32_t *)(MULT_IP_BASE + ADDR_B_OFFSET);
volatile uint32_t *mult_C = (volatile uint32_t *)(MULT_IP_BASE + ADDR_C_OFFSET);

int main() {
    uint32_t A[8] = {1,2,3,4,5,6,7,8};
    uint32_t B[8] = {2,3,4,5,6,7,8,9};
    uint32_t C[8];
    
    // 1. 写入输入数组到FPGA
    for (int i=0; i<8; i++) {
        mult_A[i] = A[i];
        mult_B[i] = B[i];
    }
    
    // 2. 触发FPGA运算：写入控制寄存器启动位
    *mult_ctrl = CTRL_START_BIT;
    
    // 3. 轮询等待运算完成
    while (!(*mult_ctrl & CTRL_DONE_BIT));
    
    // 4. 读取结果数组
    for (int i=0; i<8; i++) {
        C[i] = mult_C[i];
    }
    
    // 结果验证（可选）
    for (int i=0; i<8; i++) {
        if (C[i] != A[i]*B[i]) {
            // 错误处理
            while(1);
        }
    }
    
    return 0;
}

硬件集成注意事项 #

1. 在Quartus中将Verilog模块封装为IP核，通过Platform Designer连接到Nios V系统，分配Avalon-MM地址
2. 确保数据宽度匹配：Nios V默认32位数据总线，FPGA端存储模块需对应32位宽度
3. 若需替代轮询，可在FPGA端添加中断输出信号，连接到Nios V中断控制器，在C代码中注册中断服务函数

内容的提问来源于stack exchange，提问作者Hellen