51单片机16*16点阵显示汉字程序流程图Proteus仿真图

包括原理图 程序 仿真以及流程图
可以通过按键控制点阵显示内容的快慢和方向

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

主程序流程图

按键流程图


显示流程图


单片机源程序如下:

1. 
   
2. //宏定义
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. #define zishu 5                        //字数
   
6. 
   
7. //包含头文件
   
8. #include <reg51.h>
   
9. #include <intrins.h>
   
10. #include <math.h>
    
11. 
    
12. uchar i,flag,j,k;
    
13. uint X=0;
    
14. uchar KEY_NUM=0;
    
15. uchar speed=10;                 //初始速度
    
16. bit pause=0;                 //暂停变量，为1时是暂停
    
17. 
    
18. //管脚定义
    
19. 
    
20. //595
    
21. sbit SI=P0^6;//数据脚
    
22. sbit SCK=P0^5;//上升沿时数据寄存器的数据移位。QA-->QB-->QC-->...-->QH；下降沿移位寄存器数据不变
    
23. sbit RCK=P0^4;//上升沿时移位寄存器的数据进入数据存储寄存器，下降沿时存储寄存器数据不变。通常我将
    
24.                                   //RCK置为低电平，当移位结束后，在RCK端产生一个正脉冲（5V时，大于几十纳秒就行了。我
    
25.                                   //通常都选微秒级），更新显示数据。
    
26. sbit SI0=P0^3;//
    
27. sbit SCK0=P0^2;//
    
28. sbit RCK0=P0^1;
    
29. sbit SI1=P2^1;
    
30. sbit RCK1=P2^2;
    
31. sbit SCK1=P2^0;
    
32. sbit SI2=P2^4;
    
33. sbit RCK2=P2^5;
    
34. sbit SCK2=P2^3;
    
35. sbit KEY_=P3^2;                  //切换方向
    
36. sbit KEY_ADD=P1^0;          //加速
    
37. sbit KEY_DEC=P1^1;          //减速
    
38. sbit KEY_PAUSE=P1^2;  //暂停
    
39. //函数声明
    
40. void Init595_l1();
    
41. void Init595_l2();
    
42. void Init595_c1();
    
43. void Init595_c2();
    
44. void Write_byte595_l1(uchar temp);
    
45. void Write_byte595_l2(uchar temp);
    
46. void Write_byte595_c1(uchar temp);
    
47. void Write_byte595_c2(uchar temp);
    
48. void delay(uint z);
    
49. 
    
50. //汉字数组
    
51. uchar code H1[]=                                                                                                //左移 逐字
    
52. {
    
53. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*" ",0*/
    
54. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*" ",1*/
    
55. 
    
56. ^^^^^^^^^^^^省略见附件^^^^^^^
    
57. };
    
58. uchar code a[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
    
59. uchar code b[]={0x7f,0xbf,0xdf,0xef,0xf7,0xfb,0xfd,0xfe};
    
60. uchar code c[]={0x20,0x40,0x60,0x80};
    
61. 
    
62. void T0_time() interrupt 1                 //定时器0
    
63. {
    
64.         TH0=0x3c;
    
65.         TL0=0xb0;
    
66.         if(KEY_==0)
    
67.         {
    
68.                 KEY_NUM++;
    
69.                 if(KEY_NUM>=2)
    
70.                 {
    
71.                         KEY_NUM=0;
    
72.                         TR0=0;
    
73.                         pause=0;
    
74.                         flag++;
    
75.                         if(flag>=6)                  //切换模式
    
76.                         {
    
77.                                 flag=1;
    
78.                         }
    
79.                         Write_byte595_l1(0xff);
    
80.                         Write_byte595_l2(0xff);
    
81.                         Write_byte595_c1(0x00);
    
82.                         Write_byte595_c2(0x00);
    
83.                         i=1;X=0;j=0;k=0;
    
84.                 }
    
85.         }
    
86.         if(KEY_ADD==0)                                   //加速按键
    
87.         {
    
88.                 speed-=2;                                   //速度变量减2（速度变量越小速度越快）
    
89.                 if(speed<2)                                   //最小减到2
    
90.                 speed=2;
    
91.                 TR0=0;
    
92.         }
    
93.         if(KEY_DEC==0)                                          //减速按键
    
94.         {
    
95.                 speed+=2;
    
96.                 if(speed>20)
    
97.                 speed=20;
    
98.                 TR0=0;
    
99.         }
    
100.         if(KEY_PAUSE==0)                                        //暂停按键
     
101.         {
     
102.                 pause=!pause;                                        //变量为1时进入暂停状态
     
103.                 TR0=0;
     
104.         }
     
105. }
     
106. 
     
107. void display()                                   //显示函数
     
108. {
     
109.         if(flag==1)                                                   //左移函数
     
110.         {
     
111.                 for(k=0;k<speed;k++)                                  //更改speed能改变速度
     
112.                 {
     
113.                         for(i=1;i<17;i++)                                                                                 //一个for循环，分别选中16个列
     
114.                         {  
     
115.                                 if(flag==1)
     
116.                                 {
     
117.                                         Write_byte595_l1(0xff);
     
118.                                         Write_byte595_l2(0xff);
     
119.                                         if(i<9)
     
120.                                         {
     
121.                                                 Write_byte595_c1(a[i-1]);
     
122.                                                 Write_byte595_c2(0x00);
     
123.                                         }
     
124.                                         else
     
125.                                         {
     
126.                                                 Write_byte595_c2(a[i-9]);
     
127.                                                 Write_byte595_c1(0x00);
     
128.                                         }
     
129.                                         Write_byte595_l1(H1[i*2-2+2*X]);
     
130.                                         Write_byte595_l2(H1[i*2-1+2*X]);                        //显示内容
     
131.                                         delay(7);
     
132.                                 }
     
133.                                 if(KEY_&&KEY_ADD&&KEY_DEC&&KEY_PAUSE==1) TR0=1;
     
134.                         }
     
135.                 }
     
136.         }                                 
     
137.         if(flag==2)                                                    //右移函数
     
138.         {
     
139.                 for(k=0;k<speed;k++)
     
140.                 {  
     
141.                         for(i=1;i<17;i++)                                                                                 //一个for循环，分别选中16个列
     
142.                         {  
     
143.                                 if(flag==2)
     
144.                                 {
     
145.                                         Write_byte595_l1(0xff);
     
146.                                         Write_byte595_l2(0xff);
     
147.                                         if(i<9)
     
148.                                         {
     
149.                                                 Write_byte595_c1(a[i-1]);
     
150.                                                 Write_byte595_c2(0x00);
     
151.                                         }
     
152.                                         else
     
153.                                         {
     
154.                                                 Write_byte595_c2(a[i-9]);
     
155.                                                 Write_byte595_c1(0x00);
     
156.                                         }
     
157.                                         Write_byte595_l2(H2[i*2-1-2*X+32*(zishu+1)]);                   //32乘以要显示的汉字加1
     
158.                                         Write_byte595_l1(H2[i*2-2-2*X+32*(zishu+1)]);                   //32乘以要显示的汉字加1
     
159.                                         delay(7);
     
160.                                 }
     
161.                                 if(KEY_&&KEY_ADD&&KEY_DEC&&KEY_PAUSE==1) TR0=1;
     
162.                         }
     
163.                 }
     
164.         }                                 
     
165.        
     
166.         if(flag==3)                                                          // 上移函数
     
167.         {
     
168.                 for(k=0;k<speed;k++)
     
169.                 {  
     
170.                         for(i=1;i<17;i++)                                                                                 //一个for循环，分别选中16个列
     
171.                         {        
     
172.                                 if(flag==3)
     
173.                                 {
     
174.                                         Write_byte595_c1(0x00);
     
175.                                         Write_byte595_c2(0x00);
     
176.                                         if(i<9)
     
177.                                         {
     
178.                                                 Write_byte595_l1(b[i-1]);
     
179.                                                 Write_byte595_l2(0xff);
     
180.                                         }
     
181.                                         else
     
182.                                         {
     
183.                                                 Write_byte595_l2(b[i-9]);
     
184.                                                 Write_byte595_l1(0xff);
     
185.                                         }
     
186.                                         Write_byte595_c1(H3[i*2-2+2*X]);
     
187.                                         Write_byte595_c2(H3[i*2-1+2*X]);
     
188.                                         delay(7);
     
189.                                 }
     
190.                                 if(KEY_&&KEY_ADD&&KEY_DEC&&KEY_PAUSE==1) TR0=1;
     
191.                         }
     
192.                 }
     
193.         }                                                       
     
194.         if(flag==4)                                                         //下移函数
     
195.         {
     
196.                 for(k=0;k<speed;k++)
     
197.                 {  
     
198.                         for(i=1;i<17;i++)                                                                                 //一个for循环，分别选中16个列
     
199.                         {        
     
200.                                 if(flag==4)
     
201.                                 {
     
202.                                         Write_byte595_c1(0x00);
     
203.                                         Write_byte595_c2(0x00);
     
204.                                         if(i<9)
     
205.                                         {
     
206.                                                 Write_byte595_l1(b[i-1]);
     
207.                                                 Write_byte595_l2(0xff);
     
208.                                         }
     
209.                                         else
     
210.                                         {
     
211.                                                 Write_byte595_l2(b[i-9]);
     
212.                                                 Write_byte595_l1(0xff);
     
213.                                         }
     
214.                                         Write_byte595_c1(H4[i*2-2-2*X+32*(zishu+1)]);                          //32乘以要显示的汉字加1
     
215.                                         Write_byte595_c2(H4[i*2-1-2*X+32*(zishu+1)]);                          //32乘以要显示的汉字加1
     
216.                                         delay(7);
     
217.                                 }
     
218.                                 if(KEY_&&KEY_ADD&&KEY_DEC&&KEY_PAUSE==1) TR0=1;
     
219.                         }
     
220.                 }
     
221.         }                                    
     
222.        
     
223.         if(pause==0)                                   //非暂停状态时，正常控制X变量加，也就是正常移动显示
     
224.         {
     
225.                 X++;                                                                                                                //显示左移
     
226.                 if(X==16+16*zishu)                                                                                                        //16加16乘以要显示的汉字数
     
227.                 X=0;                                                                                                        //从头开始
     
228.         }
     
229. }
     
230. 
     
231. void dis_zhuzi()                                                          //逐字显示函数
     
232. {
     
233.         uchar zancun;                                                          //暂存变量
     
234.         if(flag==5)                                  //逐字显示
     
235.         {
     
236.                 for(j=1;j<(zishu+2);j++)                                   //字数+2（加1时是正好都显示，为了显示完显示一个空格，所以此处加2）
     
237.                 {
     
238.                         if(pause!=0)                                                  //暂停状态时
     
239.                         {
     
240.                                 j=zancun;                                                  //将暂存里的数值复制给j（j的值会在上面的for循环里循环变大，在暂停状态时，不想让显示继续，所以这里会将暂停前的j值复制回来）
     
241.                         }
     
242.                         zancun=j;                                                           //正常显示时保存j值到暂存变量中，用于暂停后停止显示
     
243.                         for(k=0;k<(speed*4);k++)                           //调速
     
244.                         {  
     
245.                                 for(i=1;i<17;i++)                                                                                 //一个for循环，分别选中16个列
     
246.                                 {  
     
247.                                         if(flag==5)
     
248.                                         {
     
249.                                                 Write_byte595_l1(0xff);
     
250.                                                 Write_byte595_l2(0xff);
     
251.                                                
     
252.                                                 if(i<9)
     
253.                                                 {
     
254.                                                         Write_byte595_c1(a[i-1]);
     
255.                                                         Write_byte595_c2(0x00);
     
256.                                                 }
     
257.                                                 else
     
258.                                                 {
     
259.                                                         Write_byte595_c2(a[i-9]);
     
260.                                                         Write_byte595_c1(0x00);
     
261.                                                 }
     
262.                                                 Write_byte595_l1(H1[i*2-2+0x20*j]);
     
263.                                                 Write_byte595_l2(H1[i*2-1+0x20*j]);                        //显示内容
     
264.                                                 delay(7);
     
265.                                         }
     
266.                                         if(KEY_&&KEY_ADD&&KEY_DEC&&KEY_PAUSE==1) TR0=1;
     
267.                                 }
     
268.                         }                                       
     
269.                
     
270.                         Write_byte595_c1(0x00);
     
271.                         Write_byte595_c2(0x00);
     
272.                         Write_byte595_l1(0xff);
     
273.                         Write_byte595_l2(0xff);
     
274.                         delay(10);
     
275.                 }
     
276.        
     
277.         }
     
278. }
     
279. 
     
280. //主函数
     
281. void main()
     
282. {
     
283.         EA=1;
     
284.         TMOD=0x01;
     
285.         TH0=0x3c;
     
286.         TL0=0xb0;
     
287.         ET0=1;
     
288.         TR0=1;
     
289.         //595c初始化
     
290.         Init595_l1();
     
291.         Init595_l2();
     
292.         Init595_c1();
     
293.         Init595_c2();
     
294.         //循环演示
     
295.         while(1)          //循环
     
296.         {  
     
297.                 display();                 //调用显示函数
     
298.                 dis_zhuzi();         //调用逐字显示函数
     
299.         }
     
300. }
     
301. 
     
302. //初始化595
     
303. void Init595_l1()
     
304. {
     
305.         flag=1;
     
306.         SI=1;
     
307.         SCK=0;
     
308.         RCK=0;
     
309. }
     
310. void Init595_l2()
     
311. {
     
312.         SI0=1;
     
313.         SCK0=0;
     
314.         RCK0=0;
     
315. }
     
316. void Init595_c1()
     
317. {
     
318.         SI1=1;
     
319.         SCK1=0;
     
320.         RCK1=0;
     
321. }
     
322. void Init595_c2()
     
323. {
     
324.         SI2=1;
     
325.         SCK2=0;
     
326.         RCK2=0;
     
327. }
     
328. 
     
329. void Write_byte595_l1(uchar temp)                //写数据到595
     
330. {
     
331.         uchar i,data_=temp;
     
332.                                                 //关闭列选
     
333.         for(i=0;i<8;i++)                                //传值8位
     
334.         {
     
335.                 if(data_&0x01==0x01)                //判断低位为1
     
336.                 {
     
337.                         SI=1;                                        //数据脚就写入1
     
338.                 }
     
339.                 else                                                 //判断低位为0
     
340.                 {
     
341.                         SI=0;                                        //数据脚写入0
     
342.                 }
     
343.                 //产生一个上升沿
     
344.                 SCK=0;
     
345.                 SCK=1;
     
346.                 SCK=0;
     
347.                 data_>>=1;                                        //将要写入的数据右移一位
     
348.         }
     
349.         RCK=0;//显示数据
     
350.         RCK=1;
     
351.         RCK=0;
     
352. }
     
353. void Write_byte595_c1(uchar temp)                //写数据到595
     
354. {
     
355.         uchar i,data_=temp;
     
356.                                                 //关闭列选
     
357.         for(i=0;i<8;i++)                                //传值8位
     
358.         {
     
359.                 if(data_&0x01==0x01)                //判断低位为1
     
360.                 {
     
361.                         SI1=1;                                        //数据脚就写入1
     
362.                 }
     
363.                 else                                                 //判断低位为0
     
364.                 {
     
365.                         SI1=0;                                        //数据脚写入0
     
366.                 }
     
367.                 //产生一个上升沿
     
368.                 SCK1=0;
     
369.                 SCK1=1;
     
370.                 SCK1=0;
     
371.                 data_>>=1;                                        //将要写入的数据右移一位
     
372.         }
     
373.         RCK1=0;//显示数据
     
374.         RCK1=1;
     
375.         RCK1=0;
     
376. }
     
377. void Write_byte595_l2(uchar temp)                //写数据到595
     
378. {
     
379.         uchar i,data_=temp;
     
380.                                                 //关闭列选
     
381.         for(i=0;i<8;i++)                                //传值8位
     
382.         {
     
383.                 if(data_&0x01==0x01)                //判断低位为1
     
384.                 {
     
385.                         SI0=1;                                        //数据脚就写入1
     
386.                 }
     
387.                 else                                                 //判断低位为0
     
388.                 {
     
389.                         SI0=0;                                        //数据脚写入0
     
390.                 }
     
391.                 //产生一个上升沿
     
392.                 SCK0=0;
     
393.                 SCK0=1;
     
394.                 SCK0=0;
     
395.                 data_>>=1;                                        //将要写入的数据右移一位
     
396.         }
     
397.         RCK0=0;//显示数据
     
398.         RCK0=1;
     
399.         RCK0=0;
     
400. }
     
401. void Write_byte595_c2(uchar temp)                //写数据到595
     
402. {
     
403.         uchar i,data_=temp;
     
404.                                                 //关闭列选
     
405.         for(i=0;i<8;i++)                                //传值8位
     
406.         {
     
407.                 if(data_&0x01==0x01)                //判断低位为1
     
408.                 {
     
409.                         SI2=1;                                        //数据脚就写入1
     
410.                 }
     
411.                 else                                                 //判断低位为0
     
412.                 {
     
413.                         SI2=0;                                        //数据脚写入0
     
414.                 }
     
415.                 //产生一个上升沿
     
416.                 SCK2=0;
     
417.                 SCK2=1;
     
418.                 SCK2=0;
     
419.                 data_>>=1;                                        //将要写入的数据右移一位
     
420.         }
     
421.         RCK2=0;//显示数据
     
422.         RCK2=1;
     
423.         RCK2=0;
     
424. }
     
425. 
     
426. void delay(uint z)           //延时函数
     
427. {
     
428.         uint x,y;
     
429.         for(x=z;x>0;x--)
     
430.                 for(y=7;y>0;y--);
     
431. }
     

复制代码

Keil代码与Proteus8.8 7.5仿真下载:
16点阵.zip (888.79 KB, 下载次数: 141)

2022-8-2 16:46 上传

点击文件名下载附件

好资料，51黑有你更精彩!!!

51有你更精彩

亲测能用  感谢楼主

51有你更精彩

太好了，我一直只懂一些段码的基础东西，先收藏了，有时间慢慢学习。

太好了，我一直只懂一些段码的基础东西，先收藏了，有时间慢慢学习。