设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 可上下左右滚动的可调式单片机16x64点钟时钟(源代码+仿 ...
返回列表 发新帖
查看: 2323|回复: 1
收起左侧

可上下左右滚动的可调式单片机16x64点钟时钟(源代码+仿真)

[复制链接]
ID:126738 发表于 2019-3-4 14:04 | 显示全部楼层 |阅读模式
可调式点阵时钟，带温度显示，proteus仿真,并且可以上下左右滚动

64点阵仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
0.png 0.png 0.png 0.png

单片机源程序如下:
  1. // A B C D 对应P1.0; P1.1 ; P1.2; P1.3
  2. //--------------------------------
  3. #include "reg52.h"

  5. #define  uchar unsigned char
  6. #define  uint  unsigned int
  7. //========================
  8. //****滚屏事件定义****
  9. #define         MSG_MV_L         1         //左移
  10. #define         MSG_MV_R         2        //右移
  11. #define         MSG_MV_U    3        //上移
  12. #define         MSG_MV_D    4        //下移
  13. #define         MSG_NONE         0        //无
  14. uchar MSG_MV = 0;
  15. //========================
  16. //****显示状态定义****
  17. #define STA_gTIME        1        //滚动显示时间
  18. #define        STA_gTEMP        2        //滚动显示温度
  19. #define        STA_gWORD        3        //滚动显示文字
  20. #define        STA_sTIME        4        //静态显示时间
  21. #define        STA_sWEEK        5        //静态显示星期
  22. #define        STA_sDATE        6        //静态显示日期
  23. #define STA_sYEAR        7        //静态显示年份
  24. #define        STA_sTEMP        8        //静态显示温度
  25. #define        STA_sWORD        9        //静态显示文字
  26. #define STA_CHG                10        //校时模式
  27. #define STA_SONG        11        //滚动显示诗歌
  28. #define STA_COPYRIGHT        12        //开机显示
  29. uchar STATE = 1;
  30. //=========================
  31. //****校时状态定义****
  32. #define CHG_HOUR        1        //调整小时
  33. #define CHG_MIN                2        //调整分
  34. #define CHG_SEC                3        //调整秒
  35. #define CHG_MON                4        //调整月
  36. #define CHG_DAY                5        //调整日
  37. #define CHG_WEEK        6        //调整星期
  38. #define CHG_YEAR        7        //调整年
  39. uchar CHANGE = 1;
  40. uchar hide_times = 0;        //校时闪烁时间变量
  41. uchar HIDE = 0;                //隐藏显示标志位
  42. uchar TMP_TIME = 0;
  43. //=========================
  44. //****按键定义****
  45. sbit  key0 = P1^0;
  46. sbit  key1 = P1^1;
  47. sbit  key2 = P1^2;
  48. sbit  key3 = P1^3;

  50. #define KEY0        0x0e
  51. #define KEY1         0x0d
  52. #define KEY2         0x0b
  53. #define KEY3         0x07

  55. #define KEY0_S        0x0e        //KEY0短按下
  56. #define KEY1_S        0x0d        //KEY1短按下
  57. #define KEY2_S        0x0b        //KEY2短按下
  58. #define KEY3_S        0x07        //KEY3短按下
  59. #define KEY0_L        0x1e        //KEY0长按下
  60. #define KEY1_L        0x1d        //KEY1长按下
  61. #define KEY2_L        0x1b        //KEY2长按下
  62. #define KEY3_L        0x17        //KEY3长按下
  63. #define KEY_NONE        0        //无按键
  64. uchar MSG_KEY = KEY_NONE;
  65. uchar key_times = 0;        //持续时间
  66. uchar key_keep_times = 0;
  67. uchar cur_key_val = 0;
  68. uchar key_done = 0;        //按键事件有无做好
  69. uchar exit = 0;        //校时状态下长时间无按键退出
  70. //=========================
  71. //uchar time_read_times = 0;        //读时间
  72. //uchar tem_read_times = 0;        //读温度
  73. //=========================
  74. //****引脚定义****
  75. sbit  CLK =P2^5 ;                  //74HC595移时钟
  76. sbit  STB =P2^4        ;          // 74HC595锁存信号
  77. sbit  Red=P2^7        ;          //红色数据输出引脚低电平有效            
  78. sbit  Greed=P2^6;         //全屏控制使能0，低电平有效
  79. sbit  OE = P0^7;           //全屏使能
  80. //========================
  81. //****DS1302****
  82. sbit SCLK=P0^5;   //位定义1302芯片的接口，时钟输出端口定义在P2.4引脚
  83. sbit DATA=P0^6;   //位定义1302芯片的接口，数据输出端定义在P2.5引脚
  84. sbit RST=P0^7;    //位定义1302芯片的接口，复位端口定义在P2.6引脚

  86. typedef struct __SYSTEMTIME__
  87. {
  88.         uchar Second;
  89.         uchar Minute;
  90.         uchar Hour;
  91.         uchar Day;
  92.         uchar Month;
  93.         uchar Week;
  94.         uchar  Year;
  95. }SYSTEMTIME;        //定义的时间类型
  96. SYSTEMTIME Time;


  99. //=========================================
  100. //****18B20****
  101. sbit DQ = P0^4
  102. ;  //定义DS18B20端口DQ  

  104. unsigned char data  temp_data[2] = {0x00,0x00} ;
  105. unsigned char data  temp_ram[5] =   {0x00,0x00,0x00,0x00,0x00} ;
  106. unsigned char code  ditab[16] =    {0x00,0x01,0x01,0x02,0x03,0x03,0x04,0x04,
  107.                                     0x05,0x06,0x06,0x07,0x08,0x08,0x09,0x09};
  108. //==========================================
  109. bit presence  ;
  110. uchar SendData;                  //要发送的数据变量
  111. uchar hang;                        //行扫描变量  （半屏只有16行，所以hang=0到15）
  112. uchar move_times = 0;        //左右移动位数
  113. uchar start_word = 0;


  116. uchar data h_dispram[10];         //显示缓存
  117. uchar code *disword[26];        //显示文字指针


  120. void  Keyscan (void); //修改参数按键扫描子程序
  121. void  Sendping(); //发送半屏子程序
  122. void  Put_Wdispram(uchar first_word);//
  123. void  Put_Hdispram(); //把显示文字放入显示缓存
  124. void  Move_Left();        //左移
  125. void  Move_Right();        //右移
  126. void  RL_Move();
  127. void  UD_Move();
  128. void  Show_Line();
  129. void  Show_Move_Word(uchar code *WORDS[][8]);
  130. void  delay();
  131. void  SendByte(void);
  132. void  RowsCan(void);
  133. void  Disp_Temperature();
  134. void Put_gTEMP();
  135. void Change_obj();

  137. uchar ReadKey1();



  141. uchar code MY_WORDS[][16]=
  142.                                         {
  143. {0x21,0x11,0x11,0x02,0x97,0x52,0x52,0x12,0x2F,0x22,0xE2,0x22,0x23,0x20,0x20,0x20},


  146. **************详见51hei附件****************
  147. {0x00,0x00,0x80,0x04,0xFC,0x00,0x04,0xF8,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00},/*"宁",1*/
  148. {0x00,0x06,0x14,0x24,0x3F,0x44,0x7F,0x04,0x24,0x3F,0x24,0x24,0x25,0x04,0x00,0x00},
  149. {0x00,0x02,0x02,0x92,0x12,0x12,0xD2,0x12,0x52,0xD2,0x52,0x42,0x82,0x0C,0x04,0x00},/*"制",2*/
  150. {0x00,0x0C,0x08,0x09,0x11,0x1A,0x34,0x54,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x00},
  151. {0x00,0xC0,0x80,0x04,0xF8,0x40,0x40,0x7C,0x40,0x40,0x44,0x78,0x40,0x40,0x00,0x00},/*"作",3*/
  152. };

  154. void Put_Wdispram(uchar code *WORDS[][8]){        //,uchar first_word
  155.         uchar i;
  156.         disword[0] = &NO_WORDS[12][0];
  157.         for(i=1;i<25;i++){
  158.                 disword[i] = &WORDS[i-1][0];        //first_word+
  159.         }
  160. }        

  162. void  Put_Hdispram(){
  163.         uchar i;
  164.         for(i=0;i<10;i++){
  165.                 h_dispram[i] = *(disword[i+start_word]+hang);        //
  166.         }
  167. }

  169. void Move_Left(){
  170.         uchar i;
  171.         for(i=0;i<9;i++){
  172.                 h_dispram[i] = (h_dispram[i] << (move_times)) | (h_dispram[i+1] >> (8-move_times));
  173.         }
  174. }

  176. void Move_Right(){
  177.         uchar i;
  178.         for(i=9;i>0;i--){
  179.                 h_dispram[i] = (h_dispram[i] >> (move_times)) | (h_dispram[i-1] << (8-move_times));
  180.         }
  181. }

  183. void RL_Move(){
  184.         //
  185.         switch(MSG_MV){
  186.                 case MSG_MV_L:        //左移
  187.                         Move_Left();
  188.                         break;
  189.                 case MSG_MV_R:        //右移
  190.                         Move_Right();
  191.                         break;
  192.                 case MSG_NONE:
  193.                         break;
  194.                 default:
  195.                         break;
  196.                 }
  197. }

  199. void Move_Up(){
  200.         //
  201.         uchar i,j,m,n;
  202.         for(m=0;m<16;m++){
  203.                 for(n=0;n<8;n++){
  204.                         for(j=0;j<16-m;j++){
  205.                                 for(i=0;i<10;i++){
  206.                                         h_dispram[i] = *(disword[i]+m+j);                //
  207.                                 }
  208.                                 Show_Line();
  209.                         }
  210.                         for(j=16-m;j<16;j++){
  211.                                 for(i=0;i<10;i++){
  212.                                         h_dispram[i] = *(disword[i+8]+m+j-16);                //0x00
  213.                                 }
  214.                                 Show_Line();
  215.                         }
  216.                 }
  217.         }
  218. }

  220. void Move_Down(){
  221.         //
  222.         uchar i,j,m,n;
  223.         for(m=0;m<16;m++){
  224.                 for(n=0;n<8;n++){
  225.                         for(j=0;j<m;j++){
  226.                                 for(i=0;i<10;i++){
  227.                                         h_dispram[i] = *(disword[i+8]+15-m+j);                //
  228.                                 }
  229.                                 Show_Line();
  230.                         }
  231.                         for(j=m;j<16;j++){
  232.                                 for(i=0;i<10;i++){
  233.                                         h_dispram[i] = *(disword[i]-m+j);                //0x00
  234.                                 }
  235.                                 Show_Line();
  236.                         }
  237.                 }
  238.         }
  239. }

  241. void UD_Move(){
  242.         //
  243.         switch(MSG_MV){
  244.                 case MSG_MV_U:        //左移
  245.                 //        Move_Up();
  246.                         break;
  247.                 case MSG_MV_D:        //右移
  248.                 //        Move_Down();
  249.                         break;
  250.                 case MSG_NONE:
  251.                         break;
  252.                 default:
  253.                         break;
  254.                 }
  255. }

  257. void Show_Line(){
  258.         uchar m;
  259.         OE=1;
  260.         for(m =0;m<8;m++)  
  261.         {        
  262.                 SendData = h_dispram[m+1];
  263.                 SendByte();
  264.         }
  265.         STB = 0;
  266.         STB = 1;                 //上升沿数据锁存
  267.         RowsCan();                //行扫描
  268.         OE = 0;
  269. //        delay();        //
  270. }

  272. void Show_sWord(){
  273.         int m,i;//
  274.         hang = 0;
  275.         for(m=0;m<14;m++){
  276.                 for(i=0;i<16;i++){
  277.                         Put_Hdispram();        //把第i行放入行缓冲
  278.                         Show_Line();
  279.                         //delay();        //看需要
  280.                 }
  281.                
  282.         }
  283. }
  284. void Show_Move_Word(uchar code *WORDS[][8]){
  285.         int m,i;
  286.         while(1){
  287.         for(m=0;m<6;m++){        //若要上下移动 m=16
  288.                 //hang = 0;
  289.                 for(i=0;i<16;i++){
  290.                         Put_Hdispram();        //把第i行放入行缓冲
  291.                         RL_Move();        //是否要左右移动
  292.                         Show_Line();
  293.                         //delay();        //看需要
  294.                 }
  295.         //UD_Move();        //是否要上下移动
  296.         }
  297.         //========================================
  298.         //测试左移右移        切换时有跳变！！
  299. //        if(MSG_MV){
  300.                 move_times++;
  301.                 if((move_times == 9) && (MSG_MV == MSG_MV_L)){
  302.                         move_times = 1;
  303.                         Put_Wdispram(WORDS);
  304.                         start_word++;
  305.                         switch(STATE){
  306.                                 case STA_gTEMP:
  307.                                         Read_Temperature();
  308.                                         Disp_Temperature();                                   //
  309.                                         Put_gTEMP();          //
  310.                                         if(start_word > (sizeof(TMP_WORDS)/16 - 8))
  311.                                                 MSG_MV = MSG_MV_R;
  312.                                         break;
  313.                                 case STA_gWORD:
  314.                                         if(start_word > (sizeof(MY_WORDS)/16 - 8))
  315.                                                 MSG_MV = MSG_MV_R;
  316.                                 default:
  317.                                         break;
  318.                         }
  319.                 if(start_word > (sizeof(TMP_WORDS)/16 - 4))
  320.                                 MSG_MV = MSG_MV_R;
  321.                 }
  322.                 else if((move_times == 9) && (MSG_MV == MSG_MV_R)){
  323.                         move_times = 1;
  324.                         Put_Wdispram(WORDS);  //
  325.                         start_word-- ;
  326.                         switch(STATE){
  327.                                 case STA_gTEMP:
  328.                                         Disp_Temperature();                                   //
  329.                                         Put_gTEMP();
  330.                                                 break;
  331.                                 default:
  332.                                         break;
  333.                         }
  334.                         if(start_word < 1){
  335.                                 MSG_MV = MSG_MV_L;
  336.                                 return;
  337.                         }
  338.                 }
  339. //        }
  340.                 }
  341. }
  342. void Show_All_Word(){
  343.         int m,i;
  344.         //MSG_MV = MSG_MV_L;
  345.         for(start_word = 0;start_word < 8;start_word++){
  346.                 for(move_times = 0; move_times < 8;move_times++){
  347.                         for(m=0;m<4;m++){        //若要上下移动 m=16
  348.                                 for(i=0;i<16;i++){
  349.                                         Put_Hdispram();        //把第i行放入行缓冲
  350.                                         RL_Move();        //是否要左右移动
  351.                                         Show_Line();
  352.                                 }
  353.                         }
  354.                 }
  355.         }
  356. }

  358. void delay()
  359. {
  360.         uint i;
  361.         for(i=0;i<40;i++);
  362. }                        
  363.         
  364. //------------------------------------
  365. //----------字发送子程序-----------
  366.         void SendByte(void)
  367.                 {
  368.                    uchar m;
  369.                    for(m=0;m<8;m++)
  370.                    {
  371.                                    CLK = 0;
  372.                                 Red = (SendData & 0x80);                  //红屏显示
  373.                     //        Greed =  (SendData & 0x80);                  //绿屏显示
  374.                                   SendData =SendData<<1;                        
  375.                                 CLK = 1;          //移位时钟上升沿
  376.                    }
  377.                 }
  378. //-----------------------------------
  379. //----------行扫描子程序-------------
  380.            void RowsCan(void)
  381.            {
  382.                         P2 = P2 & 0xf0;
  383.                         P2 = P2 | hang;
  384.                         hang++;
  385.                         if (hang>=16)
  386.                         {
  387.                                 hang =0x00;
  388.                         }
  389.                 }

  391.                 void initial(void)
  392.                    {
  393.                           OE = 1;
  394.                         Red = 1;
  395.                         Greed = 1;
  396.                         SendData = 0x00;
  397.                         hang = 0x00;
  398.                                                         
  399.                  }
  400. /*****************************************************
  401. 函数功能：延时若干微秒
  402. 入口参数：n
  403. ***************************************************/
  404. void delaynus(unsigned char n)
  405. {
  406. unsigned char i;
  407. // for(i=0;i<n;i++)
  408.       ;
  409. }
  410. /*****************************************************
  411. 函数功能：向1302写一个字节数据
  412. 入口参数：x
  413. ***************************************************/
  414. void Write1302(unsigned char dat)
  415. {
  416.   unsigned char i;
  417.   SCLK=0;            //拉低SCLK，为脉冲上升沿写入数据做好准备
  418.   delaynus(2);       //稍微等待，使硬件做好准备
  419.   for(i=0;i<8;i++)      //连续写8个二进制位数据
  420.     {
  421.             DATA=dat&0x01;    //取出dat的第0位数据写入1302
  422.                 delaynus(2);       //稍微等待，使硬件做好准备
  423.                  SCLK=1;           //上升沿写入数据
  424.                  delaynus(2);      //稍微等待，使硬件做好准备
  425.                  SCLK=0;           //重新拉低SCLK，形成脉冲
  426.                  dat>>=1;          //将dat的各数据位右移1位，准备写入下一个数据位
  427.           }
  428.         
  429. }
  430. /*****************************************************
  431. 函数功能：根据命令字，向1302写一个字节数据
  432. 入口参数：Cmd，储存命令字；dat，储存待写的数据
  433. ***************************************************/
  434. void WriteSet1302(unsigned char Cmd,unsigned char dat)
  435. {
  436.    RST=0;           //禁止数据传递
  437.    SCLK=0;          //确保写数居前SCLK被拉低
  438.         RST=1;           //启动数据传输
  439.         delaynus(2);     //稍微等待，使硬件做好准备
  440.         Write1302(Cmd);  //写入命令字
  441.         Write1302(dat);  //写数据
  442.         SCLK=1;          //将时钟电平置于已知状态
  443.         RST=0;           //禁止数据传递
  444. }
  445. /*****************************************************
  446. 函数功能：从1302读一个字节数据
  447. 入口参数：x
  448. ***************************************************/
  449. unsigned char Read1302(void)
  450. {
  451.    unsigned char i,dat;
  452.         delaynus(2);       //稍微等待，使硬件做好准备
  453.         for(i=0;i<8;i++)   //连续读8个二进制位数据
  454.          {
  455.            dat>>=1;       //将dat的各数据位右移1位，因为先读出的是字节的最低位
  456.                 if(DATA==1)    //如果读出的数据是1
  457.                  dat|=0x80;    //将1取出，写在dat的最高位
  458.                  SCLK=1;       //将SCLK置于高电平，为下降沿读出
  459.                  delaynus(2);  //稍微等待
  460.                  SCLK=0;       //拉低SCLK，形成脉冲下降沿
  461.                  delaynus(2);  //稍微等待
  462.           }         
  463.   return dat;        //将读出的数据返回
  464. }  
  465. /*****************************************************
  466. 函数功能：根据命令字，从1302读取一个字节数据
  467. 入口参数：Cmd
  468. ***************************************************/
  469. unsigned char  ReadSet1302(unsigned char Cmd)
  470. {
  471.   unsigned char dat;
  472.   RST=0;                 //拉低RST
  473.   SCLK=0;                //确保写数居前SCLK被拉低
  474.   RST=1;                 //启动数据传输
  475.   Write1302(Cmd);       //写入命令字
  476.   dat=Read1302();       //读出数据
  477.   SCLK=1;              //将时钟电平置于已知状态
  478.   RST=0;               //禁止数据传递
  479.   return dat;          //将读出的数据返回
  480. }
  481. /*****************************************************
  482. 函数功能： 1302进行初始化设置
  483. ***************************************************/
  484. void Init_DS1302(void)
  485. {        
  486.   unsigned char flag;
  487.    
  488.     flag= ReadSet1302(0x81);
  489.         if(flag&0x80)        {      //判断时钟芯片是否关闭
  490.    WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字，写入不保护指令
  491.    WriteSet1302(0x80,((0/10)<<4|(0%10)));   //根据写秒寄存器命令字，写入秒的初始值
  492.         WriteSet1302(0x82,((18/10)<<4|(18%10)));   //根据写分寄存器命令字，写入分的初始值
  493.         WriteSet1302(0x84,((21/10)<<4|(21%10))); //根据写小时寄存器命令字，写入小时的初始值
  494.         WriteSet1302(0x86,((23/10)<<4|(23%10))); //根据写日寄存器命令字，写入日的初始值
  495.         WriteSet1302(0x88,((7/10)<<4|(7%10))); //根据写月寄存器命令字，写入月的初始值
  496.         //WriteSet1302(0x8A,2);
  497.         WriteSet1302(0x8c,((10/10)<<4|(10%10)));   //根据写小时寄存器命令字，写入小时的初始值
  498.                 WriteSet1302(0x90,0xa5);
  499.         WriteSet1302(0x8E,0x80);
  500.   }
  501.   //如果不想每次都初始化时间，也就是掉电后还想让时钟继续走时的话 就用上面的语句


  504.   /*--------------------这是每次都初始化的语句-----------------*/
  505.     /* WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字，写入不保护指令
  506.    WriteSet1302(0x80,((0/10)<<4|(0%10)));   //根据写秒寄存器命令字，写入秒的初始值
  507.         WriteSet1302(0x82,((18/10)<<4|(18%10)));   //根据写分寄存器命令字，写入分的初始值
  508.         WriteSet1302(0x84,((21/10)<<4|(21%10))); //根据写小时寄存器命令字，写入小时的初始值
  509.         WriteSet1302(0x86,((23/10)<<4|(23%10))); //根据写日寄存器命令字，写入日的初始值
  510.         WriteSet1302(0x88,((7/10)<<4|(7%10))); //根据写月寄存器命令字，写入月的初始值
  511.         //WriteSet1302(0x8A,2);
  512.         WriteSet1302(0x8c,((10/10)<<4|(10%10)));   //根据写小时寄存器命令字，写入小时的初始值
  513.                 WriteSet1302(0x90,0xa5);
  514.         WriteSet1302(0x8E,0x80);
  515.         */



  519. }
  520. void write_time1302(){
  521.     WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字，写入不保护指令
  522.     WriteSet1302(0x80,Time.Second);   //根据写秒寄存器命令字，写入秒的初始值
  523.         WriteSet1302(0x82,Time.Minute);   //根据写分寄存器命令字，写入分的初始值
  524.         WriteSet1302(0x84,Time.Hour); //根据写小时寄存器命令字，写入小时的初始值
  525.         WriteSet1302(0x86,Time.Day); //根据写日寄存器命令字，写入日的初始值
  526.         WriteSet1302(0x88,Time.Month); //根据写月寄存器命令字，写入月的初始值
  527.         WriteSet1302(0x8A,Time.Week);
  528.         WriteSet1302(0x8c,Time.Year);   //根据写小时寄存器命令字，写入小时的初始值
  529.         //        WriteSet1302(0x90,0xa5);
  530.         //WriteSet1302(0x8E,0x80);        
  531. }

  533. //读时间
  534. void Read_TIME(){

  536.         RST=0;                 //拉低RST
  537.           SCLK=0;                //确保写数居前SCLK被拉低
  538.           RST=1;                 //启动数据传输
  539.           Write1302(0xbf);       //写入命令字
  540.         Time.Second = Read1302() & 0x7f;
  541.         Time.Minute = Read1302() & 0x7f;
  542.         Time.Hour = Read1302() & 0x7f;
  543.         Time.Day = Read1302() & 0x7f;
  544.         Time.Month = Read1302() & 0x7f;  
  545.          Time.Week= Read1302() & 0x7f;
  546.         Time.Year = Read1302() & 0x7f;
  547.         SCLK=1;          //将时钟电平置于已知状态
  548.         RST=0;           //禁止数据传递
  549.          
  550.         /*unsigned char ReadValue;   //储存从1302读取的数据
  551.         ReadValue = ReadSet1302(0x81);   //从秒寄存器读数据
  552.         Time.Second =ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F);//将读出数据转化
  553.          ReadValue = ReadSet1302(0x83);  //从分寄存器读
  554.      Time.Minute = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  555.      ReadValue = ReadSet1302(0x85);  //从时寄存器读
  556.      Time.Hour = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  557.      ReadValue = ReadSet1302(0x87);  //从分寄存器读
  558.      Time.Day = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  559.          ReadValue = ReadSet1302(0x89);  //从分寄存器读
  560.      Time.Month = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  561.         ReadValue = ReadSet1302(0x8B);  //从时寄存器读
  562.         Time.Week= ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  563.          ReadValue = ReadSet1302(0x8d);  //从分寄存器读                                                                           
  564.      Time.Year = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化  
  565.    
  566.    */ }

  568. void Put_Adispram(uchar a){
  569.         uchar i;
  570.         //第一屏"今天是:"
  571.         disword[a+1] = &NO_WORDS[12][0];        //空格
  572.         for(i=0;i<6;i++)
  573.                 disword[a+i+2] = &TIME_WORDS[i][0];
  574.         disword[a+8] = &NO_WORDS[11][0];        //":"
  575.         //第二屏
  576.         //disword[4] = &TIME_WORDS[];
  577.                
  578. }
  579.         
  580. //将年份放入到显示缓存
  581. //需要参数:缓冲区首地址下标
  582. void Put_Ydispram(uchar i){
  583.         disword[i+1] = &NO_WORDS[12][0];
  584.         if(Time.Year < 30 && !HIDE){
  585.                 disword[i+2] = &NO_WORDS[2][0];
  586.                 disword[i+3] = &NO_WORDS[0][0];
  587.                 }
  588.         else if(!HIDE){
  589.                 disword[i+2] = &NO_WORDS[1][0];
  590.                 disword[i+3] = &NO_WORDS[9][0];
  591.                 }
  592.         disword[i+4] = &NO_WORDS[Time.Year>>4][0];
  593.         disword[i+5] = &NO_WORDS[Time.Year&0x0f][0];
  594.         disword[i+6] = &TIME_WORDS[6][0];
  595.         disword[i+7] = &TIME_WORDS[7][0];        //年
  596.         disword[i+8] = &NO_WORDS[12][0];
  597. }        
  598. //将星期放入到显示缓存
  599. //参数:缓冲区首地址下标
  600. void Put_Kdispram(uchar i){
  601.         disword[i+1] = &NO_WORDS[12][0];                 
  602.         disword[i+2] = &TIME_WORDS[12][0];               
  603.         disword[i+3] = &TIME_WORDS[13][0];        //星期               
  604.         disword[i+4] = &TIME_WORDS[14][0];                 
  605.         disword[i+5] = &TIME_WORDS[15][0];
  606.         if(STATE== STA_CHG &&HIDE){
  607.                 disword[i+6] = &NO_WORDS[12][0];                //
  608.                 disword[i+7] = &NO_WORDS[12][0];                  //
  609.                 }
  610.         else{
  611.                 disword[i+6] = &WEEK_WORDS[Time.Week*2-2][0];                //
  612.                 disword[i+7] = &WEEK_WORDS[Time.Week*2-1][0];                  //
  613.                 }
  614.         disword[i+8] = &NO_WORDS[12][0];                 
  615. }

  617. //将日期放入到显示缓存
  618. //参数:缓冲区首地址下标
  619. void Put_Ddispram(uchar i){
  620.         disword[i+1] = &NO_WORDS[Time.Month>>4][0];                 //小时高位
  621.         disword[i+2] = &NO_WORDS[ Time.Month&0x0f][0];                //小时地位
  622.         disword[i+3] = &TIME_WORDS[8][0];                //-
  623.         disword[i+4] = &TIME_WORDS[9][0];                 //分钟高位
  624.         disword[i+5] = &NO_WORDS[ Time.Day>>4][0];                //分钟地位
  625.         disword[i+6] = &NO_WORDS[Time.Day&0x0f][0];                //-
  626.         disword[i+7] = &TIME_WORDS[10][0];                  //秒高位
  627.         disword[i+8] = &TIME_WORDS[11][0];                 //秒地位
  628. }

  630. //将时间放入到显示缓存
  631. //参数:缓冲区首地址下标
  632. void Put_Tdispram(uchar i){
  633.         disword[i+1] = &NO_WORDS[Time.Hour>>4][0];                 //小时高位
  634.         disword[i+2] = &NO_WORDS[ Time.Hour&0x0f][0];                //小时地位
  635.         disword[i+3] = &NO_WORDS[ 11 ];                //-
  636.         disword[i+4] = &NO_WORDS[Time.Minute>>4][0];                 //分钟高位
  637.         disword[i+5] = &NO_WORDS[ Time.Minute&0x0f][0];                //分钟地位
  638.         disword[i+6] = &NO_WORDS[ 11 ];                //-
  639.         disword[i+7] = &NO_WORDS[Time.Second>>4][0];                 //秒高位
  640.         disword[i+8] = &NO_WORDS[ Time.Second&0x0f][0];                //秒地位
  641. }
  642. //===================================
  643. //*****关于温度检测部分*****
  644. void Put_gTEMP(){
  645. //        uchar i;
  646. //        Put_Wdispram(TMP_WORDS,0);
  647.         disword[6] = &NO_WORDS[temp_ram[3]][0];                 //百位
  648.         disword[7] = &NO_WORDS[temp_ram[2]][0];                //十位
  649.         disword[8] = &NO_WORDS[temp_ram[1]][0];                //个位
  650.         disword[10] = &NO_WORDS[temp_ram[0]][0];                //小数
  651.         disword[12]        = &NO_WORDS[12];                //空格
  652.         disword[13]        = &NO_WORDS[12];                //空格
  653.          //
  654. }

  656. void Put_sTEMP(uchar i){
  657.         disword[i+1] = &NO_WORDS[12];                //空格
  658.         disword[i+2] = &NO_WORDS[12];//&NO_WORDS[temp_ram[3]][0];                 //百位
  659.         disword[i+3] = &NO_WORDS[temp_ram[2]][0];                //十位
  660.         disword[i+4] = &NO_WORDS[temp_ram[1]][0];                //个位
  661.         disword[i+5] = &TMP_WORDS[8][0];        //小数点
  662.         disword[i+6] = &NO_WORDS[temp_ram[0]][0];                //小数
  663.         disword[i+7] = &TMP_WORDS[10][0];
  664.         disword[i+8] = &NO_WORDS[12];                //空格
  665. }
  666. void Put_Cpyrt(uchar i){
  667.         uchar m;
  668.         for(m=0;m<8;m++)
  669.                 disword[i+1+m] = &CPYRT_WORDS[m];
  670. }
  671. void Show_Cpyrt(){
  672.         uchar i;
  673.         for(i=1;i<9;i++)
  674.                 disword[i] = &NO_WORDS[12];
  675.         Put_Cpyrt(8);
  676.         Move_Down();
  677.         Put_Cpyrt(0);
  678.         Put_Tdispram(8);
  679.         Move_Down();
  680. }
  681.         
  682. //========================
  683. //参数i:放入第几屏缓存
  684. //参数j:诗歌第几页
  685. //========================
  686. void Put_Song(uchar i,uchar j){
  687.         uchar m;
  688.         for(m=0;m<8;m++)
  689.                 disword[i+1+m] = &SONG_WORDS[j+m];
  690. }
  691. //显示诗歌
  692. void Show_Song(){
  693.         uchar i;
  694.         Put_Song(8,0);
  695.         Move_Up();
  696.         for(i=0;i<3;i++){
  697.                 Put_Song(0,i*8);
  698.                 Put_Song(8, (i+1)*8);
  699.                 Move_Up();
  700.                 }
  701.         Put_Song(0, 3*8);
  702.         Put_Tdispram(8);
  703.         Move_Up();
  704. }

  706.         
  707. //======================
  708. //*滚动显示所有信息*
  709. //======================
  710. void Show_All_Info(){
  711.         Put_Adispram(8);
  712.         Move_Down();        //切换效果
  713.         
  714.         Put_Adispram(0);
  715.         Put_Ydispram(8);        //XXXX年
  716.         Show_All_Word();
  717.         
  718.         Put_Ydispram(0);        //XXXX年
  719.         Put_Ddispram(8);
  720.         Show_All_Word();

  722.         Put_Ddispram(0);
  723.         Put_Kdispram(8);
  724.         Show_All_Word();

  726.         
  727.         Read_Temperature();
  728.         Disp_Temperature();
  729.         Put_Kdispram(0);
  730.         Put_Tdispram(8);
  731.         Show_All_Word();

  733.         Read_Temperature();
  734.         Disp_Temperature();
  735.         Put_Tdispram(0);
  736.         Put_sTEMP(8);
  737.         Show_All_Word();

  739.         Read_TIME();
  740.         Put_sTEMP(0);
  741.         Put_Tdispram(8);
  742.         Move_Up();
  743.         
  744. }

  746.         
  747. /*us级延时函数                                        */
  748. /*******************************************************************/

  750. void Delay(unsigned int num)
  751. {
  752.   num = num*2;
  753.   while( --num ) ;
  754. }

  756. /*初始化ds1820                                      */
  757. /*******************************************************************/
  758. Init_DS18B20(void)
  759. {  
  760.      DQ = 1 ;      //DQ复位
  761.      Delay(8) ;    //稍做延时

  763.      DQ = 0 ;      //单片机将DQ拉低
  764.      Delay(90) ;   //精确延时 大于 480us

  766.      DQ = 1 ;       //拉高总线
  767.      Delay(8) ;

  769.      presence = DQ ;    //如果=0则初始化成功 =1则初始化失败
  770.      Delay(100) ;
  771.      DQ = 1 ;
  772.      
  773.      return(presence) ; //返回信号，0=presence,1= no presence
  774. }


  777. /* 读一个字节                     */
  778. /*******************************************************************/
  779. ReadOneChar(void)
  780. {
  781. unsigned char i = 0 ;
  782. unsigned char dat = 0 ;

  784. for (i = 8 ; i > 0 ; i--)
  785.   {
  786.     DQ = 0 ; // 给脉冲信号
  787.     dat >>= 1 ;
  788.     DQ = 1 ; // 给脉冲信号

  790.     if(DQ)
  791.      dat |= 0x80 ;
  792.     Delay(4) ;
  793.   }

  795.     return (dat) ;
  796. }

  798. /* 写一个字节                                         */
  799. /*******************************************************************/
  800. WriteOneChar(unsigned char dat)
  801. {
  802.   unsigned char i = 0 ;
  803.   for (i = 8 ; i > 0 ; i--)
  804.   {
  805.     DQ = 0 ;
  806.     DQ = dat&0x01 ;
  807.     Delay(5) ;

  809.     DQ = 1 ;
  810.     dat>>=1 ;
  811.   }
  812. }

  814. /* 读取温度                            */
  815. /*******************************************************************/
  816. Read_Temperature(void)
  817. {
  818.      Init_DS18B20() ;
  819.   
  820.      WriteOneChar(0xCC) ;  // 跳过读序号列号的操作
  821.      WriteOneChar(0x44) ;  // 启动温度转换

  823.      Init_DS18B20() ;
  824.      WriteOneChar(0xCC) ;  //跳过读序号列号的操作
  825.      WriteOneChar(0xBE) ;  //读取温度寄存器

  827.      temp_data[0] = ReadOneChar() ;   //温度低8位
  828.      temp_data[1] = ReadOneChar() ;   //温度高8位
  829. }

  831. /* 数据转换与温度显示                                              */
  832. /*******************************************************************/
  833. void Disp_Temperature()
  834. {
  835.   temp_ram[4]=temp_data[0]&0x0f ;
  836.   temp_ram[0]=ditab[temp_ram[4]]+0x30 ;     //查表得小数位的值
  837.   
  838.   temp_ram[4]=((temp_data[0]&0xf0)>>4)|((temp_data[1]&0x0f)<<4) ;
  839.   temp_ram[3]=temp_ram[4]/100+0x30 ;
  840.   temp_ram[1]=temp_ram[4]%100 ;
  841.   temp_ram[2]=temp_ram[1]/10+0x30 ;
  842.   temp_ram[1]=temp_ram[1]%10+0x30 ;

  844.     if(temp_ram[3]==0x30)        //高位为0，不显示
  845.    {
  846.      temp_ram[3]=0x20 ;              
  847.      if(temp_ram[2]==0x30)      //次高位为0，不显示
  848.      temp_ram[2]=0x20 ;
  849.    }

  851. }
  852. /*
  853. void start_time(){
  854.         Time.Year = 0x10;
  855.         Time.Month = 0x7;
  856.         Time.Day = 0x23;
  857.         Time.Hour = 0x21;
  858.         Time.Minute = 0x58;
  859.         Time.Second = 0x0;
  860.         Time.Week = 0x5;
  861. }*/

  863. //=================
  864. //****校时函数****
  865. //=================
  866. void Change_Time(){
  867.         //
  868.         MSG_MV = MSG_MV_L;
  869.         move_times = 0;
  870.         start_word=0;
  871.         TMP_TIME = Time.Hour;
  872.         TR1 = 1;                //开启定时器1闪烁
  873.         do{
  874.                 switch(CHANGE){
  875.                                 case CHG_HOUR:
  876.                                 case CHG_MIN:
  877.                                 case CHG_SEC:
  878.                                         Put_Tdispram(0);
  879.                                         break;
  880.                                 case CHG_MON:
  881.                                 case CHG_DAY:
  882.                                         Put_Ddispram(0);
  883.                                         break;
  884.                                 case CHG_WEEK:
  885.                                         Put_Kdispram(0);
  886.                                         break;
  887.                                 case CHG_YEAR:
  888.                                         Put_Ydispram(0);
  889.                                         break;
  890.                                 default:
  891.                                         break;
  892.                                 }        
  893.                 Show_sWord();
  894.                 //if(!key_done)
  895.                 //        ReadKey1();
  896.                 }while(ReadKey1() != KEY3_S && exit < 10);                //MSG_KEY
  897.         Change_obj();        //保证退出校时无隐身
  898.         HIDE = 0;
  899.         key_done = 0;
  900.         //key_done = 1;        //按键事件处理完成
  901.         TR1 = 0;                //关闭定时器1闪烁                                       
  902.         
  903. }
  904. //==================
  905. //****对象切换****
  906. //==================
  907. void Change_obj(){
  908.         switch(CHANGE){
  909.                                 case CHG_HOUR:
  910.                                         if(Time.Hour == 0xcc)
  911.                                                 Time.Hour = TMP_TIME;
  912.                                         TMP_TIME = Time.Minute;
  913.                                         break;
  914.                                 case CHG_MIN:
  915.                                         if(Time.Minute == 0xcc)
  916.                                                 Time.Minute = TMP_TIME;
  917.                                         TMP_TIME = Time.Second;
  918.                                         break;
  919.                                 case CHG_SEC:
  920.                                         if(Time.Second == 0xcc)
  921.                                                 Time.Second = TMP_TIME;
  922.                                         TMP_TIME = Time.Month;
  923.                                         break;
  924.                                 case CHG_MON:
  925.                                         if(Time.Month == 0xcc)
  926.                                                 Time.Month = TMP_TIME;
  927.                                         TMP_TIME = Time.Day;
  928.                                         break;
  929.                                 case CHG_DAY:
  930.                                         if(Time.Day == 0xcc)
  931.                                                 Time.Day = TMP_TIME;
  932.                                         TMP_TIME = Time.Week;
  933.                                         break;
  934.                                 case CHG_WEEK:
  935.                                         if(Time.Week == 0xcc)
  936.                                                 Time.Week = TMP_TIME;
  937.                                         TMP_TIME = Time.Year;
  938.                                         break;
  939.                                 case CHG_YEAR:
  940.                                         if(Time.Year == 0xcc)
  941.                                                 Time.Year = TMP_TIME;
  942.                                         TMP_TIME = Time.Hour;
  943.                                         break;
  944.                                 default:
  945.                                         break;
  946.                                 }
  947. }
  948. //==================
  949. //****加加函数****
  950. //功能: 0x19 ++  =0x20
  951. //==================
  952. uchar Add_num(char *num){
  953.         ++(*num);
  954.         if(((*num) & 0x0f) == 0x0a){
  955.                 *num += 0x10;
  956.                 *num &= 0xf0;
  957.                 }
  958.         return *num;
  959. }
  960. //==================
  961. //****校时加加****
  962. //==================
  963. void Add_Time(){
  964.         switch(CHANGE){
  965.                                 case CHG_HOUR:
  966.                                         if(HIDE){
  967.                                                 if(Add_num(&TMP_TIME) == 0x24)
  968.                                                         TMP_TIME= 0;
  969.                                                 }
  970.                                         else{
  971.                                                 if(Add_num(&Time.Hour) == 0x24)
  972.                                                         Time.Hour = 0;
  973.                                                 }
  974.                                         break;
  975.                                 case CHG_MIN:
  976.                                         if(HIDE){
  977.                                                 if(Add_num(&TMP_TIME) == 0x60)
  978.                                                         TMP_TIME= 0;
  979.                                                 }
  980.                                         else{
  981.                                                 if(Add_num(&Time.Minute) == 0x60)
  982.                                                         Time.Minute= 0;
  983.                                                 }
  984.                                         break;
  985.                                 case CHG_SEC:
  986.                                         if(HIDE){
  987.                                                 if(Add_num(&TMP_TIME) == 0x60)
  988.                                                         TMP_TIME= 0;
  989.                                                 }
  990.                                         else{
  991.                                                 if(Add_num(&Time.Second) == 0x60)
  992.                                                         Time.Second = 0;
  993.                                                 }
  994.                                         break;
  995.                                 case CHG_MON:
  996.                                         if(HIDE){
  997.                                                 if(Add_num(&TMP_TIME) == 0x13)
  998.                                                         TMP_TIME= 0;
  999.                                                 }
  1000.                                         else{
  1001.                                                 if(Add_num(&Time.Month) == 0x13)
  1002.                                                         Time.Month= 1;
  1003.                                                 }
  1004.                                         break;
  1005.                                 case CHG_DAY:
  1006.                                         if(HIDE){
  1007.                                                 if(Add_num(&TMP_TIME) == 0x32)
  1008.                                                         TMP_TIME= 0;
  1009.                                                 }
  1010.                                         else{
  1011.                                                 if(Add_num(&Time.Day) == 0x32)
  1012.                                                         Time.Day= 0;
  1013.                                                 }
  1014.                                         break;
  1015.                                 case CHG_WEEK:
  1016.                                         if(HIDE){
  1017.                                                 if(Add_num(&TMP_TIME) == 0x08)
  1018.                                                         TMP_TIME= 1;
  1019.                                                 }
  1020.                                         else{
  1021.                                                 if(Add_num(&Time.Week) == 0x08)
  1022.                                                         Time.Week= 1;
  1023.                                                 }
  1024.                                         break;
  1025.                                 case CHG_YEAR:
  1026.                                         if(HIDE){
  1027.                                                 if(Add_num(&TMP_TIME) == 0xa0)
  1028.                                                         TMP_TIME = 0;
  1029.                                                 }
  1030.                                         else{
  1031.                                                 if(Add_num(&Time.Year) == 0xa0)
  1032.                                                         Time.Year = 0;
  1033.                                                 }
  1034.                                         //if(Add_num(&Time.Year) == 0x24)
  1035.                                         //        Time.Year= 0;
  1036.                                         break;
  1037.                                 default:
  1038.                                         break;
  1039.                                 }
  1040. }
  1041. //==================
  1042. //****减减函数****
  1043. //功能: 0x20 --  =0x19
  1044. //==================
  1045. uchar Cut_num(char *num){
  1046.         --(*num);
  1047.         if(((*num)&0x0f) == 0x0f){
  1048.                 //*num -= 0x10;
  1049.                 *num &= 0xf9;
  1050.         }
  1051.         //if((*num == 0xf9)
  1052.                 //*num = 0x99;
  1053.         return *num;
  1054. }
  1055. //==================
  1056. //****校时减减****
  1057. //==================
  1058. void Cut_Time(){
  1059.         switch(CHANGE){
  1060.                                 case CHG_HOUR:
  1061.                                         if(HIDE){
  1062.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1063.                                                         TMP_TIME= 0x23;
  1064.                                                 }
  1065.                                         else{
  1066.                                                 if(Cut_num(&Time.Hour) == 0xf9)
  1067.                                                         Time.Hour = 0x23;
  1068.                                                 }
  1069.                                         break;
  1070.                                 case CHG_MIN:
  1071.                                         if(HIDE){
  1072.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1073.                                                         TMP_TIME= 0x59;
  1074.                                                 }
  1075.                                         else{
  1076.                                                 if(Cut_num(&Time.Minute) == 0xf9)
  1077.                                                         Time.Minute= 0x59;
  1078.                                                 }
  1079.                                         break;
  1080.                                 case CHG_SEC:
  1081.                                         if(HIDE){
  1082.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1083.                                                         TMP_TIME= 0x59;
  1084.                                                 }
  1085.                                         else{
  1086.                                                 if(Cut_num(&Time.Second) == 0xf9)
  1087.                                                         Time.Second = 0x59;
  1088.                                                 }
  1089.                                         break;
  1090.                                 case CHG_MON:
  1091.                                         if(HIDE){
  1092.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1093.                                                         TMP_TIME= 0x12;
  1094.                                                 }
  1095.                                         else{
  1096.                                                 if(Cut_num(&Time.Month) == 0xf9)
  1097.                                                         Time.Month= 0x12;
  1098.                                                 }
  1099.                                         break;
  1100.                                 case CHG_DAY:
  1101.                                         if(HIDE){
  1102.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1103.                                                         TMP_TIME= 0x31;
  1104.                                                 }
  1105.                                         else{
  1106.                                                 if(Cut_num(&Time.Day) == 0xf9)
  1107.                                                         Time.Day= 0x31;
  1108.                                                 }
  1109.                                         break;
  1110.                                 case CHG_WEEK:
  1111.                                         if(HIDE){
  1112.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1113.                                                         TMP_TIME= 0x7;
  1114.                                                 }
  1115.                                         else{
  1116.                                                 if(Cut_num(&Time.Week) == 0xf9)
  1117.                                                         Time.Week= 0x7;
  1118.                                                 }
  1119.                                         break;
  1120.                                 case CHG_YEAR:
  1121.                                         if(HIDE){
  1122.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1123.                                                         TMP_TIME= 0x99;
  1124.                                                 }
  1125.                                         else{
  1126.                                                 if(Cut_num(&Time.Year) == 0xf9)
  1127.                                                         Time.Year = 0x99;
  1128.                                                 }
  1129.                                         //if(Cut_num(&Time.Year) == 0x99)
  1130.                                         //        Time.Year= 0;
  1131.                                         break;
  1132.                                 default:
  1133.                                         break;
  1134.                                 }
  1135. }

  1137. //======按键======
  1138. uchar ReadKey(){
  1139.         //
  1140.         if(!key_done){
  1141.         switch(MSG_KEY){
  1142.                 case KEY0_S:STATE = STA_sTIME;
  1143.                                         break;
  1144.                 case KEY1_S:STATE = STA_gWORD;        //STA_sWEEK
  1145.                                         break;
  1146.                 case KEY2_S:STATE = STA_gTEMP;
  1147.                                         break;
  1148.                 case KEY3_S:STATE = STA_gTIME;
  1149.                                         break;
  1150.                 case KEY0_L:STATE = STA_CHG;
  1151.                                         break;
  1152.                 case KEY1_L:STATE = STA_SONG;
  1153.                                         break;
  1154.                 case KEY2_L:STATE = STA_gTEMP;
  1155.                                         break;
  1156.                 case KEY3_L:STATE = STA_gWORD;        //STA_sTIME
  1157.                                         break;
  1158.                 default:        break;
  1159.                 }
  1160.                 }
  1161.         key_done = 1;        //按键事件处理完成
  1162.         return MSG_KEY;        
  1163. }
  1164. //=======================
  1165. //****校时按键处理****
  1166. //=======================
  1167. uchar ReadKey1(){
  1168.         //
  1169.         if(!key_done){
  1170.         switch(MSG_KEY){
  1171.                 case KEY0_S:                //切换校时对象
  1172.                 case KEY0_L:
  1173.                                         exit = 0;
  1174.                                         TR1 = 0;                //关闭定时器1闪烁
  1175.                                         Change_obj();
  1176.                                         if(CHANGE++ >= CHG_YEAR)
  1177.                                                 CHANGE = CHG_HOUR;
  1178.                                         TR1 = 1;                //开启定时器1闪烁
  1179.                                         break;
  1180.                 case KEY1_S:                //加加
  1181.                 case KEY1_L:
  1182.                                         exit = 0;
  1183.                                         TR1 = 0;                //关闭定时器1闪烁
  1184.                                         Add_Time();
  1185.                                         TR1 = 1;                //开启定时器1闪烁
  1186.                                         break;
  1187.                 case KEY2_S:                //减减
  1188.                 case KEY2_L:
  1189.                                         exit = 0;
  1190.                                         TR1 = 0;                //关闭定时器1闪烁
  1191.                                         Cut_Time();
  1192.                                         TR1 = 1;                //开启定时器1闪烁
  1193.                                         break;
  1194.                 case KEY3_L:
  1195.                 case KEY3_S:
  1196.                                         return KEY3_S;
  1197.                 default:        break;
  1198.                 }
  1199.                 }
  1200.         key_done = 1;        //按键事件处理完成
  1201.         return 0;
  1202. }
  1203. //===========================
  1204. void Tinit(){
  1205.         TMOD = 0x11;
  1206.         TH0 = 0xD8;
  1207.         TL0 = 0xF0;
  1208.         TH1 = 0x42;
  1209.         TL1 = 0xCA;
  1210.         TR0 = 1;
  1211.         //TR1 = 1;
  1212.         ET0 = 1;
  1213.         ET1 = 1;
  1214.         EA = 1;
  1215. }

  1217. timer0() interrupt 1{
  1218.         TH0 = 0xb1;
  1219.         TL0 = 0xe0;

  1221.         if(P1 != 0xff) {//若有键按下
  1222.                 cur_key_val = P1&0x0f;        //记录按键值
  1223.                 if(key_times < 150)
  1224.                         key_times++;  
  1225.                 else{
  1226.                         key_keep_times++;         //长按连击
  1227.                         if(key_keep_times >= 10){  //10 1秒连击10次
  1228.                                 key_keep_times = 0;
  1229.                                 MSG_KEY = 0x10 | cur_key_val;
  1230.                                 key_done = 0;        //按键事件复位
  1231.                                 }
  1232.                         }         
  1233.         }else{
  1234.                 if(key_times > 2 && key_times < 100 && key_done){        //短按键
  1235.                         MSG_KEY = cur_key_val;
  1236.                         key_done = 0;         //按键事件复位
  1237.                         }
  1238.                 else if(key_times >= 100 && key_done){        //长按键
  1239.                         MSG_KEY = 0x10 | cur_key_val;
  1240.                         key_done = 0;         //按键事件复位
  1241.                         }
  1242.                 key_times = 0;        
  1243.                 key_keep_times = 0;
  1244.                 }
  1245. }

  1247. timer1() interrupt 3{
  1248.         if(STATE == STA_CHG){
  1249.                 TH1 = 0x42;
  1250.                 TL1 = 0xCA;
  1251.                 if(hide_times++ == 8){
  1252.                         HIDE = 0;        //显示
  1253.                         switch(CHANGE){
  1254.                                 case CHG_HOUR:
  1255.                                         Time.Hour =TMP_TIME;
  1256.                                         break;
  1257.                                 case CHG_MIN:
  1258.                                         Time.Minute = TMP_TIME;
  1259.                                         break;
  1260.                                 case CHG_SEC:
  1261.                                         Time.Second = TMP_TIME;
  1262.                                         break;
  1263.                                 case CHG_MON:
  1264.                                         Time.Month = TMP_TIME;
  1265.                                         break;
  1266.                                 case CHG_DAY:
  1267.                                         Time.Day = TMP_TIME;
  1268.                                         break;
  1269.                                 case CHG_WEEK:
  1270.                                         Time.Week = TMP_TIME;
  1271.                                         break;
  1272.                                 case CHG_YEAR:
  1273.                                         Time.Year = TMP_TIME;
  1274.                                         break;
  1275.                                 default:
  1276.                                         break;
  1277.                                 }
  1278.                  }
  1279.                  if(hide_times > 17){
  1280.                          hide_times = 0;
  1281.                         HIDE = 1;        //隐藏
  1282.                         exit++;
  1283.                         switch(CHANGE){
  1284.                                 case CHG_HOUR:
  1285.                                         TMP_TIME = Time.Hour;
  1286.                                         Time.Hour = 0xcc;
  1287.                                         break;
  1288.                                 case CHG_MIN:
  1289.                                         TMP_TIME = Time.Minute;
  1290.                                         Time.Minute = 0xcc;
  1291.                                         break;
  1292.                                 case CHG_SEC:
  1293.                                         TMP_TIME = Time.Second;
  1294.                                         Time.Second = 0xcc;
  1295.                                         break;
  1296.                                 case CHG_MON:
  1297.                                         TMP_TIME = Time.Month;
  1298.                                         Time.Month = 0xcc;
  1299.                                         break;
  1300.                                 case CHG_DAY:
  1301.                                         TMP_TIME = Time.Day;
  1302.                                         Time.Day = 0xcc;
  1303.                                         break;
  1304.                                 case CHG_WEEK:
  1305.                                         TMP_TIME = Time.Week;
  1306.                                         Time.Week = 0xcc;
  1307.                                         break;
  1308.                                 case CHG_YEAR:
  1309.                                         TMP_TIME = Time.Year;
  1310.                                         Time.Year = 0xcc;
  1311.                                         break;
  1312.                                 default:
  1313.                                         break;
  1314.                                 }
  1315.                 }
  1316.         }
  1317. }

  1319. void Compute_State(){
  1320.         switch(Time.Second){
  1321.                 case 0x1:
  1322.                         //STATE = STA_gTIME;
  1323.                         break;
  1324.                 case 0x2:
  1325.                         STATE = STA_sYEAR;
  1326.                         break;
  1327.                 case 0x15:
  1328.                         STATE = STA_sTEMP;
  1329.                         break;
  1330.                 case 0x31:
  1331.                         STATE = STA_sDATE;
  1332.                         break;
  1333.                 case 0x40:
  1334.                         STATE = STA_sWEEK;
  1335.                         break;
  1336.                 case 0x50:
  1337.                         STATE = STA_sTEMP;
  1338.                         break;
  1339.                 default:
  1340.                         break;
  1341.                 }
  1342.         if(Time.Minute%2 == 0 && Time.Second == 0)
  1343.                 STATE = STA_gTIME;
  1344.         if((Time.Minute&0x0f)%5 == 0 && Time.Second == 30)
  1345.                 STATE = STA_gTEMP;
  1346.         if((Time.Minute&0x0f) == 7 && Time.Second == 0)
  1347.                 STATE = STA_gWORD;
  1348.         if((Time.Minute&0x0f) == 3 && Time.Second == 0)
  1349.                 STATE = STA_SONG;
  1350. }
  1351. //;---------主程序循环--------------
  1352.                    void main()
  1353.                 {
  1354.                         int i;
  1355.                         initial();
  1356.                         Tinit();
  1357.                         Init_DS1302();
  1358.                         Read_TIME();        //读取时间
  1359.                         Read_Temperature();
  1360.                         Show_Cpyrt();
  1361.                         //start_time();
  1362.                         //write_time1302();
  1363.                         MSG_MV = MSG_MV_L;
  1364.                         STATE        = STA_sTIME;
  1365.                         while(1)
  1366.                         {
  1367.                            ReadKey();
  1368.                                 switch(STATE){
  1369.                                         case STA_gTIME:
  1370.                                                 //添加代码
  1371.                                                 MSG_MV = MSG_MV_L;
  1372.                                                 move_times = 0;
  1373.                                                 start_word=0;
  1374.                                                 Read_TIME();        //读取时间
  1375.                                                 Show_All_Info();
  1376.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1377.                                                 key_done = 0;
  1378.                                                 break;
  1379.                                         case STA_gTEMP:
  1380.                                                 Put_Wdispram(TMP_WORDS); //,start_word++
  1381.                                                 Read_Temperature();
  1382.                                                   Disp_Temperature();
  1383.                                                   Put_gTEMP();
  1384.                                                 //Move_Down();
  1385.                                                   Show_Move_Word(TMP_WORDS);
  1386.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1387.                                                 key_done = 0;
  1388.                                                 break;
  1389.                                         case STA_gWORD:
  1390.                                                 //添加代码
  1391.                                                 Put_Wdispram(MY_WORDS); //,start_word++         
  1392.                                                 //Move_Down();
  1393.                                                   Show_Move_Word(MY_WORDS);
  1394.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1395.                                                 key_done = 0;
  1396.                                                 break;
  1397.                                         case STA_sTIME:
  1398.                                                 //添加代码
  1399.                                                 MSG_MV = MSG_MV_L;
  1400.                                                 move_times = 0;
  1401.                                                 start_word=0;
  1402.                                                 Read_TIME();        //读取时间
  1403.                                                 Put_Tdispram(0);        
  1404.                                                 Show_sWord();
  1405.                                                 Compute_State();
  1406.                                                 break;
  1407.                                         case STA_sDATE:
  1408.                                                 //添加代码
  1409.                                                 MSG_MV = MSG_MV_L;
  1410.                                                 move_times = 0;
  1411.                                                 start_word=0;
  1412.                                                 Read_TIME();        //读取时间
  1413.                                                 Put_Ddispram(8);
  1414.                                                 Move_Down();
  1415.                                                 Put_Ddispram(0);
  1416.                                                 for(i=0;i<8;i++)
  1417.                                                         Show_sWord();
  1418.                                                 Read_TIME();
  1419.                                                 Put_Tdispram(8);
  1420.                                                 Move_Up();
  1421.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1422.                                                 key_done = 0;
  1423.                                                 break;
  1424.                                         case STA_sWEEK:
  1425.                                                 //添加代码
  1426.                                                 MSG_MV = MSG_MV_L;
  1427.                                                 move_times = 0;
  1428.                                                 start_word=0;
  1429.                                                 Read_TIME();        //读取时间
  1430.                                                 Put_Kdispram(8);
  1431.                                                 Move_Up();        //Move_Down();
  1432.                                                 for(i=0;i<8;i++){        
  1433.                                                         Read_TIME();        //读取时间
  1434.                                                         Put_Kdispram(0);
  1435.                                                         Show_sWord();
  1436.                                                         }
  1437.                                                 Read_TIME();
  1438.                                                 Put_Tdispram(8);
  1439.                                                 Move_Down();        //Move_Up();
  1440.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1441.                                                 key_done = 0;
  1442.                                                 break;
  1443.                                         case STA_sYEAR:
  1444.                                                 MSG_MV = MSG_MV_L;
  1445.                                                 move_times = 0;
  1446.                                                 start_word=0;
  1447.                                                 Read_TIME();        //读取时间
  1448.                                                 Put_Ydispram(8);
  1449.                                                 Move_Down();
  1450.                                                 for(i=0;i<8;i++){        
  1451.                                                         Read_TIME();        //读取时间
  1452.                                                         Put_Ydispram(0);
  1453.                                                         Show_sWord();
  1454.                                                         }
  1455.                                                 Read_TIME();
  1456.                                                 Put_Tdispram(8);
  1457.                                                 Move_Up();
  1458.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1459.                                                 key_done = 0;
  1460.                                                 break;
  1461.                                         case STA_sTEMP:
  1462.                                                 //添加代码
  1463.                                                 MSG_MV = MSG_MV_L;
  1464.                                                 move_times = 0;
  1465.                                                 start_word=0;
  1466.                                                 Read_Temperature();
  1467.                                                   Disp_Temperature();
  1468.                                                 Put_sTEMP(8);
  1469.                                                 Move_Up();        //Move_Down();
  1470.                                                 for(i=0;i<8;i++)        {
  1471.                                                         Read_Temperature();
  1472.                                                           Disp_Temperature();
  1473.                                                         Put_sTEMP(0);
  1474.                                                         Show_sWord();
  1475.                                                         }
  1476.                                                 Read_TIME();
  1477.                                                 Put_Tdispram(8);
  1478.                                                 Move_Down();        //Move_Up();
  1479.                                                 MSG_KEY = KEY0_S;        //回到时间画面
  1480.                                                 key_done = 0;
  1481.                                                 break;
  1482.                                         case STA_sWORD:
  1483.                                                 //添加代码
  1484.                                                 break;
  1485.                                         case STA_CHG:
  1486.                                                 //校时模式
  1487.                                                 Change_Time();
  1488.                                                 write_time1302();
  1489.                                                 Read_TIME();
  1490.                                                 Put_Tdispram(8);
  1491.                                                 Move_Up();
  1492.                                                 MSG_KEY = KEY0_S;
  1493.                                                 break;
  1494.                                         case STA_SONG:
  1495.                                                 MSG_MV = MSG_MV_L;
  1496.                                                 move_times = 0;
  1497.                                                 start_word=0;
  1498.                                                 Show_Song();
  1499.                                                 MSG_KEY = KEY0_S;
  1500.                                                 key_done = 0;
  1501.                                                 break;
  1502.                                         default:
  1503.                                                 break;
  1504.                                          }
  1505.                         }
  1506.                  }

复制代码

所有资料51hei提供下载:
点阵时钟proteus仿真.rar (209.37 KB, 下载次数: 92)

评分

参与人数 1黑币 +90 收起 理由
admin + 90 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:1 发表于 2019-3-5 15:47 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表