The Basic Parts of a Robot

One-sentence summary

A robot is made of a control unit, sensors, actuators, a power source, a mechanical structure and software working together, and these parts let it sense its surroundings, make a decision and move.

Why does it matter?

In earlier modules we met the parts one at a time: code with Arduino, distance with sensors, light with LEDs. But those were separate experiments. What turns a pile of parts into a robot is connecting them into one single system.

Instead of seeing the inside of a robot as "wires in a box," think of each part as a team member with a clear job. When something fails or the robot acts strangely, you will know which section to check. This lesson is the shared map for every robotics lesson that follows.

Short definition: A robot is a system whose parts work together to sense the world, decide what to do based on some logic, and move in the physical world.

The six basic parts

Different robots look very different; an arm robot and a tracked explorer have almost nothing in common. Yet nearly all of them contain the same six parts.

1. The control unit (the brain)

The control unit is the robot's brain. It reads information from the sensors, decides what to do based on the software, and sends commands to the motors. In our lessons this brain is usually an Arduino board (a micro:bit works too).

Everyday example: The control unit is like a referee. It watches the field (sensors), decides by the rules (software) and blows a whistle to tell players what to do (commands to motors).

2. Sensors (the senses)

Sensors are the robot's senses. They measure temperature, distance, light, a line or a tilt, and pass this to the control unit as numerical information. A robot only "feels" the outside world through its sensors.

Everyday example: In a dark room, you run your hand along the wall to find a switch. Your hand acts like a sensor, sending what it gathers to your brain.

3. Actuators and motors (the muscles)

An actuator is a part that turns electrical energy into movement. The most common one is the motor: it spins wheels, lifts an arm or opens a lid. Servo motors turn to a specific angle; DC motors spin continuously. Motors are the robot's muscles.

Everyday example: Your brain decides "raise my arm," but your muscles do the lifting. A motor likewise turns the robot's decision into real movement.

4. The power source (the energy)

No part works without energy. The power source is usually a battery pack. Here is an important rule: motors draw far more current than an Arduino can safely supply on its own. That is why we never connect motors straight to an Arduino pin.

Instead we use a motor driver board and a separate battery pack. The Arduino tells the driver "how fast and which direction," and the driver takes power from the separate battery and sends it to the motor. The common ground (GND) of both power sources is joined so they speak the same language.

Everyday example: A crane operator lifts a huge load with a small controller. The controller has little power; a separate, powerful motor does the heavy work. The Arduino is the controller; the motor driver plus battery is the powerful motor.

5. The mechanical structure (the skeleton)

The mechanical structure is the body that holds every part together: chassis, wheels, gears and connectors. Without a good skeleton even the smartest software is useless; the motor may spin, but the robot will not move properly.

Two ideas matter here:

• Torque: the turning strength of a motor. A robot that climbs a slope or carries a heavy load needs high torque.
• Gear ratio: gears trade speed for torque. Going from a small gear to a large gear makes the robot slower but stronger — just like shifting to a low gear on a bike when the hill is steep.

Everyday example: The same motor on a smooth wheel slips on the floor, but on a rubber-tyred wheel with the right gears it climbs. The difference is not the software; it is the mechanical structure.

6. Software (the personality)

Software is the code that tells the control unit what to do. It reads sensor data, runs the decision logic and writes commands to the motors. The same hardware becomes a different robot with different software: you can load "follow the line" or "avoid obstacles" onto the very same vehicle.

Everyday example: Give the same bike to two people and one races while the other goes sightseeing. The bike (hardware) is the same; the decision (software) shapes the behaviour.

How do the parts connect?

These parts are not wired at random; information flows in a particular direction. We call this the sense–decide–act loop, and the entire next lesson is devoted to it.

The text block diagram below shows the flow:

   [Power source / Battery]
      |            |
      v            v
 [Motor driver]  [Arduino: Control unit]
      ^            ^   |
      |            |   |
   (power)     (data) (command)
      |            |   |
      |       [Sensors] |
      |                 v
      +---------> [Motors / Actuators]
                        |
                        v
             [Mechanical structure: wheels, gears, chassis]

Let us put the diagram into words:

1. The power source feeds both the Arduino and the motor driver (common GND).
2. The sensors send what they measure to the Arduino as data.
3. The Arduino decides what to do based on its software.
4. The Arduino sends a low-power command to the motor driver.
5. The driver passes power from the battery to the motors.
6. The motors move the mechanical structure, and the robot goes.

Example: An obstacle-avoiding robot (pseudocode)

Suppose you have a wheeled robot with a front distance sensor. The logic works like this:

Repeat forever:
  distance = read front sensor
  If distance < 15 centimetres
    stop the motors
    spin the right wheel backward briefly  (turn)
  Otherwise
    run both motors forward

Every part has a visible role in this logic: the sensor reads, the software decides, the motors move.

Example: The same logic in Arduino (C++)

The short program below is a simplified Arduino version of the pseudocode above. The motors are wired to a driver board; the code only gives a "direction" command.

void loop() {
  int distance = readDistance();   // read from sensor in cm

  if (distance < 15) {             // is an obstacle close?
    stop();                        // stop first
    turnRight();                   // then change direction
  } else {
    forward();                     // path clear, keep going
  }
}

The code looks different, but the logic is exactly the same as the pseudocode: sense, decide, act.

Mini activity

This activity needs no soldering and no power; the goal is simply to recognise the parts.

1. Pick a toy vehicle at home or in class (a remote-control car, a robot vacuum, a toy crane).
2. On paper, draw six columns: control unit, sensor, actuator/motor, power source, mechanical structure, software.
3. Examine the vehicle and write which part matches each column. For a part you cannot see, make a guess and note "couldn't see it, but I think it's here."
4. Finally, draw your own block diagram: which part sends information or power to which? Show it with arrows.

If an adult is nearby, talk about why a robot vacuum backs up after a bump: which sensor, which decision, which motor?

Common mistakes

Connecting a motor straight to an Arduino pin

Motors draw high current and can damage the control board. Always use a motor driver and a separate battery.

Forgetting the common ground (GND)

If you use two separate power sources and do not join their GND lines, the system behaves erratically or does not work at all. A common GND is a must.

Ignoring the mechanical structure

Most "the code is right but the robot won't move" situations are mechanical, not software: a loose wheel, the wrong gear, an overly heavy chassis or not enough torque.

Confusing a sensor with an actuator

A sensor gathers information (input); an actuator turns it into movement (output). To tell which is which, ask whether the part reads the world or changes the world.

Safety note

A moving robot can pinch, fall or run into things. So follow these rules:

• Prepare a clear, safe test area; stay away from edges to keep the robot from falling off a table.
• Keep your fingers, hair and cables away from wheels and gears; spinning gears catch hair and clothing easily.
• When you run a robot for the first time, test it at low speed, then increase the speed slowly.
• Always use a motor driver and a separate, low-voltage battery; connect the common GND.
• Never use mains (wall-socket) electricity. Keep an adult supervising any work with motors, batteries or vehicles.
• For any step involving cutting tools, soldering or hot surfaces, always ask an adult for help.

Lesson summary

• A robot is made of six basic parts: control unit, sensors, actuators/motors, power source, mechanical structure and software.
• The control unit (Arduino) reads the sensors, decides based on the software and sends commands to the motors.
• Because motors draw high current, we use a motor driver and a separate battery; the two power sources share a common GND.
• The mechanical structure, through torque and gear ratio, decides whether the robot really moves and carries a load.
• The same hardware can become a completely different robot with different software; information flows in the sense–decide–act direction.

Check questions

1. Which part is a robot's "brain," and what is its job?
2. What is the basic difference between a sensor and an actuator?
3. Why do we not connect motors straight to an Arduino pin? What do we use instead?
4. Why is a common GND needed when using two separate power sources?
5. When we change the gear ratio from a small gear to a large gear, how do the robot's speed and strength change?

Answers

1. The control unit (an Arduino in our lessons). It reads information from the sensors, decides based on the software and sends commands to the motors.
2. A sensor gathers information from the world (input); an actuator/motor turns the decision into physical movement (output).
3. Motors draw high current and can damage the control board. Instead we use a motor driver board and a separate battery pack.
4. A common GND lets the two power sources share the same reference point; without it the signals are unreliable and the system will not work properly.
5. The robot becomes slower but stronger (torque increases) — like shifting a bike into a low gear on a steep hill.

Source and verification note

For “The Basic Parts of a Robot”, verification focuses on whether the relationship between The six basic parts and 2. Sensors (the senses) remains consistent across examples. Robot behaviour cannot be explained by code alone; mechanical structure, power system, sensor placement and surface conditions must be evaluated together. Test results should be recorded over several runs on the same course.

Next lesson

The Sense–Decide–Act Loop: In this lesson we will build, step by step, how the parts we just met process information as a loop and turn it into real robot behaviour.