En un viejo microcontrolador de 8 bits (como un NXP MC9S08 o un ATmega), el procesador solo puede sumar números hasta 255. Cuando en el Día 299 declaraste tu variable uint64_t volumen_acumulado_mL, un chip de 8 bits requeriría docenas de instrucciones en lenguaje ensamblador para fragmentar ese número, sumar los acarreos (Carries) y volver a ensamblarlo. El ARM Cortex-M4 del STM32 procesa datos en bloques masivos de 32 bits y ejecuta operaciones complejas (incluso multiplicaciones enteras con acumulación) en un solo ciclo de reloj. Esto libera a la CPU para atender al RTOS inmediatamente.
En chips simples, si una interrupción de Wi-Fi UART se está atendiendo, una interrupción del caudalímetro tiene que esperar; si espera demasiado, pierdes pulsos de gas. El NVIC (Nested Vectored Interrupt Controller) de la arquitectura ARM permite Anidación (Nesting). Si configuras la prioridad del caudalímetro más alta que la del Wi-Fi, el NVIC congelará la interrupción del Wi-Fi en pleno vuelo, atenderá el pulso de gas en microsegundos, y luego regresará al Wi-Fi. Esto es la base del Tiempo Real.
El problema: En un micro de 8 bits, si el módulo Wi-Fi (ESP32) te envía un JSON de 200 bytes por UART, la CPU tiene que interrumpir lo que esté haciendo 200 veces para leer un byte del registro UART y escribirlo en la memoria RAM.
La solución ARM: El Cortex-M integra el controlador DMA. Le dices al DMA: "Apunta al registro receptor del UART. Cuando lleguen datos, cópialos en la RAM en el arreglo 'buffer_rx'. Avísame con una sola interrupción cuando hayas movido los 200 bytes". La CPU se desentiende y sigue ejecutando tu lógica de metrología. Esto se llama Procesamiento Paralelo por Hardware.
El RTOS FreeRTOS delega casi todo su funcionamiento interno a las interrupciones del ARM Cortex-M. Si configuras mal las prioridades en el NVIC, destruirás el Kernel del sistema operativo. En STM32, la prioridad 0 es la más alta y urgente, y 15 es la más baja.
/**
* @file nvic_arm_config.c
* @brief Configuración del Controlador de Interrupciones ARM (NVIC)
*/
#include "stm32f4xx_hal.h"
// =========================================================================
// CONFIGURACIÓN DE PRIORIDADES (EL CORAZÓN DEL DETERMINISMO)
// =========================================================================
/**
* @brief Establece las jerarquías de hardware antes de arrancar el RTOS.
*/
void ARM_NVIC_Configuration(void) {
// 1. Configurar el grupo de prioridades (Preemption vs Subpriorities)
// En FreeRTOS sobre STM32, se EXIGE agrupar todos los bits como "Preemption Priority".
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
// ---------------------------------------------------------------------
// JERARQUÍA DE SUPERVIVENCIA INDUSTRIAL
// ---------------------------------------------------------------------
// [PRIORIDAD 0] - MÁXIMA (Nivel Máquina)
// El Watchdog de ventana, o la caída del voltaje de la fuente (Brownout).
// Jamás se bloquea, ni siquiera por el RTOS.
HAL_NVIC_SetPriority(PVD_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(PVD_IRQn);
// [PRIORIDAD 5] - URGENCIA METROLÓGICA
// El pulso del Caudalímetro EXTI. Si lo perdemos, perdemos dinero.
// OJO: En FreeRTOS, las interrupciones que interactúan con APIs del SO
// (ej. xQueueSendFromISR) deben ser numéricamente MAYORES O IGUALES a
// configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY (generalmente 5).
HAL_NVIC_SetPriority(EXTI0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
// [PRIORIDAD 7] - URGENCIAS MECÁNICAS DE RUTINA
// El ADC de Presión leyendo el transductor 4-20mA.
HAL_NVIC_SetPriority(ADC_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(ADC_IRQn);
// [PRIORIDAD 10] - COMUNICACIONES (Baja latencia requerida)
// El ESP32 enviando comandos vía UART. Usaremos DMA para que el hardware
// trabaje solo, y la interrupción solo nos avisa al terminar el bloque.
HAL_NVIC_SetPriority(USART2_IRQn, 10, 0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
// [PRIORIDAD 14] - INTERFAZ DE USUARIO LENTA
// I2C de la pantalla LCD. Al ojo humano no le importa si el caracter
// tarda 2 milisegundos más en dibujarse.
HAL_NVIC_SetPriority(I2C1_EV_IRQn, 14, 0);
HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);
}
// =========================================================================
// DEMOSTRACIÓN DE DMA (INICIALIZACIÓN BÁSICA)
// =========================================================================
extern UART_HandleTypeDef huart2;
uint8_t rx_buffer_iot[200];
void Start_DMA_UART_Background_Listen(void) {
// La CPU ordena al DMA que espere 200 bytes en segundo plano.
// La CPU NO se bloquea aquí, retorna instantáneamente.
HAL_UART_Receive_DMA(&huart2, rx_buffer_iot, 200);
}
Objetivo del día: Comprensión del Silicio Subyacente (Cortex-M) y Optimización de Buses.
Cuando dabas tus primeros pasos con arquitecturas de 8 bits (como el venerable NXP MC9S08QE128), programar en C requería exprimir cada ciclo y sufrir con las matemáticas largas. Si hubieras intentado calcular el volumen compensado por temperatura (API 54) usando variables de 64 bits en un chip de 8 bits, la ALU del procesador se habría atragantado. Habría demorado tanto en hacer una simple multiplicación que habría ignorado la lectura del pin del sensor de flujo.
Al migrar tu proyecto de Tesis hacia la arquitectura **ARM Cortex-M4 (STM32)**, no solo ganaste velocidad cruda (84 MHz), ganaste inteligencia estructural. El **AHB Bus Matrix** permite que tu procesador esté resolviendo matemáticas complejas (gracias a sus registros anchos de 32 bits) exactamente al mismo tiempo que el chip **DMA** transfiere subrepticiamente los bytes de la red Wi-Fi hacia la memoria RAM. Además, al configurar el **NVIC**, le has dado al hardware la capacidad de interrumpirse a sí mismo: si el Wi-Fi está reportando y entra un pulso de gas, el Cortex-M4 congela la red, cuenta el gas, y retoma la red en microsegundos. Este es el verdadero paralelismo de hardware que hace posible la existencia de un RTOS confiable.
uint64_t).configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY.