Robotik Automatisierung: 20% mehr Output + €94k ROI [Cobot Guide 2025]

Robotik_Setup:
  Cobot (Collaborative Robot):
    Model: Universal Robots UR10e
    Payload: 10 kg
    Reach: 1.300 mm
    Safety: ISO/TS 15066 (Cobots)
    Preis: €38.000
  
  Vision-System:
    Kamera: Basler acA1920-50uc (2MP, USB3)
    Beleuchtung: LED Ring Light (diffus)
    Objektiv: 8mm (Field of View optimiert)
    Preis: €2.400
  
  Greifer:
    Typ: Pneumatisch (2-Finger-Parallel)
    Hersteller: Schunk PGN-plus 80
    Kraft: Adaptiv (0,5-80N)
    Preis: €1.800
  
  Edge-Compute (Vision AI):
    Hardware: NVIDIA Jetson AGX Xavier
    Model: YOLOv8 (Custom-trainiert)
    Inference-Zeit: 42ms
    Preis: €1.200
  
  Integration:
    PLC: Siemens S7-1200 (CNC-Anbindung)
    HMI: Touchscreen 10" (Status, Manual-Override)
    Safety-Sensors: Light Curtains (Sick)
    Preis: €6.800

Total Hardware: €50.200
Installation & Programmierung: €28.000
Safety-Zertifizierung (TÜV): €8.000
**Total Setup:** €86.200

# Production-Ready Vision AI für Cobot

import cv2
import numpy as np
from ultralytics import YOLO
import requests
import json

class CobotVisionAI:
    def __init__(self, model_path, camera_url):
        # YOLOv8 Custom Model laden
        self.model = YOLO(model_path)  # 'models/pickplace_v8.pt'
        self.camera_url = camera_url   # 'rtsp://192.168.1.100/stream'
        
    def capture_image(self):
        """
        Bild von Basler-Kamera erfassen
        """
        cap = cv2.VideoCapture(self.camera_url)
        ret, frame = cap.read()
        cap.release()
        
        if not ret:
            raise Exception("Kamera-Feed nicht verfügbar!")
        
        return frame
    
    def detect_parts(self, image):
        """
        Teile-Erkennung mit YOLOv8
        """
        results = self.model(image, conf=0.85)[0]  # Confidence-Threshold 85%
        
        detections = []
        
        for box in results.boxes:
            # Bounding Box
            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
            
            # Klasse & Confidence
            class_id = int(box.cls[0])
            confidence = float(box.conf[0])
            class_name = results.names[class_id]
            
            # Schwerpunkt berechnen (Pick-Point)
            center_x = int((x1 + x2) / 2)
            center_y = int((y1 + y2) / 2)
            
            # Orientierung schätzen (via Minimum Rotated Rect)
            mask = (results.masks.data[0].cpu().numpy() * 255).astype(np.uint8) if results.masks else None
            
            if mask is not None:
                contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
                if contours:
                    rect = cv2.minAreaRect(contours[0])
                    angle = rect[2]  # Rotation in Grad
                else:
                    angle = 0
else:
                angle = 0
            
            detections.append({
                'class': class_name,
                'confidence': confidence,
                'bbox': [int(x1), int(y1), int(x2), int(y2)],
                'center_px': [center_x, center_y],
                'angle_deg': angle
            })
        
        return detections
    
    def px_to_robot_coords(self, px_x, px_y, calibration_matrix):
        """
        Pixel-Koordinaten → Roboter-Koordinaten (Hand-Eye-Kalibrierung)
        """
        # Vereinfachte Transformation (in Praxis: Kalibrierung mit Marker-Pattern)
        # calibration_matrix: 3x3 Homographie-Matrix
        
        px_point = np.array([[px_x], [px_y], [1]])
        robot_point = calibration_matrix @ px_point
        
        robot_x = robot_point[0, 0] / robot_point[2, 0]
        robot_y = robot_point[1, 0] / robot_point[2, 0]
        
        # Z-Koordinate (Höhe) aus CAD oder Messung
        robot_z = -50  # mm (Greifer-Höhe über Tisch)
        
        return {
            'x': round(robot_x, 2),
            'y': round(robot_y, 2),
            'z': robot_z
        }
    
    def send_pick_command_to_robot(self, robot_coords, angle):
        """
        Pick-Befehl an UR10e senden (via TCP-Socket oder REST-API)
        """
        ur_ip = "192.168.1.101"
        ur_port = 30002  # Real-Time Interface
        
        # URScript-Kommando generieren
        ur_script = f"""
        movej(get_inverse_kin(p[{robot_coords['x']/1000:.4f}, 
                                  {robot_coords['y']/1000:.4f}, 
                                  {robot_coords['z']/1000:.4f}, 
                                  {np.radians(180):.4f}, 
                                  {np.radians(0):.4f}, 
                                  {np.radians(angle):.4f}]), a=1.2, v=0.3)
        set_digital_out(0, True)  # Greifer schließen
        sleep(0.5)
        movej(home_pose, a=1.2, v=0.5)
        """
        
        # An Robot Controller senden
        import socket
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((ur_ip, ur_port))
        s.send(ur_script.encode())
        s.close()
        
        return {'status': 'pick_command_sent', 'coords': robot_coords, 'angle': angle}


# Deployment: Continuous Vision Loop
vision_ai = CobotVisionAI('models/pickplace_v8.pt', 'rtsp://192.168.1.100/stream')

# Kalibrierung (einmalig)
calibration_matrix = np.array([
    [0.082, 0, -156.4],
    [0, 0.082, -98.2],
    [0, 0, 1]
])  # Beispiel-Matrix (aus Hand-Eye-Kalibrierung)

while True:
    # 1. Bild erfassen
    image = vision_ai.capture_image()
    
    # 2. Teile erkennen
    detections = vision_ai.detect_parts(image)
    
    if len(detections) > 0:
        # Erstes erkanntes Teil nehmen
        part = detections[0]
        
        print(f"Erkannt: {part['class']} (Confidence: {part['confidence']:.0%})")
        
        # 3. Pixel → Robot-Koordinaten
        robot_coords = vision_ai.px_to_robot_coords(
            part['center_px'][0],
            part['center_px'][1],
            calibration_matrix
        )
        
        # 4. Pick-Befehl senden
        result = vision_ai.send_pick_command_to_robot(robot_coords, part['angle_deg'])
        
        print(f"Pick-Befehl gesendet: {result}")
        
        # Warten bis Roboter fertig (via PLC-Signal oder Status-Check)
        time.sleep(8)  # Vereinfachung
    else:
        print("Keine Teile erkannt. Warte 2 Sek...")
        time.sleep(2)

Risk-Assessment:
  Gefahren:
    - Kollision Mensch-Robot: Mittel (mit Safety-Features: Niedrig)
    - Quetschgefahr Greifer: Niedrig (Kraft-begrenzt)
    - Herabfallende Teile: Mittel (mit Absturzsicherung: Niedrig)
  
  Maßnahmen:
    - Kraft-/Geschwindigkeitsüberwachung (ISO/TS 15066)
    - Safety-Rated Monitored Stop (bei Mensch in Zelle)
    - Light Curtains (Gefahrenbereich)
    - Emergency-Stop-Taster (4× in Zelle)
  
  Performance-Level:
    - Erforderlich: PL d (nach ISO 13849-1)
    - Erreicht: PL e (Safety-PLC + Safety-Controller)