Autonomous and Semi-Autonomous Systems

One-sentence summary

An autonomous system makes its own decisions, while a semi-autonomous system still leaves some decisions to a human, and in this lesson we connect that difference to the sense–decide–act loop.

Why it matters

In the previous lesson you controlled the robot yourself from a distance. Every button on the controller was a decision that you made. But what if the robot could make some of those decisions on its own?

Many machines around us do exactly that. A robot vacuum changes direction before it hits a wall. A car's parking sensor warns you as you get close. An automatic door opens when someone stands in front of it. No human is pressing a button in that moment.

In this lesson we will tell two ideas apart: autonomy (making its own decisions) and control (a human making the decisions). There is no sharp wall between them; most real systems mix the two. Understanding this is the first step toward designing safe, honest robots.

What is autonomy?

The word autonomous means "making its own decisions." An autonomous robot gathers information from its surroundings, decides what to do based on a rule, and then acts. We can think of this with the sense–decide–act loop we met earlier.

The sense–decide–act loop

The heart of autonomy is these three steps, and they repeat over and over:

1. Sense: Read data from sensors (distance, light, line, temperature).
2. Decide: Choose what to do based on a rule.
3. Act: Drive the motors, an LED or a sound.

Repeat forever:
  distance = read the front sensor
  If distance < 20 cm
    stop and turn right
  Otherwise
    drive straight ahead

In this pseudocode no human presses a button. The robot measures the distance and applies the rule itself. That is autonomy: a rule inside the program makes the decision.

An example at each end

We can run a robot in two very different ways:

• Full remote control: You send "forward", "right" and "stop" commands from a controller. The robot makes no decisions on its own. This was the previous lesson.
• Full autonomy: You give the robot a goal ("clean the room") and it makes all direction decisions itself, from its sensors and rules.

In real life most robots sit between these ends. We call this middle ground semi-autonomous.

Semi-autonomous systems

In a semi-autonomous system the robot makes some decisions on its own, but for important decisions it checks with a human or waits for the human's approval. Control is shared.

Who is making the decision?

To see the difference, ask one question: "Who is making this decision, the human or the program?" In one system some decisions can belong to the human and others to the program.

Example: a line follower that you start

Imagine a robot that starts when you press a button, follows a black line on its own, but stops and waits for a new command from you when the line ends.

If the human pressed the "start" button
Repeat forever:
  line = read the bottom sensors
  If a line is visible
    follow the line        // robot's decision
  Otherwise
    stop and wait          // human steps in

Here the direction decision belongs to the robot, while starting and deciding what to do when the line ends belong to the human. This is exactly semi-autonomous behaviour: an aircraft's autopilot manages level flight on its own, but the pilot usually decides when to begin landing. Robot and human work together.

The logic of an obstacle-avoiding robot

Now let's look at the most classic autonomous behaviour: an obstacle-avoiding robot. It has a distance sensor at the front (ultrasonic, for example) and a motor driver that runs its two wheels.

The rule is very simple

• If the path ahead is clear, drive forward.
• If the path is blocked, stop, back up, turn and look in a new direction.

Let's write this behaviour as a short Arduino (C++) sketch. The goal is not to memorise the code but to see the logic:

void loop() {
  long distance = readDistance();  // read cm from the sensor

  if (distance > 25) {
    driveForward();                // path clear: keep going
  } else {
    stopMotors();
    driveBackward(300);            // back up a little
    turnRight(400);                // look in a new direction
  }
}

Functions like readDistance, driveForward and stopMotors are written separately; what we see here is the decision logic. The robot measures its surroundings again on every loop, so even if the obstacle moves, it adapts.

Improving the rule

On the first try the robot sometimes gets too close or keeps turning the same way. Small changes fix this:

• Decide earlier by using a 30 cm threshold instead of 25 cm.
• Turn right when the obstacle is on the left and left when it is on the right, instead of always turning right.
• Test at low speed; a fast robot can hit something before it even reads the sensor.

These show an important truth about autonomy: the better the rule, the better the robot decides, but no rule can foresee every situation.

The limits of autonomy and what to watch for

An autonomous robot is only as clever as the rules you give it. If a sensor reads incorrectly or an unexpected situation appears, it can make the wrong decision.

Why you always need a "stop" path

When you test an autonomous system, a human must be able to step in and stop the robot at any moment. This is often called an emergency stop: a button, a key on the controller, or a switch that cuts the power. The semi-autonomous approach provides exactly this; the robot decides for itself but a human keeps watch.

A short note on ethics

When a machine makes its own decision, who is responsible for the result? Engineers genuinely debate this. At our level the lesson is: the more decisions you leave to a robot, the more carefully and honestly you must design its rules. If a robot's decision could harm a person or its surroundings, it is safer to leave that decision to a human.

Mini practice

You will design on paper; no code or hardware is needed.

Imagine a robot moving around on top of a table. The robot has a distance sensor at the front and, underneath, a sensor that notices the edge of the table (at the edge, the floor is far away).

Write this behaviour as pseudocode:

• When it gets close to the table edge, it should stop without falling and turn back.
• If there is an obstacle in front, it should change direction.
• It should start when you press a button (so it is semi-autonomous).

Example start:

If the human pressed the "start" button
Repeat forever:
  If the bottom sensor sees an edge
    stop and turn back
  ...

Check your work:

• Which decision belongs to the human and which to the robot?
• How can you stop the robot at any moment?
• If both dangers (edge and obstacle) happen at once, which should the robot handle first?

Common mistakes

Confusing "autonomous" and "automatic"

An automatic washing machine always runs the same program. An autonomous robot changes its decision based on its surroundings. Autonomy is deciding by situation, not repeating a fixed sequence.

Leaving no emergency stop

Removing the human's ability to stop the robot because "it decides for itself" is dangerous. Every autonomous test needs a stop path.

Trusting a single sensor blindly

Sensors sometimes read incorrectly. A robot is safer when it decides from repeated readings rather than a single one.

Testing the robot at high speed

If the robot is too fast, it may already have crashed before the sensor reads an obstacle and the rule decides. Start low, then increase gradually.

Safety note

A moving robot can pinch, fall or run into things. Before you test, keep these in mind:

• Clear a safe area. Prepare an obstacle-free test area with clear boundaries to prevent falling off a table or running into a wall.
• Keep fingers, hair and cables away. Spinning wheels and gears can catch them. Watch out for loose clothing and long hair.
• Start at low speed. Do not increase the speed until you can see how the robot behaves.
• Use a motor driver and a separate battery. Motors draw more current than a microcontroller can supply; wiring motors directly to the board can damage it. Power the motors through a motor driver with a separate low-voltage battery pack, and connect the common ground (GND) of the two power sources.
• Never use mains electricity. Only low-voltage sources such as batteries.
• Adult supervision. Ask an adult for help with any step that involves motors, cutting tools or soldering.

Lesson summary

• An autonomous system makes its own decisions, while a semi-autonomous system leaves some decisions to a human.
• The heart of autonomy is the sense–decide–act loop, and this loop repeats continuously.
• The question "Who is making this decision?" is the easiest way to judge how autonomous a system is.
• An obstacle-avoiding robot is a classic autonomous behaviour that reads a sensor and changes direction by a simple rule.
• Every autonomous test needs a safe way for a human to step in and stop the robot.

Check questions

1. What is the main difference between an autonomous and a semi-autonomous system?
2. Write the three steps of the sense–decide–act loop in order.
3. What question can you ask to judge how autonomous a system is?
4. What steps does an obstacle-avoiding robot typically take when its path is blocked?
5. When testing an autonomous robot, why do you always need a "stop" path?

Answers

1. An autonomous system makes its own decisions; in a semi-autonomous system the robot makes some decisions itself, but important ones (starting, stopping) are left to a human.
2. Sense (read data from a sensor), decide (choose what to do based on a rule), act (drive a motor/LED/sound).
3. "Who is making this decision, the human or the program?" The more decisions belong to the program, the more autonomous the system is.
4. It stops, backs up a little, turns and looks in a new direction; then the loop restarts and it measures again.
5. A sensor can read incorrectly or an unexpected situation can appear; letting a human stop the robot safely at any moment prevents harm.

Source and verification note

For “Autonomous and Semi-Autonomous Systems”, verification focuses on whether the relationship between What is autonomy? and An example at each end 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

Preparing a Test Course