onehour.one
Back to Blog
PythonPatternsBest Practices

Python Patterns I Use in Every Robotics Project

A collection of Python patterns and practices that make robotics code more reliable - from state machines to real-time data pipelines.

2 min read

Building Reliable Robot Software

Writing Python for robotics is different from writing a web app. Your code controls physical hardware, latency matters, and bugs can break expensive equipment. Over the past few months, I have developed a set of patterns that I now use in every project.

Pattern 1: State Machines for Robot Behavior

Robots are inherently stateful. A walking robot might be in states like IDLE, WALKING, TURNING, or RECOVERING. I use a simple enum-based state machine:

python
from enum import Enum, auto
from typing import Callable

class RobotState(Enum):
    IDLE = auto()
    WALKING = auto()
    TURNING = auto()
    RECOVERING = auto()

class StateMachine:
    def __init__(self):
        self.state = RobotState.IDLE
        self.transitions: dict[tuple, RobotState] = {}

    def add_transition(self, from_state, event, to_state):
        self.transitions[(from_state, event)] = to_state

    def handle_event(self, event: str):
        key = (self.state, event)
        if key in self.transitions:
            self.state = self.transitions[key]
            return True
        return False

This keeps robot behavior predictable and debuggable. When something goes wrong, you can trace exactly which state transitions occurred.

Pattern 2: Publisher-Subscriber for Sensor Data

Robotics systems produce a lot of data from multiple sensors. I use a lightweight pub-sub pattern to decouple sensor reading from processing:

python
from collections import defaultdict
from typing import Any

class EventBus:
    def __init__(self):
        self._subscribers = defaultdict(list)

    def subscribe(self, topic: str, callback: Callable):
        self._subscribers[topic].append(callback)

    def publish(self, topic: str, data: Any):
        for callback in self._subscribers[topic]:
            callback(data)

# Usage
bus = EventBus()
bus.subscribe("imu/orientation", update_balance_controller)
bus.subscribe("camera/depth", update_obstacle_map)

Pattern 3: Configuration as Data

Robot parameters change constantly during development. I keep all configuration in YAML files and load them with validation:

python
from dataclasses import dataclass
import yaml

@dataclass
class WalkingConfig:
    step_height: float = 0.05
    step_length: float = 0.15
    cycle_time: float = 0.8
    hip_offset: float = 0.08

def load_config(path: str) -> WalkingConfig:
    with open(path) as f:
        data = yaml.safe_load(f)
    return WalkingConfig(**data)

This makes it easy to tune parameters without touching code, which is essential when you are iterating on a physical robot.

Why These Patterns Matter

Good software patterns do not make your robot smarter, but they make you faster at iterating on ideas.

These patterns have saved me countless hours of debugging. The state machine alone has prevented dozens of "why is my robot doing that?" moments. Start simple, keep things predictable, and your robotics projects will be much more enjoyable.