Arduino se reinicia solo o se cuelga: causas y soluciones

Si tu Arduino se reinicia solo o se cuelga después de funcionar un rato, casi nunca es porque la placa esté averiada. En la mayoría de los casos la causa es la alimentación: cuando un servo empieza a moverse, un motor arranca o un relé se activa, la corriente repentina hunde la línea de 5 V durante un instante y la protección contra baja tensión del procesador (brown-out) reinicia la placa. En el resto de los casos los culpables son el ruido eléctrico de relés y motores, los cables largos, una RAM llena, un watchdog olvidado o un puerto USB del ordenador que no da suficiente corriente.

En esta guía primero aprenderás a distinguir si la placa realmente se reinicia o solo se cuelga. Después explicaremos cómo funciona cada causa con valores reales de corriente y tensión, y te mostraremos las soluciones con código: alimentación separada y GND común, condensadores de 100–470 µF, diodos de rueda libre, búferes fijos en lugar de String y el watchdog. También encontrarás un sketch de diagnóstico que mide la tensión de alimentación y la RAM libre del propio Arduino, una tabla paso a paso del síntoma a la solución y ejemplos que leen el motivo del reinicio en el ESP32 y en la Raspberry Pi Pico.

¿Reinicio o cuelgue? Identifica primero el síntoma

Un Arduino que se reinicia ejecuta el programa desde el principio, como si hubieras desconectado y vuelto a conectar el cable USB: setup() se ejecuta otra vez, el servo vuelve a su ángulo inicial, la LCD muestra de nuevo el texto de arranque y el mensaje de inicio reaparece en el Monitor Serie. Un Arduino colgado, en cambio, no responde a nada; los LED se quedan en su último estado, la salida serie se detiene y la placa sigue así hasta que pulsas el botón de reset. Como las causas y las soluciones son distintas, empieza por averiguar cuál de los dos te pasa. Lo más fácil es añadir una línea Serial.println("INICIO") en setup() y dejar abierto el Monitor Serie.

¿Por qué se reinicia solo un Arduino? Las fuentes de reinicio

Solo unas pocas fuentes pueden reiniciar el procesador ATmega328P del Arduino Uno y del Nano, y cada una tiene su propio disparador. Cuando la tensión de alimentación baja de cierto umbral entra en acción el detector de brown-out (BOD); en el Uno y el Nano los bits de configuración del chip (fuses) fijan ese umbral en 2,7 V. Todo lo que lleve el pin RESET a LOW también reinicia la placa: el botón de reset, la señal DTR del ordenador o el ruido que capta un cable largo conectado a ese pin. Además hay un caso que parece un reinicio pero no lo es: por culpa de una memoria corrupta el programa salta a la dirección 0 y el código empieza de nuevo, pero como los periféricos no se reinician, la placa empieza a comportarse de forma extraña.

Corriente de servos, motores y relés: cómo una caída de tensión provoca el reinicio

Un servo SG90 consume 100–250 mA mientras se mueve, pero al arrancar y cuando su brazo está forzado la corriente sube por encima de 0,5 A. El puerto USB 2.0 de un ordenador da como máximo 500 mA, y el fusible de la línea USB del Uno trabaja en ese mismo límite. Cuando el servo, los 50 mA de la propia placa y algunos módulos superan ese límite, el puerto o el fusible recortan la corriente, la línea de 5 V se hunde un instante y, si la tensión baja de 2,7 V, el BOD reinicia la placa. El caso más traicionero es cuando la tensión se queda entre 2,7 V y unos 3,8 V: según la hoja de datos del ATmega328P, necesita unos 3,8 V para funcionar con seguridad a 16 MHz. En esa zona gris el BOD no actúa, pero el procesador trabaja fuera de su límite de velocidad, así que la placa puede colgarse en lugar de reiniciarse, dar valores absurdos o hacer que pantallas y sensores I2C se bloqueen internamente.

Los cables también cuentan. Los cables jumper finos que se usan en la protoboard suelen ser de 26–28 AWG, y el hilo de cobre de 28 AWG tiene unos 0,21 Ω por metro. Si alimentas el servo con dos cables de 20 cm (0,4 m entre ida y vuelta) a través de una protoboard, los cables añaden unos 0,085 Ω y cuatro contactos de la protoboard otros 0,2 Ω aproximadamente. Según la ley de Ohm (V = I × R), un pico de 1 A del servo pierde unos 0,3 V en esos 0,29 Ω. Un cable USB fino y largo, el fusible y los componentes de protección de la placa suman cerca de medio ohmio más; con el mismo pico, la línea de 5 V del Arduino baja de 4,5 V, y si el puerto del ordenador empieza a limitar la corriente, la caída es mucho mayor. Puedes calcular la caída de tu propio circuito con la calculadora de la ley de Ohm.

Solución 1: alimentación separada y GND común

1. Elige una fuente aparte para servos y motores: para servos, un adaptador de 5–6 V que dé al menos 1 A por servo (2–3 A para un MG996R), un pack de 4 pilas AA NiMH o un módulo reductor LM2596 ajustado a 5–6 V.
2. Conecta el positivo de la fuente solo a los cables rojos de los servos o a la entrada de potencia del driver de motor; no lleves esta línea al pin 5V del Arduino.
3. Conecta el negativo (GND) de la fuente tanto a la carga como al pin GND del Arduino. Sin esta GND común la tensión del pin de señal no tiene referencia; el servo tiembla o no se mueve.
4. Une las GND en un solo punto junto a la fuente (masa en estrella). La corriente del motor no debe volver a través del Arduino y sus pistas de GND; de lo contrario, la GND del Arduino oscila con cada pico del motor.
5. Alimenta el Arduino por su propia entrada: USB, el conector DC (7–12 V) o 5 V regulados. Así el procesador no se ve afectado aunque la fuente de los servos se hunda.
6. Por último, mide entre los pines 5V y GND del Arduino mientras el servo se mueve, o ejecuta el sketch de diagnóstico de más abajo; la tensión no debería bajar de 4,75 V.

Solución 2: condensador (100–470 µF) y diodo

Un condensador electrolítico funciona como un pequeño depósito de energía junto a la carga: cuando el servo pide una corriente repentina, la entrega él mismo hasta que los cables y la fuente reaccionan. Cuánto ayuda lo dice la fórmula ΔV = I × Δt / C. Un condensador de 470 µF solo deja caer la tensión 0,21 V durante un pico de 1 A que dura 100 µs; si el mismo pico dura 1 ms, la caída es de 2,1 V. Es decir, el condensador absorbe los picos cortos y el ruido de las escobillas del motor, pero no sustituye a una fuente insuficiente. Pon 470–1000 µF en la línea de los servos y 100 µF entre 5V y GND del Arduino, y añade junto a cada uno un condensador cerámico de 100 nF marcado como 104 para el ruido de alta frecuencia. Para leer los códigos usa la herramienta de código de condensadores, y para sumar condensadores en paralelo la calculadora de redes de condensadores; las diferencias entre tipos están en ¿Qué es un condensador?.

Las bobinas de los relés, los motores y los solenoides son inductancias. Cuando la corriente que las atraviesa se corta de golpe, la bobina se opone al cambio y genera en sus terminales un pico de tensión breve de decenas o incluso cientos de voltios, muy por encima de la alimentación. Ese pico se propaga por la línea y reinicia el Arduino, y además puede destruir el transistor que la controla o el propio pin. La solución es un diodo de rueda libre (flyback) conectado en paralelo con la bobina y en sentido inverso: el extremo con la franja (cátodo) de un 1N4007 va al positivo y el otro al lado que va al transistor. Los módulos de relé ya traen este diodo; si usas un relé suelto, un solenoide o un motor controlado con un transistor o un MOSFET, tienes que añadirlo tú. En motores con control de velocidad por PWM, el diodo Schottky 1N5819, más rápido, da mejores resultados. Más detalles en ¿Qué es un diodo? y en cómo usar un MOSFET con Arduino.

Ruido, contactos de relé y cables largos

Si la placa se reinicia justo cuando un relé se desactiva, el problema no es la alimentación sino el ruido. Cuando un relé apaga una bomba de agua, un ventilador, un fluorescente o un contactor, se forma un pequeño arco entre los contactos y ese arco emite ruido electromagnético de banda ancha. El ruido se acopla a los cables de los sensores cercanos, a la línea RESET y a las líneas I2C, y reinicia el procesador o bloquea un módulo. Para evitarlo, usa un módulo de relés con optoacoplador, quita el puente JD-VCC y alimenta las bobinas desde una fuente de 5 V aparte; así la corriente de las bobinas y el ruido quedan lejos de la línea del Arduino. Con cargas inductivas conectadas a la red, un snubber RC (100 Ω + 100 nF, clase X2) o un varistor en paralelo con los contactos o con la carga reduce mucho el arco. Tienes los detalles de conexión en ¿Qué es un módulo de relé? y la idea del aislamiento en ¿Qué es un optoacoplador?.

• I2C corto: el I2C se diseñó para distancias cortas dentro de una placa. Mantén los cables SDA y SCL por debajo de 50 cm; en tramos más largos baja las resistencias pull-up de 4,7 kΩ a 2,2 kΩ y deja la velocidad en 100 kHz.
• Cables trenzados: trenza cada cable de señal con un cable de GND; los pares trenzados de un cable de red son ideales para esto.
• Separa potencia y señal: no lleves los cables de sensores en paralelo con los de motores, relés o la red eléctrica; si tienen que cruzarse, que sea en ángulo recto.
• Deja libre el pin RESET: un cable largo en el pin RESET actúa como una antena y reinicia la placa al tocarlo o cuando funciona un motor cercano. Si necesitas un botón de reset externo, usa un cable corto.
• Ferritas y caja: los anillos de ferrita en los cables de los motores y una caja metálica reducen el ruido de alta frecuencia.
• Pon un tiempo límite: si el ruido bloquea el bus I2C, la librería Wire espera para siempre por defecto y la placa se cuelga. El código siguiente evita ese cuelgue con un tiempo límite.

1#include <Wire.h>
2
3const uint8_t ADDR = 0x27;   // örnek: I2C LCD adresi / example: I2C LCD address
4
5void setup() {
6  Serial.begin(9600);
7  Wire.begin();
8  Wire.setWireTimeout(25000, true);   // 25 ms; takılırsa I2C birimini sıfırla / reset the I2C unit on timeout
9}
10
11void loop() {
12  Wire.beginTransmission(ADDR);
13  byte err = Wire.endTransmission();  // 0 = cihaz cevap verdi / 0 = device answered
14
15  if (Wire.getWireTimeoutFlag()) {    // hat kilitlendi ama program donmadı / bus hung, sketch did not freeze
16    Serial.println(F("I2C zaman asimi / I2C timeout"));
17    Wire.clearWireTimeoutFlag();
18  } else if (err != 0) {
19    Serial.print(F("I2C hatasi / I2C error: "));
20    Serial.println(err);              // 2 = cihaz yok, 5 = zaman aşımı / 2 = no device, 5 = timeout
21  }
22  delay(1000);
23}

RAM desbordada y uso de String

El Arduino Uno solo tiene 2 KB de SRAM, y ese pequeño espacio lo comparten las variables globales, la memoria dinámica (heap) y la pila (stack) que usan las llamadas a funciones. Si al compilar ves el aviso Low memory available, stability problems may occur., lo más probable es que la placa falle al cabo de un tiempo. La causa más traicionera es la clase String: cada concatenación reserva un trozo nuevo en el heap, el anterior se libera y con el tiempo la memoria queda llena de huecos. Un día la pila choca con el heap y el programa se reinicia o se cuelga en un momento aleatorio. Como esto suele aparecer tras minutos u horas, es fácil distinguirlo de los problemas de alimentación. Deja los textos fijos en la flash con la macro F(), usa arrays de char de tamaño fijo y snprintf() en lugar de String y no declares arrays locales grandes dentro de las funciones. El código siguiente muestra la RAM libre cada segundo; si el valor no para de bajar, hay una fuga de memoria. El tema completo está en Arduino sin memoria suficiente.

1extern int __heap_start, *__brkval;
2
3// Heap ile stack arasındaki boş RAM / free RAM between heap and stack
4int freeRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9char line[32];             // sabit tampon, bir kez ayrılır / fixed buffer, allocated once
10unsigned long counter = 0;
11
12void setup() {
13  Serial.begin(9600);
14}
15
16void loop() {
17  counter++;
18  // Kaçın / avoid: String s = "Sayac: " + String(counter) + " sn";
19  snprintf(line, sizeof(line), "Sayac: %lu sn", counter);  // heap kullanmaz / no heap use
20  Serial.println(line);
21
22  Serial.print(F("Bos RAM / free RAM: "));  // F(): metin flaşta kalır / text stays in flash
23  Serial.println(freeRam());                // sürekli azalıyorsa sızıntı var / steady drop = leak
24  delay(1000);
25}

Watchdog: el cinturón de seguridad contra los cuelgues

El watchdog (perro guardián) es un contador dentro del procesador que funciona de forma independiente con su propio oscilador de 128 kHz. Tu programa tiene que alimentarlo con regularidad mediante wdt_reset(); si no lo hace dentro del tiempo fijado (entre 15 ms y 8 segundos), el watchdog reinicia la placa. Así, un bus I2C bloqueado, una función atrapada en un bucle infinito o una lectura de sensor estropeada por el ruido no pueden congelar la placa para siempre; se recupera en pocos segundos. Recuerda que el watchdog es un cinturón de seguridad, no una reparación: no arregla problemas de alimentación ni de memoria, solo permite que un proyecto que funciona en el exterior se recupere por sí mismo. Elige un tiempo claramente mayor que la operación más larga de tu código; con un delay(3000) en el código, un watchdog de 2 segundos reiniciará la placa una y otra vez.

1#include <avr/wdt.h>
2
3const int LED_PIN = 13;
4
5void setup() {
6  MCUSR = 0;          // reset bayraklarını temizle / clear reset flags
7  wdt_disable();      // açılışta watchdog kapalı / watchdog off during startup
8  Serial.begin(9600);
9  pinMode(LED_PIN, OUTPUT);
10  Serial.println(F("Basladi / started"));
11  delay(500);
12  wdt_enable(WDTO_2S);  // 2 sn içinde beslenmezse reset / reset if not fed within 2 s
13}
14
15void loop() {
16  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
17  delay(250);
18
19  // Seri Monitör'den 'x' gönder: takılmayı taklit eder / send 'x' to simulate a hang
20  if (Serial.available() && Serial.read() == 'x') {
21    Serial.println(F("Sonsuz donguye girildi / stuck in a loop"));
22    while (true) {}     // wdt_reset() yok: 2 sn sonra reset / no wdt_reset(): reset after 2 s
23  }
24
25  wdt_reset();          // her turda besle / feed it every loop
26}

Sketch de diagnóstico: que el Arduino mida su propia tensión y su RAM

Un multímetro es demasiado lento para ver caídas de tensión de milisegundos. En su lugar puedes usar el propio Arduino como un instrumento de medida sencillo: el código siguiente mide con el ADC la referencia interna de 1,1 V del chip y calcula a partir de ella la tensión de alimentación unas 9000 veces por segundo, y muestra el valor más bajo de cada segundo. Además incrementa un contador en la EEPROM en cada arranque, de modo que aunque abras el Monitor Serie más tarde verás cuántas veces se ha reiniciado la placa. Como carga de prueba mueve el servo de D9 entre 0 y 180 grados cada 2 segundos; si tienes tu propio proyecto, puedes añadir la parte de medida a su código. Abre el Monitor Serie a 115200 baudios.

1// Reset teşhis kodu (Uno, Nano) / reset diagnostic sketch (Uno, Nano)
2#include <EEPROM.h>
3#include <Servo.h>
4
5Servo servo;
6extern int __heap_start, *__brkval;
7
8int freeRam() {
9  int v;
10  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
11}
12
13// Besleme gerilimini dahili 1,1 V referansla ölç / measure supply voltage against the internal 1.1 V reference
14long readVcc() {
15  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
16  ADCSRA |= _BV(ADSC);                  // ölçümü başlat / start a conversion
17  while (bit_is_set(ADCSRA, ADSC)) {}   // bitmesini bekle / wait until it is done
18  return 1125300L / ADC;                // 1100 mV × 1023 / okuma → mV / reading → mV
19}
20
21long minVcc = 9999;
22unsigned long lastPrint = 0, lastMove = 0;
23bool sideA = false;
24
25void setup() {
26  Serial.begin(115200);
27  uint16_t boots;
28  EEPROM.get(0, boots);                 // açılış sayacı / boot counter
29  if (boots == 0xFFFF) boots = 0;       // boş EEPROM / blank EEPROM
30  EEPROM.put(0, ++boots);
31  Serial.print(F("BASLADI / STARTED  acilis no / boot #"));
32  Serial.println(boots);
33
34  servo.attach(9);                      // test yükü: servo D9'da / test load: servo on D9
35  readVcc();                            // ilk ölçümü at / discard the first reading
36  delay(5);
37}
38
39void loop() {
40  long v = readVcc();                   // saniyede ~9000 ölçüm / ~9000 samples per second
41  if (v < minVcc) minVcc = v;
42
43  if (millis() - lastMove >= 2000) {    // 2 sn'de bir servoyu oynat / move the servo every 2 s
44    lastMove = millis();
45    sideA = !sideA;
46    servo.write(sideA ? 180 : 0);
47  }
48
49  if (millis() - lastPrint >= 1000) {
50    lastPrint = millis();
51    Serial.print(F("sn/s: "));
52    Serial.print(millis() / 1000);
53    Serial.print(F("  min Vcc (mV): "));
54    Serial.print(minVcc);
55    Serial.print(F("  bos RAM / free RAM: "));
56    Serial.println(freeRam());
57    minVcc = 9999;                      // her saniye sıfırla / reset every second
58  }
59}

Interpreta los resultados así: en un Uno sano alimentado por USB, el valor mínimo se mantiene entre 4,6 y 5,1 V. Si baja de 4,5 V cada vez que el servo se mueve y los reinicios coinciden con esos momentos, el problema es la alimentación. Si el número de arranque sigue subiendo mientras la tensión se mantiene estable, busca la causa en el ruido o en el software; si además la RAM libre no deja de bajar, tienes una fuga de memoria. La referencia interna de 1,1 V puede variar alrededor de un 10 % de un chip a otro, así que compara la medida una vez con un multímetro: si el multímetro marca 4,95 V y el código muestra 5,10 V, cambia la constante 1125300 por 1125300 × 4,95 / 5,10 ≈ 1092200. Cuando termines, quita el contador de EEPROM del código; las celdas de la EEPROM aguantan unas 100.000 escrituras.

Tabla de diagnóstico paso a paso: síntoma, causa y solución

Lee la tabla de arriba abajo; las primeras filas son las causas más frecuentes. Cambia una sola cosa cada vez y vuelve a ejecutar el sketch de diagnóstico. Si cambias tres cosas a la vez no sabrás cuál resolvió el problema, y el mismo fallo volverá en tu siguiente proyecto.

El puerto USB no da suficiente corriente y el reinicio del Monitor Serie

Un puerto USB 2.0 da 500 mA y uno USB 3.0, 900 mA; pero como el fusible USB del Uno limita a 500 mA, un puerto USB 3.0 no te da corriente extra. Un hub USB sin alimentación reparte la corriente de un solo puerto entre todos los dispositivos, los puertos del frontal de la torre pierden tensión por sus finos cables internos y los portátiles que funcionan con batería pueden alimentar débilmente sus puertos en modo de ahorro. Conecta la placa directamente a un puerto trasero con un cable corto y de buena calidad. También hay un reinicio que no es un fallo: el Uno y el Nano se reinician mediante la señal DTR cuando el Monitor Serie o un programa en Python abre el puerto, y precisamente esa función es la que permite subir el código. Si te comunicas desde Python, espera 2 segundos después de abrir el puerto (comunicación serie entre Arduino y Python). Si quieres desactivar el reinicio por completo, pon un condensador de 10 µF entre RESET y GND y quítalo para subir código. Los detalles del puerto serie están en Monitor Serie de Arduino.

El ESP32 se reinicia solo: cómo leer el motivo del reinicio

El ESP32 es todavía más sensible a los mismos problemas porque funciona a 3,3 V y consume unos 240 mA al transmitir por Wi-Fi, más en picos breves; Espressif recomienda una fuente capaz de dar al menos 500 mA. Lo bueno es que el propio ESP32 te dice por qué se ha reiniciado. El mensaje Brownout detector was triggered en el Monitor Serie indica una caída de tensión, y las líneas rst:0xf (RTCWDT_BROWN_OUT_RESET) o Guru Meditation Error del arranque muestran el motivo del reinicio. El código siguiente lee esa misma información con esp_reset_reason() y la convierte en un texto legible. En el ESP32 el botón EN apaga y enciende el chip por completo, así que un reinicio con ese botón también aparece como un encendido. Tienes todos los mensajes y sus soluciones en errores brownout y Guru Meditation del ESP32.

1#include <esp_system.h>
2
3// Reset sebebini yazıya çevir / turn the reset reason into text
4const char* reasonText(esp_reset_reason_t r) {
5  switch (r) {
6    case ESP_RST_POWERON:   return "Guc acilisi ya da EN tusu / power-on or EN button";
7    case ESP_RST_SW:        return "Yazilimla (ESP.restart) / software restart";
8    case ESP_RST_PANIC:     return "Cokme (Guru Meditation) / panic";
9    case ESP_RST_INT_WDT:   return "Kesme watchdog'u / interrupt watchdog";
10    case ESP_RST_TASK_WDT:  return "Gorev watchdog'u / task watchdog";
11    case ESP_RST_WDT:       return "Diger watchdog / other watchdog";
12    case ESP_RST_DEEPSLEEP: return "Derin uykudan uyanma / deep sleep wake-up";
13    case ESP_RST_BROWNOUT:  return "Gerilim dusmesi (brownout) / brownout";
14    default:                return "Bilinmeyen / unknown";
15  }
16}
17
18void setup() {
19  Serial.begin(115200);
20  delay(500);
21  esp_reset_reason_t r = esp_reset_reason();
22  Serial.print("Reset nedeni / reset reason: ");
23  Serial.println(reasonText(r));
24}
25
26void loop() {
27  Serial.print("Calisma suresi / uptime (s): ");
28  Serial.println(millis() / 1000);
29  delay(5000);
30}

Raspberry Pi Pico: motivo del reinicio y watchdog (MicroPython)

Gracias a su regulador buck-boost, la Raspberry Pi Pico funciona con cualquier tensión entre 1,8 y 5,5 V en el pin VSYS, así que tolera mejor las caídas de tensión que un Arduino. Aun así, si conectas un servo al pin VBUS, que lleva los 5 V del USB, la corriente sale directamente del puerto del ordenador y, si el puerto se hunde, la Pico se apaga también; tampoco deberías sacar más de 300 mA en total del pin 3V3. El pin de reset de la Pico, RUN, tiene una resistencia pull-up interna de unos 50 kΩ dentro del chip; conectarle un cable largo deja la puerta abierta al ruido, igual que el pin RESET del Arduino. En MicroPython, machine.reset_cause() devuelve solo dos valores en la Pico: PWRON_RESET para el encendido o el pin RUN, y WDT_RESET para el watchdog o machine.reset(). El watchdog se puede ajustar como máximo a 8388 ms y no se puede detener una vez iniciado; sigue reiniciando la placa aunque pares el programa en Thonny. Por eso conviene poner una espera de 3 segundos al principio del código.

1import machine, time
2from machine import Pin
3
4time.sleep(3)   # Thonny durdurabilsin diye bekle / wait so Thonny can stop the script
5
6neden = machine.reset_cause()
7if neden == machine.WDT_RESET:
8    print("Watchdog ya da machine.reset() / watchdog or machine.reset()")
9else:
10    print("Guc acilisi ya da RUN pini / power-on or RUN pin")
11
12led = Pin("LED", Pin.OUT)          # Pico ve Pico W dahili LED / onboard LED
13wdt = machine.WDT(timeout=5000)    # 5 sn; RP2040'ta en fazla 8388 ms / max 8388 ms on RP2040
14
15sayac = 0
16while True:
17    led.toggle()
18    sayac += 1
19    print("Calisiyor / running", sayac)
20    wdt.feed()                     # her turda besle / feed it every loop
21    time.sleep(1)

La alimentación adecuada para cada proyecto

• Coche robot: alimenta los motores desde un pack 2S 18650 a través de un L298N o un L9110S y pon un condensador de 100 nF en los terminales de cada motor; el montaje está en cómo hacer un coche con Arduino.
• Brazo robótico con servos: para cuatro servos o más usa una fuente de 5–6 V que dé al menos 3–5 A y añade 1000 µF a la línea de servos; para elegir componentes mira servo MG996R y brazo robótico con Arduino.
• Riego con bomba y relé: alimenta la bomba con una fuente aparte, aísla el relé con JD-VCC y aleja los cables largos de los sensores del cable de la bomba (sensor de humedad del suelo).
• Tiras LED y NeoPixel: calcula unos 2 A por cada 30 LED, pon 1000 µF en la entrada de la tira y una resistencia de 300–500 Ω en la línea de datos (WS2812B NeoPixel).
• Control de motores DC: no olvides el diodo de rueda libre en cada motor que controles con un transistor o un MOSFET; para las placas driver ya hechas mira control de motores DC con L298N.
• Estación de sensores en exteriores: activa el watchdog, configura un tiempo límite para el I2C y toma la alimentación de una fuente eficiente como el reductor de tensión LM2596.

Que un Arduino se reinicie solo es frustrante, pero casi siempre hay una causa medible y con solución: primero identifica el síntoma, después mide la tensión y la RAM con el sketch de diagnóstico, separa la alimentación, une las GND, añade el condensador y el diodo y, si hace falta, protege el proyecto con el watchdog. Con este montaje, tus proyectos con servos, motores y relés funcionarán durante días sin problemas. En la app BlueGrays encontrarás el control de servomotores, un coche Bluetooth con L298N, un robot que esquiva obstáculos, el control de una bombilla de 220 V y una estación de riego inteligente, con esquemas que muestran las conexiones de alimentación correctas y código paso a paso.