adams/controls version 12 training - university of … guide.pdf · 2 contents contents chapter 1:...

ADAMS/Controls Version 12TRAINING

Contents

Chapter 1: Welcome to ADAMS/Controls Training 6A Brief History of ADAMS 7About Mechanical Dynamics 8Getting Help in Class 9Getting Help at Your Job Site 10A Recap of Basic ADAMS Terminology 11 Design Methodology with/without ADAMS/Controls 12

Chapter 2: Modeling Controls in ADAMS 15Open Loop Control Systems 16Closed Loop Controls Systems 17ADAMS/Controls Process 19ADAMS/Controls Compatibility with CSS 20

Contents

Chapter 3: Overview of Using ADAMS/Controls 22ADAMS/Controls Goal: create ADAMS Plant for simulation

24Four Step Process 25Step 1: Exporting Plant Files from ADAMS for the CSS 26 Step 2: Creating the Plant in CSS 30Step 3: Connecting the ADAMS Plant and adjusting the

simulation parameters 34Step 4: Running simulations from the CSS 37Workshop 1: The Controls Process 43

Chapter 4: Setting Up Your ADAMS model for Plant Export 53Creating Plant Inputs and Plant Outputs 54ADAMS Variable Types 55Creating Input State Variables 56Creating Output State Variables 58Specifying Plant Input/Output for Plant Export 59State Variable Order in Plant Inputs/Outputs 60 Workshop 2: Creating State Variables 61

Contents

Chapter 5: Simulation Modes: Discrete vs. Continuous 69Discrete Mode 70Continuous Mode 71Continuous vs. Discrete Mode 74Co-simulation Process 76State Repartitioning 78Output Step Size/Sampling Rate 79Workshop 3 : Discrete vs. Continuous Results 80

Chapter 6: Preparing Simulations 89Licenses (or) Should View be running? 90Speeding Up Simulations 91Initialization Commands 92 Workshop 4: Initialization Commands 93

Chapter 7: Advanced Topics 97User Libraries/Subroutines 98 Debugging Models: General Tips 100Error Messages: Plant Communication Error 101

5 Contents

Chapter 1: Welcome to ADAMS/Controls Training

Within this chapter, you will find the following topics:

A Brief History of ADAMS 7About Mechanical Dynamics 8Getting Help in Class 9Getting Help at Your Job Site 10A Recap of Basic ADAMS Terminology 11 Design Methodology with/without ADAMS/Controls 12

A Brief History of ADAMS

•ADAMS: Automatic Dynamic Analysis of Mechanical Systems.•Technology has been around for 25 years.•Mechanical Dynamics Incorporated formed by researchers that developed the base ADAMS code at University of Michigan, Ann Arbor, Michigan, USA.•Large displacement code.•Systems based analysis.•Original product was the ADAMS/Solver, an application that solves non-linear numerical equations. Models are built up in text format then submitted to Solver. •In the early 90’s, the ADAMS/View GUI was released which allowed the user to build, simulate and examine results in a single environment.•Today, industry focused products are being produced such as ADAMS/Car, ADAMS/Rail, ADAMS/Engine etc.

About Mechanical Dynamics

Find a list of ADAMS products at:

http://www.adams.com/mdi/product/modules.htm

Learn about the ADAMS – CAD/CAM/CAE integration at:

http://www.adams.com/mdi/product/partner.htm

Find additional training at:

http://support.adams.com/training/training.html

…or your local support center.

Get custom information at my.adams.com:

http://my.adams.com

Getting Help in Class

Performing searches on any online ADAMS guide.

Getting Help at Your Job Site

Online guides

Use the “Help” menu in the ADAMS toolbar

Knowledge Base

Go to http://support.adams.com/

…and select “Technical Support” �“Knowledge Base”

ASK Email-Based Users Group

…and select “Technical Support” �“ASK Email Listservers”

Consulting Services

…and select “Expert Consultants”

Technical Support

To read the Service Level Agreement, go to http://support.adams.com/ and select “Technical Support” �“Standard Service Level Agreement”

To find you support center, go to http://support.adams.com/and select “Technical Support” � “Support Centers”

A Recap of Basic ADAMS terminology.

•ADAMS/Solver•The solution engine.

•ADAMS/Solver Deck (*.adm file)•The actual ASCII format file submitted to the ADAMS/Solver.

•ADAMS/Solver Command (*.acf file)•An ASCII file which contains commands to control how the ADAMS/Solver runs the model.

•ADAMS/Solver Output Files.•Graphics (*.gra file) – Information about how graphics work.•Request (*.req file) – Contains output for a user-defined set of results.•Results (*.res file) - Contains state results for every entity. •Message (*.msg file) – Information about the solver/simulation/problems.•Output (*.out file) – Output including initial conditions and request, and content can depend on output specifications.

Why You Use ADAMS/Controls: Typical Design Methodology

PhysicalPrototype

Design Verification& Testing

Controls Designer

Mechanical Designer

Concept

Design

Design Methodology with ADAMS/Controls

Controls Designer

Mechanical Designer

Share same model

VirtualPrototype

Concept

PhysicalPrototype

Design Verification& Testing

Design

Chapter 2: Modeling Controls with ADAMS

Open Loop Control Systems 16Closed Loop Controls Systems 17ADAMS/Controls Process 19ADAMS/Controls Compatibility with CSS 20

Open Loop Control Systems

� Open loop performance is determined by the calibration� Open loop not generally troubled with instability� Open loop not generally high performance� Open Loop Example: “automatic” toaster uses timer

Control Elements

PlantReferenceInput Controlled

OutputControlvariable

Disturbance

Transfer Function = Controlled OutputReference Input

Closed Loop Control Systems

A closed loop control system is one in which the control action is dependent on the output (usually), using “feedback”.

Feed back is…

A property of a closed loop system which permits the output (or some

other state of the system) to be compared with the input (or some

other state of the system), so that the appropriate control action

may be formed as some function of both the output and the input.

Benefits of a closed-loop system over an open-loop system:• Provides increased accuracy to track an input signal• Reduced sensitivity to variations in the system• Reduced effect of non-linearities• Increased bandwidthExample: home thermostat

Closed Loop Control Systems

Control Elements Plant

FeedbackElements

ReferenceInput

Controlvariable

Controlled Output

Disturbance

FeedbackSignal

ActuatingSignal

Transfer Function = Controlled OutputReference Input

Controller

ADAMS/Controls Process

ADAMSPlant

Controlvariable

Controlled Output

Produced by ADAMS/Controls:

Control Elements

ADAMSPlant

FeedbackElements

Inserted into your CSS model for simulation:

ADAMS/Controls Compatibility with CSS

ADAMS/Controls v12.0 is compatible with:

•MATLAB •EASY5•MATRIXx

(MATRIXx support will parallel Mathwork’s support)

See the “Partner Integration” information at www.adams.comfor specific release compatibility. For ADAMS v12.0, this can be found at:

Chapter 3: Overview of Using ADAMS/Controls

ADAMS/Controls Goal: create ADAMS Plant for simulation 24Four Step Process 25Step 1: Exporting Plant Files from ADAMS for the CSS 26Step 2: Creating the Plant in CSS 30Step 3: Connecting the ADAMS Plant and adjusting the simulation parameters 34Step 4: Running simulations from the CSS 37Workshop 1: The Controls Process 43

ADAMS/Controls Goal: Create Plant for Simulation

Steps for setting up your model in ADAMS for use with ADAMS/Controls.

Goal: create ADAMS model to insert into controls model

Example: Antenna Control ProblemAzimuth and Elevation DOFFlexible supportDisturbance to elevation loopInput torques applied

Four Step Process

Mechanical System Simulation- Create ADAMS model

-Define control inputs and -sensor outputs

- Create ADAMS model-Define control inputs and -sensor outputs

Control System Design

- Build system block diagram- Include ADAMS block

- Export model- Create .m or .inf file

- Connect inputs and outputs -Perform simulation of -combined systems

- Simulate and analyze- Visualize system in motion

Mechanical System Simulation

Four Step Process: Step 1

Step 1: Exporting the Plant Files from ADAMS for the controls simulation software (CSS)

Example: Create or obtain antenna model; define variables to be used as inputs and outputs to antenna model (forces, torques to control antenna motion; azimuth and elevation position measurements)

- Create ADAMS model- Define control inputs and sensor outputs

- Export model- Create .m or .inf file

Four Step Process: Step 1 (continued)

Step 1 (continued): Exporting the Plant Files from ADAMS for the CSS

“Plant export” feature will create files specifically to generate an ADAMS antenna plant in the CSS:• .adm and .cmd files that describe mechanical model• .acf file includes solver commands (not necessarily used)• .m file for MATLAB; .inf for MATRIXx and EASY5

Example: antenna model produces .m shown below

addpath( 'F:\PROGRA~1\ADAMS1~2.0/controls' ) ;addpath( 'F:\PROGRA~1\ADAMS1~2.0\controls\matlab' ) ;% ADAMS / MATLAB Interface - Release 12.0.0ADAMS_sysdir = 'F:\PROGRA~1\ADAMS1~2.0' ;ADAMS_exec = '' ;ADAMS_prefix = 'ant_test' ;if (exist([ADAMS_prefix,'.adm']))

ADAMS_static = 'no' ;ADAMS_init = '' ;ADAMS_inputs = 'control_torque' ;ADAMS_outputs = 'rotor_velocity!azimuth_position' ;ADAMS_pinput = '.main_olt.tmp_MDI_PINPUT' ;ADAMS_poutput = '.main_olt.tmp_MDI_POUTPUT' ;ADAMS_uy_ids = [

123] ;

ADAMS_mode = 'non-linear' ;tmp_in = decode( ADAMS_inputs ) ;tmp_out = decode( ADAMS_outputs ) ;disp( ' ' ) ;disp( '%%% INFO : ADAMS plant actuators names :' ) ;disp( [int2str([1:size(tmp_in,1)]'),blanks(size(tmp_in,1))',tmp_in] ) ;disp( '%%% INFO : ADAMS plant sensors names :' ) ;disp( [int2str([1:size(tmp_out,1)]'),blanks(size(tmp_out,1))',tmp_out] ) ;disp( ' ' ) ;clear tmp_in tmp_out ;

elsedisp( ' ' ) ;disp( '%%% ERROR : missing ADAMS plant model file !!!' ) ;disp( ' ' ) ;

end% ADAMS / MATLAB Interface - Release 12.0.0

Model Files Prefix (produced by plant

export)

Variables

Example: antenna model produces .inf shown below

C:\Program Files\ADAMS 12.0 <---location of ADAMS <---user executable name

ant_test <---model file nameant_test <---analysis file nameinteractive <--not used**discrete <---not used**0.010000 <---sample rate or output rateautomatic <---not used**no <----static flag (yes=run static)NUMBER OF COMMANDS <---#initialization commands0 (each command listed next - note must be mode compatible)NUMBER OF INPUTS/OUTPUTS1 2 <----# inputs to ADAMS/# outputs from ADAMSINPUT VARIABLES control_torque 1 1 <----input name, input var ID, input multiplier rateOUTPUT VARIABLESrotor_velocity 2 1 <----output #1 name, output var ID, output multiplier rateazimuth_position 3 1 <----output #2 name, output var ID, output multiplier rate

** In past versions of EASY5, these parameters were used.

Step 2: Creating the Plant in CSS

Create control model (except for plant)Read in the .m/.inf file to set up the paths, variables

- Build system block diagram- Include ADAMS block

Four Step Process: Step 2(continued)

Step 2 (continued): Creating the Plant in CSS

MATLABAfter the .m is read into MATLAB, type “adams_sys” which will generate the ADAMS plant

MATLABDouble click the “adams_sub” block to see:•Input and output names are automatically created•Workspace hooks are also automatically created

Four Step Process: Step 2(continued)

EASY5Create an ADAMS Extension which references the .inf file created in Step 1

Step 3: Connecting the ADAMS Plant and adjusting the simulation parameters in the CSS

- Connect inputs and outputs - Perform simulation of combined systems

MATLAB Plant Mask•Double click the Mechanical Dynamics block to bring up the mask•Here you select modes from and gain access to the full capabilities of ADAMS/Controls

EASY5•Double click the Mechanical Dynamics block to bring up the Component Data Table•Here you select modes from and gain access to the full capabilities of ADAMS/Controls

Step 4: Running simulations from the CSS

Example: Antenna model will simulate according to controls inputs (forces, torques, etc.)

- Simulate and analyze- Visualize system in motion

Step 4(continued): Running simulations from the CSS

Use Simulation � Parameters in MATLAB to control the control system integrator step size, end time, and integrator settings.

Interactive vs. Batch Modes•Interactive mode launches ADAMS/View (vcontrols.exe will use the .cmd file and see the model update)•Batch mode launches ADAMS/Solver (scontrols.exe will use the .adm file and will not see the model update, but will run faster)

Set animation mode here

Step 4 (continued)

MATLAB Notes:

•Input and output variables are automatically saved to the workspace (if “adams_sub” block is used)•Use/modify MATLAB variable names to push data onto the mask instead of editing the mask entries directly•Mask variables are accessible via command line if you wish to set them manually or in a MATLAB script

EASY5Use Analysis � Simulation to control the control system integrator step size, end time, and integrator settings.

Interactive vs. Batch Modes•Interactive mode launches ADAMS/View (vcontrols.exe will use the .cmd file and see the model update)•Batch mode launches ADAMS/Solver (scontrols.exe will use the .adm file and will not see the model update, but will run faster)In EASY5, set the animation mode with the ANI_MOD variable in the ADAMS block:

Workshop 1: The Controls Process

In this workshop, you will export a non-linear ADAMS model to your CSS (MATLAB or EASY5) by creating state variables for inputs and outputs to you ADAMS plant. You will also setup a pre-built controls model to observe how the co-simulation process works.

1. Open ADAMS/View.

NT: Select Start � Programs � ADAMS 12.0 �AView � ADAMS - View

Unix: Open a shell and type the alias “adams120”which points to the “mdi” script to launch the ADAMS toolbar. Next, select the ADAMS/View button (1st button).

2. Select 'Import File' and find the 'antenna.cmd' file in the /Workshop1-General/ folder to load the “antenna” model.

3. Simulate the antenna model for 0.5 seconds and 100 steps to see what it does. Note the gear and applied torque at the base.

4. Load the ADAMS/Controls plugin with Tools � Plugins �Controls � Load

5. Select Controls � Plant Export

To work with MATLAB, follow steps 6 – 20.

To work with EASY5, follow steps 21 – 38.

MATLAB Steps

6. Specify information about this mechanical model as MATLAB is going to see it. Enter the following:

File Prefix: ant_test - this tells ADAMS to write out a ant_test.m file containing state variable and file location information that MATLAB understands.

Plant Input: tmp_MDI_PINPUT. This contains the variable, control_torque - our plant input signal.

Plant Output: tmp_MDI_POUTPUT. This contains the variabless, rotor_velocity & azimuth_position - our plants outputs.

Control package: MATLAB

Type: non_linear - our plant is a nonlinear description of our mechanical system (as opposed to linearized about some operating point).

7. Select 'OK' to write out a plant description.

We've supposedly written out a valid description of our mechanical system that MATLAB can handle. Now to import it into MATLAB.

8. Start MATLAB by typing ‘matlab'. Ensure that you're in the working directory where your .m file is. You can use “cd” and “ls” in the MATLAB environment to navigate through directories.

9. Load the ant_test.m file that you just made in ADAMS into MATLAB by simply typing the name of the file (ant_test).

10. Type 'who' to give you a listing of all the variables currently defined in the MATLAB environment. See that you now have several ADAMS_*** variables defined in MATLAB. These tell MATLAB how to interact with ADAMS.

11. Type the highly intuitive command 'adams_sys' to build a Simulink block representing your mechanical system.

12. The block named ‘adams_sub’ represents your non-linear mechanical system. Note it's two outputs (that you've previously defined) and the single input.

13. Select File �� Open from the Simulink window containing your ADAMS plant block. Select 'antenna.mdl' to read in a pre-made control system for the antenna. The ‘adams_sub’ block has already been added (with the ‘adams_sys’ MATLAB command).

14. In the Simulink window containing all of the control system elements, select Simulation �� Simulation Parameters.. and set:

Stop time = 0.5

Max. Step size = 0.001

15. Select ‘OK'.

16. Select Simulation �� Start to run a simulation.

17. Take a look at the output by double clicking the terminal icons labeled 'rotor_vel' and 'azimuth_pos'.

18. Note that the azimuth position has been driven to a fixed value and the rotor velocity has increased then dropped back to zero.

19. Change the control parameters (step function end value, gain value) and resimulate.

20. Change the animation mode in the ADAMS plant mask (batch vs. interactive) - note solution speed difference.

EASY5 Steps

21. Specify information about this mechanical model as EASY5 is going to see it. Enter the following:

File Prefix: ant_test - this tells ADAMS to write out a ant_test.inf file containing state variable and file location information that EASY5 understands.

Plant Input: tmp_MDI_PINPUT. This contains the variable, control_torque - our plant input signal.

Plant Output: tmp_MDI_POUTPUT. This contains the variabless, rotor_velocity & azimuth_position - our plants outputs.

Control package: MATRIXx_and_EASY5

Type: non_linear - our plant is a nonlinear description of our mechanical system (as opposed to linearized about some operating point).

22. Select 'OK' to write out a plant description.

We've supposedly written out a valid description of our mechanical system that EASY5 can handle. Now to import it into EASY5.

23. Start EASY5:UNIX: Type ‘easy5'. Windows: Start � Programs � EASY5 61Ensure that you're in the working directory where the “antenna.mf.0” model and “ant_test.inf” are.

24. Open the EASY5 model “antenna.mf.0”

The EASY5 model opens. Notice that it already contains an ADAMS non-linear model block, so you do not need to create one. Note it's two outputs (that you've previously defined) and the single input.

Now, before you connect the AD block to the rest of the system, initialize the AD block

25. Open up the Component Data Table for the AD block and select ‘Spawn ADAMS Interface’

26. Enter the name of the .inf file (ant_test.inf).

27. Enter “25” for the maximum number of states.

28. Enter “3” to submit a co-simulation (discrete) analysis.

Your AD block is now initialized.

29. Select ‘OK’ in the AD Component Data Table.

30. Select Build � Create Executable to compile and link the model.

31. In the EASY5 main menu, select Analysis �� Simulationand set:

Title: my_antennaStop time = 0.25

Time Increment = 0.001

32. Toggle “Plot Results” to “yes”, and select “Show/Edit Plot Variables”.

The “Plot Specification Form” opens.

33. Select “Show Name List” to query the available variables to plot. Select “Y1”, “Y2”, “S2 LA”, and “S2 SF” as variables to plot.

34. Select “OK” to set-up the plots.

35. Select “Execute and Close” to submit the simulation.

If the animation mode is set to interactive (ANI_MOD = 1) , the simulation will be submitted with graphic updates to the ADAMS model during the co-simulation; if set to 0, a batch simulation will be submitted, which provides no graphical feedback. Note that the batch simulation takes less time.

36. Take a look at the output by looking at the plots that EASY5 has created.

• Y1 vs. Time (rotor velocity)

• Y2 vs. Time (azimuth position)

• S2 SF vs. Time (desired step function input)

• S2 SL vs. Time (actual torque input)

Note that the azimuth position has been driven to a fixed value and the rotor velocity has increased then dropped back to zero.

37. Change the control parameters (step function end value, gain value) and resimulate.

Chapter 4: Setting Up Your ADAMS Model for Plant Export

Chapter 4:Setting Up Your ADAMS Model for Plant Export

Steps to setup your model for a Plant Export 54ADAMS Variable Types 55Creating Input State Variables 56Creating Output State Variables 58Creating Plant Inputs and Outputs 59State Variable Order in Plant Inputs/Outputs 60 Specifying Plant Input/Output for Plant Export 61Workshop 2: Creating State Variables 62

Steps to setup your model for a Plant Export

In order to export your plant model, you must define the inputs and outputs to your plant.

To do so:

1. Create the state variables to which will be the inputs and outputs to your plant

2. Create Plant Inputs and Outputs which hold the state variables from step 1

3. Use a single Plant Input and Plant Output to export your plant files using the ADAMS/Controls Plant Export dialog box.

ADAMSPlant

PlantInput

Plant Output

Both contain a list of state variables

ADAMS Variable Types

Creating Input State Variables

Input Variables

Create state variables to hold inputs.

•Leave function = 0 (usually)

•Initial values will be used if an initial static simulation is performed

Assign Input State Variables to Actuators

Assign the state variables which define your plant inputs to the actuators (e.g., forces) in the model with the VARVAL function.

Creating Output State Variables

Create any valid runtime expression to provide an output to the CSS.

Example: azimuth angle, elevation angle

Creating Plant Inputs and Plant Outputs

Create Plant Inputs and Plant Outputs in your ADAMS model to provide inputs and outputs to your ADAMS plant. You specify one Plant Input and one Plant Output for your ADAMS plant, but they may contain as many variables as you desire.

ADAMSPlant

PlantInput

Plant Output

Both contain a list of state variables

State Variable Order in Plant Input/Output Elements

The state variable order in the Plant Input and Plant Output elements is very important, because it determines the order which the variables must be defined in the CSS.

Specifying Plant Inputs/Outputs for Plant Export

Once the Plant Inputs and Outputs are created, reference these in the Plant Export dialog box.

Using plant inputs and outputs instead of state variables allows users to edit inputs and outputs to the plant more robustly (for example, for a large number of state variables, the Plant Input/Output can be edited, rather than specifying them one by one in the Plant Export dialog box)

Workshop 2: Creating State Variables & Plant Inputs/Outputs

In this workshop, you create a model to control the position of a ball on a beam-balancing mechanism. To do so, you will create state variables and a plant input and output for you non-linear plant export of the ball-beam model (the following are general steps; see the Appendix for an exact solution).

1. Open the 'ball_beam.cmd' file in the /Workshop2-General/ folder from ADAMS/Controls.

2. Simulate the ball and beam model for 10 seconds and 200 time steps - the ball should fall off the beam due to an initial velocity assignment to the beam.

We're going to try to balance the ball on a point off of the beam's center point by controlling a torque applied to the beam.

3. Create 3 state variables that will be used for plant (this mechanical system) communication. As you're going to make your ADAMS model compatible with an existing control system, use the following names for the 3 state variables:

Beam_Angle

Position

Torque_In

4. Two of these 3 variables are the outputs of our plant. Define functions for these variables as follows:

Beam_Angle = angle of the beam w.r.t. horizontal from the front view: AZ(.ball_beam.beam.cm)

Position = position of ball center of mass (CM) along the beam top surface where the initial position is at distance = 0 and the value increases to the right:

DX(.ball_beam.ball.cm,.ball_beam.beam.ref,.ball_beam.beam.ref)

5. Simulate the system again for 10 seconds and 200 steps, then go to the PostProcessor and see if your Beam_Angle and Position variable values look to be correct.

6. Specify a value for the Torque_In state variable (for example, torque = 5). The next step will hook this value to the Torque that is applied to the beam.

7. Tell the Torque on the beam (Sforce SFO1) to get it's magnitude from the state variable Torque_In. Use a VARVAL() in the Sforce function definition to do this.

8. Simulate the system - the beam should rotate due to the applied torque. Change the torque value in the state variable and resimulate to ensure that the value of the state variable is getting picked up by the torque SFO1.

9. Set the Torque_In state variable value back to zero with Build � System Elements � State Variable � Modify.

10. Create a Plant Input with Build � Controls Toolkit � Plant Input

Plant Input Name: MDI_PINPUTVariable Name: Torque_In

11. Create a Plant Output with Build � Controls Toolkit � Plant Output

Plant Output Name: MDI_POUTPUTVariable Name: Beam_Angle, Position

IMPORTANT: Take care that you get the order correct for the outputs (they have to synch up with the existing controls model).

To work with MATLAB, follow steps 12-27.

To work with EASY5, follow steps 28-51.

MATLAB Steps

12. Export the plant with Controls � Plant Export

File Prefix = ball_testPlant Input = MDI_PINPUT

Plant Output = MDI_POUTPUTControl Package = MATLAB

13. Start MATLAB from a new x-window by typing ‘matlab’.

14. Type 'ball_test' - the .m file that we just exported from ADAMS - this sets up the state variables needed in MATLAB.

15. Type ‘adams_sys' – this creates a plant that you can use in MATLAB.

16. Select File �� Open = ball_beam.mdl . This opens the previously made MATLAB control schematic. Copy the plant from ‘adams_sys’ to the ball beam control model.

Now, before you use MATLAB to simulate the combined controls/mechanical system, set up your environment:

17. Set simulation parameters (Simulation �� Simulation Parameters):

End time = 4 secondsSolver = ode15s (stiff integrator)

Next, set the ADAMS plant properties

18. Double click the 'Mechanical Dynamics' block

19. Set the “Output files” prefix to 'ball_results‘

Note: be sure to include the quotes (‘ ‘)

20. Set the simulation modes to discrete

21. Set the animation mode to interactive.

22. Select ‘OK’ to save.

23. Simulate the control system containing the ADAMS block by doing a Simulation �� Start.

24. View results in MATLAB:

If stripcharts in MATLAB aren't visible, double click the scope icons labelled 'Position', 'Force input', etc. The MATLAB strip charts can be autoscaled if the signal disappears by hitting the binocular icon.

Next, look at results in ADAMS/Controls.

25. Open ADAMS/PPT and select File �� Import

26. Select “Analysis Files”

27. Choose 'ball_results.gra' or 'aplant_out.gra' file (if you used the default output name)

You can now animate the mechanical system.

EASY5 Steps

28. Export the plant with Controls � Plant Export

File Prefix = ball_testPlant Input = MDI_PINPUTPlant Output = MDI_POUTPUTControl Package = MATRIXx_and_EASY5

29. Start EASY5 from a new x-window by typing ‘easy5’.

30. Open the existing EASY5 model “ball_beam_noad.mf.0”.

Notice that the model does not contain the non-linearADAMS plant block.

31. Select the block “Add” or the keystroke CRTL-A to open the Add Components dialog box.

32. Select “Extensions” in the Open Libraries field, and select AD ADAMS Nonlinear Block to create an ADAMS (AD) block.

An icon will follow your cursor until you select the location to create it.

33. Place the AD block in the right of the model, between the “LA” block and the two unit gain blocks.

Now, before you connect the AD block to the rest of the system, initialize the AD block

33. Enter the name of the .inf file (ball_test.inf).

Next, connect the AD block to the rest of the EASY5 model.

38. Connect S2 LA (actuator input) to U1 of the AD block (S-U1)

39. Delete the two dummy unit gain blocks.

40. Connect Y1 of the AD block to S3 SJ.

41. Connect Y2 of the AD block to S1 SJ2.

The EASY5 model should now be connect properly to the AD block. Before you use EASY5 to simulate the combined controls/mechanical system, set the AD block properties.

42. Double click the AD block

43. Set the animation mode to interactive (ANI_MOD=1).

Next, set the simulation parameters:

46. Set simulation parameters (Analysis �� Simulation Parameters):

Title = ball_beamEnd time = 4 secondsTime increment = 0.01 secondsInt. Method = BCS Gear (stiff integrator)

47. Create plots (Y1, Y2, etc.) by toggling “Plot Results” to “yes”and making appropriate selections in “Show/Edit Plot Variables”.

48. Simulate the control system containing the ADAMS block by selecting “Execute and Close”.

When the simulation is finished, the plots you created will appear automatically.

51. Choose 'ball_test.gra‘.

You can now animate the mechanical system..

Chapter 5: Simulation Modes: Discrete vs. Continuous

Discrete Mode 70Continuous Mode 71Continuous vs. Discrete Mode 74Co-simulation Process 76State Repartitioning 78Output Step Size/Sampling Rate 79Workshop 3 : Discrete vs. Continuous Results 80

Discrete Mode (Co-simulation)

There are two choices for the method of exchanging data between the control simulation software and ADMAS:

1. Discrete mode2. Continuous mode

Discrete mode (the most common) lets MATLAB integrate the Control system, ADAMS integrate the mechanical system. Controls takes a step in time, then ADAMS does the same, hence the 'discrete' label. In this mode, the integrators on both sides (CSS and ADAMS) are running in parallel. They exchange data as specified by the output step size. In this mode, the controls package, using output from ADAMS, calculates the mechanical model inputs and sends it back to ADAMS. It is the responsibility of ADAMS to integrate the mechanical system for a single time step with the specified inputs.

Discrete mode is also known as “co-simulation”

Continuous (Function Evaluation) Mode

Continuous mode lets the controls simulation software integrate everything. The CSS computes a big system Jacobian that includes our mechanical system. ADAMS acts as a function evaluator.

By this, we mean that the Jacobian, which describes the mechanical system, is evaluated by ADAMS, and the values are sent to the controls package to populate the equations integrated *solely* by the controls package. Viewed from the control side, ADAMS is no different from a nonlinear block (something like General State Equation, GSE, in ADAMS). At each integration steps, ADAMS provides the necessary information, such as inputs and states to the controls packages.

Continuous (Function Evaluation) Mode (continued)

Because function evaluation mode creates a large system Jacobian matrix that presents both the control scheme and the mechanical system at once, any integrator dealing with this sees an effectively 'continuous' system. This means that function evaluation mode will give results that are exact for simple systems. The downfall is that the control system integrators must be used and they are not finely tuned for solving mechanical systems, hence they have a tendency to fail for complex systems, particularly those with high frequency mechanical system effects.

Initially a system Jacobian is formulated by ADAMS based on the initial model configuration. As the CSS requests values from ADAMS and the model position changes, there is a possibility that the system Jacobian may change (by choosing different variables which define the Jacobian).

Continuous (Function Evaluation) Mode (continued)

ADAMS automatically chooses new independent generalized coordinates to build a Jacobian with, based on which variables are changing most rapidly in a simulation. If the variables that ADAMS uses change, the system Jacobian changes. This is a problem, as there is currently not a way to tell MATLAB that the form of the Jacobian has changed.

What this means is that continuous mode only works for models that are near-linear. This is a limitation of the mode, so most people use discrete mode for mechanical systems with rotating parts and movements with large displacements.

Continuous vs. Discrete Modes

Function Evaluation Mode Co-Simulation Mode

ADAMS writes out function and controls application does the work

ADAMS and controls application share the work

ControlsSoftware

ADAMS plant outputs(state variables)sent by ADAMS

Jacobian partialssent by ADAMS

Continuous vs. Discrete Modes

( )( )

� , , ,

x x x u

� ( , , )( , , )

x xy x

f th t

PlantP

ControllerC

y,f(.)u,t,x PlantP

ControllerC

y,f(.)U,t,x

Function Evaluation Mode Cosimulation Mode

Control App. does the work! ADAMS and Control App.share the work!

Co-simulation (discrete mode) Process

Here's what happens when you run an ADAMS/Control co-simulation in discrete mode. The following steps through an ADAMS message file (.msg) output from a batch mode co-simulation.

1. Controls tells ADAMS to start and loads up your model. Youshould see the following lines in your message file:

OUTFOP:IN_FILENM

ADAMS model file ..

VERINP:END_INPUT

Input and Input Check Phase complete.

GTMODE:NUMB_DOF1

The system has one kinematic degree of freedom.

2. After the initialization tasks, the controls package and ADAMS exchange data regarding system states. The line

GLGETL:USER_CMND

var/1, fun=0

in the .msg file shows the value from your controls package coming into ADAMS. At the same time the plant outputs from ADAMS are being sent to the Controls package.

Co-simulation (discrete mode) Process (continued)

3.Now that ADAMS has the input values needed, the line

DBANNR:BDF

Begin the dynamic analysis.

appears indicating that the dynamic analysis has begun on the ADAMS side. At this point the inputs to the plant are held fixed from the current time until the next output time step. In the above example, variable 1 is held fixed at 0.

4.When the dynamic analysis in ADAMS has proceeded for the output time step interval the message appears:

Simulation Time Cumulative Cumulative Integrator

Time Step Iterations Steps Taken Order

___________ ___________ __________ ___________ __________

0.00000E+00 2.50000E-04 0 0 1

2.50000E-04 2.50000E-04 3 1 1

5.00000E-03 2.50000E-03 13 5 2

GLGETL:USER_CMND

var/1, fun=0.01

….indicating that the dynamic simulation has halted. The linevar/1, fun=0.01 indicates that another exchange between the controls package and ADAMS follows, setting variable 1 to a value of 0.01. In this manner the co-simulation proceeds. At every specified time interval the controls package and ADAMS stop, update one another with new state values. Each package then runs it's simulation independently, using the fixed values throughout the following interval.

State Repartitioning

You may be performing an ADAMS/Controls simulation and get part way through when the simulation stops, with the error message: 'ADAMS State Repartitioning occurred ...‘ The 'State Repartitioning' message means that the ADAMS integrator is having some major problems resolving an event in your mechanical system, such as a rapidly changing input force or a locking up mechanism. This message can sometimes be overlooked when using regular old ADAMS, but it is not good when using ADAMS/Controls, as it may trigger a failure in the Controls package <-> ADAMS communication process.

To avoid this problem with your mechanical system check things such:

- gains in your Controls package. If they're large and they feed back rapidly changing forces you can have trouble - try decreasing these.

- step times for forces in ADAMS. If you're using any STEP functions, try increasing the ramp-up time.

- force magnitudes. Try decreasing your forcing function magnitudes.

- the output step size for ADAMS (typically set in the ADAMS plant mask, or properties panel). The Controls package and ADAMS trade data only at discrete output steps. Try decreasing the output step size to have the two packages update more frequently, decreasing the discrepancies when they exchange data in periodic update process.

Essentially the best way to avoid this is to try and 'smooth' things out by checking rapidly changing forces and/or making the output step size small so that the results from the two packages don't diverge too much.

Output Step Size/Sampling Rate

The output step size is the duration at which information is exchanged between the controls package and ADAMS. This is commonly known as the sampling rate, and its greatest affects are seen in the discrete mode.In discrete mode, the controls package, using output from ADAMS, calculates the mechanical model inputs and sends it back to ADAMS. It is the responsibility of ADAMS to integrate the mechanical system for a single time step with the specified inputs.The sampling rate at which the ADAMS side receives input updates is critical - you must ensure that you're sampling the mechanical system (in MATLAB this is set as the 'output step size' variable in the ADAMS plant mask; EASY5, the “Time Increment”) at more than twice the highest frequency you're interested in on the mechanical side. Otherwise, you may see aliasing in your mechanical model (aliasing is the generation of a false (alias) frequency).The effect of aliasing is that high frequency noise can be converted into a lower frequency, which could change the response of your system.

Workshop 3: Discrete vs. Continuous Results

In this workshop, you will simulate the ball-beam model in both discrete (co-simulation) and continuous (function evaluation) modes, and compare the results.

To work with MATLAB, follow steps 1-14.To work with EASY5, follow steps 15-47.

MATLAB Steps

1. Open up MATLAB and select File �� Open in the Simulink window and read in the .mdl for the from Workshop 2 for the ball_beam model.

Now, look at the plant properties - we'll be modifying the solution method and noting the simulation results.

To open the plant properties:2. Double click plant (adams_sub block in the control

system diagram)3. Double click 'Mechanical Dynamics' block

MATLAB Steps4. Set Output files prefix to 'ball_results_discrete‘5. Set Simulation mode to discrete.6. Set Animation mode - batch (interactive if you like the

animations).7. Select ‘OK’ to save.8. Simulate using these parameters. The results, stored

in the ball_results_discrete. files, will be saved for comparison to the continuous mode.

9. Take a look at the results in the MATLAB strip charts. Use the zoom tool to take a close look at a section of the curve in the 'Position' strip chart. It should show the discrete nature of the simulation, with small steps evident in the plot.

10. Now, change the simulation mode to continuous, the output prefix to 'ball_results_continuous‘.

11. In your Simulink model, select Simulate � Simulation Parameters, and change the solver to “ode23s (stiff/ Mod. Rosenbrock).

12. Select OK, and re-run the simulation

MATLAB Steps13. As in step 5 use the zoom tool and examine the

'Position' strip chart. It should appear continuous no matter how close you zoom in.

14. Open up the plant properties again and change back to the discrete mode. Make the output step size large -say 0.05 and resimulate. You should see the very discrete nature of the simulation and the result of undersampling the system.

EASY5 Steps15. Edit the file “ball_test.inf” from Workshop 2, so that

the fourth line is changed from “ball_test” to “ball_test_discrete”. This will change the output file names.

16. Open the EASY5 model “ball_beam.mf.#” (where # = the number of your last saved model from Workshop 2)

EASY5 Steps

Before you use EASY5 to simulate the combined controls/mechanical system, set the AD block properties.

23. Set the animation mode (ANI_MOD)to interactive.

Title = ball_beam_discreteEnd time = 4 secondsTime increment = 0.01 secondsInt. Method = BCS Gear (stiff integrator)

EASY5 Steps

27. Create plots (Y1, Y2, etc.) by toggling “Plot Results” to “yes” and making appropriate selections in “Show/Edit Plot Variables”.

You can zoom in on the plots and see the discrete nature of the curve.

31. Choose 'ball_beam_discrete.res‘. You can now make plots from results of the simulation of your mechanical system.

Next, perform the same simulation in continuous mode.32. Edit the file “ball_test.inf” from Workshop 2, so that

the fourth line is changed from “ball_test” to “ball_test_continuous”. This will change the output file names.

EASY5 Steps

36. Enter “1” to submit a continuous analysis with no input feed-through.

Before you use EASY5 to simulate the combined controls/mechanical system, set the AD block properties.

39. Set the animation mode (ANI_MOD)to batch.

EASY5 Steps

Title = ball_beam_continuousEnd time = 4 secondsTime increment = 0.01 secondsInt. Method = BCS Gear (stiff integrator)

43. Create plots (Y1, Y2, etc.) by toggling “Plot Results” to “yes” and making appropriate selections in “Show/Edit Plot Variables”.

You can zoom in on the plots and see that the plots are smooth, no matter how close you zoom in.

47. Choose 'ball_beam_continuous.res‘. You can now make plots from results of the simulation of your mechanical system.

Chapter 6: Preparing Simulations

Licenses (or) Should View be running? 90Speeding Up Simulations 91Initialization Commands 92 Workshop 4: Initialization Commands 93

Licenses

Question: I'm about to run the cosimulation from MATLAB. Should ADAMS be running at this time?

Answer: You do not have to have ADAMS/View running when running a co-simulation. The ADAMS/Controls scripts will launch ADAMS/View on its own when the time comes to animate the model interactively during the co-simulation. Note that ADAMS/View will only be launched if you are running an "interactive“ simulation. If you run a "batch" simulation, then View is not launched – the job is run completely by Solver, and you will not see any graphical feedback.

The upside to running in "batch" mode is that the simulation will take far less time.

Beware that if you have ADAMS/View running while you try to run a co-simulation, you will then need two licenses. If you don't have two available, you will get an error (“Plant communication error 109).

Speeding Up Simulation Times

There are two cosimulation modes when using ADAMS/Controls. Interactive = use View, batch = use Solver on the command line. For speed you want to do the batch cosimulation.

Here's the results of a simple experiment using the Antenna model provided with your ADAMS distribution. To baseline things,I've first run in plain old View, then ran the Controls cosimulationfor comparison of it's operating modes.

1. The baseline: run antenna model in View using output steps of size 0.005 and a simulation time of 1.0 seconds. Doing this yields:

Description Computation time

Regular View simulation 11 seconds

View simulation - execution display off 5 seconds

2. Test the ADAMS/Controls cosimulation: run cosimulation with MATLAB, using settings in the MATLAB plant mask:

end time = 1 second

dt (plant output step size) = 0.005s

using Stiff integrator (ODE15S) in Simulation settings

Result:

Description Computation time

View (interactive cosimulation) 1:26 (~20 second startup)

Solver (batch cosimulation) 0:18 (~8 second startup)

Summary:

Use the interactive cosimulation to verify that you've set your model up correctly; once you're sure of that, run using 'batch' model to significantly speed things up.

Initialization Commands

You can submit commands to your ADAMS model before the co-simulation process starts by using “initialization commands”. Initialization commands allow you to specify a Solver or View command that will be issued to ADAMS/Solver when running ADAMS/Controls. Solver commands are used for batch mode, and view commands are used for interactive mode. These can be used to run your model until it reaches some initial state at which you want to turn on your system controller (among other things).

To use this in MATALB, enter a single Solver command (for batchmode) such as:

['file/command=Starting_Commands.acf']

in the MATLAB plant mask "Initialization Commands" field. This Solver command reads an .acf (ADAMS command file) that can exercise your model before your Control system is turned on.

To use this in EASY5, enter a single Solver command such as:

file/command=Starting_Commands.acf

in the EASY5 .inf file under the line NUMBER OF COMMANDS 1. This Solver command reads an .acf (ADAMS command file) that can exercise your model before your Control system is turned on.

Refer to the ADAMS/Solver reference guide for valid Solver command file syntax.

Workshop 4: Initialization Commands

In the following workshop, the antenna model has a motion activated on the antenna base that twists the antenna in the direction opposite to what the control system does. An .acffile runs the model for .5 seconds with this motion turned on, then uses a DEACTIVATE/MOTION, ID=1 command to turn off the motion prior to the Control system turning on and running for another .5 seconds.

To work with MATLAB, follow steps 1-7.

To work with EASY5, follow steps 8-18.

MATLAB Steps

1. Start MATLAB and change to the /Workshop4-InitCommands/ directory.

2. Type ‘ant_test’ to setup the MATLAB environment variables, then type ‘adams_sys’ to bring up a Simulink window.

3. From the Simulink window, select File � Open and open antenna.mdl.

4. Edit the adams_sub block to include the initialization command ['file/command=Starting_Commands.acf'] in the initialization field.

5. Simulate from MATLAB.

6. Open ADAMS/View and import antenna.cmd. Then import the ADAMS/Solver Analysis files and attach the files to the antenna model or to a new analysis that you created (right-click on the field beside ‘model name’ or 'analysis name').

7. Inspect the results and convince yourself that the initialization commands were performed before the co-simulation.

EASY5 Steps

8. With a text editor, modify ant_test.inf to include the following commands:

F:\Program Files\ADAMS 12.0

ant_testant_testinteractivecontinuous0.010000automaticnoNUMBER OF COMMANDS1File/command=Starting_Commands.acfNUMBER OF INPUTS/OUTPUTS1 2INPUT VARIABLEScontrol_torque 1 1OUTPUT VARIABLESrotor_velocity 2 1azimuth_position 3 1

9. Start EASY5 and open the antenna model the /Workshop4-InitCommands/ directory.

10. Double click on the ADAMS AD block

11. Set the animation mode to batch (ANI_MOD=0).

12. Select Spawn ADAMS Interface.

13. Enter “ball_test.inf”.

14. Enter 25 for the number of states.

15. Enter 3 for a co-simulation.

16. Build the executable and simulate.

17. Open ADAMS/View and import antenna.cmd. Then import the ADAMS/Solver Analysis files and attach the files to the antenna model or to a new analysis that you created (right-click on the field beside ‘model name’ or 'analysis name').

18. Inspect the results and convince yourself that the initialization commands were performed before the co-simulation.

Chapter 7: Advanced Topics

User Libraries/Subroutines 98 Debugging Models: General Tips 100Error Messages: Plant Communication Error 101

User Libraries

Unlike previous versions of ADAMS, you no longer create an entire executable for ADAMS when you want to link in a user subroutine. Instead, a library is created once and simply selected when the subroutine(s) within the library are needed. For more information on this change, see KB 9317.

What does this mean? Well, instead of creating a controls executable (e.g., adams11 controls cr-uscontrols), you simply create a "standard" user executable (e.g., adams11 cr-user).

So, here are the explicit steps:

From the mdi script for UNIX, or the NT selections from the Start menu, do the following:

1) UNIX: mdi -c cr-user

NT: Start --> Programs --> ADAMS 11.0 --> ASolver -->

Create Custom Solver (or just type mdi cr-user in the DOS

prompt)

2) answer if you want to link in debug mode, and provide the

list of your user subroutines.

3) provide a name for the library, such as my_sub.dll

User Libraries (continued)

4) within ADAMS/View, when you use the Controls Plant Export

dialog box to save out your input and output data, include the

name of the user library you just created in the appropriate

5) The user executable name is now automatically written out to

the MATLAB .m file or the MATRIXx/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).

6) Note that there is no longer a difference between a custom solver library and a custom view library if the library is used by solver. In other words, you create a library for solver, which can be used by either the view interface or solver when simulating. A view library can *only* be in view as in design-time; it makes no sense to use this with solver, and obviously cannot be used in solver.

Debugging Models: General Tips

It's often difficult to understand what's happening with your ADAMS/Controls cosimulation because the Solver messages will scroll across your screen (or won't even be visible, depending on setup), then be gone, so you can't see what's causing errors in your cosimulation.

To see the output from Solver in the cosimulation, turn on message file output by setting the MDI_ADAMS_NOMSGFILE environment variable to FALSE. This will save all of the output messages to a .msg file that you can look through for errors.

If you're having trouble solving your equations of motion (integrator failures, long simulation times, odd results, etc.),use initialization commands to create a Solver command file (.acf file) which can change the default integrator settings, or perhaps run your model for a time without the controls inputs.

To summarize, some of the things to watch for:

- your inputs/outputs are in the correct order

- your control block diagram is proper

- you have an ADAMS license available (did you shut down ADAMS before doing the cosim?)

- your input forces/torques are reasonable (not too large or abrupt)- the ADAMS integrator shouldn't have problems with them.

Error Messages: Plant Communication Error

If you receive an ADAMS plant communication error when trying to perform the co-simulation, this could mean many things. The ADAMS plant communication error is a generic message that could unfortunately mean anything from you don't have a license available to you've referenced a variable incorrectly inthe controls simulation software. If you're trying to make your own model work and haven't tried one of the example problems found in your ADAMS installation at /ADAMS_install/controls/examples/, then run an example. It's important to ensure that you can run an example as your own model can potentially have incorrect feedback values, crossed lines, etc. You should establish that you can run an example model, which has been setup to work properly, before you start with your own model.

If you generate an ADAMS plant communication error at some point in an ADAMS/Controls co-simulation (due to too rapid feedback, improper variable specification in MATLAB, etc.) and then fix the source of your error, but now get the plant communication error as soon as you hit 'Simulate', you may need to do some clean-up in your workspace.

To clear things in the MATLAB <-> ADAMS/Controls environment, use the

clear mex

command on the command line in MATLAB. This gets rid of anything floating around from past failures and will allow you to perform subsequent co-simulations.

Finally, make sure there are no “pipe” files remaining: delete any “APCInput” or “APCOutput” files.

adams/controls version 12 training - university of … guide.pdf · 2 contents contents chapter 1:...

Documents

adams user guide for cricketers - amazon web...

transfer pricing - adams & adams · the term ‘transfer...

contents installation - abandonia machines 2 - turbo...1...

evaluation of nutrient levels in children with asd vs....

· contents section 1 introduction...

adams shaun armes adams fritz bultemeyer adams kristopher...

table of contents - adams engineers

table of contents - hays fluid controls

getting started using...

adams, amy e adams, amy adams, alan w …...unclaimed...

running msc.adams on windows - msc software...

adams rite aerospace inc. · adams rite aerospace is a...

table of contents - artisan controls

table of contents - islip flow controls

getting started using adams controls

table of contents chapter 7 human memory. table of contents...

audition 1.0.pdf · contents iv presets . . . . . . . . . ....

table of contents - flow-rite controls

getting started using adams/controls - … started using...

using adams/controls - md adams 2010