event_m04_c2.c

sircs decoder, for amplifier.. this is to decode

/****************************************************************************************************/
/* $Header  : 																					  	
/* AUTHOR 	: TC PUI																		  		
/* FILE NAME: EVENT.C																		  		
/* PURPOSE	: EVENT CONTROL												 				 		
/* MODEL	: 2004 CIS 2-CH AMP 										  						
/* Copyright (c) 2004 Sony Corporation All Rights Reserved					  						
/****************************************************************************************************/
#define _EVENT_C

#include "_main_M04_C2.h"
   
/****************************************************************************************************/
/* local define                                                                                     
/****************************************************************************************************/ 

/****************************************************************************************************/
/* FUNCTION     :   EventAvailable                                                                  
/* PURPOSE      :   Event Available                                                                 
/* INPUT        :   None                                                                            
/* RETURN VALUE :   None                                                                            
/****************************************************************************************************/
unsigned int EventAvailable(unsigned int stts)
{
    unsigned int rslt = EVENT_TRUE;
    
	switch(stts) {
		case EVCHK_NULL: rslt = EVENT_NULL;	break;
		case EVCHK_TRUE: break;
		case EVCHK_EROR: rslt = EVENT_EROR;	break;
		case EVCHK_SPOF: 
						 if (PowWork.Prtc == ON){
						 	break;
						 }else if ( AU_DET.IRInput.flag == CLEAR ) {			
							rslt = EVENT_NULL;
						 }
						 break;
		case EVCHK_IDIN: if (IDSwitch.Learn == ON){
							 rslt = EVENT_NULL;
						 }
					     break;
		case EVCHK_SIRO: if (IDSwitch.Test == OFF){
							rslt = EVENT_NULL;
						 }
				      	 break;
		case EVCHK_SIRI: if (IDSwitch.Learn == ON){
							 rslt = EVENT_NULL;
						 }
						 break;	
		default :	     break;				 
	}    
    
    return rslt;
}
/****************************************************************************************************/
/* FUNCTION     :   EventExecute                                                                    
/* PURPOSE      :   Event Execute                                                                   
/* INPUT        :   None                                                                            
/* RETURN VALUE :   None                                                                            
/****************************************************************************************************/
unsigned int EventExecute(unsigned int event, unsigned int flag)
{
    unsigned int i , result = CLEAR;    

	static const unsigned int PowerEvent[POWEV_NUM] = {    	
		EV_POWERONOFF,		/* 000	POWEV_POWERONOFF,	*/
		EV_POWERON,			/* 001	POWEV_POWERON,		*/
		EV_POWERONSTART,	/* 002	POWEV_POWERONSTART,	*/
		EV_SIRPOWERONOFF,	/* 003  POWEV_SIRPOWERONOFF,*/
		EV_SIRPOWERON,		/* 004  POWEV_SIRPOWERON,	*/
		EV_SIRPOWEROFF,		/* 005  POWEV_SIRPOWEROFF,	*/
		EV_IRINPUTPOWER,	/* 006  POWEV_IRINPURPOWER,	*/
		EV_IDSWITCHIN,		/* 007  POWEV_IDSWITCHIN	*/
		EV_KEYPOWERONOFF,	/* 008  POWEV_KEYPOWERONOFF	*/
		EV_KEYPOWERON,		/* 009	POWEV_KEYPOWERON   	*/
		EV_KEYPOWEROFF,		/* 010  POWEV_KEYPOWEROFF	*/
		EV_KEYMUTING,		/* 011  POWEV_KEYMUTING 	*/
		EV_KEYVOLUP,		/* 012  POWEV_KEYVOLUP		*/
		EV_KEYVOLDW,		/* 013  POWEV_KEYVOLDW   	*/
   	}; 
    	   
	static const unsigned int ProtectorEvent[_PRTEV_NUM] = {
		EV_POWERONOFF,		/* 000	PROEV_POWERONOFF, 	*/								
		EV_POWEROFF,		/* 001	PROEV_POWEROFF,		*/
		EV_POWERON,			/* 002	PROEV_POWERON,		*/		
		EV_SIRPOWERONOFF,	/* 003  PROEV_SIRPOWERONOFF,*/
		EV_SIRPOWERON,		/* 004  PROEV_SIRPOWERON,	*/
		EV_SIRPOWEROFF,		/* 005  PROEV_SIRPOWEROFF,	*/
		EV_IDSWITCHIN,		/* 006  PROEV_IDSWITCHIN	*/		
	};

   	 static const unsigned int AlwaysEvent[ALWEV_NUM] = {
		EV_POWERONOFF,		/* 000	ALWEV_POWERONOFF,	*/
		EV_POWEROFF,		/* 001	ALWEV_POWEROFF,		*/
		EV_POWERONSTART,	/* 001	ALWEV_POWERONSTART,	*/
		EV_SIRPOWERONOFF,	/* 003  ALWEV_SIRPOWERONOFF,*/
		EV_SIRPOWERON,		/* 004  ALWEV_SIRPOWERON,	*/
		EV_SIRPOWEROFF,		/* 005  ALWEV_SIRPOWEROFF,	*/
		EV_IRINPUTPOWER,	/* 006  ALWEV_IRINPURPOWER,	*/
		EV_IDSWITCHIN,		/* 007  ALWEV_IDSWITCHIN	*/
	}; 
    
	static unsigned char (*const execute[EV_NUM])(unsigned char) = {      
		ExeNop   		,	/* 000	NO OPERATION    	*/
		ExePowerOn		,	/* 001	EV_POWERON			*/
		ExePowerOff		,	/* 002	EV_POWEROFF			*/
		ExePowerOnOff	,	/* 003	EV_POWERONOFF		*/
		ExePowerOnStart	,	/* 004	EV_POWERONSTART		*/
		ExeVRComingLeft	,	/* 005	VR EV_VRCOMINGLEFT	*/
		ExeVRComingRight,	/* 006	EV_VRCOMINGRIGHT	*/
		ExeVolUp      	,	/* 007	EV_VOLUP           	*/	
		ExeVolDw      	,	/* 008	EV_VOLDW           	*/	
		ExeMuting     	,	/* 009	EV_MUTING          	*/	
		ExeSirPowerOn	,	/* 010	EV_SIRPOWERON		*/
		ExeSirPowerOff	,	/* 011	EV_SIRPOWEROFF		*/
		ExeSirPowerOnOff,	/* 012	EV_SIRPOWERONOFF	*/
		ExeKeyPowerOnOff,	/* 013  EV_KEYPOWERONOFF	*/
		ExeKeyPowerOn,		/* 014	EV_KEYPOWERON   	*/
		ExeKeyPowerOff,		/* 015  EV_KEYPOWEROFF		*/
		ExeKeyMuting,		/* 016  EV_KEYMUTING 		*/
		ExeKeyVolUp,		/* 017  EV_KEYVOLUP			*/
		ExeKeyVolDw,		/* 018  EV_KEYVOLDW   		*/
		ExeIDSwitchIn,		/* 019  EV_IDSWITCHIN		*/		
		ExeIRInputPower,	/* 020  EV_IRINPUTPOWER		*/
		ExeAllClear,		/* 021	EV_ALLCLEAR			*/
	};  

    if (Power.Flag.PowOn == OFF) {
   		for (i = 0; i < POWEV_NUM; i++){
			if (event == PowerEvent[i]){         
        			result = execute[event](flag);                           
    			}
    		}
   	} else if (PowWork.Prtc == ON) {
		for (i = 0; i < _PRTEV_NUM; i++){
			if (event == ProtectorEvent[i]){
					result = execute[event](flag);
    			}
    		}
    } else if (PowWork.Pw1s == ON) {
		if ((Power.Flag.PowOn == ON) && (event < EV_NUM)){
			result = execute[event](flag);
		}	
	} else {
		for (i = 0; i < ALWEV_NUM; i++){
			if (event == AlwaysEvent[i]){
				result = execute[event](flag);
     		}
    	}
    }
    return result;  
}
/****************************************************************************************************/