Consola de disparo pirotécnico

International Español Proyectos
1

Buenas noches a todos:

Os presento mi proyecto sencillo para ver si me podéis ayudar un poco a resolver algunas dudas. Según vaya aprendiendo lo iré haciendo mas completo.

Consiste mediante reles, para poder separar un circuito de secuencia de los disparadores, cada vez que se activa el rele cierra un circuito prendiendo un artefacto pirotécnico.

Dispongo de una placa Arduino Mega, una placa de 8 reles (los reles se activan por LOW), un pulsador con su resistencia y dos led con su resistencia.

Proyecto 1.0.:
Consiste en que una vez se realice una pulsación de dos segundos, se iniciaría una secuencia de parpadeo de dos led de advertencia durante un tiempo y se seguirá por conectar el rele 1º por un segundo y su posterior des-conexión, esperar 35 segundos y conectar el rele 2º por un segundo y su posterior des-conexión, esperar 60 segundos y continuara con esta dinámica hasta el rele 8º que una vez se produzca su des-conexión se pare todo.

Este es el código que he empezado escribir para que me ayudéis a completarlo, me falta hacer que no se repita y ajustar el pulsador para que tras pulsarlo durante dos segundos se inicie la secuencia.

const int ReleDisparador1 = 23; //Primer rele que activara el articulo pirotécnico
const int ReleDisparador2 = 25;
const int ReleDisparador3 = 27;
const int ReleDisparador4 = 29;
const int ReleDisparador5 = 31;
const int ReleDisparador6 = 33;
const int ReleDisparador7 = 35;
const int ReleDisparador8 = 37; //Octavo rele que activara el articulo pirotécnico

const int Activador = 2; // Pulsador de disparo de la secuencia

const int LedAlarma1 = 7; // Led indicador de comienzo de la secuencia
const int LedAlarma2 = 8; // Led indicador de comienzo de la secuencia

int EstadoActivador = 0; // Variable para leer el estado del pulsador
int Activar = 0; // Variable para activar rele, tiene que ser 0 ya que el modelo de rele se activa por LOW
int Desactivar = 1; // Variable para desactivar un rele, tiene que ser 1 ya que el modelo de rele se desactiva por HIGH
int Encender = 1; // Variable para encender un led
int Apagar = 1; // Variable para apagar un led

void setup() {

pinMode(ReleDisparador1, OUTPUT);
pinMode(ReleDisparador2, OUTPUT);
pinMode(ReleDisparador3, OUTPUT);
pinMode(ReleDisparador4, OUTPUT);
pinMode(ReleDisparador5, OUTPUT);
pinMode(ReleDisparador6, OUTPUT);
pinMode(ReleDisparador7, OUTPUT);
pinMode(ReleDisparador8, OUTPUT);

pinMode(Activador, INPUT);

pinMode(LedAlarma1, OUTPUT);
pinMode(LedAlarma2, OUTPUT);

digitalWrite(ReleDisparador1, Desactivar); // Esto es para desactivar todos los reles ya que la placa de los reles a si lo requiere
digitalWrite(ReleDisparador2, Desactivar);
digitalWrite(ReleDisparador3, Desactivar);
digitalWrite(ReleDisparador4, Desactivar);
digitalWrite(ReleDisparador5, Desactivar);
digitalWrite(ReleDisparador6, Desactivar);
digitalWrite(ReleDisparador7, Desactivar);
digitalWrite(ReleDisparador8, Desactivar);

digitalWrite(LedAlarma1, Apagar);
digitalWrite(LedAlarma2, Apagar);

}

void loop(){

EstadoActivador = digitalRead(Activador);
// <===================================================Falta modificar para que cumpla
// que se tiene que apretar durante dos segundos
if (EstadoActivador == HIGH) {
digitalWrite(LedAlarma1, Encender); //Se encienden dos led de alarma que se alternam
delay(5000);
digitalWrite(LedAlarma1, Apagar);
digitalWrite(LedAlarma2, Encender);
delay(5000);
digitalWrite(LedAlarma2, Apagar);
digitalWrite(LedAlarma1, Encender);
delay(3000);
digitalWrite(LedAlarma1, Apagar);
digitalWrite(LedAlarma2, Encender);
delay(3000);
digitalWrite(LedAlarma2, Apagar);
digitalWrite(LedAlarma1, Encender);
delay(2000);
digitalWrite(LedAlarma1, Apagar);
digitalWrite(LedAlarma2, Encender);
delay(2000);
digitalWrite(LedAlarma2, Apagar); //Finalizan los led de alarma

digitalWrite(ReleDisparador1, Activar); // Activa el rele
delay(1000); // todo esto durante 1 seg
digitalWrite(ReleDisparador1, Desactivar); // hasta que se apaga
delay(35000); // y espera 35 seg que es lo que duraría el articulo pirotécnico

digitalWrite(ReleDisparador2, Activar); // Activa el rele
delay(1000); // todo esto durante 1 seg
digitalWrite(ReleDisparador2, Desactivar); // hasta que se apaga
delay(60000); // y este dura 60 seg

digitalWrite(ReleDisparador3, Activar); // Activa el rele
delay(1000); // todo esto durante 1 seg
digitalWrite(ReleDisparador3, Desactivar); // hasta que se apaga
delay(60000); // y este dura 60 seg

// y los siguientes reles
// <====================================================Falta añadir para que no se repita
}
}

Quedo a la espera de vuestra ayuda.

Un saludo y agradeceros vuestra ayuda por adelantado.

2

Buenas, y bienvenido

Yo no te recomiendo que uses el delay() para el parpadeo del led, delay() paraliza el micro, y no daras controlado el tiempo que mantiene el pulsador activo.

Prueba algo así:

#define OF HIGH      // Encender apagar reles
#define ON LOW


byte PinRele[] = {23,25,27,29,31,33,35,37};  // Reles que activara el articulo pirotécnico
byte PinLed1  = 7;                           // Led indicador de comienzo de la secuencia
byte PinLed2  = 8;                           // Led indicador de comienzo de la secuencia
byte Activador = 2;                          // Pulsador de disparo de la secuencia

bool EstadoActivador=false;                  // Variable para leer el estado del pulsador
bool EstadoAnterior=false;                   // Variable para controlar tiempo pulsado

bool EstadoLed1=false;                       // Led 1 apagado
bool EstadoLed2=false;                       // Led 2 apagado

unsigned long T_a_Pulsar=3000;               // Tiempo a mantener pulsado para arrancar la secuencia
unsigned long T_Pulsado=0;                   // Para controlar el tiempo que permanece el boton pulsado
unsigned long T_Pulso_Led=0;                 // Tiempo que parpadea el led
unsigned long T_Led=0;                       // Para controlar el tiempo de parpadeo del led
unsigned long T_Rele_Activo=1000;            // Tiempo que permanecera activo cada rele
unsigned long T_Rele[]={3000,3000,3000,3000,3000,3000,3000,3000};  // Tiempo de espera entre reles

void setup() 
{
  pinMode (Activador, INPUT);
  for (int x=0;x<8;x++)
  {
    pinMode (PinRele[x], OUTPUT);               
    digitalWrite(PinRele[x], OF);            
  }  
  pinMode (PinLed1, OUTPUT);
  pinMode (PinLed2, OUTPUT);  
  digitalWrite(PinLed1, EstadoLed1);             
  digitalWrite(PinLed1, EstadoLed2);  
}

void loop() 
{
  EstadoActivador = digitalRead(Activador);    // Leer pin con reistencia pull_up
  //EstadoActivador = !digitalRead(Activador);   // Leer pin con reistencia pull_down
  if (!EstadoActivador)                        // Pulsador no pulsado
  {
    EstadoLed1=false;
    EstadoLed2=false;
  }
  else 
  {                                        
    if (EstadoActivador!=EstadoAnterior)       // Pulsador cambio a pulsado,
    {
      T_Pulsado=millis() + T_a_Pulsar;         // Almacenamos tiempo para inciar
      T_Pulso_Led=175;                         // Tiempo del primer parpadeo del led
      T_Led=millis();                          // Tiempo que controla parpadeo del led2
    }  
    else                                       // Pulsador permanece pulsado
    {
      if (millis()>T_Led)                      // Finalizo timepo espera led
      {
        EstadoLed1=!EstadoLed1;                // Cambiams estado apagado-encendido
        EstadoLed2=!EstadoLed1;                // Uno enciende y el otro apaga
        T_Pulso_Led=T_Pulso_Led-4;             // Reducimos tiempo siguiente parpadeo
        T_Led=millis() + T_Pulso_Led;          // Tiempo que controla parpadeo del led2
      }
      if (millis()>T_Pulsado)                  // Finalizo timepo espera Activador
      {
        EstadoLed1=true;                       // Encendemos led 1
        EstadoLed2=true;                       // Encendemos led 2 
        digitalWrite(PinLed1, EstadoLed1);             
        digitalWrite(PinLed2, EstadoLed2);
        for (int x=0;x<8;x++)                  // Recorremos los 8 reles
        {             
          digitalWrite(PinRele[x], ON);        // Encender rele
          delay(T_Rele_Activo);                // Tiempo que permanece el rele activo
          digitalWrite(PinRele[x], OF);        // Apagar rele
          delay(T_Rele[x]);                    // Tiempo de espera entre reles         
        }
        EstadoLed1=false;                      // Apagamos led 1
        EstadoLed2=false;                      // apagamos led 2
      }      
    }
  }
  EstadoAnterior=EstadoActivador;              // Almacenar ultimo estado pulsador
  digitalWrite(PinLed1, EstadoLed1);             
  digitalWrite(PinLed2, EstadoLed2);
}
3

Muchisimas gracias Marcial.

Menudo código has desarrollado, me has dejado impresionado, se nota que estoy muy en pañales.

Gracias a tu código he sacado muchas conclusiones que me servirán según evolucione el proyecto.

De nuevo agradecerte el gran trabajo

4

Hay personal muy bueno en el foro, en mi caso me conformo con mediocre bajo :blush: