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. A copied test run keeps the source's driver and knowledge (`driver`): check them for another vehicle.

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.

Keys only in a, only in b, and those whose values differ ([a, b]), e.g. two vehicles or a test run and its 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. ok: at least one mode is ready (see ready); all_checks_passed: everything, the MATLAB session included.

Let IPGDriver learn the car (basic) or the car on this circuit (race), and save the knowledge. It takes minutes (basic about 2 standalone, 5 to 20 with MATLAB; race as long as the test run allows): run it only when the car changed noticeably, the race driver lacks knowledge, or the user asks, and tell the user the duration first. Start returns at once; then 'wait' until state is done/failed.

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. Driver parameters belong in the driver template (kind 'driver', 'Template/<name>'), which other test runs share: say which changed.

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

A section of this server's guide (the same text as the resource carmaker://guide).

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); the answer lists signal_names. Requires an idle simulation. The result file (.erg) holds CarMaker's quantities, this the Simulink side. To see whether a signal is logged, run with save_logs=true and read signal_names.

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. Needs the MATLAB session; without it use cm_standalone_launch(movie=true).

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. Needs the MATLAB session's IPGMovie (cm_movie_open); a standalone IPGMovie (movie=true) has no pictures.

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, 300 at a time: filter by keys, prefix or search, or page with offset. For a test run first `driver` (its template or 'TestRun', knowledge, main limits) and, also for a vehicle, `standalone`: false names the vehicle's Simulink parts (runs need the MATLAB session).

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

Interpolated times at which a quantity crosses each value, and the time between the first crossings of consecutive values (lap or sector times from distance gates); with `at`, the values of other quantities there (the speed at 75 m).

Write quantities of a result file at full resolution (no thinning) to a MAT file (one double variable per quantity, dots as underscores, plus quantity_names and units) or a CSV file (header 'Time [s],Car.v [m/s],...': name and unit), in any folder of this computer. Never overwrites.

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

Plot quantities of result files in IPGControl, IPG's plotting program; needs no MATLAB. The window stays open for the user (the next plot replaces it) and a picture comes back as an image. This server has no MATLAB evaluation: for MATLAB figures use a MATLAB server, or cm_results_export.

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, or open its IPGMovie. A study with movie=true runs on one instance: cm_standalone_status shows it.

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. start=false only opens CarMaker (and IPGMovie).

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.

The MATLAB session (CarMaker for Simulink) only; standalone work needs none of it (cm_doctor). Simulation state (sim_status; sim_status_code is CarMaker's raw value, -2 idle, 0 or more running), matlab_simstate (Simulink's model state: 'terminated' is normal when idle), active 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).

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.