Electronica, Robotica e IoT con Elixir de 0 a Hero: indice del curso

Este curso enseña a construir dispositivos que perciben el mundo físico, deciden algo con esa información y actúan sobre el entorno, usando Elixir como lenguaje conductor. No empieza en el código: empieza en la carga eléctrica, en el voltaje y en la ley de Ohm, porque un programa que enciende un LED sin una resistencia calculada quema el LED por más elegante que sea el código.

El recorrido va de la electricidad básica a una flota de dispositivos con GPS reportando posición por MQTT a un tablero de Grafana. Entre ambos extremos hay 18 capítulos que cubren circuitos, componentes, herramientas de taller, la familia completa de controladores disponibles hoy, los protocolos de IoT, la máquina virtual de Erlang corriendo dentro de un microcontrolador de 520 KB de RAM, la alimentación solar de un nodo autónomo y siete proyectos completos con su código.

A quién va dirigido

El curso está escrito para tres perfiles que llegan por caminos distintos y necesitan cosas distintas del mismo material.

Programadores que nunca han tocado hardware. Si escribes software y el mundo físico te parece una caja negra, este es el punto de entrada. Los primeros cuatro capítulos no asumen ningún conocimiento de electrónica: explican qué es una carga, por qué una resistencia limita la corriente, cómo se lee un esquemático y cómo se mide con un multímetro. La ventaja de venir del software es que el modelo de procesos de Elixir y OTP encaja de forma natural con la lectura concurrente de varios sensores, y eso se aprovecha desde el capítulo 13 en adelante.

Gente de electrónica que quiere salir de C. Si ya sabes conectar un transistor pero programas todo en C sobre el bucle principal, los capítulos de fundamentos se leen rápido como repaso y el valor está en la segunda mitad: AtomVM ejecutando bytecode de la BEAM en un ESP32, el modelo de procesos supervisados aplicado a firmware, Nerves para dispositivos con Linux y Elixir Circuits para hablar GPIO, I2C, SPI y UART desde procesos aislados que se reinician solos.

Estudiantes y aficionados que quieren un mapa completo. El problema típico al aprender robótica no es la falta de tutoriales, es que cada tutorial vive aislado y nadie explica cómo se conectan entre sí la ley de Ohm, la elección del microcontrolador, el protocolo I2C y el tablero de telemetría. Este curso es exactamente ese mapa, y cada capítulo dice de dónde viene y hacia dónde va.

Qué sabrás hacer al terminar

Al cerrar el capítulo 18 tendrás la capacidad de llevar un proyecto embebido de la idea al dispositivo funcionando, sin depender de que alguien más resuelva las partes incómodas.

• Calcular una resistencia limitadora, un divisor de tensión, una constante RC y el consumo promedio de un nodo, con las fórmulas y no por tanteo.
• Leer un esquemático, armar el circuito en protoboard, simularlo antes de conectarlo y medir con multímetro y osciloscopio para saber si lo que pasa es lo que creías que iba a pasar.
• Elegir el controlador correcto para un proyecto concreto con un método defendible, en vez de usar siempre la misma placa porque es la que conoces.
• Programar un ESP32 en Elixir sobre AtomVM: GPIO, I2C, temporizadores, procesos, supervisión, WiFi y un servidor HTTP embebido.
• Extender la máquina virtual con NIFs y port drivers en C cuando la funcionalidad que necesitas no existe todavía.
• Montar la cadena completa de IoT: dispositivo, broker MQTT, base de series temporales, tablero de Grafana y automatizaciones en Home Assistant, con su modelo de amenazas y sus actualizaciones OTA.
• Dimensionar un panel solar, un controlador de carga y una batería para que un nodo sobreviva varios días nublados sin intervención humana.
• Construir los siete proyectos integradores del curso y modificarlos para tu propio caso.

Qué necesitas para partir

No hace falta comprar todo antes de empezar. Los capítulos 1 a 3 se pueden leer con papel, lápiz y un simulador; el material físico se vuelve necesario a partir del capítulo 4.

Momento del curso	Qué necesitas	Por qué
Capítulos 1 a 3	Un computador y un simulador de circuitos	Se calcula y se simula antes de conectar
Capítulos 4 a 7	Multímetro, protoboard, cables, resistencias, LED, pulsadores	Primeras mediciones y montajes reales
Capítulos 8 a 12	Una placa ESP32, cable USB de datos, sensor I2C	Conectividad, buses y telemetría
Capítulos 13 a 15	La misma ESP32, más servos o motores y un puente H	Proyectos con AtomVM
Capítulos 16 a 18	Raspberry Pi opcional, módulo GPS, panel solar pequeño	Nerves, energía y flota

El kit mínimo para seguir el curso completo es modesto. Esta es la lista que cubre todos los ejercicios sin comprar de más.

Elemento	Cantidad	Nota
Placa ESP32 con USB	1	Es la placa central del curso
Protoboard de 830 puntos	1	Con dos rieles de alimentación
Cables macho-macho y macho-hembra	40	Los hembra sirven para servos y sensores
Resistencias surtidas	1 juego	Al menos 220 ohm, 1 k, 4.7 k y 10 k
LED de varios colores	10	Para las prácticas de corriente y PWM
Pulsadores táctiles	5	Entradas digitales y antirrebote
Potenciómetro de 10 k	2	Lectura analógica y ajuste de umbrales
Sensor I2C, por ejemplo BME280 o MPU6050	1	Se usa desde el capítulo 10
Servo pequeño tipo SG90	1	Actuador para los proyectos
Multímetro digital	1	La herramienta más importante del taller

En software, el curso trabaja con Elixir instalado en el computador, la cadena de herramientas de AtomVM para ESP32, PlatformIO como entorno unificado de compilación, un simulador de circuitos y un broker MQTT local. Cada capítulo indica su instalación cuando corresponde, y todas las herramientas usadas son de código abierto o tienen una edición gratuita suficiente.

Herramienta	Para qué se usa	Capítulo donde aparece
Elixir y Mix	Lenguaje y sistema de construcción de todo el curso	5
ngspice	Simulación de circuitos antes de armarlos	3
KiCad o EasyEDA	Esquemáticos y diseño de placas	12
PlatformIO	Compilación y carga de firmware	11
AtomVM	Máquina virtual de la BEAM en el microcontrolador	13
Mosquitto	Broker MQTT local para las pruebas	10
Grafana	Visualización de telemetría	11
Home Assistant	Automatización local	11
Nerves	Firmware Linux con Elixir	16

La ruta de aprendizaje

Los 18 capítulos se agrupan en cinco bloques temáticos. Cada bloque resuelve una pregunta distinta, y el siguiente no se sostiene sin el anterior.

flowchart TD
    subgraph B1["Bloque 1 · Fundamentos de electrónica"]
        C1["Cap 1<br/>Historia y primeros conceptos"]
        C2["Cap 2<br/>Electricidad y medición"]
        C3["Cap 3<br/>Circuitos y Kirchhoff"]
        C4["Cap 4<br/>Componentes y herramientas"]
        C1 --> C2 --> C3 --> C4
    end

    subgraph B2["Bloque 2 · Controladores y cómputo"]
        C5["Cap 5<br/>Sistemas incrustados y lenguajes"]
        C6["Cap 6<br/>555, PIC16F877a, Basic Stamp"]
        C7["Cap 7<br/>Arduino y Raspberry Pi"]
        C8["Cap 8<br/>ESP32, STM32, nRF52"]
        C9["Cap 9<br/>Jetson, Kria, FPGA, ASIC"]
        C5 --> C6 --> C7 --> C8 --> C9
    end

    subgraph B3["Bloque 3 · IoT y ecosistema"]
        C10["Cap 10<br/>IoT, MQTT e I2C"]
        C11["Cap 11<br/>PlatformIO, Home Assistant, Grafana"]
        C12["Cap 12<br/>CAD, compras, RTOS y ROS"]
        C10 --> C11 --> C12
    end

    subgraph B4["Bloque 4 · Elixir en el microcontrolador"]
        C13["Cap 13<br/>AtomVM y entorno"]
        C14["Cap 14<br/>NIFs, ports y Popcorn"]
        C15["Cap 15<br/>Proyectos AtomVM"]
        C13 --> C14 --> C15
    end

    subgraph B5["Bloque 5 · Producto real"]
        C16["Cap 16<br/>Nerves, Circuits, GRiSP"]
        C17["Cap 17<br/>Energía solar"]
        C18["Cap 18<br/>Cuatro proyectos ESP32"]
        C16 --> C17 --> C18
    end

    C4 --> C5
    C9 --> C10
    C12 --> C13
    C15 --> C16

La dependencia entre bloques no es decorativa. Cada uno aporta una capacidad concreta que el siguiente da por instalada, y esa cadena es lo que permite que el capítulo 18 construya una flota de dispositivos sin volver a explicar qué es un divisor de tensión.

flowchart LR
    E["Electricidad<br/>y circuitos"] -->|"sé calcular<br/>y medir"| P["Elección<br/>de plataforma"]
    P -->|"sé qué placa<br/>usar y por qué"| R["Protocolos<br/>y telemetría"]
    R -->|"el dato viaja<br/>y se ve"| V["Elixir sobre<br/>el hardware"]
    V -->|"proceso supervisado<br/>hablando con pines"| D["Dispositivo<br/>autónomo"]
    D -->|"energía, OTA<br/>y flota"| PR["Producto"]

Tabla resumen de los 18 capítulos

Capítulo	Qué aprendes	Con qué sales
1. Historia y primeros conceptos	Cómo se llegó de los autómatas mecánicos a los sistemas embebidos, y el ciclo capturar, procesar y actuar	Vocabulario de electrónica y una idea clara de qué es un sistema embebido
2. Fundamentos de electricidad	Carga, voltaje, corriente, resistencia, ley de Ohm, potencia, energía, AC y DC, seguridad	Capacidad de medir con multímetro y de calcular consumo y disipación
3. Fundamentos de circuitos	Serie y paralelo, nodos y mallas, leyes de Kirchhoff, divisores, condensadores y constante RC	Un circuito analizado y simulado antes de tocar un cable
4. Componentes y herramientas	Resistencias, condensadores, diodos, LED, transistores, MOSFET, reguladores, sensores y actuadores	Un taller mínimo funcionando y criterio para elegir cada componente
5. Sistemas incrustados y lenguajes	Microcontrolador contra microprocesador, metal desnudo, RTOS y máquina virtual; C, C++, Rust, MicroPython y Elixir	Un criterio de lenguaje basado en memoria, latencia y ergonomía
6. Controladores clásicos	El temporizador 555, el PIC16F877a y el Parallax Basic Stamp con sus fórmulas y su modelo de programación	Capacidad de leer y reutilizar diseños antiguos que siguen vigentes
7. Arduino y Raspberry Pi	Arquitectura del ATmega328P y del BCM2712, GPIO real, entornos y cuándo usar cada uno	La distinción operativa entre microcontrolador y computador de placa única
8. ESP32, STM32 y nRF52	Conectividad WiFi y BLE, consumo, periféricos, toolchains y criterios de selección	La placa correcta elegida con datos y no por costumbre
9. Jetson, Kria, FPGA y ASIC	Cómputo intensivo en el borde, lógica programable y silicio a medida	Un método de decisión para todo el espectro de controladores
10. IoT y el protocolo I2C	Arquitectura IoT completa, MQTT paquete por paquete, seguridad, flota y OTA; el bus I2C hasta el bit	Un dispositivo que publica datos y un bus depurado con criterio
11. PlatformIO, Home Assistant y Grafana	Compilación unificada, automatización local, series temporales y tableros	Telemetría visible y automatizaciones que reaccionan a tus sensores
12. CAD, compras, RTOS y ROS	EDA y CAD 3D, compra de componentes sin sorpresas, tiempo real y ROS	Piezas diseñadas, componentes comprados y vocabulario de robótica
13. AtomVM y entorno	Cómo la BEAM corre en un ESP32, sus componentes internos y el entorno de desarrollo	Elixir ejecutándose en tu microcontrolador
14. NIFs, ports y Popcorn	Extender la máquina virtual en C, port drivers con estado y Elixir en el navegador con WASM	Capacidad de añadir lo que la VM no trae y de controlar el equipo a distancia
15. Proyectos AtomVM	Máquina arcade, robot de combate con puente H y tablero de mensajes con HTTP y NVS	Tres proyectos completos entendidos de punta a punta
16. Nerves, Circuits y GRiSP	Firmware Linux con particiones A/B, GPIO supervisado, Soleil, Beam Bots y Erlang sobre RTEMS	El ecosistema BEAM aplicado a hardware de producto
17. Energía solar	Efecto fotovoltaico, curva I-V, PWM contra MPPT, químicas de batería y dimensionamiento	Un nodo autónomo que sobrevive varios días sin sol
18. Proyectos con ESP32	Serial bidireccional, control remoto, sensores y una flota con GPS, paso a paso	Cuatro proyectos integradores que combinan todo lo anterior

Bloque 1: fundamentos de electrónica

Este bloque existe porque la mayoría de los fallos de un proyecto embebido no son fallos de software. Un sensor que devuelve valores erráticos casi siempre tiene un problema de alimentación, de referencia de masa o de resistencia mal calculada, y ninguna cantidad de depuración en el editor lo arregla. Los cuatro capítulos construyen la capacidad de razonar sobre el circuito antes de escribir la primera línea.

Capítulo 1: De los autómatas a los sistemas embebidos

Historia de la robótica y primeros conceptos de electrónica

Recorre la línea que va de los mecanismos de los hermanos Banu Musa y los muñecos karakuri japoneses al telar de Jacquard, el Unimate, el transistor y los microcontroladores actuales, explicando qué problema concreto resolvió cada invento y qué limitación heredó el siguiente. La segunda mitad entra en electrónica desde cero con el ciclo capturar, procesar y actuar, que es el esqueleto de todo lo que se construye después en el curso.

• Por qué la programabilidad nació en la industria textil y no en el cálculo.
• Qué cambió el Unimate en la línea de montaje y qué no pudo cambiar.
• El transistor como conmutador y como amplificador, en su versión conceptual.
• El ciclo sensor, procesamiento, actuador aplicado a ejemplos cotidianos.

Capítulo 2: Fundamentos de electricidad

Carga, voltaje, corriente y medición

Desarrolla las magnitudes eléctricas que sostienen cualquier proyecto: qué es la carga, cómo se relacionan voltaje, corriente y resistencia a través de la ley de Ohm, cómo se calculan potencia y energía, en qué se diferencian corriente alterna y continua. Cierra con las reglas de seguridad al trabajar con baterías y con la práctica de medir de verdad con un multímetro, que es la diferencia entre suponer y saber.

• La ley de Ohm aplicada a la resistencia limitadora de un LED, con el cálculo completo.
• Potencia disipada y por qué una resistencia de un cuarto de watt se quema.
• Diferencia entre capacidad en miliamperio hora y energía en watt hora.
• Cómo medir voltaje, corriente y continuidad sin dañar el instrumento.

Capítulo 3: Fundamentos de circuitos

Serie, paralelo, Kirchhoff y condensadores

Pasa del circuito de un solo elemento al análisis completo: conexiones en serie y paralelo, nodos y mallas, las dos leyes de Kirchhoff, divisores de tensión y de corriente, condensadores y la constante RC. Incluye el mapa real de conexiones internas de una protoboard, cómo se lee un esquemático y cómo simular con ngspice antes de conectar nada.

• Cuándo un divisor de tensión sirve como adaptador de nivel y cuándo no.
• La constante RC como base del antirrebote y del filtrado.
• Las rutas ocultas de la protoboard que provocan cortocircuitos inexplicables.
• Una simulación completa que se compara con la medición real.

Capítulo 4: Componentes electrónicos y herramientas del taller

Catálogo razonado de componentes y equipamiento

Presenta los componentes que aparecerán durante todo el curso con el cálculo que determina cada valor: resistencias, condensadores, diodos, LED, transistores bipolares, MOSFET, reguladores lineales y conmutados, sensores y actuadores. La segunda parte cubre el equipamiento mínimo, cautín, multímetro, osciloscopio y fuente regulable, cómo usarlo correctamente y qué comprar primero cuando el presupuesto es limitado.

• Por qué un MOSFET reemplaza al transistor bipolar en conmutación de potencia.
• Diodo de rueda libre: qué destruye si no está y por qué.
• Regulador lineal contra convertidor conmutado en términos de calor y eficiencia.
• Un orden de compra de herramientas según lo que desbloquea cada una.

Bloque 2: controladores y plataformas de cómputo

Con los fundamentos resueltos aparece la pregunta que define el proyecto: qué pone la inteligencia. Este bloque recorre el espectro completo, del circuito integrado de cincuenta centavos al silicio diseñado a medida, y termina con un método de decisión que se aplica en el resto del curso.

Capítulo 5: Sistemas incrustados y los lenguajes que los programan

Del metal desnudo a la máquina virtual

Define qué es un sistema incrustado, en qué se diferencia un microcontrolador de un microprocesador y cuáles son los tres modelos de ejecución posibles: metal desnudo, sistema operativo de tiempo real y máquina virtual. Después escribe el mismo programa en Assembler, C, C++, Rust, MicroPython y Elixir sobre AtomVM, para comparar con código y no con opiniones.

• El mismo parpadeo de un LED en seis lenguajes, completo y compilable.
• Los compromisos reales de memoria, latencia y velocidad de desarrollo.
• Por qué una máquina virtual puede ser una decisión razonable en un microcontrolador.
• Qué significa determinismo y cuándo el proyecto lo exige de verdad.

Capítulo 6: Los controladores clásicos

555, PIC16F877a y Basic Stamp

Profundiza en tres controladores que definieron décadas de electrónica y que siguen resolviendo problemas hoy: el temporizador 555, el microcontrolador PIC16F877a y el módulo Parallax Basic Stamp. Se explica la arquitectura interna de cada uno, sus fórmulas de diseño y su modelo de programación, con ejemplos completos en Elixir, en C con XC8 y en PBASIC.

• Las fórmulas de astable y monoestable del 555, deducidas y aplicadas.
• La arquitectura Harvard del PIC y sus bancos de registros.
• Por qué el Basic Stamp bajó la barrera de entrada a la electrónica.
• Qué de estos tres integrados sigue apareciendo en diseños actuales.

Capítulo 7: Arduino y Raspberry Pi

Microcontrolador contra computador de placa única

Compara las dos plataformas más difundidas mostrando cómo funcionan por dentro: la arquitectura del ATmega328P frente a la del BCM2712, qué es realmente un pin GPIO en cada una, qué entornos de desarrollo existen y cómo se programan desde Elixir. Incluye tablas de referencia de pines y de modos de operación.

• Qué ocurre en el silicio cuando escribes un uno en un registro de puerto.
• Por qué un sistema con Linux no puede garantizar un pulso de microsegundos.
• Cuándo conviene combinar ambas placas en un mismo proyecto.
• El costo real en consumo y en arranque de elegir una computadora completa.

Capítulo 8: ESP32, STM32 y nRF52

Conectividad, consumo y criterios de selección

Analiza las tres familias que dominan la robótica y el IoT profesional: el ESP32 con WiFi y Bluetooth integrados, el STM32 con su control determinista y sus series de bajo consumo, y el nRF52 con su radio Bluetooth de baja energía muy eficiente. Revisa arquitecturas internas, periféricos, modos de sueño y cadenas de herramientas.

• Los modos de sueño del ESP32 y su consumo medido en microamperios.
• Temporizadores avanzados del STM32 para control de motores.
• Presupuesto de energía de un nodo que despierta cada quince minutos.
• Una tabla de selección que cruza conectividad, consumo, precio y ecosistema.

Capítulo 9: Cómputo avanzado en el borde

Jetson, Kria, FPGA y ASIC

Sube del microcontrolador a las plataformas de cómputo intensivo que viven dentro del robot: los módulos Nvidia Jetson con aceleradores de inferencia, los módulos AMD Kria que combinan procesadores ARM con lógica programable, las FPGA como hardware que se reescribe y los ASIC como silicio hecho a medida. Cierra con el método de elección que ordena todo el bloque.

• Qué problema resuelve una FPGA que un procesador no puede resolver.
• Cuándo la inferencia debe ocurrir en el dispositivo y no en el servidor.
• El punto de volumen a partir del cual un ASIC deja de ser absurdo.
• Un árbol de decisión aplicable a cualquier proyecto del curso.

Bloque 3: IoT, protocolos y ecosistema

Un dispositivo aislado tiene poco valor. Este bloque conecta el hardware con el resto del mundo: los protocolos con los que habla, las herramientas con las que se construye y se visualiza, y la infraestructura de diseño y compra que sostiene un proyecto real.

Capítulo 10: IoT de punta a punta y el bus I2C

Arquitectura, MQTT y el bus I2C sin misterios

Desarrolla la arquitectura completa de un sistema IoT por capas, con los protocolos de radio disponibles y MQTT explicado paquete por paquete: calidad de servicio, mensajes retenidos, testamento y listas de control de acceso por tema. Incluye el modelo de amenazas real y la gestión de flota con actualizaciones remotas con particiones A y B. La segunda mitad desarma el bus I2C hasta el bit.

• Los tres niveles de calidad de servicio de MQTT y cuándo cada uno importa.
• Cálculo de resistencias de pull-up para un bus de colector abierto.
• El mapa de direcciones reservadas y qué hacer ante dos sensores con la misma.
• Cómo depurar un bus congelado con osciloscopio y con software.

Capítulo 11: Herramientas del ecosistema

PlatformIO, Home Assistant, Grafana y dashboards

Recorre las cuatro herramientas que convierten un microcontrolador aislado en un sistema de telemetría completo: PlatformIO como entorno unificado de compilación y carga, Home Assistant como cerebro de automatización local, Grafana como capa de visualización sobre bases de series temporales, y la construcción de tableros que responden preguntas en vez de mostrar gráficos decorativos.

• Un archivo de configuración de PlatformIO explicado línea por línea.
• Descubrimiento automático de dispositivos por MQTT en Home Assistant.
• Consultas de series temporales que agregan por ventana de tiempo.
• Qué panel poner primero cuando el tablero debe detectar fallas.

Capítulo 12: CAD, compra de componentes, RTOS y ROS

Del dibujo a la pieza y del hilo al robot

Cubre las herramientas de diseño asistido usadas en robótica, separadas en dos familias: las de diseño electrónico para esquemáticos y placas, con KiCad, EasyEDA, Eagle, Proteus y Wokwi, y las de diseño mecánico para carcasas y piezas, con FreeCAD, OpenSCAD, Tinkercad y Fusion. Después explica cómo comprar componentes sin sorpresas de costo y cierra con sistemas operativos de tiempo real y con Robot Operating System.

• El flujo completo de esquemático a archivos de fabricación.
• Costos reales de importación y compra local, con el detalle chileno.
• Qué garantiza un RTOS que un bucle principal no puede garantizar.
• El modelo de nodos y temas de ROS comparado con procesos y mensajes de OTP.

Bloque 4: Elixir dentro del microcontrolador

Aquí el curso cambia de naturaleza. Hasta el capítulo 12 el objetivo era entender el hardware; desde el 13 el objetivo es programarlo con el modelo de concurrencia de la BEAM, con procesos aislados, supervisión y mensajes, dentro de un chip que tiene menos memoria que una imagen.

Capítulo 13: AtomVM, la BEAM dentro de un microcontrolador

Fundamentos y entorno de desarrollo

Explica qué es AtomVM y cómo consigue ejecutar bytecode de Erlang y Elixir en un ESP32 con menos de medio megabyte de memoria. Recorre su arquitectura interna componente por componente: el cargador de módulos, el planificador de procesos, el recolector de basura por proceso, la capa de plataforma y las librerías incluidas. Termina montando el entorno completo y cargando el primer programa.

• Por qué un recolector de basura por proceso evita las pausas globales.
• Qué subconjunto de la biblioteca estándar está disponible y qué no.
• El flujo de compilar, empaquetar y grabar en la placa.
• El primer programa en Elixir corriendo sobre el microcontrolador.

Capítulo 14: Extender AtomVM

NIFs, port drivers, Popcorn y control remoto

Enseña a salir de los límites de la máquina virtual: escribir funciones nativas en C, construir port drivers con estado propio y decidir cuál de los dos corresponde en cada caso. Después lleva el mismo AtomVM al navegador con Popcorn y WebAssembly, y cierra convirtiendo un ESP32 en punto de acceso WiFi con un servidor HTTP que recibe comandos desde el teléfono.

• La regla práctica para elegir entre función nativa y port driver.
• Qué pasa cuando una función nativa bloquea el planificador.
• Elixir ejecutándose dentro de una pestaña del navegador.
• Un control remoto por WiFi sin infraestructura externa.

Capítulo 15: Tres proyectos AtomVM de punta a punta

Máquina arcade, Coliseo Atómico y Tagboard

Desarma tres proyectos reales construidos sobre AtomVM y ESP32: un gabinete arcade que traduce un potenciómetro y dos botones en teclas para el motor de juegos TIC-80, un robot de combate con puente H L298N y un servo controlado por radio, y un tablero de mensajes que sirve HTTP y guarda datos en la memoria no volátil de la placa. De cada uno se revisa la arquitectura, el hardware y el código.

• Lectura analógica convertida en eventos discretos sin rebotes.
• Control de dos motores con puente H y su lógica de dirección.
• Persistencia en NVS para que la configuración sobreviva al corte de energía.
• Cómo se estructura un proyecto AtomVM en procesos supervisados.

Bloque 5: del prototipo al producto

El último bloque resuelve lo que separa un montaje en protoboard de un dispositivo que funciona solo durante meses: firmware actualizable, alimentación autónoma y proyectos integradores que combinan todo el curso.

Capítulo 16: Hardware avanzado con la BEAM

Nerves, Elixir Circuits, Soleil, Beam Bots y GRiSP

Recorre el ecosistema de hardware que ejecuta la máquina virtual de Erlang más allá de AtomVM: cómo Nerves construye firmware Linux mínimo con particiones A y B y actualizaciones remotas, cómo Elixir Circuits habla GPIO, I2C, SPI y UART desde procesos supervisados, cómo Soleil sostiene un nodo con batería y panel solar, cómo Beam Bots plantea una alternativa a ROS con OTP puro y cómo GRiSP corre Erlang sobre metal desnudo con RTEMS.

• Un proyecto Nerves completo, del generador al firmware grabado.
• Supervisión aplicada a drivers de hardware que fallan de verdad.
• Actualización remota con reversión automática si el arranque falla.
• Cuándo conviene Nerves y cuándo basta con AtomVM.

Capítulo 17: Energía solar para nodos IoT autónomos

Paneles, controladores de carga, baterías y dimensionamiento

Explica cómo alimentar un nodo con energía solar sin adivinar: el efecto fotovoltaico y la curva corriente contra voltaje, los tipos de panel, los controladores de carga por modulación de ancho de pulso frente a los de seguimiento del punto de máxima potencia con el algoritmo de perturbar y observar, las químicas de batería y el cálculo de dimensionamiento completo.

• Por qué un panel entrega su máxima potencia solo en un punto de la curva.
• El presupuesto energético diario de un nodo que duerme la mayor parte del tiempo.
• Cuántos días de autonomía pedirle a la batería y qué cuesta cada día extra.
• Protecciones que evitan que la batería se descargue por completo.

Capítulo 18: Cuatro proyectos con ESP32

De un botón por serial a una flota con GPS

El capítulo final construye los cuatro proyectos integradores del curso, cada uno paso a paso y con su código completo. Empieza con comunicación serial bidireccional entre la placa y el computador, sigue con control remoto, incorpora sensores y termina con una flota de dispositivos que reportan posición por GPS, cerrando la cadena que empezó en el capítulo 2 con la ley de Ohm.

• Un protocolo propio sobre serial, con tramas delimitadas y verificación.
• Lectura de un módulo GPS y análisis de sus sentencias.
• Publicación de posición por MQTT y visualización en un tablero.
• Qué cambia cuando pasas de un dispositivo a veinte.

Cómo recorrer el curso

El orden numérico es el orden recomendado, y no es arbitrario: cada capítulo asume el vocabulario y las técnicas del anterior. Aun así, hay rutas razonables según de dónde vengas.

flowchart TD
    INICIO{"¿De dónde vienes?"}
    INICIO -->|"Software, sin electrónica"| R1["Ruta completa<br/>Capítulos 1 a 18 en orden"]
    INICIO -->|"Electrónica, quiero Elixir"| R2["Repaso rápido 1 a 4<br/>luego 5, 8, 10 y salto a 13"]
    INICIO -->|"Elixir, quiero hardware"| R3["Capítulos 2 a 4 completos<br/>luego 8, 13, 14, 15"]
    INICIO -->|"Necesito un producto IoT"| R4["Capítulos 8, 10, 11<br/>luego 16, 17 y 18"]

    R1 --> PRACTICA["Práctica obligatoria:<br/>montar cada circuito<br/>antes de avanzar"]
    R2 --> PRACTICA
    R3 --> PRACTICA
    R4 --> PRACTICA
    PRACTICA --> CIERRE["Proyectos de los<br/>capítulos 15 y 18"]

Estas son las recomendaciones que más diferencia hacen en el resultado.

Lee un capítulo, monta un capítulo. El material está escrito para que cada capítulo tenga al menos un montaje o un programa que se pueda ejecutar. Leer tres capítulos seguidos sin construir nada produce la sensación de entender sin la capacidad de hacer. Un capítulo por sesión, con su montaje, rinde más que cuatro capítulos leídos de corrido.

Mide antes de creer. Cuando el capítulo dice que en ese punto del circuito hay 3.3 voltios, mídelo. Cuando dice que el consumo en sueño profundo es de microamperios, mídelo. La diferencia entre el valor calculado y el medido es la parte que todavía no entiendes, y encontrarla temprano ahorra horas de depuración después.

Simula lo que no puedas medir. Los capítulos 3 y 12 introducen simuladores por una razón práctica: permiten equivocarse sin quemar componentes. Un circuito que se comporta mal en el simulador se comporta peor en la protoboard.

No te saltes el capítulo 2 aunque te parezca elemental. Es el capítulo del que más dependen los demás. Los errores más frecuentes en proyectos avanzados son errores de la ley de Ohm mal aplicada o de masas mal conectadas, no errores de arquitectura de software.

Repite los proyectos con una variación propia. Los capítulos 15 y 18 traen siete proyectos completos. Construirlos tal cual enseña la mitad; modificarlos, agregando un sensor distinto o cambiando el transporte de los datos, enseña la otra mitad, porque obliga a entender por qué cada pieza está donde está.

Ritmo de práctica. La forma más efectiva de avanzar es alternar: una sesión de lectura y cálculo, una sesión de montaje y medición. Los bloques 1 y 2 se pueden avanzar más rápido si ya tienes base; los bloques 4 y 5 conviene tomarlos con más calma, porque el código y el hardware se depuran juntos y eso siempre es más lento que depurar solo software.

Errores comunes al empezar el curso

Estos son los tropiezos que aparecen con más frecuencia en las primeras semanas, con su causa y su solución.

Error	Causa	Solución
El LED se quema al primer encendido	Se conectó sin resistencia limitadora	Calcular la resistencia con la ley de Ohm antes de conectar, capítulo 2
La placa no aparece como puerto serial	Se está usando un cable USB solo de carga	Cambiar por un cable con líneas de datos y verificar el controlador USB
El sensor entrega valores erráticos	Masas no conectadas entre sí o alimentación con caídas	Unir todas las masas a un punto común y medir el voltaje bajo carga
El bus I2C no responde a ningún dispositivo	Faltan las resistencias de pull-up o son de valor incorrecto	Calcular los pull-ups según el capítulo 10 y verificar con un escaneo del bus
El microcontrolador se reinicia al mover un servo	La fuente no entrega la corriente de arranque del motor	Alimentar el actuador con una fuente aparte y unir masas
Los cálculos no coinciden con la medición	Se ignora la tolerancia de las resistencias y la caída de los cables	Medir el valor real de los componentes y trabajar con rangos, no con valores exactos
El proyecto en protoboard falla de forma intermitente	Contactos flojos o rutas internas mal entendidas	Revisar el mapa de la protoboard del capítulo 3 y reemplazar cables sospechosos
El programa en Elixir no carga en la placa	Versión de la cadena de herramientas distinta a la del proyecto	Fijar las versiones indicadas en el capítulo 13 antes de compilar

Ejercicios antes de empezar

Estos ejercicios no requieren haber leído ningún capítulo y sirven para saber en qué punto de partida estás.

1. Escribe con tus palabras qué hace un microcontrolador que un computador de escritorio no hace bien, y guarda la respuesta para compararla al terminar el capítulo 7.
2. Busca en tu casa tres dispositivos que contengan un sistema embebido e identifica en cada uno cuál sería el sensor, cuál el procesamiento y cuál el actuador.
3. Si tienes un multímetro, mide el voltaje de una pila alcalina nueva y de una usada. Anota ambos valores; el capítulo 2 explica por qué la diferencia importa menos de lo que parece.
4. Haz la lista de los componentes del kit mínimo y busca sus precios en dos tiendas distintas. El capítulo 12 vuelve sobre esta comparación con criterios de compra.
5. Instala Elixir en tu computador y ejecuta un programa que imprima la suma de los números del 1 al 100. Es todo el Elixir que necesitas para llegar al capítulo 13.

Fuente y créditos

El temario de este curso está basado en la guía Elixir Robotics de la comunidad Elixir Chile, disponible en https://elixircl.github.io/elixir-robotics/. Esa guía define el recorrido temático que aquí se sigue: la secuencia de fundamentos de electricidad y circuitos, el repaso de controladores clásicos y modernos, la introducción a IoT y al bus I2C, el tratamiento de AtomVM y del ecosistema Nerves, la energía solar y los proyectos prácticos con ESP32.

Este material es una reelaboración propia y extendida. El texto, los diagramas, las tablas, los ejemplos de código, los ejercicios y las secciones de errores comunes fueron escritos para este curso y no reproducen literalmente el contenido de la fuente. Cada capítulo desarrolla los temas con mayor extensión, agrega los cálculos completos donde la guía original enuncia el concepto, e incorpora material que no está en el temario original, como el análisis de las plataformas de cómputo en el borde del capítulo 9 y el detalle de dimensionamiento del capítulo 17.

El reconocimiento va a la comunidad Elixir Chile por haber ordenado un campo que suele enseñarse en fragmentos inconexos, y por publicar la guía de forma abierta.

Si vas a citar este curso, cita también la fuente original: sin ese temario, este material no existiría en esta forma.

Con el mapa completo a la vista, el punto de entrada es el capítulo 1, que empieza por el principio real de esta historia: los mecanismos que automatizaron tareas mucho antes de que existiera la electricidad.