event.c

minitos是一个实时的嵌入式操作系统

//#define VC_dEVENT


#include <stdio.h>
#include "minitosdef.h"
#include "extdefine.h"

#define N_SYSEVENT 20
#define EVENT_NO_MALLOC
#define MO_AND  0x01
#define MO_OR   0x02

struct Event
{
    int WaitEventNum;       //挂起的任务数
    int CurrentEvent;           //已被设置的事件
    //struct SuspendAtEvent * ptrSuspendTaskHead;
    PROC * ptrSuspendTaskHead;  //挂起的进程链
};
typedef struct Event EVENT;

/*
struct SuspendAtEvent
{
    int WaitEvent;
    int ReceiveEvent;
    PROC *ptrSuspendTask;
    struct SuspendAtEvent *next;
};

typedef struct SuspendAtEvent SUSPEND_AT_EVENT;
*/
#ifdef  EVENT_NO_MALLOC
    EVENT SysEvent[N_SYSEVENT];
    int g_SysEventUsed=0;
#endif

EVENT * CreateEvent(EVENT * pEvent)
{
    lock_int();

    if(pEvent==NULL)
    {
#ifdef  EVENT_NO_MALLOC        
        SysEvent[g_SysEventUsed].ptrSuspendTaskHead=NULL;
		SysEvent[g_SysEventUsed].WaitEventNum=0;
		g_SysEventUsed++;
		unlock_int();
		return &(SysEvent[g_SysEventUsed-1]);    
#else

#endif		
    }
//
    pEvent->ptrSuspendTaskHead=NULL;
    pEvent->WaitEventNum=0;
    unlock_int();
    return pEvent;
}

int GetEvent(EVENT *pEvent,int WaitEvent,int * ptrReceiveEvent,int AndOr,int SuspendOrNo)
{
    int tmp;
    lock_int();
    if(AndOr==MO_AND)
    {
            //已经存在的事件和要等待的事件比较
        tmp=pEvent->CurrentEvent & WaitEvent;
        if(tmp==WaitEvent)
        {
                //事件已经存在直接返回
             * ptrReceiveEvent=pEvent->CurrentEvent;
             unlock_int();
             return 0;    
        }
    }else if(AndOr==MO_OR)
    {
        //只要满足其中一个事件就返回
        tmp=pEvent->CurrentEvent & (~WaitEvent);
        if(tmp)
        {
            * ptrReceiveEvent=pEvent->CurrentEvent;
            unlock_int();
             return 0;
        }
    }else
    {
        //错误的参数
        unlock_int();
        return -1;
    }
    // Current event no exist,suspend this task?
    if(SuspendOrNo)
    {
        pEvent->WaitEventNum++;
        AddLinkToProcLastPos(pEvent->ptrSuspendTaskHead,ptrCurrProc);
        if(AndOr==MO_AND)
            ptrCurrProc->flags |= MO_AND;
        else
            ptrCurrProc->flags |= MO_OR;
            
            //设置等待的事件
        ptrCurrProc->WaitEvent=WaitEvent;
        ptrCurrProc->status|=0x20;  //set status bit mean blocking for waiting event
        unready(ptrCurrProc); //bug????
        sched();
        lock_int();
        
        ptrCurrProc->status &= ~0x20; 
        pEvent->WaitEventNum--;
        if(AndOr==MO_AND)
            ptrCurrProc->flags &= ~MO_AND;
        else
            ptrCurrProc->flags &= ~MO_OR;
            
                //事件已经存在直接返回
        * ptrReceiveEvent=ptrCurrProc->ReceiveEvent;
        unlock_int();
        return 0;        
    
    }else
    {
        //不挂起，直接返回
        unlock_int();
        return -2;
     }


}

int SetEvent(EVENT *pEvent,int EventFlags,int AndOr)
{
    int tmp;
    PROC *pProc;
    lock_int();
    if(pEvent==NULL)
    {
        unlock_int();
        return -1;        
    }

    if(AndOr==MO_AND)
    {
        pEvent->CurrentEvent &= EventFlags;
    }else
    {
        pEvent->CurrentEvent |= EventFlags;
    }
    if(pEvent->ptrSuspendTaskHead)
    {    //存在挂起的任务
        do
        {
            pProc=pEvent->ptrSuspendTaskHead;
            if(pProc->flags & MO_AND )
            {   //and mode
                tmp=pEvent->CurrentEvent & pProc->WaitEvent ;
                if(tmp==pProc->WaitEvent)
                {
                    goto lb_SetEvent;
                }
                
            }else
            {   //or mode
                tmp=pEvent->CurrentEvent & (~pProc->WaitEvent);
                if(tmp)
                {
                   goto lb_SetEvent;
                    
                }
            }
            continue;
lb_SetEvent:            
                    //事件已经收到，设置ReceiveEvent
                    pProc->ReceiveEvent=pEvent->CurrentEvent;
                    pProc->status &= ~0x20; 
                    if(AndOr==MO_AND)
                        pProc->flags &= ~MO_AND;
                    else
                        pProc->flags &= ~MO_OR;
                    ready(pProc);
                    RemoveProcFromProcLink(pEvent->ptrSuspendTaskHead,pProc);                                        
            
        }while(pProc->ptrNextProc!=NULL);
        //全部完成，
        sched();
    }
    //不存在挂起的任务，返回
    
    unlock_int();
    return 0;
}



#ifdef VC_dEVENT
#include "proctbl.h"
void lock_int(void){};
void unlock_int(void){};
void switch_task(void){};
void SendOneChar(int i,char a){i=i;a=a;};
#endif


#ifdef VC_dEVENT

void main(void)
{
	
}

#endif