Fita LED Endereçável com a Vespa

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 LEDs RGB endereçável WS2812B utilizando a Vespa, para o controle total dos LEDs da extensão da fita, e para o controle unitário de cada LED da extensão da fita.

Lista de Materiais

Lista completa de produtos

comprar

Vespa

R$ 189,90 no PIX

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

R$ 66,40 no PIX

Adaptador P4 Fêmea - Borne

R$ 3,70 no PIX

Fonte Chaveada 5V 5A

R$ 47,40 no PIX

Potenciômetro 10kΩ

R$ 2,18 no PIX

Protoboard 400 Pontos

R$ 6,55 no PIX

Cabo USB Micro B 80cm

R$ 9,40 no PIX

Jumpers Macho-Macho x40 Unidades

R$ 7,50 no PIX

Jumpers Macho-Fêmea x40 Unidades

R$ 7,50 no PIX

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.

A fita de LED RGB Endereçável WS2812B possui tensão operacional de 5V, portanto para o controle com a Vespa devemos utilizar os pinos de controle de servos (S1 - S4), pois eles possuem conversão de nível lógico de 3,3V do ESP32 para 5V (tensão operacional dos servos também).

Observação: embora a fita de LED tenha que ser alimentada com uma tensão de 5V, e a Vespa 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 Vespa, é 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 Vespa. Caso nunca tenha utilizado a Vespa antes, siga os passos do tutorial Primeiros Passos com a Vespa.

/*******************************************************************************
* Controlando a Fita de LED RGB Enderecavel com a Vespa (v1.0)
* 
* Codigo de exibicao basico da fita de LEDs RGB Enderecavel WS2812B controlada
* pela Vespa. 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 (11/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 = 26; // Pino S1 da Vespa

// 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 a 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); // Espera para nova cor

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

  // Realiza um aparecimento gradual acendendo a 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); // Espera 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); // Espera para nova cor

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

}

void loop() {

  // Gera valores RGB aleatorios
  randomSeed(analogRead(36));
  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 = 26; // Pino S1 da Vespa

// 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 serão apagados, e 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, eles 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 a 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); // Espera para nova cor

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

  // Realiza um aparecimento gradual acendendo a 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); // Espera 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); // Espera 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 VP (GPIO 36) da Vespa pelo comando randomSeed(analogRead(36)). 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(36));
  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 Vespa 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. Para isso, utilizaremos um potenciômetro para controlar a posição dos LEDs que serão acionados na extensão da fita de LED.

Circuito

Para este projeto, monte o circuito a seguir.

Código

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

/*******************************************************************************
* Controlando a Fita de LED RGB Enderecavel com a Vespa (v1.0)
* 
* Codigo de controle individual dos LEDs da extensao da fita. Neste codigo o
* potenciometro e responsavel por controlar a posicao dos LEDs RGB que serao
* acesos ao decorrer da extensao da fita.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (11/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 = 26; // Pino S1 da Vespa

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

// Variavel que armazena o pino conectado ao potenciometro
const int PINO_POT = 36;

// Variavel que armazena as cores RGB que sera usada para os LEDs
const int COR_LEDS[3] = {120, 20, 180}; // Altere para a cor que preferir

// Variaveis para o controle de posicao dos LEDs
int leitura_analogica; // Armazena a leitura analogica
int posicao; // Armazena a posicao de acionamento dos LEDs
int posicao_antes; // Armazena a ultima posicao lida

void setup() {

  pinMode(PINO_POT, INPUT); // Configura o pino conectado ao potenciometro como entrada

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

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

}

void loop() {

  // Realiza a leitura analogica do potenciometro
  leitura_analogica = analogRead(PINO_POT);

  // Converte a leitura analogica na posicao dos LEDs que serao acionados na extensao da fita
  posicao = map(leitura_analogica, 0, 4095, 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();
    if (posicao > 0) {
      fita_LED.setPixelColor(posicao - 1, COR_LEDS[0] / 2, COR_LEDS[1] / 2, COR_LEDS[2] / 2);
    }
    fita_LED.setPixelColor(posicao, COR_LEDS[0], COR_LEDS[1], COR_LEDS[2]);
    if (posicao < NUMERO_LEDS) {
      fita_LED.setPixelColor(posicao + 1, COR_LEDS[0] / 2, COR_LEDS[1] / 2, COR_LEDS[2] / 2);
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
  }

  // 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, 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_POT armazena o GPIO da Vespa conectado ao potenciômetro no circuito. O vetor COR_LEDS armazena os três valores RGB para a cor que será exibida nos LEDs (se preferir pode alterar esses valores para outra cor, inclusive existem algumas ferramentas online que auxiliam esta escolha, como esta, por exemplo). 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 potenciômetro; 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 eixo do potenciômetro for movido.

// Variavel que armazena o pino conectado ao potenciometro
const int PINO_POT = 36;

// Variavel que armazena as cores RGB que sera usada para os LEDs
const int COR_LEDS[3] = {120, 20, 180}; // Altere para a cor que preferir

// Variaveis para o controle de posicao dos LEDs
int leitura_analogica; // Armazena a leitura analogica
int posicao; // Armazena a posicao de acionamento dos LEDs
int posicao_antes; // Armazena a ultima posicao lida

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

void setup() {

  pinMode(PINO_POT, INPUT); // Configura o pino conectado ao potenciometro como entrada

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

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

}

Na repetição do código mantemos a Vespa constantemente realizando a leitura analógica do pino conectado ao potenciômetro, e armazenando a leitura na variável leitura_analogica. Feito isso, através do comando posicao = map(leitura_analogica, 0, 4095, 0, NUMERO_LEDS) convertemos a leitura analógica do potenciômetro e um número entre 0 e o número de LEDs na extensão da fita de LED, que basicamente representa a posição do LED que será aceso na fita. Em seguida, verificamos pela condição if (posicao != posicao_antes) se a recém convertida é diferente da última posição lida. Se for, apagamos os dados de controle de todos os LEDs e então acionamos o LED correspondente à posição convertida com os valores de cor RGB salvos no vetor COR_LEDS. Além disso, se a posição for maior do que zero, acendemos o LED anterior, e caso a posição seja menor do que número de LEDs da extensão da fita, também acionamos o LED seguinte, ambos com metade dos valores RGB salvos no vetor COR_LEDS.

void loop() {

  // Realiza a leitura analogica do potenciometro
  leitura_analogica = analogRead(PINO_POT);

  // Converte a leitura analogica na posicao dos LEDs que serao acionados na extensao da fita
  posicao = map(leitura_analogica, 0, 4095, 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();
    if (posicao > 0) {
      fita_LED.setPixelColor(posicao - 1, COR_LEDS[0] / 2, COR_LEDS[1] / 2, COR_LEDS[2] / 2);
    }
    fita_LED.setPixelColor(posicao, COR_LEDS[0], COR_LEDS[1], COR_LEDS[2]);
    if (posicao < NUMERO_LEDS) {
      fita_LED.setPixelColor(posicao + 1, COR_LEDS[0] / 2, COR_LEDS[1] / 2, COR_LEDS[2] / 2);
    }
    fita_LED.show(); // Exibe o ultimo controle salvo nos LEDs
  }

  // Atualiza a ultima posicao
  posicao_antes = posicao;

}

O Que Deve Acontecer

Após carregar o código para a sua Vespa, mova o eixo do potenciômetro do circuito, e veja que a posição dos LEDs que estão sendo acionados irá mudar conforme a movimentação, como no GIF abaixo.

Resultado Final

Indo Além

Como a Vespa possui conexão Wi-Fi, por que não criar uma aplicação Web para controlar remotamente qual a cor e quais LEDs da extensão da fita serão acesos? Isso é possível utilizando plataformas IoT prontas (como o Blynk, por exemplo), ou até mesmo criando sua própria plataforma ou página Web para realizar o controle da maneira que preferir.

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.