commswitch.c

此程序为DP256的SPI实验程序,已经通过实验证明

			
			//4. set switch state ok flag
			CmbSwt_stBrush2Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stBrush3Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiBrush3, LIN_GetCurrentTime(), CmbSwt_tiBrush3Debounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stBrush3	= CmbSwt_stBrush3_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nBrush3ErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stBrush3Err &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stBrush3Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stBrush4Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiBrush4, LIN_GetCurrentTime(), CmbSwt_tiBrush4Debounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stBrush4	= CmbSwt_stBrush4_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nBrush4ErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stBrush4Err &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stBrush4Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stTurnLeftErr & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiTurnLeft, LIN_GetCurrentTime(), CmbSwt_tiTurnLeftDebounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stTurnLeft	= CmbSwt_stTurnLeft_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nTurnLeftErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stTurnLeftErr &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stTurnLeftErr	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stTurnRightErr & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiTurnRight, LIN_GetCurrentTime(), CmbSwt_tiTurnRightDebounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stTurnRight	= CmbSwt_stTurnRight_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nTurnRightErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stTurnRightErr &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stTurnRightErr	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stLamp1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiLamp1, LIN_GetCurrentTime(), CmbSwt_tiLamp1Debounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stLamp1	= CmbSwt_stLamp1_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nLamp1ErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stLamp1Err &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stLamp1Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)	
		
//----------------------------------------------------------------------------------------------------

	if((CmbSwt_stLamp2Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiLamp2, LIN_GetCurrentTime(), CmbSwt_tiLamp2Debounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stLamp2	= CmbSwt_stLamp2_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nLamp2ErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stLamp2Err &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stLamp2Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)	
		
//----------------------------------------------------------------------------------------------------
	if((CmbSwt_stLamp3Err & CMBSWT_STATE_DEBOUNCE) == CMBSWT_STATE_DEBOUNCE)
	{
		if(LIN_CheckTimeOut(CmbSwt_tiLamp3, LIN_GetCurrentTime(), CmbSwt_tiLamp3Debounce_C))
		{
			//1. Remember the correct status 
			CmbSwt_stLamp3	= CmbSwt_stLamp3_mp0;
					
			//2. Reset Err Counter
			CmbSwt_nLamp3ErrCntr	= 0;
					
			//3. Clear Debounce Flag
			CmbSwt_stLamp3Err &= ~CMBSWT_STATE_DEBOUNCE;
			
			//4. set switch state ok flag
			CmbSwt_stLamp3Err	|= CMBSWT_STATE_OK;
		}//if((CmbSwt_stBrush1Err & CMBSWT_STATE_ERR) == CMBSWT_STATE_ERR)				
	}//if(LIN_CheckTimeOut(CmbSwt_tiBrush1, LIN_GetCurrentTime(), CmbSwt_tiBrush1Debounce_C))
//----------------------------------------------------------------------------------------------------
}

void MC33993_Data_Received(void)
{
	if(CmbSwt_stBrush1Err	== CMBSWT_STATE_UNKNOWN)
	{
		MC33993_Data_Initial();
	}
	else 
	{
		MC33993_Data_Processing();
	}
}

void	MC33993_Data_Initial(void)
{			
	MC33993_DataIn();
	CmbSwt_tiBrush1		= LIN_GetCurrentTime();
	CmbSwt_stBrush1Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stBrush1Err	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiBrush2		= LIN_GetCurrentTime();
	CmbSwt_stBrush2Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stBrush2Err	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiBrush3		= LIN_GetCurrentTime();
	CmbSwt_stBrush3Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stBrush3Err	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiBrush4		= LIN_GetCurrentTime();
	CmbSwt_stBrush4Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stBrush4Err	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiTurnLeft		= LIN_GetCurrentTime();
	CmbSwt_stTurnLeftErr	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stTurnLeftErr	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiTurnRight		= LIN_GetCurrentTime();
	CmbSwt_stTurnRightErr	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stTurnRightErr	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiLamp1		= LIN_GetCurrentTime();
	CmbSwt_stLamp1Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stLamp1Err	&= ~CMBSWT_STATE_UNKNOWN;

	CmbSwt_tiLamp2		= LIN_GetCurrentTime();
	CmbSwt_stLamp2Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stLamp2Err	&= ~CMBSWT_STATE_UNKNOWN;
			
	CmbSwt_tiLamp3		= LIN_GetCurrentTime();
	CmbSwt_stLamp3Err	|= CMBSWT_STATE_DEBOUNCE;
	CmbSwt_stLamp3Err	&= ~CMBSWT_STATE_UNKNOWN;			
}

void MC33993_Data_Processing(void)
{
	/*
		Switch status input process
		1. get current switch status
		2. compare with the former value
		3. if status changed, remember the new value and start debounce process
	*/
	
	if(SPI_Rx_Buf[CMBSWT_BRUSH1_DATA] & CMBSWT_BRUSH1) 
	{//we get input as 1
		if(CmbSwt_stBrush1_mp0	== 0)
		{//we are in low status, remember this status, start debounce process
			CmbSwt_stBrush1_mp0	= 1;	
			CmbSwt_tiBrush1		= LIN_GetCurrentTime();
			CmbSwt_stBrush1Err	|= CMBSWT_STATE_DEBOUNCE;
		}
		//state has no change, and we do nothing here, the debounce process excuted by function
		//MC33993_Data_Debounce
	}
	else
	{//we got 0 input
		if(CmbSwt_stBrush1_mp0	== 1)
		{//we are in high status, remember this status and start the debounce process
			CmbSwt_stBrush1_mp0	= 0;	
			CmbSwt_tiBrush1		= LIN_GetCurrentTime();
			CmbSwt_stBrush1Err	|= CMBSWT_STATE_DEBOUNCE;
		}
		//state has no change, and we do nothing here, the debounce process excuted by function
		//MC33993_Data_Debounce
	}
						
	if(SPI_Rx_Buf[CMBSWT_BRUSH2_DATA] & CMBSWT_BRUSH2)
	{
		if(CmbSwt_stBrush2_mp0	== 0)
		{
			CmbSwt_stBrush2_mp0	= 1;	
			CmbSwt_tiBrush2		= LIN_GetCurrentTime();
			CmbSwt_stBrush2Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stBrush2_mp0	== 1)
		{
			CmbSwt_stBrush2_mp0	= 0;	
			CmbSwt_tiBrush2		= LIN_GetCurrentTime();
			CmbSwt_stBrush2Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	
	if(SPI_Rx_Buf[CMBSWT_BRUSH3_DATA] & CMBSWT_BRUSH3)
	{
		if(CmbSwt_stBrush3_mp0	== 0)
		{
			CmbSwt_stBrush3_mp0	= 1;	
			CmbSwt_tiBrush3		= LIN_GetCurrentTime();
			CmbSwt_stBrush3Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stBrush3_mp0	== 1)
		{
			CmbSwt_stBrush3_mp0	= 0;	
			CmbSwt_tiBrush3		= LIN_GetCurrentTime();
			CmbSwt_stBrush3Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}

	if(SPI_Rx_Buf[CMBSWT_BRUSH4_DATA] & CMBSWT_BRUSH4)
	{
		if(CmbSwt_stBrush4_mp0	== 0)
		{
			CmbSwt_stBrush4_mp0	= 1;	
			CmbSwt_tiBrush4		= LIN_GetCurrentTime();
			CmbSwt_stBrush4Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stBrush4_mp0	== 1)
		{
			CmbSwt_stBrush4_mp0	= 0;	
			CmbSwt_tiBrush4		= LIN_GetCurrentTime();
			CmbSwt_stBrush4Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}

	if(SPI_Rx_Buf[CMBSWT_TURNLEFT_DATA] & CMBSWT_TURNLEFT)
	{
		if(CmbSwt_stTurnLeft_mp0	== 0)
		{
			CmbSwt_stTurnLeft_mp0	= 1;	
			CmbSwt_tiTurnLeft		= LIN_GetCurrentTime();
			CmbSwt_stTurnLeftErr	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stTurnLeft_mp0	== 1)
		{
			CmbSwt_stTurnLeft_mp0	= 0;	
			CmbSwt_tiTurnLeft		= LIN_GetCurrentTime();
			CmbSwt_stTurnLeftErr	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	
	if(SPI_Rx_Buf[CMBSWT_TURNRIGHT_DATA] & CMBSWT_TURNRIGHT)
	{
		if(CmbSwt_stTurnRight_mp0	== 0)
		{
			CmbSwt_stTurnRight_mp0	= 1;	
			CmbSwt_tiTurnRight		= LIN_GetCurrentTime();
			CmbSwt_stTurnRightErr	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stTurnRight_mp0	== 1)
		{
			CmbSwt_stTurnRight_mp0	= 0;	
			CmbSwt_tiTurnRight		= LIN_GetCurrentTime();
			CmbSwt_stTurnRightErr	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	
	if(SPI_Rx_Buf[CMBSWT_LAMP1_DATA] & CMBSWT_LAMP1)
	{
		if(CmbSwt_stLamp1_mp0	== 0)
		{
			CmbSwt_stLamp1_mp0	= 1;	
			CmbSwt_tiLamp1		= LIN_GetCurrentTime();
			CmbSwt_stLamp1Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stLamp1_mp0	== 1)
		{
			CmbSwt_stLamp1_mp0	= 0;	
			CmbSwt_tiLamp1		= LIN_GetCurrentTime();
			CmbSwt_stLamp1Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	
	if(SPI_Rx_Buf[CMBSWT_LAMP2_DATA] & CMBSWT_LAMP2)
	{
		if(CmbSwt_stLamp2_mp0	== 0)
		{
			CmbSwt_stLamp2_mp0	= 1;	
			CmbSwt_tiLamp2		= LIN_GetCurrentTime();
			CmbSwt_stLamp2Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stLamp2_mp0	== 1)
		{
			CmbSwt_stLamp2_mp0	= 0;	
			CmbSwt_tiLamp2		= LIN_GetCurrentTime();
			CmbSwt_stLamp2Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	
	if(SPI_Rx_Buf[CMBSWT_LAMP3_DATA] & CMBSWT_LAMP3)
	{
		if(CmbSwt_stLamp3_mp0	== 0)
		{
			CmbSwt_stLamp3_mp0	= 1;	
			CmbSwt_tiLamp3		= LIN_GetCurrentTime();
			CmbSwt_stLamp3Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}
	else
	{
		if(CmbSwt_stLamp3_mp0	== 1)
		{
			CmbSwt_stLamp3_mp0	= 0;	
			CmbSwt_tiLamp3		= LIN_GetCurrentTime();
			CmbSwt_stLamp3Err	|= CMBSWT_STATE_DEBOUNCE;
		}
	}			
}

void MC33993_DataIn(void)
{
	if(SPI_Rx_Buf[CMBSWT_BRUSH1_DATA] & CMBSWT_BRUSH1) CmbSwt_stBrush1_mp0	= 1;		
	else CmbSwt_stBrush1_mp0	= 0;	
						
	if(SPI_Rx_Buf[CMBSWT_BRUSH2_DATA] & CMBSWT_BRUSH2) CmbSwt_stBrush2_mp0	= 1;	
	else CmbSwt_stBrush2_mp0	= 0;	
	
	if(SPI_Rx_Buf[CMBSWT_BRUSH3_DATA] & CMBSWT_BRUSH3) CmbSwt_stBrush3_mp0	= 1;	
	else CmbSwt_stBrush3_mp0	= 0;	

	if(SPI_Rx_Buf[CMBSWT_BRUSH4_DATA] & CMBSWT_BRUSH4) CmbSwt_stBrush4_mp0	= 1;	
	else CmbSwt_stBrush4_mp0	= 0;
	if(SPI_Rx_Buf[CMBSWT_TURNLEFT_DATA] & CMBSWT_TURNLEFT) CmbSwt_stTurnLeft_mp0	= 1;	
	else CmbSwt_stTurnLeft_mp0	= 0;
	
	if(SPI_Rx_Buf[CMBSWT_TURNRIGHT_DATA] & CMBSWT_TURNRIGHT) CmbSwt_stTurnRight_mp0	= 1;	
	else CmbSwt_stTurnRight_mp0	= 0; 
	
	if(SPI_Rx_Buf[CMBSWT_LAMP1_DATA] & CMBSWT_LAMP1) CmbSwt_stLamp1_mp0	= 1; 
	else CmbSwt_stLamp1_mp0	= 0; 
	
	if(SPI_Rx_Buf[CMBSWT_LAMP2_DATA] & CMBSWT_LAMP2) CmbSwt_stLamp2_mp0	= 1; 
	else CmbSwt_stLamp2_mp0	= 0; 
	
	if(SPI_Rx_Buf[CMBSWT_LAMP3_DATA] & CMBSWT_LAMP3) CmbSwt_stLamp3_mp0	= 1; 
	else CmbSwt_stLamp3_mp0	= 0;
}

void MC33993_Debug(void)
{
}