小贱钟做好了

shihaipeng04

架子撘起来了，但是手头只有2个舵机，没办法看到全貌。很是郁闷。分开测试，到是运行的挺流畅。


来个全家福


这个小孔改造的非常棒，和舵机可以实现无螺丝固定，而且配合很完美。


但愿舵机的轴都是这样。


组装很简单


摆拍一个。。那是马克笔，不是白板笔，如果写上了，就再也擦不掉了


少一个舵机，真是挠头


挥舞起来吧


用手持方式写了一个


猜了半天，才看明白，它写的是 00:02，那个零好圆哦

机架结构似乎还是不太合理，还有修改的余地。过几天弄个完美版的，淘宝开个店卖卖20￥一套预定送螺丝哦！


程序奉上，需要时间模块一个，我是用的DS3231，如果是其他时间模块，。H文件需要改一下。字模文件都是程序里写好的路径，如果感觉它的字实在太难看了，可以自己修改。呵呵

1. 
   
2. #define CALIBRATION      // enable calibration mode
   
3. //#define REALTIMECLOCK    // enable real time clock
   
4. 
   
5. // When in calibration mode, adjust the following factor until the servos move exactly 90 degrees
   
6. #define SERVOFAKTORLEFT 650
   
7. #define SERVOFAKTORRIGHT 650
   
8. 
   
9. // Zero-position of left and right servo
   
10. // When in calibration mode, adjust the NULL-values so that the servo arms are at all times parallel
    
11. // either to the X or Y axis
    
12. #define SERVOLEFTNULL 2250
    
13. #define SERVORIGHTNULL 920
    
14. 
    
15. #define SERVOPINLIFT  2
    
16. #define SERVOPINLEFT  3
    
17. #define SERVOPINRIGHT 4
    
18. 
    
19. // lift positions of lifting servo
    
20. #define LIFT0 1080 // on drawing surface
    
21. #define LIFT1 925  // between numbers
    
22. #define LIFT2 725  // going towards sweeper
    
23. 
    
24. // speed of liftimg arm, higher is slower
    
25. #define LIFTSPEED 1500
    
26. 
    
27. // length of arms
    
28. #define L1 35
    
29. #define L2 55.1
    
30. #define L3 13.2
    
31. 
    
32. // origin points of left and right servo
    
33. #define O1X 22
    
34. #define O1Y -25
    
35. #define O2X 47
    
36. #define O2Y -25
    
37. 
    
38. #include <Time.h>
    
39. #include <Servo.h>
    
40. #include <Wire.h>
    
41. #include <DS3231.h>   
    
42. 
    
43. 
    
44. int servoLift = 1500;
    
45. 
    
46. Servo servo1;  //
    
47. Servo servo2;  //
    
48. Servo servo3;  //
    
49. 
    
50. volatile double lastX = 75;
    
51. volatile double lastY = 47.5;
    
52. 
    
53. int last_min = 0;
    
54. 
    
55. void setup()
    
56. {
    
57. 
    
58.   Serial.begin(9600);
    
59.   Wire.begin();
    
60.   
    
61.   drawTo(75.2, 47);
    
62.   lift(0);
    
63.   servo1.attach(SERVOPINLIFT);  //  lifting servo
    
64.   servo2.attach(SERVOPINLEFT);  //  left servo
    
65.   servo3.attach(SERVOPINRIGHT);  //  right servo
    
66.   delay(1000);
    
67. 
    
68. }
    
69. 
    
70. void loop()
    
71. {
    
72. 
    
73.   int i = 0;
    
74.   if (last_min != minute()) {
    
75. 
    
76.     if (!servo1.attached()) servo1.attach(SERVOPINLIFT);
    
77.     if (!servo2.attached()) servo2.attach(SERVOPINLEFT);
    
78.     if (!servo3.attached()) servo3.attach(SERVOPINRIGHT);
    
79. 
    
80.     lift(0);
    
81. 
    
82.     hour();
    
83.     while ((i+1)*10 <= hour())
    
84.     {
    
85.       i++;
    
86.     }
    
87. 
    
88.     number(3, 3, 111, 1);
    
89.     number(5, 25, i, 0.9);
    
90.     number(19, 25, (hour()-i*10), 0.9);
    
91.     number(28, 25, 11, 0.9);
    
92. 
    
93.     i=0;
    
94.     while ((i+1)*10 <= minute())
    
95.     {
    
96.       i++;
    
97.     }
    
98.     number(34, 25, i, 0.9);
    
99.     number(48, 25, (minute()-i*10), 0.9);
    
100.     lift(2);
     
101.     drawTo(74.2, 47.5);
     
102.     lift(1);
     
103.     last_min = minute();
     
104. 
     
105.     servo1.detach();
     
106.     servo2.detach();
     
107.     servo3.detach();
     
108.   }
     
109. 
     
110. 
     
111. 
     
112. }
     
113. 
     
114. // Writing numeral with bx by being the bottom left originpoint. Scale 1 equals a 20 mm high font.
     
115. // The structure follows this principle: move to first startpoint of the numeral, lift down, draw numeral, lift up
     
116. void number(float bx, float by, int num, float scale) {
     
117. 
     
118.   switch (num) {
     
119. 
     
120.   case 0:
     
121.     drawTo(bx + 12 * scale, by + 6 * scale);
     
122.     lift(0);
     
123.     bogenGZS(bx + 7 * scale, by + 10 * scale, 10 * scale, -0.8, 6.7, 0.5);
     
124.     lift(1);
     
125.     break;
     
126.   case 1:
     
127. 
     
128.     drawTo(bx + 3 * scale, by + 15 * scale);
     
129.     lift(0);
     
130.     drawTo(bx + 10 * scale, by + 20 * scale);
     
131.     drawTo(bx + 10 * scale, by + 0 * scale);
     
132.     lift(1);
     
133.     break;
     
134.   case 2:
     
135.     drawTo(bx + 2 * scale, by + 12 * scale);
     
136.     lift(0);
     
137.     bogenUZS(bx + 8 * scale, by + 14 * scale, 6 * scale, 3, -0.8, 1);
     
138.     drawTo(bx + 1 * scale, by + 0 * scale);
     
139.     drawTo(bx + 12 * scale, by + 0 * scale);
     
140.     lift(1);
     
141.     break;
     
142.   case 3:
     
143.     drawTo(bx + 2 * scale, by + 17 * scale);
     
144.     lift(0);
     
145.     bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 3, -2, 1);
     
146.     bogenUZS(bx + 5 * scale, by + 5 * scale, 5 * scale, 1.57, -3, 1);
     
147.     lift(1);
     
148.     break;
     
149.   case 4:
     
150.     drawTo(bx + 10 * scale, by + 0 * scale);
     
151.     lift(0);
     
152.     drawTo(bx + 10 * scale, by + 20 * scale);
     
153.     drawTo(bx + 2 * scale, by + 6 * scale);
     
154.     drawTo(bx + 12 * scale, by + 6 * scale);
     
155.     lift(1);
     
156.     break;
     
157.   case 5:
     
158.     drawTo(bx + 2 * scale, by + 5 * scale);
     
159.     lift(0);
     
160.     bogenGZS(bx + 5 * scale, by + 6 * scale, 6 * scale, -2.5, 2, 1);
     
161.     drawTo(bx + 5 * scale, by + 20 * scale);
     
162.     drawTo(bx + 12 * scale, by + 20 * scale);
     
163.     lift(1);
     
164.     break;
     
165.   case 6:
     
166.     drawTo(bx + 2 * scale, by + 10 * scale);
     
167.     lift(0);
     
168.     bogenUZS(bx + 7 * scale, by + 6 * scale, 6 * scale, 2, -4.4, 1);
     
169.     drawTo(bx + 11 * scale, by + 20 * scale);
     
170.     lift(1);
     
171.     break;
     
172.   case 7:
     
173.     drawTo(bx + 2 * scale, by + 20 * scale);
     
174.     lift(0);
     
175.     drawTo(bx + 12 * scale, by + 20 * scale);
     
176.     drawTo(bx + 2 * scale, by + 0);
     
177.     lift(1);
     
178.     break;
     
179.   case 8:
     
180.     drawTo(bx + 5 * scale, by + 10 * scale);
     
181.     lift(0);
     
182.     bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 4.7, -1.6, 1);
     
183.     bogenGZS(bx + 5 * scale, by + 5 * scale, 5 * scale, -4.7, 2, 1);
     
184.     lift(1);
     
185.     break;
     
186. 
     
187.   case 9:
     
188.     drawTo(bx + 9 * scale, by + 11 * scale);
     
189.     lift(0);
     
190.     bogenUZS(bx + 7 * scale, by + 15 * scale, 5 * scale, 4, -0.5, 1);
     
191.     drawTo(bx + 5 * scale, by + 0);
     
192.     lift(1);
     
193.     break;
     
194. 
     
195.   case 111:
     
196. 
     
197.     lift(0);
     
198.     drawTo(70, 46);
     
199.     drawTo(65, 43);
     
200. 
     
201.     drawTo(65, 49);
     
202.     drawTo(5, 49);
     
203.     drawTo(5, 45);
     
204.     drawTo(65, 45);
     
205.     drawTo(65, 40);
     
206. 
     
207.     drawTo(5, 40);
     
208.     drawTo(5, 35);
     
209.     drawTo(65, 35);
     
210.     drawTo(65, 30);
     
211. 
     
212.     drawTo(5, 30);
     
213.     drawTo(5, 25);
     
214.     drawTo(65, 25);
     
215.     drawTo(65, 20);
     
216. 
     
217.     drawTo(5, 20);
     
218.     drawTo(60, 44);
     
219. 
     
220.     drawTo(75.2, 47);
     
221.     lift(2);
     
222. 
     
223.     break;
     
224. 
     
225.   case 11:
     
226.     drawTo(bx + 5 * scale, by + 15 * scale);
     
227.     lift(0);
     
228.     bogenGZS(bx + 5 * scale, by + 15 * scale, 0.1 * scale, 1, -1, 1);
     
229.     lift(1);
     
230.     drawTo(bx + 5 * scale, by + 5 * scale);
     
231.     lift(0);
     
232.     bogenGZS(bx + 5 * scale, by + 5 * scale, 0.1 * scale, 1, -1, 1);
     
233.     lift(1);
     
234.     break;
     
235. 
     
236.   }
     
237. }
     
238. 
     
239. 
     
240. 
     
241. void lift(char lift) {
     
242.   
     
243. 
     
244.   switch (lift) {
     
245.     // room to optimize  !
     
246. 
     
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. }
     

复制代码

mxhhaixin

先提前预订一套。
楼主淘宝店地址是什么。

mxhhaixin

这个有没有其他颜色的。感觉红色暗了点。弄个鲜明活泼的颜色呗。

mxhhaixin

不知道把字体换成数码管显示的那种，写出来会不会更好看些。楼主试验下呗。
还有，能不能做个底座，把小贱钟和Arduino固定在一起。

咯小3虽

{:soso_e179:}

mxhhaixin

要是卖成品，就集成Mini。卖散件的话，就在底座上钻四个能装UNO的孔。毕竟大家还是用UNO的多。

mxhhaixin

mxhhaixin 发表于 2014-5-15 14:13
要是卖成品，就集成Mini。卖散件的话，就在底座上钻四个能装UNO的孔。毕竟大家还是用UNO的多。

搞精致点，做成工艺品，就有人愿意花钱了。

for

能不能脱离电脑工作？

沧海笑1122

激光切割吗？支持！预订！。。。对了，怎么预订啊？

『超人不会飞』

求上架日期

shihaipeng04

『超人不会飞』 发表于 2014-5-26 11:04
求上架日期

【新提醒】plotclock小贱钟套件完工啦 - Powered by Discuz!
http://www.geek-workshop.com/thread-10014-1-1.html

刚刚上线

那一小撮人

您好问一下。想按自己轨迹写的话用改那些参数，数据。那些事不用改的？

shihaipeng04

那一小撮人 发表于 2014-7-24 10:06
您好问一下。想按自己轨迹写的话用改那些参数，数据。那些事不用改的？

程序里有个 drawto函数 还有个 lift抬臂函数 ，就用着个函数控制就能随便画了。比如做个小绘图仪啥的。呵呵

那一小撮人

shihaipeng04 发表于 2014-7-24 10:21
程序里有个 drawto函数 还有个 lift抬臂函数 ，就用着个函数控制就能随便画了。比如做个小绘图仪啥的。呵 ...

恩谢谢， 你知道有什么类似可以建立坐标纸的软件吗

那一小撮人

问一下 bogenUZS函数中的start，ende，sqee代表什么