Bloque 3.1: Arquitecturas: Arduino, ESP8266 y ESP32

1. Introducción: Arduino

Arduino es una plataforma de desarrollo de código abierto basada en hardware y software fácil de usar. Su objetivo principal es democratizar la electrónica para artistas, diseñadores, aficionados y cualquier persona interesada en crear objetos o entornos interactivos. Fue lanzado en 2005 y se ha convertido en un estándar de facto para el prototipado rápido y la educación. [1]

Características Clave de Arduino:

• Microcontrolador: Basado principalmente en microcontroladores AVR de Atmel (por ejemplo, ATmega328P en el UNO).
• Entorno de Desarrollo (IDE): Software gratuito y multiplataforma (Windows, Mac, Linux) con una sintaxis simplificada basada en C/C++.
• Comunidad: Una de las comunidades más grandes y activas de hardware y software libre. Miles de tutoriales, librerías y proyectos disponibles.
• Shield System: Tarjetas de expansión que se conectan directamente al Arduino para añadir funcionalidades específicas (Ethernet, WiFi, Motores, etc.).

2. Avance Tecnológico: ESP8266

El ESP8266, desarrollado por Espressif Systems, no es una plataforma completa como Arduino, sino un chip WiFi SoC (System on Chip) de bajo coste. Contiene un microcontrolador de 32 bits, memoria flash, y una pila TCP/IP completa. Su popularidad creció enormemente cuando se empezaron a comercializar módulos como el ESP-01 y, sobre todo, placas de desarrollo como el NodeMCU, que incorporaban el ESP8266 en un formato compatible con Arduino. [2]

Características Clave del ESP8266:

• Conectividad: WiFi integrado (802.11 b/g/n). Esto es su principal ventaja sobre Arduino.
• Microcontrolador: CPU de 32 bits Tensilica L106, más potente que los AVR de Arduino.
• Software (ESP8266 Core for Arduino): Se puede programar directamente desde el IDE de Arduino, lo que lo hace muy accesible. También se puede programar con otros entornos como MicroPython o directamente con el SDK de Espressif.
• Coste: Muy bajo, lo que lo hace ideal para proyectos IoT económicos.

3. El Sucesor Natural: ESP32

El ESP32 es el sucesor del ESP8266, también diseñado por Espressif. Es un SoC (System on Chip) aún más potente y versátil, que ofrece conectividad dual (WiFi y Bluetooth/Bluetooth Low Energy) y una gran cantidad de periféricos integrados. Se ha convertido rápidamente en una opción preferida para proyectos IoT y mecatrónicos más avanzados. [3]

Características Clave del ESP32:

• Conectividad: WiFi 802.11 b/g/n y Bluetooth 4.2 LE integrados. Esto lo hace ideal para una amplia gama de aplicaciones IoT.
• Microcontrolador: CPU dual-core de 32 bits Tensilica LX6 (puede funcionar en modo single-core a velocidades más altas). Mucho más potente que el ESP8266 y Arduino UNO.
• Recursos: Más memoria RAM y Flash que sus predecesores. Soporta tarjetas microSD.
• Periféricos: Incluye una gran cantidad de periféricos: ADCs (Conversores Analógico-Digital), DACs, touch pads, PWM, UART, SPI, I2C, etc. Incluso incluye hardware dedicado para acelerar operaciones criptográficas.
• Software: Totalmente compatible con el IDE de Arduino. También se puede programar con MicroPython, Rust, JavaScript (ESP-IDF), entre otros.

4. Comparativa: Arduino UNO, ESP8266 (NodeMCU) y ESP32

Entender las diferencias es clave para elegir la plataforma adecuada para tu proyecto.

4.1. Distribución de Pines

Conocer la distribución de pines (pinout) de tu placa es crucial para conectar correctamente sensores, actuadores y otros componentes.

Arduino UNO R3

Pines Digitales (0-13): Pueden funcionar como entradas o salidas digitales (HIGH/LOW). Algunos tienen funciones especiales:

• Pines 0 (RX) y 1 (TX): Usados para la comunicación serial (por ejemplo, para comunicarse con el ordenador o módulos Bluetooth).
• Pines 3, 5, 6, 9, 10, 11: Pueden generar salidas PWM (modulación por ancho de pulso), útiles para controlar la intensidad de LEDs o la velocidad de motores.
• Pines 10, 11, 12, 13: Usados para la comunicación SPI (por ejemplo, con tarjetas SD).

Pines Analógicos (A0-A5): Se pueden usar como entradas analógicas para leer valores de sensores como potenciómetros o sensores de temperatura. En placas más nuevas, algunos de estos pines también pueden funcionar como salidas PWM.

Pines de Alimentación: 5V, 3.3V, GND (Tierra).

NodeMCU ESP8266

El ESP8266 tiene sus propios pines GPIO (General Purpose Input/Output), pero en la placa NodeMCU estos se mapean a etiquetas más amigables (D0, D1, D2, etc.).

Pines GPIO Mapeados (D0-D8): Son los pines principales para entradas y salidas. Algunos tienen funciones especiales:

• D0 (GPIO16): Conectado internamente al circuito de despertar (Wake-up). No tiene interrupciones ni PWM.
• D1 (GPIO5) y D2 (GPIO4): Comunes para comunicación I2C (SCL y SDA).
• D3 (GPIO0): Tiene una función especial en el arranque del microcontrolador. Si se conecta a GND durante el encendido, entra en modo de grabación (flashing mode).
• D4 (GPIO2): También tiene una función especial en el arranque. Debe estar en HIGH durante el arranque para que el chip arranque correctamente.
• D5 (GPIO14), D6 (GPIO12), D7 (GPIO13), D8 (GPIO15): Usados para comunicación SPI. D8 (GPIO15) debe estar en LOW durante el arranque.
• RX (GPIO3) y TX (GPIO1): Pines de comunicación serial principal.

Pines de Alimentación: 3V3, G (GND), Vin (Voltaje de entrada).

Nota: El ESP8266 funciona internamente a 3.3V. Tener cuidado al conectar sensores o módulos que operan a 5V, ya que pueden dañar el microcontrolador.

ESP32 Dev Kit

El ESP32 tiene muchos más pines GPIO que sus predecesores, ofreciendo gran flexibilidad.

Pines GPIO (0-39): Una gran cantidad de pines configurables. Algunos tienen funciones especiales o restricciones:

• GPIO 0, 2, 4, 5, 12-15, 18-19: Tienen funciones especiales durante el arranque (boot) y se deben usar con cuidado. Por ejemplo, GPIO 0 debe estar en HIGH para un arranque normal.
• GPIO 34-39: Son solo entradas. No pueden generar salidas ni se pueden usar con pull-up/pull-down internos.
• GPIO 6-11: Están conectados internamente a la memoria flash y no se deben usar para E/S.
• Múltiples UARTs: El ESP32 tiene 3 UARTs (puertos seriales), lo que permite múltiples conexiones seriales simultáneas.
• Touch Pads: GPIOs específicos se pueden usar como sensores táctiles (T0-T9).
• PWM: La mayoría de los GPIOs pueden generar salidas PWM.

Pines de Alimentación: 3V3, GND, Vin (5V en algunas placas).

Nota: Al igual que el ESP8266, el ESP32 opera a 3.3V. Tener cuidado con componentes de 5V.

4.2. Otras Placas de la Familia Arduino

Además del clásico Arduino UNO, existen otras placas de la familia Arduino diseñadas para necesidades específicas.

Arduino Nano

El Arduino Nano es una versión más pequeña y compacta del Arduino UNO. Mantiene una gran compatibilidad con el UNO en cuanto a pines y funciones, pero su formato reducido lo hace ideal para proyectos donde el espacio es limitado. Utiliza el mismo microcontrolador ATmega328P que el UNO. Es muy popular en proyectos de electrónica, robótica pequeña y wearables.

Arduino Mega 2560

El Arduino Mega 2560 es una versión más potente del UNO, basada en el microcontrolador ATmega2560. Ofrece una gran cantidad de pines de E/S digitales (54) y analógicos (16), además de más memoria (256 KB Flash, 8 KB SRAM). Esto lo hace ideal para proyectos más complejos que requieren controlar muchos sensores, actuadores o dispositivos simultáneamente, como brazos robóticos, impresoras 3D o CNC. También tiene 4 UARTs (puertos seriales) hardware.

Arduino Uno R4

El Arduino Uno R4 es la más reciente iteración del icónico Arduino UNO. En lugar del tradicional microcontrolador ATmega328P, utiliza un microcontrolador ARM Cortex-M0+ de 32 bits (RA4M1 de Renesas). Esto representa un gran salto en potencia de procesamiento, memoria y conectividad:

• Microcontrolador: ARM Cortex-M0+ de 32 bits a 48 MHz.
• Memoria: 256 KB de Flash (8x más que el UNO) y 32 KB de RAM (16x más que el UNO).
• Conectividad: Incorpora un conector USB-C y un conector Qwiic (I2C) para una conexión más fácil con sensores y actuadores modernos.
• Compatibilidad: Mantiene el mismo factor de forma y distribución de pines que el UNO, asegurando la compatibilidad con la gran mayoría de shields existentes.
• Objetivo: Ofrece la potencia de una plataforma de 32 bits manteniendo la simplicidad y familiaridad del UNO.

El Arduino Uno R4 representa una evolución importante, combinando la facilidad de uso del UNO con la potencia de una arquitectura moderna de 32 bits, preparándolo para proyectos más exigentes y futuras tecnologías.

4.3. Entorno de Desarrollo: Arduino IDE

Para programar cualquiera de estas placas, necesitas un entorno de desarrollo. El Arduino IDE (Entorno de Desarrollo Integrado) es el más común y oficial.

Instalación

Descarga el Arduino IDE desde el sitio web oficial (https://www.arduino.cc/en/software) e instálalo siguiendo las instrucciones para tu sistema operativo (Windows, macOS, Linux).

Configuración para ESP8266 y ESP32

El IDE viene preconfigurado para Arduino, pero necesitas añadir soporte para ESP8266 y ESP32:

1. Ve a Archivo > Preferencias.
2. En el campo "Gestor de URLs Adicionales de Tarjetas", pega las siguientes URLs:
   • Para ESP32: https://dl.espressif.com/dl/package_esp32_index.json
   • Para ESP8266: https://arduino.esp8266.com/stable/package_esp8266com_index.json
   (Separa las URLs con una coma si pegas ambas).
3. Ve a Herramientas > Placa > Gestor de Tarjetas.
4. Busca "esp32" y/o "esp8266" e instala los paquetes correspondientes.
5. Selecciona tu placa específica en Herramientas > Placa (por ejemplo, "ESP32 Dev Module" o "NodeMCU 1.0").

Estructura Básica de un Programa (Sketch)

Un programa en Arduino se llama "Sketch". Tiene una estructura básica con dos funciones principales:

• void setup(): Se ejecuta una sola vez al inicio. Aquí se inicializan pines, sensores, comunicación serial, etc.
• void loop(): Se ejecuta repetidamente después de setup(). Aquí va la lógica principal del programa.

Ejemplo Práctico: Hola Mundo con Arduino - Blink

El ejemplo clásico "Blink" hace parpadear el LED integrado en la mayoría de placas Arduino (conectado internamente al pin digital 13).

Código:

                         Copiar
                    ##include <Arduino.h>

/*
  Blink

  Enciende un LED durante un segundo, luego lo apaga durante un segundo, repetidamente.

  La mayoría de placas Arduino tienen un LED integrado conectado al pin 13.
  Si tu placa no tiene uno, puedes conectar un LED externo (con su respectiva resistencia) al pin 13.
*/

// El LED integrado está conectado al pin digital 13 en la mayoría de placas Arduino.
int ledPin = 13;

// La función setup se ejecuta una vez cuando presionas reset o enciendes la placa.
void setup() {
  // Inicializa el pin digital como una salida.
  pinMode(ledPin, OUTPUT);
}

// La función loop se ejecuta una y otra vez para siempre.
void loop() {
  digitalWrite(ledPin, HIGH);  // Enciende el LED (HIGH es el nivel de voltaje que lo enciende)
  delay(1000);                 // Espera un segundo
  digitalWrite(ledPin, LOW);   // Apaga el LED cambiando el voltaje a LOW
  delay(1000);                 // Espera un segundo
}

Instrucciones:

1. Conecta tu placa Arduino al ordenador con un cable USB.
2. En el IDE, ve a Herramientas > Placa y selecciona tu modelo de Arduino (por ejemplo, "Arduino Uno").
3. Ve a Herramientas > Puerto y selecciona el puerto COM asociado a tu placa.
4. Pega el código en el editor del IDE.
5. Haz clic en el botón Verificar (check) para compilar el código.
6. Si no hay errores, haz clic en el botón Cargar (flecha) para subir el código a la placa.
7. ¡Deberías ver el LED integrado parpadear!

Este ejemplo simple introduce conceptos clave: configurar un pin como salida (pinMode), escribir un valor digital a un pin (digitalWrite) y crear un retardo (delay).

5. Galería de Videos Recomendados

Profundiza en las características específicas de cada plataforma.

6. Referencias y Lecturas Recomendadas

• [1] Banzi, M. (2008). Getting Started with Arduino. O'Reilly Media.
• [2] Schwartz, M. (2017). Arduino Cookbook. O'Reilly Media. (Capítulos sobre ESP8266)
• [3] Espressif Systems. (2021). ESP-IDF Programming Guide. https://docs.espressif.com/projects/esp-idf/en/latest/esp32/