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ções simples e práticas que podem ser utilizadas para concre...

Bem vindos a mais um tutorial onde será explicado o funcionamento de sensores que detectam e conseguem quantificar a quantidade de luz, este tipo de sensores normalmente utilizam uma resistência eléctrica do tipo LDRou "Light Dependent Resistor".

A LDR inserida neste sensores tem a particularidade de alterar o seu valor resistivo consoante a quantidade de luz que está a incidir nesta, tornando assim possível medir a quantidade de luz um determinado local. Neste caso a LDR está instalada numa pequena placa com um circuito que permite utilizar esta função através de 2 formas distintas, uma é através da saída digital e a outra através da saída analógica (Ver imagem acima).

A montagem do nosso tutorial irá permitir utilizar este sensor de luminosidade com estas 2 funções detectando e medindo a quantidade luz e indicando-as através de uma régua de 10 LED.

Quando utilizamos a função analógica será alterado o valor de tensão à sua saída à medida que a luminosidade incidida também variar, já a função digital permite regular um valor máximo de luminosidade, através de uma resistência variável incorporada na placa, alterando assim o estado da saída sempre que a quantidade de luminosidade incidida passar esse valor (Ver imagem acima).

Caso queiram saber mais sobre a sensor de luminosidade vejam a sua datasheet (Ver ficheiros abaixo), como também as especificações detalhadas do Arduino UNO através da seguinte ligação https://store.arduino.cc/arduino-uno-rev3.

Step 1: Montagem

Como nesta montagem serão explicadas as funções digital e analógica do sensor de luminosidade, vamos explicar-las separadamente através de 2 montagens explicativas, sendo estas apenas diferentes nos pinos utilizados no sensor e nos pinos do Arduino UNO que recebem a informação.

Material necessário:

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

Instalação do sensor de luminosidade:

O sensor de luminosidade é constituído por 2 pinos de alimentação VCC e GND, podendo ser utilizada uma tensão entre os 3,3VDC e os 5VDC, alem destes o sensor também tem 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 analógico:

Vamos começar então pela montagem que utiliza a saída de sinal analógico, em primeiro lugar ligamos as alimentações do nosso sensor e seguidamente o seu pino A0 a um dos pinos de sinal analógico do Arduino UNO, sendo neste caso também o pino A0.

Depois vamos montar o nosso indicador de quantidade de luminosidade, para simplificar esta montagem utilizamos uma "Breadboard" onde são distribuídas as alimentações positivas e negativas vindas do Arduino e os 10 LED com as suas respectivas resistências de 1KΩ (Ver imagem acima).

Relembro mais uma vez que os LED só funcionam se directamente polarizados, assim os pinos positivos são ligados ao pinos de sinal digital escolhidos do Arduino e o pino negativo ligado a GND, sendo neste caso os pinos escolhidos de 4 a 13, formando assim uma régua de indicação (Ver imagem acima).

Montagem de sinal digital:

Já a montagem que utiliza a saída de sinal digital do sensor é muito idêntica à anterior, porem apenas é necessário alterar o pino de saída de informação do A0 para o D0 e consequentemente também teremos de alterar o pino A0 do Arduino UNO para um dos pinos de sinal digital desocupados, sendo escolhido o pino D2.

Agora teremos que ajustar o nível de luminosidade necessários para que o sensor mude de estado da sua saída neste caso de "HIGH" para "LOW", para que isto aconteça regulamos a resistência variável incorporada na placa para nesse exacto ponto (Ver imagem acima).

Assim se rodarmos no sentido dos ponteiros do relógio o sensor ficará mais sensível à luminosidade e se rodarmos no sentido oposto ficará menos sensível. Já os LED da nossa montagem já não terão a função de indicar a quantidade de iluminação, mas sim indicar se o sensor detecta uma quantidade de iluminação superior à ajustada previamente.

Este tipo de montagem é muito utilizada em sistemas de doméstica em que os equipamento e de iluminação interior e exterior das habitações só acendem se a iluminação natural for reduzida, no entanto ao invés de controlar LED será um relé que liga e desliga a iluminação existente (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 230VAC, através de um pequeno relé:

Arduino Tutorial - Motion Sensor

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, sublinhamos a utilização da função For em 2 situações distintas, esta será 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 "HIGH" ou baixo "LOW" 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:

Com este código será possível indicar a quantidade de luz num determinado local utilizando a régua de LED, o Arduino UNO ao receber este sinal, podendo este variar entre 0 e 5V, irá gerar um valor numérico compreendido entre 0 e 1023, permitindo assim referenciar esse valor ao numero de LED da montagem dividimos o valor máximo 1023 pelo numero de LED que neste caso é 10 (Ver imagem acima).

Entrada analógica:

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


Saída Digital:

//Coloca o pino digital em nível alto:
digitalWrite(Pino, HIGH)
//Coloca o pino digital em nível baixo:
digitalWrite(Pino, LOW)

Este é o código completo para a nossa montagem utilizando a saída de sinal analógica do nosso sensor (Ver ficheiro abaixo).

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 de sinal digital do nosso sensor.

Entrada Digital:

//Leitura de pino digital:
digitalRead(Pino)

Este código é muito mais simples do que o anterior, pois apenas é necessário utilizar uma das saídas digitais para realizar esta funcionalidade, no entanto, para utilizar a mesma montagem, ou seja, controlar os 10 LED colocados na montagem, utilizamos novamente função For para que sejam todos todos os LED 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 da seguinte ligação https://www.arduino.cc/en/Reference/HomePage.

Procurem os nossos tutoriais sobre o Arduino, onde explicamos diversas montagens e o funcionamento dos seus componentes, já agora visitem o nosso canal no Youtube, Instagram, Facebook ou Twitter.

Share

    Recommendations

    • Classroom Science Contest

      Classroom Science Contest
    • Backyard Contest

      Backyard Contest
    • Colors of the Rainbow Contest

      Colors of the Rainbow Contest

    Discussions