欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 原創51單片機俄羅斯方塊程序 12864屏顯示 代碼有詳細注釋 [打印本頁]

---

作者: 51hei學習技術中    時間: 2017-3-6 03:46
標題: 原創51單片機俄羅斯方塊程序 12864屏顯示 代碼有詳細注釋
給51黑電子論壇的朋友們分享一個很優秀的俄羅斯方塊程序，lcd12864屏幕 是用普通的51單片機做的，P3.4口，短按就可以開始運行了。效果如下圖所示：

完整的源碼下載：
俄羅斯方塊全部源碼.zip (147.88 KB, 下載次數: 599)

2017-3-6 03:43 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

Tetris.c源程序文件內容：

1. /*******************************************************
   
2. * 文件名稱：Tetris.c
   
3. * 單 片 機：STC89C52RC
   
4. * 簡    述：使用LCD12864顯示的俄羅斯方塊程序
   
5. * 功    能：計分，下一個方塊預覽，歡迎結束界面，長按連續左右移，暫停（按鍵Left+Turn）
   
6. * 作    者：劉琦
   
7. * 完成日期：4月21日
   
8. * IO口設定：按鍵
   
9.                         sbit key_sr_left=P3^7;
   
10.                         sbit key_sr_turn=P3^6;
    
11.                         sbit key_sr_right=P3^5;
    
12.                         sbit key_sr_down=P3^4;
    
13.                         LCD12864
    
14.                         sbit RS_Port=P1^0;
    
15.                         sbit RW_Port=P1^1;
    
16.                         sbit E_Port=P2^5;
    
17.                         sbit PSB_Port=P1^2;
    
18.                         sbit RST_Port=P1^4;
    
19.                         數碼管鎖存器
    
20.                         sbit dula=P2^6;
    
21.                         sbit wela=P2^7;
    
22. 
    
23. *******************************************************/
    
24. 
    
25. /*****************************頭文件區*****************************************************/
    
26. #include<reg52.h>
    
27. //#include"STC15F2K60S2.h"
    
28. #include"task_key.h"
    
29. #include"task_activation.h"
    
30. #include"12864b.h"
    
31. #include"TaskBlock.h"
    
32. #include"Block.h"
    
33. /*****************************宏定義區*****************************************************/
    
34. 
    
35. //需要判斷是否刷新的任務總數
    
36. //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
    
37. #define NUM_TASK_FLAG 7
    
38. //需要定時刷新的任務總數
    
39. //1TaskGoingDown,2KeyService
    
40. #define NUM_TASK_REFRESH 3
    
41. //刷新頻率
    
42. #define TIME_PER_SEC 200                                                        //每次進入中斷的頻率，200Hz
    
43. #define TIME_CLOCK 11059200                                                        //晶振頻率
    
44. #define TIME_KEY_SERVICE_50HZ  TIME_PER_SEC/50          //按鍵服務頻率，0.02s
    
45. #define TIME_TASKGOINGDOWN_2HZ  TIME_PER_SEC/2          //下落頻率，0.5s
    
46. 
    
47. /******************************子函數聲明區***********************************************/
    
48. 
    
49. void initial_myself(void);   
    
50. void initial_peripheral(void);
    
51. void delay100ms(void);        
    
52. 
    
53. /******************************全局變量定義區***********************************************/
    
54. unsigned char uc_state=1;//狀態標示:1歡迎界面，2等待開始界面，3下落界面，4死亡界面，5暫停界面
    
55. enum Block{S1,S2,Z1,Z2,L1,L2,L3,L4,J1,J2,J3,J4,I1,I2,O1,T_1,T_2,T_3,T_4}enumBlock;//方塊編號
    
56. unsigned char ucBlockNow=0;//當前方塊
    
57. unsigned char ucBlockNext=0;//下一個方塊
    
58. 
    
59. unsigned char ucFlagScreenChange=1;//界面變更標志，界面更改時置1，激活task_activation
    
60. 
    
61. unsigned char ucCoordinate[2];//方塊的旋轉點坐標，橫H，豎S
    
62. unsigned char xdata ucxMap[10][20];//整張屏幕的標記地圖，用來記錄未消除方塊位置，有方塊則為1
    
63. unsigned char ucxBlockPosition[4][2];//方塊的4個小方塊坐標,[0][0],[0][1]為旋轉點坐標H,S
    
64. 
    
65. unsigned int uc_delay_task_cnt[NUM_TASK_REFRESH];//任務刷新延遲
    
66. unsigned char uc_flag_taskrefresh[NUM_TASK_FLAG];//任務刷新標志
    
67. 
    
68. unsigned long int ucScore=0;//得分
    
69. 
    
70. /******************************主函數開始***********************************************/
    
71. void main(void)
    
72. {
    
73.         unsigned char i=0;
    
74.         initial_myself();
    
75.         delay100ms();   
    
76.     initial_peripheral();
    
77. 
    
78. 
    
79.         while(1)
    
80.         {
    
81.                 if(ucFlagScreenChange==1)//界面變更標志為1時，進行任務激活，防止一直刷新界面
    
82.                 {
    
83.                         task_activation(uc_state);
    
84.                         ucFlagScreenChange=0;
    
85.                 }
    
86.                 if(uc_delay_task_cnt[2]==0)//20HZ頻率刷新key_service
    
87.                 {
    
88.                         task_key_service();
    
89.                         ET0=0;//在中斷中也有可能變化的變量在更改前時先關閉中斷
    
90.                         uc_delay_task_cnt[2]=TIME_KEY_SERVICE_50HZ;//延遲重置
    
91.                         ET0=1;
    
92.                 }
    
93.                 if(uc_flag_taskrefresh[5]&&uc_delay_task_cnt[1]==0)//需要時,2HZ頻率刷新TaskGoingDown
    
94.                 {
    
95.                         if(!TaskGoingDown())//下落失敗
    
96.                         {
    
97.                                 //將當前方塊位置寫入Map
    
98.                                 for(i=0;i<4;i++)
    
99.                                 {
    
100.                                         ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]=1;
     
101.                                 }
     
102.                                 //調用消除方塊函數
     
103.                                 TaskClear();
     
104.                         }
     
105.                         ET0=0;//在中斷中也有可能變化的變量在更改前時先關閉中斷
     
106.                         uc_delay_task_cnt[1]=TIME_TASKGOINGDOWN_2HZ;//延遲重置
     
107.                         ET0=1;
     
108.                 }
     
109. 
     
110.         }
     
111. }
     
112. 
     
113. //中斷函數
     
114. void timer0(void) interrupt 1
     
115. {
     
116.         unsigned char i;
     
117.         TR0=0;
     
118.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
     
119.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
     
120.         //task_delay[]減到0時，相應的函數準備就緒
     
121.         for(i=0;i<NUM_TASK_REFRESH;i++)
     
122.         {
     
123.                 if(uc_delay_task_cnt[i]!=0)//延遲不為0時才減
     
124.                         {uc_delay_task_cnt[i]--;};
     
125.         }
     
126.         task_key_scan();//按鍵掃描函數，放在中斷中，保證準時掃描
     
127.         TR0=1;
     
128. }
     
129. 
     
130. //初始化區
     
131. void initial_myself(void)//第一區 初始化單片機
     
132. {
     
133.         unsigned char i;
     
134.         for(i=0;i<NUM_TASK_REFRESH;i++)uc_delay_task_cnt[i]=0;//初始化讓所有任務就緒
     
135.         TMOD=0X21; //定時器0為16位不自動重裝，用來定時；定時器1為8位自動重裝，用來產生隨機數
     
136.         TH0=255-TIME_CLOCK/TIME_PER_SEC/12/256;
     
137.         TL0=255-TIME_CLOCK/TIME_PER_SEC/12%256;
     
138.         TH1=0;
     
139.         TL1=0;
     
140. }
     
141. 
     
142. void initial_peripheral(void) //第二區 初始化外圍
     
143. {
     
144.         Lcd_Init();//初始化12864
     
145.         EA=1;     //開總中斷
     
146.         ET0=1;    //允許定時器0中斷，定時器1無需開啟中斷
     
147.     TR0=1;    //啟動定時器0
     
148.     TR1=1;         //啟動定時器1
     
149. }
     
150. 
     
151. void delay100ms(void)                //@11.0592MHz
     
152. {
     
153.         unsigned char i, j, k;
     
154. 
     
155.         ;
     
156.         ;
     
157.         i = 5;
     
158.         j = 52;
     
159.         k = 195;
     
160.         do
     
161.         {
     
162.                 do
     
163.                 {
     
164.                         while (--k);
     
165.                 } while (--j);
     
166.         } while (--i);
     
167. }
     

復制代碼

1. /*******************************************************
   
2. * 文件名稱：task_activation.c
   
3. * 單 片 機：STC89C52RC
   
4. * 簡    述：任務激活子程序，uc_state:1歡迎界面，2等待界面，3下落界面，4死亡界面
   
5. * 作    者：劉琦
   
6. * 完成日期：2015年5月1日
   
7. *******************************************************/
   
8. #include"reg52.h"
   
9. #include"12864b.h"
   
10. #include"tetris.h"
    
11. #include"TaskBlock.h"
    
12. #include"Score.h"
    
13. //#include"STC15F2K60S2.h"
    
14. 
    
15. #define  xchar unsigned char code
    
16. 
    
17. //歡迎詞
    
18. xchar CorpInf[]=
    
19. {
    
20.         "來玩俄羅斯方塊！"
    
21. };
    
22. //死亡詞
    
23. xchar CorpInf1[]=
    
24. {
    
25.         "不好意思你死了！"
    
26. };
    
27. 
    
28. void task_activation(unsigned char state)        
    
29. {
    
30.         unsigned char i=0,j=0;
    
31.         switch(state)
    
32.         {
    
33.                 case 1: //歡迎界面
    
34.                                 DisGBStr(CorpInf);                                //寫入歡迎詞
    
35.                         //當前界面需要刷新的任務
    
36.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
    
37.                                 uc_flag_taskrefresh[1]=0;               
    
38.                             uc_flag_taskrefresh[2]=0;
    
39.                             uc_flag_taskrefresh[3]=0;
    
40.                             uc_flag_taskrefresh[4]=1;
    
41.                             uc_flag_taskrefresh[5]=0;
    
42.                             uc_flag_taskrefresh[6]=0;
    
43.                             break;
    
44.                 case 2:        //等待界面
    
45.                                 //清空所有顯示
    
46.                                 Cram_Off();                //清空文本顯示
    
47.                                 Clr_GDRAM();        //清空繪圖顯示
    
48.                                 //畫出邊框
    
49.                                 DrawLineY(7,1,62,1);
    
50.                                 DrawLineX(7,127,1,1);
    
51.                                 DrawLineX(7,127,62,1);
    
52. 
    
53.                                 //將地圖數據清空
    
54.                                 for(i=0;i<10;i++)
    
55.                                 {
    
56.                                         for(j=0;j<20;j++)
    
57.                                         {
    
58.                                                 ucxMap[i][j]=0;
    
59.                                         }
    
60.                                 }
    
61. 
    
62.                                 ucScore=0;//計分清0
    
63. 
    
64.                         //當前界面需要刷新的任務
    
65.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
    
66.                         uc_flag_taskrefresh[1]=0;
    
67.                             uc_flag_taskrefresh[2]=0;
    
68.                             uc_flag_taskrefresh[3]=0;
    
69.                             uc_flag_taskrefresh[4]=1;
    
70.                             uc_flag_taskrefresh[5]=0;
    
71.                             uc_flag_taskrefresh[6]=0;
    
72.                             break;
    
73.                 case 3:        //下落界面
    
74.                                 TaskScore ();                //寫分，刷新最開始的0000000
    
75.                                 TaskComingNew();        //出新方塊
    
76.                         //當前界面需要刷新的任務
    
77.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
    
78.                                 uc_flag_taskrefresh[1]=1;
    
79.                             uc_flag_taskrefresh[2]=1;
    
80.                             uc_flag_taskrefresh[3]=1;
    
81.                             uc_flag_taskrefresh[4]=1;
    
82.                             uc_flag_taskrefresh[5]=1;
    
83.                             uc_flag_taskrefresh[6]=1;
    
84.                             break;
    
85.                 case 4:        //死亡界面
    
86.                                 Cram_Off();                //清空文本顯示
    
87.                                 Clr_GDRAM();        //清空繪圖顯示
    
88.                                 DisGBStr(CorpInf1);
    
89.                         //當前界面需要刷新的任務
    
90.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
    
91.                         uc_flag_taskrefresh[1]=0;
    
92.                             uc_flag_taskrefresh[2]=0;
    
93.                             uc_flag_taskrefresh[3]=0;
    
94.                             uc_flag_taskrefresh[4]=1;
    
95.                             uc_flag_taskrefresh[5]=0;
    
96.                             uc_flag_taskrefresh[6]=0;
    
97.                             break;
    
98.                 case 5:        //暫停界面
    
99.                         //當前界面需要刷新的任務
    
100.                                 //1KeyLeft,2KeyTurn,3KeyRight,4KeyDown,5TaskGoingDown,6KeyPause
     
101.                         uc_flag_taskrefresh[1]=0;
     
102.                             uc_flag_taskrefresh[2]=0;
     
103.                             uc_flag_taskrefresh[3]=0;
     
104.                             uc_flag_taskrefresh[4]=1;
     
105.                             uc_flag_taskrefresh[5]=0;
     
106.                             uc_flag_taskrefresh[6]=0;
     
107.                             break;
     
108.                 default:
     
109.                             break;
     
110.         }
     
111. }
     

復制代碼

1. #include"reg52.h"
   
2. //#include"STC15F2K60S2.h"
   
3. #include"tetris.h"
   
4. #include"Block.h"
   
5. #include"TaskBlock.h"
   
6. 
   
7. #define CONST_KEY_TIME 10    //按鍵去抖動延時的時間
   
8. 
   
9. //#define const_time_0_25s  111   //0.25秒鐘的時間需要的定時中斷次數
   
10. //#define const_time_0_5s     222   //0.5秒鐘的時間需要的定時中斷次數
    
11. 
    
12. #define const_time_0_25s  60   //0.125秒鐘的時間需要的定時中斷次數
    
13. #define const_time_0_5s     60   //0.125秒鐘的時間需要的定時中斷次數
    
14. 
    
15. 
    
16. sbit key_sr_left=P3^7;
    
17. sbit key_sr_turn=P3^6;
    
18. sbit key_sr_right=P3^5;
    
19. sbit key_sr_down=P3^4;
    
20. 
    
21. unsigned char ucKeySec=0;   //被觸發的按鍵編號
    
22. 
    
23. unsigned int  uiKeyTimeCnt_left=0; //按鍵去抖動延時計數器
    
24. unsigned int  uiKeyCtntyCnt_left=0; //按鍵連續觸發的間隔延時計數器
    
25. unsigned char ucKeyLock_left=0; //按鍵觸發后自鎖的變量標志
    
26. 
    
27. unsigned int  uiKeyTimeCnt_turn=0; //按鍵去抖動延時計數器
    
28. //unsigned int  uiKeyCtntyCnt_turn=0; //按鍵連續觸發的間隔延時計數器
    
29. unsigned char ucKeyLock_turn=0; //按鍵觸發后自鎖的變量標志
    
30. 
    
31. unsigned int  uiKeyTimeCnt_right=0; //按鍵去抖動延時計數器
    
32. unsigned int  uiKeyCtntyCnt_right=0; //按鍵連續觸發的間隔延時計數器
    
33. unsigned char ucKeyLock_right=0; //按鍵觸發后自鎖的變量標志
    
34. 
    
35. unsigned int  uiKeyTimeCnt_down=0; //按鍵去抖動延時計數器
    
36. unsigned char ucKeyLock_down=0; //按鍵觸發后自鎖的變量標志
    
37. 
    
38. unsigned int  uiKeyTimeCnt_pause=0; //按鍵去抖動延時計數器
    
39. unsigned char ucKeyLock_pause=0; //按鍵觸發后自鎖的變量標志
    
40. 
    
41. //放在中斷中，其中的每個按鍵的標志位為1時才刷新
    
42. void task_key_scan(void)
    
43. {
    
44.         if(uc_flag_taskrefresh[1])
    
45.         {
    
46.                 if(key_sr_left==1)//left
    
47.                   {
    
48.                      ucKeyLock_left=0;
    
49.                      uiKeyTimeCnt_left=0;
    
50.                          uiKeyCtntyCnt_left=0;   
    
51.                  }
    
52.             else if(ucKeyLock_left==0)
    
53.                  {
    
54.                      uiKeyTimeCnt_left++;
    
55.                      if(uiKeyTimeCnt_left>CONST_KEY_TIME)
    
56.                      {
    
57.                         uiKeyTimeCnt_left=0;
    
58.                         ucKeyLock_left=1;  
    
59.                         ucKeySec=1;    //觸發1號鍵,left
    
60.                      }
    
61.             }
    
62.                 else if(uiKeyTimeCnt_left<const_time_0_5s)
    
63.                 {
    
64.                          uiKeyTimeCnt_left++;
    
65.                 }
    
66.                 else
    
67.                 {
    
68.                          uiKeyCtntyCnt_left++;
    
69.                          if(uiKeyCtntyCnt_left>const_time_0_25s)
    
70.                          {
    
71.                                  uiKeyCtntyCnt_left=0;
    
72.                                 ucKeySec=1;    //觸發1號鍵,left
    
73.                          }
    
74.                 }
    
75.         }
    
76. 
    
77.         if(uc_flag_taskrefresh[2])
    
78.         {
    
79.                 if(key_sr_turn==1)//turn
    
80.                   {
    
81.                      ucKeyLock_turn=0;
    
82.                      uiKeyTimeCnt_turn=0;
    
83. //                         uiKeyCtntyCnt_turn=0;   
    
84.                  }
    
85.             else if(ucKeyLock_turn==0)
    
86.                  {
    
87.                      uiKeyTimeCnt_turn++;
    
88.                      if(uiKeyTimeCnt_turn>CONST_KEY_TIME)
    
89.                      {
    
90.                         uiKeyTimeCnt_turn=0;
    
91.                         ucKeyLock_turn=1;  
    
92.                         ucKeySec=2;    //觸發2號鍵,turn
    
93.                      }
    
94.             }
    
95.         }
    
96. 
    
97.         if(uc_flag_taskrefresh[3])
    
98.         {
    
99.                 if(key_sr_right==1)//right
    
100.                   {
     
101.                      ucKeyLock_right=0;
     
102.                      uiKeyTimeCnt_right=0;
     
103.                          uiKeyCtntyCnt_right=0;   
     
104.                  }
     
105.             else if(ucKeyLock_right==0)
     
106.                  {
     
107.                      uiKeyTimeCnt_right++;
     
108.                      if(uiKeyTimeCnt_right>CONST_KEY_TIME)
     
109.                      {
     
110.                         uiKeyTimeCnt_right=0;
     
111.                         ucKeyLock_right=1;  
     
112.                         ucKeySec=3;    //觸發3號鍵,right
     
113.                      }
     
114.             }
     
115.                 else if(uiKeyTimeCnt_right<const_time_0_5s)
     
116.                 {
     
117.                          uiKeyTimeCnt_right++;
     
118.                 }
     
119.                 else
     
120.                 {
     
121.                          uiKeyCtntyCnt_right++;
     
122.                          if(uiKeyCtntyCnt_right>const_time_0_25s)
     
123.                          {
     
124.                                  uiKeyCtntyCnt_right=0;
     
125.                                 ucKeySec=3;    //觸發3號鍵,right
     
126.                          }
     
127.                 }
     
128.         }
     
129. 
     
130.         if(uc_flag_taskrefresh[4])
     
131.         {
     
132.                 if(key_sr_down==1)//down
     
133.                   {
     
134.                      ucKeyLock_down=0; //按鍵自鎖標志清零
     
135.                      uiKeyTimeCnt_down=0;//按鍵去抖動延時計數器清零   
     
136.                  }
     
137.             else if(ucKeyLock_down==0)//有按鍵按下，且是第一次被按下，并且當前界面支持這個按鍵
     
138.                  {
     
139.                      uiKeyTimeCnt_down++; //累加定時中斷次數
     
140.                           if(uiKeyTimeCnt_down>CONST_KEY_TIME)
     
141.                      {
     
142.                         uiKeyTimeCnt_down=0;
     
143.                         ucKeyLock_down=1;  //自鎖按鍵置位,避免一直觸發
     
144.                         ucKeySec=4;    //觸發4號鍵,down
     
145.                      }
     
146.             }
     
147.         }
     
148. 
     
149.         if(uc_flag_taskrefresh[6])
     
150.         {                        
     
151.           if(key_sr_left==1||key_sr_turn==1)//pause，按鍵左和按鍵旋轉未同時按下
     
152.           {
     
153.                  ucKeyLock_pause=0; //按鍵自鎖標志清零
     
154.                  uiKeyTimeCnt_pause=0;//按鍵去抖動延時計數器清零      
     
155.           }
     
156.                 else if(ucKeyLock_pause==0)//有按鍵按下，且是第一次被按下
     
157.                 {
     
158.                     uiKeyTimeCnt_pause++; //累加定時中斷次數
     
159.                     if(uiKeyTimeCnt_pause>CONST_KEY_TIME)
     
160.                     {
     
161.                             uiKeyTimeCnt_pause=0;
     
162.                         ucKeyLock_pause=1;  //自鎖按鍵置位,避免一直觸發
     
163.                     ucKeySec=6;    //觸發6號鍵，暫停
     
164.                     }
     
165.                 }
     
166.         }
     
167. }
     
168. 
     
169. //按鍵服務函數
     
170. void task_key_service(void)
     
171. {
     
172.         unsigned char ucCheck=0;
     
173.         unsigned char ucOldEnum=0;
     
174.         unsigned char ucNewEnum=0;
     
175.         unsigned char i=0;
     
176.         switch(ucKeySec) //按鍵服務狀態切換
     
177.           {
     
178.             case 1:// 1號鍵,left
     
179.                                 ucCoordinate[0]++;                                //旋轉點坐標H+1
     
180.                                 WriteBlockCoordinate();                        //寫入其他3個方塊坐標
     
181.                                 ucCheck=TaskCheck();                        //檢測碰撞
     
182.                                 if(ucCheck)                                                //未碰撞，則左移
     
183.                                 {
     
184.                                         ucCoordinate[0]--;
     
185.                                         ChangeBlock(0);
     
186.                                         ucCoordinate[0]++;
     
187.                                         ChangeBlock(1);
     
188.                                 }
     
189.                                 else                                                    //碰撞，不變
     
190.                                 {
     
191.                                         ucCoordinate[0]--;
     
192.                                         WriteBlockCoordinate();
     
193.                                 }
     
194.             break;
     
195.                 case 2:// 2號鍵,turn
     
196.                                 ucOldEnum=enumBlock;
     
197.                                 switch(enumBlock)                                //旋轉后改變方塊編號
     
198.                                 {
     
199.                                         case S1:
     
200.                                                         enumBlock=S2;
     
201.                                         break;
     
202.                                         case S2:
     
203.                                                         enumBlock=S1;
     
204.                                         break;
     
205.                                         case Z1:
     
206.                                                         enumBlock=Z2;
     
207.                                         break;
     
208.                                         case Z2:
     
209.                                                         enumBlock=Z1;
     
210.                                         break;
     
211.                                         case L1:
     
212.                                                         enumBlock=L2;
     
213.                                         break;
     
214.                                         case L2:
     
215.                                                         enumBlock=L3;
     
216.                                         break;
     
217.                                         case L3:
     
218.                                                         enumBlock=L4;
     
219.                                         break;
     
220.                                         case L4:
     
221.                                                         enumBlock=L1;
     
222.                                         break;
     
223.                                         case J1:
     
224.                                                         enumBlock=J2;
     
225.                                         break;
     
226.                                         case J2:
     
227.                                                         enumBlock=J3;
     
228.                                         break;
     
229.                                         case J3:
     
230.                                                         enumBlock=J4;
     
231.                                         break;
     
232.                                         case J4:
     
233.                                                         enumBlock=J1;
     
234.                                         break;
     
235.                                         case I1:
     
236.                                                         enumBlock=I2;
     
237.                                         break;
     
238.                                         case I2:
     
239.                                                         enumBlock=I1;
     
240.                                         break;
     
241.                                         case O1:
     
242.                                                         enumBlock=O1;
     
243.                                         break;
     
244.                                         case T_1:
     
245.                                                         enumBlock=T_2;
     
246.                                         break;
     
247.                                         case T_2:
     
248.                                                         enumBlock=T_3;
     
249.                                         break;
     
250.                                         case T_3:
     
251.                                                         enumBlock=T_4;
     
252.                                         break;
     
253.                                         case T_4:
     
254.                                                         enumBlock=T_1;
     
255.                                         break;
     
256.                                         default:
     
257.                                         break;
     
258.                                 }
     
259.                                 WriteBlockCoordinate();
     
260.                                 ucCheck=TaskCheck();
     
261.                                 if(ucCheck)
     
262.                                 {
     
263.                                         ucNewEnum=enumBlock;
     
264.                                         enumBlock=ucOldEnum;
     
265.                                         ChangeBlock(0);
     
266.                                         enumBlock=ucNewEnum;
     
267.                                         ChangeBlock(1);
     
268.                                 }
     
269.                                 else
     
270.                                 {
     
271.                                         enumBlock=ucOldEnum;
     
272.                                         WriteBlockCoordinate();
     
273.                                 }
     
274. 
     
275.             break;
     
276.             case 3:// 3號鍵,right
     
277.                                 ucCoordinate[0]--;
     
278.                                 WriteBlockCoordinate();
     
279.                                 ucCheck=TaskCheck();
     
280.                                 if(ucCheck)
     
281.                                 {
     
282.                                         ucCoordinate[0]++;
     
283.                                         ChangeBlock(0);
     
284.                                         ucCoordinate[0]--;
     
285.                                         ChangeBlock(1);
     
286.                                 }
     
287.                                 else
     
288.                                 {
     
289.                                         ucCoordinate[0]++;
     
290.                                         WriteBlockCoordinate();
     
291.                                 }
     
292. 
     
293.             break;
     
294.                 case 4:// 4號鍵,down
     
295.                                 //根據所處界面不同，按鍵down的功能不同
     
296.                                 switch(uc_state)
     
297.                                 {
     
298.                                         case 1:
     
299.                                                         ucBlockNow=TL1%7;                //準備進入等待界面，就先產生當前隨機方塊
     
300.                                                         uc_state=2;                                 //進入等待界面
     
301.                                                         ucFlagScreenChange=1;        //激活界面變更
     
302.                                         break;
     
303.                                         case 2:
     
304.                                                         uc_state=3;                                //進入下落界面
     
305.                                                         ucFlagScreenChange=1;
     
306.                                         break;
     
307.                                         case 3:        //在下落界面下，down為直接下落到底
     
308.                                                         ET0=0;//關閉計時器0，出新后開啟，防止直接下落
     
309.                                                         ChangeBlock(0);                 //先清除當前的圖形
     
310.                                                         do                                                //循環模擬下落并檢測，直到失敗
     
311.                                                         {
     
312.                                                                 ucCoordinate[1]++;
     
313.                                                                 WriteBlockCoordinate();
     
314.                                                                 ucCheck=TaskCheck();
     
315.                                                         }
     
316.                                                         while(ucCheck);
     
317.                                                         ucCoordinate[1]--;                //恢復到最后一次成功的坐標
     
318.                                                         WriteBlockCoordinate();
     
319.                                                         ChangeBlock(1);                        //畫方塊
     
320. 
     
321.                                                         //立即寫入，并消除，防止到底后還可以移動
     
322.                                                         //寫入Map
     
323.                                                         for(i=0;i<4;i++)
     
324.                                                         {
     
325.                                                                 ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]=1;
     
326.                                                         }
     
327.                                                         //調用消除
     
328.                                                         TaskClear();
     
329.                                                         //刷新下落延遲，防止出新后，直接下落
     
330.                                                         ET0=1;
     
331.                                         break;
     
332.                                         case 4:        //死亡界面
     
333.                                                         ucBlockNow=TL1%7;                //準備進入等待界面，就先產生當前隨機方塊
     
334.                                                         uc_state=2;                                 //進入等待界面
     
335.                                                         ucFlagScreenChange=1;
     
336.                                         break;
     
337.                                         case 5:        //暫停界面
     
338.                                                         uc_state=3;                                //進入下落界面
     
339.                                                         //開啟下落界面時的相關任務
     
340.                                                         uc_flag_taskrefresh[1]=1;
     
341.                                                     uc_flag_taskrefresh[2]=1;
     
342.                                                     uc_flag_taskrefresh[3]=1;
     
343.                                                     uc_flag_taskrefresh[4]=1;
     
344.                                                     uc_flag_taskrefresh[5]=1;
     
345.                                                     uc_flag_taskrefresh[6]=1;
     
346.                                         break;
     
347.                                 }
     
348.             break;
     
349.                 case 6:// 6號鍵,pause
     
350.                                 uc_state=5;
     
351.                                 ucFlagScreenChange=1;
     
352.                 break;
     
353.                 default:
     
354.                 break;                 
     
355.           }
     
356.         ucKeySec=0;
     
357. }
     

復制代碼

1. /*******************************************************
   
2. * 文件名稱：TaskBlock.c
   
3. * 單 片 機：STC89C52RC
   
4. * 簡    述：方塊子程序，包含，下落，出新，消除，檢測
   
5. * 作    者：劉琦
   
6. * 完成日期：2015年4月21日
   
7. *******************************************************/
   
8. #include<reg52.h>
   
9. #include"Tetris.h"
   
10. #include"Block.h"
    
11. #include"tetris.h"
    
12. #include"Score.h"
    
13. /*******************************************************
    
14. * 函 數 名:TaskCheck(void)
    
15. * 功能描述:檢測
    
16. * 函數說明:檢測左右移，下落，出新，旋轉
    
17. * 輸入參數:無
    
18. * 返 回 值:成功失敗標示，ucReturn
    
19. *******************************************************/
    
20. unsigned char TaskCheck(void)
    
21. {
    
22.         unsigned char ucReturn=0;
    
23.         unsigned char i=0;
    
24.         //加入檢測部分,包括邊界檢測，碰撞檢測
    
25.         //邊界檢測
    
26.         for(i=0;i<4;i++)
    
27.         {
    
28.                 if(ucxBlockPosition[i][0]>=0&&ucxBlockPosition[i][0]<=9                        //檢測左右
    
29.                    &&ucxBlockPosition[i][1]>=0&&ucxBlockPosition[i][1]<=19)                //檢測上下
    
30.                 {
    
31.                         ucReturn=1;
    
32.                 }
    
33.                 else
    
34.                 {
    
35.                         ucReturn=0;
    
36.                         return ucReturn;//如果邊界檢測失敗，就不進行下面檢測，直接返回失敗
    
37.                 }
    
38.         }
    
39.         //碰撞檢測
    
40.         for(i=0;i<4;i++)
    
41.         {
    
42.                 if(ucxMap[ ucxBlockPosition[i][0] ][ ucxBlockPosition[i][1] ]!=0)//與地圖標記位置進行比較
    
43.                 {
    
44.                         ucReturn=0;
    
45.                         return ucReturn;
    
46.                 }
    
47.         }
    
48.         return ucReturn;
    
49. }
    
50. /*******************************************************
    
51. * 函 數 名:unsigned char TaskGoingDown(void)
    
52. * 功能描述:方塊下落
    
53. * 函數說明:
    
54. * 輸入參數:無
    
55. * 返 回 值:ucResult，1無碰撞，0碰撞
    
56. *******************************************************/
    
57. unsigned char TaskGoingDown(void)
    
58. {
    
59.         unsigned char ucCheck=0;
    
60.         unsigned char ucResult=0;
    
61.         ucCoordinate[1]++;                                //旋轉點坐標，豎S+1
    
62.         WriteBlockCoordinate();                        //將其他三個小方塊坐標寫入數組
    
63.         ucCheck=TaskCheck();                        //檢測碰撞
    
64.         if(ucCheck)                                                //無碰撞
    
65.         {
    
66.                 ucCoordinate[1]--;                        //坐標復位
    
67.                 ChangeBlock(0);                                //在老位置消除方塊，只刷新有改變的位置，加快顯示速度
    
68.                 ucCoordinate[1]++;                        //坐標+1
    
69.                 ChangeBlock(1);                                //在新位置畫方塊
    
70.                 ucResult=1;
    
71.         }
    
72.         else                                                        //有碰撞，則不變
    
73.         {
    
74.                 ucCoordinate[1]--;                        
    
75.                 WriteBlockCoordinate();
    
76.                 ucResult=0;
    
77.         }
    
78.         return ucResult;
    
79. }
    
80. /*******************************************************
    
81. * 函 數 名:unsigned char TaskComingNew(void)
    
82. * 功能描述:方塊出新
    
83. * 函數說明:
    
84. * 輸入參數:無
    
85. * 返 回 值:ucResult，1成功，0失敗
    
86. *******************************************************/
    
87. unsigned char TaskComingNew(void)
    
88. {
    
89.         unsigned char ucCheck=0;
    
90.         unsigned char ucResult=0;
    
91.         //寫入當前方塊的相關信息
    
92.         switch(ucBlockNow)                                         
    
93.         {
    
94.                 case 0:
    
95.                                 enumBlock=S1;
    
96.                                 ucCoordinate[0]=4;
    
97.                                 ucCoordinate[1]=0;
    
98.                 break;
    
99.                 case 1:
    
100.                                 enumBlock=Z1;
     
101.                                 ucCoordinate[0]=4;
     
102.                                 ucCoordinate[1]=0;
     
103.                 break;
     
104.                 case 2:
     
105.                                 enumBlock=L1;
     
106.                                 ucCoordinate[0]=4;
     
107.                                 ucCoordinate[1]=1;
     
108.                 break;
     
109.                 case 3:
     
110.                                 enumBlock=J1;
     
111.                                 ucCoordinate[0]=4;
     
112.                                 ucCoordinate[1]=1;
     
113.                 break;
     
114.                 case 4:
     
115.                                 enumBlock=I1;
     
116.                                 ucCoordinate[0]=5;
     
117.                                 ucCoordinate[1]=0;
     
118.                 break;
     
119.                 case 5:
     
120.                                 enumBlock=O1;
     
121.                                 ucCoordinate[0]=5;
     
122.                                 ucCoordinate[1]=0;
     
123.                 break;
     
124.                 case 6:
     
125.                                 enumBlock=T_1;
     
126.                                 ucCoordinate[0]=4;
     
127.                                 ucCoordinate[1]=0;
     
128.                 break;
     
129.                 default:
     
130.                 break;
     
131.         }
     
132.         //檢測碰撞
     
133.         WriteBlockCoordinate();        
     
134.         ucCheck=TaskCheck();
     
135.         if(ucCheck)                                                //成功
     
136.         {
     
137.                 ChangeSmallBlock(0);                //將預覽的方塊清除
     
138.                 ucBlockNext=TL1%7;                        //產生隨機數，作為預覽方塊
     
139.                 ChangeBlock(1);                         //畫新的方塊
     
140.                 ChangeSmallBlock(1);                //畫新的預覽方塊
     
141.                 ucBlockNow=ucBlockNext;
     
142.                 ucResult=1;
     
143.         }
     
144.         else
     
145.         {
     
146.                 ucResult=0;
     
147.         }
     
148. 
     
149.         return ucResult;
     
150. }
     
151. /*******************************************************
     
152. * 函 數 名:void TaskClear(void)
     
153. * 功能描述:消除滿行
     
154. * 函數說明:消除滿行，并出新
     
155. * 輸入參數:無
     
156. * 返 回 值:無
     
157. *******************************************************/
     
158. void TaskClear(void)
     
159. {
     
160.         char i=0,j=0,n=0;
     
161.         unsigned char m=0;
     
162.         unsigned char k=0;
     
163.         unsigned char flag_man=1,flag_kong=1,flag_clear=0;//滿行、空行、待清除標志
     
164.         unsigned char man[4],count=0;                                          //滿行位置數組，滿行數量
     
165.         unsigned char kong=20;                                                          //空行位置
     
166.         unsigned char oldkong=20;                                                  //用來儲存舊的空行位置
     
167. 
     
168.         unsigned char ucResult=0;
     
169. 
     
170.         //標記出來滿行及第一個空行
     
171.         for(i=19;i>=0;i--)
     
172.         {
     
173.                 for(j=9;j>=0;j--)
     
174.                 {
     
175.                         if(ucxMap[j][i]==0)
     
176.                         {
     
177.                                 flag_man=0;
     
178.                         }
     
179.                         else
     
180.                         {
     
181.                                 flag_kong=0;
     
182.                         }
     
183.                 }
     
184.                 if(flag_man==1)
     
185.                 {
     
186.                         flag_clear=1;//激活消除標記
     
187.                         man[k]=i;//標記滿行
     
188.                         count++;
     
189.                         k++;
     
190.                 }
     
191.                 else if(flag_kong==1)
     
192.                 {
     
193.                          kong=i;
     
194.                         break;//檢測到第一個空行，就退出循環
     
195.                 }
     
196.                 flag_man=1;//將滿行標志復位
     
197.                 flag_kong=1;
     
198.         }
     
199. 
     
200.         //計分
     
201.         switch(count)
     
202.         {
     
203.                 case 0:
     
204.                                 ucScore=ucScore+100;
     
205.                                 break;
     
206.                 case 1:
     
207.                                 ucScore=ucScore+200;
     
208.                                 break;
     
209.                 case 2:
     
210.                                 ucScore=ucScore+400;
     
211.                                 break;
     
212.                 case 3:
     
213.                                 ucScore=ucScore+700;
     
214.                                 break;
     
215.                 case 4:
     
216.                                 ucScore=ucScore+1100;
     
217.                                 break;
     
218.                 default:
     
219.                                 break;
     
220.         }
     
221. 
     
222.         oldkong=kong;
     
223.         //消除滿行
     
224.         if(flag_clear==1)
     
225.         {
     
226.                 while(count!=0)//至少有一個滿行，才進行消除
     
227.                 {
     
228.                         //逐行下移
     
229.                         for(m=0;m<man[count-1]-kong-1;m++)
     
230.                         {
     
231.                                 for(n=9;n>=0;n--)
     
232.                                 {
     
233.                                         ucxMap[n][man[count-1]-m]=ucxMap[n][man[count-1]-m-1];        
     
234.                                 }
     
235.                         }
     
236.                         //最上行清空
     
237.                         for(n=0;n<10;n++)
     
238.                         {
     
239.                                 ucxMap[n][kong+1]=0;        
     
240.                         }
     
241. 
     
242.                         kong++;
     
243.                         count--;
     
244.                 }
     
245.                 ChangeMap(oldkong-1,man[0]); //寫入當前Map，只寫有改變的行，加快顯示速度
     
246.         }
     
247. 
     
248.         //將分數寫入屏幕
     
249.         TaskScore();
     
250.         //出新的方塊
     
251.         ucResult=TaskComingNew();
     
252.         //如果失敗，就進入失敗界面
     
253.         if(ucResult==0)
     
254.         {
     
255.                 uc_state=4;
     
256.                 ucFlagScreenChange=1;
     
257.         }
     
258. }

復制代碼

---

作者: zqy181818    時間: 2017-3-17 19:41
太厲害了

---

作者: bayga456    時間: 2017-3-18 09:45
這個要支持。正打算用匯編寫這個

---

作者: 還是看不穿    時間: 2017-5-4 10:18
謝謝分享!!!!1

---

作者: 1197338529    時間: 2017-5-15 15:51
這個io口怎么改？能不能詳細說下

---

作者: 越快樂越墮落    時間: 2017-6-28 19:01
編譯過不了，

---

作者: 越快樂越墮落    時間: 2017-6-30 16:28
花屏有點嚴重啊 為什么圖里的很清楚？？怎么解決

---

作者: 15576118519    時間: 2017-7-2 22:04

越快樂越墮落 發表于 2017-6-30 16:28
花屏有點嚴重啊 為什么圖里的很清楚？？怎么解決

圖里用的晶振是11兆的，如果你用的晶振是12兆的就要修改延時，否則可能會花屏。

---

作者: 772740573    時間: 2017-7-31 14:06
積分不夠

---

作者: Lanny_1    時間: 2017-8-1 08:34
學習學習

---

作者: gaohan130    時間: 2017-11-23 19:36
鎖存器用的什么型號的呢？

---

作者: 孤狼131    時間: 2017-12-26 19:35
我用清翔的開發板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

---

作者: Jerry0925    時間: 2017-12-28 16:17

孤狼131 發表于 2017-12-26 19:35
我用清翔的開發板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

控制數碼管的段選與位選鎖存器的

---

作者: 孤狼131    時間: 2017-12-28 23:17

Jerry0925 發表于 2017-12-28 16:17
控制數碼管的段選與位選鎖存器的

那你知道這個鎖存器是哪個型號的嗎

---

作者: dexter    時間: 2018-1-5 00:33
按照接線連好單片機，為什么進入界面后無法運行，只有一個邊框。本人剛接觸單片機，還有很多不懂

---

作者: jxdianqi    時間: 2018-1-7 21:34
樓主很強大，下載學習下算法，謝謝分享

---

作者: 攸央    時間: 2018-1-8 09:28
學習學習

---

作者: 孤獨求敗    時間: 2018-1-15 21:13
坐等超級瑪麗

---

作者: wafush    時間: 2018-3-6 22:57
高手啊  不錯！！

---

作者: 13lxw    時間: 2018-4-12 08:20
感謝樓主的無私奉獻，給了我很大的啟發

---

作者: mlpl    時間: 2018-5-2 22:39
感謝分享代碼，經測試能夠運行，但是移植到串行12864模塊上很難，單片機RAM太小，無法緩存所有屏幕點陣，而并口LCD則可以直接讀取屏幕內容。

---

作者: plaodj    時間: 2018-5-2 23:29
給個元器件電路圖咯  謝謝

---

作者: 山狼    時間: 2018-11-29 14:22
好帖收藏一波

---

作者: wangbo    時間: 2018-11-29 19:41
這是好資料

---

作者: 是迷麓麓Yai    時間: 2018-12-13 20:31
厲害厲害，支持一波

---

作者: qzyhlf    時間: 2019-1-25 14:31
太厲害了

---

作者: kadnn    時間: 2019-2-22 11:00
樓主有沒有更詳細的資料啊，要買啥，焊哪里

---

作者: 蹦蹦跳跳    時間: 2019-2-23 01:33
mark!mark!mark!mark!

---

作者: wyh_3069    時間: 2019-4-10 16:24
DB0-DB7是P0口嗎，那要上啦電阻輸出嗎

---

作者: linlexiao    時間: 2019-5-12 00:27

孤狼131 發表于 2017-12-26 19:35
我用清翔的開發板，其他引腳都改好了，但是dula=P2^6和wela=P2^7是什么東西的引腳

我用的也是清翔的開發板，想請問你這個子程序到底怎么弄啊。我萌新，這個復制過去編譯都過不了

---

作者: 一只大狐貍    時間: 2019-5-14 22:42
萌新求一下資料 么有幣。。

---

作者: 啊啊啊單片機    時間: 2019-11-2 23:07
哇！！！這個才是硬核！！！！

---

作者: luozhao    時間: 2019-11-26 09:29
大佬大佬，來學習學習

---

作者: LazyRise    時間: 2019-12-28 10:40

linlexiao 發表于 2019-5-12 00:27
我用的也是清翔的開發板，想請問你這個子程序到底怎么弄啊。我萌新，這個復制過去編譯都過不了

所以到底怎么搞啊

---

作者: 盛世游龍    時間: 2020-1-6 19:54
謝謝樓主分享！

---

作者: Swagger8    時間: 2020-1-24 19:30
感謝分享！！！

---

作者: 老河口    時間: 2020-2-4 21:25
感謝分享了，困家里沒事做，D一個

---

作者: abcd5690    時間: 2020-2-5 18:23
謝謝樓主分享，這個算是大型程序了，值得我學習啊。

---

作者: cdong58    時間: 2020-2-10 21:44
謝謝分享，樓主太厲害了

---

作者: 青箜    時間: 2020-8-24 09:31
感謝樓主的分享，稍后自己也試試看

---

歡迎光臨 (http://www.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影