Help with approach to repetitive sketch

I am a beginner with sketches. Need help getting pointed on an approach to a repetitive sketch.
I have a large radio controlled model sailing ship (over 2M/6 ft long) with 9 cannons. I designed an electronic system to simulate firing cannons (similar to a large e-cigarette). I have tested the cannon system using an Uno to run through the control cycle for one cannon. Now need to write a sketch that repeats that cycle for 9 different devices. Details are in the attachments.
I basically can only baby talk arduino programming - I'm 70 and this is not my strongest area :wink: .
I have a how to book, but bewildered by the strategy to choose.
My sketch for one cannon is attached, and attachments showing what I need to get to.
I have a Mega 2560 embed with the 27 outputs needed - 3 functions for each cannon x 9 cannons.
Once the sequence starts, it will fire all 9 cannons. Sequence will be started by powering on the Mega with an R/C switch, and ended by powering off the Mega by R/C .
Any help much appreciated, from identifying a best approach, pointing to examples I can copy, or even writing the sketch if this is more simplistic than I thought.
Guys, when I was a kid, we had party line phones, B&W TV, and pencil and paper was our calculator. This Arduino stuff is so amazing!
Thanks.

In the board pinout diagram, the red pins are for heat, the blue for air solenoids and the yellow for LED's

//test sketch for Mega 2560 Pro Embed
void setup() {
  //set pullup to prevent activation on start up?
  //pinMode(D2, INPUT_PULLUP);  //heat function
  //pinMode(D12, INPUT_PULLUP); //air function
  //pinMode(D22, INPUT_PULLUP); //LED function
  // initialize pins as output
  pinMode(D2, OUTPUT); //heat  5V to drive logic level Mosfet
  pinMode(D12, OUTPUT); //AIR   5V to drive Darlington
  pinMode(D22, OUTPUT); //LED  output to drive LED directly - 2.5V,50ma
}
// basic test with loop for 1 cannon
void loop() {
  digitalWrite(D2, HIGH);  //heat on, stays on until write low
  delay(8000); //preheat time til air on
  digitalWrite(D12, HIGH);  // air on, stays on until write low
  delay(30); //vs previous 50
  analogWrite(D22, 150); // LED on.   flash sequence for LED starts
  delay(130);  
  analogWrite(D22, 0);
  delay(80);
  analogWrite(D22, 150);
  delay(130);
  analogWrite(D22, 0);
  delay(80);
  analogWrite(D22, 150);
  delay(130);
  analogWrite(D22, 0);
  digitalWrite(D2, LOW); // heat goes off
  delay(500)
  digitalWrite(D12, LOW); // air off after heat goes off - clears barrel
  
  delay(30000); //30 sec delay for manual power off
}

Looks like something that could be tackled with a couple of arrays pretty easily.
Then just write the actions once like you have, but refer to them in an array vs discretely.
Declare all the pins:

byte inputPins[] = {
2,3,4,
5,6,7,
8,9,10,
// etc for 9 groups
}; // etc. as an example, up to the 27  I think you said you'd need
byte numberOfInputs = 27; // to agree with the above

byte outputPins[] = {
30,31,32
33,34,35,
36,37,39,
// etc for 9 groups
}; // insert your own pins, up to the 27 I think you said you'd need
byte numberOf Outputs = 27;

byte x; // to be used as an array pointer

void setup(){
for (x = 0; x <numberOfInputs; x=x+1){ // set up the inputs
pinMode (inputPins[x])= INPUT_PULLUP};
}
for (x = 0; x <  numberOfOutputs; x=x+1){ // setup the outputs
pinMode (outputPins[x] = OUTPUT);
}
//and your other stuff
}

void loop(){
for (x = 0; x <27; x=x+3){ // step thru IO 3 pins at a time -   etc

  //do stuff  using inputPins[x], inputPins[x+1], inputPins[x_+2], and
  // outputPins [x], outputPins [x+1], outputPins [x+2]

  }
}

If you need some hardware support, I offer a board that you can plug the 2560 Pro Mini onto,
or it can be soldered down, to give yourself screw terminals to connect all the wires to.
All the pins are brought out, and there are extra 3.3V, 5V, and Gnd connections as well.

Same sequence repeats nine times with a 2 to 3 second delay for each start time.

According to this, and your drawing, multiple cannon will be timing and firing simultaneously. Therefore you cannot have delay() timing things. You'll have to learn about doing several things at the same time and timing with millis(). There's an example in IDE-> file/examples/digital/blink without delay and tutorials/threads galore on this site.

You might want to consider using a Finite State Machine or FSM tutorial (and other examples abound) to control each cannon sequence or do the sequencing with a series of if/else statements.

Is this the same project we had a 57 post thread about back in 2018?

https://forum.arduino.cc/?topic=579922#msg3954343

Hello DanLRC
How are you?
As beginner do you have a hugh project seleted, but we can help.
My proposal is to organize a canon-object, in a struct{}, for each canon.
So you can change each element inside the sequence for the heater, air and LED very simple.
Each time array inside the struct{} must have their own timer and related control, not shown.
Later on you can organized all canons in an array controlled via a canon time contoller.

struct CANON {
  byte  heatPin = 2;
  byte  airPin = 3;
  byte  ledPin = 4;
  bool  heatStart = true;
  bool  airStart = false;
  bool  ledStart = false;
  unsigned long  heatTime[2] = {8580, 0};
  unsigned long  airTime[3] = {8000, 1080, 0};
  unsigned long  ledTime[7] = {8030 + 130, 80, 130, 80, 130, 1, 0};
};
CANON canon;
void setup() {
  pinMode (LED_BUILTIN, OUTPUT);
  pinMode (canon.heatPin, OUTPUT);
  pinMode (canon.airPin, OUTPUT);
  pinMode (canon.ledPin, OUTPUT);
  digitalWrite (canon.heatPin, canon.heatStart);
  digitalWrite (canon.airPin, canon.airStart);
  digitalWrite (canon.ledPin, canon.ledStart);
}
void loop() {
  digitalWrite(LED_BUILTIN, (millis() / 500) % 2);
  // insert the timer for heater operation here
  // insert the timer for air operation here
  // insert the timer for LED operation here
}

Compiles, but not tested:

#define CANNONS 9
#define HEAT_PIN D2
#define AIR_PIN D12
#define LED_PIN D22

long startTime[CANNONS];

//test sketch for Mega 2560 Pro Embed
void setup() {
  randomSeed(analogRead(A0)); // Randomise the random function
  for (byte c = 0; c < CANNONS; c++) {
    // initialize pins as output
    pinMode(HEAT_PIN + c, OUTPUT); //heat  5V to drive logic level Mosfet
    pinMode(AIR_PIN + c, OUTPUT); //AIR   5V to drive Darlington
    pinMode(LED_PIN + c, OUTPUT); //LED  output to drive LED directly - 2.5V,50ma
    //stagger start times randomly
    if (c > 0) startTime[c] = startTime[c-1] + random(2000, 3000);
  }
}

void loop() {
  for (byte c = 0; c < CANNONS; c++) {
    
    long seqTime = millis() - startTime[c]; // Calculate time into sequence for this cannon
    
    if(seqTime >= 0L && seqTime < 8580L)
      digitalWrite(HEAT_PIN + c, HIGH);
    else
      digitalWrite(HEAT_PIN + c, LOW);
      
    if(seqTime >= 8000L && seqTime < 9080L)
      digitalWrite(AIR_PIN + c, HIGH);
    else
      digitalWrite(AIR_PIN + c, LOW);
      
    if(seqTime >= 8030L && seqTime < 8160L || seqTime >= 8240L && seqTime < 8370L || seqTime >= 8450L && seqTime < 8580L)
      analogWrite(LED_PIN + c, 150);
    else
      analogWrite(LED_PIN + c, 0);
  }
}

Questions:

  • Why is analogWrite() used for the LEDs? Are all those pins PWM capable?
  • Are pin names D2, D12 etc valid on Mega Pro? They are not valid for normal Mega.

WattsThat:
Is this the same project we had a 57 post thread about back in 2018?

Arduino Forum

I was going to refer him to that thread. I didn't realize it was so long ago.

WattsThat:
Is this the same project we had a 57 post thread about back in 2018?

Arduino Forum

Sure looks like it - the name of the boat is the same.

I still have the code I wrote for it and the requirement looks largely unchanged. Timing is a bit different (heating is longer) but those are all specified once in the program and therefore easily changed. I don't recall if it was ever used or tested, but it does at least compile.

// It is assumed that the pins used for controlling the carronades will be a contiguous set and that each gun's pins are next to each other
// These constants indicate which pins are used for a single carronade. 
const byte HeatPinOffset=0;
const byte AirPinOffset=1;
const byte LedPinOffset=2;

const byte FirstCarronadePin = 2; //Arbitrarily starting at pin 2.

typedef struct
{
byte PinOffset;           // Offset from the base pin of the gun
byte SetTo;               // What should the pin be set to for this action
unsigned int TimeOffset;  // How long after the gun started its sequence should this action take place
const char *Name;         // Action name for debugging
}Action;

// Sequence of actions for a single gun, used by all. Note that there are some Led actions not yet specified but easy to add
Action Actions[]={ 
                   { HeatPinOffset,HIGH,0,    "Heat on " },
                   { HeatPinOffset,LOW, 3500, "Heat off" },
                   { AirPinOffset, HIGH,2600, "Air on  " },
                   { AirPinOffset, LOW, 3600, "Air off " },
                   { LedPinOffset, HIGH,2700, "Led on1 " },
                   { LedPinOffset, LOW, 2750, "Led off1" },
                   { LedPinOffset, HIGH,2800, "Led on2 " },
                   { LedPinOffset, LOW, 2900, "Led off2" }
                 };
const unsigned int NoActions = sizeof Actions/sizeof Actions[0];

class Carronade
{
byte basePin;
unsigned long startTime;
bool ActionsDone[NoActions];
public:
static unsigned int ActionsCompleted;//=0;
  void SetBasePin(byte _basePin) { basePin=_basePin;}
  void DoCarronadeActions();
  void SetStartTime(unsigned long _startTime) {startTime=_startTime;}
  void ResetCarronade();
};

unsigned int Carronade::ActionsCompleted=0;

// Look through the actions for this gun as yet not done to see if any are due and if so, do them.
void Carronade::DoCarronadeActions()
{
for(byte j=0;j<NoActions;j++)
  {
  if(!ActionsDone[j])
    {
    if(millis()>startTime+Actions[j].TimeOffset)
      {
      Serial.print(F("Action "));
      Serial.print(j);
      Serial.print(F(" ("));
      Serial.print(Actions[j].Name);
      Serial.print(F(") on gun "));
      Serial.print((basePin-FirstCarronadePin)/3+1);
      Serial.print(F(" StartTime "));      
      Serial.print(startTime);
      Serial.print(F(" Action offset "));
      Serial.print(Actions[j].TimeOffset);
      Serial.print(F(" millis: "));
      Serial.print(millis());
      Serial.println();

      digitalWrite(basePin+Actions[j].PinOffset,Actions[j].SetTo);
      ActionsDone[j]=true;
      ActionsCompleted++;
      }
    }
  }
}

void Carronade::ResetCarronade()
{
startTime=0;
for(byte j=0;j<NoActions;j++)
  ActionsDone[j]=false;
}

const unsigned int NoCarronades = 3;//9;
unsigned long BroadsideStartTime;
Carronade Carronades[NoCarronades];
bool RunActions=false;

void setup()
{
Serial.begin(115200);  
Serial.println(F("Starting"));
for(unsigned int i=0;i<NoCarronades;i++)
  {
  Carronades[i].SetBasePin(FirstCarronadePin+i*3); // Each Carronade has three contiguous pins to control it. 
  }
}

void loop()
{
CheckTrigger();
if(RunActions)
  {
  for(byte i=0;i<NoCarronades;i++)
    {
    Carronades[i].DoCarronadeActions(); 
    }
  CheckCompletion();
  }
}

//Simulate sequence trigger using a single character from serial
void CheckTrigger()
{
if(Serial.available()>0)
  {
  Serial.read();
  if(!RunActions)
    {
    BroadsideStartTime=millis();
    for(byte lp=0;lp<NoCarronades;lp++)
      Carronades[lp].SetStartTime(millis()+1500*lp);

    RunActions=true;    
    }
  }
}

//If all actions are complete, reset the system for another go
void CheckCompletion()
{
if(Carronade::ActionsCompleted>=NoCarronades*NoActions)
  {
  Serial.println(F("\nSequence complete, resetting\n"));
  RunActions=false;
  Carronade::ActionsCompleted=0;
  for(unsigned int lp=0;lp<NoCarronades;lp++)
    Carronades[lp].ResetCarronade();
  }
}
pinMode(D22, OUTPUT); //LED  output to drive LED directly - 2.5V,50ma
...
analogWrite(D22, 150); // LED on.   flash sequence for LED starts

Is the analogWrite() with 150 in order to get 2.5V for the led? Unfortunately, that does not work because analogWrite() does not in fact output a variable voltage. It outputs a Pulse Width a Modulated (PWM) signal which switches between 5V and 0V around 500 times per second. The 150 is the Duty Cycle, ie. what portion of the time the output is 5V. While it may look to the eye like the led is being lit with 2.5V, in practice this will damage and shorten the life of the LEDs and the Arduino pins connected to them.

Rather than using analogWrite(), you should use digitalWrite() and put a resistor in series with each led to drop the voltage and limit the current to a safe level.

Not many LEDs can take 50mA current. Most ordinary 5mm LEDs have a max of 20 or 30mA. Can you post a link to some data about these LEDs?

An Arduino pin cannot supply 50mA. If 50mA is required, you will need more transistors/Darlingtons.

First, thank you for all the help. Second, apologies for not looking back at my own thread first. Embarrassed to say it slipped my mind - old guy syndrome. I did follow up and recently got the Mega embed version, and finished all the hardware details long ago, but just getting back to the project after years. Again, appreciate your patience.
The LED is LED-72 from AllElectronics.com. Typical If is 20mA, max 50mA. Running at 38mA with 68ohm R to get high brightness during the short flash.
Thanks for the screw terminal board suggestion, but all connections will be soldered and board mounted in a small enclosure splash proof enclosure.
Pin names...used the board designations for the example - dumb. Actual sketch uses the board Arduino names - simply the pin numbers.
Again, thank you for your responses - need now to go back to all the past and present feedback, digest it all and put more effort into this.
Will post again after that.
Best,
Dan

Update:
Project electronics and hardware are completed and working well.
My huge problem was the control program, and despite all the help given here and time spent trying to decipher the suggested sketch approaches, I gave up. Just can't break through on the C++ stuff.
But I can use Excel very well...ha...lightbulb went on. Wrote the whole thing in a spreadsheet with copy and paste, cumulative time and event time tracking, cascading autofill, etc. Even used columns to generate proper sketch format. Easy for me vs a complex sketch.
Ugly, but works perfectly.
All I need to do now for any future timing changes is update one gun on the spreadsheet and everything auto-fills and recalculates automatically. Then just copy and paste for Arduino. The actual output sketch is abysmal...mishmash use of delays, repetitive code lines, etc...but works for me.
Thank you again for your help. Sorry, just couldn't grasp the sketch approach.
The sketch, as copied from the spreadsheet, is attached for your chuckles.

 //Syren 9 e-Gun Sequential Firing    
 //Ver 21.04.17    New for Mega 2560 Pro Mini   
 //System activation: 12V power "on" by R/C Tx,  start sketch by 7.5V power "on" to board, end sequence by board power "off", 12V power "off"   
 //Sketch includes 7.6hr delay at end to essentially terminate operation, since max system use time is 3 -4hrs.   
// Sketch restarted as desired by re-powering board.
 //A spreadsheet is formatted to change total sketch sequence by changing only Gun 1 variables.
 //Spreadsheet is formatted to copy directly into sketch format (sloppy, but correct)
  
  void setup()    
{   
 pinMode(2, OUTPUT); //HEAT for gun #1, pins 2-10 (gun heat 1-9)    
 pinMode(3, OUTPUT); //gun #2     
 pinMode(4, OUTPUT); //gun #3 etc         
 pinMode(5, OUTPUT);    
 pinMode(6, OUTPUT);    
 pinMode(7, OUTPUT);    
 pinMode(8, OUTPUT);    
 pinMode(9, OUTPUT);    
 pinMode(10, OUTPUT);   
    
 pinMode(12, OUTPUT);  //LED flash for gun #1, pins 22-30(LED flash 1-9)        
 pinMode(13, OUTPUT); // Note: board LED flash on startup will flash Gun 2 LED - will indicate sequence start   
 pinMode(14, OUTPUT);     
 pinMode(15, OUTPUT);     
 pinMode(16, OUTPUT);     
 pinMode(17, OUTPUT);     
 pinMode(18, OUTPUT);   
 pinMode(19, OUTPUT);   
 pinMode(20, OUTPUT);   
    
 pinMode(21, OUTPUT);  // Main valve to air manifold   
    
 pinMode(22, OUTPUT);  //AIR for gun #1, pins 12-20 (air burst 1-9)    
 pinMode(23, OUTPUT);   
 pinMode(24, OUTPUT);     
 pinMode(25, OUTPUT);     
 pinMode(26, OUTPUT);     
 pinMode(27, OUTPUT);     
 pinMode(28, OUTPUT);   
 pinMode(29, OUTPUT);   
 pinMode(30, OUTPUT);   
 }    
    
void loop()   
{   
  //external power to board (7.5VDC) switched "on" by R/C to start the following sketch sequence    
      
  digitalWrite (21, HIGH);  // turn on main air solenoid to manifold    
    
 // Guns 1-4 pre-heat    
    
  digitalWrite(2, HIGH);   // heat 1 on   
  delay             (1800)  ;  //change only this line for event start interval
  digitalWrite(3, HIGH);   //heat 2 on              
  delay (1800)  ;
  digitalWrite(4, HIGH);   //heat 3 on        
  delay (1800)  ;
  digitalWrite(5, HIGH);   //heat 4 on        
    
 // Gun 1   
  delay (1600)  ; //preheat timing trimmer 
    
  digitalWrite(22, HIGH);  //air 1 on               
  delay (100) ;      //change this line only for air burst time trim
  digitalWrite(2, LOW); // heat 1 off   
  digitalWrite(12, HIGH);  //flash sequence 1 begins      
  delay                   (100) ;    
  digitalWrite(6, HIGH);   //heat 5 on        
  digitalWrite(12, LOW);     
  delay                       (40)  ;     //change only gun 1 flash times to effect all guns
  digitalWrite(12, HIGH);   
  delay (75)  ;
  digitalWrite(12, LOW);    
  delay (30)  ;
  digitalWrite(12, HIGH);   
  delay (75)  ;
  digitalWrite(12, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(22, LOW); // air 1 off     
    
 //  Gun 2    
   delay  (1180)  ;   //auto generated timing trimmer, guns 2-9
    
  digitalWrite(23, HIGH);  //air 2 on               
  delay (100) ;
  digitalWrite(3, LOW); // heat 2 off    
  digitalWrite(13, HIGH);  //flash sequence 2 begins      
  delay                   (100) ;
  digitalWrite(7, HIGH);   // heat 6 on   
  digitalWrite(13, LOW);      
  delay                       (40)  ;
  digitalWrite(13, HIGH);   
  delay (75)  ;
  digitalWrite(13, LOW);    
  delay (30)  ;
  digitalWrite(13, HIGH);   
  delay (75)  ;
  digitalWrite(13, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(23, LOW); // air 2 off     
    
 //  Gun3   
   delay  (1180)  ;
    
  digitalWrite(24, HIGH);  //air 3 on               
  delay (100) ;
  digitalWrite(4, LOW); // heat 3 off   
  digitalWrite(14, HIGH);  //flash sequence3 begins       
  delay                   (100) ;
  digitalWrite(8, HIGH);   // heat 7 on   
  digitalWrite(14, LOW);      
  delay                       (40)  ;
  digitalWrite(14, HIGH);   
  delay (75)  ;
  digitalWrite(14, LOW);    
  delay (30)  ;
  digitalWrite(14, HIGH);   
  delay (75)  ;
  digitalWrite(14, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(24, LOW); // air 3 off     
    
 //  Gun 4    
   delay  (1180)  ;
    
  digitalWrite(25, HIGH);  //air4 on                
  delay (100) ;
  digitalWrite(5, LOW); // heat 4 off   
  digitalWrite(15, HIGH);  //flash sequence 4 begins      
  delay                   (100) ;
  digitalWrite(9, HIGH);   // heat 8 on   
  digitalWrite(15, LOW);      
  delay                       (40)  ;
  digitalWrite(15, HIGH);   
  delay (75)  ;
  digitalWrite(15, LOW);    
  delay (30)  ;
  digitalWrite(15, HIGH);   
  delay (75)  ;
  digitalWrite(15, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(25, LOW); // air 4 off     
    
 //  Gun 5    
   delay  (1180)  ;
    
  digitalWrite(26, HIGH);  //air 5 on               
  delay (100) ;
  digitalWrite(6, LOW); // heat 5 off   
  digitalWrite(16, HIGH);  //flash sequence 5 begins      
  delay                   (100) ;
  digitalWrite(10, HIGH);   // heat 9 on    
  digitalWrite(16, LOW);      
  delay                       (40)  ;
  digitalWrite(16, HIGH);   
  delay (75)  ;
  digitalWrite(16, LOW);    
  delay (30)  ;
  digitalWrite(16, HIGH);   
  delay (75)  ;
  digitalWrite(16, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(26, LOW); // air 5 off     
    
 //  Gun 6    
   delay  (1180)  ;
    
  digitalWrite(27, HIGH);  //air6 on                
  delay (100) ;
  digitalWrite(7, LOW); // heat 6 off   
  digitalWrite(17, HIGH);  //flash sequence 6 begins      
  delay                   (100) ;
  digitalWrite(17, LOW);      
  delay                       (40)  ;
  digitalWrite(17, HIGH);   
  delay (75)  ;
  digitalWrite(17, LOW);    
  delay (30)  ;
  digitalWrite(17, HIGH);   
  delay (75)  ;
  digitalWrite(17, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(27, LOW); // air 6 off     
    
 //  Gun 7    
   delay  (1180)  ;
    
  digitalWrite(28, HIGH);  //air 7 on               
  delay (100) ;
  digitalWrite(8, LOW); // heat 7 off   
  digitalWrite(18, HIGH);  //flash sequence 7 begins      
  delay                   (100) ;
  digitalWrite(18, LOW);      
  delay                       (40)  ;
  digitalWrite(18, HIGH);   
  delay (75)  ;
  digitalWrite(18, LOW);    
  delay (30)  ;
  digitalWrite(18, HIGH);   
  delay (75)  ;
  digitalWrite(18, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(28, LOW); // air 7 off     
    
 //  Gun 8    
   delay  (1180)  ;
    
  digitalWrite(29, HIGH);  //air 8 on               
  delay (100) ;
  digitalWrite(9, LOW); // heat 8  off    
  digitalWrite(19, HIGH);  //flash sequence 8 begins      
  delay                   (100) ;
  digitalWrite(19, LOW);      
  delay                       (40)  ;
  digitalWrite(19, HIGH);   
  delay (75)  ;
  digitalWrite(19, LOW);    
  delay (30)  ;
  digitalWrite(19, HIGH);   
  delay (75)  ;
  digitalWrite(19, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(29, LOW); // air 8 off     
    
 //  Gun 9    
   delay  (1180)  ;
    
  digitalWrite(30, HIGH);  //air9 on                
  delay (100) ;
  digitalWrite(10, LOW); // heat 9 off    
  digitalWrite(20, HIGH);  //flash sequence 9 begins      
  delay                   (100) ;
  digitalWrite(20, LOW);      
  delay                       (40)  ;
  digitalWrite(20, HIGH);   
  delay (75)  ;
  digitalWrite(20, LOW);    
  delay (30)  ;
  digitalWrite(20, HIGH);   
  delay (75)  ;
  digitalWrite(20, LOW); //flash seq. ends    
  delay (200) ; 
  digitalWrite(30, LOW); // air 9 off     
    
  delay (1000)  ;
  digitalWrite (21, LOW);  // air manifold off    
    
  delay(120000UL*200);  // Final delay allows 6.7 hrs before firing loop begins again.   (120sec*200=24,000*1hr/3600sec=6.7hrs)   
                                          // Essentially ends sketch repitition, since total sailing time is much less than 6.7hrs    
 }    
 // To repeat firing sequence:    
   // - turn off board power with R/C switch    
   // - re-power board with R/C switch    

Yes, LOL. But that is what is important: it works for you.

If I was at the big rig I would find it hard to resist writing this "properly" and I predict there will be someone who can't. Resist. Writing. This.

One thing you might be able to hack is a better method for retriggering than a full power cycle. OTOH it works, so.

a7

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.