Agent skill
safety-interlocks
Implement safety interlocks and protective mechanisms to prevent equipment damage and ensure safe control system operation.
Install this agent skill to your Project
npx add-skill https://github.com/benchflow-ai/skillsbench/tree/main/tasks-no-skills/hvac-control/environment/skills/safety-interlocks
SKILL.md
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))
Safety During Open-Loop Testing
During calibration/excitation, safety is especially important because there's no feedback control:
def run_test_with_safety(system, input_value, duration, dt, max_limit):
"""Run open-loop test while monitoring safety limits."""
data = []
current_input = input_value
for step in range(int(duration / dt)):
result = system.step(current_input)
data.append(result)
# Safety check
if result["output"] >= max_limit:
current_input = 0.0 # Cut input
return data
Logging Safety Events
Always log safety events for analysis:
safety_log = {
"limit": max_limit,
"events": []
}
if measurement >= max_limit:
safety_log["events"].append({
"time": current_time,
"measurement": measurement,
"command_before": command,
"command_after": 0.0,
"event_type": "limit_exceeded"
})
Pre-Control Checklist
Before starting any control operation:
-
Verify sensor reading is reasonable
- Not NaN or infinite
- Within physical bounds
-
Check initial conditions
- Measurement should be at expected starting point
- Output should start at safe value
-
Confirm safety limits are configured
- Maximum limit threshold set
- Output clamping enabled
def pre_control_checks(measurement, config):
"""Run pre-control safety verification."""
assert not np.isnan(measurement), "Measurement is NaN"
assert config.get("max_limit") is not None, "Safety limit not configured"
return True
Best Practices
- Defense in depth: Multiple layers of protection
- Fail safe: When in doubt, reduce output
- Log everything: Record all safety events
- Never bypass: Safety code should not be conditionally disabled
- Test safety: Verify interlocks work before normal operation
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
benchflow-ai/skillsbench
csv-processing
Use this skill when reading sensor data from CSV files, writing simulation results to CSV, processing time-series data with pandas, or handling missing values in datasets.
benchflow-ai/skillsbench
pid-controller
Use this skill when implementing PID control loops for adaptive cruise control, vehicle speed regulation, throttle/brake management, or any feedback control system requiring proportional-integral-derivative control.
benchflow-ai/skillsbench
yaml-config
Use this skill when reading or writing YAML configuration files, loading vehicle parameters, or handling config file parsing with proper error handling.
benchflow-ai/skillsbench
simulation-metrics
Use this skill when calculating control system performance metrics such as rise time, overshoot percentage, steady-state error, or settling time for evaluating simulation results.
benchflow-ai/skillsbench
vehicle-dynamics
Use this skill when simulating vehicle motion, calculating safe following distances, time-to-collision, speed/position updates, or implementing vehicle state machines for cruise control modes.
benchflow-ai/skillsbench
web-interface-guidelines
Vercel's comprehensive UI guidelines for building accessible, performant web interfaces. Use this skill when reviewing or building UI components for compliance with best practices around accessibility, performance, animations, and visual stability.
Didn't find tool you were looking for?