Início / Projetos Arduino / Projetos Squids / Básico / Projeto 30 - Sensor de luminosidade LDR com sinalizador de Leds

---

Projeto 30 - Sensor de luminosidade LDR com sinalizador de Leds

Angelo Luis Ferreira | 09/12/2017 Acessos: 22.356

Objetivo

Criar um circuito para que um sensor LDR ao detectar luz forneça um feedback luminoso da quantidade de luz detectada através de 3 leds, sendo 1 verde, para grande quantidade de luz recebida, 1 amarelo, para valores intermediários e 1 vermelho, quando o sensor recebe pouca luz.

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 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Resistor	Resistor	5		3 Resistores de 100Ω(leds) 1 Resistor de 150Ω (led)   1 Resistor de 10KΩ (sensor piezoelétrico) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado.
Led Difuso 5mm	LEDs 5mm	4		1 LED alto brilho azul 1 LED difuso verde 1 LED difuso amarelo 1 LED difuso vermelho Você poderá utilizar também LEDs de qualquer outra cor de 3mm ou 5mm.
Sensor de luminosidade LDR	Sensor de Luminosidade LDR 5mm	1
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

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.

Atenção

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

1.1. Portanto, faça a conexão do Arduino no terminal positivo (anodo) e o GND no terminal negativo (catodo) do led.

1.2. Para evitar danos ao led é necessário a inclusão de um resistor no circuito. Como o resistor é um limitador da corrente elétrica, ele poderá estar conectado no anodo (terminal maior) ou no catodo (terminal menor) do led, tanto faz.

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 alto brilho = 100 Ω. Leds difuso amarelo e 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. 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.

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.

3. Os valores do ambiente no nosso exemplo variam 420 a 450.

3.1. 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 tampe a luz ambiente, sobre o sensor tampando a luz e fazendo o sensor ficar na sombra. Faça novamente a leitura:

5. Pronto, agora já sabemos a grandeza de valores para o ambiente iluminado e com sombra. Desta forma, podemos definir um parâmetro para que o led se acenda quando o ambiente ficar mais escuro. No nosso exemplo vamos utilizar: valores acima de 200 para verde (recebe muita luz), entre 200 e 40 para amarelo (intermediário) e abaixo de 40 para vermelho (o sensor recebe pouca luz). Você poderá alterar estes valores da forma que achar mais adequado de acordo com os valores lidos no seu projeto. Estes poderão ser bem diferentes, dependo 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 projeto30.ino no IDE do Arduino:  DOWNLOAD - projeto30.ino

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

/*******************************************************************************
*
*    Projeto 30 – Sensor de luz LDR com sinalizador de Leds
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
const int buzzerPin = 7; // Piezo no pino 8
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 ledAmarelo = 9;
const int ledVermelho = 10;

int ldrValue = 0; // Valor lido do LDR
const int freq = 5; // altera frequencia do sonorizador

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(ledAmarelo,OUTPUT);
    pinMode(ledVermelho,OUTPUT);
}

void loop() {
ldrValue = analogRead(ldrPin); // lê o valor do LDR
 
  //Luminosidade baixa.
  if (ldrValue < 40) {
    apagaLeds();
    digitalWrite(ledVermelho,HIGH);
    
    //toca o alarme
    tone(buzzerPin,1000); // toca um tom de 1000 Hz do piezo
    digitalWrite(ledPin, HIGH);
    delay(25); // espera um pouco
    noTone(buzzerPin); // interrompe o tom
    digitalWrite(ledPin, LOW);
    delay(ldrValue); // espera a quantidade de milissegundos em ldrValue
  }
   
  //Luminosidade média.
  if (ldrValue >= 40 && ldrValue <= 200) {
    apagaLeds();
    digitalWrite(ledAmarelo,HIGH);
  }
   
  //Luminosidade alta.
  if (ldrValue > 200) {
    apagaLeds();
    digitalWrite(ledVerde,HIGH);
  }
   
  //Exibindo o valor do sensor no serial monitor.
  Serial.println(ldrValue);
  
  delay(50); 
}

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

 ATENÇÃO: Como já mencionamos anteriormente, utilizamos os valores de referência: acima de 200 para verde (recebe muita luz), entre 200 e 40 para amarelo (intermediário) e abaixo de 40 para vermelho (o sensor recebe pouca luz). Você poderá alterar estes valores da forma que achar mais adequado de acordo com das leituras feitas na calibragem do LDR.

Depois do código ajustado, faça a verificação e o upload para o microcontrolador.

Vídeo

Como o projeto deve funcionar

1. Quando você iniciar o programa, o led verde deverá ficar aceso, pois os valores da luminosidade do ambiente deverão estar maiores que o valor de referência que você utilizou no projeto (no nosso projeto utilizamos 200).

2. Reduza um pouco a luz ambiente que incide sobre o sensor e o led aceso deverá acender, desde que o valor lido no sensor esteja entre os valores de referência (no nosso projeto utilizamos valor máximo de 200 e mínimo de 40).

3. Reduza mais a luz ambiente até acender o led vermelho e acionar o alarme. Isto acontece quando o valor lido no sensor LDR estiver abaixo do valor de referência (no nosso projeto utilizamos 40). 

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". 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, ledAmarelo e ledVermelho se referem aos leds verde, amarelo e vermelho conectados às portas 8, 9 e 10 respectivamente.

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

1.6. Declaramos a constante freq como 5 (este valor deve ser diferente de zero e pode ser alterado para aumentar ou diminuir a frequência de bips no seu alarme).

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, ledAmarelo e ledVermelho como saídas do Arduino (OUTPUT) conectadas às portas digitais 8, 9 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, através da função analogRead() que faz a conversão de analógico para digital. Esta leitura é feita pelo ADC (Analog to Digital Converter - conversor analógico para digital) sem tratamento nenhum. A variável 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 <40). Portanto, se a variável ldrValue for menor que 40 (número que utilizamos como referência quando o sensor estiver recebendo pouca luz) 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. A função tone() define um tom para o buzzer. Vamos utilizar tone(buzzerPin,1000) que gera um tom com frequência de 1.000Hz. (Você pode alterar este valor definindo tons diferentes para o buzzer).

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

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().

3.2.3.5. Através da função digitalWrite(ledPin, LOW) apagamos o Led de alto brilho.

3.2.3.5. A função delay(ledrValue/freq) define o intervalo entre os bips. Quanto maior a incidência de luz sobre o sensor, menor será o valor de ledrValue e portanto menor o intervalo entre os bips, fazendo com que os mesmos sejam emitidos de forma mais rápida. Quanto menor for a incidência de luz sobre o sensor, maior será o valor lido e portanto maior o intervalo entre os bips, portanto, emitidos de forma mais lenta.

3.8. Já a constante freq faz com que o intervalo entre os bips sejam maiores ou menores, dependo do seu valor. Quanto maior for o seu valor, menor será o tempo de espera. Portanto os bips serão emitidos de forma mais rápida.

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 >=40 && ldrValue<=200). 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(ledAmarelo, HIGHT) faz com que acenda o led vermelho.

3.4. Utilizamos a estrutura condicional If (ldrValue >200). Portanto, se a variável ldrValue lida for maior que o valor de referênci e 200 (valor que utilizamos como referência para quando o sensor receba uma boa quantidade de luz) o led verde 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 vermelho.

3.5. Escrevemos na tela do Monitor Serial 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 apagaleds():

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

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

Comentários