- Inicio
- Artículos
Arquitectura
Arquitecturas mantenibles para sistemas embebidos
Un producto embebido sobrevive a su primer hardware, a su primer equipo y a sus primeros requisitos. Cinco decisiones estructurales que determinan si el software podrá seguirle el paso.
- Publicado
- Tiempo de lectura
- 4 min de lectura
Un producto embebido rara vez está terminado. La primera versión sale con una placa; la segunda necesita otro sensor porque el original quedó descatalogado; la tercera añade una conectividad que nadie había previsto. Diez años después el producto sigue en el campo, mantenido por ingenieros que nunca conocieron a los autores originales.
Que ese recorrido sea barato o doloroso depende, en gran medida, de unas pocas decisiones estructurales tomadas durante el primer año. Ninguna exige un framework o una metodología concretos. Todas exigen intención deliberada.
1. Aislar explícitamente el acceso al hardware
La separación más valiosa en una base de código embebida es la que distingue el código que conoce el hardware del que no lo conoce. Cuando la lógica de aplicación llama directamente a funciones a nivel de registro, cada cambio de hardware se convierte en un cambio de aplicación.
Una capa de abstracción de hardware no tiene por qué ser elaborada. Debe ser estrecha, propiedad de la aplicación y expresada en el vocabulario de la aplicación. Una interfaz como pressure_sensor_read_kpa() es útil; un envoltorio fino que expone la transacción SPI no lo es: simplemente desplaza el acoplamiento un fichero más allá.
/* Propiedad de la aplicación: describe lo que necesita, no cómo se hace. */
typedef struct {
int (*init)(void);
int (*read_kpa)(int32_t *out_millikpa);
void (*set_sample_rate)(uint16_t hz);
} pressure_sensor_ops;
Desde el principio deberían existir dos implementaciones: el driver real y un fake para las pruebas en el host. Si escribir el fake resulta difícil, probablemente la interfaz está filtrando detalles del hardware.
2. Convertir la dirección de las dependencias en una regla, no en un hábito
Los diagramas de capas son fáciles de dibujar y fáciles de violar. El diagrama sigue limpio mientras el grafo de includes se convierte poco a poco en una malla.
El remedio es hacer comprobable la dirección de dependencias prevista. En CMake, eso significa un target por componente, con las dependencias declaradas explícitamente mediante target_link_libraries y rutas de include PRIVATE salvo que haya motivo para lo contrario. Un componente que no está enlazado no puede incluirse por accidente. En sistemas más grandes, un pequeño script en CI que inspeccione el grafo de targets y rechace las aristas prohibidas es un seguro barato.
3. Tratar el tiempo y la memoria como parte de la interfaz
En sistemas con recursos limitados, el contrato de una función no son solo sus entradas y salidas. También es cuánto puede tardar, si puede bloquearse, si reserva memoria y desde qué contexto puede llamarse.
Estas propiedades suelen ser implícitas, y por eso se violan. Escríbalas donde el siguiente ingeniero las verá (en la cabecera de la interfaz, no en un documento aparte) y verifíquelas cuando sea posible:
- Reserve la memoria de forma estática o en la inicialización; prohíba el uso del heap en régimen estable y hágalo cumplir con un hook del enlazador o del asignador.
- Indique qué funciones pueden llamarse de forma segura desde una interrupción.
- Asigne a cada tarea periódica un tiempo máximo de ejecución explícito y mídalo en el target como parte de las pruebas habituales.
Un sistema con límites explícitos puede razonarse cuando se añade una funcionalidad. Un sistema con límites implícitos solo puede probarse y esperar que funcione.
4. Separar la configuración de la variación
Los productos embebidos rara vez existen como una sola variante. Distintas placas, mercados y clientes generan builds distintas. El enfoque ingenuo, con bloques #ifdef repartidos por todo el código, convierte cada variante en un fork que casualmente comparte repositorio.
Un enfoque más mantenible separa tres cosas:
- La selección en tiempo de build de qué componentes y drivers se incluyen, hecha en el sistema de build y no en los ficheros fuente.
- La configuración estática de los componentes incluidos, expresada como estructuras de datos validadas en tiempo de compilación.
- Los parámetros en tiempo de ejecución, limitados al mínimo que realmente necesita cambiar tras el despliegue.
Cuando la variación vive en un número reducido de lugares conocidos, añadir una variante es trabajo de configuración y no una revisión de código de todo el sistema.
5. Registrar las decisiones, no solo el diseño
El diseño describe qué es el sistema. Los futuros ingenieros necesitan saber por qué: qué restricciones eran reales, qué alternativas se consideraron y qué compromisos se aceptaron conscientemente.
Los registros de decisiones de arquitectura (un documento breve por cada decisión relevante, con contexto, opciones y consecuencias) cuestan una hora de escritura y ahorran semanas de arqueología después. Manténgalos en el repositorio, junto al código que explican, y revíselos como si fueran código.
Qué se obtiene
Ninguna de estas prácticas acelera la primera versión. Su valor aparece en la segunda revisión del hardware, con el tercer equipo, en la actualización de seguridad cinco años después del lanzamiento. Es precisamente entonces cuando se concentra la mayor parte del coste de ingeniería de un producto embebido, y cuando la arquitectura sostiene al equipo o lo frena.