Use static variables to retain state and timestamps of the events you want to be periodic. For example, the following will set an LED in a random column on row zero, and every 250ms will move it to the next row until after reaching row 3, it will restart at a new random column.

  static int j = 0 ;
  static int i = 0 ;
  
  // When j == 0, set initial LED
  if( j == 0 )
  {
      i = random(0, 2);
      digitalWrite(LEDrows[i][j], HIGH ) ;
  }
  
     
  // Get current millisecond tick
  unsigned long now = millis() ;

  // Every 250ms move the LED     
  static unsigned long led_timestamp = millis() ;
  if( now - led_timestamp > 250 )
  {
      led_timestamp = now ;

      digitalWrite(LEDrows[i][j], LOW ) ;
      j++ ;
      if( j > 3 )
      {
          j = 0 ;
      }
      else
      {
          digitalWrite(LEDrows[i][j], HIGH ) ;
      }
  }

The general pattern is:

static unsigned long timestamp = millis() ;
unsigned long now = millis() ;

if( now - timestamp > PERIOD_MS )
{
    timestamp = now ;

    // do something every PERIOD_MS here
    ...
}

With multiple timestamp variables you can perform tasks at various independent intervals.

I was wrong being too confident about my whole code. When people suggested posting my whole code, I should have just done it!!!

Anyway, here is the mistake I made. I initialized the variable flash_time as an 8-bit integer. Of course, 8 bit can only hold up to 255. I am trying to store 9000!!! The following code has this bug fixed.

const long sleep_interval = 3000; 
const long awake_interval = 250; 
const int ledPin = 3;

const uint16_t flash_time = 9000;  //bug fixed by using uint16_t instead of uint8_t
const uint16_t t1 = 5; 
const uint16_t t2 = 495;

void flash() {  
    unsigned long x = millis();
    while(millis() - x < flash_time){ 
        digitalWrite(ledPin, HIGH);
        delay(t1);
        digitalWrite(ledPin, LOW);
        delay(t2);
    }   
}   

void setup() {
    Serial.begin(57600);  
    pinMode(ledPin, OUTPUT);
}

void loop() {
    unsigned long x = millis();
    while(millis() - x < awake_interval){
        Serial.println("flash time!");
        flash();    
    }

    unsigned long y = millis();; 
    while (millis() - y < sleep_interval) {  //sleep_interval = 3 secs
        Serial.println("Sleep time!");
    }
}

So, nested loops that use millis() to determine the terminating conditions work just fine, even if loop 1 runs for 250 ms and loop 2 (that's inside loop 1) runs for much longer, like 9 seconds.

Apologies if I have wasted too much of people's time.

You have made the code to go in the loop every “interval” ms; now you have two options:

1. create another “interval” and “previousTime” variable (changing the name of course) and place another condition inside

2. add a “delay(1000);” after the lcd.print(i).

The difference is the following:

1. you maintain the code multi-task oriented, that is, you can check if (a) you have to launch the lcd updating with the current code and (b) check if you indeed have to change the value shown in the lcd (with the new addition to the code). Whatever it is the state (update or not, change “i” or not), you can then do other things before checking again (that is, you can read a sensor or blink a LED or do whatever you need). This is the best practice to get the most out of the Microcontroller.

2. with the delay, however, your code will simply wait one second on every loop tick. This means that yOu will have 10 seconds spent (indeed, wasted) every time you get in that loop (which for a microcontroller is equivalent to years of time :D). Therefore, any other task will only happen, regardless your need, every 10 seconds. This is a waste of potential.

I avoided writing code examples to invite you to explore options. Let me know if you need some inspiration. I recommend you to give it a try, the “ingredients” are there already :)

You can do this, for quite simple sketches. It starts to become ugly if you add more features and conditions.

Therefore, the "correct^TM" (read: professional) way is to implement a state machine. See in the IDE the non-delay blink example.

const unsigned long DELAY_MS = 1000;

int pin = 13;

enum State {
    WAITING, WORKING,
};

State state;

unsigned long startTime;

void setup()
{
    pinMode(pin, INPUT);
    state = WAITING;
    startTime = millis();
}

void loop()
{
    switch (state) {
    case WAITING:
        // You can put both conditions in one "if" with an "||" operator.
        // But it will look less clear.
        if (millis() - startTime > DELAY_MS) {
            state = WORKING;
        } else if (digitalRead(pin)) {
            state = WORKING;
        }
        break;
    case WORKING:
        // anything to do after the delay or the button
        break;
    default:
        // any error handling you see fit
        break;
    }
}

The function loop() is designed to be called endlessly in repetition. Use this to your advantage.