Led RGB Alto Brilho

Descrição

LED RGB 5mm Difuso. Esse LED possui 4 pinos, e de acordo com a conexão você pode fazer com que ele emita luz nas cores vermelho (RED), verde (GREEN) ou azul (BLUE). Com esse led, você pode montar um sistema de sinalização sem precisar de vários componentes no mesmo circuito..

Especificação

Vermelho
Comprimento de onda: 630-640 nm
Luminosidade: 1000-1200 mcd –
Tensão: 1.8 – 2.0V

Verde
Comprimento de onda: 515-512 nm
Luminosidade: 3000-5000 mcd –
Tensão :3.2 – 3.4V

Azul
Comprimento de onda: 465-475 nm
Luminosidade: 2000-3000 mcd –
Tensão: 3.2 – 3.4V

Tipos de LED

O LED RGB pode ser encontrado no formato cátodo comum ou ânodo comum, sendo que é mais comum encontrarmos o cátodo comum. O LED ânodo comum tem os LEDs internos com o terminal ânodo em comum e que deve ser ligado ao terminal positivo. Já o LED cátodo comum, tem o cátodo como terminal comum e este deve ser ligado ao terminal negativo.

Projeto(s) relacionado(s)

Controlando Led RGB com potenciômetro

O projeto usa 3 Potenciômetros, resistores 100 ou 120 ohms, placa Arduino Uno R3 e jumpers para controlar a cor de um Led RGB.

// Projeto: Controlando Led RGB com potenciômetro 
// Autor: André Silveira
// Data: 12/05/2019

int PinoPotRed   = A0;            // Pino do potenciômetro vermelho 
int PinoPotGreen = A1;           // Pino do potenciômetro verde
int PinoPotBlue  = A2;            // Pino do potenciômetro azul

int PinoLedRed   = 4;             // Pino do Led vermelho
int PinoLedGreen = 5;            // Pino do Led verde
int PinoLedBlue  = 6;             // Pino do Led azul

int Valor   = 0;

void setup() {

     Serial.begin(9600); 
     pinMode(PinoPotRed, INPUT);
     pinMode(PinoPotGreen, INPUT);
     pinMode(PinoPotBlue, INPUT);
   
     pinMode(PinoLedRed, OUTPUT);
     pinMode(PinoLedGreen, OUTPUT);
     pinMode(PinoLedBlue, OUTPUT);

}

void loop() {

  // ---- Vermelho ---- //

     Valor = analogRead(PinoPotRed);
     analogWrite(PinoLedRed, map(Valor, 0, 1023, 0, 255));

  // ---- Verde ---- //

     Valor = analogRead(PinoPotGreen);
     analogWrite(PinoLedGreen, map(Valor, 0, 1023, 0, 255));
     
  // ---- Azul ---- //

     Valor = analogRead(PinoPotBlue);
     analogWrite(PinoLedBlue, map(Valor, 0, 1023, 0, 255));
     
     delay(100);   
}

Led RGB pulsante

O projeto usa resistores 100 ou 120 ohms, placa Arduino Uno R3 e jumpers para controlar a cor de um Led RGB.
Abaixo, duas versões do circuíto para o projeto.

1 - Versão: liga e apaga LED

// Projeto: Led RGB pulsante (Versão 1) 
// Autor: André Silveira
// Data: 12/05/2019

int vermelho = 4;     // Pino da cor vermelho do LED
int verde 	  = 5;      // Pino da cor verde do LED
int azul 	  = 6;      // Pino da cor azul do LED

void setup() {
    pinMode(vermelho, OUTPUT);
    pinMode(verde, OUTPUT);
    pinMode(azul, OUTPUT);
}

void loop() {

  // --- LIGA LED VERMELHO --- //

    ligaled(255, 0, 0);
    delay (500);
    ligaled(0, 0, 0);
    delay (500);
 
  // --- LIGA LED VERDE --- //
      
    ligaled(0, 255, 0);
    delay (500);
    ligaled(0, 0, 0);
    delay (500);
  
  // --- LIGA LED AZUL --- //
    
    ligaled(0, 0, 255);
    delay (500);
    ligaled(0, 0, 0);
    delay (500);
 
}

// --- Função que liga ou desliga os Leds --- //  

int ligaled(int r, int g, int b) {   
 
    analogWrite(vermelho, r);  
    analogWrite(verde, g);  
    analogWrite(azul, b);  

}

2 - Versão: Fade nos LEDs

// Projeto: Led RGB pulsante (Versão 2)
// Autor: André Silveira
// Data: 21/08/2020

// --- O Pino digital PWM simula sinal analógico (0 até 255 ou 0v até 5v) --- //

int vermelho = 11;      // Pino PWM para o led vermelho
int verde 	  = 10;       // Pino PWM para o led verde 
int azul 	  = 9;         // Pino PWM para o led azul 
int i;                          // Variável de contabilização  

void setup() {
    pinMode(vermelho, OUTPUT);
    pinMode(verde, OUTPUT);
    pinMode(azul, OUTPUT);
}
 
void loop() {  
 
 // ---- FADE LED VERMELHO ---- //
 
  for (i = 0; i < 256; i++) {
       ligaled(i, 0, 0);    
       delay(10);     
  }
  
 // ---- FADE LED VERDE ---- //
  
  for (i = 0; i < 256; i++) {
       ligaled(0, i, 0);    
       delay(10);     
  }
  
 // ---- FADE LED AZUL ---- //
  
  for (i = 0; i < 256; i++) {
       ligaled(0, 0, i);    
       delay(10);     
  }  
 
}

// --- Função que liga ou desliga os Leds --- //

int ligaled(int r, int g, int b) {   
 
	analogWrite(vermelho, r);  
	analogWrite(verde, g);  
	analogWrite(azul, b);  

}

Acionando um LED com Chave Táctil ou Push-Button

O projeto utiliza um resistor de 100 ohms (Como calcular o resistor adequado), Chave Táctil Push-Button, Arduino Uno R3 e Jumpers para ligar ou desligar um LED.

Observe que a Chave Táctil possui dois estados lógicos: HIGH (Vcc) e LOW (GND) ou NÃO PRESSIONADO e PRESSIONADO. Entretanto, o circuito lógico do Arduino sempre reconhece 3 estados lógicos, que são: HIGH, LOW e Floating. O Floating ocorre porque o microprocessador não está recebendo nem HIGH ou LOW. Neste último caso, a leitura fica flutuando e o LED fica piscando. Para resolver o problema, é necessário acrescentar um resistor ao circuito ou inicializar o pino da Chave Táctil como INPUT_PULLUP.


// Projeto: Acionando um LED com Chave Táctil ou Push-Button 
// Autor: André Silveira
// Data: 15/02/2019 

int PinoBotao = 6;   				// Pino de entrada do Botão 
int PinoLed = 10;        			// Pino de saída do LED
int Botao_status;  		 		// Variável armazena status do botão

void setup() { 
    pinMode(PinoBotao,INPUT_PULLUP);    // Pino inicializado como INPUT_PULLUP devido floating 
    pinMode(PinoLed,OUTPUT); 
    Serial.begin(9600);
}

void loop() { 
    Botao_status = digitalRead(PinoBotao); 	// Lê status do botão 
    if (Botao_status == LOW) { 			// Se botão foi acionado => LOW 
        digitalWrite(PinoLed,HIGH);  
    } else { 
            digitalWrite(PinoLed,LOW); 
            } 
}

Detecta movimento e acende LED

O projeto usa Módulo Motion detector HC-SR501 (Sensor PIR Passive InfraRed), resistores 150 ohms, placa Arduino Uno R3 e jumpers para acionar um Led quando detecta movimento no ambiente.

// Projeto: Detecta movimento e acende LED 
// Autor: André Silveira
// Data: 12/05/2019

int PinoPIR = A5;        				// Pino do Sensor PIR (HC-SR501)
int PinoLed = 13;				       // Pino do Led 
 
void setup() {
    Serial.begin(9600);
    pinMode(PinoPIR,INPUT);   		       // Inicializa pino como input 
    pinMode(PinoLed,OUTPUT);  		       // Inicializa pino como output
}
 
void loop() { 

    Serial.print("Sensor de movimento: "); 
    if (digitalRead(PinoPIR) == HIGH) {  // Verifica se Sensor foi ativado
        digitalWrite(PinoLed, HIGH);   	 // Acende Led
        Serial.println("ativado"); 
    } else {
            digitalWrite(PinoLed, LOW);  // Apaga Led
            Serial.println("inativo");
            } 
    delay(1);  
    
}

Acendendo LEDS com Shield Ethernet

O projeto utiliza um sensor usa Shield Ethernet, resistores 100 ohms e placa Arduino Uno R3 para controlar Leds.

// Projeto Acendendo LEDS com Shield Ethernet 
// Autor: André Silveira
// Data: 15/02/2018

#include <SPI.h>             						// Biblioteca utilizada para comunicação entre o computador e o Arduino
#include <Ethernet.h>  	     					// Biblioteca utilizada para comunicação entre Shield Ethernet e o Arduino 

byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  	// Endereço físico da placa de rede (MAC ADDRESS) 
byte ip[]  = {192,168,15,104};                 			// Define o endereço IP => http://192.168.15.104
EthernetServer server(80);                     			// Porta aberta para comunicação Internet e Arduino      
String readString;

int Pin1 = 3;  //  LED branco.
int Pin2 = 4;  //  LED azul.
int Pin3 = 5;  //  LED vermelho.
int Pin4 = 6;  //  LED verde.
int Pin5 = 7;  //  LED amarelo.   
    
void setup(){
    pinMode(Pin1, OUTPUT);  					// Define o Pino1 como saída.
    pinMode(Pin2, OUTPUT);  					// Define o Pino2 como saída.
    pinMode(Pin3, OUTPUT);  					// Define o Pino3 como saída.
    pinMode(Pin4, OUTPUT);  					// Define o Pino4 como saída.
    pinMode(Pin5, OUTPUT);  					// Define o Pino5 como saída.
    digitalWrite(Pin1, LOW);  					// Apaga Lampada do Pino1.
    digitalWrite(Pin2, LOW);  					// Apaga Lampada do Pino2.
    digitalWrite(Pin3, LOW);  					// Apaga Lampada do Pino3.
    digitalWrite(Pin4, LOW);  					// Apaga Lampada do Pino4.
    digitalWrite(Pin5, LOW);  					// Apaga Lampada do Pino5.  
    Ethernet.begin(mac, ip);  					// Chama o MAC e o endereço IP da placa Ethernet.
    server.begin();   					        	// Inicia o servidor que esta inserido junto a placa Ethernet.
}

void loop(){

    EthernetClient client = server.available();

    if (client) {

     	while (client.connected()) {

            if (client.available()) {

	// ---- Faz a leitura caracter por caracter da HTTP request  ---- //

                char c = client.read(); 
                if (readString.length() < 100) {
                    readString += c; 
                } 
                
                if (c == '\n') {

    // ---- A partir daqui começa os códigos html ----  //

                  client.println("HTTP/1.1 200 OK");
                  client.println("Content-Type: text/html");
                  client.println();  
                  client.println("<HTML>"); 
                  client.println("<HEAD>");
                  client.println("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />");  
                  client.println("<title>Acendendo LEDs</title>");
                  client.println("</HEAD>");
                  client.println(); 
                  client.println("<style>");
                  client.println("* {font-family: Verdana, Geneva, sans-serif;  font-size: 12px;  text-align: left; }");
                  client.println("#caixa {background-color: #E6E6F0; margin: 80px; height: 250px;");
                  client.println("width: 400px; border: 2px solid #000;}");
                  client.println("#titulo{background-color: #0066FF; margin: 0px; width: 390px;");
                  client.println("font-weight: bold; padding: 5px; text-align: center; vertical-align: middle;");
                  client.println("border-bottom: #000000 2px solid; color: #FFF;}");
                  client.println("ul {margin: 20px 0px 0px 70px; // TOP RIGHT BOTTOM LEFT}");
                  client.println("li {line-height: 28px;}");
                  client.println("</style>");
                  client.println("<BODY>");
                  client.println("<div id=\"caixa\">");
                  client.println("<div id=\"titulo\">Automação residencial: controlando LED</div>");
                  client.println("<ul>");
                  client.println("<li><b>LED Branco: </b><a href=\"/branco/on\">Ligar</a> - <a href=\"/branco/of\">Apagar</a></li>");
                  client.println("<li><b>LED Azul: </b><a href=\"/azul/on\">Ligar</a> - <a href=\"/azul/of\">Apagar</a></li>"); 
                  client.println("<li><b>LED Vermelho: </b><a href=\"/vermelho/on\">Ligar</a> - <a href=\"/vermelho/of\">Apagar</a></li>"); 
                  client.println("<li><b>LED Verde: </b><a href=\"/verde/on\">Ligar</a> - <a href=\"/verde/of\">Apagar</a></li>"); 
                  client.println("<li><b>LED Amarelo: </b><a href=\"/amarelo/on\">Ligar</a> <a href=\"/amarelo/of\">Apagar</a> </li>");
                  client.println("<li><b>LED TODOS: </b><a href=\"/leds/on\">Ligar</a> - <a href=\"/leds/of\">Apagar</a</li>");
                  client.println("</ul>");
                  client.println("</div>");
                  client.println("</BODY>");
                  client.println("</HTML>");
                  delay(1);
                  client.stop();
  
                  if (readString.indexOf("branco/on") > 0)   {
                     digitalWrite(Pin1, HIGH); 
                  } 
                  if (readString.indexOf("branco/of") > 0)   {
                     digitalWrite(Pin1, LOW);  
                  } 
                  if (readString.indexOf("azul/on") > 0)   {
                     digitalWrite(Pin2, HIGH); 
                  } 
                  if (readString.indexOf("azul/of") > 0)   {
                     digitalWrite(Pin2, LOW);  
                  }
                  if (readString.indexOf("vermelho/on") > 0)   {
                     digitalWrite(Pin3, HIGH); 
                  } 
                  if (readString.indexOf("vermelho/of") > 0)   {
                     digitalWrite(Pin3, LOW);  
                  }
                  if (readString.indexOf("verde/on") > 0)   {
                     digitalWrite(Pin4, HIGH); 
                  } 
                  if (readString.indexOf("verde/of") > 0)   {
                     digitalWrite(Pin4, LOW);  
                  }
                  if (readString.indexOf("amarelo/on") > 0)   {
                     digitalWrite(Pin5, HIGH); 
                  } 
                  if (readString.indexOf("amarelo/of") > 0)   {
                     digitalWrite(Pin5, LOW);  
                  }
                  if (readString.indexOf("leds/on") > 0)   {
                      digitalWrite(Pin1, HIGH);  
                      digitalWrite(Pin2, HIGH);  
                      digitalWrite(Pin3, HIGH); 
                      digitalWrite(Pin4, HIGH);  
                      digitalWrite(Pin5, HIGH);  
                  } 
                  if (readString.indexOf("leds/of") > 0)   {
                      digitalWrite(Pin1, LOW);  
                      digitalWrite(Pin2, LOW);  
                      digitalWrite(Pin3, LOW);  
                      digitalWrite(Pin4, LOW);  
                      digitalWrite(Pin5, LOW);  
                  } 
                  readString=""; 
                }
             }
          }
       }
    }

O que é um Servidor?

A internet compreende a união de redes de computadores em nível mundial que conversam entre si através de um conjunto próprio de protocolos de comunicação. Um Servidor é um computador responsável por fornecer e receber dados dos diversos clientes, atuando como centralizador de informação. Em síntese, é um software dentro de um computador centralizador, conectado a uma Rede Local ou da Internet, que pode receber dados de clientes bem como fornecê-los.

O Servidor/Cliente é baseado em um sistema de recebimento, processamento e resposta. O Servidor recebe, processa e responde a requisições feitas por um Cliente através de algum protocolo de comunicação.

O que é um Protocolo de Transferência de Hipertexto?

Protocolo que intermedia a relação entre os computadores que atuam como Servidores de hospedagem sites e os navegadores que utilizamos em nossos computadores ou celulares (Clientes). Neste tipo de relação, utiliza-se para estabelecer a comunicação, o procotolo o HTTP (Hypertext Transfer Protocol), que é responsável pelo tratamento dos pedidos e respostas entre Cliente e Servidor na World Wide Web ou em uma Rede Local. Nesse contexto, chamamos os servidores de Servidores Web.

O que é Linguagem de Marcação de Hipertexto?

As informações que o Servidor Web envia para seu navegador a partir de uma requisição HTTP feita pelo mesmo, pode ocorrer em alguns determinados formatos que precisarão ser interpretados. Um desses formatos é o HTML (HyperText Markup Language), que por sua vez, é uma linguagem utilizada na construção de páginas na Web.

O que é TCP/IP?

TCP (Transmission Control Protocol): responsável pelo suporte a rede global Internet, verificando se os dados são enviados na sequência correta e sem erros via rede.
IP (Internet Protocol): responsável pela comunicação entre os hosts de uma rede (computador ou máquina conectado a uma rede, que conta com número de IP e nome definidos), administrando o transporte de uma mensagem do host de origem até o host de destino.

Como liberar acesso externo ao arduino?

O programa "Acendendo LEDS com Shield Ethernet" criou um Servidor através da tecnologia Ethernet (arquitetura de interconexão para redes locais) e de um protocolo de rede (TCP/IP). O protocolo controla a forma pela qual os computadores e dispositivos na rede interna podem se comunicar. Ele atribuiu o endereço IP 192.168.15.104 e Porta 80 para acesso ao Arduino na Rede Local. Para acesso externo ao programa, é necessário liberar o acesso no Modem/roteador. O procedimento compreende a criação de um redirecionador de portas.

Abaixo, apresenta-se 2 exemplos de configuração de modem para liberar porta de comunicação para o público externo.

Para que o programa "Acendendo LEDS com Shield Ethernet" funcione, libere o "Endereço IP" e "Porta" declarados.

1) Configurando Modem para liberar Porta do Modem Dlink