Guias · 10 min de leitura

Vela LED com Arduino: chama realista e coroa do Advento

Faça uma vela LED com Arduino tremular como uma chama de verdade usando PWM e aleatoriedade suavizada: coroa do Advento com 4 velas, ajustes da chama, autonomia da bateria com Nano e Pico.

Neste projeto de vela LED com Arduino, você faz um LED comum tremular como a chama de uma vela de verdade usando PWM e aleatoriedade controlada. O resultado é uma vela que fica acesa com segurança na mesa, na janela ou no quarto das crianças, sem fogo, fuligem ou risco de tombar. A maioria das velas LED prontas repete um único padrão de tremulação; quando você escreve seu próprio código, é você quem decide o quanto a chama é calma ou agitada, em que faixa ela brilha e diminui e com que frequência ela se curva com uma “corrente de ar”.

Neste guia, você vai ver primeiro a lógica por trás do efeito de tremulação e um sketch curto para uma vela, depois uma tabela mostrando como cada parâmetro muda a chama. Em seguida, vai montar uma coroa do Advento com quatro velas: cada toque no botão acende mais uma vela, a escolha fica salva na EEPROM e o circuito entra em modo de repouso sozinho depois de 6 horas. Por fim, vêm a montagem em uma caixinha com Arduino Nano, o cálculo de autonomia da bateria e uma versão em MicroPython para o Raspberry Pi Pico.

LEDs de 5 mm
LED de 5 mm: para o efeito de vela, escolha amarelo, laranja ou branco quente; LEDs azuis e branco frio não parecem uma chama.

Como funciona o efeito de vela LED?

Os pinos do Arduino só conseguem fornecer 0 V ou 5 V; para acender um LED com metade do brilho, o pino é ligado e desligado centenas de vezes por segundo. Isso se chama PWM (modulação por largura de pulso). O valor de 0–255 em analogWrite(pino, valor) define quanto de cada período o pino fica ligado: 64 significa cerca de 25 por cento e 191 cerca de 75 por cento de brilho. No Uno e no Nano, a frequência do PWM é de cerca de 980 Hz nos pinos 5 e 6 e de cerca de 490 Hz nos pinos 3, 9, 10 e 11; o olho não percebe essa velocidade e enxerga o LED aceso de forma contínua, mas mais fraco. Os detalhes estão no guia o que é PWM.

O segredo de uma chama realista é suavizar a aleatoriedade. Se você escrever analogWrite(pin, random(0, 256)) a cada 20 milissegundos, o LED se agita como uma lâmpada fluorescente com defeito, porque uma chama de verdade nunca pula de zero para o brilho máximo num instante. Um método melhor é escolher um brilho-alvo aleatório e aproximar o brilho atual um pouco dele a cada passo: nível = nível + (alvo − nível) / 4. O alvo muda de vez em quando e o nível flui suavemente até ele. Acrescente quedas profundas ocasionais, a chama se curvando com uma corrente de ar, e o olho aceita aquilo como uma vela de verdade.

Componentes e escolha dos LEDs

Cor do LEDTensão direta (aprox.)Resistor (Uno, 5 V)Resistor (Pico, 3,3 V)Aparência de vela
Amarelo2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Muito boa, a cor clássica de vela
Laranja / âmbar2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)O tom mais quente e mais realista
Branco quente3,0–3,2 V150 Ω (~12 mA)Não recomendado (fraco demais)Brilhante, como uma vela LED moderna
Vermelho1,8–2,0 V220 Ω (~14 mA)220 Ω (~6 mA)Escuro demais sozinho; fica bom junto com o amarelo
  • Arduino Uno ou Nano: O Uno para testar na mesa, o Nano para caber numa caixa. As duas placas têm os mesmos pinos e o mesmo código.
  • 4 LEDs amarelos ou laranja e o resistor da tabela para cada um. Você encontra os resistores para outros LEDs com a calculadora Resistor para LED.
  • 1 botão: Para mudar o número de velas e desligar. Como o pull-up interno é usado, não é preciso nenhum resistor extra.
  • Protoboard e jumpers, além de placa perfurada e solda para uma coroa permanente.
  • Alimentação: Um carregador USB, um power bank ou um suporte de pilhas. Vamos escolher a bateria com o cálculo mais abaixo.
  • Corpo da vela: Um pedaço de cano de PVC branco, uma vela velha escavada por dentro ou um copo de vidro jateado; qualquer coisa que espalhe a luz do LED serve.

Uma vela: o primeiro sketch de tremulação

C++ (Arduino IDE)
1const byte LED_PIN = 9;          // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180;                 // şu anki parlaklık / current brightness
4int target = 180;                // hedef parlaklık / target brightness
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  randomSeed(analogRead(A0));    // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12  if (random(100) < 8) {                 // %8 ihtimalle yeni hedef / 8% chance of a new target
13    target = random(90, 256);
14    if (random(100) < 5) target = 40;    // nadir esinti: alev eğilir / rare gust: the flame dips
15  }
16  level += (target - level) / 4;         // hedefe yumuşak yaklaş / ease toward the target
17  analogWrite(LED_PIN, level);
18  delay(random(15, 40));                 // düzensiz adım / irregular step
19}

Ligue o LED através de um resistor de 220 Ω ao pino 9, a perna curta ao GND, e carregue o sketch. A cada ciclo, há 8 por cento de chance de um novo alvo entre 90 e 255; com 5 por cento de chance, o alvo é puxado para 40, uma queda profunda. A linha level += (target − level) / 4 soma um quarto da diferença para uma transição suave, e a pausa aleatória de 15–40 ms deixa o padrão ainda mais irregular. A linha randomSeed(analogRead(A0)) usa o ruído do pino A0 desconectado para iniciar uma sequência aleatória diferente a cada vez que a placa liga; sem ela, a vela tremula do mesmo jeito todas as vezes.

Tabela de parâmetros da tremulação

ParâmetroPadrãoSe você diminuirSe você aumentar
FLAME_MIN90A chama tremula mais fundo e parece prestes a apagarA chama se acalma e fica acesa quase sem variar
FLAME_MAX255A vela fica mais fraca, como uma luz noturna255 é o limite máximo; para mais brilho, é preciso mais corrente no LED
CHANGE_CHANCE8 (%)Uma chama tranquila, num cômodo sem corrente de arTremulação rápida e nervosa, que cansa depois de um tempo
GUST_CHANCE3 (%)Quase nenhuma corrente de arUma chama que se curva com frequência, como com a janela aberta
SMOOTH41–2: saltos bruscos, como uma lâmpada com defeito8 ou mais: variações de brilho lentas, como ondas
STEP_MS25 msUma chama mais rápida e mais vivaA partir de 50 ms, parece câmera lenta
Durante o ajuste, mude um parâmetro de cada vez e observe o LED através de um papel ou de um vidro jateado, e não diretamente; num LED sem nada na frente, a tremulação sempre parece mais brusca do que é. Para a maioria das pessoas, o resultado mais natural vem com FLAME_MIN entre 80–110, SMOOTH entre 3–5 e CHANGE_CHANCE entre 6–10.

Coroa do Advento com quatro velas: ligações

A coroa do Advento é uma tradição, muito querida principalmente na Alemanha, na Áustria e na Suíça, em que se acende uma vela a mais em cada um dos quatro domingos antes do Natal. Em 2026, os domingos do Advento são 29 de novembro, 6 de dezembro, 13 de dezembro e 20 de dezembro. Na nossa coroa, quatro LEDs representam as quatro velas; um toque curto no botão acrescenta uma vela acesa (0, 1, 2, 3, 4 e de volta a 0) e um toque longo desliga o circuito. Cada vela tem seu próprio estado de tremulação, então as quatro chamas parecem independentes e naturais.

LigaçãoArduino Uno / NanoRaspberry Pi Pico
Vela 1 (resistor até a perna longa do LED)D3GP14
Vela 2D5GP15
Vela 3D6GP16
Vela 4D9GP17
Pernas curtas dos LEDsGNDGND
Botão (outra perna no GND)D2GP2
Ligue as velas apenas em pinos com PWM: no Uno e no Nano, eles são 3, 5, 6, 9, 10 e 11 (marcados com ~ na placa). Um LED em qualquer outro pino não tremula com analogWrite(); ele fica apagado para valores abaixo de 128 e totalmente aceso acima disso. Ligue o botão no pino 2, porque o sketch acorda do modo de repouso pela interrupção desse pino (INT0). Para o mapa de pinos do Nano, veja o guia pinagem do Arduino Nano.
Arduino Nano
Arduino Nano: o mesmo processador ATmega328P e os mesmos pinos PWM do Uno, mas pequeno o bastante para caber na base de uma coroa.

Código da coroa do Advento: uma vela a mais a cada domingo

O sketch funciona com millis() em vez de delay(), então a tremulação nunca para enquanto ele escuta o botão e conta o tempo do temporizador. Essa abordagem é explicada no guia millis em vez de delay. A cada 25 ms, o estado das quatro velas é atualizado, e as velas apagadas ficam com valor de PWM zero. O número de velas que você escolhe é gravado no endereço 0 da EEPROM; mesmo se você tirar da tomada e ligar de novo, a coroa volta com o mesmo número de velas.

C++ (Arduino IDE)
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9};   // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2;                        // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90;          // en kısık alev / dimmest flame
10const int FLAME_MAX = 255;         // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8;      // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3;        // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4;             // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25;  // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000;   // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1;                 // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {}                   // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26  for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27  while (digitalRead(BUTTON_PIN) == LOW) {}        // butonun bırakılmasını bekle / wait for release
28  delay(50);
29  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30  sleep_enable();
31  noInterrupts();
32  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33  interrupts();
34  sleep_cpu();                                     // burada uyur / sleeps here
35  sleep_disable();                                 // butona basınca buradan devam / resumes here on press
36  detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37  while (digitalRead(BUTTON_PIN) == LOW) {}        // uyandıran basış sayılmasın / ignore the wake-up press
38  delay(50);
39  onSince = millis();
40}
41
42void flicker() {
43  for (byte i = 0; i < CANDLES; i++) {
44    if (i >= litCount) {                           // bu mum henüz yakılmadı / not lit yet
45      analogWrite(CANDLE_PINS[i], 0);
46      continue;
47    }
48    if (random(100) < CHANGE_CHANCE) {
49      target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50      if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2;   // alev eğilir / the flame bends
51    }
52    level[i] += (target[i] - level[i]) / SMOOTH;
53    analogWrite(CANDLE_PINS[i], level[i]);
54  }
55}
56
57void setup() {
58  pinMode(BUTTON_PIN, INPUT_PULLUP);
59  for (byte i = 0; i < CANDLES; i++) {
60    pinMode(CANDLE_PINS[i], OUTPUT);
61    level[i] = target[i] = 200;
62  }
63  randomSeed(analogRead(A0));
64  litCount = EEPROM.read(0);                       // son seçimi hatırla / remember the last choice
65  if (litCount > CANDLES) litCount = 1;            // boş EEPROM 255 okur / empty EEPROM reads 255
66  onSince = millis();
67}
68
69void loop() {
70  if (digitalRead(BUTTON_PIN) == LOW) {
71    unsigned long pressStart = millis();
72    while (digitalRead(BUTTON_PIN) == LOW) {
73      if (millis() - pressStart > 1500) {          // uzun basış: kapat / long press: switch off
74        goToSleep();
75        return;
76      }
77    }
78    if (millis() - pressStart > 50) {              // kısa basış: bir mum daha / short press: one more candle
79      litCount = (litCount + 1) % (CANDLES + 1);
80      EEPROM.update(0, litCount);
81      onSince = millis();
82    }
83  }
84
85  if (millis() - onSince > ON_TIME) goToSleep();   // zamanlayıcı / auto-off timer
86
87  if (millis() - lastStep >= STEP_MS) {
88    lastStep = millis();
89    flicker();
90  }
91}
CódigoO que faz
level[i], target[i] (brilho e alvo)O brilho e o alvo próprios de cada vela; as quatro chamas tremulam de forma independente
i >= litCount (velas ainda apagadas)Apaga as velas cuja vez ainda não chegou; no 2º domingo, litCount = 2
EEPROM.update(0, litCount) (salva o número de velas)Não grava se o valor não mudou, preservando a vida útil da célula da EEPROM
se litCount > CANDLES, então 1Uma EEPROM nunca gravada lê 255; na primeiríssima vez, começa com uma vela
ON_TIME (tempo ligado)Depois de 6 horas, apaga as velas e entra em repouso; uma coroa esquecida ligada à noite não descarrega a bateria
goToSleep() (entrar em repouso)Para o processador com SLEEP_MODE_PWR_DOWN; apertar o botão acorda a placa pela interrupção INT0

No modo de repouso, o clock do ATmega328P para e o consumo do processador cai para microampères. Para acordá-lo, uma interrupção por nível LOW é associada ao pino 2; no modo power-down, só uma interrupção por nível consegue acordar o processador, então CHANGE ou FALLING não funcionam aqui. Depois de acordar, o código espera o botão ser solto, para que o toque que acordou a placa não conte também como mais uma vela. O millis() também para durante o repouso, e é por isso que o temporizador é zerado ao acordar.

Tamanho compacto com Nano e cálculo de autonomia da bateria

Você descobre quanto tempo uma bateria dura com autonomia (horas) = capacidade utilizável (mAh) / corrente média (mA). Vamos calcular a corrente da coroa: um LED tremulando consome em média cerca de 70 por cento da sua corrente de pico, ou seja, uns 8–9 mA para um LED de 12 mA. Quatro velas dão cerca de 35 mA; somando os 15–20 mA que um Nano clone consome sozinho, o total fica em cerca de 50 mA. Uma noite de 6 horas gasta 300 mAh. Em repouso, o processador quase não consome nada, mas, por causa do LED de alimentação, do chip USB e do regulador da placa, a maioria dos clones do Nano ainda gasta alguns mA (normalmente em torno de 5 mA); 18 horas de repouso somam cerca de 90 mAh. Você pode testar outros cenários com a ferramenta Autonomia da bateria.

Fonte de alimentaçãoCapacidade utilizávelNoites de 6 horas (≈50 mA)Observação
3 × AA alcalinas (≈4,5 V, no pino 5V)~2,000 mAh~5 noites (com as perdas no repouso)Os LEDs ficam mais fracos à medida que as pilhas se esgotam
4 × AA NiMH recarregáveis (≈4,8 V, no pino 5V)~1,900 mAh~5 noitesPrecisa recarregar 4–5 vezes durante o Advento
18650 + TP4056 + conversor boost de 5 V~1,600 mAh (em 5 V)~4 noitesCarrega pela USB, cabe numa caixa
Power bank USB de 10,000 mAh~6,300 mAh (em 5 V)~16 noitesPode se desligar sozinho durante o repouso por causa da corrente baixa
Carregador USB de 5 V 1 AIlimitadaIlimitadoA solução mais fácil para uma coroa sobre a mesa
Não ligue quatro pilhas AA alcalinas direto no pino 5V: pilhas alcalinas novas chegam a 6,4 V no total, e no pino 5V, que não passa pelo regulador, isso ultrapassa o limite de 5,5 V do processador. Uma bateria de 9 V também não é uma boa escolha; a capacidade dela é de cerca de 500 mAh, e o regulador no VIN transforma o excesso de tensão em calor. Se você quer uma vela que funcione muito tempo com pilhas, um Arduino Pro Mini sem o LED de alimentação reduz a corrente em repouso a microampères.

Versão em MicroPython para Raspberry Pi Pico

Todos os pinos GPIO do Pico podem gerar PWM, então as velas vão nos pinos GP14–GP17 e o botão no GP2. No MicroPython, o brilho é definido com duty_u16() de 0 a 65535; o código mantém os valores de 0–255 da versão Arduino e os multiplica por 257 para chegar à mesma escala (255 × 257 = 65535). Em vez da EEPROM, o número de velas fica salvo num arquivo mum.txt no sistema de arquivos do Pico. Salve o código como main.py e a coroa acende assim que o Pico é ligado.

MicroPython
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17)              # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90                       # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8                    # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3                      # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16    pwm = PWM(Pin(p))
17    pwm.freq(1000)                   # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18    leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24    with open("mum.txt") as f:       # son seçimi oku / read the last choice
25        lit = int(f.read())
26except (OSError, ValueError):
27    lit = 1
28
29
30def save(n):
31    with open("mum.txt", "w") as f:
32        f.write(str(n))
33
34
35last_button = 1
36while True:
37    b = button.value()
38    if b == 0 and last_button == 1:  # basıldığı an / the moment it is pressed
39        lit = (lit + 1) % (len(PINS) + 1)
40        save(lit)
41        time.sleep_ms(30)            # basit debounce / simple debounce
42    last_button = b
43
44    for i, led in enumerate(leds):
45        if i >= lit:
46            led.duty_u16(0)
47            continue
48        if random.randint(0, 99) < CHANGE_CHANCE:
49            target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50            if random.randint(0, 99) < GUST_CHANCE:
51                target[i] = FLAME_MIN // 2
52        level[i] += (target[i] - level[i]) // SMOOTH
53        led.duty_u16(level[i] * 257)  # 0-255 -> 0-65535
54    time.sleep_ms(STEP_MS)

Como o Pico funciona com 3,3 V, LEDs branco quente (cerca de 3 V de tensão direta) mal acendem; use LEDs amarelos ou laranja com resistores de 220 Ω. Esta versão não tem temporizador nem modo de repouso; se quiser, conte 6 horas com time.ticks_ms() e zere todos os valores de duty. Definimos a frequência do PWM do Pico em 1 kHz; em frequências mais baixas, podem aparecer listras em vídeos gravados com a câmera do celular.

Deixando a aparência realista

  • Espalhe a luz: Deixe a ponta do LED fosca com uma lixa fina ou coloque um pouco de algodão dentro do corpo da vela; o corpo inteiro brilha, em vez de um único ponto.
  • Chama com dois LEDs: Coloque um LED amarelo e um laranja na mesma vela, em pinos PWM separados, e faça-os tremular em velocidades diferentes; assim a cor da chama também se mexe. Os seis pinos PWM do Uno bastam para três velas desse tipo.
  • Corpo da vela: Use cano de PVC branco de 2–3 cm de diâmetro, uma vela de verdade escavada por dentro ou um copo de vidro jateado. O corpo de uma vela de verdade espalha a luz da forma mais natural.
  • Base da coroa: Decore as quatro velas com galhos de pinheiro artificiais e pinhas, esconda o Nano e a bateria embaixo da base e coloque o botão num canto fácil de alcançar.
  • Temperatura de cor: Se você usar LEDs branco quente, uma película transparente laranja na frente deles aproxima a luz da cor de uma chama de verdade.

Erros comuns e soluções

SintomaCausa provávelSolução
O LED não tremula, fica só aceso ou apagadoO LED está num pino sem PWMMude o LED para o pino 3, 5, 6, 9, 10 ou 11
A chama se agita como uma lâmpada fluorescente com defeitoSMOOTH está pequeno demais ou o alvo muda a cada passoColoque SMOOTH em 4–6 e baixe CHANGE_CHANCE para menos de 10
Todas as velas tremulam do mesmo jeito ao mesmo tempoUma única variável level é escrita em todos os pinosUse arrays level e target separados para cada vela
A placa não acorda do repousoO botão não está no D2 ou a interrupção não é por nível LOWLigue o botão no D2 e use attachInterrupt(..., LOW)
O mesmo padrão de tremulação toda vez que ligarandomSeed não foi chamado ou o A0 está ligado a alguma coisaChame randomSeed(analogRead(A0)) com um pino analógico desconectado
A bateria acaba em poucos diasO LED de alimentação e o chip USB do Nano consomem corrente mesmo em repousoUse um carregador ou troque por um Pro Mini sem o LED de alimentação
Observe uma vela de verdade num cômodo escuro por alguns minutos e conte com que frequência o brilho muda; depois ajuste STEP_MS e CHANGE_CHANCE de acordo com o que você viu. A maioria das chamas oscila visivelmente duas ou três vezes por segundo e só se curva de verdade uma vez a cada poucos minutos.

Esta vela LED, feita com alguns LEDs, alguns resistores e um botão, reúne PWM, temporização com millis(), EEPROM, modo de repouso e cálculo de bateria num único projeto aconchegante. Você pode levar o efeito de vela para os seus próprios projetos consultando, no app BlueGrays, os esquemas de circuito e os códigos passo a passo de projetos básicos de luz, como acender um LED, ligar e desligar um LED com botão, fazer uma transição suave de cores com um LED RGB e controlar o brilho por PWM com ESP32 ou Pico.

Perguntas frequentes

Como fazer uma vela LED tremulante com Arduino?

Ligue o LED através de um resistor de 220 Ω a um dos pinos PWM do Arduino e mude o brilho dele de forma aleatória, mas suave, com analogWrite(). O melhor resultado vem de escolher um brilho-alvo aleatório e aproximar o brilho atual devagar dele a cada passo. Quedas profundas ocasionais imitam a chama se curvando com uma corrente de ar.

Qual cor de LED devo usar para uma vela LED?

LEDs amarelos ou laranja (âmbar) são os que mais se aproximam da cor de uma chama de verdade. LEDs branco quente são mais brilhantes e lembram as velas LED modernas, mas ficam fracos em placas de 3,3 V. LEDs azuis e branco frio não parecem uma chama.

Qual resistor devo usar para ligar um LED ao Arduino?

Em 5 V, um resistor de 220 Ω para um LED amarelo ou vermelho e de 150 Ω para um LED branco quente dão cerca de 12–14 mA, o que é seguro. O valor é calculado com (tensão de alimentação − tensão do LED) / corrente desejada. Deixar o resistor de fora pode danificar tanto o LED quanto o pino do Arduino.

Quais pinos do Arduino têm PWM?

No Arduino Uno e no Nano, os pinos PWM são 3, 5, 6, 9, 10 e 11, marcados com ~ na placa. Os pinos 5 e 6 funcionam a cerca de 980 Hz e os outros a cerca de 490 Hz. No Raspberry Pi Pico, todos os pinos GPIO podem gerar PWM.

Quanto tempo uma vela LED com Arduino dura com pilhas?

Uma coroa com quatro velas num Nano consome cerca de 50 mA; com três pilhas AA de 2,000 mAh, contando as perdas no repouso, isso dá cerca de cinco noites de 6 horas. Um power bank de 10,000 mAh dura cerca de 16 noites. Para uma autonomia longa, use um Pro Mini sem o LED de alimentação junto com o modo de repouso.

Em que dias se acendem as velas da coroa do Advento?

Na coroa do Advento, acende-se uma vela a mais em cada um dos quatro domingos antes do Natal. Em 2026, esses dias são 29 de novembro, 6 de dezembro, 13 de dezembro e 20 de dezembro. Aperte o botão deste projeto uma vez a cada domingo para aumentar o número de velas acesas.

Ver todos os projetos
LED piscante
AR-1Iniciante

LED piscante

O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

4.6(200)
1246
Dois LEDs piscando alternadamente
AR-2Iniciante

Dois LEDs piscando alternadamente

Dois LEDs piscam rapidamente, um de cada vez: quando um acende, o outro apaga, como se estivessem jogando uma bola de um para o outro.

4.6(110)
362
Ligar e desligar um LED com botão
AR-10Iniciante

Ligar e desligar um LED com botão

Pressione o botão uma vez para acender a luz e outra vez para apagar, como o interruptor do seu quarto.

4.7(103)
177
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
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