This note describes a Python example that we created as part of an application note which describes the basics of power supply efficiency testing, which is available here: Power Supply Efficiency App Note

Typical power efficiency curves require 10 or more load current steps to get an accurate representation of efficiency. Manually performing this test can be a bit tedious and prone to error.

For the resolution question, consider that most commercial power supplies and DC loads have 3.5 digit measurement resolution and accuracy values that may not be high enough to characterize the DUT confidently.

To address these two considerations, we added four multimeters: one to measure Vin, Iin, Vout, and Iout and created a computer program to automate the instrument configurations, step load current values, and data collection.

Here is a wiring diagram of the setup:

Software

Automating this type of test is a great way to minimize errors as well as speed up the test process.

We put together an example program using Python that performs the following:

• • Prompts the user for start, stop, and number of current load steps
  • Power Supply settings to deliver proper power to the DUT
  • Filename to save the CSV data file

Requirements:

• • Qty 1 SIGLENT SPD series power supply
  • Qty 1 SIGLENT SDL1000X series DC electronic load
  • Qty 4 SIGLENT SDM3000 series digital multimeter
  • Qty 1 6 port or more USB hub, USB cables
  • Cabling* to connect all instruments and DUT
  • Python 3.0 or greater
  • tkinter
  • PyVISA

*Use the proper gauge wiring and connectors that are rated above the maximum current draw expected to minimize the risk of fire or overheating.

To run the program:

• • Download Python 3.6, PyVISA, and tkinter (a module that eases Graphical User Interface creation)
  • Download the program SIGLENT PS Efficiency.ZIP
  • Connect instruments and DUT. It may be helpful to put a small label on each DMM to make it easier to visually identify their roles.
  • Open the program using a Python editor like IDLE
  • Edit the USB addresses for each instrument.

Here is a screenshot of the code showing the addresses:

Where:

• • • • SPDadd is the power supply address
      • SDLadd is the electronic load address
      • SDMVinadd is the address of the DMM measuring the input voltage
      • SDMIinadd is the address of the DMM measuring the input current
      • SDMVoutadd is the address of the DMM measuring the output voltage
      • SDMIoutadd is the address of the DMM measuring the output current

One easy way to establish the USB addresses is to use the National Instruments MAX application. With Max, you can connect the instruments via USB and check all of the addresses:

NOTE: The USB resource ID contains the instrument serial number, which can be used to help identify which instrument you are communicating with. As noted above, it may be helpful to put a small label on each instrument including the serial number to make it easier to visually identify each instrument and ensure they are wired correctly for their role in the test.

• • After wiring everything up, you can run the module.
  • The first thing you should see is the User Interface (UI) as shown below:

• • Enter the proper values for each entry and press Start
  • As the process begins, you should see the output indicator on the power supply turn on, the DC Load input light should turn on, and the displayed values for current and voltage should meet your programmed values
  • The program prints each step value measurement on the display as shown here:

This program uses the auto-ranging measurement function of each instrument, which can add time to each measurement. For proper DC measurements, there needs to be some time delay at each step value to ensure a stable reading. We have programmed sufficient delays for most DUTs, but you may need to tweak delays to meet your specific test needs.

• • Upon completion, the program will indicate that it is complete and write a CSV file to the folder where the Python program is located.

• Find the CSV file, copy columns A – I:

• Open a copy of the file Efficiency Template.xls included in the program folder, and paste the results to plot the curve:

The post Programming Example: Python Power Supply Efficiency Example appeared first on Siglent.

Many electronic designs require a power supply that delivers a known voltage over a specific range of current loads and conditions. In many instances, the efficiency of the supply is an essential characteristic of the design. More efficient designs covert the input power into a higher percentage of output power than less efficient designs. Since the majority of power supply losses are generated as heat within the supply, more efficient designs tend to run cooler, offer higher stability, and longer operating lifetime. More efficiency often just makes more sense. This is especially important for applications that require battery power like remote IOT sensing or communications modules that need to be operational for an extended length of time.

In order to make more efficient designs, we need to know how to measure power supply efficiency. In this note, we will introduce the basic theory for DC power supply efficiency calculations, present a physical setup for accurately measuring the important parameters, and provide an example program that coordinates measurements and automatically calculates power supply efficiency quickly.

Background Theory

The efficiency of a power supply is simply the ratio of the power out vs the power in.

From power electronics theory:

η = Pout / Pin

Where η = Power Efficency, Pout = Output power (Watts), and Pin = Input power (Watts)

For DC power,

P = V * I

Where P = Power (Watts = Joules/s), V = Volts (Joules/Coulomb), and I = Current (Amps = Coulombs/s)

So, if we measure the input voltage and current draw, we can calculate the input power.

Pin = Vin * Iin

If we measure the output voltage and current draw, we can calculate the output power.

Pout = Vout * Iout

Now, some simple division provides Power Efficiency as a ratio which can be easily shown as a percentage at that specific load value. A curve of the efficiency vs. load values can be calculated by stepping the load value and calculating the efficiency at each load value and plotting it as shown below:

Figure 1: Sample Power Supply Efficiency Curve, from Linear Technologies Datasheet for an LTM4646.

Setup

The most basic setup for this test uses:

Qty 1 Power Supply

Qty 1 DC electronic load

Typically wired as shown:

The process:

• Supply power to the DUT
• Set the load for a given current draw
• Measure the Vin, Iin, Vout, and Iout at the load current set point

This is about as simple as it gets with an electronics test.. but there are two important considerations with this setup:

1. 1. How many load steps are required to accurately build an efficiency curve for your DUT?
   2. What level of resolution and accuracy do you need for the calculation?

Typical power efficiency curves require 10 or more load current steps to get an accurate representation of efficiency. Manually performing this test can be a bit tedious and prone to error. To save time, you may want to consider automating the setup with a computer. Here is an example we built using Python that may be helpful: LINK TO EXAMPLE

For the resolution question, consider that most commercial power supplies and DC loads have 3.5 digit measurement resolution and accuracy values that may not be high enough to characterize the DUT confidently.

To address these two considerations, we added four multimeters: One to measure Vin, Iin, Vout, and Iout and created a computer program to automate the instrument configurations, step load current values, and data collection.

Here is a wiring diagram of the setup:

Here is a picture of the experimental setup which uses a SIGLENT SPD1168X, SDM3055s for Iin and Iout, SDM3045Xs for Vin and Vout, and an SDL1020X-E DC load:

Here the DUT is the Linear Technologies LTM4646 power module we used in this video on Load Step Testing

NOTE: Keep the leads to the load as short as possible to minimize I*R voltage drop and select DMMs with a low voltage burden on the current measurement ranges you expect to use. Long leads and a high voltage burden can cause the DUT to reach its output voltage limit before reaching the maximum expected current draw. 

Summary

Power supply efficiency is an important aspect of any power supply design. Using a few standard pieces of test gear, one can quickly build a modular system with enough resolution to measure the most demanding applications.

The post Easy DC power supply efficiency measurements appeared first on Siglent.

Here is a zip file of the working program: PythonSocket_SPD_10232019.zip

NOTE: The SPD uses VXI-11 protocol for LAN. On some systems, it is helpful to use the VXI-11 format for the IP address:

“TCPIP::ip.add.re.ss::INSTR”

Here is the program in full:

#!/usr/bin/env python
#-*- coding:utf-8 –*-
#-----------------------------------------------------------------------------
# The short script is a example that open a socket, sends a query,
# print the return message and closes the socket.
#
#No warranties expressed or implied
#
#SIGLENT/JAC 05.2018
#
#-----------------------------------------------------------------------------
import socket # for sockets
import sys # for exit
import time # for sleep
#-----------------------------------------------------------------------------

remote_ip = "192.168.55.109" # should match the instrument’s IP address
port = 5025 # the port number of the instrument service

#Port 5024 is valid for the following:
#SIGLENT SDS1202X-E, SDG1/2X Series, SDG6X Series
#SDM3055, SDM3045X, and SDM3065X
#
#Port 5025 is valid for the following:
#SIGLENT SVA1000X series, SSA3000X Series, and SPD3303X/XE

count = 0
def SocketConnect():
    try:
        #create an AF_INET, STREAM socket (TCP)
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    except socket.error:
        print ('Failed to create socket.')
        sys.exit();
    try:
        #Connect to remote server
        s.connect((remote_ip , port))
    except socket.error:
        print ('failed to connect to ip ' + remote_ip)
    return s
def SocketClose(Sock):
    #close the socket
    Sock.close()
    time.sleep(1)

def main():
    global remote_ip
    global port
    global count

    # Body: send the SCPI commands *IDN? 10 times and print the return message
    s = SocketConnect()
    for i in range(1):
        s.sendall(b'OUTPUT CH1,ON')
        #s.sendall(b'\n')
        time.sleep(5)
        s.sendall(b'OUTPUT CH1,OFF')
        #s.sendall(b'\n')
        time.sleep(5)
        print (str(count))
        count = count + 1
    SocketClose(s)
    print('Test complete. Exiting program')
    sys.exit

if __name__ == '__main__':
    proc = main()

The post Programming Example: Controlling an SPD power supply via Sockets over LAN appeared first on Siglent.

One method of quickly determining stability is to use a load step response.

In this test, a DC electronic load is used to provide a current load that steps from a low current draw to a higher value in a short period of time. By directly measuring the voltage and current output of the supply with the stepped load, we can visually observe the recovery of the power supply feedback loop and make changes to the design to optimize the response.

For this note, we are going to perform identical tests on two supplies and compare the output voltage and current waveforms: One has been tuned so that the output quickly recovers with minimal overshoot and ringing. The other supply is not tuned and subsequently oscillates. We will also discuss some measurement techniques to help get the right data as quickly as possible.

We also have a video to accompany this note:

Power Supply Design: Load Step Response with a SIGLENT DC Electronic Load

The Equipment:

• A DC Electronic Load: The SIGLENT SDL1020X-E is a 200 W load with dynamic testing capabilities to perform the load step. It also features remote sense capabilities to compensate for the voltage drop across the load leads. High currents can provide a substantial voltage drop across the leads and will add unwanted error.
• An oscilloscope: The SIGLENT SDS2354X Plus scope has a large display, easy-to-use interface, and features that make capturing these waveforms very easy.
• A power supply: The SIGLENT SPD1168X single output supply delivers power to our power supply board
• A current probe: The SIGLENT CP4070 features a 150 kHz bandwidth that will minimize most switching noise from the measurement
• Power supplies to test: The Analog Devices LTM4646 series of uModule Regulators. This module features two 10A DC-DC converters. One has been “detuned” to show some common problems associated with power supply design. The other supply has been left in it’s tuned state as a comparison to the detuned supply.

The Setup:

• Connect the SPD bench power supply to the power supply to test and configure the output values to match your supply needs. Here, we set the SPD for 12 V @ 3 A.

• Connect the SDL electronic DC load to the output of the power supply to test. Configure the load for Constant Current (CC), set the voltage and current ranges to the lowest ranges that still accommodate the requirements of the test, set the current load to a value near the maximum for your design. You may also wish to wire up and enable the SDL remote sense which enables remote voltage measurement to minimize the voltage drop caused by the high current flow through the electronic load leads. Here, we set the current to 5 A.

• Connect a passive probe to the oscilloscope CH1. This probe should be connected to the power supply feedback loop to monitor the voltage as the supply adjusts to the load.
• On the oscilloscope, configure CH1 for AC coupling to provide the most resolution to view the feedback voltage which can have high DC offsets. Enabling the Bandwidth Limit (BW limit) can also decrease noise. Here, the SDS2X Plus also has on-screen labels for traces, which can be a convenient way of keeping information organized. Here, I labeled CH1 Vout.

• Connect the current probe to the oscilloscope CH2.
• On the oscilloscope, set the trigger for Rising Edge, CH2 and AUTO. This will allow you to adjust the current probe zero position without dealing with the trigger setting.
• Configure CH2 as a current probe (Units = A), set the Probe attenuation to the proper value (50 mV/A in this case). DC coupling here because we want to see the total signal amplitude. I also applied a label to the output current (Iout).

• Zero the current probe. The CPs have a knob that you can use to move the DC offset. Set the scope to a low current range and adjust the probe to get 0 A on the display.

• Clip the current probe around the positive current lead going from the power supply under test to the DC load. Make sure to have the clamp connected such that positive current flow (into the load) produces a positive signal on the scope.

Now, everything is connected and ready to test:

Be on the lookout for interlopers and/or pesky critters wondering where the magic smoke came from:

DC Load Verification

Now, you can power on the SPD power supply and SDL load.

Make sure that the scope is set to AUTO trigger for now. You can also add an RMS measurement on CH2 so that you can verify the current draw matches the setting on the DC Load.

Here, we have a setting of 5 A on the DC load.. and we show 5 A RMS on the scope:

Things are looking good. The current output matches our load setting.

DC Load Step Response

Now, set the DC load to Dynamic Current mode by pressing Utility > CC.. and configure the appropriate ranges, low and high current values and duration, and slew rate for your application.

Here are the settings used for this test:

This will continuously cycle from 1 A for 5 ms to 5 A for 5 ms with 500 mA/us slew rate.

Now, switch the scope trigger mode to Normal and adjust the vertical, horizontal scales and positions.. as well as the trigger level to get a stable trigger and a few periods of transition on the display:

Verify that the supply high and low current values match the setpoints. For this example, we have 1 A for 5 ms and 5 A for 5 ms.. which is what we observe.

Observe and Optimize

Now, let’s compare a tuned setup to one that is not tuned for our load as well as some techniques to gather more information about the response.

First, you likely see quite a bit of noise on your signal. The majority of this is due to switching noise in the supply being tested. Here is a zoomed image of the feedback voltage where you can see the switching noise quite clearly.

Enabling waveform averaging can help:

Now, we see the output voltage from CH1 (yellow), output current from CH2 (pink/purple), and the average voltage math function (orange):

This is the tuned setup.

Now, let’s look at a detuned supply:

The scaling on these two images is exactly the same. You can see a large amount of ringing associated with the detuned supply. This design is very close to becoming an oscillator with this load. If our step duration was any shorter, the supply voltage wouldn’t be settled and our output would be very poorly regulated.

Here are some closer images of the rising and falling edges on shorter time scales:

Tuned, Rising:

Tuned, Falling:

Detuned, Rising:

Detuned, Falling:

Conclusions

A DC load step test can quickly show you the performance and stability of a power supply design. Using a few common pieces of test gear, you can ensure that your design is ready to undertake the most challenging application requirements.

The post Power Supply Design: Load Step Response with a SIGLENT DC Electronic Load appeared first on Siglent.

You can download the VI here: VISA_IDN.ZIP

In this example, the user can:

• Select the connected instruments from the VISA Resource List drop down menu:

NOTE: USB devices will automatically appear. For LAN connections, you will need to add the device. This is commonly done using NI Measurement and Automation Explorer (NI-MAX)

• Request the identification string once-per-press of the RUN button.

This sends the “*IDN?” identification query string to the instrument. The instrument then responds to the query with its identification string information. The identification string data will appear in the text box.

This code also uses the event structure connected to the value change of the RUN button to run once-and-only-once per keypress. This is a useful method of controlling code execution.

• Stop and exit upon pressing the STOP button

To run:

1. Connect instruments using a USB or LAN connection (see users manual for specific instrument details)
2. Power on instrument
3. Open LabVIEW and select the IDN.VI. This will open the VI front panel:

4. Select the instrument of interest from the VISA Resource drop down menu:

5. Press RUN on the LabVIEW VI menu strip to run the program:

6. Now, the “graph paper” background goes clear, indicating that the code is running. Now, you can press RUN in the VI Front Panel to execute the code:

The identification string should appear in the textbox:

7. Press STOP on the VI Front Panel to exit the code

The post Programming Example: Identification String (*IDN?) return with LabVIEW 2018 appeared first on Siglent.

Some products do not have locations for cable lock connections.

In this case, we recommend using a special glue or physical attachment system to secure the cable to the case of the instrument.

Here is an example:

https://www.kensington.com/p/products/security/lock-anchor-points-accessories/security-slot-adapter-kit-for-ultrabook/

The post Secure products without K-lock slots appeared first on Siglent.

The VXI bus and subsequent software drivers form a convenient software API that can make remote control of instrumentation over LAN quite simple. In fact, it forms the basis of the TCPIP communications used in LXI format that is being implemented across the industry.

For more info on VXI, you can check out the VXI Consortium

VXI has a small installation size and is quite flexible.. especially when compared to VISA based applications. VISA is convenient and does allow for easy bus changes (from GPIB to USB with just a few lines of code), but it is also a large installation that isn’t always easy to use on machines that are not running Windows.

VXI has many flavors.. and can be used with many OS’ and can be used on many instruments that do not have “open sockets” on their LAN connection.

Here is a list of SIGLENT products that have LAN but do not have open sockets:

SDS2000

SDS2000X

SDS1000X/X+

SPD3000X/XE

In this note, we are going to show how to use VXI-11 with Python to control an instrument. This can be used with traditional OS’ like Windows but offer even more when coupled with Linux variants like those running on Rasberry Pis and other single board computers (SBCs).

Configuration

First, you will need to download a few programs..

• Python: https://www.python.org/downloads/release/python-2714/

NOTE: This technique works with version 2.x and 3.x.. in this example, we will use Python 2.7.14 for Windows 64 bit OS’

• Python VXI-11: https://github.com/alexforencich/python-vxi11

Once downloaded, you can add VXI-11 to your Python instance..

1. Open the command line program in Windows. You can find it by searching for “CMD” or by going to the Start Menu >  Windows System > Command Prompt as shown here:

2. In another window, find the location of the Python VXI-11 folder that was downloaded previously and find the path for setup.py. In this case, the path on my PC is shown as:

Now, you can click on the “address” to open the exact path:

Here, I suggest opening Notepad and “copy-paste” the path. It will make the transfer easier:

3. Change the directory in the Command line program to match the path from step 2:

Type “cd <PATH>” as shown:

4. Now, the directory has changed to match the path. You can run the setup.py file by typing “python setup.py install” as shown:

5. Close the Command Prompt

Test the installation

Now that everything has been installed, let’s test the communications link.

1. Connect the instrument to the LAN of the controlling computer and power it on

2. Check the IP address for the product (see the User’s Guide of the specific product for more info), In this case, I am using an SDS2000X oscilloscope. Here is the IP address information:

3. Now, start the Python shell. There are a few ways to start this application. In this case, you can find the Python folder in the Windows start folder.

Open IDLE (A Python GUI):

Now, click Run > Python Shell to open the shell:

4. Now, import the VXI11 library by typing “import vxi11”

5. Now, we can assign the variable “instr” to the instrument as shown:

6. Now, we can use the VXI Ask command to send the identification string (*IDN?), request the response, and print it to the screen:

The VXI11 library features a number of functions to handle writing and reading strings and other formats. You can use this technique to establish communications and control the instrument efficiently.

Click here to download a Python file of this example: PythonVXI11_IDN

The post Programming Example: Using VXI11 (LXI) and Python for LAN control without sockets appeared first on Siglent.

This example scans and lists the available resources.

It requires PyVISA to be installed (see the PyVISA documentation for more information)

***

#Example that scans a computer for connected instruments that
#are compatible with the VISA communication protocol.
#
#The instrument VISA resource ID for each compatible instrument
#is then listed.
#
#
#Dependencies:
#Python 3.4 32 bit
#PyVisa 1.7
#
#Rev 1: 08302018 JC

import visa

def main():
    rm = visa.ResourceManager()
    print (rm.list_resources())

if __name__=='__main__':
    main()

*****

Here is the code:

And here is the result of a scan:

Each connected instrument returns a specific formatted string of characters called the VISA Resource ID.

The resource ID format is as follows:

‘Communication/Board Type (USB, GPIB, etc.)::Resource Information (Vendor ID, Product ID, Serial Number, IP address, etc..)::Resource Type’

In the response, each resource is separated by a comma. So, we have three resources listed in this example:

‘USB0::0x0483::0x7540::SPD3XGB4150080::INSTR’ – This is a power supply (SPD3X) connected via USB (USB0)

‘USB0::0xF4EC::0x1301::SVA1XEAX2R0073::INSTR’ – This is a vector network analyzer (SVA1X) connected via USB (USB0)

‘TCPIP0::192.168.55.122::inst0::INSTR’ – This is an instrument connected via LAN using a TCPIP connection at IP address 192.168.55.122

The post Programming Example: List connected VISA compatible resources using PyVISA appeared first on Siglent.

In this note, we are going to show how to use Python to create a communications link between an instrument and a remote computer using a LAN connection. Once the connection is verified, you can begin to work on the control software.

NOTE: This example requires open sockets on the instrumentation. At this time, not all SIGLENT products feature open sockets. Check the product page FAQs or with your local SIGLENT support office for more information.

Python is an interpreted programming language that lets you work quickly and is very portable. Python has a low-level networking module that provides access to the socket interface. Python scripts can be written for sockets to do a variety of test and measurements tasks.

Here is a Python 2.7 script that opens a socket, sends a query and closes the socket. It performs this operation in a loop 10 times:

PythonSocket_052018

You can follow the instructions below to build your own example:

1. Power on and connect the instrument to the network via LAN

2. Verify that the Gateway, Subnet Mask, and IP address of the instrument are valid for the network you wish to use. This information is typically located in the System Information or IO menu. See the specific instrument user’s guide for more information on LAN settings.

3. Download python and your favorite python editor (I use IDLE):

https://www.python.org/

https://docs.python.org/2/library/idle.html

Start your python editor:

5. Open a new file by pressing File > New File.. and name the file

6. Copy and paste the code at the end of this note into the file editing window:

7. Change the IP address and port number so that they match the IP address and port for the instrument you wish to connect to:

Save the file:

8. To Run, select Run and Run Module:

The post Programming Example: Open Socket LAN connection using Python appeared first on Siglent.

Luckily, there are a few solutions that can help. In this application note, we are going to discuss using open socket communication techniques using an open source communication tool called PuTTY with a SIGLENT SSA3032X Spectrum Analyzer.

What are open sockets and why use them?

Within the context of Ethernet/LAN connections, sockets are like mailboxes. If you want to deliver information to a specific place, you need to be sure that your information is delivered to the correct address.

In the context of test instrumentation, an open socket is a fixed address (or port number) on the Ethernet/LAN bus that is dedicated to process remote commands.

Open sockets allow remote computers to simply use existing raw Ethernet connections for communications without having to add additional libraries (VISA or similar) that require additional storage space and processing overhead.

Programs that utilize sockets for LAN communication tend to take up less memory and operate more quickly.

PuTTY

PuTTY is an open source software tool that provides a number of simple communication links (RAW, Telnet, SSSH, Serial, and others). It is available for free and there are a number of versions available for popular operating systems.

You can download as well as learn more here: http://www.putty.org/

In this example, we are using PuTTY to verify the raw LAN connection is working properly. It is quite a simple program that does not allow for very complex operation (sequences, converting data sets/strings, etc..). If you require more complex functionality, software platforms like Python, .NET, C#, LabVIEW, etc.. can be used to control the instrument using a similar open socket connection.

Configuration

In this test, we are using the most current revision of the SIGLENT SSA3032X Spectrum Analyzer firmware (Revision 01.02.08.02) which enables open socket communication.

This example also uses PuTTY version 0.67:

Steps

1. Install PuTTY for the OS you intend to use

2. Make sure your instrument and firmware revision can use open sockets

The SSA3032X revision 01.02.08.02 enables open socket communication.

To find the revision, press the System button > Sys Info.

Figure 1 below shows a sample system information screen from a SIGLENT SSA3000X analyzer:

Check the product page and firmware release notes for more information.

3. Connect the instrument to the local area using an Ethernet cable

4. Find the IP address for the instrument. This is typically located in the System Information menu. On the SIGLENT SSA3032X, press the System button on the front panel > Interface > LAN.

Figure 2 below shows a sample LAN setup page from a SIGLENT SSA3000X:

5. Open PuTTY

6. Select Raw as connection type

7. Enter the IP address in the Host Name field

8. Enter the port number. This should be provided in the users or programming guide for the instrument.

The SIGLENT SSA3000X Spectrum Analyzer uses port 5025.

Figure 3 below shows the PuTTY configuration for this example:

9. Press Open. This will open a terminal window as shown in below:

10. Using the computer keypad, enter *IDN? and press the Enter key on the keyboard to send the command.

This is the standard command string that is used to request the identification string from the instrument. As shown below, the instrument responds with the manufacture, product ID, Serial Number, and firmware revision.

Conclusion

PuTTY is an easy way to verify an operational LAN connection to instrumentation that can use open sockets.

The post Testing Open Socket Communications Using PuTTY appeared first on Siglent.