Traffic Advisor (arrow stick)

8 light, rear of vehicle traffic advisor controller, with 4 modes and 14 patterns.

Mar 29, 2020

•

2446 views

•

5 respects

passenger vehicles

emergency

traffic advisor

Components and supplies

3 mm LED: Yellow

3 mm LED: Green

Pushbutton Switch, Momentary

Adafruit NeoPixel Digital RGB LED Strip 144 LED, 1m White

Relay Shield for Particle Photon I²C 8-Channel SPDT 10-Amp

Hook Up Wire Kit, 22 AWG

Arduino Nano R3

Resistor 220 ohm

Tools and machines

Soldering iron (generic)

Solder Wire, Lead Free

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Project description

Code

c_cpp

.INO

1#include <EEPROM.h>
2int warning_button = A5;
3int left_button = 2;
4int  center_button = 4;
5int right_button = 3;
6int off_button = A0;
7int pattern_button  = A2;
8int statuslight = 13;
9int LEDright[] = {5, 6, 7, 8, 9, 10, 11, 12};
10int  LEDleft[] = {12, 11, 10, 9, 8, 7, 6, 5};
11int centerleft[] = {9, 10, 11, 12};
12int  centerright[] = {8, 7, 6, 5};
13int light = 0;
14int counter = 1;
15int pattern_count  = 0;
16int warning_count = EEPROM.read(0);
17long lasttimer = 0;
18static long  timer = 200;
19static long timer2 = 300;
20static long switch_timer = 4000;
21#define  LEFTside 0x0
22#define RIGHTside 0x1
23byte whichLED = LEFTside;
24byte LEFT_state  = LOW;
25byte RIGHT_state = LOW;
26unsigned long switchDelay = 1000;
27unsigned  long switchDelay2 = 500;
28unsigned long strobeDelay = 75;
29unsigned long strobeWait  = strobeDelay;
30unsigned long waitUntilSwitch = switchDelay;
31unsigned long  sequenceStartTime;
32//----------------------------------------------------------------------------
33void  setup() {
34  Serial.begin(9600);
35  for (int i = 0; i < 8; i++) {
36    pinMode(LEDright[i],  OUTPUT);
37  }
38  pinMode(statuslight, OUTPUT);
39  pinMode(warning_button,  INPUT_PULLUP);
40  pinMode(left_button, INPUT_PULLUP);
41  pinMode(center_button,  INPUT_PULLUP);
42  pinMode(right_button, INPUT_PULLUP);
43  pinMode(off_button,  INPUT_PULLUP);
44  pinMode(pattern_button, INPUT_PULLUP);
45  pinMode(12, OUTPUT);
46  pinMode(11, OUTPUT);
47  pinMode(10, OUTPUT);
48  pinMode(9, OUTPUT);
49  pinMode(8,  OUTPUT);
50  pinMode(7, OUTPUT);
51  pinMode(6, OUTPUT);
52  pinMode(5, OUTPUT);
53}
54//------------------------------------------------------------------------
55void  loop() {
56  digitalWrite(13, HIGH);
57  delayMicroseconds(10); // Approximately  10% duty cycle @ 1KHz
58  digitalWrite(13, LOW);
59  delayMicroseconds(1000 -  10);
60  if (digitalRead(pattern_button) == HIGH)
61  {
62    delay(500);
63    warning_count++;
64    if (warning_count > 10) {
65      warning_count = 1;
66    }
67  }
68  if (digitalRead(warning_button) == HIGH)
69  {
70    delay(50);
71    pattern_count = 1; 
72  }
73  if (digitalRead(left_button) == HIGH)
74  {
75    delay(50);
76    pattern_count = 2;
77  }
78  if (digitalRead(center_button)  == HIGH)
79  {
80    delay(50);
81    pattern_count = 3;
82  }
83  if (digitalRead(right_button)  == HIGH)
84  {
85    delay(50);
86    pattern_count = 4;
87  }
88  if (digitalRead(off_button)  == HIGH)
89  {
90    delay(50);
91    pattern_count = 0;
92    EEPROM.update(0,warning_count);
93  }
94  switch (pattern_count) {
95    case 0:
96      pattern_off();
97      break;
98    case 1:
99      traffic_left();
100      break;
101    case 2:
102      traffic_center();
103      break;
104    case 3:
105      traffic_right();
106      break;
107    case  4:
108      traffic_warning();
109      break;
110  }
111}
112void pattern_off()  {
113  for (int i = 0; i <= 7; i++) {
114    digitalWrite(LEDright[i], LOW);
115  }
116}
117void traffic_left() {
118  unsigned long currenttimer = millis();
119  if (currenttimer - lasttimer >= timer) {
120    lasttimer = currenttimer;
121    for (int i = 0; i <= 7; i++) {
122      digitalWrite(LEDright[i], LOW);
123    }
124    digitalWrite(LEDleft[light], LOW);
125    light = light + counter;
126    if (light > 7) {
127      light = 0;
128      counter = 1;
129    }
130    digitalWrite(LEDleft[light],  HIGH);
131  }
132}
133void traffic_center() {
134  unsigned long currenttimer =  millis();
135  if (currenttimer - lasttimer >= timer2) {
136    lasttimer = currenttimer;
137    for (int i = 0; i <= 7; i++) {
138      digitalWrite(LEDright[i], LOW);
139    }
140    digitalWrite(centerright[light], LOW);
141    digitalWrite(centerleft[light],  LOW);
142    light = light + counter;
143    if (light > 3) {
144      light = 0;
145      counter = 1;
146    }
147    digitalWrite(centerright[light], HIGH);
148    digitalWrite(centerleft[light],  HIGH);
149  }
150}
151void traffic_right() {
152  unsigned long currenttimer = millis();
153  if (currenttimer - lasttimer >= timer) {
154    lasttimer = currenttimer;
155    for (int i = 0; i <= 7; i++) {
156      digitalWrite(LEDright[i], LOW);
157    }
158    digitalWrite(LEDright[light], LOW);
159    light = light + counter;
160    if (light > 7) {
161      light = 0;
162      counter = 1;
163    }
164    digitalWrite(LEDright[light],  HIGH);
165  }
166}
167void traffic_warning() {
168  switch (warning_count) {
169    case 1:
170      even_odd_flash();
171      break;
172    case 2:
173      half_half();
174      break;
175    case 3:
176      half_half_flash();
177      break;
178    case  4:
179      two_by_two();
180      break;
181    case 5:
182      two_by_two_parallel();
183      break;
184    case 6:
185      out_flash();
186      break;
187    case 7:
188      one_center();
189      break;
190    case 8:
191      outboard();
192      break;
193    case 9:
194      inboard();
195      break;
196    case 10:
197      even_odd();
198      break;
199  }
200}
201void even_odd_flash() {
202  for (int i = 0; i <= 7;  i++) {
203    digitalWrite(LEDright[i], LOW);
204  }
205  digitalWrite(12, LEFT_state);
206  digitalWrite(11, RIGHT_state);
207  digitalWrite(10, LEFT_state);
208  digitalWrite(9,  RIGHT_state);
209  digitalWrite(8, LEFT_state);
210  digitalWrite(7, RIGHT_state);
211  digitalWrite(6, LEFT_state);
212  digitalWrite(5, RIGHT_state);
213  if ((long)(millis()  - waitUntilSwitch) >= 0) {
214    LEFT_state = LOW;
215    RIGHT_state = LOW;
216    whichLED = !whichLED;
217    waitUntilSwitch += switchDelay;
218  }
219  if  ((long)(millis() - strobeWait) >= 0) {
220    if (whichLED == LEFTside)
221      LEFT_state  = !LEFT_state;
222    if (whichLED == RIGHTside)
223      RIGHT_state = !RIGHT_state;
224    strobeWait += strobeDelay;
225  }
226}
227void half_half_flash() {
228  for  (int i = 0; i <= 7; i++) {
229    digitalWrite(LEDright[i], LOW);
230  }
231  digitalWrite(12,  LEFT_state);
232  digitalWrite(11, LEFT_state);
233  digitalWrite(10, LEFT_state);
234  digitalWrite(9, LEFT_state);
235  digitalWrite(8, RIGHT_state);
236  digitalWrite(7,  RIGHT_state);
237  digitalWrite(6, RIGHT_state);
238  digitalWrite(5, RIGHT_state);
239  if ((long)(millis() - waitUntilSwitch) >= 0) {
240    LEFT_state = LOW;
241    RIGHT_state  = LOW;
242    whichLED = !whichLED;
243    waitUntilSwitch += switchDelay2;
244  }
245  if ((long)(millis() - strobeWait) >= 0) {
246    if (whichLED == LEFTside)
247      LEFT_state = !LEFT_state;
248    if (whichLED == RIGHTside)
249      RIGHT_state  = !RIGHT_state;
250    strobeWait += strobeDelay;
251  }
252}
253void half_half()  {
254  for (int i = 0; i <= 7; i++) {
255    digitalWrite(LEDright[i], LOW);
256  }
257  long time = millis() - sequenceStartTime;
258  if (time < 250)
259  {
260    digitalWrite(12, HIGH);
261    digitalWrite(11, HIGH);
262    digitalWrite(10,  HIGH);
263    digitalWrite(9, HIGH);
264    digitalWrite(8, LOW);
265    digitalWrite(7,  LOW);
266    digitalWrite(6, LOW);
267    digitalWrite(5, LOW);
268  }
269  else  if (time < 500)
270  {
271    digitalWrite(12, LOW);
272    digitalWrite(11, LOW);
273    digitalWrite(10, LOW);
274    digitalWrite(9, LOW);
275    digitalWrite(8, HIGH);
276    digitalWrite(7, HIGH);
277    digitalWrite(6, HIGH);
278    digitalWrite(5,  HIGH);
279  }
280  else sequenceStartTime = millis();
281}
282void out_flash() {
283  for (int i = 0; i <= 7; i++) {
284    digitalWrite(LEDright[i], LOW);
285  }
286  long time = millis() - sequenceStartTime;
287  if (time < 150)
288  {
289    digitalWrite(12,  HIGH);
290    digitalWrite(11, HIGH);
291    digitalWrite(10, LOW);
292    digitalWrite(9,  LOW);
293    digitalWrite(8, LOW);
294    digitalWrite(7, LOW);
295    digitalWrite(6,  HIGH);
296    digitalWrite(5, HIGH);
297  }
298  else if (time < 300)
299  {
300    digitalWrite(12, LOW);
301    digitalWrite(11, HIGH);
302    digitalWrite(10,  HIGH);
303    digitalWrite(9, LOW);
304    digitalWrite(8, LOW);
305    digitalWrite(7,  HIGH);
306    digitalWrite(6, HIGH);
307    digitalWrite(5, LOW);
308  }
309  else  sequenceStartTime = millis();
310}
311void two_by_two() {
312  for (int i = 0; i  <= 7; i++) {
313    digitalWrite(LEDright[i], LOW);
314  }
315  long time = millis()  - sequenceStartTime;
316  if (time < 150)
317  {
318    digitalWrite(12, HIGH);
319    digitalWrite(11, HIGH);
320    digitalWrite(10, LOW);
321    digitalWrite(9,  LOW);
322    digitalWrite(8, LOW);
323    digitalWrite(7, LOW);
324    digitalWrite(6,  HIGH);
325    digitalWrite(5, HIGH);
326  }
327  else if (time < 300)
328  {
329    digitalWrite(12, LOW);
330    digitalWrite(11, LOW);
331    digitalWrite(10,  HIGH);
332    digitalWrite(9, HIGH);
333    digitalWrite(8, HIGH);
334    digitalWrite(7,  HIGH);
335    digitalWrite(6, LOW);
336    digitalWrite(5, LOW);
337  }
338  else  sequenceStartTime = millis();
339}
340void two_by_two_parallel() {
341  for (int  i = 0; i <= 7; i++) {
342    digitalWrite(LEDright[i], LOW);
343  }
344  long time  = millis() - sequenceStartTime;
345  if (time < 150)
346  {
347    digitalWrite(12,  HIGH);
348    digitalWrite(11, HIGH);
349    digitalWrite(10, LOW);
350    digitalWrite(9,  LOW);
351    digitalWrite(8, HIGH);
352    digitalWrite(7, HIGH);
353    digitalWrite(6,  LOW);
354    digitalWrite(5, LOW);
355  }
356  else if (time < 300)
357  {
358    digitalWrite(12,  LOW);
359    digitalWrite(11, LOW);
360    digitalWrite(10, HIGH);
361    digitalWrite(9,  HIGH);
362    digitalWrite(8, LOW);
363    digitalWrite(7, LOW);
364    digitalWrite(6,  HIGH);
365    digitalWrite(5, HIGH);
366  }
367  else sequenceStartTime = millis();
368}
369void  one_center() {
370  for (int i = 0; i <= 7; i++) {
371    digitalWrite(LEDright[i],  LOW);
372  }
373  long time = millis() - sequenceStartTime;
374  if (time < 500)
375  {
376    digitalWrite(12, HIGH);
377    digitalWrite(11, HIGH);
378    digitalWrite(10,  HIGH);
379    digitalWrite(9, LOW);
380    digitalWrite(8, HIGH);
381    digitalWrite(7,  LOW);
382    digitalWrite(6, LOW);
383    digitalWrite(5, LOW);
384  }
385  else  if (time < 1000)
386  {
387    digitalWrite(12, LOW);
388    digitalWrite(11, LOW);
389    digitalWrite(10, LOW);
390    digitalWrite(9, HIGH);
391    digitalWrite(8,  LOW);
392    digitalWrite(7, HIGH);
393    digitalWrite(6, HIGH);
394    digitalWrite(5,  HIGH);
395  }
396  else sequenceStartTime = millis();
397}
398void outboard() {
399  for (int i = 0; i <= 7; i++) {
400    digitalWrite(LEDright[i], LOW);
401  }
402  long time = millis() - sequenceStartTime;
403  if (time < 200)
404  {
405    digitalWrite(12,  HIGH);
406    digitalWrite(11, HIGH);
407    digitalWrite(6, LOW);
408    digitalWrite(5,  LOW);
409  }
410  else if (time < 400)
411  {
412    digitalWrite(12, LOW);
413    digitalWrite(11, LOW);
414    digitalWrite(6, HIGH);
415    digitalWrite(5,  HIGH);
416  }
417  else sequenceStartTime = millis();
418}
419void inboard() {
420  for (int i = 0; i <= 7; i++) {
421    digitalWrite(LEDright[i], LOW);
422  }
423  long time = millis() - sequenceStartTime;
424  if (time < 200)
425  {
426    digitalWrite(11,  HIGH);
427    digitalWrite(10, HIGH);
428    digitalWrite(9, LOW);
429    digitalWrite(8,  LOW);
430    digitalWrite(7, HIGH);
431    digitalWrite(6, HIGH);
432  }
433  else  if (time < 400)
434  {
435    digitalWrite(11, LOW);
436    digitalWrite(10, LOW);
437    digitalWrite(9, HIGH);
438    digitalWrite(8, HIGH);
439    digitalWrite(7,  LOW);
440    digitalWrite(6, LOW);
441  }
442  else sequenceStartTime = millis();
443}
444void  even_odd() {
445  for (int i = 0; i <= 7; i++) {
446    digitalWrite(LEDright[i],  LOW);
447  }
448  long time = millis() - sequenceStartTime;
449  if (time < 300)
450  {
451    digitalWrite(12, HIGH);
452    digitalWrite(11, LOW);
453    digitalWrite(10,  HIGH);
454    digitalWrite(9, LOW);
455    digitalWrite(8, HIGH);
456    digitalWrite(7,  LOW);
457    digitalWrite(6, HIGH);
458    digitalWrite(5, LOW);
459  }
460  else  if (time < 600)
461  {
462    digitalWrite(12, LOW);
463    digitalWrite(11, HIGH);
464    digitalWrite(10, LOW);
465    digitalWrite(9, HIGH);
466    digitalWrite(8,  LOW);
467    digitalWrite(7, HIGH);
468    digitalWrite(6, LOW);
469    digitalWrite(5,  HIGH);
470  }
471  else sequenceStartTime = millis();
472}

#include <EEPROM.h>
int warning_button = A5;
int left_button = 2;
int  center_button = 4;
int right_button = 3;
int off_button = A0;
int pattern_button  = A2;
int statuslight = 13;
int LEDright[] = {5, 6, 7, 8, 9, 10, 11, 12};
int  LEDleft[] = {12, 11, 10, 9, 8, 7, 6, 5};
int centerleft[] = {9, 10, 11, 12};
int  centerright[] = {8, 7, 6, 5};
int light = 0;
int counter = 1;
int pattern_count  = 0;
int warning_count = EEPROM.read(0);
long lasttimer = 0;
static long  timer = 200;
static long timer2 = 300;
static long switch_timer = 4000;
#define  LEFTside 0x0
#define RIGHTside 0x1
byte whichLED = LEFTside;
byte LEFT_state  = LOW;
byte RIGHT_state = LOW;
unsigned long switchDelay = 1000;
unsigned  long switchDelay2 = 500;
unsigned long strobeDelay = 75;
unsigned long strobeWait  = strobeDelay;
unsigned long waitUntilSwitch = switchDelay;
unsigned long  sequenceStartTime;
//----------------------------------------------------------------------------
void  setup() {
  Serial.begin(9600);
  for (int i = 0; i < 8; i++) {
    pinMode(LEDright[i],  OUTPUT);
  }
  pinMode(statuslight, OUTPUT);
  pinMode(warning_button,  INPUT_PULLUP);
  pinMode(left_button, INPUT_PULLUP);
  pinMode(center_button,  INPUT_PULLUP);
  pinMode(right_button, INPUT_PULLUP);
  pinMode(off_button,  INPUT_PULLUP);
  pinMode(pattern_button, INPUT_PULLUP);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(8,  OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(5, OUTPUT);
}
//------------------------------------------------------------------------
void  loop() {
  digitalWrite(13, HIGH);
  delayMicroseconds(10); // Approximately  10% duty cycle @ 1KHz
  digitalWrite(13, LOW);
  delayMicroseconds(1000 -  10);
  if (digitalRead(pattern_button) == HIGH)
  {
    delay(500);
    warning_count++;
    if (warning_count > 10) {
      warning_count = 1;
    }
  }
  if (digitalRead(warning_button) == HIGH)
  {
    delay(50);
    pattern_count = 1; 
  }
  if (digitalRead(left_button) == HIGH)
  {
    delay(50);
    pattern_count = 2;
  }
  if (digitalRead(center_button)  == HIGH)
  {
    delay(50);
    pattern_count = 3;
  }
  if (digitalRead(right_button)  == HIGH)
  {
    delay(50);
    pattern_count = 4;
  }
  if (digitalRead(off_button)  == HIGH)
  {
    delay(50);
    pattern_count = 0;
    EEPROM.update(0,warning_count);
  }
  switch (pattern_count) {
    case 0:
      pattern_off();
      break;
    case 1:
      traffic_left();
      break;
    case 2:
      traffic_center();
      break;
    case 3:
      traffic_right();
      break;
    case  4:
      traffic_warning();
      break;
  }
}
void pattern_off()  {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
}
void traffic_left() {
  unsigned long currenttimer = millis();
  if (currenttimer - lasttimer >= timer) {
    lasttimer = currenttimer;
    for (int i = 0; i <= 7; i++) {
      digitalWrite(LEDright[i], LOW);
    }
    digitalWrite(LEDleft[light], LOW);
    light = light + counter;
    if (light > 7) {
      light = 0;
      counter = 1;
    }
    digitalWrite(LEDleft[light],  HIGH);
  }
}
void traffic_center() {
  unsigned long currenttimer =  millis();
  if (currenttimer - lasttimer >= timer2) {
    lasttimer = currenttimer;
    for (int i = 0; i <= 7; i++) {
      digitalWrite(LEDright[i], LOW);
    }
    digitalWrite(centerright[light], LOW);
    digitalWrite(centerleft[light],  LOW);
    light = light + counter;
    if (light > 3) {
      light = 0;
      counter = 1;
    }
    digitalWrite(centerright[light], HIGH);
    digitalWrite(centerleft[light],  HIGH);
  }
}
void traffic_right() {
  unsigned long currenttimer = millis();
  if (currenttimer - lasttimer >= timer) {
    lasttimer = currenttimer;
    for (int i = 0; i <= 7; i++) {
      digitalWrite(LEDright[i], LOW);
    }
    digitalWrite(LEDright[light], LOW);
    light = light + counter;
    if (light > 7) {
      light = 0;
      counter = 1;
    }
    digitalWrite(LEDright[light],  HIGH);
  }
}
void traffic_warning() {
  switch (warning_count) {
    case 1:
      even_odd_flash();
      break;
    case 2:
      half_half();
      break;
    case 3:
      half_half_flash();
      break;
    case  4:
      two_by_two();
      break;
    case 5:
      two_by_two_parallel();
      break;
    case 6:
      out_flash();
      break;
    case 7:
      one_center();
      break;
    case 8:
      outboard();
      break;
    case 9:
      inboard();
      break;
    case 10:
      even_odd();
      break;
  }
}
void even_odd_flash() {
  for (int i = 0; i <= 7;  i++) {
    digitalWrite(LEDright[i], LOW);
  }
  digitalWrite(12, LEFT_state);
  digitalWrite(11, RIGHT_state);
  digitalWrite(10, LEFT_state);
  digitalWrite(9,  RIGHT_state);
  digitalWrite(8, LEFT_state);
  digitalWrite(7, RIGHT_state);
  digitalWrite(6, LEFT_state);
  digitalWrite(5, RIGHT_state);
  if ((long)(millis()  - waitUntilSwitch) >= 0) {
    LEFT_state = LOW;
    RIGHT_state = LOW;
    whichLED = !whichLED;
    waitUntilSwitch += switchDelay;
  }
  if  ((long)(millis() - strobeWait) >= 0) {
    if (whichLED == LEFTside)
      LEFT_state  = !LEFT_state;
    if (whichLED == RIGHTside)
      RIGHT_state = !RIGHT_state;
    strobeWait += strobeDelay;
  }
}
void half_half_flash() {
  for  (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  digitalWrite(12,  LEFT_state);
  digitalWrite(11, LEFT_state);
  digitalWrite(10, LEFT_state);
  digitalWrite(9, LEFT_state);
  digitalWrite(8, RIGHT_state);
  digitalWrite(7,  RIGHT_state);
  digitalWrite(6, RIGHT_state);
  digitalWrite(5, RIGHT_state);
  if ((long)(millis() - waitUntilSwitch) >= 0) {
    LEFT_state = LOW;
    RIGHT_state  = LOW;
    whichLED = !whichLED;
    waitUntilSwitch += switchDelay2;
  }
  if ((long)(millis() - strobeWait) >= 0) {
    if (whichLED == LEFTside)
      LEFT_state = !LEFT_state;
    if (whichLED == RIGHTside)
      RIGHT_state  = !RIGHT_state;
    strobeWait += strobeDelay;
  }
}
void half_half()  {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 250)
  {
    digitalWrite(12, HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(10,  HIGH);
    digitalWrite(9, HIGH);
    digitalWrite(8, LOW);
    digitalWrite(7,  LOW);
    digitalWrite(6, LOW);
    digitalWrite(5, LOW);
  }
  else  if (time < 500)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(5,  HIGH);
  }
  else sequenceStartTime = millis();
}
void out_flash() {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 150)
  {
    digitalWrite(12,  HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9,  LOW);
    digitalWrite(8, LOW);
    digitalWrite(7, LOW);
    digitalWrite(6,  HIGH);
    digitalWrite(5, HIGH);
  }
  else if (time < 300)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10,  HIGH);
    digitalWrite(9, LOW);
    digitalWrite(8, LOW);
    digitalWrite(7,  HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(5, LOW);
  }
  else  sequenceStartTime = millis();
}
void two_by_two() {
  for (int i = 0; i  <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time = millis()  - sequenceStartTime;
  if (time < 150)
  {
    digitalWrite(12, HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9,  LOW);
    digitalWrite(8, LOW);
    digitalWrite(7, LOW);
    digitalWrite(6,  HIGH);
    digitalWrite(5, HIGH);
  }
  else if (time < 300)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10,  HIGH);
    digitalWrite(9, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(7,  HIGH);
    digitalWrite(6, LOW);
    digitalWrite(5, LOW);
  }
  else  sequenceStartTime = millis();
}
void two_by_two_parallel() {
  for (int  i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time  = millis() - sequenceStartTime;
  if (time < 150)
  {
    digitalWrite(12,  HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9,  LOW);
    digitalWrite(8, HIGH);
    digitalWrite(7, HIGH);
    digitalWrite(6,  LOW);
    digitalWrite(5, LOW);
  }
  else if (time < 300)
  {
    digitalWrite(12,  LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, HIGH);
    digitalWrite(9,  HIGH);
    digitalWrite(8, LOW);
    digitalWrite(7, LOW);
    digitalWrite(6,  HIGH);
    digitalWrite(5, HIGH);
  }
  else sequenceStartTime = millis();
}
void  one_center() {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i],  LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 500)
  {
    digitalWrite(12, HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(10,  HIGH);
    digitalWrite(9, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(7,  LOW);
    digitalWrite(6, LOW);
    digitalWrite(5, LOW);
  }
  else  if (time < 1000)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, HIGH);
    digitalWrite(8,  LOW);
    digitalWrite(7, HIGH);
    digitalWrite(6, HIGH);
    digitalWrite(5,  HIGH);
  }
  else sequenceStartTime = millis();
}
void outboard() {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 200)
  {
    digitalWrite(12,  HIGH);
    digitalWrite(11, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(5,  LOW);
  }
  else if (time < 400)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, LOW);
    digitalWrite(6, HIGH);
    digitalWrite(5,  HIGH);
  }
  else sequenceStartTime = millis();
}
void inboard() {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i], LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 200)
  {
    digitalWrite(11,  HIGH);
    digitalWrite(10, HIGH);
    digitalWrite(9, LOW);
    digitalWrite(8,  LOW);
    digitalWrite(7, HIGH);
    digitalWrite(6, HIGH);
  }
  else  if (time < 400)
  {
    digitalWrite(11, LOW);
    digitalWrite(10, LOW);
    digitalWrite(9, HIGH);
    digitalWrite(8, HIGH);
    digitalWrite(7,  LOW);
    digitalWrite(6, LOW);
  }
  else sequenceStartTime = millis();
}
void  even_odd() {
  for (int i = 0; i <= 7; i++) {
    digitalWrite(LEDright[i],  LOW);
  }
  long time = millis() - sequenceStartTime;
  if (time < 300)
  {
    digitalWrite(12, HIGH);
    digitalWrite(11, LOW);
    digitalWrite(10,  HIGH);
    digitalWrite(9, LOW);
    digitalWrite(8, HIGH);
    digitalWrite(7,  LOW);
    digitalWrite(6, HIGH);
    digitalWrite(5, LOW);
  }
  else  if (time < 600)
  {
    digitalWrite(12, LOW);
    digitalWrite(11, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(9, HIGH);
    digitalWrite(8,  LOW);
    digitalWrite(7, HIGH);
    digitalWrite(6, LOW);
    digitalWrite(5,  HIGH);
  }
  else sequenceStartTime = millis();
}

Downloadable files

schematic

Comments

Only logged in users can leave comments

dylanraymond

0 Followers

•

0 Projects

Intro