#ifndef _DIS_C_
#define _DIS_C_

#include "global.h"

void fEnDistinguishDriverMotorType(void)
{

	rEnTimer2 |= bEnTimer2ForDM; 
	rTimer2CounterForDM = 0x3f;

	if(~rEnTimer2 & bEnTimer2 )
	{
		fInitialTimer2();
		TMR2ON = 1;							//start to increment.
		rEnTimer2 |= bEnTimer2;
	}

}


void fInitialTimer2(void)
{
	T2CON = 0;  							//stop timer2
 	TMR2 = 0;								//clear timer2 register
	PR2 = TMR2 + 125;						// 1ms
	PEIE = 1;
	TMR2IE = 1;
	TMR2IF = 0;
 	T2CKPS1 = 1;							//prescale  1/16
}

void fTimer2InterruptSeviceRoutine(void)
{	
	PR2 = TMR2 + 125;						// 1ms
	bHavePassed1ms = 1;						
	TMR2IF = 0;								// Clr interrupt flag, ready for next
}


void fTimer2ISR(void)
{
	if(bHavePassed1ms)
	{	
		bHavePassed1ms = 0;
			
	
		if(	rEnTimer2 & bEnTimer2ForDM)
		fDisDriverMotorType();
/*
		if(rEnDisLoadType & bEnDisFrontMotor)
		fDisFrontMotorType();
		
		if(rEnDisLoadType & bEnDisRearLeftMotor)
		fDisRearLeftMotorType();
		
		if(rEnDisLoadType & bEnDisRearRightMotor)
		fDisRearRightMotorType();
*/


		if( ~rEnTimer2 & ( bEnTimer2ForDM + bEnTimer2ForFM 
+ bEnTimer2ForLM + bEnTimer2ForRM ))
		{
			TMR2ON = 0;
			rEnTimer2 &= ~bEnTimer2;
		}
	}
}




void fDisDriverMotorType(void)
{
	unsigned char vADResult;

	unsigned char vStep;
	unsigned char vTimer;
	unsigned char vAddress;
	
	unsigned int vValue;
	unsigned char vPeak;
	unsigned char vMean;
/*
+--------------------+----+----+----+----+----+----+----+----+
|rTimer2CounterForDM |   Step  | BufferAddress| TimerCounter |   
+--------------------+----+----+----+----+----+----+----+----+
*/

	vStep = rTimer2CounterForDM >> 6;
	vTimer = rTimer2CounterForDM & 0x07;
	vAddress = rTimer2CounterForDM & 0b00111000; 
	vAddress >>= 3;

	if( vStep == mStepNoAction)
	{	
		if(vTimer)
		{	
			fItlADC();
			vADResult = fADConverter(AD_DrM);
	

			if(	vADResult > mThreshold)	
			{	
				rBufferForDM[vAddress] = vADResult;
		
				vStep = mStepRise;
				rTimer2CounterForDM = 0x37 ; 		//vAddress = 6;
				rTimer2CounterForDM |= 	vStep << 6;
			}
	
			rTimer2CounterForDM--;
		}

		else	//if the value all < threshold continuiously.
		{
			
			;
			;
			;
			;	
			;
			;
		}
	}


	if( vStep ==  mStepRise)
	{
		fItlADC();
		vADResult = fADConverter(AD_DrM);

		rBufferForDM[vAddress] = vADResult;

		if(vAddress)
		{
			rTimer2CounterForDM -= 0x8;	//vaddress - 1; 
 	 	}
		else
		{
			vValue = fGetAverageAndMaxFromBuffer(rBufferForDM);
			vPeak = vValue;
			vMean = vValue >> 8;
// add code
			
					
			vStep = mStepFall;
			rTimer2CounterForDM &= 0x3f ; //vAddress = 7;vTimer = 7;
			rTimer2CounterForDM |= 	vStep << 6;
		}
	}

	if( vStep ==  mStepFall)
	{	
		if(vTimer)
		{
			vTimer--;
		
		}
		else
		{	
			fItlADC();
			vADResult = fADConverter(AD_DrM);
			rBufferForDM[vAddress] = vADResult;	
			
			if(vAddress)
			{		
				vAddress--;
				vAddress = 0x07 << 3;
				rTimer2CounterForDM &= 0b11000111; 
				rTimer2CounterForDM |= 	vAddress;
		
				vTimer = 0x07;
			}
			else 	
			{
				vValue = fGetAverageAndMaxFromBuffer(rBufferForDM);
				vPeak = vValue;
				vMean = vValue >> 8;
					//add code	
			}
		}

		rTimer2CounterForDM &= 0xf8 ; 
		rTimer2CounterForDM |= 	vTimer;		
	
	}

}



unsigned int fGetAverageAndMaxFromBuffer(bank2 unsigned char *BufferAdd)
{
	unsigned char *ptr;
	unsigned char i;
	unsigned int vSum;
	unsigned char vMax;	

	ptr = BufferAdd;
	vSum = 0;
	for(i = 0; i <= 7; i++)
	vSum += *ptr++;
	vSum <<= 5;	
	vSum &= 0xff00;

	ptr = BufferAdd;
	vMax = *ptr++;
	for(i = 1; i <= 7; i++)
	if( vMax < *ptr++ )
	vMax = *ptr;

	vSum += vMax;
	return(vSum);
}



unsigned char fIsCorrectLoad(unsigned char vMax,unsigned char vAverage)
{
	float wMax = vMax;	
	float wAverage = vAverage;	
	
	if( vMax > mHeavyLoad + 10)				// not my motor
	return(0);	

	if( vMax < mHeavyLoad - 10)				// not my motor
	return(0);	
		
	
	if(wAverage < mLightLoad )
	return(1);
	
	if(wAverage > mHeavyLoad )			//
	return(2);
}


#endif