Adams 2021.0.2 Adams Controls User Guide

Adams 2021.0.
2
Adams Controls User's Guide
Corporate Europe, Middle East, Africa
MSC Software Corporation MSC Software GmbH
4675 MacArthur Court, Suite 900 Am Moosfeld 13
Newport Beach, CA 92660 81829 Munich, Germany
Telephone: (714) 540-8900 Telephone: (49) 89 431 98 70
Toll Free Number: 1 855 672 7638 Email: europe@mscsoftware.com
Email: americas.contact@mscsoftware.com
Japan Asia-Pacific
MSC Software Japan Ltd. MSC Software (S) Pte. Ltd.
KANDA SQUARE 16F 100 Beach Road
2-2-1 Kanda Nishikicho, Chiyoda-ku #16-05 Shaw Tower
Tokyo 101-0054, Japan Singapore 189702
Telephone: (81)(3) 6275 0870 Telephone: 65-6272-0082
Email: MSCJ.Market@mscsoftware.com Email: APAC.Contact@mscsoftware.com
Worldwide Web
www.mscsoftware.com
Support
http://www.mscsoftware.com/Contents/Services/Technical-Support/Contact-Technical-Support.aspx
Disclaimer
This documentation, as well as the software described in it, is furnished under license and may be used only in accordance with the
terms of such license.
MSC Software Corporation reserves the right to make changes in specifications and other information contained in this document
without prior notice.
The concepts, methods, and examples presented in this text are for illustrative and educational purposes only, and are not intended
to be exhaustive or to apply to any particular engineering problem or design. MSC Software Corporation assumes no liability or
responsibility to any person or company for direct or indirect damages resulting from the use of any information contained herein.
User Documentation: Copyright © 2021 MSC Software Corporation. Printed in U.S.A. All Rights Reserved.
This notice shall be marked on any reproduction of this documentation, in whole or in part. Any reproduction or distribution of this
document, in whole or in part, without the prior written consent of MSC Software Corporation is prohibited.
This software may contain certain third-party software that is protected by copyright and licensed from MSC Software suppliers.
Additional terms and conditions and/or notices may apply for certain third party software. Such additional third party software terms
and conditions and/or notices may be set forth in documentation and/or at http://www.mscsoftware.com/thirdpartysoftware (or successor
website designated by MSC from time to time). Portions of this software are owned by Siemens Product Lifecycle Management, Inc.
© Copyright 2021
The MSC Software logo, MSC, MSC Adams, MD Adams, and Adams are trademarks or registered trademarks of MSC Software
Corporation in the United States and/or other countries. Hexagon and the Hexagon logo are trademarks or registered trademarks of
Hexagon AB and/or its subsidiaries. FLEXlm and FlexNet Publisher are trademarks or registered trademarks of Flexera Software.
Parasolid is a registered trademark of Siemens Product Lifecycle Management, Inc. All other trademarks are the property of their
respective owners.
ADAM:V2021.0.2:Z:Z:Z:DC-CNTL
Documentation Feedback
At MSC Software, we strive to produce the highest quality documentation and welcome your feedback.
If you have comments or suggestions about our documentation, write to us at: documentation-
feedback@mscsoftware.com.
Please include the following information with your feedback:
 Document name
 Release/Version number
 Chapter/Section name
 Topic title (for Online Help)
 Brief description of the content (for example, incomplete/incorrect information, grammatical
errors, information that requires clarification or more details and so on).
 Your suggestions for correcting/improving documentation
You may also provide your feedback about MSC Software documentation by taking a short 5-minute
survey at: http://msc-documentation.questionpro.com.
Note: The above mentioned e-mail address is only for providing documentation specific
feedback. If you have any technical problems, issues, or queries, please contact Technical
Support.
Welcome to Adams Controls 1
About Adams Controls
Welcome to Adams Controls

About Adams Controls
Adams Controls, part of the Adams® 2021.0.2 suite of software, is a plugin to MSC Software’s Adams Car,
Adams View, or Adams Solver that helps you add sophisticated controls to your Adams model. Adams
Controls lets you connect your Adams model to block diagrams that you've developed with control
applications such as Easy5® or MATLAB®.
Benefits of Adams Controls

By combining mechanical system simulation tools and controls design tools, you can:
 Add sophisticated controls to an Adams model and simulate the combined system.
 Generate mechanical system simulation models directly from your Adams data without having to
write equations.
 Analyze the results of your simulation in the Adams environment or the controls application
environment.
How to Improve the Design Process with Adams Controls

In the typical design process of a mechanical system with controls, the mechanical designer and the controls
designer work from the same concept, but use different sets of software tools. The result is that each designer
produces a model for the same problem.
Each design is then subject to verification and testing, and the first time the two designs are brought together
is during physical prototype testing. If a problem occurs during the interaction between the controls design
and the mechanical design, the engineers must refine the control design, the mechanical design, or both, and
then go through the entire verification process again as shown in the figure below.
2 Adams Controls
Benefits of Adams Controls
With Adams Controls, the two designers can share the same mechanical model. They can also verify from
one database the combined effects of a control system on a nonlinear, non-rigid model. The physical testing
process is greatly simplified, and the risk of the control law being poorly matched to the real system is
eliminated as you can see in the figure below.
Welcome to Adams Controls 3
Ways to Use Adams Controls
Ways to Use Adams Controls

You can use Adams Controls in a variety of ways.
Adams Controls offers you the option of simulating the combined mechanical system and controller:
 entirely within the controls application via Function Evaluation.
 entirely within Adams via Control System Import.
 by solving the controls equations with the control package and solving the mechanical system
equations with Adams via co-simulation.
Using co-simulation or Function Evaluation:

By using Adams Controls with Adams View, you can animate your model and view the effects of the control
system and any structural modifications you make. For faster simulation results, you can run Adams Controls
directly with Adams Solver, MSC Software’s powerful analysis engine. The process is faster because you're
running a simulation in batch mode.
You can also run Adams Controls with Adams template-based products, such as Adams Car, and others. In
these environments, you run the simulations in batch mode and view model animations when the simulation
is complete. Adams Car also requires co-simulation mode to run.
4 Adams Controls
About the Adams Controls Four-Step Process
Using Control System Import:

You also have the option with Adams Controls to import the controls system definition into Adams.
Importing the control system requires either Mathwork's Real-Time Workshop® or Easy5's XFE.
About the Adams Controls Four-Step Process

The figure below describes the four-step process of combining controls with a mechanical system. Refer to
Getting Started Using Adams Controls for detailed procedures for each step.
Adams Input Adams Adams Output
Controls
Application
Controls Output Controls Input
1. Build the Model - The first step in working with Adams Controls is to build or import an Adams
model. The model should be complete and include all necessary geometry, constraints, forces, and
measures.
2. Create the Adams Inputs and Outputs - The outputs describe the variables that go to the controls
application (the output from the Adams model is the input to the controls system). The inputs
describe the variables that come back into Adams (the output of the controls application) and,
therefore, complete a closed loop between Adams and the controls application. All inputs and outputs
must be set up as state variables. After these are defined, you export the plant system files from Adams
for use in the controls simulation software.
3. Build the Block Diagram - Build the control system block diagram with Easy5 or
MATLAB/Simulink. Include the Adams plant in your block diagram, or if using Real-Time
Workshop, export the controls system and import into Adams.
4. Simulate the Model - Simulate the combined mechanical model and control system. Several different
methods are available to run your simulation.
Adams Controls Overview 7
Loading Adams Controls
Adams Controls Overview

Loading Adams Controls
To start Adams Controls, you first start your host product, such as Adams View, import a model, and then
load the Adams Controls plugin.
To start Adams Controls:

1. Start Adams View by doing one of the following:
• On Linux, type the command adams2021_0_2 to start the Adams Toolbar at the command
prompt, and then press Enter. Select the Adams View tool.
• On Windows, from the Start menu, point to Programs, point to Adams 2021.0.2, and then
select Adams View.
The Welcome dialog box appears, in the Adams View main window.
2. From the File menu, select Import. The File Import dialog box appears.
3. Right-click the File To Read text box, and then select Browse.
Select the model and click Open and click OK. The model appears in the Adams View main window.
4. Load Adams Controls by doing the following:
a. From the Tools menu, point to Plugin Manager.
• Select the Load check box next to Adams Controls.
• Select OK.
Adams Controls is now loaded.
b. Click the Plugin tab on the Adams View ribbon.
• From the Controls container, click the Controls icon .
To unload the Adams Controls plugin:

1. From the Tools menu, point to Plugin Manager.
• Clear the Load check box next to Adams Controls.
• Select OK.
2. Click the Plugin tab on the Adams View ribbon.
• From the Controls container, click the Controls icon and then select the Unload the
Controls plugin.
Getting Started Using Adams Controls

When first starting using Adams Controls, we recommend that you start by working through the tutorial
entitled 'Getting Started Using Adams Controls'. This tutorial gives you an overview of the four-step process
8 Adams Controls
Simulation Methods
of adding controls to an Adams model. The example also includes tutorials for each of the controls
applications you can use with Adams Controls: Co-simulation, Function evaluation, and Control System
Import with both Easy5 and MATLAB. See the Examples section to find this tutorial.
Simulation Methods
Choosing a Simulation Method
Adams Controls offers you three methods with which you can simulate your integrated model and controller:
Co-simulation/Discrete mode: Specifies that Adams solve the mechanical system equations and the control
application solve the control system equations. Adams and the control application exchange inputs and
outputs at predetermined time interval also known as the communication interval or co-simulation interval.
The mode names of "co-simulation" and "discrete" are synonymous.
Function Evaluation/Continuous mode: Specifies that the control application solve both the mechanical and control
system equations. The mode names of "function evaluation" and “continuous” are synonymous.
Control System Import : Specifies that Adams solve the combined mechanical system and control system
equations by importing an External System Library (ESL) which is binary representation of a model
generated by MATLAB/Real-Time Workshop or Easy5. The ESL is used by Adams Controls to automatically
create a General State Equations (GSE) entity, along with other supporting entities. This process is also
known as External Function Evaluation (XFE), External System Import (ESI), Importing General State
Equations, or Dynamic System Import (DSI).
These methods allow you to use different methods to integrate your Adams and controls models (EASY5 or
MATLAB). See the table below for an overview of suitable controller/simulation method options.
Simulation Method
Controller type: Discrete mode: Continuous mode: C-code import:
Continuous Yes Yes Yes
Continuous sampled controller Yes Yes Yes
Controller with discrete and Yes Yes Yes
continuous states
Discrete controller with synchronous Yes Yes Yes
sampling rates
Discrete controller with asynchronous No Yes Yes
multi-sampling rates
Logic-based controller No Yes No
Co-simulation
For most analyses, the discrete mode is generally the more efficient simulation method. It is faster and can
handle complex models better than continuous mode. You should use continuous mode when equations
Plant Inputs and Outputs
solved in the control system would cause a large coupling effect on the Adams data. For example, you might
prefer to use the continuous mode if your analysis requires a very small time step.
To preserve the proper dynamics for a mechanical system, discrete mode should sample the mechanical
system at least five times greater than the highest frequency of interest. If the time step is too small to sample
at five times the highest frequency, then you should use continuous mode.
Note: You can find the highest frequency of your mechanical system by performing a linear analysis
with the Adams add-on module, Adams Linear.
Function Evaluation
In continuous (function evaluation) mode, the control system package solves the equations of motion for the
combined controls and mechanical dynamics system. Adams formulates the equations of motion for the
mechanical subsystem and provides information to the controls package as needed.
Typically Adams simulations involve solving a set of differential (equations of motion) and algebraic
(constraint and applied force) equations, known as a DAE system. The Adams integrators are specially tuned
for efficient solution of this type of problem. Using coordinate partitioning, Adams can also formulate the
equations of motion based on a minimum independent set of system states. This results in a compact
ordinary differential equation (ODE) formulation of the equations of motion. Typically this system of
equations is more difficult to solve numerically than the DAE method described above.
The benefit of this ODE formulation is that the state values and time derivatives can be easily communicated
to the controls package. Using this information, the controls package can form a combined ODE system
describing the controls and mechanical states. This is the problem that the controls package then solves with
its own integration techniques. When a new set of state values is found in the controls package, Adams is
called to find the time derivatives of these states, based on the ODE formulation that Adams has created for
the mechanical states. This is why it is known as “function evaluation” mode. Adams simply sets up the
equations of motion and provides time derivative information for the states in this mode.
For more information on how continuous mode works, refer to
http://simcompanion.mscsoftware.com/iKB8015801.
Control System Import

In this mode, you can import into Adams a binary representation of the control system (or any other model)
built in Easy5 or MATLAB. To do this, you have to first export the Easy5 or Simulink model using Easy5 or
Real-Time Workshop along with Adams Controls to generate code. Adams Controls then allows you to
create, in an automated manner, a general state equation (GSE) element and supporting elements in your
Adams model. After this is done, you can simulate your combined model in Adams.
Plant Inputs and Outputs

To create the connect between the (external) control system and the Adams model, Plant Inputs and Plant
Outputs must be created and used to specify the inputs and outputs from the Adams plant. Plant Inputs and
Plant Outputs are Adams entities that contain a list of state variables. These are either created automatically
10 Adams Controls
Exporting Adams Controls Plant Files
by the Plant Export dialog box, or created by using Plant Input/Plant Output option found in Elements Tab
→ Data Elements container → Create an ADAMS Plant Input/Plant Output.
Note that in Adams Controls you can use two types of variables: design variables and state variables.
A design variable is only a preprocessing entity. It is a placeholder for element parameter values. When writing
an .adm file, these entities are evaluated and entered in the Adams Solver dataset as numerical values. The
design variable value can be any expression created in the Adams Expression Builder. Design variables are also
known as Adams View variables and simply as variables (in the Adams View Database Navigator).
A state variable is a variable whose value is calculated at every simulation step. The value can be any function
created in the Adams View Function Builder. State variables are also known as Adams Solver variables,
Adams_Variable (in Adams View Database Navigator), and VARIABLE (statement in Adams Solver dataset).
Adams Controls uses state variables to specify the inputs and outputs from the Adams model, because these
variables are computed during runtime.
For more information, see the online help for Adams View Function Builder.
Exporting Adams Controls Plant Files

When you export the Adams plant files, Adams Controls saves the input and output information in an .inf
file (for Easy5) or an .m file (for MATLAB). It also generates a command file (.cmd) and a dataset file (.adm)
that are used during the simulation process.
To export Adams Controls plant files:

2. From the Controls container, click the Controls icon and then select Plant Export.
3. Complete the Adams Controls Plant Export dialog box as described in Adams Controls Plant Export.
4. Select OK.
Using Easy5
Installing the Adams Extension for Easy5

To run Adams and Easy5 together, you must install the Adams extension into Easy5. To import models into
Adams that were exported from Easy5 (containing components from licensed Easy5 libraries), you must also
configure your computer so that Adams knows how to find your Easy5 license. The following procedures
explain how to do this.
Using Easy5
To install the Adams extension for Easy5:
Note: Check http://simcompanion.mscsoftware.com/ to find the versions of Easy5 that are compatible
with Adams.
1. Make sure that both Easy5 and Adams have been installed.
2. Make sure you have permission (that is, root ('superuser') privilege) to add and modify files in the
Easy5 installation directory.
3. Perform the following, depending on your platform:
On Linux:
a. Open an xterm window and set your working directory to a directory outside the Easy5
installation directory tree.
b. Start Easy5. The standard command is easy5x.
c. In the Easy5 main window, from the File menu, select Open Command Shell.
d. At the prompt in the command shell, enter:
$EZHOME/install_adams_controls.ksh adamscmd
where: adamscmd = command used to invoke Adams (for example, adams1401)
On Windows:
a. From the Start menu, point to Programs, point to Easy5 - (version), point to Shell, and then
select Easy5 Command Shell.
b. At the prompt within the command shell type:
install_adams_controls.bat <Adams_topdir> <Easy5_topdir>
where: <Adams_topdir> is the top-level directory for Adams, also provided by "adams2021_0_2
-top"; <Easy5_topdir> is the top-level directory of Easy5 (for example, C:\Program
Files\MSC.Software\Adams\2021_0_2, C:\Program Files\MSC.Software\EASY5\2015,
respectively).
Note: If you are unable to identify a command line command to run Adams but you can
identify the top-level directory of the Adams installation, you can use -d "directory
path" in place of the command line command.
4. Type exit to close the command window.

5. If you started Easy5, from the File menu, select Quit.
The Adams extension installation is complete. Be sure to configure your computer as described next.
12 Adams Controls
Using Easy5
License Configuration
To configure your computer to run licensed exported Easy5 models within Adams:
1. Start Easy5.
2. From the File menu, select Open Command Shell.
3. At the prompt in the command shell, type easy5x -license.
Easy5 displays the licensing information, beginning with the type of license and the server name (if a
server license) or the path to the license file.
4. Write down the contents of the line that starts with Active license file(s), and the value that appears
in the line following it (for example, 1700@rainier).
5. Perform one of the following:
• If the line is Active license file(s) [EASY5_LMD_LICENSE_FILE], set the environment variable
EASY5_LMD_LICENSE_FILE to the output value displayed in Step 4 above (for example,
1700@rainier).
• If the line is Active license file(s) [MSC_LICENSE_FILE], find the value of the environment
variable MSC_LICENSE_FILE to see what license file Adams is using.
• If Easy5 and Adams are using different licenses (or license servers), set LM_LICENSE_FILE to
the value for the Easy5 license (for example 2500@bosco).
• If Easy5 and Adams are using the same license, your computer is configured properly.
6. For Windows platforms only, modify the Path environment variable to include the path to the
lib_em64t_IFORT (Win64) subdirectory of your Easy5 installation tree.
• If your Easy5 model contains components from a licensed library (for example, the Thermo-
Hydraulic, Powertrain, or Gas Dynamics libraries), you will need to make sure Adams finds your
Easy5 license. Failure to perform this step will result in the Easy5 license library not being found.
• Adams supports the Intel Visual Fortran 16 compiler. The Easy5 model import feature is not
supported with the GNU or other compilers. Check http://simcompanion.mscsoftware.com/DOC9283
for latest compiler support information.
To find the appropriate value for the variable:
a. Start Easy5.
b. Open an Easy5 command shell: from the Easy5 File menu, select Open Command Shell.
c. At the command shell prompt, enter: echo %EZHOME%.
The output is the directory in which Easy5 is installed. You will use the directory information in
Step 5 below. The usual value of EZHOME is:
C:\Program Files\MSC.Software\Easy5\(version)\
Note: Check http://simcompanion.mscsoftware.com to find the versions of Easy5 that are

compatible with Adams.
Using Easy5
To apply the value of the environment variable:

a. From the Start menu, point to Settings, and then select Control Panel.
b. In the Control Panel dialog box, select the System icon.
c. In the System Properties dialog box, select the Advanced tab.
d. In the Advanced tab container, select Environment Variables.
Adams must know the path to the subdirectory of your Easy5 installation tree to be able to load
ez5_lmgr.dll:
e. Using the path from step 3, in the Environment Variables dialog box, append or create the path
to the user variable as follows:
Variable Name = PATH
Enter the following, where <CURRENT_VALUE> is the current value of PATH:
Variable Value = <CURRENT_VALUE>; %EZHOME%\easy5x\lib_em64t_IFORT
and where the value of EZHOME is taken into account.
For more information on Control System Import in Easy5, see Learning Adams Controls with Control
System Import from Easy5 in 'Getting Started Using Adams Controls' tutorial. This tutorial gives you an
overview of the four-step process of adding controls to an Adams model. The example also includes tutorials
for each of the controls applications you can use with Adams Controls: Co-simulation, Function evaluation,
and Control System Import with both Easy5 and MATLAB. See the Examples section for more details.
Easy5 Update of Adams Controls Extension Components

Overview
Easy5 now provides an update of all Extension components in the same way that it has updated Library
components in past releases. This also includes the Adams Controls Extension component (that is, AD block)
which has been modified to provide this automatic update. In the past, an update of the component only
occurred when selecting and configuring the AD block within the Easy5 GUI.
The “update check” is performed automatically anytime a model “executable” is built (whether done
manually or automatically when a topology change has occurred). A model executable can be an .exe file, or
any exported runtime file (.dll). Easy5 will attempt to synchronize the model component instance with the
library version of a component or Extension being used.
Update Process Details

The update of the Adams Controls Easy5 extension requires an .inf file for the component and by default will
search your Easy5 model for the name of the .inf file provided by 'AdamsFileName'. It also looks for the
execution mode (for example, co-simulation, function evaluation) with the keyword 'ExecMode', with an
additional method of update for old models where ExecMode was not yet available. If this process fails, you
can update the model by configuring the AD block manually in the interface.
In addition, if you are updating from command line with:
easy5x -AutoUpdate
14 Adams Controls
Using Easy5
or
easy5x -AutoUpdPurge
and you want to launch the Configure dialog box to manually select the .inf and/or Execution Mode, you
can display the Adams Controls Extension Component (AD Block) by setting the following environment
variable to zero:
set EZ5_EXT_UPDATE_AD_NO_GUI=0
You can set back to the default mode of suppressing the Adams Controls Extension Component (AD Block)
by removing this environment variable or setting the following environment variable to anything non-zero:
set EZ5_EXT_UPDATE_AD_NO_GUI=1
Although it is recommended that the AD block be updated for each model, to suppress the Extension
Component Update, set the following environment variable:
set EZ5_SKIP_EXT_UPD_CHECK=true
and it will not do any checking for Extensions (this would revert to the prior behavior for Extensions – no
checking at all). For users of 8.0.7, this is recommended since an error in 8.0.7 will prevent the correct
timestamp from being updated and running simulations and Exporting Model as External System Library
will fail.
Co-Simulation and Function Evaluation 19
Animation Options
Co-Simulation and Function

Evaluation
Animation Options
Adams Controls lets you choose one of two animation modes: interactive or batch. Both methods allow you
to save results to Adams files for review at a later date.
Method: Its purpose:

Interactive mode  Specifies the simulation to run in Adams View.
 Provides a dynamic, graphic display of the simulation results.
 Allows you to pause during a simulation to review any animation or plotting
results.
 Allows you to verify the initial design of your control law for proper signal phase
and magnitude.
 Not supported by Adams Car Full-Vehicle analyses.
Batch mode  Specifies that the simulation run in Adams Solver. This is the preferred method if a
graphic display of the analysis results is unnecessary, since it provides a much faster
solve time.
 Supported by Adams Car Full-Vehicle analyses.
Initialization
Initialization Sequence
Adams Controls performs an Initialization Sequence, consisting of a few different steps, before commencing
with the Co-simulation or Function Evaluation run. The initialization sequence is as follows.
1. If desired, necessary Adams Solver or Adams View commands are submitted (for example,
ADAMS_init variable for MATLAB; see the Initialization Commands section for more details).
2. Following sequence is followed depending on the status of static simulation:
a. If static simulation is requested, then static analysis is performed at time = 0. (for example,
ADAMS_static='yes' for MATLAB)
b. If static simulation is requested and the simulation fails, the initial conditions analysis is
submitted.
c. If static simulation is not requested, then initial conditions analysis is submitted.
3. Dynamic co-simulation/function evaluation run begins at time = 0.
20 Adams Controls
Initialization
Thus, equivalent commands in Adams View and Adams Solver work in a similar manner. The exception is
that with Adams View, the model is not registered with the Adams Solver until after all the user commands
in Step 1. have been submitted, which means you may create modeling entities with Adams View commands.
In general, when the model is submitted to Adams Solver, you cannot create new modeling entities, so this
feature will not be available.
The Plant Export dialog box below displays the options that correspond to the steps listed above. The option
Initialization Command corresponds to Step 1. above, while Initial Static Analysis corresponds to Steps 2.a.-
c.
Initialization Commands
Initialization commands are Adams commands which are executed before the controls package starts the co-
simulation. If you run a simulation with animation in interactive mode, you must use Adams View
commands to initialize your model. If you are in batch mode, use Adams Solver commands.
Co-Simulation and Interpolation/Extrapolation
You can specify a command in two ways. For example, if you want to change the color of the antenna model,
for an interactive (Adams View) simulation, you can issue one of the following commands:
 At the MATLAB prompt, enter:
Adams_Init=‘geometry attributes geometry_name=.main_olt.antenna.REV15
color=RED’
Within the Adams mask, Initialization command field reads: Adams_Init.
 Alternatively, in the Initialization commands text box, you can enter the complete command string
enclosed in single quotes and square brackets as follows:
[‘geometry attributes geometry_name=.main_olt.antenna.REV15 color=RED’]
For Adams Solver, you can also place all of your initialization commands in a single file, and reference it with
the FILE command. You can do this in the Plant Export dialog box or you can manually edit your .inf or .m
files. For Easy5, your .inf file might look like this:
NUMBER OF COMMANDS
1
file/command=myfile.acf
This reads in and executes the .acf file.
In MATLAB, you would modify the following variable, either in the .m file, or in the workspace:
ADAMS_init='file/command=myfile.acf'

For co-simulation mode, the variables are not continuously in-sync with each other, as in Function
Evaluation mode, since the variables passed between Adams and MATLAB/Simulink or Easy5 are sampled.
Optionally, you can choose to interpolate/extrapolate these variables in between the sample times. The
following is a brief description of how Adams Controls co-simulation interpolation/extrapolation works.
During co-simulation, if either Simulink or Easy5 is driving the analysis (that is, "leading the co-simulation"),
single communication interval (delta) step consists of the following:
1. Easy5 or MATLAB/Simulink integrates from time = t - 1 to t to compute inputs for Adams
Controls at time = t.
2. Easy5 or MATLAB/Simulink then requests outputs from Adams Controls at time = t.
3. Adams Controls integrates its equations until from t - 1 to t to provide outputs to Easy5 or
MATLAB/Simulink.
4. Easy5 or MATLAB/Simulink takes the Adams outputs at time = t to complete the cycle and move
on to integrate from t to t + 1.
During these four stages, in step 1, the inputs to Adams Controls can be interpolated or held constant, while
in step 3, the outputs from Adams Controls can be extrapolated or held constant.
22 Adams Controls
Interpolation/Extrapolation Options
Step 1 - Options for Adams Controls Plant Inputs
The following describe what happens to the Adams Plant inputs (that is, outputs from Easy5 or
MATLAB/Simulink) when Simulink or Easy5 leads the co-simulation.
 If the Plant Input interpolation order is set to zero:
Adams Controls holds the Easy5/Simulink inputs, U, as constant values. In other words, apply a
zero-order hold to the Plant Input values of Easy5 coming into Adams. For example, specify that the
sample times occur at time = 0, 1, 2... If the current sample time is time = 2, and the last
communication interval is time = 1, the Plant Inputs are sampled at time = 2, and held
constant while Adams integrates from the last time (t1) to the current time (t2) to provide the
Plant Outputs to Easy5.
 If the Plant Input interpolation order is set to one:
Adams Controls uses linear interpolation between the current and past values from Easy5 or
MATLAB/Simulink. For example, if the current sample time is time= 2 (t2), and the last sample
time is time = 1 (t2), the Plant Inputs are sampled by Adams Controls at time = 2, and
linearly interpolated from t1 (saved from the previous communication time) to t2, as shown below
while Adams integrates from the last time (t1) to the current time (t2) to provide the Plant
Outputs to Easy5.
interpolation: Plant Inputs, U (1 → 2) = U1 + (U2 - U1) /
communication_interval * (current_simulation_time - t1)
Step 3 - Options for Adams Controls Plant Outputs

The following describes what happens to the Adams Plant outputs (that is, inputs to Easy5 or
MATLAB/Simulink)
 If the Plant Output extrapolation order is set to zero:
Easy5 or MATLAB/Simulink assumes that the Adams outputs (Y) are constant values. In other
words, apply a zero-order hold to the Plant Output values of Adams coming into Easy5 or
MATLAB/Simulink. For example, if the last sample time was time = 1, and the current sample
time is time = 2, then Easy5 samples the Adams Plant Outputs at time = 1, and holds them
constant while Easy5 integrates from the last time (t1) up to the current time (t2) to provide the
Plant Inputs to Adams.
 If the Plant Output extrapolation order is set to one:
Easy5 or MATLAB/Simulink uses linear extrapolation beyond the past two values from Adams. For
example, if the last sample time was time = 1, and the current sample time is time = 2, then
Easy5 uses the saved samples of the Adams Plant Outputs at time = 1 and time = 0, and linearly
extrapolates, as shown below while Easy5 integrates from the last time (t1) up to the current time
(t2) to provide the Plant Inputs to Adams.
extrapolation: Plant Outputs, Y (1 → 2) = Y1 + (Y1 - Y0) /
communication_interval * (current_simulation_time - t1)
Only in Simulink, optionally, you can choose Adams to lead the co-simulation, which may be used to break
an algebraic loop with the Adams Controls S-Function. In this case, the interpolation and extrapolation
methods are exactly the same, but are reversed for the plant inputs and outputs (that is, the Plant Inputs are
extrapolated and the Plant Outputs are interpolated). This setting can be seen highlighted below:
24 Adams Controls
Example: Antenna Model

The following shows the antenna example found in the Getting Started Using Adams Controls for setting
interpolation/extrapolation in Co-simulation vs. Function Evaluation. This example shows the effect of
interpolation and extrapolation on the accuracy of the result, and also shows the effect of the communication
interval on extrapolation. Here, Simulink leads the co-simulation.
The first plots show the antenna model output azimuth position for Function Evaluation (red curve) vs. co-
simulation:
The communication interval is set to 1 millisecond, and the results for all interpolation settings are very close
to the result for Function Evaluation. However, upon closer inspection, the plot on the right show that for
linear extrapolation ("extrap1"), the co-simulation results (shown in the green line) are very close to the
results for Function Evaluation. The results for extrapolation off are similar (red and blue striped line), but a
little bit different than Function Evaluation. This can also be seen in the next plot of the input torque to
Adams:
The plot to the right is a close-up of the bottom of the plot on the right. You can see that the red line for
Function Evaluation is more closely matched by the plots that use extrapolation ("extrap1").
26 Adams Controls
User Libraries
Now, for comparison, look at this same example where the communication interval has been changed from
1 ms to 5 ms. In this case, the linear extrapolation is not as accurate as for 1 ms, and the results without
extrapolation appear to be closer to the Function Evaluation case.
Plot of azimuth position:
Plot of control torque:
Thus, linear extrapolation can help get an accurate answer, as long as the communication interval is small
enough to provide an accurate prediction.
User Libraries
In Adams when you want to link in a user subroutine, you create a library (standard user executable) and
simply select it when you need the subroutine(s) within the library.
To create a user library:

1. Perform one of the following:
• On Linux: enter adams2021_0_2 -c cr-user
Using TCP/IP
• On Windows: From the Start menu, point to Programs, point to Adams 2021.0.2, point to
Adams Solver, and then select Create Custom Solver. (Or, type adams2021_0_2 cr-user in the
DOS prompt.)
2. Specify if you want to link in debug mode, and provide the list of your user subroutines.
3. Provide a name for the Adams Solver library, such as my_sub.dll.
4. Within Adams View, when you use the Controls Plant Export dialog box to write out your input and
output data, include the name of the user library you just created in the appropriate text box.
The user executable name is now automatically written out to the MATLAB .m file or the EASY5
information file and automatically picked up by the controls program as the proper executable.
Alternatively, you can enter this explicitly in the file. For example, in MATLAB, enter Adams_exec
= '$my_path/my_sub.dll'; (where $my_path is the path to your library).
For more information, see the Running and Configuring online help.
Using TCP/IP
About TCP/IP
TCP/IP (Transmission Control Protocol/Internet Protocol) is the standard for network communications. In
addition to the default pipes-based communication protocol, you can use TCP/IP communication Adams
Controls. TCP/IP-based communication allows you to run Adams on one workstation while running
controls software, such as Easy5 or MATLAB, on a second networked machine of the same or different
architecture. In the Adams Controls communication protocol, the controls software is the client and Adams
is the server.
A python script, adams_daemon.py, is used to setup TCP/IP communication between Adams and Easy5 or
MATLAB. This script can be found in /$install_dir/controls/utils, where $install_dir is the directory in which
Adams is installed.
Once started, the default mode of Adams daemon will be available to sequentially service requests from clients
for successive Adams simulations. When a client terminates an Adams simulation, the daemon becomes
available to start another Adams simulation for the next client. In the default mode, the daemon does not
terminate until you explicitly terminate it from the operating system. To terminate the process, you can either
close the window of the process, or enter:
 Windows: Ctrl + Break
 Linux: Ctrl + C
Optionally, you can enter the number of runs before termination with the -n flag for adams_daemon.py.
28 Adams Controls
Using TCP/IP
Starting the Adams Daemon Process
Note: Although it is not required for general use, for the instructions below, copy the file
/$install_dir/controls/utils/adams_daemon.py to your local working directory, where
$install_dir is the directory in which Adams is installed
To start the Adams daemon process:

1. On the workstation on which you will run Adams daemon process, export the Adams plant as
instructed in Exporting Adams Controls Plant Files. Verify that the name automatically detected for Adams
Host is a fully qualified hostname (To be fully qualified, the hostname must contain the workstation
and domain name). If the Adams Host is not fully qualified, edit the value in the text box so that it
is fully qualified.
2. Select OK, and then exit Adams View.
3. Move or copy the .inf or .m file created in step 2 to the directory on the client machine from which
you intend to run Easy5 or MATLAB.
4. To view the options available for the Adams daemon, in a command shell, issue one of the following
commands:
• On Windows: adams2021_0_2 python adams_daemon.py -h
• On Linux: adams2021_0_2 -c python adams_daemon.py -h exit
The script returns the available options and the acceptable values for each option, as shown next
This script can be invoked in the following ways:

On Linux: $adams_alias -c python topdir/controls/utils/adams_daemon.py
[-h] [-p port] [-n #] exit
On Windows: $adams_alias python topdir\controls\utilsdams_daemon.py
[-h] [-p port] [-n #] exit
topdir is the installation directory of Adams and can be got by issuing
"$adams_alias -top".
-h print this help message.
-p port specify the port number. The default value: 30001
-n # specify the number of runs before the daemon stops.
The default is -1 = infinite loop until process closed.
Note: $adams_alias is the adams command line alias
5. Start the default Adams daemon in your current working directory by entering one of the following
commands in a command shell:
• On Windows: adams2021_0_2 python adams_daemon.py
Using TCP/IP
• On Linux: adams2021_0_2 -c python adams_daemon.py exit

If using MATLAB and you are running the Simulink and Adams models on the same machine,
optionally you can start the same process by using the start_adams_daemon.m script found in the
Adams installation. To use it after importing the .m file from the Plant Export, simply enter the
following at a MATLAB command prompt:
>> start_adams_daemon
The Adams daemon starts and displays the following:
---------------------------------------------------------------
The Adams Controls server daemon is now operational for
TCP/IP communication with Easy5, Matlab or Adams FMI client(s).
This server daemon will remain in the send/receive mode
until this window is closed or the following keyed in:
Windows: Ctrl+Break
Linux: Ctrl+C
-------------------------------------------------------------
Note: When your client connects to the Adams daemon, it displays information similar to the
following:
Running Adams with MATLAB

To run Adams with MATLAB:
1. In the Adams plant mask in MATLAB/Simulink, make the following changes in the mask:
• Set Interprocess Option to TCP/IP.
2. Note that the Adams working directory is the directory where the Adams files are on the server
specified by Adams host. These are specified by the .m file generated by Plant Export. Confirm that
these values are appropriate for your simulation or change them accordingly.
3. Select OK to save your settings.
30 Adams Controls
Using TCP/IP
4. Start the Adams daemon on the Adams host before starting the simulation in MATLAB/Simulink
Running Adams with Easy5

To run Adams with Easy5:
1. In the component data table for the AD block in Easy5, change the following:
• Adams_Communication_Mode to 2.0
The component data table should look as follows:
2. To save your settings, select OK.

3. Note that the .inf file generated by the Adams Controls Plant export contains the Adams working
directory (ADAMS cwd) and host (ADAMS Host). These specify the directory where the Adams files
are on the Adams server. Confirm that these values are appropriate for your simulation or change
them accordingly. For example:
Using TCP/IP
ADAMS Host
My_machine.my_domain.com
ADAMS cwd
C:\adams\antenna
4. Start the Adams daemon on the Adams host before starting the simulation in Easy5.
32 Adams Controls
Using Time Offset with Matlab

To allow for an initialization of either the Adams model or the MATLAB/Simulink model, time offset is
introduced.
Note: This functionality is available in co-simulation with Matlab/Simlink only.
Using the time offset parameter, in the MATLAB workspace called ADAMS_time_offset, allows Adams and
MATLAB/Simulink to start its simulations at different times. If a positive value time offset T o is used then
Simulink will simulate for T o seconds prior to starting the Adams simulation. If a negative time offset is
used, then Adams will simulate for T o seconds first. If t M is the time used in MATLAB and t A is the time
used in Adams, then:
tM = tA + To
For example, time offset can be used for calibration of a Simulink control system that requires a vehicle at
stand-still, but where the Adams simulation is started at an initial speed for computation efficiencies. In such
case using To > 0s the Simulink will start its simulation prior to starting the Adams simulation.
A negative time offset can be used to bring the Adams model at a desired state before starting the controls
system.
An example model antenna_with_time_offset.mdl, is provided in the $topdir/controls/examples directory of
the Adams installation. Applying a step response at 0.05s in Simulink and using a positive time offset
To=0.05, the Adams simulation will show the response at 0s time in Adams, as shown in the following figure.
Figure 1 Adams and Simulink times for a step response applied in Simulink at 0.05s and using 0.05s time offset.
The figure below shows the step response for a negative time offset of -0.05s. It can be seen that Adams already
runs for 0.05s prior to running the Simulink simulation.
34 Adams Controls
Figure 2 Adams and Simulink times for a step response applied in Simulink at 0.05s and using -0.05s time offset.
It should be noted that when To > 0s, Adams will perform a static equilibrium at t M = 0s and then wait
until t M = To .
It is also important to note that the block containing the Adams plant can only be run when
t A = t M – T o ≥ 0s because Adams cannot simulate at negative times. This can be accomplished with
enable and merge blocks in Simulink as shown below or in the above mentioned example
antenna_with_time_offset.mdl.
Limitations
Figure 3 Enabling the Adams block only when t A ≥ 0
Limitations
 Only one Adams Plant Block may be used in a model.
 Name of the Adams model limited to 512 characters.
 Adams and the MATLAB/Simulink or Easy5 must communicate at the same time interval.
 Quasi-static co-simulations are not supported (co-simulation performs a series of simulate/dynamic
commands).
 Kinematic Adams models in Function Evaluation are not supported (Workaround: add a dummy
part to get a dynamic model).
 Adams Control Subroutines (CONSUB's) in Function Evaluation are not supported.
 Initialization Commands: SAVE and RELOAD are not supported.
 The compiler used by EASY5 must be the same as that supported by Adams; see
http://www.mscsoftware.com/ for a list of supported compilers.
36 Adams Controls
Limitations
Control System Import 37
Importing External System Library
Control System Import

Importing External System Library
Imports an External System Library (ESL) into your Adams model by creating general state equation (GSE)
and other supporting elements that use the library.
To import an External System Library:

2. From the Controls container, click the Adams Controls icon . Select Controls System →
Import.
The Adams Controls System Import dialog box appears.
3. Complete the dialog box as described in Adams Controls System Import help page.
4. Select OK.
Setting External System Library Error Tolerance

Adams Controls System Import loads the equations found in the External System Library (ESL) with an
ADAMS General State Equation (GSE) element. By default, the continuous states of the GSE are integrated
to an error tolerance as specified by the INTEGRATOR statement. However, Adams Controls gives you the
option to override the default computation of the integrator's local integration error using the error tolerance
settings for the continuous states of an ESL. Effectively, you have more control over the error of the individual
states of the ESL. You may want to use this feature to help refine the accuracy of your ESL states, but just like
any INTEGRATOR setting, this may require tuning.
In order to apply the error tolerance of the ESL, Adams Controls will pass a scale factor to the GSE subroutine
that will multiply the ESL error tolerance values to determine the final GSE continuous state error, that is:
Final GSE error tolerance = Error Scale Factor * ESL error tolerance, Error Scale Factor > 0
For an Error Scale Factor <=0, this will disable the ESL error tolerance values and will use the default method
instead.
For example, if you set the Error Scale Factor = 20, this will loosen the ESL error tolerance values by
multiplying them all by 20.
ESL Error tolerance, state 1 = 1e-8
ESL Error tolerance, state 2 = 1e-6
Error Scale Factor = 20
Final GSE error tolerance, state 1 = 1E-8 *20 = 2E-7
Final GSE error tolerance, state 2 = 1E-6 *20 = 2E-5
These final GSE error tolerance values will then be used to scale the local integration error of the respective
state, as described next.
38 Adams Controls
Removing External System Library
The integrator error tolerance is compared against a local error measure that depends on the difference
between the current predicted and corrected states, the past history of the states, and the current integration
order.
The integrator's error tolerance check can effectively be written as:
2 2 2 2
e 1 + e2 + e3 + … + en < E
where e is the difference between the predicted and corrected state, and E is the integrator ERROR setting.
If, for example, e3 has an error tolerance setting from the ESL for the GSE of E3, then the formula becomes:
2 2 2 2
e 1 + e2 + ( e3 × E ⁄ E3 ) + … + en < E
which effectively tightens the error tolerance if E3 < E.
As a general guideline, this feature may be more effective when the number of continuous states from your
ESL is much larger than the number of states in the rest of the Adams model. If the opposite is true, then the
addition of the ESL error tolerance values may not have much effect, or may be too restrictive. Also, you may
find this beneficial to decrease simulation times if you are able to increase the integrator ERROR setting to
loosen error needed on the Adams parts, and so on, while maintaining the error required for the GSE/ESL.
See the INTEGRATOR statement for more details about ERROR. This feature only applies to the C++
Solver, and only Easy5 models currently report error tolerance values.
Removing External System Library

You can delete the general state equation (GSE) that uses the external system library, its associated arrays, and
the dependency on the Adams model.
To delete a GSE:
2. From the Controls container, click the Adams Controls icon . Select Controls System →
Delete.
3. Enter the name of the model and GSE you want to delete.
4. Select OK.
Using MATLAB/Code Generation

For more information on Control System Import in MATLAB, see the tutorial entitled 'Getting Started
Using Adams Controls'. This tutorial gives you an overview of the four-step process of adding controls to an
Adams model. The example also includes tutorials for each of the controls applications you can use with
Adams Controls: Co-simulation, Function evaluation, and Control System Import with both Easy5 and
MATLAB. See the Examples section to find this tutorial.
Software Requirements
This example requires licenses for Adams Solver, Adams View, and Adams Controls. It also requires licenses
for MATLAB/Simulink/Real-Time Workshop, and using the version(s) that are compatible with Adams. The
exact versions supported can be found under "Supported Versions of Integration Products" in the following
link:
www.mscsoftware.com/support/platform-support
Compilers supported by both Adams and MATLAB/Code Generation must also be available (for example,
Microsoft Visual Studio 2013) - again, see the link above for exact details. These products are all assumed to
be on the same machine for this tutorial.
Solver Settings
You can choose either Variable-step or Fixed-step solvers in MATLAB/Simulink, under Simulation →
Configuration Parameters → Solver → Type. The choice will affect the model code that is generated from
Code Generation, in particular to how sample times are handled. This is important to Adams since Adams
will be integrating the model, not MATLAB/Code Generation. In this regard, the Variable-step integrator is
recommended since Adams Solver uses mainly variable-step integrators, and this will ensure the outputs and
states are computed properly. If you would still like to use a Fixed-step integrator setting, the model should
have at least one continuous state to produce the code for Adams that will handle the sample times properly.
For example, if you have a discrete-only model, add a dummy continuous block (for example, integrator) to
the model.
Tip:  To look for differences in sample times between Fixed-Step and Variable-step integrators
settings, look for the function ssIsSampleHit(), which handles evaluation of code at
sample times.
 As a MATLAB requirement, an Code Generation S-Function must have the same type of
integrator setting as the model that will use it (that is, both Fixed-step, or both Variable-
step).
Exporting Parameters in Simulink/Code Generation Models to Adams

You can export specific parameters from the Simulink/Code Generation model in order to fine-tune the
controller, or conduct design-of-experiments on the External System Library (ESL) without rebuilding the
model.
For the block diagram in the example below, the process of exporting the parameters is as follows:
 Step 1 - Define the parameters in MATLAB workspace
 Step 2 - Reference the Kp and Kv in the Simulink model
 Step 3 - Define the proper storage class for parameter export
 Step 4 - Create ESL with the tunable parameters exposed in Adams View
40 Adams Controls
The controller for the antenna model will be used to illustrate this process. This file can be found in
install_dir/controls/example/antenna/continuous.mdl. The parameters to be changed are 1040 in Transfer
Fcn and 950 in Transfer Fcn1.
Step 1 - Define the parameters in MATLAB workspace

In the MATLAB workspace, issue the following:
• Kp = 1040
• Kv = 950
These two MATLAB variables can be accessed from the Simulink model.
Step 2 - Reference the Kp and Kv in the Simulink model

1. Double-click the Transfer Fcn block. Notice that the numerator is hard-wired with a value of 1040.
2. In the Numerator text box, enter Kp:
3. Select OK.
4. Double-click the Transfer Fcn1 block.
5. In the Numerator text box, enter Kv.
The parameterized Simulink model now looks like this:
Step 3 - Define the proper storage class for parameter export

1. In the Simulink model window, from the Tools menu, point to Code Generation, and then select
Options.
2. In the Configuration Parameters window that opens, select Optimization Tab.
3. Under Signals and Parameters, select Inline parameters.
4. Select Configure.
5. Highlight Kp and Kv and select Add to Table.
6. Verify that Storage class is set to SimulinkGlobal(Auto).
7. Select OK to apply the changes and close the Model Parameters Configuration window.
8. In the Configuration Parameters window, select the Code Generation tab.
Here, you generate the C-code and External System Library of the Simulink model. For details on
code generation for Adams Controls, refer to the Learning Adams Controls with Control System
Import chapter in Getting Started Using Adams Controls.
After the code is generated, the following code appears in continuous_rsim_cg/continuous.h.
/* Parameters (auto storage) */
struct Parameters {
real_T Kp; /* Variable: Kp
* '<Root>/Transfer Fcn'
*/
real_T Kv; /* Variable: Kv
* '<Root>/Transfer Fcn1'
*/
};
42 Adams Controls
extern Parameters rtP; /* parameters */
…and in continuous_rsim_cg/continuous_data.c:
/* Block parameters (auto storage) */

Parameters rtP = {
1040.0, /* Kp : '<Root>/Transfer Fcn'
*/
950.0 /* Kv : '<Root>/Transfer Fcn1'
*/
};
Adams Controls wrapper code (adams.tlc) recognizes this structure and will generate Adams design
variables for these parameters. When entering values for these Adams design variables, these are
propagated to the Simulink/Code Generation parameters via the arguments to Adams GSE.
Step 4 - Create Code Generation-GSE with the tunable parameters exposed in Adams View
1. Create ESL as described in Learning Adams Controls with Controls System Import.
2. Once the GSE is created, open the Database Navigator and expand the GSE to examine its children
- you should see that the design variables Kp and Kv are created. The default values are 1040.0 and
950.0 as defined in the Simulink model. Those design variables can be changed to study the effects
on ESL.
Using Control System Import with MATLAB/Simulink/RTW on Windows and

Adams Controls on Linux
The process of transporting RTW code from one platform to another is as follows:
 Step 1 - Create MATLAB tree on Linux to build RTW library
 Step 2 - Create makefile and C-code template on Linux
 Step 3 - Generate C-code and makefile
 Step 4 - Build RTW dll
Step 1 - Create MATLAB tree on Linux to build RTW library

You need to emulate the Windows MATLAB file structure (tree) on your Linux machine to build the RTW
library.
1. Create a directory such as, home/rtwuser/cross.
2. Copy the following directories from the Windows MATLAB installation to the home/rtwuser/cross
directory on your Linux machine:
• simulink/include
• extern/include
• rtw/c/rsim
• rtw/c/libsrc
• rtw/c/src
• rtw/c/tools
• rtw/c/tlc
Note: Your make utility and compiler may be sensitive to DOS/Linux end-of-line character
differences. Therefore, we recommend that you run a dos2Linux file conversion utility to
ensure your files have a Linux end-of-line.
Step 2 - Create makefile and C-code template on Linux

1. Set the environment variable MATLAB_ROOT to /home/rtwuser/cross.
2. In the file, /home/rtwuser/cross/rtw/c/rsim/rsim_Linux.tmf, change the following:
• MATLAB_ROOT = |>MATLAB_ROOT<|
to
MATLAB_ROOT = /home/rtwuser/cross
• COMPUTER = |>COMPUTER<|
to
COMPUTER = <MATLAB_computer_name>
where <MATLAB_computer_name> is the name returned by the MATLAB “computer”
command (for example, GLNX86). There should be no white space at the end of any line you
modified.
This will instruct the template makefile to use /home/rtwuser/cross as your MATLAB tree, and
to build on a Linux machine.
3. Create the Adams target in your working directory (in this example, /home/rtwuser/workbench).
Step 3 - Generate C-code and makefile

Here, assume that the working directory on Windows is C:/pcbench, the location of the Simulink model. We
assume that the working directory on Linux is /home/rtwuser/workbench/.
1. Copy the modified files, rsim_Linux.tmf, rsim.tlc, and adams.tlc, from /home/rtwuser/workbench/
on Linux to C:/pcbench on Windows.
2. Launch MATLAB from C:/pcbench. Open the Simulink model file. On the RTW Page, change the
template makefile to rsim_Linux.tmf.
3. Select Build.
The RTW generates code and a makefile will display, but the executable will not build. You will see
a subdirectory called model_rsim_rtw in your C:/pcbench directory.
4. Copy all files in the build directory on Windows (C:/pcbench/model_rsim_rtw) to the working
directory on Linux (/home/rtwuser/workbench).
44 Adams Controls
You may need to run a dos2Linux utility against the generated code to conform to Linux end-of-line
character standards.
Step 4 - Build RTW dll

1. Enter make -f model.mk in /home/rtwuser/workbench.
2. If there is build failure, you will see error messages. Check to see if there are any Linux end-of-line
symbols in the makefile (in the build directory), header files, and source code files in
/home/rtwuser/cross.
Now you have the library you require for the Linux platform. Continue with the control system import
procedure described in Getting Started Using Adams Controls.
Using Control System Import with MATLAB/Simulink/RTW and Adams

Controls on Two Windows Machines
Note: This procedure applies if you have Adams Controls installed on one Windows machine and
MATLAB/Simulink/RTW installed on another Windows machine.
To import your Simulink model to Adams Controls using RTW:

1. Create a new directory on the machine where Adams Controls is installed, for example, c:/pcbench.
2. Set the MATLAB_ROOT variable in a DOS shell to point to this new directory. For example, enter:
set MATLAB_ROOT=C:/pcbench/
3. Copy the following directories from the MATLAB machine to the directory you just created on the
Adams Controls machine:
• simulink/include
• extern/include
• rtw/c/rsim
• rtw/c/libsrc
• rtw/c/src
• rtw/c/tools
• rtw/c/tlc
4. In the Adams working directory (on the Adams Controls machine), run
<adams_install_dir>/controls/utils/process.py to create the RTW target for Adams Controls.
5. Copy all of the .tmf and .tlc files from the working directory to the directory on the MATLAB
machine where the Simulink model resides.
6. Create the External System Library of the Simulink model on the RTW machine. For specific
instructions, see About Control System Import.
7. Copy the created ESL to the working directory on the Adams Controls machine.
The code generation of the Simulink model now exists on both machines.
8. On the machine where Adams Controls is installed, create the GSE with Control System Import and
run the simulation (see About Control System Import).
Using Control System Import with S-Functions

The following outlines the general steps to generate an External System Library for Control System Import.
For a detailed example, see the Getting Started Using Adams Controls tutorial.
S-Function Support with Source Code

To generate an ESL using an S-Function from source code:
1. Create an S-Function written in C (for example, by using the S-Function Target in Real-Time
Workshop (RTW)).
2. Create Simulink model using S-Function from step 1. It must have the same integrator type (Fixed-
Step vs. Variable-Step) that was specified in step 1.
3. Generate ESL via RTW using Adams Controls-modified RSIM target (all supporting files for S-
Function must be made available, for example, MEX file for S-Function sfunctionname_sf.mexw32
and other source code)
S-Function Support without Source Code

To generate an ESL using S-Function with no S-Function source code:
1. Create an S-Function using S-Function target in the same manner as in steps 1 for "S-Function
Support with Source Code".
2. Use Adams Controls setup_rtw_for_adams script to generate Adams Controls-modified RSIM target.
3. Modify model with S-Function to choose RSIM target from step 2 and build S-Function again - this
will create an object file that can be used in later steps to build the Adams Controls ESL from RTW.
4. Provide the following when distributing the model to the person who will make the Adams Controls
ESL from RTW:
sfunctionname_sf.mexw32
sfunctionname_sf.h
sfunctionname_sfcn_rtw/sfunctionname_sf.h
sfunctionname_sfcn_rtw/sfunctionname_mid.h
sfunctionname_sfcn_rtw/sfunctionname_sid.h
sfunctionname_sfcn_rtw/sfunctionname_sf_private.h
sfunctionname_sfcn_rtw/sfunctionname_sf_types.h
sfunctionname_sfcn_rtw/sfunctionname.mk
sfunctionname_sfcn_rtw/sfunctionname_sf_data.c (if applicable)
modelname_rsim_rtw/sfunctionname_sf.obj
modelname.mdl
5. At the receiver's end, using the files from Step 4, retain the directory structure and place the object
file in the directory of the new model's name, for example,
"newmodelname_rsim_rtw/sfunctionname_sf.obj"
46 Adams Controls
6. Put the S-Function block in modelname.mdl within the new Simulink model (for example,
newmodelname.mdl").
7. Build the ESL using the Adams Controls-modified RSIM target.
Limitations:
If your S-function depends on other modules, this method may fail. You may have to manually add the
dependent modules to the S-function by using the following command:
set_param('Sfunction_blockpath','SFunctionModules','file1 file2 file3')
Where:
 'Sfunction_blockpath' is the path of the Sfunction block.
 'file1', 'file2' and so on are the names of the dependent files.
These details can be found also written for another example here:
 How do I build my model that contains an RTW generated S-function block if I do not have the
source code?
http://www.mathworks.com/matlabcentral/answers/196427
 How do I build my model containing a C-MEX S-function if I don't have the S-function C source
file using Real-Time Workshop?
http://www.mathworks.com/matlabcentral/answers/196428
The overriding rules for working with MATLAB/Simulink/Real-Time Workshop must be followed in use of
S-Functions. Please consult Mathworks and their documentation for more details.
Parameterizing S-Functions for Adams

To parameterize an S-Function for Adams, when building the S-Function block using an S-
Function target, you must:
1. Build the S-Function using the S-Function target in RTW and choose the parameters to be Global
(tunable) Parameters - (that is, Inline, and then choose exceptions -- just as you would for an Adams
ESL)
2. Build the ESL using the Adams Controls-modified RSIM target and again choose the same
parameters to be Global (tunable) Parameters.
The parameters can be generally found in the "_data.c" files, for example, "sfunctionname_sf_data.c" and
"ESL_model_name_data.c" when this is done properly.
For more details on these steps, see the Learning Adams Controls with Control System Import from MATLAB with S-
Functions.
Sample Time Setting of Simulink Source Blocks for Adams Controls Target
of RTW
In Simulink, some blocks in the source library have a parameter Sample Time, which is the interval at which
those block are sampled. Setting sample time in your Simulink/RTW model can change the behavior of the
system, and you should take care to select this. If the Sample Time is zero, the blocks can be sampled at any
time. In real-time applications, or when the simulation is based on explicit and fixed step-size integration, a
nonzero setting of Sample Time makes sense because it controls the progression of the simulation to
guarantee accuracy. Adams Solver integrators usually maintain accuracy with variable-step integrator, error
controls, and step-size settings (for example, HMAX), which is also true when solving the Adams Controls
External System Library (ESL). Thus, the sample rate of continuous states depends on the integrator settings.
At the same time, the sample rate for the blocks in the ESL is maintained with internal calls to GSE_SAMP
to compute non-zero sample times, and GSE_UPDATE to call the sampled blocks. Therefore, you may want
to set the sample time to zero to let Adams Solver sample the block as needed (that is, continuous) instead of
at a specified sample rate. You can confirm the sample rates by looking at the RTW source code generated
for the Simulink model, for example:
Model_rsim_rtw/Model.c:
…
/* Function to initialize sample times */

void MdlInitializeSampleTimes(void)
{
/* task periods */
ssSetSampleTime(rtS, 0, 0.0);
ssSetSampleTime(rtS, 1, 0.001);
/* task offsets */
ssSetOffsetTime(rtS, 0, 0.0);
ssSetOffsetTime(rtS, 1, 0.0);
}
Here, there is one non-zero sample time (0.001) which will set the sample rate in GSE_SAMP. You can
confirm the blocks that use these sample times by searching for the ssIsSampleHit function in this same file.
Finally, setting the Fixed-step size for Simulink can add a sample time to your model, even if it is purely
continuous.
48 Adams Controls
Limitations
The models supported by Adams Controls are firstly limited by those restrictions enforced by
MATLAB/Real-Time workshop itself. Please consult the Mathworks documentation for the official
limitations, but a summary of these can be found next. In addition, Adams Controls has its own limitations
for S-Functions support for ESL creation/use which are also listed.
S-Function Target Limitations

Sample Time Propagation in Generated S-Functions
A generated S-Function block can inherit its sample time from the model in which it is placed if certain
criteria are met. Six conditions that govern sample time propagation for S-functions and for the S-function
code format are described in Inheriting Sample Times in the Simulink documentation. These conditions also
apply to sample times propagated to Model blocks, and are further discussed in Inherited Sample Time for
Referenced Models.
Rapid Simulation Target Limitations

Adams Controls uses a modified version of the RSIM (rapid simulation) target, and an S-Function must be
written in C or C++ to work with the RSim target. The RSim target does not support noninlined M-file,
FORTRAN, or Ada S-functions (inlining means to use an RTW .tlc file to write the code for the S-Function
directly in the generated code).
 The RSim target is subject to the following limitations:
 The RSim target does not support algebraic loops.
 The RSim target does support MATLAB function blocks, if there is no discrete-time block.
However to make this work with discrete-time block, use the below methods.
• Step 1: Generate the S-Function block from RTW by applying the S-Function Target in
Code Generation.
• Step 2: Create Adams ESL from the Simulink model that contains the S-Function block
generated in Step 1.
50 Adams Controls
Limitations
 The RSim target does not support the transport delay block. However to make this work, use the
similar method mentioned in the discrete-time block.
 The RSim target does not support noninlined M-file, FORTRAN, or Ada S-functions.
 If an RSim build includes referenced models (by using Model blocks), these models must be set up
to use fixed-step solvers for code to be generated for them. The top model, however, can use a
variable-step solver as long as all blocks in the referenced models are discrete (variable-step solver not
supported by Adams).
 In certain cases, changing block parameters can result in structural changes to your model that
change the model checksum. An example of such a change would be changing the number of delays
in a DSP simulation. In such cases, you must regenerate the code for the model.
Adams Controls Limitations

1. RSIM Target
a. Models need to have only one output value per outport.
b. Solver Type: Variable-step solver setting in MATLAB recommended; otherwise, Fixed-step
models with no continuous states need to add a continuous block (for example, a dummy
integrator block)
c. Inputs and outputs (ports) must be double variable type (that is, "real_T" in RTW code)
d. Variable-time steps for a variable-step integrator are not supported.
2. RSIM and S-Function Targets
a. Parameters must be double type (that is, "real_T" in RTW code) (From SimulinkGlobal(Auto)
storage class)
b. Target Language must be in C
Choice of Solver Type: S-Function setting for Solver Type must match setting in the model where
it is used. Variable-step solver setting in MATLAB recommended; otherwise, Fixed-step models
with no continuous states need to add a continuous block (for example, a dummy integrator
block)
c. Blocks:
Discrete Pulse Generator: The discrete pulse generator must be time-based, not sample based.
d. Misc
Must have at least one input and one output for the model, even if it is a dummy (for example,
use terminator block to import/outport).
Limitations
 External System Libraries (ESL's) are not guaranteed to be compatible from release to release; you
must rebuild the ESL for each new version of Adams.
 The ESL may be used only once per Control System Import. (Workaround: to use the same model
more than once, create duplicate ESL's with different names and repeat the Control System Import.
This includes copying/renaming a file already generated. Mechatronics excluded from workaround.)
Limitations
 A maximum limit of 100 ESL's can be loaded.

 The name of the ESL is limited to 32 characters Easy5, 200 characters MATLAB/Simulink.
 SAVE and RELOAD are not supported for an External System Library (ESL).
 MATLAB/Simulink and Easy5 Interactive (IS) blocks are not supported (that is, recreated in
Adams).
 "From File" block in Simulink is not supported - see Article KB8016298 "How to prepare a Simulink
model for RTW DLL creation."
 The compiler used by EASY5 or MATLAB/RTW must be the same as that supported by Adams; see
http://www.mscsoftware.com/ for a list of supported compilers.
 Easy5 models may not be implicit.
 Adams Solver (FORTRAN) does not have a bisection method for SENSOR's to improve the
accuracy of the detection of continuous state reset and switch states in Easy5. So, if you have these in
your model, you may improve the accuracy of your simulation by using the C++ Solver instead of
FORTRAN.
Also see the Limitations under the section Using MATLAB/Code Generation.
52 Adams Controls
Limitations
Functional Mock-up Interface (FMI) 55
Adams support for FMI standard
Functional Mock-up Interface (FMI)

Adams support for FMI standard
Functional Mock-up Interface (FMI) is an open standard to support the exchange of simulation models and
coupling between different tools. It provides two user scenarios: Model Exchange and Co-Simulation.
Currently Adams provides the support for FMI 1.0 and 2.0 Co-Simulation (both Master and Slave mode)
and Model Exchange (Master mode).
In the FMI Master mode, Adams could import external models that conform to the FMI 1.0 and 2.0 Co-
Simulation/Model Exchange standard. The model is also called Functional Mock-up Unit (FMU). The user
needs to specify the communication interval in case of co-simulation. The user could then perform
simulation using Adams as the master.
In the FMI Co-Simulation Slave mode, the user could export an Adams model as an FMU, and then use it
in any software which supports the FMI Co-Simulation Master mode.
The FMU file is a zip formatted file which contains a model description file in XML format, a binary file for
the model as well as optional resource files and source codes for the binary file. The model description file
provides information such as input/output and capability flags.
Note: Microsoft Visual Studio C compiler is required on Windows platforms (supported version:
Visual Studio 2017, MSVC toolset version 14.11) and GNU C compiler is required on
Linux platforms for FMU V1 export. Compilers are not required for FMU import and FMU
V2 export.
For more information please refer to https://www.fmi-standard.org/.
Exporting an FMU
Adams model could be exported as an FMU with the FMI 1.0 or 2.0 Co-Simulation Tool standard. This
could be done by using the existing Adams Controls Plant Export dialog box.
56 Adams Controls
Exporting an FMU
You need to specify the Input and Output signals, select the Target Software as FMU and then choose the
communication mode (whether to use TCP/IP, PIPE or DIRECT during the co-simulation). You can select
DIRECT to speed up communication between master and slave. It is available only if the C++ solver is
selected. It should be selected only if the FMU is intended to be imported by a master other than Adams. In
case an FMU that was exported using the DIRECT option for Communication Mode is imported into
Adams, the initialization would fail. Selecting DIRECT mode when exporting the FMU would cause the
output files (like .res, .msg and so on) to not get generated (by default) during simulation run for improving
the overall performance. If these files are required in this mode, then an environment variable called
MSC_ADAMS_REAL_TIME can be set with specified options. This would allow the user to have control
over what files to generate and what not to. The various values which the environment variable can take are
listed below.
 ON - Turns on the "Real Time environment" (no results, no message file, no display, no RTI
reporting).
 OFF - Turns off the "Real Time environment" (yes results, yes messages, yes display and yes timing
info).
 MESSAGESON - Turns on messages/display
Exporting an FMU
 MESSAGESOFF - Turns off messages/display

 RESULTSON - Turns on results generation.
 RESULTSOFF - Turns off results generation.
 CALLBACKON - Enable callbacks
 CALLBACKOFF - Disable callbacks
 LUSINGULAR - Ignore singularities
 TIMING - Turns on RTI report.
 FIRSTRTI - Displays the RTI for the first time step taken.
Different options can be combined as well in the manner shown below.
MSC_ADAMS_REAL_TIME=ON/TIMING/FIRSTRTI
Alternately, the FMU fixed string parameter called "msc_adams_realtime" can also be set to the same values
as above. The value specified by the environment variable takes precedence in case both options are used.
The Include MNF radio button is enabled only if there are flexible bodies in the model that is to be exported
and the Adams solver does not need them. If the solver needs the files, then the radio button is automatically
set to Yes and it is in a disabled state. If there are no flexible bodies, then it is set to No and it is in a disabled
state.
The Real Time FMI Master option is used to select the FMI master in case of real-time simulations. Currently
two real-time FMI masters are supported. SIMulation Workbench® from Concurrent REAL-TIME and
SCALEXIO® from dSPACE. Selecting either of these two disables some options from being set by the user
and are managed internally. When a generic FMI master is to be targeted selecting None would allow
individual settings to be selected.
The Expose Model Parameters button opens another dialog where users can select the parameters to be
included in the FMU. These appear as fixed parameters (not tunable). For more details, refer to the section
Exporting model specific parameters in an Adams FMU.
The Real Time FMI Master option is useful for generating customized FMUs for real time masters. Currently
supported realtime masters are SIMulation Workbench and SCALEXIO. The latter is supported only for
FMU v2.0. The default selection is None, which is equivalent to generating a normal FMU which can be
imported to any FMI master. When realtime master selection is not "None", some values like Adams Solver
Choice and Communication Mode are not available for selection to the end user.
On clicking the OK or Apply buttons, an FMU file will be created in the current working directory with the
name specified in "File Prefix" field and the extension .fmu. A pair of .cmd and .adm file will also be generated
with the same name.
The exporting FMU will have the following capability flags:
canHandleEvents="false" // The slave does not support event handling during co-simulation.
canSignalEvents="false" // The slave cannot provide information about events during a
communication step.
canBeInstantiatedOnlyOncePerProcess="true" // Only one instance per FMU is possible.
maxOutputDerivativeOrder="0" // The slave is not able to provide derivatives of outputs.
58 Adams Controls
Exporting an FMU
canInterpolateInputs="false" // The slave is not able to interpolate continuous inputs.

canHandleVariableCommunicationStepSize="true" // The slave can handle variable
communication step size.
Note: An FMU with DIRECT option for Communication Mode would not work with Adams as
master. A limitation has also been found with Simulink as master. It has currently been
validated to work with FMU Compliance Checker (tool provided by FMI organization for
FMU validation), Easy5 and Concurrent's SIMulation Workbench® (SimWB) as masters.
To use this FMU on a different machine, the alias "adamsXXXX" (where XXXX is the version of Adams, for
example adams2021_0_2) needs to be set up. To do this, on Windows platforms, add
"Adams_installation_path\bin\" (for example, C:\Program Files\MSC.Software\Adams\2021_0_2\bin) to
the User PATH environment variable, which could be found under Control Panel → System → System
Properties → Advanced → Environment Variables.
Exporting an FMU
On linux64 platform, create the alias as specified in the Adams installation guide. It is suggested that the
exporting and importing machine has the same Adams installation path. Otherwise the Adams cannot be
called during a Co-Simulation. Or the user could use TCP/IP instead of PIPE as the communication mode.
The addition of the Adams installation path to the PATH environment variable in Windows is performed
automatically by the installer. Similarly, the creation of the alias in Linux is automatically performed by the
installer when being installed as root. If the above are not done automatically due to some permission issues
on the PC, then these steps have to be taken care of manually using the above prescribed procedure.
To use TCP/IP, the Adams Host Name should be set correctly and adams_daemon.py should be running on
the host machine. The adams_daemon.py could be found under "Adams_installation_path\controls\utils\"
60 Adams Controls
Default tunable parameters in an Adams FMU
(for example, C:\Program Files\MSC.Software\Adams\2021_0_2\controls\utils\). To run the

adams_daemon.py, see Using TCP/IP in the help document.
After the Co-Simulation, the Adams FMU generated result files could be found in the resource directory of
the extracted FMU. This is decided by the software importing the Adams FMU. For example, if the Adams
FMU is imported into another Adams session, the extracted FMU could be found in the current working
directory. Other software may use the user temporary directory.
Running an Adams FMU with Simulink as master

An Adams FMU with PIPE and TCP/IP options for Communication Mode is supported on all Operating
Systems that Adams supports when used with Simulink as a master (Simulink FMI Import block). A
limitation exists using DIRECT for communication mode. A complete overview is found in the table below.
Operating System Simulink as master (FMI import block - Adams FMU)

PIPE TCP/IP DIRECT
Windows 7 SP1 X X
Windows 10 X X
Linux RH 7.3/7.5 X X X
Linux SUSE 12 SP1/2 X X
Default tunable parameters in an Adams FMU

Adams FMU (V2) supports the below default tunable parameter which can be modified by the master during
initialization phase of the FMU or during the simulation (effect takes place at next communication point).
Parameter
Name Data Type Possible Values Default Value Description
pause_simulat Boolean TRUE FALSE The FMU does not step and
ion returns the old values of
FALSE outputs when this value is
True. When it is False, the
FMU process the inputs,
internally steps the model and
returns the new outputs.
Default fixed parameters in an Adams FMU

Adams FMU supports the below default parameters which can be modified by the master during
initialization phase of the FMU. Once an FMU is initialized, these cannot be modified.
Parameter
pause_simulat Boolean TRUE FALSE The FMU does not step and
ion returns the old values of
FALSE outputs when this value is
True. When it is False, the
FMU process the inputs,
internally steps the model and
returns the new outputs.
output_rate Integer Any value in integer range As specified in the This is the multiplier which is
plant export dialog applied to the communication
box interval between master and
slave which determines the
interval at which Adams
output files (.res) are written.
This is also dependent on
another parameter, namely
communication_scale. Output
files are updated at the period
determined by communication
interval *
communication_scale*output_
rate
solver_selectio Enumeration 1 (F77 solver) As specified in the Specifies the solver that is to be
n plant export dialog used by the Adams FMU
2 (CXX solver) box
communicatio Enumeration 1 (PIPE) As specified in the Specifies the communication
n_mode plant export dialog mode to be used between the
2 (TCP/IP) box master and slave. Note that
DIRECT mode can be used
3 (DIRECT)
only with non-Adams masters
and with CXX solver
62 Adams Controls
Parameter
communicatio Integer Any value in integer range 1 This specifies the scaling factor
n_scale between the master and the
slave.
initial_static_a Boolean TRUE As specified in the This specifies whether Adams
nalysis plant export dialog should run a static analysis
FALSE box before the dynamic simulation.
initialize_inpu Boolean TRUE TRUE This specifies whether Adams
ts_to_zero should retain the initial values
FALSE of inputs as specified in the
model or they should be set to
zero. Default behavior is to
initialize them to zero.
initial_warmu Boolean TRUE TRUE if FMU is This specifies whether a short
p_analysis exported using dynamic analysis is to be
FALSE communication_mo executed before the actual
de as DIRECT. analysis. This is useful in real-
time scenarios to prime the
FALSE otherwise solver and avoid initial
overruns.
solver_thread Boolean TRUE FALSE This option works only when
_stats running Adams on
FALSE Concurrent's SimWB. It
displays the statistics of
different solver threads and is
useful for debugging to find out
where more time is being used.
Parameter
adams_path_f String Any string value Empty string This is used to specify the
or_fmu Adams installation path that is
to be used by the FMU
(typically used if FMU is
exported with one version of
Adams and is to be used with a
different version). This obviates
the need for setting the
environment variable
"ADAMS_PATH_FOR_FMU
". The environment variable, if
set, takes precedence over this
value and is useful for FMI
masters that do not support
strings.
thread_affinit String String values that contain Empty string Specifies the processor affinity
y_set0 numbers (indicating for set0 threads as comma
cores/processors) separated by - separated individual values or a
or , range. For example, if five
threads are to run on cores
1,2,3,5,7 this can be specified
as 1-3,5,7. See section Thread
Affinity Settings in Adams for more
information.
thread_affinit String String values that contain Empty string Specifies the processor affinity
y_set1 numbers (indicating for set1 threads as comma
cores/processors) separated by - separated individual values or a
or , range. Note that this parameter
is currently not being utilized
by Adams Solver in real time.
64 Adams Controls
Parameter
msc_adams_re String String values in ON, OFF, Empty string Specifies the string settings
altime MESSAGESON, which determine if the output
MESSAGESOFF, files are generated or not and if
RESULTSON, so what output files are
CALLBACKON, generated. Individual values in
CALLBACKOFF, the specified set of values or a
LUSINGULAR, combination of values
RESULTSOFF, TIMING, separated by / can be used. This
FIRSTRTI. obviates the need for setting the
environment variable
"MSC_ADAMS_REAL_TIM
E". The environment variable,
if set, takes precedence over this
value and is useful for FMI
masters that do not support
strings.
adams_hostna String Any string value. Host name of the This is used to override the
me PC from which default host name that specifies
FMU is exported the PC where Adams would
run (typically the same PC
from where the FMU is
exported). The host name or IP
address of some other PC can
be specified which has Adams
installed.
input_interpo Enumeration FMI V1 FMI V2 1 for FMI V1 This can be used to specify the
lation_order 1 (zero order) 0 (zero order) interpolation order for Adams
0 for FMI V2 slave inputs. Accordingly, the
2 (Linear) 1 (Linear)
solver interpolates the value
3 (Quadratic) 2 (Quadratic) before using it every step.
4 (Linear least 3 (Linear least
squares) squares)
Parameter
output_extrap Enumeration FMI V1 FMI V2 1 for FMI V1 This can be used to specify the
olation_order 1 (zero order) 0 (zero order) extrapolation order for Adams
0 for FMI V2 slave outputs. This works only
2 (Linear) 1 (Linear)
if the communication_scale is
3 (Quadratic) 2 (Quadratic) greater than 1.
4 (Linear least 3 (Linear least
squares) squares)
animation Boolean TRUE TRUE if "Real Time This is used to enable real-time
Animation" radio animation with Adams. It is
FALSE button is set to On available only for non-Adams
in the Real Time View products (like Adams
Animation Settings Car, Adams Driveline and so
dialog before on)
performing a files
only analysis in
Adams Car, Adams
Driveline and so on,
FALSE otherwise.
rta_hostname String Any string value localhost This is used to specify the host-
name of the PC on which the
real-time animation would run.
It is available only for non-
Adams View products (like
Adams Car, Adams Driveline
and so on)
mtl_file String Any string value that points to mdids://acar_shared This is used to specify the
the material file path (in the /shell_graphics.tbl/a material file that is to be used
format required by ACar). dams_vtd_mat.mtl for real-time animation. It is
available only for non-Adams
View products (like Adams
Car, Adams Driveline and so
on)
startup_time Real Any real value 5.0 This specifies the startup time
for the real-time animation and
the units is seconds. It is
available only for non-Adams
on)
66 Adams Controls
Exporting model specific parameters in an Adams FMU
Parameter
sample_time Real Any real value 0.01 This specifies the
communication frequency
between Adams and the real-
time animation component.
Units is seconds. It is available
only for non-Adams View
products (like Adams Car,
Adams Driveline and son on)
road_grid_size Real Any real value 200 This specifies the grid size of
the road for real-time
animation and units are in m. It
is available only for non-Adams
on)
road_grid_spa Real Any real value 1 This specifies the grid spacing
cing of the road for real-time
animation and units are in mm.
It is available only for non-
Adams View products (like
Adams Car, Adams Driveline
and so on)
Solver_thread Integer Greater than 0 and preferably As specified in the This setting overrides the
_count limited to the number of cores model settings thread count specified in the
available in the PC during plant export model during plant export as
long as the newly set value is
greater than 0.
initialSpeed Real Any real value As specified in the This specifies the initial speed
event during of the vehicle. It is available
files_only analysis only for non-Adams View
before a plant export products (like Adams Car,
Adams Driveline and so on)

Adams supports including model specific parameters into the FMU. These appear as fixed parameters. Upon
clicking the Expose Model Parameters button in the Plant Export dialog box, a new dialog opens in which
users can select the parameters to be included in the FMU. The dialog is different for AView and ACar models
and are shown below. Once the new dialog is opened, the Plant Export dialog box is disabled until the user
either clicks on OK or Cancel or closes this new dialog box.
In AView models, the parameters that are allowed to be exported are design variables, points and mass
properties of parts. The model name is to be selected first. Subsequently, user can add individual parameters
in the respective fields by right-clicking on the field and selecting the parameters or by clicking on the Add
All button which populates all parameters in all fields. Alternately, users can also add all parameters of a
particular type (for example, all design variables, all points or all mass properties) by clicking on the buttons
at the respective fields. Design variables of type integers, real and strings are supported. Point locations (x, y
and z) are created as separate parameters of real type because the FMI can only support scalar types. Mass
properties defined by user or by density are supported. Mass properties of parts defined by material are not
supported. Individual parameters like mass, density, ixx, iyy, izz, ixy, iyz and izx are created for each selected
part.
Figure 1 Parameter selection dialog for AView based models
In ACar models, the parameters that are allowed to be exported are assembly variants, analysis events, hard
points, mass properties of general parts, parameter variables, UDE design variables and property files. The
individual parameters created for general parts, parameter variables and hard points are same as for AView
based models. The design/instance design variables of UDEs and property file variables are supported
additionally for ACar.
Once this dialog box is opened, the individual tabs are visible and the subsystems for the active variant are
seen. To modify the active variant to be used, user has to first select the desired variant (if any exist) from the
drop down menu and click on the arrow ( ). Only on clicking the arrow, the subsystems for individual
68 Adams Controls
categories are displayed. A subsystem is displayed in the particular tab only if it has parameters of the
corresponding type. Users can click Add All to add all parameters of a particular type. Alternately, the buttons
beside the individual subsystems can be clicked to select all parameters of that particular type in that
subsystem. Another method is to right-click on the field and manually select the parameters. For UDEs, the
design/instance design variables are not displayed in this dialog. Instead, only the UDE is displayed. The
design/instance design variables are internally found and added.
Figure 2 Parameter selection dialog for ACar based models
Once the user completes the selection of parameters and clicks OK or Cancel, the Plant Export dialog box is
enabled again and the saved parameters are exported as part of the FMU.
Importing an FMU
Importing an FMU
An external FMU could be loaded in Adams by using the Adams Controls System Import dialog box. The
FMU should conform to FMI 1.0 or 2.0 Co-Simulation or Model Exchange standard. Currently Adams
cannot handle events during co-simulation, nor does it support interpolation/extrapolation. Adams will not
allow string inputs, outputs or parameters.
To import an FMU into Adams, simply choose the FMU in the External System Library field. The Output
and Input signals should be selected using Existing Controls Plant or from Poutput/Pinput.
The Communication Interval should be set according to the frequency of interest of the FMU model (above
the Nyquist Frequency). The Visibility specifies whether the importing FMU could be visible or not during
the Co-Simulation (needs to be supported by the importing FMU). If the imported FMU belongs to Adams,
then after the simulation, GUI of the imported FMU would not be closed automatically. It would remain
open so that users can continue perform other simulation activity by interacting with the FMU master Adams
window. The GUI of the imported FMU does not support any user interaction. It automatically gets closed
once user resets the simulation from the FMU master Adams window.
The Communication Interval and Visibility fields are automatically disabled if the imported FMU is of
Model Exchange type. If the FMU supports FMI 2.0 and supports both Model Exchange and Co-
Simulation, the user would be presented with an option to choose the kind of simulation that is to be run.
Accordingly, the corresponding simulation would be executed.
The imported FMU will be extracted in the current working directory under /fmu/<General State Equation
Name>/.
70 Adams Controls
Importing an FMU
There are two default parameters created under the GSE (general state equation) when importing a co-
simulation FMU. They are listed below.
1. adams_master_communication_interval - This allows users to dynamically modify the
communication interval between two different simulation runs without having to delete the GSE and
reimport the FMU which creates a new GSE.
2. adams_master_output_extrapolation_order - This allows users to dynamically modify the
extrapolation order between two different simulation runs without having to delete the GSE and
reimport the FMU which creates a new GSE.
In addition to the above two default parameters, any parameters exposed by the FMU are also created as
design variables underneath the GSE. Currently, the supported data types are integer, real, Boolean and
Enumeration. Strings are not supported during FMU import. If an FMU contains string parameters, they
are ignored and the corresponding variables are not created underneath the GSE. All variables are created as
real data type in the GSE irrespective of the data type in the FMU. The data type translation is handled
internally when setting/getting the parameter values.
If an Adams exported FMU is to be imported into a different version of Adams than with which it was
exported, an environment variable "ADAMS_PATH_FOR_FMU" needs to be set with a value containing a path
to the Adams installation with which it is to be imported. This feature is applicable only to FMUs exported
with Adams 2017.1 and higher. Alternately, the FMU fixed string parameter "adams_path_for_fmu" can also
be modified to point to the Adams path. This parameter is applicable only to FMUs exported with Adams
2019 and higher. The value specified in the environment variable takes precedence in case both options are
used.
For example, consider a scenario where FMU was exported with Adams 2017 and is to be imported and run
in Adams 2017.1. The installation path for Adams 2017.1 is "C:\Program
Files\MSC.Software\Adams\2017.1". Then user has to set the environment variable
"ADAMS_PATH_FOR_FMU" to the value "C:\Program Files\MSC.Software\Adams\2017.1". This would
enable the FMU exported with Adams 2017 to run with Adams 2017.1. Otherwise, it would run only with
Adams 2017 (version with which it was exported).
When the FMU is exported for FMI V1.0, then that FMU can be imported only on the platform with which
it was exported. For example, if the FMU is exported on Windows, it can only be imported on Windows and
similarly if it is exported on Linux, it can be imported only on Linux.
In case an FMU is exported for FMI V2.0, then the same FMU can be imported in both Windows and Linux
platforms. The only condition that needs to be met during import is that the same version of Adams needs
to be used and the alias needs to be set (see the Exporting an FMU section for more details on setting of the alias).
If a different Adams version is used during import, then the ADAMS_PATH_FOR_FMU environment variable
needs to be defined or the FMU fixed string parameter "adams_path_for_fmu" needs to be set as mentioned
above.
Integration with Vertical Products 63
Integration with Vertical Products

Adams Mechatronics
Features in Adams Mechtronics may be attractive to Adams Car users who want to use Adams Controls.
Adams Mechatronics is a plug-in to Adams which can be used to easily incorporate control systems into
mechanical models. Adams Mechatronics has been developed based on the Adams Control functionality and
contains modeling elements which transfer information to/from the control system. For example, using
Adams Mechatronics in Adams Car, you can quickly create assemblies of vehicle systems including control
systems, and then analyze them to understand their performance and behavior. Adams Mechatronics enables
you to work faster and smarter with control systems, letting you have more time to study and understand
how design changes as well as changes in the controls systems affect the total mechanical model performance.
From a modeling perspective, Adams Mechatronics has following benefits:
 A control system has to be setup and coupled only once.
 Control systems and control signals are handled as components among others.
 The model can easily be used by different users, including those who are not familiar with the
control systems.
 Automatic signal unit conversions.
 Easy to connect transducer and actuator signals to the control systems.
 Overview and modify the control system input and output specifications.
For more information, see the Adams Mechtronics documentation.
For the latest information on integrating Adams Controls with Adams Car, refer to the Adams Technical
Articles at http://simcompanion.mscsoftware.com.
64 Adams Controls
Examples 65
Tutorials and Examples
Examples
The following Adams Controls examples are available:
 Getting Started Using Adams Controls - Gives you an overview of the four-step process of adding controls
to an Adams model. The example also includes tutorials for each of the controls applications you can
use with Adams Controls: Co-simulation, Function evaluation, and Control System Import with
both Easy5 and MATLAB.
 MSC Software Simcompanion Article KB8016239 - Various examples of Adams Controls features:
• Using Adams Solver (C++) with Adams Controls in an Easy5 co-simulation
• Performing a design study with an Adams External Systems Library (ESL) containing Easy5
parameters and requests
• Generalized communication using TCP/IP
• Improved performance of co-simulation through first-order interpolation
 MSC SoftwareSimcompanion Article KB8014597 - A list of links to several articles in our Knowledge Base
dealing with Adams Controls.
 install_dir/ainsight/examples/ain_tut_110_asc_mat.txt - Studies the control system of a linearized model
using the Adams Insight ASCII conduit and MATLAB.
 install_dir/ainsight/examples/ain_tut_102_asc_aco.txt - Studies the control system using the Adams Insight
ASCII conduit and Adams Controls.
66 Adams Controls
Dialog Box - F1 Help
Adams Controls Plant Export
Controls → Plant Export
Exports the Adams plant files. Adams Controls saves the input and output information in an .m (for
MATLAB) or .inf file (for EASY5). It also generates a command file (.cmd) and a dataset file (.adm) that are
used during the simulation process. Adams could also export the model as a .fmu file (Functional Mock-up
Unit or FMU) that follows the FMI standard.
For the option: Do the following:

Tips on Entering Object Names in Text Boxes
Tips on Entering File Names in Text Boxes

Controls Plant selection Specify whether you are creating a new controls plant or modifying an
existing one. Enter the name of the new or existing plant in the text box
to the right.
File Prefix Enter the prefix for the .adm, .cmd, .acf, .m, and .inf files that Adams
Controls creates.
Initial Static Analysis Select one of the following:
 Yes: Performs initial static analysis.

 No: Does not perform initial static analysis.
Note: If Initial Static Analysis is set to Yes and Type is set to linear,
Adams Controls performs a static analysis before the linear
analysis. Otherwise, Adams Controls performs an initial
conditions analysis.
Initialization Command Check if you want to enter Adams View or Adams Solver non-time
advancing (NTA) commands that you want to have executed before the
co-simulation or function evaluation starts. In the text box that appears,
enter one NTA command. To execute more than one NTA command,
create an .acf file and refer to it using the FILE/COMMAND =
command_file_name string in this text box.
Import Settings from Existing Select to display the Database Navigator, where you can choose an
Controls Plant existing controls plant whose settings you want to use in your current
plant. Adams Controls updates the Adams Controls Plant Export dialog
box with the appropriate settings.
Input Signals Enter names of state variables that you want to use as plant inputs. Select
From Pinput to enter state variables from existing plant inputs.
68 Adams Controls

Output Signals Enter names of state variables that you want to use as plant outputs.
Select From Poutput to enter state variables from existing plant outputs.
Re-order Adams Inputs The reorder of plant inputs and outputs change the order of the signals
Signal(s)/Re-order Adams in the PINPUT and POUTPUT entities. This is useful when you
Output Signal(s) already created the PINPUT and POUTPUT entities and at a later
point in time (during plant export) would like to reorder the signals
within them.
Important: The order of signals should be same during plant export

and plant import. Otherwise, simulation could fail and
produce undesired results.
Target Software Select one of the following:
 Easy5
 MATLAB
 FMU - Creates a Functional Mock-up Unit that follows the
FMI standard.
Analysis Type Select one of the following:
 linear - Creates a linearized representation of the model in terms

of (A, B, C, D) matrices. A linear analysis is performed. For
Target Software of FMU, this option is not supported.
 non_linear - Exports plant for dynamic analysis.
Adams Solver Choice Select one of the following:
 Fortran - Uses the default Adams Solver (FORTRAN) for this

simulation.
 C++ - Uses Adams Solver (C++) for this simulation.
User Defined Library Name Enter the name of the user-defined library.
Adams Host Name Enter the name of the host machine from which the Adams plant is
being exported. This host name is used if you choose TCP/IP-based
communication to perform cosimulation or function evaluation
between Adams and MATLAB, Easy5 or FMU.
Dialog Box - F1 Help 69

Communication Mode This option is only available for FMU target software. The different
possible modes of communication are PIPES/TCP-IP or DIRECT.
PIPES mode of communication requires the Adams and the FMU
master to run on the same PC. TCP/IP allows you to run Adams on one
workstation while running FMU Master on a second networked
machine of the same or different architecture. DIRECT mode is
applicable only with the C++ solver. This option only works when
Adams is not the master. If an Adams FMU is exported with this option
and is imported into Adams for execution, then initialization of the
FMU would fail.
Dynamic State Output Dynamic States Output performs an initial conditions analysis or a static
analysis (if Initial Static Analysis is set to Yes), and computes the number
of states (that is, displacements, velocities) in the model. This is used by
Easy5 for Function Evaluation mode. If your model has difficulty
computing this properly, you can disable this feature, but you will not be
able to use Function Evaluation mode unless the number for NUMBER
OF STATES is modified in the .inf file from Plant Export.
Include MNF This option is available only when the target software is selected as FMU
v1 or v2. It provides the user an option to either include the mnf files or
exclude them from the FMU. These are used for the animation of the
flex bodies in the model. Excluding these files could reduce the size of
the FMU considerably. It is enabled only when there are flex bodies in
the model and when there are no flex body contacts. If there are no flex
bodies in the model, then it is disabled and set to a value of "No" by
default. If there are flex body contacts in the model, then it is disabled
and set to a value of "Yes" by default.
Real Time FMI Master This option is available only when the Target Software is selected as
FMU v1.0 or v2.0. It is used to select the software package that acts as
the real-time FMI master. It is to be used only for real-time simulations.
The currently supported real-time FMI masters are SIMulation
Workbench® from Concurrent REAL-TIME and SCALEXIO® from
dSPACE. If None is selected, then the FMI master is any generic master
which supports the FMI specification.
70 Adams Controls

Output Rate This option is available only when the target software is selected as FMU
v1 or v2. It takes an integer value which specifies a multiplier of the
communication interval between master and slave for writing the Adams
results to file.
This button is enabled when the Target Software is selected as FMU v1.0
or FMU v2.0. Clicking on this button opens up a dialog where model
parameters can be selected for export. Currently design variables, points
and mass properties are supported in AView models. Parameter variables,
hard points, mass properties, UDE design variables and property files are
supported in ACar models.
Real Time FMI Master This selection is visible only if the "Target Software" selection is either
FMU v1.0 or FMU v2.0. When FMU v1.0 is selected, the options are
None and SIMulation Workbench. When FMU v2.0 is selected, the
options are None, SIMulation Workbench and SCALEXIO. Selection of
"None" results in a generic FMU being generated that can be used in
non-realtime environments. Options like "Adams Solver Choice" and
"Communication Mode" are enabled and are available for selection.
Selection of either "SIMulation Workbench" or "SCALEXIO" results in
an FMU customized for the corresponding real-time FMI master. In this
case, the options like "Adams Solver Choice" and "Communication
Mode" are unavailable for selection.
Adams Controls System Delete
Adams Controls System Delete

Controls → Controls System → Controls System Delete
Deletes the general state equation (GSE), its associated arrays, and the dependency on the Adams model.

Model Enter the name of the model.
General State Equation Name Enter the name of the GSE you want to delete.
Adams Controls System Import

Controls → Controls System → Controls System Import
Imports a control system into your Adams model as a general state equation (GSE).

Tips on Entering File Names in Text Boxes

Model Enter the name of the model.
General State Equation Name Enter the name of the GSE to be created.
External System Library Enter the name of the external system library. If the extension entered
is .fmu, Adams will expect an FMU that conforms to the FMI standard.
Import I/O Signals from Select to display the Database Navigator, where you can select an
Existing Controls Plant existing controls plant from which output and input signals are to be
imported.
From Poutput Select to display the Database Navigator, where you can select an
existing poutput from which to import output signals.
For more information on creating plant outputs, see Data Element

Create Plant Output.
From Pinput Select to display the Database Navigator, where you can select an
existing pinput from which to import input signals.
For more information on creating plant inputs, see Data Element

Create Plant Input.
72 Adams Controls

Re-order Adams Inputs The reorder of plant inputs and outputs change the order of the signals
Signal(s)/Re-order Adams in the PINPUT and POUTPUT entities. This is useful when you
Output Signal(s) already created the PINPUT and POUTPUT entities and at a later
point in time (during plant export) would like to reorder the signals
within them.
Note: The order of signals should be same during plant export and
plant import. Otherwise, simulation could fail and produce
undesired results.
Static Hold Select one of the following:
 Off: Turns static hold off.

 On: Turns static hold on.
For more information on static hold, see GSE statement.
Use External System Library Check to apply the error tolerance values of the continuous states of
Error Tolerance ESL to the GSE during integration. The ESL error tolerance values
change the computation of the local integration error that is computed
after the corrector as converged. If the estimated error is greater than the
specified integration ERROR the integrator rejects the solution. See the
INTEGRATOR statement for more details about ERROR. You may
want to use this feature to help refine the accuracy of your ESL states,
but just like any INTEGRATOR setting, this may require tuning. This
feature only applies to the C++ Solver, and only Easy5 models currently
report error tolerance values.
Error Scale Factor: Values > 0 will scale all of the ESL error tolerance
values in order to tighten or loosen these values, that is, Final GSE error
tolerance = Error Scale Factor * ESL error tolerance
Values <= 0 will disable using the ESL error tolerance values, and the
default computation for the local integration error will be used.
Information Check to display verbose information about the general state equation
(GSE) that the controls system import created.
Communication Interval This option is only enabled for External System Libraries of type FMU
co-simulation. For co-simulation with the FMU, you need to specify
the communication interval. Sample the FMU at least two times faster
than the highest frequency of interest (refer to Nyquist frequency). This
option is disabled for FMU of type model exchange and other ESLs
exported using MATLAB or Easy5.

Visibility This option is only enabled for External System Libraries of type FMU
co-simulation. Visibility means the FMU runs in interactive mode.
Turn it off if you want to run it in batch mode. In order for this option
to work in Adams, visibility needs to be supported by the specified
FMU.
Overwrite PINPUT Functions Check to overwrite the values of any existing PINPUT functions in the
GSE. Default is to add to the existing values.
One caveat when checking this option is that, if the same PINPUT
variable is updated by multiple ESLs, then only the last imported ESL
value would be retained.
ESL Output Extrapolation This option is only enabled for External System Libraries of type FMU
Order co-simulation. When Adams is acting as master in a co-simulation, this
would allow the outputs of the FMU (inputs of Adams) to be
extrapolated and used by Adams during its integrator step. Currently
supported extrapolation orders are 0, 1, 2 and 3. (that is, zero order
hold, linear, quadratic and linear least squares)
74 Adams Controls
Select Assembly Parameters for Export to FMU
Select Assembly Parameters for Export to FMU

(Standard Interface) Simulate → FMI Interface → General FMU Export → Expose Model Parameters
(Standard Interface) Simulate → FMI Interface → Real Time Analysis → Expose Model Parameters
(Standard Interface) Controls → Plant Export → Expose Model Parameters
(Standard Interface) Mechatronics → Tools → Export Plant → Expose Model Parameters

Select assembly parameters of a specific variant for export to FMU. The parameters include hard points, mass
properties, parameter variables, UDE design variables and property files.

Assembly Select the Assembly to export.
Assembly Variant Select the variant in the assembly to export.
Expose Assembly Variant Select to allow the FMI master to switch between assembly variants.
Expose Events Select to allow the FMI master to switch between analysis events. Events
must be defined prior to exporting the FMU.
Hardpoints
Add All Click this to auto-select all hardpoints in the entire assembly.
For each subsystem and testrig in the assembly that contains

hardpoints, a toggle-button and a field will be created. In the field any
number of hardpoints can be entered. The button will add all
hardpoints from the current subsystem into the field.
Mass Properties
Add All Click this to auto-select all general parts and wheels in the entire
assembly.
For each subsystem and testrig in the assembly that contains general
parts or wheels, a toggle-button and a field will be created. In the field
any number of general parts or wheels can be entered. The button
will add all general parts from the current subsystem into the field.
Parameter Variables
Select Parameters for Export to FMU

Add All Click this to auto-select all parameter variables in the entire assembly.
For each subsystem and testrig in the assembly that contains parameter
variables, a toggle-button and a field will be created. In the field any
number of parameter variables can be entered. The button will
add all parameter variables from the current subsystem into the field.
User Defined Elements (UDEs)
Add All Click this to auto-select all user defined elements in the entire assembly.
For each subsystem and testrig in the assembly that contains user
defined elements (UDEs), a toggle-button and a field will be created. In
the field any number of UDEs can be entered. The button will
add all UDEs from the current subsystem into the field.
Note: Only UDEs having variables in the design parameters vector

will have variables exposed in the sheet. If a UDE is selected
which has no such variables it is ignored.
Property Files
Add All Click this to auto-select all property file variables in the entire assembly.
For each subsystem and testrig in the assembly that contains property
file variables, a toggle-button and a field will be created. In the field any
number of property file variables can be entered. The button will
add all property file variables from the current subsystem into the field.
The property file variable may hold a list of property files. Property files
can be added or removed via the Property File field in the dialog box
(for example, Modify Bushing). Each property file in this list will be
copied into the FMU and is referenced by the enumerator value in the
model description file, as packaged in the FMU. The description field
in this file holds the name and index of each property file. Modifying
the enumerator value allows to change the property file while executing
the FMU.

Controls → Plant Export → Expose Model Parameters
Mechatronics → Tools → Export Plant → Expose Model Parameters

Select model parameters for export to FMU. The parameters include design variables, points and mass
properties.
76 Adams Controls

Model Name Select the model to export if more than one model is opened. The active
model is the default model.
Add All Click this to auto-select all design variables, points and mass properties
in the model.
Design Variables
Design Variables Click this to auto-select all design variables in the model.
Points
Points Click this to auto-select all points in the model.
Mass Properties
Mass Properties Click this to auto-select all general parts in the model.
Appendix
Entering File Names in Text Boxes
To enter file names in text boxes, you can do either of the following:
 Enter the file name directly in the text box.
 Clear the text box and then double-click to open a selection window.
 Right-click to either:
• Search a database
• Browse a database
Entering Object Names in Text Boxes

To enter object names in text boxes, you can do either of the following:
 Enter the object name directly in the text box.
 Clear the text box and then double-click to open the Database Navigator.
 Right-click to either:
• Pick an object shown on the screen.
• Browse a complete list of available objects.
• Choose from a product-generated list of guesses.
74 Adams Controls
Entering Object Names in Text Boxes

Adams 2021.0.2 Adams Controls User Guide

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Adams 2021.0.2 Adams Controls User Guide

Uploaded by

Copyright:

Available Formats

Adams 2021.0.

Welcome to Adams Controls

Benefits of Adams Controls

How to Improve the Design Process with Adams Controls

Ways to Use Adams Controls

Using co-simulation or Function Evaluation:

Using Control System Import:

About the Adams Controls Four-Step Process

Adams Input Adams Adams Output

Adams Controls Overview

To start Adams Controls:

To unload the Adams Controls plugin:

Getting Started Using Adams Controls

Control System Import

Plant Inputs and Outputs

Exporting Adams Controls Plant Files

To export Adams Controls plant files:

Installing the Adams Extension for Easy5

To install the Adams extension for Easy5:

4. Type exit to close the command window.

Note: Check http://simcompanion.mscsoftware.com to find the versions of Easy5 that are

To apply the value of the environment variable:

Easy5 Update of Adams Controls Extension Components

Update Process Details

Co-Simulation and Function

Method: Its purpose:

Co-Simulation and Interpolation/Extrapolation

Step 3 - Options for Adams Controls Plant Outputs

Example: Antenna Model

Plot of control torque:

To create a user library:

Starting the Adams Daemon Process

To start the Adams daemon process:

This script can be invoked in the following ways:

Note: $adams_alias is the adams command line alias

• On Linux: adams2021_0_2 -c python adams_daemon.py exit

Running Adams with MATLAB

Running Adams with Easy5

2. To save your settings, select OK.

Using Time Offset with Matlab

Note: This functionality is available in co-simulation with Matlab/Simlink only.

Figure 3 Enabling the Adams block only when t A ≥ 0

Control System Import

To import an External System Library:

Setting External System Library Error Tolerance

Removing External System Library

Using MATLAB/Code Generation

Exporting Parameters in Simulink/Code Generation Models to Adams

Step 1 - Define the parameters in MATLAB workspace

Step 2 - Reference the Kp and Kv in the Simulink model

Step 3 - Define the proper storage class for parameter export

extern Parameters rtP; /* parameters */

/* Block parameters (auto storage) */

Using Control System Import with MATLAB/Simulink/RTW on Windows and

Step 1 - Create MATLAB tree on Linux to build RTW library

Step 2 - Create makefile and C-code template on Linux

Step 3 - Generate C-code and makefile

Step 4 - Build RTW dll

Using Control System Import with MATLAB/Simulink/RTW and Adams

To import your Simulink model to Adams Controls using RTW:

Using Control System Import with S-Functions

S-Function Support with Source Code

S-Function Support without Source Code