user.c

一个多任务实时操作系统

#include "VisbyDevice.h"
#include "VisbyKernelDef.h"
#include "VisbyISR.h"
#include "VisbyCPU.h"
#include "LCD\lcd.h"

extern void SWI_Handler(void);
extern void TICK_Handler(void);
extern volatile bool Visby_Started;
extern volatile uint Visby_Critical;
extern volatile ullong Visby_Tick;
extern Visby_Task *pVisby_CurrTask;
extern LPFUNC pVisby_IntHand[];
extern Visby_Device	pVisby_Device[];
extern BOOL Visby_Resouce[];

/*/////////////////////////消息函数/////////////////////////////
***************************************************************/
//提交完消息，继续运行
bool VB_SendMsg(VB_HTASK pdestTask, uint msgType, void *pdetail)
{
	Visby_Msg *pNewMsg;
	pNewMsg = (Visby_Msg *)heapalloc(sizeof(Visby_Msg));
	if(pNewMsg == NULL)
		return false;
	pNewMsg->Type = msgType;
	pNewMsg->pDetail = pdetail;
	pNewMsg->pNext = NULL;
	Visby_KReqSendMsg((Visby_Task *)pdestTask, pNewMsg);
	return true;
}

void VB_WaitMsg(VB_HTASK hTask, uint msgType)
{
	Visby_KReqWaiTask( (Visby_Task *)hTask, msgType );
}

//提交完消息，如有必要，立即进入任务调度
void VB_UrgentMsg(VB_HTASK pdestTask, uint msgType, void *pdetail)
{
	Visby_Msg *pNewMsg;
	pNewMsg = (Visby_Msg *)heapalloc(sizeof(Visby_Msg));
	if(pNewMsg == NULL)
		return;
	pNewMsg->Type = msgType;
	pNewMsg->pDetail = pdetail;
	pNewMsg->pNext = NULL;
	Visby_KReqUrgtMsg((Visby_Task *)pdestTask, pNewMsg);
}

VB_HMSG VB_DequeueMsg()
{
	Visby_Msg *pMsg = NULL;
	VB_ENCRIT;
	if(pVisby_CurrTask->pHeadMsg != NULL)
	{
		pMsg = pVisby_CurrTask->pHeadMsg;
		pVisby_CurrTask->pHeadMsg = pMsg->pNext;
		if(pMsg == pVisby_CurrTask->pTailMsg)
		{
			pVisby_CurrTask->pTailMsg = NULL;
		}
	}
	VB_DECRIT;
	return (VB_HMSG)pMsg;
}

void VB_DestroyMsg(VB_HMSG pMsg)
{
	if( pMsg )
		heapfree((void *)pMsg);
}


/*/////////////////////////任务函数/////////////////////////////
***************************************************************/
VB_HTASK VB_CreateTask(void (*pentry)(void), byte priority, uint stackSize)
{
	Visby_Msg *pMsg;
	Visby_Task *pTask;
	if(pentry == NULL || priority < PRIO_REAL || priority > PRIO_LOW || stackSize < 1)
	{
		return NULL;
	}
	if(Visby_Started)
	{
		Visby_KReqNewTask(pentry, priority, stackSize, 0x00000010);
		pMsg = (Visby_Msg *)VB_DequeueMsg();
		pTask = (Visby_Task *)(pMsg->pDetail); 
		heapfree((void *)pMsg);
	}
	else
	{
		pTask = Visby_KCreateTask(pentry, priority, stackSize, 0x00000010);
		Visby_KAddTask(pTask);
	}
	return (VB_HTASK)pTask;
}

void VB_DeleteTask(VB_HTASK ptask)
{
	Visby_KReqDelTask((Visby_Task *)ptask);
}

void VB_SuspendTask(VB_HTASK ptask)
{
	Visby_KReqSusTask((Visby_Task *)ptask);
}

void VB_SleepTask(VB_HTASK ptask, uint tick)
{
	if( tick )
		Visby_KReqSlpTask((Visby_Task *)ptask, tick);
}

void VB_ResumeTask(VB_HTASK ptask)
{
	Visby_KReqRsmTask((Visby_Task *)ptask);
}

void VB_ChangePrio(VB_HTASK ptask, byte newPrio)
{
	if(newPrio >= PRIO_REAL && newPrio <= PRIO_LOW)
	{
		Visby_KReqChgPrio((Visby_Task *)ptask, newPrio);
	}
}


/*/////////////////////中断管理函数/////////////////////////////
***************************************************************/
VB_HISR VB_InstallISR(VB_HISR isr, int index)
{
	VB_HISR old;
	if( index < VB_ISR_EINT0 || index > VB_ISR_ADC )
		return 0xFFFFFFFF;
	old = (VB_HISR)(pVisby_IntHand[index - VB_ISR_EINT0]);
	pVisby_IntHand[index - VB_ISR_EINT0] = (LPFUNC)isr;
	return old;
}

//请求开关中断
BOOL VB_SetISREnable(int index, BOOL enable)
{
	if( index < VB_ISR_EINT0 || index > VB_ISR_ADC )
		return FALSE;
	if( pVisby_IntHand[index - VB_ISR_EINT0] == NULL )
		return FALSE;
	
	switch( index )
	{
#if (VB_ISR_ADC != 0)
	case VB_ISR_ADC:
		CLR_IRQ(BIT_ADC);
		(enable) ? UNMK_INT(BIT_ADC) : MASK_INT(BIT_ADC	); 
		break;
#endif
#if (VB_ISR_RTC != 0)
	case VB_ISR_RTC: 
		CLR_IRQ(BIT_RTC);
		(enable) ? UNMK_INT(BIT_RTC) : MASK_INT(BIT_RTC);
		break;
#endif
#if (VB_ISR_UTXD1 != 0)
	case VB_ISR_UTXD1: 
		CLR_IRQ(BIT_UTXD1);
		(enable) ? UNMK_INT(BIT_UTXD1) : MASK_INT(BIT_UTXD1); 
		break;
#endif
#if (VB_ISR_UTXD0 != 0)
	case VB_ISR_UTXD0: 
		CLR_IRQ(BIT_UTXD0);
		(enable) ? UNMK_INT(BIT_UTXD0) : MASK_INT(BIT_UTXD0);
		break;
#endif
#if (VB_ISR_SIO != 0)
	case VB_ISR_SIO: 
		CLR_IRQ(BIT_SIO);
		(enable) ? UNMK_INT(BIT_SIO) : MASK_INT(BIT_SIO);
		break;
#endif
#if (VB_ISR_IIC != 0)
	case VB_ISR_IIC: 
		CLR_IRQ(BIT_IIC);
		(enable) ? UNMK_INT(BIT_IIC) : MASK_INT(BIT_IIC);
		break;
#endif
#if (VB_ISR_URXD1 != 0)
	case VB_ISR_URXD1: 
		CLR_IRQ(BIT_URXD1);
		(enable) ? UNMK_INT(BIT_URXD1) : MASK_INT(BIT_URXD1);
		break;
#endif
#if (VB_ISR_URXD0 != 0)
	case VB_ISR_URXD0: 
		CLR_IRQ(BIT_URXD0);
		(enable) ? UNMK_INT(BIT_URXD0) : MASK_INT(BIT_URXD0);
		break;
#endif
#if (VB_ISR_TIMER5 != 0)
	case VB_ISR_TIMER5: 
		CLR_IRQ(BIT_TIMER5);
		(enable) ? UNMK_INT(BIT_TIMER5) : MASK_INT(BIT_TIMER5); 
		break;
#endif
#if (VB_ISR_TIMER4 != 0)
	case VB_ISR_TIMER4: 
		CLR_IRQ(BIT_TIMER4);
		(enable) ? UNMK_INT(BIT_TIMER4) : MASK_INT(BIT_TIMER4); 
		break;
#endif
#if (VB_ISR_TIMER3 != 0)
	case VB_ISR_TIMER3:
		CLR_IRQ(BIT_TIMER3);
		(enable) ? UNMK_INT(BIT_TIMER3) : MASK_INT(BIT_TIMER3); 
		break;
#endif
#if (VB_ISR_TIMER2 != 0)
	case VB_ISR_TIMER2: 
		CLR_IRQ(BIT_TIMER2);
		(enable) ? UNMK_INT(BIT_TIMER2) : MASK_INT(BIT_TIMER2); 
		break;
#endif
#if (VB_ISR_TIMER1 != 0)
	case VB_ISR_TIMER1: 
		CLR_IRQ(BIT_TIMER1);
		(enable) ? UNMK_INT(BIT_TIMER1) : MASK_INT(BIT_TIMER1); 
		break;
#endif
#if (VB_ISR_TIMER0 != 0)
	case VB_ISR_TIMER0: 
		CLR_IRQ(BIT_TIMER0);
		(enable) ? UNMK_INT(BIT_TIMER0) : MASK_INT(BIT_TIMER0); 
		break;
#endif
#if (VB_ISR_USER01 != 0)
	case VB_ISR_USER01: 
		CLR_IRQ(BIT_UERR01); 
		(enable) ? UNMK_INT(BIT_UERR01) : MASK_INT(BIT_UERR01);
		break;
#endif
#if (VB_ISR_WDT != 0)
	case VB_ISR_WDT: 
		CLR_IRQ(BIT_WDT);
		(enable) ? UNMK_INT(BIT_WDT) : MASK_INT(BIT_WDT); 
		break;
#endif
#if (VB_ISR_INTBDMA1 != 0)
	case VB_ISR_INTBDMA1: 
		CLR_IRQ(BIT_BDMA1);
		(enable) ? UNMK_INT(BIT_BDMA1) : MASK_INT(BIT_BDMA1); 
		break;
#endif
#if (VB_ISR_INTBDMA0 != 0)
	case VB_ISR_INTBDMA0: 
		CLR_IRQ(BIT_BDMA0);
		(enable) ? UNMK_INT(BIT_BDMA0) : MASK_INT(BIT_BDMA0); 
		break;
#endif
#if (VB_ISR_INTZDMA1 != 0)
	case VB_ISR_INTZDMA1: 
		CLR_IRQ(BIT_ZDMA1);
		(enable) ? UNMK_INT(BIT_ZDMA1) : MASK_INT(BIT_ZDMA1); 
		break;
#endif
#if (VB_ISR_INTZDMA0 != 0)
	case VB_ISR_INTZDMA0: 
		CLR_IRQ(BIT_ZDMA0);
		(enable) ? UNMK_INT(BIT_ZDMA0) : MASK_INT(BIT_ZDMA0); 
		break;
#endif
#if (VB_ISR_INTTICK != 0)
	case VB_ISR_INTTICK: 
		CLR_IRQ(BIT_TICK);
		(enable) ? UNMK_INT(BIT_TICK) : MASK_INT(BIT_TICK); 
		break;
#endif
#if (VB_ISR_EINT4567 != 0)
	case VB_ISR_EINT4567: 
		CLR_IRQ(BIT_EINT4567);
		(enable) ? UNMK_INT(BIT_EINT4567) : MASK_INT(BIT_EINT4567);
		break;
#endif
#if (VB_ISR_EINT3 != 0)
	case VB_ISR_EINT3: 
		CLR_IRQ(BIT_EINT3);
		(enable) ? UNMK_INT(BIT_EINT3) : MASK_INT(BIT_EINT3);