Simulink Basic Modeling
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
Simulink Real-Time Configuration
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');



