Opción 1: Zephyr RTOS: pequeño de tamaño, gigante en capacidades para IoT y sistemas embebidos Opción 2: Zephyr RTOS — un gigante en miniatura para el IoT y los sistemas embebidos Opción 3: Zephyr RTOS: potencia en un paquete diminuto para IoT y disposi

Opción 1: Zephyr RTOS: pequeño de tamaño, gigante en capacidades para IoT y sistemas embebidos Opción 2: Zephyr RTOS — un gigante en miniatura para el IoT y los sistemas embebidos Opción 3: Zephyr RTOS: potencia en un paquete diminuto para IoT y disposi

Zephyr — un sistema operativo de tiempo real de código abierto que creció desde un proyecto interno de Intel hasta convertirse en una comunidad bajo el amparo de la Linux Foundation. Hoy el núcleo soporta más de 170 plataformas hardware, y la versión 4.1 aporta aceleración del kernel, Rust experimental y USB MIDI 2.0. En este artículo desglosaremos Zephyr en sus átomos: explicaremos la arquitectura, la seguridad, mostraremos un flujo de trabajo real y desplegaremos paso a paso el entorno en Ubuntu, macOS y Windows.

Breve historia y filosofía del proyecto

El proyecto arrancó en 2016 como un intento de unir esfuerzos de fabricantes de microcontroladores. La idea es simple: el desarrollo colaborativo es más barato y rápido que decenas de RTOS propietarios sin controladores ni procesos CVE. En ocho años Zephyr maduró hasta la rama LTS 3.7, y la versión 4.1 señala preparación para tareas "adultas": certificación PSA, soporte ampliado para RISC‑V de 64 bits y herramientas para desarrolladores en Rust.

Arquitectura del núcleo: desde el planificador hasta la pila de red

  • Configurabilidad mediante Kconfig. Cualquier función se activa en .menuconfig y termina en autoconf.h, desde donde la toma el compilador.
  • Dos modos de planificación: cooperativo para latencia mínima y por prioridad para escenarios complejos.
  • Asignación de recursos estática. A diferencia de FreeRTOS heap_4, aquí por defecto no hay asignación dinámica, lo que elimina la fragmentación de la memoria.
  • Device Driver Model. Un controlador es la estructura struct device con punteros a la API. El registro se realiza mediante el macro DEVICE_DT_DEFINE.
  • Seguridad de memoria avanzada: protección de pilas, MPU, seguimiento de permisos sobre objetos del kernel.
  • Pila de red IP nativa con soporte para IPv6, 6LoWPAN, TCP, DTLS, MQTT y CANopen.
  • Subsistemas: USB Device/Host, sistemas de archivos LittleFS y FAT, registro mediante CBPRINTF, shell, DFU.

La seguridad como proceso

Zephyr aplica un Secure Development Lifecycle: análisis estático, fuzzing, revisión de código y firmas DCO obligatorias. Existe un PSIRT y un rastreador de CVE. El proyecto ya alcanzó PSA Certified Level 1 y trabaja en IEC 61508, por lo que en el futuro serán posibles aplicaciones SIL‑2 en automatización industrial.

Novedades en la versión 4.1

Optimización del rendimiento

Se rehicieron el cambio de contexto, la cola de hilos listos y los manejadores de interrupciones. El benchmark thread_metric muestra mejoras del 20 al 60 %. Activar MULTIQ aporta aproximadamente un 40 % adicional al planificador cooperativo.

Soporte para IAR Arm Toolchain

Basta con establecer la variable ZEPHYR_TOOLCHAIN_VARIANT=iar y IAR_TOOLCHAIN_PATH. CMake seleccionará automáticamente las opciones de optimización.

Rust experimental

El componente rust_ns añade el crate zephyr. Ejemplo "Hello World" en Rust: 

// src/main.rs
#![no_std]
#![no_main]

use zephyr::println;

zephyr::init!(start);

fn start() {
    println!("¡Hola desde Rust en Zephyr!");
    zephyr::sleep_ms(1000);
}

Nuevos controladores y placas

Se añadieron Raspberry Pi Pico 2, CH32V003 y decenas de placas CAN+USB. Apareció el controlador USB MIDI 2.0: es posible montar un teclado MIDI literalmente en una tarde.

Despliegue: instalación paso a paso y primer proyecto

Dependencias generales

Se necesitará CMake 3.20+, Python 3.10+, device‑tree‑compiler 1.4.6+. El resto se instala con los scripts que siguen.

Ubuntu 22.04+

# 1. Actualizar el sistema
sudo apt update && sudo apt upgrade -y

# 2. Instalar dependencias
sudo apt install --no-install-recommends git cmake ninja-build gperf /
    ccache dfu-util device-tree-compiler wget python3-venv /
    python3-pip python3-setuptools python3-wheel xz-utils file /
    build-essential libsdl2-dev libmagic1 -y

# 3. Crear carpeta de trabajo y entorno virtual
mkdir -p ~/zephyrproject
python3 -m venv ~/zephyrproject/.venv
source ~/zephyrproject/.venv/bin/activate

# 4. Instalar west y descargar el código fuente
pip install west
west init ~/zephyrproject
cd ~/zephyrproject
west update
west zephyr-export
west packages pip --install

# 5. Instalar Zephyr SDK (por defecto en ~/.zephyr-sdk)
cd zephyr
west sdk install

macOS 13+

# 1. Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 2. Dependencias
brew install cmake ninja gperf python3 ccache qemu dtc libmagic wget openocd

# 3. Ruta a Python
echo 'export PATH="$(brew --prefix)/opt/python/libexec/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile

# 4. Repositorio Zephyr
mkdir -p ~/zephyrproject
python3 -m venv ~/zephyrproject/.venv
source ~/zephyrproject/.venv/bin/activate
pip install west
west init ~/zephyrproject
cd ~/zephyrproject
west update
west zephyr-export
west packages pip --install
cd zephyr
west sdk install

Windows 10+

:: Abrir PowerShell como usuario normal
winget install Kitware.CMake Ninja-build.Ninja oss-winget.gperf /
               python Git.Git oss-winget.dtc wget 7zip.7zip -e --id

:: Crear directorio de trabajo
cd %HOMEPATH%
python -m venv zephyrproject/.venv
zephyrproject/.venv/Scripts/activate.bat
pip install west

:: Clonar el código fuente
west init zephyrproject
cd zephyrproject
west update
west zephyr-export
west packages pip --install

:: Instalar Zephyr SDK
cd zephyr
west sdk install

Compilación de «Blinky»

Después de instalar el SDK y activar el entorno virtual: 

# Ejemplo para la placa nrf52840dk_nrf52840
cd ~/zephyrproject/zephyr
west build -b nrf52840dk_nrf52840 samples/basic/blinky -p always
west flash

Uso real: del prototipo a las actualizaciones OTA

Devicetree y controladores

La descripción del hardware se realiza en .dts. Ejemplo de conexión de un sensor de temperatura I2C: 

/ {
    zephyr,user {
        compatible = "zephyr,user";
        temp@0 {
            compatible = "ti,tmp117";
            reg = <0x48>;
            label = "TMP117";
        };
    };
};

En el controlador: 

const struct device *temp = DEVICE_DT_GET(DT_NODELABEL(tmp117));
sensor_sample_fetch(temp);
sensor_channel_get(temp, SENSOR_CHAN_AMBIENT_TEMP, &val);

OTA mediante MCUboot

  1. Habilitar el cargador de arranque: 
    CONFIG_BOOTLOADER_MCUBOOT=y
CONFIG_IMG_MANAGER=y
CONFIG_MCUBOOT_IMAGE_VERSION="1.0.0+0"
  2. Construir signed_by_mcuboot.bin:
    3. west sign -t imgtool -- --version 1.0.1
  3. Transferir la imagen al dispositivo vía BLE/HTTP, donde el bootloader verificará la firma y reiniciará la MCU.

Registro y trazado

La subsistema LOG envía salida a UART o RTT. Ejemplo: 

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

void main(void) {
    LOG_INF("El sistema ha arrancado");
    while (1) {
        LOG_DBG("Temperatura actual: %d", temp_c);
        k_sleep(K_SECONDS(5));
    }
}

Twister: pruebas automatizadas en CI

Twister es el framework que compila y ejecuta pruebas en QEMU local o en placas externas. 

# Localmente
scripts/twister -T tests/kernel -p qemu_x86 -y

# GitHub Actions
- name: Twister
  run: |
    west init .     west update
    pip install -r zephyr/scripts/requirements.txt
    scripts/twister -p qemu_cortex_m3 -T tests/drivers

Integración con VS Code

La extensión Zephyr Tools importa compile_commands.json y proporciona intellisense. Para depuración se usan Cortex‑DAP y OpenOCD; la configuración está en el archivo launch.json.

Caso: contador inteligente de energía

  • MCU: STM32L4 con 128 KB de RAM.
  • Protocolo de red: IPv6 sobre 6LoWPAN + CoAP.
  • Alimentación desde la red 220 V → convertidor a 3.3 V, por eso modo tickless para ahorro.
  • En 48 horas se ensambló el prototipo: medición de corriente mediante INA219, envío de lecturas cada cinco minutos al broker MQTT.

Configuración del kernel: 

CONFIG_NET_IPV6=y
CONFIG_NET_6LO=y
CONFIG_COAP=y
CONFIG_PM_DEVICE=y
CONFIG_LOG=y
CONFIG_LOG_PROCESS_THREAD=y

CI/CD de ciclo completo

Esquema:

  1. Un push en GitHub inicia el workflow.
  2. Twister compila las pruebas y QEMU ejecuta las pruebas unitarias.
  3. La imagen se firma con imgtool.
  4. El artefacto se sube a S3, desde donde el servidor OTA distribuye las firmware.
  5. El dispositivo comprueba la versión y descarga un parche diferencial Z‑std con reescritura parcial del flash.

Fragmento .github/workflows/build.yml: 

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Setup Zephyr
      uses: zephyrproject-rtos/action@v1
    - name: Run Twister
      run: scripts/twister -p qemu_x86 -T tests/kernel
    - name: Build firmware
      run: west build -b nrf52840dk_nrf52840 app -p always
    - name: Sign image
      run: west sign -t imgtool -- --version 1.2.${{github.run_number}}

Puntos críticos

  • Los archivos Devicetree de placas antiguas a veces están obsoletos: revisa el diff antes de portar.
  • La biblioteca tinycrypt no soporta SHA‑512: con TLS 1.3 será necesario incorporar mbedTLS.
  • Una pila de red grande no cabe en un MCU con 64 KB de RAM: habilita solo los protocolos necesarios.

Hoja de ruta 2025‑2026

Los planes incluyen: Wi‑Fi 6, Thread 1.3, runtime de Rust sin FFI, un gestor de paquetes similar a Cargo y la certificación IEC 61508 SIL‑2.

Conclusión

Zephyr no es otro "micro‑Linux", sino un constructor que toma lo mejor del código abierto: transparencia, comunidad y despliegue rápido de parches. Con una configuración adecuada, el sistema ocupa menos de 10 KB de flash y además soporta IPv6 y TLS. Si necesita una plataforma fiable para un dispositivo IoT de producción, pero no quiere escribir controladores y la pila de red desde cero, Zephyr es un candidato válido. Y si encuentra un error, haga un pull request: mañana ayudará a miles de desarrolladores.

Alt text
article-title

Deni Haipaziorov