Shaking Game

Overview

Students learn to program the Micro:bit to react to shake movement and use that behavior to build a “shaking game.” This lesson continues building toward a working event-driven project in the Micro:bit Explorers unit.

Learning intentions

• Students will be able to explain how the shake feature triggers an event on the Micro:bit.
• Students will be able to write a simple program that displays output after a shake.
• Students will be able to organize game ideas into categories (goal, rules, controls, feedback).
• Students will be able to revise their program based on test results.

Success criteria

• I can describe what “shake” detects and when my code runs.
• I can create a program where shaking changes what the Micro:bit shows.
• I can test my game, identify what is not working, and fix it.
• I can present my game plan using a clear mini-outline with headings and/or a table.

Curriculum links

• Writing: organize ideas into broader categories and include formatting/graphics to aid comprehension (CCSS.ELA-LITERACY.WHST.6-8.2a).
• Conduct a short research project using multiple sources and generate focused questions (CCSS.ELA-LITERACY.WHST.6-8.7).
• Use technology to produce and publish writing and clearly show relationships between ideas (CCSS.ELA-LITERACY.WHST.6-8.6).
• Write for shorter time frames, with time to reflect and revise (CCSS.ELA-LITERACY.WHST.6-8.10).
• Strengthen writing through planning and revising based on purpose and audience (CCSS.ELA-LITERACY.WHST.6-8.5).

Lesson structure (45 minutes)

1. 0–5 min · Hook + question. Teacher demonstrates a quick Micro:bit shake response (or shows a short demo clip) and asks: “What do you notice happens right after you shake?” Students do a quick think-write: one sentence describing cause and effect they observe.

2. 5–12 min · Mini-lesson: event logic. Teacher explains that shake movement triggers code (event-driven behavior) and shows a starter block example using shake detection and a simple display outcome. Students sketch a 3-box flow: “Shake happens → Micro:bit detects → Display changes.”

3. 12–18 min · Guided build: “Shake to Score.” Teacher distributes a starter template and walks through building the first version: when shake is detected, increase a score variable and show score briefly. Students follow along on their Micro:bit simulators/devices, then test with 3 shakes and record what they see.

4. 18–26 min · Research + plan (quick). Teacher prompts a brief, student-friendly research step: “Find one detail about how shake detection works (for example, sensitivity ideas or recommended ways to test). Then make a game plan.” Students use assigned printed/digital reference cards (no hyperlinks) and fill out a mini-planning sheet with headings: Goal, Rules, Controls, Feedback plus a simple table of “Shake count → Display.”

5. 26–36 min · Independent build: make it a game. Teacher sets requirements:

• Must respond to shake with at least one clear feedback method (number, pattern, or message).
• Must include a “win” condition (example: reach 5 points) and a reset or end state.
• Must be testable within 1 minute. Students improve their program, adding win/reset behavior and tweaking timing so feedback is readable.

6. 36–42 min · Pair test + troubleshoot. Teacher models a troubleshooting routine: “Change one thing, test again, note the result.” Students swap Micro:bits or swap roles: Player (shakes and watches) and Builder (tracks results, identifies one fix to try).

7. 42–45 min · Share-out + exit check. Teacher has 2–3 students share one successful feature and one fix they made. Students complete a 1-question exit ticket: “In my game, shaking triggers code that makes ______ happen.”

Resources

• Micro:bit kits (1 per student or shared pairs)
• USB cables / charging station (if needed)
• Teacher-prepared starter code for shake-detection game
• Student mini-planning sheet (Goal/Rules/Controls/Feedback)
• Simple reference cards about Micro:bit shake feature and testing tips
• Timer for quick playtesting (phone timer or classroom timer)
• Device logs or notebook page for test notes
• Project submission checklist for the last 3 minutes of class

Assessment

• Formative checks during the guided build: teacher listens for correct cause-and-effect statements and verifies the first shake response works.
• During independent build, teacher uses a quick rubric checklist: shake triggers output, win condition exists, feedback is visible/readable.
• Exit ticket confirms understanding: students fill in how shaking triggers a specific behavior in their program.

Differentiation

• Support: Provide sentence starters for the plan (“My goal is…,” “When the Micro:bit shakes, it will…,” “Players win when…”).
• Support: Offer a “minimum viable game” version with preset win condition (e.g., 3 points) and reset behavior.
• Extension: Challenge students to add a second behavior (example: different output on the first shake vs. later shakes, or a short animation on win).
• EAL/SEN: Use visual step-by-step icons in the planning sheet and allow drawing instead of long written explanations for the first draft.