The Manual Controller combined with the HF2LI allows for adding offset voltages to the dF signal (frequency deviation) of the Phase Locked Loop. In this way, it allows for manually setting the frequency setpoint using the fine feeling of your fingertips. It can also be used to control other parameters of an AFM setup.

The list of controllable parameters includes:

• Frequency deviation (dF)
• Drive amplitude
• Frequency
• Arbitrary voltage on any Aux Output

Nanosurf Manual Controller box.

Requirements

• Zurich Instruments HF2PLL
• Zurich Instruments HF2LI-PID Option
• Nanosurf Manual Controller

Setup Overview

The AFM system which was set up by the Molecular Self-Assembly Research Group of Professor Kühnle, University of Mainz, allows for manually controlling the frequency setpoint of the phase locked-loop in order to optimize the image quality of an NC-AFM scan.
To connect the Manual Controller to the Zurich Instruments lock-in amplifier, an adapter to the Lemo connector has to be built according to the information you find in “Building Instruction” below.

Block diagram of the AFM system incorporating an HF2LI lock-in amplifier from Zurich Instruments and a Manual Controller box from Nanosurf.

Building Instructions

The ZCtrl port of the HF2LI has to provide the power supply (±12V) for the Manual Controller. Furthermore, the Aux Input of the HF2LI has to read the returned analog offset voltage from the Manual Controller. Therefore, a Y-cable is needed that connects the Lemo connector of the Manual Controller to the ZCtrl and the Aux Input of the HF2LI. Here you find the necessary technical information for the connectors.

Parts List

• Lemo Connector PCA.0S.304.CLLC37 Datasheet
• BNC Connector (half BNC cable)
• RJ45 connector with cable (sacrifice a network cable). Be referred to our user manual for a pin description of the ZCtrl connector.
• Short piece of four-core cable

Electric Connectivity

Adapter cable

Lemo connector	Lemo connector disassembled

HF2LI Configuration

One of the four PID controllers of the HF2LI is used as a generic interconnectivity module providing only proportional gain. The output is written to the Aux Output offset (and thus added to the dF value, which is output at the same Aux Output). The PID is configured as follows:

Input = Aux Input Setpoint = 0 P = gain I = 0 D = 0 Output = Aux Output (Offset) Center = 0 Range = maximum output range

The HF2LI configuration file can be downloaded there:
hf2conf_pll_AmpPID_OffsetBox.zip

By default the Aux Input performs an averaging of 256 samples in a moving average manner. This is a sensible setting for this purpose as it has to reduce noise while still providing sufficient bandwidth.

Connectivity to Scan Controller

The voltage encoding of the dF – dFOffset fed into the scan controller as the feedback signal is set under “Aux outputs”. Depending on the scan controllers’ feedback, the sign of the encoding has to be chosen accordingly.

Application Example

These images, which were recorded in non-contact mode using an HF2LI, were kindly provided by Philipp Rahe from the Molecular Self-Assembly Research Group Kühnle, University of Mainz, Germany.

P. Rahe, J. Schütte, A. Kühnle
NC-AFM contrast formation on the calcite (10-14) surface
J. Phys.: Condens. Matter 24 (2012) 084006

In this post, I will demonstrate you the interplay between resolution, scanning speed and demodulation bandwidth. In case you ever used a scanning probe microscope (SPM) or a laser scanning microscope, you know that the image you acquired at the end of the day is your sample convoluted by the response of your scanning system. In standard AFM imaging, this is the shape of your scanning tip, in laser scanning microscopy, this is the shape of your focus, also known as the point spread function. However, during the actual scanning process, you are dealing with a continuous time measurement signal and need to ensure sensitive signal detection. I will therefore describe the scanning process in the time and frequency domain. With help of some calculations, I will show you how filters acting on the scanning signal influence the imaging resolution and how you can use these results in practice.

Scanning: Filtering in time-domain

In the spatial domain, the resolution along one line can often be described by a Gaussian function

with the relation

to the full width half maximum (FWHM), which approximates the smallest resolvable feature. In the scanning process, R(x) moves across the sample X(x) at a constant velocity vs. Consequently, a continuous-time measurement signal y(t) is generated. The scan controller samples this signal at distinct points, which correspond to equidistant points in the spatial domain: image pixels. For now, I want to focus on the properties of the continuous-time measurement signal y(t). With the substitution (x = vs t) into R(x), it is straightforward to see that R(t) is again a Gaussian with

In analogy to spatial filtering of the sample by R(x), R(t) is the impulse response of a Gaussian filter, which filters X(x = vs t). Assuming that the sample contains more features than those resolvable by R(x), the bandwidth of the measurement signal y(t) is limited by the Gaussian filter R(t). To calculate this bandwidth, I use the unitary Fourier transform for the frequency domain equivalent R(ω), similar as in (1)

which has the 3dB frequency

In consistence with basic intuition, the bandwidth is proportional to the scanning speed and inversely proportional to the smallest resolvable feature. I plotted R(x), R(t) and R(ω) in the Figure below (from left to right). The abscissa for R(x) and R(t) is in units of the corresponding FWHM, whereas for R(ω), units of the 3dB frequency are chosen.

Note that I start in spatial domain, then transform to time substituting (x = vs t) and finally apply the Fourier transform. For completeness, keep in mind that imaging resolution and contrast can also be described by the modulation transfer function, which is the spatial Fourier transform of R(x). In case you are used to think in terms of modulation transfer functions, you can simply transform the frequency domain to the reciprocal space by substituting (ω = vs k), where k is 2π/x: It is therefore only a rescaling of the frequency axis.

Role of the Lock-in Amplifier

In many applications, R(ω) is modulated by a carrier ωc, whose frequency is well above the bandwidth of R(ω). In AFM/SPM, ωc is the probe oscillation in spatial domain; in laser scanning microscopy, ωc is the modulation frequency of the laser-beam in time domain. Accordingly, the measurement signal needs to be demodulated at ωc and filtered prior to pixel mapping by the scan controller. To keep things simple and general, I skip application details on AFM, where the demodulated signal is part of a feedback loop. A schematic on this is given in the figure below. On the left hand side, the moving tip/focus with modulation at ωc is depicted. This analog signal is demodulated by the HF2LI and routed to the scan controller by the auxiliary analog outputs. Because the HF2LI is a digital lock-in, an analog to digital (A/D) conversion on the input and a digital to analog (D/A) conversion on the auxiliary output is performed. This internal sampling is at a much higher rate than the pixel sampling in the scan controller. To avoid resolution degradation due to demodulation, the demodulation filter should thus leave R(ω) as it is. On the contrary, an efficient rejection of out of band noise requires a demodulation filter bandwidth as narrow as possible. To handle this tradeoff, I will show you some simulations for different filter settings and scanning speeds.

Fast Scanning

If you want to scan as fast as possible, the maximum demodulation bandwidth limits the scan speed. In practice, such situations arise in laser scanning microscopy at fast frame rates. The question I highlight is therefore: What is the fastest possible scan speed with the HF2LI?

First of all, the maximum demodulation bandwidth needs to be known. For the demodulator, the maximum bandwidth is 200 kHz for a first order filter with a time constant of 780 ns. I will refer to this demodulation filter as D. In addition, there is a second order 200 kHz analog filter on the auxiliary output. For this filter, I use A as reference.  These two filters together (D·A) have a bandwidth of 147 kHz. To find out how these filters affect the spatial resolution, I filter R(ω) with D and A and examine the resulting signal (R·D·A) in the spatial domain. By sweeping the scanning speed, I then get the effective FWHM, which I term as the effective resolution, in dependence of the scanning speed. The procedure is depicted in the figure below. In case you want the plots with a better resolution, just get the svg .

On the left hand side, the frequency domain signals and filters are illustrated. The D·A filter with 147 kHz bandwidth is depicted in magenta by the dashed line. The scanning signal R(ω) in red has here a bandwidth of 156 kHz and is therefore slightly above the demodulation bandwidth. The resulting R·D·A is shown in blue.

In the middle, you see R(x) and R·D·A(x). For R(x), I used a FWHM of 0.5 μm, which is a typical value for laser scanning setups. Because there is no analytical solution for a filtered Gaussian function, I needed to calculate R·D·A(x) with help of the inverse Fourier transform. Since the filters narrow the signal in frequency, the spatial equivalent is broader and results in a higher FWHM. For the illustrated curves, the effective FWHM is 1.43 times the physical FWHM of R(x). I did not include contrast degradation and phase shift due to the low pass filter. In the subsequent section on slow scanning, I include the delay due to the filter in my calculations.

On the right hand side, I plotted the effective resolution against the scanning speed in units of the physical FWHM. The abscissa is swept from 0 to 5E5. The maximum value on the abscissa therefore corresponds to R(ω) with a bandwidth of 156 kHz, which is shown on the illustrations on the left and in the middle. At the fastest speed, where the demodulation bandwidth is equal to the bandwidth of R(ω), the spatial resolution can be degraded by 30% (1 – 1/1.43).

Slow Scanning

At slower scan speeds, you have a lot of choices for the demodulation filter. You can choose between different filter orders as well as between different 3dB cutoff frequencies. To show you the related effects, I again made some simulations. Here, I used 1st, 2nd and 4th order filters – D1, D2 and D4 respectively – at different filter bandwidths. I expressed the filter bandwidth in units of the 3dB frequency of R(ω). The analog filter A on the auxiliary output is not considered, because it has a much higher bandwidth. Results are shown in the figure below. In case you want the plots with a better resolution, just get the svg .

On the left hand side, the frequency domain signals and filters are illustrated. The demodulation filters D1, D2 and D4 all have their bandwidth equal to the bandwidth of R(ω). Due to the filter steepness, higher order filters attenuate the signal stronger above their 3dB frequency compared t0 lower order filters, which can be readily seen in the figure below. Below their 3dB frequency, lower order filters attenuate the signal stronger compared to higher order filters, which is difficult to see in the illustrated figure.

In the middle, the curves are shown in the spatial domain. The demodulation filter bandwidth is also in this case identical to the bandwidth of R(ω). In the slow scanning case discussed here, I accounted for the phase shift of the demodulation filter. The phase shift in the frequency domain corresponds to a time delay of the filtered measurement signal. By mapping this delay to the spatial domain, the filtered curves are shifted in space. Accordingly, the spatial shift is the distance that the tip/focus travels until the demodulated signal is at the auxiliary output of the lock-in amplifier. The numerical values for the shift are 0.33, 0.52 and 0.79 times the FWHM for a 1st, 2nd and 4th order filter, respectively. In a regular imaging process, this shift/delay can be corrected by the pixel sampling in the scan controller. The situation is different in feedback systems, where an instantaneous feedback signal is essential for stability. In AFM systems, the conditions are even stricter, because you usually want the feedback system to react before crashing your tip against some sharp feature.

On the right hand side, the spatial shift and the effective resolution, both in units of the FWHM, are plotted against the demodulation filter bandwidth in units of the 3dB frequency of R(ω). On this figure, you see that the higher the demodulation filter bandwidth, the lower the spatial shift and effective FWHM, as less high frequency components in R(ω) are attenuated/delayed by the demodulation filter. When looking at these results, keep in mind that a higher demodulation filter bandwidth also degrades the SNR. If you increase the bandwidth by a factor of 4, the noise power doubles. In addition to that, a higher order filters suppress out of band noise better due to their higher steepness.

If the filters and R(ω) have equal 3dB frequencies, you can actually make some approximations to calculate the effective FWHM yourself. You get an analytical solution, if the demodulation filter would also be a Gaussian function. On the left hand side of the figure below, you see that a Gaussian decays much faster than a low pass filter. Approximating the demodulation filter as Gaussian therefore yields an upper limit to the spatial FWHM for the filter orders studied here. The analytical bound is easy to calculate, since the multiplication of two Gaussians with equal bandwidth results in a Gaussian with a √2 times lower bandwidth. The effective spatial FWHM is therefore higher by a factor of √2 ~ 1.414. The numerical values found here are all smaller: 1.24, 1.29 and 1.33 for the 1st, 2nd and 4th order filter, respectively.

For the spatial phase shift, you can also easily calculate an analytical upper bound. Consider a first order filter with its bandwidth equal to the bandwidth of R(ω). At the signals 3dB frequency, the filter introduces a phase shift of 45°, which corresponds to a time delay of one eighth of the 3dB frequency’s oscillation period. Transforming this delay back to the spatial domain results in a shift of 1/8·FWHM/0.312 ~ 0.4. The numerically calculated value for the first order filter is 0.33.

Usage in Practice

In practice, you might not know how your R(x) looks like. In this case, the ziControl software of the HF2LI has a very useful tool: ZoomFFT. This tool shows you the frequency spectrum of the demodulated signal. By scanning your sample and observing ZoomFFT with peak hold averaging and demodulation filter compensation, you can at first determine the 3dB bandwidth of R(ω) and find out at which level your noise floor is. If you are scanning a sample with a multitude of sharp features, you can even determine R(ω) with help of ZoomFFT and then calculate R(x) from this, because the scanning speed is a known quantity. This is a different approach than the widely used resolution determination at one single step.

With the bandwidth of R(ω) at hand, it is up to you to choose a demodulation filter. In case of very weak signals, you need to make a tradeoff in imaging resolution and SNR.

In special cases where you are not capable of spatial oversampling, the demodulation filter can also be used for higher aliasing suppression in the resulting image. The transformation of a low pass filter to an image filter is very easy, because the frequency domain is transformed into the reciprocal domain by substituting (ω = vs k).

References

The installation of the Zurich Instruments Python interface is discussed in Controlling the HF2LI Lock-in with Python.

Simple Plotting Example with Python

Find below a simple plot example that uses the Matplotlib.pyplot module:

import matplotlib.pyplot as plt
from numpy import *

a=arange(0,10,0.1)
plt.figure()
plt.plot(a,sin(2*pi*a/10))

plt.figure()
plt.plot(a,cos(2*pi*a/10))
plt.show()
print 'Done!'


The show() command tells the Matplotlib to render all figure windows and start the GUI mainloop. As the mainloop is blocking, this command should be called only once at the end of the script. The figure will contain the final result of all preceding plot commands. Script commands following show() will be blocked until all figures are closed by the user.
One solution to plot continuous oscilloscope data using the show() command is the creation of a new figure for each oscilloscope shot.
However, it is more convenient to update the same figure for each oscilloscope shot as it is for example done for the oscilloscope tab within ziControl (Zurich Instruments graphics user interface). Therefore, continuous updating of the figure with each pyplot command has to be enabled. Command draw() is suitable to force re-plotting. In that case, the program execution after plotting will also be possible, even without closing the figure.

Python Settings for Dynamic Plotting

There are interactive Python distributions such as iPython that are automatically working in the mode where every pyplot command triggers a figure update. The subsequently presented approach is not limited to a specific distribution and explains a general method to enable the interactive mode.
Matplotlib uses matplotlibrc configuration file to customize all kinds of properties such as default figure size, line width, colors and style, grid properties, text font. To find out the location of matplotlibrc file that is currently loaded use the command matplotlib.matplolib_frame(). To support updating the figure on every pyplot command the backend should be set to TkAgg and the interactive flag should be set to True in the matplotlibrc file. If matplotlib is installed again, the settings will be overwritten.
Alternatively, the settings can also be applied in the python script directly. Before importing pyplot, backend should be set with command matplotlib.use('TkAgg'). After importing pyplot, interactive mode should be turned on with the command matplolib.pyplot.ion().

Dynamic Plotting of HF2 Lock-in Oscilloscope Data

The Python script presented in this section will plot the sum of two sine waves with frequency difference of 1 Hz. The result is a signal with beating amplitude. Before running the script scope_example.py, Signal Output 2 Out should be connected to Signal Output 1 Add and Signal Output 1 Out should be connected to Signal Input 1 +In. The HF2-LI Lock-in should be connected to the computer with a USB 2.0 cable. The ziServer should be running on the computer where the instrument is connected to.
There are several ways how to run scope_example.py script because the code in the script is structured so that can be used as a standalone program and as a module. As a standalone program, the script can be run from the command prompt with python -i scope_example.py. This is possible if you are located in folder that contains file scope_example.py and the environment variable path contains path to the executable Python file in C:Python26.
For the users who are using IDLE (Python GUI), it’s recommended to open file scope_example.py with the right click on file and selecting ‘Edit with IDLE’. In this case the IDLE shell will write a message ==== No Subprocess ====. To run the script, press F5 or select Run module from the Run menu. It’s important to run Python shell with no sub-processes because otherwise the script execution will crash if you for example only try to move the figure window.
The scope_example.py script can be imported in a Python shell as a module with import scope_example. It contains class called Oscilloscope. Class instantiation automatically invokes the __init__() method to obtain initialized instance of the class. Arguments that must be supplied at class instantiation are the reference to the server, the device name string and the input channel number of which data should be analyzed. The class defines methods set_parameters and update. Method set_parameters sets the oscilloscope parameters (see ZI oscilloscope tab in the ziControl) source channel, sampling rate, configuring the trigger, and time between to oscilloscope shots. The method update creates an oscilloscope window and plots new oscilloscope data after each call.

Download the file .

import time, math, random
import zhinst.ziPython, zhinst.utils
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from numpy import *
plt.ion()

class Oscilloscope(object):
   def __init__(self,device,daq,channel):
       self.device=device
       self.daq=daq
       self.channel=channel
       self.updated=0
       
   def set_parameters(self, bwlimit=0,trigedge=1,triglevel=0,
                      trigholdoff=0.01,trigchannel=-2,t=1):
       settings = [
           [['/', self.device, '/scopes/0/channel'], self.channel-1],
           [['/', self.device, '/scopes/0/bwlimit'], bwlimit],
           [['/', self.device, '/scopes/0/trigedge'], trigedge],
           [['/', self.device, '/scopes/0/triglevel'], triglevel],
           [['/', self.device, '/scopes/0/trigholdoff'], trigholdoff],
           [['/', self.device, '/scopes/0/trigchannel'], trigchannel],
           [['/', self.device, '/scopes/0/time'], t]
       ]
       self.daq.set(settings)
       # Wait 1s
       time.sleep(1)
       # Clean queue
       self.daq.flush()
 
   def update(self):
           rng=self.daq.getDouble('/' + self.device + '/sigins/'
                                  + str(self.channel-1) + '/range')
           # Poll data 0.05s with a timeout of 500ms
           dataDict = self.daq.poll(0.05,500)
           # For first oscilloscope shot use plot function and after is
           # used draw function to update figure with new oscilloscope data
           if self.device in dataDict:
               data=dataDict[self.device]['scopes']['0']['wave'][0]['wave']
               datay=data*rng/float(2**15)
               if plt.get_fignums() and self.updated==1:
                   self.line.set_ydata(datay)
                   plt.draw()
               else:
                   # Create oscilloscope window
                   plt.figure()
                   plt.grid(True)
                   plt.title('Osciloscope data')
                   plt.xlabel('Time(us)')
                   plt.ylabel('Amplitude(V)')
                   
		   # Plot first oscilloscope shot
                   dt=dataDict[self.device]['scopes']['0']['wave'][0]['dt']
                   datax=[x*1e6 for x in arange(0,dt*2048,dt)]
                   plt.axis([0,datax[-1],-2*rng,2*rng])
                   self.line, = plt.plot(datax,datay)
                   self.updated=1


if __name__ == '__main__':

   # Open connection to ziServer
   daq = zhinst.ziPython.ziDAQServer('localhost', 8005)

   # Detect device
   device = zhinst.utils.autoDetect()

   # Set channels parameters
   channel_settings = [
       [['/', device, '/sigins/0/diff'], 0],
       [['/', device, '/sigins/0/imp50'], 0],
       [['/', device, '/sigins/0/ac'], 0],
       [['/', device, '/sigins/0/range'], 1],

       [['/', device, '/sigins/1/diff'], 0],
       [['/', device, '/sigins/1/imp50'], 0],
       [['/', device, '/sigins/1/ac'], 0],
       [['/', device, '/sigins/1/range'], 1],

       [['/', device, '/oscs/0/freq'], 100e3],
       [['/', device, '/oscs/1/freq'], 100e3+1],

       [['/', device, '/sigouts/0/add'], 1],
       [['/', device, '/sigouts/0/on'], 1],
       [['/', device, '/sigouts/0/range'], 1],
       [['/', device, '/sigouts/0/amplitudes/6'],0.5],

       [['/', device, '/sigouts/1/add'], 0],
       [['/', device, '/sigouts/1/on'], 1],
       [['/', device, '/sigouts/1/range'],1],
       [['/', device, '/sigouts/1/amplitudes/7'],0.5],
       ]
   daq.set(channel_settings)
   time.sleep(1)

   # Select lock-in channel
   channel=1

   # Create object Oscilloscope
   a=Oscilloscope(device,daq,channel)

   # Set parameters for the scope
   a.set_parameters(bwlimit=0,trigedge=1,triglevel=0,
                    trigholdoff=0.01,trigchannel=0,t=1)

   # Subscribe to scope data
   path0 = '/' + device + '/scopes/0/wave'
   daq.subscribe(path0)

   # N is number of oscilloscope shots
   N=random.randint(50,100)

   for i in range(0, N):
       a.update()
   
   # Unsubscribe     
   daq.unsubscribe(path0)
   print 'Done!'

Here is a figure with only 8 oscilloscope shots plotted in the same figure. The darker the color the later the oscilloscope data was recorded.

The MOD option is not included in the basic HF2LI and additionally requires the multifrequency option MF. If you already have a HF2LI and are interested in the MOD option, the upgrade is possible on the field without shipping the HF2LI back to ZI.

Tandem Sideband Demodulation with the HF2LI

Suppose I want to demodulate an input signal consisting of a carrier at a frequency ωc and two sidebands at frequencies +-ωm from the carrier. Tandem demodulation is the standard approach that requires two lock-in amplifiers in a tandem configuration: firstly, the input signal is demodulated to baseband at the carrier frequency with a bandwidth larger ωm; then the demodulated signal (either R or Theta according to whether the signal is an amplitude of frequency modulated signal) is fed to the second lock-in, where it is demodulated at the modulation frequency ωm. Additional instrumentation or measurement effort is paid, because the demodulation oscillator in the first demodulation step needs to be in phase with the carrier at ωc of the incoming signal.

As one single HF2LI contains two lock-in amplifiers, tandem demodulation is feasible. The first channel demodulates the incoming signal at the carrier frequency. From the three available demodulators of channel 1, I would use one demodulator with a narrow bandwidth to analyze the carrier frequency and another demodulator with sufficient bandwidth for the baseband signal. For further demodulation with the modulation frequency, the baseband signal is fed to the input of the second lock-in channel via the analog auxiliary output. In doing so, up to three sidebands can be analyzed in the second channel. The core limitation of this technique is set by the highest possible 200 kHz demodulation bandwidth and another 200 kHz filter on the auxiliary output channel.

Direct Sideband Demodulation with the HF2LI-MOD

Instead of tandem demodulation, the sidebands can also be analyzed directly by demodulating at frequencies (ωc – ωm) and (ωc + ωm). The HF2LI-MOD implements this scheme by using local oscillators at the corresponding sum and difference frequency of ωc and ωm. The assignment of the 6 internal demodulators to these local oscillators is shown in the figure below: Demodulators (1,2,3) and (4,5,6) are grouped into two MOD channels, MOD1 and MOD2, respectively. The 2 carrier frequencies can be equal, harmonics of each other (e.g. ωc1 = n * ωc2) or set arbitrarily. The same holds for the 4 different sideband spacings ωm1, .., ωm4. In the example of the figure below, each of these frequencies is set arbitrarily.  In total, you can therefore detect 4 sidebands (one upper and one lower sideband for each MOD channel). With such many degrees of freedom, you have plenty of possibilities for direct sideband demodulation with a frequency range up to 50 MHz in just one single box. This direct scheme has several advantages: it reduces lab complexity (only one lock-in used) and minimizes the SNR, because only one analog to digital conversion is required, which is not the case for tandem demodulation schemes.

HF2LI-MOD Output Signals

As stimuli for your measurements, you can choose between sinusoidal excitation, amplitude modulated (AM) excitation or frequency modulated (FM) excitation for either the MOD1 or MOD2 channel. Note that the FM generation requires two oscillators and one demodulator, thus leaving the other MOD available for demodulating 1 carrier and 2 sidebands. For sinusoidal excitation and AM excitation, you have all the 6 demodulators available to measure 4 independent sidebands.

The FM Spectrum

Only few people are excited about the mathematical description of an FM signal s(t), because

with the modulation index

Measuring the Bessel Functions

To demonstrate direct sideband demodulation with the HF2LI-MOD, I will sweep the modulation index h and directly measure the Bessel functions shown above with the demodulated sidebands. In a first step, I will generate an FM signal and demodulate 2 sidebands by using one HF2LI-MOD. In a second step, I use two HF2LI-MOD, one to generate the FM signal and another one to demodulate 4 sidebands.

Single Instrument FM Loop-back

To generate the FM signal, I use MOD1. I set the carrier frequency ωc to 1 MHz, the modulation frequency ωm to 1 kHz and the output amplitude to 1 V. The frequency deviation Δω is the sweep parameter. This FM signal is fed back to the input and routed to MOD2, where all sidebands are demodulated with a bandwidth of 6.8 Hz. I set demodulator 4 to the carrier frequency ωc, demodulator 5 to  ωc + ωm and demodulator 6 to ωc – 2ωm, which is done in the MF panel by selecting the harmonic 2 in demodulator 6.
I implemented the modulation index sweep in a LabVIEW routine, where I step the frequency derivation Δω in 100 steps from 0 to 10 kHz and record a single measurement value per demodulator for each step. The modulation index is thus swept from 0 to 10 with a step size of 0.1. Before the measurement, my routine provides an auto-zero function to eliminate the phase shifts φc and φm. I therefore directly obtain the Bessel functions on the (in-phase) X channels of each demodulator. One detail is a factor of √2 due to the RMS reading of X, which I accord for before plotting the Bessel functions. The resulting demodulator signals plotted against the modulation index h are shown in the figure below. The carrier corresponds to J0, the first sideband to J1 and the second sideband to J2. While the second sideband actually is a lower sideband (n=-2), I directly get J2 due to the even n.

In a next step, I then set φm to -90 degrees, which leads to a phase shift of -90 degrees between each created sideband. The first sideband is therefore shifted by -90 degrees and needs to be detected on the (quadrature) Y channel. The demodulated signal will correspond to -J1. The second sideband is shifted by 180 degrees and is measured on X. In this case, also the second sideband will have a different sign and therefore correspond to -J2. The figure shown below exactly reproduces the expectations.

In case you are interested in the LabVIEW implementation, you can download the vi . Provided you have a HF2LI-MOD, you simply need to connect output 1 to input 1 and run the vi with the same settings as shown in the former figure. If you also want to reproduce the latter figure, you need to shift the phase of oscillator 2 by -90 degrees.

Two Instrument FM Loop-back

To measure 4 sidebands at a time, I use a second HF2LI device with the MOD extension to generate an FM signal. Think of the FM signal generated by the second lock-in I use as the measurement signal resulting from an experiment. Consider for instance a laser, intensity modulated at 1 MHz and phase modulated at 1 kHz. You could use such a setup to measure the phase modulation sidebands at higher frequencies, where the laser noise is lower than at kHz frequencies. Hereto, you need a 1 MHz and a 1 kHz sinusoidal carrier to excite the modulation and then have exactly the same situation as I create here with a second lock-in amplifier as FM generator.

I use exactly the same settings for the generated FM signal as in the example with one device. On the HF2LI used for sideband demodulation, I use the second demodulator for J1, the third for J2, the fifth for J3 and the sixth for J4. The third and sixth demodulator both measure a lower sideband, but are here equal to the upper due to the properties of the Bessel functions Jn for even n. The resulting plots are shown in the figure below. On the left hand side, I have set the phases φc and φm to zero and thus get all the signals on the X channels. On the right hand side, I used a phase shift of -90 degrees for φm. I therefore detect the odd sidebands on the Y channels and the even sidebands on the X channels. According to the expectations, J1 and J2 are negative, whereas J3 and J4 are again positive.

Application Examples
You are welcome to browse the publications section of the Zurich Instruments website for the HF2LI-MOD. You find there examples on frequency modulation Kelvin probe force microscopy (FM-KPFM) and on advanced gyroscopes for inertial navigation. These examples combine the MOD option with the PLL option to measure sidebands of mechanical resonances, which is a very powerful tool for AFM and MEMS applications.

There is a new application note about pseudoheterodyne detection in nearfield optics, which is based on measurements I did together with Rolf Brönnimann at the EMPA Dübendorf, Switzerland, on a scanning nearfield optical microscope (SNOM). The detection scheme allows for visualization of optical intensity and phase down to intensities in the lower femtowatt range. First of all, this is two orders of magnitude better than what is possible with an avalanche photodiode module (APD), and furthermore gives you optical phase information. You can achieve higher detection sensitivity by using time-triggered single photon detectors (PMTs or APDs in Geiger mode). These however require a pulsed laser setup.

Please note that the optical phase needs to be preserved with interferometric techniques, because any nowadays available optical detector solely measures the optical intensity. Besides the discussed pseudoheterodyne detection scheme, heterodyne detection and phase shifting interferometry are popular approaches to measure the optical phase.

Difference between Heterodyne and Pseudoheterodyne Detection

Sometimes I get confused reactions on the term “pseudoheterodyne detection”, because “pseudo” sounds like nothing real is going on. To avoid confusions, I’d like to shortly point out how I see the difference between heterodyne and pseudoheterodyne detection in optics.

For both detection techniques, the measurement setup results in interference between the measurement signal and the modulated reference signal. The measurement signal (sig) and the modulated reference signal (ref) are both from the same laser source, as shown in the figure below.

By neglecting losses in the optical setup, the intensity of the interference signal to be detected reads

which corresponds to the square sum of the corresponding field amplitudes plus the interference term. φ is the optical phase difference between the measurement signal and the reference signal. By keeping the optical phase of the reference signal constant, φ is the optical phase of the sample and therefore the quantity of interest for phase-sensitive measurements. The main idea behind modulation of the reference signal is a spectral separation of the interference term. I therefore introduced an additional modulation ϕ, which accounts for the modulation technique. In total, there are two modulation techniques manipulating exclusively the optical phase of the reference signal:

Frequency-shifting

Frequency-shifting can be realized by acousto-optic modulators (AOM). The shift-frequency Δω is in the order of several MHz and a combination of two AOM is often applied for a kHz shift-frequency (1, 2). The interference term for a frequency-shifted reference signal is

The detection of φ and the amplitude of the measurement signal is straightforward with a lock-in amplifier that demodulates Δω. Frequency-shifting therefore creates one single interference beat oscillating at Δω. Phase-sensitive detection by frequency-shifting is known as a heterodyne detection technique.

Phase-modulation

Phase-modulation can be realized by electro-optic modulators (EOM) or piezo-electric phase modulators. Depending on the modulation device, the modulation frequency ω has a value from lower kHz up to MHz. The interference term for a phase-modulated reference signal is

where I introduced the angular phase modulation amplitude am, which is also known as the modulation depth or the modulation index. If I want to extract the optical amplitude and phase of the signal, I need to expand the interference signal as a Fourier series. To do so, I first use the cos(a+b) identity to separate the φ terms and then use the expansions for cos(cos) and sin(cos), which introduce lengthy Fourier series. The result is

The formula above should give you the following two important messages: Firstly, each sideband is a harmonic of the modulation frequency and weighted by the corresponding Bessel function evaluated at the modulation amplitude. Due to this weighting, you observe only a few low order harmonics in practice, whereas high order harmonics vanish. Secondly, the optical in-phase component – the term proportional to cos(φ) on the first line – is on even harmonics, whereas the optical quadrature component – the term proportional to sin(φ) on the second line – is on odd harmonics. As both the optical in-phase and quadrature component are needed for phase-resolved measurements, an even and an odd harmonic of the modulation frequency need to be demodulated by the lock-in amplifier. The most convenient way is to set the modulation amplitude am to 2.63 rad (e.g. 150.7°), where J1(am) = J2(am) = 0.4624, as mentioned in the application note. The first and second harmonic then have the same Bessel coefficient and are demodulated with the lock-in amplifier, which is straightforward with the HF2LI.
Phase-modulation therefore creates multiple interference beats oscillating at several harmonics of the modulation frequency. Phase-sensitive detection by phase-modulation is known as pseudoheterodyne detection. The main difference to phase-sensitive heterodyne detection is that more than one beat frequency needs to be demodulated in order to extract the optical phase information.

Does Phase-Modulation imply Pseudoheterodyne Detection?

Based on this description, one might thinks that optical heterodyne detection is linked to frequency-shifting and pseudoheterodyne detection is linked to phase-modulation. However, this is only true with respect to interferometric phase-sensitive detection. While frequency-shifting creates only a single beat frequency, pseudoheterodyne applications for frequency-shifting do not exist. For phase-modulation on the other hand, there are numerous applications where only the first sideband is demodulated. Accordingly, these techniques are termed heterodyne detection. The outcome of these measurements is not the same as for the pseudoheterodyne detection technique described above. I give a few examples in the following, where I differentiate between interferometric techniques and non-interferometric techniques. For interferometric techniques, the formulas above are also applicable. These techniques measure the first harmonic exclusively, which corresponds to the optical quadrature component discussed above. For non-interferometric techniques, different formalisms are needed to describe oscillating components in the measured intensity.

An example for interferometric heterodyne detection with phase-modulation is interferometric CARS, where optical quadrature component yields the background-free vibrational absorption spectrum (3). Another example for interferomtric heterodyne detection with phase modulation is the optical interferometer incorporated into AFMs to measure the cantilever oscillation (4). The cantilever movement modulates the optical phase with a very small modulation amplitude. For both examples, the phase of the reference signal needs to be adjusted for maximum sensitivity, which is when the two interfering signals are in quadrature. A third example is Pound-Drever-Hall laser stabilization (5), which creates a feedback signal based on the first phase-modulation sideband.

Another set of examples for heterodyne detection with phase-modulation is found in non-interferometric detection schemes. One example is FM spectroscopy, where the first sideband gives information about absorption and dispersion (6).

While optical heterodyne detection has a counterpart in communication technology (heterodyne receiver with local oscillator), I never heard anyone from the communication community speaking about a pseudoheterodyne receiver. The term pseudoheterodyne detection is so far only used in the context of phase-resolved measurements in optics (7,8).

References

1. A. Nesci, R. Dändliker, H. Herzig, Quantitative amplitude and phase measurement by use of a heterodyne scanning near-field optical microscope, Opt. Lett. 26, 208-210 (2001)
2. M. Sandtke, R. J. P. Engelen, H. Schoenmaker, I. Attema, H. Dekker, I. Cerjak, J. P. Korterik, F. B. Segerink, L. Kuipers, Novel instrument for surface plasmon polariton tracking in space and time, Rev. Sci. Instrum. 79, 013704 (2008)
3. E. Potma, C. Evans, X. Xie, Heterodyne coherent anti-Stokes Raman scattering (CARS) imaging, Opt. Lett. 31, 241-243 (2006)
4. D. Rugar, H. J. Mamin, R. Erlandsson, J. E. Stern, B. D. Terris, Force microscope using a fiber-optic displacement sensor, Rev. Sci. Instrum. 59, 2337 (1988)
5. C.G. Bjorklund, M. D. Levenson, W. Lenth, C. Ortiz, Frequency modulation (FM) spectroscopy, Applied Physics B: Lasers and Optics, Vol. 32, Nr. 3, 145 – 152 (1983)
6. R. W. P. Drever, J. L. Hall, F. V. Kowalski, J. Hough, G. M. Ford, A. J. Munley, H. Ward, Laser phase and frequency stabilization using an optical resonator, Applied Physics B: Lasers and Optics, Vol. 32, Nr. 3, 97 – 105 (1983)
7. M. Vaez-Iravani, R. Toledo-Crow, Phase contrast and amplitude pseudoheterodyne interference near field scanning optical microscopy, Appl. Phys. Lett. 62, 1044 (1993)
8. Nenad Ocelic, Andreas Huber, Rainer Hillenbrand, Pseudoheterodyne detection for background-free near-field spectroscopy, Appl. Phys. Lett. 89, 101124 (2006)

The LabVIEW example described in this blog can be downloaded . Our getting started for inexperienced LabVIEW users is found . Note that both these files require a proper installation of our LabVIEW driver, as explained below.

Other communication interfaces are explained in Controlling the HF2LI Lock in with Matlab  and in Controlling the HF2LI Lock in with Python. LabVIEW has a different concept than these two languages due to its graphical programming interface, but the underlying communication scheme is similar. Since the ziControl user interface itself is based on LabVIEW, many useful functional building blocks and sophisticated examples are included in the LabVIEW driver.

Installation

The LabVIEW API is included in the ziBase installation, which can be downloaded from our website. To inte­grate the driver within LabVIEW, you need to extract driver.zip from API/LabVIEW in your Zurich Instru­ments program folder to the instr.lib folder in the LabVIEW program folder. After restarting Lab­VIEW, the added functions are found in LabVIEWs func­tion palette, as illustrated below.

The Instrument Driver Functionality

The VI tree shown below depicts the drivers capabilities.

As can be seen in the tree, ziOpen and ziClose are mandatory functions to initialize and close the connection to the Instrument. Then, there are three subgroups, whose elements are freely arrangeable to fulfill your desired measurement task.

Configuration

The configuration functions give reading and writing access to the parameters of the ZI device. This capability to define the critical parameters and settings for specific measurements directly within LabVIEW guarantees reproducible measurement conditions.

Besides parameter access, the configuration subgroup also provides functions to read a single instantaneous measurement value. One can choose between all possible readings of the Instrument, which are 6 demodulators, 2 analog auxiliary inputs and 1 digital input with up to 32 bits for the HF2LI. It is furthermore possible to set the values for the auxiliary outputs. For experiments requiring only a few measurement readings, these simple functions are sufficient.

Data

The data functions stream sequential data and are essential if every measurement sample needs to be processed. To choose the input to be streamed, subscribe and unsubscribe functions are provided. Once there is a subscription, the buffered data stream is read out with ziPollData.vi. The data rate is specified by the user and high data rates up to 230kS/sec are possible. Later in this blog, there is a loop-back example which demonstrates the proper use of the subscribe and poll functions.

Utility

The utility functions provide a set of functions to use setting files to save/load the instrument configuration, work with multiple ZI devices, use frequency sweeping functions to measure transfer functions and perform unit conversions.

LabVIEW Examples

LabVIEW examples give a guideline on how the functions can be used. Upon proper installation of the driver, the examples can be found by searching for HF2 within LabVIEWs example finder. Inexperienced LabVIEW users furthermore find a getting started for download, which uses easy to understand examples to guarantee programming success.

Loop-back Example

For demonstration purposes, I provide an example performing basic parameter setup and measurement data streaming with the HF2LI. The block diagram is shown in the figure below. If you want to explore this VI yourself, you can download it . In the following, I explain the program flow according to the text labels shown in the bottom of the block diagram.

Label 1 / 2: Initialize a connection / Initialize settings

The program flow starts with ziOpen, which initializes the connection to the Instrument. Thereafter, I initialize three parameters within a for loop. Within each loop iteration, one of the three node/value pairs from the array is unbundled and routed to ziSetValueDouble. This function writes the value to the parameter addressed by its node definition. Here I use the following node definitions

The quickest way to find out a parameters node definition is within the ziControl application. Every time you change a parameter in ziControl, you see the parameters node definition with the new value in the history bar in the bottom of the ziControl window.

Label 3 / 4: Subscribe data node / Flush data buffer

To setup data streaming, we use ziSubscribe to get a subscription to the first demodulator channel, which is addressed by demods/0/sample. Before reading data, ziFlush is used to remove any old data from the buffer.

Label  5: Poll and plot data

In the subsequent poll loop, data is continuously read  from the ziServer buffer and plotted in the graph. If the buffer has no new data upon request, ziPollData waits for new data until the specified timeout expires, which is here set to 100 ms. Such cases only occur with slow sample rates and it is recommended to always guarantee functionality of your program by adding a case structure that treats a possible timeout event. In the current example, this case structure is labeled with Timeout? and assures that no data is plotted in case of a timeout. As can be seen inside the case structure, each measurement sample read by ziPollData contains the following records:

In this basic example, I only use the demodulators X and Y reading to calculate and plot the corresponding absolute value.

Label 6: Close the connection

At the end of the program, ziClose closes the connection to the device.

Loop-back Measurement

If I physically feed the output signal back to the input, I perform a simple loop-back experiment. If I then run the example program, the front panel appears as shown below. The data graph correctly shows a straight line corresponding to the RMS value of 1/√2. To avoid remaining open connections to the Instrument, program execution must be aborted with the STOP button instead of LabVIEWs own abort button. Otherwise, too many unclosed connections left in the memory could hamper your computing performance and a LabVIEW restart is needed to release the occupied memory.

LabVIEW Driver Summary

Altogether the LabVIEW driver offers you far reaching possibilities towards measurement automation and measurement reproducibility due to the following features

1. Full control over instrument parameters
2. Fast measurement data streaming
3. Flexible interface to control complex measurements

Communication with HF2LI Lock-in using Matlab is explained in Controlling the HF2LI Lock in with Matlab.. These two libraries share most of the code and are thus very similar in usage.

Zurich Instruments Python Interface Installation

Currently, Python 2.6x is supported. It’s recommend to install this Python version from Python programming language official website. The ziPython package containing the interface to control the HF2LI Lock-in from Python can be downloaded from the Zurich Instruments download page. Please use your Zurich Instruments login to get access to the download area.

To install the package on Windows execute the installer. It will guide you through the installation process as displayed in the following screen shots.

After clicking on the Next button, the existing Python installation can be selected. The package will be installed in the folder …Python26Libsite-packageszhinst.

The interface will use numpy for fast data transfer. Therefore, the package NumPy is required. To run the example code the matplotlib library needs to be installed as well. Unofficial 64bit precompiled packages of both modules can be found on the page of Christoph Gohlke.

After installation, we are ready to run the first Python script controlling the HF2 Lock-in amplifier.

Simple Loop-back Measurement with the HF2LI Lock-in

During a loop-back measurement we generate a signal and measure the signal with the HF2LI Lock-in. Thus, connect the Signal Output 1 Out to Signal Input 1 +In with a BNC cable. The HF2LI Lock-in is connected to the computer with a USB 2.0 cable. The ziServer should be running on the computer where the instrument is connected to. It is automatically started if the Zurich Instruments driver ziBase was installed beforehand. To check whether a server is running, check in the Windows Task Manager for the processes ziSrv01.exe and ziStrt01.exe. On Linux the process name is ziServer64 or ziServer32 for 64bit or 32bit systems, respectively.

The package ziPython contains two modules zhinst.ziPython and zhinst.utils. The module zhinst.ziPython provides all classes for interfacing to the ziServer which is communicating with the HF2LI Lock-in. The class ziDAQServer provides methods that access the device with synchronous calls. This methods block during execution.
The module zhinst.utils contains helper functions to provide code for often performed tasks. In the example below we use the method autoDetect to read the name of the HF2LI Lock-in device currently connected to the ziServer.
Download the file .

import zhinst.ziPython, zhinst.utils
from numpy import *
import time
# Open connection to ziServer
daq = zhinst.ziPython.ziDAQServer('localhost', 8005)
# Detect device
device = zhinst.utils.autoDetect()
#Record one demodulator sample from the specified node
sample = daq.getSample('/'+device+'/demods/0/sample')
r = sqrt(sample['x']**2+sample['y']**2)
print 'Measured rms amplitude is %fV.' % r

After running this script, measured rms amplitude is zero because the output channel is not enabled.

Changing Device Settings

Switching the output channel on and setting the amplitude of the output signal to 100 mV using the ziControl interface, the measured rms amplitude after running the same example will be around 70.7 mV. Because the ziServer manages all communication between the HF2LI amplifier and all programs (clients) that access the HF2LI, it’s possible to control HF2LI device with user programs and ziControl simultaneously. The ziServer keeps track of all the setting changes and sends update changes to the other applications.

There are two methods for changing device settings with Python. The first approach is using setInt(...), setDouble(...), setByte(...) methods. This methods receive as argument a path string of the node and the node value. In a multi-threaded environment the Python interpreter uses a global lock, called Global Interpreter Lock (GIL), that synchronizes the code execution of the different Python threads. Only one thread that has acquired the GIL may operate on Python objects. This serialization process may slow down program execution in the multi-thread environment if many set commands are executed in sequence. For performance reasons it is thus an advantage to collect all settings in a list and the set all at once. During that set command execution the GIL is released by ziPython. This allows the Python interpreter to execute code from other threads simultaneously.
The following gives an example of single setInt(...), setDouble(...), and setByte(...) commands. The ziPython interface performs an implicit conversion between double and integer if needed. Thus, for most settings the precision is accurate enough to use either of them.

import zhinst.ziPython, zhinst.utils
from numpy import *
import time
# Open connection to ziServer
daq = zhinst.ziPython.ziDAQServer('localhost', 8005)
# Detect device
device = zhinst.utils.autoDetect()
#set the amplitude of output channel 1 to 100mV
daq.setDouble('/' + device + '/sigouts/0/amplitudes/0', 0.1);
#set the enable output channel
daq.setDouble('/' + device + '/sigouts/0/enables/0', 1);
#turn on output channel
daq.setInt('/' + device + '/sigouts/0/on', 1);
# wait 1s
time.sleep(1)
#Record one demodulator sample from the specified node
sample = daq.getSample('/'+device+'/demods/0/sample')
r = sqrt(sample['x']**2+sample['y']**2)
print 'Measured rms amplitude is %fV.' % r

From the point of view of program execution time if it’s needed to change more settings, it’s better to use set command. That method receives as argument a list with elements [[node_path], set_value]. The next example uses the set command to change settings of the HF2LI Lock-in amplifier.

It’s convenient to use the ziControl to find out path strings of the nodes. If you change a setting using the ziControl, the command line display (located at the bottom of the ziControl interface) will show the command that was sent to the instrument in a format node_path : set_value.

Polling Demodulator Data

If continuous data recording is performed polling functions are best suited. To select the nodes from which data should be polled, the subscribe / unsubscribe commands are used. The following example demonstrates the synchronous poll usage. Thus, the poll command will block during the specified recording time. Due to the blocking behavior, too long recording times should be avoided as the interface is not responsive within that time.

For recoding times longer than 10s it is recommended to used the poll command inside a loop. With this method continuous data can be recorded over a longer time frame. Internal data buffering on the ziServer ensures that no data is lost between the poll commands. As these buffers are limited in size, the time between poll commands must not be too large for high sampling rates. If extensive calculations should be performed during the poll commands, the asynchronous poll interface might be better suited.
Download the file .

import time, math
import zhinst.ziPython, zhinst.utils
import matplotlib
import matplotlib.pyplot as plt
from numpy import *
def measureSynchronousFeedback(daq, device, channel, frequency):
   c=str(channel-1)
   amplitude=1
   rate=200
   tc=0.01
   # Disable all outputs and all demods
   general_setting = [
        [['/', device, '/demods/0/trigger'], 0],
        [['/', device, '/demods/1/trigger'], 0],
        [['/', device, '/demods/2/trigger'], 0],
        [['/', device, '/demods/3/trigger'], 0],
        [['/', device, '/demods/4/trigger'], 0],
        [['/', device, '/demods/5/trigger'], 0],
        [['/', device, '/sigouts/0/enables/*'], 0],
        [['/', device, '/sigouts/1/enables/*'], 0]
   ]
   daq.set(general_setting)
   # Set test settings
   t1_sigOutIn_setting = [
       [['/', device, '/sigins/',c,'/diff'], 0],
       [['/', device, '/sigins/',c,'/imp50'], 1],
       [['/', device, '/sigins/',c,'/ac'], 0],
       [['/', device, '/sigins/',c,'/range'], 2],
       [['/', device, '/demods/',c,'/order'], 8],
       [['/', device, '/demods/',c,'/timeconstant'], tc],
       [['/', device, '/demods/',c,'/rate'], rate],
       [['/', device, '/demods/',c,'/adcselect'], channel-1],
       [['/', device, '/demods/',c,'/oscselect'], channel-1],
       [['/', device, '/demods/',c,'/harmonic'], 1],
       [['/', device, '/oscs/',c,'/freq'], frequency],
       [['/', device, '/sigouts/',c,'/add'], 0],
       [['/', device, '/sigouts/',c,'/on'], 1],
       [['/', device, '/sigouts/',c,'/enables/',c], 1],
       [['/', device, '/sigouts/',c,'/range'], 1],
       [['/', device, '/sigouts/',c,'/amplitudes/',c], amplitude],
   ]
   daq.set(t1_sigOutIn_setting);
   # wait 1s to get a settled lowpass filter
   time.sleep(1)
   #clean queue
   daq.flush()
   # Subscribe to scope
   path0 = '/' + device + '/demods/',c,'/sample'
   daq.subscribe(path0)
   # Poll data 1s, second parameter is poll timeout in [ms]  
   # (recomended value is 500ms) 
   dataDict = daq.poll(1,500);
   # Unsubscribe to scope
   daq.unsubscribe(path0)
   # Recreate data
   if device in dataDict:
       if dataDict[device]['demods'][c]['sample'][0]['time']['dataloss']:
           print 'Sample loss detected.'
       else:
           e=0.5*amplitude/sqrt(2)
           data = dataDict[device]['demods'][c]['sample'][0]
           rdata = sqrt(data['x']**2+data['y']**2)
           print 'Measured rms amplitude is %.5fV (expected: %.5fV).' %(mean(rdata),e)
           tdata= (data['timestamp']-data['timestamp'][0])/210e6
           # Create plot 
           plt.figure(channel)
           plt.grid(True)
           plt.plot(tdata,rdata)
           plt.title('Demodulator data')
           plt.xlabel('Time (s)')
           plt.ylabel(' R component (V)')
           plt.axis([tdata[0],tdata[-1],0.97*e,1.03*e])
           plt.show()
# Open connection to ziServer
daq = zhinst.ziPython.ziDAQServer('localhost', 8005)
# Detect device
device = zhinst.utils.autoDetect()
measureSynchronousFeedback(daq, device, 1, 1e5);

The method ziDAQServer creates an instance of the ziServer you are connecting to. The poll method of this object returns data of all subscribed nodes in the Python dict data type. In the previous example values of the following nodes have been received.

data['timestamp'] # Time stamp data [uint64]. Divide value by 210e6 to
# calculate the time stamp in seconds.
data['x'] # Demodulator x value in volt [double]
data['y'] # Demodulator y value in volt [double]
data['frequency'] # Current demodulator frequency in hertz [double].
data['phase'] # Phase value [double].
data['dio'] # Digital IO data [uint32].
data['auxin0'] # Auxiliary input value of channel 0 in volt [double].
data['auxin1'] # Auxiliary input value of channel 1 in volt [double].
data['time']['dataloss '] # Indication of sample loss (including block loss).
data['time']['blockloss '] # Indication of data block loss over the socket
# connection. This may be the result of a too long break between subsequent
# poll commands.
data['time']['invalidtimestamp '] # Indication of invalid time stamp data
# as a result of a sampling rate change during the measurement.

Simple Loop-back Measurement with the Instrument

To perform the measurement connect the HF output of your instrument with the HF input with a short BNC cable. This routes the output signal back to the input of the instrument. Also connect your Zurich Instruments HF2LI device with a USB cable to a computer with the ziServer running. The ziServer is automatically started if the Zurich Instruments driver was installed beforehand.

Next you need to install the Matlab driver ziDAQ for the instrument. You can get the latest version by supplying following information in a support request:

• Matlab version e.g 7.6
• Matlab processor architecture e.g. 64Bit (win64)
• Operating system e.g. Windows 7

The appropriate DLL driver (e.g. ziDAQ.mexw64) needs to be copied in the local directory you are working in. Or you also may add the driver directory to your Matlab path (type help path in Matlab).

Now you are ready to start the example in Matlab.

The interface to the Zurich Instruments lock-in amplifier is based on the function call ziDAQ. The first parameter is used to specify the interface functionality that should be executed. Use the command help ziDAQ to get a help text on all available commands.
The simplest method of accessing demodulator data offers the function call ziDAQ('getSample',...). This function call returns a single sample from the specified demodulator path. Download the file .

function simple_example
clear ziDAQ
ziDAQ('connect');
device = autoDetect;
% Record one demodulator sample from the specified node.
sample = ziDAQ('getSample', ['/' device '/demods/0/sample']);
% Calculate r from x and y.
r = sqrt(sample.x.^2 + sample.y.^2);
fprintf('Measured rms amplitude %gVn', r);

In order to select the connected device automatically, the following helper function should be copied in the working directory. The function assumes, that only one device is connected to the computer. Download the file .

function device = autoDetect
nodes = lower(ziDAQ('listNodes', '/'));
dutIndex = strmatch('dev', nodes);
if length(dutIndex) > 1
error('autoDetect does only support a single device configuration.');
elseif isempty(dutIndex)
error('No DUT found. Make sure that the USB cable is connected to the host and the device is turned on.');
end
% Found only one device -> selection valid.
device = lower(nodes{dutIndex});
fprintf('Will perform measurement for device %s ...n', device)

Polling Demodulator Data

If continuous data recording is required the polling functions are best suited. To select the nodes from which data should be polled, the subscribe / unsubscribe commands are used. The following example demonstrates the synchronous poll usage. Thus, the poll command will block during the specified recording time. Due to the blocking behavior, too long recording times should be avoided as the interface is not responsive during that time.
For recoding times longer than 10s it is recommended to used the poll command inside a loop. With this method continuous data can be recorded over a longer time frame. Internal data buffering on the ziServer ensures that no data is lost between the poll commands. As these buffers are limited in size, the time between poll commands must not be too large for high sampling rates. If extensive calculations should be performed during the poll commands, the asynchronous poll interface may be better suited.
Download the file .

function synchronous_example
clear ziDAQ
ziDAQ('connect');
device = autoDetect;
measureSynchronousFeedback(device, 1, 1e5);

function measureSynchronousFeedback(device, channel, frequency)
c = num2str(channel - 1, '%0d');
% Settings
rate = 200;
tc = 0.001;
ziDAQ('setInt',['/' device '/sigins/' c '/imp50'], int64(1));
ziDAQ('setInt',['/' device '/sigins/' c '/ac'], int64(0));
ziDAQ('setInt',['/' device '/sigins/' c '/diff'], int64(0));
ziDAQ('setDouble',['/' device '/sigins/' c '/range'], 2);
ziDAQ('setInt',['/' device '/sigouts/' c '/on'], int64(1));
ziDAQ('setInt',['/' device '/sigouts/' c '/enables/' c], int64(1));
ziDAQ('setInt',['/' device '/sigouts/' c '/add'], int64(0));
ziDAQ('setDouble',['/' device '/sigouts/' c '/range'], 1);
ziDAQ('setDouble',['/' device '/sigouts/' c '/amplitudes/*'], 0);
ziDAQ('setDouble',['/' device '/sigouts/' c '/amplitudes/' c], 1);
ziDAQ('setDouble',['/' device '/demods/' c '/rate'], rate);
ziDAQ('setDouble',['/' device '/demods/' c '/phaseshift'], 0);
ziDAQ('setInt',['/' device '/demods/' c '/order/'], int64(8));
ziDAQ('setInt',['/' device '/demods/' c '/harmonic/'], int64(1));
ziDAQ('setInt',['/' device '/demods/' c '/adcselect/'], int64(channel - 1));
ziDAQ('setDouble',['/' device '/demods/' c '/timeconstant'], tc);
ziDAQ('setInt',['/' device '/demods/' c '/oscselect'], int64(channel - 1));
ziDAQ('setDouble',['/' device '/oscs/' c '/freq'], frequency);
% Unsubscribe all streaming data
ziDAQ('unsubscribe', '*');
% Clean queue
ziDAQ('flush');
% Pause to get a settled lowpass filter
pause(10*tc);
ziDAQ('subscribe',['/' device '/demods/' c '/sample']);
d = ziDAQ('poll', 1, int64(200));
ziDAQ('unsubscribe',['/' device '/demods/' c '/sample']);
if ~isempty(d)
device = getfield(d, device);
if device.demods(channel).sample.time.dataloss
fprintf('Sample loss detected.');
end
r = mean(sqrt(device.demods(channel).sample.x.^2 + device.demods(channel).sample.y.^2));
end
e = 0.5 / sqrt(2);
fprintf('Measured rms amplitude %gV (expected: %gV)n', r, e);

The function call ziDAQ('poll', ...) returns the following data structure.

sample.timestamp % Time stamp data [uint64]. Divide value by 210e6 to calculate the time stamp in seconds.
sample.x % Demodulator x value in volt [double]
sample.y % Demodulator y value in volt [double]
sample.frequency % Current demodulator frequency in hertz [double].
sample.phase % Phase value [double].
sample.dio % Digital IO data [uint32].
sample.auxin0 % Auxiliary input value of channel 0 in volt [double].
sample.auxin1 % Auxiliary input value of channel 1 in volt [double].
sample.time.dataloss % Indication of sample loss (including block loss).
sample.time.blockloss % Indication of data block loss over the socket connection. This may be the result of a too long break between subsequent poll commands.
sample.time.invalidtimestamp % Indication of invalid time stamp data as a result of a sampling rate change during the measurement.


Vectors that contain NaN’s indicate sample loss. In this case the sample.time.dataloss flag is set.

Using the HF2LI Graphical User Interface ziControl

Loading the data from a file is a simple and fast approach. It is well suited if you would like to share the data between different applications.

It is best to save the data in binary format. Therefore, make sure that the check box Binary Save is enabled. Then press the Save button to start the measurement. This should save binary files with file extension *.ziBin into the specified directory.

Saving measurement data with the ziControl

Loading the Binary Data in Matlab

To load the measurement files we use a helper function which loads the file content into a structure. Download the file .

function data = ziLoad(file)
% Loads the measurement data from a ziBin file
% E.g data = ziLoad('Freq1.ziBin');
fid = fopen(file, 'r', 'ieee-be');
if fid == -1
error(['File ' file ' not found.']);
end
raw = fread(fid, inf, '*double');
if mod(length(raw), 7) ~= 0
error('Illegal file size of ziBin file detected.');
end
data.timestamp = raw(1:7:end);
data.x = raw(2:7:end);
data.y = raw(3:7:end);
data.frequency = raw(4:7:end);
data.bits = uint32(raw(5:7:end));
data.auxin0 = raw(6:7:end);
data.auxin1 = raw(7:7:end);
fclose(fid);

To load the data in Matlab you just call the function ziLoad in Matlab.

% Load the measurement data of demodulator 1 into a structure
data = ziLoad('mydata/Freq1.ziBin');

Now the data is found on the workspace. It is a structure array with following fields.

data =
timestamp: [2855x1 double]
x: [2855x1 double]
y: [2855x1 double]
frequency: [2855x1 double]
bits: [2855x1 uint32]
auxin0: [2855x1 double]
auxin1: [2855x1 double]

Now we plot R over recording time. The plot2svg function can be downloaded here.

s = plot(data.timestamp - data.timestamp(1), ...
sqrt(data.x.^2 + data.y.^2) * 1e9, 'black');
% Format the plot
set(s, 'LineWidth', 2);
xlabel('Time [s]');
ylabel('Voltage R [nV]')
box on
grid on
% Save the plot as Scalable Vector Graphics (SVG)
plot2svg('my_first_lockin_measurement.svg')

R recorded with Zurich Instruments HF2LI