Parede de 500 LEDs com ESP32: 16 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Olá a todos! Ao final deste tutorial, você saberá como criar sua própria parede de LED.

Este tutorial é baseado em um programa de verão oferecido na Sacred Heart University.

Divirta-se!

Suprimentos

Suprimentos listados abaixo.

Etapa 1: suprimentos

Vamos começar reunindo tudo o que precisamos para completar nosso Led Wall:

(Links foram criados em 2019-07-10)

Software Arduino IDE

ESP32 Micro Controller

LED Pixel Light

Fonte de energia

Cabo de alimentação

Ferramenta para descascar fio

Cabos de jumper de tábua de pão

Fio elétrico

Etapa 2: determinar a fonte de alimentação certa para seu LedWall

Existe uma maneira matemática simples de descobrir qual fonte de alimentação é a melhor para o seu uso.

Estamos usando a lei de potência de Ohm: P = IxV (Potência = Intensidade x Tensão)

A tensão é determinada por nossos leds: neste caso 5V.

A intensidade depende do hardware, um único Led consome 30mA.

Cada tira de 50 Leds, portanto, consome 50 x 30mA = 1250mA = 1,25A.

Nossa parede de 500 Led consome 10 vezes mais (10 tiras): 12,5A.

O uso de energia é, então, 5 V x 12,5 A = 62,5 W para os Leds.

É claro que, além dos Leds, você precisa levar em conta o ESP e todos os outros itens do seu circuito.

Temos uma fonte de alimentação 60A, temos muito mais do que precisamos.

Etapa 3: o cabo de alimentação

Nossa fonte de alimentação vem com conectores de fio. Precisamos adaptar um cabo de alimentação para conectá-lo a um plugue de 110V.

- Corte o conector fêmea do cabo de alimentação. Manteremos a parte masculina, também conhecida como NEMA 5-15P.

- Desencape o cabo para ter cerca de 3 mm de cobre visível em todos os fios.

Aqui está um rápido tutorial em vídeo sobre como descascar fios:

Etapa 4: Fiação da fonte de alimentação

Agora estamos prontos para conectar nossa fonte de alimentação!

Sempre desligue a fonte de alimentação quando estiver trabalhando nela.

Fiação

• O fio preto (fase) se conecta ao pino 'L' da fonte de alimentação
• O fio branco (neutro) se conecta ao pino 'N' da fonte de alimentação
• O fio verde se conecta ao pino de 'aterramento' da fonte de alimentação

(Se os fios internos do seu cabo de alimentação não forem da mesma cor que os nossos, esteja seguro e procure os esquemas online.)

Testando

Conecte o cabo de alimentação do computador a qualquer tomada elétrica. O LED verde na fonte de alimentação deve acender.

Etapa 5: Ligando o ESP32S

Olhando para o seu ESP, deve haver rótulos ao lado de cada pino. Se não estiver rotulado, você pode procurar a 'pinagem' do seu ESP individual online.

Usando um jumper de placa de ensaio macho para fêmea ou um fio elétrico, conecte:

• O pino ESP32S '5V' no '+ V' da fonte de alimentação (laranja na foto acima)
• O pino ESP32S 'GND' na seção '-V' da fonte de alimentação (preto na foto acima)

(Em alguns ESPs, o pino '5V' é rotulado como 'VCC', ambos significam a mesma coisa.)

Observe que seu ESP pode ter uma 'pinagem' diferente da que estamos usando. Como tal, você pode conectar seus fios em locais diferentes dos da imagem acima. Contanto que esteja conectando aos pinos corretos (5V e GND), a localização física na placa não importa.

TestingPlug em sua fonte de alimentação novamente, e se o ESP tiver um indicador LED (a maioria tem), ele acenderá para indicar que a energia está sendo enviada para o ESP. Parabéns!

Etapa 6: Alimentação das fitas de luz LED

Usando fios elétricos:

- Conecte o fio vermelho da Faixa de Luz LED a V + na fonte de alimentação.

- Conecte o fio azul do LED Light Strip ao V- da fonte de alimentação.

Etapa 7: Conectando o ESP32 às fitas de luz de LED

Nosso ESP32 instrui o driver WS2811 conectado a cada led sobre a cor e o brilho necessários. Para isso, nosso ESP32 precisa de um cabo de "dados" para as tiras.

As tiras de Leds vêm com um conector de 3 fios:

- Vermelho: Power- Blue: Neutro- White: Data

Vamos conectar o cabo de tira Led Branco a um pino digital no ESP. Lembre-se do número PIN selecionado, pois precisaremos selecioná-lo no código mais tarde. Conectamos o nosso ao pino 13.

Etapa 8: Preparando o Computador: Driver C2102

Agora que nosso hardware está conectado, queremos fazer upload de nosso primeiro código para testá-lo. Por padrão, o Windows ou MacOs não podem se comunicar com nosso ESP32. Para isso, precisamos baixar um "driver" para o chip de comunicação ESP USB: o C2102.

Este driver deve ser baixado e instalado:

- Windows 10: https://www.silabs.com/documents/public/software/C…- Windows 7/8 / 8.1: https://www.silabs.com/documents/public/software/C…- Mac:

(Links em 2019-07-10)

Etapa 9: Software Arduino - Adicionando suporte ESP32 - Etapa 1

Antes de podermos usar nosso ESP32 com o software Arduino, precisamos ter certeza de que ele é reconhecido. Por padrão, o software Arduino não pode compilar o código para nosso ESP32, vamos consertar isso:

Etapa 1: Adicionando placas ao gerente

1 - Clique no Arduino na opção Arquivo >> Preferências

2- No campo "URLs adicionais do gerenciador de placas", copie o seguinte link:

Etapa 10: Software Arduino - Adicionando suporte ESP32 - Etapa 2

Agora que o software Arduino "conhece" mais placas, vamos instalar nosso suporte ESP32

Etapa 2: instalação do suporte ESP32

1 - No menu superior, selecione: Ferramentas >> Placa >> Gerenciador de placas

2 - Uma janela aparecerá. Use a caixa de pesquisa, localizada no canto superior direito, para encontrar "ESP32".

3 - Localize o feito por espressif. Instale-o. (Veja a imagem)

Etapa 11: Software Arduino - Adicionando suporte ESP32 - Etapa 3

Agora que o software Arduino pode se comunicar com nosso ESP32, vamos conectá-lo ao computador e verificar se tudo funciona.

1 - Vamos nos certificar de que trabalhamos na plataforma ESP32:

Clique em Ferramentas >> Placa >> Módulo ESP32 Dev

1- Vamos nos certificar de que o software Arduino sabe como se comunicar com nosso ESP:

Clique em Ferramentas >> Porta e selecione aquele que aparece ao conectar este cabo.

Importante:

Se você tiver algum problema para fazer upload do código para o ESP, verifique esses dois menus primeiro. Se a porta não for selecionada com uma marca de seleção, o software Arduino não se comunicará com ela.

Etapa 12: Adicionando Bibliotecas ao IDE Arduino

Agora vamos adicionar uma biblioteca que nos permitirá testar nosso Led Wall!

1- Clique em Ferramentas >> Gerenciar Bibliotecas.

2- No canto superior direito, procure NeoPixelBus. Localize "NeoPixelBus by Makuna", instale-o (veja a imagem)

Possíveis outras bibliotecas interessantes: (não é necessário para este tutorial)

- NeoMatrix

- FastLed

- Artnet

- GFX

Etapa 13: Primeiro código: teste de cadeia

Nosso primeiro código é um exemplo da Biblioteca.

Você pode copiar / colar o código abaixo ou clicar em:

Arquivo >> Exemplos >> Adafruit NeoPixelBus >> Strandtest

Certifique-se de mudar seu LED_PIN para aquele que você usou para conectar fisicamente seus leds. Usamos 13 ao longo deste tutorial.

Além disso, certifique-se de adaptar o tamanho do fio com a variável LED_COUNT.

// Um programa básico de LED Striptest para o dia-a-dia.

# include # ifdef _AVR_ #include // Requerido para 16 MHz Adafruit Trinket #endif // Qual pino no Arduino está conectado aos NeoPixels? #define LED_PIN 13 // Quantos NeoPixels estão anexados ao Arduino? #define LED_COUNT 500 // Declare nosso objeto de tira NeoPixel: tira Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Argumento 1 = Número de pixels na faixa NeoPixel // Argumento 2 = número do pino Arduino (a maioria são válidos) // Argumento 3 = Sinalizadores de tipo de pixel, somados conforme necessário: // NEO_KHZ800 800 KHz bitstream (a maioria dos produtos NeoPixel com WS2812 LEDs) // NEO_KHZ400 400 KHz (clássico 'v1' (não v2) pixels FLORA, drivers WS2811) // NEO_GRB Pixels são conectados para GRB bitstream (a maioria dos produtos NeoPixel) // NEO_RGB Pixels são conectados para bitstream (v1 FLORA pixels, não v2) // NEO_RGBW Pixels são conectados para bitstream RGBW (produtos NeoPixel RGBW) // função setup () - executa uma vez na inicialização -------------------- ------------ void setup () {// Estas linhas são especificamente para suportar o Adafruit Trinket 5V 16 MHz. // Qualquer outra placa, você pode remover esta parte (mas não há problema em deixá-la): #if defined (_ AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // FIM do código específico do Trinket. strip.begin (); // INITIALIZE NeoPixel strip object (REQUIRED) strip.show (); // DESLIGA todos os pixels o mais rápido possível strip.setBrightness (50); // Defina BRIGHTNESS para cerca de 1/5 (max = 255)} // função loop () - executa repetidamente enquanto a placa estiver ligada --------------- void loop () {// Preencher ao longo do comprimento da faixa em várias cores… colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Green colorWipe (strip. Color (0, 0, 255), 50); // Azul // Faz um efeito de teatro em várias cores… theaterChase (strip. Color (127, 127, 127), 50); // Branco, meio brilho theaterChase (strip. Color (127, 0, 0), 50); // Vermelho, meio brilho theaterChase (strip. Color (0, 0, 127), 50); // Azul, arco-íris de meio brilho (10); // Fluxo do ciclo do arco-íris ao longo de toda a faixa theaterChaseRainbow (50); // Variante do teatroChase aprimorada com arco-íris} // Algumas funções próprias para criar efeitos animados ----------------- // Preencher a faixa de pixels um após o outro com uma cor. A faixa NÃO é apagada // primeiro; qualquer coisa lá será coberta pixel por pixel. Passe em color // (como um único valor 'empacotado' de 32 bits, que você pode obter chamando // strip. Color (red, green, blue) conforme mostrado na função loop () acima), // e um tempo de atraso (em milissegundos) entre pixels. void colorWipe (uint32_t color, int wait) {for (int i = 0; i strip.setPixelColor (i, color); // Definir a cor do pixel (na RAM) strip.show (); // Atualizar tira para corresponder ao atraso (wait); // Faça uma pausa por um momento}} // Luzes de perseguição estilo letreiro de teatro. Passe em uma cor (valor de 32 bits, // a la strip. Color (r, g, b) como mencionado acima), e um tempo de atraso (em ms) // entre os quadros. void theaterChase (uint32_t color, int wait) {for (int a = 0; a <10; a ++) {// Repete 10 vezes… for (int b = 0; b <3; b ++) {// 'b' conta de 0 a 2… strip.clear (); // Define todos os pixels na RAM para 0 (desligado) // 'c' conta de 'b' até o final de strip em etapas de 3… for (int c = b; c strip.setPixelColor (c, color); // Definir pixel 'c' para o valor de 'color'} strip.show (); // Atualizar faixa com novo atraso de conteúdo (esperar); // Pausa por um momento}}} // Ciclo de arco-íris ao longo de toda a faixa. Tempo de atraso de passagem (em ms) entre os quadros. arco-íris vazio (espera int) {// Matiz do primeiro pixel executa 5 loops completos através do roda de cores. // A roda de cores tem um intervalo de 65536, mas é OK, se passarmos, // conte apenas de 0 a 5 * 65536. Adicionar 256 a firstPixelHue cada vez // significa que faremos 5 * 65536/256 = 1280 passagens por este loop externo: for (long firstPixelHue = 0; firstPixelHue <5 * 65536; firstPixelHue + = 256) {for (int i = 0; I // Desloca o matiz do pixel em uma quantidade para fazer uma revolução completa no // círculo de cores (intervalo de 65536) ao longo do comprimento da faixa // (strip.numPixels () etapas): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels ()); // strip. ColorHSV () pode receber 1 ou 3 argumentos: um matiz (0 a 65535) ou // opcionalmente adicionar saturação e valor (brilho) (cada 0 a 255). // Aqui, estamos usando apenas a variante de matiz de argumento único. O resultado // é passado por strip.gamma32 () para fornecer cores 'mais verdadeiras' // antes de atribuir a cada pixel: strip.setPixelColor (i, strip.gamma32 (strip. ColorHSV (pixelHue)));} strip.show (); // Atualizar a faixa com atraso de novos conteúdos (esperar); // Pausar por um momento}} // Letreiro de teatro aprimorado com arco-íris. Tempo de atraso de passagem (em ms) entre os quadros. void theaterChaseRainbow (int wait) {i nt firstPixelHue = 0; // O primeiro pixel começa em vermelho (matiz 0) para (int a = 0; a <30; a ++) {// Repete 30 vezes… para (int b = 0; b RGB strip.setPixelColor (c, color); / / Definir pixel 'c' para o valor de 'cor'} strip.show (); // Atualizar faixa com novo atraso de conteúdo (esperar); // Pausar por um momento firstPixelHue + = 65536/90; // Um ciclo de roda de cores mais de 90 quadros}}}

Etapa 14: Código de Amostra SHU

Nosso código liga todos os Leds um por um para garantir que funcionem:

// Este exemplo irá alternar entre mostrar 500 pixels como vermelho

#includeconst uint16_t PixelCount = 500; // este exemplo assume 4 pixels, torná-lo menor causará uma falha const uint8_t PixelPin = 13; // certifique-se de definir isso para o pino correto, ignorado para Esp8266

#define colorSaturation 128 // pixels de três elementos, em ordem e velocidades diferentes

Tira NeoPixelBus (PixelCount, PixelPin);

// Tira NeoPixelBus (PixelCount, PixelPin); RgbColor vermelho (0, colorSaturation, 0); RgbColor verde (colorSaturation, 0, 0); RgbColor blue (0, 0, colorSaturation); RgbColor branco (colorSaturation); RgbColor preto (0); HslColor hslRed (vermelho); HslColor hslGreen (verde); HslColor hslBlue (azul); HslColor hslWhite (branco); HslColor hslBlack (preto); void setup () {Serial.begin (115200) while (! Serial); // aguarde a conexão serial Serial.println (); Serial.println ("Inicializando …"); Serial.flush (); // isso redefine todos os neopixels para um estado off strip. Begin (); strip. Show (); Serial.println (); Serial.println ("Executando…"); } loop vazio () {atraso (100); Serial.println ("Cores R, G, B, W …"); for (int i = 0; i <= 499; i ++) {// definir as cores, // se não corresponderem na ordem, você precisará usar o recurso NeoGrbFeature strip. SetPixelColor (i, red); strip. Show (); atraso (100); strip. SetPixelColor (i, hslRed); strip. Show (); atraso (100); }}

Etapa 15: upload do código para o ESP32

Importante:

Para poder fazer upload do código para qualquer microcontrolador, ele precisa estar no modo de programação. A maioria faz isso automaticamente e tudo o que você precisa fazer é clicar em upload no software.

Nosso ESP32 exige que você segure o botão de programação enquanto o código está sendo enviado. Você também precisa redefini-lo depois que o código é carregado, pressionando uma vez o botão de redefinição.

O botão de programação do nosso ESP32 está localizado à esquerda e o botão de reinicialização à direita. Consulte o manual se tiver outro microcontrolador.

Etapa 16: Citações

Este instrutível foi feito com a ajuda dos seguintes tutoriais:

randomnerdtutorials.com/installing-the-esp…

Usado para instalar o ESP32 no Arduino IDE.

Autores:

Nathaniel BaroneGabriel Castro

Editor:

Cedric Bleimling