Tudo que você queria saber sobre LEDs com Arduino, mas tinha vergonha de perguntar.
Mais um artigo sobre LEDS?
Sim! Mas agora procurei agrupar em um só lugar toda a teoria e prática necessária para o desenvolvimento de projetos envolvendo esse componente muitas vezes subestimado mas que, na verdade, é uma das estrelas da eletrônica e uma das grandes invenções da humanidade: O LED!
LED para Leigos
O que é um LED?
O LED (Light Emitting Diode ou Diodo Emissor de Luz) é um dos componentes eletrônicos mais utilizados no mundo da eletrônica e sua principal aplicação é na sinalização, como indicador visual. Ele nada mais é do que um diodo semicondutor que, quando é energizado, emite luz visível de uma determinada cor. Essa cor dependente do cristal e da impureza de dopagem com que o componente é fabricado.
Um diodo semicondutor é um componente eletrônico que conduz corrente elétrica apenas em uma polarização (anodo positivo e catodo negativo). Vejamos então como identificar os terminais de um LED:
Tipos de LED
Vejamos agora os principais tipos de LED usados com Arduino.
LEDs difusos: a luz destes LEDs é espalhada por sua cápsula de plástico de forma uniforme.
LEDs de alto brilho: A cápsula de plástico deste LED é transparente, o que aumenta sua luminosidade.
Fitas de LED: É uma fita que possui em sua extensão vários LEDs minúsculos (SMD), brilhando em conjunto ou alternadamente;
LEDs RGB: possuem três cores, vermelho (Red), verde (Green) e azul (Blue) que, combinadas, podem formar milhares de cores;
Matriz de LEDs: são conjuntos de LEDs usados em linhas e colunas, para apresentar letras e até gráficos de baixa resolução. Podem funcionar em conjunto ou individualmente.
Esquema de ligação
Para controlarmos um LED pelo Arduino, usamos a seguinte ligação física:
- O catodo (Perna curta) do LED ao GND do Arduino;
- O anodo (Perna comprida) do LED a uma porta digital do Arduino através de um resistor.
Observações:
A) Para qualquer tipo de LED, a ligação vai ser sempre essa;
B) O resistor é necessário como limitador de corrente, caso contrário o LED poderá ser danificado. Para calcularmos seu valor de uma forma bem simples, devemos saber:
- A tensão da fonte de alimentação (Va);
- A tensão suportada pelo seu LED em volts(Vled);
- A corrente suportada pelo seu LED em amperes(Iled).
R = (Va – Vled) / Iled
Exemplo: Sabendo que a maioria dos LEDs suporta uma corrente de 0,02A com 3V e que a tensão fornecida pelo Arduino UNO é de 5V, temos o seguinte resultado:
2V / 0,02A = 100Ω
Na prática, podem ser usados quaisquer resistores com valores entre 220Ω a 430Ω.
Caso seja perfeccionista ou sofra de T.O.C. e quer calcular o valor exato, neste endereço, você encontra uma calculadora online: http://led.linear1.org/1led.wiz
C) O Arduino possui um LED e resistor interno na porta 13. Esse LED pode ser usado para testes.
D) Para controlar o LED, basta enviar um sinal para o pino onde o anodo está ligado:
HIGH ou 1 → Acende o LED
LOW ou 0 → Desliga o LED
E) É possível variar a intensidade da luz utilizando-se um pino PWM que aceita valores de 0 (Desligado) a 255 (máxima intensidade).
Projetos de LEDs com Arduino
Veremos agora algumas montagens e sketches básicos de LEDs com Arduino.
Blink com LED interno
Este é o clássico Hello World com Arduino. O Objetivo é fazer o LED interno conectado ao pino 13 piscar em um intervalo fixo.
Esquema: Somente o Arduino é necessário.
Sketch:
byte ledPin = 13; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); }
Blink com LED externo
Produz o mesmo efeito do exemplo anterior, mas agora usando um led externo.
Esquema:
Sketch:
byte ledPin = 5; void setup() { pinMode(ledPin, OUTPUT); } void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); }
Blink sem delay
Muitas vezes queremos realizar outros tipos de processamento ao mesmo tempo em que o LED está piscando. Nesse caso não podemos usar o comando delay pois esse comando para todo o processamento. A solução é usar o comando millis:
Esquema: O mesmo da figura 9
Sketch:
byte ledPin = 5; // Pino do LED boolean ledState = false; // Estado do LED: False = desligado ou true = ligado long prevMillis = 0; // Última mudança de estado long interval = 2000; // intervalo desejado para o blink void setup() { pinMode(ledPin, OUTPUT); } void loop() { unsigned long curMillis = millis(); //millis atual if(curMillis - prevMillis > interval) { prevMillis = curMillis; ledState = !ledState; digitalWrite(ledPin, ledState); } }
Blink com delay variável via potenciômetro
Neste exemplo, o delay do blink será controlado por um potenciômetro. Conforme o potenciômetro é ajustado, o tempo entre as piscadas irá diminuir ou aumentar.
Esquema:
Sketch:
int ledPin = 10; int potPin = 0; int interval = 0; void setup() { pinMode(ledPin,OUTPUT); } void loop() { //Leitura do valor do potenciômetro que é usada como delay interval = analogRead(potPin); digitalWrite(ledPin, HIGH); delay(interval); digitalWrite(ledPin, LOW); delay(interval); }
Efeito FADE – Controle da intensidade
Neste exemplo vamos controlar a intensidade do brilho do LED através de uma porta PWM que permite variarmos o sinal de 0 até 255 .
Esquema: O mesmo da figura 9
Sketch:
int ledPin = 5; // pino onde o LED vai estar ligado int brilho = 0; // variável que armazena a quatidade de brilho do LED. int fade = 5; // determina a variação void setup() { // configura o pino 5 como saída digital pinMode(ledPin, OUTPUT); } void loop() { //Acende o LED com o brilho atual analogWrite(ledPin, brilho); // Altera o brilho para o próximo loop brilho = brilho + fade; // Inverte a direção do Fade if (brilho == 0 || brilho == 255) { fade = -fade ; } // Espera 30 milisegundos para percebermos a variação delay(30); }
Controle da intensidade por potenciômetro
Agora vamos controlar a intensidade do brilho do LED através de um potenciômetro ligado à uma saída analógica que permite variarmos o sinal de 0 até 1023. No entanto teremos que compatibilizar o sinal para variar entre 0 e 255.
Esquema: O mesmo da figura 10
Sketch:
#define potPin 0 // Pino do potenciômetro #define ledPin 10 // Pino do LED int valPot = 0; //Variável para ler o potenciômetro void setup() { pinMode(ledPin,OUTPUT); // Configura o pino do LED como saída } void loop() { valPot = analogRead(potPin); //Leitura do potenciômetro valPot = map(valPot,0,1023,0,255); //Transforma a escala analogWrite(ledPin,valPot ); // Aciona o LED proporcionalmente }
Blink com PushButton
Vamos fazer o led acender toda vez que o pushbutton for pressionado. Repare que estamos ativando o resistor pull-up interno para o botão.
Esquema:
Sketch:
int ledPin = 11; int buttonPin = 2; int buttonState = LOW; //Estado do botão void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); //Resitor pull-up interno } void loop() { buttonState = digitalRead(buttonPin); if (buttonState == LOW) { digitalWrite(ledPin, HIGH); } else { digitalWrite(ledPin, LOW); } }
Liga/Desliga LED com PushButton
Para este experimento, vamos transformar o pushbutton em um interruptor que vai ligar ou desligar o led.
Um problema típico para este tipo de aplicação é o efeito de bouncing: Como a velocidade de processamento do microprocessador é muito alta, o pressionamento do botão pode ser detectado mais de uma vez. Para contornar essa situação, vamos apelar novamente para o millis.
Esquema: O mesmo da figura 11
Sketch:
int ledPin = 11; int buttonPin = 2; int buttonState = LOW; // Estado atual do botão int oldButtonState = LOW; // Estado anterior do botão int ledState = LOW; //Estado do botão int time = 0; int bounceWait = 200; //Tempo de espera para evitar bounce void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT_PULLUP); //Ativamos o resistor interno } void loop() { buttonState = digitalRead(buttonPin); //Leitura do botão // Verifica os estado do botão e o tempo de bounce if ( (buttonState == HIGH) && (oldButtonState == LOW) && ((millis() - time) > bounceWait) ) { // Muda o estado do LED if (ledState == HIGH) ledState = LOW; else ledState = HIGH; time = millis(); //Guarda o valor de millis para testes do próximo bounce } // Muda o estado do led digitalWrite(ledPin, ledState); // Guarda o estado do botão para o próximo loop oldButtonState = buttonState; }
Trabalhando com LED RGB
Controlar um LED RGB é a mesma coisa que trabalhar com três LEDs separados com as cores Red, Green e Blue. Cada perna do LED deverá ser ligada a um resistor. Você pode enviar sinais de 0 a 255 para fazer a combinação de milhares de cores.
Exemplo:
Vermelho → R=255,G=0,B=0
Azul → R=0,G=0,B=255
Amarelo → R=255,G=255,B=0
Cuidado! Você precisa verificar se o seu LED é Anodo Comum. Nesse caso os valores são invertidos
Esquema:
Sketch:
int redPin = 11; int greenPin = 10; int bluePin = 9; //Descomente essa linha seu o seu led é ANODO comum //#define COMMON_ANODE void setup() { pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT); } void loop() { setColor(255, 0, 0); // vermelho delay(1000); setColor(0, 255, 0); // verde delay(1000); setColor(0, 0, 255); // azul delay(1000); setColor(255, 255, 0); // amarelho delay(1000); setColor(80, 0, 80); // roxo delay(1000); } void setColor(int red, int green, int blue) { #ifdef COMMON_ANODE red = 255 - red; green = 255 - green; blue = 255 - blue; #endif analogWrite(redPin, red); analogWrite(greenPin, green); analogWrite(bluePin, blue); }
Conclusão
Espero ter ajudado o iniciante em Arduino a tirar todas suas dúvidas com o controle de LEDs. Em breve irei publicar projetos mais elaborados com esse componente aqui no blog.
Até lá!