制作小贱钟出问题求大神帮助

超级飞马

网上买了一套小贱钟的亚克力零件，用arduino pro mini做控制板，安装过程，用商家给的调试程序调整摆臂位置均正常，但用商家给的主程序（摆臂位置已我改成调试后的值）运行出错，不写时间只是不停的在同一位置上点点，整个一磕头机。郁闷啊
代码如下

1. //左右悬臂舵机的90度位置,，数字增加，左侧舵机顺时针调整，右侧舵机逆时针调整
   
2. #define SERVOFAKTORLEFT 620
   
3. #define SERVOFAKTORRIGHT 580
   
4. 
   
5. //左右悬臂舵机的 0或180度位置,，数字增加，左侧舵机顺时针调整，右侧舵机逆时针调整
   
6. #define SERVOLEFTNULL 2060
   
7. #define SERVORIGHTNULL 1090
   
8. 
   
9. //升举舵机的3个角度
   
10. #define LIFT0 1140 // on drawing surface
    
11. #define LIFT1 925  // between numbers
    
12. #define LIFT2 725  // going towards sweeper
    
13. 
    
14. //
    
15. //以上参数，请运行调试程序 plotclockadj ，调整好位置后，将数据复制过来
    
16. //
    
17. 
    
18. //三只舵机的接口
    
19. #define SERVOPINLIFT  2
    
20. #define SERVOPINLEFT  3
    
21. #define SERVOPINRIGHT 4
    
22. 
    
23. // 速度
    
24. #define LIFTSPEED 1500
    
25. 
    
26. // 悬臂的长度，根据图纸测量，无需改变
    
27. #define L1 35
    
28. #define L2 57.2
    
29. #define L3 14.2
    
30. 
    
31. 
    
32. // 左右舵机轴心的位置
    
33. #define O1X 22
    
34. #define O1Y -25
    
35. #define O2X 47
    
36. #define O2Y -25
    
37. 
    
38. 
    
39. 
    
40. #include <Time.h> // see http://playground.arduino.cc/Code/time
    
41. //这里报错请把压缩包内的time.h复制到C:\Program Files\Arduino\libraries下
    
42. #include <Servo.h>
    
43. 
    
44. int  rubberx=72,rubbery=42; //笔擦的坐标位置，如不能对准笔擦可以微调单位毫米
    
45. 
    
46. int servoLift = 1500;
    
47. 
    
48. Servo servo1;  //
    
49. Servo servo2;  //
    
50. Servo servo3;  //
    
51. 
    
52. volatile double lastX = 70;
    
53. volatile double lastY = 42;
    
54. 
    
55. int last_min = 0;
    
56. 
    
57. void setup()
    
58. {
    
59.   // 在这里设置一个初始时间
    
60.   setTime(06,41,0,0,0,0);
    
61. 
    
62.   
    
63.   servo1.attach(SERVOPINLIFT);  //  lifting servo
    
64.   servo2.attach(SERVOPINLEFT);  //  left servo
    
65.   servo3.attach(SERVOPINRIGHT);  //  right servo
    
66.   
    
67.   lift(1); //抬笔
    
68.   drawTo(rubberx, rubbery); //停留在笔擦位置
    
69.   delay(1000);
    
70. 
    
71. }
    
72. 
    
73. void loop()
    
74. {
    
75. 
    
76. int i = 0;
    
77. if  ( last_min != minute())   //现在是不停的书写，如果每分钟写一次就改成        if (1 || last_min != minute())
    
78.   {
    
79. 
    
80.     if (!servo1.attached()) servo1.attach(SERVOPINLIFT);
    
81.     if (!servo2.attached()) servo2.attach(SERVOPINLEFT);
    
82.     if (!servo3.attached()) servo3.attach(SERVOPINRIGHT);
    
83. 
    
84.     lift(0);
    
85. 
    
86.     hour();
    
87.     while ((i+1)*10 <= hour())
    
88.     {
    
89.       i++;
    
90.     }
    
91. 
    
92.     number(3, 3, 111, 1);
    
93.     number(5, 25, i, 0.9);
    
94.     number(19, 25, (hour()-i*10), 0.9);
    
95.     number(28, 25, 11, 0.9);
    
96. 
    
97.     i=0;
    
98.     while ((i+1)*10 <= minute())
    
99.     {
    
100.       i++;
     
101.     }
     
102.     number(34, 25, i, 0.9);
     
103.     number(48, 25, (minute()-i*10), 0.9);
     
104.     lift(2);
     
105.      drawTo(rubberx, rubbery); //回到笔擦位置
     
106.     lift(1);
     
107.     last_min = minute();
     
108. 
     
109.     servo1.detach();
     
110.     servo2.detach();
     
111.     servo3.detach();
     
112.   }
     
113. 
     
114. 
     
115. }
     
116. 
     
117. // Writing numeral with bx by being the bottom left originpoint. Scale 1 equals a 20 mm high font.
     
118. // The structure follows this principle: move to first startpoint of the numeral, lift down, draw numeral, lift up
     
119. void number(float bx, float by, int num, float scale) {
     
120. 
     
121.   switch (num) {
     
122. 
     
123.   case 0:
     
124.     drawTo(bx + 12 * scale, by + 6 * scale);
     
125.     lift(0);
     
126.     bogenGZS(bx + 7 * scale, by + 10 * scale, 10 * scale, -0.8, 6.7, 0.5);
     
127.     lift(1);
     
128.     break;
     
129.   case 1:
     
130. 
     
131.     drawTo(bx + 3 * scale, by + 15 * scale);
     
132.     lift(0);
     
133.     drawTo(bx + 10 * scale, by + 20 * scale);
     
134.     drawTo(bx + 10 * scale, by + 0 * scale);
     
135.     lift(1);
     
136.     break;
     
137.   case 2:
     
138.     drawTo(bx + 2 * scale, by + 12 * scale);
     
139.     lift(0);
     
140.     bogenUZS(bx + 8 * scale, by + 14 * scale, 6 * scale, 3, -0.8, 1);
     
141.     drawTo(bx + 1 * scale, by + 0 * scale);
     
142.     drawTo(bx + 12 * scale, by + 0 * scale);
     
143.     lift(1);
     
144.     break;
     
145.   case 3:
     
146.     drawTo(bx + 2 * scale, by + 17 * scale);
     
147.     lift(0);
     
148.     bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 3, -2, 1);
     
149.     bogenUZS(bx + 5 * scale, by + 5 * scale, 5 * scale, 1.57, -3, 1);
     
150.     lift(1);
     
151.     break;
     
152.   case 4:
     
153.     drawTo(bx + 10 * scale, by + 0 * scale);
     
154.     lift(0);
     
155.     drawTo(bx + 10 * scale, by + 20 * scale);
     
156.     drawTo(bx + 2 * scale, by + 6 * scale);
     
157.     drawTo(bx + 12 * scale, by + 6 * scale);
     
158.     lift(1);
     
159.     break;
     
160.   case 5:
     
161.     drawTo(bx + 2 * scale, by + 5 * scale);
     
162.     lift(0);
     
163.     bogenGZS(bx + 5 * scale, by + 6 * scale, 6 * scale, -2.5, 2, 1);
     
164.     drawTo(bx + 5 * scale, by + 20 * scale);
     
165.     drawTo(bx + 12 * scale, by + 20 * scale);
     
166.     lift(1);
     
167.     break;
     
168.   case 6:
     
169.     drawTo(bx + 2 * scale, by + 10 * scale);
     
170.     lift(0);
     
171.     bogenUZS(bx + 7 * scale, by + 6 * scale, 6 * scale, 2, -4.4, 1);
     
172.     drawTo(bx + 11 * scale, by + 20 * scale);
     
173.     lift(1);
     
174.     break;
     
175.   case 7:
     
176.     drawTo(bx + 2 * scale, by + 20 * scale);
     
177.     lift(0);
     
178.     drawTo(bx + 12 * scale, by + 20 * scale);
     
179.     drawTo(bx + 2 * scale, by + 0);
     
180.     lift(1);
     
181.     break;
     
182.   case 8:
     
183.     drawTo(bx + 5 * scale, by + 10 * scale);
     
184.     lift(0);
     
185.     bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 4.7, -1.6, 1);
     
186.     bogenGZS(bx + 5 * scale, by + 5 * scale, 5 * scale, -4.7, 2, 1);
     
187.     lift(1);
     
188.     break;
     
189. 
     
190.   case 9:
     
191.     drawTo(bx + 9 * scale, by + 11 * scale);
     
192.     lift(0);
     
193.     bogenUZS(bx + 7 * scale, by + 15 * scale, 5 * scale, 4, -0.5, 1);
     
194.     drawTo(bx + 5 * scale, by + 0);
     
195.     lift(1);
     
196.     break;
     
197. 
     
198.   case 111://擦除面板的动作
     
199. 
     
200.     lift(0);
     
201.     drawTo(rubberx, rubbery);
     
202.     drawTo(58, 42);
     
203. 
     
204.     drawTo(58, 45);
     
205.     drawTo(2, 45);
     
206.     drawTo(2, 41);
     
207.     drawTo(58, 41);
     
208.     drawTo(60, 37);
     
209. 
     
210.     drawTo(2, 37);
     
211.     drawTo(2, 33);
     
212.     drawTo(60, 33);
     
213.     drawTo(60, 29);
     
214. 
     
215.     drawTo(2, 29);
     
216.     drawTo(2, 25);
     
217.     drawTo(60, 25);
     
218.     drawTo(60, 20);
     
219. 
     
220.     drawTo(2, 20);
     
221.     drawTo(60, rubbery);
     
222. 
     
223.     drawTo(rubberx + 3 , rubbery); //向左侧多推一些，让笔擦能够进入笔架
     
224.     lift(2);
     
225. 
     
226.     break;
     
227. 
     
228.   case 11:
     
229.     drawTo(bx + 5 * scale, by + 15 * scale);
     
230.     lift(0);
     
231.     bogenGZS(bx + 5 * scale, by + 15 * scale, 0.1 * scale, 1, -1, 1);
     
232.     lift(1);
     
233.     drawTo(bx + 5 * scale, by + 5 * scale);
     
234.     lift(0);
     
235.     bogenGZS(bx + 5 * scale, by + 5 * scale, 0.1 * scale, 1, -1, 1);
     
236.     lift(1);
     
237.     break;
     
238. 
     
239.   }
     
240. }
     
241. 
     
242. 
     
243. 
     
244. void lift(char lift) {
     
245.   switch (lift) {
     
246.     // room to optimize  !
     
247. 
     
248.   case 0: //850
     
249. 
     
250.       if (servoLift >= LIFT0) {
     
251.       while (servoLift >= LIFT0)
     
252.       {
     
253.         servoLift--;
     
254.         servo1.writeMicroseconds(servoLift);                               
     
255.         delayMicroseconds(LIFTSPEED);
     
256.       }
     
257.     }
     
258.     else {
     
259.       while (servoLift <= LIFT0) {
     
260.         servoLift++;
     
261.         servo1.writeMicroseconds(servoLift);
     
262.         delayMicroseconds(LIFTSPEED);
     
263. 
     
264.       }
     
265. 
     
266.     }
     
267. 
     
268.     break;
     
269. 
     
270.   case 1: //150
     
271. 
     
272.     if (servoLift >= LIFT1) {
     
273.       while (servoLift >= LIFT1) {
     
274.         servoLift--;
     
275.         servo1.writeMicroseconds(servoLift);
     
276.         delayMicroseconds(LIFTSPEED);
     
277. 
     
278.       }
     
279.     }
     
280.     else {
     
281.       while (servoLift <= LIFT1) {
     
282.         servoLift++;
     
283.         servo1.writeMicroseconds(servoLift);
     
284.         delayMicroseconds(LIFTSPEED);
     
285.       }
     
286. 
     
287.     }
     
288. 
     
289.     break;
     
290. 
     
291.   case 2:
     
292. 
     
293.     if (servoLift >= LIFT2) {
     
294.       while (servoLift >= LIFT2) {
     
295.         servoLift--;
     
296.         servo1.writeMicroseconds(servoLift);
     
297.         delayMicroseconds(LIFTSPEED);
     
298.       }
     
299.     }
     
300.     else {
     
301.       while (servoLift <= LIFT2) {
     
302.         servoLift++;
     
303.         servo1.writeMicroseconds(servoLift);                               
     
304.         delayMicroseconds(LIFTSPEED);
     
305.       }
     
306.     }
     
307.     break;
     
308.   }
     
309. }
     
310. 
     
311. 
     
312. void bogenUZS(float bx, float by, float radius, int start, int ende, float sqee) {
     
313.   float inkr = -0.05;
     
314.   float count = 0;
     
315. 
     
316.   do {
     
317.     drawTo(sqee * radius * cos(start + count) + bx,
     
318.     radius * sin(start + count) + by);
     
319.     count += inkr;
     
320.   }
     
321.   while ((start + count) > ende);
     
322. 
     
323. }
     
324. 
     
325. void bogenGZS(float bx, float by, float radius, int start, int ende, float sqee) {
     
326.   float inkr = 0.05;
     
327.   float count = 0;
     
328. 
     
329.   do {
     
330.     drawTo(sqee * radius * cos(start + count) + bx,
     
331.     radius * sin(start + count) + by);
     
332.     count += inkr;
     
333.   }
     
334.   while ((start + count) <= ende);
     
335. }
     
336. 
     
337. 
     
338. void drawTo(double pX, double pY) {
     
339.   double dx, dy, c;
     
340.   int i;
     
341. 
     
342.   // dx dy of new point
     
343.   dx = pX - lastX;
     
344.   dy = pY - lastY;
     
345.   //path lenght in mm, times 4 equals 4 steps per mm
     
346.   c = floor(4 * sqrt(dx * dx + dy * dy));
     
347. 
     
348.   if (c < 1) c = 1;
     
349. 
     
350.   for (i = 0; i <= c; i++) {
     
351.     // draw line point by point
     
352.     set_XY(lastX + (i * dx / c), lastY + (i * dy / c));
     
353. 
     
354.   }
     
355. 
     
356.   lastX = pX;
     
357.   lastY = pY;
     
358. }
     
359. 
     
360. double return_angle(double a, double b, double c) {
     
361.   // cosine rule for angle between c and a
     
362.   return acos((a * a + c * c - b * b) / (2 * a * c));
     
363. }
     
364. 
     
365. void set_XY(double Tx, double Ty)
     
366. {
     
367.   delay(1);
     
368.   double dx, dy, c, a1, a2, Hx, Hy;
     
369. 
     
370.   // calculate triangle between pen, servoLeft and arm joint
     
371.   // cartesian dx/dy
     
372.   dx = Tx - O1X;
     
373.   dy = Ty - O1Y;
     
374. 
     
375.   // polar lemgth (c) and angle (a1)
     
376.   c = sqrt(dx * dx + dy * dy); //
     
377.   a1 = atan2(dy, dx); //
     
378.   a2 = return_angle(L1, L2, c);
     
379. 
     
380.     servo2.writeMicroseconds(floor(((a2 + a1 - M_PI) * SERVOFAKTORLEFT) + SERVOLEFTNULL));
     
381. 
     
382.   // calculate joinr arm point for triangle of the right servo arm
     
383.   a2 = return_angle(L2, L1, c);
     
384.   Hx = Tx + L3 * cos((a1 - a2 + 0.621) + M_PI); //36,5掳
     
385.   Hy = Ty + L3 * sin((a1 - a2 + 0.621) + M_PI);
     
386. 
     
387.   // calculate triangle between pen joint, servoRight and arm joint
     
388.   dx = Hx - O2X;
     
389.   dy = Hy - O2Y;
     
390. 
     
391.   c = sqrt(dx * dx + dy * dy);
     
392.   a1 = atan2(dy, dx);
     
393.   a2 = return_angle(L1, (L2 - L3), c);
     
394. 
     
395.    servo3.writeMicroseconds(floor(((a1 - a2) * SERVOFAKTORRIGHT) + SERVORIGHTNULL));
     
396. 
     
397. }
     
398. 
     
399. 
     
400. 
     
401. 
     

复制代码

下面是视频链接
http://v.qq.com/page/i/m/z/i0142894amz.html

超级飞马

求各位大神看看问题出在哪了