03 //Academy
- Sensors
- Motors
- Circuits
- Debugging
Code that moves something.
Robotics connects a program to the physical world, where a mistake is visible immediately: the motor turns the wrong way, the sensor reads nothing, or the robot simply refuses to do what you told it to.
01 //What learners build
Four things, in order.
- 01Sensing the world
A robot doesn't know what's around it — it measures.
Reading distance, light, movement or sound, and turning that into a number a program can use. Physical signals become data the code can interpret.
- 02Making things move
Turn a programming instruction into controlled movement.
Driving motors and mechanisms, and getting the timing right. A few lines move something forward; a small change makes it turn or stop at exactly the right moment.
- 03Circuits and connections
Understand what happens between the code and the machine.
Identifying components, following simple circuit diagrams, connecting sensors and actuators, and troubleshooting wiring safely.
- 04Testing and fixing
Turn a malfunctioning robot into a working one.
Change one thing, test it, observe the result, understand what happened, try again — instead of guessing.
02 //The robotics journey
Sense, think, move, test, improve.
How a learner moves through the path
01
Sense
What is happening around the robot? Read information from sensors.
02
Think
What should it do about it? Use code and logic to interpret the information.
03
Move
How should it respond? Control motors, lights or other outputs.
04
Test
Did it behave the way we expected? Observe the physical result.
05
Improve
What should change? Modify the code, wiring or design, and try again.
03 //The robotics loop
Input, logic, output, feedback.
Every robotic system can be understood through one cycle.
The cycle that repeats
01
Input
A sensor observes something: distance, light, movement, sound.
02
Logic
The program decides what to do. If this, then that.
03
Output
The robot responds: move, stop, turn, light up.
04
Feedback
The sensor observes the new situation, and the cycle begins again.
04 //What learners explore
Where software meets hardware.
- 01
Sensors — how robots measure the world
- 02
Motors — how electrical signals become movement
- 03
Controllers — how a programmable board connects code with hardware
- 04
Circuits — how components connect and communicate
- 05
Programming — logic, conditions, loops and functions to control behaviour
- 06
Automation — systems that respond to their environment
- 07
Debugging — diagnosing physical and software problems
- 08
Engineering thinking — design, test, evaluate and improve
05 //Learning through builds
Every concept should move something.
- 01Build 01
Sensor explorer
Connect a sensor and observe how its readings change. Inputs, measurements and data.
- 02Build 02
Smart light
A system that responds to changing light conditions. Sensors, conditions and outputs.
- 03Build 03
Obstacle detector
A system that detects an object and changes its behaviour. Distance sensing, decisions and motor control.
- 04Build 04
Mini rover
Program a small robot to move, stop and change direction. Motors, timing, navigation.
- 05Build 05
Responsive robot
Combine sensors, logic and movement so the robot reacts to its environment. Feedback loops.
- 06Final challenge
Build a robot that can respond
Give the robot a job. The learner decides what it senses, how it decides, and how it responds — then designs, wires, programs, tests, debugs and demonstrates it.
06 //The learner progression
From connecting components to designing behaviour.
- 01Explorer
“What does this component do?”
Discovering sensors, motors and basic circuits.
- 02Builder
“Can I make these parts work together?”
Connecting hardware and creating simple behaviours.
- 03Programmer
“Can I control what happens?”
Using code to respond to inputs and control outputs.
- 04Debugger
“Why isn't it doing what I expected?”
Learning systematic testing and troubleshooting.
- 05Robot creator
“I know what I want my robot to do.”
Designing and building an independent robotic system.
07 //What parents can expect
More than assembling a robot.
- 01
Problem solving
Breaking physical and programming problems into smaller pieces.
- 02
Logical thinking
Connecting sensor inputs with decisions and physical outputs.
- 03
Engineering confidence
Becoming comfortable with components, systems and mechanisms.
- 04
Persistence
A malfunction becomes something to investigate rather than give up on.
- 05
Creativity
Learners decide what their robot should do and how it should behave.
- 06
Systems thinking
Seeing how software, electronics and physical components work together.
08 //What learners leave with
Don't teach children to assemble robots. Teach them to make systems behave.
The hardware is one part. The code is one part. The real learning happens when a learner understands the relationship between them: sense, think, act, observe, improve.
- An understanding of sensors and electronics
- And experience writing the control logic above them.
- A method for testing and debugging
- Applied to problems that are physical, not only logical.
- A foundation in engineering thinking
- “I wrote the code — and the real world responded.”
Other paths
Other paths
- 01
Coding
Coding starts with logic a learner can see and moves into written code, so the step from blocks to a real language feels like the next sentence rather than a new subject.
- 02
AI
AI is explored by using it and taking it apart: training something simple, seeing where it gets things wrong, and asking why.
- 03
Game Development
Game development turns a familiar pastime into a design problem: rules, movement, difficulty and feedback all have to be decided by the person making it.
Make something move
Then make it smarter.
A first robot moves forward. Then it stops. Then it detects an obstacle. Then the learner asks what else it could do.
