Teoría del todo

Parte VI · Robótica e IoT

Microcontroladores

en cursoÚltima actualización: 26 de octubre de 2026 · Primera versión del capítulo

Se construye sobre: Del sumador a la CPU, Sensores y actuadores

Abre el control remoto del televisor, la lavadora, el horno microondas, el cepillo eléctrico, la llave del carro. En casi todos vas a encontrar un chip negro, a veces del tamaño de una lenteja, que nadie llama computador y que sin embargo lo es: tiene un procesador, memoria para el programa, memoria para los datos y patas que hablan con botones, luces y motores. Es un microcontrolador, y probablemente hay varias decenas en tu casa. Son los computadores más numerosos del mundo y los más invisibles.

Este capítulo une dos caminos del libro. Por uno llegamos a la CPU de juguete, que busca, decodifica y ejecuta instrucciones al ritmo de un reloj. Por el otro, a los sensores y actuadores, que traducen el mundo en voltajes y los voltajes en movimiento. El microcontrolador es el lugar donde se encuentran. Y como es la pieza con la que casi todo el mundo empieza en robótica e IoT, al final hay un primer proyecto paso a paso.

Un computador entero en un chip

Tu computador de escritorio reparte el trabajo entre muchas piezas: un procesador, módulos de memoria RAM aparte, un disco, una tarjeta de video, y encima de todo un sistema operativo que reparte el tiempo entre cientos de programas. Un microcontrolador mete lo esencial en un solo chip y corre un solo programa, desde que recibe energía hasta que se la quitan. El ATmega328P del Arduino Uno, por ejemplo, tiene un procesador de 8 bits a 16 MHz, 32 KB de memoria flash para el programa y 2 KB de RAM. Dos kilobytes: más o menos una página de texto plano. El ESP32, en su versión clásica, es otra liga: dos núcleos de 32 bits hasta 240 MHz, unos 520 KB de RAM, y radio de wifi y Bluetooth en el mismo chip.

Placa azul Arduino Uno vista desde arriba, con un chip negro alargado de 28 patas, un conector USB metálico, un conector de alimentación y filas de pines negros en los bordes
Un Arduino Uno. El chip largo de abajo es el ATmega328P, el microcontrolador; casi todo lo demás es ayuda: el conector USB para programarlo, la entrada de alimentación y las filas de pines, los digitales arriba y los de alimentación y entradas analógicas abajo.Foto: Suyash Dwivedi · CC BY-SA 4.0 · Wikimedia Commons

Lo que los hace microcontroladores, más que su tamaño, son los periféricos que traen integrados: pines de entrada y salida, el conversor analógico-digital, temporizadores, generadores de PWM y circuitos de comunicación. Hay también una diferencia de arquitectura interesante. En la máquina que se suele asociar a von Neumann, programa y datos comparten memoria; en un AVR como el del Uno, el programa vive en la flash y los datos en la RAM, por buses separados, una organización de tipo Harvard. Los dos diseños calculan lo mismo, en el sentido de lo que se puede computar; lo que cambia es la ingeniería.

Pines: donde el bit se vuelve voltaje

Un pin GPIO (entrada y salida de propósito general) se configura por programa. Como salida, el chip lo conecta por dentro, con transistores, al voltaje de alimentación (un 1, HIGH) o a tierra (un 0, LOW). Puede entregar unos pocos miliamperios, suficiente para un LED con su resistencia, insuficiente para un motor o un relé, que necesitan un transistor de por medio. Como entrada, el pin mide el voltaje y decide si es alto o bajo comparándolo con unos umbrales: es la frontera donde un voltaje continuo se vuelve un valor de la lógica booleana. Cuidado con los voltajes: el Uno trabaja a 5 V y el ESP32 a 3,3 V, y no conviene meterle 5 V a un pin del ESP32.

Una entrada sin nada conectado no lee 0: queda flotando, y cualquier campo cercano la hace saltar entre 0 y 1. La solución es la resistencia de pull-up, que la amarra suavemente al voltaje alto. Con un botón entre el pin y tierra, el pin lee 1 en reposo y 0 cuando lo aprietas. Casi todos los microcontroladores traen esas resistencias por dentro y se activan con una línea de código.

Y aun así el botón te va a engañar. Los contactos metálicos no se cierran de una vez: rebotan durante algunos milisegundos, y el pin ve una ráfaga de ceros y unos. Para un programa que cuenta pulsaciones, una sola pulsación son cinco. Se arregla de dos maneras. Por programa, aceptando un cambio solo cuando el valor se mantiene estable unos milisegundos. Por circuito, con un filtro RC, que suaviza la ráfaga como explica condensadores y bobinas, seguido de una entrada con histéresis, un disparador de Schmitt, del que hablaremos enseguida.

El bucle que nunca termina

Un programa de Arduino tiene dos funciones obligatorias. setup() corre una vez al encender: configura los pines, abre el puerto serie. loop() corre después, una y otra vez, para siempre. No hay un “final del programa”: el microcontrolador vive dentro de ese bucle, leyendo, decidiendo y actuando. Es el mismo ciclo de buscar-decodificar-ejecutar, un piso más arriba. El lenguaje es C++ con una biblioteca que esconde los registros del chip; en el ESP32 también se puede programar en MicroPython. Qué gana y qué pierde cada estilo lo cuenta lenguajes y paradigmas.

Hay un error de principiante que conviene evitar desde ya: delay(1000) detiene el programa un segundo entero, y durante ese segundo el microcontrolador no ve nada. Si quieres parpadear un LED y atender un botón, en vez de esperar se consulta el reloj (millis() devuelve los milisegundos desde el encendido) y se actúa solo cuando pasó el tiempo. El bucle sigue girando, y nada se queda sin atender.

Temporizadores e interrupciones

Por dentro, el chip tiene temporizadores: contadores que avanzan con el reloj sin que la CPU haga nada. Con ellos se miden tiempos, se genera el PWM y se cronometra el eco de un sensor de ultrasonido. Y está la otra forma de enterarse de las cosas. En vez de preguntar una y otra vez si el botón cambió (eso se llama sondeo), se le pide al hardware que avise: una interrupción. Cuando ocurre el evento, la CPU guarda lo que estaba haciendo, salta a una función corta, la rutina de interrupción, y luego vuelve exactamente donde iba. Es la diferencia entre mirar el celular cada minuto y dejar que suene. La regla de oro: la rutina de interrupción debe ser brevísima, apenas levantar una bandera, y el trabajo pesado se hace en el loop().

Decidir sin parpadear

El primer programa útil de casi todo el mundo es un termostato: si hace calor, prende el ventilador. La versión ingenua es una línea: prender si la temperatura pasa de 27 °C. Juega con ella antes de seguir.

Juega · un microcontrolador de juguete

Cada 300 ms corre una vuelta de loop(): lee el termistor con un ADC de 12 bits (con ±0,6 °C de ruido), convierte el código a grados y decide si el ventilador va prendido. Mueve la temperatura del cuarto y compara con y sin histéresis.

20253035prende 28 °Capaga 26 °Cventilador (últimas 60 vueltas)apagado
codigo  = analogRead(SENSOR);   // —
grados  = aGrados(codigo);       // — °C
if (!prender && grados >= 28) prender = true;
if ( prender && grados <= 26) prender = false;
digitalWrite(VENTILADOR, prender); // LOW

Ventilador apagado

Esperando la primera vuelta del loop…

Pon el modo de umbral simple con el cuarto en 27 °C. La lectura tiene ruido, como toda lectura real, y se pasea por encima y por debajo del umbral. En sesenta vueltas del bucle el ventilador cambia de estado unas treinta veces. Con un LED es feo; con un relé o un compresor es ruina, porque cada arranque los desgasta. La solución es la histéresis: dos umbrales en vez de uno. Prender a 28 °C, apagar a 26 °C, y entre los dos, no cambiar nada. Ahora la decisión depende de la temperatura y del estado actual; el sistema tiene memoria, como los flip-flops del camino a la CPU. Formalmente la salida ya no es una función de la lectura sola, sino del par (estado, lectura):

Para que funcione, la banda tiene que ser más ancha que el ruido. En la animación el ruido es de ±0,6 °C, una oscilación de 1,2 °C de pico a pico, y la banda es de 2 °C: una lectura que acaba de prender el ventilador, con 28 °C o más, no puede caer por ruido hasta 26 °C. Sube el cuarto despacio de 24 a 31 °C y verás un solo cambio. El disparador de Schmitt del botón es exactamente esto, hecho con transistores. Lo que este juguete no hace es dejar que el ventilador enfríe el cuarto; cuando el actuador cambia lo que el sensor mide, el lazo se cierra, y diseñarlo bien es tema de control y retroalimentación. Tu cuerpo, de paso, hace algo parecido con su temperatura.

Hablar con otros chips

Un sensor moderno no siempre entrega un voltaje: muchos traen su propio ADC y mandan el número ya hecho, en bits, por alguno de tres protocolos que vas a encontrar en todas partes.

UART: dos cables, uno para transmitir y otro para recibir, sin reloj compartido. Los dos lados acuerdan de antemano la velocidad (por ejemplo 115.200 baudios) y cada byte va enmarcado entre un bit de inicio y uno de parada. Es lo que usa el monitor serie para que tu programa te escriba en el computador.

I2C: dos cables, datos y reloj, compartidos por muchos dispositivos, cada uno con su dirección. Las líneas solo se pueden jalar a 0; vuelven a 1 gracias a resistencias de pull-up, otra vez ellas. Lento y económico en cables: ideal para colgar varios sensores del mismo par.

SPI: cuatro cables (reloj, datos de ida, datos de vuelta y una línea de selección por dispositivo). Más rápido que I2C, a costa de más cables. Lo usan pantallas y tarjetas de memoria.

Los tres son acuerdos sobre qué significa cada voltaje en cada instante, y como todo canal real, pueden corromperse; por eso muchos sensores añaden un byte de verificación, la idea de los códigos a escala de protoboard.

Dormir para durar

Un ESP32 con el wifi activo consume del orden de cien miliamperios, con picos mayores al transmitir. En sueño profundo, el chip solo baja a unos pocos microamperios, aunque muchas placas de desarrollo gastan bastante más por su regulador y sus luces. La diferencia lo es todo para un sensor con batería. Si despierta un segundo cada diez minutos a 100 mA y duerme el resto a 10 µA, su corriente promedio es

y una batería ideal de 2000 mAh duraría unas 11.000 horas, más de un año, frente a 20 horas despierto todo el tiempo. Es una cuenta idealizada, sin autodescarga ni pérdidas, pero muestra dónde está la palanca: en el tiempo despierto, no en el procesador. Es energía repartida en el tiempo, y es la lógica que lleva a protocolos de radio como el de IoT y LoRa.

Tu primer proyecto: un ventilador que se cuida solo

El juguete de arriba se puede armar de verdad en una tarde, con una placa ESP32, un termistor NTC de 10 kΩ, una resistencia de 10 kΩ, un LED con su resistencia de 330 Ω y, para la segunda parte, un ventilador pequeño de 5 V, un transistor y un diodo.

1. El divisor. Termistor entre 3,3 V y el pin 34; resistencia de 10 kΩ entre el pin 34 y tierra. A 25 °C las dos resistencias son iguales, el pin queda en 1,65 V y el ADC de 12 bits lee 2048. Al calentarse, la resistencia del termistor baja y la lectura sube. (En el ESP32 clásico, usa pines del ADC1, del 32 al 39: el ADC2 no se puede usar mientras el wifi está activo.)

2. Leer. Sube un programa que solo haga Serial.println(analogRead(34)) y mira los números en el monitor serie. Agarra el termistor con los dedos: deberías ver la lectura subir. Si no cambia, revisa el cableado antes que el código.

3. Convertir. Del código al voltaje, del voltaje a la resistencia con la fórmula del divisor, de la resistencia a la temperatura con la ecuación beta, la misma que usa la animación. No esperes precisión de laboratorio: el ADC del ESP32 tiene fama de no ser muy lineal, y un error de uno o dos grados es normal sin calibrar.

4. Decidir. Agrega la histéresis y prende el LED del pin 25. Así queda el programa completo:

const int SENSOR = 34;       // un pin del ADC1 del ESP32
const int VENTILADOR = 25;   // va al transistor, no al motor
bool prendido = false;

float aGrados(int codigo) {
  float v = (codigo + 0.5) / 4096.0 * 3.3;        // código → voltios
  float r = 10000.0 * (3.3 / v - 1.0);            // voltios → ohmios
  float invT = 1.0 / 298.15 + log(r / 10000.0) / 3950.0;
  return 1.0 / invT - 273.15;                     // ohmios → °C
}

void setup() {
  pinMode(VENTILADOR, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  float grados = aGrados(analogRead(SENSOR));
  if (!prendido && grados >= 28) prendido = true;
  if ( prendido && grados <= 26) prendido = false;
  digitalWrite(VENTILADOR, prendido ? HIGH : LOW);
  Serial.println(grados);
  delay(300);
}

5. Mover algo. Cambia el LED por el ventilador, pero no al pin: el pin va a la base (o compuerta) del transistor, el transistor conecta el ventilador a tierra, el ventilador se alimenta de 5 V, y el diodo va en paralelo con el ventilador, en inversa, porque un motor también es una bobina. Tierras comunes. Si funciona, acabas de cerrar el recorrido de este libro desde el voltaje hasta un programa que siente y actúa.

A partir de ahí, los caminos se abren: mandar la temperatura por wifi a una base de datos, controlar la velocidad con PWM en vez de prender y apagar, sumar más sensores y motores hasta tener un robot. Todos empiezan igual que este: un bucle que lee, decide y actúa, una y otra vez.