标题: 48×16点阵LED电子显示屏的设计 程序+电路图+pcb文件 [打印本页]
作者: dzdiy    时间: 2015-4-11 21:50
标题: 48×16点阵LED电子显示屏的设计 程序+电路图+pcb文件
   LED点阵显示屏作为一种新兴的显示器件,是由多个独立的LED发光二极管封装而成。这个48×16点阵LED电子显示屏的设计,是多网上看到到，感觉比较适合初学者制作，特此进行转载，在这里要感谢原作者颜志伟的无私奉献。LED点阵显示屏可以显示数字或符号, 通常用来显示时间、速度、系统状态等。本设计是48×16点阵LED电子显示屏的设计。整机以美国STC公司生产的40脚单片机STC89C52为核心，介绍了以它为控制系统的LED点阵电子显示屏的动态设计和开发过程。通过该芯片控制八个行驱动器74HC164和八个列驱动器74HC595来驱动显示屏显示。该电子显示屏可以显示各种文字或单色图像，全屏能显示4个汉字，采用16块8 x 8点阵LED显示模块来组成4个16x16点阵显示模式。显示采用动态显示，使得图形或文字能够实现静止、移入移出等多种显示方式。文中详细介绍了LED点阵显示的硬件设计思路、硬件电路各个部分的功能及原理、相应软件的程序设计，以及使用说明等。这里就不一一介绍，文章后面的资料都有介绍，需要的可以自己下载。

   电路图pcb及其源程序打包下载： 4个16乘16LED点阵资料.rar (2.38 MB, 下载次数: 1322)



源代码如下：
  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. /******************  字模  *************************/
  39. code unsigned char         WU[32]={
  40.           0x11,0x00,0x11,0x00,0x51,0x00,0x51,0x04,
  41.       0x7B,0xFE,0x54,0xA4,0x90,0xA4,0x1C,0xA4,
  42.       0x31,0x24,0xD1,0x44,0x12,0x44,0x12,0x44,
  43.       0x14,0x84,0x10,0x84,0x11,0x28,0x10,0x10};//物
  44. code unsigned char DIAN[32]={
  45.           0x02,0x00,0x02,0x00,0x02,0x10,0x7F,0xF8,
  46.       0x42,0x10,0x42,0x10,0x7F,0xF0,0x42,0x10,
  47.       0x42,0x10,0x7F,0xF0,0x42,0x10,0x02,0x00,
  48.       0x02,0x04,0x02,0x04,0x01,0xFC,0x00,0x00};//电
  49. code unsigned char XUE[32]={
  50.           0x22,0x08,0x11,0x08,0x11,0x10,0x00,0x20,
  51.       0x7F,0xFE,0x40,0x02,0x80,0x04,0x1F,0xE0,
  52.       0x00,0x40,0x01,0x84,0xFF,0xFE,0x01,0x00,
  53.       0x01,0x00,0x01,0x00,0x05,0x00,0x02,0x00}; //学
  54. code unsigned char YUAN[32]={
  55.           0x00,0x80,0x78,0x40,0x4F,0xFE,0x54,0x02,
  56.       0x58,0x14,0x63,0xF8,0x50,0x00,0x48,0x08,
  57.       0x4F,0xFC,0x48,0xA0,0x68,0xA0,0x50,0xA0,
  58.       0x41,0x22,0x41,0x22,0x42,0x1E,0x4C,0x00};         //院


  61. code unsigned char LING[32]={
  62.           0x1F,0xF0,0x01,0x00,0x7F,0xFE,0x41,0x02,
  63.       0x9D,0x74,0x01,0x00,0x1D,0x70,0x02,0x80,
  64.       0x0C,0x60,0x32,0x18,0xC1,0x06,0x0F,0xE0,
  65.       0x00,0x40,0x02,0x80,0x01,0x00,0x00,0x80};         //零

  67. code unsigned char JIU[32]={
  68.           0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x20,
  69.       0xFF,0xF0,0x04,0x20,0x04,0x20,0x04,0x20,
  70.       0x04,0x20,0x04,0x20,0x08,0x20,0x08,0x20,
  71.       0x10,0x22,0x10,0x22,0x20,0x1E,0xC0,0x00};          //九
  72. code unsigned char DIAN1[32]={
  73.           0x02,0x00,0x02,0x00,0x02,0x10,0x7F,0xF8,
  74.       0x42,0x10,0x42,0x10,0x7F,0xF0,0x42,0x10,
  75.       0x42,0x10,0x7F,0xF0,0x42,0x10,0x02,0x00,
  76.       0x02,0x04,0x02,0x04,0x01,0xFC,0x00,0x00};          //电

  78. code unsigned char ZI[32]={
  79.           0x00,0x00,0x3F,0xF0,0x00,0x10,0x00,0x20,
  80.       0x00,0x40,0x01,0x80,0x01,0x04,0xFF,0xFE,
  81.       0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  82.       0x01,0x00,0x01,0x00,0x05,0x00,0x02,0x00};          //子
  83. code unsigned char XIN[32]={
  84.           0x10,0x08,0x0A,0x1C,0x7F,0x60,0x00,0x40,
  85.       0x22,0x40,0x14,0x44,0xFF,0xFE,0x0A,0x48,
  86.       0x7F,0x48,0x08,0x48,0x0A,0x48,0x29,0x88,
  87.       0x48,0x88,0x89,0x08,0x28,0x08,0x10,0x08};          //新
  88. code unsigned char NIAN[32]={
  89.       0x08,0x00,0x08,0x08,0x1F,0xFC,0x11,0x00,
  90.       0x21,0x00,0x41,0x10,0x1F,0xF8,0x11,0x00,
  91.       0x11,0x00,0x11,0x04,0xFF,0xFE,0x01,0x00,
  92.       0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00};           //年
  93. code unsigned char KUAI[32]={
  94.           0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x88,
  95.       0x5B,0xFC,0x54,0x88,0x50,0x88,0x90,0x88,
  96.       0x10,0x88,0x1F,0xFE,0x10,0x80,0x11,0x40,
  97.       0x11,0x20,0x12,0x10,0x14,0x0E,0x18,0x04};          //快
  98. code unsigned char LE[32]={
  99.           0x00,0x20,0x00,0xF0,0x1F,0x00,0x10,0x00,
  100.       0x11,0x00,0x11,0x00,0x21,0x04,0x7F,0xFE,
  101.       0x01,0x00,0x01,0x00,0x09,0x20,0x09,0x10,
  102.       0x11,0x08,0x21,0x0C,0x45,0x04,0x02,0x00};          //乐
  103. code unsigned char BEI[32] ={
  104.           0x04,0x80,0x04,0x80,0x04,0x88,0x04,0x98,
  105.       0x04,0xA0,0x7C,0xC0,0x04,0x80,0x04,0x80,
  106.       0x04,0x80,0x04,0x80,0x04,0x80,0x04,0x80,
  107.       0x1C,0x82,0xE4,0x82,0x44,0x7E,0x00,0x00};           //北
  108. code unsigned char JING[32] = {
  109.           0x02,0x00,0x01,0x00,0x01,0x04,0xFF,0xFE,
  110.       0x00,0x10,0x1F,0xF8,0x10,0x10,0x10,0x10,
  111.       0x10,0x10,0x1F,0xF0,0x01,0x00,0x09,0x40,
  112.       0x09,0x30,0x11,0x18,0x25,0x08,0x02,0x00};           //京
  113. code unsigned char SHI[32] = {
  114.           0x00,0x08,0x04,0x08,0x7E,0x08,0x44,0x08,
  115.       0x47,0xFE,0x44,0x08,0x44,0x08,0x7C,0x88,
  116.       0x44,0x48,0x44,0x48,0x44,0x08,0x44,0x08,
  117.       0x7C,0x08,0x44,0x48,0x00,0x28,0x00,0x10};                //时
  118. code unsigned char JIAN[32] = {
  119.           0x20,0x04,0x1B,0xFE,0x08,0x04,0x40,0x24,
  120.       0x4F,0xF4,0x48,0x24,0x48,0x24,0x48,0x24,
  121.       0x4F,0xE4,0x48,0x24,0x48,0x24,0x48,0x24,
  122.       0x4F,0xE4,0x48,0x24,0x40,0x14,0x40,0x08};                //间

  124. code unsigned char XL[32]={
  125.                 0x07,0xc0,0x18,0x30,0x20,0x08,0x40,0x04,
  126.                 0x4C,0x64,0x8C,0x62,0x80,0x02,0x80,0x02,
  127.                 0x90,0x12,0x98,0x32,0x4C,0x64,0x47,0xC4,
  128.                 0x20,0x08,0x18,0x30,0x07,0xC0,0x00,0x00};  //笑脸
  129. code unsigned char ANZHUO[32]={
  130.                 0x08,0x20,0x03,0x80,0x07,0xc0,0x0d,0x60,
  131.                 0x0f,0xe0,0x00,0x00,0x6f,0xec,0x6f,0xec,
  132.                 0x6f,0xec,0x6f,0xec,0x6f,0xec,0x0f,0xe0,
  133.                 0x06,0xc0,0x06,0xc0,0x06,0xc0,0x00,0x00};    //安卓
  134. code unsigned char HOU[32]={
  135.           0x02,0x00,0x02,0x00,0x02,0x08,0x03,0xFC,
  136.       0x02,0x00,0x02,0x10,0x3F,0xF8,0x20,0x10,
  137.       0x20,0x10,0x20,0x10,0x3F,0xF0,0x00,0x00,
  138.       0x29,0x10,0x24,0xC8,0x44,0x44,0x80,0x04};          //“点”
  139. code unsigned char MIN[32]={
  140.           0x00,0x80,0x04,0x80,0x04,0x40,0x08,0x40,
  141.       0x08,0x20,0x10,0x10,0x20,0x08,0x4F,0xEE,
  142.       0x84,0x24,0x04,0x20,0x04,0x20,0x04,0x20,
  143.       0x04,0x20,0x08,0x20,0x11,0x40,0x20,0x80};          //“分”
  144. code unsigned char NIAN2[32]={
  145.       0x08,0x00,0x08,0x08,0x1F,0xFC,0x11,0x00,
  146.       0x21,0x00,0x41,0x10,0x1F,0xF8,0x11,0x00,
  147.       0x11,0x00,0x11,0x04,0xFF,0xFE,0x01,0x00,
  148.       0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  149.                                                         };             //年
  150. code unsigned char YUE[32]={
  151.           0x00,0x10,0x0F,0xF8,0x08,0x10,0x08,0x10,
  152.       0x08,0x10,0x0F,0xF0,0x08,0x10,0x08,0x10,
  153.       0x08,0x10,0x0F,0xF0,0x08,0x10,0x08,0x10,
  154.       0x10,0x10,0x10,0x10,0x20,0x50,0x40,0x20,
  155.                                                         };                  //月
  156. code unsigned char RI2[32]={
  157.           0x00,0x10,0x1F,0xF8,0x10,0x10,0x10,0x10,
  158.       0x10,0x10,0x10,0x10,0x10,0x10,0x1F,0xF0,
  159.       0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
  160.       0x10,0x10,0x1F,0xF0,0x10,0x10,0x00,0x00
  161.                                                         };                   //日
  162. //时数据
  163. code unsigned char c[3][16]={
  164. ///*--  文字:  0  --*//*--  楷体_GB231212;  此字体下对应的点阵为：宽x高=8x16   --*/
  165. {0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,},
  166. {///*--  文字:  1  --*/
  167. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,},
  168. {///*--  文字:  2  --*/
  169. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,}
  170. };

  172. code unsigned char d[10][16]={
  173. {///*--  文字:  0  --*/
  174. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  175. },
  176. {///*--  文字:  1  --*/
  177. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  178. },
  179. {///*--  文字:  2  --*/
  180. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  181. },
  182. {///*--  文字:  3  --*/
  183. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  184. },
  185. {///*--  文字:  4  --*/
  186. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  187. },
  188. {///*--  文字:  5  --*/
  189. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  190. },
  191. {///*--  文字:  6  --*/
  192. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  193. },
  194. {///*--  文字:  7  --*/
  195. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  196. },
  197. {///*--  文字:  8  --*/
  198. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  199. },
  200. {///*--  文字:  9  --*/
  201. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,}
  202. };

  204. //分数据
  205. code unsigned char b[10][16]={
  206. {///*--  文字:  0  --*/
  207. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  208. },
  209. {///*--  文字:  1  --*/
  210. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  211. },
  212. {///*--  文字:  2  --*/
  213. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  214. },
  215. {///*--  文字:  3  --*/
  216. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  217. },
  218. {///*--  文字:  4  --*/
  219. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  220. },
  221. {///*--  文字:  5  --*/
  222. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  223. },
  224. {///*--  文字:  6  --*/
  225. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  226. },
  227. {///*--  文字:  7  --*/
  228. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  229. },
  230. {///*--  文字:  8  --*/
  231. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  232. },
  233. {///*--  文字:  9  --*/
  234. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  235. }
  236. };


  239. code unsigned char a[6][16]={
  240. {///*--  文字:  0  --*/
  241. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  242. },
  243. {///*--  文字:  1  --*/
  244. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  245. },
  246. {///*--  文字:  2  --*/
  247. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  248. },
  249. {///*--  文字:  3  --*/
  250. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  251. },
  252. {///*--  文字:  4  --*/
  253. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  254. },
  255. {///*--  文字:  5  --*/
  256. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  257. }
  258. };

  260. /*code unsigned char GGJJ[4][32]={                                 //"关关雎鸠"
  261. {0x10,0x10,0x08,0x18,0x04,0x20,0x04,0x48,
  262. 0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x04,
  263. 0xFF,0xFE,0x01,0x00,0x02,0x80,0x02,0x80,
  264. 0x04,0x40,0x08,0x30,0x30,0x0E,0xC0,0x04,},
  265. {0x10,0x10,0x08,0x18,0x04,0x20,0x04,0x48,
  266. 0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x04,
  267. 0xFF,0xFE,0x01,0x00,0x02,0x80,0x02,0x80,
  268. 0x04,0x40,0x08,0x30,0x30,0x0E,0xC0,0x04,},
  269. {0x00,0xC0,0x08,0xA0,0x7D,0x24,0x49,0xFE,
  270. 0x4B,0x20,0x7D,0x28,0x49,0xFC,0x49,0x20,
  271. 0x79,0x28,0x49,0xFC,0x49,0x20,0x4D,0x20,
  272. 0xF1,0x24,0x41,0xFE,0x01,0x00,0x01,0x00,},
  273. {0x20,0x20,0x20,0x48,0x21,0xFC,0x29,0x08,
  274. 0xFD,0x48,0x29,0x08,0x29,0x28,0x29,0x10,
  275. 0x29,0x04,0x29,0xFE,0x28,0x04,0x2A,0x24,
  276. 0x4D,0xF4,0x48,0x04,0x80,0x14,0x00,0x08}
  277. };

  279. code unsigned char ZHZZ[4][32]={                          //"在河之洲"
  280. {0x02,0x00,0x02,0x00,0x02,0x04,0xFF,0xFE,
  281.       0x04,0x00,0x04,0x40,0x08,0x40,0x08,0x50,
  282.       0x13,0xF8,0x30,0x40,0x50,0x40,0x90,0x40,
  283.       0x10,0x40,0x10,0x44,0x17,0xFE,0x10,0x00,},
  284. { 0x40,0x04,0x3F,0xFE,0x10,0x08,0x00,0x08,
  285.       0x80,0x48,0x67,0xE8,0x24,0x48,0x0C,0x48,
  286.       0x14,0x48,0x24,0x48,0xE7,0xC8,0x24,0x48,
  287.       0x20,0x08,0x20,0x08,0x20,0x28,0x20,0x10,},
  288. { 0x02,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
  289.       0x7F,0xF8,0x00,0x10,0x00,0x20,0x00,0x40,
  290.       0x00,0x80,0x01,0x00,0x02,0x00,0x0C,0x00,
  291.       0x30,0x00,0x48,0x06,0x07,0xFC,0x00,0x00,},
  292. {0x01,0x04,0x41,0x04,0x31,0x24,0x11,0x24,
  293.       0x81,0x24,0x65,0xB4,0x23,0x6C,0x0B,0x6C,
  294.       0x11,0x24,0x21,0x24,0xE1,0x24,0x21,0x24,
  295.       0x22,0x24,0x22,0x24,0x24,0x04,0x20,0x04}
  296. };

  298. code unsigned char YTSN[4][32]={                         //"窈窕淑女"
  299. {0x02,0x00,0x41,0x00,0x7F,0xFE,0x48,0x22,
  300. 0x90,0x14,0x04,0x40,0x08,0x48,0x11,0xFC,
  301. 0x7E,0x48,0x04,0x48,0x08,0x48,0x14,0x48,
  302. 0x22,0x88,0x7E,0x88,0x01,0x28,0x02,0x10,
  303. },
  304. {0x02,0x00,0x41,0x00,0x7F,0xFE,0x48,0x22,
  305. 0x92,0x94,0x02,0x80,0x22,0x90,0x12,0x98,
  306. 0x16,0xA0,0x0A,0xC0,0x12,0xA0,0x62,0x98,
  307. 0x04,0x8A,0x04,0x82,0x18,0x7E,0x60,0x00,},
  308. {0x02,0x00,0x42,0x00,0x33,0x80,0x12,0x7C,
  309. 0x82,0x44,0x62,0x44,0x2F,0xC4,0x0A,0x44,
  310. 0x12,0x28,0x27,0x28,0xEA,0x90,0x32,0x10,
  311. 0x22,0x28,0x2A,0x46,0x24,0x84,0x21,0x00,},
  312. {0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
  313. 0x02,0x04,0xFF,0xFE,0x04,0x20,0x04,0x20,
  314. 0x08,0x20,0x10,0x20,0x0C,0x40,0x02,0x80,
  315. 0x01,0x80,0x06,0x60,0x18,0x18,0x60,0x08,
  316. }
  317. };

  319. code unsigned char JZHQ[4][32]={                             //“君子好逑”
  320. {0x00,0x10,0x3F,0xF8,0x04,0x10,0x04,0x14,
  321. 0xFF,0xFE,0x04,0x10,0x04,0x10,0x3F,0xF0,
  322. 0x08,0x00,0x08,0x08,0x1F,0xFC,0x18,0x08,
  323. 0x28,0x08,0x48,0x08,0x8F,0xF8,0x08,0x08,},
  324. {0x00,0x00,0x3F,0xF0,0x00,0x10,0x00,0x20,
  325. 0x00,0x40,0x01,0x80,0x01,0x04,0xFF,0xFE,
  326. 0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  327. 0x01,0x00,0x01,0x00,0x05,0x00,0x02,0x00,},
  328. {0x10,0x00,0x11,0xFC,0x10,0x04,0x10,0x08,
  329. 0xFC,0x10,0x24,0x20,0x24,0x24,0x27,0xFE,
  330. 0x24,0x20,0x44,0x20,0x28,0x20,0x10,0x20,
  331. 0x28,0x20,0x44,0x20,0x84,0xA0,0x00,0x40,},
  332. {0x00,0x40,0x40,0x50,0x30,0x48,0x17,0xFC,
  333. 0x00,0x40,0x02,0x48,0xF1,0x50,0x10,0x40,
  334. 0x11,0x50,0x16,0x4C,0x10,0x44,0x11,0x40,
  335. 0x10,0x80,0x28,0x06,0x47,0xFC,0x00,0x00}
  336. };                */

  338. /*code unsigned char DH1[32] = {
  339.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  340.         0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x80,
  341.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  342.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  343. };
  344. code unsigned char DH2[32] = {
  345.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  346.         0x00,0x00,0x00,0x00,0x01,0x80,0x01,0x80,
  347.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  348.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  349. };
  350. code unsigned char DH3[32] = {
  351.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  352.         0x00,0x00,0x01,0x80,0x03,0xC0,0xFF,0xFF,
  353.         0x01,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
  354.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  355. };

  357. code unsigned char DH4[32] = {
  358.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  359.         0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,
  360.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  361.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  362. };        */
  363. void init()                                         //初始化程序
  364. {
  365.         TMOD = 0x01;                               //  定时器0为工作方式1
  366.         TH0 = (65536-50000)/256;        //定时50mS
  367.         TL0 = (65536-50000)%256;
  368.         EA = 1;                                       //开总中断
  369.         ET0 = 1;                                   //开定时器0中断
  370.         EX0 = 1;                                   //开外部中断0
  371.         EX1 = 1;                                   //开外部中断1
  372.         IT0 = 0;                                   //设置外部中断0的中断方式为0 低电平触发
  373.         IT1 = 0;
  374.         TR0 = 1;                                   //启动定时器0

  376.         num = 0;
  377.         nums = 12;
  378.         numf = 30;
  379.         numyear = 2013;
  380.         nummonth = 1;
  381.         numday = 15;
  382. }
  383. void displayshijian()                 //显示时间函数
  384. {
  385.                 unsigned char i,j,p1,k1,p2,k2;
  386.                 p1 = nums/10;
  387.                 k1 = nums%10;          //小时数据
  388.                 p2 = numf/10;
  389.                 k2 = numf%10;          //分钟数据
  390.                
  391.                 for(i=0;i<128;i++)         //显示缓存清空       
  392.                 {       
  393.                         lhj[i]=0;
  394.                 }

  396.                 for(i=0,j=0;i<128;)               
  397.                 {       
  398.                         lhj[i]=c[p1][j];
  399.                         lhj[i+1]=d[k1][j];
  400.        
  401.                           i=i+8;
  402.                         j=j+1;
  403.                 }
  404.        
  405.                 for(i=2,j=0;i<128;)               
  406.                 {       
  407.                         lhj[i]=HOU[j];
  408.                         lhj[i+1]=HOU[j+1];
  409.        
  410.                           i=i+8;
  411.                         j=j+2;
  412.                 }
  413.        
  414.                 for(i=4,j=0;i<128;)               
  415.                 {       
  416.                         lhj[i]=a[p2][j];
  417.                         lhj[i+1]=b[k2][j];
  418.        
  419.                           i=i+8;
  420.                         j=j+1;
  421.                 }
  422.                
  423.                 for(i=6,j=0;i<128;)               
  424.                 {       
  425.                         lhj[i]=MIN[j];
  426.                         lhj[i+1]=MIN[j+1];
  427.        
  428.                           i=i+8;
  429.                         j=j+2;
  430.                 }
  431.                 displayS(1);        



  435. }

  437. void displayshijian2()                 //显示时间函数
  438. {
  439.                
  440.                 unsigned char i,j,p1,k1,p2,k2;
  441.                 p1 = nums/10;
  442.                 k1 = nums%10;          //小时数据
  443.                 p2 = numf/10;
  444.                 k2 = numf%10;          //分钟数据
  445.                
  446.                 for(i=0;i<128;i++)         //显示缓存清空       
  447.                 {       
  448.                         lhj[i]=0;
  449.                 }

  451.                 for(i=0,j=0;i<128;)               
  452.                 {       
  453.                         lhj[i]=c[p1][j];
  454.                         lhj[i+1]=d[k1][j];
  455.        
  456.                           i=i+8;
  457.                         j=j+1;
  458.                 }
  459.        
  460.                 for(i=2,j=0;i<128;)               
  461.                 {       
  462.                         lhj[i]=HOU[j];
  463.                         lhj[i+1]=HOU[j+1];
  464.        
  465.                           i=i+8;
  466.                         j=j+2;
  467.                 }
  468.        
  469.                 for(i=4,j=0;i<128;)               
  470.                 {       
  471.                         lhj[i]=a[p2][j];
  472.                         lhj[i+1]=b[k2][j];
  473.        
  474.                           i=i+8;
  475.                         j=j+1;
  476.                 }
  477.                
  478.                 for(i=6,j=0;i<128;)               
  479.                 {       
  480.                         lhj[i]=MIN[j];
  481.                         lhj[i+1]=MIN[j+1];
  482.        
  483.                           i=i+8;
  484.                         j=j+2;
  485.                 }
  486.                 displayS(1);        
  487. }


  490. void displaynyr()                                //年月日显示程序
  491. {       
  492.                 unsigned char i,j,n1,n2,n3,n4,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  493.                 n1 = numyear/1000;
  494.                 n2 = (numyear%1000)/100;
  495.                 n3 = (numyear%100)/10;
  496.                 n4 = numyear%10;
  497.                 p1 = nummonth/10;
  498.                 k1 = nummonth%10;          //月数据
  499.                 p2 = numday/10;
  500.                 k2 = numday%10;          //日数据

  502.                 for(i=0;i<128;i++)         //显示缓存清空       
  503.                 {       
  504.                         lhj[i]=0;
  505.                 }

  507.                 for(i=0,j=0;i<128;)               
  508.                 {       
  509.                         lhj[i]=d[n1][j];
  510.                         lhj[i+1]=d[n2][j];
  511.        
  512.                           i=i+8;
  513.                         j=j+1;
  514.                 }
  515.                 for(i=2,j=0;i<128;)               
  516.                 {       
  517.                         lhj[i]=d[n3][j];
  518.                         lhj[i+1]=d[n4][j];
  519.        
  520.                           i=i+8;
  521.                         j=j+1;
  522.                 }
  523.                 for(i=4,j=0;i<128;)               
  524.                 {       
  525.                         lhj[i]=NIAN2[j];
  526.                         lhj[i+1]=NIAN2[j+1];
  527.        
  528.                           i=i+8;
  529.                         j=j+2;
  530.                 }
  531.                 displayS(2);
  532.         displaymovetb(1,0,4,2);

  534.                 for(i=0,j=0;i<128;)               
  535.                 {       
  536.                         lhj[i]=d[p1][j];
  537.                         lhj[i+1]=d[k1][j];
  538.        
  539.                           i=i+8;
  540.                         j=j+1;
  541.                 }
  542.                 for(i=2,j=0;i<128;)               
  543.                 {       
  544.                         lhj[i]=YUE[j];
  545.                         lhj[i+1]=YUE[j+1];
  546.        
  547.                           i=i+8;
  548.                         j=j+2;
  549.                 }
  550.                 for(i=4,j=0;i<128;)               
  551.                 {       
  552.                         lhj[i]=d[p2][j];
  553.                         lhj[i+1]=d[k2][j];
  554.        
  555.                           i=i+8;
  556.                         j=j+1;
  557.                 }
  558.                 for(i=6,j=0;i<128;)               
  559.                 {       
  560.                         lhj[i]=RI2[j];
  561.                         lhj[i+1]=RI2[j+1];
  562.        
  563.                           i=i+8;
  564.                         j=j+2;
  565.                 }
  566.            displayS(3);
  567.        displaymovetb(1,0,4,1);
  568. }

  570. void displaynyr2()
  571. {       
  572.                 unsigned char i,j,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  573. /*                n1 = numyear/1000;
  574.                 n2 = (numyear%1000)/100;
  575.                 n3 = (numyear%100)/10;
  576.                 n4 = numyear%10;             */
  577.                 p1 = nummonth/10;
  578.                 k1 = nummonth%10;          //月数据
  579.                 p2 = numday/10;
  580.                 k2 = numday%10;          //日数据

  582. /*                for(i=0;i<128;i++)         //显示缓存清空       
  583.                 {       
  584.                         lhj[i]=0;
  585.                 }

  587.                 for(i=0,j=0;i<128;)               
  588.                 {       
  589.                         lhj[i]=d[n1][j];
  590.                         lhj[i+1]=d[n2][j];
  591.        
  592.                           i=i+8;
  593.                         j=j+1;
  594.                 }
  595.                 for(i=2,j=0;i<128;)               
  596.                 {       
  597.                         lhj[i]=d[n3][j];
  598.                         lhj[i+1]=d[n4][j];
  599.        
  600.                           i=i+8;
  601.                         j=j+1;
  602.                 }
  603.                 for(i=4,j=0;i<128;)               
  604.                 {       
  605.                         lhj[i]=NIAN2[j];
  606.                         lhj[i+1]=NIAN2[j+1];
  607.        
  608.                           i=i+8;
  609.                         j=j+2;
  610.                 }
  611.                 displayS2(1);                  */
  612. //       displaymovetb2(1,0,4,1);
  613. /*                for(i=0;i<128;i++)         //显示缓存清空       
  614.                 {       
  615.                         lhj[i]=0;
  616.                 }  */
  617.                 for(i=0,j=0;i<128;)               
  618.                 {       
  619.                         lhj[i]=d[p1][j];
  620.                         lhj[i+1]=d[k1][j];
  621.        
  622.                           i=i+8;
  623.                         j=j+1;
  624.                 }
  625.                 for(i=2,j=0;i<128;)               
  626.                 {       
  627.                         lhj[i]=YUE[j];
  628.                         lhj[i+1]=YUE[j+1];
  629.        
  630.                           i=i+8;
  631.                         j=j+2;
  632.                 }
  633.                 for(i=4,j=0;i<128;)               
  634.                 {       
  635.                         lhj[i]=d[p2][j];
  636.                         lhj[i+1]=d[k2][j];
  637.        
  638.                           i=i+8;
  639.                         j=j+1;
  640.                 }
  641.                 for(i=6,j=0;i<128;)               
  642.                 {       
  643.                         lhj[i]=RI2[j];
  644.                         lhj[i+1]=RI2[j+1];
  645.        
  646.                           i=i+8;
  647.                         j=j+2;
  648.                 }
  649.            displayS2(1);
  650. //      displaymovetb2(1,0,4,1);
  651. }



  655. void extern1() interrupt 2                 //外部中断1
  656. {
  657.         displaynyr2();
  658.         if((key2 == 0)&&(key3 ==0))
  659.                 ISP_CONTR = 0x20;
  660.          
  661.          if(key3 == 0)  
  662.         {       
  663.                 if(key3 == 0)
  664.                 {
  665.                         numday++;
  666.                         if(numday > 31)
  667.                           numday = 1;
  668.                  }
  669.         }

  671.         if(key2 == 0)  
  672.         {       
  673.                 if(key2 == 0)
  674.                 {
  675.                         nummonth++;
  676.                         if(nummonth > 12)
  677.                                 nummonth = 1;
  678.                  }
  679.         }

  681.         key4 = 1;

  683. }       

  685. void extern0() interrupt 0                 //外部中断0
  686. {       

  688.                 displayshijian2();
  689.                 if(key2 == 0)                     //key2按键扫描，按下则 小时nums加1
  690.                 {       
  691.                         if(key2 == 0)
  692.                         {
  693.                                 nums++;
  694.                                 if(nums > 23)
  695.                                         nums =0;
  696.                          }
  697.                 }
  698.                 if(key3 == 0)                         //key3按键扫描，按下则 分钟numf加1
  699.                 {
  700.                         if(key3 == 0)
  701.                         {
  702.                                 numf++;
  703.                                 if(numf > 59)
  704.                                         numf =0;               
  705.                         }
  706.                 }
  707.          /*        if((key2 == 0)&&(key3 ==0))
  708.                     if((key2 == 0)&&(key3 ==0))
  709.                          {
  710.                                  displaymove2(GGJJ,4,1);       
  711.                                 displaymove2(ZHZZ,4,1);       
  712.                                 displaymove2(YTSN,4,1);       
  713.                                 displaymove2(JZHQ,4,1);
  714.                          }         */
  715.         key1 = 1;                   //P3.2口赋高电平 防止下次重复进入中断       

  717. }
  718.        

  720. void T0timer() interrupt 1                   //定时器0中断
  721. {
  722.         TH0 = (65536-50000)/256;
  723.         TL0 = (65536-50000)%256;
  724.         numt0++;
  725.         if(numt0 >= 40)                //24M hz40次为一秒
  726.         {
  727.                 numt0 = 0;
  728.                 num++;
  729.                 if(num > 59)
  730.                 {        num = 0;
  731.                         numf++;
  732.                 }
  733.         }
  734. }

  736. void displaytu_an()
  737. {
  738.          unsigned char i,j;
  739.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  740.          {       
  741.                 lhj[i]=XL[j];
  742.                 lhj[i+1]=XL[j+1];

  744.                   i=i+8;
  745.                 j=j+2;
  746.             }
  747.          
  748.         for(i=4,j=0;i<128;)                                                        //复制安卓机器人图案到中间
  749.                  {       
  750.                         lhj[i]=ANZHUO[j];
  751.                         lhj[i+1]=ANZHUO[j+1];
  752.        
  753.                           i=i+8;
  754.                         j=j+2;
  755.                     }
  756.          displayS(4);                                      //显示图案约2秒

  758. }

  760. /*void displaydonghua()
  761. {
  762.          unsigned char i,j;
  763.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  764.          {       
  765.                 lhj[i]=DH1[j];
  766.                 lhj[i+1]=DH1[j+1];

  768.                   i=i+8;
  769.                 j=j+2;
  770.             }
  771.          displayS(4);
  772.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  773.          {       
  774.                 lhj[i]=DH2[j];
  775.                 lhj[i+1]=DH2[j+1];

  777.                   i=i+8;
  778.                 j=j+2;
  779.             }
  780.          displayS(4);


  783.          for(i=0,j=0;i<128;)                                                        //复制笑脸图案到中间
  784.          {       
  785.                 lhj[i]=DH4[j];
  786.                 lhj[i+1]=DH4[j+1];

  788.                   i=i+8;
  789.                 j=j+2;
  790.             }
  791.                   for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  792.          {       
  793.                 lhj[i]=DH3[j];
  794.                 lhj[i+1]=DH3[j+1];

  796.                   i=i+8;
  797.                 j=j+2;
  798.             }
  799.          for(i=4,j=0;i<128;)                                                        //复制笑脸图案到中间
  800.          {       
  801.                 lhj[i]=DH4[j];
  802.                 lhj[i+1]=DH4[j+1];

  804.                   i=i+8;
  805.                 j=j+2;
  806.             }
  807.                   for(i=6,j=0;i<128;)                                                        //复制笑脸图案到中间
  808.          {       
  809.                 lhj[i]=DH4[j];
  810.                 lhj[i+1]=DH4[j+1];

  812.                   i=i+8;
  813.                 j=j+2;
  814.             }
  815.          displayS(5);


  818. }  */

  820. void shijianzz()
  821. {
  822. /***************************************************///时间自增
  823.         if(numf > 59)                           //分钟numf，小时nums自增
  824.         {
  825.                 numf = 0;
  826.                 nums++;
  827.                 if(nums > 23)
  828.                         {
  829.                         nums = 0;
  830.                         numday++;

  832.                         switch(nummonth)
  833.                         {
  834.                         case 1:
  835.                         case 3:
  836.                         case 5:
  837.                         case 7:
  838.                         case 8:
  839.                         case 10:
  840.                         case 12:  if(numday > 31)
  841.                                                 {        nummonth++;
  842.                                                         numday=1;
  843.                                                         if(nummonth > 12)
  844.                                                                 {
  845.                                                                  nummonth =1;
  846.                                                                  numyear++;       
  847.                                                                 }
  848.                                                 };       
  849.                                                 break;                                       
  850.                                           
  851.                         case 4:
  852.                         case 6:
  853.                         case 9:
  854.                         case 11:if(numday > 30)
  855.                                                 {        nummonth++;
  856.                                                         numday=1;
  857.                                                         if(nummonth > 12)
  858.                                                                 {nummonth =1;
  859.                                                                  numyear++;
  860.                                                                 }
  861.                                                 };       
  862.                                                 break;                                       

  864.                         case 2:        {
  865.                                          if(numyear%4==0)
  866.                                                 if(numday > 29  )
  867.                                                 {
  868.                                                         nummonth++;
  869.                                                         numday=1;
  870.                                                         if(nummonth > 12)
  871.                                                                 {nummonth = 1;
  872.                                                                  numyear++;
  873.                                                                 }       
  874.                                                 }
  875.                                          else
  876.                                                 if(numday > 28  )
  877.                                                 {
  878.                                                         nummonth++;
  879.                                                         numday=1;
  880.                                                         if(nummonth > 12)
  881.                                                                 {nummonth =1;
  882.                                                                  numyear++;
  883.                                                                 }       
  884.                                                 }
  885.                                         };break;       
  886.                         }
  887.                        
  888.                 }
  889.         }
  890. /*********************************************************/
  891. }

  893. void displayXNKL()
  894. {
  895.                  /*********逐个显示“新年快乐”************/       
  896.         uchar i,j;
  897.         for(i=0,j=0;i<128;)               
  898.         {       
  899.                 lhj[i]=XIN[j];
  900.                 lhj[i+1]=XIN[j+1];

  902.                   i=i+8;
  903.                 j=j+2;
  904.         }
  905.         displayS(2);
  906.        
  907.         for(i=2,j=0;i<128;)               
  908.         {       
  909.                 lhj[i]=NIAN[j];
  910.                 lhj[i+1]=NIAN[j+1];

  912.                   i=i+8;
  913.                 j=j+2;
  914.         }
  915.         displayS(2);
  916.        
  917.         for(i=4,j=0;i<128;)               
  918.         {       
  919.                 lhj[i]=KUAI[j];
  920.                 lhj[i+1]=KUAI[j+1];

  922.                   i=i+8;
  923.                 j=j+2;
  924.         }
  925.         displayS(2);
  926.        
  927.         for(i=6,j=0;i<128;)               
  928.         {       
  929.                 lhj[i]=LE[j];
  930.                 lhj[i+1]=LE[j+1];

  932.                   i=i+8;
  933.                 j=j+2;
  934.         }
  935.         displayS(2);
  936. /**********************************/       

  938. }

  940. /********************** 主函数 *************************************/
  941. void main(void)           
  942. {

  944.         init();            //初始化程序
  945.         displaytu_an();
  946.         displayS(2);                    
  947.         //displaydonghua();       
  948.         while(1)
  949.         {
  950. //        displaytu_an();                                      //显示图案
  951.         shijianzz();                                        //时间自增函数
  952.         displaymovetb(1,0,4,3);                         //向下清屏
  953.         displaymovetb(1,WU,4,2);                  //向下显示“物电学院"
  954.         displayS(1);                                        //持续显示2S
  955.         displaymovetb(0,0,4,2);                          //向上卷帘清屏
  956.         displaymove(LING,4,1);                          //左跑马 “零九电子”
  957.         displayS(1);
  958.         displaymovetb(1,0,4,2);                        //向下卷帘清屏
  959.         displayXNKL();                                   //由左往右显示‘新年快乐’
  960.         displaymove(0,4,2);                    //左跑马清屏
  961.         displaymovetb(1,BEI,4,3);            //向下显示 “北京时间”
  962.         displayS(2);
  963.         displaymovetb(1,0,4,1);
  964.         displaynyr();                                    //显示****年**月**日
  965.         displayshijian();                            //调用显示**点**分 时间函数
  966.         displayS(5);
  967.         displaymovetb(1,0,4,3);                        //向下清屏
  968.         }

  970. }
  971. /********************** 主函数 *************************************/

  973. void display2()                  //显示子函数 中断调用才使用
  974. {       
  975.         unsigned char i,ia,tmp;       
  976.         unsigned int j;
  977.         DATAOUT=0XFF;                                       
  978.         AB=0;                                                                                //将行数据位清0，准备移位
  979.         for(i=0;i<16;i++)
  980.         {               
  981.                 SCK=0;                       
  982.                 SCLT=0;                       
  983.                 for(ia=8;ia>0;)
  984.                 {                                                //每行64个点，循环位移8个字节
  985.                 ia--;                                                                        //循环四次
  986.                 tmp=~lhj[i*8+ia];       
  987.                         for(j=0;j<8;j++)
  988.                         {                                                //循环两次，每次移一个字节，
  989.                                 SCLH=0;                       
  990.                              DATA=tmp&0x01;                                             //将数据低位做输出
  991.                                 tmp>>=1;         
  992.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  993.                         }                                                                                //移入单字节结束
  994.                 }                                                                                //移入两个字节结束
  995.                 DATAOUT|=0X24;       
  996.                 //等价于SCK=1;               
  997.                 //      SCLT=1;               
  998.                 AB=1;               
  999.         }
  1000.         j=100;
  1001.         while(j--);                                          //每一行的显示，保持6个字节的移位时间，因此，最后一行的显示，也要加入保持时间，补尝显示的亮度
  1002.         SCK=0;                                                  
  1003.         SCK=1;                                                  //将最后一行数据移出
  1004. }


  1007. void display()                                             //显示子函数
  1008. {       
  1009.         unsigned char i,ia,tmp;       
  1010.         unsigned int j;
  1011.         DATAOUT=0XFF;                                       
  1012.         AB=0;                                                                                //将行数据位清0，准备移位
  1013.         for(i=0;i<16;i++)
  1014.         {               
  1015.                 SCK=0;                       
  1016.                 SCLT=0;                       
  1017.                 for(ia=8;ia>0;)
  1018.                 {                                                //每行64个点，循环位移8个字节
  1019.                 ia--;                                                                        //循环四次
  1020.                 tmp=~lhj[i*8+ia];       
  1021.                         for(j=0;j<8;j++)
  1022.                         {                                                //循环两次，每次移一个字节，
  1023.                                 SCLH=0;                       
  1024.                              DATA=tmp&0x01;                                             //将数据低位做输出
  1025.                                 tmp>>=1;         
  1026.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  1027.                         }                                                                                //移入单字节结束
  1028.                 }                                                                                //移入两个字节结束
  1029.                 DATAOUT|=0X24;       
  1030.                 //等价于SCK=1;               
  1031.                 //      SCLT=1;               
  1032.                 AB=1;               
  1033.         }
  1034.         j=100;
  1035.         while(j--);                                          //每一行的显示，保持6个字节的移位时间，因此，最后一行的显示，也要加入保持时间，补尝显示的亮度
  1036.         SCK=0;                                                  
  1037.         SCK=1;                                                  //将最后一行数据移出
  1038. }


  1041. void displayS2(unsigned int timer)                   //指定时间扫描显示函数 中断调用时用
  1042. {
  1043.         unsigned char i;       
  1044.         while(timer--)
  1045.         {                                  //当timer=1时，大约1秒时间
  1046.                 i=20;               
  1047.                 while(i--)
  1048.                         display2();
  1049.         }
  1050. }



  1054. void displayS(unsigned int timer)            //指定时间扫描显示函数
  1055. {
  1056.         unsigned char i;       
  1057.         while(timer--)
  1058.         {                                  //当timer=1时，大约1秒时间
  1059.                 i=20;               
  1060.                 while(i--)
  1061.                         display();
  1062.         }
  1063. }

  1065. void displaymove(unsigned char *lp,unsigned char c,unsigned char timer)//左移显示函数，LP指向要显示第一个字的首地址，C表示显示字的个数，
  1066.                                                                                                                                                 //timer是移动的速度
  1067. {
  1068.         unsigned char i=0,j=0,ia=0;
  1069.         unsigned int tmp=0,timerc=0;
  1070.         unsigned char tmp2[16];
  1071.         c*=2;               
  1072.         for(i=0;i<16;i++)
  1073.                 tmp2[i]=0;                                            //将缓冲区清0，
  1074.         while(c)
  1075.         {
  1076.                 if(lp!=0)
  1077.                 {                                            //当lp指向的地址为0时，直接用组缓冲0补上，效果是将当前显示的内容移出
  1078.                 tmp=c%2;                                                                        //取余，目的是为了判断处理汉字的前半部份还是后半部份
  1079.                 for(i=0;i<16;i++)
  1080.                         {               
  1081.                                 tmp2[i]=lp[i*2+tmp];                                        //取半个汉字点阵数据，16字节
  1082.                         }
  1083.                 if(tmp)                                                                                //当tmp为1时，表时一个字数组处理完成，将地址转到下一个字
  1084.                         lp+=32;
  1085.                 }
  1086.                 //--------------
  1087.                 tmp=8;                                                                                //变量再次利用
  1088.                 while(tmp)
  1089.                 {                                                                        //循环8次，是将下一个字的前半部份的字节数据移入显示缓冲       
  1090.                 ia=0;                                                                                //做为点阵数组的元素
  1091.                 for(i=0;i<16;i++)
  1092.                 {                                                        //移动是16行同时移，因此要处理16个字节
  1093.                         for(j=0;j<7;j++)
  1094.                         {                                                //一行32个点四字节，有三字节在显示缓冲中移动
  1095.                                 lhj[ia]<<=1;                                                //移当前显示缓冲的半行字节
  1096.                                 if(lhj[ia+1]&0x80)                                        //判断后半行字节的高位是否为1，是移入前半行字节低位，否则不处理
  1097.                                         lhj[ia]++;
  1098.                                 ia++;
  1099.                         }
  1100.                         lhj[ia]<<=1;                                                        //一行32个点四字节，将最后一字节用下一个字补上
  1101.                         if(tmp2[i]&0x80)                                                //判断下一个要显示汉字的前半行字节的高位是否为1，是移入，否则不处理
  1102.                                 lhj[ia]++;
  1103.                         ia++;
  1104.                         tmp2[i]<<=1;                                                        //下一个要显示汉字的半行字节向高位移一位，准备下一次取位
  1105.                 }
  1106.                 tmp--;
  1107.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1108.                 while(timerc--)                                                                        //循环做为处理的速度，即移动的速度
  1109.                         display();
  1110.                 }
  1111.                 //----------
  1112.                 c--;                                                                                        //移完一半，进入下一半或下一个汉字，直到结束
  1113.         }
  1114. }


  1117. void displaymove2(unsigned char *lp,unsigned char c,unsigned char timer)//左移显示函数，LP指向要显示第一个字的首地址，C表示显示字的个数，
  1118.                                                                                                                                                 //timer是移动的速度
  1119. {
  1120.         unsigned char i=0,j=0,ia=0;
  1121.         unsigned int tmp=0,timerc=0;
  1122.         unsigned char tmp2[16];
  1123.         c*=2;               
  1124.         for(i=0;i<16;i++)
  1125.                 tmp2[i]=0;                                            //将缓冲区清0，
  1126.         while(c)
  1127.         {
  1128.                 if(lp!=0)
  1129.                 {                                            //当lp指向的地址为0时，直接用组缓冲0补上，效果是将当前显示的内容移出
  1130.                 tmp=c%2;                                                                        //取余，目的是为了判断处理汉字的前半部份还是后半部份
  1131.                 for(i=0;i<16;i++)
  1132.                         {               
  1133.                                 tmp2[i]=lp[i*2+tmp];                                        //取半个汉字点阵数据，16字节
  1134.                         }
  1135.                 if(tmp)                                                                                //当tmp为1时，表时一个字数组处理完成，将地址转到下一个字
  1136.                         lp+=32;
  1137.                 }
  1138.                 //--------------
  1139.                 tmp=8;                                                                                //变量再次利用
  1140.                 while(tmp)
  1141.                 {                                                                        //循环8次，是将下一个字的前半部份的字节数据移入显示缓冲       
  1142.                 ia=0;                                                                                //做为点阵数组的元素
  1143.                 for(i=0;i<16;i++)
  1144.                 {                                                        //移动是16行同时移，因此要处理16个字节
  1145.                         for(j=0;j<7;j++)
  1146.                         {                                                //一行32个点四字节，有三字节在显示缓冲中移动
  1147.                                 lhj[ia]<<=1;                                                //移当前显示缓冲的半行字节
  1148.                                 if(lhj[ia+1]&0x80)                                        //判断后半行字节的高位是否为1，是移入前半行字节低位，否则不处理
  1149.                                         lhj[ia]++;
  1150.                                 ia++;
  1151.                         }
  1152.                         lhj[ia]<<=1;                                                        //一行32个点四字节，将最后一字节用下一个字补上
  1153.                         if(tmp2[i]&0x80)                                                //判断下一个要显示汉字的前半行字节的高位是否为1，是移入，否则不处理
  1154.                                 lhj[ia]++;
  1155.                         ia++;
  1156.                         tmp2[i]<<=1;                                                        //下一个要显示汉字的半行字节向高位移一位，准备下一次取位
  1157.                 }
  1158.                 tmp--;
  1159.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1160.                 while(timerc--)                                                                        //循环做为处理的速度，即移动的速度
  1161.                         display2();
  1162.                 }
  1163.                 //----------
  1164.                 c--;                                                                                        //移完一半，进入下一半或下一个汉字，直到结束
  1165.         }
  1166. }




  1171. void displaymovetb(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1172. //上下移动显示函数，din：1为向下，0为向上，lp指向要移入的内容，C表示有几个汉字要移，timer为移动速度
  1173. {
  1174.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1175.         unsigned int tmp=0,timerc=0;
  1176.         if(din)
  1177.         {                                                                                                        //判断移动方向，向下
  1178.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1179.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1180.         ic=96;
  1181.         id=128;
  1182.         i=16;                                                                                                        //行索引
  1183.         while(i--)
  1184.         {                                                                                                       //逐行处理
  1185.                   j=120;
  1186.                 while(j)
  1187.                 {
  1188.                         j--;
  1189.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行，每两行内容相隔6个字节，复制15行
  1190.                 }
  1191.                 if(lp==0)
  1192.                 {                                                                                        //最后一行的处理，判断移入的内容是否为空，是用0移入
  1193.                         j=8;
  1194.                         while(j--)
  1195.                                 lhj[j]=0;
  1196.                 }
  1197.                 else
  1198.                 {                                                                                                //否则，取字数组处理
  1199.                         ia--;ib--;ic--;id--        ;

  1201.                         if(c==4)
  1202.                         {                                                                                //判断4个字，移一行，6个字节
  1203.                         lhj[1]=lp[ia];
  1204.                         ia--;
  1205.                         lhj[0]=lp[ia];
  1206.                         lhj[3]=lp[ib];
  1207.                         ib--;
  1208.                         lhj[2]=lp[ib];
  1209.                         lhj[5]=lp[ic];
  1210.                         ic--;
  1211.                         lhj[4]=lp[ic];
  1212.                         lhj[7]=lp[id];
  1213.                         id--;
  1214.                         lhj[6]=lp[id];
  1215.                         }


  1218.                         else if(c==3)
  1219.                         {                                                                //否则3个字，将字放在中间，旁边补0
  1220.                         lhj[0]=0;
  1221.                         lhj[2]=lp[ia];
  1222.                         ia--;
  1223.                         lhj[1]=lp[ia];
  1224.                         lhj[4]=lp[ib];
  1225.                         ib--;
  1226.                         lhj[3]=lp[ib];
  1227.                         lhj[6]=lp[ic];
  1228.                         ic--;
  1229.                         lhj[5]=lp[ic];
  1230.                         lhj[7]=0;
  1231.                         }

  1233.                         else if(c==2)
  1234.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1235.                         lhj[0]=0;
  1236.                         lhj[1]=0;

  1238.                         lhj[3]=lp[ia];
  1239.                         ia--;
  1240.                         lhj[2]=lp[ia];
  1241.                         lhj[5]=lp[ib];
  1242.                         ib--;
  1243.                         lhj[4]=lp[ib];                       
  1244.                         lhj[6]=0;
  1245.                         lhj[7]=0;
  1246.                         }
  1247.                         else if(c==1)
  1248.                         {                                                                //否则1个字，将字放在中间，旁边补0
  1249.                         lhj[0]=0;
  1250.                         lhj[1]=0;
  1251.                         lhj[2]=0;

  1253.                         lhj[4]=lp[ia];
  1254.                         ia--;
  1255.                         lhj[3]=lp[ia];

  1257.                         lhj[5]=0;       
  1258.                         lhj[6]=0;
  1259.                         lhj[7]=0;

  1261.                         }
  1262.                 }
  1263.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1264.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1265.                         display();
  1266.         }
  1267.         }
  1268.         else
  1269.         {                                                                                        //移动方向，向上
  1270.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动，移入汉字从低位开始

  1272.                 for(i=0;i<16;i++)
  1273.                 {                                                        //处理16行
  1274.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行，每两行内容相隔6个字节，复制15行
  1275.                                 lhj[j]=lhj[j+8];
  1276.                         if(lp==0)
  1277.                         {                                                                //最后一行的处理，判断移入的内容是否为空，是用0移入
  1278.                                 while(j!=128)
  1279.                                 {
  1280.                                         lhj[j]=0;
  1281.                                         j++;
  1282.                                    }
  1283.                         }
  1284.                         else
  1285.                         {                                                                        //否则，取字数组处理
  1286.                         if(c==4)
  1287.                         {                                                                  //判断4个字，移一行，8个字节                                       
  1288.                                 lhj[120]=lp[ia];
  1289.                                 lhj[121]=lp[ia+1];
  1290.                                 lhj[122]=lp[ib];
  1291.                                 lhj[123]=lp[ib+1];
  1292.                                 lhj[124]=lp[ic];
  1293.                                 lhj[125]=lp[ic+1];
  1294.                                 lhj[126]=lp[id];
  1295.                                 lhj[127]=lp[id+1];

  1297.                                 ia+=2;ib+=2;ic+=2;id+=2;                          
  1298.                         }
  1299.                         else if(c==3)
  1300.                         {                                                        //否则3个字，将字放在中间，旁边补0
  1301.                                 lhj[120]=0;
  1302.                                 lhj[121]=lp[ia];
  1303.                                 lhj[122]=lp[ia+1];
  1304.                                 lhj[123]=lp[ib];
  1305.                                 lhj[124]=lp[ib+1];
  1306.                                 lhj[125]=lp[ic];
  1307.                                 lhj[126]=lp[ic+1];
  1308.                                 lhj[127]=0;
  1309.                                 ia+=2;ib+=2;ic+=2;
  1310.                         }
  1311.                         else if(c==2)
  1312.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1313.                                 lhj[120]=0;
  1314.                                 lhj[121]=0;
  1315.                                 lhj[122]=lp[ia];
  1316.                                 lhj[123]=lp[ia+1];
  1317.                                 lhj[124]=lp[ib];
  1318.                                 lhj[125]=lp[ib+1];
  1319.                                 lhj[126]=0;
  1320.                                 lhj[127]=0;
  1321.                                 ia+=2;ib+=2;
  1322.                         }
  1323.                         else
  1324.                         {                                                                                //判断1个字，移一行，8个字节，将字放在中间，两边补0
  1325.                                 lhj[120]=0;
  1326.                                 lhj[121]=0;
  1327.                                 lhj[122]=0;
  1328.                                 lhj[123]=lp[ia];
  1329.                                 ia++;
  1330.                                 lhj[124]=lp[ia];
  1331.                                 ia++;
  1332.                                 lhj[125]=0;
  1333.                                 lhj[126]=0;
  1334.                                 lhj[127]=0;

  1336.                          }
  1337.                         }
  1338.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1339.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1340.                         display();
  1341.                    }
  1342.            }
  1343.                        
  1344. }


  1347. void displaymovetb2(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1348. //上下移动显示函数，din：1为向下，0为向上，lp指向要移入的内容，C表示有几个汉字要移，timer为移动速度
  1349. {
  1350.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1351.         unsigned int tmp=0,timerc=0;
  1352.         if(din)
  1353.         {                                                                                                        //判断移动方向，向下
  1354.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1355.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1356.         ic=96;
  1357.         id=128;
  1358.         i=16;                                                                                                        //行索引
  1359.         while(i--)
  1360.         {                                                                                                       //逐行处理
  1361.                   j=120;
  1362.                 while(j)
  1363.                 {
  1364.                         j--;
  1365.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行，每两行内容相隔6个字节，复制15行
  1366.                 }
  1367.                 if(lp==0)
  1368.                 {                                                                                        //最后一行的处理，判断移入的内容是否为空，是用0移入
  1369.                         j=8;
  1370.                         while(j--)
  1371.                                 lhj[j]=0;
  1372.                 }
  1373.                 else
  1374.                 {                                                                                                //否则，取字数组处理
  1375.                         ia--;ib--;ic--;id--        ;

  1377.                         if(c==4)
  1378.                         {                                                                                //判断4个字，移一行，6个字节
  1379.                         lhj[1]=lp[ia];
  1380.                         ia--;
  1381.                         lhj[0]=lp[ia];
  1382.                         lhj[3]=lp[ib];
  1383.                         ib--;

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

  1387.                         lhj[5]=lp[ic];
  1388.                         ic--;
  1389.                         lhj[4]=lp[ic];

  1391.                         lhj[7]=lp[id];
  1392.                         id--;
  1393.                         lhj[6]=lp[id];
  1394.                         }

  1396.                         else if(c==3)
  1397.                         {                                                                //否则3个字，将字放在中间，旁边补0
  1398.                         lhj[0]=0;
  1399.                         lhj[2]=lp[ia];
  1400.                         ia--;
  1401.                         lhj[1]=lp[ia];
  1402.                         lhj[4]=lp[ib];
  1403.                         ib--;
  1404.                         lhj[3]=lp[ib];
  1405.                         lhj[6]=lp[ic];
  1406.                         ic--;
  1407.                         lhj[5]=lp[ic];
  1408.                         lhj[7]=0;
  1409.                         }


  1412.                         else if(c==2)
  1413.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1414.                         lhj[0]=0;
  1415.                         lhj[1]=0;

  1417.                         lhj[3]=lp[ia];
  1418.                         ia--;
  1419.                         lhj[2]=lp[ia];
  1420.                         lhj[5]=lp[ib];
  1421.                         ib--;
  1422.                         lhj[4]=lp[ib];                       
  1423.                         lhj[6]=0;
  1424.                         lhj[7]=0;

  1426.                         }
  1427.                         else if(c==1)
  1428.                         {                                                                //否则1个字，将字放在中间，旁边补0
  1429.                         lhj[0]=0;
  1430.                         lhj[1]=0;
  1431.                         lhj[2]=0;

  1433.                         lhj[4]=lp[ia];
  1434.                         ia--;
  1435.                         lhj[3]=lp[ia];

  1437.                         lhj[5]=0;       
  1438.                         lhj[6]=0;
  1439.                         lhj[7]=0;

  1441.                         }
  1442.                 }
  1443.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1444.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1445.                         display();
  1446.         }
  1447.         }
  1448.         else
  1449.         {                                                                                        //移动方向，向上
  1450.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动，移入汉字从低位开始

  1452.                 for(i=0;i<16;i++)
  1453.                 {                                                        //处理16行
  1454.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行，每两行内容相隔6个字节，复制15行
  1455.                                 lhj[j]=lhj[j+8];
  1456.                         if(lp==0)
  1457.                         {                                                                //最后一行的处理，判断移入的内容是否为空，是用0移入
  1458.                                 while(j!=128)
  1459.                                 {
  1460.                                         lhj[j]=0;
  1461.                                         j++;
  1462.                                    }
  1463.                         }
  1464.                         else
  1465.                         {                                                                        //否则，取字数组处理
  1466.                         if(c==4)
  1467.                         {                                                                  //判断4个字，移一行，8个字节                                       
  1468.                                 lhj[120]=lp[ia];
  1469.                                 lhj[121]=lp[ia+1];
  1470.                                 lhj[122]=lp[ib];
  1471.                                 lhj[123]=lp[ib+1];
  1472.                                 lhj[124]=lp[ic];
  1473.                                 lhj[125]=lp[ic+1];
  1474.                                 lhj[126]=lp[id];
  1475.                                 lhj[127]=lp[id+1];

  1477.                                 ia+=2;ib+=2;ic+=2;id+=2;                          
  1478.                         }
  1479.                         else if(c==3)
  1480.                         {                                                        //否则3个字，将字放在中间，旁边补0
  1481.                                 lhj[120]=0;
  1482.                                 lhj[121]=lp[ia];
  1483.                                 lhj[122]=lp[ia+1];
  1484.                                 lhj[123]=lp[ib];
  1485.                                 lhj[124]=lp[ib+1];
  1486.                                 lhj[125]=lp[ic];
  1487.                                 lhj[126]=lp[ic+1];
  1488.                                 lhj[127]=0;
  1489.                                 ia+=2;ib+=2;ic+=2;
  1490.                         }
  1491.                         else if(c==2)
  1492.                         {                                                                //否则2个字，将字放在中间，旁边补0
  1493.                                 lhj[120]=0;
  1494.                                 lhj[121]=0;
  1495.                                 lhj[122]=lp[ia];
  1496.                                 lhj[123]=lp[ia+1];
  1497.                                 lhj[124]=lp[ib];
  1498.                                 lhj[125]=lp[ib+1];
  1499.                                 lhj[126]=0;
  1500.                                 lhj[127]=0;
  1501.                                 ia+=2;ib+=2;
  1502.                         }
  1503.                         else
  1504.                         {                                                                                //判断1个字，移一行，8个字节，将字放在中间，两边补0
  1505.                                 lhj[120]=0;
  1506.                                 lhj[121]=0;
  1507.                                 lhj[122]=0;
  1508.                                 lhj[123]=lp[ia];
  1509.                                 ia++;
  1510.                                 lhj[124]=lp[ia];
  1511.                                 ia++;
  1512.                                 lhj[125]=0;
  1513.                                 lhj[126]=0;
  1514.                                 lhj[127]=0;
  1515.                          }
  1516.                         }
  1517.                 timerc=timer;                                                                //处理完16行，调用显示函数更新点阵
  1518.                 while(timerc--)                                                                //循环做为处理的速度，即移动的速度
  1519.                         display();
  1520.                    }
  1521.            }                       
  1522. }
复制代码



作者: 东东东510    时间: 2015-5-24 23:37
真牛 有没有论文，51黑有你更精彩！！！
作者: zzavav    时间: 2015-5-29 10:12
不错，下来看看
作者: junxuzhou    时间: 2015-6-15 10:00
先下来看看
作者: junxuzhou    时间: 2015-6-15 10:01
不知道是用什么做的仿真
作者: 348643887    时间: 2015-9-23 21:34
顶一个
作者: huafeixue8    时间: 2015-9-23 22:48
看起来不错哦
作者: q123456wo    时间: 2015-11-10 13:26
真厉害
作者: jimmy96853421    时间: 2015-11-24 10:41
拿回去看看
作者: 狗莽狗带    时间: 2015-11-25 16:19
很好很强
作者: xxxhim    时间: 2015-11-27 15:26
拿来研究研究
作者: abnerh    时间: 2015-12-21 20:23
很不错，谢谢楼主
作者: q435833414    时间: 2016-1-5 07:37
zzavav 发表于 2015-5-29 10:12
**** 作者被禁止或删除 内容自动屏蔽 ****

哥们，能加我 QQ发下文件吗？我做课程设计急着要。非常感谢435833414
作者: 645896361    时间: 2016-2-2 18:32
大神能加Q指点一下吗！
作者: hjk1994    时间: 2016-3-17 10:29
屌屌屌
作者: mmmoon90    时间: 2016-3-17 18:34
看样子还不错哦。。。
作者: mmmoon90    时间: 2016-3-17 18:34
看样子还不错哦。。。
作者: mmmoon90    时间: 2016-3-17 18:34
看样子还不错哦。。。哈哈
作者: longyi32    时间: 2016-3-27 23:37
your code is just what i want ! i love you!!
作者: 桃子不懂爱    时间: 2016-5-6 21:54
我要研究下
作者: 1238    时间: 2016-5-9 11:49
很好的资料，下载收藏了，
作者: 1238    时间: 2016-5-9 11:50
下载了，不错。学习，学习
作者: liutairun    时间: 2016-5-21 11:23
学习了
作者: nwpchennan    时间: 2016-5-27 13:00
感谢楼主的贡献，看起来应该不错
作者: LeonLee    时间: 2016-9-12 17:23
可以不可以企鹅发我啊，课程设计急需，1739910956
作者: song93    时间: 2016-12-1 23:27
努力学习中
作者: 落叶海潮    时间: 2016-12-14 16:11
程序内容很全，但是你们制作过程中有没有proteus仿真？我想看一下你们的proteus仿真，一般在烧程序之前都会用proteus仿真，multisim也可以。
作者: 伊卜拉    时间: 2016-12-14 21:28
很好的资料
作者: ganggang233    时间: 2016-12-20 16:01
楼主非常不错，学习了
作者: a1101100261    时间: 2016-12-25 12:47
好东西，学习一下，谢谢楼主
作者: 卧室谁    时间: 2016-12-25 22:45
楼主厉害
作者: dianzi8266    时间: 2017-2-17 14:45
学习一下
作者: fang7706    时间: 2017-2-19 20:58
资料比较详细，学习学习！！！
作者: s小y鱼w    时间: 2017-3-4 11:08
急需的资料，谢谢楼主，向楼主学习
作者: tengzhenm    时间: 2017-5-8 21:14
来学习了。
作者: gkx119    时间: 2017-5-21 14:57
厉害 有protues设计么
作者: 13780463700    时间: 2017-6-21 18:28
下载学习
作者: 城市的秋天    时间: 2017-8-17 15:47
得鼓励一下，在校生能做出这样的东西出来，确实很厉害。
看到上面介绍里存在一个概念错误，说stc是美国的。正确的说应该是，stc89c52是国内的品牌，国产的芯片，与美国没有关系。官网网址是：www点stcmcu点com ，里面有芯片的文档和示例代码可以下载
作者: chq018450    时间: 2017-10-16 11:09
谢谢 楼主   正需要，
作者: yang_buck    时间: 2017-11-3 22:47
很好，很强大的说。
作者: xwnc    时间: 2017-11-8 18:33
楼主太强了,学习学习
作者: yf20130607    时间: 2018-3-21 17:49
谢谢楼主的分享！
作者: yang_buck    时间: 2018-6-3 15:55
厉害厉害
作者: 15827594123    时间: 2018-7-3 22:22
要资料
作者: hacehi    时间: 2018-7-9 21:08
历害，优秀的学生
作者: hacehi    时间: 2018-7-12 12:21
要是有元件清单和proteus仿真就好了

作者: pang848687    时间: 2018-7-27 19:59
资料很好，刚好需要，谢谢~~
作者: haidao63    时间: 2018-7-28 20:21
学习了，很好的网站，谢谢了
作者: 祖国的北郊    时间: 2018-11-11 23:16
感谢感谢
作者: xzyyglyt    时间: 2018-11-13 00:00
下载了，慢慢学习，自己做一个显示屏看来挺好玩的
作者: 快乐眼泪    时间: 2018-11-14 10:52
这种的是不是有专门改字的软件？
作者: GG1101    时间: 2018-12-3 10:16
好资料，准备看下
作者: kang13001    时间: 2019-1-10 11:10
大神呀，学习一下！！！
作者: OPIK    时间: 2019-6-24 16:43
很不错，谢谢楼主！
作者: wcs1668    时间: 2019-9-3 15:28
谢谢楼主资料分享。你的程序太长如果做成模块化结构会更好
作者: yaoyao001    时间: 2019-9-3 17:21
牛啊，路过学习下！
作者: fzyzmd    时间: 2019-9-5 16:29

我要研究下
作者: cck314    时间: 2019-9-7 23:15
高手高手，向你学习



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