首页 > 其他分享 >PS端上板验证Layer0计算结果

PS端上板验证Layer0计算结果

时间：2023-07-20 23:44:45浏览次数：39  
标签：bin PS 上板 字节 DMA Xil Layer0 数据 PL

PS端上板验证Layer0计算结果

目的

- 目的：使用搭建好的上板验证工程，在PS端增加代码，对YOLO网络的第一层（Layer0）的计算结果进行验证
- 前提：SD卡中存储了YOLO网络的参数文件和输入图像数据的bin文件，这些文件需要符合上板验证工程的存储结构要求

- Layer0是一个卷积层，输入是8通道416x416的图像数据（其中5通道为0），输出是16通道208x208的特征图
- 其他层可以参考Layer0的控制方式和代码结构，完成相应的计算和验证
  • 验证YOLO网络的第一层卷积运算是否正确
  • 使用之前搭建好的上板验证工程
  • 在PS端编写代码控制PL端和DMA
  • 读取SD卡中的参数文件和输入数据文件
  • 对比PL端输出结果和Python仿真结果

准备工程

  • 修改Python代码生成适合上板验证的bin文件

    这些bin文件需要符合上板工程的要求，即每个字节对应一个通道的数据，而不是同一个通道内相邻位置像素点的数据

    例如：

    第一个字节存储第一个通道的第一行第一个像素点，

    第二个字节存储第二个通道的第一行第一个像素点，

    依次类推，

    直到第八个字节存储第八个通道的第一行第一个像素点，

    然后第九个字节存储第一个通道的第一行第二个像素点，

    以此类推

    • 图像数据：增加5个通道的全0数据，使得总通道数为8，调整存储顺序，使得每8个字节对应8个通道的同一位置的像素值

    • 权重数据：增加填充数据，使得输入通道数为8的倍数，调整存储顺序，使得每8个字节对应8个通道的同一位置的权重值

      如果输入通道数或权重通道数不是8的整数倍，需要在后面补零，使其成为8的整数倍

    • 偏置数据和激活数据：不需要修改

  • 将生成的bin文件拷贝到SD卡中

    • image_data.bin：存储输入图像数据，由原始的3通道图像数据扩展为8通道，后5个通道全为0
    • l0_b.bin：第一层偏置数据（bias），由原始的16个32位值组成
    • l0_r.bin：第一层激活数据（relu），由原始的256个8位值组成
    • l0_w.bin：第一层权重数据（weight），由原始的3x3x3x16个8位值扩展为3x3x8x16个8位值，后5个通道全为0

  • 修改后的Python代码命名为quantize_print_v2.py，生成的bin文件存放在SD_BIN_V2文件夹中

创建Vitis工程

  • 在Vivado中导出硬件信息文件（.xsa），并将其复制到Vitis文件夹下

  • 在Vitis中创建一个应用工程，选择hello world模板，并导入硬件信息文件（.xsa）

  • 在src文件夹下创建一个main.c文件，用来编写PS端的代码

  • 编写PS端代码，包括以下功能：

    • SD卡读写：使用ff.h库文件，定义SD卡读写函数，将bin文件中的数据读取到DDR3内存中

      按照以下顺序读取bin文件：image_data.bin, l0_b.bin, l0_r.bin, l0_w.bin

    • AXI Lite寄存器写：使用xil_io.h库文件，定义AXI Lite寄存器写函数，向PL端发送命令和控制信号

      按照以下顺序写入寄存器：l0_b, l0_r, l0_w, image_data, conv_start, read_start

    • DMA读写：使用XAxiDma库函数初始化DMA，发送数据给PL端或接收数据从PL端，设置中断回调函数

      先发送BIAS数据，然后发送激活数据，然后发送权重数据，然后发送图像数据。每次发送数据之前，需要先设置DMA的配置信息，包括源地址，目标地址，数据长度等。每次发送数据之后，需要等待PL端完成计算，并通过中断信号通知PS端。然后需要接收PL端计算完成后的结果数据，并存储到DDR3内存中

    • 中断响应：使用XScuGic库函数初始化中断控制器，并注册一个中断处理函数，等待PL端完成运算后触发中断，清除中断标志

      当PL端完成计算后，会向PS端发送一个中断信号，PS端在接收到中断信号后，会调用中断处理函数，在中断处理函数中，可以做一些必要的操作，例如清除中断标志位，打印一些信息等

  • PS端代码流程

    • 初始化SD卡、DMA和中断模块

      先初始化中断控制器和处理器，然后再初始化SD卡和DMA

    • 依次读取SD卡中的image_data.bin、l0_b.bin、l0_r.bin和l0_w.bin文件，并将其存储到DDR3内存中不同的地址

      • image_data.bin：0x10000000
      • l0_b.bin：0x20000000
      • l0_r.bin：0x20000040
      • l0_w.bin：0x20000200

    • 判断文件是否存在，如果不存在，打印错误信息并退出程序

    • 将BIAS数据类型（4）和数据长度（64）转换为16进制格式，使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），向PL端发送BIAS数据类型和数据长度

      先写入数据长度，再写入数据类型，因为数据类型的寄存器地址比数据长度的寄存器地址高4个字节

    • 配置DMA的控制寄存器，设置传输方向为PS到PL，传输长度为64字节，启动位为1，使用Xil_DmaSimpleTransfer函数启动DMA传输，向PL端发送BIAS数据（从DDR3地址0x20000000开始）

    • 使用Xil_DmaIsBusy函数检查DMA是否完成传输，如果完成，继续执行下一步

    • 等待PL端发出中断信号（通过InterruptHandler函数），表示接收完成

    • 将ReLU数据类型（31）和数据长度（256）转换为16进制格式，使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），向PL端发送ReLU数据类型和数据长度

      同样需要先写入数据长度，再写入数据类型

    • 配置DMA的控制寄存器，设置传输方向为PS到PL，传输长度为256字节，启动位为1，使用Xil_DmaSimpleTransfer函数启动DMA传输，向PL端发送ReLU数据（从DDR3地址0x20000040开始）

    • 使用Xil_DmaIsBusy函数检查DMA是否完成传输，如果完成，继续执行下一步

    • 等待PL端发出中断信号（通过InterruptHandler函数），表示接收完成

    • 将权重数据类型（11）和数据长度（1152）转换为16进制格式，使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），向PL端发送权重数据类型和数据长度

      同样需要先写入数据长度，再写入数据类型

    • 配置DMA的控制寄存器，设置传输方向为PS到PL，传输长度为1152字节，启动位为1，使用Xil_DmaSimpleTransfer函数启动DMA传输，向PL端发送权重数据（从DDR3地址0x20000200开始）

    • 使用Xil_DmaIsBusy函数检查DMA是否完成传输，如果完成，继续执行下一步

    • 等待PL端发出中断信号（通过InterruptHandler函数），表示接收完成

    • 循环发送图像数据：

      • 根据当前发送的批次和组数来设置Batch Type和Set Type的值

        需要注意Batch Type和Set Type是两个不同的寄存器地址，并且Batch Type是一个4位的值，而Set Type是一个8位的值

        • Batch Type：表示当前发送的是第几批图像数据（每批9行）
        • Set Type：表示当前发送的是第几组图像数据（每组416个像素点）
        • Batch Type和Set Type都是从0开始计数，并且每次发送后自增1
        • Batch Type和Set Type都是4位二进制数，并且分别占据命令字节的第7~10位 和 第11~14位

      • 将图像数据类型（0）、卷积类型（0）、Batch Type、Set Type、Code Select（0）和数据长度（29952）转换为16进制格式，使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），向PL端发送图像数据类型和数据长度

        需要注意数据长度的寄存器地址比数据类型的寄存器地址高4个字节，并且Batch Type和Set Type的寄存器地址比数据类型的寄存器地址高8个字节

        • 图像数据类型：占据命令字节的第1~4位，表示发送的是图像数据
        • 卷积类型：占据命令字节的第5~6位，表示发送的是普通卷积
        • Code Select：占据命令字节的第15~16位，表示不选择任何特殊功能
        • 数据长度：占据命令字节的第17~32位，表示发送的图像数据的字节数

      • 配置DMA的控制寄存器，设置传输方向为PS到PL，传输长度为29952字节，启动位为1，使用Xil_DmaSimpleTransfer函数启动DMA传输，向PL端发送图像数据（从DDR3地址0x10000000开始）

      • 使用Xil_DmaIsBusy函数检查DMA是否完成传输，如果完成，继续执行下一步

      • 等待PL端发出中断信号（通过InterruptHandler函数），表示接收完成

    • 循环结束后：

      • 根据当前层的卷积类型来设置Code Select的值

        需要注意Code Select是一个4位的值，并且它的寄存器地址比数据类型的寄存器地址高12个字节

        • Code Select：占据命令字节的第15~16位，表示选择特殊功能
        • 如果是普通卷积，Code Select为0
        • 如果是深度可分离卷积，Code Select为1
        • 如果是点积卷积，Code Select为2

      • 将卷积计算命令（494）转换为16进制格式，并使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），并等待PL端完成卷积计算后发出的中断信号。

        需要注意卷积计算命令是一个16位的值，并且它的寄存器地址比数据类型的寄存器地址高16个字节

        • 卷积计算命令：将命令字节的第2位设为1，表示开始卷积计算

      • 等待PL端发出中断信号（通过InterruptHandler函数），表示卷积计算完成

      • 将读取输出数据命令（2）转换为16进制格式，并使用Xil_Out32函数写入AXI Lite寄存器地址（RAG0），向PL端发送读取输出数据命令

        需要注意读取输出数据命令是一个4位的值，并且它的寄存器地址比数据类型的寄存器地址高20个字节

        • 读取输出数据命令：将命令字节的第3位设为1，表示开始读取输出数据

      • 配置DMA的控制寄存器，设置传输方向为PL到PS，传输长度为6656字节，启动位为1，使用Xil_DmaSimpleTransfer函数启动DMA传输，从PL端读取输出数据，并存储到DDR3内存中（从地址0x30000000开始）

        需要注意传输长度是6656字节而不是64字节，并且需要指定一个不同于之前的DDR3内存地址来存储输出数据

      • 使用Xil_DmaIsBusy函数检查DMA是否完成传输，如果完成，继续执行下一步

      • 等待PL端完成输出数据发送后发出的中断信号

    • 重复上述步骤，直到发送完所有的image数据，并接收完所有的输出数据

graph TD A[准备工程] --> B[创建Vitis工程] B --> C[编写PS端代码] C --> D[编译运行] A -->|使用Python代码| E[生成bin文件] E -->|存储结构符合PL端接收方式| F[每字节对应一个通道] C -->|SD卡读写| G[读取bin文件到DDR3] C -->|AXI Lite寄存器写| H[向PL端发送命令] C -->|DMA读写| I[发送或接收数据] C -->|中断响应| J[等待PL端完成计算] D -->|拷贝可执行文件和bin文件到SD卡| K[启动开发板] K -->|观察串口输出和LED灯状态| L[验证PS端代码]

main.c

#include "xparameters.h"	/* SDK generated parameters */
#include "xsdps.h"		/* SD device driver */
#include "xil_printf.h"
#include "ff.h"
#include "xil_cache.h"
#include "xplatform_info.h"
#include "xil_io.h"
#include "xaxidma.h"
#include "xil_types.h"
#include "xil_exception.h"
#include "xil_cache.h"
#include "xscugic.h"


#define INTC_DEVICE_ID		XPAR_SCUGIC_0_DEVICE_ID
#define INTC_DEVICE_INT_ID	XPS_FPGA0_INT_ID


XScuGic InterruptController; 	     /* Instance of the Interrupt Controller */
static XScuGic_Config *GicConfig;    /* The configuration parameters of the
                                       controller */
volatile static int InterruptProcessed = FALSE;
void DeviceDriverHandler(void *CallbackRef);
int Intr_init();
void wait_pl_finish();

static FIL fil;		/* File object */
static FATFS fatfs;

#define	Lite_Reg0			XPAR_AXI4_LITE_V1_0_0_BASEADDR
#define	Lite_Reg1			XPAR_AXI4_LITE_V1_0_0_BASEADDR+0x4
#define	Lite_Reg2			XPAR_AXI4_LITE_V1_0_0_BASEADDR+0x8

static char FileName0[32] = "img_data.bin";
static char FileName1[32] = "l0_b.bin";
static char FileName2[32] = "l0_r.bin";
static char FileName3[32] = "l0_w.bin";

int SD_Init();
int SD_Write(char *FileName, u32 SourceAddress, u32 FileSize);
int SD_Read(char *FileName, u32 DestinationAddress, u32 FileSize);

void DMA_Init();
void DMA_Tx(u32 TxAddr, u32 Length);
void DMA_Rx(u32 RxAddr, u32 Length);

int main()
{
	SD_Init();
	DMA_Init();
	Intr_init();
	// 读取Bin文件至 DDR3内存
	SD_Read(FileName0, 0x1000000, 1384448);
	SD_Read(FileName1, 0x2000000, 64);
	SD_Read(FileName2, 0x2000040, 256);
	SD_Read(FileName3, 0x2000140, 1152);

	Xil_Out32(Lite_Reg2, 0x09004100);
	Xil_Out32(Lite_Reg1, 0x4B5A0000);
	Xil_Out32(Lite_Reg0, 0x21);			// 发送bias数据
	DMA_Tx(0x2000000, 64);
	wait_pl_finish();

	Xil_Out32(Lite_Reg0, 0x31);			// 发送LeakyRelu数据
	DMA_Tx(0x2000040, 256);
	wait_pl_finish();

	Xil_Out32(Lite_Reg0, 0x11);			// 发送Weight数据
	DMA_Tx(0x2000140, 1152);
	wait_pl_finish();

	Xil_Out32(Lite_Reg0, 0x101181);		// 发送Feature数据
	DMA_Tx(0x1000000, 29952);
	wait_pl_finish();
	Xil_Out32(Lite_Reg0, 0x101184);		// 卷积计算
	wait_pl_finish();

	Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
	DMA_Rx(0x3000000, 6656);			// 9行数据+1行填充=10行数据 --->卷积后，8个416的数据量---》经过池化后，变成4*208---> 总共8个通道，即最终数据量4*208*8=6656
	wait_pl_finish();

	// 不包含第一次发送和最后一次发送数据的计算过程，共循环58次
	int tx_addr = 0x1000000;
	int rx_addr = 0x3000000;
	for(int i=0; i<=57; i++) {
		Xil_Out32(Lite_Reg0, 0x101381);			// 发送Feature数据
		tx_addr = tx_addr + 23296;
		DMA_Tx(tx_addr, 29952);
		wait_pl_finish();
		Xil_Out32(Lite_Reg0, 0x101384);			// 卷积计算
		wait_pl_finish();
		if(i%2 == 0) {
			rx_addr = rx_addr + 6656;
			Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
			DMA_Rx(rx_addr, 4992);				//
			wait_pl_finish();
		}
		else {
			rx_addr = rx_addr + 4992;
			Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
			DMA_Rx(rx_addr, 6656);
			wait_pl_finish();
		}
	}

	// Layer0 前8个输出通道的最后一次发送数据
	tx_addr = tx_addr + 23296;
	Xil_Out32(Lite_Reg0, 0x41581);		// 发送Feature数据
	DMA_Tx(tx_addr, 9984);
	wait_pl_finish();
	Xil_Out32(Lite_Reg0, 0x41584);		// 卷积计算
	wait_pl_finish();
	rx_addr = rx_addr + 6656;
	Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
	DMA_Rx(rx_addr, 1664);
	wait_pl_finish();
//////////////////////////////////////////////////////////
	Xil_Out32(Lite_Reg1, 0x4B5A0101);
	Xil_Out32(Lite_Reg0, 0x101181);		// 发送Feature数据
	DMA_Tx(0x1000000, 29952);
	wait_pl_finish();
	Xil_Out32(Lite_Reg0, 0x101184);		// 卷积计算
	wait_pl_finish();

	Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
	DMA_Rx(0x3054800, 6656);			// 9行数据+1行填充=10行数据 --->卷积后，8个416的数据量---》经过池化后，变成4*208---> 总共8个通道，即最终数据量4*208*8=6656
	wait_pl_finish();

	// 不包含第一次发送和最后一次发送数据的计算过程，共循环58次
	tx_addr = 0x1000000;
	rx_addr = 0x3054800;
	for(int i=0; i<=57; i++) {
		Xil_Out32(Lite_Reg0, 0x101381);			// 发送Feature数据
		tx_addr = tx_addr + 23296;
		DMA_Tx(tx_addr, 29952);
		wait_pl_finish();
		Xil_Out32(Lite_Reg0, 0x101384);			// 卷积计算
		wait_pl_finish();
		if(i%2 == 0) {
			rx_addr = rx_addr + 6656;
			Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
			DMA_Rx(rx_addr, 4992);				//
			wait_pl_finish();
		}
		else {
			rx_addr = rx_addr + 4992;
			Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
			DMA_Rx(rx_addr, 6656);
			wait_pl_finish();
		}
	}

	// Layer0 前8个输出通道的最后一次发送数据
	tx_addr = tx_addr + 23296;
	Xil_Out32(Lite_Reg0, 0x41581);		// 发送Feature数据
	DMA_Tx(tx_addr, 9984);
	wait_pl_finish();
	Xil_Out32(Lite_Reg0, 0x41584);		// 卷积计算
	wait_pl_finish();
	rx_addr = rx_addr + 6656;
	Xil_Out32(Lite_Reg0, 0x2);			// 将PL端的数据传至PS端
	DMA_Rx(rx_addr, 1664);
	wait_pl_finish();

	Xil_DCacheFlushRange(0x3054800, 0x54800);

	return 0;

}

int SD_Init()
{
	FRESULT Res;
	/*
	 * To test logical drive 0, Path should be "0:/"
	 * For logical drive 1, Path should be "1:/"
	 */
	TCHAR *Path = "0:/";

	/*
	 * Register volume work area, initialize device
	 */
	Res = f_mount(&fatfs, Path, 0);

	if (Res != FR_OK) {
		return XST_FAILURE;
	}

	/*
	 * Path - Path to logical driver, 0 - FDISK format.
	 * 0 - Cluster size is automatically determined based on Vol size.
	 */
//	Res = f_mkfs(Path, FM_FAT32, 0, work, sizeof work);
//	if (Res != FR_OK) {
//		return XST_FAILURE;
//	}
	return XST_SUCCESS;
}

int SD_Write(char *FileName, u32 SourceAddress, u32 FileSize)
{
	FRESULT Res;
	UINT NumBytesWritten;

	Res = f_open(&fil, FileName, FA_CREATE_ALWAYS | FA_WRITE);
	if (Res) {
		return XST_FAILURE;
	}

	/*
	 * Pointer to beginning of file .
	 */
	Res = f_lseek(&fil, 0);
	if (Res) {
		return XST_FAILURE;
	}

	/*
	 * Write data to file.
	 */
	Res = f_write(&fil, (const void*)SourceAddress, FileSize,
			&NumBytesWritten);
	if (Res) {
		return XST_FAILURE;
	}


	/*
	 * Close file.
	 */
	Res = f_close(&fil);
	if (Res) {
		return XST_FAILURE;
	}

	return XST_SUCCESS;
}

int SD_Read(char *FileName, u32 DestinationAddress, u32 FileSize)
{
	FRESULT Res;
	UINT NumBytesRead;

	Res = f_open(&fil, FileName, FA_READ);
	if (Res) {
		return XST_FAILURE;
	}

	/*
	 * Pointer to beginning of file .
	 */
	Res = f_lseek(&fil, 0);
	if (Res) {
		return XST_FAILURE;
	}

	/*
	 * Write data to file.
	 */
	Res = f_read(&fil, (const void*)DestinationAddress, FileSize,
			&NumBytesRead);
	if (Res) {
		return XST_FAILURE;
	}


	/*
	 * Close file.
	 */
	Res = f_close(&fil);
	if (Res) {
		return XST_FAILURE;
	}

	return XST_SUCCESS;
}

void DMA_Init()
{
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_TX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_CR_RESET_MASK);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_RX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_CR_RESET_MASK);


	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_TX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_IRQ_ALL_MASK);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_RX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_IRQ_ALL_MASK);

	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_TX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_CR_RUNSTOP_MASK);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_RX_OFFSET+XAXIDMA_CR_OFFSET, XAXIDMA_CR_RUNSTOP_MASK);
}


void DMA_Tx(u32 TxAddr, u32 Length)
{
	Xil_DCacheFlushRange(TxAddr, Length);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_TX_OFFSET+XAXIDMA_SRCADDR_OFFSET, TxAddr);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_TX_OFFSET+XAXIDMA_BUFFLEN_OFFSET, Length);
}

void DMA_Rx(u32 RxAddr, u32 Length)
{
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_RX_OFFSET+XAXIDMA_DESTADDR_OFFSET, RxAddr);
	Xil_Out32(XPAR_AXIDMA_0_BASEADDR+XAXIDMA_RX_OFFSET+XAXIDMA_BUFFLEN_OFFSET, Length);
}

void DeviceDriverHandler(void *CallbackRef)
{
	/*
	 * Indicate the interrupt has been processed using a shared variable
	 */
	InterruptProcessed = TRUE;
}

int Intr_init()
{
	int Status;

	/*
	 * Initialize the interrupt controller driver so that it is ready to
	 * use.
	 */
	GicConfig = XScuGic_LookupConfig(INTC_DEVICE_ID);
	if (NULL == GicConfig) {
		return XST_FAILURE;
	}

	Status = XScuGic_CfgInitialize(&InterruptController, GicConfig,
					GicConfig->CpuBaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}


	Xil_ExceptionInit();
	/*
	 * Connect the interrupt controller interrupt handler to the hardware
	 * interrupt handling logic in the ARM processor.
	 */
	Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
			(Xil_ExceptionHandler) XScuGic_InterruptHandler,
			&InterruptController);

	/*
	 * Enable interrupts in the ARM
	 */
	Xil_ExceptionEnable();

	/*
	 * Connect a device driver handler that will be called when an
	 * interrupt for the device occurs, the device driver handler performs
	 * the specific interrupt processing for the device
	 */
	Status = XScuGic_Connect(&InterruptController, INTC_DEVICE_INT_ID,
			   (Xil_ExceptionHandler)DeviceDriverHandler,
			   (void *)&InterruptController);

	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	XScuGic_SetPriTrigTypeByDistAddr(&InterruptController, INTC_DEVICE_INT_ID, 0x0, 0x3);

	/*
	 * Enable the interrupt for the device and then cause (simulate) an
	 * interrupt so the handlers will be called
	 */
	XScuGic_Enable(&InterruptController, INTC_DEVICE_INT_ID);

	return 0;
}

void wait_pl_finish()
{
	while(InterruptProcessed == FALSE);
	InterruptProcessed = FALSE;
}

目

标签：bin,PS,上板,字节,DMA,Xil,Layer0,数据,PL
From： https://www.cnblogs.com/LiamJacob/p/17570013.html

相关文章

  • 我的章管家AppStore技术支持
    我的章管家，一键生成电子印章【产品功能】输入名称和编号，可一键生成印章：可以查看我的印章列表，预览印章效果，复制印章文本信息，可以创建印章，删除印章，保存印章到手机相册。如果您在使用过程中有问题请留言或发邮件给我谢谢!Ifyouhaveanyquestions,pleaseleaveamessageorsendm......
  • NoSuchMethodError: javax.servlet.http.HttpServletRequest.getHttpServletMappi
    NoSuchMethodError:javax.servlet.http.HttpServletRequest.getHttpServletMapping1.介绍在Java应用程序中，可能会遇到javax.servlet.http.HttpServletRequest.getHttpServletMapping方法引发的NoSuchMethodError异常。这个异常通常是由于servletAPI版本不兼容导致的。本文将详......
  • 喜报｜ 无限极入选信通院 2023 XOps“领新杯”业技融合攻坚先锋案例
    点击链接了解详情2023年7月，腾讯云CODING联合无限极参加中国信通院2023XOps“领新杯”案例评选活动，无限极从一百多家参选厂商中脱颖而出，高分荣获“业技融合攻坚先锋案例”奖项，并在7月18日信通院隆重举办的2023XOps产业创新发展论坛上正式颁奖。客户背景无限极......
  • qForms tips
    官方教程http://www.pengoworks.com/qforms/docs/index.htm1set和getform中的field的代码本来obj.fieldName.getValue()可以用来获取form中某个field的值，用obj.fieldName.setValue()可以用来设置form中某个field的值。如js为：functiontestqForm(){alert(wfqForm.tex......
  • java “HttpServletRequest”中删除“授权”标头
    JavaHttpServletRequest中删除授权标头在Java的Web开发中，我们经常使用HttpServletRequest对象来处理HTTP请求。HttpServletRequest对象提供了许多方法来获取请求的信息，包括请求头信息。有时候我们需要从请求头中删除某些特定的标头，本文将介绍如何在HttpServletRequest中删除授权......
  • appsmith使用第三方库进行http请求
    安装使用exportdefault{ debugMeter:async()=>{ letrID=Number(Select1.selectedOptionValue); letmetricName=Input6.text; letmeterAsset=Input7.text; letbusAddr=Input8.text; letmeterAddr=Number(Input9.text); letregisterAddr=......
  • 【高并发项目】面对 QPS 太高我该怎么办？
    ......
  • HTTPS chatgpt
    对于HTTPS协议的底层实现，需要同时使用TCP和SSL/TLS协议来提供安全的通信。TCP协议用于建立可靠的网络连接，而SSL/TLS则用于对数据进行加密和身份验证。在C++中，你可以使用OpenSSL库来实现HTTPS的底层支持。OpenSSL提供了丰富的功能和API，可以用于处理SSL/TLS连接......
  • Mac/Ubuntu18.04使用privoxy将socks转为https、http和ftp代理
    转载：https://blog.csdn.net/gongchenyu/article/details/80482981privoxy可以转换socks代理1.将socks代理地址设置为127.0.0.1:1080。2.安装privoxyUbuntu$sudoaptinstallprivoxy1Mac$brewinstallprivoxy13.更改provoxy配置Ubuntu$sudovi/etc/privoxy/config1Mac$......
  • Java开发工具MyEclipse发布v2023.1.2，今年第二个修复版！
    MyEclipse一次性提供了巨量的Eclipse插件库，无需学习任何新的开发语言和工具，便可在一体化的IDE下进行JavaEE、Web和PhoneGap移动应用的开发；强大的智能代码补齐功能，让企业开发化繁为简。MyEclipsev2023.1.2官方正式版下载更新日志如下：v2023.1.2是MyEclipse2023的一个小错误修......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99