很不错，对于初学者有很大的帮助

很不错，对于初学者有很大的帮助

黑币不够啊，能不能把这么多文件放在一个压缩包里，谢谢！

很有参考价值

楼主可以帮我看一下是怎么回事吗

http://www.51hei.com/bbs/dpj-126816-1.html
大佬你好，我照着您的教程还原俄罗斯方块，通电后是这个状况，请问是什么原因？
想联系您aienn7086@gmail.com，看到能否回我！

上传一个点阵引脚图

想问pcb封装时 点阵引脚间距设定问题求助555

在实现过程中io设定还是有点问题
继续琢磨看看！

真滴有点帅哦 发表于 2017-12-15 21:48
太棒了！刚才试了一下，完全没有毛病，完美通过！看来我单片机课设，有着落啦！这就买东西！上一波图！

大大，我想问问为什么仿真的时候RESET复位无效呢

大大，我想问问为什么仿真的时候RESET复位无效呢

厉害啊

太棒了！刚才试了一下，完全没有毛病，完美通过！看来我单片机课设，有着落啦！这就买东西！上一波图！

我感觉非常有意思，而且内容给的非常的详细，程序很多注释，我这种小白都基本都能看懂，我单片机课程设计，就准备做它了，我准备先仿真一下试试看看

谢谢大佬，国庆花几天做着玩一下

强！~ 按照楼主做一个试试

牛掰

源程序：

1. /*****************************************************************************************
   
2. 名称：《基于8052单片机和8X16点阵屏俄罗斯方块游戏板》
   
3. 时间：05月23日17时
   
4. 单位：武汉理工大学信息学院电子1003班
   
5. 作者：颜百千
   
6. *****************************************************************************************/
   
7. #include<reg52.h>
   
8. #include<stdlib.h>
   
9. #include<math.h>
   
10. #define uchar unsigned char
    
11. sbit slock=P2^7;                                        //译码器输出使能端
    
12. sbit upkey=P2^3;                                        //“旋转图形/向上”按键
    
13. sbit leftkey=P2^1;                                        //“左移/向左”按键
    
14. sbit rightkey=P2^2;                                        //“右移/向右”按键
    
15. sbit downkey=P2^0;                                        //“快速下移/向下”按键
    
16. sbit duan=P2^5;                                                //数码管段选信号所用锁存器的锁存允许端
    
17. sbit wei=P2^6;                                                //数码管位选信号所用锁存器的锁存允许端
    
18. sbit startsuspendkey=P2^4;                        //“开始/暂停/继续”多功能切换按键
    
19. /***********************************图形编码机制介绍**************************************
    
20. 1.由于俄罗斯方块图形的宽度和高度最多只有四位，所以要以4X4为基本单元。
    
21. 2.硬件采用16行扫描、8位送显示信号
    
22. 3.各个图形的宽度不一致，所以要人为给图形设定居中位置。
    
23.   若图形宽度为偶数可直接将其居中，若为奇数则靠左居中。
    
24. 4.由于图形需要旋转，所以由基本的图形会衍生出另外3种图形。
    
25. 5.因此每个图形应该给定4个8位的二进制码，并放入一个二维数组里。
    
26. 6.经典俄罗斯方块游戏里有19种不同形状的方块，包括旋转得到的。
    
27. 7.数组的第一个下标为该图形的编号
    
28. *****************************************************************************************/
    
29. uchar code allshape[19][4]={0x00,0x00,0x18,0x18,0x10,0x10,0x10,0x10,0x00,0x00,0x00,0x3c,
    
30.                                                         0x00,0x08,0x18,0x10,0x00,0x00,0x30,0x18,0x00,0x10,0x18,0x08,
    
31.                                                         0x00,0x00,0x18,0x30,0x00,0x08,0x08,0x18,0x00,0x00,0x38,0x08,
    
32.                                                         0x00,0x18,0x10,0x10,0x00,0x00,0x20,0x38,0x00,0x10,0x10,0x18,
    
33.                                                         0x00,0x00,0x08,0x38,0x00,0x18,0x08,0x08,0x00,0x00,0x38,0x20,
    
34.                                                         0x00,0x00,0x10,0x38,0x00,0x08,0x18,0x08,0x00,0x00,0x38,0x10,
    
35.                                                         0x00,0x10,0x18,0x10};
    
36. /****************************************************************************************/
    
37. uchar code number[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};        //数码管数形显示编码
    
38. uchar code weima[4]={0x01,0x02,0x04,0x08};                                                                        //位选信号编码，方便写循环使用
    
39. char shapewidth[19]={2,1,4,2,3,2,3,2,3,2,3,2,3,2,3,3,2,3,2};                                //各个图形的宽度属性，用于判断左移和右移的步格数上限
    
40. char shaperotate[19]={0,2,1,4,3,6,5,8,9,10,7,12,13,14,11,16,17,18,15};                //旋转图形时，用于改变图形的编号以实现图形的切换
    
41. uchar staticdata[20]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xff};                        //用于存储方块降落后固定显示的图形信息
    
42. uchar rate[5]={0,1,3,6,10};                                                                                                        //规定一次性消掉的行数的分数奖励机制
    
43. 
    
44. 
    
45. /****************************************全局变量声明************************************/
    
46. char y;                                        //方块位置属性：底部下落的高度，y=0时：刚刚出现，y=15时：下落到屏幕最底部
    
47. char shapenum;                        //方块形状属性：从0到18
    
48. int left;                                 //方块位置属性：方块偏离居中位置的格数，不同的方块left值的上限不同
    
49. int mark;                                //玩家分数变量
    
50. int speed;                                //方块下落速度变量
    
51. int initialspeed;                //方块下落的初始速度
    
52. int systemspeed;                //系统下落速度，此值会随着玩家分数的增加而减小，相应的下落速度会增大
    
53. int fastspeed;                        //当用户按下down键时，方块下落速度为此值
    
54. int k;                                        //一个全局循环变量，“帧数”变量
    
55. int startcontrol=1;                //开始画面状态指示变量，为1时说明程序进入开机欢迎界面
    
56. int suspendcontrol=0;        //游戏暂停与游戏继续画面状态指示变量，为1说明处在暂停界面，为0说明处在继续画面
    
57. int randnum;                        //随机数变量，用于产生随机方块
    
58. /****************************************************************************************/
    
59. 
    
60. 
    
61. /****************************************函数声明****************************************/
    
62. void delayms(int);                                //粗略延时函数
    
63. uchar move(uchar,int);                        //对二进制码实行移位，可为负值
    
64. void shapedisplay();                        //对点阵扫描一场，对数码管扫描一场，用于显示图形和数字
    
65. void keyscan();                                        //对所有键盘扫描一次，并执行相应运算和操作
    
66. uchar check(char,int);                        //用于检查方块将要下落的位置或是将要旋转的位置是否有障碍
    
67. uchar shapedisappear();                        //用于消行，返回一次性消掉的行数
    
68. numberdisplay(int amark);                //用于四位数字显示
    
69. void startimage();                                //游戏等待开始画面函数
    
70. void overimage();                                //游戏结束后的画面
    
71. void dataset();                                        //对数据初始化，为游戏重新开始做准备
    
72. /****************************************************************************************/
    
73. 
    
74. 
    
75. /*****************************************主函数*****************************************/
    
76. void main()
    
77. {
    
78.         char j;
    
79.         startimage();                                        //进入开机，函数内有键盘扫描，只有按下“开始”键会退出函数，否则不退出
    
80.         dataset();                                                //对数据进行初始化
    
81.         while(1){                                                //进入大循环
    
82.                 k=speed;                                        //确定显示的帧数
    
83.                 while(k--){
    
84.                         keyscan();                                //扫描键盘，放入高速循环语句中提高键盘的响应速度，并检测此时用户是否有相应请求
    
85.                         shapedisplay();                        //显示图形和数字
    
86.                 }
    
87.                 y++;                                                //图形下落一格
    
88.                 if(check(shapenum,left)){        //在没有显示之前判断将要下落的位置是否有障碍物，如果有障碍就进入到if语句中
    
89.                         if(y==1){                                //如果y=1；说明方块刚出现就遇到障碍物了，这时游戏需结束
    
90.                                 overimage();                //进入游戏结束画面，此函数内没有键盘扫描，运行一段时间会自动退出
    
91.                                 startimage();                //又进入开机画面
    
92.                                 dataset();                        //对数据进行初始化，将前一用户数据清零       
    
93.                         }
    
94.                         else{                                                                                                        //遇到障碍物，但还不至于图形不能出现
    
95.                                 y--;                                                                                                //y回到原值
    
96.                                 for(j=0;j<4;j++){                                                                        //将下落形状的值赋给固定图形，形成停留显示的效果
    
97.                                         staticdata[y+j]+=move(allshape[shapenum][j],left);
    
98.                                 }
    
99.                                 mark+=rate[shapedisappear()];                                                //消掉已拼满的函数，并记录所得分数
    
100.                                 y=0;                                                                                                //为下一个方块赋属性值：从第一行出现
     
101.                                 left=0;                                                                                                //为下一个方块赋属性值：居中显示
     
102.                                 randnum=rand()%19;shapenum=randnum;                                        //为下一个方块赋属性值：给定形状
     
103.                                 systemspeed=initialspeed-10*(mark/40);                                //计算相应分数下的系统速度值，分数越高，速度越快
     
104.                                 speed=systemspeed;                                                                        //将此值赋给速度控制量
     
105.                         }
     
106.                 }
     
107.         }
     
108. }
     
109. /****************************************************************************************/
     
110. 
     
111. 
     
112. /***************************************自定义函数***************************************/
     
113. void delayms(int xms)                          //粗略的延时函数
     
114. {       
     
115.         int i,j;
     
116.         for(i=xms;i>0;i--)
     
117.                 for(j=110;j>0;j--);
     
118. }
     
119. /****************************************************************************************/
     
120. uchar move(uchar aa,int anum)        //移位函数       
     
121. {                                                                
     
122.         if(anum>=0)
     
123.                 aa<<=anum;
     
124.         else
     
125.                 aa>>=(-anum);
     
126.         return aa;
     
127. }
     
128. /****************************************************************************************/
     
129. void shapedisplay()                                //显示函数
     
130. {
     
131.         uchar j;
     
132.         for(j=y<3?3-y:0;j<4;j++){        //显示动态方块               
     
133.                 slock=1;P1=j+y-3;P3=move(allshape[shapenum][j],left);
     
134.                 slock=0;delayms(1);P3=0x00;
     
135.         }
     
136.         for(j=0;j<16;j++){                        //显示静态方块
     
137.                 slock=1;P1=j;P3=staticdata[j+3];
     
138.                 slock=0;delayms(1);P3=0x00;
     
139.         }
     
140.         numberdisplay(mark);                //分数显示       
     
141. }
     
142. /****************************************************************************************/
     
143. numberdisplay(int amark)                //大数拆分并显示，带去无效零功能
     
144. {
     
145.         char i;
     
146.         uchar num[4];
     
147.         num[0]=amark/1000%10;num[1]=amark/100%10;num[2]=amark/10%10;num[3]=amark%10;
     
148.         if(amark<10){                                   //显示一位数
     
149.                 for(i=3;i<4;i++){
     
150.                         P0=0xff;
     
151.                         duan=1;
     
152.                         P0=number[num[i]];
     
153.                         duan=0;
     
154.                         P0=0x00;
     
155.                         wei=1;
     
156.                         P0=weima[i];
     
157.                         wei=0;
     
158.                         delayms(1);
     
159.                         wei=1;
     
160.                         P0=0x00;
     
161.                         wei=0;
     
162.                 }
     
163.         }
     
164.         else if(amark<100){                          //显示两位数
     
165.                 for(i=2;i<4;i++){
     
166.                         P0=0xff;
     
167.                         duan=1;
     
168.                         P0=number[num[i]];
     
169.                         duan=0;
     
170.                         P0=0x00;
     
171.                         wei=1;
     
172.                         P0=weima[i];
     
173.                         wei=0;
     
174.                         delayms(1);
     
175.                         wei=1;
     
176.                         P0=0x00;
     
177.                         wei=0;
     
178.                 }
     
179.         }
     
180.         else if(amark<1000){                  //显示三位数
     
181.                 for(i=1;i<4;i++){
     
182.                         P0=0xff;
     
183.                         duan=1;
     
184.                         P0=number[num[i]];
     
185.                         duan=0;
     
186.                         P0=0x00;
     
187.                         wei=1;
     
188.                         P0=weima[i];
     
189.                         wei=0;
     
190.                         delayms(1);
     
191.                         wei=1;
     
192.                         P0=0x00;
     
193.                         wei=0;
     
194.                 }
     
195.         }
     
196.         else{                                                //显示四位数
     
197.                 for(i=0;i<4;i++){
     
198.                         P0=0xff;
     
199.                         duan=1;
     
200.                         P0=number[num[i]];
     
201.                         duan=0;
     
202.                         P0=0x00;
     
203.                         wei=1;
     
204.                         P0=weima[i];
     
205.                         wei=0;
     
206.                         delayms(1);
     
207.                         wei=1;
     
208.                         P0=0x00;
     
209.                         wei=0;
     
210.                 }  
     
211.         }          
     
212.         return 0;
     
213. }
     
214. /****************************************************************************************/
     
215. void keyscan()                                         //键盘扫锚并执行用户输入的指令
     
216. {
     
217.         if(leftkey==0&&(left<(shapewidth[shapenum]<3?3:2))&&!check(shapenum,left+1)&&
     
218.            startcontrol==0&&suspendcontrol==0){
     
219.                 delayms(10);                        //按键无效条件：1.左移超边缘；2.左移遇障碍；3.处在欢迎界面；4.处在暂停界面
     
220.                 if(leftkey==0){       
     
221.                         left++;                                //按键命令：方块左移一位
     
222.                         speed=systemspeed;
     
223.                         while(!leftkey){                                                       
     
224.                                 shapedisplay();                               
     
225.                         }
     
226.                 }
     
227.         }
     
228.         if(rightkey==0&&(left>(shapewidth[shapenum]<3?shapewidth[shapenum]-5:shapewidth[shapenum]-6))&&
     
229.            !check(shapenum,left-1)&&startcontrol==0&&suspendcontrol==0){
     
230.                 delayms(10);                           //按键无效条件：1.右移超边缘；2.右移遇障碍；3.处在欢迎界面；4.处在暂停界面
     
231.                 if(rightkey==0){       
     
232.                         left--;                                //按键命令：方块右移一位
     
233.                         speed=systemspeed;
     
234.                         while(!rightkey){                       
     
235.                                 shapedisplay();       
     
236.                         }
     
237.                 }
     
238.         }
     
239.         if(upkey==0&&!check(shaperotate[shapenum],left)&&(left<(shapewidth[shaperotate[shapenum]]<3?4:3))
     
240.            &&(left>(shapewidth[shaperotate[shapenum]]<3?shapewidth[shaperotate[shapenum]]-6:shapewidth[shapenum]-7))
     
241.            &&startcontrol==0&&suspendcontrol==0){
     
242.                 delayms(10);                        //按键无效条件：1.翻转超左右边缘；2.翻转遇障碍；3.处在欢迎界面；4.进入暂停界面
     
243.                 if(upkey==0){       
     
244.                         shapenum=shaperotate[shapenum];        //按键命令：将翻转后的图形编号赋给要显示的图形编号
     
245.                         speed=systemspeed;
     
246.                         while(!upkey){                       
     
247.                                 shapedisplay();
     
248.                         }
     
249.                 }
     
250.         }
     
251.         if(downkey==0&&speed!=fastspeed&&startcontrol==0&&suspendcontrol==0){
     
252.                 delayms(10);                        //按键无效条件：1.已经进入快速下降状态；2.处在欢迎界面；3.进入暂停界面
     
253.                 if(downkey==0){       
     
254.                         speed=fastspeed;        //按键命令：将方块下落速度加快
     
255.                         k=speed;
     
256.                         while(!downkey){
     
257.                                 shapedisplay();
     
258.                         }
     
259.                 }
     
260.         }
     
261.         if(startsuspendkey==0&&startcontrol==1&&suspendcontrol==0){
     
262.                 delayms(10);                           //按键有效条件：1.处在开始欢迎界面；2.处在暂停界面
     
263.                 if(startsuspendkey==0){
     
264.                         startcontrol=0;                          
     
265.                         suspendcontrol=0;        //按键命令：使进入继续游戏状态
     
266.                         while(!startsuspendkey){
     
267.                         }
     
268.                 }       
     
269.         }
     
270.         if(startsuspendkey==0&&startcontrol==0&&suspendcontrol==0){
     
271.                 delayms(10);                         //按键无效条件：1.处在开始欢迎界面；2.处在暂停状态
     
272.                 if(startsuspendkey==0){
     
273.                         suspendcontrol=1;       
     
274.                         startcontrol=0;                //按键命令：状态切换，使进入暂停状态
     
275.                         while(!startsuspendkey){
     
276.                                 shapedisplay();       
     
277.                         }
     
278.                         while(suspendcontrol){
     
279.                                 shapedisplay();
     
280.                                 keyscan();                //等待结束暂停状态的命令
     
281.                         }                                                       
     
282.                 }
     
283.         }
     
284.         if(startsuspendkey==0&&startcontrol==0&&suspendcontrol==1){
     
285.                 delayms(10);                        //按键有效条件：处在暂停界面
     
286.                 if(startsuspendkey==0){       
     
287.                         suspendcontrol=0;
     
288.                         startcontrol=0;                //按键命令：状态切换，使进入继续游戏状态
     
289.                         while(!startsuspendkey){
     
290.                                 shapedisplay();
     
291.                         }                               
     
292.                 }
     
293.         }
     
294. }
     
295. /****************************************************************************************/
     
296. uchar check(char ashapenum,int aleft)        //判断方块是否会遇到障碍物
     
297. {
     
298.         char i=3,j=0;
     
299.         while(!j&&i>=0){
     
300.                 if((move(allshape[ashapenum][i],aleft)+staticdata[y+i])!=(move(allshape[ashapenum][i],aleft)|staticdata[y+i])){
     
301.                         j++;
     
302.                 }
     
303.                 i--;
     
304.         }
     
305.         return j;                                                           //返回0，说明没有障碍
     
306. }
     
307. /****************************************************************************************/
     
308. uchar shapedisappear()                                           //方块落定后消掉拼满的行，并使没有拼满的行整体下移填补空缺行
     
309. {
     
310.         char i,j,r=4;
     
311.         for(i=0;i<r;i++){
     
312.                 if(staticdata[y+3-i]==0xff){
     
313.                         for(j=y+3-i;j>0;j--){
     
314.                                 staticdata[j]=staticdata[j-1];
     
315.                         }
     
316.                         i--,r--;
     
317.                 }
     
318.         }
     
319.         return 4-r;                                                        //函数返回一次性消掉的行的数目
     
320. }
     
321. /****************************************************************************************/
     
322. void startimage()                                                  //开机欢迎画面，在没有按键作用的时候会不断执行
     
323. {
     
324.         uchar i,j;
     
325.         startcontrol=1;
     
326.         while(startcontrol){
     
327.                 for(i=10;i>0;i--){
     
328.                         for(j=0;j<16;j+=2){
     
329.                                 slock=1;P1=j;P3=0xaa;
     
330.                                 slock=0;delayms(1);P3=0x00;
     
331.                         }
     
332.                         for(j=1;j<16;j+=2){
     
333.                                 slock=1;P1=j;P3=0x55;
     
334.                                 slock=0;delayms(1);P3=0x00;
     
335.                         }
     
336.                         keyscan();                                           //随时响应用户输入
     
337.                 }               
     
338.                 for(i=10;i>0;i--){
     
339.                         for(j=1;j<16;j+=2){
     
340.                                 slock=1;P1=j;P3=0xaa;
     
341.                                 slock=0;delayms(1);P3=0x00;
     
342.                         }
     
343.                         for(j=0;j<16;j+=2){
     
344.                                 slock=1;P1=j;P3=0x55;
     
345.                                 slock=0;delayms(1);P3=0x00;
     
346.                         }
     
347.                         keyscan();                                        //随时响应用户输入       
     
348.                 }
     
349.         }
     
350. }
     
351. /****************************************************************************************/
     
352. void overimage()                                                  //游戏结束画面，分数会强制闪烁8次，并自动结束
     
353. {
     
354.         int i,j;
     
355.         for(j=0;j<8;j++){
     
356.                 for(i=0;i<200;i++){
     
357.                         numberdisplay(mark);       
     
358.                 }
     
359.                 delayms(500);
     
360.         }
     
361. }       
     
362. /****************************************************************************************/
     
363. void dataset()                                                           //数据全部清零，重新开始游戏
     
364. {
     
365.         char j;
     
366.         y=0;
     
367.         left=0;
     
368.         shapenum=0;
     
369.         initialspeed=100;
     
370.         speed=initialspeed;
     
371.         systemspeed=initialspeed;
     
372.         fastspeed=5;
     
373.         randnum=rand()%19;
     
374.         shapenum=randnum;
     
375.         mark=0;
     
376.         for(j=0;j<19;j++){                                          //清除点阵上的显示数据
     
377.                 staticdata[j]=0;
     
378.         }
     
379. }
     
380. /****************************************************************************************/

复制代码