📄 power_m04_c2.c

📁 sircs decoder, for amplifier.. this is to decode
💻 C
字号:
/****************************************************************************************************/
/* $Header  : 																					  	
/* AUTHOR 	: TC PUI																		  		
/* FILE NAME: POWER.C																		  		
/* PURPOSE	: POWER CONTROL												 				 		
/* MODEL	: 2004 CIS 2-CH AMP 										  						
/* Copyright (c) 2004 Sony Corporation All Rights Reserved					  						
/****************************************************************************************************/
#define _POWER_C

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

unsigned int	pow_time;
unsigned int	pow_time2;					/* for Backup Fale Safe Timer 		*/
unsigned int	prot_time;
unsigned int	stop_time;
unsigned char 		PowStt;
unsigned char 		PowBak;	

/****************************************************************************/
/* static function definition												*/
/****************************************************************************/
static void PowInitial( void );
static void PowOff( void );
static void PowWait( void );
static void PowClrOff( void );
static void PowOn1( void );
static void PowOn2( void );
static void PowSpOff( void );
static void PowProtector( void );
static void PowACOff( void );
static void PowSoftReset( void );

static void AllRyOff( void );
static void AllLedOff( void );
static void SpeakerRelayControl( void );	/* Speaker Realy Control 			*/

/****************************************************************************************************/
/* FUNCTION		:	PowInitialize																	
/* PURPOSE		:	Power Initialize						  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void IniPower(void)
{
	Power.Flag.PowOn  = ON;
	Power.Flag.PowOnSel = Power.Flag.PowOn;	/* power on buffer ram for Input Selector checking */
	PowStt = NOP_LP ;
	PowBak = Power.Flag.PowOn;
	PowWork.Pw1s= OFF ;						/* Module Not Activate				*/
	PowWork.Pwok= OFF ;						/* Power On Loop					*/
	PowWork.Prtc= OFF ; 					/* Protect flag     				*/
	Power.SpRy.Byte = NULL;
	PowWork.ProtCnt = NULL;
	pow_time = _100mS;						/* c/m for none IR-IN initial power on */
	pow_time2= _2sec;						/* Power Backup False Safe Timer 	*/
	prot_time = CLEAR;
	stop_time = _20mS ;
	EIC1.BYTE = CLEAR;						/* Disable INT10 & INT11			*/
	EIC2.BYTE = CLEAR;						/* Disable INT12 & INT13			*/	
	AllRyOff();
	ALL_MUTE_ON;			
	return;
}
/****************************************************************************************************/
/* FUNCTION		:	PowControl																			
/* PURPOSE		:	Power Control						  										
/* INPUT		:	None																			
/* RETURN VALUE	:	None																			
/****************************************************************************************************/
void PowControl(void)
{
 unsigned char stt;

	if (P_STOP==LOW){
		Bak.Wait = ON ;						/* Back Busy 0(Write)/1 (Not Write)	*/
		POW_ACTIVE = OFF ;					/* Module not Active				*/
		if (Is10msATimeOver(&stop_time)){
			AllRyOff() ;					/* Relay Off						*/
			ALL_MUTE_ON ;					/* Mute ON							*/
			PowStt = PACOFF ;
			pow_time = _20mS ;
		}
	} else {								/* Module not Active				*/
		if (PowStt == POWON2){
			POW_ACTIVE = ON;
		}else if ((PowStt == POWON1)||(PowStt == POFFLP)){
			POW_ACTIVE = ON;
		}else{
			POW_ACTIVE = OFF;
		}
/*		if ((PowStt != POWON2)&&(PowStt != POWSPOFF))	POW_ACTIVE = OFF ;
/*		else											POW_ACTIVE = ON  ;*/
		stop_time = _20mS ;
	}

	stt = PowStt;
	switch(stt){							/*	Pw1s flag Set/Rest				*/
		case PCLROFF:
		case POWON1 :
		case POWON2	:
		case PRTCON	:						/*	FL Display Enable				*/
				PowWork.Pw1s = ON;
				break ;
		default :
				PowWork.Pw1s = OFF;
				break ;
	}
											/* Power Off or Protect->not Active	*/
	if (stt==POWON2){
/*		POW_ACTIVE = ON ;*/
	}else{
/*		POW_ACTIVE = OFF ;*/
		ALL_MUTE_ON;
	}

	if (PowBak != Power.Flag.PowOn){		/* Power Backup Data != Now Data	*/
		PowBak = Power.Flag.PowOn;			/* Power Backup Data <= Now Data	*/
		BakSearchStartReq();				/* Eeprom Start						*/
		pow_time2 = _2sec ;					/* depend on longest sir.code 		*/
	}

	switch(stt){
		case NOP_LP	:						/* 	Initial state 					*/
				PowInitial() ;
				break ;
		case PRTCON	:						/* 	Power protector state 			*/
				PowProtector();
				break ;
		case POFFLP :			 			/* 	Power OFF state 				*/
				PowOff() ;
				break ;
		case POWAIT :						/* 	Power Wait State 				*/
				PowWait() ;
				break ;
		case PCLROFF :						/*	Power OFF State After All Clear	*/
				PowClrOff();
				break ;
		case POWON1 :						/* 	Power ON Start 					*/
				PowOn1() ;	
				break ;
		case POWON2 :						/* 	Power ON State 					*/
				PowOn2() ;
				break ;
		case POWSPOFF : 					/*	Power ON SP Relay OFF			*/
				PowSpOff() ;
				break ;
		case PACOFF :						/* 	AC power off state 				*/
				PowACOff() ;
				break ;
		case PRESET :						/* 	Soft Reset state				*/
				PowSoftReset() ;
				break ;
		default: 
				PowSoftReset() ;
				break;
	}
	return;
	
	
	
	
}

/********************************************************************************/
/*		INITIAL process														  	*/
/********************************************************************************/
static void 	PowInitial( void )
{
	if( Is10msATimeOver( &pow_time ) ){
		if (Power.Flag.PowOn){					/* power on? 					*/
			pow_time = _500mS;
			P_POWRLY = ON;						/* power relay on 				*/
			P_12V_TRIG_OUT = ON;
			PowStt = POWAIT;					/* waiting 						*/
		}
		else {									/* power off 					*/
			PowStt = POFFLP ;
		}
	}
}

/********************************************************************************/
/*		POWER OFF process													  	*/
/********************************************************************************/
static void 	PowOff( void )
{
	if( Power.Flag.PowOn ){						/* power on? 					*/
		PowStt = PRESET ;						/* Power Reset Process			*/
	}
	else {
/*		waiting power off */
	}
}

/********************************************************************************/
/*		waiting process														  	*/
/********************************************************************************/
static void PowWait( void )
{
	if( Is10msATimeOver( &pow_time ) ){
		EventExecute(EV_POWERONSTART,FALSE);	/* power on start event execute	*/
		pow_time = _4sec;						/* 4s set 						*/
		PowStt = POWON1;						/* pow_status = PowOn			*/
		if( Bak.Init & _BACK_CLOF ){
			PowStt = PCLROFF;					/* pow_status = PowClearOff		*/
/*			PowWork.Pclr = ON;					/* Key Event disable			*/
			pow_time = _2sec;					/* 2s set 						*/
		}
	}
}

/********************************************************************************/
/*		POWER OFF AFTER ALL CLEAR											  	*/
/******static void PowClrOff( void )
**************************************************************************/
static void PowClrOff( void )
{
	if (Power.Flag.PowOn == OFF){					/* Main or R2nd or R3nd Power	*/
		PowStt = POWSPOFF;
		pow_time = _100mS;
	}else{										/* Power ON						*/
		if(!Bak.Buzy){
			if(Is10msATimeOver( &pow_time )) {
				EventExecute(EV_POWEROFF,FALSE);/* power off event execute	*/
			}
		} else {
			pow_time = _2sec;
		}
	}

}

/********************************************************************************/
/*		POWER ON1 process													  	*/
/********************************************************************************/
static void PowOn1( void )
{
	if (Power.Flag.PowOn == OFF){					/* Main or R2nd or R3nd Power	*/
		AllRyOff() ;							/* Relay OFF					*/
		AllLedOff();
		PowStt = POWSPOFF ;
		pow_time = _100mS;
	} else {									/* Power ON						*/
		if( Is10msATimeOver( &pow_time )){
			PowStt = POWON2		;				/* 								*/
		}
		if (pow_time < _2sec){
			ALL_MUTE_OFF;						/* c/m for request of Mute release 2sec before spk relay on */
		}
	}
}

/********************************************************************************/
/*		POWER ON2 process													  	*/
/********************************************************************************/
static void PowOn2( void )
{
	if (Power.Flag.PowOn == OFF){				/* power off? 					*/
		PowStt = POWSPOFF ;
		pow_time = _100mS;
		ALL_MUTE_ON;		
	} else {									/* Power ON						*/
		SpeakerRelayControl();					/* Speaker Realy Control 		*/
		if(!P_PROTCT ){						
			PowStt = PRTCON;					/*								*/
			PowWork.Prtc = ON;					/* protector flag on			*/
			pow_time = _100mS;
			prot_time = CLEAR;
		}		
	}
}

/********************************************************************************/
/*		Speaker OFF -> Power OFF process									  	*/
/********************************************************************************/
static void PowSpOff( void )
{
	if(Is10msATimeOver(&pow_time)){				/* Stop signal Time Over		*/
		AllRyOff() ;							/* Relay Off					*/
		AllLedOff();
		ALL_MUTE_ON ;							/* Mute ON						*/
		P_POWRLY = OFF;							/* No need power relay 			*/	/* power relay off 				*/
		P_12V_TRIG_OUT = OFF;			
		PowStt = POFFLP ;
	}
}


/********************************************************************************/
/*		Protector process													  	*/
/********************************************************************************/
static void PowProtector( void )
{												/* Relay Off					*/
	if(Is10msATimeOver(&pow_time)){
		AllRyOff() ;	/* Stop signal Time Over		*/
	}
	if( Power.Flag.PowOn == OFF ){
		PowStt = PRESET;						/* Soft Reset state				*/
	}
}
/********************************************************************************/
/*		AC OFF STOP check process											  	*/
/********************************************************************************/
static void PowACOff( void )
{
	if (P_STOP==LOW){
		pow_time = _20mS ;
		F_STDBYLED = OFF;
		P_SIRCS_OUT = OFF;
		SirCarrierStop(); 						/* Stop Carrier					*/
	}else
		if (Is10msATimeOver(&pow_time)){		/* Power Time Over				*/
			PowStt = PRESET ;					/* Soft Reset state				*/
	}
}

/********************************************************************************/
/*		Soft Reset check process											  	*/
/********************************************************************************/
static void PowSoftReset(void)
{
	if (Is10msATimeOver(&pow_time2) || IsBakSearchFinished()){	/* Eeprom Check	*/
		BakSearchReqCancel();					/* Search   Cancel				*/
		SOFTWARE_RESET;							/* software reset				*/
	}
}

/********************************************************************************/
/*		Speaker Relay All Off								  				    */
/********************************************************************************/
static void AllRyOff(void)
{
	F_RLY_SP = OFF;
	return;
}

/********************************************************************************/
/*		LED All Off											  				    */
/********************************************************************************/
static void AllLedOff(void)
{
	F_OPERTLED = CLEAR;
    F_PROTRLED = CLEAR;
	return;
}
/********************************************************************************/
/* FUNCTION NAME: ProcessControl(void)										  	*/
/* PURPOSE: power process control											  	*/
/********************************************************************************/
static void SpeakerRelayControl(void)
{
	F_RLY_SP = ON;
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	SirExIntEnable											  						
/* PURPOSE		:	Sircs External Interrupt Enable c/m for stop in when sircs is sending			 				  						
/* INPUT		:	None													  						
/* RETURN VALUE	:	None													  						
/****************************************************************************************************/
void StopExIntEnable(void)
{
	EIC2.BYTE 	= 0x05;				/* Interrupt Enable : P_STOP(INT12,IRQ1) 	*/
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	StopExIntDisable											  						
/* PURPOSE		:	Stop In External Interrupt Enable			 				  						
/* INPUT		:	None													  						
/* RETURN VALUE	:	None													  						
/****************************************************************************************************/
void StopExIntDisable(void)
{
	EIC2.BYTE 	= CLEAR;			/* Interrupt Disable : P_STOP(INT12,IRQ1) 	*/
	return;
}

/****************************************************************************************************/
/* FUNCTION		:	StopIn											  						
/* PURPOSE		:	Stop In Interrupt		 				  						
/* INPUT		:	None													  						
/* RETURN VALUE	:	None													  						
/****************************************************************************************************/
__interrupt void StopIn(void)
{
	IDSwitch.Test = OFF;			/* Test mode OFF		 					*/
	P_SIRCS_OUT = OFF;
	SirCarrierStop();				/* Stop Carrier								*/
	return;
}

/********************************************************************************/
/*		Power Status Read														*/
/********************************************************************************/
unsigned char PowStatus(void)
{
	if(PowStt == POWON1){	return TRUE;	}
	if(PowStt == POWON2){	return TRUE;	}
	if(PowStt == POFFLP){	return TRUE;	}
	if(PowStt == PRTCON){	return TRUE;	}
	if(PowStt == PCLROFF){	return TRUE;	}
	return FALSE;
}

unsigned char PowStatusTest(void)
{
	if(POW_ACTIVE == OFF){	
		return FALSE;	/* c/m for stop in					*/	
	}
	if(PowStt == POWON1){	return TRUE;	}
	if(PowStt == POWON2){	return TRUE;	}
	if(PowStt == POFFLP){	return TRUE;	}
	return FALSE;
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -