05 Test代码

 1  #include "reg51.h"
 2 
 3  sbit led = P0^0;
 4 
 5  void main()
 6  {
 7      while(1)
 8     {
 9         led = 1;
10     }
11  }

 1  #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 sbit led = P0^0;              //将led的管脚定义到P0^0
 7 
 8 void delay(u16 i)
 9 {
10     while(i--);
11 }
12 
13  void main()
14  {
15     while(1)
16     {
17         led = 1;
18         delay(50000);
19         led = 0;
20         delay(50000);    
21     }
22  }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数坐在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 #define led P0                  //选择P0端口
 8 
 9 void delay(u16 i)              //定义延时函数
10 {
11     while(i--);
12 }
13 
14 void main()
15 {
16     u8 i;
17     led = 0x01;
18     delay(50000);
19     while(1)
20     {
21 //        for(i = 0; i < 8; i++)
22 //        {
23 //             led = (0x01<<i);
24 //            delay(50000)
25 //        }        
26         for(i = 0; i < 7; i++)
27         {
28             led =_crol_(led,1);   //循环左移
29             delay(50000);
30         }
31         for(i = 0; i < 7; i++)
32         {
33             led =_cror_(led,1);   //循环右移
34             delay(50000);
35         }    
36     }
37 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数坐在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit beep = P1^5;              //选择P15端口       此处不能用define
 8 
 9 void delay(u16 i)              //定义延时函数
10 {
11     while(i--);
12 }
13 
14 void main()
15 {
16     while(1)
17     {
18         beep = ~beep;          //取反，不断产生高低电平
19         delay(10);              //延时，以产生占空比
20     }
21 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数坐在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit relay = P1^4;              //选择P14端口       
 8 
 9 void main()
10 {
11     relay = 0;
12     while(1)
13     {
14             
15     }
16 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数坐在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 u8 code smgduan[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
 8                         0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//共阴
 9 
10 void main()
11 {
12     P0 = ~smgduan[0];          //共阴取反
13     while(1)
14     {
15             
16     }
17 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数坐在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 u8 code smgduan[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
 8                         0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//共阴
 9 
10 sbit LSA = P2^2;
11 sbit LSB = P2^3;
12 sbit LSC = P2^4;
13 
14 void delay(u16 i)
15 {
16     while(i--);
17 }
18 
19 void DigDisplay()
20 {
21     u8 i;
22     for(i = 0; i < 8; i++)
23     {
24         switch(i)
25         {
26             case(0):
27                 LSA=0;LSB=0;LSC=0; break;//显示第0位
28             case(1):
29                 LSA=1;LSB=0;LSC=0; break;//显示第1位
30             case(2):
31                 LSA=0;LSB=1;LSC=0; break;//显示第2位
32             case(3):
33                 LSA=1;LSB=1;LSC=0; break;//显示第3位
34             case(4):
35                 LSA=0;LSB=0;LSC=1; break;//显示第4位
36             case(5):
37                 LSA=1;LSB=0;LSC=1; break;//显示第5位
38             case(6):
39                 LSA=0;LSB=1;LSC=1; break;//显示第6位
40             case(7):
41                 LSA=1;LSB=1;LSC=1; break;//显示第7位
42         }
43         P0 = smgduan[i+1];          
44         delay(100);
45         P0=0x00;
46     }    
47 }
48 
49 void main()
50 {
51     while(1)
52     {
53         DigDisplay();        
54     }
55 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit led = P0^0;
 8 sbit k1 = P1^0;
 9 
10 void delay(u16 i)
11 {
12     while(i--);
13 }
14 
15 void keypress()
16 {
17    if(k1==0)
18    {
19            delay(1000);
20         if(k1==0)
21         {
22              led = ~led;
23         }
24         while(!k1);
25    }
26 }
27 
28 void main()
29 {
30     led = 0;
31     while(1)
32     {
33         keypress();        
34     }
35 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 #define GPIO_DIG P0
 8 #define GPIO_KEY P1
 9 
10 u8 code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
11                     0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//显示0~F的值
12 
13 void delay(u16 i)
14 {
15     while(i--);
16 }
17 
18 u8 KeyValue;
19 
20 void KEYDOWN()
21 {
22     char a = 0;
23     GPIO_KEY = 0x0f;
24     if(GPIO_KEY != 0x0f)
25     {
26          delay(1000);
27         if(GPIO_KEY != 0x0f)
28         {
29              switch(GPIO_KEY)
30              {
31                 case(0X07):    KeyValue=0; break;    //4
32                 case(0X0b):    KeyValue=1; break;    //3
33                 case(0X0d): KeyValue=2; break;    //2
34                 case(0X0e):    KeyValue=3; break;  //1         
35              }
36              GPIO_KEY = 0xf0;
37                switch(GPIO_KEY)
38              {
39                 case(0X70):    KeyValue=KeyValue;    break;    //4
40                 case(0Xb0):    KeyValue=KeyValue+4;  break;    //3
41                 case(0Xd0): KeyValue=KeyValue+8;  break;    //2
42                 case(0Xe0):    KeyValue=KeyValue+12; break;    //1         
43              }
44             while(a < 50 && GPIO_KEY != 0xf0)
45             {
46                  delay(1000);
47                 a++;
48             }
49          }
50     }    
51 }
52 
53 void main()
54 {
55     while(1)
56     {
57         KEYDOWN();
58         GPIO_DIG = ~smgduan[KeyValue];        
59     }
60 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 #define GPIO_LED P0
 8 
 9 sbit IN_PL   =P1^6;              //定义移位/置入管脚
10 sbit IN_Data =P1^7;              //定义输出管脚
11 sbit SCK     =P3^6;              //定义时钟管脚
12 
13 u8 Read74HC165()                  //读取函数
14 {
15     u8 indata;                  //保存读取的数据
16     u8 i;
17     
18     IN_PL = 0;
19     _nop_();                  //延时一个机器周期
20     IN_PL = 1;
21     _nop_();                  //产生上升沿，使移位/置入管脚切换到移位状态
22 
23     indata = 0;                  //初始化
24     for(i=0;i<8;i++)          //循环读入 注意：for后面没有冒号
25     {
26         indata = indata<<1;      //左移
27         SCK = 0;
28         _nop_();              //延时一个机器周期
29 
30         indata |= IN_Data;      //读入，使用‘或‘,只读入高电平，不影响其它位的电平
31         SCK = 1;              //上升沿时钟脉冲触发移位
32     }
33     return indata;     
34 }
35 
36 void main()
37 {
38     u8 H165Value;
39     
40     GPIO_LED = 0;
41     while(1)
42     {
43         H165Value = Read74HC165();
44         if(H165Value != 0xff)
45         {
46             GPIO_LED = ~H165Value;
47         }
48     }
49 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit SRCLK =P3^6;              //定义
 8 sbit RCLK  =P3^5;              //定义
 9 sbit SER   =P3^4;              //定义串行输入管脚
10 
11 void delay(u16 i)
12 {
13     while(i--);
14 }
15 
16 void HC595SendByte(u8 dat)              //发送数据函数
17 {
18     u8 i;
19     SRCLK = 1;
20     RCLK  = 1;
21     
22     for(i = 0; i < 8; i++)
23     {
24         SER = dat>>7;          //先把最高位移出来
25         dat <<=1;              //然后移次高位到最高位上准备下一次发送
26 
27         SRCLK = 0;
28         _nop_();
29         _nop_();
30         SRCLK = 1;              //产生上升沿，发送数据到IO口
31     }
32     RCLK = 0;
33     _nop_();
34     _nop_();
35     RCLK = 1;         
36 }
37 
38 void main()
39 {
40     u8 LED_Num;
41     LED_Num = 0x01;
42     while(1)
43     {
44         HC595SendByte(LED_Num);
45         LED_Num = _crol_(LED_Num,1);
46         delay(50000);    
47     }
48 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit SRCLK =P3^6;              //定义
 8 sbit RCLK  =P3^5;              //定义
 9 sbit SER   =P3^4;              //定义串行输入管脚
10 
11 //void delay(u16 i)
12 //{
13 //    while(i--);
14 //}
15 
16 void HC595SendByte(u8 dat1,u8 dat2)              //发送数据函数
17 {
18     u8 i;
19     SRCLK = 1;
20     RCLK  = 1;
21     
22     for(i = 0; i < 8; i++)
23     {
24         SER = dat1>>7;          //先把最高位移出来
25         dat1 <<=1;              //然后移次高位到最高位上准备下一次发送
26 
27         SRCLK = 0;
28         _nop_();
29         _nop_();
30         SRCLK = 1;              //产生上升沿，发送数据到IO口
31     }
32 
33     for(i = 0; i < 8; i++)
34     {
35         SER = dat2>>7;          //先把最高位移出来
36         dat2 <<=1;              //然后移次高位到最高位上准备下一次发送
37 
38         SRCLK = 0;
39         _nop_();
40         _nop_();
41         SRCLK = 1;              //产生上升沿，发送数据到IO口
42     }
43 
44     RCLK = 0;
45     _nop_();
46     _nop_();
47     RCLK = 1;         
48 }
49 
50 void main()
51 {
52     HC595SendByte(0x08,0xf7);
53     while(1)
54     {
55 
56     }
57 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit SRCLK =P3^6;              //定义移位寄存器时钟
 8 sbit RCLK  =P3^5;              //定义存储寄存器时钟
 9 sbit SER   =P3^4;              //定义串行输入管脚
10 
11 //u8 hangduanxuan[4] = {0x01,0x08,0x80,0xff};    //“王”
12 //u8 lieweixuan[4] = {0x00,0x00,0x00,0xf7};
13 
14 u8 hangduanxuan[4] = {0x01,0x08,0x80,0xff};
15 u8 lieweixuan[4] = {0x00,0x00,0x00,0xf7};
16 
17 void delay(u16 i)
18 {
19     while(i--);
20 }
21 
22 void HC595SendByte(u8 dat1,u8 dat2)              //数据发送函数
23 {
24     u8 i;                      
25     SRCLK = 1;                  //使互补的VCC通电
26     RCLK  = 1;                  //使
27     
28     for(i = 0; i < 8; i++)
29     {
30         SER = dat1 >>7;          //先把最高位向右移动七位到最低位，移出来
31         dat1 <<=1;              //然后移次高位到最高位上准备下一次发送
32 
33         SRCLK = 0;
34         _nop_();
35         _nop_();
36         SRCLK = 1;              //产生上升沿，发送数据到移位寄存器
37     }
38 
39     for(i = 0; i < 8; i++)
40     {
41         SER = dat2>>7;          //先把最高位移出来
42         dat2 <<=1;              //然后移次高位到最高位上准备下一次发送
43 
44         SRCLK = 0;
45         _nop_();
46         _nop_();
47         SRCLK = 1;              //SRCLK产生上升沿，发送数据到移位寄存器
48     }
49 
50     RCLK = 0;
51     _nop_();
52     _nop_();
53     RCLK = 1;                   //RCLK产生上升沿，发送数据到存储寄存器中
54 }
55 
56 void main()
57 {
58     u8 i;
59     while(1)
60     {    for(i=0;i<4;i++)
61         {
62             HC595SendByte(hangduanxuan[i],lieweixuan[i]);
63             delay(500);
64         }
65 
66     }
67 }

 1  #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 sbit motor = P1^0;              //
 7 
 8 void delay(u16 i)
 9 {
10     while(i--);
11 }
12 
13 void main()
14 {
15     u8 i;
16     motor = 0;
17     for(i=0;i<100;i++)
18     {
19          motor = 1;
20         delay(1000);
21     }
22     motor = 0;
23     while(1)
24     {
25             
26     }
27 }

 1  #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 sbit motor = P1^0;              //
 7 
 8 void delay(u16 i)
 9 {
10     while(i--);
11 }
12 
13 void main()
14 {
15     u8 i;
16     motor = 0;
17     for(i=0;i<100;i++)
18     {
19          motor = 1;
20         delay(1000);
21     }
22     motor = 0;
23     while(1)
24     {
25             
26     }
27 }

 1 #include "reg51.h"
 2 #include "intrins.h"          //包含循环函数所在的库
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit led = P2^0;
 8 sbit k3 = P3^2;
 9 
10 void delay(u16 i)
11 {
12     while(i--);
13 }
14 
15 void Int0Init()    //定义中断触发函数
16 {
17     EA = 1;        //打开总中断开关
18     EX0= 1;        //打开外部中断开关
19     IT0= 1;        //设置外部中断触发模式为下降沿触发
20 }
21 
22 void main()
23 {
24     Int0Init();    //调用中断函数
25     while(1);       
26 }
27 
28 void Int0() interrupt 0  //编写中断函数
29 {
30     delay(5000);
31     if(k3==0)
32     {
33         led = ~led;
34     }
35 }

 1 #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 sbit led = P2^0;              //将led的控制管脚定义到P2^0
 7 
 8 void Timer0Init()              //定时器初始化
 9 {
10     TMOD = 0x01;              //设置定时器工作模式
11     TH0  = 0xfc;              //设置定时时间
12     TL0  = 0x18;
13 
14     EA   = 1;                  //打开总中断
15     ET0  = 1;                  //打开定时器0中断允许位
16     TR0  = 1;                  //启动定时器定时
17 }
18 
19 void main()
20 {
21     Timer0Init();              //调用定时器初始化函数
22     while(1);
23 }
24 
25 void Timer0() interrupt 1      //编写中断函数（定时器函数名 中断号）
26 {
27     static u16 i;    
28 
29     TH0  = 0xfc;              //重载初值
30     TL0  = 0x18;
31     
32     i++;
33     if(i == 1000)
34     {
35         i = 0;
36         led = ~led;
37     }    
38 }

  1 #include "reg51.h"
  2 #include "intrins.h"          //包含循环函数坐在的库
  3 
  4 typedef unsigned char u8;      //字符型数据一般为8位
  5 typedef unsigned int u16;      //整型数据一般为16位
  6 
  7 u8 code smgduan[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
  8                      0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//共阴数码管
  9 
 10 u8 second = 0;
 11 u8 DisplayData[8];
 12 
 13 sbit LSA = P2^2;
 14 sbit LSB = P2^3;
 15 sbit LSC = P2^4;
 16 
 17 #define GPIO_DIG     P0           //数码管段选管脚     宏定义
 18 #define GPIO_TRAFFIC P1           //交通灯管脚位
 19 
 20 sbit shangrenRED   = P1^0;       //LED管脚位定义
 21 sbit shangrenGREEN = P1^1;
 22 sbit shangRED      = P1^2;
 23 sbit shangYELLOW   = P1^3;
 24 sbit shangGREEN    = P1^4;
 25 
 26 sbit xiarenGREEN   = P3^0;
 27 sbit xiarenRED     = P3^1;
 28 sbit xiaRED        = P1^5;
 29 sbit xiaYELLOW     = P1^6;
 30 sbit xiaGREEN      = P1^7;
 31 
 32 void delay(u16 i)
 33 {
 34     while(i--);
 35 }
 36 
 37 void DigDisplay()
 38 {
 39     u8 i;
 40     for(i = 0; i < 8; i++)
 41     {
 42         switch(i)
 43         {
 44             case(0):
 45                 LSA=0;LSB=0;LSC=0; break;//显示第0位
 46             case(1):
 47                 LSA=1;LSB=0;LSC=0; break;//显示第1位
 48             case(2):
 49                 LSA=0;LSB=1;LSC=0; break;//显示第2位
 50             case(3):
 51                 LSA=1;LSB=1;LSC=0; break;//显示第3位
 52             case(4):
 53                 LSA=0;LSB=0;LSC=1; break;//显示第4位
 54             case(5):
 55                 LSA=1;LSB=0;LSC=1; break;//显示第5位
 56             case(6):
 57                 LSA=0;LSB=1;LSC=1; break;//显示第6位
 58             case(7):
 59                 LSA=1;LSB=1;LSC=1; break;//显示第7位
 60         }
 61 
 62         P0 = DisplayData[i];          
 63         delay(100);
 64         GPIO_DIG=0x00;
 65     }    
 66 }
 67 
 68 void Timer0Init()              //定时器初始化
 69 {
 70     TMOD = 0x01;              //设置定时器工作模式
 71     TH0  = 0xfc;              //设置定时时间
 72     TL0  = 0x18;
 73 
 74     EA   = 1;                  //打开总中断
 75     ET0  = 1;                  //打开定时器0中断允许位
 76     TR0  = 1;                  //启动定时器定时
 77 }
 78 
 79 void main()
 80 {
 81     Timer0Init();              //调用定时器初始化函数
 82     while(1)
 83     {
 84          if(second == 70)
 85         {
 86             second = 0;
 87         }
 88 
 89         if(second < 31)
 90         {
 91             GPIO_TRAFFIC = 0xff;     //关闭所有灯
 92             xiarenRED     = 1;
 93             xiarenGREEN     = 1;
 94             
 95             shangrenGREEN = 0;           //红绿灯通行部分
 96             shangrenRED   = 1;
 97             shangRED      = 1;
 98             shangYELLOW   = 1;
 99             shangGREEN    = 0;
100 
101 
102             xiarenRED     = 0;
103             xiarenGREEN   = 1;
104             xiaRED        = 0;
105             xiaYELLOW     = 1;
106             xiaGREEN      = 1;
107                                      //数码管显示部分
108             DisplayData[0]=0x00;
109             DisplayData[1]=0x00;
110             DisplayData[2]=smgduan[(30-second)%100/10];
111             DisplayData[3]=smgduan[(30-second)%10];
112 
113             DisplayData[4]=0x00;
114             DisplayData[5]=0x00;
115             DisplayData[6]=smgduan[(30-second)%100/10];
116             DisplayData[7]=smgduan[(30-second)%10];
117 
118             DigDisplay();
119         }
120 
121         else if(second < 36)
122         {
123             shangrenGREEN = 1;           //红绿灯通行部分
124             shangrenRED   = 0;
125             shangRED      = 1;
126             shangYELLOW   = 0;
127             shangGREEN    = 1;
128 
129 
130             xiarenRED     = 0;
131             xiarenGREEN   = 1;
132             xiaRED        = 0;
133             xiaYELLOW     = 1;
134             xiaGREEN      = 1;
135                                      //数码管显示部分
136             DisplayData[0]=0x00;
137             DisplayData[1]=0x00;
138             DisplayData[2]=smgduan[(36-second)%100/10];
139             DisplayData[3]=smgduan[(36-second)%10];
140 
141             DisplayData[4]=0x00;
142             DisplayData[5]=0x00;
143             DisplayData[6]=DisplayData[2];
144             DisplayData[7]=DisplayData[3];
145 
146             DigDisplay();
147         }
148 
149         else if(second < 66)
150         {
151             shangrenGREEN = 1;           //红绿灯通行部分
152             shangrenRED   = 0;
153             shangRED      = 0;
154             shangYELLOW   = 1;
155             shangGREEN    = 1;
156 
157 
158             xiarenRED     = 1;
159             xiarenGREEN   = 0;
160             xiaRED        = 1;
161             xiaYELLOW     = 1;
162             xiaGREEN      = 0;
163                                      //数码管显示部分
164             DisplayData[0]=0x00;
165             DisplayData[1]=0x00;
166             DisplayData[2]=smgduan[(66-second)%100/10];
167             DisplayData[3]=smgduan[(66-second)%10];
168 
169             DisplayData[4]=0x00;
170             DisplayData[5]=0x00;
171             DisplayData[6]=DisplayData[2];
172             DisplayData[7]=DisplayData[3];
173 
174             DigDisplay();
175         }
176 
177         else if(second < 71)
178         {
179             shangrenGREEN = 1;           //红绿灯通行部分
180             shangrenRED   = 0;
181             shangRED      = 0;
182             shangYELLOW   = 1;
183             shangGREEN    = 1;
184 
185 
186             xiarenRED     = 0;
187             xiarenGREEN   = 1;
188             xiaRED        = 1;
189             xiaYELLOW     = 0;
190             xiaGREEN      = 1;
191                                      //数码管显示部分
192             DisplayData[0]=0x00;
193             DisplayData[1]=0x00;
194             DisplayData[2]=smgduan[(71-second)%100/10];
195             DisplayData[3]=smgduan[(71-second)%10];
196 
197             DisplayData[4]=0x00;
198             DisplayData[5]=0x00;
199             DisplayData[6]=DisplayData[2];
200             DisplayData[7]=DisplayData[3];
201 
202             DigDisplay();
203         }
204     }
205 }
206 
207 void Timer0() interrupt 1      //编写中断函数（定时器函数名 中断号）
208 {
209     static u16 i;    
210 
211     TH0  = 0xfc;              //重载初值,定时1ms
212     TL0  = 0x18;
213     
214     i++;
215     if(i == 1000)
216     {
217         i = 0;
218         second++;
219         
220     }    
221 }

  1 #include "reg51.h"              
  2 #include "intrins.h"           //包含循环函数坐在的库
  3 
  4 typedef unsigned char u8;       //字符型数据一般为8位
  5 typedef unsigned int u16;       //整型数据一般为16位
  6 
  7 #define GPIO_DIG     P0           //数码管段选管脚     宏定义
  8 
  9 sbit LSA = P2^2;
 10 sbit LSB = P2^3;
 11 sbit LSC = P2^4;
 12 
 13 u8 code smgduan[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
 14                      0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//共阴数码管
 15 
 16 u8 DisplayData[8];               //数码管显示数组，存放
 17 
 18 unsigned long TimeCount;       //累计时间
 19 unsigned long Freq;               //脉冲频率（累计次数）
 20 
 21 
 22 void delay(u16 i)               //延时函数
 23 {
 24     while(i--);
 25 }
 26 
 27 
 28 void DigDisplay()               //数码管显示函数
 29 {
 30     u8 i;
 31     for(i = 0; i < 8; i++)
 32     {
 33         switch(i)
 34         {
 35             case(0):
 36                 LSA=0;LSB=0;LSC=0; break;//显示第0位
 37             case(1):
 38                 LSA=1;LSB=0;LSC=0; break;//显示第1位
 39             case(2):
 40                 LSA=0;LSB=1;LSC=0; break;//显示第2位
 41             case(3):
 42                 LSA=1;LSB=1;LSC=0; break;//显示第3位
 43             case(4):
 44                 LSA=0;LSB=0;LSC=1; break;//显示第4位
 45             case(5):
 46                 LSA=1;LSB=0;LSC=1; break;//显示第5位
 47             case(6):
 48                 LSA=0;LSB=1;LSC=1; break;//显示第6位
 49             case(7):
 50                 LSA=1;LSB=1;LSC=1; break;//显示第7位
 51         }
 52 
 53         GPIO_DIG = DisplayData[i];          
 54         delay(10);
 55         GPIO_DIG=0x00;
 56     }    
 57 }
 58 
 59 void Timer_Config()      //定时器0计数器1配置函数
 60 {
 61     TMOD = 0x51;              //设置T1为计数器，T0为定时器,工作方式均为1
 62     TH0  = 0x3C;              //设置定时时间为50ms
 63     TL0  = 0xB0;
 64 
 65     EA   = 1;                  //打开总中断
 66     
 67     ET0  = 1;                  //打开定时器0中断允许位
 68     ET1  = 1;                  //打开计数器1中断允许位
 69     
 70     TR0  = 1;                  //启动定时器定时
 71     TR1  = 1;                  //启动计数器计数
 72 }
 73 
 74 void main()
 75 {
 76     Timer_Config();            //调用定时器0计数器1初始化函数
 77     
 78     while(1)
 79     {
 80         if(TR1 == 0)                //判断时间是否到1s
 81         {
 82              Freq = Freq + TL1;        //加上低八位    求频率值
 83             Freq = Freq + (TH1*256);    //加上高八位
 84 
 85             DisplayData[0] = smgduan[Freq%1000000/100000];//数码管显示第一位
 86             DisplayData[1] = smgduan[Freq%100000/10000];  //数码管显示第二位
 87             DisplayData[2] = smgduan[Freq%10000/1000];    //数码管显示第三位
 88             DisplayData[3] = smgduan[Freq%1000/100];      //数码管显示第四位
 89             DisplayData[4] = smgduan[Freq%100/10];        //数码管显示第五位
 90             DisplayData[5] = smgduan[Freq%10];            //数码管显示第六位
 91 
 92             Freq = 0;               //频率值清零，方便下一次累加
 93 
 94             TL1 = 0;               //计数器清零
 95             TH1 = 0;                    
 96 
 97             TR0  = 1;               //打开定时器
 98             TR1  = 1;               //打开计数器
 99         }
100         DigDisplay();               //放在if外面，目的是动态显示
101     }
102 }
103 
104 void Timer0() interrupt 1      //定时器0中断函数 ，定时达到50ms的时候进入中断，然后根据定时的次数可以得到累计的时间
105 {                              
106     TH0  = 0x3C;              //设置定时时间为50ms
107     TL0  = 0xB0;
108     
109     TimeCount++;
110     if(TimeCount == 20)          //定时达到1s
111     {
112         TimeCount = 0;          //清零
113         TR1 = 0;              //关闭计数器
114         TR0 = 0;              //关闭定时器
115     }    
116 }
117 
118 void Timer1() interrupt 3      //计数器1中断函数，每逢65536个（脉冲溢出）脉冲就计数一次
119 {
120     Freq = Freq + 65536;        
121 }

 1 #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 void UsartInit()              //串口初始化
 7 {
 8     TMOD = 0x20;              //设置定时器1为八位自动重装载工作方式
 9     SCON = 0x50;              //设置串口工作方式为1
10     PCON = 0x80;              //设置波特率倍增1倍
11 
12     TH1  = 0xF3;              //设置T1初值
13     TL1  = 0xF3;              
14 
15     EA   = 1;                  //打开总中断
16     ES   = 1;                  //打开串口中断
17     TR1     = 1;                  //打开定时器1
18 }
19 
20 void main()
21 {
22     UsartInit();
23     while(1);
24 }
25 
26 void Usart() interrupt 4      //中断函数
27 {
28     u8 ReceiveData;              //定义变量来保存数据
29     ReceiveData = SBUF;          //将接受到的数据保存到变量
30 
31     RI = 0;                      //当串行接收第八位数据结束，串行接收停止位的中间时，由内部硬件使RI置1，
32                               //向CPU发送中断申请，因此需要软件清0准备下一次接收
33     
34     SBUF = ReceiveData;          //将数据返回到上位PC机，发送完成之后TI由硬件置1
35 
36     while(!TI);                  //判断TI是否为1，即是否发送完成，发送完成之后跳出while循环
37     
38     TI = 0;                      //软件清0准备下一次发送
39 }

 1 #include "reg51.h"
 2 
 3 typedef unsigned char u8;      //字符型数据一般为8位
 4 typedef unsigned int u16;      //整型数据一般为16位
 5 
 6 sbit DIR = P1^0;
 7 
 8 void delay(u8 i)
 9 {
10     while(i--);
11 }
12 
13 void UsartInit()              //串口初始化
14 {
15     TMOD = 0x20;              //设置定时器1为八位自动重装载工作方式
16     SCON = 0x50;              //设置串口工作方式为1
17     PCON = 0x80;              //设置波特率倍增1倍
18 
19     TH1  = 0xF3;              //设置T1初值
20     TL1  = 0xF3;              
21 
22     EA   = 1;                  //打开总中断
23     ES   = 1;                  //打开串口中断
24     TR1     = 1;                  //打开定时器1
25     
26     DIR  = 0;                  //设置485芯片接收状态
27 }
28 
29 void main()
30 {
31     UsartInit();
32     while(1);
33 }
34 
35 void Usart() interrupt 4      //中断函数
36 {
37     u8 ReceiveData;              //定义变量来保存数据
38     ReceiveData = SBUF;          //将接受到的数据保存到变量
39 
40     RI = 0;                      //当串行接收第八位数据结束，串行接收停止位的中间时，由内部硬件使RI置1，
41                               //向CPU发送中断申请，因此需要软件清0准备下一次接收
42 
43     delay(100);
44 
45     DIR=1;                      //设置485芯片发送状态
46     
47     SBUF = ReceiveData;          //将数据返回到上位PC机，发送完成之后TI由硬件置1
48 
49     while(!TI);                  //判断TI是否为1，即是否发送完成，发送完成之后跳出while循环
50     
51     TI = 0;                      //软件清0准备下一次发送
52 
53     DIR=0;                      //清零
54 }

  1 #include "reg51.h"
  2 #include"i2c.h"
  3 
  4 typedef unsigned char u8;      //字符型数据一般为8位
  5 typedef unsigned int u16;      //整型数据一般为16位
  6 
  7 sbit k1 = P3^1;                  //保存数据
  8 sbit k2 = P3^0;                  //显示保存的数据
  9 sbit k3 = P3^2;                  //显示的数据累加
 10 sbit k4 = P3^3;                  //清零
 11 
 12 sbit LSA = P2^2;
 13 sbit LSB = P2^3;
 14 sbit LSC = P2^4;
 15 
 16 u8 code smgduan[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//共阴
 17 u8 num=0;
 18 u8 disp[4];
 19 
 20 void delay(u16 i)
 21 {
 22      while(i--);
 23 }
 24 
 25 void Keypros()
 26 {    
 27     if(k1==0)                         //保存
 28     {
 29           delay(1000);
 30          if(k1==0)
 31          {
 32              AT24C02Write(1,num);
 33          }
 34          while(!k1);
 35     }
 36     if(k2==0)                         //读取
 37     {
 38           delay(1000);
 39          if(k2==0)
 40          {
 41              num = AT24C02Read(1);
 42          }
 43          while(!k2);
 44     }
 45     if(k3==0)                          //累加
 46     {
 47           delay(1000);
 48          if(k3==0)
 49          {
 50              num++;
 51             if(num>255) num=0;
 52          }
 53          while(!k3);
 54     }
 55     if(k4==0)
 56     {
 57           delay(1000);
 58          if(k4==0)
 59          {    
 60              num = 0;
 61          }
 62          while(!k4);
 63     }
 64 }
 65 
 66 void DigDisplay()                //数码管显示
 67 {
 68     u8 i;
 69     for(i = 0; i < 4; i++)
 70     {
 71         switch(i)
 72         {
 73             case(0):
 74                 LSA=0;LSB=0;LSC=0; break;//显示第0位
 75             case(1):
 76                 LSA=1;LSB=0;LSC=0; break;//显示第1位
 77             case(2):
 78                 LSA=0;LSB=1;LSC=0; break;//显示第2位
 79             case(3):
 80                 LSA=1;LSB=1;LSC=0; break;//显示第3位
 81         }
 82         P0 = disp[i];          
 83         delay(100);
 84         P0=0x00;                          //消隐
 85     }    
 86 }
 87 
 88 void DataPros()                             //数据处理
 89 {
 90     disp[0]=smgduan[num/1000];
 91     disp[1]=smgduan[num%1000/100];
 92     disp[2]=smgduan[num%1000%100/10];
 93     disp[3]=smgduan[num%1000%100%10];
 94 }
 95 
 96 void main()
 97 {
 98     
 99     while(1)
100     {
101         Keypros();
102         DataPros();
103         DigDisplay();
104     }
105 }

  1 #include"i2c.h"
  2 
  3 void delay10us()         //延时10us函数
  4 {
  5     unsigned char a,b;
  6     for(b=1;b>0;b--)
  7         for(a=2;a>0;a--);
  8 }
  9 
 10 void I2CStart()             //起始信号
 11 {
 12     SDA = 1;                 //在SCL为高电平期间，
 13     delay10us();             //SDA由高电平向低电平变化表示起始信号
 14     SCL = 1;
 15     delay10us();
 16     SDA = 0;
 17     delay10us();
 18     SCL = 0;                 //
 19     delay10us();
 20 }
 21 
 22 void I2CStop()             //终止信号
 23 {
 24      SDA = 0;                 //在SCL为高电平期间，
 25     delay10us();             //SDA由低电平向高电平变化表示终止信号
 26     SCL = 1;
 27     delay10us();
 28     SDA = 1;
 29     delay10us();
 30 }
 31 
 32 unsigned char I2CSendByte(unsigned char dat)    //发送函数
 33 {
 34      unsigned char a=0, b=0;       //dat为传输的字节
 35     for(a=0;a<8;a++)
 36     {
 37          SDA = dat>>7;        //先把数据最高位右移七位到最低位上，发送出去
 38         dat = dat<<1;        //将次高位左移到最高位上，等待下一次循环发送
 39          delay10us();
 40         SCL = 1;            //时钟线在1到0之间翻转，在为0的时候数据发生变化，准备下一次发送
 41          delay10us();
 42         SCL = 0;
 43          delay10us();        
 44     }
 45     SDA = 1;                //释放数据线
 46     delay10us();
 47     SCL = 1;                //释放时钟线
 48     while(SDA)                //判断数据线的状态，给出返回值表示是否应答，数据线为1时为非应答，进入while循环
 49     {
 50         b++;        
 51         if(b > 200)
 52         {
 53              SCL = 0;
 54             delay10us();
 55             return 0;        //返回值0，表示通讯失败
 56         }
 57     }
 58     SCL = 0;                //若数据线为0.则不进入while循环，直接拉低时钟线，准备下一次发送
 59     delay10us();
 60     return 1;                //返回值1，表示应答，发送成功
 61 }
 62 
 63 unsigned char I2CReadByte()    //IIC接收读取函数
 64 {
 65      unsigned char a=0, dat=0;
 66     SDA = 1;                     //拉高，使数据线处于空闲状态
 67     delay10us();
 68     for(a=0;a<8;a++)
 69     {
 70          SCL = 1;
 71         delay10us();
 72         dat<<=1;
 73         dat |= SDA;
 74         delay10us();
 75          SCL = 0;
 76         delay10us();
 77     }
 78     return dat;
 79 }
 80 
 81 void AT24C02Write(unsigned char addr, unsigned char dat) //AT24C02写入函数
 82 {
 83      I2CStart();             //起始信号
 84     I2CSendByte(0xa0);     //器件地址
 85     I2CSendByte(addr);     //首地址
 86     I2CSendByte(dat);     //发送数据
 87     I2CStop();             //停止信号
 88 }
 89 
 90 unsigned char AT24C02Read(unsigned char addr)     //AT24C02读取函数
 91 {
 92      unsigned char num;
 93     
 94     I2CStart();             //起始信号
 95     I2CSendByte(0xa0);     //器件地址
 96     I2CSendByte(addr);     //发送首地址
 97      I2CStart();             //重新发送起始信号，数据帧格式，改变传输方向
 98 
 99     I2CSendByte(0xa1);     //读器件地址
100     num = I2CReadByte(); //读取数据并保存到num
101     I2CStop();             
102     return num;
103 }

 1 #ifndef _I2C_H
 2 #define _I2C_H
 3 
 4 #include <reg51.h>
 5 
 6 sbit SDA = P2^0;
 7 sbit SCL = P2^1;
 8 
 9 void I2CStart();        //起始信号
10 
11 void I2CStop();            //终止信号
12 
13 unsigned char I2CSendByte(unsigned char dat);    //发送函数
14 
15 unsigned char I2CReadByte();    //接收读取函数
16 
17 void AT24C02Write(unsigned char addr, unsigned char dat); //AT24C02写入函数
18 
19 unsigned char AT24C02Read(unsigned char addr);     //AT24C02读取函数
20 
21 #endif

 1 #include "reg51.h"
 2 #include "temp.h"
 3 
 4 typedef unsigned char u8;      //字符型数据一般为8位
 5 typedef unsigned int u16;      //整型数据一般为16位
 6 
 7 sbit LSA=P2^2;                  //38译码器
 8 sbit LSB=P2^3;
 9 sbit LSC=P2^4;
10 
11 char num = 0;
12 u8 DisplayData[8];
13 u8 code smgduan[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
14 
15 void delay(u16 i)              //延时函数
16 {
17      while(i--);
18 }
19 
20 void datapros(int temp)      
21 {
22        float tp;  
23     if(temp<0)                //当温度值为负数
24       {
25         DisplayData[0]=0x40;//在数码管上显示负号“-”
26 
27         temp=temp-1;        //负温度要进行还原，得到实际温度
28         temp=~temp;
29 
30         tp=temp;
31         temp=tp*0.0625*100+0.5;    //加上0.5是四舍五入 
32       }
33      else
34       {            
35         DisplayData[0]=0x00;    //不显示负号
36         tp=temp;            //因为数据处理有小数点所以将温度赋给一个浮点型变量
37         temp=tp*0.0625*100+0.5;    
38     }
39     DisplayData[1]=smgduan[temp/10000];
40     DisplayData[2]=smgduan[temp%10000/1000];
41     DisplayData[3]=smgduan[temp%1000/100]|0x80;    //让小数点亮起来
42     DisplayData[4]=smgduan[temp%100/10];
43     DisplayData[5]=smgduan[temp%10];
44 }
45 
46 void DigDisplay()
47 {
48     u8 i;
49     for(i=0;i<6;i++)
50     {
51         switch(i)     //位选，选择点亮的数码管，
52         {
53             case(0):
54                 LSA=0;LSB=0;LSC=0; break;//显示第0位
55             case(1):
56                 LSA=1;LSB=0;LSC=0; break;//显示第1位
57             case(2):
58                 LSA=0;LSB=1;LSC=0; break;//显示第2位
59             case(3):
60                 LSA=1;LSB=1;LSC=0; break;//显示第3位
61             case(4):
62                 LSA=0;LSB=0;LSC=1; break;//显示第4位
63             case(5):
64                 LSA=1;LSB=0;LSC=1; break;//显示第5位    
65         }
66         P0=DisplayData[i];//发送数据
67         delay(100); //间隔一段时间扫描    
68         P0=0x00;//消隐
69     }        
70 }
71 
72 void main()                      //主函数
73 {
74     while(1)
75     {
76         datapros(DS18B20ReadTemp());
77         DigDisplay();
78     }
79 }

 1 #include "temp.h"
 2 
 3 void Delay1ms(uint y)    //延时yms，根据y的数值来选择延时的具体时间
 4 {
 5     uint x;
 6     for( ; y>0; y--)
 7     {
 8         for(x=110; x>0; x--);
 9     }
10 }
11 
12 uchar DS18B20Init()        //DS18B20初始化  返回值1表示初始化成功 0失败
13 {
14     uchar i=0;
15     DSPORT=0;            //数据线拉低到低电平
16     i=70;
17     while(i--);            //延时642us
18     DSPORT=1;            //数据线拉高电平
19     i=0;
20     while(DSPORT)        //等待DS18B20拉低总线
21     {
22         Delay1ms(1);    //延时1ms
23         i++;
24         if(i>5)            //超时判断 等待5ms
25         {
26              return 0;    //返回值0初始化失败
27         }
28     }
29     return 1;            //初始化成功
30 }
31 
32 void DS18B20WriteByte(uchar dat)
33 {                         //按从低位到高位的顺序发送字节（一次只发送一位）
34      uint i, j;
35 
36     for(j=0;j<8;j++)
37     {
38          DSPORT=0;
39         i++;
40         DSPORT=dat&0x01; //“与” 一个为0结果为0，使除最低位的其它位都为0
41         i=6;
42         while(i--);         //延时68us
43          DSPORT=1;         //数据线拉高释放
44         dat>>=1;         //右移一位
45     }
46 }
47                          
48 uchar DS18B20ReadByte()
49 {
50      uint i, j;             //i用作延时，j用作循环计数
51     uchar bi, byte;         //bi用来过渡只保存传输中的一位，byte保存最终读到的数据
52     for(j=8;j>0;j--)
53     {
54          DSPORT=0;         //数据线拉低
55         i++;             //延时1us
56          DSPORT=1;         //数据线拉高，释放总线准备读数据
57         i++;             //延时10us
58         i++;
59         bi=DSPORT;         //开始读取数据
60         byte=(byte>>1)|(bi<<7);     //先右移一位，然后读入数据，先放到最高位，然后经过七次移位移到最低位
61         i=4;
62         while(i--);         //延时45us
63     }                     
64     return byte;         //返回读取到的数据
65 }
66 
67 void DS18B20TempChange() //转换温度
68 {
69      DS18B20Init();
70     Delay1ms(1);
71     DS18B20WriteByte(0xcc);       //单片工作，直接向DS18B20发送温度转换命令
72     DS18B20WriteByte(0x44);       //启动DS18B20进行温度转换
73                                //连续读取，所以不加延时
74 }
75 
76 void DS18B20ReadTempCom() //发送温度读取命令
77 {
78      DS18B20Init();
79     Delay1ms(1);
80     DS18B20WriteByte(0xcc);       //单片工作，直接向DS18B20发送温度转换命令
81     DS18B20WriteByte(0xbe);       //读取内部RAM中9字节的内容
82 }
83 
84 int DS18B20ReadTemp()     //温度读取
85 {
86      int temp=0;
87     uchar tmh, tml;         //tmh存储读取的高八位字节数据，tml低八位字节
88     
89     DS18B20TempChange();       //调用温度转换
90     DS18B20ReadTempCom();       //发送温度读取命令
91 
92     tml    = DS18B20ReadByte();
93     tmh = DS18B20ReadByte();   //存储变量
94 
95     temp = tmh;                   //将高八位和第八位组合成16位数据
96     temp<<=8;
97     temp|=tml;
98     return temp;
99 }

 1 #ifndef __TEMP_H_
 2 #define __TEMP_H_
 3 
 4 #include<reg51.h>
 5 
 6 #ifndef uchar                      //重定义关键词
 7 #define uchar unsigned char 
 8 #endif
 9 
10 #ifndef uint 
11 #define uint unsigned int 
12 #endif
13 
14 sbit DSPORT = P3^7;                 //定义IO口
15 
16                                  //函数声明
17 void Delay1ms(uint y);    //延时yms，根据y的数值来选择延时的具体时间
18 uchar DS18B20Init();        //DS18B20初始化  返回值1表示初始化成功 0失败
19 void DS18B20WriteByte(uchar dat);
20 uchar DS18B20ReadByte();
21 void DS18B20TempChange(); //转换温度
22 void DS18B20ReadTempCom(); //发送温度读取命令
23 int DS18B20ReadTemp();     //温度读取
24 
25 #endif