If you're lazy ellapsedMillis also works really well. To my eyes it also results in more easily readable code, I use it a lot.

Several options here, and a couple folks have pointed out some challenges.

"Best" answer -- probably to use a real-time clock (RTC) board to assist your timing, and effectively set a target time (next motor run is at 23:14...) each time the cycle restarts. By saving this target off (to the EEPROM or an SD card for instance), you'd protect against a potential shutdown and reset of the arduino in the middle.

Secondary answer; set your loop() to include a relatively short delay() statement, then check the elapsed time since the last motor engagement. This would allow you to have other items processing, as someone else noted in this thread. This I've pseudocoded below.

unsigned long lastMotorRunTime;

void loop()
{
    /*
     * do whatever 
     */
    if(millis()-lastMotorRunTime > 21600000)  // 6 hours have passed
    {
         runTheMotor(); // placeholder for the motor movements you need
         lastMotorRunTime = millis();
    }
   /* 
    * do other stuff 
    */
   delay(100); // loop about every 1/10 second, or whatever works
}

Given you don't seem to need detailed precision -- a few seconds either way wouldn't matter -- this should work reasonably. Note it WILL fail if the Ardiuno is reset -- then it will only (in my pseudocode) rotate the motor 6 hours after the last Arduino reset. Probably better to assume that an arduino reset means move the motor 'now', if the point is to ensure periodic motion rather than precise timing.

For precise timing, as noted, the RTC would be required.

(Updated: Changed lastMotorRunTime to unsigned long)

There is no absolute need for any Arduino program to use delay()

The blink without delay sketch that is included in the standard sketch examples is the canonical illustration of this.

In most cases you don't need to poll your sensors thousands of times a second. It is good discipline to only poll sensors as often as makes sense for the specific application. Sometimes this might be once every five minutes. For example an ambient temperature sensor. In those cases there is nothing to be gained be polling a thousand times a second. To do so wastes resources and is a poor habit that could be troublesome for battery powered applications.

For example, the use of millis() for timing allows you to effectively poll several peripherals each at different intervals, perhaps averaging some readings to reduce noise, perhaps also updating a display at other intervals that suit human perception.

For long running battery powered applications it is likely that you will benefit from finding out about putting the microcontroller to sleep using sleep() or deepSleep() and using interrupts to wake it. A real time clock (RTC) or the watchdog timer interrupt can perhaps be used to schedule your sensor readings and other actions, perhaps in conjunction with millis().

For very simple programs that don't need precise timings. delay() can be the simplest and clearest way to manage timings.

In-depth explanation of delay() VS millis() in Arduino:What is delay()?The delay(ms) function is a simple way to pause your program for a specific duration (in milliseconds). While using delay(), the microcontroller does nothing except wait, effectively blocking all other code execution.Example: Blinking an LED using delay()Here’s a basic example of using delay() to blink an LED every second: const int ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); // Turn LED on delay(1000); // Wait for 1 second digitalWrite(ledPin, LOW); // Turn LED off delay(1000); // Wait for 1 second } This works, but there's a major drawback: nothing else can run while delay() is active. If you need to read a sensor, receive serial input, or perform another task during the delay, it won’t be possible. What is millis()?The millis() function returns the number of milliseconds since the Arduino board was powered on or reset. Unlike delay(), millis() does not stop program execution. Instead, it allows you to track elapsed time while still performing other tasks.Example: Blinking an LED without delay() using millis()Instead of stopping everything for a delay, we can check if enough time has passed and then toggle the LED. const int ledPin = 13; unsigned long previousMillis = 0; // Store the last time LED was updated const long interval = 1000; // Blink interval (1 second) void setup() { pinMode(ledPin, OUTPUT); } void loop() { unsigned long currentMillis = millis(); // Get the current time // Check if 1000ms (1 second) has passed since the last LED update if (currentMillis - previousMillis >= interval) { previousMillis = currentMillis; // Save the last time LED changed state digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED state } }   In this example:The LED toggles every second without blocking the loop. Other code can run simultaneously, such as reading sensors, handling inputs, or controlling motors. When should you use millis() instead of delay()?You should use millis() when:1. You need to run multiple tasks at once (e.g., read sensors while controlling LEDs).2. You need a responsive program that can handle inputs in real time.3. You want to avoid blocking the execution of other parts of the code.4. You are working with interrupts, communication protocols, or multitasking logic.delay() is only suitable for very simple programs where no other tasks need to run during the wait time.Multitasking with millis()Let’s say we want to:1. Blink an LED every 1 second.2. Read a button press every 100ms.3. Print a message every 2 seconds.Using millis(), we can handle all three tasks without blocking execution: const int ledPin = 13; const int buttonPin = 2; unsigned long previousLedMillis = 0; unsigned long previousButtonMillis = 0; unsigned long previousMessageMillis = 0; const long ledInterval = 1000; const long buttonInterval = 100; const long messageInterval = 2000; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); Serial.begin(9600); } void loop() { unsigned long currentMillis = millis(); // Blink LED every 1 second if (currentMillis - previousLedMillis >= ledInterval) { previousLedMillis = currentMillis; digitalWrite(ledPin, !digitalRead(ledPin)); } // Check button state every 100ms if (currentMillis - previousButtonMillis >= buttonInterval) { previousButtonMillis = currentMillis; if (digitalRead(buttonPin) == LOW) { Serial.println("Button Pressed!"); } } // Print a message every 2 seconds if (currentMillis - previousMessageMillis >= messageInterval) { previousMessageMillis = currentMillis; Serial.println("Hello from Arduino!"); } } This allows everything to run independently without interference, making the code much more efficient and responsive.