FIFO IP <-> AHB

我们在设计中创建了一个FIFO IP核，并将其挂载到AHB总线上，以实现MCU对FIFO的读写访问。

FIFO IP配置

FIFO是先入先出，设计如下：

FIFO的设计为先入先出队列，配置如下：

• 位宽设置为8位
• 存储深度设置为4096，以充分利用4个M9K存储块
• 其余参数保持默认配置，不使用empty和usedw信号。

值得注意的是，FIFO的读写时序上，读取数据时输出会滞后一个时钟周期。

FPGA代码设计

参考cpld-fpga文档中的5.mcu读写cpld寄存器。

这里的设计需要参考AHB的时序图，由于AHB总在线上升沿进行数据读写操作，而FIFO也是在上升沿进行操作，因此我们将系统时钟反相后输入FIFO，以确保时序的一致性。

此外，AHB在传输数据时，数据与地址并非处于同一时钟周期内，数据会滞后一个时钟周期，因此我们给hreadyout 一个时钟周期的延时，从而确保AHB传输过来的数据被正确接收。此外，由于FIFO是在sys_clk下降沿进行数据读写，所以会滞后AHB数据读取一个周期，因此需要对wr_en进行一个周期的延时操作。

而在读取FIFO数据时，不需要hreadyout，FIFO的数据输出直接提供给AHB总线。

module user_ip (
  input              sys_clock,
  input              bus_clock,
  input              resetn,
  input              stop,
  input       [1:0]  mem_ahb_htrans,
  input              mem_ahb_hready,
  input              mem_ahb_hwrite,
  input       [31:0] mem_ahb_haddr,
  input       [2:0]  mem_ahb_hsize,
  input       [2:0]  mem_ahb_hburst,
  input       [31:0] mem_ahb_hwdata,
  output tri1        mem_ahb_hreadyout,
  output tri0        mem_ahb_hresp,
  output tri0 [31:0] mem_ahb_hrdata,
  output tri0        slave_ahb_hsel,
  output tri1        slave_ahb_hready,
  input              slave_ahb_hreadyout,
  output tri0 [1:0]  slave_ahb_htrans,
  output tri0 [2:0]  slave_ahb_hsize,
  output tri0 [2:0]  slave_ahb_hburst,
  output tri0        slave_ahb_hwrite,
  output tri0 [31:0] slave_ahb_haddr,
  output tri0 [31:0] slave_ahb_hwdata,
  input              slave_ahb_hresp,
  input       [31:0] slave_ahb_hrdata,
  output tri0 [3:0]  ext_dma_DMACBREQ,
  output tri0 [3:0]  ext_dma_DMACLBREQ,
  output tri0 [3:0]  ext_dma_DMACSREQ,
  output tri0 [3:0]  ext_dma_DMACLSREQ,
  input       [3:0]  ext_dma_DMACCLR,
  input       [3:0]  ext_dma_DMACTC,
  output tri0 [3:0]  local_int
);

assign slave_ahb_hready  = 1'b1; 

reg hreadyout_reg;
reg hreadyout_del;

assign mem_ahb_hreadyout = hreadyout_reg;

// Internal signals
reg [7:0] data_in;
wire [7:0] data_out;
reg wr_en;
reg wr_en_del;
reg rd_en;

assign mem_ahb_hrdata = {24'b0, data_out}; // Zero-padding upper bits

reg [1:0] state;//addr phase 00:idel 01:write 10:read

// AHB state machine
always @(posedge sys_clock or negedge resetn) begin          //clk上升沿触发
        if (!resetn) begin
                hreadyout_reg <= 1'b1;
                                         wr_en <= 1'b0;
        end else if(mem_ahb_htrans == 2'b10 && hreadyout_reg) begin //写地址为0x60000000（cpld内部用相对偏移）。
                hreadyout_reg <= 1'b0;
                //led3reg <= 1'b0;
        end else if(!hreadyout_del &&                          //cpld已ready状态，ahb上数据可以写过来了
                mem_ahb_hwrite &&                        //写 （0 读，1 写）
                mem_ahb_haddr[23:0] == 'h00)
                        begin
                hreadyout_reg <= 1'b1;
                                         data_in <= mem_ahb_hwdata[7:0];
                wr_en <= 1'b1;
        end else begin
                hreadyout_reg <= 1'b1;
                                         wr_en <= 1'b0;
        end
end

always @ (posedge sys_clock or negedge resetn) begin
        if (!resetn) begin
                 hreadyout_del <= 1'b1;
                                          wr_en_del <= 1'b0;
        end else begin
                hreadyout_del <= hreadyout_reg;
                                         wr_en_del <=wr_en;
        end
end

//mcu的读操作响应
//mcu端用C语言：int value = *((int *)0x60000004);
//reg [7:0] hrdata_reg;                                         //定义32位的hrdata_reg
always @(posedge sys_clock or negedge resetn) begin          //clk上升沿触发
        if (!resetn) begin
                rd_en <= 1'b0;
        end else if (mem_ahb_htrans == 2'b10 &&          //NONSEQ状态，第一次传输
                mem_ahb_hready &&                                  //master已ready，可以给数据线写入了
                !mem_ahb_hwrite &&                        //读 （0 读，1 写）
                mem_ahb_haddr[23:0] == 'h04)         //读地址为0x60000004（cpld内部用相对偏移）。
        begin
                //hrdata_reg <= hwdata_reg;                //把另一准备好的数据给到hrdata_reg
                rd_en <= 1'b1;
        end else begin
                rd_en <= 1'b0;
        end
end
//assign mem_ahb_hrdata = hrdata_reg;        //绑定hrdata_reg到读的数据线上

fifo_ip        fifo_ip_inst (
        .clock (~sys_clock),
        .data ( data_in ),
        .rdreq ( rd_en ),
        .wrreq ( wr_en_del ),
        .full ( full_sig ),
        .q ( data_out )
        );


endmodule

最后综合出来的rtl网表如下图所示：

MCU代码

为了测试FIFO是否能正常工作，我们通过USB串口写入16个数据，然后读取并验证数据是否正确：

if ( tud_cdc_available() )
    {
      // read data
      unsigned char buf[16] = {0};
      uint32_t count = tud_cdc_read(buf, sizeof(buf));
      (void) count;
      for(int i = 0; i < 16; i++)
      {
        *((char *)0x60000000) = buf[i];
        //asm("nop");
      }

      unsigned char buf2[16] = {0};
      for(int i = 0; i < 16; i++)
      {
        buf2[i] = *((char *)0x60000004);
        //asm("nop");
      }
      cdc_transfer(buf2, 16);
    }

从输出结果可以看到，接收到的数据与我们写入的数据完全一致，说明FIFO功能正常。

采样时钟频率控制模块

逻辑分析仪主要分为：stream模式和buffer模式。

其中stream模式是指采样和传输同时进行，不对采集的数据进行本地缓存。这种方式不受buffer大小的限制，但是受传输速率的影响，其采样率会收到一定的限制。

buffer模式相反，将采集到的数据先存储在本地，采样结束后再将其传输到上位机，这种方式能够实现很高的采样率，但是采样深度会受到buffer大小的限制。

由于AG32的CPLD上带有4个M9K，最大能够提供4KByte的存储空间，因此这里我们这里采用buffer模式。

受制于存储空间，采样率并不是越大越好，如果采样速度太快，则buffer会很快被填满，甚至无法存储一个传输周期的波形；然而受制于奈奎斯特采样定律，采样速度又不能太低，否则采集到的数据无法恢复出原始波形。

因此，我们首先需要设计一个采样使能信号，从而对逻辑分析仪的采样速率进行调整控制。其本质就是一个计数器分频电路。

功能代码设计

具体设计代码如下：

module div_freq(
        input clk,//100MHz
        input rest_n,//复位信号，低电平有效
        input [3:0] sel,//频率选择
        output clken//时钟有效信号
);

reg [19:0] cnt;//20位宽 计数器
reg [19:0] clk_div;//分频值

//wire div_100m;//100MHz判断信号

//assign div_100m = (sel == 4'hf);

//assign clken = div_100m?1'b1:(cnt == clk_div);//clk使能信号, 100M时一直为高电平;分频时,计数结束为高电平
assign clken = (clk_div == 20'd0)?1'b1:(cnt == clk_div);//clk使能信号, 100M时一直为高电平;分频时,计数结束为高电平

//计数器
always @(posedge clk or negedge rest_n)
begin
        if(!rest_n) begin
                cnt <= 20'd0;
        end else if(clken) begin
                cnt <= 20'b0;//计数完成后清计数器零
        end else begin
                cnt <= cnt + 1'b1;
        end
end

//频率选择
always @(sel)
begin
        case(sel)
                4'h0: clk_div <= 20'd999999;//100Mhz/1000000 = 100Hz
                4'h1: clk_div <= 20'd199999;//100Mhz/200000 = 500Hz
                4'h2: clk_div <= 20'd99999;//100Mhz/100000 = 1KHz
                4'h3: clk_div <= 20'd19999;//100Mhz/20000 = 5KHz
                4'h4: clk_div <= 20'd9999;//100Mhz/10000 = 10KHz
                4'h5: clk_div <= 20'd1999;//100Mhz/2000 = 50KHz
                4'h6: clk_div <= 20'd999;//100Mhz/1000 = 100KHz
                4'h7: clk_div <= 20'd499;//100Mhz/500 = 200KHz
                4'h8: clk_div <= 20'd199;//100Mhz/200 = 500KHz
                4'h9: clk_div <= 20'd99;//100Mhz/100 = 1MHz
                4'ha: clk_div <= 20'd49;//100Mhz/50 = 2MHz
                4'hb: clk_div <= 20'd19;//100Mhz/20 = 5MHz
                4'hc: clk_div <= 20'd9;//100Mhz/10 = 10MHz
                4'hd: clk_div <= 20'd4;//100Mhz/5 = 20MHz
                4'he: clk_div <= 20'd1;//100Mhz/2 = 50MHz
                4'hf: clk_div <= 20'd0;//100Mhz/1 = 100MHz
        endcase
end

endmodule

仿真验证

testbench：

// Copyright (C) 1991-2013 Altera Corporation
// Your use of Altera Corporation's design tools, logic functions 
// and other software and tools, and its AMPP partner logic 
// functions, and any output files from any of the foregoing 
// (including device programming or simulation files), and any 
// associated documentation or information are expressly subject 
// to the terms and conditions of the Altera Program License 
// Subscription Agreement, Altera MegaCore Function License 
// Agreement, or other applicable license agreement, including, 
// without limitation, that your use is for the sole purpose of 
// programming logic devices manufactured by Altera and sold by 
// Altera or its authorized distributors.  Please refer to the 
// applicable agreement for further details.

// *****************************************************************************
// This file contains a Verilog test bench template that is freely editable to  
// suit user's needs .Comments are provided in each section to help the user    
// fill out necessary details.                                                  
// *****************************************************************************
// Generated on "10/18/2024 16:55:28"
                                                                                
// Verilog Test Bench template for design : div_freq
// 
// Simulation tool : ModelSim (Verilog)
// 

`timescale 1 ns/ 1 ns
module div_freq_vlg_tst();
// constants                                           
// general purpose registers
reg eachvec;
// test vector input registers
reg clk;
reg rest_n;
reg [3:0] sel;
// wires                                               
wire clken;

always #5 clk=~clk;

// assign statements (if any)                          
div_freq i1 (
// port map - connection between master ports and signals/registers   
        .clk(clk),
        .clken(clken),
        .rest_n(rest_n),
        .sel(sel)
);
initial                                                
begin                                                  
// code that executes only once                        
// insert code here --> begin                          
        clk <= 1'b0;
        rest_n <= 1'b0;
        
        # 10;
        rest_n <= 1'b1;
        sel <= 4'hc;
// --> end                                             
$display("Running testbench");                       
end                                                    
always                                                 
// optional sensitivity list                           
// @(event1 or event2 or .... eventn)                  
begin                                                  
// code executes for every event on sensitivity list   
// insert code here --> begin                          
                                                       
@eachvec;                                              
// --> end                                             
end                                                    
endmodule

测试结果：（分频10MHz）

为了实现正确的采样并且存入RAM中，我们需要进行触发检测以及采样使能。

采样触发

任何示波器的存储器容量都是有限的，因此逻辑分析仪必须使用触发。

逻辑 分析仪中常见的触发方式包括延迟触发、限定触发、组合触发、毛刺触发等。 本简易逻辑分析仪主要支持以下几种触发方式：

• 电平触发： 低电平触发、高电平触发
• 边沿触发： 上升沿触发、下降沿触发、边沿触发（上升沿 或下降沿触发）
• 立即触发：实时触发

触发条件检测

input clk,//系统时钟 100MHz
        input rest_n,//复位信号
        input clken,//时钟使能信号
        input [7:0] data_in,//采样数据输入

//触发采样
reg [7:0] data_del1;//一级存储
reg [7:0] data_del2;//二级存储

wire [7:0] s_posedge;//上升沿标志位
wire [7:0] s_negedge;//下降沿标志位
wire [7:0] s_edge;//边沿标志位

assign s_posedge = data_del1 & ~data_del2;//上升沿检测
assign s_negedge = ~data_del1 & data_del2;//下降沿检测
assign s_edge = data_del1 ^ data_del2;//边沿检测

//输入信号二级缓存
always @(posedge clk)
begin
        if (clken) begin//时钟使能时开始检测
                data_del1 <= data_in;
                data_del2 <= data_del1;
        end
end

触发条件选择

input [2:0] mode_sel,//采样模式选择
        
        
//触发条件选择
reg [7:0] trigger_dat;//触发条件比较寄存器

//根据触发条件选择出发数据(mode_sel可以不要？)
always @(mode_sel or s_posedge or s_negedge or s_edge or data_del2)//分别用于上升沿、下降沿、高低电平
begin
        case(mode_sel)
                3'd0: trigger_dat <= ~data_del2;//低电平触发
                3'd1: trigger_dat <= data_del2;//高电平触发
                3'd2: trigger_dat <= s_posedge;//上升沿触发
                3'd3: trigger_dat <= s_negedge;//下降沿触发
                3'd4: trigger_dat <= s_edge;//跳变沿触发
                3'd5: trigger_dat <= 8'b11111111;//立即触发
                default: trigger_dat <= 8'b11111111;//默认立即触发
        endcase
end

触发标志位

//触发标志位
reg trigger;

//触发条件判断
always @(posedge clk or negedge rest_n)
begin
        if (!rest_n)
                trigger <= 1'b0;
        else if(clken && trigger_dat[channel_sel])
                trigger <= 1'b1;
        else
                trigger <= 1'b0;
end

采样存储

除了采样触发外，还需要一个采样使能标志位，它起到一个总开关的作用，只有打开采样使能且满足触发条件时，才会进行数据的采集与存储。否则若只满足触发条件，则不进行采样。

input act_trigger,//采样使能

//采样使能标志位
reg act_en;//采集使能标志位
wire full;//FIFO满 标志位

//采样启动并保持至FIFO写满
always @(posedge clk or negedge rest_n)
begin
        if(!rest_n)
                act_en <= 1'b0;
        else if(act_trigger)
                act_en <= 1'b1;
        else if(full)
                act_en <= 1'b0;
        else
                act_en <= act_en;
end

FIFO写使能控制

output reg wr_en//FIFO写使能

//FIFO写数据使能
always @(posedge clk or negedge rest_n)
begin
        if(!rest_n)
                wr_en <= 1'b0;
        else if(act_en && trigger && ~wr_en)//是首次触发并已使能，~wren表示上个FIFO已写满
                wr_en <=1'b1;
        else if(full)
                wr_en <= 1'b0;
        else
                wr_en <= wr_en;
end

VE文件引脚定义

ct_trigger和full_sign两个信号线

首先是act_trigger和full_sign为两个信号线，我们分别将其映射到GPIO2_1和GPIO2_2上。其中，act_trigger方向为MCU->CPLD;full_sign方向为CPLD->MCU。因此其定义如下：

GPIO2_1 act_trigger:OUTPUT

GPIO2_2 full_sign:INPUT

• 当控制mcu 的gpio2_1 高低切换时，cpld 中的act_trigger_out_data，会对应来变化。
• 当cpld 中控制full_sign_in_data 信号高低时，mcu 中的gpio2_2 对应变化。

8个采样引脚

根据板卡上的排针排列，我们选取的采样引脚对应关系如下：

VE文件编写如下：

data_in[0] PIN_67:INPUT
data_in[1] PIN_80:INPUT
data_in[2] PIN_82:INPUT
data_in[3] PIN_84:INPUT
data_in[4] PIN_86:INPUT
data_in[5] PIN_88:INPUT
data_in[6] PIN_92:INPUT
data_in[7] PIN_95:INPUT

MCU代码编写

if(buf[0] == 0x01)//写入设置
    {
      int wValue = 0;
      // 将 buf[0] 放入 int 的低8位
      wValue |= buf[1];
      // 将 buf[1] 移动到 int 的中间8位，并与combined进行或运算
      wValue |= (buf[2] << 8);
      //write register 0x60000008
      *((int *)0x60000008) = wValue;
    }
    else if(buf[0] == 0x02)
    {
      //GPIO_SetLow(SIGNAL_GPIO, ACT_GPIO_BITS);
      //GPIO_SetHigh(LED_GPIO, ACT_GPIO_BITS);

      for(int i = 0; i < 4096; i++)
      {
        buf[i] = *((char *)0x60000004);
        asm("nop");
      }
      cdc_transfer(buf, 4096);
    }

act_en: MCU->CPLD 当进行读取FIFO时将其拉低

full：CPLD->MCU FIFO满标志位，当full=1时，将act_en拉低，并且读出FIFO中全部数据

上位机代码

import serial
import struct

import numpy as np
import matplotlib.pyplot as plt

class LogicAnalyzer:
    def __init__(self, channels):
        self.channels = channels
        self.data = {channel: [] for channel in channels}

    def capture(self, signals):
        for channel, signal in zip(self.channels, signals):
            self.data[channel].append(signal)

    def plot(self):
        time = np.arange(0, len(self.data[self.channels[0]]))
        for index, channel in enumerate(self.channels):
            plt.subplot(len(self.channels), 1, index+1)
            plt.step(time, self.data[channel], where='post', label=channel)
            plt.xlabel('Time')
            plt.ylabel('Signal Level')
            plt.title('Logic Analyzer Output')
            plt.legend()
            plt.grid()
        plt.show()

# 初始化串口
ser = serial.Serial(
    port='COM17',  # 请根据实际情况更改端口名
    baudrate=9600,  # 根据实际情况调整波特率
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=2  # 设置超时时间
)

try:
    # 准备要发送的数字
    number_to_send = 2
    
    # 将整数转换为字节序列
    packed_number = struct.pack('>B', number_to_send)  # '>B' 表示无符号字节 (0 to 255)
    
    # 发送数据
    ser.write(packed_number)  # 发送字节序列
    
    # 读取响应数据
    total_received = b''  # 用于存储接收到的数据
    expected_size = 4096  # 期望接收的数据量
    while len(total_received) < expected_size:
        remaining = expected_size - len(total_received)
        chunk = ser.read(min(remaining, 1024))  # 每次最多读取1024字节
        if not chunk:
            break  # 如果没有接收到新的数据，跳出循环
        total_received += chunk
    
    if len(total_received) == expected_size:
        # 如果接收到的数据量等于期望值，可以进一步处理数据
        print("Received all data.")
        # 提取每个字节的最低位
        bits0 = [byte & 1 for byte in total_received]
        bits1 = [(byte >> 1) & 1 for byte in total_received]
        bits2 = [(byte >> 2) & 1 for byte in total_received]
        bits3 = [(byte >> 3) & 1 for byte in total_received]
        bits4 = [(byte >> 4) & 1 for byte in total_received]
        bits5 = [(byte >> 5) & 1 for byte in total_received]
        bits6 = [(byte >> 6) & 1 for byte in total_received]
        bits7 = [(byte >> 7) & 1 for byte in total_received]
        
        # 打印结果
        print("Extracted lowest bits:")
        # print(second_highest_bits)
    else:
        print("Did not receive enough data. Received:", len(total_received), "bytes out of", expected_size, "expected.")
        
except Exception as e:
    print(f"Error occurred: {e}")

finally:
    # 关闭串口
    ser.close()

analyzer = LogicAnalyzer(['Channel 1', 'Channel 2', 'Channel 3', 'Channel 4', 'Channel 5', 'Channel 6', 'Channel 7', 'Channel 8'])
# analyzer = LogicAnalyzer(['Channel 1'])

for i in range(4096):
    signals = [bits0[i], bits1[i], bits2[i], bits3[i], bits4[i], bits5[i], bits6[i], bits7[i]]
    # signals = [bits6[i]]
    analyzer.capture(signals)

analyzer.plot()

结果