Acionamento de motor junto com datalogger (PROBLEMA - DÚVIDA)

Bom dia pessoal... estou com um problema que gostaria de resolver, e se puderem me ajudar agradeço.

Estou com um projeto de um motor que é acionado de 2 em 2 horas. E junto com esse projeto gostaria de usar um sensor de temperatura e luminosidade.

No entanto, no código que eu fiz, o delay do motor interfere no datalogger dos sensores.

Gostaria que os sensores coletassem de 5 em 5 minutos, mas eles estão coletando os dados no tempo que defini para o motor.

Sou leigo em programação, conheço um pouco de eletrônica.
Alguém poderia me ajudar nesse problema?

Obrigado.

PS: Segue o código que fiz até então:

//Programa : Modulo Rele Arduino 2 canais com motores e sensores
//Autor : THIERRY

int sensor = 1; //Pino analógico em que o sensor está conectado.
int valorSensor = 0; //variável usada para ler o valor do sensor em tempo real.
const int LM35 = A0; // Define o pino que lera a saída do LM35 - sensor de temperatura
float temperatura; // Variável que armazenará a temperatura medida
int porta_rele1 = 7; //Porta ligada ao pino IN1 do modulo
int porta_rele2 = 8; //Porta ligada ao pino IN2 do modulo

void setup()
{
//Define pinos para o rele como saida
pinMode(porta_rele1, OUTPUT);
pinMode(porta_rele2, OUTPUT);
Serial.begin(9600); // inicializa a comunicação serial
}

void loop()
{
digitalWrite(porta_rele1, LOW); //Liga rele 1
digitalWrite(porta_rele2, HIGH); //Desliga rele 2
delay(7200000);
digitalWrite(porta_rele1, HIGH); //Desliga rele 1
digitalWrite(porta_rele2, LOW); //Liga rele 2
delay(20);
digitalWrite(porta_rele2, HIGH); //Desliga rele 2
delay(10000);

temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Serial.print("Temperatura: ");
Serial.println(temperatura);

//Lendo o valor do sensor.
int valorSensor = analogRead(sensor);

//Exibindo o valor do sensor no serial monitor.
Serial.println(valorSensor);
delay(300000);
}

Ola,
Estou começando com o Arduino, e ajudar nos problemas dos outros me ajuda da entender melhor.
Nesse caso, vejo três possibilidades;

  1. Usar o TIMER1 (eu acho que ele) para interromper de tempos em tempos (não lembro se pode chegar a 2 horas). A rotina de interrupção pode ficar responsável pela leitura dos sensores, já que o intervalo de tempo e consideravelmente menor.
  2. Usar um RTC para disparar um alarme a cada duas horas.
  3. Melhor o código atual, incluindo um contador de tempo e condicionais. Conforme fiz abaixo.
    Pelo que entendi a cada duas horas o rele1 inverte de estado; e o rele2 somente da uma "picada",
//Programa : Modulo Rele Arduino 2 canais com motores e sensores
//Autor : THIERRY


int sensor = 1;      //Pino analógico em que o sensor está conectado.
int valorSensor = 0; //variável usada para ler o valor do sensor em tempo real.
const int LM35 = A0; // Define o pino que lera a saída do LM35 - sensor de temperatura
float temperatura; // Variável que armazenará a temperatura medida
int porta_rele1 = 7; //Porta ligada ao pino IN1 do modulo
int porta_rele2 = 8; //Porta ligada ao pino IN2 do modulo

int contador_de_tempo=0; // resolução em segundos
// Não tenho certeza se isso esta correto.
boolean rele1_estado=false; // Ou LOW, LIGA
 
void setup()
{
  //Define pinos para o rele como saida
  pinMode(porta_rele1, OUTPUT);
  pinMode(porta_rele2, OUTPUT);
  Serial.begin(9600); // inicializa a comunicação serial
  // define o estado inicial dos reles.
  digitalWrite(porta_rele1, rele1_estado);  //Liga rele 1
  digitalWrite(porta_rele2, HIGH); //Desliga rele 2
}




void loop()
{
  if (contador_de_tempo >= 7200) {
     contador_de_tempo=0;
     rele1_estado = ! rele1_estado; // inverte o estado.
     digitalWrite(porta_rele1, rele1_estado);
     digitalWrite(porta_rele2, LOW); //Liga rele 2
     delay(20); 
     digitalWrite(porta_rele2, HIGH); //Desliga rele 2
  } else {
     contador_de_tempo++; // incrementa o contador
  };
temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Serial.print("Temperatura: ");
Serial.println(temperatura);

   
  //Lendo o valor do sensor.
  valorSensor = analogRead(sensor);
   
  //Exibindo o valor do sensor no serial monitor.
  Serial.println(valorSensor);
delay(980); // Um segundo, contando com os 20ms anterior.
}

Opcionamente, poderia ler o estado atual do registrador da porta e inverter. (Não o estado físico da porta)

digitalWrite(porta_rele1, !digitalRead(porta_rele1);

Ola,
Após ler o guia de referencia, ponderar um pouco, ler algumas recomendações e textos de não faça assim, para períodos tão longos como duas horas, acredito que o código adequado seja esse abaixo.

//Programa : Modulo Rele Arduino 2 canais com motores e sensores
//Autor : THIERRY


int sensor = 1;      //Pino analógico em que o sensor está conectado.
int valorSensor = 0; //variável usada para ler o valor do sensor em tempo real.
const int LM35 = A0; // Define o pino que lera a saída do LM35 - sensor de temperatura
float temperatura; // Variável que armazenará a temperatura medida
int porta_rele1 = 7; //Porta ligada ao pino IN1 do modulo
int porta_rele2 = 8; //Porta ligada ao pino IN2 do modulo

unsigned long tempo_atual=0;
unsigned long tempo_anterior_rele=0;
unsigned long tempo_anterior_sensor=0;
boolean rele1_estado=false; // Ou LOW, LIGA
 
void setup()
{
  //Define pinos para o rele como saida
  pinMode(porta_rele1, OUTPUT);
  pinMode(porta_rele2, OUTPUT);
  Serial.begin(9600); // inicializa a comunicação serial
  // define o estado inicial dos reles.
  digitalWrite(porta_rele1, rele1_estado);  //Liga rele 1
  digitalWrite(porta_rele2, HIGH); //Desliga rele 2
}

void loop()
{
  tempo_atual=(unsigned long) millis(); // atualiza o tempo atual
  // modifica o estado dos reles a cada duas horas ou (2 * 60 * 60 * 1000)milisegundos
  if ((unsigned long) tempo_atual-tempo_anterior_rele >= 7200000) {
     tempo_anterior_rele = (unsigned long) tempo_atual;
     rele1_estado = ! rele1_estado; // inverte o estado.
     digitalWrite(porta_rele1, rele1_estado);
     digitalWrite(porta_rele2, LOW); //Liga rele 2
     delay(20);
     digitalWrite(porta_rele2, HIGH); //Desliga rele 2
  };
  // Le os sensores a cada 1 segundo.
  if ((unsigned long) tempo_atual-tempo_anterior_sensor >= 1000) {
     tempo_anterior_sensor = (unsigned long) tempo_atual;
     temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
     Serial.print("Temperatura: ");
     Serial.println(temperatura);   
     //Lendo o valor do sensor.
     valorSensor = analogRead(sensor);
     //Exibindo o valor do sensor no serial monitor.
     Serial.println(valorSensor);
  };
}

Como podem observar, substitui o delay() por millis() e comparadores. O delay() e uma operação de bloqueio, o seja o código fica parado no delay() até que o tempo estipulado passe, dependo de como o delay() e implementado até as interrupções podem ficar paradas (pelo que li, não e o caso do arduino).
O delay() pode ser usando para situações onde o tempo de espera e curto, alguns segundos. E desde que não necessite de acuidade no tempo.
O cast e para garantir que o compilador faça a associação correta de tipo, principalmente dentro do if(). Caso contrário, no overflow a subtração vai resultar em um valor incorreto (como em um signed int).