单片机/MCU论坛
直播中

Sensation_ANG

4年用户 1经验值
擅长:可编程逻辑 嵌入式技术 处理器/DSP
私信 关注
[文章]

时钟控制器（电子时钟）

`基于电子钟的控制器，其实相当于是闹钟的功能。学习来源是根据宋雪松老师的《手把手教你学单片机》。通过stc89c52+LCD1602+DS1302+矩阵按键+LED小灯实现的。具体现象，到固定时间小灯会自主亮灭。程序分为5个部分。程序所实现的现象为在10:00,10:02,10:05开始亮，在10:01,10:04,10:06开始灭。
protues的仿真图在下方

一：LCD1602液晶模块
  1. #include
  2. //控制LCD1602的位
  3. #define LCD1602_DB P0        //数据位
  4. ***it LCD1602_RS = P2^6;        //指令/数据选择信号
  5. ***it LCD1602_RW = P2^5;        //读写选择信号
  6. ***it LCD1602_E = P2^7;        //使能信号

  8. /*LCD1602状态检测函数DB7为忙标志位，为1时禁止，为0是工作*/
  9. void LcdWaitReady()
  10. {
  11.         unsigned char sta;                //用来缓存LCD1602_DB的值

  13.         LCD1602_DB = 0xff;                //赋初值
  14.         LCD1602_RS = 0;
  15.         LCD1602_RW = 1;
  16.         do {
  17.                 LCD1602_E = 1;
  18.                 sta = LCD1602_DB;
  19.                 LCD1602_E = 0;
  20.         }while (sta&0x80);         //当DB7为0时结束循环
  21. }

  23. /*LCD1602写指令函数，形参cmd-要输入的指令*/
  24. void LcdWriteCmd(unsigned char cmd)
  25. {
  26.         LcdWaitReady();                //检测状态函数
  27.         LCD1602_RS = 0;                //根据LCD1602时序图所写
  28.         LCD1602_RW = 0;
  29.         LCD1602_DB = cmd;
  30.         LCD1602_E = 1;
  31.         LCD1602_E = 0;        
  32. }

  34. /*LCD1602设置坐标函数，形参(x,y)-书写坐标*/
  35. void LcdSetCursor(unsigned char x, unsigned char y)
  36. {
  37.         unsigned char addr;                        //书写地址

  39.         if (y == 0)
  40.                 addr = x + 0x00;
  41.         else
  42.                 addr = x + 0x40;
  43.         LcdWriteCmd(addr | 0x80);  //写入书写的地址
  44. }

  46. /*LCD1602写入数据函数，形参dat-要写入的数据*/
  47. void LcdWriteDat(unsigned char dat)
  48. {
  49.         LcdWaitReady();                                //状态检测函数
  50.         LCD1602_RS = 1;
  51.         LCD1602_RW = 0;
  52.         LCD1602_DB = dat;
  53.         LCD1602_E = 1;
  54.         LCD1602_E = 0;
  55. }

  57. /*LCD1602开光标函数*/
  58. void LcdOpenCursor()
  59. {
  60.         LcdWriteCmd(0x0f);
  61. }

  63. /*LCD1602关闭光标函数*/
  64. void LcdCloseCursor()
  65. {
  66.         LcdWriteCmd(0x0c);
  67. }

  69. /*LCD1602显示字符函数，形参(x,y)-代表书写坐标，str-所写字符串的指针*/
  70. void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str)
  71. {
  72.         LcdSetCursor(x, y);                        //设置坐标函数
  73.         while (*str != '\0')
  74.         {
  75.                 LcdWriteDat(*str++);         //写数据函数
  76.         }
  77. }

  79. /*LCD1602液晶初始化函数*/
  80. void InitLcd1602()
  81. {
  82.         LcdWriteCmd(0x38);        //写指令函数。功能设置，8位数据总线，两行显示，5*7点阵
  83.         LcdWriteCmd(0x0c);        //显示开关控制，开显示，游标不显示
  84.         LcdWriteCmd(0x06);        //完成一个字符码传送后，光标右移，地址自动加1
  85.         LcdWriteCmd(0x01);        //清显示
  86. }

二:矩阵按键模块
  1. #include
  2. //控制按键的位
  3. ***it keyout1 = P1^7;
  4. ***it keyout2 = P1^6;
  5. ***it keyout3 = P1^5;
  6. ***it keyout4 = P1^4;
  7. ***it keyin1 = P1^3;
  8. ***it keyin2 = P1^2;
  9. ***it keyin3 = P1^1;
  10. ***it keyin4 = P1^0;

  12. unsigned char code KeyCodeMap[4][4] = {         //矩阵按键编号到标准键盘键码的印射表
  13.         {'1', '2', '3', 0x26},                                 //数字键1，数字键2，数字键3，向上键
  14.         {'4', '5', '6', 0x25},                                 //数字键4，数字键5，数字键6，向左键
  15.         {'7', '8', '9', 0x28},                                 //数字键7，数字键8，数字键9，向下键
  16.         {'0', 0x1b, 0x0d, 0x27}                                 //数字键0，ESC键，回车键，向右键
  17. };
  18. //用来保存按键的状态
  19. unsigned char keysta[4][4] = {
  20.         {1, 1, 1, 1},{1, 1, 1, 1},{1, 1, 1, 1},{1, 1, 1, 1}
  21. };

  23. extern void KeyAction(unsigned char keycode);

  25. /*按键驱动函数，用来调用按键*/
  26. void KeyDriver()
  27. {        //用来保存上一次按键的状态
  28.         static unsigned char backup[4][4] = {
  29.                 {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
  30.         };
  31.         unsigned char i;
  32.         unsigned char j;

  34.         for (i = 0; i < 4; i++)        //构建两层循环来完成对矩阵按键的扫描
  35.         {
  36.                 for (j = 0; j < 4; j++)
  37.                 {
  38.                         if (keysta[i][j] != backup[i][j])
  39.                         {
  40.                                 if (backup[i][j] != 0)
  41.                                 {
  42.                                         KeyAction(KeyCodeMap[i][j]); //通过按键位置来执行相应的程序
  43.                                 }
  44.                                 backup[i][j] = keysta[i][j];
  45.                         }
  46.                 }
  47.         }        
  48. }

  50. /*按键扫描函数，通过定时器0中断来完成1ms扫描一次*/
  51. void KeyScan()
  52. {
  53.         static unsigned char keyout = 0;
  54.         static unsigned char keybuff[4][4] = {        //用来消抖
  55.                 {0xff, 0xff, 0xff, 0xff},{0xff, 0xff, 0xff, 0xff},
  56.                 {0xff, 0xff, 0xff, 0xff},{0xff, 0xff, 0xff, 0xff}
  57.         };
  58.         unsigned char i;

  60.         //将一行的4个按键值移入缓冲区
  61.         keybuff[keyout][0] = (keybuff[keyout][0] << 1)|keyin1;
  62.         keybuff[keyout][1] = (keybuff[keyout][1] << 1)|keyin2;
  63.         keybuff[keyout][2] = (keybuff[keyout][2] << 1)|keyin3;
  64.         keybuff[keyout][3] = (keybuff[keyout][3] << 1)|keyin4;
  65.         //消抖后更新按键状态
  66.         for (i = 0; i < 4; i++)
  67.         {
  68.                 if ((keybuff[keyout][i]&0x0f) == 0x0f)
  69.                 {//连续4次扫描值为1，即4*4ms内都是弹起状态时，可以认为按键已稳定弹起
  70.                         keysta[keyout][i] = 1;
  71.                 }
  72.                 else if ((keybuff[keyout][i]&0x0f) == 0x00)
  73.                 {//连续4次扫描值为0，即4*4ms内都是按下状态时，可以认为按键已稳定按下
  74.                         keysta[keyout][i] = 0;
  75.                 }
  76.         }
  77.         keyout++;
  78.         if (keyout >= 4)
  79.                 keyout = 0;
  80.         switch (keyout)
  81.         {  //每次拉低一个按键的值
  82.                 case 0:keyout1=0;keyout2=1;keyout3=1;keyout4=1;break;
  83.                 case 1:keyout1=1;keyout2=0;keyout3=1;keyout4=1;break;
  84.                 case 2:keyout1=1;keyout2=1;keyout3=0;keyout4=1;break;
  85.                 case 3:keyout1=1;keyout2=1;keyout3=1;keyout4=0;break;
  86.                 default:break;
  87.         }
  88. }
三：DS1302时钟芯片模块（单字节读出函数未使用）
  1. #include
  2. #include
  3. //控制DS1302时钟的位
  4. ***it DS1302_SK = P3^6;                        //时钟信号端，通过控制其高低电平来输入/输出数据
  5. ***it DS1302_IO = P3^4;                        //输入输出数据端
  6. ***it DS1302_CE = P3^5;                        //使能端，高电平时有效

  8. struct sTime {                                           //定义时间结构体
  9.         unsigned char year;                        //年
  10.         unsigned char mon;                        //月
  11.         unsigned char day;                        //日
  12.         unsigned char hour;                        //时
  13.         unsigned char min;                        //分
  14.         unsigned char sec;                        //秒
  15.         unsigned char week;                        //星期
  16. };

  18. /*DS1302读出函数，根据时序图编写，返回值为读出的数据*/
  19. unsigned char DS1302ByteRead()
  20. {
  21.         unsigned char dat = 0;
  22.         unsigned char mask;

  24.         for (mask=0x01; mask!=0; mask<<=1)
  25.         {
  26.                 if (DS1302_IO != 0)
  27.                         dat |= mask;
  28.                 DS1302_SK = 1;        //先准备好数据，然后拉高SK
  29.                 _nop_();
  30.                 DS1302_SK = 0;        //拉低SK
  31.                 _nop_();
  32.         }

  34.         return dat;
  35. }

  37. /*DS1302写入函数，根据时序图编写，dat-写入的数据*/
  38. void DS1302ByteWrite(unsigned char dat)
  39. {
  40.         unsigned char mask;

  42.         for (mask=0x01; mask!=0; mask<<=1)
  43.         {
  44.                 if ((mask&dat) != 0) //将输入数据的位从最低位依次输入
  45.                         DS1302_IO = 1;
  46.                 else
  47.                         DS1302_IO = 0;
  48.                 DS1302_SK = 1;                 //先准备好数据，拉高SK，数据采样
  49.                 _nop_();
  50.                 DS1302_SK = 0;                 //拉低SK，数据输出
  51.                 _nop_();
  52.         }
  53.         DS1302_IO = 1;                            //释放IO引脚
  54. }

  56. /*DS1302单字节读出函数，addr-写入要读字节的寄存器地址，返回值为读出的数据*/
  57. unsigned char DS1302SingleRead(unsigned char addr)
  58. {
  59.         unsigned char dat;

  61.         DS1302_CE = 1;
  62.         _nop_();
  63.         DS1302ByteWrite(addr);
  64.         dat = DS1302ByteRead();
  65.         DS1302_CE = 0;
  66.         _nop_();

  68.         return dat;
  69. }

  71. /*DS1302单字节写入函数,addr-写入字节的寄存器地址，dat-写入数据*/
  72. void DS1302SingleWrite(unsigned addr, unsigned dat)
  73. {
  74.         DS1302_CE = 1;
  75.         _nop_();
  76.         DS1302ByteWrite(addr);
  77.         DS1302ByteWrite(dat);
  78.         DS1302_CE = 0;
  79.         _nop_();
  80. }

  82. /*DS1302Burst写入模式，一次写入8个字节,dat-写入数据的指针*/
  83. void DS1302BurstWrite(unsigned char *dat)
  84. {
  85.         unsigned char i;

  87.         DS1302_CE = 1;
  88.         _nop_();
  89.         DS1302ByteWrite(0xbe);
  90.         for (i = 0; i < 8; i++)
  91.         {
  92.                 DS1302ByteWrite(*dat++);
  93.         }
  94.         DS1302_CE = 0;
  95.         _nop_();
  96. }

  98. /*DS1302Burst读出模式，一次读出8个字节，dat-存储读出数据的指针*/
  99. void DS1302BurstRead(unsigned char * dat)
  100. {
  101.         unsigned char i;

  103.         DS1302_CE = 1;
  104.         _nop_();
  105.         DS1302ByteWrite(0xbf);
  106.         for (i = 0; i < 8; i++)
  107.         {
  108.                 *dat++ = DS1302ByteRead();
  109.         }
  110.         DS1302_CE = 0;
  111.         _nop_();
  112. }

  114. /*获取实时时间，time-存储时间的结构体*/
  115. void GetRealTime(struct sTime * time)
  116. {
  117.         unsigned char buf[8];

  119.         DS1302BurstRead(buf);
  120.         time->year = buf[6] + 0x2000;
  121.         time->week = buf[5];
  122.         time->mon = buf[4];
  123.         time->day = buf[3];
  124.         time->hour = buf[2];
  125.         time->min = buf[1];
  126.         time->sec = buf[0];
  127. }

  129. /*设置实时时间，dat-要写入的数据的结构体*/
  130. void SetRealTime(struct sTime * dat)
  131. {
  132.         unsigned char buf[8];

  134.         buf[7] = 0x00;
  135.         buf[6] = dat->year;
  136.         buf[5] = dat->week;
  137.         buf[4] = dat->mon;
  138.         buf[3] = dat->day;
  139.         buf[2] = dat->hour;
  140.         buf[1] = dat->min;
  141.         buf[0] = dat->sec;
  142.         DS1302BurstWrite(buf);
  143. }

  145. /*初始化DS1302函数*/
  146. void InitDS1302()
  147. {
  148.         struct sTime code InitTime[] = {0x2019, 0x10, 0x11, 0x09, 0x59, 0x50, 0x05};

  150.         DS1302_CE = 0;
  151.         _nop_();                                       //延时一个机器周期
  152.         DS1302_SK = 0;
  153.         _nop_();
  154.         DS1302SingleWrite(0x8e, 0x00); //撤销写保护，0x8e-写保护位的地址，0x00-撤销写保护
  155.         SetRealTime(InitTime);                   //设置初始时间
  156.         DS1302SingleWrite(0x8e, 0x80); //添加写保护
  157. }
四：设置时间函数
  1. #include

  3. struct sTime {                                        //定义时间结构体
  4.         unsigned char year;                        //年
  5.         unsigned char mon;                    //月
  6.         unsigned char day;                        //日
  7.         unsigned char hour;                        //时
  8.         unsigned char min;                        //分
  9.         unsigned char sec;                        //秒
  10.         unsigned char week;                        //星期
  11. };

  13. struct sTime bufTime;                        //时间缓冲区
  14. unsigned char setIndex = 0;                //设置标志位
  15. /*函数声明*/
  16. extern void RefreshTime();
  17. extern void LcdSetCursor(unsigned char x, unsigned char y);
  18. extern void SetRealTime(struct sTime * dat);
  19. extern void LcdCloseCursor();
  20. extern void LcdOpenCursor();

  22. /*刷新当前设置位的光标指示*/
  23. void RefreshSetShow()
  24. {
  25.         switch(setIndex)
  26.         {
  27.                 case 1:LcdSetCursor(2, 0);break;
  28.                 case 2:LcdSetCursor(3, 0);break;
  29.                 case 3:LcdSetCursor(5, 0);break;
  30.                 case 4:LcdSetCursor(6, 0);break;
  31.                 case 5:LcdSetCursor(8, 0);break;
  32.                 case 6:LcdSetCursor(9, 0);break;
  33.                 case 7:LcdSetCursor(15, 0);break;
  34.                 case 8:LcdSetCursor(4, 1);break;
  35.                 case 9:LcdSetCursor(5, 1);break;
  36.                 case 10:LcdSetCursor(7, 1);break;
  37.                 case 11:LcdSetCursor(8, 1);break;
  38.                 case 12:LcdSetCursor(10, 1);break;
  39.                 case 13:LcdSetCursor(11, 1);break;
  40.                 default:break;
  41.         }
  42. }

  44. /***********************************************************************/
  45. //递增或递减分，秒的BCD码
  46. /*递增一个BCD码的高位*/
  47. unsigned char IncTimeBcdHigh(unsigned char bcd)
  48. {
  49.         if ((bcd&0xf0) < 0x50)
  50.                 bcd += 0x10;
  51.         else
  52.                 bcd &= 0x0f;

  54.         return bcd;
  55. }

  57. /*递减一个BCD码的高位*/
  58. unsigned char DecTimeBcdHigh(unsigned char bcd)
  59. {
  60.         if ((bcd&0xf0) > 0x00)
  61.                 bcd -= 0x10;
  62.         else
  63.                 bcd |= 0x50;

  65.         return bcd;
  66. }

  68. //递增或递减时，分，秒的BCD码
  69. /********************************************************************/

  71. /*递增一个BCD码的高位*/
  72. unsigned char IncBcdHigh(unsigned char bcd)
  73. {
  74.         if ((bcd&0xf0) < 0x90)
  75.                 bcd += 0x10;
  76.         else
  77.                 bcd &= 0x0f;

  79.         return bcd;
  80. }

  82. /*递增一个BCD码的低位*/
  83. unsigned char IncBcdLow(unsigned char bcd)
  84. {
  85.         if ((bcd&0x0f) < 0x09)
  86.                 bcd += 0x01;
  87.         else
  88.                 bcd &= 0xf0;

  90.         return bcd;
  91. }

  93. /*递减一个BCD码的高位*/
  94. unsigned char DecBcdHigh(unsigned char bcd)
  95. {
  96.         if ((bcd&0xf0) > 0x00)
  97.                 bcd -= 0x10;
  98.         else
  99.                 bcd |= 0x90;

  101.         return bcd;
  102. }

  104. /*递减一个BCD码的低位*/
  105. unsigned char DecBcdLow(unsigned char bcd)
  106. {
  107.         if ((bcd&0x0f) > 0x00)
  108.                 bcd -= 0x01;
  109.         else
  110.                 bcd |= 0x09;

  112.         return bcd;
  113. }

  115. /*递增周的BCD码*/
  116. unsigned char IncWeekBcd(unsigned char bcd)
  117. {
  118.         if ((bcd&0x0f) < 0x07)
  119.                 bcd += 0x01;
  120.         else
  121.                 bcd = 0x00;        

  123.         return bcd;
  124. }

  126. /*递减周的BCD码*/
  127. unsigned char DecWeekBcd(unsigned char bcd)
  128. {
  129.         if ((bcd&0x0f) > 0x00)
  130.                 bcd -= 0x01;
  131.         else
  132.                 bcd = 0x07;

  134.         return bcd;
  135. }

  137. /*递增时间当前设置位的值*/
  138. void IncSetTime()
  139. {
  140.         switch(setIndex)
  141.         {
  142.                 case 1:bufTime.year = IncBcdHigh(bufTime.year);break;
  143.                 case 2:bufTime.year = IncBcdLow(bufTime.year);break;
  144.                 case 3:bufTime.mon = IncBcdHigh(bufTime.mon);break;
  145.                 case 4:bufTime.mon = IncBcdLow(bufTime.mon);break;
  146.                 case 5:bufTime.day = IncBcdHigh(bufTime.day);break;
  147.                 case 6:bufTime.day = IncBcdLow(bufTime.day);break;
  148.                 case 7:bufTime.week = IncWeekBcd(bufTime.week);break;
  149.                 case 8:bufTime.hour = IncBcdHigh(bufTime.hour);break;
  150.                 case 9:bufTime.hour = IncBcdLow(bufTime.hour);break;
  151.                 case 10:bufTime.min = IncTimeBcdHigh(bufTime.min);break;
  152.                 case 11:bufTime.min = IncBcdLow(bufTime.min);break;
  153.                 case 12:bufTime.sec = IncTimeBcdHigh(bufTime.sec);break;
  154.                 case 13:bufTime.sec = IncBcdLow(bufTime.sec);break;
  155.                 default:break;
  156.         }
  157.         RefreshTime();
  158.         RefreshSetShow();
  159. }

  161. /*递减时间当前设置位的值*/
  162. void DecSetTime()
  163. {
  164.         switch(setIndex)
  165.         {
  166.                 case 1:bufTime.year = DecBcdHigh(bufTime.year);break;
  167.                 case 2:bufTime.year = DecBcdLow(bufTime.year);break;
  168.                 case 3:bufTime.mon = DecBcdHigh(bufTime.mon);break;
  169.                 case 4:bufTime.mon = DecBcdLow(bufTime.mon);break;
  170.                 case 5:bufTime.day = DecBcdHigh(bufTime.day);break;
  171.                 case 6:bufTime.day = DecBcdLow(bufTime.day);break;
  172.                 case 7:bufTime.week = DecWeekBcd(bufTime.week);break;
  173.                 case 8:bufTime.hour = DecBcdHigh(bufTime.hour);break;
  174.                 case 9:bufTime.hour = DecBcdLow(bufTime.hour);break;
  175.                 case 10:bufTime.min = DecTimeBcdHigh(bufTime.min);break;
  176.                 case 11:bufTime.min = DecBcdLow(bufTime.min);break;
  177.                 case 12:bufTime.sec = DecTimeBcdHigh(bufTime.sec);break;
  178.                 case 13:bufTime.sec = DecBcdLow(bufTime.sec);break;
  179.                 default:break;
  180.         }
  181.         RefreshTime();
  182.         RefreshSetShow();        
  183. }

  185. /*光标左移函数*/
  186. void LeftShift()
  187. {
  188.         if (setIndex != 0)
  189.         {
  190.                 if (setIndex > 1)
  191.                 {
  192.                         setIndex--;
  193.                 }
  194.                 else
  195.                 {
  196.                         setIndex = 13;
  197.                 }
  198.                 RefreshSetShow();
  199.         }
  200. }

  202. /*光标右移函数*/
  203. void RightShift()
  204. {
  205.         if (setIndex != 0)
  206.         {
  207.                 if (setIndex < 13)
  208.                 {
  209.                         setIndex++;
  210.                 }
  211.                 else
  212.                 {
  213.                         setIndex = 1;
  214.                 }
  215.                 RefreshSetShow();
  216.         }
  217. }

  219. /*退出时间设置函数，save-是否保存标志*/
  220. void ExitSetTime(bit save)
  221. {
  222.         setIndex = 0;
  223.         if (save)
  224.         {
  225.                 SetRealTime(&bufTime);
  226.         }
  227.         LcdCloseCursor();
  228. }

  230. /*进入时间设置函数*/
  231. void EnterSetTime()
  232. {
  233.         setIndex = 2;                        //先把设置标志位设为2，再向左移
  234.         LeftShift();
  235.         LcdOpenCursor();
  236. }

  238. /*按键执行函数，keycode-所传递的哪一个按键被按下*/
  239. void KeyAction(unsigned char keycode)
  240. {
  241.         if (keycode >= '0' && keycode <= '9')
  242.         {
  243.         //数字按键不执行任何动作
  244.         }
  245.         else if (keycode == 0x26)          //数字键加
  246.         {
  247.                 IncSetTime();
  248.         }
  249.         else if (keycode == 0x28)          //数字键减
  250.         {
  251.                 DecSetTime();
  252.         }
  253.         else if (keycode == 0x25)          //光标向左移动
  254.         {
  255.                 LeftShift();
  256.         }
  257.         else if (keycode == 0x27)          //光标向右移动
  258.         {
  259.                 RightShift();
  260.         }
  261.         else if (keycode == 0x0d)          //进入/退出时间设置
  262.         {
  263.                 if (setIndex == 0)
  264.                 {
  265.                         EnterSetTime();
  266.                 }
  267.                 else
  268.                 {
  269.                         ExitSetTime(1);          //保存数据并退出
  270.                 }
  271.         }
  272.         else if (keycode == 0x1b)          //取消键
  273.         {
  274.                 ExitSetTime(0);                  //不保存数据
  275.         }
  276. }
五：主程序
  1. #include
  2. //控制小灯的位
  3. ***it led1 = P2^0;
  4. ***it led2 = P2^1;
  5. ***it led3 = P2^2;

  7. //小灯开启时间表
  8. ledstarthour[3] = {0x10, 0x10, 0x10};
  9. ledstartmin[3] = {0x00, 0x02, 0x05};
  10. //小灯关闭时间表
  11. ledclosehour[3] = {0x10, 0x10, 0x10};
  12. ledclosemin[3] = {0x01, 0x04, 0x06};

  14. struct sTime {                                        //定义时间结构体
  15.         unsigned char year;                        //年
  16.         unsigned char mon;                        //月
  17.         unsigned char day;                        //日
  18.         unsigned char hour;                        //时
  19.         unsigned char min;                        //分
  20.         unsigned char sec;                        //秒
  21.         unsigned char week;                        //星期
  22. };

  24. bit flag200ms = 0;                                                //定时标志
  25. extern struct sTime bufTime;                        //时间缓冲区
  26. extern unsigned char setIndex ;                    //设置标志位
  27. unsigned char T0RH = 0;                                        //定时器的高8位
  28. unsigned char T0RL = 0;                                        //定时器的低8位
  29. /*函数声明*/
  30. extern void KeyScan();
  31. void configTimer0(unsigned char ms);
  32. extern void InitLcd1602();
  33. extern void InitDS1302();
  34. extern void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
  35. extern void KeyDriver();
  36. extern void GetRealTime(struct sTime * time);
  37. void RefreshTime();
  38. void LedStartMonitor();
  39. void LedCloseMonitor();

  41. void main()
  42. {
  43.         unsigned char psec = 0xaa;        //秒备份

  45.         EA = 1;                                                //开总中断
  46.         configTimer0(1);                        //为定时器0配置时间
  47.         InitLcd1602();                                //初始化液晶显示屏
  48.         InitDS1302();                                //初始化时钟
  49.         //显示液晶上固定的位
  50.         LcdShowStr(0, 0, "20  -  -   week ");
  51.         LcdShowStr(4, 1, "  :  :  ");

  53.         while (1)
  54.         {
  55.                 KeyDriver();                                //按键驱动
  56.                 if (flag200ms && (setIndex == 0))
  57.                 {
  58.                         flag200ms = 0;
  59.                         GetRealTime(&bufTime);                 //获取实时时间
  60.                         LedStartMonitor();
  61.                         LedCloseMonitor();
  62.                         if (psec != bufTime.sec)        //如果秒发生变化，就刷新时间
  63.                         {
  64.                                 RefreshTime();
  65.                                 psec = bufTime.sec;
  66.                         }
  67.                 }
  68.         }
  69. }

  71. /*监控时间开启小灯函数，当到达指定时间，小灯亮*/
  72. void LedStartMonitor()
  73. {
  74.         static unsigned char i = 0;
  75.         if ((bufTime.hour == ledstarthour[i])&&(bufTime.min == ledstartmin[i]))
  76.         {
  77.                 led1 = 0;
  78.                 led2 = 0;
  79.                 led3 = 0;
  80.                 i++;
  81.                 if (i >= 3)
  82.                         i = 0;
  83.         }
  84. }

  86. /*监控时间关闭小灯函数，当到达指定时间，小灯灭*/
  87. void LedCloseMonitor()
  88. {
  89.         static unsigned char i = 0;
  90.         if ((bufTime.hour == ledclosehour[i])&&(bufTime.min == ledclosemin[i]))
  91.         {
  92.                 led1 = 1;
  93.                 led2 = 1;
  94.                 led3 = 1;
  95.                 i++;
  96.                 if (i >= 3)
  97.                         i = 0;
  98.         }
  99. }

  101. /*将BCD码转换为字符串*/
  102. void ShowBcdByte(unsigned char x, unsigned char y, unsigned char dat)
  103. {
  104.         unsigned char buf[3];
  105.         if (x == 15)                                 //对“周”的特殊照顾
  106.         {
  107.                 buf[0] = (dat&0x0f)+'0';
  108.                 buf[1] = '\0';
  109.         }
  110.         else
  111.         {
  112.                 buf[0] = (dat>>4)+'0';         
  113.                 buf[1] = (dat&0x0f)+'0';
  114.                 buf[2] = '\0';
  115.         }
  116.         LcdShowStr(x, y, buf);
  117. }

  119. /*刷新时间函数*/
  120. void RefreshTime()
  121. {
  122.         ShowBcdByte(2, 0, bufTime.year);
  123.         ShowBcdByte(5, 0, bufTime.mon);
  124.         ShowBcdByte(8, 0, bufTime.day);
  125.         ShowBcdByte(15, 0, bufTime.week);
  126.         ShowBcdByte(4, 1, bufTime.hour);
  127.         ShowBcdByte(7, 1, bufTime.min);
  128.         ShowBcdByte(10, 1, bufTime.sec);
  129. }

  131. /*配置定时器0*/
  132. void configTimer0(unsigned char ms)
  133. {
  134.         unsigned long temp;

  136.         temp = 11059200 / 12;
  137.         temp = (temp*ms)/1000;
  138.         temp = 65536 - temp;
  139.         T0RH = (unsigned char)(temp >> 8);
  140.         T0RL = (unsigned char)temp;
  141.         TMOD &= 0xf0;
  142.         TMOD |= 0x01;
  143.         TH0 = T0RH;
  144.         TL0 = T0RL;
  145.         TR0 = 1;
  146.         ET0 = 1;                //打开定时器0中断
  147. }

  149. /*中断函数*/
  150. void InterruptTimer0()                        interrupt 1
  151. {
  152.         static unsigned char tmr200ms = 0;

  154.         TH0 = T0RH;
  155.         TL0 = T0RL;
  156.         KeyScan();
  157.         tmr200ms++;
  158.         if (tmr200ms >= 200)
  159.         {
  160.                 tmr200ms = 0;
  161.                 flag200ms = 1;
  162.         }
  163. }



` 控制系统.jpg

更多回帖

0 0 4

相关帖子

控制器 电子钟
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分