⚙️ Motors and power

Almost every movement in a benchtop robot comes from one of three motor types. A DC motor spins continuously while it receives power: it’s the rover’s wheel. A servo goes to an angle and stays there: it’s the “neck” that turns the sensor. The stepper motor moves in small, precise steps: it’s the axis of a 3D printer. The right question isn’t “which is better?” but “what movement does the task require?”

How to read this map: the DC motor’s solid arrow indicates free rotation; the servo’s dashed arc shows that it only moves within a range (0° to 180°); the stepper motor’s little marks are the fixed positions where it stops. The two green cards spin without limit; the cyan one works by position.

Why learn this

The wrong motor leaves the robot weak, slow, or imprecise, and no code can fix that. Choosing based on the type of movement also determines the rest: which driver to buy, how much current the battery needs to deliver, and how many ESP32 pins you’ll use.

Key concepts

An ESP32 pin supplies only a few milliamps at 3.3 V; a TT motor draws hundreds of milliamps and over 1 A at startup. Connecting the motor directly to the pin will burn it out. Between them, you need a motor driver: the ESP32 sends only the signal, and the driver opens the path for current from the battery.

How to read this map: follow the green arrow: it enters through S1, passes through the motor from left to right, and exits through S4. The dashed cyan arrow follows the mirrored path (S2, motor in the opposite direction, S3). Closing S1 and S3 together would connect the battery directly to GND, causing a short circuit; the driver chip is there specifically to ensure the IN1/IN2 pins never allow that.

Why learn this

The driver is the bridge between the code and the power. Understanding its pins (power, logic, direction, speed, on/off) means the rover wiring in 1.6 is no longer a memorized recipe: you know why each wire is there and can switch drivers with confidence.

Key concepts

Direction comes from the IN1/IN2 pins. Speed comes from PWM, which you already used in module 1.3 to control the LED brightness: the driver switches battery power to the motor on and off thousands of times per second, and the motor responds to the average. The greater the fraction of each cycle that’s “on,” the duty cycle, the faster it spins.

How to read this map: all three waves have the same height (the battery voltage) and the same rhythm; only the width of the high section changes. At 25%, the TT motor usually just buzzes: the average force isn’t enough to overcome the gearbox friction. This useless range is the dead zone, and the code below skips over it.

Goal: create the rover’s “verbs” (forward, reverse, turn, stop, and ramp) with a TB6612FNG and see each one in the Serial Monitor. The pins are the same as in project 1.6: left motor on PWMA 25, AIN1 26, AIN2 27; right motor on PWMB 33, BIN1 32, BIN2 4; STBY on 13.

// Motor test with TB6612FNG (ESP32, esp32 core 3.x)
// Forward, reverse, turn, and stop, with acceleration ramp.
// The first time, keep the robot SUSPENDED (wheels off the ground).

const int PINO_PWMA = 25, PINO_AIN1 = 26, PINO_AIN2 = 27;  // left motor
const int PINO_PWMB = 33, PINO_BIN1 = 32, PINO_BIN2 = 4;   // right motor
const int PINO_STBY = 13;
const int PWM_FREQ = 20000;  // 20 kHz: outside the range of human hearing
const int PWM_BITS = 8;      // speed from 0 to 255
const int VEL_MIN  = 90;     // below this, the TT motor hums but doesn't turn
// speed from -255 (reverse) to 255 (forward); 0 = stopped
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;  // skips the dead zone
  digitalWrite(in1, vel > 0 ? HIGH : LOW);
  digitalWrite(in2, vel < 0 ? HIGH : LOW);
  ledcWrite(pinoPwm, forca);                  // API 3.x: receives the PIN
}
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); }  // wheels in opposite directions
void parar()            { andar(0, 0); }
// increases (or decreases) speed in steps of 5: no sudden jolts
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);   // channel selected automatically
  ledcAttach(PINO_PWMB, PWM_FREQ, PWM_BITS);
  digitalWrite(PINO_STBY, HIGH);               // takes the driver out of standby
  parar();
  Serial.println("Motor test: forward, reverse, turn, stop");
  delay(2000);
}
void loop() {
  Serial.println("ramp to forward 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("turn right"); girarDireita(160); delay(700);
  Serial.println("parar");                parar();           delay(2000);
}

Why learn this

Forward, reverse, turn, and stop are the verbs the rover’s state machine will use. Writing them once as small functions keeps the project code short and readable: “if the wall is close, parar(), then re()".

Key concepts

The servo has three wires: brown (GND), red (5 V), and orange (signal). It doesn’t read the duty cycle like a DC motor; it reads the pulse width. A pulse arrives every 20 ms (50 times per second), and its duration determines the angle. The ESP32Servo library calculates these pulses for you. The Servo.h from Arduino Uno doesn’t work on the ESP32.

How to read this map: each pulse color on the left corresponds to the arm of the same color on the right. A short pulse (green) moves the arm to one end, a medium pulse (cyan) to the center, and a long pulse (amber) to the other end. The space after the pulse completes the 20 ms. Your servo may use a slightly different range; the values 500 and 2400 in the code adjust it.

Step by step

Goal: make the servo “look” forward, to the right, forward again, and to the left, as the rover’s neck will do in 1.6.

// SG90 servo on the ESP32 with the ESP32Servo library (esp32 core 3.x)
#include <ESP32Servo.h>

const int PINO_SERVO = 23;  // orange wire (signal)
Servo cabeca;   // the servo that turns the rover's sensor

void setup() {
  Serial.begin(115200);
  cabeca.setPeriodHertz(50);             // one pulse every 20 ms
  cabeca.attach(PINO_SERVO, 500, 2400);  // 0.5 ms = 0 degrees ... 2.4 ms = 180 degrees
  cabeca.write(90);                      // starts facing forward
  Serial.println("Servo ready on GPIO 23");
  delay(1000);
}

void loop() {
  int angulos[] = {90, 20, 90, 160};    // forward, right, forward, left
  for (int i = 0; i < 4; i++) {
    cabeca.write(angulos[i]);
    Serial.printf("angle: %d\n", angulos[i]);
    delay(800);                          // time for the servo to reach its position
  }
}

Why learn this

With the distance sensor mounted on the servo, the rover looks to both sides before deciding which way to turn, instead of always turning the same way. It’s the same “pointing” technique you’ll use with the gripper, the camera that follows an object, and the arm in Track 5.

Key concepts

A robot battery needs two things: the voltage right one for the motors and current enough for startup. This is where the square 9 V battery fails: the voltage looks good, but it delivers too little current, drops on the first acceleration, and the ESP32 restarts. For Track 1, the safe choice is 4 rechargeable AA batteries (NiMH) or 2 18650 cells with a protection board.

How to read this map: The longer the bar, the more current the battery delivers without the voltage plummeting. The tiny red bar explains why the 9 V battery makes the robot restart. The LiPo has the longest bar, which is exactly why it is the most dangerous: in a short circuit, it turns all that current into heat.

Why learn this

The wrong power supply is the number one cause of a robot that “restarts by itself,” and lithium batteries are the biggest real hazard on the workbench. Knowing how to read voltage, capacity, and protection helps your rover run longer and keeps the classroom (and your home) safer.

Key concepts

The battery provides 7,4 V; the ESP32, sensor, and servo need 5 V. The conversion is done by a buck regulator, a small board that lowers the voltage while wasting little energy as heat. The wiring has two branches: the battery connects directly to VM on the driver (motor power) and, through the buck, to the electronics' 5 V supply. All the negative terminals meet at a single point: the Common GND.

How to read this map: The amber path is the battery voltage, which only goes to the driver and the buck. Green is the clean 5 V supply for the electronics. The dashed cyan line is the 3,3 V that the ESP32 sends to the driver's logic. The dotted gray lines are the GND connections: they all end at the same circle. If one is missing, the signals lose their reference and the robot behaves unpredictably.

Goal: find out why the ESP32 restarted. Run the sketch by itself to see the “normal” reason. Then copy the function reason() and the lines from setup() to the start of the motor test in topic 3: each time the board restarts, the first line in the Serial Monitor tells you why.

// Why did the ESP32 restart? (esp32 3.x package)
#include "esp_system.h"

const char* motivo(esp_reset_reason_t r) {
  switch (r) {
    case ESP_RST_POWERON:  return "power was turned on or EN was pressed (normal)";
    case ESP_RST_SW:       return "reset requested by the program";
    case ESP_RST_PANIC:    return "program error (panic)";
    case ESP_RST_BROWNOUT: return "BROWNOUT: voltage dropped (motor, weak battery, wire)";
    default:               return "other reason";
  }
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.print("Last restart: ");
  Serial.println(motivo(esp_reset_reason()));
}

void loop() {}

Why learn this

Without a regulator, capacitors, and common GND, motor noise restarts the ESP32 exactly when it most needs to work: while braking and turning in front of the wall. This fault looks like a “code bug” and makes many people give up; now you know to check the power supply first.

Key concepts