motor_ctl-3/SelfTestUser/src_middlewares/stm32fxx_STURunTimeCheck.c

#include "stm32f1xx_hal.h"
#include "stm32fxx_STUlib.h"

ErrorStatus STU_CheckStack(void);

void STU_InitStackBottom(void);

void STU_InitRunTimeChecks(void)
{
	STU_RamRunInit();
	STU_RomCrc32Init();
	STU_InitStackBottom();
}

void STU_DoRunTimeChecks(void)
{
	STU_TestStatus  rom_test;
	
	if(TimeBaseFlag == 0xAAAAAAAAuL)
	{
		if ((TimeBaseFlag ^ TimeBaseFlagInv) == 0xFFFFFFFFuL) //ʱ¼ä±êÖ¾
		{
			/* Initialization of counters for control flow monitoring */
			init_control_flow();
			
			/*----------------------------------------------------------------------*/
      /*---------------------------- CPU registers ----------------------------*/
      /*----------------------------------------------------------------------*/
			control_flow_call(CPU_TEST_CALLER);
			
			STU_CpuTestRun();
			
			control_flow_resume(CPU_TEST_CALLER);
			
			/*----------------------------------------------------------------------*/
      /*------------------------- Stack overflow -----------------------------*/
      /*----------------------------------------------------------------------*/
			control_flow_call(STACK_OVERFLOW_TEST);
			
			 if (STU_CheckStack() == ERROR)
			 {
					FailSafePOR();
			 }
			
			 control_flow_resume(STACK_OVERFLOW_TEST);
			 
			/*--------------------------------------------------------------------------*/
			/*--------------------- ROM CRC check ------------------------*/
			/*--------------------------------------------------------------------------*/
			control_flow_call(CRC32_TEST_CALLER);
			 
			rom_test = STU_RomCrc32Run();
			switch ( rom_test )
      {
				 case TEST_RUNNING:
					 break;
				 case TEST_OK:
					 break;
				 case TEST_FAILURE:
					 FailSafePOR();
					 break;
         case CLASS_C_DATA_FAIL:
         default:
					 FailSafePOR();
           break;
			}
			
			control_flow_resume(CRC32_TEST_CALLER);
			
			/*--------------------------------------------------------------------------*/
			/* --------------------- Instruct and decode test -------------------*/
			/*--------------------------------------------------------------------------*/
			control_flow_call(INSTRUCT_AND_DECODE_TEST_CALLER);
			
			if(STU_InstructAndDecode() == ERROR)
			{
				FailSafePOR();
			}
			
			control_flow_resume(INSTRUCT_AND_DECODE_TEST_CALLER);
			
			/*--------------------------------------------------------------------------*/
			/* --------------------- Addressing test -------------------*/
			/*--------------------------------------------------------------------------*/
			control_flow_call(ADDRESSING_TEST_CALLER);
			
			if(STU_AddressingTest() == ERROR)
			{
				FailSafePOR();
			}
			
			control_flow_resume(ADDRESSING_TEST_CALLER);
			
			
			/*--------------------------------------------------------------------------*/
			/*---------------------   Verify Control flow   ----------------------------*/
			/*--------------------------------------------------------------------------*/
			 if (control_flow_check_point(RUNTIME_TEST_CHECK) == ERROR)
			{
				 FailSafePOR();
			}
			
			/******Çå³ýʱ¼ä±êÖ¾*******/
			TimeBaseFlag = 0u;
		}
		else
		{
			FailSafePOR();
		}
	}
	

}

void STU_InitStackBottom(void)
{
	aStackOverFlowPtrn[0] = 0xEEEEEEEEuL;
  aStackOverFlowPtrn[1] = 0xCCCCCCCCuL;
  aStackOverFlowPtrn[2] = 0xBBBBBBBBuL;
  aStackOverFlowPtrn[3] = 0xDDDDDDDDuL;
}

/**
  * @brief  This function verifies that Stack didn't overflow
  * @param  : None
  * @retval : ErrorStatus = (ERROR, SUCCESS)
  */
ErrorStatus STU_CheckStack(void)
{
  ErrorStatus result = SUCCESS;
  
  //CtrlFlowCnt += STACK_OVERFLOW_CALLEE;

  if ( aStackOverFlowPtrn[0] != 0xEEEEEEEEuL )
  {
    result = ERROR;
  }
  if ( aStackOverFlowPtrn[1] != 0xCCCCCCCCuL )
  {
    result = ERROR;
  }
  if ( aStackOverFlowPtrn[2] != 0xBBBBBBBBuL )
  {
    result = ERROR;
  }
  if ( aStackOverFlowPtrn[3] != 0xDDDDDDDDuL )
  {
    result = ERROR;
  }

  //CtrlFlowCntInv -= STACK_OVERFLOW_CALLEE;

  return (result);
}