[参考译文] AM2634：SBL CAN 问题

/*******************************************************************************/
/* NEC Interrupt Vector Define */
/*******************************************************************************/
//#pragma	interrupt INTTM50	Timebase_Routine
//#pragma	interrupt INTTMH1	CycleWakeUp_Routine

/*******************************************************************************/
/* Header File Includes*/
/*******************************************************************************/ 


//#include "TI_Define.h"
//#include "DF_Value.h"

#include <stdio.h>

#include <kernel/dpl/ClockP.h>
#include <kernel/dpl/DebugP.h>
#include <kernel/dpl/SystemP.h>
#include <drivers/soc.h>
#include <kernel/dpl/AddrTranslateP.h>
#include "ti_dpl_config.h"
#include "ti_drivers_config.h"
#include "HHtimebase.h"
#include "DF_Value.h"

//#define CONFIG_TIMER0_INT_NUM                       (CONFIG_TIMER0_INT_NUM)
#define APP_MCAN_INTR_NUM                        (CONFIG_MCAN0_INTR)
#define APP_MCAN_MSG_LOOP_COUNT                  (10U)

void myClockCallback(void *args);
/*******************************************************************************/
/* Private Typedef Structure*/
/*******************************************************************************/
typedef struct
{
    DF_U08	T1msFlag	;     /* Flag for 1ms   */
	DF_U08	T10msFlag	;     /* Flag for 10ms  */
	DF_U08	T50msFlag	;     /* Flag for 50ms  */
    DF_U08	T100msFlag	;     /* Flag for 100ms */

	DF_U32	T10msTimer	;
	DF_U32	T50msTimer	;
    DF_U32	T100msTimer	;

	DF_U32	DelayCount	;


}TS_TIMEBASE_DATA;

/*******************************************************************************/
/* Private Variable Definition*/
/*******************************************************************************/
static TS_TIMEBASE_DATA	tbmData = {0};

uint32_t gOneShotCount = 0;
uint32_t gPeriodicCount = 0;

/*******************************************************************************/
/* Public Function Definition*/
/*******************************************************************************/

/*******************************************************************************/
/* Function name: TBM_Init()*/
/* Description	: Initialize TimeBase Module Data*/
/* Parameters	: N.A  */
/* Returns		: N.A*/
/* Remark		: N.A*/
/*******************************************************************************/
void TBM_Init(void)
{
    tbmData.T1msFlag = DF_CLEAR;
    tbmData.T10msFlag = DF_CLEAR;
    tbmData.T50msFlag = DF_CLEAR;
    tbmData.T100msFlag = DF_CLEAR;

	tbmData.T10msTimer = 10;
	tbmData.T50msTimer = 5;
    tbmData.T100msTimer = 2;
}

/*******************************************************************************/
/* Function name: TBM_Handler()*/
/* Description	: Handler TimeBase Module Data*/
/* Parameters	: N.A*/
/* Returns		: N.A*/
/* Remark		: N.A*/
/*******************************************************************************/
void TBM_Handler(void)
{

    //DebugP_log("TBM_Handler ...\r\n");
	/* Clear All Timer Base Flags */
	tbmData.T1msFlag = DF_CLEAR;
	tbmData.T10msFlag = DF_CLEAR;
	tbmData.T50msFlag = DF_CLEAR;
	tbmData.T100msFlag = DF_CLEAR;
	/* Clear WatchDog Timer*/
	//WDOG_Refresh(WDOG);

	/* Handle 50 ms */
	tbmData.T50msTimer--;
	if (tbmData.T50msTimer == DF_CLEAR)
	{
		tbmData.T50msFlag = DF_ON;
		/* Reset 50ms Timer*/
		tbmData.T50msTimer = 5;
		/* Handle 100 ms */
		tbmData.T100msTimer--;
		if (tbmData.T100msTimer == DF_CLEAR)
		{
			tbmData.T100msFlag = DF_ON;
			/* Reset 100ms Timer*/
			tbmData.T100msTimer = 2;
		}	
	}

}


DF_BOOL TBM_PollData(TE_TIMEBASE_TYPE inType)
{
    switch (inType)
    {  
		case TBM_10ms:
			return (tbmData.T10msFlag);
		case TBM_50ms:
			return (tbmData.T50msFlag);
		case TBM_100ms:
			return (tbmData.T100msFlag);
		default:
			return DF_OFF;
    }
	return DF_OFF;
}

/*******************************************************************************/
/* Function name: TBM_Delay(LS_U16 value)*/
/* Description	: Delay function.*/
/* Parameters	: LS_U16 value, timebase = 1 ms*/
/* Returns		: N.A*/
/* Remark		: N.A*/
/*******************************************************************************/
void TBM_Delay(DF_U16 value)/*timebase 10ms*/
{
    tbmData.DelayCount = DF_CLEAR;
    while (tbmData.DelayCount < value)
    {
		if ((tbmData.DelayCount%20) == 0)
		{
	//		WDOG_Refresh(WDOG);
		}
    }
}

/*******************************************************************************/
/* Interrupt Routine Definition*/
/*******************************************************************************/

volatile unsigned int SwTimer=0;
unsigned char PollingTask10ms=0;
unsigned char PollingTask100ms=0;
unsigned char PollingTask1000ms=0;

uint32_t gTimerCount = 0;
uint32_t gpioFlag_timer = 0;

void HHClockCallback(void *args)
{

    uint32_t *value = (uint32_t*)args;

    (*value)++; /* increment number of time's this callback is called */
    DebugP_log("value %d ...\r\n", (*value));
    SwTimer++;
    if(SwTimer>10000)
    {SwTimer=1;}

    if((SwTimer%10)==0)
    {PollingTask10ms=1;}

    if((SwTimer%100)==0)
    {PollingTask100ms=1;}

    if((SwTimer%1000)==0)
    {PollingTask1000ms=1;}


    //PRINTF("Timebase_Routine: %d\r\n", tbmData.T1msFlag);
    /* Handle 10 ms */
    tbmData.T10msTimer-- ;
    if (tbmData.T10msTimer == DF_CLEAR)
    {
        tbmData.T10msFlag = DF_ON;
        /* Reset 10ms Timer */
        tbmData.T10msTimer = 10;
    }
}