DIY 0.1 to 10Hz Noise Amplifier

[Alex Nikitin]

What sample rates are you using with each DMM?

1 NPLC, roughly 20 Hz

Cheers

Alex

[Kleinstein]

The 1 PLC (20 ms in Europe) integration already effects the bandwidth. With the usual AZ mode the meter only reads the input a little less than half the time. This adds some sensitivity to frequencies around 25 Hz. Together with a 1st order filter this gives a frequency response that looks a bit complicated. Not a simple 10 Hz upper limit, though a somewhat comparable equivalent noise bandwidth.

The effective frequencies anyway depend on the filter details. IFAIK there is not strict standard of the filter response and the comparison of noise data from different filter (including the AC coupling) setups can thus be a bit tricky.

[Alex Nikitin]

Yes, there is (obviously) some aliasing, I did check the response with a sweep generator, though for a noise signal the effects of narrow band variations should be reasonably benign. On the first screen shot below the sweep is linear, 60s, from 2Hz to 20Hz, with the filter, at 1NPLC, on the second it is 2Hz to 62Hz, and on the third is 2Hz to 62Hz without the filter.

Cheers

Alex

[trtr6842]

That's definitely still useful, if you have such a low-noise DMM already!!
Very cool to see multiple approaches at this. 

[andrewtaylor]

Hi Richard,

great project, congratulations!
Is it possible you add the PCB layout files (I think you might have orderd your pcb from JLCPCB) on your project homepage later?

would appreciate this.

[trtr6842]

Hi Richard,

great project, congratulations!
Is it possible you add the PCB layout files (I think you might have orderd your pcb from JLCPCB) on your project homepage later?

would appreciate this.

Thanks!  You can order bare PCB's, assembled PCB's, or enclosed LNA's from me if you'd like one!  will not be sharing the gerbers or placement files.  It turns out this design is a good alternative to the $500 Euler precision LNA, and I don't want my entire design to be copied with zero effort by some manufacturer, I hope you understand.  Instead I'm selling my design for much less to recoup some of the development costs, but still making it accessible to hobbyists and engineers.  Please contact me if you're interested! 

I have a new batch with some extra features arriving in about 1 week, I'll be adding updates on this thread soon!

[MegaVolt]

There are also battery measurements performed by Walls at NIST, time-frequency group.
I think the filename is 1111.pdf, but it is a moving target on their server.

https://tf.nist.gov/general/pdf/1133.pdf

[trtr6842]

I've received the latest batch of LNA boards, this revision has a few updates, and I've shipped out orders for 5 of them so far.

Notable new features:

• Metal EMI shield over the 1st gain stage circuit, clipped on to allow rework/modification
• Threaded BNC connectors for easy panel mounting and better shielding
• Negative input warning LED
• Protection against swapped inputs/outputs (accomplished through rework)
• Wire pads for easy gain switch installation

New board with EMI shield


EMI shield clip close-up


New Board with EMI shield removed


Bottom side rework and labelling


Fully enclosed unit.  This one has a custom 0.1-100Hz bandwidth for someone interested in using it to measure small 60Hz signals.
The red LED on the left lights up if the LNA is powered on and the DC input voltage goes below -10mV. 
The input protection limits the current to ±2mA, which buys me some time when I inevitably hook up my input backwards!


The new Hammond 1590Y enclosure fits everything nicely.  The foam keeps the battery from rattling around, a good re-use of the packaging these PCB's came in.
The threaded BNC connectors make mounting the board much simpler. 


In past revisions I definitely stressed input protection, since having such a large input capacitor paired with low input impedance is a recipie for trouble.  However, I neglected to protect the signal outputs from any accidental connection to DC sources of up to +30V.  With past revisions that would surely damage or completely destroy the LNA.  On these boards I reworked some series resistors and TVS diodes on the bottom side of the board.  These limit and clamp any injected current, and they do not significantly change any output characteristics when used with 1MΩ scope inputs.

x250 output protection: Series 4.99kΩ 1206 resistor and a TVS diode:


Main output protection: 2kΩ series resistor.  The DC blocking cap also helps with protection.


Since I had a few orders for these boards, I wrote an automated test script so that every LNA would be fully and consistently tested before I shipped them out.  It checks gain at input current, gain at 1Hz, shorted-input noise floor, and it does an FFT based frequency response measurement. Below is a frequency response measurement example.  I know the lines are fuzzy, and that immediately makes all of us noise-freaks think that there is something fishy going on, but that's just part of this FFT method I'm using!!!


Here is how the FFT method I use works:

I use my RTB2004 to record the un-attenuated signal generator output and the LNA outputs.  The signal generator output starts at 0V, then steps to +4V halfway through the capture.  I take each channels time-domain data and use python to calculate the FFT of each.  Then I divide the magnitude of each output by the magnitude of the input, and I get a pretty good frequency response plot!  However, since the input function I'm using is just a step function, it does not have much energy in the higher frequencies, and I quickly run into the noise floor of my scope.  I actually do two of these captures, one with a 180 second capture time, and one with a 6 second capture time.  This covered the 0.1Hz to 10Hz range well, but you definitely can see lots of fuzz up near 500Hz. 

I use this method because it is much faster than injecting one sine wave at a time and measuring the gain.  That takes hours at these low frequencies, but only a few minutes with this method.  For me that's well worth a little fuzz on the resulting plots.  I am working on some more advanced excitation signals to try and get cleaner results.  I've tried a sin(x)/x input, and that cleaned up the higher frequencies, but at the expense of the low frequencies.  One promising input signal is a sum of approximately log-spaced input frequencies.  If each input frequency is a multiple of some base frequency, then the pattern repeats cleanly and can be loaded as an arbitrary waveform in my signal generator.  Focusing the spectral energy on a log spaced of points could result in a group of clean data points that would make a good bode plot, but it leaves a lot of points with no energy, so those would have to be removed from the plot to keep it clean.  Anyways, I will share how that goes if I get around to it!

[gf]

One promising input signal is a sum of approximately log-spaced input frequencies.  If each input frequency is a multiple of some base frequency, then the pattern repeats cleanly and can be loaded as an arbitrary waveform in my signal generator.

Since the peak amplitude is limited, the key to good SNR is a signal with a low crest factor.
The script I found here some time ago tries to find a phase for each tone of a multi-tone signal, so that the crest factor is minimzed.
It seems to work nicely as long as the spectrum is populated sparsely enough.
Since it uses FFT internally, the frequencies of all tones are integer multiples of a base frequency, which meets your desire, too.

[trtr6842]

Interesting script!

Here is what I've got: The script is trying to add 100 sines together, approximately log-spaced from 0.02Hz to 10Hz.  Since a lot of the lower ones overlap when rounded to the nearest multiple of the base frequency, the script ends up giving 70 tones.  To get a small enough resolution bandwidth on the FFT, the pattern is repeated 4 times before the FFT is computed.  Right now each sine has the same amplitude, but I do want to start shaping the amplitude profile to optimize SNR for the expected LNA frequency response.

Basic sum-of-sines, no phase shift:  Vpp = 28.6x the amplitude of a single sine


Flipped phase for every-other frequency:  Vpp = 23.7x the base amplitude


Linear phase shift, each frequency's starting phase is evenly spread out over 360°, Vpp = 16.9x the base amplitude, which feels pretty good considering there are 70 tones added together.  I'm curious what kind of Vpp to tone amplitude ratios the random iterative script can accomplish.


Here is the script I used to generate the time domain signals:

Code: [Select]

import numpy as np
class WaveformMath:       
    def sum_logspace_sines(n_points, f_max_ratio, n_f, n_cycles=1):
        # n_points is how many time-domain samples you want.  The resulting signal will have fewer tones, since tones that are too close together will be skipped
        # f_max ratio is the ratio of the max frequency to the min frequency (the lowest frequency is normalized to 1.0, so this is how you define the max frequency)
        # n_f is the number of frequencies you'd like
        # n_cycles is how may times you'd like the pattern to repeat within the number of points given

        x = np.linspace(0, n_cycles, n_points)  # 0.0 to 1.0 normalized sample time
        y = np.zeros(n_points)
        f_log = np.logspace(0, np.log10(f_max_ratio), n_f)  # ideal set of log-spaced tones
       
        f_approx = []
        f_max = 0
       
        for f in f_log:
            fa = (f*n_cycles//1)/n_cycles  # round down to nearest frequency
            if fa > f_max:
                f_approx.append(fa)
                f_max = fa
               
        for i in range(len(f_approx)):
            # y += np.sin(2*np.pi*f_approx[i]*x)  # straight sum
            y += np.sin(2*np.pi*f_approx[i]*(x+n_cycles*i/len(f_approx)))  # linear shifted phase based on index
           
            # if i%2 == 0:  # Flipped sign every other frequency
            #     y += np.sin(2*np.pi*f_approx[i]*x)
            # else:
            #     y += np.sin(2*np.pi*f_approx[i]*x*-1)

        # print('Number of tones: %d' % len(f_approx))
        # print('peak: %.3f' % (max(y)/2-min(y)/2))
        y = 2 * y / (max(y)-min(y))   # normalize Vpp to 1.0
        # print(y[0])  # print initial DC offset (DC average is stil 0)
           
        return x, y