篮球比赛计时计分器

1、 显示内容，队名用英文名，3个大写字母20分

队名1-A:队名2-B =

xxx：xxx

第x节剩余时间：

XX分XX秒

2、 串口控制 20分

A+1% A队加1分，％为结束符 A+2% A队加2分，％为结束符 A+3% A队加3分，％为结束符 B+1% B队加1分，％为结束符

以此类推

3、 串口控制交换场地 5分 A-B% AB队交换 4、 20 分

PAUSE% 计时暂停 按键1-定义为PAUSE按键用ZLG7290 RESTART%重新计时按键2-定义为RESTART RESET%重新比赛 按键3-定义为RESET

5、 存储近5场的成绩到AT24C02 格式：1-队名1队名2=90:100类推20分 RECALL1% 提取存储的第1场成绩，在数码管上显示，只显示比分，串口传回比分

+

队名&整场结束，提示是否保存成绩，按键 4-存储键 按键5-放弃键 15分

源代码：

接线说明： PSB-VCC RS-P1.0 RW-P1.1 P1.3-E INT-P3.2 TXD-P3.1 RXD-P3.0

SDA-P1.6 SCL-P1.7 I2C 总线的ABC》别接键盘的ABCD以程序

为准 凭记忆写出来的 )

主程序

#include #include #include #include #include

#define unchar unsigned char #define unit unsigned int #define Lcd_Bus P0

#define unchar unsigned char unsigned char KeyValue,FlagINT; int ney;// 纪录第及场比赛

sbit RS=P1A0;//LCD 显示屏 sbit RW=P1A1； sbit E=P1A3;

unchar code lcddata[]={\"01234567:\

unchar code duiming[]={'1','H','O','U',':','2','C','H','I','='}; unchar bifen[7]; unchar fen1; unchar fen2; unchar jie; unchar min; unchar sec; unchar control; unchar table[10];

**************

延时函数 ***********************

void delay(unsigned int t) { unsigned int i,j;

for(i=0;i/* ------------ 写命令到 LCD ---------------------- */ void write_com(unsigned char cmdcode) { //chk_busy(); RS = 0; RW = 0; E = 1;

Lcd_Bus = cmdcode;

delay(10); // 在数据写入的时候加入适当的延时 E = 0;

}

// 置零

/* ------------ 写数据到 LCD ---------------------- */ void write_data(unsigned char Dispdata)

{

//chk_busy(); RS = 1; RW = 0; E = 1;

Lcd_Bus = Dispdata;

delay(10); // 在数据写入的时候加入适当的延时 E = 0;

// 写数据

/******* 函数名称

： Write_Char* 功能描述 ：写字符void write_char(unsigned int num) {

// chk_busy();

RS = 1; RW = 0; E = 1;

Lcd_Bus = lcddata[num]; E = 0;

}

/* ------------ 显示字符串 ----------------- */ void hzkdis(unsigned char code *s) { while(*s>0)

{ write_data(*s);

******/

s++;

/* ------------ 初始化

LCD 屏 -----------------

*void lcdreset() // / 选择基本指令集 （30H）

{

// 点设定，游标右移

write_com(0x30); delay(16); // 开显示控制 （无游标、不反白 ） write_com(0x04); delay(16); write_com(0x0f); // 清除显示，并且设定地址指针为 00H

delay(16); write_com(0x01); delay(16);

}

//unchar duiming[]= \"1-HOU:2-CHI\";// 队名数组 //unchar bifen[7];// 比分数组 unchar k;// 记录第几场比赛

/**用作计时 void timer0init(void)

* ***/ {

TMOD=0X21; TH0=0X31; TL0=0XB0; ET0=1; EA=1; TR0=1; //IT0=1;

// EX0=1;

}

/***** 用作串口通信 ****/ void timer1init(void)

{

TH1=0xf3; TL1=0XF3; SCON=0X50; EA=1; ES=1; TR1=1;

}

/**** 保存成绩 */ void save(int ney)

{

同时地址归为 ）（

int i;

unchar buff[7]; // ney++;

ZLG7290_Download(i,0,0,0X0A); bifen[2]=fen2/100; bifen[1]=(fen2%100-fen2%10)/10; bifen[0]=fen2%10; bifen[3]=0X1F; bifen[6]=fen1/100;

bifen[5]=(fen1%100-fen1%10)/10; bifen[4]=fen1%10;

for(i=0;i<7;i++)

{

x24c02_write(i+7*ney,bifen[i]);

}

for(i=0;i<7;i++)

{

buff[i]=x24c02_read(i+7*ney); delay(12);

}

for(i=0;i<7;i++)

{

ZLG7290_Download(i,0,0,buff[i]);

}

/********** 将存储在 at24c02 的数据通过串口通信发还给电脑 **/ void fahuan(unsigned char k)

{

unchar buff[7],i; for(i=0;i<10;i++)

{

SBUF=duiming[i]; while(!TI){;} TI=0;

}

for(i=0;i<7;i++)

{

buff[i]=x24c02_read(i+7*k); delay(12);

}

for(i=0;i<7;i++)

{

ZLG7290_Download(i,0,0,buff[i]);

for(i=6;i>3;i--)

}

{

SBUF=buff[i]+48; while(!TI){;} TI=0;

}

SBUF=':'; while(!TI){;} TI=0;

SBUF=buff[2]+48; while(!TI){;} TI=0;

SBUF=buff[1]+48; while(!TI){;} TI=0; SBUF=buff[0]+48; while(!TI){;} TI=0; P2=0xf0;

}

/**** 定时器中断用作计时 **/ void timer0(void) interrupt 1 using 1 {

static unchar count=0; unchar i; TH0=0X3C;

TL0=0XB0; count++; if(count==20)

{

count=0; sec--; if(sec==-1)

{

sec=59; min--; if(min==-1) {

if(jie<=3) {

write_com(0x01); jie++; min=1; } else { // TR0=0; control=0; //save();

}

}

}

}

/**** 主要用作显示比分 **/

void show_fen1(void)

{

write_com(0x80); hzkdis(\"2-CHI:1-HOU=\");

write_com(0x90); delay(16); write_char(fen2/ 100); delay(16);

write_char((fen2%100-fen2% 10)/10); delay(16); write_char(fen2% 10); delay(16); write_char( 10 ); delay(16) ; write_char(fen1/ 100); delay(16);

write_char((fen1%100-fen1% 10)/10); delay(16); write_char(fen1% 10); delay(16);

}

/**** 显示比分队名顺序相反 **/ void show_fen0(void)

{

write_com(0x80); hzkdis(\"1-HOU:2-CHI=\");

write_com(0x90); delay(16); write_char(fen1/ 100); delay(16);

write_char((fen1%100-fen1% 10)/10); delay(16); write_char(fen1% 10);

delay(16);

write_char( 10 ); delay(16) ;

write_char(fen2/ 100); delay(16); write_char((fen2%100-fen2% 10)/10); delay(16);

write_char(fen2% 10); delay(16);

}

/*** 显示时间 **/ void show_time(void)

{

write_com(0x88); if(jie%10==1) hzkdis(\"第 1 节”)； if(jie%10==2) hzkdis(\"第 2 节\"); if(jie%10==3) hzkdis(\"第 3 节\"); if(jie%10==4) hzkdis(\"第 4 节\"); write_com(0x8c); hzkdis(\"剩余时间\"); write_com(0x9a); delay(16);

write_char( min / 10 ); delay(16);

write_char( min % 10 ); delay(16); write_char( 10 ); delay(16);

write_char( sec / 10 ); delay(16);

write_char( sec % 10 );

delay(16);

}

write_com(0x80);

hzkdis(\"是否保存成绩？ ”)； write_com(0x90);

hzkdis(\"y press butter 4\")； write_com(0x88)； hzkdis(\"n press butter 5 \")； write_com(0x98)； hzkdis(\"

\")；

void show()

{

}

/***** 串口中断处理来自串口助手的命令 */ void chuanko() interrupt 4

{

unchar i=0；

unchar buff[]=\"wrong\"；

while(1)

{

while(!RI)；

RI=0； if(SBUF=='%') break； table[i]=SBUF； i++；

}

if(table[0]=='A'&&table[1]=='+'&&table[2]=='1') fen1++；

else if(table[0]=='A'&&table[1]=='+'&&table[2]=='2') {

fen1++； fen1++；

}

else if(table[0]=='A'&&table[1]=='+'&&table[2]=='3') {

fen1++； fen1++； fen1++；

}

else if(table[0]=='B'&&table[1]=='+'&&table[2]=='1') fen2++;

else if(table[0]=='B'&&table[1]=='+'&&table[2]=='2') {

fen2++; fen2++;

}

else if(table[0]=='B'&&table[1]=='+'&&table[2]=='3')

{

fen2++; fen2++;

fen2++;

}

control=2;// 交换场地

else if(table[0]=='A'&&table[1]=='-'&&table[2]=='B')

{

}

else

if(table[0]=='P'&&table[1]=='A'&&table[2]=='U'&&table[3]=='S'&&table[4]=='E')

{

TRO=(~TRO);〃 暂停

}

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='S'&&table[3]=='T'&&table[4]=='A'&&table[5]=='R'& &table[6]=='T')

{

TR0=0; min=11; sec=59;

TR0=1;〃重新计时

}

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='S'&&table[3]=='E'&&table[4]=='T')

{

timer0init();

// TR0=0;

min=11; sec=59; jie=1; fen1=0; fen2=0;

TR0=1;〃重新开始 write_com(0x01); control=1;

}

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='C'&&table[3]=='A'&&table[4]=='L'&&table[5]=='L'& &table[6]=='1')

{

ZLG7290_Download(i,0,0,0X0E);

fahuan(0);//shuma(1);

}

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='C'&&table[3]=='A'&&table[4]=='L'&&table[5]=='

L'& &table[6]=='2')

{ }

fahuan(1);//shuma(2);

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='C'&&table[3]=='A'&&table[4]=='L'&&table[5]=='L'& &table[6]=='3')

{ }

fahuan(2);//shuma(3);

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='C'&&table[3]=='A'&&table[4]=='L'&&table[5]=='L'& &table[6]=='4')

{ }

fahuan(3);//shuma(4);

else

if(table[0]=='R'&&table[1]=='E'&&table[2]=='C'&&table[3]=='A'&&table[4]=='L'&&table[5]=='L'& &table[6]=='5')

{ }

fahuan(4);//shuma(5);

else

{

for(i=0;i<6;i++) {

SBUF=buff[i]; while(!TI); TI=0;

/**** 外部中断初始化 响应按键中断 **/ void SystemInit()

{

I2C_Init(); EA = 0;

IT0 = 1; // 负边沿触发中断 EX0 = 1; // 允许外部中断

EA = 1; // 等待 ZLG7290 复位完毕 }

/***** 外部中断函数 响应各个按键 **/ void INT0_SVC() interrupt 0 {

unchar i; ZLG7290_ReadReg(ZLG7290_Key,&KeyValue);

// 显示键值

DispValue(0,KeyValue); if(KeyValue==0x09) {

TRO=(~TRO);//暂停

} {

if(KeyValue==0x0a)

TR0=0; min=11; sec=59;

TR0=1;//重新计时

}

if(KeyValue==0x0b)

timer0init(); write_com(0x01); TR0=0; min=11; sec=59; jie=1; fen1=0; fen2=0; control=1;

TR0=1;〃重新开始 } if(KeyValue==0x0c) { save(ney); ney++;

timer0init();// 响应完中断记得重新初始化 timer1init(); SystemInit();

}

不然可能会出错

main()

{

min=11; sec=59; fen1=0; fen2=0; jie=1; control=1; ney=0; timer0init(); timer1init(); lcdreset(); SystemInit();

//系统初始化

while(1)

{

if(control==1)

{

show_fen0(); show_time();

}

if(control==0)

{

show();// 比赛结束提示

show_fen1();// 交换场地 show_time();

}

if(control==2)

{

}

后面加上主程序调用的一些头文件和程序 I2C.C和I2C.H只要是7和7290.C 729O.h的一些驱动程序 Ex_i2c.c是at24c01的驱动程序~

I2C.C

标准80C51单片机模拟I2C总线的主机程序

Copyright (c) 2005,广州周立功单片机发展有限公司 All rights reserved.

本程序仅供学习参考，不提供任何可靠性方面的担保；请勿用于商业目的

*/

#i nclude \"I2C.h\"

//定义延时变量，用于宏 l2C_Delay() un sig ned char data I2C_Delay_t; /*

宏定义：I2C_Delay()

功能：延时，模拟I2C总线专用

*/

#defi ne I2C_Delay()\\ {\\

I2C_Delay_t = (I2C_DELAY_VALUE);\\ while ( --I2C_Delay_t != 0 );\\

/*

函数：I2C_I nit()

功能：I2C总线初始化，使总线处于空闲状态

说明：在main()函数的开始处，通常应当要执行一次本函数

*/

void I2C_I nit() {

I2C_SCL = 1; I2C_Delay(); I2C_SDA = 1;

I2C_Delay();

/*

函数： I2C_Start()

功能：产生 I2C 总线的起始状态 说明：

SCL处于高电平期间，当 SDA出现下降沿时启动I2C总线 不论SDA和SCL处于什么电平状

态，本函数总能正确产生起始状态 本函数也可以用来产生重复起始状态 本函数执行后，I2C总线处于忙状态

*/

void I2C_Start()

{

I2C_SDA = 1; I2C_Delay(); I2C_SCL = 1; I2C_Delay(); I2C_SDA = 0; I2C_Delay(); I2C_SCL = 0; I2C_Delay();

}

/* 函数： I2C_Write()

功能：向I2C总线写1个字节的数据 参数：

dat:要写到总线上的数据 */ void I2C_Write(char dat)

{

unsigned char t = 8; do

{

I2C_SDA = (bit)(dat & 0x80); dat <<= 1; I2C_SCL = 1; I2C_Delay(); I2C_SCL = 0; I2C_Delay();

} while ( --t != 0 ); /*

函数： I2C_Read() 功能：从从机读取 1 个字节的数据 返回：读取的一个字节数据*/

char I2C_Read()

{

char dat;

unsigned char t = 8;

I2C_SDA = 1; //在读取数据之前，要把 SDA拉高

do {

I2C_SCL = 1; I2C_Delay(); dat <<= 1;

if ( I2C_SDA ) dat |= 0x01; I2C_SCL = 0; I2C_Delay();

} while ( --t != 0 ); return dat;

}

/*

函数： I2C_GetAck() 功能：读取从机应答位 返回：

0：从机应答

1 ：从机非应答 说明：

从机在收到每个字节的数据后，要产生应答位 从机在收到最后 1 个字节的数据后，一般要产生非应答位 */

bit I2C_GetAck()

{

bit ack; I2C_SDA = 1; I2C_Delay(); I2C_SCL = 1; I2C_Delay();

ack = I2C_SDA; I2C_SCL = 0; I2C_Delay(); return ack;

/*

函数： I2C_PutAck() 功能：主机产生应答位或非应答位 参数：

ack=O：主机产生应答位 ack=1 :主机产生非应答位

说明：

主机在接收完每一个字节的数据后，都应当产生应答位 主机在接收完最后一个字节的数据后，应当产生非应答位

*/

void I2C_PutAck(bit ack)

{

I2C_SDA = ack; I2C_Delay(); I2C_SCL = 1; I2C_Delay(); I2C_SCL = 0; I2C_Delay();

}

/*

函数： I2C_Stop()

功能：产生 I2C 总线的停止状态 说明：

SCL处于高电平期间，当 SDA出现上升沿时停止I2C总线

不论SDA和SCL处于什么电平状态，本函数总能正确产生停止状态 本函数执行后，I2C总线处于空闲状态

*/

void I2C_Stop()

{

unsigned int t = I2C_STOP_WAIT_VALUE; I2C_SDA = 0; I2C_Delay(); I2C_SCL = 1; I2C_Delay(); I2C_SDA = 1; I2C_Delay(); while ( --t != 0 );

// 在下一次产生 Start 之前，要加一定的延时

}

/*

函数： I2C_Puts()

功能：I2C总线综合发送函数，向从机发送多个字节的数据 参数：

SlaveAddr：从机地址(7位纯地址，不含读写位) SubAddr：从机的子地址

SubMod:子地址模式，0—无子地址，1 —单字节子地址，2—双字节子地址 *dat ：要发送

的数据

Size：数据的字节数

返回：

0：发送成功

1 ：在发送过程中出现异常

说明： 本函数能够很好地适应所有常见的 I2C 器件，不论其是否有子地址 当从机没有子地址

时，参数 SubAddr 任意，而 SubMod 应当为 0

*/

bit I2C_Puts

(

unsigned char SlaveAddr, unsigned int SubAddr, unsigned char SubMod, char *dat, unsigned int Size

){

unsigned char i; char a[3];

// 定义临时变量

// 检查长度

if ( Size == 0 ) return 0; // 准备从机地址

a[0] = (SlaveAddr << 1); // 检查子地址模式

if ( SubMod > 2 ) SubMod = 2; // 确定子地址

switch ( SubMod )

{

case 0: break; case 1:

a[1] = (char)(SubAddr); break; case 2:

a[1] = (char)(SubAddr >> 8); a[2] = (char)(SubAddr); break; default: break;

}

// 发送从机地址，接着发送子地址(如果有子地址的话) SubMod++;

I2C_Start();

for ( i=0; i{

I2C_Write(a[i]); if ( I2C_GetAck() )

{

I2C_Stop(); return 1; }

}

// 发送数据

do

{

I2C_Write(*dat++); if ( I2C_GetAck() ) break;

} while ( --Size != 0 );

//发送完毕，停止I2C总线，并返回结果

I2C_Stop(); if ( Size == 0 )

{

return 0; }

else

{

return 1; }

}

/*

函数： I2C_Gets()

功能：I2C总线综合接收函数，从从机接收多个字节的数据 参数：

SlaveAddr：从机地址(7位纯地址，不含读写位) SubAddr：从机的子地址

SubMod:子地址模式，0—无子地址，1 —单字节子地址, *dat ：保存接收到的数据 Size：数据的字节数 返回：

2—双字节子地址

0：接收成功

1 ：在接收过程中出现异常

说明：

本函数能够很好地适应所有常见的 I2C 器件，不论其是否有子地址 当从机没有子地址时，参数 SubAddr 任意，而 SubMod 应当为 0 */

bit I2C_Gets

(

unsigned char SlaveAddr, unsigned int SubAddr, unsigned char SubMod, char *dat, unsigned int Size

){

// 定义临时变量 unsigned char i; char a[3]; // 检查长度

if ( Size == 0 ) return 0; // 准备从机地址

a[0] = (SlaveAddr << 1); // 检查子地址模式

if ( SubMod > 2 ) SubMod = 2;

// 如果是有子地址的从机，则要先发送从机地址和子地址

if ( SubMod != 0 )

{

if ( SubMod == 1 )

{

//确定子地址

a[1] = (char)(SubAddr);

}

else

{

a[1] = (char)(SubAddr >> 8); a[2] = (char)(SubAddr);

}

//发送从机地址，接着发送子地址

SubMod++; I2C_Start();

for ( i=0; i{

I2C_Write(a[i]); if ( I2C_GetAck() ) {

I2C_Stop(); return 1;

}

}

//这里的l2C_Start()对于有子地址的从机是重复起始状态 //对于无子地址的从机则是正常的起始状态 l2C_Start(); // 发送从机地址

l2C_Write(a[0]+1); if ( l2C_GetAck() )

{

l2C_Stop();

return 1;

}

//接收数据

for (;;)

{

*dat++ = l2C_Read(); if ( --Size == 0 )

{

l2C_PutAck(1); break; l2C_PutAck(0);

}

}

//接收完毕，停止I2C总线，并返回结果

l2C_Stop(); return 0;

}

ZLG7290.c

/*

数码管显示与键盘管理芯片 ZLG7290的标准80C51驱动程序C文件

Copyright (c) 2005，广州周立功单片机发展有限公司 All rights reserved.

本程序仅供学习参考，不提供任何可靠性方面的担保；请勿用于商业目的 */ #include

\"I2C.h\"

#include \"ZLG7290.h\" /*

函数： ZLG7290_WriteReg()

功能：向ZLG7290的某个内部寄存器写入数据 参数：

RegAddr： ZLG7290的内部寄存器地址 dat ：要写入的数据 返回： 0：正常

1:访问ZLG7290时出现异常 */

bit ZLG7290_WriteReg(unsigned char RegAddr, char dat)

{

bit b;

b = I2C_Puts(ZLG7290_I2C_ADDR,RegAddr,1,&dat,1); return b;

}

/*

函数： ZLG7290_ReadReg()

功能：从ZLG7290的某个内部寄存器读出数据 参数：

RegAddr： ZLG7290的内部寄存器地址 *dat ：保存读出的数据 返回： 0：正常

1:访问ZLG7290时出现异常 */

bit ZLG7290_ReadReg(unsigned char RegAddr, char *dat)

{

bit b;

b = I2C_Gets(ZLG7290_I2C_ADDR,RegAddr,1,dat,1); return b;

}

/*

函数： ZLG7290_cmd()

功能：向ZLG7290发送控制命令 参数：

cmdO :写入 CmdBufO寄存器的命令字(第 1字节) cmdl :

写入 CmdBufl寄存器的命令字(第 2字节) 返回：

0：正常

1:访问ZLG7290时出现异常 */

bit ZLG7290_cmd(char cmd0, char cmd1)

{

bit b; char buf[2]; buf[0] = cmd0; buf[1] = cmd1;

b = I2C_Puts(ZLG7290_I2C_ADDR,ZLG7290_CmdBuf,1,buf,2); return b;

}

/* 函数： ZLG7290_SegOnOff()

功能：段寻址，单独点亮或熄灭数码管(或 参数：

LED)中的某一段

seg：取值0〜63,表示数码管(或 LED)的段号 b： 0 表示熄灭， 1 表示点亮 返回： 0：正常

1:访问ZLG7290时出现异常

说明：

在每一位数码管中,段号顺序按照“ a,b,c,d,e,f,g,dp ”进行 */

bit ZLG7290_SegOnOff(char seg, bit b)

{

char cmd; cmd = seg & 0x3F; if ( b ) cmd |= 0x80; return ZLG7290_cmd(0x01,cmd);

}

/*

函数： ZLG7290_Download() 功能：下载数据并译码 参数：

addr :取值0〜7,显示缓存 DpRamO〜DpRam7的编号 dp：是否点亮该位的小数点，

0 —熄灭，1—点亮

flash:控制该位是否闪烁，0—不闪烁，1—闪烁 dat :取值0〜31,表示要显示的数据

返回：

0：正常

1:访问ZLG7290时出现异常

说明：

显示数据具体的译码方式请参见

*/

bit ZLG7290_Download(char addr, bit dp, bit flash, char dat)

{

ZLG7290的数据手册

char cmd0; char cmd1;

cmd0 = addr & 0x0F; cmd0 |= 0x60; cmd1 = dat & 0x1F; if ( dp ) cmd1 |= 0x80; if ( flash ) cmd1 |= 0x40; return ZLG7290_cmd(cmd0,cmd1);

}

/*

I2C.h

标准80C51单片机模拟I2C总线的主机程序头文件

Copyright (c) 2005，广州周立功单片机发展有限公司

All rights reserved. 本程序仅供学习参考，不提供任何可靠性方面的担保；请勿用于商

业目的 */

#ifndef _I2C_H_ #define _I2C_H_ #include //模拟I2C总线的引脚定义 sbit I2C_SCL = P1A6; sbit I2C_SDA = P\"7;

//定义I2C总线时钟的延时值，要根据实际情况修改，取值 //SCL信号周期约为(I2C_DELAY_VALUE*4+15个机器周期 #define I2C_DELAY_VALUE 12

//定义I2C总线停止后在下一次开始之前的等待时间，取值

1〜65535 1〜255

〃等待时间约为(I2C_STOP_WAIT_VALUE*8个机器周期

//对于多数器件取值为 1 即可；但对于某些器件来说，较长的延时是必须的 #define I2C_STOP_WAIT_VALUE 120

//I2C 总线初始化，使总线处于空闲状态 void I2C_Init();

void x24c02_write(unsigned char address,unsigned char info); unsigned char

x24c02_read(unsigned char address); //unsigned char x24c02_read(unsigned char address); //I2C 总线综合发送函数，向从机发送多个字节的数据 bit I2C_Puts

(

unsigned char SlaveAddr, unsigned int SubAddr,

unsigned char SubMod, char *dat, unsigned int Size );

//I2C 总线综合接收函数，从从机接收多个字节的数据 bit I2C_Gets

(

unsigned char SlaveAddr, unsigned int SubAddr,

unsigned char SubMod, char *dat, unsigned int Size

);

#endif //_I2C_H_ /*

ZLG7290.h

数码管显示与键盘管理芯片 ZLG7290的标准80C51驱动程序头文件

Copyright (c) 2005，广州周立功单片机发展有限公司

All rights reserved. 本程序仅供学习参考，不提供任何可靠性方面的担保；请勿用于商

业目的 */

#ifndef _ZLG7290_H_ #define _ZLG7290_H_

#include //ZLG7290 中断请求信号的引脚定义 sbit ZLG7290_pi nINT = P3A2;

II定义ZLG7290在I2C总线协议中的从机地址

// 这是 7 位纯地址，不含读写位 #define ZLG7290_I2C_ADDR 0x38

II定义ZLG7290内部寄存器地址(子地址) #define ZLG7290_SystemReg 0x00 #define ZLG7290_Key

II#define ZLG7290_RepeatCnt II#define ZLG7290_FunctionKey #define ZLG7290_CmdBuf #define ZLG7290_CmdBuf0

#define ZLG7290_CmdBuf1 //#define ZLG7290_FlashOnOff #define ZLG7290_ScanNum #define ZLG7290_DpRam #define ZLG7290_DpRam0

0x01

0x02 0x03

II系统寄存器 II 键值寄存器

II 连击次数寄存器 II 功能键寄存器

II 命令缓冲区起始地0x07

址 II 命令缓冲区 0 0x07 0x08 //命令缓冲区 1 0x0C 0x0D 0x10 0x10

//闪烁控制寄存器

//扫描位数寄存器

// 显示缓存起始地址

//显示缓存 0/#define ZLG7290_DpRam1

0x11 //显示缓存 1

#define ZLG7290_DpRam2 0x12 //显示缓存 2 #define ZLG7290_DpRam3 0x13

//显示缓存 3 #define ZLG7290_DpRam5 0x15 //显示缓存 5 #define ZLG7290_DpRam6 0x16 //显示缓存 6

#define ZLG7290_DpRam7 0x17

//显示缓存 7

//向ZLG7290的某个内部寄存器写入数据

bit ZLG7290_WriteReg(unsigned char RegAddr, char dat); //从ZLG7290的某个内部寄存器读出数据

bit ZLG7290_ReadReg(unsigned char RegAddr, char *dat); //向ZLG7290发送控制命令

bit ZLG7290_cmd(char cmd0, char cmd1); //段寻址，单独点亮或熄灭数码管(或 LED)中的某一段

bit ZLG7290_SegOnOff(char seg, bit b); //下载数据并译码

bit ZLG7290_Download(char addr, bit dp, bit flash, char dat);

〃闪烁控制指令(Fn应当是字节型)

//Fn 的 8 个位分别控制数码管的 8 个位是否闪烁， 0－不闪烁，#define ZLG7290_Flash(Fn) ZLG7290_cmd(0x70,(Fn)) #endif //_ZLG7290_H_

#include #include #include

//sbit dula=P2A6;

//sbit wela=P2A7; unsigned char j,c; void de(unsigned char i)

// 延时程序

{

for(j=i;j>0;j--) for(c=125;c>0;c--);

}

/*24C02 读写驱动程序 */

－闪烁 1

void flash()// 短时间的延时，几微秒左右 { ; ;

}

void init() //24c02 初始化子程序 {

I2C_SCL=1; flash(); I2C_SDA=1; flash();

}

void start() // 启动 I2C 总线

{

I2C_SDA=1; flash(); I2C_SCL=1; flash();

I2C_SDA=0;

flash(); // scl=0; // flash();

}

void stop() // 停止 I2C 总线

{

I2C_SDA=0; flash(); I2C_SCL=1; flash(); I2C_SDA=1; flash();

}

void writex(unsigned char j) // 写一个字节 { unsigned char i,temp;

temp=j;

for (i=0;i<8;i++)

{ temp=temp<<1; I2C_SCL=0; flash(); I2C_SDA=CY; flash(); I2C_SCL=1; flash();

}

I2C_SCL=0; flash(); I2C_SDA=1; flash();

} unsigned char readx() // 读一个字节 {

unsigned char i,z; I2C_SCL=0;

flash(); I2C_SDA=1; for (i=0;i<8;i++)

{

flash(); I2C_SCL=1; flash(); if (I2C_SDA==1) j=1; else j=0;

z=(z<<1)|j;// 先左移，然后在最低位读入

值 I2C_SCL=0;

}

flash(); return(z);

}

unsigned char i=0; I2C_SCL=1; flash();

while ((I2C_SDA==1)&&(i<255))i++; I2C_SCL=0; flash();

void clock() //I2C 总线时钟响应

{

//////// 从 24c02 的地址 address 中读取一个字节数据 ///// unsigned char x24c02_read(unsigned char address) {

unsigned char i; start();

writex(0xa8);//A1 A2 A3 全部低电平 // clock(); writex(address); clock();

start(); writex(0xa9); clock(); i=readx(); stop(); de(10); return(i); }

////// 向 24c02 的 address 地址中写入一字节数据 info///// void x24c02_write(unsigned char address,unsigned char info) {

EA=0;

start(); writex(0xa8); clock(); writex(address); clock(); writex(info); clock(); stop(); de(50);