#include<STC15F2K60S2.H>
#define uchar unsigned char
#define uint unsigned int
sbit led_sel=P2^3;//P2^3----E3   对引脚的声明，大小为一位！  用"^"来声明引脚是C51特定的，指明IO口的引脚位置
uchar led;      //一定要注意，因为P0是8个引脚，所以就8位，所以要定义成char！  不要定义成int，很容易因为移位等操作出错

void Init(){

	P0M1=0x00;
	P0M0=0xff;     //P0口的控制寄存器

	P2M1=0x00;
	P2M0=0x08;

	led_sel=1;	   //看电路图，P23有非门，置1才使二极管阴极为0
}

//STC-ISP“软件延时计算器”生成
void delay_ms(uint n)		
{
	while(n){
	uchar i, j;
	i = 11;
	j = 190;
	do
	{
		while (--j);
	} while (--i);
	n--;
}
}

void Delay200ms()		//@11.0592MHz
{
	unsigned char i, j, k;

	//_nop_();
	//_nop_();
	i = 9;
	j = 104;
	k = 139;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}


void main()
{
	Init();
	led=0x01;
	while(1)                          //让程序一直跑，死循环不退出
	{
		P0=led;                     //对端口赋值，设置引脚电平
		//delay_ms(200);
		Delay200ms(); //延时200ms	
		if(led==0x80)                  //也可以用_crol_函数去循环左移，就不用判断0x80的情况了  汇编为rol指令   rotate left
			led=0x01;
		else
			led=led<<1;   //每次就亮一盏灯。所以用移位！
	}
	
}

#include <STC15F2K60S2.h>
#define uint unsigned int
#define uchar unsigned char

uint i=0;
uchar duanxuan[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f}; //显示0-8
uchar weixuan[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07}; //数码管0-7，P2.3是数码管的位选，但是有反相器，所以P2.3置0，数码管才能工作

void Delay(int n)				
{
	while(n--);
}

void main()
{
	P2M0=0xff;				//设置推挽输出
   	P2M1=0x00;
    P0M0=0xff;
    P0M1=0x00;

	while(1)
	{
		for(i=0;i<8;i++)
		{
			P0=0;
			P2=weixuan[i];		//选择数码管位数
			P0=duanxuan[i+1];	//显示对应数值
			Delay(600);
		}
	}
}

#include <STC15F2K60S2.h>
#define uint unsigned int
#define uchar unsigned char

uchar arrSeg7Select[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f}; //显示0-8
uchar arrDigitSelect[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};   //数码管0-7

sbit sbtLedSel = P2 ^ 3;  //ÊýÂë¹ÜÓëLEDµÆÇл»Òý½Å

/*---------±äÁ¿¶¨Òå---------*/
uchar uiLed = 0x01;        //LED灯值寄存
uint  uiLedCnt = 0;        //LED累计计数器
uchar i = 0;               //数码管扫描循环显示

/*---------³õʼ»¯º¯Êý---------*/
void Init()
{
    P0M1 = 0x00;
    P0M0 = 0xff;
    P2M1 = 0x00;
    P2M0 = 0x08;
    sbtLedSel = 0;  //先选择数码管亮
}

//延时n毫秒
void delay_ms( uint n )
{
    while( n )
    {
        uchar i, j;
        i = 11;
        j = 190;
        do
        {
            while ( --j );
        }
        while ( --i );
        n--;
    }
}


void main()
{
    Init();
    while( 1 )
    {
        sbtLedSel = 0;
        for( i = 0; i < 8; i++ )
        {
            P0 = 0;
            P2 = arrDigitSelect[i];     //选择数码管位数
            P0 = arrSeg7Select[i + 1];  //显示对应数值
            delay_ms( 1 );
        }
        uiLedCnt++;
        sbtLedSel = 1;
        P0 = uiLed;                     //LED灯显示
        delay_ms( 1 );                  //延时1ms
        if( uiLedCnt == 50 )   //同一个灯亮50次，再换下一个灯
        {
            if( uiLed == 0x80 )        //rotate
                uiLed = 0x01;
            else
                uiLed = uiLed << 1;    //流水灯左移
            uiLedCnt = 0;
        }
    }
}

#include"STC15F2K60S2.H"

//引脚
sbit KEY1 = P3^2;
sbit KEY2 = P3^3;
sbit KEY3 = P1^7;
sbit led_sel = P2^3;

void main()
{
	//推挽输出
	P0M0 = 0XFF;
	P0M1 = 0X00;
	P2M0 = 0X08;
	P2M1 = 0X00;
	
	led_sel = 1;			//让LED发光
	P0 = 0;						//初始化P0，让灯全灭
	
	while(1)
	{
		if(KEY1 == 0)		//key1被按下
			P0 |= 0x01;		//L0发光
		else
			P0 &= ~0x01;	//L0熄灭
		
		if(KEY2 == 0)		
			P0 |= 0x02;		
		else
			P0 &= ~0x02;
		
		if(KEY3 == 0)	
			P0 |= 0x04;		
		else
			P0 &= ~0x04;	
	}
}

#include "STC15F2K60S2.H"	

#define uchar unsigned char		
#define uint  unsigned int

sbit beep = P3^4;					//蜂鸣器
sbit key1 = P3^2;					//按键1

bit flag;						   //蜂鸣器开关的标志

void init()
{
	//ÉèÖÃÍÆÍìģʽ
	P3M1=0x00;
	P3M0=0x10;					  //设置P3^4为推挽模式

	TMOD=0x00;					  //设置定时器0，工作模式0，16位自动重装定时器
	TH0=0xff;					  //定时器初值
	TL0=0x03;
	EA=1;						  //打开总中断
	ET0=1;						  //定时器0的中断允许位
	TR0=1;

	flag=0;						  //标志位置1
	P0=0x00;					  //关闭P0端口
	beep=0;						  //蜂鸣器引脚置0，保护蜂鸣器   因为板子复位时，所有引脚为高电平
}


void delay(uint xms)
{
	uchar i;
	for(; xms>0; xms--)						
		for(i=114; i>0; i--)
		{
			;
		}
}	 

void main()
{
	init();
	while(1)
	{
		if(key1==0)         //按下
		{	
			delay(10);						 //延时消抖
			if(key1==0)
			{									  
				while(!key1);       //key1松开才停止循环，去翻转蜂鸣器开关标志
				flag=~flag;		   //开关标志位翻转，用于中断函数内去翻转开关，产生方波
			}
		}
	}
}

/********************
	 定时器中断
********************/
void timer0() interrupt 1               //用定时器来定时产生方波
{
	if(flag)
	{
		beep=~beep;				   //产生方波使得蜂鸣器发声
	}
	else
	{
		beep=0;				      //flag=0时，说明已经再次按下了key1，那么蜂鸣器就该停止发声
	}
}

/**********************
进行实时时钟模块测试的例程
采用定时器0，方式1通过数码管对时间进行显示
***********************/

/**********************
基于STC15F2K60S2系列单片机C语言编程实现
使用如下头文件，不用另外再包含"REG51.H"
***********************/
#include"STC15F2K60S2.H" //头文件
#include"intrins.H" //头文件

#define uchar unsigned char 	   //宏定义
#define uint unsigned int

/***********时分秒写寄存器**************/
#define DS1302_SECOND_WRITE 0x80	//不是sfr，是ds1302对应功能的控制字
#define DS1302_MINUTE_WRITE 0x82
#define DS1302_HOUR_WRITE   0x84 
#define DS1302_WEEK_WRITE   0x8A
#define DS1302_DAY_WRITE    0x86
#define DS1302_MONTH_WRITE  0x88
#define DS1302_YEAR_WRITE   0x8C

/***********时分秒读寄存器**************/
#define DS1302_SECOND_READ  0x81
#define DS1302_MINUTE_READ  0x83
#define DS1302_HOUR_READ    0x85 
#define DS1302_WEEK_READ    0x8B
#define DS1302_DAY_READ     0x87
#define DS1302_MONTH_READ   0x89
#define DS1302_YEAR_READ    0x8D

/**********************
引脚别名定义
***********************/
/********DS1302*******/
sbit Rtc_sclk = P1^5;			//时钟线引脚,控制数据的输入与输出
sbit Rtc_rst  = P1^6;			//CE线引脚,读、写数据时必须置为高电平
sbit Rtc_io   = P5^4;			//实时时钟的数据线引脚
/********数码管显示******/
sbit Led_sel = P2^3;		   //流水灯和数码管选通引脚
sbit Sel0    = P2^0;		   //Sel0、Sel1、Sel2三位二进制进行数码管位选0-7  	
sbit Sel1    = P2^1;
sbit Sel2    = P2^2;

/**********************
变量定义
***********************/
uchar duanxuan[]={ 					  //数码管显示所要用的段码
 
                0x3F,  //"0"
                0x06,  //"1"
                0x5B,  //"2"
                0x4F,  //"3"
                0x66,  //"4"
                0x6D,  //"5"
                0x7D,  //"6"
                0x07,  //"7"
                0x7F,  //"8"
                0x6F,  //"9"
                0x77,  //"A"
                0x7C,  //"B"
                0x39,  //"C"
                0x5E,  //"D"
                0x79,  //"E"
                0x71,  //"F"
                0x76,  //"H"
                0x38,  //"L"
                0x37,  //"n"
                0x3E,  //"u"
                0x73,  //"P"
                0x5C,  //"o"
                0x40,  //"-"
                0x00,  //熄灭
                0x00  //自定义
 
                };

uchar weixuan[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};	   //数码管位选数组
uchar flag;					 //所选择点亮的数码管0-7标志位
uchar temp;					 //要写入到DS1302的数据

/**********************
定义时间结构体
***********************/
typedef struct __SYSTEMTIME__
{
	uchar Second;
	uchar Minute;
	uchar Hour;
	uchar Week;
	uchar Day;
	uchar Month;
	uchar Year;
}SYSTEMTIME; 			//定义的时间类型

SYSTEMTIME t;			

/*******************************
 * 函数名：Delayms
 * 描述  ：毫秒延时程序
 * 输入  ：延时i毫秒
 * 输出  ：无
 *******************************/
void Delayms(char i) 			
{
	while(i--)
	{	
		int n=500;
		while (n--)
	    {
	        _nop_();
	        _nop_();
	        _nop_();
	        _nop_();
	        _nop_();
			_nop_();
	    }
	}
}

/**********************
函数名称：Ds1302_write
功能描述：Ds1302写入一字节
入口参数：uchar 要写入的数据 
***********************/
//单个字节写：在前 8 个 SCLK 时钟周期，上升沿写入控制字，在后 8 个 SCLK 时钟周期，上升沿写入数据字；均从最低位开始。   在这里由代码生成sclk的波形，来控制数据写入
void Ds1302_write(uchar temp) 		 //temp:要写入的数据
{
	uchar i;
	for(i=0;i<8;i++)				 //循环8次写入一个字节
	{
		Rtc_sclk=0;					//时钟脉冲拉低
		Rtc_io=(bit)(temp&0x01);	 //取最低位数据
		temp>>=1;					 //右移一位
		Rtc_sclk=1;					  //上升沿输入 	
	}
}
/**********************
函数名称：Ds1302_read
功能描述：Ds1302读取一字节
入口参数：无
出口参数：返回uchar 读出的数据
***********************/
uchar Ds1302_read()	 
{
	 uchar i, dat;
	 for(i=0;i<8;i++)			
	 {
	 	Rtc_sclk=0;				//时钟脉冲拉低	 下降沿时读取
	 	dat>>=1;				//要返回的数据右移一位	 
		if(Rtc_io==1)			//数据线为高，证明该位数据为1
		dat|=0x80;				//要传输数据的当前值置为1，若不是，则为0
		Rtc_sclk=1;				//拉高时钟线 
	 }
	 return dat;				//返回读取出的数据
}


/**********************
函数名称：WriteDS1302
功能描述：向Addr对应的寄存器中写入数据Data
入口参数：uchar Addr 寄存器地址, uchar Data 要写入寄存器的数据
***********************/
void WriteDS1302(uchar Addr, uchar Data) 	   //Addr: DS1302地址,Data: 要写的数据
{
    Rtc_rst = 0;						 //初始CE线置0
    Rtc_sclk = 0;						 //初始时钟线置0
    Rtc_rst = 1;						 //初始CE线置为1，传输开始
	Ds1302_write(Addr);					 // 地址，传输命令字   即控制字，写到控制字寄存器
	Ds1302_write(Data);			   		 // 写1Byte数据 
	Rtc_rst = 0;   						 //读取结束，CE置0，结束数据的传输
    Rtc_sclk = 1;						 //时钟线拉高
}

/**********************
函数名称：ReadDS1302
功能描述：读出Addr对应的寄存器中的数据
入口参数：uchar cmd 寄存器地址
***********************/
uchar ReadDS1302(uchar cmd)
{
    uchar Data;
    Rtc_rst = 0;			  //初始CE线置为0
    Rtc_sclk = 0;			  //初始时钟线置为0     就算之前sclk为高电平，产生下降沿,io口读数据也没事   因为读数据只是ds1302把数据传到io口，我们并没有进行接收，所以没事
    Rtc_rst = 1;			  //初始CE置为1，传输开始
    Ds1302_write(cmd);        // 地址，传输命令字 
    Data =Ds1302_read();      // 读1Byte数据	  
	Rtc_rst = 0;			  //读取结束，CE置为0，结束数据的传输
    Rtc_sclk = 1; 			  //时钟线拉高       write/read完sclk都是=1
    return Data;			  //返回得到的数据
}

/**********************
函数名称：DS1302_GetTime_BCD
功能描述：读出DS1302中时、分、秒、年、月、日寄存器中对应的数据
***********************/

SYSTEMTIME DS1302_GetTime()
{
	SYSTEMTIME Time;
 	uchar ReadValue;
 	ReadValue = ReadDS1302(DS1302_SECOND_READ);       //1字节
 	//将BCD码转换成十进制
 	Time.Second=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);		  //读取秒寄存器中的数据
	ReadValue=ReadDS1302(DS1302_MINUTE_READ);
 	Time.Minute = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);		  //读取分寄存器中的数据
 	ReadValue = ReadDS1302(DS1302_HOUR_READ);
 	Time.Hour = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);		  //读取时寄存器中的数据
	ReadValue = ReadDS1302(DS1302_DAY_READ);
 	Time.Day = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F); 		  //读取日寄存器中的数据
 	ReadValue = ReadDS1302(DS1302_WEEK_READ);
 	Time.Week = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);		  //读取周寄存器中的数据
 	ReadValue = ReadDS1302(DS1302_MONTH_READ);
 	Time.Month = ((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);		  //读取月寄存器中的数据
 	ReadValue = ReadDS1302(DS1302_YEAR_READ);
 	Time.Year=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F); 			  //读取年寄存器中的数据

	return Time;
}

/**********************
函数名称：Init
功能描述：完成各部分功能模块的初始化
入口参数：无 
出口参数：无
备注：
***********************/
void Init()
{
 	P2M0=0xff;				 //设置推挽模式
   	P2M1=0x00;
    P0M0=0xff;
    P0M1=0x00;

	Led_sel=0;				 //选通数码管

 	TMOD=0x01;				//定时器0，方式1
	EA=1;					//打开总的中断
	ET0=1;					//开启定时器中断	
 	TH0=(65535-1000)/256;	//设置定时初值
	TL0=(65535-1000)%256;
	TR0=1;					//启动定时器
}

void Initial_DS1302(void)	
{
 	WriteDS1302(0x8E,0x00);			 //禁止写保护位，因为初始化要进行写操作	
	temp=ReadDS1302(DS1302_SECOND_READ)&0x7f ;   //第7位置0，启动晶振
	WriteDS1302(0x80,temp);		   	//晶振开始工作
	WriteDS1302(0x8E,0x80);			 //写保护位置1，现在开始不能写了  
}	

/********************************定时器中断处理程序************************************************/
void timer0() interrupt 1	  //把数码管的显示提到中断里面来了
 {
 	TH0=(65535-1000)/256;	  //重新填充初值  定时1ms
	TL0=(65535-1000)%256;

	/********显示程序*******/
	flag++;						  //初值为0
	if(flag==8)					  
	flag=0;
	P0=0x00;					//先初始化，什么都不亮		   
	P2=weixuan[flag];
	switch(flag)
	{
		case 0:P0=duanxuan[t.Hour/10];break; 
	    case 1:P0=duanxuan[t.Hour%10];break; 
		case 3:P0=duanxuan[t.Minute/10];break; 
		case 4:P0=duanxuan[t.Minute%10];break; 
		case 6:P0=duanxuan[t.Second/10];break; 
		case 7:P0=duanxuan[t.Second%10];break; 
		default:P0=duanxuan[22];break;					  //duanxuan[22]所对应的字符为“-”
	}	
}

void main()
{
	Init();
	if (ReadDS1302(DS1302_SECOND_READ)&0x80)			  //判断掉电之后时钟是否还在运行
	Initial_DS1302();									  //若没有运行，则进行DS1302初始化
	while(1)
	{
		Delayms(300);
		t=DS1302_GetTime();								 //取时间各数据放到结构体t中
	}	

}

/**************************
说明：导航按键的例程
修改：消除数码管显示中的残影
**************************/

/**************************
使用头文件如下：
**************************/

#include "STC15F2K60S2.H" 
#include <intrins.h>			  //_cror_(); 

#define uint unsigned int
#define ulint unsigned long
#define uchar unsigned char
#define ADC_FLAG 0x10

/**************************
引脚别名定义如下：
**************************/

sbit SEL0 = P2^0;
sbit SEL1 = P2^1;
sbit SEL2 = P2^2;
sbit LED_SEL = P2^3;

/**************************
定义变量如下：
**************************/

uint global = 0;
uint date_h = 0;   
ulint sum = 0;
uint x = 0;         //全局变量存储AD转换值
uint y = 0;
uchar seg_flag;
//0123456789- 
char duanxuan[] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//选择哪一位数码管
uchar weixuan[] = {0x00,0x06,0x07};

//初始化系统
void InitSYS(){
	
	//P0口推挽输出，用于给数码管和发光二极管增加电流
	P0M1 = 0x00;
	P0M0 = 0xff;
	//P2.3(即LED_SEL),P2.2,P2.1为推挽输出
	P2M1 = 0x00;
	P2M0 = 0x0E;

	seg_flag = 0;
	
	TMOD = 0x00;		//定时器0，工作方式1；
	EA = 1;				//打开总中断；
 	TH0 = (65535-1000)/256;	   	//定时器初值      1ms
	TL0 = (65535-1000)%256;
	ET0 = 1;			//打开定时中断；
	TR0	= 1;			//启动定时器；	
}

//初始化ADC
void InitADC()
{
	P1ASF = 0x80;			//P1.7作为A/D使用
	ADC_RES = 0;			//清零ADC结果寄存器
	ADC_CONTR = 0X8F;		//打开ADC电源  540个时钟周期转换一次 
	CLK_DIV = 0X00;			//ADRJ = 0	  ADC_RES存放高八位结果
	EADC = 1;				//允许ADC中断
	PADC = 1;				//ADC中断优先级为1	
}

//显示高三位和低五位
void HighThree()
{
	 x = date_h&0xE0;					//将八位转换结果的低五位清零
	 x = _cror_(x,5);					//将高三位移到低三位
	 y = date_h&0x1F;					//对原值取低5位，将八位转换结果的高三位清零
}

void timer0() interrupt 1 {	
	
	seg_flag++;	                          //每1ms扫描一次，各位轮流显示
	if(seg_flag==4)
		seg_flag = 0;
	P0 = 0x00;	              //每次首先初始化，什么都不亮
	switch(seg_flag) {
		case 0:
			LED_SEL = 0;				//选择数码管显示
			P2 = weixuan[seg_flag];
			P0 = duanxuan[x];			//显示ADC转换结果高三位的十进制值
			break;	
		case 1:
			LED_SEL = 0;				//选择数码管显示
			P2 = weixuan[seg_flag];
			P0 = duanxuan[y/10];		//显示ADC转换结果低五位的十进制值的高位
			break;
		case 2:
			LED_SEL = 0;				//选择数码管显示
			P2 = weixuan[seg_flag];
			P0 = duanxuan[y%10];		//显示ADC转换结果低五位的十进制值的低位
			break;
		case 3:
			LED_SEL = 1;				//选择发光二极管显示
			P0=date_h;                 //LED灯直接显示整个8位
			break;
	}
	
}

//AD中断
void adc_isr() interrupt 5    //只要ADC_CONTR的ADC_POWER=1（即打开AD电源），且每次AD中断中设置ADC_START=1，AD转换是一直在转换的，就算不按导航按键，数码管也会显示当前电压值。所以几乎是实时刷新当前电压值，刷新频率由控制寄存器的speed设置。 若想让AD停止，把Power位=0即可。
{
	IE=0x00;				  //关闭所有中断，防止数据没有采集完就进入新的中断（包括定时器的中断！ 反正AD中断函数不长，耽误不了多少数码管显示时间）
	ADC_CONTR&=~0X10;		  //将ADC_FLAG位清零
	
	global++;					
	if(global>1000)			  //将采集1000次后的数据求出平均值
	{
		date_h=(sum+500)/1000;//四舍五入

		HighThree();
		global=0;
		sum=0;
	}
	sum+=ADC_RES;           //每次中断，累加
	ADC_CONTR|=0X08;		 //将ADC_START进行软件置位，开启下一次转换
	IE=0xa2;				 //再次开启中断
}

void main()
{
	InitSYS();
	InitADC();

	while(1)     //直接让定时器和AD跑，不断扫描
		;
}

#include <STC15F2K60S2.h>
#define uint unsigned int
#define uchar unsigned char
#define FOSC 11059200L	//晶振频率
#define T_ms 0.1	 	//定时时间为0.1ms
#define NMAX_KEY 10 	
/*位声明*/
sbit Key1=P3^2;		  	//按下key1，向存储器写入数据并读取该地址的数据，显示在数码管上。
sbit Key2=P3^3;		  	//按下key2，要写入的数据加1
sbit Key3=P1^7;		 	//按下key3，要写入的地址加1					  
sbit led=P2^3;	      	//LED灯与数码管切换引脚
sbit SDA=P4^0;		  	//I2C总线的数据线
sbit SCL=P5^5;		  	//I2C总线的时钟线
/*变量定义*/
uchar duan[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71}; //数码管段选，显示0-f
uchar wei[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};	  //数码管位选
uchar flag1;				//数码管循环扫描变量
uchar write_addr;			//写入地址
uchar write_date; 			//写入数据
uchar read_date;  	 		//读出数据
/*按键计数消抖变量*/
uchar G_count;				//定时器0中断计数值
uint Key1_count;			//KEY1键在1ms内达到低电平的次数
uint Key2_count;			//KEY2键在1ms内达到低电平的次数
uint Key3_count;			//KEY3键在1ms内达到低电平的次数
uint Key_count;				//由100递减到0
bit flg_1ms;				//表示1ms时间到
bit Key1_C;/*key1当前的状态*/
bit Key1_P;/*key1前一个状态*/
bit Key2_C;/*key2当前的状态*/
bit Key2_P;/*key2前一个状态*/
bit Key3_C;/*key3当前的状态*/
bit Key3_P;/*key3前一个状态*/

void SMG1(uchar date1,uchar date2,uchar date3) //数码管显示函数
{	
	flag1++;
	if(flag1==8)
	{
		flag1=0;
	}
	P0=0x00;
	P2=wei[flag1];						
	switch(flag1)							
	{									    
		case 0:P0=duan[date1/16];break; 
	    case 1:P0=duan[date1%16];break; 	
		case 2:P0=0x40;break;
		case 3:P0=duan[date2/16];break; 
		case 4:P0=duan[date2%16];break; 		
		case 5:P0=0x40;break; 		
		case 6:P0=duan[date3/16];break; 
		default:P0=duan[date3%16];break; 
	}
} 
void KEY_init()	//按键消抖模块初始化
{	
	G_count=0;
	flg_1ms=0;	
	Key1_C=1;	/*key1当前的状态*/
	Key1_P=1;	/*key1前一个状态*/
	Key2_C=1;	/*key2当前的状态*/
	Key2_P=1;	/*key2前一个状态*/
	Key3_C=1;	/*key3当前的状态*/
	Key3_P=1;	/*key3前一个状态*/
	Key1_count=0x80+NMAX_KEY/3*2;
	Key2_count=0x80+NMAX_KEY/3*2;
	Key3_count=0x80+NMAX_KEY/3*2;
	Key_count=NMAX_KEY;
}
void delay() 		//延时4us
{
	;;	
}
void IIC_init()		//I2C总线初始化
{
	SCL=1;
	delay();		//让SCL稳定
	SDA=1;			//为开始信号做准备， 因为开始信号是SDA高到低
	delay();	
}

void start()	 	//主机启动信号
{
 	SDA=1;
	delay();		//让电平稳定
	SCL=1;
	delay();
	SDA=0;	//重点是在start函数内造成的SDA高到低！ 之前的SDA是高是低都无关，因为这里是开始信号，这里声明开始传输
	delay(); 	
}
void stop()		 	//停止信号
{
 	SDA=0;
	delay();
	SCL=1; 			//先让SDA稳定，再把SCL置1
	delay();
	SDA=1;
	delay();
}
void respons()	 	//从机应答信号
{
	uchar i=0;
	SCL=1;
	delay();
	while(SDA==1&&(i<255))  //表示若在一段时间内没有收到从器件的应答则
		i++;				//主器件默认从期间已经收到数据而不再等待应答信号。 这里没有考虑从机未接收到字节的情况
	SCL=0;
	delay();
}
void writebyte(uchar date) //对24C16写一个字节数据
{
	uchar i,temp;
	temp=date;
	for(i=0;i<8;i++)
	{
		temp=temp<<1;
		SCL=0;
		delay();
		SDA=CY;        //进位标志，即左移出来的位
		delay();
		SCL=1;
		delay();
	}
	SCL=0;
	delay();
	SDA=1;
	delay();	
}
uchar readbyte()  			//从24C16读一个字节数据
{
	uchar i,k;
	SCL=0;
	delay();
	SDA=1;
	delay();
	for(i=0;i<8;i++)
	{
		SCL=1;			//接受过程中SCL=1，  不然SCL=0时IC不工作
		delay();
		k=(k<<1)|SDA;   //SDA就1位     这里直接接收IC从SDA线传过来的数据
		delay();
		SCL=0;
		delay();
	}
	delay();
	return k;	
}
void write_add(uchar addr,uchar date)  //对24C16的地址addr，写入一个数据date
{
	start();				//发生开始信号
	writebyte(0xa0);		// 10100000   最后一位=0，表示本次是写操作  A3A2A1=0				
	respons();				//接收ACK
	writebyte(addr);
	respons();
	writebyte(date);
	respons();
	stop();							
}
uchar read_add(uchar addr) //从24C16的addr地址，读一个字节数据
{	
	uchar date; //读字节为了和写字节工作模式统一，所以都要传输3个字节过去，之后SDA才会把数据传输给CPU
	start();
	writebyte(0xa0);	//读和写的第一个DEV SEL最低位都是0，表示把地址写进去
	respons();
	writebyte(addr);
	respons();	
	start();			//需要再一个start信号，表示要输入DEV SEL
	writebyte(0xa1);
	respons();
	date=readbyte();
	stop();
	return date;
}
void IO_init()		 //IO口初始化，变量初始化
{	
	P2M1=0x00;		//设置P0口和P2^3推挽输出
	P2M0=0x08;
	P0M1=0x00;
	P0M0=0xff;		//按键无需推挽
	led=0;		   	//关LED显示，开启数码管
	P0=0x00;		//什么都不显示
	write_addr=0x00;		//写入地址初始化
	write_date=0x00;		//写入数据初始化	
}
void Timer0_Init()		 //计时器0初始化
{
	TMOD=0x00;   		//计时器0工作方式0，16位自动重装计数
	AUXR=0x80;   		//1T模式,T0x12=1,
	EA=1;		 		//开总中断
	ET0=1;				//开定时器0中断
	TH0=(65536-T_ms*FOSC/1000)/256;//给定时器赋初值
	TL0=(65536-T_ms*FOSC/1000);
	TR0=1;			   	//启动定时器
}    

void Timer_T0() interrupt 1	 //定时器0中断函数		
{	
	G_count++;
	if(G_count==10)
	{
		flg_1ms=1;		//1ms时间到，fla_1ms=1     此方法也可用于数码管单位闪烁
		G_count=0x00;
	}
	SMG1(write_addr,write_date,read_date); //在定时器中短中调用数码管显示函数						  
}
int main()				//主函数
{
	IO_init();		 	//IO口初始化
	Timer0_Init();		//定时器0初始化
	KEY_init();			//按键消抖模块初始化
	IIC_init();		    //IIC总线初始化
	while(1)
	{
		while(flg_1ms)  //1ms时间到 判断按键状态           计数消抖法
 		{
			flg_1ms=0;
			read_date=read_add(write_addr);	//读出地址为write_addr的数据
			if(Key1==0)
			Key1_count--;
			if(Key2==0)
			Key2_count--;
			if(Key3==0)    //按键是按下状态
			Key3_count--;
			Key_count--;   //总的次数直接减1，10ms减完  就是用作计数，每1ms进行一次扫描		
		 	if(Key_count==0)//10次完了   10ms
			{
				if(Key1_count<0x80)    //即“按下”次数超出抖动最大范围，那么说明确实按下了
				{
					Key1_C=0;
					if(Key1_P==1)	//下降沿（按键做动作）  排除一直按下没松开的情况
					{
						Key1_P=0;
						write_add(write_addr,write_date);//向地址write_addr写入数据		
					}
				}
				if(Key1_count>=0x80)      
				{
					Key1_C=1;
					if(Key1_P==0)      //因为每10ms就会来判断一下，所以在按键松开后，会在这里把上一个key状态置1
					   Key1_P=1;	//上升沿（假设不做动作那就继续）
				}

				if(Key2_count<0x80)
				{
					Key2_C=0;
					if(Key2_P==1)	//下降沿（按键做动作）
					{
						Key2_P=0;
						write_date++;		   	//按键数据加1
						if(write_date==0xff) 	//假如输入的数据大于0xff，则变为0x00。
						write_date=0x00;				
						}
					}

				
				if(Key2_count>=0x80)
				{
					Key2_C=1;
					if(Key2_P==0)
					   Key2_P=1;	//上升沿（假设不做动作那就继续）
				}


				if(Key3_count<0x80)
				{
					Key3_C=0;
					if(Key3_P==1)	//下降沿（按键做动作）
					{
						Key3_P=0;
						write_addr++;			//按键写入地址+1
						if(write_addr==0xff)
						write_addr=0;
					}

				}
				if(Key3_count>=0x80)
				{
					Key3_C=1;
					if(Key3_P==0)
					   Key3_P=1;	//上升沿（假设不做动作那就继续）
				}
								
				Key1_count=0x80+NMAX_KEY/3*2;    //新一轮的判断   key_cnt=0时才重置次数
				Key2_count=0x80+NMAX_KEY/3*2;
				Key3_count=0x80+NMAX_KEY/3*2;

				Key_count=NMAX_KEY;
			}
		}//read_date=read_add(read_addr); 读数据函数放在此处数码管会无法及时显示
	}
}