Random Analog and Digital Fireflies using PWM

Last Modified: February 27, 2014, at 10:11 PM
By: garthfielding2
Author: Garth Fielding II

Intro

This sketch is a program to randomly turn on LED's fading them up and down as they turn on/off. The LED's stay on for a random amount of time, stay turned off for a random amount of time, and the fade between is constant. They simulate fireflies in nature or with 2 LED's they can simulate glowing spooky eyes.

You can easily change the intervals that fireflies are randomly chosen from for both the amount of time to wait before turning an LED on and how long to actually keep the LED on. You can also change the maximum number of fireflies that could potentially be on at once.

Background

I discovered the Arduino when I wanted to create a ton of fireflies floating in my yard for Halloween. With the help of a neighbor, we got 3 fireflies working and fading using hareware that I've had for 20+ years: a 555 timer, resistors, capacitors, and some green LED's. It was a huge hit. Afterwards, I thought there's got to be some major advances since 20 years ago when I last did anything with hardware and switched to writing software. So I spoke to another neighbor about a device I'd heard he had built and he introduced me to the Arduino.

Setup in your yard

You can find some 22/4 security wire at many hardware stores. It's 22awg wire with 4 strands. Strip off about one to two feet (30-60cm) of the jacketing (the outside sheath) to expose the 4 wires. Strip just a little bit off the end of each of the 4 wires. Attach 2 LED's to the stripped off ends of the 4 wires (pick a color - one end you'll plug into ground and the other to where you have a current limiting resistor coming from a pin). You can solder the wires if you want or just use electrician's tape to affix the LED's to the wires like I did. Either way, wrap some electrician's tape between and around the exposed wires and LED leads to prevent them from touching each other. It also helps to give weight to the wire. Now, hang the wire from a tree, some paracord, a halloween spider web, etc. such that the jacket of the wire is what is touching the tree branch, etc. The 1-2 feet of really thin wire is hanging down towards the ground. When a slight wind picks up it will cause these wires with a bit of tape and an LED to wiggle back and forth - making them look like they are flying. Or, to make some spooky eyes, use the 22/4 security wire and put 2 red LED's in series on the same pin. Then place these LED's close to each other in the bushes or in a tree.

I've also built into the setup code where every LED that you've plugged in will light briefly when the program starts. This is so you can check your hardware setup in your yard. If you realize a firefly didn't light after you've attached everything and started the Arduino, fix it, then press the reset button on the Arduino and it will light every LED again (it will never exceed MAX_FIREFLIES_ON).

The Circuit

LEDs with current limiting resistors attached from each of the 14 pins to ground.

The perfect firefly in my opinion is a 5mm Flat Top LED with a 2.1v forward voltage and a current of 6mA (this is NOT an ultra-bright LED and is a bit harder to find).

If you can't find that since ultra-bright is common, you can use an ultra-bright 5mm Round Green 3.0-3.4v Forward Voltage 20,000mcd LED with 0.14 mA.

You can also experiment with differing values of resistors to get the brightness that you want.

R = (VS - VL) / I ResistorNeeded = (SourceVoltage - LEDForwardVoltage) / Current

Example of a 1 LED setup (where the LED has a Forward Voltage of 3.4v).
R=(5v-3.4v)/.00014=11428.6=round up to 12000 ohm

Example of a 1 LED setup (where the LED has a Forward Voltage of 2.1v).
R=(5v-2.1v)/.006=483.33=round up to 560 ohm

Example of a 2 LED setup in series (where the LED has a Forward Voltage of 2.1v
R=(5v-2.1v-2.1v)/.006=133.33=round up to 150 ohm
NOTE that you cannot do two 3.1v LED's in series as there's only 5v of power).

Note: Why 6mA for the current instead of 20mA? 2 reasons. 1, it looks better with that particular LED. 2, read the warning below on overloading your Arduino.

Note: Forward Voltages are different for every LED. Your package should tell you what they are. For example: Clear Red and Clear Yellow 1.88-2.0V, Clear Green: 2.89-3.1V, Clear Blue, Clear White and Clear Pink: 3.0-3.2V. If you are unsure of what voltage your LED is rated at, connect it up to a circuit with 5V power, a 10k-ohm resistor and use a voltmeter to measure the voltage across the 2 wires of the LED. That will tell you the approximate voltage. Once you have that setting, do the math above to find a 6ma current and then after building that check the LED with the voltmeter again. The settings for the forward voltage may change slightly if at all.

You can easily build this entire circuit on your breadboard to get it working the way you want then come Halloween just pull the LED's off the board and plug in the 22/4 security wire's you've attached to the LED's and voila, instant fireflies.

Warning on overloading your Arduino

The code below is setup so that it currently outputs to all 14 pins with the maximum number of pins that could ever be on at the same time set to MAX_FIREFLIES_ON.

Ever wondered why every example of lighting up LED's only lights up 10 pins total? While each pin can send 40mA of power through it, the total power sent through the system at one time cannot exceed 150mA. That means that if you were running LED's on more than 7 pins at full brightness (20mA) you could hit that limit. Some people say you have 200mA and in that case you'd be able to have 10 pins running LED's at full brightness simultaneously (like you see on other examples of PWM with LED's).

When I built my circuit, I ran 28 LED's (2 LED's on each pin). Each LED had a Forward Voltage of 2.1volts and the current on each pin was only 6mA (84ma Total for the system). At that rate, you could run at max 25 different pins (on a mega 2560 for example) simultaneously before you'd hit the limit of 150 mA. You want to stay far away from the limit of 150mA though as running at the limit can also ruin your Arduino. I'd recommend you don't exceed around half of the total (for example 84mA out of 150mA). When running, I've found you typically don't come close to hitting MAX_FIREFLIES_ON if there are 14 pins and you have MAX_FIREFLIES_ON set to 7. In that case you'll see around half of that light on average.

For firefly brightness, I've found that 6mA with a 5mm flat top 2.1v LED is plenty bright. I found that an ultra-bright LED with a 3.4v forward voltage looked good with 0.14mA - which is even less. Play around with the brightness and then make note of how many mA you are using.

Which version of Code to use.

There are 2 versions of the code below. They are nearly identical and differ only in how they choose which LED to light up next. What if you setup a set of glowing spooky eyes that took 5 minutes to cycle through all 54 pins on a Mega 2560? That means in one hour you'd have each set of eyes show only 12 times IF every single set of eyes showed once without repeating. If it randomly chose, you could easily have at least one LED out of the 54 show zero times and others that show 24 or more. And if you went to work on Halloween to setup 54 sets of eyes and it's only going to last for 3 hours, you may feel bad that some of the eyes never showed. The second code listing (shuffle sort) solves that problem by making the sequence of lighting up less random. It does this by creating an array of all of the pins and then shuffle sorting that array (like shuffling a deck of cards). It then iterates through that array choosing LED's that are not currently on. When it gets to the end of the array it shuffle sorts the array again.

So why not always pick the second version? Because it's not random anymore it loses something in the way it feels while watching them. Both will work, but I prefer the first code listing more for fireflies and the second if I had a set of glowing spooky eyes.

In short, pick the first version unless you really really want to make sure that every LED must light.


Code Listing #1 - Analog and Digital Fireflies

/*  Analog and Digital Fireflies

    This sketch is a program to randomly turn on LED's fading them up and down as they turn on/off.
    The LED's stay on for a random amount of time, stay turned off for a random amount of time, and the fade between is constant.
    They simulate fireflies in nature or with 2 LED's they can simulate glowing spooky eyes.

    You can easily change the intervals that fireflies are randomly chosen from for both the amount of time to wait before
    turning an LED on and how long to actually keep the LED on.  You can also change the maximum number of fireflies that
    could potentially be on at once.

    created 2014
    by Garth Fielding II



  The circuit:
    LEDs with current limiting resistors attached from each of the 14 pins to ground.
    The perfect firefly in my opinion is a 5mm Flat Top LED with a 2.1v forward voltage
    and a current of 6mA (this is NOT an ultra-bright LED and is a bit harder to find).
    If you can't find that since ultra-bright is common, you can use an ultra-bright
    5mm Round Green 3.0-3.4v Forward Voltage 20,000mcd LED with 0.14 mA.
    You can also experiment with differing values of resistors to get the brightness that you want.

    R = (VS - VL) / I
    ResistorNeeded = (SourceVoltage - LEDForwardVoltage) / Current

    Example of a 1 LED setup (where the LED has a Forward Voltage of 3.4v).
    R=(5v-3.4v)/.00014=11428.6=round up to 12000 ohm
           12000 ohm    LED (3.4v)   Ground
    PIN ---`/\/\/\/`------|>|--------___
                                      -
                                      `
    Example of a 1 LED setup (where the LED has a Forward Voltage of 2.1v).
    R=(5v-2.1v)/.006=483.33=round up to 560 ohm
           12000 ohm    LED (3.4v)   Ground
    PIN ---`/\/\/\/`------|>|--------___
                                      -
                                      `
    Example of a 2 LED setup in series (where the LED has a Forward Voltage of 2.1v
    R=(5v-2.1v-2.1v)/.006=133.33=round up to 150 ohm
            150 ohm    LED (2.1v)     LED (2.1v)    Ground
    PIN ---`/\/\/\/`------|>|------------|>|--------___
                                                     -
                                                     `
    NOTE that you cannot do two 3.1v LED's in series as there's only 5v of power).

    Note: Why 6mA for the current instead of 20mA?
    2 reasons.
    1, it looks better with that particular LED.
    2, read the warning below on overloading your Arduino.

    Note: Forward Voltages are different for every LED.  Your package should tell you what they are.
    For example: Clear Red and Clear Yellow 1.88-2.0V, Clear Green: 2.89-3.1V, Clear Blue, Clear White and Clear Pink: 3.0-3.2V.
    If you are unsure of what voltage your LED is rated at, connect it up to a circuit with 5V power, a 10k-ohm resistor and
    use a voltmeter to measure the voltage across the 2 wires of the LED.  That will tell you the approximate voltage.  Once
    you have that setting, do the math above to find a 6ma current and then after building that check the LED with the voltmeter
    again.  The settings for the forward voltage may change slightly if at all.

    You can easily build this entire circuit on your breadboard to get it working the way you want then come Halloween just pull
    the LED's off the board and plug in the 22/4 security wire's you've attached to the LED's and voila, instant fireflies.

  Setup in your yard   
    You can find some 22/4 security wire at many hardware stores. It's 22awg wire with 4 strands. Strip off about
    one to two feet (30-60cm) of the jacketing (the outside sheath) to expose the 4 wires. Strip just a little bit
    off the end of each of the 4 wires. Attach 2 LED's to the 4 wires (pick a color - one end you'll plug into
    ground and the other to where you have a current limiting resistor coming from a pin). You can solder the wires
    if you want or just use electrician's tape to affix the LED's to the wires like I did. Either way, wrap some
    electrician's tape between and around the exposed wires and LED leads to prevent them from touching each other. Now, hang the wire from
    a tree, some paracord, a halloween spider web, etc. such that the jacket of the wire is what is touching the tree
    branch, etc. The 1-2 feet of really thin wire is hanging down towards the ground. When a slight wind picks up it
    will cause these wires with a bit of tape and an LED to wiggle back and forth - making them look like they are flying.
    Or, to make some spooky eyes, use the 22/4 security wire and put 2 red LED's in series on the same pin.  Then place
    these LED's close to each other in the bushes or in a tree.

    I've also built into the setup code where every LED that you've plugged in will light up briefly. This is so you can
    check your setup. If you realize a firefly didn't light after you've attached everything, fix it and then press the reset
    button on the arduino to have it cycle through all of the LED's again.
 */



/*
  --------------------WARNING ON CHANGING THIS VALUE-------------------
  ---DO NOT BLOW UP YOUR ARDUINO BY SENDING TOO MUCH POWER THROUGH IT---
    The code below is setup so that it currently outputs to all 14 pins with the maximum number of pins that could
    ever be on at the same time set to MAX_FIREFLIES_ON.

    Ever wondered why every example of lighting up LED's only lights up 10 pins total?
    While each pin can send 40mA of power through it, the total power sent through the system at one time cannot exceed 150mA.
    That means that if you were running LED's on more than 7 pins at full brightness (20mA) you could hit that limit.
    Some people say you have 200mA and in that case you'd be able to have 10 pins running LED's at full brightness
    simultaneously (like you see on other examples of PWM with LED's).

    When I built my circuit, I ran 28 LED's (2 LED's on each pin).
    Each LED had a Forward Voltage of 2.1volts and the current on each pin was only 6mA (84ma Total for the system).
    At that rate, you could run at max 25 different pins (on a mega 2560 for example) simultaneously before you'd hit the limit of 150 mA.
    You want to stay far away from the limit of 150mA though as running at the limit can also ruin your Arduino.
    I'd recommend you don't exceed around half of the total (for example 84mA out of 150mA).
    When running, I've found you typically don't come close to hitting MAX_FIREFLIES_ON if there are 14 pins and you have MAX_FIREFLIES_ON set to 7.
    In that case you'll see around half of that light on average.

    For firefly brightness, I've found that 6mA with a 5mm flat top 2.1v LED is plenty bright.
    I found that an ultra-bright LED with a 3.4v forward voltage looked good with 0.14mA - which is even less.
    Play around with the brightness and then make note of how many mA you are using.
  ------------------END WARNING ON CHANGING THIS VALUE-----------------

  Also, realize that this is the MAX.  In usage, you may rarely come close to this.
*/
#define MAX_FIREFLIES_ON 7

//If you get an Arduino Mega 2560 and want to have all 54 pins showing fireflies then uncomment this line.
//#define MEGA_2560 true

//Change these values to determine how long the LED stays OFF and how long it stays ON for the Analog fireflies.
//These values are in milliseconds times 10 (i.e. 27 = 270 milliseconds).
#define ANALOG_MIN_OFF 410
#define ANALOG_MAX_OFF 3000
#define ANALOG_MIN_ON 27
#define ANALOG_MAX_ON 270

//Change these values to determine how long the LED stays OFF and how long it stays ON for the Digital fireflies.
//These values are in milliseconds.
#define DIGITAL_MIN_OFF 4410
#define DIGITAL_MAX_OFF 30000
#define DIGITAL_MIN_ON 210
#define DIGITAL_MAX_ON 2100


//The number of levels of fade before the LED is off with a digital PWM.
//Best to not change these
#define DIGITAL_FADE_INTERVAL 20
#define DIGITAL_FADE_WAIT 20

//Used to indicate the 4 states we can be in.
typedef enum {FADEUP, ON, FADEDOWN, OFF} FireflyState;

typedef struct FireFlyStruct {
  byte pin;                //PWM output pins are 3,5,6,9,10,and 11
  FireflyState state;      //used to determine what state the LED is in, fading up/down or on/off
  unsigned long value;     //used as LED's current value

  //Analog Values
  int duration;            //specifies how long the led will be on/off

  //Digital Values
  unsigned long time;      //Used for time calculations to see if it's time to change state
  boolean toggle;          //Used for toggling the LED on/off with PWM
  unsigned long fade;      //used to calculate how long the led will be on/off for PWM during a fade up/down
  unsigned long fadeWait;  //used to increase the time it takes to fade so it lasts just a little longer.
} Firefly;


#ifdef MEGA_2560
//MEGA 2560 - 54 pins
int analogPins[]  = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 44, 45, 46 };
//int digitalPins[] = { 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 47, 48, 49, 50, 51, 52, 53 };
int allPins[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 };
#else
//UNO R3 - 14 pins
int analogPins[]  = { 3, 5, 6, 9, 10, 11 };
//int digitalPins[] = { 0, 1, 2, 4, 7, 8, 12, 13 };
int allPins[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
#endif

Firefly fireflies[sizeof(allPins)/sizeof(*allPins)];

//Used to determine if the current pin is an Analog or a Digital Pin.
boolean isAnalog(int pin) {
  int length = sizeof(analogPins)/sizeof(*analogPins);
  for (int i=0; i<length; i++) {
    if (analogPins[i] == pin)
      return true;
  }
  return false;
}

//At the end of this function, all of the fireflies will be setup
//with the data they need in order to work properly.
//We also turn on MAX_FIREFLIES_ON fireflies to start us off.
void initialize() {
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    //Why am I using this pointer notation of taking the address of the object
    //and then dereferencing it?  It was to show someone how to do it.
    //If it bothers you, replace every occurrence of "ff->" with "fireflies[i]." and
    //it will run the same.
    Firefly *ff = &fireflies[i];
    ff->pin = allPins[i];
    if (i < MAX_FIREFLIES_ON)
      ff->state = ON;
    else
      ff->state = OFF;
    ff->value = 0;

    //Analog Values
    ff->duration = 0;

    //Digital Values
    ff->time = 0;
    ff->toggle = true;
    ff->fade = 0;
    ff->fadeWait = 0;

    if (i < MAX_FIREFLIES_ON) {
      if (isAnalog(ff->pin) == true)
        ff->duration = random(ANALOG_MIN_ON, ANALOG_MAX_ON);
      else
        ff->value = millis() + random(DIGITAL_MIN_ON, DIGITAL_MAX_ON);
    }
    else {
      if (isAnalog(ff->pin) == true)
        ff->duration = random(ANALOG_MIN_OFF, ANALOG_MAX_OFF);
      else
        ff->value = ff->time + random(DIGITAL_MIN_OFF, DIGITAL_MAX_OFF);
    }
  }
}

//Determine how many LED's are currently ON and if that is equal to MAX_FIREFLIES_ON, return true.
boolean isMaxFireflies() {
  boolean retValue = false;
  int cnt = 0;
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    Firefly *ff = &fireflies[i];
    if (ff->state != OFF)
      cnt++;
  }
  if (cnt >= MAX_FIREFLIES_ON) {
    retValue = true;
  }
  return retValue;
}

//Used for our delay of 10ms for analog.
unsigned long analogDelayTime = 0;

/*
  ANALOG FIREFLIES
  NOTE: (there is a 10ms delay on all analog fireflies).

  There are 4 states the fireflies can be in.
  ON = Keeps the LED on until the counter reaches the duration set for on.
  OFF = Keeps the LED off until the counter reaches the duration set for on.
  FADEUP = Over the course of 500ms, change the LED's brightness about 51 times
  FADEDOWN = Over the course of 500ms, change the LED's brightness about 51 times

  When the firefly has finished it's FADEUP, it will determine a random duration
  for how long to keep the LED on.  Similarly, FADEDOWN determines a random duration
  for how long to keep the LED off.

  If an LED is ready to be turned on (FADEUP) we check to see if we have reached MAX_FIREFLIES_ON.
  If we have, then we set that LED back to the OFF state and tell it to wait again without turning on.
*/
void analogFireflies() {
  //Put a 10ms delay on all of the analog stuff.
  if (millis()-analogDelayTime < 10)
    return;
  analogDelayTime = millis();

  //Iterate through all of the analog fireflies
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    Firefly *ff = &fireflies[i];

    if (isAnalog(ff->pin) == false)
      continue;

    if (ff->state == ON) {              // Pin On
      analogWrite (ff->pin, 255);

      ff->value +=1;
      if (ff->value == ff->duration) {
        ff->state=FADEDOWN;
        ff->value = 255;
      }
    }
    else if (ff->state == OFF) {        // Pin Off
      analogWrite (ff->pin, 0);

      ff->value +=1;
      if (ff->value == ff->duration) {
        if (isMaxFireflies()) {
          ff->value = 0;
          ff->state=OFF;
          ff->duration = random(ANALOG_MIN_OFF, ANALOG_MAX_OFF);
        }
        else {
          ff->state=FADEUP;
          ff->value = 0;
        }
      }
    }
    else if (ff->state == FADEUP){      // Pin Fade Up
      ff->value +=5;
      analogWrite (ff->pin, ff->value);

      if (ff->value == 255) {
        ff->value = 0;
        ff->state=ON;
        ff->duration = random(ANALOG_MIN_ON, ANALOG_MAX_ON);
      }
    }
    else if (ff->state == FADEDOWN) {   // Pin Fade Down
      ff->value -=5;
      analogWrite (ff->pin, ff->value);

      if (ff->value == 0) {
        ff->value = 0;
        ff->state=OFF;
        ff->duration = random(ANALOG_MIN_OFF, ANALOG_MAX_OFF);
      }
    }
  }
}

/*
  DIGITAL FIREFLIES

  There are 4 states the fireflies can be in.
  ON = Keeps the LED on until the current time becomes greater than how long we set to wait for
  OFF = Keeps the LED off until the current time becomes greater than how long we set to wait for
  FADEUP = We turn the LED on and off, changing the duration of time between each to simulate growing brighter
  FADEDOWN = We turn the LED on and off, changing the duration of time between each to simulate growing dimmer

  When the firefly has finished it's FADEUP, it will determine a random duration
  for how long to keep the LED on.  Similarly, FADEDOWN determines a random duration
  for how long to keep the LED off.

  The code for digital fireflies behaves in the same manner as the analog ones with the following exception.
  We have to execute PWM manually.  PWM (Pulse Width Modulation) is where you turn the LED on/off faster than
  the human eye can see a change.  The rate at which you change how long it is off versus on fools the eye into
  thinking that it is dimmer when in fact it is just flashing at a different rate.
  100% brightness = ------------------------------------ = 5 volts on all the time
   75% brightness = ---------___---------___---------___ = Alternating between 5 volts on then 0v off
   50% brightness = ------______------______------______ = Alternating between 5 volts on then 0v off
   25% brightness = ---_________---_________---_________ = Alternating between 5 volts on then 0v off

  The digital fireflies replace the "duration" variable with "time, toggle, fade, & fadeWait".
  These values are used to determine whether to be in the on or off state as the LED flashes in varying
  intervals to simulate growing dimmer or brighter.  For the most part, it works just like the digital fade
  examples you can find
    digitalWrite(pin, LOW);
    delayMicroseconds(period-i);
    digitalWrite(pin, HIGH);
    delayMicroseconds(i);
  The difference being that we don't use delayMicroseconds but do comparisons of time using millis,
  the value of "i" is "ff->value", and we have a flag to determine whether we are setting HIGH or LOW
  with the digitalWrite.

  If an LED is ready to be turned on (FADEUP) we check to see if we have reached MAX_FIREFLIES_ON.
  If we have, then we set that LED back to the OFF state and tell it to wait again without turning on.
*/
void digitalFireflies() {
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    Firefly *ff = &fireflies[i];

    if (isAnalog(ff->pin) == true)
      continue;

    if (ff->state == ON) {                      // Pin On
      digitalWrite (ff->pin, HIGH);

      if (ff->time >= ff->value) {
        ff->value = DIGITAL_FADE_INTERVAL;
        ff->state=FADEDOWN;
        ff->fadeWait = millis();
      }
    }
    else if (ff->state == OFF) {                // Pin Off
      digitalWrite (ff->pin, LOW);

      if (ff->time >= ff->value) {
        if (isMaxFireflies()) {
          ff->state=OFF;
          ff->value = ff->time + random(DIGITAL_MIN_OFF, DIGITAL_MAX_OFF);
        }
        else {
          ff->value = 0;
          ff->state=FADEUP;
          ff->value = 0;
          ff->fadeWait = millis();
        }
      }
    }
    else if (ff->state == FADEUP){              // Pin Fade Up
      unsigned long currentMillis = millis();

      //We have a short wait before incrementing the value to make the fade take just a little longer.
      if (millis() - ff->fadeWait > DIGITAL_FADE_WAIT) {
        ff->value++;
        ff->fadeWait = millis();
      }

      if (currentMillis - ff->fade > DIGITAL_FADE_INTERVAL - ff->value && ff->toggle == true) {
        ff->toggle = false;
        ff->fade = currentMillis;
      }
      else if (currentMillis - ff->fade > ff->value && ff->toggle == false) {
        ff->toggle = true;
        ff->fade = currentMillis;
      }

      if (ff->toggle == true)
        digitalWrite(ff->pin, LOW);
      else
        digitalWrite(ff->pin, HIGH);

      if (ff->value == DIGITAL_FADE_INTERVAL) {
        ff->state=ON;
        ff->value = ff->time + random(DIGITAL_MIN_ON, DIGITAL_MAX_ON);
      }

    }
    else if (ff->state == FADEDOWN) {            // Pin Fade Down
      unsigned long currentMillis = millis();

      //We have a short wait before incrementing the value to make the fade take just a little longer.
      if (millis() - ff->fadeWait > DIGITAL_FADE_WAIT) {
        ff->value--;
        ff->fadeWait = millis();
      }

      if (currentMillis - ff->fade > DIGITAL_FADE_INTERVAL - ff->value && ff->toggle == true) {
        ff->toggle = false;
        ff->fade = currentMillis;
      }
      else if (currentMillis - ff->fade > ff->value && ff->toggle == false) {
        ff->toggle = true;
        ff->fade = currentMillis;
      }

      if (ff->toggle == true)
        digitalWrite(ff->pin, LOW);
      else
        digitalWrite(ff->pin, HIGH);

      if (ff->value == 1) {
        ff->state=OFF;
        ff->value = ff->time + random(DIGITAL_MIN_OFF, DIGITAL_MAX_OFF);
      }
    }

    ff->time = millis();
  }
}

//----------------------------------------------------------------------------------------------------

void turnLedOn(int pin) {
  if (isAnalog(pin) == true)
    analogWrite (pin, 255);
  else
    digitalWrite(pin, HIGH);
}
void turnLedOff(int pin) {
  if (isAnalog(pin) == true)
    analogWrite (pin, 0);
  else
    digitalWrite(pin, LOW);
}

//Iterates through all of the pins (digital and analog) and turns them on (up to MAX_FIREFLIES_ON).
//Allows us a chance to make sure all of the LED's are connected and working before the program starts
//and when we hit reset on the arduino.
void caterpillar() {
  int allcount = (sizeof(allPins)/sizeof(*allPins));

  for (int i=allcount-1; i>=0; i--) {
    if (i < allcount-MAX_FIREFLIES_ON)
      turnLedOff(allPins[MAX_FIREFLIES_ON+i]);
    turnLedOn(allPins[i]);
    delay(250);
  }

  for (int i=MAX_FIREFLIES_ON-1; i >=0; i--) {
    turnLedOff(allPins[i]);
    delay(250);
  }
}

void setup() {
  //Set all of the digital pins to OUTPUT
  for (int i=0; i < (sizeof(allPins)/sizeof(*allPins)); i++) {
    if (isAnalog(i) == false)
      pinMode(i, OUTPUT);
  }

  caterpillar();
  initialize();
}

void loop() {
  analogFireflies();
  digitalFireflies();
}


Code Listing #2 - Analog and Digital Fireflies - Shuffle Sort

/*  Analog and Digital Fireflies - Shuffle Sort

    This sketch is a program to randomly turn on LED's fading them up and down as they turn on/off.
    The LED's stay on for a random amount of time, stay turned off for a random amount of time, and the fade between is constant.
    They simulate fireflies in nature or with 2 LED's they can simulate glowing spooky eyes.

    You can easily change the intervals that fireflies are randomly chosen from for both the amount of time to wait before
    turning an LED on and how long to actually keep the LED on.  You can also change the maximum number of fireflies that
    could potentially be on at once.

    This differs from the other "Analog and Digital Fireflies" in that there is more of a guarantee that every LED will light.
    Due to the nature of randomness, it could be possible for you to light up one LED out of 54 over forty times before another
    LED has even lit once.  This solves that problem by making the sequence of lighting up less random.  It does this by creating
    an array of all of the pins and then shuffle sorting that array (like shuffling a deck of cards).  It then iterates through
    that array choosing LED's that are not currently on.  When it gets to the end of the array it shuffle sorts the array again.
    Why would you want this version over the other one that just chooses a pin at random and uses it as long as the total of pins
    that are not off is <= MAX_FIREFLIES_ON?  What if you setup a set of glowing spooky eyes that took 5 minutes to cycle through
    all 54 pins on a Mega 2560?  That means in one hour you'd have each set of eyes show only 12 times if every single set of eyes
    showed once without repeating.  If it randomly chose, you could easily have at least one LED out of the 54 show zero times and
    others show 24 or more.  And if you went to work on Halloween to setup 54 sets of eyes and it's only going to last for 3 hours,
    you may feel bad that some of the eyes never showed.

    created 2014
    by Garth Fielding II



  The circuit:
    LEDs with current limiting resistors attached from each of the 14 pins to ground.
    The perfect firefly in my opinion is a 5mm Flat Top LED with a 2.1v forward voltage
    and a current of 6mA (this is NOT an ultra-bright LED and is a bit harder to find).
    If you can't find that since ultra-bright is common, you can use an ultra-bright
    5mm Round Green 3.0-3.4v Forward Voltage 20,000mcd LED with 0.14 mA.
    You can also experiment with differing values of resistors to get the brightness that you want.

    R = (VS - VL) / I
    ResistorNeeded = (SourceVoltage - LEDForwardVoltage) / Current

    Example of a 1 LED setup (where the LED has a Forward Voltage of 3.4v).
    R=(5v-3.4v)/.00014=11428.6=round up to 12000 ohm
           12000 ohm    LED (3.4v)   Ground
    PIN ---`/\/\/\/`------|>|--------___
                                      -
                                      `
    Example of a 1 LED setup (where the LED has a Forward Voltage of 2.1v).
    R=(5v-2.1v)/.006=483.33=round up to 560 ohm
           12000 ohm    LED (3.4v)   Ground
    PIN ---`/\/\/\/`------|>|--------___
                                      -
                                      `
    Example of a 2 LED setup in series (where the LED has a Forward Voltage of 2.1v
    R=(5v-2.1v-2.1v)/.006=133.33=round up to 150 ohm
            150 ohm    LED (2.1v)     LED (2.1v)    Ground
    PIN ---`/\/\/\/`------|>|------------|>|--------___
                                                     -
                                                     `
    NOTE that you cannot do two 3.1v LED's in series as there's only 5v of power).

    Note: Why 6mA for the current instead of 20mA?
    2 reasons.
    1, it looks better with that particular LED.
    2, read the warning below on overloading your Arduino.

    Note: Forward Voltages are different for every LED.  Your package should tell you what they are.
    For example: Clear Red and Clear Yellow 1.88-2.0V, Clear Green: 2.89-3.1V, Clear Blue, Clear White and Clear Pink: 3.0-3.2V.
    If you are unsure of what voltage your LED is rated at, connect it up to a circuit with 5V power, a 10k-ohm resistor and
    use a voltmeter to measure the voltage across the 2 wires of the LED.  That will tell you the approximate voltage.  Once
    you have that setting, do the math above to find a 6ma current and then after building that check the LED with the voltmeter
    again.  The settings for the forward voltage may change slightly if at all.

    You can easily build this entire circuit on your breadboard to get it working the way you want then come Halloween just pull
    the LED's off the board and plug in the 22/4 security wire's you've attached to the LED's and voila, instant fireflies.

  Setup in your yard   
    You can find some 22/4 security wire at many hardware stores. It's 22awg wire with 4 strands. Strip off about
    one to two feet (30-60cm) of the jacketing (the outside sheath) to expose the 4 wires. Strip just a little bit
    off the end of each of the 4 wires. Attach 2 LED's to the 4 wires (pick a color - one end you'll plug into
    ground and the other to where you have a current limiting resistor coming from a pin). You can solder the wires
    if you want or just use electrician's tape to affix the LED's to the wires like I did. Either way, wrap some
    electrician's tape between and around the exposed wires and LED leads to prevent them from touching each other. Now, hang the wire from
    a tree, some paracord, a halloween spider web, etc. such that the jacket of the wire is what is touching the tree
    branch, etc. The 1-2 feet of really thin wire is hanging down towards the ground. When a slight wind picks up it
    will cause these wires with a bit of tape and an LED to wiggle back and forth - making them look like they are flying.
    Or, to make some spooky eyes, use the 22/4 security wire and put 2 red LED's in series on the same pin.  Then place
    these LED's close to each other in the bushes or in a tree.

    I've also built into the setup code where every LED that you've plugged in will light up briefly. This is so you can
    check your setup. If you realize a firefly didn't light after you've attached everything, fix it and then press the reset
    button on the arduino to have it cycle through all of the LED's again.
 */



/*
  --------------------WARNING ON CHANGING THIS VALUE-------------------
  ---DO NOT BLOW UP YOUR ARDUINO BY SENDING TOO MUCH POWER THROUGH IT---
    The code below is setup so that it currently outputs to all 14 pins with the maximum number of pins that could
    ever be on at the same time set to MAX_FIREFLIES_ON.

    Ever wondered why every example of lighting up LED's only lights up 10 pins total?
    While each pin can send 40mA of power through it, the total power sent through the system at one time cannot exceed 150mA.
    That means that if you were running LED's on more than 7 pins at full brightness (20mA) you could hit that limit.
    Some people say you have 200mA and in that case you'd be able to have 10 pins running LED's at full brightness
    simultaneously (like you see on other examples of PWM with LED's).

    When I built my circuit, I ran 28 LED's (2 LED's on each pin).
    Each LED had a Forward Voltage of 2.1volts and the current on each pin was only 6mA (84ma Total for the system).
    At that rate, you could run at max 25 different pins (on a mega 2560 for example) simultaneously before you'd hit the limit of 150 mA.
    You want to stay far away from the limit of 150mA though as running at the limit can also ruin your Arduino.
    I'd recommend you don't exceed around half of the total (for example 84mA out of 150mA).
    When running, I've found you typically don't come close to hitting MAX_FIREFLIES_ON if there are 14 pins and you have MAX_FIREFLIES_ON set to 7.
    In that case you'll see around half of that light on average.

    For firefly brightness, I've found that 6mA with a 5mm flat top 2.1v LED is plenty bright.
    I found that an ultra-bright LED with a 3.4v forward voltage looked good with 0.14mA - which is even less.
    Play around with the brightness and then make note of how many mA you are using.
  ------------------END WARNING ON CHANGING THIS VALUE-----------------

  Also, realize that this is the MAX.  In usage, you may rarely come close to this.
*/
#define MAX_FIREFLIES_ON 7

//If you get an Arduino Mega 2560 and want to have all 54 pins showing fireflies then uncomment this line.
//#define MEGA_2560 true

//Change these values to determine how long the LED stays OFF and how long it stays ON for the Analog fireflies.
//These values are in milliseconds times 10 (i.e. 27 = 270 milliseconds).
#define ANALOG_MIN_OFF 410
#define ANALOG_MAX_OFF 1500
#define ANALOG_MIN_ON 27
#define ANALOG_MAX_ON 270

//Change these values to determine how long the LED stays OFF and how long it stays ON for the Digital fireflies.
//These values are in milliseconds.
#define DIGITAL_MIN_OFF 410
#define DIGITAL_MAX_OFF 15000
#define DIGITAL_MIN_ON 210
#define DIGITAL_MAX_ON 2100


//The number of levels of fade before the LED is off with a digital PWM.
//Best to not change these
#define DIGITAL_FADE_INTERVAL 20
#define DIGITAL_FADE_WAIT 20

//Used to indicate the 4 states we can be in.
typedef enum {FADEUP, ON, FADEDOWN, OFF} FireflyState;

typedef struct FireFlyStruct {
  byte pin;                //PWM output pins are 3,5,6,9,10,and 11
  FireflyState state;      //used to determine what state the LED is in, fading up/down or on/off
  unsigned long value;     //used as LED's current value

  //Analog Values
  int duration;            //specifies how long the led will be on/off

  //Digital Values
  unsigned long time;      //Used for time calculations to see if it's time to change state
  boolean toggle;          //Used for toggling the LED on/off with PWM
  unsigned long fade;      //used to calculate how long the led will be on/off for PWM during a fade up/down
  unsigned long fadeWait;  //used to increase the time it takes to fade so it lasts just a little longer.
} Firefly;


#ifdef MEGA_2560
//MEGA 2560 - 54 pins
int analogPins[]  = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 44, 45, 46 };
//int digitalPins[] = { 0, 1, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 47, 48, 49, 50, 51, 52, 53 };
int allPins[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 };
#else
//UNO R3 - 14 pins
int analogPins[]  = { 3, 5, 6, 9, 10, 11 };
//int digitalPins[] = { 0, 1, 2, 4, 7, 8, 12, 13 };
int allPins[]     = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
#endif

Firefly fireflies[MAX_FIREFLIES_ON];

//Used to determine if the current pin is an Analog or a Digital Pin.
boolean isAnalog(int pin) {
  int length = sizeof(analogPins)/sizeof(*analogPins);
  for (int i=0; i<length; i++) {
    if (analogPins[i] == pin)
      return true;
  }
  return false;
}

int counter = 0;
//At the end of this function, all of the fireflies will be setup
//with the data they need in order to work properly.
//We also turn on MAX_FIREFLIES_ON fireflies to start us off.
void initialize() {
  randomize();
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    //Why am I using this pointer notation of taking the address of the object
    //and then dereferencing it?  It was to show someone how to do it.
    //If it bothers you, replace every occurrence of "ff->" with "fireflies[i]." and
    //it will run the same.
    Firefly *ff = &fireflies[i];
    ff->pin = allPins[i];
    if (i < MAX_FIREFLIES_ON)
      ff->state = ON;
    else
      ff->state = OFF;
    ff->value = 0;

    //Analog Values
    ff->duration = 0;

    //Digital Values
    ff->time = 0;
    ff->toggle = true;
    ff->fade = 0;
    ff->fadeWait = 0;

    if (i < MAX_FIREFLIES_ON) {
      if (isAnalog(ff->pin) == true)
        ff->duration = random(ANALOG_MIN_ON, ANALOG_MAX_ON);
      else
        ff->value = millis() + random(DIGITAL_MIN_ON, DIGITAL_MAX_ON);
    }
    else {
      if (isAnalog(ff->pin) == true)
        ff->duration = random(ANALOG_MIN_OFF, ANALOG_MAX_OFF);
      else
        ff->value = ff->time + random(DIGITAL_MIN_OFF, DIGITAL_MAX_OFF);
    }


    counter++;
  }
}

//----------------------------------------------------------------------------------------------------

//Used by randomize to swap 2 integers with each other.
void swap(int* a, int* b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

//Used to shuffle sort all of the elements within the array allPins.
void randomize() {
  int length = sizeof(allPins)/sizeof(*allPins);
  for (int i= length-1; i>0; i--) {
    int j = random(length) % (i+1);
    swap(&allPins[i], &allPins[j]);
  }
}

//Retrieves the next element in the array.  If we reach the end of the array it performs a shuffle
//sort and then grabs the first element in that array.  If that element is currently being used by
//a firefly then we grab the next one.
int getNextValue() {
  int retValue = getArrayElementOrShuffle();
  int lengthFireflies = sizeof(fireflies)/sizeof(Firefly);
  if (counter < lengthFireflies) {
    for (int i = 0; i < lengthFireflies; i++) {
      if (fireflies[i].pin == retValue) {
        i=-1;
        retValue = getArrayElementOrShuffle();
      }
    }
  }
  return retValue;
}

//This grabs the next element in the array.  If we reach the end of the array it performs a shuffle
//sort and then grabs the first element in that array.
int getArrayElementOrShuffle() {
  int length = sizeof(allPins)/sizeof(*allPins);
  if (counter == length) {
    counter = 0;
    randomize();
  }

  int retValue = allPins[counter++];
  return retValue;
}

//----------------------------------------------------------------------------------------------------

//Used for our delay of 10ms for analog.
unsigned long analogDelayTime = 0;

/*
  ANALOG FIREFLIES
  NOTE: (there is a 10ms delay on all analog fireflies).

  There are 4 states the fireflies can be in.
  ON = Keeps the LED on until the counter reaches the duration set for on.
  OFF = Keeps the LED off until the counter reaches the duration set for on.
  FADEUP = Over the course of 500ms, change the LED's brightness about 51 times
  FADEDOWN = Over the course of 500ms, change the LED's brightness about 51 times

  When the firefly has finished it's FADEUP, it will determine a random duration
  for how long to keep the LED on.  Similarly, FADEDOWN determines a random duration
  for how long to keep the LED off.

  When we are finished with one LED, we grab the next one from the array.  If we hit the
  end of the array, we shuffle sort the array and then grab the next one.  For the first
  MAX_FIREFLIES_ON in the array, we check to see if they are already being used.  If they
  are, we skip them and move on to the next item in the array.
*/
void analogFireflies() {
  //Put a 10ms delay on all of the analog stuff.
  if (millis()-analogDelayTime < 10)
    return;
  analogDelayTime = millis();

  //Iterate through all of the analog fireflies
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    Firefly *ff = &fireflies[i];

    if (isAnalog(ff->pin) == false)
      continue;

    if (ff->state == ON) {              // Pin On
      analogWrite (ff->pin, 255);

      ff->value +=1;
      if (ff->value == ff->duration) {
        ff->state=FADEDOWN;
        ff->value = 255;
      }
    }
    else if (ff->state == OFF) {        // Pin Off
      analogWrite (ff->pin, 0);

      ff->value +=1;
      if (ff->value == ff->duration) {
        ff->state=FADEUP;
        ff->value = 0;
        ff->pin = getNextValue();
      }
    }
    else if (ff->state == FADEUP){      // Pin Fade Up
      ff->value +=5;
      analogWrite (ff->pin, ff->value);

      if (ff->value == 255) {
        ff->value = 0;
        ff->state=ON;
        ff->duration = random(ANALOG_MIN_ON, ANALOG_MAX_ON);
      }
    }
    else if (ff->state == FADEDOWN) {   // Pin Fade Down
      ff->value -=5;
      analogWrite (ff->pin, ff->value);

      if (ff->value == 0) {
        ff->value = 0;
        ff->state=OFF;
        ff->duration = random(ANALOG_MIN_OFF, ANALOG_MAX_OFF);
      }
    }
  }
}

/*
  DIGITAL FIREFLIES

  There are 4 states the fireflies can be in.
  ON = Keeps the LED on until the current time becomes greater than how long we set to wait for
  OFF = Keeps the LED off until the current time becomes greater than how long we set to wait for
  FADEUP = We turn the LED on and off, changing the duration of time between each to simulate growing brighter
  FADEDOWN = We turn the LED on and off, changing the duration of time between each to simulate growing dimmer

  When the firefly has finished it's FADEUP, it will determine a random duration
  for how long to keep the LED on.  Similarly, FADEDOWN determines a random duration
  for how long to keep the LED off.

  The code for digital fireflies behaves in the same manner as the analog ones with the following exception.
  We have to execute PWM manually.  PWM (Pulse Width Modulation) is where you turn the LED on/off faster than
  the human eye can see a change.  The rate at which you change how long it is off versus on fools the eye into
  thinking that it is dimmer when in fact it is just flashing at a different rate.
  100% brightness = ------------------------------------ = 5 volts on all the time
   75% brightness = ---------___---------___---------___ = Alternating between 5 volts on then 0v off
   50% brightness = ------______------______------______ = Alternating between 5 volts on then 0v off
   25% brightness = ---_________---_________---_________ = Alternating between 5 volts on then 0v off

  The digital fireflies replace the "duration" variable with "time, toggle, fade, & fadeWait".
  These values are used to determine whether to be in the on or off state as the LED flashes in varying
  intervals to simulate growing dimmer or brighter.  For the most part, it works just like the digital fade
  examples you can find
    digitalWrite(pin, LOW);
    delayMicroseconds(period-i);
    digitalWrite(pin, HIGH);
    delayMicroseconds(i);
  The difference being that we don't use delayMicroseconds but do comparisons of time using millis,
  the value of "i" is "ff->value", and we have a flag to determine whether we are setting HIGH or LOW
  with the digitalWrite.

  When we are finished with one LED, we grab the next one from the array.  If we hit the
  end of the array, we shuffle sort the array and then grab the next one.  For the first
  MAX_FIREFLIES_ON in the array, we check to see if they are already being used.  If they
  are, we skip them and move on to the next item in the array.
*/
void digitalFireflies() {
  for (int i=0; i < (sizeof(fireflies)/sizeof(Firefly)); i++) {
    Firefly *ff = &fireflies[i];

    if (isAnalog(ff->pin) == true)
      continue;

    if (ff->state == ON) {                      // Pin On
      digitalWrite (ff->pin, HIGH);

      if (ff->time >= ff->value) {
        ff->value = DIGITAL_FADE_INTERVAL;
        ff->state=FADEDOWN;
        ff->fadeWait = millis();
      }
    }
    else if (ff->state == OFF) {                // Pin Off
      digitalWrite (ff->pin, LOW);

      if (ff->time >= ff->value) {
        ff->value = 0;
        ff->state=FADEUP;
        ff->value = 0;
        ff->fadeWait = millis();
        ff->pin = getNextValue();
      }
    }
    else if (ff->state == FADEUP){              // Pin Fade Up
      unsigned long currentMillis = millis();

      //We have a short wait before incrementing the value to make the fade take just a little longer.
      if (millis() - ff->fadeWait > DIGITAL_FADE_WAIT) {
        ff->value++;
        ff->fadeWait = millis();
      }

      if (currentMillis - ff->fade > DIGITAL_FADE_INTERVAL - ff->value && ff->toggle == true) {
        ff->toggle = false;
        ff->fade = currentMillis;
      }
      else if (currentMillis - ff->fade > ff->value && ff->toggle == false) {
        ff->toggle = true;
        ff->fade = currentMillis;
      }

      if (ff->toggle == true)
        digitalWrite(ff->pin, LOW);
      else
        digitalWrite(ff->pin, HIGH);

      if (ff->value == DIGITAL_FADE_INTERVAL) {
        ff->state=ON;
        ff->value = ff->time + random(DIGITAL_MIN_ON, DIGITAL_MAX_ON);
      }

    }
    else if (ff->state == FADEDOWN) {            // Pin Fade Down
      unsigned long currentMillis = millis();

      //We have a short wait before incrementing the value to make the fade take just a little longer.
      if (millis() - ff->fadeWait > DIGITAL_FADE_WAIT) {
        ff->value--;
        ff->fadeWait = millis();
      }

      if (currentMillis - ff->fade > DIGITAL_FADE_INTERVAL - ff->value && ff->toggle == true) {
        ff->toggle = false;
        ff->fade = currentMillis;
      }
      else if (currentMillis - ff->fade > ff->value && ff->toggle == false) {
        ff->toggle = true;
        ff->fade = currentMillis;
      }

      if (ff->toggle == true)
        digitalWrite(ff->pin, LOW);
      else
        digitalWrite(ff->pin, HIGH);

      if (ff->value == 1) {
        ff->state=OFF;
        ff->value = ff->time + random(DIGITAL_MIN_OFF, DIGITAL_MAX_OFF);
      }
    }

    ff->time = millis();
  }
}

//----------------------------------------------------------------------------------------------------

void turnLedOn(int pin) {
  if (isAnalog(pin) == true)
    analogWrite (pin, 255);
  else
    digitalWrite(pin, HIGH);
}
void turnLedOff(int pin) {
  if (isAnalog(pin) == true)
    analogWrite (pin, 0);
  else
    digitalWrite(pin, LOW);
}

//Iterates through all of the pins (digital and analog) and turns them on (up to MAX_FIREFLIES_ON).
//Allows us a chance to make sure all of the LED's are connected and working before the program starts
//and when we hit reset on the arduino.
void caterpillar() {
  int allcount = (sizeof(allPins)/sizeof(*allPins));

  for (int i=0; i < allcount; i++) {
    if (i >= MAX_FIREFLIES_ON)
      turnLedOff(allPins[i-MAX_FIREFLIES_ON]);
    turnLedOn(allPins[i]);
    delay(250);
  }

  for (int i=allcount-MAX_FIREFLIES_ON; i < allcount; i++) {
    turnLedOff(allPins[i]);
    delay(250);
  }
}

void setup() {
  //Set all of the digital pins to OUTPUT
  for (int i=0; i < (sizeof(allPins)/sizeof(*allPins)); i++) {
    if (isAnalog(i) == false)
      pinMode(i, OUTPUT);
  }

  caterpillar();
  initialize();
}

void loop() {
  analogFireflies();
  digitalFireflies();
}

Share