单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2348|回复: 3
打印 上一主题 下一主题
收起左侧

单片机点阵时钟原理图和源码

[复制链接]
跳转到指定楼层
楼主
这是单片机点阵时钟的程序和proteus图,欢迎大家指正

原理图大家执行解压后用protel99打开.


单片机源程序如下:
  1. //LED点阵时钟程序
  2. //作者:刘宁
  3. //--------------------------------
  4. #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;

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

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

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


  94. //=========================================
  95. //****18B20****
  96. sbit DQ = P0^7
  97. ;  //定义DS18B20端口DQ  

  98. unsigned char data  temp_data[2] = {0x00,0x00} ;
  99. unsigned char data  temp_ram[5] =   {0x00,0x00,0x00,0x00,0x00} ;
  100. unsigned char code  ditab[16] =    {0x00,0x01,0x01,0x02,0x03,0x03,0x04,0x04,
  101.                                     0x05,0x06,0x06,0x07,0x08,0x08,0x09,0x09};
  102. //==========================================
  103. bit presence  ;
  104. uchar SendData;                  //要发送的数据变量
  105. uchar hang;                        //行扫描变量  (半屏只有16行,所以hang=0到15)
  106. uchar move_times = 0;        //左右移动位数
  107. uchar start_word = 0;


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


  110. void  Keyscan (void); //修改参数按键扫描子程序
  111. void  Sendping(); //发送半屏子程序
  112. void  Put_Wdispram(uchar first_word);//
  113. void  Put_Hdispram(); //把显示文字放入显示缓存
  114. void  Move_Left();        //左移
  115. void  Move_Right();        //右移
  116. void  RL_Move();
  117. void  UD_Move();
  118. void  Show_Line();
  119. void  Show_Move_Word(uchar code *WORDS[][8]);
  120. void  delay();
  121. void  SendByte(void);
  122. void  RowsCan(void);
  123. void  Disp_Temperature();
  124. void Put_gTEMP();
  125. void Change_obj();

  126. uchar ReadKey1();



  127. uchar code MY_WORDS[][16]=
  128.                                         {
  129. {0x10,0x08,0x04,0x7F,0x01,0x21,0x12,0x0A,0x04,0x06,0x0A,0x11,0x21,0x41,0x80,0x00},
  130. {0x04,0x04,0x04,0xA4,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x04,0x84,0x14,0x08,0x00},/*"刘",0*/
  131. {0x02,0x01,0x3F,0x20,0x40,0x00,0x00,0x7F,0x01,0x01,0x01,0x01,0x01,0x01,0x05,0x02},
  132. {0x00,0x04,0xFE,0x04,0x08,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"宁",1*/
  133. {0x01,0x01,0x01,0x01,0x01,0x1F,0x10,0x10,0x10,0x1F,0x10,0x01,0x28,0x24,0x44,0x00},
  134. {0x00,0x00,0xF8,0x00,0x10,0xF8,0x10,0x10,0x10,0xF0,0x10,0x10,0x88,0x44,0x44,0x00},/*"点",2*/
  135. {0x00,0xF8,0x88,0x97,0xA1,0x91,0x8A,0x8F,0x88,0xA8,0x97,0x80,0x80,0x80,0x80,0x80},
  136. {0x80,0x80,0x80,0xFC,0x00,0x40,0x40,0xFC,0x40,0x40,0xFE,0x40,0x40,0x40,0x40,0x40},/*"阵",3*/
  137. {0x00,0x00,0x3F,0x00,0x00,0x00,0xFF,0x03,0x07,0x06,0x0C,0x18,0x31,0x7F,0x20,0x00},
  138. {0x00,0x30,0xF8,0x00,0x00,0x0C,0xFE,0x00,0x00,0x40,0x20,0x10,0xF8,0x0C,0x08,0x00},/*"云",0*/
  139. {0x01,0x01,0xFF,0x01,0x02,0x3F,0x24,0x22,0x2F,0x21,0x3F,0x21,0x21,0x21,0x21,0x00},
  140. {0x00,0x04,0xFE,0x00,0x00,0xFC,0x24,0x44,0xF4,0x04,0xFC,0x04,0x04,0x14,0x08,0x00},/*"南",1*/
  141. {0x02,0x02,0x04,0x3F,0x20,0x20,0x20,0x20,0x3F,0x20,0x20,0x20,0x20,0x3F,0x20,0x00},
  142. {0x00,0x00,0x00,0xF8,0x08,0x08,0x08,0x08,0xF8,0x08,0x08,0x08,0x08,0xF8,0x08,0x00},/*"白",2*/
  143. {0x04,0x04,0x7F,0x04,0x14,0x10,0x24,0x7C,0x09,0x10,0x7E,0x20,0x06,0x78,0x20,0x00},
  144. {0x40,0x40,0xFE,0x40,0x40,0x40,0x7C,0x84,0x04,0x44,0x24,0x24,0x04,0x04,0x28,0x10},/*"药",3*/
  145. {0x08,0x08,0x1F,0x10,0x20,0x4F,0x00,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},



  146.                                         };

  147. uchar code NO_WORDS[][16]={

  148. {0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00},/*"0",0*/
  149. {0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00},/*"1",1*/
  150. {0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00},/*"2",2*/
  151. {0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00},/*"3",3*/
  152. {0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00},/*"4",4*/
  153. {0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00},/*"5",5*/
  154. {0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00},/*"6",6*/
  155. {0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00},/*"7",7*/
  156. {0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00},/*"8",8*/
  157. {0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00},/*"9",9*/
  158. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"-",10*/
  159. {0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00},/*":",11*/
  160. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"空格",12*/
  161.                                                 };
  162. uchar code TMP_WORDS[][16]={


  163. {0x02,0x01,0x3F,0x20,0x40,0x3F,0x04,0x08,0x1F,0x01,0x01,0x3F,0x01,0x01,0xFF,0x00},
  164. {0x00,0x00,0xFE,0x04,0x08,0xFC,0x00,0x20,0xF0,0x10,0x00,0xF8,0x00,0x00,0xFE,0x00},/*"室",3*/
  165. {0x40,0x27,0x24,0x07,0x94,0x54,0x17,0x20,0x2F,0xC9,0x49,0x49,0x49,0x49,0x5F,0x40},
  166. {0x00,0xF0,0x10,0xF0,0x10,0x10,0xF0,0x00,0xFC,0x24,0x24,0x24,0x24,0x24,0xFE,0x00},/*"温",4*/
  167. {0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00},/*":",5*/
  168. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",6*/
  169. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",7*/
  170. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",8*/
  171. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00},/*".",9*/
  172. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",10*/
  173. {0x00,0xC0,0xC0,0x3E,0x42,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x44,0x38,0x00,0x00},/*"C",11*/
  174.                                                         };
  175. uchar code TIME_WORDS[][16]={

  176. {0x01,0x01,0x02,0x04,0x08,0x12,0x21,0xC0,0x00,0x1F,0x00,0x00,0x00,0x00,0x00,0x01},
  177. {0x00,0x00,0x80,0x40,0x20,0x18,0x8E,0x84,0x00,0xF0,0x20,0x20,0x40,0x40,0x80,0x00},/*"今",0*/
  178. {0x00,0x3F,0x01,0x01,0x01,0x01,0x7F,0x01,0x01,0x02,0x02,0x04,0x08,0x10,0x20,0x40},
  179. {0x00,0xFC,0x00,0x00,0x00,0x00,0xFE,0x00,0x00,0x80,0x40,0x20,0x18,0x0E,0x04,0x00},/*"天",1*/
  180. {0x00,0x0F,0x08,0x0F,0x08,0x0F,0x00,0xFF,0x01,0x09,0x09,0x09,0x15,0x23,0x40,0x00},
  181. {0x00,0xF0,0x10,0xF0,0x10,0xF0,0x00,0xFE,0x00,0x00,0xF8,0x00,0x00,0x00,0xFE,0x00},/*"是",2*/

  182. {0x08,0x0F,0x10,0x10,0x20,0x4F,0x88,0x08,0x08,0x08,0xFF,0x00,0x00,0x00,0x00,0x00},
  183. {0x00,0xFC,0x80,0x80,0x80,0xF8,0x80,0x80,0x80,0x80,0xFE,0x80,0x80,0x80,0x80,0x80},/*"年",1*/
  184. {0x07,0x04,0x04,0x04,0x07,0x04,0x04,0x04,0x07,0x04,0x08,0x08,0x10,0x20,0x40,0x00},
  185. {0xF0,0x10,0x10,0x10,0xF0,0x10,0x10,0x10,0xF0,0x10,0x10,0x10,0x10,0x50,0x20,0x00},/*"月",2*/
  186. {0x00,0x1F,0x10,0x10,0x10,0x10,0x1F,0x10,0x10,0x10,0x10,0x10,0x1F,0x10,0x00,0x00},
  187. {0x00,0xF0,0x10,0x10,0x10,0x10,0xF0,0x10,0x10,0x10,0x10,0x10,0xF0,0x10,0x00,0x00},/*"日",3*/
  188. {0x00,0x1F,0x10,0x1F,0x10,0x1F,0x01,0x11,0x1F,0x21,0x21,0x4F,0x01,0x01,0x7F,0x00},
  189. {0x00,0xF8,0x08,0xF8,0x08,0xF8,0x00,0x00,0xFC,0x00,0x00,0xF8,0x00,0x00,0xFE,0x00},/*"星",4*/
  190. {0x22,0x22,0x7F,0x22,0x3E,0x22,0x3E,0x22,0x22,0xFF,0x00,0x24,0x22,0x43,0x81,0x00},
  191. {0x00,0x7C,0x44,0x44,0x44,0x7C,0x44,0x44,0x44,0x7C,0x44,0x84,0x84,0x14,0x08,0x00},/*"期",5*/
  192.                                                 };
  193. uchar code WEEK_WORDS[][16]={
  194.        
  195. {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  196. {0x00,0x00,0x00,0x00,0x00,0x00,0x04,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"一",0*/
  197. {0x00,0x00,0x3F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00},
  198. {0x00,0x10,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0xFE,0x00,0x00,0x00},/*"二",1*/
  199. {0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00,0x00,0x7F,0x00,0x00},
  200. {0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0xFE,0x00,0x00},/*"三",2*/
  201. {0x00,0x7F,0x44,0x44,0x44,0x44,0x44,0x44,0x48,0x48,0x50,0x60,0x40,0x7F,0x40,0x00},
  202. {0x00,0xFC,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x7C,0x04,0x04,0x04,0xFC,0x04,0x00},/*"四",3*/
  203. {0x00,0x7F,0x02,0x02,0x02,0x02,0x02,0x3F,0x04,0x04,0x04,0x04,0x04,0xFF,0x00,0x00},
  204. {0x00,0xF8,0x00,0x00,0x00,0x00,0x20,0xF0,0x20,0x20,0x20,0x20,0x24,0xFE,0x00,0x00},/*"五",4*/
  205. {0x04,0x03,0x01,0x01,0xFF,0x00,0x00,0x04,0x06,0x04,0x08,0x08,0x10,0x20,0x40,0x00},
  206. {0x00,0x00,0x80,0x00,0xFE,0x00,0x00,0x80,0x40,0x20,0x10,0x18,0x0C,0x0C,0x08,0x00},/*"六",5*/
  207. {0x00,0x1F,0x10,0x10,0x10,0x10,0x1F,0x10,0x10,0x10,0x10,0x10,0x1F,0x10,0x00,0x00},
  208. {0x00,0xF0,0x10,0x10,0x10,0x10,0xF0,0x10,0x10,0x10,0x10,0x10,0xF0,0x10,0x00,0x00},/*"日",0*/

  209. };

  210. uchar code SONG_WORDS[][16] = {
  211.        
  212. {0x00,0x08,0x04,0x04,0x00,0x0F,0x01,0x01,0x7F,0x01,0x02,0x04,0x08,0x30,0x00,0x00},
  213. {0x40,0x40,0x40,0x80,0xE0,0x00,0x00,0xF8,0x00,0x00,0x80,0x40,0x30,0x1C,0x00,0x00},/*"关",0*/
  214. {0x00,0x08,0x04,0x04,0x00,0x0F,0x01,0x01,0x7F,0x01,0x02,0x04,0x08,0x30,0x00,0x00},
  215. {0x40,0x40,0x40,0x80,0xE0,0x00,0x00,0xF8,0x00,0x00,0x80,0x40,0x30,0x1C,0x00,0x00},/*"关",1*/
  216. {0x00,0x00,0x18,0x68,0x49,0x6B,0x4D,0x69,0x49,0x4D,0x71,0xC1,0x01,0x01,0x01,0x00},
  217. {0x40,0x40,0xA0,0x90,0x1C,0x70,0x1C,0x70,0x1C,0x70,0x10,0x1E,0x60,0x00,0x00,0x00},/*"雎",2*/
  218. {0x00,0x00,0x10,0x11,0x1D,0x75,0x15,0x15,0x17,0x25,0x24,0x40,0x87,0x00,0x00,0x00},
  219. {0x40,0x40,0xF0,0x10,0x50,0x10,0x70,0x00,0x1C,0xE4,0x04,0xF4,0x04,0x14,0x08,0x00},/*"鸠",3*/
  220. {0x01,0x01,0x01,0x01,0x1E,0x04,0x04,0x08,0x18,0x2B,0x48,0x88,0x0F,0x08,0x08,0x00},
  221. {0x00,0x00,0x00,0xF0,0x00,0x40,0x40,0x40,0x70,0xC0,0x40,0x7C,0x80,0x00,0x00,0x00},/*"在",4*/
  222. {0x00,0x10,0x08,0x07,0x40,0x21,0x06,0x04,0x13,0x10,0x20,0x20,0x20,0x00,0x00,0x00},
  223. {0x00,0x00,0x1E,0xF0,0x10,0x90,0x90,0x90,0x90,0x10,0x10,0x10,0x30,0x10,0x00,0x00},/*"河",5*/
  224. {0x00,0x04,0x02,0x00,0x03,0x3C,0x00,0x03,0x0C,0xF0,0x0C,0x03,0x00,0x00,0x00,0x00},
  225. {0x00,0x00,0x00,0x00,0xE0,0x40,0x80,0x00,0x00,0x00,0x00,0x80,0x7E,0x00,0x00,0x00},/*"之",6*/
  226. {0x00,0x00,0x20,0x12,0x02,0x82,0x4B,0x0A,0x2A,0x22,0x24,0x48,0x50,0x00,0x00,0x00},
  227. {0x00,0x08,0x08,0x48,0x48,0x48,0x68,0xD8,0x48,0x48,0x48,0x08,0x08,0x08,0x00,0x00},/*"洲",7*/
  228. {0x02,0x01,0x01,0x3E,0x24,0x18,0x08,0x10,0x25,0x38,0x12,0x2E,0x31,0x02,0x04,0x00},
  229. {0x00,0x00,0xF8,0x88,0x40,0x20,0x40,0x78,0xC8,0x48,0x88,0x90,0x50,0x20,0x00,0x00},/*"窈",8*/
  230. {0x02,0x01,0x11,0x1E,0x24,0x08,0x00,0x24,0x14,0x0C,0x74,0x04,0x08,0x10,0x20,0x00},
  231. {0x00,0x00,0xF8,0x88,0x40,0x00,0x90,0xA0,0xC0,0xA0,0x94,0x84,0x84,0x7C,0x00,0x00},/*"窕",9*/
  232. {0x00,0x02,0x22,0x13,0x02,0x83,0x5C,0x02,0x2B,0x2A,0x52,0xC3,0x06,0x02,0x00,0x00},
  233. {0x00,0x00,0x00,0x80,0x38,0x48,0x90,0x50,0x20,0x50,0x88,0x0E,0x00,0x00,0x00,0x00},/*"淑",10*/
  234. {0x02,0x02,0x02,0x02,0x02,0x02,0x07,0xFC,0x04,0x02,0x01,0x06,0x18,0x00,0x00,0x00},
  235. {0x00,0x00,0x00,0x00,0x00,0x40,0xFE,0x40,0x80,0x80,0x80,0x60,0x10,0x00,0x00,0x00},/*"女",11*/
  236. {0x00,0x01,0x0E,0x02,0x7F,0x02,0x03,0x3E,0x04,0x08,0x17,0x24,0xC4,0x07,0x00,0x00},
  237. {0x00,0xF0,0x10,0x1E,0xE0,0x20,0xE0,0x00,0x00,0xF0,0x10,0x10,0x70,0x80,0x00,0x00},/*"君",12*/
  238. {0x00,0x01,0x0E,0x00,0x01,0x01,0x7F,0x00,0x00,0x00,0x00,0x00,0x06,0x01,0x00,0x00},
  239. {0x00,0xE0,0x40,0x80,0x00,0x7C,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,0x00,0x00},/*"子",13*/
  240. {0x00,0x10,0x10,0x11,0x10,0x14,0x1E,0xE5,0x14,0x08,0x14,0x22,0x40,0x00,0x00,0x00},
  241. {0x00,0x00,0x78,0x90,0x20,0x40,0x3E,0xE0,0x20,0x20,0x20,0x20,0x60,0x20,0x00,0x00},/*"好",14*/
  242. {0x00,0x00,0x20,0x10,0x03,0x30,0xD4,0x22,0x21,0x22,0x15,0xF8,0x07,0x00,0x00,0x00},
  243. {0x80,0x90,0x88,0xF0,0x80,0x90,0xB0,0xC0,0xA0,0x90,0x88,0x00,0x80,0x7E,0x00,0x00},/*"逑",15*/

  244.                                 };
  245. uchar code CPYRT_WORDS[][16] = {

  246. {0x00,0x08,0x04,0x04,0x7B,0x01,0x22,0x12,0x0C,0x06,0x09,0x11,0x20,0x40,0x00,0x00},
  247. {0x00,0x02,0x04,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x04,0x04,0x0C,0x00,0x00},/*"刘",0*/
  248. {0x00,0x01,0x00,0x00,0x3F,0x60,0x00,0x3F,0x01,0x01,0x01,0x01,0x00,0x03,0x00,0x00},
  249. {0x00,0x00,0x80,0x04,0xFC,0x00,0x04,0xF8,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00},/*"宁",1*/
  250. {0x00,0x06,0x14,0x24,0x3F,0x44,0x7F,0x04,0x24,0x3F,0x24,0x24,0x25,0x04,0x00,0x00},
  251. {0x00,0x02,0x02,0x92,0x12,0x12,0xD2,0x12,0x52,0xD2,0x52,0x42,0x82,0x0C,0x04,0x00},/*"制",2*/
  252. {0x00,0x0C,0x08,0x09,0x11,0x1A,0x34,0x54,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x00},
  253. {0x00,0xC0,0x80,0x04,0xF8,0x40,0x40,0x7C,0x40,0x40,0x44,0x78,0x40,0x40,0x00,0x00},/*"作",3*/
  254. };

  255. void Put_Wdispram(uchar code *WORDS[][8]){        //,uchar first_word
  256.         uchar i;
  257.         disword[0] = &NO_WORDS[12][0];
  258.         for(i=1;i<25;i++){
  259.                 disword[i] = &WORDS[i-1][0];        //first_word+
  260.         }
  261. }       

  262. void  Put_Hdispram(){
  263.         uchar i;
  264.         for(i=0;i<10;i++){
  265.                 h_dispram[i] = *(disword[i+start_word]+hang);        //
  266.         }
  267. }

  268. void Move_Left(){
  269.         uchar i;
  270.         for(i=0;i<9;i++){
  271.                 h_dispram[i] = (h_dispram[i] << (move_times)) | (h_dispram[i+1] >> (8-move_times));
  272.         }
  273. }

  274. void Move_Right(){
  275.         uchar i;
  276.         for(i=9;i>0;i--){
  277.                 h_dispram[i] = (h_dispram[i] >> (move_times)) | (h_dispram[i-1] << (8-move_times));
  278.         }
  279. }

  280. void RL_Move(){
  281.         //
  282.         switch(MSG_MV){
  283.                 case MSG_MV_L:        //左移
  284.                         Move_Left();
  285.                         break;
  286.                 case MSG_MV_R:        //右移
  287.                         Move_Right();
  288.                         break;
  289.                 case MSG_NONE:
  290.                         break;
  291.                 default:
  292.                         break;
  293.                 }
  294. }

  295. void Move_Up(){
  296.         //
  297.         uchar i,j,m,n;
  298.         for(m=0;m<16;m++){
  299.                 for(n=0;n<4;n++){
  300.                         for(j=0;j<16-m;j++){
  301.                                 for(i=0;i<10;i++){
  302.                                         h_dispram[i] = *(disword[i]+m+j);                //
  303.                                 }
  304.                                 Show_Line();
  305.                         }
  306.                         for(j=16-m;j<16;j++){
  307.                                 for(i=0;i<10;i++){
  308.                                         h_dispram[i] = *(disword[i+8]+m+j-16);                //0x00
  309.                                 }
  310.                                 Show_Line();
  311.                         }
  312.                 }
  313.         }
  314. }

  315. void Move_Down(){
  316.         //
  317.         uchar i,j,m,n;
  318.         for(m=0;m<16;m++){
  319.                 for(n=0;n<4;n++){
  320.                         for(j=0;j<m;j++){
  321.                                 for(i=0;i<10;i++){
  322.                                         h_dispram[i] = *(disword[i+8]+15-m+j);                //
  323.                                 }
  324.                                 Show_Line();
  325.                         }
  326.                         for(j=m;j<16;j++){
  327.                                 for(i=0;i<10;i++){
  328.                                         h_dispram[i] = *(disword[i]-m+j);                //0x00
  329.                                 }
  330.                                 Show_Line();
  331.                         }
  332.                 }
  333.         }
  334. }

  335. void UD_Move(){
  336.         //
  337.         switch(MSG_MV){
  338.                 case MSG_MV_U:        //左移
  339.                 //        Move_Up();
  340.                         break;
  341.                 case MSG_MV_D:        //右移
  342.                 //        Move_Down();
  343.                         break;
  344.                 case MSG_NONE:
  345.                         break;
  346.                 default:
  347.                         break;
  348.                 }
  349. }

  350. void Show_Line(){
  351.         uchar m;
  352.         OE=1;
  353.         for(m =0;m<8;m++)  
  354.         {       
  355.                 SendData = h_dispram[m+1];
  356.                 SendByte();
  357.         }
  358.         STB = 0;
  359.         STB = 1;                 //上升沿数据锁存
  360.         RowsCan();                //行扫描
  361.         OE = 0;
  362. //        delay();        //
  363. }

  364. void Show_sWord(){
  365.         int m,i;//
  366.         hang = 0;
  367.         for(m=0;m<7;m++){
  368.                 for(i=0;i<16;i++){
  369.                         Put_Hdispram();        //把第i行放入行缓冲
  370.                         Show_Line();
  371.                         //delay();        //看需要
  372.                 }
  373.                
  374.         }
  375. }
  376. void Show_Move_Word(uchar code *WORDS[][8]){
  377.         int m,i;
  378.         while(1){
  379.         for(m=0;m<3;m++){        //若要上下移动 m=16
  380.                 //hang = 0;
  381.                 for(i=0;i<16;i++){
  382.                         Put_Hdispram();        //把第i行放入行缓冲
  383.                         RL_Move();        //是否要左右移动
  384.                         Show_Line();
  385.                         //delay();        //看需要
  386.                 }
  387.         //UD_Move();        //是否要上下移动
  388.         }
  389.         //========================================
  390.         //测试左移右移        切换时有跳变!!
  391. //        if(MSG_MV){
  392.                 move_times++;
  393.                 if((move_times == 9) && (MSG_MV == MSG_MV_L)){
  394.                         move_times = 1;
  395.                         Put_Wdispram(WORDS);
  396.                         start_word++;
  397.                         switch(STATE){
  398.                                 case STA_gTEMP:
  399.                                         Disp_Temperature();                                   //
  400.                                         Put_gTEMP();          //
  401.                                         if(start_word > (sizeof(TMP_WORDS)/16 - 8))
  402.                                                 MSG_MV = MSG_MV_R;
  403.                                         break;
  404.                                 case STA_gWORD:
  405.                                         if(start_word > (sizeof(MY_WORDS)/16 - 8))
  406.                                                 MSG_MV = MSG_MV_R;
  407.                                 default:
  408.                                         break;
  409.                         }
  410.                 if(start_word > (sizeof(TMP_WORDS)/16 - 4))
  411.                                 MSG_MV = MSG_MV_R;
  412.                 }
  413.                 else if((move_times == 9) && (MSG_MV == MSG_MV_R)){
  414.                         move_times = 1;
  415.                         Put_Wdispram(WORDS);  //
  416.                         start_word-- ;
  417.                         switch(STATE){
  418.                                 case STA_gTEMP:
  419.                                         Disp_Temperature();                                   //
  420.                                         Put_gTEMP();
  421.                                                 break;
  422.                                 default:
  423.                                         break;
  424.                         }
  425.                         if(start_word < 1){
  426.                                 MSG_MV = MSG_MV_L;
  427.                                 return;
  428.                         }
  429.                 }
  430. //        }
  431.                 }
  432. }
  433. void Show_All_Word(){
  434.         int m,i;
  435.         //MSG_MV = MSG_MV_L;
  436.         for(start_word = 0;start_word < 8;start_word++){
  437.                 for(move_times = 0; move_times < 8;move_times++){
  438.                         for(m=0;m<2;m++){        //若要上下移动 m=16
  439.                                 for(i=0;i<16;i++){
  440.                                         Put_Hdispram();        //把第i行放入行缓冲
  441.                                         RL_Move();        //是否要左右移动
  442.                                         Show_Line();
  443.                                 }
  444.                         }
  445.                 }
  446.         }
  447. }

  448. void delay()
  449. {
  450.         uint i;
  451.         for(i=0;i<40;i++);
  452. }                         
  453.        
  454. //------------------------------------
  455. //----------字发送子程序-----------
  456.         void SendByte(void)
  457.                 {
  458.                    uchar m;
  459.                    for(m=0;m<8;m++)
  460.                    {
  461.                                    CLK = 0;
  462.                                 Red = (SendData & 0x80);                  //红屏显示
  463.                     //        Greed =  (SendData & 0x80);                  //绿屏显示
  464.                                   SendData =SendData<<1;                       
  465.                                 CLK = 1;          //移位时钟上升沿
  466.                    }
  467.                 }
  468. //-----------------------------------
  469. //----------行扫描子程序-------------
  470.            void RowsCan(void)
  471.            {
  472.                         P2 = P2 & 0xf0;
  473.                         P2 = P2 | hang;
  474.                         hang++;
  475.                         if (hang>=16)
  476.                         {
  477.                                 hang =0x00;
  478.                         }
  479.                 }

  480.                 void initial(void)
  481.                    {
  482.                           OE = 1;
  483.                         Red = 1;
  484.                         Greed = 1;
  485.                         SendData = 0x00;
  486.                         hang = 0x00;
  487.                                                        
  488.                  }
  489. /*****************************************************
  490. 函数功能:延时若干微秒
  491. 入口参数:n
  492. ***************************************************/
  493. void delaynus(unsigned char n)
  494. {
  495. unsigned char i;
  496. // for(i=0;i<n;i++)
  497.       ;
  498. }
  499. /*****************************************************
  500. 函数功能:向1302写一个字节数据
  501. 入口参数:x
  502. ***************************************************/
  503. void Write1302(unsigned char dat)
  504. {
  505.   unsigned char i;
  506.   SCLK=0;            //拉低SCLK,为脉冲上升沿写入数据做好准备
  507.   delaynus(2);       //稍微等待,使硬件做好准备
  508.   for(i=0;i<8;i++)      //连续写8个二进制位数据
  509.     {
  510.             DATA=dat&0x01;    //取出dat的第0位数据写入1302
  511.                 delaynus(2);       //稍微等待,使硬件做好准备
  512.                  SCLK=1;           //上升沿写入数据
  513.                  delaynus(2);      //稍微等待,使硬件做好准备
  514.                  SCLK=0;           //重新拉低SCLK,形成脉冲
  515.                  dat>>=1;          //将dat的各数据位右移1位,准备写入下一个数据位
  516.           }
  517.        
  518. }
  519. /*****************************************************
  520. 函数功能:根据命令字,向1302写一个字节数据
  521. 入口参数:Cmd,储存命令字;dat,储存待写的数据
  522. ***************************************************/
  523. void WriteSet1302(unsigned char Cmd,unsigned char dat)
  524. {
  525.    RST=0;           //禁止数据传递
  526.    SCLK=0;          //确保写数居前SCLK被拉低
  527.         RST=1;           //启动数据传输
  528.         delaynus(2);     //稍微等待,使硬件做好准备
  529.         Write1302(Cmd);  //写入命令字
  530.         Write1302(dat);  //写数据
  531.         SCLK=1;          //将时钟电平置于已知状态
  532.         RST=0;           //禁止数据传递
  533. }
  534. /*****************************************************
  535. 函数功能:从1302读一个字节数据
  536. 入口参数:x
  537. ***************************************************/
  538. unsigned char Read1302(void)
  539. {
  540.    unsigned char i,dat;
  541.         delaynus(2);       //稍微等待,使硬件做好准备
  542.         for(i=0;i<8;i++)   //连续读8个二进制位数据
  543.          {
  544.            dat>>=1;       //将dat的各数据位右移1位,因为先读出的是字节的最低位
  545.                 if(DATA==1)    //如果读出的数据是1
  546.                  dat|=0x80;    //将1取出,写在dat的最高位
  547.                  SCLK=1;       //将SCLK置于高电平,为下降沿读出
  548.                  delaynus(2);  //稍微等待
  549.                  SCLK=0;       //拉低SCLK,形成脉冲下降沿
  550.                  delaynus(2);  //稍微等待
  551.           }         
  552.   return dat;        //将读出的数据返回
  553. }  
  554. /*****************************************************
  555. 函数功能:根据命令字,从1302读取一个字节数据
  556. 入口参数:Cmd
  557. ***************************************************/
  558. unsigned char  ReadSet1302(unsigned char Cmd)
  559. {
  560.   unsigned char dat;
  561.   RST=0;                 //拉低RST
  562.   SCLK=0;                //确保写数居前SCLK被拉低
  563.   RST=1;                 //启动数据传输
  564.   Write1302(Cmd);       //写入命令字
  565.   dat=Read1302();       //读出数据
  566.   SCLK=1;              //将时钟电平置于已知状态
  567.   RST=0;               //禁止数据传递
  568.   return dat;          //将读出的数据返回
  569. }
  570. /*****************************************************
  571. 函数功能: 1302进行初始化设置
  572. ***************************************************/
  573. void Init_DS1302(void)
  574. {       
  575.   unsigned char flag;
  576.    
  577.     flag= ReadSet1302(0x81);
  578.         if(flag&0x80)        {      //判断时钟芯片是否关闭
  579.    WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字,写入不保护指令
  580.    WriteSet1302(0x80,((0/10)<<4|(0%10)));   //根据写秒寄存器命令字,写入秒的初始值
  581.         WriteSet1302(0x82,((18/10)<<4|(18%10)));   //根据写分寄存器命令字,写入分的初始值
  582.         WriteSet1302(0x84,((21/10)<<4|(21%10))); //根据写小时寄存器命令字,写入小时的初始值
  583.         WriteSet1302(0x86,((23/10)<<4|(23%10))); //根据写日寄存器命令字,写入日的初始值
  584.         WriteSet1302(0x88,((7/10)<<4|(7%10))); //根据写月寄存器命令字,写入月的初始值
  585.         //WriteSet1302(0x8A,2);
  586.         WriteSet1302(0x8c,((10/10)<<4|(10%10)));   //根据写小时寄存器命令字,写入小时的初始值
  587.                 WriteSet1302(0x90,0xa5);
  588.         WriteSet1302(0x8E,0x80);
  589.   }
  590.   //如果不想每次都初始化时间,也就是掉电后还想让时钟继续走时的话 就用上面的语句


  591.   /*--------------------这是每次都初始化的语句-----------------*/
  592.     /* WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字,写入不保护指令
  593.    WriteSet1302(0x80,((0/10)<<4|(0%10)));   //根据写秒寄存器命令字,写入秒的初始值
  594.         WriteSet1302(0x82,((18/10)<<4|(18%10)));   //根据写分寄存器命令字,写入分的初始值
  595.         WriteSet1302(0x84,((21/10)<<4|(21%10))); //根据写小时寄存器命令字,写入小时的初始值
  596.         WriteSet1302(0x86,((23/10)<<4|(23%10))); //根据写日寄存器命令字,写入日的初始值
  597.         WriteSet1302(0x88,((7/10)<<4|(7%10))); //根据写月寄存器命令字,写入月的初始值
  598.         //WriteSet1302(0x8A,2);
  599.         WriteSet1302(0x8c,((10/10)<<4|(10%10)));   //根据写小时寄存器命令字,写入小时的初始值
  600.                 WriteSet1302(0x90,0xa5);
  601.         WriteSet1302(0x8E,0x80);
  602.         */



  603. }
  604. void write_time1302(){
  605.     WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字,写入不保护指令
  606.     WriteSet1302(0x80,Time.Second);   //根据写秒寄存器命令字,写入秒的初始值
  607.         WriteSet1302(0x82,Time.Minute);   //根据写分寄存器命令字,写入分的初始值
  608.         WriteSet1302(0x84,Time.Hour); //根据写小时寄存器命令字,写入小时的初始值
  609.         WriteSet1302(0x86,Time.Day); //根据写日寄存器命令字,写入日的初始值
  610.         WriteSet1302(0x88,Time.Month); //根据写月寄存器命令字,写入月的初始值
  611.         WriteSet1302(0x8A,Time.Week);
  612.         WriteSet1302(0x8c,Time.Year);   //根据写小时寄存器命令字,写入小时的初始值
  613.         //        WriteSet1302(0x90,0xa5);
  614.         //WriteSet1302(0x8E,0x80);       
  615. }

  616. //读时间
  617. void Read_TIME(){

  618.         RST=0;                 //拉低RST
  619.           SCLK=0;                //确保写数居前SCLK被拉低
  620.           RST=1;                 //启动数据传输
  621.           Write1302(0xbf);       //写入命令字
  622.         Time.Second = Read1302() & 0x7f;
  623.         Time.Minute = Read1302() & 0x7f;
  624.         Time.Hour = Read1302() & 0x7f;
  625.         Time.Day = Read1302() & 0x7f;
  626.         Time.Month = Read1302() & 0x7f;  
  627.         Time.Week= Read1302() & 0x7f;
  628.         Time.Year = Read1302() & 0x7f;
  629.         SCLK=1;          //将时钟电平置于已知状态
  630.         RST=0;           //禁止数据传递
  631.          
  632.         /*unsigned char ReadValue;   //储存从1302读取的数据
  633.         ReadValue = ReadSet1302(0x81);   //从秒寄存器读数据
  634.         Time.Second =ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F);//将读出数据转化
  635.          ReadValue = ReadSet1302(0x83);  //从分寄存器读
  636.      Time.Minute = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  637.      ReadValue = ReadSet1302(0x85);  //从时寄存器读
  638.      Time.Hour = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  639.      ReadValue = ReadSet1302(0x87);  //从分寄存器读
  640.      Time.Day = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  641.          ReadValue = ReadSet1302(0x89);  //从分寄存器读
  642.      Time.Month = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  643.         ReadValue = ReadSet1302(0x8B);  //从时寄存器读
  644.         Time.Week= ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化
  645.          ReadValue = ReadSet1302(0x8d);  //从分寄存器读                                                                          
  646.      Time.Year = ReadValue&0x7f;//(ReadValue&0x70) + (ReadValue&0x0F); //将读出数据转化  
  647.    
  648.    */ }

  649. void Put_Adispram(uchar a){
  650.         uchar i;
  651.         //第一屏"今天是:"
  652.         disword[a+1] = &NO_WORDS[12][0];        //空格
  653.         for(i=0;i<6;i++)
  654.                 disword[a+i+2] = &TIME_WORDS[i][0];
  655.         disword[a+8] = &NO_WORDS[11][0];        //":"
  656.         //第二屏
  657.         //disword[4] = &TIME_WORDS[];
  658.                
  659. }
  660.        
  661. //将年份放入到显示缓存
  662. //需要参数:缓冲区首地址下标
  663. void Put_Ydispram(uchar i){
  664.         disword[i+1] = &NO_WORDS[12][0];
  665.         if(Time.Year < 30 && !HIDE){
  666.                 disword[i+2] = &NO_WORDS[2][0];
  667.                 disword[i+3] = &NO_WORDS[0][0];
  668.                 }
  669.         else if(!HIDE){
  670.                 disword[i+2] = &NO_WORDS[1][0];
  671.                 disword[i+3] = &NO_WORDS[9][0];
  672.                 }
  673.         disword[i+4] = &NO_WORDS[Time.Year>>4][0];
  674.         disword[i+5] = &NO_WORDS[Time.Year&0x0f][0];
  675.         disword[i+6] = &TIME_WORDS[6][0];
  676.         disword[i+7] = &TIME_WORDS[7][0];        //年
  677.         disword[i+8] = &NO_WORDS[12][0];
  678. }       
  679. //将星期放入到显示缓存
  680. //参数:缓冲区首地址下标
  681. void Put_Kdispram(uchar i){
  682.         disword[i+1] = &NO_WORDS[12][0];                
  683.         disword[i+2] = &TIME_WORDS[12][0];               
  684.         disword[i+3] = &TIME_WORDS[13][0];        //星期               
  685.         disword[i+4] = &TIME_WORDS[14][0];                
  686.         disword[i+5] = &TIME_WORDS[15][0];
  687.         if(STATE== STA_CHG &&HIDE){
  688.                 disword[i+6] = &NO_WORDS[12][0];                //
  689.                 disword[i+7] = &NO_WORDS[12][0];                  //
  690.                 }
  691.         else{
  692.                 disword[i+6] = &WEEK_WORDS[Time.Week*2-2][0];                //
  693.                 disword[i+7] = &WEEK_WORDS[Time.Week*2-1][0];                  //
  694.                 }
  695.         disword[i+8] = &NO_WORDS[12][0];                
  696. }

  697. //将日期放入到显示缓存
  698. //参数:缓冲区首地址下标
  699. void Put_Ddispram(uchar i){
  700.         disword[i+1] = &NO_WORDS[Time.Month>>4][0];                 //小时高位
  701.         disword[i+2] = &NO_WORDS[ Time.Month&0x0f][0];                //小时地位
  702.         disword[i+3] = &TIME_WORDS[8][0];                //-
  703.         disword[i+4] = &TIME_WORDS[9][0];                 //分钟高位
  704.         disword[i+5] = &NO_WORDS[ Time.Day>>4][0];                //分钟地位
  705.         disword[i+6] = &NO_WORDS[Time.Day&0x0f][0];                //-
  706.         disword[i+7] = &TIME_WORDS[10][0];                  //秒高位
  707.         disword[i+8] = &TIME_WORDS[11][0];                 //秒地位
  708. }

  709. //将时间放入到显示缓存
  710. //参数:缓冲区首地址下标
  711. void Put_Tdispram(uchar i){
  712.         disword[i+1] = &NO_WORDS[Time.Hour>>4][0];                 //小时高位
  713.         disword[i+2] = &NO_WORDS[ Time.Hour&0x0f][0];                //小时地位
  714.         disword[i+3] = &NO_WORDS[ 11 ];                //-
  715.         disword[i+4] = &NO_WORDS[Time.Minute>>4][0];                 //分钟高位
  716.         disword[i+5] = &NO_WORDS[ Time.Minute&0x0f][0];                //分钟地位
  717.         disword[i+6] = &NO_WORDS[ 11 ];                //-
  718.         disword[i+7] = &NO_WORDS[Time.Second>>4][0];                 //秒高位
  719.         disword[i+8] = &NO_WORDS[ Time.Second&0x0f][0];                //秒地位
  720. }
  721. //===================================
  722. //*****关于温度检测部分*****
  723. void Put_gTEMP(){
  724. //        uchar i;
  725. //        Put_Wdispram(TMP_WORDS,0);
  726.         disword[6] = &NO_WORDS[temp_ram[3]][0];                 //百位
  727.         disword[7] = &NO_WORDS[temp_ram[2]][0];                //十位
  728.         disword[8] = &NO_WORDS[temp_ram[1]][0];                //个位
  729.         disword[10] = &NO_WORDS[temp_ram[0]][0];                //小数
  730.         disword[12]        = &NO_WORDS[12];                //空格
  731.         disword[13]        = &NO_WORDS[12];                //空格
  732.         //
  733. }

  734. void Put_sTEMP(uchar i){
  735.         disword[i+1] = &NO_WORDS[12];                //空格
  736.         disword[i+2] = &NO_WORDS[12];//&NO_WORDS[temp_ram[3]][0];                 //百位
  737.         disword[i+3] = &NO_WORDS[temp_ram[2]][0];                //十位
  738.         disword[i+4] = &NO_WORDS[temp_ram[1]][0];                //个位
  739.         disword[i+5] = &TMP_WORDS[8][0];        //小数点
  740.         disword[i+6] = &NO_WORDS[temp_ram[0]][0];                //小数
  741.         disword[i+7] = &TMP_WORDS[10][0];
  742.         disword[i+8] = &NO_WORDS[12];                //空格
  743. }
  744. void Put_Cpyrt(uchar i){
  745.         uchar m;
  746.         for(m=0;m<8;m++)
  747.                 disword[i+1+m] = &CPYRT_WORDS[m];
  748. }
  749. void Show_Cpyrt(){
  750.         uchar i;
  751.         for(i=1;i<9;i++)
  752.                 disword[i] = &NO_WORDS[12];
  753.         Put_Cpyrt(8);
  754.         Move_Down();
  755.         Put_Cpyrt(0);
  756.         Put_Tdispram(8);
  757.         Move_Down();
  758. }
  759.        
  760. //========================
  761. //参数i:放入第几屏缓存
  762. //参数j:诗歌第几页
  763. //========================
  764. void Put_Song(uchar i,uchar j){
  765.         uchar m;
  766.         for(m=0;m<8;m++)
  767.                 disword[i+1+m] = &SONG_WORDS[j+m];
  768. }
  769. //显示诗歌
  770. void Show_Song(){
  771.         uchar i;
  772.         Put_Song(8,0);
  773.         Move_Up();
  774.         for(i=0;i<3;i++){
  775.                 Put_Song(0,i*8);
  776.                 Put_Song(8, (i+1)*8);
  777.                 Move_Up();
  778.                 }
  779.         Put_Song(0, 3*8);
  780.         Put_Tdispram(8);
  781.         Move_Up();
  782. }

  783.        
  784. //======================
  785. //*滚动显示所有信息*
  786. //======================
  787. void Show_All_Info(){
  788.         Put_Adispram(8);
  789.         Move_Down();        //切换效果
  790.        
  791.         Put_Adispram(0);
  792.         Put_Ydispram(8);        //XXXX年
  793.         Show_All_Word();
  794.        
  795.         Put_Ydispram(0);        //XXXX年
  796.         Put_Ddispram(8);
  797.         Show_All_Word();

  798.         Put_Ddispram(0);
  799.         Put_Kdispram(8);
  800.         Show_All_Word();

  801.        
  802.         Read_Temperature();
  803.         Disp_Temperature();
  804.         Put_Kdispram(0);
  805.         Put_Tdispram(8);
  806.         Show_All_Word();

  807.         Read_Temperature();
  808.         Disp_Temperature();
  809.         Put_Tdispram(0);
  810.         Put_sTEMP(8);
  811.         Show_All_Word();

  812.         Read_TIME();
  813.         Put_sTEMP(0);
  814.         Put_Tdispram(8);
  815.         Move_Up();
  816.        
  817. }

  818.        
  819. /*us级延时函数                                        */
  820. /*******************************************************************/

  821. void Delay(unsigned int num)
  822. {
  823.   num = num/2;
  824.   while( --num ) ;
  825. }

  826. /*初始化ds1820                                      */
  827. /*******************************************************************/
  828. Init_DS18B20(void)
  829. {  
  830.      DQ = 1 ;      //DQ复位
  831.      Delay(8) ;    //稍做延时

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

  834.      DQ = 1 ;       //拉高总线
  835.      Delay(8) ;

  836.      presence = DQ ;    //如果=0则初始化成功 =1则初始化失败
  837.      Delay(100) ;
  838.      DQ = 1 ;
  839.      
  840.      return(presence) ; //返回信号,0=presence,1= no presence
  841. }


  842. /* 读一个字节                     */
  843. /*******************************************************************/
  844. ReadOneChar(void)
  845. {
  846. unsigned char i = 0 ;
  847. unsigned char dat = 0 ;

  848. for (i = 8 ; i > 0 ; i--)
  849.   {
  850.     DQ = 0 ; // 给脉冲信号
  851.     dat >>= 1 ;
  852.     DQ = 1 ; // 给脉冲信号

  853.     if(DQ)
  854.      dat |= 0x80 ;
  855.     Delay(4) ;
  856.   }

  857.     return (dat) ;
  858. }

  859. /* 写一个字节                                         */
  860. /*******************************************************************/
  861. WriteOneChar(unsigned char dat)
  862. {
  863.   unsigned char i = 0 ;
  864.   for (i = 8 ; i > 0 ; i--)
  865.   {
  866.     DQ = 0 ;
  867.     DQ = dat&0x01 ;
  868.     Delay(5) ;

  869.     DQ = 1 ;
  870.     dat>>=1 ;
  871.   }
  872. }

  873. /* 读取温度                            */
  874. /*******************************************************************/
  875. Read_Temperature(void)
  876. {
  877.      Init_DS18B20() ;
  878.   
  879.      WriteOneChar(0xCC) ;  // 跳过读序号列号的操作
  880.      WriteOneChar(0x44) ;  // 启动温度转换

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

  884.      temp_data[0] = ReadOneChar() ;   //温度低8位
  885.      temp_data[1] = ReadOneChar() ;   //温度高8位
  886. }

  887. /* 数据转换与温度显示                                              */
  888. /*******************************************************************/
  889. void Disp_Temperature()
  890. {
  891.   temp_ram[4]=temp_data[0]&0x0f ;
  892.   temp_ram[0]=ditab[temp_ram[4]]+0x30 ;     //查表得小数位的值
  893.   
  894.   temp_ram[4]=((temp_data[0]&0xf0)>>4)|((temp_data[1]&0x0f)<<4) ;
  895.   temp_ram[3]=temp_ram[4]/100+0x30 ;
  896.   temp_ram[1]=temp_ram[4]%100 ;
  897.   temp_ram[2]=temp_ram[1]/10+0x30 ;
  898.   temp_ram[1]=temp_ram[1]%10+0x30 ;

  899.     if(temp_ram[3]==0x30)        //高位为0,不显示
  900.    {
  901.      temp_ram[3]=0x20 ;              
  902.      if(temp_ram[2]==0x30)      //次高位为0,不显示
  903.      temp_ram[2]=0x20 ;
  904.    }

  905. }
  906. void start_time(){
  907.         Time.Year = 0x10;
  908.         Time.Month = 0x7;
  909.         Time.Day = 0x23;
  910.         Time.Hour = 0x21;
  911.         Time.Minute = 0x58;
  912.         Time.Second = 0x0;
  913.         Time.Week = 0x5;
  914. }

  915. //=================
  916. //****校时函数****
  917. //=================
  918. void Change_Time(){
  919.         //
  920.         MSG_MV = MSG_MV_L;
  921.         move_times = 0;
  922.         start_word=0;
  923.         TMP_TIME = Time.Hour;
  924.         TR1 = 1;                //开启定时器1闪烁
  925.         do{
  926.                 switch(CHANGE){
  927.                                 case CHG_HOUR:
  928.                                 case CHG_MIN:
  929.                                 case CHG_SEC:
  930.                                         Put_Tdispram(0);
  931.                                         break;
  932.                                 case CHG_MON:
  933.                                 case CHG_DAY:
  934.                                         Put_Ddispram(0);
  935.                                         break;
  936.                                 case CHG_WEEK:
  937.                                         Put_Kdispram(0);
  938.                                         break;
  939.                                 case CHG_YEAR:
  940.                                         Put_Ydispram(0);
  941.                                         break;
  942.                                 default:
  943.                                         break;
  944.                                 }       
  945.                 Show_sWord();
  946.                 //if(!key_done)
  947.                 //        ReadKey1();
  948.                 }while(ReadKey1() != KEY3_S && exit < 10);                //MSG_KEY
  949.         Change_obj();        //保证退出校时无隐身
  950.         HIDE = 0;
  951.         key_done = 0;
  952.         //key_done = 1;        //按键事件处理完成
  953.         TR1 = 0;                //关闭定时器1闪烁                                       
  954.        
  955. }
  956. //==================
  957. //****对象切换****
  958. //==================
  959. void Change_obj(){
  960.         switch(CHANGE){
  961.                                 case CHG_HOUR:
  962.                                         if(Time.Hour == 0xcc)
  963.                                                 Time.Hour = TMP_TIME;
  964.                                         TMP_TIME = Time.Minute;
  965.                                         break;
  966.                                 case CHG_MIN:
  967.                                         if(Time.Minute == 0xcc)
  968.                                                 Time.Minute = TMP_TIME;
  969.                                         TMP_TIME = Time.Second;
  970.                                         break;
  971.                                 case CHG_SEC:
  972.                                         if(Time.Second == 0xcc)
  973.                                                 Time.Second = TMP_TIME;
  974.                                         TMP_TIME = Time.Month;
  975.                                         break;
  976.                                 case CHG_MON:
  977.                                         if(Time.Month == 0xcc)
  978.                                                 Time.Month = TMP_TIME;
  979.                                         TMP_TIME = Time.Day;
  980.                                         break;
  981.                                 case CHG_DAY:
  982.                                         if(Time.Day == 0xcc)
  983.                                                 Time.Day = TMP_TIME;
  984.                                         TMP_TIME = Time.Week;
  985.                                         break;
  986.                                 case CHG_WEEK:
  987.                                         if(Time.Week == 0xcc)
  988.                                                 Time.Week = TMP_TIME;
  989.                                         TMP_TIME = Time.Year;
  990.                                         break;
  991.                                 case CHG_YEAR:
  992.                                         if(Time.Year == 0xcc)
  993.                                                 Time.Year = TMP_TIME;
  994.                                         TMP_TIME = Time.Hour;
  995.                                         break;
  996.                                 default:
  997.                                         break;
  998.                                 }
  999. }
  1000. //==================
  1001. //****加加函数****
  1002. //功能: 0x19 ++  =0x20
  1003. //==================
  1004. uchar Add_num(char *num){
  1005.         ++(*num);
  1006.         if(((*num) & 0x0f) == 0x0a){
  1007.                 *num += 0x10;
  1008.                 *num &= 0xf0;
  1009.                 }
  1010.         return *num;
  1011. }
  1012. //==================
  1013. //****校时加加****
  1014. //==================
  1015. void Add_Time(){
  1016.         switch(CHANGE){
  1017.                                 case CHG_HOUR:
  1018.                                         if(HIDE){
  1019.                                                 if(Add_num(&TMP_TIME) == 0x24)
  1020.                                                         TMP_TIME= 0;
  1021.                                                 }
  1022.                                         else{
  1023.                                                 if(Add_num(&Time.Hour) == 0x24)
  1024.                                                         Time.Hour = 0;
  1025.                                                 }
  1026.                                         break;
  1027.                                 case CHG_MIN:
  1028.                                         if(HIDE){
  1029.                                                 if(Add_num(&TMP_TIME) == 0x60)
  1030.                                                         TMP_TIME= 0;
  1031.                                                 }
  1032.                                         else{
  1033.                                                 if(Add_num(&Time.Minute) == 0x60)
  1034.                                                         Time.Minute= 0;
  1035.                                                 }
  1036.                                         break;
  1037.                                 case CHG_SEC:
  1038.                                         if(HIDE){
  1039.                                                 if(Add_num(&TMP_TIME) == 0x60)
  1040.                                                         TMP_TIME= 0;
  1041.                                                 }
  1042.                                         else{
  1043.                                                 if(Add_num(&Time.Second) == 0x60)
  1044.                                                         Time.Second = 0;
  1045.                                                 }
  1046.                                         break;
  1047.                                 case CHG_MON:
  1048.                                         if(HIDE){
  1049.                                                 if(Add_num(&TMP_TIME) == 0x13)
  1050.                                                         TMP_TIME= 0;
  1051.                                                 }
  1052.                                         else{
  1053.                                                 if(Add_num(&Time.Month) == 0x13)
  1054.                                                         Time.Month= 1;
  1055.                                                 }
  1056.                                         break;
  1057.                                 case CHG_DAY:
  1058.                                         if(HIDE){
  1059.                                                 if(Add_num(&TMP_TIME) == 0x32)
  1060.                                                         TMP_TIME= 0;
  1061.                                                 }
  1062.                                         else{
  1063.                                                 if(Add_num(&Time.Day) == 0x32)
  1064.                                                         Time.Day= 0;
  1065.                                                 }
  1066.                                         break;
  1067.                                 case CHG_WEEK:
  1068.                                         if(HIDE){
  1069.                                                 if(Add_num(&TMP_TIME) == 0x08)
  1070.                                                         TMP_TIME= 0;
  1071.                                                 }
  1072.                                         else{
  1073.                                                 if(Add_num(&Time.Week) == 0x08)
  1074.                                                         Time.Week= 1;
  1075.                                                 }
  1076.                                         break;
  1077.                                 case CHG_YEAR:
  1078.                                         if(HIDE){
  1079.                                                 if(Add_num(&TMP_TIME) == 0xa0)
  1080.                                                         TMP_TIME = 0;
  1081.                                                 }
  1082.                                         else{
  1083.                                                 if(Add_num(&Time.Year) == 0xa0)
  1084.                                                         Time.Year = 0;
  1085.                                                 }
  1086.                                         //if(Add_num(&Time.Year) == 0x24)
  1087.                                         //        Time.Year= 0;
  1088.                                         break;
  1089.                                 default:
  1090.                                         break;
  1091.                                 }
  1092. }
  1093. //==================
  1094. //****减减函数****
  1095. //功能: 0x20 --  =0x19
  1096. //==================
  1097. uchar Cut_num(char *num){
  1098.         --(*num);
  1099.         if(((*num)&0x0f) == 0x0f){
  1100.                 //*num -= 0x10;
  1101.                 *num &= 0xf9;
  1102.         }
  1103.         //if((*num == 0xf9)
  1104.                 //*num = 0x99;
  1105.         return *num;
  1106. }
  1107. //==================
  1108. //****校时减减****
  1109. //==================
  1110. void Cut_Time(){
  1111.         switch(CHANGE){
  1112.                                 case CHG_HOUR:
  1113.                                         if(HIDE){
  1114.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1115.                                                         TMP_TIME= 0x23;
  1116.                                                 }
  1117.                                         else{
  1118.                                                 if(Cut_num(&Time.Hour) == 0xf9)
  1119.                                                         Time.Hour = 0x23;
  1120.                                                 }
  1121.                                         break;
  1122.                                 case CHG_MIN:
  1123.                                         if(HIDE){
  1124.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1125.                                                         TMP_TIME= 0x59;
  1126.                                                 }
  1127.                                         else{
  1128.                                                 if(Cut_num(&Time.Minute) == 0xf9)
  1129.                                                         Time.Minute= 0x59;
  1130.                                                 }
  1131.                                         break;
  1132.                                 case CHG_SEC:
  1133.                                         if(HIDE){
  1134.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1135.                                                         TMP_TIME= 0x59;
  1136.                                                 }
  1137.                                         else{
  1138.                                                 if(Cut_num(&Time.Second) == 0xf9)
  1139.                                                         Time.Second = 0x59;
  1140.                                                 }
  1141.                                         break;
  1142.                                 case CHG_MON:
  1143.                                         if(HIDE){
  1144.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1145.                                                         TMP_TIME= 0x12;
  1146.                                                 }
  1147.                                         else{
  1148.                                                 if(Cut_num(&Time.Month) == 0xf9)
  1149.                                                         Time.Month= 0x12;
  1150.                                                 }
  1151.                                         break;
  1152.                                 case CHG_DAY:
  1153.                                         if(HIDE){
  1154.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1155.                                                         TMP_TIME= 0x31;
  1156.                                                 }
  1157.                                         else{
  1158.                                                 if(Cut_num(&Time.Day) == 0xf9)
  1159.                                                         Time.Day= 0x31;
  1160.                                                 }
  1161.                                         break;
  1162.                                 case CHG_WEEK:
  1163.                                         if(HIDE){
  1164.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1165.                                                         TMP_TIME= 0x7;
  1166.                                                 }
  1167.                                         else{
  1168.                                                 if(Cut_num(&Time.Week) == 0xf9)
  1169.                                                         Time.Week= 0x7;
  1170.                                                 }
  1171.                                         break;
  1172.                                 case CHG_YEAR:
  1173.                                         if(HIDE){
  1174.                                                 if(Cut_num(&TMP_TIME) == 0xf9)
  1175.                                                         TMP_TIME= 0x99;
  1176.                                                 }
  1177.                                         else{
  1178.                                                 if(Cut_num(&Time.Year) == 0xf9)
  1179.                                                         Time.Year = 0x99;
  1180.                                                 }
  1181.                                         //if(Cut_num(&Time.Year) == 0x99)
  1182.                                         //        Time.Year= 0;
  1183.                                         break;
  1184.                                 default:
  1185.                                         break;
  1186.                                 }
  1187. }

  1188. //======按键======
  1189. uchar ReadKey(){
  1190.         //
  1191.         if(!key_done){
  1192.         switch(MSG_KEY){
  1193.                 case KEY0_S:STATE = STA_sTIME;
  1194.                                         break;
  1195.                 case KEY1_S:STATE = STA_gWORD;        //STA_sWEEK
  1196.                                         break;
  1197.                 case KEY2_S:STATE = STA_gTEMP;
  1198.                                         break;
  1199.                 case KEY3_S:STATE = STA_gTIME;
  1200.                                         break;
  1201.                 case KEY0_L:STATE = STA_CHG;
  1202.                                         break;
  1203.                 case KEY1_L:STATE = STA_SONG;
  1204.                                         break;
  1205.                 case KEY2_L:STATE = STA_gTEMP;
  1206.                                         break;
  1207.                 case KEY3_L:STATE = STA_gWORD;        //STA_sTIME
  1208.                                         break;
  1209.                 default:        break;
  1210.                 }
  1211.                 }
  1212.         key_done = 1;        //按键事件处理完成
  1213.         return MSG_KEY;       
  1214. }
  1215. //=======================
  1216. //****校时按键处理****
  1217. //=======================
  1218. uchar ReadKey1(){
  1219.         //
  1220.         if(!key_done){
  1221.         switch(MSG_KEY){
  1222.                 case KEY0_S:                //切换校时对象
  1223.                 case KEY0_L:
  1224.                                         exit = 0;
  1225.                                         TR1 = 0;                //关闭定时器1闪烁
  1226.                                         Change_obj();
  1227.                                         if(CHANGE++ >= CHG_YEAR)
  1228.                                                 CHANGE = CHG_HOUR;
  1229.                                         TR1 = 1;                //开启定时器1闪烁
  1230.                                         break;
  1231.                 case KEY1_S:                //加加
  1232.                 case KEY1_L:
  1233.                                         exit = 0;
  1234.                                         TR1 = 0;                //关闭定时器1闪烁
  1235.                                         Add_Time();
  1236.                                         TR1 = 1;                //开启定时器1闪烁
  1237.                                         break;
  1238.                 case KEY2_S:                //减减
  1239.                 case KEY2_L:
  1240.                                         exit = 0;
  1241.                                         TR1 = 0;                //关闭定时器1闪烁
  1242.                                         Cut_Time();
  1243.                                         TR1 = 1;                //开启定时器1闪烁
  1244.                                         break;
  1245.                 case KEY3_L:
  1246.                 case KEY3_S:
  1247.                                         return KEY3_S;
  1248.                 default:        break;
  1249.                 }
  1250.                 }
  1251.         key_done = 1;        //按键事件处理完成
  1252.         return 0;
  1253. }
  1254. //===========================
  1255. void Tinit(){
  1256.         TMOD = 0x11;
  1257.         TH0 = 0xD8;
  1258.         TL0 = 0xF0;
  1259.         TH1 = 0x42;
  1260.         TL1 = 0xCA;
  1261.         TR0 = 1;
  1262.         //TR1 = 1;
  1263.         ET0 = 1;
  1264.         ET1 = 1;
  1265.         EA = 1;
  1266. }

  1267. timer0() interrupt 1{
  1268.         TH0 = 0xD8;
  1269.         TL0 = 0xF0;

  1270.         if(P1 != 0xff) {//若有键按下
  1271.                 cur_key_val = P1&0x0f;        //记录按键值
  1272.                 if(key_times < 150)
  1273.                         key_times++;  
  1274.                 else{
  1275.                         key_keep_times++;         //长按连击
  1276.                         if(key_keep_times >= 10){  //10 1秒连击10次
  1277.                                 key_keep_times = 0;
  1278.                                 MSG_KEY = 0x10 | cur_key_val;
  1279.                                 key_done = 0;        //按键事件复位
  1280.                                 }
  1281.                         }         
  1282.         }else{
  1283.                 if(key_times > 2 && key_times < 100 && key_done){        //短按键
  1284.                         MSG_KEY = cur_key_val;
  1285.                         key_done = 0;         //按键事件复位
  1286.                        
  1287. ……………………

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

所有资料51hei提供下载:
led点阵时钟.rar (1.92 MB, 下载次数: 48)




分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 转播转播 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

沙发
qxdqx 发表于 2018-1-21 17:40 | 只看该作者
多谢分享!!!!!!!!
回复

使用道具 举报

板凳
13763865005 发表于 2018-3-28 14:58 | 只看该作者
很不错的分享
回复

使用道具 举报

地板
big_zhuang 发表于 2019-2-11 14:46 | 只看该作者

很不错的分享
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51hei电子论坛2群 联系QQ:125739409;技术交流QQ群219535678

Powered by 单片机教程网

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