Arduino Tutorial - LDR Sensor

Published

Introduction: Arduino Tutorial - LDR Sensor

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ç&oti...

Este é mais um tutorial onde é explicado o funcionamento de sensores possíveis de ligar ao Arduino, neste caso será explicado o funcionamento de sensor de luz, que utiliza uma resistência LDR ou Light Dependent Resistor, senso possível assim medir a quantidade de luz um determinado local através da sua função analógica. Este estará ligado numa montagem onde será possível quantificar essa quantidade luz através de uma régua de LED.

Alem da função analógica, também explicaremos a sua função digital, que apesar desta ser a mais simples é também a mais utilizada, permitindo controlar equipamentos do tipo ON/OFF, como por exemplo relés. Este controlo pode ser ajustado através de uma resistência variável incorporada no sensor, ligando ou desligando o equipamento consoante a quantidade de iluminação pré-seleccionada anteriormente.

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

Step 1: Montagem

Como este sensor tem 2 funções, uma analógica e outra digital, vamos explicar-las realizando as duas montagens explicativas, sendo estas apenas diferentes na selecção dos pinos de saida do sensor e dos pinos de entrada do sinal enviado pelo sensor ao Arduino.

Material necessário:

  • 1x Arduino UNO;
  • 1x Cabo USB;
  • 1x Sensor de Luz com LDR;
  • 10x LED Vermelhos;
  • 10x Resistências de 1KΩ.

Instalação do sensor de luz (Saida analógica):

Este sensor é constituído 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 dois pinos de saída um digital e outro analógica, sendo o sinal do enviado pelo pino digital (D0) um sinal digital que altera entre 2 estados possíveis (ON/OFF), o de nível alto (5V DC) e o nível baixo (Gnd). O pino de sinal analógico (A0) por outro lado envia um sinal que pode alterar o seu valor entre 0V e 5V DC, podendo assim ter valores intermédios (Ver imagem acima).

Começamos então com a montagem que utiliza a saída analógica do sensor, assim ligamos ao nosso sensor as alimentações, e de seguida, ligamos o pino A0 do sensor, a um dos pinos de entrada analógica do Arduino UNO, que neste caso também será pino A0.

Depois montamos o nosso quantificador, que nos indicará a quantidade de luz que está num determinado momento em um determinado local, para isso utilizamos uma Breadboard onde vamos ligar as alimentações positivas e negativas do Arduino. Agora só falta colocar os 10 LED e as suas respectivas resistências de 1K Ohms, ligando-os a GND, respeitando as ligações eléctricas da Breadboard e a suas polarizações (Ver imagem acima).

Por fim, ligamos os pinos digitais do Arduino, neste caso, de 13 a 4 a cada um dos LED, formando assim uma pequena régua feita com LED, sendo esta que irá indicar e quantificar a luminosidade (Ver imagem acima).

Por outro lado, a montagem que utiliza a saida digital do sensor é util em casos em que não é necessário quantificar o valor medido pelo senor, mas apenas activar ou desactivar algum circuito eléctrico, quando existe um determinado nível de luminosidade, logo não é usado o pino A0 mas sim o pino D0 do sensor.

Este é pino digital, ou seja, tem apenas 2 condições ou estados (ON/OFF), assim utilizando a montagem anterior teremos apenas de retirar a ligação do pino A0 e colocar o pino D0 do sensor num pino digital do Arduino, neste caso escolhemos o pino 2.

Agora para ajustar o nível de luminosidade a que o sensor irá mudar de estado, ou seja, de nível alto para nível baixo, que traduzido para níveis eléctricos será 5V DC para GND, teremos de ajustar a sensibilidade através da resistência variável incorporada neste.

Assim se rodarmos no sentido dos ponteiros do relógio o sensor ficará mais sensível á luminosidade, se rodar no sentido oposto ficará menos sensível. Neste caso, controlamos apenas os LED da Breadboard, mas se quisermos ligar um equipamento, cuja as tensões ou potências sejam muito superiores podemos utilizar um relé (Ver Datasheet abaixo).

Caso queiram saber mais sobre a utilização do relé com o Arduino, vejam o tutorial anterior, onde é utilizado um sensor de movimento que controla uma lâmpada a 230V AC, através de um pequeno relé "https://www.instructables.com/id/Arduino-Tutorial-Motion-Sensor/".

.

Step 2: Código

Com a montagem terminada, vamos então carregar o código no Arduino, no entanto, realçamos apenas a utilização da função "For" em 2 situações distintas, sendo responsável pela definição dos pinos do Arduino como saídas, como também a colocação dessas saídas em nível alto ou baixo fazendo assim ligar e desligar os LED.

//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
//Depois incrementa +1 ao valor da variável Pino.
for (Pino_LED; Pino_LED < 14; Pino_LED ++){

	//Definição do tipo de pino (Saída ou entrada):
	pinMode(Pino_LED, OUTPUT);
	
	ou
	
	//Liga o LED (HIGH é nível alto):
	digitalWrite(Pino_LED, HIGH);
}

Código para sinal analógico:

Este é o código completo para a nossa montagem utilizando a saída analógica do nosso sensor (Ver ficheiro abaixo). Este permite quantificar a quantidade de luz num determinado local, para isso, utilizamos uma régua constituída por 10 LED, assim o Arduino ao receber o sinal, entre 5V DC e 0V criado pelo sensor, irá gerar um valor numérico compreendido entre 1023 e 0, para quantificar esse valor através dos LED dividimos o valor 1023 por 10 (Ver imagem acima).

int Pino_Sensor = A0; //Variável para o pino do sensor de movimento.
int Pino_LED; //Variável para os pinos dos LED.
int Valor_Sensor = 0; //Variável para a leitura do sensor.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){
	//Coloca na variável.
	Pino_LED = 4;
	//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
	//Depois incrementa +1 ao valor da variável Pino.
	for (Pino_LED; Pino_LED < 14; Pino_LED ++){
		//Definição do tipo de pino (Saída ou entrada):
		pinMode(Pino_LED, OUTPUT);
	}
}

//Correr a função LOOP repetidamente:
void loop(){
	//Leitura da luminosidade no do sensor:
	Valor_Sensor = analogRead(Pino_Sensor);
	
	//Se o valor da variável for menor que 1023 e maior que 918:
	if (Valor_Sensor < 1023 & Valor_Sensor > 918){
		//Coloca na variável.
		Pino_LED = 13;
		
		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 919 e maior que 816:
	else if (Valor_Sensor < 919 & Valor_Sensor > 816){
		//Coloca na variável.
		Pino_LED = 12;
		
		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 817 e maior que 714:
	else if (Valor_Sensor < 817 & Valor_Sensor > 714){
		//Coloca na variável.
		Pino_LED = 11;
		
		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 715 e maior que 612:
	else if (Valor_Sensor < 715 & Valor_Sensor > 612){
		//Coloca na variável.
		Pino_LED = 10;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 613 e maior que 510:
	else if (Valor_Sensor < 613 & Valor_Sensor > 510){
		//Coloca na variável.
		Pino_LED = 9;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 511 e maior que 408:
	else if (Valor_Sensor < 511 & Valor_Sensor > 408){
		//Coloca na variável.
		Pino_LED = 8;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 409 e maior que 306:
	else if (Valor_Sensor < 409 & Valor_Sensor > 306){
		//Coloca na variável.
		Pino_LED = 7;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 307 e maior que 204:
	else if (Valor_Sensor < 307 & Valor_Sensor > 204){
		//Coloca na variável.
		Pino_LED = 6;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 205 e maior que 102:
	else if (Valor_Sensor < 205 & Valor_Sensor > 102){
		//Coloca na variável.
		Pino_LED = 5;

		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Se o valor da variável for menor que 103 e maior que 0:
	else if (Valor_Sensor < 103 & Valor_Sensor > 0){
		//Coloca na variável.
		Pino_LED = 4;
		//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino.
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){     
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	//Coloca na variável.
	Pino_LED = 4;
	//Enquanto a variável Pino, for menor que 14, executa o código abaixo;
	//Depois incrementa +1 ao valor da variável Pino:
	for (Pino_LED; Pino_LED < 14; Pino_LED ++){
		//Liga o LED (HIGH é nível alto):
		digitalWrite(Pino_LED, LOW);
	}
}

Código para sinal digital:

Caso não seja necessário quantificar o valor da iluminação, basta-nos utilizar ao invés da saída analógica, a saída digital do nosso sensor. Este código é muito mais simples do que o anterior, sendo apenas necessário utilizar uma das saídas digitais, no entanto, para utilizar a mesma montagem, ou seja, os 10 LED colocados na Breadboard, utilizamos novamente a função "For" para os accionar todos em simultâneo.

int Pino_Sensor = 2;  //Variável para o pino do sensor de movimento.
int Pino_LED;  //Variável para os pinos dos LED.

//Correr a função SETUP apenas uma vez após ser pressionado Reset:
void setup(){
	pinMode(Pino_Sensor, INPUT);  //Definição do tipo de pino (Saída ou Entrada):
	//Coloca na variável.
	Pino_LED = 4;
	
	//Enquanto a variável Pino_LED, for menor que 14, executa o código abaixo;
	//Depois incrementa +1 ao valor da variável Pino.
	for (Pino_LED; Pino_LED < 14; Pino_LED ++){
		//Definição do tipo de pino (Saída ou entrada):
		pinMode(Pino_LED, OUTPUT);
	}
}

//Correr a função LOOP repetidamente:
void loop(){
	//Se a leitura de Pino_Sensor for igual a HIGH ou nível alto:
	if (digitalRead(Pino_Sensor) == LOW){
		//Coloca na variável.
		Pino_LED = 4;

		//Enquanto a variável Pino, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino:
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, HIGH);
		}
	}
	else{
		//Coloca na variável.
		Pino_LED = 4;

		//Enquanto a variável Pino, for menor que 14, executa o código abaixo;
		//Depois incrementa +1 ao valor da variável Pino:
		for (Pino_LED; Pino_LED < 14; Pino_LED ++){
			//Liga o LED (HIGH é nível alto):
			digitalWrite(Pino_LED, LOW);
		}
	}
}

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, Facebook ou Twitter.

Share

    Recommendations

    • Clocks Contest

      Clocks Contest
    • Creative Misuse Contest

      Creative Misuse Contest
    • Oil Contest

      Oil Contest

    Discussions