Controle de uma Fita LED RGB com o Arduino

Introdução

Neste tutorial vamos explicar como usar o seu Arduino para controlar a fita LED RGB de forma simples e prática. A fita possui LEDs com as cores primárias vermelho, verde e azul, por isso o nome RGB (Red, Green e Blue em inglês). Ela permite a possibilidade de formar outras cores misturando a intensidade de cada cor primária, por exemplo, com a ajuda de um potenciômetro. Agora que você sabe que é possível controlar a fita LED RGB, que tal começar o projeto?

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Cabo USB AB 1.50m

R$ 10,35 no PIX

Fita LED RGB - 1 metro

R$ 14,15 no PIX

Potenciômetro 10kΩ

R$ 2,18 no PIX

Transistor NPN TIP122

R$ 2,37 no PIX

Fonte Chaveada 12V 5A

R$ 34,10 no PIX

Adaptador P4 Fêmea - Borne

R$ 3,70 no PIX

Resistor 300Ω - Pacote com 10 unidades

R$ 0,71 no PIX

Protoboard 400 Pontos

R$ 6,55 no PIX

WorkPlate 400 - Preta

R$ 14,15 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

A lista de materiais foi dimensionada para um metro de fita LED, portanto é necessário redimensionar os componentes se seu projeto for utilizar um comprimento maior.

Primeiros Passos

Nessa primera etapa do tutorial, vamos acionar as cores da fita LED de maneira simples e rápida.

Preparando a Fita LED RGB

Antes de começar o projeto é necessário preparar a fita LED RGB, para que você consiga conectar ela ao seu circuito. Primeiro, você deve preparar a fita LED utilizando jumpers M/M de cor vermelha, verde e azul para conectar a fita à sua protoboard. Para isso, corte um lado de seu jumper para efetuar a solda nos pads de conexão da fita LED.

ATENÇÃO: Corte somente um lado do jumper porque a outra ponta (com o pino) vai ser conectada a protoboard.

Depois, descasque a ponta recém cortada e solde-a no pad respectivo da fita LED. Veja o resultado na imagem a seguir.

Solda Fita LED RGB — Solda de jumpers na Fita LED RGB

Circuito

Agora você pode montar o circuito abaixo.

Descricao Breve da Imagem — Circuito LED RGB

Programação

Carregue o código a seguir na sua BlackBoard.

/*******************************************************************************
* Fita LED RGB (v1.0)
*  
* Controlando uma fita LED RGB com o Arduino.
* As cores primarias acendem por 2 segundos. Por ultimo, duas cores
* sao misturadas para formar uma nova cor.
*
* Copyright 2019 RoboCore.
* Escrito por Renan Piva (30/04/2019).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*********************************************************************************/

// Declarando os pinos
const int PINO_LED_R = 11;	// Vermelho
const int PINO_LED_G = 10;  // Verde
const int PINO_LED_B = 9;	// Azul

void setup() {
  // Configurando os pinos como saida
  pinMode(PINO_LED_R, OUTPUT); // LED vermelho
  pinMode(PINO_LED_G, OUTPUT); // LED verde
  pinMode(PINO_LED_B, OUTPUT); // LED azul
}

void loop() {
  // Ligando o LED vermelho e desligando o LED azul e verde
  digitalWrite(PINO_LED_R, HIGH); // Liga LED vermelho
  digitalWrite(PINO_LED_G, LOW);  // Desliga LED verde
  digitalWrite(PINO_LED_B, LOW);  // Desliga LED azul
  delay(2000);                    // Deixando dois segundos aceso LED vermelho
  digitalWrite(PINO_LED_R, LOW);  // Desliga LED vermelho
  delay(2000);                    // Espera dois segundos para ligar o proximo LED

  // Ligando LED verde e desligando LED vermelho e verde
  digitalWrite(PINO_LED_R, LOW);  // Desliga LED vermelho
  digitalWrite(PINO_LED_G, HIGH); // Liga LED verde
  digitalWrite(PINO_LED_B, LOW);  // Desliga LED azul
  delay(2000);                    // Deixando dois segundos aceso LED verde
  digitalWrite(PINO_LED_G, LOW);  // Desliga LED verde
  delay(2000);                    // Espera dois segundos para ligar proximo LED

  // Ligando LED azul e desligando LED vermelho e verde
  digitalWrite(PINO_LED_R, LOW);  // Desliga LED vermelho
  digitalWrite(PINO_LED_G, LOW);  // Desliga LED verde
  digitalWrite(PINO_LED_B, HIGH); // Liga LED azul
  delay(2000);                    // Deixando 2 segundos para ligar proximo LED
  digitalWrite(PINO_LED_B, LOW);  // Desliga LED azul
  delay(2000);                    // Espera 2 segundos para voltar ao  LED vermelho

  // Ligando LED vermelho e azul para criar roxo
  digitalWrite(PINO_LED_R, HIGH); // Liga LED vermelho
  digitalWrite(PINO_LED_G, LOW);  // Desliga LED verde
  digitalWrite(PINO_LED_B, HIGH); // Liga LED azul
  delay(2000);                    // Deixando 2 segundos para ligar proximo LED
  digitalWrite(PINO_LED_R, LOW);  // Desliga LED vermelho
  digitalWrite(PINO_LED_B, LOW);  // Desliga LED azul
  delay(2000);                    // Espera dois segundos para voltar ao vermelho
}

Entendendo o Código

A primeira parte do código consiste em declarar as variáveis referentes aos pinos de cada cor da fita LED, dando a você a possibilidade de criar 7 cores diferentes. Na inicialização do programa (função setup()), configuramos os pinos como saídas. Em seguida, na função loop(), controlamos os pinos de cada cor para escolher como os LEDs acendem.

No trecho abaixo, repare que na primeira linha o pino referente à cor vermelha está em HIGH, o que significa que o LED vermelho é ligado, enquanto as outras cores estão em LOW, portanto desligadas. A mesma lógica é usada na sequência para ligar apenas as luzes verde e azul.

 // Ligando o LED vermelho e desligando o LED azul e verde
 digitalWrite(PINO_LED_R, HIGH)	// Liga LED vermelho
 digitalWrite(PINO_LED_G, LOW); // Desliga LED verde
 digitalWrite(PINO_LED_B, LOW); // Desliga LED azul
 delay(2000);                   // Deixando dois segundos aceso LED vermelho
 digitalWrite(PINO_LED_R, LOW); // Desliga LED vermelho
 delay(2000);                   // Espera dois segundos para ligar o proximo LED

No último trecho do código, inserido abaixo, usamos as cores vermelha e azul em HIGH e a cor verde em LOW, criando assim a cor roxa.

digitalWrite(PINO_LED_R, HIGH);	// Liga LED vermelho
digitalWrite(PINO_LED_G, LOW);  // Desliga LED verde
digitalWrite(PINO_LED_B, HIGH); // Liga LED azul

O Que Deve Acontecer

Veja o resultado na animação a seguir.

Acionando fita LED RGB com sua BlackBoard

Controle com Potenciômetros

Que tal agora acrescentar potenciômetros no seu projeto para misturar as cores da fita LED? Assim você pode utilizar as cores primárias para deixar seu projeto com cores diferentes.

Circuito

Monte o circuito como o da imagem abaixo.

Programação

Carregue o código a seguir na sua BlackBoard.

/******************************************************************************************
* Fita LED RGB com Potenciometros (v1.0)
*
* Controle de intensidade de cada cor primaria utilizando potenciometros.
*
* Copyright 2019 RoboCore.
* Escrito por Renan Piva (30/04/2019).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
******************************************************************************************/

// Declarando os pinos
const int PINO_POT_R = A1; // Potenciometro do LED vermelho
const int PINO_LED_R = 11; // Pino do LED vermelho
const int PINO_POT_G = A2; // Potenciometro do LED verde
const int PINO_LED_G = 10; // Pino do LED verde
const int PINO_POT_B = A3; // Potenciometro do LED azul
const int PINO_LED_B = 9;  // Pino do LED azul

int valor_pot = 0;         // Valor de leitura do potenciometro
int valor_LED_RGB = 0;     // Valor dos LEDs RGB

void setup() {
  // Configurando os pinos para cada saida
  pinMode(PINO_POT_R, INPUT);	// Pino do potenciometro para LED vermelho
  pinMode(PINO_POT_G, INPUT);   // Pino do potenciometro para LED verde
  pinMode(PINO_POT_B, INPUT);   // Pino do potenciometro para LED azul
  pinMode(PINO_LED_R, OUTPUT);  // LED vermelho
  pinMode(PINO_LED_G, OUTPUT);  // LED verde
  pinMode(PINO_LED_B, OUTPUT);  // LED azul
}

void loop() {
  // Controle do LED vermelho
  valor_pot = analogRead(PINO_POT_R);				// Lendo o valor do potenciometro
  valor_LED_RGB = map(valor_pot, 0,1023, 0, 255);   // Convertendo o valor
  analogWrite(PINO_LED_R, valor_LED_RGB);           // Alterando o valor do PWM

  // Controle do LED verde
  valor_pot = analogRead(PINO_POT_G);               // Informando valor pino para verde
  valor_LED_RGB = map(valor_pot, 0, 1023, 0, 255);  // Informando valor para o potenciometro
  analogWrite(PINO_LED_G, valor_LED_RGB);           // Mudando o valor para analogico

  // Controle do LED azul
  valor_pot = analogRead(PINO_POT_B);               // Informando valor pino para azul
  valor_LED_RGB = map(valor_pot, 0, 1023, 0, 255);  // Informando valor para o potenciometro
  analogWrite(PINO_LED_B, valor_LED_RGB);           // Mudando o valor para analogico
}

Entendendo o Código

Com a adição dos potenciômetros, o código controla a intensidade de cada cor da fita LED RGB utilizando sinais PWM, portanto passamos a usar a função analogWrite(). O PWM (modulação por largura de pulso) é um método que utiliza um pino digital para variar a energia sobre a carga. Essa variação é controlada pelo duty cycle (ciclo de trabalho), que é, para uma frequência fixa, a proporção do tempo em que a tensão fica em nível lógico alto no período da onda quadrada. Veja o exemplo abaixo, onde as linhas verdes indicam os intervalos dos ciclos da onda (período) e a linha preta representa o sinal PWM.

Demonstração de onda quadrada da função duty cycle
*Fonte: https://www.arduino.cc/en/Tutorial/PWM*

A função analogWrite() no Arduino é utilizada para definir o duty cycle de uma saída PWM e utiliza um parâmetro de 0 a 255, valores que equivalem a 0 e 100 % respectivamente. Como usamos os potenciômetros, cujas leituras vão de 0 a 1023, precisamos converter os valores lidos para valores dentro da faixa de leitura da função. Para isso utilizamos a função map().

A função map() converte um valor dentro de um intervalo para o valor equivalente dentro de um segundo intervalo. Por exemplo, considerando o intervalo de leitura potenciômetro, que é de 0 a 1023, e o intervalo aceito pela funçãoanalogWrite(), que é de 0 a 255, transformamos o valor lido de 512, que equivale a 50 % do potenciômetro, para o valor de 50 % da função, que é 127.

O Que Deve Acontecer

Diferentemente da primeira etapa, agora a intensidade de cada cor primária da fita LED RGB está sendo controlada pelos potenciômetros, dando a possibilidade de deixar sua fita LED RGB com a cor que você desejar.

Solução de Problemas

Caso uma cor não ligue, verifique as conexões dos jumpers e a posição dos transistores TIP122. Verifique também que a sua fonte de 12 V está alimentando corretamente o conjunto.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

gvan1961
date

Enviado 2023-12-22 20:56:31

Como amplificar o sinal de controle para usar 4 fitas ws2812b com o arduino?

luan.ferreira
date

Enviado 2024-01-02 09:38:45
gvan1961

Olá! Neste caso, se pretende controlar 4 fitas de 1 metro cada (somando 4 metros), acreditamos que não deve ser necessário amplificar o sinal. No entanto, caso queira controlar 4 rolos de fita (que geralmente contém 5 metros cada (somando 20 metros)), talvez seja necessário amplificar o sinal, porém como infelizmente nunca realizamos essa aplicação, infelizmente não temos muita informação sobre como fazer essa amplificação.

luan.ferreira
date

Enviado 2024-01-02 09:39:22
gvan1961

Caso seja a segunda opção (controlar 20 metros de fita), você pode usar um pino para cada rolo de fita, pois assim você não deve ter problemas para controlar as fitas, e caso precise que elas funcionem em conjunto, será necessário criar um código para essa função (acionamento em conjunto). De toda forma, vale lembrar que, para realizar esse projeto é necessário usar uma fonte de alimentação capaz de suprir o consumo das fitas.

lacerdabusatta
date

Enviado 2023-04-20 15:16:10

Para fazer o projeto com 5 metros de fita led, eu devo aumentar a resistência em 5x (1.5KOhms) ou reduzir em 5x (60Ohms)? Eu consegui identificar que o consumo de corrente vai de 1.2Amps para 6Amps, mas me perdi no cálculo da tensão pra verificar o total da resistência.

Giovanni5

Enviado 2023-04-20 15:47:02
lacerdabusatta

Se você está se referindo ao transistor conectado ao TIP122, ele não deve precisar ser mudado, mesmo com uma extensão maior da fita de LED, já que ele já é capaz de saturar ("acionar") o transistor. Entretanto, como o TIP122 só é capaz de conduzir 5A (https://www.onsemi.com/pdf/datasheet/tip120-d.pdf), para 6A de corrente para a fita, ele pode ser danificado, e portanto será necessário um transistor que suporte uma potência maior para essa extensão de fita, e então você pode utilizar calculadoras de resistência para saturação de transistores, para saber qual o valor do resistor.

fobalia
date

Enviado 2023-02-06 22:17:57

Boa noite, eu conseguiria fazer algum tipo de comunicação com o arduino pelo pc e utilizar algum software tipo aurasync ?

luan.ferreira
date

Enviado 2023-02-07 09:09:41
fobalia

Olá! É possível conectar a placa ao computador, e controlar a cor do RGB através dele. No entanto, deve ser criado um código que seja compatível com o software que será usado no computador. Vale dizer que infelizmente não temos nenhum tutorial que mostre como realizar essa aplicação, e por isso não temos uma indicação de qual programa para computador pode ser utilizado.

m.serpellone
date

Enviado 2023-01-06 13:58:34

Tem que ser o adaptador P4-macho e não o p4-fêmea como está na lista de materiais.

m.serpellone
date

Enviado 2023-01-06 14:52:54
m.serpellone

Se você ficou meio perdido como eu: a fonte liga no adaptador, e não direto na placa. Agora deu certo :D

luan.ferreira
date

Enviado 2023-01-06 16:12:43
m.serpellone

Ficamos felizes em saber que funcionou. Vale dizer que você está correto, a fonte é para ser conectada no adaptador que está conectado na fita LED. No gif usado para demonstrar o funcionamento do projeto, usamos uma segunda fonte para alimentar a BlackBoard, porém essa segunda fonte não é necessária, pois a placa pode ser alimentada pela USB.

tiago.ney
date

Enviado 2022-04-12 12:21:25

Boa tarde! Quero fazer um projeto de nascer e por do sol com fita WRGB. O que muda com relação aos componentes? E, alguém sabe onde consigo um código pronto pra adiantar minha vida?

Giovanni5

Enviado 2022-04-12 12:54:22
tiago.ney

Se você está se referindo à fitas de LED RBD endereçáveis, como a WS2812B (https://www.robocore.net/display-led/fita-de-led-rgb-ws2812-5050-1m), por exemplo, o controle dela mudará completamente, e você pode ver como o controle é feito através do vídeo a seguir, https://www.youtube.com/watch?v=QBX2EglOEgM . Já sobre o código para o seu projeto, infelizmente não temos um código ou tutorial específico para isso.

redesistema
date

Enviado 2020-08-17 10:21:06

ah, ja me liguei qual foi minha confusao.. os pinos analogicos sao somente de ENTRADA. Os digitais sao ENTRADA DIGITAL, SAIDA DIGITAL, SAIDA PWM.
Eh, apesar de eu ter feito todo o kit iniciante e todo o avancado, alguns conceitos estao muito recente na minha cabeca, rs
O Nano e Node nao tem marcacoes ~nos pinos de quais sao PWM... todos sao?

Giovanni5

Enviado 2020-08-17 10:53:07
redesistema

Na verdade, apenas os pinos analógicos A6 e A7 da Nano são utilizados somente como entradas analógicas, o outros pinos analógicos  podem ser utilizados também como entradas digitais e como saídas digitais, pois são compostos de um conversor analógico digital ("ADC"). Em relação às saídas PWM, não, nem todas as portas digitais da Nano possuem saída PWM. Como ela possui o mesmo microcontrolador das placas Arduino UNO, os mesmos pinos digitais que possuem saída PWM na UNO, também possuem na Nano, ou seja, somente os pinos 3, 5, 6, 9, 10 e 11 possuem saída PWM na Nano.

redesistema
date

Enviado 2020-08-16 11:43:37

Puts, como disse abaixo, apanhei mas rodou no NANO (na tentativa e erro). Tentei agora no NodeMCU ( q outras coisas seguindo tutorial eu consegui fazer, controlar pelo Blynk, etc). Mas simplesmente replicar isso no Node nao consigo, tb nao entendo qual a logica das portas dele, D0 a d7 e nao ter portas "A"

Giovanni5

Enviado 2020-08-17 09:35:59
redesistema

As portas digitais no NodeMCU, assim como na placa Nano, são representadas pela sigla "D", e o NodeMCU possui apenas um pino analógico ("A0"). Provavelmente você não obteve sucesso com este projeto usando o NodeMCU por conta da diferença de tensões operacionais. O NodeMCU opera em 3,3 V, enquanto a maioria das placas da plataforma Arduino operam em 5 V. Levando isso em conta, é necessário alterar o circuito de acionamento da fita de LED, para compatibilizar o NodeMCU com este projeto.

redesistema
date

Enviado 2020-08-16 11:26:08

Ola! Fiz esse projeto com o UNO, ok, tudo certo. Apanhei para replicar no NANO por falta de conceito da minha parte.
Afinal o NANO, tem portas D2 a D12 (Entendo q isso sejam portas digitais) e portas A1 a A7 (entendo q isso sejam as analogicas). Porem so consegui fazer usando as portas "D" e nao as "A". Afinal, o que determina isso? o uso de digitalWrite ou analogWrite? Qual a difereca? Analogica eh sempre 0 a 255 e nao 0 a 1023 certo? Socorro, rs

Giovanni5

Enviado 2020-08-17 09:18:48
redesistema

As placas da plataforma Arduino Nano possuem o mesmo microcontrolador das placas Arduino UNO (em um encapsulamento diferente), portanto você pode simplesmente replicar as conexões deste projeto com a Nano. Os pinos com demarcação "D" são pinos digitais, logo os pinos com demarcações "A" são pinos analógicos. A diferença entre "digitalWrite()" e "analogWrite()" é o tipo de sinal enviado. Para o "digitalWrite()" é enviado um sinal digital de 0 (LOW) ou 5 V (HIGH). Já para o "analogWrite()" é enviado um PWM digital que varia entre 0 e 255 ("duty cycle" de 0 e 100%, respectivamente).

Giovanni5

Enviado 2020-08-17 09:19:55
redesistema

Os valores de 0 a 1023 mencionados estão relacionados à resolução de leitura analógica ("analogRead()") da placa.

edu.gripp13
date

Enviado 2020-07-24 22:33:00

Boa noite, seria possível eu alimentar o arduino através de uma fonte 12v 2A pelo jack de energia e, dessa forma, alimentar a fita de LED pelo pino VIN?

Giovanni5

Enviado 2020-07-27 08:35:41
edu.gripp13

Isso vai depender um pouco do comprimento de fita de LED que você deseja alimentar, pois quanto maior o comprimento, maior é o consumo de corrente de fita, para alimentar todos os LEDs. Com uma fonte de 12 V 2 A, você deve ser capaz de alimentar um placa Arduino UNO, com o restante do seu circuito de controle, se for o caso, e ainda alimentar 1 metro desta fita de LED. Entretanto, lembre-se que, é necessário dimensionar a fonte de alimentação, de acordo com o consumo de corrente do sistema completo, para que ela seja capaz de alimentar todos os componentes em máxima eficiência.

Giovanni5

Enviado 2020-07-27 08:36:30
edu.gripp13

Você pode dimensionar corretamente a fonte de alimentação necessária para o comprimento de fita desejado, através da potência consumida por metro pela fita de LED, que está disponível nas "Inf. Técnicas" da página do produto (https://www.robocore.net/loja/itens-eletronicos/fita-led-rgb).

Francois

Enviado 2020-07-27 18:18:19
edu.gripp13

Complementando a resposta do Giovanni5, não é recomendado alimentar uma carga de mais de 2 A usando o pino VIN (ou qualquer outro do Arduino). Uma corrente dessa magnitude pode provocar o derretimento do conector, pois ele é dimensionado para sinais de baixa corrente. Por isso, alimente a sua fita LED separadamente (mesmo que usando a mesma fonte) e, se necessário para o seu circuito, interligue os pólos negativos (GND) para fechar as malhas.