21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › SPI CLK响应较慢
12345下一页
返回列表 发新帖我要提问

[STM32H7] SPI CLK响应较慢

[复制链接]
5244|87
belindagraham 发表于 2023-10-17 21:56 | 显示全部楼层
如果SPI主从设备的通信速率不匹配，可能会导致SPI CLK响应较慢。
回复

收藏 举报

qiufengsd 发表于 2023-10-17 22:23 | 显示全部楼层
可能是SPI接收卡死问题，这可能会导致程序运行异常。
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 08:55 | 显示全部楼层
belindagraham 发表于 2023-10-17 21:56
如果SPI主从设备的通信速率不匹配，可能会导致SPI CLK响应较慢。

我在俩个从设备上试过，分别是DRV8305和AMS5047P，都是这个现象。从设备的CLK是主设备发的为啥会不匹配呢？
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 14:51 | 显示全部楼层
呐咯密密 发表于 2023-10-17 10:43
不用任何怀疑，是你的SPI发送函数有问题，在你的CS下拉之后，你并没有立刻传输数据，而是执行了各种校验工 ...

那这个是HAL库的正常现象了吧，实际传输时间是预期的3倍，效率有点低
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 14:53 | 显示全部楼层
chenjun89 发表于 2023-10-17 19:46
几十个时钟周期也太夸张了吧，你是用的软片选还是硬片选。

软件写GPIO来控制的CS
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 14:53 | 显示全部楼层
macpherson 发表于 2023-10-17 21:29
数据传输速率和 CLK 信号频率不匹配

CLK是主机给的怎么会不匹配呢？
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 14:56 | 显示全部楼层
玄德 发表于 2023-10-13 19:50
往 SPI ->DR 寄存器写入数据，SCK 才会出现。
你的 CS 是用 IO 方式产生的，它的边沿和 SCK 没有任何关系 ...

软件写完CS就立刻运行SPI HAL函数了，但是是放在主循环里面跑的。实际再有个100us的中断在运行（运行时间大概在20us左右），可能是中断导致了SPI运行变慢嘛？
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 14:59 | 显示全部楼层
呐咯密密 发表于 2023-10-17 10:43
不用任何怀疑，是你的SPI发送函数有问题，在你的CS下拉之后，你并没有立刻传输数据，而是执行了各种校验工 ...

// SPI发送读取函数
uint16_t SPI_ReadWrite_OneByte(uint16_t _txdata)
{

        HAL_GPIO_WritePin(SPI5_CS_GPIO_Port, SPI5_CS_Pin, GPIO_PIN_RESET);
        uint16_t rxdata;
        if(HAL_SPI_TransmitReceive(&hspi5,(uint8_t *)&_txdata,(uint8_t *)&rxdata,1,100) !=HAL_OK)
                {
                        rxdata=0;
                }
               
    HAL_GPIO_WritePin(SPI5_CS_GPIO_Port, SPI5_CS_Pin, GPIO_PIN_SET);
        return rxdata;
}
uint16_t AS5047_read(uint16_t add)
{
        uint16_t data;
        add |= 0x4000;        //读指令 bit14 置1
        if(Parity_bit_Calculate(add)==1) add=add|0x8000; //如果前15位 1的个数位偶数，则Bit15 置1
        SPI_ReadWrite_OneByte(add);                //发送一条指令，不管读回的数据
        data=SPI_ReadWrite_OneByte(NOP|0x4000); //发送一条空指令，读取上一次指令返回的数据。
        data &=0x3fff;
        return data;
}
代码是这么实现的，中间没有其他操作了
回复

收藏 举报

呐咯密密 发表于 2023-10-18 17:02 | 显示全部楼层
Hufei1994 发表于 2023-10-18 14:59
// SPI发送读取函数
uint16_t SPI_ReadWrite_OneByte(uint16_t _txdata)
{

问题在这个函数：HAL_SPI_TransmitReceive，你贴一下这个函数，这个函数在发送数据前应该是做了某些操作
回复

收藏 举报

呐咯密密 发表于 2023-10-18 17:21 | 显示全部楼层
Hufei1994 发表于 2023-10-18 14:59
// SPI发送读取函数
uint16_t SPI_ReadWrite_OneByte(uint16_t _txdata)
{
复制
  1. /**
    

  2.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Transmit and Receive an amount of data in blocking mode.
    

  3.   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
    

  4.   *               the configuration information for SPI module.
    

  5.   * @param  pTxData: pointer to transmission data buffer
    

  6.   * @param  pRxData: pointer to reception data buffer
    

  7.   * @param  Size: amount of data to be sent and received
    

  8.   * @param  Timeout: Timeout duration
    

  9.   * @retval HAL status
    

  10.   */
    

  11. HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size,
    

  12.                                           uint32_t Timeout)
    

  13. {
    

  14.   uint32_t tickstart = 0U;
    

  15.   HAL_StatusTypeDef errorcode = HAL_OK;
    


  16. 

  17.   /* Check Direction parameter */
    

  18.   assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));
    


  19. 

  20.   /* Process Locked */
    

  21.   __HAL_LOCK(hspi);
    


  22. 

  23.   /* Init tickstart for timeout management*/
    

  24.   tickstart = HAL_GetTick();
    


  25. 

  26.   if (!((hspi->State == HAL_SPI_STATE_READY) || \
    

  27.         ((hspi->Init.Mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (hspi->State == HAL_SPI_STATE_BUSY_RX))))
    

  28.   {
    

  29.     errorcode = HAL_BUSY;
    

  30.     __HAL_UNLOCK(hspi);
    

  31.     return errorcode;
    

  32.   }
    


  33. 

  34.   if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U))
    

  35.   {
    

  36.     errorcode = HAL_ERROR;
    

  37.     __HAL_UNLOCK(hspi);
    

  38.     return errorcode;
    

  39.   }
    


  40. 

  41.   /* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */
    

  42.   if (hspi->State != HAL_SPI_STATE_BUSY_RX)
    

  43.   {
    

  44.     hspi->State = HAL_SPI_STATE_BUSY_TX_RX;
    

  45.   }
    


  46. 

  47.   /* Set the transaction information */
    

  48.   hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
    

  49.   hspi->pRxBuffPtr  = (uint8_t *)pRxData;
    

  50.   hspi->RxXferCount = Size;
    

  51.   hspi->RxXferSize  = Size;
    

  52.   hspi->pTxBuffPtr  = (uint8_t *)pTxData;
    

  53.   hspi->TxXferCount = Size;
    

  54.   hspi->TxXferSize  = Size;
    


  55. 

  56.   /*Init field not used in handle to zero */
    

  57.   hspi->RxISR       = NULL;
    

  58.   hspi->TxISR       = NULL;
    


  59. 

  60.   /* Set the number if data at current transfer */
    

  61.   MODIFY_REG(hspi->Instance->CR2, SPI_CR2_TSIZE, Size);
    


  62. 

  63.   __HAL_SPI_ENABLE(hspi);
    


  64. 

  65.   if (hspi->Init.Mode == SPI_MODE_MASTER)
    

  66.   {
    

  67.     /* Master transfer start */
    

  68.     SET_BIT(hspi->Instance->CR1, SPI_CR1_CSTART);
    

  69.   }
    


  70. 

  71.   /* Transmit and Receive data in 32 Bit mode */
    

  72.   if (hspi->Init.DataSize > SPI_DATASIZE_16BIT)
    

  73.   {
    

  74.     while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))
    

  75.     {
    

  76.       /* Check TXE flag */
    

  77.       if ((hspi->TxXferCount > 0U) && (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)))
    

  78.       {
    

  79.         *((__IO uint32_t *)&hspi->Instance->TXDR) = *((uint32_t *)hspi->pTxBuffPtr);
    

  80.         hspi->pTxBuffPtr += sizeof(uint32_t);
    

  81.         hspi->TxXferCount --;
    

  82.       }
    


  83. 

  84.       /* Check RXWNE/EOT flag */
    

  85.       if ((hspi->RxXferCount > 0U) && (hspi->Instance->SR & (SPI_FLAG_RXWNE|SPI_FLAG_EOT)))
    

  86.       {
    

  87.         *((uint32_t *)hspi->pRxBuffPtr) = *((__IO uint32_t *)&hspi->Instance->RXDR);
    

  88.         hspi->pRxBuffPtr += sizeof(uint32_t);
    

  89.         hspi->RxXferCount --;
    

  90.       }
    


  91. 

  92.       if ((Timeout != HAL_MAX_DELAY) && ((HAL_GetTick() - tickstart) >=  Timeout))
    

  93.       {
    

  94.         /* Call standard close procedure with error check */
    

  95.         SPI_CloseTransfer(hspi);
    


  96. 

  97.         /* Process Unlocked */
    

  98.         __HAL_UNLOCK(hspi);
    


  99. 

  100.         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_TIMEOUT);
    

  101.         hspi->State = HAL_SPI_STATE_READY;
    

  102.         return HAL_ERROR;
    

  103.       }
    

  104.     }
    

  105.   }
    

  106.   /* Transmit and Receive data in 16 Bit mode */
    

  107.   else if (hspi->Init.DataSize > SPI_DATASIZE_8BIT)
    

  108.   {
    

  109.     while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))
    

  110.     {
    

  111.       /* Check TXE flag */
    

  112.       if ((hspi->TxXferCount > 0U) && (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)))
    

  113.       {
    

  114.         if ( (hspi->TxXferCount > 1U) && (hspi->Init.FifoThreshold > SPI_FIFO_THRESHOLD_01DATA))
    

  115.         {
    

  116.           *((__IO uint32_t *)&hspi->Instance->TXDR) = *((uint32_t *)hspi->pTxBuffPtr);
    

  117.           hspi->pTxBuffPtr += sizeof(uint32_t);
    

  118.           hspi->TxXferCount-=2;
    

  119.         }
    

  120.         else
    

  121.         {
    

  122.           *((__IO uint16_t *)&hspi->Instance->TXDR) = *((uint16_t *)hspi->pTxBuffPtr);
    

  123.           hspi->pTxBuffPtr += sizeof(uint16_t);
    

  124.           hspi->TxXferCount--;
    

  125.         }
    

  126.       }
    


  127. 

  128.       /* Check RXWNE/FRLVL flag */
    

  129.       if ((hspi->RxXferCount > 0U) && (hspi->Instance->SR & (SPI_FLAG_RXWNE|SPI_FLAG_FRLVL)))
    

  130.       {
    

  131.         if (hspi->Instance->SR & SPI_FLAG_RXWNE)
    

  132.         {
    

  133.           *((uint32_t *)hspi->pRxBuffPtr) = *((__IO uint32_t *)&hspi->Instance->RXDR);
    

  134.           hspi->pRxBuffPtr += sizeof(uint32_t);
    

  135.           hspi->RxXferCount-=2;
    

  136.         }
    

  137.         else
    

  138.         {
    

  139.           *((uint16_t *)hspi->pRxBuffPtr) = *((__IO uint16_t *)&hspi->Instance->RXDR);
    

  140.           hspi->pRxBuffPtr += sizeof(uint16_t);
    

  141.           hspi->RxXferCount--;
    

  142.         }
    

  143.       }
    


  144. 

  145.       if ((Timeout != HAL_MAX_DELAY) && ((HAL_GetTick() - tickstart) >=  Timeout))
    

  146.       {
    

  147.         /* Call standard close procedure with error check */
    

  148.         SPI_CloseTransfer(hspi);
    


  149. 

  150.         /* Process Unlocked */
    

  151.         __HAL_UNLOCK(hspi);
    


  152. 

  153.         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_TIMEOUT);
    

  154.         hspi->State = HAL_SPI_STATE_READY;
    

  155.         return HAL_ERROR;
    

  156.       }
    

  157.     }
    

  158.   }
    

  159.   /* Transmit and Receive data in 8 Bit mode */
    

  160.   else
    

  161.   {
    

  162.     while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))
    

  163.     {
    

  164.       /* check TXE flag */
    

  165.       if ((hspi->TxXferCount > 0U) && (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)))
    

  166.       {
    

  167.         if ((hspi->TxXferCount > 3U) && (hspi->Init.FifoThreshold > SPI_FIFO_THRESHOLD_03DATA))
    

  168.         {
    

  169.           *((__IO uint32_t *)&hspi->Instance->TXDR) = *((uint32_t *)hspi->pTxBuffPtr);
    

  170.           hspi->pTxBuffPtr += sizeof(uint32_t);
    

  171.           hspi->TxXferCount-=4;
    

  172.         }
    

  173.         else if ((hspi->TxXferCount > 1U) && (hspi->Init.FifoThreshold > SPI_FIFO_THRESHOLD_01DATA))
    

  174.         {
    

  175.           *((__IO uint16_t *)&hspi->Instance->TXDR) = *((uint16_t *)hspi->pTxBuffPtr);
    

  176.           hspi->pTxBuffPtr += sizeof(uint16_t);
    

  177.           hspi->TxXferCount-=2;
    

  178.         }
    

  179.         else
    

  180.         {
    

  181.           *((__IO uint8_t *)&hspi->Instance->TXDR) = *((uint8_t *)hspi->pTxBuffPtr);
    

  182.           hspi->pTxBuffPtr += sizeof(uint8_t);
    

  183.           hspi->TxXferCount--;
    

  184.         }
    

  185.       }
    


  186. 

  187.       /* Wait until RXWNE/FRLVL flag is reset */
    

  188.       if ((hspi->RxXferCount > 0U) && (hspi->Instance->SR & (SPI_FLAG_RXWNE|SPI_FLAG_FRLVL)))
    

  189.       {
    

  190.         if (hspi->Instance->SR & SPI_FLAG_RXWNE)
    

  191.         {
    

  192.           *((uint32_t *)hspi->pRxBuffPtr) = *((__IO uint32_t *)&hspi->Instance->RXDR);
    

  193.           hspi->pRxBuffPtr += sizeof(uint32_t);
    

  194.           hspi->RxXferCount-=4;
    

  195.         }
    

  196.         else if ((hspi->Instance->SR & SPI_FLAG_FRLVL) > SPI_FRLVL_QUARTER_FULL)
    

  197.         {
    

  198.           *((uint16_t *)hspi->pRxBuffPtr) = *((__IO uint16_t *)&hspi->Instance->RXDR);
    

  199.           hspi->pRxBuffPtr += sizeof(uint16_t);
    

  200.           hspi->RxXferCount-=2;
    

  201.         }
    

  202.         else
    

  203.         {
    

  204.           *((uint8_t *)hspi->pRxBuffPtr) = *((__IO uint8_t *)&hspi->Instance->RXDR);
    

  205.           hspi->pRxBuffPtr += sizeof(uint8_t);
    

  206.           hspi->RxXferCount--;
    

  207.         }
    

  208.       }
    


  209. 

  210.       if ((Timeout != HAL_MAX_DELAY) && ((HAL_GetTick() - tickstart) >=  Timeout))
    

  211.       {
    

  212.         /* Call standard close procedure with error check */
    

  213.         SPI_CloseTransfer(hspi);
    


  214. 

  215.         /* Process Unlocked */
    

  216.         __HAL_UNLOCK(hspi);
    


  217. 

  218.         SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_TIMEOUT);
    

  219.         hspi->State = HAL_SPI_STATE_READY;
    

  220.         return HAL_ERROR;
    

  221.       }
    

  222.     }
    

  223.   }
    


  224. 

  225.   /* Wait for Tx/Rx (and CRC) data to be sent/received */
    

  226.   if (SPI_WaitOnFlagUntilTimeout(hspi, SPI_FLAG_EOT, RESET, tickstart, Timeout) != HAL_OK)
    

  227.   {
    

  228.     SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_FLAG);
    

  229.   }
    


  230. 

  231.   /* Call standard close procedure with error check */
    

  232.   SPI_CloseTransfer(hspi);
    


  233. 

  234.        /* Process Unlocked */
    

  235.   __HAL_UNLOCK(hspi);
    


  236. 

  237.   hspi->State = HAL_SPI_STATE_READY;
    


  238. 

  239.   if (hspi->ErrorCode != HAL_SPI_ERROR_NONE)
    

  240.   {
    

  241.     return HAL_ERROR;
    

  242.   }
    

  243.   return HAL_OK;
    

  244. }
这是我从STM32H743的HALL库里面找出来的的SPI发送接收函数，从你进入函数开始到真正将数据开始送出，前面经历了多少校验和查询，这写都会导致时钟延时。下面我贴寄存器方式的你看看，除了定义一个局部变量，之后马上使能SPI，然后会等待一个发送区空，然后立马向数据寄存器写值，此时时钟开始响应，开始发送数据。
复制
  1. u8 SPI2_ReadWriteByte(u8 TxData)
    

  2. {                                    
    

  3.         u8 RxData=0;        
    

  4.         SPI2->CR1|=1<<0;                                //SPE=1,使能SPI2
    

  5.         SPI2->CR1|=1<<9;                                  //CSTART=1,启动传输
    

  6.         
    

  7.         while((SPI2->SR&1<<1)==0);                //等待发送区空 
    

  8.         *(vu8 *)&SPI2->TXDR=TxData;                //发送一个byte,以传输长度访问TXDR寄存器   
    

  9.         while((SPI2->SR&1<<0)==0);                //等待接收完一个byte  
    

  10.         RxData=*(vu8 *)&SPI2->RXDR;                //接收一个byte,以传输长度访问RXDR寄存器        
    

  11.         
    

  12.         SPI2->IFCR|=3<<3;                                //EOTC和TXTFC置1,清除EOT和TXTFC位 
    

  13.         SPI2->CR1&=~(1<<0);                                //SPE=0,关闭SPI2,会执行状态机复位/FIFO重置等操作
    

  14.         return RxData;                                        //返回收到的数据
    

  15. }
如果你想更快，初始化的时候就使能SPI，不检测发送区，直接给TXDR送数据，就会更快的让时钟起来。自己测试就知道了。还是那句话，HALL库只能保证你的代码安稳的运行，并检测出在哪出错，但是实时性巨差，是所有方式里面最慢的。如果向高速运行代码，要学会交叉使用，需要快速就自己写寄存器。其他初始化可以用HALL
回复

收藏 举报

1988020566 发表于 2023-10-18 19:46 | 显示全部楼层
SPI接口的信号线连接不良可能会导致SPI CLK响应较慢。
回复

收藏 举报

pixhw 发表于 2023-10-18 20:25 | 显示全部楼层
SPI接口的时钟频率是SPI通信速度的关键因素之一，如果时钟频率设置过低，可能会导致SPI CLK响应较慢。
回复

收藏 举报

louliana 发表于 2023-10-18 20:56 | 显示全部楼层
SPI协议是一种同步串行数据协议，数据一位一位地传输，需要时钟线来同步。如果传输速度提高，则时钟频率也会提高，会导致硬件电路上的延迟，从而降低了SPI CLK的响应速度。
回复

收藏 举报

mnynt121 发表于 2023-10-18 21:17 | 显示全部楼层
没有正确配置SPI的时钟频率，或者没有正确初始化SPI。
回复

收藏 举报

eefas 发表于 2023-10-18 22:07 | 显示全部楼层
如果数据传输模式配置不正确，可能会导致响应时间变慢，需要检查数据传输模式的配置。
回复

收藏 举报

 楼主| Hufei1994 发表于 2023-10-18 23:04 | 显示全部楼层
呐咯密密 发表于 2023-10-18 17:21
这是我从STM32H743的HALL库里面找出来的的SPI发送接收函数，从你进入函数开始到真正将数据开始送出，前面 ...

感谢解惑，改日我使用寄存器来重写一下看看速度能否提升
回复

收藏 举报

呐咯密密 发表于 2023-10-19 09:14 | 显示全部楼层
Hufei1994 发表于 2023-10-18 23:04
感谢解惑，改日我使用寄存器来重写一下看看速度能否提升

测试完记得回来结贴，给问题一个答案
回复

收藏 举报

abotomson 发表于 2023-10-22 10:50 | 显示全部楼层
减小硬件电路延迟对SPI CLK响应速度的影响。
回复

收藏 举报

10299823 发表于 2023-10-22 11:44 | 显示全部楼层
可以优化程序结构，减少系统资源占用，提高响应速度。
回复

收藏 举报

modesty3jonah 发表于 2023-10-22 11:53 | 显示全部楼层
如果STM32单片机同时运行多个任务或程序，可能会导致系统资源占用过多，从而影响SPI接口的响应速度。
回复

收藏 举报

下一页 »
12345下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部