Desligar o Arduino com motor e relé: a ordem que protege a placa e a porta USB

O teste acabou, você puxa o cabo USB com o motor ainda girando e o relé armado. O notebook faz o som de dispositivo desconectado, e a porta USB não reconhece mais nada até você reiniciar. Na semana seguinte, a mesma placa começa a travar sem motivo. Desligar também é parte do circuito: a carga energizada sem a lógica ligada procura caminho pelos pinos do Arduino.

A resposta curta, em quatro passos: pare os atuadores pelo código e confirme, corte a fonte da carga (motor, relé, fita de LED), espere os indicadores do driver apagarem e só então tire o USB. Para ligar, a ordem se inverte: primeiro a placa, depois a carga.

Por que a ordem de desligar importa

Num projeto com motor ou relé existem duas alimentações: a da lógica (USB ou o conector do Arduino) e a da carga (pilhas, bateria, fonte de 12 V). Elas se encontram no terra comum e nos fios de sinal entre o Arduino e o driver. Enquanto as duas estão ligadas, tudo tem referência. Quando uma sai antes da outra, aparecem caminhos que ninguém desenhou.

• Carga ligada, lógica desligada: um módulo alimentado por fora continua com tensão nos fios de sinal. Ela entra nos pinos do microcontrolador sem energia e passa pelos diodos de proteção internos, tentando alimentar a placa por um lugar que não foi feito para isso. A placa fica num meio-termo, com LED fraco aceso, e os pinos sofrem.
• Motor girando quando a energia some: o motor, ainda em movimento, vira gerador. Essa tensão volta pelo driver para a alimentação.
• Bobina cortada de repente: relé e motor guardam energia no campo magnético e devolvem um pico de tensão quando a corrente é interrompida. Módulos prontos costumam ter diodo para isso; fio solto, não.
• Terra arrancado primeiro: se o fio de GND entre placa e driver sai antes dos fios de sinal, a corrente de retorno passa pelos pinos de sinal.
• Porta USB com proteção: muitos computadores desligam a porta quando detectam sobrecorrente ou picos. Ela pode só voltar depois de replugar ou reiniciar.

Nenhum desses efeitos costuma queimar a placa na primeira vez. Eles somam desgaste, e o defeito aparece semanas depois, quando ninguém lembra do cabo puxado.

O sketch com estado seguro e botão de estacionar

O exemplo que vai atravessar o texto: um Uno que controla uma bomba d'água pequena por um driver L298N (fonte de 12 V separada) e uma lâmpada de bancada por um módulo de relé ativo em nível baixo. O código tem duas ideias: um estado seguro definido no começo do setup() e um comando de "estacionar" que deixa tudo parado antes de você desligar.

const int PINO_IN1 = 8;
const int PINO_IN2 = 7;
const int PINO_ENA = 9;          // PWM da bomba
const int PINO_RELE = 4;         // módulo de relé ativo em LOW
const int PINO_BOTAO_PARAR = 2;  // botão para o GND
const int PINO_LED_SEGURO = 13;

int velocidadeAtual = 0;
bool estacionado = false;

void estadoSeguro() {
  analogWrite(PINO_ENA, 0);
  digitalWrite(PINO_IN1, LOW);
  digitalWrite(PINO_IN2, LOW);
  digitalWrite(PINO_RELE, HIGH);   // HIGH desliga num módulo ativo em LOW
  velocidadeAtual = 0;
}

void trabalhar() {
  digitalWrite(PINO_IN1, HIGH);
  digitalWrite(PINO_IN2, LOW);
  velocidadeAtual = 180;
  analogWrite(PINO_ENA, velocidadeAtual);
  digitalWrite(PINO_RELE, LOW);    // acende a lâmpada
}

void estacionar() {
  for (int v = velocidadeAtual; v > 0; v -= 5) {
    analogWrite(PINO_ENA, v);
    delay(20);
  }
  estadoSeguro();
  estacionado = true;
  digitalWrite(PINO_LED_SEGURO, HIGH);
  Serial.println("ESTACIONADO: desligue a fonte da carga e depois o USB.");
}

void setup() {
  // No Uno, escrever HIGH antes de virar saída evita o estalo do relé ao ligar.
  digitalWrite(PINO_RELE, HIGH);
  pinMode(PINO_RELE, OUTPUT);
  pinMode(PINO_IN1, OUTPUT);
  pinMode(PINO_IN2, OUTPUT);
  pinMode(PINO_ENA, OUTPUT);
  pinMode(PINO_LED_SEGURO, OUTPUT);
  pinMode(PINO_BOTAO_PARAR, INPUT_PULLUP);
  estadoSeguro();
  Serial.begin(9600);
}

void loop() {
  if (estacionado) {
    return;   // só volta a trabalhar depois de um reset
  }

  trabalhar();

  if (digitalRead(PINO_BOTAO_PARAR) == LOW) {
    estacionar();
  } else if (Serial.available() > 0 && Serial.read() == 'D') {
    estacionar();
  }
}

A desaceleração em rampa evita que a bomba seja cortada em plena rotação e devolva energia ao driver. O LED do pino 13 aceso é o sinal visual de que já pode desligar a fonte. O detalhe do digitalWrite antes do pinMode vale para placas AVR como o Uno: o nível fica definido antes de o pino virar saída, e o relé ativo em LOW não pisca no boot. Se o botão ficar repetindo, veja botão no Arduino sem repetir; aqui, como o estado só muda uma vez, a repetição não atrapalha.

A ordem para desligar e para ligar

Desligar

1. Estacione pelo código: aperte o botão ou mande D pela serial. Espere o LED de estado seguro.
2. Corte a fonte da carga: chave da bateria ou plugue da fonte de 12 V.
3. Espere os indicadores apagarem. O LED do driver some devagar porque os capacitores da placa ainda estão carregados. Quando apagar, eles descarregaram.
4. Tire o USB ou desligue a alimentação da placa.
5. Só agora mexa em fios. Se precisar desconectar o driver, tire os fios de sinal antes do GND, nunca o contrário.

Ligar

1. Ligue a placa primeiro. O setup() coloca os pinos em estado seguro.
2. Depois ligue a fonte da carga. Os sinais já estão definidos e nada dispara sozinho.

Escreva esses passos numa etiqueta colada na bancada. É a versão de hardware do desligamento gracioso de um serviço, aquele em que o processo termina o que está fazendo antes de sair, como em SIGTERM termina o pedido.

Duas fontes ligadas ao mesmo tempo

O Uno R3 tem um circuito que escolhe automaticamente entre o USB e o conector de alimentação externa, então ter os dois conectados não é problema em si. O problema aparece quando a fonte externa entra direto no pino 5V: ela não passa por esse circuito de escolha, e com o USB conectado as duas fontes podem ficar em paralelo, com corrente voltando para o computador. Se o projeto usa uma fonte de 5 V externa no pino 5V, desconecte-a antes de plugar o USB para gravar. A explicação completa de cada entrada de alimentação está em como alimentar o Arduino.

Se o relé comanda uma carga de rede elétrica, 127 ou 220 V, a regra fica mais rígida: tire a carga da tomada ou desligue o disjuntor antes de tocar em qualquer fio do lado do relé, mesmo com o Arduino desligado. O contato do relé pode estar fechado, e o borne continua energizado. Instalação na rede elétrica não substitui um eletricista habilitado. Veja também como o relé separa o Arduino da rede.

Erros comuns

• Puxar o USB com o motor girando: a lógica some, a carga continua, e a corrente passa pelos pinos.
• Não ter estado seguro no setup(): ao ligar, o motor dá um tranco ou o relé fecha por um instante.
• Ligar a fonte da carga antes da placa: com os pinos ainda indefinidos, o driver pode acionar a carga sozinho.
• Arrancar o fio de GND primeiro: o retorno da corrente procura caminho pelos fios de sinal.
• Fonte externa no pino 5V com o USB conectado: duas fontes em paralelo, e a porta do computador pode receber corrente de volta.
• Mexer no relé de rede com a carga na tomada: risco de choque, mesmo com o Arduino desligado.

Checklist

• O setup() coloca todos os atuadores em estado seguro antes de qualquer outra coisa.
• Existe um botão ou comando que estaciona o sistema e acende um indicador.
• A ordem de desligar está escrita na bancada.
• A fonte da carga tem uma chave fácil de alcançar.
• Você espera o LED do driver apagar antes de tirar o USB.
• Para ligar, a placa vem primeiro e a carga depois.
• Nenhuma fonte externa fica no pino 5V enquanto o USB está conectado.

Olhe para a sua bancada agora. Se você precisasse desligar tudo neste minuto, qual cabo sairia primeiro? Se a resposta for "o USB", escreva a ordem de três passos antes do próximo teste.