标题: 单片机12864时钟制作资料下载 代码注释详细 [打印本页]
作者: liuzhen18    时间: 2017-5-28 00:57
标题: 单片机12864时钟制作资料下载 代码注释详细
12864时钟资料包（附件中可下载完整版的代码 而且注释非常详细）：


单片机源程序如下:
  1. #include         "Initial.h"
  2. #include         "ds1302.h"
  3. #include         "12864.h"
  4. #include        "IC.h"
  5. #include        "HongWai.h"
  6. #include        "Alarm.h"

  8. /**********************************************************
  9.         函数名：         Initial()
  10.         函数功能：        用于单片机开机后的第一次初始化
  11.         入口参数：无
  12.         出口参数：无
  13. **********************************************************/



  17. void Initial()
  18. {
  19.         Initial_12864();                                 //12864的初始化
  20.         Write_12864_DS1302_Constant();         //写12864的固定部分
  21.        
  22.         g_Alarm_min  = Read_Add_24c02(1); //首次从24C02中读取数据 闹钟的时分
  23.         g_Alarm_hour = Read_Add_24c02(2);

  25.         Initial_IIC();                                         //24c02的初始化
  26.                   
  27.     Initial_HW_Time();                                 //初始化红外的定时器
  28.        
  29.         g_Alarm_Flag1             = 0;
  30.         g_Alarm_Flag2            = 0;
  31.         g_HongWai_Work_Flag = 0;
  32.         g_Uart_Work_Flag    = 0;
  33. ……………………

  35. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

红外遥控部分：
  1. /***************************************************************
  2.         文件说明：本文件主要处理红外因定时器与串口有重合
  3.                           的部分，故定时器0中采用判断与标志位处理
  4.                           在调用本模块时只需修改  Ir_work(void)
  5.                           并在主函数中调用        IRR_Work()以便让整个C文件工作
  6. **************************************************************/

  8. #include                 "HongWai.h"
  9. #include                "Control.h"
  10. #include                "ds1302.h"
  11. #include                "12864.h"
  12. #include                "Initial.h"
  13. #include                "Uart.h"
  14. #include                "Alarm.h"

  16. bit                                g_HongWai_Work_Flag;        //红外是否工作标志位的标志位
  17. uchar                        T0_Count;                                //T0的计数变量主要用于在串口工作时统计5s的时间
  18. /**********************************************
  19.         以下是红外的变量
  20. ***********************************************/
  21. uchar                          irtime;               
  22. bit                         irpro_ok,irok;
  23. uchar                         IRcord[4];
  24. uchar                         irdata[33];
  25. /*********************************************
  26.         函数名：        Initial_HW_Time()
  27.         函数功能：        初始化红外的定时器
  28.         入口参数：  无
  29.         出口参数：  无
  30.         备    注：
  31. *********************************************/

  33. void        Initial_HW_Time()               
  34. {
  35.     /*  因与显示的频率有一定的冲突故将备份如下
  36.         TMOD = 0x12;                                //定时器0工作方式2，TH0是重装值，TL0是初值
  37.         TH0  = 0x00;                                 //重载值
  38.         TL0  = 0x00;                                 //初始化值
  39.         ET0  = 1;                                    //开中断
  40.         TR0  = 1;                                   //开定时器0
  41.         IT0  = 1;                                   //指定外部中断0下降沿触发，INT0 (P3.2)
  42.     EX0  = 1;                                   //使能外部中断
  43.     TH1  = 0x3c;                //50ms  12MHZ晶振
  44.     TL1  = 0xB0;
  45.     ET1  = 1;                   //使能T1
  46.     TR1  = 1;
  47.     EA   = 1;                                    //开总中断
  48.     ***************************************/
  49.     TMOD = 0x02;                                //定时器0工作方式2，TH0是重装值，TL0是初值
  50.         TH0  = 0x00;                                 //重载值
  51.         TL0  = 0x00;                                 //初始化值
  52.         ET0  = 1;                                    //开中断
  53.         TR0  = 1;                                   //开定时器0
  54.         IT0  = 1;                                   //指定外部中断0下降沿触发，INT0 (P3.2)
  55.     EX0  = 1;                                   //使能外部中断
  56.     EA   = 1;                                    //开总中断
  57. }

  59. /*********************************************
  60.         函数名:         T0_Time(void) interrupt 1
  61.         函数功能：        定时器0中断处理
  62.         入口参数;   无
  63.         出口参数：  无
  64.         备    注：  因定时器处理与串口重叠
  65.                                 本函数利用标志位g_Uart_Work_Flag
  66.                                 把两者分开
  67. *********************************************/
  68. void         T0_Time (void) interrupt 1 using 1
  69. {
  70.         static Count_5S = 0;
  71.         if(g_Uart_Work_Flag == 0)        //如果没有串口工作则计红外的时间
  72.         {
  73.                 irtime++;          //用于计数2个下降沿之间的时间
  74.         }
  75.         else                                        //否则统计5s的时间
  76.         {
  77.                 TH0 = 0x3c;                        //定时50ms 12M晶振
  78.                 TL0 = 0xB0;
  79.                 T0_Count ++;
  80.                 if(T0_Count >= 20)
  81.                 {
  82.                         T0_Count = 0;
  83.                         g_Run_Time_Uart_Flag = 1;
  84.                         Count_5S ++;
  85.                         if(Count_5S >= 5)
  86.                         {
  87.                                 Count_5S = 0;
  88.                                 g_Send_Uart_Flag = 1;
  89.                         }
  90.                 }
  91.         }
  92. }
  93. /*******************************************
  94.         函数名：        EX0_Ser(void) interrupt 0
  95.         函数功能：        外部中断0服务函数
  96.         入口参数：  无
  97.         出口参数：  无
  98. ********************************************/
  99. void         EX0_Ser(void) interrupt 0                
  100. {
  101.         static unsigned char  i;             //接收红外信号处理
  102.         static bit startflag;                //是否开始处理标志位

  104.         if(startflag)                        
  105.         {
  106.                 if(irtime < 65 &&irtime >= 33 )//引导码 TC9012的头码，9ms+4.5ms
  107.                 {
  108.                         i = 0;
  109.                 }
  110.                 irdata[i] = irtime;//存储每个电平的持续时间，用于以后判断是0还是1
  111.                 irtime = 0;
  112.                 i++;
  113.                 if(i == 33)
  114.                 {
  115.                         irok = 1;
  116.                         i = 0;
  117.                 }
  118.         }
  119.         else
  120.         {
  121.                 irtime = 0;
  122.                 startflag = 1;
  123.         }

  125. }


  128. /****************************************************
  129.         函数名：        Ir_work(void)
  130.         函数功能：        兼键值处理函数
  131.         入口参数：  无
  132.         出口参数：  无
  133.         备    注：        本函数主要用于处理按下遥控后的处理
  134.                                 处理操作标志位，是本文件中很核心的一个函数
  135. *****************************************************/
  136. void        Ir_work(void)                                               
  137. {
  138.         switch(IRcord[2])                                        //判断第三个数码值
  139.         {
  140.             case 0x0c:                                                //1 功能位置增加 显示相应的按键值                                       
  141.                 {
  142.                         g_HongWai_Work_Flag = !g_HongWai_Work_Flag;//对红外的标志位进行取反
  143.                         g_Alarm_Flag1 = 0;                                                        //对闹钟的两个标志位清零，让程序稳定
  144.                         g_Alarm_Flag2 = 0;
  145.             g_Turn_Poem_Flag = 0;
  146.                         Initial_12864();                        //12864的初始化
  147.                         if(g_HongWai_Work_Flag == 0)
  148.                         {
  149.                                 Write_12864_DS1302_Constant();        //写12864的固定部分
  150.                         }
  151.                 }
  152.         /**********************************************************
  153.                     case 0x18:        DataPort = table[1];        break;//2
  154.             case 0x5e:        DataPort = table[2];        break;//3
  155.             case 0x08:        DataPort = table[3];        break;//4
  156.             case 0x1c:        DataPort = table[4];        break;//5
  157.             case 0x5a:        DataPort = table[5];        break;//6
  158.             case 0x42:        DataPort = table[6];        break;//7
  159.             case 0x52:        DataPort = table[7];        break;//8
  160.             case 0x4a:        DataPort = table[8];        break;//9
  161.                 case 0x0d:  DataPort = table[9];    break;//200++
  162.                 case 0x09:  DataPort = table[0];        break;//EQ 显示相应的按键值
  163.                 case 0x45:  DataPort = 0x00;        break;//CH-
  164.                 case 0x46:  DataPort = 0xff;        break;//CH
  165.                 case 0x47:  DataPort = 0x00;        break;//CH+
  166.                 case 0x44:  DataPort = 0xff;        break;//后退
  167.                 case 0x40:  DataPort = 0x00;        break;//前进
  168.                 case 0x43:  DataPort = 0x02;        break;//暂停
  169.                 case 0x07:  DataPort = 0x00;        break;//-
  170.                 case 0x15:  DataPort = 0xff;        break;//+
  171.                 case 0x16:  DataPort = 0xff;        break;//0
  172.                 case 0x19:  DataPort = 0xf0;        break;//100+
  173.             default:        break;
  174.         **************************************************************/
  175.         }
  176.    irpro_ok = 0;        //处理完成标志
  177.        
  178. }
  179. /***************************************************
  180.         函数名：        Ircordpro(void)
  181.         函数功能：        红外码值处理函数 红外码值处理
  182.         入口参数：  无
  183.         出口参数：  无
  184.     备  注  ：
  185. ****************************************************/   
  186. void        Ircordpro(void)
  187. {
  188.         uchar i, j, k;
  189.         uchar cord,value;

  191.         k = 1;
  192.         for(i = 0;i < 4;i++)      //处理4个字节
  193.         {
  194.                 for(j = 1;j <= 8;j++) //处理1个字节8位
  195.                 {
  196.                         cord = irdata[k];
  197.                         if(cord>7)//大于某值为1，这个和晶振有绝对关系，这里使用12M计算，此值可以有一定误差
  198.                         {
  199.                                 value |= 0x80;
  200.                         }
  201.                         if(j<8)
  202.                         {
  203.                                 value >>= 1;
  204.                         }
  205.                                 k++;
  206.                 }
  207.                 IRcord[i] = value;
  208.             value = 0;     
  209.         }
  210.         irpro_ok = 1;        //处理完毕标志位置1
  211. }
  212. /******************************************************
  213.         函数名：        IRR_Work(void)
  214.         函数功能：  调用整个c文件        以便让整个文件函数工作
  215.         入口参数：  无
  216.     出口参数：  无
  217.     备    注：
  218. ******************************************************/
  219. void        IRR_Work()
  220. ……………………

  222. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

串口：
  1. /***********************************************************
  2.                 本文件主要用来写串口通信
  3.                 注：统计5s时间的函数写在红外里面了
  4.             若调用本文件的定时器  定期写在最后 在工程中我把
  5.             定时器屏蔽掉
  6. ***********************************************************/
  7. #include        "Uart.h"
  8. #include        "ds1302.h"
  9. #include        "HongWai.h"
  10. #include        "12864.h"
  11. #include        "Alarm.h"

  13. bit                        g_Recieve_Flag;
  14. bit                        g_Run_Time_Uart_Flag;        //串口调试的时候时间走动的时候标志位
  15. bit                        g_Send_Uart_Flag;                //串口发送给电脑的标志位

  17. uchar                Recieve_Time_Data;                //接受的时间数据
  18. uchar                g_Num_Uart;                                //统计串口接收的次数
  19. /*********************************************************
  20.         函数名: Initial_Uart()
  21.         函数功能：初始化串口
  22.         入口参数：无
  23.         出口参数：无
  24.         备    注: 12M晶振 600bps
  25. *********************************************************/
  26. void                Initial_Uart()        //初始化串口
  27. {
  28.         TMOD = 0x21;                                //串行口通信时要把定时器打开，设置定时器工作方式
  29.         TH0  = (65536 - 45872) / 256;//装初值
  30.         TL0  = (65536 - 45872) % 256;
  31.         TH1  = 0xcc;                                 //自动重装波特率为600bps 12M晶振
  32.         TL1  = 0x98;
  33.         TR1  = 1;                                        //打开定时器1

  35.         ET0  = 1;                                        //
  36.         SM0  = 0;                                        //设置串行口工作方式1，要与TMOD相对应
  37.         SM1  = 1;
  38.         EA   = 1;                                        //打开总中断
  39.         ES   = 1;                                        //打开串行口中断
  40.         REN  = 1;                                        //允许串行口接受，当TMOD = 0x21时要在设置好SM0,SM1后再写
  41. }
  42. /****************************************************************
  43.         函数名称：        Ser_Uart()
  44.         函数功能：        主要用于串口的中断服务       
  45.         入口参数：        无
  46.         出口参数：        无
  47.         备          注：        进入计算机通信中断后设定标志位
  48. *****************************************************************/
  49. void        Ser_Uart()                interrupt 4
  50. {        
  51.         RI          = 0;
  52.         Recieve_Time_Data    = SBUF;                //把接收的数据给时间标志位
  53.            
  54.     if(Recieve_Time_Data == 'r')
  55.     {
  56.         g_Num_Uart = 0;
  57.     }
  58.         else
  59.     {
  60.         Recieve_Time_Data   = Recieve_Time_Data - '0';
  61.         g_Num_Uart ++;

  63.     }
  64.         g_Recieve_Flag = 1;                                //串口服务的标志主要用于接收
  65.        
  66. }

  68. /***********************************************************
  69.         函数名称：        Uart_Process()
  70.         函数功能：        串口处理
  71.         入口参数：        无
  72.         出口参数：        无
  73.         备    注：        本函数主要通过处理g_Recieve_Flag  g_Send_Uart_Flag
  74.                                 g_Run_Time_Uart_Flag来达到执行相应函数的目的
  75. ***********************************************************/
  76. void                Uart_Process()
  77. {
  78.         if(g_Recieve_Flag        ==  1)                        //如果出现标志位置1 则进行接收的处理
  79.         {
  80.                 g_Recieve_Flag = 0;
  81.                 ES                           = 0;
  82.                 TI                           = 1;
  83.                
  84.                 switch(g_Num_Uart)                                                //通过判断串口发送的次数来进行相应的处理
  85.                 {
  86.                         case 1:                break;
  87.                         case 2:                break;
  88.                         case 3:                g_year  = Recieve_Time_Data * 10;                break;
  89.                         case 4:                g_year  = Recieve_Time_Data + g_year;        break;                               
  90.                         case 5:                g_month = Recieve_Time_Data * 10;                break;               
  91.                         case 6:                g_month = Recieve_Time_Data + g_month;        break;                                                                               
  92.                         case 7:                g_date  = Recieve_Time_Data * 10;                break;       
  93.                         case 8:                g_date  = Recieve_Time_Data + g_date;        break;
  94.                         case 9:                g_hour  = Recieve_Time_Data * 10;                break;
  95.                         case 10:        g_hour  = Recieve_Time_Data + g_hour;        break;
  96.                         case 11:        g_min   = Recieve_Time_Data * 10;                break;
  97.                         case 12:        g_min   = Recieve_Time_Data + g_min;        break;
  98.                         case 13:        g_sec   = Recieve_Time_Data * 10;                break;
  99.                         case 14:                                                        //对数据进行最后一次处理并退出串口中断服务
  100.                                         {
  101.                                                 g_sec = Recieve_Time_Data  + g_sec;
  102.                                                 Write_sfm(6,g_sec);                        //把调节的数据写在液晶屏上
  103.                                                 Locate_pos(2,2);                        //显示位置重新回到调节处
  104.                                
  105.                                                 g_Num_Uart         = 0;
  106.                                                 g_Uart_Work_Flag   = 0;                        //串口工作的标志位清零退出串口工作
  107.                         g_Set_DS1302_Num  = 0;
  108.                                                 Write_1302_Date   ();                        //把数据写进DS1302
  109.                                                 Write_12864_DS1302_Constant();        //把显示DS1302时间的固定部分写在液晶上
  110.                                                 Initial_HW_Time   ();                          //初始化红外的定时器
  111.                                                 break;
  112.                                         }
  113.                         default:                                                        //为了让程序稳定        对一些标志位继续处理       
  114.                                         {
  115.                                                 g_Num_Uart         = 0;
  116.                                                 g_Uart_Work_Flag   = 0;                //串口工作的标志位清零退出串口工作
  117.                         g_Set_DS1302_Num   = 0;
  118.                                                 Write_1302_Date   ();                        //把数据写进DS1302
  119.                                                 Write_12864_DS1302_Constant();        //把显示DS1302时间的固定部分写在液晶上
  120.                                                 Initial_HW_Time   ();                          //初始化红外的定时器

  122.                                         }
  123.                        
  124.                 }
  125.        
  126.                 if(g_Num_Uart >= 15)                                        //增加程序的稳定性                       
  127.                 {
  128.                         g_Num_Uart = 0;
  129.                 }

  131.                 while(!TI);
  132.                 TI = 0;
  133.                 ES = 1;
  134.         }
  135.        
  136.         if(g_Send_Uart_Flag      ==  1)                        //进行发送给电脑数据的处理        发送后DS1302便会更改
  137.         {
  138.                 g_Send_Uart_Flag = 0;
  139.                 ES                  = 0;
  140.                 TI                  = 1;
  141.                 printf("\n\n\n                              现在时间是\n");
  142.                 printf("\n                     20%c%c年%c%c月%c%c日        %c%c时%c%c分%c%c秒\n",
  143.                                         g_year  / 10 + '0', g_year  % 10 + '0',
  144.                                         g_month / 10 + '0', g_month % 10 + '0',
  145.                                         g_date  / 10 + '0', g_date  % 10 + '0',
  146.                                         g_hour  / 10 + '0', g_hour  % 10 + '0',
  147.                                         g_min   / 10 + '0', g_min   % 10 + '0',
  148.                                         g_sec   / 10 + '0', g_sec   % 10 + '0');
  149.                
  150.                 while(!TI);
  151.                 TI                  = 0;
  152.                 ES                  = 1;
  153.         }
  154.        
  155.         if(g_Run_Time_Uart_Flag  ==  1)                        //到达一秒的时间对DS1302的时间进行读取更新
  156.         {
  157.                 g_Run_Time_Uart_Flag = 0;
  158.                 Read_All_DS1302_Date();                                //读取DS1302的所有数据
  159.                 Display_DS1302_Time();                                //把读取的数据显示在液晶上
  160.         }


  163. }

  165. /*******************************************************

  167.     函数名：    T0_Time (void) interrupt 1 using 1
  168.     函数功能：  定时器0的中断处理
  169.     入口参数：  无
  170.     出口参数：  无
  171. void         T0_Time (void) interrupt 1 using 1
  172. ……………………

  174. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
  1. /*******************************************************
  2.         文件说明：本文件主要用来写DS1302与闹铃相应
  3.                           的按键按下之后对相应的数值进行处理的函数
  4. ********************************************************/


  7. #include        "Control.h"
  8. #include        "Delay.h"
  9. #include        "ds1302.h"
  10. #include        "12864.h"
  11. #include        "IC.h"
  12. #include        "Alarm.h"


  15. /**************************************************
  16.         函数名：   Di()
  17.         函数功能： 制造蜂鸣器的声音
  18.         入口参数： 无
  19.         出口参数： 无
  20.         备          注：
  21. *************************************************/
  22. void    Di()
  23. {
  24.         uint        i;
  25.         for(i = 1;i < 50; i ++)
  26.         {
  27.                 beep = 0;
  28.                 DelayUs2x(i * 10);
  29.                 beep = 1;
  30.                 DelayUs2x( ( 50 - i) * 5);
  31.         }
  32.     for(i = 1;i < 50; i++)
  33.     {
  34.                 beep = 1;
  35.                 DelayUs2x(i * 10);
  36.                 beep = 0;
  37.                 DelayUs2x( ( 50 - i) * 5);
  38.     }
  39. }


  42. /*************************************************
  43.         函数名：        Locate_DS1302()
  44.         函数功能：        用于调整DS1302时间时  定位游标
  45.                                 与提示改变的项目
  46.         入口参数：  无
  47.         出口参数：        无
  48.         备          注：
  49.        
  50. *************************************************/
  51. void         Locate_DS1302()                               
  52. {                       
  53.         Remind_DS1302_Exchange(g_Set_DS1302_Num);        //提示DS1302改变的项目
  54.         switch(g_Set_DS1302_Num)                                        //定位光标
  55.         {
  56.                 case 1:        Locate_pos(2,6);        break;        //第一次按下光标到秒位置
  57.                 case 2: Locate_pos(2,4);        break;        //第二次按下光标到分钟位置
  58.                 case 3:        Locate_pos(2,2);        break;        //第三次按下光标到小时位置
  59.                 case 4: Locate_pos(2,1);        break;        //第四次按下光标到星期位置
  60.                 case 5:        Locate_pos(1,6);        break;        //第五次按下光标到日位置
  61.                 case 6:        Locate_pos(1,4);        break;        //第六次按下光标到月位置
  62.                 case 7: Locate_pos(1,2);        break;        //第七次按下光标到年位置
  63.                 default:                                                        //返回界面并对标志位进行处理
  64.                         {
  65.                                 g_Set_DS1302_Num = 0;
  66.                                 Initial_12864();
  67.                                 Initial_12864();                                 //初始化12864
  68.                                 Write_12864_DS1302_Constant();        //写12864固定的部分
  69.                                 Write_1302_Date();                                //写入 存储数据
  70.                                 g_Alarm_Flag1 = 0;
  71.                                 g_Alarm_Flag2 = 0;
  72.                         }
  73.         }

  75.         if(g_Set_DS1302_Num >= 8)                                        //增加程序的稳定性                                               
  76.         {
  77.                 g_Set_DS1302_Num = 0;
  78.         }

  80. }



  84. /************************************************
  85.         函数名：        Increase_DS1302()
  86.         函数功能:   用于处理调整DS1302的数值之时
  87.                                 对调整的项目进行数值增加
  88.         入口参数：无
  89.         出口参数：无
  90.         备    注：
  91. ************************************************/
  92. void         Increase_DS1302()                                                               
  93. {
  94.         Remind_DS1302_Exchange(g_Set_DS1302_Num);                                //提示改变的项目

  96.         switch(g_Set_DS1302_Num)
  97.         {
  98.                 case 1:                                                        //增大调整秒
  99.                 {
  100.                         g_sec ++;
  101.                         if(g_sec >= 60)                                //到达一分钟的时间               
  102.                         {
  103.                                 g_sec = 0;
  104.                         }
  105.                         Write_sfm(6,g_sec);                        //把调节的数据写在液晶屏上
  106.                         Locate_pos(2,6);                        //显示位置重新回到调节处
  107.                         break;
  108.                 }
  109.                 case 2:                                                        //增大调整分钟
  110.                 {
  111.                         g_min ++;
  112.                         if(g_min >= 60)                        //到达一小时的时间
  113.                         {
  114.                                 g_min = 0;       
  115.                         }                               
  116.                         Write_sfm(4,g_min);                        //把调节的数据写在液晶屏上
  117.                         Locate_pos(2,4);                        //显示位置重新回到调节处
  118.                
  119.                         break;
  120.                 }
  121.                 case 3:                                                        //增大调整小时
  122.                 {
  123.                         g_hour ++;
  124.                         if(g_hour >= 24)
  125.                         {
  126.                                 g_hour = 0;
  127.                         }
  128.                         Write_sfm(2,g_hour);                        //把调节的数据写在液晶屏上
  129.                         Locate_pos(2,2);                        //显示位置重新回到调节处
  130.                         break;
  131.                        
  132.                 }
  133.                 case 4:                                                        //增大调整星期
  134.                 {
  135.                         g_week ++;
  136.                         if(g_week >= 8)
  137.                         {
  138.                                 g_week = 1;
  139.                         }
  140.                         Write_week(g_week);                //把调节的数据写在液晶屏上
  141.                         Locate_pos(2,1);                        //显示位置重新回到调节处
  142.                         break;
  143.                 }
  144.                 case 5:                                                    //增大调整日期
  145.                 {
  146.                         g_date ++;
  147.                         if(g_date >= 31)
  148.                         {
  149.                                 g_date = 1;
  150.                                 g_month ++;
  151.                                 if(g_month >= 13)//到达一年的时间
  152.                                 {
  153.                                         g_month = 1;
  154.                                         g_year++;
  155.                                         if(g_year >= 20)
  156.                                         {
  157.                                                 g_year = 9;
  158.                                         }
  159.                                 }

  161.                         }
  162.                         Write_nyr(6,g_date);                //把调节的数据写在液晶屏上
  163.                         Locate_pos(1,6);                        //显示位置重新回到调节处
  164.                         break;
  165.                 }
  166.                 case 6:                                                        //增大调整月份
  167.                 {
  168.                         g_month ++;
  169.                         if(g_month >= 12)
  170.                         {
  171.                                 g_month = 1;
  172.                                 g_year ++;
  173.                                 if(g_year >= 20)
  174.                                 {
  175.                                         g_year = 9;
  176.                                 }
  177.                         }
  178.                         Write_nyr(4,g_month);                //把调节的数据写在液晶屏上
  179.                         Locate_pos(1,4);                        //显示位置重新回到调节处
  180.                         break;
  181.                 }
  182.                 case 7:                                                        //增大调整年
  183.                 {
  184.                         g_year ++;
  185.                         if(g_year >= 20)
  186.                         {
  187.                                 g_year = 9;
  188.                         }
  189.                         Write_nyr(2,g_year);                //把调节的数据写在液晶屏上
  190.                         Locate_pos(1,2);                        //显示位置重新回到调节处
  191.                         break;
  192.                 }
  193.                

  195.         }
  196. }


  199. /***********************************************
  200.         函数名：        Decrease_DS1302()
  201.         函数功能:   用于处理调整DS1302的数值之时
  202.                                 对调整的项目进行数值减小
  203.         入口参数：无
  204.         出口参数：无
  205.         备          注：
  206. /***********************************************/
  207. void         Decrease_DS1302()                                                               
  208. {
  209.         switch(g_Set_DS1302_Num)
  210.         {
  211.                 case 1:                                                        //减小调整秒
  212.                 {
  213.                         g_sec --;
  214.                         if(g_sec <= 0)
  215.                         {
  216.                                 g_sec = 59;
  217.                         }
  218.                        
  219.                         Write_sfm(6,g_sec);                        //把调节的数据写在液晶屏上
  220.                         Locate_pos(2,6);                        //显示位置重新回到调节处
  221.                         break;
  222.                 }
  223.                 case 2:                                                        //减小调整分钟
  224.                 {
  225.                         g_min --;
  226.                         if(g_min <= 0)
  227.                         {
  228.                                 g_min = 59;       
  229.                         }                               
  230.                         Write_sfm(4,g_min);                        //把调节的数据写在液晶屏上
  231.                         Locate_pos(2,4);                        //显示位置重新回到调节处
  232.                         break;
  233.                 }
  234.                 case 3:                                                        //减小调整小时
  235.                 {
  236.                         g_hour --;
  237.                         if(g_hour <= 0)
  238.                         {
  239.                                 g_hour = 23;
  240.                         }
  241.                         Write_sfm(2,g_hour);                        //把调节的数据写在液晶屏上
  242.                         Locate_pos(2,2);                        //显示位置重新回到调节处
  243.                         break;
  244.                        
  245.                 }
  246.                 case 4:                                                        //减小调整星期
  247.                 {
  248.                         g_week --;
  249.                         if(g_week <= 0)
  250.                         {
  251.                                 g_week = 7;
  252.                         }
  253.                         Write_week(g_week);                //把调节的数据写在液晶屏上
  254.                         Locate_pos(2,1);                        //显示位置重新回到调节处
  255.                         break;
  256.                 }
  257.                 case 5:                                                        //减小调整日期
  258.                 {
  259.                         g_date --;
  260.                         if(g_date <= 0)
  261.                         {
  262.                                 g_date = 31;
  263.                         }

  265.                         Write_nyr(6,g_date);                //把调节的数据写在液晶屏上
  266.                         Locate_pos(1,6);                        //显示位置重新回到调节处
  267.                         break;
  268.                 }
  269.                 case 6:                                                        //减小调整月份
  270.                 {
  271.                         g_month --;
  272.                         if(g_month <= 0)
  273.                         {
  274.                                 g_month = 12;
  275.                                 g_year --;
  276.                                 if(g_year <= 8)
  277.                                 {
  278.                                         g_year = 20;
  279.                                 }

  281.                         }
  282.                         Write_nyr(4,g_month);                //把调节的数据写在液晶屏上
  283.                         Locate_pos(1,4);                        //显示位置重新回到调节处
  284.                         break;
  285.                 }
  286.                 case 7:                                                        //减小调整年
  287.                 {
  288.                         g_year --;
  289.                         if(g_year <= 8)
  290.                         {
  291.                                 g_year = 20;
  292.                         }
  293.                         Write_nyr(2,g_year);                //把调节的数据写在液晶屏上
  294.                         Locate_pos(1,2);                        //显示位置重新回到调节处
  295.                         break;
  296.                 }
  297.                
  298.         }
  299. }
  300. /************************************************
  301.         函数名：        void Locate_A()
  302.         函数功能：        给变项目时对闹钟的调整项目进行提示
  303.                                 并定位改变的项目
  304.         入口参数：无
  305.         出口参数：无
  306.         备          注：
  307. ************************************************/
  308. void        Locate_A()                                               
  309. {
  310.         switch(g_Set_Alarm_Num)
  311.         {
  312.                 case 1:     Write_Remind_Alarm_Time(1);       break;         //设置分钟
  313.                                                        
  314.                 case 2:          Write_Remind_Alarm_Time(2);                  break;                //定位小时
  315.         }
  316. }
  317. /************************************************
  318.         函数名：        void A_Increase()
  319.         函数功能：  在调整闹铃的数值时对相应的时分
  320.                                 进行增加
  321.         入口参数：        无
  322.         出口参数：  无
  323.         备          注：
  324. ************************************************/
  325. void        A_Increase()
  326. {
  327.         switch(g_Set_Alarm_Num)
  328.         {
  329.                 case 1:                                                        //增加闹钟分钟的时间                                          
  330.                 {
  331.                         g_Alarm_min ++;
  332.                         if(g_Alarm_min >= 60)
  333.                         {
  334.                                 g_Alarm_min = 0;
  335.                         }
  336.                         Write_Remind_Alarm_Time        (1);                                //读取设置后的闹铃时间
  337.                         Write_Add_24c02                        (1,g_Alarm_min);                //24C02存数据

  339.                         break;
  340.                 }
  341.                 case 2:                                                        //增加闹钟小时的时间                                          
  342.                 {
  343.                         g_Alarm_hour ++;
  344.                         if(g_Alarm_hour >= 24)
  345.                         {
  346.                                 g_Alarm_hour = 0;
  347.                         }
  348.                         Write_Remind_Alarm_Time        (2);                        //读取设置后的闹铃时间
  349.                         Write_Add_24c02                        (2,g_Alarm_hour);        //24C02存数据
  350.                         break;
  351.                 }
  352.         }
  353. }
  354. /************************************************
  355.         函数名：        A_Decrease()
  356.         函数功能：        调整闹铃时对闹铃的小时与分钟进行
  357.                                 减小
  358. ……………………

  360. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


所有资料51hei提供下载（完整源码打包）:
我的超级时钟.zip (163.52 KB, 下载次数: 97)


作者: dragon19790000    时间: 2017-5-28 22:03
不错，值得学习！！！
作者: wjwjwjwj    时间: 2017-6-16 08:13
好东西值得收藏
作者: 875427704    时间: 2019-1-6 10:00
12864是带字库的吗
作者: 原来如鸟    时间: 2019-1-6 15:43
这就是我一直想要找的，好东西啊
作者: leezll    时间: 2019-10-11 06:15
不错，值得学习！！！
作者: leezll    时间: 2019-10-11 06:32
没有电路图啊！！！
作者: 94情节    时间: 2019-10-11 14:09
代码很棒，值得学习，谢谢



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1