safety-interlocks

Safety Interlocks for Control Systems

Overview

Safety interlocks are protective mechanisms that prevent equipment damage and ensure safe operation. In control systems, the primary risks are output saturation and exceeding safe operating limits.

Implementation Pattern

Always check safety conditions BEFORE applying control outputs:

def apply_safety_limits(measurement, command, max_limit, min_limit, max_output, min_output):
    """
    Apply safety checks and return safe command.

    Args:
        measurement: Current sensor reading
        command: Requested control output
        max_limit: Maximum safe measurement value
        min_limit: Minimum safe measurement value
        max_output: Maximum output command
        min_output: Minimum output command

    Returns:
        tuple: (safe_command, safety_triggered)
    """
    safety_triggered = False

    # Check for over-limit - HIGHEST PRIORITY
    if measurement >= max_limit:
        command = min_output  # Emergency cutoff
        safety_triggered = True

    # Clamp output to valid range
    command = max(min_output, min(max_output, command))

    return command, safety_triggered

Integration with Control Loop

class SafeController:
    def __init__(self, controller, max_limit, min_output=0.0, max_output=100.0):
        self.controller = controller
        self.max_limit = max_limit
        self.min_output = min_output
        self.max_output = max_output
        self.safety_events = []

    def compute(self, measurement, dt):
        """Compute safe control output."""
        # Check safety FIRST
        if measurement >= self.max_limit:
            self.safety_events.append({
                "measurement": measurement,
                "action": "emergency_cutoff"
            })
            return self.min_output

        # Normal control
        output = self.controller.compute(measurement, dt)

        # Clamp to valid range
        return max(self.min_output, min(self.max_output, output))