¿Mi Arduino está quemado? Síntomas, diagnóstico y reparación

«¿Mi Arduino está quemado?» es una pregunta que casi todo aficionado a la electrónica se hace algún día: un cable toca donde no debe, se conecta un motor y la placa se queda muda de golpe. La buena noticia es que en la mayoría de los casos no se ha quemado la placa entera. Un Arduino Uno está formado por varias partes separadas: la conexión USB y su fusible, el regulador de tensión, el chip conversor USB-serie y el microcontrolador principal, el ATmega328P. Cuando falla una, las demás suelen sobrevivir, y con un buen diagnóstico salvar la placa a veces es cuestión de dos minutos.

En esta guía aprenderás a interpretar bien los síntomas y a aislar la placa paso a paso hasta encontrar la parte averiada. Seguiremos un orden: alimentación por Vin, comprobación del polyfuse y del regulador con el multímetro, localizar un chip caliente, probar el chip USB con un test de bucle (loopback) y dos programas de Arduino que comprueban los pines uno a uno. Después grabaremos de nuevo un bootloader dañado con un segundo Arduino, cambiaremos el ATmega328P si hace falta y resumiremos las reglas para no volver a quemar una placa. La parte de software de los errores de carga la tratamos aparte en Arduino no carga el código.

¿Arduino quemado? Primeros síntomas y qué significan

Antes de empezar el diagnóstico, escucha lo que te dice la placa. El LED verde ON indica si hay tensión en la línea de 5 V, el LED L (D13) si el microcontrolador y el bootloader funcionan, y los LED TX/RX si el chip USB-serie está pasando datos. La tabla resume los síntomas más habituales y dónde mirar primero.

Paso 1: primera revisión con los ojos, la nariz y un cable

1. Revisa la placa con buena luz: buscas un chip oscurecido o abombado, un encapsulado agrietado, estaño derretido o una pista quemada. Fíjate sobre todo alrededor del regulador, el polyfuse y el chip USB.
2. Huele la placa. La electrónica quemada deja un olor fuerte y reconocible, normalmente más intenso cerca de la pieza averiada.
3. Mira la parte de abajo. Una mesa metálica, un trozo de cable o una espuma conductora pueden unir las soldaduras de la placa y provocar un cortocircuito.
4. Prueba otro cable USB y otro puerto USB. Algunos cables baratos solo llevan los hilos de alimentación y no transmiten datos; es la causa más común de una placa que parece muerta.
5. Anota si el ordenador hace el sonido de conexión USB al enchufar la placa y si se enciende el LED ON; los siguientes pasos dependen de estas dos observaciones.

El camino de la alimentación del Arduino Uno: ¿qué pieza alimenta qué?

La forma más rápida de encontrar una avería es conocer el camino que sigue la corriente en la placa. Los 5 V del USB pasan primero por un polyfuse de 500 mA (un fusible que se rearma solo) y luego por un pequeño MOSFET de canal P hasta llegar a la línea de 5 V. La tensión del conector de alimentación pasa primero por un diodo que protege contra la polaridad inversa, llega a la línea VIN y el regulador NCP1117 la baja a 5 V. Cuando VIN supera unos 6,6 V, un comparador apaga el MOSFET del lado USB, así que las dos fuentes nunca se pelean. Los 3,3 V se obtienen de la línea de 5 V con un pequeño regulador LP2985. El LED ON, el chip USB-serie (un ATmega16U2 en las placas originales, normalmente un CH340 en los clones) y el ATmega328P se alimentan de esa línea de 5 V.

Paso 2: si el LED ON no se enciende, prueba por USB y por Vin

Alimenta la placa una vez por USB y otra con un adaptador de 9 V en el conector (o con 7–12 V en el pin Vin), y mira el LED ON cada vez. Como lo único que comparten los dos caminos es la línea de 5 V, esta comparación sencilla acota mucho la avería. Si el polyfuse se ha disparado por sobrecorriente, deja la placa sin alimentación unos minutos para que se recupere sola; si el cortocircuito sigue, volverá a dispararse al enchufarla. Explicamos las opciones de pilas y adaptadores en alimentar Arduino con pilas.

Paso 3: comprobar cortocircuitos, polyfuse y regulador con el multímetro

1. Prueba de cortocircuito (placa sin alimentar): Pon el multímetro en resistencia o continuidad y toca con las puntas los pines 5V y GND. Es normal que la lectura empiece baja y suba al cargarse los condensadores; un pitido continuo o un valor que se queda por debajo de unos pocos ohmios indica cortocircuito.
2. Prueba del polyfuse (USB conectado): En tensión continua, pon la punta negra en GND y mide los dos extremos del polyfuse. Deberías ver unos 5 V en ambos; 5 V en uno y casi cero en el otro indica que el polyfuse está abierto.
3. Prueba del regulador (9 V en el conector): Deberías medir unos 8,3 V en la pata de entrada del NCP1117 (en el diodo caen 0,7 V) y 5,0 V en su salida.
4. Prueba de 3,3 V: Entre el pin 3V3 y GND deberías medir 3,2–3,4 V.
5. Haz las medidas en este orden; cada paso cambia el significado del siguiente. Explicamos las escalas del multímetro y cómo medir con seguridad en cómo usar un multímetro.

Paso 4: encontrar el chip que se calienta

Si hay un cortocircuito en la línea de 5 V, la pieza en corto se lleva casi toda la corriente y se calienta en pocos segundos. Conecta la placa al USB, espera 3–5 segundos, desenchúfala y toca un instante con la punta del dedo el ATmega328P, el chip USB y el regulador, uno tras otro. Si encuentras una pieza que quema al tacto, el cortocircuito está ahí. Si se calienta el ATmega328P, normalmente uno de sus pines ha recibido más de 5 V; si es el chip USB, el problema está en el lado USB; si es el regulador, o está averiado o una carga de la línea de 5 V pide demasiada corriente. Haz esta prueba sin dejar la placa alimentada mucho tiempo, o también se pueden dañar las piezas sanas.

Paso 5: probar el chip USB si no aparece el puerto

Si el LED ON se enciende pero el ordenador no ve la placa, descarta primero el software: instala el driver del chip CH340 en los clones y busca en Windows, dentro del Administrador de dispositivos, en «Puertos (COM y LPT)», o en macOS y Linux los dispositivos /dev/cu.* o /dev/ttyUSB*. Si el dispositivo no aparece o sale como desconocido, toca probar el propio chip USB-serie. El test de bucle (loopback) deja fuera al ATmega328P y hace que el chip USB reciba de vuelta los datos que envía; así distingues si el fallo está en el chip USB o en el microcontrolador.

1. Quita la alimentación de la placa y une el pin RESET con GND mediante un cable. Así el ATmega328P queda en reset y deja libres las líneas TX/RX.
2. Une los pines D0 (RX) y D1 (TX) con un segundo cable.
3. Conecta la placa al USB, elige el puerto en el Arduino IDE y abre el Monitor Serie (la velocidad da igual).
4. Escribe algo y pulsa Enviar. Si el texto vuelve tal cual y los LED TX/RX parpadean, el chip USB está bien; el problema está en el ATmega328P o en el bootloader.
5. Si el texto no vuelve y el puerto tampoco aparece, el chip USB o el conector USB están dañados. En ese caso aún puedes cargar código con un conversor USB-TTL externo o un programador ISP.

Paso 6: comprobar si hay pines quemados

Si la placa carga el código pero tu proyecto hace cosas raras, puede que se haya quemado un solo pin. Conectar a un pin un motor, la bobina de un relé o un LED sin resistencia, cortocircuitar dos salidas entre sí o aplicar más de 5 V a un pin puede matar solo ese pin mientras el resto del ATmega328P sigue funcionando. El primer programa de abajo pone cada pin como entrada con pull-up interno: un pin sano debe leer HIGH cuando está libre. Después conectas un extremo de un cable a GND y tocas los pines con el otro, uno a uno; con cada toque deberías ver en el Monitor Serie que ese pin baja a LOW.

1// Arduino Uno giriş testi / input test (D0 ve D1 seri port için hariç / D0 and D1 skipped for serial)
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4bool lastState[COUNT];
5
6void printPin(byte p) {
7  if (p >= A0) {
8    Serial.print('A');
9    Serial.print(p - A0);
10  } else {
11    Serial.print('D');
12    Serial.print(p);
13  }
14}
15
16void setup() {
17  Serial.begin(9600);
18  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], INPUT_PULLUP);   // dahili pull-up açık / internal pull-up on
19  delay(10);
20  Serial.println(F("1) Bos pin testi / free pin test:"));
21  for (byte i = 0; i < COUNT; i++) {
22    lastState[i] = digitalRead(PINS[i]);
23    printPin(PINS[i]);
24    Serial.println(lastState[i] ? F("  HIGH  tamam / ok") : F("  LOW   SUPHELI / suspect"));
25  }
26  Serial.println(F("2) GND'ye bagli kabloyla pinlere sirayla dokun / touch each pin with a GND wire"));
27}
28
29void loop() {
30  for (byte i = 0; i < COUNT; i++) {
31    bool v = digitalRead(PINS[i]);
32    if (v != lastState[i]) {                 // durum değişti / state changed
33      lastState[i] = v;
34      printPin(PINS[i]);
35      Serial.println(v ? F("  birakildi / released") : F("  GND algilandi / GND detected"));
36    }
37  }
38  delay(20);
39}

Un pin que lee LOW estando libre o que no cambia nada al tocarlo con GND es sospechoso; su etapa de entrada está en corto o abierta por dentro. En algunas placas clónicas el LED L va conectado directamente al pin D13, así que D13 puede leer LOW estando libre; no es una avería. El segundo programa prueba la etapa de salida: todos los pines pasan a HIGH y LOW una vez por segundo. Si conectas el cátodo de un LED a GND y su ánodo a un extremo de una resistencia de 220 Ω, y tocas los pines con el otro extremo de la resistencia, el LED parpadeará en cada pin sano; el valor adecuado de la resistencia lo calculas con la calculadora de resistencia para LED. Con un multímetro deberías ver unos 5 V en estado HIGH; un pin que nunca enciende el LED, lo enciende débil o se queda muy por debajo de 4 V está dañado.

1// Arduino Uno çıkış testi / output test: bütün pinler 1 sn HIGH, 1 sn LOW / all pins 1 s HIGH, 1 s LOW
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4
5void setAll(bool level) {
6  for (byte i = 0; i < COUNT; i++) digitalWrite(PINS[i], level);
7}
8
9void setup() {
10  Serial.begin(9600);
11  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], OUTPUT);
12  Serial.println(F("LED + 220 ohm probuyla pinlere dokun / touch the pins with an LED + 220 ohm probe"));
13}
14
15void loop() {
16  setAll(HIGH);
17  Serial.println(F("HIGH (~5 V)"));
18  delay(1000);
19  setAll(LOW);
20  Serial.println(F("LOW (0 V)"));
21  delay(1000);
22}

Mientras se ejecuta este programa no debe haber nada más conectado a los pines, porque todos se manejan como salidas. Si además quieres probar las entradas analógicas, conecta A0 a GND, a 3V3 y a 5V por turnos y léelo con analogRead(): deberías ver unos 0, 675 y 1023. La lista completa de pines y qué función tiene cada uno está en pines del Arduino Uno, y los esquemas de la placa en la herramienta de pinout.

Grabar de nuevo el bootloader: Arduino as ISP

Si la alimentación está bien y el test de bucle funciona, pero el LED L no parpadea al reiniciar y cada carga termina con el error «avrdude: stk500_getsync(): not in sync», puede que el bootloader se haya borrado o dañado. El bootloader es el pequeño programa que permite cargar código por USB y se puede volver a grabar mediante ISP (programación en el circuito). No hace falta comprar un programador aparte: un segundo Arduino Uno sano se convierte en programador con el ejemplo ArduinoISP. La conexión ISP usa los pines SPI; también puedes usar el conector ICSP de 6 pines de la placa de destino.

1. Conecta el Uno sano al ordenador, abre Archivo > Ejemplos > 11.ArduinoISP > ArduinoISP y cárgalo en esta placa.
2. Desconéctalo del ordenador, une las dos placas según la tabla de arriba y pon el condensador de 10 µF entre los pines RESET y GND del Uno programador.
3. Vuelve a conectar el programador al USB. En el menú Herramientas elige Arduino Uno como placa y el puerto del programador.
4. En Herramientas > Programador elige Arduino as ISP. La opción de nombre parecido «ArduinoISP» es para un programador USB independiente; no la elijas.
5. Ejecuta Herramientas > Quemar bootloader. Tarda unos segundos y termina con el mensaje «Done burning bootloader».
6. Quita los cables, conecta la placa de destino por su propio USB y carga el ejemplo Blink. Si el LED L vuelve a parpadear rápido al reiniciar, la placa está salvada.

Si el proceso falla, el mensaje de firma (signature) de avrdude dice mucho. «Device signature = 0x000000» o «0xffffff» significa que el programador no puede hablar con el chip de destino: revisa el cableado, el condensador de 10 µF y que el destino reciba 5 V; si todo está bien, lo más probable es que el ATmega328P esté muerto. Una firma 1E 95 0F indica que el chip es un ATmega328P y que la conexión funciona. Si ves 1E 95 14, tu chip es un ATmega328 sin la «P» y necesitas la definición de placa adecuada para ese chip.

Cambiar el ATmega328P

En el Arduino Uno R3 original y en muchos clones, el ATmega328P viene en encapsulado DIP de 28 patas y montado en un zócalo, así que se puede cambiar sin soldar. Si el microcontrolador se calienta, no se puede leer su firma o la mayoría de sus pines están muertos, es la solución más económica. Si al quitar el chip también desaparece el cortocircuito (el LED ON vuelve a encenderse y la placa no se calienta), queda confirmado que la avería está en el chip. Al comprar uno nuevo, elegir un ATmega328P-PU con el bootloader del Uno ya grabado te facilita las cosas; si compraste un chip vacío, puedes grabar tú mismo el bootloader con el método Arduino as ISP de arriba. En placas como el Nano y el Uno SMD el chip va soldado; cambiarlo requiere una estación de aire caliente y experiencia.

1. Quita la alimentación de la placa y haz una foto de hacia dónde mira la muesca del chip (el lado de la pata 1).
2. Mete un destornillador plano pequeño entre el chip y el zócalo y levanta el chip poco a poco, alternando entre los dos extremos; si haces palanca solo por un lado, se doblan las patas.
3. Las patas de un chip nuevo suelen estar algo abiertas hacia fuera. Apoya el chip de lado sobre una mesa plana y presiona para doblar un poco hacia dentro las dos filas a la vez.
4. Alinea el chip con el zócalo con la muesca hacia el mismo lado que el antiguo, comprueba que todas las patas entran en sus agujeros y presiona de forma uniforme.
5. Conecta la placa al USB, comprueba que el LED L parpadea al reiniciar y termina la prueba cargando el ejemplo Blink.

Notas rápidas para el ESP32 y la Raspberry Pi Pico

La misma lógica sirve para otras placas; solo cambian las piezas. Las placas de desarrollo ESP32 llevan un regulador tipo AMS1117 que baja 5 V a 3,3 V y un chip USB CP2102 o CH340; si el regulador se calienta, busca un cortocircuito en la línea de 3,3 V. Los pines del ESP32 no toleran 5 V, así que la avería más común es meter 5 V en un pin. El error «Failed to connect» al cargar muchas veces no es una avería, sino que hay que mantener pulsado el botón BOOT; los detalles están en Arduino no carga el código. En la Raspberry Pi Pico, la prueba más rápida es conectarla al USB con el botón BOOTSEL pulsado: si aparece en el ordenador una unidad llamada RPI-RP2, el RP2040 y la conexión USB están bien. Los pines de la Pico tampoco toleran 5 V, y en el pin 3V3(OUT) deberías medir unos 3,3 V.

10 reglas para no quemar tu Arduino

• 20 mA por pin: No pidas más de 20 mA a un pin; el límite absoluto es 40 mA y la suma de todos los pines no debe pasar de 200 mA.
• Siempre una resistencia con el LED: Conectar un LED sin resistencia fuerza el pin y el LED; a 5 V bastan 220–330 Ω.
• Nunca más de 5 V en un pin: La tensión de una entrada no debe superar en más de 0,5 V la alimentación; una señal de 12 V mata el pin al instante.
• Motores, relés y bombas nunca directos a un pin: Usa un transistor o un MOSFET y un diodo flyback; tienes un circuito de ejemplo en la guía de la mini bomba de agua.
• 7–12 V en Vin: Es el rango recomendado; por encima de 12 V el regulador se calienta y por encima de 20 V se supera el límite.
• No inviertas la polaridad en el pin Vin: El diodo de protección del conector no protege lo que entra por el pin Vin; confundir positivo y negativo quema la placa.
• No pidas más de 50 mA al pin 3V3: Para cargas como un módulo Wi-Fi o una pantalla grande usa un regulador de 3,3 V aparte.
• Desconecta la alimentación al recablear: Poner y quitar cables con el circuito encendido es la causa más común de cortocircuitos breves.
• No apoyes la placa sobre metal: Las soldaduras de abajo hacen cortocircuito si tocan una mesa metálica, una herramienta o un trozo de cable; usa patas de plástico o una caja.
• Masa común y alimentación aparte: Une las masas de las cargas alimentadas desde fuera, pero no hagas pasar corrientes grandes por la placa.

Antes de dar tu Arduino por muerto, encontrar qué parte se ha quedado muda suele salvar la placa: el LED ON comprueba el camino de la alimentación, el test de bucle el chip USB, el LED L al reiniciar el bootloader y los programas de prueba cada pata del ATmega328P por separado. El bootloader se puede volver a grabar, un chip en zócalo se cambia en pocos minutos y, con las reglas de arriba, tu próxima placa vivirá mucho tiempo. Para ver que tu placa vuelve a funcionar bien, prueba en la app BlueGrays los proyectos Encender un LED, Semáforo, LED con botón y Voltímetro digital con LCD, con esquemas y código paso a paso.