Início / Projetos Arduino / Projetos Squids / Básico / Projeto 31 - Alarme com laser e sensor de luz LDR

---

Projeto 31 - Alarme com laser e sensor de luz LDR

Angelo Luis Ferreira | 26/12/2017 Acessos: 27.609

Objetivo

Criar um circuito para simular um alarme utilizando um laser 5V apontado para um sensor LDR. Assim que luz do laser é interrompida por algum motivo, o alarme é acionado. O alarme após 5 ciclos é desligado automaticamente e poderá ser acionando novamente se o sensor LDR deixar de receber a luz do laser.

Observação: Para este projeto utilizaremos um sensor de luminosidade LDR (Light Dependent Resistor), em português Resistor Dependente de Luz ou Fotoresistência, que nada mais é do que um componente eletrônico do tipo resistor variável, mais especificamente, um resistor cuja resistência varia conforme a intensidade da luz (luminosidade) que incide sobre ele.

Aplicação

Para fins didáticos e projetos de automação.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 e 400 pontos	2		Utilizar 1 protoboard com 830 pontos para montagem do circuito principal e 1 protoboard com 400 pontos (opcional) para ligação do laser
Jumpers	Kit cabos ligação macho / macho	1
Led Difuso 5mm	LEDs 5mm	3		1 LED difuso vermelho 1 LED difuso verde 1 LED alto brilho azul ou vermelho Você poderá utilizar também LEDs de qualquer outra cor de 3mm ou 5mm.
Resistor	Resistor	4		2 Resistores de 100Ω / 1 Resistor de 150Ω (led)   1 Resistor de 10KΩ (sensor LDR) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado.
Diodo Laser	Diodo Laser 5v 6MM	1
Sensor de luminosidade LDR	Sensor de Luminosidade LDR 5mm	1
Buzzer	Buzzer 5V 12mm	1
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito Principal

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito.

Montagem do laser

Monte o laser em um protoboard de 400 pontos, observando a alimentação de 5V (ligação positiva e negativa). No nosso exemplo ligamos o laser no circuito principal através de dois jumpers. Aponte a luz do laser para o sensor LDR. Utilize uma fita crepe para manter o diodo laser fixo no lugar.

Observação 1: O sensor LDR deverá estar dobrado e direcionado para o laser.

Observação 2: Se você desejar, ligue o laser em uma outra fonte externa de 5V.

Atenção

1. Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

2. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Como calcular o resistor adequado para o led e Leds ligados em série e em paralelo.

2.1. Valor do resistor utilizado no nosso projeto para o LED Azul de alto brilho = 100 Ω. Leds difuso verde = 100 Ω. Led difuso vermelho 150 Ω.

3. O buzzer tem polaridade. Portando, cuidado para não ligar o buzzer invertido. Se você retirar o adesivo superior do buzzzer poderá ver um sinal de positivo (+). Este sinal mostra onde está o pino positivo do componente que deverá estar conectado ao Arduino.

4. Conecte o sensor de luminosidade LDR como um divisor de tensão, conforme o esquema abaixo:

4.1. Desta forma, a tensão na entrada analógica do Arduino é alta quando o LDR está sob iluminação e baixa quando mantido na sombra. Para saber mais sobre divisão de potencial LDR, leia Divisores de Tensão.

Obs.: O sensor de luminosidade LDR, assim como um resistor comum, não tem polaridade.

4.2. Veja abaixo a montagem no protoboard:

5. Montagem do circuito principal

5.1. A montagem abaixo foi realizada em um protoboard com linhas de alimentação não contínuas, onde acrescentamos jampers para a ligação. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

6. Montagem do diodo laser

6.1. Monte o laser em um protoboard de 400 pontos, conforme figura abaixo:

6.2. Conecte o diodo laser no circuito principal. Dobre o sensor LDR apontando-o para o diodo laser.

6.3. Direcione a luz do laser no sensor LDR. Utilizando uma fita crepe, fixe o o laser na posição correta.

6.4. Veja abaixo como ficou a montagem final do circuito:

Calibrando o sensor de luminosidade LDR

Antes de definirmos o valor de referência para acender o Led precisamos conhecer a luminosidade do ambiente onde o sensor está instalado. Copie o código abaixo e cole no IDE do Arduino.

/*******************************************************************************
*
*               Calibrar sensor de luminosidade LDR
*                   http://squids.com.br/arduino
*
*******************************************************************************/
const int LDR = 0;
int ValorLido = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
ValorLido = analogRead(LDR);
Serial.print("Valor lido pelo LDR = ");
Serial.println(ValorLido);
delay(500);
}

1. Faça o upload para o microcontrolador e abra o Monitor Serial para fazer a leitura do sensor LDR no ambiente.

2. Observe que os valores para o sensor variam de 0 até 1023, sendo 0 para ambiente mais escuro e 1023 para ambiente mais iluminado, em função da montagem do nosso sensor no protoboard.

Obs.: O valor de leitura de uma porta analógica do Arduino UNO, Mega e Leonardo, varia de 0 a 1023 em função do ADC (Analog to Digital converter, ou conversor analógico para digital), para estas placas.

2.1. Veja abaixo os valores medidos com o sensor LDR recebendo a luz do laser:

3. Os valores lidos no nosso exemplo variam 1015 a 1016. (Obs.: Se você está lendo um valor fixo, sem variação, certifique-se que os componentes estão bem colocados e na posição correta. Este é um erro muito comum neste tipo de experimento.)

4. Coloque agora a palma da sua mão, ou qualquer outro material que interrompa o feixe de luz do gerado pelo laser. Faça novamente a leitura:

5. Pronto, agora já sabemos a grandeza de valores para o sensor recebendo o feixe de luz e para o sensor sem receber o feixe de luz do laser. Desta forma, podemos definir um parâmetro para que o alarme possa ser acionado. No nosso exemplo vamos utilizar 800 como valor de referência. Você poderá alterar este valor da forma que achar mais adequado de acordo com os valores lidos no seu projeto. Estes poderão ser bem diferentes, dependendo da luminosidade do ambiente e do fabricante do sensor LDR. A seguir, acesse o sketch do projeto.

Código do Projeto (sketch)

Faça o dowload e abra o arquivo projeto31.ino no IDE do Arduino: DOWNLOAD - projeto31.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto 31 – Alarme com laser
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
const int buzzerPin = 7; // Piezo no pino 7
const int ldrPin = 0; // LDR no pino analógico 0
const int ledPin = 3; // LED no pino digital 3 

const int ledVerde = 8;
const int ledVermelho = 10;

int ldrValue = 0; // Valor lido do LDR

int toneVal = 0;
int toneAdjustment = 2000;
float sinVal;

void setup() {
    //Ativando o serial monitor que exibirá os valores lidos no sensor.
    Serial.begin(9600);
    //Definindo pinos digitais dos leds e buzzer como de saída.
    pinMode(ledPin, OUTPUT);
    pinMode(buzzerPin, OUTPUT);
    pinMode(ledVerde,OUTPUT);
    pinMode(ledVermelho,OUTPUT);
}

void loop() {
ldrValue = analogRead(ldrPin); // lê o valor do LDR
 
  //Luminosidade baixa.
  if (ldrValue <= 800) {
    apagaLeds();
    digitalWrite(ledVermelho,HIGH);
    
    //toca o alarme
    digitalWrite(ledPin, HIGH);
    sirene();
    delay(25); // espera um pouco
    noTone(buzzerPin); // interrompe o tom
  }
     
  //Luminosidade alta.
  if (ldrValue > 800) {
    apagaLeds();
    digitalWrite(ledVerde,HIGH);
  }
   
  //Exibindo o valor do sensor no serial monitor.
  Serial.print("Valor lido no sensor: ");
  Serial.println(ldrValue);
  delay(50); 
}

//Função sirene
void sirene(){
  //tocar 5 ciclos
  for (int k=0; k<5; k++){
    for (int x=0;x<180;x++){        
        //converte graus em radianos
        sinVal = (sin(x*(3.1412/180)));
        //agora gera uma frequencia
        toneVal = 2000+(int(sinVal*100));
        //toca o valor no buzzer
        tone(buzzerPin,toneVal);
        //atraso de 2ms e gera novo tom
        delay(2);        
    }
  }
}

//Função criada para apagar todos os leds de uma vez.
void apagaLeds() {
  digitalWrite(ledVerde,LOW);
  digitalWrite(ledVermelho,LOW);
  digitalWrite(ledPin,LOW);
}

Atenção: Se necessário, altere o valor de referência no código acima. No nosso exemplo utilizamos 800.

Vídeo

Como o projeto deve funcionar

1. Quando você iniciar o programa, o led verde deverá ficar aceso, pois o feixe de luz do laser está incidindo sobre o sensor LDR. Os valores lidos são maiores que o valor de referência que você utilizou no projeto (no nosso projeto utilizamos 800).

2. Interrompendo o feixe de luz sobre o sensor LDR, o led vermelho acenderá assim como o alarme (sirene) será acionado. Isto acontece quando o valor lido no sensor LDR estiver abaixo do valor de referência (no nosso projeto utilizamos 800).

3. Após alguns instantes o alarme é desligado automaticamente.

4. Abrindo o Monitor Serial do IDE do Arduino, você poderá fazer as leituras do sensor a qualquer momento.

Explicando o Código do Projeto

 1. Primeiro declaramos as constantes e as variáveis do projeto.

1.1. Observe que utilizamos as constantes e variáveis tipo "int" e "float". Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.1. A constante buzzerPin se refere ao buzzer que deverá estar conectado à porta digital 7 do microcontrolador Arduino.

1.2. A constante ldrPin se refere ao Sensor de luminosidade LDR que deverá estar conectado à porta analógica A0.

1.3. A constante ledPin se refere ao Led de alto brilho que deverá estar conectado à porta 3 do microcontrolador Arduino.

1.4. As constantes ledVerde e ledVermelho se referem aos leds verde e vermelho conectados às portas 8, 9 e 10 respectivamente.

1.5. Declaramos a variável ldrvalue como 0 (zero).

1.6. Declaramos a variável inteira toneval como 0 (zero) e a variável toneAdjustment como 2000.

1.7. Declaramos a variável float sinVal.

2. Através da estrutura void setup(), definimos:

2.1. A função Serial.begin() serve para dizer ao Arduino que será coletado dados para o computador a partir da porta serial e o cabo USB. O número entre os parênteses significa qual é a taxa de dados que a placa vai se comunicar com o computador. Utilizaremos a taxa padrão de 9600bps (bits-per-second).

2.2. Define-se a constante ledPin como saída do controlador Arduino (OUTPUT) conectada à porta digital 3.

2.3. Define-se a constante buzzerPin como saída do controlador Arduino (OUTPUT) conectada à porta digital 7.

2.4. Define-se as constantes ledVerde e ledVermelho como saídas do Arduino (OUTPUT) conectadas às portas digitais 8 e 10 respectivamente.

2.5. Observe que portas analógicas não precisam ser definidas, pois por padrão, já são definidas como INPUT. Entretanto, você pode utilizar a linha de código: pinMode(ldrPin, INPUT);

3. Através da estrutura void loop(), obtemos:

3.1. A variável ldrValue será igual aos valores lidos diretamente pelo pino analógico onde está conectado o sensor LDR. Esta leitura é feita através da função analogRead() que faz a conversão de analógico para digital onde é utilizado o   ADC (Analog to Digital Converter - conversor analógico para digital) sem tratamento nenhum. A variável ldrValue foi definida localmente como tipo inteiro (int), e portanto, vai de 0 a 1023, ou seja, possui 2¹⁰ = 1024 valores inteiros (referente à resolução de 10 bits do ADC para controladores Arduino UNO, Mega e Leonardo). Assim, quando o sensor LDR não estiver recebendo pouca ou nenhuma luz do ambiente, o valor lido será próximo de zero, e quando sensor receber muita luz, o valor será próximo de 1023, fazendo assim a leitura da luminosidade de um ambiente.

Observação: Nosso exemplo, o sensor LDR varia de 0V a 5V(leitura analógica), ou seja, de 0 a 1023 quando convertido em leitura digital através do ADC do controlador Arduino.

3.2. Utilizamos a estrutura condicional If (ldrValue <=800). Portanto, se a variável ldrValue for menor que 800 (número que utilizamos como referência) o led vermelho acenderá e o alarme será acionado,  conforme explicação a seguir:

3.2.1. Chamamos a função apagaleds() que apagará todos os leds.

3.2.2. A função digitalWrite(ledVermelho, HIGHT) faz com que acenda o led vermelho.

3.2.3. Dispara o alarme, conforme explicação a seguir:

3.2.3.1. Através da função digitalWrite(ledPin, HIGH) acendemos o Led de alto brilho.

3.2.3.2. Chamamos a função sirene() que irá gerar o som do alarme.

3.2.3.3. Através da função delay(25) esperamos 25ms. Este valor define o tempo que o led e o buzzer fiquem ativos, gerando um tipo de bip.

3.2.3.4. Interrompemos o som do buzzer através da função noTone(), desligando o alarme.

Observação: O alarme explicado acima poderá ser substituído por outros tipos de alarmes que você pode criar ou copiar.

3.3. Utilizamos a estrutura condicional If (ldrValue >800). Portanto, se a variável ldrValue lida estiver entre os valores de referência 40 e 200 (valores que utilizamos como referência quantidade de luz intermediária) o led amarelo acenderá,  conforme explicação a seguir:

3.2.1. Chamamos a função apagaleds() que apagará todos os leds.

3.2.2. A função digitalWrite(ledVerde, HIGHT) faz com que acenda o led verde.

3.4. Escrevemos na tela do Monitor Serial o texto "Valor lido no sensor: " através do comando Serial.print() o valor da variável ldrValue através do comando Serial.printn(). O comando println() diz ao monitor que se deve pular uma linha após escrever o valor definido entre parêntesis.

3.6. Através da função delay(50), definimos um tempo de espera de 50 ms entre cada ciclo do loop.

4. Estrutura void sirene():

4.1. A função sirene() foi retirada do site Do bit Ao Byte e está explicada no tutorial: Sirene com Arduino

5. Estrutura void apagaleds():

5.1.  Define-se a função apagaleds(), sendo:

5.1.1. Apagamos todos os leds através das funções digitalWrite(ledVerde,LOW), digitalWrite(ledVermelho,LOW) e digitalWrite(ledPin, LOW).

Comentários