Using Millis() and a while if statement is creating a delay to read other callfn

I know you will comment on how I post I am not new but post very infrequently. My code works, and I believe the when{if{ is what is creating the program to not look at other call functions. I could be wrong, but I cannot get my led to blink even though I’m calling all functions to create no delay.

All and any help is appreciated.

  void Sensor()   {
       if(digitalRead(pirPin) == HIGH){
            while(millis() < time_now + period*60000){
              if(millis() > time_now5 + period*60000){
              counter = counter+1;
               Serial.println("The number of events : "); 
               Serial.println(counter);
                time_now5 = millis();}
              digitalWrite(ledPin, LOW);   //the led visualizes the sensors output pin state
              if(millis() > time_now2 + 10000){
              Serial.print("motion detected HOLD ");
              Serial.print(millis()/1000);
              Serial.println(" sec"); 
              delay(50);
              time_now2 = millis();
              }
              takeLowTime = true;  
            if(lockLow){                  //makes sure we wait for a transition to LOW before any further output is made:
             lockLow = false;
             if(millis() > time_now3 + 1000){            
             Serial.println("---");
             Serial.print("motion detected at ");
             Serial.print(millis()/1000);
             Serial.println(" sec"); 
             delay(50);
             time_now3 = millis();
             }  
            }     
           }
       }

Please post your complete program

I’m calling all functions to create no delay.

    while (millis() < time_now + period * 60000)

What about this while loop that causes the program to stay in the function for at least 60 seconds.

Sure

/* 
 * PIR SENSOR with a count for every event and a millis pause when active 
 */

/////////////////////////////
int period = 10;                       // minutes
unsigned long time_now = 0;
unsigned long time_now2 = 0; 
unsigned long time_now3 = 0;
unsigned long time_now4 = 0;
unsigned long time_now5 = 0;
int counter = 0;

//VARS
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)

#define blueLed 13

unsigned long previousMillis = 0;        // stores last time Led blinked

long interval = 200;           // interval at which to blink (milliseconds)

//----------
int calibrationTime = 10;        

//the time when the sensor outputs a low impulse
long unsigned int lowIn;         

//the amount of milliseconds the sensor has to be low 
//before we assume all motion has stopped
long unsigned int pause = 1000;  

boolean lockLow = true;
boolean takeLowTime;  

int pirPin = 2;    //the digital pin connected to the PIR sensor's output
int ledPin = 12;   // solenoid pin


/////////////////////////////
//SETUP
void setup(){
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);
//----
    // set the digital pin as output:
  pinMode(blueLed, OUTPUT);
//----
  //give the sensor some time to calibrate
  Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){
      Serial.print(".");
      delay(1000);
      }
    Serial.println(" done");
    Serial.println("SENSOR ACTIVE");
    delay(50);
    
  }

////////////////////////////
//LOOP

void loop(){
       
       Ser();
       Blink();
       time_now = millis();
       Sensor();
}
       
void Ser()  {

if(millis() > time_now4 + 10000){
    Serial.println();
    Serial.print("The number of events : ");
    Serial.print(counter);
    Serial.println();
    Serial.print(period);
    Serial.print("   - Minutes for delay on");
        Serial.println();
  time_now4 = millis();}
  }
       
  void Sensor()   {
       if(digitalRead(pirPin) == HIGH){
            while(millis() < time_now + period*60000){
              if(millis() > time_now5 + period*60000){
              counter = counter+1;
               Serial.println("The number of events : "); 
               Serial.println(counter);
                time_now5 = millis();}
              digitalWrite(ledPin, LOW);   //the led visualizes the sensors output pin state
              if(millis() > time_now2 + 10000){
              Serial.print("motion detected HOLD ");
              Serial.print(millis()/1000);
              Serial.println(" sec"); 
              delay(50);
              time_now2 = millis();
              }
              takeLowTime = true;  
            if(lockLow){                  //makes sure we wait for a transition to LOW before any further output is made:
             lockLow = false;
             if(millis() > time_now3 + 1000){            
             Serial.println("---");
             Serial.print("motion detected at ");
             Serial.print(millis()/1000);
             Serial.println(" sec"); 
             delay(50);
             time_now3 = millis();
             }  
            }     
           }
       }
       

     if(digitalRead(pirPin) == LOW){       
       digitalWrite(ledPin, HIGH);  //the led visualizes the sensors output pin state

       if(takeLowTime){
        lowIn = millis();          //save the time of the transition from high to LOW
        takeLowTime = false;       //make sure this is only done at the start of a LOW phase
        }
       //if the sensor is low for more than the given pause, 
       //we assume that no more motion is going to happen
       if(!lockLow && millis() - lowIn > pause){  
           //makes sure this block of code is only executed again after 
           //a new motion sequence has been detected
           lockLow = true;
           if(millis() > time_now2 + 1000){ 
           Serial.println("---");                       
           Serial.print("motion ended at ");      //output
           Serial.print((millis() - pause)/1000);
           Serial.println(" sec");
           delay(50);
           time_now2 = millis();
           }
       }
       }
  }
void Blink()      {
        //-/---
        if (millis() - previousMillis >= interval) {
                                                          // save the last time you blinked the LED
        previousMillis = millis();
        digitalWrite(blueLed, !digitalRead(blueLed));     //change led state
    
  }
}

Did you note my previous comment about this while loop ?

void Sensor()
{
  if (digitalRead(pirPin) == HIGH)
  {
    while (millis() < time_now + period * 60000)
    {

Before calling the Sensor function period is set to 10 and time_now is set to millis() so the code will not exit the while loop until 600000 milliseconds has elapsed once pirPin goes HIGH. Is that what you intend to happen ?

void Sensor()   {
  if (digitalRead(pirPin) == HIGH) {
    while (millis() < time_now + period * 60000) {
      if (millis() > time_now5 + period * 60000) {
        counter = counter + 1;
        Serial.println("The number of events : ");
        Serial.println(counter);
        time_now5 = millis();
      }
      digitalWrite(ledPin, LOW);   //the led visualizes the sensors output pin state
      if (millis() > time_now2 + 10000) {
        Serial.print("motion detected HOLD ");
        Serial.print(millis() / 1000);
        Serial.println(" sec");
        delay(50);
        time_now2 = millis();
      }
      takeLowTime = true;
      if (lockLow) {                //makes sure we wait for a transition to LOW before any further output is made:
        lockLow = false;
        if (millis() > time_now3 + 1000) {
          Serial.println("---");
          Serial.print("motion detected at ");
          Serial.print(millis() / 1000);
          Serial.println(" sec");
          delay(50);
          time_now3 = millis();
        }
      }
    }
  }


  if (digitalRead(pirPin) == LOW) {
    digitalWrite(ledPin, HIGH);  //the led visualizes the sensors output pin state

    if (takeLowTime) {
      lowIn = millis();          //save the time of the transition from high to LOW
      takeLowTime = false;       //make sure this is only done at the start of a LOW phase
    }
    //if the sensor is low for more than the given pause,
    //we assume that no more motion is going to happen
    if (!lockLow && millis() - lowIn > pause) {
      //makes sure this block of code is only executed again after
      //a new motion sequence has been detected
      lockLow = true;
      if (millis() > time_now2 + 1000) {
        Serial.println("---");
        Serial.print("motion ended at ");      //output
        Serial.print((millis() - pause) / 1000);
        Serial.println(" sec");
        delay(50);
        time_now2 = millis();
      }
    }
  }
}

This function is doing a lot; maybe more than a single function ought to. You should look into introducing a State Machine approach to managing the Sensor.

Yes i do intend it to not exit for the 600,000 ms but i do not know any other way "language based" to run this code for that period of time. Do you know of a way to incorporate the millis() for a extended timeframe without being contained in the while loop?

I guess i need to rethink this portion. I will read up on state machine approaches. Do you have any links where i can read up on this type of coding?

Thank again

cyrut2:
I guess i need to rethink this portion. I will read up on state machine approaches. Do you have any links where i can read up on this type of coding?

Try googling State Machine, or YouTube.

@cyrut2

1. Will you please describe, briefly in text, the purpose of your program?
2. I have executed your program, and I have observed the following:
(a) DPin-2 = LOW; RESET UNO. After a while blueLed (built-in LED of UNO) starts blinking. DPin-12 becomes active.

(b) DPin-2 = HIGH; RESET UNO. After a while blueLed becomes ON. DPin-12 remains inactive.

3. What is the meaning of this – " I cannot get my led to blink even though I’m calling all functions to create no delay."

GolamMostafa:
3. What is the meaning of this -- " I cannot get my led to blink even though I'm calling all functions to create no delay."

Seems obvious, the blocking nature of sensor() prevents the non-blocking blink function from executing.

Im using a PIR sensor with a kind a delay for the bluelight(solenoid) to remain on. To know status of active there is a blink of onboard led at the interval set. You walk in from of the sensor light remains on for x amount of minutes. As each event occurs it hits a counter which will then be translated by x number of events lights up a led. There is serial feedback to understand the state of the cpu or operation. The end project will be more complicated and im trying to get all these elements under one arduino. This is the first time i use millis, call functions, or while conditions so im slowly progressing.

A function called Sensor() should be just sensing. Don't have it also do the timing and output.

Your main loop could look something like...

void loop() {
  Sensor();
  if(sensedSomethingNew()) startTimer();
  if(timerIsActive) turnOutputOn(); else turnOutputOff();
}

Also, I have the relay cycle as the pir sensor becomes active to ensure that it has progressed from the setup to loop function. It does go high then low. Thanks, everyone for the responses I will do some light reading on your recommendations.

Got it! I just wrote it, so I haven't thought it through thoroughly. I will do just that and also research on machine state etc. I think I was over complicating things.