1609 lines
54 KiB
Org Mode
1609 lines
54 KiB
Org Mode
#+TITLE: Voltage Amplifier PD200 - Test Bench
|
|
:DRAWER:
|
|
#+LANGUAGE: en
|
|
#+EMAIL: dehaeze.thomas@gmail.com
|
|
#+AUTHOR: Dehaeze Thomas
|
|
|
|
#+HTML_LINK_HOME: ../index.html
|
|
#+HTML_LINK_UP: ../index.html
|
|
|
|
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="https://research.tdehaeze.xyz/css/style.css"/>
|
|
#+HTML_HEAD: <script type="text/javascript" src="https://research.tdehaeze.xyz/js/script.js"></script>
|
|
|
|
#+BIND: org-latex-image-default-option "scale=1"
|
|
#+BIND: org-latex-image-default-width ""
|
|
|
|
#+LaTeX_CLASS: scrreprt
|
|
#+LaTeX_CLASS_OPTIONS: [a4paper, 10pt, DIV=12, parskip=full]
|
|
#+LaTeX_HEADER_EXTRA: \input{preamble.tex}
|
|
|
|
#+PROPERTY: header-args:matlab :session *MATLAB*
|
|
#+PROPERTY: header-args:matlab+ :comments org
|
|
#+PROPERTY: header-args:matlab+ :exports both
|
|
#+PROPERTY: header-args:matlab+ :results none
|
|
#+PROPERTY: header-args:matlab+ :eval no-export
|
|
#+PROPERTY: header-args:matlab+ :noweb yes
|
|
#+PROPERTY: header-args:matlab+ :mkdirp yes
|
|
#+PROPERTY: header-args:matlab+ :output-dir figs
|
|
|
|
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
|
|
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes
|
|
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
|
|
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100
|
|
#+PROPERTY: header-args:latex+ :results file raw replace
|
|
#+PROPERTY: header-args:latex+ :buffer no
|
|
#+PROPERTY: header-args:latex+ :tangle no
|
|
#+PROPERTY: header-args:latex+ :eval no-export
|
|
#+PROPERTY: header-args:latex+ :exports results
|
|
#+PROPERTY: header-args:latex+ :mkdirp yes
|
|
#+PROPERTY: header-args:latex+ :output-dir figs
|
|
#+PROPERTY: header-args:latex+ :post pdf2svg(file=*this*, ext="png")
|
|
:END:
|
|
|
|
#+begin_export html
|
|
<hr>
|
|
<p>This report is also available as a <a href="./test-bench-pd200.pdf">pdf</a>.</p>
|
|
<hr>
|
|
#+end_export
|
|
|
|
* Introduction
|
|
The goal of this test bench is to characterize the Voltage amplifier [[https://www.piezodrive.com/drivers/pd200-60-watt-voltage-amplifier/][PD200]] from PiezoDrive.
|
|
|
|
The documentation of the PD200 is accessible [[file:doc/PD200-V7-R1.pdf][here]].
|
|
|
|
#+name: fig:amplifier_PD200
|
|
#+caption: Picture of the PD200 Voltage Amplifier
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:figs/amplifier_PD200.png]]
|
|
|
|
* Voltage Amplifier Requirements
|
|
|
|
#+name: tab:voltage_amplifier_requirements
|
|
#+caption: Requirements for the Voltage Amplifier
|
|
#+attr_latex: :environment tabularx :width 0.5\linewidth :align lX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
| <l> | <c> |
|
|
| | *Specification* |
|
|
|--------------------------------+--------------------|
|
|
| Continuous Current | > 50 [mA] |
|
|
| Output Voltage Noise (1-200Hz) | < 2 [mV rms] |
|
|
| Voltage Input Range | +/- 10 [V] |
|
|
| Voltage Output Range | -20 [V] to 150 [V] |
|
|
| Small signal bandwidth (-3dB) | > 5 [kHz] |
|
|
|
|
* PD200 Expected characteristics
|
|
|
|
#+name: tab:pd200_characteristics
|
|
#+caption: Characteristics of the PD200
|
|
#+attr_latex: :environment tabularx :width \linewidth :align lXX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
| <l> | <c> | <c> |
|
|
| *Characteristics* | *Manual* | *Specification* |
|
|
|-------------------------------------+--------------+-----------------|
|
|
| Input Voltage Range | +/- 10 [V] | +/- 10 [V] |
|
|
| Output Voltage Range | -50/150 [V] | -20/150 [V] |
|
|
| Gain | 20 [V/V] | |
|
|
| Maximum RMS current | 0.9 [A] | > 50 [mA] |
|
|
| Maximum Pulse current | 10 [A] | |
|
|
| Slew Rate | 150 [V/us] | |
|
|
| Noise (10uF load) | 0.7 [mV RMS] | < 2 [mV rms] |
|
|
| Small Signal Bandwidth (10uF load) | 7.4 [kHz] | > 5 [kHz] |
|
|
| Large Signal Bandwidth (150V, 10uF) | 300 [Hz] | |
|
|
|
|
For a load capacitance of $10\,\mu F$, the expected $-3\,dB$ bandwidth is $6.4\,kHz$ (Figure [[fig:pd200_expected_small_signal_bandwidth]]) and the low frequency noise is $650\,\mu V\,\text{rms}$ (Figure [[fig:pd200_expected_noise]]).
|
|
|
|
#+name: fig:pd200_expected_small_signal_bandwidth
|
|
#+caption:Expected small signal bandwidth
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:./figs/pd200_expected_small_signal_bandwidth.png]]
|
|
|
|
#+name: fig:pd200_expected_noise
|
|
#+caption: Expected Low frequency noise from 0.03Hz to 20Hz
|
|
#+attr_latex: :width 0.8\linewidth
|
|
[[file:figs/pd200_expected_noise.png]]
|
|
|
|
* Voltage Amplifier Model
|
|
The Amplifier is characterized by its dynamics $G_p(s)$ from voltage inputs $V_{in}$ to voltage output $V_{out}$.
|
|
Ideally, the gain from $V_{in}$ to $V_{out}$ is constant over a wide frequency band with very small phase drop.
|
|
|
|
It is also characterized by its output noise $n$.
|
|
This noise is described by its Power Spectral Density.
|
|
|
|
The objective is therefore to determine the transfer function $G_p(s)$ from the input voltage to the output voltage as well as the Power Spectral Density $S_n(\omega)$ of the amplifier output noise.
|
|
|
|
As both $G_p$ and $S_n$ depends on the load capacitance, they should be measured when loading the amplifier with a $10\,\mu F$ capacitor.
|
|
|
|
#+begin_src latex :file pd200-model-schematic.pdf
|
|
\begin{tikzpicture}
|
|
\node[block] (G) at (0,0){$G_p(s)$};
|
|
\node[addb, right=0.8 of G] (add){};
|
|
|
|
\draw[<-] (G.west) -- ++(-1.2, 0) node[above right]{$V_{in}$};
|
|
\draw[->] (G.east) -- (add.west);
|
|
\draw[->] (add.east) -- ++(1.2, 0) node[above left]{$V_{out}$};
|
|
\draw[<-] (add.north) -- ++(0, 0.6) node[below right](n){$n$};
|
|
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(G.south west) (n.north-|add.east)}, inner sep=8pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[below] at (P.north) {PD-200};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
#+end_src
|
|
|
|
#+name: fig:pd200-model-schematic
|
|
#+caption: Model of the voltage amplifier
|
|
#+RESULTS:
|
|
[[file:figs/pd200-model-schematic.png]]
|
|
|
|
* Noise measurement
|
|
** Introduction :ignore:
|
|
|
|
- Section [[sec:noise_setup]]
|
|
- Section [[sec:noise_model]]
|
|
- Section [[sec:noise_quantization]]
|
|
- Section [[sec:noise_preamp]]
|
|
- Section [[sec:noise_pd200]]
|
|
- Section [[sec:noise_dac]]
|
|
- Section [[sec:noise_full_measurement]]
|
|
- Section [[sec:noise_ssi2v]]
|
|
|
|
** Matlab Init :noexport:ignore:
|
|
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
|
|
<<matlab-dir>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none :results silent :noweb yes
|
|
<<matlab-init>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
** Setup
|
|
<<sec:noise_setup>>
|
|
|
|
#+begin_note
|
|
Here are the documentation of the equipment used for this test bench:
|
|
- Voltage Amplifier [[file:doc/PD200-V7-R1.pdf][PD200]]
|
|
- Load Capacitor [[file:doc/0900766b815ea422.pdf][EPCOS 10uF Multilayer Ceramic Capacitor]]
|
|
- Low Noise Voltage Amplifier [[file:doc/egg-5113-preamplifier.pdf][EG&G 5113]]
|
|
- Speedgoat ADC [[file:doc/IO131-OEM-Datasheet.pdf][IO313]]
|
|
#+end_note
|
|
|
|
The output noise of the voltage amplifier PD200 is foreseen to be around 1mV rms in a bandwidth from DC to 1MHz.
|
|
If we suppose a white noise, this correspond to an amplitude spectral density:
|
|
\begin{equation}
|
|
\phi_{n} \approx \frac{1\,mV}{\sqrt{1\,MHz}} = 1 \frac{\mu V}{\sqrt{Hz}}
|
|
\end{equation}
|
|
|
|
The RMS noise begin very small compare to the ADC resolution, we must amplify the noise before digitizing the signal.
|
|
The added noise of the instrumentation amplifier should be much smaller than the noise of the PD200.
|
|
We use the amplifier EG&G 5113 that has a noise of $\approx 4 nV/\sqrt{Hz}$ referred to its input which is much smaller than the noise induced by the PD200.
|
|
|
|
The gain of the low-noise amplifier can be increased until the full range of the ADC is used.
|
|
This gain should be around 1000.
|
|
|
|
#+name: fig:setup-noise-measurement
|
|
#+caption: Schematic of the test bench to measure the Power Spectral Density of the Voltage amplifier noise $n$
|
|
#+attr_latex: :width \linewidth
|
|
[[file:figs/setup-noise-measurement.png]]
|
|
|
|
A low pass filter at 10kHz can be included in the EG&G amplifier in order to limit aliasing.
|
|
An high pass filter at low frequency can be added if there is a problem of large offset.
|
|
|
|
** Model of the setup
|
|
<<sec:noise_model>>
|
|
|
|
As shown in Figure [[fig:noise_meas_procedure]], there are 4 equipment involved in the measurement:
|
|
- a Digital to Analog Convert (DAC)
|
|
- the Voltage amplifier to be measured with a gain of 20 (PD200)
|
|
- a low noise voltage amplifier with a variable gain and integrated low pass filters and high pass filters
|
|
- an Analog to Digital Converter (ADC)
|
|
|
|
Each of these equipment has some noise:
|
|
- $q_{da}$: quantization noise of the DAC
|
|
- $n_{da}$: output noise of the DAC
|
|
- $n_p$: output noise of the PD200 (what we wish to characterize)
|
|
- $n_a$: input noise of the pre amplifier
|
|
- $q_{ad}$: quantization noise of the ADC
|
|
|
|
#+begin_src latex :file noise_meas_procedure.pdf
|
|
\begin{tikzpicture}
|
|
% DAC
|
|
\node[DAC] (DAC) at (0,0) {DAC};
|
|
\node[addb, right=0.4 of DAC] (addqda){};
|
|
\node[addb, right=0.4 of addqda] (addnda){};
|
|
|
|
% PD200
|
|
\node[block, right=1.2 of addnda] (Gp){$G_p(s)$};
|
|
\node[addb, right=0.4 of Gp] (addnp){};
|
|
|
|
% Pre Amp
|
|
\node[addb, right=1.2 of addnp] (addna){};
|
|
\node[block, right=0.4 of addna] (Ga) {$G_a(s)$};
|
|
|
|
% ADC
|
|
\node[addb, right=1.2 of Ga] (addqad){};
|
|
\node[ADC, right=0.4 of addqad] (ADC) {ADC};
|
|
|
|
% \draw[->] (const.east) -- node[sloped]{$/$} (DAC.west);
|
|
\draw[<-] (DAC.west) -- node[sloped]{$/$} ++(-1.0, 0);
|
|
\draw[->] (DAC.east) -- (addqda.west);
|
|
\draw[->] (addqda.east) -- (addnda.west);
|
|
\draw[->] (addnda.east) -- (Gp.west);
|
|
\draw[->] (Gp.east) -- (addnp.west);
|
|
\draw[->] (addnp.east) -- (addna.west);
|
|
\draw[->] (addna.east) -- (Ga.west);
|
|
\draw[->] (Ga.east) -- (addqad.west);
|
|
\draw[->] (addqad.east) -- (ADC.west);
|
|
\draw[->] (ADC.east) -- node[sloped]{$/$} ++(1.0, 0) node[above left]{$n$};
|
|
|
|
\draw[<-] (addnda.north) -- ++(0, 0.6) node[below right](nda){$n_{da}$};
|
|
\draw[<-] (addqda.north) -- ++(0, 0.6) node[below right](qda){$q_{da}$};
|
|
|
|
\draw[<-] (addnp.north) -- ++(0, 0.6) node[below right](np){$n_{p}$};
|
|
\draw[<-] (addna.north) -- ++(0, 0.6) node[below right](na){$n_{a}$};
|
|
|
|
\draw[<-] (addqad.north) -- ++(0, 0.6) node[below right](qad){$q_{ad}$};
|
|
|
|
\coordinate[] (top) at (nda.north);
|
|
\coordinate[] (bot) at (Ga.south);
|
|
|
|
% DAC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(DAC.west|-bot) (addnda.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {DAC};
|
|
\end{scope}
|
|
|
|
% PD200
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(Gp.west|-bot) (addnp.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {PD200};
|
|
\end{scope}
|
|
|
|
% 5113
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addna.west|-bot) (Ga.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {Pre Amp};
|
|
\end{scope}
|
|
|
|
% ADC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addqad.west|-bot) (ADC.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {ADC};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
#+end_src
|
|
|
|
#+name: fig:noise_meas_procedure
|
|
#+caption: Sources of noise in the experimental setup
|
|
#+RESULTS:
|
|
[[file:figs/noise_meas_procedure.png]]
|
|
|
|
** Quantization Noise
|
|
<<sec:noise_quantization>>
|
|
|
|
The quantization noise is something that can be predicted.
|
|
The Amplitude Spectral Density of the quantization noise of an ADC/DAC is equal to:
|
|
\begin{equation}
|
|
\Gamma_q(\omega) = \frac{q}{\sqrt{12 f_s}}
|
|
\end{equation}
|
|
with:
|
|
- $q = \frac{\Delta V}{2^n}$ the quantization in [V], which is the corresponding value in [V] of the least significant bit
|
|
- $\Delta V$ is the full range of the ADC in [V]
|
|
- $n$ is the number of bits
|
|
- $f_s$ is the sample frequency in [Hz]
|
|
|
|
#+begin_src matlab
|
|
adc = struct();
|
|
adc.Delta_V = 20; % [V]
|
|
adc.n = 16; % number of bits
|
|
adc.Fs = 20e3; % [Hz]
|
|
adc.Gamma_q = adc.Delta_V/2^adc.n/sqrt(12*adc.Fs); % [V/sqrt(Hz)]
|
|
#+end_src
|
|
|
|
The obtained Amplitude Spectral Density is src_matlab[:exports results :results value replace]{adc.Gamma_q} {{{results(=6.2294e-07=)}}} $V/\sqrt{Hz}$.
|
|
|
|
** Pre Amplifier noise measurement
|
|
<<sec:noise_preamp>>
|
|
|
|
First, we wish to measure the noise of the pre-amplifier.
|
|
To do so, the input of the pre-amplifier is shunted such that there is 0V at its inputs.
|
|
Then, the gain of the amplifier is increase until the measured signal on the ADC is much larger than the quantization noise.
|
|
|
|
The Amplitude Spectral Density $\Gamma_n(\omega)$ of the measured signal $n$ is computed.
|
|
Finally, the Amplitude Spectral Density of $n_a$ can be computed taking into account the gain of the pre-amplifier:
|
|
\begin{equation}
|
|
\Gamma_{n_a}(\omega) \approx \frac{\Gamma_n(\omega)}{|G_a(\omega)|}
|
|
\end{equation}
|
|
|
|
This is true if the quantization noise $\Gamma_{q_{ad}}$ is negligible.
|
|
|
|
#+begin_src latex :file noise_measure_setup_preamp.pdf
|
|
\begin{tikzpicture}
|
|
\node[block={0.6cm}{0.6cm}] (const) {$0$};
|
|
% Pre Amp
|
|
\node[addb, right=0.6 of const] (addna) {};
|
|
\node[block, right=0.4 of addna] (Ga) {$G_a(s)$};
|
|
|
|
% ADC
|
|
\node[addb, right=1.2 of Ga] (addqad){};
|
|
\node[ADC, right=0.4 of addqad] (ADC) {ADC};
|
|
|
|
\draw[->] (const.east) -- (addna.west);
|
|
\draw[->] (addna.east) -- (Ga.west);
|
|
\draw[->] (Ga.east) -- (addqad.west);
|
|
\draw[->] (addqad.east) -- (ADC.west);
|
|
\draw[->] (ADC.east) -- node[sloped]{$/$} ++(1.0, 0) node[above left]{$n$};
|
|
|
|
\draw[<-] (addna.north) -- ++(0, 0.6) node[below right](na){$n_{a}$};
|
|
\draw[<-] (addqad.north) -- ++(0, 0.6) node[below right](qad){$q_{ad}$};
|
|
|
|
\coordinate[] (top) at (na.north);
|
|
\coordinate[] (bot) at (Ga.south);
|
|
|
|
% 5113
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addna.west|-bot) (Ga.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {Pre Amp};
|
|
\end{scope}
|
|
|
|
% ADC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addqad.west|-bot) (ADC.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {ADC};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
#+end_src
|
|
|
|
#+name: fig:noise_measure_setup_preamp
|
|
#+caption: Sources of noise in the experimental setup
|
|
#+RESULTS:
|
|
[[file:figs/noise_measure_setup_preamp.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
% Load Data
|
|
preamp = load('mat/noise_preamp_5113.mat', 't', 'Vn', 'notes');
|
|
#+end_src
|
|
|
|
The gain of the low noise amplifier is set to src_matlab[:exports results :results value replace]{ans = preamp.notes.pre_amp.gain} {{{results(=50000=)}}}.
|
|
|
|
#+begin_src matlab :exports none
|
|
% Compute the equivalent voltage at the input of the amplifier
|
|
preamp.Vn = preamp.Vn/preamp.notes.pre_amp.gain;
|
|
preamp.Vn = preamp.Vn - mean(preamp.Vn);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (preamp.t(end) - preamp.t(1))/(length(preamp.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
% Hanning window
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
% Power Spectral Density
|
|
[pxx, f] = pwelch(preamp.Vn, win, [], [], Fs);
|
|
|
|
% Save the results inside the struct
|
|
preamp.pxx = pxx;
|
|
preamp.f = f;
|
|
#+end_src
|
|
|
|
The obtained Amplitude Spectral Density of the Low Noise Voltage Amplifier is shown in Figure [[fig:asd_preamp]].
|
|
The obtained noise amplitude is very closed to the one specified in the documentation of $4nV/\sqrt{Hz}$ at 1kHZ.
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', '$\Gamma_{n_a}$');
|
|
plot([1 Fs/2], [adc.Gamma_q, adc.Gamma_q]./preamp.notes.pre_amp.gain, 'k--', 'DisplayName', '$\Gamma_{q_{ad}}/|G_a|$');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'northeast');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_preamp.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_preamp
|
|
#+caption: Obtained Amplitude Spectral Density of the Low Noise Voltage Amplifier
|
|
#+RESULTS:
|
|
[[file:figs/asd_preamp.png]]
|
|
|
|
** PD200 noise measurement
|
|
<<sec:noise_pd200>>
|
|
|
|
The input of the PD200 amplifier is shunted such that there is 0V between its inputs.
|
|
Then the gain of the pre-amplifier is increased in order to measure a signal much larger than the quantization noise of the ADC.
|
|
We compute the Amplitude Spectral Density of the measured signal $\Gamma_n(\omega)$.
|
|
The Amplitude Spectral Density of $n_p$ can be computed taking into account the gain of the pre-amplifier:
|
|
\begin{equation}
|
|
\Gamma_{n_p}(\omega) = \frac{\Gamma_n(\omega)}{|G_a(\omega)|}
|
|
\end{equation}
|
|
|
|
And we verify that this is indeed the noise of the PD200 and not the noise of the pre-amplifier by checking that:
|
|
\begin{equation}
|
|
\Gamma_{n_p} \ll \Gamma_{n_a}
|
|
\end{equation}
|
|
|
|
#+begin_src latex :file noise_measure_setup_pd200.pdf
|
|
\begin{tikzpicture}
|
|
\node[block={0.6cm}{0.6cm}] (const) {$0$};
|
|
|
|
% PD200
|
|
\node[block, right=0.6 of const] (Gp){$G_p(s)$};
|
|
\node[addb, right=0.4 of Gp] (addnp){};
|
|
|
|
% Pre Amp
|
|
\node[addb, right=1.2 of addnp] (addna) {};
|
|
\node[block, right=0.4 of addna] (Ga) {$G_a(s)$};
|
|
|
|
% ADC
|
|
\node[addb, right=1.2 of Ga] (addqad){};
|
|
\node[ADC, right=0.4 of addqad] (ADC) {ADC};
|
|
|
|
\draw[->] (const.east) -- (Gp.west);
|
|
\draw[->] (Gp.east) -- (addnp.west);
|
|
\draw[->] (addnp.east) -- (addna.west);
|
|
\draw[->] (addna.east) -- (Ga.west);
|
|
\draw[->] (Ga.east) -- (addqad.west);
|
|
\draw[->] (addqad.east) -- (ADC.west);
|
|
\draw[->] (ADC.east) -- node[sloped]{$/$} ++(1.0, 0) node[above left]{$n$};
|
|
|
|
\draw[<-] (addnp.north) -- ++(0, 0.6) node[below right](np){$n_{p}$};
|
|
\draw[<-] (addna.north) -- ++(0, 0.6) node[below right](na){$n_{a}$};
|
|
\draw[<-] (addqad.north) -- ++(0, 0.6) node[below right](qad){$q_{ad}$};
|
|
|
|
\coordinate[] (top) at (na.north);
|
|
\coordinate[] (bot) at (Ga.south);
|
|
|
|
% PD200
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(Gp.west|-bot) (addnp.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {PD200};
|
|
\end{scope}
|
|
|
|
% 5113
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addna.west|-bot) (Ga.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {Pre Amp};
|
|
\end{scope}
|
|
|
|
% ADC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addqad.west|-bot) (ADC.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {ADC};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
#+end_src
|
|
|
|
#+name: fig:noise_measure_setup_pd200
|
|
#+caption: Sources of noise in the experimental setup
|
|
#+RESULTS:
|
|
[[file:figs/noise_measure_setup_pd200.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
pd200w = {};
|
|
for i = 1:7
|
|
pd200w(i) = {load(['mat/noise_PD200_' num2str(i) '_3uF_warmup.mat'], 't', 'Vn', 'notes')};
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Take into account the pre-amplifier gain
|
|
for i = 1:7
|
|
pd200w{i}.Vn = pd200w{i}.Vn/pd200w{i}.notes.pre_amp.gain;
|
|
end
|
|
#+end_src
|
|
|
|
The measured low frequency noise $n_p$ of one of the amplifiers is shown in Figure [[fig:pd200_noise_time_lpf]].
|
|
It is very similar to the one specified in the datasheet in Figure [[fig:pd200_expected_noise]].
|
|
#+begin_src matlab :exports none
|
|
% Compute the low frequency noise
|
|
G_lpf = 1/(1 + s/2/pi/20);
|
|
t_max = 40;
|
|
|
|
figure;
|
|
hold on;
|
|
plot(pd200w{1}.t(1:t_max/Ts), lsim(G_lpf, 1e3*pd200w{1}.Vn(1:t_max/Ts), pd200w{1}.t(1:t_max/Ts)))
|
|
hold off;
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [mV]');
|
|
ylim([-3, 3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/pd200_noise_time_lpf.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:pd200_noise_time_lpf
|
|
#+caption: Measured low frequency noise of the PD200 from 0.01Hz to 20Hz
|
|
#+RESULTS:
|
|
[[file:figs/pd200_noise_time_lpf.png]]
|
|
|
|
The obtained RMS and peak to peak values of the measured noises are shown in Table [[tab:rms_pkp_noise]].
|
|
#+begin_src matlab :exports none
|
|
%% Compute the RMS and Peak to Peak noise for the low frequency noise
|
|
Vn_rms = zeros(7,1); % RMS value [uV rms]
|
|
Vn_pkp = zeros(7,1); % Peak to Peak Value in 20Hz bandwidth [mV]
|
|
for i = 1:7
|
|
Vn_rms(i) = 1e6*rms(pd200w{i}.Vn);
|
|
Vn_lpf = lsim(1/(1 + s/2/pi/20), pd200w{i}.Vn, pd200w{i}.t);
|
|
Vn_pkp(i) = 1e3*(max(Vn_lpf)-min(Vn_lpf));
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([[714; Vn_rms], [4.3; Vn_pkp]], {'Specification [10uF]', 'PD200_1', 'PD200_2', 'PD200_3', 'PD200_4', 'PD200_5', 'PD200_6', 'PD200_7'}, {'*RMS [uV]*', '*Peak to Peak [mV]*'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:rms_pkp_noise
|
|
#+caption: RMS and Peak to Peak measured low frequency noise (0.01Hz to 20Hz)
|
|
#+attr_latex: :environment tabularx :width \linewidth :align lXX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | *RMS [uV]* | *Peak to Peak [mV]* |
|
|
|----------------------+------------+---------------------|
|
|
| Specification [10uF] | 714.0 | 4.3 |
|
|
| PD200_1 | 565.1 | 3.7 |
|
|
| PD200_2 | 767.6 | 3.5 |
|
|
| PD200_3 | 479.9 | 3.0 |
|
|
| PD200_4 | 615.7 | 3.5 |
|
|
| PD200_5 | 651.0 | 2.4 |
|
|
| PD200_6 | 473.2 | 2.7 |
|
|
| PD200_7 | 423.1 | 2.3 |
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200w{1}.t(end) - pd200w{1}.t(1))/(length(pd200w{1}.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
for i = 1:7
|
|
[pxx, f] = pwelch(pd200w{i}.Vn, win, [], [], Fs);
|
|
pd200w{i}.f = f;
|
|
pd200w{i}.pxx = pxx;
|
|
end
|
|
#+end_src
|
|
|
|
The Amplitude Spectral Density of the measured noise is now computed and shown in Figure [[fig:asd_noise_3uF_warmup]].
|
|
#+begin_src matlab :exports none
|
|
colors = get(gca,'colororder');
|
|
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', '$\Gamma_{n_a}$');
|
|
plot(pd200w{1}.f, sqrt(pd200w{1}.pxx), 'color', [colors(2, :), 0.5], 'DisplayName', '$\Gamma_{n_p}$');
|
|
for i = 2:7
|
|
plot(pd200w{i}.f, sqrt(pd200w{i}.pxx), 'color', [colors(2, :), 0.5], 'HandleVisibility', 'off');
|
|
end
|
|
plot([1 Fs/2], [adc.Gamma_q, adc.Gamma_q]./pd200w{1}.notes.pre_amp.gain, 'k--', 'DisplayName', '$\Gamma_{q_{ad}}/|G_a|$');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southeast');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_3uF_warmup.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_3uF_warmup
|
|
#+caption: Amplitude Spectral Density of the measured noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_3uF_warmup.png]]
|
|
|
|
** DAC noise measurement
|
|
<<sec:noise_dac>>
|
|
|
|
In order not to have any quantization noise, we impose the DAC to output a zero voltage.
|
|
The gain of the low noise amplifier is adjusted to
|
|
|
|
The Amplitude Spectral Density $\Gamma_n(\omega)$ of the measured signal is computed.
|
|
The Amplitude Spectral Density of $n_{da}$ can be computed taking into account the gain of the pre-amplifier:
|
|
\begin{equation}
|
|
\Gamma_{n_{da}}(\omega) = \frac{\Gamma_m(\omega)}{|G_a(\omega)|}
|
|
\end{equation}
|
|
|
|
And it is verify that the Amplitude Spectral Density of $n_{da}$ is much larger than the one of $n_a$:
|
|
\begin{equation}
|
|
\Gamma_{n_{da}} \gg \Gamma_{n_a}
|
|
\end{equation}
|
|
|
|
#+begin_src latex :file noise_measure_setup_dac.pdf
|
|
\begin{tikzpicture}
|
|
\node[block={0.6cm}{0.6cm}] (const) {$0$};
|
|
|
|
% DAC
|
|
\node[DAC, right=0.6 of const] (DAC) {DAC};
|
|
\node[addb, right=0.4 of DAC] (addnda){};
|
|
|
|
% Pre Amp
|
|
\node[addb, right=1.2 of addnda] (addna) {};
|
|
\node[block, right=0.4 of addna] (Ga) {$G_a(s)$};
|
|
|
|
% ADC
|
|
\node[addb, right=1.2 of Ga] (addqad){};
|
|
\node[ADC, right=0.4 of addqad] (ADC) {ADC};
|
|
|
|
\draw[->] (const.east) -- node[sloped]{$/$} (DAC.west);
|
|
\draw[->] (DAC.east) -- (addnda.west);
|
|
\draw[->] (addnda.east) -- (addna.west);
|
|
\draw[->] (addna.east) -- (Ga.west);
|
|
\draw[->] (Ga.east) -- (addqad.west);
|
|
\draw[->] (addqad.east) -- (ADC.west);
|
|
\draw[->] (ADC.east) -- node[sloped]{$/$} ++(1.0, 0);
|
|
|
|
\draw[<-] (addnda.north) -- ++(0, 0.6) node[below right](nda){$n_{da}$};
|
|
\draw[<-] (addna.north) -- ++(0, 0.6) node[below right](na){$n_{a}$};
|
|
\draw[<-] (addqad.north) -- ++(0, 0.6) node[below right](qad){$q_{ad}$};
|
|
|
|
\coordinate[] (top) at (na.north);
|
|
\coordinate[] (bot) at (Ga.south);
|
|
|
|
% DAC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(DAC.west|-bot) (addnda.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {DAC};
|
|
\end{scope}
|
|
|
|
% 5113
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addna.west|-bot) (Ga.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {Pre Amp};
|
|
\end{scope}
|
|
|
|
% ADC
|
|
\begin{scope}[on background layer]
|
|
\node[fit={(addqad.west|-bot) (ADC.east|-top)}, inner sep=10pt, draw, dashed, fill=black!20!white] (P) {};
|
|
\node[above] at (P.north) {ADC};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
#+end_src
|
|
|
|
#+name: fig:noise_measure_setup_dac
|
|
#+caption: Sources of noise in the experimental setup
|
|
#+RESULTS:
|
|
[[file:figs/noise_measure_setup_dac.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
dac = load('mat/noise_preamp_5113_dac.mat', 't', 'Vn', 'notes');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
dac.Vn = dac.Vn/dac.notes.pre_amp.gain;
|
|
dac.Vn = dac.Vn - mean(dac.Vn);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (dac.t(end) - dac.t(1))/(length(dac.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx, f] = pwelch(dac.Vn, win, [], [], Fs);
|
|
dac.pxx = pxx;
|
|
dac.f = f;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
colors = get(gca,'colororder');
|
|
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', '$\Gamma_{n_a}$');
|
|
set(gca,'ColorOrderIndex',3)
|
|
plot(dac.f, sqrt(dac.pxx), 'DisplayName', '$\Gamma_{n_{da}}$');
|
|
plot([1 Fs/2], [adc.Gamma_q, adc.Gamma_q]./dac.notes.pre_amp.gain, 'k--', 'DisplayName', '$\Gamma_{q_{ad}}/|G_a|$');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southeast');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_dac.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_dac
|
|
#+caption:
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_dac.png]]
|
|
|
|
** Total noise measurement
|
|
<<sec:noise_full_measurement>>
|
|
|
|
Let's now analyze the measurement of the setup in Figure [[fig:noise_meas_procedure]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
pd200dac = {};
|
|
for i = 1:7
|
|
pd200dac(i) = {load(['mat/noise_PD200_' num2str(i) '_3uF_DAC.mat'], 't', 'Vn', 'notes')};
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Take into account the pre-amplifier gain
|
|
for i = 1:7
|
|
pd200dac{i}.Vn = pd200dac{i}.Vn/pd200dac{i}.notes.pre_amp.gain;
|
|
pd200dac{i}.Vn = pd200dac{i}.Vn - mean(pd200dac{i}.Vn);
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200dac{1}.t(end) - pd200dac{1}.t(1))/(length(pd200dac{1}.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
The PSD of the measured noise is computed and the ASD is shown in Figure [[fig:asd_noise_tot]].
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
for i = 1:7
|
|
[pxx, f] = pwelch(pd200dac{i}.Vn, win, [], [], Fs);
|
|
pd200dac{i}.f = f;
|
|
pd200dac{i}.pxx = pxx;
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
colors = get(gca,'colororder');
|
|
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', '$\Gamma_{n_a}$');
|
|
plot(pd200w{2}.f, sqrt(pd200w{2}.pxx), 'color', [colors(2, :), 0.5], 'DisplayName', '$\Gamma_{n_p}$');
|
|
for i = 2:7
|
|
plot(pd200w{i}.f, sqrt(pd200w{i}.pxx), 'color', [colors(2, :), 0.5], 'HandleVisibility', 'off');
|
|
end
|
|
set(gca,'ColorOrderIndex',3)
|
|
plot(dac.f, 20*sqrt(dac.pxx), 'DisplayName', '$|G_p| \cdot \Gamma_{n_{da}}$');
|
|
plot([1 Fs/2], [adc.Gamma_q, adc.Gamma_q]./dac.notes.pre_amp.gain, 'k--', 'DisplayName', '$\Gamma_{q_{ad}}/|G_a|$');
|
|
plot(pd200dac{2}.f, sqrt(pd200dac{2}.pxx), 'color', [colors(4, :), 0.5], 'DisplayName', '$\Gamma_{tot}$');
|
|
for i = 2:7
|
|
plot(pd200dac{i}.f, sqrt(pd200dac{i}.pxx), 'color', [colors(4, :), 0.5], 'HandleVisibility', 'off');
|
|
end
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southeast');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_tot.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_tot
|
|
#+caption: Amplitude Spectral Density of the measured noise and of the individual sources of noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_tot.png]]
|
|
|
|
#+begin_important
|
|
The output noise of the PD200 amplifier is limited by the noise of the DAC.
|
|
Having a DAC with lower noise could lower the output noise of the PD200.
|
|
SSI2V DACs will be used to verify that.
|
|
#+end_important
|
|
|
|
** 20bits DAC noise measurement
|
|
<<sec:noise_ssi2v>>
|
|
Let's now measure the noise of another DAC called the "SSI2V" ([[file:doc/\[SSI2V\]Datasheet.pdf][doc]]).
|
|
It is a 20bits DAC with an output of +/-10.48 V and a very low noise.
|
|
|
|
The measurement setup is the same as the one in Figure [[fig:noise_measure_setup_dac]].
|
|
|
|
#+begin_src matlab :exports none
|
|
ssi2v = load('mat/noise_preamp_5113_SSI2V.mat', 't', 'Vn', 'notes');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
ssi2v.Vn = ssi2v.Vn/ssi2v.notes.pre_amp.gain;
|
|
ssi2v.Vn = ssi2v.Vn - mean(ssi2v.Vn);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (ssi2v.t(end) - ssi2v.t(1))/(length(ssi2v.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx, f] = pwelch(ssi2v.Vn, win, [], [], Fs);
|
|
ssi2v.pxx = pxx;
|
|
ssi2v.f = f;
|
|
#+end_src
|
|
|
|
The obtained noise of the SSI2V DAC is shown in Figure [[fig:asd_ssi2v_noise]] and compared with the noise of the 16bits DAC.
|
|
It is shown to be much smaller (~1 order of magnitude).
|
|
|
|
#+begin_src matlab :exports none
|
|
colors = get(gca,'colororder');
|
|
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', '$\Gamma_{n_a}$');
|
|
set(gca,'ColorOrderIndex',3)
|
|
plot(dac.f, sqrt(dac.pxx), 'DisplayName', '$\Gamma_{n_{da}}$');
|
|
plot([1 Fs/2], [adc.Gamma_q, adc.Gamma_q]./ssi2v.notes.pre_amp.gain, 'k--', 'DisplayName', '$\Gamma_{q_{ad}}/|G_a|$');
|
|
set(gca,'ColorOrderIndex',5)
|
|
plot(ssi2v.f, sqrt(ssi2v.pxx), 'DisplayName', '$\Gamma_{n_{SSI2V}}$');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southeast');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_ssi2v_noise.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_ssi2v_noise
|
|
#+caption: Amplitude Spectral Density of the SSI2V DAC's noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_ssi2v_noise.png]]
|
|
|
|
#+begin_important
|
|
Using the SSI2V as the DAC with the PD200 should give much better noise output than using the 16bits DAC.
|
|
The limiting factor should then be the noise of the PD200 itself.
|
|
#+end_important
|
|
|
|
** Tests :noexport:
|
|
*** Matlab Init :noexport:ignore:
|
|
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
|
|
<<matlab-dir>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none :results silent :noweb yes
|
|
<<matlab-init>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
*** DONE Pre-Amp Noise
|
|
CLOSED: [2021-01-22 ven. 22:51]
|
|
#+begin_src matlab
|
|
preamp = load('mat/noise_preamp_5113.mat', 't', 'Vn', 'notes');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
preamp.Vn = preamp.Vn/preamp.notes.pre_amp.gain;
|
|
preamp.Vn = preamp.Vn - mean(preamp.Vn);
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
figure;
|
|
plot(preamp.t, preamp.Vn);
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [V]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (preamp.t(end) - preamp.t(1))/(length(preamp.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx, f] = pwelch(preamp.Vn, win, [], [], Fs);
|
|
|
|
preamp.pxx = pxx;
|
|
preamp.f = f;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(preamp.f, sqrt(preamp.pxx));
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
*** DONE DAC (16bits) Noise
|
|
CLOSED: [2021-01-22 ven. 23:13]
|
|
#+begin_src matlab
|
|
dac = load('mat/noise_preamp_5113_dac.mat', 't', 'Vn', 'notes');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
dac.Vn = dac.Vn/dac.notes.pre_amp.gain;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
dac.Vn = dac.Vn - mean(dac.Vn);
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
figure;
|
|
plot(dac.t, 1e6*dac.Vn);
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [$\mu V$]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (dac.t(end) - dac.t(1))/(length(dac.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx, f] = pwelch(dac.Vn, win, [], [], Fs);
|
|
dac.pxx = pxx;
|
|
dac.f = f;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(dac.f, sqrt(dac.pxx), 'DisplayName', 'DAC');
|
|
plot(dac.f, ones(size(dac.f))*(10/2^16)/sqrt(12*Fs)/dac.notes.pre_amp.gain, 'k--', 'DisplayName', 'ADC quant.');
|
|
plot(preamp.f, sqrt(preamp.pxx), 'DisplayName', 'Pre Amp');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
*** DONE Noise when shunting the input (50 Ohms) - After Warmup
|
|
CLOSED: [2021-01-22 ven. 23:09]
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
pd200w = {};
|
|
for i = 1:7
|
|
pd200w(i) = {load(['mat/noise_PD200_' num2str(i) '_3uF_warmup.mat'], 't', 'Vn', 'notes')};
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Take into account the pre-amplifier gain
|
|
for i = 1:7
|
|
pd200w{i}.Vn = pd200w{i}.Vn/pd200w{i}.notes.pre_amp.gain;
|
|
end
|
|
#+end_src
|
|
|
|
The time domain measurements of the amplifier noise are shown in Figure [[fig:noise_shunt_time_3uF_warmup]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200w{i}.t, 1e3*pd200w{i}.Vn)
|
|
end
|
|
hold off;
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [mV]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/noise_shunt_time_3uF_warmup.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:noise_shunt_time_3uF_warmup
|
|
#+caption: Time domain measurement of the amplifier output noise
|
|
#+RESULTS:
|
|
[[file:figs/noise_shunt_time_3uF_warmup.png]]
|
|
|
|
The obtained RMS and peak to peak values of the measured noises are shown in Table [[tab:rms_pkp_noise]].
|
|
#+begin_src matlab :exports none
|
|
%% Compute the RMS and Peak to Peak noise
|
|
Vn_rms = zeros(7,1); % RMS value [uV rms]
|
|
Vn_pkp = zeros(7,1); % Peak to Peak Value in 20Hz bandwidth [mV]
|
|
for i = 1:7
|
|
Vn_rms(i) = 1e6*rms(pd200w{i}.Vn);
|
|
Vn_lpf = lsim(1/(1 + s/2/pi/20), pd200w{i}.Vn, pd200w{i}.t);
|
|
Vn_pkp(i) = 1e3*(max(Vn_lpf)-min(Vn_lpf));
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([[714; Vn_rms], [4.3; Vn_pkp]], {'Specification [10uF]', 'PD200_1', 'PD200_2', 'PD200_3', 'PD200_4', 'PD200_5', 'PD200_6', 'PD200_7'}, {'*RMS [uV]*', '*Peak to Peak [mV]*'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:rms_pkp_noise
|
|
#+caption: RMS and Peak to Peak measured noise
|
|
#+attr_latex: :environment tabularx :width \linewidth :align lXX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | *RMS [uV]* | *Peak to Peak [mV]* |
|
|
|----------------------+------------+---------------------|
|
|
| Specification [10uF] | 714.0 | 4.3 |
|
|
| PD200_1 | 565.1 | 3.7 |
|
|
| PD200_2 | 767.6 | 3.5 |
|
|
| PD200_3 | 479.9 | 3.0 |
|
|
| PD200_4 | 615.7 | 3.5 |
|
|
| PD200_5 | 651.0 | 2.4 |
|
|
| PD200_6 | 473.2 | 2.7 |
|
|
| PD200_7 | 423.1 | 2.3 |
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200w{1}.t(end) - pd200w{1}.t(1))/(length(pd200w{1}.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
for i = 1:7
|
|
[pxx, f] = pwelch(pd200w{i}.Vn, win, [], [], Fs);
|
|
pd200w{i}.f = f;
|
|
pd200w{i}.pxx = pxx;
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200w{i}.f, sqrt(pd200w{i}.pxx), 'DisplayName', sprintf('PD200W-%i', i));
|
|
end
|
|
plot(preamp.f, sqrt(preamp.pxx), 'k-', 'DisplayName', 'Pre Amp');
|
|
plot(dac.f, ones(size(dac.f))*(10/2^16)/sqrt(12*Fs)/pd200w{1}.notes.pre_amp.gain, 'k--', 'DisplayName', 'ADC quant.');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
% ylim([5e-7, 1e-3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_3uF_warmup.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_3uF_warmup
|
|
#+caption: Amplitude Spectral Density of the measured noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_3uF_warmup.png]]
|
|
|
|
#+begin_src matlab
|
|
Gn = 1e-6*(s + 2*pi*40)^2/(s + 2*pi)^2;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
freqs = logspace(0, 4, 1000);
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200w{i}.f, sqrt(pd200w{i}.pxx), 'DisplayName', sprintf('PD200W-%i', i));
|
|
end
|
|
plot(freqs, abs(squeeze(freqresp(Gn, freqs, 'Hz'))), 'k--', 'DisplayName', '$|G_n(j\omega)|$');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
*** Load / No Load :noexport:
|
|
#+begin_src matlab
|
|
pd200_load = load('noise_PD200_7_3uF_warmup.mat');
|
|
pd200_no_load = load('noise_PD200_7_no_load.mat');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
pd200_load.Vn = pd200_load.Vn/pd200_load.notes.pre_amp.gain;
|
|
pd200_no_load.Vn = pd200_no_load.Vn/pd200_no_load.notes.pre_amp.gain;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200_load.t(end) - pd200_load.t(1))/(length(pd200_load.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
The PSD of the measured noise is computed and the ASD is shown in Figure [[fig:asd_noise_3uF]].
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx_load, f] = pwelch(pd200_load.Vn, win, [], [], Fs);
|
|
[pxx_no_load, ~] = pwelch(pd200_no_load.Vn, win, [], [], Fs);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(f, sqrt(pxx_load), 'DisplayName', 'Load');
|
|
plot(f, sqrt(pxx_no_load), 'DisplayName', 'No Load');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
*** Noise when shunting the input (50 Ohms) :noexport:
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
pd200 = {};
|
|
for i = 1:7
|
|
pd200(i) = {load(['mat/noise_PD200_' num2str(i) '.mat'], 't', 'Vn', 'notes')};
|
|
end
|
|
|
|
%% Take into account the pre-amplifier gain
|
|
for i = 1:7
|
|
pd200{i}.Vn = pd200{i}.Vn/pd200{i}.notes.pre_amp.gain;
|
|
end
|
|
#+end_src
|
|
|
|
The time domain measurements of the amplifier noise are shown in Figure [[fig:noise_shunt_time_3uF]].
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200{i}.t, 1e3*pd200{i}.Vn)
|
|
end
|
|
hold off;
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [mV]');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/noise_shunt_time_3uF.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:noise_shunt_time_3uF
|
|
#+caption: Time domain measurement of the amplifier output noise
|
|
#+RESULTS:
|
|
[[file:figs/noise_shunt_time_3uF.png]]
|
|
|
|
Obtained low frequency (0.1Hz - 20Hz) noise is shown in Figure [[fig:low_noise_time_domain_3uF]] which is very similar to the noise shown in the documentation (Figure [[fig:pd200_expected_noise]]).
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(pd200{1}.t, lsim(1/(1 + s/2/pi/20), 1e3*pd200{1}.Vn, pd200{1}.t))
|
|
hold off;
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [mV]');
|
|
xlim([0, 40]); ylim([-3, 3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/low_noise_time_domain_3uF.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:low_noise_time_domain_3uF
|
|
#+caption: Low Frequency Noise (0.1Hz - 20Hz)
|
|
#+RESULTS:
|
|
[[file:figs/low_noise_time_domain_3uF.png]]
|
|
|
|
The obtained RMS and peak to peak values of the measured noises are shown in Table [[tab:rms_pkp_noise]].
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Compute the RMS and Peak to Peak noise
|
|
Vn_rms = zeros(7,1); % RMS value [uV rms]
|
|
Vn_pkp = zeros(7,1); % Peak to Peak Value [mV]
|
|
for i = 1:7
|
|
Vn_rms(i) = 1e6*rms(pd200{i}.Vn);
|
|
Vn_pkp(i) = 1e3*(max(pd200{i}.Vn)-min(pd200{i}.Vn));
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
data2orgtable([[714; Vn_rms], [4.3; Vn_pkp]], {'Specification [10uF]', 'PD200_1', 'PD200_2', 'PD200_3', 'PD200_4', 'PD200_5', 'PD200_6', 'PD200_7'}, {'*RMS [uV]*', '*Peak to Peak [mV]*'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:rms_pkp_noise
|
|
#+caption: RMS and Peak to Peak measured noise
|
|
#+attr_latex: :environment tabularx :width \linewidth :align lXX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
#+RESULTS:
|
|
| | *RMS [uV]* | *Peak to Peak [mV]* |
|
|
|----------------------+------------+---------------------|
|
|
| Specification [10uF] | 714.0 | 4.3 |
|
|
| PD200_1 | 524.9 | 4.5 |
|
|
| PD200_2 | 807.7 | 6.7 |
|
|
| PD200_3 | 630.3 | 5.4 |
|
|
| PD200_4 | 619.7 | 5.5 |
|
|
| PD200_5 | 630.8 | 5.6 |
|
|
| PD200_6 | 517.3 | 4.9 |
|
|
| PD200_7 | 393.8 | 3.7 |
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200{1}.t(end) - pd200{1}.t(1))/(length(pd200{1}.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
The PSD of the measured noise is computed and the ASD is shown in Figure [[fig:asd_noise_3uF]].
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
[pxx, f] = pwelch(pd200{1}.Vn, win, [], [], Fs);
|
|
|
|
pxx = zeros(length(pxx), 7);
|
|
|
|
for i = 1:7
|
|
pxx(:, i) = pwelch(pd200{i}.Vn, win, [], [], Fs);
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(f, sqrt(pxx(:, i)), 'DisplayName', sprintf('PD200-%i', i));
|
|
end
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_3uF.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_3uF
|
|
#+caption: Amplitude Spectral Density of the measured noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_3uF.png]]
|
|
|
|
*** DONE Noise with DAC at the input of the PD200
|
|
CLOSED: [2021-01-22 ven. 23:39]
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
pd200dac = {};
|
|
for i = 1:7
|
|
pd200dac(i) = {load(['mat/noise_PD200_' num2str(i) '_3uF_DAC.mat'], 't', 'Vn', 'notes')};
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Take into account the pre-amplifier gain
|
|
for i = 1:7
|
|
pd200dac{i}.Vn = pd200dac{i}.Vn/pd200dac{i}.notes.pre_amp.gain;
|
|
pd200dac{i}.Vn = pd200dac{i}.Vn - mean(pd200dac{i}.Vn);
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200dac{i}.t, 1e3*pd200dac{i}.Vn)
|
|
end
|
|
hold off;
|
|
xlabel('Time [s]');
|
|
ylabel('Voltage [mV]');
|
|
xlim([0, 0.1]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/noise_shunt_time_3uF_dac.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:noise_shunt_time_3uF_dac
|
|
#+caption: Time domain measurement of the amplifier output noise
|
|
#+RESULTS:
|
|
[[file:figs/noise_shunt_time_3uF_dac.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
% Sampling time / frequency
|
|
Ts = (pd200dac{1}.t(end) - pd200dac{1}.t(1))/(length(pd200dac{1}.t) - 1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
The PSD of the measured noise is computed and the ASD is shown in Figure [[fig:asd_noise_3uF_dac]].
|
|
#+begin_src matlab
|
|
win = hanning(ceil(0.5/Ts));
|
|
|
|
for i = 1:7
|
|
[pxx, f] = pwelch(pd200dac{i}.Vn, win, [], [], Fs);
|
|
pd200dac{i}.f = f;
|
|
pd200dac{i}.pxx = pxx;
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
for i = 1:7
|
|
plot(pd200dac{i}.f, sqrt(pd200dac{i}.pxx), 'DisplayName', sprintf('PD200DAC-%i', i));
|
|
end
|
|
plot(preamp.f, sqrt(preamp.pxx), 'k-', 'DisplayName', 'Pre Amp');
|
|
plot(dac.f, 20*sqrt(dac.pxx), 'k-', 'DisplayName', 'ADC noise');
|
|
plot(dac.f, ones(size(dac.f))*(10/2^16)/sqrt(12*Fs)/pd200dac{1}.notes.pre_amp.gain, 'k--', 'DisplayName', 'ADC quant.');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
% ylim([5e-7, 1e-3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/asd_noise_3uF_dac.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:asd_noise_3uF_dac
|
|
#+caption: Amplitude Spectral Density of the measured noise
|
|
#+RESULTS:
|
|
[[file:figs/asd_noise_3uF_dac.png]]
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
hold on;
|
|
plot(pd200dac{1}.f, sqrt(pd200dac{1}.pxx), 'DisplayName', 'PD200 + DAC');
|
|
plot(pd200w{1}.f, sqrt(pd200w{1}.pxx), 'DisplayName', 'PD200');
|
|
plot(dac.f, 20*sqrt(dac.pxx), 'k-', 'DisplayName', 'DAC');
|
|
plot(preamp.f, sqrt(preamp.pxx), 'k-', 'DisplayName', 'Pre Amp');
|
|
plot(dac.f, ones(size(dac.f))*(10/2^16)/sqrt(12*Fs)/pd200dac{1}.notes.pre_amp.gain, 'k--', 'DisplayName', 'ADC quant.');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
xlabel('Frequency [Hz]'); ylabel('ASD [$V/\sqrt{Hz}$]');
|
|
legend('location', 'southwest');
|
|
xlim([1, Fs/2]);
|
|
% ylim([5e-7, 1e-3]);
|
|
#+end_src
|
|
|
|
#+begin_important
|
|
The output noise of the PD200 amplifier is limited by the noise of the DAC.
|
|
#+end_important
|
|
|
|
* Transfer Function measurement
|
|
** Setup
|
|
In order to measure the transfer function from the input voltage $V_{in}$ to the output voltage $V_{out}$, the test bench shown in Figure [[fig:setup-dynamics-measurement]] is used.
|
|
|
|
#+begin_note
|
|
Here are the documentation of the equipment used for this test bench:
|
|
- Voltage Amplifier [[file:doc/PD200-V7-R1.pdf][PD200]]
|
|
- Load Capacitor [[file:doc/0900766b815ea422.pdf][EPCOS 10uF Multilayer Ceramic Capacitor]]
|
|
- Speedgoat DAC/ADC [[file:doc/IO131-OEM-Datasheet.pdf][IO313]]
|
|
#+end_note
|
|
|
|
For this measurement, the sampling frequency of the Speedgoat ADC should be as high as possible.
|
|
|
|
#+name: fig:setup-dynamics-measurement
|
|
#+caption: Schematic of the test bench to estimate the dynamics from voltage input $V_{in}$ to voltage output $V_{out}$
|
|
[[file:figs/setup-dynamics-measurement.png]]
|
|
|
|
** Matlab Init :noexport:ignore:
|
|
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
|
|
<<matlab-dir>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none :results silent :noweb yes
|
|
<<matlab-init>>
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no
|
|
addpath('./matlab/mat/');
|
|
addpath('./matlab/');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :eval no
|
|
addpath('./mat/');
|
|
#+end_src
|
|
|
|
** Maximum Frequency/Voltage to not overload the amplifier
|
|
|
|
The maximum current is 1A [rms] which corresponds to 0.7A in amplitude of the sin wave.
|
|
|
|
The impedance of the capacitance is:
|
|
\[ Z_C(\omega) = \frac{1}{jC\omega} \]
|
|
|
|
Therefore the relation between the output current amplitude and the output voltage amplitude for sinusoidal waves of frequency $\omega$:
|
|
\[ V_{out} = \frac{1}{C\omega} I_{out} \]
|
|
|
|
Moreover, there is a gain of 20 between the input voltage and the output voltage:
|
|
\[ 20 V_{in} = \frac{1}{C\omega} I_{out} \]
|
|
|
|
For a specified voltage input amplitude $V_{in}$, the maximum frequency at which the output current reaches its maximum value is:
|
|
\[ \omega_{\text{max}} = \frac{1}{20 C V_{in}} I_{out,\text{max}} \]
|
|
|
|
$\omega_max$ as a function of $V_{in}$ is shown in Figure [[fig:max_frequency_voltage]].
|
|
|
|
#+begin_src matlab :exports none
|
|
Iout_max = 0.57; % Maximum output current [A]
|
|
C = 2.7e-6; % Load Capacitance [F]
|
|
|
|
V_in = linspace(0, 5, 100); % Input Voltage [V]
|
|
|
|
w_max = 1./(20*C*V_in) * Iout_max; % [rad/s]
|
|
|
|
figure;
|
|
plot(V_in, w_max/2/pi);
|
|
xlabel('Input Voltage Amplitude [V]');
|
|
ylabel('Maximum Frequency [Hz]');
|
|
set(gca, 'yscale', 'log');
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/max_frequency_voltage.pdf', 'width', 'wide', 'height', 'normal');
|
|
#+end_src
|
|
|
|
#+name: fig:max_frequency_voltage
|
|
#+caption: Maximum frequency as a function of the excitation voltage amplitude
|
|
#+RESULTS:
|
|
[[file:figs/max_frequency_voltage.png]]
|
|
|
|
** Obtained Transfer Functions
|
|
Several identifications using sweep sin were performed with input voltage amplitude ranging from 0.1V to 4V.
|
|
|
|
#+begin_src matlab :exports none
|
|
%% Load all the measurements
|
|
Vin_ampl = {'0_1', '0_5', '1', '2', '4'};
|
|
|
|
pd200 = {};
|
|
for i = 1:length(Vin_ampl)
|
|
pd200(i) = {load(['tf_pd200_7_' Vin_ampl{i} 'V.mat'], 't', 'Vin', 'Vout', 'notes')};
|
|
end
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Compute sampling Frequency
|
|
Ts = (pd200{1}.t(end) - pd200{1}.t(1))/(length(pd200{1}.t)-1);
|
|
Fs = 1/Ts;
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
% Hannning Windows
|
|
win = hanning(ceil(0.5*Fs));
|
|
|
|
% Compute all the transfer functions
|
|
for i = 1:length(pd200)
|
|
[tf_est, f] = tfestimate(pd200{i}.Vin, 20*pd200{i}.Vout, win, [], [], 1/Ts);
|
|
pd200{i}.tf = tf_est(f < 0.99*pd200{i}.notes.pd200.f_max);
|
|
pd200{i}.f = f(f < 0.99*pd200{i}.notes.pd200.f_max);
|
|
end
|
|
#+end_src
|
|
|
|
The obtained frequency response functions are shown in Figure [[fig:pd200_tf_voltage]].
|
|
As the input voltage increases, the voltage drop is increasing.
|
|
|
|
#+begin_src matlab :exports none
|
|
figure;
|
|
tiledlayout(2, 1, 'TileSpacing', 'None', 'Padding', 'None');
|
|
|
|
ax1 = nexttile;
|
|
hold on;
|
|
for i = 1:length(pd200)
|
|
plot(pd200{i}.f, abs(pd200{i}.tf), 'DisplayName', sprintf('$V_{in} = %.1f [V]$', pd200{i}.notes.pd200.Vin))
|
|
end
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude $V_{out}/V_{in}$ [V/V]'); set(gca, 'XTickLabel',[]);
|
|
hold off;
|
|
ylim([19, 21]);
|
|
legend('location', 'northeast');
|
|
|
|
ax2 = nexttile;
|
|
hold on;
|
|
for i = 1:length(pd200)
|
|
plot(pd200{i}.f, 180/pi*angle(pd200{i}.tf))
|
|
end
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
|
|
yticks(-360:5:360);
|
|
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
|
|
hold off;
|
|
ylim([-15, 5]);
|
|
|
|
linkaxes([ax1,ax2],'x');
|
|
xlim([10, 5e3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/pd200_tf_voltage.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:pd200_tf_voltage
|
|
#+caption: Transfer function for the PD200 amplitude between $V_{in}$ and $V_{out}$ for multiple voltage amplitudes
|
|
#+RESULTS:
|
|
[[file:figs/pd200_tf_voltage.png]]
|
|
|
|
The small signal transfer function of the amplifier can be approximated by a first order low pass filter.
|
|
|
|
#+begin_src matlab
|
|
Gp = 19.95/(1 + s/2/pi/35e3);
|
|
#+end_src
|
|
|
|
The comparison from the model and measurements are shown in Figure [[fig:tf_pd200_model]].
|
|
|
|
#+begin_src matlab :exports none
|
|
freqs = logspace(1, 4, 1000);
|
|
figure;
|
|
tiledlayout(2, 1, 'TileSpacing', 'None', 'Padding', 'None');
|
|
|
|
ax1 = nexttile;
|
|
hold on;
|
|
for i = 1:length(pd200)
|
|
plot(pd200{i}.f, abs(pd200{i}.tf))
|
|
end
|
|
plot(freqs, abs(squeeze(freqresp(Gp, freqs, 'Hz'))), 'k--');
|
|
hold off;
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude $V_{out}/V_{in}$ [V/V]'); set(gca, 'XTickLabel',[]);
|
|
hold off;
|
|
ylim([19, 21]);
|
|
|
|
ax2 = nexttile;
|
|
hold on;
|
|
for i = 1:length(pd200)
|
|
plot(pd200{i}.f, 180/pi*angle(pd200{i}.tf), 'DisplayName', sprintf('$V_{in} = %.1f [V]$', pd200{i}.notes.pd200.Vin))
|
|
end
|
|
plot(freqs, 180/pi*angle(squeeze(freqresp(Gp, freqs, 'Hz'))), 'k--', 'DisplayName', '$G_p(j\omega)$');
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
|
|
yticks(-5:1:5);
|
|
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
|
|
hold off;
|
|
ylim([-3, 1]);
|
|
legend('location', 'southwest');
|
|
|
|
linkaxes([ax1,ax2],'x');
|
|
xlim([10, 1e3]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :tangle no :exports results :results file replace
|
|
exportFig('figs/tf_pd200_model.pdf', 'width', 'wide', 'height', 'tall');
|
|
#+end_src
|
|
|
|
#+name: fig:tf_pd200_model
|
|
#+caption: Comparison of the model transfer function and the measured frequency response function
|
|
#+RESULTS:
|
|
[[file:figs/tf_pd200_model.png]]
|
|
|
|
* Conclusion
|
|
|
|
#+name: tab:table_name
|
|
#+caption: Measured characteristics, Manual characterstics and specified ones
|
|
#+attr_latex: :environment tabularx :width \linewidth :align lXXX
|
|
#+attr_latex: :center t :booktabs t :float t
|
|
| <l> | <c> | <c> | <c> |
|
|
| *Characteristics* | *Measurement* | *Manual* | *Specification* |
|
|
|-------------------------------------+---------------+--------------+-----------------|
|
|
| Input Voltage Range | - | +/- 10 [V] | +/- 10 [V] |
|
|
| Output Voltage Range | - | -50/150 [V] | -20/150 [V] |
|
|
| Gain | | 20 [V/V] | - |
|
|
| Maximum RMS current | | 0.9 [A] | > 50 [mA] |
|
|
| Maximum Pulse current | | 10 [A] | - |
|
|
| Slew Rate | | 150 [V/us] | - |
|
|
| Noise (10uF load) | | 0.7 [mV RMS] | < 2 [mV rms] |
|
|
| Small Signal Bandwidth (10uF load) | | 7.4 [kHz] | > 5 [kHz] |
|
|
| Large Signal Bandwidth (150V, 10uF) | | 300 [Hz] | - |
|