The Dual Gyro: a launcher for spinning tops. One motor under the Brick turns a big gear. There is a spinning top on each side of it. Run the motor, and both tops fly off together, spinning.
Lesson 1 was about where the robot went. Lesson 2 was about how often it moved. This one is about how hard. That is the third dial. It is also the one most people get wrong.
By the end, you will launch two tops at once. You will also find the slowest speed that still keeps them standing. That number is not on this page. You have to measure it.
A warning about the name. This model is named after gyroscopes, which are spinning tops. It is not the EV3 Gyro Sensor. There is no sensor at all on this build. You will meet the Gyro Sensor in Lesson 43, the Gyro Magic Stick.
In the real world 5 min
Where you have seen it
A spinning top can stand up on a tiny point. Some big tops are as wide as a dinner plate, and heavier than a brick. Two people launch them with a rope. A good throw can make one spin for over an hour.
A toy gyroscope: a spinning wheel held inside rings that can tilt. Photo: Wikimedia Commons (CC0).
Why it is built that way
A spinning wheel does not like to tip over. Scientists call this angular momentum. The important part for today: it gets stronger with speed. The faster the wheel turns, the harder it is to tip over. That is why a top stays up. It is not balance. It is spin.
Spin helps in other places too. A moving bicycle stays up, but a still one falls over. Planes and ships use gyroscopes to keep going the right way. Your phone uses one to know which way you tilt it.
What would go wrong without it
Spin a top too slowly, and it does not just wobble more. It falls over at once. Below a certain speed, the trick stops working.
Speed is not like a volume knob, where more is just more. Between “falls over” and “stands up” there is a line. It is a real number, and you can find it by testing.
Finding that line is this lesson’s mission. Everything before it helps you set the speed carefully, so you can trust your answer.
The main concept — speed is its own dial 6 min
Last lesson, the Wipers had a speed block at the top. You set it once and moved on. Today you find out what that block really does. And you choose the speed yourself.
Speed and distance are two separate dials. The speed block does not move anything. It changes what the next movement does.
That second part trips up nearly everyone. What if you put the speed block after the movement? Nothing warns you. The program runs, and the number is right there. But the motor does not use it at all. Watch both versions run side by side.
speed first — works
A set speed to 25 %
A run clockwise for 2rotations
speed last — does nothing
A run clockwise for 2rotations
A set speed to 25 %
0.00rotations · slow0.00rotations · fast
Speed first: the movement was slowSpeed last: it only affects the NEXT movement
Two programs. Same two blocks in each — only the order is different.Both are running — and the right-hand one is already finished. The left is barely a third of the way.Its speed block runs now, far too late to affect the movement above it. The left motor is still going, slowly, as it was told to.Both turned exactly 2 rotations. Only one of them did it at the speed the program asked for.Finished — it will run again in a moment.
stopped
Both shafts turn exactly 2 rotations. Only the time they take is different — and the right-hand program never gets the slow movement it was written to have.
▶Speed and power, and writing to the screenHow both work. Open it if setting a speed, or writing on the Brick screen, is not clear yet.Show meHide
ComponentMotion4 min
Speed and power
Speed is set separately from movement. You tell the motor how fast it should go, and then you tell it to go — two blocks, in that order.
Speed is a percentage of what this motor can do, not a real-world unit — the same 50 % moves a light arm quickly and a heavy one slowly.
Blocks reference
Block
What it does
[A v] set speed to (25) % :: motors
Sets the speed for this motor from now on. Nothing moves — it only changes what the next movement will do.
[A v] run [clockwise v] for (2) [rotations v] :: motors
Now moves, at whatever speed was last set.
Set it first
when program starts :: events hat
[A v] set speed to (25) % :: motors
[A v] run [clockwise v] for (2) [rotations v] :: motors
Swap those two blocks round and the program still contains a speed of 25 % — it just never gets used. Both shafts below are asked for exactly 2 rotations; watch how long each one takes.
speed first — works
A set speed to 25 %
A run clockwise for 2rotations
speed last — does nothing
A run clockwise for 2rotations
A set speed to 25 %
0.00rotations · slow0.00rotations · fast
Speed first: the movement was slowSpeed last: it only affects the NEXT movement
Two programs. Same two blocks in each — only the order is different.Both are running — and the right-hand one is already finished. The left is barely a third of the way.Its speed block runs now, far too late to affect the movement above it. The left motor is still going, slowly, as it was told to.Both turned exactly 2 rotations. Only one of them did it at the speed the program asked for.Finished — it will run again in a moment.
stopped
Both shafts turn exactly 2 rotations. Only the time they take is different — and the right-hand program never gets the slow movement it was written to have.
The right-hand movement is over before the left is a third of the way round, because it ran at the default speed. Its set speed to () block does run — you can see it light up — but by then the movement it was meant to slow down has already happened. A speed block only ever affects the movements after it. This catches people out constantly.
Slow is often better
A high speed is not a better program. Slow movements are gentler on the gears, easier to watch and debug, and look more like the real machine — a barrier that snaps up in a fraction of a second reads as broken rather than fast.
ComponentOutput5 min
The Brick display
The Brick’s screen is a small black-and-white whiteboard. You can wipe it, draw one of the built-in pictures on it, or write your own words at a spot you choose. It is how the robot tells a person what it is doing.
The screen sits above the buttons on the face of the Brick. It is small and black-and-white, so short messages work and long ones do not.
Blocks reference
Block
What it does
clear display :: display
Wipes the screen blank, ready for something new.
display [Eyes / Neutral v] :: display
Draws a built-in picture chosen from a list — eyes, faces, arrows, symbols.
display [Eyes / Neutral v] for (2) seconds :: display
Draws the picture, holds the program for that long, and then carries on. Handy when a face should be seen before anything else happens.
write [Hello] at line (1) :: display
Writes your own text on one of the screen’s eight lines.
write [Hello] at x: (10) y: (40) with font [normal black v] :: display
Writes text at an exact spot instead of a line, and lets you choose the size. Use it when a message has to line up with something else on the screen.
Clear it, or write on top of what is there
The screen has no memory of whose writing is whose. It keeps every mark until something wipes it — including the marks left by the last run. Watch the same program with and without its clear display block.
with clear display
when program starts
clear display
display Eyes / Neutral
write GATE OPEN at line 7
without it
display Eyes / Neutral
write GATE OPEN at line 7
1lines · cleared1lines · not cleared1run
Cleared: one message, readableNot cleared: 1 messages on line 7
Both Bricks still show whatever was left on the screen when the last run ended.The left program clears its screen. The right one has no clear block, so the old writing stays where it is.Both draw the eyes.Both write this run's message on line 7 — and on the right it lands on top of the message that was already there.Finished. The right-hand screen keeps everything it has ever been told to write.
drawing
Let it loop two or three times. The left screen still reads cleanly; the right one is the same program with one block missing.
Both Bricks are told exactly the same thing. The left one wipes the screen first, so line 7 holds one message and reads correctly. The right one never wipes, so each new message is drawn over the last and the words turn into a smudge. This is why a program that seems to display nonsense is usually displaying the truth — several times over.
Where the writing goes
There are two blocks for writing text, and they describe where in two completely different ways. Watch one message move around the screen under both of them.
clear display
write READY at line 1
write READY at x: – y: – with font normal black
the screen is 178 pixels across and 128 down
0x · across0y · down1line
write [READY] at line (1). Line 1 is the top of the screen, hard against the left edge.The same block, with line 4. Same words, three lines further down — the lines are evenly spaced, about ten pixels apart.Line 8 is as far as the line block goes, and that is only part of the way down. The bottom of the screen is out of its reach.So here is the other block: write [READY] at x: (0) y: (0). That has landed in exactly the same place as line 1 — because x: 0 y: 0 IS the top-left corner.x is how far across, from the left. x: 90 moves it towards the middle.y is how far DOWN, from the top. y: 110 is near the bottom — a bigger y means lower, and that is the one that catches everybody.Finished. Two blocks, two ways of saying where — and one of them can reach the whole screen.
line 1
The arrows are the two numbers. The one along the top is x; the one down the side is y, and it counts downwards from the top edge.
Writing on a line
write [EV3] at line (1) is the simple one. You give it a line number and it puts the text there, starting hard against the left edge — you do not choose how far across, only how far down.
Line 1 is the top. The numbers count downwards, so line 2 is below line 1, not above it.
There are eight of them, each about ten pixels lower than the last. That means all eight sit in the upper part of the screen and the line block cannot reach the bottom at all.
One message per line. Two messages sent to the same line land on top of each other and turn into a smudge — put them on different lines, or clear the screen in between.
For most robots this is all you need: a status word on line 1, a reading on line 3, a warning on line 5. Pick your lines at the start and keep each one for one job, the way you would keep one colour of status light for one meaning.
Writing at x and y
write [EV3] at x: () y: () with font [] treats the screen as a grid of pixels — 178 across and 128 down — and lets you put the text anywhere on it.
x is how far across, from the left edge. x: 0 is the far left; x: 177 is the far right. Bigger x moves right, which is what everybody expects.
y is how far down, from the top edge. y: 0 is the very top; y: 127 is the bottom. Bigger y means lower — this is the one that catches people out, because on a graph at school a bigger y means higher.
The corner is 0, 0. x: 0 y: 0 is the top-left, and it puts the text in exactly the same place as at line 1 — the two blocks are describing the same screen.
The pair of numbers is the top-left corner of the text, not its middle. The letters go down and to the right from the point you name.
The block ends with a font dropdown, and normal black is the usual choice. A larger font makes the writing easier to read from across the room but takes more room across the screen, so fewer characters fit before the text runs off the edge.
Which one to use
Use lines for ordinary status messages — quick to write, impossible to get wrong, and eight of them is plenty for one robot.
Use x and y when the position itself matters: putting a label and its number side by side, lining a heading up over a reading, filling the lower part of the screen, or moving something across the screen as a value changes.
Putting a number on the screen
The text slot of either block will take a reporter, so a sensor value can be shown directly: drop (4 distance in cm) into the slot and the screen shows the reading. That is the EV3’s version of a print statement, and it is the fastest way to find out what a robot actually thinks it is seeing.
A bare number on its own is hard to read, though. To show DIST: 23 rather than 23, use the operator block join [DIST: ] () to glue the label to the value, and put the join into the write block’s text slot.
when program starts :: events hat
clear display :: display
forever
write (join [DIST: ] ([4 v] distance in [cm v] :: sensors)) at line (1) :: display
end
Note the forever: a value written once is a value from the start of the program. To watch a reading change, the write block has to be inside a loop.
Advanced — a dashboard, not a number
Once one value is on the screen the rest follows, and the useful trick throughout is join: it glues two pieces of text together and hands the result to the write block. Anything that reports a value can go in either slot — a variable, a sensor, or another join.
A variable with a label on it
Counting is the classic case. A variable counts how many times the Touch Sensor has been pressed, and a bare 5 on the screen tells nobody anything — PRESSED: 5 tells them everything:
when program starts :: events hat
clear display :: display
set [count v] to (0) :: variables
forever
wait until <[1 v] is pressed? :: sensors>
change [count v] by (1) :: variables
write (join [PRESSED: ] (count)) at line (1) :: display
wait until <not <[1 v] is pressed? :: sensors>>
end
The two wait until blocks are what make it count presses rather than counting as fast as the loop runs while your finger is down. That is the Touch Sensor’s own lesson, but it shows up here because a counter on the screen is where you first notice it going wrong.
Several sensors, one line each
Give every reading its own line and keep it. A line that changes meaning halfway through a program is unreadable at a glance, which is the only speed a screen on a moving robot gets read at.
when program starts :: events hat
clear display :: display
forever
write (join [DIST: ] ([4 v] distance in [cm v] :: sensors)) at line (2) :: display
write (join [DEG: ] ([A v] degrees counted :: sensors)) at line (5) :: display
end
degrees counted is worth putting on the screen the first time you use it — it is the fastest way to find out whether a motor is turning as far as you think it is, and it is the block behind every “why did it stop early” question.
Turning a number into a word
Sensors report numbers, and people read words. The Colour Sensor reports 5; the person watching wants RED. A chain of if … then … else blocks does the translation, and it is worth doing once into a variable rather than in every write block:
if <([3 v] color :: sensors) = (5)> then
set [name v] to [RED] :: variables
else
if <([3 v] color :: sensors) = (4)> then
set [name v] to [YELLOW] :: variables
else
set [name v] to [OTHER] :: variables
end
end
write (join [COLOR: ] (name)) at line (4) :: display
The same shape turns a distance into a warning. Here the screen carries the number and what the number means, which is what lets somebody across the room tell whether the robot is about to hit something:
if <([4 v] distance in [cm v] :: sensors) < (10)> then
set [status v] to [TOO CLOSE!] :: variables
else
if <([4 v] distance in [cm v] :: sensors) < (30)> then
set [status v] to [OBSTACLE FOUND] :: variables
else
set [status v] to [NOTHING FOUND] :: variables
end
end
write (status) at line (3) :: display
Drive all four of those at once below. The screen is the real thing — five write blocks, five lines, and every one of them a join.
Drive the sensors and read the screen. Every line is one write block with a join in its text slot.
24 cm
180°
Colour Sensor5 → RED
Touch Sensor3 presses
Line
What goes in the write block
On the screen now
1
join "PRESSED: " (count)
PRESSED: 3
2
join "DIST: " (4 distance in cm)
DIST: 24
3
(status) — set by the if chain
OBSTACLE FOUND
4
join "COLOR: " (name)
COLOR: RED
5
join "DEG: " (A degrees counted)
DEG: 180
Line 4 says COLOR: RED, but the sensor only ever said 5. The if chain in between is what turns a number into a word.
Advanced — stopping the screen from flickering
The moment a reading goes inside a loop, one of two things goes wrong, and which one depends on where the clear display block went.
Almost everybody tries clear inside the loop first. It gives the right text — and a screen that blinks several times a second, because between the clear and the write there is genuinely nothing on the screen and the loop goes round faster than your eye.
So the clear gets moved to the start of the program, the blinking stops, and the words go wrong. Writing text paints only the characters it has and leaves everything past them exactly where it was. Write RED over YELLOW and the LOW is still there: the screen says REDLOW. Go the other way — yellow first, then red — and it looks fine, which is why this bug takes so long to pin down.
when program starts :: events hat
clear display :: display
forever
write (name) at line (3) :: display
end
YELLOWwhat the sensor says—what the screen says0characters left behind
never blankleftovers survive
The Colour Sensor reads a colour and the name goes on line 3, over and over, inside a forever loop.Rock steady, and wrong. Writing paints only the characters it has, so the tail of the longer word before it is still sitting there.Nothing is misspelled and nothing is broken. Every red character is the tail of a longer word that was never wiped — RED over YELLOW reads REDLOW.Finished. Three programs, one screen, and only one of them is both steady and right.
waiting
Watch the bottom three rows rather than the Brick. They are what the screen is actually doing: old characters, new characters, and whatever survives.
The fix is to make the new text at least as long as the old one, and join already does that: pad it with spaces. RED plus three spaces is six characters — exactly enough to paint over YELLOW. Nothing is left behind, and nothing is ever blank.
write (join (name) [ ]) at line (3) :: display
Pad to the length of the longest thing that line can ever show. Six characters covers RED, BLUE and GREEN but not NOTHING FOUND — count the longest message, and add spaces to match. The same applies to numbers: DIST: 5 after DIST: 40 leaves a stray 0 on the end, so a line that shows a two-digit reading needs a trailing space.
Use clear-inside-the-loop when the whole screen changes at once and a flicker does not matter; use the padding trick whenever a value is being watched.
Advanced — a whole list on the screen
Once several values need showing, the line number becomes a counter and the values come out of a list: write item 1 at line 1, item 2 at line 2, and so on inside a repeat. That needs the list blocks rather than the display blocks, so it lives with them — Lists covers building one and reading it back item by item, and the loop that walks it is the same loop that fills the screen.
Why it matters
Machines in the real world tell you what they are doing: a microwave counts down, a lift shows its floor, a car dashboard warns you. A robot that shows WAITING and then OPEN is far easier to understand — and far easier to debug — than one that moves silently.
Say this back before moving on: “Setting the speed moves nothing. It decides how fast the movements after it will happen.”
What’s in this build 4 min
Look at your model and find the parts with cables. There are only two. Lesson 1 had three.
EV3 Brick × 1
Large Motor × 1
The Dual Gyro's electronics: one Brick, one Large Motor, and nothing else. No sensor at all.
This is a Large Motor, the long one. It is the same kind that drove the wheels in Lesson 1. It is slower than the Medium Motor, but stronger. A launcher needs that. It has to start two tops and three gears moving from still.
What the gears are actually for
The motor turns one big gear in the middle. A smaller gear on each side fits into its teeth. Each small gear carries a top. This means two useful things. You can check both by hand, before you switch the Brick on:
One motor drives both tops. They always turn together, because the same teeth push them.
Both tops turn the same way as each other. They turn the opposite way to the middle gear. Two gears joined to the same middle gear always do this.
Turn the middle gear slowly with a finger, and watch. Does one top turn, but not the other? Then a gear has come apart. Fix it now. Later, it will look just like a program mistake.
Ports — and the rule 4 min
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.
There is only one thing to plug in today. This is the easiest wiring in the course. That makes it easy to be careless, so take care.
Part
Port
Why this one
Large Motor (the launcher)
A
When there is only one motor, we usually use A. That keeps B and C free for driving wheels. Every program on this page says A.
Check your own build now:
Motor cable in port A — a letter, not a number.
Turn the middle gear by hand. Do both tops turn?
Do the tops spin freely, without rubbing the frame or each other? A top that scrapes will fall over at any speed. Then you will blame the wrong thing all lesson.
Connect the Brick 4 min
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.
▶How to connect the BrickUSB and Bluetooth, step by step, with a photograph of every screen. Open it if you have not done this before — or if pairing is not working.Show meHide
USB — the reliable one
Switch the Brick on with the dark grey centre button.
Cable into the Brick’s PC port — the small square socket beside the numbered ports, not one of the numbered ones.
Other end into the computer.
Bluetooth — name it first
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.
Name your Brick. On the Brick: Settings (the spanner) → Brick Name. Type something nobody else will pick, then press the tick. Every Brick is called EV3 until somebody changes it.
Turn Bluetooth on. Settings → Bluetooth. Tick Bluetooth and Visibility. Leave iPhone/iPad/iPod unticked.
Connect from EV3 Classroom. Click the Brick icon at the top of the programming area, find your Brick by name, and click Connect.
Say yes on the Brick. It asks “Connect?” with the computer’s name — choose the tick, then accept the passkey, which is already 1234.
Where to read it. The name sits in the bar across the very top of the screen, on every screen — so you can check which Brick you are holding at any moment without going into a menu. This one is EV3VE. A Brick nobody has renamed says EV3.Step 3, and the reason step 1 exists. Three Bricks in range — read the name before you click Connect. Pairing with the wrong one is not an error: it works perfectly, on somebody else’s robot.
Step 2.Bluetooth switches the radio on; Visibility is what lets the computer find you. With Visibility off your Brick works perfectly and simply never appears in the list.Step 4. Look at the Brick. It asks whether to accept and names the computer. Choose the tick.Then the passkey, already 1234. Press the tick again and you are connected.
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.
Two things often go wrong. The Brick may have gone to sleep. Or you may connect to the next group’s robot. Today that one is easy to spot. Do somebody else’s tops fly off when you press play? Then that is what happened!
Confirm the connection 2 min
Check the Brick icon: connected, or not.
Check the port tiles. You want a motor on A, and nothing anywhere else.
Now the useful bit. The motor tile shows a number called degrees counted. It counts how far the motor turns. Turn the middle gear by hand and watch it change.
Does that number stay still when the gear moves? Then stop here. The cable is in the wrong port, or not pushed all the way in. Nothing later in this lesson can work until you fix it.
A motor does not only turn. It also counts how far it has turned, and tells the Brick. So that number is the quickest way to check a cable is good. You can check it before any block runs.
Change it and test 8 min
Make one change at a time, and predict before each run. Predict means guess what will happen. Start the tops the same way every time: same spot, same table. If not, you are testing the table, not the speed.
Change the motor block only to 30 %. Leave the screen line alone. Predict: will the tops still stand? Then run it.
Now look at the screen. It still says SPEED 75, but that is wrong! The two numbers are not joined. The screen only shows what you typed. It knows nothing about the motor. Fix it, and remember: one change often means two edits.
Try 100 % in both places. Do the tops go further, spin longer, or both?
Put the speed back to 75 and cut the movement to 1 rotation. Predict first. Does a shorter run launch them at all?
This last one is the most important. Drag the set speed block below the run block. The program still says 75 %, but too late. Predict what the motor does, then run it.
Think about step 4. Fewer rotations means a shorter launch, but not a softer one. The tops still fly off at the speed you set. Distance and speed really are two separate dials. Step 5 shows what happens when you set the speed too late.
Do the tops fall over at once, at every speed? Then the problem is probably not the program. Check that both tops sit flat on their gears. Check that nothing rubs. Check that the table is not sloping. Then test the speeds again.
Build it 15 min
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.
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 cartoon of the mission: what your program should make the robot do.
The program, block by block
Motor A · Speed 100% · Sensors none
What it does
Holding the centre button runs the launcher motor at full speed, spinning both tops.
Letting go stops the motor. Two stacks
share the one button: one listens for pressed, the other for released.
Worth noticing
Speed comes before the movement.Set speed to 100% sits above start motor, so the
motor starts at the speed it was given.
Start, not run for.Start motor keeps turning until something stops it. That is why
the motor runs for as long as the button is held.
Pressed and released are two different events. The second hat's dropdown says
released. Without that stack, the motor never stops.
Speed is a dial, not a distance. 100% says how fast, not how far.
Challenges 27 min
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.
Challenge 1
- When Center Button is pressed, play a sound "okey-dokey", then the motor turns clockwise.
- When Center Button is released, stop motor and play a sound "bravo".
Fullscreen it while you build — you can pause and scrub with the player's own controls.
Log in to see hints.
Challenge 2
- When Up button is pressed, speed increases by 5, display the new speed.
- When Down button is pressed, speed decreases by 5, display the new speed.
- The motor speed must stay between 0% and 100% (it should not go above 100 or below 0).
- Press the center button, the motor turns clockwise at the set speed, release it to stop the motor.
A cartoon of the mission: what your program should make the robot do.
Log in to see hints.
Challenge 3
Set the initial speed to 0
1. When the center button is pressed, the motor will turn clockwise and increase the speed by 10 for every 1 second and update the motor speed on the display.
2. Stop the loop once speed exceeds 100%.
3. Play a countdown sequence ("Three", "Two", "One"), stop motor and exit the program.
A cartoon of the mission: what your program should make the robot do.
Log in to see hints.
Extra challenge
Design your own gyro and test timer better than the original.
1. When the center button is pressed, set the speed to 100% and the motor turns clockwise.
2. When the center button is released, stop motor, reset the timer and continuously display the live timer on the screen.
3. When the up button is pressed, stop the timer and display the final recorded time.