key.c

汽车上四车窗升降器：包括电路图与源程序

#ifndef _KEY_C_
#define _KEY_C_


#include "global.h"

//------------------------------------------------------------------------------------
void fScanKeyPort(void)
//------------------------------------------------------------------------------------
// Scan keyboard Routines
// This routine must be called every 10 ms or 5ms.
//------------------------------------------------------------------------------------
{
		//power on 74hcHC4051
		fPowerOnHC4051 ;
 		fDelay(200);
 
		fScanDrMInput();
		fScanDrCtrFPPMInput();
		fScanFPPMInput();
		fScanDrCtrRLPMInput();
		fScanRLPMInput();
		fScanRRPMInput();
		fScanDrCtrRRPMInput();
		fSCanInhibitedInput();

		fPowerOffHC4051 ;			//power off
//		fDelay(200);
		nop();
}










//==============================================================================================//
//								scan  driver signal input										//
//==============================================================================================//


void fScanDrMInput(void)
{
	unsigned char ad_result;

//	fPowerOnHC4051 ;

	fSelectHC4051Channel(HC4051_DrM);

	fItlADC();
	ad_result = fADConverter(AD_HC4051);

				if(ad_result > mNoKey)						 
				{
					if(vDrKeyBouTC++ > mJitter)	
					{	
								bDrMDown = 0;
								bDrMUp = 0;														//nokey	
					
								vDrKeyBouTC--;
								vDrKeyPreUpTC= 0;
								vDrKeyPreDownTC= 0;		

								bDrConPressUp  = 0; 
								bDrConPressDown  = 0; 					
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vDrKeyPreDownTC++  > mJitter)	
						{	
								bDrMDown = 1;													//down	
								bDrMUp = 0;	

								vDrKeyPreDownTC--;
								vDrKeyBouTC = 0;
								vDrKeyPreUpTC= 0;
			
								bDrConPressUp  = 0; 
							}		
					}
					else	
					{
						if(vDrKeyPreUpTC++ > mJitter)	
						{		
								bDrMUp = 1;	
								bDrMDown = 0;	

								vDrKeyPreUpTC--;												//up
								vDrKeyBouTC = 0;
								vDrKeyPreDownTC= 0;

								bDrConPressDown  = 0; 
						}
					}
				}	


//	fPowerOffHC4051 ;
	
}



//==============================================================================================//
//								scan  FP signal input											//
//==============================================================================================//


//scan  FPPM signal input
void fScanFPPMInput(void)
{
	unsigned char ad_result;

//	fPowerOnHC4051 ;
	fSelectHC4051Channel(HC4051_FPM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

				if(ad_result > mNoKey)						 
				{
					if(vFPKeyBouTC++ > mJitter)	
					{	
								bFPMDown = 0;
								bFPMUp = 0;														//nokey	
					
								vFPKeyBouTC--;
								vFPKeyPreUpTC= 0;
								vFPKeyPreDownTC= 0;		

								bFPConPressDown  = 0; 					
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vFPKeyPreDownTC++  > mJitter)	
						{	
								bFPMDown = 1;													//down	
								bFPMUp = 0;	

								vFPKeyPreDownTC--;
								vFPKeyBouTC = 0;
								vFPKeyPreUpTC= 0;

							}		
					}
					else	
					{
						if(vFPKeyPreUpTC++ > mJitter)	
						{		
								bFPMUp = 1;	
								bFPMDown = 0;	

								vFPKeyPreUpTC--;												//up
								vFPKeyBouTC = 0;
								vFPKeyPreDownTC= 0;

								bFPConPressDown  = 0; 
						}
					}
				}	
//	fPowerOffHC4051 ;
//	fDelay(200);
}


//==============================================================================================//
//								scan  DCFP signal input											//
//==============================================================================================//
//scan Dr control FPPM signal input
void fScanDrCtrFPPMInput(void)
{
	unsigned char ad_result;
	
//	fPowerOnHC4051 ;

	fSelectHC4051Channel(HC4051_DCFPM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

	if(ad_result > mNoKey)						 
				{
					if(vDrCtrFPKeyBouTC++ > mJitter)	
					{	
								bDrCtrFPMDown = 0;
								bDrCtrFPMUp = 0;												//nokey	
	
								vDrCtrFPKeyBouTC--;
								vDrCtrFPKeyPreUpTC= 0;
								vDrCtrFPKeyPreDownTC= 0;

								bDrCtrFPConPressDown  = 0; 
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vDrCtrFPKeyPreDownTC++ > mJitter)	
						{			
								bDrCtrFPMDown = 1;												//down
								bDrCtrFPMUp = 0;	
								
						
								vDrCtrFPKeyPreDownTC--;
								vDrCtrFPKeyBouTC = 0;
								vDrCtrFPKeyPreUpTC= 0;
			 			}		
					}
					else	
					{
						if(vDrCtrFPKeyPreUpTC++ > mJitter)	
						{		
								bDrCtrFPMUp = 1;	
								bDrCtrFPMDown = 0;

								vDrCtrFPKeyPreUpTC--;						
								vDrCtrFPKeyBouTC = 0;											//up
								vDrCtrFPKeyPreDownTC= 0;

								bDrCtrFPConPressDown  = 0; 
						}
					}
				}

//		fPowerOffHC4051 ;
//		fDelay(200);

}


//==============================================================================================//
//								scan  RL signal input											//
//==============================================================================================//
//scan  RLPM signal input
void fScanRLPMInput(void)
{
	unsigned char ad_result;

//	fPowerOnHC4051 ;
	fSelectHC4051Channel(HC4051_RLM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

				if(ad_result >  mNoKey)						 
				{
					if(vRLKeyBouTC++ > mJitter)	
					{	
								bRLMDown = 0;
								bRLMUp = 0;														//nokey	
					
								vRLKeyBouTC--;
								vRLKeyPreUpTC= 0;
								vRLKeyPreDownTC= 0;		

								bRLConPressDown  = 0; 					
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vRLKeyPreDownTC++  > mJitter)	
						{	
								bRLMDown = 1;													//down	
								bRLMUp = 0;	

								vRLKeyPreDownTC--;
								vRLKeyBouTC = 0;
								vRLKeyPreUpTC= 0;

							}		
					}
					else	
					{
						if(vRLKeyPreUpTC++ > mJitter)	
						{		
								bRLMUp = 1;	
								bRLMDown = 0;	

								vRLKeyPreUpTC--;												//up
								vRLKeyBouTC = 0;
								vRLKeyPreDownTC= 0;

								bRLConPressDown  = 0; 
						}
					}
				}	
//	fPowerOffHC4051 ;
//	fDelay(200);
}


//==============================================================================================//
//								scan  DCRL signal input											//
//==============================================================================================//
//scan Dr control RLPM signal input
void fScanDrCtrRLPMInput(void)
{
	unsigned char ad_result;
//	fPowerOnHC4051 ;
	fSelectHC4051Channel(HC4051_DCRLM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

	if(ad_result > mNoKey)						 
				{
					if(vDrCtrRLKeyBouTC++ > mJitter)	
					{	
								bDrCtrRLMDown = 0;
								bDrCtrRLMUp = 0;												//nokey	
	
								vDrCtrRLKeyBouTC--;
								vDrCtrRLKeyPreUpTC= 0;
								vDrCtrRLKeyPreDownTC= 0;

								bDrCtrRLConPressDown  = 0; 
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vDrCtrRLKeyPreDownTC++ > mJitter)	
						{			
								bDrCtrRLMDown = 1;												//down
								bDrCtrRLMUp = 0;	
								
						
								vDrCtrRLKeyPreDownTC--;
								vDrCtrRLKeyBouTC = 0;
								vDrCtrRLKeyPreUpTC= 0;
			 			}		
					}
					else	
					{
						if(vDrCtrRLKeyPreUpTC++ > mJitter)	
						{		
								bDrCtrRLMUp = 1;	
								bDrCtrRLMDown = 0;

								vDrCtrRLKeyPreUpTC--;						
								vDrCtrRLKeyBouTC = 0;											//up
								vDrCtrRLKeyPreDownTC= 0;

								bDrCtrRLConPressDown  = 0; 
						}
					}
				}
//	fPowerOffHC4051 ;
//	fDelay(200);
}

//==============================================================================================//
//								scan  RR signal input											//
//==============================================================================================//
//scan  RRPM signal input
void fScanRRPMInput(void)
{
	unsigned char ad_result;
//	fPowerOnHC4051 ;
	fSelectHC4051Channel(HC4051_RRM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

				if(ad_result > mNoKey)						 
				{
					if(vRRKeyBouTC++ > mJitter)	
					{	
								bRRMDown = 0;
								bRRMUp = 0;														//nokey	
					
								vRRKeyBouTC--;
								vRRKeyPreUpTC= 0;
								vRRKeyPreDownTC= 0;		

								bRRConPressDown  = 0; 					
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vRRKeyPreDownTC++  > mJitter)	
						{	
								bRRMDown = 1;													//down	
								bRRMUp = 0;	

								vRRKeyPreDownTC--;
								vRRKeyBouTC = 0;
								vRRKeyPreUpTC= 0;

							}		
					}
					else	
					{
						if(vRRKeyPreUpTC++ > mJitter)	
						{		
								bRRMUp = 1;	
								bRRMDown = 0;	

								vRRKeyPreUpTC--;												//up
								vRRKeyBouTC = 0;
								vRRKeyPreDownTC= 0;

								bRRConPressDown  = 0; 
						}
					}
				}	
//	fPowerOffHC4051 ;
//	fDelay(200);
}


//==============================================================================================//
//								scan  DCRR signal input											//
//==============================================================================================//
//scan Dr control RRPM signal input
void fScanDrCtrRRPMInput(void)
{
	unsigned char ad_result;
//	fPowerOnHC4051 ;
	fSelectHC4051Channel(HC4051_DCRRM);
	fItlADC();
	ad_result = fADConverter(AD_HC4051);

	if(ad_result > mNoKey)						 
				{
					if(vDrCtrRRKeyBouTC++ > mJitter)	
					{	
								bDrCtrRRMDown = 0;
								bDrCtrRRMUp = 0;												//nokey	
	
								vDrCtrRRKeyBouTC--;
								vDrCtrRRKeyPreUpTC= 0;
								vDrCtrRRKeyPreDownTC= 0;

								bDrCtrRRConPressDown  = 0; 
					}
				}
				else										
				{	
					if(ad_result > mUpKey)													 
					{
						if(vDrCtrRRKeyPreDownTC++ > mJitter)	
						{			
								bDrCtrRRMDown = 1;												//down
								bDrCtrRRMUp = 0;	
								
						
								vDrCtrRRKeyPreDownTC--;
								vDrCtrRRKeyBouTC = 0;
								vDrCtrRRKeyPreUpTC= 0;
			 			}		
					}
					else	
					{
						if(vDrCtrRRKeyPreUpTC++ > mJitter)	
						{		
								bDrCtrRRMUp = 1;	
								bDrCtrRRMDown = 0;

								vDrCtrRRKeyPreUpTC--;						
								vDrCtrRRKeyBouTC = 0;											//up
								vDrCtrRRKeyPreDownTC= 0;

								bDrCtrRRConPressDown  = 0; 
						}
					}
				}
//	fPowerOffHC4051 ;
//	fDelay(200);
}



void fProcessKeyEnter(void)
{

// I H B
	fIHBKeyProcess();
//Dr vehicle Win M
	fDrWinProcess();
//F P vehicle M
	fFPWinProcess();
//R L P Vehicle M
 	fRLWinProcess();
//R R P Vehicle M
	fRRWinProcess();
}





void fDrWinProcess(void)
{
	if(!bIGNIsOk||bBatterIsHightVolt||bBatteryIsLowVolt||bEnDrLRTC)
	{
		bDrMDown = 0;
		bDrMUp = 0;
    	bDrMAutoUp = 0;
    	bDrMAutoDown = 0;
	}
	
 


	if(bDrMDown)
	{	if(vDrKeyPreDownTC++ > mAutoThresholdTime)
		{			
			vDrKeyPreDownTC--;
			bDrMAutoDown = 1;												//autoDown
			bDrConPressDown = 1;
		}
	}	

	if(bDrMUp)
	{	if(vDrKeyPreUpTC++ > mAutoThresholdTime)
		{			
			vDrKeyPreUpTC--;
			bDrMAutoUp = 1;													//autoup
			bDrConPressUp = 1;
		}
	}


//driver auto, then driver press the key = stop,
	if( ( bDrMAutoDown || bDrMAutoUp ) && ( bDrMDown && !bDrConPressDown ||  bDrMUp && !bDrConPressUp ))  
	bDrLock = 1;


	if (!bDrMDown && !bDrMUp)
	bDrLock = 0;

 //fall
	if ( !bDrMDown && !bDrMUp && bDrMAutoDown && !bDrLock ||  bDrMDown && !bDrLock ) 
	   
	{
		if(bDrMED & !bDrMDR)
		return; 
	
		bDrMStop = 0;