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 "Eep.h"
#include "Fls.h"
#include "SchM_Fls.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"
#include "Gpt.h"
#include "Wdg_43_Instance0.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"
#include "Hal_Fls.h"

#include "cm_backtrace.h"
#define APPNAME                        "S32K146_4G"
#define HARDWARE_VERSION               "V1.0.0"
#define SOFTWARE_VERSION               "V0.0.1"
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 */

    /* Partition only if it was not partitioned before for EERAM with code 0x4 */
//    Eep_DepartParitition(T_EEEPROM_SIZE);
    /* Initialize Eep driver */
#if defined (EEP_PRECOMPILE_SUPPORT)
    Eep_Init(NULL_PTR);
#else
    Eep_Init(&Eep_Config_VS_0);
#endif
    //Init Flash Driver
#if defined (FLS_PRECOMPILE_SUPPORT)
    Fls_Init(NULL_PTR);
#else
    Fls_Init(&Fls_Config_VS_0);
    while(MEMIF_IDLE == Fls_GetStatus())
    {
    	;
    }
#endif
	// 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;
	}
	ADC_ReadValue();
	Boot_CheckDownlaodAPPStatus();

	Spi_Init(NULL_PTR);
	    /* Initialize the Gpt driver */
	Gpt_Init(&Gpt_Config_VS_0);

	/* Enable the Gpt notification to periodically service the Wdg */
	Gpt_EnableNotification(GptConf_GptChannelConfiguration_GptChannelConfiguration_0);

	WdgInit();
	IP_LPUART0->CTRL |= LPUART_CTRL_ILT(1);
	IP_LPUART1->CTRL |= LPUART_CTRL_ILT(1);
	IP_LPUART2->CTRL |= LPUART_CTRL_ILT(1);
	IP_LPUART0->CTRL |= LPUART_CTRL_IDLECFG(5);
	IP_LPUART1->CTRL |= LPUART_CTRL_IDLECFG(3);
	IP_LPUART2->CTRL |= LPUART_CTRL_IDLECFG(3);

	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);
	Dio_WriteChannel(DioConf_DioChannel_PTE9_GPIO_OUT_MCU_LED5, STD_OFF);
	Mcu_ResetType bootreason;
	bootreason = Mcu_GetResetReason();
	cm_backtrace_init(APPNAME,HARDWARE_VERSION,SOFTWARE_VERSION);
#if SEGGER_PRINTF==1
	SEGGER_RTT_Init();
	SEGGER_RTT_printf("[%d] boot -%d\r\n",__LINE__,bootreason);
#endif
	UartInit();
	xTaskCreate(MainTask, (const char *const)"MainTask", 256, (void *)0, main_TASK_PRIORITY + 3, NULL);
	xTaskCreate(Uart0Task, (const char *const)"Uart0_Bms_Task", 1024, (void *)0, main_TASK_PRIORITY + 2, NULL);
	xTaskCreate(CanTask, (const char *const)"CanTask", 512, (void *)0, main_TASK_PRIORITY + 2, NULL);
	xTaskCreate(GpsTask, (const char *const)"GpsTask", 512, (void *)0, main_TASK_PRIORITY + 1, NULL);
	xTaskCreate(Uart_4G_Task, (const char *const)"Uart_4G_Task", 2048, (void *)0, main_TASK_PRIORITY + 0, NULL);
	vTaskStartScheduler();
	for (;;)
	{
		if (exit_code != 0)
		{
			break;
		}
	}
	return exit_code;
}
/** @} */