单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

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

48×16点阵LED电子显示屏的设计 程序+电路图+pcb文件

  [复制链接]
跳转到指定楼层
楼主
dzdiy 发表于 2015-4-11 21:50 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
   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, 下载次数: 1230)



源代码如下:
  1. /*64*16点阵屏的显示点阵屏的显示*/

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

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

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

  34. /******************  字模  *************************/
  35. code unsigned char         WU[32]={
  36.           0x11,0x00,0x11,0x00,0x51,0x00,0x51,0x04,
  37.       0x7B,0xFE,0x54,0xA4,0x90,0xA4,0x1C,0xA4,
  38.       0x31,0x24,0xD1,0x44,0x12,0x44,0x12,0x44,
  39.       0x14,0x84,0x10,0x84,0x11,0x28,0x10,0x10};//物
  40. code unsigned char DIAN[32]={
  41.           0x02,0x00,0x02,0x00,0x02,0x10,0x7F,0xF8,
  42.       0x42,0x10,0x42,0x10,0x7F,0xF0,0x42,0x10,
  43.       0x42,0x10,0x7F,0xF0,0x42,0x10,0x02,0x00,
  44.       0x02,0x04,0x02,0x04,0x01,0xFC,0x00,0x00};//电
  45. code unsigned char XUE[32]={
  46.           0x22,0x08,0x11,0x08,0x11,0x10,0x00,0x20,
  47.       0x7F,0xFE,0x40,0x02,0x80,0x04,0x1F,0xE0,
  48.       0x00,0x40,0x01,0x84,0xFF,0xFE,0x01,0x00,
  49.       0x01,0x00,0x01,0x00,0x05,0x00,0x02,0x00}; //学
  50. code unsigned char YUAN[32]={
  51.           0x00,0x80,0x78,0x40,0x4F,0xFE,0x54,0x02,
  52.       0x58,0x14,0x63,0xF8,0x50,0x00,0x48,0x08,
  53.       0x4F,0xFC,0x48,0xA0,0x68,0xA0,0x50,0xA0,
  54.       0x41,0x22,0x41,0x22,0x42,0x1E,0x4C,0x00};         //院


  55. code unsigned char LING[32]={
  56.           0x1F,0xF0,0x01,0x00,0x7F,0xFE,0x41,0x02,
  57.       0x9D,0x74,0x01,0x00,0x1D,0x70,0x02,0x80,
  58.       0x0C,0x60,0x32,0x18,0xC1,0x06,0x0F,0xE0,
  59.       0x00,0x40,0x02,0x80,0x01,0x00,0x00,0x80};         //零

  60. code unsigned char JIU[32]={
  61.           0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x20,
  62.       0xFF,0xF0,0x04,0x20,0x04,0x20,0x04,0x20,
  63.       0x04,0x20,0x04,0x20,0x08,0x20,0x08,0x20,
  64.       0x10,0x22,0x10,0x22,0x20,0x1E,0xC0,0x00};          //九
  65. code unsigned char DIAN1[32]={
  66.           0x02,0x00,0x02,0x00,0x02,0x10,0x7F,0xF8,
  67.       0x42,0x10,0x42,0x10,0x7F,0xF0,0x42,0x10,
  68.       0x42,0x10,0x7F,0xF0,0x42,0x10,0x02,0x00,
  69.       0x02,0x04,0x02,0x04,0x01,0xFC,0x00,0x00};          //电

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

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

  162. code unsigned char d[10][16]={
  163. {///*--  文字:  0  --*/
  164. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  165. },
  166. {///*--  文字:  1  --*/
  167. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  168. },
  169. {///*--  文字:  2  --*/
  170. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  171. },
  172. {///*--  文字:  3  --*/
  173. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  174. },
  175. {///*--  文字:  4  --*/
  176. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  177. },
  178. {///*--  文字:  5  --*/
  179. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  180. },
  181. {///*--  文字:  6  --*/
  182. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  183. },
  184. {///*--  文字:  7  --*/
  185. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  186. },
  187. {///*--  文字:  8  --*/
  188. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  189. },
  190. {///*--  文字:  9  --*/
  191. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,}
  192. };

  193. //分数据
  194. code unsigned char b[10][16]={
  195. {///*--  文字:  0  --*/
  196. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  197. },
  198. {///*--  文字:  1  --*/
  199. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  200. },
  201. {///*--  文字:  2  --*/
  202. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  203. },
  204. {///*--  文字:  3  --*/
  205. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  206. },
  207. {///*--  文字:  4  --*/
  208. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  209. },
  210. {///*--  文字:  5  --*/
  211. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  212. },
  213. {///*--  文字:  6  --*/
  214. 0x00,0x00,0x00,0x1C,0x24,0x40,0x40,0x58,0x64,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  215. },
  216. {///*--  文字:  7  --*/
  217. 0x00,0x00,0x00,0x7E,0x44,0x44,0x08,0x08,0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00,
  218. },
  219. {///*--  文字:  8  --*/
  220. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x24,0x18,0x24,0x42,0x42,0x42,0x3C,0x00,0x00,
  221. },
  222. {///*--  文字:  9  --*/
  223. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x26,0x1A,0x02,0x02,0x24,0x38,0x00,0x00,
  224. }
  225. };


  226. code unsigned char a[6][16]={
  227. {///*--  文字:  0  --*/
  228. 0x00,0x00,0x00,0x18,0x24,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18,0x00,0x00,
  229. },
  230. {///*--  文字:  1  --*/
  231. 0x00,0x00,0x00,0x10,0x70,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x7C,0x00,0x00,
  232. },
  233. {///*--  文字:  2  --*/
  234. 0x00,0x00,0x00,0x3C,0x42,0x42,0x42,0x04,0x04,0x08,0x10,0x20,0x42,0x7E,0x00,0x00,
  235. },
  236. {///*--  文字:  3  --*/
  237. 0x00,0x00,0x00,0x3C,0x42,0x42,0x04,0x18,0x04,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  238. },
  239. {///*--  文字:  4  --*/
  240. 0x00,0x00,0x00,0x04,0x0C,0x14,0x24,0x24,0x44,0x44,0x7E,0x04,0x04,0x1E,0x00,0x00,
  241. },
  242. {///*--  文字:  5  --*/
  243. 0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
  244. }
  245. };

  246. /*code unsigned char GGJJ[4][32]={                                 //"关关雎鸠"
  247. {0x10,0x10,0x08,0x18,0x04,0x20,0x04,0x48,
  248. 0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x04,
  249. 0xFF,0xFE,0x01,0x00,0x02,0x80,0x02,0x80,
  250. 0x04,0x40,0x08,0x30,0x30,0x0E,0xC0,0x04,},
  251. {0x10,0x10,0x08,0x18,0x04,0x20,0x04,0x48,
  252. 0x7F,0xFC,0x01,0x00,0x01,0x00,0x01,0x04,
  253. 0xFF,0xFE,0x01,0x00,0x02,0x80,0x02,0x80,
  254. 0x04,0x40,0x08,0x30,0x30,0x0E,0xC0,0x04,},
  255. {0x00,0xC0,0x08,0xA0,0x7D,0x24,0x49,0xFE,
  256. 0x4B,0x20,0x7D,0x28,0x49,0xFC,0x49,0x20,
  257. 0x79,0x28,0x49,0xFC,0x49,0x20,0x4D,0x20,
  258. 0xF1,0x24,0x41,0xFE,0x01,0x00,0x01,0x00,},
  259. {0x20,0x20,0x20,0x48,0x21,0xFC,0x29,0x08,
  260. 0xFD,0x48,0x29,0x08,0x29,0x28,0x29,0x10,
  261. 0x29,0x04,0x29,0xFE,0x28,0x04,0x2A,0x24,
  262. 0x4D,0xF4,0x48,0x04,0x80,0x14,0x00,0x08}
  263. };

  264. code unsigned char ZHZZ[4][32]={                          //"在河之洲"
  265. {0x02,0x00,0x02,0x00,0x02,0x04,0xFF,0xFE,
  266.       0x04,0x00,0x04,0x40,0x08,0x40,0x08,0x50,
  267.       0x13,0xF8,0x30,0x40,0x50,0x40,0x90,0x40,
  268.       0x10,0x40,0x10,0x44,0x17,0xFE,0x10,0x00,},
  269. { 0x40,0x04,0x3F,0xFE,0x10,0x08,0x00,0x08,
  270.       0x80,0x48,0x67,0xE8,0x24,0x48,0x0C,0x48,
  271.       0x14,0x48,0x24,0x48,0xE7,0xC8,0x24,0x48,
  272.       0x20,0x08,0x20,0x08,0x20,0x28,0x20,0x10,},
  273. { 0x02,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
  274.       0x7F,0xF8,0x00,0x10,0x00,0x20,0x00,0x40,
  275.       0x00,0x80,0x01,0x00,0x02,0x00,0x0C,0x00,
  276.       0x30,0x00,0x48,0x06,0x07,0xFC,0x00,0x00,},
  277. {0x01,0x04,0x41,0x04,0x31,0x24,0x11,0x24,
  278.       0x81,0x24,0x65,0xB4,0x23,0x6C,0x0B,0x6C,
  279.       0x11,0x24,0x21,0x24,0xE1,0x24,0x21,0x24,
  280.       0x22,0x24,0x22,0x24,0x24,0x04,0x20,0x04}
  281. };

  282. code unsigned char YTSN[4][32]={                         //"窈窕淑女"
  283. {0x02,0x00,0x41,0x00,0x7F,0xFE,0x48,0x22,
  284. 0x90,0x14,0x04,0x40,0x08,0x48,0x11,0xFC,
  285. 0x7E,0x48,0x04,0x48,0x08,0x48,0x14,0x48,
  286. 0x22,0x88,0x7E,0x88,0x01,0x28,0x02,0x10,
  287. },
  288. {0x02,0x00,0x41,0x00,0x7F,0xFE,0x48,0x22,
  289. 0x92,0x94,0x02,0x80,0x22,0x90,0x12,0x98,
  290. 0x16,0xA0,0x0A,0xC0,0x12,0xA0,0x62,0x98,
  291. 0x04,0x8A,0x04,0x82,0x18,0x7E,0x60,0x00,},
  292. {0x02,0x00,0x42,0x00,0x33,0x80,0x12,0x7C,
  293. 0x82,0x44,0x62,0x44,0x2F,0xC4,0x0A,0x44,
  294. 0x12,0x28,0x27,0x28,0xEA,0x90,0x32,0x10,
  295. 0x22,0x28,0x2A,0x46,0x24,0x84,0x21,0x00,},
  296. {0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,
  297. 0x02,0x04,0xFF,0xFE,0x04,0x20,0x04,0x20,
  298. 0x08,0x20,0x10,0x20,0x0C,0x40,0x02,0x80,
  299. 0x01,0x80,0x06,0x60,0x18,0x18,0x60,0x08,
  300. }
  301. };

  302. code unsigned char JZHQ[4][32]={                             //“君子好逑”
  303. {0x00,0x10,0x3F,0xF8,0x04,0x10,0x04,0x14,
  304. 0xFF,0xFE,0x04,0x10,0x04,0x10,0x3F,0xF0,
  305. 0x08,0x00,0x08,0x08,0x1F,0xFC,0x18,0x08,
  306. 0x28,0x08,0x48,0x08,0x8F,0xF8,0x08,0x08,},
  307. {0x00,0x00,0x3F,0xF0,0x00,0x10,0x00,0x20,
  308. 0x00,0x40,0x01,0x80,0x01,0x04,0xFF,0xFE,
  309. 0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,
  310. 0x01,0x00,0x01,0x00,0x05,0x00,0x02,0x00,},
  311. {0x10,0x00,0x11,0xFC,0x10,0x04,0x10,0x08,
  312. 0xFC,0x10,0x24,0x20,0x24,0x24,0x27,0xFE,
  313. 0x24,0x20,0x44,0x20,0x28,0x20,0x10,0x20,
  314. 0x28,0x20,0x44,0x20,0x84,0xA0,0x00,0x40,},
  315. {0x00,0x40,0x40,0x50,0x30,0x48,0x17,0xFC,
  316. 0x00,0x40,0x02,0x48,0xF1,0x50,0x10,0x40,
  317. 0x11,0x50,0x16,0x4C,0x10,0x44,0x11,0x40,
  318. 0x10,0x80,0x28,0x06,0x47,0xFC,0x00,0x00}
  319. };                */

  320. /*code unsigned char DH1[32] = {
  321.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  322.         0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x80,
  323.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  324.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  325. };
  326. code unsigned char DH2[32] = {
  327.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  328.         0x00,0x00,0x00,0x00,0x01,0x80,0x01,0x80,
  329.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  330.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  331. };
  332. code unsigned char DH3[32] = {
  333.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  334.         0x00,0x00,0x01,0x80,0x03,0xC0,0xFF,0xFF,
  335.         0x01,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
  336.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  337. };

  338. code unsigned char DH4[32] = {
  339.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  340.         0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,
  341.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  342.         0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  343. };        */
  344. void init()                                         //初始化程序
  345. {
  346.         TMOD = 0x01;                               //  定时器0为工作方式1
  347.         TH0 = (65536-50000)/256;        //定时50mS
  348.         TL0 = (65536-50000)%256;
  349.         EA = 1;                                       //开总中断
  350.         ET0 = 1;                                   //开定时器0中断
  351.         EX0 = 1;                                   //开外部中断0
  352.         EX1 = 1;                                   //开外部中断1
  353.         IT0 = 0;                                   //设置外部中断0的中断方式为0 低电平触发
  354.         IT1 = 0;
  355.         TR0 = 1;                                   //启动定时器0

  356.         num = 0;
  357.         nums = 12;
  358.         numf = 30;
  359.         numyear = 2013;
  360.         nummonth = 1;
  361.         numday = 15;
  362. }
  363. void displayshijian()                 //显示时间函数
  364. {
  365.                 unsigned char i,j,p1,k1,p2,k2;
  366.                 p1 = nums/10;
  367.                 k1 = nums%10;          //小时数据
  368.                 p2 = numf/10;
  369.                 k2 = numf%10;          //分钟数据
  370.                
  371.                 for(i=0;i<128;i++)         //显示缓存清空       
  372.                 {       
  373.                         lhj[i]=0;
  374.                 }

  375.                 for(i=0,j=0;i<128;)               
  376.                 {       
  377.                         lhj[i]=c[p1][j];
  378.                         lhj[i+1]=d[k1][j];
  379.        
  380.                           i=i+8;
  381.                         j=j+1;
  382.                 }
  383.        
  384.                 for(i=2,j=0;i<128;)               
  385.                 {       
  386.                         lhj[i]=HOU[j];
  387.                         lhj[i+1]=HOU[j+1];
  388.        
  389.                           i=i+8;
  390.                         j=j+2;
  391.                 }
  392.        
  393.                 for(i=4,j=0;i<128;)               
  394.                 {       
  395.                         lhj[i]=a[p2][j];
  396.                         lhj[i+1]=b[k2][j];
  397.        
  398.                           i=i+8;
  399.                         j=j+1;
  400.                 }
  401.                
  402.                 for(i=6,j=0;i<128;)               
  403.                 {       
  404.                         lhj[i]=MIN[j];
  405.                         lhj[i+1]=MIN[j+1];
  406.        
  407.                           i=i+8;
  408.                         j=j+2;
  409.                 }
  410.                 displayS(1);        



  411. }

  412. void displayshijian2()                 //显示时间函数
  413. {
  414.                
  415.                 unsigned char i,j,p1,k1,p2,k2;
  416.                 p1 = nums/10;
  417.                 k1 = nums%10;          //小时数据
  418.                 p2 = numf/10;
  419.                 k2 = numf%10;          //分钟数据
  420.                
  421.                 for(i=0;i<128;i++)         //显示缓存清空       
  422.                 {       
  423.                         lhj[i]=0;
  424.                 }

  425.                 for(i=0,j=0;i<128;)               
  426.                 {       
  427.                         lhj[i]=c[p1][j];
  428.                         lhj[i+1]=d[k1][j];
  429.        
  430.                           i=i+8;
  431.                         j=j+1;
  432.                 }
  433.        
  434.                 for(i=2,j=0;i<128;)               
  435.                 {       
  436.                         lhj[i]=HOU[j];
  437.                         lhj[i+1]=HOU[j+1];
  438.        
  439.                           i=i+8;
  440.                         j=j+2;
  441.                 }
  442.        
  443.                 for(i=4,j=0;i<128;)               
  444.                 {       
  445.                         lhj[i]=a[p2][j];
  446.                         lhj[i+1]=b[k2][j];
  447.        
  448.                           i=i+8;
  449.                         j=j+1;
  450.                 }
  451.                
  452.                 for(i=6,j=0;i<128;)               
  453.                 {       
  454.                         lhj[i]=MIN[j];
  455.                         lhj[i+1]=MIN[j+1];
  456.        
  457.                           i=i+8;
  458.                         j=j+2;
  459.                 }
  460.                 displayS(1);        
  461. }


  462. void displaynyr()                                //年月日显示程序
  463. {       
  464.                 unsigned char i,j,n1,n2,n3,n4,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  465.                 n1 = numyear/1000;
  466.                 n2 = (numyear%1000)/100;
  467.                 n3 = (numyear%100)/10;
  468.                 n4 = numyear%10;
  469.                 p1 = nummonth/10;
  470.                 k1 = nummonth%10;          //月数据
  471.                 p2 = numday/10;
  472.                 k2 = numday%10;          //日数据

  473.                 for(i=0;i<128;i++)         //显示缓存清空       
  474.                 {       
  475.                         lhj[i]=0;
  476.                 }

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

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

  538. void displaynyr2()
  539. {       
  540.                 unsigned char i,j,p1,k1,p2,k2;         //n年 p1k1月 p2k2日
  541. /*                n1 = numyear/1000;
  542.                 n2 = (numyear%1000)/100;
  543.                 n3 = (numyear%100)/10;
  544.                 n4 = numyear%10;             */
  545.                 p1 = nummonth/10;
  546.                 k1 = nummonth%10;          //月数据
  547.                 p2 = numday/10;
  548.                 k2 = numday%10;          //日数据

  549. /*                for(i=0;i<128;i++)         //显示缓存清空       
  550.                 {       
  551.                         lhj[i]=0;
  552.                 }

  553.                 for(i=0,j=0;i<128;)               
  554.                 {       
  555.                         lhj[i]=d[n1][j];
  556.                         lhj[i+1]=d[n2][j];
  557.        
  558.                           i=i+8;
  559.                         j=j+1;
  560.                 }
  561.                 for(i=2,j=0;i<128;)               
  562.                 {       
  563.                         lhj[i]=d[n3][j];
  564.                         lhj[i+1]=d[n4][j];
  565.        
  566.                           i=i+8;
  567.                         j=j+1;
  568.                 }
  569.                 for(i=4,j=0;i<128;)               
  570.                 {       
  571.                         lhj[i]=NIAN2[j];
  572.                         lhj[i+1]=NIAN2[j+1];
  573.        
  574.                           i=i+8;
  575.                         j=j+2;
  576.                 }
  577.                 displayS2(1);                  */
  578. //       displaymovetb2(1,0,4,1);
  579. /*                for(i=0;i<128;i++)         //显示缓存清空       
  580.                 {       
  581.                         lhj[i]=0;
  582.                 }  */
  583.                 for(i=0,j=0;i<128;)               
  584.                 {       
  585.                         lhj[i]=d[p1][j];
  586.                         lhj[i+1]=d[k1][j];
  587.        
  588.                           i=i+8;
  589.                         j=j+1;
  590.                 }
  591.                 for(i=2,j=0;i<128;)               
  592.                 {       
  593.                         lhj[i]=YUE[j];
  594.                         lhj[i+1]=YUE[j+1];
  595.        
  596.                           i=i+8;
  597.                         j=j+2;
  598.                 }
  599.                 for(i=4,j=0;i<128;)               
  600.                 {       
  601.                         lhj[i]=d[p2][j];
  602.                         lhj[i+1]=d[k2][j];
  603.        
  604.                           i=i+8;
  605.                         j=j+1;
  606.                 }
  607.                 for(i=6,j=0;i<128;)               
  608.                 {       
  609.                         lhj[i]=RI2[j];
  610.                         lhj[i+1]=RI2[j+1];
  611.        
  612.                           i=i+8;
  613.                         j=j+2;
  614.                 }
  615.            displayS2(1);
  616. //      displaymovetb2(1,0,4,1);
  617. }



  618. void extern1() interrupt 2                 //外部中断1
  619. {
  620.         displaynyr2();
  621.         if((key2 == 0)&&(key3 ==0))
  622.                 ISP_CONTR = 0x20;
  623.          
  624.          if(key3 == 0)  
  625.         {       
  626.                 if(key3 == 0)
  627.                 {
  628.                         numday++;
  629.                         if(numday > 31)
  630.                           numday = 1;
  631.                  }
  632.         }

  633.         if(key2 == 0)  
  634.         {       
  635.                 if(key2 == 0)
  636.                 {
  637.                         nummonth++;
  638.                         if(nummonth > 12)
  639.                                 nummonth = 1;
  640.                  }
  641.         }

  642.         key4 = 1;

  643. }       

  644. void extern0() interrupt 0                 //外部中断0
  645. {       

  646.                 displayshijian2();
  647.                 if(key2 == 0)                     //key2按键扫描,按下则 小时nums加1
  648.                 {       
  649.                         if(key2 == 0)
  650.                         {
  651.                                 nums++;
  652.                                 if(nums > 23)
  653.                                         nums =0;
  654.                          }
  655.                 }
  656.                 if(key3 == 0)                         //key3按键扫描,按下则 分钟numf加1
  657.                 {
  658.                         if(key3 == 0)
  659.                         {
  660.                                 numf++;
  661.                                 if(numf > 59)
  662.                                         numf =0;               
  663.                         }
  664.                 }
  665.          /*        if((key2 == 0)&&(key3 ==0))
  666.                     if((key2 == 0)&&(key3 ==0))
  667.                          {
  668.                                  displaymove2(GGJJ,4,1);       
  669.                                 displaymove2(ZHZZ,4,1);       
  670.                                 displaymove2(YTSN,4,1);       
  671.                                 displaymove2(JZHQ,4,1);
  672.                          }         */
  673.         key1 = 1;                   //P3.2口赋高电平 防止下次重复进入中断       

  674. }
  675.        

  676. void T0timer() interrupt 1                   //定时器0中断
  677. {
  678.         TH0 = (65536-50000)/256;
  679.         TL0 = (65536-50000)%256;
  680.         numt0++;
  681.         if(numt0 >= 40)                //24M hz40次为一秒
  682.         {
  683.                 numt0 = 0;
  684.                 num++;
  685.                 if(num > 59)
  686.                 {        num = 0;
  687.                         numf++;
  688.                 }
  689.         }
  690. }

  691. void displaytu_an()
  692. {
  693.          unsigned char i,j;
  694.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  695.          {       
  696.                 lhj[i]=XL[j];
  697.                 lhj[i+1]=XL[j+1];

  698.                   i=i+8;
  699.                 j=j+2;
  700.             }
  701.          
  702.         for(i=4,j=0;i<128;)                                                        //复制安卓机器人图案到中间
  703.                  {       
  704.                         lhj[i]=ANZHUO[j];
  705.                         lhj[i+1]=ANZHUO[j+1];
  706.        
  707.                           i=i+8;
  708.                         j=j+2;
  709.                     }
  710.          displayS(4);                                      //显示图案约2秒

  711. }

  712. /*void displaydonghua()
  713. {
  714.          unsigned char i,j;
  715.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  716.          {       
  717.                 lhj[i]=DH1[j];
  718.                 lhj[i+1]=DH1[j+1];

  719.                   i=i+8;
  720.                 j=j+2;
  721.             }
  722.          displayS(4);
  723.          for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  724.          {       
  725.                 lhj[i]=DH2[j];
  726.                 lhj[i+1]=DH2[j+1];

  727.                   i=i+8;
  728.                 j=j+2;
  729.             }
  730.          displayS(4);


  731.          for(i=0,j=0;i<128;)                                                        //复制笑脸图案到中间
  732.          {       
  733.                 lhj[i]=DH4[j];
  734.                 lhj[i+1]=DH4[j+1];

  735.                   i=i+8;
  736.                 j=j+2;
  737.             }
  738.                   for(i=2,j=0;i<128;)                                                        //复制笑脸图案到中间
  739.          {       
  740.                 lhj[i]=DH3[j];
  741.                 lhj[i+1]=DH3[j+1];

  742.                   i=i+8;
  743.                 j=j+2;
  744.             }
  745.          for(i=4,j=0;i<128;)                                                        //复制笑脸图案到中间
  746.          {       
  747.                 lhj[i]=DH4[j];
  748.                 lhj[i+1]=DH4[j+1];

  749.                   i=i+8;
  750.                 j=j+2;
  751.             }
  752.                   for(i=6,j=0;i<128;)                                                        //复制笑脸图案到中间
  753.          {       
  754.                 lhj[i]=DH4[j];
  755.                 lhj[i+1]=DH4[j+1];

  756.                   i=i+8;
  757.                 j=j+2;
  758.             }
  759.          displayS(5);


  760. }  */

  761. void shijianzz()
  762. {
  763. /***************************************************///时间自增
  764.         if(numf > 59)                           //分钟numf,小时nums自增
  765.         {
  766.                 numf = 0;
  767.                 nums++;
  768.                 if(nums > 23)
  769.                         {
  770.                         nums = 0;
  771.                         numday++;

  772.                         switch(nummonth)
  773.                         {
  774.                         case 1:
  775.                         case 3:
  776.                         case 5:
  777.                         case 7:
  778.                         case 8:
  779.                         case 10:
  780.                         case 12:  if(numday > 31)
  781.                                                 {        nummonth++;
  782.                                                         numday=1;
  783.                                                         if(nummonth > 12)
  784.                                                                 {
  785.                                                                  nummonth =1;
  786.                                                                  numyear++;       
  787.                                                                 }
  788.                                                 };       
  789.                                                 break;                                       
  790.                                           
  791.                         case 4:
  792.                         case 6:
  793.                         case 9:
  794.                         case 11:if(numday > 30)
  795.                                                 {        nummonth++;
  796.                                                         numday=1;
  797.                                                         if(nummonth > 12)
  798.                                                                 {nummonth =1;
  799.                                                                  numyear++;
  800.                                                                 }
  801.                                                 };       
  802.                                                 break;                                       

  803.                         case 2:        {
  804.                                          if(numyear%4==0)
  805.                                                 if(numday > 29  )
  806.                                                 {
  807.                                                         nummonth++;
  808.                                                         numday=1;
  809.                                                         if(nummonth > 12)
  810.                                                                 {nummonth = 1;
  811.                                                                  numyear++;
  812.                                                                 }       
  813.                                                 }
  814.                                          else
  815.                                                 if(numday > 28  )
  816.                                                 {
  817.                                                         nummonth++;
  818.                                                         numday=1;
  819.                                                         if(nummonth > 12)
  820.                                                                 {nummonth =1;
  821.                                                                  numyear++;
  822.                                                                 }       
  823.                                                 }
  824.                                         };break;       
  825.                         }
  826.                        
  827.                 }
  828.         }
  829. /*********************************************************/
  830. }

  831. void displayXNKL()
  832. {
  833.                  /*********逐个显示“新年快乐”************/       
  834.         uchar i,j;
  835.         for(i=0,j=0;i<128;)               
  836.         {       
  837.                 lhj[i]=XIN[j];
  838.                 lhj[i+1]=XIN[j+1];

  839.                   i=i+8;
  840.                 j=j+2;
  841.         }
  842.         displayS(2);
  843.        
  844.         for(i=2,j=0;i<128;)               
  845.         {       
  846.                 lhj[i]=NIAN[j];
  847.                 lhj[i+1]=NIAN[j+1];

  848.                   i=i+8;
  849.                 j=j+2;
  850.         }
  851.         displayS(2);
  852.        
  853.         for(i=4,j=0;i<128;)               
  854.         {       
  855.                 lhj[i]=KUAI[j];
  856.                 lhj[i+1]=KUAI[j+1];

  857.                   i=i+8;
  858.                 j=j+2;
  859.         }
  860.         displayS(2);
  861.        
  862.         for(i=6,j=0;i<128;)               
  863.         {       
  864.                 lhj[i]=LE[j];
  865.                 lhj[i+1]=LE[j+1];

  866.                   i=i+8;
  867.                 j=j+2;
  868.         }
  869.         displayS(2);
  870. /**********************************/       

  871. }

  872. /********************** 主函数 *************************************/
  873. void main(void)           
  874. {

  875.         init();            //初始化程序
  876.         displaytu_an();
  877.         displayS(2);                    
  878.         //displaydonghua();       
  879.         while(1)
  880.         {
  881. //        displaytu_an();                                      //显示图案
  882.         shijianzz();                                        //时间自增函数
  883.         displaymovetb(1,0,4,3);                         //向下清屏
  884.         displaymovetb(1,WU,4,2);                  //向下显示“物电学院"
  885.         displayS(1);                                        //持续显示2S
  886.         displaymovetb(0,0,4,2);                          //向上卷帘清屏
  887.         displaymove(LING,4,1);                          //左跑马 “零九电子”
  888.         displayS(1);
  889.         displaymovetb(1,0,4,2);                        //向下卷帘清屏
  890.         displayXNKL();                                   //由左往右显示‘新年快乐’
  891.         displaymove(0,4,2);                    //左跑马清屏
  892.         displaymovetb(1,BEI,4,3);            //向下显示 “北京时间”
  893.         displayS(2);
  894.         displaymovetb(1,0,4,1);
  895.         displaynyr();                                    //显示****年**月**日
  896.         displayshijian();                            //调用显示**点**分 时间函数
  897.         displayS(5);
  898.         displaymovetb(1,0,4,3);                        //向下清屏
  899.         }

  900. }
  901. /********************** 主函数 *************************************/

  902. void display2()                  //显示子函数 中断调用才使用
  903. {       
  904.         unsigned char i,ia,tmp;       
  905.         unsigned int j;
  906.         DATAOUT=0XFF;                                       
  907.         AB=0;                                                                                //将行数据位清0,准备移位
  908.         for(i=0;i<16;i++)
  909.         {               
  910.                 SCK=0;                       
  911.                 SCLT=0;                       
  912.                 for(ia=8;ia>0;)
  913.                 {                                                //每行64个点,循环位移8个字节
  914.                 ia--;                                                                        //循环四次
  915.                 tmp=~lhj[i*8+ia];       
  916.                         for(j=0;j<8;j++)
  917.                         {                                                //循环两次,每次移一个字节,
  918.                                 SCLH=0;                       
  919.                              DATA=tmp&0x01;                                             //将数据低位做输出
  920.                                 tmp>>=1;         
  921.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  922.                         }                                                                                //移入单字节结束
  923.                 }                                                                                //移入两个字节结束
  924.                 DATAOUT|=0X24;       
  925.                 //等价于SCK=1;               
  926.                 //      SCLT=1;               
  927.                 AB=1;               
  928.         }
  929.         j=100;
  930.         while(j--);                                          //每一行的显示,保持6个字节的移位时间,因此,最后一行的显示,也要加入保持时间,补尝显示的亮度
  931.         SCK=0;                                                  
  932.         SCK=1;                                                  //将最后一行数据移出
  933. }


  934. void display()                                             //显示子函数
  935. {       
  936.         unsigned char i,ia,tmp;       
  937.         unsigned int j;
  938.         DATAOUT=0XFF;                                       
  939.         AB=0;                                                                                //将行数据位清0,准备移位
  940.         for(i=0;i<16;i++)
  941.         {               
  942.                 SCK=0;                       
  943.                 SCLT=0;                       
  944.                 for(ia=8;ia>0;)
  945.                 {                                                //每行64个点,循环位移8个字节
  946.                 ia--;                                                                        //循环四次
  947.                 tmp=~lhj[i*8+ia];       
  948.                         for(j=0;j<8;j++)
  949.                         {                                                //循环两次,每次移一个字节,
  950.                                 SCLH=0;                       
  951.                              DATA=tmp&0x01;                                             //将数据低位做输出
  952.                                 tmp>>=1;         
  953.                              SCLH=1;                                                                //将DATA上的数据移入寄存器
  954.                         }                                                                                //移入单字节结束
  955.                 }                                                                                //移入两个字节结束
  956.                 DATAOUT|=0X24;       
  957.                 //等价于SCK=1;               
  958.                 //      SCLT=1;               
  959.                 AB=1;               
  960.         }
  961.         j=100;
  962.         while(j--);                                          //每一行的显示,保持6个字节的移位时间,因此,最后一行的显示,也要加入保持时间,补尝显示的亮度
  963.         SCK=0;                                                  
  964.         SCK=1;                                                  //将最后一行数据移出
  965. }


  966. void displayS2(unsigned int timer)                   //指定时间扫描显示函数 中断调用时用
  967. {
  968.         unsigned char i;       
  969.         while(timer--)
  970.         {                                  //当timer=1时,大约1秒时间
  971.                 i=20;               
  972.                 while(i--)
  973.                         display2();
  974.         }
  975. }



  976. void displayS(unsigned int timer)            //指定时间扫描显示函数
  977. {
  978.         unsigned char i;       
  979.         while(timer--)
  980.         {                                  //当timer=1时,大约1秒时间
  981.                 i=20;               
  982.                 while(i--)
  983.                         display();
  984.         }
  985. }

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


  1036. void displaymove2(unsigned char *lp,unsigned char c,unsigned char timer)//左移显示函数,LP指向要显示第一个字的首地址,C表示显示字的个数,
  1037.                                                                                                                                                 //timer是移动的速度
  1038. {
  1039.         unsigned char i=0,j=0,ia=0;
  1040.         unsigned int tmp=0,timerc=0;
  1041.         unsigned char tmp2[16];
  1042.         c*=2;               
  1043.         for(i=0;i<16;i++)
  1044.                 tmp2[i]=0;                                            //将缓冲区清0,
  1045.         while(c)
  1046.         {
  1047.                 if(lp!=0)
  1048.                 {                                            //当lp指向的地址为0时,直接用组缓冲0补上,效果是将当前显示的内容移出
  1049.                 tmp=c%2;                                                                        //取余,目的是为了判断处理汉字的前半部份还是后半部份
  1050.                 for(i=0;i<16;i++)
  1051.                         {               
  1052.                                 tmp2[i]=lp[i*2+tmp];                                        //取半个汉字点阵数据,16字节
  1053.                         }
  1054.                 if(tmp)                                                                                //当tmp为1时,表时一个字数组处理完成,将地址转到下一个字
  1055.                         lp+=32;
  1056.                 }
  1057.                 //--------------
  1058.                 tmp=8;                                                                                //变量再次利用
  1059.                 while(tmp)
  1060.                 {                                                                        //循环8次,是将下一个字的前半部份的字节数据移入显示缓冲       
  1061.                 ia=0;                                                                                //做为点阵数组的元素
  1062.                 for(i=0;i<16;i++)
  1063.                 {                                                        //移动是16行同时移,因此要处理16个字节
  1064.                         for(j=0;j<7;j++)
  1065.                         {                                                //一行32个点四字节,有三字节在显示缓冲中移动
  1066.                                 lhj[ia]<<=1;                                                //移当前显示缓冲的半行字节
  1067.                                 if(lhj[ia+1]&0x80)                                        //判断后半行字节的高位是否为1,是移入前半行字节低位,否则不处理
  1068.                                         lhj[ia]++;
  1069.                                 ia++;
  1070.                         }
  1071.                         lhj[ia]<<=1;                                                        //一行32个点四字节,将最后一字节用下一个字补上
  1072.                         if(tmp2[i]&0x80)                                                //判断下一个要显示汉字的前半行字节的高位是否为1,是移入,否则不处理
  1073.                                 lhj[ia]++;
  1074.                         ia++;
  1075.                         tmp2[i]<<=1;                                                        //下一个要显示汉字的半行字节向高位移一位,准备下一次取位
  1076.                 }
  1077.                 tmp--;
  1078.                 timerc=timer;                                                                //处理完16行,调用显示函数更新点阵
  1079.                 while(timerc--)                                                                        //循环做为处理的速度,即移动的速度
  1080.                         display2();
  1081.                 }
  1082.                 //----------
  1083.                 c--;                                                                                        //移完一半,进入下一半或下一个汉字,直到结束
  1084.         }
  1085. }




  1086. void displaymovetb(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1087. //上下移动显示函数,din:1为向下,0为向上,lp指向要移入的内容,C表示有几个汉字要移,timer为移动速度
  1088. {
  1089.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1090.         unsigned int tmp=0,timerc=0;
  1091.         if(din)
  1092.         {                                                                                                        //判断移动方向,向下
  1093.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1094.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1095.         ic=96;
  1096.         id=128;
  1097.         i=16;                                                                                                        //行索引
  1098.         while(i--)
  1099.         {                                                                                                       //逐行处理
  1100.                   j=120;
  1101.                 while(j)
  1102.                 {
  1103.                         j--;
  1104.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行,每两行内容相隔6个字节,复制15行
  1105.                 }
  1106.                 if(lp==0)
  1107.                 {                                                                                        //最后一行的处理,判断移入的内容是否为空,是用0移入
  1108.                         j=8;
  1109.                         while(j--)
  1110.                                 lhj[j]=0;
  1111.                 }
  1112.                 else
  1113.                 {                                                                                                //否则,取字数组处理
  1114.                         ia--;ib--;ic--;id--        ;

  1115.                         if(c==4)
  1116.                         {                                                                                //判断4个字,移一行,6个字节
  1117.                         lhj[1]=lp[ia];
  1118.                         ia--;
  1119.                         lhj[0]=lp[ia];
  1120.                         lhj[3]=lp[ib];
  1121.                         ib--;
  1122.                         lhj[2]=lp[ib];
  1123.                         lhj[5]=lp[ic];
  1124.                         ic--;
  1125.                         lhj[4]=lp[ic];
  1126.                         lhj[7]=lp[id];
  1127.                         id--;
  1128.                         lhj[6]=lp[id];
  1129.                         }


  1130.                         else if(c==3)
  1131.                         {                                                                //否则3个字,将字放在中间,旁边补0
  1132.                         lhj[0]=0;
  1133.                         lhj[2]=lp[ia];
  1134.                         ia--;
  1135.                         lhj[1]=lp[ia];
  1136.                         lhj[4]=lp[ib];
  1137.                         ib--;
  1138.                         lhj[3]=lp[ib];
  1139.                         lhj[6]=lp[ic];
  1140.                         ic--;
  1141.                         lhj[5]=lp[ic];
  1142.                         lhj[7]=0;
  1143.                         }

  1144.                         else if(c==2)
  1145.                         {                                                                //否则2个字,将字放在中间,旁边补0
  1146.                         lhj[0]=0;
  1147.                         lhj[1]=0;

  1148.                         lhj[3]=lp[ia];
  1149.                         ia--;
  1150.                         lhj[2]=lp[ia];
  1151.                         lhj[5]=lp[ib];
  1152.                         ib--;
  1153.                         lhj[4]=lp[ib];                       
  1154.                         lhj[6]=0;
  1155.                         lhj[7]=0;
  1156.                         }
  1157.                         else if(c==1)
  1158.                         {                                                                //否则1个字,将字放在中间,旁边补0
  1159.                         lhj[0]=0;
  1160.                         lhj[1]=0;
  1161.                         lhj[2]=0;

  1162.                         lhj[4]=lp[ia];
  1163.                         ia--;
  1164.                         lhj[3]=lp[ia];

  1165.                         lhj[5]=0;       
  1166.                         lhj[6]=0;
  1167.                         lhj[7]=0;

  1168.                         }
  1169.                 }
  1170.                 timerc=timer;                                                                //处理完16行,调用显示函数更新点阵
  1171.                 while(timerc--)                                                                //循环做为处理的速度,即移动的速度
  1172.                         display();
  1173.         }
  1174.         }
  1175.         else
  1176.         {                                                                                        //移动方向,向上
  1177.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动,移入汉字从低位开始

  1178.                 for(i=0;i<16;i++)
  1179.                 {                                                        //处理16行
  1180.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行,每两行内容相隔6个字节,复制15行
  1181.                                 lhj[j]=lhj[j+8];
  1182.                         if(lp==0)
  1183.                         {                                                                //最后一行的处理,判断移入的内容是否为空,是用0移入
  1184.                                 while(j!=128)
  1185.                                 {
  1186.                                         lhj[j]=0;
  1187.                                         j++;
  1188.                                    }
  1189.                         }
  1190.                         else
  1191.                         {                                                                        //否则,取字数组处理
  1192.                         if(c==4)
  1193.                         {                                                                  //判断4个字,移一行,8个字节                                       
  1194.                                 lhj[120]=lp[ia];
  1195.                                 lhj[121]=lp[ia+1];
  1196.                                 lhj[122]=lp[ib];
  1197.                                 lhj[123]=lp[ib+1];
  1198.                                 lhj[124]=lp[ic];
  1199.                                 lhj[125]=lp[ic+1];
  1200.                                 lhj[126]=lp[id];
  1201.                                 lhj[127]=lp[id+1];

  1202.                                 ia+=2;ib+=2;ic+=2;id+=2;                          
  1203.                         }
  1204.                         else if(c==3)
  1205.                         {                                                        //否则3个字,将字放在中间,旁边补0
  1206.                                 lhj[120]=0;
  1207.                                 lhj[121]=lp[ia];
  1208.                                 lhj[122]=lp[ia+1];
  1209.                                 lhj[123]=lp[ib];
  1210.                                 lhj[124]=lp[ib+1];
  1211.                                 lhj[125]=lp[ic];
  1212.                                 lhj[126]=lp[ic+1];
  1213.                                 lhj[127]=0;
  1214.                                 ia+=2;ib+=2;ic+=2;
  1215.                         }
  1216.                         else if(c==2)
  1217.                         {                                                                //否则2个字,将字放在中间,旁边补0
  1218.                                 lhj[120]=0;
  1219.                                 lhj[121]=0;
  1220.                                 lhj[122]=lp[ia];
  1221.                                 lhj[123]=lp[ia+1];
  1222.                                 lhj[124]=lp[ib];
  1223.                                 lhj[125]=lp[ib+1];
  1224.                                 lhj[126]=0;
  1225.                                 lhj[127]=0;
  1226.                                 ia+=2;ib+=2;
  1227.                         }
  1228.                         else
  1229.                         {                                                                                //判断1个字,移一行,8个字节,将字放在中间,两边补0
  1230.                                 lhj[120]=0;
  1231.                                 lhj[121]=0;
  1232.                                 lhj[122]=0;
  1233.                                 lhj[123]=lp[ia];
  1234.                                 ia++;
  1235.                                 lhj[124]=lp[ia];
  1236.                                 ia++;
  1237.                                 lhj[125]=0;
  1238.                                 lhj[126]=0;
  1239.                                 lhj[127]=0;

  1240.                          }
  1241.                         }
  1242.                 timerc=timer;                                                                //处理完16行,调用显示函数更新点阵
  1243.                 while(timerc--)                                                                //循环做为处理的速度,即移动的速度
  1244.                         display();
  1245.                    }
  1246.            }
  1247.                        
  1248. }


  1249. void displaymovetb2(unsigned char din,unsigned char *lp,unsigned char c,unsigned char timer)
  1250. //上下移动显示函数,din:1为向下,0为向上,lp指向要移入的内容,C表示有几个汉字要移,timer为移动速度
  1251. {
  1252.         unsigned char i=0,j=0,ia=0,ib=0,ic=0,id=0;
  1253.         unsigned int tmp=0,timerc=0;
  1254.         if(din)
  1255.         {                                                                                                        //判断移动方向,向下
  1256.         ia=32;                                                                                                        //要移入第一个汉字的数组元素
  1257.         ib=64;                                                                                                        //要移入第二个汉字的数组元素
  1258.         ic=96;
  1259.         id=128;
  1260.         i=16;                                                                                                        //行索引
  1261.         while(i--)
  1262.         {                                                                                                       //逐行处理
  1263.                   j=120;
  1264.                 while(j)
  1265.                 {
  1266.                         j--;
  1267.                         lhj[j+8]=lhj[j];                                                                //将上一行的内容复制到下一行,每两行内容相隔6个字节,复制15行
  1268.                 }
  1269.                 if(lp==0)
  1270.                 {                                                                                        //最后一行的处理,判断移入的内容是否为空,是用0移入
  1271.                         j=8;
  1272.                         while(j--)
  1273.                                 lhj[j]=0;
  1274.                 }
  1275.                 else
  1276.                 {                                                                                                //否则,取字数组处理
  1277.                         ia--;ib--;ic--;id--        ;

  1278.                         if(c==4)
  1279.                         {                                                                                //判断4个字,移一行,6个字节
  1280.                         lhj[1]=lp[ia];
  1281.                         ia--;
  1282.                         lhj[0]=lp[ia];
  1283.                         lhj[3]=lp[ib];
  1284.                         ib--;

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

  1286.                         lhj[5]=lp[ic];
  1287.                         ic--;
  1288.                         lhj[4]=lp[ic];

  1289.                         lhj[7]=lp[id];
  1290.                         id--;
  1291.                         lhj[6]=lp[id];
  1292.                         }

  1293.                         else if(c==3)
  1294.                         {                                                                //否则3个字,将字放在中间,旁边补0
  1295.                         lhj[0]=0;
  1296.                         lhj[2]=lp[ia];
  1297.                         ia--;
  1298.                         lhj[1]=lp[ia];
  1299.                         lhj[4]=lp[ib];
  1300.                         ib--;
  1301.                         lhj[3]=lp[ib];
  1302.                         lhj[6]=lp[ic];
  1303.                         ic--;
  1304.                         lhj[5]=lp[ic];
  1305.                         lhj[7]=0;
  1306.                         }


  1307.                         else if(c==2)
  1308.                         {                                                                //否则2个字,将字放在中间,旁边补0
  1309.                         lhj[0]=0;
  1310.                         lhj[1]=0;

  1311.                         lhj[3]=lp[ia];
  1312.                         ia--;
  1313.                         lhj[2]=lp[ia];
  1314.                         lhj[5]=lp[ib];
  1315.                         ib--;
  1316.                         lhj[4]=lp[ib];                       
  1317.                         lhj[6]=0;
  1318.                         lhj[7]=0;

  1319.                         }
  1320.                         else if(c==1)
  1321.                         {                                                                //否则1个字,将字放在中间,旁边补0
  1322.                         lhj[0]=0;
  1323.                         lhj[1]=0;
  1324.                         lhj[2]=0;

  1325.                         lhj[4]=lp[ia];
  1326.                         ia--;
  1327.                         lhj[3]=lp[ia];

  1328.                         lhj[5]=0;       
  1329.                         lhj[6]=0;
  1330.                         lhj[7]=0;

  1331.                         }
  1332.                 }
  1333.                 timerc=timer;                                                                //处理完16行,调用显示函数更新点阵
  1334.                 while(timerc--)                                                                //循环做为处理的速度,即移动的速度
  1335.                         display();
  1336.         }
  1337.         }
  1338.         else
  1339.         {                                                                                        //移动方向,向上
  1340.         ia=0;ib=32;ic=64;id=96;                                                        //向上移动,移入汉字从低位开始

  1341.                 for(i=0;i<16;i++)
  1342.                 {                                                        //处理16行
  1343.                         for(j=0;j<120;j++)                                                //将下一行的内容复制到上一行,每两行内容相隔6个字节,复制15行
  1344.                                 lhj[j]=lhj[j+8];
  1345.                         if(lp==0)
  1346.                         {                                                                //最后一行的处理,判断移入的内容是否为空,是用0移入
  1347.                                 while(j!=128)
  1348.                                 {
  1349.                                         lhj[j]=0;
  1350.                                         j++;
  1351.                                    }
  1352.                         }
  1353.                         else
  1354.                         {                                                                        //否则,取字数组处理
  1355.                         if(c==4)
  1356.                         {                                                                  //判断4个字,移一行,8个字节                                       
  1357.                                 lhj[120]=lp[ia];
  1358.                                 lhj[121]=lp[ia+1];
  1359.                                 lhj[122]=lp[ib];
  1360.                                 lhj[123]=lp[ib+1];
  1361.                                 lhj[124]=lp[ic];
  1362.                                 lhj[125]=lp[ic+1];
  1363.                                 lhj[126]=lp[id];
  1364.                                 lhj[127]=lp[id+1];

  1365.                                 ia+=2;ib+=2;ic+=2;id+=2;                          
  1366.                         }
  1367.                         else if(c==3)
  1368.                         {                                                        //否则3个字,将字放在中间,旁边补0
  1369.                                 lhj[120]=0;
  1370.                                 lhj[121]=lp[ia];
  1371.                                 lhj[122]=lp[ia+1];
  1372.                                 lhj[123]=lp[ib];
  1373.                                 lhj[124]=lp[ib+1];
  1374.                                 lhj[125]=lp[ic];
  1375.                                 lhj[126]=lp[ic+1];
  1376.                                 lhj[127]=0;
  1377.                                 ia+=2;ib+=2;ic+=2;
  1378.                         }
  1379.                         else if(c==2)
  1380.                         {                                                                //否则2个字,将字放在中间,旁边补0
  1381.                                 lhj[120]=0;
  1382.                                 lhj[121]=0;
  1383.                                 lhj[122]=lp[ia];
  1384.                                 lhj[123]=lp[ia+1];
  1385.                                 lhj[124]=lp[ib];
  1386.                                 lhj[125]=lp[ib+1];
  1387.                                 lhj[126]=0;
  1388.                                 lhj[127]=0;
  1389.                                 ia+=2;ib+=2;
  1390.                         }
  1391.                         else
  1392.                         {                                                                                //判断1个字,移一行,8个字节,将字放在中间,两边补0
  1393.                                 lhj[120]=0;
  1394.                                 lhj[121]=0;
  1395.                                 lhj[122]=0;
  1396.                                 lhj[123]=lp[ia];
  1397.                                 ia++;
  1398.                                 lhj[124]=lp[ia];
  1399.                                 ia++;
  1400.                                 lhj[125]=0;
  1401.                                 lhj[126]=0;
  1402.                                 lhj[127]=0;
  1403.                          }
  1404.                         }
  1405.                 timerc=timer;                                                                //处理完16行,调用显示函数更新点阵
  1406.                 while(timerc--)                                                                //循环做为处理的速度,即移动的速度
  1407.                         display();
  1408.                    }
  1409.            }                       
  1410. }
复制代码



评分

参与人数 2黑币 +6 收起 理由
hacehi + 1 绝世好帖!
18316719944 + 5 共享资料的黑币奖励!

查看全部评分

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

使用道具 举报

来自 2#
城市的秋天 发表于 2017-8-17 15:47 | 只看该作者
得鼓励一下,在校生能做出这样的东西出来,确实很厉害。
看到上面介绍里存在一个概念错误,说stc是美国的。正确的说应该是,stc89c52是国内的品牌,国产的芯片,与美国没有关系。官网网址是:www点stcmcu点com ,里面有芯片的文档和示例代码可以下载

评分

参与人数 1黑币 +20 收起 理由
admin + 20 回帖助人的奖励!

查看全部评分

回复

使用道具 举报

板凳
东东东510 发表于 2015-5-24 23:37 | 只看该作者
真牛 有没有论文,51黑有你更精彩!!!
回复

使用道具 举报

地板
zzavav 发表于 2015-5-29 10:12 | 只看该作者
不错,下来看看
回复

使用道具 举报

5#
junxuzhou 发表于 2015-6-15 10:00 | 只看该作者
先下来看看
回复

使用道具 举报

6#
junxuzhou 发表于 2015-6-15 10:01 | 只看该作者
不知道是用什么做的仿真
回复

使用道具 举报

7#
348643887 发表于 2015-9-23 21:34 | 只看该作者
顶一个
回复

使用道具 举报

8#
huafeixue8 发表于 2015-9-23 22:48 | 只看该作者
看起来不错哦
回复

使用道具 举报

9#
q123456wo 发表于 2015-11-10 13:26 | 只看该作者
真厉害
回复

使用道具 举报

10#
jimmy96853421 发表于 2015-11-24 10:41 | 只看该作者
拿回去看看
回复

使用道具 举报

11#
狗莽狗带 发表于 2015-11-25 16:19 | 只看该作者
很好很强
回复

使用道具 举报

12#
xxxhim 发表于 2015-11-27 15:26 | 只看该作者
拿来研究研究
回复

使用道具 举报

13#
abnerh 发表于 2015-12-21 20:23 | 只看该作者
很不错,谢谢楼主
回复

使用道具 举报

14#
q435833414 发表于 2016-1-5 07:37 | 只看该作者
zzavav 发表于 2015-5-29 10:12
**** 作者被禁止或删除 内容自动屏蔽 ****

哥们,能加我 QQ发下文件吗?我做课程设计急着要。非常感谢435833414
回复

使用道具 举报

15#
645896361 发表于 2016-2-2 18:32 | 只看该作者
大神能加Q指点一下吗!
回复

使用道具 举报

16#
hjk1994 发表于 2016-3-17 10:29 | 只看该作者
屌屌屌
回复

使用道具 举报

17#
mmmoon90 发表于 2016-3-17 18:34 | 只看该作者
看样子还不错哦。。。
回复

使用道具 举报

18#
mmmoon90 发表于 2016-3-17 18:34 | 只看该作者
看样子还不错哦。。。
回复

使用道具 举报

19#
mmmoon90 发表于 2016-3-17 18:34 | 只看该作者
看样子还不错哦。。。哈哈
回复

使用道具 举报

20#
longyi32 发表于 2016-3-27 23:37 | 只看该作者
your code is just what i want ! i love you!!
回复

使用道具 举报

21#
桃子不懂爱 发表于 2016-5-6 21:54 | 只看该作者
我要研究下
回复

使用道具 举报

22#
1238 发表于 2016-5-9 11:49 | 只看该作者
很好的资料,下载收藏了,
回复

使用道具 举报

23#
1238 发表于 2016-5-9 11:50 | 只看该作者
下载了,不错。学习,学习
回复

使用道具 举报

24#
liutairun 发表于 2016-5-21 11:23 | 只看该作者
学习了
回复

使用道具 举报

25#
nwpchennan 发表于 2016-5-27 13:00 | 只看该作者
感谢楼主的贡献,看起来应该不错
回复

使用道具 举报

26#
LeonLee 发表于 2016-9-12 17:23 | 只看该作者
可以不可以企鹅发我啊,课程设计急需,1739910956
回复

使用道具 举报

27#
song93 发表于 2016-12-1 23:27 | 只看该作者
努力学习中
回复

使用道具 举报

28#
落叶海潮 发表于 2016-12-14 16:11 | 只看该作者
程序内容很全,但是你们制作过程中有没有proteus仿真?我想看一下你们的proteus仿真,一般在烧程序之前都会用proteus仿真,multisim也可以。
回复

使用道具 举报

29#
伊卜拉 发表于 2016-12-14 21:28 | 只看该作者
很好的资料
回复

使用道具 举报

30#
ganggang233 发表于 2016-12-20 16:01 | 只看该作者
楼主非常不错,学习了
回复

使用道具 举报

31#
a1101100261 发表于 2016-12-25 12:47 | 只看该作者
好东西,学习一下,谢谢楼主
回复

使用道具 举报

32#
卧室谁 发表于 2016-12-25 22:45 | 只看该作者
楼主厉害
回复

使用道具 举报

33#
dianzi8266 发表于 2017-2-17 14:45 | 只看该作者
学习一下
回复

使用道具 举报

34#
fang7706 发表于 2017-2-19 20:58 | 只看该作者
资料比较详细,学习学习!!!
回复

使用道具 举报

35#
s小y鱼w 发表于 2017-3-4 11:08 | 只看该作者
急需的资料,谢谢楼主,向楼主学习
回复

使用道具 举报

36#
tengzhenm 发表于 2017-5-8 21:14 | 只看该作者
来学习了。
回复

使用道具 举报

37#
gkx119 发表于 2017-5-21 14:57 | 只看该作者
厉害 有protues设计么
回复

使用道具 举报

38#
13780463700 发表于 2017-6-21 18:28 来自手机 | 只看该作者
下载学习
回复

使用道具 举报

39#
chq018450 发表于 2017-10-16 11:09 | 只看该作者
谢谢 楼主   正需要,
回复

使用道具 举报

40#
yang_buck 发表于 2017-11-3 22:47 | 只看该作者
很好,很强大的说。
回复

使用道具 举报

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

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51黑电子论坛单片机.

Powered by 单片机教程网

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