Smart Factory End-to-End: OEE +12% + €284k ROI [Industrie 4.0 Guide]

IIoT-Infrastruktur:
  Maschinen-Anbindung (8× CNC):
    - OPC-UA Gateway (Siemens IOT2040)
    - Daten: Status, Spindeldrehzahl, Vorschub, Werkzeugverschleiß
    - Update-Rate: 1 Hz
    - Preis: €890/Gateway × 8 = €7.120
  
  Zusatz-Sensoren:
    - Vibrationssensoren (Spindellager): 8× €185 = €1.480
    - Stromsensoren (Clamp-On): 8× €340 = €2.720
    - Temperatursensoren (Kühlmittel): 8× €95 = €760
  
  Edge-Gateway (zentral):
    - Raspberry Pi 4 (8GB) + HAT
    - MQTT Broker + Node-RED
    - Preis: €180
  
  Time-Series-Database:
    - InfluxDB (Self-Hosted)
    - Server: Existing (€0)
  
  Dashboards:
    - Grafana (Open Source)
    - Custom OEE-Dashboards

Total Hardware: €12.260
Installation (3 Tage): €4.800
Software: Open Source (€0)

# Automatische OEE-Berechnung aus IIoT-Daten

import pandas as pd
from datetime import datetime, timedelta

class OEECalculator:
    def __init__(self):
        self.influxdb_client = InfluxDBClient()
        
    def calculate_oee_realtime(self, machine_id, timeframe_hours=24):
        """
        Berechnet OEE in Echtzeit aus Maschinendaten
        """
        # Daten aus InfluxDB laden
        query = f"""
        SELECT status, speed, parts_produced
        FROM machine_data
        WHERE machine_id = '{machine_id}'
        AND time > now() - {timeframe_hours}h
        """
        df = self.influxdb_client.query(query)
        
        # 1. VERFÜGBARKEIT
        total_time = timeframe_hours * 3600  # Sekunden
        planned_downtime = self.get_planned_stops(machine_id, timeframe_hours)
        
        productive_time = len(df[df['status'] == 'running']) 
        unplanned_downtime = total_time - productive_time - planned_downtime
        
        availability = (total_time - unplanned_downtime - planned_downtime) / (total_time - planned_downtime)
        
        # 2. PERFORMANCE
        actual_parts = df['parts_produced'].sum()
        ideal_cycle_time = 180  # Sekunden/Teil (Sollwert)
        ideal_parts = productive_time / ideal_cycle_time
        
        performance = actual_parts / ideal_parts if ideal_parts > 0 else 0
        
        # 3. QUALITÄT
        rejected_parts = self.get_rejected_count(machine_id, timeframe_hours)
        quality = (actual_parts - rejected_parts) / actual_parts if actual_parts > 0 else 0
        
        # OEE = A × P × Q
        oee = availability * performance * quality
        
        return {
            'machine_id': machine_id,
            'timeframe_h': timeframe_hours,
            'availability': round(availability, 3),
            'performance': round(performance, 3),
            'quality': round(quality, 3),
            'oee': round(oee, 3),
            'oee_pct': round(oee * 100, 1),
            'unplanned_downtime_min': round(unplanned_downtime / 60, 1),
            'parts_produced': actual_parts,
            'parts_rejected': rejected_parts
        }

# Live OEE für alle Maschinen
calculator = OEECalculator()

for machine in range(1, 9):
    oee_data = calculator.calculate_oee_realtime(f'cnc_{machine}', timeframe_hours=24)
    print(f"Maschine {machine}: OEE {oee_data['oee_pct']}% (A:{oee_data['availability']*100:.1f}% × P:{oee_data['performance']*100:.1f}% × Q:{oee_data['quality']*100:.1f}%)")

# Output:
# Maschine 1: OEE 72.3% (A:84% × P:89% × Q:96%)
# Maschine 2: OEE 65.1% (A:78% × P:87% × Q:96%) ← LOW!
# Maschine 3: OEE 69.8% (A:82% × P:88% × Q:97%)
# ...
# Durchschnitt: 68.4% → Baseline bestätigt ✅

# Predictive Maintenance mit Isolation Forest

from sklearn.ensemble import IsolationForest
import numpy as np

class PredictiveMaintenance:
    def __init__(self):
        self.model = IsolationForest(contamination=0.05)
        
    def train_baseline(self, normal_operation_data):
        """
        Trainiert auf Normalbetrieb (2 Wochen Daten)
        """
        features = normal_operation_data[[
            'vibration_rms', 'temperature', 'current_avg',
            'speed_variance', 'tool_wear_estimate'
        ]]
        
        self.model.fit(features)
        
    def detect_anomalies(self, current_data):
        """
        Erkennt Abweichungen vom Normalbetrieb
        """
        features = current_data[[
            'vibration_rms', 'temperature', 'current_avg',
            'speed_variance', 'tool_wear_estimate'
        ]]
        
        predictions = self.model.predict(features)
        anomaly_scores = self.model.score_samples(features)
        
        # Anomalien mit Severity bewerten
        anomalies = []
        for idx, (pred, score) in enumerate(zip(predictions, anomaly_scores)):
            if pred == -1:  # Anomalie
                severity = 'critical' if score < -0.5 else 'warning'
                
                anomalies.append({
                    'timestamp': current_data.iloc[idx]['timestamp'],
                    'machine_id': current_data.iloc[idx]['machine_id'],
                    'severity': severity,
                    'anomaly_score': score,
                    'features': features.iloc[idx].to_dict(),
                    'recommended_action': self.get_recommendation(features.iloc[idx])
                })
        
        return anomalies
    
    def get_recommendation(self, feature_values):
        """
        Empfiehlt Wartungsaktionen basierend auf Anomalie-Muster
        """
        if feature_values['vibration_rms'] > 25:
            return 'Check spindle bearings - high vibration detected'
        elif feature_values['temperature'] > 75:
            return 'Check cooling system - overheating'
        elif feature_values['tool_wear_estimate'] > 0.85:
            return 'Schedule tool change - high wear detected'
        else:
            return 'Inspect machine for unusual patterns'

# Deployment
pm_system = PredictiveMaintenance()
pm_system.train_baseline(historical_normal_data)

# Täglich laufende Checks
anomalies = pm_system.detect_anomalies(yesterday_data)

if anomalies:
    for anomaly in anomalies:
        if anomaly['severity'] == 'critical':
            send_sms_alert(maintenance_team, anomaly)
        else:
            create_maintenance_ticket(anomaly)

Optimierungs-Logik:
  Datensammlung:
    - 6 Wochen Produktion = 12.000 Teile
    - Features: Geschwindigkeit, Vorschub, Kühlmittel-Temp, Material-Charge
    - Target: Zykluszeit, Oberflächengüte, Werkzeugverschleiß
  
  ML-Modell (XGBoost):
    - Predict optimale Parameter für jede Teil-Geometrie
    - Multi-Objective: Min Zykluszeit + Max Qualität + Min Verschleiß
  
  Closed-Loop:
    - Für neuen Auftrag: ML schlägt Parameter vor
    - Bediener kann akzeptieren/anpassen
    - Nach Produktion: Feedback ins Modell
    - Kontinuierliches Lernen

Ergebnis:
  - Zykluszeit: -8% im Durchschnitt
  - Werkzeugstandzeit: +25%
  - Qualität: stabil/besser