Rolando Textos em Painéis RGB 32×9

Publicado em por
Tempo de leitura: 6 minutes

Como discutimos no último post, hoje continuamos explorando as possibilidades de painéis 32×8 RGB com controle independente, que nos permitem criar aplicações muito interessantes. No caso de hoje, veremos como obter letreiros publicitários de texto com rolagem (um clássico da publicidade atraente).

Objetivos

  • Continuamos brincando com os painéis 8×32 de leds Neopixel.
  • Faremos um programa de Rolagem de Texto, movendo o texto lateralmente.
  • Veremos como cascatear vários painéis para aumentar o tamanho da nossa tela.

 

Material Necessário

  • Arduino Uno ou (genérico)
  • Painel LED RGB 32×8 (Flexível)
  • Fios

 

Painéis de led RGB Flexíveis

Na sessão anterior apresentamos os painéis RGB Neopixel de 8×32 pontos. Vimos como instalar algumas bibliotecas necessárias para brincar com eles e fizemos um primeiro programa, para lançar as bases, no qual vimos como mover um ponto de luz ao longo da matriz.

Não é que fosse um programa de grande interesse, mas certamente precisávamos de um capítulo anterior para desvendar algumas ideias básicas sobre painéis RGB e iniciar o que era necessário para fazer um trabalho mais lucrativo (e interessante) com as pequenas luzes em questão.

Portanto, se você não leu o tutorial anterior, recomendo que comece por lá antes de entrar neste, porque para não nos repetirmos, vamos dar como certo, e seguindo o guia para preguiçosos, você nem precisará procurá-lo, deixo-lhe o link e aqui abaixo:

Introdução aos Neopixels

As meninas muitas vezes ficam surpresas que os homens são fascinados por luzes coloridas, e muitas vezes nos culpam por perder muito tempo brincando com eles, mas o que elas querem que eu diga a elas: eu as amo! E parece que há muitos tão presos quanto eu com isso, porque esses tipos de tutoriais costumam fazer muito sucesso.

Além disso, outro clássico dos displays é mostrar textos movendo-se lateralmente através de painéis luminosos, e já apresentamos sessões com matrizes de LEDs vermelhos 8×8 e 8×24, mas nesta ocasião, vamos aproveitar o fato de que os painéis Neopixel são de cores para melhorar a experiência.

Nesta sessão, veremos como exibir mensagens de rolagem em um painel RGB Neopixel e também veremos como unir vários painéis para obter um painel de letras mais longo e faremos um exemplo unindo dois, dando 8×64, mas eles podem ser combinados de diferentes formas pelo gosto de cada um.

Conexão de Painéis RGB Flexíveis com Arduino

O procedimento de conexão é bastante simples, mas vale a pena descrever as conexões do painel. Se você olhar o painel com os leds na frente, à direita está o conector Data Input onde injetaremos a saída do nosso Arduino. Na parte de trás do painel, esta entrada é rotulada como DIN (Data IN) enquanto o outro conector de 3 pinos é rotulado como DOUT (Data Out)

Se quisermos cascatear vários painéis, basta conectar a saída do primeiro à entrada do segundo e assim sucessivamente. Se quisermos cascatear vários painéis, basta conectar a saída do primeiro à entrada do segundo e assim sucessivamente.

Por fim, há a questão da alimentação. Cada um desses painéis pode ser alimentado pelo conector de entrada que possui 3 pinos: DIN, 5V e GND, mas lembre-se que cada um dos LEDs pode consumir entre 50 e 60 mA se você colocar um branco intenso. Como temos 8 x 32 LEDs no painel, o consumo máximo pode ser:

8 x 32 x 60 = 15.360 mA

São 15 amperes, o que certamente não está ao alcance do seu Arduino alimentado por USB. Na prática, o consumo habitual estará muito longe destes consumos, mas é preciso ter cuidado e calcular o consumo que vai produzir. Em condições normais e se você usar cores simples com meia intensidade, o consumo por painel pode ficar em torno de um ampere ou menos por painel, mas se você colocar 5… bem, é isso.

É por isso que o painel tem um conector específico, no centro, com um par de cabos vermelho e preto, para usar uma fonte externa que evita o problema, mas vocês vão ver que vou usar a fonte direta do Arduino para esses exemplos simples que veremos a seguir.

Agora conectar nosso Arduino é trivial:

Vamos com o programa

 

Instalando algumas Bibliotecas

Primeiro vamos baixar algumas bibliotecas Adafruit para conduzir o painel. Precisamos de tudo isso:

Adafruit_GFX.h
Adafruit_NeoMatrix.h
Adafruit_NeoPixel.h

Para isso, vamos instalá-los a partir do gerenciador de bibliotecas.

Você obterá essa tela e, se escrever Neopixel acima, na área de pesquisa, terá que instalar dois dos que aparecem:

Repita a operação com os GFX se você não os tiver instalado (o que é improvável se você vier aqui com frequência) e pronto.

 

Primeiro Programa com Painel RGB

Como todos os displays Neopixel, esses painéis começam por numerar o primeiro LED RGB como 0 e aumentam a posição consecutivamente, para que possamos endereçar cada LED independentemente dos outros, o que é uma de suas grandes virtudes.

Não é tão claro como a numeração muda quando você pula de linha em coluna e às vezes o bom senso pode enganá-lo e, portanto, você deve fazer alguns testes com sua matriz para descobrir como as coisas estão indo. É por isso que vamos começar com um programa simples que ilumina consecutivamente os pixels para que você possa ver como eles são numerados.

Começamos com as inclusões da biblioteca:

#include <Adafruit_NeoPixel.h>

E agora algumas constantes do nosso programa

const int dinPin = 6;       // Pino Din para pino Arduino
const int numOfLeds = 256;  // número de leds

Os dados em indicam ao programa o pino do Arduino com o qual governamos o painel, e como este é 32 x 8 = 256 pixels, é o que indicamos na segunda constante. Agora temos que instanciar o objeto Neopixel da biblioteca:

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(numOfLeds, dinPin, NEO_GRB + NEO_KHZ800);

Os dois últimos parâmetros indicam o controlador de tudo e a velocidade de comunicação com o sistema

  • Dependendo do controlador e sua idade, a velocidade de comunicação pode ser menor (e no futuro, certamente maior)
  • Isso é importante, porque se a velocidade de comunicação for baixa, não permitirá que você faça cascata de muitos elementos para fazer telas maiores. Dobre a velocidade, dobre as chances.

Vamos para a configuração:

void setup()
{  
   pixels.begin(); // Inicializa a biblioteca NeoPixel
   pixels.setBrightness(60); // Valor de 0 a 100%
}

Sempre precisamos inicializar o objeto com begin() e depois definir o nível de brilho, neste caso 60% (100% é o máximo, claro) para que o consumo de corrente seja baixo.

Como eu quero fazer um programa de teste simples, vamos fazer um ponto de cor aleatória passar do primeiro pixel para o último e para isso começamos definindo a cor aleatória no loop com três parâmetros dentro da iteração que passa os pixels:

void loop()
{ 
   for(int i=0;i<numOfLeds;i++)
   { 
      int red = random(128);    //Valor de 0(led-off) a 255().
      int green = random(128);
      int blue = random(128);

Agora ligamos os pixels

pixels.setPixelColor(i, pixels.Color(red,green,blue));
pixels.show(); // Isso envia a cor do pixel atualizada para o hardware.
delay(50);   // Demora por um período de tempo para mudar o próximo led

A primeira linha define a cor (Random) do pixel a pintar, mas no Neopixel ativar um led não significa que ele acende, para isso você tem que executar a instrução pixel.show(), isso permite pintar rapidamente como quantos pixels você quiser… ANTES de mostrá-los!!!

Estas últimas instruções ligam os diferentes pixels em ordem e o atraso regula o tempo entre a iluminação de um ponto e o seguinte. E, finalmente, é conveniente desligar todos os pixels quando terminar.

for (int i=0; i<=numOfLeds; i++)
     pixels.setPixelColor(i, pixels.Color(0,0,0));
pixels.show(); //Isso envia a cor do pixel atualizada para o hardware.

Aqui deixo o programa para download

(Aqui)

 
Twittar
Compartilhar
Compartilhar
0 Compart.