代码如下#include "Std_Types.h"
#include "RteLayer_User.h"
#include "RunnableTimeTest.h"
#include "Os_Cfg.h"
#include "RteLayer_OS.h"
#include "SchM_Rtm.h"
#include "Os_Stack_Cfg.h"
#include "IfxStm_reg.h"
#include "McalLib.h"
#include "Os_Types_Lcfg.h"
#include "IfxStm_reg.h"
//------------------------------------------------
#define RTM_SUPPORT STD_ON
//------------------------------------------------
#if (RTM_SUPPORT == STD_ON)
#include "Rtm.h"
#include "Rtm_Cfg.h"
#endif
#define RUNING_TIME_LENGTH 70
/* 100ms cnt++, 2s update index */
#define TaskIDAndIsrUpdateCnt_Max 21
/* 3: Core0/Core1/Core2 ISR */
#define TASK_ISR_STACK_SIZE (OS_TASKID_COUNT + 3)
#define CORE0_ISR_STACK_INDEX (OS_TASKID_COUNT)
#define CORE1_ISR_STACK_INDEX (OS_TASKID_COUNT + 1)
#define CORE2_ISR_STACK_INDEX (OS_TASKID_COUNT + 2)
static const uint16 TaskAndIsrStackSize[TASK_ISR_STACK_SIZE] = {
/* 0 */ OS_CFG_SIZE_DEFAULT_BSW_CORE0_ASYNC_TASK_STACK ,
/* 1 */ OS_CFG_SIZE_DEFAULT_BSW_CORE0_SYNC_TASK_STACK ,
/* 2 */ OS_CFG_SIZE_DEFAULT_BSW_CORE1_SYNC_TASK_STACK ,
/* 3 */ OS_CFG_SIZE_DEFAULT_BSW_CORE2_SYNC_TASK_STACK ,
/* 4 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 5 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 6 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 7 */ OS_CFG_SIZE_OSCORE2_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 8 */ OS_CFG_SIZE_OSCORE2_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 9 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 10 */ OS_CFG_SIZE_DEFAULT_RTE_MODE_SWITCH_TASK_STACK ,
/* 11 */ OS_CFG_SIZE_OSCORE0_TASK_PRIO4294967295_STACK ,
/* 12 */ OS_CFG_SIZE_OSCORE1_TASK_PRIO4294967295_STACK ,
/* 13 */ OS_CFG_SIZE_OSCORE0_TASK_PRIO4294967295_STACK ,
/* 14 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 15 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILA_TASK_100MS_STACK ,
/* 16 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILA_TASK_10MS_STACK ,
/* 17 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILA_TASK_5MS_STACK ,
/* 18 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 19 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILB_TASK_10MS_STACK ,
/* 20 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILC_5MS_STACK ,
/* 21 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 22 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 23 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILD_TASK_100MS_STACK ,
/* 24 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_ASILD_TASK_10MS_STACK ,
/* 25 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 26 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_QM_TASK_1000MS_STACK ,
/* 27 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_QM_TASK_100MS_STACK ,
/* 28 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_QM_TASK_10MS_STACK ,
/* 29 */ OS_CFG_SIZE_STARTAPP_ASW_CORE1_QM_TASK_5MS_STACK ,
/* 30 */ OS_CFG_SIZE_OSCORE2_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 31 */ OS_CFG_SIZE_STARTAPP_ASW_CORE2_QM_TASK_1000MS_STACK ,
/* 32 */ OS_CFG_SIZE_STARTAPP_ASW_CORE2_QM_TASK_100MS_STACK ,
/* 33 */ OS_CFG_SIZE_STARTAPP_ASW_CORE2_QM_TASK_10MS_STACK ,
/* 34 */ OS_CFG_SIZE_STARTAPP_ASW_CORE2_QM_TASK_5MS_STACK ,
/* 35 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_ASILB_CDD_TASK_STACK ,
/* 36 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 37 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_ASILD_AFE_TASK_STACK ,
/* 38 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_ASILD_CDD_TASK_STACK ,
/* 39 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 40 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 41 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_ECUMSHUTDOWN_TASK_STACK ,
/* 42 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_QM_ASRCOMMON_TASK_STACK ,
/* 43 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_QM_CDD_TASK_STACK ,
/* 44 */ OS_CFG_SIZE_OSCORE0_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 45 */ OS_CFG_SIZE_STARTAPP_BSW_CORE0_QM_NVM_TASK_STACK ,
/* 46 */ OS_CFG_SIZE_OSCORE0_TASK_PRIO29_STACK,
/* 47 */ OS_CFG_SIZE_OSCORE1_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 48 */ OS_CFG_SIZE_STARTAPP_BSW_CORE1_QM_TASK_STACK ,
/* 49 */ OS_CFG_SIZE_OSCORE1_TASK_PRIO33_STACK,
/* 50 */ OS_CFG_SIZE_STARTAPP_BSW_CORE2_QM_TASK_STACK ,
/* 51 */ OS_CFG_SIZE_OSCORE2_TASK_NONPREEMPTIVEBASIC_STACK ,
/* 52 */ OS_CFG_SIZE_OSCORE2_TASK_PRIO40_STACK,
/* 53 */ OS_CFG_SIZE_STARTAPP_CORE0_QM_CDD_ASW_TASK_STACK ,
/* 54 */ OS_CFG_SIZE_OSCORE0_ISR_CORE_STACK ,
/* 55 */ OS_CFG_SIZE_OSCORE1_ISR_CORE_STACK ,
/* 56 */ OS_CFG_SIZE_OSCORE2_ISR_CORE_STACK ,
};
/* Occupied the default area*/
#define DEFAULT_OCCUPIED_MAX 16
#define DEFAULT_OCCUPIED_INDEX 0
volatile uint8 Default_Occupied_Data[DEFAULT_OCCUPIED_MAX] = {0};
volatile uint8 Default_Occupied_Bss[DEFAULT_OCCUPIED_MAX];
#if (RUNTIME_TEST_CTRL == RUNTIME_TEST_ENABLE)
#define RTE_START_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
/* get run time */
uint32 Test_DeltRunTime[RUNING_TIME_LENGTH] = {0};
static uint32 u32LastRunnableTimeus[RUNING_TIME_LENGTH];
static uint32 u32StartTimeus[RUNING_TIME_LENGTH];
static uint32 u32StopTimeus[RUNING_TIME_LENGTH];
static uint32 u32MaxDelatTime[RUNING_TIME_LENGTH];
static uint32 u32MaxRunnableTime[RUNING_TIME_LENGTH];
static uint8 u8DltDelayCnt[RUNING_TIME_LENGTH];
static uint32 u32CurDelatTime[RUNING_TIME_LENGTH];
static uint32 u32NewTime[RUNING_TIME_LENGTH];
static uint32 u32CurrntRunTime[RUNING_TIME_LENGTH];
static uint8 u8RunDelayCnt[RUNING_TIME_LENGTH];
#define RTE_STOP_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
#endif
#if (RTM_SUPPORT == STD_ON)
#define RTE_START_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
/* Core0 Cupload*/
static Rtm_CpuLoadHistogramType Core0Cupload = {{0}};
#define RTE_STOP_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
#define RTE_START_SEC_CORE1_QM_RAM_CLEARED
#include "Rte_MemMap.h"
/* Core1 Cupload*/
static Rtm_CpuLoadHistogramType Core1Cupload = {{0}};
#define RTE_STOP_SEC_CORE1_QM_RAM_CLEARED
#include "Rte_MemMap.h"
#define RTE_START_SEC_CORE2_QM_RAM_CLEARED
#include "Rte_MemMap.h"
/* Core2 Cupload*/
static Rtm_CpuLoadHistogramType Core2Cupload = {{0}};
#define RTE_STOP_SEC_CORE2_QM_RAM_CLEARED
#include "Rte_MemMap.h"
#endif
#define RTE_START_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
/* Task ID And Isr info*/
static uint8 TaskIDAndIsrIndex = 0;
static uint8 TaskIDAndIsrUpdateCnt = 0;
/* Task ID And Isr info for Com*/
static uint8 Com_TaskIDAndIsrIndex = 0;
static uint8 Com_RequestTaskIDAndIsrCnt = 0;
static uint8 TaskAndIsrStackUsage[TASK_ISR_STACK_SIZE] = {0};
#define RTE_STOP_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
/* Task And Isr Stack Measurement */
void TaskAndIsrStackMeasurement(void)
{uint16 TaskAndIsrStack_temp = 0;
uint32 TaskAndIsrID_Stack_temp = 0;
TaskIDAndIsrUpdateCnt++;
if(TaskIDAndIsrUpdateCnt_Max == TaskIDAndIsrUpdateCnt)
{(void)(Default_Occupied_Data[DEFAULT_OCCUPIED_INDEX]);
(void)(Default_Occupied_Bss[DEFAULT_OCCUPIED_INDEX]);
TaskIDAndIsrIndex++;
TaskIDAndIsrUpdateCnt = 0;}
if(((uint8)OS_TASKID_COUNT) > TaskIDAndIsrIndex)
{/* Task Stack Measurement */
TaskAndIsrStack_temp = (uint16)Os_GetTaskStackUsage((TaskType)TaskIDAndIsrIndex);}
else if(((uint8)CORE0_ISR_STACK_INDEX) == TaskIDAndIsrIndex)
{/* Isr Stack Measurement */
TaskAndIsrStack_temp = (uint16)Os_GetISRStackUsage(AdcGroup0);}
else if(((uint8)CORE1_ISR_STACK_INDEX) == TaskIDAndIsrIndex)
{/* Isr Stack Measurement */
TaskAndIsrStack_temp = (uint16)Os_GetISRStackUsage(CounterIsr_OsCounter01);}
else if(((uint8)CORE2_ISR_STACK_INDEX) == TaskIDAndIsrIndex){
/* Isr Stack Measurement */
TaskAndIsrStack_temp = (uint16)Os_GetISRStackUsage(CounterIsr_OsCounter02);
}else
{/* Task Stack Measurement */
TaskIDAndIsrIndex = 0;
TaskAndIsrStack_temp = (uint16)Os_GetTaskStackUsage((TaskType)TaskIDAndIsrIndex);
}
TaskAndIsrID_Stack_temp = (((uint32)TaskIDAndIsrIndex << 24) & 0xff000000u) + (((uint32)TaskAndIsrStack_temp << 8) & 0x00ffff00u);
/* to rte*/
OS_Set_U32_TaskAndIsrID_Stack(TaskAndIsrID_Stack_temp);
if(TaskAndIsrStackSize[Com_TaskIDAndIsrIndex] > 0)
{/*Stack Usage Rate Calculate For Com*/
if(((uint8)OS_TASKID_COUNT) > Com_TaskIDAndIsrIndex)
{/*Task Stack Usage Rate Calculate For Com*/
TaskAndIsrStackUsage[Com_TaskIDAndIsrIndex] = (uint8)(100 * Os_GetTaskStackUsage((TaskType)Com_TaskIDAndIsrIndex)/TaskAndIsrStackSize[Com_TaskIDAndIsrIndex]);}
else if(((uint8)CORE0_ISR_STACK_INDEX) == Com_TaskIDAndIsrIndex){
/*ISR Stack Usage Rate Calculate For Com*/
TaskAndIsrStackUsage[Com_TaskIDAndIsrIndex] = (uint8)(100 * Os_GetISRStackUsage(AdcGroup0)/TaskAndIsrStackSize[Com_TaskIDAndIsrIndex]);
}else if(((uint8)CORE1_ISR_STACK_INDEX) == Com_TaskIDAndIsrIndex)
{/*ISR Stack Usage Rate Calculate For Com*/
TaskAndIsrStackUsage[Com_TaskIDAndIsrIndex] = (uint8)(100 * Os_GetISRStackUsage(CounterIsr_OsCounter01)/TaskAndIsrStackSize[Com_TaskIDAndIsrIndex]);
}
else if(((uint8)CORE2_ISR_STACK_INDEX) == Com_TaskIDAndIsrIndex)
{
/*ISR Stack Usage Rate Calculate For Com*/
TaskAndIsrStackUsage[Com_TaskIDAndIsrIndex] = (uint8)(100 * Os_GetISRStackUsage(CounterIsr_OsCounter02)/TaskAndIsrStackSize[Com_TaskIDAndIsrIndex]);
}else
{/*The First Index Task Stack Usage Rate Calculate For Com*/
Com_TaskIDAndIsrIndex = 0;
TaskAndIsrStackUsage[Com_TaskIDAndIsrIndex] = (uint8)(100 * Os_GetTaskStackUsage((TaskType)Com_TaskIDAndIsrIndex)/TaskAndIsrStackSize[Com_TaskIDAndIsrIndex]);}}
Com_TaskIDAndIsrIndex++;}
uint32 OS_TaskAndIsrStackUsageForCom(void)
{uint32 Retval = 0;
uint32 Isr_tmp = 1;
if(((uint8)OS_TASKID_COUNT) > Com_RequestTaskIDAndIsrCnt)
{/* Task Stack For Com */
Retval = (((uint32)Com_RequestTaskIDAndIsrCnt << 8) & 0x0000ff00u) + ((uint32)TaskAndIsrStackUsage[Com_RequestTaskIDAndIsrCnt] & 0x000000ffu);}
else if(((uint8)CORE0_ISR_STACK_INDEX) == Com_RequestTaskIDAndIsrCnt)
{/* ISR Stack For Com */
Isr_tmp = 1;
Isr_tmp = Isr_tmp << 16;
Retval = (Isr_tmp & 0x00ff0000u) + (((uint32)Com_RequestTaskIDAndIsrCnt << 8) & 0x0000ff00u) + ((uint32)TaskAndIsrStackUsage[Com_RequestTaskIDAndIsrCnt] & 0x000000ffu);}
else if(((uint8)CORE1_ISR_STACK_INDEX) == Com_RequestTaskIDAndIsrCnt){
/* ISR Stack For Com */
Isr_tmp = 2;
Isr_tmp = Isr_tmp << 16;
Retval = (Isr_tmp & 0x00ff0000u) + (((uint32)Com_RequestTaskIDAndIsrCnt << 8) & 0x0000ff00u) + ((uint32)TaskAndIsrStackUsage[Com_RequestTaskIDAndIsrCnt] & 0x000000ffu);
}else if(((uint8)CORE2_ISR_STACK_INDEX) == Com_RequestTaskIDAndIsrCnt)
{/* ISR Stack For Com */
Isr_tmp = 3;
Isr_tmp = Isr_tmp << 16;
Retval = (Isr_tmp & 0x00ff0000u) + (((uint32)Com_RequestTaskIDAndIsrCnt << 8) & 0x0000ff00u) + ((uint32)TaskAndIsrStackUsage[Com_RequestTaskIDAndIsrCnt] & 0x000000ffu);
}else{/* Task Stack For Com */
Com_RequestTaskIDAndIsrCnt = 0;
Retval = (((uint32)Com_RequestTaskIDAndIsrCnt << 8) & 0x0000ff00u) + ((uint32)TaskAndIsrStackUsage[Com_RequestTaskIDAndIsrCnt] & 0x000000ffu);}
Com_RequestTaskIDAndIsrCnt++;
return Retval;}
#if (RUNTIME_TEST_CTRL == RUNTIME_TEST_ENABLE)
uint32 GetRunnableTime(uint8 RunnableIndex)
{uint32 u32Time = 0;
if(RunnableIndex >= RUNING_TIME_LENGTH)
{u32Time = 0;}
else{//Infineon TC377 is 0xF0001010
u32NewTime[RunnableIndex] = (STM0_TIM0.U)/80;
if(u32NewTime[RunnableIndex] >= u32LastRunnableTimeus[RunnableIndex])
{ u32Time = u32NewTime[RunnableIndex] - u32LastRunnableTimeus[RunnableIndex];
}else {
u32Time = 0xffffffffu / 80 - u32LastRunnableTimeus[RunnableIndex] + u32NewTime[RunnableIndex];}
u32LastRunnableTimeus[RunnableIndex] = (STM0_TIM0.U)/80;
u32CurrntRunTime[RunnableIndex] = u32Time;
u8RunDelayCnt[RunnableIndex] ++;
if(u8RunDelayCnt[RunnableIndex] >= 10)
{ u8RunDelayCnt[RunnableIndex] = 10; /*10次后开始记录最大时间*/
if(u32Time > u32MaxRunnableTime[RunnableIndex])
{u32MaxRunnableTime[RunnableIndex] = u32Time;}}}
return u32Time;
}
void StartRunnableTime(uint8 RunnableIndex)
{if(RunnableIndex >= RUNING_TIME_LENGTH){
/* return */
;
}else{
/* get start time */
u32StartTimeus[RunnableIndex] = (STM0_TIM0.U)/80;}}
uint8 StopRunnableTime(uint8 RunnableIndex, uint32 *DeltRunTime, uint32 *MaxDeltRunTime)
{uint32 u32ret;
uint8 RetVal = E_OK;
if((RunnableIndex >= RUNING_TIME_LENGTH) || (DeltRunTime == NULL_PTR) || (MaxDeltRunTime == NULL_PTR))
{
RetVal = E_NOT_OK;
}else
{/* get stop time */
u32StopTimeus[RunnableIndex] = (STM0_TIM0.U)/80;
if(u32StopTimeus[RunnableIndex] >= u32StartTimeus[RunnableIndex])
{
u32ret = u32StopTimeus[RunnableIndex] - u32StartTimeus[RunnableIndex];
}else{
u32ret = 0xffffffffu / 80 - u32StartTimeus[RunnableIndex] + u32StopTimeus[RunnableIndex];}
u32CurDelatTime[RunnableIndex] = u32ret;
*DeltRunTime = u32ret;
u8DltDelayCnt[RunnableIndex] ++;
if(u8DltDelayCnt[RunnableIndex] >= 10)
{u8DltDelayCnt[RunnableIndex] = 10; /*10次后开始记录最大时间*/
if(u32ret > u32MaxDelatTime[RunnableIndex])
{u32MaxDelatTime[RunnableIndex] = u32ret;
}}
*MaxDeltRunTime = u32MaxDelatTime[RunnableIndex];
RetVal = E_OK;}
return RetVal;
}
uint32 GetMaxRunnableDeltTime(uint8 RunnableIndex)
{uint32 RetVal = 0;
if( RunnableIndex < RUNING_TIME_LENGTH){
RetVal = u32MaxDelatTime[RunnableIndex];
}else{
RetVal = 0xFFFFFFFFU;
}return RetVal;
}
uint32 GetMaxRunnableTime(uint8 RunnableIndex)
{uint32 RetVal = 0;
if( RunnableIndex < RUNING_TIME_LENGTH)
{RetVal = u32MaxRunnableTime[RunnableIndex];}
else{ RetVal = 0xFFFFFFFFU;}
return RetVal;}
#endif
#define RTE_START_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
static uint8 u8Start_cpuloadcore0 = 0;
static uint32 Core0_u32Cpuload = 0;
#define RTE_STOP_SEC_BSW_CORE0_QM_INIT
#include "Rte_MemMap.h"
void Core0CpuLoadMeasurement(uint8 *ptrCpuload)
{ if(ptrCpuload == NULL_PTR)
{ ;}else{
#if (RTM_SUPPORT == STD_ON)
if(1 == u8Start_cpuloadcore0)
{/* Stop CpuLoad Measurement */
Rtm_Stop_CpuLoadMeasurement_0();
(void)Rtm_GetCpuLoadHistogram(0,&Core0Cupload);
/* get current CpuLoad result */
(void)Rtm_GetMeasurementItem(RtmConf_RtmMeasurementPoint_Rtm_CpuLoadMeasurement_0,RTM_ITEM_CPU_LOAD_CURRENT, &Core0_u32Cpuload);
/* Start CpuLoad Measurement */
Rtm_Start_CpuLoadMeasurement_0(); }
if(0 == u8Start_cpuloadcore0){
/* Start CpuLoad Measurement, only run once */
Rtm_Start_CpuLoadMeasurement_0();
u8Start_cpuloadcore0 = 1;}
#endif
*ptrCpuload = (uint8)Core0_u32Cpuload;}}
#define RTE_START_SEC_CORE1_QM_RAM_INIT
#include "Rte_MemMap.h"
static uint8 u8Start_cpuloadcore1 = 0;
static uint32 Core1_u32Cpuload = 0;
#define RTE_STOP_SEC_CORE1_QM_RAM_INIT
#include "Rte_MemMap.h"
void Core1CpuLoadMeasurement(uint8 *ptrCpuload)
{ if(ptrCpuload == NULL_PTR)
{ ;}
else
{#if (RTM_SUPPORT == STD_ON)
if(1 == u8Start_cpuloadcore1)
{
/* Stop CpuLoad Measurement */
Rtm_Stop_CpuLoadMeasurement_1();
(void)Rtm_GetCpuLoadHistogram(1,&Core1Cupload);
/* get current CpuLoad result */
(void)Rtm_GetMeasurementItem(RtmConf_RtmMeasurementPoint_Rtm_CpuLoadMeasurement_1,RTM_ITEM_CPU_LOAD_CURRENT, &Core1_u32Cpuload);
/* Start CpuLoad Measurement */
Rtm_Start_CpuLoadMeasurement_1(); }
if(0 == u8Start_cpuloadcore1)
{/* Start CpuLoad Measurement, only run once */
Rtm_Start_CpuLoadMeasurement_1();
u8Start_cpuloadcore1 = 1;}
#endif
*ptrCpuload = (uint8)Core1_u32Cpuload;
}}
#define RTE_START_SEC_CORE2_QM_RAM_INIT
#include "Rte_MemMap.h"
static uint8 u8Start_cpuloadcore2 = 0;
static uint32 Core2_u32Cpuload = 0;
#define RTE_STOP_SEC_CORE2_QM_RAM_INIT
#include "Rte_MemMap.h"
extern uint8 CDDRst_0x107_TestSwitchSig;
extern uint16 Core2_TrapTest_Switch;
extern uint32 * Ptr_Core2_TrapTest_1;
void Core2CpuLoadMeasurement(uint8 *ptrCpuload){
if(4 == CDDRst_0x107_TestSwitchSig) {
/* MPU */
CddCtrl_Set_U32_CHGPL_ST(2); }
if(ptrCpuload == NULL_PTR)
{ ;}else{
#if (RTM_SUPPORT == STD_ON)
if(1 == u8Start_cpuloadcore2)
{
/* Stop CpuLoad Measurement */
Rtm_Stop_CpuLoadMeasurement_2();
(void)Rtm_GetCpuLoadHistogram(2,&Core2Cupload);
/* get current CpuLoad result */
(void)Rtm_GetMeasurementItem(RtmConf_RtmMeasurementPoint_Rtm_CpuLoadMeasurement_2,RTM_ITEM_CPU_LOAD_CURRENT, &Core2_u32Cpuload);
/* Start CpuLoad Measurement */
Rtm_Start_CpuLoadMeasurement_2(); }
if(0 == u8Start_cpuloadcore2)
{
/* Start CpuLoad Measurement, only run once */
Rtm_Start_CpuLoadMeasurement_2();
u8Start_cpuloadcore2 = 1;}
#endif
*ptrCpuload = (uint8)Core2_u32Cpuload;
}
}
/*********************************************************************************************
Function Introdution: OS 延时函数 us
**********************************************************************************************/
uint64 Os_Time_HiRes_Tick(void)
{
uint64 u64Time_us_divide_100 = 0;
uint32 CoreId = 0xFFFF;
CoreId = Mcal_GetCpuIndex();
if(0 == CoreId)
{
SuspendAllInterrupts();
/* Fisrt, Read STM low 32bit; meanwhile, the upper 32 bits of STM stores in CAP Register; then read the CAP Register as the upper 32 bits*/
u64Time_us_divide_100 = (uint64)(STM0_TIM0.U) | ((uint64)(STM0_CAP.U) << 32);
ResumeAllInterrupts();}
else if(1 == CoreId){
SuspendAllInterrupts();
/* Fisrt, Read STM low 32bit; meanwhile, the upper 32 bits of STM stores in CAP Register; then read the CAP Register as the upper 32 bits*/
u64Time_us_divide_100 = (uint64)(STM1_TIM0.U) | ((uint64)(STM1_CAP.U) << 32);
ResumeAllInterrupts();
}
else if(2 == CoreId)
{
SuspendAllInterrupts();
/* Fisrt, Read STM low 32bit; meanwhile, the upper 32 bits of STM stores in CAP Register; then read the CAP Register as the upper 32 bits*/
u64Time_us_divide_100 = (uint64)(STM2_TIM0.U) | ((uint64)(STM2_CAP.U) << 32);
ResumeAllInterrupts();}
else{}
return u64Time_us_divide_100;
}
怎么写这部分详细设计文档的数据结构设计部分
最新发布