Crear un temporizador

Buenas, quisiera saber como crear otro temporizador para mi proyecto. Se trata de un medidor de rayos UV utilizando NodeMCU Wifi. Lo que quiero hacer es que el primer temporizador se ejecute después de un minuto de encender el proyecto, después otro que cada 20 min compruebe el índice UV. El tercero no es de importancia, es para que se restablezcan los valores del temporizador.

#include <ESP8266WiFi.h>
#define PubNub_BASE_CLIENT WiFiClient
#include <PubNub.h>
 
const static char ssid[] = "SSID";
const static char pass[] = "xxxxxxx"; 

int sendTimer; // Temporizador utilizado para controlar la frecuencia con la que se publican los mensajes. Envía un nuevo mensaje una vez cada 10 minutos.
int sensorTimer; // Temporizador utilizado para controlar la frecuencia con la que se comprueba el sensor. Comprobado cada 60 segundos.
float sensorValue; // Valor del sensor.
int lastuvindex; //Bucle indice UV
int uvindex; // Valor del sensor convertido a índice UV

void setup() {
    Serial.begin(9600);
    WiFi.begin(ssid, pass);
    if(WiFi.waitForConnectResult() == WL_CONNECTED){
      Serial.println("WiFi connected.");
      PubNub.begin("pub-xxxxxxxxxxxxx", "sub-c-xxxxxxxxxx");
    } else {
      Serial.println("Couldn't get a wifi connection.");
      while(1) delay(100);
    }
}
 
void loop() {
    sensorTimer = (sensorTimer + 1); 
    if (sensorTimer == 60) { //Comprobar el sensor cada 60 segundos
      sensorTimer = 0;
      
      sendTimer = (sendTimer + 1);
      if (sendTimer == 10) { //Restablecer el sensor cada 10 min
        sendTimer = 0;
      }
      sensorValue = analogRead(A0);
      if ((sensorValue >= 0) && (sensorValue < 10)) {
        uvindex = 0; 
      }
      else if ((sensorValue >= 10) && (sensorValue < 65)) {
        uvindex = 1;
      }
      else if ((sensorValue >= 65) && (sensorValue < 83)) {
        uvindex = 2;
      }
      else if ((sensorValue >= 83) && (sensorValue < 103)) {
        uvindex = 3;
      }
      else if ((sensorValue >= 103) && (sensorValue < 124)) {
        uvindex = 4;
      }
      else if ((sensorValue >= 124) && (sensorValue < 142)) {
        uvindex = 5;
      }
      else if ((sensorValue >= 142) && (sensorValue < 162)) {
        uvindex = 6;
      }
      else if ((sensorValue >= 162) && (sensorValue < 180)) {
        uvindex = 7;
      }
      else if ((sensorValue >= 180) && (sensorValue < 200)) {
        uvindex = 8;
      }
      else if ((sensorValue >= 200) && (sensorValue < 221)) {
        uvindex = 9;
      }
      else if ((sensorValue >= 221) && (sensorValue < 240)) {
        uvindex = 10;
      }
      else if (sensorValue >= 240) {
        uvindex = 11;
      }
      if ((lastuvindex != uvindex) || (sendTimer == 0)) {
        lastuvindex = uvindex;
        sendTimer = 0;
        PubNub_BASE_CLIENT *client;
        Serial.println("publishing a message");
        char msg[64] = "{\"eon\":{\"uvindex\":"; 
        sprintf(msg + strlen(msg), "%d", uvindex);
        strcat(msg, "}}");
        client = PubNub.publish("uvindex", msg);
        if (!client) {
            Serial.println("publishing error");
            delay(1000);
            return;
        }
        while (client->connected()) {
            while (client->connected() && !client->available());
            char c = client->read();
            Serial.print(c);
        }
        client->stop();
        Serial.println();
      } 
    }
    delay(1000);
}

Generalmente uso un array de estructura para los temporizadores, entre otros. No me gusta generar una cascada de variables para cada timer, pero esto no es sino una forma de programar personal.

  1. Generamos una estructura con los valores necesarios para los timer; se puede repetir, el intervalo, el tiempo total -> millis().
  2. Creamos un array de esta estructura con índice igual al número de temporizadores.
  3. La variable de intervalo no la ponemos unsigned para poder poner valores negativos y usarlo a modo de Flag para detener en la condición los timers.
  4. Creamos una variable estática en el loop que será el indice del array que actuará como un bucle for al estar en el loop.
  5. Cuando se cumple la condición del timer realizamos la acción que queramos en función del índice del temporizador donde estemos en ese momento
/*
* Ejercicio temporizadores Cuantron.com
*/

//macro
#define SIZE(x) (sizeof(x) / sizeof(x[0]))

//estructura

struct temporizador{
  bool se_repite;
  int intervalo;
  unsigned long tiempo;        
};

temporizador temp[3] = {
  {false, 60000, 0}, // se ejecuta tras 1 minuto y no se repite
  {true, -1,  0},    // valores negativos no entran hasta que el valor cambie
  {true, -1, 0},        
};

void setup(){
	Serial.begin(9600);
}

void loop(){
  static byte index_temp;
  if(temp[index_temp].intervalo > 0 && millis() - temp[index_temp].tiempo >= temp[index_temp].intervalo){
    if(temp[index_temp].se_repite){
      temp[index_temp].tiempo = millis();
    }
    else{
      temp[index_temp].intervalo = -1;
    }
    switch(index_temp){
      case 0 : // temporizador 1
        Serial.println("1 min Tras encender");
        //iniciamos el temporizador 2 cada 10 segundos
        temp[1].intervalo = 10000;
      	temp[1].tiempo = millis();
        //inciamos el temporizador 3 cada 20
        temp[2].intervalo = 20000;
      	temp[2].tiempo = millis();
      break;
      case 1 : // temporizador 2
      	Serial.println("Han pasado 10 seg");
      break;
      case 2 : // temporizador 3
      	Serial.println("Han pasado 20 seg");
      break;
    }
  }
  index_temp = ((index_temp + 1) == SIZE(temp) ? 0 : index_temp + 1 );
}

Por tanto el timer 1 se ejecuta tras 1 minuto (y no se repite) y activa otros dos timers que se repetirán cada 10 y 20 segundos respectivamente.
Espero que te ayude cómo una posibilidad.

En caso que tu sketch necesite que la acción de varios temporizadores coincidan previo dar la vuelta al ciclo loop cambia la variable estática por un simple for de 0 a < tamaño del array y listo.

sensorTimer = (sensorTimer + 1); 

No es un temperizador, es un contador usado como tal.
Lo que te propone @cuantron si se aprovecha de millis() que es un temporizador que lleva el tiempo desde que el arduino se ha energizado. Con tomar fotos o valores de los momentos que uno desea se puede hacer casi cualquier cosa.
Para entender lo que te ha propuesto el compañero busca Arduino structure y lee al respecto.