zsquadbot

Develop and control quadruped robots with motor commands, sensor fusion, gait generation, diagnostics, and communication protocols for platforms like Unitree...

Security Scan

The skill's code, runtime instructions, and resource requests are consistent with a quadruped-robot development toolkit; it does not request unrelated secrets, network access, or unusual install artifacts — but there are some quality/accuracy issues and safety considerations you should review before running it on real hardware.

Purpose & Capability

Name/description match the included files: gait generator, motor control, IMU reader, simulator, and exporters. The code operates on serial ports and sim state which is expected for a robot control toolbox. There are no unrelated credentials, network endpoints, or cloud SDKs requested.

Instruction Scope

SKILL.md shows step-by-step examples that are limited to simulator and direct hardware control via serial (e.g., /dev/ttyUSB0, /dev/ttyUSB1). That scope is appropriate for the stated purpose, but examples will talk to serial devices and write motion files to the working directory. Also note some minor inaccuracies in docs vs files (e.g., SKILL.md examples import a top-level 'quadruped' module which isn't present as a package module; some listed helper scripts are placeholders). Running motor-control examples on live hardware can physically move motors — a safety risk.

Install Mechanism

This is an instruction-only skill with bundled source files and no install spec or remote downloads. No external binary installers or archive downloads are present, which minimizes supply-chain risk.

Credentials

The skill declares no required environment variables, no credentials, and no config paths. The code reads and writes local files (motion exports) and accesses serial devices — appropriate for robotics but not requesting excessive system secrets.

Persistence & Privilege

Skill is not always-enabled; it does not request permanent agent presence or modify other skill/system configs. It only contains scripts and runtime examples that run when invoked.

Assessment

This package appears coherent for quadruped development, but review and take precautions before running: 1) Safety first — motor_control.py and related scripts send raw commands over serial and can move real actuators; test in the simulator (sim_state/sim_control) before connecting to hardware and have an emergency stop in place. 2) Dependency check — the code expects pyserial and standard Python libs; install dependencies in a controlled virtualenv. 3) File and module mismatches — SKILL.md examples reference a top-level 'quadruped' import and some listed helper scripts that aren't present; you may need to adjust imports or run scripts with PYTHONPATH set to the skill folder. 4) Run tests in an isolated environment (or without physical devices connected) to verify behavior first. 5) If you plan to use it on a commercial platform (Unitree/ANYmal), confirm compatibility and safety limits; do not assume the code enforces hardware safety limits. If you want, I can point out specific code lines that warrant close review (e.g., serial packet formats, struct packing/unpacking, places that write files), or produce a short checklist to sandbox and smoke-test the skill safely.

Quadruped Robot Development

Overview

This skill provides tools and guidance for developing quadruped robots, including motor control, sensor data processing, locomotion patterns, and debugging workflows. Target platforms include Unitree Go1, ANYmal, and custom four-legged robots.

机器人名称: 太玄照业 - The virtual quadruped robot you're controlling

Core Capabilities

1. Motor Control

Control individual motors or coordinated multi-motor commands for gait generation.

Typical operations:

• Set motor position/velocity/force
• Read motor telemetry (temperature, voltage, errors)
• Configure motor parameters (PID gains, limits)
• Emergency stop and safety protocols

2. Sensor Data Processing

Handle sensor inputs from IMUs, joint encoders, and environmental sensors.

Typical operations:

• Read IMU data (acceleration, gyro, orientation)
• Process encoder data for joint position/velocity
• Temperature and voltage monitoring
• Sensor fusion for state estimation

3. Locomotion Patterns

Implement and tune walking, running, and other gaits.

Typical operations:

• Stance phase planning
• Swing phase kinematics
• High-speed running stabilization
• Gait transition logic

4. Debugging & Diagnostics

Monitor system health and debug communication issues.

Typical operations:

• Real-time motor telemetry display
• IMU data visualization
• Communication protocol debugging
• System status reports

Quick Start

Basic Motor Control

# Example: Initialize and control a motor
from quadruped import Motor, Quadruped

# Initialize robot (adjust port/ID based on your setup)
robot = Quadruped(port='/dev/ttyUSB0', baudrate=1000000)

# Enable motors
for motor_id in range(1, 13):
    robot.motor[motor_id].enable()

# Set target position (degrees)
robot.motor[1].set_position(45.0)
robot.motor[2].set_position(45.0)

# Read motor status
status = robot.motor[1].get_status()
print(f"Position: {status.position:.2f}°, Temperature: {status.temperature:.1f}°C")

IMU Data Reading

# Example: Read IMU data
imu_data = robot.imu.read()
print(f"Accel: {imu_data.accel} m/s²")
print(f"Gyro: {imu_data.gyro} rad/s")
print(f"Quaternion: {imu_data.quaternion}")

Walking Gait

# Example: Simple forward walking
robot.gait.walk(forward_steps=10, step_length=0.3, frequency=1.5)

# Wait for completion
robot.gait.wait()

# Stop
robot.stop()

Virtual Robot Control

Use the simulator to test code before hardware connection:

from sim_state import QuadrupedSimulator
from sim_control import QuadrupedController
from gait_generator import QuadrupedGaitGenerator, GaitType

# Create simulator
sim = QuadrupedSimulator()
controller = QuadrupedController(sim, dt=0.01)

# Set initial pose
controller.set_static_pose()
time.sleep(0.5)

# Run walking gait
controller.set_gait_walk(step_length=0.1, frequency=1.0)

# Monitor real-time
controller.monitor(interval=0.1)

# Or run pre-programmed animation
controller.run_animation(duration=5.0)

# Get current state
state = sim.get_state_dict()
print(f"Position: ({state['global']['x']:.2f}, {state['global']['y']:.2f})")
print(f"IMU: {state['imu']['accel']}")

### Generate Custom Gaits

Use the gait generator for custom locomotion patterns:

```python
from gait_generator import QuadrupedGaitGenerator, GaitType

generator = QuadrupedGaitGenerator()

# Generate trot gait
positions, freq = generator.create_gait_profile(
    GaitType.TROT,
    amplitude=25,
    frequency=1.2
)

# Generate run gait with flight phase
positions, freq = generator.create_gait_profile(
    GaitType.RUN,
    amplitude=45,
    frequency=2.0,
    flight_phase=0.2
)

# Generate gallop gait
positions, freq = generator.create_gait_profile(
    GaitType.GALLOP,
    amplitude=40,
    frequency=2.5
)

# Export to JSON for robot execution
from motion_export import MotionExporter
exporter = MotionExporter(generator)
json_path = exporter.export_to_json(
    positions,
    gait_type='trot',
    frequency=freq,
    metadata={'author': 'user', 'notes': 'Custom trot pattern'}
)

print(f"Motion exported to: {json_path}")

Create Motion Sequences

Combine multiple gait patterns:

from motion_export import MotionExporter

exporter = MotionExporter()

# Create sequence: stand → walk → run → stand
sequence = [
    {
        'gait_type': 'static',
        'duration': 1.0,
        'amplitude': 0
    },
    {
        'gait_type': 'walk',
        'duration': 2.0,
        'frequency': 1.0,
        'amplitude': 30
    },
    {
        'gait_type': 'run',
        'duration': 2.0,
        'frequency': 2.0,
        'amplitude': 45
    },
    {
        'gait_type': 'static',
        'duration': 1.0,
        'amplitude': 0
    }
]

# Generate and export
all_positions = exporter.create_motion_sequence(sequence)
json_path = exporter.export_to_json(
    all_positions,
    gait_type='sequence',
    frequency=1.0,
    output_path='motion_sequence.json'
)

Resource Structure

scripts/

Motor control utilities and sensor reading scripts.

Available scripts:

• motor_control.py - Motor initialization, control, and status reading
• imu_reader.py - IMU data acquisition and formatting
• sim_state.py - Virtual robot state simulation
• sim_control.py - Virtual robot interactive control
• gait_generator.py - Quadruped gait pattern generation
• motion_export.py - Motion trajectory export (JSON, CSV)
• encoder_reader.py - Joint encoder data processing (预留)
• telemetry_monitor.py - Real-time system monitoring dashboard (预留)

references/

Technical documentation for sensor data formats, motion models, and protocol details.

Available references:

• motor_protocol.md - Motor command protocol specification
• imu_format.md - IMU data format and coordinate frames
• motion_kinematics.md - Inverse kinematics for leg movements

Best Practices

Communication Protocol

Always check connection status before sending commands. Use timeout values appropriate for your hardware.

# Example: Safe motor command pattern
try:
    robot.connect()
    if not robot.is_connected():
        raise ConnectionError("Robot not connected")

    robot.motor[1].set_position(45.0)
    status = robot.motor[1].get_status()
except Exception as e:
    print(f"Error: {e}")
    robot.emergency_stop()
finally:
    robot.disconnect()

Safety First

• Always enable motors before attempting motion
• Set safe position limits before running gaits
• Monitor temperature and error states during operation
• Implement emergency stop capability

Debugging Tips

1. Communication Issues: Check baud rate and cable connections first
2. Motor Errors: Check for overheating, overcurrent, or cable breaks
3. Poor Gait Performance: Check sensor calibration and PID tuning
4. Unexpected Motion: Verify gait parameters and ensure motors are enabled

Common Tasks

Task 1: Calibrate Sensors

# Use the calibration script
python scripts/motor_control.py --calibrate

Task 2: Test Motor Control

# Move individual motors in test mode
python scripts/motor_control.py --test --motor 1

Task 3: Monitor System Telemetry

# Real-time monitoring (requires Python GUI or serial console)
python scripts/telemetry_monitor.py

Task 4: Generate Motion Patterns

# Create and save a motion profile
python scripts/motion_planner.py --gait walk --steps 20

Task 5: Virtual Robot Simulation

Before connecting to real hardware, test with the virtual simulator:

# Interactive control (press keys to change gaits)
python scripts/sim_control.py

# Run automatic animation
python scripts/sim_control.py --animation 5

# Custom simulation parameters
python scripts/sim_control.py --dt 0.01 --port 921600

Virtual robot commands:

• g - Walk gait
• r - Run gait
• t - Trot gait
• c - Crawl gait
• s - Static pose
• S - Stretch pose
• q - Quit

Task 6: Generate Motion Patterns

Create and export gait patterns for real robot execution:

# Generate walking gait and export to JSON
python scripts/gait_generator.py --gait walk --amplitude 30 --frequency 1.0

# Export to CSV format
python scripts/motion_export.py --format csv

# Generate and save motion sequence
python scripts/motion_export.py --sequence demo --output motions/

Available gaits:

• walk - Sine wave walking
• run - Fast running with flight phase
• trot - Diagonal pair coordination
• crawl - Smooth slow locomotion
• gallop - Fast efficient running
• pace - Lateral pair coordination

Troubleshooting

Motor not responding:

• Check cable connections and power supply
• Verify baud rate matches robot configuration
• Ensure motors are enabled (not in error state)

Unstable gait:

• Check sensor calibration
• Tune PID gains (start with conservative values)
• Verify IMU and encoder synchronization

Connection drops:

• Check for USB/electrical interference
• Try different USB cable or port
• Reduce baud rate if communication errors occur

---

For platform-specific details (Unitree, ANYmal, custom), consult the appropriate reference documentation or hardware datasheet.