What is a Wobbledog?

Wobbledogs are small toys that walk by converting a simple motor rotation into a wobbling motion. That wobble shifts the toy’s center of mass so its legs alternately catch and slip, producing a walking action without complex joint control. We can copy that idea with LEGO Education SPIKE Prime (hub + motors + beams) to make a fun robot that ‘wobbles’ forward.

Overview — how we’ll proceed

1. Understand the walking principle (wobble + shift center of mass).
2. Decide a mechanical design that produces an asymmetric wobble (cam, eccentric wheel, crank, or pantograph legs).
3. Build a chassis with the SPIKE Hub and at least one motor that creates the wobble.
4. Write a SPIKE program (Scratch or Python) to drive the motor and tune speed/phase.
5. Test, observe, and iterate.

Parts you’ll need

• LEGO Education SPIKE Prime Hub
• 1–2 Large Motors (for main wobble and optional steering)
• Beams, liftarms, connectors to build body and legs
• Axles and bushings to build cams/cranks
• Rubber pieces or friction pads for feet
• Optional sensors: Color/Distance sensor, Gyro (IMU) for advanced behaviors
• Rubber bands or flexible elements for springy leg action

Mechanical design ideas (choose one)

All of these produce a side‑to‑side wobble or shifting center of mass:

• Eccentric cam / off‑center axle: Fix a disc or wheel so its rotational center is offset. As it spins, it lifts and drops the body in a cycle. Simple and effective.
• Crank and connecting rod (oscillating axle): Use a motor turning a crank that pushes a small rocker back and forth. The rocker moves legs so they alternate grip/slide.
• Pantograph or four‑bar leg linkage: Converts rotation to an oval foot path—gives better controlled foot contact phases.
• Two independent leg clusters: One motor drives left legs, another drives right; phasing them slightly creates a forward bias.

Simple suggested build (1 motor, eccentric wobble)

1. Mount the SPIKE hub centrally on a rectangular chassis made of beams.
2. Attach one large motor under the chassis so its axle points sideways and can carry an eccentric cam (a wheel or disc built from round pieces or a small gear offset with spacers).
3. From the chassis, build 4 legs — two in front and two in back. Make them wide and slightly flexible so they can tilt and slip. Attach small friction pads at the feet.
4. Connect legs to the body so that when the cam turns, the whole body tilts side to side and the legs alternately press and release the floor.
5. Adjust leg length and foot friction so each swing causes one side to catch (push forward) while the other slides backward or stays passive.

Programming concept

You don’t need precise gait control. The motor simply spins at a steady speed or with small speed variations. Key parameters to tune in code are motor power (speed), acceleration and whether you occasionally reverse or pulse the motor to make the step more effective.

Example SPIKE Python code (MicroPython)

This example uses a single motor on port A. It spins continuously at power 30. Adjust power and sleep timing to change step size. For SPIKE Prime, these imports work in the Python environment in the SPIKE app.

from spike import PrimeHub, Motor
import time

hub = PrimeHub()
motor = Motor('A')   # change port if needed

try:
    while True:
        # spin forward slowly to create wobble
        motor.start_at_power(30)   # try 20-40 for gentle steps
        time.sleep(2.0)            # how long each wobble cycle lasts

        # a short reverse pulse can help 'reset' the legs:
        motor.start_at_power(-20)
        time.sleep(0.15)

        # continue forward
        motor.start_at_power(30)
        time.sleep(0.05)

except KeyboardInterrupt:
    motor.stop()

Notes:

• Use motor.run_for_degrees(...) instead of start_at_power(...) if you want precise cycles.
• Try different power values and sleep durations to find the best walking motion.
• If the motor stalls, lower power or add a small gear reduction.

Tuning and troubleshooting

• If it just spins in place: increase foot friction on the side that should push, or shorten the legs so the body displacement produces forward motion.
• If it flips or tips: lower the center of mass (move hub down), make the base wider, or reduce wobble amplitude.
• If it stalls or motor overheats: reduce load, add gearing, or use two motors sharing the load.
• If motion is jerky: smooth the motor power changes or add small rubber bands to provide spring damping.

Experiments and extensions (challenge ideas for a 15‑year‑old)

• Add a color or distance sensor so the Wobbledog avoids obstacles or follows a colored path.
• Use a second motor to steer (change the phase between left and right) so the robot can turn.
• Record motor current or stall events (if available) to detect when the robot is stuck and try a recovery routine.
• Replace the simple eccentric cam with linkages that make the foot trace an oval path—this produces more efficient walking.
• Try writing the controller in Scratch blocks first, then convert to Python to learn both styles.

How to approach the project in class or at home

1. Sketch an idea on paper: where the motor will sit, how legs attach, where the center of mass will be.
2. Build a quick prototype with simple beams and test the wobble before refining the legs.
3. Program a basic continuous spin and watch how the robot moves. Make one mechanical change at a time and retest.
4. Keep notes: record motor power, wobble size, leg length, and how well it walked. That’s the engineering design loop.

Final tips

• Start simple. A basic eccentric wobble often works better than a complex linkage on the first try.
• Small geometry changes make big differences—experiment with leg angles and foot friction.
• Use the SPIKE app’s live play mode to change motor power quickly while the robot runs; it speeds up tuning.

If you want, tell me which SPIKE parts you have and I can sketch a specific parts list and a step‑by‑step build plan (with photos or diagrams suggested), or I can convert the Python code above into Scratch blocks.