Guias · 12 min de leitura

Projetos com Raspberry Pi Pico para iniciantes: 20 ideias com código

20 projetos com Raspberry Pi Pico para iniciantes, de LEDs e interrupções de botão a PWM, sensores, OLED e servo, com tabela de linguagem, peças e dificuldade.

Procurando projetos com Raspberry Pi Pico para iniciantes e não sabe por onde começar? Esta lista é para você: reunimos 20 projetos do mais fácil ao mais difícil, de piscar um único LED e interrupções de botão a um efeito de respiração com PWM, leitura de sensores, um display OLED e um servo motor. Uma tabela mostra qual linguagem usar em cada projeto (MicroPython ou C/C++), as peças necessárias e a dificuldade, e o projeto mais didático de cada nível vem com código funcionando.

Há três motivos para a Pico ser uma ótima primeira placa: ela é barata, o MicroPython roda o código sem esperar compilação e todos os seus 26 pinos GPIO têm saída PWM. Se você acabou de tirar a sua da caixa, siga primeiro os passos de configuração em O que é a Raspberry Pi Pico?; aqui partimos do princípio de que a sua placa já roda no Thonny e você consegue piscar o LED integrado.

Placa microcontroladora Raspberry Pi Pico
Raspberry Pi Pico: chip RP2040, 26 GPIO, 3 entradas analógicas e PWM em todos os pinos. Todos os projetos desta lista funcionam na Pico, na Pico W e na Pico 2.

Antes de começar: o que você precisa

  • Placa: Raspberry Pi Pico, Pico W ou Pico 2. O projeto sem fio (número 19) precisa de uma Pico W.
  • Protoboard e jumpers: para montar circuitos sem solda; confira se a sua Pico está com as barras de pinos soldadas.
  • LEDs e resistores: 5–10 LEDs e resistores de 220 Ω e 330 Ω; use a calculadora de resistor para LED para escolher os valores.
  • Entradas: 2–3 botões, um potenciômetro de 10 kΩ, um LDR e um resistor de 10 kΩ.
  • Sensores e saídas: HC-SR04, DHT11, PIR HC-SR501, um buzzer passivo, um servo SG90, um OLED SSD1306 de 0,96 polegada e um anel WS2812B com 8–12 LEDs.
  • Software: Thonny para MicroPython; a Arduino IDE com o core RP2040 de Earle Philhower para C/C++.

MicroPython ou C/C++?

A Pico aceita os dois mundos, e a maioria dos projetos desta lista pode ser escrita em qualquer uma das linguagens. No MicroPython você digita o código no Thonny, aperta Executar e vê o resultado em menos de um segundo; quando algo dá errado, aparece uma mensagem clara com o número da linha. O C/C++ (Arduino IDE ou Pico SDK) precisa de compilação, mas roda de 10 a 100 vezes mais rápido e permite usar milhares de bibliotecas escritas para Arduino. Se você está começando, faça os 19 primeiros projetos em MicroPython e passe para C/C++ quando precisar de velocidade ou de uma biblioteca pronta.

CritérioMicroPythonC/C++ (com Arduino IDE)
Curva de aprendizadoFácil, Python básico bastaFamiliar se você conhece Arduino
Rodar o códigoNa hora (com o Thonny)Compilar e carregar: 10–30 segundos
VelocidadeMais lento, mas suficiente para a maioria dos projetosDe 10 a 100 vezes mais rápido
BibliotecasMódulos integrados como machine, neopixel, dhtA maioria das bibliotecas do Arduino
Melhor paraAprender, ler sensores, testes rápidosTempo preciso, teclados USB, cálculos pesados

20 projetos com Raspberry Pi Pico: linguagem, peças e dificuldade

NºProjetoLinguagem sugeridaPeças necessáriasDificuldade
1Piscar o LED integradoMicroPythonSó a PicoFácil
2LED externo (GP14)MicroPythonLED, resistor de 220 ΩFácil
3SemáforoMicroPythonLEDs vermelho, amarelo e verde, 3 resistoresFácil
4Efeito de sirene de políciaMicroPythonLEDs vermelho e azul, 2 resistoresFácil
5Varredura estilo Knight RiderMicroPython6 LEDs, 6 resistoresFácil
6Ligar e desligar um LED com um botãoMicroPythonBotão, LED, resistorFácil
7Interrupção de botão (IRQ) e debounceMicroPythonBotão, LED, resistorMédio
8LED respirando com PWMMicroPythonLED, resistorFácil
9Ciclo de cores com LED RGBMicroPythonLED RGB, 3 resistoresFácil
10Tocar uma melodia em um buzzer passivoMicroPythonBuzzer passivoFácil
11Brilho do LED com potenciômetroMicroPythonPotenciômetro de 10 kΩ, LEDFácil
12Sensor de temperatura integradoMicroPythonSó a PicoFácil
13Luz noturna automática com LDRMicroPythonLDR, resistor de 10 kΩ, LEDFácil
14Alarme de movimento com PIRMicroPythonHC-SR501, buzzer ativoFácil
15Medidor de distância com HC-SR04MicroPythonHC-SR04, resistores de 1 kΩ e 2 kΩMédio
16Termômetro com OLEDMicroPythonOLED SSD1306, DHT11Médio
17Controle de servo com potenciômetroMicroPythonServo SG90, potenciômetro de 10 kΩMédio
18Animação em anel de LEDs WS2812BMicroPythonAnel WS2812B (8–12 LEDs)Médio
19Controlar um LED por Wi-Fi com a Pico WMicroPythonPico W, LEDDifícil
20Teclado de macros USBC/C++ (com Arduino IDE)3–4 botõesDifícil

A ordem não é aleatória: cada projeto acrescenta um passo ao que você aprendeu no anterior. Os seis primeiros ensinam saída e entrada digital, do 7 ao 10 entram interrupções e PWM, do 11 ao 15 sensores analógicos e digitais, do 16 ao 18 um display, um servo e LEDs controlados por PIO, e os dois últimos mostram recursos próprios da Pico, como Wi-Fi e USB. A seguir, passamos por cada nível com o seu circuito e damos o código dos projetos mais didáticos.

Nível 1: projetos com LED e botão (1–6)

No primeiro projeto você pisca o LED integrado com Pin(25) (na Pico W e na Pico 2 W, use Pin("LED")). No segundo, você liga um LED externo ao GP14 (pino físico 19) por meio de um resistor de 220 Ω; o resistor pode ficar na perna longa ou na curta, desde que esteja em série. O semáforo acende em sequência os três LEDs no GP11, GP12 e GP13, a sirene de polícia pisca um LED vermelho e um azul em rajadas rápidas, e a varredura Knight Rider faz uma luz ir e voltar por seis LEDs no GP9–GP14. Nesses três projetos, guardar os pinos em uma lista e percorrê-la com um laço for corta o seu código pela metade.

No projeto seis, o botão vai ao GP2 com a outra perna no GND, e o resistor de pull-up interno da Pico é ativado; assim o pino lê 1 com o botão solto e 0 com o botão pressionado. Para alternar o LED a cada toque, você precisa guardar o estado anterior do botão em uma variável e contar só a mudança de 1 para 0. Por que os botões têm bouncing e como funcionam os pull-ups você encontra em Como ligar um botão no Arduino; as mesmas regras valem para a Pico.

Nível 2: interrupções de botão, PWM e som (7–10)

Verificar um botão sem parar dentro do loop (polling) funciona em projetos simples, mas o seu código pode perder toques enquanto está ocupado com outra coisa. Com uma interrupção (IRQ), a Pico chama a sua função no instante em que o pino muda de nível. O código abaixo é o projeto 7 inteiro: cada toque alterna o LED no GP14, e um filtro de tempo de 200 ms impede que o bouncing mecânico seja lido como toque duplo.

MicroPython
1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT)                     # GP14 + 220 Ω direnç / GP14 + 220 Ω resistor
5button = Pin(2, Pin.IN, Pin.PULL_UP)       # butonun diğer ucu GND / other leg to GND
6last_ms = 0                                # son geçerli basış / last valid press
7
8def on_press(pin):
9    global last_ms
10    now = time.ticks_ms()
11    if time.ticks_diff(now, last_ms) > 200:   # 200 ms sıçrama filtresi / 200 ms debounce
12        led.toggle()
13        last_ms = now
14
15button.irq(trigger=Pin.IRQ_FALLING, handler=on_press)   # basınca 1→0 / press pulls 1→0
16
17while True:
18    time.sleep(1)                          # ana döngü boşta, iş kesmede / main loop idle, work in the IRQ
Mantenha a função de interrupção curta: nada de longas sequências de print, nada de time.sleep e nada de montar listas grandes dentro dela. O jeito mais limpo é só mudar uma variável de sinalização na interrupção e fazer o trabalho de verdade no loop principal. Para comparar tempos, use sempre time.ticks_diff(); ele dá a resposta certa mesmo quando o contador dá a volta.

O projeto oito é o exemplo clássico de PWM. Todo pino GPIO da Pico tem saída PWM, e no MicroPython você define o ciclo de trabalho com duty_u16(), de 0 a 65535. Se você aumentar o brilho de forma linear, o olho não vai achar natural: a mudança parece rápida demais nos níveis baixos e lenta demais nos altos. O código abaixo usa uma curva de cosseno para um ritmo de respiração suave e eleva o valor ao quadrado para obter uma curva de brilho mais próxima de como o olho percebe a luz. A explicação está em O que é PWM?

MicroPython
1from machine import Pin, PWM
2import math, time
3
4led = PWM(Pin(14))
5led.freq(1000)                             # 1 kHz, titreme görünmez / 1 kHz, no visible flicker
6
7while True:
8    for step in range(200):
9        level = (1 - math.cos(step / 200 * 2 * math.pi)) / 2   # 0 → 1 → 0 yumuşak / smooth 0 → 1 → 0
10        led.duty_u16(int(level * level * 65535))             # kare alma göze doğal gelir / squaring looks natural
11        time.sleep_ms(15)                                      # 200 × 15 ms = 3 s bir nefes / one 3 s breath

No projeto nove, você aplica a mesma ideia a três canais: ligue as pernas vermelha, verde e azul de um LED RGB ao GP11, GP12 e GP13, cada uma com um resistor, e defase os três valores de duty para que as cores se misturem. Em LEDs de anodo comum, lembre-se de inverter os valores; os detalhes estão em Como usar um LED RGB. No projeto dez, você muda a frequência do PWM: ligue um buzzer passivo a um pino, chame freq(440) e ele toca a nota lá; um duty de 32768 (50 por cento) dá o som mais alto, e percorrer uma lista de notas gera uma melodia.

Nível 3: projetos com sensores (11–15)

As entradas analógicas da Pico são GP26, GP27 e GP28, e read_u16() retorna um valor de 0 a 65535 (o chip mede 12 bits internamente e o MicroPython escala o resultado para 16 bits). No projeto onze, você liga o pino do meio de um potenciômetro ao GP26 e escreve a leitura direto no duty do LED. O projeto doze não precisa de peças extras: o canal 4 do ADC está ligado a um sensor de temperatura dentro do chip, e a temperatura é T = 27 − (V − 0.706) / 0.001721. Como ele mede o chip e não o ambiente, espere alguns graus de diferença. No projeto treze, você monta um divisor de tensão com um LDR e um resistor de 10 kΩ e acende um LED quando a leitura passa de um limite de escuridão; a calculadora de divisor de tensão facilita as contas.

O sensor PIR HC-SR501 do projeto catorze é alimentado com 5 V, mas a saída dele é de 3,3 V, então pode ir direto a um GPIO; quando detecta movimento, o pino vai para 1 por alguns segundos. Para os ajustes de tempo e sensibilidade, veja Sensor de movimento PIR. O projeto quinze pede um pouco mais de cuidado: o HC-SR04 funciona com 5 V e o pino ECHO dele envia um pulso de 5 V. O código abaixo manda um pulso de 10 microssegundos ao TRIG, mede a duração do eco com time_pulse_us() e calcula a distância pela velocidade do som.

MicroPython
1from machine import Pin, time_pulse_us
2import time
3
4trig = Pin(17, Pin.OUT)                    # GP17 → TRIG
5echo = Pin(16, Pin.IN)                     # GP16 ← ECHO (1 kΩ + 2 kΩ bölücüyle / through a 1k + 2k divider)
6
7def distance_cm():
8    trig.low()
9    time.sleep_us(2)
10    trig.high()
11    time.sleep_us(10)                      # 10 µs tetik darbesi / 10 µs trigger pulse
12    trig.low()
13    t = time_pulse_us(echo, 1, 30000)      # en çok 30 ms bekle (~5 m) / wait up to 30 ms (~5 m)
14    if t < 0:
15        return None                        # yankı yok / no echo
16    return t * 0.0343 / 2                  # 343 m/s, gidiş-dönüş / round trip
17
18while True:
19    d = distance_cm()
20    print("Mesafe / Distance:", "---" if d is None else "%.1f cm" % d)
21    time.sleep_ms(200)
Não ligue o pino ECHO do HC-SR04 direto na Pico: os pinos dela não toleram 5 V. Coloque um resistor de 1 kΩ entre o ECHO e o GP16 e um de 2 kΩ entre o GP16 e o GND, o que reduz o pulso de 5 V para cerca de 3,3 V. Se você usar as versões de 3,3 V, HC-SR04P ou RCWL-1601, não precisa do divisor.

Nível 4: display OLED, servo e NeoPixel (16–18)

No projeto dezesseis, você mostra a temperatura e a umidade de um DHT11 em um display OLED de 0,96 polegada. O módulo dht de que o DHT11 precisa já vem no firmware MicroPython da Pico; para o OLED, você copia o arquivo de driver ssd1306.py para a Pico. O display se liga por I2C ao GP4 (SDA) e ao GP5 (SCL). O código do display está em Como usar o display OLED SSD1306, e o sensor em Sensor de temperatura e umidade DHT11.

No projeto dezessete, você gira um servo SG90 com um potenciômetro. O servo espera um sinal de 50 Hz e lê o ângulo pela largura do pulso: cerca de 500 microssegundos é 0 grau e 2500 microssegundos são 180 graus. No MicroPython, duty_ns() deixa você escrever a largura do pulso direto em nanossegundos, o que deixa as contas bem simples:

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15))                       # GP15 → servo sinyal (turuncu) / signal (orange)
5servo.freq(50)                             # 50 Hz = 20 ms periyot / 20 ms period
6pot = ADC(26)                              # GP26 (ADC0) ← potansiyometre orta ucu / pot wiper
7
8def set_angle(angle):
9    pulse_us = 500 + angle * 2000 // 180   # 0° = 500 µs, 180° = 2500 µs
10    servo.duty_ns(pulse_us * 1000)
11
12while True:
13    angle = pot.read_u16() * 180 // 65535  # 0–65535 → 0–180°
14    set_angle(angle)
15    time.sleep_ms(20)                      # her periyotta bir güncelleme / one update per period
Não alimente o servo pelo pino 3V3 da Pico. Um SG90 pode puxar picos de mais de 500 mA enquanto se move, o que reinicia a Pico ou faz o servo tremer. Ligue o fio vermelho do servo aos 5 V que vêm do USB (VBUS, pino físico 40) ou a uma fonte externa de 5 V e o fio marrom ao GND; se usar uma fonte externa, sempre ligue os dois GNDs juntos. Veja O que é um servo motor? para os detalhes.

No projeto dezoito, você controla um anel de LEDs WS2812B com o módulo integrado neopixel do MicroPython. Esses LEDs precisam de tempo preciso na casa dos microssegundos, e a Pico dá conta disso sem ocupar a CPU graças aos seus blocos de E/S programável, chamados PIO. Explicamos passo a passo como usar o PIO e o segundo núcleo em PIO e dois núcleos na Pico. Um anel pequeno com 8–12 LEDs pode funcionar pelo pino VBUS; fitas mais longas precisam de uma fonte de 5 V separada.

Nível 5: Wi-Fi e teclado USB com a Pico W (19–20)

No projeto dezenove, a Pico W entra na sua rede de casa e liga e desliga um LED por botões em uma página web que você abre no celular. Com os módulos network e socket do MicroPython, dá para escrever um servidor web funcional em 40–50 linhas; para a configuração passo a passo, veja Servidor web Wi-Fi na Pico W. No projeto vinte, a sua Pico aparece no computador como um teclado: dê a cada botão um atalho ou um trecho de texto e você terá o seu próprio teclado de macros. Aqui o C/C++ é o caminho mais fácil, porque o core da Pico para a Arduino IDE já vem com a biblioteca Keyboard.

O mesmo projeto em C/C++: a Pico na Arduino IDE

Depois de instalar o pacote Raspberry Pi Pico/RP2040 de Earle Philhower pelo Gerenciador de Placas da Arduino IDE, você programa a Pico com os comandos do Arduino que já conhece. O número do pino é o número GP (14 para o GP14), analogWrite() trabalha na faixa de 0–255 por padrão e attachInterrupt() funciona em todos os pinos. No primeiro upload, talvez você precise conectar a Pico segurando o botão BOOTSEL. O código abaixo junta os projetos 7 e 8: o LED respira, para quando você aperta o botão e continua quando você aperta de novo.

C++ (Arduino IDE)
1// Arduino IDE + Raspberry Pi Pico (Earle Philhower çekirdeği / core)
2const int LED_PIN = 14;      // GP14 (fiziksel pin 19 / physical pin 19)
3const int BUTTON_PIN = 2;    // GP2, diğer ucu GND / other leg to GND
4
5volatile bool breathing = true;            // kesmede değişir / changed in the interrupt
6volatile unsigned long lastPress = 0;
7
8void onPress() {
9  unsigned long now = millis();
10  if (now - lastPress > 200) {             // 200 ms sıçrama filtresi / 200 ms debounce
11    breathing = !breathing;
12    lastPress = now;
13  }
14}
15
16void setup() {
17  pinMode(LED_PIN, OUTPUT);
18  pinMode(BUTTON_PIN, INPUT_PULLUP);
19  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
20}
21
22void loop() {
23  if (!breathing) {                        // butonla durdurulduysa LED sönük / paused by the button
24    analogWrite(LED_PIN, 0);
25    return;
26  }
27  for (int v = 0; v <= 255; v++) { analogWrite(LED_PIN, v); delay(4); }   // yavaşça yan / fade in
28  for (int v = 255; v >= 0; v--) { analogWrite(LED_PIN, v); delay(4); }   // yavaşça sön / fade out
29}

Erros comuns e como resolver

  • Número de pino errado: o código usa o número GP, não o número do pino físico. O GP14 é o pino 19 da placa; o mapa completo está na ferramenta Pinagem.
  • O LED integrado não acende na Pico W: na Pico W o LED está ligado ao chip sem fio; use Pin("LED") em vez de Pin(25).
  • O código não roda quando você desconecta do computador: salve o arquivo na Pico como main.py; é o único arquivo que a Pico executa sozinha ao ligar.
  • O servo treme ou a Pico reinicia: o servo está alimentado pelo 3V3 ou os GNDs não estão ligados juntos; alimente com 5 V e coloque um capacitor de 470 µF na alimentação.
  • O valor analógico é sempre 0 ou sempre 65535: o sensor está em um pino fora do GP26–GP28, ou você está lendo uma perna externa do potenciômetro em vez da do meio.
  • duty() de exemplos antigos dá erro: na Pico, o PWM do MicroPython usa duty_u16() ou duty_ns().
  • Um toque é detectado várias vezes: isso é bouncing mecânico; adicione um filtro de tempo de 150–200 ms como o do código de interrupção.
Quando quiser que um projeto funcione longe do computador, alimente a Pico com um carregador de celular USB ou aplique 1,8–5,5 V no pino VSYS (por exemplo, 3 pilhas AA ou uma única célula de Li-ion). Não esqueça de salvar o código como main.py antes.

Depois de terminar esses 20 projetos em ordem, você terá usado as entradas e saídas digitais da Pico, interrupções, PWM, o ADC, I2C, PIO e Wi-Fi, ou seja, quase tudo de que precisa para começar a criar os seus próprios projetos. Para se sentir mais à vontade no MicroPython, Fundamentos do MicroPython é um bom próximo passo. No app BlueGrays você pode experimentar passo a passo projetos com a Pico como o LED integrado, semáforo, sirene de polícia, Knight Rider, interrupção de botão, efeito de respiração com PWM e ciclo de cores RGB, cada um com esquema de ligação e código.

Perguntas frequentes

O que dá para fazer com uma Raspberry Pi Pico?

Dá para montar efeitos de LED, medidores com sensores, termômetros com OLED, controladores de servo e motor, teclados USB e controles de jogo e, com uma Pico W, projetos de automação residencial controlados pelo celular. A Pico é um microcontrolador, não um computador, então não serve para reproduzir vídeo nem rodar programas de desktop.

A Raspberry Pi Pico é boa para iniciantes?

Sim. Com o MicroPython você usa logo o que sabe de Python e roda o código sem esperar compilação. O principal cuidado é que os pinos trabalham com 3,3 V, então sensores com saída de 5 V precisam de um divisor de tensão ou de um conversor de nível.

Devo aprender MicroPython ou C++ para a Pico?

Se você é iniciante em programação e em eletrônica, comece pelo MicroPython: as mensagens de erro são claras e o ciclo de teste é curto. Passe para C/C++ quando precisar de tempo preciso, mais velocidade ou de uma biblioteca que só existe para Arduino; a Pico aceita as duas.

A Raspberry Pi Pico consegue controlar um servo diretamente?

Do lado do sinal, sim: qualquer pino GPIO controla um servo como o SG90 com PWM de 50 Hz. Mas alimente o servo pelo VBUS ou por uma fonte externa de 5 V, e não pelo pino 3V3, e ligue os GNDs juntos.

Qual é a diferença entre a Pico e a Pico W?

As duas usam o mesmo chip RP2040; a Pico W acrescenta um chip de Wi-Fi de 2,4 GHz e Bluetooth. Todo projeto que não precisa de Wi-Fi roda nas duas, e a única mudança é que o LED integrado da Pico W é controlado com Pin("LED").

Posso usar código de Arduino em uma Raspberry Pi Pico?

Se você instalar o pacote RP2040 de Earle Philhower na Arduino IDE, a maioria dos sketches do Arduino roda com pequenas mudanças, usando os números GP como números de pino. Códigos que usam registradores específicos do AVR, ou circuitos que contam com lógica de 5 V, precisam ser adaptados.

Ver todos os projetos
Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
PI-1Iniciante

Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)

O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

5.0(1)
10
Raspberry Pi Pico: controle de LED externo (protoboard)
PI-2Iniciante

Raspberry Pi Pico: controle de LED externo (protoboard)

O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

4.5(2)
7
Raspberry Pi Pico: semáforo (3 LEDs em sequência)
PI-4Iniciante

Raspberry Pi Pico: semáforo (3 LEDs em sequência)

Simulamos um semáforo real com LEDs vermelho, amarelo e verde — o primeiro projeto com 3 LEDs da série Pico! Verde por 4 segundos: "siga"; amarelo por 1,5 segundo: "prepare-se"; vermelho por 3 segundos: "pare"; e vermelho+amarelo por 1 segundo: "saída" (padrão de semáforo europeu). Aprenda definição de funções (def all_off()), lógica de máquina de estados (sequência) e sincronização de vários GPIOs.

4.0(1)
12
Raspberry Pi Pico: efeito de luz policial (vermelho + azul)
PI-5Iniciante

Raspberry Pi Pico: efeito de luz policial (vermelho + azul)

Simulamos a barra de luzes de uma viatura com um Raspberry Pi Pico da forma mais simples! Os LEDs vermelho e azul acendem alternadamente (flip-flop): enquanto o vermelho está aceso, o azul fica apagado, e eles trocam de estado a cada 0,3 segundo, para sempre. O código escreve as duas etapas diretamente em um único laço while True; a velocidade é definida pela constante WAIT_MS.

4.7(3)
10
Raspberry Pi Pico: efeito Knight Rider com LEDs (6 LEDs em vaivém)
PI-8Iniciante

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.

5.0(1)
14
Raspberry Pi Pico: debounce de botão com IRQ ou consulta por software
PI-13Intermediário
Premium

Raspberry Pi Pico: debounce de botão com IRQ ou consulta por software

Você pressiona o botão uma vez e o código conta 3 ou 4? A culpa é dos contatos metálicos, que oscilam várias vezes em microssegundos. Aqui o mesmo botão é contado de 2 formas, lado a lado no Monitor Serial: consulta sem filtro, que conta a mais, e IRQ + debounce por software (ticks_diff() > 50ms, Pin.irq() e IRQ_FALLING), que conta certo. A cada contagem correta, o LED também alterna entre aceso e apagado.

12
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
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