Guias · 11 min de leitura

Controle de fita LED RGB com Arduino: mistura de cores em 12 V com MOSFETs

Controle de fita LED RGB com Arduino: acione uma fita 5050 de 12 V com MOSFETs IRLZ44N, PWM em três canais, transições de cor, seleção de cor por potenciômetro e código para ESP32 e Pico.

Controlar uma fita LED RGB com Arduino significa acionar os canais vermelho, verde e azul de uma fita RGB 5050 não endereçável de 12 V com três sinais PWM separados para obter a cor que você quiser. Os pinos do Arduino não aguentam os amperes que a fita consome nem os 12 V, por isso cada canal ganha um MOSFET: o Arduino só envia um sinal de 5 V para o gate do MOSFET, e o MOSFET conduz a corrente de verdade. Assim, um microcontrolador pequeno consegue controlar metros de fita com segurança.

Neste guia você vai conhecer o interior de uma fita 5050, como escolher o MOSFET certo, a ligação e o cálculo da fonte de alimentação. Depois vai misturar cores com um Arduino Uno, criar uma transição de cor suave baseada em millis() e escolher matiz e brilho com potenciômetros, além de rodar o mesmo circuito com a unidade LEDC do ESP32 e o PWM em MicroPython do Raspberry Pi Pico. Você também vai ver como a fita difere da WS2812B e, no final, as soluções para os erros mais comuns.

O que é uma fita LED RGB e como ela funciona?

Em uma fita RGB não endereçável, cada encapsulamento SMD 5050 contém três chips de LED separados: vermelho, verde e azul. A fita é formada por segmentos de 12 V ligados em paralelo, cada um com três LEDs e um resistor limitador de corrente por cor; a tensão direta total dos três LEDs em série fica em torno de 6–9 V, dependendo da cor, e o resistor absorve o restante. A fita tem quatro conexões: um positivo comum (+12V) mais R, G e B. Ou seja, a fita é de ânodo comum: para acender uma cor, você puxa a linha dessa cor para o GND. A fita inteira mostra uma única cor por vez; não dá para acender LEDs individualmente em cores diferentes. Você define a cor pelo ciclo de trabalho do PWM de cada canal: vermelho e verde no máximo dão amarelo, e os três no máximo dão uma luz quase branca.

CaracterísticaFita de 30 LED/mFita de 60 LED/m
Tipo de LED5050 SMD (5,0 × 5,0 mm, 3 chips)5050 SMD (5,0 × 5,0 mm, 3 chips)
Tensão de operação12 V DC12 V DC
Potência (branco total)Cerca de 7,2 W/mCerca de 14,4 W/m
Corrente (branco total)Cerca de 0,6 A/mCerca de 1,2 A/m
Corrente por canalCerca de 0,2 A/mCerca de 0,4 A/m
Intervalo de corteA cada 3 LEDs (10 cm)A cada 3 LEDs (5 cm)
Conexões+12V, R, G, B+12V, R, G, B

Fita RGB ou WS2812B: qual é a diferença?

As duas fitas produzem luz RGB, mas são controladas de formas completamente diferentes. Uma fita não endereçável é como uma lâmpada: você define a cor da fita inteira mudando o brilho de três canais. Em uma fita WS2812B NeoPixel, cada LED tem um pequeno chip driver interno, e você pode enviar uma cor diferente para cada LED por uma única linha de dados. A tabela abaixo ajuda você a decidir qual escolher:

CaracterísticaFita RGB de 12 V (5050)Fita WS2812B
ControleFita inteira, uma corCada LED com sua própria cor
Alimentação12 V (também existem versões de 24 V)5 V
Fiação4 fios: +12V, R, G, B3 fios: 5V, DIN, GND
Circuito driverUm MOSFET por canalNão precisa, um pino de dados basta
CódigoanalogWrite / PWMBiblioteca FastLED ou Adafruit NeoPixel
Corrente (60 LED/m, branco total)Cerca de 1,2 A/m (12 V)Cerca de 3,6 A/m (5 V)
Queda de tensãoNormalmente sem problemas até 5 mFitas longas precisam de injeção de alimentação em vários pontos
EfeitosCor fixa, transições, efeito respiraçãoLuzes sequenciais, arco-íris, animações
PreçoBarataMais cara

Por que você precisa de um MOSFET e qual escolher?

Um pino do Arduino Uno foi projetado para fornecer cerca de 20 mA (limite absoluto de 40 mA), mas um único canal de uma fita de 5 m com 60 LED/m pode consumir 2 A. Além disso, a fita funciona em 12 V. Um MOSFET de canal N resolve isso como uma chave do lado baixo: o Drain vai na linha de cor da fita, o Source vai no GND, e a tensão no Gate liga e desliga o MOSFET. O ponto principal é escolher um MOSFET de nível lógico; MOSFETs comuns como o IRF520 ou o IRF540N precisam de cerca de 10 V para conduzir totalmente e, em 5 V, ficam meio abertos e esquentam. A potência dissipada em um MOSFET é P = I² × Rds(on): para 2 A e 0,025 Ω, isso dá 2 × 2 × 0,025 = 0,1 W, então não é preciso dissipador. Para o básico, confira Como usar MOSFET com Arduino.

MOSFETTensão de gateRds(on)Adequação
IRLZ44NNível lógico, conduz totalmente com 4–5 V0,025 Ω (em 5 V)Ideal para Uno e Nano; em 3,3 V só para fitas curtas
IRLB8721Conduz bem também em 3,3 VCerca de 0,009 Ω (em 4,5 V)Uma das melhores opções para ESP32 e Pico
AO3400 (SMD)Conduz a partir de 2,5 VCerca de 0,03 Ω (em 4,5 V)Placas pequenas, 2–3 A por canal
IRF520 / IRF540NPrecisa de cerca de 10 VAlto em 5 VNão recomendado, esquenta
Nunca ligue o fio R, G ou B da fita diretamente a um pino do Arduino, e nunca, em hipótese alguma, ligue o fio +12V aos pinos 5V ou de sinal do Arduino. Se 12 V chegarem a um pino, o microcontrolador queima na hora. Desconecte a fonte da tomada enquanto monta o circuito e só ligue depois de conferir as conexões.

Esquema do circuito e tabela de ligações

Você monta o mesmo circuito pequeno três vezes, um para cada canal de cor. Segure o IRLZ44N com o lado escrito virado para você: os terminais, da esquerda para a direita, são Gate, Drain, Source; você também pode conferir a ordem dos terminais na ferramenta Transistores. Coloque um resistor de 220 Ω entre o Gate e o pino da placa; ele limita o pico de corrente puxado do pino enquanto a capacitância do gate carrega. Adicione também um resistor de pull-down de 10 kΩ entre o Gate e o GND; ele impede que o MOSFET ligue sozinho e acenda a fita aleatoriamente quando os pinos ficam flutuando durante a inicialização ou o carregamento do código. A regra mais importante: o negativo da fonte de 12 V precisa estar ligado ao GND da placa, senão o sinal de gate fica sem referência. Explicamos isso em detalhes no artigo sobre GND comum.

ConexãoArduino UnoESP32Raspberry Pi Pico
Gate do MOSFET vermelho (via 220 Ω)D9GPIO 25GP11
Gate do MOSFET verde (via 220 Ω)D10GPIO 26GP12
Gate do MOSFET azul (via 220 Ω)D11GPIO 27GP13
Terminais Drain dos MOSFETsFios R, G, B da fitaFios R, G, B da fitaFios R, G, B da fita
Terminais Source dos MOSFETsGNDGNDGND
Potenciômetro de matiz (pino do meio)A0GPIO 34GP26 (ADC0)
Potenciômetro de brilho (pino do meio)A1Não usadoNão usado
Pinos externos do potenciômetro5V e GND3V3 e GND3V3 e GND
Negativo da fonte de 12 VGNDGNDGND
Fio +12V da fitaPositivo da fontePositivo da fontePositivo da fonte

Cálculo de potência: qual fonte comprar?

Para escolher a fonte, primeiro calcule a corrente da fita em branco total: I = metros × A/m. Uma fita de 5 m com 60 LED/m consome 5 × 1,2 = 6 A; a potência é P = V × I = 12 × 6 = 72 W. Sempre escolha uma fonte com cerca de 20% de margem: neste exemplo, uma fonte de 12 V 8 A (96 W) é a certa. Uma fita de 2 m com 30 LED/m consome 1,2 A, então uma fonte de 12 V 2 A é suficiente. Escolha também o fio de acordo com a corrente; acima de 5 A, use fio de pelo menos 0,75 mm² em vez de jumpers. Se quiser alimentar a placa com a mesma fonte, o conector DC ou o pino Vin do Arduino Uno aceita 12 V e funciona bem com cargas leves. Nas placas de desenvolvimento ESP32 e no Pico, não ligue 12 V diretamente; a entrada VSYS do Pico aceita no máximo 5,5 V. Para essas placas, a solução mais limpa é baixar os 12 V para 5 V com um conversor buck LM2596 e ligar no pino 5V do ESP32 e no VSYS do Pico. Você pode conferir os cálculos com a calculadora da lei de Ohm e ler como calcular potência elétrica para mais detalhes.

Montagem passo a passo

  1. Monte o circuito inteiro antes de ligar a fonte na tomada; não mude as conexões com o circuito energizado.
  2. Solde quatro fios nas ilhas de solda da fita ou use um conector pronto; ligue o fio +12V ao positivo da fonte.
  3. Posicione os três MOSFETs e ligue os terminais Source à linha de GND comum. As linhas da protoboard servem para cerca de 1 A; para fitas que consomem vários amperes, faça o caminho da corrente com ligações soldadas ou um borne com parafuso.
  4. Ligue o Drain de cada MOSFET ao fio de cor correspondente da fita (R, G, B).
  5. Ligue os terminais Gate a D9, D10 e D11 por meio de resistores de 220 Ω; adicione um resistor de 10 kΩ entre cada Gate e o GND.
  6. Ligue o negativo da fonte de 12 V ao pino GND do Arduino para criar o terra comum.
  7. Conecte o Arduino ao computador via USB, carregue o primeiro código e depois ligue a fonte.
  8. Confira se cada cor acende sozinha; se acender a cor errada, troque os números dos pinos no código.

Primeiro código: mistura de cores com Arduino

Depois de montar o circuito, o começo mais seguro é testar cada canal um por um. O código abaixo usa os pinos PWM 9, 10 e 11 do Uno e mostra seis cores diferentes em sequência com a função setColor(). Se você tem curiosidade sobre como o PWM funciona, veja O que é PWM.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10;   // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11;   // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6  analogWrite(PIN_R, r);   // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7  analogWrite(PIN_G, g);
8  analogWrite(PIN_B, b);
9}
10
11void setup() {
12  pinMode(PIN_R, OUTPUT);
13  pinMode(PIN_G, OUTPUT);
14  pinMode(PIN_B, OUTPUT);
15  setColor(0, 0, 0);       // başlangıçta kapalı / off at start
16}
17
18void loop() {
19  setColor(255, 0, 0);     delay(1000);   // kırmızı / red
20  setColor(0, 255, 0);     delay(1000);   // yeşil / green
21  setColor(0, 0, 255);     delay(1000);   // mavi / blue
22  setColor(255, 120, 0);   delay(1000);   // turuncu / orange
23  setColor(160, 0, 255);   delay(1000);   // mor / purple
24  setColor(255, 255, 255); delay(1000);   // beyaz / white
25}

Aqui há uma diferença importante: quando você liga um único LED RGB de ânodo comum direto em um pino, a lógica é invertida (255 apaga), mas em um circuito com MOSFET analogWrite(pin, 255) liga o MOSFET totalmente e acende a cor no brilho máximo; 0 apaga. No Uno, os pinos 9 e 10 estão ligados ao Timer1 e o pino 11 ao Timer2, e os três funcionam a cerca de 490 Hz; nessa frequência o olho não percebe cintilação. Porém, tone() usa o Timer2 e por isso estraga o PWM do pino 11, e a biblioteca Servo desativa o PWM nos pinos 9 e 10. Se o seu projeto tem buzzer ou servo, planeje os pinos de acordo. Além disso, o brilho das cores da fita não é igual; se o branco parecer azulado, você pode equilibrá-lo baixando o canal azul para algo em torno de 200.

Transição lenta de cores: roda de cores com millis()

Para fazer a fita passar suavemente por todas as cores, usamos uma roda de cores: um valor de matiz de 0–767 é dividido em três regiões. Nos primeiros 256 passos o vermelho diminui e o verde aumenta, nos 256 seguintes vai do verde ao azul, e na última parte do azul ao vermelho. Como os dois canais sempre somam 255, as cores fluem umas nas outras sem saltos. Como usamos millis() em vez de delay(), o loop() também pode fazer outras tarefas, como ler botões ou medir sensores. Nossos olhos não percebem o brilho de forma linear: pequenas mudanças em valores baixos são bem visíveis, enquanto as de valores altos são difíceis de notar. Por isso a função gamma8() do código escala o valor pelo seu quadrado (v × v / 255) e deixa as transições em luz fraca mais naturais. Se você aumentar STEP_MS, o ciclo completo fica mais longo; com 15 ms, um ciclo leva cerca de 11,5 segundos.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı / red
2const int PIN_G = 10;   // yeşil / green
3const int PIN_B = 11;   // mavi / blue
4
5const unsigned long STEP_MS = 15;   // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0;                        // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10  return (uint16_t)v * v / 255;     // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14  analogWrite(PIN_R, gamma8(r));
15  analogWrite(PIN_G, gamma8(g));
16  analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20  uint8_t p = h % 256;
21  if (h < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
22  else if (h < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
23  else              setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27  pinMode(PIN_R, OUTPUT);
28  pinMode(PIN_G, OUTPUT);
29  pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33  if (millis() - lastStep >= STEP_MS) {
34    lastStep = millis();
35    wheel(hue);
36    hue = (hue + 1) % 768;
37  }
38  // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}

Escolhendo cor e brilho com potenciômetros

Dois potenciômetros bastam para escolher a cor na mão: o do A0 define a matiz (0–767) e o do A1 define o brilho geral (0–255). Como analogRead() retorna 0–1023, escalamos para a faixa que queremos com map(). O brilho é aplicado multiplicando o valor de cada canal por bri / 255, assim a luz diminui enquanto a matiz é mantida. Também dá para ajustar R, G e B diretamente com três potenciômetros separados, mas uma roda de cores com um só botão é muito mais intuitiva e permite chegar a todas as cores saturadas, exceto o branco.

C++ (Arduino IDE)
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0;   // renk tonu / hue
5const int POT_BRI = A1;   // parlaklık / brightness
6
7void setup() {
8  pinMode(PIN_R, OUTPUT);
9  pinMode(PIN_G, OUTPUT);
10  pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14  int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15  int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17  uint8_t r, g, b;
18  uint8_t p = hue % 256;
19  if (hue < 256)      { r = 255 - p; g = p;       b = 0; }       // kırmızı -> yeşil / red -> green
20  else if (hue < 512) { r = 0;       g = 255 - p; b = p; }       // yeşil -> mavi / green -> blue
21  else                { r = p;       g = 0;       b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23  analogWrite(PIN_R, (uint16_t)r * bri / 255);   // parlaklığı uygula / apply brightness
24  analogWrite(PIN_G, (uint16_t)g * bri / 255);
25  analogWrite(PIN_B, (uint16_t)b * bri / 255);
26  delay(20);
27}

Controlando uma fita RGB com o ESP32 (LEDC)

O ESP32 usa sua unidade de hardware LEDC para PWM; você mesmo escolhe a frequência e a resolução. 5 kHz e 8 bits dão uma luz sem cintilação e a conhecida faixa 0–255. No Arduino core 3.x você usa ledcAttach(pin, frequência, resolução) e ledcWrite(pin, valor), enquanto no 2.x você primeiro configura um canal com ledcSetup(), associa a um pino com ledcAttachPin() e ledcWrite() escreve no canal; o código abaixo suporta as duas versões com #if. Como os pinos do ESP32 fornecem 3,3 V, é importante escolher um MOSFET com tensão de gate baixa, como o IRLB8721 da tabela. Ligamos o potenciômetro no GPIO 34, um pino do ADC1 que funciona bem mesmo com o Wi-Fi ligado; o ADC é de 12 bits, então os valores vão de 0–4095, e a média de oito leituras é usada para reduzir o ruído. Para o básico da placa, veja O que é o ESP32.

C++ (Arduino IDE)
1const int PIN_R = 25;       // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26;       // yeşil / green
3const int PIN_B = 27;       // mavi / blue
4const int POT_HUE = 34;     // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000;  // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8;      // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10  ledcWrite(PIN_R, r);      // core 3.x: pine yaz / write to pin
11  ledcWrite(PIN_G, g);
12  ledcWrite(PIN_B, b);
13#else
14  ledcWrite(0, r);          // core 2.x: kanala yaz / write to channel
15  ledcWrite(1, g);
16  ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22  ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23  ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24  ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26  ledcSetup(0, PWM_FREQ, PWM_RES);
27  ledcSetup(1, PWM_FREQ, PWM_RES);
28  ledcSetup(2, PWM_FREQ, PWM_RES);
29  ledcAttachPin(PIN_R, 0);
30  ledcAttachPin(PIN_G, 1);
31  ledcAttachPin(PIN_B, 2);
32#endif
33  analogReadResolution(12);  // 0-4095
34  setColor(0, 0, 0);
35}
36
37void loop() {
38  long sum = 0;
39  for (int i = 0; i < 8; i++) {
40    sum += analogRead(POT_HUE);   // 8 okumayı topla / sum 8 readings
41  }
42  int hue = map(sum / 8, 0, 4095, 0, 767);
43  uint8_t p = hue % 256;
44  if (hue < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
45  else if (hue < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
46  else                setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
47  delay(20);
48}

Código MicroPython com o Raspberry Pi Pico

No Pico, todo pino GPIO pode gerar PWM, e duty_u16() recebe um valor de 0–65535. No código, escalamos os valores de cor de 0–255 para essa faixa multiplicando por 257 (255 × 257 = 65535). O potenciômetro está no GP26 (ADC0); read_u16() também retorna 0–65535, então ele é facilmente convertido em um valor de matiz. GP12 e GP13 compartilham a mesma slice PWM (slice 6); como damos a mesma frequência aos dois, não há problema, mas se você tentar definir frequências diferentes, a última configuração afeta os dois. Como o Pico funciona em 3,3 V, a recomendação de MOSFET que demos para o ESP32 vale aqui também. Para a configuração, leia O que é o Raspberry Pi Pico.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13)                      # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7    pwm = PWM(Pin(p))
8    pwm.freq(1000)                       # 1 kHz PWM
9    pwm.duty_u16(0)                      # başlangıçta kapalı / off at start
10    leds.append(pwm)
11
12pot = ADC(26)                            # GP26 = ADC0
13
14def set_color(r, g, b):
15    # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16    leds[0].duty_u16(r * 257)
17    leds[1].duty_u16(g * 257)
18    leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21    p = hue % 256
22    if hue < 256:
23        return 255 - p, p, 0             # kırmızı -> yeşil / red -> green
24    elif hue < 512:
25        return 0, 255 - p, p             # yeşil -> mavi / green -> blue
26    return p, 0, 255 - p                 # mavi -> kırmızı / blue -> red
27
28while True:
29    hue = pot.read_u16() * 767 // 65535  # 0-767 ton / hue
30    set_color(*wheel(hue))
31    time.sleep_ms(20)

Ideias de projetos com fita LED RGB

  • Luz ambiente que reage à música: mude a cor e o brilho da fita no ritmo da música com um sensor de som; detalhes no artigo sobre LED que reage à música.
  • Iluminação traseira de TV com controle remoto: mude a cor e o brilho do sofá com um Receptor IR + controle remoto.
  • Luz de escada acionada por movimento: quando um sensor PIR detectar alguém, acenda a fita devagar e desligue depois de um tempo.
  • Luz noturna automática: quando um LDR perceber que está escurecendo, acenda um laranja quente com brilho baixo.
  • Controle pelo celular: crie um servidor web no ESP32 e use um seletor de cores no navegador.
  • Despertador nascer do sol: começando 20 minutos antes da hora de acordar, acenda a fita lentamente do vermelho escuro até o branco.

Erros comuns e como corrigi-los

SintomaCausa provávelSolução
A fita não acende de jeito nenhumFalta GND comum ou o fio +12V não está ligadoLigue o negativo da fonte ao GND da placa e confira o fio +12V da fita
Uma cor fica sempre acesa, não importa o que o código digaDrain e Source do MOSFET invertidos ou MOSFET queimadoConfira a ordem dos terminais (G-D-S) e troque o MOSFET se necessário
A fita pisca sozinha ao ligarFalta o resistor de pull-down no GateAdicione 10 kΩ entre cada Gate e o GND
O MOSFET esquenta muitoMOSFET que não é de nível lógico ou tensão de gate insuficiente em 3,3 VUse um MOSFET de nível lógico, como o IRLZ44N ou o IRLB8721
Cores trocadas (acende verde em vez de vermelho)As marcações da fita ou a ordem dos fios são diferentesTroque os valores de PIN_R, PIN_G, PIN_B no código
O final da fita fica amarelado e fracoQueda de tensão em fita longaAlimente fitas com mais de 5 m pelas duas pontas e use fio mais grosso
A placa reseta ou reiniciaFonte fraca demais, tensão caindoUse uma fonte mais potente e alimente a placa por um regulador separado
Cintilação ou linhas na câmeraFrequência de PWM baixaAumente a frequência para 1–5 kHz no ESP32 e no Pico

Uma fita RGB não endereçável com três MOSFETs e três pinos PWM é a forma mais prática de adicionar uma camada de luz forte e barata ao seu quarto, à sua mesa ou ao seu projeto. Se quiser controlar cada LED individualmente, a WS2812B pode ser o seu próximo passo. No app BlueGrays você pode explorar os projetos de mistura de cores com LED RGB, transição suave de cores, luminária misturadora de cores com ESP32 e ciclo de cores RGB com Pico, passo a passo, com esquema do circuito e código.

Perguntas frequentes

Dá para ligar uma fita LED RGB diretamente no Arduino?

Não. Uma fita de 12 V pode consumir mais de um ampere por metro, enquanto um pino do Arduino fornece só cerca de 20 mA e funciona em 5 V. Você precisa acionar a fita por meio de um MOSFET de nível lógico para cada canal de cor; o Arduino só envia um sinal PWM para o gate do MOSFET.

Qual MOSFET devo usar para uma fita LED de 12 V?

Para o Arduino Uno e o Nano, de 5 V, o IRLZ44N é uma escolha comum e adequada. Em placas de 3,3 V como o ESP32 e o Raspberry Pi Pico, MOSFETs que conduzem totalmente com tensão de gate baixa, como o IRLB8721 ou o AO3400, funcionam melhor. O IRF520 e o IRF540N não conduzem totalmente em 5 V, por isso esquentam.

Quantos amperes consome uma fita LED RGB de 5 metros?

Uma fita 5050 de 60 LED/m consome cerca de 1,2 A por metro em branco total; 5 metros dão cerca de 6 A e 72 W. Em uma fita de 30 LED/m, esses valores caem pela metade. Escolha a fonte com 20% de margem; para 6 A, uma fonte de 12 V 8 A é a certa.

Qual é a diferença entre uma fita LED RGB e a WS2812B?

Em uma fita RGB não endereçável, todos os LEDs mostram a mesma cor ao mesmo tempo, e ela é acionada com três MOSFETs. Na WS2812B, cada LED tem seu próprio chip driver, e você envia uma cor diferente para cada um a partir de um único pino de dados. A WS2812B é ideal para efeitos sequenciais, enquanto a fita RGB é ideal para iluminação simples, forte e barata.

Onde dá para cortar uma fita LED RGB?

Fitas de 12 V funcionam em segmentos de três LEDs e só podem ser cortadas nas marcas de corte sobre as ilhas de cobre; esse espaçamento é de 5 cm na de 60 LED/m e de 10 cm na de 30 LED/m. Se você cortar em outro lugar, aquele segmento não acende. Você pode religar o pedaço cortado soldando fios nas ilhas ou usando um conector de encaixe.

Posso alimentar o Arduino com a fonte de 12 V da fita?

Você pode alimentar o Arduino Uno com 12 V pelo conector DC ou pelo pino Vin; o regulador da placa dá conta disso com cargas leves. Nas placas de desenvolvimento ESP32 e no Raspberry Pi Pico, é preciso baixar os 12 V para 5 V com um conversor buck como o LM2596. Em todos os casos, o negativo da fonte precisa estar ligado ao GND da placa.

Ver todos os projetos
Uso de LED RGB
AR-39Iniciante
Premium

Uso de LED RGB

Três cores se escondem em um único LED: o LED RGB acende primeiro em vermelho, depois em verde e, por fim, em azul.

4.9(73)
100
Transição suave de cores com LED RGB
AR-40Iniciante
Premium

Transição suave de cores com LED RGB

Um único LED RGB muda lentamente do vermelho para o verde, do verde para o azul e de volta para o vermelho, repetindo esse ciclo de arco-íris sem parar.

4.8(58)
78
Controle de LED RGB com ESP32
ES-9Iniciante

Controle de LED RGB com ESP32

Gere inúmeras cores com um único LED RGB em vez de 3 LEDs separados. Como no Arduino, ajustamos os valores R/G/B com analogWrite() para criar uma transição de arco-íris. Você vê a teoria das cores na prática, como vermelho + verde = amarelo.

4.6(29)
52
Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)
ES-36Avançado
Premium

Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)

Uma luminária inteligente que permite misturar a cor que você quiser girando três potenciômetros com o ESP32! Ao girar os potenciômetros de vermelho, verde e azul, o LED RGB de cátodo comum muda de cor em tempo real. O display OLED SSD1306 mostra os valores de cada cor na faixa de 0–255, barras de preenchimento e o código HEX da cor para a web, como #FF8040.

4.7(6)
10
Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)
PI-15Iniciante

Ciclo de cores com LED RGB no Raspberry Pi Pico (PWM de 3 canais)

Um LED, milhões de cores! Um LED RGB guarda, na verdade, três LEDs: vermelho, verde e azul. Com os 3 canais PWM do Pico, você ajusta o brilho de cada um e as cores se misturam: vermelho + verde = amarelo, verde + azul = ciano, os três = branco. O LED passa por 8 cores, meio segundo cada, e você aprende a usar vários canais PWM, criar uma função com def set_color(...) e converter valores de 8 para 16 bits (x257), a mesma ideia usada nas telas.

6
Variação gradual do brilho do LED com PWM no ESP32
ES-8Iniciante

Variação gradual do brilho do LED com PWM no ESP32

Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

4.8(36)
55
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)

Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

4.5(19)
32
Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)
PI-14Iniciante

Raspberry Pi Pico: variação de brilho do LED com PWM (efeito de respiração)

O LED não só pisca — ele respira! Com o PWM (modulação por largura de pulso) do Raspberry Pi Pico, o brilho do LED aumenta e diminui lentamente, como a luz de um MacBook em repouso. Aprenda a usar a classe machine.PWM, duty_u16() (brilho de 16 bits, de 0–65535), frequência PWM (freq(1000) — 1.000 ciclos de ligar/desligar por segundo, sem cintilação visível), laços com passos usando range() (crescentes e decrescentes) e saída semelhante à analógica em um pino digital.

4