# NRC 2026 — Coaching Plan v3
### RoboMission Rookie Primary | LEGO SPIKE Prime | Robot Rockstar Mission

---

## Overview

| Detail | Info |
|---|---|
| **Competition** | The 2026 National Robotics Competition (NRC) |
| **Category** | RoboMission Rookie Primary |
| **Mission** | Robot Rockstar (Robots Meet Culture) |
| **Kit** | LEGO® Education SPIKE™ Prime (45678) + Expansion Set (45681) |
| **Teams** | 3 teams — Team 1, Team 2, Team 3 |
| **Students** | 3 students per team = **9 students total** (Age 10–12) |
| **Coaching Duration** | 4 sessions × 2 hours = **8 hours total** |
| **Format** | Extra class / intensive coaching, all 3 teams coached simultaneously |

### Equipment Required

| Item | Qty | Notes |
|---|---|---|
| LEGO SPIKE Prime Set (45678) | 3 | One per team |
| LEGO SPIKE Prime Expansion Set (45681) | 3 | One per team |
| Laptop / tablet with SPIKE app | 3 | One per team |
| Game mat (official or printed) | 3 | Ideal — each team tests simultaneously |
| Game mat | 1 (minimum) | If only 1 mat: rotation schedule in Sessions 3 & 4 |
| Workstation area (table + chairs) | 3 | Separate areas reduce cross-team distraction |
| Measuring tape or ruler | 3 | One per team — used every session |
| Sticky notes / whiteboard marker | — | For recording measured distances per team |

---

## Multi-Team Coaching Structure

### Session Flow (Every Session)

Each 2-hour session follows a fixed three-phase structure:

| Phase | Time | Duration | Activity |
|---|---|---|---|
| **Group Instruction** | 0:00–0:20 | 20 min | Coach introduces the session concept to all 9 students together |
| **Team Work** | 0:20–1:40 | 80 min | Teams work independently; coach circulates (~25 min per team) |
| **Group Debrief** | 1:40–2:00 | 20 min | Each team shares one win + one challenge; coach highlights key lessons |

**Why this structure works:**
- Group instruction avoids repeating the same explanation three times
- Independent team work time builds ownership — students solve problems themselves before asking for help
- Group debrief creates cross-team knowledge sharing: if Team A solved a drift problem, Teams B and C learn from it immediately

### Coach Circulation Strategy

During the 80-minute team work phase, rotate through all three teams with intent:

| Rotation | Team | Duration | Coach Focus |
|---|---|---|---|
| Round 1 | Most stuck team | 30 min | Unblock the critical issue; leave them with a clear next step |
| Round 2 | Second team | 25 min | Check progress; correct technique before it becomes a habit |
| Round 3 | Third team | 25 min | Review work; challenge fast finishers with extension tasks |

> Prioritise the most stuck team first each rotation — a team that's blocked for 30 minutes makes no progress. A team that's moving will continue moving even without coach attention.

### Team Differentiation

Teams will naturally progress at different rates. Manage the gap proactively:

| Team State | Coach Response |
|---|---|
| **Behind pace** | Simplify the session goal — e.g., if Session 3 target is cables + microphone + instruments, accept cables only as the minimum deliverable |
| **On pace** | Standard coaching — measure, code, test, adjust cycle |
| **Ahead of pace** | Extension challenge: optimise route time, improve bonus object protection, reduce arm wait times |

### Inter-Team Knowledge Rules

- **Observations are shared** — if one team discovers that `ReflectedLightIntensity = 58` works well, announce it to all teams during debrief
- **Code values are NOT shared** — each team's robot has slightly different motor alignment and arm geometry; copying values will break the other robot
- **Healthy competition encouraged** — from Session 3 onward, post each team's cable task time on a shared scoreboard; from Session 4 onward, run timed cross-team mock runs

### Team Roles (Per Team)

Each team of 3 should have assigned roles that rotate across sessions:

| Role | Responsibilities |
|---|---|
| **Builder** | Assemble and maintain the robot; measure distances on the mat |
| **Programmer** | Write and modify code blocks in the SPIKE app |
| **Tester / Navigator** | Place the robot at start, observe each run, note what failed |

> Rotate roles after Session 2 so every student has coded, built, and observed before Sessions 3–4.

### Team Roster

| Team | Student | Class | Role |
|---|---|---|------|
| **Team 1** | Muhammad Nur Najah bin Anuar Idris | 6K | P    |
| **Team 1** | Maya Qairina binti Anuar Idris | 5A | RM   |
| **Team 1** | Mifthahul Jannah binti Abdullah | 4I | FM   |

| Team | Student | Class | Role |
|---|---|---|------|
| **Team 2** | Fasha Ashriq bin Faizal | 6K | P    |
| **Team 2** | Muhammad Zhorfan Abqori bin Samsudin | 5K | RM   |
| **Team 2** | Noah Nuqman bin Erdey Hakim | 5K | FM   |

| Team | Student | Class | Role |
|---|---|---|------|
| **Team 3** | Muhammad Adra Omair bin Mohamad Nuruddin | 4K | P    |
| **Team 3** | Muhammad Harraz Zafri bin Mohd Imran | 4D | RM   |
| **Team 3** | Uwais Al Amin bin Aidil Dasila | 4B | FM   |

---

## What Each Team Needs to Achieve

By the end of Session 4, each team must independently run their robot **fully autonomously** on the official game mat to:

- Deliver both cables completely into the grey area (upright)
- Deliver the microphone completely into its target area (upright)
- Move guitar, keyboard, and congas from the truck to the backstage area
- Deliver all 6 notes to their matching colour target zones (upright)
- Complete all tasks **within 2 minutes**

### Score Target (Per Team)

| Task | Max Points | Target |
|---|---|---|
| Cables × 2 (upright, completely in) | 30 | 30 |
| Microphone (upright, completely in) | 20 | 20 |
| Instruments × 3 (completely in backstage) | 45 | 45 |
| Notes × 6 (upright, completely in colour zone) | 120 | 120 |
| Bonus — don't knock Clef ×1 + Speakers ×2 + Amplifier ×1 | 40 | 40 |
| **TOTAL** | **255** | **255** |

> **Partial scoring:** Cables, Microphone, and Notes each score **half points** if partly in the target area or not upright (cables: 5 pts each; microphone: 10 pts; notes: 10 pts each). Instruments have no upright requirement — completely in backstage scores full 15 pts.

---

## Session 1 — Build & Move (2 Hours)

**Goal:** All 3 teams assemble their robot with drivetrain and arm mechanism. Each team leaves knowing how to drive straight, turn, and open/close arms in code.

### Group Instruction (0:00–0:20)

Walk all 9 students through the full robot design before any team starts building:
- Show a completed robot (or reference photos) — point out drivetrain, hub, arm motors, colour sensor
- Explain the port assignment: C = left drive, D = right drive, B = left arm, F = right arm, E = colour sensor
- Explain the broadcast system at a high level: "the robot listens for messages and responds — this is how we split the mission into tasks"
- Assign roles for Session 1: each team decides who builds what before they start

### Team Work (0:20–1:40)

**Hour 1 — Build the Robot (all teams simultaneously)**

*Drivetrain*
- Build two-wheel differential drive chassis
- Mount the SPIKE Prime hub; route motor cables to ports C (left) and D (right)
- Test: wheels spin freely, robot sits flat on the table

*Arm Mechanism*
- Build left arm on motor port B, right arm on motor port F
- Arms open to ~0° position; close to a gripping position (~60–120° depending on each team's build)
- Attach colour sensor pointing downward at front — navigation sensor (port E)
- Test: arms move smoothly; sensor is at the correct height to read tiles and lines

**Hour 2 — First Code: Movement + Arms**

*Movement blocks to learn:*
```
Set drive motors [CD]
Set drive speed [X]%
Move [X] cm
Start dual speed L=[X]% R=[X]%
Stop drive
Motor [CD] set degrees-counted = 0
```

*Arm blocks to learn:*
```
Motor [B/F] speed [X]%
Motor [B/F] → position [X] (clockwise / counterclockwise)
Stop motor [B/F]
```

*Activity 1 — Square drive*
Program the robot to move forward 30 cm → turn 90° → repeat ×4. Adjust until the square closes.

*Activity 2 — Open and close arms*
- Broadcast `[Open Arm Both]` → both arms go to position 0
- Broadcast `[Close Arm Both]` → both arms close to grip position
- Practice timing: `Wait 0.5s` after every arm command before continuing

### Group Debrief (1:40–2:00)

Each team demonstrates their square drive. Compare results:
- Which team's square closes best?
- Whose arms move smoothest?
- Key lesson: arm position values differ per build — this is expected and normal

### Student Achievement Checklist — Session 1

Each student on every team should be able to tick these off before Session 2:

**Builder**
- [ ] Drivetrain assembled with motors correctly wired to ports C and D
- [ ] Arm motors mounted on ports B (left) and F (right); arms move without obstruction
- [ ] Colour sensor mounted downward-facing at port E at correct tile-reading height
- [ ] Robot sits flat; wheels spin freely; no loose connections

**Programmer**
- [ ] Square drive program runs: robot moves forward, turns ~90°, and repeats ×4
- [ ] `[Open Arm Both]` broadcast opens both arms to position 0
- [ ] `[Close Arm Both]` broadcast closes both arms to a gripping position
- [ ] `Wait 0.5s` delay is in place after every arm command

**Tester / Navigator**
- [ ] Can place the robot at a consistent starting position and reproduce the same run twice
- [ ] Can observe and describe what went wrong in a run (e.g., "turned too far", "arm didn't close fully")
- [ ] Knows the layout of the game mat: where cables, instruments, notes, and bonus objects are

**All students**
- [ ] Can explain what the broadcast system does in their own words
- [ ] Know their team's arm position values from testing

### Coach Notes — 3 Teams
- Expect builds to be at different stages at the end of Hour 1 — this is fine; the programmer can start Hour 2 code while the builder finishes
- The biggest risk in Session 1 is one student doing all the building. Watch for this in each team during your first circulation.
- Arm position values (0, 60, 120, 240, 300, 335) will vary by build — each team must find their own values through testing; do not share values between teams
- End the session by placing all 3 robots on the game mat so all students see the field together

---

## Session 2 — Sensors & Navigation (2 Hours)

**Goal:** All 3 teams learn gyro-based straight driving and line following — the two navigation techniques used throughout the mission program.

### Group Instruction (0:00–0:20)

Demonstrate with one robot (ideally from the team with the most stable build from Session 1):
1. Run the robot at full speed for 1 metre with no correction — let it drift
2. Ask students: "why did it veer?" — motor differences, floor friction, battery level
3. Show the gyro straight concept: "the hub has a compass inside — we tell it to keep pointing the same direction and steer itself back when it drifts"
4. Show the colour sensor reading live values on the hub display over white tile, black line, and coloured areas

### Team Work (0:20–1:40)

**Hour 1 — Gyro Straight Driving**

*The GyroStraight concept:*
```
Reset yaw
Repeat until degrees-counted > [target]:
    Error = HubOrientation[yaw] − TargetAngle
    Correction = (3 × Error) + (10 × (Error − Last_Error))
    Motor C power = (Speed − Correction) × −1
    Motor D power = (Speed + Correction)
```
- Plain language explanation: "the robot checks its compass, calculates how far off it is, and steers back"
- Kp = 3 (how hard it steers), Kd = 10 (how fast it reacts to changes)

*Key blocks:*
```
Reset yaw
HubOrientation[yaw]
Motor [C] set degrees-counted = 0
abs(MotorPosition(C) + MotorPosition(D)) ÷ 2
```

*Activity:* Drive 100 cm straight using gyro correction. Each team runs with and without correction and compares.

**Hour 2 — Line Following**

*Calibration first:* Each team finds their own `ReflectedLightIntensity` midpoint value (typically ~58) by reading the sensor on their specific mat under their specific lighting conditions.

*The FollowLine concept:*
```
Error = TargetReflection − Reflectivity(E)
Correction = (Kp × Error) + (Kd × (Error − Last_Error))
Motor C power = (Speed − Correction) × −1
Motor D power = (Speed + Correction)
```
- Same PD formula as gyro straight — just a different error source
- Position = 1: following the right edge of the line (most tasks)
- Position = 2: following the left edge (some note routes)

*Activity:* Follow a black line for 50 cm, then stop at the next black line. Each team tunes Kp and Kd until smooth.

*Combining both:*
- GyroStraight for open field travel (no line available)
- FollowLine for precise positioning near targets and along mat edges

### Group Debrief (1:40–2:00)

Each team reports their calibration values:

| Team | ReflectedLightIntensity | Kp | Kd | Notes |
|---|---|---|---|---|
| Team A | | | | |
| Team B | | | | |
| Team C | | | | |

Key lesson: values differ between teams because each robot and sensor mounting is slightly different — this is why we calibrate individually.

Close with a combined routine on each robot: gyro straight → turn 90° → follow line → stop.

### Student Achievement Checklist — Session 2

**Builder**
- [ ] Colour sensor height confirmed correct — sensor reads a clear difference between white tile and black line
- [ ] Robot is mechanically stable after Session 1 changes; no loose connections introduced

**Programmer**
- [ ] GyroStraight routine programmed: robot drives 100 cm with yaw correction and stays straight
- [ ] `Reset yaw` called at the start of every straight segment
- [ ] `ReflectedLightIntensity` calibration value found and set as a variable (not hardcoded)
- [ ] FollowLine routine programmed: robot follows a black line for 50 cm and stops at the next line
- [ ] Kp and Kd values tuned — robot follows the line smoothly without zigzagging

**Tester / Navigator**
- [ ] Can set up a test track (tape or mat lines) for the FollowLine activity
- [ ] Can describe the difference between Kp too high (zigzag) and Kp too low (slow correction)
- [ ] Ran both GyroStraight and FollowLine tests and recorded the results

**All students**
- [ ] Can explain in plain words why the robot needs gyro correction (drift causes)
- [ ] Know their team's calibrated `ReflectedLightIntensity` value and where it is set in the program

### Coach Notes — 3 Teams
- Students do not need to memorise the PD formula — they need to understand what each parameter does: "Kp makes it react more. Kd makes it smoother. Too much Kp = zigzag. Too little = slow correction."
- If a team's `ReflectedLightIntensity` calibration is significantly different (e.g., 45 vs 70), check sensor mounting height — the sensor may be positioned differently from the other teams
- `ScanBlackStop` (`Wait until RawColour(E)[0] < 200`) is a simpler alternative to FollowLine for stopping — useful for slower teams to unblock quickly
- If one team finishes early: challenge them to follow the line and then automatically stop exactly on a coloured tile

---

## Session 3 — Mission Tasks: Cables, Microphone & Instruments (2 Hours)

**Goal:** All 3 teams program the first three tasks in sequence. By the end of this session, each robot should complete Cables → Microphone → Instruments reliably.

### Group Instruction (0:00–0:20)

Walk all 9 students through the full task order and broadcast chain on a whiteboard or printed mat:
- Draw the robot's path from start through cables, microphone pickup, and instrument delivery
- Explain the broadcast chain: `Cables → Microphone → Instruments → Notes 1`
- Emphasise: **test each broadcast independently before chaining** — press the button to trigger `[Cables]` alone first, then `[Microphone]` alone, then chain them

Set up all 3 mats (or, if 1 mat, post the rotation schedule):

**Mat Rotation Schedule (if only 1 mat available):**
| Time Slot | Team on Mat | Teams Off Mat |
|---|---|---|
| 0:20–0:47 | Team A | Teams B & C: code and dry-run on floor |
| 0:47–1:13 | Team B | Teams A & C: code and dry-run on floor |
| 1:13–1:40 | Team C | Teams A & B: refine code from test results |

### Team Work (0:20–1:40)

**Hour 1 — Cables Task**

Task sequence:
1. Move back slightly from start to align
2. Reset yaw; GyroStraight to cable 1 position
3. Follow line to approach, open arms, advance, close arms (pick up cable)
4. GyroStraight to stage grey area, open arms to release (cable must land upright)
5. Repeat for cable 2 from the other edge
6. Broadcast `[Microphone]` at the end

```
When I receive [Cables]:
    ... cable 1 route ...
    ... cable 2 route ...
    Broadcast [Microphone]
```

Time target: both cables complete in **≤ 30 seconds**

Test checklist:
- Does each cable land completely in the grey area?
- Is each cable upright? (Adjust arm close force if tipping)
- Run 3 times — consistent results?

**Hour 2 — Microphone + Instruments Tasks**

*Microphone task:*
```
When I receive [Microphone]:
    FollowLine to microphone position
    Open arms → advance → Close arms 2 (tighter grip)
    GyroStraight back to stage area
    Turn → approach target zone
    Open arms → microphone released upright
    Broadcast [Instruments]
```

*Instruments task:*
```
When I receive [Instruments]:
    FollowLine along edge to truck area
    Turn and navigate into truck
    Push/carry instruments toward backstage area
    GyroStraight to backstage
    Broadcast [Notes 1]
```

Note: instruments score 15 pts each when completely in backstage — no upright requirement.

Combined test target: Cables + Microphone + Instruments complete by **90 seconds**.

### Group Debrief (1:40–2:00)

Post a live scoreboard for all 3 teams:

| Team | Cables ✓ | Microphone ✓ | Instruments ✓ | Combined Time |
|---|---|---|---|---|
| Team A | | | | |
| Team B | | | | |
| Team C | | | | |

Celebrate every team that completed at least one task. For teams still on cables only — identify the single blocking issue and give them a specific fix to attempt before Session 4.

### Student Achievement Checklist — Session 3

**Builder**
- [ ] All game field objects measured and distances recorded (from start zone to each object)
- [ ] Approach angles noted for cables, microphone, and truck area
- [ ] Robot checked before and after each test run — no loose connections or shifted sensors

**Programmer**
- [ ] `[Cables]` broadcast handler programmed: both cables delivered to grey area
- [ ] Each cable tested independently at least 3 times before chaining
- [ ] `[Microphone]` broadcast handler programmed: microphone delivered to target area upright
- [ ] `[Instruments]` broadcast handler programmed: all 3 instruments pushed into backstage area
- [ ] Full chain `Cables → Microphone → Instruments` runs end-to-end without stopping

**Tester / Navigator**
- [ ] Timed the cables task alone — result recorded (target: ≤ 30 sec)
- [ ] Timed the full Cables + Microphone + Instruments chain — result recorded (target: ≤ 90 sec)
- [ ] Identified which segment is slowest and communicated it to the programmer

**All students**
- [ ] Know the broadcast chain order: `Cables → Microphone → Instruments → Notes 1`
- [ ] Can explain why each task is tested independently before chaining
- [ ] Can point to where the Clef, Speakers, and Amplifier are on the mat and know to avoid them

### Coach Notes — 3 Teams
- Session 3 is the session most likely to expose a wide gap between teams — one team may complete all three tasks while another is still debugging the cables route. This is normal at this stage.
- With only 1 mat: keep teams on a strict rotation; off-mat teams should **never be idle** — have them dry-run the robot path on the floor using tape marks, or refine code based on what they observed
- The broadcast chain (`Cables → Microphone → Instruments → Notes 1`) is the spine of the program — if a team hasn't grasped this by the end of Session 3, spend the first 10 minutes of Session 4 fixing it before any notes work
- Bonus alert for all teams: the **Clef, 2 × Speakers, and Amplifier** are worth 40 points (10 pts each) — remind all teams during debrief to program routes that pass well clear of all 4 objects
- **Partial scoring reminder:** cables score 5 pts each (not 0) if partly in the grey area or not upright — worth mentioning so teams don't give up on a cable that isn't perfectly placed

---

## Session 4 — Notes Delivery & Competition Simulation (2 Hours)

**Goal:** All 3 teams program the full 6-note delivery sequence, integrate the complete mission, then compete against each other in a timed mock competition.

### Group Instruction (0:00–0:20)

Brief all 9 students together:
- The notes task is worth **120 points** — nearly half the total score. This session decides the leaderboard.
- The notes program splits into 3 broadcast groups of 2 notes each — chained in sequence
- Each team's note routes will be different values but the same structure
- Announce the Session 4 mock competition format: each team gets 2 timed runs at the end; best score wins the session trophy

### Team Work (0:20–1:30)

**Program Notes 1, 2, and 3 (all teams)**

For each notes broadcast group:
1. Study the mat — identify each note's starting position and its matching colour target zone
2. Decide the delivery sequence within the group (closest note first)
3. For each note:
   - GyroStraight or FollowLine to note position
   - Open arms → advance to pick up → Close arms (use Close Arm Both 2/3/4 — notes are smaller than instruments, grip depth matters)
   - Navigate to the colour target zone
   - Open arms to release — verify note is upright
4. Test each group independently before chaining
5. Chain: Notes 1 working → add Notes 2 → test → add Notes 3 → test all three

Key programming habits:
- Reset yaw before every long straight segment
- Use `StopAtLine = 1` to stop automatically at the next black line — reliable positioning
- Use `FollowLine` for final approach to colour zones

### Mock Competition (1:30–2:00)

**Format:** Timed cross-team competition — all 3 teams run on the same mat one at a time.

Each team gets **2 runs**. Best score per team counts.

| Team | Run 1 Score | Run 1 Time | Run 2 Score | Run 2 Time | **Best Score** |
|---|---|---|---|---|---|
| Team A | | | | | |
| Team B | | | | | |
| Team C | | | | | |

Rules:
- Each run is exactly 2 minutes — coach acts as timekeeper and judge
- Between runs: **one fix only** — biggest failure, one change, done
- After all runs: brief debrief — what did each team do well that the others can learn from?

**The Surprise Rule Exercise** (if time allows, run before the final round):
- Announce a mock rule change mid-competition (e.g., "the microphone zone has moved 3 cm forward" or "one cable must be delivered last")
- Give all 3 teams **10 minutes simultaneously** to adapt their programs
- Observe how each team responds under pressure — this is the most valuable 10 minutes of the entire 8-hour programme

**Final Robot Check (all teams)**
- Tighten loose LEGO connections on all 3 robots
- Re-verify sensor mounting height on each robot
- Save final working program on each SPIKE hub
- Back up each program on a device

### Student Achievement Checklist — Session 4

**Builder**
- [ ] All 3 robots checked and tightened before mock competition
- [ ] Sensor mounting height verified on each robot after any adjustments
- [ ] Starting position marked and memorised — robot placed consistently at the start line

**Programmer**
- [ ] `[Notes 1]`, `[Notes 2]`, `[Notes 3]` broadcast handlers all programmed
- [ ] Each notes group tested independently before chaining
- [ ] Full chain `Notes 1 → Notes 2 → Notes 3` runs reliably
- [ ] Complete mission chain `Cables → Microphone → Instruments → Notes 1 → Notes 2 → Notes 3` runs end-to-end
- [ ] Final program saved on the SPIKE hub and backed up on a device

**Tester / Navigator**
- [ ] Timed the full mission — result recorded (target: ≤ 2 minutes)
- [ ] Scored each mock competition run — noted which objects were fully in zone and upright (20 pts), partly in or not upright (10 pts), or missed (0 pts)
- [ ] Identified and communicated the single biggest issue after each run

**All students**
- [ ] Every team member can explain what the robot does in 2–3 sentences
- [ ] Completed the Surprise Rule exercise — adapted the program within 10 minutes
- [ ] Know their competition day roles: who places the robot, who presses start, who observes

### Competition Day Checklist (Per Team)
- [ ] Final program saved on the SPIKE hub
- [ ] Program backed up on a device
- [ ] Robot, hub cable, and all building pieces packed
- [ ] Starting position on mat memorised
- [ ] Each team member knows their role: who places the robot, who presses start, who observes
- [ ] **No 3D-printed wheels** on the robot (banned for all teams — use LEGO wheels)
- [ ] Only original LEGO sensors fitted (SPIKE Prime is fine)

### ⚠️ Rule-Clarification Reminders (organizer update, 5 Jun 2026)
Coach these before the mock run and again on the day:
- **Release notes UPRIGHT — don't end a run still gripping a note.** The rules now warn that holding an object at match-end "can lift it slightly," which **fails the upright condition** (notes only score the full 20 upright). Make the routine open the arm and back off after each note.
- **"Completely in" is strict** — a note/cable/instrument scores only if it sits fully inside **one** zone, touching **no other area**. Tune the final placing nudge so objects don't straddle a line.
- **Fully autonomous** — no human may touch the robot to claim points (instant 0 for that score). Remind students: hands off once it starts.

---

## Coach Quick Reference

### Session Summary

| Session | Focus | Key Outcome |
|---|---|---|
| 1 | Build + Move + Arms | All 3 robots drive, turn, and grip objects |
| 2 | Gyro Straight + Line Follow | All 3 robots navigate accurately using sensors |
| 3 | Cables + Microphone + Instruments | Each team completes first 3 tasks in ≤ 90 seconds |
| 4 | Notes + Full Integration + Mock Competition | All 3 teams run full mission; cross-team leaderboard |

### Session Time Allocation

| Phase | Duration | Coach Action |
|---|---|---|
| Group instruction | 20 min | Teach concept to all 9 students together |
| Team work | 80 min | Circulate — ~25 min per team, prioritise most stuck team first |
| Group debrief | 20 min | Share results; post scoreboard; highlight one lesson from each team |

### Time Budget Per Full Run (Per Team)

| Task | Target |
|---|---|
| Cables × 2 | 30 seconds |
| Microphone | 15 seconds |
| Instruments × 3 | 45 seconds |
| Notes × 6 (3 groups) | 25 seconds |
| Buffer | 5 seconds |
| **Total** | **≤ 2 minutes** |

### Scoring Priority

| Priority | Task | Points | Why |
|---|---|---|---|
| 1 | Notes × 6 (upright + completely in) | 120 | Largest block — nearly half the score |
| 2 | Bonus — don't knock Clef, Speakers, Amplifier | 40 | Free points, no extra effort needed |
| 3 | Instruments × 3 (completely in backstage) | 45 | Consistent push-in scores reliably |
| 4 | Microphone (upright + completely in) | 20 | High value single object |
| 5 | Cables × 2 (upright + completely in) | 30 | First task — quick win closest to start |

### Broadcast Chain

```
Program Start
    └─▶ [Cables]
            └─▶ [Microphone]
                    └─▶ [Instruments]
                              └─▶ [Notes 1]
                                      └─▶ [Notes 2]
                                              └─▶ [Notes 3]
                                                      └─▶ END
```

---

## What Good Looks Like

**All 3 teams are competition-ready when each team can independently:**

1. Complete the full mission (cables, microphone, instruments, all 6 notes) in a single run under 2 minutes ✅
2. Deliver all 6 notes to correct colour zones consistently ✅
3. Score all 4 bonus objects (Clef, Speaker ×2, Amplifier — 10 pts each) without knocking them ✅
4. Adapt to a surprise rule change in under 10 minutes ✅
5. Every student on the team can explain what their robot does in 2–3 sentences ✅

**Minimum acceptable outcome (state competition threshold):**
- Every team scores at least cables + microphone + all instruments on a clean run (≥ 95 points)
- Every team has a functioning, complete program saved on their hub on competition day

---

*Coaching plan v3 — NRC 2026, RoboMission Rookie Primary*
*Based on WRO 2026 Elementary "Robot Rockstar" mission rules and actual SPIKE Prime block code*
*This is a suggested coaching framework, not an official NRC/WRO document*