LED flashing assitance

Projects General Guidance
1

Hello, working on an arduino for an airplane model, and need some assistance. I have three parts:

Navigation light - flashes slow
Strobe light - flash flash
LED chaser lights - sequence of 6 LEDs down the side.

I need to seperate the LED chase portion and then call it, so I dont screw up the sequencing of the navs and strobes - any advice on how to change is appreciated:

#include <LedFlasher.h> 

// set up some leds
LedFlasher strobe (0, 500, 70); // pin2 off for 500 mS, on for 70 mS
LedFlasher navigation (1, 1200, 1200); //pin 3 off for 1200 ms on for 1200 ms

int LED1 = 26;
int LED2 = 27;
int LED3 = 28;
int LED4 = 29;
int LED5 = 6;
int LED6 = 7;

void setup() 
  {      
  strobe.begin ();
  navigation.begin ();
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  }  // end of setup

void loop() 
  {
 
// update lights
  navigation.update ();
  digitalWrite(LED1, HIGH);    // turn on LED1 
  delay(100);                  // wait for 200ms
  digitalWrite(LED2, HIGH);    // turn on LED2
  delay(100);                  // wait for 200ms       
  digitalWrite(LED3, HIGH);    // turn on LED3 
  delay(100);                  // wait for 200ms
  digitalWrite(LED4, HIGH);    // turn on LED4
  delay(100);                  // wait for 200ms
  digitalWrite(LED5, HIGH);    // turn on LED5
  delay(100);                  // wait for 200ms
  digitalWrite(LED6, HIGH);    // turn on LED6
  delay(100);                  // wait for 200ms
  digitalWrite(LED1, LOW);     // turn off LED1
  delay(100);                  // wait for 300ms
  digitalWrite(LED2, LOW);     // turn off LED2
  delay(100);                  // wait for 300ms
  digitalWrite(LED3, LOW);     // turn off LED3
  delay(100);                  // wait for 300ms
  digitalWrite(LED4, LOW);     // turn off LED4
  delay(100);                  // wait for 300ms
  digitalWrite(LED5, LOW);     // turn off LED5
  delay(100);                  // wait for 300ms
  digitalWrite(LED6, LOW);     // turn off LED6
  delay(100);
  strobe.update ();// wait for 300ms
  } //end of loop
2

You should get away from using delay(). With delay() only one thing can happen at a time. Use non-blocking timing with millis() or micros().

Non-blocking timing tutorials:
Blink without delay().
Beginner's guide to millis().
Several things at a time.

3

Hello dylaninwv

Take a search engine of your choice and ask the WWW for 'led sequencer'.

Have a nice day and enjoy coding in C++.

4

Determine the fastest blink that you need(1), or setup multiple millis timers(2).

If #1, identify a multiple, or LCM of your blink rate, than derive the three blink frequencies from that fastest event. These wil remain synchronous.

If #2, simply create three timers, each calling the blink routine for each of the three lights.
These can flash asynchronously.

DO NOT USE DELAY() !

5

I enjoy the practice so I wrote a small example that shows using several millis() timers to simulate multitasking. There are 3 timers operating to actuate a 6 LED sequence, a pair of LEDs that have opposite states (one on, the other off) and a strobe that has a quick flash then and longer pause. Tested with my trusty Uno and many LEDs.

This code uses the methods from the tutorials linked in reply #2 .

const byte sequenceLedPins[] = {2, 3, 4, 5, 6, 7};
const byte navLedPins[] = {8, 9};
const byte strobeLedPin = 10;

unsigned long sequenceStepTime = 30;
unsigned long navTime = 750;
unsigned long strobeOnTime = 20;
unsigned long strobeOffTime = 1000;

void setup()
{
  Serial.begin(115200);
  for (byte n = 0; n < 6; n++)
  {
     pinMode(sequenceLedPins[n], OUTPUT);
     digitalWrite(sequenceLedPins[n], LOW);
  }

  pinMode(navLedPins[0], OUTPUT);
  pinMode(navLedPins[1], OUTPUT);

  pinMode(strobeLedPin, OUTPUT);
}

void loop()
{
  sequence();
  nav();
  strobe();
}

void strobe()
{
  static bool state = 0;
  static unsigned long timer = 0;
  static unsigned long interval = strobeOffTime;
  if (millis() - timer >= interval)
  {
     timer = millis();
     if (state == HIGH)
     {
        digitalWrite(strobeLedPin, HIGH);
        interval = strobeOnTime;
     }
     else
     {
        digitalWrite(strobeLedPin, LOW);
        interval = strobeOffTime;
     }
     state = !state;
  }
}

void nav()
{
  static bool state = 0;
  static unsigned long timer = 0;
  unsigned long interval = navTime;
  if (millis() - timer >= interval)
  {
     timer = millis();
     state = !state;
     digitalWrite(navLedPins[0], state);
     digitalWrite(navLedPins[1], !state);
  }
}

void sequence()
{
  static byte index = 0;
  static unsigned long timer = 0;
  unsigned long interval = sequenceStepTime;
  if (millis() - timer >= interval)
  {
     timer = millis();
     digitalWrite(sequenceLedPins[index], !digitalRead(sequenceLedPins[index]));
     //Serial.println(sequenceLedPins[index]);
     index ++;
     if (index > 5)
     {
        index = 0;
     }
  }
}
6 
//#include <LedFlasher.h>

// set up some leds
//LedFlasher strobe (0, 500, 70); // pin2 off for 500 mS, on for 70 mS
//LedFlasher navigation (1, 1200, 1200); //pin 3 off for 1200 ms on for 1200 ms

const int strobePin = 2;
const int navigationPin = 3;

const int LED1 = 26;
const int LED2 = 27;
const int LED3 = 28;
const int LED4 = 29;
const int LED5 = 6;
const int LED6 = 7;

void strobe() {
  const unsigned long onTime = 70;
  const unsigned long offTime = 500;

  static int state = LOW;
  static unsigned long delayTime = offTime;
  static unsigned long lastTime;

  if ( millis() - lastTime >= delayTime ) {
    // time to toggle
    lastTime = millis();
    if (state == LOW) {
      state = HIGH;
      delayTime = onTime;
    }
    else {
      state = LOW;
      delayTime = offTime;
    }
    digitalWrite(strobePin, state);
  }
}


void navigation() {
  const unsigned long onTime = 1200;
  const unsigned long offTime = 1200;

  static int state = LOW;
  static unsigned long delayTime = offTime;
  static unsigned long lastTime;

  if ( millis() - lastTime >= delayTime ) {
    // time to toggle
    lastTime = millis();
    if (state == LOW) {
      state = HIGH;
      delayTime = onTime;
    }
    else {
      state = LOW;
      delayTime = offTime;
    }
    digitalWrite(navigationPin, state);
  }
}

void chaser() {
  const unsigned long delayTime = 100;

  static int state = 0;
  static unsigned long lastTime;

  if ( millis() - lastTime >= delayTime ) {
    // time to move to next state
    lastTime = millis();
    switch ( state ) {
      case 0:
        digitalWrite(LED1, HIGH);    // turn on LED1
        break;

      case 1:
        digitalWrite(LED2, HIGH);    // turn on LED2
        break;

      case 2:
        digitalWrite(LED3, HIGH);    // turn on LED3
        break;

      case 3:
        digitalWrite(LED4, HIGH);    // turn on LED4
        break;

      case 4:
        digitalWrite(LED5, HIGH);    // turn on LED5
        break;

      case 5:
        digitalWrite(LED6, HIGH);    // turn on LED6
        break;

      case 6:
        digitalWrite(LED1, LOW);     // turn off LED1
        break;

      case 7:
        digitalWrite(LED2, LOW);     // turn off LED2
        break;

      case 8:
        digitalWrite(LED3, LOW);     // turn off LED3
        break;

      case 9:
        digitalWrite(LED4, LOW);     // turn off LED4
        break;

      case 10:
        digitalWrite(LED5, LOW);     // turn off LED5
        break;

      case 11:
        digitalWrite(LED6, LOW);     // turn off LED6
        break;
    }
    state++;    // next state
    if ( state > 11 ) state = 0;
  }
}

void setup()
{
  pinMode(strobePin, OUTPUT); // strobe.begin ();
  pinMode(navigationPin, OUTPUT); //navigation.begin ();
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
}  // end of setup

void loop()
{

  // update lights
  navigation();
  strobe();
  chaser();
} //end of loop
7

Hello dylaninwv

I enjoy the practice too. :sunglasses:

So I edit an object oriented sketch to flash leds under several given conditions.

Try, check, study and have fun:

/* BLOCK COMMENT
  - https://forum.arduino.cc/t/led-flashing-assitance/1101937
  - LED flashing assitance
  - This sketch may contain traces of C++.
  - In case of indisposition:
  - https://www.learncpp.com/
  - Hardware:
  - Thanks to LarryD
  - https://europe1.discourse-cdn.com/arduino/original/4X/7/e/0/7e0ee1e51f1df32e30893550c85f0dd33244fb0e.jpeg
  - Tested @ Arduino: Mega[ ] - UNO [X] - Nano [ ]
*/
#define ProjectName "LED flashing assitance"

// I am too lazy to type
#define usl unsigned long
// make names
enum modes {Off, On};
// make variables
constexpr int UsedLeds[] {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
constexpr int StrobeLed {2};
constexpr int NavLed {3};
constexpr int ChaserLeds[] {4, 5, 6, 7, 8, 9, 10, 11};
constexpr usl StrobeLedFlash[] {500, 70};
constexpr usl NavLedFlash[] {1200, 1200};
// make structures
struct MAKECHASER {
  usl span;
  int pattern[sizeof(ChaserLeds) / sizeof(ChaserLeds[0])];
  usl stamp;
  int onOff;
} makeChasers[]
{
  {100, 0, 0, 0, 0, 0, 0, 0, 0, 0, HIGH},
  {100, 0, 1, 0, 0, 0, 0, 0, 0, 0, LOW},
  {100, 0, 0, 1, 0, 0, 0, 0, 0, 0, LOW},
  {100, 0, 0, 0, 1, 0, 0, 0, 0, 0, LOW},
  {100, 0, 0, 0, 0, 1, 0, 0, 0, 0, LOW},
  {100, 0, 0, 0, 0, 0, 1, 0, 0, 0, LOW},
  {100, 0, 0, 0, 0, 0, 0, 1, 0, 0, LOW},
  {100, 0, 0, 0, 0, 0, 0, 0, 1, 0, LOW},
  {100, 0, 0, 0, 0, 0, 0, 0, 0, 1, LOW},
  {100, 0, 0, 0, 0, 0, 0, 0, 1, 1, LOW},
  {100, 0, 0, 0, 0, 0, 0, 1, 1, 1, LOW},
  {100, 0, 0, 0, 0, 0, 1, 1, 1, 1, LOW},
  {100, 0, 0, 0, 0, 1, 1, 1, 1, 1, LOW},
  {100, 0, 0, 0, 1, 1, 1, 1, 1, 1, LOW},
  {100, 0, 0, 1, 1, 1, 1, 1, 1, 1, LOW},
  {100, 0, 1, 1, 1, 1, 1, 1, 1, 1, LOW},
  {100, 1, 1, 1, 1, 1, 1, 1, 1, 1, LOW},
  {100, 1, 1, 1, 1, 1, 1, 1, 1, 0, LOW},
  {100, 1, 1, 1, 1, 1, 1, 1, 0, 0, LOW},
  {100, 1, 1, 1, 1, 1, 1, 0, 0, 0, LOW},
  {100, 1, 1, 1, 1, 1, 0, 0, 0, 0, LOW},
  {100, 1, 1, 1, 1, 0, 0, 0, 0, 0, LOW},
  {100, 1, 1, 1, 0, 0, 0, 0, 0, 0, LOW},
  {100, 1, 1, 0, 0, 0, 0, 0, 0, 0, LOW},
  {100, 1, 0, 0, 0, 0, 0, 0, 0, 0, LOW},
};
struct MAKELED {
  int pin;
  usl stamp;
  usl duration[2];
} makeNavStrobes[]
{
  {StrobeLed , 0, StrobeLedFlash[Off], StrobeLedFlash[On]},
  {NavLed , 0, NavLedFlash[Off], NavLedFlash[On]},
};
// tools
void heartBeat(int LedPin)
{
  static bool setUp = false;
  if (!setUp) pinMode (LedPin, OUTPUT), setUp = !setUp, Serial.println("make heartBeat");
  digitalWrite(LedPin, (millis() / 500) % 2);
}
void setup()
{
  Serial.begin(115200);
  Serial.print(ProjectName), Serial.print(" in "), Serial.println(__FILE__);
  Serial.print("led test ");
  for (auto &UsedLed : UsedLeds)
  {
    pinMode(UsedLed, OUTPUT);
    digitalWrite(UsedLed, HIGH);
    delay(500);
    Serial.print(" .");
    digitalWrite(UsedLed, LOW);
  }
  Serial.println(" done"); 
}
// functions
void navigationStrobe(usl currentMillis)
{
  for (auto &makeNavStrobe : makeNavStrobes)
  {
    if (currentMillis - makeNavStrobe.stamp >= makeNavStrobe.duration[digitalRead(makeNavStrobe.pin)])
    {
      makeNavStrobe.stamp = currentMillis;
      digitalWrite(makeNavStrobe.pin, digitalRead(makeNavStrobe.pin) ? LOW : HIGH);
    }
  }
}
void  chaser(usl currentMillis)
{
  for (auto &makeChaser : makeChasers)
  {
    if (currentMillis - makeChaser.stamp >= makeChaser.span && makeChaser.onOff)
    {
      static int number = 0;
      makeChaser.onOff = LOW;
      number = (number + 1) % (sizeof(makeChasers) / sizeof(makeChasers[0]));
      makeChasers[number].stamp = currentMillis;
      makeChasers[number].onOff = HIGH;
      int element = 0;
      for (auto &ChaserLed : ChaserLeds) digitalWrite(ChaserLed, makeChasers[number].pattern[element++]);
    }
  }
}
//
void loop()
{
  usl currentMillis = millis();
  heartBeat(LED_BUILTIN);
  
  navigationStrobe(currentMillis);
  chaser(currentMillis);
}

Have a nice day and enjoy coding in C++. :vulcan_salute:

8

That did it! Thank you SO MUCH!