STM32F429 МОЖЕТ получить (опрос) не работает - PullRequest
0 голосов
/ 08 мая 2018

Я использую устройство STM32F429 для опроса CAN, передающего и получающего сообщения.

Я использовал часть примера LOOPBACK "STM32Cube_FW_F4_V1.21.0". По разнице я переключил режим обратной петли в нормальный режим.

Я могу успешно передавать сообщения, но не могу получить ни одного сообщения. Я передаю сообщения CAN с Id = 0x22 с другого устройства на STM32F429, но он не может их получить, и уровень FIFO всегда равен нулю. Вот код:

/* Includes -------------------------------------------------------- */
#include "main.h"
#include "stm32f4xx_hal.h"

/* USER CODE BEGIN Includes */
/* USER CODE END Includes */


/* Private variables ----------------------------------------------- */
CAN_HandleTypeDef hcan1;


/* USER CODE BEGIN PV */
/* Private variables ----------------------------------------------- */

/* USER CODE END PV */


/* Private function prototypes ------------------------------------- */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN1_Init(void);
void Can_Transmit();
void Can_Recieve();

CAN_HandleTypeDef   CanHandle;
CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
uint8_t             TxData[8];
uint8_t             RxData[8];
uint32_t            TxMailbox;
uint32_t            RcvData = 0;
uint32_t            td = 0x67;
uint8_t             ERR = 0;


/* USER CODE BEGIN PFP */
/* Private function prototypes ------------------------------------- */
/* USER CODE END PFP */


/* USER CODE BEGIN 0 */
/* USER CODE END 0 */


/**
    * @brief  The application entry point.
    *
    * @retval None
    */
int main(void)
{
    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

    /* MCU Configuration---------------------------------------------------------- */

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();

    /* USER CODE BEGIN Init */
    /* USER CODE END Init */


    /* Configure the system clock */
    SystemClock_Config();

    /* USER CODE BEGIN SysInit */
    /* USER CODE END SysInit */


    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_CAN1_Init();


    /* USER CODE BEGIN 2 */
    /* USER CODE END 2 */


    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1)
    {
        if (HAL_CAN_GetRxFifoFillLevel(&CanHandle, CAN_RX_FIFO0) != 1)
        {
            /* Reception Missing */
            Error_Handler();
        }

        if (HAL_CAN_GetRxMessage(&CanHandle, CAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK)
        {
            /* Reception Error */
            Error_Handler();
        }

        if (RxHeader.StdId == 0x22)
            RcvData  = ((RxData[1]<<8) | RxData[0]);
    }
}


/**
    * @brief System Clock Configuration
    * @retval None
    */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct;
    RCC_ClkInitTypeDef RCC_ClkInitStruct;

    /** Configure the main internal regulator output voltage */
    __HAL_RCC_PWR_CLK_ENABLE();

    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

    /** Initializes the CPU, AHB and APB busses clocks */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 8;
    RCC_OscInitStruct.PLL.PLLN = 336;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 4;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        _Error_Handler(__FILE__, __LINE__);
    }

    /** Initializes the CPU, AHB and APB busses clocks */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                                                    |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
    {
        _Error_Handler(__FILE__, __LINE__);
    }

    /** Configure the Systick interrupt time */
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

    /** Configure the Systick */
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

    /* SysTick_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}


/* CAN1 init function */
static void MX_CAN1_Init(void)
{
    CAN_FilterTypeDef  sFilterConfig;

    /* ## -1- Configure the CAN peripheral ########################### */
    CanHandle.Instance = CAN1;

    CanHandle.Init.TimeTriggeredMode = DISABLE;
    CanHandle.Init.AutoBusOff = DISABLE;
    CanHandle.Init.AutoWakeUp = DISABLE;
    CanHandle.Init.AutoRetransmission = ENABLE;
    CanHandle.Init.ReceiveFifoLocked = DISABLE;
    CanHandle.Init.TransmitFifoPriority = DISABLE;
    CanHandle.Init.Mode = CAN_MODE_NORMAL;
    CanHandle.Init.SyncJumpWidth = CAN_SJW_1TQ;
    CanHandle.Init.TimeSeg1 = CAN_BS1_4TQ;
    CanHandle.Init.TimeSeg2 = CAN_BS2_2TQ;
    CanHandle.Init.Prescaler = 12;

    if (HAL_CAN_Init(&CanHandle) != HAL_OK)
    {
        /* Initialization Error */
        Error_Handler();
    }

    /* ## -2- Configure the CAN Filter ############################### */
    sFilterConfig.FilterBank = 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 = CAN_RX_FIFO0;
    sFilterConfig.FilterActivation = ENABLE;
    sFilterConfig.SlaveStartFilterBank = 14;

    if (HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig) != HAL_OK)
    {
        /* Filter configuration Error */
        Error_Handler();
    }

    /* ## -3- Start the CAN peripheral ############################### */
    if (HAL_CAN_Start(&CanHandle) != HAL_OK)
    {
        /* Start Error */
        Error_Handler();
    }
}


/** Configure pins as
                * Analog
                * Input
                * Output
                * EVENT_OUT
                * EXTI
*/
static void MX_GPIO_Init(void)
{
    /* GPIO Ports Clock Enable */
    __HAL_RCC_GPIOH_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
}


/* USER CODE BEGIN 4 */
/* USER CODE END 4 */


/**
    * @brief  This function is executed in case of error occurrence.
    * @param  file: The file name as string.
    * @param  line: The line in file as a number.
    * @retval None
    */
void _Error_Handler(char *file, int line)
{
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL
       error return state */
    while(1){
    }
    /* USER CODE END Error_Handler_Debug */
}

1 Ответ

0 голосов
/ 10 июля 2018

Если это все еще активно, попробуйте sth. как это:

//set filter / mask to accept every identifier
CAN_FilterTypeDef filter = {0};
filter.FilterIdHigh = 0x1fff;
filter.FilterIdLow = 0xffff;
filter.FilterMaskIdHigh = 0;
filter.FilterMaskIdLow = 0;
filter.FilterFIFOAssignment = CAN_RX_FIFO0;
filter.FilterBank = 0;
filter.FilterMode = CAN_FILTERMODE_IDMASK;
filter.FilterScale = CAN_FILTERSCALE_16BIT;
filter.FilterActivation = ENABLE;
filter.SlaveStartFilterBank = 0;
if (HAL_CAN_ConfigFilter(&can_handle, &filter) != HAL_OK)
    return (1);
...