xapp1052之dma_test.v

dma_test.v是Xilinx FPGA设计中针对DMA功能的仿真测试文件,涵盖DMA写、读数据测试。该测试通过模拟PC应用程序与FPGA的DMA交互,初始化配置寄存器,设置DMA写操作的起始地址、数据长度和TLP数量,以完成DMA写操作的流程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

    dma_test是针对dma硬件设计的仿真测试文件,文件包括DMA写数据测试,DMA读数据测试以及DMA读写数据测试。这个测试文件其实就是模拟pc的应用程序对fpga设备进行DMA读写。

    DMA写测试指的是fpga设备往pc端进行DMA方式的写数据,而不是pc端往fpga设备中进行读写,这点要弄清。dma写测试的选择如下所示:

else if (testname == "dma_mwr_test")
    在写测试中,仿真文件模仿了操作系统对pcie设备操作的整个流程:

    首先:测试文件会对fpga设备中的配置寄存器进行赋值,例如BAR寄存器,command寄存器。在TSK_BAT_INIT任务里面其实是在模拟BIOS和驱动程序的操作,首先会对BAR寄存器进行赋值,然后会对BAR指向的设备内存进行IO或者mem映射,最后就是对设备的配置寄存器的参数写入。

TSK_BAT_INIT; // pci_exp_usrapp_tx.v 2281
board.RP.cfg_usrapp.TSK_WRITE_CFG_DW(32'h00000004,32'h00000007,4'b1110); // pci_exp_usrapp_cfg.v 226
TSK_TX_TYPE0_CONFIGURATION_WRITE(DEFAULT_TAG,12'h04,P_READ_DATA[31:0],4'hF); // pci_exp_usrapp_tx.v 522
    然后:测试文件会进行写DMA配置操作,在执行DMA操作之前,是需要利用PIO的方式对fpga设备进行初始化的,初始化的数据存放在BAR空间中,即设备的内存中
#include "user_include.h" #include "user_spi.h" /* SPI通道配置 */ /*▲▲▲*/#define TEST_SPIx SPI4 /*▲▲▲*/#define TSET_SPIx_IRQn SPI4_IRQn /*▲▲▲*/#define TEST_SPIx_DMA_RX_HS DMA_HS_SPI4_RX /*▲▲▲*/#define TEST_SPIx_DMA_TX_HS DMA_HS_SPI4_TX /* SPI工作模式 */ /*▲▲▲*/#define TEST_SPIx_IT_MODE 0x00 //0 阻塞模式: 0x00仅发送 0x01仅接收 0x02发送接收 //1 中断模式: 0x10仅发送 0x11仅接收 0x12发送接收 //2 DMA模式: 0x20仅发送 0x21仅接收 0x22发送接收 static SPI_HandleTypeDef hspi; #if TEST_SPIx_IT_MODE == 0x10 || TEST_SPIx_IT_MODE == 0x11 || TEST_SPIx_IT_MODE == 0x12 \ || TEST_SPIx_IT_MODE == 0x20 || TEST_SPIx_IT_MODE == 0x21 || TEST_SPIx_IT_MODE == 0x22 //中断服务函数标志位 static uint8_t Transmit_done_flg = 1; static uint8_t Receive_done_flg = 1; static void TEMPLATE_SPI_IRQHandler(void) { HAL_SPI_IRQHandler(&hspi); } void TEST_HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) { Transmit_done_flg = 1; } void TEST_HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) { Receive_done_flg = 1; } void TEST_HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) /* 未使用20240814 */ { rt_kprintf("RXTX cpl\n"); } void TEST_HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) { rt_kprintf("ERROR=%d\n",hspi->ErrorCode); } static void gc9005_dma_config(void); #endif //发送数据定义 /*▲▲▲*/#define Test_hal_spi_txDataSize 64 // 发送的数据长度 rt_align(64) static uint8_t data_tx[Test_hal_spi_txDataSize]= {0}; //任何DMA模式必须对齐rt_align(64) //接收数据定义 /*▲▲▲*/#define Test_hal_spi_rxDataSize 64 //接收的数据长度 rt_align(64) static uint8_t data_rx[Test_hal_spi_rxDataSize] = {0}; //任何DMA模式必须对齐rt_align(64) //发送接收数据定义 /*▲▲▲*/#define Test_hal_spi_txrxDataSize 64 //发送接收的数据长度 #define mc33996_txDataSize 3 // 发送的数据长度 #define CHIP_NUM 4 static uint8_t mc33996_data[mc33996_txDataSize]= {0}; static uint32_t cs_pins[CHIP_NUM] = {CS3_PIN, CS4_PIN, CS1_PIN, CS2_PIN}; static uint32_t chip_channel_states[CHIP_NUM] = {0}; static uint32_t MC33996_states = 0; static void template_hal_spi_thread(void* parameter) { uint8_t i = 0; uint8_t id = 0; uint8_t ret = 0; uint8_t spi_ret = 0; uint32_t spi_clk = 0; rt_kprintf("Hello SPI\n"); HAL_SPI_StructInit(&hspi); hspi.Instance = TEST_SPIx; /*▲▲▲*/hspi.Init.Mode = SPI_MODE_MASTER;//SPI_MODE_MASTER SPI_MODE_SLAVE /*▲▲▲*/hspi.Init.DataSize = SPI_DATASIZE_8BIT; /*▲▲▲*/hspi.Init.FrameFormat = SPI_FRF_MOTOROLA; /*▲▲▲*/hspi.Init.SPO = SPI_SPO_LOW; /*▲▲▲*/hspi.Init.SPH = SPI_SPH_1EDGE; //baudrate = Fspiclk / (CPSDVR * (1 + SCR)) hspi.Init.CPSDVR = 0x10; // 时钟预分频系数 取值范围2-254之前的偶数 hspi.Init.SCR = 0x7; // Clock pre-frequency dividing parameters /*▲▲▲*/spi_clk = 1000; //HAL_RCC_GetAPBClock这个接口第二个参数是spi目标clk if (hspi.Instance == SPI0) { id = 0; } else if (hspi.Instance == SPI1) { id = 1; } else if (hspi.Instance == SPI2) { id = 2; } else if (hspi.Instance == SPI3) { id = 3; } else if (hspi.Instance == SPI4) { id = 4; } if(HAL_RCC_ConfigSPICLK(id, spi_clk, &hspi.Init.CPSDVR, &hspi.Init.SCR) != HAL_OK) { rt_kprintf("spi clk error\n",ret); } HAL_SPI_Init(&hspi); #if TEST_SPIx_IT_MODE == 0x00 while(1) { if(Global_Falg_t.Mc33996_on == 1) { Global_Falg_t.Mc33996_on = 0; memset(chip_channel_states,0,sizeof(chip_channel_states)); for (uint8_t chip = 0; chip < CHIP_NUM; chip++) { for (uint8_t channel = 0; channel < 16; channel++) { chip_channel_states[chip] |= (1 << channel); // mc33996_data[0] = 0; mc33996_data[0] = 0x00; // 高8位命令码 mc33996_data[1] = (chip_channel_states[chip] >> 8) & 0xFF; // 状态高8位 mc33996_data[2] = chip_channel_states[chip] & 0xFF; // 状态低8位 HAL_GPIO_WritePin(CS_GPIO_PORT, cs_pins[chip], GPIO_PIN_RESET); udelay(100); HAL_SPI_Transmit(&hspi, mc33996_data, mc33996_txDataSize, HAL_MAX_DELAY); udelay(10); HAL_GPIO_WritePin(CS_GPIO_PORT, cs_pins[chip], GPIO_PIN_SET); rt_kprintf(" 发送数据: 0x%02X 0x%02X 0x%02X\n", mc33996_data[1], mc33996_data[2], mc33996_data[3]); rt_thread_mdelay(100); } } } else if (Global_Falg_t.Mc33996_off == 1) { Global_Falg_t.Mc33996_off = 0; for (uint8_t chip = 0; chip < CHIP_NUM; chip++) { // mc33996_data[0] = 0; mc33996_data[0] = 0x00; // 高8位命令码 mc33996_data[1] = 0; // 状态高8位 mc33996_data[2] = 0; // 状态低8位 HAL_GPIO_WritePin(CS_GPIO_PORT, cs_pins[chip], GPIO_PIN_RESET); udelay(100); HAL_SPI_Transmit(&hspi, mc33996_data, mc33996_txDataSize, HAL_MAX_DELAY); udelay(10); HAL_GPIO_WritePin(CS_GPIO_PORT, cs_pins[chip], GPIO_PIN_SET); } } rt_thread_mdelay(1000); } #elif TEST_SPIx_IT_MODE == 0x01 //使用USB转SPI I2C工具hspi.Init.Mode=SPI_MODE_SLAVE,并使用测试设备的高级发送窗口(NSS低→NSS高); //使用USB转SPI I2C工具hspi.Init.Mode=SPI_MODE_MASER,并使用测试设备的从发送配置 //2块开发板对发: while (1) { ret = HAL_SPI_Receive(&hspi, data_rx, Test_hal_spi_rxDataSize, HAL_MAX_DELAY); if(ret == HAL_OK) { rt_kprintf("\n"); rt_kprintf("ret = %d, rx pass\n",ret); for(i = 0; i < Test_hal_spi_rxDataSize; i++) { rt_kprintf("data_rx[%d]=0x%x\n", i, data_rx[i]); } } else { rt_kprintf("ret = %d, rx fail\n",ret); } rt_thread_mdelay(1000); } #elif TEST_SPIx_IT_MODE == 0x02 for(i=0;i<Test_hal_spi_txrxDataSize;i++) { data_tx[i] = i + 0x30; } while (1) { ret = HAL_SPI_TransmitReceive(&hspi, data_tx, data_rx, Test_hal_spi_txrxDataSize, HAL_MAX_DELAY); if(ret == HAL_OK) { rt_kprintf("\n"); rt_kprintf("ret = %d, txrx pass\n",ret); for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_rx[%d]=0x%x\n",i,data_rx[i]); } for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_tx[%d]=0x%x\n",i,data_tx[i]); } } else { rt_kprintf("ret = %d, txrx fail\n",ret); } rt_thread_mdelay(1000); } #elif TEST_SPIx_IT_MODE == 0x10 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 0, TEMPLATE_SPI_IRQHandler); uint16_t config_data = 0x0406; // 配置寄存器值 uint16_t channel_state = 0x0000; // 初始所有通道关闭 // 发送配置命令 HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_RESET); ndelay(100); spi_ret = HAL_SPI_Transmit_IT(&hspi, (uint8_t*)&config_data, 2); rt_kprintf("spi_ret=%d\n",spi_ret); HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_SET); rt_thread_mdelay(10); while (1) { // uint16_t tx_data = 0x4000 | 0x3FFF; // 0x4000 | 0x3FFF = 0x7FFF // // HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_RESET); // ndelay(100); // spi_ret = HAL_SPI_Transmit_IT(&hspi, (uint8_t*)&tx_data, 2); // rt_kprintf("spi_ret=%d\n",spi_ret); // HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_SET); for (i = 13; i >= 0; i--) { // 从OUT1到OUT14 (13~0位) channel_state |= (1 << i); // 开启当前通道 uint16_t tx_data = 0x4000 | channel_state; // 命令码+通道状态 HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_RESET); ndelay(100); spi_ret = HAL_SPI_Transmit_IT(&hspi, (uint8_t*)&tx_data, 2); rt_kprintf("spi_ret=%d\n",spi_ret); HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_SET); rt_thread_mdelay(100); } if(Global_Falg_t.Mc33996_on == 1) { Global_Falg_t.Mc33996_on = 0; mc33996_data[0] = ( 0x01FFFF >> 16) & 0xFF; // 第23-16位(命令类型) mc33996_data[1] = ( 0x01FFFF >> 8) & 0xFF; // 第15-8位(输出状态高8位) mc33996_data[2] = 0x01FFFF & 0xFF; // 第7-0位(输出状态低8位 HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS2_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS2_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS3_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS3_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS4_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS4_PIN, GPIO_PIN_SET); } else if (Global_Falg_t.Mc33996_off == 1) { Global_Falg_t.Mc33996_off = 0; mc33996_data[0] = ( 0x010000 >> 16) & 0xFF; // 第23-16位(命令类型) mc33996_data[1] = ( 0x010000 >> 8) & 0xFF; // 第15-8位(输出状态高8位) mc33996_data[2] = 0x010000 & 0xFF; // 第7-0位(输出状态低8位 HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS1_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS2_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS2_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS3_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS3_PIN, GPIO_PIN_SET); HAL_GPIO_WritePin(CS_GPIO_PORT, CS4_PIN, GPIO_PIN_RESET); HAL_SPI_Transmit_IT(&hspi, mc33996_data, mc33996_txDataSize); HAL_GPIO_WritePin(CS_GPIO_PORT, CS4_PIN, GPIO_PIN_SET); } rt_thread_mdelay(100); //因操作系统原因,本处禁用HAL_Delay } #elif TEST_SPIx_IT_MODE == 0x11 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 1, TEMPLATE_SPI_IRQHandler); while (1) { if(Receive_done_flg == 1) { Receive_done_flg = 0; ret = HAL_SPI_Receive_IT(&hspi, data_rx, Test_hal_spi_rxDataSize); if(ret == HAL_OK) { rt_kprintf("ret = %d\n",ret); for(i=0;i<Test_hal_spi_rxDataSize;i++) { rt_kprintf("data_rx[%d]=0x%x\n",i,data_rx[i]); } } else { rt_kprintf("ret = %d\n",ret); } } rt_thread_mdelay(1000); //因操作系统原因,本处禁用HAL_Delay } #elif TEST_SPIx_IT_MODE == 0x12 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 1, TEMPLATE_SPI_IRQHandler); for(i = 0; i < Test_hal_spi_txDataSize; i++) { data_tx[i] = i + 0x60; } while (1) { if(Transmit_done_flg == 1 && Receive_done_flg == 1) { Transmit_done_flg = 0; Receive_done_flg = 0; ret = HAL_SPI_TransmitReceive_IT(&hspi, data_tx, data_rx, Test_hal_spi_txrxDataSize); if( ret == HAL_OK) { rt_kprintf("\n"); rt_kprintf("ret = %d\n",ret); for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_rx[%d]=0x%x\n",i,data_rx[i]); } for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_tx[%d]=0x%x\n",i,data_tx[i]); } } else { rt_kprintf("ret = %d\n",ret); } } rt_thread_mdelay(1000); //因操作系统原因,本处禁用HAL_Delay } #elif TEST_SPIx_IT_MODE == 0x20 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 1, TEMPLATE_SPI_IRQHandler); gc9005_dma_config(); while (1) { for(i = 0; i < Test_hal_spi_txDataSize; i++) { data_tx[i] = i + 0x60; } if(Transmit_done_flg == 1) { Transmit_done_flg = 0; ret = HAL_SPI_Transmit_DMA(&hspi, data_tx, Test_hal_spi_txDataSize); if(ret == HAL_OK) { rt_kprintf("ret = %d, tx pass\n",ret); } else { rt_kprintf("ret = %d, tx fail\n",ret); } } rt_thread_mdelay(1000); //因操作系统原因,本处禁用HAL_Delay } #elif TEST_SPIx_IT_MODE == 0x21 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 1, TEMPLATE_SPI_IRQHandler); gc9005_dma_config(); while (1) { if(Receive_done_flg == 1) { Receive_done_flg = 0; ret = HAL_SPI_Receive_IT(&hspi, data_rx, Test_hal_spi_rxDataSize); if(ret == HAL_OK) { rt_kprintf("ret = %d\n",ret); for(i=0;i<Test_hal_spi_rxDataSize;i++) { rt_kprintf("data_rx[%d]=0x%x\n",i,data_rx[i]); //接收快了容易死 } } else { rt_kprintf("ret = %d\n",ret); } } rt_thread_mdelay(1000); //因操作系统原因,本处禁用HAL_Delay } #elif TEST_SPIx_IT_MODE == 0x22 HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_COMPLETE_CB_ID, TEST_HAL_SPI_TxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_RX_COMPLETE_CB_ID, TEST_HAL_SPI_RxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_TX_RX_COMPLETE_CB_ID, TEST_HAL_SPI_TxRxCpltCallback); HAL_SPI_RegisterCallback(&hspi, HAL_SPI_ERROR_CB_ID, TEST_HAL_SPI_ErrorCallback); ECLIC_Register_IRQ(TSET_SPIx_IRQn, ECLIC_NON_VECTOR_INTERRUPT, ECLIC_LEVEL_TRIGGER, 2, 1, TEMPLATE_SPI_IRQHandler); gc9005_dma_config(); for(i = 0; i < Test_hal_spi_txDataSize; i++) { data_tx[i] = i + 0x60; } while (1) { if(Transmit_done_flg == 1 && Receive_done_flg == 1) { Transmit_done_flg = 0; Receive_done_flg = 0; ret = HAL_SPI_TransmitReceive_IT(&hspi, data_tx, data_rx, Test_hal_spi_txrxDataSize); if( ret == HAL_OK) { rt_kprintf("\n"); rt_kprintf("ret = %d\n",ret); for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_rx[%d]=0x%x\n",i,data_rx[i]); } for(i=0;i<Test_hal_spi_txrxDataSize;i++) { rt_kprintf("data_tx[%d]=0x%x\n",i,data_tx[i]); } } else { rt_kprintf("ret = %d\n",ret); } } rt_thread_mdelay(1000); //因操作系统原因,本处禁用HAL_Delay } #endif } #if TEST_SPIx_IT_MODE == 0x10 || TEST_SPIx_IT_MODE == 0x11 || TEST_SPIx_IT_MODE == 0x12 \ || TEST_SPIx_IT_MODE == 0x20 || TEST_SPIx_IT_MODE == 0x21 || TEST_SPIx_IT_MODE == 0x22 static DMA_HandleTypeDef spi2_tx_hdma; static DMA_HandleTypeDef spi2_rx_hdma; static void gc9005_dma_config(void) { /*---spi0-TX-DMA--------------------------------------------------------------------------------------------*/ rt_memset(&spi2_tx_hdma, 0, sizeof(DMA_HandleTypeDef)); spi2_tx_hdma.Instance = DMA; HAL_DMA_StructInit(&(spi2_tx_hdma.Init)); __HAL_LINKDMA(&hspi, hdmatx, spi2_tx_hdma); spi2_tx_hdma.Init.mChannel = DMA_CHANNEL0; spi2_tx_hdma.Init.mS_Address = 0;/*!< Specifies Source Address. */ spi2_tx_hdma.Init.mD_Address = 0;/*!< Specifies Destination Address. */ spi2_tx_hdma.Init.mBlockSize = 0; spi2_tx_hdma.Init.mS_TransferWidth = DMA_TR_WIDTH_8bits; spi2_tx_hdma.Init.mD_TransferWidth = DMA_TR_WIDTH_8bits; spi2_tx_hdma.Init.mSBurstLength = 0UL; spi2_tx_hdma.Init.mDBurstLength = 0UL;/*!< [0 ~ DMAX_CHx_MAX_AMBA_BURST_LENGTH]*/ spi2_tx_hdma.Init.mSBurstLength_EN = DMA_ENABLE; spi2_tx_hdma.Init.mDBurstLength_EN = DMA_ENABLE; spi2_tx_hdma.Init.mNonPostedLastWrite_EN = DMA_DISABLE; spi2_tx_hdma.Init.mS_BurstTransactionLen = DMA_DATA_ITEMS_4; spi2_tx_hdma.Init.mD_BurstTransactionLen = DMA_DATA_ITEMS_4; spi2_tx_hdma.Init.mS_OutstandingRequestLimit = 4; spi2_tx_hdma.Init.mD_OutstandingRequestLimit = 4; spi2_tx_hdma.Init.mS_AddrInc = DMA_INCREMENTAL; spi2_tx_hdma.Init.mD_AddrInc = DMA_FIXED; spi2_tx_hdma.Init.mChannelPriority = spi2_tx_hdma.Init.mChannel; spi2_tx_hdma.Init.mTransferType_FlowControl = DMA_TT_MEM_TO_PER_DMAC; spi2_tx_hdma.Init.mS_Peripheral = DMA_HS_MEMORY; spi2_tx_hdma.Init.mD_Peripheral = TEST_SPIx_DMA_TX_HS; spi2_tx_hdma.Init.mEnable = DMA_DISABLE; HAL_DMA_Init(&spi2_tx_hdma); __HAL_DMA_CHX_DISABLE_IT(&spi2_tx_hdma, DMA_CH_INT_ALL); __HAL_DMA_CHX_ENABLE_IT(&spi2_tx_hdma, DMA_CH_INT_DMA_TFR_DONE); rt_dma_node_register(&spi2_tx_hdma); /*---spi0-RX-DMA--------------------------------------------------------------------------------------------*/ rt_memset(&spi2_rx_hdma, 0, sizeof(DMA_HandleTypeDef)); spi2_rx_hdma.Instance = DMA; HAL_DMA_StructInit(&(spi2_rx_hdma.Init)); __HAL_LINKDMA(&hspi, hdmarx, spi2_rx_hdma); spi2_rx_hdma.Init.mChannel = DMA_CHANNEL1; spi2_rx_hdma.Init.mS_Address = 0;/*!< Specifies Source Address. */ spi2_rx_hdma.Init.mD_Address = 0;/*!< Specifies Destination Address. */ spi2_rx_hdma.Init.mBlockSize = 0; spi2_rx_hdma.Init.mS_TransferWidth = DMA_TR_WIDTH_8bits; spi2_rx_hdma.Init.mD_TransferWidth = DMA_TR_WIDTH_8bits; spi2_rx_hdma.Init.mSBurstLength = 0UL; spi2_rx_hdma.Init.mDBurstLength = 0UL;/*!< [0 ~ DMAX_CHx_MAX_AMBA_BURST_LENGTH]*/ spi2_rx_hdma.Init.mSBurstLength_EN = DMA_ENABLE; spi2_rx_hdma.Init.mDBurstLength_EN = DMA_ENABLE; spi2_rx_hdma.Init.mNonPostedLastWrite_EN = DMA_DISABLE; spi2_rx_hdma.Init.mS_BurstTransactionLen = DMA_DATA_ITEMS_4; spi2_rx_hdma.Init.mD_BurstTransactionLen = DMA_DATA_ITEMS_4; spi2_rx_hdma.Init.mS_OutstandingRequestLimit = 4; spi2_rx_hdma.Init.mD_OutstandingRequestLimit = 4; spi2_rx_hdma.Init.mS_AddrInc = DMA_FIXED; spi2_rx_hdma.Init.mD_AddrInc = DMA_INCREMENTAL; spi2_rx_hdma.Init.mChannelPriority = spi2_rx_hdma.Init.mChannel; spi2_rx_hdma.Init.mTransferType_FlowControl = DMA_TT_PER_TO_MEM_DMAC; spi2_rx_hdma.Init.mS_Peripheral = TEST_SPIx_DMA_RX_HS; spi2_rx_hdma.Init.mD_Peripheral = DMA_HS_MEMORY; spi2_rx_hdma.Init.mEnable = DMA_DISABLE; HAL_DMA_Init(&spi2_rx_hdma); __HAL_DMA_CHX_DISABLE_IT(&spi2_rx_hdma, DMA_CH_INT_ALL); __HAL_DMA_CHX_ENABLE_IT(&spi2_rx_hdma, DMA_CH_INT_DMA_TFR_DONE); rt_dma_node_register(&spi2_rx_hdma); } #endif void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(hspi->Instance == SPI0) { /**SPI0 GPIO Configuration PB6 ------> SPI0_SCK PB7 ------> SPI0_NSS PB8 ------> SPI0_MISI PB9 ------> SPI0_MOSO */ HAL_GPIO_StructInit(&GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = (uint32_t)GPIO_AF1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } else if(hspi->Instance == SPI1) { /**SPI1 GPIO Configuration PB14 ------> SPI1_SCK PB15 ------> SPI1_NSS PB16 ------> SPI1_MISI PB17 ------> SPI1_MOSO */ HAL_GPIO_StructInit(&GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_14 | GPIO_PIN_15 | GPIO_PIN_16 | GPIO_PIN_17; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = (uint32_t)GPIO_AF1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } else if(hspi->Instance == SPI2) { /**SPI2 GPIO Configuration PB24 ------> SPI2_SCK PB25 ------> SPI2_NSS PB26 ------> SPI2_MOSI PB27 ------> SPI2_MISO */ HAL_GPIO_StructInit(&GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_24 | GPIO_PIN_25 | GPIO_PIN_26 | GPIO_PIN_27; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = (uint32_t)GPIO_AF1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } else if(hspi->Instance == SPI3) { /**SPI3 GPIO Configuration PB28 ------> SPI3_SCK PB29 ------> SPI3_NSS PB30 ------> SPI3_MOSI PB31 ------> SPI3_MISO */ HAL_GPIO_StructInit(&GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_28 | GPIO_PIN_29 | GPIO_PIN_30 | GPIO_PIN_31; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = (uint32_t)GPIO_AF1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } else if(hspi->Instance == SPI4) { /**SPI4 GPIO Configuration PB27 ------> SPI4_SCK PB28 ------> SPI4_NSS PB29 ------> SPI4_MISI PB30 ------> SPI4_MOSO */ HAL_GPIO_StructInit(&GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_27 | GPIO_PIN_28 | GPIO_PIN_29 | GPIO_PIN_30; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = (uint32_t)GPIO_AF3; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Alternate = GPIO_AF0; GPIO_InitStruct.Pin = GPIO_PIN_22 | GPIO_PIN_23 | GPIO_PIN_24 | GPIO_PIN_28; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } //(1)(Slave Select):从设备选择信号线,常称为片选信号线,也称为 NSS、CS,以下用 NSS 表示. // 当有多个SPI从设备与 SPI主机相连时,设备的其它信号线 SCK、MOSI及 MISO同时并联到相 同的 SPI 总线上,即无论有多少个从设备,都共同只使用这3条总线; // 而每个从设备都有独立的这一条 NSS 信号线,本信号线独占主机的一个引脚,即有多少个从设备,就有多少条片选信号 线. // I2C协议中通过设备地址来寻址、选中总线上的某个设备并与其进行通讯; // 而 SPI 协议中没有设备地址,它使用 NSS 信号线来寻址,当主机要选择从设备时,把该从设备的 NSS 信号线设置为低电平,该从设备即被选中,即片选有效,接着主机开始与被选中的从设备进行 SPI 通讯。 // 所以 SPI 通讯以 NSS 线置低电平为开始信号,以 NSS 线被拉高作为结束信号。 //(2)SCK(Serial Clock):时钟信号线,用于通讯数据同步.它由通讯主机产生,决定了通讯的速率,不同的设备支持的最高时钟频率不一样,如 STM32的SPI时钟频率最大为f pclk/2,两个设备之间 通讯时,通讯速率受限于低速设备。 //(3)MISO(Master Input,Slave Output):主设备输入 / 从设备输出引脚.主机从这条信号线读入数据,从机的数据由这条信号线输出到主机,即在这条线上数据的方向为从机到主机. //(4)MOSI(Master Output,Slave Input):主设备输出 / 从设备输入引脚.主机的数据从这条信号线输出,从机由这条信号线读入主机发送的数据,即这条线上数据的方向为主机到从机. } #define THREAD_PRIORITY 17 #define THREAD_STACK_SIZE 2048 #define THREAD_TIMESLICE 5 static rt_uint8_t thread_stack[THREAD_STACK_SIZE]; struct rt_thread template_hal_spi_tid; int create_template_hal_spi_init_thread(void) { rt_thread_init(&template_hal_spi_tid, "template_hal_spi_thread", template_hal_spi_thread, NULL, thread_stack, THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE); rt_thread_startup(&template_hal_spi_tid); return 0; } int template_hal_spi_init(void) { create_template_hal_spi_init_thread(); } //INIT_APP_EXPORT(template_hal_spi_init); mc33996输出脚8没有置高,硬件没有问题
最新发布
07-01
为什么按照下面代码,我C代码创建的线程和python是同一个线程,应该如何修改才能使C代码线程和python线程独立开来 C代码如下: void ep_int_hook_register( unsigned int bus_no,ep_read_dma_callback hook) { g_ep_irq_read_callback_info.bus_no = bus_no; g_ep_irq_read_callback_info.hook[bus_no] = hook; printf("ep_read_dma_callback.hook[%d] = 0x%x\n",\ bus_no,(unsigned int)(g_ep_irq_read_callback_info.hook[bus_no])); } int module_init(void) { int ret = 0; usr_board_info_show(); /*pcie 配置寄存器和数据通道初始化*/ ret = pcie_reg_base_addr_init(); if(ret < 0) { printf("Pcie Cfg Reg Bar Init Failed...\n"); return ret; } ep_read_irq_pthead_init(); return ret; } int ep_read_irq_pthead_init(void) { int ret; ret = pcie_thread_create_detached(NULL,ep_read_irq_thread,NULL); if(ret < 0) { printf("ep read irq thread create Fail ! \n"); return -1; } return 0; } void* ep_read_irq_thread(void* param) { unsigned int data_len = 0; unsigned int channel = 0; unsigned int value = 0; int ret = 0; while(1) { sem_wait(&g_irq_sem[READ_IRQ_TYPE]); //等待接收读中断 g_ep_w_irq_num++; pcie_reg_write(PCI_EP_W_IRQ_NUM_REG,g_ep_w_irq_num); data_len = pcie_reg_read(EP_WRITE_LEN_TO_RC_REG); if(0x2 == g_ep_w_irq_type) { /*调用注册的函数*/ if(g_ep_irq_read_callback_info.hook[0] != NULL) { ret = read(gEpDevFd,g_ep_dma_addr_info.r_vir_addr[g_ep_dma_addr_info.r_flag],data_len); if(ret < 0) { printf("read error ret:%d.\n",ret); return NULL; } g_ep_irq_read_callback_info.hook[0](0,channel, g_ep_dma_addr_info.r_vir_addr[g_ep_dma_addr_info.r_flag],data_len); } } else if(0x1 == g_ep_w_irq_type) { printf("recv pcie pkg\n"); ret = read(gEpDevFd,g_ep_dma_addr_info.r_vir_addr[g_ep_dma_addr_info.r_flag],data_len); if(ret < 0) { printf("read error ret:%d.\n",ret); return NULL; } ret = deal_pcie_pkg(g_ep_dma_addr_info.r_vir_addr[g_ep_dma_addr_info.r_flag], data_len); if(ret < 0) { printf("deal pcie pkg fail ret = %d\n", ret); } } if(g_ep_dma_addr_info.r_flag == 0) { /*等待回调函数结束再切换地址*/ g_ep_dma_addr_info.r_flag = 1; } else { /*等待回调函数结束再切换地址*/ g_ep_dma_addr_info.r_flag = 0; } pcie_reg_write(PCI_R_ADDR_FLAG,g_ep_dma_addr_info.r_flag); value = g_ep_dma_addr_info.r_addr[g_ep_dma_addr_info.r_flag] & 0xffffffff; pcie_reg_write(RC_READ_LOW_ADDR_CFG_REG,value); value = (g_ep_dma_addr_info.r_addr[g_ep_dma_addr_info.r_flag] >> 32) & 0xffffffff; pcie_reg_write(RC_READ_HIGH_ADDR_CFG_REG,value); } } int pcie_thread_create_detached(pthread_t *thread,void *(*thread_start)(void*),void *arg) { int err; pthread_t thread_id; pthread_attr_t attr; err = pthread_attr_init (&attr); if (err != 0) { printf(" pthread_attr_init() fail "); return -1; } err = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); if (err != 0) { printf("pthread_attr_setdetachstate" "(PTHREAD_CREATE_DETACHED) failed"); return -1; } err = pthread_create(&thread_id,&attr, thread_start,(void*)arg); if (err != 0) { printf(" pthread_create() fail "); return -1; } if(thread != NULL) { *thread = thread_id; } (void) pthread_attr_destroy(&attr); return 0; } python代码如下: # coding:utf-8 # 运行双模型代码 20250416 import numpy as np import onnxruntime as ort import queue from ctypes import * import time import multiprocessing import os from onnx_model import Predictor, npuPredictor ort.set_default_logger_severity(3) from util import post_pro, vis_image import ctypes from utils.acllite.acllite_model import AclLiteModel from utils.acllite.acllite_resource import AclLiteResource import random import traceback receive_queue = multiprocessing.Queue(maxsize=500) # 该队列存接收数据包 def ep_read_callback_test(irq_type,channel,addr,rcvlen): print('*******************************') print('tgC_test:recv data') start = time.time() data_size = rcvlen data_buffer = ctypes.create_string_buffer(data_size) ctypes.memmove(data_buffer,ctypes.c_void_p(addr),data_size) head = np.frombuffer(data_buffer[:2], dtype=np.uint16) #头,data_buffer切片单位为1字节 if head[0] == 32382: data = data_buffer[28:-4] try: receive_queue.put(data, block=False) except queue.Full: x = receive_queue.get() print('receive_queue is full, size ', receive_queue.qsize()) else: print('recv_data time', time.time()-start) print('receive_queue input size ', receive_queue.qsize()) print('tgC_test:recv OK') print('*******************************') PCIEREADFUNC = CFUNCTYPE(None, c_uint, c_uint, c_ulonglong,c_uint) pResutFunc = PCIEREADFUNC(ep_read_callback_test) lib = cdll.LoadLibrary('/usr/lib/libpetEpApi.so') def after_model(power_data, output, CLASSES, start_frequency, end_frequency, end_time, sum_sec, width, height, time_every_point, rbw, modelType): results = b'' print('output:', np.array(output).shape) if len(output) > 0: output = output[output[:, 0] >= 0] output = output[output[:, 1] >= 0] output = output[output[:, 2] <= width] output = output[output[:, 3] <= height] clss = output[:, 5].tolist() clss = [CLASSES[int(i)] for i in clss] output[:, 4] = output[:, 4] * 100 bboxs = output[:, :5].astype(np.float32).astype(np.int32).tolist() results, count = post_pro(power_data, bboxs, clss, start_frequency, end_frequency, end_time, sum_sec, width, height, time_every_point) # print('len results', len(results)) if len(results)==0: # 为了数据回环,造一个数据出来 maxa = np.argmax(power_data) h, w = power_data.shape xx = maxa - int(maxa/w)*w results = end_time+sum_sec + np.array([1,(start_frequency+xx*rbw/1000000)*100*1000,(start_frequency+xx*(rbw+1)/1000000)*100*1000,rbw/10,0,101]).astype(np.uint32).tobytes() results = results + np.array([1,2,3,4,1,0]).astype(np.uint16).tobytes() results = results + np.array([(start_frequency+xx*rbw/1000000)*100*1000,10*100*1000,rbw/10,10,20,30]).astype(np.uint32).tobytes() head = np.array([32382,0,0,0]).astype(np.uint16).tobytes() datalen = np.array([len(results)+36+4]).astype(np.uint32).tobytes() others = np.array([1,2,3,230,0,0,1,1]).astype(np.uint16).tobytes() print('modelType:',modelType) modelType = np.array([int(modelType)]).astype(np.uint32).tobytes() sgnNum = np.array([0]).astype(np.uint32).tobytes() #用于回环,信号数先设为1? tail = np.array([0,3338]).astype(np.uint16).tobytes() real_send_data = head + datalen + others + modelType + sgnNum + results + tail print('before send') iRet = lib.usrPcieWriteData(real_send_data, len(real_send_data)) print('end send') else: head = np.array([32382,0,0,0]).astype(np.uint16).tobytes() datalen = np.array([len(results)+36+4]).astype(np.uint32).tobytes() others = np.array([1,2,3,230,0,0,1,1]).astype(np.uint16).tobytes() print('modelType:',modelType) modelType = np.array([int(modelType)]).astype(np.uint32).tobytes() sgnNum = np.array([count]).astype(np.uint32).tobytes() tail = np.array([0,3338]).astype(np.uint16).tobytes() real_send_data = head + datalen + others + modelType + sgnNum + results + tail print('before send') iRet = lib.usrPcieWriteData(real_send_data, len(real_send_data)) print('end send') # print('after time:', time.time()-start) # print('+++++++++ end ++++++++++') def infer_model(CLASSES1, CLASSES2, args): try: if args['device'] == 'npu': model_path1 = os.path.join(args['model1_dir'], 'yolox_416_832.om') model_path2 = os.path.join(args['model2_dir'], 'yolox_416_832.om') predictor1 = npuPredictor(model_path1, cls_names=CLASSES1, test_conf=args['confidence'], nmsthre=args['nms']) predictor2 = npuPredictor(model_path2, cls_names=CLASSES2, test_conf=args['confidence'], nmsthre=args['nms']) print('model_path1: ', model_path1) print('model_path2: ', model_path2) else: model_path1 = args['model1_dir'] + '/yolox.onnx' model_path2 = args['model2_dir'] + '/yolox.onnx' # print('model_path: ', model_path) model1 = ort.InferenceSession(model_path1) model2 = ort.InferenceSession(model_path2) predictor1 = Predictor(model=model1, cls_names=CLASSES1, test_conf=args['confidence'], nmsthre=args['nms'], decoder=False, device='cpu') predictor2 = Predictor(model=model2, cls_names=CLASSES2, test_conf=args['confidence'], nmsthre=args['nms'], decoder=False, device='cpu') except Exception as e: traceback.print_exc() while True: try: start = time.time() data = receive_queue.get() end_time = data[:16] sum_sec = data[16:20] #以秒为单位的时间,测试时只有这个有真实时间数据 # print('sum_sec', np.frombuffer(sum_sec, dtype=np.uint32)[0]) start_frequency = np.frombuffer(data[20:24], dtype=np.uint32)[0] rbw = np.frombuffer(data[24:28], dtype=np.uint32)[0] #单位hz rtw = np.frombuffer(data[28:32], dtype=np.uint32)[0] frameLen = np.frombuffer(data[32:36], dtype=np.uint32)[0] frameNum = np.frombuffer(data[36:40], dtype=np.uint32)[0] # print('rbw',rbw) #1000 # print('rtw',rtw) #20 # print('frameLen', frameLen) # print('frameNum', frameNum) real_data = data[48:frameLen*frameNum*2*2+48] power_data_orign = np.frombuffer(real_data, dtype=np.uint16) # print(power_data.shape) power_data_orign = power_data_orign.reshape(2,-1,frameLen) #临时 # print(power_data.shape) # power_data = power_data_orign[0] power_data = power_data_orign[0].copy() power_data[np.isnan(power_data)] = 0 power_data[np.isinf(power_data)] = 0 power_data = power_data*0.25 #因为转换前单位是0.25db end_frequency = (start_frequency + frameLen*rbw/1000)/1000 #单位是Mhz # print('end_frequency',end_frequency) #200.82 start_frequency = start_frequency/1000 #单位是Mhz # print('start_frequency',start_frequency) # time_every_point = (rtw*10)/(10**6) #单位是毫秒 # print('time_every_point',time_every_point) # print('power_data.shape', power_data.shape) # print('power_data.max', power_data.max()) # print('power_data.max', power_data.min()) height, width = power_data.shape pmin = power_data.min() + 5 power_data_min_max = power_data - pmin power_data_min_max[power_data_min_max<0] = 0 # 专用模型 output1 = predictor1.inference(power_data_min_max) after_model(power_data, output1, CLASSES1, start_frequency, end_frequency, end_time, sum_sec, width, height, time_every_point,rbw, 0) # 通用模型 output2 = predictor2.inference(power_data_min_max) after_model(power_data, output2, CLASSES2, start_frequency, end_frequency, end_time, sum_sec, width, height, time_every_point,rbw, 10) print('*********************************infer_time:', time.time()-start) except Exception as e: traceback.print_exc() def heartbeat(): try: end_time = np.array([1,2,3,4,1,0]).astype(np.uint16).tobytes() + np.array([1]).astype(np.uint32).tobytes() sum_sec = np.array([0]).astype(np.uint32).tobytes() results = end_time+sum_sec + np.array([1,1,2,1,0,101]).astype(np.uint32).tobytes() results = results + np.array([1,2,3,4,1,0]).astype(np.uint16).tobytes() results = results + np.array([1,10*100*1000,1,10,20,30]).astype(np.uint32).tobytes() head = np.array([32382,0,0,0]).astype(np.uint16).tobytes() datalen = np.array([len(results)+36+4]).astype(np.uint32).tobytes() others = np.array([1,2,3,224,0,0,1,1]).astype(np.uint16).tobytes() modelType = np.array([0]).astype(np.uint32).tobytes() sgnNum = np.array([0]).astype(np.uint32).tobytes() tail = np.array([0,3338]).astype(np.uint16).tobytes() real_send_data = head + datalen + others + modelType + sgnNum + results + tail # print('heart send') print('-----heartbeat-----') iRet = lib.usrPcieWriteData(real_send_data, len(real_send_data)) # print('heart end send') except Exception as e: traceback.print_exc() if __name__ == "__main__": try: iRet = 0 iRet = lib.module_init() print("start register ") lib.ep_int_hook_register(0,pResutFunc) except Exception as e: traceback.print_exc() try: acl_resource = AclLiteResource() acl_resource.init() args = {'model1_dir':'./models/model_22cls','model2_dir':'./models/model_dingpin', 'confidence':0.2, 'device':'npu', 'nms':0.15} with open(os.path.join(args['model1_dir'], 'new_classes.txt'), 'r') as fp: CLASSES1 = [line.strip('\n') for line in fp.readlines()] CLASSES1 = [int(cls) for cls in CLASSES1] with open(os.path.join(args['model2_dir'], 'new_classes.txt'), 'r') as fp: CLASSES2 = [line.strip('\n') for line in fp.readlines()] CLASSES2 = [int(cls) for cls in CLASSES2] heartbeat() infer_model(CLASSES1, CLASSES2, args) except Exception as e: traceback.print_exc()
06-24
评论 14
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值