Arduino reiniciando sozinho? Resolva problemas de servo, relé e travamento

Se o seu Arduino fica reiniciando ou trava depois de funcionar um tempo, a placa quase nunca está com defeito. Na maioria dos casos, a causa é a alimentação: quando um servo começa a se mover, um motor acelera ou um relé fecha, o consumo repentino de corrente derruba a linha de 5 V por um instante e a proteção contra tensão baixa do processador (brown-out) reinicia a placa. Nos casos restantes, o culpado é o ruído elétrico de relés e motores, fios longos, a RAM cheia, um watchdog esquecido ou uma porta USB do computador que não fornece corrente suficiente.

Neste guia, você vai aprender primeiro a distinguir se a placa está realmente reiniciando ou só travando. Depois explicamos como cada causa funciona, com valores reais de corrente e tensão, e mostramos as soluções com código: alimentação separada e GND comum, capacitores de 100–470 µF, diodos de roda livre, buffers fixos no lugar de String e o watchdog. Você também vai encontrar um sketch de diagnóstico que mede a própria tensão de alimentação do Arduino e a RAM livre, uma tabela de diagnóstico passo a passo do sintoma à solução e exemplos que leem o motivo do reinício no ESP32 e no Raspberry Pi Pico.

Reinício ou travamento? Identifique o sintoma primeiro

Um Arduino que reinicia roda o programa desde o começo, como se você tivesse tirado e posto o cabo USB de novo: o setup() roda outra vez, o servo volta ao ângulo inicial, o LCD mostra de novo o texto de abertura e a mensagem de início reaparece no Monitor Serial. Já um Arduino travado não responde a nada; os LEDs ficam no último estado, a saída serial para e a placa fica assim até você apertar o botão de reset. Como as causas e as soluções são diferentes, comece descobrindo qual é o seu caso. O jeito mais fácil é acrescentar uma linha Serial.println("STARTED") ao setup() e deixar o Monitor Serial aberto.

Por que um Arduino reinicia sozinho? As fontes de reset

Só algumas fontes conseguem reiniciar o processador ATmega328P do Arduino Uno e do Nano, e cada uma tem seu próprio gatilho. Quando a tensão de alimentação cai abaixo de um certo limite, entra em ação o detector de brown-out (BOD); no Uno e no Nano, a configuração dos fusíveis põe esse limite em 2,7 V. Qualquer coisa que leve o pino RESET a LOW também reinicia a placa: o botão de reset, o sinal DTR do computador ou o ruído captado por um fio longo ligado a esse pino. Há também um caso que parece um reset, mas não é: a memória corrompida faz o programa saltar para o endereço 0 e o código recomeça, mas, como os periféricos de hardware não são reiniciados, a placa começa a se comportar de forma estranha.

Corrente de servo, motor e relé: como uma queda de tensão causa um reset

Um servo SG90 consome 100–250 mA enquanto se move, mas na partida e com o braço carregado a corrente salta acima de 0,5 A. Uma porta USB 2.0 de computador fornece no máximo 500 mA, e o fusível da linha USB do Uno trabalha no mesmo limite. Quando o servo, os 50 mA da própria placa e alguns módulos passam desse limite, a porta ou o fusível limitam a corrente, a linha de 5 V cai por um instante e, se a tensão ficar abaixo de 2,7 V, o BOD reinicia a placa. O caso mais traiçoeiro é quando a tensão fica entre 2,7 V e uns 3,8 V: segundo a folha de dados do ATmega328P, o chip precisa de cerca de 3,8 V para funcionar com segurança a 16 MHz. Nessa zona cinzenta, o BOD não dispara, mas o processador funciona fora do seu limite de velocidade, então a placa pode travar em vez de reiniciar, gerar valores sem sentido, ou displays e sensores I2C podem travar internamente.

Os fios também importam. Os jumpers finos usados em projetos com protoboard costumam ser de 26–28 AWG, e o fio de cobre 28 AWG tem cerca de 0,21 Ω por metro. Se você alimenta o servo por dois fios de 20 cm (0,4 m de ida e volta) e uma protoboard, os fios acrescentam uns 0,085 Ω, e quatro contatos da protoboard somam cerca de 0,2 Ω. Pela lei de Ohm (V = I × R), um pulso de 1 A do servo perde cerca de 0,3 V nesses 0,29 Ω. Um cabo USB fino e longo, o fusível e as peças de proteção da placa acrescentam mais uns meio ohm; durante o mesmo pulso, a linha de 5 V do Arduino cai abaixo de 4,5 V e, se a porta do computador começar a limitar a corrente, a queda é bem mais funda. Você pode calcular a queda no seu próprio circuito com a calculadora da lei de Ohm.

Solução 1: fonte de alimentação separada e GND comum

1. Escolha uma fonte separada para servos e motores: para servos, um adaptador de 5–6 V que forneça pelo menos 1 A por servo (2–3 A para um MG996R), um pack de 4×AA NiMH ou um módulo buck LM2596 ajustado para 5–6 V.
2. Ligue o positivo da fonte só aos fios vermelhos dos servos ou à entrada de alimentação do driver de motor; não ligue essa linha ao pino 5V do Arduino.
3. Ligue o negativo (GND) da fonte tanto à carga quanto ao pino GND do Arduino. Sem esse GND comum, a tensão do pino de sinal fica sem referência; o servo treme ou nem se move.
4. Una os GNDs em um único ponto ao lado da fonte (aterramento em estrela). A corrente do motor não pode voltar passando pelo Arduino e pelas trilhas de GND dele; senão, o nível do GND do Arduino se desloca a cada pulso do motor.
5. Alimente o Arduino pela própria entrada: USB, o conector DC (7–12 V) ou 5 V regulados. Assim o processador não é afetado mesmo que a fonte dos servos caia.
6. Por fim, meça entre os pinos 5V e GND do Arduino enquanto o servo se move, ou rode o sketch de diagnóstico abaixo; a tensão não deve cair abaixo de 4,75 V.

Solução 2: capacitores (100–470 µF) e diodos

Um capacitor eletrolítico funciona como um pequeno reservatório de energia ao lado da carga: quando o servo pede uma corrente repentina, ele mesmo fornece essa corrente até os fios e a fonte darem conta. A fórmula ΔV = I × Δt / C mostra o quanto ele ajuda. Um capacitor de 470 µF deixa a tensão cair só 0,21 V durante um pulso de 1 A que dura 100 µs; se o mesmo pulso durar 1 ms, a queda é de 2,1 V. Ou seja, um capacitor engole pulsos curtos e o ruído das escovas do motor, mas não substitui uma fonte insuficiente. Ponha 470–1000 µF na linha dos servos e 100 µF entre o 5V e o GND do Arduino, e acrescente ao lado de cada um um capacitor cerâmico de 100 nF com a marcação 104 para o ruído de alta frequência. Use a ferramenta de código de capacitores para ler as marcações e a calculadora de associação de capacitores para achar o total de capacitores em paralelo; as diferenças entre os tipos estão em O que é um capacitor?.

Bobinas de relé, motores e solenoides são todos indutores. Quando a corrente que passa por eles é cortada de repente, a bobina resiste à mudança e produz um pico de tensão curto de dezenas ou até centenas de volts, muito acima da tensão de alimentação. Esse pico se espalha pela linha e reinicia o Arduino, e também pode destruir o transistor do driver ou o pino. A solução é um diodo de roda livre (flyback) ligado em paralelo com a bobina, ao contrário: a ponta do cátodo de um 1N4007, com a faixa, vai para o lado positivo, e a outra ponta para o lado que vai ao transistor. Os módulos relé prontos já têm esse diodo; se você usa um relé solto, um solenoide ou um motor acionado por transistor ou MOSFET, precisa acrescentar o diodo você mesmo. Para motores com controle de velocidade por PWM, o diodo Schottky 1N5819, mais rápido, dá melhores resultados. Para os detalhes, veja O que é um diodo? e como usar um MOSFET com Arduino.

Ruído, contatos de relé e fios longos

Se a placa reinicia exatamente quando um relé desliga, o problema é ruído, não alimentação. Quando um relé desliga uma bomba d'água, uma ventoinha, uma lâmpada fluorescente ou um contator, forma-se um pequeno arco entre os contatos, e esse arco irradia ruído eletromagnético de banda larga. O ruído se acopla aos fios de sensores próximos, à linha RESET e às linhas I2C, reiniciando o processador ou travando um módulo. Para evitar isso, use um módulo relé com optoacoplador, tire o jumper JD-VCC e alimente as bobinas dos relés por uma fonte de 5 V separada; isso mantém a corrente das bobinas e o ruído longe da linha do Arduino. Com cargas indutivas ligadas à rede, um snubber RC (100 Ω + 100 nF, classe X2) ou um varistor sobre os contatos ou sobre a carga reduz muito o arco. Os detalhes das ligações estão em O que é um módulo relé?, e a ideia por trás da isolação em O que é um optoacoplador?.

• Mantenha o I2C curto: o I2C foi feito para distâncias curtas em uma placa de circuito. Mantenha os fios SDA e SCL com menos de 50 cm; em trechos mais longos, baixe os resistores de pull-up de 4,7 kΩ para 2,2 kΩ e deixe a velocidade em 100 kHz.
• Use fios trançados: trance cada fio de sinal com um fio de GND; os pares trançados de um cabo de rede são ideais para isso.
• Separe alimentação e sinal: não passe fios de sensores em paralelo com fios de motor, relé ou da rede elétrica; se precisarem se cruzar, cruze em ângulo reto.
• Deixe o pino RESET em paz: um fio longo no pino RESET funciona como antena e reinicia a placa quando é tocado ou quando um motor próximo funciona. Se você precisa de um botão de reset externo, mantenha o fio curto.
• Ferrites e um gabinete: anéis de ferrite nos fios dos motores e um gabinete metálico reduzem o ruído de alta frequência.
• Acrescente um tempo limite: se o ruído travar o barramento I2C, a biblioteca Wire espera para sempre por padrão e a placa trava. O código abaixo evita esse travamento com um tempo limite.

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}

Estouro de RAM e uso de String

O Arduino Uno tem só 2 KB de SRAM, e esse espaço pequeno é dividido entre as variáveis globais, a memória dinâmica (heap) e a pilha (stack) usada pelas chamadas de função. Se você vir o aviso Low memory available, stability problems may occur. no fim da compilação, a placa provavelmente vai falhar depois de um tempo. A causa mais traiçoeira é a classe String: cada concatenação aloca um pedaço novo no heap, o antigo é liberado e, com o tempo, a memória fica cheia de buracos. Um dia a pilha colide com o heap e o programa reinicia ou trava em um momento aleatório. Como isso costuma aparecer depois de minutos ou horas, é fácil de distinguir dos problemas de alimentação. Guarde textos constantes na flash com a macro F(), use arrays de char de tamanho fixo e snprintf() no lugar de String, e não declare arrays locais grandes dentro de funções. O código abaixo mostra a RAM livre a cada segundo; se o valor não para de cair, há um vazamento de memória. A história completa está em memória insuficiente no Arduino.

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: um cinto de segurança contra travamentos

O watchdog timer é um contador dentro do processador que funciona de forma independente, com o seu próprio oscilador de 128 kHz. O seu programa precisa alimentá-lo regularmente com wdt_reset(); se não for alimentado dentro do tempo definido (entre 15 ms e 8 segundos), o watchdog reinicia a placa. Assim, um barramento I2C travado, uma função presa em um laço infinito ou uma leitura de sensor corrompida por ruído não conseguem travar a placa para sempre; ela se recupera em poucos segundos. Lembre-se de que o watchdog é um cinto de segurança, não um conserto: ele não corrige problemas de alimentação ou de memória, só permite que um projeto em campo se recupere sozinho. Escolha um tempo limite bem maior que a operação mais longa do seu código; em um código com delay(3000), um watchdog de 2 segundos vai reiniciar a placa sem parar.

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: deixe o Arduino medir a própria tensão e a RAM

Um multímetro é lento demais para ver quedas de tensão de milissegundos. Em vez disso, você pode usar o próprio Arduino como um instrumento de medição simples: o código abaixo usa o ADC para medir a referência interna de 1,1 V do chip e calcula a partir dela a tensão de alimentação, cerca de 9000 vezes por segundo, e mostra o menor valor de cada segundo. Ele também incrementa um contador na EEPROM a cada inicialização, então mesmo que você abra o Monitor Serial depois, dá para ver quantas vezes a placa reiniciou. Como carga de teste, ele move o servo do D9 entre 0 e 180 graus a cada 2 segundos; se você tem o seu próprio projeto, pode acrescentar a parte de medição ao código dele. Abra o Monitor Serial em 115200 baud.

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}

Leia os resultados assim: em um Uno saudável alimentado pelo USB, o menor valor fica entre 4,6 e 5,1 V. Se o valor cai abaixo de 4,5 V toda vez que o servo se move e os resets coincidem com esses momentos, o problema é a alimentação. Se o número de inicializações continua subindo enquanto a tensão fica estável, procure ruído ou uma causa de software; se a RAM livre também diminui o tempo todo, há um vazamento de memória. A referência interna de 1,1 V pode variar cerca de 10% de um chip para outro, então compare a leitura uma vez com um multímetro: se o multímetro mostra 4,95 V enquanto o código mostra 5,10 V, mude a constante 1125300 para 1125300 × 4,95 / 5,10 ≈ 1092200. Tire o contador da EEPROM do código quando terminar; as células da EEPROM aguentam cerca de 100.000 gravações.

Tabela de diagnóstico passo a passo: sintoma, causa, solução

Leia a tabela de cima para baixo; as primeiras linhas são as causas mais comuns. Mude só uma coisa de cada vez e rode o sketch de diagnóstico de novo. Se você mudar três coisas de uma vez, não vai saber qual resolveu o problema, e a mesma falha vai voltar no seu próximo projeto.

Porta USB que não fornece corrente suficiente e o reset do Monitor Serial

A porta USB 2.0 de um computador fornece 500 mA, e a USB 3.0, 900 mA; mas como o fusível do USB do Uno limita em 500 mA, uma porta USB 3.0 não dá corrente a mais. Um hub USB sem alimentação divide a corrente de uma porta entre todos os dispositivos, as portas frontais perdem tensão pelos cabos internos finos, e notebooks na bateria podem alimentar mal as portas no modo de economia de energia. Ligue a placa direto em uma porta traseira, com um cabo curto e de boa qualidade. Também há um reset que não é defeito: o Uno e o Nano reiniciam sozinhos pelo sinal DTR quando o Monitor Serial ou um programa em Python abre a porta, e é justamente esse recurso que torna o carregamento possível. Se você se comunica pelo Python, espere 2 segundos depois de abrir a porta (comunicação serial entre Arduino e Python). Se quiser desativar o reset de vez, ponha um capacitor de 10 µF entre RESET e GND e tire-o na hora de carregar. Os detalhes da porta serial estão em Monitor Serial do Arduino.

ESP32 reiniciando sem parar: lendo o motivo do reset

O ESP32 é ainda mais sensível aos mesmos problemas, porque funciona com 3,3 V e consome cerca de 240 mA durante a transmissão Wi-Fi, mais em picos curtos; a Espressif recomenda uma fonte capaz de fornecer pelo menos 500 mA. A boa notícia é que o próprio ESP32 diz por que reiniciou. A mensagem Brownout detector was triggered no Monitor Serial significa uma queda de tensão, e as linhas rst:0xf (RTCWDT_BROWN_OUT_RESET) ou Guru Meditation Error na inicialização mostram o motivo do reset. O código abaixo lê a mesma informação com esp_reset_reason() e a transforma em um texto legível. No ESP32, o botão EN desliga e liga o chip por completo, então um reset por esse botão também aparece como ligação da alimentação. Para todas as mensagens e soluções, veja brownout e erros Guru Meditation no 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 do reset e watchdog (MicroPython)

Graças ao regulador buck-boost, o Raspberry Pi Pico funciona com qualquer tensão entre 1,8 e 5,5 V no pino VSYS, então tolera quedas de tensão melhor que um Arduino. Mesmo assim, se você ligar um servo no pino VBUS, que leva os 5 V do USB, a corrente é puxada direto da porta do computador e, se a porta cair, o Pico cai junto; você também não deve puxar mais de 300 mA no total do pino 3V3. O pino de reset do Pico, o RUN, é puxado para cima por um resistor interno de cerca de 50 kΩ; ligar um fio longo nele deixa uma porta aberta para o ruído, como o pino RESET do Arduino. No MicroPython, machine.reset_cause() retorna só dois valores no Pico: PWRON_RESET para ligação da alimentação ou o pino RUN, e WDT_RESET para o watchdog ou machine.reset(). O watchdog pode ser ajustado para no máximo 8388 ms e não pode ser parado depois de iniciado; ele continua reiniciando a placa mesmo que você pare o programa no Thonny. Por isso ponha uma espera de 3 segundos no início do 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)

A disposição de alimentação certa para o seu projeto

• Carrinho robô: alimente os motores com um pack 2S de 18650 por um L298N ou L9110S e ponha um capacitor de 100 nF sobre os terminais do motor; a montagem está em como fazer um carrinho robô com Arduino.
• Braço robótico com servos: para quatro ou mais servos, use uma fonte de 5–6 V que forneça pelo menos 3–5 A e acrescente 1000 µF à linha dos servos; para escolher as peças, veja servo MG996R e braço robótico com Arduino.
• Sistema de irrigação com bomba e relé: alimente a bomba por uma fonte separada, isole o relé com o JD-VCC e mantenha os fios longos dos sensores longe do cabo da bomba (sensor de umidade do solo).
• Fitas de LED e NeoPixels: reserve cerca de 2 A para cada 30 LEDs e ponha 1000 µF na entrada da fita e um resistor de 300–500 Ω na linha de dados (WS2812B NeoPixel).
• Acionando motores CC: não esqueça o diodo de roda livre em cada motor acionado por transistor ou MOSFET; para placas de driver prontas, veja controle de motor CC com o L298N.
• Estação de sensores em campo: ative o watchdog, defina um tempo limite para o I2C e tire a alimentação de uma fonte eficiente como o conversor abaixador LM2596.

Um Arduino que reinicia sozinho irrita, mas quase sempre há uma causa mensurável e corrigível: primeiro identifique o sintoma, depois meça a tensão e a RAM com o sketch de diagnóstico, então separe a alimentação, una os GNDs, acrescente o capacitor e o diodo e, se preciso, proteja o projeto com o watchdog. Com essa estrutura montada, os seus projetos com servo, motor e relé vão funcionar por dias sem problema. No app BlueGrays você encontra controle de servo motor, um carrinho Bluetooth com L298N, um robô que desvia de obstáculos, controle de lâmpada de 220 V e uma estação de irrigação inteligente, com esquemas de circuito que mostram as ligações de alimentação corretas e código passo a passo.