STM32L476+ST253993代码移植

m261678889 提问时间：2020-2-2 22:11 /

问答
是否解决:

我准备在官方的STM32L476+ST253993增加freertos，但是代码下进去系统运行时就卡住，单步调试，系统一直卡在prvCheckTasksWaitingTermination中。rtos使用systick，HAL_delay使用TIM7

freertos的两个任务，一个是LED闪烁，一个是RFID测试程序
第一次执行时，任务2的第一个测试代码完成后，到osdelay里就出不来了

RFID测试程序中发送只要屏蔽一行代码，系统就可以正常运行
基本可以判定是下面的代码跟osdelay发生了什么冲突，导致系统死在prvCheckTasksWaitingTermination函数中

继续屏蔽代码查找到冲突代码，下面的红线

到这就无法继续查找原因了，

继续屏蔽代码，发现HAL_SPI_TransmitReceive系统SPI函数这出现的问题

可，这个系统HAL函数跟osdelay由啥关系呢，两者不应该冲突啊？？
附上系统SPI函数
************************************
HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size,
                                       uint32_t Timeout)
{
  uint16_t          initial_TxXferCount;
  uint32_t          tmp_mode;
  HAL_SPI_StateTypeDef tmp_state;
  uint32_t          tickstart;
  /* Variable used to alternate Rx and Tx during transfer */
  uint32_t          txallowed = 1U;
  HAL_StatusTypeDef errorcode = HAL_OK;
  /* Check Direction parameter */
  assert_param(IS_SPI_DIRECTION_2LINES(hspi->Init.Direction));
  /* Process Locked */
  __HAL_LOCK(hspi);
  /* Init tickstart for timeout management*/
  tickstart = HAL_GetTick();
  /* Init temporary variables */
  tmp_state          = hspi->State;
  tmp_mode          = hspi->Init.Mode;
  initial_TxXferCount = Size;
  if (!((tmp_state == HAL_SPI_STATE_READY) || \
      ((tmp_mode == SPI_MODE_MASTER) && (hspi->Init.Direction == SPI_DIRECTION_2LINES) && (tmp_state == HAL_SPI_STATE_BUSY_RX))))
  {
errorcode = HAL_BUSY;
goto error;
  }
  if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U))
  {
errorcode = HAL_ERROR;
goto error;
  }
  /* Don't overwrite in case of HAL_SPI_STATE_BUSY_RX */
  if (hspi->State != HAL_SPI_STATE_BUSY_RX)
  {
hspi->State = HAL_SPI_STATE_BUSY_TX_RX;
  }
  /* Set the transaction information */
  hspi->ErrorCode = HAL_SPI_ERROR_NONE;
  hspi->pRxBuffPtr  = (uint8_t *)pRxData;
  hspi->RxXferCount = Size;
  hspi->RxXferSize  = Size;
  hspi->pTxBuffPtr  = (uint8_t *)pTxData;
  hspi->TxXferCount = Size;
  hspi->TxXferSize  = Size;
  /*Init field not used in handle to zero */
  hspi->RxISR    = NULL;
  hspi->TxISR    = NULL;
#if (USE_SPI_CRC != 0U)
  /* Reset CRC Calculation */
  if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
  {
SPI_RESET_CRC(hspi);
  }
#endif /* USE_SPI_CRC */
  /* Check if the SPI is already enabled */
  if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
  {
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
  }
  /* Transmit and Receive data in 16 Bit mode */
  if (hspi->Init.DataSize == SPI_DATASIZE_16BIT)
  {
if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))
{
   hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);
   hspi->pTxBuffPtr += sizeof(uint16_t);
   hspi->TxXferCount--;
}
while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))
{
   /* Check TXE flag */
   if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)) && (hspi->TxXferCount > 0U) && (txallowed == 1U))
   {
      hspi->Instance->DR = *((uint16_t *)hspi->pTxBuffPtr);
      hspi->pTxBuffPtr += sizeof(uint16_t);
      hspi->TxXferCount--;
      /* Next Data is a reception (Rx). Tx not allowed */
      txallowed = 0U;
#if (USE_SPI_CRC != 0U)
      /* Enable CRC Transmission */
      if ((hspi->TxXferCount == 0U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))
      {
      SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);
      }
#endif /* USE_SPI_CRC */
   }
   /* Check RXNE flag */
   if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE)) && (hspi->RxXferCount > 0U))
   {
      *((uint16_t *)hspi->pRxBuffPtr) = (uint16_t)hspi->Instance->DR;
      hspi->pRxBuffPtr += sizeof(uint16_t);
      hspi->RxXferCount--;
      /* Next Data is a Transmission (Tx). Tx is allowed */
      txallowed = 1U;
   }
   if (((HAL_GetTick() - tickstart) >=  Timeout) && (Timeout != HAL_MAX_DELAY))
   {
      errorcode = HAL_TIMEOUT;
      goto error;
   }
}
  }
  /* Transmit and Receive data in 8 Bit mode */
  else
  {
if ((hspi->Init.Mode == SPI_MODE_SLAVE) || (initial_TxXferCount == 0x01U))
{
   *((__IO uint8_t *)&hspi->Instance->DR) = (*hspi->pTxBuffPtr);
   hspi->pTxBuffPtr += sizeof(uint8_t);
   hspi->TxXferCount--;
}
while ((hspi->TxXferCount > 0U) || (hspi->RxXferCount > 0U))
{
   /* Check TXE flag */
   if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE)) && (hspi->TxXferCount > 0U) && (txallowed == 1U))
   {
      *(__IO uint8_t *)&hspi->Instance->DR = (*hspi->pTxBuffPtr);
      hspi->pTxBuffPtr++;
      hspi->TxXferCount--;
      /* Next Data is a reception (Rx). Tx not allowed */
      txallowed = 0U;
#if (USE_SPI_CRC != 0U)
      /* Enable CRC Transmission */
      if ((hspi->TxXferCount == 0U) && (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE))
      {
      SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);
      }
#endif /* USE_SPI_CRC */
   }
   /* Wait until RXNE flag is reset */
   if ((__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_RXNE)) && (hspi->RxXferCount > 0U))
   {
      (*(uint8_t *)hspi->pRxBuffPtr) = hspi->Instance->DR;
      hspi->pRxBuffPtr++;
      hspi->RxXferCount--;
      /* Next Data is a Transmission (Tx). Tx is allowed */
      txallowed = 1U;
   }
   if ((((HAL_GetTick() - tickstart) >=  Timeout) && ((Timeout != HAL_MAX_DELAY))) || (Timeout == 0U))
   {
      errorcode = HAL_TIMEOUT;
      goto error;
   }
}
  }
#if (USE_SPI_CRC != 0U)
  /* Read CRC from DR to close CRC calculation process */
  if (hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
  {
/* Wait until TXE flag */
if (SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_RXNE, SET, Timeout, tickstart) != HAL_OK)
{
   /* Error on the CRC reception */
   SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);
   errorcode = HAL_TIMEOUT;
   goto error;
}
/* Read CRC */
READ_REG(hspi->Instance->DR);
  }
  /* Check if CRC error occurred */
  if (__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_CRCERR))
  {
SET_BIT(hspi->ErrorCode, HAL_SPI_ERROR_CRC);
/* Clear CRC Flag */
__HAL_SPI_CLEAR_CRCERRFLAG(hspi);
errorcode = HAL_ERROR;
  }
#endif /* USE_SPI_CRC */
  /* Check the end of the transaction */
  if (SPI_EndRxTxTransaction(hspi, Timeout, tickstart) != HAL_OK)
  {
errorcode = HAL_ERROR;
hspi->ErrorCode = HAL_SPI_ERROR_FLAG;
goto error;
  }
  /* Clear overrun flag in 2 Lines communication mode because received is not read */
  if (hspi->Init.Direction == SPI_DIRECTION_2LINES)
  {
__HAL_SPI_CLEAR_OVRFLAG(hspi);
  }
error :
  hspi->State = HAL_SPI_STATE_READY;
  __HAL_UNLOCK(hspi);
  return errorcode;
}

************************************

新人求助，求助，解惑，谢谢（小弟金币较少，见谅）