buenos dias consulta sensor temporal con millis y rele

mi pregunta es como hago que cuando el sensor detecte movimiento active un rele por un periodo de tiempo, establecido en el codigo, y luego se apague para luego prenderse nuevamente en el caso que haiga un movimiento usando la funcion millis. ya que el proyecto tiene varios reles pero solo uno se utiliza con el sensor.
qui esta el codigo el cual consigo prenderlo pero luego ya no se apaga, osea no sale del bucle, para leer de vuelta el estado del sensor.
agradeceria mucho alguna sugerencia para mi proyecto

/*
control de varios reles
Enciende y apaga reles, conectado a un pin digital 13, 12 y 11 con la funcion if y millis de arduino.
*/

// asignacion de los pines para cada rele
const int pin_rele = 13;
const int pin_rele2 = 12;
const int pin_rele3 = 11;
const int pin_sensor = 8;
const int pin_alimentacion_sensor = 9;
int valor = 0;
int valor_alimentacion= 0;

// Variables que cambiarán:
int estado_rele = LOW; // estado inicial usado para configurar el rele Nº1
int estado_rele2 = LOW; // estado inicial usado para configurar el rele Nº2
int estado_rele3 = LOW; // estado inicial usado para configurar el rele Nº3

// se declara varibles que tendran el valor prendido o apagado

int on = HIGH;
int off = LOW;

// varible que se utilizara de intervalo de reloj que se tomará para comvertirlo de milisegundo a segundos

long intervalo_segundo;

// declaracion de variables e intervalos de tiempo para los reles Nº1, 2 y 3 con sus respectivos tiempos y valores

int intervalo1_rele = 5;
int estado_rele_1 = on; //prendido
int intervalo2_rele = 5;
int estado_rele_2 = off; //apagado
int intervalo3_rele = 5;
int estado_rele_3 = on; //prendido
int intervalo4_rele = 5;
int estado_rele_4 = off; //apagado
int intervalo5_rele = 5;
int estado_rele_5 = on; //prendido

int intervalo1_rele2 = 4;
int estado_rele2_1 = on;
int intervalo2_rele2 = 4;
int estado_rele2_2 = off;
int intervalo3_rele2 = 8;
int estado_rele2_3 = on;
int intervalo4_rele2 = 20;
int estado_rele2_4 = off;
int intervalo5_rele2 = 25;
int estado_rele2_5 = on;

int intervalo1_rele3 = 6;
int estado_rele3_1 = on;
int intervalo2_rele3 = 2;
int estado_rele3_2 = off;
int intervalo3_rele3 = 10;
int estado_rele3_3 = on;
int intervalo4_rele3 = 10;
int estado_rele3_4 = off;
int intervalo5_rele3 = 15;
int estado_rele3_5 = on;

// declaracion de varibles que se utilizaran para contadores y asi poder cerar los segundos para cada intervalo

int operacionrele = 0;
int operacionrele2 = 0;
int operacionrele3 = 0;

// se asignan variables para acumular el tiempo en segundos

int segundos_rele ;
int segundos_rele2 ;
int segundos_rele3 ;

// variable utilizables si se requiere en escala de tiempo de horas o minutos

int decimas_rele;
int minutos_rele;
int hora_rele;

void setup() {

// se configura el pin digital como pin de salida
pinMode(pin_rele, OUTPUT);
pinMode(pin_rele2, OUTPUT);
pinMode(pin_rele3, OUTPUT);
pinMode(pin_sensor, INPUT);
pinMode(pin_alimentacion_sensor, OUTPUT);

Serial.begin(9600);

// intervalo de reloj que se tomará para comvertirlo de milisegundo a segundos
intervalo_segundo = 1000;
}

void loop()
{
// codigo que correra repetidamente

//---------------------------------------------------------------------------------------------

long milisegundos = millis(); // se carga el valor de la funcion millis en la variable millsegundos
valor_alimentacion = digitalRead(pin_alimentacion_sensor); // lee el estado del sensor para luego cargar el valor en la variable
digitalWrite(pin_alimentacion_sensor, HIGH); // escribe el valor alto en el pin q alimentará al sensor
valor = digitalRead(pin_sensor); // lee el estado del sensor para luego cargarla en la variable

if (milisegundos == intervalo_segundo) // condicion para que se ejecute el codigo de los reles repetidamente
{

intervalo_segundo += 1000; // suma intervalo_segundo + 1000, para luego empesar a incrementar el intervalo_luz cada mil ciclos (1 segundo)

segundos_rele2++; // se incrementa en +1 la variable cada 1000 milisengudos
segundos_rele3++; // se incrementa en +1 la variable cada 1000 milisengudos
//----------------------------------------------------------------------------------------------

// inicio de bloque de codigo para el rele Nº1

if (valor == HIGH)
{
segundos_rele++; // se incrementa en +1 la variable cada 1000 milisengudos
if ((segundos_rele <= intervalo1_rele) && operacionrele == 0)
{

digitalWrite(pin_rele, estado_rele_1);

if (segundos_rele >= intervalo1_rele )
{
operacionrele = 1;
segundos_rele=0;
digitalWrite(pin_rele, estado_rele_2);
}
}
}

// final de bloque de codigo para el rele Nº 1

//---------------------------------------------------------------------------------------------

// inicio de bloque de codigo para el rele Nº2

if ((segundos_rele2 <= intervalo1_rele2 ) && operacionrele2 == 0)
{

digitalWrite(pin_rele2 , estado_rele2_1 );

if (segundos_rele2 >= intervalo1_rele2 )
{
operacionrele2 = 1;
segundos_rele2 =0;
}
}
if ((segundos_rele2 <= intervalo2_rele2 ) && operacionrele2 == 1)
{
digitalWrite(pin_rele2 , estado_rele2_2);

if (segundos_rele2 >= intervalo2_rele2 )
{
operacionrele2 = 2;
segundos_rele2 =0;
}
}
if ((segundos_rele2 <= intervalo3_rele2 ) && operacionrele2 == 2)
{
digitalWrite(pin_rele2 , estado_rele2_3);

if (segundos_rele2 >= intervalo3_rele2 )
{
operacionrele2 = 3;
segundos_rele2 =0;
}
}

if ((segundos_rele2 <= intervalo4_rele2 ) && operacionrele2 == 3)
{
digitalWrite(pin_rele2, estado_rele2_4);

if (segundos_rele2 >= intervalo4_rele2 )
{
operacionrele2 = 4;
segundos_rele2 =0;
}
}

if ((segundos_rele2 <= intervalo5_rele2 ) && operacionrele2 == 4)
{
digitalWrite(pin_rele2 , estado_rele2_5);

if (segundos_rele2 >= intervalo5_rele2 )
{
operacionrele2 = 5;
segundos_rele2 =0;
}

}
// final de bloque de codigo para el rele Nº 2

//---------------------------------------------------------------------------------------------

// inicio de bloque de codigo para el rele Nº 3

if ((segundos_rele3 <= intervalo1_rele3) && operacionrele3 == 0)
{

digitalWrite(pin_rele3, estado_rele3_1);

if (segundos_rele3 >= intervalo1_rele3 ){
operacionrele3 = 1;
segundos_rele3=0;
}
}

if ((segundos_rele3 <= intervalo2_rele3) && operacionrele3 == 1)
{
digitalWrite(pin_rele3, estado_rele3_2);

if (segundos_rele3 >= intervalo2_rele3 )
{
operacionrele3 = 2;
segundos_rele3=0;
}
}

if ((segundos_rele3 <= intervalo3_rele3) && operacionrele3 == 2)
{
digitalWrite(pin_rele3, estado_rele3_3);

if (segundos_rele3 >= intervalo3_rele3)
{
operacionrele3 = 3;
segundos_rele3=0;
}
}

if ((segundos_rele3 <= intervalo4_rele3) && operacionrele3 == 3)
{
digitalWrite(pin_rele3, estado_rele3_4);

if (segundos_rele3 >= intervalo4_rele3 )
{
operacionrele3 = 4;
segundos_rele3=0;
}
}

if ((segundos_rele3 <= intervalo5_rele3) && operacionrele3 == 4)
{
digitalWrite(pin_rele3, estado_rele3_5);

if (segundos_rele3 >= intervalo5_rele3 )
{
operacionrele3 = 5;
segundos_rele3=0;
}
}
// final de bloque de codigo para el rele Nº 3

//---------------------------------------------------------------------------------------------

// impresion en pantalla valores de variables

Serial.println (“estado de Sensor”);
Serial.println(valor);
Serial.println (“estado de alimentacion sensor”);
Serial.println(valor_alimentacion);
Serial.println (“estado de rele1”);
Serial.println(pin_rele);

}

}

moderator remarks:

  • code tags missing
  • moved to spanish section

controlar los 4 reles por un periodo de tiempo real con millis seria la pregunta agregado con un PIR de movimiento

creo que te has liado bastante, haz esto:

sensor PIR=cierto{
rele=on;
variable=millis()}

si (millis() > (variable+tiempo deseado)) {
rele=off}

espero que esto te oriente, pasalo a codigo y pueba. Para cuatro reles es lo mismo pero primero prueba con uno.