Challenge 1
Make the ride last just 5 seconds, not 10. Make it beep twice at the end, not once. Before you run it, guess how far round the wheel will get in that time. Then check if you were right.
Quick Learn — the model, the instructions, the program and the challenges. The theory is in Full Lesson.
EV3 Robotics›Level 1 · Beginner›Lesson 12
Level 1 · Lesson 12 · EV3-L01-1260 minutes · Ages 7+ · Model: Ferris Wheel
The Ferris Wheel: a tower that stands on the Brick. A motor sits near the top. It turns a wheel with four arms and four coloured cars. The cars stay upright as the wheel turns.
Most programs you have written had their own ending. Four rotations, then stop. Two seconds, then stop. A fairground ride is not like that. It runs while the ride is open. It stops when a person decides it should.
By the end, your ride will say hello. It will turn slowly and steadily for as long as you choose. Then it will stop when you tell it to. You will also find out why one missing block keeps it turning after the program ends.
George Ferris built the first Ferris wheel for the 1893 Chicago World’s Fair. It was America’s answer to the Eiffel Tower. It carried more than two thousand people at a time. Every big wheel since then is copied from it. You can ride them in cities all over the world.

Two things matter. Your model does both.
It turns slowly, with a lot of force. The motor spins fast, but it is not very strong. The wheel must turn slowly and strongly. It lifts full cars all the way up. Gears swap speed for strength. You will find them on your own model soon.
The cars hang. Nothing clever holds them level. Each car swings from a pin. Gravity keeps it upright, all the way round. Turn your wheel by hand and watch.
Now the part that matters for the program. A real ride is not switched on for “six turns”. It runs while people are riding. Then the person in charge ends it. They stop early if someone feels ill. They run longer if the queue is short.
If a counter decides when a machine stops, a person cannot stop it. Some movements need their own ending. Others need to run until something else says stop.
Most motor blocks you used were one kind. You gave it an amount. It did that amount, then it finished. You also used a second kind, with the Unicycle and the EV3 Fan. Today you find out how it works. It is just right for a fairground ride.
| Block | What it does | When the program moves on |
|---|---|---|
[A v] run [clockwise v] for (4) [rotations v] :: motors | Turns exactly that far, then stops itself. | After the movement finishes. |
[A v] start motor [clockwise v] :: motors | Starts turning and keeps turning. Nothing in it says when to stop. | Straight away, while the motor is still going. |
start motor does not wait. The program goes straight on to the next block. The wheel is still turning. The motor keeps going until a stop motor block tells it to stop.
That is how a wait block can set how long the ride lasts. Watch the rotation counter here. It keeps going up during the wait. The wait pauses the program, not the motor.
0.00rotations so farnoshaft turning
The count does not pause when the program does. A wait holds up the blocks, and the motor carries on turning underneath it.
The ride needs sound too. Sound blocks come in the same two kinds. One makes the program wait until the sound ends. The other starts the sound and carries on.
play sound until done
start sound
Watch the barriers, not the clock. On the left the warning finishes before anything moves; on the right it sounds while the barrier lifts.
Everything an EV3 does begins with a motor turning. Before worrying about how far or how fast, there are only two things to say to a motor: start and stop. The blocks are the same whichever motor you use — only the port letter changes.
| Block | What it does |
|---|---|
[A v] start motor [clockwise v] :: motors | Starts the motor and immediately carries on to the next block. The motor keeps turning on its own. |
[A v] stop motor :: motors | Stops the motor. |
wait (2) seconds | Holds the program here, which is how you control how long a motor runs. |
Because start motor does not wait, a motor started on its own would run until the program ended. The pattern that gives a motor a length is three blocks:
when program starts :: events hat [A v] start motor [clockwise v] :: motors wait (2) seconds [A v] stop motor :: motors
Read it aloud: start it, leave it two seconds, stop it. Change the wait and you change how far the motor gets.
The highlight below follows the block the Brick is running, and the shaft turns only while the program is between start motor and stop motor. Notice that the count keeps climbing all the way through the wait — the wait does not pause the motor, it pauses the program.
0.00rotations so farnoshaft turning
The count does not pause when the program does. A wait holds up the blocks, and the motor carries on turning underneath it.
This is the whole idea behind start motor: it hands the motor its instruction and moves on, leaving the motor running behind it. Nothing stops the shaft until a block tells it to.
The direction dropdown says clockwise or counterclockwise — but clockwise seen from where? Always from the axle end: look straight at the shaft coming towards you, and clockwise is the way a clock’s hands go.
Here the Medium Motor faces you, so its output axle points straight out of the page. This is the view to picture when you are choosing a direction.
when program starts :: events hat [A v] start motor [clockwise v] :: motors wait (2) seconds [A v] stop motor :: motors
A Medium Motor normally lives in port A or D.
The Large Motor is shown from the side, which is the face its axle comes out of — so once again you are looking straight down the shaft.
when program starts :: events hat [B v] start motor [clockwise v] :: motors wait (2) seconds [B v] stop motor :: motors
A Large Motor normally lives in port B or C. Compare the two programs: they are the same three blocks, and only A has become B.
A fan, a conveyor belt or a spinning ride does not need to stop at an exact position — it just needs to run while something is happening. For those, timing the motor is simpler and perfectly good enough.
The Brick has a small speaker. It can play one of the built-in sound files, or beep a note you choose. Sound is what makes a machine feel finished — and it is also a way for the robot to tell you something without you having to look at it.
| Block | What it does |
|---|---|
play sound [Communication / Hello v] until done :: sound | Plays the sound and waits for it to finish before the next block runs. |
start sound [Communication / Hello v] :: sound | Starts the sound and moves straight on to the next block, so the sound plays while the robot keeps working. |
play beep (60) for (0.5) seconds :: sound | Plays a single note for a set time — useful for short alerts. The number is a note, not a volume: bigger means higher. |
set volume to (100) % :: sound | Sets how loud everything after it will be. Worth putting at the top of a program — the Brick remembers the last volume it was given, even from somebody else’s program. |
stop all sounds :: sound | Cuts off anything that is still playing, including a long sound started earlier. |
These two blocks play the very same file. The difference is what the rest of the program does while it plays — so it cannot be heard on its own, only seen. Here are both, each lifting a barrier.
play sound until done
start sound
Watch the barriers, not the clock. On the left the warning finishes before anything moves; on the right it sounds while the barrier lifts.
The bars underneath are when the speaker was on and when the motor was turning. On the left they never overlap: the program is stuck at the sound block until the file has finished, and only then does the barrier lift. On the right they overlap almost completely, and the whole job is done in half the time.
Real machines warn before they move, not after: a lift chimes before the doors close, a reversing lorry beeps while it rolls back, a level crossing sounds before the barrier drops. Getting the order right is the difference between a warning and an apology.
Waiting is how a program gives the physical world time to catch up. There are two kinds, and choosing between them is one of the first real design decisions in robotics.
| Block | What it does |
|---|---|
wait (1) seconds | Holds the program for a fixed length of time, whatever else is happening. |
wait until <> | Holds the program until a condition becomes true — usually a sensor reading. |
Most sensors bring their own ready-made wait block, already coloured to match the sensor and with its comparison built in. They are all the same idea — hold here until this is true — and they live in the sensor’s own palette rather than in Control.
| Sensor | Block | Waits until |
|---|---|---|
| Touch | [1 v] wait until [pressed v] :: sensors | the button is pressed. The dropdown also offers released and bumped. |
| Colour | [3 v] wait until color is [red v] :: sensors | the surface underneath is that one of the eight colours. |
| Ultrasonic | [4 v] wait until distance [< v] (15) [cm v] :: sensors | something is nearer than 15 cm. Flip the dropdown to > to wait for something to move away. |
| Gyro | [2 v] wait until angle [< v] (45) :: sensors | the robot has turned past that angle. |
| Brick buttons | wait until [center v] button is [pressed v] :: sensors | somebody presses that button on the Brick. No port — it is built in. |
Some readings have no wait block of their own — reflected light, ambient light, the timer, and a motor’s degrees counted. For those, drop the matching boolean into the plain wait until from Control. It does exactly the same job:
wait until <[3 v] is reflected light intensity [< v] (30) %? :: sensors> wait until <[3 v] is ambient light intensity [> v] (50) %? :: sensors> wait until <(timer) > (5)> wait until <([A v] degrees counted :: sensors) > (720)>
This is also the way to wait for two things at once, which no ready-made block can do — the sensor blocks each take one condition, but a boolean can be combined:
wait until <<[1 v] is pressed? :: sensors> or <(timer) > (5)>>
That one says “stop waiting when the button is pressed, or after five seconds, whichever comes first” — which is how you stop a wait hanging for ever when the thing you are waiting for never happens.
Two robots, the same job: drive up to the wall and stop. One waits two seconds; the other waits for the wall. Let it run several times — the interesting part is what happens on the second and third run.
wait for a length of time
wait for a condition
Each orange dash is where a previous timed run finished. The sensing robot has never left a second mark, because it has never stopped anywhere else.
The timed robot is not being careless. Two seconds is a perfectly good guess, and on the first run it may look exactly right. But a second covers a different distance on a fresh battery, on a dusty floor, or with a heavier load, so the robot finishes somewhere new every run — sometimes short, sometimes into the wall. The sensing robot has never had to guess.
Prefer waiting for a condition wherever a sensor can tell you. Keep timed waits for things with no sensor to check — letting a sound finish, or pausing so a person can watch.
A lift that waits three seconds for its doors is guessing; one that waits for the door sensor knows. The first eventually closes on somebody.
Say this back before moving on: “run for has its ending inside it. start motor has no ending, so I have to give it one.”
Look at your model and find the parts with cables. There are two again. One Brick, and one motor that does all the work.
The motor does not turn the wheel directly. A small gear on the motor’s axle drives a 40-tooth gear on the wheel. Count the teeth on the small gear yourself. It is a real number on your own model. That number decides how the whole ride moves.
Say the small gear has 8 teeth. Then the motor turns five times for each turn of the wheel. In return, the wheel gets about five times the turning force. That is just what the ride needs. It is slow, smooth, and strong enough to lift four full cars.
Try it by hand before switching on. Turn the small gear one full turn. See how little the wheel moves. Then try to stop the wheel by holding a car. It is hard to stop! That is the extra force from the gears, not the motor.
Sensors go in ports 1, 2, 3, 4. Motors go in ports A, B, C, D. You cannot swap them. If you do, nothing warns you. The robot just will not work.
| Part | Port | Why this one |
|---|---|---|
| Large Motor (turns the wheel) | A | When there is only one motor, we usually use A. Every program on this page says A. |
The motor sits high on the tower. Its cable is longer than in any model so far. Run it down the outside of a beam, not through the wheel. A cable caught in the wheel will stop the ride. It will look just like a mistake in the program.
Check your own build now:
Two routes, and either is fine. USB is the reliable one and the one to fall back on when a room’s Bluetooth is busy; Bluetooth leaves the robot free to move, which some models need.
Do these in order. Naming the Brick after you go looking for it in the list is how groups end up driving each other’s robots.
EV3 until somebody changes it.EV3.The two failures, every class, every time. The Brick has gone to sleep while you were building — press the centre button to wake it. Or you have paired with the group at the next table, which is why the name matters.
The long version, including Port View and how to read the port tiles, is in the Brick & Bluetooth guide.
The Brick is the base of the tower now. It holds up the whole model. Leave the cable a bit loose. Then a tug on the laptop will not pull the ride over.
If the number does not move when the wheel does, stop here. The cable is in the wrong port, or not pushed all the way in.
Turn the wheel a little, and the number moves a lot. That is the gears, seen from the other end. The counter measures the motor, not the wheel.
Make one change at a time. Guess what will happen before each run.
Steps 3 and 4 show the lesson from both sides. A block with no ending needs you to give it one. A block with its own ending does not need the wait at all.
If the wheel refuses to start turning, try a higher speed before you blame the program. The gears make the wheel slow, and it carries four cars. It needs a real push to get going. 10 % may not move it at all.

Build the model before you read any further. Everything after this is about making it do something, and none of it will make much sense with nothing on the table in front of you.
One page at a time — use Next and Previous, or the ← → keys. Fullscreen makes it big enough to build from.
The same build on Google Drive — sometimes a video, sometimes a scan:
Fullscreen it while you build — you can pause and scrub with the player's own controls.
Check the finished build against the picture before you switch anything on. A motor mounted the wrong way round is far easier to spot now than it is to debug later, when it looks like a program fault.
A whole ride in seven blocks. Call the riders. Turn the wheel gently for ten seconds. Stop it, and beep to say it is over.
when program starts :: events hat play sound [Communication / Hello v] until done :: sound [A v] set speed to (25) % :: motors [A v] start motor [clockwise v] :: motors wait (10) seconds [A v] stop motor :: motors play beep (60) for (0.5) seconds :: sound
Read it in the order the Brick runs it:
What success looks like: first a hello. Then ten seconds of slow, smooth turning, with the cars hanging level. Then a clean stop and a beep. Does the wheel jerk or get stuck on the way up? Then the speed is too low for the load, not too high.
Work through them in order — each is harder than the last. The extra challenge comes after all three, and it is meant to make you plan before you build.
Make the ride last just 5 seconds, not 10. Make it beep twice at the end, not once. Before you run it, guess how far round the wheel will get in that time. Then check if you were right.
Give the ride a proper start and finish. First, sound a warning. Then wait two seconds so riders can sit down. Then run. At the end, slow to a gentler speed for the last two seconds. Then stop, so no one gets a jolt. The wheel must never stop and start again in the middle.
Run the ride three times in a row from one press of play. Leave a clear pause between rides so riders can get on and off. Each ride must be shorter than the one before. Try not to write the same blocks out three times. If you cannot do that yet, write them out. Then say in one sentence what would make it easier.
The person running the ride needs a control that really works. Build a Ferris Wheel that a person runs. It must not run by itself. It must say when riders can get on. It must turn while the ride is open. It must stop when the person decides. It must not stop after a time you chose before. Plan on paper first. You already have a block that holds the program until a person acts. Work out where it must go. The wheel must keep turning while the program waits. It must not stand still. That one choice is the whole mission. You will be asked two questions when you show it. Where does the wheel keep turning while your program waits? How do you know? And what should the ride do if the person walks away and never presses anything?