Programa tu Raspberry Pi Pico con C/C++ y VS Code

El Raspberry Pi Pico ha revolucionado el mundo de los microcontroladores con su potente chip RP2040 y su bajo coste. Muchos usuarios comienzan su aventura con MicroPython por su simplicidad y facilidad de uso. Sin embargo, cuando buscas el máximo rendimiento, una eficiencia computacional superior y un control total sobre el hardware, el lenguaje C/C++ es el camino a seguir. Aunque la configuración inicial puede parecer intimidante en comparación con otras plataformas, los beneficios en velocidad y optimización son innegables. En esta guía completa, te llevaremos de la mano a través de todo el proceso para configurar un entorno de desarrollo profesional usando Visual Studio Code (VS Code) y compilar tu primer programa en C para hacer parpadear un LED.

¿Por qué C/C++ para el Raspberry Pi Pico?

Mientras que MicroPython es fantástico para prototipado rápido y proyectos que no requieren una ejecución a la velocidad del metal, C/C++ te permite acceder directamente a las capacidades del hardware del RP2040. Esto se traduce en programas que se ejecutan mucho más rápido, consumen menos memoria y te dan un control granular sobre cada aspecto del microcontrolador. Es la elección predilecta para aplicaciones de tiempo real, procesamiento de señales, emuladores o cualquier proyecto donde cada ciclo de reloj cuenta.

Paso 1: Instalación de las Herramientas de Compilación

A diferencia de plataformas como Arduino que vienen con un IDE todo en uno, para programar el Pico en C/C++ necesitamos instalar manualmente una cadena de herramientas (toolchain). Este proceso varía ligeramente según tu sistema operativo. A continuación, detallamos los pasos para cada uno.

Para usuarios de Linux (Raspberry Pi OS, Debian, Ubuntu)

La Fundación Raspberry Pi ha simplificado enormemente este proceso para los sistemas basados en Debian con un práctico script de configuración. Abre una terminal y ejecuta los siguientes comandos:

wget https://raw.githubusercontent.com/raspberrypi/pico-setup/master/pico_setup.sh chmod +x pico_setup.sh ./pico_setup.sh sudo reboot

Este script descargará e instalará automáticamente el SDK del Pico, el compilador ARM, CMake y otras dependencias necesarias. Una vez finalizado el reinicio, tu sistema estará listo.

Para usuarios de macOS

Si tienes Homebrew instalado, el proceso es igualmente sencillo. Homebrew es un gestor de paquetes que facilita la instalación de software en macOS. Abre tu terminal y ejecuta:

# Instalar Homebrew si no lo tienes /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)" # Instalar las herramientas necesarias brew install cmake brew tap ArmMbed/homebrew-formulae brew install arm-none-eabi-gcc

Nota importante para Mac con M1/M2: Es posible que necesites instalar Rosetta 2, ya que el compilador ARM podría no ser nativo para la arquitectura Apple Silicon todavía. El sistema operativo generalmente te lo pedirá automáticamente, pero si no, puedes forzar la instalación con:

/usr/sbin/softwareupdate --install-rosetta --agree-to-license

Para usuarios de Windows

Windows requiere un poco más de atención, ya que no tiene un gestor de paquetes nativo como los anteriores. La guía oficial recomienda instalar las Herramientas de Compilación de Visual Studio, que ocupan varios gigabytes. Una alternativa más ligera es usar MinGW (Minimalist GNU for Windows).

• Opción 1 (Oficial): Sigue el capítulo 9 de la guía oficial "Getting Started with Raspberry Pi Pico" para instalar las herramientas de Visual Studio y el resto de componentes.
• Opción 2 (Recomendada y más ligera): Instala MinGW y Make. Puedes hacerlo fácilmente a través de gestores de paquetes como Chocolatey o MSYS2. Esto te permitirá tener un entorno de compilación similar al de Linux sin la pesada instalación de Visual Studio.

Independientemente del método, asegúrate de tener instalados: el compilador `arm-none-eabi-gcc`, `CMake`, y el sistema de compilación (`NMake` para Visual Studio o `Make` para MinGW).

Paso 2: Configurando Visual Studio Code

VS Code es un editor de código potente y extensible que se ha convertido en el estándar de facto para muchos desarrolladores. Para trabajar con el Pico, necesitaremos un par de extensiones.

1. Abre VS Code y ve a la pestaña de Extensiones (el icono de los cuatro cuadrados en la barra lateral).
2. Busca e instala "CMake Tools". Esta extensión es fundamental, ya que nos permitirá configurar, compilar y depurar nuestros proyectos de CMake directamente desde la interfaz de VS Code.
3. Una vez instalada, haz clic en el icono del engranaje junto a la extensión y selecciona "Configuración de la extensión".
4. Busca la opción `Cmake: Build Environment`. Aquí es crucial definir la ruta al SDK del Pico. Haz clic en "Añadir elemento" y crea una variable llamada PICO_SDK_PATH. En el campo de valor, introduce la ruta completa a la carpeta `pico-sdk` que se descargó durante la instalación de las herramientas. Por ejemplo: `C:\pico\pico-sdk` en Windows o `/home/pi/pico/pico-sdk` en Linux.
5. Ahora, busca la opción `Cmake: Generator`. Este campo le dice a CMake qué sistema de compilación usar. Debes configurarlo según tu instalación:
   • Linux y macOS: `Unix Makefiles`
   • Windows (con Visual Studio): `NMake Makefiles`
   • Windows (con MinGW): `MinGW Makefiles`

Paso 3: Creando el Proyecto "Blink"

Ahora que el entorno está configurado, vamos a crear nuestro primer proyecto para hacer parpadear el LED integrado en la placa.

Estructura de archivos

Desde VS Code, ve a `Archivo > Abrir Carpeta` y crea una nueva carpeta para tu proyecto (por ejemplo, `pico_blink`). Dentro de esta carpeta, crea dos archivos:

1. `main.c`: Aquí irá nuestro código fuente en C.
2. `CMakeLists.txt`: Este es el archivo de configuración para CMake, que le indica cómo debe compilar nuestro proyecto.

El Código Fuente: `main.c`

Abre `main.c` y pega el siguiente código. Es un programa simple que inicializa el pin del LED y lo enciende y apaga cada segundo.

#include "pico/stdlib.h" #include <stdio.h> int main() { // El pin del LED integrado en la Pico es el 25 const uint LED_PIN = 25; // Inicializar el pin del LED gpio_init(LED_PIN); gpio_set_dir(LED_PIN, GPIO_OUT); // Inicializar la E/S estándar (para poder usar printf) stdio_init_all(); // Bucle infinito while (true) { printf("¡Encendiendo LED!\r\n"); gpio_put(LED_PIN, 1); // Poner el pin en alto (encender) sleep_ms(1000); // Esperar 1000 milisegundos (1 segundo) printf("¡Apagando LED!\r\n"); gpio_put(LED_PIN, 0); // Poner el pin en bajo (apagar) sleep_ms(1000); // Esperar 1 segundo } }

El Script de Compilación: `CMakeLists.txt`

Este archivo es el cerebro de nuestro proceso de compilación. Le dice a CMake qué archivos compilar, qué bibliotecas del SDK usar y cómo generar los archivos de salida. Pega lo siguiente en `CMakeLists.txt`:

# Versión mínima requerida de CMake cmake_minimum_required(VERSION 3.13) # Importar el SDK del Pico usando la variable de entorno que configuramos include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake) # Definir el nombre del proyecto y los lenguajes a usar project(pico_blink C CXX ASM) set(CMAKE_C_STANDARD 11) set(CMAKE_CXX_STANDARD 17) # Inicializar el SDK para nuestro proyecto pico_sdk_init() # Añadir nuestro archivo fuente al ejecutable add_executable(${PROJECT_NAME} main.c ) # Vincular las bibliotecas estándar del Pico (para GPIO, tiempo, etc.) target_link_libraries(${PROJECT_NAME} pico_stdlib) # Generar archivos adicionales como .uf2, .bin y .hex pico_add_extra_outputs(${PROJECT_NAME}) # Habilitar la salida de printf() a través del puerto USB serie pico_enable_stdio_usb(${PROJECT_NAME} 1) pico_enable_stdio_uart(${PROJECT_NAME} 0)

Paso 4: Compilar y Cargar el Programa

Con los archivos listos, la magia de la extensión CMake Tools entra en acción. Fíjate en la barra de estado azul en la parte inferior de VS Code.

1. Seleccionar el Kit de Compilación: Haz clic donde dice "No active kit". VS Code debería escanear tu sistema y encontrar el compilador `GCC for arm-none-eabi`. Selecciónalo.
2. Configurar el Proyecto: Haz clic en el botón `Build` de la barra de estado. La primera vez, CMake se ejecutará y creará una carpeta `build` en tu proyecto. Aquí es donde se guardarán todos los archivos compilados. Verás la salida en la terminal de VS Code.
3. Compilar el Código: Vuelve a hacer clic en el botón `Build`. Esta vez, CMake llamará al compilador y enlazará tu código. Si todo va bien, no deberías ver errores y en la carpeta `build` aparecerán varios archivos, incluyendo `pico_blink.uf2`.

Cargar el archivo .uf2 en el Pico

El archivo .uf2 es el que nos interesa. Es un formato especial que el bootloader del Pico entiende.

1. Desconecta tu Raspberry Pi Pico del ordenador.
2. Mantén presionado el botón BOOTSEL de la placa.
3. Sin soltar el botón, conecta el Pico a tu ordenador con un cable USB.
4. Suelta el botón BOOTSEL.
5. Tu ordenador detectará el Pico como una unidad de almacenamiento masivo llamada `RPI-RP2`.
6. Abre el explorador de archivos, navega a la carpeta `build` de tu proyecto, y arrastra (o copia y pega) el archivo `pico_blink.uf2` a la unidad `RPI-RP2`.
7. La unidad se desmontará automáticamente, el Pico se reiniciará y... ¡el LED integrado comenzará a parpadear! Además, si abres un monitor serie (como el incluido en VS Code o PuTTY) conectado al puerto COM de tu Pico a 115200 baudios, verás los mensajes que enviamos con `printf`.

Tabla Comparativa: MicroPython vs C/C++ para Pico

Preguntas Frecuentes (FAQ)

¿Por qué mi compilador `arm-none-eabi-gcc` no es detectado por VS Code?

Asegúrate de que la ruta al directorio `bin` del compilador esté añadida a la variable de entorno PATH de tu sistema. Después de añadirla, reinicia VS Code.

¿Qué es CMake y por qué es necesario?

CMake es un meta-sistema de compilación. En lugar de escribir complejos `Makefiles` a mano, escribimos un archivo `CMakeLists.txt` más simple y CMake genera los archivos de compilación nativos para tu plataforma (Makefiles en Linux/macOS, proyectos de Visual Studio en Windows, etc.). Es el sistema oficial para construir proyectos con el SDK del Pico.

Al copiar el archivo .uf2, obtengo un error. ¿Qué puede ser?

Asegúrate de que el cable USB que estás usando es de datos y no solo de carga. Intenta usar otro puerto USB en tu ordenador. También, verifica que has arrastrado el archivo correcto y no una carpeta.

¿Puedo usar otro editor de código como CLion o Eclipse?

Sí. Dado que el proyecto se basa en CMake, cualquier IDE o editor con buen soporte para CMake puede ser configurado para trabajar con el Pico. Sin embargo, la integración con VS Code es una de las más populares y bien documentadas.

¡Felicidades! Has configurado con éxito un entorno de desarrollo C/C++ completo para tu Raspberry Pi Pico y has compilado y cargado tu primer programa. Este es el punto de partida para crear proyectos mucho más complejos y de alto rendimiento. Te animamos a explorar la documentación oficial del SDK de C/C++ para Pico, donde encontrarás ejemplos y una descripción detallada de todas las funciones disponibles para controlar los periféricos del RP2040.