Enfeite de Natal com Raspberry Pi Pico: estrela com anel NeoPixel WS2812B
Faça um enfeite de Natal com Raspberry Pi Pico: anel WS2812B de 24 LEDs, efeitos de giro, brilho e neve em MicroPython, troca de modo pelo TTP223, power bank e Pico W.
Neste projeto de enfeite de Natal com Raspberry Pi Pico, você usa um Pico e um anel WS2812B de 24 LEDs para montar uma estrela de Natal luminosa que gira, cintila e faz nevar, pronta para pendurar na árvore. Você escreve o código com o módulo neopixel que já vem no MicroPython, alterna entre os efeitos com um sensor de toque TTP223 e faz o enfeite funcionar sem cabo na tomada, com um power bank USB. Quase não há solda, o custo total é baixo e, quando terminar, você terá um enfeite para reutilizar todo ano.
Neste guia você vai ver como o anel funciona, a ligação correta no Pico, um primeiro sketch de teste, os pequenos truques de matemática por trás de cada um dos cinco efeitos, uma tabela de efeitos e brilho, um programa completo que lembra o último modo escolhido e o cálculo de quantas horas ele funciona com um power bank. Na última seção, você vai deixar o mesmo enfeite controlável pelo navegador do celular com um Pico W.

Por que um Pico e um anel WS2812B?
O WS2812B é um LED endereçável que reúne chips vermelho, verde e azul e um pequeno CI driver no mesmo encapsulamento 5050. O Pico envia dados de cor de 24 bits pela linha de dados, um atrás do outro; o primeiro LED pega a sua parte e repassa o resto para o próximo. Assim, um único pino GPIO consegue acender cada um dos 24 LEDs com a sua própria cor. O formato de anel cabe direitinho dentro de uma estrela ou de uma bola de Natal. Como o módulo neopixel já vem pronto no firmware MicroPython do Pico, você começa a programar sem baixar nenhuma biblioteca; para o básico do WS2812B, veja o guia LED WS2812B NeoPixel.
| Característica | Valor |
|---|---|
| Número de LEDs | 24 × WS2812B (SMD 5050) |
| Diâmetro externo | Cerca de 6,5–8,5 cm (varia conforme o fabricante) |
| Alimentação | 5 V (aproximadamente 3,5–5,3 V) |
| Corrente | Até ~20 mA por canal de cor por LED; ~60 mA por LED no branco total |
| Corrente em repouso | Cerca de 0,5–1 mA por LED, mesmo com os LEDs apagados |
| Dados | Linha única, 800 kHz; atualizar 24 LEDs leva cerca de 0,7 ms |
| Pinos | DI (entrada de dados), DO (saída de dados), 5V, GND |
Materiais
- Raspberry Pi Pico (um Pico W ou Pico 2 W se você quiser escolher as cores pelo celular) e um cabo micro USB que transmita dados.
- Anel WS2812B de 24 LEDs: anéis de 12 ou 16 LEDs também funcionam; basta mudar o valor de N no código.
- Módulo sensor de toque TTP223: para trocar de modo. Você pode usar um botão de pressão comum no lugar.
- Resistor de 330 Ω (para a linha de dados) e, opcionalmente, um capacitor eletrolítico de 100–470 µF.
- Power bank USB: 5,000–10,000 mAh é suficiente. Se a árvore estiver perto de uma tomada, um carregador USB também serve.
- Corpo do enfeite: uma estrela de papelão, espuma ou plástico impresso em 3D; papel vegetal ou espuma branca fina para suavizar a luz.
Tabela de ligações
| Ligação | Pino do Pico | Pino físico | Observação |
|---|---|---|---|
| DI do anel (entrada de dados) | GP0 | 1 | Resistor de 330 Ω no meio |
| 5V do anel | VBUS | 40 | 5 V vindos do USB |
| GND do anel | GND | 38 | O terminal negativo do capacitor também vai aqui |
| VCC do TTP223 | 3V3(OUT) | 36 | Funciona com 3,3 V |
| I/O do TTP223 | GP15 | 20 | HIGH ao tocar (A e B abertos) |
| GND do TTP223 | GND | 23 | Qualquer pino GND serve |

Primeiro teste: acendendo o anel com o módulo neopixel
1from machine import Pin
2import neopixel, time
3
4N = 24 # halkadaki LED sayısı / LEDs on the ring
5np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
6
7for i in range(N):
8 np[i] = (40, 0, 0) if i % 2 == 0 else (0, 40, 0) # kırmızı-yeşil sıra / red-green pattern
9 np.write() # renkleri halkaya gönder / send colours to the ring
10 time.sleep_ms(50)Ao rodar o código no Thonny, os LEDs do anel devem acender um a um em vermelho e verde. Mantivemos os valores de cor em 40 de propósito: 255 ofusca e puxa corrente desnecessária durante um teste. A linha np[i] = (r, g, b) define na memória a cor do LED número i, mas nada muda no anel ainda; as cores só são enviadas quando np.write() é chamado. Na verdade, o WS2812B espera as cores na ordem verde, vermelho, azul (GRB); o módulo neopixel cuida disso para você, então você sempre escreve (vermelho, verde, azul). Se o anel não acender de jeito nenhum, talvez você tenha ligado os dados na ponta errada: eles devem ir para a ilha marcada DI ou IN, enquanto DO ou OUT vai para o próximo anel.
Tabela de efeitos e brilho
| Modo | Efeito | Cores | Tempo do quadro | Corrente aprox. (brilho 0,2, anel + Pico) |
|---|---|---|---|---|
| 0 | Cometa girando | Uma volta vermelha, uma volta verde | 40 ms | ~65 mA |
| 1 | Cintilação dourada | Luz de fundo quente + faíscas douradas aleatórias | 60 ms | ~70 mA |
| 2 | Neve caindo | Fundo azul-noite, flocos de neve brancos | 40 ms | ~110 mA |
| 3 | Estrela respirando | Amarelo dourado, clareando e apagando devagar | 30 ms | ~125 mA |
| 4 | Arco-íris girando | A roda de cores inteira | 30 ms | ~145 mA |
Uma forma aproximada de calcular a corrente: cada canal de cor puxa cerca de 20 mA no valor máximo (255) e proporcionalmente menos em valores menores. Então um LED puxa aproximadamente 20 mA × (r + g + b) / 255; some cerca de 1 mA de corrente em repouso por LED e os 20–25 mA do próprio Pico. O código tem três níveis de brilho: 0,08 (fraco, para a noite), 0,2 (padrão) e 0,4 (para a luz do dia). Passar de 0,4 cansa os olhos e encurta rapidamente a duração da bateria.
Código completo: cinco efeitos e troca de modo com o TTP223
Salve o programa abaixo no Pico como main.py pelo Thonny, para que o enfeite comece sozinho assim que for ligado ao power bank. Um toque curto no TTP223 passa para o próximo efeito; um toque com mais de 0,7 segundo muda o nível de brilho. A sua escolha é gravada no arquivo susu.txt e o enfeite começa com o mesmo efeito na próxima vez.
1from machine import Pin
2import neopixel, time, random, math
3
4N = 24 # halkadaki LED sayısı / LEDs on the ring
5np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
6touch = Pin(15, Pin.IN) # TTP223 I/O (A ve B açık / A and B open)
7
8LEVELS = (0.08, 0.2, 0.4) # parlaklık kademeleri / brightness steps
9FRAME_MS = (40, 60, 40, 30, 30) # her efektin kare süresi / frame time of each effect
10NAMES = ("donen", "parilti", "kar", "nefes", "gokkusagi")
11LONG_MS = 700 # uzun dokunuş / long touch
12
13buf = [[0, 0, 0] for _ in range(N)] # ham renkler 0-255 / raw colours 0-255
14flakes = [] # kar taneleri / snowflakes
15step = 0
16
17
18def load():
19 try:
20 with open("susu.txt") as f:
21 m, b = f.read().split(",")
22 return int(m) % len(NAMES), int(b) % len(LEVELS)
23 except (OSError, ValueError):
24 return 0, 1
25
26
27def save():
28 with open("susu.txt", "w") as f:
29 f.write("%d,%d" % (mode, level))
30
31
32def show():
33 k = LEVELS[level]
34 for i in range(N):
35 r, g, b = buf[i]
36 np[i] = (int(r * k), int(g * k), int(b * k))
37 np.write()
38
39
40def fade(f):
41 for c in buf:
42 c[0] = int(c[0] * f)
43 c[1] = int(c[1] * f)
44 c[2] = int(c[2] * f)
45
46
47def wheel(h): # 0-255 renk tekerleği / 0-255 colour wheel
48 h %= 256
49 if h < 85:
50 return [255 - h * 3, h * 3, 0]
51 if h < 170:
52 h -= 85
53 return [0, 255 - h * 3, h * 3]
54 h -= 170
55 return [h * 3, 0, 255 - h * 3]
56
57
58def spinning(): # dönen kuyruklu yıldız / spinning comet
59 fade(0.7)
60 head = step % N
61 buf[head] = [255, 0, 0] if (step // N) % 2 == 0 else [0, 255, 0]
62
63
64def twinkle(): # altın parıltı / golden sparkle
65 fade(0.88)
66 for c in buf: # sıcak taban ışığı / warm base glow
67 c[0] = max(c[0], 30)
68 c[1] = max(c[1], 10)
69 if random.randint(0, 99) < 35:
70 buf[random.randint(0, N - 1)] = [255, 170, 40]
71
72
73def snow(): # tepeden iki yana akan kar / snow falling down both sides
74 for c in buf:
75 c[0], c[1], c[2] = 0, 0, 25 # gece mavisi / night blue
76 for j in range(len(flakes)): # her tane bir LED aşağı / each flake moves one LED down
77 flakes[j] += 1
78 while flakes and flakes[0] > N // 2:
79 flakes.pop(0) # en alta ulaşan silinir / remove flakes at the bottom
80 if random.randint(0, 99) < 20:
81 flakes.append(0) # tepede yeni tane / new flake at the top
82 for k in flakes:
83 buf[k % N] = [230, 230, 255]
84 buf[(N - k) % N] = [230, 230, 255]
85
86
87def breathe(): # yıldız nefesi / breathing star
88 v = (1 - math.cos(step * 2 * math.pi / 100)) / 2
89 for i in range(N):
90 buf[i] = [int(255 * v), int(150 * v), int(20 * v)]
91
92
93def rainbow(): # dönen gökkuşağı / rotating rainbow
94 for i in range(N):
95 buf[i] = wheel(i * 256 // N + step * 3)
96
97
98EFFECTS = (spinning, twinkle, snow, breathe, rainbow)
99mode, level = load()
100touch_start = None
101
102while True:
103 if touch.value() and touch_start is None:
104 touch_start = time.ticks_ms() # dokunuş başladı / touch started
105 elif not touch.value() and touch_start is not None:
106 held = time.ticks_diff(time.ticks_ms(), touch_start)
107 touch_start = None
108 if held >= LONG_MS:
109 level = (level + 1) % len(LEVELS) # uzun: parlaklık / long: brightness
110 else:
111 mode = (mode + 1) % len(NAMES) # kısa: sonraki efekt / short: next effect
112 flakes = [] # karı sıfırla / reset the snow
113 save()
114 print("efekt / effect:", NAMES[mode], "parlaklik / brightness:", LEVELS[level])
115
116 EFFECTS[mode]()
117 show()
118 step += 1
119 time.sleep_ms(FRAME_MS[mode])| Código | O que faz |
|---|---|
| buf | Guarda as cores brutas dos 24 LEDs, de 0 a 255; os efeitos sempre escrevem aqui |
| show() | Multiplica as cores brutas pelo brilho selecionado e as envia ao anel; o brilho é aplicado em um só lugar |
| fade(f) | Escurece cada LED pelo fator f; 0,7 deixa um rastro curto, 0,88 um rastro longo |
| wheel(h) | Transforma um único número de 0 a 255 em uma cor que mistura vermelho, verde e azul |
| touch_start / held | Mede quanto tempo durou o toque; o limite de 700 ms separa toques curtos e longos |
| load() / save() | Grava o modo e o brilho no sistema de arquivos do Pico e os lê de volta na inicialização |
Como os efeitos funcionam?
O cometa girando escurece o anel inteiro em 30 por cento a cada quadro e acende o próximo LED com brilho total. Como os LEDs anteriores apagam um pouco mais a cada quadro, uma cauda suave se forma sozinha atrás da cabeça: 0,7 × 0,7 × 0,7 ≈ 0,34, ou seja, um LED três quadros atrás fica com um terço do brilho original. Cada vez que a cabeça completa uma volta, ela troca de vermelho para verde ou vice-versa. O efeito cintilação dourada escurece o anel mais devagar, mas nunca deixa nenhum LED cair abaixo de uma luz de fundo quente; a cada quadro, com 35 por cento de chance, um LED aleatório brilha em dourado e vai apagando devagar.
A neve caindo trata o LED no topo do anel (número 0) como o céu e o da parte de baixo (número 12) como o chão. Um novo floco de neve nasce no topo e desce um LED por quadro; o mesmo floco é espelhado nos dois lados do anel, então a neve parece descer pelos dois lados ao mesmo tempo. A estrela respirando leva o brilho suavemente de zero a um e de volta com a fórmula (1 − cos(2π × passo / 100)) / 2; com quadros de 30 ms, uma respiração leva cerca de 3 segundos. O arco-íris dá a cada LED uma matiz igualmente espaçada na roda de cores e desloca todas as matizes um pouco a cada quadro.
Funcionamento com power bank e duração da bateria
A capacidade impressa no power bank é a capacidade das suas células de 3,7 V. Como a saída é de 5 V e o conversor trabalha com cerca de 85 por cento de eficiência, a capacidade que você realmente pode usar é capacidade × 3,7 / 5 × 0,85; um power bank de 10,000 mAh fornece cerca de 6,300 mAh em 5 V. O tempo de funcionamento é capacidade utilizável / corrente média. Você pode testar outros valores de bateria e corrente com a calculadora de autonomia da bateria.
| Brilho | Corrente total no modo arco-íris | Power bank de 5,000 mAh | Power bank de 10,000 mAh |
|---|---|---|---|
| 0,08 (fraco) | ~85 mA | ~37 horas | ~74 horas |
| 0,2 (padrão) | ~145 mA | ~22 horas | ~43 horas |
| 0,4 (forte) | ~240 mA | ~13 horas | ~26 horas |
Escolhendo cores pelo celular com um Pico W
Se você usa um Pico W ou Pico 2 W, pode adicionar uma pequena página web ao enfeite. O programa abaixo se conecta ao Wi-Fi da sua casa, mostra um endereço IP no Shell e, quando você abre esse endereço no celular, aparece um seletor de cores e uma lista de efeitos. A cor escolhida aparece na hora no anel, no modo fixo, cintilação ou arco-íris. As luzes e o servidor web rodam lado a lado com asyncio; um não espera pelo outro. O básico do servidor web está explicado em detalhes no guia servidor web com Pico W.
1import network, asyncio, neopixel, random, time
2from machine import Pin
3
4SSID = "AgAdi" # Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
5PASSWORD = "Sifre123" # Wi-Fi şifren / your Wi-Fi password
6N = 24
7np = neopixel.NeoPixel(Pin(0), N) # DIN -> 330 ohm -> GP0
8BRIGHT = 0.2 # genel parlaklık / overall brightness
9
10color = [255, 120, 20] # telefondan seçilen renk / colour picked on the phone
11mode = 1 # 0 sabit, 1 parıltı, 2 gökkuşağı / 0 solid, 1 sparkle, 2 rainbow
12
13PAGE = """<!DOCTYPE html><html><head><meta charset="utf-8">
14<meta name="viewport" content="width=device-width, initial-scale=1"><title>Noel Susu</title></head>
15<body style="font-family:sans-serif;text-align:center">
16<h2>Noel Susu / Ornament</h2>
17<form action="/" method="get">
18<p><input type="color" name="c" value="#ff7814" style="width:120px;height:80px"></p>
19<p><select name="m"><option value="0">Sabit / Solid</option><option value="1" selected>Parilti / Sparkle</option>
20<option value="2">Gokkusagi / Rainbow</option></select></p>
21<p><button style="font-size:22px">Uygula / Apply</button></p>
22</form></body></html>"""
23
24
25def connect():
26 wlan = network.WLAN(network.STA_IF)
27 wlan.active(True)
28 wlan.connect(SSID, PASSWORD)
29 for _ in range(20):
30 if wlan.isconnected():
31 break
32 time.sleep(1)
33 print("Telefonda ac / open on the phone: http://" + wlan.ifconfig()[0])
34
35
36def parse(query):
37 global mode
38 for part in query.split("&"):
39 if part.startswith("c=") and len(part) >= 8:
40 hexcode = part[-6:] # "%23ff7814" -> "ff7814"
41 color[0] = int(hexcode[0:2], 16)
42 color[1] = int(hexcode[2:4], 16)
43 color[2] = int(hexcode[4:6], 16)
44 elif part.startswith("m=") and part[2:].isdigit():
45 mode = int(part[2:]) % 3
46
47
48async def handle(reader, writer):
49 line = await reader.readline() # "GET /?c=%23ff7814&m=1 HTTP/1.1"
50 while True: # başlıkları atla / skip the headers
51 h = await reader.readline()
52 if not h or h == b"\r\n":
53 break
54 try:
55 path = line.decode().split(" ")[1]
56 if "?" in path:
57 parse(path.split("?", 1)[1])
58 except (IndexError, ValueError):
59 pass
60 writer.write(b"HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n")
61 writer.write(PAGE.encode())
62 await writer.drain()
63 writer.close()
64 await writer.wait_closed()
65
66
67def wheel(h):
68 h %= 256
69 if h < 85:
70 return (255 - h * 3, h * 3, 0)
71 if h < 170:
72 h -= 85
73 return (0, 255 - h * 3, h * 3)
74 h -= 170
75 return (h * 3, 0, 255 - h * 3)
76
77
78async def lights():
79 step = 0
80 while True:
81 for i in range(N):
82 if mode == 0:
83 c = color
84 elif mode == 1: # rastgele LED'ler parlar / random LEDs flare
85 k = 1.0 if random.randint(0, 99) < 8 else 0.25
86 c = [int(x * k) for x in color]
87 else:
88 c = wheel(i * 256 // N + step * 3)
89 np[i] = (int(c[0] * BRIGHT), int(c[1] * BRIGHT), int(c[2] * BRIGHT))
90 np.write()
91 step += 1
92 await asyncio.sleep_ms(60 if mode == 1 else 30)
93
94
95async def main():
96 connect()
97 await asyncio.start_server(handle, "0.0.0.0", 80)
98 await lights() # ışıklar sonsuza kadar döner / lights run forever
99
100
101asyncio.run(main())Quando o navegador envia o formulário, o endereço fica parecido com /?c=%23ff7814&m=1: %23 é o sinal # no início do código de cor. A função parse() pega os seis últimos caracteres e os divide em três números hexadecimais de dois dígitos, os valores de vermelho, verde e azul. O celular e o Pico precisam estar na mesma rede; o Pico W só se conecta a redes de 2,4 GHz. Se você não quiser um IP diferente a cada inicialização, reserve um IP fixo para o Pico nas configurações do roteador.
Montagem do enfeite e dicas de acabamento
- Suavize a luz: coloque papel vegetal ou espuma branca a 1–2 cm na frente do anel. Assim os LEDs parecem uma única estrela brilhante em vez de pontos separados.
- Coloque dentro de uma estrela: recorte duas estrelas de papelão, cole o anel entre elas, deixe o Pico e o power bank no pé da árvore e passe os três fios (5V, GND, dados) entre os galhos em um cabo verde.
- Esconda o sensor de toque: prenda o TTP223 com fita na parte de trás do enfeite. O sensor também funciona através de 1–2 mm de papelão ou plástico.
- Vários enfeites: ligue o DO do primeiro anel ao DI do segundo e defina N como 48 para controlar dois enfeites com um só pino; dobre o seu cálculo de alimentação.
- Cuidado com o calor: com brilho 0,2 o anel nem chega a esquentar, mas se ele for funcionar por horas em 0,4 dentro de uma caixa fechada, faça pequenos furos de ventilação.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| Nenhum LED acende | Os dados estão na ilha DO ou o GND não é comum | Ligue os dados no DI e una o GND do anel ao GND do Pico |
| O primeiro LED pisca, cores aleatórias | O sinal de dados de 3,3 V está no limite ou o fio é longo | Encurte o fio de dados, acrescente o resistor de 330 Ω e use um conversor de nível lógico se necessário |
| Cores erradas (verde no lugar de vermelho) | O anel usa outra ordem de cores (por ex. RGB em vez de GRB) | Acrescente np.ORDER = (0, 1, 2, 3) depois da linha np = neopixel.NeoPixel(...) e teste de novo |
| O sensor de toque não responde | O TTP223 se calibrou com um dedo encostado ao ser ligado | Afaste a mão e desconecte e reconecte o USB do Pico; não toque no sensor na inicialização |
| O Pico não inicia o efeito ao ser ligado | O arquivo não foi salvo como main.py | No Thonny: Salvar como > Raspberry Pi Pico > main.py |
| O enfeite apaga depois de alguns minutos | O power bank se desliga com corrente baixa | Use um power bank com modo de baixa corrente ou aumente o brilho mínimo |
Este enfeite de Natal, feito com um Pico, um anel de 24 LEDs e um sensor de toque, ensina LEDs endereçáveis, controle de brilho sem PWM, gravação de configurações em arquivo e cálculos de bateria em um único projeto. Você pode adicionar novos efeitos ao seu enfeite consultando, no app BlueGrays, os esquemas do circuito e códigos passo a passo de projetos básicos de luz com o Pico, como LED com fade, ciclo de cores RGB e LEDs sequenciais, além de projetos com WS2812B, como luz de polícia e animações.
Perguntas frequentes
O Raspberry Pi Pico consegue controlar LEDs WS2812B diretamente?
Sim. O módulo neopixel do MicroPython já vem pronto no Pico e cuida sozinho da temporização precisa do WS2812B. A linha de dados pode ir para qualquer pino GP; os LEDs, porém, devem ser alimentados com 5 V pelo VBUS, e não pelo pino de 3,3 V do Pico.
Quanta corrente um anel WS2812B de 24 LEDs consome?
Cada LED puxa cerca de 60 mA no branco total, então o pior caso para 24 LEDs é de cerca de 1,44 A. Com efeitos reais e brilho 0,2, isso cai para algo em torno de 60–150 mA. Limitar o brilho no código aumenta a duração da bateria e evita sobrecarregar a linha USB.
O sinal de dados de 3,3 V do Pico é suficiente para o WS2812B?
Tecnicamente, o WS2812B pede um nível de dados de cerca de 3,5 V com alimentação de 5 V, mas com um fio curto a maioria dos anéis funciona bem com 3,3 V. Se o primeiro LED piscar, encurte o fio e coloque o resistor de 330 Ω perto do anel. A solução definitiva é um conversor de nível lógico como o 74AHCT125.
Quanto tempo um enfeite de Natal com Pico funciona em um power bank?
Um power bank de 10,000 mAh fornece cerca de 6,300 mAh em 5 V. Com o brilho padrão de 0,2, o enfeite puxa cerca de 145 mA, o que significa mais de 40 horas de funcionamento. Reduzir o brilho pela metade quase dobra esse tempo.
Como faço o código MicroPython rodar automaticamente quando o Pico liga?
Basta salvar o código no Raspberry Pi Pico como main.py pelo Thonny. A cada vez que é ligado, o Pico roda primeiro o boot.py e depois o main.py. Para parar o código, clique em Parar (Stop) no Thonny ou use Ctrl+C.
Dá para controlar luzes de Natal pelo celular com um Pico W?
Sim. O Pico W pode se conectar ao Wi-Fi da sua casa e rodar um pequeno servidor web; ao abrir o endereço IP do Pico no navegador do celular, aparecem um seletor de cores e botões de efeito. Graças ao asyncio, os efeitos de luz e o servidor web funcionam ao mesmo tempo.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

Raspberry Pi Pico: LEDs sequenciais (6 LEDs)
A clássica animação de LEDs sequenciais com o Pico — versão com 6 LEDs! Os 6 LEDs acendem em sequência da esquerda para a direita, como se a luz percorresse a fileira. Aprenda listas em Python, compreensão de listas ([Pin(p, Pin.OUT) for p in LED_PINS]), controle de pinos com laço for e enumerate(). São 6 LEDs nos pinos GP9-GP14, cada um com um resistor limitador de corrente de 220Ω.

Raspberry Pi Pico: efeito Knight Rider com LEDs (6 LEDs em vaivém)
Efeito clássico de LEDs do "Knight Rider" com o Pico! 6 LEDs acendem da esquerda para a direita e depois no sentido contrário, sem parar. Como a grade dianteira do carro KITT da famosa série dos anos 80. Este projeto é uma evolução do projeto LEDs em sequência: o mesmo circuito com 6 LEDs (GP9-GP14), com outro padrão de código. Aprenda a inverter listas com reversed(), usar dois laços for separados para o vaivém e criar várias animações no mesmo circuito.

Uso da fita LED WS2812B
Conheça uma fita LED inteligente em que você pode definir a cor de cada luz individualmente.

LED sequencial com WS2812B
Em uma fita de dez LEDs, um ponto de luz verde avança do início ao fim, um LED por vez, e depois volta ao começo; ele permanece em cada LED por um terço de segundo.

Animação 1 com WS2812B
Em uma fita de 56 LEDs, todas as cores do arco-íris ficam lado a lado e fluem sem parar, como se um rio de luz deslizasse pela fita.

Controle de fita WS2812B NeoPixel com ESP32
Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.
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
