Circuitos · Arduino

Arduino y ESP32 en el simulador de circuitos

En el simulador de circuitos la placa no es un dibujo: tu programa en C++ de Arduino se compila y corre contra el circuito real, con voltajes, corrientes, PWM, interrupciones y el monitor serie. Si el LED no tiene resistencia se quema y si cortocircuitas un pin te avisa, igual que en la mesa del laboratorio (pero sin quemar nada).

1. Las placas

La placa se alimenta por USB (5 V de la computadora) o por VIN; lo eliges en sus propiedades. Sus pines 5V y 3V3 sirven para alimentar sensores y módulos pequeños, y todo debe compartir el GND de la placa.

2. Escribe el programa

1. De la paleta, rama Arduino, coloca la placa y arma el circuito a su alrededor (LED con resistencia, botón, sensores…).
2. Pulsa el botón </> Código del Arduino de la barra. Se abre el panel con el editor: arriba eliges la placa (si tienes varias), Verificar, Subir y Ejemplos con fragmentos listos (Blink, parpadeo sin delay con millis, desvanecer con PWM, LCD, servo, teclado, DHT, HX711, ESP32…).
3. Escribe setup() y loop() como en el IDE de Arduino.
4. Verificar compila sin simular y te dice cuánta memoria de programa usa el boceto. Si hay un error, ves la línea y una pista.
5. El programa se compila solo al pulsar ▶ Iniciar. Si lo cambias mientras simulas, Subir lo vuelve a compilar y reinicia la placa (como el botón de subir del IDE).

Conviene poner la velocidad de la simulación en 1 s/s (tiempo real): así un delay(1000) dura un segundo de verdad.

3. Monitor serie y graficador

La pestaña Monitor serie muestra lo que la placa envía con Serial.print():

• Texto o Graficador; autodesplazamiento y marca de tiempo; Limpiar.
• La velocidad (baudios) del monitor debe ser la misma que la de Serial.begin(): si no coincide, lo que envíes llega como basura y el simulador te lo advierte. Con el ESP32 el monitor arranca en 115200.
• Para enviar datos a la placa escribe en la caja de abajo, elige el fin de línea (sin fin de línea, nueva línea, retorno de carro o ambos) y pulsa Enviar; en el programa los lees con Serial.available(), Serial.read(), Serial.parseInt() o Serial.readStringUntil('\n').
• El Graficador dibuja números: envía uno por línea con Serial.println(valor) o varios con nombre separados por comas: luz:512,umbral:400. Cada nombre aparece en la leyenda con su valor actual.

4. Bibliotecas

En el ESP32, WiFi.h, WebServer.h, HTTPClient.h y BluetoothSerial.h compilan para que tu programa no falle, pero la red no se simula: el monitor te avisa con un mensaje [IngSimulator].

5. Cómo se simula el tiempo

• Cada instrucción del Arduino Uno toma alrededor de 1 µs y las funciones de la placa cuestan lo mismo que en el microcontrolador: digitalWrite ≈ 4.5 µs, digitalRead ≈ 4.8 µs, analogRead ≈ 112 µs. El ESP32 es unas cuatro veces más rápido por instrucción.
• delay() y delayMicroseconds() dejan avanzar el circuito; millis() y micros() cuentan el tiempo simulado.
• Las salidas cambian en el instante exacto en que tu programa las escribe, así que el PWM, los pulsos de un servo o el disparo de un HC-SR04 tienen la duración correcta en el osciloscopio.
• El puerto serie transmite a la velocidad real: a 9600 baudios caben unos 960 caracteres por segundo. Si imprimes más rápido, Serial.print() se detiene a esperar, como en la placa.
• Algunas bibliotecas tardan lo mismo que las reales: el LCD con I²C tarda cerca de un segundo en iniciar y el DHT solo entrega una lectura nueva cada 2 s.

6. Ejercicio: brillo de un LED con un potenciómetro

1. Abre Ejemplos → Arduino: potenciómetro → brillo con PWM, o arma tú: potenciómetro de 10 kΩ entre 5V y GND con el cursor en A0, y un LED con 220 Ω en el pin 9.
2. Programa:

   void setup() {
     Serial.begin(9600);
   }
   void loop() {
     int lectura = analogRead(A0);          // 0 a 1023
     int brillo = map(lectura, 0, 1023, 0, 255);
     analogWrite(9, brillo);                // PWM de 490 Hz
     Serial.print("lectura:"); Serial.print(lectura);
     Serial.print(",brillo:"); Serial.println(brillo);
     delay(50);
   }

3. Pon la velocidad en 1 s/s y pulsa ▶ Iniciar. Abre Monitor serie → Graficador y gira el potenciómetro: con la rueda del ratón sobre él o cambiando su posición en Propiedades.
4. Pon el osciloscopio en el pin 9: verás la señal PWM de 490 Hz y, en Medidas, el ciclo de trabajo que cambia con el potenciómetro.

7. Ejemplos incluidos

En Ejemplos hay circuitos completos con su programa: Blink, botón con INPUT_PULLUP, potenciómetro y PWM, fotorresistencia con graficador, barrido de un servo, distancia con HC-SR04 en un LCD, cerradura con teclado 4×4 y LCD I²C, semáforo con botón para peatones, contador con display de 7 segmentos, velocidad de un motor DC con transistor, sentido de giro con puente H, estación de temperatura con DHT22, báscula con HX711 y tres del ESP32 (parpadeo y monitor a 115200, ADC y DAC con graficador, PWM con LEDC).

8. Errores típicos

• El monitor no muestra nada: falta Serial.begin() en setup(), o los baudios del monitor no coinciden.
• Un pin en cortocircuito: una salida está conectada directo a GND, a 5 V o a otra salida. Revisa el cableado y agrega la resistencia.
• El botón lee valores al azar: la entrada está flotante; usa pinMode(pin, INPUT_PULLUP) o una resistencia de pull-down.
• LCD I²C en blanco: «ningún dispositivo responde en la dirección 0x27»; revisa SDA, SCL, la alimentación y la dirección del módulo.
• ESP32: Servo.h no funciona (usa ESP32Servo.h), los pines 34–39 no son salidas y sus entradas no toleran 5 V.

9. De la simulación a la placa

Con Exportar → Diseñar la PCB de este circuito el Arduino Uno se vuelve la huella de un shield (con los conectores en su lugar) y el Nano o el ESP32 su huella de tiras de pines; los módulos (LCD, HC-SR04, relé, DHT…) reciben su propia huella. Sigue con la guía de PCB.