This should work...
int arrowArray[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; // arrow lights
int arrowLen = 11; //the number of lights in the array above
int arrowCount = 0; //keeps the state of the arrow lights (which LED is currently on)
int arrowInterval = 100; //milliseconds - interval between changes on the arrow section
int outsideArray[] = {28, 30, 32}; //outside sign lights
int outsideLen = 3; //the number of lights in the array above
int outsideState = LOW; //blink the outside lights variable
int outsideOnTime = 50; //milliseconds - time the outside lights are on for the flash
int outsideOffTime = 200; //milliseconds - time the outside lights are OFF for the flash
unsigned long arrowMillis = 0;
unsigned long outsideMillis = 0;
void doArrow(unsigned long currentMillis) {
//animating the arrow is easy - only one output pin is on at one time (you may connect some pins to more than one light)
if(currentMillis - arrowMillis >= arrowInterval) {
arrowMillis += arrowInterval;
digitalWrite(arrowArray[arrowCount], LOW); //turn off the light that is currently on
arrowCount++; //advance the counter
if(arrowCount >= arrowLen) arrowCount = 0; //if we went off the end, start at the beginning
digitalWrite(arrowArray[arrowCount], HIGH); //turn on the current light
}
}
void outsideAllChange(int LEDState) {
// set the LED with the ledState of the variable:
for (int count = 0; count1 < outsideLen; count++) {
digitalWrite(outsideArray[count], LEDState);
}
}
void doOutside(unsigned long currentMillis) {
//animating the blink/flash is slightly different, because you may want the on/off times to be different
if(outsideState == LOW) {
if(currentMillis - outsideMilllis >= outsideOffTime) {
outsideMillis += outsideOffTime;
outsideState = HIGH;
outsideAllChange(outsideState);
}
} else { //outside lights are on
if(currentMillis - outsideMilllis >= outsideOnTime) {
outsideMillis += outsideOnTime;
outsideState = LOW;
outsideAllChange(outsideState);
}
}
}
void setup() {
// we make all the declarations at once
for (int count = 0; count < arrowLen; count++) {
pinMode(arrowArray[count], OUTPUT);
}
for (int count = 0; count < outsideLen; count++) {
pinMode(outsideArray[count], OUTPUT);
}
}
void loop() {
unsigned long currentMillis = millis();
doArrow(currentMillis);
doOutside(currentMillis);
//since neither of the above functions are "blocking", which means they only take a few nanoseconds or microseconds to run each time
//then we can do more work here
//add some more functions!
}
So, what did I do to your code?
- ran the auto-format on it to get the braces lined up
- changed the names of the two arrays so that there's no "1" in any variable names
- changed the loop() function to just call two functions which do the work
- identified that "count" was the state variable which remembered which arrow light is currently on
- wrote the doArrow() function to just step through the counter once per X milliseconds
- identified that the outside lights are always all-on or all-off and a simple function can do both
- wrote the doOutside() function to give you independent on and off times
Some tricks:
a. The length of the arrays is really important. You don't want to run off the end if you change the number of lights at some point in the future. Make this a variable. Then you can use it in many places in the code.
b. Instead of writing previousMillis = currentMillis, I add the interval. That way it doesn't slip by one or two milliseconds over a long period.
Future ideas:
i. I seem to remember that the Beetlejuice sign was kind of flickery. You could add random stuttering or stumbling by randomly changing the milliseconds interval after each time it's used.
ii. Add more stuff. The Arduino can do a lot of other things at the same time.
iii. Make the lights fade out instead of just going off. This is a pretty big project as you have to use blink-without-delay to simulate PWM on the non-PWM pins. But the different on and off times shown in this example should give you some idea how to do it.