sircs_m04_c2.c

sircs decoder, for amplifier.. this is to decode

			sir.buf	 = S_OFF;
			sir.cht	 = CLEAR;
			F_SIRREQ = CLEAR;						/* sircs event req.flag	  	*/
			F_SIRFST = CLEAR;						/* sircs input first flag 	*/
			F_SIRSLP = CLEAR;						/* sircs sleep req.flag	  	*/
			if ((sir.stt == SIR_COD_INIT) && (F_SIRSLP != SET)) {
				F_SIRSLP = SET;						/* u-com sleep request flg	*/
			}
			
		} else if (F_SIRSLP != CLEAR) {
			F_SIRSLP = CLEAR;
		}
	}

	Is10msATimeOver(&sir.tim);
	if ((F_SIRREQ == SET) && ((F_SIRFST == SET) || (sir.tim == TIME_UP))) {

		if (F_SIRFST == SET) {
			task = TRUE;
		} else {
			task = FALSE;
		}
		
		F_SIRFST = CLEAR;													/* sircs in 1st flg clear */
	
		if (sir.buf < SIRCS_EVENT_NUM) {
				sir.tim = EventExecute(SirEventTable[sir.buf], task); 		/* event execute */	
		} else {
			
			sir.tim = NULL;
			
		}
		
		if (sir.tim == NULL) {
			F_SIRREQ = CLEAR;												/* sircs in req.flg clear */
		}
	}

	return;
	
}

/****************************************************************************************************/
/* FUNCTION		:	GetSircsID												  						
/* PURPOSE		:	Get Sircs ID with Sircs Code							 						
/* INPUT		:	Sircs Code												  						
/* RETURN VALUE	:	Sircs ID												  						
/****************************************************************************************************/
unsigned int GetSircsID(unsigned long int code)
{
	unsigned int id, cod0, cod1;							/* sircs id */
	cod0 = (unsigned int)((code >> 10) & MASK_10BIT );		/* 1st 10 bit sircs data code (D0 - D9) */
	cod1 = (unsigned int)(code & MASK_10BIT);				/* last 10 bit sircs data code (D10 - D19) */

	for (id = S_OFF; id < SIRCS_EVENT_NUM; id++) {
		if ((cod0 == SirDecTable0[id][Sir.Sircom]) && (cod1 == _SIR_COD)) {	
			break;	
		}
	}
	if (id >= SIRCS_EVENT_NUM) {							/* for N.G. */
		id = S_OFF;
	}	
	return id;
}

/****************************************************************************************************/
/* FUNCTION		:	GetSircsAct												  						
/* PURPOSE		:	Get Sircs Action with Sircs ID							  						
/* INPUT		:	Sircs ID												  						
/* RETURN VALUE	:	Sircs Action											  						
/****************************************************************************************************/
unsigned char GetSircsAct(unsigned int id)
{
	unsigned char result;					/* result of action */

	if ((sir.cht & SFSTRG) == SFSTRG) {		/* sircs code in first end */
		if (sir.buf != id) {				/* sircs code change */
			result  = SIROFF;				/* action : sircs code off */
			sir.cht = CLEAR;				/* state clear */
			sir.buf = S_OFF;				/* sircs id buffer : off */
		} else {
			result  = SIRCNT;				/* action : sir.code in  continue */
			if(sir.cht != SCHTED) {			/* not end of count ? */
				sir.cht++;					/*count up state,keep fist end bit*/
			}
		}
	} else {
		if ((id != S_OFF) && (sir.buf == id)) {
			result  = UNKNWN;				/* action : unknown */
			if (++sir.cht >= SCHTOK) {		/* chattering check o.k. */
				result  = SIRFST;			/* action : sir.code in first */
				sir.cht = SFSTRG;			/* reset state, set fist end bit */
			}
		} else {
			result  = SIROFF;				/* action : sircs code off */
			if ((id != S_OFF) && (sir.buf == S_OFF)) {
				result  = UNKNWN;			/* action : unknown */
			}
			sir.cht = CLEAR;				/* reset state */
			sir.buf = id;					/* store id to buffer */
		}
	}
	
	return result;
}

/******************************************************************************/
/* FUNCTION NAME :	SirOutInitialize										  */
/* PURPOSE       :	Initialize 16bit timer/counter register					  */
/******************************************************************************/
void SirOutInitialize(void)
{
	unsigned char i;
	
	TMCR.BYTE = CLEAR;				/* timer control register 		*/
	TCR.WORD  = _MC_START;			/* data out now 				*/
	ILR3.BYTE &= 0xFC;				/* interrupt level 1 (Enable)	*/
	ILR3.BYTE |= 0x01;				/* interrupt level 1 (Enable)	*/
							
	sircs_out_stt 	= _SOUT_END;
	sircs_out_frame = CLEAR;
	sircs_firstime 	= CLEAR;
	sircs_out_bit 	= CLEAR;
	sircs_out_num_dat_1 = CLEAR;
	sircs_out_gap_len  = CLEAR;
	siro_time = CLEAR;
	SIRCS_DAT_0;
	for (i=0; i<_BIT_NUM; i++) {
		SIRCSDATAOUT[i]	= CLEAR;
	}
	SirCarrierIni();	
	return;

}

/****************************************************************************************************/
/* FUNCTION		:	SirCarrierIni												  						
/* PURPOSE		:	Generate 40kHz Carrier							  						
/* INPUT		:	none												  						
/* RETURN VALUE	:	none											  						
/****************************************************************************************************/
void SirCarrierIni(void)
{
	COMR1.BYTE = 0x26;				/* sircs out carrier 12.5us 	*/
	CNTR1.BYTE = 0x00;
	CNTR3.BYTE = 0x20;
	CNTR2.BYTE = 0x00;				/* Stop counter					*/
	return;	
}

/****************************************************************************************************/
/* FUNCTION		:	SirCarrierStop												  						
/* PURPOSE		:	Stop Carrier							  						
/* INPUT		:	none												  						
/* RETURN VALUE	:	none											  						
/****************************************************************************************************/
void SirCarrierStop(void)
{
	COMR1.BYTE = CLEAR;
	CNTR1.BYTE = CLEAR;
	CNTR3.BYTE = CLEAR;
	CNTR2.BYTE = CLEAR;
	return;	
}
 
/******************************************************************************/
/* FUNCTION NAME :	SircsOutStart											  */
/* PURPOSE       :	Start sending sircs data								  */
/******************************************************************************/
void SircsOutControl(void)
{	

	static const unsigned int GapLenTable[_MAX_NUM_1] = {		
		_MC_GAP_0,       	/* 000 	 	*/	
		_MC_GAP_1,			/* 001	  	*/	
		_MC_GAP_2, 		   	/* 002	  	*/	
		_MC_GAP_3,		   	/* 003	 	*/	
		_MC_GAP_4,			/* 004	 	*/	
		_MC_GAP_5,  		/* 005	 	*/	
		_MC_GAP_6,		   	/* 006	 	*/	
		_MC_GAP_7,		   	/* 007	 	*/	
		_MC_GAP_8,		   	/* 008	 	*/
		_MC_GAP_9,		   	/* 009	 	*/
		_MC_GAP_10,		   	/* 010	 	*/
		_MC_GAP_11,		   	/* 011	 	*/
		_MC_GAP_12,		   	/* 012	 	*/
			
	};

	if (sircs_firstime){										/* first time sircs out?*/
		sircs_firstime = CLEAR;
		sircs_out_stt  = _SOUT_BUSOFF;							/* check bus off 		*/
		sircs_out_gap_len = GapLenTable[sircs_out_num_dat_1];	/* gap between frames  	*/
		TCR.WORD = _MC_DELAY;									/* delay start data out	*/
		TMCR.BYTE = _TIM16_START;								/* start count up 		*/
		sircs_out_bit = CLEAR;									/* transfer bit count 	*/
	}
	return;
}

/******************************************************************************/
/* FUNCTION NAME :	SircsCodeTx												  */
/* PURPOSE       :	Send Sircs Format data transmit							  */
/******************************************************************************/
__interrupt void SircsCodeTx(void)
{
	TMCR.BYTE = 0x00;								/* clear interrupt request & stop counter up */
	if (sircs_out_frame == 0) {
		CNTR2.BYTE = CLEAR;							/* stop carrier						*/
		TMCR.BYTE = CLEAR;
		F_OPERTLED = OFF;
		LED_DAT_0;
		siro_time = _600mS;							/* gap between next sircs output	*/
		sircs_out_stt = _SOUT_END;	  
		sircs_out_bit = CLEAR;
	} else if (sircs_out_stt == _SOUT_DATA) {		/*** data bit ***/
			sircs_out_stt = _SOUT_OFFBIT;			
			if (SIRCSDATAOUT[sircs_out_bit]){
				TCR.WORD = _MC_DAT_1;				/* 1.2msec - bit '1' 				*/
			}else{
				TCR.WORD = _MC_DAT_0;				/* 0.6msec - bit '0' 				*/
			}				
			TMCR.BYTE = _TIM16_START;
			SIRCS_DAT_1;
			CNTR2.BYTE = _CARIER_START;				/* start carrier					*/
			sircs_out_bit = sircs_out_bit + 1;	
					
	} else if (sircs_out_stt == _SOUT_OFFBIT) {		/*** off bit out or start bit end ***/	
			if (sircs_out_bit >= _BIT_NUM){
				sircs_out_stt = _SOUT_GAP;
				TCR.WORD = sircs_out_gap_len;		/* Depend on no. of bit '1' - Gap 	*/
			} else {
				sircs_out_stt = _SOUT_DATA;
				TCR.WORD = _MC_OFBIT;				/* 0.6msec - off bit 				*/
			}
			TMCR.BYTE = _TIM16_START;
			CNTR2.BYTE = CLEAR;						/* stop carrier						*/
			SIRCS_DAT_0;
	} else if (sircs_out_stt == _SOUT_BUSOFF) {		/*** sircs out transfer start ***/	
			sircs_out_stt = _SOUT_OFFBIT;			/* update output status 			*/
			TCR.WORD = _MC_STBIT;					/* 2.4msec - start bit 				*/
			TMCR.BYTE = _TIM16_START;				/* start counter up 				*/
			SIRCS_DAT_1;
			CNTR2.BYTE = _CARIER_START;				/* start carrier					*/
	} else if (sircs_out_stt == _SOUT_GAP) {		/*** sircs out transfer finish ***/		
			if (sircs_out_frame){
				if (sircs_out_frame > FRAMFST){		/* fail safe						*/
					sircs_out_frame = FRAMFST;
				}
				--sircs_out_frame; 
				sircs_out_stt  = _SOUT_BUSOFF;		/* check bus off 					*/

				if (F_OPERTLED == ON){				/* OPERATION LED blinking			*/
					F_OPERTLED = OFF;
					LED_DAT_0;
				} else {
					F_OPERTLED = ON;
					LED_DAT_1;
				}

				TCR.WORD = _MC_START;				/* data out now 					*/
				TMCR.BYTE = _TIM16_START;
				sircs_out_bit = CLEAR;
			}
			CNTR2.BYTE = CLEAR;						/* stop carrier						*/
			SIRCS_DAT_0;
	} else {
			TMCR.BYTE = CLEAR;
			sircs_out_stt = _SOUT_END;	  
			sircs_out_bit = CLEAR;
			CNTR2.BYTE = CLEAR;						/* stop carrier						*/
			SIRCS_DAT_0;
	}
	return;
}