Arduino Learning Studiorobotics pathway

R10-U3 · usually age 10 · Robot Explorers

Create an Automatic Response

How can we open and close safely?

Pilot unit plan · 5 sessions · not yet classroom-validated

Build: Servo gate model

A servo turns its arm to the angle the program chooses. Learners find the angles on a card arm, power a real micro servo from the robotics board (never from the micro:bit), time how long the gate stays open and close it in steps, and add a safe stop rule (if something is in the gate's path, open or stay open), then demonstrate the gate with predictions.

  • Decide
  • Act
  • Power and safety

Who it is for

Age is a starting point, never a limit. A learner who can show what this unit starts from can begin here at any age.

How they learn
By arranging instruction cards or blocks, predicting what happens, and testing on a kit. Short sentences, with words and pictures together.
The adult's role
An adult oversees circuits, batteries and motors.
Session
60–75 minutes
Hardware
micro:bit with MakeCode, or a similar child-friendly board. Start in the board's own simulator. A micro:bit is 3.3 V: never connect a 5 V signal straight to it.

Starts from

Builds, and what it is the input for

In the studio today

No studio lab or activity for this unit yet.

Sessions

  1. Session 1 · 60 min

    What is an angle, and which way is safe for a gate?

    A servo turns its arm to an angle from 0 to 180 degrees. On the robotics board, the “set Servo 1 to … degrees” block chooses the angle. A gate has an open angle and a closed angle, and one rule above all: it never comes down on something.

    The adult says first: “A servo turns to the angle you choose. Let's find open and closed.”

    Learner card

    1. Turn the card arm to 90.
    2. Guess, then turn.
    3. Which angle is closed?
    4. Which angle is open?
    5. Never close on a car.

    Key words (show each with a picture): servo · angle · degrees

    Timing (15 of 60 min at the screen)

    1. 15 minAway from the screen: Card arm on a paper protractor: guess, then turn it to 0, 45, 90, 135 and 180 degrees.
    2. 10 minAway from the screen: Choose closed and open; role-play the gate with a toy car pushed by a ruler.
    3. 15 minAt the screen: MakeCode: the board's extension; 90 on A and 0 on B, each with its number shown.
    4. 10 minAway from the screen: Draw where the real arm will point for each angle.
    5. 10 minAway from the screen: Fill in the table; say which angle is open, which is closed, and why.

    In the studio

    No studio lab or activity.

    Outside the studio: MakeCode editor and its micro:bit simulator (makecode.microbit.org)

    Hands-on

    Nothing is powered: this session uses card, a paper protractor and the simulator only. First, away from the screen, each pair fixes a strip of light card to the centre of a paper protractor with a paper fastener and turns it to 0, 45, 90, 135 and 180 degrees, guessing first where each will point. The group decides which position is closed (across the road) and which is open (straight up). Then the group role-plays the gate on a taped road: one learner holds an arm out as the gate, a toy car is pushed along with a ruler, and the arm must never come down while the car is under it. In MakeCode next, the adult adds the board's extension; the learner puts “set Servo 1 to … degrees” with 90 and “show number” 90 inside “on button A pressed”, and 0 with “show number” 0 inside “on button B pressed”. MakeCode's simulator has no robotics board: the board's motor and servo blocks run there but move nothing, so the simulator checks only what the display shows.

    Starting blocks: Built from scratch: “on button A pressed” holding “set Servo 1 to … degrees” with 90 and “show number” 90, and “on button B pressed” with 0.

    Evidence to collect

    A prediction for each angle, a short test table (Angle | My guess | Where it points) for five angles on the card arm, filled in by the learner, and the learner's spoken explanation of which angle is open, which is closed, and why a gate must never close on something.

    Test table columns: Angle | My guess | Where it points

    Predict
    Before each turn of the card arm, the learner points to where it will end.
    Debug
    If the simulator shows nothing on A, check that both blocks sit inside “on button A pressed”.
    Reflect
    Why must a gate never come down on something?

    Works towards: Servo angles

  2. Session 2 · 75 min

    Where does the real servo point?

    The real servo, powered by the board's battery through the Servo 1 socket; the micro:bit sends only the signal. The card arm is fitted with the servo at 90 degrees, pointing halfway, so on this gate open and closed are 135 and 45, away from the servo's ends. The learner finds where 0, 45, 135 and 180 point.

    The adult says first: “Now the real arm moves. The board's battery powers it. The micro:bit sends the angle.”

    Learner card

    1. Hands away from the arm.
    2. Guess where it will point.
    3. Press A. Then press B.
    4. Draw where it points.
    5. Mark open and closed.

    Key words (show each with a picture): servo · angle · open and closed

    Timing (15 of 75 min at the screen)

    1. 10 minAway from the screen: With the board off: the servo in its socket, the post, and the power path from the battery to the servo.
    2. 10 minAt the screen: The session 1 blocks in the simulator, then download.
    3. 15 minAway from the screen: The adult fits the arm at 90; turns at the gate, one pair at a time (about 3 minutes each): press A and B, draw where it points.
    4. 5 minAt the screen: 45 on A, 135 on B: the simulator, then download.
    5. 20 minAway from the screen: Turns again: guess, press, draw; the adult shows 180 once.
    6. 15 minAway from the screen: Mark open (135) and closed (45) on the post; fill in the table.

    In the studio

    No studio lab or activity.

    Outside the studio: MakeCode editor and its micro:bit simulator (makecode.microbit.org)

    Hands-on

    Before the session, with the board and the holder switched off, the adult plugs the servo into the Servo 1 socket (brown to GND, red to V, orange to SIG) and tapes it to a card post at the roadside, the board and the holder on the adult's side. In the simulator first, the learner checks the session 1 blocks; then the learner downloads them (the board switched off, the micro:bit out of the board, USB in; USB out once the light on the back stops flashing, the micro:bit back in). With one pair's micro:bit in, the adult switches on and presses A. To fit the arm, the program sets 90 degrees, the adult switches off, then presses the card arm on pointing halfway between straight up and across the road; nobody turns the arm by hand while the board is on. The post is taller than the arm is long, so the arm touches nothing at any angle. Pairs then take turns at the gate: at each turn the adult, with the board switched off, puts the pair's micro:bit in; the adult switches on; the learner presses A (90) and B (0) and draws where the arm points. Then the learner changes A to 45 and B to 135, tried in the simulator and downloaded the same way, and at the pair's next turn guesses, presses and draws. The adult shows 180 once for the group. Last, the group marks this gate's open angle (135, straight up) and closed angle (45, across the road) on the post; if 45 pointed up, the adult, with the board switched off, turns the servo round on its post so that 135 is up, as on every card.

    Starting blocks: The learner's session 1 blocks (90 on A, 0 on B, each with its number shown).

    Evidence to collect

    A prediction for each angle, a short test table (Angle | My guess | Where it pointed) for 0, 45, 90, 135 and 180 degrees, and the learner's spoken explanation of which angles open and close this gate, and where the servo gets its power.

    Test table columns: Angle | My guess | Where it pointed

    Predict
    Before each press, the learner points to where the arm will stop.
    Debug
    If the arm buzzes at 0 or 180, it is pressing on its own stop: switch off and move that angle 10 towards 90. If it shakes at every angle, switch off and check the cells and the socket's brown, red and orange order; never push the arm by hand.
    Reflect
    Why does the servo get its power from the board, not from the micro:bit?

    ⚠ Adult checks before power-on: Nothing metal touches the micro:bit, its gold pins or the board, and nothing metal lies under it. Before the adult switches on: the micro:bit is firmly in the board, display facing the Link header, its own battery pack and USB unplugged; both switches were off while anything was plugged in or moved. The servo plugs into the board's Servo 1 socket (brown to GND, red to V, orange to SIG), powered by the board's battery; the micro:bit sends only the signal. Never power a servo from the micro:bit's 3V pin. The gate arm is a strip of light card: no wood, metal or sharp corners. Hands never go in the gate's path: vehicles are pushed with a ruler or rolled from a ramp behind a start line. Plastic toy vehicles only near the board; nothing metal on or under it. Rewire only when unpowered: the board and the holder are switched off before any wire, motor, servo or sensor is plugged in, moved or taken out.

    Works towards: Servo angles

  3. Session 3 · 75 min

    How long should the gate stay open?

    Timing: “on start” opens the gate, the safe position when the program does not yet know what is underneath; “on button A pressed” opens it, waits with “pause (ms)”, then closes it in steps 1000 ms apart, slow enough to watch. 1000 ms is 1 second. Is the gate open long enough for the slowest vehicle to pass?

    The adult says first: “The pause keeps the gate open. 1000 ms is one second.”

    Learner card

    1. Press A. Start the stopwatch.
    2. Push the car with a ruler.
    3. Did it get through?
    4. Watch the arm close in steps.
    5. Hands out of the gate's path.

    Key words (show each with a picture): pause · seconds · timing

    Timing (20 of 75 min at the screen)

    1. 10 minAway from the screen: Guess: how many seconds is 3000 ms? How long does a slow car take to pass?
    2. 15 minAt the screen: Build “on start” and button A with the pause, the closing steps and the pictures; check the simulator; download.
    3. 20 minAway from the screen: Turns at the gate, one pair at a time (about 5 minutes each): press A; time the open arm; push a car through with a ruler.
    4. 5 minAt the screen: Change the first pause (two pairs 1000, two pairs 5000); download.
    5. 15 minAway from the screen: Turns again; share the times.
    6. 10 minAway from the screen: Fill in the table from everyone's times; choose the pause for the slowest car.

    In the studio

    No studio lab or activity.

    Outside the studio: MakeCode editor and its micro:bit simulator (makecode.microbit.org)

    Hands-on

    In the simulator first, the learner builds “on start” holding “set Servo 1 to … degrees” with 135 (open), and “on button A pressed” holding 135 with a “show leds” picture of a standing line, “pause (ms)” 3000, then the closing steps: 105, “pause (ms)” 1000, 75, “pause (ms)” 1000, and 45 (closed) with a picture of a lying line. The learner takes out session 1's “on button B pressed”, so B does nothing yet, and checks the pictures in the simulator. Then the learner downloads it (the board switched off, the micro:bit out of the board, USB in; USB out once the light on the back stops flashing, the micro:bit back in). Pairs take turns at the gate: at each turn the adult, with the board switched off, puts the pair's micro:bit in; the adult switches on; the learner presses A, and the adult times how long the arm stays up before it starts to close; a toy car is pushed under the arm with a ruler, slowly, and the group says whether it got through before the arm came down. Then the learner changes the first pause (two pairs to 1000, two pairs to 5000), tried in the simulator and downloaded the same way, guessing the open time first; the group shares the times.

    Starting blocks: The learner's session 2 blocks, with this gate's open angle (135), its closed angle (45) and the closing steps (105, 75).

    Evidence to collect

    A prediction for each pause, a short test table (Pause (ms) | My guess (s) | Open for (s)) for 3000, 1000 and 5000 ms, and the learner's spoken or written explanation of how the pause sets the open time and which pause suits the slowest car.

    Test table columns: Pause (ms) | My guess (s) | Open for (s)

    Predict
    Before each run, the learner guesses how many seconds the arm will stay up.
    Debug
    If the arm stays up longer than the pause, that is right: in blocks each “show leds” picture waits 400 ms, the arm takes time to move, and the stopwatch measures all of it.
    Reflect
    Who decides how long is long enough: the program, or the slowest car?

    ⚠ Adult checks before power-on: Nothing metal touches the micro:bit, its gold pins or the board, and nothing metal lies under it. Before the adult switches on: the micro:bit is firmly in the board, display facing the Link header, its own battery pack and USB unplugged; both switches were off while anything was plugged in or moved. The servo plugs into the board's Servo 1 socket (brown to GND, red to V, orange to SIG), powered by the board's battery; the micro:bit sends only the signal. Never power a servo from the micro:bit's 3V pin. The gate arm is a strip of light card: no wood, metal or sharp corners. Hands never go in the gate's path: vehicles are pushed with a ruler or rolled from a ramp behind a start line. Plastic toy vehicles only near the board; nothing metal on or under it. Rewire only when unpowered: the board and the holder are switched off before any wire, motor, servo or sensor is plugged in, moved or taken out.

    Works towards: Servo angles

  4. Session 4 · 75 min

    What must the gate do if something is in its path?

    The safe stop rule: if something is in the gate's path, the gate opens, or stays open. Button B is a stand-in, and the learner is told so: the adult holds it to mean something is in the gate's path. R10-U4 replaces it with a real distance sensor. Each closing step checks first: an “if then else” sets the open angle if “button B is pressed”, else the step's angle; and a “forever” checks B again and again, opening the gate whenever it is pressed.

    The adult says first: “A safe gate never closes on something. Button B means something is in the way.”

    Learner card

    1. Press A: open, wait, close.
    2. Hold B: the gate stays open.
    3. Guess each case first.
    4. Safe? Tick ✓ or ✗.
    5. Hands stay out of the path.

    Key words (show each with a picture): safe stop · path · rule

    Timing (15 of 75 min at the screen)

    1. 10 minAway from the screen: Role-play the rule: close a step at a time, only while a partner's hand is down.
    2. 15 minAt the screen: Put each closing step in an “if then else”; add the “forever” check; click A and B in the simulator; download.
    3. 10 minAway from the screen: Write a guess for each of the five cases.
    4. 25 minAway from the screen: Turns at the gate, one pair at a time (about 5 minutes each): the five cases, B held by the adult, hands out of the path.
    5. 15 minAway from the screen: Tick ✓ or ✗ for safe; say why the gate opens when something is in its path.

    In the studio

    No studio lab or activity.

    Outside the studio: MakeCode editor and its micro:bit simulator (makecode.microbit.org)

    Hands-on

    First, away from the screen, the group role-plays the rule: the learner playing the gate closes a step at a time, only while a partner's hand is down, and opens at once when it goes up. In the simulator next: in “on button A pressed”, each closing step (105, 75, 45) moves into its own “if then else”: if “button B is pressed”, the open angle, else the step's angle; and a “forever” holds an “if then else” that sets the open angle when “button B is pressed”, with nothing in else. The learner clicks A and B in the simulator and watches the pictures (the arm cannot be seen there). Then the learner downloads it (the board switched off, the micro:bit out of the board, USB in; USB out once the light on the back stops flashing, the micro:bit back in). Pairs take turns at the gate: at each turn the adult, with the board switched off, puts the pair's micro:bit in; the adult switches on. The learner tests five cases, each predicted: just switched on; A with nothing in the path; A, then B held by the adult before the arm starts to close; B pressed while the gate is closed; B pressed while the arm is closing step by step, a window of about 2 seconds.

    Starting blocks: The learner's session 3 blocks, with the safe stop rule added.

    Evidence to collect

    A prediction for each case, a short test table (Case | My guess | What it did | Safe?) for five cases, and the learner's spoken explanation of the safe stop rule and why the gate opens when something is in its path.

    Test table columns: Case | My guess | What it did | Safe?

    Predict
    Before each case, the learner says what the arm will do and whether that is safe.
    Debug
    If the arm comes down while B is held, check which part of each step's “if then else” holds the step's angle: “then” or “else”.
    Reflect
    Why is open the safe choice for this gate when something might be underneath?

    ⚠ Adult checks before power-on: Nothing metal touches the micro:bit, its gold pins or the board, and nothing metal lies under it. Before the adult switches on: the micro:bit is firmly in the board, display facing the Link header, its own battery pack and USB unplugged; both switches were off while anything was plugged in or moved. The servo plugs into the board's Servo 1 socket (brown to GND, red to V, orange to SIG), powered by the board's battery; the micro:bit sends only the signal. Never power a servo from the micro:bit's 3V pin. The gate arm is a strip of light card: no wood, metal or sharp corners. Hands never go in the gate's path: vehicles are pushed with a ruler or rolled from a ramp behind a start line. Plastic toy vehicles only near the board; nothing metal on or under it. Rewire only when unpowered: the board and the holder are switched off before any wire, motor, servo or sensor is plugged in, moved or taken out.

    Works towards: Servo angles

  5. Session 5 · 75 min

    Can I show my gate stops safely, and explain why?

    The prototype, a servo gate model, demonstrated: its angles, its timing, its input logic (A asks the gate to let a car through; B stands in for something in the path) and its safe stop rule, with a prediction before every step.

    The adult says first: “Show us your gate. Tell us why it is safe.”

    Learner card

    1. Show the start.
    2. A car passes in time.
    3. Hold B before it closes.
    4. Hold B while it closes.
    5. Explain the safe stop rule.

    Key words (show each with a picture): demonstrate · safe stop · explain

    Timing (10 of 75 min at the screen)

    1. 15 minAway from the screen: Rehearse with the card arm: what will each step do?
    2. 10 minAt the screen: Run the final program in the simulator once, then download.
    3. 30 minAway from the screen: Demonstrations, one pair at a time (about 7 minutes each): start, a car passing, B before closing, B while closing.
    4. 20 minAway from the screen: Explain the safe stop rule, the angles and the timing.

    In the studio

    No studio lab or activity.

    Outside the studio: MakeCode editor and its micro:bit simulator (makecode.microbit.org)

    Hands-on

    First, away from the screen, the learner rehearses the demonstration with the card arm and the protractor. In the simulator next, the learner runs the final program once, then downloads it (the board switched off, the micro:bit out of the board, USB in; USB out once the light on the back stops flashing, the micro:bit back in). At the pair's turn at the gate, the adult, with the board switched off, puts the pair's micro:bit in; the adult switches on. The learner demonstrates: the gate at start; A, with a toy car pushed through with a ruler in time; A, with B held by the adult before the arm starts to close; B while the arm is closing step by step. Before each step the learner says what will happen; afterwards they explain the safe stop rule, the open and closed angles and the pause they chose.

    Starting blocks: The learner's own gate blocks from session 4.

    Evidence to collect

    The unit's evidence: the learner demonstrates a gate with a safe stop rule: a prediction before each step, a short test table (Step | My guess | What it did | Safe?) for the start, a car passing, B before the arm starts to close and B while it closes, and the learner's spoken or written explanation of the safe stop rule, the angles and the timing.

    Test table columns: Step | My guess | What it did | Safe?

    Predict
    Before each step of the demonstration, the learner says what the arm will do.
    Debug
    If a step goes wrong, switch off, read the blocks aloud from “on start” down, and find the step that differs.
    Reflect
    If a real gate used your rule, what would it need to sense instead of button B?

    ⚠ Adult checks before power-on: Nothing metal touches the micro:bit, its gold pins or the board, and nothing metal lies under it. Before the adult switches on: the micro:bit is firmly in the board, display facing the Link header, its own battery pack and USB unplugged; both switches were off while anything was plugged in or moved. The servo plugs into the board's Servo 1 socket (brown to GND, red to V, orange to SIG), powered by the board's battery; the micro:bit sends only the signal. Never power a servo from the micro:bit's 3V pin. The gate arm is a strip of light card: no wood, metal or sharp corners. Hands never go in the gate's path: vehicles are pushed with a ruler or rolled from a ramp behind a start line. Plastic toy vehicles only near the board; nothing metal on or under it. Rewire only when unpowered: the board and the holder are switched off before any wire, motor, servo or sensor is plugged in, moved or taken out.

    Works towards: Servo angles

Materials

  • Per pair: a BBC micro:bit and its USB cable (USB micro-B at the micro:bit end)
  • A computer with a web browser for MakeCode (makecode.microbit.org); no installs needed
  • Per pair: a Kitronik Compact All-In-One Robotics Board for BBC micro:bit (stock code 5693), its Link header fitted with a 2.54 mm pin header by the adult (soldering is adult-only)
  • Kept by the adult: 4 × AA alkaline cells (1.5 V each, 6 V nominal) in a holder with a screwed-shut cover and its own on/off switch, wired by the adult to the board's power terminal block; no rechargeable cells, Li-ion, LiPo, RC or coin-cell packs
  • Pencils and paper for the test tables
  • One gate per adult, which the pairs take turns at: a 180-degree micro servo rated 4.8–6 V with its arm (horn): the Kitronik Mini 180 Degree Metal Gear Servo MG90S (stock code 2592), the servo Kitronik's board page links to, or, as Kitronik now marks it discontinued, another micro servo with the same rating, checked first by the adult
  • Light card for the gate arm and a post taller than the arm is long, a paper protractor, paper fasteners, sticky tape and masking tape for the road
  • A plastic toy car and a 30 cm ruler to push it; a stopwatch or a clock with a seconds hand, used by the adult

⚠ Safety before any session

  • Batteries: only AA alkaline cells in the board's closed holder, and USB from a computer for downloads; no rechargeable cells, power banks, Li-ion, LiPo, RC packs or coin cells.
  • Cells: the adult fits four new alkaline cells of one type, the right way round, never mixes new and used cells, takes spent cells out and screws the cover shut.
  • The battery holder stays with the adult, beside the board on the adult's side; learners never handle the cells or the holder.
  • The power-off switch is the board's on/off switch: it cuts the battery to the board, the micro:bit and every motor and servo. Anyone may switch it off at any time; only the adult switches it on.
  • The servo plugs into the board's Servo 1 socket (brown to GND, red to V, orange to SIG), powered by the board's battery; the micro:bit sends only the signal. Never power a servo from the micro:bit's 3V pin.
  • The gate arm is a strip of light card: no wood, metal or sharp corners. Hands never go in the gate's path: vehicles are pushed with a ruler or rolled from a ramp behind a start line.
  • Rewire only when unpowered: the board and the holder are switched off before any wire, motor, servo or sensor is plugged in, moved or taken out.
  • Only the parts the plan names connect to the micro:bit, through the board's Link header. Never connect a 5 V signal or supply to a micro:bit's pins or battery socket: it runs at 3.6 V at most.
  • Plastic toy vehicles only near the board; nothing metal on or under it.
  • If the board, a motor, the holder or a wire gets warm: switch the board off, don't touch it, tell the adult.
Safety for every band
  • Low voltage only: battery packs or USB. Never mains electricity.
  • Never connect a motor straight to a controller pin: use a driver and a separate supply.
  • Every moving robot has a power-off switch within reach that cuts the motor battery (or all power). A software stop button is extra, never a replacement.
  • No coin or button cells and no loose small magnets; battery compartments screwed shut.
  • Guard wheels and moving parts against pinched fingers; keep robots slow and indoors.
  • No exposed lithium cells, improvised chargers or lasers.
  • No Li-ion, LiPo or RC packs: AA alkaline or NiMH cells in a closed holder with a switch, or USB.
  • Check polarity and voltage before power-on; a 3.3 V board must not receive 5 V signals.

Notes for the adult

  • Read each step aloud first: your words come before the learner's card. The card uses short sentences; show each key word with a picture.
  • These plans assume one adult for up to four pairs. Learners plug the USB cable into their own computer, gripping the plug, while the adult watches; only the adult handles cells and battery packs. With more pairs, add an adult or bring fewer pairs to the real board at once.
  • Kitronik labels the board Age 11+ and tags it Designed for_Engineers. These plans are adult-led for that reason: the adult builds, wires, powers and switches every rig and keeps the battery holder; the learner changes numbers in blocks, presses the micro:bit's buttons when the adult says, and watches from outside the safe zone or the gate's path.
  • Only one spinner or gate runs at a time near each adult. Its board sits outside the safe zone on the adult's side, with leads long enough to reach, and the adult stands at its switch as the stopper.
  • One powered rig per adult: pairs take turns at it, one pair at a time. Each pair downloads to its own micro:bit, and at the pair's turn the adult, with the board switched off, swaps it into the rig. While they wait, the other pairs predict, fill in their tables or work in the simulator, watching from outside the zone. Each session's timing counts the turns and the waiting.
  • Each session's timing keeps screen time to short bursts (15 minutes at most), with building, acting or testing away from the screen between them.
  • Before the first session on the real board, set up each computer and test a download: either pair each micro:bit once with WebUSB (then MakeCode's Download button sends the program straight to it), or download the .hex file and drag it onto the MICROBIT drive. The light on the back flashes while the program copies: unplug only after it stops.
  • To download, the board is switched off and the adult takes the micro:bit out of it (or the learner does, with the adult watching), holding it by its edges and pulling it straight out; the learner plugs in USB, downloads and unplugs USB once the light on the back stops flashing; the micro:bit goes back in the same way, straight and firmly, display facing the Link header, before the adult switches on. Every swap wears the edge connector a little: swap only to download or at a pair's turn, and never rock the micro:bit out.
  • Before the first session, add the extensions on each computer: in MakeCode's Extensions, search for Kitronik and pick the Kitronik robotics Board; for the distance sensor, search for sonar.
  • The MakeCode simulator prepares the work. Only the real board, seen working by the adult, counts as evidence: a simulator run is never physical success.
  • Hand out each session's test table with its columns ready: the learner fills it in, and the adult writes only for a learner who needs it. Making their own tables is taught in R09-U3.
  • The studio's Arduino labs are written for ages 12 and up and are not used in this unit, not even its motor, servo or distance labs: they wire a 5 V Uno, never a micro:bit.
  • The pack is 6 V nominal (4 × 1.5 V), at the edge of all three ranges: the bottom of Kitronik's recommended 6.0–10.8 V for the board, and the top of the TT motor's 3–6 V and the servo's 4.8–6 V. Expect it to vary: new cells can read above 1.5 V each with nothing running (Energizer's handbook works an example with an open circuit voltage of 1.6 V), and the pack sags under load, because each fresh cell has 150 to 300 milliohms of internal resistance (Energizer E91). Kitronik's board page lists under Requires a Power Supply that links to its 3 × AA holder; these plans use 4 × AA instead, because 3 × AA is 4.5 V nominal, below the board's recommended 6.0 V and the servo's 4.8 V.
  • MakeCode's own “servo write pin … to …” block drives a servo on a micro:bit pin. MakeCode's servo page wires the servo to the 3V pin, which these plans never do, because the Foundation advises powering servos externally. Our servo plugs into the board, so it uses the board's “set Servo 1 to … degrees” block; both take an angle from 0 to 180.
  • Check each servo before its first powered session. A servo's signal must suit its supply: the Foundation warns that at a higher supply voltage “the 3V from the micro:bit might not be enough to direct the servo”, and Kitronik's MG90S page says you may need to level shift the signal. The board's own signal level is not documented, so the adult checks: on the board at 6 V, the servo moves to 0, 90 and 180 and holds still at each. A servo that does not follow is not used.
  • Kitronik's servo block sends pulses from about 0.5 ms (0 degrees) to 2.5 ms (180 degrees), a wider range than some servos accept. If the arm buzzes at an end, it is pressing on the servo's own stop: switch off, and move that angle 10 towards 90 (10 instead of 0, 170 instead of 180). The gate's open and closed angles stay well away from the ends.
  • Button B is a stand-in, and the learner is told so: the adult holds it to mean something is in the gate's path. R10-U4 replaces it with a real distance sensor.
  • The gate closes in steps (105, 75, 45), 1000 ms apart, so “B while the arm is closing” has a window of about 2 seconds. Each step checks B first. When B is let go during the closing, the closing goes on from the next step; if B is still held at the last step, the gate stays open until A is pressed again: open is the safe choice.
  • This unit does not start from R10-U1: the adult sets up the board and its battery and shows the servo's power path (battery, board, servo socket); the micro:bit only sends the angle.
  • The board feeds its servo sockets from the battery; the micro:bit's own battery pack is never plugged in while it sits in the board.
  • Readiness decides, not age: a learner who already sets a servo's angle, times a gate and explains a safe stop rule can move on to R10-U4.

Planned studio features

Not built yet. The unit runs without them.

  • A micro:bit motor and servo simulator in the studio, with the gate arm drawn and every control labelled as a code setting or a simulated input.
  • Printable picture cards for each session's key words, a paper protractor and printable learner cards.
  • A printable test-table sheet for each session, with its columns.

Sources

The facts this plan relies on, in each source's own words.