397 lines
16 KiB
C
397 lines
16 KiB
C
/************************************************************************************//**
|
|
* \file Source/ARMCM7_STM32H7/can.c
|
|
* \brief Bootloader CAN communication interface source file.
|
|
* \ingroup Target_ARMCM7_STM32H7
|
|
* \internal
|
|
*----------------------------------------------------------------------------------------
|
|
* C O P Y R I G H T
|
|
*----------------------------------------------------------------------------------------
|
|
* Copyright (c) 2020 by Feaser http://www.feaser.com All rights reserved
|
|
*
|
|
*----------------------------------------------------------------------------------------
|
|
* L I C E N S E
|
|
*----------------------------------------------------------------------------------------
|
|
* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation, either version 3 of the License, or (at your option) any later
|
|
* version.
|
|
*
|
|
* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You have received a copy of the GNU General Public License along with OpenBLT. It
|
|
* should be located in ".\Doc\license.html". If not, contact Feaser to obtain a copy.
|
|
*
|
|
* \endinternal
|
|
****************************************************************************************/
|
|
|
|
|
|
/****************************************************************************************
|
|
* Include files
|
|
****************************************************************************************/
|
|
#include "boot.h" /* bootloader generic header */
|
|
#if (BOOT_COM_CAN_ENABLE > 0)
|
|
#include "stm32h7xx.h" /* STM32 CPU and HAL header */
|
|
#include "stm32h7xx_ll_rcc.h" /* STM32 LL RCC header */
|
|
|
|
|
|
/****************************************************************************************
|
|
* Macro definitions
|
|
****************************************************************************************/
|
|
/** \brief Timeout for transmitting a CAN message in milliseconds. */
|
|
#define CAN_MSG_TX_TIMEOUT_MS (50u)
|
|
|
|
/* map the configured CAN channel index to the STM32's CAN peripheral */
|
|
#if (BOOT_COM_CAN_CHANNEL_INDEX == 0)
|
|
/** \brief Set CAN base address to CAN1. */
|
|
#define CAN_CHANNEL FDCAN1
|
|
#elif (BOOT_COM_CAN_CHANNEL_INDEX == 1)
|
|
/** \brief Set CAN base address to CAN2. */
|
|
#define CAN_CHANNEL FDCAN2
|
|
#endif
|
|
|
|
|
|
/****************************************************************************************
|
|
* Type definitions
|
|
****************************************************************************************/
|
|
/** \brief Structure type for grouping CAN bus timing related information. */
|
|
typedef struct t_can_bus_timing
|
|
{
|
|
blt_int8u tseg1; /**< CAN time segment 1 */
|
|
blt_int8u tseg2; /**< CAN time segment 2 */
|
|
} tCanBusTiming;
|
|
|
|
|
|
/****************************************************************************************
|
|
* Local constant declarations
|
|
****************************************************************************************/
|
|
/** \brief CAN bittiming table for dynamically calculating the bittiming settings.
|
|
* \details According to the CAN protocol 1 bit-time can be made up of between 8..25
|
|
* time quanta (TQ). The total TQ in a bit is SYNC + TSEG1 + TSEG2 with SYNC
|
|
* always being 1. The sample point is (SYNC + TSEG1) / (SYNC + TSEG1 + SEG2) *
|
|
* 100%. This array contains possible and valid time quanta configurations with
|
|
* a sample point between 68..78%.
|
|
*/
|
|
static const tCanBusTiming canTiming[] =
|
|
{
|
|
/* TQ | TSEG1 | TSEG2 | SP */
|
|
/* ------------------------- */
|
|
{ 5, 2 }, /* 8 | 5 | 2 | 75% */
|
|
{ 6, 2 }, /* 9 | 6 | 2 | 78% */
|
|
{ 6, 3 }, /* 10 | 6 | 3 | 70% */
|
|
{ 7, 3 }, /* 11 | 7 | 3 | 73% */
|
|
{ 8, 3 }, /* 12 | 8 | 3 | 75% */
|
|
{ 9, 3 }, /* 13 | 9 | 3 | 77% */
|
|
{ 9, 4 }, /* 14 | 9 | 4 | 71% */
|
|
{ 10, 4 }, /* 15 | 10 | 4 | 73% */
|
|
{ 11, 4 }, /* 16 | 11 | 4 | 75% */
|
|
{ 12, 4 }, /* 17 | 12 | 4 | 76% */
|
|
{ 12, 5 }, /* 18 | 12 | 5 | 72% */
|
|
{ 13, 5 }, /* 19 | 13 | 5 | 74% */
|
|
{ 14, 5 }, /* 20 | 14 | 5 | 75% */
|
|
{ 15, 5 }, /* 21 | 15 | 5 | 76% */
|
|
{ 15, 6 }, /* 22 | 15 | 6 | 73% */
|
|
{ 16, 6 }, /* 23 | 16 | 6 | 74% */
|
|
{ 16, 7 }, /* 24 | 16 | 7 | 71% */
|
|
{ 16, 8 } /* 25 | 16 | 8 | 68% */
|
|
};
|
|
|
|
|
|
/****************************************************************************************
|
|
* Local data declarations
|
|
****************************************************************************************/
|
|
/** \brief CAN handle to be used in API calls. */
|
|
static FDCAN_HandleTypeDef canHandle;
|
|
|
|
|
|
/************************************************************************************//**
|
|
** \brief Search algorithm to match the desired baudrate to a possible bus
|
|
** timing configuration.
|
|
** \param baud The desired baudrate in kbps. Valid values are 10..1000.
|
|
** \param prescaler Pointer to where the value for the prescaler will be stored.
|
|
** \param tseg1 Pointer to where the value for TSEG2 will be stored.
|
|
** \param tseg2 Pointer to where the value for TSEG2 will be stored.
|
|
** \return BLT_TRUE if the CAN bustiming register values were found, BLT_FALSE
|
|
** otherwise.
|
|
**
|
|
****************************************************************************************/
|
|
static blt_bool CanGetSpeedConfig(blt_int16u baud, blt_int16u *prescaler,
|
|
blt_int8u *tseg1, blt_int8u *tseg2)
|
|
{
|
|
blt_int8u cnt;
|
|
blt_int32u canClockFreqkHz;
|
|
|
|
/* the CAN peripheral can be clocked by the external crystal, the PLL1Q or the PLL2Q
|
|
* clock. the external crystal option is typically preferred to meet the clock
|
|
* tolerance specified in the CAN 2.0B protocol. therefore, this driver assumes that
|
|
* an external crystal is present. configure the external crystal to be the clock
|
|
* source of the CAN peripheral.
|
|
*/
|
|
LL_RCC_SetFDCANClockSource(LL_RCC_FDCAN_CLKSOURCE_HSE);
|
|
canClockFreqkHz = BOOT_CPU_XTAL_SPEED_KHZ;
|
|
|
|
/* loop through all possible time quanta configurations to find a match */
|
|
for (cnt=0; cnt < sizeof(canTiming)/sizeof(canTiming[0]); cnt++)
|
|
{
|
|
if ((canClockFreqkHz % (baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1))) == 0)
|
|
{
|
|
/* compute the prescaler that goes with this TQ configuration */
|
|
*prescaler = canClockFreqkHz/(baud*(canTiming[cnt].tseg1+canTiming[cnt].tseg2+1));
|
|
|
|
/* make sure the prescaler is valid */
|
|
if ((*prescaler > 0) && (*prescaler <= 512))
|
|
{
|
|
/* store the bustiming configuration */
|
|
*tseg1 = canTiming[cnt].tseg1;
|
|
*tseg2 = canTiming[cnt].tseg2;
|
|
/* found a good bus timing configuration */
|
|
return BLT_TRUE;
|
|
}
|
|
}
|
|
}
|
|
/* could not find a good bus timing configuration */
|
|
return BLT_FALSE;
|
|
} /*** end of CanGetSpeedConfig ***/
|
|
|
|
|
|
/************************************************************************************//**
|
|
** \brief Initializes the CAN controller and synchronizes it to the CAN bus.
|
|
** \return none.
|
|
**
|
|
****************************************************************************************/
|
|
void CanInit(void)
|
|
{
|
|
blt_int16u prescaler = 0;
|
|
blt_int8u tseg1 = 0, tseg2 = 0;
|
|
blt_int32u rxMsgId = BOOT_COM_CAN_RX_MSG_ID;
|
|
FDCAN_FilterTypeDef filterConfig;
|
|
|
|
/* the current implementation supports CAN1 and 2. throw an assertion error in case a
|
|
* different CAN channel is configured.
|
|
*/
|
|
ASSERT_CT((BOOT_COM_CAN_CHANNEL_INDEX == 0 || BOOT_COM_CAN_CHANNEL_INDEX == 1));
|
|
|
|
/* obtain bittiming configuration information. */
|
|
if (CanGetSpeedConfig(BOOT_COM_CAN_BAUDRATE/1000, &prescaler, &tseg1, &tseg2) == BLT_FALSE)
|
|
{
|
|
/* Incorrect configuration. The specified baudrate is not supported for the given
|
|
* clock configuration. Verify the following settings in blt_conf.h:
|
|
* - BOOT_COM_CAN_BAUDRATE
|
|
* - BOOT_CPU_XTAL_SPEED_KHZ
|
|
* - BOOT_CPU_SYSTEM_SPEED_KHZ
|
|
*/
|
|
ASSERT_RT(BLT_FALSE);
|
|
}
|
|
|
|
/* set the CAN controller configuration. */
|
|
canHandle.Instance = CAN_CHANNEL;
|
|
canHandle.Init.FrameFormat = FDCAN_FRAME_CLASSIC;
|
|
canHandle.Init.Mode = FDCAN_MODE_NORMAL;
|
|
canHandle.Init.AutoRetransmission = ENABLE;
|
|
canHandle.Init.TransmitPause = DISABLE;
|
|
canHandle.Init.ProtocolException = DISABLE;
|
|
canHandle.Init.NominalPrescaler = prescaler;
|
|
canHandle.Init.NominalSyncJumpWidth = 1;
|
|
canHandle.Init.NominalTimeSeg1 = tseg1;
|
|
canHandle.Init.NominalTimeSeg2 = tseg2;
|
|
/* FD mode is not used by this driver, so the .Init.DataXxx values are don't care. */
|
|
canHandle.Init.DataPrescaler = 1;
|
|
canHandle.Init.DataSyncJumpWidth = 1;
|
|
canHandle.Init.DataTimeSeg1 = 1;
|
|
canHandle.Init.DataTimeSeg2 = 1;
|
|
canHandle.Init.MessageRAMOffset = 0;
|
|
/* does the message to be received have a standard 11-bit CAN identifier? */
|
|
if ((rxMsgId & 0x80000000) == 0)
|
|
{
|
|
canHandle.Init.StdFiltersNbr = 1;
|
|
canHandle.Init.ExtFiltersNbr = 0;
|
|
}
|
|
else
|
|
{
|
|
canHandle.Init.StdFiltersNbr = 0;
|
|
canHandle.Init.ExtFiltersNbr = 1;
|
|
}
|
|
/* only reception FIFO 0 is used. */
|
|
canHandle.Init.RxFifo0ElmtsNbr = 1;
|
|
canHandle.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8;
|
|
canHandle.Init.RxFifo1ElmtsNbr = 0;
|
|
canHandle.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
|
|
canHandle.Init.RxBuffersNbr = 0;
|
|
canHandle.Init.RxBufferSize = FDCAN_DATA_BYTES_8;
|
|
/* only one transmit buffer is needed. transmit FIFO is not used. */
|
|
canHandle.Init.TxEventsNbr = 0;
|
|
canHandle.Init.TxBuffersNbr = 1;
|
|
canHandle.Init.TxFifoQueueElmtsNbr = 0;
|
|
canHandle.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
|
|
canHandle.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
|
|
/* initialize the CAN controller. this only fails if the CAN controller hardware is
|
|
* faulty. no need to evaluate the return value as there is nothing we can do about
|
|
* a faulty CAN controller.
|
|
*/
|
|
(void)HAL_FDCAN_Init(&canHandle);
|
|
|
|
/* configure the reception filter. note that the implementation of this function
|
|
* always returns HAL_OK as long as the CAN controller is initialized, so no need to
|
|
* evaluate the return value.
|
|
*/
|
|
if ((rxMsgId & 0x80000000) == 0)
|
|
{
|
|
filterConfig.IdType = FDCAN_STANDARD_ID;
|
|
}
|
|
else
|
|
{
|
|
filterConfig.IdType = FDCAN_EXTENDED_ID;
|
|
/* negate the ID-type bit */
|
|
rxMsgId &= ~0x80000000;
|
|
}
|
|
filterConfig.FilterIndex = 0;
|
|
filterConfig.FilterType = FDCAN_FILTER_DUAL;
|
|
filterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
|
|
filterConfig.FilterID1 = rxMsgId;
|
|
filterConfig.FilterID2 = rxMsgId;
|
|
filterConfig.RxBufferIndex = 0;
|
|
(void)HAL_FDCAN_ConfigFilter(&canHandle, &filterConfig);
|
|
|
|
/* configure global filter to reject all non-matching frames. */
|
|
HAL_FDCAN_ConfigGlobalFilter(&canHandle, FDCAN_REJECT, FDCAN_REJECT,
|
|
FDCAN_REJECT_REMOTE, FDCAN_REJECT_REMOTE);
|
|
|
|
/* start the CAN peripheral. no need to evaluate the return value as there is nothing
|
|
* we can do about a faulty CAN controller. */
|
|
(void)HAL_FDCAN_Start(&canHandle);
|
|
} /*** end of CanInit ***/
|
|
|
|
|
|
/************************************************************************************//**
|
|
** \brief Transmits a packet formatted for the communication interface.
|
|
** \param data Pointer to byte array with data that it to be transmitted.
|
|
** \param len Number of bytes that are to be transmitted.
|
|
** \return none.
|
|
**
|
|
****************************************************************************************/
|
|
void CanTransmitPacket(blt_int8u *data, blt_int8u len)
|
|
{
|
|
blt_int32u txMsgId = BOOT_COM_CAN_TX_MSG_ID;
|
|
FDCAN_TxHeaderTypeDef txMsgHeader;
|
|
blt_int32u timeout;
|
|
HAL_StatusTypeDef status;
|
|
|
|
/* configure the message that should be transmitted. */
|
|
if ((txMsgId & 0x80000000) == 0)
|
|
{
|
|
/* set the 11-bit CAN identifier. */
|
|
txMsgHeader.Identifier = txMsgId;
|
|
txMsgHeader.IdType = FDCAN_STANDARD_ID;
|
|
}
|
|
else
|
|
{
|
|
/* negate the ID-type bit. */
|
|
txMsgId &= ~0x80000000;
|
|
/* set the 29-bit CAN identifier. */
|
|
txMsgHeader.Identifier = txMsgId;
|
|
txMsgHeader.IdType = FDCAN_EXTENDED_ID;
|
|
}
|
|
txMsgHeader.TxFrameType = FDCAN_DATA_FRAME;
|
|
txMsgHeader.DataLength = len << 16U;
|
|
txMsgHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
|
|
txMsgHeader.BitRateSwitch = FDCAN_BRS_OFF;
|
|
txMsgHeader.FDFormat = FDCAN_CLASSIC_CAN;
|
|
txMsgHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;
|
|
txMsgHeader.MessageMarker = 0x52;
|
|
|
|
/* add the message to the transmit buffer. */
|
|
status = HAL_FDCAN_AddMessageToTxBuffer(&canHandle, &txMsgHeader, data,
|
|
FDCAN_TX_BUFFER0);
|
|
/* only continue with the transmission if the message was added to the buffer. */
|
|
if (status == HAL_OK)
|
|
{
|
|
/* submit the message for transmission. */
|
|
status = HAL_FDCAN_EnableTxBufferRequest(&canHandle, FDCAN_TX_BUFFER0);
|
|
/* only continue with polling for transmit completion if the message transmit request
|
|
* could be submitted.
|
|
*/
|
|
if (status == HAL_OK)
|
|
{
|
|
/* determine timeout time for the transmit completion. */
|
|
timeout = TimerGet() + CAN_MSG_TX_TIMEOUT_MS;
|
|
/* poll for completion of the transmit operation. */
|
|
while (HAL_FDCAN_IsTxBufferMessagePending(&canHandle, FDCAN_TX_BUFFER0) != 0)
|
|
{
|
|
/* service the watchdog. */
|
|
CopService();
|
|
/* break loop upon timeout. this would indicate a hardware failure or no other
|
|
* nodes connected to the bus.
|
|
*/
|
|
if (TimerGet() > timeout)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} /*** end of CanTransmitPacket ***/
|
|
|
|
|
|
/************************************************************************************//**
|
|
** \brief Receives a communication interface packet if one is present.
|
|
** \param data Pointer to byte array where the data is to be stored.
|
|
** \param len Pointer where the length of the packet is to be stored.
|
|
** \return BLT_TRUE is a packet was received, BLT_FALSE otherwise.
|
|
**
|
|
****************************************************************************************/
|
|
blt_bool CanReceivePacket(blt_int8u *data, blt_int8u *len)
|
|
{
|
|
blt_bool result = BLT_FALSE;
|
|
blt_int32u rxMsgId = BOOT_COM_CAN_RX_MSG_ID;
|
|
FDCAN_RxHeaderTypeDef rxMsgHeader;
|
|
HAL_StatusTypeDef rxStatus = HAL_ERROR;
|
|
|
|
/* check if the expected CAN message was received? */
|
|
if (HAL_FDCAN_GetRxFifoFillLevel(&canHandle, FDCAN_RX_FIFO0) > 0)
|
|
{
|
|
/* attempt to read the newly received CAN message from its buffer. */
|
|
rxStatus = HAL_FDCAN_GetRxMessage(&canHandle, FDCAN_RX_FIFO0, &rxMsgHeader, data);
|
|
}
|
|
|
|
/* only continue processing the CAN message if something was received. */
|
|
if (rxStatus == HAL_OK)
|
|
{
|
|
/* check if this message has the configured CAN packet identifier. */
|
|
if ((rxMsgId & 0x80000000) == 0)
|
|
{
|
|
/* was an 11-bit CAN message received that matches? */
|
|
if ( (rxMsgHeader.Identifier == rxMsgId) &&
|
|
(rxMsgHeader.IdType == FDCAN_STANDARD_ID) )
|
|
{
|
|
/* set flag that a packet with a matching CAN identifier was received. */
|
|
result = BLT_TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* negate the ID-type bit. */
|
|
rxMsgId &= ~0x80000000;
|
|
/* was an 29-bit CAN message received that matches? */
|
|
if ( (rxMsgHeader.Identifier == rxMsgId) &&
|
|
(rxMsgHeader.IdType == FDCAN_EXTENDED_ID) )
|
|
{
|
|
/* set flag that a packet with a matching CAN identifier was received. */
|
|
result = BLT_TRUE;
|
|
}
|
|
}
|
|
/* store the data length. */
|
|
if (result == BLT_TRUE)
|
|
{
|
|
*len = (blt_int8u)(rxMsgHeader.DataLength >> 16U);
|
|
}
|
|
}
|
|
|
|
/* Give the result back to the caller. */
|
|
return result;
|
|
} /*** end of CanReceivePacket ***/
|
|
#endif /* BOOT_COM_CAN_ENABLE > 0 */
|
|
|
|
|
|
/*********************************** end of can.c **************************************/
|