The Scoreboard has two buttons that add points and a reset. It has a screen showing the game, and a motor arm that points at whoever is ahead.
The machine has three sensors, and all three are just switches. Yet nothing measures the numbers people really want. Who is winning? By how much? How fast is the scoring going?
By the end of the lesson your scoreboard will show four numbers. Only two of them are measured. It will also know when one of them is not worth showing.
In the real world 5 min
Where you have seen it
A stadium scoreboard shows the score, which somebody types in. Everything else on it is worked out: the time left, the run rate, the goal difference, possession. No sensor in the building measures “goal difference”. It is a subtraction.
In cricket the required run rate is the most watched number on the ground. It is all worked out: runs still needed, divided by overs left. It changes every ball, and nobody measures anything new.
Why it is built that way
Because raw measurements rarely answer the question people are asking. Nobody wants the two scores. They want to know who is winning and whether it is close. That is a subtraction, and nobody has to be told to do it.
A car does the same thing. Nothing in it measures fuel economy — it measures fuel used and distance travelled, and divides. The number on the dashboard is arithmetic, and it is the one drivers actually look at.
What would go wrong without it
A machine that only shows what it measured makes its user do the thinking. When the useful number is a rate or a trend, most people will not do the sum in their heads. So the facts are there, and nobody uses them.
The most useful number on a display is usually one no sensor produced.
The main concept — computing new numbers 6 min
A derived value is calculated from things you already have. It costs nothing to measure because nobody measures it — and it is very often the number that matters.
Shape
Made from
On this scoreboard
Difference
Two measured values.
lead = score A − score B — who is ahead, and by how much, in one number.
Total
Several values added.
points = score A + score B — how much has happened.
Rate
A value divided by time.
points ÷ minutes — how fast the game is going.
set [lead v] to ((score a) - (score b)) :: variables
set [points v] to ((score a) + (score b)) :: variables
set [minutes v] to ((timer) / (60)) :: variables
set [rate v] to ((points) / (minutes)) :: variables
Four lines. Two of them make numbers that nothing on the machine can measure. Those are the two people will read.
The sign carries information
lead is not just a size. It is a direction too. Positive means A is ahead, negative means B, zero means level. One number replaces three separate checks. The error term did exactly this back in Lesson 5.
Derived once, in one place
Never store a derived value as if it were measured. Say you keep a lead variable and also change it by hand when somebody scores. One day you will update a score and forget the lead. Then the display will be wrong and look sure of itself. Work it out fresh from the scores each time. A value that is always worked out again cannot drift away from its inputs.
This is the same rule as Lesson 8’s: use length of rather than a separate counter. A number derived from another cannot disagree with it.
When a derived value is meaningless
rate is points per minute. Four seconds into a game that is 1 ÷ 0.067, or fifteen points a minute — arithmetically perfect and complete nonsense. And at exactly zero seconds it is a division by zero.
if <(minutes) > (0.5)> then
set [rate v] to ((points) / (minutes)) :: variables
write (rate) at line (7) :: display
else
write [RATE: --] at line (7) :: display
end
Show dashes rather than a number you do not believe. This is what a real scoreboard does for the first over of a cricket match.
Deciding when a computed number should not be shown is part of computing it. A machine that displays nonsense confidently teaches its user to distrust everything else on the screen.
ComponentData6 min
Variables
Why anybody needs one
Long before there were computers, people had exactly this problem. A shepherd counting sheep through a gate, a trader counting sacks of grain, a builder counting days — none of them can hold the number in their head while they get on with the work. So they scratched a mark on a wall, cut a notch in a stick, or wrote a number on a piece of paper. The number lived outside the person, in a place they had agreed on, and they could go back to it, read it, and change it.
Better still, once the number is written down somebody else can use it. Watch these two: one of them counts and writes, the other never sees a single animal and simply reads the wall.
Abby never remembers the numberBen never sees a henThe wall holds it for both
Abby has a gate and a wall. Before a single hen comes through she chalks 0 on the wall — that is where the number is going to live.A hen goes through. Abby rubs out the 0 and chalks 1. Another goes through, and she does it again.Three hens have been through, and the wall says 3. Abby is not remembering the number — she is reading her own wall each time and writing the next one.Ben has been at the market all morning. He has not seen one hen. He walks up, reads the wall, and knows the answer — without asking Abby anything.That is a variable. Not a number in somebody's head, but a place both of them agreed on: one writes to it, the other reads from it, and it keeps the number in between.Finished. Abby wrote, Ben read, and the wall is what joined them up.
the wall holds it
Notice what never happens: Ben never asks Abby. He does not need to — the number is not in her head, it is on the wall, and the wall is there for anyone who needs it.
Neither Abby nor Ben is holding the number — the wall is. And notice what never happens: Ben does not ask Abby. He does not need to, because the count is not in her head. It is in a place they both agreed on, which is what makes it useful to more than one of them.
That is all a variable is. The robot cannot hold a number in its head either, so you give it a wall of its own, write a name at the top so everyone knows which wall is which — score, count, degree_turn — and the program can read what is on it and write something new. One part of the program writes; another part reads. Exactly Abby and Ben.
The paper, and the two things you can do to it
Say we are counting rotations of a motor. Before we start we write 0 on the paper. Every time the motor completes a turn we cross out what is there and write one more: 0 becomes 1, then 2, then 3. That is change — it has to read the old number to work out the new one.
set is the other thing you can do, and it is completely different: rub the whole paper out and write the number you want. It does not care what was there. Press the buttons and watch what happens to the crossings-out.
score
0
The paper starts blank, so we write 0 on it. That is what a variable is: a place to keep a number while the robot works.
change leaves a trail — every value follows from the one before it. This is what counting is.
set wipes the sheet. Use it to start a count, never to continue one.
Press set score to 0 after counting up a few times and watch the whole history vanish. That is what happens to a count when a set block ends up in the wrong place — and it is the commonest variable bug there is.
Blocks reference
Block
What it does
set [count v] to (0)
Puts a value in, replacing whatever was there.
change [count v] by (1)
Adds to what is already there.
(count)
Reports the current value, for use in a comparison or on the display.
Set, or change?
set replaces; change adds. Counting things needs change. Starting a count needs set. Both programs below have both blocks — the only difference is whether the set block is inside the loop or above it.
set before the loop
when program starts
set count to 0
repeat 4
A run clockwise for 1rotations
change count by 1
set inside it
repeat 4
set count to 0
A run clockwise for 1rotations
change count by 1
Before the loop: counted 0Inside the loop: stuck at 0
Both programs count the turns of a motor. The left sets the count to zero before the loop; the right sets it inside.Turn 1. Both counters read 1, and so far the two programs agree.Turn 2. The left count is 2. The right was set back to zero at the top of the loop, so it is 1 again.Turn 3. The left reads 3. The right still reads 1.Turn 4. The motor turned four times on both robots — only one of them counted them.Finished. Four turns, and one of the two counts is fiction.
stopped
Both programs contain both blocks. Only the position of set [count] to 0 is different.
The count on the right is not broken; it is being told to start again on every pass. Each time round the loop it is wiped back to zero and then changed by one, so the honest answer is always 1 — while the motor cheerfully turns four times. A counter stuck at 1 almost always means a set block that has slipped inside the loop.
Anything oval is a number you can pick up
EV3 Classroom tells you what a block does by its shape, and once you have noticed that, a whole set of questions answers itself:
Oval — reports a number. The blue degrees counted, the timer, a distance, your own variable.
Pointed — reports true or false. These go in an if or a wait until, not in a variable.
Block-shaped — does something. These stack up; they do not fit inside anything.
So when a slot is oval, any oval fits it — and it does not matter in the least where that number came from. You can take the motor’s own A degrees counted and keep it in a variable you named degree_turn, then compare that with a number later. Pick an oval below and watch the same one drop into all three kinds of slot.
pick an oval
the same oval fits all three
set degree_turn to A degrees countedkeep it in a variable of your own
A degrees counted+10do arithmetic with it
A degrees counted>50compare it with a number
Every one of those slots is oval-shaped, and A degrees counted is an oval — so it drops in. Nothing about where the number came from matters.
This is what makes a variable more than a counter. A sensor reading is true only at the instant you read it; copying it into a variable freezes it, so the robot can compare where it is now against where it was when something happened:
when program starts :: events hat
[A v] reset degrees counted :: motors
set [degree_turn v] to ([A v] degrees counted :: sensors)
start moving [right: 30] :: movement
wait until <(([A v] degrees counted :: sensors) - (degree_turn)) > (400)>
stop moving :: movement
Read the condition aloud: how far the motor has gone now, minus where it was when we started, is more than 400. Both are ovals, so both can go into a subtraction, and the subtraction is an oval too — which is why it can go into a comparison. Ovals nest inside ovals as deep as you need.
Reset at the start, every time
A variable keeps its value after the program ends. Run the program again without setting it back and the second run begins where the first left off — the count starts at 14, the robot thinks it has already done the job. Every variable a program changes must be set to its starting value at the top.
Why it matters
A variable is the difference between a machine that repeats a fixed routine and one that responds to how things have gone — counting parts, tracking a score, remembering where it started.
ComponentControl5 min
Comparing and combining
A sensor that reports a number cannot be used to make a decision on its own — 23 is neither true nor false. An operator turns that number into an answer by comparing it with something.
Blocks reference
Block
What it does
<(x) > (50)>
True when the left value is bigger than the right.
<(x) < (50)>
True when it is smaller.
<<> and <>>
True only when both conditions are true.
<<> or <>>
True when at least one of them is.
Try it: which way round does it go?
Forget the symbols for a moment. A comparison is a question about position on a number line: is x to the left of the other number, or to the right? Left is smaller, right is bigger — and that is the whole of it.
Drag the orange x and the black marker, and change the comparison. The green stretch is every position of x that would make the answer true — so you can see where the answer flips before you get there. Turn not on and watch the green jump to the other side.
Drag either marker, or use the arrow keys.
-3 < 4true
is x to the LEFT of it?
< is true while x sits on the left. Slide x past the marker and it flips.
> is the same question the other way round — so exactly one of the two is true, unless the markers are on the same spot.
= is true for one single position out of twenty-one. Try landing on it. That is why a sensor is almost never compared with =: a reading passes straight through the exact number without ever being measured there.
not flips the answer, whatever it was. not (x < 4) covers everything x < 4 does not — including landing exactly on 4.
Try it: which numbers make it true?
The lab above asks one question at a time: is this x true? A robot never has just one x, though — a sensor reading slides up and down all the time, so what really matters is which stretch of the line makes the condition true. This one draws the whole answer at once.
Drag the circle to move the number you are comparing against, and change the comparison. Everything shaded green is a value of x that would make it true.
Drag the circle, or use the arrow keys. It moves in steps of 0.2.
x < 0.2x < 0.2
Every number to the left of 0.2 — but not 0.2 itself, so the circle is hollow.
Watch the circle, because it carries the part everyone gets wrong:
Hollow ○ — the boundary is not included. x < 0.2 shades everything left of 0.2 but leaves 0.2 itself out, because 0.2 is not less than 0.2.
Filled ● — the boundary is included. Choose = and nothing is shaded at all: one single number qualifies.
Now turn not on with x > 2 selected and watch two things happen together. The shading jumps to the other side, and the circle fills in — because “not greater than 2” means 2 or less, and 2 has to be part of it. That pairing is the whole reason a hollow circle is worth drawing.
Why a robot cares. Two conditions that look almost identical — light < 30 and not (light > 30) — differ by exactly one value, the reading of precisely 30. A robot sitting right on its threshold behaves differently under the two, and that is the sort of bug that only shows up occasionally and looks like a broken sensor.
Try it: and, or, not
These three join answers together rather than numbers. The trap is that English is looser than a program: “stop if it is close and the bumper is pressed” sounds like it covers both situations, when it covers neither on its own.
Flip the two conditions and watch the table. There are only four possible situations in total, and and and or differ on exactly two of them.
close: trueandbumper: falsefalse
close
bumper
and
or
true
true
true
true
true
false
false
true
false
true
false
true
false
false
false
false
and is fussy: it wants both. Three of the four rows are false.
and is true on one row out of four. It narrows — the robot acts less often, but more certainly.
or is true on three rows out of four. It widens — the robot acts more readily.
The two agree on the top and bottom rows and disagree in the middle. Whenever swapping one for the other seems to make no difference, you have only tried the rows where they agree.
Watch them decide
Two sensors are running below: an Ultrasonic reporting a number, and a Touch Sensor reporting true or false. Watch the comparison turn the number into an answer, and watch and and or disagree.
when program starts
forever
if distance < 15 and is pressed? then
stop moving
if distance < 15 or is pressed? then
play beep 60 for 0.2 seconds
Nothing is within 15 cm and the bumper is out. Both conditions are false.Something comes close. The comparison flips to true — the bumper has not been touched.It backs away, and instead the bumper is pressed. Now the other condition is the true one.Close AND pressed. Only now is «and» true — while «or» has been true ever since the first of them was.Finished. Four situations, and the two operators disagreed in three of them.
and false · or false
and was true in one row out of four. or was true in three. That is the whole difference, and it is why one of them makes a robot look broken.
The comparison is doing one job: it takes a reading that is neither true nor false and, by holding it against a number you chose, produces something a decision can use. The moment the blue fill crosses the black marker is the moment the answer changes.
Choosing the threshold
The number you compare against is a design decision, not a fact. “Close” for a parking sensor might be 15 cm; for a robot arm it might be 3. Pick it by measuring what the sensor actually reads in the situation you care about, then leave a margin.
Combining two conditions
and narrows: both must hold, so the robot acts less often but more certainly — stop only if something is close and the bumper is pressed. or widens: either will do, so the robot acts more readily — stop if something is close or the bumper is pressed.
In the four situations above, and was true in one of them and or in three. That is the practical difference: swapping one for the other does not adjust a robot slightly, it changes how often it reacts at all.
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.
Compute it fresh from what you measured, and know when it is too early to mean anything.
▶OperatorsFrom Level 2 — arithmetic on measurements, and how the blocks nest.Show meHide
ComponentControl5 min
Comparing and combining
A sensor that reports a number cannot be used to make a decision on its own — 23 is neither true nor false. An operator turns that number into an answer by comparing it with something.
Blocks reference
Block
What it does
<(x) > (50)>
True when the left value is bigger than the right.
<(x) < (50)>
True when it is smaller.
<<> and <>>
True only when both conditions are true.
<<> or <>>
True when at least one of them is.
Try it: which way round does it go?
Forget the symbols for a moment. A comparison is a question about position on a number line: is x to the left of the other number, or to the right? Left is smaller, right is bigger — and that is the whole of it.
Drag the orange x and the black marker, and change the comparison. The green stretch is every position of x that would make the answer true — so you can see where the answer flips before you get there. Turn not on and watch the green jump to the other side.
Drag either marker, or use the arrow keys.
-3 < 4true
is x to the LEFT of it?
< is true while x sits on the left. Slide x past the marker and it flips.
> is the same question the other way round — so exactly one of the two is true, unless the markers are on the same spot.
= is true for one single position out of twenty-one. Try landing on it. That is why a sensor is almost never compared with =: a reading passes straight through the exact number without ever being measured there.
not flips the answer, whatever it was. not (x < 4) covers everything x < 4 does not — including landing exactly on 4.
Try it: which numbers make it true?
The lab above asks one question at a time: is this x true? A robot never has just one x, though — a sensor reading slides up and down all the time, so what really matters is which stretch of the line makes the condition true. This one draws the whole answer at once.
Drag the circle to move the number you are comparing against, and change the comparison. Everything shaded green is a value of x that would make it true.
Drag the circle, or use the arrow keys. It moves in steps of 0.2.
x < 0.2x < 0.2
Every number to the left of 0.2 — but not 0.2 itself, so the circle is hollow.
Watch the circle, because it carries the part everyone gets wrong:
Hollow ○ — the boundary is not included. x < 0.2 shades everything left of 0.2 but leaves 0.2 itself out, because 0.2 is not less than 0.2.
Filled ● — the boundary is included. Choose = and nothing is shaded at all: one single number qualifies.
Now turn not on with x > 2 selected and watch two things happen together. The shading jumps to the other side, and the circle fills in — because “not greater than 2” means 2 or less, and 2 has to be part of it. That pairing is the whole reason a hollow circle is worth drawing.
Why a robot cares. Two conditions that look almost identical — light < 30 and not (light > 30) — differ by exactly one value, the reading of precisely 30. A robot sitting right on its threshold behaves differently under the two, and that is the sort of bug that only shows up occasionally and looks like a broken sensor.
Try it: and, or, not
These three join answers together rather than numbers. The trap is that English is looser than a program: “stop if it is close and the bumper is pressed” sounds like it covers both situations, when it covers neither on its own.
Flip the two conditions and watch the table. There are only four possible situations in total, and and and or differ on exactly two of them.
close: trueandbumper: falsefalse
close
bumper
and
or
true
true
true
true
true
false
false
true
false
true
false
true
false
false
false
false
and is fussy: it wants both. Three of the four rows are false.
and is true on one row out of four. It narrows — the robot acts less often, but more certainly.
or is true on three rows out of four. It widens — the robot acts more readily.
The two agree on the top and bottom rows and disagree in the middle. Whenever swapping one for the other seems to make no difference, you have only tried the rows where they agree.
Watch them decide
Two sensors are running below: an Ultrasonic reporting a number, and a Touch Sensor reporting true or false. Watch the comparison turn the number into an answer, and watch and and or disagree.
when program starts
forever
if distance < 15 and is pressed? then
stop moving
if distance < 15 or is pressed? then
play beep 60 for 0.2 seconds
Nothing is within 15 cm and the bumper is out. Both conditions are false.Something comes close. The comparison flips to true — the bumper has not been touched.It backs away, and instead the bumper is pressed. Now the other condition is the true one.Close AND pressed. Only now is «and» true — while «or» has been true ever since the first of them was.Finished. Four situations, and the two operators disagreed in three of them.
and false · or false
and was true in one row out of four. or was true in three. That is the whole difference, and it is why one of them makes a robot look broken.
The comparison is doing one job: it takes a reading that is neither true nor false and, by holding it against a number you chose, produces something a decision can use. The moment the blue fill crosses the black marker is the moment the answer changes.
Choosing the threshold
The number you compare against is a design decision, not a fact. “Close” for a parking sensor might be 15 cm; for a robot arm it might be 3. Pick it by measuring what the sensor actually reads in the situation you care about, then leave a margin.
Combining two conditions
and narrows: both must hold, so the robot acts less often but more certainly — stop only if something is close and the bumper is pressed. or widens: either will do, so the robot acts more readily — stop if something is close or the bumper is pressed.
In the four situations above, and was true in one of them and or in three. That is the practical difference: swapping one for the other does not adjust a robot slightly, it changes how often it reacts at all.
Say this back before moving on: “What do they actually want to know?”
What’s in this build 4 min
Find the three switches. Then decide, before you program anything, what the four most useful numbers on this board would be.
Part
What it is doing here
EV3 Intelligent Brick
The board itself. For the first time in the course the screen is the product. Everything else is there to put numbers on it.
Medium Motor — the indicator
Points at whoever is ahead. It is driven by a derived value, not a measured one — the lead, sign and all.
Touch Sensor ×2 — the score buttons
One per team. The only two things this machine actually measures.
Touch Sensor — reset
Starts a new game. It must clear the clock as well as the scores, or every rate afterwards is wrong.
The indicator arm (not electronic)
Must swing both ways from centre. Centre means level, and if it cannot reach centre the board cannot show a draw.
Keep the two score buttons far apart and clearly labelled. Excited people will press them quickly. A scoreboard that gives points to the wrong team is worse than no scoreboard.
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.
Part
Port
Why this one
Indicator (Medium)
A
The only motor.
Team A scores (Touch)
1
Team A on port 1 — the numbering matches, which prevents mistakes.
Team B scores (Touch)
2
Team B on port 2.
Reset (Touch)
3
Deliberately last, and worth mounting away from the other two.
Check your own build now:
Indicator in A, buttons in 1, 2 and 3.
Press each and confirm the right tile responds. A swapped pair gives points to the wrong team, and nothing on screen will look wrong.
Centre the indicator arm and note it as zero — a level game.
Swing it fully both ways and note the degrees. That is the largest lead the board can show.
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.
Download and unplug. A scoreboard is used by people standing round it, not by somebody at a laptop. And the last challenge asks you to hand it to the people watching.
Confirm the connection 2 min
Check the Brick icon: connected, or not.
One motor tile — A.
Three sensor tiles — 1, 2 and 3.
Swing the indicator to each extreme and note the degrees. You need that to map a lead onto an arm angle — which is Lesson 17, arriving in a lesson about arithmetic.
Stuck? The long version, with a photograph of every screen, is in the Brick & Bluetooth guide.
Change it and test 8 min
One change at a time. Predict, then run, then look.
Remove the rate guard. Press a button one second in and look at the number. Perfect arithmetic, complete nonsense — and it looks exactly as trustworthy as a real one.
Store the lead instead of deriving it. Update it in the button stack when A scores, but forget on purpose to update it when B scores. Play a game and watch the board contradict itself. Then go back to deriving it.
Add a fifth number: the biggest lead so far. That one has to be remembered rather than derived — it depends on history, not on the current scores. Say why it is different from the other four.
Add points per minute for each team separately and show which is scoring faster. Two more derived numbers, no new sensors.
Reset without clearing the timer. Play a second game and watch the rate. Then fix it, and say in one sentence what a derived value depends on besides its inputs.
Derive it, do not store it. And if it is too early to mean anything, show dashes.
Where this goes 3 min
Your scoreboard does one thing at a time, in order, and everything it does is equally important.
The next model is not like that. An insect walking across a table has a plan: get to the other side. It also has a reflex: something is in the way, stop now. Those two are not equal, and they cannot politely take turns.
When two behaviours want the machine at the same moment, one of them has to win. It must be the same one every time. The next lesson is about choosing which one, and making the fast one always beat the slow one.
Today the machine worked out what to say. Next it works out what matters most.
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.
This is what you are building: the EV3 Electrical Scoring Board.
Make it move 10 min
One stack measures — it watches three buttons and does nothing else. Another computes and displays, and never reads a sensor.
```ev3blocks Two measured numbers, four derived ones. The arm swings left or right without any rule deciding a direction — the sign of lead does it.
when program starts :: events hat
set [score a v] to (0) :: variables
set [score b v] to (0) :: variables
[A v] reset degrees counted :: motors
reset timer :: control
clear display :: display
// ---- the only stack that touches a sensor ----
when program starts :: events hat
forever
if <[1 v] is pressed? :: sensors> then
change [score a v] by (1) :: variables
play sound [Mechanical / Blip 2 v] :: sound
wait until <not <[1 v] is pressed? :: sensors>> :: control
end
if <[2 v] is pressed? :: sensors> then
change [score b v] by (1) :: variables
play sound [Mechanical / Blip 4 v] :: sound
wait until <not <[2 v] is pressed? :: sensors>> :: control
end
if <[3 v] is pressed? :: sensors> then
set [score a v] to (0) :: variables
set [score b v] to (0) :: variables
reset timer :: control
wait until <not <[3 v] is pressed? :: sensors>> :: control
end
end
// ---- everything here is derived. no sensor is read. ----
when program starts :: events hat
forever
set [lead v] to ((score a) - (score b)) :: variables
set [points v] to ((score a) + (score b)) :: variables
set [minutes v] to ((timer) / (60)) :: variables
write (score a) at line (1) :: display
write (score b) at line (2) :: display
write (lead) at line (4) :: display
if <(minutes) > (0.5)> then
write ((points) / (minutes)) at line (6) :: display
else
write [RATE --] at line (6) :: display
end
if <(lead) > (0)> then
write [A AHEAD] at line (8) :: display
end
if <(lead) < (0)> then
write [B AHEAD] at line (8) :: display
end
if <(lead) = (0)> then
write [LEVEL] at line (8) :: display
end
// the indicator is driven by a derived value, sign and all
[A v] run to position ((lead) * (25)) [degrees v] at (30) % speed :: motors
end
1. **`lead` is recomputed every pass, never stored by the button stack.** It cannot get out of step with the scores, because it is made from them.
2. **The rate is suppressed for the first thirty seconds.** Dashes are more honest than a number nobody should act on.
3. **The indicator uses the sign.** No `if` chooses a direction — a negative lead gives a negative angle. Lesson 5's error term in a completely different setting.
4. **Reset clears the clock as well as the scores.** Forget that and the second game's rate is computed over the first game's time.
**What success looks like:** press A twice and B once. The board shows 2, 1, a lead of 1 and "A AHEAD". The arm swings one step to the left. The rate shows dashes at first and then a sensible number.
> **If the arm swings the wrong way**, your motor is mounted mirrored — negate the 25 rather than adding a rule. **If the rate is enormous**, you are dividing by seconds somewhere instead of minutes.
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
Add two more derived numbers. A derived number is one worked out from other numbers.
Show the total points scored by both teams. Show points per minute for each team on its own.
No new sensors. Say out loud where each of the four numbers on your board came from.
Challenge 2
Store the lead instead of deriving it.
Keep a lead variable and update it when A scores. But on purpose, forget to update it when B scores. Play a game and watch the board disagree with itself.
Then go back to deriving it. Write one sentence on why a derived value cannot drift.
Challenge 3
Add a number that CANNOT be derived.
Show the biggest lead either team has had all game.
That one has to be remembered, because it depends on what happened before, not on the scores now. Explain in one sentence how it is different from the other four.
Extra challenge
Build a board that tells the crowd something they had not noticed.
As well as the two scores, it must show at least four derived numbers. At least one must be something a person watching would not work out in their head.
It must have:
1. Every derived value is worked out again from its inputs each time round the loop. Nothing derived is stored and updated by hand.
2. A value that means nothing early in the game shows dashes until it means something. You can say where you drew that line.
3. The motor indicator is driven by a derived value, plus or minus sign and all. No rule picks a direction.
4. Reset clears everything a new game should not keep, including the clock.
Then run a real game with it, like table football or a card game. Afterwards, ask the players which number they looked at most. It will usually not be the score. Write down which it was and why.