Switching onCommandssim_optionsrobust_testUI commandsUI commands – reference »Editor APIClient scriptExample
The Robot Cell Simulator can be controlled by commands from outside – the same steps as in the window (load a simulation, run, report, work zones, check interlocks), without dialogs. Use it for nightly regression tests of a station, for comparing variants of programs by a script and for an AI agent that runs the studies.
Switching on
The API is off by default. It is switched on in the settings of the simulator (Settings > Configure..., tab AI Agent: Command API of the Robot Cell Simulator for the AI agent and scripts) or by the environment variable DRES_RCS_API=1 when DReS starts. The same tab shows the path of the client script (default template\RCS\AIAgent\rcs_api.ps1 in the installation directory). It starts when the window of the Robot Cell Simulator is opened (Plugins > Robot Cell Simulator); the console shows Command API of the Robot Cell Simulator listening on \\.\pipe\DReS_RCS_API. Only the user who started DReS can connect (local pipe, no network).
License: the command APIs of the editor and of the Robot Cell Simulator need the additional license API / CLI (control of DReS and the simulator by other programs, scripts and AI agents). Without it only reading commands work (e.g. status, run_data, view, robust_test with status / risks, ui_list, ui_shot, scene_shot, recent_files), the other commands answer with an error about the missing license, and the settings of the command APIs are locked. The voice control VeRa needs this license too.
Commands
One JSON object per line in both directions, e.g. {"cmd":"status"}. Every answer contains
"ok": true / false and "error" when the command failed. While a command runs, message boxes are
not shown – the default answer is used and the message is written to the console.
Since 2026-10-25 this also applies to what comes later: a run, a robustness test or a simulation of both orders started
(or stopped) through the API ends without windows (Simulation finished, Collision risk in the simulation,
Request races, Request race found, the result of the simulation of both orders) – their text is in the
console and in status.lastRunMessages (also in the answers of report / run_data); a simulation file
loaded through the API (load, open, package_open) does not open the window Load simulation –
Not restored (list in status.lastLoadMissing and the console), and errors of the opening (unknown format, a
study that cannot be extracted) are only in the console. Only the pause at a collision risk (option Stop the simulation
at a collision risk) still opens its window with Continue; continue with
{"cmd":"sim_action","action":"resume"}. A missing license during a command or while DReS is closed is only
a message in the console.
Client script and time limit: since 2026-10-25 rcs_api.ps1 (and the voice assistant VeRa) writes the command with a time limit and without waiting until the program has read it – when DReS is busy or not answering, the script ends with an error instead of waiting without end.
Closing DReS through a script: when DReS or the window of the simulator is closed while a file is loaded (load, open, package_open, extraction of a package, conversion of JT models, work zones), the closing waits until the load is finished (the console shows Loading / calculation is in progress - DReS is closed when it is finished); the extraction of a package and the work zones are cancelled, loads not started yet are skipped (status.lastLoadError: cancelled - the program is being closed).
Flag "anon": true (any command): the names are translated – R1, R2 …, <file N>
and <name> in the command are replaced by the real robot names and file paths before the command runs, and in the
answer the robot names, file paths and plant identifiers are replaced by these identifiers. Used by the
AI Agent window in the anonymous mode and its MCP server (environment
DRES_AI_ANON=1); e.g. {"cmd":"robot","robot":"R2","goto":"UP42/P5","anon":true}.
| Command | Parameters | What it does |
|---|---|---|
| ping | name of the plugin | |
| status | loading (simulation file), preparing (programs parsed in the background), running, loop / loops, robots, speed, SPS, last errors (lastRunError, lastLoadMissing, robotNameWarnings), measuredCycles, uiPending (UI commands not executed yet) and modal (title of an open modal window); simTime (clock of the simulation, s), robustTest (a robustness test runs), waitTimes (number of the WARTE ZEIT commands in the robot programs, details with wait_times); during a run also elapsedSeconds (real time since the start of the run), simSeconds (simulation time of the run), effectiveSpeed (% = simulation time / real time, with the waiting for the Live 3D check), loopSeconds (real time of one loop, from the 2nd loop), remainingSeconds and estimatedEnd (until the end of all loops; missing in the 1st loop) and robotsProgress (robot, running, loop, loops); since 2026-10-25 ready (window of the simulator built and shown – commands sent earlier wait up to 60 s, then answer notReady), converting (JT models are converted now – changing commands answer an error until it ends) and modelConversion (result of the last load: converted, reused, failed, skipped, seconds, cancelled, noConverter, models [{jt, glb, state, seconds, triangles, error}]); fps (frames of the 3D view drawn per second – the view draws on request, so without changes of the scene there are few frames) and viewSyncMs (mean time of the GUI thread per frame for taking the changes of the scene into the view, ms); both -1 when the build does not measure them (variant with the JT reader); the same values are shown by the OSD statistics of the view (Settings: OSD). Since 2026-10-25 also glRenderer (graphics card of the 3D view: renderer / vendor / OpenGL version – the same text the console shows once as 3D view: graphics card ...) and paintFps (paintings of the widgets of the 3D view per second since the previous status; it works also in the variant with the JT reader, where fps is -1; in the variant without the JT reader (Qt3D view) fps is the value that counts). Since 2026-10-26 also the object memory (privateMB = committed private memory of the program, workingSetMB, peakWorkingSetMB, peakPagefileMB; see memory_trim). modelConversion starts again with every load, open and package_open: mode ("auto" | "ask" | "never" – the mode of this load); with "never" the JT models are listed with state "jt" (loaded directly); after a simulation package its models with state "package" and the number package. Also lastLoadError (error of the last load / open / package_open after its answer started, empty = none; also in the console) and extracting (a simulation package is extracted now, with a progress window). loading is true from the answer started until the file is loaded; since 2026-10-25 it is true during the whole opening of a file – also an opening from the menu / File > Wizard – until the message Opening finished; in this time changing commands answer the error A file is being loaded (as with load through the API). ready is unchanged (window of the simulator built). In modelConversion.models the state failed with error is also given for a JT file the converter cannot read and that is skipped without a new try. simTime stops at the end of a run (all robots finished or stop) and starts from 0 with the next run; since 2026-10-25 it also stands from the opening of the simulator until the first run (before it grew by about 1 s per second without any simulation). lastRunMessages (since 2026-10-25): the texts of the windows that a run started or stopped through the API does not open (Simulation finished, COLLISION RISK: ..., request races, result of the simulation of both orders); empty again with the next run started through the API | |
| load | file, newScene (true), convert | loads a simulation file (.xml) or a simulation package (.rcsz) with everything it contains (like the default choice of Load simulation); asynchronous – wait until status is idle. Like open, missing paths of the study do not open the window Paths not set: the console shows the warning Paths not set: ... and the simulation is loaded anyway. convert (since 2026-10-25): "auto" | "ask" (in the API like "auto", no windows) | "never" – the JT tool models as converted glTF models; without it the setting JT models: use converted glTF models; result in status.modelConversion. Since 2026-10-25 the answer started, file comes at once (before: after the whole load, 12–34 s, the window did not respond); the file is loaded in the next cycle of the event loop. A missing file is an error at once; other errors of the load are in status.lastLoadError and the console. While the file is loaded, changing commands answer an error (A file is being loaded); reading commands and the ui_* commands work |
| open | file, systemRoot, robotArchives, convert, objects | opens a file like File > Open file,
without dialogs: a Process Simulate study (.psz or StandaloneStudy*.xml), a JT model (.jt)
or a session of the simulator (.rcsession). systemRoot (system root of the study: library, macros) and
robotArchives (folder of the robot archives) are optional and are stored like the paths of File > Wizard
(they stay for the next opening). Missing paths do not open the window Paths not set: the console shows the
warning Paths not set: ... and the file is opened anyway. objects (since 2026-10-25): "all" (all
objects of the study, like Select all in the window Available objects) or the path of a selection file
.ini (saved with the button Save of this window, like its button Open); without it the remembered
selection (Remember selected items; without that no object). Refused while a simulation runs. Answer at once:
started, file, systemRoot, robotArchives (the paths used now), objects when given; the file is loaded in the
background – wait with status until loading / preparing are false, the console then shows
Opening finished after mm:ss. A study without its library (System Root not set) has no 3D models and no
robots - then the robots are inserted from their archives at the study positions (as insert_study_robots,
message in the console); wait until robots in status is the number of robots. Example:
{"cmd":"open","file":"D:/studies/cell_A/StandaloneStudy.xml","systemRoot":"D:/studies/sysroot","robotArchives":"D:/studies/archives","convert":"auto","objects":"all"}.
Also a simulation package .rcsz. convert as for load (components of the study and tools on the
robots; in the variant without the JT reader also the robots and the components with a mechanism).
An unknown file type is an error at once; a file that could not be opened: status.lastLoadError |
| insert_study_robots | file, convert | like File > Insert robots at
study positions without dialogs: inserts the robots of a Process Simulate study (file, .psz or
StandaloneStudy*.xml) at their positions in the study into the current scene; answer inserted (number of robots)
and report (text of the report: robots, archives, problems); errors: no scene yet (Create a scene first – open a cell first or
File > New scene), the study cannot be read, no robots in the study, a simulation runs, e.g.
{"cmd":"insert_study_robots","file":"D:/studies/cell_A/StandaloneStudy.xml"}; after the insert the
base check runs automatically (result in the console) |
| base_check | tolMm (default 2), tolDeg (default 0.2), study, last (true / false), console (default true), project, place, customer, team, station, comment, report (.pdf or .html), view (true / false), apply (default false), robots (default [] = all robots outside the tolerance, ["*"] = all), saveStudy (default <study>_calibrated.xml), overwrite (default false), reload (default true) | like
Tools > Check bases against the study... (description): compares the bases
of the study (frames b1, b2 ... / Fanuc uf1, uf2 ... at ir_<robot>, nominal values) with the bases of the
robot archives ($BASE_DATA[n] also #TCP / Fanuc UF[n], measured values). tolMm / tolDeg are saved like the
fields of the window; study = another study than the one the robots were inserted from; last: true = only
the last result without a new check; console: false = no lines in the console; the report fields are saved like
the fields of the window; report saves the report (PDF or HTML by the extension), view with the 3D view
(default: the check box of the window). Answer: study, tolMm, tolDeg, bases [{robot, base,
kind (base / externalTcp / userFrame), dPosMm, dXyzMm [x, y, z] in the robot coordinates, dRotDeg, worldStudy,
worldArchive [x, y, z], studyFrame, archiveFrame [x, y, z, a, b, c], ok}], groups (common bases of the station)
[{studyWorld, robots [{robot, base}], spreadMm, between [robot, robot], ok}], deviations (number of bases
outside the tolerance), time, robotsNotInScene, reportFile. The archive bases are taken relative to
$WORLD of the robot (Global * ROBROOT(0)-1), as the program paths.
Calculated robot positions: calibration [{robot, externalId, supported,
reason (e.g. robot on a linear unit), basesUsed, basesRejected, shiftMm, shiftXyzMm [x, y, z] in the world, rotationDeg,
oldWorld, newWorld, residualMm, residualDeg, needed (outside the tolerance), matrix}]. apply: true writes the
calculated positions of robots like the button Apply to the selected robots: to saveStudy (default
the copy <study>_calibrated.xml), overwrite: true = the study itself (backup copy
.bak_<date>_<time>), reload: true = simulation saved next to the copy as
<copy>_simulation.xml and loaded again; answer field apply {applied, study, backup, simulation,
reloadError, stationFramesKept, skipped}. Station base frames attached to the robot stay in the world, the copy is for
the Robot Cell Simulator, not for an import into Process Simulate. Errors: no study, the study has no base frames, the
report cannot be written, a simulation runs, no calculated positions, no robot to correct. Examples:
{"cmd":"base_check","tolMm":2,"tolDeg":0.2,"station":"ST 010","report":"D:/reports/base_check.pdf","view":true},
{"cmd":"base_check","apply":true,"robots":["*"],"reload":true} |
| weld_report | study (default the study of the robot positions), tolMm (default 2), tolDeg (default 5), robots (default [] = all), anonymize (default false), axisCorner (coordinate system of the world on the map: auto | top-left | top-right | bottom-left | bottom-right | center | none, default as in the window = auto), maxItems (default 500), report (.pdf, .html or .csv), view (default true), last (default false) | like Tools > Weld point report...
(description), license RCS 140: spot weld points of the programs of the robots
(SERVOZANGE / TECH EZ, SP, VW_USER EZSP; VW point numbers below 100 = service points, skipped) compared with the weld
points of the study (PmWeldLocationOperation projectedLocation, PmWeldPoint sheet thickness) after a robust fit per
robot / base / tool. tolMm, tolDeg, anonymize default to the values of the window
(anonymize: robot names as R1, R2 ...); maxItems: largest number of rows in the answer
(rowsTruncated: true when more); last: true = only the last result (without rows) or a report of it;
report saves the report (by the extension), view with the 3D view. Answer: points, programs,
robots, matched, withinTolerance, unnamed, studyWeldPoints, studyOperations,
fits [{robot, base, tool, points, fitted, fitMode, used, shiftMm, rotationDeg, toolAxis, frameDiffers (rotation > 10 deg: program
frame rotated against the study), noFit (no fit possible: frames differ, too few matching points)}], rows [{robot, program, order, point, line, name, base, tool, gun,
weldProgram, pointNumber, inStudy, ok, dXyzRawMm, dRawMm, dMm, angleDeg, angleRawDeg, thickness, studyProgram, file,
nameFromPointNumber (no name above the point, matched by the point number of the OLP commands of the study, unique
numbers only), noFit (no deviation numbers)}] (dRawMm before, dMm after the fit), notInPrograms (weld points of the study not found in the
programs), time, reportFile. Errors: no license, no robots in the scene, no spot weld points in the
programs, no report yet (last). Example:
{"cmd":"weld_report","tolMm":2,"tolDeg":5,"anonymize":true,"report":"D:/reports/weld_points.pdf"} |
| recent_files | – | reading, no license needed: {"ok":true,"simulations":[...],"studies":[...],"current":"<Simulation_File>"}
– simulations: the last 15 loaded simulation files (also loaded through the API), newest first, only
existing files (menu Simulation > Recent simulations); studies: the
recent studies (File > Recent files); current: the simulation file loaded now. Load one of them with
load – the AI agent takes a file the user names from here, it does not search the disk |
| set | speed, folge, up, loops, sps | values of the Simulation tab (not while the simulation runs);
up: N selects UP N instead of a Folge; answer (also without keys = only read): programType ("folge" |
"up"), number, loops, sps – the current values of the tab (the AI agent reads the Folge of
the station this way). sps is applied first, then folge / up / loops (since 2026-10-25;
before, "sps":false together with loops restored the previous number of loops, e.g. 30 → 3) |
| fast_run | program ("folge125" or "up42"), loops | like the Fast Run buttons, always without the SPS |
| run | folge or up, loops, speed, sps | Run on all robots; up: N runs UP N instead of a Folge;
with the SPS on the command answers the error Not started: ... (fields spsFolge = the Folgen of the SPS
program, spsCycles; the answer also has sps true) when folge / loops differ from the SPS program
(as before) or when the number in the Program field differs from the Folge of the SPS program – also
without folge, e.g. after an earlier set; the error has the text of the question of the button
Run on all robots (without Continue / Cancel); run again with the Folge of the SPS program or
"sps":false;
asynchronous. Missing work zones are calculated first. sps before loops / folge as in set.
The end of the run opens no windows (since 2026-10-25) – texts in status.lastRunMessages, the risks in
run_data (collisionCheck, areaConflicts) |
| stop | stops all robots; the end of a run stopped through the API opens no windows, also when the run was started in the GUI (since 2026-10-25) | |
| sim_options | without keys: read; keys: see below | options of the Simulation tab like in the GUI; locked while the simulation runs (error). Answer: all values and locked |
| sim_action | action: "pause", "resume", "quitt", "check_interlock_map" | Pause / Resume of the clock of the station, Continue (Quitt), Check interlock map (the table opens in a window, read it with the ui_* commands) |
| live_check | on, cell, capsule, range, warn, contact, stopNear, ignoreStartContacts, thread, parallel, grid, stepMs; export, format, anonymize, exportCsv, window, show | Live 3D collision check (works from the next start); contact (0..50 mm, default 5) – closest points at most this far apart = collision (case key 3D|...), farther with a common cell or below warn (default 30 mm, 0 = off) = proximity (key 3Dnear|..., warning, no pause); answer: the values and closest – the closest approach of every pair: robot, where, part, partner, partnerWhere, partnerPart, distance, t, rangeMm, joints, partnerJoints – and stats of the last run (checks, checkMsP50 / P95, gapAvgS / gapMaxS, nearMoveMaxMm / nearMoveP95Mm, clockWaitS, recommendedStepMs, maxSpeedWithoutWait). Since 2026-10-30: stopNear (true / false) – pause also at a proximity below warn; in closest also contacts (checks with contact) and, for pairs in contact, overlap (largest overlap of the models, mm), overlapT, overlapWhere, overlapPartnerWhere; distance -1 = only common cells, not measured. Closest approaches: export (file) with format pdf / html / csv (default: from the extension) and anonymize (robots R1..Rn), exportCsv (file, CSV), window (true – open the window). stopNear pauses once per approach of a pair (again after the models moved apart by more than warn + one cell). ignoreStartContacts (true / false, default true) – pairs whose models overlap already at the first check (start position) are not a collision until they are apart; in closest such a pair has startContact true and startOverlap (mm); every pair has point [x, y, z] (middle of the closest points). show: {robot, partner, what: 3d | robot | partner} – like a double click in the window: 3d = both robots to the moment of the closest approach and the 3D view to the place (simulation paused or stopped), robot / partner = program in the editor at the point. overlap is an approximation from the grid of the check (extent of the common cells, accuracy one cell), not the depth of a solid. License Collision 3D: without it stopNear / ignoreStartContacts / export / window / show answer "License '...' not found" |
| view | robotNamesOnFloor, robotLabels, axes, perspective, recordedPath, nullPoint, grid, consolesAndLinearUnits, simulationTcp, collisionPlaces, collisionPlaceLabels, whiteBackground, pointLabels, pointFrames, programPaths (true / false); fitAll, viewAll (true); standardView ("default" | "top" | "bottom" | "left" | "right" | "front" | "back"), coordinateSystemSize (60..400 px), allRobotsPath ({kind: "folge" | "up", number, withSubprograms} or false); zoom (factor 0.01..100), target ([x, y, z] mm), signalLabelSize (30..300 %, 100 = default), collisionPlaceColor3D, collisionPlaceColorZone, collisionPlaceColorProximity ("#rrggbb"), orbit ([yawDeg, pitchDeg]) | also the context menu of the 3D view:
point labels, show / hide the paths of the tab Programs, size of the coordinate system, the path of one Folge / UP for
all robots (false = hide it); pointFrames like Show point frames (since 2026-10-25, off by default,
kept in the settings): a coordinate frame (X red, Y green, Z blue, 100 mm) at every point of every shown program path
in the orientation of the point, nothing without a shown path; the answer always contains pointFrames;
programPaths like Show paths / Hide all paths: since 2026-10-25
true shows the path and the points of the program of every robot – during and after a run the
program of the run (with the called UPs), without a run the program selected for the robot (before: only the program
selected in the tree of the current robot); when all robots have the same program (e.g. Folge 81) the set is saved in
the simulation file like allRobotsPath (Show Folge path for all robots); false = hide all
paths (unchanged); standardView like Navigation > Standard View; switches of the menu
View (and white background, Fit All / View All): names of the robots on the floor, labels over the robots, axes,
perspective, recorded path, null point, grid, consoles and linear units, TCP of the tool in the simulation
(simulationTcp: since 2026-10-25 only the TCP frame of the tool, from the axis values of the drawn model; the
former frame of the program point / target is removed);
collisionPlaces like View > Show the places of collisions (spheres in the scene: red = contact of the 3D
models of the Live 3D check, yellow = proximity of the 3D models without contact, violet = collision risk from the
work zones, label with the robots and the time; they stay
until the next run, see Places of collisions);
collisionPlaceLabels like View > Show the labels of the collision places (false = only the spheres,
without the texts above them; kept in the settings, default true);
collisionPlaceColor3D / collisionPlaceColorZone / collisionPlaceColorProximity like View >
Colors of the collision places... (color of the spheres as "#rrggbb": 3D contact, default #ff0000;
work zones, default #e000e0; 3D proximity, default #ffc000; the answer always contains all three colors);
signalLabelSize like View > Signal label size... (size of the signal descriptions along the lines of
the interlock / collision map, the answer contains signalLabelSize); without keys:
read (also without the license API / CLI); zoom: > 1 closer, < 1 farther (like the mouse wheel),
target: the center of the view in mm (like panning) – to frame a region of the cell;
orbit [yawDeg, pitchDeg] (since 2026-10-26) rotates the camera around its target relative to the
current view – yaw about the vertical scene axis Z, pitch about the horizontal camera axis – like a mouse
drag with the rotate button (the answer contains the camera as usual; for the mouse drag itself see
view_drag). Order of the camera
keys in one command: first standardView, then fitAll / viewAll, then target and zoom
(so {"standardView":"default","target":p,"zoom":6} keeps the target; before 2026-10-25 standardView
came last and fitted the view to the whole scene). Answer: the state of
every switch and always camera {"target":[x,y,z],"scale":s,"distance":d} after all changes of the
command: target [mm] the center of the view, scale the height of the view at the target [mm],
distance = scale / (2·tan 22.5°) the distance of the camera in the perspective (angle of view 45°;
in the orthographic view without effect on the image), e.g.
{"cmd":"view","target":[2500,-1200,800],"zoom":2}. The 3D view is also a control of the UI commands
(type view3d, see below) |
| scene_shot | file (path of the PNG file) | image of the 3D scene only (OpenGL, with
the labels and decorations, like the scene image in the reports) as a PNG file; reading, no license needed (like
ui_shot). Answer: {"ok":true,"file":"...","bytes":n}; error 3D view not ready or
cannot write. Frame the region first with view (standardView, target, zoom) |
| view_drag | from, to ([x, y], fraction 0..1 of the view window), steps (default 60, 2..5000), intervalMs (default 16), button ("left" = rotate | "middle" | "right"), ctrl, shift | injects a mouse drag into
the 3D view window (since 2026-10-26; only the variant without the JT reader), the same mouse events as from the user –
for measuring the smoothness of rotating and panning. Answer: {"events":n,"pressMs":..,"moveMsAvg":..,"moveMsMax":..,"releaseMs":..,"wallMs":..}
(time of handling of the mouse events in the program, in ms). Error: 3D view window not found, or from, to missing.
GUI: the same drag with the mouse in the 3D view |
| memory_trim | returns the heap memory to the system (_heapmin,
HeapCompact, trim of the working set); diagnostic command for memory tests (e.g. memory after a new scene).
Answer: {before, after, heaps, heapWalk} – before / after are the same objects as
memory in status; heapWalk lists per process heap busyMB, freeMB (free bytes inside
the heap segments = fragmentation), committedRegionsMB, blocks, largestFreeMB and histogram
(live blocks by size: <64 B, <256 B, <1 KB, <4 KB, <64 KB, <1 MB, ≥1 MB as [count, MB]). Reading | |
| report | file, html, pdf, xlsx, shot, ganttAll, ganttRange, rangeFrom, rangeTo, ganttPrAct, compareFile | report of the times like Report...; always also the data of the run *.rcsrun.json; the API never opens the report in a browser |
| signal_timeline | from, to, signals, select, add, remove, record, why + robot, showAt, export, anonymize, window, data | Signals timeline of the last station run (license Simulation). from / to [s] – time window (default the whole run); signals ["robot|E80", ...] – only these (default the selection; empty selection = all signals that changed); select – new selection, add / remove – change it (saved in the simulation file); record – record in every station run; why (time [s]) with robot – text why the robot waits there; showAt (time [s]) – robots in 3D at that time (simulation paused or stopped); export .csv / .pdf / .html (+ anonymize R1..Rn); window true – window; data false – only the summary. Answer: duration, recording, samples, robots [{robot, states [{t0, t1, state, where}]}], signals [{robot, signal, at_from, changes [[t, value], ...]}], available, selection, record, why. Without changes reading (also without the license API / CLI). All parameters with defaults: below. |
| cycle_reserve | action (status, analyze, test, cancel, clear), share, minOverride, minGain, use, export, anonymize, window | Cycle time reserve (license 146 Motion optimization): analyze – motions after which the robot waits anyway in the last station run and the proposed override; test – the next station run drives the used motions with this override (programs unchanged), then the cycle time is compared (lastTest: takt, baseTakt, difference, ok, robots, unticked – proposals of robots that became slower than the takt, unticked automatically); cancel / clear; share / minOverride / minGain [%] – the fields of the window; use [{robot, point, use, override}] – change a proposal; export .pdf / .html / .csv. Answer: proposals [{robot, point, motion, waitAfter, waitKind (il / warte / fs / end), override, newMotion, energy, use}], baseTakt, baseCycles, energyIndicator, testPending, lastTest, controllers. status without changes is reading. All parameters with defaults: below. |
| report_open | open (true / false) | option Open a
saved report (HTML, PDF) in the default program (Plugin settings > Simulation, default on) for the times
report, the Robustness test report and the collision risk report; off = the files are only saved – recommended
when an AI agent or a script makes the reports. Without open: read (also without the license API / CLI); setting
needs the license API / CLI. Answer: {"ok":true,"open":false} |
| model_converter | path (string, "" = automatic) | option
Model converter (JT to glTF) (Plugin settings > Simulation):
path of modelconv.exe, an independent program (GNU GPL v3) that converts files in the JT™ data format into
glTF 2.0. path "" = automatic (<program folder>/RuntimeTools/modelconv/modelconv.exe, set by itself
when the installer installed the converter). Without path: read. Answer:
{"ok":true,"path":"...","default":"...","found":true} – path empty = no converter,
default = the automatic path, found = the converter file exists. The simulator uses it at the load
(model_cache). Needs the license API / CLI. JT is a trademark of Siemens Industry
Software Inc. |
| model_cache | convert, mode, folder, estimate, file | (since 2026-10-25)
JT models as glTF: convert "auto" | "ask" | "never" (setting JT models:
use converted glTF models), mode "nextToJt" | "folder" and folder ("" = %LOCALAPPDATA%/DrAmaT/RCS/Models;
setting Save converted models); without them: read (also without the license API / CLI). estimate with
file (simulation file, Process Simulate study .xml or a .jt file): the JT models that a load would
convert – nothing is converted. Answer: convert, mode, folder, defaultFolder,
secondsPerMB (seconds per MB of one modelconv process), secondsPerFile (overhead per file),
parallel (processes at the same time) – both factors learn from the last conversions on this computer –,
kinematicModels (true = robots and mechanisms also from glTF: variant without the JT reader), converter,
lastConversion, fileType and estimate {toConvert, reused, megabytes, seconds, models,
convertedModels, unreadable [{jt, error}], text}; for a Process Simulate study (.xml) next to estimate
(tools on the robots) also estimateAll (same fields: all components of the study with a 3D model, as
File > Open with all objects), e.g.
{"cmd":"model_cache","estimate":true,"file":"D:/sim/sim_jt.xml"} |
| package_save | file, includeRobotData (true), includeSource (true), dryRun (false) | (since 2026-10-25) like File > Save simulation package (*.rcsz)...: one self-contained ZIP file with the simulation, the SPS program, the loaded cell components and the tools of the robots as converted models (.glb) with their positions and the robot data needed for the simulation; the study file is never included (includeStudy is ignored). includeSource (default true) also stores the original model files as source only; false makes the package smaller. A package that would point to a file outside of it is refused with the list of the paths. dryRun: true writes nothing and returns estimatedSize {glb, source, robots, total} in MB (uncompressed). Answer: the manifest without the file list (robots with their files, models, notIncluded), file, bytes, megabytes, fileCount |
| package_open | file, convert | (since 2026-10-25) like File > Open simulation package...: extracts the package (once per file, to %LOCALAPPDATA%/DrAmaT/RCS/Packages) and loads its simulation in a new scene like load; answer started, simulation (file in the package folder), folder; then wait with status. The answer comes at once; the package is extracted in a worker thread with the progress window Open simulation package (Cancel stops it; status.extracting is true, status.modal shows the window), then the simulation is loaded. Errors after the answer: status.lastLoadError |
| run_data | file (optional) | the data of the run (as in *.rcsrun.json) in the answer; the run file also has the array waitTimes (the WARTE ZEIT commands, as in wait_times) for a later comparison; robots[].zeitPerCycle = the time of the active WARTE ZEIT commands per cycle of the robot in s (shown in its own colour in the Gantt chart); collisionCheck.conflicts[] has (since 2026-10-25) kind – zone (risk from the work zones), 3d (collision = contact of the 3D models), near (3D proximity without contact) – and for 3D cases distance (closest points, mm), cells and parts |
| wait_times | robot (optional, part of the robot name) | reading, no license needed
(like status), also while the simulation runs: every WARTE ZEIT of the robot
programs – waitTimes [{robot, program, point, command, seconds, condition, line}], count,
secondsTotal, note; e.g. {"cmd":"wait_times","robot":"R03"} |
| zones | programs (["folge81", ...]), mode ("cubes" | "triangles"), grid (mm, a value of the list: 50, 100, 150, 200, 300), radius (mm), withTool, withSubprograms (true / false), calculate (true), clear (false) | Work Zones: checks these programs of all robots and calculates the zones; mode, grid, radius, withTool, withSubprograms like the fields of the group Calculation; calculate: false only sets the fields, clear: true removes the zones from the 3D view (button Clear). Answer: 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 (number of the UP) | tab Auto-Docking: tool change at the docking points, the commands put down the tool (DS abdocken) and take the tool (DS andocken), max. distance of the tool from the flange, Detach all tools from all robots (without the question) / Attach default tools to all robots, run = Tool change on all robots with this UP; refused while a simulation runs; without keys: read |
| sps_program | xml, file (.xml), newFromRobots (true), saveFile (.xml), open (true) | SPS program of the station (tab SPS, SPS editor): sets it from XML or a file (file may also be a simulation file <RcsSimulation> – its element <Sps> is used; without it the error No SPS program in the file), newFromRobots like New from the robots of the cell (without the question), saveFile writes it, open opens the editor window like Edit SPS program... (while a simulation runs only to look at it: live states of the blocks, also the Interlock priority blocks); answer: xml, blocks, check (result of Check before the run), with open also opened and readOnly (true while a simulation runs) |
| 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, default 2)}], clear (true) | request races of interlock zones (two robots request the same zone within window seconds, default 1 s; Plugin settings > Simulation), message = window with the races at the end of a station simulation, lock = keep the order of the robots at a request race during the run (rule "auto" only in the run, setting Race_Lock_Order; the SPS program is not changed); rules = interlock priority like the SPS block Interlock priority (SPS) for the next simulations, also without the SPS (second empty = every partner, mode "window" = priority within a time window: the second robot waits at most window seconds from its own request, then goes and the order changes – only for requests at almost the same moment; "order" = order in every cycle: the second robot always after the first one, also when the first one is late because of other zones – use it for variant B); a rule for a zone replaces the SPS blocks of this zone (variant B, e.g. {"zone": 4, "first": "R06", "second": "R03", "mode": "order"}), clear removes them. Answer: window, message, lock, rules (API), spsRules (blocks of the SPS program), autoRules (rules from the races of the last run with whereFirst, whereSecond, difference), races [{zone, robotA, whereA, robotB, whereB, count, minDifference, maxDifference, lostA, lostB, waited}] of the last run, log (every use of a rule), proposals (the races of the last run, like race_study), pendingBlocks (number of Interlock priority blocks added for races that wait for the decision at save: keep or remove); without keys: read |
| race_study | action ("status" | "add_blocks" | "start" | "stop" | "apply", default "status"), races ([indices], missing = all), cycles (1..20, default 3), choices (["A" | "B" | "none", ...]) | proposal at the end of a simulation with request races and the simulation of both orders (Request races: proposal and simulation of both orders); the simulation never changes the SPS program by itself. status (also without the license API / CLI): proposals [{race, zone, first, whereFirst, second, whereSecond, difference}] (the races of the last simulation with races - a run without races, e.g. Folge 125 to HOME, keeps them), active, run / runs (while active), result, pendingBlocks; add_blocks = button Add protection blocks: blocks with the order of the simulation for the given races, answer added [texts]; start = button Simulate both orders: for every race 2 runs with cycles cycles (A = order of the simulation, B = robots swapped), the SPS program is restored after every run (license Simulation, active SPS program); stop stops it (result of the finished runs); apply = button Add the chosen blocks: one choice per race of the result, answer added. Result: [{race, zone, first, whereFirst, second, whereSecond, difference, A {avg, min, max, cycles, waitTotal, collisionRisks, interrupted, done}, B {...}, recommended ("A" | "B" | "none")}]. Typical flow of an agent: run → wait for the end (status) → race_study status → start {cycles: 3} → wait until active is false → read result → apply {choices: [...]} → save {raceBlocks: "keep"} |
| 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} | the windows State lamp... and Console messages... of the tab Simulation, also during a simulation; without keys: read |
| export | what ("times" | "motionTimes"), file (.csv) | CSV like Export... of the tab Times and of the motion times of the tab Motion; the collision matrix and Check interlocks: collision_matrix and check_interlocks give the data as JSON |
| zones_view | show, overlapOnly, pathColors (true / false), transparency (10..95 %) | group Display of the Work Zones tab: show the work zones, only the shared areas, the program path in interlock colors, transparency; without keys: read (also without the license API / CLI) |
| motion_options | planner (true / false), override (%), ptpRamp (s), pathAcc (mm/s², 0 = from the robot archive), oriVel (°/s), approximation, showPath (true / false), defaults (true) | tab Motion: real motion (motion planner), its parameters (program override, PTP acceleration time, path acceleration, orientation velocity, approximation of the corners), the real path in the 3D view; defaults = button Default values; refused while a simulation runs; without keys: read |
| check_interlocks | findings of Check interlocks as data (severity, code, robot, partner, point, message, suggestion; see What RCS checks) and comments: missing comments above points with a request / release (row, robot, point, interlock, release, comment from the template, note) | |
| robot | robot (part of the name, e.g. "R06"), override (1..100), pause (true / false), axes ([A1..A6, E1]), ms, run ("UP42" | "folge81"), point (1), stop (true), goto ("UP43/P8" | "folge81/P12"), tcp {tool, base}, moveTcp {x, y, z, [a, b, c], tool, base, frame ("base" | "scene")}, rebuildPrograms (true) | override and pause of one robot also during the simulation
of the station (like the SmartPad); run = the program of this robot only (like Run program of the tab
Programs) from the point point (the robot moves there first); stop = stops only this robot; goto =
the robot stands in this point of the program (the point is selected in the tab Programs), the program is not started
– e.g. to check the tool in a weld point (only when the simulation is stopped; answer at); axes
like the sliders of the tab Robot Axis (degrees, E1 in mm; only when the simulation is stopped; ms > 0 =
smooth motion); answer: robot, running, paused, override, axes and tool {id, name, x, y, z, a, b, c} (the tool on
the flange and its mounting position relative to the KUKA flange $FLANGE, like pos of tool_model; missing without a tool), toolKind ("cad" = CAD model of the
real tool, "dummy" = dummy tool - an approximation, "none" = no tool) and toolText (the text of the column
Tool (3D) of the times report, see Report), flange ([x, y, z] mm, the flange position of the
robot in the scene, e.g. as target of view to zoom on the tool), base ([x, y, z] mm, the robot base
– robot root or the carriage of the 7th axis – in the scene), archive (the archive folder of the robot) and
archiveZip (the ZIP file it was extracted from, when there is one). tcp = the TCP position like the group Cartesian (TCP) of the Cartesian jog with tool tool and base base (0 = world / robot root; tool and base data from $config.dat); answer tcp {x, y, z, a, b, c, s, t, tool, base} in that base and tcpScene ([x, y, z] mm, the same TCP in the scene). moveTcp = the robot moves its TCP to x, y, z (without a, b, c the current orientation stays) like the − / + buttons of the Cartesian jog: inverse kinematics with S and T of the current position; frame "base" (default) = x, y, z in the base base, "scene" = x, y, z in the scene (e.g. tcpScene or flange of another robot); only when the simulation is not running; error Position not reachable when the IK has no solution or the axes leave their limits; the answer contains tcp / tcpScene of the new position. rebuildPrograms = like Find all programs of the context menu of the robot (Model Browser): the program tree of the robot is built again from the archive, new and changed Folge / UP files are read (e.g. after writing a copy of a UP into the archive); answer programsRebuilt; not while the robot is moving. E.g. {"cmd":"robot","robot":"R6","tcp":{"tool":1,"base":1}},
{"cmd":"robot","robot":"R5","moveTcp":{"x":2450.5,"y":-310.0,"z":1620.0,"tool":2,"frame":"scene"}},
{"cmd":"robot","robot":"R5","rebuildPrograms":true} |
| tool_model | robot (part of the name), file (.jt, .gltf, .glb, binary .stl, .stp, .step), pos {x, y, z (mm), a, b, c (°)}, fixture (true), id | a tool model from a JT, glTF, STL or STEP file on the flange of a robot (like the robot menu Tool model (JT / STEP / STL / glTF)..., see Tool model from a JT, glTF, STL or STEP file; glTF / STL / STEP in the coordinate system of the JT model, glTF with the colors of the parts, id with the suffix _gltf / _glb / _stl / _stp / _step; a large STEP file can take minutes - use a long timeout): pos = origin of the model relative to the KUKA flange ($FLANGE, KUKA ABC; default 0 = the model is in the flange frame) like the mountLocation of the tool in a Process Simulate study - not the TCP ($TOOL_DATA); the model replaces the tool on the flange and a dummy tool is removed; fixture: true = an additional element on the flange (e.g. tool changer), the tool stays. The model is saved with the simulation (element Docked, attribute jtFile) and the session (attached[].file) and mounted again at the load. Without file and id: only a new position of the tool model already on the robot; id = new position of this model. Not while the simulation runs. Answer: id, robot, tool (true = tool, false = fixture). The same model (the same name, or a name that starts with the other name at an underscore) is never mounted twice on a robot: if it or the tool is already on the robot the command returns an error that names the mounted elements; replace: true replaces it. A robot with a 3D model of its tool has no dummy tool |
| tool_info | robot | the elements mounted on the robot: tool (id, name, slot, file, pos {x, y, z, a, b, c} relative to the KUKA flange in mm / °, visible, source = study | model | package | dummy, dummy) and fixtures[] (the same fields), toolText |
| tool_remove | robot, id or name, all (true), fixtures (true, with all) | removes an element from the robot: a model from a file disappears from the scene, an element of the study stays hidden. With all: true the tool and (fixtures, default true) all fixtures. A removed model is no longer part of the collision checks. Not while the simulation runs |
| tool_hide / tool_show | robot, id | hides or shows a mounted element without removing it; saved with the simulation and the package. A hidden model stays in the collision checks (3D, zones, interlocks); only tool_remove takes it out |
| signals | robot (part of the name or "all"), set ({"A76": 1, "E80": 0}), release (true or ["A76", ...]), always ({"M95": 1 | 0 | -1}), read (["E80", ...]), eval ("E80 & E76") | signals E / A / F / M like the signal menu of the SmartPad and of the window Signals E / A of the robots: set = set by hand (stays until released), release = back to the simulation (true = all signals of the robot set by hand), always = fixed value in the signals file (only M / F; -1 removes it); answer: values {robot: {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) | window Dummy tool of a robot: the given values are saved and the dummy tool is attached (a tool on the flange is detached); remove removes it, allRobots puts the same dummy tool on all robots (without the question); without values: the saved values |
| insert_interlocks | mode ("stop" | "request"), stopText, requestText, releaseText, apply (false), rows ([0, 2, ...]) | Work Zones > Insert interlocks... without the window: the proposals for every entry into a shared area without interlock (answer rows: row, robot, partner, area, changes, note, ok); apply: true writes the checked rows (default the rows with ok) into the programs in the editor - check and save them, then calculate the work zones again; answer also inserted, changedFiles |
| save | file (.xml), cell, robots, jt, docked, dummy, sps (true / false), raceBlocks ("keep" | "remove", default "keep") | Simulation > Save simulation... without the windows: the settings of the simulation always, the parts of the cell layout as given (default: what the scene contains); raceBlocks = what to do with the not confirmed Interlock priority blocks added for request races (on the user's choice or with race_study), when the SPS program is saved (remove removes them from the SPS program, like Save without the blocks, Simulation file). Answer: file, raceBlocks ("none" | "kept" | "removed"), raceBlocksCount |
| zone_steps | robot, program ("folge81") | for every point of the program (with the called UPs) from the work zones: robots met in a shared area (contact), motions without interlock (unprotected), interlocks active in the motion and after the point |
| collision_ignore | key (case of collisionCheck.conflicts), ignore (true / false) – or clear (true), all (true) | collision risks that do not pause the simulation any more (Ignore in the window); clear empties the list (Ignore none), all ignores every case of the current simulation (Ignore all); answer: ignored keys |
| collision_case | key (any key of a case, e.g. from run_data or robust_test risks), action ("points" | "editor") | the buttons of a row of the collision risk window: points = both robots to their points (only when the simulation is stopped or paused; in the pause they move smoothly and Continue moves them back; for a contact of the 3D models (Live 3D) both robots move to their axes at the first place of contact of the row (a 3D case keeps up to 4 places more than 400 mm apart, each with its own sphere, time and axes); a repeated call with the same key moves to the next place of the row (after the last one again the first; the key of one contact shows exactly this contact), the red sphere with the same time lies on the touching parts; for a work-zone case to the points of the programs, where the 3D models are checked once in this pose: touching = orange sphere and a console warning, otherwise the closest distance; this result comes about 0.2–6 s later in the console), editor = both programs in the editor at the points; the answer contains point ([x, y, z] mm, the place of the collision – the red sphere – in the scene, when the case has one), e.g. as target of view for a screenshot of the place, place / places (3D rows: the shown place and the number of places, like 2/6 on the button) and shown (the text of the blue line below the table: what the 3D view shows) |
| collision_report | file (.pdf or .html), view (true / false, default true), test (true / false) | saves the collision cases like the button Save as HTML / PDF of the window: during a robustness test (or test = true) all cases of the test, otherwise the cases of the last simulation; neighbouring points of one place as one case (plugin settings, Collision report) |
| robust_test | action, see below | Robustness test (Robustness test); every answer contains the status: active, paused, finished, step, totalCycles, collisionRisks, minutes, report, remainingMinutes and estimatedEnd (estimated remaining time and end of the test; missing when not known yet) |
| insert_comments | rows (numbers "row" of comments, empty = all), texts (own texts of these rows, optional) | inserts the missing comments of the last check_interlocks into the programs in the editor without saving (inserted, log) |
| collision_matrix | scope ("checked" = programs checked in Work Zones, default; "archive" = whole robot archives) | collision matrix as data: robots with their interlocks (requests, releases, partners, requests without partner), robot pairs (interlocks, state, shared / red m3 when the zones are calculated) and the signal logic errors (robot, point, line, code, message) - no zone calculation needed |
| anon_study | file (result; the key is written next to it as <file>.key.json), check, run (true = include Check interlocks / the last simulation), show (true = show the summary window like the button), texts (true = with the interlock comments and long texts), collisions (true = default; false = without the COLLISION findings in checkInterlocks and without simulation.collisionCheck – for a blind test of the AI; GUI: question when saving) | anonymised study for an AI assistant: robots R#, programs F#/U#, points P#, program steps with interlock events and contacts, shared volumes, Check interlocks and simulation – without names, coordinates or program text; answer with the files, statistics and leaks (parts of real names found in the file, must be empty). Needs calculated work zones |
| ai_import | text (answer of the AI with {"changes": [...]}) or file or changes (array), key (key file, default: the last exported one), apply (true = apply the rows with status ok), rows (indices to apply), check3d (true = after applying: work zones from the triangles of the 3D models, answer check3d with ok and the entries without interlock) | proposals of the AI agent translated to the robots and programs of the cell: rows with robot, program, point, action, changes in the program, note and status (ok / check / error); with apply: backup of the programs, changes saved, backupDir and log. Then run and ai_compare |
| ai_compare | key (optional) | station cycle, cycle and waiting time of every robot before the changes of the AI and in the last simulation (cycleDelta), expected values of the AI |
| ai_keep | keep the applied changes of the AI as the new starting point (next round: new anon_study, new key) | |
| ai_restore | original programs from the backup (editor windows of these programs are closed without saving) | |
| ai_chat | message, newChat (true), stop (true), last (20), anonymous (true / false), warmUp (true / false) | the AI Agent
window (license API / CLI): message = a message like from the text field (while the agent works it waits in
the queue; error without API key or license); message "/reload" loads the knowledge files of the
agent again without a request to the model (like Refresh knowledge in the settings, the conversation stays; the
reasoning blocks of earlier answers are removed from the history; the transcript gets an entry with the summary);
message "/status", "/run folge=125 loops=1", "/view {json}" … = a
direct command run at once without the model (also while the agent works; the
answer is shown in the chat window, only an error goes into the transcript – from a script call the command
directly; /ai_chat is rejected); newChat = New chat; stop = Stop; last = number of the last entries
of the chat in the answer (0 = all); anonymous = the anonymous mode on / off
(like /anonymous on | off and the check box in the settings; a change starts a new chat). When
consentPending is true, the first message was held by the question send the real data? – answer with
message "yes" (real data), "anon" (anonymous mode on) or "no" (nothing is
sent). warmUp = the setting Load the AI knowledge on startup (warm-up in the background). Answer: busy (the agent works), anonymous (mode on), warmUp (the setting), connectionConfigured (a connection to the model is set: Claude Code found / API key / OpenAI key and address), consentPending (the question YES / ANON /
NO waits), transcript [{who (user | agent | tool | error | question), text, time}] |
| agents_md | auto (true / false), update (true), get (true), section (auto | notes), notes ("text"), file ("path") | the
briefing file AGENTS.md of the station for the AI agent (see AGENTS.md). auto = the menu item
Simulation > Update AGENTS.md automatically (setting RCS_Group/AgentsMd_Auto, default off; status shows
agentsMdAuto); update = Update AGENTS.md now (works also with the option off and during a run – then a light
update); get = read the file (needs no API license 248); section auto | notes = which block to
return or write; notes = replaces the NOTES block (the block between RCS:NOTES BEGIN and RCS:NOTES END is never
touched by an update); file = writes a copy of the text to this path (error when there is no AGENTS.md yet). The command supports the
anonymous mode like the other commands. Answer: auto, file, exists, chars, updatedAt, text,
copy |
sim_options – options of the Simulation tab
Without keys the command reads the options. With keys it sets them like a click in the GUI (also stored in the settings). While the simulation runs the options are locked and setting them gives an error. The answer always contains all values and locked (true while the simulation runs).
| Key | Value | Option in the GUI |
|---|---|---|
| stopAtCollisionRisk | true / false | Stop the simulation at a collision risk |
| autoResume | 0..600 (s) | continue after N s (0 = wait for Continue) – after a pause at a collision risk the simulation goes on by itself; also during the run (2026-10-31) |
| 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 (next to 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 |
| ignoreMotionConditions | true / false | Ignore motion conditions (FB PSPS / FB ONL) – the robots do not wait for FB PSPS / FB ONL (test of the motions without partners); saved in the simulation file |
| freeRun | true / false | Free run - ignore all conditions (SPS, interlocks, WARTE BIS, FB, collisions) – all robots run without waiting for anything (no SPS program, no interlocks, no common start, WARTE BIS and FB PSPS / FB ONL pass, no stop at a collision risk); saved in the simulation file |
| 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 | number (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 floor, 1 above, 2 base | position of the collision map |
| upCalls | "none", "onlyEin", "all" | UP calls: Do not execute / Only unconditional calls / All calls |
| syncWaits | text, e.g. "E23; E80 & E76" | Stop at WARTE BIS: |
| redrawMs | 16, 50, 100, 250, 1000 | redraw the scene every ... ms (Live 3D options); can also be changed while the simulation runs |
| programRules | [{kind, value, ms, prAct, mode, overlap}] | table Program rules (replaces the whole table). 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":30,"contact":5,"thread":true,"parallel":true,"grid":true,"stepMs":20}'
robust_test – actions
| action | Parameters | What it does |
|---|---|---|
| load | file or plan {...}; services, stops, sps, program (true / false, default true) | loads a plan; the parts choose what is taken from the file (service programs, stops in points, SPS program, program); plan = the plan as a JSON object in the command (format of a plan file, e.g. from the AI agent) – it is written to a temporary file and loaded from there; answer: file (this temporary file) |
| save | file; services, stops, sps, program | saves the plan with these parts |
| options | the keys of a plan file (seed, speed, ignoreCollisions, stopOnCollision, only3d, allUps, repeat, baseline, baselineCycles, timeLimitMin, maxCycles, recoveryTolerance, report, startAt, generator {...}, missingTest {...} or false), autoSave (true / false) | sets the options of the tab without a plan file - only the given keys change (generator and missingTest key by key); a plan source is needed: a loaded plan, generator or missingTest. Answer: plan (all options after the change) |
| find_services | fills the table of the service programs from the Folge of the robots; answer: services | |
| service | robot, up, everyCycle | adds or changes a row of the service programs; answer: services |
| stop_point | robot, point ("UP42/P29" or "P12"), sec (20), everyCycle (1) – or clear (true), remove (row 0..n-1) | adds a stop in a point, removes one row (remove, index as in the answer) or empties the table; answer: stops |
| start / resume | starts the test / continues a saved test | |
| pause / continue | pauses / continues the test | |
| stop | stops the test | |
| status | active, paused, finished, round, step, totalCycles, collisionRisks, baselineCycle, seed, stopReason, minutes, report, remainingMinutes and estimatedEnd (estimated remaining time and end of the test; missing when not known yet; after the time limit the rest of the current step, which always runs to its end); in the test of missing interlocks also missing (total, done, collisions); while the test runs also the current step: stepRunning, stepName, stepLoop / stepLoops (loop of the slowest robot / loops of the step), stepMinutes, timeLimitMinutes and timeLimitReached | |
| risks | findings of the whole test so far: robot, where, partner, partnerWhere, count, firstAt, firstStep, kind (zone | 3d | near), distance, parts, png | |
| report | progress: "<folder>" (optional) | writes the report; with progress the report of a saved test from its folder; answer: file |
signal_timeline – parameters
Signals timeline of the last station run (license Simulation). The
recording is made during every station run (Run on all robots) while record is on. All keys are optional;
without record, select, add, remove, showAt, export and window the command
only reads (also without the license API / CLI). A signal is named "robot|signal", e.g.
"<robot>|E80", "<robot>|A41" or "<robot>|Zone5" (zone taken by the
robot). robot, signals, select, add and remove use the real robot names (as in an
answer without anonymize).
| Key | Value | Default | What it does | Option in the GUI |
|---|---|---|---|---|
| from | number [s] | 0 | start of the time window (simulation time) for the answer and the export | shown time window (wheel / drag) |
| to | number [s] | -1 (= end of the run) | end of the time window; a value after the end of the run is the end of the run | shown time window, Whole run |
| signals | ["robot|E80", ...] | the selection | only these signals in the answer and the export; empty selection = all signals that changed in the run | – |
| select | ["robot|E80", ...] | – (unchanged) | new selection of the signals (replaces it, [] = empty); saved in the simulation file | tree of the signals (tick), Clear selection |
| add | ["robot|E80", ...] | – | adds signals to the selection | tick in the tree |
| remove | ["robot|E80", ...] | – | removes signals from the selection | untick in the tree |
| record | true / false | true (unchanged) | record the states and the signals in every station run; saved in the simulation file | record in every station run |
| why | number [s] | – | text why robot waits at this time: state, point, the zone and the robot that holds it since which point, the WARTE BIS / FB PSPS condition, or the robots still working before the Folgenstart (answer why) | click in the timeline, text below the chart |
| robot | robot name | – (needed with why) | robot for why; error why: "robot" missing | – |
| showAt | number [s] | – | all robots in the 3D view to their axes at this time (only when the simulation is paused or stopped); answer shownAt | Robots to the cursor, 3D follows the cursor |
| export | file .csv / .pdf / .html | – | saves the time window from..to: CSV
(one line per change: time_s;robot;signal;value;where, states and signals, semicolon, UTF-8), PDF or HTML
(chart and table of the signal changes, at most 5000 rows); answer export | Save... |
| anonymize | true / false | false | robot names R1..Rn (alphabetical order) in the answer and the export | robot names as R1..Rn |
| window | true / false | false | opens the window Signals timeline | tab Times > Signals timeline... |
| data | true / false | true | false = only the summary, without robots, signals and available | – |
Answer: duration [s] (length of the recording), recording (true while the station runs), samples, from, to, robots [{robot, states [{t0, t1, state, where}]}] – state: motion, process, waits for an interlock zone, WARTE BIS, Warte auf Folgenstart, waits at the end of the loop, waits (condition), not moving; where: program and point –, signals [{robot, signal, at_from (value at from, -1 = not set yet), changes [[t, value], ...]}], available (all recorded signals), selection, record, and when asked why, shownAt, export.
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"signal_timeline","data":false}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"signal_timeline","why":41.5,"robot":"<robot>","data":false}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"signal_timeline","from":30,"to":75,"signals":["<robot>|E80","<robot>|Zone5"],"export":"C:\\temp\\timeline.csv","anonymize":true}'
cycle_reserve – parameters
Cycle time reserve (license 146 Motion optimization). Order of work: a station run (run, best 2 loops or more) → action analyze → action test → the same station run again (it is the control run) → status reads lastTest. When lastTest.ok is false, the proposals of the robots that became slower than the takt of the station are unticked automatically (list lastTest.unticked) – then action test and the run again. status without other keys only reads.
| Key | Value | Default | What it does | Option in the GUI |
|---|---|---|---|---|
| action | status, analyze, test, cancel, clear | status | analyze – proposals from the last station run (error when the simulation runs or no cycle was measured); test – the next station run is the control run with the ticked proposals (error without proposals or while the simulation runs); cancel – no control run; clear – deletes the proposals and the last test | Analyse last run, Test run with these speeds, No test run |
| share | 10..100 [%] | 80 | part of the shortest waiting after the motion (over all cycles) that becomes a slower motion | use of the waiting |
| minOverride | 10..100 [%] | 30 | smallest proposed override | override not below |
| minGain | 1..50 [%] | 5 | a motion is proposed only when it can be at least this much slower | only from |
| use | [{robot, point, use, override}] | – | changes proposals: use true / false (ticked for the control run), override 1..100 [%]; robot and point exactly as in proposals of an answer without anonymize (the real robot name, not R1..Rn) | table: Use (tick), Override [%] (double click) |
| export | file .pdf / .html / .csv | – | report of the proposals and of the last test; CSV:
robot;point;motion_s;wait_after_s;wait_kind;override_pct;new_motion_s;energy_rel;use (semicolon, UTF-8);
answer export | Save report... |
| anonymize | true / false | false | robot names R1..Rn (alphabetical order) in the answer and the report | robot names as R1..Rn |
| window | true / false | false | opens the window Cycle time reserve | tab Times > Cycle time reserve... |
Answer: share, minOverride, minGain, baseTakt [s] (takt of the station in the analysed run, -1 = no analysis), baseCycles {robot: cycle [s]}, testPending (the next station run is the control run), proposals [{robot, point, motion [s], waitAfter [s], waitKind (il = interlock zone, warte = WARTE BIS, fs = Warte auf Folgenstart, end = end of the cycle), override [%], newMotion [s], energy ((override / 100)²), use}], energyIndicator (ticked motions against now, 1 = unchanged), lastTest {takt, baseTakt, difference, ok, robots [{robot, cycle, baseCycle}], unticked [{robot, point}] (only when not ok)}, controllers (text: for which controllers the proposals hold). ok = takt of the control run ≤ baseTakt + max(0.1 s, 0.5 %).
Example (anonymized station): analyze → baseTakt 74.20 s, 5 proposals; control run →
"lastTest":{"takt":74.20,"baseTakt":74.20,"difference":0,"ok":true,...}.
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"cycle_reserve","action":"analyze","share":80,"minOverride":30,"minGain":5}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"cycle_reserve","use":[{"robot":"<robot>","point":"<point from proposals>","use":false}]}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"cycle_reserve","action":"test"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"cycle_reserve","export":"C:\\temp\\cycle_reserve.pdf","anonymize":true}'
Every option of the window (UI commands)
Besides the commands above, every control of the simulator is reachable – also in the dialogs, message boxes, settings and context menus – without screenshots: the answer contains the controls as data (type, label, path tab / group / dock, value, items, rows of tables and trees). The list of all menu actions and controls: Command API - reference. Each control gets a number (id) that stays the same while the control exists; a control can also be given by its label (+ window, path, type; first: true takes the first of several matching controls), a menu action by action (menu path). This is the target in the table below. Changes and clicks are executed right after the answer, so a dialog they open does not block the API: it appears in ui_windows (modal first) and status (modal, uiPending).
| Command | Parameters | What it does |
|---|---|---|
| ui_windows | all | open windows of the simulator (dialogs, message boxes with their text, menus) |
| ui_list | window, filter, hidden, labels, all | controls of the windows; hidden = also on tabs not shown; labels = also texts (QLabel); all = also windows outside the simulator. The 3D view of the main window is in the list as a control of type view3d (objectName view3d, label 3D view); its id is the target of ui_context and ui_key |
| ui_actions | window, hidden | menu and toolbar actions with their path, e.g. Simulation > Load simulation... |
| ui_get | id | label | action | one control with all details (tooltip, all list items) |
| ui_set | target, value, enter; dockHeight, dockWidth (px); scroll | sets a check box, text, number, list item, slider or tab like the user;
scroll (without value) scrolls a text field or list: "top", "bottom", a number 0..1
or "find:text" (first place of the text at the top - also in read-only fields like the chat of the AI agent);
dockHeight / dockWidth with any control inside a docked panel (e.g. the Send button of the AI Agent window):
sets the size of this panel like dragging its edge; answer e.g. {"dock":"AI Agent","dockHeight":665,"dockWidth":1682,"ok":true};
error when the control is not in a docked panel or the panel is floating |
| ui_click | target | action | button, menu action, item of an open context menu |
| 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 | reads or changes tables and trees (check programs in Work Zones, edit program rules, double click a finding) |
| ui_context | target, row, column | opens the context menu of a control or a row; with the id of the 3D view (control view3d) the context menu of the 3D view, the same as a right click in the view (Fit All, white background, places of collisions, size of the coordinate system, Hide / View Only / View All, paths, point labels, point frames, Display, object types) – the items then with ui_click |
| ui_close / ui_key | window, accept / keys, text | closes a window, sends keys; with the id of the
3D view the keys of the view (Qt3D viewer): F Fit All, S fit the selection, 0 / Home default
view, 1..6 standard views, arrows rotate by 15° (with Shift: pan),
+ / - and PgUp / PgDn zoom, Esc ends a forced operation or clears the selection;
no key for the perspective (only the menu View or view perspective) and no W. Keys typed
in the component tree do not move the view. Note: in the variant with the JT reader ui_key on view3d
does not change the view (black box test 2026-10-25) |
| ui_file | answer, answers, clear | answers for the next file dialogs (the dialog is not shown); empty = Cancel. Give them only right before the command that opens the file dialog (e.g. ui_click on a menu item). A command that takes the file or folder from its parameters (file, folder: package_save, report, export, save, load, ...) opens no file dialog; since 2026-10-25 the answers still waiting after such a command are discarded (answer uiFileDiscarded: number, warning in the console) – before, they stayed in the queue (pending) and answered a later, unrelated file dialog |
| ui_shot | target, file, parent | image of a window or control (only when a person should see it); parent: n levels up from the control (a group, or the whole content of a scrolled tab, also the part outside the visible area) |
| settings_get / settings_set | filter / key, value, remove; group (default RCS_Group) | settings of the simulator (RCS_Group), e.g. the macros prepared in the background or the program rules |
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_click","action":"Settings > Configure..."}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_set","label":"Macros prepared in the background","value":"20, 45, 46, 47, 50, 57"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_click","window":"settings","label":"OK"}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"ui_set","label":"Send","dockHeight":665}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"report_open","open":false}'
template\RCS\AIAgent\rcs_api.ps1 '{"cmd":"model_converter"}'
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 > Load simulation..."}'
Starting the simulator without a click (editor API)
When Settings > AI Agent > Command API of the editor is switched on (or with DRES_API=1) DReS itself listens on \\.\pipe\DReS_API (client
AIAgent\dres_api.ps1): license tells whether the license check runs, whether the first reading of the key
has finished (ready) and which licenses are available; with "details": true it also gives every
license with its type and validity, the key and the knowledge packs of the AI agents (fields: Editor API,
window: Help > License info); plugins lists the plugins of the menus;
run_plugin {name, wait} opens a plugin as soon as the license key has been read (wait = seconds to wait for
the license) and the editor is not busy – while the editor restores the session after the start or opens many files
(Open all recent files), the plugin start is delayed and the answer has the field waitingFor (what the editor is
doing); open {file, line} opens a
file; status shows the active file, an open dialog and busy (true while the editor restores the session or
opens files, then busyReason tells what it does; currentSession and, while a session is restored,
session – see session) – before loading a station in the simulator check status
until busy is false instead of waiting a fixed time (while the editor is busy, load of the simulator reports
that the robot configurations are not read now; load the station again when the editor is ready); settings_get / settings_set read and change the settings of the editor and the plugins, e.g. RCS_Group/Automation_Api = true before run_plugin, so that the agent switches on the API of the simulator itself.
plugin_cmd {plugin, command, ...} calls an API command of a plugin of the editor; the other fields are the parameters of the command. Today: Robot Cell Simulator Lite with the commands lite_open, lite_archive, lite_calculate, lite_status, lite_matrix, lite_check, lite_report and lite_image (parameters and results: Robot Cell Simulator Lite - API). The plugin needs its own license (Lite: Robot Cell Simulator basic, 140) and the license API / CLI (248).
Settings > Configure > AI Agent, tab Command API (local path hidden)
AIAgent\dres_api.ps1 '{"cmd":"license"}'
AIAgent\dres_api.ps1 '{"cmd":"license","details":true}'
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"}'
AIAgent\dres_api.ps1 '{"cmd":"plugin_cmd","plugin":"Robot Cell Simulator Lite","command":"lite_status"}'
AIAgent\dres_api.ps1 -StartNewSession -SessionName "Station 010"
-StartNewSession [-SessionName "Name"] starts the editor with a new empty session (without a name or with
the given name) instead of the last one and waits until it is ready – details: session.
Client script
template\RCS\AIAgent\rcs_api.ps1 (PowerShell) sends one command and prints the answer; -WaitIdle waits until the
simulator is idle (no loading, no preparing, no 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/variant_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"}'
Example: variant of a station
Load the original station, run Folge 81 ten times with the SPS program of the station, save the report; load the changed copy of the programs, run it the same way and save a report with the comparison to the original (compareFile = the .rcsrun.json of the first report). The same sequence for several variants gives a table of cycle times without a single click. The speed of the simulation does not change the measured times (400 % gives the same cycle times as 100 %).
The data of the run (run_data) contain the cycle time of the station, the robot that sets it, the
waiting for interlocks per robot and point (zoneWaits), how long each zone is held (zoneHolds) and who holds
a zone since when in the first cycle (firstCycleWaits), wait chains (waitChains: the partner holding the zone
waits itself for another zone or a condition) and requests of the same zone at nearly the same moment (requestRaces with minDt / maxDt, the time window raceWindow, the rules of the interlock priority raceRules and their use raceRuleLog, the rules from races raceAutoRules)
– enough to find the bottleneck and the robot it waits for. After a run, check_interlocks also returns the codes
CHAIN and RACE, and LONG as a warning when a partner waited for the zone.