Multiple Arduino functions without delay

here is an alternate approach you can try

I have not included the actual digital IO, you already know how to do that but it does use a rudimentary state machine that should work for you and is easy extended if you need

the code does compile on an arduino but I have not uploaded or tested it yet

it will run every 6 seconds, will never re-run until the state machine is complete and reached the 6 seconds (Or should behave that way )

hope it helps, I will try to execute it and verify i got it right over the next few days but you can have a look now and try it for your self if you feel lucky

// constants
#define  solenoidOnTime 25 // 25mS
#define  LEDBuzzerTime 500 // 500mS
#define  SolenoidDelayTime 2000 // 2 seconds
#define  LoopTime 6000 // 6 seconds

#define LEDPin 8
#define BUZZERPin 9
#define SOLENOIDPin 11

//variables
double LoopTrigger = 0; // loop timer
int stateMachineValue = -1; // state tracker “-1” = waiting for trigger
double nextState = 0; // used by the state machine function for timing

void setup()
{
  Serial.begin(9600); // add other initialization stuff
  LoopTrigger = millis();
  stateMachineValue = 0; // start state machine
}

void loop()
{
  if ( (LoopTrigger <= (millis() - LoopTime)) && (stateMachineValue == -1)) // waiting for trigger and looptime has elapsed
  {
    stateMachineValue = 0 ; // start the state machine
    LoopTrigger = millis(); // reset loop timer, not this will not trigger until the state machine has completed
  }
  stateMachine();
}

void stateMachine()
{
  switch (stateMachineValue)
  {
  case 0: 
    {
      nextState = millis();
      LEDBUZZERON();
      stateMachineValue ++; // next state
      break;
    }
  case 1: 
    {
      if(nextState <= (millis()-LEDBuzzerTime))
      {
        nextState = millis();
        LEDBUZZEROFF();
        stateMachineValue++; // next state
        break;
      }
    }
  case 2: 
    {
      if(nextState <= (millis()-SolenoidDelayTime))
      {
        nextState = millis(); 
        SOLENOIDON();
        stateMachineValue++; 
        break;
      }
    }
  case 3: 
    {
      if(nextState <= (millis()-solenoidOnTime))
      {
        nextState = millis(); 
        SOLENOIDOFF();
        stateMachineValue == -1;  // end state machine
        break;
      }
    }
    default:
    {
      LEDBUZZEROFF();
      SOLENOIDOFF();
    }
  }
}
void  LEDBUZZERON()
{
  Serial.println("LED and Buzzer ON");
}
void  LEDBUZZEROFF()
{
  Serial.println("LED and Buzzer OFF");
}
void  SOLENOIDON() 
{
  Serial.println("LED and Buzzer ON");
}
void  SOLENOIDOFF() 
{
  Serial.println("LED and Buzzer OFF");
}

here is an alternate approach you can try

I have not included the actual digital IO, you already know how to do that but it does use a rudimentary state machine that should work for you and is easy extended if you need

the code does compile on an arduino but I have not uploaded or tested it yet

it will run every 6 seconds, will never re-run until the state machine is complete and reached the 6 seconds (Or should behave that way )

hope it helps, I will try to execute it and verify i got it right over the next few days but you can have a look now and try it for your self if you feel lucky

// constants
#define  solenoidOnTime 25 // 25mS
#define  LEDBuzzerTime 500 // 500mS
#define  SolenoidDelayTime 2000 // 2 seconds
#define  LoopTime 6000 // 6 seconds

#define LEDPin 8
#define BUZZERPin 9
#define SOLENOIDPin 11

//variables
double LoopTrigger = 0; // loop timer
int stateMachineValue = -1; // state tracker “-1” = waiting for trigger
double nextState = 0; // used by the state machine function for timing

void setup()
{
  Serial.begin(9600); // add other initialization stuff
  LoopTrigger = millis();
  stateMachineValue = 0; // start state machine
}

void loop()
{
  if ( (LoopTrigger <= (millis() - LoopTime)) && (stateMachineValue == -1)) // waiting for trigger and looptime has elapsed
  {
    stateMachineValue = 0 ; // start the state machine
    LoopTrigger = millis(); // reset loop timer, not this will not trigger until the state machine has completed
  }
  stateMachine();
}

void stateMachine()
{
  switch (stateMachineValue)
  {
  case 0: 
    {
      nextState = millis();
      LEDBUZZERON();
      stateMachineValue ++; // next state
      break;
    }
  case 1: 
    {
      if(nextState <= (millis()-LEDBuzzerTime))
      {
        nextState = millis();
        LEDBUZZEROFF();
        stateMachineValue++; // next state
        break;
      }
    }
  case 2: 
    {
      if(nextState <= (millis()-SolenoidDelayTime))
      {
        nextState = millis(); 
        SOLENOIDON();
        stateMachineValue++; 
        break;
      }
    }
  case 3: 
    {
      if(nextState <= (millis()-solenoidOnTime))
      {
        nextState = millis(); 
        SOLENOIDOFF();
        stateMachineValue == -1;  // end state machine
        break;
      }
    }
    default:
    {
      LEDBUZZEROFF();
      SOLENOIDOFF();
    }
  }
}
void  LEDBUZZERON()
{
  Serial.println("LED and Buzzer ON");
}
void  LEDBUZZEROFF()
{
  Serial.println("LED and Buzzer OFF");
}
void  SOLENOIDON() 
{
  Serial.println("LED and Buzzer ON");
}
void  SOLENOIDOFF() 
{
  Serial.println("LED and Buzzer OFF");
}

That is amazing, thank you. I'll be able to check it with the rig on Tuesday, but it looks perfect.

Everyone's help has been so so appreciated!

One question -- So should I set the tone and potentiometer the same way? I should define the tone/LED/solenoid as outputs and the potentiometer as an input  in the void setup and keep the "lick" set up as is, correct?

sorry -- I am just not 100% what you are referring to when you say the "actual digital IO". I know, I am very knew to all of this and it must seem trivial, but I want to make sure I have it all set up correctly.

is this how it should all come together?

#include <elapsedMillis.h> //the timer. 


//stopwatches
elapsedMillis timer;  


// constants  
int solenoidOnTime = 25; // 25mS  
int LEDBuzzerTime  = 500; // 500mS  
int SolenoidDelayTime = 2000; // 2 seconds  
int LoopTime = 6000; // 6 seconds  
  
int LEDPin = 8;
int BUZZERPin = 9;  
int SOLENOIDPin = 11;  
int LICK = 4;


int playTime = 500;  //how long speakers will play for
int freq = 8000;  //frequency for left prize speakers in hz
int toneTime = 500;   
  
  
//variables  
double LoopTrigger = 0; // loop timer  
int stateMachineValue = -1; // state tracker “-1” = waiting for trigger  
double nextState = 0; // used by the state machine function for timing  
  
void setup()  
{  
  Serial.begin(9600); // initialization stuff  
  pinMode(LICK, INPUT);  
  pinMode(LEDPin, OUTPUT); 
  pinMode(SPEAKERPin, OUTPUT);
  pinMode(SPOLENOIDPin, OUTPUT);
  LoopTrigger = millis();  
  stateMachineValue = 0; // start state machine  
  elapsedMillis timer = 0;
}  
  
void loop()  
{  
  int lickstate = digitalRead(lick);
 if (lickstate == HIGH){
    //    Serial.println(lickstate);
    Serial.println(timer);  
    
  if ( (LoopTrigger <= (millis() - LoopTime)) && (stateMachineValue == -1)) // waiting for trigger and looptime has elapsed  
  {  
    stateMachineValue = 0 ; // start the state machine  
    LoopTrigger = millis(); // reset loop timer, not this will not trigger until the state machine has completed  
  }  
  stateMachine();  
}  
  
void stateMachine()  
{  
  switch (stateMachineValue)  
  {  
  case 0:   
    {  
      nextState = millis();  
      LEDBUZZERON(); 
       
      stateMachineValue ++; // next state  
      break;  
    }  
  case 1:   
    {  
      if(nextState <= (millis()-LEDBuzzerTime))  
      {  
        nextState = millis();  
        LEDBUZZEROFF();  
        stateMachineValue++; // next state  
        break;  
      }  
    }  
  case 2:   
    {  
      if(nextState <= (millis()-SolenoidDelayTime))  
      {  
        nextState = millis();   
        SOLENOIDON();  
        stateMachineValue++;   
        break;  
      }  
    }  
  case 3:   
    {  
      if(nextState <= (millis()-solenoidOnTime))  
      {  
        nextState = millis();   
        SOLENOIDOFF();  
        stateMachineValue == -1;  // end state machine  
        break;  
      }  
    }  
    default:  
    {  
      LEDBUZZEROFF();  
      SOLENOIDOFF();  
    }  
  }  
}  
void  LEDBUZZERON()  
{  
  Serial.println("LED and Buzzer ON");  
  Serial.println (timer)
}  
void  LEDBUZZEROFF()  
{  
  Serial.println("LED and Buzzer OFF"); 
  Serial.println (timer) 
}  
void  SOLENOIDON()   
{  
  Serial.println("Solenoid ON");  
  Serial.println (timer)
}  
void  SOLENOIDOFF()   
{  
  Serial.println("Solenoid OFF");  
  Serial.println (timer)
} 

looks like your on the right track, keep it up

I would be pleased to see your progress as you move forward

If you need more help, please ask

Peter

What is the Lick for, is the system waiting for a fuzzy creature to lick the end of a pipe for a drink to trigger the system or is the idea to “Train” said fuzzy creature to come lick the pipe 2 seconds after it hears or sees the alarm signal (LED/Buzzer) and record if it does come and lick ?

Peter

Spot on!

I m still playing around with the statemachine code trying to get it ironed out -- what statemachine library did you include, FMS?

There is no library, what you see is it

for something this simple there was no need for additional libraries

is it working for you or are you having issues, as I stated above, I was able to compile but did not have time to test it

look forward to your feedback

Peter

It does compile -- but there is still an issue with the ending of one command and the beginning of another. Where should I put the actual command for turning on/off a pin? For instance, should I put digitalWrite(LEDPin, HIGH); in the void LEDBUZZEROn section or in the case 0 zero section? I assume it is necessary to put that (or something like it) in the code, otherwise i'm not clear on how the arduino will receive the command to turn a pin on/off.

yes you need to add the digital write etc to the code, i figured you knew how to do that part already, I have empty functions for that in the sample that currently just output the expected behaviour to the serial console

so LEDBUZZERON would have code added to turn on the LED and the Buzzer

LEDBUZZEROFF would have code added to turn off the buzzer and led

etc.

If it is still confusing, let me know and ill add some more code but I cant get to it till the weekend

Regards

Peter

Hopefully I can sort it out myself! Just to clarify-- will the digitalWrite prices of the code go under the void LEDBUZZERON() sections or will they be in the place of "LEDBUZZERON" etc. in the void statemachine() region of the code?

thank you!