Sensores de incendio


Hay diferentes forma de detectar un posible incendio. Normalmente se suele utilizar una combinación de componentes diseñados para detectar condiciones asociadas con un incendio, como humo, calor, llamas o gases específicos. Los componentes principales suelen incluir:

  • Sensores de Gas :pueden ser sensores electroquímicos que detectan gases específicos, como monóxido de carbono (CO), que son comunes durante un incendio o sensores de semiconductores que detecta cambios en la conductividad eléctrica cuando está expuesto a gases inflamables o tóxicos.
  • Sensores de Humo: pueden ser en forma de cámara óptica o fotoeléctrica utilizando un haz de luz y un fotodetector para identificar partículas de humo en el aire o bien con sensores de ionización detectando partículas de humo a nivel molecular mediante la ionización del aire.
  • Sensores de Calor: se implementan mediante termistores o termopares (detectan cambios en la temperatura), sensores de temperatura fija (se activan cuando la temperatura alcanza un umbral predefinido) o sensores de velocidad de cambio de temperatura detectanod aumentos rápidos en la temperatura (detección por tasa de subida).
  • Sensores de Llama: pueden ser sensores de infrarrojo (IR): Detecta la radiación infrarroja emitida por las llamas, sensores ultravioleta (UV): Detectan la radiación ultravioleta emitida por llamas, especialmente en la etapa inicial del incendio y sensores duales UV/IR: Combina detección UV e IR para minimizar falsas alarmas.

Ejemplo práctico de sensor fotoeléctrico

Veamos ahora un posible sensor de detección de llama usando una placa Arduino usando un sensor fotoeléctrico compacto . El diseño del sensor usado es típico con un voltaje de funcionamiento de 3,3 V-5 V y con una salida de voltaje analógico para una detección precisa de la llama. Puede detectar llamas o luz dentro de una longitud de onda de 760 ~ 1100 nm, con un ángulo de detección de 60 grados . Este sensor cuenta con un potenciómetro azul para ajustar la sensibilidad. La salida del comparador cuenta con una fuerte capacidad de conducción de más de 15 mA para una detección de llama confiable, lo que garantiza una detección precisa de la llama.

El circuito como vemos es muy simple pues basta conectar la alimentación de 5v y la salida analógica al puerto 6 del Arduino (o compatible). Por simplificar al detectar humo solo conectaremos el led interno, pero obviamente podemos conectar , un buzzer piezoeléctrico, un relé , etc. a otro pin libre del Arduino.

El módulo detector de llama también como vemos incluye un comparador LM393 y un potenciómetro para ajustar la sensibilidad de detección.

Obviamente el componente más importante de este módulo es el sensor receptor de infrarrojos, que detecta una llama dado que el fuego produce energía en forma de calor y luz, cuyo espectro de luz va desde el ultravioleta hasta el infrarrojo. Este último se puede detectar con el sensor.

Conectaremos pues la señal de salida D0 del módulo al pin 6 de nuestro microcontrolador y la alimentación y con el siguiente código podemos probar su funcionamiento:

int flame_sensor = 6;
int  val;

void  setup() {
      pinMode(LED_BUILTIN, OUTPUT);
      pinMode(flame_sensor, INPUT);
      Serial.begin(9600);
}

void  loop() {
      val = digitalRead(flame_sensor);
      if(val==HIGH) {
            digitalWrite(LED_BUILTIN,HIGH);
            Serial.println("Fire not detected");   
      } else {
            digitalWrite(LED_BUILTIN,LOW);
            Serial.println("Fire detected !!!!");
      }
}


Ejemplo práctico de sensor de humo

Otro tipo de sensores , son los sensores de humo como por ejemplo el Sensor MQ-2. Este tipo de sensores sirven para la detección de GLP, i-butano, propano, metano, alcohol, hidrógeno y humo.
De modo similar a otros sensor tiene sensibilidad ajustable , su tensión de funcionamiento es de 5V DC y cuenta tanto con con una salida analógica (valor medido) y una salida digital (valor umbral).

Este sensor se utiliza para detectar humo y gases inflamables. Se pueden medir concentraciones de gas de 300 a 10000 ppm.

Los sensores de gas MQ utilizan un pequeño calentador con un sensor electroquímico que cambia su resistencia en función de la concentración de gas en el aire. El voltaje de alimentación del módulo debe ser de 5 VDC para que el calentador funcione correctamente, motivo por el cual en algunas placas compatibles con Arduino alimentadas con 3.3v usaremos un convertidor cc/cc para elevar la salida del 3.3 a 5V DC ( además se debe utilizar una fuente de alimentación externa para obtener suficiente energía).

En la imagen podemos ver los pines de conexión: alimentación de 5v DC (VCC y GND) y las dos salidas (analógica y digital).

Este sensor se utiliza en interiores a temperatura ambiente y como se ha comentado dispone de una salida digital y otra analógica que es la que utilizamos en el prototipo conectado al pin analógico A2. También en caso de usar algunas variante de Arduino deberemos usar un convertidor dc/dc para obtener los 5v DC para alimentar al sensor. Por simplificar al detectar humo sacamos un mensaje por la consola pero conectar también el led interno, y obviamente podemos conectar , un buzzer piezoeléctrico, un relé , etc. a otro pin libre del Arduino.

int smokeA2 = A2;
int sensorThres = 400;

void setup() {
      pinMode(smokeA2, INPUT);
      Serial.begin(9600);
}

void loop() {
      int analogSensor = analogRead(smokeA2);

      Serial.print("Pin A2: ");
      Serial.println(analogSensor);

      if (analogSensor > sensorThres) {
            Serial.println("Gas detected");
      } else {
            Serial.println("No gas detected");
      }
      delay(100);
}

Este módulo de gas MQ-2 es capaz de detectar GLP, i-butano, propano, metano, alcohol, hidrógeno y humo, lo que puede ser útil en la detección de fugas de gas y humo. Por cierto, si lo conectamos a un Arduino UNO el esquema se simplifica bastante como podemos ver a continuación.

Divertido dispensador de caramelos o lo que se tercie


A veces para hacer realidad ideas , actualmente no hace falta grandes desarrollos o un despliegue de recursos desorbitado, porque como vamos a ver, realizar un dispensador de caramelos , una hucha o incluso un alimentador para animales puede ser realmente casi una tarea relativamente sencilla.

En Internet, se pueden ver dispensadores de caramelos con un motor lineal y piezas de la impresora 3D. En muchas paginas también se muestra una colección de chatarra con viejas unidades de CD/DVD donde tanto el cajón como el cabezal de lectura se mueven de esta manera. Así que diseccionar una unidad antigua puede ser emocionante, pero al final no parece adecuado para los nuevos tiempos, por lo que la alternativa es un servomotor.

En efecto para llevar a cabo el nuevo proyecto con tecnología actual , todo lo que necesita es un microcontrolador, LED y botones, así como un potente servomotor, además de algunos retoques y muchas dosis de creatividad.

Hardware

1Microcontrolador Uno
1Prototyping Shield, alternativamente Mini Breadboard
2RGB LEDs
1Servo de engranajes metálicos MG90S, MG995, MG996R
1Botón (aquí botón arcade con LED)
Optar.Zumbador activo (zumbador)
Cable de puente y fuente de alimentación: 4 pilas AA
aprox. 1 mCanal de cables 60x40mm de la ferretería, cinta adhesiva

En primer lugar, aquí está el componente más importante, el

Dispensador de caramelos

Quizas la tarea mas compleja es la caja donde ira el dispensador de caramelos que queremos qeu se pueda abrir o cerrar automaticamente

El dispensador de caramelos se puede realizar con un canal de cables 60×40 mm y el servobrazo extendido con tubo retráctil unido al baston del servo.

Desafortunadamente, no está en la gama AZ-Delivery el botón iluminado, ya que se usa en las consolas arcade. Por supuesto, también puedes usar otros botones.

Li dea es sencilla: los niños presionan la nariz roja de una cara de payaso ligeramente espeluznante, los ojos rojos se vuelven verdes, después de 2,5 segundos los ojos parpadean dos veces y el servomotor gira 90° para empujar un pequeño paquete de dulces.

Se puede pintar el cuadro, imprimirlo o pegarlo como un patchwork.

Toda la configuración no está pensada para durar para siempre, por lo que los componentes electrónicos y las baterías están en una caja de cartón.

Se utilizan LEDs RGB con un cátodo común. Este tiene la pata más larga del LED RGB, la pata única de un lado es para el componente rojo, las dos patas del otro lado son para el verde y el azul.

Se utilizan los pines del microcontrolador Arduino usando el GPIO 3 para el rojo, el GPIO 4 para GND, el GPIO 5 para el verde y el GPIO 6 para el azul, en primer lugar para poder atenuar opcionalmente los LED (3, 5 y 6 tienen PWM) y en segundo lugar para activar tanto el guiño como el zumbador opcional ajustando brevemente el GPIO 4 a HIGH. 

Se conectan los dos «ojos» (LED RGB) en paralelo. Opcionalmente, se podrían controlar individualmente usando un pin adicional del GPIO .

Todo el conjunto cabe en una caja de cartón que podemos cerrar para que no se vea el mecanismo. En la imagen , a la derecha vemos el aspecto del Arduino Uno con Escudo de Prototipos ( para el buzzer ). En la parte de la derecha vemos los 2 LED RGB y el botón iluminado (igual que los usados en consolas de juegos)

Esquemático

El circuito como vemos en la imagen es bastante simple usando sólo pines digitales :

  • El GPIO 8 lo conectamos al pulsador ( y el otro a masa)
  • El GPIO 3 lo conectamos al pin rojo de cada led RGB.
  • El GPIO 4 lo conectamos a la masa de cada led
  • El GPIO 5 lo conectamos al pin verde de cada led RGB.
  • El GPIO 9 lo conectamos al led interno del pulsador
  • El GPIO 10 conectamos al pin de datos del servo ( también necesitará 5v DC para los otros dos terminales)
  • El GPIO 5 también lo conectamos al zumbador.

Este es el aspecto del conjunto al que ha añadido la alimentación consistente en 4 pilas AA que nos dan una tensión final de unos 6 Voltios.

Código Arduino

El código controla un rostro de payaso con LEDs RGB como ojos y un botón grande con un LED como nariz. El comportamiento es el siguiente:

  1. Operación normal: Los ojos (LEDs) están en rojo y el botón tiene un LED rojo encendido.
  2. Cuando se presiona el botón:
    • Los ojos se vuelven verdes y el LED del botón se apaga durante 6 segundos.
    • Después de 2.5 segundos, los ojos verdes parpadean y suena un zumbador dos veces.
    • Un servo se activa para empujar dulces.

Explicación del código:


Inclusión de la librería Servo:

#include <Servo.h>
Servo myservo;  // Crear objeto servo para controlar un servo
int pos = 0;    // Variable para almacenar la posición del servo


Definición de pines:

const int buttonPin = 8; // Pin del botón
const int redledPin = 3; // Pin del LED rojo
const int gndledPin = 4; // Pin de tierra común para LEDs
const int greenledPin = 5; // Pin del LED verde
const int blueledPin = 6; // Pin del LED azul
const int ledPin = 9; // Pin del LED en el botón


Variables:

int buttonState = 0; // Variable para leer el estado del botón


Configuración inicial:

void setup() {
 pinMode(redledPin, OUTPUT);
 pinMode(gndledPin, OUTPUT);
 digitalWrite(gndledPin, LOW);
 pinMode(greenledPin, OUTPUT);
 pinMode(blueledPin, OUTPUT);
 pinMode(ledPin, OUTPUT);
 pinMode(buttonPin, INPUT_PULLUP);
 myservo.attach(10); // Conectar el servo al pin 10
 myservo.write(130);
 delay(500);
}


Función para mover el servo:

void servoturn() {
 for (pos = 130; pos >= 20; pos -= 1)
 {myservo.write(pos);
  delay(10);
 }
 for (pos = 20; pos <= 130; pos += 1) 
  { myservo.write(pos);
  delay(10); 
  }
}


Bucle principal:

void loop() {
 buttonState = digitalRead(buttonPin);
 if (buttonState == LOW) {
  digitalWrite(redledPin, LOW);
  digitalWrite(ledPin, LOW);
  digitalWrite(greenledPin, HIGH);
  delay(2500);
  digitalWrite(gndledPin, HIGH);
  delay(250);
  digitalWrite(gndledPin, LOW);
  delay(250);
  digitalWrite(gndledPin, HIGH);
  delay(250);
  digitalWrite(gndledPin, LOW);
  servoturn();
  delay(2500);
 } else {
  digitalWrite(greenledPin, LOW);
  digitalWrite(ledPin, HIGH);
  digitalWrite(redledPin, HIGH);
 }
}

Por cierto , en la secuencia descrita en el código, el zumbador se activa después de que los ojos (LEDs verdes) han estado encendidos durante 2.5 segundos. Aquí está el detalle:

  1. Después de 2.5 segundos de que los ojos se vuelven verdes, el zumbador suena brevemente dos veces.
  2. Esto se logra mediante el parpadeo del LED común a tierra (gndledPin), que simula el sonido del zumbador.

El código para esto es:

delay(2500);  // Espera 2.5 segundos
digitalWrite(gndledPin, HIGH);  // Activa el zumbador (simulado)
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, LOW);  // Desactiva el zumbador
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, HIGH);  // Activa el zumbador nuevamente
delay(250);  // Espera 0.25 segundos
digitalWrite(gndledPin, LOW);  // Desactiva el zumbador

Este parpadeo del LED común a tierra (gndledPin) simula el sonido del zumbador, creando un efecto de sonido breve dos veces.

Funcionamiento general

  • Estado normal: Los ojos (LEDs) están en rojo y el LED del botón está encendido.
  • Al presionar el botón:
    1. Los ojos se vuelven verdes y el LED del botón se apaga.
    2. Después de 2.5 segundos, los ojos verdes parpadean y el zumbador suena brevemente dos veces.
    3. El servo motor se activa para empujar dulces.

RESUMEN Y CODIGO COMPLETO

En resumen, el código controla LEDs y un servo para crear un efecto de cara de payaso interactiva para Halloween o lo que se quiera.

En las siguientes líneas podemos ver el código completo Arduino para probar el montaje anterior.

<Servo.h>
Servo myservo; // create servo object to control a servo
int pos = 0; // variable to store the servo position

// constants won’t change. They’re used here to set pin numbers:
const int buttonPin = 8;      // the number of the pushbutton pin
const int redledPin =  3;     // the number of the red LED pin
const int gndledPin =  4;     // the number of the common ground LED pin
const int greenledPin =  5;   // the number of the green LED pin
const int blueledPin =  6;    // the number of the blue LED pin
const int ledPin =  9;       // the number of the LED pin in button

// variables will change:
int buttonState = 0;          // variable for reading the pushbutton status

void setup() {
 // initialize the LED pin as an output:
 pinMode(redledPin, OUTPUT);
 pinMode(gndledPin, OUTPUT);
 digitalWrite(gndledPin, LOW);    
 pinMode(greenledPin, OUTPUT);
 pinMode(blueledPin, OUTPUT);
 pinMode(ledPin, OUTPUT);  
 // initialize the pushbutton pin as an input:
 pinMode(buttonPin, INPUT_PULLUP);
 myservo.attach(10); // attaches the servo on Pin 10 to the servo object
 myservo.write(130);
 delay(500);  
}  // end setup

void servoturn()   {    // adjust angles acc. to your setup
   for (pos = 130; pos >= 20; pos -= 1) {
   // goes from 120 degrees to 20 degrees
   // in steps of 1 degree
   Serial.println(pos);
   myservo.write(pos);
   delay(10);
   }
 for (pos = 20; pos <= 130; pos += 1) {
   // goes from 20 degrees to 120 degrees
   Serial.println(pos);  
   myservo.write(pos);
   delay(10);
   }
}  // end servoturn

void loop() {
 // read the state of the pushbutton value:
 buttonState = digitalRead(buttonPin);
 // check if the pushbutton is pressed. If it is, the buttonState is LOW:
 if (buttonState == LOW) {
   // turn green LED on, red LED off:
   digitalWrite(redledPin, LOW);
   digitalWrite(ledPin, LOW);    
   digitalWrite(greenledPin, HIGH);
   delay(2500);
   digitalWrite(gndledPin, HIGH);     
   delay(250);
   digitalWrite(gndledPin, LOW);
   delay(250);
   digitalWrite(gndledPin, HIGH);     
   delay(250);
   digitalWrite(gndledPin, LOW);
   servoturn();      
   delay(2500);        
 } else {
   // turn green LED off red LED on:
   digitalWrite(greenledPin, LOW);
   digitalWrite(ledPin, HIGH);      
   digitalWrite(redledPin, HIGH);    
 }
}  // end loop