下面这个函数TX_memset4是什么意思了?

#include <iostream>
using namespace std;

void TX_memset4(void *dst, unsigned int val, unsigned int len) 
{                                  
	unsigned int  __count = (len);                 
	unsigned int __nTimes = (__count + 3) / 4;    
	unsigned int *__p = (unsigned int*)dst;         
	unsigned int __val = (val);         
	
	if (len == 0) 
	{
		return;             
	}
	
	switch (__count % 4)                
	{                                  
		case 0:                        
		do                             
		{                              
					*__p++ = __val;   
			case 3: *__p++ = __val;    
			case 2: *__p++ = __val;    
			case 1: *__p++ = __val;           
		}while(--__nTimes); 
	}                                 
}

int main(int argc, char *argv[])
{
	unsigned int iArr[10];
	TX_memset4(iArr, 7, 10);
	
	return 0;
}





                
#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
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值