Welcome to Adams/Controls 1

Welcome to Adams/Controls
2 Adams/Controls
About Adams/Controls

About Adams/Controls
Adams/Controls, part of the MD Adams 2010® suite of software, is a plugin to MSC.Software’s
Adams/Car, Adams/Chassis, 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®.
 Welcome to Adams/Controls 3
Benefits of Adams/Controls

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.
4 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 5
Ways to Use Adams/Controls

Ways to Use Adams/Controls

You can use Adams/Controls in the 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.

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.
6 Adams/Controls
About the Adams/Controls Four-Step Process

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 Input Controls Output

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

Adams/Controls Overview
8 Adams/Controls
Loading Adams/Controls

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 UNIX, type the command 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 MSC.Software, point to MD
Adams 2010, point to AView, and then select Adams - View.
The Welcome dialog box appears, in the Adams/View main window.
2. From the Welcome dialog box, select Import a file, and then select OK.
3. Select the file you want to import.
4. In the Select File dialog box, select OK.
5. In the File Import dialog box, select OK.
The model appears in the Adams/View main window.
6. Load Adams/Controls by doing the following:
• From the Tools menu, point to Plugin Manager.
• Select the Load check box next to Adams/Controls.
• Select OK.
Adams/Controls is now loaded.

To unload the Adams/Controls plugin:

1. From the Tools menu, point to Plugin Manager.
2. Clear the Load check box next to Adams/Controls.
3. Select OK.
 Adams/Controls Overview 9
Getting Started Using Adams/Controls

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 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.
10 Adams/Controls
Simulation Methods

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. 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 generated by MATLAB/Real-Time
Workshop or Easy5. The ESL is used by automatically creating a General State Equations (GSE) entity
in Adams. 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 No Yes Yes
asynchronous 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 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.
 Adams/Controls Overview 11
Simulation Methods

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://support.adams.com/kb/faq.asp?ID=kb10371.html.

Control System Import

In this mode, you can import into Adams a C-code representation of the control system built in Easy5 or
MATLAB. To do this, you have to first export a C language representation of the control system using
XFE or Real-Time Workshop. Adams/Controls then allows you to create, in an automated manner, a
general state equation (GSE) element in your Adams model and an object library from this C code. After
this is done, you can simulate your combined model in Adams.
12 Adams/Controls
Plant Inputs and Outputs

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 by the Plant Export dialog box, or created by using Build > Data Elements > Plant
Input/Plant Output > New.
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.
 Adams/Controls Overview 13
Exporting Adams/Controls Plant Files

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:

1. From the Controls menu, select Plant Export.
2. Complete the Adams/Controls Plant Export dialog box as described in Adams/Controls Plant
Export.
3. Select OK.
14 Adams/Controls
Using Easy5

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.

To install the Adams extension for Easy5:

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. Identify the command line command used to start the Adams version you will use with Easy5, for
example, mdadams2010.

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 in the following steps.

4. Perform the following, depending on your platform:

On UNIX:
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 adams_command
where adams_command is the command line command from Step 3 above.
On Windows:
a. From the Start menu, point to Programs, point to MSC.Software, point to EASY5 2008r1,
point to Shell, and then select Easy5 Command Shell.
b. At the prompt in the command shell, enter:
install_adams_controls.ksh adams_command
where adams_command is the command line command from Step 3 above.
5. Type exit to close the command window.
6. If you started Easy5, from the File menu, select Quit.
 Adams/Controls Overview 15
Using Easy5

The Adams extension installation is complete. Be sure to configure your computer as described
next.

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_nt_IF91 (Win32) or lib_em64t_IF91 (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 10.1 and 11 compilers only (note that this will work
with the "91" directory on Easy5). The Easy5 model import feature is not supported with the
GNU or other compilers. Check http://support.adams.com 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:
16 Adams/Controls
Using Easy5

C:\MSC.Software\EASY5\2008r1\
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:
Win32:
Variable Value = <CURRENT_VALUE>; %EZHOME%\easy5x\lib_nt_IF91
Win64:
Variable Value = <CURRENT_VALUE>; %EZHOME%\easy5x\lib_em64t_IF91
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.
 Adams/Controls Overview 17
Using Easy5

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 (e.g., 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
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.
18 Adams/Controls
Using Easy5
 Co-Simulation and Function Evaluation 19

Co-Simulation and Function Evaluation

20 Adams/Controls
Animation Options

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.
 Co-Simulation and Function Evaluation 21
Initialization

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 (e.g.
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. (e.g.
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.
4. Dynamic co-simulation/function evaluation run begins at time = 0.
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.
22 Adams/Controls
Initialization

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 Function Evaluation 23
Initialization

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'
24 Adams/Controls
Co-Simulation and Interpolation/Extrapolation

Co-Simulation and Interpolation/Extrapolation

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 (i.e., "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.

Interpolation/Extrapolation Options
Step 1 - Options for Adams/Controls Plant Inputs
The following describe what happens to the Adams Plant inputs (i.e., 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)
 Co-Simulation and Function Evaluation 25
Co-Simulation and Interpolation/Extrapolation

Step 3 - Options for Adams/Controls Plant Outputs

The following describes what happens to the Adams Plant outputs (i.e., 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 (i.e., the
Plant Inputs are extrapolated and the Plant Outputs are interpolated). This setting can be seen highlighted
below:
26 Adams/Controls
Co-Simulation and Interpolation/Extrapolation
 Co-Simulation and Function Evaluation 27
Co-Simulation and Interpolation/Extrapolation

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:
28 Adams/Controls
Co-Simulation and Interpolation/Extrapolation

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").
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.
 Co-Simulation and Function Evaluation 29
Co-Simulation and Interpolation/Extrapolation

Plot of azimuth position:

30 Adams/Controls
Co-Simulation and Interpolation/Extrapolation

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.
 Co-Simulation and Function Evaluation 31
User Libraries

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 UNIX: enter mdadams2010 -c cr-user
• On Windows: From the Start menu, point to Programs, point to MSC.Software, point to
MD Adams 2010, point to ASolver, and then select Create Custom Solver. (Or, type
mdadams2010 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.
32 Adams/Controls
Using TCP/IP

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
• Unix/Linux: Ctrl + C

Optionally, you can enter the number of runs before termination with the -n flag for adams_daemon.py.

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:
 Co-Simulation and Function Evaluation 33
Using TCP/IP

• On Windows: mdadams2010 python adams_daemon.py -h

• On UNIX: mdadams2010 -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 UNIX/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: mdadams2010 python adams_daemon.py
• On UNIX: mdadams2010 -c python adams_daemon.py exit
If using MATLAB, 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 or Matlab 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
Unix: Ctrl+C
--------------------------------------------------------
34 Adams/Controls
Using TCP/IP

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.
4. Start the Adams daemon on the Adams host before starting the simulation in MATLAB/Simulink
 Co-Simulation and Function Evaluation 35
Using TCP/IP

.
36 Adams/Controls
Using TCP/IP

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:
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.
 Control System Import 35

Control System Import

36 Adams/Controls
Importing External System Library

Importing External System Library

Imports an External System Library (ESL) into your Adams model by creating general state equation
(GSE) that uses the library.

To import an External System Library:

1. From the Controls menu, select Controls System, and then select Controls System Import.
2. Complete the Adams/Controls System Import dialog box as described in Adams/Controls System
Import.
3. Select OK.
 Control System Import 37
Removing External System Library

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:
1. From the Controls menu, select Controls System, and then select Controls System Delete.
2. Enter the name of the model and GSE you want to delete.
3. Select OK.
38 Adams/Controls
Using MATLAB/RTW

Using MATLAB/RTW
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:
http://support.adams.com

Compilers supported by both Adams and MATLAB/RTW must also be available (for example, Microsoft
Visual Studio 2005) - 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 RTW, in particular to how sample times are handled. This is important to Adams since Adams will
be integrating the model, not MATLAB/RTW. 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 RTW-generated 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/RTW Models to Adams

You can export specific parameters from the Simulink/RTW model in order to fine-tune the controller,
or conduct design-of-experiments on the External System Library (ESL) without rebuilding the model.
 Control System Import 39
Using MATLAB/RTW

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

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.
40 Adams/Controls
Using MATLAB/RTW

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 Real-Time Workshop, and then
select Options.
2. In the Configuration Parameters window that opens, select Optimization Tab.
3. Under Simulation and Code Generation, 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 Real-Time Workshop 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_rtw/continuous.h.
/* Parameters (auto storage) */
struct Parameters {
real_T Kp; /* Variable: Kp
* '<Root>/Transfer Fcn'
*/
real_T Kv; /* Variable: Kv
* '<Root>/Transfer Fcn1'
*/
};
 Control System Import 41
Using MATLAB/RTW

extern Parameters rtP; /* parameters */

…and in continuous_rsim_rtw/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/RTW parameters via the arguments to Adams GSE.

Step 4 - Create RTW-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 it’s
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 UNIX
The process of transporting RTW code from one platform to another is as follows:
• Step 1 - Create MATLAB tree on UNIX to build RTW library
• Step 2 - Create makefile and C-code template on UNIX
• Step 3 - Generate C-code and makefile
• Step 4 - Build RTW dll

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

You need to emulate the Windows MATLAB file structure (tree) on your UNIX 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 UNIX machine:
• simulink/include
• extern/include
• rtw/c/rsim
42 Adams/Controls
Using MATLAB/RTW

• rtw/c/libsrc
• rtw/c/src
• rtw/c/tools
• rtw/c/tlc

Note: Your make utility and compiler may be sensitive to DOS/UNIX end-of-line character
differences. Therefore, we recommend that you run a dos2unix file conversion utility to
ensure your files have a UNIX end-of-line.

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

1. Set the environment variable MATLAB_ROOT to /home/rtwuser/cross.
2. In the file, /home/rtwuser/cross/rtw/c/rsim/rsim_unix.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 Unix 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 UNIX is /home/rtwuser/workbench/.
1. Copy the modified files, rsim_unix.tmf, rsim.tlc, and adams.tlc, from
/home/rtwuser/workbench/ on UNIX 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_unix.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.
 Control System Import 43
Using MATLAB/RTW

4. Copy all files in the build directory on Windows (C:/pcbench/model_rsim_rtw) to the working
directory on UNIX (/home/rtwuser/workbench).
You may need to run a dos2unix utility against the generated code to conform to UNIX 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 UNIX 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 UNIX 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.
44 Adams/Controls
Using MATLAB/RTW

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
 Control System Import 45
Using MATLAB/RTW

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"
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/support/solutions/data/1-4JEC1P.html?solution=1-4JEC1P
• 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/support/solutions/data/1-3JK8LD.html?solution=1-3JK8LD

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.
46 Adams/Controls
Using MATLAB/RTW

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 (e.g, 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.
 Control System Import 47
Using MATLAB/RTW

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-
48 Adams/Controls
Using MATLAB/RTW

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 not support MATLAB function blocks.
• 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).
 Integration with Vertical Products 45

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.

Note: Adams/Mechatronics is an MD-only feature.

For the latest information on integrating Adams/Controls with Adams/Car, and Adams/Chassis, refer to
the Adams Knowledge Base at http://support.adams.com/kb.
46 Adams/Controls
 Examples 47

Examples
48 Adams/Controls
Tutorials and Examples

Tutorials and 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 Knowledge Base Article 12408 - 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.Software Knowledge Base Article 1-KB8965 - 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.