The simplest option is to use delay() to implement the waits:

void loop() {
    turn_motor_on();
    delay(10000);  // 10 seconds
    turn_motor_off();
    delay(600000);  // 10 minutes
}

Since these long numbers may be difficult to read, you can make them more readable by defining some units:

const unsigned long second = 1000;
const unsigned long minute = 60000;

Then you can for example delay(10 * minute);

Beware there is a trap if you try to do arithmetics with integer literals. The following:

delay(10 * 60 * 1000);  // BUG!

will not work on most Arduinos, as the multiplications will be performed on the int data type, which can only hold numbers up to 32,767. It is safer to use either explicitly typed constants (unsigned long is the appropriate type for delays) or integer literals typed with the suffix UL (which stands for “unsigned long”).

Note that the Arduino will do no useful work while delaying. If you want to do any kind of work during the delay, see the “Blink Without Delay” Arduino example.

It seems that you need to explicitly set numeric literals to long (L) and they use them. Otherwise it does not work. If anyone can explain if there is any kind of automatic conversion it will be awesome but until then simply use:

unsigned long seconds = 1000L; // !!! SEE THE CAPITAL "L" USED!!!
unsigned long minutes = seconds * 60;
unsigned long hours = minutes * 60; 

and then simply use delay(millisec) as usual:

delay(5 * minutes);

It worked for me.

Yes, absolutely, it should work. But your code will be easier to read if you use some constants, like:

const unsigned long SECOND = 1000;
const unsigned long HOUR = 3600*SECOND;

delay(7*HOUR);

You should always update the comments you have in your code when you are changing it.

For the solution you should change the for loop that puts your board to idle mode. The code: LowPower.idle(SLEEP_8S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF,SPI_OFF, USART0_OFF, TWI_OFF); Will put your board to idle for 8 seconds + the time the board needs to wake up. So you should change the for loop time_interval. From the code that you posted you are using the time_interval only for the for loop so instead of calculating it inside of it you can set it to 12 minutes on initialization: const int time_interval = 12 * 60; // 12 minute wake up interval in seconds .

The start of the for loop would then be like that: for(int i = 0; i < time_interval / 8; i++) The division by 8 could be done in the initialization, but it is more clear to have it in for loop that is putting the board to idle for 8s each round.

If your timings need to be more precise you need to take into account wake-up times and delays that you have in your code.

dont do arithmetic operation on such function, why not just write delay(120000); instead?. if you want to make arithmetic operations, is better to separe the operation, like this:

long int timeDelay1 = 60*2*1000;
delay(timeDelay1);

such long delay is not very good practice, instead used the funtion millis() to measure time, like this:

    long int t0 = 0;
    long int t1 = 0;
    
    long int howManyTimeIWantToWait = 120000;
    
    void setup() {
      t0 = millis();  
    
    }
    
    void loop() {
      t1 = millis();
      if(t1 >= (t0+howManyTimeIWantToWait)){
        t0 = millis();
          //howManyTimeIWantToWait has been passed
      
      }
      //do other stuff whithout waiting on the function delay();
    }

The real time clock method is the most accurate way but otherwise use millis

unsigned long startMillis = millis();
while (millis() - startMillis < LONG_DELAY_MS);

This will delay up to approx. 4294967295ms (2^32-1) or 49 days, after which the timer will catch up to the value of startMillis