/* USER CODE BEGIN Header */
/* you can remove the copyright */
/*
* Copyright 2020-2023 Yuntu Microelectronics co.,ltd
* All rights reserved.
*
* YUNTU Confidential. This software is owned or controlled by YUNTU and may only be
* used strictly in accordance with the applicable license terms. By expressly
* accepting such terms or by downloading, installing, activating and/or otherwise
* using the software, you are agreeing that you have read, and that you agree to
* comply with and are bound by, such license terms. If you do not agree to be
* bound by the applicable license terms, then you may not retain, install,
* activate or otherwise use the software. The production use license in
* Section 2.3 is expressly granted for this software.
*
* @file main.c
* @brief
*
*/
/* USER CODE END Header */
#include "Mcal.h"
/* Includes ------------------------------------------------------------------*/
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define CAN_ID_TYPE_FD_FRAME_MASK (0x40000000U)
#define CAN_ID_TYPE_EXTENDED_FRAME_MASK (0x80000000U)
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#ifdef CAN_INTERMITTENT_TXRX
#undef CAN_INTERMITTENT_TXRX
#endif
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
uint8 sduDataA1[8] = {0xF7, 0xE6, 0x05, 0xC4, 0xB3, 0xA2, 0x91, 0x80};
uint8 sduDataA2[8] = {0x78, 0x69, 0x5A, 0x4B, 0x0C, 0x2D, 0x1E, 0x0F};
uint8 sduDataA3[8] = {0xF7, 0xE6, 0xD5, 0xC4, 0xB3, 0xA2, 0x91, 0x80};
uint8 sduDataA4[8] = {0x15, 0xD2, 0xA1, 0xF3, 0x47, 0x13, 0xBC, 0x29};
uint8 sduDataA7[8] = {0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, 0x87};
uint8 sduDataA8[8] = {0x78, 0x88, 0x98, 0xa8, 0xb8, 0xc8, 0xd8, 0xe8};
uint8 sduDataA9[8] = {0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98};
uint8 sduDataA10[8]= {0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88};
uint8 sduData64[64] =
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc,
0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc,
0xAA, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55,
0xAA, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
uint8 sduData16[16] =
{ 0xfa, 0x33, 0x31, 0x05, 0x77, 0xf8, 0x12, 0x89,
0x33, 0x2c, 0xad, 0x69, 0x02, 0xdb, 0x35, 0x12};
uint8 sduData24[64] =
{
0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
0x2a, 0xde, 0x8f, 0xdc, 0x16, 0x80, 0x43, 0xc5,
0x36, 0xc2, 0xbb, 0x9a, 0x78, 0x56, 0x34, 0x12};
Can_PduType pduInfo0 = {
.swPduHandle = 1,
.id = 0x18FF0101U | CAN_ID_TYPE_EXTENDED_FRAME_MASK,
.length = 8U,
.sdu = sduDataA1,
};
Can_PduType pduInfo1 = {
.swPduHandle = 10,
.id = 0x675U,
.length = 8U,
.sdu = sduDataA1,
};
Can_PduType pduInfo2 = {
.swPduHandle = 11,
.id = 0x502U,
.length = 8U,
.sdu = sduDataA2,
};
Can_PduType pduInfo3 = {
.swPduHandle = 12,
.id = 0x503U,
.length = 8U,
.sdu = sduDataA3,
};
Can_PduType pduInfo4 = {
.swPduHandle = 20,
.id = 0x168U,
.length = 8U,
.sdu = sduDataA4,
};
Can_PduType pduInfo5 = {
.swPduHandle = 25,
#if(CAN_FD_USAGE == STD_ON)
.id = 0x3E4U | CAN_ID_TYPE_FD_FRAME_MASK,
.length = 64U,
#else
.id = 0x3E4U,
.length = 8U,
#endif
.sdu = sduData64,
};
Can_PduType pduInfo6 = {
.swPduHandle = 26,
#if(CAN_FD_USAGE == STD_ON)
.id = 0x1AA66007U | CAN_ID_TYPE_EXTENDED_FRAME_MASK | CAN_ID_TYPE_FD_FRAME_MASK,
.length = 21U,
#else
.id = 0x1AA66007U | CAN_ID_TYPE_EXTENDED_FRAME_MASK,
.length = 8U,
#endif
.sdu = sduData24,
};
Can_PduType pduInfo7 = {
.swPduHandle = 47,
.id = 0x0D000000U | CAN_ID_TYPE_EXTENDED_FRAME_MASK,
.length = 8U,
.sdu = sduDataA1,
};
Can_PduType pduInfo8 = {
.swPduHandle = 48,
.id = 0x105U,
.length = 8U,
.sdu = sduData24,
};
Can_PduType pduInfo9 = {
.swPduHandle = 49,
.id = 0x1A8U ,
.length = 8U,
.sdu = sduDataA9,
};
Can_PduType pduInfo10 = {
.swPduHandle = 93,
#if(CAN_FD_USAGE == STD_ON)
.id = 0x7F0U | CAN_ID_TYPE_FD_FRAME_MASK,
#else
.id = 0x7E0U,
#endif
.length = 8U,
.sdu = sduDataA10,
};
Can_PduType Feedback_pduInfo0 = {
.swPduHandle = 7U,
.id = 0x268U,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo1 = {
.swPduHandle = 2U,
.id = 0x775U,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo2 = {
.swPduHandle = 4U,
#if(CAN_FD_USAGE == STD_ON)
.id = 0x4E4U | CAN_ID_TYPE_FD_FRAME_MASK,
.length = 16U,
#else
.id = 0x4E4U,
.length = 8U,
#endif
.sdu = sduData16,
};
Can_PduType Feedback_pduInfo3 = {
.swPduHandle = 9U,
.id = 0x603U,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo4 = {
.swPduHandle = 77U,
#if(CAN_FD_USAGE == STD_ON)
.id = 0x1CC88007U | CAN_ID_TYPE_EXTENDED_FRAME_MASK | CAN_ID_TYPE_FD_FRAME_MASK,
.length = 24U,
#else
.id = 0x1CC88007U | CAN_ID_TYPE_EXTENDED_FRAME_MASK,
.length = 8U,
#endif
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo7 = {
.swPduHandle = 57U,
.id = 0x10856699U | CAN_ID_TYPE_EXTENDED_FRAME_MASK,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo8 = {
.swPduHandle = 58U,
.id = 0x205U,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo9 = {
.swPduHandle = 59U,
.id = 0x305U,
.length = 8U,
.sdu = NULL_PTR,
};
Can_PduType Feedback_pduInfo10 = {
.swPduHandle = 60U,
.id = 0x2A8U,
.length = 8U,
.sdu = NULL_PTR,
};
Std_ReturnType TestResult[32];
uint8 tmp_i = 0;
volatile uint32 time1 = 0;
volatile uint32 time2 = 0;
uint8 Key3ScanTime = 0;
boolean Key3Status = 0;
uint8 Key2ScanTime = 0;
boolean Key2Status = 0;
uint32 tempSent, tempReceived, handleNum, handleAcc;
uint8 tempTestSignal = 0;
boolean signCan0Busoff = FALSE;
boolean signCan1Busoff = FALSE;
uint8 loopCycle;
/* USER CODE END PV */
/* Private function declare --------------------------------------------------*/
/* USER CODE BEGIN PFDC */
MCU_CONFIG_PB
extern const Port_ConfigType Port_Config;
void CanTransmitCallOut(PduIdType TxPduId)
{
handleAcc = TxPduId;
tempSent ++;
}
boolean CanReceiveCallOut(uint8 Hrh, Can_IdType CanId, uint8 CanDataLegth, const uint8* CanSduPtr)
{
uint8 tempi, Data[8];
#if(CAN_FD_USAGE == STD_ON)
uint8 Data64[64];
#endif
if(4 == Hrh)
{
if(0x168U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo0.id = 0x268U;
Feedback_pduInfo0.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjDoor, &Feedback_pduInfo0); /* Can0 standard Can frame*/
}
if(0x16AU == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo0.id = 0x26AU;
Feedback_pduInfo0.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjDoor, &Feedback_pduInfo0); /* Can0 standard Can frame*/
}
if(0x16CU == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo0.id = 0x26CU;
Feedback_pduInfo0.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjDoor, &Feedback_pduInfo0); /* Can0 standard Can frame*/
}
if(0x16DU == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo0.id = 0x26DU;
Feedback_pduInfo0.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjDoor, &Feedback_pduInfo0); /* Can0 standard Can frame*/
}
}
if(3 == Hrh)
{
if(0x675U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo1.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjTemperature, &Feedback_pduInfo1); /* Can3 standard Can frame*/
}
}
if(6 == Hrh)
{
if(0x3E4U == (CanId & 0x1fffffffU))
{
#if(CAN_FD_USAGE == STD_ON)
for(tempi = 0; tempi < 64; tempi ++)
{
Data64[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo2.sdu = Data64;
Data64[0] -= 0x88U;
#else
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo2.sdu = Data;
Data[0] -= 0x88U;
#endif
Can_Write(CanConf_CanHardwareObject_ObjEpbi, &Feedback_pduInfo2); /* Can2 standard CanFd frame*/
}
}
if(5 == Hrh)
{
if(0x503U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo3.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans2, &Feedback_pduInfo3); /* Can1 standard Can frame*/
}
if(0x1AA66007U == (CanId & 0x1fffffffU))
{
#if(CAN_FD_USAGE == STD_ON)
for(tempi = 0; tempi < 24; tempi ++)
{
Data64[tempi] = CanSduPtr[tempi] - 0x18U;
}
Feedback_pduInfo4.sdu = Data64;
#else
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi] - 0x18U;
}
Feedback_pduInfo4.sdu = Data;
#endif
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans1, &Feedback_pduInfo4);
}
}
if(7 == Hrh)
{
if(0x0D000000U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi];
}
Feedback_pduInfo7.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjTemperature, &Feedback_pduInfo7); /* Can1 standard Can frame*/
}
}
if(2 == Hrh)
{
if(0x105U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi] + 0x10U;
}
Feedback_pduInfo8.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjEpbi, &Feedback_pduInfo8); /* Can1 standard Can frame*/
}
}
if(1 == Hrh)
{
if(0x205U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi] + 0x20U;
}
Feedback_pduInfo9.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans2, &Feedback_pduInfo9); /* Can1 standard Can frame*/
}
}
if(0 == Hrh)
{
if(0x1A8U == (CanId & 0x1fffffffU))
{
for(tempi = 0; tempi < 8; tempi ++)
{
Data[tempi] = CanSduPtr[tempi] + 0x08U;
}
Feedback_pduInfo10.sdu = Data;
Can_Write(CanConf_CanHardwareObject_ObjWindow, &Feedback_pduInfo10); /* Can1 standard Can frame*/
}
}
return TRUE;
}
void CanBusoff0(void)
{
signCan0Busoff = TRUE; /*if Can0 busoff */
}
void CanBusoff1(void)
{
signCan1Busoff = TRUE; /*if Can1 busoff */
}
/* USER CODE END PFDC */
static void Board_Init(void);
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
Mcu_Init(&Mcu_Config);
Mcu_InitClock(0);
#if (MCU_NO_PLL == STD_OFF)
while ( MCU_PLL_LOCKED != Mcu_GetPllStatus() )
{
/* Busy wait until the System PLL is locked */
}
Mcu_DistributePllClock();
#endif
/* USER CODE END 1 */
Board_Init();
/* USER CODE BEGIN 2 */
#if (CAN_FIXED_PB_CONFIG == STD_OFF)
Can_Init(&Can_Config);
#else
Can_Init(NULL_PTR);
#endif
Platform_Init(NULL_PTR);
Can_SetControllerMode(CanConf_CanController_BCAN, CAN_CS_STARTED); /*set Can0 to started*/
Can_SetControllerMode(CanConf_CanController_DCAN, CAN_CS_STARTED); /*set Can1 to started*/
Can_SetControllerMode(CanConf_CanController_PCAN, CAN_CS_STARTED); /*set Can2 to started*/
Can_SetControllerMode(CanConf_CanController_infoCAN, CAN_CS_STARTED); /*set Can3 to started*/
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
time1++;
{
if(time1 % 50000U == 0U)
{
sduDataA1[3] += 0x10;
sduDataA2[6] += 2;
sduDataA3[1] += 0x27;
sduDataA4[5] += 0x4E;
sduData16[12] += 5;
sduData24[2] += 0x1A;
sduData64[1] ++;
sduDataA9[7] += 0x10;
sduDataA8[6] += 0x42;
sduDataA7[5] -= 0x36;
}
}
if(time1 > 200000U)
{
time1 = 0;
#ifdef CAN_INTERMITTENT_TXRX
if(loopCycle == 200)
{
#if (CAN_FIXED_PB_CONFIG == STD_OFF)
Can_Init(&Can_Config);
#else
Can_Init(NULL_PTR);
#endif
Can_SetControllerMode(CanConf_CanController_BCAN, CAN_CS_STARTED); /*set Can0 to started*/
Can_SetControllerMode(CanConf_CanController_DCAN, CAN_CS_STARTED); /*set Can1 to started*/
Can_SetControllerMode(CanConf_CanController_PCAN, CAN_CS_STARTED); /*set Can2 to started*/
Can_SetControllerMode(CanConf_CanController_infoCAN, CAN_CS_STARTED); /*set Can3 to started*/
}
if(loopCycle == 100)
{
Can_SetControllerMode(CanConf_CanController_BCAN, CAN_CS_STOPPED); /*set Can0 to started*/
Can_SetControllerMode(CanConf_CanController_DCAN, CAN_CS_STOPPED); /*set Can1 to started*/
Can_SetControllerMode(CanConf_CanController_PCAN, CAN_CS_STOPPED); /*set Can2 to started*/
Can_SetControllerMode(CanConf_CanController_infoCAN, CAN_CS_STOPPED); /*set Can3 to started*/
Can_DeInit();
}
#endif
if(loopCycle >= 200)
{
loopCycle = 0;
}
Can_Write(CanConf_CanHardwareObject_ObjEpbi, &pduInfo10); /* CAN2R1 0x7F0 */
Can_Write(CanConf_CanHardwareObject_ObjEpbi, &pduInfo6); /* CAN2R1 0x1AA66007U resp CAN1R0 0x1CC88007U */
Can_Write(CanConf_CanHardwareObject_ObjWindow, &pduInfo1); /* CAN0R0 0x675U resp CAN3R0 0x775U */
Can_Write(CanConf_CanHardwareObject_ObjWindow, &pduInfo7); /* CAN0R0 0x0D000000U resp CAN3R0 0x10856699U */
Can_Write(CanConf_CanHardwareObject_ObjDoor, &pduInfo0); /* CAN0R0 0x18FF0101U */
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans1, &pduInfo5); /* CAN1R0 0x3E4U resp CAN2R1 0x4E4U */
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans2, &pduInfo2); /* CAN1R1 0x502U */
Can_Write(CanConf_CanHardwareObject_ObjTransmission, &pduInfo3);/* CAN2R0 0x503U resp CAN1R1 0x603U */
Can_Write(CanConf_CanHardwareObject_ObjInfoTrans1, &pduInfo8); /* CAN1R0 0x105U resp CAN2R1 0x205U and CAN1R1 0x305U */
Can_Write(CanConf_CanHardwareObject_ObjTemperature, &pduInfo9); /* CAN3R0 0x1A8U resp CAN0R0 0x2A8 */
pduInfo4.id = 0x168U;
pduInfo4.sdu = sduDataA2;
Can_Write(CanConf_CanHardwareObject_ObjPm2d5, &pduInfo4); /* CAN3R0 0x168U resp CAN0R0 0x268 */
pduInfo4.id = 0x16AU;
pduInfo4.sdu = sduDataA3;
Can_Write(CanConf_CanHardwareObject_ObjPm2d5, &pduInfo4); /* CAN3R0 0x16AU resp CAN0R0 0x26A */
pduInfo4.id = 0x16CU;
pduInfo4.sdu = sduDataA4;
Can_Write(CanConf_CanHardwareObject_ObjPm2d5, &pduInfo4); /* CAN3R0 0x16CU resp CAN0R0 0x26C */
pduInfo4.id = 0x16DU;
pduInfo4.sdu = sduDataA1;
Can_Write(CanConf_CanHardwareObject_ObjPm2d5, &pduInfo4); /* CAN3R0 0x16DU */
loopCycle ++;
}
if((time1 % 2000U) == 0U)
{
time1 ++;
#if (CAN_TX_PROCESS_HAS_POLLING == STD_ON)
#if (CAN_MAIN_FUNCTION_RW_PERIOD_OPTION_NUM == 1U)
Can_MainFunction_Write();
#elif (CAN_MAIN_FUNCTION_RW_PERIOD_OPTION_NUM > 1U)
Can_MainFunction_Write_Write2ms();
Can_MainFunction_Write_Write10ms();
Can_MainFunction_Write_Read2ms();
Can_MainFunction_Write_Read10ms();
#endif
#endif
#if (CAN_RX_PROCESS_HAS_POLLING == STD_ON)
#if (CAN_MAIN_FUNCTION_RW_PERIOD_OPTION_NUM == 1U)
Can_MainFunction_Read();
#elif (CAN_MAIN_FUNCTION_RW_PERIOD_OPTION_NUM > 1U)
Can_MainFunction_Read_Write2ms();
Can_MainFunction_Read_Write10ms();
Can_MainFunction_Read_Read2ms();
Can_MainFunction_Read_Read10ms();
#endif
#endif
Can_MainFunction_Mode();
#if (CAN_BUSOFF_PROCESS_HAS_POLLING == STD_ON)
Can_MainFunction_BusOff();
#endif
if(signCan0Busoff == TRUE)
{
signCan0Busoff = FALSE;
Can_SetControllerMode(CanConf_CanController_BCAN, CAN_CS_STARTED);
}
if(signCan1Busoff == TRUE)
{
signCan1Busoff = FALSE;
Can_SetControllerMode(CanConf_CanController_DCAN, CAN_CS_STARTED);
}
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
static void Board_Init(void)
{
Port_Init(&Port_Config);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */