power.c

一款新开发的

//2006-7-3
#include "pic.h"
#include "power.h"
#define	MODE_TIME
//#define MODE_AVERAGE
//#define MODE_UNAVERAGE
__EEPROM_DATA(0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00);
__CONFIG(PROTECT&PWRTEN&WDTEN&INTIO&LVPDIS&MCLREN&BOREN);

//#define  	DEBUG

ERom Save;
unsigned int  UserOn=0;
unsigned char SwitchUser;
enum SwitchState {CLOSE_LAMP,WAIT_CLOSE,NEXT_LAMP_ON,DELAY,ACCOUNT};
enum SwitchState State=CLOSE_LAMP;
//unsigned char Count4ms;
unsigned char EleEnergy;
unsigned char RestTimes;
unsigned char SwitchCount=0;
//volatile unsigned char DelayTimeCount;
TimerStruct DelaySwitch={0,0,0};
TimerStruct DelayReadWork={0,0,0};
unsigned long Hour_1_Time=TIMEBEGIN;

unsigned char Count1000ms=250;
/*
unsigned char  fWorkMode;
unsigned char  fTimeOut12ms;
unsigned char  fChangeSwitch;
unsigned char  fUnKnown;
unsigned char  fSaveEnergy;
unsigned char  fBeginDelay;
unsigned char  fDELAY_TimeOut=0;
*/

bit SystemWdt;
bit  fWorkMode;
bit  fTimeOut12ms;
bit  fChangeSwitch;
bit  fUnKnown;
bit  fSaveEnergy;
//bit  fBeginDelay;
//bit  fDELAY_TimeOut=0;

//bit fBegin2000ms=0;
bit fDelay2000ms=0;
//unsigned int Time2000ms;

void short_delay(unsigned char DelayTime)
{
	for(;DelayTime!=0;DelayTime--){}
}

void init_io(void)
{	
	CMCON=0x07;
	TRISA=0x30;
	TRISB=0x01;
}

void write_eeprom(unsigned char addr, unsigned char value)
{
	//do
	//{
		eeprom_write(addr, value);
		//while(WR){;}
	//}
	//while(eeprom_read(addr)!=value);
}

void init_time(void)
{
	//time0 for 4ms 
	T0CS=0;  //time mode
	PSA=0;    //don't use for wdt
	T0IE=1;   //time interrupt enable
	PS2=0;
	PS1=1;
	PS0=1;
}

void init_int(void)
{
	#ifndef	MODE_TIME
	INTEDG=0;
	INTE=1;
	#endif
}

char read_mode(void)
{
	unsigned char SystemTimes;
	char returnValue=1;
	//read eeprom 
	unsigned char eepromValue;
	do
	{
		eepromValue=eeprom_read(ADDR_USERS);
		short_delay(119);
	}while(eepromValue!=eeprom_read(ADDR_USERS));
	Save.Users=eepromValue;
	
	do
	{
		eepromValue=eeprom_read(ADDR_RESTTIMES);
		short_delay(119);
	}while(eepromValue!=eeprom_read(ADDR_RESTTIMES));
	Save.RestTimes=eepromValue;

	#ifdef DEBUG
	do
	{
		eepromValue=eeprom_read(ADDR_MY);
	}while(eepromValue!=eeprom_read(ADDR_MY));
	SystemTimes=eepromValue;
	
		if(SystemTimes>=119){return(0);}
	SystemTimes++;
	write_eeprom(ADDR_MY,SystemTimes);
	#endif

	if(Save.Users>=MAX_USERS)
		Save.Users=0;	
	if(Save.RestTimes>=A_DAY)
		Save.RestTimes=A_DAY;	
	fWorkMode=MODE_IN;
	//Count4ms=3;
	//fTimeOut12ms=0;
	return(returnValue);
}

void mode_deal(void)
{
	if(Save.RestTimes==0){fChangeSwitch=1;}
}

void close_all_lamp(void)
{
	OUT1=OFF;
	short_delay(5);
	OUT2=OFF;
	short_delay(5);
	OUT3=OFF;
	short_delay(5);
	OUT4=OFF;
	short_delay(5);
	OUT5=OFF;
	short_delay(5);
	OUT6=OFF;
	short_delay(5);
	OUT7=OFF;
	short_delay(5);
	OUT8=OFF;
	short_delay(5);
	OUT9=OFF;
	short_delay(5);
	OUT10=OFF;
	short_delay(5);
	OUT11=OFF;
	short_delay(5);
	OUT12=OFF;
}

void lamp_on(unsigned char LampNoub)
{
	switch(LampNoub)
	{
		case 0:OUT1=ON;break;
		case 1:OUT2=ON;break;
		case 2:OUT3=ON;break;
		case 3:OUT4=ON;break;
		case 4:OUT5=ON;break;
		case 5:OUT6=ON;break;
		case 6:OUT7=ON;break;
		case 7:OUT8=ON;break;
		case 8:OUT9=ON;break;
		case 9:OUT10=ON;break;
		case 10:OUT11=ON;break;
		case 11:OUT12=ON;break;
		default:break;
	}
}

void quit_switch(unsigned char Rest,unsigned char User)
{
	di();
	fChangeSwitch=0;
	fSaveEnergy=1;
	State=CLOSE_LAMP;
	Save.RestTimes=Rest;
	Save.Users=User;
	#ifndef MODE_TIME
	INTF=0;
	INTE=1;
	#endif
	ei();
}

void account_user(unsigned CurrentUser)
{
	/*
	unsigned char i,j,k;
	unsigned char temp=0;
	unsigned int  DataUserOn;
	unsigned char DataCount=0,Sum=0;
	
	for(i=CurrentUser;i<OUTALLCHANNELS;i++)
	{
		temp=0;
		bitset(temp,CurrentUser-1);
		if(UserOn&temp)
		{
			Save.Users=CurrentUser;
			for(j=0;j<i;j++)
			{
				DataUserOn=UserOn>>j;
				for(k=0;k<OUTALLCHANNELS;k++)
				{
					//DataUserOn=UserOn;
					if(DataUserOn&0x0001){DataCount++;}
					DataUserOn>>=1;
				}
				Sum+=ALL_TIME/DataCount;
			}
			Save.RestTimes=Sum;
			break;
		}
		else
		{
			if(CurrentUser++==OUTALLCHANNELS){CurrentUser=1;}
		}
	}
	*/
}

void switch_deal(void)
{ 
	unsigned char NextUser;
	static bit SignalOn;
	switch(State)
	{
		case CLOSE_LAMP:
			close_all_lamp();
			State=WAIT_CLOSE;
			break;
		case WAIT_CLOSE:
			if(SIGNALIN)
			{
				short_delay(250);
				if(SIGNALIN)
				{
					State=NEXT_LAMP_ON;
				}				
			}
			break;
		case NEXT_LAMP_ON:
			NextUser=SwitchUser+1;
			if(NextUser>=MAX_USERS){NextUser=0;}
				lamp_on(NextUser);
			di();
			DelaySwitch.TimeOut=0;
			DelaySwitch.en=1;
			ei();
			/*
			DelayTimeCount=TIME500ms;
			fDELAY_TimeOut=0;
			fBeginDelay=1;
			*/
			State=DELAY;
			break;
		case DELAY:
		
			//if(fDELAY_TimeOut)
			//{
				//fDELAY_TimeOut=0;
				//fBeginDelay=0;
				//State=ACCOUNT;
			//}
			if(DelaySwitch.TimeOut)
			{
				DelaySwitch.TimeOut=0;
				State=ACCOUNT;
			}
			break;
		case ACCOUNT:
			if(SIGNALIN)
			{	
				unsigned char i;
				for (i=0;i<10;i++) short_delay(250);
				if(SIGNALIN)
				{
					SignalOn=0;
					bitclr(UserOn,NextUser);
				}
				else return;
			}
			else
			{
				unsigned char i;
				for(i=0;i<10;i++) short_delay(250);
				if(!SIGNALIN)
				{
					SignalOn=1;
					bitset(UserOn,NextUser);
				}
			}
			SwitchCount++;
			if(++SwitchUser>=MAX_USERS){SwitchUser=0;}
   		    #ifdef MODE_AVERAGE 
   				if(SignalOn==1)
				{
					quit_switch(AVERAGE_REST_TIME,NextUser);
				}
				else{State=CLOSE_LAMP;}
			#endif 
			/*
			#ifdef MODE_UNAVERAGE 
				if((SwitchCount>=OUTALLCHANNELS)&&UserOn)
				{
					account_user(Save.Users+1);
					quit_switch(Save.RestTimes,Save.Users);
				}
				else{State=CLOSE_LAMP;}
			#endif
			*/
			#ifdef MODE_TIME
				if(SignalOn==1)
				{
					quit_switch(A_DAY,NextUser);
				}
				else{State=CLOSE_LAMP;}
			#endif
			break;
		default:State=CLOSE_LAMP;break;
	}	
}

void read_work(void)
{
	static unsigned char Step=0;
	if(SIGNALIN)
	{
		switch(Step)
		{
			case 0:
				DelayReadWork.Interval=0;
				DelayReadWork.en=1;
				DelayReadWork.TimeOut=0;
				Step=1;
				break;
			case 1:
				if(DelayReadWork.TimeOut)
				{
					DelayReadWork.TimeOut=0;
					if(SIGNALIN)
					{
						fChangeSwitch=1;
						SwitchUser=Save.Users;
						SwitchCount=0;
						INTE=0;
					}
					Step=0;
				}
				break;
			default:Step=1;break;
		}
		
		/*
		if(DelayReadWork.en)
		{
			if(DelayReadWork.TimeOut)
			{
				DelayReadWork.TimeOut=0;
				if(!SIGNALIN)
				{
					fChangeSwitch=1;
					SwitchUser=Save.Users;
					SwitchCount=0;
					INTE=0;
				}
			}
		}
		else 
		{
			DelayReadWork.en=1;
			DelayReadWork.TimeOut=0;
		}
		*/		
	}
	else Step=0;
}

char Save2Eeprom(ERom SaveData)
{
	write_eeprom(ADDR_USERS,Save.Users);
	CLRWDT();
	write_eeprom(ADDR_RESTTIMES,Save.RestTimes);
	return(1);
}

void unknown_deal(void)
{
}

void main(void)
{
	init_io();
	init_time();
	init_int();
	ei();
	close_all_lamp();
	read_mode();

	lamp_on(Save.Users);
	while(1)
	{
		if(SystemWdt) 
		{
			SystemWdt=0;
			CLRWDT();
		}
		T0IE=1;   //time interrupt enable
		ei();
		if(fChangeSwitch)
		{
			//fChangeSwitch = 0;      		//del
			//quit_switch(A_DAY,1); 		//del
			di();
			//fBegin2000ms=0;
			//Time2000ms=0;
			DelayReadWork.en=0;
			DelayReadWork.Interval=0;
			ei();
			
			switch_deal();
		}
		else
		{
			if(fSaveEnergy)
			{	
				if(Save.RestTimes>A_DAY) 
					Save.RestTimes=A_DAY;		
				fSaveEnergy=0;
				Save2Eeprom(Save);
			}
			read_work();
			if(fUnKnown)
			{
				fUnKnown=0;
				unknown_deal();
			}
		}
		if(Save.RestTimes>A_DAY) 
			Save.RestTimes=A_DAY;
		//RA1=SIGNALIN;
		//
	}

}

void interrupt Int(void)
{
	if(T0IE&&T0IF)
	{
		T0IF=0;	
		//if(!--Count4ms)
		//{
			//fTimeOut12ms=1;
			//Count4ms=3;
		//}
		//if(fBeginDelay)
		//{
			//if(!--DelayTimeCount){fDELAY_TimeOut=1;}
		//}
		SystemWdt=1;
		if(DelaySwitch.en)
		{
			if(DelaySwitch.Interval++>=TIME500ms)
			{
				DelaySwitch.en=0;
				DelaySwitch.Interval=0;
				DelaySwitch.TimeOut=1;
			}
		}
		//if(fBegin2000ms)
		//{
			//if(Time2000ms++>=TIME2000MS)
			//{
				//Time2000ms=0;
				//fDelay2000ms=1;
			//}
		//}
		if(DelayReadWork.en)
		{
			if(DelayReadWork.Interval++>=TIME2000MS)
			{
				DelayReadWork.Interval=0;
				DelayReadWork.en=0;
				DelayReadWork.TimeOut=1;
			}
		}
		if(!--Count1000ms)
		{
			RA1=!RA1;
			Count1000ms=250;
		}
		#ifdef MODE_TIME
			if(Hour_1_Time>TIMEBEGIN) 
				Hour_1_Time=TIMEBEGIN;
			if(--Hour_1_Time==0)
			{
				Hour_1_Time=TIMEBEGIN;
				//Save.RestTimes--;
				fSaveEnergy=1;
				if(--Save.RestTimes==0)
				{
					fChangeSwitch=1;
					SwitchUser=Save.Users;
				}
			}
		#endif
	}
	
	
	if(INTF&&INTE)
	{
		INTF=0;
		#ifndef MODE_TIME
		if(EleEnergy++>=32)
		{
			EleEnergy=0;
			for(j=100;j!=0;j--){}
			if(!POWIN)
			{
				RA1=!RA1;
				fSaveEnergy=1;
				if(!--Save.RestTimes)
				{
					fChangeSwitch=1;
					SwitchCount=0;
					SwitchUser=Save.Users;
					INTE=0;
				}
			}
		}
		#endif
	}
	
}