exect_m04_c2.c

sircs decoder, for amplifier.. this is to decode

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

#include "_main_M04_C2.h"

#if MAIN_LOOP_TEST
	static unsigned char MainLoopTrig;
#endif
/****************************************************************************************************/
/* static variable definition											  							
/****************************************************************************************************/


/****************************************************************************************************/
/* local variables definition which are refered only this file										
/****************************************************************************************************/
#define key_800mS _400mS
#define key_200mS _100mS
#define key_400mS _200mS
#define key_120mS _60mS
#define key_100mS _50mS
#define key_60mS  _30mS
#define key_20mS  _10mS
#define GAPMAX	10			/* 4.2 dB */
#define LOWVOL	15  		/* sircs step (low volume) */
#define BITCNT	10
#define BITMASK 0x0200

/****************************************************************************************************/
/* FUNCTION		:	IniExecute																		
/* PURPOSE		:	Execute Initialize 																
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void IniExecute(void)
{	
#if MAIN_LOOP_TEST
	MainLoopTrig = CLEAR;
#endif
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	ExeControl																		
/* PURPOSE		:	Execute Control			 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void ExeControl(void)
{		
	/* NO USE */
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	ExeNop																			
/* PURPOSE		:	No Operation			 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeNop(unsigned char arg)
{
	return arg = 0;
}
/****************************************************************************************************/
/* FUNCTION		:	ExePowerOnOff																	
/* PURPOSE		:	POWER ON/OFF			 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExePowerOnOff(unsigned char arg)
{	
	if (arg) {
		if (PowStatus()) {
			if ((Power.Flag.PowOn == ON)||(PowWork.Prtc == ON)){
				ExePowerOff(arg);
			}else{
				ExePowerOn(arg);
			}
			return 0;
		} else if (Power.Flag.PowOn == ON){
			return _100mS;
		} else{
			return 0;
		}
	} else {
		if (Bak.Init){
			return 0;
		}
		return _100mS;
	}

}

/****************************************************************************/
/* Power On																	*/
/****************************************************************************/
unsigned char ExePowerOn(unsigned char arg)
{
	Power.Flag.PowOn = ON;					/* power on request	*/
	return arg = 0;
}
/****************************************************************************/
/* Power Off																*/
/****************************************************************************/
unsigned char ExePowerOff(unsigned char arg)
{
	Power.Flag.PowOn = OFF;
	return arg = 0;
}

/****************************************************************************/
/* Power On Start															*/
/****************************************************************************/
unsigned char ExePowerOnStart(unsigned char arg)
{
	return arg = 0;
}

/****************************************************************************************************/
/* FUNCTION		:	ExeSirPowerOnOff																	
/* PURPOSE		:	POWER ON/OFF			 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeSirPowerOnOff(unsigned char arg)
{	
	if((EventAvailable(EVT_SPOF) == EVENT_TRUE)&&(EventAvailable(EVT_SIRI) == EVENT_TRUE)) {
		if (arg) {
			if (PowStatus()) {
				if ((Power.Flag.PowOn == ON)||(PowWork.Prtc == ON)){
					ExePowerOff(arg);
				}else{
					ExePowerOn(arg);
				}
				BakMemoryWriteReq((unsigned char *)&Power.Flag);
				Power.Flag.PowOnSel = Power.Flag.PowOn;
				return 0;
			} else if (Power.Flag.PowOn == ON){
				return _100mS;
			} else{
				return 0;
			}
		} else {
			if (Bak.Init){
				return 0;
			}
			return _100mS;
		}
	}
	return 0;
}

/****************************************************************************/
/* Power On																	*/
/****************************************************************************/
unsigned char ExeSirPowerOn(unsigned char arg)
{
	if((EventAvailable(EVT_SPOF) == EVENT_TRUE)&&(EventAvailable(EVT_SIRI) == EVENT_TRUE)) {
		Power.Flag.PowOn = ON;					/* power on request	*/
		BakMemoryWriteReq((unsigned char *)&Power.Flag);
		Power.Flag.PowOnSel = Power.Flag.PowOn;
	}
	return arg = 0;
}
/****************************************************************************/
/* Power Off																*/
/****************************************************************************/
unsigned char ExeSirPowerOff(unsigned char arg)
{	
	if((EventAvailable(EVT_SPOF) == EVENT_TRUE)&&(EventAvailable(EVT_SIRI) == EVENT_TRUE)){
		Power.Flag.PowOn = OFF;
		BakMemoryWriteReq((unsigned char *)&Power.Flag);
		Power.Flag.PowOnSel = Power.Flag.PowOn;
	}
	return arg = 0;
}

/****************************************************************************************************/
/* FUNCTION		:	ExeVRComingLeft																		
/* PURPOSE		:	VR change					 														
/* INPUT		:	id (vr value)																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeVRComingLeft(unsigned char arg)
{
	if(EVR_OUT[0] > arg){
		if((EVR_OUT[0]- arg)> GAPMAX){
			EVR_OUT[0] -= GAPMAX;
		}else{ 
			EVR_OUT[0] = arg;				/* assign vr value to global ram */
		}
	}else{
		if((arg - EVR_OUT[0])> GAPMAX){
			EVR_OUT[0] += GAPMAX;
		}else{ 
			EVR_OUT[0] = arg;
		}
	}	 
	_vr[0].buff = EVR_OUT[0];
	return arg = 0;

}

/****************************************************************************************************/
/* FUNCTION		:	ExeVRComingRight																		
/* PURPOSE		:	VR change					 														
/* INPUT		:	id (vr value)																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeVRComingRight(unsigned char arg)
{
	if(EVR_OUT[1] > arg){
		if((EVR_OUT[1]- arg)> GAPMAX){
			EVR_OUT[1] -= GAPMAX;
		}else{ 
			EVR_OUT[1] = arg;				/* assign vr value to global ram */ 
		}
	}else{
		if((arg - EVR_OUT[1])> GAPMAX){
			EVR_OUT[1] += GAPMAX;
		}else{ 
			EVR_OUT[1] = arg;
		}
	}
	_vr[1].buff = EVR_OUT[1];
	return arg = 0;

}

/****************************************************************************************************/
/* FUNCTION		:	ExeVolUp																		
/* PURPOSE		:	VOL +					 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/

unsigned char ExeVolUp(unsigned char arg)
{
	unsigned char result;
	
	result = CLEAR;
	if(EventAvailable(EVT_SIRI) == EVENT_TRUE) {
		if (arg == TRUE){	
			E_VOL.SircsVolStep++;
			result = _800mS;
		}else{
			if (E_VOL.SircsVolStep < LOWVOL){
				E_VOL.SircsVolStep = E_VOL.SircsVolStep+2;		/* 2 step up when low volume */
			}else{
				E_VOL.SircsVolStep++;
			}				
			result = _200mS;
		}
		
		if (E_VOL.SircsVolStep >= _STEP_MAX) {
			E_VOL.SircsVolStep  = _STEP_MAX;
		}
		
		E_VOL.Muting = OFF;
	}
	return result;
}

/****************************************************************************************************/
/* FUNCTION		:	ExeVolDw																	
/* PURPOSE		:	VOL -					 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeVolDw(unsigned char arg)
{	
	unsigned char result;
	
	result = CLEAR;
	if(EventAvailable(EVT_SIRI) == EVENT_TRUE) {
		if (arg == TRUE){	
			if (E_VOL.SircsVolStep > 0) {
				E_VOL.SircsVolStep--;
			}
			result = _800mS;
		}else{
			if (E_VOL.SircsVolStep > 0) {
				if ((E_VOL.SircsVolStep < LOWVOL)&&(E_VOL.SircsVolStep > 1)) {		/* avoid overflow */
					E_VOL.SircsVolStep = E_VOL.SircsVolStep-2;		/* 2 step down when low volume */
				}else{
					E_VOL.SircsVolStep--;
				}				
			}
			result = _200mS;
		}
	}
	return result;
}

/****************************************************************************************************/
/* FUNCTION		:	ExeMuting																		
/* PURPOSE		:	Muting Key				 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeMuting(unsigned char arg)
{
	if(EventAvailable(EVT_SIRI) == EVENT_TRUE) {
		if (arg) {
			if (E_VOL.Muting) {
				E_VOL.Muting = OFF;
			} else {
				E_VOL.Muting = ON;
			}
		}
	}
	return arg = 0;
}

/****************************************************************************************************/
/* FUNCTION		:	ExeKeyPowerOnOff																	
/* PURPOSE		:	POWER ON/OFF sircs out			 														
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
unsigned char ExeKeyPowerOnOff(unsigned char arg)
{	
	unsigned char result,i;
	unsigned int sirodat,bitmsk;

	result = CLEAR;
	if(EventAvailable(EVT_SIRO) == EVENT_TRUE) {
		sirodat = SirDecTable0[S_POWERONOFF][IDSwitch.IDNum];