Fita LED Endereçável com a BlackBoard Uno

Introdução

Desde a época que os LEDs foram criados, o mundo vem se atualizado para o uso desta tecnologia como substituta das antigas lâmpadas incandescentes e das não tão antigas lâmpadas fluorescentes. Em certo momento os LEDs RGB foram criados, e cada vez mais os ambientes em que vivemos tem se tornado mais coloridos.

Neste tutorial veremos como controlar a fita de LED RGB endereçável WS2812B utilizando a BlackBoard UNO, para o controle total dos LEDs da extensão da fita, e para o controle individual de cada LED da extensão da fita.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$99.90

Fita LED RGB Endereçável WS2812B 5050 - 1 metro

R$74.90

Adaptador P4 Fêmea - Borne

R$3.90

Fonte Chaveada 5V 5A

R$49.90

Sensor de Som

R$14.90

Protoboard 400 Pontos

R$7.50

Jumpers Macho-Macho x40 Unidades

R$7.90

Cabo USB AB 40cm

R$10.50

Conceitos Teóricos

LED RGB

LEDs RGB são componentes que basicamente possuem 3 componentes diferentes dentro de um único encapsulamento. Isso se deve pelo fato de que o LED RGB nada mais é do que 3 LEDs de cores distintas, que são, vermelho ("Red" - R), verde ("Green" - G) e azul ("Blue" - B). Inclusive é desta combinação que seu nome é concebido.

Assim como todo LED comum, os LEDs RGB também possuem polaridade, porém de uma maneira um pouco diferente. Este tipo de LED geralmente possui 4 terminais, sendo que 3 deles são para controle individual das cores do componente, ou seja, um terminal para a cor vermelha, um terminal para a cor verde, e um terminal para a cor azul. O quarto terminal restante é chamado de "comum", pois ele é internamente conectado aos 3 LEDs do componente, para completar o circuito e fazer com que cada LED seja aceso. Entretanto, dependendo da fabricação do componente, o terminal "comum" pode ser o ânodo ou o cátodo de todos os LEDs, como nas imagens abaixo, por exemplo.

led-rgb-anodo-comum — LED RGB Ânodo Comum

Como cada cor do LED RGB pode ser controlada individualmente, é possível criar uma imensidade de combinações e cores distintas, como mostrado na tabela abaixo. No caso da cor preta, listada abaixo, o resultado é obtido mantendo todos as cores em seu valor mínimo, ou seja, no caso do LED RGB, todos os LEDs internos estariam desligados, e como o encapsulamento destes LEDs são normalmente transparentes, infelizmente não é possível replicar a cor preta.

tabela-cores-rgb — Tabela de Cores RGB
Fonte: Wikipedia

Em algumas aplicações foi necessário o controle paralelo de diversos LEDs RGB, e para sanar essa necessidade foi criado a fita de LED RGB, que ensinamos como controlar no tutorial Controle de uma Fita LED RGB com o Arduino.

LED RGB Endereçável

Já os LEDs RGB endereçáveis foram desenvolvidos para suprir uma nova necessidade do mercado. Embora o controle paralelo de LEDs RGB seja o suficiente para a maioria das aplicações no passado, começaram a surgir aplicações mais complexas e que dependiam do controle individual de inúmeros LEDs RGB. Este novo componente criado, não só possui um LED RGB em seu encapsulamento, como também possui um microcontrolador que é responsável por receber um sinal digital de um protocolo de comunicação específico para o controle deste modelo de componente, como também de retransmitir esse sinal para o componente em série seguinte, e controlar o LED RGB interno. Um esquema básico de ligação e controle pode ser visto na próxima imagem.

conexao-comunicacao-led-rgb-enderecavel — Conexão e Comunicação do LED RGB Endereçável
Fonte: Tim's Blog

Como é possível observar na imagem acima, este novo modelo de componente também possui 4 terminais, porém neste caso, 2 são para alimentação positiva e negativa, enquanto os outros dois são para receber e enviar os sinais digitais do protocolo de comunicação. Neste momento vale ressaltar que, como o LED RGB endereçável possui um pino para receber e outro para enviar sinais, é necessário atentar-se ao sentido de transmissão de dados da fita de LEDs.

Outro ponto interessante que vale ressaltar no controle destes componentes é que, diferentemente dos LEDs RGB comuns, o controle dos modelos endereçáveis não são tão diretos. O valor de acionamento de cada cor de LED deve ser primeiramente salvo na memória RAM do microcontrolador do componente, e então, através de um comando de controle específico o microcontrolador irá acionar os LEDs do componente, exibindo a cor desejada.

Controle Conjunto dos LEDs

Neste primeiro projeto iremos controlar todos os LEDs da extensão da fita em conjunto, como se fosse o controle paralelo de LEDs RGB comuns, para exibir gradualmente as cores RGB e então criar algumas combinações de cores.

Circuito

Para este primeiro projeto monte o circuito a seguir.

Observação: embora a fita de LED tenha que ser alimentada com uma tensão de 5V, e a BlackBoard UNO possua saída nesta tensão, não é recomendado alimentá-la diretamente pelas saídas da placa, pois o consumo de corrente da extensão da fita é maior do que a placa é capaz de fornecer. Portanto o uso de uma fonte externa é recomendado.

Biblioteca

Para fazer o controle da fita de LED RGB Endereçável com a BlackBoard UNO, é necessário instalar uma biblioteca. Para isso, acesse o "Gerenciador de Bibliotecas" pelo caminho da imagem a seguir. Se preferir, basta pressionar as teclas "Ctrl + Shift + l" no seu teclado.

Com o "Gerenciador de Bibliotecas" aberto, digite "adafruit neopixel" na barra de pesquisa, e então pressione "Enter" para pesquisar. Assim que as opções forem listadas, instale a terceira biblioteca listada, como mostrado na próxima imagem.

biblioteca-encontrada — Biblioteca Encontrada

Após alguns instantes a biblioteca estará instalada, e estará escrito logo abaixo do nome da biblioteca, como na imagem abaixo.

Código

Com a biblioteca instalada e o circuito montado, carregue o código a seguir para a sua BlackBoard UNO. Caso nunca tenha utilizado a BlackBoard UNO antes, siga os passos do tutorial Instalando o Driver da BlackBoard, para que ela seja reconhecida corretamente, e lembre-se de selecionar corretamente o modelo de placa como "Arduino Uno" nas Ferramentas da IDE.

/*******************************************************************************
* Controlando a Fita de LED RGB Enderecavel com a BlackBoard UNO (v1.0)
* 
* Codigo de exibicao basico da fita de LEDs RGB Enderecavel WS2812B controlada
* pela BlackBoard UNO. O codigo ira realizar um aparecimento gradual das tres 
* cores R, G e B, e entao ficar variando a cor dos LEDs aleatoreamente.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (12/08/2022).
* 
* 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/>).
*******************************************************************************/

// Adicao da biblioteca de controle da fita de LED
#include <Adafruit_NeoPixel.h>

// Variavel que armazena o numero de LEDs que serao controlados
const int NUMERO_LEDS = 60; // Padrao para 1 metro
// Caso queira controlar mais do que 1 metro, altere o valor acima com o numero de LEDs correspondente a metragem

// Variavel que armazena o pino de controle da fita de LEDs
const int PINO_FITA_LEDS = 2;

// Objeto de controle da fita de LEDs
Adafruit_NeoPixel fita_LED(NUMERO_LEDS, PINO_FITA_LEDS);

void setup() {

  fita_LED.begin(); // Inicializacao da fita de LEDs

  // Inicia com os LEDs da fita apagados
  fita_LED.clear();
  fita_LED.show();
  delay(100);

  // Realiza um aparecimento gradual acendendo da cor vermelha em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, i, 0, 0); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }

  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

  // Realiza um aparecimento gradual acendendo da cor verde em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, 0, i, 0); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }

  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

  // Realiza um aparecimento gradual acendendo da cor azul em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, 0, 0, i); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }
  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

}

void loop() {

  // Gera valores RGB aleatorios
  randomSeed(analogRead(A0));
  int vermelho = random(0, 255);
  int verde = random(0, 255);
  int azul = random(0, 255);

  // Acende os LEDs com os valores RGB gerados
  for (int l = 0; l < NUMERO_LEDS; l++) {
    fita_LED.setPixelColor(l, vermelho, verde, azul); // Atualiza a cor dos LEDs com os valores coletados
  }
  fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
  delay(500); // Espera para nova cor
  
}

Entendendo o Código

O código se inicia com a inclusão da biblioteca "Adafruit_NeoPixel" que nos ajudará a fazer o controle da fita de LED RGB Endereçável WS2812B. Em seguida, declaramos as variáveis PINO_FITA_LED e NUMERO_LEDS, que armazenam, o pino de controle da fita de LED, e o número de LEDs na extensão da fita. Na RoboCore vendemos esta fita de LED por metro, e em um metro de fita estão presentes 60 LEDs. Portanto, se quiser controlar uma metragem maior desta fita de LED, atualize o número salvo nesta variável, para que todos os LEDs sejam acionados. Para finalizar as declarações globais do código, criamos o objeto fita_LED como a instância Adafruit_NeoPixel para a biblioteca, levando em conta o número de LEDs e o pino de controle salvo nas variáveis anteriores.

// Adicao da biblioteca de controle da fita de LED
#include <Adafruit_NeoPixel.h>

// Variavel que armazena o numero de LEDs que serao controlados
const int NUMERO_LEDS = 60; // Padrao para 1 metro
// Caso queira controlar mais do que 1 metro, altere o valor acima com o numero de LEDs correspondente a metragem

// Variavel que armazena o pino de controle da fita de LEDs
const int PINO_FITA_LEDS = 2;

// Objeto de controle da fita de LEDs
Adafruit_NeoPixel fita_LED(NUMERO_LEDS, PINO_FITA_LEDS);

Já nas configurações do código (função void setup()), o controle da fita de LED é iniciado através do comando fita_LED.begin(). Em seguida, os dados de controle salvos na memória dos LEDs apagados pelo comando fita_LED.clear(), e então os LEDs são mantidos apagados através do comando fita_LED.show() que exibe os últimos dados de controle salvos nos componentes. Neste momento é importante ressaltar que, esses comandos só serão realizados pelos LEDs que estiverem dentro da extensão configurada na variável NUMERO_LEDS, ou seja, se a sua fita de LEDs tiver 70 LEDs ao total, apenas 60 executarão as demais funções do código.

Após garantir que os LEDs da fita serão iniciados apagados, iniciamos as animações de controle conjunto, que inicialmente realizarão um aparecimento gradual de cada cor RGB. Para realizar essa animação são utilizados dois laços "for". O primeiro deles varia o valor da variável i que será o controle de cada cor RGB do seu valor mínimo (0) até o seu valor máximo (255), incrementando esse valor de controle em uma unidade a cada repetição. Dentro deste laço "for" há outro laço "for", que varia o valor da variável j entre 0 e o número de LEDs salvo na variável NUMERO_LEDS, incrementando o seu valor em uma unidade. Isso garante que todos os LEDs da extensão da fita de LED receberão todos os valores de controle das cores RGB. Os dados de controle dos LEDs RGB são enviados para todos os componentes da extensão da fita através do comando fita_LED.setPixelColor(j , i, 0, 0) (cor vermelha como exemplo), lembrando que a variável j é o LED que receberá o dado, enquanto a variável i é o valor da cor RGB de controle. Após salvar os dados de controle em todos os LEDs, os LEDs são acionados com o comando fita_LED.show(). Os LEDs são mantidos ligados nesta cor por um breve período, e então os dados de controle são apagados, juntamente com os LEDs.

Esse processo é repetido para as cores verde e azul, encerrando a configuração de código.

void setup() {

  fita_LED.begin(); // Inicializacao da fita de LEDs

  // Inicia com os LEDs da fita apagados
  fita_LED.clear();
  fita_LED.show();
  delay(100);

  // Realiza um aparecimento gradual acendendo da cor vermelha em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, i, 0, 0); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }

  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

  // Realiza um aparecimento gradual acendendo da cor verde em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, 0, i, 0); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }

  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

  // Realiza um aparecimento gradual acendendo da cor azul em todos os LEDs
  for (int i = 0; i < 256; i ++) { // Varia a cor do seu minimo (0) ate o seu maximo (255)
    for (int j = 0; j < NUMERO_LEDS; j++) {
      fita_LED.setPixelColor(j, 0, 0, i); // Atualiza a cor de todos os LEDs da fita com o ultimo valor
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
    delay(5);
  }
  delay(100); // Aguarda 500 ms para nova cor

  // Apaga os LEDs para nova cor
  fita_LED.clear();
  fita_LED.show();

}

Já na repetição do código, inicializamos o gerador de números aleatórios tomando como base a leitura analógica "vazia" do pino A0 da BlackBoard UNO pelo comando randomSeed(analogRead(A0)). Feito isso, criamos variáveis, sendo elas vermelho, verde e azul, cada uma recebendo um valor aleatório diferente entre 0 e 255. Com essas variáveis atualizadas com os novos valores, enviamos os dados de controle com esses valores aleatórios para todos os LEDs da extensão da fita, e então exibimos a cor gerada.

void loop() {

  // Gera valores RGB aleatorios
  randomSeed(analogRead(A0));
  int vermelho = random(0, 255);
  int verde = random(0, 255);
  int azul = random(0, 255);

  // Acende os LEDs com os valores RGB gerados
  for (int l = 0; l < NUMERO_LEDS; l++) {
    fita_LED.setPixelColor(l, vermelho, verde, azul); // Atualiza a cor dos LEDs com os valores coletados
  }
  fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
  delay(500); // Espera para nova cor
  
}

O Que Deve Acontecer

Assim que o código for carregado para a sua BlackBoard UNO com o circuito do projeto montado, você verá uma crescente no brilho das cores RGB, e logo em seguida, você verá diversas cores aleatórias sendo exibidas pela fita de LED, como no GIF abaixo.

Resultado Final

Controle Individual dos LEDs

Já neste projeto veremos como realizar o controle individual de cada LED da extensão da fita, e aproveitar a grande vantagem do LED RGB endereçável. Com o sensor de som seremos capazes de monitorar os sons ambientes e criar um bargraph sonoro, que você poderá utilizar de qualquer saída de áudio que quiser.

Circuito

Para este projeto, monte o circuito a seguir.

Código

Com o circuito montado, carregue o código a seguir para a sua BlackBoard UNO.

/*******************************************************************************
* Controlando a Fita de LED RGB Enderecavel com a BlackBoard UNO (v1.0)
* 
* Codigo de controle individual dos LEDs da extensao da fita. Neste codigo o
* criamos um bargraph sonoro para representar visualmente o volume ambiente
* "ouvido" pelo sensor de som.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (12/08/2022).
* 
* 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/>).
*******************************************************************************/

// Adicao da biblioteca de controle da fita de LED
#include <Adafruit_NeoPixel.h>

// Variavel que armazena o numero de LEDs que serao controlados
const int NUMERO_LEDS = 60; // Padrao para 1 metro
// Caso queira controlar mais do que 1 metro, altere o valor acima com o numero de LEDs correspondente a metragem

// Variavel que armazena o pino de controle da fita de LEDs
const int PINO_FITA_LEDS = 2;

// Objeto de controle da fita de LEDs
Adafruit_NeoPixel fita_LED(NUMERO_LEDS, PINO_FITA_LEDS);

// Variavel que armazena o pino conectado ao sensor de som
const int PINO_SENSOR_SOM = A0;

// Variaveis para o controle de posicao dos LEDs
int leitura_analogica;
int posicao = 0;
int posicao_antes = posicao;

void setup() {

  fita_LED.begin(); // Inicializacao da fita de LEDs

  // Inicia com os LEDs da fita apagados
  fita_LED.clear();
  fita_LED.show();

  // Configura o pino conectado ao sensor de som como uma entrada
  pinMode(PINO_SENSOR_SOM, INPUT);

}

void loop() {

  // Realiza uma variação tipo "rainbow" em todos os LEDs
  leitura_analogica = analogRead(PINO_SENSOR_SOM);
  posicao = map(leitura_analogica, 525, 1023, 0, NUMERO_LEDS);

  // Verifica se a posicao convertida e diferente da ultima posicao salva
  if (posicao != posicao_antes) {
    // Apaga os LEDs que estavam acesos, e acende os novos LEDs de acordo com a posicao convertida
    fita_LED.clear();
    for (int i = 0; i < posicao; i++){
      if(i > NUMERO_LEDS * 0.95){
        fita_LED.setPixelColor(i, 120, 20, 180);
      }
      else if(i > NUMERO_LEDS * 0.85){
        fita_LED.setPixelColor(i, 255, 0, 0);
      }
      else if(i > NUMERO_LEDS * 0.70){
        fita_LED.setPixelColor(i, 255, 190, 0);
      }
      else{
        fita_LED.setPixelColor(i, 0, 255, 0);
      }
    }
    fita_LED.show();
  }

  // Atualiza a ultima posicao
  posicao_antes = posicao;

}

Entendendo o Código

Neste projeto, além da inclusão da biblioteca, das variáveis do número de LEDs da extensão da fita e do pino de controle, e da criação do objeto fita_LED, também temos a criação de algumas variáveis adicionais. A variável PINO_SENSOR_SOM armazena o pino da BlackBoard UNO conectado ao sensor de som no circuito. Para finalizar as declarações globais do código, temos a declaração das variáveis leitura_analogica, que receberá as leituras analógicas do sensor de som; posicao que receberá a posição dentro da extensão da fita para o acionamento dos LEDs; e posicao_antes que receberá o último valor salvo na variável posicao para atualizarmos os LEDs apenas quando a posição for alterada, ou seja, quando o sensor captar um novo som no ambiente.

// Variavel que armazena o pino conectado ao sensor de som
const int PINO_SENSOR_SOM = A0;

// Variaveis para o controle de posicao dos LEDs
int leitura_analogica;
int posicao = 0;
int posicao_antes = posicao;

Já nas configurações do código, apenas configuramos o pino conectado ao sensor de som como uma entrada, e iniciamos o controle da fita de LED com todos os LEDs apagados.

void setup() {

  fita_LED.begin(); // Inicializacao da fita de LEDs

  // Inicia com os LEDs da fita apagados
  fita_LED.clear();
  fita_LED.show();

  // Configura o pino conectado ao sensor de som como uma entrada
  pinMode(PINO_SENSOR_SOM, INPUT);

}

Na repetição do código mantemos a BlackBoard UNO constantemente realizando a leitura analógica do pino conectado ao sensor de som, e armazenando a leitura na variável leitura_analogica. Feito isso, através do comando posicao = map(leitura_analogica, 525, 1023, 0, NUMERO_LEDS) convertemos os picos da leitura analógica do sensor de som em um número entre 0 e o número de LEDs na extensão da fita de LED, que basicamente representa a posição final dos LEDs que serão acesos na fita. Em seguida, verificamos pela condição if (posicao != posicao_antes) se a leitura recém convertida é diferente da última posição lida. Se for, apagamos os dados de controle de todos os LEDs e então acionamos todos os LEDs até a posição correspondente ao valor convertido, de acordo com o nível sonoro coletado. Se o número de LEDs que serão acionados for maior do que 95% do número de LEDs da extensão da fita, os LEDs finais assumirão a cor roxa. Caso o número de LEDs que serão acionados for maior do que 85%, os LEDs entre esta faixa e a faixa final assumirão a cor vermelha. LEDs entre 70 e 85% assumirão a cor laranja. Já o restante dos LEDs assumirão a cor verde. Isso é feito para indicar o nível do volume "ouvido" pelo sensor de som. Após atualização dos LEDs, a variável posicao_antes é atualizada com o último valor da variável posicao.

void loop() {

  // Realiza uma variação tipo "rainbow" em todos os LEDs
  leitura_analogica = analogRead(PINO_SENSOR_SOM);
  posicao = map(leitura_analogica, 525, 1023, 0, NUMERO_LEDS);

  // Verifica se a posicao convertida e diferente da ultima posicao salva
  if (posicao != posicao_antes) {
    // Apaga os LEDs que estavam acesos, e acende os novos LEDs de acordo com a posicao convertida
    fita_LED.clear();
    for (int i = 0; i < posicao; i++){
      if(i > NUMERO_LEDS * 0.95){
        fita_LED.setPixelColor(i, 120, 20, 180);
      }
      else if(i > NUMERO_LEDS * 0.85){
        fita_LED.setPixelColor(i, 255, 0, 0);
      }
      else if(i > NUMERO_LEDS * 0.70){
        fita_LED.setPixelColor(i, 255, 190, 0);
      }
      else{
        fita_LED.setPixelColor(i, 0, 255, 0);
      }
    }
    fita_LED.show();
  }

  // Atualiza a ultima posicao
  posicao_antes = posicao;

}

O Que Deve Acontecer

Após carregar o código para a placa, faça sons próximo ao sensor, e observe que o bargraph começará a variar de acordo com o volume do som captado, como no GIF a seguir.

Resultado Final

Indo Além

Como aprendemos como criar uma interface áudio visual utilizando o sensor som e a fita de LED RGB endereçável WS2812B, uma aplicação possível seria a de animações de imersão reativas para filmes ou jogos. Por exemplo, você pode fixar a fita de LEDs atrás da sua televisão, e então realizar uma animação de cores vermelhas, ou laranjas, para simular como se uma explosão tivesse passado para o ambiente.

Conclusão

Neste tutorial vimos como controlar os LEDs RGB da fita de LED RGB Endereçável WS2812B, tanto em conjunto, quanto individualmente em projetos simples.