Introduction to Robotics

What Actually Makes Something a Robot

A robot is a machine that senses something about the world, decides what that reading means, and then acts on the decision — by itself, without a person steering every step. That three-part loop is the whole definition. Everything else in robotics is detail, and almost every argument about whether some gadget "counts" as a robot is settled by asking whether all three parts are present.

Two machines in the same room make the difference obvious. A ceiling fan spins because you moved a switch. It has no idea whether the room is hot, empty, or on fire, and it will keep spinning until somebody moves the switch back. An air conditioner reads the room temperature, compares it against the setting you chose, and starts or stops its compressor on its own. The fan is a machine. The air conditioner is doing exactly what a robot does — it simply has no wheels, so nobody calls it one.

This is also why a remote-controlled car is not a robot, however impressive it looks racing across the floor. You are the sensor and you are the brain; the car is only muscles. Bolt one small distance sensor to the front and add twenty lines of code so it stops before hitting a wall without you touching the remote, and it becomes a robot. Nothing about the chassis changed. The decision moved out of your head and into the machine.

The word itself is younger than most people expect. It comes from a 1920 Czech play, R.U.R. by Karel Čapek, built on the Czech word robota, meaning forced labour. A century later the same word covers a factory welding arm, a vacuum cleaner bumping around a living room, and the cardboard-and-tape car you are about to build.

• Senses — it takes a real measurement instead of assuming what the world looks like
• Decides — some logic, however simple, turns that measurement into a choice
• Acts — it changes something physical: a wheel turns, a gripper closes, a buzzer sounds
• Repeats — the loop runs again and again, so the robot keeps responding as conditions change

Sense, Think, Act — the Loop Your Code Lives In

Every program in this course has the same shape, because every robot has the same shape: a one-time setup, then a loop that never ends. On an Arduino board this is not a style choice, it is built into the language. You write a function called setup(), which the board runs once the moment it powers up, and a function called loop(), which it then runs over and over until the power is cut.

Inside loop(), keep the three stages mentally separate even when the code is only ten lines long. Read your sensors first, work out what the readings mean second, drive your motors and lights third. Beginners who mix the stages together — reading a sensor halfway through a motor sequence, for instance — end up with robots that behave differently on every run and are painful to debug, because there is never a single moment where the robot's picture of the world is settled.

The skeleton below is the obstacle-avoiding car from a later lesson, stripped to its bones. The three helper functions do not exist yet; writing them is most of what this course is for. Read it now for the shape, not for the details.

// Every Arduino sketch has exactly these two functions.

void setup() {
  // Runs ONCE, the moment the board powers up.
  Serial.begin(9600);       // open a text link back to your computer
  // ...and here you declare which pins are inputs and which are outputs
}

void loop() {
  // Runs again and again, forever, until the power is cut.

  // 1. SENSE - read the world as it is right now
  int distanceCm = readFrontSensor();

  // 2. THINK - turn that reading into a decision
  bool pathBlocked = (distanceCm < 20);

  // 3. ACT - change something physical
  if (pathBlocked) {
    turnAway();
  } else {
    driveForward();
  }
}

// readFrontSensor(), turnAway() and driveForward() get written in
// later lessons. The three-stage shape above never changes.

The Four Parts Every Robot Has

Open up any robot, from a college line-follower to an industrial arm, and you find the same four blocks. Learning to name them is useful because when a robot misbehaves, the first diagnostic question is always "which of the four is at fault?".

The controller runs your code. On an Arduino Uno it is a single small chip with no screen, no operating system and no files — it holds one program and runs it from the instant it gets power. That sounds limited compared to a laptop, and it is, but the trade is worth it: the chip starts in a fraction of a second, does exactly one predictable thing, and can read a pin's voltage directly. A laptop cannot do any of that.

A sensor converts something physical into an electrical signal the controller can read: distance into a pulse whose length you can time, light into a voltage, a button press into a connection. Sensors are how a robot escapes guessing. An actuator is the opposite conversion — electricity back into movement, light, sound or heat. Motors, servos, buzzers and LEDs are all actuators.

The fourth part, power, is the one beginners forget, and it causes more mysterious failures than the other three combined. A controller sips a tiny current; motors gulp. A battery that runs your Arduino happily for an hour can sag badly the instant two motors start, dropping the supply voltage low enough to reset the board mid-instruction. The robot then reboots, forgets what it was doing, restarts the motors, and browns out again — a loop that looks like a software bug and is not one.

• Controller — Arduino Uno, ESP32, Raspberry Pi; holds and runs your program
• Sensors — ultrasonic distance, infrared line sensors, buttons, potentiometers, temperature sensors
• Actuators — DC motors, servo motors, stepper motors, buzzers, LEDs, relays
• Power — USB from your laptop, a AA battery pack, or a rechargeable pack, usually with a separate supply for the motors
• Structure — the chassis, brackets and wheels that hold everything in place; cardboard and foam board work fine to start

Kinds of Robots, and Which One You Are Building

Robots are usually grouped by the job they do rather than by how they are built, because the same motors and sensors turn up everywhere. The categories below are worth knowing mainly so that you can read a job description or a research paper without getting lost.

Everything you build in this course belongs to the last two groups: small mobile robots and educational platforms. That is not a consolation prize. An obstacle-avoiding car uses the same sense-think-act loop, the same kind of distance sensor and the same closed-loop thinking as a warehouse robot costing several lakh rupees. The expensive machine has better sensors, sturdier motors and far more code — but if you understand why your car turns left at the right moment, you understand the warehouse robot too.

• Industrial robots — bolted to a factory floor, repeating a welding or assembly motion with high precision
• Mobile robots — they move through the world: delivery robots, warehouse carriers, self-driving vehicles, drones
• Service robots — built for everyday tasks around people, like robot vacuum cleaners and hospital delivery carts
• Humanoid robots — human-shaped, mostly research platforms; the shape is far harder than it looks and rarely the best engineering choice
• Educational robots — Arduino kits, line-follower chassis and similar platforms designed so that you can see and change every part

What You Need to Follow This Course

You do not need an expensive kit. The whole course runs on an Arduino Uno, a handful of components, and a chassis you can cut from cardboard or foam board. Arduino is an open hardware design, which means locally made clone boards use the same microcontroller chip, take the same code and cost a fraction of a genuine board. A clone is a perfectly sensible way to start; buying an official board later supports the people who made all of this free in the first place.

Buy in stages rather than all at once. Lessons three and four need almost nothing — a board, a USB cable, a breadboard, a few LEDs and resistors. Motors and a driver module come in later, and the servo arm later still. Buying a large kit on day one usually means half of it stays in the bag while you are still learning what a resistor does.

Salvage is genuinely useful here. Old remote-control toys give up perfectly good DC motors and wheels, dead chargers give up wire, and a discarded computer mouse gives up a switch you can use as a button. Skill in robotics is much more about careful wiring and clear thinking than about owning expensive parts.

• Arduino Uno board (genuine or clone) and a USB cable that carries data, not just charge
• Solderless breadboard and a bundle of male-to-male and male-to-female jumper wires
• A few LEDs and a strip of resistors — the cheapest and most useful thing you can own
• Two DC gear motors with wheels, plus a motor driver module such as the L298N
• An HC-SR04 ultrasonic distance sensor and a pair of infrared line sensors
• One or two small hobby servo motors for the robotic arm lesson
• A battery holder or rechargeable pack, and cardboard or foam board for the chassis

Safety, Briefly but Seriously

Everything in this course runs on low-voltage direct current from a USB port or from batteries. That is deliberate and it keeps the electrical risk to you very low. It does not make the risk zero for your components: reversed polarity, a stray wire touching the wrong pin, or a motor wired straight into the controller can destroy hardware in under a second and often without any warning smell or sound.

Build a habit now that will save you money later: power off before you rewire. Unplug the USB cable or disconnect the battery, make the change, check every connection once with your eyes, then reconnect. Changing wiring on a live circuit is how most beginners kill their first board, and a dead board is far more discouraging than the two extra seconds the habit costs.