time_tester.c

此测试仪可以测量继电器的吸合时间

	#include <reg51.h>
	#include <intrins.h>
	#define uchar unsigned char
	#define Display_Data P1
	#define Bit P0
	#define Time_Value_10 246
	#define Time_Value_100 156
	#define Time_Value_30 226
	#define Multi 1.49
	#define Multi_B 3.03
	#define ASK 0xFF
	#define ACK 0x00
	#define Test_Start 0x11
	#define Times_Input 0x22
	sbit Start=P2^0;
	sbit No=P2^1;
	sbit Nc=P2^2;
	sbit Coil=P2^3;
	uchar code Display_Code[10]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
	uchar code Display_Code_Point[10]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};
	uchar Dis_Value[4][3]={0},Temp[3]={0};//TH0_Value=255,TL0_Value=246;
	unsigned int T_Count=0,Test_Data[4]={0};
	uchar Test_Times=1;
	bit Test_Flag=0;
	bit Commu_OK=0;
	bit KB_Pro(void);
	void Dis_Pro(void);
	bit PDT_Pro(void);
	bit BT_Pro(void);
	void Delay(uchar i);
	void Code_Convert(uchar m,uchar *Value);
	void Num_Convert(unsigned int i);
	//void T0_Ini(void);
	void Code_Convert_1(uchar m,uchar *Value);
	void Recieve_Pro(void);
	void Send_Pro(void);

	main()
	{
		TMOD=0x22;//T0 and T1 both Method 2;
		TH0=Time_Value_10;
		TL0=Time_Value_10;
		SCON=0x50;//UART method 1;recieved enable.
		PCON=0x80;//Boud Double;
		TH1=0xF3;//4800b;
		TL1=0xF3;
		TR1=1;
		//ET0=1;
		//EA=1;
		while(1)
		{
			Recieve_Pro();
			if(KB_Pro())
			{
				uchar i=0;
				for(i=0;i<Test_Times;i++)
				{
					PDT_Pro();
			 		BT_Pro();
					if(Commu_OK==1) Send_Pro();
					Dis_Pro();
				}
			}
		}
	}

	void Recieve_Pro(void)
	{
		uchar x=0;
		static bit i=0;
		if(RI)
		{
			RI=0;
			x=SBUF;
			//Dis_Pro();
			if(i==0)
			{
				if(x==ASK)
		 		{
					SBUF=ACK;
					while(!TI);
					TI=0;
					Commu_OK=1;
				}
				if(x==Test_Start) Test_Flag=1;
			}
			else 
			{
				Test_Times=x;
				i=0;
			}
			if(x==Times_Input) i=1;
		}
	}

	void Send_Pro(void)
	{
		uchar x=0,m=0;
		for(m=0;m<4;m++)
		{
			x=Test_Data[m]/256;//send high 8 bit;
			SBUF=x;
			while(!TI);
			TI=0;
			Delay(10);
			x=Test_Data[m]%256;//send low 8 bit;
			SBUF=x;
			while(!TI);
			TI=0;
			Delay(10);		
		}
	}

	bit KB_Pro(void)
	{
		if(Start==0)
		{
			Delay(50);
			if(Start==0)
			{
				Num_Convert(999);
				Code_Convert(0,Temp);
				Code_Convert(1,Temp);
				Code_Convert(2,Temp);
				Code_Convert(3,Temp);
				Test_Data[0]=999;
				Test_Data[1]=999;
				Test_Data[2]=999;
				Test_Data[3]=999;
				TR0=0;
				T_Count=0;
				Display_Data=0xFF;
				Bit=0xFF;
				Test_Times=1;
		 		return(1);
		 	}
		}
		if(Test_Flag)
		{
			Test_Flag=0;
	 		return(1);
		}
		return(0);
	}

	void Dis_Pro(void)
	{
		uchar m=0,n=0,y=0xFE;//,i=0;
		TR0=1;
		for(m=0;m<4;m++)
		{
			T_Count=0;
			//TR0=1;
			TF0=0;
			TH0=Time_Value_100;
			TL0=Time_Value_100;
			while(T_Count<=240)
			{
				for(n=0;n<3;n++)
				{
					Display_Data=Dis_Value[m][n];
					Bit=y;
					y=~y;
					y<<=1;
					if(y==8) y=1;
					y=~y;
					Delay(2);
					//if(KB_Pro()) return;
					if(TF0)
					{
						TF0=0;
						T_Count++;
					}
				}
			}
			Bit=0xFF;
			Delay(200);
			Delay(100);
			T_Count=0;
		}
		TR0=0;
		TF0=0;
		TH0=Time_Value_10;
		TL0=Time_Value_10;
	}

	bit PDT_Pro(void)
	{
		TH0=Time_Value_10;
		TL0=Time_Value_10;
		T_Count=0;
		Coil=0;
		TR0=1;
		while(!No)
		{
			while(!TF0);
			TF0=0;
			T_Count++;
			if(T_Count>=9999)
		 	{		
				Num_Convert(999);
				Code_Convert(0,Temp);
				Coil=1;
				//break;
				return(0);
			}
		}
		TR0=0;
		T_Count=T_Count*Multi;
		Test_Data[0]=T_Count;
		if(T_Count<1000)
		{
			Num_Convert(T_Count);
			Code_Convert_1(0,Temp);
		}
		else
		{
			T_Count/=10;
			Num_Convert(T_Count);
			Code_Convert(0,Temp);			
		}
		Delay(100);
		TH0=Time_Value_10;
		TL0=Time_Value_10;
		T_Count=0;
		Coil=1;
		TR0=1;
		while(No)
		{
			while(!TF0);
			TF0=0;
			T_Count++;
			if(T_Count>=9999)
		 	{		
				Num_Convert(999);
				Code_Convert(1,Temp);
				return(0);
				//break;
			}			
		}
		TR0=0;
		T_Count=T_Count*Multi;
		Test_Data[1]=T_Count;
		if(T_Count<1000)
		{
			Num_Convert(T_Count);
			Code_Convert_1(1,Temp);
		}
		else
		{
			T_Count/=10;
			Num_Convert(T_Count);
			Code_Convert(1,Temp);			
		}
		Delay(100);
		return(1);
	}

	bit BT_Pro(void)
	{
		unsigned int m=0,n=0,y=0;
		bit F=1;
		TH0=Time_Value_30;
		TL0=Time_Value_30;
		TR0=0;
		T_Count=0;		
		Coil=0;			
		while(!No)
		{
			m++;
			if(m==100)
			{	
				m=0;
				n++;
				if(n==100)
				{
					Num_Convert(999);
					Code_Convert(2,Temp);
					Coil=1;
					return(0);
					//break;
				}
			}
		}
		TR0=1;
		while(TR0)
		{
			while(!TF0);
			TF0=0;
			T_Count++;
			if(No&&F)
			{
				F=!F;
				y=T_Count;
			}
			if((No==0)&&(F==0)) F=!F;
			if((y+1000)<=T_Count) TR0=0;
		}
		y=y*Multi_B;
		Test_Data[2]=y;
		if(y<1000)
		{
			Num_Convert(y);
			Code_Convert_1(2,Temp);
		}
		else
		{
			y/=10;
			Num_Convert(y);
			Code_Convert(2,Temp);			
		}
		Delay(100);
		TH0=Time_Value_30;
		TL0=Time_Value_30;
		TR0=0;
		T_Count=0;
		m=0;
		n=0;
		y=0;
		F=1;
		Coil=1;
		while(!Nc)
		{
			m++;
			if(m==100)
			{	
				m=0;
				n++;
				if(n==100)
				{
					Num_Convert(999);
					Code_Convert(3,Temp);
					//break;
					return(0);
				}
			}
		}
		TR0=1;
		while(TR0)
		{
			while(!TF0);
			TF0=0;
			T_Count++;
			if(Nc&&F)
			{
				F=!F;
				y=T_Count;
			}
			if((Nc==0)&&(F==0)) F=!F;
			if((y+1000)<=T_Count) TR0=0;
		}
		y=y*Multi_B;
		Test_Data[3]=y;
		if(y<1000)
		{
			Num_Convert(y);
			Code_Convert_1(3,Temp);
		}
		else
		{
			y/=10;
			Num_Convert(y);
			Code_Convert(3,Temp);			
		}
		return(1);
	}

	void Delay(uchar i)
	{
		uchar m,n;
		for(m=0;m<200;m++)
		{
			for(n=0;n<i;n++) _nop_();
		}
	}

	void Code_Convert(uchar m,uchar *Value)
	{
		uchar n=0;
		for(n=0;n<3;n++)
		{
			if(n==1) Dis_Value[m][n]=Display_Code_Point[Value[n]];
			else Dis_Value[m][n]=Display_Code[Value[n]];
		}		
	}

	void Code_Convert_1(uchar m,uchar *Value)
	{
		uchar n=0;
		for(n=0;n<3;n++)
		{
			if(n==0) Dis_Value[m][n]=Display_Code_Point[Value[n]];
			else Dis_Value[m][n]=Display_Code[Value[n]];
		}		
	}

	void Num_Convert(unsigned int i)
	{
		uchar m=0,n=100;
		for(m=0;m<3;m++)
		{
			Temp[m]=i/n;
			i%=n;
			n/=10;			
		}		
	}

	/*void T0_Ini(void) interrupt 1 using 1
	{
		//TH0=-Time_Value/256;
		//TL0=-Time_Value%256;
		TH0=TH0_Value;
		TL0=TL0_Value;
		T_Count++;
	}*/