tmrtsk.c

一个操作系统源代码 用于嵌入式设备 在Vc++环境下仿真 成功移植到多款处理器上

	
	if(timer -> flag != 0xface)
		return	TIMER_ERROR;
		
	if(timer -> state == TIMER_RUN) {
		/* Enter Critical Section */
		vDisableDispatch();
		
		for(t = Timers;t != NULL;tlast = t,t = t->next)
			if(t == timer)
				break;

		if(t == NULL)
		{
			/* Pessia 2002/4/4 : Fix serious bug !*/
			/* Leave Critical Section */
			vEnableDispatch();

			return	TIMER_ERROR;/* Should probably panic here */
		}
		

		/* Delete from active timer list */
		if(tlast != NULL)
			tlast->next = t->next;
		else
			Timers = t->next;
		
		/* Leave Critical Section */
		vEnableDispatch();
	}

	SysLfree((void*)timer);
	
	return		TIMER_OK;
	
}




static void DefaultTimerProc(struct timer *t)
{
	/* shit code!!! */
	MSG msg;
	msg.lparam = (DWORD)t; /* Timer's ID */
	msg.message = SM_TIMER;
	//system func by ppp
	//aim at task id
	SysSendMessage(t -> taskid, &msg);
}

STATUS SysSetDateTime( ASIX_DATE *date, ASIX_TIME *time )
{
	SetGlobalDate( date );
	SetGlobalTime( time );

	return		TIMER_OK;
}

STATUS SysReadDateTime( ASIX_DATE *date, ASIX_TIME *time )
{
	if( date == NULL || time == NULL )
		return TIMER_ERROR;

	ReadGlobalDate( date );
	ReadGlobalTime( time );
	
	return		TIMER_OK;
}

STATUS SysSetTime( ASIX_TIME *time )
{
	if( time == NULL )
		return TIMER_ERROR;

	SetGlobalTime( time );
	
	return TIMER_OK;
}

STATUS SysSetDate( ASIX_DATE *date )
{
	if( date == NULL )
		return TIMER_ERROR;

	SetGlobalDate( date );
	
	return TIMER_OK;
}
STATUS SysGetTime( ASIX_TIME *time )
{
	if( time == NULL )
		return TIMER_ERROR;

	ReadGlobalTime( time );
	
	return TIMER_OK;
}

STATUS SysGetDate( ASIX_DATE *date )
{
	if( date == NULL )
		return TIMER_ERROR;

	ReadGlobalDate( date );
	
	return TIMER_OK;
}

STATUS SysGetElapsedTime( ASIX_TIME *elapse, ASIX_TIME *start, ASIX_TIME *end )
{
	BYTE	mc = 0, hc = 0;

	if( elapse == NULL || start == NULL || end == NULL )
		return TIMER_ERROR;

	if( end->second < start->second )
	{
		mc = 1;
		elapse->second = end->second + 60 - start->second;
	}
	else
		elapse->second = end->second - start->second;

	if( end->minute < ( start->minute + mc ) )
	{
		hc = 1;
		elapse->minute = end->minute + 60 - start->minute - mc;
	}
	else
		elapse->minute = end->minute - start->minute - mc;
	
	if( end->hour < ( start->hour + hc ) )
		return TIMER_ERROR;
	else
		elapse->hour = end->hour - start->hour - hc;

	return TIMER_OK;
}

STATUS SysGetElapsedDays( DWORD *elapse, ASIX_DATE *start, ASIX_DATE *end )
{
	DWORD	start_days, end_days;

	if( elapse == NULL || start == NULL || end == NULL )
		return TIMER_ERROR;

	*elapse = 0;

	Date2Days( &start_days, start );
	Date2Days( &end_days, end );

	if( start_days > end_days )
		return TIMER_ERROR;

	*elapse = end_days - start_days;
	
	return TIMER_OK;
}

STATUS SysTimeElapse( ASIX_TIME *end, ASIX_TIME *start, ASIX_TIME *elapse )
{
	BYTE	mc = 0, hc = 0;

	if( elapse == NULL || start == NULL || end == NULL )
		return TIMER_ERROR;

	end->second = start->second + elapse->second;
	if( end->second >= 60 )
	{
		mc = 1;
		end->second -= 60;
	}

	end->minute = start->minute + elapse->minute + mc;
	if( end->minute >= 60 )
	{
		hc = 1;
		end->minute -= 60;
	}
	
	end->hour = start->hour + elapse->hour + hc;

	return TIMER_OK;
}

short SysCompareTime( ASIX_TIME *timL, ASIX_TIME *timR )
{
	if( timL->hour == timR->hour )
	{
		if( timL->minute == timR->minute )
		{
			if( timL->second == timR->second )
				return 0;
			else
				return ( (short)timL->second - (short) timR->second );
		}
		else
			return ( (short)timL->minute - (short) timR->minute );
	}
	else
		return ( (short)timL->hour - (short) timR->hour );
}

short SysCompareDate( ASIX_DATE *dateL, ASIX_DATE *dateR )
{
	if( dateL->year == dateR->year )
	{
		if( dateL->month == dateR->month )
		{
			if( dateL->day == dateR->day )
				return 0;
			else
				return ( (short)dateL->day - (short) dateR->day );
		}
		else
			return ( (short)dateL->month - (short) dateR->month );
	}
	else
		return ( (short)dateL->year - (short) dateR->year );
}

STATUS SysDateElapse( ASIX_DATE *end, ASIX_DATE *start, DWORD elapse )
{
	DWORD	start_days, end_days;

	if( start == NULL || end == NULL )
		return TIMER_ERROR;

	Date2Days( &start_days, start );
	end_days = start_days + elapse;
	Days2Date( end, end_days );

	return TIMER_OK;
}

STATUS Date2Days( DWORD *days, ASIX_DATE *date )
{
	DWORD	temp_day;
	WORD	leap_year;

	if( days == NULL || date == NULL )
		return TIMER_ERROR;

	if( VerifyDate( date ) != TIMER_OK )
		return TIMER_ERROR;

	temp_day = date->day;
	temp_day += AccumMonthDays[ date->month - 1 ];
	temp_day += ( date->year - 1 ) * 365;
	
	if( CaculateLeapYear( &leap_year, date->year ) )
	{
		// 闰年
		if( date->month < 3 )
		{
			leap_year--;
		}
	}
	
	temp_day += leap_year;

	*days = temp_day;

	return TIMER_OK;	
}

STATUS Days2Date( ASIX_DATE *date, DWORD days )
{
	WORD	year, month = 0, day = 0;
	WORD	leap_year;
	WORD	temp_day;
	BYTE	is_leap_year, is_leap_day = 0;
	BYTE	i;

	if( date == NULL )
		return TIMER_ERROR;
	
	// 年份
	year = (WORD)( days *1459/532900 + 1 );		// (days-days/(365*4))/365+1
	temp_day = (WORD)( days - ( year - 1 )*365 );

	is_leap_year = CaculateLeapYear( &leap_year, year );

	if( leap_year > temp_day )
	{
		year--;
		temp_day += ( is_leap_year ? 366 : 365 );
	}	
	temp_day -= leap_year;
	if( temp_day > 365 )
	{
		temp_day -= 365;
		year++;
		is_leap_year = IS_LEAP_YEAR( year );
		temp_day -= is_leap_year;
	}
//	else if( temp_day > 366 && is_leap_year )
//	{
//		temp_day -= 366;
//		year++;
//		is_leap_year = IS_LEAP_YEAR( year );
//	}

	if( is_leap_year )	// 闰年
	{
		if( temp_day < AccumMonthDays[2] )	// 未过闰月
			temp_day++;
		else if( temp_day == AccumMonthDays[2] )	// 闰日
			is_leap_day = 1;
	}

	// 月份和日子
	for( i = 0; i < 12; i++ )
	{
		if( MonthDay[i] < temp_day )
			temp_day -= MonthDay[i];
		else
		{
			month = i + 1;			
			day = temp_day;
			if( is_leap_day )	// 闰日
				day++;
			break;
		}
	}

//	if( i == 12 )
//		printf( "Error Date!\n" );

	date->year = year;
	date->month = month;
	date->day = day;

	return TIMER_OK;
}

// 计算闰年天数
BYTE CaculateLeapYear( WORD *leapYear, WORD curYear )
{
	WORD	flag1 = 0, flag2 = 0, flag3 = 0;
	WORD	temp_year, leap_year;
	BYTE	is_leap_year;

	leap_year = curYear / 400 * 97;
	temp_year = curYear % 400;
	flag1 = temp_year;
	if( flag1 )
	{
		leap_year += temp_year / 100 * 24;
		temp_year %= 100;
		flag2 = temp_year;
		if( flag2 )
		{
			leap_year += temp_year / 4;
			flag3 = temp_year % 4;
		}
	}

	*leapYear = leap_year;

	is_leap_year = ( flag3 == 0 && ( flag2 != 0 || flag1 == 0 ) );
//	if( is_leap_year != IS_LEAP_YEAR(curYear) )
//		printf( "Caculate Leap Year Error!\n" );
	
	return is_leap_year;
}

STATUS VerifyDate( ASIX_DATE *date )
{
	if( date == NULL )
		return TIMER_ERROR;

	if( date->year == 0 )
		return TIMER_ERROR;

	if( date->month == 0 || date->month > 12 )
		return TIMER_ERROR;

	if( date->month == 2 && IS_LEAP_YEAR(date->year) )
	{
		if( date->day > MonthDay[date->month-1]+1 )
			return TIMER_ERROR;
	}
	else
	{
		if( date->day > MonthDay[date->month-1] )
			return TIMER_ERROR;
	}

	return TIMER_OK;
}