os_obj.c

引入事件驱动观念的抢占式多任务微型实时内核——MicroStar的设计与实现；提出基于事件的优先级这一新概念。

/**************** os_obj.c**************/
/*            MacroStar 1.0a            */
/*          Zhengyuquan,2003.7,Beijing  */
/*           All rights reserved        */
/****************************************/
#include "mStar.h"

extern HTIMER STDCALL _FAR os_SetTimerIn(uchar timerId, uint_16 elapse, TIMERPROC lpTimerFunc);
uint_16 os_objectState=0xFFFF;
OBJECT 	os_objects[MAX_OBJECT_NUM];		// 16*4=64

extern volatile uint_16 os_timerState;
extern TIMER  	os_timers[ ];

/*
************************************************************
*
*
*
************************************************************
*/
HOBJECT STDCALL _FAR os_CreateObject(uchar num, uchar type )
{
	HOBJECT  hObject = NULL_HOBJECT;
    uchar    index;
	LOCK_INT( );
	if( os_objectState )
    {
		if( HIGHBYTE(os_objectState) )
		{
			index = os_fastTable[ HIGHBYTE(os_objectState) ];
		}
		else
		{
			index = os_fastTable[ LOWBYTE(os_objectState) ] | 8;
		}
		os_objectState ^= os_maskTable[ index ];

		hObject = &os_objects[ index ];
		hObject->waiter = 0;
		hObject->num  = num;
		hObject->type = type;
	}
	UNLOCK_INT( );
	return hObject;
}

/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_SetEvent( HEVENT hEvent,uchar mode)
{
	os_ASSERT( (hEvent!= NULL_HEVENT)&&(hEvent->type == EVENT_OBJECT),SET_INVALID_EVENT );
    os_ASSERT( (mode==AUTO_RESET) || (mode==HANDLE_RESET),SET_EVENT_MODE);
	os_slpState |= hEvent->waiter;
	hEvent->waiter = 0;
	hEvent->num = mode;
	os_SetSwitchFlag( );
}

/*
************************************************************
*
*
*
************************************************************
*/
void  STDCALL _FAR os_ResetEvent( HEVENT hEvent)
{
	os_ASSERT( (hEvent!= NULL_HEVENT)&&(hEvent->type == EVENT_OBJECT),RESET_INVALID_EVENT );
	hEvent->num =0;
}

/*
************************************************************
*
*
*
************************************************************
*/
BOOL STDCALL _FAR os_RequireObject(HOBJECT hObject)
{
	BOOL ret = os_false;
	LOCK_INT( );
	if( hObject->num)
	{
		if(hObject->type == SEMAPHORE_OBJECT)hObject->num--;
		ret = os_true;
	}
	UNLOCK_INT( );
	return ret;
}

/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_WaitObject( HOBJECT hObject)
{
	LOCK_INT( );
	if( hObject->num )
	{
		if(hObject->type == SEMAPHORE_OBJECT )hObject->num--;
		UNLOCK_INT( );
	}
	else
	{
		hObject->waiter |= os_curPrioMask;
		os_slpState     ^= os_curPrioMask;
		UNLOCK_INT( );
		os_Schedule( );
	}
}

/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_ReleaseSemaphore(HSEMAPHORE hSemaphore)
{
	uint_16 temp;
    uchar   who;

	os_ASSERT( (hSemaphore != NULL_HSEMAPHORE)&&hSemaphore->type == SEMAPHORE_OBJECT,
		RELE_INVALID_SEMAPHORE);

	LOCK_INT( );
	if( !hSemaphore->waiter )
	{
		hSemaphore->num++;
		UNLOCK_INT( );
		return;
	}

    ENTER_CRITICAL_SEG( );
	UNLOCK_INT( );

	if( (temp = hSemaphore->waiter&os_rdyhState)  )
	{
		if( temp > (os_curPrioMask&os_rdyhState) )
			os_SetSwitchFlag( );

	}
	else
	{
		if( (temp = (hSemaphore->waiter & os_rdyState)) > os_curPrioMask)
			os_SetSwitchFlag( );
    }
	who = os_fastTable[ HIGHBYTE(temp) ];
	if( who == 0xFF )
		who = os_fastTable[ temp ] + 8;

    os_ASSERT( !(os_prioState&os_maskTable[who]) ,RELE_SEMA_TO_NULL);
    os_slpState |= os_maskTable[who];
	hSemaphore->waiter ^= os_maskTable[who];

	LEAVE_CRITICAL_SEG( );
}

/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_DeleteObject( HOBJECT hObject)
{
	ENTER_CRITICAL_SEG( );

	os_ASSERT( hObject!=NULL_OBJECT,DEL_NULL_OBJECT );
    os_WARNING( !hObject->waiter,DEL_WAITING_OBJECT );

	os_objectState |= os_maskTable[((int)(hObject-os_objects))];

	os_slpState |= hObject->waiter;/*robust code*/
	LEAVE_CRITICAL_SEG( );
}

/*
************************************************************
*
*
*
************************************************************
*/
uchar STDCALL _FAR os_WaitObjectTimeOut( HOBJECT hObject,uint_16 elapse)
{
	HTIMER hTimer;

	os_ASSERT( hObject != NULL_OBJECT,WAIT_INVALID_OBJECT);

	LOCK_INT( );
	if( hObject->num )
	{
		if(hObject->type == SEMAPHORE_OBJECT )hObject->num--;
		UNLOCK_INT( );
		return WAIT_SUCCESS;
	}
	else
	{
		LOCK_SCHEDULE( );
		UNLOCK_INT( );

	   if( ( hTimer = os_SetTimerIn(SLEEP_ID,elapse,0) ) == NULL_TIMER )
		{
			UNLOCK_SCHEDULE( );
			os_Schedule( );
			return NOT_ENOUGH_TIMER;
		}
        else
		{
			hObject->waiter |= os_curPrioMask;
			os_slpState ^= os_curPrioMask;
  		    UNLOCK_SCHEDULE( );

			os_Schedule( );

			if( hObject->waiter & os_curPrioMask )
			{
				hObject->waiter ^= os_curPrioMask;
				return WAIT_TIME_OUT;
			}
			else
			{
				if(os_timers[hTimer].taskId == os_GetCurrentTaskId() )
					os_timerState |= os_maskTable[ hTimer ];
				return WAIT_SUCCESS;
			}
		}
	}
}


#ifdef _DEBUG
/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_WaitEvent(HEVENT hEvent)
{
	os_ASSERT( (hEvent!= NULL_HEVENT)&&(hEvent->type == EVENT_OBJECT),WAIT_INVALID_EVENT );
    os_WaitObject( (HOBJECT)hEvent );
}

/*
************************************************************
*
*
*
************************************************************
*/
void STDCALL _FAR os_WaitSemaphore(HSEMAPHORE hSemaphore)
{
	os_ASSERT( (hSemaphore!= NULL_HSEMAPHORE)&&(hSemaphore->type == SEMAPHORE_OBJECT),
		WAIT_INVALID_SEMAPHORE);
	os_WaitObject( (HSEMAPHORE)hSemaphore );
}

/*
************************************************************
*
*
*
************************************************************
*/
BOOL STDCALL _FAR os_RequireEvent( HEVENT hEvent)
{
	os_ASSERT( (hEvent!=NULL_OBJECT) && (hEvent->type==EVENT_OBJECT),
		REQ_INVALID_EVENT);
	return os_RequireObject(hEvent);
}

/*
************************************************************
*
*
*
************************************************************
*/
BOOL STDCALL _FAR os_RequireSemaphore( HOBJECT hObject)
{
	os_ASSERT( (hObject!=NULL_OBJECT) && (hObject->type==SEMAPHORE_OBJECT),
		REQ_INVALID_SEMAPHORE);
	return os_RequireObject(hObject);
}

#endif