Olá, como estão? A princípio iremos desenvolver um projeto com LDR e interrupções, para estar realizando esse objetivo usaremos o KIT básico com Arduíno da WJ Componentes.
Componentes Utilizados no Projeto com LDR e Interrupções
OU
LDR (Resistor Dependente de Luz)
Antes de mais nada iremos precisar saber como que funciona o LDR. Ele vem do inglês Light Dependent Resistor, ou seja, Resistor Dependente de Luz também é conhecido como fotoresistor. Em outras palavras é um tipo de resistor que varia sua resistência a partir da luz. Dessa forma quanto mais a luz, maior será sua resistência, porém, quanto menos luz, menor será sua resistência. Apesar disso o LDR não possui polaridade, em outras palavras, não temos um “lado” correto para conectar na protoboard.
Interrupções com Arduíno
Entretanto, temos que saber como utilizar e como funcionam as interrupções. Contudo as interrupções são um sinal enviado periodicamente por um dispositivo, que interrompe a execução das tarefas da CPU por um tempo. Assim permitindo que execute a instrução enviada pelo equipamento. Em seguida o código retorna para sua rotina convencional. Além disso para usar a interrupção precisamos utilizar os pinos digitais com interrupção, segue uma tabela abaixo dos pinos de alguns microcontroladores:
| PLACAS | PINOS DIGITAIS COM INTERRUPÇÕES |
| Arduíno UNO, Nano e Mini | 2 e 3 |
| Arduíno UNO WiFi Rev.2 | Todos os Pinos Digitais |
| Arduíno Mega, Mega2560 e MegaADK | 2, 3, 18, 19, 20 e 21 |
| Arduíno Micro e Leonardo | 0, 1, 2, 3, 7 |
| Arduíno Zero | Todos os Pinos Digitais, exceto o pino 7 |
| Arduíno Due | Todos os Pinos Digitais |
Sintaxe:
attachInterrupt(digitalPinToInterrupt(pino), ISR, modo);Parâmetros:
- pino – Declaramos o pino de interrupção que utilizamos em nosso projeto.
- ISR – Função a ser chamada quando acontecer interrupção ocorrer.
- modo – Tipo de sinal para que ocorra a interrupção, para isso temos 5 tipos de modos, sendo eles:
- LOW – Sempre que o pino for LOW,
- CHANGE – Sempre que o pino mudar,
- RESING – Sempre que o pino for de LOW para HIGH,
- FALLING – Sempre que o pino for de HIGH para LOW.
- HIGH – Sempre que o pino for HIGH. (Somente Arduíno Due, Zero e MKR1000 suportam).
Exemplo:
//Definições --------------------------------------------------------------------------------------
#define led 2 // Utilizaremos o pino de interrupção
// para utilizar o led,
//Variáveis Globais -------------------------------------------------------------------------------
bool est = LOW; // Utilizaremos uma variável para que
// seja possível armazenar o estado
//Funções Auxiliares ------------------------------------------------------------------------------
void pisca(); // Como iremos utilizar uma função
// auxiliar temos que declarar ela
//Setup -------------------------------------------------------------------------------------------
void setup() {
pinMode(led, OUTPUT); // Configuramos o pino como output
attachInterrupt(digitalPinToInterrupt(led), pisca, CHANGE); // Definimos modo para acionar a
} // interrupção do led, quando ocorrer
// chamamos a função pisca
//Loop --------------------------------------------------------------------------------------------
void loop() {
digitalWrite(led, est); // Mudamos o estado do led
}
//Pisca -------------------------------------------------------------------------------------------
void pisca(){
est = !est; // Invertemos a variável
}Funcionamento do Projeto com LDR e Interrupções
Como foi comentado anteriormente hoje iremos desenvolver um projeto com LDR e Interrupções. Entretanto podemos estar controlando o funcionamento do LED a partir de um botão com as funções de:
- Ligar o LED,
- Controlar o acionamento do LED a partir da luminosidade do ambiente,
- Realizar um fade com o LED a partir da luminosidade do ambiente, ou seja, quanto mais escuro mais forte o led, quanto mais claro mais fraco o LED,
- Desligar o LED.
Todas essas funções irão poder ser acessadas a partir de um único botão assim economizando dinheiro, espaço e melhorando o design do seu projeto.
Montagem do Projeto com LDR e Interrupções
Logo após compra dos componentes na WJ Componentes, vamos à montagem! Em seguida conectamos o LED na protoboard com o resistor que ligamos no catodo do LED, e para finalizar o LED conectamos o anodo ao pino 3 do Arduíno. Logo após conectamos um botão na protoboard e ligamos ao pino 2 do Arduíno, dando seguimento conectamos o LDR com um resistor de 10K Ohms no 5v e um jumper conectando ao pino A5 do Arduíno, em sequência ligamos o GND no LDR.
Contudo segue abaixo uma imagem que demonstra a montagem do circuito.
Diagrama Esquemático do Projeto com LDR e Interrupções
Código-fonte do Projeto com LDR e Interrupções
Em seguida terá o código completo do projeto.
//Definições -----------------------------------------------------------------------------------------
#define btn 2 // Definição do pino do botão
#define led 3 // Definição do pino do LED
#define ldr A5 // Definição do pino do LDR
//Variáveis Globais ----------------------------------------------------------------------------------
byte cont = 0; // Variável de controle
//Funções Auxiliares ---------------------------------------------------------------------------------
void function(); // Seleciona a função
//Setup ----------------------------------------------------------------------------------------------
void setup() {
Serial.begin(9600); // Inicializar a Serial
pinMode(btn, INPUT_PULLUP); // Configura como INPUT PULL UP
pinMode(led, OUTPUT); // Configura como OUTPUT
pinMode(ldr, INPUT); // Configura como INPUT
attachInterrupt(digitalPinToInterrupt(btn), function, FALLING); // Configura interrupção
}
//Loop -----------------------------------------------------------------------------------------------
void loop() {
if (cont == 1) { // Verifica se cont = 1
digitalWrite(led, HIGH); // Liga o LED
}
else if (cont == 2) { // Se não Verifica se cont = 2
if(analogRead(ldr) > 500){ // Se a luminosidade > 500
digitalWrite(led, HIGH); // Liga o LED
}
else { // Se não
digitalWrite(led, LOW); // Desliga o LED
}
}
else if (cont == 3) { // Se não verifica se cont = 3
analogWrite(led, map(analogRead(ldr), 0, 1024, 0, 255)); // Remapeia resistência ao LED
}
else { // Se não
digitalWrite(led, LOW); // Desliga o LED
}
}
//Funções --------------------------------------------------------------------------------------------
void function() {
cont++; // Incrementa +1 a cont
switch(cont){ // Realiza um switch de cont
case 1: // Caso cont = 1
Serial.println(F("[1] Ligado")); // Imprime na Serial
break; // Sai do case
case 2: // Caso cont = 2
Serial.println(F("[2] Ligado com Baixa Iluminação")); // Imprime na Serial
break; // Sai do case
case 3: // Caso cont = 3
Serial.println(F("[3] Fade com Iluminação")); // Imprime na Serial
break; // Sai do case
case 4: // Caso cont = 4
Serial.println(F("[4] Desligado")); // Imprime na Serial
cont = 0; // Atribuímos 0 a cont
break; // Sai do case
}
}Vamos dar uma olhada mais de perto no código:
Definições de Pinos
Primeiramente temos que estar definindo dos pinos que utilizamos em nosso projeto.
//Definições -----------------------------------------------------------------------------------------
#define btn 2 // Definição do pino do botão
#define led 3 // Definição do pino do LED
#define ldr A5 // Definição do pino do LDRVariáveis Globais
Em seguida declaramos uma variável global, sendo ela cont que é responsável por armazenar o valor da função atual.
//Variáveis Globais ----------------------------------------------------------------------------------
byte cont = 0; // Variável de controleFunções Auxiliares
Do mesmo modo também declaramos uma função auxiliar chamada function, onde essa função é responsável por incrementar +1 a cont e assim mudar a função que será executada na função loop.
//Funções Auxiliares ---------------------------------------------------------------------------------
void function(); // Seleciona a funçãoFunções Setup
Em seguida iremos para a função setup, onde estaremos realizando a inicialização da Serial com velocidade de 9600, configuramos o pino 2 como INPUT_PULLUP, pino 3 como OUTPUT e pino A5 como INPUT.
//Setup ----------------------------------------------------------------------------------------------
void setup() {
Serial.begin(9600); // Inicializar a Serial
pinMode(btn, INPUT_PULLUP); // Configura como INPUT PULL UP
pinMode(led, OUTPUT); // Configura como OUTPUT
pinMode(ldr, INPUT); // Configura como INPUT
attachInterrupt(digitalPinToInterrupt(btn), function, FALLING); // Configura interrupção
}Funções Loop
Logo após vamos para a função loop, onde verificamos se cont é igual a 1, 2, 3 ou nenhuma das anteriores, caso seja alguma estaremos realizando a função correspondente a ela. Exemplo caso seja 1 ligaremos o LED, caso seja 2 realizamos o controle do LED a partir da luminosidade, caso seja 3 executamos um fade com o LED com base na luminosidade, ou seja, ele ficará mais forte quanto menor for a iluminação e mais fraco quanto maior for a iluminação e caso não seja nenhuma das anteriores desligamos o LED.
//Loop -----------------------------------------------------------------------------------------------
void loop() {
if (cont == 1) { // Verifica se cont = 1
digitalWrite(led, HIGH); // Liga o LED
}
else if (cont == 2) { // Se não Verifica se cont = 2
if(analogRead(ldr) > 500){ // Se a luminosidade > 500
digitalWrite(led, HIGH); // Liga o LED
}
else { // Se não
digitalWrite(led, LOW); // Desliga o LED
}
}
else if (cont == 3) { // Se não verifica se cont = 3
analogWrite(led, map(analogRead(ldr), 0, 1024, 0, 255)); // Remapeia resistência ao LED
}
else { // Se não
digitalWrite(led, LOW); // Desliga o LED
}
}Função function
Na sequência passamos para a última função chamada function, onde incrementamos +1 em cont e realizamos um switch verificando case, se case é igual 1, 2, 3 ou 4. Caso seja igual a alguma, ele irá imprimir na serial o valor e a função, porém, caso seja igual a 4 atribuímos 0 a cont e imprimimos na serial.
//Funções --------------------------------------------------------------------------------------------
void function() {
cont++; // Incrementa +1 a cont
switch(cont){ // Realiza um switch de cont
case 1: // Caso cont = 1
Serial.println(F("[1] Ligado")); // Imprime na Serial
break; // Sai do case
case 2: // Caso cont = 2
Serial.println(F("[2] Ligado com Baixa Iluminação")); // Imprime na Serial
break; // Sai do case
case 3: // Caso cont = 3
Serial.println(F("[3] Fade com Iluminação")); // Imprime na Serial
break; // Sai do case
case 4: // Caso cont = 4
Serial.println(F("[4] Desligado")); // Imprime na Serial
cont = 0; // Atribuímos 0 a cont
break; // Sai do case
}
}Assim finalizamos todo o código com a explicação sobre o projeto com Arduíno UNO.
Resultado do Projeto com LDR e Interrupções
Por fim esse foi o resultado obtido com o projeto.
Agradecemos sua Presença
Por fim, espero que tenham gostado e aprendido. Então compartilhe com seus colegas e deixe um comentário de qual projeto deveria ser o próximo aqui no Blog da WJ Componentes!!
Enfim estarei deixando o arquivo Arduíno e Fritzing, link dos posts anteriores referentes ao projeto e software e sites utilizados.
Fique à vontade para tirar suas dúvidas nos comentários.
Software e Sites Utilizados
Post Relacionados
- Código Morse com Arduíno UNOOlá, como estão? Hoje iremos desenvolver um decodificador de código… Leia mais: Código Morse com Arduíno UNO
- Como Programar pelo Celular o Arduíno!Olá, como estão? A princípio iremos explicar como programar pelo… Leia mais: Como Programar pelo Celular o Arduíno!
- Como Programar por BlocosOlá, como estão? A princípio iremos falar sobre alguns sites… Leia mais: Como Programar por Blocos
- Contador com Botões no Arduíno UNOOlá, como estão? A princípio iremos realizar um contador. Entretanto… Leia mais: Contador com Botões no Arduíno UNO
- Jogo da Forca com Arduíno UNOOlá, como estão? A princípio iremos falar sobre a Serial… Leia mais: Jogo da Forca com Arduíno UNO
Posts mais Recentes
- Programando Relé RF 4331 -Instruções de emparelhamento do modo de alternância Modo de… Leia mais: Programando Relé RF 433
- Acionando motor DC por meio do pino “Touch” do ESP-32Neste projeto, vamos explorar uma aplicação ainda mais dinâmica e… Leia mais: Acionando motor DC por meio do pino “Touch” do ESP-32
- Acendendo led RGB por meio do pino “Touch” do ESP-32No último post, exploramos o fascinante mundo dos pinos touch… Leia mais: Acendendo led RGB por meio do pino “Touch” do ESP-32
- Utilizando os Pinos touch do ESP32
Nesse projeto Vamos aprender a usar os pinos touch´s do… Leia mais: Utilizando os Pinos touch do ESP32 - Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduinoeste guia, vou levá-lo através dos passos para programar uma… Leia mais: Como Programar e Localizar o Endereço de uma Tela OLED I2C com Arduino
Julio Cesar Bonow Manoel
Cursando Engenharia da Computação pelo Centro Universitário Facens e atua no desenvolvimento de projetos na WJ Componentes. Participante da equipe de robótica Omegabotz.
Deixe um comentário