Olá pessoal bem vindos a mais um tutorial sobre o Arduino, desta vez vamos demonstrar o funcionamento e as características de um Arduino NANO através de uma montagem que utiliza 2 tipos sensores muito utilizados em detectores de incêndio, que são os sensores de fumo e de fogo ou de infravermelhos.

Vamos então começar por apresentar o Arduino NANO, esta é a primeira vez que é utilizado no nosso canal e comparativamente ao Arduino UNO este é 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 "FLASH memory" ou EEPROM e 2Kb de RAM.

Apenas uma ligação MiniUSB com a função de ligar o Arduino ao computador, servindo tanto 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 dos nossos projectos.

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", já o pino 13 está ligado um pequeno LED designado por L (Ver imagem acima).

Alem deste tipo de pinos o Arduino NANO tem mais 8 pinos de entrada de sinal analógico, tendo até mais 2 que o 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 "Reset" com a função de reiniciar o dispositivo.

Sensor de fogo ou infravermelhos:

Este tipo de sensor é normalmente utilizado em projectos cuja a sua função é detectar e responder à presença de chamas ou fogo. Isto deve-se ao facto das chamas ou fogo normalmente emitir uma quantidade anormal de energia electromagnética, esta energia encontra-se dentro da gama dos ultra-violetas, entre os 10nm e 10000nm, ou seja, entre os ultra-violetas e os infravermelhos passando claro pela luz visível (Ver diagrama acima).

Já o nosso sensor é constituído por um díodo receptor de infravermelhos, assim este consegue captar grande parte dessa energia electromagnética emitida. Este sensor está inserido num modulo electrónico que analisa o sinal enviado pelo díodo receptor, determinando então se está a ocorrer uma emissão anormal de infravermelhos o que indicará a ocorrência de um fogo.

O 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 o sensor detectar fogo ou chamas o seu modulo electrónico irá alterar o estado das suas saídas digitais, colocando as saídas digitais em nível baixo "LOW", caso contrário o estado da saída permanecerá em nível alto "HIGH" (Ver imagem acima).

Para ajustar a sensibilidade do sensor e assim definir a quantidade de infravermelhos necessários para considerar que existe um fogo, basta rodar a resistência variável que se encontra no modulo electrónico no sentido dos ponteiros do relógio aumentando assim a sua sensibilidade e se rodarmos no sentido contrário esta irá diminuir (Ver imagem abaixo).

Se pretendermos utilizar a saída de sinal analógico teremos que ter em atenção que agora a saída irá variar o seu valor de tensão entre os 0 e 5V sendo depois traduzido pelo Arduino em valores numéricos 0 e 1023. Logo se o sensor não detectar fogo ou chamas a saída permanecerá perto do valor de 5V, no entanto se for detectada uma emissão de infravermelhos anormal, ou seja fogo ou chamas, esse valor de tensão irá diminuir à medida que a emissão de infravermelhos também aumenta até chegar perto dos 0V. (Ver imagem acima).

Sensor de fumo ou de partículas:

Este tipo de sensor é muito utilizado para detectar de fumo em área que possa existir a possibilidade da existência de um incêndio. Existem vários tipos de detectores de fumo e com funcionamentos diferentes, o sensor utilizado na nossa montagem utiliza um sensor semicondutor MQ-2.

Este é indicado para 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 sua condutividade altera-se, sendo mais alta quanto maior for a concentração destes gases (Ver gráfico acima).

Esta alteração de condutividade eléctrica é então analisada pelo modulo electrónico que determina se a concentração de gases ou fumo está acima no normal, se este verificar que essa concentração é superior ao normal, irá alterar os estado das suas saídas de sinal digital.

Assim se o sensor detectar uma concentração de gases ou fumo o seu modulo electrónico irá alterar o estado das suas saídas digitais, colocando as saídas digitais em nível baixo "HIGH", caso contrário o estado da saída permanecerá em nível alto "LOW" (Ver imagem acima).

Para ajustar a sensibilidade do sensor e assim definir a concentração de gases ou fumos necessários para considerar que existe um fogo, basta rodar a resistência variável que se encontra no modulo electrónico no sentido dos ponteiros do relógio aumentando assim a sua sensibilidade e se rodarmos no sentido contrário esta irá diminuir (Ver imagem abaixo).

Ao utilizar a saída de sinal analógico do sensor, teremos também de ter em atenção que agora a saída irá variar o seu valor de tensão entre os 0 e 5V sendo depois traduzido pelo Arduino em valores numéricos entre 0 e 1023, Agora se o sensor não detectar gases ou fumos a saída permanecerá perto do valor de 0V, no entanto se for detectada uma concentração anormal o que indica a existência de um fogo, esse valor de tensão irá aumentando à medida que essa concentração também aumenta até chegar perto dos 5V. (Ver imagem acima).

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

Step 1: Montagem

Como os sensores da montagem podem ser utilizado através das suas funções digitais ou analógicas, realizamos 2 montagens onde estas serão explicadas e como são realizadas as suas ligações, sendo estas diferentes apenas nas ligações de ambos os sensores e do pinos do Arduino.

Vamos então começar pela montagem que utiliza os pinos digitais dos nossos sensores, como sempre começamos como a "Breadboard" onde são colocamos todos os componentes e ligações necessárias, depois montamos o Arduino NANO, pois o seu tamanho e configuração é apropriada 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 de fumo e infravermelhos:

Ambos os sensores são constituídos por 2 pinos de alimentação VCC e GND, podendo ser utilizada uma tensão entre os 3,3VDC e os 5VDC, alem destes os sensores também têm mais 2 pinos de informação, uma saída de sinal digital designada por D0 e outra de sinal analógico o pino A0. (Ver imagem acima).

Montagem de sinal digital:

Vamos começar então pela montagem que utiliza as saídas de sinal analógico, em primeiro lugar ligamos as alimentações dos nossos sensores e seguidamente os seus pinos D0 a um dos pinos de sinal digital do Arduino NANO, sendo neste caso os pinos D2 para o sensor de fumo e D3 para o sensor de infravermelhos(Ver imagem acima).

Agora teremos que ajustar o nível de concentração de fumo e de intensidade de infravermelhos necessários para que os sensores mudem o estado das suas saídas e para que isto aconteça regulamos a resistência variável incorporada na placa de cada um dos sensores para nesse exacto ponto (Ver imagem acima).

Montagem de sinal analógico:

Já a montagem que utiliza as saídas de sinal digital dos sensores é muito idêntica à anterior, porem apenas é necessário alterar os pinos de saída de informação de ambos os sensores de D0 para o A0, consequentemente também teremos alterar os pino de sinal digital do Arduino NANO para os pinos de sinal analógico, sendo escolhidos os pinos A7 para o sensores de fumo e A6 para o de infravermelhos.

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 incêndio na área.

A sinalização sonora é realizada através de um pequeno "Buzzer", este funciona com uma tensão de 5VDC, podendo assim ser alimentado directamente através de um dos pinos do nosso Arduino NANO produzindo som continuamente, já a sua activação é realizada através do pinos de sinal digital D12 (Ver montagem acima).

Agora só falta a sinalização luminosa, esta é feita através de 2 LED de cores diferentes, um vermelho para indicação de detecção de fogo ou chamas, já o amarelo indica a detecção de fumo. Tendo estes funções diferentes são assim ligados a pinos de sinal digital , ficando o LED amarelo ligado ao pino D10 e o LED vermelho ligado ao pino D11.

Relembro mais uma vez que teremos de ter atenção à polarização dos LED, pois só funcionam se directamente polarizados, assim os pinos positivos são ligados aos pinos de sinal digital escolhidos no Arduino e os pinos negativos ligados aos pinos GND do Arduino (Ver imagem acima).

Alem da sua polarização também não nos podemos esquecer de ligar o LED em serie com uma resistência eléctrica com cerca de 1KΩ, evitando assim que este se danifique quando o ligarmos.

Caso queiram saber mais sobre os pinos de sinal digital e os pinos de sinal analógico do Arduino, vejam os tutoriais anteriores, onde são explicados pormenorizadamente as suas características e funções.

Arduino Tutorial - Digital Input - Button - Monitor Serial

https://www.instructables.com/id/Arduino-Tutorial-Digital-Input-Button-Monitor-Seri/

Arduino Tutorial - Analog Input - Resistive Sensors - Monitor Serial

https://www.instructables.com/id/Arduino-Tutorial-Analog-Input-Resistive-Sensors-Mo/

Step 2: Código

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

Em ambas as montagens são utilizados pinos de sinal digital para controlar tanto o "Buzzer" como os LED de sinalização, assim para colocar estes pinos como saídas utilizamos a função PinMode, bastando depois apenas colocar a palavra "OUTPUT", caso queiramos utilizar os pinos de sinal digital como entradas, o que acontece na montagem de sinal digital onde estes receberão a informação dos sensores para isso utilizamos novamente esta função, mas agora com a palavra for "INPUT" fica o pino definido como entrada.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:<br>void setup(){
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Trig, OUTPUT);
	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_Echo, INPUT);
}

Código para sinal Digital:

Estes é o código completo que funciona como um alarme de incêndio verificando e avisando da existência de um incêndio numa determinada área, este tem 3 tipos de aviso indicando assim situações diferentes.

Um dos tipos de avisos é o aviso luminoso amarelo que indica a existência de fogo ou chamas, já no caso de apenas existir apenas fumo ou gases na área será activado o aviso vermelho e por ultimo se ambos os sensores detectarem fogo e fuma é activado o aviso sonoro através do "Buzzer" indicando com toda a certeza a existência de um incêndio.

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) == HIGH){
		//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) == HIGH){
		//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 ou aumentar a precisão do nosso sistema de alarme a melhor forma é melhor utilizar a montagem com os pinos de sinal analógico, pois desta forma é possível visualizar concretamente os valores medidos pelos sensores e definir com exactidão os valores de de aviso.

Para realizar a leitura dos pinos de sinal analógico teremos de utilizar a função analogRead sendo esta responsável pela conversão do valor de tensão recebido pelo pino entre 0 e 5V,em um valor numérico de compreendido entre 0 e 1023.

//Leitura do pino analógico:<br>analogRead(Pino)

Não esquecer que para visualizar o valores medidos pelo sensores, poderemos de utilizar a janela de Monitor serial através a activação da função Communication Serial. Caso queiram saber mais sobre esta funcionalidade vejam o tutorial anterior.

Arduino Tutorial - Analog Input - Resistive Sensors - Monitor Serial

https://www.instructables.com/id/Arduino-Tutorial-Analog-Input-Resistive-Sensors-Mo/

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 da ligação 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.