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.

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ódigo | Qué hace | Línea típica | Cómo reconocerla |
|---|---|---|---|
| Comentarios | Explican el código; el compilador los ignora | // nota o /* ... */ | Empiezan con //, en gris en el IDE |
| Librerías | Agregan código listo (servo, pantalla, sensor) | #include <Servo.h> | Empiezan con #, hasta arriba |
| Definiciones de pines y constantes | Ponen nombre a los números de pin y a los umbrales | const int LED_PIN = 13; | Suelen ser nombres en MAYÚSCULAS |
| Variables globales y objetos | Datos accesibles desde cualquier parte del código | int count = 0; Servo lidServo; | Fuera de cualquier función |
| setup() | Se ejecuta una vez al encender | pinMode(LED_PIN, OUTPUT); | void setup() { ... } |
| loop() | Se repite sin fin; aquí ocurre el trabajo real | if (distance < 20) { ... } | void loop() { ... } |
| Funciones propias | Agrupan una tarea que se repite | long readDistanceCm() { ... } | Bloques aparte, arriba o abajo de loop |
¿Por dónde empezar? Un método en cinco pasos
- 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.
- 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.
- 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.).
- 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.
- 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.
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ínea | Qué hace | ¿Qué pasa si la cambias? |
|---|---|---|
| #include <Servo.h> | Agrega la librería Servo al código | Si la borras, el compilador dice "'Servo' does not name a type" |
| const int TRIG_PIN = 9; | Le pone el nombre TRIG_PIN al pin 9 | Si mueves el cable, solo cambias este número |
| const int OPEN_DISTANCE = 20; | Distancia umbral para abrir la tapa | Con 30, la tapa se abre desde más lejos |
| Servo lidServo; | Crea un objeto servo llamado lidServo | Todas las líneas siguientes deben usar el mismo nombre |
| int openCount = 0; | Contador global, en cero al encender | Si lo pasas dentro de loop(), vuelve a cero en cada vuelta y siempre muestra 1 |
| lidServo.attach(SERVO_PIN); | Conecta el servo al pin 6 | Si la olvidas, el servo no se mueve nunca |
| long distance = readDistanceCm(); | Llama a la función y guarda el resultado | distance solo existe dentro de loop() |
| if (distance > 0 && distance < OPEN_DISTANCE) | Entra al bloque si las dos condiciones son verdaderas | distance > 0 descarta el 0 que llega cuando no vuelve el eco |
| delay(3000); | Hace esperar a la placa 3 segundos | Durante ese tiempo el Arduino no revisa nada más |
| return duration / 58; | Convierte el tiempo del eco en centímetros | El 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.
| Tipo | Rango (Arduino Uno) | Uso típico |
|---|---|---|
| int | de -32 768 a 32 767 | Números de pin, valores de analogRead, contadores |
| long | unos ±2100 millones | Duración de pulseIn, números grandes |
| unsigned long | de 0 a unos 4290 millones | Tiempos de millis() y micros() |
| float | Números con decimales, 6–7 cifras de precisión | Cálculos de temperatura, voltaje y distancia |
| bool | true o false | ¿Algo está encendido o apagado? |
| byte | de 0 a 255 | Valores PWM, números pequeños |
| char / String | Un carácter / texto | Comandos 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.
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ón | Qué hace | Ejemplo |
|---|---|---|
| pinMode(pin, modo) | Configura un pin como entrada o salida | pinMode(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 LOW | digitalRead(2) |
| analogRead(pin) | Convierte 0–5 V en un número de 0 a 1023 | analogRead(A0) |
| analogWrite(pin, 0–255) | Ajusta con PWM el brillo de un LED o la velocidad de un motor | analogWrite(9, 128); |
| delay(ms) | Detiene la placa durante el tiempo indicado | delay(1000); |
| millis() | Milisegundos desde que se encendió | if (millis() - last > 500) |
| Serial.begin / print / println | Envía texto al monitor serie | Serial.println(distance); |
| map(x, a, b, c, d) | Lleva un rango de valores a otro | map(value, 0, 1023, 0, 180) |
| pulseIn(pin, HIGH) | Mide la duración de un pulso en µs | pulseIn(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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
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:
| Tema | Arduino Uno | ESP32 | Qué hacer |
|---|---|---|---|
| Nombres de pines | D2–D13, A0–A5 | Números GPIO | Cambia las constantes por números GPIO; cuidado con 6–11 y 34–39 |
| Voltaje de trabajo | 5 V | 3,3 V | Pon un divisor de voltaje en los sensores con salida de 5 V (ECHO del HC-SR04) |
| analogRead | 10 bits, 0–1023 | 12 bits, 0–4095 | Recalcula umbrales y rangos de map() para un rango cuatro veces mayor |
| Librería de servo | Servo.h | ESP32Servo.h | Cambia la librería e indica en attach el rango del pulso |
| Velocidad serie | Normalmente 9600 | Normalmente 115200 | Iguala Serial.begin y el monitor serie |
| Memoria | 2 KB de RAM | Unos 320 KB de RAM | Los arrays grandes y los String dejan de ser un problema |
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:
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
| Error | Por qué es un problema | Lo correcto |
|---|---|---|
| Pensar que el código es una lista que corre una sola vez | loop() se repite sin fin y las variables cambian entre vueltas | Sigue loop() durante varias vueltas con valores distintos |
| Confundir = con == | if (x = 5) siempre es verdadero | Para comparar usa siempre == |
| Pasar por alto la división entera | 5 / 2 da 2; se pierden los decimales | Si necesitas decimales, escribe 5.0 / 2 o usa float |
| Olvidar que delay() lo detiene todo | Mientras espera no se leen botones ni sensores | Para varias tareas a la vez, controla el tiempo con millis() |
| Ignorar las diferencias de versión de una librería | La misma función puede llamarse distinto en una versión nueva | Busca en los comentarios con qué librería se escribió el código |
| Cambiar la constante de un pin y olvidar el cable | El código lee el pin correcto, pero el cable está en otro lado | Actualiza tu tabla de conexiones después de cada cambio |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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…

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.

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

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.

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…

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.

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

