keyin_m04_c2.c

sircs decoder, for amplifier.. this is to decode

	static const unsigned char _AdKeyIdTable[_ADV_NUM][_ADL_NUM] = {
		/*	AN0       	 	AN1       	 	AN2     	 	AN3  	 	AN4  	 	AN5  	 	AN6  	 	AN7  	*/	      	        	
		{ 	K_OFF     	,	K_OFF     		,	K_OFF   	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 000	key off 	*/	
		{ 	K_OFF     	,	K_OFF     		,	K_OFF  		,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 001	key 7 on	*/	
		{ 	K_OFF		,	K_OFF	 		,	K_OFF	  	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 002	key 6 on	*/	
		{ 	K_OFF	 	,	K_OFF	 		,	K_OFF	  	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 003	key 5 on	*/	
		{ 	K_OFF	 	,	K_OFF	  		,	K_OFF	  	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 004	key 4 on	*/	
		{ 	K_OFF	 	,	K_OFF			,	K_OFF	  	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 005	key 3 on	*/	
		{ 	K_POWEROFF 	,	K_VOLUP			,	K_OFF		,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 006	key 2 on	*/	
		{ 	K_POWERON 	,	K_VOLDW 		,	K_OFF	 	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 007	key 1 on	*/	
		{ 	K_POWERONOFF,	K_MUTING   		,	K_OFF	 	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 008	key 0 on	*/	

	};

	static const unsigned int _AdThreshold[_ADV_NUM] = {
		_ADTH_KOFF,							/* [0] a/d key off		*/
		_ADTH_KEY7,							/* [1] a/d key number 7	*/		
		_ADTH_KEY6,							/* [2] a/d key number 6	*/
		_ADTH_KEY5,							/* [3] a/d key number 5	*/
		_ADTH_KEY4,							/* [4] a/d key number 4	*/
		_ADTH_KEY3,							/* [5] a/d key number 3	*/
		_ADTH_KEY2,							/* [6] a/d key number 2	*/
		_ADTH_KEY1,							/* [7] a/d key number 1	*/
		_ADTH_KEY0							/* [8] a/d key number 0	*/
	};
	

	unsigned int val, key;
	unsigned char id;	
	
	const static unsigned char	adc1_tbl[] = {
		0x01,	/* AD key 0 */
		0x11,	/* AD key 1 */
		0x21,	/* AD key 2 */
		0x31,	/* AD key 3 */
		0x41,	/* AD key 4 */
		0x51,	/* AD key 5 */
		0x61,	/* AD key 6 */
		0x71,	/* AD key 7 */
	};		
	

	ADC2.BYTE = 0x01;
	ADC1.BYTE = adc1_tbl[ch];							/* start AD Conversion 				*/
		
	while( !(ADC1.BYTE & 0x08) );						/* finish convert? 					*/
	ADC1.BYTE = 0x00;
	
	val =  (unsigned int)((ADDH.BYTE << 8)|ADDL.BYTE);	/* get ad data 						*/
		
	for (key = 0; key < _ADV_NUM; key++) {
		if (val >= _AdThreshold[key]) {	
			break;
		}
	}	

	id = _AdKeyIdTable[key][(ch & 0x07)];
		
	return id;
}

/****************************************************************************************************/
/* FUNCTION		:	GetKeyAct																		
/* PURPOSE		:	get adkey action						  										
/* INPUT		:	adkey id, channel																
/* RETURN VALUE	:	action																			
/****************************************************************************************************/
static unsigned char GetKeyAct(unsigned char id, unsigned char ch)
{
	unsigned char result = _KEYOFF;						/* result of action					*/

	if (ch < _KEY_NUM) {
	
		if ((_key[ch].stat & _KEY1TRG) == _KEY1TRG) {	/* key on first end					*/
		
			if (_key[ch].buff != id) {					/* key change						*/
				result  = _KEYOFF;						/* action : key off					*/
				_key[ch].stat = _KEYOFF;				/* state clear						*/
				_key[ch].buff = K_OFF;					/* key id buffer : key off			*/
			} else {
				result = _KEYCNT;						/* action : key on continue			*/
				if (_key[ch].stat != _KEYEND) {			/* not end of count ?				*/
					_key[ch].stat++;					/* count up state,keep fist end bit	*/
				}
			}
		} else {
			if ((id != K_OFF) && (_key[ch].buff == id)) {
				_key[ch].stat++;						/* state count up					*/
				if (_key[ch].stat >= _CHATOK){			/* chattering check o.k.			*/
					result        = _KEY1ST;			/* action : key on first			*/
					_key[ch].stat = _KEY1TRG;			/* reset state, set fist end bit	*/
				} else {
					result  = _UNKNWN;
				}
			} else {
				if ((id != K_OFF) && (_key[ch].buff == K_OFF)) {
					result  = _UNKNWN;
				} else {
					result  = _KEYOFF;
				}
				_key[ch].stat = _KEYOFF;				/* reset state						*/
				_key[ch].buff = id;						/* store id to buffer				*/
			}
		}
	}
	return result;
}
/****************************************************************************************************/
/* FUNCTION		:	MltplxKeyAvailable																
/* PURPOSE		:	multiplex keys check					  										
/* INPUT		:	special mode number																
/* RETURN VALUE	:	TRUE/FLASE																		
/****************************************************************************************************/
unsigned int MltplxKeyAvailable(unsigned int n)
{
	const static unsigned char MltplxKeyTable[SPM_NUM][_ADL_NUM] = {
		/*	AN0       	 	AN1      	 	AN2     	 	AN3  	 	AN4  	 	AN5  	 	AN6  	 	AN7  	*/	      	                	
		{ 	K_OFF		,	K_OFF    	,	K_OFF   	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 000	SPM_NOP = 0,    	*/	
		{ 	K_POWEROFF	,	K_OFF		,	K_OFF	 	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 001	SPM_ALLCLR, 		*/
		{ 	K_POWEROFF	,	K_VOLUP    	,	K_OFF   	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	,	K_OFF	},	/* 000	SPM_VERSION,    	*/		
	};
	
	unsigned int ch, result = TRUE;

	if (n >= SPM_NUM) {									/* fail safe						*/
		return FALSE;
	}
	
	for (ch = 0; ch < _KEY_NUM; ch++) {
		if (_key[ch].buff != MltplxKeyTable[n][ch]) {
			result = FALSE;
			break;
		}
	}
	
	return result;
}


/********************************************************************************/
/*		Multiplex Key Check														*/
/********************************************************************************/
void MltplxKeyCheck(void)
{
	if(Is10msATimeOver(&_mltplxkey_time)) {				/* Is multikey check over?			*/
		if (MltplxKeyAvailable(SPM_ALLCLR)) {			/* Memory All Clear multiplex?		*/
			if (Bak.Init){
				return;						/* Memory All Clear execute already?*/
			}
			Test.Exe = SPM_ALLCLR;	
			ExeAllClear(TRUE);							/* Execute Memory All Clear			*/
		} else if (MltplxKeyAvailable(SPM_VERSION)) {	/* Version show multiplex?			*/
			Test.Exe = SPM_VERSION;
		}
	}
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	IsMltplxKeyEnd																		
/* PURPOSE		:	Check whether multiplex keys check is end							  										
/* INPUT		:	None																			
/* RETURN VALUE	:	TRUE/FALSE																			
/****************************************************************************************************/
int IsMltplxKeyEnd(void)
{
	return(_mltplxkey_time == 0);
}

/****************************************************************************************************/
/* FUNCTION		:	IDSircsIn																		
/* PURPOSE		:	ID switch control 							  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void IDSircsIn(void)
{	
	/*** Learn bit Use ***/
	if (P_ID4 == HIGH) {
		IDSwitch.Learn = ON;							/* Test bit ON						*/
	} else {
		IDSwitch.Learn = OFF;							/* Test bit OFF						*/
	}

	if ((IDSwitch.Learn == ON)&&(PowStatusTest())) {
		IDSwitch.Test = ON;								/* Test mode ON						*/
	} else {
		IDSwitch.Test = OFF;							/* Test mode OFF					*/
	}
	
	IDSwitch.IDNum = CLEAR;
	if (P_ID0 == HIGH) 	{
		IDSwitch.IDNum = 1;								/* IR ID bit 0						*/
	}
	if (P_ID1 == HIGH)  {
		IDSwitch.IDNum |= 0x02;							/* IR ID bit 1						*/
	}
	if (P_ID2 == HIGH)  {
		IDSwitch.IDNum |= 0x04;							/* IR ID bit 2						*/
	}
	if (P_ID3 == HIGH)  {
		IDSwitch.IDNum |= 0x08;							/* IR ID bit 3						*/
	}
	
	if (IDSwitch.IDNum >= SIRCOM_IDMAX) {
		IDSwitch.IDNum = SIRCOM_ID1;					/* fail safe 						*/
	}
	if (IDSwitch.IDNum != Sir.Sircom ) {
		EventExecute(EV_IDSWITCHIN, TRUE);
	}
	
	return;
}