test.c

abstract rtos

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif 
#endif 



#include "sys/sys_pub.h"
#include "aos.h"







U32 eventTaskId;

AOS_ASSERTFILE();


#define MSG_TEST_COUNT 5

struct short_tst_msg_s
{
    U32 type;
    U8 info[20];
};

struct long_tst_msg_s
{
    U32 type;
    U8 info[400];
};

struct debug_cmd_msg_s
{
    U32 cmd;
    U32 para1;
    U32 para2;
    U32 para3;
};

TMR my_tmr[3]= {NULL,NULL,NULL};
#define TIMEOUT_LEN 1000

#define TM_CREATE_TASK  4
#define TM_SEND_EVENT    5

VOID eventProc();

U32  msgInit1( START_ORDER_E order )
{
    switch( order )
    {
        case STARTUP_INITIAL:       
            break;
            
        case STARTUP_LOAD_DATA:  
            break;
            
        case STARTUP_GO:               
        aos_timer_start(&my_tmr[0],MPE_TST1, TIMEOUT_LEN*4,     0, 0, AOS_TIMER_NO_LOOP);
        aos_timer_start(&my_tmr[1],MPE_TST1, TIMEOUT_LEN*2, 1, 0, AOS_TIMER_NO_LOOP);
        aos_timer_start(&my_tmr[2],MPE_TST1, TIMEOUT_LEN*2, 2, 0, AOS_TIMER_NO_LOOP);

        aos_timer_start(NULL,MPE_TST1, TIMEOUT_LEN*4,    TM_CREATE_TASK, 0, AOS_TIMER_NO_LOOP);
        
            break;

    }
return AOS_SUCC;
}
VOID msgProc1( MSG_S *msg, VOID*pvMsgBuf )
{
    struct long_tst_msg_s *pMsg = (struct long_tst_msg_s*)pvMsgBuf;
    struct debug_cmd_msg_s *pDebugMsg;
    TIMER_MSG_S *pTimerMsg;
    
    AOS_ASSERT(  NULL != msg && NULL != pvMsgBuf );

    aos_printf( MPE_TST1, "Recv Msg, srcProc=%d, srcMpe=%d, dstProc=%d,dstMpe=%d,msg_buf=0x%x, size=%d",
                         msg->srcProcessorId,msg->srcMpe,msg->dstProcessorId,msg->dstMpe,pvMsgBuf, msg->ulSize);
                         
    switch( msg->srcMpe )
    {
        case MPE_DEBUG:
            pDebugMsg = (struct debug_cmd_msg_s *)pvMsgBuf;
            
            switch( pDebugMsg->cmd )
            {
                case 0:
                    aos_printf( MPE_TST1, "to test 0" );
                    break;
                    
                case 1:
                    aos_printf( MPE_TST1, "to test 1" );
                    break;
                    
                case 2:
                    aos_printf( MPE_TST1, "to test 2" );
                    break;
                    
            }

            break;
            
        case MPE_TST2:
            if( 0 == pMsg->type )
            {
                aos_printf( MPE_TST1,"It is short test message" );
            }
            else if( 1 == pMsg->type )
            {
                aos_printf( MPE_TST1,"It is long test message" );
            }
            else
            {
                aos_printf( MPE_TST1,"unknown test message" );
            }
            
            break;

        case MPE_TST3:
            break;

        case MPE_TIMER:
            pTimerMsg = (TIMER_MSG_S*)pvMsgBuf;
            aos_printf( MPE_TST1, "Timeout message, name=%d, para=%d",pTimerMsg->ulTimerName,pTimerMsg->ulPara);
            switch( pTimerMsg->ulTimerName )
            {
                case 0:

                    break;
                    
                case 1:

                    break;
                    
                case 2:
                    break;

                case TM_CREATE_TASK:
                    if( AOS_SUCC != 
                        aos_task_create("_event", 0x2000, TASK_PRIO_NORMAL, AOS_TASK_NOPREEMPT, eventProc, (VOID*)NULL, &eventTaskId) )
                    {
                        aos_printf( MPE_TST1, "create event test task fail" );
                    }

                    aos_timer_start( NULL, MPE_TST1, TIMEOUT_LEN*10, TM_SEND_EVENT, 1, AOS_TIMER_NO_LOOP );
                    break;

                case TM_SEND_EVENT:

                        aos_printf( MPE_TST1, "send event =0x%x", pTimerMsg->ulPara );    
                        aos_event_post( eventTaskId, pTimerMsg->ulPara);
                         pTimerMsg->ulPara |= pTimerMsg->ulPara<<1;

						 if( pTimerMsg->ulPara )
						 {
						 }
                         
                    aos_timer_start( NULL, MPE_TST1, TIMEOUT_LEN*3, TM_SEND_EVENT, pTimerMsg->ulPara, AOS_TIMER_NO_LOOP );

                    break;

                    
                    
            }

			if( pTimerMsg->ulTimerName >2 )
			{
				break;
			}

                if( 0 == pTimerMsg->ulTimerName )
                {
                    aos_timer_start(&my_tmr[pTimerMsg->ulTimerName],MPE_TST1, TIMEOUT_LEN*4,  pTimerMsg->ulTimerName,++(pTimerMsg->ulPara), AOS_TIMER_NO_LOOP);
                }
                else if ( 1 == pTimerMsg->ulTimerName )
                {
                   aos_timer_start(&my_tmr[pTimerMsg->ulTimerName],MPE_TST1, TIMEOUT_LEN*2,  pTimerMsg->ulTimerName,++(pTimerMsg->ulPara), AOS_TIMER_NO_LOOP); 
                }
                else
                {
                   aos_timer_start(&my_tmr[pTimerMsg->ulTimerName],MPE_TST1, TIMEOUT_LEN*2,  pTimerMsg->ulTimerName,++(pTimerMsg->ulPara), AOS_TIMER_NO_LOOP); 
                }
                

            break;
    }

}

VOID eventProc()
{
    U32 event;
    if( AOS_SUCC == aos_event_wait((U32)-1, AOS_WAIT_ALL, 0, &event) )
    {
         aos_printf( MPE_TST1, "wait succ, recv =0x%x",event );
    }
    else
    {
         aos_printf( MPE_TST1, "wait fail, recv =0x%x",event );
    }

    if( AOS_SUCC == aos_event_wait((U32)-1, AOS_WAIT_ANY, 0, &event) )
    {
         aos_printf( MPE_TST1, "wait succ, recv =0x%x",event );
    }
    else
    {
         aos_printf( MPE_TST1, "wait fail, recv =0x%x",event );
    }
    
}

VOID StartTest( U32 cmd )
{
    struct debug_cmd_msg_s *pDebugMsg;
    MSG_S msg;

    pDebugMsg = (struct debug_cmd_msg_s *)aos_msg_alloc(MPE_DEBUG, sizeof(struct debug_cmd_msg_s));
    if( NULL == pDebugMsg )
    {
        aos_printf( MPE_DEBUG, "Start Test fail1" );
    }

    msg.srcProcessorId = LOCAL_PROCESSOR_ID;
    msg.srcMpe           = MPE_DEBUG;
    msg.dstProcessorId= LOCAL_PROCESSOR_ID;
    msg.dstMpe           = MPE_TST1;
    msg.msgPrio           = MSG_PRIO_NORMAL;
    msg.ulSize= sizeof( struct debug_cmd_msg_s);
    
    pDebugMsg->cmd = cmd;

    if( AOS_SUCC != aos_msg_send(& msg) )
    {
        aos_printf( MPE_DEBUG, "Start Test fail2" );
    }

}

#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif