标题: 基于单片机的64*16LED点阵电子显示屏设计 pcb图+原理图+源程序 [打印本页]
作者: levous    时间: 2015-6-25 15:09
标题: 基于单片机的64*16LED点阵电子显示屏设计 pcb图+原理图+源程序
这是一个51单片机的64*16LED点阵电子显示屏设计包含原理图+pcb图+源程序


压缩包全部的资料下载：
基于单片机的LED电子显示屏的设计.rar (8.36 MB, 下载次数: 739)

下面分享一下部分源程序：
  1. /*64*16点阵屏的显示点阵屏的显示*/

  3. #include <reg52.h>
  4. #include <intrins.h>
  5. #include <stdio.h>
  6. #define ulong  unsigned long
  7. #define uchar unsigned char
  8. #define uint unsigned int
  9. #define DATAOUT P2           //指定P2口做为输出
  10. sfr ISP_CONTR = 0xe7;
  11. sbit DATA=DATAOUT^0;        //列数据输出位        
  12. sbit SCLH=DATAOUT^1;        //列扫描时钟位
  13. sbit SCLT=DATAOUT^2;        //列数据锁存位
  14. sbit AB=DATAOUT^4;                //行数据输出位
  15. sbit SCK=DATAOUT^5;                //行扫描时钟位        
  16. sbit key1 = P3^2;                //键盘位定义
  17. sbit key2 = P0^1;
  18. sbit key3 = P0^2;
  19. sbit key4 = P3^3;
  20. unsigned int idata numyear;
  21. unsigned char idata numt0,num,numf,nums,numday,nummonth;   //全局变量定义numt0 为定时器0计数,num 为时间秒计数,numf 分钟计数,nums 小时计数
  22. unsigned char idata lhj[128];      //128字节RAM做为64*16点阵屏显示缓存
  23. void display();                   //做为点阵扫描函数，将显示缓存的数据输出到点阵屏
  24. void display2();
  25. void displayS(unsigned int timer);//指定时间扫描显示
  26. void displayS2(unsigned int );
  27. void displaymove(unsigned char *lp,unsigned char c,unsigned char timer);        //显示汉字内容的移动效果，LP指向要显示第一个字的首地址，C表示显示字的个数，

  29. void displaymove2(unsigned char *,unsigned char ,unsigned char );                //timer是移动的速度
  30. void displaymovetb(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer);
  31. void displaymovetb2(unsigned char ,unsigned char *,unsigned char ,unsigned char);

  33. void init();                     //初始化函数
  34. void displayshijian();                         //时间显示函数//上下移动内容，din：1为向下，0为向上，
  35. void displayshijian2();                    //lp指向要移入的内容表示有几个汉字要移，timer为移动速度                                                                                                                                                                                                
  36. //void delay(unsigned int z);//延时子函数

  38. /******************  字模  *************************/

  40. code unsigned char DIAN[32]={
  41.         0x00,0x00,0x00,0x00,0x1F,0xF8,0x11,0x10,
  42.         0x11,0x10,0x11,0x10,0x11,0x10,0xFF,0xFE,
  43.         0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
  44.         0x1F,0xF9,0x00,0x01,0x00,0x0F,0x00,0x00,
  45.                                                           };                                                 //电

  47. code unsigned char QI[32]={
  48.         0x04,0x00,0x08,0x00,0x32,0x00,0xE2,0x00,
  49.         0x2A,0x00,0x2A,0x00,0x2A,0x00,0x2A,0x00,
  50.         0x2A,0x00,0x2A,0x00,0x2A,0x00,0x2B,0xF0,
  51.         0x20,0x0C,0x20,0x02,0x00,0x0F,0x00,0x00,
  52.                                                     };                                            //气

  54. code unsigned char GONG[32]={
  55.         0x00,0x04,0x20,0x04,0x20,0x04,0x20,0x04,
  56.         0x20,0x04,0x20,0x04,0x20,0x04,0x3F,0xFC,
  57.         0x20,0x04,0x20,0x04,0x20,0x04,0x20,0x04,
  58.         0x20,0x04,0x20,0x04,0x00,0x04,0x00,0x00,
  59.                                                           };                                                  //工

  61. code unsigned char CHENG[32]={
  62.         0x22,0x10,0x22,0x60,0x23,0x80,0x7F,0xFF,
  63.         0xC2,0x80,0x42,0x60,0x00,0x02,0x7A,0x92,
  64.         0x42,0x92,0x42,0x92,0x42,0xFE,0x42,0x92,
  65.         0x42,0x92,0x7A,0x92,0x00,0x82,0x00,0x00,
  66.                                                         };                                                  //程

  68. code unsigned char LAO[32]={
  69.     0x04,0x08,0x04,0x10,0x24,0x20,0x24,0x40,
  70.         0x24,0xFC,0x24,0xA2,0xFD,0x22,0x26,0x22,
  71.         0x24,0x42,0x2C,0x42,0x14,0x42,0x24,0x82,
  72.         0x44,0x1E,0x04,0x00,0x04,0x00,0x00,0x00,
  73.                                                         };                                             //老

  75. code unsigned char SHI1[32]={
  76.          0x00,0x00,0x3F,0xE1,0x00,0x02,0x00,0x0C,
  77.         0xFF,0xF0,0x00,0x00,0x40,0x00,0x27,0xF8,
  78.         0x24,0x00,0x24,0x00,0x7F,0xFF,0x24,0x10,
  79.         0x24,0x08,0x27,0xF0,0x20,0x00,0x00,0x00,
  80.                                                         };                                           //师

  82. code unsigned char MEN[32]={
  83.         0x00,0x80,0x01,0x00,0x06,0x00,0x1F,0xFF,
  84.         0xE0,0x00,0x00,0x00,0x1F,0xFF,0x80,0x00,
  85.         0x60,0x00,0x00,0x00,0x20,0x00,0x20,0x02,
  86.         0x20,0x01,0x3F,0xFE,0x00,0x00,0x00,0x00,
  87.                                                         };                                          //们

  89. code unsigned char HAO[32]={
  90.         0x08,0x02,0x08,0x44,0x0F,0xA8,0xF8,0x10,
  91.         0x08,0x68,0x0F,0x86,0x00,0x00,0x01,0x00,
  92.         0x41,0x02,0x41,0x01,0x47,0xFE,0x49,0x00,
  93.         0x51,0x00,0x61,0x00,0x01,0x00,0x00,0x00,
  94.                                                         };                                           //好

  96. code unsigned char BEI[32] ={
  97.         0x00,0x04,0x04,0x06,0x04,0x04,0x04,0x08,
  98.         0x04,0x08,0xFF,0xFF,0x00,0x00,0x00,0x00,
  99.         0x00,0x00,0xFF,0xFC,0x02,0x02,0x04,0x02,
  100.         0x08,0x02,0x10,0x02,0x00,0x1E,0x00,0x00,

  102.                                                           };                                           //北

  104. code unsigned char JING[32] = {
  105.         0x20,0x00,0x20,0x02,0x20,0x04,0x27,0xD8,
  106.         0x24,0x40,0x24,0x42,0xA4,0x41,0x64,0x7E,
  107.         0x24,0x40,0x24,0x40,0x24,0x40,0x27,0xD0,
  108.         0x20,0x08,0x20,0x06,0x20,0x00,0x00,0x00,
  109.                                                           };                                           //京

  111. code unsigned char SHI[32] = {
  112.         0x00,0x00,0x3F,0xFC,0x21,0x08,0x21,0x08,
  113.         0x21,0x08,0x3F,0xFC,0x00,0x00,0x08,0x00,
  114.         0x08,0x80,0x08,0x60,0x08,0x02,0x08,0x01,
  115.         0xFF,0xFE,0x08,0x00,0x08,0x00,0x00,0x00,
  116.                                                           };                                        //时
  117.                                                                   
  118. code unsigned char JIAN[32] = {
  119.         0x00,0x00,0x1F,0xFF,0x80,0x00,0x60,0x00,
  120.         0x00,0x00,0x0F,0xF8,0x48,0x88,0x48,0x88,
  121.         0x48,0x88,0x4F,0xF8,0x40,0x00,0x40,0x02,
  122.         0x40,0x01,0x7F,0xFE,0x00,0x00,0x00,0x00,

  124.                                                           };                                        //间

  126. code unsigned char XL[32]={
  127.                 0x00,0x00,0x07,0xc0,0x18,0x30,0x20,0x0C,
  128.                 0x40,0xC4,0x8C,0x62,0x8C,0x32,0x80,0x12,
  129.                 0x80,0x12,0x80,0x12,0x8C,0x32,0x4C,0x64,
  130.                 0x40,0xC4,0x20,0x08,0x18,0x60,0x07,0xC0,
  131.                                                         };                                  //笑脸

  133. code unsigned char ANZHUO[32]={
  134.                 0x00,0x00,0x00,0x00,0x03,0xE0,0x03,0xE0,
  135.                 0x00,0x00,0x9B,0xF0,0x3B,0xFE,0x6B,0xFE,
  136.                 0x7B,0xF0,0x6B,0xFE,0x3B,0xFE,0x9B,0xF0,
  137.                 0x00,0x00,0x03,0xE0,0x03,0xE0,0x00,0x00,
  138.                                                           };                                    //安卓

  140. code unsigned char HOU[32]={
  141.          0x00,0x01,0x00,0x02,0x03,0xfC,0x02,0x30,
  142.          0x02,0x10,0x02,0x18,0xFE,0x16,0x12,0x10,
  143.          0x12,0x18,0x12,0x16,0x12,0x10,0x13,0xf0,
  144.          0x10,0x08,0x10,0x07,0x00,0x00,0x00,0x00,
  145.                                                           };                                          //“点”

  147. code unsigned char MIN[32]={
  148.          0x01,0x00,0x02,0x01,0x04,0x02,0x09,0x04,
  149.          0x11,0x18,0x61,0xE0,0x01,0x00,0x01,0x02,
  150.          0x01,0x01,0xC1,0x02,0x31,0xFC,0x08,0x00,
  151.          0x04,0x00,0x02,0x00,0x01,0x00,0x00,0x00,
  152.                                                           };                                          //“分”

  154. code unsigned char el[32]={
  155.          0x00,0x00,0x07,0x0C,0x10,0x14,0x10,0x24,
  156.          0x10,0x44,0x11,0x84,0x0e,0x0c,0x00,0x00,
  157.          0x00,0x00,0x07,0xe0,0x08,0x10,0x10,0x08,
  158.          0x10,0x08,0x08,0x10,0x07,0xe0,0x00,0x00,};   //20

  160. code unsigned char yw[32]={
  161.          0x00,0x00,0x08,0x04,0x08,0x04,0x1f,0xfc,
  162.          0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,
  163.          0x00,0x00,0x3e,0x02,0x22,0x02,0x22,0x02,
  164.          0x22,0x04,0x22,0x08,0x21,0xf0,0x00,0x00,};   //15

  166. code unsigned char NIAN2[32]={
  167.      0x00,0x20,0x04,0x20,0x18,0x20,0xE3,0xE0,
  168.          0x22,0x20,0x22,0x20,0x22,0x20,0x22,0x20,
  169.          0x3F,0xFF,0x22,0x20,0x22,0x20,0x22,0x20,
  170.          0x22,0x20,0x20,0x20,0x00,0x20,0x00,0x00,
  171.                                                           };                                   //年

  173. code unsigned char nop[32]={
  174.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  175.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  176.      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  177.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  178.                                                           };  
  179. code unsigned char lw[32]={
  180.          0x00,0x00,0x07,0xe0,0x08,0x10,0x10,0x08,
  181.          0x10,0x08,0x08,0x10,0x07,0xe0,0x00,0x00,
  182.          0x00,0x00,0x3e,0x02,0x22,0x02,0x22,0x02,
  183.          0x22,0x04,0x22,0x08,0x21,0xf0,0x00,0x00,};         //05


  186. code unsigned char YUE[32]={
  187.          0x00,0x01,0x00,0x02,0x00,0x0C,0x3F,0xF0,
  188.          0x22,0x40,0x22,0x40,0x22,0x40,0x22,0x40,
  189.          0x22,0x40,0x22,0x40,0x22,0x42,0x22,0x41,
  190.          0x3F,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,
  191.                                                         };                                          //月

  193. code unsigned char shl[32]={
  194.          0x00,0x00,0x08,0x04,0x08,0x04,0x1f,0xfc,
  195.          0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,
  196.          0x00,0x00,0x0e,0xf8,0x10,0x84,0x20,0x84,
  197.          0x20,0x84,0x20,0x84,0x20,0x78,0x00,0x00,};        //16
  198. code unsigned char RI2[32]={
  199.          0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0xFF,
  200.          0x41,0x02,0x41,0x02,0x41,0x02,0x41,0x02,
  201.          0x41,0x02,0x41,0x02,0x41,0x02,0x7F,0xFF,
  202.          0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

  204.                                                         };                                           //日
  205. code unsigned char xie[32]={
  206.          0x02,0x00,0x42,0x00,0x33,0xFC,0x00,0x08,
  207.          0x00,0x54,0x3F,0xC8,0x6A,0x52,0xAA,0x61,
  208.          0x3F,0xFE,0x01,0x00,0x08,0xC2,0x08,0x01,
  209.          0xFF,0xFE,0x08,0x00,0x08,0x00,0x00,0x00,
  210.                                                         };
  211. code unsigned char xie1[32]={
  212.          0x02,0x00,0x42,0x00,0x33,0xFC,0x00,0x08,
  213.          0x00,0x54,0x3F,0xC8,0x6A,0x52,0xAA,0x61,
  214.          0x3F,0xFE,0x01,0x00,0x08,0xC2,0x08,0x01,
  215.          0xFF,0xFE,0x08,0x00,0x08,0x00,0x00,0x00,
  216.                                                         };
  217. code unsigned char LAO1[32]={
  218.     0x04,0x08,0x04,0x10,0x24,0x20,0x24,0x40,
  219.         0x24,0xFC,0x24,0xA2,0xFD,0x22,0x26,0x22,
  220.         0x24,0x42,0x2C,0x42,0x14,0x42,0x24,0x82,
  221.         0x44,0x1E,0x04,0x00,0x04,0x00,0x00,0x00,
  222.                                                         };                                             //老

  224. code unsigned char SHI2[32]={
  225.          0x00,0x00,0x3F,0xE1,0x00,0x02,0x00,0x0C,
  226.         0xFF,0xF0,0x00,0x00,0x00,0x00,0x2f,0xF8,
  227.         0x28,0x00,0x28,0x00,0x3F,0xFF,0x28,0x10,
  228.         0x28,0x08,0x2f,0xF0,0x20,0x00,0x00,0x00,
  229.                                                         };                                           //师
  230. //时数据
  231. code unsigned char c[3][16]={
  232. ///*--  文字:  0  --*//*--  楷体_GB231212;  此字体下对应的点阵为：宽x高=8x16   --*/
  233. {0x00,0x00,0x07,0xe0,0x08,0x10,0x10,0x08,0x10,0x08,0x08,0x10,0x07,0xe0,0x00,0x00,},
  234. {///*--  文字:  1  --*/
  235. 0x00,0x00,0x08,0x04,0x08,0x04,0x1f,0xfc,0x00,0x04,0x00,0x04,0x00,0x07,0x10,0x10,},
  236. {///*--  文字:  2  --*/
  237. 0x00,0x00,0x07,0x0C,0x10,0x14,0x10,0x24,0x10,0x44,0x11,0x84,0x0e,0x0c,0x00,0x00,}
  238. };

  240. code unsigned char d[10][16]={
  241. {///*--  文字:  0  --*/
  242. 0x00,0x00,0x07,0xe0,0x08,0x10,0x10,0x08,0x10,0x08,0x08,0x10,0x07,0xe0,0x00,0x00,
  243. },
  244. {///*--  文字:  1  --*/
  245. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,
  246. 0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  247. },
  248. {///*--  文字:  2  --*/
  249. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  250. },
  251. {///*--  文字:  3  --*/
  252. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  253. },
  254. {///*--  文字:  4  --*/
  255. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  256. },
  257. {///*--  文字:  5  --*/
  258. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  259. },
  260. {///*--  文字:  6  --*/
  261. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  262. },
  263. {///*--  文字:  7  --*/
  264. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  265. },
  266. {///*--  文字:  8  --*/
  267. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  268. },
  269. {///*--  文字:  9  --*/
  270. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,}
  271. };

  273. //分数据
  274. code unsigned char b[10][16]={
  275. {///*--  文字:  0  --*/
  276. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  277. },
  278. {///*--  文字:  1  --*/
  279. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  280. },
  281. {///*--  文字:  2  --*/
  282. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  283. },
  284. {///*--  文字:  3  --*/
  285. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  286. },
  287. {///*--  文字:  4  --*/
  288. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  289. },
  290. {///*--  文字:  5  --*/
  291. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  292. },
  293. {///*--  文字:  6  --*/
  294. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  295. },
  296. {///*--  文字:  7  --*/
  297. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  298. },
  299. {///*--  文字:  8  --*/
  300. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  301. },
  302. {///*--  文字:  9  --*/
  303. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  304. }
  305. };


  308. code unsigned char a[6][16]={
  309. {///*--  文字:  0  --*/
  310. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  311. },
  312. {///*--  文字:  1  --*/
  313. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  314. },
  315. {///*--  文字:  2  --*/
  316. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  317. },
  318. {///*--  文字:  3  --*/
  319. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  320. },
  321. {///*--  文字:  4  --*/
  322. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  323. },
  324. {///*--  文字:  5  --*/
  325. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  326. }
  327. };

  329. void init()                                         //初始化程序
  330. {
  331.         TMOD = 0x01;                               //  定时器0为工作方式1
  332.         TH0 = (65536-50000)/256;        //定时50mS
  333.         TL0 = (65536-50000)%256;
  334.         EA = 1;                                       //开总中断
  335.         ET0 = 1;                                   //开定时器0中断
  336.         EX0 = 1;                                   //开外部中断0
  337.         EX1 = 1;                                   //开外部中断1
  338.         IT0 = 0;                                   //设置外部中断0的中断方式为0 低电平触发
  339.         IT1 = 0;
  340.         TR0 = 1;                                   //启动定时器0

  342.         num = 0;
  343.         nums = 12;
  344.         numf = 30;
  345.         numyear = 2015;
  346.         nummonth = 5;
  347.         numday = 15;
  348. }
  349. void displayshijian()                 //显示时间函数
  350. {
  351.                 unsigned char i,j,p1,k1,p2,k2;
  352.                 p1 = nums/10;
  353.                 k1 = nums%10;          //小时数据
  354.                 p2 = numf/10;
  355.                 k2 = numf%10;          //分钟数据
  356.                
  357.                 for(i=0;i<128;i++)         //显示缓存清空        
  358.                 {        
  359.                         lhj[i]=0;
  360.                 }

  362.                 for(i=0,j=0;i<128;)               
  363.                 {        
  364.                         lhj[i]=c[p1][j];
  365.                         lhj[i+1]=d[k1][j];
  366.         
  367.                           i=i+8;
  368.                         j=j+1;
  369.                 }
  370.         
  371.                 for(i=2,j=0;i<128;)               
  372.                 {        
  373.                         lhj[i]=HOU[j];
  374.                         lhj[i+1]=HOU[j+1];
  375.         
  376.                           i=i+8;
  377.                         j=j+2;
  378.                 }
  379.         
  380.                 for(i=4,j=0;i<128;)               
  381.                 {        
  382.                         lhj[i]=a[p2][j];
  383.                         lhj[i+1]=b[k2][j];
  384.         
  385.                           i=i+8;
  386.                         j=j+1;
  387.                 }
  388.                
  389.                 for(i=6,j=0;i<128;)               
  390.                 {        
  391.                         lhj[i]=MIN[j];
  392.                         lhj[i+1]=MIN[j+1];
  393.         
  394.                           i=i+8;
  395.                         j=j+2;
  396.                 }
  397.                 displayS(1);         



  401. }

  403. void displayshijian2()                 //显示时间函数
  404. {
  405.                
  406.                 unsigned char i,j,p1,k1,p2,k2;
  407.                 p1 = nums/10;
  408.                 k1 = nums%10;          //小时数据
  409.                 p2 = numf/10;
  410.                 k2 = numf%10;          //分钟数据
  411.                
  412.                 for(i=0;i<128;i++)         //显示缓存清空        
  413.                 {        
  414.                         lhj[i]=0;
  415.                 }

  417.                 for(i=0,j=0;i<128;)               
  418.                 {        
  419.                         lhj[i]=c[p1][j];
  420.                         lhj[i+1]=d[k1][j];
  421.         
  422.                           i=i+8;
  423.                         j=j+1;
  424.                 }
  425.         
  426.                 for(i=2,j=0;i<128;)               
  427.                 {        
  428.                         lhj[i]=HOU[j];
  429.                         lhj[i+1]=HOU[j+1];
  430.         
  431.                           i=i+8;
  432.                         j=j+2;
  433.                 }
  434.         
  435.                 for(i=4,j=0;i<128;)               
  436.                 {        
  437.                         lhj[i]=a[p2][j];
  438.                         lhj[i+1]=b[k2][j];
  439.         
  440.                           i=i+8;
  441.                         j=j+1;
  442.                 }
  443.                
  444.                 for(i=6,j=0;i<128;)               
  445.                 {        
  446.                         lhj[i]=MIN[j];
  447.                         lhj[i+1]=MIN[j+1];
  448.         
  449.                           i=i+8;
  450.                         j=j+2;
  451.                 }
  452.                 displayS(1);         
  453. }


  456. void displaynyr()                                //年月日显示程序
  457. {        
  458.                 unsigned char i,j,n1,n2,n3,n4,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  459.                 n1 = numyear/1000;
  460.                 n2 = (numyear%1000)/100;
  461.                 n3 = (numyear%100)/10;
  462.                 n4 = numyear%10;
  463.                 p1 = nummonth/10;
  464.                 k1 = nummonth%10;          //月数据
  465.                 p2 = numday/10;
  466.                 k2 = numday%10;          //日数据

  468.                 for(i=0;i<128;i++)         //显示缓存清空        
  469.                 {        
  470.                         lhj[i]=0;
  471.                 }

  473.                 for(i=0,j=0;i<128;)               
  474.                 {        
  475.                         lhj[i]=d[n1][j];
  476.                         lhj[i+1]=d[n2][j];
  477.         
  478.                           i=i+8;
  479.                         j=j+1;
  480.                 }
  481.                 for(i=2,j=0;i<128;)               
  482.                 {        
  483.                         lhj[i]=d[n3][j];
  484.                         lhj[i+1]=d[n4][j];
  485.         
  486.                           i=i+8;
  487.                         j=j+1;
  488.                 }
  489.                 for(i=4,j=0;i<128;)               
  490.                 {        
  491.                         lhj[i]=NIAN2[j];
  492.                         lhj[i+1]=NIAN2[j+1];
  493.         
  494.                           i=i+8;
  495.                         j=j+2;
  496.                 }
  497.                 displayS(2);
  498.         displaymovetb(1,0,4,2);

  500.                 for(i=0,j=0;i<128;)               
  501.                 {        
  502.                         lhj[i]=d[p1][j];
  503.                         lhj[i+1]=d[k1][j];
  504.         
  505.                           i=i+8;
  506.                         j=j+1;
  507.                 }
  508.                 for(i=2,j=0;i<128;)               
  509.                 {        
  510.                         lhj[i]=YUE[j];
  511.                         lhj[i+1]=YUE[j+1];
  512.         
  513.                           i=i+8;
  514.                         j=j+2;
  515.                 }
  516.                 for(i=4,j=0;i<128;)               
  517.                 {        
  518.                         lhj[i]=d[p2][j];
  519.                         lhj[i+1]=d[k2][j];
  520.         
  521.                           i=i+8;
  522.                         j=j+1;
  523.                 }
  524.                 for(i=6,j=0;i<128;)               
  525.                 {        
  526.                         lhj[i]=RI2[j];
  527.                         lhj[i+1]=RI2[j+1];
  528.         
  529.                           i=i+8;
  530.                         j=j+2;
  531.                 }
  532.            displayS(3);
  533.        displaymovetb(1,0,4,1);
  534. }

  536. void displaynyr2()
  537. {        
  538.                 unsigned char i,j,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  539.                 p1 = nummonth/10;
  540.                 k1 = nummonth%10;          //月数据
  541.                 p2 = numday/10;
  542.                 k2 = numday%10;          //日数据

  544.                 for(i=0,j=0;i<128;)               
  545.                 {        
  546.                         lhj[i]=d[p1][j];
  547.                         lhj[i+1]=d[k1][j];
  548.         
  549.                           i=i+8;
  550.                         j=j+1;
  551.                 }
  552.                 for(i=2,j=0;i<128;)               
  553.                 {        
  554.                         lhj[i]=YUE[j];
  555.                         lhj[i+1]=YUE[j+1];
  556.         
  557.                           i=i+8;
  558.                         j=j+2;
  559.                 }
  560.                 for(i=4,j=0;i<128;)               
  561.                 {        
  562.                         lhj[i]=d[p2][j];
  563.                         lhj[i+1]=d[k2][j];
  564.         
  565.                           i=i+8;
  566.                         j=j+1;
  567.                 }
  568.                 for(i=6,j=0;i<128;)               
  569.                 {        
  570.                         lhj[i]=RI2[j];
  571.                         lhj[i+1]=RI2[j+1];
  572.         
  573.                           i=i+8;
  574.                         j=j+2;
  575.                 }
  576.            displayS2(1);
  577. }



  581. void extern1() interrupt 2                 //外部中断1
  582. {
  583.         displaynyr2();
  584.          if((key2 == 0)&&(key3 ==0))
  585.                  ISP_CONTR = 0x20;
  586.          
  587.          if(key3 == 0)  
  588.         {        
  589.                 if(key3 == 0)
  590.                 {
  591.                         numday++;
  592.                         if(numday > 31)
  593.                           numday = 1;
  594.                  }
  595.         }

  597.         if(key2 == 0)  
  598.         {        
  599.                 if(key2 == 0)
  600.                 {
  601.                         nummonth++;
  602.                         if(nummonth > 12)
  603.                                 nummonth = 1;
  604.                  }
  605.         }

  607.         key4 = 1;

  609. }        

  611. void extern0() interrupt 0                 //外部中断0
  612. {        

  614.                 displayshijian2();
  615.                 if(key2 == 0)                     //key2按键扫描，按下则 小时nums加1
  616.                 {        
  617.                         if(key2 == 0)
  618.                         {
  619.                                 nums++;
  620.                                 if(nums > 23)
  621.                                         nums =0;
  622.                          }
  623.                 }
  624.                 if(key3 == 0)                         //key3按键扫描，按下则 分钟numf加1
  625.                 {
  626.                         if(key3 == 0)
  627.                         {
  628.                                 numf++;
  629.                                 if(numf > 59)
  630.                                         numf =0;               
  631.                         }
  632.                 }
  633.         key1 = 1;                   //P3.2口赋高电平 防止下次重复进入中断        

  635. }
  636.         

  638. void T0timer() interrupt 1                   //定时器0中断
  639. {
  640.         TH0 = (65536-50000)/256;
  641.         TL0 = (65536-50000)%256;
  642.         numt0++;
  643.         if(numt0 >= 40)                //24M hz40次为一秒
  644.         {
  645.                 numt0 = 0;
  646.                 num++;
  647.                 if(num > 59)
  648.                 {        num = 0;
  649.                         numf++;
  650.                 }
  651.         }
  652. }

  654. void displaytu_an()
  655. {
  656.          unsigned char i,j;
  657.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  658.          {        
  659.                 lhj[i]=XL[j];
  660.                 lhj[i+1]=XL[j+1];

  662.                   i=i+8;
  663.                 j=j+2;
  664.             }
  665.          
  666.         for(i=4,j=0;i<128;)                                                        //复制安卓机器人图案到中间
  667.                  {        
  668.                         lhj[i]=ANZHUO[j];
  669.                         lhj[i+1]=ANZHUO[j+1];
  670.         
  671.                           i=i+8;
  672.                         j=j+2;
  673.                     }
  674.          displayS(4);                                      //显示图案约2秒

  676. }



  680. void shijianzz()
  681. {
  682. /***************************************************///时间自增
  683.         if(numf > 59)                           //分钟numf，小时nums自增
  684.         {
  685.                 numf = 0;
  686.                 nums++;
  687.                 if(nums > 23)
  688.                         {
  689.                         nums = 0;
  690.                         numday++;

  692.                         switch(nummonth)
  693.                         {
  694.                         case 1:
  695.                         case 3:
  696.                         case 5:
  697.                         case 7:
  698.                         case 8:
  699.                         case 10:
  700.                         case 12:  if(numday > 31)
  701.                                                 {        nummonth++;
  702.                                                         numday=1;
  703.                                                         if(nummonth > 12)
  704.                                                                 {
  705.                                                                  nummonth =1;
  706.                                                                  numyear++;        
  707.                                                                 }
  708.                                                 };        
  709.                                                 break;                                       
  710.                                           
  711.                         case 4:
  712.                         case 6:
  713.                         case 9:
  714.                         case 11:if(numday > 30)
  715.                                                 {        nummonth++;
  716.                                                         numday=1;
  717.                                                         if(nummonth > 12)
  718.                                                                 {nummonth =1;
  719.                                                                  numyear++;
  720.                                                                 }
  721.                                                 };        
  722.                                                 break;                                       

  724.                         case 2:        {
  725.                                          if(numyear%4==0)
  726.                                                 if(numday > 29  )
  727.                                                 {
  728.                                                         nummonth++;
  729.                                                         numday=1;
  730.                                                         if(nummonth > 12)
  731.                                                                 {nummonth = 1;
  732.                                                                  numyear++;
  733.                                                                 }        
  734.                                                 }
  735.                                          else
  736.                                                 if(numday > 28  )
  737.                                                 {
  738.                                                         nummonth++;
  739.                                                         numday=1;
  740.                                                         if(nummonth > 12)
  741.                                                                 {nummonth =1;
  742.                                                                  numyear++;
  743.                                                                 }        
  744.                                                 }
  745.                                         };break;        
  746.                         }
  747.                         
  748.                 }
  749.         }
  750. /*********************************************************/
  751. }

  753. void displayXNKL()
  754. {
  755.                  /*********逐个显示“老师们好”************/        
  756.         uchar i,j;
  757.         for(i=0,j=0;i<128;)               
  758.         {        
  759.                 lhj[i]=LAO[j];
  760.                 lhj[i+1]=LAO[j+1];

  762.                   i=i+8;
  763.                 j=j+2;
  764.         }
  765.         displayS(2);
  766.         
  767.         for(i=2,j=0;i<128;)               
  768.         {        
  769.                 lhj[i]=SHI1[j];
  770.                 lhj[i+1]=SHI1[j+1];

  772.                   i=i+8;
  773.                 j=j+2;
  774.         }
  775.         displayS(2);
  776.         
  777.         for(i=4,j=0;i<128;)               
  778.         {        
  779.                 lhj[i]=MEN[j];
  780.                 lhj[i+1]=MEN[j+1];

  782.                   i=i+8;
  783.                 j=j+2;
  784.         }
  785.         displayS(2);
  786.         
  787.         for(i=6,j=0;i<128;)               
  788.         {        
  789.                 lhj[i]=HAO[j];
  790.                 lhj[i+1]=HAO[j+1];

  792.                   i=i+8;
  793.                 j=j+2;
  794.         }
  795.         displayS(2);
  796. /**********************************/        

  798. }

  800. /********************** 主函数 *************************************/
  801. void main(void)           
  802. {

  804.         init();            //初始化程序
  805.         displaytu_an();
  806.         displayS(4);                  
  807.         while(1)
  808.         {
  809.          shijianzz();                                        //时间自增函数
  810.         displaymovetb(1,0,4,3);                         //向下清屏
  811.         displaymove(DIAN,4,1);                          //左跑马 “电气工程”
  812.         displayS(2);
  813.         displaymovetb(1,0,4,2);                        //向下卷帘清屏
  814.         displayXNKL();                                   //由左往右显示‘老师们好’
  815.         displayS(2);
  816.         displaymove(0,4,2);                    //左跑马清屏
  817.         displaymovetb(1,BEI,4,3);            //向下显示 “北京时间”
  818.         displayS(2);
  819.         displaymovetb(0,el,4,1);
  820.         displayS(2);
  821.         displaymovetb(1,lw,4,2);
  822.         displayS(2);
  823.         displaymove(xie,4,1);
  824.         displayS(3);
  825.         displaymovetb(1,0,4,3);                        //向下清屏
  826.         displaytu_an();
  827.         displayS(2);
  828.         /*displaymovetb(1,0,4,1);
  829.         displaynyr();                                    //显示****年**月**日
  830.         displayshijian();                            //调用显示**点**分 时间函数
  831.         displayS(4000);*/           
  832.         
  833.         }

  835. }
  836. /********************** 主函数 *************************************/

  838. void display2()                  //显示子函数 中断调用才使用
  839. {        
  840.         unsigned char i,ia,tmp;        
  841.         unsigned int j;
  842.         DATAOUT=0XFF;                                       
  843.         AB=0;                                                                                //将行数据位清0，准备移位
  844.         for(i=0;i<16;i++)
  845.         {               
  846.                 SCK=0;                        
  847.                 SCLT=0;                        
  848.                 for(ia=8;ia>0;)
  849.                 {                                                //每行64个点，循环位移8个字节
  850.                 ia--;                                                                        //循环四次
  851.                  tmp=~lhj[i*8+ia];        
  852.                         for(j=0;j<8;j++)
  853.                         {                                                //循环两次，每次移一个字节，
  854.                                 SCLH=0;                        
  855.                              DATA=tmp&0x01;                                             //将数据低位做输出
  856.                                 tmp>>=1;         
  857.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  858.                         }                                                                                //移入单字节结束
  859.                 }                                                                                //移入两个字节结束
  860.                 DATAOUT|=0X24;        
  861.                 //等价于SCK=1;               
  862.                 //      SCLT=1;               
  863.                 AB=1;               
  864.         }
  865.         j=100;
  866.         while(j--);                                          //每一行的显示，保持6个字节的移位时间，因此，最后一行的显示，也要加入保持时间，补尝显示的亮度
  867.         SCK=0;                                                  
  868.         SCK=1;                                                  //将最后一行数据移出
  869. }


  872. void display()                                             //显示子函数
  873. {        
  874.         unsigned char i,ia,tmp;        
  875.         unsigned int j;
  876.         DATAOUT=0XFF;                                       
  877.         AB=0;                                                                                //将行数据位清0，准备移位
  878.         for(i=0;i<16;i++)
  879.         {               
  880.                 SCK=0;                        
  881.                 SCLT=0;                        
  882.                 for(ia=8;ia>0;)
  883.                 {                                                //每行64个点，循环位移8个字节
  884.                 ia--;                                                                        //循环四次
  885.                  tmp=~lhj[i*8+ia];        
  886.                         for(j=0;j<8;j++)
  887.                         {                                                //循环两次，每次移一个字节，
  888.                                 SCLH=0;                        
  889.                              DATA=tmp&0x01;                                             //将数据低位做输出
  890.                                 tmp>>=1;         
  891.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  892.                         }                                                                                //移入单字节结束
  893.                 }                                                                                //移入两个字节结束
  894.                 DATAOUT|=0X24;        
  895.                 //等价于SCK=1;               
  896.                 //      SCLT=1;               
  897.                 AB=1;               
  898.         }
  899.         j=100;
  900.         while(j--);                                          //每一行的显示，保持6个字节的移位时间，因此，最后一行的显示，也要加入保持时间，补尝显示的亮度
  901.         SCK=0;                                                  
  902.         SCK=1;                                                  //将最后一行数据移出
  903. }


  906. void displayS2(unsigned int timer)                   //指定时间扫描显示函数 中断调用时用
  907. {
  908.         unsigned char i;        
  909.         while(timer--)
  910.         {                                  //当timer=1时，大约1秒时间
  911.                 i=20;               
  912.                 while(i--)
  913.                         display2();
  914.         }
  915. }



  919. void displayS(unsigned int timer)            //指定时间扫描显示函数
  920. {
  921.         unsigned char i;        
  922.         while(timer--)
  923.         {                                  //当timer=1时，大约1秒时间
  924.                 i=20;               
  925.                 while(i--)
  926.                         display();
  927.         }
  928. }

  930. void displaymove(unsigned char *lp,unsigned char c,unsigned char timer)//左移显示函数，LP指向要显示第一个字的首地址，C表示显示字的个数，
  931.                                                                                                                                                 //timer是移动的速度
  932. {
  933.         unsigned char i=0,j=0,ia=0;
  934.         unsigned int tmp=0,timerc=0;
  935.         unsigned char tmp2[16];
  936.         c*=2;               
  937.         for(i=0;i<16;i++)
  938.                 tmp2[i]=0;                                            //将缓冲区清0，
  939.         while(c)
  940.         {
  941.                 if(lp!=0)
  942.                 {                                            //当lp指向的地址为0时，直接用组缓冲0补上，效果是将当前显示的内容移出
  943.                 tmp=c%2;                                                                        //取余，目的是为了判断处理汉字的前半部份还是后半部份
  944.                 for(i=0;i<16;i++)
  945.                         {               
  946.                                 tmp2[i]=lp[i*2+tmp];                                        //取半个汉字点阵数据，16字节
  947.                         }
  948.                 if(tmp)                                                                                //当tmp为1时，表时一个字数组处理完成，将地址转到下一个字
  949.                         lp+=32;
  950.                 }
  951.                 //--------------
  952.                 tmp=8;                                                                                //变量再次利用
  953.                 while(tmp)
  954.                 {                                                                        //循环8次，是将下一个字的前半部份的字节数据移入显示缓冲        
  955.                 ia=0;                                                                                //做为点阵数组的元素
  956.                 for(i=0;i<16;i++)
  957.                 {                                                        //移动是16行同时移，因此要处理16个字节
  958.                         for(j=0;j<7;j++)
  959.                         {                                                //一行32个点四字节，有三字节在显示缓冲中移动
  960.                                 lhj[ia]<<=1;                                                //移当前显示缓冲的半行字节
  961.                                 if(lhj[ia+1]&0x80)                                        //判断后半行字节的高位是否为1，是移入前半行字节低位，否则不处理
  962.                                         lhj[ia]++;
  963.                                 ia++;
  964.                         }
  965.                         lhj[ia]<<=1;                                                        //一行32个点四字节，将最后一字节用下一个字补上
  966.                         if(tmp2[i]&0x80)                                                //判断下一个要显示汉字的前半行字节的高位是否为1，是移入，否则不处理
  967.                                 lhj[ia]++;
  968.                         ia++;
  969.                         tmp2[i]<<=1;                                                        //下一个要显示汉字的半行字节向高位移一位，准备下一次取位
  970.                 }
  971.                 tmp--;
  972.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  973.                 while(timerc--)                                                                        //循环做为处理的速度，即移动的速度
  974.                         display();
  975.                 }
  976.                 //----------
  977.                 c--;                                                                                        //移完一半，进入下一半或下一个汉字，直到结束
  978.         }
  979. }


  982. void displaymove2(unsigned char *lp,unsigned char c,unsigned char timer)//左移显示函数，LP指向要显示第一个字的首地址，C表示显示字的个数，
  983.                                                                                                                                                 //timer是移动的速度
  984. {
  985.         unsigned char i=0,j=0,ia=0;
  986.         unsigned int tmp=0,timerc=0;
  987.         unsigned char tmp2[16];
  988.         c*=2;               
  989.         for(i=0;i<16;i++)
  990.                 tmp2[i]=0;                                            //将缓冲区清0，
  991.         while(c)
  992.         {
  993.                 if(lp!=0)
  994.                 {                                            //当lp指向的地址为0时，直接用组缓冲0补上，效果是将当前显示的内容移出
  995.                 tmp=c%2;                                                                        //取余，目的是为了判断处理汉字的前半部份还是后半部份
  996.                 for(i=0;i<16;i++)
  997.                         {               
  998.                                 tmp2[i]=lp[i*2+tmp];                                        //取半个汉字点阵数据，16字节
  999.                         }
  1000.                 if(tmp)                                                                                //当tmp为1时，表时一个字数组处理完成，将地址转到下一个字
  1001.                         lp+=32;
  1002.                 }
  1003.                 //--------------
  1004.                 tmp=8;                                                                                //变量再次利用
  1005.                 while(tmp)
  1006.                 {                                                                        //循环8次，是将下一个字的前半部份的字节数据移入显示缓冲        
  1007.                 ia=0;                                                                                //做为点阵数组的元素
  1008.                 for(i=0;i<16;i++)
  1009.                 {                                                        //移动是16行同时移，因此要处理16个字节
  1010.                         for(j=0;j<7;j++)
  1011.                         {                                                //一行32个点四字节，有三字节在显示缓冲中移动
  1012.                                 lhj[ia]<<=1;                                                //移当前显示缓冲的半行字节
  1013.                                 if(lhj[ia+1]&0x80)                                        //判断后半行字节的高位是否为1，是移入前半行字节低位，否则不处理
  1014.                                         lhj[ia]++;
  1015.                                 ia++;
  1016.                         }
  1017.                         lhj[ia]<<=1;                                                        //一行32个点四字节，将最后一字节用下一个字补上
  1018.                         if(tmp2[i]&0x80)                                                //判断下一个要显示汉字的前半行字节的高位是否为1，是移入，否则不处理
  1019.                                 lhj[ia]++;
  1020.                         ia++;
  1021.                         tmp2[i]<<=1;                                                        //下一个要显示汉字的半行字节向高位移一位，准备下一次取位
  1022.                 }
  1023.                 tmp--;
  1024.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1025.                 while(timerc--)                                                                        //循环做为处理的速度，即移动的速度
  1026.                         display2();
  1027.                 }
  1028.                 //----------
  1029.                 c--;                                                                                        //移完一半，进入下一半或下一个汉字，直到结束
  1030.         }
  1031. }




  1036. void displaymovetb(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1037. //上下移动显示函数，din：1为向下，0为向上，lp指向要移入的内容，C表示有几个汉字要移，timer为移动速度
  1038. {
  1039.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1040.         unsigned int tmp=0,timerc=0;
  1041.         if(din)
  1042.         {                                                                                                        //判断移动方向，向下
  1043.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1044.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1045.         ic=96;
  1046.         id=128;
  1047.         i=16;                                                                                                        //行索引
  1048.         while(i--)
  1049.         {                                                                                                       //逐行处理
  1050.                   j=120;
  1051.                 while(j)
  1052.                 {
  1053.                         j--;
  1054.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行，每两行内容相隔6个字节，复制15行
  1055.                 }
  1056.                 if(lp==0)
  1057.                 {                                                                                        //最后一行的处理，判断移入的内容是否为空，是用0移入
  1058.                         j=8;
  1059.                         while(j--)
  1060.                                 lhj[j]=0;
  1061.                 }
  1062.                 else
  1063.                 {                                                                                                //否则，取字数组处理
  1064.                         ia--;ib--;ic--;id--        ;

  1066.                         if(c==4)
  1067.                         {                                                                                //判断4个字，移一行，6个字节
  1068.                         lhj[1]=lp[ia];
  1069.                         ia--;
  1070.                         lhj[0]=lp[ia];
  1071.                         lhj[3]=lp[ib];
  1072.                         ib--;
  1073.                         lhj[2]=lp[ib];
  1074.                         lhj[5]=lp[ic];
  1075.                         ic--;
  1076.                         lhj[4]=lp[ic];
  1077.                         lhj[7]=lp[id];
  1078.                         id--;
  1079.                         lhj[6]=lp[id];
  1080.                         }


  1083.                         else if(c==3)
  1084.                         {                                                                //否则3个字，将字放在中间，旁边补0
  1085.                         lhj[0]=0;
  1086.                         lhj[2]=lp[ia];
  1087.                         ia--;
  1088.                         lhj[1]=lp[ia];
  1089.                         lhj[4]=lp[ib];
  1090.                         ib--;
  1091.                         lhj[3]=lp[ib];
  1092.                         lhj[6]=lp[ic];
  1093.                         ic--;
  1094.                         lhj[5]=lp[ic];
  1095.                         lhj[7]=0;
  1096.                         }

  1098.                         else if(c==2)
  1099.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1100.                         lhj[0]=0;
  1101.                         lhj[1]=0;

  1103.                         lhj[3]=lp[ia];
  1104.                         ia--;
  1105.                         lhj[2]=lp[ia];
  1106.                         lhj[5]=lp[ib];
  1107.                         ib--;
  1108.                         lhj[4]=lp[ib];                        
  1109.                         lhj[6]=0;
  1110.                          lhj[7]=0;
  1111.                         }
  1112.                         else if(c==1)
  1113.                         {                                                                //否则1个字，将字放在中间，旁边补0
  1114.                         lhj[0]=0;
  1115.                         lhj[1]=0;
  1116.                          lhj[2]=0;

  1118.                         lhj[4]=lp[ia];
  1119.                         ia--;
  1120.                         lhj[3]=lp[ia];

  1122.                         lhj[5]=0;        
  1123.                         lhj[6]=0;
  1124.                         lhj[7]=0;

  1126.                         }
  1127.                 }
  1128.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1129.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1130.                         display();
  1131.         }
  1132.         }
  1133.         else
  1134.         {                                                                                        //移动方向，向上
  1135.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动，移入汉字从低位开始

  1137.                 for(i=0;i<16;i++)
  1138.                 {                                                        //处理16行
  1139.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行，每两行内容相隔6个字节，复制15行
  1140.                                 lhj[j]=lhj[j+8];
  1141.                         if(lp==0)
  1142.                         {                                                                //最后一行的处理，判断移入的内容是否为空，是用0移入
  1143.                                 while(j!=128)
  1144.                                 {
  1145.                                         lhj[j]=0;
  1146.                                         j++;
  1147.                                    }
  1148.                         }
  1149.                         else
  1150.                         {                                                                        //否则，取字数组处理
  1151.                         if(c==4)
  1152.                         {                                                                  //判断4个字，移一行，8个字节                                       
  1153.                                 lhj[120]=lp[ia];
  1154.                                 lhj[121]=lp[ia+1];
  1155.                                 lhj[122]=lp[ib];
  1156.                                 lhj[123]=lp[ib+1];
  1157.                                 lhj[124]=lp[ic];
  1158.                                 lhj[125]=lp[ic+1];
  1159.                                  lhj[126]=lp[id];
  1160.                                  lhj[127]=lp[id+1];

  1162.                                 ia+=2;ib+=2;ic+=2;id+=2;                           
  1163.                         }
  1164.                         else if(c==3)
  1165.                         {                                                        //否则3个字，将字放在中间，旁边补0
  1166.                                 lhj[120]=0;
  1167.                                 lhj[121]=lp[ia];
  1168.                                 lhj[122]=lp[ia+1];
  1169.                                 lhj[123]=lp[ib];
  1170.                                 lhj[124]=lp[ib+1];
  1171.                                 lhj[125]=lp[ic];
  1172.                                 lhj[126]=lp[ic+1];
  1173.                                 lhj[127]=0;
  1174.                                 ia+=2;ib+=2;ic+=2;
  1175.                         }
  1176.                         else if(c==2)
  1177.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1178.                                 lhj[120]=0;
  1179.                                 lhj[121]=0;
  1180.                                 lhj[122]=lp[ia];
  1181.                                 lhj[123]=lp[ia+1];
  1182.                                 lhj[124]=lp[ib];
  1183.                                 lhj[125]=lp[ib+1];
  1184.                                 lhj[126]=0;
  1185.                                 lhj[127]=0;
  1186.                                 ia+=2;ib+=2;
  1187.                         }
  1188.                         else
  1189.                         {                                                                                //判断1个字，移一行，8个字节，将字放在中间，两边补0
  1190.                                 lhj[120]=0;
  1191.                                 lhj[121]=0;
  1192.                                 lhj[122]=0;
  1193.                                 lhj[123]=lp[ia];
  1194.                                 ia++;
  1195.                                 lhj[124]=lp[ia];
  1196.                                 ia++;
  1197.                                 lhj[125]=0;
  1198.                                 lhj[126]=0;
  1199.                                 lhj[127]=0;

  1201.                          }
  1202.                         }
  1203.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1204.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1205.                         display();
  1206.                    }
  1207.            }
  1208.                         
  1209. }


  1212. void displaymovetb2(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1213. //上下移动显示函数，din：1为向下，0为向上，lp指向要移入的内容，C表示有几个汉字要移，timer为移动速度
  1214. {
  1215.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1216.         unsigned int tmp=0,timerc=0;
  1217.         if(din)
  1218.         {                                                                                                        //判断移动方向，向下
  1219.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1220.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1221.         ic=96;
  1222.         id=128;
  1223.         i=16;                                                                                                        //行索引
  1224.         while(i--)
  1225.         {                                                                                                       //逐行处理
  1226.                   j=120;
  1227.                 while(j)
  1228.                 {
  1229.                         j--;
  1230.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行，每两行内容相隔6个字节，复制15行
  1231.                 }
  1232.                 if(lp==0)
  1233.                 {                                                                                        //最后一行的处理，判断移入的内容是否为空，是用0移入
  1234.                         j=8;
  1235.                         while(j--)
  1236.                                 lhj[j]=0;
  1237.                 }
  1238.                 else
  1239.                 {                                                                                                //否则，取字数组处理
  1240.                         ia--;ib--;ic--;id--        ;

  1242.                         if(c==4)
  1243.                         {                                                                                //判断4个字，移一行，6个字节
  1244.                         lhj[1]=lp[ia];
  1245.                         ia--;
  1246.                         lhj[0]=lp[ia];
  1247.                         lhj[3]=lp[ib];
  1248.                         ib--;

  1250.                         lhj[2]=lp[ib];

  1252.                         lhj[5]=lp[ic];
  1253.                         ic--;
  1254.                         lhj[4]=lp[ic];

  1256.                         lhj[7]=lp[id];
  1257.                         id--;
  1258.                         lhj[6]=lp[id];
  1259.                         }

  1261.                         else if(c==3)
  1262.                         {                                                                //否则3个字，将字放在中间，旁边补0
  1263.                         lhj[0]=0;
  1264.                         lhj[2]=lp[ia];
  1265.                         ia--;
  1266.                         lhj[1]=lp[ia];
  1267.                         lhj[4]=lp[ib];
  1268.                         ib--;
  1269.                         lhj[3]=lp[ib];
  1270.                         lhj[6]=lp[ic];
  1271.                         ic--;
  1272.                         lhj[5]=lp[ic];
  1273.                         lhj[7]=0;
  1274.                         }


  1277.                         else if(c==2)
  1278.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1279.                         lhj[0]=0;
  1280.                         lhj[1]=0;

  1282.                         lhj[3]=lp[ia];
  1283.                         ia--;
  1284.                         lhj[2]=lp[ia];
  1285.                         lhj[5]=lp[ib];
  1286.                         ib--;
  1287.                         lhj[4]=lp[ib];                        
  1288.                         lhj[6]=0;
  1289.                          lhj[7]=0;

  1291.                         }
  1292.                         else if(c==1)
  1293.                         {                                                                //否则1个字，将字放在中间，旁边补0
  1294.                         lhj[0]=0;
  1295.                         lhj[1]=0;
  1296.                          lhj[2]=0;

  1298.                         lhj[4]=lp[ia];
  1299.                         ia--;
  1300.                         lhj[3]=lp[ia];

  1302.                         lhj[5]=0;        
  1303.                         lhj[6]=0;
  1304.                         lhj[7]=0;

  1306.                         }
  1307.                 }
  1308.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1309.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1310.                         display();
  1311.         }
  1312.         }
  1313.         else
  1314.         {                                                                                        //移动方向，向上
  1315.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动，移入汉字从低位开始

  1317.                 for(i=0;i<16;i++)
  1318.                 {                                                        //处理16行
  1319.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行，每两行内容相隔6个字节，复制15行
  1320.                                 lhj[j]=lhj[j+8];
  1321.                         if(lp==0)
  1322.                         {                                                                //最后一行的处理，判断移入的内容是否为空，是用0移入
  1323.                                 while(j!=128)
  1324.                                 {
  1325.                                         lhj[j]=0;
  1326.                                         j++;
  1327.                                    }
  1328.                         }
  1329.                         else
  1330.                         {                                                                        //否则，取字数组处理
  1331.                         if(c==4)
  1332.                         {                                                                  //判断4个字，移一行，8个字节                                       
  1333.                                 lhj[120]=lp[ia];
  1334.                                 lhj[121]=lp[ia+1];
  1335.                                 lhj[122]=lp[ib];
  1336.                                 lhj[123]=lp[ib+1];
  1337.                                 lhj[124]=lp[ic];
  1338.                                 lhj[125]=lp[ic+1];
  1339.                                  lhj[126]=lp[id];
  1340.                                  lhj[127]=lp[id+1];

  1342.                                 ia+=2;ib+=2;ic+=2;id+=2;                           
  1343.                         }
  1344.                         else if(c==3)
  1345.                         {                                                        //否则3个字，将字放在中间，旁边补0
  1346.                                 lhj[120]=0;
  1347.                                 lhj[121]=lp[ia];
  1348.                                 lhj[122]=lp[ia+1];
  1349.                                 lhj[123]=lp[ib];
  1350.                                 lhj[124]=lp[ib+1];
  1351.                                 lhj[125]=lp[ic];
  1352.                                 lhj[126]=lp[ic+1];
  1353.                                 lhj[127]=0;
  1354.                                 ia+=2;ib+=2;ic+=2;
  1355.                         }
  1356.                         else if(c==2)
  1357.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1358.                                 lhj[120]=0;
  1359.                                 lhj[121]=0;
  1360.                                 lhj[122]=lp[ia];
  1361.                                 lhj[123]=lp[ia+1];
  1362.                                 lhj[124]=lp[ib];
  1363.                                 lhj[125]=lp[ib+1];
  1364.                                 lhj[126]=0;
  1365.                                 lhj[127]=0;
  1366.                                 ia+=2;ib+=2;
  1367.                         }
  1368.                         else
  1369.                         {                                                                                //判断1个字，移一行，8个字节，将字放在中间，两边补0
  1370.                                 lhj[120]=0;
  1371.                                 lhj[121]=0;
  1372.                                 lhj[122]=0;
  1373.                                 lhj[123]=lp[ia];
  1374.                                 ia++;
  1375.                                 lhj[124]=lp[ia];
  1376.                                 ia++;
  1377.                                 lhj[125]=0;
  1378.                                 lhj[126]=0;
  1379.                                 lhj[127]=0;
  1380.                          }
  1381.                         }
  1382.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1383.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1384.                         display();
  1385.                    }
  1386.            }                        
  1387. }
复制代码


作者: levous    时间: 2015-6-25 17:10
欢饮大家下载
作者: admin    时间: 2016-5-12 03:37
这个设计很不错，51黑有你更精彩！！！
作者: wang7606    时间: 2016-5-14 17:55
新手学习了
作者: wangsiat    时间: 2016-8-17 00:05
点阵显示屏
作者: LeonLee    时间: 2016-9-12 19:32
有没有proteus仿真图啊？
作者: 我是小勇    时间: 2016-10-17 22:45
楼主，有个毕业设计也是点阵屏汉字显示，要求能在pc端控制输出的汉字，能够联系下探讨探讨
作者: 小白吕    时间: 2016-10-22 01:32
谢谢楼主
作者: 1002章鱼    时间: 2016-11-20 18:02

有没有proteus仿真图啊？
作者: 沫熙时间    时间: 2016-12-21 13:40
厉害，感谢分享
作者: 盗版小温    时间: 2016-12-26 02:08
可以的  好东西 值得一顶
作者: 东北那谁    时间: 2016-12-28 16:19
谢谢楼主
作者: 1605104939    时间: 2017-1-2 18:19
下载下来结果发现。。。。。
作者: 无罪之宾    时间: 2017-1-2 19:28
不错，好好学学，应该有帮助
作者: dfdd    时间: 2017-1-2 19:32
写的好多，辛苦了！
作者: 鸭梨125    时间: 2017-4-27 13:30
写的真棒楼主有做三基色的显示屏吗
作者: hqboy    时间: 2017-5-6 16:35
谢谢楼主！ 我这里正好有16*64的点阵屏 。参考下看能不能改一个出来、
作者: 185408744    时间: 2017-5-15 17:42
感谢大神的分享
作者: elise    时间: 2017-5-16 10:26
不知道什么时候我也能写出这样的程序。。。很是羡慕。。。我继续学习。。感谢分享，下载保存以备之后学习！
作者: XDDZ1013    时间: 2017-5-16 20:23
好资料，下载学习
作者: 海海海哥啦    时间: 2017-6-4 09:24
很好，很实用的哦
作者: viver    时间: 2017-6-4 12:44
多谢楼主分享，对我很有帮助
作者: 编程993    时间: 2017-6-4 14:51
厉害厉害！
作者: REN7777777    时间: 2017-9-5 08:40
不错 很好
作者: sxzu    时间: 2017-9-5 09:18
不错，注释也很详细，很有用！
作者: qxdqx    时间: 2017-10-21 19:49
谢谢分享!是学习的很好资料.
作者: 持勤补拙    时间: 2017-10-22 00:12
感谢楼主分享
作者: tbjgdtcn    时间: 2017-12-15 16:07
有没有proteus仿真图啊？
作者: 无敌123    时间: 2018-4-16 10:42
我是小勇 发表于 2016-10-17 22:45
**** 作者被禁止或删除 内容自动屏蔽 ****

哇，我现在的毕设就是你这个可以请教下大神吗
作者: ysyzgt    时间: 2018-4-24 08:22
谢谢楼主的分享，好好的学习一下
作者: zbj6321    时间: 2018-5-1 13:57
终于找到了这个 不知道电路图怎么样
作者: 彳亍望月人    时间: 2018-5-3 23:46
程序好长，不过我做的8*16的
作者: 东大门    时间: 2018-5-30 22:15
厉害啦楼主
作者: billy226    时间: 2018-9-7 15:18
厉害啦楼主
作者: suqing130op    时间: 2018-10-18 23:30
厉害了毕业设计有希望了，谢谢楼主
作者: 对方哈根达斯    时间: 2018-12-6 13:59
绝世好帖！
作者: 迷路    时间: 2018-12-25 15:57
感谢楼主分享用处很大
作者: yext    时间: 2019-3-27 07:54
谢谢楼主。不知道能不能修改用于08接口的屏。
作者: he972382779    时间: 2019-9-24 13:08
感谢！
作者: he972382779    时间: 2019-9-24 13:08
感谢楼主
作者: 4526231424    时间: 2019-12-20 20:09
这个是16*64点阵显示屏吗？
作者: zhoufayin    时间: 2019-12-23 22:08
谢谢楼主！
作者: jiangzn2020    时间: 2020-2-6 16:43
感谢楼主
作者: 天道酬情    时间: 2020-4-24 22:58
有大佬成功做出来了吗？
作者: wangkkk    时间: 2020-4-28 11:39
太好了 感谢
作者: vaad    时间: 2020-5-5 09:33
请问你这使用8片74HC595级联的吗？
作者: 勿忘我科技    时间: 2020-5-8 13:40
好东西 ，收藏了
作者: HEHELO    时间: 2020-5-11 14:41
大神们千行代码信手捏来啊！！！我之前用仿真做了一个64*16的点阵，显示超两个字就闪起来了，我还以为是51带不动。。。。。
作者: angel168111    时间: 2020-5-14 17:33
谢谢楼主，不过不是proteus
作者: 电控2001    时间: 2020-5-14 19:40
值得学习



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