Fundamentos · 12 min de lectura

Cómo entender un código de Arduino: léelo línea por línea

Cómo entender un código de Arduino: librerías, pines, setup y loop, funciones y condiciones if, un ejemplo explicado línea por línea y su paso a ESP32 y Pico.

Saber cómo entender un código de Arduino es la diferencia entre copiar un proyecto esperando que funcione y hacerlo realmente tuyo. Casi todos los códigos que encuentras en internet, en libros o que te pasa un compañero siguen el mismo esqueleto: arriba las librerías y las definiciones de pines, en el medio un setup() que se ejecuta una vez, abajo un loop() que se repite para siempre y, si hace falta, algunas funciones propias. Cuando reconoces ese esqueleto, puedes mirar un código que nunca viste y decir "esta línea lee tal pin y, en tal caso, enciende tal motor".

En esta guía vas a aprender un método paso a paso para leer código de Arduino. Primero conocerás las partes de un sketch y lo que hace cada una; después desarmaremos, línea por línea, el código de un pequeño bote de basura cuya tapa se abre al acercar la mano. Luego veremos cómo leer variables, condiciones y funciones, cómo adaptar el código de otra persona a tu circuito y cómo pasar el mismo código a un ESP32 y a una Raspberry Pi Pico. Al final verás cómo practicar con la pestaña "Entender el código" de BlueGrays.

Placa Arduino Uno y sus pines
Cada número de pin del código corresponde a una marca de la placa: la línea const int TRIG_PIN = 9 te dice que el cable va en el orificio marcado D9.

La anatomía de un código de Arduino

Los códigos de Arduino (sketches) siguen siempre el mismo orden de arriba abajo. El compilador lee el archivo de principio a fin, pero la placa lo ejecuta en otro orden: primero se preparan las declaraciones globales, luego setup() corre una vez y después loop() se repite mientras la placa tenga energía. La tabla resume las partes que verás al abrir un código y cómo reconocerlas:

Parte del códigoQué haceLínea típicaCómo reconocerla
ComentariosExplican el código; el compilador los ignora// nota o /* ... */Empiezan con //, en gris en el IDE
LibreríasAgregan código listo (servo, pantalla, sensor)#include <Servo.h>Empiezan con #, hasta arriba
Definiciones de pines y constantesPonen nombre a los números de pin y a los umbralesconst int LED_PIN = 13;Suelen ser nombres en MAYÚSCULAS
Variables globales y objetosDatos accesibles desde cualquier parte del códigoint count = 0; Servo lidServo;Fuera de cualquier función
setup()Se ejecuta una vez al encenderpinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Se repite sin fin; aquí ocurre el trabajo realif (distance < 20) { ... }void loop() { ... }
Funciones propiasAgrupan una tarea que se repitelong readDistanceCm() { ... }Bloques aparte, arriba o abajo de loop

¿Por dónde empezar? Un método en cinco pasos

  1. Lee los comentarios y las librerías. Las líneas #include delatan el hardware: Servo.h significa un servo, LiquidCrystal_I2C.h una pantalla LCD I2C, DHT.h un sensor de temperatura.
  2. Anota los pines en un papel. Convierte cada línea const int o #define en una lista de conexiones como "TRIG = D9, ECHO = D10" y compárala con tu circuito.
  3. Lee setup(). Ahí ves qué pines son entradas y cuáles salidas, la velocidad del puerto serie y cómo arranca la placa (servo cerrado, LED apagado, etc.).
  4. Ejecuta loop() una vez a mano. Elige un valor del sensor (por ejemplo 45 cm) y sigue el código línea por línea con ese valor; anota en qué bloque if entras y qué variable cambia.
  5. Entra en las funciones cuando haga falta. Si ves una llamada como readDistanceCm() dentro de loop(), adivina primero qué hace por su nombre y luego abre la función para comprobarlo.

Código de ejemplo: análisis línea por línea

Para practicar elegimos el código de un proyecto real: un sensor ultrasónico HC-SR04 detecta una mano que se acerca, un servo abre la tapa y la cierra tres segundos después, mientras tanto se enciende un LED y el número de aperturas aparece en el monitor serie. El código tiene de todo: librería, constantes, variable global, objeto, setup, loop, condición y una función propia. Échale primero un vistazo completo y después lo recorremos línea por línea con la tabla.

C++ (Arduino IDE)
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h>                  // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9;             // HC-SR04 TRIG
5const int ECHO_PIN = 10;            // HC-SR04 ECHO
6const int SERVO_PIN = 6;            // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13;             // durum LED'i / status LED
8const int OPEN_DISTANCE = 20;       // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90;          // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0;         // kapalı kapak açısı / closed lid angle
11
12Servo lidServo;                     // servo nesnesi / servo object
13int openCount = 0;                  // kaç kez açıldı / how many times it opened
14
15void setup() {
16  Serial.begin(9600);
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.attach(SERVO_PIN);
21  lidServo.write(CLOSED_ANGLE);     // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25  long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26  Serial.print("Mesafe / Distance: ");
27  Serial.println(distance);
28
29  if (distance > 0 && distance < OPEN_DISTANCE) {
30    openCount++;                    // sayacı bir artır / add one to the counter
31    digitalWrite(LED_PIN, HIGH);
32    lidServo.write(OPEN_ANGLE);     // kapağı aç / open the lid
33    delay(3000);                    // 3 sn açık kal / stay open for 3 s
34    lidServo.write(CLOSED_ANGLE);   // kapağı kapat / close the lid
35    digitalWrite(LED_PIN, LOW);
36    Serial.print("Acilma sayisi / Times opened: ");
37    Serial.println(openCount);
38  }
39  delay(100);                       // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);     // 10 µs tetik darbesi / 10 µs trigger pulse
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);  // en fazla 30 ms bekle / wait at most 30 ms
50  return duration / 58;             // µs'yi cm'ye çevir / convert µs to cm
51}
LíneaQué hace¿Qué pasa si la cambias?
#include <Servo.h>Agrega la librería Servo al códigoSi la borras, el compilador dice "'Servo' does not name a type"
const int TRIG_PIN = 9;Le pone el nombre TRIG_PIN al pin 9Si mueves el cable, solo cambias este número
const int OPEN_DISTANCE = 20;Distancia umbral para abrir la tapaCon 30, la tapa se abre desde más lejos
Servo lidServo;Crea un objeto servo llamado lidServoTodas las líneas siguientes deben usar el mismo nombre
int openCount = 0;Contador global, en cero al encenderSi lo pasas dentro de loop(), vuelve a cero en cada vuelta y siempre muestra 1
lidServo.attach(SERVO_PIN);Conecta el servo al pin 6Si la olvidas, el servo no se mueve nunca
long distance = readDistanceCm();Llama a la función y guarda el resultadodistance solo existe dentro de loop()
if (distance > 0 && distance < OPEN_DISTANCE)Entra al bloque si las dos condiciones son verdaderasdistance > 0 descarta el 0 que llega cuando no vuelve el eco
delay(3000);Hace esperar a la placa 3 segundosDurante ese tiempo el Arduino no revisa nada más
return duration / 58;Convierte el tiempo del eco en centímetrosEl sonido va y vuelve: cerca de 58 µs por centímetro

Ahora ejecutemos loop() a mano con dos situaciones. Sin nadie delante, el sensor mide 45 cm: distance vale 45, el monitor serie muestra "Mesafe / Distance: 45", la condición 45 < 20 es falsa, así que se salta el bloque, la placa espera 100 ms y loop() vuelve a empezar. Eso se repite unas diez veces por segundo. Si acercas la mano a 12 cm, las dos condiciones son verdaderas: openCount pasa de 0 a 1, el LED se enciende, el servo gira a 90 grados, la placa espera tres segundos, la tapa se cierra, el LED se apaga y el monitor muestra "Acilma sayisi / Times opened: 1". Seguir un código con números reales es la forma más segura de entenderlo.

Fíjate en un detalle más: si pulseIn() no recibe eco en 30 ms, devuelve 0. Sin la comprobación distance > 0, ese 0 medido frente al vacío contaría como "menor que 20" y la tapa se abriría sin motivo. Los códigos bien escritos están llenos de pequeñas comprobaciones como esta; si no entiendes por qué está una línea, bórrala un momento y mira qué pasa. Cómo funciona el sensor lo explicamos en la guía del sensor ultrasónico HC-SR04, y la versión completa del proyecto con dos sensores en la del bote de basura inteligente.

Variables y tipos de datos: las etiquetas de las cajas

Una variable es una caja con etiqueta donde guardas un número o un texto. La palabra al inicio de la línea indica el tipo de caja, es decir, qué cabe dentro. En el Arduino Uno, elegir el tipo equivocado provoca errores silenciosos: si guardas millis() en un int, por ejemplo, el número se vuelve negativo a los 32 segundos más o menos.

TipoRango (Arduino Uno)Uso típico
intde -32 768 a 32 767Números de pin, valores de analogRead, contadores
longunos ±2100 millonesDuración de pulseIn, números grandes
unsigned longde 0 a unos 4290 millonesTiempos de millis() y micros()
floatNúmeros con decimales, 6–7 cifras de precisiónCálculos de temperatura, voltaje y distancia
booltrue o false¿Algo está encendido o apagado?
bytede 0 a 255Valores PWM, números pequeños
char / StringUn carácter / textoComandos del puerto serie, textos de pantalla

También importa dónde se declara una variable; eso se llama alcance. En el ejemplo, openCount está declarada fuera de toda función, así que es global: su valor se conserva en cada vuelta de loop(). distance, en cambio, se declara dentro de loop(): es local, nace en cada vuelta y desaparece al terminarla. Una variable con const delante es una constante y el programa no puede cambiarla mientras corre. Si quieres profundizar, mira nuestra guía de fundamentos de programación con Arduino y, para guardar varios valores en una sola variable, la de arrays en Arduino.

Cómo leer condiciones, bucles y funciones

  • if / else if / else: léelo como "si ... entonces haz esto, si no, haz aquello". Las llaves { } muestran qué líneas dependen de la condición.
  • Comparaciones: == significa "igual a", != "distinto de", < "menor que", >= "mayor o igual que". && quiere decir "y", || "o", ! "no".
  • Bucle for: lee for (int i = 0; i < 5; i++) como "i empieza en 0, repite mientras i sea menor que 5 y súmale uno en cada vuelta"; el bloque se ejecuta 5 veces.
  • Bucle while: while (digitalRead(BUTTON_PIN) == HIGH) se lee "espera mientras el botón no esté presionado"; si la condición nunca cambia, el código se queda trabado ahí.
  • switch / case: el programa toma un camino distinto según el valor de una variable; si olvidas el break al final de un case, también se ejecuta el siguiente.
  • Definición de función: en long readDistanceCm(), long es el tipo del valor que devuelve, readDistanceCm su nombre y los paréntesis vacíos indican que no recibe parámetros. Las funciones que empiezan con void no devuelven nada, solo hacen un trabajo.
Hay dos trampas que se escapan fácilmente al leer código. if (x = 5) no es una comparación sino una asignación de 5 a x, y la condición siempre es verdadera; lo correcto es if (x == 5). La segunda: el punto y coma al final de if (distance < 20); anula la condición y el bloque de abajo se ejecuta en cada vuelta. El compilador no marca error en ninguno de los dos casos, así que lee esas líneas con mucha atención.

Reconocer las funciones de las librerías

En una línea como lidServo.write(90), el punto indica que la función write pertenece al objeto lidServo: "lidServo, ve a 90 grados". Hay tres formas fáciles de saber qué hace una función de una librería: en el Arduino IDE 2, pasar el cursor por encima para leer su descripción o hacer clic derecho y elegir Go to Definition; abrir los ejemplos de la librería desde Archivo > Ejemplos; o revisar la lista de funciones en el archivo .h de la librería. Explicamos cómo instalar librerías en la guía cómo agregar una librería en Arduino. Estas son las funciones básicas que verás en casi cualquier código:

FunciónQué haceEjemplo
pinMode(pin, modo)Configura un pin como entrada o salidapinMode(13, OUTPUT);
digitalWrite(pin, valor)Pone una salida en 5 V (HIGH) o 0 V (LOW)digitalWrite(13, HIGH);
digitalRead(pin)Lee si una entrada está en HIGH o en LOWdigitalRead(2)
analogRead(pin)Convierte 0–5 V en un número de 0 a 1023analogRead(A0)
analogWrite(pin, 0–255)Ajusta con PWM el brillo de un LED o la velocidad de un motoranalogWrite(9, 128);
delay(ms)Detiene la placa durante el tiempo indicadodelay(1000);
millis()Milisegundos desde que se encendióif (millis() - last > 500)
Serial.begin / print / printlnEnvía texto al monitor serieSerial.println(distance);
map(x, a, b, c, d)Lleva un rango de valores a otromap(value, 0, 1023, 0, 180)
pulseIn(pin, HIGH)Mide la duración de un pulso en µspulseIn(10, HIGH, 30000)

Para la lista completa con ejemplos detallados, revisa nuestra guía de comandos de Arduino. Entender la diferencia entre delay() y millis() es de lo más útil para leer códigos; la guía millis y delay la explica con ejemplos.

Adaptar el código de otra persona a tu circuito

  1. Saca una tabla de conexiones del código. Escribe todas las constantes de pines una debajo de otra: ese es el circuito de quien escribió el código.
  2. Compárala con tu circuito. Si usaste otros pines, no muevas los cables: cambia solo los números de las líneas const y deja el resto del código igual.
  3. Revisa las diferencias de librerías. Dos librerías con el mismo nombre pueden usar funciones distintas; en las pantallas LCD I2C, la dirección 0x27 o 0x3F es además el desajuste más común.
  4. Ojo con activo en LOW y activo en HIGH. La mayoría de los módulos relé se activan con LOW; si el código enciende con HIGH, tu relé hará exactamente lo contrario.
  5. Iguala la velocidad del puerto serie. Si el código tiene Serial.begin(115200), elige también 115200 en el monitor serie; si no, verás caracteres sin sentido.
  6. Prueba por partes. Primero haz funcionar solo la parte que lee el sensor y, cuando los valores se vean bien, agrega el motor y la pantalla.
El monitor serie es una linterna que metes dentro de tu código. Si no entiendes por qué una condición no se cumple, agrega justo antes del if una línea como Serial.println(distance) y mira con qué valor se compara de verdad. Tienes más detalles en la guía del monitor serie de Arduino.

Pasar el mismo código a un ESP32

El ESP32 también se programa con el Arduino IDE, así que la mayor parte del código funciona tal cual; lo que cambia son los números de pin, el nivel de voltaje y algunas librerías. La tabla lista lo que debes revisar al pasar un código de Arduino Uno al ESP32:

TemaArduino UnoESP32Qué hacer
Nombres de pinesD2–D13, A0–A5Números GPIOCambia las constantes por números GPIO; cuidado con 6–11 y 34–39
Voltaje de trabajo5 V3,3 VPon un divisor de voltaje en los sensores con salida de 5 V (ECHO del HC-SR04)
analogRead10 bits, 0–102312 bits, 0–4095Recalcula umbrales y rangos de map() para un rango cuatro veces mayor
Librería de servoServo.hESP32Servo.hCambia la librería e indica en attach el rango del pulso
Velocidad serieNormalmente 9600Normalmente 115200Iguala Serial.begin y el monitor serie
Memoria2 KB de RAMUnos 320 KB de RAMLos arrays grandes y los String dejan de ser un problema
C++ (Arduino IDE)
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h>             // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26;            // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27;            // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18;           // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2;              // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16  Serial.begin(115200);             // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.setPeriodHertz(50);      // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21  lidServo.attach(SERVO_PIN, 500, 2400);  // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22  lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26  long distance = readDistanceCm();
27  Serial.print("Mesafe / Distance: ");
28  Serial.println(distance);
29
30  if (distance > 0 && distance < OPEN_DISTANCE) {
31    openCount++;
32    digitalWrite(LED_PIN, HIGH);
33    lidServo.write(OPEN_ANGLE);
34    delay(3000);
35    lidServo.write(CLOSED_ANGLE);
36    digitalWrite(LED_PIN, LOW);
37    Serial.print("Acilma sayisi / Times opened: ");
38    Serial.println(openCount);
39  }
40  delay(100);
41}
42
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50  return duration / 58;
51}

Como ves, loop() y la función readDistanceCm() pasaron sin cambiar ni una letra; todo lo que cambió está arriba del archivo y dentro de setup(). Eso es señal de un código bien escrito: los detalles del hardware se juntan arriba y la lógica de abajo queda limpia. Como el pin ECHO del HC-SR04 entrega 5 V, debe llegar al ESP32 a través de un divisor de voltaje de 1 kΩ y 2 kΩ; el servo, por su parte, se alimenta de los 5 V del pin VIN, no de 3,3 V. Comparamos las demás diferencias entre placas en la guía Arduino o ESP32.

La misma lógica en la Raspberry Pi Pico: MicroPython

Cuando programas la Pico con MicroPython, el código se ve distinto, pero la lógica es la misma. Se escribe import en lugar de #include y la sangría reemplaza a las llaves. No existen las palabras setup() ni loop(): las líneas de arriba del archivo se ejecutan una vez (el equivalente de setup) y el bloque while True: se repite para siempre (el equivalente de loop). Las funciones empiezan con def en vez de void o long. Pon este código junto al de Arduino de arriba y encontrarás el equivalente de cada línea:

MicroPython
1from machine import Pin, PWM, time_pulse_us   # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT)              # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN)               # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT)               # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50)                       # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20                   # cm
11
12
13def set_angle(angle):
14    pulse_us = 500 + angle * 2000 // 180            # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15    servo.duty_u16(pulse_us * 65535 // 20000)       # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19    TRIG.low()
20    time.sleep_us(2)
21    TRIG.high()                      # 10 µs tetik darbesi / 10 µs trigger pulse
22    time.sleep_us(10)
23    TRIG.low()
24    duration = time_pulse_us(ECHO, 1, 30000)        # zaman aşımında negatif / negative on timeout
25    if duration < 0:
26        return 0
27    return duration // 58
28
29
30set_angle(0)                         # setup() karşılığı / the setup() part
31open_count = 0
32
33while True:                          # loop() karşılığı / the loop() part
34    distance = read_distance_cm()
35    print("Mesafe / Distance:", distance)
36    if 0 < distance < OPEN_DISTANCE:
37        open_count += 1
38        LED.on()
39        set_angle(90)
40        time.sleep(3)
41        set_angle(0)
42        LED.off()
43        print("Acilma sayisi / Times opened:", open_count)
44    time.sleep_ms(100)

Como aquí Python no tiene librería Servo, la función set_angle() convierte ella misma el ángulo en duración de pulso: el servo se posiciona según un pulso de 0,5 a 2,5 ms que llega cada 20 ms. La forma 0 < distance < OPEN_DISTANCE es la versión corta, en Python, de la condición de C++ distance > 0 && distance < OPEN_DISTANCE. Si recién empiezas con MicroPython, la guía de fundamentos de MicroPython explica las reglas de sangría, variables y funciones.

Practicar con "Entender el código" en BlueGrays

En la app BlueGrays, la pantalla de código de cada proyecto tiene además la pestaña "Entender el código". La sección "¿Qué hace este código?" resume primero en pocas frases el trabajo del programa. "Paso a paso" divide después el código en partes pequeñas y explica debajo de cada una para qué sirven esas líneas y qué pasa si las cambias. "Si te atascas" reúne los problemas más comunes como síntoma y solución, y "Pruébalo tú" te propone una pequeña tarea con pista y solución, por ejemplo cambiar el umbral de una lámpara nocturna para que el LED se encienda antes. Ahí puedes aplicar el método de cinco pasos de esta guía: lee el resumen, relaciona cada parte con tu circuito y al final resuelve la tarea modificando el código tú mismo.

Ejercicios para aprender a leer código

  • Predice y comprueba: antes de cambiar una constante, escribe qué va a pasar; luego sube el código y compara con tu predicción.
  • Comenta una línea: pon // delante de una línea y vuelve a subir el código; lo que deje de funcionar te muestra para qué servía.
  • Cuéntalo con tus palabras: traduce cada línea de loop() a una frase en español; una línea que no puedes traducir es una línea que todavía no entiendes.
  • Dibuja un diagrama de flujo: representa setup, loop, los if y las llamadas a funciones con cajas y flechas; ayuda mucho en códigos que usan una máquina de estados.
  • Equivócate a propósito: borra un punto y coma y lee el mensaje del compilador; la guía de errores de compilación en Arduino explica los mensajes más comunes.

Errores comunes al leer código

ErrorPor qué es un problemaLo correcto
Pensar que el código es una lista que corre una sola vezloop() se repite sin fin y las variables cambian entre vueltasSigue loop() durante varias vueltas con valores distintos
Confundir = con ==if (x = 5) siempre es verdaderoPara comparar usa siempre ==
Pasar por alto la división entera5 / 2 da 2; se pierden los decimalesSi necesitas decimales, escribe 5.0 / 2 o usa float
Olvidar que delay() lo detiene todoMientras espera no se leen botones ni sensoresPara varias tareas a la vez, controla el tiempo con millis()
Ignorar las diferencias de versión de una libreríaLa misma función puede llamarse distinto en una versión nuevaBusca en los comentarios con qué librería se escribió el código
Cambiar la constante de un pin y olvidar el cableEl código lee el pin correcto, pero el cable está en otro ladoActualiza tu tabla de conexiones después de cada cambio
Cuando un código te parezca difícil, reescríbelo primero en palabras simples: "Mide la distancia. Si es mayor que 0 y menor que 20, suma uno al contador, enciende el LED, abre la tapa, espera 3 segundos, cierra la tapa y apaga el LED. Espera 100 ms y vuelve a empezar." Eso se llama pseudocódigo y es la manera más rápida de captar lo que pensaba quien escribió el programa.

Leer código, igual que leer un diagrama electrónico, se vuelve más rápido con cada ejemplo que ves. Para empezar, abre en la app BlueGrays proyectos cortos como encender un LED, el semáforo, el LED con botón o la lámpara nocturna con LDR, y sigue la pestaña "Entender el código" línea por línea; cada proyecto viene con su diagrama, la explicación del código por partes y una pequeña tarea.

Preguntas frecuentes

¿En qué lenguaje se programa Arduino?

El código de Arduino se basa en C y C++. Arduino agrega funciones listas como pinMode o digitalWrite para facilitar el trabajo, pero las reglas de los if, los bucles for, las variables y las funciones son C++ puro. Por eso, saber un poco de C++ hace mucho más fácil leer códigos de Arduino.

¿Cuál es la diferencia entre setup y loop?

setup() se ejecuta una sola vez, cuando la placa se enciende o se reinicia, y sirve para preparar cosas como los pines y la comunicación serie. loop() se repite después sin parar mientras la placa tenga energía; ahí se hace el trabajo real, como leer sensores, tomar decisiones y mover motores.

¿Qué significa void en Arduino?

void indica que una función no devuelve ningún valor. void setup() y void loop() hacen cosas pero no entregan un resultado. Una función como long readDistanceCm(), en cambio, devuelve con return un valor del tipo escrito antes de su nombre.

¿Por qué mi código compila pero el circuito no funciona?

El compilador solo revisa la sintaxis; un número de pin equivocado, un módulo conectado al revés o un umbral mal elegido no producen errores de compilación. Compara las constantes de pines del código con tu circuito y observa los valores con Serial.println en el monitor serie; casi siempre el problema está en el cableado o en un umbral.

¿Puedo usar un código de Arduino en un ESP32?

Casi siempre sí, porque el ESP32 también se programa con el Arduino IDE y las funciones básicas son las mismas. Tendrás que cambiar los números de pin por números GPIO, bajar las señales de 5 V a 3,3 V y reemplazar algunas librerías, como Servo, por sus versiones para ESP32. Recuerda también que analogRead devuelve valores de 0 a 4095.

¿Dónde encuentro ejemplos de código de Arduino?

El menú Archivo > Ejemplos del Arduino IDE es un excelente punto de partida, junto con los ejemplos de cada librería que instales. Los proyectos de la app BlueGrays también traen su diagrama y el código explicado línea por línea. Venga de donde venga el código, leerlo una vez con el método de esta guía antes de subirlo te ayuda a detectar errores desde el principio.

Ver todos los proyectos
Parpadeo de LED
AR-1Principiante

Parpadeo de LED

El primer hola de la electrónica: encender y apagar un solo LED. El Arduino enciende y apaga el LED a intervalos cortos, así que la luz parpadea rápido.

4.6(200)
1246
Semáforo
AR-3Principiante

Semáforo

Una copia en miniatura del semáforo que ves cada día en la calle. El rojo se queda dos segundos, el amarillo brilla un instante, el verde se queda dos segundos y luego vuelve al rojo pasando otra vez…

4.8(137)
440
Encender un LED con pulsador (Push)
AR-9Principiante

Encender un LED con pulsador (Push)

Como un timbre: la luz se enciende mientras pulsas y se apaga cuando sueltas. El Arduino escucha el botón todo el rato; mientras está pulsado enciende el LED, y en cuanto levantas el dedo lo apaga.

4.8(114)
253
Luz nocturna con LDR
AR-12Principiante

Luz nocturna con LDR

Una pequeña lamparita que se enciende sola cuando oscurece y se apaga cuando llega la mañana.

4.7(105)
224
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
Sensor de aparcamiento con HC-SR04
AR-28Intermedio
Premium

Sensor de aparcamiento con HC-SR04

Una versión en miniatura del sensor de aparcamiento de los coches: cuanto más se acerca algo, más rápidos son los pitidos.

4.8(64)
86
Funcionamiento del servomotor con potenciómetro
AR-36Principiante
Premium

Funcionamiento del servomotor con potenciómetro

A medida que giras el mando del potenciómetro, el brazo del servomotor gira con él: un extremo del mando equivale a cero grados y el otro a media vuelta.

4.6(37)
53