Student's Companion: LEGO SPIKE Prime

At a glance

Big idea: Your yellow Hub is a brain that is currently "asleep". You will wake it up with a tiny Python program.

• Robotics experience needed: None. You just follow this page step by step.
• Python experience needed: None. You will type a few short lines and read the explanations underneath.
• Main outcomes: Battery inserted, Hub connected over Bluetooth, and your first program runs successfully on the Hub display.

Before you start

• A LEGO SPIKE Prime kit with a Hub, battery, charging cable, and at least two motors in the box.
• A laptop or tablet with the LEGO SPIKE App installed (Python mode available).
• A USB cable or working Bluetooth on your device.
• Optional but helpful: open the LEGO Education SPIKE Prime resources page in a separate tab.

Story to understand before you code (10–15 mins)

Read this slowly. If you have teammates, you can read it out loud as if you are the teacher.

1. The story: "This yellow brick is a $300 brain. Right now, it is in a coma. Today you will perform brain surgery to wake it up using a language called Python."
2. Libraries: Write (or just look at) this line: from hub import light_matrix. Think of Python as an empty toolbox. You import the tools you need. Today you import the Hub's tiny light display.
3. Goal: Your mission is to make the Hub count down 5-4-3-2-1 and then show a happy face. That tells you the brain is awake and listening.

Phase 1 – Get your kit ready (10–15 mins)

Before opening the laptop, get control of the LEGO pieces so they do not explode across the room or table.

• Sort pieces roughly into the main tray sections (it does not need to be perfect).
• Check that the Hub, battery, and motors are in the kit and easy to find.
• Remember: organized kits = more building and coding time later.

Phase 2 – Your first script (30–40 mins)

Now you will create your first Python program. Follow these steps slowly—don't rush the typing.

1. Connect the Hub: Insert the battery into the Hub, turn it on, and connect via Bluetooth or USB inside the SPIKE app (follow the on‑screen prompts).
2. Create a Python project: In the SPIKE app, create a new project and choose the Python option (not word blocks).
3. Type the code: Look at the code example below. Type each line carefully. If you get stuck, read the explanation under the code.
4. Run the program: Press the Run button in the SPIKE app. Check that the numbers and happy face appear on the Hub.
5. Extension (if you have time): Change the message, speed, or picture and see what happens.

At a glance

Big idea: You build the first driving base and teach the brain (Hub) to recognize its legs (motors) so it can drive in a straight line.

• Robotics experience needed: None. You follow the build instructions and a simple script.
• Python experience needed: Very little. You will copy one short program.
• Main outcomes: Drive Base 1 is built, motors are paired with the Hub, and the robot completes a simple drag race (forward, pause, backward).

Before you start building

• Open the SPIKE app and find the build for Drive Base 1 ("Competition Ready – Training Camp 1: Driving Around").
• Optional: on the LEGO Education SPIKE Prime page you can explore other builds and lessons.
• Check that your kit has two motors and a Hub with enough battery.
• Choose a flat place to run your drag race (a 1 metre strip on the floor or a long table).

Understand the handshake story (10–15 mins)

Read this explanation before you write code. Imagine explaining it to a friend who just joined your team.

1. In your code (or on paper), look at this line: motor_pair.pair(motor_pair.PAIR_1, port.C, port.D) and notice C and D. You are telling the brain which ports are the wheels.
2. Draw a quick sketch of the Hub and label ports C and D. On your real robot, trace the cables and make sure C is left and D is right.
3. Remember: once the handshake is done, you can say "Drive!" and both wheels move together like a three‑legged race team.

Phase 1 – Build the robot (40–60 mins)

Follow the official instructions to build Drive Base 1.

• If you are working in a team, give one person the job of finding pieces and one the job of building.
• Swap jobs every 15 minutes so everyone gets hands‑on time.
• Press on each wheel and check that it is firmly attached and that cables are not tangled.

Phase 2 – The drag race code (30–40 mins)

Now that the robot has legs, you will give it a simple mission: drive forward 50cm, pause, then drive back.

1. Confirm motors are plugged into ports C (left) and D (right).
2. Create a new Python project in the SPIKE app.
3. Type the code below, one line at a time, checking spelling and indentation carefully.
4. Place the robot at the start of your taped drag strip and run the program.

At a glance

Big idea: Instead of writing the same movement over and over, you use a loop to make the robot drive in a square.

• Robotics experience needed: You already have Drive Base 1 from Week 2.
• Python experience needed: You know basic movement; this week introduces the for loop.
• Main outcomes: You write a loop to drive four equal sides and adjust the turning amount (around 176 degrees) so your robot makes clean 90° corners.

Before you start

• Make sure your robot is still built as Drive Base 1 with motors on ports C and D.
• Clear a square area on the floor or table for testing. Optional: tape a large square route.
• Have a ruler or measuring tape so you can estimate 20cm segments.

Understand the loop story (10–15 mins)

1. Sketch a square path with four equal sides. Label each side "Forward" and each corner "Turn".
2. Write this mini-loop: for i in range(4): and remember it means "repeat the next steps 4 times".
3. Notice that turning the wheel 90 degrees does not turn the robot 90 degrees. You must experiment to find the magic number (around 176).

Phase 1 – The turning mystery (20–30 mins)

Goal: Feel the difference between wheel degrees and robot degrees.

• Guess: if you turn the wheel 90 degrees, will the robot turn 90 degrees?
• Test different turning amounts (for example 90, 140, 176 degrees) and watch how far the robot turns.
• Write down which number gets you closest to a clean corner (usually around 176°).

Phase 2 – The square challenge (40–50 mins)

Mission: Drive in a perfect square: forward, turn right, repeat 4 times.

1. Sketch the square path and label each side 20cm.
2. Plan that the loop will run 4 times: drive forward, then turn, then repeat.
3. Type the full program below, then tweak the turning amount until the robot ends where it started.

At a glance

Big idea: Steering is not just left or right. It is a dial that controls how sharply the robot turns.

• Robotics experience needed: You already have a working Drive Base from Weeks 2–3.
• Python experience needed: You can already move forward and turn. This week you adjust the steering parameter to drive in curves.
• Main outcomes: You understand steering values (0, 20, 50, 100) and program a slalom path weaving between cups without touching them.

Before you start this mission

• Check your robot is still Drive Base 1 with motors on ports C and D.
• Prepare at least 3 cups or small objects to act as slalom cones.
• Mark a straight lane with tape and place the cups in a line with enough space to weave between them.

Steering story (10–15 mins)

Use this explanation to think about steering like a volume knob. Read it out loud if you are working with a partner.

Think of this cheat sheet:

Phase 1 – Steering practice (20–30 mins)

Goal: See how different steering values change the path.

• Drive the robot straight with steering 0 for a short distance.
• Repeat with steering 20, then 50, then 100, and describe each path (gentle curve vs. pivot vs. spin).

Phase 2 – The slalom challenge (40–50 mins)

Mission: Program the robot to weave around the cups in an S-shape without knocking them over.

1. Place three cups in a straight line along the lane.
2. Use two curves: curve right (positive steering) then curve left (negative steering).
3. Adjust the distance and steering until the robot passes between the cups cleanly.

At a glance

Big idea: Your robot needs a sense of touch. With a Force Sensor and a while loop, it can bump into a wall, stop, beep, and back up.

• Robotics experience needed: You upgrade to Drive Base 2 with a Force Sensor mounted on the front.
• Python experience needed: You already know movement; this week you use a while loop for "wait until" logic.
• Main outcomes: Your robot drives forward, waits for a collision, then stops, beeps, and reverses safely.

Before you start

• Upgrade your robot to Drive Base 2 using the official LEGO instructions.
• Mount the Force Sensor on the front and plug it into Port E.
• Set up a solid wall or box for the robot to bump into (never a person).

Concept story (10–15 mins)

• Look at the Force Sensor and press it with your finger. This is the robot's fingertip.
• Write (or read) the line while not force_sensor.is_pressed(port.E): and remember it means: "keep waiting until the button is pressed".

Phase 1 – Bumper car mission (40–50 mins)

Mission: Drive forward until the robot hits the wall, then stop, beep, and reverse.

1. Place the robot a safe distance from the wall with the Force Sensor pointing forward.
2. Type the full program below and predict what will happen when the robot touches the wall.
3. Run the program and watch for the exact moment the sensor is pressed.

At a glance

Big idea: The robot can "see" how far away walls are using sound, like a bat. You teach it a safety rule: if distance < 10cm, stop.

• Robotics experience needed: Drive Base 2 with Distance Sensor attached to the front (usually Port F).
• Python experience needed: You know while loops from Week 5; this week adds a comparison (<) and the special value -1 for "no object".
• Main outcomes: Your robot drives toward a wall and stops itself at about 10cm before crashing.

Before you start

• Upgrade your robot to Drive Base 2 and mount the Distance Sensor on the front (Port F).
• Set up a solid wall or box as the target. Avoid soft surfaces like pillows or clothing.
• Have a ruler or tape measure ready so you can see what 10cm looks like.

Physics story (10–15 mins)

Topic: Echolocation & thresholds.

Phase 1 – Measuring distance (15–20 mins)

Let yourself see the numbers from the Distance Sensor.

• Notice how the sensor returns numbers in centimeters and -1 when it sees "infinity" (nothing).
• Move the robot closer and farther from the wall and call out the distances.

Phase 2 – Don't crash (40–50 mins)

Mission: Drive toward the wall and stop at around 10cm.

1. Place the robot facing the wall with at least 50–80cm of space.
2. Type the full program below.
3. Test and adjust the 10cm threshold if needed for your surface.

At a glance

Big idea: The robot reads colors and uses if / elif decisions to follow simple traffic rules.

• Robotics experience needed: Same drive base; add a Color Sensor pointing at the floor (usually Port A).
• Python experience needed: You know loops; this week you combine a while True loop with if / elif decisions.
• Main outcomes: Your robot drives over green and red patches, speeding up on green and stopping on red.

Before you start

• Attach the Color Sensor pointing down and plug it into Port A.
• Tape pieces of green and red paper to the floor or table where the robot will drive.

Logic story (10–15 mins)

• Draw a simple tree: "Is it GREEN?" → Go Fast. "Else, is it RED?" → Stop.
• Remember: the robot checks one condition at a time, in order.

Phase 1 – Traffic school activity (40–50 mins)

Mission: Drive slowly until the robot sees green or red.

1. Place green and red patches along the robot's path.
2. Type the program below and test whether the robot speeds up on green and stops on red.

At a glance

Big idea: Line following is a "holy grail" robotics skill. The robot cannot actually see a line; it only measures brightness and constantly nudges left/right to stay on the edge.

• Robotics experience needed: Same drive base and Color Sensor as Week 7.
• Python experience needed: You are comfortable with loops and if. This week you tune thresholds.
• Main outcomes: Your robot follows a curvy black tape line by "wiggling" around its edge.

Before you start

• Lay a long, curved strip of black electrical tape on a light-coloured floor or board.
• Position the Color Sensor so it watches the tape from a few millimetres above the surface.

Phase 1 – Wiggle demo (15–20 mins)

• Walk along a tape line and act out the algorithm: "Too bright → turn right. Too dark → turn left." Say it out loud as you move.
• Remember: the robot repeats this check many times per second.

Phase 2 – Line following mission (40–50 mins)

Mission: Follow a curvy tape line from start to finish without leaving it.

1. Place the robot so the Color Sensor sits over the edge of the black tape.
2. Type the full line-following program below.
3. Test, then tweak the threshold value (starting at 50) if your surface is lighter or darker.

At a glance

Big idea: Your robot transforms into an advanced drive base with gears and an arm (Drive Base 3).

• Robotics experience needed: You are familiar with Drive Base 1–2 builds.
• Python experience needed: None new this week. Focus is on careful building.
• Main outcomes: Drive Base 3 is fully built with good cable management and working gears.

Before you start

• Open the LEGO instructions for Drive Base 3 (Competition Ready – Training Camp 4).
• Check that your kit has all beams, gears, and the extra motor required for the arm.
• Plan enough time: this is a long build (up to 90 minutes).

Story & expectations (10 mins)

• Today’s success is a strong, reliable build, not new code.
• Slow down and double-check each step in the instructions.

Phase 1 – The big build (60–90 mins)

• Carefully dismantle your old drive base and sort useful parts.
• While you build, count the teeth on key gears and guess what changing gear ratios might do to speed or strength.
• Check that cables are neat and not wrapped tightly around moving parts.

At a glance

Big idea: The arm is not a pair of wheels. It is a single motor you control directly using degrees.

• Robotics experience needed: Drive Base 3 from Week 9, with an arm on Port E.
• Python experience needed: You learn to use motor.run_for_degrees() and combine motion with the claw.
• Main outcomes: Your robot can raise/lower the arm to grab and place an object.

Before you start

• Confirm the arm motor is plugged into Port E.
• Prepare a small brick and a raised surface (like a book) to act as the drop-off spot.

Concept story (10–15 mins)

• Think of await motor.run_for_degrees(port.E, 90, velocity=300) as bending an elbow 90 degrees.

Phase 1 – Forklift mission (40–50 mins)

Mission: Start with the arm up, drive to a brick, lower the arm to grab it, lift it, drive forward, and place it gently on a book.

1. Place a brick in front of the robot and a book a short distance away.
2. Type the full program below, then fine-tune degrees to match your specific arm build.

At a glance

Big idea: Instead of repeating the same arm code over and over, you give it a name and call it as a function.

• Robotics experience needed: Same robot as Week 10.
• Python experience needed: You create and use your first custom function.
• Main outcomes: Your program has a grab_thing() function that you call from the main code.

Before you start

• No special build changes; use the robot from Week 10.
• Think of a simple non-robot example of a function, like: def morning(): wake_up(), eat(), brush().

Concept story (10–15 mins)

• First imagine a function in English (for example morning() → wake up, eat, brush).
• Then look at the Python version: async def grab_thing(): and notice that everything indented under it belongs to that function.

Phase 1 – Build the function (25–30 mins)

Mission: Create a grab_thing() function that opens and closes the claw.

1. Type the function definition async def grab_thing(): and put the arm code inside it.
2. At first, just test the function by calling it once; make sure it moves the arm correctly.

Phase 2 – Use the function in a mission (25–30 mins)

Mission: Drive to a brick, use grab_thing() to pick it up, and then return.

1. Add calls to grab_thing() in your main code at the right time.
2. Run the program and adjust arm degrees as needed.

At a glance

Big idea: Plan your final competition mission on paper before you touch the robot.

• Robotics experience needed: You know how to drive, use sensors, and move the arm.
• Python experience needed: Today you mostly use "pseudo-code" (plain English steps) instead of real code.
• Main outcomes: Your team has a clear written plan for how your robot will complete the mission.

Before you start

• Set up a simple competition field with:
  • Zone A: Base
  • Zone B: Sample/brick area
  • Zone C: Drop-off zone
• Prepare large paper and pencils or markers for your team.

At a glance

Big idea: Failure is expected. You learn to debug robots systematically.

• Main outcomes: You run your planned mission, find problems, and improve your code or build.

Engineering mindset (10 mins)