De la lógica al microcontrolador

01 · Punto de partida

Cambiar el comportamiento sin cambiar los cables

En el curso anterior armaste una alarma con memoria: una puerta lógica calculaba el próximo estado y un flip-flop lo guardaba en cada flanco del reloj. Para construirla hicieron falta varios circuitos integrados, un reloj y un cableado cuidadoso. Si después querías que la alarma alternara en cada pulsación o contara aperturas, tenías que desarmar y volver a cablear.

Un programador está acostumbrado a lo contrario: el hardware es fijo y el comportamiento se cambia editando código. El microcontrolador lleva esa idea al mundo de los circuitos. Es un chip con entradas y salidas eléctricas cuyo comportamiento está definido por un programa guardado en su memoria.

El punto de partida son los cursos anteriores: niveles lógicos, puertas, registros, contadores y memorias. Nada de eso desaparece; ahora está dentro del chip, y el programa lo controla a través de registros.

02 · Definición

Un computador completo en un solo circuito integrado

Un microcontrolador (MCU, de microcontroller unit) integra en un mismo encapsulado:

• una CPU que ejecuta instrucciones;
• memoria para el programa y para los datos;
• un reloj que marca el ritmo de ejecución;
• periféricos como pines de entrada y salida, temporizadores, conversores analógicos y puertos de comunicación.

Su objetivo no es calcular rápido ni ejecutar muchas aplicaciones, sino interactuar con el mundo físico: leer un pulsador, medir una temperatura, encender un motor, hablar con otro chip. Por eso es pequeño, barato, de bajo consumo y no necesita componentes externos para funcionar, aparte de la alimentación y, a veces, un cristal.

Un microcontrolador normalmente ejecuta un solo programa, sin sistema operativo, desde que se energiza hasta que se corta la alimentación. Ese programa se llama firmware: software que vive pegado al hardware.

03 · Por dentro

Los bloques de un microcontrolador

Todos los microcontroladores comparten una organización parecida. La CPU, las memorias y los periféricos se comunican a través de buses internos; algunos periféricos se conectan al exterior mediante los pines del chip.

Cada bloque ya te resulta conocido. La diferencia es que ahora están construidos en silicio, integrados y listos para configurarse desde el programa.

04 · El cambio de enfoque

El programa reemplaza el cableado

Veamos la alarma del curso anterior. Con lógica cableada, la ecuación Q próximo = NOT R AND (Q OR S) se materializa con puertas y un flip-flop. En un microcontrolador se escribe el mismo comportamiento como código. El sensor S entra por el pin PB0, el botón R por el pin PB4 y la alarma sale por el pin PB1:

#include <avr/io.h>

int main(void) {
    DDRB |= (1 << PB1);            // PB1 es salida; PB0 y PB4 quedan como entradas

    while (1) {
        if (PINB & (1 << PB4)) {
            PORTB &= ~(1 << PB1);  // R: apagar la alarma
        } else if (PINB & (1 << PB0)) {
            PORTB |= (1 << PB1);   // S: encender y recordar
        }
    }
}

No te preocupes todavía por cada símbolo: DDRB, PORTB y PINB son registros de los pines, y los estudiaremos con detalle en los temas 9 y 15. Por ahora fijate en dos ideas:

• Leer PINB equivale a mirar los voltajes de los pines de entrada.
• Escribir PORTB equivale a poner niveles altos o bajos en los pines de salida. Como ese registro conserva su valor, el bit de PORTB hace de memoria: no hizo falta un flip-flop externo.

05 · La estructura básica

Leer, decidir y actuar, una y otra vez

Casi todos los programas de un microcontrolador siguen el mismo esquema. Primero se inicializa el hardware: se configuran pines, temporizadores y comunicación. Después se entra en un bucle infinito que se repite mientras el chip esté alimentado:

1. Leer las entradas: pulsadores, sensores, mensajes recibidos.
2. Decidir qué hacer, usando esas lecturas y las variables que guardan el estado.
3. Actuar sobre las salidas: LED, motores, pantallas, mensajes enviados.

Es el mismo modelo secuencial del curso anterior: próximo estado = f(estado actual, entradas). La diferencia es que el «reloj» que marca cada actualización es ahora la propia ejecución del bucle, y el estado puede vivir en un registro de salida o en una variable en memoria.

Cuánto tarda cada vuelta

Una placa Arduino Uno usa un reloj de 16 MHz. Cada ciclo de reloj dura 1 / 16 000 000 s = 62,5 ns, y la mayoría de las instrucciones del ATmega328P tarda entre uno y dos ciclos. Un bucle de unas diez instrucciones puede entonces repetirse en el orden de un microsegundo, es decir, cerca de un millón de veces por segundo.

Ese tiempo determina la rapidez con que el sistema mira el mundo. Un evento que dure menos que una vuelta del bucle puede pasar inadvertido, igual que el pulso que se perdía entre dos flancos de reloj en el curso anterior. Más adelante veremos cómo las interrupciones y los temporizadores resuelven ese problema sin que la CPU esté vigilando todo el tiempo.

Lo que el hardware hace en paralelo

Aunque la CPU ejecute una instrucción por vez, los periféricos funcionan al mismo tiempo: un temporizador sigue contando, un conversor analógico mide y una UART recibe bytes mientras el programa hace otra cosa. La habilidad central al programar un microcontrolador es delegar en los periféricos todo lo que se pueda y reservar la CPU para decidir.

06 · Un caso concreto

El ATmega328P: nuestro chip de referencia

A lo largo del curso usamos como referencia el ATmega328P, el microcontrolador de la placa Arduino Uno. Es un chip de 8 bits, sencillo, bien documentado y muy difundido. Sus conceptos se trasladan a otras familias como ARM Cortex-M, ESP32 o RP2040: cambian los nombres de los registros, no las ideas.

Comparado con una computadora actual, parece diminuto: miles de veces menos memoria y velocidades que se miden en megahertz en lugar de gigahertz. Pero para encender un LED, leer un sensor de temperatura y enviar el dato por un cable, sobra. Además cuesta poco, consume muy poca energía y no requiere sistema operativo ni disco.

07 · Decidir bien

Cuándo conviene un microcontrolador y cuándo no

Una función simple como «encender un LED mientras un interruptor esté cerrado» no necesita programa: basta una conexión. Un reloj despertador con ajuste de hora, alarma, pantalla y memoria de configuración es un caso típico de microcontrolador: hacerlo con puertas sería un laberinto de chips.

Hay también una zona intermedia. Las señales más rápidas que el microcontrolador puede seguir se resuelven con hardware dedicado, como un contador de alta frecuencia, y el microcontrolador se limita a leer el resultado.

08 · Analogía con programación

Muestrear: qué se pierde entre dos lecturas

El código C del tema depende del chip, así que usamos Python para modelar una idea de fondo: un programa que consulta una entrada cada cierto tiempo solo ve lo que ocurre en esos instantes. La lista sensor_us contiene el valor del sensor en cada microsegundo: un pulso breve de 3 µs y otro más largo de 40 µs. El programa lo consulta cada periodo microsegundos y cuenta los flancos ascendentes.

# Valor del sensor en cada microsegundo (lo que ocurre en el mundo físico).
sensor_us = [0] * 11 + [1] * 3 + [0] * 9 + [1] * 40 + [0] * 20


def contar_pulsos(periodo):
    """Simula un bucle que lee el sensor cada `periodo` microsegundos."""
    previo = 0
    pulsos = 0
    for t in range(0, len(sensor_us), periodo):
        ahora = sensor_us[t]            # leer
        if ahora and not previo:        # decidir: ¿flanco ascendente?
            pulsos += 1                 # actuar
        previo = ahora
    return pulsos


for periodo in (1, 2, 5, 20):
    print(f"Lectura cada {periodo:2d} µs -> {contar_pulsos(periodo)} pulso(s) detectado(s)")

Resultado: con 1 µs y 2 µs se detectan los 2 pulsos; con 5 µs y 20 µs solo se detecta 1. Probá agrandar el pulso breve a 6 µs, o hacerlo más corto, y predecí el resultado antes de ejecutar.

Este modelo anticipa un problema real: si el bucle principal hace demasiadas cosas, tarda más en volver a leer la entrada y puede perderse eventos. Los temas de interrupciones, temporizadores y captura de entrada existen para evitarlo.

La analogía tiene un límite: el modelo ignora los rebotes, el ruido eléctrico y la forma real de las señales. Es una herramienta para razonar sobre el tiempo, no una simulación del chip.

09 · Exploración interactiva

El mismo hardware, cuatro comportamientos

Este microcontrolador virtual tiene un sensor en PB0, un botón R en PB4 y tres LED en las salidas PB1, PB2 y PB3. Elegí un programa, cambiá las entradas y ejecutá una vuelta del bucle por vez. Sin tocar el «circuito», solo cambiando el programa, el comportamiento es otro.

Reset del microcontrolador lleva los registros y las variables a 0 y suelta las entradas. Cambiar de programa produce el mismo efecto, porque al grabar otro firmware el chip arranca de nuevo.

Recorrido guiado

1. Con el programa 1, activá S y ejecutá una vuelta: PB1 se enciende. Desactivá S y ejecutá otra: se apaga. No hay memoria.
2. Cambiá al programa 2. Activá S, ejecutá una vuelta y desactivá S. Ejecutá otra vuelta: PB1 sigue encendido, porque PORTB conserva su valor.
3. Activá R y ejecutá una vuelta: la alarma se borra. Observá cómo se parece a la alarma con flip-flop del curso anterior.
4. Con el programa 3, activá y desactivá S varias veces ejecutando una vuelta en cada cambio. El LED alterna solo con los flancos ascendentes.
5. Con el programa 4, contá pulsaciones hasta 7 y mirá cómo la cuenta vuelve a 0. Usá R para borrarla en cualquier momento.

10 · Método de trabajo

Cómo plantear un problema para un microcontrolador

1. Listá las entradas y las salidas. Distinguí si son digitales (pulsador, LED), analógicas (potenciómetro, sensor de temperatura) o de comunicación (otro chip, la computadora).
2. Definí el estado. ¿Qué debe recordar el sistema? Puede ser un bit de salida, una variable o un dato guardado en EEPROM.
3. Precisá los tiempos. ¿Cada cuánto hay que leer? ¿Cuál es el evento más breve que no se puede perder? ¿Cuánto puede tardar la respuesta?
4. Revisá los niveles eléctricos. Tensión de alimentación y de los sensores, corriente que pide cada salida y compatibilidad entre 5 V y 3,3 V.
5. Elegí los periféricos. Decidí qué hará el hardware (temporizador, ADC, UART) y qué hará el programa.
6. Escribí y probá en pasos pequeños. Empezá encendiendo un LED, luego leé una entrada y agregá funciones de a una.

En la mesa de trabajo, antes de culpar al programa, comprobá lo básico: la alimentación (con el multímetro), la masa común, el capacitor de desacople cerca del chip y el estado del reset. Cuando el comportamiento es temporal, un osciloscopio o un analizador lógico muestra lo que el multímetro no puede: flancos, anchos de pulso y rebotes.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. ¿Cableado o microcontrolador?

Decidí cuál de las dos opciones resulta más razonable: (a) encender un LED cuando dos interruptores están cerrados, sin cambios futuros; (b) medir una temperatura, compararla con un valor configurable y mostrar el resultado; (c) contar pulsos de una señal de 500 MHz; (d) un semáforo con tiempos configurables mediante un menú.

2. Tiempo de una vuelta

Un bucle principal tarda 40 ciclos de reloj con un reloj de 16 MHz. ¿Cuánto dura una vuelta y qué ancho mínimo debe tener un pulso para estar seguro de detectarlo?

3. Seguir el programa 3

El programa «Alternar» parte con PB1 = 0 y previo = 0. El sensor vale, en seis vueltas consecutivas: 0, 1, 1, 0, 1, 0. ¿Cuál es el valor de PB1 después de cada vuelta?

4. Cambiar una prioridad sin tocar un cable

En la alarma queremos que, si S y R valen 1 a la vez, gane la detección. ¿Qué cambia en el programa?

5. ¿Entra en el ATmega328P?

Un proyecto necesita 12 KB de código, 300 bytes de variables y 200 bytes de configuración que deben sobrevivir cuando se desconecta la alimentación. ¿En qué memoria va cada cosa y alcanza la capacidad?

13 · Síntesis

Ideas para recordar

¿Listo para el tema 2?

Antes de avanzar, explicá con tus palabras la diferencia entre un microcontrolador y un microprocesador, nombrá cuatro bloques internos con su equivalente en lógica digital y describí por qué un pulso muy breve puede perderse. Si podés justificar las tres respuestas, ya tenés el mapa general.

En el próximo tema vamos a recorrer las familias de microcontroladores (AVR, ARM Cortex-M, ESP32, RP2040 y PIC) y los criterios para elegir el más adecuado para cada proyecto.