Skip to content

Robotics & Automation

Course review

A single place to see how far you have come, jump back to where you left off, and revisit any week. Your progress is saved on this device.

0 of 8 weeks completed

0%

Start Week 1

Weeks

  • 01

    What Makes Something a Robot?

    Week 1: What Makes Something a Robot?. Status: Not started

    Open
  • 02

    Building a Robot That Moves

    Week 2: Building a Robot That Moves. Status: Not started

    Open
  • 03

    Giving Exact Instructions

    Week 3: Giving Exact Instructions. Status: Not started

    Open
  • 04

    Helping Robots Sense

    Week 4: Helping Robots Sense. Status: Not started

    Open
  • 05

    Making Robots React

    Week 5: Making Robots React. Status: Not started

    Open
  • 06

    Debugging and Reliability

    Week 6: Debugging and Reliability. Status: Not started

    Open
  • 07

    Planning an Autonomous Mission

    Week 7: Planning an Autonomous Mission. Status: Not started

    Open
  • Final

    Final project

    Final project. Status: Not started

    Open

Saved programs

Programs you build and save in the programming weeks will appear here.

Simulator runs

Simulator missions you complete will be listed here.

Printable resources & adult guidance

Each week has a print-friendly student worksheet and a parent & teacher guide (with the learning purpose, pacing, common misconceptions, questions to ask, safety notes, and the knowledge-check answer key). Open one and use your browser's Print option.

Vocabulary reference

Every robotics term from the course, week by week.

Week 1: What Makes Something a Robot?

Robot:
A machine that can sense its surroundings, decide what to do, and act on its own using a program.
Machine:
A tool that does work, like a bicycle or a stapler. A machine is only a robot if it can sense and decide by itself.
Input:
Information a robot takes in from the world, usually through a sensor.
Processing:
The 'thinking' step where the controller uses the inputs to decide what to do.
Output:
The action a robot takes, like moving a wheel or turning on a light.
Controller:
The robot's 'brain' - the small computer that runs the program and makes decisions.
Sensor:
A part that measures something about the world, like distance, light, or touch.
Actuator:
A part that makes something move or happen, like a motor, wheel, or buzzer.
Program:
A set of instructions the controller follows to do a job the same way every time.
Autonomous:
Acting on its own, using sensors and a program, without a person steering it.
Remote-controlled:
Steered by a person in real time, for example with a joystick or app.

Week 2: Building a Robot That Moves

Motor:
A part that spins when it gets power, giving the robot the movement it needs to roll.
Axle:
A rod that a wheel is attached to, so when the axle turns, the wheel turns with it.
Wheel:
A round part that rolls the robot along the ground when its axle spins.
Gear:
A toothed wheel that locks into another gear to pass along spinning motion and change its speed or power.
Speed:
How fast the robot moves. A small gear driving a big gear makes the wheels spin slower.
Torque:
The turning power a motor or gear has. More torque means more force to move a heavy robot or climb.
Friction:
The rubbing force between two surfaces that touch. It slows sliding and lets wheels grip instead of spinning in place.
Traction:
How well a wheel grips the ground. Good traction means the wheel pushes the robot forward instead of slipping.
Balance:
Keeping the robot's weight spread so it stays upright and does not tip over.
Stability:
How hard it is to tip a robot over. A low, wide base is more stable than a tall, narrow one.
Center of mass:
The average spot where a robot's weight is centered. A lower center of mass makes the robot harder to tip.
Chassis:
The frame or base of the robot that holds the motors, wheels, and everything else together.
Differential drive:
A way to steer by driving the two side wheels at different speeds: the robot turns toward the slower wheel.

Week 3: Giving Exact Instructions

Program:
A list of instructions a computer follows to do a job. This week, a program is a sequence of movement commands.
Command:
One single instruction the robot can carry out, like 'move forward' or 'turn right'.
Sequence:
Commands run one after another, in order, from top to bottom. Order matters.
Algorithm:
A clear step-by-step plan for doing a task, with no missing or fuzzy steps.
Pseudocode:
Writing the steps of a plan in plain language before you turn them into real code.
Event:
The moment that starts a program running, like pressing 'Start' or a 'when tapped' block.
Timing:
How long a command runs, measured in seconds - one way to control how far the robot goes.
Distance:
How far the robot moves in a command, often set in centimeters or grid squares.
Turn:
A command that rotates the robot in place, usually by a set number of degrees like 90.
Speed:
How fast the motors run. Faster speed covers more distance in the same amount of time.
Prediction:
Your best guess about where the robot will end up, made before you run the program.

Week 4: Helping Robots Sense

Touch sensor:
A sensor that tells whether it is being pressed or not, like a button or a bumper.
Distance sensor:
A sensor that measures how far away the nearest object is, usually in centimeters.
Light sensor:
A sensor that measures how bright or dark it is, giving a higher number in bright light.
Color sensor:
A sensor that reads the color of a surface right in front of it, like red, blue, or white.
Sensor reading:
The number a sensor gives you at one moment, such as 20 centimeters or a brightness of 47.
Threshold:
A cutoff number you pick that separates two cases, like 'closer than 15 cm means near'.
Detection limit:
The point past which a sensor can no longer sense, like a distance sensor that can't read farther than about 2 meters.
Calibration:
Adjusting or checking a sensor so its readings are correct for this room and this robot.
Noise:
Small wobbles in a reading even when nothing changes, which is why you take several readings.
Reliability:
How much you can trust a sensor to give the same, correct reading each time.
Trial:
One single measurement in a test; you usually run several trials and compare them.
Baseline:
A starting reading you take in a known, steady condition to compare other readings against.

Week 5: Making Robots React

Loop:
A block that repeats one or more steps instead of writing them out over and over.
Forever loop:
A loop that keeps repeating its steps over and over until you stop the program.
Repeat-until:
A loop that repeats its steps until a condition becomes true, then stops and moves on.
Condition:
A check about the world, like 'is the wall close?', that is always either true or false.
If:
A block that runs its steps only when its condition is true, and skips them when it is false.
If/else:
A block that runs one set of steps when the condition is true and a different set when it is false.
Boolean:
A value that can only be one of two things: true or false. Conditions give a boolean answer.
Obstacle avoidance:
A behavior where the robot loops, reads a distance sensor, and turns away when something is close.
Line following:
A behavior where the robot keeps checking a light or color sensor and steers to stay on a marked line.
Responsive behavior:
When a robot changes what it does based on what it senses, in real time, instead of following a fixed list.

Week 6: Debugging and Reliability

Debugging:
The work of finding out why a robot's actual result is different from the expected result, then fixing it.
Variable:
A named place in a program that stores a value which can change while the program runs.
Counter:
A variable used to count: it starts at a number and goes up by one each time something happens.
Stored value:
A number or fact a program keeps in a variable so it can use or change it later.
Calibration value:
A number you measure and save so a sensor's readings mean the right thing, like the light level of a white floor.
Expected result:
What SHOULD happen when the program runs correctly - what you predict before you test.
Actual result:
What DID happen when you actually ran the robot, which you observe and write down.
Test case:
One specific situation you set up on purpose to test, like 'a wall exactly 15 cm away'.
Mechanical bug:
A physical problem with the robot's body, like a loose wheel, a dragging wire, or a jammed gear.
Programming bug:
A mistake in the instructions: a wrong, missing, or out-of-order block or number.
Sensor bug:
A problem with sensing: a bad reading, a wrong threshold, or a sensor that needs calibrating.
Reliability:
How well a robot does the same job correctly again and again, proven by repeated trials.

Week 7: Planning an Autonomous Mission

Autonomous:
Acting on its own: the robot uses its sensors and a program to decide what to do, with no person steering it.
Remote-controlled:
Steered by a person in real time, moment by moment, for example with a joystick or an app.
Requirement:
Something the robot MUST do to count as doing the mission, like 'reach the drop-off zone'.
Constraint:
A limit you have to work inside, like time, size, materials, or budget.
Criteria:
The measures you use to judge success, like 'stops within 5 cm of the wall' or 'finishes in under 30 seconds'.
Trade-off:
Giving up some of one good thing to get more of another, like going slower to be more reliable.
Engineering design process:
The repeating cycle engineers use: plan, build, test, and improve.
Iteration:
One trip around the design cycle - testing your plan or robot, finding a problem, and improving it.
Efficiency:
Doing the job well with less: fewer steps, less time, or less energy.
Safe stop:
A programmed behavior that halts the robot safely when the job is done or something is in the way.
Responsible robotics:
Thinking about safety and about when a human should stay in control instead of the robot.
Flowchart:
A step-by-step diagram of a program that uses boxes for actions and diamonds for decisions.

Final project

Mission:
The one helpful job you choose for your robot to do.
Planning brief:
A short written plan describing the mission, requirements, and constraints before you build.
Input-processing-output diagram:
A picture showing what your robot senses, how it decides, and what it does.
Flowchart:
A step-by-step diagram of your program using boxes for actions and diamonds for decisions.
Iteration:
Improving your design by testing it, finding a problem, and changing it.
Safe stop:
A behavior that makes the robot stop safely when the job is done or something is in the way.
Rubric:
A chart that describes what beginning, developing, proficient, and exemplary work looks like.

Predictions

Predictions you write before an experiment will appear here.

Test records

Test tables you fill in during the testing weeks will appear here.

Bugs & fixes

Fixes you note in the debugging missions will appear here.

Journal entries

Design-journal answers you save will appear here.

Answer explanations

Once you take a knowledge check, its answer explanations will appear here to re-read.

Design journalFinal projectBack to course overview