En tu STM32, cuando usas interrupciones (NVIC), parece que la máquina hace varias cosas a la vez. Pero es una ilusión óptica. La Unidad Aritmético-Lógica (ALU) detiene lo que estaba haciendo, guarda su estado, atiende al sensor y luego regresa. Esta Arquitectura de Von Neumann lee instrucciones de memoria secuencialmente. Si tienes 4 boquillas despachadoras de gas inyectando pulsos a 10 MHz, el procesador colapsará por la sobrecarga de interrupciones (Interrupt Latency).
Un FPGA (Field Programmable Gate Array) no tiene un procesador central, ni un main(), ni un ciclo while(1). Físicamente es una matriz de miles de compuertas lógicas y Flip-Flops desconectados. Cuando "programas" un FPGA (usando lenguajes como Verilog o VHDL), no le estás dando una lista de instrucciones; le estás dando un Plano de Cableado. El FPGA conecta sus compuertas físicamente para convertirse en el circuito que diseñaste. Si escribes 4 contadores en Verilog, el FPGA crea 4 circuitos físicos distintos. Ambos contarán a 100 MHz en concurrencia verdadera, en el mismo picosegundo, sin interrumpirse el uno al otro.
Paso 1: Cambiar la mentalidad de "Software" a "Hardware".
En C, una variable es un espacio en memoria RAM. En Verilog (el lenguaje estándar para FPGAs), un `wire` (cable) es literalmente una pista de cobre físico, y un `reg` (registro) es un Flip-Flop. Cuando escribes código en Verilog, no estás programando algoritmos; estás dibujando diagramas esquemáticos con texto. El sintetizador tomará tu texto y configurará los interruptores microscópicos (SRAM) del FPGA para conectar las compuertas lógicas (LUTs).
Paso 2: Arquitectura Híbrida (MCU + FPGA).
En equipos industriales avanzados, no sustituimos el STM32 por el FPGA. Usamos ambos. El FPGA actúa como un escudo o periférico ultrarrápido personalizado. El FPGA recibe las señales de las turbinas de gas, filtra el ruido rebotante en nanosegundos y mantiene cuentas perfectas. Luego, el STM32 interroga al FPGA por bus SPI cada 100 milisegundos para pedirle los "totales", dejando al MCU libre para manejar la pantalla, la criptografía y el Wi-Fi.
Observa el siguiente código. A primera vista parece software, pero nota que los tres bloques always no se ejecutan uno después del otro. Se instancian en el silicio y ocurren simultáneamente con cada ciclo del reloj a 50 MHz.
/**
* @file mass_flow_counters.v
* @brief Módulo Verilog para conteo concurrente de 3 medidores de gas a alta velocidad.
*/
module mass_flow_counters (
input wire clk_50MHz, // Reloj principal del FPGA a 50 MHz
input wire rst_n, // Reset general (Activo en bajo)
// Entradas físicas desde los 3 sensores de Efecto Hall
input wire sensor1_in,
input wire sensor2_in,
input wire sensor3_in,
// Salidas hacia los registros que leerá el STM32 vía SPI
output reg [31:0] count_1,
output reg [31:0] count_2,
output reg [31:0] count_3
);
// =========================================================================
// INSTANCIA FÍSICA 1: Contador Independiente para el Sensor 1
// =========================================================================
// Este bloque crea un Flip-Flop de 32 bits físicamente dedicado en el silicio.
always @(posedge sensor1_in or negedge rst_n) begin
if (!rst_n)
count_1 <= 32'd0;
else
count_1 <= count_1 + 1'b1; // Incrementar cuenta
end
// =========================================================================
// INSTANCIA FÍSICA 2: Contador Independiente para el Sensor 2
// =========================================================================
// Este bloque opera en TOTAL PARALELISMO con la Instancia 1.
// No hay retardo ni competencia de CPU.
always @(posedge sensor2_in or negedge rst_n) begin
if (!rst_n)
count_2 <= 32'd0;
else
count_2 <= count_2 + 1'b1;
end
// =========================================================================
// INSTANCIA FÍSICA 3: Contador Independiente para el Sensor 3
// =========================================================================
always @(posedge sensor3_in or negedge rst_n) begin
if (!rst_n)
count_3 <= 32'd0;
else
count_3 <= count_3 + 1'b1;
end
endmodule
Objetivo del día: Comprender las limitaciones estructurales del núcleo ARM para futuras expansiones.
Hasta hoy, en nuestro proyecto de Despachador de Gas LP, hemos utilizado caudalímetros de tipo turbina. Estos giran y emiten unos cuantos cientos de pulsos por litro. Un STM32 puede manejar esto usando interrupciones en los pines (EXTI) con total holgura.
Pero supongamos que el negocio crece y queremos certificar el equipo para despachar Hidrógeno o Gas Natural Comprimido a presiones extremas. Las turbinas mecánicas ya no sirven; necesitaremos sensores de Flujo Másico de Coriolis. Estos sensores emiten señales diferenciales que requieren procesamiento de señales digitales (DSP) para analizar desfases a frecuencias de Megahertz. Si intentamos conectar esto a los pines del STM32, el procesador será aplastado por el diluvio de interrupciones, bloqueando todo lo demás (pantalla, nube, criptografía).
Al entender la naturaleza del FPGA, has expandido tu arsenal arquitectónico. Sabes que la solución no es comprar un microcontrolador más rápido de 1 GHz, sino delegar el problema de alta velocidad al silicio concurrente de un FPGA, creando un sistema Híbrido MCU + FPGA inexpugnable. Esta es la diferencia entre un programador de software y un verdadero Arquitecto de Hardware.