tdehaeze/test-bench-pd200
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
730fea5116
test-bench-pd200/test-bench-pd200.org

1610 lines
54 KiB
Org Mode
Raw Normal View History

Initial Commit
2020-12-15 23:03:14 +01:00
#+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}
Rename files
2021-02-02 18:50:47 +01:00
#+EXPORT_FILE_NAME: test-bench-pd200.tex
Initial Commit
2020-12-15 23:03:14 +01:00
#+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:
Rename files
2021-02-02 18:50:47 +01:00
#+begin_export html
<hr>
<p>This report is also available as a <a href="./test-bench-pd200.pdf">pdf</a>.</p>
<hr>
#+end_export
Update PDF output
2021-01-13 12:14:03 +01:00
* Introduction
Initial Commit
2020-12-15 23:03:14 +01:00
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.
Add some comments
2020-12-16 16:21:54 +01:00
The documentation of the PD200 is accessible [[file:doc/PD200-V7-R1.pdf][here]].
Add picture of amplifier
2021-01-04 11:09:04 +01:00
#+name: fig:amplifier_PD200
#+caption: Picture of the PD200 Voltage Amplifier
Update PDF output
2021-01-13 12:14:03 +01:00
#+attr_latex: :width 0.8\linewidth
Add picture of amplifier
2021-01-04 11:09:04 +01:00
[[file:figs/amplifier_PD200.png]]
Add some comments
2020-12-16 16:21:54 +01:00
* 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
Update PDF output
2021-01-13 12:14:03 +01:00
#+attr_latex: :width 0.8\linewidth
Add some comments
2020-12-16 16:21:54 +01:00
[[file:./figs/pd200_expected_small_signal_bandwidth.png]]
#+name: fig:pd200_expected_noise
#+caption: Expected Low frequency noise from 0.03Hz to 20Hz
Update PDF output
2021-01-13 12:14:03 +01:00
#+attr_latex: :width 0.8\linewidth
Add some comments
2020-12-16 16:21:54 +01:00
[[file:figs/pd200_expected_noise.png]]
Initial Commit
2020-12-15 23:03:14 +01:00
* Voltage Amplifier Model
Change notation
2021-01-23 15:40:31 +01:00
The Amplifier is characterized by its dynamics $G_p(s)$ from voltage inputs $V_{in}$ to voltage output $V_{out}$.
Initial Commit
2020-12-15 23:03:14 +01:00
Ideally, the gain from $V_{in}$ to $V_{out}$ is constant over a wide frequency band with very small phase drop.
Add some comments
2020-12-16 16:21:54 +01:00
It is also characterized by its output noise $n$.
Initial Commit
2020-12-15 23:03:14 +01:00
This noise is described by its Power Spectral Density.
Change notation
2021-01-23 15:40:31 +01:00
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.
Update PDF output
2021-01-13 12:14:03 +01:00
Change notation
2021-01-23 15:40:31 +01:00
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.
Update PDF output
2021-01-13 12:14:03 +01:00
Initial Commit
2020-12-15 23:03:14 +01:00
#+begin_src latex :file pd200-model-schematic.pdf
\begin{tikzpicture}
Change notation
2021-01-23 15:40:31 +01:00
\node[block] (G) at (0,0){$G_p(s)$};
Add some comments
2020-12-16 16:21:54 +01:00
\node[addb, right=0.8 of G] (add){};
Initial Commit
2020-12-15 23:03:14 +01:00
Add some comments
2020-12-16 16:21:54 +01:00
\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}$};
Initial Commit
2020-12-15 23:03:14 +01:00
\draw[<-] (add.north) -- ++(0, 0.6) node[below right](n){$n$};
\begin{scope}[on background layer]
Add some comments
2020-12-16 16:21:54 +01:00
\node[fit={(G.south west) (n.north-|add.east)}, inner sep=8pt, draw, dashed, fill=black!20!white] (P) {};
Initial Commit
2020-12-15 23:03:14 +01:00
\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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
** 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
Add some comments
2020-12-16 16:21:54 +01:00
** Setup
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
<<sec:noise_setup>>
Initial Commit
2020-12-15 23:03:14 +01:00
#+begin_note
Here are the documentation of the equipment used for this test bench:
- Voltage Amplifier [[file:doc/PD200-V7-R1.pdf][PD200]]
Update PDF output
2021-01-13 12:14:03 +01:00
- Load Capacitor [[file:doc/0900766b815ea422.pdf][EPCOS 10uF Multilayer Ceramic Capacitor]]
Initial Commit
2020-12-15 23:03:14 +01:00
- Low Noise Voltage Amplifier [[file:doc/egg-5113-preamplifier.pdf][EG&G 5113]]
- Speedgoat ADC [[file:doc/IO131-OEM-Datasheet.pdf][IO313]]
#+end_note
Add some comments
2020-12-16 16:21:54 +01:00
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.
Update PDF output
2021-01-13 12:14:03 +01:00
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.
Add some comments
2020-12-16 16:21:54 +01:00
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.
Initial Commit
2020-12-15 23:03:14 +01:00
#+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]]
Update PDF output
2021-01-13 12:14:03 +01:00
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.
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
** 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:
Add analysis of measured noise
2021-01-19 23:13:03 +01:00
*** 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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
*** DONE Pre-Amp Noise
CLOSED: [2021-01-22 ven. 22:51]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
*** DONE DAC (16bits) Noise
CLOSED: [2021-01-22 ven. 23:13]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
*** DONE Noise when shunting the input (50 Ohms) - After Warmup
CLOSED: [2021-01-22 ven. 23:09]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
The time domain measurements of the amplifier noise are shown in Figure [[fig:noise_shunt_time_3uF_warmup]].
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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:
Add analysis of measured noise
2021-01-19 23:13:03 +01:00
#+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]]
Add some comments
2020-12-16 16:21:54 +01:00
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
*** DONE Noise with DAC at the input of the PD200
CLOSED: [2021-01-22 ven. 23:39]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
The PSD of the measured noise is computed and the ASD is shown in Figure [[fig:asd_noise_3uF_dac]].
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+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
Initial Commit
2020-12-15 23:03:14 +01:00
* Transfer Function measurement
Add some comments
2020-12-16 16:21:54 +01:00
** Setup
Initial Commit
2020-12-15 23:03:14 +01:00
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]]
Update PDF output
2021-01-13 12:14:03 +01:00
- Load Capacitor [[file:doc/0900766b815ea422.pdf][EPCOS 10uF Multilayer Ceramic Capacitor]]
Initial Commit
2020-12-15 23:03:14 +01:00
- Speedgoat DAC/ADC [[file:doc/IO131-OEM-Datasheet.pdf][IO313]]
#+end_note
Add some comments
2020-12-16 16:21:54 +01:00
For this measurement, the sampling frequency of the Speedgoat ADC should be as high as possible.
Initial Commit
2020-12-15 23:03:14 +01:00
#+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]]
Add some comments
2020-12-16 16:21:54 +01:00
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
** 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
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
** 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} \]
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
Therefore the relation between the output current amplitude and the output voltage amplitude for sinusoidal waves of frequency $\omega$:
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
\[ V_{out} = \frac{1}{C\omega} I_{out} \]
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
Moreover, there is a gain of 20 between the input voltage and the output voltage:
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
\[ 20 V_{in} = \frac{1}{C\omega} I_{out} \]
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
For a specified voltage input amplitude $V_{in}$, the maximum frequency at which the output current reaches its maximum value is:
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
\[ \omega_{\text{max}} = \frac{1}{20 C V_{in}} I_{out,\text{max}} \]
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
$\omega_max$ as a function of $V_{in}$ is shown in Figure [[fig:max_frequency_voltage]].
#+begin_src matlab :exports none
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
Iout_max = 0.57; % Maximum output current [A]
C = 2.7e-6; % Load Capacitance [F]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
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
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/max_frequency_voltage.pdf', 'width', 'wide', 'height', 'normal');
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
#+end_src
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+name: fig:max_frequency_voltage
#+caption: Maximum frequency as a function of the excitation voltage amplitude
#+RESULTS:
[[file:figs/max_frequency_voltage.png]]
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
** Obtained Transfer Functions
Several identifications using sweep sin were performed with input voltage amplitude ranging from 0.1V to 4V.
Analyze: dac noise, pre-amp noise, amp bandwidth
2021-01-21 19:02:02 +01:00
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+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
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+begin_src matlab :exports none
% Compute sampling Frequency
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
Ts = (pd200{1}.t(end) - pd200{1}.t(1))/(length(pd200{1}.t)-1);
Fs = 1/Ts;
#+end_src
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+begin_src matlab :exports none
% Hannning Windows
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
win = hanning(ceil(0.5*Fs));
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
% Compute all the transfer functions
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
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
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
The obtained frequency response functions are shown in Figure [[fig:pd200_tf_voltage]].
As the input voltage increases, the voltage drop is increasing.
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+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
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+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.
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+begin_src matlab
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
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;
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
for i = 1:length(pd200)
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
plot(pd200{i}.f, 180/pi*angle(pd200{i}.tf), 'DisplayName', sprintf('$V_{in} = %.1f [V]$', pd200{i}.notes.pd200.Vin))
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
end
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
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]);
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+end_src
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+begin_src matlab :tangle no :exports results :results file replace
exportFig('figs/tf_pd200_model.pdf', 'width', 'wide', 'height', 'tall');
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+end_src
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
#+name: fig:tf_pd200_model
#+caption: Comparison of the model transfer function and the measured frequency response function
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
#+RESULTS:
Analyze transfer function measurements
2021-01-23 15:38:31 +01:00
[[file:figs/tf_pd200_model.png]]
Analyze all noise meaurements
2021-01-22 23:44:36 +01:00
Add some comments
2020-12-16 16:21:54 +01:00
* 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] | - |
Reference in New Issue Copy Permalink