Controlando LEDs com Arduino

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:

1. O catodo (Perna curta) do LED ao GND do Arduino;
2. 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 (V_a);
• A tensão suportada pelo seu LED em volts(V_led);
• A corrente suportada pelo seu LED em amperes(I_led).

R = (V_a – V_led) / I_led

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á!

Referências

http://playground.arduino.cc/
http://www.nubiasouza.com.br/controle-do-led-com-push-button-arduino/
http://learn.acrobotic.com/tutorials/post/arduino-activity-03-push-button