keyhd.bak

日本FAMILY按摩椅W-1用的配套操作器程序。带VFD显示

//*******************************************************
//*														*
//*		REMOCON OF MASSAGE MACHINE FOR FAMILY			*
//*														*
//*					DEVICE : uPD784218					*
//*														*
//*						Copyright (C) 2000 FAMILY    	*
//*														*
//*******************************************************
//*					KEY HANDLER							*
//*******************************************************
#pragma		sfr
#pragma		nop
#include	<stdio.h>
#include	<string.h>
#include	"key_hl.h"
#include	"slcd.h"
#include    "test.h"
#define		FT_UP	0x23
#define		FT_DN	0x29
#define		RCL_UP	0x22
#define		RCL_DN	0x28
#define     FT_LONG 0x24
#define     FT_SHORT 0x2a
#define     CONTROLLER_TEST_CODE 0x38
#define     PACK_CODE            0x39

//#define     STOP_PORT P3

//*******************************************************
//		function prototype
//*******************************************************
void	Key_hd( void );
void	Key_scan( void );
int	Kh_chk( void );
int	Key_con( void );
void	Kh_rpt( void );
void	Wait_100us(void);
//*******************************************************
//		key scan handler
//*******************************************************

void	Key_hd( void )
    {

/** debug **/
//	unsigned char work;
//
//	work = P10;
//	work ^= 0x08;
//	P10 = work;
/** debug end **/
	Key_scan();                     /*only design which column*/
	if( key_tmr != 0 )              /*key_tmr is key process cycle timer*/
    {
		key_tmr--;
	}
	else
	{
		key_tmr = KEY_TM;          /*key_tm=9*/
		if( Kh_chk() == 0 )     
        {			               /* KEY PRECESS */
			Kh_con();
		}
		Kh_rpt();
	    }
    }


//*******************************************************
//		key scan process
//*******************************************************
void 	Key_scan(void)
{
	char	i;
	unsigned char out_type , work;
	for( i = 0 ; i < 8 ; i++ )
    {							
		swimage2[i] = swimage1[i];                   /*swimage0:       ds	8	; now key data*/
                                                     /*_swimage1:      ds	8	; last time key data*/
                                                     /* swimage2:      ds	8	; two time before key data*/
                                                     /* _fiximage:     ds	8	 ; fix key data  */
		swimage1[i] = swimage0[i];
    }

	out_type = 0x01 ;
	for( i = 0 ; i < 6 ; i++ )
    {
		work = out_type ^ 0xff;
		KS_PORT = work;                             /*define ks_port P9*/
		Wait_100us();	
		out_type <<= 1;
		swimage0[i] = KR_PORT ^ 0xff;		        /*define kr_port p12*/	
	
		swimage0[6] = (STOP_PORT^0xff)  & 0x80;   		
		if(i==0)
		     swimage0[7] = (DSW_PORT ^ 0xff) & 0x40;		/* define DSW_PORT P0*/	
		
    }
	KS_PORT = 0xff;
}	


//*******************************************************
//		key fix check
//*******************************************************

int	Kh_chk( void )
{
	char i;
	int  j;
	j = 0;
	for( i = 0 ; i < 8 ; i++ )
    {
		if(( swimage0[i] != swimage1[i] ) ||(swimage1[i] != swimage2[i] ))
        {
				j = -1;
		}
	}
	if( j == 0 )
    {
		
		OLD_DOOR_F = DOOR_F;         //DOOR_F=1 : DOOR CLOSE
		for( i = 0 ; i < 8 ; i++ )
        {
			fiximage[i] = swimage0[i];
		}
	 }
	return(j);
}


//*******************************************************
//		key code convert
//*******************************************************

int		Kh_con( void )
{

	unsigned char	key , i;
	unsigned char work;
	unsigned char test_key ;
	key = 0;
	test_key = 0 ;
	for( i = 0 ; i < 6 ; i++ )
 	{	
 		if( fiximage[i] != 0 )
        {
			if( key == 0 )
            {
				key = i * 8;
				switch( fiximage[i] )
                {
					case 0x80:
								key++ ;
					case 0x40:
								key++ ;
					case 0x20:
								key++ ;
					case 0x10:
								key++ ;
					case 0x08:
								key++ ;
					case 0x04:
								key++ ;
					case 0x02:
								key++ ;
					case 0x01:
								key++ ;
								break;
//					case TEST_PT:           /*define TEST_PT 0X24*/
//                                                                   
//								if(( i == 0 ) && ( DOOR_F != 0 )) 
//                               {
//									    key = TEST_CODE;        /*define TEST_CODE 0x52*/
//								}
//								else
//                              {
//									    key = 0x0f0;
//								}
//								break;
					default:
								key = 0x0f0;			/* MULT KEY */
				}
		    }
            else 
            {
				if(DOOR_F != 0) 
				{
					if(fiximage[i] == 0x08)
                       
					{
						if((key == RCL_UP) && ( i == 5))
                        {
						    if(keyvld == (RCL_DN + 0x2d))                          
							    key = RCL_DN;       /*22*/ 					    
						    else
							    key = RCL_UP;       /*1a*/	    
					    }
					}
				   else if(fiximage[i]== 0x10)
				   {
					    if((key == FT_UP) && (i == 5))     /*define FT_UP 0x02*/
                        {
						   if(keyvld == (FT_DN + 0x2d))   /*define FT_DN 0x0a*/
							   key = FT_DN ;
						   else
   							   key = FT_UP;
					    }
				   }
				   else if(fiximage[i] == 0x20)
				   {
					    if((key == FT_LONG)&&(i == 5))
						{
						   if(keyvld == (FT_SHORT +0x2d))
							 key = FT_SHORT ;
						 else
							 key = FT_LONG;
						}
				   }
			       else
						key = 0x0f0;
					     
			    }
				else if(DOOR_F == 0)
				{
					if(fiximage[i] == 0x08)    
					{
						if((key == RCL_UP) && ( i == 5))
                        {
						    if(keyvld == RCL_DN )                          
							    key = RCL_DN;       /*22*/ 					    
						    else
							    key = RCL_UP;       /*1a*/	    
					    }
					}
				   else if(fiximage[i]== 0x10) 
				   {
					    if((key == FT_UP) && (i == 5))     /*define FT_UP 0x02*/
                        {
						   if(keyvld == FT_DN)   /*define FT_DN 0x0a*/
							   key = FT_DN ;
						   else
   							   key = FT_UP;
					    }
				   }
				   else if(fiximage[i] == 0x20)
				   {
					    if((key == FT_LONG)&&(i == 5))
						{
						   if(keyvld == FT_SHORT)
							 key = FT_SHORT ;
						 else
							 key = FT_LONG;
						}
				   }
			       else
						key = 0x0f0;
					     
			    }
					
		    }
	    }                   /*fixamige[i]!=0 end*/	
	}                       /*fir(i=0;i<6;i++)loop end*/
	   
//*********************** test  start*******************************
	    if (DOOR_F != 0 )
	    {
	    	// controller test start
	    	if ((fiximage[0] == 0x08)&& (fiximage[1] == 0x10 ))
	    	{
	    		key = CONTROLLER_TEST_CODE ;
	 //   		return (key) ;
	    	}
	    	// controller test end
	    	
	    	// pack start
	    	if ((fiximage[0] == 0x20)&& (fiximage[1] == 0x08 ))
	    	{
	    		key = PACK_CODE ;
	  //  		return (key) ;
	    	}
	    	//pack end 
	    }
//******************************test end****************************	
	if( key == 0 )
    {
		KEYERRF = 0;
	}
	if(STOP_F == 1)
	{
		key = STOP_CODE;		/*define STOP_CODE 0x5b*/
		test_area = P45_AREA;
    }			
	if( key >= 0x0f0 )
    {
		KEYERRF = 1;
		key = 0;
	}
	else if(( key > 0 ) && ( key < STOP_CODE ))
    {   
        test_area = key ;
		if( DOOR_F != 0 )              /*door close*/
        {
            
			key += 0x38 ;	
		}
	}
	if(KEYERRF == 1)
    {
		key = 0;
	}
	keynew = key ;									
	if( keynew != keyvld )               /*keyvld is now key code*/
     {
		if( keynew == NOKEY )            /*0x00*/
         {
			keyold = keyvld ;
			keyvld = NOKEY ;
			key_sys &= KEY_OFF_SYS ;     /*only remain KEYERRF*/
			
		 }
		else
        {
			keyvld = keynew ;
			key_sys |= KALL_FLG_SET ;     /*define KALL_FLAG_SET 0X37*/
			key_sys &= KEY_ON_SYS ;       /*define key_on_sys 0x85*/
		}
	 }
	 
	return(key);
}


//*******************************************************
//		key repeat process
//*******************************************************

void	Kh_rpt( void )
{

	      if( KRPREQF == 1 )      /*krpreqf is key repeat request flag*/
          {
		     if( kreptmr == 0 )
             {
			  KEYREQF = 1 ;        /*key  request flag*/
			  KREPTF = 1 ;         /*key repeat flag*/
		     }
		     else
             {
			     kreptmr-- ;
		     }
	      }
}

//*******************************************************
//		wait process (100us)
//*******************************************************

void	Wait_100us( void )
{
	int	i;
	for( i = 0 ; i < TM100US ; i++);
}