dzc_bak.c

单片机汇编例程学习,大量的汇编例程

    #include <at89x51.h>
    //#include <math.h>

    #define HI  254      //mode 1 254-0.5ms 236-5ms  252-1ms initial setting
    #define LO  12   // 12-0.5ms 120-5ms  24-1ms initial seting
    #define DEDA 2000 // 200-5ms 1000-1ms   // 200*5ms=1second

    // 7 bit segment LED code from 0 to f 
    unsigned char DATA_7seg[16]={0x3f,0x06,0x5b,0x4f,
                        0x66,0x6d,0x7d,0x07,
      	    				0x7f,0x6f,0x77,0x7c,
					      	0x39,0x5e,0x79,0x71};
    unsigned char disp[5];    // buffer data
    unsigned char act[5]={0xfe,0xfd,0xfb,0xf7,0xef}; // scan control signal
    unsigned char temp[5],init_delta1,delta0,init_delta0,delta2=61;
    char tag=0,ptr=0,init_hour,init_min,rem_sec,init0_sec;
    bit apm_flag=1,init_apm,debug_flag=0,debug_flag1=0,debug_flag2=0;  
    bit flash1_flag=0,no_key_flag;
    bit  flash2_flag=0;
    bit alert_status=1;
	 bit int0,k=0;
	 bit alt_ent_ext=0;
    char key,hour_flag=0,alt_hour=7,alt_min=30,alt_inithour,alt_initmin,alt_apm;
    char key_scan(),key_name;
  // key scan control program 
    char hour=12,min=0,sec=0;
    int  delta=0;   // count value;
    int alt_clk_status=-1; // clock and alert status  clock=1 alert=0 no alert or clock =-1
    void convert(),delay(int),up_dwnhldset();
	 void timeset(),beep(),get_key(),up_downholdset();
   
/*******************************************************************************/
/********************************** up_dwnhldst() ******************************/
/********************************************************************************/
  void up_dwnhldset()
     {
//        key_name=key_name1;
      if(key_name==2&&delta%250==0)
			    {
				 if(flash1_flag==1&&flash2_flag==0)
			      {
					if(++min==60)
				   min=0;
					}
			  if(flash2_flag==1&&flash1_flag==0)  
			    {
				 if(++hour==12)
				  apm_flag=apm_flag^1;
			    if(hour==13)
      	     hour=1;
				 }
			 }
			 if(key_name==3&&delta%250==0)
			  {
			  if(flash1_flag==1&&flash2_flag==0)
			    if(--min==-1)
				   min=59;
			  if(flash2_flag==1&&flash1_flag==0)
   			  {
				  if(--hour==0)
				    hour=12;
				  if(hour==11)
				    apm_flag=apm_flag^1;
					}
			}      
	 }
/*******************************************************************************/
/********************************** key_prs_hold() *****************************/
/********************************************************************************/
	 
	 void key_prs_hold()
	   {
		if(key_name==0&&alt_clk_status!=1)  // prohibit alert key function 
			  {
			  alt_ent_ext=alt_ent_ext^1;
			  if(alt_ent_ext==1)
			    {
				 alt_clk_status=0;
				 flash1_flag=1;
				 flash2_flag=1;
				 init_hour=hour;
				 init_min=min;
				 init_apm=apm_flag;
				 hour=alt_hour;
				 min=alt_min;
			         apm_flag=alt_apm;
				 }
//				 if(0)
				if(alt_ent_ext==0)
				  {
				  alt_clk_status=-1;
				  flash1_flag=0;
				  flash2_flag=0;
				  alt_hour=hour;
                                  alt_min=min;
				  alt_apm=apm_flag;
			          apm_flag=init_apm;     
				  hour=init_hour;
				  min=init_min;
				  sec=0;
				  debug_flag1=0;
				  temp[0]=0xfe;
				  temp[1]=0xfd;
				  temp[2]=0xfb;
				  temp[3]=0xf7;
				  }
			  }  
	   	else
			  if(key_name==1&&alt_clk_status!=0)  // prohibit time key function
	    	  {
			   alt_ent_ext=alt_ent_ext^1;
			  if(alt_ent_ext==1)
			    {
				 alt_clk_status=1;
			    flash1_flag=1;
			    flash2_flag=1;
			 init_hour=hour;
			 init_min=min;
			 init_apm=apm_flag;
	    
				 }
				 if(alt_ent_ext==0)
			    {
				 alt_clk_status=-1;              // no time  or alert status
			    flash1_flag=0;
				 flash2_flag=0;
				 sec=0;
				  temp[0]=0xfe;
				  temp[1]=0xfd;
				  temp[2]=0xfb;
				  temp[3]=0xf7;
				 
			    }
			  }
		 }
/*******************************************************************************/
/********************************** action() ***********************************/
/********************************************************************************/
	  action()
	   {
	   char init0_min;
	   if(debug_flag2==1)
	   return 0;
	key_name=4;
       int0=0;
       
		  while(sec<59)
		  {
			 if(key_scan()==1)
			   {
				int0=1;
				debug_flag2=1;
				return 0;
//				break;
				
				}
			 beep();
		 }
//			init0_min=((min<55)?(min+5):(min-55));
			
			init0_min=((min<58)?(min+2):(min-58));
			while(min!=init0_min&&int0==0)
			  {
			  if(key_scan()==1)
			    {
				 int0=1;
				debug_flag2=1;
				 return 0;
				 }
			  } 
			  while(sec<59&&int0==0)// loop for 60 seconds
			  {
			  if(key_scan()==1) // if key pressed 
			   {
				int0=1;   // interrupt flag=1
				break;
				}
			 P1|=0x14;		//正转一分钟
        	  }
          P1&=0xeb;
          
		  if(int0==1)
			rem_sec=sec;		//rem_sec record the reverse time.
			else
			{
			    rem_sec=59;		
//			init0_min=((min<55)?(min+5):(min-55));
			init0_min=((min<58)?(min+2):(min-58));
			while(min!=init0_min)
			;
		    	}

		    
		  while(sec!=((2*rem_sec<60)?(2*rem_sec):(2*rem_sec-60)))
			{
		 P1|=0x28;		//反转一分钟
		 }
		  P1&=0xd7;
		  
		}
/*******************************************************************************/
/********************************** alt_stsset() *******************************/
/*******************************************************************************/
     void alt_stsset()
     {
     unsigned char  t0;

      if(init_delta1<2&&alt_ent_ext==0)  // press time < 2 seconds
        {
//        t0=P1;
//        t0=t0^1;
//        P1=t0;
        P1=P1^1;         // alert status shift
        t0=P1;
        t0=t0<<7;
        }
        
      if(t0==0x80)  // check if alert status is 1
        alert_status=1;  
      else
        alert_status=0;
      }
/*******************************************************************************/
/********************************** upset()) ******************************/
/********************************************************************************/

     void upset()
       {  
         if(flash1_flag==1&&flash2_flag==0)   // minute bit flash
	         if(++min==60)
					min=0;
				if(flash2_flag==1&&flash1_flag==0)   // hour bit flash
				  {
				  if(++hour==12)
	 			    apm_flag=apm_flag^1;  // am or pm shift 
				  if(hour==13)
				    hour=1;
				  }
     
	   }
     /*******************************************************************************/
/********************************** downset() ***************************************/
/************************************************************************************/

     void downset()
       {
	      {
			if(flash1_flag==1&&flash2_flag==0)  // minute flash
	        if(--min==-1)
				  min=59;
			if(flash2_flag==1&&flash1_flag==0)  // hour flash
			  {
			  if(--hour==11)
				  apm_flag=apm_flag^1;  // am or pm shift
			  if(hour==0)
				 hour=12;
			  }
			 }

	   }
/*******************************************************************************/
/********************************** time_flashset() *****************************/
/********************************************************************************/
    void time_flashset()
      {
  	  	if(init_delta1<2&&alt_clk_status!=-1)
	     {
	     	debug_flag1=1;
	      if(k==0)
	       {
		  flash1_flag=1;   // minute bit flash
	       flash2_flag=0;   // hour bit no flash
	       }
	     if(k==1)
	       {
	       flash2_flag=1;  // hour bit flash
	       flash1_flag=0;   // minute bit no flash 	
			 }
			k=k^1;
		  }
	  }
/*******************************************************************************/
/********************************** beep()******************************/
/********************************************************************************/
 
 void beep()         // buzzer output from P1.2
   {
	int i;
	P1&=0xfd;
	for(i=0;i<10;i++)
	   {
		P1=P1^2;  
		delay(1);
		}
	 }

/*******************************************************************************/
/********************************** delay() ************************************/
/*******************************************************************************/

    void delay0(int t)
      {
	   int i,j;
	   for(i=0;i<10;i++)
	   for(j=0;j<t;j++);
  	   }
 /*******************************************************************************/
/********************************** delay 0.5*t milliseconds ******************************/
/********************************************************************************/
 
    void delay(int t)  // delay  5*t ms
      {
	   char init_ms;
      init_ms=delta;
      while(delta-init_ms<t);
	   }
 
/*******************************************************************************/
/********************************** init_time() ********************************/
/*******************************************************************************/
  init_time() 
   {
  /****set work mode************/
  TMOD=0x21;    // counter 1 mode 2 , counter 0 mode 1
  TH0=HI;   // load initial value
  TL0=LO;
  IP=0x10;   // PS=1 set serial port priority 
  IE=0x82;   // set enable status
  TR0=1;     // TR0=1 boot counter 0 
  TR1=1;     // TR1=1 boot counter 1
   }

 /*******************************************************************************/
/********************************** key_scan()**** ******************************/
/********************************************************************************/
  char key_scan()
    {
	  char j,find ,in,inj=4,p0in;
		  find=0;  // clear key flag
		  P0=P0|0x01;
  in=P3;
	p0in=P0;
	in=in>>4;  // in right shift 4 bits 
	in=in|0xf1;
	p0in=p0in|0xfe;
	in=in&p0in;
	for(j=0;j<4;j++)   //check if key press
	   if(act[j]==in)
		  {
		  find=1; //set key flag
		  inj=j;  // record key scan pointer
		  }	
    	if(find==0) 
		  return 0;  // return 0 if no key press
		 key=inj;
		 return 1;
		 }
/*******************************************************************************/
/********************************** get_key() ******************************/
/********************************************************************************/

    void get_key()
      {
      char relax_flag;
		if(key_scan()==1)
	     {
       key_name=key;
  		  while(1)
	       {
			if(key_scan()==0)  // if key relaxed
		    {
			  beep();
			  delay(1);
			  init_delta1=sec-init_delta0;	//key released
			  debug_flag=0;
            		  delta2=((sec<53)?(sec+7):(sec-53));
			  break;
	        }
      init_delta1=sec-init_delta0;			//key not released

      if(init_delta1>=2)
	 		{
			up_dwnhldset();
	//		relax_flag=0;
		//	if(alt_clk_status!=-1)	 
		//	  relax_flag=1;
			//if(flash1_flag!=flash2_flag)
			  //relax_flag=0;
		 // 	if(relax_flag==0)
		 if(debug_flag==0)		//
		 	{
		 	debug_flag=1;
		 	
		        key_prs_hold();
			}		        
//			key_name1=key_name;
			
//			key_name=4;
//			
		   }
//
	     }
		 }
    }
/*******************************************************************************/
/********************************** timer0 interrupt*****************************/
/********************************************************************************/

void timer0(void) interrupt 1  using 1 // counter 0 5 ms interrupt program
  {
  TR0=0;
  TH0=HI;  // load initial value;
  TL0=LO;
  TR0=1;
  if(ptr++==4)
    ptr=0; 
	 if(delta%1000==0)  // flash once every 0.5 second
    {
    if(flash1_flag==1)
	   {
		temp[0]=temp[0]^1;
		temp[1]=temp[1]^2;
		}
	else if(debug_flag1==1)
	   {
		temp[0]=0xfe;
		temp[1]=0xfd;
		}
			
	 if(flash2_flag==1)
	   {
		temp[2]=temp[2]^4;
		temp[3]=temp[3]^8;
		}
	else if(debug_flag1==1)
	   {
		temp[2]=0xfb;
		temp[3]=0xf7;
		}

	  }      
	 if(delta==DEDA) // 1 second is enough 
    {
    tag=tag^0x80;	
	 sec++;
    delta=0;
	 }
    P3=temp[ptr];  //
    P2=disp[ptr]|tag;  // colon flash
    delta++;   // counter add 1
	 convert();
     }

/*******************************************************************************/
/********************************** convert()**** ******************************/
/*******************************************************************************/

 // time value convert to 7-segment LED data  ********/
 void convert()
	 {
	 if(sec==60)
	   {
		min++;
		sec=0;
		}
/*		if(min==60&&flash1_flag==0)
		 {
 		 hour++;
        	    min=0;
		 if(hour==12)
		   apm_flag=apm_flag^1;// am flag=0 pm flag=1
	 	 }
*/		if(min==60)
		  {
		   min=0;
		if(flash1_flag==0)
		 {
 		 hour++;
        	  if(hour==12)
		   apm_flag=apm_flag^1;// am flag=0 pm flag=1
	 	 }
		if(hour==13)    // if hour is over 13 ,hour =1;	
              hour=1;
                 }
	if(apm_flag==0)
		disp[4]=0x01;  // display am 
   else
     disp[4]=0x02;   // display pm
     disp[3]=DATA_7seg[hour/10];
	 disp[2]=DATA_7seg[hour%10];
	 disp[1]=DATA_7seg[min/10];
	 disp[0]=DATA_7seg[min%10];
	 }
/*******************************************************************************/
/********************************** main() *************************************/
/*******************************************************************************/

 main()  
   {
   char wait_no_key,t,i;  
   P1=0x01; // inital status is alert on
  	P2=P3=0x00; // clear 0
	convert();  // time data convert 
	init_time();  // initial counter 
	while(sec<1)
   for(i=0;i<5;i++)
     {
	  P2=0xff;
	  P3=act[i];
     //delay0(3);
	  temp[i]=act[i];
	  }
	while(1)  // endless loop
	  {
      init_delta0=sec;  // key initial time value  before key pressed
	   key_name=4;

	   if(sec==delta2)
	   {
			   
		  alt_ent_ext=0;
		  flash1_flag=0;
		  flash2_flag=0;
		  debug_flag1=0;
		  temp[0]=0xfe;
		  temp[1]=0xfd;
		  temp[2]=0xfb;
		  temp[3]=0xf7;
		  delta2=61;

		if(alt_clk_status==1)
		{
		  alt_clk_status=-1;
		  hour=init_hour;
		  min=init_min;
		}
		else if(alt_clk_status==0)
		{
		  alt_clk_status=-1;
		  hour=init_hour;
		  min=init_min;
		  apm_flag=init_apm;

		}
	   }		  
	   	
	   get_key(); 
		/*no_key_flag=0;
      if(alt_clk_status!=-1)
        {
		  wait_no_key=sec;
		  t=(wait_no_key<55)?(wait_no_key+5):(wait_no_key-55);
		 while(sec<t)
	     {
        init_delta0=sec;
	     key_name=4;
	     get_key();
		  if(key!=4)
			  {
			  no_key_flag=0;
			  break;
			  }
		  else
		    no_key_flag=1;
        }
		}
		if(no_key_flag==1)
		  {
		  flash1_flag=flash2_flag=0;  
		  hour=init_hour;
		  min=init_min;
		  apm_flag=init_apm;
		  no_key_flag=0;
		  }*/
    	   if(min!=alt_min)
	   	debug_flag2=0;
if(alert_status==1)
{        		  
    if(alt_hour==hour&&alt_min==min&&alt_clk_status==-1&&alt_apm==apm_flag) // if alert time out beep out buzzer
    {
        if(debug_flag2==0)
        {	   	
	    action();  // do beep(), motor1 motor2 etc ......
	}
     }	    
}     
	   switch(key_name)
        {
        case 0: alt_stsset();break;   // do alert status program
        case 1: time_flashset();break;    // do time set program
        case 2: upset(); break;     // do up key set program
        case 3: downset();break;    // do down key set program 
        default: break;            // do nothing
    	}
     }
  	}