Início / Projetos Arduino / Projetos Squids / Básico / Projeto 28 - Iluminação de LED automatizada

---

Projeto 28 - Iluminação de LED automatizada

Angelo Luis Ferreira | 04/11/2017 Acessos: 15.927

Objetivo

Criar um circuito para que um Led de alto brilho acenda gradativamente se a iluminação ambiente, por qualquer motivo, diminuir ou apagar completamente. 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.

Observação: Utilizamos neste projeto conceitos de automação através do uso de entradas analógicas, PWM e utilização de sensores. Projeto semelhante é utilizado em postes de luz, onde as lâmpadas acendem sozinhas, conforme a luminosidade do dia.

Aplicação

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

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
Led Difuso 5mm	LEDs 5mm alto brilho	1		1 LED alto brilho azul Você poderá utilizar também LEDs de qualquer outra cor ou LEDs difuso de 3 ou 5mm nas cores que desejar.
Resistor	Resistor	2		1 Resistor de 150Ω (led)   1 Resistor de 10KΩ (sensor LDR) Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado - Calcular Resistor.
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.

Obs.: Resistores iguais ou superiores a 250 Ω poderão ser utilizados em LEDs de todas as cores para um circuito com tensão igual ou inferior a 5V.

2.1. Valor do resistor utilizado no nosso projeto para o LED Azul alto brilho = 150 Ω.

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

3.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.

3.2. Veja abaixo a montagem no protoboard:

4. 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. (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 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 80 como valor de referência. Entretanto, poderíamos definir outros valores, se desejarmos acender o led com uma sombra moderada ou mais escura. A seguir, acesse o sketch do projeto.

Código do projeto (Sketch)

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

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

/*******************************************************************************
*
*    Projeto 28 – Iluminação de LED automatizada com sensor de luminosidade LDR
*                   http://squids.com.br/arduino
*
*******************************************************************************/
 
const int LDR = 0;
const int led = 3;
int ValorLido = 0;
int pwm = 0;


void setup() {
Serial.begin(9600);

pinMode(led, OUTPUT);
}

void loop() {
ValorLido = analogRead(LDR);
Serial.print("Valor lido pelo LDR = ");
Serial.println(ValorLido);
delay(500);

if (ValorLido < 80){
analogWrite(led, pwm);
pwm++;
delay(100);
}
else{
digitalWrite(led, LOW);
pwm = 0;
}

if(pwm > 255){
pwm=255;
}
}

ATENÇÃO: Como já mencionamos anteriormente, utilizamos o valor de 80 como referência para a variável ValorLido. Se desejar, altere este valor para um novo em função 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 deverá ficar apagado, pois os valores da luminosidade do ambiente deverão estar maiores que o valor de referência que você utilizou no projeto.

2. Reduza a luz ambiente que incide sobre o sensor, assim o led deverá acender de forma gradativa simulando um projeto de automação onde as lâmpadas acendem sozinhas, conforme a luminosidade do dia.

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

PWM - Pulse With Modulation

Como demonstrado nos projetos Projeto 14 - Led com efeito dimmer usando potenciômetro e Projeto 18 - Efeito lâmpada pulsante, este experimento também utiliza o conceito o PWM (Pulse Width Modulation, em português, modulação por largura de pulso) no controle da luminosidade (brilho dos LEDs).

O Arduino UNO, que utilizamos no exemplo, possui 6 saídas digitais que podem ser utilizadas como PWM, sendo elas: 11, 10, 9, 6, 5 e 3.

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 LDR se refere ao Sensor de luminosidade LDR que deverá estar conectado à porta analógica A0.

1.2. A variável led se refere ao Led que deverá estar conectado à porta 3 do microcontrolador Arduino (saída PWM).

1.3. Declaramos a variável ValorLido como 0 (zero).

1.4. Declaramos a variável pwm como 0 (zero).

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 led como saída do controlador Arduino (OUTPUT) conectados à porta digital 3.

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

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

3.1. A variável ValorLido 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. Escrevermos na tela do Monitor Serial a frase "Valor lido pelo LDR = " através do comando Serial.print().

3.3. Escrevemos na tela do Monitor Serial o valor da variável ValorLido através do comando Serial.print(). O comando println() diz ao monitor que se deve pular uma linha após escrever o valor definido entre parêntesis. 

3.4. Utilizamos a estrutura condicional If (ValorLido <80). Portanto, se a variável ValorLido for menor que 80 (número que utilizamos como referência para acender o led), o led deverá acender gradativamente conforme a explicação a seguir:

3.4.1. Através da função analogWrite (led, pwm), definimos o brilho do led. Como a variável pwm foi definida inicialmente como zero, temos um efeito gradativo de apagado até totalmente acesso.

Obs.: A função analogWrite faz uma escrita analógica, ou seja, faz a escrita da variável pwm. No Arduino está predefinido que para ter 0% de PWM, basta escrever: analogWrite(pino a ser escrito, 0); do mesmo modo que, para obter 100% de PWM, basta escrever: analogWrite(pino a ser escrito, 255), ou seja, na estrutura que o Arduino entende como PWM, os valores vão de 0 (mínimo, ou seja, 0%) até 255 (máximo, ou seja,100%). Assim, dependendo do valor da variável pwm, o led terá seu brilho de mais escuro até totalmente aceso, quando atingir o valor de 255.

3.4.2. Através do comando pwm++, incrementamos em 1 o valor da variável pwm para a próxima leitura da estrutura condicional If.

3.4.3. Através do comando delay(100), criamos um pausa de 100ms.

3.4.4. Caso por algum motivo a luminosidade volte a ficar maior que 80 (nosso valor de referência), o led é apagado pela função digitalWrite(led, LOW) e variável pwm volta a ser definida como zero, permitindo que se crie o efeito gradativo quando o led for acesso novamente.

3.4.5. Finalmente, pela estrutura condicional if (pwm >255) verifica-se se o valor da variável pwm é maior que 255. Caso seja maior, ele permanecerá como 255,ou seja, manterá o led totalmente aceso (HIGH).

Comentários