提交代码

System/Sys_Scheduler.c

+
+#include "Sys_Scheduler.h"
+#include "RTE.h"
+
+void Sys_Scheduler_Init(void)
+{
+    RTE_Tick_Timer_Stop();
+    Sys_Scheduler_Start(SYS_TICK_INTERVAL);
+    RTE_Tick_Timer_Start(SYS_TICK_INTERVAL, Sys_Scheduler_ISR);
+}

System/Sys_Scheduler.h

+#include "Sys_Scheduler_Lib.h"
+
+#define   SYS_TICK_INTERVAL                 (1000UL)    /* us */
+
+
+extern void Sys_Scheduler_Init(void);
+
+
+

System/Sys_Scheduler_Lib.c

+#include <stddef.h>
+#include "Sys_Scheduler_Lib.h"
+#include "tim.h"
+
+typedef struct
+{
+    uint32_t u32msRocBak;
+    uint32_t u32Task2msCnt;
+    uint32_t u32Task5msCnt;
+    uint32_t u32Task10msCnt;
+    uint32_t u32Task20msCnt;
+    uint32_t u32Task50msCnt;
+    uint32_t u32Task100msCnt;
+} Sys_Scheduler_st_t;
+
+typedef struct 
+{
+    uint32_t u32Pending;
+    uint32_t u32usCounter;
+    Sys_Timer_st_t *pstList;
+}Sys_Timer_Ctrl_st_t;
+
+#define   SYS_TIMER_MODE_IDLE               (0UL)
+#define   SYS_TIMER_MODE_RUN                (1UL)
+#define   SYS_TIMER_MODE_LOOP               (2UL)
+
+uint32_t            g_u32SysIntInterval      = 0UL;
+uint32_t            g_u32SysusCounter        = 0UL;
+volatile uint32_t   g_u32SysmsRollingCounter = 0UL;
+
+Sys_Scheduler_st_t  g_stSysScheduler;
+Sys_Timer_Ctrl_st_t g_stSysTimerCtrl;
+
+uint32_t Sys_Get_ms_Rolling_Counter(void)
+{
+    uint32_t u32Counter[2];
+
+    do
+    {
+        u32Counter[0] = g_u32SysmsRollingCounter;
+        u32Counter[1] = g_u32SysmsRollingCounter;
+    }while (u32Counter[0] != u32Counter[1]);
+    
+    return u32Counter[0];
+}
+
+int32_t Sys_Get_Running_Time(Sys_Time_st_t *pstTime)
+{
+    int32_t  i32Result;
+    uint32_t u32msCounter;
+
+    i32Result = -1;
+    if (pstTime != NULL)
+    {
+        u32msCounter = Sys_Get_ms_Rolling_Counter();
+
+        pstTime->u32Hour  = u32msCounter / 3600000UL;
+        u32msCounter      = u32msCounter % 3600000UL;
+
+        pstTime->u32Min   = u32msCounter / 60000UL;
+        u32msCounter      = u32msCounter % 60000UL;
+
+        pstTime->u32Sec   = u32msCounter / 1000UL;
+        u32msCounter      = u32msCounter % 1000UL;
+
+        pstTime->u32mSec  = u32msCounter;
+        
+        i32Result = 0;
+    }
+
+    return i32Result;
+}
+
+int32_t Sys_Timer_Start(Sys_Timer_st_t *pHandle, uint32_t u32Interval, uint32_t u32Loop, Sys_Timer_Cb_pfn_t pfnCallBack)
+{
+    int32_t  i32Result;
+    uint32_t u32Exist;
+    Sys_Timer_st_t *pstSearch;
+
+    i32Result = -1;
+    if (pHandle != NULL)
+    {
+        pHandle->u32Run = SYS_TIMER_MODE_IDLE;
+
+        pHandle->u32Cnt      = 0UL;
+        pHandle->u32Dst      = u32Interval;
+        pHandle->pfnCallBack = pfnCallBack;
+
+        if (g_stSysTimerCtrl.pstList == NULL)
+        {
+            g_stSysTimerCtrl.u32Pending = 1UL;
+            
+            pHandle->pstNext = NULL;
+            g_stSysTimerCtrl.pstList = pHandle;
+
+            g_stSysTimerCtrl.u32Pending = 0UL;
+        }
+        else if (g_stSysTimerCtrl.pstList == pHandle)
+        {
+            /* Nothing to do */
+        }
+        else
+        {
+            u32Exist  = 0UL;
+            pstSearch = g_stSysTimerCtrl.pstList;
+            while((pstSearch->pstNext != NULL) && (u32Exist == 0UL))
+            {
+                pstSearch = pstSearch->pstNext;
+                if (pstSearch == pHandle)
+                {
+                    u32Exist = 1UL;
+                }
+            }
+
+            if (u32Exist == 0UL)
+            {
+                g_stSysTimerCtrl.u32Pending = 1UL;
+                
+                pHandle->pstNext = NULL;
+                pstSearch->pstNext = pHandle;
+                
+                g_stSysTimerCtrl.u32Pending = 0UL;
+            }
+        }
+
+        if (u32Loop)
+        {
+            pHandle->u32Run = SYS_TIMER_MODE_LOOP;
+        }
+        else
+        {
+            pHandle->u32Run = SYS_TIMER_MODE_RUN;
+        }
+
+        i32Result = 0;
+    }
+
+    return i32Result;
+}
+
+int32_t Sys_Timer_Stop(Sys_Timer_st_t *pHandle)
+{
+    int32_t  i32Result;
+    Sys_Timer_st_t *pstSearch;
+
+    i32Result = -1;
+    if (pHandle != NULL)
+    {
+        if (g_stSysTimerCtrl.pstList == NULL)
+        {
+            /* Nothing to do */
+        }
+        else if (g_stSysTimerCtrl.pstList == pHandle)
+        {
+            g_stSysTimerCtrl.u32Pending = 1UL;
+
+            pHandle->u32Run = SYS_TIMER_MODE_IDLE;
+            g_stSysTimerCtrl.pstList = pHandle->pstNext;
+            
+            g_stSysTimerCtrl.u32Pending = 0UL;
+
+            i32Result = 0;
+        }
+        else
+        {
+            pstSearch = g_stSysTimerCtrl.pstList;
+            while ((pstSearch->pstNext != NULL) && (pstSearch->pstNext != pHandle))
+            {
+                pstSearch = pstSearch->pstNext;
+            }
+
+            if (pstSearch->pstNext == pHandle)
+            {
+                g_stSysTimerCtrl.u32Pending = 1UL;
+
+                pHandle->u32Run = SYS_TIMER_MODE_IDLE;
+                pstSearch->pstNext = pHandle->pstNext;
+                
+                g_stSysTimerCtrl.u32Pending = 0UL;
+
+                i32Result = 0;
+            }
+        }
+    }
+
+    return i32Result;
+}
+
+int32_t Sys_Timer_Get_Status(Sys_Timer_st_t *pHandle)
+{
+    int32_t  i32Result;
+    
+    i32Result = -1;
+    if (pHandle != NULL)
+    {
+        if (pHandle->u32Run)
+        {
+            i32Result = 1;
+        }
+        else
+        {
+            i32Result = 0;
+        }
+    }
+
+    return i32Result;
+}
+
+int32_t Sys_Timer_Get_Counter(Sys_Timer_st_t *pHandle, uint32_t *pu32Counter)
+{
+    int32_t  i32Result;
+    volatile uint32_t *pu32Cnt;
+    uint32_t u32Counter[2];
+    
+    i32Result = -1;
+    if ((pHandle != NULL) && (pu32Counter != NULL))
+    {
+        pu32Cnt = (volatile uint32_t *)(&pHandle->u32Cnt);
+
+        do
+        {
+            u32Counter[0] = *pu32Cnt;
+            u32Counter[1] = *pu32Cnt;
+        } while (u32Counter[0] != u32Counter[1]);
+
+        *pu32Counter = u32Counter[0];
+        i32Result = 0;
+    }
+    
+    return i32Result;
+}
+
+void Sys_Scheduler_Start(uint32_t u32SchCycle)
+{
+    g_u32SysIntInterval = u32SchCycle;
+    g_u32SysusCounter   = 0UL;
+    g_u32SysmsRollingCounter = 0UL;
+
+    g_stSysTimerCtrl.u32Pending      = 0UL;
+    g_stSysTimerCtrl.u32usCounter    = 0UL;
+    g_stSysTimerCtrl.pstList         = NULL;
+
+    g_stSysScheduler.u32msRocBak     = Sys_Get_ms_Rolling_Counter();
+    g_stSysScheduler.u32Task2msCnt   = 0UL;
+    g_stSysScheduler.u32Task10msCnt  = 1UL;
+    g_stSysScheduler.u32Task20msCnt  = 3UL;
+    g_stSysScheduler.u32Task50msCnt  = 5UL;
+    g_stSysScheduler.u32Task100msCnt = 7UL;
+}
+
+void Sys_Scheduling_Service(void)
+{
+    uint32_t u32msROC;
+    uint32_t u32msDelta;
+    
+    Sys_Pseudo_Real_Time_Tasks();
+
+    u32msROC = Sys_Get_ms_Rolling_Counter();
+    if (u32msROC >= g_stSysScheduler.u32msRocBak)
+    {
+        u32msDelta = u32msROC - g_stSysScheduler.u32msRocBak;
+    }
+    else
+    {
+        u32msDelta = 0xFFFFFFFFUL - g_stSysScheduler.u32msRocBak + u32msROC + 0x00000001UL;
+    }
+    g_stSysScheduler.u32msRocBak = u32msROC;
+
+    g_stSysScheduler.u32Task2msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task2msCnt >= 2UL)
+    {
+        g_stSysScheduler.u32Task2msCnt %= 2UL;
+        Sys_2ms_Tasks();
+    }
+
+    g_stSysScheduler.u32Task5msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task5msCnt >= 5UL)
+    {
+        g_stSysScheduler.u32Task5msCnt %= 5UL;
+        Sys_5ms_Tasks();
+    }
+
+    g_stSysScheduler.u32Task10msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task10msCnt >= 10UL)
+    {
+        g_stSysScheduler.u32Task10msCnt %= 10UL;
+        Sys_10ms_Tasks();
+    }
+
+    g_stSysScheduler.u32Task20msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task20msCnt >= 20UL)
+    {
+        g_stSysScheduler.u32Task20msCnt %= 20UL;
+        Sys_20ms_Tasks();
+    }
+
+    g_stSysScheduler.u32Task50msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task50msCnt >= 50UL)
+    {
+        g_stSysScheduler.u32Task50msCnt %= 50UL;
+        Sys_50ms_Tasks();
+    }
+
+    g_stSysScheduler.u32Task100msCnt += u32msDelta;
+    if (g_stSysScheduler.u32Task100msCnt >= 100UL)
+    {
+        g_stSysScheduler.u32Task100msCnt %= 100UL;
+        Sys_100ms_Tasks();
+    }
+}
+
+void Sys_Scheduler_ISR(void)
+{
+    uint32_t u32msInc;
+    Sys_Timer_st_t *pstTimer;
+    Sys_Timer_st_t *pstPrev;
+
+    g_u32SysusCounter += g_u32SysIntInterval;
+    if (g_u32SysusCounter >= 1000UL)
+    {
+        u32msInc = g_u32SysusCounter / 1000UL;
+        g_u32SysusCounter = g_u32SysusCounter % 1000UL;
+        g_u32SysmsRollingCounter += u32msInc;
+    }
+
+    g_stSysTimerCtrl.u32usCounter += g_u32SysIntInterval;
+    if (g_stSysTimerCtrl.u32Pending == 0UL)
+    {
+        pstPrev  = NULL;
+        pstTimer = g_stSysTimerCtrl.pstList;
+        while (pstTimer != NULL)
+        {
+            if (pstTimer->u32Run)
+            {
+                /* if (pstTimer->u32Cnt + u32Interval < 0xFFFFFFFFUL) */
+                if (pstTimer->u32Cnt < 0xFFFFFFFFUL - g_stSysTimerCtrl.u32usCounter)
+                {
+                    pstTimer->u32Cnt += g_stSysTimerCtrl.u32usCounter;
+                }
+                else
+                {
+                    pstTimer->u32Cnt = 0xFFFFFFFFUL;
+                }
+                
+                if (pstTimer->u32Cnt >= pstTimer->u32Dst)
+                {
+                    if (pstTimer->u32Run == SYS_TIMER_MODE_RUN)
+                    {
+                        pstTimer->u32Run = SYS_TIMER_MODE_IDLE;
+
+                        if (pstPrev == NULL)
+                        {
+                            g_stSysTimerCtrl.pstList = pstTimer->pstNext;
+                        }
+                        else
+                        {
+                            pstPrev->pstNext = pstTimer->pstNext;
+                        }
+                    }
+                    else
+                    {
+                        pstTimer->u32Cnt = 0UL;
+                    }
+
+                    if (pstTimer->pfnCallBack != NULL)
+                    {
+                        pstTimer->pfnCallBack();
+                    }
+                }
+            }
+
+            pstPrev  = pstTimer;        
+            pstTimer = pstTimer->pstNext;
+        }
+        
+        g_stSysTimerCtrl.u32usCounter = 0UL;
+    }
+}

System/Sys_Scheduler_Lib.h

+#include "stdint.h"
+
+typedef struct stSysTime
+{
+    uint32_t u32Hour;
+    uint32_t u32Min;
+    uint32_t u32Sec;
+    uint32_t u32mSec;
+}Sys_Time_st_t;
+
+typedef void (*Sys_Timer_Cb_pfn_t)(void);
+
+/**@struct Sys_Timer_st_t
+ * @brief  Sys Timer 控制块
+ */
+typedef struct stSysTimer
+{
+    uint32_t u32Run;  /**< Sys Timer运行标志   */
+    uint32_t u32Cnt;  /**< Sys Timer计数器     */
+    uint32_t u32Dst;  /**< Sys Timer计数目标值 */
+    
+    Sys_Timer_Cb_pfn_t  pfnCallBack;  /**< Sys Timer计时结束回调函数 */
+    struct stSysTimer  *pstNext;      /**< 下一个Sys Timer控制块 */
+}Sys_Timer_st_t;
+
+extern uint32_t Sys_Get_ms_Rolling_Counter(void);
+extern int32_t  Sys_Get_Running_Time(Sys_Time_st_t *pstTime);
+
+extern int32_t  Sys_Timer_Start(Sys_Timer_st_t *pHandle, uint32_t u32Interval, uint32_t u32Loop, Sys_Timer_Cb_pfn_t pfnCallBack);
+extern int32_t  Sys_Timer_Stop(Sys_Timer_st_t *pHandle);
+extern int32_t  Sys_Timer_Get_Status(Sys_Timer_st_t *pHandle);
+extern int32_t  Sys_Timer_Get_Counter(Sys_Timer_st_t *pHandle, uint32_t *pu32Counter);
+
+extern void Sys_Scheduler_Start(uint32_t u32SchCycle);
+extern void Sys_Scheduling_Service(void);
+extern void Sys_Scheduler_ISR(void);
+
+extern void Sys_Pseudo_Real_Time_Tasks(void);
+extern void Sys_Exact_1ms_Tasks(void);
+extern void Sys_2ms_Tasks(void);
+extern void Sys_5ms_Tasks(void);
+extern void Sys_10ms_Tasks(void);
+extern void Sys_20ms_Tasks(void);
+extern void Sys_50ms_Tasks(void);
+extern void Sys_100ms_Tasks(void);

System/Sys_Task_List.c

+
+#include "Sys_Scheduler_Lib.h"
+#include "Components.h"
+//#include "CommonInterface.h"
+#include "RTE.h"
+#include "FreIn.h"
+#include "FreIn_User.h"
+#include "Telltales_user.h"
+#include "Display.h"
+#include "PowerManagement\PowerManagement.h"
+#include "PowerManagement\PowerManag_user.h"
+#include "Line_In\Line_In.h"
+#include "AMT630H\UartProtocol.h"
+#include "tim.h"
+#include "UDS\DoCAN_ISO15765.h"
+#include "UDS\UDS_ISO14229_Server.h"
+#include "OPT3004.h"
+#include "UDS\UDS_ISO14229_Services.h"
+#include "RTE_GPIO_BAT32A279.h"
+#include "CAN_Signal\CAN_Lib.h"
+#include "Can_User.h"
+void Sys_Pseudo_Real_Time_Tasks(void)
+{
+    Power_Management_Service();
+    DoCAN_Communication_Service();
+    UDS_Server_Application_Service();
+}
+
+void Sys_2ms_Tasks(void)
+{
+    Common_Input_Para();
+    Sys_Status_Update_Service();
+    Analog_Signal_Conv_Service();
+}
+
+void Sys_5ms_Tasks(void)
+{
+    Flash_Sync_Signal_Generation_Service();
+    
+}
+
+void Sys_10ms_Tasks(void)
+{
+    Speed_Self_Inspection();
+    Fre_In_Service(FRE_VEHICLE);
+    Fre_In_Time_Out_Handle(10);
+    LED_Turn_Left_Judgement();
+    LED_Turn_Right_Judgement();
+    Line_In_Debounce_Service(10u);
+    Mileage_Total_Clearing();
+    Data_Mileage_Write_EEPROM();
+    Fuel_R_Cal(10u);
+    Coolant_R_Cal(10u);
+    tyre_Size();
+    Driving_Mode_Display();
+    Key_Service();
+    Can_BusOff_Recover(10u);
+}
+
+void Sys_20ms_Tasks(void)
+{
+    Data_Vehicle_Speed_Duty_Cycle_Detection();
+    Data_Vehicle_Speed_Processing_Service();
+    Data_Engine_Speed_Processing_Service();
+    ADProcess_NTC_Temp_Service();
+}
+
+void Sys_50ms_Tasks(void)
+{
+    Telltales_Management();
+    Time_Display_Service();
+    Time_Cocln_server();
+    Backlight_SetPwm_cotrol();
+    Optical_Fault_Recovery();
+    Self_Inspection();
+    AMT630H_Main();
+}
+
+
+extern void PackedTransfer_GetSwVer(void);
+void Sys_100ms_Tasks(void)
+{
+    S3_ServerCNTT();
+    Fuel_Cal_Sevice(100u);
+    Coolant_Cal_Sevice(100u);
+    Fuel_Self_InspectionOld();
+    Coolant_Self_InspectionOld();
+    Service_Interval_Processing();
+    Service_Interval_TimerISR();
+    Display_Battery_Voltage();
+    PackedTransfer_GetSwVer();
+    // AMT630_CLK();
+    AMT630H_Sleep12();
+}
+
+uint16_t task_2ms = 0u;
+uint32_t task_100ms = 0u;
+void Sys_Exact_1ms_Tasks(void)
+{
+    GenDelay_Tick();
+    eeprom_1ms_timeCount();
+    CanMSg_XMS_Analysis(&CAN_CH0_CanMsgOp, 1u);
+    task_2ms++;
+    if (task_2ms >= 2)
+    {
+        task_2ms = 0;
+        AMT630H_Timer(2);
+        Can_Write_Fun(&CAN_CH0_CanMsgTxOp, 2000u);//无外发
+        DoCAN_Timer_Update(2000u);
+    }
+    // Pwm_Controller();
+    Pwm_Controller_Buzzer_X();
+    if(task_100ms >= 100)
+    {
+        task_100ms = 0;
+        Services_Mileage_Callback();
+    }
+    else
+    {
+        task_100ms++;
+    }
+}
+

System/main.c

+/*****************************************************************************
+ * Copyright (c) 2022, Nations Technologies Inc.
+ *
+ * All rights reserved.
+ * ****************************************************************************
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the disclaimer below.
+ *
+ * Nations' name may not be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY NATIONS "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * DISCLAIMED. IN NO EVENT SHALL NATIONS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ****************************************************************************/
+
+/**
+ * @file main.c
+ * @author Nations
+ * @version v1.0.0
+ *
+ * @copyright Copyright (c) 2022, Nations Technologies Inc. All rights reserved.
+ */
+#include "main.h"
+#include <stdio.h>
+#include <stdint.h>
+#include "Sys_Scheduler.h"
+#include "RTE.h"
+#include "Components.h"
+#include "Can_User.h"
+#include "userdefine.h"
+#include "BackLight.h"
+#include "tim.h"
+#include "PowerManagement\PowerManagement.h"
+void Sys_Startup_Pre_Init(void)
+{
+#if (HAS_BOOTLOADER == 1u)
+    __disable_irq();
+    SCB->VTOR = APP_BASE;
+    __DMB();
+    __enable_irq();
+#endif
+    __disable_irq();
+
+    /* soft delay, for power to stabilize */
+    {
+        uint32_t  tmpPowerStabCnt = 20000;
+
+		while ( tmpPowerStabCnt-- ) 
+        {  ;  }
+    }
+
+    __enable_irq();
+    RTE_CLOCK_Select_Start();
+}
+
+
+uint32_t u4Freq = 0;
+void Sys_Startup_Init(void)
+{
+    uint8_t u8StartupMode = 0U;
+
+    uint32_t width = 0;
+
+    __disable_irq();
+    RTE_WDT_Enable();
+    GenDelay_Init(RTE_WDT_Clear);
+    RTE_GPIO_Init(); 
+
+    // TimerM_PWM_CH_Output_init(TIMERM_COUNTER1, TIMERM_CHB, ActiveLevel_High);
+    RTE_CAPTURE_KL30_Init();
+    Gpio_Init(Gpio_KL30_Init);
+    RTE_DEEPSLEEP_GPIO_Interrupt_Disable();
+    __enable_irq();
+
+    // Gen_TimeDelay(10000u, 1000u); 
+    PwrMemInit( );
+    Power_Management_Init(u8StartupMode);
+    Can_Init();
+    Amt630hInit();
+
+}
+
+/**
+ * @brief  Main program.
+ */
+int main(void)
+{
+
+ 	Sys_Startup_Pre_Init();
+    Sys_Scheduler_Init();
+	Sys_Startup_Init();
+    while ( 1 )
+    {
+        
+        RTE_WDT_Clear();        
+        Sys_Scheduling_Service();
+    }
+}
+
+/**
+ * @brief Assert failed function by user.
+ * @param file The name of the call that failed.
+ * @param line The source line number of the call that failed.
+ */
+#ifdef USE_FULL_ASSERT
+void assert_failed(const uint8_t* expr, const uint8_t* file, uint32_t line)
+{
+    while (1)
+    {
+    }
+}
+#endif // USE_FULL_ASSERT
+
+/**
+ * @}
+ */

System/main.h

+/*****************************************************************************
+ * Copyright (c) 2022, Nations Technologies Inc.
+ *
+ * All rights reserved.
+ * ****************************************************************************
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the disclaimer below.
+ *
+ * Nations' name may not be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY NATIONS "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * DISCLAIMED. IN NO EVENT SHALL NATIONS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ****************************************************************************/
+
+/**
+ * @file main.h
+ * @author Nations
+ * @version v1.0.0
+ *
+ * @copyright Copyright (c) 2022, Nations Technologies Inc. All rights reserved.
+ */
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MAIN_H__ */
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */
+
+/**
+ * @}
+ */