Der Robot Cell Simulator kann von außen mit Befehlen gesteuert werden – dieselben Schritte wie im Fenster (Simulation laden, fahren, Bericht, Arbeitsbereiche, Verriegelungen prüfen), ohne Dialoge. Gedacht für nächtliche Regressionstests einer Station, den Vergleich von Programmvarianten per Skript und für einen KI-Agenten, der die Studien durchführt.
Einschalten
Die API ist standardmäßig aus. Sie wird in den Einstellungen des Simulators eingeschaltet (Extras > Einstellungen..., Registerkarte KI-Agent: Befehls-API des Robot Cell Simulator für den KI-Agenten und Skripte) oder mit der Umgebungsvariable DRES_RCS_API=1 beim Start von DReS. Dieselbe Registerkarte zeigt den Pfad des Client-Skripts (Standard template\RCS\AIAgent\rcs_api.ps1 im Installationsverzeichnis). Sie startet, wenn das Fenster des Robot Cell Simulator geöffnet wird (Plugins > Robot Cell Simulator); die Konsole zeigt Befehls-API des Robot Cell Simulator empfängt Befehle über \\.\pipe\DReS_RCS_API. Nur der Benutzer, der DReS gestartet hat, kann sich verbinden (lokale Pipe, kein Netzwerk).
Lizenz: die Befehls-APIs des Editors und des Robot Cell Simulator brauchen die Zusatzlizenz API / CLI (Steuerung von DReS und dem Simulator durch andere Programme, Skripte und KI-Agenten). Ohne sie gehen nur lesende Befehle (z. B. status, run_data, view, robust_test mit status / risks, ui_list, ui_shot, recent_files), die anderen Befehle antworten mit einem Fehler über die fehlende Lizenz, und die Einstellungen der Befehls-APIs sind gesperrt. Die Sprachsteuerung VeRa arbeitet ohne diese Lizenz.
Befehle
Ein JSON-Objekt pro Zeile in beide Richtungen, z. B. {"cmd":"status"}. Jede Antwort enthält
"ok": true / false und "error", wenn der Befehl fehlgeschlagen ist. Während ein Befehl läuft, werden
keine Meldungsfenster gezeigt – es gilt die Standardantwort, die Meldung steht in der Konsole.
Flag "anon": true (jeder Befehl): die Namen werden übersetzt – R1, R2 …,
<file N> und <name> im Befehl werden vor der Ausführung durch die echten Roboternamen und Dateipfade
ersetzt, und in der Antwort werden Roboternamen, Dateipfade und Kennungen der Anlage durch diese Kennungen ersetzt. Genutzt vom
Fenster KI-Agent im anonymen Modus und seinem MCP-Server (Umgebungsvariable
DRES_AI_ANON=1); z. B. {"cmd":"robot","robot":"R2","goto":"UP42/P5","anon":true}.
| Befehl | Parameter | Was er macht |
|---|---|---|
| ping | Name des Plugins | |
| status | loading (Simulationsdatei), preparing (Programme werden im Hintergrund geparst), running, loop / loops, Roboter, Geschwindigkeit, SPS, letzte Fehler (lastRunError, lastLoadMissing, robotNameWarnings), measuredCycles, uiPending (noch nicht ausgeführte UI-Befehle) und modal (Titel eines offenen modalen Fensters); simTime (Uhr der Simulation, s), robustTest (ein Robustheitstest läuft); während eines Laufs auch elapsedSeconds (Echtzeit seit dem Start des Laufs), simSeconds (Simulationszeit des Laufs), effectiveSpeed (% = Simulationszeit / Echtzeit, mit dem Warten auf die Live-3D-Prüfung), loopSeconds (Echtzeit eines Durchlaufs, ab dem 2. Durchlauf), remainingSeconds und estimatedEnd (bis zum Ende aller Durchläufe; fehlen im 1. Durchlauf) und robotsProgress (robot, running, loop, loops) | |
| load | file, newScene (true) | lädt eine Simulationsdatei mit allem, was sie enthält (wie die Standardauswahl von Simulation laden); asynchron – warten, bis status frei ist |
| recent_files | – | lesend, ohne Lizenz: {"ok":true,"simulations":[...],"studies":[...],"current":"<Simulation_File>"}
– simulations: die letzten 15 geladenen Simulationsdateien (auch über die API geladen), die neueste zuerst,
nur existierende Dateien (Menü Simulation > Zuletzt geladene Simulationen);
studies: die zuletzt geöffneten Studien (Datei > Zuletzt geöffnete Dateien); current: die jetzt
geladene Simulationsdatei. Laden mit load – der KI-Agent nimmt eine vom Benutzer genannte Datei von hier
und durchsucht nicht die Festplatte |
| set | speed, folge, up, loops, sps | Werte der Registerkarte Simulation (nicht während der Simulation); up: N wählt UP N statt einer Folge; Antwort (auch ohne Schlüssel = nur Lesen): programType ("folge" | "up"), number, loops, sps – die aktuellen Werte der Registerkarte (so liest der KI-Agent die Folge der Station) |
| fast_run | program ("folge125" oder "up42"), loops | wie die Fast-Run-Tasten, immer ohne SPS |
| run | folge oder up, loops, speed, sps | Run on all robots; up: N fährt UP N statt einer Folge; asynchron. Fehlende Arbeitsbereiche werden zuerst berechnet |
| stop | hält alle Roboter an | |
| sim_options | ohne Schlüssel: lesen; Schlüssel: siehe unten | Optionen der Registerkarte Simulation wie in der Oberfläche; während der Simulation gesperrt (Fehler). Antwort: alle Werte und locked |
| sim_action | action: "pause", "resume", "quitt", "check_interlock_map" | Pause / Resume der Uhr der Station, Continue (Quitt), Check interlock map (die Tabelle öffnet sich in einem Fenster, lesen mit den ui_*-Befehlen) |
| live_check | on, cell, capsule, range, warn, thread, parallel, grid, stepMs | Live-3D-Kollisionsprüfung (wirkt ab dem nächsten Start); Antwort: die Werte und closest – die größte Annäherung jedes Paars: robot, where, part, partner, partnerWhere, partnerPart, distance, t, rangeMm, joints, partnerJoints – und stats des letzten Laufs (checks, checkMsP50 / P95, gapAvgS / gapMaxS, nearMoveMaxMm / nearMoveP95Mm, clockWaitS, recommendedStepMs, maxSpeedWithoutWait) |
| view | robotNamesOnFloor, robotLabels, axes, perspective, recordedPath, nullPoint, grid, consolesAndLinearUnits, simulationTcp, whiteBackground, pointLabels, programPaths (true / false); fitAll, viewAll (true); standardView ("default" | "top" | "bottom" | "left" | "right" | "front" | "back"), coordinateSystemSize (60..400 px), allRobotsPath ({kind: "folge" | "up", number, withSubprograms} oder false) | auch das Kontextmenü der 3D-Ansicht: Punktbeschriftungen, Bahnen der Registerkarte Programme anzeigen / ausblenden, Größe des Koordinatensystems, die Bahn einer Folge / eines UP für alle Roboter (false = ausblenden); standardView wie Navigation > Normansicht; Schalter des Menüs Ansicht (und weißer Hintergrund, Fit All / View All): Namen der Roboter auf dem Boden, Beschriftungen über den Robotern, Achsen, Perspektive, aufgezeichnete Bahn, Nullpunkt, Gitter, Konsolen und Lineareinheiten, TCP des Werkzeugs in der Simulation; ohne Schlüssel: lesen (auch ohne Lizenz API / CLI). Antwort: der Zustand jedes Schalters |
| report | file, html, pdf, xlsx, shot, ganttAll, ganttRange, rangeFrom, rangeTo, ganttPrAct, compareFile | Zeitbericht wie Bericht...; immer auch die Daten des Laufs *.rcsrun.json; die API öffnet den Bericht nie in einem Browser |
| report_open | open (true / false) | Option Gespeicherten
Bericht (HTML, PDF) im Standardprogramm öffnen (Plugin-Einstellungen > Simulation, Standard: ein) für den
Zeitenbericht, den Bericht des Robustheitstests und den Bericht der Kollisionsrisiken; aus = die Dateien werden nur
gespeichert – empfohlen, wenn ein KI-Agent oder ein Skript die Berichte erstellt. Ohne open: lesen (auch ohne
die Lizenz API / CLI); Setzen benötigt die Lizenz API / CLI. Antwort: {"ok":true,"open":false} |
| run_data | file (optional) | die Daten des Laufs (wie in *.rcsrun.json) in der Antwort |
| zones | programs (["folge81", ...]), mode ("cubes" | "triangles"), grid (mm, ein Wert der Liste: 50, 100, 150, 200, 300), radius (mm), withTool, withSubprograms (true / false), calculate (true), clear (false) | Arbeitsbereiche: markiert diese Programme aller Roboter und berechnet die Bereiche; mode, grid, radius, withTool, withSubprograms wie die Felder der Gruppe Berechnung; calculate: false setzt nur die Felder, clear: true entfernt die Bereiche aus der 3D-Ansicht (Schaltfläche Leeren). Antwort: robots, mode, grid, radius, withTool, withSubprograms |
| docking | enabled (true / false), distance (mm), put / take {name ("MAKRO" | "UP" | "A" | ...), number, condition ("EIN" | "TRUE" | ...)}, detachAll, attachDefaults (true), run (Nummer des UP) | Registerkarte Auto-Docking: Werkzeugwechsel an den Dockpunkten, die Befehle Werkzeug ablegen (DS abdocken) und Werkzeug aufnehmen (DS andocken), max. Abstand des Werkzeugs vom Flansch, Alle Werkzeuge von allen Robotern lösen (ohne Frage) / Standardwerkzeuge an alle Roboter anbauen, run = Werkzeugwechsel auf allen Robotern mit diesem UP; während einer Simulation abgelehnt; ohne Schlüssel: lesen |
| sps_program | xml, file (.xml), newFromRobots (true), saveFile (.xml), open (true) | SPS-Programm der Station (Registerkarte SPS, SPS-Editor): setzt es aus XML oder einer Datei, newFromRobots wie Neu aus den Robotern der Zelle (ohne Frage), saveFile schreibt es, open öffnet das Editorfenster wie Edit SPS program... (während einer Simulation nur zum Ansehen: Zustände der Bausteine live, auch die bei einem Wettlauf eingefügten Bausteine Interlock priority); Antwort: xml, blocks, check (Ergebnis von Prüfung vor dem Lauf), mit open auch opened und readOnly (true während einer Simulation) |
| race_rules | window (s, 0.1..5), message (true / false), lock (true / false), rules [{zone, first, second, mode ("window" | "order"), window (s, 0,1..30, Standard 2)}], clear (true) | Wettläufe um Verriegelungsbereiche (zwei Roboter fordern denselben Bereich innerhalb von window Sekunden an, Standard 1 s; Plugin-Einstellungen > Simulation), message = Fenster mit den Wettläufen am Ende einer Stationssimulation, lock = Reihenfolge der Roboter bei einem Wettlauf beibehalten (Regel "auto" und Baustein Interlock priority mit Kommentar im SPS-Programm); rules = Vorrang wie der SPS-Baustein Interlock priority (SPS) für die nächsten Simulationen, auch ohne SPS (second leer = jeder Partner, mode "window" = Vorrang in einem Zeitfenster: der zweite Roboter wartet höchstens window Sekunden ab seiner eigenen Anforderung, dann fährt er und die Reihenfolge ändert sich – nur für fast gleichzeitige Anforderungen; "order" = Reihenfolge in jedem Zyklus: der zweite Roboter immer nach dem ersten, auch wenn der erste wegen anderer Bereiche verspätet ist – für Variante B); eine Regel für einen Bereich ersetzt die SPS-Bausteine dieses Bereichs (Variante B, z. B. {"zone": 4, "first": "R06", "second": "R03", "mode": "order"}), clear entfernt sie. Antwort: window, message, lock, rules (API), spsRules (Bausteine des SPS-Programms), autoRules (Regeln aus den Wettläufen des letzten Laufs mit whereFirst, whereSecond, difference), races [{zone, robotA, whereA, robotB, whereB, count, minDifference, maxDifference, lostA, lostB, waited}] des letzten Laufs, log (jede Anwendung einer Regel), pendingBlocks (Zahl der bei Wettläufen eingefügten Bausteine Interlock priority, die auf die Entscheidung bei save warten: behalten oder entfernen); ohne Schlüssel: lesen |
| sim_display | lamps {motion, process, warte, interlock, folgenstart, loopEnd: "green" | "orange" | "red" | "blue" | "off"}, console {loops, up, dwell, warte, folgenstart, interlock, io, motion, sps, timers (true / false), debug, flushMs, maxLines, remindSec} | die Fenster Statusleuchte... und Konsolenmeldungen... der Registerkarte Simulation, auch während einer Simulation; ohne Schlüssel: lesen |
| export | what ("times" | "motionTimes"), file (.csv) | CSV wie Exportieren... der Registerkarte Zeiten und der Bewegungszeiten der Registerkarte Motion; Kollisionsmatrix und Verriegelungen prüfen: collision_matrix und check_interlocks liefern die Daten als JSON |
| zones_view | show, overlapOnly, pathColors (true / false), transparency (10..95 %) | Gruppe Anzeige der Registerkarte Work Zones: Arbeitsbereiche anzeigen, nur gemeinsame Bereiche, Programmbahn in den Farben der Verriegelungen, Transparenz; ohne Schlüssel: lesen (auch ohne Lizenz API / CLI) |
| motion_options | planner (true / false), override (%), ptpRamp (s), pathAcc (mm/s², 0 = aus dem Roboterarchiv), oriVel (°/s), approximation, showPath (true / false), defaults (true) | Registerkarte Motion: reale Bewegung (Bewegungsplaner), seine Parameter (Programm-Override, PTP-Beschleunigungszeit, Bahnbeschleunigung, Orientierungsgeschwindigkeit, Überschleifen), die reale Bahn in der 3D-Ansicht; defaults = Schaltfläche Standardwerte; während einer Simulation abgelehnt; ohne Schlüssel: lesen |
| check_interlocks | Ergebnisse von Verriegelungen prüfen als Daten (Schwere, Code, Roboter, Partner, Punkt, Meldung, Vorschlag; siehe Was RCS prüft) und comments: fehlende Kommentare über Punkten mit Anforderung / Freigabe (row, Roboter, Punkt, Verriegelung, Freigabe, Kommentar aus der Vorlage, Hinweis) | |
| robot | robot (Namensteil, z. B. "R06"), override (1..100), pause (true / false), axes ([A1..A6, E1]), ms, run ("UP42" | "folge81"), point (1), stop (true), goto ("UP43/P8" | "folge81/P12") | Override und Pause eines Roboters auch während der Simulation der Station (wie im SmartPad); run = nur das Programm dieses Roboters (wie Programm starten der Registerkarte Programme) ab dem Punkt point (der Roboter fährt zuerst dorthin); stop = hält nur diesen Roboter an; goto = der Roboter steht in diesem Punkt des Programms (der Punkt wird in der Registerkarte Programme markiert), das Programm wird nicht gestartet – z. B. zur Prüfung des Werkzeugs in einem Schweißpunkt (nur bei angehaltener Simulation; Antwort at); axes wie die Schieberegler der Registerkarte Roboterachsen (Grad, E1 in mm; nur bei angehaltener Simulation; ms > 0 = sanfte Bewegung); Antwort: robot, running, paused, override, axes und tool {id, name, x, y, z, a, b, c} (das Werkzeug am Flansch und seine Anbauposition; fehlt ohne Werkzeug) |
| tool_model | robot (Namensteil), file (.jt), pos {x, y, z (mm), a, b, c (°)}, fixture (true), id | ein Werkzeugmodell aus einer JT-Datei am Flansch eines Roboters (wie Insert JT File + Attach to robot..., siehe Werkzeuge an den Robotern): pos = Ursprung des Modells relativ zum Flansch (KUKA ABC; Standard 0 = das Modell liegt im Flanschkoordinatensystem); das Modell ersetzt das Werkzeug am Flansch (z. B. ein Dummy-Werkzeug); fixture: true = ein zusätzliches Teil am Flansch statt des Werkzeugs. Ohne file und id: nur eine neue Position des schon angebauten Werkzeugmodells; id = neue Position dieses Modells. Nicht während der Simulation. Antwort: id, robot, tool (true = Werkzeug, false = zusätzliches Teil) |
| signals | robot (Namensteil oder "all"), set ({"A76": 1, "E80": 0}), release (true oder ["A76", ...]), always ({"M95": 1 | 0 | -1}), read (["E80", ...]), eval ("E80 & E76") | Signale E / A / F / M wie das Signalmenü des SmartPads und des Fensters Signale E / A der Roboter: set = von Hand setzen (bleibt bis zur Freigabe), release = zurück an die Simulation (true = alle von Hand gesetzten Signale des Roboters), always = fester Wert in der Signaldatei (nur M / F; -1 entfernt ihn); Antwort: values {Roboter: {Signal: {value, forced}}}, eval |
| dummy_tool | robot, shape ("sphere" | "box"), r, dx, dy, dz, x, y, z (mm), a, b, c (°), position ("flange" | "tcp"), remove (true), allRobots (true), attach (true) | Fenster Dummy-Werkzeug eines Roboters: die angegebenen Werte werden gespeichert und das Dummy-Werkzeug angebaut (ein Werkzeug am Flansch wird gelöst); remove entfernt es, allRobots setzt dasselbe Dummy-Werkzeug auf alle Roboter (ohne Frage); ohne Werte: die gespeicherten Werte |
| insert_interlocks | mode ("stop" | "request"), stopText, requestText, releaseText, apply (false), rows ([0, 2, ...]) | Arbeitsbereiche > Verriegelungen einfügen... ohne Fenster: die Vorschläge für jede Einfahrt in einen gemeinsamen Bereich ohne Verriegelung (Antwort rows: row, robot, partner, area, changes, note, ok); apply: true schreibt die markierten Zeilen (Standard: die Zeilen mit ok) in die Programme im Editor - prüfen und speichern, danach die Arbeitsbereiche neu berechnen; Antwort auch inserted, changedFiles |
| save | file (.xml), cell, robots, jt, docked, dummy, sps (true / false), raceBlocks ("keep" | "remove", Standard "keep") | Simulation > Simulation speichern... ohne Fenster: die Einstellungen der Simulation immer, die Teile des Zellenlayouts wie angegeben (Standard: was die Szene enthält); raceBlocks = was mit den noch nicht bestätigten Bausteinen Interlock priority geschieht, die die Simulation bei Wettläufen eingefügt hat, wenn das SPS-Programm gespeichert wird (remove entfernt sie aus dem SPS-Programm, wie Save without the blocks, Simulationsdatei). Antwort: file, raceBlocks ("none" | "kept" | "removed"), raceBlocksCount |
| zone_steps | robot, program ("folge81") | für jeden Punkt des Programms (mit den aufgerufenen UPs) aus den Arbeitsbereichen: Roboter im gemeinsamen Bereich (contact), Bewegungen ohne Verriegelung (unprotected), aktive Verriegelungen in der Bewegung und nach dem Punkt |
| collision_ignore | key (Fall aus collisionCheck.conflicts), ignore (true / false) – oder clear (true), all (true) | Kollisionsgefahren, bei denen die Simulation nicht mehr anhält (Ignorieren im Fenster); clear leert die Liste (Keine ignorieren), all ignoriert alle Fälle der aktuellen Simulation (Alle ignorieren); Antwort: ignorierte Schlüssel |
| collision_case | key (beliebiger Schlüssel eines Falls, z. B. aus run_data oder robust_test risks), action ("points" | "editor") | die Schaltflächen einer Zeile des Fensters der Kollisionsgefahren: points = beide Roboter in ihre Punkte (nur bei angehaltener oder pausierter Simulation; in der Pause fahren sie sanft und Weiter fährt sie zurück), editor = beide Programme im Editor an den Punkten |
| collision_report | file (.pdf oder .html), view (true / false, Standard true), test (true / false) | speichert die Kollisionsfälle wie die Schaltfläche Als HTML / PDF speichern des Fensters: während eines Robustheitstests (oder test = true) alle Fälle des Tests, sonst die Fälle der letzten Simulation; benachbarte Punkte einer Stelle als ein Fall (Einstellungen des Plugins, Kollisionsbericht) |
| robust_test | action, siehe unten | Robustheitstest (Robustheitstest); jede Antwort enthält den Status: active, paused, finished, step, totalCycles, collisionRisks, minutes, report, remainingMinutes und estimatedEnd (geschätzte Restzeit und Ende des Tests; fehlen, solange unbekannt) |
| insert_comments | rows (Nummern "row" aus comments, leer = alle), texts (eigene Texte dieser Zeilen, optional) | fügt die fehlenden Kommentare des letzten check_interlocks ohne Speichern in die Programme im Editor ein (inserted, log) |
| collision_matrix | scope ("checked" = in Arbeitsbereiche markierte Programme, Standard; "archive" = ganze Roboterarchive) | Kollisionsmatrix als Daten: Roboter mit ihren Verriegelungen (Anforderungen, Freigaben, Partner, Anforderungen ohne Partner), Roboterpaare (Verriegelungen, Zustand, gemeinsame / rote m3, wenn die Bereiche berechnet sind) und die Fehler der Signallogik (Roboter, Punkt, Zeile, Code, Meldung) - ohne Berechnung der Arbeitsbereiche |
| anon_study | file (Ergebnis; der Schlüssel wird daneben als <Datei>.key.json gespeichert), check, run (true = Verriegelungen prüfen / letzte Simulation einschließen), show (true = Zusammenfassung wie die Schaltfläche anzeigen), texts (true = mit Verriegelungskommentaren und Langtexten) | anonymisierte Studie für einen KI-Assistenten: Roboter R#, Programme F#/U#, Punkte P#, Programmschritte mit Verriegelungsereignissen und Berührungen, gemeinsame Volumen, Verriegelungen prüfen und Simulation – ohne Namen, Koordinaten und Programmtext; Antwort mit den Dateien, Statistik und leaks (gefundene Teile echter Namen, muss leer sein). Arbeitsbereiche müssen berechnet sein |
| ai_import | text (Antwort der KI mit {"changes": [...]}) oder file oder changes (Array), key (Schlüsseldatei, Standard: die zuletzt exportierte), apply (true = Zeilen mit Status ok übernehmen), rows (Indizes der zu übernehmenden Zeilen), check3d (true = nach dem Übernehmen Arbeitsbereiche aus den Dreiecken der 3D-Modelle, Antwort check3d mit ok und den entries ohne Verriegelung) | Vorschläge des KI-Agenten übersetzt auf die Roboter und Programme der Zelle: Zeilen mit Roboter, Programm, Punkt, Aktion, Änderungen im Programm, Hinweis und Status (ok / check / error); mit apply: Sicherung der Programme, Änderungen gespeichert, backupDir und log. Danach run und ai_compare |
| ai_compare | key (optional) | Stationstakt, Takt und Wartezeit jedes Roboters vor den Änderungen der KI und in der letzten Simulation (cycleDelta), Erwartung der KI |
| ai_keep | übernommene Änderungen der KI als neuen Ausgangszustand behalten (nächste Runde: neue anon_study, neuer Schlüssel) | |
| ai_restore | Originalprogramme aus der Sicherung (Editorfenster dieser Programme werden ohne Speichern geschlossen) | |
| ai_chat | message, newChat (true), stop (true), last (20), anonymous (true / false) | das Fenster
KI-Agent (Lizenz API / CLI): message = eine Nachricht wie aus dem Textfeld (während der Agent arbeitet, wartet
sie in der Warteschlange; Fehler ohne API-Schlüssel oder Lizenz); message "/reload" lädt die
Wissensdateien des Agenten neu, ohne Anfrage an das Modell (wie Wissen neu laden in den Einstellungen, das Gespräch
bleibt; die Denkblöcke früherer Antworten werden aus dem Verlauf entfernt; das transcript erhält einen Eintrag mit der
Zusammenfassung); message "/status", "/run folge=125 loops=1", "/view {json}"
… = ein direkter Befehl, sofort ohne Modell ausgeführt (auch während der
Agent arbeitet; die Antwort erscheint im Fenster des Chats, nur ein Fehler kommt in das transcript – aus einem Skript
den Befehl direkt aufrufen; /ai_chat wird abgewiesen); newChat = Neuer Chat; stop = Stopp; last = Anzahl der
letzten Einträge des Chats in der Antwort (0 = alle); anonymous = der anonyme
Modus an / aus (wie /anonymous on | off und das Kontrollkästchen in den Einstellungen; eine
Änderung beginnt einen neuen Chat). Ist consentPending true, wurde die erste Nachricht von der Frage echte Daten
senden? zurückgehalten – antworten mit message "yes" (echte Daten), "anon"
(anonymer Modus an) oder "no" (nichts wird gesendet). Antwort: busy (der Agent arbeitet),
anonymous (Modus an), consentPending (die Frage YES / ANON / NO wartet), transcript [{who (user | agent |
tool | error | question), text, time}] |
sim_options – Optionen der Registerkarte Simulation
Ohne Schlüssel liest der Befehl die Optionen. Mit Schlüsseln setzt er sie wie ein Klick in der Oberfläche (auch in den Einstellungen gespeichert). Während der Simulation sind die Optionen gesperrt, das Setzen gibt einen Fehler. Die Antwort enthält immer alle Werte und locked (true, während die Simulation läuft).
| Schlüssel | Wert | Option in der Oberfläche |
|---|---|---|
| stopAtCollisionRisk | true / false | Stop the simulation at a collision risk |
| loopSync | true / false | Start all together at 'Warte auf Folgenstart' |
| interlocks | true / false | Respect interlock signals (A8n / Makro20 / A4n) |
| autoQuitt | true / false | Quitt if all robots wait |
| stopOnBreakpoints | true / false | Stop on breakpoints |
| syncOncePerCycle | true / false | once per cycle (neben Stop at WARTE BIS:) |
| stopWaitFalse | true / false | Stop at 'WARTE BIS AUS' and wait for Continue |
| stopEveryWait | true / false | Stop at every 'WARTE BIS' and wait for Continue |
| printAxes | true / false | Show the axis values of every point in the console |
| toolDocking | true / false | Tool change at the docking points (Auto-Docking) |
| toolDockingDistance | Zahl (mm) | Max. distance of the tool from the flange (Auto-Docking) |
| showState | true / false | Show the program state above the robots |
| collisionMap | true / false | Show collision map |
| collisionMapPosition | 0 Boden, 1 oben, 2 Fuß | Lage der Kollisionskarte |
| upCalls | "none", "onlyEin", "all" | UP calls: Do not execute / Only unconditional calls / All calls |
| syncWaits | Text, z. B. "E23; E80 & E76" | Stop at WARTE BIS: |
| redrawMs | 16, 50, 100, 250, 1000 | Szene alle ... ms zeichnen (Optionen Live 3D); auch während der Simulation änderbar |
| programRules | [{kind, value, ms, prAct, mode, overlap}] | Tabelle Program rules (ersetzt die ganze Tabelle). kind: excludeUp, waitAtCommand, excludeMakro, excludeFbPsps, customCommand; mode: solo, before, after, reload |
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"sim_options"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"sim_options","stopAtCollisionRisk":false,"upCalls":"all","syncWaits":"E23; E80 & E76"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"sim_options","programRules":[{"kind":"waitAtCommand","value":"SERVOZANGE","ms":1200,"prAct":true,"mode":"after","overlap":400}]}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"live_check","on":true,"cell":30,"capsule":60,"range":200,"warn":50,"thread":true,"parallel":true,"grid":true,"stepMs":20}'
robust_test – Aktionen
| action | Parameter | Was sie macht |
|---|---|---|
| load | file oder plan {...}; services, stops, sps, program (true / false, Standard true) | lädt einen Plan; die Teile wählen, was aus der Datei übernommen wird (Serviceprogramme, Halte in Punkten, SPS-Programm, Programm); plan = der Plan als JSON-Objekt im Befehl (Format einer Plandatei, z. B. vom KI-Agenten) – er wird in eine temporäre Datei geschrieben und von dort geladen; Antwort: file (diese temporäre Datei) |
| save | file; services, stops, sps, program | speichert den Plan mit diesen Teilen |
| options | die Schlüssel einer Plandatei (seed, speed, ignoreCollisions, stopOnCollision, only3d, allUps, repeat, baseline, baselineCycles, timeLimitMin, maxCycles, recoveryTolerance, report, startAt, generator {...}, missingTest {...} oder false), autoSave (true / false) | setzt die Optionen der Registerkarte ohne Plandatei - nur die angegebenen Schlüssel ändern sich (generator und missingTest Schlüssel für Schlüssel); eine Quelle der Schritte ist nötig: geladener Plan, generator oder missingTest. Antwort: plan (alle Optionen nach der Änderung) |
| find_services | füllt die Tabelle der Serviceprogramme aus der Folge der Roboter; Antwort: services | |
| service | robot, up, everyCycle | fügt eine Zeile der Serviceprogramme hinzu oder ändert sie; Antwort: services |
| stop_point | robot, point ("UP42/P29" oder "P12"), sec (20), everyCycle (1) – oder clear (true), remove (Zeile 0..n-1) | fügt einen Halt in einem Punkt hinzu, entfernt eine Zeile (remove, Index wie in der Antwort) oder leert die Tabelle; Antwort: stops |
| start / resume | startet den Test / setzt einen gespeicherten Test fort | |
| pause / continue | hält den Test an / setzt ihn fort | |
| stop | beendet den Test | |
| status | active, paused, finished, round, step, totalCycles, collisionRisks, baselineCycle, seed, stopReason, minutes, report, remainingMinutes und estimatedEnd (geschätzte Restzeit und Ende des Tests; fehlen, solange unbekannt; nach dem Zeitlimit der Rest des aktuellen Schritts, der immer zu Ende läuft); beim Test fehlender Verriegelungen auch missing (total, done, collisions); während des Tests auch der aktuelle Schritt: stepRunning, stepName, stepLoop / stepLoops (Durchlauf des langsamsten Roboters / Durchläufe des Schritts), stepMinutes, timeLimitMinutes und timeLimitReached | |
| risks | findings des ganzen Tests bis jetzt: robot, where, partner, partnerWhere, count, firstAt, firstStep, kind (zone | 3d | near), distance, parts, png | |
| report | progress: "<Ordner>" (optional) | schreibt den Bericht; mit progress den Bericht eines gespeicherten Tests aus seinem Ordner; Antwort: file |
Jede Option des Fensters (UI-Befehle)
Neben den Befehlen oben ist jedes Bedienelement des Simulators erreichbar – auch in Dialogen, Meldungsfenstern, Einstellungen und Kontextmenüs – ohne Bildschirmfotos: die Antwort enthält die Elemente als Daten (Typ, Beschriftung, Pfad Registerkarte / Gruppe / Dock, Wert, Einträge, Zeilen von Tabellen und Bäumen). Die Liste aller Menüaktionen und Bedienelemente: Befehls-API - Referenz. Jedes Element hat eine Nummer (id), die gleich bleibt, solange es existiert; es kann auch über seine Beschriftung (+ window, path, type; first: true nimmt das erste von mehreren passenden Elementen), eine Menüaktion über action (Menüpfad). Das ist target in der Tabelle unten. Änderungen und Klicks werden direkt nach der Antwort ausgeführt, ein dadurch geöffneter Dialog blockiert die API nicht: er erscheint in ui_windows (modale zuerst) und status (modal, uiPending).
| Befehl | Parameter | Was er macht |
|---|---|---|
| ui_windows | all | offene Fenster des Simulators (Dialoge, Meldungsfenster mit Text, Menüs) |
| ui_list | window, filter, hidden, labels, all | Bedienelemente der Fenster; hidden = auch auf nicht gezeigten Registerkarten; labels = auch Texte (QLabel); all = auch Fenster außerhalb des Simulators |
| ui_actions | window, hidden | Menü- und Symbolleistenaktionen mit Pfad, z. B. Simulation > Simulation laden... |
| ui_get | id | label | action | ein Element mit allen Details (Tooltip, alle Listeneinträge) |
| ui_set | target, value, enter; dockHeight, dockWidth (px); scroll | setzt Kontrollkästchen, Text, Zahl, Listeneintrag, Schieberegler oder Registerkarte wie der Benutzer;
scroll (ohne value) scrollt ein Textfeld oder eine Liste: "top", "bottom", eine Zahl 0..1
oder "find:Text" (erste Stelle des Textes oben – auch in schreibgeschützten Feldern wie dem Chat des KI-Agenten);
dockHeight / dockWidth mit einem beliebigen Element in einem angedockten Fenster (z. B. die Schaltfläche Senden des KI-Agenten):
setzt die Größe dieses Fensters wie das Ziehen am Rand; Antwort z. B. {"dock":"AI Agent","dockHeight":665,"dockWidth":1682,"ok":true};
Fehler, wenn das Element nicht in einem angedockten Fenster liegt oder das Fenster frei schwebt |
| ui_click | target | action | Taste, Menüaktion, Eintrag eines offenen Kontextmenüs |
| ui_view / ui_view_set | target, row ("0/2/1"), column; ui_view: maxRows (500), depth (32), expandedOnly; ui_view_set: check, value, select, add, expand, collapse, click, doubleClick, activate | liest oder ändert Tabellen und Bäume (Programme in Arbeitsbereiche markieren, Programmregeln bearbeiten, Doppelklick auf ein Ergebnis) |
| ui_context | target, row, column | öffnet das Kontextmenü eines Elements oder einer Zeile |
| ui_close / ui_key | window, accept / keys, text | schließt ein Fenster, sendet Tasten |
| ui_file | answer, answers, clear | Antworten für die nächsten Dateidialoge (der Dialog wird nicht gezeigt); leer = Abbrechen |
| ui_shot | target, file, parent | Bild eines Fensters oder Elements (nur wenn ein Mensch es sehen soll); parent: n Ebenen über dem Element (eine Gruppe oder der ganze Inhalt eines gescrollten Reiters, auch der Teil außerhalb des sichtbaren Bereichs) |
| settings_get / settings_set | filter / key, value, remove; group (Standard RCS_Group) | Einstellungen des Simulators (RCS_Group), z. B. die im Hintergrund vorbereiteten Makros oder die Programmregeln |
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_click","action":"Extras > Einstellungen..."}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_set","label":"Im Hintergrund vorbereitete Makros","value":"20, 45, 46, 47, 50, 57"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_click","window":"Einstellungen","label":"OK"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_file","answer":"C:/cells/station_folge81.xml"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_click","action":"Simulation > Simulation laden..."}'
Simulator ohne Klick starten (Editor-API)
Wenn Settings > AI Agent > Command API of the editor (Einstellungen des Editors) eingeschaltet ist (oder mit DRES_API=1), empfängt DReS selbst Befehle über \\.\pipe\DReS_API (Client
AIAgent\dres_api.ps1): license zeigt, ob die Lizenzprüfung läuft, ob das erste Lesen des Schlüssels
abgeschlossen ist (ready) und welche Lizenzen verfügbar sind; plugins listet die Plugins der Menüs;
run_plugin {name, wait} öffnet ein Plugin, sobald der Lizenzschlüssel gelesen ist; open {file, line} öffnet
eine Datei; status zeigt die aktive Datei und einen offenen Dialog; settings_get / settings_set lesen und ändern die Einstellungen des Editors und der Plugins, z. B. RCS_Group/Automation_Api = true vor run_plugin, damit der Agent die API des Simulators selbst einschaltet.
Settings > Configure > AI Agent, Registerkarte Command API (lokaler Pfad verdeckt)
AIAgent\dres_api.ps1 '{"cmd":"license"}'
AIAgent\dres_api.ps1 '{"cmd":"settings_set","key":"RCS_Group/Automation_Api","value":true}'
AIAgent\dres_api.ps1 '{"cmd":"run_plugin","name":"Robot Cell Simulator"}'
Der KI-Agent VeRa (Sprachsteuerung, MCP-Server für Claude Code) nutzt diese APIs: VeRa - KI-Agent und Sprachsteuerung.
Client-Skript
template\RCS\AIAgent\rcs_api.ps1 (PowerShell) sendet einen Befehl und gibt die Antwort aus; -WaitIdle wartet,
bis der Simulator frei ist (kein Laden, keine Vorbereitung, keine Simulation).
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"status"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"load","file":"C:/cells/station_folge81.xml","newScene":true}' -WaitIdle
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"fast_run","program":"folge125"}' -WaitIdle
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"run","folge":81,"loops":10,"speed":400,"sps":true}' -WaitIdle -TimeoutSec 900
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"run","up":42,"loops":1,"sps":false}' -WaitIdle
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"sim_action","action":"pause"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"report","file":"C:/reports/variante_c.html","pdf":true,"compareFile":"C:/reports/original.rcsrun.json"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"zones","programs":["folge81"]}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"check_interlocks"}'
Beispiel: Variante einer Station
Originalstation laden, Folge 81 zehnmal mit dem SPS-Programm der Station fahren, Bericht speichern; die geänderte Kopie der Programme laden, gleich fahren und einen Bericht mit Vergleich zum Original speichern (compareFile = die .rcsrun.json des ersten Berichts). Dieselbe Folge für mehrere Varianten ergibt eine Tabelle der Taktzeiten ohne einen einzigen Klick. Die Simulationsgeschwindigkeit ändert die gemessenen Zeiten nicht (400 % ergibt dieselben Taktzeiten wie 100 %).
Die Daten des Laufs (run_data) enthalten die Taktzeit der Station, den Roboter, der sie bestimmt, das
Warten auf Verriegelungen je Roboter und Punkt (zoneWaits), wie lange jeder Bereich gehalten wird (zoneHolds)
und wer im ersten Zyklus seit wann einen Bereich hält (firstCycleWaits), Warteketten (waitChains: der Partner,
der den Bereich hält, wartet selbst auf einen anderen Bereich oder eine Bedingung) und fast gleichzeitige Anforderungen
desselben Bereichs (requestRaces mit minDt / maxDt, Zeitfenster raceWindow, Vorrangregeln raceRules und ihre Anwendung raceRuleLog, Regeln aus Wettläufen raceAutoRules) – genug, um den Engpass und den Roboter, auf den er wartet, zu finden. Nach
einem Lauf liefert check_interlocks auch die Codes CHAIN und RACE sowie LONG als Warnung, wenn
ein Partner auf den Bereich gewartet hat.