devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

51单片机——多功能电子钟_51单片机多功能电子钟

作者：知新_RL | 2024-04-12 01:49:07

赞

踩

51单片机多功能电子钟

单片机——多功能电子钟


宗旨：技术的学习是有限的，分享的精神是无限的。


实现的功能有：走 时、校时、闹钟、温度、遥控这几个功能。要想实现这几个功能，其中走时所需要的就是时 钟芯片，即 DS1302；时间需要显示给人看，就需要显示器件，我们用到了点阵、数码管、 独立 LED、液晶；再来看校时，校时需要输入器件。

 

注重模块化思想：

  1. // 工程配置头文件config.h:
  2. #ifndef _CONFIG_H
  3. #define _CONFIG_H
  4.  
  5. /* 通用头文件 */
  6. #include <reg52.h>
  7. #include <intrins.h>
  8.  
  9. /* 数据类型定义 */
  10. typedef signed  char         int8;   // 8位有符号整型数
  11. typedef signed  int            int16;  //16位有符号整型数
  12. typedef signed  long         int32;  //32位有符号整型数
  13. typedef unsigned  char     uint8;  // 8位无符号整型数
  14. typedef unsigned  int        uint16; //16位无符号整型数
  15. typedef unsigned  long     uint32; //32位无符号整型数
  16.  
  17. /* 全局运行参数定义 */
  18. #define SYS_MCLK   (11059200/12)  //系统主时钟频率，即振荡器频率÷12
  19.  
  20. /* IO引脚分配定义 */
  21. sbit KEY_IN_1  = P2 ^ 4; //矩阵按键的扫描输入引脚1
  22. sbit KEY_IN_2  = P2 ^ 5; //矩阵按键的扫描输入引脚2
  23. sbit KEY_IN_3  = P2 ^ 6; //矩阵按键的扫描输入引脚3
  24. sbit KEY_IN_4  = P2 ^ 7; //矩阵按键的扫描输入引脚4
  25. sbit KEY_OUT_1 = P2 ^ 3; //矩阵按键的扫描输出引脚1
  26. sbit KEY_OUT_2 = P2 ^ 2; //矩阵按键的扫描输出引脚2
  27. sbit KEY_OUT_3 = P2 ^ 1; //矩阵按键的扫描输出引脚3
  28. sbit KEY_OUT_4 = P2 ^ 0; //矩阵按键的扫描输出引脚4
  29.  
  30. sbit ADDR0 = P1 ^ 0; //LED位选译码地址引脚0
  31. sbit ADDR1 = P1 ^ 1; //LED位选译码地址引脚1
  32. sbit ADDR2 = P1 ^ 2; //LED位选译码地址引脚2
  33. sbit ADDR3 = P1 ^ 3; //LED位选译码地址引脚3
  34. sbit ENLED = P1 ^ 4; //LED显示部件的总使能引脚
  35.  
  36. #define LCD1602_DB  P0  //1602液晶数据端口
  37. sbit LCD1602_RS = P1 ^ 0; //1602液晶指令/数据选择引脚
  38. sbit LCD1602_RW = P1 ^ 1; //1602液晶读写引脚
  39. sbit LCD1602_E  = P1 ^ 5; //1602液晶使能引脚
  40.  
  41. sbit DS1302_CE = P1 ^ 7; //DS1302片选引脚
  42. sbit DS1302_CK = P3 ^ 5; //DS1302通信时钟引脚
  43. sbit DS1302_IO = P3 ^ 4; //DS1302通信数据引脚
  44.  
  45. sbit I2C_SCL = P3 ^ 7; //I2C总线时钟引脚
  46. sbit I2C_SDA = P3 ^ 6; //I2C总线数据引脚
  47.  
  48. sbit BUZZER = P1 ^ 6; //蜂鸣器控制引脚
  49.  
  50. sbit IO_18B20 = P3 ^ 2; //DS18B20通信引脚
  51.  
  52. sbit IR_INPUT = P3 ^ 3; //红外接收引脚
  53.  
  54. #endif /* _CONFIG_H  */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>
  1. // 头文件Lcd1602.h：
  2. #ifndef  _LCD1602_H
  3. #define _LCD1602_H
  4.  
  5. #ifndef  _LCD1602_C
  6.  
  7. #endif
  8.  
  9. void InitLcd1602();
  10. void LcdClearScreen();
  11. void LcdOpenCursor();
  12. void LcdCloseCursor();
  13. void LcdSetCursor(uint8 x, uint8 y);
  14. void LcdShowStr(uint8 x, uint8 y, uint8*str);
  15. void LcdShowChar(uint8 x, uint8 y, uint8chr);
  16.  
  17. #endif /* _LCD1602_H  */
  18.  
  19. // 实时时钟芯片DS1302驱动模块的头文件DS1302.h：
  20. #ifndef  _DS1302_H
  21. #define _DS1302_H
  22.  
  23. struct sTime    //日期时间结构
  24. {
  25.     uint16 year; //年
  26.     uint8 mon;   //月
  27.     uint8 day;   //日
  28.     uint8 hour;  //时
  29.     uint8 min;   //分
  30.     uint8 sec;   //秒
  31.     uint8 week;  //星期
  32. };
  33.  
  34. #ifndef  _DS1302_C
  35.  
  36. #endif
  37.  
  38. void InitDS1302();
  39. void GetRealTime(struct sTime *time);
  40. void SetRealTime(struct sTime *time);
  41.  
  42. #endif /* _DS1302_H  */
  1. // 温度传感器DS18B20驱动模块的头文件
  2. #ifndef  _DS18B20_H
  3. #define _DS18B20_H
  4.  
  5. #ifndef  _DS18B20_C
  6.  
  7. #endif
  8.  
  9. bit Start18B20();
  10. bit Get18B20Temp(int16 *temp);
  11.  
  12. #endif /* _DS18B20_H */

  1. // 多功能电子钟主要功能文件的头文件Time.h：
  2. #ifndef  _TIME_H
  3. #define _TIME_H
  4.  
  5. #ifndef   _TIME_C
  6.  
  7. #endif
  8. void RefreshTime();
  9. void RefreshDate(uint8 ops);
  10. void RefreshAlarm();
  11. void AlarmMonitor();
  12. void KeyAction(uint8 keycode);
  13.  
  14. #endif /* _TIME_H */

  1. // 4*4矩阵按键驱动模块的头文件keyboard.h：
  2. #ifndef  _KEY_BOARD_H
  3. #define _KEY_BOARD_H
  4.  
  5. #ifndef  _KEY_BOARD_C
  6.  
  7. #endif
  8.  
  9. void KeyScan();
  10. void KeyDriver();
  11.  
  12. #endif /* _KEY_BOARD_H */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

  1. // 点阵LED、数码管、独立LED和无源蜂鸣器的驱动模块头文件：LedBuzzer.h：
  2. #ifndef  _LED_BUZZER_H
  3. #define _LED_BUZZER_H
  4.  
  5. struct sLedBuff    //LED显示缓冲区结构
  6. {
  7.     uint8 array[8];   //点阵缓冲区
  8.     uint8 number[6];  //数码管缓冲区
  9.     uint8 alone;      //独立LED缓冲区
  10. };
  11.  
  12. #ifndef  _LED_BUZZER_C
  13. extern bit staBuzzer;
  14. extern struct sLedBuff ledBuff;
  15. #endif
  16.  
  17. void InitLed();
  18. void FlowingLight();
  19. void ShowLedNumber(uint8 index, uint8num, uint8 point);
  20. void ShowLedArray(uint8 *ptr);
  21.  
  22. #endif /* _LED_BUZZER_H */<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

  1. // 主文件的头文件main.h：
  2. #ifndef  _MAIN_H
  3. #define _MAIN_H
  4.  
  5. enum eStaSystem    //系统运行状态枚举
  6. {
  7.     E_NORMAL, E_SET_TIME, E_SET_ALARM
  8. };
  9.  
  10. #ifndef  _MAIN_C
  11. extern enum eStaSystem staSystem;
  12. #endif
  13.  
  14. void RefreshTemp(uint8 ops);
  15. void ConfigTimer0(uint16 ms);
  16.  
  17. #endif /* _MAIN_H */

//=============================================================================

  1. // Lcd1602.c：
  2. #define  _LCD1602_C
  3. #include "config.h"
  4. #include "Lcd1602.h"
  5.  
  6. uint8 tmpP0;   //暂存P0口的值
  7. bit tmpADDR0;  //暂存LED位选译码地址0的值
  8. bit tmpADDR1;  //暂存LED位选译码地址1的值
  9.  
  10. /* 暂停LED动态扫描，暂存相关引脚的值 */
  11. void LedScanPause()
  12. {
  13.     ENLED = 1;
  14.     tmpP0 = P0;
  15.     tmpADDR0 = ADDR0;
  16.     tmpADDR1 = ADDR1;
  17. }
  18. /* 恢复LED动态扫描，恢复相关引脚的值 */
  19. void  LedScanContinue()
  20. {
  21.     ADDR0 = tmpADDR0;
  22.     ADDR1 = tmpADDR1;
  23.     P0 = tmpP0;
  24.     ENLED = 0;
  25. }
  26. /* 等待液晶准备好 */
  27. void  LcdWaitReady()
  28. {
  29.     uint8 sta;
  30.  
  31.     LCD1602_DB = 0xFF;
  32.     LCD1602_RS = 0;
  33.     LCD1602_RW = 1;
  34.     do
  35.     {
  36.         LCD1602_E = 1;
  37.         sta = LCD1602_DB; //读取状态字
  38.         LCD1602_E = 0;
  39.     }
  40.     while (sta & 0x80);   //bit7等于1表示液晶正忙，重复检测直到其等于0为止
  41. }
  42. /* 向LCD1602液晶写入一字节命令，cmd-待写入命令值 */
  43. void  LcdWriteCmd(uint8 cmd)
  44. {
  45.     LedScanPause();
  46.     LcdWaitReady();
  47.     LCD1602_RS = 0;
  48.     LCD1602_RW = 0;
  49.     LCD1602_DB = cmd;
  50.     LCD1602_E  = 1;
  51.     LCD1602_E  = 0;
  52.     LedScanContinue();
  53. }
  54. /* 向LCD1602液晶写入一字节数据，dat-待写入数据值 */
  55. void  LcdWriteDat(uint8 dat)
  56. {
  57.     LedScanPause();
  58.     LcdWaitReady();
  59.     LCD1602_RS = 1;
  60.     LCD1602_RW = 0;
  61.     LCD1602_DB = dat;
  62.     LCD1602_E  = 1;
  63.     LCD1602_E  = 0;
  64.     LedScanContinue();
  65. }
  66. /* 清屏 */
  67. void LcdClearScreen()
  68. {
  69.     LcdWriteCmd(0x01);
  70. }
  71. /* 打开光标的闪烁效果 */
  72. void  LcdOpenCursor()
  73. {
  74.     LcdWriteCmd(0x0F);
  75. }
  76. /* 关闭光标显示 */
  77. void  LcdCloseCursor()
  78. {
  79.     LcdWriteCmd(0x0C);
  80. }
  81. /* 设置显示RAM起始地址，亦即光标位置，(x,y)-对应屏幕上的字符坐标 */
  82. void  LcdSetCursor(uint8 x, uint8 y)
  83. {
  84.     uint8 addr;
  85.  
  86.     if (y == 0)  //由输入的屏幕坐标计算显示RAM的地址
  87.     {
  88.         addr = 0x00 + x;    //第一行字符地址从0x00起始
  89.     }
  90.     else
  91.     {
  92.         addr = 0x40 + x;    //第二行字符地址从0x40起始
  93.     }
  94.     LcdWriteCmd(addr | 0x80);  //设置RAM地址
  95. }
  96. /* 在液晶上显示字符串，(x,y)-对应屏幕上的起始坐标，str-字符串指针 */
  97. void  LcdShowStr(uint8 x, uint8 y, uint8*str)
  98. {
  99.     LcdSetCursor(x, y);   //设置起始地址
  100.     while (*str != '\0')  //连续写入字符串数据，直到检测到结束符
  101.     {
  102.         LcdWriteDat(*str++);
  103.     }
  104. }
  105. /* 在液晶上显示一个字符，(x,y)-对应屏幕上的起始坐标，chr-字符ASCII码 */
  106. void  LcdShowChar(uint8 x, uint8 y, uint8chr)
  107. {
  108.     LcdSetCursor(x, y);  //设置起始地址
  109.     LcdWriteDat(chr);    //写入ASCII字符
  110. }
  111. /* 初始化1602液晶 */
  112. void  InitLcd1602()
  113. {
  114.     LcdWriteCmd(0x38);  //16*2显示，5*7点阵，8位数据接口
  115.     LcdWriteCmd(0x0C);  //显示器开，光标关闭
  116.     LcdWriteCmd(0x06);  //文字不动，地址自动+1
  117.     LcdWriteCmd(0x01);  //清屏
  118. }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

  1. // 实时时钟芯片DS1302驱动模块DS1302.c：
  2. #define  _DS1302_C
  3. #include "config.h"
  4. #include "DS1302.h"
  5.  
  6. /* 发送一个字节到DS1302通信总线上 */
  7. void DS1302ByteWrite(uint8 dat)
  8. {
  9.     uint8 mask;
  10.  
  11.     for (mask = 0x01; mask != 0; mask <<= 1) //低位在前，逐位移出
  12.     {
  13.         if ((mask & dat) != 0) //首先输出该位数据
  14.         {
  15.             DS1302_IO = 1;
  16.         }
  17.         else
  18.         {
  19.             DS1302_IO = 0;
  20.         }
  21.         DS1302_CK = 1;       //然后拉高时钟
  22.         DS1302_CK = 0;       //再拉低时钟，完成一个位的操作
  23.     }
  24.     DS1302_IO = 1;           //最后确保释放IO引脚
  25. }
  26. /* 由DS1302通信总线上读取一个字节 */
  27. uint8 DS1302ByteRead()
  28. {
  29.     uint8 mask;
  30.     uint8 dat = 0;
  31.  
  32.     for (mask = 0x01; mask != 0; mask <<= 1) //低位在前，逐位读取
  33.     {
  34.         if (DS1302_IO != 0)  //首先读取此时的IO引脚，并设置dat中的对应位
  35.         {
  36.             dat |= mask;
  37.         }
  38.         DS1302_CK = 1;       //然后拉高时钟
  39.         DS1302_CK = 0;       //再拉低时钟，完成一个位的操作
  40.     }
  41.     return dat;              //最后返回读到的字节数据
  42. }
  43. /* 用单次写操作向某一寄存器写入一个字节，reg-寄存器地址，dat-待写入字节 */
  44. void DS1302SingleWrite(uint8 reg, uint8dat)
  45. {
  46.     DS1302_CE = 1;                  //使能片选信号
  47.     DS1302ByteWrite((reg << 1) | 0x80); //发送写寄存器指令
  48.     DS1302ByteWrite(dat);           //写入字节数据
  49.     DS1302_CE = 0;                  //除能片选信号
  50. }
  51. /* 用单次读操作从某一寄存器读取一个字节，reg-寄存器地址，返回值-读到的字节 */
  52. uint8 DS1302SingleRead(uint8 reg)
  53. {
  54.     uint8 dat;
  55.  
  56.     DS1302_CE = 1;                  //使能片选信号
  57.     DS1302ByteWrite((reg << 1) | 0x81); //发送读寄存器指令
  58.     dat = DS1302ByteRead();         //读取字节数据
  59.     DS1302_CE = 0;                  //除能片选信号
  60.  
  61.     return dat;
  62. }
  63. /* 用突发模式连续写入8个寄存器数据，dat-待写入数据指针 */
  64. void DS1302BurstWrite(uint8 *dat)
  65. {
  66.     uint8 i;
  67.  
  68.     DS1302_CE = 1;
  69.     DS1302ByteWrite(0xBE);  //发送突发写寄存器指令
  70.     for (i = 0; i < 8; i++) //连续写入8字节数据
  71.     {
  72.         DS1302ByteWrite(dat[i]);
  73.     }
  74.     DS1302_CE = 0;
  75. }
  76. /* 用突发模式连续读取8个寄存器的数据，dat-读取数据的接收指针 */
  77. void DS1302BurstRead(uint8 *dat)
  78. {
  79.     uint8 i;
  80.  
  81.     DS1302_CE = 1;
  82.     DS1302ByteWrite(0xBF);  //发送突发读寄存器指令
  83.     for (i = 0; i < 8; i++) //连续读取8个字节
  84.     {
  85.         dat[i] = DS1302ByteRead();
  86.     }
  87.     DS1302_CE = 0;
  88. }
  89. /* 获取实时时间，即读取DS1302当前时间并转换为时间结构体格式 */
  90. void GetRealTime(struct sTime *time)
  91. {
  92.     uint8 buf[8];
  93.  
  94.     DS1302BurstRead(buf);
  95.     time->year = buf[6] + 0x2000;
  96.     time->mon  = buf[4];
  97.     time->day  = buf[3];
  98.     time->hour = buf[2];
  99.     time->min  = buf[1];
  100.     time->sec  = buf[0];
  101.     time->week = buf[5];
  102. }
  103. /* 设定实时时间，时间结构体格式的设定时间转换为数组并写入DS1302 */
  104. void SetRealTime(struct sTime *time)
  105. {
  106.     uint8 buf[8];
  107.  
  108.     buf[7] = 0;
  109.     buf[6] = time->year;
  110.     buf[5] = time->week;
  111.     buf[4] = time->mon;
  112.     buf[3] = time->day;
  113.     buf[2] = time->hour;
  114.     buf[1] = time->min;
  115.     buf[0] = time->sec;
  116.     DS1302BurstWrite(buf);
  117. }
  118. /* DS1302初始化，如发生掉电则重新设置初始时间 */
  119. void InitDS1302()
  120. {
  121.     uint8 dat;
  122.     struct sTime code InitTime[] =   //默认初始值：2014-01-0112:30:00 星期3
  123.     {
  124.         0x2014, 0x01, 0x01, 0x12, 0x30, 0x00, 0x03
  125.     };
  126.  
  127.     DS1302_CE = 0;  //初始化DS1302通信引脚
  128.     DS1302_CK = 0;
  129.     dat = DS1302SingleRead(0);  //读取秒寄存器
  130.     if ((dat & 0x80) != 0)      //由秒寄存器最高位CH的值判断DS1302是否已停止
  131.     {
  132.         DS1302SingleWrite(7, 0x00);  //撤销写保护以允许写入数据
  133.         SetRealTime(&InitTime);     //设置DS1302为默认的初始时间
  134.     }
  135. }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

  1. // 温度传感器DS18B20驱动模块DS18B20.c：DS18B20.cs
  2. #define  _DS18B20_C
  3. #include "config.h"
  4. #include "DS18B20.h"
  5.  
  6. /* 软件延时函数，延时时间(t*10)us */
  7. void DelayX10us(uint8 t)
  8. {
  9.     do
  10.     {
  11.         _nop_();
  12.         _nop_();
  13.         _nop_();
  14.         _nop_();
  15.         _nop_();
  16.         _nop_();
  17.         _nop_();
  18.         _nop_();
  19.     }
  20.     while (--t);
  21. }
  22. /* 复位总线，获取存在脉冲，以启动一次读写操作 */
  23. bit Get18B20Ack()
  24. {
  25.     bit ack;
  26.  
  27.     EA = 0;   //禁止总中断
  28.     IO_18B20 = 0;     //产生500us复位脉冲
  29.     DelayX10us(50);
  30.     IO_18B20 = 1;
  31.     DelayX10us(6);    //延时60us
  32.     ack = IO_18B20;   //读取存在脉冲
  33.     while(!IO_18B20); //等待存在脉冲结束
  34.     EA = 1;   //重新使能总中断
  35.  
  36.     return ack;
  37. }
  38. /* 向DS18B20写入一个字节，dat-待写入字节 */
  39. void Write18B20(uint8 dat)
  40. {
  41.     uint8 mask;
  42.  
  43.     EA = 0;   //禁止总中断
  44.     for (mask = 0x01; mask != 0; mask <<= 1) //低位在先，依次移出8个bit
  45.     {
  46.         IO_18B20 = 0;         //产生2us低电平脉冲
  47.         _nop_();
  48.         _nop_();
  49.         if ((mask & dat) == 0) //输出该bit值
  50.         {
  51.             IO_18B20 = 0;
  52.         }
  53.         else
  54.         {
  55.             IO_18B20 = 1;
  56.         }
  57.         DelayX10us(6);        //延时60us
  58.         IO_18B20 = 1;         //拉高通信引脚
  59.     }
  60.     EA = 1;   //重新使能总中断
  61. }
  62. /* 从DS18B20读取一个字节，返回值-读到的字节 */
  63. uint8 Read18B20()
  64. {
  65.     uint8 dat;
  66.     uint8 mask;
  67.  
  68.     EA = 0;   //禁止总中断
  69.     for (mask = 0x01; mask != 0; mask <<= 1) //低位在先，依次采集8个bit
  70.     {
  71.         IO_18B20 = 0;         //产生2us低电平脉冲
  72.         _nop_();
  73.         _nop_();
  74.         IO_18B20 = 1;         //结束低电平脉冲，等待18B20输出数据
  75.         _nop_();              //延时2us
  76.         _nop_();
  77.         if (!IO_18B20)        //读取通信引脚上的值
  78.         {
  79.             dat &= ~mask;
  80.         }
  81.         else
  82.         {
  83.             dat |= mask;
  84.         }
  85.         DelayX10us(6);        //再延时60us
  86.     }
  87.     EA = 1;   //重新使能总中断
  88.  
  89.     return dat;
  90. }
  91. /* 启动一次18B20温度转换，返回值-表示是否启动成功 */
  92. bit Start18B20()
  93. {
  94.     bit ack;
  95.  
  96.     ack = Get18B20Ack();   //执行总线复位，并获取18B20应答
  97.     if (ack == 0)          //如18B20正确应答，则启动一次转换
  98.     {
  99.         Write18B20(0xCC);  //跳过ROM操作
  100.         Write18B20(0x44);  //启动一次温度转换
  101.     }
  102.     return ~ack;   //ack==0表示操作成功，所以返回值对其取反
  103. }
  104. /* 读取DS18B20转换的温度值，返回值-表示是否读取成功 */
  105. bit Get18B20Temp(int16 *temp)
  106. {
  107.     bit ack;
  108.     uint8 LSB, MSB; //16bit温度值的低字节和高字节
  109.  
  110.     ack = Get18B20Ack();    //执行总线复位，并获取18B20应答
  111.     if (ack == 0)           //如18B20正确应答，则读取温度值
  112.     {
  113.         Write18B20(0xCC);   //跳过ROM操作
  114.         Write18B20(0xBE);   //发送读命令
  115.         LSB = Read18B20();  //读温度值的低字节
  116.         MSB = Read18B20();  //读温度值的高字节
  117.         *temp = ((int16)MSB << 8) + LSB; //合成为16bit整型数
  118.     }
  119.     return~ack;  //ack==0表示操作应答，所以返回值为其取反值
  120. }

  1. // 多功能电子钟主要功能文件Time.c：
  2. #define  _TIME_C
  3. #include "config.h"
  4. #include "DS1302.h"
  5. #include "LedBuzzer.h"
  6. #include "Lcd1602.h"
  7. #include "Time.h"
  8. #include "main.h"
  9.  
  10. uint8 code WeekMod[] =    //星期X字符图片表
  11. {
  12.     0xFF, 0x99, 0x00, 0x00, 0x00, 0x81, 0xC3, 0xE7,  //星期日(红心)
  13.     0xEF, 0xE7, 0xE3, 0xE7, 0xE7, 0xE7, 0xE7, 0xC3,  //星期1
  14.     0xC3, 0x81, 0x9D, 0x87, 0xC3, 0xF9, 0xC1, 0x81,  //星期2
  15.     0xC3, 0x81, 0x9D, 0xC7, 0xC7, 0x9D, 0x81, 0xC3,  //星期3
  16.     0xCF, 0xC7, 0xC3, 0xC9, 0xC9, 0x81, 0xCF, 0xCF,  //星期4
  17.     0x81, 0xC1, 0xF9, 0xC3, 0x87, 0x9D, 0x81, 0xC3,  //星期5
  18.     0xC3, 0x81, 0xF9, 0xC3, 0x81, 0x99, 0x81, 0xC3,  //星期6
  19. };
  20.  
  21. bit staMute = 0;  //静音标志位
  22. uint8 AlarmHour = 0x07;  //闹钟时间的小时数
  23. uint8 AlarmMin  = 0x30; //闹钟时间的分钟数
  24. struct sTime CurTime;    //当前日期时间
  25.  
  26. uint8 SetIndex = 0;  //设置位索引
  27. uint8 pdata SetAlarmHour;    //闹钟小时数设置缓冲
  28. uint8 pdata SetAlarmMin;     //闹钟分钟数设置缓冲
  29. struct sTime pdata SetTime;  //日期时间设置缓冲区
  30.  
  31. /* 获取当前日期时间，并刷新时间和星期的显示 */
  32. void RefreshTime()
  33. {
  34.     GetRealTime(&CurTime);                  //获取当前日期时间
  35.     ShowLedNumber(5, CurTime.hour >> 4, 0); //时
  36.     ShowLedNumber(4, CurTime.hour & 0xF, 1);
  37.     ShowLedNumber(3, CurTime.min >> 4, 0); //分
  38.     ShowLedNumber(2, CurTime.min & 0xF, 1);
  39.     ShowLedNumber(1, CurTime.sec >> 4, 0); //秒
  40.     ShowLedNumber(0, CurTime.sec & 0xF, 0);
  41.     ShowLedArray(WeekMod + CurTime.week * 8); //星期
  42. }
  43. /* 日期刷新函数，ops-刷新选项：为0时只当日期变化才刷新，非0则立即刷新 */
  44. void RefreshDate(uint8 ops)
  45. {
  46.     uint8 pdata str[12];
  47.     static uint8 backup = 0;
  48.  
  49.     if ((backup != CurTime.day) || (ops != 0))
  50.     {
  51.         str[0] = ((CurTime.year >> 12) & 0xF) + '0'; //4位数年份
  52.         str[1] = ((CurTime.year >> 8) & 0xF) + '0';
  53.         str[2] = ((CurTime.year >> 4) & 0xF) + '0';
  54.         str[3] = (CurTime.year & 0xF) + '0';
  55.         str[4] = '-';                       //分隔符
  56.         str[5] = (CurTime.mon >> 4) + '0';   //月份
  57.         str[6] = (CurTime.mon & 0xF) + '0';
  58.         str[7] = '-';                       //分隔符
  59.         str[8] = (CurTime.day >> 4) + '0';   //日期
  60.         str[9] = (CurTime.day & 0xF) + '0';
  61.         str[10] = '\0';         //字符串结束符
  62.         LcdShowStr(0, 0, str);  //显示到液晶上
  63.         backup = CurTime.day;   //刷新上次日期值
  64.     }
  65. }
  66. /* 刷新闹钟时间的显示 */
  67. void RefreshAlarm()
  68. {
  69.     uint8 pdata str[8];
  70.  
  71.     LcdShowStr(0, 1, "Alarm at ");     //显示提示标题
  72.     str[0] = (AlarmHour >> 4) + '0';  //闹钟小时数
  73.     str[1] = (AlarmHour & 0xF) + '0';
  74.     str[2] = ':';                      //分隔符
  75.     str[3] = (AlarmMin >> 4) + '0';   //闹钟分钟数
  76.     str[4] = (AlarmMin & 0xF) + '0';
  77.     str[5] = '\0';                    //字符串结束符
  78.     LcdShowStr(9, 1, str);            //显示到液晶上
  79. }
  80. /* 闹钟监控函数，抵达设定的闹钟时间时执行闹铃 */
  81. void AlarmMonitor()
  82. {
  83.     if ((CurTime.hour == AlarmHour) && (CurTime.min == AlarmMin)) //检查时间匹配
  84.     {
  85.         if (!staMute)  //检查是否静音
  86.         {
  87.             staBuzzer = ~staBuzzer;    //实现蜂鸣器断续鸣叫
  88.         }
  89.         else
  90.         {
  91.             staBuzzer = 0;
  92.         }
  93.     }
  94.     else
  95.     {
  96.         staMute = 0;
  97.         staBuzzer = 0;
  98.     }
  99. }
  100. /* 将设置时间及标题提示显示到液晶上 */
  101. void ShowSetTime()
  102. {
  103.     uint8 pdata str[18];
  104.  
  105.     str[0]  = ((SetTime.year >> 4) & 0xF) + '0'; //2位数年份
  106.     str[1]  = (SetTime.year & 0xF) + '0';
  107.     str[2]  = '-';
  108.     str[3]  = (SetTime.mon >> 4) + '0';  //月份
  109.     str[4]  = (SetTime.mon & 0xF) + '0';
  110.     str[5]  = '-';
  111.     str[6]  = (SetTime.day >> 4) + '0';  //日期
  112.     str[7]  = (SetTime.day & 0xF) + '0';
  113.     str[8]  = '-';
  114.     str[9]  = (SetTime.week & 0xF) + '0'; //星期
  115.     str[10] = ' ';
  116.     str[11] = (SetTime.hour >> 4) + '0';  //小时
  117.     str[12] = (SetTime.hour & 0xF) + '0';
  118.     str[13] = ':';
  119.     str[14] = (SetTime.min >> 4) + '0';   //分钟
  120.     str[15] = (SetTime.min & 0xF) + '0';
  121.     str[16] = '\0';
  122.     LcdShowStr(0, 0, "Set Date Time");  //显示提示标题
  123.     LcdShowStr(0, 1, str);             //显示设置时间值
  124. }
  125. /* 将设置闹钟及标题提示显示到液晶上 */
  126. void ShowSetAlarm()
  127. {
  128.     uint8 pdata str[8];
  129.  
  130.     str[0] = (SetAlarmHour >> 4) + '0';   //小时
  131.     str[1] = (SetAlarmHour & 0xF) + '0';
  132.     str[2] = ':';
  133.     str[3] = (SetAlarmMin >> 4) + '0';    //分钟
  134.     str[4] = (SetAlarmMin & 0xF) + '0';
  135.     str[5] = '\0';
  136.     LcdShowStr(0, 0, "Set Alarm"); //显示提示标题
  137.     LcdShowStr(0, 1, str);          //显示设定闹钟值
  138. }
  139. /* 取消当前设置，返回正常运行状态 */
  140. void CancelCurSet()
  141. {
  142.     staSystem = E_NORMAL;
  143.     LcdCloseCursor();  //关闭光标
  144.     LcdClearScreen();  //液晶清屏
  145.     RefreshTime();   //刷新当前时间
  146.     RefreshDate(1);  //立即刷新日期显示
  147.     RefreshTemp(1);  //立即刷新温度显示
  148.     RefreshAlarm();  //闹钟设定值显示
  149. }
  150. /* 时间或闹钟设置时，设置位右移一位，到头后折回 */
  151. void SetRightShift()
  152. {
  153.     if (staSystem == E_SET_TIME)
  154.     {
  155.         switch (SetIndex)
  156.         {
  157.         case 0:
  158.             SetIndex = 1;
  159.             LcdSetCursor(1, 1);
  160.             break;
  161.         case 1:
  162.             SetIndex = 2;
  163.             LcdSetCursor(3, 1);
  164.             break;
  165.         case 2:
  166.             SetIndex = 3;
  167.             LcdSetCursor(4, 1);
  168.             break;
  169.         case 3:
  170.             SetIndex = 4;
  171.             LcdSetCursor(6, 1);
  172.             break;
  173.         case 4:
  174.             SetIndex = 5;
  175.             LcdSetCursor(7, 1);
  176.             break;
  177.         case 5:
  178.             SetIndex = 6;
  179.             LcdSetCursor(9, 1);
  180.             break;
  181.         case 6:
  182.             SetIndex = 7;
  183.             LcdSetCursor(11, 1);
  184.             break;
  185.         case 7:
  186.             SetIndex = 8;
  187.             LcdSetCursor(12, 1);
  188.             break;
  189.         case 8:
  190.             SetIndex = 9;
  191.             LcdSetCursor(14, 1);
  192.             break;
  193.         case 9:
  194.             SetIndex = 10;
  195.             LcdSetCursor(15, 1);
  196.             break;
  197.         default:
  198.             SetIndex = 0;
  199.             LcdSetCursor(0, 1);
  200.             break;
  201.         }
  202.     }
  203.     else if (staSystem == E_SET_ALARM)
  204.     {
  205.         switch (SetIndex)
  206.         {
  207.         case 0:
  208.             SetIndex = 1;
  209.             LcdSetCursor(1, 1);
  210.             break;
  211.         case 1:
  212.             SetIndex = 2;
  213.             LcdSetCursor(3, 1);
  214.             break;
  215.         case 2:
  216.             SetIndex = 3;
  217.             LcdSetCursor(4, 1);
  218.             break;
  219.         default:
  220.             SetIndex = 0;
  221.             LcdSetCursor(0, 1);
  222.             break;
  223.         }
  224.     }
  225. }
  226. /* 时间或闹钟设置时，设置位左移一位，到头后折回 */
  227. void SetLeftShift()
  228. {
  229.     if (staSystem == E_SET_TIME)
  230.     {
  231.         switch (SetIndex)
  232.         {
  233.         case 0:
  234.             SetIndex = 10;
  235.             LcdSetCursor(15, 1);
  236.             break;
  237.         case 1:
  238.             SetIndex = 0;
  239.             LcdSetCursor(0, 1);
  240.             break;
  241.         case 2:
  242.             SetIndex = 1;
  243.             LcdSetCursor(1, 1);
  244.             break;
  245.         case 3:
  246.             SetIndex = 2;
  247.             LcdSetCursor(3, 1);
  248.             break;
  249.         case 4:
  250.             SetIndex = 3;
  251.             LcdSetCursor(4, 1);
  252.             break;
  253.         case 5:
  254.             SetIndex = 4;
  255.             LcdSetCursor(6, 1);
  256.             break;
  257.         case 6:
  258.             SetIndex = 5;
  259.             LcdSetCursor(7, 1);
  260.             break;
  261.         case 7:
  262.             SetIndex = 6;
  263.             LcdSetCursor(9, 1);
  264.             break;
  265.         case 8:
  266.             SetIndex = 7;
  267.             LcdSetCursor(11, 1);
  268.             break;
  269.         case 9:
  270.             SetIndex = 8;
  271.             LcdSetCursor(12, 1);
  272.             break;
  273.         default:
  274.             SetIndex = 9;
  275.             LcdSetCursor(14, 1);
  276.             break;
  277.         }
  278.     }
  279.     else if (staSystem == E_SET_ALARM)
  280.     {
  281.         switch (SetIndex)
  282.         {
  283.         case 0:
  284.             SetIndex = 3;
  285.             LcdSetCursor(4, 1);
  286.             break;
  287.         case 1:
  288.             SetIndex = 0;
  289.             LcdSetCursor(0, 1);
  290.             break;
  291.         case 2:
  292.             SetIndex = 1;
  293.             LcdSetCursor(1, 1);
  294.             break;
  295.         default:
  296.             SetIndex = 2;
  297.             LcdSetCursor(3, 1);
  298.             break;
  299.         }
  300.     }
  301. }
  302. /* 输入设置数字，修改对应的设置位，并显示该数字，ascii-输入数字的ASCII码 */
  303. void InputSetNumber(uint8 ascii)
  304. {
  305.     uint8 num;
  306.  
  307.     num = ascii - '0';
  308.     if (num <= 9)  //只响应0～9的数字
  309.     {
  310.         if (staSystem == E_SET_TIME)
  311.         {
  312.             switch (SetIndex)
  313.             {
  314.             case 0:
  315.                 SetTime.year = (SetTime.year & 0xFF0F) | (num << 4);
  316.                 LcdShowChar(0, 1, ascii);
  317.                 break;     //年份高位数字
  318.             case 1:
  319.                 SetTime.year = (SetTime.year & 0xFFF0) | (num);
  320.                 LcdShowChar(1, 1, ascii);
  321.                 break;      //年份低位数字
  322.             case 2:
  323.                 SetTime.mon = (SetTime.mon & 0x0F) | (num << 4);
  324.                 LcdShowChar(3, 1, ascii);
  325.                 break;      //月份高位数字
  326.             case 3:
  327.                 SetTime.mon = (SetTime.mon & 0xF0) | (num);
  328.                 LcdShowChar(4, 1, ascii);
  329.                 break;      //月份低位数字
  330.             case 4:
  331.                 SetTime.day = (SetTime.day & 0x0F) | (num << 4);
  332.                 LcdShowChar(6, 1, ascii);
  333.                 break;      //日期高位数字
  334.             case 5:
  335.                 SetTime.day = (SetTime.day & 0xF0) | (num);
  336.                 LcdShowChar(7, 1, ascii);
  337.                 break;      //日期低位数字
  338.             case 6:
  339.                 SetTime.week = (SetTime.week & 0xF0) | (num);
  340.                 LcdShowChar(9, 1, ascii);
  341.                 break;      //星期数字
  342.             case 7:
  343.                 SetTime.hour = (SetTime.hour & 0x0F) | (num << 4);
  344.                 LcdShowChar(11, 1, ascii);
  345.                 break;      //小时高位数字
  346.             case 8:
  347.                 SetTime.hour = (SetTime.hour & 0xF0) | (num);
  348.                 LcdShowChar(12, 1, ascii);
  349.                 break;      //小时低位数字
  350.             case 9:
  351.                 SetTime.min = (SetTime.min & 0x0F) | (num << 4);
  352.                 LcdShowChar(14, 1, ascii);
  353.                 break;      //分钟高位数字
  354.             default:
  355.                 SetTime.min = (SetTime.min & 0xF0) | (num);
  356.                 LcdShowChar(15, 1, ascii);
  357.                 break;      //分钟低位数字
  358.             }
  359.             SetRightShift();  //完成该位设置后自动右移
  360.         }
  361.         else if (staSystem == E_SET_ALARM)
  362.         {
  363.             switch (SetIndex)
  364.             {
  365.             case 0:
  366.                 SetAlarmHour = (SetAlarmHour & 0x0F) | (num << 4);
  367.                 LcdShowChar(0, 1, ascii);
  368.                 break;      //小时高位数字
  369.             case 1:
  370.                 SetAlarmHour = (SetAlarmHour & 0xF0) | (num);
  371.                 LcdShowChar(1, 1, ascii);
  372.                 break;      //小时低位数字
  373.             case 2:
  374.                 SetAlarmMin = (SetAlarmMin & 0x0F) | (num << 4);
  375.                 LcdShowChar(3, 1, ascii);
  376.                 break;      //分钟高位数字
  377.             default:
  378.                 SetAlarmMin = (SetAlarmMin & 0xF0) | (num);
  379.                 LcdShowChar(4, 1, ascii);
  380.                 break;      //分钟低位数字
  381.             }
  382.             SetRightShift();  //完成该位设置后自动右移
  383.         }
  384.     }
  385. }
  386. /* 切换系统运行状态 */
  387. void SwitchSystemSta()
  388. {
  389.     if (staSystem == E_NORMAL)  //正常运行切换到时间设置
  390.     {
  391.         staSystem = E_SET_TIME;
  392.         SetTime.year = CurTime.year;  //当前时间拷贝到时间设置缓冲区中
  393.         SetTime.mon  = CurTime.mon;
  394.         SetTime.day  = CurTime.day;
  395.         SetTime.hour = CurTime.hour;
  396.         SetTime.min  = CurTime.min;
  397.         SetTime.sec  = CurTime.sec;
  398.         SetTime.week = CurTime.week;
  399.         LcdClearScreen();  //液晶清屏
  400.         ShowSetTime();     //显示设置时间
  401.         SetIndex = 255;    //与接下来的右移一起将光标设在最左边的位置上
  402.         SetRightShift();
  403.         LcdOpenCursor();   //开启光标
  404.     }
  405.     else if (staSystem == E_SET_TIME)  //时间设置切换到闹钟设置
  406.     {
  407.         staSystem = E_SET_ALARM;
  408.         SetTime.sec = 0;          //秒清零，即当设置时间后从0秒开始走时
  409.         SetRealTime(&SetTime);    //设定时间写入实时时钟
  410.         SetAlarmHour = AlarmHour; //当前闹钟值拷贝到设置缓冲区
  411.         SetAlarmMin  = AlarmMin;
  412.         LcdClearScreen();  //液晶清屏
  413.         ShowSetAlarm();    //显示设置闹钟
  414.         SetIndex = 255;    //与接下来的右移一起将光标设在最左边的位置上
  415.         SetRightShift();
  416.     }
  417.     else  //闹钟设置切换会正常运行
  418.     {
  419.         staSystem = E_NORMAL;
  420.         AlarmHour = SetAlarmHour;  //设定的闹钟值写入闹钟时间
  421.         AlarmMin  = SetAlarmMin;
  422.         LcdCloseCursor();  //关闭光标
  423.         LcdClearScreen();  //液晶清屏
  424.         RefreshTime();   //刷新当前时间
  425.         RefreshDate(1);  //立即刷新日期显示
  426.         RefreshTemp(1);  //立即刷新温度显示
  427.         RefreshAlarm();  //闹钟设定值显示
  428.     }
  429. }
  430. /* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
  431. void KeyAction(uint8 keycode)
  432. {
  433.     if  ((keycode >= '0') && (keycode <= '9')) //数字键输入当前位设定值
  434.     {
  435.         InputSetNumber(keycode);
  436.     }
  437.     else if (keycode == 0x25)  //向左键，向左切换设置位
  438.     {
  439.         SetLeftShift();
  440.     }
  441.     else if (keycode == 0x27)  //向右键，向右切换设置位
  442.     {
  443.         SetRightShift();
  444.     }
  445.     else if (keycode == 0x0D)  //回车键，切换运行状态/保存设置
  446.     {
  447.         SwitchSystemSta();
  448.     }
  449.     else if (keycode == 0x1B)  //Esc键，静音/取消当前设置
  450.     {
  451.         if (staSystem == E_NORMAL) //处于正常运行状态时闹铃静音
  452.         {
  453.             staMute = 1;
  454.         }
  455.         else                       //处于设置状态时退出设置
  456.         {
  457.             CancelCurSet();
  458.         }
  459.     }
  460. }
  1. // 4*4矩阵按键驱动模块keyboard.c：
  2. #define  _KEY_BOARD_C
  3. #include "config.h"
  4. #include "keyboard.h"
  5. #include "Time.h"
  6.  
  7. const uint8 code KeyCodeMap[4][4] =   //矩阵按键到标准键码的映射表
  8. {
  9.     { '1',  '2',  '3', 0x26 }, //数字键1、数字键2、数字键3、向上键
  10.     { '4',  '5',  '6', 0x25 }, //数字键4、数字键5、数字键6、向左键
  11.     { '7',  '8',  '9', 0x28 }, //数字键7、数字键8、数字键9、向下键
  12.     { '0', 0x1B, 0x0D, 0x27 }   //数字键0、ESC键、  回车键、 向右键
  13. };
  14. uint8 pdata KeySta[4][4] =    //全部矩阵按键的当前状态
  15. {
  16.     {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}, {1, 1, 1, 1}
  17. };
  18.  
  19. /* 按键驱动函数，检测按键动作，调度相应动作函数，需在主循环中调用 */
  20. void KeyDriver()
  21. {
  22.     uint8 i, j;
  23.     static uint8 pdata backup[4][4] =   //按键值备份，保存前一次的值
  24.     {
  25.         {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}, {1, 1, 1, 1}
  26.     };
  27.  
  28.     for (i = 0; i < 4; i++) //循环检测4*4的矩阵按键
  29.     {
  30.         for (j = 0; j < 4; j++)
  31.         {
  32.             if (backup[i][j] != KeySta[i][j])   //检测按键动作
  33.             {
  34.                 if (backup[i][j] != 0)           //按键按下时执行动作
  35.                 {
  36.                     KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
  37.                 }
  38.                 backup[i][j] = KeySta[i][j];    //刷新前一次的备份值
  39.             }
  40.         }
  41.     }
  42. }
  43. /* 按键扫描函数，需在定时中断中调用，推荐调用间隔1ms */
  44. void KeyScan()
  45. {
  46.     uint8 i;
  47.     static uint8 keyout = 0;   //矩阵按键扫描输出索引
  48.     static uint8 keybuf[4][4] =    //矩阵按键扫描缓冲区
  49.     {
  50.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
  51.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
  52.     };
  53.  
  54.     //将一行的4个按键值移入缓冲区
  55.     keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
  56.     keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
  57.     keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
  58.     keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
  59.     //消抖后更新按键状态
  60.     for (i = 0; i < 4; i++) //每行4个按键，所以循环4次
  61.     {
  62.         if ((keybuf[keyout][i] & 0x0F) == 0x00)
  63.         {
  64.             //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
  65.             KeySta[keyout][i] = 0;
  66.         }
  67.         else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
  68.         {
  69.             //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
  70.             KeySta[keyout][i] = 1;
  71.         }
  72.     }
  73.     //执行下一次的扫描输出
  74.     keyout++;        //输出索引递增
  75.     keyout &= 0x03;  //索引值加到4即归零
  76.     switch (keyout)  //根据索引值，释放当前输出引脚，拉低下次的输出引脚
  77.     {
  78.     case 0:
  79.         KEY_OUT_4 = 1;
  80.         KEY_OUT_1 = 0;
  81.         break;
  82.     case 1:
  83.         KEY_OUT_1 = 1;
  84.         KEY_OUT_2 = 0;
  85.         break;
  86.     case 2:
  87.         KEY_OUT_2 = 1;
  88.         KEY_OUT_3 = 0;
  89.         break;
  90.     case 3:
  91.         KEY_OUT_3 = 1;
  92.         KEY_OUT_4 = 0;
  93.         break;
  94.     default:
  95.         break;
  96.     }
  97. }
  1. // 点阵LED、数码管、独立LED和无源蜂鸣器的驱动模块LedBuzzer.c：
  2. #define  _LED_BUZZER_C
  3. #include "config.h"
  4. #include "LedBuzzer.h"
  5.  
  6. uint8 code LedChar[] =    //数码管显示字符转换表
  7. {
  8.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  9.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  10. };
  11.  
  12. bit staBuzzer = 0; //蜂鸣器状态控制位，1-鸣叫、0-关闭
  13. struct sLedBuff ledBuff; //LED显示缓冲区，默认初值全0，正好达到上电全亮的效果
  14.  
  15. /* LED初始化函数，初始化IO、配置定时器 */
  16. void InitLed()
  17. {
  18.     //初始化IO口
  19.     P0 = 0xFF;
  20.     ENLED = 0;
  21.     //配置T2作为动态扫描定时
  22.     T2CON = 0x00;  //配置T2工作在16位自动重载定时器模式
  23.     RCAP2H = ((65536 - SYS_MCLK / 1500) >> 8); //配置重载值，每秒产生1500次中断，
  24.     RCAP2L = (65536 - SYS_MCLK / 1500);  //以使刷新率达到100Hz无闪烁的效果
  25.     TH2 = RCAP2H;  //设置初值等于重载值
  26.     TL2 = RCAP2L;
  27.     ET2 = 1;       //使能T2中断
  28.     PT2 = 1;       //设置T2中断为高优先级
  29.     TR2 = 1;       //启动T2
  30. }
  31. /* 流水灯实现函数，间隔调用实现流动效果 */
  32. void FlowingLight()
  33. {
  34.     static uint8 i = 0;
  35.     const uint8 code tab[] =    //流动表
  36.     {
  37.         0x7F, 0x3F, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF
  38.     };
  39.  
  40.     ledBuff.alone = tab[i];   //表中对应值送到独立LED的显示缓冲区
  41.     if (i < (sizeof(tab) - 1)) //索引递增循环，遍历整个流动表
  42.     {
  43.         i++;
  44.     }
  45.     else
  46.     {
  47.         i = 0;
  48.     }
  49. }
  50. /* 数码管上显示一位数字，index-数码管位索引(从右到左对应0～5)，
  51. **    num-待显示的数字，point-代表是否显示此位上的小数点 */
  52. void ShowLedNumber(uint8 index, uint8num, uint8 point)
  53. {
  54.     ledBuff.number[index] = LedChar[num]; //输入数字转换为数码管字符0～F
  55.     if (point != 0)
  56.     {
  57.         ledBuff.number[index] &= 0x7F; //point不为0时点亮当前位的小数点
  58.     }
  59. }
  60. /* 点阵上显示一帧图片，ptr-待显示图片指针 */
  61. void ShowLedArray(uint8 *ptr)
  62. {
  63.     uint8 i;
  64.  
  65.     for (i = 0; i < sizeof(ledBuff.array); i++)
  66.     {
  67.         ledBuff.array[i] = *ptr++;
  68.     }
  69. }
  70. /* T2中断服务函数，LED动态扫描、蜂鸣器控制 */
  71. void InterruptTimer2() interrupt 5
  72. {
  73.     static uint8 i = 0;  //LED位选索引
  74.  
  75.     TF2 = 0;  //清零T2中断标志
  76.     //全部LED动态扫描显示
  77.     if (ENLED == 0)  //LED使能时才进行动态扫描
  78.     {
  79.         P0 = 0xFF;                      //关闭所有段选位，显示消隐
  80.         P1 = (P1 & 0xF0) | i;           //位选索引值赋值到P1口低4位
  81.         P0 = *((uint8 data*)&ledBuff + i); //缓冲区中索引位置的数据送到P0口
  82.         if (i < (sizeof(ledBuff) - 1))  //索引递增循环，遍历整个缓冲区
  83.         {
  84.             i++;
  85.         }
  86.         else
  87.         {
  88.             i = 0;
  89.         }
  90.     }
  91.     //由蜂鸣器状态位控制蜂鸣器
  92.     if (staBuzzer == 1)
  93.     {
  94.         BUZZER = ~BUZZER;    //蜂鸣器鸣叫
  95.     }
  96.     else
  97.     { BUZZER = 1; }        //蜂鸣器静音
  98. }

  1. // 多功能电子钟工程主文件main.c：
  2. #define  _MAIN_C
  3. #include "config.h"
  4. #include "Lcd1602.h"
  5. #include "LedBuzzer.h"
  6. #include "keyboard.h"
  7. #include "DS1302.h"
  8. #include "DS18B20.h"
  9. #include "Infrared.h"
  10. #include "Time.h"
  11. #include "main.h"
  12.  
  13. bit flag2s = 0;    //2s定时标志位
  14. bit flag200ms = 0; //200ms定时标志
  15. uint8 T0RH = 0;    //T0重载值的高字节
  16. uint8 T0RL = 0;    //T0重载值的低字节
  17. enum eStaSystem staSystem = E_NORMAL;  //系统运行状态
  18.  
  19. void main()
  20. {
  21.     EA = 1;           //开总中断
  22.     ConfigTimer0(1);  //配置T0定时1ms
  23.     InitLed();        //初始化LED模块
  24.     InitDS1302();     //初始化实时时钟模块
  25.     InitLcd1602();    //初始化液晶模块
  26.     Start18B20();     //启动首次温度转换
  27.  
  28.     while (!flag2s);  //上电后延时2秒
  29.     flag2s = 0;
  30.     RefreshTime();    //刷新当前时间
  31.     RefreshDate(1);   //立即刷新日期显示
  32.     RefreshTemp(1);   //立即刷新温度显示
  33.     RefreshAlarm();   //闹钟设定值显示
  34.  
  35.     while (1)  //进入主循环
  36.     {
  37.         KeyDriver();      //执行按键驱动
  38.         if (flag200ms)    //每隔200ms执行以下分支
  39.         {
  40.             flag200ms = 0;
  41.             FlowingLight();  //流水灯效果实现
  42.             RefreshTime();   //刷新当前时间
  43.             AlarmMonitor();  //监控闹钟
  44.             if (staSystem == E_NORMAL)  //正常运行时刷新日期显示
  45.             {
  46.                 RefreshDate(0);
  47.             }
  48.         }
  49.         if (flag2s)  //每隔2s执行以下分支
  50.         {
  51.             flag2s = 0;
  52.             if (staSystem == E_NORMAL)  //正常运行时刷新温度显示
  53.             {
  54.                 RefreshTemp(0);
  55.             }
  56.         }
  57.     }
  58. }
  59. /* 温度刷新函数，读取当前温度并根据需要刷新液晶显示，
  60. ** ops-刷新选项：为0时只当温度变化才刷新，非0则立即刷新 */
  61. void RefreshTemp(uint8 ops)
  62. {
  63.     int16 temp;
  64.     uint8 pdata str[8];
  65.     static int16 backup = 0;
  66.  
  67.     Get18B20Temp(&temp); //获取当前温度值
  68.     Start18B20();        //启动下一次转换
  69.     temp >>= 4;          //舍弃4bit小数位
  70.     if ((backup != temp) || (ops != 0)) //按需要刷新液晶显示
  71.     {
  72.         str[0] = (temp / 10) + '0'; //十位转为ASCII码
  73.         str[1] = (temp % 10) + '0'; //个位转为ASCII码
  74.         str[2] = '\'';             //用'C代替℃
  75.         str[3] = 'C';
  76.         str[4] = '\0';             //字符串结束符
  77.         LcdShowStr(12, 0, str);    //显示到液晶上
  78.         backup = temp;             //刷新上次温度值
  79.     }
  80. }
  81. /* 配置并启动T0，ms-T0定时时间 */
  82. void ConfigTimer0(uint16 ms)
  83. {
  84.     uint32 tmp;
  85.  
  86.     tmp = (SYS_MCLK * ms) / 1000; //计算所需的计数值
  87.     tmp = 65536 - tmp;        //计算定时器重载值
  88.     tmp = tmp + 33;           //补偿中断响应延时造成的误差
  89.     T0RH = (uint8)(tmp >> 8); //定时器重载值拆分为高低字节
  90.     T0RL = (uint8)tmp;
  91.     TMOD &= 0xF0;   //清零T0的控制位
  92.     TMOD |= 0x01;   //配置T0为模式1
  93.     TH0 = T0RH;     //加载T0重载值
  94.     TL0 = T0RL;
  95.     ET0 = 1;        //使能T0中断
  96.     TR0 = 1;        //启动T0
  97. }
  98. /* T0中断服务函数，实现系统定时和按键扫描 */
  99. void InterruptTimer0() interrupt 1
  100. {
  101.     static uint8 tmr2s = 0;
  102.     static uint8 tmr200ms = 0;
  103.  
  104.     TH0 = T0RH;  //重新加载重载值
  105.     TL0 = T0RL;
  106.     tmr200ms++;  //定时200ms
  107.     if (tmr200ms >= 200)
  108.     {
  109.         tmr200ms = 0;
  110.         flag200ms = 1;
  111.         tmr2s++;  //定时2s
  112.         if (tmr2s >= 10)
  113.         {
  114.             tmr2s = 0;
  115.             flag2s = 1;
  116.         }
  117.     }
  118.     KeyScan();   //执行按键扫描
  119. }


声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/408630
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号