Meu Arduino queimou? Sintomas, diagnóstico e como recuperar a placa

“Meu Arduino queimou?” é uma pergunta que quase todo hobbista de eletrônica faz um dia: um fio encosta no lugar errado, um motor é ligado e a placa de repente fica muda. A boa notícia é que, na maioria desses casos, a placa não queimou inteira. Um Arduino Uno é formado por várias seções separadas: a conexão USB e o fusível dela, o regulador de tensão, o chip conversor USB-serial e o microcontrolador principal, o ATmega328P. Quando uma delas falha, as outras costumam sobreviver e, com o diagnóstico certo, salvar a placa às vezes é coisa de dois minutos.

Neste guia você vai aprender a interpretar os sintomas corretamente e a isolar a placa passo a passo para descobrir qual seção falhou. Vamos ver a alimentação pela entrada Vin, a verificação do polyfuse e do regulador com o multímetro, como achar um chip quente, o teste do chip USB com um teste de loopback e dois sketches do Arduino que testam os pinos um por um. Depois vamos gravar de novo um bootloader corrompido com um segundo Arduino, trocar o ATmega328P se for preciso e resumir as regras para você nunca mais queimar uma placa. O lado do software dos erros de carregamento está no post Arduino não carrega o código.

Seu Arduino queimou? Os primeiros sintomas e o que eles significam

Antes de começar o diagnóstico, preste atenção no que a placa está dizendo. O LED verde ON mostra se a linha de 5 V tem alimentação, o LED L (D13) mostra se o microcontrolador e o bootloader estão rodando, e os LEDs TX/RX mostram se o chip USB-serial está passando dados. A tabela abaixo resume os sintomas mais comuns e onde olhar primeiro.

Passo 1: primeira verificação com os olhos, o nariz e um cabo

1. Examine a placa sob uma boa luz: você procura um chip escurecido ou estufado, um encapsulamento rachado, solda derretida ou uma trilha carbonizada. Olhe principalmente em volta do regulador, do polyfuse e do chip USB.
2. Cheire a placa. Eletrônica queimada deixa um cheiro forte e conhecido, geralmente mais intenso perto da peça com defeito.
3. Confira a parte de baixo da placa. Uma mesa de metal, um pedaço de fio solto ou uma espuma condutiva podem ligar os pontos de solda da placa e causar um curto.
4. Teste outro cabo USB e outra porta USB. Alguns cabos baratos só têm os fios de alimentação e não transmitem dados; essa é a causa mais comum do que parece ser uma placa queimada.
5. Observe se o computador faz o som de conexão USB quando você liga a placa e se o LED ON acende; os próximos passos dependem dessas duas observações.

O caminho da alimentação no Arduino Uno: qual peça alimenta o quê?

A forma mais rápida de achar um defeito é conhecer o caminho que a corrente faz na placa. Os 5 V do USB passam primeiro por um polyfuse de 500 mA (um fusível rearmável), depois por um pequeno MOSFET de canal P, e chegam à linha de 5 V. A tensão do conector DC passa primeiro por um diodo que protege contra polaridade invertida, chega à linha VIN e é reduzida para 5 V pelo regulador NCP1117. Quando o VIN passa de cerca de 6,6 V, um comparador desliga o MOSFET do lado do USB, então as duas fontes nunca brigam entre si. Os 3,3 V são gerados a partir da linha de 5 V por um pequeno regulador LP2985. O LED ON, o chip USB-serial (um ATmega16U2 nas placas originais, normalmente um CH340 nos clones) e o ATmega328P são todos alimentados por essa linha de 5 V.

Passo 2: se o LED ON estiver apagado, teste com USB e com Vin

Alimente a placa uma vez pelo USB e outra por um adaptador de 9 V no conector DC (ou 7–12 V no pino Vin), e observe o LED ON em cada caso. Como a linha de 5 V é o ponto em comum dos dois caminhos, essa comparação simples já localiza bastante o defeito. Se o polyfuse desarmou por sobrecorrente, deixe a placa sem alimentação por alguns minutos para ele se recuperar sozinho; se o curto continuar, ele desarma de novo quando você religar. As opções de bateria e adaptador estão em detalhes no post como alimentar o Arduino com bateria.

Passo 3: verificando curto, polyfuse e regulador com o multímetro

1. Teste de curto (placa desligada): Coloque o multímetro em resistência ou continuidade e encoste as pontas de prova nos pinos 5V e GND. É normal a leitura começar baixa e subir conforme os capacitores carregam; um bipe contínuo ou um valor que fica abaixo de alguns ohms indica curto.
2. Teste do polyfuse (USB conectado): Na escala de tensão DC, coloque a ponta preta no GND e meça os dois lados do polyfuse, um de cada vez. Você deve ver cerca de 5 V nos dois lados; 5 V em um lado e quase zero no outro significa que o polyfuse está aberto.
3. Teste do regulador (9 V no conector DC): Você deve medir cerca de 8,3 V no pino de entrada do NCP1117 (o diodo derruba 0,7 V) e 5,0 V na saída.
4. Teste dos 3,3 V: Você deve medir 3,2–3,4 V entre o pino 3V3 e o GND.
5. Faça as medições nessa ordem; cada passo muda o significado do seguinte. Explicamos as escalas do multímetro e como medir com segurança no post como usar o multímetro.

Passo 4: encontrando o chip que esquenta

Se houver um curto na linha de 5 V, a peça em curto puxa a maior parte da corrente e esquenta em poucos segundos. Ligue a placa no USB, espere 3–5 segundos, desconecte e encoste rapidamente a ponta do dedo no ATmega328P, no chip USB e no regulador, um de cada vez. Se encontrar uma peça quente demais para tocar, o curto está nela. Se o ATmega328P está quente, normalmente algum pino dele recebeu uma tensão acima de 5 V; se o chip USB está quente, há um problema do lado do USB; se o regulador está quente, ou ele mesmo está com defeito, ou alguma carga na linha de 5 V está puxando corrente demais. Faça esse teste sem deixar a placa ligada por muito tempo, senão as peças boas também podem ser danificadas.

Passo 5: testando o chip USB quando a porta não aparece

Se o LED ON acende mas o computador não reconhece a placa, descarte primeiro o lado do software: instale o driver do chip CH340 nos clones e depois procure em “Portas (COM e LPT)” no Gerenciador de Dispositivos do Windows, ou pelos dispositivos /dev/cu.* ou /dev/ttyUSB* no macOS e no Linux. Se o dispositivo não aparece de jeito nenhum ou surge como dispositivo desconhecido, é hora de testar o próprio chip USB-serial. O teste de loopback tira o ATmega328P da jogada e faz o chip USB receber de volta os dados que ele mesmo envia; assim você descobre se o problema está no chip USB ou no microcontrolador.

1. Desligue a placa e ligue o pino RESET ao GND com um jumper. Isso mantém o ATmega328P em reset e libera as linhas TX/RX.
2. Ligue os pinos D0 (RX) e D1 (TX) entre si com um segundo jumper.
3. Conecte a placa no USB, selecione a porta no Arduino IDE e abra o Monitor Serial (o baud rate não importa).
4. Digite algo e clique em Enviar. Se o texto voltar exatamente igual e os LEDs TX/RX piscarem, o chip USB está bom; o problema está no ATmega328P ou no bootloader.
5. Se o texto não voltar e a porta também não aparecer, o chip USB ou o conector USB está danificado. Nesse caso, você ainda pode carregar código usando um conversor USB-TTL externo ou um programador ISP.

Passo 6: testando pinos queimados

Se a placa aceita o código mas o seu projeto se comporta de forma estranha, pode ser que um único pino tenha queimado. Ligar um motor, a bobina de um relé ou um LED sem resistor a um pino, colocar duas saídas em curto ou aplicar mais de 5 V em um pino pode matar só aquele pino, enquanto o resto do ATmega328P continua funcionando. O primeiro sketch abaixo configura todos os pinos como entrada com o pull-up interno: um pino bom deve ler HIGH quando está solto. Depois você liga uma ponta de um jumper ao GND e encosta a outra ponta nos pinos, um por vez; a cada toque, você deve ver aquele pino cair para LOW no Monitor Serial.

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}

Um pino que lê LOW quando está solto ou que não muda nada quando você encosta no GND é suspeito; o estágio de entrada dele entrou em curto internamente ou abriu. Em algumas placas clone, o LED L do D13 é ligado direto ao pino, então o D13 pode ler LOW quando está solto; isso não é defeito. O segundo sketch testa o estágio de saída dos pinos: todos os pinos vão para HIGH e LOW uma vez por segundo. Se você ligar o cátodo de um LED ao GND e o ânodo a uma ponta de um resistor de 220 Ω, e depois encostar a outra ponta do resistor nos pinos, um por vez, o LED vai piscar em cada pino bom; você encontra o valor certo do resistor com a calculadora Resistor para LED. Com o multímetro, você deve ver cerca de 5 V no estado HIGH; um pino que nunca acende o LED, acende fraco ou fica bem abaixo de 4 V está danificado.

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}

Nada mais deve estar ligado aos pinos enquanto esse sketch roda, porque todos os pinos são acionados como saída. Se quiser testar também as entradas analógicas, ligue o A0 ao GND, ao 3V3 e ao 5V, um de cada vez, e leia com analogRead(): você deve ver cerca de 0, 675 e 1023. A lista completa dos pinos e a função de cada um estão no post Pinagem do Arduino Uno, e as imagens das placas na ferramenta Pinagem.

Gravando o bootloader de novo: Arduino as ISP

Se a parte de alimentação está boa e o teste de loopback passa, mas o LED L não pisca ao resetar e todo carregamento dá o erro “avrdude: stk500_getsync(): not in sync”, o bootloader pode ter sido apagado ou corrompido. O bootloader é o pequeno programa que permite carregar código pelo USB, e ele pode ser regravado por ISP (programação no circuito). Você não precisa comprar um programador separado para isso; um segundo Arduino Uno em bom estado vira programador com o sketch de exemplo ArduinoISP. A ligação ISP usa os pinos SPI; você também pode usar a barra ICSP de 6 pinos da placa-alvo.

1. Conecte o Uno bom ao computador, abra Arquivo > Exemplos > 11.ArduinoISP > ArduinoISP e carregue nessa placa.
2. Desconecte do computador, ligue as duas placas conforme a tabela acima e coloque o capacitor de 10 µF entre os pinos RESET e GND do Uno programador.
3. Conecte o programador de novo no USB. No menu Ferramentas, escolha Arduino Uno como placa e a porta do programador como porta.
4. Em Ferramentas > Programador, escolha Arduino as ISP. A opção de nome parecido “ArduinoISP” é para um programador USB separado; não escolha essa.
5. Execute Ferramentas > Gravar Bootloader (Burn Bootloader). Leva alguns segundos e termina com a mensagem “Done burning bootloader”.
6. Retire os fios, conecte a placa-alvo pelo próprio USB e carregue o exemplo Blink. Se o LED L voltar a piscar rápido ao resetar, a placa foi salva.

Se o processo falhar, a mensagem de assinatura (signature) do avrdude diz muita coisa. “Device signature = 0x000000” ou “0xffffff” significa que o programador não consegue falar com o chip-alvo: confira a fiação, o capacitor de 10 µF e se o alvo está recebendo 5 V; se tudo isso estiver certo, o ATmega328P provavelmente morreu. Uma assinatura 1E 95 0F significa que o chip é um ATmega328P e a comunicação está funcionando. Se aparecer 1E 95 14, o seu chip é um ATmega328 sem o “P”; você precisa da definição de placa certa para esse chip.

Trocando o ATmega328P

No Arduino Uno R3 original e em muitos clones, o ATmega328P vem em encapsulamento DIP de 28 pinos encaixado em um soquete, então pode ser trocado sem solda. Se o microcontrolador esquenta, a assinatura não pode ser lida ou a maioria dos pinos morreu, essa é a solução mais econômica. Se o curto também some quando você retira o chip (o LED ON volta a acender e a placa fica fria), está confirmado que o defeito é no chip. Na hora de comprar um novo, escolher um ATmega328P-PU com o bootloader do Uno já gravado facilita a vida; se você comprou um chip virgem, pode gravar o bootloader você mesmo com o método Arduino as ISP acima. Em placas como o Nano e o Uno SMD, o chip é soldado na placa; trocá-lo exige uma estação de ar quente e experiência.

1. Desligue a placa e tire uma foto mostrando para que lado está o chanfro do chip (o lado do pino 1).
2. Encaixe uma chave de fenda pequena entre o chip e o soquete e levante o chip aos poucos, alternando entre as duas pontas; se forçar de um lado só, as pernas entortam.
3. As pernas de um chip novo geralmente vêm um pouco abertas para fora. Deite o chip de lado e pressione contra uma mesa plana para dobrar levemente as duas fileiras de pernas para dentro ao mesmo tempo.
4. Alinhe o chip com o soquete de modo que o chanfro fique virado para o mesmo lado do antigo, confira se todas as pernas estão nos furos e então pressione por igual.
5. Conecte a placa no USB, veja se o LED L pisca ao resetar e termine o teste carregando o exemplo Blink.

Notas rápidas para ESP32 e Raspberry Pi Pico

A mesma lógica vale para outras placas; só mudam as peças. As placas de desenvolvimento ESP32 têm um regulador tipo AMS1117 que reduz 5 V para 3,3 V e um chip USB CP2102 ou CH340; se o regulador esquentar, procure um curto na linha de 3,3 V. Os pinos do ESP32 não toleram 5 V, então o defeito mais comum é colocar 5 V em um pino. O erro “Failed to connect” durante o carregamento muitas vezes não é defeito, e sim um caso em que é preciso segurar o botão BOOT; os detalhes estão no post Arduino não carrega o código. No Raspberry Pi Pico, o teste mais rápido é conectá-lo ao USB segurando o botão BOOTSEL: se aparecer no computador uma unidade chamada RPI-RP2, o RP2040 e a conexão USB estão bons. Os pinos do Pico também não toleram 5 V, e você deve medir cerca de 3,3 V no pino 3V3(OUT).

10 regras para não queimar o seu Arduino

• 20 mA por pino: Puxe no máximo 20 mA de um pino; o limite absoluto é 40 mA, e a soma de todos os pinos não deve passar de 200 mA.
• Sempre um resistor com o LED: Ligar um LED sem resistor força tanto o pino quanto o LED; em 5 V, 220–330 Ω é suficiente.
• Nunca coloque mais de 5 V em um pino: A tensão em um pino de entrada não pode passar mais de 0,5 V acima da alimentação; um sinal de 12 V mata o pino na hora.
• Motores, relés e bombas não vão direto no pino: Use um transistor ou MOSFET e um diodo de roda livre; você encontra um circuito de exemplo no guia da mini bomba d'água.
• 7–12 V no Vin: Essa é a faixa recomendada; acima de 12 V o regulador esquenta, acima de 20 V você passa do limite.
• Nunca inverta a alimentação no pino Vin: O diodo de proteção do conector DC não protege a alimentação aplicada no pino Vin; trocar o positivo pelo negativo queima a placa.
• Não puxe mais de 50 mA do pino 3V3: Para cargas como um módulo Wi-Fi ou um display grande, use um regulador de 3,3 V separado.
• Desligue a alimentação ao mexer na fiação: Ligar e desligar fios com o circuito energizado é a causa mais comum de curtos rápidos.
• Não coloque a placa sobre superfície de metal: Os pontos de solda de baixo entram em curto quando encostam em uma mesa de metal, uma ferramenta ou um fio solto; use pezinhos de plástico ou uma caixa.
• GND comum e alimentação separada: Junte os GNDs das cargas alimentadas por uma fonte externa, mas não faça correntes altas passarem pela placa.

Antes de declarar que o seu Arduino morreu, descobrir qual seção ficou muda muitas vezes salva a placa: o LED ON verifica o caminho da alimentação, o teste de loopback o chip USB, o LED L no reset o bootloader, e os sketches de teste cada perna do ATmega328P, uma por uma. O bootloader pode ser regravado, um chip em soquete pode ser trocado em poucos minutos e, com as regras acima, a sua próxima placa vai durar muito. Para ver sua placa funcionando bem de novo, experimente os projetos LED piscante, Semáforo, Controle de LED com botão e Voltímetro digital com display LCD no app BlueGrays, com esquemas do circuito e código passo a passo.