时间戳

首页 > 技术文章 > FPGA——主机STM32与从机FPGA进行SPI通信验证

FPGA——主机STM32与从机FPGA进行SPI通信验证

cnlntr 2021-02-07 16:52 原文

一、设计思路

  • STM32F4的SPI通信特点
    一旦STM32的SPI启动之后，SPI的时钟SCK会一直处于工作状态，并不是设想中的，只有在STM32读数据或者写数据的时候，SCK才会由空闲状态转入翻转状态
    由此，带来的问题是从机FPGA会因为SCK翻转而不断的接收数据，使得从机FPGA得不到想要的数据。解决这个的问题的关键在于，在STM32输出口，定义一个CS片选信号，只有在写数据或者读数据的时候激活片选信号，以控制STM32的读写
#define SPI_CS PBout(7)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOB, &GPIO_InitStructure);

SPI_CS = 0;
SPI1_ReadWriteByte(0xAB12);
SPI_CS = 1;
  • FPGA输入信号问题
    https://www.cnblogs.com/cnlntr/p/14382552.html
    因为要接收CS片选信号，不在同一个时钟域，为防止亚稳态，因此需要异步信号同步化处理,取CS_SYNC[1]为FPGA内部CS控制信号
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cs_sync <= 2'b11;
   else
      cs_sync <= {cs_sync[0],spi_cs};
end
  • 验证SPI通信
    这里将FPGA接上一个串口发送模块，STM32按下对应的按键发送对应数据到FPGA，FPGA再由串口将数据传上PC端

二、STM32部分代码实现

SPI部分————spi.c

/以下是SPI模块的初始化代码，配置成主机模式 						  

//SPI口初始化
//这里针是对SPI1的初始化
void SPI1_Init(void)
{	 
   GPIO_InitTypeDef  GPIO_InitStructure;
	 GPIO_InitTypeDef  GPIO_InitStructure1;
   SPI_InitTypeDef  SPI_InitStructure;
   
   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟
   
  //GPIOFB3,4,5初始化设置
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3~5复用功能输出	
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;//100MHz
   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
	
   GPIO_InitStructure1.GPIO_Pin =  GPIO_Pin_7;
   GPIO_InitStructure1.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStructure1.GPIO_OType = GPIO_OType_PP;//推挽输出
   GPIO_InitStructure1.GPIO_Speed = GPIO_High_Speed;//100MHz
   GPIO_InitStructure1.GPIO_PuPd = GPIO_PuPd_UP;//上拉
   GPIO_Init(GPIOB, &GPIO_InitStructure1);//初始化
	
	GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
	GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
	GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1); //PB5复用为 SPI1

	//这里只针对SPI口初始化
	RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);										//复位SPI1
	RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);										//停止复位SPI1

	SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;  							   //设置SPI单向或者双向的数据模式:SPI设置为单向
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;												//设置SPI工作模式:设置为主SPI
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;											//设置SPI的数据大小:SPI发送接收16位帧结构
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;													//串行同步时钟的空闲状态为高电平
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;												   //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;													   //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;		         //定义波特率预分频的值:波特率预分频值为256
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;											//指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
	SPI_InitStructure.SPI_CRCPolynomial = 7;														//CRC值计算的多项式
	SPI_Init(SPI1, &SPI_InitStructure);  															//根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

	SPI_Cmd(SPI1, ENABLE); 																				//使能SPI外设

	SPI_CS = 0;
	SPI1_ReadWriteByte(0x0000);//启动传输
	SPI_CS = 1;
}   
//SPI1速度设置函数
//SPI速度=fAPB2/分频系数
//@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
//fAPB2时钟一般为84Mhz：
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
	SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
	SPI1->CR1|=SPI_BaudRatePrescaler;	//设置SPI1速度 
	SPI_Cmd(SPI1,ENABLE); //使能SPI1
} 
//SPI1 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
void SPI1_ReadWriteByte(u16 TxData)
{		 			 

   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
	
	SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
}

SPI部分——spi.h

#ifndef __SPI_H

#define __SPI_H

#include "sys.h"

#define SPI_CS PBout(7)

void SPI1_Init(void);	            //初始化SPI1口
void SPI1_SetSpeed(u8 SpeedSet);    //设置SPI1速度   
void SPI1_ReadWriteByte(u16 TxData);//SPI1总线读两个个字节
#endif

主程序——main.c

#include "sys.h"

#include "delay.h"

#include "usart.h"

#include "led.h"
#include "lcd.h"
#include "spi.h"
#include "w25qxx.h"
#include "key.h"  


int main(void)
{ 
	u8 key;
	u16 i = 0;
	SPI_CS = 1;
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
	delay_init(168);     //初始化延时函数

	LED_Init();					//初始化LED 

	KEY_Init(); 				//按键初始化  
	SPI1_Init();		    //初始化SPI
	SPI1_SetSpeed(SPI_BaudRatePrescaler_8);		//设置为10M时钟,高速模式 
	while(1)
	{
		SPI_CS = 1;
		key=KEY_Scan(0);
		if(key==KEY0_PRES)//KEY0按下
		{
			SPI_CS = 0;
			SPI1_ReadWriteByte(0xAB01);
			SPI_CS = 1;
			
		}
		if(key==KEY1_PRES)//KEY1按下
		{
			SPI_CS = 0;
			SPI1_ReadWriteByte(0xAB12);
			SPI_CS = 1;
		}
		if(key==KEY2_PRES)//KEY2按下
		{
			SPI_CS = 0;
			SPI1_ReadWriteByte(0xAC83);
			SPI_CS = 1;
		} 
		i++;
		delay_ms(10);
		if(i==20)
		{
			LED0=!LED0;//提示系统正在运行	
			i=0;
		}		   
	}  
}

三、FPGA代码实现

module spi_slave(

   clk      ,  //50MHz时钟

   rst_n    ,  //复位
   data_in  ,  //要发送的数据
   data_out ,  //接收到的数据
   spi_sck  ,  //主机时钟
   spi_miso ,  //主收从发（从机）
   spi_mosi ,  //主发从收（从机）
   spi_cs   ,  //主机片选，低有效（从机）
   tx_en    ,  //发送使能
   tx_done  ,  //发送完成标志位
   rx_done     //接收完成标志位
);
parameter DATA_W  =  16;

parameter SYNC_W  =  2;

//计数器参数
parameter CNT_W   =  4;
parameter CNT_N   =  DATA_W;

input                   clk;
input                   rst_n;
input    [DATA_W-1:0]   data_in;
input                   spi_sck;
input                   spi_mosi;
input                   spi_cs;
input                   tx_en;

output   [DATA_W-1:0]   data_out;
output                  spi_miso;
output                  tx_done;
output                  rx_done;

reg      [DATA_W-1:0]   data_out;
reg                     spi_miso;
reg                     tx_done;
reg                     rx_done;

//中间变量
reg      [SYNC_W-1:0]   sck_sync;
wire                    sck_nedge;
wire                    sck_pedge;
reg                     spi_mosi_reg;

reg      [SYNC_W-1:0]   cs_sync;
// wire                    cs_nedge;
// wire                    cs_pedge;

//计数器变量
reg      [CNT_W-1:0]    cnt_rxbit;
wire                    add_cnt_rxbit;
wire                    end_cnt_rxbit;

reg      [CNT_W-1:0]    cnt_txbit;
wire                    add_cnt_txbit;
wire                    end_cnt_txbit;
reg                     tx_flag;

//CS异步信号同步化
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cs_sync <= 2'b11;
   else
      cs_sync <= {cs_sync[0],spi_cs};
end
// assign cs_nedge = cs_sync[1:0] == 2'b10;
// assign cs_pedge = cs_sync[1:0] == 2'b01;

//SCK边沿检测
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      //SCK时钟空闲状态位高电平，工作模式3
      sck_sync <= 2'b11;
   else
      sck_sync <= {sck_sync[0],spi_sck};
end
assign sck_nedge = sck_sync[1:0] == 2'b10;
assign sck_pedge = sck_sync[1:0] == 2'b01;

//上升沿接收，工作模式三
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cnt_rxbit <= 0;
   else if(add_cnt_rxbit)begin
      if(end_cnt_rxbit)
         cnt_rxbit <= 0;
      else
         cnt_rxbit <= cnt_rxbit + 1'b1;
   end
end
assign add_cnt_rxbit = sck_pedge && cs_sync[1] == 0;
assign end_cnt_rxbit = add_cnt_rxbit && cnt_rxbit == CNT_N - 1;

//下降沿发送，工作模式三
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cnt_txbit <= 0;
   else if(add_cnt_txbit)begin
      if(end_cnt_txbit)
         cnt_txbit <= 0;
      else
         cnt_txbit <= cnt_txbit + 1'b1;
   end
end
assign add_cnt_txbit = sck_nedge && tx_flag && cs_sync[1] == 0;
assign end_cnt_txbit = add_cnt_txbit && cnt_txbit == CNT_N - 1;

//因为异步信号同步化的原因，为了与延后的下降沿对齐,多打一拍
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      spi_mosi_reg <= 0;
   else
      spi_mosi_reg <= spi_mosi;
end

//下降沿接收数据
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)  
      data_out <= 0;
   else if(cs_sync[1] == 0)
      data_out[CNT_N - 1 - cnt_rxbit ] <= spi_mosi_reg;
end

//上升沿发送数据
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      spi_miso <= 0;
   else if(cs_sync[1] == 0 && tx_flag)
      spi_miso <= data_in[CNT_N - 1 - cnt_txbit];
   else
      spi_miso <= 0;
end

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      rx_done <= 0;
   else if(end_cnt_rxbit)
      rx_done <= 1;
   else
      rx_done <= 0;
end

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      tx_done <= 0;
   else if(end_cnt_txbit)
      tx_done <= 1;
   else
      tx_done <= 0;
end


always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      tx_flag <= 0;
   else if(tx_en)
      tx_flag <= 1;
   else if(end_cnt_txbit)
      tx_flag <= 0;
end

endmodule

四、FPGA仿真验证代码

`timescale 1ns / 1ns

module spi_slave_tb();

parameter DATA_W     =  16;
parameter CYCLE      =  20;
parameter CYCLE_SPI  =  50;  

reg                   clk;
reg                   rst_n;
reg    [DATA_W-1:0]   data_in;
reg                   spi_sck;
reg                   spi_mosi;
reg                   spi_cs;

wire   [DATA_W-1:0]   data_out;
wire                  spi_miso;
wire                  rx_done;
wire                  tx_done;


reg                   tx_en;

spi_slave spi_slave(
   .clk      (clk),  //50MHz时钟
   .rst_n    (rst_n),  //复位
   .data_in  (data_in),  //要发送的数据
   .data_out (data_out),  //接收到的数据
   .spi_sck  (spi_sck),  //主机时钟
   .spi_miso (spi_miso),  //主收从发（从机）
   .spi_mosi (spi_mosi),  //主发从收（从机）
   .spi_cs   (spi_cs),  //主机片选，低有效（从机）
   .tx_done  (tx_done),  //发送完成标志位
   .tx_en    (tx_en),
   .rx_done  (rx_done)   //接收完成标志位
);

initial begin                                                  
	rst_n = 1;
	#3;
	rst_n = 0;
   #(3*CYCLE)
   rst_n = 1;
end


initial clk = 1;
always #(CYCLE/2) clk = ~clk;  

//SCK空闲时为1
initial spi_sck = 1;
always #(CYCLE_SPI/2) spi_sck = ~spi_sck;



// initial begin
//    tx_en = 0;
//    data_in = 0;
//    @ (posedge rst_n)
//    #(10*CYCLE)
//    data_in = 16'hAAA9;
//    tx_en = 1;
//    #(CYCLE)
//    tx_en = 0;
// end

//输入信号din0赋值方式
initial begin
   #1;
   spi_cs = 1;
   spi_mosi = 0;
   #(10*CYCLE);
   //开始赋值
   spi_send(16'hAAA1);
   #3000;
   spi_send(16'hAAA2);
   #3000;
   spi_send(16'hAAA3);
   #3000;
   spi_send(16'h5A54);
   #2000;
   $stop;
end


task spi_send;
input [DATA_W-1:0]  data;
//下降沿发送数据
begin
   spi_cs = 0;
   @(negedge spi_sck)
   spi_mosi <= data[15];
   @(negedge spi_sck)
   spi_mosi <= data[14];
   @(negedge spi_sck)
   spi_mosi <= data[13];
   @(negedge spi_sck)
   spi_mosi <= data[12];
   @(negedge spi_sck)
   spi_mosi <= data[11];
   @(negedge spi_sck)
   spi_mosi <= data[10];
   @(negedge spi_sck)
   spi_mosi <= data[9];
   @(negedge spi_sck)
   spi_mosi <= data[8];
   @(negedge spi_sck)
   spi_mosi <= data[7];
   @(negedge spi_sck)
   spi_mosi <= data[6];
   @(negedge spi_sck)
   spi_mosi <= data[5];
   @(negedge spi_sck)
   spi_mosi <= data[4];
   @(negedge spi_sck)
   spi_mosi <= data[3];
   @(negedge spi_sck)
   spi_mosi <= data[2];
   @(negedge spi_sck)
   spi_mosi <= data[1];
   @(negedge spi_sck)
   spi_mosi <= data[0];
   @(negedge spi_sck)
   spi_cs = 1;
end
endtask

endmodule

五、FPGA实现方法2

module spi_slave(
   clk      ,  //50MHz时钟
   rst_n    ,  //复位
   data_in  ,  //要发送的数据
   data_out ,  //接收到的数据
   spi_sck  ,  //主机时钟
   spi_miso ,  //主收从发（从机）
   spi_mosi ,  //主发从收（从机）
   spi_cs   ,  //主机片选，低有效（从机）
   tx_en    ,  //发送使能
   tx_done  ,  //发送完成标志位
   rx_done     //接收完成标志位
);
parameter DATA_W  =  16;

parameter SYNC_W  =  2;

//计数器参数
parameter CNT_W   =  4;
parameter CNT_N   =  DATA_W;

input                   clk;
input                   rst_n;
input    [DATA_W-1:0]   data_in;
input                   spi_sck;
input                   spi_mosi;
input                   spi_cs;
input                   tx_en;

output   [DATA_W-1:0]   data_out;
output                  spi_miso;
output                  tx_done;
output                  rx_done;

reg      [DATA_W-1:0]   data_out;
reg                     spi_miso;
reg                     tx_done;
reg                     rx_done;

//中间变量
reg      [SYNC_W-1:0]   sck_sync;
wire                    sck_nedge;
wire                    sck_pedge;
reg                     spi_mosi_reg;

reg      [SYNC_W-1:0]   cs_sync;
wire                    cs_nedge;
wire                    cs_pedge;

reg                     cs_low;

//计数器变量
reg      [CNT_W-1:0]    cnt_rxbit;
wire                    add_cnt_rxbit;
wire                    end_cnt_rxbit;

reg      [CNT_W-1:0]    cnt_txbit;
wire                    add_cnt_txbit;
wire                    end_cnt_txbit;
reg                     tx_flag;

//CS异步信号同步化
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cs_sync <= 2'b11;
   else
      cs_sync <= {cs_sync[0],spi_cs};
end
assign cs_nedge = cs_sync[1:0] == 2'b10;
assign cs_pedge = cs_sync[1:0] == 2'b01;

//SCK边沿检测
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      //SCK时钟空闲状态位高电平，工作模式3
      sck_sync <= 2'b11;
   else
      sck_sync <= {sck_sync[0],spi_sck};
end
assign sck_nedge = sck_sync[1:0] == 2'b10;
assign sck_pedge = sck_sync[1:0] == 2'b01;

//上升沿接收，工作模式三
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cnt_rxbit <= 0;
   else if(add_cnt_rxbit)begin
      if(end_cnt_rxbit)
         cnt_rxbit <= 0;
      else
         cnt_rxbit <= cnt_rxbit + 1'b1;
   end
end
assign add_cnt_rxbit = sck_pedge && cs_low;
assign end_cnt_rxbit = add_cnt_rxbit && cnt_rxbit == CNT_N - 1;

//下降沿发送，工作模式三
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cnt_txbit <= 0;
   else if(add_cnt_txbit)begin
      if(end_cnt_txbit)
         cnt_txbit <= 0;
      else
         cnt_txbit <= cnt_txbit + 1'b1;
   end
end
assign add_cnt_txbit = sck_nedge && tx_flag && cs_low;
assign end_cnt_txbit = add_cnt_txbit && cnt_txbit == CNT_N - 1;

//因为异步信号同步化的原因，为了与延后的下降沿对齐,多打一拍
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      spi_mosi_reg <= 0;
   else
      spi_mosi_reg <= spi_mosi;
end


always @(posedge clk or negedge rst_n)begin
   if(!rst_n)  
      data_out <= 0;
   else if(cs_low)
      data_out[CNT_N - 1 - cnt_rxbit ] <= spi_mosi_reg;
end

//上升沿发送数据
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      spi_miso <= 0;
   else if(cs_low && tx_flag)
      spi_miso <= data_in[CNT_N - 1 - cnt_txbit];
   else
      spi_miso <= 0;
end

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      rx_done <= 0;
   else if(end_cnt_rxbit)
      rx_done <= 1;
   else
      rx_done <= 0;
end

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      tx_done <= 0;
   else if(end_cnt_txbit)
      tx_done <= 1;
   else
      tx_done <= 0;
end

//cs为低电平标志信号,当计数器计数完成，即使当前CS还没有失效，拉低标志信号，防止余的CS导致计数器又在计数，当cs出现下降沿时，开始计数
always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      cs_low <= 0;
   else if(end_cnt_rxbit)
      cs_low <= 0;
   else if(cs_nedge)
      cs_low <= 1;
end

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      tx_flag <= 0;
   else if(tx_en)
      tx_flag <= 1;
   else if(end_cnt_txbit)
      tx_flag <= 0;
end

endmodule

六、FPGA板级验证相关代码

串口子模块

https://www.cnblogs.com/cnlntr/p/14318412.html

顶层模块

module spi_test(

   clk      ,

   rst_n    ,
   spi_sck  ,
   spi_mosi ,
   spi_miso ,
   uart_tx  ,
   spi_cs   ,
   led_out
);

parameter DATA_W  =  16;
parameter LED_W   =  8;

input                   clk;
input                   rst_n;
input                   spi_sck;
input                   spi_mosi;
input                   spi_cs;

output                  spi_miso;
output   [LED_W-1:0]    led_out;
output                  uart_tx;

wire                    spi_miso;
reg      [LED_W-1:0]    led_out;

wire     [DATA_W-1:0]   data_out;
wire                    tx_done;
wire                    rx_done;
wire                    uart_tx;

spi_slave spi_slave(
   .clk      (clk),     //50MHz时钟
   .rst_n    (rst_n),   //复位
   .data_in  (16'd0),   //要发送的数据
   .data_out (data_out),//接收到的数据
   .spi_sck  (spi_sck), //主机时钟
   .spi_miso (spi_miso),//主收从发（从机）
   .spi_mosi (spi_mosi),//主发从收（从机）
   .spi_cs   (spi_cs),  //主机片选，低有效（从机）
   .tx_en    (0),       //发送使能
   .tx_done  (tx_done), //发送完成标志位
   .rx_done  (rx_done)  //接收完成标志位
);

uart_tx_multibyte uart_tx_multibyte(
   .clk      (clk),  //时钟
   .rst_n    (rst_n),  //复位
   .data_n   (data_out),  //要发送的多字节数据
   .trans_go (rx_done),  //发送使能
   .uart_tx  (uart_tx)   //串口发送数据
);

always @(posedge clk or negedge rst_n)begin
   if(!rst_n)
      led_out <= 0;
   else if(rx_done) begin
      case(data_out)
      16'hAA01:led_out <= 8'b0000_0001;
      16'hAA02:led_out <= 8'b0000_0010;
      16'hAA03:led_out <= 8'b0000_0100;
      default:led_out <= data_out[7:0];
      endcase
   end
end

ila_spi ila_spi (
	.clk(clk), // input wire clk
	.probe0(spi_cs) // input wire [0:0] probe0
);

endmodule

推荐阅读