main.c

监控仪 监控仪 监控仪

     
      P1_6=0;
    }
	else
	if(Get_Value==0xbb)
	{
	  
	  Get_Value=0;
	  if( xx==CPU_NO)
	  {
	 //   XBYTE[0x8004]=0xc0;
	    Up_Get_Value=1;
	
	  }
	  else
	    Up_Get_Value=0;
	}
     if(Up_Get_Value)
	 
	 {
      // Send_Sign=1;
	//   TI=1;
	  // Send_Count=0;
	   Up_Get_Value=0;
	   Send_Count=0;
	   P1_6=1;
	   TI=0;

       SBUF=0xaa;

	//	Send_Count=0;

	 //  SBUF=0xaa;
	//   while(TI!=1);
	  }

/////////////////////////////////////////////////////////////////
	  if(xx==0x66)///////para adjust from up
	  {
	    Recieve_Para_Start=1;
		Receive_Count=0;
		P1_6=0;
	    
	  }


////////////////////////////////////////////////////////////
      if(xx==0xdd)/////up receiving measure order
	  {
	    Byte_Up_Get_Para=0xdd;
		P1_6=0;
	  }
	  else
	  if(Byte_Up_Get_Para==0xdd)
	  {
	     Byte_Up_Get_Para=0;
	     if( xx==CPU_NO)
	     {
	     //  XBYTE[0x8004]=0xc0;
	       Bit_Up_Get_Para=1;
	
	     }
	     else
	        Byte_Up_Get_Para=0;
	  }
	  if(Bit_Up_Get_Para)
	 
	 {
      // Send_Sign=1;
	//   TI=1;
	  // Send_Count=0;
	   Byte_Up_Get_Para=0;
	   Count_Up_Get_Para=0;
	   P1_6=1;
	   TI=0;

       SBUF=0xee;

	//	Send_Count=0;

	 //  SBUF=0xaa;
	//   while(TI!=1);
	  }  



	}

///////////////////////////////////////////////////
    else
	  if(Recieve_Para_Start)////para adjust from up
	  {
	    P1_6=0;
	  // TI=0;
	  // RI=0;
	    switch(Receive_Count)
		{
		case 0:
	      CPU_NO1=xx;
		  Sign_Byte=xx;
		  
		  
		 break;
		 case 1:
	      Para_Tem_Oil1=xx;
		  Sign_Byte=Sign_Byte^xx;
		 break;
		 case 2:
	      Para_Tem_water1=xx;
		  Sign_Byte=Sign_Byte^xx;
		 break;
		 case 3:
	      Para_Speed_Divide1=xx;
		  Sign_Byte=Sign_Byte^xx;
		 break;
		 case 4:
	       Para_Speed_Alarm_Percent1=xx;//alarm percent
		   Sign_Byte=Sign_Byte^xx;
		 break;
		 case 5:
	    //  Para_Speed_Alarm_Percent1=xx;
		   Sign_Temp1=xx;
		   Sign_Byte=Sign_Byte^xx;
		 break;
		 case 6:
	       Para_Speed_Standard1=((unsigned int)(Sign_Temp1))*256+(unsigned int)xx;
		   Sign_Byte=Sign_Byte^xx;
		 break;
		 case 7:
	       Para_Speed_Percent1=xx; 
		   Sign_Byte=Sign_Byte^xx;
         break;
		 case 8:
            Sign_Temp1=xx;
			Sign_Byte=Sign_Byte^xx;
		 break;
	
		 case 9:
		    Para_Pre_Oil1=((unsigned int)(Sign_Temp1))*256+(unsigned int)xx;
			Sign_Byte=Sign_Byte^xx;
	     
		 break;
		 /////////
		 case 10:
		    Para_Pre_Oil_Zoom_k1=xx;
			Sign_Byte=Sign_Byte^xx;
	     
		 break;

		 case 11:
		    Para_Pre_Oil_Shift_b1=(char)xx;
			Sign_Byte=Sign_Byte^xx;
	     
		 break;
		 //////////////////////
		 /////////Para_Pre_Oil_Zoom_k
		 case 12:
		 {
	      
		  
		  Recieve_Para_Stop=1;
		  Recieve_Para_Start=0;
		  if(Sign_Byte==xx)
		  {
		     P1_6=1;
		     TI=0;
             Sign_Byte=0;
		     SBUF=0x77;
		  }
		  Sign_Para=1;
         }
		 break;
		 default:
		   break;
		 }//switch 

		 Receive_Count++;
         
	  }
	}



//////////////////////////////////////////
///////////////////////////////////////////

	if(TI)
	{  
	   if(Sign_Para)//receive para reply   /////////////////////////////
	   {
	     Sign_Para=0;
		 P1_6=0;
		  TI=0;
	      RI=0;
	   }
	   else
	   if(Bit_Up_Get_Para)///////////////////////////////send E2prom para to up
	   {
	       //  Count_Up_Get_Para

//************************************************
     P1_6=1;
	   TI=0;
	   RI=0;

	 switch(Count_Up_Get_Para)
	  	{
	 case 0:
	     
        Check_Up_Get_Para=CPU_NO;
		 SBUF=CPU_NO;//

		Count_Up_Get_Para=1;

		break;
	  case 1:
	  	 Check_Up_Get_Para^= Para_Tem_Oil;
		 SBUF= Para_Tem_Oil;//
		Count_Up_Get_Para=2;
	  	break;

	  	case 2:
	     Check_Up_Get_Para^=  Para_Tem_water;
		 SBUF=  Para_Tem_water;//
		Count_Up_Get_Para=3;
      	break;
 
		case 3:
	    Check_Up_Get_Para^=  Para_Speed_Divide;
		 SBUF=  Para_Speed_Divide;//
		Count_Up_Get_Para=4;
      	break;


		case 4:
	  	  Check_Up_Get_Para^=  Para_Speed_Alarm_Percent;
		 SBUF=  Para_Speed_Alarm_Percent;//
		Count_Up_Get_Para=5;
      	break;

	    case 5:
	  	Check_Up_Get_Para^=  (unsigned char)(Para_Speed_Standard/256);
	    SBUF=  (unsigned char)(Para_Speed_Standard/256);//
		Count_Up_Get_Para=6;
      	break;

	    case 6:
	  	Check_Up_Get_Para^=  (unsigned char)(Para_Speed_Standard%256);
	    SBUF=   (unsigned char)(Para_Speed_Standard%256);//
		Count_Up_Get_Para=7;
      	break;
	    case 7:
	  	Check_Up_Get_Para^=  Para_Speed_Percent;
		 SBUF=  Para_Speed_Percent;//
		 Count_Up_Get_Para=8;
      	break;

		////***
       case 8:
	  	Check_Up_Get_Para^=  (unsigned char)(Para_Pre_Oil/256);
	    SBUF=  (unsigned char)(Para_Pre_Oil/256);//
		Count_Up_Get_Para=9;
      	break;

	    case 9:
	  	Check_Up_Get_Para^=  (unsigned char)(Para_Pre_Oil%256);
	    SBUF=  (unsigned char)(Para_Pre_Oil%256);//
		Count_Up_Get_Para=10;
      	break;
         ///**
		 case 10:
	  	Check_Up_Get_Para^=  (unsigned char)( Para_Pre_Oil_Zoom_k);
        SBUF=  (unsigned char)(Para_Pre_Oil_Zoom_k);//
		Count_Up_Get_Para=11;
        break;

		case 11:
	  	Check_Up_Get_Para^=  ( char)(Para_Pre_Oil_Shift_b);
	    SBUF=  ( char)(Para_Pre_Oil_Shift_b);//
		Count_Up_Get_Para=12;
       break;

		case 12:
	 
	    SBUF=   Check_Up_Get_Para;
		Count_Up_Get_Para=13;
		break;
		 case 13:
	  	P1_6=0;
		Count_Up_Get_Para=14;
		Bit_Up_Get_Para=0;
      	break;
		}//switch


		//*********************************************************
	   }
        else//////////////////////////////////////send mearure data
	  {
	   P1_6=1;
	   TI=0;
	   RI=0;
		switch(Send_Count)
	  	{
	 case 0:
	   Sign_Byte=0x00;
     	 Sign_Temp=( char)Sign_Pre_Oil;
	  	Sign_Byte =Sign_Byte | Sign_Temp;
   	  	//Sign_Byte<<1;
	  	Sign_Byte=Sign_Byte*2;
      
	  	Sign_Temp=( char)Sign_Tem_Oil;
	  	Sign_Byte =Sign_Byte | Sign_Temp;
   	 	// Sign_Byte<<1;
	  	Sign_Byte=Sign_Byte*2;

	  	Sign_Temp=( char)Sign_Tem_Water;
	  	Sign_Byte =Sign_Byte | Sign_Temp;
   	  	//Sign_Byte<<1;
	  	Sign_Byte=Sign_Byte*2;

	  	Sign_Temp=( char)Sign_Speed;
	  	Sign_Byte =Sign_Byte | Sign_Temp;
		 SBUF=Sign_Byte;//

		Send_Count=1;

		break;
	  case 1:
	  	Sign_Temp=Pre_Oil[4]/256; 
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;//check byte
		Send_Count=2;
	  	break;

	  	case 2:
	    Sign_Temp=Pre_Oil[4]%256;
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;
		Send_Count=3;
      	break;
 
		case 3:
	  	Sign_Temp=(char)Tem_Oil[4]-30;
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;
		Send_Count=4;
      	break;


		case 4:
	  	Sign_Temp=(char)Tem_Water[4]-30;
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;
		Send_Count=5;
      	break;




	    case 5:
	  	Sign_Temp=Speed/256;
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;
		Send_Count=6;
      	break;

	    case 6:
	  	Sign_Temp=Speed%256;
	    SBUF=Sign_Temp;
		Sign_Byte^=Sign_Temp;
		Send_Count=7;
      	break;
	    case 7:
	  	SBUF=Sign_Byte;
		Send_Count=8;
      	break;
		 case 8:
	  	P1_6=0;
		Send_Count=12;
      	break;
		}//switch
     }//make different sending

	}

	ES = 1; 

}
*/
void UART_Start()//serious  interrupt  initial
{  
    
  	TR1 = 0;		//First before start the Timer we should shut it down. (TCON)
   //	TCON = 0X40;      //open Timer1
	//TMOD =TMOD | 0x20;	//Mode 2: 8-bit auto-reload Timer.(TImer  1)
    IP = 0x30;//let serious interrupt high priority
   //  IP =IP 0x20;
//	TMOD = 0x25;
	TH1  = 0xf3;	//Equals to 169D
	TL1  = 0xf3;   //baru  rate 2400
	SCON = 0x50;	//[Serial Control Register], Mode 1, 8-bit UART, Variable, Receiver enabled.
	PCON =  0x80;	//[Power Configuration Register], select double baud rate in mode 2
	
	TR1  = 1;		//Start the Timer 1

    RI=0;//Must be cleared by software.
    TI=0;
	EA = 1;//enable all interrupts
	ES = 1;//1=Enable Serial port interrupt*/
}

void initial_timer0_1(void )         //定时器0的初始化,作为计数器///////////reconfiguture
 {
 	TR0=0;
    TMOD=0x25;/////////////
    TH0=0x00;
    TL0=0x00;
   // TCON =TCON | 0x50;// start timer 1 and timer 0

	TR0 = 1;		//First before start the Timer we should shut it down. (TCON)
//	TCON = 0X40;      //open Timer1
    

	TH1  = 0xf4;	//Equals to 169D
	TL1  = 0xf4;
	//SCON = 0x50;	//[Serial Control Register], Mode 1, 8-bit UART, Variable, Receiver enabled.
	//PCON = PCON | 0x80;	//[Power Configuration Register], select double baud rate in mode 2
	TR1  = 1;		//Start the Timer 1
	

	RI=0;//Must be cleared by software.
    TI=0;
	EA = 1;//enable all interrupts
	ES = 1;//1=Enable Serial port interrupt

 }
 void initial_timer2(void )   //initial the timer2 interrupt
                              //定时器2的初始化  作为定时器
 {
    TR2=0;
    IE = 0xBA;//enable all interrupt , and enable timer2
  //  IP = 0x20; //let timer 2 high priority
	T2MOD =0x00;
	T2CON =0x00;/////////////


  //  TH2=0xEC;
  //  TL2=0x78; //initial  value
//	RCAP2H=0xEC;
//	RCAP2L=0x78;
    TH2=0xEC;
    TL2=0x77; //initial  value
	RCAP2H=0xEC;
	RCAP2L=0x77;

	
   // T2CON =T2CON |0x04;// timer 2  as  timer
    
    TR2=1;       //开启定时器
 }

 void INT_TIMER2_overflow() interrupt 5
                                //定时器2的溢出中断处理函数,作为时间计时用  5ms
 {
  
  Speed_Count++;//for test speed
  Capture_Count++;
  Display_Count++;
  Alarm_Count++;

  Count_DisplayTime_5s++;
  if(Bit_Sign_Running)
     Count_RunningTime++;
  Count__Stop_Sure++;
  Count_SettingPara++;
  Count_NoKey++;


  
 // if(Bit_Sign_Alarm_Stop)
  {Count_Alarm_Stop_Send++;}



  if(Get_Key_bit)
 {
    GetKey_Count++;
    GetKey_Count_ForUse++;
	GetKey_Count_ForUse_Stop++;
 }
  if(Signed_Test)
    Test_Count++;

	if(Bit_Start_Stop)
	  Count_Start_Stop++;

  E2prom++;

  Count_Start_Machine_15s++;

  
  
  //TH2=0xF0;
  //TL2=0x0C; 
  //RCAP2H=0xF0;
  //RCAP2L=0x0C;
  WDTRST=0x1E;//喂看门狗第一步
  WDTRST=0xE1;//喂看门狗第二步
  /* if(T1) 
	  T1=0;
    else
	  T1=1;
	  */
  TF2=0;     //must be cleared by soft
//   if(Speed_Count>15)//for speed test
   if(Speed_Count>200)//for speed test
    {
	 // Speed=(TH0*256+TL0)*Speed_Count/(1000*M);
	  Speed=TH0;
//	  Speed= (unsigned int)(  ( ((float)(Speed*256+TL0)) /(Speed_Count*5*Para_Setting_Gear) ) *1000*60  );//5 is 5ms timeUp;60 is 1 minute
                                                                            //1000 is 1000ms
	  Speed= (unsigned int)(  ( ((float)(Speed*256+TL0)) /(Para_Setting_Gear) )*60  );//5 is 5ms timeUp;60 is 1 minute
                                                                            //1000 is 1000ms
	//  Speed=Speed*256+TL0;
	  TH0=0x00;
	  TL0=0x00;
	  Speed_Count=0;

	}//*/
 }


/*
void DeLay_ms(unsigned int t)                     //延时约 t ms
{
   unsigned int i=0;
   while(t--)
   {
   	for(i = 0; i < 34; i++)   //对于6M  延时约1ms
   	{
	}
   }
}*/


//unsigned char volatile xdata * Address;
 Get_KeyBoard()
{
  Key=XBYTE[0x8009];
  if( (!(Key&0x02)) || (!(Key&0x04)) || (!(Key&0x08)) || ( !(Key&0x10)) ||(!(Key&0x01)) )
  {
    GetKey_Count=0;//for time
    GetKey_Count_ForUse=0;
	GetKey_Count_ForUse_Stop=0;
     
	Get_Key_bit=1;//has key