🦾 What a robot is and what’s in its kit

A robot is a machine that perceives its surroundings, decides what to do, and acts on the world, on its own and in a loop. It measures something (the distance to a wall), compares it with a goal (not to crash), and moves something (turns its wheels). Then it measures again, because the world has changed. This cycle repeats dozens or hundreds of times per second.

How to read this map: follow the green arrows from left to right (measure → decide → move), then follow the cyan arrow back. That return loop is what separates a robot from a remote-controlled toy: it checks the result of its own action.

Why learn this

Every project in this course, from the cardboard rover to the AI arm, uses the same cycle with different parts. When something doesn’t work, you’ll ask, “Is the problem with sensing, thinking, or acting?” and narrow down the fault before opening the code.

Key concepts

Most robots working today are unassuming: arms that weld cars, carts that carry boxes in warehouses, and vacuums that map rooms. What’s new in recent years is that affordable open-source arms, like the SO-101, and AI models that learn by demonstration have moved out of the lab and become accessible to people with a 3D printer. Humanoids show up a lot in videos, but they’re still expensive and work in controlled pilot programs.

How to read this map: the green dots are already at work every day in factories and homes. The cyan dots show where researchers and makers are working now. The humanoid’s dashed outline indicates that you’re more likely to see it in a demonstration than doing routine work.

Why learn this

Knowing where robotics really stands helps you choose projects that work and avoid spending money on promises. The same building blocks you’ll put together (distance sensor, motor with encoder, camera with object detector, map) are inside the vacuum and warehouse robot.

Key concepts

The course has six tracks. The first five build on each other, each ending with a working robot; the sixth is for people who will teach. There’s no set number of hours or required order: start with the track that solves your problem today, and return to the fundamentals whenever you need a part you haven’t learned about yet.

How to read this map: the gray arrows show the natural sequence from T1 to T5, from LED to AI-powered robot. The dashed cyan arrows show entry points for different backgrounds: if you already know Arduino, you can start at T2 or T3; if you’re going to teach, go straight to T6, which is outside the sequence.

How to study a module (a routine that works)

Why learn this

People who try to learn robotics “from beginning to end” often get stuck in theory before they see anything move. Learning on demand turns that around: you start with the robot you want to build and learn only the electronics, code, and AI it requires.

Key concepts

A robot’s “brain” can be one of two types. A microcontroller, such as the ESP32, is a small chip that runs a single program as soon as it gets power: it starts up in less than a second, uses little battery power, and responds to sensors at the right time. A single-board computer, such as the Raspberry Pi 5, runs a full operating system (Linux), with a camera, network, Python, and AI, but takes longer to start and uses more power.

How to read this map: Start at the top and follow the question that describes your robot. The cyan line below reminds you that this isn’t an either-or choice: in robots on Learning Paths 3 to 5, the Raspberry Pi (or Jetson) does the thinking, while an ESP32 continues to handle the motors and emergency stop.

Why learn this

Choosing the wrong board can be costly: a Raspberry Pi used to blink an LED wastes battery; an ESP32 alone can’t run a modern object detector. Follow the rule “the computer thinks, the microcontroller controls” to build robots that can grow without rebuilding everything.

Key concepts

The robot in Learning Path 1 is a two-wheel rover that moves on its own and avoids obstacles. It uses just a few parts, all easy to find in Brazil, and each one corresponds to a part of the sense-think-act cycle. Buy them gradually: modules 1.1 to 1.3 work with just the simulator, or with the ESP32 and a few LEDs.

How to read this map: The front of the robot is at the top of the figure. Cyan = sense (ultrasonic and infrared), green = think and command (ESP32 and driver), gray = act (motors and wheels), amber = power. Every part you buy falls into one of these four colors.

* Reference prices in Oct/2026, totaling R$ 200 to R$ 400 for the complete kit. Check before buying: prices vary widely by store, shipping, and exchange rate.

Why learn this

Knowing what each part is for avoids two frustrations: spending money on components you won't use and building a robot that won't move because the power supply or driver can't handle the motors. The kit above covers all of Track 1 and much of Track 2.

Key concepts

O Wokwi (wokwi.com) is a free browser-based simulator: you build a virtual ESP32, connect LEDs, sensors, and servos, paste in the code, and press play. It runs the same program that would run on the real board. It's the fastest way to make your first "blinking LED" today, before your kit arrives.

How to read this map: follow the green wire from GPIO 2 to the resistor (amber zigzag) and the LED (red triangle, with its point facing the short leg). The cyan wire completes the circuit at GND. Without a return path, nothing lights up.

Step by step in Wokwi

Goal: make the LED blink once per second and count the blinks in the Serial Monitor. It works the same in Wokwi and on a real ESP32 (the "esp32" 3.x package in Arduino IDE 2.x).

// Blink LED: first program in the course (ESP32, esp32 3.x package)
// Turns on the GPIO 2 LED for half a second, then turns it off for half a second
// and counts the blinks in the Serial Monitor.

const int PINO_LED = 2;      // GPIO 2: external LED (and the blue LED on many DevKits)
const int TEMPO_MS = 500;    // half a second on, half a second off
unsigned long piscadas = 0;

void setup() {
  Serial.begin(115200);         // Serial Monitor speed
  pinMode(PINO_LED, OUTPUT);    // the pin will send a signal (output)
  Serial.println("INEMA Robotics: LED blink ready");
}

void loop() {
  digitalWrite(PINO_LED, HIGH); // on: 3.3 V at the pin
  delay(TEMPO_MS);
  digitalWrite(PINO_LED, LOW);  // off: 0 V at the pin
  delay(TEMPO_MS);
  piscadas++;
  Serial.print("Blinks: ");
  Serial.println(piscadas);
}

Challenge (PWM API 3.x): instead of blinking, make the LED "breathe" by gradually increasing and decreasing its brightness. In version 3.x, ledcAttach(pin, frequency, bits) sets up the pin, and ledcWrite(pin, value) takes the pin itself. If an older tutorial uses PWM functions with a separate "channel," it's for API 2.x and no longer compiles.

// LED that "breathes" using PWM (ESP32, esp32 3.x package)
const int PINO_LED = 2;

void setup() {
  Serial.begin(115200);
  ledcAttach(PINO_LED, 5000, 8);   // 5 kHz, 8 bits: brightness from 0 to 255
  Serial.println("PWM ready on GPIO 2");
}

void loop() {
  for (int v = 0; v <= 255; v += 5) { ledcWrite(PINO_LED, v); delay(15); }
  for (int v = 255; v >= 0; v -= 5) { ledcWrite(PINO_LED, v); delay(15); }
}

How to check: the LED fades on and off smoothly, without abrupt blinking, about once every 1.5 seconds; the Serial Monitor shows "PWM ready on GPIO 2".

Workbench safety (from day one)

Why learn this

Simulating first takes away the fear and cost of mistakes: you learn about pins, resistors, and code without risking damage. The safety habits you build with an LED are the same ones that will protect you when you're working with motors, lithium batteries, and a moving robotic arm.

Key concepts