使用STM32CubeMX生成HAL直接使用的问题

只看该作者 · 2017-6-16 21:49

使用Cube直接生成的HAL进行can通讯是CAN2总是显示超时

只看该作者 · 2017-6-16 21:51

void MX_can_transAndreceve()
{
CAN_FilterConfTypeDef sFilterConfig;
static CanTxMsgTypeDef       TxMessage;
static CanRxMsgTypeDef       RxMessage;
hcan2.pTxMsg = &TxMessage;
hcan1.pRxMsg = &RxMessage;
/*#############################*/
hcan2.pTxMsg->StdId = 0x11;
hcan2.pTxMsg->RTR = CAN_RTR_DATA;
hcan2.pTxMsg->IDE = CAN_ID_STD;
hcan2.pTxMsg->DLC = 8;
hcan2.pTxMsg->Data[0] = 0Xff;
hcan2.pTxMsg->Data[1] = 0x00;
hcan2.pTxMsg->Data[2] = 0xff;
hcan2.pTxMsg->Data[3] = 0x00;
hcan2.pTxMsg->Data[4] = 0xff;
hcan2.pTxMsg->Data[5] = 0x00;
hcan2.pTxMsg->Data[6] = 0xff;
hcan2.pTxMsg->Data[7] = 0x00;

/*#############################*/
sFilterConfig.FilterNumber = 0;
sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
sFilterConfig.FilterIdHigh = 0x0000;
sFilterConfig.FilterIdLow = 0x0000;
sFilterConfig.FilterMaskIdHigh = 0x0000;
sFilterConfig.FilterMaskIdLow = 0x0000;
sFilterConfig.FilterFIFOAssignment = 0;
sFilterConfig.FilterActivation = ENABLE;
sFilterConfig.BankNumber = 14;
// HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig); ÂË²¨
if (HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig) != HAL_OK)
  {
/* Filter configuration Error */
Error_Handler();
  }

}
void MX_can_use()
{

if(HAL_CAN_Transmit(&hcan2, 100) != HAL_OK)
{
Error_Handler();

}
if(HAL_CAN_GetState(&hcan2) != HAL_CAN_STATE_READY)
{
   Error_Handler();
}
/*###############################################*/
if(HAL_CAN_Receive(&hcan1, CAN_FIFO0,10) != HAL_OK)
{
Error_Handler();
}

if(HAL_CAN_GetState(&hcan1) != HAL_CAN_STATE_READY)
{
Error_Handler();
}
HAL_Delay(1000);

}

只看该作者 · 2017-6-16 21:52

配置部分
static void MX_CAN1_Init(void)
{

  hcan1.Instance = CAN1;
  hcan1.Init.Prescaler = 5;
  hcan1.Init.Mode = CAN_MODE_NORMAL;
  hcan1.Init.SJW = CAN_SJW_1TQ;
  hcan1.Init.BS1 = CAN_BS1_3TQ;
  hcan1.Init.BS2 = CAN_BS2_5TQ;
  hcan1.Init.TTCM = DISABLE;
  hcan1.Init.ABOM = ENABLE;
  hcan1.Init.AWUM = DISABLE;
  hcan1.Init.NART = DISABLE;
  hcan1.Init.RFLM = DISABLE;
  hcan1.Init.TXFP = DISABLE;
  if (HAL_CAN_Init(&hcan1) != HAL_OK)
  {
_Error_Handler(__FILE__, __LINE__);
  }

}

static void MX_CAN2_Init(void)
{

  hcan2.Instance = CAN2;
  hcan2.Init.Prescaler = 5;
  hcan2.Init.Mode = CAN_MODE_NORMAL;
  hcan2.Init.SJW = CAN_SJW_1TQ;
  hcan2.Init.BS1 = CAN_BS1_3TQ;
  hcan2.Init.BS2 = CAN_BS2_5TQ;
  hcan2.Init.TTCM = DISABLE;
  hcan2.Init.ABOM = ENABLE;
  hcan2.Init.AWUM = DISABLE;
  hcan2.Init.NART = DISABLE;
  hcan2.Init.RFLM = DISABLE;
  hcan2.Init.TXFP = DISABLE;
  if (HAL_CAN_Init(&hcan2) != HAL_OK)
  {
_Error_Handler(__FILE__, __LINE__);
  }

}

只看该作者 · 2017-6-16 21:53

hal库can启动部分包括自己分析出问题的位置
HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan)
{
  uint32_t InitStatus = CAN_INITSTATUS_FAILED;
  uint32_t tickstart = 0U;

  /* Check CAN handle */
  if(hcan == NULL)
  {
   return HAL_ERROR;
  }

  /* Check the parameters */
  assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TTCM));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.ABOM));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AWUM));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.NART));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.RFLM));
  assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TXFP));
  assert_param(IS_CAN_MODE(hcan->Init.Mode));
  assert_param(IS_CAN_SJW(hcan->Init.SJW));
  assert_param(IS_CAN_BS1(hcan->Init.BS1));
  assert_param(IS_CAN_BS2(hcan->Init.BS2));
  assert_param(IS_CAN_PRESCALER(hcan->Init.Prescaler));


  if(hcan->State == HAL_CAN_STATE_RESET)
  {
/* Allocate lock resource and initialize it */
hcan->Lock = HAL_UNLOCKED;
/* Init the low level hardware */
HAL_CAN_MspInit(hcan);
  }

  /* Initialize the CAN state*/
  hcan->State = HAL_CAN_STATE_BUSY;

  /* Exit from sleep mode */
  hcan->Instance->MCR &= (~(uint32_t)CAN_MCR_SLEEP);

  /* Request initialisation */
  hcan->Instance->MCR |= CAN_MCR_INRQ ;

  /* Get tick */
  tickstart = HAL_GetTick();

  /* Wait the acknowledge */
  while((hcan->Instance->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)  //µ÷ÊÔÏÔÊ¾³¬Ê±Î»ÖÃ
  {
if((HAL_GetTick() - tickstart ) > CAN_TIMEOUT_VALUE)
{
   hcan->State= HAL_CAN_STATE_TIMEOUT;
   /* Process unlocked */
   __HAL_UNLOCK(hcan);
   return HAL_TIMEOUT;
}
  }

  /* Check acknowledge */
  if ((hcan->Instance->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
  {
/* Set the time triggered communication mode */
if (hcan->Init.TTCM == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_TTCM;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_TTCM;
}

/* Set the automatic bus-off management */
if (hcan->Init.ABOM == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_ABOM;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_ABOM;
}

/* Set the automatic wake-up mode */
if (hcan->Init.AWUM == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_AWUM;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_AWUM;
}

/* Set the no automatic retransmission */
if (hcan->Init.NART == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_NART;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_NART;
}

/* Set the receive FIFO locked mode */
if (hcan->Init.RFLM == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_RFLM;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_RFLM;
}

/* Set the transmit FIFO priority */
if (hcan->Init.TXFP == ENABLE)
{
   hcan->Instance->MCR |= CAN_MCR_TXFP;
}
else
{
   hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_TXFP;
}

/* Set the bit timing register */
hcan->Instance->BTR = (uint32_t)((uint32_t)hcan->Init.Mode) | \
            ((uint32_t)hcan->Init.SJW) | \
            ((uint32_t)hcan->Init.BS1) | \
            ((uint32_t)hcan->Init.BS2) | \
            ((uint32_t)hcan->Init.Prescaler - 1U);

/* Request leave initialisation */
hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_INRQ;

  /* Get tick */
  tickstart = HAL_GetTick();

/* Wait the acknowledge */
while((hcan->Instance->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
{
if((HAL_GetTick() - tickstart ) > CAN_TIMEOUT_VALUE)
   {
   hcan->State= HAL_CAN_STATE_TIMEOUT;
   /* Process unlocked */
   __HAL_UNLOCK(hcan);
   return HAL_TIMEOUT;
   }
}

/* Check acknowledged */
if ((hcan->Instance->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
{
   InitStatus = CAN_INITSTATUS_SUCCESS;
}
  }

  if(InitStatus == CAN_INITSTATUS_SUCCESS)
  {
/* Set CAN error code to none */
hcan->ErrorCode = HAL_CAN_ERROR_NONE;

/* Initialize the CAN state */
hcan->State = HAL_CAN_STATE_READY;

/* Return function status */
return HAL_OK;
  }
  else
  {
/* Initialize the CAN state */
hcan->State = HAL_CAN_STATE_ERROR;

/* Return function status */
return HAL_ERROR;
  }
}

只看该作者 · 2017-6-16 21:54

while((hcan->Instance->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) //µ÷ÊÔÏÔÊ¾³¬Ê±Î»ÖÃ
这个乱码的地方就是出问题的部分//后面本来是调试显示超时位置

使用STM32CubeMX生成HAL直接使用的问题

相关下载

相关帖子