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('./mat/uniaxial_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 Noise Budget

We first load the measured PSD of the disturbance. 

  load('./mat/disturbances_dist_psd.mat', 'dist_f');

The effect of these disturbances on the distance \(D\) is computed below. The PSD of the obtain distance \(D\) due to each of the perturbation is shown in figure 5 and the Cumulative Amplitude Spectrum is shown in figure 6.

The Root Mean Square value of the obtained displacement \(D\) is computed below and can be determined from the figure 6. 

3.3793e-06

uniaxial-psd-dist.png

Figure 5: PSD of the effect of disturbances on \(D\) (png, pdf)

uniaxial-cas-dist.png

Figure 6: CAS of the effect of disturbances on \(D\) (png, pdf)

2.5 Plant

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

uniaxial-plant.png

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

3 Integral Force Feedback

uniaxial-model-nass-flexible-iff.png

Figure 8: Uniaxial IFF Control Schematic

3.1 Control Design

  load('./mat/uniaxial_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 9: 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 10: 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('actuator', 'piezo');
  initializeSample('mass', 50);

All the controllers are set to 0. 

  K = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K', '-append');
  K_iff = -K_iff;
  save('./mat/controllers_uniaxial.mat', 'K_iff', '-append');
  K_rmc = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K_rmc', '-append');
  K_dvf = tf(0);
  save('./mat/controllers_uniaxial.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('./mat/uniaxial_plants.mat', 'G_iff', '-append');

3.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_iff.png

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

uniaxial_sensitivity_dist_stages_iff.png

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

3.4 Damped Plant

uniaxial_plant_iff_damped.png

Figure 13: 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 14: Uniaxial RMC Control Schematic

4.1 Control Design

  load('./mat/uniaxial_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 15: 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 16: 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('actuator', 'piezo');
  initializeSample('mass', 50);

And initialize the controllers. 

  K = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K', '-append');
  K_iff = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K_iff', '-append');
  K_rmc = -K_rmc;
  save('./mat/controllers_uniaxial.mat', 'K_rmc', '-append');
  K_dvf = tf(0);
  save('./mat/controllers_uniaxial.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('./mat/uniaxial_plants.mat', 'G_rmc', '-append');

4.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_rmc.png

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

uniaxial_sensitivity_dist_stages_rmc.png

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

4.4 Damped Plant

uniaxial_plant_rmc_damped.png

Figure 19: 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 20: Uniaxial DVF Control Schematic

5.1 Control Design

  load('./mat/uniaxial_plants.mat', 'G');

uniaxial_dvf_plant.png

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

  K_dvf = tf(5e4);

uniaxial_dvf_loop_gain.png

Figure 22: 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('actuator', 'piezo');
  initializeSample('mass', 50);

And initialize the controllers. 

  K = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K', '-append');
  K_iff = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K_iff', '-append');
  K_rmc = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K_rmc', '-append');
  K_dvf = -K_dvf;
  save('./mat/controllers_uniaxial.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('./mat/uniaxial_plants.mat', 'G_dvf', '-append');

5.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_dvf.png

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

uniaxial_sensitivity_dist_stages_dvf.png

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

5.4 Damped Plant

uniaxial_plant_dvf_damped.png

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

5.5 Conclusion

Direct Velocity Feedback:

6 With Cedrat Piezo-electric Actuators

The model used for the Cedrat actuator is shown in figure 26.

cedrat-uniaxial-actuator.png

Figure 26: Schematic of the model used for the Cedrat Actuator

6.1 Identification

Let’s initialize the system prior to identification. 

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

And initialize the controllers. 

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

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_cedrat_bis';

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]

6.2 Control Design

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_cedrat_plant.png

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

The controller for each pair of actuator/sensor is: 

  K_cedrat = -5000/s;

uniaxial_cedrat_open_loop.png

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

6.3 Identification

Let’s initialize the system prior to identification. 

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

All the controllers are set to 0. 

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

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

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

  %% 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_cedrat = linearize(mdl, io, options);
  G_cedrat.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_cedrat.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('./mat/uniaxial_plants.mat', 'G_cedrat', '-append');

6.4 Sensitivity to Disturbance

uniaxial_sensitivity_dist_cedrat.png

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

uniaxial_sensitivity_dist_stages_cedrat.png

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

6.5 Damped Plant

uniaxial_plant_cedrat_damped.png

Figure 31: Damped Plant after CEDRAT is applied (png, pdf)

6.6 Conclusion

This gives similar results than with a classical force sensor.

7 Comparison of Active Damping Techniques

7.1 Load the plants

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

7.2 Sensitivity to Disturbance

uniaxial_sensitivity_ground_motion.png

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

uniaxial_sensitivity_direct_force.png

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

uniaxial_sensitivity_fty.png

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

uniaxial_sensitivity_frz.png

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

7.3 Noise Budget

We first load the measured PSD of the disturbance. 

  load('./mat/disturbances_dist_psd.mat', 'dist_f');

The effect of these disturbances on the distance \(D\) is computed for all active damping techniques. We then compute the Cumulative Amplitude Spectrum (figure 36).

uniaxial-comp-cas-dist.png

Figure 36: Comparison of the Cumulative Amplitude Spectrum of \(D\) for different active damping techniques (png, pdf)

The obtained Root Mean Square Value for each active damping technique is shown below.

Table 1: Obtain Root Mean Square value of \(D\) for each Active Damping Technique applied
  D [m rms]
OL 3.38e-06
IFF 3.40e-06
RMC 3.37e-06
DVF 3.38e-06

It is important to note that the effect of direct forces applied to the sample are not taken into account here.

7.4 Damped Plant

uniaxial_plant_damped_comp.png

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

7.5 Conclusion

Table 2: 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}\)) + - +
Overall RMS of \(D\) = = =

8 Voice Coil

8.1 Init

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

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

8.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_vc = linearize(mdl, io, options);
  G_vc.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_vc.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('./mat/uniaxial_plants.mat', 'G_vc', '-append');

8.3 Sensitivity to Disturbances

We load the dynamics when using a piezo-electric nano hexapod to compare the results. 

  load('./mat/uniaxial_plants.mat', 'G');

We show several plots representing the sensitivity to disturbances:

  • in figure 38 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 39, 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-vc-disturbances.png

Figure 38: Sensitivity to disturbances (png, pdf)

uniaxial-sensitivity-vc-force-dist.png

Figure 39: Sensitivity to disturbances (png, pdf)

8.4 Noise Budget

We first load the measured PSD of the disturbance. 

  load('./mat/disturbances_dist_psd.mat', 'dist_f');

The effect of these disturbances on the distance \(D\) is computed below. The PSD of the obtain distance \(D\) due to each of the perturbation is shown in figure 40 and the Cumulative Amplitude Spectrum is shown in figure 41.

The Root Mean Square value of the obtained displacement \(D\) is computed below and can be determined from the figure 41. 

4.8793e-06

uniaxial-vc-psd-dist.png

Figure 40: PSD of the displacement \(D\) due to disturbances (png, pdf)

uniaxial-vc-cas-dist.png

Figure 41: CAS of the displacement \(D\) due the disturbances (png, pdf)

Even though the RMS value of the displacement \(D\) is lower when using a piezo-electric actuator, the motion is mainly due to high frequency disturbances which are more difficult to control (an higher control bandwidth is required).

Thus, it may be desirable to use voice coil actuators.

8.5 Integral Force Feedback

  K_iff = -20/s;

uniaxial_iff_vc_open_loop.png

Figure 42: Open Loop Transfer Function for IFF control when using a voice coil actuator (png, pdf)

8.6 Identification of the Damped Plant

Let’s initialize the system prior to identification. 

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

All the controllers are set to 0. 

  K = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K', '-append');
  K_iff = -K_iff;
  save('./mat/controllers_uniaxial.mat', 'K_iff', '-append');
  K_rmc = tf(0);
  save('./mat/controllers_uniaxial.mat', 'K_rmc', '-append');
  K_dvf = tf(0);
  save('./mat/controllers_uniaxial.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_vc_iff = linearize(mdl, io, options);
  G_vc_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_vc_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]

8.7 Noise Budget

We compute the obtain PSD of the displacement \(D\) when using IFF.

uniaxial-cas-iff-vc.png

Figure 43: CAS of the displacement \(D\) (png, pdf)

8.8 Conclusion

The use of voice coil actuators would allow a better disturbance rejection for a fixed bandwidth compared with a piezo-electric hexapod.

Similarly, it would require much lower bandwidth to attain the same level of disturbance rejection for \(D\).

Author: Dehaeze Thomas

Created: 2021-02-20 sam. 23:08