⚙️ Motores e energia

Quase todo movimento de robô de bancada sai de três tipos de motor. O motor DC gira sem parar enquanto recebe energia: é a roda do rover. O servo vai até um ângulo e fica lá: é o "pescoço" que vira o sensor. O motor de passo anda em passos pequenos e exatos: é o eixo da impressora 3D. A pergunta certa não é "qual é melhor", e sim "que movimento a tarefa pede".

Como ler: a seta contínua do motor DC indica giro livre; o arco tracejado do servo mostra que ele só se move dentro de uma faixa (0° a 180°); os tracinhos do motor de passo são as posições fixas em que ele para. Os dois cartões verdes giram sem limite; o ciano trabalha por posição.

Por que aprender

Motor errado deixa o robô fraco, lento ou impreciso, e nenhum código corrige isso. Escolher pelo tipo de movimento também decide o resto: que driver comprar, quanta corrente a bateria precisa entregar e quantos pinos do ESP32 vão ser usados.

Conceitos-chave

Um pino do ESP32 entrega poucos miliampères a 3,3 V; um motor TT puxa centenas de miliampères e mais de 1 A no arranque. Ligar o motor direto no pino queima o pino. Entre os dois vai um driver de motor: o ESP32 manda só o sinal, e o driver abre o caminho da corrente que vem da bateria.

Como ler: siga a seta verde: entra pela S1, atravessa o motor da esquerda para a direita e sai pela S4. A seta ciano tracejada faz o caminho espelhado (S2, motor ao contrário, S3). Fechar S1 e S3 juntas ligaria a bateria direto ao GND, um curto; o chip do driver existe justamente para que os pinos IN1/IN2 nunca permitam isso.

Por que aprender

O driver é a ponte entre o código e a força. Entender os pinos dele (força, lógica, sentido, velocidade, liga/desliga) faz a fiação do rover da 1.6 deixar de ser receita decorada: você sabe por que cada fio está ali e consegue trocar de driver sem medo.

Conceitos-chave

O sentido vem dos pinos IN1/IN2. A velocidade vem do PWM, que você já usou no módulo 1.3 para o brilho do LED: o driver liga e desliga a bateria no motor milhares de vezes por segundo, e o motor responde à média. Quanto maior a fração "ligada" de cada ciclo, o duty cycle, mais rápido ele gira.

Como ler: as três ondas têm a mesma altura (a tensão da bateria) e o mesmo ritmo; o que muda é a largura do trecho alto. Com 25% o motor TT costuma só zumbir: a força média não vence o atrito da caixa de redução. Essa faixa inútil é a zona morta, e o código abaixo pula por cima dela.

Objetivo: criar os "verbos" do rover (frente, ré, girar, parar e rampa) com um TB6612FNG e ver cada um no Serial Monitor. Os pinos são os mesmos do projeto 1.6: motor esquerdo em PWMA 25, AIN1 26, AIN2 27; direito em PWMB 33, BIN1 32, BIN2 4; STBY no 13.

// Teste dos motores com TB6612FNG (ESP32, pacote esp32 3.x)
// Frente, re, giro e parada, com rampa de aceleracao.
// Na primeira vez, deixe o robo SUSPENSO (rodas no ar).

const int PINO_PWMA = 25, PINO_AIN1 = 26, PINO_AIN2 = 27;  // motor esquerdo
const int PINO_PWMB = 33, PINO_BIN1 = 32, PINO_BIN2 = 4;   // motor direito
const int PINO_STBY = 13;
const int PWM_FREQ = 20000;  // 20 kHz: fora da faixa que o ouvido escuta
const int PWM_BITS = 8;      // velocidade de 0 a 255
const int VEL_MIN  = 90;     // abaixo disso o motor TT zumbe e nao gira
// vel de -255 (re) a 255 (frente); 0 = parado
void motor(int in1, int in2, int pinoPwm, int vel) {
  vel = constrain(vel, -255, 255);
  int forca = abs(vel);
  if (forca > 0 && forca < VEL_MIN) forca = VEL_MIN;  // pula a zona morta
  digitalWrite(in1, vel > 0 ? HIGH : LOW);
  digitalWrite(in2, vel < 0 ? HIGH : LOW);
  ledcWrite(pinoPwm, forca);                  // API 3.x: recebe o PINO
}
void andar(int esq, int dir) {
  motor(PINO_AIN1, PINO_AIN2, PINO_PWMA, esq);
  motor(PINO_BIN1, PINO_BIN2, PINO_PWMB, dir);
}
void frente(int v)       { andar(v, v); }
void re(int v)           { andar(-v, -v); }
void girarDireita(int v) { andar(v, -v); }  // rodas em sentidos opostos
void parar()            { andar(0, 0); }
// sobe (ou desce) a velocidade de 5 em 5: sem tranco
void rampa(int de, int ate, int passoMs) {
  int passo = (ate > de) ? 5 : -5;
  for (int v = de; (passo > 0) ? (v < ate) : (v > ate); v += passo) { frente(v); delay(passoMs); }
  frente(ate);
}
void setup() {
  Serial.begin(115200);
  pinMode(PINO_AIN1, OUTPUT); pinMode(PINO_AIN2, OUTPUT);
  pinMode(PINO_BIN1, OUTPUT); pinMode(PINO_BIN2, OUTPUT);
  pinMode(PINO_STBY, OUTPUT);
  ledcAttach(PINO_PWMA, PWM_FREQ, PWM_BITS);   // canal escolhido sozinho
  ledcAttach(PINO_PWMB, PWM_FREQ, PWM_BITS);
  digitalWrite(PINO_STBY, HIGH);               // tira o driver da espera
  parar();
  Serial.println("Teste de motores: frente, re, giro, parar");
  delay(2000);
}
void loop() {
  Serial.println("rampa ate frente 200"); rampa(0, 200, 20); delay(1000);
  Serial.println("parar");                parar();           delay(800);
  Serial.println("re 160");               re(160);           delay(1000);
  Serial.println("parar");                parar();           delay(800);
  Serial.println("girar para a direita"); girarDireita(160); delay(700);
  Serial.println("parar");                parar();           delay(2000);
}

Por que aprender

Frente, ré, girar e parar são os verbos que a máquina de estados do rover vai usar. Escrevendo-os uma vez, em funções pequenas, o código do projeto fica curto e legível: "se a parede está perto, parar(), depois re()".

Conceitos-chave

O servo tem três fios: marrom (GND), vermelho (5 V) e laranja (sinal). Ele não lê o duty cycle como o motor DC; ele lê a largura do pulso. A cada 20 ms (50 vezes por segundo) chega um pulso, e a duração dele diz o ângulo. A biblioteca ESP32Servo calcula esses pulsos para você. A Servo.h do Arduino Uno não funciona no ESP32.

Como ler: cada cor de pulso, à esquerda, corresponde ao braço da mesma cor, à direita. Pulso curto (verde) põe o braço num extremo, pulso médio (ciano) no centro, pulso longo (âmbar) no outro extremo. O espaço depois do pulso completa os 20 ms. Seu servo pode usar uma faixa um pouco diferente; os números 500 e 2400 do código ajustam isso.

Passo a passo

Objetivo: fazer o servo "olhar" para a frente, para a direita, de novo para a frente e para a esquerda, como o pescoço do rover vai fazer na 1.6.

// Servo SG90 no ESP32 com a biblioteca ESP32Servo (pacote esp32 3.x)
#include <ESP32Servo.h>

const int PINO_SERVO = 23;  // fio laranja (sinal)
Servo cabeca;   // o servo que gira o sensor do rover

void setup() {
  Serial.begin(115200);
  cabeca.setPeriodHertz(50);             // um pulso a cada 20 ms
  cabeca.attach(PINO_SERVO, 500, 2400);  // 0,5 ms = 0 graus ... 2,4 ms = 180 graus
  cabeca.write(90);                      // comeca olhando para a frente
  Serial.println("Servo pronto no GPIO 23");
  delay(1000);
}

void loop() {
  int angulos[] = {90, 20, 90, 160};    // frente, direita, frente, esquerda
  for (int i = 0; i < 4; i++) {
    cabeca.write(angulos[i]);
    Serial.printf("angulo: %d\n", angulos[i]);
    delay(800);                          // tempo para o servo chegar
  }
}

Por que aprender

Com o sensor de distância em cima do servo, o rover olha para os dois lados antes de decidir para onde virar, em vez de virar sempre para o mesmo lado. É a mesma técnica de "apontar" que você vai usar na garra, na câmera que segue um objeto e no braço da Trilha 5.

Conceitos-chave

Uma bateria de robô precisa de duas coisas: a tensão certa para os motores e corrente de sobra para o arranque. É aqui que a bateria 9 V quadrada falha: a tensão parece boa, mas ela entrega pouca corrente, cai na primeira acelerada e o ESP32 reinicia. Para a Trilha 1, a escolha segura é 4 pilhas AA recarregáveis (NiMH) ou 2 células 18650 com placa de proteção.

Como ler: quanto mais longa a barra, mais corrente a bateria entrega sem a tensão despencar. A barra vermelha minúscula explica por que a 9 V reinicia o robô. A LiPo tem a barra mais longa, e por isso mesmo é a mais perigosa: num curto ela entrega essa corrente toda em calor.

Por que aprender

Energia errada é a causa número um de robô que "reinicia sozinho", e a bateria de lítio é o maior risco real da bancada. Saber ler tensão, capacidade e proteção faz o rover andar mais tempo e deixa a sala (e a sua casa) mais segura.

Conceitos-chave

A bateria tem 7,4 V; o ESP32, o sensor e o servo querem 5 V. Quem faz essa conversão é um regulador buck, uma plaquinha que baixa a tensão perdendo pouca energia em calor. A ligação fica em dois ramos: a bateria vai direto ao VM do driver (força dos motores) e, pelo buck, ao 5 V da eletrônica. E todos os negativos se encontram num ponto só: o GND comum.

Como ler: o caminho âmbar é a tensão da bateria, que só vai ao driver e ao buck. O verde é o 5 V limpo da eletrônica. O ciano tracejado é o 3,3 V que o ESP32 manda para a lógica do driver. As linhas cinza pontilhadas são os GND: todas terminam no mesmo círculo. Se faltar uma, os sinais perdem a referência e o robô se comporta de forma aleatória.

Objetivo: descobrir por que o ESP32 reiniciou. Rode o sketch sozinho para ver o motivo "normal". Depois copie a função motivo() e as linhas do setup() para o início do teste de motores do tópico 3: a cada reinício, a primeira linha do Serial Monitor diz a causa.

// Por que o ESP32 reiniciou? (pacote esp32 3.x)
#include "esp_system.h"

const char* motivo(esp_reset_reason_t r) {
  switch (r) {
    case ESP_RST_POWERON:  return "ligou a energia ou apertou EN (normal)";
    case ESP_RST_SW:       return "reset pedido pelo programa";
    case ESP_RST_PANIC:    return "erro no programa (panic)";
    case ESP_RST_BROWNOUT: return "BROWNOUT: a tensao caiu (motor, bateria fraca, fio)";
    default:               return "outro motivo";
  }
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.print("Ultimo reinicio: ");
  Serial.println(motivo(esp_reset_reason()));
}

void loop() {}

Por que aprender

Sem regulador, capacitores e GND comum, o ruído do motor reinicia o ESP32 justamente quando ele mais precisa funcionar: na hora de frear e virar diante da parede. Esse defeito parece "bug de código" e faz muita gente desistir; agora você sabe procurar na energia primeiro.

Conceitos-chave