Microprocesadores y sistemas embebidos

Este es el octavo curso en Ingeniería Eléctrica Universitaria: microprocesadores y sistemas embebidos**. EE03 construyó la lógica; este curso construye la máquina que ejecuta programas, y la disciplina de hacer que el hardware y el software se integren.

• La Unidad 8.1 mapea la arquitectura: CPU, registros, memoria y el ciclo de búsqueda-decodificación-ejecución.
• Las Unidades 8.2–8.3 lo programan: C embebido y ensamblador, luego E/S con direccionamiento en memoria.
• Las Unidades 8.4–8.5 añaden temporalidad: interrupciones/temporizadores y protocolos seriales.
• Las Unidades 8.6–8.7 cierran con interfaces analógicas y métodos de depuración.

La historia en curso es un pequeño producto: un nodo sensor alimentado por batería con un botón, un LED, un enlace serial y un sensor de 12 bits. Cada unidad por debajo mueve ese nodo hacia adelante, y cada número se verifica de la manera en que lo hace un ingeniero de firmware — por anchos de bits y límites (¿cabe el valor?), por el reloj que asume (cada temporización se cierra contra 84 MHz), y trazando los cambios exactos de estado de cada fragmento de código.

Por qué importa. El termostato en la pared, el controlador de frenos antibloqueo y el auricular en el escritorio ejecutan cada uno uno de estos: una computadora completa en un chip del tamaño de un grano de arroz, que cuesta menos que el envío que lo transporta.

La idea, con una imagen. Un microcontrolador integra tres cosas en un solo chip: memoria flash que almacena el programa, SRAM que almacena los datos, y una CPU que ejecuta el ciclo de búsqueda-decodificación-ejecución: el contador de programa (PC) mantiene la dirección de la siguiente instrucción, la unidad de control la decodifica, la ruta de datos la ejecuta y el PC avanza (o salta). Cada transferencia viaja por el bus — líneas de dirección indicando dónde, líneas de datos transportando qué, líneas de control indicando lectura o escritura — secuenciado por el reloj.

La derivación. Las direcciones son enteros sin signo, por lo que un campo de dirección de N bits direcciona exactamente $2^{N}$ ubicaciones. Todo el mapa de memoria sigue:

Flash en 0x0000_0000 y SRAM en 0x2000_0000 nunca colisionan porque sus bits superiores difieren — el decodificador de direcciones simplemente mira los bits [31:16].

Ejemplo resuelto 1 — dimensionar el mapa de memoria. El chip del nodo tiene 64 KB de flash y 8 KB de SRAM. Flash: $64\,\text{KB} = 2^{16}$ bytes → 16 líneas de dirección, por lo que ocupa el rango 0x0000_0000–0x0000_FFFF. SRAM: $8\,\text{KB} = 2^{13}$ bytes → 13 líneas, en el rango 0x2000_0000–0x2000_1FFF. Verificación: cualquier dirección con bits [31:16] = 0x0000 y [15:0] ≤ 0xFFFF se encuentra en la flash; si contiene 0x2000_…, se encuentra en SRAM; las regiones no pueden superponerse porque sus bits más significativos son distintos ✓.

Ejemplo resuelto 2 — ¿qué tan rápido es el bucle en sí? La CPU del nodo funciona a 84 MHz con un nominal de una instrucción por ciclo (un núcleo de clase Cortex-M): $84 \times 10^{6}$ instrucciones por segundo, por lo que una instrucción tarda $\dfrac{1}{84 \times 10^{6}} = 11.9$ ns. Un paso de control de 100 instrucciones cuesta por tanto 1.19 µs — y un bucle de control de 1 ms tiene espacio para aproximadamente 840 pasos si nada más interviene. La aritmética presupuestaria que comienza aquí se reutiliza en todas las unidades posteriores.

Errores comunes. Mezclar bits de dirección con bits de datos (las líneas de dirección cuentan ubicaciones, las líneas de datos su ancho). Olvidar que el mapa está fijado en el script de enlace: el mismo chip arranca en cualquier dirección que el proveedor de hardware haya elegido. Y citar el tamaño del programa en bits cuando los tamaños de flash están en bytes — un factor de ocho que invalida la elección del componente.

Resumen. Un solo chip: flash + SRAM + CPU ciclando búsqueda, decodificación, ejecución. Un campo de dirección de N bits accede a $2^{N}$ bytes; las regiones con bits más significativos distintos no puede superponerse; el reloj convierte la cuenta de instrucciones en segundos.

Por qué es importante. El firmware del nodo son unas pocas miles de líneas de C que acceden directamente a los registros de hardware. No hay nada entre tu línea de código y un transistor — lo cual explica por qué el mapeo de C a máquina debe ser Una fuerza es un empuje o jalón con una magnitud, una dirección y una

La idea, con una imagen. Un registro mapeado en memoria es simplemente una dirección; C accede a ella mediante un volatile puntero (volátil indica al compilador: esta memoria cambia fuera de tu vista, acédele cada vez). El compilador transforma C en cargas, almacenamientos, operaciones aritméticas y saltos; el ensamblaje es el mismo programa escrito a mano en esas instrucciones una por línea.

La derivación. Leer-modificar-escribir es el acto fundamental: para cambiar un pino sin alterar sus vecinos, la CPU debe cargar el registro, enmascarar el bit localmente y lo almacena de nuevo. Son tres operaciones pero solo dos transferencias del bus: una lectura y una escritura. Este ejemplo utiliza un registro palabra de lectura/escritura simple; algunos periféricos reales también ofrecen registros atómicos de establecimiento/borrado: Una implementación ilustrativa de carga-incremento-almacenamiento más ramificación sigue las trazas de

volatile uint32_t *const GPIO_OUT = (uint32_t *)0x40000000u;
*GPIO_OUT |= (1u << 5);   // load, OR, store — set bit 5 only

Ejemplo resuelto 1 — rastrear el contador. El bucle en C

uint32_t count = 0;
while (1) { count = count + 1; }

Una implementación ilustrativa de carga-incremento-almacenamiento más ramificación rastrea en un registro de CPU. Verifique el límite: el valor máximo es $0, 1, 2, 3, \ldots$; el siguiente incremento devuelve a cero después de $2^{32} - 1 = 4\,294\,967\,295$ incrementos desde cero. Asumiendo cuatro ciclos de reloj por iteración a $2^{32}$ MHz, el desbordamiento requiere Asumiendo cuatro ciclos de reloj por iteración a 84 MHz, el ciclo toma $\dfrac{4\,294\,967\,296 \times 4}{84 \times 10^{6}} \approx 204$ s — aritmética, sin esperar tres minutos con un cronómetro.

Ejemplo resuelto 2 — la máscara de bits, escalada. Para invertir los bits 5 y 6 y limpia el bit 3 en una sola expresión: la máscara es $(1 \ll 5) \,|\, (1 \ll 6) = 0x60$. Entonces *GPIO_OUT = (*GPIO_OUT & ~0x08) ^ 0x60 borra el bit 3 e invierte 5 y 6 en una sola lectura-modificación-escritura. Verifique en papel con GPIO_OUT = 0xCE: 0xCE & ~0x08 = 0xC6, luego 0xC6 ^ 0x60 = 0xA6 — bit 3 now 0 (was 1), bits 6 and 5 flipped from 1, 0 to 0, 1 ✓. The hex check on papel es el depurador más rápido en esta unidad.

Errores comunes. Eliminar volatile (el compilador guarda el registro en un registro de CPU y su bucle lo lee eternamente). Asumir un orden de evaluación C entre dos escrituras de registros cuando el hardware requiere que ocurran en secuencia — inserte una barrera o una lectura posterior. Y escribir el bit 5 como *GPIO_OUT = 0x20, lo cual borra todos los demás bits del puerto.

Resumen. Los registros son direcciones; volatile mantiene al compilador honesto; este ejemplo simple de registro-palabra usa carga-máscara-almacenamiento. Rastrear el estado en papel en hexa antes de confiar en el silicio.

Por qué importa. El botón, el LED y el sensor del nodo residen todos fuera del CPU. Cómo se conectan determina si el firmware es una tabla limpia de direcciones o un montón de números mágicos.

La idea, con una imagen. La E/S mapeada en memoria hace que un registro de periférico parezca exactamente una ubicación de memoria: leer un registro de datos recibe un byte; escribirlo lo envía. Un puerto GPIO tiene dos de estos registros — dirección (entrada o salida, un bit por pin) y datos (el nivel del pin) — para configurarlo una vez y luego leer o escribir indefinidamente.

La deducción. El sondeo es la línea base honesta: el bit de "completado" del registro de estado es una lectura de memoria en un bucle. Cada vuelta cuesta las instrucciones del bucle; esperar T segundos consume

ciclos de CPU, o aproximadamente $T f_{\text{clock}}/C$ vueltas completas cuando cada el costo en $C$ ciclos de reloj. El factor $C$ cambia el número de verificaciones, no el tiempo de CPU ocupado por una espera continua. Detección y temporización las pruebas se cuantizan a los tiempos de verificación del bucle.

Ejemplo resuelto 1 — el costo de preguntar. El nodo sondea un bit de sensor listo a 84 MHz; cada vuelta del bucle requiere 4 ciclos (carga, AND, salto, incremento), por lo que la CPU realiza $84 \times 10^{6}/4 = 21$ millones de vueltas por segundo. Esperar 1 ms equivale a ~21 000 vueltas = 84 000 ciclos: representa el 100% de la CPU durante ese milisegundo, con cero trabajo útil.

Ejemplo resuelto 2 — el mapa completo del nodo. Los periféricos del nodo se ubican en 0x4000_0000 (GPIO), 0x4001_0000 (UART), 0x4002_0000 (temporizador), 0x4003_0000 (ADC). Una tabla de constantes de firmware mapea cada controlador a su base; un error tipográfico en una entrada (0x4001_0000 vs 0x4001_0004) ubica cuatro bytes dentro del conjunto de registros del UART — por eso cada archivo de controlador comienza con desplazamientos nombrados, nunca direcciones crudas. La comprobación: tras la inicialización, leer el registro de ID de cada periférico de vuelta; una base incorrecta devuelve basura en el primer intento.

Errores comunes. Olvidar el registro de dirección (el pin permanece como entrada y la escritura no produce efecto). Interrogar sin tiempo límite — un sensor muerto congela todo el producto. Y confundir el número de bit de un puerto con el número de pin en el paquete: la tabla de pines del datasheet, no el macro de conveniencia del encabezado, es la verdad.

Resumen. Los periféricos son memoria: base más desplazamientos nombrados. Configurar la dirección una sola vez, interrogar con un tiempo límite y permitir que una comprobación de lectura de ID verifique el mapa antes de que se ejecute cualquier trabajo real.

Por qué importa. El nodo funciona con batería durante un año. Interrogar consume la batería haciendo preguntas; las interrupciones permiten que la CPU duerma hasta que el mundo necesite su intervención — la diferencia entre una semana y un año.

La idea, con una imagen. Una interrupción suspende el programa principal donde está: el hardware empuja el estado de retorno, vectoriza hacia una rutina de servicio de interrupción (ISR) elegida por el NVIC (el controlador de interrupciones vectorizadas anidadas, que también clasifica prioridades), la ISR se ejecuta y retorna. Un temporizador es simplemente un contador impulsado por reloj a través de un divisor — el prescaler. En el contador ascendente estilo STM32 utilizado aquí, un evento de actualización ocurre cuando CNT envuelve desde ARR de vuelta a cero; un interruptor habilitado puede luego llamar al ISR.

La derivación. La frecuencia del temporizador se divide dos veces:

donde PSC y ARR son los valores almacenados del registro de 16 bits, como máximo 65,535. Cada factor divisor puede alcanzar 65,536 porque el cero también se cuenta. Un diseño es válido cuando los valores almacenados caben Y $PR=f_{\text{clock}}/f_{\text{interrupt}}$. Aquí ARR es distinto de cero y el contador funciona continuamente.

Ejemplo resuelto 1 — un latido cardíaco de 1 Hz. Desde 84 MHz: factor divisor 8400 da $84 \times 10^{6}/8400 = 10$ kHz; otro factor de 10,000 da exactamente 1 Hz. Escriba PSC = 8399 y ARR = 9999. Ambos valores almacenados caben en 16 bits, y $8400 \times 10\,000 = 84 \times 10^{6}$ ✓ cierra el diseño. Un divisor factor de 84,000 requeriría PSC = 83,999, lo cual no cabe.

Ejemplo resuelto 2 — latencia de interrupción frente a sondeo, con coste. Una interruptor con 12 ciclos de entrada, un ISR de 30 instrucciones y 10 ciclos de retorno cuesta $12 + 30 + 10 = 52$ ciclos $= 0.62$ µs a 84 MHz — frente al 21 000 vueltas que consumió la espera sondeada. Pero el coste del ISR se paga en cada evento: a 1 kHz de eventos eso es 52 000 ciclos/s = 0.06% de la CPU; a 1 MHz de eventos es 62% — superado cierto ritmo, sondear un periférico rápido más barato que interrumpir. La aritmética del cruce es la decisión de diseño.

Errores comunes. Un ISR que olvida borrar su bandera de interrupción —la CPU retorna y reentra inmediatamente, para siempre. Las ISRs largas (hagan lo mínimo, establecer una bandera, dejar que el bucle principal funcione). Y competir con el temporizador: leer un 16-bit temporizador en un bus de 8-bits necesita que el byte alto se lea dos veces o se almacene, o una acarreo Resumen. Interrupción = vector + ISR corta + borrado de bandera; temporizador =

prescaler × recarga contra el reloj, con ambos factores dentro de sus $(PSC+1)(ARR+1)$ contra el reloj, con ambos valores almacenados dentro de sus registros. Los interruptores ganan a bajas tasas de eventos; la lectura por sondaje gana más allá de ~1 MHz.

Por qué es importante. Las lecturas del nodo se transmiten por tres cables o menos. Elegir entre UART, SPI o I2C y evaluar el costo de los cables frente a la velocidad es una La idea, con una imagen. UART envía bytes asíncronos:

La idea, con una imagen. UART envía asincrónico tasa de baudios acordada por ambas partes. SPI comparte un reloj: el maestro controla SCLK y chip-select, los datos fluyen en MOSI hacia afuera y MISO hacia adentro —dúplex completo. I8C necesita dos cables (SDA datos, SCL reloj), direcciona dispositivos con 2 bits, y los cablea como open-drain para que cualquier dispositivo pueda mantener la línea baja. La derivación. UART no tiene línea de reloj, así que ambas partes reconstruyen el tiempo 7 bits, y los cablea en configuración open-drain para que cualquier dispositivo pueda mantener la línea baja.

*Un frame 8N1: 10 tiempos de bit por byte, 86.8 µs a 115 200 baudios

La deducción. UART no tiene línea de reloj, por lo que ambos extremos reconstruyen el tiempo desde la baudión acordada: un byte en formato 8N1 ocupa exactamente 10 tiempos de bit,

SPI en cambio envía un bit por ciclo completo de reloj, por lo que un byte requiere 8 ciclos más configuración: $T_{\text{byte}} \approx 8/f_{\text{SCLK}}$ — el reloj determina la velocidad.

Ejemplo resuelto 1 — dimensionamiento UART. A 115 200 baudios, 8N1: el rendimiento es $115\,200/10 = 11\,520$ bytes/s; un byte tarda $10/115\,200 = 86.8$ µs. Contra el bucle de control de 1 ms del nodo: 11 bytes caben perfectamente (0.95 ms) ✓; pero una ráfaga bloqueante de 100 bytes (8.68 ms) supera el presupuesto — divídala o aumente la baudión. El dimensionamiento se decide por cálculo, no por preferencia.

Ejemplo resuelto 2 — el precio tripartito. SPI a 10 MHz clockea un byte en $8/10\,\text{MHz} = 0.8$ µs — aproximadamente 108× más rápido que UART aquí — pero cuesta un cable de selección de chip por dispositivo. I2C a 400 kHz necesita 9 ciclos para 8 bits de datos más ACK: $9/400\,\text{kHz} = 22.5$ µs, antes de los sobrecostos de dirección, inicio y parada. A estas velocidades elegidas, se sitúa entre SPI y UART, pero con dos cables sirven para toda la placa (dirección de 7 bits = hasta 112 dispositivos a 1 direcciones por dispositivo). Sensor en I2C, flash en SPI, consola en UART — la división estándar, cada una precificada mediante este cálculo.

Errores comunes. Baudios incompatibles (el frame aún 'funciona' y los bytes son basura — verifique las matemáticas del divisor respecto al reloj periférico, no al reloj central). Leer una dirección I2C como 8 bits: la dirección de 7 bits más el bit de lectura/escritura se empaquetan en un byte, y las hojas técnicas citan ambas formas. Y olvidar el modo SPI (polaridad y fase del reloj): existen cuatro modos porque los dispositivos difieren; el incorrecto desfasa cada byte un bit.

Resumen. UART: 10 tiempos de bit por byte, sin reloj, ambos extremos acuerdan la baudión. SPI: un bit por ciclo, un cable por dispositivo. I2C: dos cables, direcciones de 7 bits, open-drain. Evalúe los bytes por milisegundo frente al número de cables antes de elegir.

Por qué importa. El mundo físico habla en voltios; la CPU habla en números. La lectura de temperatura del nodo es tan buena como el convertidor y su cableado —y los errores aquí son silenciosos, no ruidosos. cableado — y los errores aquí son silenciosos, no ruidosos.

La idea, con una imagen. Un ADC cuantiza: un N-bit un convertidor que abarca una tensión de referencia $V_{\text{ref}}$ tiene una resolución de un único LSB $= V_{\text{ref}}/2^{N}$. La elección de N es la elección de qué tan finamente se mide el mundo; el cableado decide si esa finura se mantiene. para que esa finura se mantenga.

La deducción. La cuantización mapea una tensión al código cuya banda la contiene: código $= \lfloor V_{\text{in}}/V_{\text{ref}} \times 2^{N} \rfloor$ (con variantes en los bordes). Reconstruir cada banda de entrada en su punto medio proporciona un límite ideal de error de cuantización de medio LSB dentro de la entrada rango; una entrada individual puede tener error cero.

Ejemplo resuelto 1 — el sensor de 12 bits. Con $V_{\text{ref}} = 3.3$ V, uno LSB equivale a $3.3/4096 = 0.806$ mV. Una entrada de 1.65 V se lee como $1.65/3.3 \times 4096 = 2048$ — escala intermedia exacta ✓. Si el nodo debe resolver 0.1 °C y el sensor proporciona 10 mV/°C, necesita 1 mV de resolución — un convertidor de 12 bits (0.806 mV) pasa, uno de 10 bits (3.22 mV) falla: el requisito, no el catálogo, determina N.

Ejemplo resuelto 2 — la trampa de impedancia de fuente. El capacitor de muestreo y retención del ADC se carga a través de la resistencia condensador ($\approx 7$ pF en este chip) se carga a través de la resistencia del generador, y la estabilización a ½ LSB requiere un tiempo de muestreo mínimo de $R_{\text{source}} C \ln(2^{N+1})$. Para un generador de 50 kΩ, esto equivale a $50\,000 \times 7\,\text{pF} \times 9.01 \approx 3.2$ µs para un salto de entrada a escala completa en este modelo RC simple. Reducir la ventana a 1 µs (resistencia de Thevenin de $16$ kΩ) por lo tanto necesita la configuración de 100 µs — o reducir a la mitad los valores del divisor. (50 kΩ Thevenin) requiere al menos una ventana de 3.2 µs — o reducir a la mitad el divisor Un DAC recorre la misma escalera en sentido inverso: al escribir 2048 a un DAC de 12 bits con $V_{\text{ref}} = 3.3$ V produce 1.650 V.

Errores comunes. Citar la resolución en bits y olvidar la tensión de referencia (0.806 mV solo es válido a 3.3 V). Tratar la entrada del ADC como un voltímetro: su corriente de muestreo carga sensores de alta impedancia, como indica la restricción RC anterior, 16 bits de resolución efectiva, pero no puede corregir un desplazamiento sistemático ni una muestra deformada. que gana aproximadamente 2 bits de resolución efectiva, pero no puede reparar un desplazamiento sistemático o una muestra caída.

Resumen. Un LSB = $V_{\text{ref}}/2^{N}$; el requisito determina N. La reconstrucción del punto medio proporciona un límite de error de cuantización de media LSB; el límite RC $t_{s} \ge R C \ln(2^{N+1})$ intercambia impedancia de fuente contra tiempo de muestreo — la impedancia de fuente permitida depende del modelo y de la ventana de adquisición.

Por qué importa. El firmware se prueba ejecutándolo en el hardware exacto que será embarcado, y cada error llega como un rumor ("se congeló dos veces anoche"). El método marca la diferencia entre corregirlo o simplemente renombrarlo. La idea, con una imagen. El ciclo es: reproducir con la entrada más pequeña posible; biseccionar el límite entre código confiable y sospechoso (un LED, un breakpoint o una impresión UART); corregir UNA cosa; re-verificar. Un watchdog

es la red de seguridad que reinicia un sistema colgado: restablecer el contador antes de que expire, para que el producto se reinicie por diseño en lugar de congelarse por accidente. es la red de seguridad que reinicia un sistema bloqueado: restablecer el contador antes Reproducir, biseccionar, corregir una cosa, re-verificar — y un watchdog fuera del ciclo La deducción. La bisección es el algoritmo: si el fallo se reproduce con la sonda de límite colocada en el punto medio del rango sospechoso, el bug

La derivación. La bisección es el algoritmo: si el fallo se reproduce con la sonda de límite colocada en el punto medio del rango sospechoso, el bug vive en la primera mitad; de lo contrario, en la segunda. Cada sonda reduce a la mitad el rango, por lo que $\log_{2}(\text{suspicious instructions})$ sondas son suficientes — diez sondas para mil instrucciones. El mismo proceso de reducción a la mitad que ejecuta la escalera ADC ejecuta el bucle de depuración. debug loop.

Worked example 1 — debounce as a state trace. The node's button reads 1, 0, 0, 1 across four 10 ms samples (a bouncing contact). Rule: require two consecutive equal readings. Trace: t = 0 ms reads 1 (no verdict); t = 10 ms reads 0 (one, no verdict); t = 20 ms reads 0 again → stable 0 declared. The 1 at t = 30 ms is one sample, not yet stable, and is correctly ignored. Debounce = N consecutive samples = a timer tick + a GPIO read + a state decision: the whole course in one trace.

Worked example 2 — bisecting the freeze. The node freezes within an hour of a specific log sequence; the suspected region is 1 024 instructions del controlador de comunicaciones. Hacer que la instrucción 512 encienda el LED: si el nodo se congela con el LED aún apagado, el error está en la primera mitad; si el LED se enciende antes de congelar, está en la segunda. Cada ejecución reduce a la mitad la región: 512 → 256 → 128 → … — diez ejecuciones lo acotan a una sola instrucción. La aritmética explica por qué la bisección supera reLeer el código esperando verlo: $2^{10} = 1024$.

Errores comunes. Corregir dos cosas a la vez (una funcionó, otra rompió algo más — ahora hay tres errores). Depurar en una versión diferente del board que la que falla. Y desactivar el watchdog 'por ahora': el fallo de campo que el watchdog habría sobrevivido es exactamente el que llega al cliente.

Resumen. Reproducir, bisecar, fijar uno, re-verificar; $\log_{2}$ sondeos de límite la búsqueda. El debounce convierte el ruido en eventos mediante N muestras consecutivas. La perro guardián es la última línea de defensa: accionarlo solo en el bucle principal, nunca en un ISR.