自制<<手把手教你学单片机C程序设计>>实验板

只看该作者 · 2010-6-12 11:31

单片机与PC机通信实验2

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//----------------------------------------------------------------------
sbit D0=P1^0;
sbit D1=P1^1;
sbit D2=P1^2;
sbit D3=P1^3;
sbit D4=P1^4;
sbit D5=P1^5;
sbit D6=P1^6;
sbit D7=P1^7;
#define ON 0
#define OFF 1
uchar a[2];
uchar cnt;
bit outflag;
//-------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//--------------------------------
void init(void)
{
TMOD=0x20;
TH1=0xfd;
TL1=0xfd;
SCON=0x50;
TR1=1;
ES=1;
EA=1;
}
//==============================================
void main(void)
{
init();
while(1)
{
  P0=SEG7[a[0]];P2=ACT[2];delay(1);
  P0=SEG7[a[1]];P2=ACT[0];delay(1);
  if(outflag==1)
  {
switch(a[0])
      {
case 1:if(a[1]==1)D0=ON;else D0=OFF;break;
case 2:if(a[1]==1)D1=ON;else D1=OFF;break;
case 3:if(a[1]==1)D2=ON;else D2=OFF;break;
case 4:if(a[1]==1)D3=ON;else D3=OFF;break;
case 5:if(a[1]==1)D4=ON;else D4=OFF;break;
case 6:if(a[1]==1)D5=ON;else D5=OFF;break;
case 7:if(a[1]==1)D6=ON;else D6=OFF;break;
case 8:if(a[1]==1)D7=ON;else D7=OFF;break;
default:break;
      }
outflag=0;
  }
}
}
//=======================================================
void serial_serve(void) interrupt 4
{
uchar temp;
RI=0;
EA=0;
temp=SBUF;
switch(cnt)
   {
case 0:if(temp=='#')cnt=1;
         else outflag=0;
break;
case 1:if((temp>0x30)&&(temp<0x39)){a[0]=temp-0x30;cnt=2;}
         else outflag=0;
break;
case 2:if(temp=='(')cnt=3;
         else outflag=0;
break;
case 3:if((temp>=0x30)&&(temp<=0x38)){a[1]=temp-0x30;cnt=4;}
         else outflag=0;
break;
case 4:if(temp==')'){cnt=0;outflag=1;}
         else outflag=0;
break;
default:break;
}
EA=1;
}

只看该作者 · 2010-6-12 11:33

下面是第18章

外中断实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//----------------------------------------------------------------------
uint data cnt;
bit bdata bitflag;
//-------------------------------------
void init(void)
{
bitflag=0;
EX0=1;
IT0=1;
EA=1;
}
//----------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//==============================================
void main(void)
{
uchar i;
init();
while(1)
   {
   if(bitflag)cnt++;
   if(cnt>999)cnt=0;
   for(i=0;i<100;i++)
      {
         P0=SEG7[cnt/100];
         P2=ACT[2];
         delay(1);
         //----------------------
         P0=SEG7[(cnt%100)/10];
         P2=ACT[1];
         delay(1);
         //-----------------------
         P0=SEG7[cnt%10];
         P2=ACT[0];
         delay(1);
         }
   }
}
//-----------------------------------------------
void extern_int0(void) interrupt 0 using 0
{
bitflag=!bitflag;
}

只看该作者 · 2010-6-12 11:34

定时中断实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
//----------------------------------------------------------------------
uchar data cnt;
//-----------------
sbit LAMP=P1^0;
//-----------------
void init(void)
{
TMOD=0x01;
TH0=-(50000/256);
TL0=-(50000%256);
ET0=1;
TR0=1;
EA=1;
}
//----------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-----------------------------------------
void time0(void) interrupt 1
{
TH0=-(50000/256);
TL0=-(50000%256);
cnt++;
if(cnt<=4)LAMP=0;
else LAMP=1;
if(cnt>=20)cnt=0;
}
//==============================================
void main(void)
{
init();
while(1)
{
  delay(3000);
  }
}

只看该作者 · 2010-6-12 11:35

简易万年历实例

#include <REG51.H>
#define uchar unsigned char
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code WEEK_SEG7[8]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar deda,sec,min,hour,week=1;
uchar cnt;
//----------------------------------------------------------------------
void init(void)
{
TMOD=0x11;
TH0=-(50000/256);
TL0=-(50000%256);
ET0=1;
TR0=1;
TH1=-(1000/256);
TL1=-(1000%256);
ET1=1;
TR1=1;
EA=1;
}
//------------------------
void time0(void) interrupt 1
{
TH0=-(50000/256);
TL0=-(50000%256);
deda++;
}
//-----------------------------
void time1(void) interrupt 3
{
TH1=-(1000/256);
TL1=-(1000%256);
if(++cnt>7)cnt=0;
switch(cnt)
{
  case 0:P0=SEG7[sec%10];P2=ACT[0];break;
  case 1:P0=SEG7[sec/10];P2=ACT[1];break;
  case 2:P0=SEG7[min%10];P2=ACT[2];break;
  case 3:P0=SEG7[min/10];P2=ACT[3];break;
  case 4:P0=SEG7[hour%10];P2=ACT[4];break;
  case 5:P0=SEG7[hour/10];P2=ACT[5];break;
  case 6:P0=0x00;P2=0xff;break;
  case 7:P0=WEEK_SEG7[week];P2=ACT[7];break;
  default:break;
  }
}
//-------------------------------------------------
void conv(void)
{
if(deda>=20){deda=0;sec++;}
if(sec>=60){sec=0;min++;}
if(min>=60){min=0;hour++;}
if(hour>=24){hour=0;week++;}
if(week>7){week=1;}
}
//=================================
void main()
{
init();
while(1)
{
  conv();
  }
}

只看该作者 · 2010-6-12 11:38

下面是第19章

独立式键盘输入实验

#include<REG51.H>
#define uint unsigned int
#define uchar unsigned char
uchar flag;
//---------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
  }
}
//---------------------------
uchar scan_key(void)
{
uchar temp;
temp=P3;
return temp;
}
//=======================
void main()
{
while(1)
{
  P3=0xff;
  if(P3!=0xff)
{
   delay(20);
   P3=0xff;
   if(P3!=0xff)flag=scan_key();
}
else flag=0;
  switch(flag)
      {
      case 0xfb:P1=0xfb;break;
   case 0xf7:P1=0xf0;break;
   case 0xef:P1=0xc0;break;
   case 0xdf:P1=0x00;break;
   default:P1=0xff;break;
      }
  }
}

只看该作者 · 2010-6-12 11:39

行列式键盘输入实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//                      0    1    2 3    4 5 6 7 8    9 A B C D E F
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar code SKEY[16]={10,11,12,13,
                  3,6,9,14,
   2,5,8,0,
   1,4,7,15};
uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};
//-------------------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-------------------------------------
char scan_key(void)
{
uchar i,j,in,ini,inj;
bit find=0;
for(i=0;i<4;i++)
   {
P1=ACT;
delay(10);
in=P1;
in=in>>4;
in=in|0xf0;
for(j=0;j<4;j++)
{
if(ACT[j]==in)
      {
   find=1;
      inj=j;ini=i;
      }
   }
   }
if(find==0)return -1;
return(ini*4+inj);
}
//==============================
void main()
{
char c;
uchar key_value;
while(1)
{
  c=scan_key();
  if(c!=-1)key_value=SKEY[c];
  P0=DIS_SEG7[key_value];
  P2=DIS_BIT[0];
  delay(2);
  }
  }

只看该作者 · 2010-6-12 11:41

扫描方式的键盘输入实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,
                  0x6d,0x7d,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar code SKEY[16]={10,11,12,13,3,6,9,14,2,5,8,0,1,4,7,15};
uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};
//-------------------------------------------------
void delay10ms(void)
{
uint data i,j;
for(i=0;i<10;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-------------------------------------
char scan_key(void)
{
uchar i,j,in,ini,inj;
bit find=0;
for(i=0;i<4;i++)
   {
P1=ACT;
delay10ms();
in=P1;
in=in>>4;
in=in|0xf0;
for(j=0;j<4;j++)
{
if(ACT[j]==in)
   {
   find=1;
      inj=j;ini=i;
   }
   }
   }
if(find==0)return -1;
return(ini*4+inj);
}
//==============================
void main()
{
char c;
uchar key_value;
P0=0xff;P2=0xfe;
while(1)
{
  delay(5000);
  c=scan_key();
  if(c!=-1)key_value=SKEY[c];
  if(key_value==1){P0=0xff;P2=0xff;}
  }
  }

只看该作者 · 2010-6-12 11:42

定时中断方式的键盘输入实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,
                  0x6d,0x7d,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar code SKEY[16]={10,11,12,13,3,6,9,14,2,5,8,0,1,4,7,15};
uchar code ACT[4]={0xfe,0xfd,0xfb,0xf7};
//-------------------------------------------------
void delay10ms(void)
{
uint data i,j;
for(i=0;i<10;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-------------------------------------
char scan_key(void)
{
uchar i,j,in,ini,inj;
bit find=0;
for(i=0;i<4;i++)
   {
P1=ACT;
delay10ms();
in=P1;
in=in>>4;
in=in|0xf0;
for(j=0;j<4;j++)
{
if(ACT[j]==in)
   {
   find=1;
      inj=j;ini=i;
   }
   }
   }
if(find==0)return -1;
return(ini*4+inj);
}
//--------------------------------
void init(void)
{
TMOD=0x01;
TH0=-(50000/256);
TL0=-(50000%256);
ET0=1;
TR0=1;
EA=1;
}
//==============================
void main()
{
init();
P0=0xff;P2=0xfe;
while(1)
{
  delay(5000);
}
}
//========================================
void time0(void) interrupt 1
{
char c; uchar key_value;
TH0=-(50000/256);
TL0=-(50000%256);
  c=scan_key();
  if(c!=-1)key_value=SKEY[c];
  if(key_value==1){P0=0xff;P2=0xff;}
}

只看该作者 · 2010-6-12 11:43

下面是第20章

静态显示实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//                      0    1    2 3    4 5 6 7 8    9 A B C D E F
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//-------------------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//==============================
void main()
{
P0=DIS_SEG7[8];
P2=DIS_BIT[0];
while(1)
{
  P1=~P1;
  delay(500);
  }
}

只看该作者 · 2010-6-12 11:44

慢速扫描动态显示实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//                      0    1    2 3    4 5 6 7 8    9 A B C D E F
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//-------------------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//==============================
void main()
{
uchar cnt;
while(1)
{
  for(cnt=0;cnt<8;cnt++)
   {
P0=DIS_SEG7[cnt+1];
P2=DIS_BIT[cnt];
   delay(100);
   }
  }
}

只看该作者 · 2010-6-12 11:45

快速扫描动态显示实验

#include<REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code DIS_SEG7[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//                      0    1    2 3    4 5 6 7 8    9 A B C D E F
uchar code DIS_BIT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
//-------------------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//==============================
void main()
{
uchar cnt;
while(1)
{
  for(cnt=0;cnt<8;cnt++)
   {
P0=DIS_SEG7[cnt+1];
P2=DIS_BIT[cnt];
   delay(1);
   }
  }
}

只看该作者 · 2010-6-12 11:46

实时时钟实验

#include <REG51.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar code WEEK_SEG7[8]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar deda,sec,min,hour,week=1;
uchar cnt;
//----------------------------------------------------------------------
void init(void)
{
TMOD=0x11;
TH0=-(50000/256);
TL0=-(50000%256);
ET0=1;
TR0=1;
TH1=-(1000/256);
TL1=-(1000%256);
ET1=1;
TR1=1;
EA=1;
}
//------------------------
void time0(void) interrupt 1
{
TH0=-(50000/256);
TL0=-(50000%256);
deda++;
}
//-----------------------------
void time1(void) interrupt 3
{
TH1=-(1000/256);
TL1=-(1000%256);
if(++cnt>7)cnt=0;
switch(cnt)
{
  case 0:P0=SEG7[sec%10];P2=ACT[0];break;
  case 1:P0=SEG7[sec/10];P2=ACT[1];break;
  case 2:P0=SEG7[min%10];P2=ACT[2];break;
  case 3:P0=SEG7[min/10];P2=ACT[3];break;
  case 4:P0=SEG7[hour%10];P2=ACT[4];break;
  case 5:P0=SEG7[hour/10];P2=ACT[5];break;
  case 6:P0=0x00;P2=0xff;break;
  case 7:P0=WEEK_SEG7[week];P2=ACT[7];break;
  default:break;
  }
}
//-------------------------------------------------
void conv(void)
{
if(deda>=20){deda=0;sec++;}
if(sec>=60){sec=0;min++;}
if(min>=60){min=0;hour++;}
if(hour>=24){hour=0;week++;}
if(week>7){week=1;}
}
//-----------------------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-----------------------------------------------
uchar scan_key(void)
{
uchar temp;
P3=0xff;
temp=P3;
if(temp!=0xff)
{
delay(20);
temp=P3;
if(temp!=0xff)return temp;
  }
return 0;
}
//=================================
void main(void)
{
uchar key_flag;
init();
while(1)
{
  conv();
  key_flag=scan_key();
  switch(key_flag)
      {
case 0xfb:if(++min>59)min=0;delay(300);break;
case 0xf7:if(++hour>23)hour=0;delay(300);break;
case 0xef:if(++week>7)week=1;delay(300);break;
  }
  }
}

只看该作者 · 2010-6-12 11:48

下面是第21章

读写AT24C01实验

#include <REG51.H>
#include <intrins.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
sbit SDA=P3^7;
sbit SCL=P3^6;
bdata char com_data;
sbit mos_bit=com_data^7;
sbit low_bit=com_data^0;
uchar cnt,x;
void delay_iic(int n);
uchar rd_24c01(char a);
void wr_24c01(char a,char b);
//----------------------------------------------------------------------
void init(void)
{
TMOD=0x01;
TH0=-(1000/256);
TL0=-(1000%256);
ET0=1;
TR0=1;
EA=1;
}
//------------------------
uchar scan_key(void)
{
uchar temp;
temp=P3;
return temp;
}
//-----------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-----------------------------------
void main(void)
{
uchar key_val;
init();
while(1)
  {
key_val=scan_key();
  switch(key_val)
{
case 0xfb:if(x<255)x++;delay(300);break;
case 0xf7:if(x>0)x--;delay(300);break;
case 0xef:EA=0;wr_24c01(10,x);delay_iic(250);EA=1;P1=x;break;
case 0xdf:EA=0;rd_24c01(10);delay_iic(250);EA=1;P1=~x;break;
default:break;
}
  }
}
//===================================
void time0(void) interrupt 1
{
uchar dis_val;
TH0=-(1000/256);
TL0=-(1000%256);
dis_val=x;
if(++cnt>2)cnt=0;
switch(cnt)
   {
   case 0:P0=SEG7[dis_val%10];P2=ACT[cnt];break;
   case 1:P0=SEG7[(dis_val%100)/10];P2=ACT[cnt];break;
   case 2:P0=SEG7[dis_val/100];P2=ACT[cnt];break;
   default:break;
   }
}
//-----------------------------
void start()
{
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=1;_nop_();_nop_();_nop_();_nop_();
SDA=0;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
}
//-------------------------------------------------
void stop()
{
SDA=0;_nop_();_nop_();_nop_();_nop_();
SCL=1;_nop_();_nop_();_nop_();_nop_();
SDA=1;_nop_();_nop_();_nop_();_nop_();
}
//--------------------------------------------
void ack()
{
SCL=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
}
//-----------------------------------
void shift8(char a)
{
data uchar i;
com_data=a;
for(i=0;i<8;i++)
  {
SDA=mos_bit;
  SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
   SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
com_data=com_data*2;
  }
}
//-------------------------------------------------
uchar rd_24c01(char a)
{
data uchar i,command;
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
start();
command=160;
shift8(command);
ack();
shift8(a);
ack();
start();
command=161;
shift8(command);
ack();
SDA=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
for(i=0;i<8;i++)
  {
com_data=com_data*2;
   SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  low_bit=SDA;
  SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
}
stop();
return(com_data);
}
//-----------------------------------------------
void wr_24c01(char a,char b)
{
data uchar command;
_nop_();_nop_();_nop_();_nop_();_nop_();
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
start();
command=160;
shift8(command);
ack();
shift8(a);
ack();
shift8(b);
ack();
stop();
_nop_();_nop_();_nop_();_nop_();_nop_();
}
//-----------------------------------------
void delay_iic(int n)
{
int i;
for(i=1;i<n;i++){;}
}

只看该作者 · 2010-6-12 11:50

具有断电后**定时时间的实时时钟实验

#include <REG51.H>
#include <intrins.H>
#define uchar unsigned char
#define uint unsigned int
uchar code SEG7[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar ACT[8]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
#define INC_KEY 0xfb
#define DEC_KEY 0xf7
#define OK_KEY 0xef
#define STATUS_KEY 0xdf
#define ON 0
#define OFF 1
sbit SDA=P3^7;
sbit SCL=P3^6;
sbit OUTPUT=P1^0;
//--------------------------------------------------------------------
uchar status;
uchar deda,sec,min,hour;
uchar set1_dat[2],set2_dat[2];
bit set1_flag,set2_flag;
//--------------------------------------------------------
uchar key(void);
void pout(void);
void delay(uint k);
bdata char com_data;
sbit mos_bit=com_data^7;
sbit low_bit=com_data^0;
void delay_iic(int n);
uchar rd_24c01(char a);
void wr_24c01(char a,char b);
//----------------------------------------------------------------------
void initial(void)
{
uchar rd_val;
rd_val=rd_24c01(100);delay_iic(250);
if(rd_val==88)
  {
set1_dat[0]=rd_24c01(80);delay_iic(250);
   set1_dat[1]=rd_24c01(81);delay_iic(250);
   set2_dat[0]=rd_24c01(90);delay_iic(250);
   set2_dat[1]=rd_24c01(91);delay_iic(250);
   set1_flag=(bit)rd_24c01(70);delay_iic(250);
   set2_flag=(bit)rd_24c01(71);delay_iic(250);
  }

TMOD=0x11;
TH0=-(50000/256);
TL0=-(50000%256);
TH1=-(1000/256);
TL1=-(1000%256);
TR0=1;
ET0=1;
TR1=1;
ET1=1;
EA=1;
}
//======================================
void main(void)
{
uchar key_val;
initial();
for(;;)
  {
key_val=key();
  pout();
  if(key_val==STATUS_KEY)
{
status++;
if(status==5)
{
   status=0;
   EA=0;
wr_24c01(100,88);delay_iic(250);
wr_24c01(80,set1_dat[0]);delay_iic(250);
wr_24c01(81,set1_dat[1]);delay_iic(250);
wr_24c01(90,set2_dat[0]);delay_iic(250);
wr_24c01(91,set2_dat[1]);delay_iic(250);
wr_24c01(70,(uchar)set1_flag);delay_iic(250);
wr_24c01(71,(uchar)set2_flag);delay_iic(250);
EA=1;
   }
   delay(300);
}
//----------------------
   if(key_val==INC_KEY)
   {
   switch(status)
      {
      case 1:if(set1_dat[0]<60)set1_dat[0]++;delay(300);break;
   case 2:if(set1_dat[1]<23)set1_dat[1]++;delay(300);break;
   case 3:if(set2_dat[0]<60)set2_dat[0]++;delay(300);break;
   case 4:if(set2_dat[1]<23)set2_dat[1]++;delay(300);break;
default:break;
      }
   }
//---------------------
   if(key_val==DEC_KEY)
   {
   switch(status)
      {
      case 1:if(set1_dat[0]>0)set1_dat[0]--;delay(300);break;
   case 2:if(set1_dat[1]>0)set1_dat[1]--;delay(300);break;
   case 3:if(set2_dat[0]>0)set2_dat[0]--;delay(300);break;
   case 4:if(set2_dat[1]>0)set2_dat[1]--;delay(300);break;
default:break;
      }
   }
//-----------------
   if(key_val==OK_KEY)
   {
   if((status==1)||(status==2)){set1_flag=!set1_flag;delay(300);}
  if((status==3)||(status==4)){set2_flag=!set2_flag;delay(300);}
   }
  }
}
//======================================================
uchar key(void)
{
uchar temp;
P3=0xff;
temp=P3;
if(temp!=0xff)
{
delay(30);
P3=0xff;
temp=P3;
}
return(temp);
}
//-----------------------------------
void pout(void)
{
if(set1_flag)
  {
if((min==set1_dat[0])&&(hour==set1_dat[1]))OUTPUT=ON;
  }
  else OUTPUT=OFF;
  //-------------------------------------------------
if(set2_flag)
  {
if((min==set2_dat[0])&&(hour==set2_dat[1]))OUTPUT=OFF;
  }
  else OUTPUT=OFF;
}
//------------------------------------------------------------
void time0_serve(void) interrupt 1
{
TH0=-(50000/256);
TL0=-(50000%256);
deda++;
if(deda>=20){deda=0;sec++;}
if(sec>59){sec=0;min++;}
if(min>59){min=0;hour++;}
if(hour>23){hour=0;}
}
//-----------------------------------
void time1_serve(void) interrupt 3
{
static uchar time_cnt;
static bit bit_flag;
TH1=-(1000/256);
TL1=-(1000%256);
time_cnt++;
bit_flag=~bit_flag;
//----------------------------------
if(status==0){if(time_cnt>5)time_cnt=0;}
else{if(time_cnt>29)time_cnt=0;}
//----------------------------------
if(status==0)
  {
  switch(time_cnt)
{
case 0:P0=SEG7[sec%10];P2=ACT[time_cnt];break;
case 1:P0=SEG7[sec/10];P2=ACT[time_cnt];break;
case 2:P0=SEG7[min%10];P2=ACT[time_cnt];break;
case 3:P0=SEG7[min/10];P2=ACT[time_cnt];break;
case 4:P0=SEG7[hour%10];P2=ACT[time_cnt];break;
case 5:P0=SEG7[hour/10];P2=ACT[time_cnt];break;
default:break;
}
  }
//-----------------------------------
if(status==1)
  {
  switch(time_cnt)
{
case 0:P0=SEG7[status];P2=ACT[time_cnt];break;
case 1:if(set1_flag)P0=0x01;else P0=0x00;P2=ACT[time_cnt];break;
case 2:P0=SEG7[set1_dat[0]%10];P2=ACT[time_cnt];break;
case 3:P0=SEG7[set1_dat[0]/10];P2=ACT[time_cnt];break;
case 4:P0=SEG7[set1_dat[1]%10];P2=ACT[time_cnt];break;
case 5:P0=SEG7[set1_dat[1]/10];P2=ACT[time_cnt];break;
default:if(bit_flag){P0=SEG7[set1_dat[0]%10];P2=ACT[2];}
               else{P0=SEG7[set1_dat[0]/10];P2=ACT[3];}break;
}
  }
//-----------------------------------
if(status==2)
  {
  switch(time_cnt)
{
case 0:P0=SEG7[status];P2=ACT[time_cnt];break;
case 1:if(set1_flag)P0=0x01;else P0=0x00;P2=ACT[time_cnt];break;
case 2:P0=SEG7[set1_dat[0]%10];P2=ACT[time_cnt];break;
case 3:P0=SEG7[set1_dat[0]/10];P2=ACT[time_cnt];break;
case 4:P0=SEG7[set1_dat[1]%10];P2=ACT[time_cnt];break;
case 5:P0=SEG7[set1_dat[1]/10];P2=ACT[time_cnt];break;
default:if(bit_flag){P0=SEG7[set1_dat[1]%10];P2=ACT[4];}
               else{P0=SEG7[set1_dat[1]/10];P2=ACT[5];}break;
}
  }
//-----------------------------------
if(status==3)
  {
  switch(time_cnt)
{
case 0:P0=SEG7[status];P2=ACT[time_cnt];break;
case 1:if(set2_flag)P0=0x01;else P0=0x00;P2=ACT[time_cnt];break;
case 2:P0=SEG7[set2_dat[0]%10];P2=ACT[time_cnt];break;
case 3:P0=SEG7[set2_dat[0]/10];P2=ACT[time_cnt];break;
case 4:P0=SEG7[set2_dat[1]%10];P2=ACT[time_cnt];break;
case 5:P0=SEG7[set2_dat[0]/10];P2=ACT[time_cnt];break;
default:if(bit_flag){P0=SEG7[set2_dat[0]%10];P2=ACT[2];}
               else{P0=SEG7[set2_dat[0]/10];P2=ACT[3];}break;
}
  }
//-----------------------------------
if(status==4)
  {
  switch(time_cnt)
{
case 0:P0=SEG7[status];P2=ACT[time_cnt];break;
case 1:if(set2_flag)P0=0x01;else P0=0x00;P2=ACT[time_cnt];break;
case 2:P0=SEG7[set2_dat[0]%10];P2=ACT[time_cnt];break;
case 3:P0=SEG7[set2_dat[0]/10];P2=ACT[time_cnt];break;
case 4:P0=SEG7[set2_dat[1]%10];P2=ACT[time_cnt];break;
case 5:P0=SEG7[set2_dat[1]/10];P2=ACT[time_cnt];break;
default:if(bit_flag){P0=SEG7[set2_dat[1]%10];P2=ACT[4];}
               else{P0=SEG7[set2_dat[1]/10];P2=ACT[5];}break;
}
  }
}
//-----------------------------------
void delay(uint k)
{
uint data i,j;
for(i=0;i<k;i++)
{
  for(j=0;j<121;j++)
   {;}
}
}
//-----------------------------------
void start()
{
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=1;_nop_();_nop_();_nop_();_nop_();
SDA=0;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
}
//-------------------------------------------------
void stop()
{
SDA=0;_nop_();_nop_();_nop_();_nop_();
SCL=1;_nop_();_nop_();_nop_();_nop_();
SDA=1;_nop_();_nop_();_nop_();_nop_();
}
//--------------------------------------------
void ack()
{
SCL=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
}
//-----------------------------------
void shift8(char a)
{
data uchar i;
com_data=a;
for(i=0;i<8;i++)
  {
SDA=mos_bit;
  SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
   SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
com_data=com_data*2;
  }
}
//-------------------------------------------------
uchar rd_24c01(char a)
{
data uchar i,command;
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
start();
command=160;
shift8(command);
ack();
shift8(a);
ack();
start();
command=161;
shift8(command);
ack();
SDA=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
for(i=0;i<8;i++)
  {
com_data=com_data*2;
   SCL=1;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  low_bit=SDA;
  SCL=0;_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
}
stop();
return(com_data);
}
//-----------------------------------------------
void wr_24c01(char a,char b)
{
data uchar command;
_nop_();_nop_();_nop_();_nop_();_nop_();
SDA=1;_nop_();_nop_();_nop_();_nop_();
SCL=0;_nop_();_nop_();_nop_();_nop_();
start();
command=160;
shift8(command);
ack();
shift8(a);
ack();
shift8(b);
ack();
stop();
_nop_();_nop_();_nop_();_nop_();_nop_();
}
//-----------------------------------------
void delay_iic(int n)
{
int i;
for(i=1;i<n;i++){;}
}