4G/src/main.c

/*==================================================================================================
*   Project              : RTD AUTOSAR 4.4
*   Platform             : CORTEXM
*   Peripheral           : S32K3XX
*   Dependencies         : none
*
*   Autosar Version      : 4.4.0
*   Autosar Revision     : ASR_REL_4_4_REV_0000
*   Autosar Conf.Variant :
*   SW Version           : 1.0.0
*   Build Version        : S32K3_RTD_1_0_0_D2110_ASR_REL_4_4_REV_0000_20211007
*
*   (c) Copyright 2020 - 2021 NXP Semiconductors
*   All Rights Reserved.
*
*   NXP Confidential. This software is owned or controlled by NXP 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.
==================================================================================================*/

/**
 *   @file main.c
 * Ö÷º¯ÊýÈë¿Ú
 *   @addtogroup main_module main module documentation
 *   @{
 */

/* Including necessary configuration files. */
#include "Mcal.h"
#include "CAN.h"
#include "SchM_Can.h"
#include "Mcu.h"
#include "Mcl.h"
#include "Port.h"
#include "Dio.h"
#include "Uart.h"
#include "Platform.h"
#include "Lpuart_Uart_Ip_Irq.h"
#include "Flexio_Uart_Ip_Irq.h"
#include "Dma_Ip.h"
#include "Dma_Ip_Irq.h"
#include "Lpuart_Uart_Ip.h"
/* User includes */

#include <string.h>
#include "hal_adapter.h"
#include "Lpuart_Uart_Ip.h"

#include "AppTaskMain.h"
#include "AppTaskUart0.h"
#include "AppTaskUart1.h"
#include "AppTaskCan.h"
#include "AppTaskGps.h"
int main(void)
{
	volatile int exit_code = 0;
	/* Initialize the Mcu driver */
#if (MCU_PRECOMPILE_SUPPORT == STD_ON)
	Mcu_Init(NULL_PTR);
#elif (MCU_PRECOMPILE_SUPPORT == STD_OFF)
	Mcu_Init(&Mcu_Config_VS_0);
#endif /* (MCU_PRECOMPILE_SUPPORT == STD_ON) */

	Mcu_InitClock(McuClockSettingConfig_0);

	/* Wait until PLL is locked */
	while (MCU_PLL_LOCKED != Mcu_GetPllStatus())
	{
		/* Busy wait until the System PLL is locked */
	}
	Mcu_DistributePllClock();
	/* Initialize Mcl module */
	Mcl_Init(NULL_PTR);

	Mcu_SetMode(McuModeSettingConf_Run);
	OsIf_Init(NULL_PTR);
	Platform_Init(NULL_PTR);

	/* Initialize all pins*/
#if (PORT_PRECOMPILE_SUPPORT == STD_ON)
	Port_Init(NULL_PTR);
#elif (PORT_PRECOMPILE_SUPPORT == STD_OFF)
	Port_Init(&Port_Config_VS_0);
#endif

	/* Initializes an UART driver*/
#if (UART_PRECOMPILE_SUPPORT == STD_ON)
	Uart_Init(NULL_PTR);
#elif (UART_PRECOMPILE_SUPPORT == STD_OFF)
	Uart_Init(&Uart_xConfig_VS_0);
#endif

#if 1 /* Initialize Platform driver */
#if (CAN_PRECOMPILE_SUPPORT == STD_ON)
	Can_Init(NULL_PTR);
#elif (CAN_PRECOMPILE_SUPPORT == STD_OFF)
	Can_Init(&Can_Config_VS_0);
#endif
	Can_SetControllerMode(CanController_0, CAN_CS_STARTED);
	Can_SetControllerMode(CanController_1, CAN_CS_STARTED);
#endif
#if (ADC_PRECOMPILE_SUPPORT == STD_ON)
	Adc_Init(NULL_PTR);
#else
	Adc_Init(&Adc_Config_VS_0);
#endif /* ADC_PRECOMPILE_SUPPORT == STD_ON */

	// this function should be called in ADC Task at once
	Adc_CalibrationStatusType CalibStatus;
	Adc_Calibrate(AdcHwUnit_0, &CalibStatus);
	if (CalibStatus.Adc_UnitSelfTestStatus == E_NOT_OK)
	{
		// if so, the adc is failed to Calibrate;
	}
	TP_Value_Type value = 0;
	for (ADC_TP_Channel_Type channel = 0; channel < ChannelCounter; channel++)
	{
		ADC_ReadValue(channel, &value);
	}

	IP_LPUART0->CTRL |= LPUART_CTRL_ILT(1);
	IP_LPUART1->CTRL |= LPUART_CTRL_ILT(1);
	IP_LPUART2->CTRL |= LPUART_CTRL_ILT(1);

	Dio_WriteChannel(DioConf_DioChannel_PTE0_GPIO_OUT_MCU_LED1, STD_OFF);
	Dio_WriteChannel(DioConf_DioChannel_PTE1_GPIO_OUT_MCU_LED2, STD_OFF);
	Dio_WriteChannel(DioConf_DioChannel_PTE7_GPIO_OUT_MCU_LED3, STD_OFF);
	Dio_WriteChannel(DioConf_DioChannel_PTE8_GPIO_OUT_MCU_LED4, STD_OFF);

	xTaskCreate(MainTask, (const char *const)"MainTask", 128, (void *)0, main_TASK_PRIORITY + 3, NULL);
	xTaskCreate(Uart_4G_Task, (const char *const)"Uart_4G_Task", 2048, (void *)0, main_TASK_PRIORITY + 0, NULL);
#ifdef APP_UART0_ENABLE
	xTaskCreate(Uart0Task, (const char *const)"Uart0_Bms_Task", 256, (void *)0, main_TASK_PRIORITY + 1, NULL);
#endif
#ifdef APP_CAN_ENABLE
	xTaskCreate(CanTask, (const char *const)"CanTask", 512, (void *)0, main_TASK_PRIORITY + 2, NULL);
#endif
	xTaskCreate(GpsTask, (const char *const)"GpsTask", 512, (void *)0, main_TASK_PRIORITY + 1, NULL);
	vTaskStartScheduler();
	for (;;)
	{
		if (exit_code != 0)
		{
			break;
		}
	}
	return exit_code;
}

/** @} */