Challenge 1
Make the machine say which mode it is in. The screen must read READY when it is waiting, SINGLE while a single shot is firing, and AUTO while continuous fire is running — changing at the moment the behaviour changes, not before or after.
What you are building 3 min
The EV3 Machine Gun: a motor and a rubber band flick LEGO bricks out of a magazine, one after another. Two Touch Sensors control it — one fires a single shot, the other keeps firing while you hold it down.
Every model so far has had at most one sensor. That has made the ports rule easy to obey and impossible to understand: with one Touch Sensor there is only one place it can go.
Today you have two of them. They are the same part, the same shape, the same colour — physically identical. The only thing in the entire system that knows them apart is which socket the cable is in.
In the real world 5 min
Where you have seen it
The mechanism in your model — store energy, release it to fire one thing, reload, repeat — is not really a weapon mechanism. It is a nail gun, and there is one on every building site in the country.
Why it is built that way
A nail gun has a magazine of nails, a store of energy — compressed air or a spring — and a mechanism that lets exactly one nail’s worth of that energy out at a time. Then a spring pushes the next nail into place and it is ready again.
Here is the part that matters today. A real nail gun has two controls, and they are deliberately different. There is a sequential mode, where you must press and release for each nail, and a bump mode, where holding the trigger fires one every time the nose touches wood. Roofers use the fast one. Anyone doing careful work uses the single-shot one.
What would go wrong without it
Now imagine the two controls wired the wrong way round. You press what you believe is the careful single-shot trigger and the tool empties its magazine.
Nothing about the tool would look wrong. Both triggers are triggers. The mistake would be invisible until the moment it mattered — and that is exactly the mistake you can make today, because your two sensors are identical and the cables are not labelled.
When two parts are identical, the port is the only thing that tells them apart — so the port stops being a rule and becomes information.
Before you build 1 min
This model has no step-by-step manual, and the video below is not one. It is a film of a finished machine working. Watch it for the target — especially for where the two switches sit — then build from the model your teacher has, or from a photograph of a finished one. You are not missing a page; the page does not exist.
The main concept — the port is the name 6 min
Two Touch Sensors. Same part, twice. Nothing on either one says which is which.
the one in port 1the one in port 2When your program says [1 v] wait until [bumped v], the Brick does not look for “the single-shot trigger”. It has never heard of such a thing. It looks at socket number 1 and reads whatever is plugged into it.
| What you mean | What the Brick understands |
|---|---|
| “the single-shot trigger” | port 1 |
| “the rapid-fire trigger” | port 2 |
So swapping the two cables does not break the program. It silently swaps the two behaviours — everything still runs, nothing reports an error, and the machine simply does the wrong thing on the wrong button. That is a worse kind of bug than a crash, because a crash tells you where to look.
The port table, and why it is bent today
All course the sensor ports have had fixed jobs: Touch on 1, Gyro on 2, Colour on 3, Ultrasonic on 4. That convention exists so a program written by one group runs on another group’s robot.
This model has two of one kind, so the second sensor has to borrow a port from the table. It goes in 2. That is fine — there is no Gyro here to argue with — but it is a decision, and the rule to keep is the one underneath:
The program and the cables must agree. Which port you choose matters far less than writing it down and wiring it that way.
The Touch Sensor, in fullPressed, released and bumped, and the trap in asking is-pressed inside a loop. Open it if any of that is not clear yet.Show meHide
The Touch Sensor
The Touch Sensor is the simplest input the EV3 has: a button that is either pressed or not. That sounds trivial, but it is how a robot knows it has hit a wall, reached the end of a track, or been told to start by a person.
released
pressedBlocks reference
| Block | What it does |
|---|---|
wait until <[1 v] is pressed? :: sensors> | Holds the program here until somebody presses the sensor. |
<[1 v] is pressed? :: sensors> | Reports true or false. Drop it into a condition to make a decision rather than a wait. |
[1 v] when [bumped v] :: events hat | Starts a whole stack of its own. The dropdown chooses the moment: pressed, released or bumped. |
Three different events
A button is not only “pressed”. One press is three things: the moment it goes down, the time it stays down, and the moment it comes back up. Watch what a single press does to three programs at once.
when program starts
forever
if 1 is pressed? then
change count by 1
versus two hat blocks
1 when pressed
1 when bumped
0is pressed? in a loop0when pressed0when bumped
In a loop: 0 answers from one pressBumped: exactly one
Nobody is touching the sensor. All three programs are watching it.
The middle counter is the one that surprises people. Nothing is wrong with it — a loop really does check that fast, and every check really is a separate answer.
Nothing there is broken. A loop really does get round hundreds of times a second, and each time it asks is pressed? the honest answer is still yes — so if that loop plays a sound or counts something, it does it hundreds of times from one finger. The two hat blocks each fire once, and they fire at different moments: pressed the instant the button goes down, bumped only when it comes back up.
The three options, and what each is for:
- Pressed — the button is down right now. Good for “hold to run”.
- Released — it is up again. Good for acting when somebody lets go.
- Bumped — pressed and released. This is what you want for “click to start”, because it will not fire repeatedly while a finger stays down.
The classic bumper
when program starts :: events hat set movement motors to [B v] and [C v] :: movement start moving [straight: 0] :: movement wait until <[1 v] is pressed? :: sensors> stop moving :: movement
The robot drives until something presses the sensor. Note that the movement is started unmeasured on purpose — the sensor decides when to stop, not a distance.
Why it matters
Touch sensors are everywhere in machines you cannot see into: a lift knows the doors are shut, a printer knows the lid is closed, a washing machine will not spin until it is latched. They are safety devices as much as inputs.
Say this back before moving on: “The Brick does not know which sensor is which. It only knows which port.”
What’s in this build 4 min
Four parts with cables — the most of any model so far. And once again you have to tell us which motor it is: this model has no manual, and the catalogue’s own notes disagree with themselves about it.
Large Motor
Medium Motor| Part | What it is doing here |
|---|---|
| EV3 Intelligent Brick | Runs the program and holds the machine steady while it fires. |
| One motor — you decide which | Drives the firing mechanism through the rubber band. Whichever it is, it goes in port A. |
| Touch Sensor ×2 | The two triggers. Identical parts; the ports give them their jobs. |
Label them before you plug them in
This takes thirty seconds and it will save you the whole lesson.
- Decide which physical sensor is the single shot one. Usually the one nearest your firing hand.
- Put a small piece of tape on its cable, near the plug, and write 1 on it.
- Tape the other cable and write 2.
- Now plug them into the matching numbered ports — and from here on they can never get confused, because the cable tells you.
This is what real engineers do. Every wiring loom in every machine you have ever used has labels on it, for exactly the reason you just met: identical parts, different jobs, no way to tell by looking.
Ports — and the rule 4 min
Sensors go in ports 1, 2, 3, 4. Motors go in ports A, B, C, D. They are not interchangeable, and nothing will tell you politely if you swap them.
| Part | Port | Why this one |
|---|---|---|
| The motor (drives the firing mechanism) | A | A single working motor takes A, as it has all course. |
| Touch Sensor — single shot | 1 | Touch is always port 1 in this course. |
| Touch Sensor — rapid fire | 2 | Borrowed from the Gyro’s usual slot, because this model has no Gyro and needs a second number. |
Check your own build now:
- Motor cable in A. A letter.
- The sensor you labelled 1 in port 1, and the one you labelled 2 in port 2. Read the tape, do not guess.
- Press each button in turn and say out loud which one you just pressed. If you cannot answer confidently, go back and label them.
- Load the magazine and point the machine at a clear space — not at a person, not at a window.
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
EV3until 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.
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.
Four cables on one Brick gets crowded. Route them so none crosses the firing path and none can be tugged out when the machine jumps — because it will jump.
Confirm the connection 2 min
This is the most useful confirm step in the whole course, because it is the one that catches a swap.
- Check the Brick icon: connected, or not.
- Port A shows a motor. Note which kind, and check it against section 5.
- Ports 1 and 2 both show a Touch Sensor.
- Now the important one. Press the sensor you labelled 1 and watch which tile changes. It must be tile 1. Then press the other and watch tile 2.
- If the wrong tile lit up, your cables are crossed. Swap them now — at this point it costs five seconds, and after you have written the program it will cost you twenty minutes of blaming your blocks.
You cannot tell a swapped pair apart by looking at the model or by reading the program. This screen is the only place it shows.
Make it move 10 min
Eight blocks — the longest program in Level 1, and every one of them earns its place. Trigger 1 fires once. Trigger 2 starts continuous fire, and pressing it again stops.
when program starts :: events hat [A v] set speed to (100) % :: motors [1 v] wait until [bumped v] :: sensors [A v] run [clockwise v] for (1) [rotations v] :: motors [2 v] wait until [bumped v] :: sensors [A v] start motor [clockwise v] :: motors [2 v] wait until [bumped v] :: sensors [A v] stop motor :: motors
Walk it in the order the Brick runs it:
- set speed to 100 % — a setting, not an action. It has to be here, before anything turns. That was Lesson 21.
- [1] wait until bumped — the program stops until the port-1 trigger is clicked.
- run clockwise for 1 rotation — one shot. It has an ending built in, so the program waits for the shot to finish.
- [2] wait until bumped — now it waits for the other trigger. Note the number is the only thing that changed.
- start motor clockwise — no ending built in. It keeps firing, and the program moves on while it does.
- [2] wait until bumped — a second click on the same trigger, while the machine is firing.
- stop motor — and it stops.
What success looks like: click trigger 1, exactly one brick flies. Click trigger 2, a stream of them. Click trigger 2 again, it stops. If trigger 1 gives you a stream, your cables are swapped — go back to section 8.
Why bumped and not pressed? Same reason as the Timber Saw. With pressed, one long press on trigger 2 would satisfy both the start and the stop, and the machine would fire for a fraction of a second and stop again.
Change it and test 8 min
One change at a time, and predict before each run. Keep the firing line clear on every single run.
- Change the single shot to 3 rotations. Predict how many bricks fly per click. Does one rotation actually equal one brick on your build?
- Change both [2] blocks to [1]. Predict what happens. Now one trigger does everything and the other is dead — the machine has not broken, it has been rewired in software.
- Put them back, then physically swap the two cables at the Brick without touching the program. Predict which trigger now does what. This is the bug from section 2, and you have just caused it on purpose.
- Swap them back, and change the speed to 40 %. Do the bricks still make it out of the magazine? A launcher that is too slow does not fire gently — it jams.
- Add a write [FIRING] at line (1) after start motor and a write [READY ] after stop motor. Now the machine says which mode it is in.
Step 3 is the one to remember. You changed nothing in the program and the machine behaved differently — because half of what a program means lives in the cables, not the blocks.
A program is only half the machine. The wiring is the other half, and it is the half with no error messages.
