Código Arduino con inteligencia artificial: prompts y errores

Generar código Arduino con inteligencia artificial consiste en describirle tu proyecto a un asistente de chat como ChatGPT, Gemini, Claude o Copilot y pedirle código que funcione en un Arduino, un ESP32 o una Raspberry Pi Pico. Bien usada, la IA convierte horas de trabajo en minutos: en lugar de una página en blanco tienes un borrador listo para compilar. Pero la IA no ve tu circuito, no sabe qué placa tienes en la mesa y puede afirmar algo falso con total seguridad. Puede inventarse una función de biblioteca que no existe, elegir el pin equivocado o escribir bucles con delay() que lo bloquean todo. Por eso la verdadera habilidad no es pedir código, sino pedirlo bien y verificar lo que recibes.

En esta guía verás cómo genera código Arduino un asistente de IA y por qué se equivoca, cómo escribir un buen prompt que incluya la placa, los pines, las bibliotecas y el comportamiento esperado, y qué pasos seguir para verificar el código antes de subirlo. Repasaremos los tres errores más frecuentes con mensajes reales del compilador y código corregido. Después veremos la forma correcta de pegar un error de compilación para que te lo corrija, por qué no debes fiarte de la IA cuando trabajas con la tensión de red de 220-230 V y cómo usar estas herramientas sin dejar de aprender.

¿Cómo escribe la IA código Arduino y por qué se equivoca?

Los grandes modelos de lenguaje (LLM) como ChatGPT no escriben código ejecutándolo como un compilador, sino prediciendo la continuación más probable a partir de los millones de ejemplos que vieron durante el entrenamiento. En temas con muchos ejemplos en internet (hacer parpadear un LED, leer un DHT11, mover un servo) esto funciona muy bien. Pero el conocimiento del modelo está congelado en una fecha concreta, así que puede no conocer funciones que cambiaron en versiones nuevas de una biblioteca. Puede confundir las funciones de dos bibliotecas distintas con el mismo nombre. Y, sobre todo, en lugar de decir «no lo sé» puede inventarse una respuesta que suena razonable; a esto se le llama alucinación. Como el modelo no ve tu circuito, deduce los números de pin, los niveles de tensión y la versión del módulo a partir de lo que escribiste o de sus propias suposiciones.

¿Cómo se escribe un buen prompt?

El código que te da la IA no puede ser mejor que la información que tú le das. Con una petición de una línea como «escribe código Arduino para medir la temperatura», el modelo elige por su cuenta la placa, el sensor, el pin y la biblioteca. Si lo que elige no coincide con lo que tienes, el código no compila, o compila y no funciona. Escribe un buen prompt como si le explicaras el proyecto por teléfono a un amigo que lo oye por primera vez: di uno por uno la placa, los componentes, las conexiones, las bibliotecas, el comportamiento esperado y las restricciones. La tabla resume lo que debe llevar un prompt para Arduino:

Por ejemplo, este prompt da resultados mucho mejores que una petición de una línea: «Uso un Arduino Uno R3 y Arduino IDE 2.3. El pin DATA del DHT22 está en D2, un zumbador activo en D8 y una LCD 16x2 I2C (PCF8574, dirección 0x27) tiene SDA en A4 y SCL en A5. Tengo instaladas la Adafruit DHT sensor library y la biblioteca LiquidCrystal I2C de Frank de Brabander. Cada 2 segundos muestra la temperatura y la humedad en la LCD y, si la temperatura pasa de 30 °C, haz que el zumbador pite a ráfagas cortas. Usa millis() en lugar de delay() y comenta las líneas en español. Al principio enumera las bibliotecas que debo instalar y, al final, las suposiciones que hayas hecho.» Con este prompt al modelo no le queda casi nada que adivinar.

Pasos para verificar el código generado por IA

Por muy limpio que parezca el código, pásalo por una lista de comprobación antes de subirlo a la placa. La mayoría de estos pasos llevan unos minutos y salen mucho más baratos que un módulo quemado por un pin mal conectado:

1. Primero, solo compila: Pulsa Verificar (el botón con la marca de visto) sin conectar la placa. Si aparece un error, haz que te lo corrija con el método de más abajo; para entender los mensajes, consulta errores de compilación de Arduino.
2. Comprueba las bibliotecas una a una: Busca cada línea #include en el Gestor de bibliotecas e instala la biblioteca cuyo nombre, autor y ejemplos coincidan con el código. Si no sabes cómo, la guía cómo instalar una biblioteca en Arduino te lo explica paso a paso.
3. Compara los pines: Compara cada número de pin del código con tu cableado y con el mapa de pines de la placa. Para los pines PWM y los que conviene evitar, usa la herramienta Pinout.
4. Calcula los valores eléctricos: Revisa el valor de resistencia propuesto con la calculadora de resistencia para LED. Si un sensor con salida de 5 V va a un ESP32 o una Pico de 3,3 V, pon un divisor de tensión en medio.
5. Pruébalo en un simulador: Ejecuta el código en Wokwi o Tinkercad antes de conectar el hardware real; así detectas errores de lógica sin arriesgar ninguna pieza.
6. Prueba por partes: No subas todo el proyecto de golpe. Prueba primero un sketch pequeño que solo lea el sensor y lo muestre en el monitor serie, luego añade la pantalla y, al final, el zumbador o el relé.
7. Vigila el monitor serie: Añade Serial.println() en puntos clave para ver si las variables toman los valores que esperas, y comprueba que la velocidad en baudios coincide con Serial.begin() en el código. Más detalles en monitor serie de Arduino.
8. Pide que te expliquen el código: Por cada línea que no entiendas, pregunta «¿qué hace esta línea y qué pasa si la borro?». No subas código que no sepas explicar.

Error frecuente 1: funciones de biblioteca que no existen

El error más traicionero de la IA es escribir funciones que en realidad no existen pero tienen nombres muy creíbles. Por ejemplo, la biblioteca Servo estándar tiene attach(), write(), writeMicroseconds(), read() y detach(), pero ninguna función setSpeed() para la velocidad; el modelo puede inventársela si le pides un servo que gire despacio. A veces la función existe de verdad, pero en otra placa: Serial.printf() funciona en el ESP32, pero en un Arduino Uno no compila. Y a veces la función pertenece a una versión antigua: en la versión 3.x del núcleo Arduino para ESP32, publicada en 2024, se eliminaron ledcSetup() y ledcAttachPin(), pero la mayoría de los modelos siguen escribiendo código con ellas. Además hay bibliotecas distintas que usan el mismo archivo de cabecera: en una llamada LiquidCrystal_I2C.h la pantalla se inicia con lcd.init() y en otra con el mismo nombre, con lcd.begin(). Si ves el aviso «Multiple libraries were found» en la salida del compilador, sospecha de esta confusión.

La trampa de las funciones antiguas en el ESP32: ledcAttach en vez de ledcSetup

Cuando pides código ESP32 para regular el brillo de un LED o la velocidad de un motor, lo más probable es que la IA escriba el trío ledcSetup(canal, frecuencia, resolución), ledcAttachPin(pin, canal) y ledcWrite(canal, valor). Ese código funciona con la versión 2.x del núcleo. En la versión 3.x, en cambio, los canales se asignan solos: ledcAttach(pin, frecuencia, resolución) prepara el pin de una vez y ledcWrite(pin, valor) recibe ahora un número de pin en lugar de un canal. Puedes ver qué versión tienes junto al paquete esp32 en el Gestor de placas. El siguiente código comprueba la versión al compilar, así que funciona con los dos núcleos:

1// ESP32 PWM: çekirdek 2.x ve 3.x ile uyumlu LED soldurma / LED fade for both core 2.x and 3.x
2#include <esp_arduino_version.h>   // ESP_ARDUINO_VERSION_MAJOR için / for ESP_ARDUINO_VERSION_MAJOR
3
4const int LED_PIN = 2;             // çoğu DevKit'te dahili LED / onboard LED on most DevKits
5const uint32_t FREKANS = 5000;     // PWM frekansı, Hz / PWM frequency, Hz
6const uint8_t COZUNURLUK = 8;      // 8 bit: 0-255 / 8-bit: 0-255
7
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9// Çekirdek 3.x: kanal otomatik seçilir, fonksiyonlar pin alır / Core 3.x: channel is automatic, functions take the pin
10void pwmBaslat() { ledcAttach(LED_PIN, FREKANS, COZUNURLUK); }
11void pwmYaz(uint32_t deger) { ledcWrite(LED_PIN, deger); }
12#else
13// Çekirdek 2.x: önce kanal kurulur, sonra pine bağlanır / Core 2.x: set up a channel, then attach the pin
14const uint8_t KANAL = 0;
15void pwmBaslat() { ledcSetup(KANAL, FREKANS, COZUNURLUK); ledcAttachPin(LED_PIN, KANAL); }
16void pwmYaz(uint32_t deger) { ledcWrite(KANAL, deger); }
17#endif
18
19void setup() {
20  Serial.begin(115200);
21  Serial.print("ESP32 Arduino cekirdegi / core: ");
22  Serial.println(ESP_ARDUINO_VERSION_MAJOR);
23  pwmBaslat();
24}
25
26void loop() {
27  // Tek iş yaptığı için burada delay() sorun değil / delay() is fine here: only one task
28  for (int d = 0; d <= 255; d++) { pwmYaz(d); delay(4); }   // yavaşça yan / fade in
29  for (int d = 255; d >= 0; d--) { pwmYaz(d); delay(4); }   // yavaşça sön / fade out
30}

La lección no es solo para el ESP32: si pones en el prompt la versión del núcleo y de las bibliotecas, el modelo tiene la oportunidad de elegir las funciones correctas. Si aun así usa funciones antiguas, abre uno de los ejemplos oficiales de la biblioteca desde Archivo > Ejemplos y pégalo en el prompt con «reescríbelo con las funciones de este ejemplo». Los ejemplos oficiales siempre coinciden con la versión instalada. Si quieres saber cómo funciona el PWM, echa un vistazo a ¿Qué es el PWM?

Error frecuente 2: elegir el pin equivocado

Aunque el código compile y se suba, un pin equivocado significa un circuito que no hace nada sin avisar o un módulo quemado. El compilador no puede detectarlo, porque para él un número de pin es solo un número. Estos son los errores de pines que más comete la IA, placa por placa:

Error frecuente 3: el bloqueo de delay()

Como la mayoría de los ejemplos de Arduino en internet están escritos con delay(), la IA también usa delay() por defecto. Mientras se ejecuta delay(1000), el procesador no hace nada más durante un segundo entero: no lee botones, no mira sensores y no actualiza la pantalla. En un código que hace una sola cosa no pasa nada. Pero si pides dos cosas a la vez, como «que parpadee un LED y que suene el zumbador al pulsar el botón», a menudo sale un código como este:

1// Yapay zekanın sık ürettiği, kilitlenen kod / Blocking code that AI often produces
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6void setup() {
7  pinMode(BUTON_PIN, INPUT_PULLUP);
8  pinMode(LED_PIN, OUTPUT);
9  pinMode(BUZZER_PIN, OUTPUT);
10}
11
12void loop() {
13  digitalWrite(LED_PIN, HIGH);
14  delay(1000);                          // 1 sn boyunca buton okunmaz / button is not read for 1 s
15  digitalWrite(LED_PIN, LOW);
16  delay(1000);                          // 1 sn daha kör bekleme / another blind second
17
18  if (digitalRead(BUTON_PIN) == LOW) {  // yalnızca tam bu anda basılıysa / only if pressed right now
19    digitalWrite(BUZZER_PIN, HIGH);
20    delay(200);
21    digitalWrite(BUZZER_PIN, LOW);
22  }
23}

Este código compila sin errores, pero casi siempre que pulsas el botón no pasa nada. Unos 2 segundos de cada vuelta de loop() se van dentro de las dos llamadas a delay(), y el botón solo se lee durante unos pocos microsegundos entre ellas. Una pulsación corta casi siempre se pierde ese momento; para que el zumbador suene seguro, tienes que mantener el botón pulsado más de 2 segundos. La solución no es esperar, sino mirar el reloj: millis() devuelve los milisegundos transcurridos desde el arranque, cada tarea comprueba si le ha llegado su momento y loop() da miles de vueltas por segundo:

1// millis() ile kilitlenmeyen sürüm / Non-blocking version with millis()
2const int BUTON_PIN = 2;    // buton: D2 ile GND arası / button between D2 and GND
3const int LED_PIN = 13;     // dahili LED / onboard LED
4const int BUZZER_PIN = 8;   // aktif buzzer / active buzzer
5
6const unsigned long LED_ARALIK = 1000;  // LED değişim aralığı, ms / LED toggle interval, ms
7const unsigned long BIP_SURE = 200;     // bip süresi, ms / beep length, ms
8const unsigned long SICRAMA = 30;       // debounce süresi, ms / debounce time, ms
9
10unsigned long ledZaman = 0;     // LED'in son değiştiği an / last LED toggle
11unsigned long bipZaman = 0;     // bipin başladığı an / beep start
12unsigned long butonZaman = 0;   // butonun son değiştiği an / last button change
13bool ledDurum = false;
14bool bipCaliyor = false;
15int oncekiButon = HIGH;         // önceki buton seviyesi / previous button level
16
17void setup() {
18  pinMode(BUTON_PIN, INPUT_PULLUP);
19  pinMode(LED_PIN, OUTPUT);
20  pinMode(BUZZER_PIN, OUTPUT);
21}
22
23void loop() {
24  unsigned long simdi = millis();
25
26  // 1) LED: zamanı geldiyse durum değiştir / toggle the LED when its time has come
27  if (simdi - ledZaman >= LED_ARALIK) {
28    ledZaman = simdi;
29    ledDurum = !ledDurum;
30    digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
31  }
32
33  // 2) Buton: yalnızca basıldığı anı yakala / catch only the moment of the press
34  int buton = digitalRead(BUTON_PIN);
35  if (buton != oncekiButon && simdi - butonZaman >= SICRAMA) {
36    butonZaman = simdi;
37    oncekiButon = buton;
38    if (buton == LOW && !bipCaliyor) {  // HIGH -> LOW: yeni basış / new press
39      bipCaliyor = true;
40      bipZaman = simdi;
41      digitalWrite(BUZZER_PIN, HIGH);
42    }
43  }
44
45  // 3) Buzzer: süre dolunca sustur / silence it when the time is up
46  if (bipCaliyor && simdi - bipZaman >= BIP_SURE) {
47    bipCaliyor = false;
48    digitalWrite(BUZZER_PIN, LOW);
49  }
50}

En esta versión el LED, el botón y el zumbador funcionan sin esperarse unos a otros. Una resta del tipo simdi - ledZaman >= LED_ARALIK da el resultado correcto incluso cuando millis() se desborda y vuelve a cero, más o menos cada 49,7 días, mientras que la comparación millis() > tiempoObjetivo que a veces escribe la IA falla en ese desbordamiento. Detectar el momento en que el botón pasa de HIGH a LOW evita que el zumbador pite una y otra vez mientras mantienes pulsado, y la espera de 30 ms filtra los rebotes del contacto (debounce). Tienes el tema completo en la guía millis() en lugar de delay() en Arduino y la conexión del botón en cómo conectar un botón a Arduino.

Pegar un error de compilación para que te lo corrija

La IA es realmente buena explicando errores de compilación, siempre que le des el error completo y el contexto. Escribir solo «el código no funciona» obliga al modelo a adivinar. Sigue este orden:

1. Cuando aparezca un error de compilación en Arduino IDE 2, pulsa Copiar mensajes de error en la notificación de abajo a la derecha, o selecciona y copia todo el texto del panel de salida. El exit status 1 de la última línea no sirve por sí solo; la causa real está más arriba, en la línea con error:.
2. Tu prompt debe incluir, en este orden: la placa y la versión del núcleo, el código completo, el mensaje de error completo y el nombre y la versión de las bibliotecas instaladas.
3. Antes de pedir la corrección, escribe «Primero explica la causa del error y luego muestra solo las líneas que hay que cambiar». Así el modelo no reescribe todo el sketch añadiendo errores nuevos, y tú aprendes qué cambia y por qué.
4. Aplica el cambio propuesto y vuelve a compilar. Si aparece un error nuevo, pega otra vez la primera línea con error:; corrige un solo error cada vez.
5. Si el mismo error sigue ahí después de dos o tres rondas, rompe el bucle y compila el ejemplo oficial de la biblioteca. Si el ejemplo tampoco compila, el problema no está en el código sino en la instalación: placa equivocada, biblioteca que falta o dos bibliotecas con el mismo nombre en conflicto.

Si el error aparece al subir y no al compilar (por ejemplo, «avrdude: stk500_recv(): programmer is not responding» o, en el ESP32, «Failed to connect to ESP32»), cambiar el código no sirve de nada; tienes que revisar el puerto, el cable, el driver y la placa seleccionada. La guía Arduino no sube el código te lleva paso a paso por esos casos. Cuando le preguntes a la IA por un error de subida, incluye también el mensaje completo y tu sistema operativo.

Código para Raspberry Pi Pico y MicroPython con IA

Las mismas reglas valen para el código MicroPython, pero aquí la IA también puede mezclar plataformas. El código escrito para los ordenadores Raspberry Pi con RPi.GPIO o gpiozero no funciona en la Pico; en la Pico se usa el módulo machine de MicroPython. Los módulos board y digitalio de CircuitPython tampoco existen en MicroPython. Por eso pon en el prompt información clara como «Raspberry Pi Pico W, MicroPython, Thonny». El siguiente código funciona tanto en la Pico como en la Pico W y temporiza con ticks_ms() en lugar de esperar:

1# Pico ve Pico W: bekletmeden LED + buton / Pico and Pico W: LED + button without blocking
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)             # Pico W'da Pin(25) çalışmaz / Pin(25) does not work on Pico W
6buton = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arası / button between GP14 and GND
7
8ARALIK = 500                          # LED değişim aralığı, ms / LED toggle interval, ms
9SICRAMA = 30                          # debounce süresi, ms / debounce time, ms
10son = time.ticks_ms()                 # LED'in son değiştiği an / last LED toggle
11degisim = time.ticks_ms()             # butonun son değiştiği an / last button change
12onceki = 1                            # önceki buton seviyesi / previous button level
13sayac = 0
14
15while True:
16    simdi = time.ticks_ms()
17    if time.ticks_diff(simdi, son) >= ARALIK:      # taşmada da doğru / correct even on overflow
18        son = simdi
19        led.toggle()
20    deger = buton.value()
21    if deger != onceki and time.ticks_diff(simdi, degisim) >= SICRAMA:
22        degisim = simdi
23        onceki = deger
24        if deger == 0:                # basıldığı an / moment of the press
25            sayac += 1
26            print("Basma / press:", sayac)

Al ejecutar el código en Thonny, el LED integrado parpadea cada medio segundo y cada pulsación del botón escribe un número creciente en la ventana Shell. time.ticks_diff() da la diferencia correcta incluso cuando el contador de tiempo se desborda, mientras que la simple resta time.ticks_ms() - son que suele escribir la IA puede dar un resultado erróneo en un código que funciona durante mucho tiempo. Si eres nuevo con la Pico, empieza por ¿Qué es la Raspberry Pi Pico?

Con 220-230 V, no te fíes de la IA

Si tu proyecto va a funcionar con la red eléctrica, pruébalo primero a baja tensión: un LED en lugar de la lámpara y una tira de LED de 12 V en lugar del enchufe. Si el sistema tiene que conmutar de verdad la tensión de red, hay reglas que no se negocian. Desenchufa el circuito antes de trabajar en él. El relé debe cortar la fase (L), no el neutro. No superes la corriente y la tensión impresas en el módulo de relé (10 A 250 VAC en la mayoría) y mete la parte de alta tensión en una caja cerrada y aislante. Los módulos de relé baratos a menudo dejan poca distancia entre la parte de baja y la de alta tensión; si puedes, elige un enchufe inteligente o una caja de relé ya fabricados y certificados. Tienes la conexión del módulo de relé en detalle en ¿Qué es un módulo de relé?

Usar la IA sin dejar de aprender

Si la IA te escribe todos los sketches, el primer día que el código no funcione no sabrás qué hacer. Si tu objetivo es aprender electrónica y programación, úsala no como una máquina de código sino como un profesor paciente:

• Escríbelo tú primero: Prueba el código por tu cuenta y luego pide a la IA que lo revise con «muéstrame los errores pero no me des el código corregido».
• Pide pistas, no respuestas: Cuando te atasques, di «dame solo una pista para el siguiente paso».
• Que te lo explique línea a línea: Después de la explicación, intenta contar la misma lógica con tus palabras; lo que no sepas explicar es lo que aún no has aprendido.
• Escribe en lugar de copiar: Teclear el código a mano en vez de pegarlo te enseña la sintaxis y los nombres de las funciones mucho más rápido.
• Predice y luego prueba: Antes de cambiar un valor, piensa qué va a pasar (por ejemplo, si LED_ARALIK pasa a 200) y luego súbelo y compruébalo.
• Ponte a prueba: Pide a la IA que te haga cinco preguntas sobre lo que acabas de aprender; para repasar lo básico, usa fundamentos de programación de Arduino.
• Respeta las normas: En los trabajos de clase y las ferias de ciencias, sigue las normas sobre el uso de IA y di claramente si la has usado.

Primeros proyectos para probar con IA

• Termómetro con pantalla: Muestra los valores de un DHT11 en una LCD I2C; indica en el prompt la dirección de la LCD y el autor de la biblioteca.
• Sensor de aparcamiento: Mide la distancia con un HC-SR04 y haz que el zumbador pite más rápido cuanto más cerca esté el obstáculo; pide que la temporización sea con millis().
• Luz nocturna: Enciende un LED cuando oscurezca con una LDR; lee antes el umbral en el monitor serie y dáselo como número en el prompt.
• LED por Wi-Fi: Enciende y apaga un LED desde una página abierta en el móvil con un ESP32; indica la versión del núcleo en el prompt.
• Tu propia idea: Elige un proyecto de la lista de ideas de proyectos con Arduino y descríbeselo a la IA con la plantilla de prompt de esta guía.

La IA puede ser el ayudante más rápido que tengas mientras aprendes Arduino, siempre que le des la información correcta, compiles lo que te devuelve, revises los pines, pruebes por partes y no subas ninguna línea que no entiendas. Si buscas ejemplos fiables con los que comparar el código de la IA, en la app BlueGrays encontrarás proyectos con LED, botón, DHT11, PWM en ESP32 y Pico, con esquemas de circuito paso a paso y código probado.