UP | HOME

Simscape Uniaxial Model

Table of Contents

The idea is to use the same model as the full Simscape Model but to restrict the motion only in the vertical direction.

This is done in order to more easily study the system and evaluate control techniques.

1 Simscape Model

A schematic of the uniaxial model used for simulations is represented in figure 1.

The perturbations \(w\) are:

  • \(F_s\): direct forces applied to the sample such as inertia forces and cable forces
  • \(F_{rz}\): parasitic forces due to the rotation of the spindle
  • \(F_{ty}\): parasitic forces due to scans with the translation stage
  • \(D_w\): ground motion

The quantity to \(z\) to control is:

  • \(D\): the position of the sample with respect to the granite

The measured quantities \(v\) are:

  • \(D\): the position of the sample with respect to the granite

We study the use of an additional sensor:

  • \(F_n\): a force sensor located in the nano-hexapod
  • \(v_n\): an absolute velocity sensor located on the top platform of the nano-hexapod
  • \(d_r\): a relative motion sensor located in the nano-hexapod

The control signal \(u\) is:

  • \(F\) the force applied by the nano-hexapod actuator

uniaxial-model-nass-flexible.png

Figure 1: Schematic of the uniaxial model used

Few active damping techniques will be compared in order to decide which sensor is to be included in the system. Schematics of the active damping techniques are displayed in figure 2.

uniaxial-model-nass-flexible-active-damping.png

Figure 2: Comparison of used active damping techniques

2 Undamped System

Let's start by study the undamped system.

2.1 Init

We initialize all the stages with the default parameters. The nano-hexapod is a piezoelectric hexapod and the sample has a mass of 50kg.

All the controllers are set to 0 (Open Loop).

2.2 Identification

We identify the dynamics of the system. 

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

The inputs and outputs are defined below and corresponds to the name of simulink blocks. 

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],   1, 'input'); % Ground Motion
io(2)  = linio([mdl, '/Fs'],   1, 'input'); % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],  1, 'input'); % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'], 1, 'input'); % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'], 1, 'input'); % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

Finally, we use the linearize Matlab function to extract a state space model from the simscape model. 

%% Run the linearization
G = linearize(mdl, io, options);
G.InputName  = {'Dw',   ... % Ground Motion [m]
                'Fs',   ... % Force Applied on Sample [N]
                'Fn',   ... % Force applied by NASS [N]
                'Fty',  ... % Parasitic Force Ty [N]
                'Frz'};     % Parasitic Force Rz [N]
G.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                'Fnm',  ... % Force Sensor in NASS [N]
                'Dnm',  ... % Displacement Sensor in NASS [m]
                'Dgm',  ... % Asbolute displacement of Granite [m]
                'Vlm'}; ... % Absolute Velocity of NASS [m/s]

Finally, we save the identified system dynamics for further analysis. 

save('./uniaxial/mat/plants.mat', 'G');

2.3 Sensitivity to Disturbances

We show several plots representing the sensitivity to disturbances:

  • in figure 3 the transfer functions from ground motion \(D_w\) to the sample position \(D\) and the transfer function from direct force on the sample \(F_s\) to the sample position \(D\) are shown
  • in figure 4, it is the effect of parasitic forces of the positioning stages (\(F_{ty}\) and \(F_{rz}\)) on the position \(D\) of the sample that are shown

uniaxial-sensitivity-disturbances.png

Figure 3: Sensitivity to disturbances (png, pdf)

uniaxial-sensitivity-force-dist.png

Figure 4: Sensitivity to disturbances (png, pdf)

2.4 Plant

The transfer function from the force \(F\) applied by the nano-hexapod to the position of the sample \(D\) is shown in figure 5. It corresponds to the plant to control.

uniaxial-plant.png

Figure 5: Bode plot of the Plant (png, pdf)

3 Integral Force Feedback

uniaxial-model-nass-flexible-iff.png

Figure 6: Uniaxial IFF Control Schematic

3.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

Let's look at the transfer function from actuator forces in the nano-hexapod to the force sensor in the nano-hexapod legs for all 6 pairs of actuator/sensor.

uniaxial_iff_plant.png

Figure 7: Transfer function from forces applied in the legs to force sensor (png, pdf)

The controller for each pair of actuator/sensor is: 

K_iff = -1000/s;

uniaxial_iff_open_loop.png

Figure 8: Loop Gain for the Integral Force Feedback (png, pdf)

3.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

All the controllers are set to 0. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = -K_iff;
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = tf(0);
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = tf(0);
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_iff = linearize(mdl, io, options);
G_iff.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_iff.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_iff', '-append');

3.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_iff.png

Figure 9: Sensitivity to disturbance once the IFF controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_iff.png

Figure 10: Sensitivity to force disturbances in various stages when IFF is applied (png, pdf)

3.4 Damped Plant

uniaxial_plant_iff_damped.png

Figure 11: Damped Plant after IFF is applied (png, pdf)

3.5 Conclusion

Integral Force Feedback:

4 Relative Motion Control

In the Relative Motion Control (RMC), a derivative feedback is applied between the measured actuator displacement to the actuator force input.

uniaxial-model-nass-flexible-rmc.png

Figure 12: Uniaxial RMC Control Schematic

4.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

Let's look at the transfer function from actuator forces in the nano-hexapod to the measured displacement of the actuator for all 6 pairs of actuator/sensor.

uniaxial_rmc_plant.png

Figure 13: Transfer function from forces applied in the legs to leg displacement sensor (png, pdf)

The Relative Motion Controller is defined below. A Low pass Filter is added to make the controller transfer function proper. 

K_rmc = s*50000/(1 + s/2/pi/10000);

uniaxial_rmc_open_loop.png

Figure 14: Loop Gain for the Integral Force Feedback (png, pdf)

4.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

And initialize the controllers. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = tf(0);
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = -K_rmc;
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = tf(0);
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_rmc = linearize(mdl, io, options);
G_rmc.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_rmc.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_rmc', '-append');

4.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_rmc.png

Figure 15: Sensitivity to disturbance once the RMC controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_rmc.png

Figure 16: Sensitivity to force disturbances in various stages when RMC is applied (png, pdf)

4.4 Damped Plant

uniaxial_plant_rmc_damped.png

Figure 17: Damped Plant after RMC is applied (png, pdf)

4.5 Conclusion

Relative Motion Control:

5 Direct Velocity Feedback

In the Relative Motion Control (RMC), a feedback is applied between the measured velocity of the platform to the actuator force input.

uniaxial-model-nass-flexible-dvf.png

Figure 18: Uniaxial DVF Control Schematic

5.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

uniaxial_dvf_plant.png

Figure 19: Transfer function from forces applied in the legs to leg velocity sensor (png, pdf)

K_dvf = tf(5e4);

uniaxial_dvf_loop_gain.png

Figure 20: Transfer function from forces applied in the legs to leg velocity sensor (png, pdf)

5.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

And initialize the controllers. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = tf(0);
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = tf(0);
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = -K_dvf;
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_dvf = linearize(mdl, io, options);
G_dvf.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_dvf.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_dvf', '-append');

5.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_dvf.png

Figure 21: Sensitivity to disturbance once the DVF controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_dvf.png

Figure 22: Sensitivity to force disturbances in various stages when DVF is applied (png, pdf)

5.4 Damped Plant

uniaxial_plant_dvf_damped.png

Figure 23: Damped Plant after DVF is applied (png, pdf)

5.5 Conclusion

Direct Velocity Feedback:

6 Comparison of Active Damping Techniques

6.1 Load the plants

load('./uniaxial/mat/plants.mat', 'G', 'G_iff', 'G_rmc', 'G_dvf');

6.2 Sensitivity to Disturbance

uniaxial_sensitivity_ground_motion.png

Figure 24: Sensitivity to Ground Motion - Comparison (png, pdf)

uniaxial_sensitivity_direct_force.png

Figure 25: Sensitivity to disturbance - Comparison (png, pdf)

uniaxial_sensitivity_fty.png

Figure 26: Sensitivity to force disturbances - Comparison (png, pdf)

uniaxial_sensitivity_frz.png

Figure 27: Sensitivity to force disturbances - Comparison (png, pdf)

6.3 Damped Plant

uniaxial_plant_damped_comp.png

Figure 28: Damped Plant - Comparison (png, pdf)

6.4 Conclusion

Table 1: Comparison of proposed active damping techniques
  IFF RMC DVF
Sensor Type Force sensor Relative Motion Inertial
Guaranteed Stability + + -
Sensitivity (\(D_w\)) - + -
Sensitivity (\(F_s\)) - (at low freq) + +
Sensitivity (\(F_{ty,rz}\)) + - +

The next step is to take into account the power spectral density of each disturbance.

Author: Dehaeze Thomas

Created: 2019-10-25 ven. 16:02

Validate