#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没有置高,硬件没有问题
最新发布