CarMaker

Recorded changes (file keys, workspace variables, model parameters, GUI settings) with old and new values.

Copy a project file to a new name in the same kind's folder. Never overwrites.

Write a new project file, for example a tyre property file that differs from an existing one. Never overwrites; the file is logged and cm_revert_all moves it to the trash folder. To change a file that exists use cm_edit, to copy one cm_clone.

Check the setup: CarMaker install, Python version, MATLAB release and engine, shared MATLAB session, GUI, project folder. Each failed check comes with its fix.

Release all quantities from DVA control.

Overwrite a quantity during a run via Direct Variable Access.

Change keys in a project file in place (backed up first, logged; only the edited lines change). Requires an idle simulation; load the test run again afterwards.

Value of a variable or field. MATLAB objects are described, not converted: read their fields.

Names of project data files of one kind (test runs, vehicles, drivers, tyres...).

Variables (name, class, size) of the MATLAB base workspace or of a Simulink model's workspace. Controller parameters usually live in the model workspace.

Current values of CarMaker quantities during a run (or the last values after it).

Load a test run into the CarMaker GUI. Requires an idle simulation. Find names with cm_list('testrun').

Last lines of the newest CarMaker session log of the project. Use it when a run aborts or does not start.

get_param on a loaded Simulink model or block.

After a CarMaker for Simulink run: write what Simulink logged (signals marked for logging and To Workspace blocks) to a MAT file, with the base workspace and the model workspace as one struct each (variables: signals, base_workspace, model_workspace, info). Requires an idle simulation. The result file (.erg) holds CarMaker's quantities; this holds the Simulink side.

Save a loaded Simulink model. The file must be inside the project; it is backed up first.

set_param on a loaded Simulink model or block. Logged; cm_revert_all restores the old value.

Open IPGMovie, CarMaker's 3D animation window (or take over one that is open). Open it BEFORE a run: it records a run only while it is open, and cm_movie_snapshot can then show any moment of it.

A picture of IPGMovie's 3D view, returned as an image. After a run it shows any moment of the last run (time_s), provided IPGMovie was open during that run. During a run, without time_s, it shows the IPGMovie window as it is at that moment (in the window's own size). With erg it replays a saved result file, which must hold the vehicle's motion (cm_output_quantities_edit(preset='movie') before that run). Do not pass time_s during a run: that makes IPGMovie stop following the run.

The quantities the next run writes to its result file, per storage rate (names may hold wildcards), with the sample times. movie_replay says whether such a result file can be replayed in IPGMovie. What a finished result file holds: cm_results_summary(erg, search='*').

Add quantities to, or remove them from, the project's output-quantities file (backed up first, logged, restored by cm_revert_all). Applies from the next start. Requires an idle simulation. Find names with cm_live (it reads any quantity) or in another result file.

Let GUI pop-ups raised by this server's commands answer themselves with their DEFAULT choice, so that a question such as 'Vehicle not saved. All changes will be lost. OK to continue?' cannot block a run. The default answer there discards the unsaved changes. Read what was answered with cm_popups. Stays until set back, cm_revert_all or a GUI restart.

Pop-up messages the CarMaker GUI raised for this server's commands (type info/warn/err/question, text, index of the answer given) and the current pop-up timeout. Also the "Internal Debugger" dialog that the GUI or IPGMovie shows after an error of its own (type 'internal error', with the program and the call stack): it is read and then closed. Reading empties the GUI's buffer (it keeps five). cm_load_testrun, cm_start_sim and cm_wait_end already return new ones as 'popups'.

Key / value pairs of a CarMaker infofile. Large files are truncated: filter by keys or prefix.

Restore project files from the backups of an earlier session. Files only.

Newest .erg result files under the project's SimOutput folder, CM_RESULT_DIRS and the folders this session's runs wrote to.

Time series from a result file, decimated to at most max_points samples.

First / last / min / max / mean and unit of quantities in a result file, plus rows and duration.

Undo every change made in this server session: workspace values and model parameters in reverse order, backed-up files put back (created files go to a trash folder), GUI settings restored.

Bring up a CarMaker for Simulink session as far as it is missing: start MATLAB (visible, in the project's src_cm4sl folder, engine shared), run cmenv, open the Simulink model and open the CarMaker GUI. Nothing is restarted or closed. Returns ready=true, or ready=false with what it is waiting for: call again until ready. Without a model it opens none and lists models_loaded and models_found to choose from. Many projects need their own setup script before the model compiles: if init_scripts_found lists one, pass it as init.

Set a variable or field. The old value is logged and cm_revert_all restores it. Model-workspace changes live in memory until cm_model_save. Requires an idle simulation. overruled_by in the answer: the model has a variable of that name in its own workspace and uses that one, so set it there.

Attach to a CarMaker simulation program that is already running, for example one started from a CarMaker Office window.

Disconnect; for instances this server launched, also stop the CarMaker process.

Start, pause, resume or stop the simulation of a standalone instance.

Overwrite a quantity in a running standalone simulation (Direct Variable Access).

Start a NEW independent CarMaker simulation program (not connected to MATLAB) and run a test run on it. Only for test runs whose vehicle does not need a Simulink controller. Results go to the project's SimOutput; see cm_standalone_results.

Result .erg files of the instance's run (read them with cm_results_summary / cm_results_read).

CarMaker simulation programs running on this machine (pid, description, whether this server manages it). A CarMaker Office window you opened shows up once its application is started.

State of a standalone instance plus live values.

Wait until the instance's simulation has finished. finished=true: simulation time and distance, error flag and log errors. finished=false: call again to keep waiting.

Start the loaded test run. Returns once it is running; fails at once, with Simulink's error, if the model does not compile. Then call cm_wait_end until it reports finished.

Simulation state, active Simulink model, project directory, last end status, the GUI's storage mode (save_mode) and gui_all_saved (false: the GUI holds unsaved data and will ask before a load; true is no guarantee, an edit in an open editor window is not counted).

Stop the running simulation. With wait_s > 0 it returns what cm_wait_end returns.

Stop the run in progress, skip the remaining ones and restore the changed workspace values. Only cancel a study this conversation started.

Run one test run several times with different parameter values, one after another, in the background. Returns a study id at once; wait with cm_study_wait. Nothing is written to project files. The answer names values that will change nothing: keys_not_found, workspace_not_found and workspace_overruled (the model has the variable in its own workspace: use scope=<model>).

State of a study (running, done, cancelled, failed) and one row per finished run, which also maps every label to its result file. To wait for progress use cm_study_wait.

Wait until another run of the study has finished or the study has ended, at most timeout_s, and return the compact table (new_rows says how many runs finished meanwhile). Call it again while state is 'running'. Use this for studies instead of cm_wait_end.

Wait until the simulation is idle again. finished=true: end status, simulation time and distance, result_file, new log errors and pop-ups. finished=false: current state and live values; call again to keep waiting.