시간 트리거 스케줄 러

/********************************************************************************/
/******************************    ******************************************/
typedef tWord unsigned int;
typedef tByte unsigned char;

//    ，   DATA ，      
//          7   
typedef data struct
{
	//       ，     void(void)  
	void (code *pTask)(void);

	//  （  ）     （   ）  
	tWord Delay;
	
	//         （  ）
	tWord Period;

	//        （    ） 1
	tByte RunMe;
	
}sTask;

#define  SCH_MAX_TASKS (3)

//        
sTask SCH_tasks_G[SCH_MAX_TASKS];


/***************************     *******************************************/
/********************************************************************************/
/*SCH_Init_T2()。        ，                       */
/*  ,                ,            1ms             */
/********************************************************************************/
void SCH_Init_T2(void)
{
	TBYTE i;

	for (i = 0; i < SCH_MAX_TASKS; i++)
	{
		SCH_Delete_Task(i);
	}

	//        ，SCH_Delete_Task         （         ）
	Error_Code_G = 0;

	//     2，    、16     。
	//     12MHz，   2    1us，      2   1ms
	//  1000      ，    65536-1000 = 64536 = 0xFC18
	//   ....

}


/***************************    *********************************************/
/********************************************************************************/
/*SCH_Updata()            ，                     */
/*        2    ，                                            */
/********************************************************************************/
void SCH_Update(void) interrupt INTERRUPT_Timer_2_Overflow
{
	tByte Index;
	TF2 = 0;//      

	//       "  "（    ）
	for (Index = 0; Index < SCH_MAX_TASKS; Index++)
	{
		//         
		if (SCH_tasks_G[Index].pTask)
		{
			if (SCH_tasks_G[Index].Delay == 0)
			{
				//      
				SCH_tasks_G[Index].RunMe += 1;//RunMe   1

				if (SCH_tasks_G[Index].Period)
				{
					//            
					SCH_tasks_G[Index].Delay = SCH_tasks_G[Index].Period;
				}
				else
				{
					//       ，   1
					SCH_tasks_G[Index].Delay -= 1;
				}

			}
		}
	}
}


/***************************      *****************************************/
/********************************************************************************/
/*SCH_Add_Task()   （  ）                               */
/*  ：pFunction         									            */
/*      Delay           ，   0                              */
/*      Period           ，   0                            */
/********************************************************************************/
tByte SCH_Add_Task(void (code * pFunciton)[], const tWord Delay, const tWord PERIDO)
{
	tByte Index = 0;

	//            （     ）
	while ((SCH_tasks_G[Index].pTask != 0) && (Index < SCH_MAX_TASKS))
	{
		Index++;
	}

	//           ？
	if (Index == SCH_MAX_TASKS)
	{
		//      
		//        
		Error_code_G = ERROR_SCH_TOO_MANY_TASKS;

		//        
		return SCH_MAX_TASKS;

	}

	//                 
	SCH_tasks_G[Index].pTask  = pFunciton;
	SCH_tasks_G[Index].Delay  = Delay;
	SCH_tasks_G[Index].Period = PERIDO;
	SCH_tasks_G[Index].RunMe  = 0;
	return Index;//       （      ）
}



/***************************"  "    ***************************************/
/********************************************************************************/
/*SCH_Dispatch_Task()  "    "，   （       ）SCH_Dispatch_Task()*/
/*    。          （  ）         					            */
/********************************************************************************/
void SCH_Dispatch_Task(void)
{
	tByte Index;

	//         （       ）
	for (Index = 0; Index < SCH_MAX_TASKS; Index++)
	{
		if (SCH_tasks_G[Index].RunMe > 0)
		{
			*SCH_tasks_G[Index].pTask();    //    
			SCH_tasks_G[Index].RunMe -= 1;  //  /  RunMe  

			//             ，       ，         
			if (SCH_tasks_G[Index].Period == 0)
			{
				SCH_Delete_Task(Index);
			}
		}

	}

	//      
	SCH_Report_Status();

	//           
	SCH_Go_To_Sleep();

}



/***************************      *****************************************/
/********************************************************************************/
/*SCH_Delete_Task()                                                       */
/********************************************************************************/
bit SCH_Delete_Task(const tByte TASK_INDEX)
{
 	bit Return_code;

	if (SCH_tasks_G[Index].pTask == 0)
	{
		//      
		//        
		Error_code_G = ERROR_SCH_CANNOT_DELETE_TASK;
		Return_code = RETURN_ERROR;
	}
	else
	{
		Return_code = RETURN_NORMAL;
	}


	SCH_tasks_G[Index].pTask  0;
	SCH_tasks_G[Index].Delay  = 0;
	SCH_tasks_G[Index].Period = 0;
	SCH_tasks_G[Index].RunMe  = 0;
	return Return_code;
}



/***************************      *****************************************/
/********************************************************************************/
/*          ，                                   */
/********************************************************************************/
void SCH_Go_To_Sleep()
{
	PCON |= 0X01; //      
}


/***************************      *****************************************/
/********************************************************************************/
/*          ，                      */
/********************************************************************************/
void SCH_Report_Status(void)
{
#if SCH_REPORT_ERRORS
	//           
	//        
	//   

#endif
}


/***************************    *********************************************/
/********************************************************************************/
/*            ，                                      */
/********************************************************************************/
void SCH_Start(void)
{
	EA = 1;
}




int main(int argc, char* argv[])
{
	//     
	SCH_Init_T2();

	// Flash_LED     
	LED_Flash_Init();

	//  FLash LED  （1000ms ，1000ms ）
	//       （1ms  ）
    SCH_Add_Task(LED_Flash_Update, 0, 1000);

	//     
	SCH_Start();

	while (1)
	{
		SCH_Dispatch_Task();
	}

}