// Start the CAN peripheral
void can_enable(void)
{
if (bus_state == OFF_BUS)
{
can_handle.Init.Prescaler = prescaler;
can_handle.Init.Mode = CAN_MODE_NORMAL;
can_handle.Init.SJW = CAN_SJW_1TQ;
can_handle.Init.BS1 = CAN_BS1_4TQ;
can_handle.Init.BS2 = CAN_BS2_3TQ;
can_handle.Init.TTCM = DISABLE;
can_handle.Init.ABOM = ENABLE;
can_handle.Init.AWUM = DISABLE;
can_handle.Init.NART = can_nart;
can_handle.Init.RFLM = DISABLE;
can_handle.Init.TXFP = DISABLE;
can_handle.pTxMsg = NULL;
HAL_CAN_Init(&can_handle);
HAL_CAN_ConfigFilter(&can_handle, &filter);
bus_state = ON_BUS;
led_blue_on();
}
}
/**
* @brief Configures the CAN, transmit and receive by polling
* @param None
* @retval PASSED if the reception is well done, FAILED in other case
*/
HAL_StatusTypeDef CAN_Polling(void)
{
CAN_FilterConfTypeDef sFilterConfig;
static CanTxMsgTypeDef TxMessage;
static CanRxMsgTypeDef RxMessage;
/*##-1- Configure the CAN peripheral #######################################*/
CanHandle.Instance = CANx;
CanHandle.pTxMsg = &TxMessage;
CanHandle.pRxMsg = &RxMessage;
CanHandle.Init.TTCM = DISABLE;
CanHandle.Init.ABOM = DISABLE;
CanHandle.Init.AWUM = DISABLE;
CanHandle.Init.NART = DISABLE;
CanHandle.Init.RFLM = DISABLE;
CanHandle.Init.TXFP = DISABLE;
CanHandle.Init.Mode = CAN_MODE_LOOPBACK;
CanHandle.Init.SJW = CAN_SJW_1TQ;
CanHandle.Init.BS1 = CAN_BS1_6TQ;
CanHandle.Init.BS2 = CAN_BS2_8TQ;
CanHandle.Init.Prescaler = 2;
if(HAL_CAN_Init(&CanHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure the CAN Filter ###########################################*/
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;
if(HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig) != HAL_OK)
{
/* Filter configuration Error */
Error_Handler();
}
/*##-3- Start the Transmission process #####################################*/
CanHandle.pTxMsg->StdId = 0x11;
CanHandle.pTxMsg->RTR = CAN_RTR_DATA;
CanHandle.pTxMsg->IDE = CAN_ID_STD;
CanHandle.pTxMsg->DLC = 2;
CanHandle.pTxMsg->Data[0] = 0xCA;
CanHandle.pTxMsg->Data[1] = 0xFE;
if(HAL_CAN_Transmit(&CanHandle, 10) != HAL_OK)
{
/* Transmition Error */
Error_Handler();
}
if(HAL_CAN_GetState(&CanHandle) != HAL_CAN_STATE_READY)
{
return HAL_ERROR;
}
/*##-4- Start the Reception process ########################################*/
if(HAL_CAN_Receive(&CanHandle, CAN_FIFO0,10) != HAL_OK)
{
/* Reception Error */
Error_Handler();
}
if(HAL_CAN_GetState(&CanHandle) != HAL_CAN_STATE_READY)
{
return HAL_ERROR;
}
if(CanHandle.pRxMsg->StdId != 0x11)
{
return HAL_ERROR;
}
if(CanHandle.pRxMsg->IDE != CAN_ID_STD)
{
return HAL_ERROR;
}
if(CanHandle.pRxMsg->DLC != 2)
{
return HAL_ERROR;
}
if((CanHandle.pRxMsg->Data[0]<<8|RxMessage.Data[1]) != 0xCAFE)
{
return HAL_ERROR;
}
return HAL_OK; /* Test Passed */
}
_Bool CAN_init(void *data) {
CAN_HandleTypeDef *handle = data;
HAL_StatusTypeDef result = HAL_ERROR;
const uint32_t baudRate = 125000;
CAN_InitTypeDef ifaceParams = {
HAL_RCC_GetPCLK1Freq()/(baudRate*(1+4+3)), //(CAN_SJW + CAN_BS1 + CAN_BS2)
CAN_MODE_NORMAL,
CAN_SJW_1TQ,
CAN_BS1_4TQ,
CAN_BS2_3TQ,
.TTCM = DISABLE,
.ABOM = DISABLE,
.AWUM = DISABLE,
.NART = DISABLE,
.RFLM = DISABLE,
.TXFP = DISABLE,
};
CAN_FilterConfTypeDef filter = {
0, 0, 0, 0,
CAN_FIFO0,
0,
CAN_FILTERMODE_IDMASK,
CAN_FILTERSCALE_32BIT,
ENABLE,
0
};
if (handle) {
free(handle->pRxMsg);
free(handle->pTxMsg);
handle->pRxMsg = NULL;
handle->pTxMsg = NULL;
memset(handle, 0, sizeof(*handle));
handle->Instance = CAN1;
handle->Init = ifaceParams;
result = HAL_CAN_Init(handle);
if (result == HAL_OK) {
HAL_CAN_ConfigFilter(handle, &filter);
HAL_NVIC_EnableIRQ(CAN1_TX_IRQn);
HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);
HAL_NVIC_EnableIRQ(CAN1_RX1_IRQn);
// HAL_NVIC_EnableIRQ(CAN1_SCE_IRQn);
handle->pRxMsg = malloc(sizeof(*handle->pRxMsg));
result &= HAL_CAN_Receive_IT(handle, CAN_FIFO0);
}
s_can1Handle = handle;
}
return result == HAL_OK;
}
_Bool CAN_write(const CanMsg_t *data) {
HAL_StatusTypeDef result = HAL_ERROR;
static const size_t msgSize = sizeof(CanTxMsgTypeDef);
if (!data)
return false;
CanTxMsgTypeDef txMsg = {
data->id,
data->id,
data->isExtended ? CAN_ID_EXT : CAN_ID_STD,
data->isRemoteFrame ? CAN_RTR_REMOTE : CAN_RTR_DATA,
data->isRemoteFrame ? 0 :
data->size > 8 ? 8 : data->size,
};
do {
if (!s_can1Handle)
break;
memcpy(txMsg.Data, data->buff, txMsg.DLC);
free(s_can1Handle->pTxMsg);
s_can1Handle->pTxMsg = malloc(msgSize);
if (!s_can1Handle->pTxMsg)
break;
memcpy(s_can1Handle->pTxMsg, &txMsg, msgSize);
result = HAL_CAN_Transmit_IT(s_can1Handle);
} while (0);
return result == HAL_OK;
}
