Lesson 14-Modeling and Simulation

Module Library and System Construction

Typical Control System Modeling Example:

% Create new model
new_system('pid_control_system');
open_system('pid_control_system');

% Add modules (from Module Library Browser)
% 1. Continuous Library - Transfer Fcn
% 2. Math Operations Library - Sum, Gain
% 3. Sources Library - Step
% 4. Sinks Library - Scope

% Add modules via command line (alternative)
add_block('simulink/Sources/Step', 'pid_control_system/Step_Input');
add_block('simulink/Math Operations/Sum', 'pid_control_system/Sum');
add_block('simulink/Continuous/Transfer Fcn', 'pid_control_system/Plant');
add_block('simulink/Math Operations/Gain', 'pid_control_system/PID_Controller');
add_block('simulink/Sinks/Scope', 'pid_control_system/Scope');

% Configure module parameters
set_param('pid_control_system/Plant', 'Numerator', '1', 'Denominator', '[1 2 1]');
set_param('pid_control_system/PID_Controller', 'Gain', '1');

% Signal line connections
add_line('pid_control_system', 'Step_Input/1', 'Sum/1');
add_line('pid_control_system', 'PID_Controller/1', 'Sum/2');
add_line('pid_control_system', 'Sum/1', 'Plant/1');
add_line('pid_control_system', 'Plant/1', 'Scope/1');

Subsystem Encapsulation Technique:

% Create subsystem
subsystem('pid_control_system/PID_Controller_Block');
% Move PID-related modules into subsystem

% Subsystem encapsulation (create Mask)
set_param('pid_control_system/PID_Controller_Block', 'MaskType', 'PID Controller');
set_param('pid_control_system/PID_Controller_Block', 'MaskParameters', ...
    {'Kp','Ki','Kd'});  % Define tunable parameters
set_param('pid_control_system/PID_Controller_Block', 'MaskDescription', ...
    'Proportional-Integral-Derivative Controller');

% Add parameter controls in Mask dialog
% Set parameter types (slider/edit box, etc.) via Mask Editor

Signal and Simulation Configuration

Multi-Domain Signal Processing:

% Mixed signal system example (continuous + discrete)
add_block('simulink/Discrete/Discrete Filter', 'pid_control_system/Digital_Filter');
set_param('pid_control_system/Digital_Filter', 'Numerator', '[0.1 0.2 0.1]', ...
    'Denominator', '[1 -0.5 0.2]', 'Sample time', '0.1');

% Signal bus creation
add_block('simulink/Signal Routing/Bus Creator', 'pid_control_system/Bus_Creator');
add_block('simulink/Signal Routing/Bus Selector', 'pid_control_system/Bus_Selector');

% Configure bus structure
% Define signal bus via Bus Editor (contains multiple sub-signals)

% Sample time configuration
set_param('pid_control_system/Plant', 'SampleTime', '-1');  % Inherited sample time
set_param('pid_control_system/Digital_Filter', 'SampleTime', '0.1');  % Fixed sample time

% Simulation parameter settings
simset('SrcWorkspace','current');  % Get variables from current workspace
simOptions = simset('MaxStep', '0.01', 'RelTol', '1e-4', 'AbsTol', '1e-6');
sim('pid_control_system', [0 10], simOptions);

Stateflow State Machine Modeling

State Transition Diagram Design

Elevator Control System Example:

% Create Stateflow chart
sfnew('elevator_control');
open_system('elevator_control/Elevator_Controller');

% Define state hierarchy
% Top-level states: [Idle, Moving]
% Moving sub-states: [Accelerating, ConstantSpeed, Decelerating]

% State transition conditions
% Idle -> Moving: When "Call" event received and current floor != target floor
% Moving -> Idle: When target floor reached

% Event definition
% Input events: Call (elevator call), Arrived (target reached)
% Output events: MoveUp (move upward), MoveDown (move downward)

% Data dictionary configuration
% Define data objects: CurrentFloor (current floor), TargetFloor (target floor)

% State action programming
% In state Entry action:
%   if CurrentFloor < TargetFloor
%       output MoveUp event
%   else
%       output MoveDown event
%   end

% Transition condition example:
% [CurrentFloor ~= TargetFloor]  -> Trigger state transition

State Transition Table Implementation:

% Create state transition table
sfnew('traffic_light_controller', 'Stateflow');
chart = find_system('traffic_light_controller', 'LookUnderMasks', 'all', 'Type', 'chart');
open_system(chart);

% Define states and transitions
% States: Red, Yellow, Green
% Transition conditions:
%   Red -> Green: timer >= 30s
%   Green -> Yellow: timer >= 25s
%   Yellow -> Red: timer >= 5s

% Use state transition table editor:
% 1. Define state rows (Red, Yellow, Green)
% 2. Define transition columns (timer conditions)
% 3. Set actions (output signals, timer reset, etc.)

Event and Data Management

Complex Event Processing Mechanism:

% Event broadcast example
% In Stateflow:
% 1. Define events: Start, Stop, Reset
% 2. Use send command to broadcast events:
%    on Start:
%        startTimer = tic;
%        send('Running', 'to_subchart');

% Data storage types
% Local: Visible only in current state machine
% Input/Output: Exchange data with Simulink ports
% Constant: Non-modifiable configuration parameters

% Data scope configuration
% In Stateflow properties dialog:
% 1. Set data scope (Local/Input/Output)
% 2. Define data type (double/int32/boolean, etc.)
% 3. Set initial value and range limits

Real-Time Simulation and HIL Testing

Real-Time System Modeling Process:

% Create real-time model
new_system('realtime_motor_control');
open_system('realtime_motor_control');

% Add real-time modules
% 1. Simulink Real-Time library - Digital I/O, Analog Input, etc.
% 2. Configure target settings (Target Preferences)

% Target computer configuration
tg = slrt;  % Connect to default target computer
set_param('realtime_motor_control', 'Target', tg);

% Hardware interface configuration
add_block('slrealtime/IO/Analog Input', 'realtime_motor_control/AI_Speed');
set_param('realtime_motor_control/AI_Speed', 'Channel', '0', 'SampleTime', '0.001');

add_block('slrealtime/IO/Digital Output', 'realtime_motor_control/DO_Control');
set_param('realtime_motor_control/DO_Control', 'Channel', '1', 'SampleTime', '0.001');

% Real-time parameter tuning
set_param('realtime_motor_control', 'FixedStep', '0.001');  % 1ms fixed step
set_param('realtime_motor_control', 'Solver', 'ode3');       % Medium accuracy solver

% Download and run real-time model
slbuild('realtime_motor_control');
tg.download('realtime_motor_control');
tg.start;

Hardware-in-the-Loop (HIL) Testing

HIL System Integration Example:

% HIL system architecture configuration
% 1. Control algorithm model (running on PC)
% 2. Hardware interface model (connected to actual device)
% 3. Signal routing and mapping

% Create HIL test environment
hil = slrealtime('TargetPC1');  % Specify target computer
set_param('hIL_system', 'Target', hil);

% Configure I/O interfaces
add_block('slrealtime/IO/Analog Input', 'hIL_system/AI_Sensor');
set_param('hIL_system/AI_Sensor', 'Channel', '0', 'Range', '[-10 10]');

add_block('slrealtime/IO/PWM Output', 'hIL_system/PWM_Actuator');
set_param('hIL_system/PWM_Actuator', 'Channel', '1', 'Frequency', '1000');

% Signal scaling and mapping
% Use Gain and Offset modules in Simulink:
% Sensor input: AI_Sensor -> Gain(0.1) -> Offset(-5) -> Control algorithm input
% Control output: Control algorithm output -> Gain(20) -> PWM_Actuator

% Real-time test execution
hil.load('hIL_system');
hil.start;
pause(10);  % Run for 10 seconds
hil.stop;

Model Optimization Techniques

Parameter Tuning and Sensitivity Analysis:

% Parameter sweep analysis
% Create parameter variation table
params = Simulink.SimulationInput('pid_control_system');
params = params.setVariable('Kp', 1);
params = params.setVariable('Ki', 0.1);
params = params.setVariable('Kd', 0.01);

% Multi-parameter sweep
paramValues = [1 2 5; 0.1 0.2 0.5; 0.01 0.02 0.05];  % Kp,Ki,Kd combinations
results = parsim('pid_control_system', 'ParameterSet', paramValues);

% Sensitivity analysis
% Use Simulink Design Optimization toolbox
open_system('pid_control_system');
opt = sdo.OptimizeOptions;
opt.Method = 'lsqnonlin';  % Least squares optimization

% Define optimization objective (reduce overshoot)
objFcn = sdo.createOptimTarget('pid_control_system/Scope', ...
    'MaxOvershoot', 'minimize');

% Run optimization
[solution, info] = sdo.optimize(objFcn, [Kp Ki Kd], opt);

% Model order reduction technique
% Use Model Reducer toolbox
reduceModel('complex_model', 'Order', 10);  % Reduce to 10th-order model

Advanced Simulation Techniques

Hybrid System Modeling

Discrete Event and Continuous System Integration:

% Create hybrid system model
new_system('hybrid_manufacturing');
open_system('hybrid_manufacturing');

% Continuous part (production process)
add_block('simulink/Continuous/Integrator', 'hybrid_manufacturing/Production_Rate');
set_param('hybrid_manufacturing/Production_Rate', 'Gain', '10');

% Discrete event part (order arrival)
add_block('simulink/Discrete/Rate Transition', 'hybrid_manufacturing/Order_Arrival');
set_param('hybrid_manufacturing/Order_Arrival', 'SampleTime', '1');

% State machine control (production scheduling)
add_block('simulink/Stateflow', 'hybrid_manufacturing/Scheduler');
set_param('hybrid_manufacturing/Scheduler', 'InitialState', 'Idle');

% Signal connections
add_line('hybrid_manufacturing', 'Order_Arrival/1', 'Scheduler/1');
add_line('hybrid_manufacturing', 'Scheduler/1', 'Production_Rate/1');

% Use event-triggered subsystem
add_block('simulink/Ports & Subsystems/Triggered Subsystem', 'hybrid_manufacturing/Event_Handler');
set_param('hybrid_manufacturing/Event_Handler', 'TriggerType', 'function-call');

Simulation Performance Optimization

Acceleration Computation Techniques:

% Acceleration simulation method comparison
% 1. Fixed step vs variable step
set_param('complex_model', 'Solver', 'ode3');  % Variable step solver
set_param('complex_model', 'FixedStep', '0.001');  % Fixed step

% 2. Fast restart technique
set_param('complex_model', 'SaveFormat', 'StructureWithTime');
simOut = sim('complex_model', 'SaveOutput', 'on', 'SaveFormat', 'Dataset');

% 3. Model reference (hierarchical modeling)
add_block('simulink/Ports & Subsystems/Model', 'top_model/Subsystem_Reference');
set_param('top_model/Subsystem_Reference', 'ModelName', 'detailed_subsystem');

% 4. Code generation acceleration
slbuild('complex_model', 'RTWCG');  % Generate real-time code

% 5. Parallel simulation (using parsim)
simIn = Simulink.SimulationInput('complex_model');
simIn = simIn.setVariable('Param1', 1);
simIn = simIn.setVariable('Param2', 2);
results = parsim(simIn, 'ShowProgress', 'on');
Share your love