Embebido · complemento

Haz parpadear una Raspberry Pi Pico

El módulo Embebido apunta a la Raspberry Pi Pico y Pico 2 (RP2040 / RP2350). Ferric genera un UF2 que flasheas por USB-C, incluye plantillas oficiales (embassy / rp-rs) y trae un emulador integrado de la Pico que verifica que tu firmware parpadee el LED — sin hardware. Es un desbloqueo único aparte (US$4.99) y no requiere Pro.

Placas soportadas

Hoy el módulo Embebido se enfoca en dos placas. Ferric elige el target y el layout de memoria correctos para cada una, así que no tienes que configurar un toolchain a mano.

• Raspberry Pi Pico — RP2040, doble núcleo Cortex-M0+, LED de placa en GPIO 25.
• Raspberry Pi Pico 2 — RP2350, GPIO 0–29, más memoria y velocidad.

Ambas placas se construyen sobre el propio silicio de la serie RP de Raspberry Pi. El RP2040 de la Pico junta dos núcleos Cortex-M0+ con 264 KB de SRAM; el RP2350 de la Pico 2 es más rápido, tiene más memoria y expone los GPIO 0–29. Ferric ya conoce el triple del target y el layout de memoria de cada una, así que elegir la placa es toda la configuración que haces.

Antes de empezar

Todo hasta el UF2 ocurre en el iPad — puedes escribir, compilar y verificar firmware sin ningún hardware. Solo necesitas una placa y un cable para el paso final de flasheo.

• El complemento Embebido — un desbloqueo único de US$4.99; no requiere Pro.
• Una Pico o Pico 2 — solo hace falta para flashear; el emulador cubre todo lo anterior.
• Un cable USB-C — para conectar la placa al iPad y que se monte como unidad.

De la plantilla al LED parpadeando

1. Elige placa y plantilla

   Elige la Pico (RP2040) o la Pico 2 (RP2350) y arranca desde una plantilla oficial — embassy (async) o rp-rs (HAL). Ferric configura el target correcto por ti.

2. Escribe tu firmware

   Edita el firmware no_std en el editor. Un primer programa clásico alterna el LED de la placa — el «blinky».

3. Verifica en el emulador

   Ejecuta el firmware en el emulador integrado de la Pico para confirmar que el LED de verdad parpadea — caza errores de lógica antes de tocar hardware.

4. Genera el UF2 y flashea

   Ferric genera un archivo UF2. Pon la Pico en modo BOOTSEL, conéctala por USB-C para que aparezca como unidad, y copia el UF2.

embassy y rp-rs

No arrancas desde un archivo en blanco. Ferric incluye dos familias de plantillas oficiales para que el boilerplate — target, mapa de memoria, configuración del HAL — ya esté correcto:

• embassy — un framework embebido async; escribe firmware con async/await y temporizadores.
• rp-rs — el HAL de la comunidad; un estilo más directo, de registros y periféricos.

Aquí el blinky clásico sobre la plantilla embassy — alterna el GPIO 25 cada 500 ms.

#![no_std]
#![no_main]

use embassy_rp::gpio::{Level, Output};
use embassy_time::Timer;
use embassy_executor::Spawner;

#[embassy_executor::main]
async fn main(_s: Spawner) {
    let p = embassy_rp::init(Default::default());
    let mut led = Output::new(p.PIN_25, Level::Low);
    loop {
        led.toggle();
        Timer::after_millis(500).await;
    }
}

src/main.rs — firmware no_std para la Pico

Aquí importan dos detalles: esto es firmware no_std —sin sistema operativo, sin std— y el bucle nunca retorna, porque en un microcontrolador tu programa es lo único que corre. La versión embassy de arriba es async; si prefieres un estilo más directo, de registros y periféricos, la plantilla del HAL rp-rs te da el mismo parpadeo sin executor.

#![no_std]
#![no_main]

use rp_pico::hal::{pac, gpio, Timer};
use embedded_hal::digital::OutputPin;

#[rp_pico::entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    // ... configurar relojes y pines ...
    let mut led = pins.gpio25.into_push_pull_output();
    loop {
        led.set_high().unwrap();
        delay.delay_ms(500);
        led.set_low().unwrap();
        delay.delay_ms(500);
    }
}

src/main.rs — el mismo parpadeo con el HAL rp-rs

Verifica antes de flashear

Antes de tocar un cable, ejecuta el firmware en el emulador integrado de la Pico. Ejecuta tu código compilado y muestra si el LED de verdad alterna, así un error de lógica — un nivel invertido, un bucle que nunca duerme — se caza en el iPad y no en la mesa de trabajo. El emulador sirve para verificar y observar firmware; nunca simula el hardware de forma interactiva por ti.

Flashear el UF2 por USB-C

Cuando el emulador se ve bien, Ferric genera un UF2 — el formato de firmware de arrastrar y soltar que entiende el bootloader de la Pico. Flashear requiere la placa física; todo hasta el UF2 funciona por completo en tu iPad.

1. Entra en modo BOOTSEL

   Mantén pulsado el botón BOOTSEL de la Pico mientras la conectas (o mientras pulsas reset). La placa aparece como una unidad de almacenamiento USB.

2. Conecta al iPad

   Conecta la Pico al iPad por USB-C. Se monta como una unidad llamada RPI-RP2 (o RP2350 en la Pico 2), visible en Archivos.

3. Copia el UF2

   Copia el .uf2 que generó Ferric a esa unidad. El bootloader lo escribe en la flash, la placa se reinicia sola y empieza a ejecutar tu firmware.

4. Mira el LED

   El LED de la placa debería parpadear ahora igual que en el emulador. Para volver a flashear, entra otra vez en BOOTSEL y repite.

Un desbloqueo aparte de US$4.99

Embebido es una compra única de US$4.99 que añade el target de placas, las plantillas, el emulador y el flasheo por USB-C. Es a propósito independiente de Pro: puedes comprarlo por su cuenta —incluso en el modo gratis— y si nunca tocas un microcontrolador nunca pagas por él. Su alcance es lo que dice: verificar y observar firmware en el dispositivo, y luego flashear una Pico real.

¿Quieres probar el flujo embebido antes de comprar? El curso gratuito «Aprende Rust» incluye un track embebido cuyo LED verificas en el mismo emulador integrado — sin hardware ni complemento para aprender cómo es.

A dónde seguir

Raspberry Pi es marca de Raspberry Pi Ltd; Ferric no está afiliado.