MEGA BREAD - Hank the HexaPod-Updated 5-31-17

A 6 legged, 18 servo, self guiding time wasting project. MEGA BREAD series #7, Delivery and retrieval from the air project.

May 19, 2017

•

5052 views

•

4 respects

bread

Components and supplies

ZX Distance and Gesture Sensor

Servos (Tower Pro MG996R)

Arduino Mega 2560

Project description

Code

MEGA BREAD - Hank the Hexabot Code

nix

Not yet published due to development issues for pickup and delivery of the bot from the air.

MEGA_BREAD_HANK_THE_HEXABOT

arduino

1/* MEGA BREAD -- SIGHT
2###################################
3# Datatypes  (KEYWORD1)
4###################################
5NewPing  KEYWORD1
6###################################
7#  Methods and Functions (KEYWORD2)
8###################################
9ping  KEYWORD2
10ping_in KEYWORD2
11ping_cm KEYWORD2
12ping_median KEYWORD2
13ping_timer  KEYWORD2
14check_timer KEYWORD2
15timer_us  KEYWORD2
16timer_ms  KEYWORD2
17timer_stop  KEYWORD2
18convert_in  KEYWORD2
19convert_cm  KEYWORD2
20###################################
21#  Constants (LITERAL1)
22###################################*/
23#include <NewPing.h>
24#define  TRIGGER_PIN  53  // Arduino pin tied to trigger pin on the ultrasonic sensor.
25#define  ECHO_PIN     52  // Arduino pin tied to echo pin on the ultrasonic sensor.
26#define  MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum  sensor distance is rated at 400-500cm.
27NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);  // NewPing setup of pins and maximum distance.
28
29/*SERVO SETUP - MEGA BREAD
30  Usable pins on the MEGA
31  Servos  analogWrite Pins  Timers used
32  1 - 12  not pins 44,45,46 Timer 5
33  13 - 24 not pins 11,12,44,45,46 Timers 1 & 5
34  24 - 36 not pins 6,7,8,11,12,44,45,46 Timers 1,4 & 5
35  37 - 48 not pins 2,3,5,6,7,8,11,12,44,45,46  Timers 1,3,4 & 5*/
36#include <Servo.h>
37int legCount = 6;
38int servoSpeed  = 2;
39int delayTimeA = 50;
40int delayTimeB = 100;
41int trueMidPos = 90;
42int  minPos = 60;
43int maxPos = 110;
44int midPos = ((maxPos - minPos) / 2) + minPos;
45int  lPos = midPos;
46int rPos = midPos;
47int aSectionlSideModifier = 0;
48int aSectionrSideModifier  = -0;
49int bSectionlSideModifier = 0;
50int bSectionrSideModifier = -0;
51int  cSectionlSideModifier = 10;
52int cSectionrSideModifier = -10;
53Servo LFA;
54Servo  LFB;
55Servo LFC;
56int ServoPinLFA = 22;
57int ServoPinLFB = 23;
58int ServoPinLFC  = 24;
59Servo LMA;
60Servo LMB;
61Servo LMC;
62int ServoPinLMA = 26;
63int  ServoPinLMB = 27;
64int ServoPinLMC = 28;
65Servo LRA;
66Servo LRB;
67Servo  LRC;
68int ServoPinLRA = 30;
69int ServoPinLRB = 31;
70int ServoPinLRC = 32;
71Servo  RFA;
72Servo RFB;
73Servo RFC;
74int ServoPinRFA = 34;
75int ServoPinRFB = 35;
76int  ServoPinRFC = 36;
77Servo RMA;
78Servo RMB;
79Servo RMC;
80int ServoPinRMA =  38;
81int ServoPinRMB = 39;
82int ServoPinRMC = 40;
83Servo RRA;
84Servo RRB;
85Servo  RRC;
86int ServoPinRRA = 42;
87int ServoPinRRB = 43;
88int ServoPinRRC = 44;
89
90void  distanceCheck() {
91  delay(delayTimeA); // Wait delayTimeB in MS. 29ms should  be the shortest delay between pings.
92  Serial.print("Ping: ");
93  Serial.print(sonar.ping_cm());  // Send ping, get distance in cm and print result (0 = outside set distance range)
94  Serial.println("cm");
95}
96
97
98//Head Setup
99Servo HeadTwist;
100Servo  HeadTilt;
101int ServoPinHeadTwist = 46;
102int ServoPinHeadTilt = 47;
103
104//  HEAD TWIST
105void headTwist() {
106  for (lPos = maxPos; lPos >= minPos; lPos -=  servoSpeed) {
107//    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
108    constrain(lPos,  minPos, maxPos);
109//    constrain(rPos, minPos, maxPos);
110    HeadTwist.write(lPos);
111//    HeadTilt.write(rPos);
112    delay(delayTimeA);
113    distanceCheck();
114  }
115  
116  delay(delayTimeB);
117  for (lPos = minPos; lPos <= maxPos; lPos  += servoSpeed) {
118//    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
119    constrain(lPos, minPos, maxPos);
120//    constrain(rPos, minPos, maxPos);
121    HeadTwist.write(lPos);
122//    HeadTilt.write(rPos);
123    delay(delayTimeA);
124    distanceCheck();
125  }
126  
127}
128// HEAD TILT
129void headTilt() {
130  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed) {
131    rPos = map(lPos,  minPos, maxPos, maxPos, minPos);
132    constrain(lPos, minPos, maxPos);
133    constrain(rPos,  minPos, maxPos);
134//    HeadTwist.write(lPos);
135    HeadTilt.write(rPos);
136    delay(delayTimeA);
137  }
138  
139}
140
141void AllLegsFlex() {
142  // Forward  Leg Swing
143  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed) {
144    rPos  = map(lPos, minPos, maxPos, maxPos, minPos);
145    constrain(lPos, minPos, maxPos);
146    constrain(rPos, minPos, maxPos);
147    LFA.write(lPos);
148    LMA.write(rPos);
149    LRA.write(lPos);
150    RFA.write(rPos);
151    RMA.write(lPos);
152    RRA.write(rPos);
153    LFB.write(lPos);
154    LMB.write(rPos);
155    LRB.write(lPos);
156    RFB.write(rPos);
157    RMB.write(lPos);
158    RRB.write(rPos);
159    LFC.write(lPos);
160    LMC.write(rPos);
161    LRC.write(lPos);
162    RFC.write(rPos);
163    RMC.write(lPos);
164    RRC.write(rPos);
165    delay(delayTimeA);
166  }
167  // Rearward Leg Swing
168  for (lPos = minPos;  lPos <= maxPos; lPos += servoSpeed) {
169    rPos = map(lPos, minPos, maxPos, maxPos,  minPos);
170    constrain(lPos, minPos, maxPos);
171    constrain(rPos, minPos,  maxPos);
172    LFA.write(lPos);
173    LMA.write(rPos);
174    LRA.write(lPos);
175    RFA.write(rPos);
176    RMA.write(lPos);
177    RRA.write(rPos);
178    LFB.write(lPos);
179    LMB.write(rPos);
180    LRB.write(lPos);
181    RFB.write(rPos);
182    RMB.write(lPos);
183    RRB.write(rPos);
184    LFC.write(lPos);
185    LMC.write(rPos);
186    LRC.write(lPos);
187    RFC.write(rPos);
188    RMC.write(lPos);
189    RRC.write(rPos);
190    delay(delayTimeA);
191  }
192}
193
194void updownLegsFlex() {
195  // Upward Leg Swing
196  for (lPos  = maxPos; lPos >= minPos; lPos -= servoSpeed) {
197    rPos = map(lPos, minPos,  maxPos, maxPos, minPos);
198    constrain(lPos, minPos, maxPos);
199    constrain(rPos,  minPos, maxPos);
200    LFA.write(trueMidPos);
201    LMA.write(trueMidPos);
202    LRA.write(trueMidPos);
203    RFA.write(trueMidPos);
204    RMA.write(trueMidPos);
205    RRA.write(trueMidPos);
206    LFB.write(lPos + bSectionlSideModifier);
207    LMB.write(lPos  + bSectionlSideModifier);
208    LRB.write(lPos + bSectionlSideModifier);
209    RFB.write(rPos  + bSectionrSideModifier);
210    RMB.write(rPos + bSectionrSideModifier);
211    RRB.write(rPos  + bSectionrSideModifier);
212    LFC.write(lPos + cSectionlSideModifier);
213    LMC.write(lPos  + cSectionlSideModifier);
214    LRC.write(lPos + cSectionlSideModifier);
215    RFC.write(rPos  + cSectionrSideModifier);
216    RMC.write(rPos + cSectionrSideModifier);
217    RRC.write(rPos  + cSectionrSideModifier);
218    delay(delayTimeA);
219  }
220  // Downward Leg  Swing
221  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed) {
222    rPos  = map(lPos, minPos, maxPos, maxPos, minPos);
223    constrain(lPos, minPos, maxPos);
224    constrain(rPos, minPos, maxPos);
225    LFA.write(trueMidPos);
226    LMA.write(trueMidPos);
227    LRA.write(trueMidPos);
228    RFA.write(trueMidPos);
229    RMA.write(trueMidPos);
230    RRA.write(trueMidPos);
231    LFB.write(lPos + bSectionlSideModifier);
232    LMB.write(lPos  + bSectionlSideModifier);
233    LRB.write(lPos + bSectionlSideModifier);
234    RFB.write(rPos  + bSectionrSideModifier);
235    RMB.write(rPos + bSectionrSideModifier);
236    RRB.write(rPos  + bSectionrSideModifier);
237    LFC.write(lPos + cSectionlSideModifier);
238    LMC.write(lPos  + cSectionlSideModifier);
239    LRC.write(lPos + cSectionlSideModifier);
240    RFC.write(rPos  + cSectionrSideModifier);
241    RMC.write(rPos + cSectionrSideModifier);
242    RRC.write(rPos  + cSectionrSideModifier);
243    delay(delayTimeA);
244  }
245}
246
247void tipLegsFlex()  {
248  // tip out Leg Swing
249  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed)  {
250    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
251    constrain(lPos,  minPos, maxPos);
252    constrain(rPos, minPos, maxPos);
253    LFA.write(trueMidPos);
254    LMA.write(trueMidPos);
255    LRA.write(trueMidPos);
256    RFA.write(trueMidPos);
257    RMA.write(trueMidPos);
258    RRA.write(trueMidPos);
259    LFB.write(midPos);
260    LMB.write(midPos);
261    LRB.write(midPos);
262    RFB.write(midPos);
263    RMB.write(midPos);
264    RRB.write(midPos);
265    LFC.write(lPos);
266    LMC.write(lPos);
267    LRC.write(lPos);
268    RFC.write(rPos);
269    RMC.write(rPos);
270    RRC.write(rPos);
271    delay(delayTimeA);
272  }
273  // tip in Leg Swing
274  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed)  {
275    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
276    constrain(lPos,  minPos, maxPos);
277    constrain(rPos, minPos, maxPos);
278    LFA.write(trueMidPos);
279    LMA.write(trueMidPos);
280    LRA.write(trueMidPos);
281    RFA.write(trueMidPos);
282    RMA.write(trueMidPos);
283    RRA.write(trueMidPos);
284    LFB.write(midPos);
285    LMB.write(midPos);
286    LRB.write(midPos);
287    RFB.write(midPos);
288    RMB.write(midPos);
289    RRB.write(midPos);
290    LFC.write(lPos);
291    LMC.write(lPos);
292    LRC.write(lPos);
293    RFC.write(rPos);
294    RMC.write(rPos);
295    RRC.write(rPos);
296    delay(delayTimeA);
297  }
298}
299
300void midLegsFlex() {
301  // mid down Leg Swing
302  for (lPos =  maxPos; lPos >= minPos; lPos -= servoSpeed) {
303    rPos = map(lPos, minPos, maxPos,  maxPos, minPos);
304    constrain(lPos, minPos, maxPos);
305    constrain(rPos,  minPos, maxPos);
306    LFA.write(trueMidPos);
307    LMA.write(trueMidPos);
308    LRA.write(trueMidPos);
309    RFA.write(trueMidPos);
310    RMA.write(trueMidPos);
311    RRA.write(trueMidPos);
312    LFB.write(midPos);
313    LMB.write(midPos);
314    LRB.write(midPos);
315    RFB.write(midPos);
316    RMB.write(midPos);
317    RRB.write(midPos);
318    LFC.write(lPos);
319    LMC.write(lPos);
320    LRC.write(lPos);
321    RFC.write(rPos);
322    RMC.write(rPos);
323    RRC.write(rPos);
324    delay(delayTimeA);
325  }
326  // mid up Leg Swing
327  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed)  {
328    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
329    constrain(lPos,  minPos, maxPos);
330    constrain(rPos, minPos, maxPos);
331    LFA.write(trueMidPos);
332    LMA.write(trueMidPos);
333    LRA.write(trueMidPos);
334    RFA.write(trueMidPos);
335    RMA.write(trueMidPos);
336    RRA.write(trueMidPos);
337    LFB.write(midPos);
338    LMB.write(midPos);
339    LRB.write(midPos);
340    RFB.write(midPos);
341    RMB.write(midPos);
342    RRB.write(midPos);
343    LFC.write(lPos);
344    LMC.write(lPos);
345    LRC.write(lPos);
346    RFC.write(rPos);
347    RMC.write(rPos);
348    RRC.write(rPos);
349    delay(delayTimeA);
350  }
351  delay(delayTimeB);
352}
353
354void setup() {
355  Serial.begin(9600);
356  LFA.attach(ServoPinLFA);
357  LMA.attach(ServoPinLMA);
358  LRA.attach(ServoPinLRA);
359  RFA.attach(ServoPinRFA);
360  RMA.attach(ServoPinRMA);
361  RRA.attach(ServoPinRRA);
362  LFB.attach(ServoPinLFB);
363  LMB.attach(ServoPinLMB);
364  LRB.attach(ServoPinLRB);
365  RFB.attach(ServoPinRFB);
366  RMB.attach(ServoPinRMB);
367  RRB.attach(ServoPinRRB);
368  LFC.attach(ServoPinLFC);
369  LMC.attach(ServoPinLMC);
370  LRC.attach(ServoPinLRC);
371  RFC.attach(ServoPinRFC);
372  RMC.attach(ServoPinRMC);
373  RRC.attach(ServoPinRRC);
374  HeadTwist.attach(ServoPinHeadTwist);
375  HeadTilt.attach(ServoPinHeadTilt);
376}
377
378void  loop() {
379  //  AllLegsFlex();
380  //delay(delayTimeB);
381//  updownLegsFlex();
382//delay(delayTimeB);
383  // tipLegsFlex();
384  //delay(delayTimeB);
385  // midLegsFlex();
386   headTwist();
387   delay(delayTimeB);
388//   headTilt();
389// delay(delayTimeB);
390//   distanceCheck();
391//  delay(delayTimeB);
392}
393
394

/* MEGA BREAD -- SIGHT
###################################
# Datatypes  (KEYWORD1)
###################################
NewPing  KEYWORD1
###################################
#  Methods and Functions (KEYWORD2)
###################################
ping  KEYWORD2
ping_in KEYWORD2
ping_cm KEYWORD2
ping_median KEYWORD2
ping_timer  KEYWORD2
check_timer KEYWORD2
timer_us  KEYWORD2
timer_ms  KEYWORD2
timer_stop  KEYWORD2
convert_in  KEYWORD2
convert_cm  KEYWORD2
###################################
#  Constants (LITERAL1)
###################################*/
#include <NewPing.h>
#define  TRIGGER_PIN  53  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define  ECHO_PIN     52  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define  MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum  sensor distance is rated at 400-500cm.
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);  // NewPing setup of pins and maximum distance.

/*SERVO SETUP - MEGA BREAD
  Usable pins on the MEGA
  Servos  analogWrite Pins  Timers used
  1 - 12  not pins 44,45,46 Timer 5
  13 - 24 not pins 11,12,44,45,46 Timers 1 & 5
  24 - 36 not pins 6,7,8,11,12,44,45,46 Timers 1,4 & 5
  37 - 48 not pins 2,3,5,6,7,8,11,12,44,45,46  Timers 1,3,4 & 5*/
#include <Servo.h>
int legCount = 6;
int servoSpeed  = 2;
int delayTimeA = 50;
int delayTimeB = 100;
int trueMidPos = 90;
int  minPos = 60;
int maxPos = 110;
int midPos = ((maxPos - minPos) / 2) + minPos;
int  lPos = midPos;
int rPos = midPos;
int aSectionlSideModifier = 0;
int aSectionrSideModifier  = -0;
int bSectionlSideModifier = 0;
int bSectionrSideModifier = -0;
int  cSectionlSideModifier = 10;
int cSectionrSideModifier = -10;
Servo LFA;
Servo  LFB;
Servo LFC;
int ServoPinLFA = 22;
int ServoPinLFB = 23;
int ServoPinLFC  = 24;
Servo LMA;
Servo LMB;
Servo LMC;
int ServoPinLMA = 26;
int  ServoPinLMB = 27;
int ServoPinLMC = 28;
Servo LRA;
Servo LRB;
Servo  LRC;
int ServoPinLRA = 30;
int ServoPinLRB = 31;
int ServoPinLRC = 32;
Servo  RFA;
Servo RFB;
Servo RFC;
int ServoPinRFA = 34;
int ServoPinRFB = 35;
int  ServoPinRFC = 36;
Servo RMA;
Servo RMB;
Servo RMC;
int ServoPinRMA =  38;
int ServoPinRMB = 39;
int ServoPinRMC = 40;
Servo RRA;
Servo RRB;
Servo  RRC;
int ServoPinRRA = 42;
int ServoPinRRB = 43;
int ServoPinRRC = 44;

void  distanceCheck() {
  delay(delayTimeA); // Wait delayTimeB in MS. 29ms should  be the shortest delay between pings.
  Serial.print("Ping: ");
  Serial.print(sonar.ping_cm());  // Send ping, get distance in cm and print result (0 = outside set distance range)
  Serial.println("cm");
}


//Head Setup
Servo HeadTwist;
Servo  HeadTilt;
int ServoPinHeadTwist = 46;
int ServoPinHeadTilt = 47;

//  HEAD TWIST
void headTwist() {
  for (lPos = maxPos; lPos >= minPos; lPos -=  servoSpeed) {
//    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos,  minPos, maxPos);
//    constrain(rPos, minPos, maxPos);
    HeadTwist.write(lPos);
//    HeadTilt.write(rPos);
    delay(delayTimeA);
    distanceCheck();
  }
  
  delay(delayTimeB);
  for (lPos = minPos; lPos <= maxPos; lPos  += servoSpeed) {
//    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos, minPos, maxPos);
//    constrain(rPos, minPos, maxPos);
    HeadTwist.write(lPos);
//    HeadTilt.write(rPos);
    delay(delayTimeA);
    distanceCheck();
  }
  
}
// HEAD TILT
void headTilt() {
  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed) {
    rPos = map(lPos,  minPos, maxPos, maxPos, minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos,  minPos, maxPos);
//    HeadTwist.write(lPos);
    HeadTilt.write(rPos);
    delay(delayTimeA);
  }
  
}

void AllLegsFlex() {
  // Forward  Leg Swing
  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed) {
    rPos  = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos, minPos, maxPos);
    LFA.write(lPos);
    LMA.write(rPos);
    LRA.write(lPos);
    RFA.write(rPos);
    RMA.write(lPos);
    RRA.write(rPos);
    LFB.write(lPos);
    LMB.write(rPos);
    LRB.write(lPos);
    RFB.write(rPos);
    RMB.write(lPos);
    RRB.write(rPos);
    LFC.write(lPos);
    LMC.write(rPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(lPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
  // Rearward Leg Swing
  for (lPos = minPos;  lPos <= maxPos; lPos += servoSpeed) {
    rPos = map(lPos, minPos, maxPos, maxPos,  minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos, minPos,  maxPos);
    LFA.write(lPos);
    LMA.write(rPos);
    LRA.write(lPos);
    RFA.write(rPos);
    RMA.write(lPos);
    RRA.write(rPos);
    LFB.write(lPos);
    LMB.write(rPos);
    LRB.write(lPos);
    RFB.write(rPos);
    RMB.write(lPos);
    RRB.write(rPos);
    LFC.write(lPos);
    LMC.write(rPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(lPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
}

void updownLegsFlex() {
  // Upward Leg Swing
  for (lPos  = maxPos; lPos >= minPos; lPos -= servoSpeed) {
    rPos = map(lPos, minPos,  maxPos, maxPos, minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos,  minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(lPos + bSectionlSideModifier);
    LMB.write(lPos  + bSectionlSideModifier);
    LRB.write(lPos + bSectionlSideModifier);
    RFB.write(rPos  + bSectionrSideModifier);
    RMB.write(rPos + bSectionrSideModifier);
    RRB.write(rPos  + bSectionrSideModifier);
    LFC.write(lPos + cSectionlSideModifier);
    LMC.write(lPos  + cSectionlSideModifier);
    LRC.write(lPos + cSectionlSideModifier);
    RFC.write(rPos  + cSectionrSideModifier);
    RMC.write(rPos + cSectionrSideModifier);
    RRC.write(rPos  + cSectionrSideModifier);
    delay(delayTimeA);
  }
  // Downward Leg  Swing
  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed) {
    rPos  = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos, minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(lPos + bSectionlSideModifier);
    LMB.write(lPos  + bSectionlSideModifier);
    LRB.write(lPos + bSectionlSideModifier);
    RFB.write(rPos  + bSectionrSideModifier);
    RMB.write(rPos + bSectionrSideModifier);
    RRB.write(rPos  + bSectionrSideModifier);
    LFC.write(lPos + cSectionlSideModifier);
    LMC.write(lPos  + cSectionlSideModifier);
    LRC.write(lPos + cSectionlSideModifier);
    RFC.write(rPos  + cSectionrSideModifier);
    RMC.write(rPos + cSectionrSideModifier);
    RRC.write(rPos  + cSectionrSideModifier);
    delay(delayTimeA);
  }
}

void tipLegsFlex()  {
  // tip out Leg Swing
  for (lPos = maxPos; lPos >= minPos; lPos -= servoSpeed)  {
    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos,  minPos, maxPos);
    constrain(rPos, minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(midPos);
    LMB.write(midPos);
    LRB.write(midPos);
    RFB.write(midPos);
    RMB.write(midPos);
    RRB.write(midPos);
    LFC.write(lPos);
    LMC.write(lPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(rPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
  // tip in Leg Swing
  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed)  {
    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos,  minPos, maxPos);
    constrain(rPos, minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(midPos);
    LMB.write(midPos);
    LRB.write(midPos);
    RFB.write(midPos);
    RMB.write(midPos);
    RRB.write(midPos);
    LFC.write(lPos);
    LMC.write(lPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(rPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
}

void midLegsFlex() {
  // mid down Leg Swing
  for (lPos =  maxPos; lPos >= minPos; lPos -= servoSpeed) {
    rPos = map(lPos, minPos, maxPos,  maxPos, minPos);
    constrain(lPos, minPos, maxPos);
    constrain(rPos,  minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(midPos);
    LMB.write(midPos);
    LRB.write(midPos);
    RFB.write(midPos);
    RMB.write(midPos);
    RRB.write(midPos);
    LFC.write(lPos);
    LMC.write(lPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(rPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
  // mid up Leg Swing
  for (lPos = minPos; lPos <= maxPos; lPos += servoSpeed)  {
    rPos = map(lPos, minPos, maxPos, maxPos, minPos);
    constrain(lPos,  minPos, maxPos);
    constrain(rPos, minPos, maxPos);
    LFA.write(trueMidPos);
    LMA.write(trueMidPos);
    LRA.write(trueMidPos);
    RFA.write(trueMidPos);
    RMA.write(trueMidPos);
    RRA.write(trueMidPos);
    LFB.write(midPos);
    LMB.write(midPos);
    LRB.write(midPos);
    RFB.write(midPos);
    RMB.write(midPos);
    RRB.write(midPos);
    LFC.write(lPos);
    LMC.write(lPos);
    LRC.write(lPos);
    RFC.write(rPos);
    RMC.write(rPos);
    RRC.write(rPos);
    delay(delayTimeA);
  }
  delay(delayTimeB);
}

void setup() {
  Serial.begin(9600);
  LFA.attach(ServoPinLFA);
  LMA.attach(ServoPinLMA);
  LRA.attach(ServoPinLRA);
  RFA.attach(ServoPinRFA);
  RMA.attach(ServoPinRMA);
  RRA.attach(ServoPinRRA);
  LFB.attach(ServoPinLFB);
  LMB.attach(ServoPinLMB);
  LRB.attach(ServoPinLRB);
  RFB.attach(ServoPinRFB);
  RMB.attach(ServoPinRMB);
  RRB.attach(ServoPinRRB);
  LFC.attach(ServoPinLFC);
  LMC.attach(ServoPinLMC);
  LRC.attach(ServoPinLRC);
  RFC.attach(ServoPinRFC);
  RMC.attach(ServoPinRMC);
  RRC.attach(ServoPinRRC);
  HeadTwist.attach(ServoPinHeadTwist);
  HeadTilt.attach(ServoPinHeadTilt);
}

void  loop() {
  //  AllLegsFlex();
  //delay(delayTimeB);
//  updownLegsFlex();
//delay(delayTimeB);
  // tipLegsFlex();
  //delay(delayTimeB);
  // midLegsFlex();
   headTwist();
   delay(delayTimeB);
//   headTilt();
// delay(delayTimeB);
//   distanceCheck();
//  delay(delayTimeB);
}

MEGA BREAD - Hank the Hexabot Code

nix

Not yet published due to development issues for pickup and delivery of the bot from the air.

Downloadable files

MEGA BREAD - Hank the Hexabot

Assembly diagram

MEGA BREAD - Hank the Hexabot

Assembly diagram

MEGA BREAD - Hank the Hexabot

Comments

Only logged in users can leave comments

Pigeon-Kicker

0 Followers

•

0 Projects

Work attribution

Intro