设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机制作的GAMEBOX_Keil5_v1.1源码与原理图(射击，赛 ...
返回列表 发新帖
查看: 2438|回复: 1
收起左侧

单片机制作的GAMEBOX_Keil5_v1.1源码与原理图(射击，赛车，贪食蛇)

[复制链接]
ID:407334 发表于 2018-10-10 08:00 | 显示全部楼层 |阅读模式
单片机制作的gamebox，包含射击游戏，赛车游戏，贪食蛇等，有led显示，2个8*8点阵 电路原理图如下：
0.png

元件清单：
0.png

可以到./src/config.h文件自由配置引脚
0.png

0.png

单片机源程序如下（有详细的代码注释）:
  1. #include "config.h"

  3. #define ASPEED 28         //按加速键后的速度
  4. uint8 ucar=1;                //你的车，1靠右，2靠左

  6. static void keyscan()
  7. {
  8.         static bit r = 0;
  9.         int8 k = Get_Kvuale(30);
  10.         if(KEY_OK==0) {
  11.                 speeds = ASPEED;
  12.                 if(!sound_cnt_time | r) Sound_Tone(sound_ON,6,255);
  13.                 r=0;
  14.         }
  15.         else{        //随着分数的增加， 游戏速度逐渐加快
  16.                 speeds = 200 - scores/10;
  17.                 if(!sound_cnt_time | !r) Sound_Tone(sound_ON,1,255);
  18.                 r=1;
  19.         }
  20.         if(k==K_LEFT)        ucar=1;
  21.         if(k==K_RIGHT)        ucar=2;
  22. }
  23. void RAC_Game()
  24. {        
  25.         int8 xcar[4][2]={0};        //[2] 0:左/右/无;        1:车的Y轴位置
  26.         uint8 code carport[3][4]={{0,0,0,0},{0x50,0x20,0x70,0x20},{0x0a,0x04,0x0e,0x04}};
  27.         uint8 code track[5]={0x81,0x81,0x81,0x00,0x00};
  28.         uint8 carid=0,lastid=0,stp=0;
  29.         uint8 p,i;
  30.         Glife=1;
  31.         speeds = 200;
  32.         scores = 0;
  33.         for(i=0;i<4;i++){
  34.                 xcar[i][1]=i*5;//其它赛车之间间隔控制,重要部分!
  35.                 xcar[i][0]=0;
  36.         }        
  37.         /******************初始化完成,开始游戏***********************/
  38.         while(Glife){        
  39. //                分层扫描,将画面两边的赛道和赛车分为两次扫描，使跑道跟赛车产生画面对比度
  40. //                uint8 xtmp[16];
  41. //                for(p=0;p<16;p++)//刷新跑道
  42. //                        DispRAM[p]=track[(p+stp)%5];//动态跑道算法
  43. //                for(p=0;p<16;p++){
  44. //                        xtmp[p]=0x00;
  45. //                        for(i=0;i<4;i++)        //刷新其他赛车
  46. //                                if((0<=(p-xcar[i][1])) && (p-xcar[i][1])<4)        
  47. //                                        xtmp[p] = carport[xcar[i][0]][p-(xcar[i][1])];
  48. //                        if(p<4)
  49. //                                if(xtmp[p] & carport[ucar][p])//判断你的赛车是否与其它赛车碰撞
  50. //                                        Glife=0;
  51. //                                else
  52. //                                        xtmp[p] |= carport[ucar][p];
  53. //                }
  54.                
  55.                 //同步扫描
  56.                 for(p=0;p<16;p++)//刷新跑道
  57.                 {
  58.                         DispRAM[p]=0x00;
  59.                         DispRAM[p]=track[(p+stp)%5];//动态跑道算法
  60.                         
  61.                         for(i=0;i<4;i++)//刷新其他赛车
  62.                                 if((0<=(p-xcar[i][1])) && (p-xcar[i][1])<4)        
  63.                                         DispRAM[p] |= carport[xcar[i][0]][p-(xcar[i][1])];
  64.                         if(p<4)
  65.                         {
  66.                                 if(DispRAM[p] & carport[ucar][p])//判断你的赛车是否与其它赛车碰撞
  67.                                         Glife=0;
  68.                                 else        DispRAM[p] |= carport[ucar][p];
  69.                         }
  70.                 }
  71.                 if(tms > speeds)//游戏速度节拍
  72.                 {        
  73.                         stp++;
  74.                         if(stp==5) stp=0;//跑道动态算法标记位
  75.                         for(i=0;i<4;i++)
  76.                         {
  77.                                 xcar[i][1]--;        //其他车跟随跑道下移
  78.                                 if(xcar[i][1]== -4){
  79.                                         xcar[i][1]=15;
  80.                                         if(lastid>0)        //游戏规则,如果上次产生的不是空车位,则这一次产生一个空车位
  81.                                                 carid=0;
  82.                                         else
  83.                                                 carid=rand()%3;//随机产生一辆车
  84.                                         lastid = carid;
  85.                                         xcar[i][0]=carid;
  86.                                         scores ++;
  87.                                 }
  88.                         }        
  89.                         tms=0;
  90.                 }
  91.                 keyscan();
  92.                 MatxDisp(DispRAM,duty);
  93.                 SMG_Display(scores,duty);
  94.         }
  95.         TR2_OFF;
  96. }
复制代码

  1. /*
  2.         2014-1-26 00:00:00        :完成贪吃蛇游戏模型
  3.         2014-3-8 23:27:05        :增加游戏会随着吃的食物的增加而加快游戏速度
  4.         2014-3-15 20:06:15        :进行实体硬件测剩，运行良好，但贪吃蛇结构设置太耗RAM，将进行优化。
  5. */
  6. #include "config.h"

  8. #define NORSPEED 360
  9. #define ASPEED 100
  10. #define WIDTH  8        //游戏屏幕宽度
  11. #define LENGTH 16        //游戏屏幕长度

  13. static struct Food
  14. {
  15.     uint8 x;//食物的横坐标
  16.     uint8 y;//食物的纵坐标
  17. }food;

  19. struct Snake snake;

  21. enum direc{up, down, left, right};//蛇的运动方向

  23. static void Snake_Init();                //初始化游戏
  24. static void Snake_Disp();        //游戏显示
  25. static void Snake_Run();                //蛇向前走一步
  26. static void Create_Food();                //随机生成食物

  28. static void Create_Food()
  29. {
  30.         uint8 i;
  31.         food.x = rand() % WIDTH;        //范围1-16;
  32.         food.y = rand() % LENGTH;        //获得随机数种子;//用计数器作为随机数发生器
  33.         for(i=1;i<(snake.node);i++)//检测产生的食物是否与蛇本身重叠
  34.         {
  35.                 if((food.x==snake.x[i])&&(food.y==snake.y[i]))
  36.                         Create_Food();        //重叠则重新成生
  37.         }
  38. }

  40. static void Snake_Init()
  41. {        
  42.         uint8 c;        
  43.         for(c=0;c < MAX_SNAKE;c++)//清除内存数据
  44.         {
  45.                 snake.x[c]=-1;
  46.                 snake.y[c]=-1;
  47.         }
  48.         snake.life = 1;                                //赋予蛇生命
  49.         snake.node = 3;                        //默认长度3节
  50.         snake.direc = up;//初始方向
  51.         snake.x[0]=4;
  52.         snake.y[0]=5;
  53.         snake.x[1]=4;
  54.         snake.y[1]=4;
  55.         snake.x[2]=4;
  56.         snake.y[2]=3;
  57.         speeds = NORSPEED;         //游戏速度
  58.         tms = 0;
  59.         scores = 0;
  60.         Create_Food();                //生成第一个食物
  61. }

  63. static void Snake_Run()        //蛇爬行算法
  64. {        
  65.         uint8 i;
  66.         for(i=(snake.node-1);i>0;i--)                //蛇头作为前进引导，长江后浪推前浪
  67.         {
  68.                 snake.y[i]=snake.y[i-1];
  69.                 snake.x[i]=snake.x[i-1];
  70.         }
  71.         switch (snake.direc)        //根据蛇的方向标前进
  72.         {
  73.                 case up:         snake.y[0]+=1;        break;
  74.                 case down:        snake.y[0]-=1;        break;
  75.                 case left:        snake.x[0]-=1;        break;
  76.                 case right:        snake.x[0]+=1;        break;
  77.         }
  78. }

  80. static void Snake_Disp()        //游戏画面显示
  81. {
  82.         uint8 p = 16;
  83. //        for(p=0;p<snake.node;p++)//绘制蛇图像
  84. //        {               
  85. //                delayus(500-duty);
  86. //                DisPoint(snake.x[p],snake.y[p]);
  87. //                delayus(duty/5);
  88. //                cdata = 0xff;
  89. //        }
  90. //        DisPoint(food.x,food.y);//绘制食物图像
  91. //        delayus(duty);
  92. //        cdata = 0xff;
  93. //        
  94. //        for(i=0;i<16;i++)
  95. //        {
  96. //                DispRAM[i] = 0;
  97. //        }
  98.         while(p--) DispRAM[p]=0;        //清除缓存        
  99.         for(p=0;p<snake.node;p++)        //写入新缓存
  100.         {        
  101.                 DispRAM[snake.y[p]] |= 0x80 >> (snake.x[p]);
  102.         }
  103. //        DispRAM[food.y] |= 0x80 >> (food.x);
  104.         
  105.         MatxDisp(DispRAM,duty);
  106.         DisPoint(7-food.x,food.y);
  107.         delayus(duty);
  108. }

  110. void Snake_Game()        //游戏过程
  111. {
  112.         Snake_Init();                //初始化游戏
  113.         Play_Music(sound_canon);
  114.         while(snake.life)        //有生命，便可玩
  115.         {
  116.                 uint8 i;
  117.                 switch(keypad)//直接读取键值，贪吃蛇不需要消抖
  118.                 {
  119.                         case K_UP:        if((snake.direc==left)||(snake.direc==right))        snake.direc=up;
  120.                                 //按下UP键时，只有蛇在水平方向时才能改变
  121.                                 break;
  122.                         case K_DOWN:if((snake.direc==left)||(snake.direc==right))        snake.direc=down;
  123.                                 //按下DOWN键时，只有蛇在水平方向时才能改变
  124.                                 break;
  125.                         case K_LEFT:if((snake.direc==up)||(snake.direc==down))                snake.direc=left;
  126.                                 //按下left键时，只有蛇在垂直方向时才能改变
  127.                                 break;
  128.                         case K_RIGHT:if((snake.direc==up)||(snake.direc==down))                snake.direc=right;
  129.                                 //按下right键时，只有蛇在垂直方向时才能改变
  130.                                 break;
  131.                         default :
  132.                                 break;
  133.                 }
  134.                
  135.                 if(KEY_OK==0) speeds = ASPEED;//加速键
  136.                 else speeds = NORSPEED;
  137.                 keypad = K_NULL;
  138.                
  139.                 if(tms > speeds)        //半秒前进一格
  140.                 {
  141.                         tms=0;
  142.                         Snake_Run();        //无聊散步
  143.                 }
  144.                 if((snake.x[0]==food.x) && (snake.y[0]==food.y))//是否吃到食物
  145.                 {
  146.                         Sound_Tone(sound_ON,4,5);
  147. //                        getfood=1;//直接在此增加蛇长度会在下一个显示扫描产生一个原有数据留影，故通过加长
  148.                         snake.node++;
  149. //                        game_speed-=10;        //每吃一个食物增加10点速度
  150.                         Create_Food();        //产生新食物
  151.                 }
  152.                 if((snake.x[0]>WIDTH-1)||(snake.x[0]<0)||(snake.y[0]>LENGTH-1)||(snake.y[0]<0))//是否碰壁
  153.                 {
  154.                         snake.life=0;        //蛇碰到墙壁死亡
  155.                 }
  156.                 for(i=3;i<snake.node;i++)//从蛇的第四节开始判断是否撞到自己了，因为蛇头不可能撞到二三四节
  157.                 {
  158.                         if((snake.x[i]==snake.x[0])&&(snake.y[i]==snake.y[0]))//是否自残
  159.                                 snake.life=0;        //蛇头碰到自身死亡
  160.                 }
  161.                 Snake_Disp();        //显示游戏图像
  162.                 scores = snake.node-3;
  163.                 SMG_Display(scores,duty);
  164.         }
  165.         scores = snake.node-3;
  166.         TR2_OFF;
  167. }
复制代码
  1. /*
  2. //作者：郑梓滨        Jaupin@126.com
  3. //日期：2014年10月27日14:04:35   
  4. //功能：复古掌上俄罗斯方块游戏机源代码，包括游戏GUI，俄罗斯方块、贪吃蛇、经典赛车游戏、射击障碍物游戏
  5. v1.0:
  6.         2014-7-26 00:00:00        :完成有俄罗斯方块游戏基本模型;
  7.         2014-7-28 02:12:03        :将原先临时使用的延时键盘扫描改为外部中断状态位检测键;
  8.         2014-7-28 20:40:37        :完成俄罗斯方块分数计数及分数显示功能;
  9.         2014-8-1 01:01:54        :将较早之前完成贪吃蛇游戏代码合并植入;
  10.         2014-8-2 17:04:25        :整理之前的临时源码,使工程文件规范化;
  11.         2014-8-3 23:50:49        :构建游戏选择画面基本模型,完成画面平移效果;
  12.         2014-8-5 00:50:04        :改进LED点阵底层驱动,用软件PWM调节画面亮度;
  13.         2014-8-7 00:53:35        :完成赛车游戏,用PWM分层扫描画面,形成游戏画面对比度;
  14.         2014-8-8 02:16:44        :完成赛车游戏选择预览画面,并将三个游戏合并在一起;
  15.         2014-8-12 01:47:07        :将逐行扫描改为逐点扫描,使显示亮度均匀;增加亮度调节功能;
  16.         2014-9-9 00:32:40        :修改及优化若干细节；
  17. v1.1:
  18.         2014-9-18 0:57:23        :重新布局电路，修改原先不合理的地方，为制作PCB板作准备；
  19.         2014-9-19 22:02:36        :加入游戏音效，并且可以通过软件方式开关声音；
  20.         2014-9-21 14:59:39        :增加三位mini数码管，实时显示游戏分数，数码管共用点阵并行数据口；
  21.         ~~~~~~~~~~~忘记备注
  22.         2014-10-20 21:30:15        :加入射击游戏,将GUI模块化，简化流程
  23. */

  25. #include "config.h"
  26. volatile uint8 data keypad = K_NULL;        //键盘状态
  27. volatile uint8 data keycont = 0;                //键盘检测消抖定时器
  28. volatile uint16 data tms = 0;                        //1ms T0定时器
  29. bit key_state = 0;                                                //按键状态

  31. uint16 data speeds = 0;                //游戏速度
  32. uint16 data scores = 0;                //游戏计分
  33. bit Glife = 1;                                //游戏生命
  34. bit sound_ON = 1;                        //音效开关
  35. uint8 data duty = 80;                //PWM，默认亮度
  36. uint8 data DispRAM[16]={0};
  37. uint8 code bitman[8]={1,2,4,8,16,32,64,128};//用于数字序号定位0~7bit位

  39. uint8 code num[10][5]=                //阳码
  40. {
  41.         {0x7,0x5,0x5,0x5,0x7},
  42.         {0x2,0x6,0x2,0x2,0x7},
  43.         {0x7,0x1,0x7,0x4,0x7},
  44.         {0x7,0x1,0x7,0x1,0x7},
  45.         {0x5,0x5,0x7,0x1,0x1},
  46.         {0x7,0x4,0x7,0x1,0x7},
  47.         {0x7,0x4,0x7,0x5,0x7},
  48.         {0x7,0x1,0x1,0x1,0x1},
  49.         {0x7,0x5,0x7,0x5,0x7},
  50.         {0x7,0x5,0x7,0x1,0x7}
  51. };

  53. /*********************PORT_INIT********************/
  54. void Port_Init()
  55. {
  56.         P0M0 = 0Xff;
  57.         P0M1 = 0X00;
  58.         P1M0 = 0Xff;
  59.         P1M1 = 0X00;
  60.         P2M0 = 0Xff;
  61.         P2M1 = 0X00;
  62.         P3M0 = 0X00;
  63.         P3M1 = 0X00;
  64.         P4M0 = 0Xff;
  65.         P4M1 = 0X00;
  66.         P5M0 = 0Xff;
  67.         P5M1 = 0X00;
  68. }

  70. void Init_Timer()
  71. {
  72. /******************定时器0中断设置**********************/
  73.         AUXR |= 0x80;                   //定时器0为1T模式
  74.     TMOD = 0x00;                    //设置定时器为模式0(16位自动重装载)
  75.     TL0 = T1MS;                     //初始化计时值
  76.     TH0 = T1MS >> 8;
  77.     TR0 = 1;                        //定时器0开始计时
  78.     ET0 = 1;                        //使能定时器0中断
  79.         
  80. /*****************外部中断设置*************************/        
  81.         IT0 = 1;                    //设置INT0下降沿触发
  82.     EX0 = 1;                    //使能外部中断INT0
  83.         IT1 = 1;                    //设置INT1下降沿触发
  84.     EX1 = 1;                    //使能外部中断INT1
  85.         INT_CLKO |= 0x70;           //使能INT2,INT3,INT4(EX4 = 1,EX3 = 1,EX2 = 1
  86.         
  87.         EA = 1;        
  88. }

  90. void Array_CLR(uint8 *p)
  91. {
  92.         uint8 i=0;
  93.         while(i!=16)
  94.         {
  95.                 p[i] = 0x00;
  96.                 i++;
  97.         }
  98. }

  100. void ShowScore(uint score)
  101. {
  102.         uint8 i;
  103.         uint8 qx,bx,sx,gx;
  104.         qx = score /1000;
  105.         bx = score %1000 /100;
  106.         sx = score %100/10;
  107.         gx = score %10;

  109.         Array_CLR(DispRAM);

  111.         for(i=0;i<5;i++)
  112.                 DispRAM[8-i] = (num[sx][i]<<4) | (num[gx][i]);
  113.         
  114.         for(i=0;i<5;i++)
  115.                 DispRAM[14-i] = (num[qx][i]<<5) | (num[bx][i]<<1);
  116.                                 
  117. //        MatxDisp(DispRAM,duty);
  118. }

  120. void main()
  121. {
  122.         Port_Init();
  123.         Sound_Init();
  124.         Init_Timer();
  125.         Sound_Tone(1,14,5);//滴
  126.         
  127.         srand(TL0);               
  128.         delayms(100);
  129.         Play_Music(sound_game_start);
  130.         Flash_Screen_Clear();
  131.         while(1)
  132.         {
  133.                 tms = 0;
  134.                 keypad = K_NULL;//清除按键状态
  135.                 switch (GUI_Main())        //进入用户游戏选择界面，返回选择的游戏
  136.                 {
  137.                         case 1:        Tetris_Game();        break;
  138.                         case 2:        Snake_Game();        break;
  139.                         case 3:        RAC_Game();                break;
  140.                         case 4:        Shot_Game();        break;
  141.                 }
  142.                 Play_Music(sound_game_over);
  143.                 Flash_Screen_Clear();
  144.                 ShowScore(scores);        //将分数载入显存
  145.                 delayms(300);
  146.                
  147.                 keypad = K_NULL;
  148.                 while(keypad != K_UP)        //在没按下OK键时保持分数显示
  149.                 {
  150.                         MatxDisp(DispRAM,duty);
  151.                         SMG_Display(scores,duty);
  152.                 }
  153.         }        
  154. }

  156. /* Timer0 interrupt routine */
  157. void T0_Timer_1ms_int() interrupt 1 using 1
  158. {
  159.         if(tms<0xfffe)        tms++;        //防止溢出
  160.         if(key_state){ if(!--keycont) key_state=0;}

  162.         if(PIN_TR2)//TR2如果打开，则开始播放音效
  163.         {
  164.                 if(!sound_cnt_time--)
  165.                 {
  166.                         TR2_OFF;
  167.                         beep = 1;
  168.                         if(music_p[s_p][1])
  169.                         {
  170.                                 Sound_Tone(sound_ON,music_p[s_p][0],music_p[s_p][1]);
  171.                                 s_p++; //自动装载下一个音符，实现音效与游戏“同时”运行
  172.                         }
  173.                 }
  174.         }
  175.         if(KEY_DOWN==0 & KEY_UP==0)        IAP_CONTR=0x60;//软件复位下载程序
  176. }

  178. void T2_Timer_Sound_freq() interrupt 12           //中断入口
  179. {
  180.      beep = ~beep; //蜂鸣器频率震动
  181. }

  183. uint8 Get_Kvuale(uint8 key_delay)//键值消抖处理，参数为灵敏度调节
  184. {
  185.         uint8 kvuale = K_NULL;        //返回的初始值为空值
  186.         if(keypad != K_NULL)        //当键值不为NULL时,说明有按键按下
  187.         {        
  188.                 if(!key_state)                //当按键状态位state为0时说明是第一次触发有效,为1时为重复触发
  189.                 {
  190.                         key_state=1;        //置1，防止重复触发
  191.                         kvuale = keypad;//获得读取键值
  192.                         keycont = key_delay;//载入消抖时间
  193.                 }
  194.                 keypad = K_NULL;        //清楚键值
  195.         }
  196.         return kvuale;
  197. }
  198. /*********外部中断按键区**********/
  199. void exint0() interrupt 0       //INT0
  200. {
  201.         keypad = 0;
  202. }
  203. void exint1() interrupt 2       //INT1
  204. {
  205.         keypad = 1;        
  206. }
  207. void exint2() interrupt 10      //INT2
  208. {
  209.         keypad = 2;
  210. }
  211. ……………………

  213. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


所有资料51hei提供下载:
GAMEBOX_CODE_Keil5_v1.1.zip (291.3 KB, 下载次数: 19)
回复

使用道具 举报

ID:577675 发表于 2019-7-4 10:46 | 显示全部楼层
啊啊啊啊啊，好纠结啊，学校要求做一个这个
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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