#PCF8563C语言可调时钟日历.docx

#PCF8563C语言可调时钟日历.docx

《#PCF8563C语言可调时钟日历.docx》由会员分享，可在线阅读，更多相关《#PCF8563C语言可调时钟日历.docx（45页珍藏版）》请在冰豆网上搜索。

#PCF8563C语言可调时钟日历

/*

PCF8563可调时钟日历

定义P0口为段输出端口

定义P1口为位输出端口

用74HC573驱动数码管

四按键可调时间日期

*/

#include

#defineucharunsignedchar

#defineuintunsignedint

bitdao1S=0。

//到1秒标志位

bitdao2MS=0。

//到2毫秒标志位

bitdao10MS=0。

//到10毫秒标志位

bitdao05s=0。

bitdao500MS=0。

sbitdula1=P3^5。

//定义日期段选

sbitwela1=P3^2。

//定义日期位选

sbitdula2=P3^4。

//定义时间星期段选

sbitwela2=P3^3。

//定义时间星期位选

sbitshanshuo=P2^4。

ucharnum,num1,num2,main_flag。

sbitkey1=P2^0。

sbitkey2=P2^1。

sbitkey3=P2^2。

sbitkey4=P2^3。

bitset,xiaoshi,fenzhong,miaozhong,xingqi,nianfen,yuefen,rifen。

sbitscl=P3^0。

//定义8563I2C的时钟线

sbitsda=P3^1。

//定义8563I2C的数据线

#defineled_dataP0//定义P0口为段输出端口

#defineled_weiP1//定义P1口为位输出端口

chara,miao,shi,fen,number,b,ms,mg,fs,fg,ss,sg,count。

charday,week,month,year。

uchartabtime[]={0,0,0,0,0,0,0,0}。

//时间星期缓冲区

uchartabdata[]={0,0,0,0,0,0,0,0}。

//日期缓冲区

ucharweitime[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}。

//时间星期显示位

ucharweidata[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80}。

//日期显示位

uchartab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90}。

//0--9数字

ucharxing[]={0xf9,0xa4,0xb0,0x99,0x92,0x82,0x80}。

#defineKEY_10x0e//定义各按键键值

#defineKEY_20x0d

#defineKEY_30x0b

#defineKEY_40x07

#defineKEY_NULL0x0f

#defineKEY_PRESS0x80//定义各按键状态

#defineKEY_LONG0x40

#defineKEY_STATE_INIT0//定义按键状态

#defineKEY_STATE_PRESS1

#defineKEY_STATE_LONG2

#defineKEY_STATE_UP3

#defineKEY_LONG_PERIOD20//定义长按键的TICK数,以及连发间隔的TICK数

#defineKEY_CONTINUE_PERIOD10

ucharKeyScan（>//按键扫描函数

{

if（key1==0>returnKEY_1。

if（key2==0>returnKEY_2。

if（key3==0>returnKEY_3。

if（key4==0>returnKEY_4。

returnKEY_NULL。

}

ucharGetKey（>

{

ucharkeyRetu=0,keyTemp=KEY_NULL。

staticuchars_keyState=KEY_STATE_INIT,keyTime=0,keyLast=KEY_NULL。

keyTemp=KeyScan（>。

switch（s_keyState>

{

caseKEY_STATE_INIT:

if（keyTemp!

=KEY_NULL>

{

s_keyState=KEY_STATE_PRESS。

}

break。

caseKEY_STATE_PRESS:

if（keyTemp!

=KEY_NULL>

{

s_keyState=KEY_STATE_LONG。

keyTime=0。

keyLast=keyTemp。

}

else

{

s_keyState=KEY_STATE_INIT。

}

break。

caseKEY_STATE_LONG:

if（keyTemp==KEY_NULL>

{

s_keyState=KEY_STATE_INIT。

keyRetu=（keyLast|KEY_PRESS>。

}

else

{

if（++keyTime>=KEY_LONG_PERIOD>//按下时间>1s

{

s_keyState=KEY_STATE_UP。

keyTime=0。

}

}

break。

caseKEY_STATE_UP:

if（keyTemp==KEY_NULL>

{

s_keyState=KEY_STATE_INIT。

}

else

{

if（++keyTime>=KEY_CONTINUE_PERIOD>//按下时间>0.5s

{

keyTime=0。

keyRetu=（keyLast|KEY_LONG>。

}

}

break。

}

returnkeyRetu。

}

ucharbcdtoasc（ucharcha>

{

return（（cha/16>*10+（cha%16>>。

}

ucharasctobcd（ucharcha>

{

return（（cha/10>*16+（cha%10>>。

}

//============延时子程序MS=====================================

voiddelay1（uintx>

{

uinta,b。

for（a=x。

a>0。

a-->

for（b=100。

b>0。

b-->。

}

//============短暂延时=====================================

voiddelay（>

{。

。

}

//=========8563起始信号子程序===============

voidstart（>

{

sda=1。

delay（>。

scl=1。

delay（>。

sda=0。

delay（>。

}

//==========8563终止信号子程序================

voidstop（>

{

sda=0。

delay（>。

scl=1。

delay（>。

sda=1。

delay（>。

}

//===========8563应答信号子程序====================

voidrespons（>

{

uchari。

scl=1。

delay（>。

while（（sda==1>&&（i<250>>i++。

//若无应答，重新开始发送地址

scl=0。

delay（>。

}

//===========8563总线初始化子程序=======================

voidp8563init（>

{

sda=1。

delay（>。

scl=1。

delay（>。

}

//===========写入1字节子程序======================

voidwrite_byte（uchardate>

{

uchari,temp。

temp=date。

//写入数据date

for（i=0。

i<8。

i++>

{

temp=temp<<1。

scl=0。

delay（>。

sda=CY。

//往数据线送date最高位,循环8次送完date

delay（>。

scl=1。

delay（>。

scl=0。

delay（>。

}

sda=1。

//释放数据总线，以便读取应答信号

delay（>。

}

//===========读取1字节子程序============================

ucharread_byte（>

{

uchari,k。

scl=0。

delay（>。

sda=1。

delay（>。

for（i=0。

i<8。

i++>//读回时是一位一位的所以要读8次

{

scl=1。

//scl置1数据才稳定才可以读取数据

delay（>。

k=（k<<1>|sda。

//sda送过来的数据送到k的最底位，循环8次从最高位读完sda上的数据

scl=0。

delay（>。

}

returnk。

//程序执行完返回k的值

}

//===========写一8位数据子程序===================================

voidwrite_add（ucharaddress,uchardate>

{

start（>。

//调用起始信号子程序,开始写入信号

write_byte（0xa2>。

//找芯片所在地址

respons（>。

//调用应答信号

write_byte（address>。

//找芯片内部存储器地址

respons（>。

write_byte（date>。

//写入数据，写进芯片内部存储器

respons（>。

stop（>。

//调用终止信号子程序，终止信号写入

}

//===========读一8位数据子程序================================

ucharread_add（ucharaddress>

{

uchardate。

start（>。

//调用起始信号子程序

write_byte（0xa2>。

//取芯片地址

respons（>。

write_byte（address>。

//取芯片内部存储器地址

respons（>。

start（>。

//调用起始信号子程序,开始读取信号

write_byte（0xa3>。

//芯片读地址

respons（>。

date=read_byte（>。

//把读取字节子程序的返回值给date

stop（>。

returndate。

//程序执行完返回date的值

}

//===============写时间子程序=============

voidwrite_8563（ucharw_miao,ucharw_fen,ucharw_shi,ucharw_day,ucharw_week,ucharw_month,ucharw_year>

{p8563init（>。

start（>。

write_add（0x00,0x00>。

write_add（0x01,0x00>。

write_add（0x02,w_miao>。

delay1（100>。

write_add（0x03,w_fen>。

delay1（100>。

write_add（0x4,w_shi>。

delay1（100>。

write_add（0x05,w_day>。

delay1（100>。

write_add（0x06,w_week>。

delay1（100>。

write_add（0x7,w_month>。

delay1（100>。

write_add（0x8,w_year>。

delay1（100>。

}

//===============读时间子程序============

voidread_8563（>

{

miao=read_add（0x02>&0x7f。

//获取秒数据

miao=（（miao&0xf0>>>4&0x0f>*10+（miao&0x0f>。

//BCD码转换成10进制数

//if（miao>=60>{miao=0。

}

fen=read_add（0x03>&0x7f。

//获取分钟

fen=（（fen&0xf0>>>4&0x0f>*10+（fen&0x0f>。

//BCD码转换成10进制数

//if（fen>=60>{fen=0。

}

shi=read_add（0x04>&0x3f。

//获取小时

shi=（（shi&0xf0>>>4&0x0f>*10+（shi&0x0f>。

//BCD码转换成10进制数

//if（shi>=24>{shi=0。

}

week=read_add（0x06>&0x07。

//获取星期

//if（week>6>{week=0。

}

day=read_add（0x05>&0x3f。

//获取日数据

day=（（day&0xf0>>>4&0x0f>*10+（day&0x0f>。

//BCD码转换成10进制数

//if（day>=31>{day=0。

}

month=read_add（0x07>&0x1f。

//获取月

month=（（month&0xf0>>>4&0x0f>*10+（month&0x0f>。

//BCD码转换成10进制数

//if（month>=24>{month=0。

}

year=read_add（0x08>&0xff。

//获取年

year=（（year&0xf0>>>4&0x0f>*10+（year&0x0f>。

//BCD码转换成10进制数

}

voiduinit（>

{wela1=0。

//关闭日期位选通

dula1=0。

//关闭日期段选通

wela2=0。

//关闭时间星期位选通

dula2=0。

//关闭时间星期段选通

TMOD=0X01。

//TH0=（65536-50000>/256。

//TL0=（65536-50000>%256。

TH0=0XF8。

//2ms

TL0=0XCC。

EA=1。

ET0=1。

TR0=1。

}

voidT_0time（>interrupt1

{

/*TH0=（65536-45872>/256。

TL0=（65536-45872>%256。

*/

TH0=0XF8。

//2ms

TL0=0XCC。

num++。

num1++。

num2++。

count++。

if（num1>=5>

{

num1=0。

dao10MS=1。

}

if（num2>=250>

{

num2=0。

dao500MS=1。

}

if（!

（count%25>>set=!

set。

if（count==500>

{

count=0。

}

if（num>=250>

{

num=0。

shanshuo=~shanshuo。

}

}

voidupdatetime（>

{

read_8563（>。

//读取秒时分

tabtime[0]=shi/10。

tabtime[1]=shi%10。

tabtime[2]=fen/10。

tabtime[3]=fen%10。

tabtime[4]=miao/10。

tabtime[5]=miao%10。

tabtime[6]=week%10。

tabdata[0]=2。

tabdata[1]=0。

tabdata[2]=year/10。

tabdata[3]=year%10。

tabdata[4]=month/10。

tabdata[5]=month%10。

tabdata[6]=day/10。

tabdata[7]=day%10。

}

/*/===============显示子程序============

voiddisplay（>

{

uchark=0。

for（k=0。

k<8。

k++>

{

wela2=1。

//时间星期

led_wei=weitime[k]。

dula2=1。

led_data=tab[tabtime[k]]。

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[k]。

dula1=1。

led_data=tab[tabdata[k]]。

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

}

}*/

voiddisplay（>

{

wela2=1。

//时间星期

led_wei=weitime[0]。

dula2=1。

led_data=tab[tabtime[0]]。

if（set&&xiaoshi>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[0]。

dula1=1。

led_data=tab[tabdata[0]]。

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[1]。

dula2=1。

led_data=tab[tabtime[1]]。

if（set&&xiaoshi>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[1]。

dula1=1。

led_data=tab[tabdata[1]]。

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[2]。

dula2=1。

led_data=tab[tabtime[2]]。

if（set&&fenzhong>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[2]。

dula1=1。

led_data=tab[tabdata[2]]。

if（set&&nianfen>

{led_data=0XFF。

}

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[3]。

dula2=1。

led_data=tab[tabtime[3]]。

if（set&&fenzhong>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[3]。

dula1=1。

led_data=tab[tabdata[3]]。

if（set&&nianfen>

{led_data=0XFF。

}

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[4]。

dula2=1。

led_data=tab[tabtime[4]]。

if（set&&miaozhong>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[4]。

dula1=1。

led_data=tab[tabdata[4]]。

if（set&&yuefen>

{led_data=0XFF。

}

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[5]。

dula2=1。

led_data=tab[tabtime[5]]。

if（set&&miaozhong>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期

led_wei=weidata[5]。

dula1=1。

led_data=tab[tabdata[5]]。

if（set&&yuefen>

{led_data=0XFF。

}

dula1=0。

wela1=0。

led_data=0xff。

delay1（1>。

wela2=1。

//时间星期

led_wei=weitime[6]。

dula2=1。

led_data=xing[tabtime[6]]。

//////////////////////////////////////////////////////

if（set&&xingqi>

{led_data=0XFF。

}

dula2=0。

wela2=0。

led_data=0xff。

delay1（1>。

//消除时间变化时的阴影

wela1=1。

//日期