51单片机项目实战---贪吃蛇（测试版）

来源：http://blog.chinaunix.net/uid-29270124-id-4949163.html

点击左下角“阅读原文”直接进入

一、元器件

1、AT89C51
    关于51单片机就不在啰嗦了，相信大家都已经很熟悉了，关于它的一些常用细节，已经在另一篇博文中提到

    http://blog.chinaunix.net/uid-29270124-id-4571661.html

2、8x8点阵
    点阵里面就是一些二极管啦，通过纵横交叉连接，横8竖8，每个交叉点都接一个二极管。这里给大家找到一个点阵的实物图
    
    我想大家看到这个图就应该知道如何去点亮一个点阵了。假如要点亮最左上角那个，那么9号引脚拉高，13号引脚拉低，这样既可。

二、原理图

三、项目分析

1、首先定义一个结构体
    struct snake{
        unsigned char x[20];
        unsigned char y[20];
        unsigned char length;
        unsigned char direction;
    }snk;
    数组x，y分别存放每一个点的横纵坐标，length为蛇的长度，direction为蛇前进的方向

2、坐标系：点阵的左下角为点（0,0），横纵坐标都是正向增长，P2控制横坐标；P0控制纵坐标。通过坐标可以找到点阵中点的位置，然后将其点亮
    假设现在有第2个点的坐标x[2] = 1, y[2] = 2,那么点亮这个点的方式为
    P2 = 0x04; //0000 0100
    P0 = 0xfb; //1111 1011

3、按键产生外部中断，在中断里判断按下那个方向get_direction()，并且同时设置坐标set_location()

4、定时器每隔1s就应该更新位置，因为蛇要不停的前进。定时器不需要更新方向，因为方向只有按键才会改动，定时器用前一步的方向

5、关于点的位置更新方式
    1)、向上移动
        后面的点去覆盖前面的点，第一个点用新坐标表示x[0]不变，y[0]+1
    2)、向下移动
        后面的点去覆盖前面的点，第一个点用新坐标表示x[0]不变，y[0]-1
    3)、向左移动
        后面的点去覆盖前面的点，第一个点用新坐标表示x[0]-1，y[0]不变
    4)、向右移动
        后面的点去覆盖前面的点，第一个点用新坐标表示x[0]+1，y[0]不变

6、关于边界问题：
    1)、任何一个点的横坐标  0 <= x[i] < 8
    2)、任何一个点的纵坐标  0 <= y[i] < 8
    3)、第一个点在移动的时候不能和其他点重复，否则就自己追尾了

7、关于原理图按键的设计
    贪吃蛇要求系统能迅速响应按键，因此轮询的方式并不可取，只有靠外部中断。然而51只有2个外部中断，我们起码需要4个方向键，这样就不能一个按键配一个外部中断，通过使用4输入与门，将所有按键状态集合在一起，然后送给外部中断0。我们将4个按键都接在与门，只要有一个按下，那么与门的输出就会产生一个下降沿，从而产生外部中断。

四、源代码
main.c

1. #include "snake.h"
   

2. 
   

3. int error = 0;
   

4. int time=0;
   

5. 
   

6. void interrupt_init()
   

7. {
   

8.     EA = 0;             //关闭总中断
   

9.     IT0 = 1;        //外部中断0方式 下降沿
   

10.     EA = 1;         //开启总中断
    

11.     EX0 = 1;        //开启外部中断
    

12. }
    

13. 
    

14. void timer_init()
    

15. {
    

16.     EA = 0;                //关总中断
    

17.     ET0 = 1;            //开定时器0中断
    

18.     TMOD = 0x02;        //定时器0工作方式2
    

19.     TL0 = 6;            //定时250us
    

20.     TH0 = 6;
    

21.     EA = 1;             //开总中断
    

22.     TR0 = 1;         //开始定时
    

23. }
    

24. int main()
    

25. {
    

26. //    unsigned char tempx, tempy;
    

27. //    unsigned char i,j;
    

28. 
    

29.     interrupt_init();
    

30.     timer_init();
    

31.     snk_init();
    

32. 
    

33.     while(1)
    

34.     {    
    

35.         //如果位置错了就重新初始化蛇
    

36.         if(error)
    

37.             snk_init();
    

38.         //点亮点阵
    

39.         matrix();    
    

40.     }
    

41. }
    

42. 
    

43. void inter0() interrupt 0
    

44. {    
    

45.     //按键产生外部中断，获取新的方向
    

46.     get_direction();
    

47.     //设置新的位置
    

48.     error = set_location();    
    

49. //    matrix();
    

50. }
    

51. void timer0() interrupt 1
    

52. {    
    

53.     time++;
    

54.     //定时器为250us 积累4000次就是1s
    

55.     if(time == 4000)
    

56.     {
    

57.         //每隔1s都需要重新设置位置，让蛇前进
    

58.         error = set_location();    
    

59.         time = 0;
    

60.     }
    

61. }

snake.c

点击(此处)折叠或打开

1. #include "snake.h"
   

2. 
   

3. //蛇的结构体，x为横坐标，y为纵坐标，length为蛇的长度，direction为蛇的前进方向
   

4. struct snake{
   

5.     unsigned char x[20];
   

6.     unsigned char y[20];
   

7.     unsigned char length;
   

8.     unsigned char direction;
   

9. }snk;
   

10. 
    

11. void matrix()
    

12. {
    

13.     unsigned char i;
    

14.     int count=500;
    

15.     //关闭所有的点
    

16.     P2 = 0x00;
    

17.     P0 = 0xff;
    

18. 
    

19.     //根据蛇每一个点的坐标，将对应的点阵点亮
    

20.     for(i=0; i<snk.length; i++)
    

21.     {
    

22.         P2 = 1<<snk.x[i];
    

23.         P0 = ~(1<<snk.y[i]);
    

24.     }
    

25. }
    

26. 
    

27. void snk_init()
    

28. {
    

29.     //初始化坐标，总共4个点（3,0） （2,0）    （1,0）     （1,0）
    

30.     snk.x[0] = 3;
    

31.     snk.y[0] = 0;
    

32.     snk.x[1] = 2;
    

33.     snk.y[1] = 0;
    

34.     snk.x[2] = 1;
    

35.     snk.y[2] = 0;
    

36.     snk.x[3] = 0;
    

37.     snk.y[3] = 0;
    

38. 
    

39.     //初始长度4
    

40.     snk.length = 4;
    

41.     //初始移动方向 向右
    

42.     snk.direction = RIGHT;
    

43.     //点亮点阵
    

44.     matrix();
    

45. }
    

46. 
    

47. 
    

48. 
    

49. void get_direction()
    

50. {
    

    单片机的品种很多，设计时怎样表示操作码和操作数，都有各自的规定，指令代码也各不相同，因此，必须对所选单片机的全部指令，也就是所谓“指令系统”，有足够的了解。各个系列的单片机虽然有不同的指令系统，但也有其共同性。掌握一种单片机的指令系统，对其它系列单片机可以起到触类旁通的作用。MCS－51单片机应用广泛，派生品种多，具有代表性，所以，这里以MCS－51系列的指令系统为例说明“指令”的组成和应用。

51.     //通过按键的状态获取方向
    

52.     if(!up)
    

53.         snk.direction = UP;
    

54. 
    

55.     if(!down)
    

56.         snk.direction = DOWN;
    

57.             
    

58.     if(!left)
    

59.         snk.direction = LEFT;
    

60.         
    

61.     if(!right)
    

62.         snk.direction = RIGHT;
    

63. }
    

64. 
    

65. int set_location()
    

66. {
    

67.     unsigned char i;
    

68.     int err = 0;
    

69.     if(snk.direction == UP)
    

70.     {                
    

71.         for(i=snk.length-1; i>0; i--)
    

72.         {
    

73.             snk.x[i] = snk.x[i-1];
    

74.             snk.y[i] = snk.y[i-1];
    

75.         }
    

76. 
    

77.         //如果向上运动，第0个点的横坐标不变，纵坐标加1
    

78.         snk.x[0] = snk.x[0];
    

79.         snk.y[0] = snk.y[0] + 1;
    

80.     }
    

81.     else if(snk.direction == DOWN)
    

82.     {
    

83.         for(i=snk.length-1; i>0; i--)
    

84.         {
    

85.             snk.x[i] = snk.x[i-1];
    

86.             snk.y[i] = snk.y[i-1];
    

87.         }
    

88. 
    

89.          //如果向下运动，第0个点的横坐标不变，纵坐标减1
    

90.         snk.x[0] = snk.x[0];
    

91.         snk.y[0] = snk.y[0] - 1;            
    

92.     }
    

93.     else if(snk.direction == LEFT)
    

94.     {
    

95.         for(i=snk.length-1; i>0; i--)
    

96.         {
    

97.             snk.x[i] = snk.x[i-1];
    

98.             snk.y[i] = snk.y[i-1];
    

99.         }
    

100. 
     

101.          //如果向左运动，第0个点的横坐标减1，纵坐标不变
     

102.         snk.x[0] = snk.x[0] - 1;
     

103.         snk.y[0] = snk.y[0];            
     

104.     }
     

105.     else
     

106.     {
     

107.         for(i=snk.length-1; i>0; i--)
     

108.         {
     

109.             snk.x[i] = snk.x[i-1];
     

110.             snk.y[i] = snk.y[i-1];
     

111.         }
     

112. 
     

113.         //如果向右运动，第0个点的横坐标加1，纵坐标不变
     

114.         snk.x[0] = snk.x[0] + 1;
     

115.         snk.y[0] = snk.y[0];        
     

116.     }
     

117. 
     

118.     err = is_location_error();
     

119.     return err;
     

120. }
     

121. 
     

122. int is_location_error()
     

123. {
     

124.     unsigned char i;
     

125. 
     

126.     //如果第0个点的坐标和其他任意一个点重复，那么蛇就自己撞自己，出错
     

127.     for(i=1; i<snk.length; i++)
     

128.     {
     

129.         if((snk.x[0]==snk.x[i]) && (snk.y[0]==snk.y[i]))
     

130.             return 1;
     

131.     }
     

132. 
     

133.     //如果蛇的坐标超出范围，也出错
     

134.     if(snk.x[0]>7 || snk.y[0]>7)
     

135.         return 1;
     

136. 
     

137.     return 0;
     

138. }

snake.h

1. #include <reg51.h>
   

2. 
   

3. //定义四个方向按键
   

4. sbit up = P3^4;
   

5. sbit down = P3^5;
   

6. sbit left = P3^6;
   

7. sbit right = P3^7;
   

8. //定义1个游戏级别按键
   

9. sbit level = P3^0;
   

10. //定义一个复位按键
    

11. sbit reset = P3^1;
    

12. 
    

13. //定义4个方向的值
    

14. #define RIGHT 0
    

15. #define    UP 1
    

16. #define LEFT 2
    

17. #define DOWN 3
    

18. 
    

19. void delay_us();
    

20. void delay_10us();
    

21. void delay_ms();
    

22. void delay_10ms();
    

23. void delay_100ms();
    

24. void delay_s();
    

25. int is_location_error();
    

26. void matrix();
    

27. void snk_init();
    

28. void set_direction();
    

29. int get_location();
    

30. int is_location_error();