Arduino Tutorial - Fire Alarm

About: Este é um canal para homemakers e DIY onde vai encontrar tutoriais úteis acerca de Electrónica, Arduíno, Robótica e Impressão 3D. Estes têm explicações simples e práticas que podem ser utilizadas para concre...

Olá pessoal mais uma vez a um tutorial sobre Arduino e os seus sensores, desta vez demonstramos o funcionamento e as características de um Arduino NANO, como também de 2 sensores muito utilizados em detectores de incêndio, que são sensores de fumo e de fogo (infravermelhos).

Vamos então começar por apresentar o Arduino NANO, pois esta é a primeira vez que é utilizado no nosso canal. Este comparativamente ao Arduino UNO é muito mais pequeno, no entanto, as suas funcionalidades são muito idênticas.

A placa do Arduino NANO é constituído por:

Um micro-controlador ATmega328, que dispõem de 32Kb de memória FLASH e 2Kb de memória RAM.

Apenas uma ligação Mini USB com a função de ligar o Arduíno ao computador, servindo para carregar o código com também para alimentar electricamente a própria placa.

Vários pinos de alimentação que fornecem diversos valores de tensão, podendo estes ser utilizados para alimentar electricamente os componentes do seu projecto.

Tem também 13 pinos de sinal digital, que podem ser programados como entradas ou saídas, onde 6 deste podem ter a funcionalidade de PWM (Pulse Width Modulation), um destes pino, o pino 13, está ligado um LED designado por “L”.

Alem deste tipo de pinos este Arduino tem também 8 pinos de entrada de sinal analógico, tendo mais 2 que o próprio Arduino UNO, estes podem ser programados para receber informação de vários tipos de sensores de sinal analógico.

Como também um botão de Reset com a função de reiniciar o dispositivo.

Sensor de fogo (infravermelhos):

Este tipo de sensor é normalmente utilizado em projectos cuja a sua função é detectar e responder à presença de uma chama ou fogo. Quando existe fogo é emitida uma determinada quantidade de energia electromagnética entre a gama dos Ultra Violetas (10nm) e os Infravermelhos (10000nm), passando pela Luz visível (Ver diagrama acima).

O nosso sensor é constituído por um díodo receptor de infravermelhos que capta parte da energia electromagnética emitida por um fogo, mais especificamente a radiação infravermelha, este está inserido num modulo electrónico, que analisa o sinal enviado pelo díodo receptor que determinará se está a ocorrer uma emissão anormal de infravermelhos o que indicara então a ocorrência de um fogo.

Este díodo receptor tem a particularidade de captar a radiação infravermelha numa gama de sensibilidade entre os valores de 760nm e 1100nm e o seu ângulo de detecção de cerca de 60º. (Ver imagem acima)

Após tendo sido confirmada a ocorrência de um fogo o modulo electrónico altera o estado das sua saídas digitais e analógicas. Assim sempre que o sensor detecta um fogo este coloca as saídas digitais em Nível Baixo (LOW), no entanto, em estado normal ou natural este permanece em Nível Alto (HIGH) (Ver imagem acima).

Para ajustar a sensibilidade do sensor definindo assim qual a quantidade de infravermelhos recebidos é considerado um fogo, rodamos a resistência variável que se encontra no modulo electrónico, rodando no sentido dos ponteiros do relógio para aumentar a sensibilidade e no sentido contrário para a diminuir (Ver imagem abaixo).

Se pretendermos utilizar a sua saída analógica, o seu comportamento é idêntico à saída digital, colocando na saída uma valor de cerca de 5V, caso não seja detectado nenhuma emissão de infravermelhos, se for detectada uma emissão o valor de tensão diminuindo à medida que a emissão aumenta até chegar perto dos 0V, sendo assim o valor de tensão inversamente proporcional ao valor de emissão. Este valor de tensão irá posteriormente ser traduzido pelo Arduino num determinado valor que varia entre 1023 (5V) e 0 (0v) (Ver imagem acima).

Sensor de fumo (partículas):

Um sensor de fumo é utilizado para detectar de fumo numa determinada área estando este normalmente associado a fogo ou um incêndio. Existem vários tipos e funcionamentos dos detectores de fumo, o nosso detector utiliza um sensor semicondutor MQ-2.

Este sensor é indicado detecção de vários tipos de fumos ou gases, como por exemplo LGP, Propano, Metano, Hidrogénio e fumos provenientes de combustão de materiais. O material sensível utilizado no sensor MQ-2 é SnO2, que tem baixa condutividade em contacto com ar limpo, mas se este estiver em contacto com algum dos gases ou fumo mencionados acima, a condutividade do sensor altera-se, sendo mais alta quanto maior for a concentração desses gases (Ver gráfico acima).

Esta alteração de condutividade eléctrica é analisada pelo modulo electrónico que determina se a concentração de gases ou fumo está acima no normal. Caso este verifique que essa concentração é superior ao normal este irá alterar a sua saída digital para Nível Baixo (LOW), se a concentração de gases ou fumo se mantiver em valores normais o modulo electrónico mantém a saída digital em Nível Alto (HIGH) (Ver imagem acima)

Para ajustar a sensibilidade deve-se rodar também a resistência variável definindo qual a quantidade de fumos ou gases fazem activar o nosso sensor (Ver imagem abaixo).

Ao utilizar a saída analógico do sensor, temos também de ter em atenção que o valor da saída irá alterar em os 5V e 0V consoante o valor de concentração de gases ou fumo, que depois será trazido também pelo Arduino num valor numérico que pode variar entre o 1023 (5V),se não existir praticamente gases ou fumos na área, e 0 (0V) se a concentração destes estiver no máximo perceptível pelo sensor (Ver imagem acima).

Caso queiram saber mais sobre o sensor de fogo ou o sensor de fumo vejam as suas datasheet (Ver ficheiros abaixo), alem destes vejam também as especificações detalhadas do Arduino NANO, através da página oficial do Arduino em "https://store.arduino.cc/arduino-nano".

Step 1: Montagem

Como os sensores da montagem têm 2 funções, uma digital e outra analógica, realizamos 2 montagens onde explicamos como ligamos todos os seus componentes, estas apenas são diferentes nas ligações dos sensores de fogo e fumo e como também no Arduino.

Vamos então começar pela montagem com os pinos digitais, para isso utilizamos uma Breadboard onde colocamos os componentes e onde são distribuídas as suas alimentações positivas e negativas, em primeiro lugar colocamos o Arduino NANO, pois já tem os pinos apropriados para ser montado directamente na Breadboard (Ver montagem acima).

Material necessário:

  • 1x Arduino NANO;
  • 1x Cabo USB;
  • 1x Breadboard;
  • 1x Sensor de Fogo YG1006;
  • 1x Sensor de Fumo MQ-2;
  • 1x Buzzer;
  • 2x Resistência 1KΩ;
  • 1x LED Vermelho;
  • 1x LED Amarelo 1KΩ.

Instalação dos sensores (Saídas Digitais):

Estes sensores são constituídos por 2 pinos de alimentação, Vcc e Gnd, tendo uma gama de tensão de alimentação entre os 3,3V e os 5V DC, e 2 pinos de saída de sinal digital e analógico, sendo o sinal do enviado pelo pino digital (D0) e o pinos de sinal analógico (A0) (Ver datasheets acima).

Como vamos começar pela montagem com os pinos digitais ligamos as alimentações positiva e negativa aos sensores e de seguida, ligamos o pino D0 de cada sensor, a qualquer um dos pinos digitais do Arduino NANO, neste caso os pinos escolhidos são o pino D2 e D3, ficando o pino D2 para o sensor de fumo e o pino D3 para o sensor de fogo (Ver montagem acima).

Instalação da indicação Sonora e Luminosa:

Depois da instalação dos sensores colocamos os avisos sonoros e luminosos na montagem, a função destes avisos será alertar o utilizador da existencial de algum fogo na área.

Para isso utilizamos um Buzzer, estes é um dispositivo de sinalização sonora que funciona a uma tensão de 5V DC, podendo ser alimentado directamente através uma fonte de alimentação DC (Arduino) produzindo um som contínuo.

Assim ligamos as sua alimentação positiva e negativa e por fim o pino de entrada de sinal é ligado a um dos pinos digitais do Arduino disponíveis, sendo o pino seleccionado o pino D12 (Ver montagem acima).

Agora só falta a sinalização luminosa, que é realizada através de 2 LED, sendo um Vermelho e o outro Amarelo. Este têm funções diferentes, pois acenderão individualmente, ficando o LED Amarelo aceso quando o sensor de fogo for activado, o LED Vermelho só fica aceso quando o sensor de fumo é activado.

Como estes têm funções diferentes são ligados a diferentes pinos digitais do Arduino, ficando o LED Amarelo ligado ao pino D10 e o LED Vermelho ligado ao pino D11.

Estes LED devem ser ligados em serie com uma resistência para que não se danifiquem, as resistência eléctricas escolhidas para esse efeito são de 1kΩ (Ver montagem acima).

Instalação dos Sensores (Saídas Analógicas):

Para que possamos utilizar os pinos de sinal analógicos dos sensores apenas teremos de alterar na montagem os as ligações dos pinos digitais dos sensores para os pinos analógicos e consequentemente também os pinos do Arduino NANO. Assim foram atribuídos os pinos A6 para o sensor de fogo e o pino A7 para o sensor de fumo, mantendo todos os outros componentes e ligações inalterados (Ver montagem acima)

No entanto, ao utilizar os pinos analógicos não é possível realizar o ajuste de sensibilidade através da resistência variável, assim este ajuste terá de ser realizado no próprio código do Arduino. Este é menos prático mas muito mais preciso, sendo possível desta forma visualizar os valores medidos pelos sensores e definir o valor exacto para a activação dos sensores.

Caso queiram saber mais sobre a utilização dos pinos digitais e pinos analógicos do Arduino, vejam os tutoriais anteriores, "https://www.instructables.com/id/Arduino-Tutorial-Analog-Input-Resistive-Sensors-Mo/" e o "https://www.instructables.com/id/Arduino-Tutorial-Digital-Input-Button-Monitor-Seri/" onde são explicados pormenorizadamente as suas características e funções.

Step 2: Código

Agora com a montagem terminada, só falta ligamos o cabo USB e carregarmos o respectivo código na placa do Arduino NANO.

Código para sinal Digital:

No código para a utilização dos pinos digitais teremos de estabelecer quais os pinos são entradas (INPUT) ou saídas (OUTPUT). Este código é bastante simples, sendo apenas necessário utilizar os pinos digitais do Arduino e colocar condições para cada estado dos nosso sensores.

Estes código funciona como um alarme de incêndio verificando se existe fogo ou fumo uma determinada área, no entanto esse alarme tem 3 condições, ligando o LED Amarelo se for detectado fogo, caso seja detectado apenas fumo liga o LED Vermelho, por outro lado, se ambos os sensores forem activos o Buzzer é accionado indicando que existe de maneira evidente um incêndio na área.

int Buzzer = 12;	//Variável para o pino do Buzzer.
int LED_Fogo = 10;	//Variável para o LED de aviso Amarelo.
int LED_Fumo = 11;	//Variável para o LED de aviso Vermelho.
int Sensor_Fogo = 3;	//Variável para o pino do sensor de fogo.
int Sensor_Fumo = 2;	//Variável para o pino do sensor de fumo.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
	//Definição do tipo de pino (Saída ou Entrada):
	pinMode(Buzzer, OUTPUT);
	pinMode(LED_Fogo, OUTPUT);
	pinMode(LED_Fumo, OUTPUT);

	pinMode(Sensor_Fogo, INPUT);
	pinMode(Sensor_Fumo, INPUT);
}

//Correr a função LOOP repetidamente:
void loop() {
	//Se a leitura do Sensor de Fogo for igual a LOW (nível baixo):
	if (digitalRead(Sensor_Fogo) == LOW){
		//Liga o LED (LOW é nível baixo):
		digitalWrite(LED_Fogo, LOW);
	}
	else {
		//Desliga o LED (HIGH é nível alto):
		digitalWrite(LED_Fogo, HIGH);
		delay(100);
	}
	//Se a leitura do Sensor de Fumo for igual a LOW (nível baixo):
	if (digitalRead(Sensor_Fumo) == LOW){
		//Liga o LED (LOW é nível baixo):
		digitalWrite(LED_Fumo, LOW);
	}
	else {
		//Desliga o LED (HIGH é nível alto):
		digitalWrite(LED_Fumo, HIGH);
		delay(100);
	}
	//Se a leitura dos Sensor Fogo e sensor de Fumo forem iguais a LOW (nível baixo):
	if (digitalRead(Sensor_Fogo) == LOW & digitalRead(Sensor_Fumo) == LOW){
		//Liga o Buzzer (LOW é nível baixo):
		digitalWrite(Buzzer, HIGH);
	}
	else {
		//Desliga o Buzzer (LOW é nível baixo):
		digitalWrite(Buzzer, LOW);
	}
}

Código para sinal Analógico:

Por outro lado caso seja necessário quantificar os valores de medidos pelos sensores, se quisermos aumentar a precisão do nosso sistema de alarme é melhor utilizar os pinos analógicos, pois desta forma é possível visualizar esses valores pelos sensores e definir os valores de disparo dos avisos com exactidão.

Não esquecer que para visualizar o valores medidos, que por sua vez permitirá definir os valores de disparo do alarme, temos de utilizar a função Monitor Serial, caso queiram saber mais sobre esta função vejam o tutorial anterior "https://www.instructables.com/id/Arduino-Tutorial-Analog-Input-Resistive-Sensors-Mo/" onde descrevemos o seu funcionamento.

int Buzzer = 12;	//Variável para o pino do Buzzer.
int LED_Fogo = 10;	//Variável para o LED de aviso Amarelo.
int LED_Fumo = 11;	//Variável para o LED de aviso Vermelho.
int Sensor_Fogo = A6;	//Variável para o pino do sensor de fogo.
int Sensor_Fumo = A7;	//Variável para o pino do sensor de fumo.

int Valor_Sensor_Fogo = 0;	//Variável para a leitura do sensor de fogo.
int Valor_Sensor_Fumo = 0;	//Variável para a leitura do sensor de fumo.

int Valor_Alerta_Fogo = 800;	//Variável para ajuste alarme de fogo.
int Valor_Alerta_Fumo = 450;	//Variável para ajuste de alarme de fumo.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup() {
	//Iniciar a  Communication Serial a 9600b/s:
	Serial.begin(9600);
	
	//Definição do tipo de pino (Saída ou Entrada):
	pinMode(Buzzer, OUTPUT);
	pinMode(LED_Fogo, OUTPUT);
	pinMode(LED_Fumo, OUTPUT);
}

//Correr a função LOOP repetidamente:
void loop() {
	//Leitura do Sensor de Fogo:
	Valor_Sensor_Fogo = analogRead(Sensor_Fogo);
	
	//Escreve no Monitor Serial o valor da variável:
	Serial.println("Sensor de Fogo: ");
	Serial.println(Valor_Sensor_Fogo);

	//Se o valor da variável do Sensor de Fogo for maior que o valor da variável Alerta Fogo:
	if (Valor_Sensor_Fogo < Valor_Alerta_Fogo){
		//Liga o LED (LOW é nível baixo):
		digitalWrite(LED_Fogo, LOW);
		delay(2000);
	}
	else {
		//Desliga o LED (HIGH é nível alto):
		digitalWrite(LED_Fogo, HIGH);
	}
	
	//Leitura do Sensor de Fumo:
	Valor_Sensor_Fumo = analogRead(Sensor_Fumo);

	//Escreve no Monitor Serial o valor da variável:
	Serial.println("Sensor de Fumo: ");
	Serial.println(Valor_Sensor_Fumo);

	//Se o valor da variável do Sensor de Fumo for maior que o valor da variável Alerta Fumo:
	if (Valor_Sensor_Fumo < Valor_Alerta_Fumo){
		//Liga o LED (LOW é nível baixo):
		digitalWrite(LED_Fumo, LOW);
		delay(2000);
	}
	else {
		//Desliga o LED (HIGH é nível alto):
		digitalWrite(LED_Fumo, HIGH);
	}
	//Se a leitura dos Sensores Fogo e Fumo forem maiores que o valor das variáveis de Alerta:
	if (Valor_Sensor_Fogo > Valor_Alerta_Fogo & Valor_Sensor_Fumo > Valor_Alerta_Fumo){
		//Liga o Buzzer (LOW é nível baixo):
		digitalWrite(Buzzer, LOW);
	}
	else {
		//Desliga o Buzzer (LOW é nível baixo):
		digitalWrite(Buzzer, HIGH);
	}
	delay(1000);
}

Caso queiram saber mais ou tenham dúvidas sobre estas e outras referências do código, vejam a sua explicação detalhada no site oficial do Arduino, através deste Link "https://www.arduino.cc/en/Reference/HomePage".

Procurem os nossos tutoriais acerca do Arduino, onde explicamos diversas montagens e o funcionamento dos seus componentes, já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.

Share

    Recommendations

    • Arduino Contest 2019

      Arduino Contest 2019
    • Trash to Treasure

      Trash to Treasure
    • Tape Contest

      Tape Contest

    Discussions