Microbit Maker Connections

Overview

Today’s focus is connecting Micro:bit inputs/outputs to simple engineering decisions, starting with the idea of “if-then” behavior using beginner blocks. This builds toward interpreting and representing relationships in real problems (including fractions/quantities) while using MakeCode to test solutions.

Learning intentions

• Students will be able to turn on a Micro:bit and load a basic MakeCode program.
• Students will be able to use event and input blocks to make the Micro:bit respond.
• Students will be able to explain how changing an input changes an output in a test cycle.
• Students will be able to solve one real-world “share/quantity” fraction-of-amount situation using an equation.

Success criteria

• I can write a MakeCode program that changes behavior when a button is pressed or when the accelerometer is tilted.
• I can describe my test plan and record results using a simple data table.
• I can represent a word problem about sharing or “how many parts” as an equation with fractions and check it with a model.
• I can improve my program after debugging.

Curriculum links

• The Number System — interpret and compute quotients of fractions and solve word problems involving division of fractions by fractions.
• Engineering habits of mind (test, iterate, refine) aligned with applying CS ideas to solve problems (Micro:bit maker approach).
• Number line, inequalities, and signed quantities are not used today, but will be supported in later weeks with sensors and data displays (CCSS.MATH.CONTENT.6.NS.C.5, CCSS.MATH.CONTENT.6.NS.C.7a).

Lesson structure (45 minutes)

1. 0–5 min · Hook (demo + question). Teacher shows a Micro:bit reacting to input (button press or tilt) and asks, “What do you notice changes, and what stays the same?” Students quick-share observations and predict what happens next.

2. 5–12 min · Direct teach (MakeCode start). Teacher guides students to open MakeCode, connect the Micro:bit, and explains the core block idea: input event triggers output behavior. Students assemble a starter program that scrolls “HELLO” (or displays a single icon) when Button A is pressed.

3. 12–22 min · Guided build (event + output + test table). Teacher models adding a second behavior for Button B (ex: different icon or scroll text) and shows how to test and record. Students add Button B behavior, then complete a quick “Test Results” table: input used, output observed, and “works/needs change.”

4. 22–32 min · Engineering challenge (debug with evidence). Teacher introduces a mini design prompt: “Make a reaction game: Press A to start, tilt to change the display, press B to reset.” Students implement a simple version using available blocks (events + display), test, and debug at least once using evidence from their table.

5. 32–40 min · Fraction connection sprint (real-world story). Teacher reads: “How much chocolate will each person get if 3 people share 1/2 lb equally?” Teacher prompts students to write an equation for the “each person gets” amount using division of fractions. Students solve with a fraction model or equation, then share one reasoning sentence.

6. 40–45 min · Exit ticket (reflect + next step). Teacher collects exit tickets: one MakeCode reflection and one fraction check. Students submit: (1) one sentence describing a change they made, (2) their fraction result for the share problem.

Resources

• Micro:bit devices (1 per student or per 2 students if needed)
• USB cables for flashing/programming
• MakeCode editor access on classroom computers/tablets
• Micro:bit “Getting Started” materials and basic starter code sheets (teacher-made or printed)
• Teacher slideshow (demo of input → output → test)
• Student worksheet template (Google Doc/Word) with:
• Test Results table
• Engineering prompt space
• Fraction sprint question with lined response
• Fraction scratch paper or fraction strips (optional but helpful)

Assessment

• During guided build: teacher checks that students can connect, upload, and get at least one correct button-driven output.
• During engineering challenge: review their Test Results table for evidence-based debugging (not just guesses).
• Exit ticket: accuracy on the fraction sharing problem and a clear reflection on one design/testing change.

Differentiation

• Support:
• Provide a partially completed MakeCode project (starter with Button A) so learners focus on Button B + testing.
• Sentence starters for reflections: “I changed ___ because I observed ___.”
• Offer a simplified fraction model (circles/strips) for students who need visuals for division of fractions.
• Extension (advanced learners):
• Add a scoring counter: each correct tilt increments points; Button B resets score.
• Add a “mode” using two inputs (Button A selects icon set; tilt cycles through icons).
• For fractions: create and solve a second share problem using a different fraction (e.g., 4 people share 3/4 lb).
• EAL/SEN:
• Use icon-only display choices to reduce language load during CS debugging.
• Allow oral explanation recorded by teacher/peer for the fraction sprint.
• Provide bilingual word bank on the worksheet (input, output, test, change, button, tilt, reset).

5-week micro:bit mini-unit mapping (15 lessons, 45 minutes each)

Note: This message contains the full structure for Lesson 1 today; the remaining 14 lessons follow the same 45-minute pattern: hook → guided build → engineering prompt → quick math connection → exit ticket.

• Week 1 (Lessons 1–3): Start-up + input/output events + first test cycle.

• Lesson 1 (today): Button/tilt events and display outputs + fraction share sprint.

• Lesson 2: Sensors (light level or temperature) shown on the display; compare before/after.

• Lesson 3: Simple branching (if/else) based on sensor thresholds; engineering iteration.

• Week 2 (Lessons 4–6): Data + behavior rules.

• Lesson 4: Data logging basics (collect values over time conceptually; show on display).

• Lesson 5: Multi-step state behavior (start/reset) and debugging strategies.

• Lesson 6: Connect math story problems to sensor outputs (use equations and ratios-of-quantities).

• ** Week 3 (Lessons 7–9): Physical computing + design constraints.

• Lesson 7: Add motion-based games (tilt controls movement icons).

• Lesson 8: Use buttons for menu states; students plan and test a “mode selector.”

• Lesson 9: Engineering design challenge: “Build a safety indicator” with thresholds.

• Week 4 (Lessons 10–12): Refine and present.

• Lesson 10: Improve reliability (debounce-like thinking with repeated tests; avoid “works once”).

• Lesson 11: Create a polished demo: instructions, labeled test results, and explanation.

• Lesson 12: Math integration day (fraction/ratio story problems tied to measurement and display).

• Week 5 (Lessons 13–15): Freedom project (student choice).

• Lesson 13: Project planning + build outline + success criteria.

• Lesson 14: Build + peer test + revisions.

• Lesson 15: Showcase + reflection on input/output and one math explanation from their story.

15-lesson success criteria expectation (unit-level)

• Students can create at least one functioning Micro:bit program using events and conditional behavior.
• Students can run tests, record results, and revise their design.
• Students can connect a real-world quantity problem to an equation using fraction division when relevant.

(Trusted Micro:bit/MakeCode lesson resources to pull from each day include the Micro:bit Teach lessons, MakeCode course units, and maker pathways from Code.org as applicable; teachers should select the specific beginner modules that match the day’s target blocks.)