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ística | Fita de 30 LED/m | Fita de 60 LED/m |
|---|---|---|
| Tipo de LED | 5050 SMD (5,0 × 5,0 mm, 3 chips) | 5050 SMD (5,0 × 5,0 mm, 3 chips) |
| Tensão de operação | 12 V DC | 12 V DC |
| Potência (branco total) | Cerca de 7,2 W/m | Cerca de 14,4 W/m |
| Corrente (branco total) | Cerca de 0,6 A/m | Cerca de 1,2 A/m |
| Corrente por canal | Cerca de 0,2 A/m | Cerca de 0,4 A/m |
| Intervalo de corte | A 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ística | Fita RGB de 12 V (5050) | Fita WS2812B |
|---|---|---|
| Controle | Fita inteira, uma cor | Cada LED com sua própria cor |
| Alimentação | 12 V (também existem versões de 24 V) | 5 V |
| Fiação | 4 fios: +12V, R, G, B | 3 fios: 5V, DIN, GND |
| Circuito driver | Um MOSFET por canal | Não precisa, um pino de dados basta |
| Código | analogWrite / PWM | Biblioteca 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ão | Normalmente sem problemas até 5 m | Fitas longas precisam de injeção de alimentação em vários pontos |
| Efeitos | Cor fixa, transições, efeito respiração | Luzes sequenciais, arco-íris, animações |
| Preço | Barata | Mais 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.
| MOSFET | Tensão de gate | Rds(on) | Adequação |
|---|---|---|---|
| IRLZ44N | Nível lógico, conduz totalmente com 4–5 V | 0,025 Ω (em 5 V) | Ideal para Uno e Nano; em 3,3 V só para fitas curtas |
| IRLB8721 | Conduz bem também em 3,3 V | Cerca de 0,009 Ω (em 4,5 V) | Uma das melhores opções para ESP32 e Pico |
| AO3400 (SMD) | Conduz a partir de 2,5 V | Cerca de 0,03 Ω (em 4,5 V) | Placas pequenas, 2–3 A por canal |
| IRF520 / IRF540N | Precisa de cerca de 10 V | Alto em 5 V | Não recomendado, esquenta |
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ão | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate do MOSFET vermelho (via 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate do MOSFET verde (via 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate do MOSFET azul (via 220 Ω) | D11 | GPIO 27 | GP13 |
| Terminais Drain dos MOSFETs | Fios R, G, B da fita | Fios R, G, B da fita | Fios R, G, B da fita |
| Terminais Source dos MOSFETs | GND | GND | GND |
| Potenciômetro de matiz (pino do meio) | A0 | GPIO 34 | GP26 (ADC0) |
| Potenciômetro de brilho (pino do meio) | A1 | Não usado | Não usado |
| Pinos externos do potenciômetro | 5V e GND | 3V3 e GND | 3V3 e GND |
| Negativo da fonte de 12 V | GND | GND | GND |
| Fio +12V da fita | Positivo da fonte | Positivo da fonte | Positivo 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
- Monte o circuito inteiro antes de ligar a fonte na tomada; não mude as conexões com o circuito energizado.
- Solde quatro fios nas ilhas de solda da fita ou use um conector pronto; ligue o fio +12V ao positivo da fonte.
- 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.
- Ligue o Drain de cada MOSFET ao fio de cor correspondente da fita (R, G, B).
- 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.
- Ligue o negativo da fonte de 12 V ao pino GND do Arduino para criar o terra comum.
- Conecte o Arduino ao computador via USB, carregue o primeiro código e depois ligue a fonte.
- 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.
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.
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.
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.
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.
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
| Sintoma | Causa provável | Solução |
|---|---|---|
| A fita não acende de jeito nenhum | Falta GND comum ou o fio +12V não está ligado | Ligue 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 diga | Drain e Source do MOSFET invertidos ou MOSFET queimado | Confira a ordem dos terminais (G-D-S) e troque o MOSFET se necessário |
| A fita pisca sozinha ao ligar | Falta o resistor de pull-down no Gate | Adicione 10 kΩ entre cada Gate e o GND |
| O MOSFET esquenta muito | MOSFET que não é de nível lógico ou tensão de gate insuficiente em 3,3 V | Use 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 diferentes | Troque os valores de PIN_R, PIN_G, PIN_B no código |
| O final da fita fica amarelado e fraco | Queda de tensão em fita longa | Alimente fitas com mais de 5 m pelas duas pontas e use fio mais grosso |
| A placa reseta ou reinicia | Fonte fraca demais, tensão caindo | Use uma fonte mais potente e alimente a placa por um regulador separado |
| Cintilação ou linhas na câmera | Frequência de PWM baixa | Aumente 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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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.

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.

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.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

