keypad.c

指纹识别源代码,用于智能门紧,还有配合MF800卡使用

#include "reg58.h"
#include "intrins.h"

#define _KEYPAD_C_
#include "keypad.h"
#include "lcd.h"
#include "define.h"
#include "rxd.h"
#include "373.h"
#include "timer.h"
#include "system.h"
#include "finger.h"
#include "event.h"
#include "setup.h"
#include "sram.h"
#include "user.h"
#include "ts.h"
#include "inout.h"


bit idinflag,passinflag,keydownflag;
unsigned char idata keybuff[8];
unsigned char data keynumber,keycounter,keyinputtimer;
unsigned char data keytype,cardnumhigh;
//unsigned char xdata password[2];
//bit keyackflag,keypackflag;
//////////////////////////////////////////////////////////////////////////
void numberfun()
{


	//if(key>NUMBER9)return;
	//beepon();
	keyinputtimer=timerh;		//fresh the keyinputtimer,

	if(setflag)
	{
		switch (setupitem)
		{
			case SETMODE:setmode( );break;
			case SETTIME:settime( );break;
			case SETAPB:setapb( );break;
			case SETCOMMID:setcommid( );break;
			case SETDURESS:setduress( );break;
			case SETDURESSPW:setduresspw( );break;
			case SETBAUDRATE:setbaudrate( );break;
			case SETEVENTCLEAR:seteventclear( );break;
			case SETMASTERCHANGE:setmasterchange( );break;
			case SETSYSINIT:setsysinit( );break;
			case SETCLEARID:setidclear( );break;
			case SETCLEARTS:settsclear( );break;
			case SETKEYIN:setkeyin( );break;
			case SETTS:setts( );break;
			case SETHOLDEF:setholdef( );break;
			case SETIODEF:setiodef( );break;
			case SETHOLINDEX:setholindex( );break;
			case SETMODEINDEX:setmodeindex( );break;
			case SETIDREGISTER:setidregister( );break;
			case SETIDDELETE:setiddelete( );break;
			case SETIDLIST:setidlist( );break;
			case SETIDCOUNT:setidcount( );break;
			case SETEVENTCOUNT:seteventcount( );break;
			case SETFWVER:setfwver( );break;
			case SETRAMTEST:setramtest( );break;
			case SETOUTTEST:setouttest( );break;
			case SETLCDTEST:setlcdtest( );break;
			case SETKEYTEST:setkeytest( );break;
			case SETREADERTEST:setreadertest( );break;
			case SETINTEST:setintest( );break;
			case SETMASTERPASS:setmasterpass( );break;
			case SETTYPE:settype();break;
			case SETCOMMTEST:setcommtest();break;
			case SETPOWERINITPASS:setpowerinitpass();break;
			default: break;

		}
	}
	else if(idinflag)
	{
		if(keycounter<MAXUSERIDLEN)
		{
			keybuff[keycounter]=keynumber;
			keycounter++;
		}
	}
	else if(passinflag)
	{
		keybuff[keycounter]=keynumber;
		keycounter++;
		if(keycounter>=4)
		{
			passinflag=0;
			keybuff[0]=(keybuff[0]<<4)+keybuff[1];
			keybuff[1]=(keybuff[2]<<4)+keybuff[3];
			
			if((keybuff[0]!=tempbuff[12])||(keybuff[1]!=tempbuff[13]))
				accessevent(eventtype|MESSAGEPASSWORDERR);
			else 
				//accessevent(EVENTKEYPAD|ACCESSGRANTED);
				accessok();
 		}
	}
	else
	{
		if(!idinflag)
		{
			//duressflag=0;
			idinflag=1;
			keycounter=1;
			keybuff[0]=keynumber;
		}
	}
	//set_373(BELLRELAY);			//start a 100ms's beep
}
/////////////////////////////////////////////////////////////////////////////////
void cancelfun()
{
	if(idinflag||passinflag)
	{
		idinflag=0;
		passinflag=0;
		keycounter=0;
		//displaymessage(LMMAIN,LINE1);
		displayMain();
		displaytime();
	}
	else if(setflag)
	{
	
	}
}
/////////////////////////////////////////////////////////////////////////////////
void getidfromkeybuff()
{
			tempbuff[0]=0;
			tempbuff[1]=0;
			tempbuff[2]=0;
			tempbuff[3]=0;
			tempbuff[4]=0;
			tempbuff[5]=0;
			tempbuff[6]=0;
			tempbuff[7]=0;

			idata2idata(keybuff,tempbuff+8-keycounter,keycounter);

			userid[0]=(tempbuff[0]<<4)+tempbuff[1];
			userid[1]=(tempbuff[2]<<4)+tempbuff[3];
			userid[2]=(tempbuff[4]<<4)+tempbuff[5];
			userid[3]=(tempbuff[6]<<4)+tempbuff[7];

}
/////////////////////////////////////////////////////////////////////////////////
void checkthrough()
{
	unsigned char secumode;
	//struct userdata idata* puserdata;

	secumode =readsecumode();
	if(secumode==IDONLY)accessok();//accessevent(EVENTKEYPAD|ACCESSGRANTED);
	else if(eventtype==EVENTREADER2)accessok();
	else 
	{
		if((tempbuff[15]&0xf)&&readfpmode())
		{
			if(captureandmatchuser())
			{
				if((secumode==IDFP)||(secumode==FPONLY))
				{
					accessok();
				}
				else
				{
					displaymessage(LMBLANK,LINE1);
					displayuserid();
					displaymessage(LMINPUTPASS,LINE2);
					passinflag=1;
					keycounter=0;
				}
			}
			else
			{
				//access event fp error
				accessevent(eventtype|MESSAGEFINGERERR);
			}
		}
		else
		{
			displaymessage(LMBLANK,LINE1);
			displayuserid();
			displaymessage(LMINPUTPASS,LINE2);
			passinflag=1;
			keycounter=0;
		}
	}
}
////////////////////////////////////////////////////////////////////////////
void enterfun()
{
		//unsigned short userid;
		unsigned short duresspw;
		unsigned char tempdata;
		unsigned short tempsn;


 //  	beepon();
	keyinputtimer=timerh;		//fresh the keyinputtimer,

	if(idinflag)
	{
	
		if(keycounter<MINUSERIDLEN)
		{
			idinflag=0;

			if(keycounter==2)
			{
				if(readduress())
				{
					duresspw=readduresspw();
					if((keybuff[0]==duresspw/10)&&(keybuff[1]==duresspw%10))duressflag=1;					
				}
			}
			keycounter=0;
		}
		else if(keycounter<=MAXUSERIDLEN)
		{
			//for(i=0;i<8;i++)tempbuff[i]=0;
			eventtype=keytype<<5;
			getidfromkeybuff();
			
			if(checkismaster())
			{
				clearsetup();
				masterpassdisp();
				passinflag=1;
				keycounter=0;
			}

			else
			{
				if(!getuserbyid())
					accessevent(eventtype|MESSAGEDENIED);
				else
				{
					tempdata=(tempbuff[15]>>4);
					if(!tempdata)
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if((tempdata==INONLY)&&(eventtype>=2))
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if((tempdata==OUTONLY)&&(eventtype<2))
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if(checkts())
					{
						checkthrough();
					}
					else
					{
					}
				}
			}
		}
		idinflag=0;
		keycounter=0;
	}
	else		//press enter and check finger
	{
		if(readfpmode())
		{
			if(readsecumode()==FPONLY)
			{
				if(captureandfinduser())
				{
					tempsn=uart0buff[PAFIMPARAM+1]<<8;
					tempsn+=uart0buff[PAFIMPARAM];

					readuserdata(tempsn);
					userid[0]=tempbuff[8];
					userid[1]=tempbuff[9];
					userid[2]=tempbuff[10];
					userid[3]=tempbuff[11];
					eventtype=EVENTKEYPAD;

					tempdata=(tempbuff[15]>>4);
					if(!tempdata)
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if((tempdata==INONLY)&&(eventtype>=2))
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if((tempdata==OUTONLY)&&(eventtype<2))
					{
						accessevent(eventtype|MESSAGEDOORERR);
					}
					else if(checkts())
					{
						accessok();
					}
					else
					{
					}
				}
				else
				{
					userid[0]=0xff;
					userid[1]=0xff;
					userid[2]=0xff;
					userid[3]=0xff;
					accessevent(EVENTKEYPAD|MESSAGEDENIED);
				}
			}
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////
void function1()
{
	if(setflag)
	{
	
		if(submenuflag)
		{
			if(setupitem==SETKEYTEST)setkeytest();
			return;
		}
		if((setupitem!=SETMASTERPASS)&&(setupitem!=SETPOWERINITPASS))
			setmodedisp();
		//setmode(0xff);
	}
	else
	{
		dispbuff[0][12]='[';
		dispbuff[0][13]='F';
		dispbuff[0][14]=0x31;
		dispbuff[0][15]=']';
		display(LINE1);
		ram_writep0(FUNCTIONS,0);
	}
}
/////////////////////////////////////////////////////////////////////////////////
void function2()
{
	if(setflag)
	{
		if(submenuflag)
		{
			if(setupitem==SETKEYTEST)setkeytest();
			return;
		}
		if((setupitem!=SETMASTERPASS)&&(setupitem!=SETPOWERINITPASS))
			settsdisp();
	
	}
	else
	{
		dispbuff[0][12]='[';
		dispbuff[0][13]='F';
		dispbuff[0][14]=0x32;
		dispbuff[0][15]=']';
		display(LINE1);
		ram_writep0(FUNCTIONS,1);
		//setflag=1;
		//submenuflag=0;
		//settsdisp();
	}
}
/////////////////////////////////////////////////////////////////////////////////
void function3()
{
	if(setflag)
	{
		if(submenuflag)
		{
			if(setupitem==SETKEYTEST)setkeytest();
			return;
		}
		if((setupitem!=SETMASTERPASS)&&(setupitem!=SETPOWERINITPASS))
			setidregisterdisp();

	}
	else
	{
		dispbuff[0][12]='[';
		dispbuff[0][13]='F';
		dispbuff[0][14]=0x33;
		dispbuff[0][15]=']';
		display(LINE1);
		ram_writep0(FUNCTIONS,2);
	}
}
/////////////////////////////////////////////////////////////////////////////////
void function4()
{
	if(setflag)
	{
		if(submenuflag)
		{
			if(setupitem==SETKEYTEST)
			{
				setkeytest();				
			}
			return;
		}
		if((setupitem!=SETMASTERPASS)&&(setupitem!=SETPOWERINITPASS))
			setfwverdisp();

	}
	else
	{
		dispbuff[0][12]='[';
		dispbuff[0][13]='F';
		dispbuff[0][14]=0x34;
		dispbuff[0][15]=']';
		display(LINE1);
		ram_writep0(FUNCTIONS,3);
	}
}
/////////////////////////////////////////////////////////////////////////////////
void delay60ms()
{
	delayTimerl(T20MS);
	delayTimerl(T20MS);
	delayTimerl(T20MS);
}
/////////////////////////////////////////////////////////////////////////////////
void keyfun()
{
	if(keynumber<NULLKEY)
	{
		set_373(BEEPPORT);
		delay60ms();
		clr_373(BEEPPORT);
		switch(keynumber)
		{
		case NUMBER0:
		case NUMBER1:
		case NUMBER2:
		case NUMBER3:
		case NUMBER4:
		case NUMBER5:
		case NUMBER6:
		case NUMBER7:
		case NUMBER8:
		case NUMBER9:numberfun();break;
		case CANCEL:
			if(setflag)
			{
				numberfun();break;
			}
			else
			{
				cancelfun();break;
			}
		case ENTER:
			if(setflag)
			{
				numberfun();break;
			}
			else
			{
				if(readpinkeyin())enterfun();
				//enterfun();
				break;
			}
		case FUNCTION1:function1();break;
		case FUNCTION2:function2();break;
		case FUNCTION3:function3();break;
		case FUNCTION4:function4();break;
		}
	}
}
/////////////////////////////////////////////////////////////////////////////////
bit checkismaster()
{
	if(!readmasterchange())
	{
		if(userid[0])return FALSE;
		if(userid[1])return FALSE;
		if(userid[2])return FALSE;
		if(userid[3])return FALSE;

		return TRUE;
	}
	else
	{

		readuserdata(MASTERUSERSN);
		if(tempbuff[8]!=userid[0])return FALSE;
		if(tempbuff[9]!=userid[1])return FALSE;
		if(tempbuff[10]!=userid[2])return FALSE;
		if(tempbuff[11]!=userid[3])return FALSE;

		return TRUE;
	}
}
/////////////////////////////////////////////////////////////////////
bit checkts()
{
	unsigned char holindex,i,typeofday;

	if(tempbuff[14]&0xf)
	{
		holindex=readholindex((tempbuff[14]&0xf)-1);
		if(!holindex)
		{
			typeofday=datetime[DTWEEK];
		}
		else
		{
			//holiday--;
			holindex--;
			for(i=0;i<32;i++)
			{
				getholdata(holindex*32+i);
				if((datetime[DTMON]==tempbuff[0])&&(datetime[DTDAY]==tempbuff[1]))break;
			}

			if(i<32)typeofday=0;		//today is holiday
			else	typeofday=datetime[DTWEEK];
		}	

		holindex=((tempbuff[14]&0xf)-1)*40+typeofday*5;

		for(i=0;i<5;i++)
		{
			gettsdata(holindex+i);

			
			if(datetime[DTHUR]<tempbuff[0])continue;
			if((datetime[DTMIN]<tempbuff[1])&&(datetime[DTHUR]==tempbuff[0]))continue;
			
			if(datetime[DTHUR]>tempbuff[2])continue;
			if((datetime[DTMIN]>=tempbuff[3])&&(datetime[DTHUR]==tempbuff[2]))continue;
			break;
		}
		if(i>=5)
		{
			accessevent(eventtype|MESSAGETSERR);
			//accessok();
			return FALSE;
		}
	}
	holindex=readmodeindex();
	if(holindex)
	{
		holindex=(holindex-1)*40+typeofday*5;
		for(i=0;i<5;i++)
		{
			gettsdata(holindex+i);
			if(datetime[DTHUR]<tempbuff[0])continue;
			if((datetime[DTMIN]<tempbuff[1])&&(datetime[DTHUR]==tempbuff[0]))continue;
			
			if(datetime[DTHUR]>tempbuff[2])continue;
			if((datetime[DTMIN]>=tempbuff[3])&&(datetime[DTHUR]==tempbuff[2]))continue;
			
			break;
		}
		if(i>=5)return TRUE;
		else
	 	{
			//accessevent(eventtype|MESSAGEGRANTED);
			accessok();
			return FALSE;
		}
	}
	else
	{
		return TRUE;
	}
}
////////////////////////////////////////////////////////////////////////////////