Time-Based Robot Control: Mastering move_tank_for_time for Choreography and Education

Introduction

Time-based motor control represents a distinct paradigm in robotics programming, prioritizing temporal synchronization over spatial positioning. The LEGO SPIKE Prime move_tank_for_time method exemplifies this approach: instead of specifying how far wheels should rotate, you specify how long motors should run at given velocities. This temporal focus makes time-based control ideal for choreographed performances, synchronized multi-robot systems, and educational scenarios where students need to coordinate robot actions with external events like music beats, light shows, or human interactions.

For robotics educators, move_tank_for_time offers unique pedagogical advantages. Students can design routines using intuitive timing concepts (“move forward for 2 seconds”) without needing to calculate wheel rotations or understand encoder counts. The method’s simplicity lowers barriers to entry while still teaching fundamental concepts like velocity control, differential drive mechanics, and sequential programming. This article examines the technical foundations of time-based tank drive, explores async programming integration, and presents educational strategies leveraging tools like the LEGO SPIKE move_tank_for_time Motion Sequencer.

Background: Temporal Control in Differential Drive Systems

Time-based motor control combines two core parameters: duration and velocity. The mathematical model is straightforward:

Distance Traveled: For a motor running at velocity v for duration t, the approximate distance is d = v × t × k, where k is a proportionality constant depending on wheel diameter, surface friction, and battery voltage. Unlike position-based commands with encoder feedback, time-based commands are open-loop—they don’t verify actual distance traveled.

Turning Behavior: When left and right motors run at different velocities, the robot follows a curved path. The instantaneous turning radius depends on the velocity ratio and wheel spacing (track width). For move_tank_for_time(duration, left_speed, right_speed):

Equal speeds → straight line (radius = infinity)
Opposite-sign equal magnitudes → point turn (radius = 0)
Different magnitudes → arc with radius proportional to speed ratio

Timing Precision: SPIKE Prime’s async runtime scheduler manages timing with millisecond precision, using hardware timers to trigger motor stops. Theoretical timing accuracy is ±10ms, but real-world factors (motor response lag, mechanical inertia, code execution overhead) typically produce ±50-100ms variation. For most educational and performance applications, this precision suffices.

Repeatability vs. Determinism: Time-based commands offer high repeatability (running the same command produces similar results) but lower determinism than position-based commands. Surface changes, battery discharge, and temperature variations affect speed-to-distance relationships, meaning a 2-second forward command might travel 40cm on one run and 38cm on another. This trade-off between temporal predictability and spatial accuracy defines the time-based control paradigm.

These characteristics make move_tank_for_time excellent for applications where timing matters more than endpoint position: performances, demonstrations, educational exercises focused on sequencing and timing, and multi-robot synchronization where robots coordinate actions rather than positions.

Workflows: Designing Time-Based Robot Routines

Workflow 1: Single-Event Choreography

For simple timed routines like “robot spins for 3 seconds then stops”:

Define Desired Motion: Specify behavior in temporal terms (“spin right for 3 seconds at moderate speed”)
Choose Parameters: Select duration (3.0 seconds) and motor speeds (e.g., left=60, right=-60 for right spin)
Test in Motion Sequencer: Create a single-step sequence and preview the animation
Adjust for Effect: If the spin is too fast or slow, adjust motor speeds rather than duration (preserves timing)
Export and Deploy: Generate async Python code and upload to SPIKE hub
Validate Timing: Use a stopwatch to verify actual duration matches intended 3 seconds
Refine: If timing is off, check for battery charge and code execution overhead

This workflow emphasizes iterative refinement based on observed behavior, teaching students empirical validation skills.

Workflow 2: Multi-Step Performance Design

For complex routines like robot dances or multi-segment demonstrations:

Storyboard the Routine: Sketch or write narrative descriptions of each movement segment
Assign Durations: Determine how long each segment should last based on music, narration, or pacing
Build in Motion Sequencer: Add steps to timeline one at a time, setting durations and motor speeds
Preview Full Routine: Watch animated path to verify flow and aesthetic appeal
Identify Transitions: Look for jarring speed changes or awkward pauses between steps
Smooth Transitions: Adjust motor speeds at boundaries (e.g., ramp down at end of segment, ramp up at start of next)
Add Markers: Annotate steps with event descriptions (“arms up” at 12 seconds, “sound effect” at 18 seconds)
Export with Comments: Generate code with inline comments marking each event
Integrate Extras: Manually add LED patterns, speaker sounds, or sensor checks to exported code
Rehearse: Test full routine multiple times, noting any timing drift or unexpected behaviors

This workflow mirrors professional choreography and production processes, exposing students to creative project management beyond pure coding.

Workflow 3: Synchronized Multi-Robot Routines

For formations, coordinated dances, or team demonstrations involving multiple robots:

Design Master Timeline: Create the overall routine timeline with marked sync points (e.g., “all robots spin” at 5 seconds)
Assign Robot Roles: Determine what each robot does during each segment (robot A moves forward, robot B circles, etc.)
Create Individual Sequences: Use Motion Sequencer to design each robot’s routine separately
Align Sync Points: Ensure critical events occur at the same time across all robot sequences
Export All Code: Generate Python for each robot, labeling files clearly (robot_a_routine.py, etc.)
Simultaneous Start: Deploy code and trigger all robots at the same moment (using remote start signal or synchronized button press)
Observe Drift: Run the routine multiple times, noting when robots fall out of sync
Calibrate Speeds: Adjust individual robot motor speeds to compensate for hardware differences (e.g., robot B runs at 78 instead of 80)
Add Checkpoints: Insert wireless sync messages at key transitions (“robot A: send ‘step2_complete’ signal; robot B: wait for signal”)
Final Rehearsal: Test with audience perspective, adjusting for visual impact and coordination quality

This advanced workflow teaches distributed systems concepts, communication protocols, and team coordination—skills valuable far beyond robotics.

Comparisons: Time-Based vs. Alternative Control Approaches

vs. Position-Based (move_tank_for_degrees)

Time-based advantages:

Simpler conceptual model (seconds vs. degrees)
Natural for performances and demonstrations
Easy synchronization to external events (music, lights)
Doesn’t require knowledge of wheel circumference or encoder counts

Position-based advantages:

Deterministic endpoint positioning
Immune to battery voltage and surface variations (within motor torque limits)
Essential for navigation tasks (mazes, waypoint following)
Better for autonomous behaviors requiring spatial accuracy

When to choose: Use time-based for choreography, multi-robot sync, and timing-critical applications. Use position-based for navigation, autonomous challenges, and projects where endpoint matters more than duration.

vs. Velocity-Based (move_tank)

Time-based advantages:

Automatic duration control (doesn’t require separate stop command)
Predictable routine length for performance planning
Async-friendly (await-able for sequential composition)

Velocity-based advantages:

Immediate responsive control (useful for teleoperation)
Can be modified mid-execution by sending new commands
Doesn’t require knowing total duration in advance
Natural for sensor-driven behaviors (e.g., “move forward until obstacle detected”)

When to choose: Use time-based for pre-planned routines with known timing. Use velocity-based for reactive behaviors, manual control, and scenarios requiring continuous speed adjustments.

Related Tool: LEGO SPIKE move_tank Maneuver Studio

vs. Path Planning Algorithms

Professional robotics uses motion planning algorithms (RRT, A*, trajectory optimization) that compute optimal paths considering constraints like obstacles, joint limits, and energy efficiency. These algorithms output sequences of commands—often time-based velocity profiles.

For educational robotics, simplified manual planning with visual tools (like the Motion Sequencer) provides the same benefits at appropriate cognitive levels. Students learn planning principles without needing advanced mathematics or computer science backgrounds. As they progress, they can graduate to algorithmic path planning using tools like ROS (Robot Operating System) or MATLAB.

Best Practices for Time-Based Robot Education

Practice 1: Start with Single-Parameter Experiments

Introduce move_tank_for_time by varying only one parameter while holding others constant:

Duration experiment: Run motors at fixed speeds (e.g., 80, 80) for 1s, 2s, 3s; observe distance relationships
Speed experiment: Run for fixed duration (e.g., 2s) at speeds 40, 60, 80, 100; observe velocity effects
Differential experiment: Run for fixed duration and left speed (e.g., 2s, left=80), vary right speed (80, 60, 40, 20); observe turning

This controlled experimentation builds parametric intuition before tackling multi-parameter optimization.

Practice 2: Connect to Real-World Timing

Relate robot timing to familiar experiences:

Music beats: “This routine matches the tempo of your favorite song”
Sports timing: “The robot completes this routine in the same time as a 40-yard dash”
Daily activities: “A 5-second forward motion is like walking across the classroom”

Contextual anchors help students develop accurate time estimation skills, crucial for debugging and optimization.

Practice 3: Emphasize Visual Planning Before Coding

Require students to design routines in the Motion Sequencer (or on paper timelines) before writing code. This “plan-then-implement” workflow mirrors engineering design processes and reduces trial-and-error debugging. The visual timeline externalizes thinking, making it easier for teachers to identify conceptual misunderstandings.

Practice 4: Teach Async Concepts Through Robotics

Use move_tank_for_time’s async nature to introduce concurrent programming concepts:

Sequential execution: await ensures steps run in order
Parallel tasks: Run motor commands alongside LED patterns using multiple async functions
Event-driven programming: Trigger routines based on button press or sensor events

Robotics provides concrete, observable demonstrations of abstract computer science principles, making async programming accessible to middle and high school students.

Practice 5: Integrate Artistic and Technical Learning

Frame robot choreography as a blend of engineering and art:

Technical challenges: “Make the robot complete this path in exactly 10 seconds”
Artistic challenges: “Create the most visually interesting 15-second routine”
Narrative challenges: “Program a robot to act out this short story scene”

This dual framing attracts diverse learners—those interested in precision engineering and those interested in creative expression—broadening robotics appeal.

Practice 6: Use Timing Drift as a Teaching Moment

When students complain that “the robot does something different each time,” use it to teach:

Open-loop vs. closed-loop control: Explain why time-based commands lack positional feedback
Real-world variability: Discuss how physical systems have tolerances and uncertainties
Engineering trade-offs: Contrast simplicity of time-based commands with accuracy of position-based alternatives
Calibration importance: Demonstrate how empirical tuning compensates for model imperfections

This transforms frustration into learning, showing that engineering is about managing uncertainty, not achieving perfection.

Case Study: High School Theater Arts x Robotics Collaboration

Context: Washington High School’s theater department collaborated with the robotics club to create a spring play where robots portrayed background characters (moving trees in a forest scene, wandering animals, etc.). The robots needed to move in sync with actors’ dialog and stage lighting cues, requiring precise temporal control.

Approach: Theater students storyboarded each scene, marking robot entry points, movement durations, and exit cues on a master timeline. Robotics students used the Motion Sequencer to translate these requirements into time-based routines. Each robot’s code included comments with corresponding dialog lines: ”# Move stage left during ‘Once upon a time…’ (6 seconds)”.

Challenges:

Timing variation: Initial tests showed robots drifted ±2 seconds from intended cues by act’s end
Battery consistency: Different charge levels caused speed variations between rehearsals
Surface differences: Stage surface differed from robotics lab, affecting movement speeds

Solutions:

Wireless sync: Inserted stage manager button presses at scene transitions, broadcasting “reset” signals to all robots via Bluetooth, re-synchronizing them
Battery protocol: Established “full charge only” rule before performances; tested battery voltage before each run
Surface calibration: Conducted full dress rehearsals on actual stage, adjusting motor speeds to match new friction characteristics
Backup timing: Added audio cues (beeps) that robots listened for using microphone sensors, providing fallback synchronization

Outcomes:

Performance success: Three show performances with zero timing failures
Learning: Theater students gained appreciation for engineering precision; robotics students learned about performance constraints and audience perspective
Engagement: 40% of participating robotics students reported increased interest in creative applications of technology
Recognition: Project featured in district STEM showcase and local news coverage

Key Insight: The collaboration revealed that time-based control’s “weakness” (lack of positional accuracy) was actually a strength for theater applications—directors cared about timing, not whether robots reached exact positions. This demonstrated to students that “best” control method depends on application context, a critical engineering lesson.

Call to Action: Choreograph with Confidence

Time-based robot control offers an accessible entry point into robotics programming while teaching fundamental concepts applicable across STEM fields: sequential thinking, parameter optimization, empirical validation, and asynchronous programming. Whether you’re designing a robot dance for a school assembly, coordinating multiple robots for a competition demonstration, or teaching middle schoolers about timing and synchronization, move_tank_for_time provides the right balance of simplicity and capability.

Next Steps to Master Time-Based Control:

Start Simple: Visit the LEGO SPIKE move_tank_for_time Motion Sequencer and create a basic 3-step routine (forward, turn, forward)
Add Complexity: Expand to 8-10 steps incorporating curves, spins, and pauses; observe how routine feels and flows
Synchronize to Music: Choose a 30-second music clip and design a routine matching its beats and energy
Experiment with Async: Export code and manually add parallel LED patterns or sensor checks to explore concurrent programming
Collaborate: Partner with another student/robot to create a synchronized two-robot routine demonstrating coordination
Reflect: Compare your time-based routine to a position-based approach for the same task; identify trade-offs and optimal use cases
Share: Document your routine with video and timeline diagrams, sharing with the robotics education community

The journey from basic forward motion to complex multi-robot choreographies is incremental and rewarding. With visual planning tools, structured workflows, and emphasis on both technical precision and creative expression, students at any level can achieve professional-quality robot performances. Begin timing your next great routine today.

External References:

LEGO Education SPIKE Prime - move_tank_for_time API Reference: Official documentation with parameter specifications and usage examples
Asynchronous Programming Concepts - MIT OpenCourseWare: Academic introduction to async/await patterns and concurrent systems

Related Gray-wolf Tools:

LEGO SPIKE move_tank_for_degrees Path Composer - Position-based motion planning for precise navigation
LEGO SPIKE move_tank Maneuver Studio - Velocity-based tank drive control and turning dynamics
LEGO SPIKE Turning Simulator Enhanced - Understand differential drive kinematics and turn radius calculations