Overview

In this project you will use Wobbledogs (www.wobbledogs.com) to explore how body shape and joint properties affect movement, then build and program a physical walking robot with a LEGO Education SPIKE Prime set to test and compare the results. This is a hands-on STEAM activity that connects virtual simulation, design thinking, measurement, and coding.

Learning goals (for a 15-year-old)

• Understand how morphology (leg length, joint stiffness, mass distribution) affects gait and stability.
• Design, build, and iterate a walking robot using the SPIKE Prime hardware.
• Program basic gait sequences in Python or Scratch and log performance data.
• Compare virtual and physical experiments, analyze results, and iterate designs.

Materials

• Computer with internet access (to run Wobbledogs in a browser).
• LEGO Education SPIKE Prime set (hub, motors, beams, connectors, sensors, cables).
• SPIKE Prime app (for Scratch or Python) installed on computer/tablet.
• Ruler or tape measure, stopwatch, notebook or spreadsheet for data.
• Tape, small weights (coins), rubber bands (optional) to change stiffness or mass.

Step-by-step plan

1. Explore Wobbledogs
   1. Play with several dog designs on wobbledogs.com. Change leg length, number of joints, joint placement, and see how they move.
   2. Pick 3–5 different designs that show clear differences (e.g., short-legged vs long-legged, floppy joints vs stiff joints).
   3. Define simple performance metrics to measure in the virtual world: e.g., time to travel 2 meters, number of falls in 1 minute, ability to climb/handle bumps. Record these in a table.
   4. For each design, run 3 trials and average the results. Note observations (wobbly, stable, fast, slow).
2. Make hypotheses

   Based on what you saw in Wobbledogs, write 2–3 hypotheses. Examples:

   • "Longer legs -> higher top speed but less stability"
   • "Stiffer joints -> fewer falls but smaller step size"
3. Design a LEGO robot inspired by the Wobbledogs

   Decide on a simple design you can build with SPIKE Prime. Two good options:

   • Two-motor differential-drive base (simple, good for testing body mass and friction rather than precise leg behavior).
   • Four-legged (quadruped) using 2–4 motors to approximate leg motion (harder but more directly comparable to Wobbledogs).

   For a 15-year-old I recommend starting with a simple 4-legged design using 2 motors: one motor controls the front-back leg motion (paired left/right), the other controls the back legs. This reduces mechanical complexity while letting you test leg length and timing changes.

4. Build checklist (suggested parts)
   • SPIKE Prime Hub
   • 2 or 4 Large Motors
   • Technic liftarms/beams to make the body and legs
   • Connector pins and angles to make joints; rubber bands or springs to add passive stiffness
   • Sensors: gyro/IMU (if available) to measure tilting, color/touch sensors for obstacles
5. Build steps (high level)
   1. Build a sturdy body/chassis that holds the hub and motors.
   2. Attach legs to rotating motor outputs or to a rocker mechanism driven by motors.
   3. Make leg length adjustable (use different beam lengths) so you can test variations quickly.
   4. Add small weights (coins) to change mass distribution, or rubber bands around joints to change stiffness.
6. Program a basic gait

   Use the SPIKE app with either Scratch blocks or Python (MicroPython). The general idea is to drive motors through a timed sequence that produces stepping motion.

   Simple Python-style pseudo-code (conceptual):

   from spike import PrimeHub, Motor, wait_for_seconds
   hub = PrimeHub()
   front_motor = Motor('A')   # attach front-leg mechanism
   back_motor = Motor('B')    # attach back-leg mechanism
   
   def step(front_power, back_power, duration):
       front_motor.run_for_seconds(duration, front_power)
       back_motor.run_for_seconds(duration, back_power)
   
   # simple alternating rhythm
   while True:
       step(60, -60, 0.4)   # lift front legs, lower back legs
       step(-60, 60, 0.4)   # opposite phase
       wait_for_seconds(0.05)
       

   Notes:

   • Use shorter/longer durations and different motor powers to change stride length and speed.
   • If you have four motors, you can sequence each leg independently for more natural gaits.
   • Start slow and test, then speed up once mechanics are safe.
7. Test, measure, and iterate
   1. Run the same performance tests you did in Wobbledogs (e.g., time to cross a fixed distance, number of falls, stability on a small ramp).
   2. Change one variable at a time (leg length, joint stiffness, motor power/timing) and record results.
   3. Compare data: does the physical robot show the same trends as Wobbledogs? If not, why might the simulator and reality differ?
8. Analyze results

   Put your recorded measurements into a spreadsheet and create simple charts: speed vs leg length, falls vs stiffness, etc. Write a short conclusion that states whether your hypotheses were supported and why.

9. Extensions (for extra challenge)
   • Implement an automated parameter search: vary motor timing and power automatically and log best-performing combinations.
   • Use the SPIKE hub gyro/IMU to measure tilt and keep the robot stable with feedback control (PID-like adjustments).
   • Create a "genetic algorithm" that mutates parameters and selects for speed or stability, inspired by the Wobbledogs breeding idea.

Practical tips and safety

• Keep speeds low when first testing mechanical parts to avoid breaking beams or motors.
• Securely mount the hub so cables don't snag during motion.
• If legs slip on the floor, add tape or rubber pads to foot tips to increase traction.
• Document each change carefully—good notes make analysis much easier.

Assessment ideas

• Design report (1–2 pages): hypothesis, design sketches, test procedure, data, conclusions.
• Demonstration: run two different designs and explain why one performs better.
• Code review: submit the SPIKE program and comment key parts (timing, motor control, sensors).

Why this is a good project

Wobbledogs gives an intuitive and fun way to see how shape affects movement. Building a physical robot with SPIKE Prime turns those observations into engineering practice: you’ll learn mechanical design, iterative testing, and programming. Comparing virtual and physical results also teaches the important scientific idea that models simplify reality, so experiments and testing are necessary.

If you want, tell me which SPIKE Prime parts you have (how many motors/sensors) and which Wobbledogs designs you liked, and I will give a detailed build plan and a starter Python program matched to your parts.