Alles Folgende kann über die UI-Befehle der Befehls-API gelesen und geändert werden, ohne Bildschirmfotos. Die Liste wurde von der API selbst erzeugt (ui_actions, ui_list mit hidden) und entspricht daher dem Programm. Ein Element wird über seine id aus ui_list oder über seine Beschriftung (+ path, type, window) angegeben; die Beschriftungen sind die der deutschen Oberfläche (englische Oberfläche: English). Listen von Robotern, Programmen und Punkten hängen von der geladenen Zelle ab und werden mit ui_view gelesen.
Die Optionen der Registerkarte Simulation lassen sich auch ohne die UI-Befehle setzen: set, run (auch up), fast_run, sim_options, sim_action, live_check, zones (mode), view, robot, collision_ignore, collision_report, race_rules, race_study (unten), report_open, model_converter, model_cache (unten) und robust_test – siehe Befehle. Ohne die Zusatzlizenz API / CLI gehen nur lesende Befehle.
Die WARTE ZEIT-Befehle der Roboterprogramme, die im Fenster nur als Warnungen in der Konsole und im Bericht (Abschnitt 3. Was zu prüfen ist) erscheinen, liest wait_times (optional robot = Teil des Roboternamens; Antwort waitTimes [{robot, program, point, command, seconds, condition, line}], count, secondsTotal, note) – nur lesend, ohne die Lizenz API / CLI, auch während der Simulation; status liefert ihre Anzahl (waitTimes), die Laufdatei *.rcsrun.json enthält das Array waitTimes.
Die Kamera der 3D-Ansicht (Mausrad, Verschieben) stellt view ein: zoom
(Faktor 0.01..100, > 1 näher) und target ([x, y, z] mm, die Mitte der Ansicht); jede Antwort von view
enthält camera {target, scale, distance} nach allen Änderungen des Befehls (target [mm] die Mitte der
Ansicht, scale die Höhe der Ansicht im Ziel [mm], distance = scale / (2·tan 22,5°) der Abstand der
Kamera in der Perspektive, Sichtwinkel 45°). In einem Befehl wird zuerst standardView angewendet, dann
fitAll / viewAll, dann target und zoom: {"cmd":"view","standardView":"default","target":[x, y, z],"zoom":6}
behält das Ziel. Die 3D-Ansicht selbst ist das Element view3d von ui_list: ui_context mit ihrer id
öffnet das Kontextmenü der Ansicht, ui_key sendet die Tasten der Ansicht (Bedienfeld und Fenster).
status liefert fps (gezeichnete Bilder der Ansicht pro Sekunde, Zeichnen auf Anforderung) und viewSyncMs
(mittlere Zeit des GUI-Threads pro Bild für die Übernahme der Szenenänderungen, ms), beide -1 in der Variante mit dem JT-Leser;
seit 2026-10-25 außerdem glRenderer (Grafikkarte der Ansicht: Renderer / Hersteller / OpenGL-Version, wie in der
Konsolenzeile 3D view: graphics card ...) und paintFps (Zeichnungen der Widgets der 3D-Ansicht pro Sekunde
seit dem vorigen status, auch in der Variante mit dem JT-Leser; in der Qt3D-Variante gilt fps); seit 26.10.2026 außerdem das Objekt memory (privateMB, workingSetMB,
peakWorkingSetMB, peakPagefileMB) und der Diagnosebefehl memory_trim. Die Antwort von robot enthält
flange ([x, y, z] mm, die Position des Flansches des Roboters in der Szene) – Zoom auf ein Roboterwerkzeug:
{"cmd":"view","target":[x, y, z],"zoom":6} mit den Werten aus flange, danach scene_shot; toolKind
(cad / dummy / none) und toolText sagen, ob der Roboter das CAD-Modell seines realen Werkzeugs oder ein
Dummy-Werkzeug hat (eine Näherung in den Arbeitsbereichen und der 3D-Kollisionsprüfung; ein Roboter mit 3D-Modell seines Werkzeugs hat kein Dummy-Werkzeug). Die am Roboter angebauten Elemente: tool_info, tool_remove, tool_hide / tool_show (Robotermenü Montierte Elemente und Doppelte Modelle entfernen). Mit view
collisionPlaces true sind die Kollisionsstellen des letzten Laufs Kugeln in der Szene (rot = 3D-Berührung,
gelb = 3D-Annäherung ohne Kontakt, violett = Gefahr aus den Arbeitsbereichen; Farben: view collisionPlaceColor3D /
collisionPlaceColorZone / collisionPlaceColorProximity);
die Antwort von collision_case action "points" enthält point
([x, y, z] mm, die Kugel des gezeigten Kontakts) – {"cmd":"view","target":point,"zoom":6} vor
scene_shot zeigt die Stelle mit beiden Robotern in ihren Achsen bei diesem Kontakt. Ein 3D-Fall behält bis zu 4
Kontaktstellen, die mehr als 400 mm auseinander liegen, und eine Zeile kann mehrere Fälle zusammenfassen – jede
Stelle hat ihre eigene Kugel, Zeit und Roboterachsen (es kann also mehr Kugeln als Zeilen geben): der erste Aufruf zeigt
die erste Stelle der Zeile, jeder wiederholte Aufruf mit demselben Schlüssel die nächste (nach der letzten wieder die
erste); der Schlüssel eines einzelnen Kontakts zeigt genau diesen Kontakt. Die Antwort enthält auch place /
places (3D-Zeilen) und shown (was die 3D-Ansicht zeigt). Bei einer Zeile der Arbeitsbereiche fahren die
Roboter in die Programmpunkte, und die 3D-Modelle werden in dieser Stellung einmal geprüft: Berührung = orange Kugel
(3D-Kontakt in den Programmpunkten) und Warnung in der Konsole, sonst der kleinste Abstand – dieses Ergebnis
kommt etwa 0,2–6 s später in der Konsole. collisionPlaceLabels false blendet die Texte über den Kugeln aus.
Die Gruppe Kartesisch (TCP) der Registerkarte Roboterachsen (Kartesisches Verfahren) hat den Befehl robot als Gegenstück: tcp {tool, base} liest die TCP-Position im gewählten Werkzeug und in der gewählten Basis (Antwort tcp und tcpScene), moveTcp {x, y, z, [a, b, c], tool, base, frame} fährt den TCP dorthin mit derselben inversen Kinematik wie die Schaltflächen − / + (S / T der aktuellen Position); mit frame "scene" wird das Ziel in der Szene angegeben, z. B. tcpScene oder flange eines anderen Roboters. Das Kontextmenü des Roboters Alle Programme suchen (Find all programs, Model Browser) ist rebuildPrograms true: der Programmbaum wird neu aufgebaut, neue oder geänderte Folge- / UP-Dateien des Archivs werden gelesen. Die Antwort von robot enthält auch base (den Roboterfuß in der Szene).
Ein Bild nur der 3D-Szene (OpenGL, mit Beschriftungen und Dekorationen, wie
das Szenenbild in den Berichten) schreibt scene_shot {"cmd":"scene_shot","file":"C:/temp/cell.png"}
(Antwort file, bytes) – nur lesend, ohne die Lizenz API / CLI, wie ui_shot für Fenster und Elemente.
Menüaktionen
{"cmd":"ui_click","action":"Datei > Datei öffnen"}; Aktionen mit Zustand (Häkchen) auch ui_set true / false.
Ohne Dialoge: Datei > Datei öffnen ist auch der Befehl open (Pfade des
Assistenten als systemRoot / robotArchives), Datei > Roboter an Studienpositionen einfügen der
Befehl insert_study_robots. Die Titelleiste des Fensters zeigt den vollen
Pfad der geöffneten Simulationsdatei und der Zelle / Studie ({"cmd":"ui_windows"}, Feld title).
| Menüpfad | Zustand |
|---|---|
| Datei > Datei öffnen | ohne Dialoge: open |
| Datei > Assistent | Pfade: systemRoot / robotArchives von open |
| Datei > Sitzung öffnen... | |
| Datei > Sitzung speichern... | |
| Datei > Simulationspaket öffnen... | Dateidialog (ui_file), dann wie Simulation laden; das Paket wird mit dem Fortschrittsfenster Simulationspaket öffnen entpackt (Simulationspaket ... wird entpackt: n von m Datei(en), Abbrechen; Status: extracting); ohne Dialoge: package_open (file, convert) |
| Datei > Simulationspaket speichern (*.rcsz)... | Dateidialog (ui_file), Fenster: Roboterdaten aufnehmen (Programme, Konfiguration, Maschinendaten, Langtexte) (ein), Original-Modelldateien als Quelle einschließen (ein) mit der geschätzten Größe der Paketteile (API dryRun: estimatedSize {glb, source, robots, total} in MB), Speichern / Abbrechen; das Paket ist eigenständig, die Studiendatei wird nie aufgenommen; ohne Dialoge: package_save (file, includeRobotData, includeSource, dryRun) |
| Datei > Zuletzt geöffnete Dateien > Dateiname | ein Eintrag je zuletzt geöffneter Datei |
| Datei > Zuletzt geöffnete Dateien > Leeren | |
| Datei > Datei einfügen... | |
| Datei > Roboter an Studienpositionen einfügen... | ohne Dialoge: insert_study_robots |
| Datei > Roboter aus Archiv einfügen... | |
| Datei > Neue Szene | |
| Datei > Szene schließen | |
| Datei > Beenden | |
| Navigation > Alles einpassen | |
| Navigation > Alle einblenden | |
| Navigation > Zoomen | ui_set true / false |
| Navigation > Verschieben | ui_set true / false |
| Navigation > Drehen | ui_set true / false |
| Navigation > Normansicht > Standard | |
| Navigation > Normansicht > Oben | |
| Navigation > Normansicht > Unten | |
| Navigation > Normansicht > Links | |
| Navigation > Normansicht > Rechts | |
| Navigation > Normansicht > Vorne | |
| Navigation > Normansicht > Hinten | |
| Auswahl > Ausblenden | |
| Auswahl > Einblenden | |
| Auswahl > Nur diese einblenden | |
| Auswahl > Einblendung umkehren | |
| Ansicht > Achsen anzeigen | ui_set true / false |
| Ansicht > Perspektivmodus | ui_set true / false |
| Ansicht > Screenshot | |
| Ansicht > Aufgezeichnete Roboterbahn anzeigen | ui_set true / false |
| Ansicht > Roboterbeschriftung anzeigen | ui_set true / false |
| Ansicht > Nullpunkt anzeigen | ui_set true / false |
| Ansicht > Raster anzeigen | ui_set true / false |
| Ansicht > Konsolen und Lineareinheiten anzeigen | ui_set true / false |
| Ansicht > Werkzeug-TCP während der Simulation anzeigen | ui_set true / false; Befehl view simulationTcp (nur das TCP-Koordinatensystem des Werkzeugs, aus den Achswerten des gezeichneten Modells; seit 2026-10-25 kein Koordinatensystem des Programmpunkts / Ziels) |
| Ansicht > Kollisionsstellen anzeigen | ui_set true / false; Befehl view collisionPlaces (Kugeln: rot = Berührung Live 3D, violett = Kollisionsgefahr aus den Arbeitsbereichen; bis zum nächsten Lauf) |
| Ansicht > Beschriftung der Kollisionsorte anzeigen | ui_set true / false; Befehl view collisionPlaceLabels (Texte über den Kugeln: Art, Roboter, Zeit; auch im Kontextmenü der 3D-Ansicht) |
| Ansicht > Farben der Kollisionsstellen... | Dialog (ui_windows / ui_click); Befehl view collisionPlaceColor3D, collisionPlaceColorZone, collisionPlaceColorProximity ("#rrggbb", Standard #ff0000 / #e000e0 / #ffc000) |
| Ansicht > Größe der Signalbeschriftungen... | Fenster mit Schieberegler 30..300 %; Befehl view signalLabelSize |
| Fenster > Symbolleiste ein-/ausblenden | ui_set true / false |
| Fenster > Bedienfeld ein-/ausblenden | ui_set true / false |
| Fenster > Meldungsfenster ein-/ausblenden | ui_set true / false |
| Fenster > Attributfenster ein-/ausblenden | ui_set true / false |
| Simulation > Simulation speichern... | |
| Simulation > Simulation laden... | |
| Simulation > Zuletzt geladene Simulationen > Dateiname | ein Eintrag je zuletzt geladener Simulationsdatei (neueste zuerst, bis 15); lädt sie ohne Dateidialog; Liste: recent_files, Laden: load file |
| Simulation > AGENTS.md automatisch aktualisieren | ui_set true / false [aus]; Einstellung AgentsMd_Auto; Befehl agents_md auto true / false (status: agentsMdAuto); siehe AGENTS.md |
| Simulation > AGENTS.md jetzt aktualisieren | Symbol Neu laden; funktioniert auch bei ausgeschalteter Option und während eines Laufs (leichte Aktualisierung); ui_click; Befehl agents_md update true (get true liest die Datei, notes "Text" ersetzt den NOTES-Block, file "Pfad" schreibt eine Kopie) |
| Extras > Basen gegen die Studie prüfen... | Fenster: Toleranz Position / Drehung, Berichtsfelder Projekt, Ort, Kunde, Team, Station, Kommentar, Bericht mit der aktuellen 3D-Ansicht; ohne Dialoge: base_check (tolMm, tolDeg, project, place, customer, team, station, comment, report, view) |
| Extras > Basen gegen die Studie prüfen... > Fenster Berechnete Roboterpositionen | Tabelle mit den Kontrollkästchen der Roboter, Studie überschreiben (Sicherungskopie .bak) statt einer Kopie <Studie>_calibrated.xml (Standard aus), Simulation mit den neuen Roboterpositionen neu laden (Standard an), Schaltfläche Auf die gewählten Roboter anwenden; ohne Dialoge: base_check (apply = true, robots, saveStudy, overwrite, reload; Ergebnis calibration, apply) |
| Extras > Schweißpunktbericht... | Fenster: Toleranz Position (Standard 2 mm), Toleranz Zangenachse (Standard 5°), Bericht mit der aktuellen 3D-Ansicht, Koordinatensystem auf der Karte, Roboternamen als R1, R2 ..., Schaltfläche Bericht erstellen... (PDF / HTML / CSV); ohne Dialoge: weld_report (study, tolMm, tolDeg, robots, anonymize, axisCorner, maxItems, report, view, last) |
| Einstellungen > Konfigurieren... | |
| Einstellungen > Client System Root festlegen | |
| Einstellungen > Robots Machine Data Files festlegen | |
| Einstellungen > Robots Archive Files festlegen | |
| Einstellungen > Part Aggregator Size festlegen | |
| Einstellungen > Nullpunktgröße festlegen | |
| Einstellungen > Raster festlegen | |
| Einstellungen > Roboterbeschriftung festlegen | |
| Einstellungen > Weißen Hintergrund zeichnen | ui_set true / false |
| Hilfe > Dokumentation | |
| Hilfe > Kapitel der Dokumentation > Erste Schritte | |
| Hilfe > Kapitel der Dokumentation > 3D-Ansicht und Einstellungen | |
| Hilfe > Kapitel der Dokumentation > Roboter, Werkzeuge und Verfahren | |
| Hilfe > Kapitel der Dokumentation > Programme und Bahnen | |
| Hilfe > Kapitel der Dokumentation > Zellensimulation | |
| Hilfe > Kapitel der Dokumentation > Auto-Docking | |
| Hilfe > Kapitel der Dokumentation > Arbeitsbereiche und Kollisionen | |
| Hilfe > Kapitel der Dokumentation > Robot Cell Simulator Lite | |
| Hilfe > Kapitel der Dokumentation > Lizenzen | |
| Hilfe > Kapitel der Dokumentation > GPU und Einschränkungen | |
| Hilfe > Lizenzen... | |
| Hilfe > Sprache > English | ui_set true / false |
| Hilfe > Sprache > Deutsch | ui_set true / false |
Bedienfeld und Fenster
| Wo | Element | Typ | API |
|---|---|---|---|
| Hauptfenster | 3D-Ansicht (3D view, objectName view3d) – Kontextmenü: Fit All, weißer Hintergrund, Kollisionsstellen, Größe des Koordinatensystems, Hide / View Only / View All, Bahnen, Punktbeschriftungen, Koordinatensysteme der Punkte (Show point frames, Befehl view pointFrames), Display, Objekttypen; Tasten (Qt3D-Viewer): F Fit All, S Auswahl einpassen, 0 / Pos1 (Home) Standardansicht, 1..6 Normansichten, Pfeiltasten drehen um 15° (Umschalt + Pfeiltasten: verschieben), + / - und Bild↑ / Bild↓ (PgUp / PgDn) Zoom, Esc beendet eine erzwungene Operation oder hebt die Auswahl auf; keine Taste für die Perspektive (nur Menü View oder view perspective), kein W; Tasten im Komponentenbaum bewegen die Ansicht nicht; Variante mit dem JT-Leser: ui_key auf view3d ändert die Ansicht nicht (Black-Box-Test 2026-10-25); status: fps, viewSyncMs (wie das OSD der Ansichtsstatistik, -1 in der Variante mit dem JT-Leser) | view3d | ui_context (danach ui_click auf den Eintrag); ui_key "keys"; Befehle view (Kamera, Schalter; orbit dreht die Kamera wie die Drehtaste), view_drag (Mausziehen in der Ansicht, zum Messen der Flüssigkeit) und scene_shot |
| Meldungsfenster | Show information messages (number of messages) [0] | Kontrollkästchen | ui_set true / false |
| Meldungsfenster | Show warnings (number of warnings) [0] | Kontrollkästchen | ui_set true / false |
| Meldungsfenster | Show errors (number of errors) [0] | Kontrollkästchen | ui_set true / false |
| Meldungsfenster | (ohne Beschriftung - über id / Pfad) | Textfenster | ui_get (Text) |
| KI-Agent | (ohne Beschriftung - über id / Pfad) – der Chat; Links öffnen sich im Webbrowser | Textfenster | ui_get (Text); eigener Befehl ai_chat (transcript) |
| KI-Agent | (Kontextmenü des Chats) Kopieren, Alles auswählen, Größere Schrift (Strg + Mausrad), Kleinere Schrift, Ganze Unterhaltung kopieren, Leeren (neuer Chat) | Menü | ui_context; dasselbe wie ai_chat last (transcript) und ai_chat newChat |
| KI-Agent | Nachricht an den Agenten (Enter sendet, Umschalt+Enter neue Zeile; /help - kurze Übersicht, /reload - Wissensdateien neu laden; /status, /run folge=125 … - ein direkter Befehl des Simulators: keine Tokens, er geht nicht an das Modell, der Simulator führt ihn sofort aus und zeigt die Antwort (JSON) in der Unterhaltung) | Textfeld | ui_set "Text"; eigener Befehl ai_chat message (auch message "/help", "/reload", "/status") |
| KI-Agent | (Kontextmenü des Nachrichtenfelds) Rückgängig, Wiederholen, Ausschneiden, Kopieren, Einfügen, Löschen, Alles auswählen, Größere Schrift (Strg + Mausrad), Kleinere Schrift, Leeren (Schriftgröße 7 … 32 pt, auch Strg+Plus / Strg+Minus; Einstellung RCS_Group/AiChat_FontSize) | Menü | ui_context; ui_set "" (leeren) |
| KI-Agent | Senden | Taste | ui_click; ai_chat message; ui_set dockHeight / dockWidth (px) – Größe des angedockten Fensters des KI-Agenten (wie bei jedem Element in einem angedockten Fenster) |
| KI-Agent | Stopp | Taste | ui_click; ai_chat stop |
| KI-Agent | Neuer Chat | Taste | ui_click; ai_chat newChat |
| KI-Agent | Verbindung zum Modell: Einstellungen > Konfigurieren... > AI Agent (Anbieter, Adresse, API-Schlüssel, Modell) | Taste | ui_click |
| KI-Agent | (Statuszeile in der Titelleiste des Fensters) Anbieter, Modell; während der Arbeit: Schritt, Fortschritt der Simulation (Zyklus x / y, Restzeit); Kontext NN %, Tokens des Chats, (NN % des Limits) – grün / orange / rot | Text | ui_get (Text) |
| Bedienfeld | (ohne Beschriftung - über id / Pfad) – Registerkarten: Model Browser, Einstellungen, Roboterachsen, Simulation, Robustheitstest, Bewegung, Zeiten, Arbeitsbereiche, Auto-Docking, SPS (Elemente der Registerkarte Robustheitstest: ui_list mit path "Robustheitstest"; eigener Befehl robust_test) | Registerkarten | ui_set "Registerkarte" |
| Bedienfeld > SPS > Stationssteuerung (SPS) | Simulation mit dem SPS-Programm steuern | Kontrollkästchen | ui_set true / false |
| Bedienfeld > SPS > Stationssteuerung (SPS) | SPS-Programm bearbeiten... | Taste | ui_click |
| Bedienfeld > SPS > Stationssteuerung (SPS) | Neu aus den Robotern der Zelle | Taste | ui_click |
| Bedienfeld > SPS > Stationssteuerung (SPS) | Signale E / A der Roboter... | Taste | ui_click |
| Bedienfeld > SPS > Stationssteuerung (SPS) > Prüfung vor dem Lauf | Show information messages (number of messages) [0] | Kontrollkästchen | ui_set true / false |
| Bedienfeld > SPS > Stationssteuerung (SPS) > Prüfung vor dem Lauf | Show warnings (number of warnings) [5] | Kontrollkästchen | ui_set true / false |
| Bedienfeld > SPS > Stationssteuerung (SPS) > Prüfung vor dem Lauf | Show errors (number of errors) [0] | Kontrollkästchen | ui_set true / false |
| Bedienfeld > SPS > Stationssteuerung (SPS) > Prüfung vor dem Lauf | (ohne Beschriftung - über id / Pfad) | Textfenster | ui_get (Text) |
| Bedienfeld > SPS > Signale der Roboter | Signaldatei: | Textfeld | ui_set "Text" |
| Bedienfeld > SPS > Signale der Roboter | Eigene Signaldatei auswählen (z. B. eine Kopie für Ihre Anlage). Die Datei wird vor der Verwendung g | Taste | ui_click |
| Bedienfeld > SPS > Signale der Roboter | Bearbeiten | Taste | ui_click |
| Bedienfeld > SPS > Signale der Roboter | Datei der Installation | Taste | ui_click |
| Bedienfeld > SPS > Signale der Roboter | Mehr | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeugwechsel an den Andockpunkten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeug ablegen (DS abdocken): – Einträge: MAKRO, UP, A | Liste | ui_set "Eintrag" |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeug ablegen (DS abdocken): (0 … 9999) | Zahl | ui_set Zahl |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | = – Einträge: EIN, TRUE | Liste | ui_set "Eintrag" |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeug aufnehmen (DS andocken): – Einträge: MAKRO, UP, A | Liste | ui_set "Eintrag" |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeug aufnehmen (DS andocken): (0 … 9999) | Zahl | ui_set Zahl |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | = – Einträge: EIN, TRUE | Liste | ui_set "Eintrag" |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Max. Abstand des Werkzeugs vom Flansch: (50 … 3000) | Zahl | ui_set Zahl |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Programm: (1 … 999) | Zahl | ui_set Zahl |
| Bedienfeld > Auto-Docking > Werkzeugwechsel (VKRC-Programme) | Werkzeugwechsel auf allen Robotern | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Datei mit Werkzeugwechselregeln auswählen (gespeichert in den Einstellungen von Robot Cell Simulator | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Regeln aus der Datei: ein regulärer Ausdruck auf den Text eines Programmbefehls VKRC: Fold-Titel, z. | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Regeldatei öffnen... | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Integrierte Regeln | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Integrierte Regeln speichern unter... | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Im Editor bearbeiten | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeugwechselregeln (alle Standards) | Neu laden | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeuge an den Robotern | Alle Werkzeuge von allen Robotern lösen | Taste | ui_click |
| Bedienfeld > Auto-Docking > Werkzeuge an den Robotern | Standardwerkzeuge an alle Roboter anbauen | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche | Aus den Bahnen ihrer Programme berechnete Arbeitsbereiche der Roboter. Grün = von einem Roboter genutzt, gelb… | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Arbeitsbereiche | Alle auswählen | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche | Keine auswählen | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche | Auswahl umkehren | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche > Berechnung | Raster: – Einträge: 50 mm, 100 mm, 150 mm, 200 mm, 300 mm | Liste | ui_set "Eintrag" |
| Bedienfeld > Arbeitsbereiche > Berechnung | Gliedradius: (0 … 1000) | Zahl | ui_set Zahl |
| Bedienfeld > Arbeitsbereiche > Berechnung | Am Flansch angehängtes Werkzeug einbeziehen (3D-Modell) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Arbeitsbereiche > Berechnung | In den Punkten aufgerufene Unterprogramme einbeziehen (UP) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Arbeitsbereiche > Berechnung | Würfelraster (Achse der Glieder + Radius) - schnell | Option | ui_set true |
| Bedienfeld > Arbeitsbereiche > Berechnung | Dreiecke der 3D-Modelle (reale Form) - dauert länger | Option | ui_set true |
| Bedienfeld > Arbeitsbereiche > Berechnung | Berechnen | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche > Berechnung | Leeren | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche > Berechnung | Kollisionsmatrix... | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche > Anzeige | Arbeitsbereiche anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Arbeitsbereiche > Anzeige | Nur gemeinsame Bereiche anzeigen (gelb / rot) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Arbeitsbereiche > Anzeige | Transparenz: (10 … 95) | Schieberegler | ui_set Zahl |
| Bedienfeld > Arbeitsbereiche > Anzeige | Programmbahn in Verriegelungsfarben | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Arbeitsbereiche > Einfahrten ohne Verriegelung | Punkte, an denen ein Roboter ohne Verriegelungsanforderung in einen mit einem anderen Roboter gemein | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Arbeitsbereiche > Einfahrten ohne Verriegelung | Verriegelungen einfügen... | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche > Einfahrten ohne Verriegelung | Verriegelungen prüfen... | Taste | ui_click |
| Bedienfeld > Arbeitsbereiche | Anonymisierte Studie für KI... – Fragen vor dem Speichern: Verriegelungskommentare und Langtexte; Die in der letzten Simulation gefundenen Kollisionsgefahren hinzufügen (Verriegelungen prüfen: COLLISION, Simulation: collisionCheck)? [Ja, die Wahl wird gespeichert] (siehe Anonymisierte Studie) | Taste | eigener Befehl anon_study (file, check, run, show, texts, collisions true / false – false = ohne die Kollisionsgefahren, Blindtest der KI) |
| Bedienfeld > Zeiten | Berichtshinweise: | Textfeld | ui_set "Text" |
| Bedienfeld > Zeiten | Eigene Hinweisdatei wählen (z. B. eine Kopie mit den Texten Ihrer Anlage oder in einer anderen Sprac | Taste | ui_click |
| Bedienfeld > Zeiten | Bearbeiten | Taste | ui_click |
| Bedienfeld > Zeiten | Datei der Installation | Taste | ui_click |
| Bedienfeld > Zeiten | (ohne Beschriftung - über id / Pfad) | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Zeiten | Alle aufklappen | Taste | ui_click |
| Bedienfeld > Zeiten | Exportieren... | Taste | ui_click |
| Bedienfeld > Zeiten | Bericht... | Taste | ui_click |
| Bedienfeld > Zeiten | Signal-Zeitachse... | Taste | ui_click; signal_timeline window true |
| Signal-Zeitachse | Baum der Signale (ankreuzen) | Kontrollkästchen | signal_timeline select / add / remove; Simulationsdatei SignalTimeline |
| Signal-Zeitachse | in jedem Stationslauf aufzeichnen | Kontrollkästchen | signal_timeline record true / false |
| Signal-Zeitachse | Klick in die Zeitachse (Cursor), Text darunter | Diagramm | signal_timeline why (Zeit) + robot |
| Signal-Zeitachse | Roboter zum Cursor / 3D folgt dem Cursor | Taste / Kontrollkästchen | signal_timeline showAt (Zeit) |
| Signal-Zeitachse | Ganzer Lauf, Mausrad / Ziehen (Zeitfenster) | Taste / Diagramm | signal_timeline from, to |
| Signal-Zeitachse | Auswahl löschen | Taste | signal_timeline select [] |
| Signal-Zeitachse | Speichern... (CSV / PDF / HTML), Roboternamen als R1..Rn | Taste / Kontrollkästchen | signal_timeline export, anonymize |
| Signal-Zeitachse | Aktualisieren | Taste | ui_click; signal_timeline |
| Bedienfeld > Zeiten | Taktzeitreserve... | Taste | ui_click; cycle_reserve window true |
| Taktzeitreserve | Nutzung der Wartezeit / Override nicht unter / erst ab (%) | Zahlen | cycle_reserve share, minOverride, minGain; Simulationsdatei CycleReserve |
| Taktzeitreserve | Letzten Lauf analysieren | Taste | cycle_reserve action analyze |
| Taktzeitreserve | Nutzen (ankreuzen), Override [%] (Doppelklick) | Tabelle | cycle_reserve use [{robot, point, use, override}] |
| Taktzeitreserve | Kontrolllauf mit diesen Geschwindigkeiten / Kein Kontrolllauf | Tasten | cycle_reserve action test / cancel (danach run) |
| Taktzeitreserve | Bericht speichern... (PDF / HTML / CSV), Roboternamen als R1..Rn | Taste / Kontrollkästchen | cycle_reserve export, anonymize |
| Taktzeitreserve | Aktualisieren | Taste | ui_click; cycle_reserve |
| Bedienfeld > Bewegung > Bewegung | Reale Bewegung (Bewegungsplaner) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Bewegung > Bewegung | Echtzeit (1:1) | Taste | ui_click |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | Programm-Override: (1 … 100) | Zahl | ui_set Zahl |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | PTP-Beschleunigungszeit: (0.05 … 3) | Zahl | ui_set Zahl |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | Bahnbeschleunigung (LIN / CIRC): (0 … 20000) | Zahl | ui_set Zahl |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | Orientierungsgeschwindigkeit: (10 … 1000) | Zahl | ui_set Zahl |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | Überschleifen der Ecken | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Bewegung > Parameter des Bewegungsplaners | Standardwerte | Taste | ui_click |
| Bedienfeld > Bewegung > Programmbahn | Reale Bahn zeichnen (PTP / LIN / CIRC, Überschleifen) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Bewegung | Maschinendaten des gewählten Roboters | Taste | ui_click |
| Bedienfeld > Bewegung > Bewegungszeiten | (ohne Beschriftung - über id / Pfad) | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Bewegung > Bewegungszeiten | Exportieren... | Taste | ui_click |
| Bedienfeld > Bewegung > Bewegungszeiten | Leeren | Taste | ui_click |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Programm: – Einträge: Folge, UP | Liste | ui_set "Eintrag" |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Programmnummer, z. B. 125 für Folge125 (1 … 9999) | Zahl | ui_set Zahl |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Anzahl der Zyklen aus dem Start-Baustein des SPS-Programms (Reiter SPS) (1 … 999) | Zahl | ui_set Zahl |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Verriegelungssignale beachten (A8n / Makro20 / A4n) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Verriegelungskarte prüfen | Taste | ui_click; Befehl sim_action "check_interlock_map" |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Simulation bei Kollisionsgefahr anhalten | Kontrollkästchen | ui_set true / false; sim_options stopAtCollisionRisk |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | weiter nach N s | Drehfeld | ui_set 0..600; sim_options autoResume; Simulationsdatei Options autoResumeSec |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Kollisionsgefahren... | Taste | ui_click |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Live-3D-Kollisionsprüfung (Modelle der Roboter und Werkzeuge, langsamer) | Kontrollkästchen | ui_set true / false; live_check on |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Zelle (10 … 100 mm) | Zahl | ui_set Zahl; live_check cell |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Dummy-Werkzeugkörper R (10 … 300 mm) | Zahl | ui_set Zahl; live_check capsule |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Abstand bis (50 … 1000 mm) | Zahl | ui_set Zahl; live_check range |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Warnung unter (0 = aus … 500 mm, Standard 30) | Zahl | ui_set Zahl; live_check warn |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Kontakt bis (0 … 50 mm, Standard 5) | Zahl | ui_set Zahl; live_check contact; Simulationsdatei Options live3dContact |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | auch bei Annäherung unter 'Warnung unter' anhalten | Kontrollkästchen | ui_set true / false; live_check stopNear; Simulationsdatei Options live3dStopNear |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Paare ignorieren, die sich beim Start schon berühren (Warnung) | Kontrollkästchen | ui_set true / false; live_check ignoreStartContacts; Simulationsdatei Options live3dIgnoreStart |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Geringste Abstände... | Schaltfläche | ui_click; live_check window true; Werte: live_check closest |
| Geringste Abstände der Roboter (Live 3D) | Doppelklick auf eine Zeile / auf Wo | Tabelle | live_check show {robot, partner, what 3d / robot / partner} |
| Geringste Abstände der Roboter (Live 3D) | Aktualisieren | Schaltfläche | ui_click; live_check closest |
| Geringste Abstände der Roboter (Live 3D) | Bericht speichern... (PDF / HTML / CSV) | Schaltfläche | live_check export, format pdf / html / csv |
| Geringste Abstände der Roboter (Live 3D) | Robotername als R1..Rn | Kontrollkästchen | live_check anonymize true / false |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Prüfung in eigenem Thread | Kontrollkästchen | ui_set true / false; live_check thread |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | mehrere Prozessorkerne für eine Prüfung | Kontrollkästchen | ui_set true / false; live_check parallel |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | fester Schritt: die Simulationsuhr wartet auf jede Prüfung | Kontrollkästchen | ui_set true / false; live_check grid |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Schritt (10 … 500 ms) | Zahl | ui_set Zahl; live_check stepMs; Ergebnis: live_check stats (checks, checkMsP50 / P95, gapAvgS / gapMaxS, nearMoveMaxMm / nearMoveP95Mm, clockWaitS, recommendedStepMs, maxSpeedWithoutWait) |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Freie Fahrt - alle Bedingungen ignorieren (SPS, Verriegelungen, WARTE BIS, FB, Kollisionen) | Kontrollkästchen | ui_set true / false; sim_options freeRun |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Szene zeichnen (16, 50, 100, 250, 1000 ms) | Liste | ui_set Index; sim_options redrawMs |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Alle gemeinsam bei 'Warte auf Folgenstart' starten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Programmzustand über den Robotern anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Statusleuchte... | Taste | ui_click |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Kollisionskarte anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Position der Kollisionskarte in der 3D-Ansicht – Einträge: auf dem Boden, oben (unter den Statusleuchten), am Robotersockel (Achse 1) | Liste | ui_set "Eintrag" |
| Bedienfeld > Simulation > Programm auf allen Robotern starten | Konsolenmeldungen... | Taste | ui_click |
| Bedienfeld > Simulation | Geschwindigkeit: (0 … 400) | Schieberegler | ui_set Zahl |
| Bedienfeld > Simulation | Animationsgeschwindigkeit für alle Roboter: 0 % = Pause, 100 % = Echtzeit, bis 400 % = schneller. Mi (0 … 400) | Zahl | ui_set Zahl |
| Bedienfeld > Simulation | 25 % | Taste | ui_click |
| Bedienfeld > Simulation | 50 % | Taste | ui_click |
| Bedienfeld > Simulation | 100 % | Taste | ui_click |
| Bedienfeld > Simulation | 200 % | Taste | ui_click |
| Bedienfeld > Simulation | 400 % | Taste | ui_click |
| Bedienfeld > Simulation | SPS | Taste | ui_set true / false |
| Bedienfeld > Simulation | Auf allen Robotern starten | Taste | ui_click; bei eingeschalteter SPS und einer anderen Programmnummer im Feld Program eine Rückfrage (Continue setzt die Nummer des SPS-Programms und startet, Cancel startet nicht) – der API-Befehl run liefert denselben Text als Fehler Nicht gestartet: ... (Felder spsFolge, spsCycles) |
| Bedienfeld > Simulation | Pause | Taste | ui_set true / false |
| Bedienfeld > Simulation | Alle stoppen | Taste | ui_click |
| Bedienfeld > Simulation | Weiter (Quitt) | Taste | ui_click |
| Bedienfeld > Simulation | Quitt, wenn alle Roboter warten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation | Folge 123 | Taste | ui_click |
| Bedienfeld > Simulation | Folge 125 | Taste | ui_click |
| Bedienfeld > Simulation | Die Programme der Roboter werden im Hintergrund vorbereitet (einmal geparst) - die Simulation starte | Fortschritt | ui_get (nur lesen) |
| Bedienfeld > Simulation > Programmablauf | UP-Aufrufe: – Einträge: Nicht ausführen, Nur unbedingte Aufrufe (= EIN), Alle Aufrufe (Bedingungen ignoriert) | Liste | ui_set "Eintrag" |
| Bedienfeld > Simulation > Programmablauf | Bei 'WARTE BIS AUS' anhalten und auf Weiter warten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programmablauf | Bei jedem 'WARTE BIS' anhalten und auf Weiter warten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programmablauf | Fahrbedingungen ignorieren (FB PSPS / FB ONL) | Kontrollkästchen | ui_set true / false; sim_options ignoreMotionConditions |
| Bedienfeld > Simulation > Programmablauf | An Haltepunkten anhalten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programmablauf | Bei WARTE BIS anhalten: | Textfeld | ui_set "Text" |
| Bedienfeld > Simulation > Programmablauf | (icon) | Taste | ui_click |
| Bedienfeld > Simulation > Programmablauf | ... | Taste | ui_click |
| Bedienfeld > Simulation > Programmablauf | einmal pro Takt | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Simulation > Programmablauf > Programmregeln | Exclude UP: Aufrufe dieser UP-Nummern werden übersprungen (z. B. 101 oder 101, 105-108). Exclude MAK | Tabelle | ui_view / ui_view_set / ui_context |
| Bedienfeld > Simulation > Programmablauf > Programmregeln | Zellen der Regeltabelle: ui_view_set row / column | Liste | ui_view_set |
| Bedienfeld > Simulation > Programmablauf > Programmregeln | Hinzufügen | Taste | ui_click |
| Bedienfeld > Simulation > Programmablauf > Programmregeln | Entfernen | Taste | ui_click |
| Bedienfeld > Simulation > Programmablauf > Programmregeln | POT-Zeiten importieren... | Taste | ui_click |
| Bedienfeld > Simulation > Programmablauf | Achswerte jedes Punkts in der Konsole anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Roboterachsen | A1 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | A2 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | A3 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | A4 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | A5 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | A6 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | E1 (0 … 0) | Schieberegler | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A1 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A2 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A3 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A4 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A5 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Roboterachse A6 [Grad] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen | Zusatzachse E1 - Lineareinheit (7. Achse) [mm] (0 … 0) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | Werkzeug | Liste | ui_set "Eintrag"; Befehl robot tcp / moveTcp {tool} |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | Basis | Liste | ui_set "Eintrag"; Befehl robot tcp / moveTcp {base} |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Position X in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Position X in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Position X in der ausgewählten Basis [mm] (-100000 … 100000) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Position Y in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Position Y in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Position Y in der ausgewählten Basis [mm] (-100000 … 100000) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Position Z in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Position Z in der ausgewählten Basis [mm]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Position Z in der ausgewählten Basis [mm] (-100000 … 100000) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Orientierung A in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Orientierung A in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Orientierung A in der ausgewählten Basis [Grad] (-180 … 180) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Orientierung B in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Orientierung B in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Orientierung B in der ausgewählten Basis [Grad] (-180 … 180) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren - (TCP-Orientierung C in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | verfahren + (TCP-Orientierung C in der ausgewählten Basis [Grad]) | Taste | ui_click |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Orientierung C in der ausgewählten Basis [Grad] (-180 … 180) | Zahl | ui_set Zahl |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | Schritt – Einträge: 0.1, 1, 10, 100 | Liste | ui_set "Eintrag" |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Position beim Verfahren von E1 beibehalten | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | TCP-Koordinatensystem anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Roboterachsen > Kartesisch (TCP) | Basiskoordinatensystem anzeigen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Transparenz | Transparente Komponenten (außer Robotern und ihren Werkzeugen) | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Transparenz | Transparenz: (0 … 100) | Schieberegler | ui_set Zahl |
| Bedienfeld > Einstellungen > Transparenz | 80 % | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Einstellungen > Transparenz | Alle | Taste | ui_click |
| Bedienfeld > Einstellungen > Transparenz | Keine | Taste | ui_click |
| Bedienfeld > Einstellungen > Transparenz | Übernehmen | Taste | ui_click |
| Bedienfeld > Einstellungen > Transparenz | Zurücksetzen | Taste | ui_click |
| Bedienfeld > Einstellungen > Culling | View Culling aktivieren | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Culling | Size Culling aktivieren | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Culling | Statistik-OSD | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Level of Detail | Qualität: (0 … 100) | Schieberegler | ui_set Zahl |
| Bedienfeld > Einstellungen > Auswahl | ... | Taste | ui_click |
| Bedienfeld > Einstellungen > Auswahl | Links | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Auswahl | Mitte | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Auswahl | Rechts | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Animierte Kameraübergänge | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Automatisch alles einpassen | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Links | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Mitte | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Rechts | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Links | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Mitte | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Rechts | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Links | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Mitte | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Rechts | Taste | ui_set true / false |
| Bedienfeld > Einstellungen > Kamerasteuerung | Zoomen mit Mausrad | Kontrollkästchen | ui_set true / false |
| Bedienfeld > Model Browser | (ohne Beschriftung - über id / Pfad) | Baum | ui_view / ui_view_set / ui_context |
| Bedienfeld > Model Browser | (Kontextmenü eines Roboters) Werkzeugmodell (JT / STEP / STL / glTF)... (Tool model (JT / STEP / STL / glTF)...) – Dialog: Modelldatei (.jt, .gltf, .glb, binäres .stl, .stp, .step), X Y Z [mm], A B C [deg] (Ursprung des Modells relativ zum Flansch), zusätzliches Element am Flansch (Vorrichtung, z. B. Werkzeugwechsler) – das Werkzeug bleibt | Menü | ui_context; eigener Befehl tool_model (robot, file, pos {x, y, z, a, b, c}, fixture) – Dummy-Werkzeug entfernt, mit der Simulation und der Sitzung gespeichert |
| Bedienfeld > Model Browser | (Kontextmenü eines Roboters) Alle Programme suchen (Find all programs) – der Programmbaum des Roboters wird neu aus seinem Archiv aufgebaut (neue und geänderte Folge- / UP-Dateien) | Menü | ui_context; Befehl robot rebuildPrograms true (Antwort programsRebuilt) |
| Bedienfeld > Model Browser | Filter | Textfeld | ui_set "Text" |
| Bedienfeld > Model Browser | (icon) | Taste | ui_click |
| Programme und Eigenschaften | (ohne Beschriftung - über id / Pfad) – Registerkarten: Programme, Knotenattr. | Registerkarten | ui_set "Registerkarte" |
| Programme und Eigenschaften > Programme | (ohne Beschriftung - über id / Pfad) | Baum | ui_view / ui_view_set / ui_context |
| Programme und Eigenschaften > Programme | Geschwindigkeit 400 % (0 … 400) | Schieberegler | ui_set Zahl |
| Programme und Eigenschaften > Programme | Programm starten | Taste | ui_click |
| Programme und Eigenschaften > Programme | TCP-Position und aktuelle Position des montierten Werkzeugs während der Bewegung aufzeichnen | Taste | ui_set true / false |
| Programme und Eigenschaften > Programme | Zum vorherigen Punkt fahren | Taste | ui_click |
| Programme und Eigenschaften > Programme | Zum nächsten Punkt fahren | Taste | ui_click |
| Programme und Eigenschaften > Programme | Fahren | Taste | ui_click |
| Programme und Eigenschaften > Programme | Programm stoppen | Taste | ui_click |
| Programme und Eigenschaften > Programme | Touch up | Taste | ui_click |
| Programme und Eigenschaften > Programme | Editor | Taste | ui_click |
| Programme und Eigenschaften > Programme | Dem Editor folgen | Kontrollkästchen | ui_set true / false |
| Datei öffnen | Taste | ui_click | |
| Datei einfügen | Taste | ui_click | |
| Neue Szene | Taste | ui_click | |
| Alles einpassen | Taste | ui_click | |
| Zoomen | Taste | ui_set true / false | |
| Verschieben | Taste | ui_set true / false | |
| Drehen | Taste | ui_set true / false | |
| Achsen anzeigen | Taste | ui_set true / false | |
| Perspektivmodus | Taste | ui_set true / false | |
| Standard | Taste | ui_click | |
| Oben | Taste | ui_click | |
| Unten | Taste | ui_click | |
| Links | Taste | ui_click | |
| Rechts | Taste | ui_click | |
| Vorne | Taste | ui_click | |
| Hinten | Taste | ui_click | |
| Screenshot | Taste | ui_click |
Fenster der Wettläufe (race_study)
Am Ende einer Stationssimulation oder eines Robustheitstests mit Wettläufen kommt das Fenster Wettlauf gefunden; nach der Simulation beider Reihenfolgen das Fenster Simulation beider Reihenfolgen - Ergebnis (siehe Wettläufe: Vorschlag und Simulation beider Reihenfolgen). Die Simulation ändert das SPS-Programm nie von selbst. Jedes Element dieser Fenster hat den Befehl race_study; Fehlermeldungen sind immer englisch.
| Wo | Element | Typ | API |
|---|---|---|---|
| Wettlauf gefunden | (Tabelle) Bereich | Zuerst in der Simulation | Zweiter | Kleinster Abstand [s] | Tabelle | race_study status: proposals [{race, zone, first, whereFirst, second, whereSecond, difference}] |
| Wettlauf gefunden | Takte pro Lauf: (1 … 20) [3] | Zahl | race_study start: cycles |
| Wettlauf gefunden | Beide Reihenfolgen simulieren | Taste | race_study start (races [Indizes], fehlt = alle; cycles 1..20, Standard 3); Lizenz Simulation, aktives SPS-Programm |
| Wettlauf gefunden | Schutzbausteine hinzufügen | Taste | race_study add_blocks (races [Indizes], fehlt = alle); Antwort added [Texte] |
| Wettlauf gefunden | Schließen | Taste | ui_click (es wird nichts geändert) |
| Registerkarte Robustness test | Stop (während beide Reihenfolgen simuliert werden) | Taste | race_study stop: das SPS-Programm wird wiederhergestellt, Ergebnis der fertigen Läufe |
| Simulation beider Reihenfolgen - Ergebnis | (Tabelle) Bereich | A: Reihenfolge der Simulation | B: Roboter vertauscht | Behalten | Tabelle | race_study status: result [{race, zone, first, whereFirst, second, whereSecond, difference, A {avg, min, max, cycles, waitTotal, collisionRisks, interrupted, done}, B {...}, recommended "A" | "B" | "none"}] |
| Simulation beider Reihenfolgen - Ergebnis | Behalten (A: R1 zuerst | B: R2 zuerst | kein Baustein) | Liste (pro Zeile) | race_study apply: choices ["A" | "B" | "none", ...] – eine pro Wettlauf des Ergebnisses |
| Simulation beider Reihenfolgen - Ergebnis | Gewählte Bausteine hinzufügen | Taste | race_study apply; Antwort added |
| Simulation beider Reihenfolgen - Ergebnis | Schließen (SPS-Programm unverändert) | Taste | ui_click |
Der Befehl:
| Aufruf | Bedeutung |
|---|---|
{"cmd":"race_study"} oder "action":"status" | lesend, auch ohne Lizenz API / CLI: proposals, active (true, solange beide Reihenfolgen simuliert werden), run / runs (während active), result, pendingBlocks (Bausteine, die auf die Entscheidung bei save warten) |
{"cmd":"race_study","action":"add_blocks","races":[0]} | Bausteine 'Interlock priority' mit der Reihenfolge der Simulation; races fehlt = alle; Antwort added [Texte] |
{"cmd":"race_study","action":"start","cycles":3} | Simulation beider Reihenfolgen: für jeden Wettlauf 2 Läufe (A = Reihenfolge der Simulation, B = Roboter getauscht); Fortschritt und Protokoll auf der Registerkarte Robustness test, Bericht in Dokumente\RCS_Robustheitstest\race_study |
{"cmd":"race_study","action":"stop"} | stoppt sie; das SPS-Programm wird wiederhergestellt |
{"cmd":"race_study","action":"apply","choices":["A","none"]} | die gewählten Bausteine in das SPS-Programm (Kommentar mit den Ergebnissen beider Varianten; ein älterer Baustein desselben Paars im Bereich wird ersetzt); Antwort added |
Typischer Ablauf eines Agenten: run → auf das Ende warten (status) → race_study status → start {cycles: 3} → warten, bis active false ist → result lesen → apply {choices: [...]} → save {raceBlocks: "keep"}. Die Antwort von race_rules enthält auch proposals.
Seit 2026-10-25 werden die Fenster dieses Abschnitts (Wettlauf gefunden, Wettläufe der Anforderungen, Simulation beider Reihenfolgen - Ergebnis) sowie Simulation beendet / Kollisionsgefahr in der Simulation am Ende eines über die API gestarteten oder angehaltenen Laufs, Tests oder einer Studie nicht geöffnet – ihren Inhalt statt mit den ui_*-Befehlen mit race_study status, run_data und status.lastRunMessages lesen. In der GUI ist immer nur ein Fenster Simulation beendet offen: das nächste Ende eines Laufs ersetzt seinen Text.
Einstellungen (Einstellungen > Konfigurieren...)
Mit ui_click auf Einstellungen > Konfigurieren... öffnen, Elemente ändern, mit OK bestätigen; dieselben Werte stehen auch als Schlüssel von RCS_Group für settings_get / settings_set bereit.
| Wo | Element | Typ | API |
|---|---|---|---|
| (ohne Beschriftung - über id / Pfad) – Registerkarten: Signalbeschreibungen, Simulation, Kollisionsbericht, Verriegelungskommentare, KI-Agent (Elemente der Registerkarten Kollisionsbericht und Verriegelungskommentare: ui_list mit window "Einstellungen") | Registerkarten | ui_set "Registerkarte" | |
| KI-Agent | Befehls-API des Robot Cell Simulator für den KI-Agenten und Skripte (\\.\pipe\DReS_RCS_API) | Kontrollkästchen | ui_set true / false |
| KI-Agent | Client-Skript des Simulators: | Textfeld | ui_set "Text" |
| KI-Agent | Client-Skript des Simulators wählen | Taste | ui_click |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Anbieter: (Anthropic API (Claude) | OpenAI-kompatible API (VW LLMaaS, Azure OpenAI, OpenAI, lokales Ollama) | Claude Code - Ihr claude.ai-Konto (nur eigene Nutzung)) | Liste | ui_set "Eintrag"; Schlüssel AiChat_Provider (anthropic | openai | claudecode) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Programm Claude Code: (leer = automatisch gefunden: PATH oder %USERPROFILE%\.local\bin\claude.exe; nur für Claude Code) | Textfeld | ui_set "Text"; Schlüssel AiChat_ClaudePath |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Python: (Python 3 für den MCP-Server AIAgent\vera_mcp.py) [python]; nur für Claude Code | Textfeld | ui_set "Text"; Schlüssel AiChat_Python |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Adresse: (mit der Standardadresse des Anbieters ausgefüllt: https://api.anthropic.com/v1/messages | https://api.openai.com/v1/chat/completions; eine eigene Adresse bleibt) | Textfeld | ui_set "Text"; Schlüssel AiChat_Url |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | API-Schlüssel / Token: | Textfeld (Passwort) | ui_set "Text"; gespeichert verschleiert als AiChat_Key (nicht über settings_set setzen) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Header des Schlüssels: (Authorization | z. B. api-key) | Textfeld | ui_set "Text"; Schlüssel AiChat_AuthHeader |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Modell: (leer = claude-sonnet-5-5 / gpt-4.1 / Standard von Claude Code, z. B. sonnet, opus) | Textfeld | ui_set "Text"; Schlüssel AiChat_Model |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Schritte pro Nachricht: (5 … 500) [60] | Zahl | ui_set Zahl; Schlüssel AiChat_MaxSteps |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Kontextfenster [Tokens]: (8000 … 2000000) [200000] | Zahl | ui_set Zahl; Schlüssel AiChat_Context |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Token-Limit pro Chat: (0 = ohne Limit … 100000000) [ohne Limit]; nur ein Hinweis in der Statuszeile | Zahl | ui_set Zahl; Schlüssel AiChat_Budget |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Anonymer Modus - das Modell sieht R1, R2 ..., <file N> und <name> statt der Roboternamen, Dateipfade und Kennungen der Anlage [aus]; eine Änderung beginnt einen neuen Chat (siehe Anonymer Modus) | Kontrollkästchen | ui_set true / false; Schlüssel AiChat_Anonymous; ai_chat anonymous true / false; Chat /anonymous on | off |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Wissen der KI beim Start laden (Aufwärmen im Hintergrund) – etwa 8 s nach dem Start werden die Wissensdateien gelesen und einmal Claude Code (claude --version) und Python gestartet; keine Anfrage an das Modell, keine Token; ohne Verbindung zum Modell passiert nichts [aus] | Kontrollkästchen | ui_set true / false; Schlüssel AiChat_WarmUp; ai_chat warmUp true / false (Antwort warmUp, connectionConfigured) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Wissensdateien: – Wissensdateien des Agenten (Markdown oder Text), in dieser Reihenfolge an das Modell gesendet [template\RCS\AIAgent\rcs_agent_instructions.md] | Liste | ui_view / ui_view_set (select); Schlüssel AiChat_Knowledge (Liste von Pfaden) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Hinzufügen... | Taste | ui_click (Dateidialog, mehrere Dateien) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Entfernen | Taste | ui_click (entfernt die markierten Dateien) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Standard – nur die mit DReS installierte Anleitung (template\RCS\AIAgent\rcs_agent_instructions.md) | Taste | ui_click |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | Wissen neu laden – speichert die Liste und lädt die Dateien neu in das Fenster des KI-Agenten; die Unterhaltung bleibt | Taste | ui_click; ai_chat message "/reload" (ohne die Liste zu speichern) |
| KI-Agent > Fenster des KI-Agenten (Registerkarte neben den Meldungen) - Verbindung zum Modell | (Zusammenfassung unter der Liste) n Datei(en), x Zeichen (etwa y Tokens); nicht gefundene Dateien | Text | ui_get (Text) |
| KI-Agent | Dokumentation – Einrichtung des KI-Agenten Schritt für Schritt, öffnet sich im Browser (linke untere Ecke der Registerkarte) | Taste | ui_click |
| Simulation | Ausgang 'Prozess aktiv' (PrAct): | Textfeld | ui_set "Text" |
| Simulation | Im Hintergrund vorbereitete Makros: | Textfeld | ui_set "Text" |
| Simulation | Kollisionsmerker in Makros suchen: | Textfeld | ui_set "Text" |
| Simulation | Suchlauf: Strecke mit Vred: (0 … 10000) | Zahl | ui_set Zahl |
| Simulation | Suchlauf: längste Zeit: (0 … 3600) | Zahl | ui_set Zahl |
| Simulation | FB PSPS während der Bewegung prüfen: (0 … 10000) | Zahl | ui_set Zahl |
| Simulation | Kein Halt auf der Prozessbahn (LIN, CIRC, KLIN, KCIR, KPTP, SLIN, SCIR, Spline) | Kontrollkästchen | ui_set true / false |
| Simulation | Wettlauf um einen Bereich - Zeitfenster: (0.1 … 5) | Zahl | ui_set Zahl; race_rules window |
| Simulation | Fenster mit den Wettläufen am Ende einer Stationssimulation | Kontrollkästchen | ui_set true / false; race_rules message |
| Simulation | Reihenfolge der Roboter bei einem Wettlauf während des Laufs beibehalten [ein] – das SPS-Programm wird nicht geändert | Kontrollkästchen | ui_set true / false; race_rules lock; Schlüssel Race_Lock_Order |
| Simulation | Gespeicherten Bericht (HTML, PDF) im Standardprogramm öffnen [ein] – Zeitenbericht, Bericht des Robustheitstests, Bericht der Kollisionsrisiken | Kontrollkästchen | ui_set true / false; eigener Befehl report_open (open true / false; ohne open: lesen) |
| Simulation | Modellkonverter (JT nach glTF): – Pfad von modelconv.exe (GNU GPL v3; leer = automatisch <Programmordner>\RuntimeTools\modelconv\modelconv.exe), Ordner-Schaltfläche, Standard (leert das Feld), Zustand gefunden / nicht gefunden (siehe Plugin-Einstellungen > Simulation) | Textfeld + Schaltflächen | ui_set "Text" (gespeichert mit OK); eigener Befehl model_converter (path "..." / "" = automatisch; ohne path: lesen; Antwort path, default, found); Schlüssel Model_Converter |
| Simulation | JT-Modelle: umgewandelte glTF-Modelle verwenden: – Auto - fehlende Modelle ohne Rückfrage umwandeln (Standard), Fragen - ein Fenster vor dem Umwandeln, Nie - JT-Dateien direkt laden (siehe JT-Modelle als glTF) | Liste | ui_set Index / Text (gespeichert mit OK); eigener Befehl model_cache (convert "auto" | "ask" | "never"); Schlüssel JT_Convert_Mode |
| Simulation | Umgewandelte Modelle speichern: – Neben der JT-Datei (Standard) / Gemeinsamer Ordner: + Ordnerfeld (leer = %LOCALAPPDATA%\DrAmaT\RCS\Models) + Ordner-Schaltfläche | Optionsfelder + Textfeld | ui_set (gespeichert mit OK); model_cache (mode "nextToJt" | "folder", folder); Schlüssel JT_Convert_Location, JT_Convert_Folder; Schätzung einer Datei: model_cache estimate + file (estimateAll für eine Studie, unreadable; secondsPerFile / secondsPerMB / parallel aus den Schlüsseln JT_Convert_JobSecPerFile, JT_Convert_JobSecPerMB, gelernt aus den letzten Umwandlungen, seit 2026-10-25) |
| Available objects (Öffnen einer Studie) | Bereich JT-Modelle als glTF: JT-Modelle in glTF umwandeln und die umgewandelten Modelle laden, Anzahl der umzuwandelnden Modelle der gewählten Komponenten / MB / geschätzte Zeit, Umgewandelte Modelle speichern (wie in den Einstellungen) | Kontrollkästchen, Text, Optionsfelder, Textfeld | ui_set bei offenem Fenster; API open (convert) nimmt ohne Fenster die Einstellung; Auswahl der Objekte: API open objects "all" (= Select all) oder eine Auswahldatei .ini (= Schaltfläche Open des Fensters), seit 2026-10-25; in der Variante ohne JT-Leser zählt der Bereich auch die Roboter und die Mechanismen |
| JT-Modelle (Fenster des Modus Fragen) | N JT-Modelle sind noch nicht umgewandelt (X MB). Geschätzte Zeit: etwa Y s., Umgewandelte Modelle speichern, Nicht mehr fragen (automatisch umwandeln), Schaltflächen Umwandeln und laden / Ohne sie laden; danach der Fortschrittsbalken JT-Modelle werden in glTF umgewandelt... mit Abbrechen | Fenster | bei API-Befehlen nie angezeigt (convert "ask" wirkt wie "auto"); ui_click auf die Schaltflächen; status.converting / status.modelConversion |
| Simulation | Prozessorkerne für die Roboter: (0 … 5) | Zahl | ui_set Zahl |
| Kollisionsbericht | Benachbarte Punkte derselben Stelle als ein Fall (z. B. UP48/P23-P25) [ein] – Fenster der Kollisionsgefahren und Berichte (siehe Plugin-Einstellungen > Kollisionsbericht) | Kontrollkästchen | ui_set true / false (ui_list mit window "Einstellungen"); gilt auch für collision_report |
| Signalbeschreibungen | Standard-Langtexte des VW-Standards im SmartPad und im Signalfenster | Kontrollkästchen | ui_set true / false |
| Signalbeschreibungen | Langtexte-Verzeichnis: | Textfeld | ui_set "Text" |
| Signalbeschreibungen | Langtexte-Verzeichnis wählen (KS Teil 4 > Langtexte) | Taste | ui_click |
| Signalbeschreibungen | Standard | Taste | ui_click |
| Signalbeschreibungen | (ohne Beschriftung - über id / Pfad) | Tabelle | ui_view / ui_view_set / ui_context |
| Signalbeschreibungen | Dateien wählen... | Taste | ui_click |
| Signalbeschreibungen | Standard für die Zeile | Taste | ui_click |
| Signalbeschreibungen | Alles Standard | Taste | ui_click |