SPI的IO状态

gqs123

     有几个问题希望各位大佬能解惑：

          1、在使用spi的时候也会初始化gpio，gpio和spi都是mcu的外设，这个时候是由spi硬件来接管gpio外设吗？pin脚最后呈现出来是高阻态还是高电平，还是由gpio决定吗？

          2、如果上面的问题成立，我将gpio设置为推挽模式，在spi从机未被cs选中的情况下，最终芯片的pin引脚默认状态是高阻态吗，但是gpio设置为推挽的时候貌似没有高阻态这个状态。

          3、I2C强制默认为高电平，如果两个spi从机接在一起，SCL 都默认为低，那一个从机在通信的时候，另一个未被选中的从机的低电平会不会对正在通信的从机造成影响，如果是高阻态肯定没有关系

          我看了一下手册，至少片选是和gpio有关系的
         

eric2013

1、SPI接管后，GPIO的ODR寄存器不可以再控制了




2和3 , 只有你配置软件片选时，CS就是配置为GPIO使用的，你配置为硬件NSS片选就不可以GPIO方式控制了。

gqs123

eric2013 发表于 2024-10-26 09:11
1、SPI接管后，GPIO的ODR寄存器不可以再控制了

感谢大佬解惑，实验了一下，确实即使配置为推挽，SPI默认情况下是高阻态的，不会有IIC一样的短路情况，这样的话，不过这样的话，为什么在初始化SPI的时候还要初始化GPIO呢

eric2013

gqs123 发表于 2024-11-4 14:35
感谢大佬解惑，实验了一下，确实即使配置为推挽，SPI默认情况下是高阻态的，不会有IIC一样的短路情况，这 ...

要配置GPIO复用模式才可以用于各种外设。

gqs123

eric2013 发表于 2024-11-5 09:22
要配置GPIO复用模式才可以用于各种外设。

还有一个问题，使用spi+dma 用hal库传输的时候，只要调用memcpy 修改send_buffer 里面的值，我接收到的数据就不对了是为什么啊。我按教程做了分区，把0x24000000 分给DMA ，不允许内存访问，不用memcpy的时候是正常的。

//使能 STM32H7 的 L1-Cache,同时开启 D cache 的强制透写
void Cache_Enable(void)
{
     SCB_EnableICache(); //使能 I-Cache,函数在 core_cm7.h 里面定义
     SCB_EnableDCache(); //使能 D-Cache,函数在 core_cm7.h 里面定义
     SCB->CACR|=1<<2; //强制 D-Cache 透写,如不开启,实际使用中可能遇到各种问题
}

void MPU_Config(void)
{
       
  MPU_Region_InitTypeDef MPU_InitStruct = {0};

  /* Disables the MPU */
  HAL_MPU_Disable();

  /*
                禁止D-cache 访问 DMA所在SRAM
  */
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.BaseAddress = 0x24000000;
  MPU_InitStruct.Size = MPU_REGION_SIZE_1KB;
  MPU_InitStruct.SubRegionDisable = 0x00;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;    //所有模式下都可以访问
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE; //禁止执行代码
  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;                         //不共享
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;                         //禁止cache
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;                 //不使用缓冲
        /*
                不允许D-cache 访问
  */
  HAL_MPU_ConfigRegion(&MPU_InitStruct);
       
  /* Enables the MPU */
  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void PeriphCommonClock_Config(void);

void HardWare_Init(void)
{
        Cache_Enable();
        MPU_Config();
       
        HAL_Init();

        SystemClock_Config();

        PeriphCommonClock_Config();
        // MX_IWDG1_Init();

        MX_GPIO_Init();
        MX_DMA_Init();
        // MX_BDMA_Init();
        // MX_USB_DEVICE_Init();
        // MX_USART3_UART_Init();
        MX_TIM2_Init();
        // MX_UART4_Init();
        MX_TIM3_Init();
        MX_TIM4_Init();
        MX_TIM5_Init();
        MX_TIM6_Init();

        // USB_Status_Init();

        __HAL_TIM_CLEAR_IT(&htim2, TIM_IT_UPDATE);
        __HAL_TIM_CLEAR_IT(&htim3, TIM_IT_UPDATE);
        __HAL_TIM_CLEAR_IT(&htim4, TIM_IT_UPDATE);

        HAL_TIM_Base_Start_IT(&htim2);
        HAL_TIM_Base_Stop_IT(&htim3);
        HAL_TIM_Base_Stop_IT(&htim4);

        // PROD_GATHER.TEMP = Get_Temp();
        MX_SPI3_Init();

        Gear_Init();                 //采样电阻挡位GPIO初始化，
        AD7616_Init(Software_Mode); //AD7616
        AD7616_ConfigeInit();

        PY_usDelayTest();
}
extern __attribute__((section(".NOCACHE")))  uint8_t recv_data[DATAALLSENDSIZE];
extern __attribute__((section(".NOCACHE")))  uint8_t send_data[DATAALLSENDSIZE];
extern  unsigned char default_buffer[DATAALLSENDSIZE];

int main(void)
{
        HardWare_Init();
        uint16_t xxxCnt = 0;
        uint16_t xxxx = 0;
    uint32_t i = 0;

        while (1)
        {
//                AD7616_Task();   //ADC采集原始值  ns
//                Product_Task();         //电阻计算                        us
//                Channel_Check();
                memcpy(send_data,default_buffer,DATAALLSENDSIZE);
                HAL_SPI_TransmitReceive_DMA(&hspi3, (uint8_t* )send_data, (uint8_t* )recv_data, DATAALLSENDSIZE);


        }
}


spi+dma 配置


/* SPI3 init function */
void MX_SPI3_Init(void)
{

  /* USER CODE BEGIN SPI3_Init 0 */

  /* USER CODE END SPI3_Init 0 */

  /* USER CODE BEGIN SPI3_Init 1 */

  /* USER CODE END SPI3_Init 1 */
  hspi3.Instance = SPI3;
  hspi3.Init.Mode = SPI_MODE_SLAVE;
  hspi3.Init.Direction = SPI_DIRECTION_2LINES;
  hspi3.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi3.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi3.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi3.Init.NSS = SPI_NSS_HARD_INPUT;
  hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_ENABLE;
  hspi3.Init.CRCPolynomial = 0x07;
  hspi3.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi3.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  hspi3.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi3.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi3.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi3.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi3.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi3.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi3.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi3.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi3.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI3_Init 2 */

  /* USER CODE END SPI3_Init 2 */

}

void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
  if(spiHandle->Instance==SPI3)
  {
  /* USER CODE BEGIN SPI3_MspInit 0 */

  /* USER CODE END SPI3_MspInit 0 */

  /** Initializes the peripherals clock
  */
    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPI3;
    PeriphClkInitStruct.Spi45ClockSelection = RCC_SPI45CLKSOURCE_D2PCLK1;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    {
      Error_Handler();
    }

    /* SPI3 clock enable */
    __HAL_RCC_SPI3_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();
    /**SPI3 GPIO Configuration
    PE2     ------> SPI3_SCK
    PE4     ------> SPI3_NSS
    PE5     ------> SPI3_MISO
    PE6     ------> SPI3_MOSI
    */
    GPIO_InitStruct.Pin = GPIO_PIN_15;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

    /* SPI3 DMA Init */
    /* SPI3_RX Init */
    hdma_spi3_rx.Instance = DMA2_Stream0;
    hdma_spi3_rx.Init.Request = DMA_REQUEST_SPI3_RX;
    hdma_spi3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_spi3_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi3_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi3_rx.Init.Mode = DMA_CIRCULAR;
    hdma_spi3_rx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_spi3_rx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
    hdma_spi3_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    hdma_spi3_rx.Init.MemBurst = DMA_MBURST_SINGLE;
    hdma_spi3_rx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_spi3_rx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(spiHandle,hdmarx,hdma_spi3_rx);

    /* SPI3_TX Init */
    hdma_spi3_tx.Instance = DMA2_Stream1;
    hdma_spi3_tx.Init.Request = DMA_REQUEST_SPI3_TX;
    hdma_spi3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi3_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi3_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi3_tx.Init.Mode = DMA_CIRCULAR;
    hdma_spi3_tx.Init.Priority = DMA_PRIORITY_LOW;
    hdma_spi3_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
    hdma_spi3_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    hdma_spi3_tx.Init.MemBurst = DMA_MBURST_SINGLE;
    hdma_spi3_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    if (HAL_DMA_Init(&hdma_spi3_tx) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi3_tx);

    /* SPI3 interrupt Init */
    HAL_NVIC_SetPriority(SPI3_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(SPI3_IRQn);
  /* USER CODE BEGIN SPI3_MspInit 1 */

  /* USER CODE END SPI3_MspInit 1 */
  }
}

gqs123

eric2013 发表于 2024-11-5 09:22
要配置GPIO复用模式才可以用于各种外设。

我的spi是从机，进一步试了一下，好像send_data 里面不能有数据，或者要初始化为0，不然收到的数据就有问题

eric2013

gqs123 发表于 2024-11-5 12:10
还有一个问题，使用spi+dma 用hal库传输的时候，只要调用memcpy 修改send_buffer 里面的值，我接收到的数 ...

memcpy底层会做4字节为一个字的加速操作，从会有对齐问题。

此贴可以解决。

石锤内存访问不支持非对齐是否STM32H7的硬件bug
https://www.armbbs.cn/forum.php? ... 4562&fromuid=58
(出处: 硬汉嵌入式论坛)

另外把你这句骚操作删掉
SCB->CACR|=1<<2; //强制 D-Cache 透写,如不开启,实际使用中可能遇到各种问题

gqs123

eric2013 发表于 2024-11-5 14:31
memcpy底层会做4字节为一个字的加速操作，从会有对齐问题。

此贴可以解决。

谢谢，删掉这一句是因为回写不用每次都写到SRAM里面比 Write through 效率更高麻

eric2013

gqs123 发表于 2024-11-6 13:24
谢谢，删掉这一句是因为回写不用每次都写到SRAM里面比 Write through 效率更高麻

使用MPU配置即可，更方便灵活。