Arduino驱动8*8点阵模块 附原理图及一个打乒乓球的游戏代码

YFRobot

一位来自葡萄牙的arduino爱好者，在他的BLOG中分享了一个基于Arduino平台的游戏，下面是他的作品：

原文地址：http://blog.bsoares.com.br/ardui ... d-matrix-on-arduino
利用常见的8*8点阵作为“游戏机”的显示屏，两个10K的电位器作为双方的“球拍”，控制器采用的是Arduino的Duemilanove兼容板。当顺时针拧电位器时，球拍向左移动；反向则向右移动。
游戏代码：

1. /**
   
2. * Ping Pong with 8x8 Led Dot Matrix on Arduino
   
3. *
   
4. * @author  Bruno Soares
   
5. * @website www.bsoares.com.br
   
6. */
   
7. 
   
8. #include "TimerOne.h"
   
9. 
   
10. #define PIN_LEFT 4
    
11. #define PIN_RIGHT 5
    
12. 
    
13. unsigned int left = 0;
    
14. unsigned int right = 0;
    
15. int angle = 0;
    
16. int radians;
    
17. 
    
18. byte rows[8] = {9, 14, 8, 12, 1, 7, 2, 5};
    
19. byte cols[8] = {13, 3, 4, 10, 6, 11, 15, 16};
    
20. byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
    
21. byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
    
22. volatile byte screenRow = 0;
    
23. volatile byte screenCol = 0;
    
24. 
    
25. int _angle;
    
26. int _px;
    
27. int _py;
    
28. int _w = 7;
    
29. int _h = 7;
    
30. int _wall[] = {3, 3};
    
31. int _count = 0;
    
32. int _speed = 3;
    
33. int _countPoints = 0;
    
34. 
    
35. 
    
36. void setup() {
    
37.   Timer1.initialize(100);
    
38.   for (int i = 2; i <= 17; i++)
    
39.     pinMode(i, OUTPUT);
    
40.   Timer1.attachInterrupt(doubleBuffer);
    
41.   
    
42.   Serial.begin(9600);
    
43.   
    
44.   face();
    
45.   reset();
    
46. }
    
47. 
    
48. void doubleBuffer() {
    
49.   digitalWrite(translatePin(rows[screenRow]), LOW);
    
50.   digitalWrite(translatePin(cols[screenCol]), HIGH);
    
51.   
    
52.   screenCol++;
    
53.   if (screenCol >= 8) {
    
54.     screenCol = 0;
    
55.     screenRow++;
    
56.     if (screenRow >= 8) {
    
57.       screenRow = 0;
    
58.     }
    
59.   }
    
60.   
    
61.   if((screen[screenRow] >> screenCol) & B1 == B1) {
    
62.     digitalWrite(translatePin(rows[screenRow]), HIGH);
    
63.     digitalWrite(translatePin(cols[screenCol]), LOW);
    
64.   } else {
    
65.     digitalWrite(translatePin(rows[screenRow]), LOW);
    
66.     digitalWrite(translatePin(cols[screenCol]), HIGH);
    
67.   }
    
68. }
    
69. 
    
70. byte translatePin(byte original) {
    
71.   return pins[original - 1];
    
72. }
    
73. 
    
74. void allOFF() {
    
75.   for (int i = 0; i < 8; i++)
    
76.     screen[i] = 0;
    
77. }
    
78. 
    
79. void on(byte row, byte column) {
    
80.     screen[column-1] |= (B1 << (row - 1));
    
81. }
    
82. 
    
83. void off(byte row, byte column) {
    
84.     screen[column-1] &= ~(B1 << (row - 1));
    
85. }
    
86. 
    
87. void calcWall()
    
88. {
    
89.   left = analogRead(PIN_LEFT);
    
90.   right = analogRead(PIN_RIGHT);
    
91.   left = constrain(map(left, 223, 800, 0, 6), 0, 6);
    
92.   right = constrain(map(right, 223, 800, 6, 0), 0, 6);
    
93.   
    
94.   clearWall();
    
95.   
    
96.   on(1, left + 1);
    
97.   on(1, left + 2);
    
98.   on(8, right + 1);
    
99.   on(8, right + 2);
    
100.   
     
101.   _wall[0] = left;
     
102.   _wall[1] = right;
     
103.   show();
     
104. }
     
105. 
     
106. void clearWall()
     
107. {
     
108.   for (int i = 0; i < 8; i++)
     
109.     screen[i] &= B01111110;
     
110. }
     
111. 
     
112. void clearGame()
     
113. {
     
114.   for (int i = 0; i < 8; i++)
     
115.     screen[i] &= B10000001;
     
116. }
     
117. 
     
118. void loop() {
     
119.   calcWall();
     
120.   enterFrameHandler();
     
121.   delay(50);
     
122. }
     
123. 
     
124. void enterFrameHandler()
     
125. {
     
126.   if (_count++ < _speed)
     
127.     return;
     
128.   
     
129.   _count = 0;
     
130.   checkCollision();
     
131.   calcAngleIncrement();
     
132.   show();
     
133. }
     
134. 
     
135. void retorted(int angle)
     
136. {
     
137.   Serial.println(angle);
     
138.   _angle = angle;
     
139.   
     
140.   if (++_countPoints % 5 == 0 && _speed > 1)
     
141.     _speed--;
     
142. }
     
143. 
     
144. void resetAnim()
     
145. {
     
146.   for (int i = 0; i < 8; i++)
     
147.   {
     
148.     screen[i] = B11111111;
     
149.     delay(25);
     
150.   }
     
151.   for (int i = 0; i < 8; i++)
     
152.   {
     
153.     screen[i] = B00000000;
     
154.     delay(25);
     
155.   }
     
156. }
     
157. 
     
158. void face()
     
159. {
     
160.   on(1, 1);
     
161.   on(1, 2);
     
162.   on(2, 1);
     
163.   on(2, 2);
     
164.   on(7, 1);
     
165.   on(7, 2);
     
166.   on(8, 1);
     
167.   on(8, 2);
     
168.   on(1, 1);
     
169.   on(1, 2);
     
170.   on(4, 4);
     
171.   on(4, 5);
     
172.   on(5, 4);
     
173.   on(5, 5);
     
174.   on(2, 7);
     
175.   on(7, 7);
     
176.   on(3, 8);
     
177.   on(4, 8);
     
178.   on(5, 8);
     
179.   on(6, 8);
     
180.   delay(5000);
     
181. }
     
182. 
     
183. void reset()
     
184. {
     
185.   resetAnim();
     
186.   
     
187.   _px = random(3, 5);
     
188.   _py = random(3, 5);
     
189.   _angle = random(0, 2) == 0 ? 0 : 180;
     
190.   _speed = 5;
     
191.   _countPoints = 0;
     
192.   
     
193.   show();
     
194.   delay(500);
     
195. }
     
196. 
     
197. void show()
     
198. {
     
199.   clearGame();
     
200.   on(_px + 1, _py + 1);
     
201. }
     
202. 
     
203. void checkCollision()
     
204. {
     
205.   if (_px == _w - 1)
     
206.   {
     
207.     if (_angle == 315 || _angle == 0 || _angle == 45)
     
208.     {
     
209.       if (_py == _wall[1] || _py == _wall[1] + 1)
     
210.       {
     
211.         if (_angle == 0 && _py == _wall[1])
     
212.           retorted(225);
     
213.         else if (_angle == 0 && _py == _wall[1] + 1)
     
214.           retorted(135);
     
215.         else if (_angle == 45 && _py == _wall[1])
     
216.           retorted(135);
     
217.         else if (_angle == 45 && _py == _wall[1] + 1)
     
218.           retorted(180);
     
219.         else if (_angle == 315 && _py == _wall[1])
     
220.           retorted(180);
     
221.         else if (_angle == 315 && _py == _wall[1] + 1)
     
222.           retorted(225);
     
223.       }
     
224.     }
     
225.   }
     
226.   else if (_px == 1)
     
227.   {
     
228.     if (_angle == 225 || _angle == 180 || _angle == 135)
     
229.     {
     
230.       if (_py == _wall[0] || _py == _wall[0] + 1)
     
231.       {
     
232.         if (_angle == 180 && _py == _wall[0])
     
233.           retorted(315);
     
234.         else if (_angle == 180 && _py == _wall[0] + 1)
     
235.           retorted(45);
     
236.         else if (_angle == 135 && _py == _wall[0])
     
237.           retorted(45);
     
238.         else if (_angle == 135 && _py == _wall[0] + 1)
     
239.           retorted(0);
     
240.         else if (_angle == 225 && _py == _wall[0])
     
241.           retorted(0);
     
242.         else if (_angle == 225 && _py == _wall[0] + 1)
     
243.           retorted(315);
     
244.       }
     
245.     }
     
246.   }
     
247.   
     
248.   if (_px == _w)
     
249.   {
     
250.     reset();
     
251.   }
     
252.   else if (_px == 0)
     
253.   {
     
254.     reset();
     
255.   }
     
256.   else if (_py == _h)
     
257.   {
     
258.     if (_angle == 45)
     
259.       _angle = 315;
     
260.     else if (_angle == 135)
     
261.       _angle = 225;
     
262.   }
     
263.   else if (_py == 0)
     
264.   {
     
265.     if (_angle == 225)
     
266.       _angle = 135;
     
267.     else if (_angle == 315)
     
268.       _angle = 45;
     
269.   }
     
270. }
     
271. 
     
272. void calcAngleIncrement()
     
273. {
     
274.   if (_angle == 0 || _angle == 360)
     
275.   {
     
276.     _px += 1;
     
277.   }
     
278.   else if (_angle == 45)
     
279.   {
     
280.     _px += 1;
     
281.     _py += 1;
     
282.   }
     
283.   else if (_angle == 135)
     
284.   {
     
285.     _px -= 1;
     
286.     _py += 1;
     
287.   }
     
288.   else if (_angle == 180)
     
289.   {
     
290.     _px -= 1;
     
291.   }
     
292.   else if (_angle == 225)
     
293.   {
     
294.     _px -= 1;
     
295.     _py -= 1;
     
296.   }
     
297.   else if (_angle == 315)
     
298.   {
     
299.     _px += 1;
     
300.     _py -= 1;
     
301.   }
     
302. }

复制代码

对应引脚接线：（下图左侧红框内表示arduino接口，14为A0，15为A1 ...依次类推，“球拍”接A4及A5）


因为点阵显示单元就占用了arduino 主板16个IO引脚，如果想扩展比分显示单元，或者将电位器换成按键，几乎无法实现。我们可以利用74HC595来对点阵的引脚进行简化，通过下面的电路，我们在实际控制的时候只需要用到3根信号线即可搞定。
*因为是动态扫描显示，图中的8个限流电阻可以舍去，还可以提高亮度。


实物接线，用按键代替了电位器（更符合人们的操作习惯），另外加入一个液晶，可以实时的将游戏比分记录下来。


代码下载：

hero_sun

有视频吗？

狱锁狂龙

nice ^^^^^^^^nice