Fase 5: Diseño Industrial y Hardware

📖 Teoría a Estudiar

El Monopolio del ISA (Instruction Set Architecture)

Un ISA es el vocabulario que entiende un procesador a nivel de hardware. Cuando tu compilador GCC transforma el código C de tu algoritmo API-54 en lenguaje ensamblador, genera instrucciones (como `MUL` o `ADD`). En el mundo de los microcontroladores (MCU), ARM mantiene un monopolio casi absoluto. Empresas como STMicroelectronics, NXP o Texas Instruments no diseñan los núcleos Cortex; le pagan licencias multimillonarias a ARM para integrarlos en su silicio. Como resultado, tú no puedes ver cómo funciona el núcleo por dentro, no puedes modificarlo, y el costo del chip absorbe esa regalía.

La Revolución RISC-V

RISC-V (pronunciado "Risk-Five") no es un chip, ni es una empresa. Es un ISA de código abierto mantenido por una fundación global. Al igual que Linux democratizó el software, RISC-V está democratizando el hardware. Cualquier fabricante puede descargar los planos lógicos de un núcleo RISC-V y fabricar su propio microcontrolador sin pagar un solo centavo de regalías. Esto ha dado origen a chips extremadamente baratos y potentes, como la serie CH32V de WCH (reemplazos directos de STM32 por una fracción del costo) o el ESP32-C3 / ESP32-C6 de Espressif.

Extensibilidad: Instrucciones a la Medida

La "Caja Negra" de ARM prohíbe modificaciones. Si tu Despachador requiere una operación criptográfica ultra-específica, tienes que hacerla por software (lento). En RISC-V, el estándar define que un espacio de la arquitectura está reservado para ti. Si eres una empresa grande, puedes sintetizar silicio que incluya una instrucción ensambladora propia (Ej. GAS_CALC) que ejecute tu ecuación de flujo en un solo ciclo de reloj $T_{exec} = \frac{\text{Cycles}}{\text{Freq}}$, algo legal y físicamente imposible bajo licencias ARM.

⚙️ Procedimiento Práctico: Migrando Código a RISC-V

Paso 1: Toolchain Agnóstico.
En lugar de usar el compilador `arm-none-eabi-gcc` atado a CubeIDE, la industria open-source utiliza `riscv64-unknown-elf-gcc`. Tu código lógico en C (las matemáticas del volumen, las máquinas de estado) es idéntico. Lo único que cambia es el acceso directo a los registros del procesador y la librería de periféricos, la cual ahora suele ser proporcionada por frameworks unificados como Zephyr o ESP-IDF.

Paso 2: Diferencias Arquitectónicas Críticas (CSRs).
En ARM, usábamos registros embebidos en el mapa de memoria para contar ciclos (como el DWT->CYCCNT que vimos para perfilar código de alta velocidad). En RISC-V, la arquitectura define un espacio especial llamado Control and Status Registers (CSR). Acceder a ellos requiere instrucciones ensambladoras intrínsecas específicas de la familia RISC-V.

💻 Firmware C: Interacción a Nivel Núcleo (ARM vs RISC-V)

Observa cómo la extracción del tiempo de ejecución preciso a nivel de reloj del procesador cambia drásticamente cuando abandonamos la capa de abstracción de ARM y adoptamos un procesador RISC-V de 32 bits (como el ESP32-C3 o CH32V307).


/**
 * @file dsp_profiling_riscv.c
 * @brief Medición de rendimiento en ciclos de reloj de la ALU
 * Contraste de acceso a registros de hardware: ARM Cortex-M vs RISC-V
 */

#include <stdint.h>

// =========================================================================
// EL PARADIGMA ARM CORTEX-M (STM32)
// =========================================================================
/**
 * @brief Retorna los ciclos del procesador en ARM usando el Data Watchpoint 
 * and Trace (DWT) register.
 */
uint32_t ARM_Get_Cycle_Count(void) {
    // En ARM, los registros de control están mapeados en la memoria estándar
    // a través del bus del sistema (CoreSight).
    // (Asumiendo que el DWT fue habilitado previamente)
    
    // volatile uint32_t* DWT_CYCCNT = (uint32_t*)0xE0001004;
    // return *DWT_CYCCNT;
    
    // Usando CMSIS de ARM:
    // return DWT->CYCCNT; 
    return 0; // Placeholder para compilación
}

// =========================================================================
// EL PARADIGMA RISC-V (ESP32-C3 / WCH CH32V)
// =========================================================================
/**
 * @brief Retorna los ciclos de la CPU usando el registro CSR estandarizado 
 * de RISC-V llamado 'mcycle' (Machine Cycle).
 */
uint32_t RISCV_Get_Cycle_Count(void) {
    uint32_t cycles;
    
    // En RISC-V, los Control and Status Registers (CSR) NO están mapeados 
    // en la memoria RAM estándar. Tienen su propio espacio opcode.
    // Debemos inyectar ensamblador en línea (Inline Assembly) usando 
    // la instrucción 'csrr' (CSR Read).
    
    __asm__ volatile (
        "csrr %0, mcycle" 
        : "=r" (cycles) /* Salida: Almacenar en la variable C 'cycles' */
    );
    
    return cycles;
}

// =========================================================================
// MEDICIÓN INDEPENDIENTE DE ARQUITECTURA (HAL CUSTOM)
// =========================================================================
void Metrology_Task_Profiler(void) {
    uint32_t start_cycles, end_cycles, exec_time;

    // Tomar marca de tiempo
    #ifdef ARCH_RISCV
        start_cycles = RISCV_Get_Cycle_Count();
    #else
        start_cycles = ARM_Get_Cycle_Count();
    #endif

    // [!] Ejecutar cálculo de Punto Fijo API-54 crítico aquí
    // Calculo_API54_Volumen();

    // Calcular costo computacional
    #ifdef ARCH_RISCV
        end_cycles = RISCV_Get_Cycle_Count();
    #else
        end_cycles = ARM_Get_Cycle_Count();
    #endif

    exec_time = end_cycles - start_cycles;
    
    // Si exec_time > Threshold, lanzar alarma de cuello de botella
}

🚀 Impacto en el Proyecto: Resiliencia de la Cadena de Suministro

Objetivo del día: Asegurar la independencia tecnológica y viabilidad comercial a largo plazo.

A lo largo de tu tesis, fundamentaste técnicamente por qué un microcontrolador determinista de 32 bits es la herramienta perfecta para gobernar las válvulas de gas. Sin embargo, el mundo corporativo te presentará un desafío distinto: la dependencia del proveedor (Vendor Lock-in). Si basas la arquitectura crítica de tu empresa exclusivamente en herramientas privativas de STMicroelectronics, y los canales de distribución fallan, la producción colapsará.

Al adoptar y comprender la arquitectura **RISC-V**, te posicionas no solo como diseñador de PCBs, sino como un estratega tecnológico. Hoy sabes que el código algorítmico C que has pulido (tus máquinas de estado, tu compensación térmica) es agnóstico. Puede ser portado rápidamente a un silicio chino ultrabarato de WCH (CH32V) o al núcleo secundario del ESP32-C3 si el STM32 falla en logística o eleva su precio. Has demostrado que tu dominio del "Bare-Metal" no está encadenado a una marca corporativa, sino que fluye hacia el estándar abierto que dominará la próxima década del silicio.

📝 Resumen del Día

Un ISA (Instruction Set Architecture) define cómo el hardware interpreta el lenguaje ensamblador. ARM es un ISA cerrado y privativo (se debe pagar licencia), mientras que RISC-V es un estándar abierto y gratuito.
En RISC-V, los registros de control (como los contadores de ciclos o el estado de interrupciones) residen en el espacio CSR (Control and Status Registers), a los que se accede mediante instrucciones ensambladoras específicas (csrr, csrw) en lugar de lectura de memoria convencional.
La naturaleza abierta de RISC-V permite la Extensibilidad: los fabricantes pueden agregar instrucciones ensambladoras personalizadas directamente en el silicio para acelerar cálculos matemáticos o criptográficos específicos, sin romper la compatibilidad base.
Adoptar toolchains basados en estándares abiertos (GCC, LLVM) en lugar de los IDE cerrados de los fabricantes asegura la portabilidad del código C frente a crisis globales en la Cadena de Suministro (Supply Chain).
RISC-V representa la evolución lógica post-ARM para la automatización industrial, reduciendo el Costo Total de Materiales (BOM) y permitiendo el diseño futuro de Silicio a la Medida (Custom ASICs) sin barreras de regalías corporativas.