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.

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.

The idea is to minimize the risk of fire or explosion by physically eliminating any potential source of ignition.

Many IS circuits utilize special fusing and elements that are designed to dissipate the available power below certain temperature thresholds. During a fault condition, no component within the design can exceed this temperature rating.

Testing the performance of this type of design is quite simple: Load the circuit to pull the maximum rated power and measure the temperature of all of the circuit elements (heat sinks, packaging, resistors, etc..).

In practice, you could use a power resistor network with proper heat sinking for the load but a more convenient solution is to use an electronic load like the SIGLENT SDL1000X series.

The SDL1000X is available in 200 and 300 W versions and features a Constant Power (CP) operation mode as well as Constant Resistance (CR), Constant Voltage (CV), as well as user-defined limits to ensure safe operation within the application test requirements.

• Connect the Device-Under-Test (DUT)
• Select Constant Power (CP) Mode
• Set the current (I_range) and voltage (V_range) ranges for the test
• Set the Power you wish the load to sink
• Activate the load input

After the specified time limit for your test (see your device/environment specifics for details), you can measure the components/design temperature using a thermal camera or direct temperature measurements using thermocouples and DMM like SIGLENTs SDM3000X series. In fact, the SDM3055-SC and SDM3065X-SC products feature the ability to monitor temperature on up-to-twelve thermocouples to provide multi-point temperature readings from different points on your design.

Be sure to check heatsinks and components that are expected to dissipate the most power, but also other peripheral components and traces that may carry unexpected loads during a fault.

NOTE: In this picture, we show an open power supply with no shielding or case. For more accurate measurement, we recommend leaving as much of the original design (shielding/case/metalwork) in place to get the most representative measurement possible.

Figure 1: Example of temperature measurement of a power supply under load.

The post Testing Intrinsic Safety Barrier fusing and circuitry using an electronic load 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.

There are many options for people considering remote communication and control of test and measurement instrumentation. In most cases, a computer is used to communicate to test instrumentation using USB or LAN connections. The computer can configure the instruments, collect and organize data, and present it in a useful and flexible way.

Remote control provides:

• Increased repeatability: The instrumentation is set up the same way, every time.
• Efficient data collection: Data can be automatically filtered and stored.
• Easily configure the test system parameters: Each command is executed in the same order and in the same timeframe.
• Quickly visualize system performance: Graphical or tabular data formatting is easy.

There are numerous platforms (Windows, Linux, etc..) and software programs (LabVIEW, .NET, Python) available to build automated test systems. The right choice for your application is highly dependent on your needs and the available skills you have.

In this note, we are going to discuss how to use LXI Tools to communicate with SIGLENT instrumentation. LXI Tools is an open source software application that uses the local area network (LAN) connection to quickly control remote instrumentation. It is easy to install, has a small operating footprint, and is really powerful while being quite easy to use. Let’s start by looking at the basics.

You can also see the video version of this note here: http://siglentna.com/video/lxi-tools/

Why Open Source?

Open source coding is a community-based development style in which a group of contributors work together to build and maintain programs using shared code and components. In this way, a platform can be built and tested quickly and may cost significantly less than commercial programming environments. LXI Tools is free open source software and the project welcomes new contributors that would like to help improve the tools.

Here is a link to the LXI Tools website: https://lxi-tools.github.io

Why LXI Tools?

LXI-Tools is a collection of open source software tools that provide direct control of LXI compatible instruments such as modern oscilloscopes, power supplies, spectrum analyzers, and more.Simply install LXI Tools, connect your instrument, and start communicating.

It really is that easy.

LXI-Tools Provides:

• Quickly discover the available instruments on the LAN
• Retrieve copies of the displayed images (quickly see signals, data, and instrumentation setups) and convert image file types
• Benchmark LAN performance
• Send individual commands to an instrument to perform simple test actions. For example, you could return the measured data from a DMM.

To learn more about LXI-Tools, please see https://github.com/lxi-tools/lxi-tools

Instructions:

1. Install the appropriate version of LXI-Tools for your operating system

2. Open a terminal. In this example, I am using Ubuntu (17.10) running on a virtual machine hosted by a Win 10/64 bit OS.

To learn more about the virtual machine used in this example:https://www.virtualbox.org/

The OS is Ubuntu: https://www.ubuntu.com/

3. Once loaded, startup Linux:

With Ubuntu, you can use Snap to install:

$ snap install lxi-tools

LXI Discover:

Quickly searches the LAN for instruments and lists their identification string and IP address.

Plug in and power on your instrumentation and make sure that they are connected to a working LAN connection. You can manually check the instrument IP address and save this info to compare to later steps.

Open up a terminal window.  At the “$” prompt, simply type lxi discover… LXI tools will search the LAN for connected instruments.

Here, we have three devices connected: an SDM3065X, SSA3032X, and an SDS1102X-E (which has been superseded by the SDS1202X-E series here in North America). It also includes the instrument serial number, firmware revision, and IP address.

NOTE: This has been tested with a large number of instruments, but may not be supported by some. There is a list of compatible instruments at the end of this note or you can check LXI-Tools support for the latest list of supported products.

Screenshot:

This function retrieves a copy of the instrument display and saves it to the local drive. This is ideal for adding information to reports and sharing events with colleagues.

Type “lxi screenshot – – address <device address>”

NOTE: There should be two “-” with no spaces before “address” for every command.

Image Edits using ImageMagicks

Use ImageMagick^® to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats (over 200) including PNG, JPEG, JPEG-2000, GIF, TIFF, DPX, EXR, WebP, Postscript, PDF, and SVG. Use ImageMagick to resize, flip, mirror, rotate, distort, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.

For more information, visit… https://www.imagemagick.org/script/index.php

$ lxi screenshot –address <ip> – | convert – screenshot.jpg
$ lxi screenshot –address <ip> – | convert – screenshot.tiff
$ lxi screenshot –address <ip> – | convert – screenshot.bmp

Benchmark:

The benchmark command sends 100 requests via LAN and measures the average response time of the instrument. It can be used as a gauge for the health of the connection. Higher response rates = faster links.

$ lxi benchmark –address <ip>

Manual vs. Auto-load:

The commands can also be manually or auto-loaded:

Auto-load/detect:

$ lxi screenshot –address 10.0.0.42

Vs. manually specifying which screenshot plugin to use:

$ lxi screenshot –address 10.0.0.42 –plugin siglent-ssa3000x

The only advantage of manually specifying which plugin to use it that it is a bit faster because it does not go through the instrument auto detection steps (retrieve ID, parse regex rules to match correct plugin etc.).

Sending instrument specific commands:

You can also use the SCPI command to send any command to the instrument.

Note that if you have an SCPI command with spaces you must remember to send the specific command in quotes like so:

$ lxi scpi –address 192.168.55.113 “MEAS:VOLT? CH1”

This way the tool knows how to parse the full SCPI string.

In this example, we send the “READ?” command to an SDM and return a reading:

GUI

Another really great feature is the GUI for LXI Tools. This allows you easy access to discovery of instruments on the network as well as some powerful tools for data capture and instrument control.

$ lxi-tools.lxi-gui

This adds a very simple yet powerful graphical interface for the LXI tools program:

NOTE: Ignore the “Qt” error shown.

This opens a clean control window:

• Search: Discover the instruments connected to the LAN. Here, we have three instruments connected:

• SCPI command line: Send instrument specific commands. Click on the instrument you wish to communicate with and then enter the command. For queries (commands that require an instrument response, or read function), the returned string will be shown in the text box:

NOTE: The specific commands that can be used are available in the instrument programming guide. Check out the specific instrument documentation for more details.

This tool can be helpful when trying out specific sequences of commands. You can send them one-at-a-time and then observe the instrument functionality.

• Screenshot:  Capture and save an image from the instrument. This also features a “live” button that will continuously poll the instrument.

After saving, you can recall the image:

• Benchmark:  Checks the performance of the LAN  connection by sending a series of commands and measuring the response time. Larger “requests/second” = greater possible bus performance.

• Data Recorder:  Sends the user-defined command a number of times/second and attempts to graph the data. Be aware that data can be returned in different formats and at different rates depending on device configuration. Going faster can make the system unstable and could cause a crash or hang-up.

And the data: 

• Settings: Configure the timeouts and other controls.

• About:  Version info.

*Here is a list of the latest compatible instruments tested with Lxi-Tools (03/13/2018)

SSA3000X Series:

SSA3000X (Latest 1.2.8.5a)

SDS1000X-E Series:

SDS1202X-E (Older 5.1.3.8R2)

SDS1202X-E (Latest 5.1.3.13)

SDS1204X-E (Latest/first production release 7.6.1.12)

SDS1000X/X+ Series:

SDS1202X+ (Latest 1.1.2.15E3)*

*LIMITED COMMAND SET AVAILABILITY

SDS2000X Series:

SDS2304X (Older 1.2.2.2)*

SDS2304X (Latest 1.2.2.2R10)*

*LIMITED COMMAND SET AVAILABILITY

SDS2000 Series (replaced by the SDS2000X):

SDS2204 (Latest 1.2.2.2)*

*LIMITED COMMAND SET AVAILABILITY

SDM3000 Series:

SDM3045X (Older rev 5.01.01.01)

SDM3045X (Latest rev 5.01.01.03)

SDM3055 (Latest rev 1.01.01.01.19)

SDM3065X (Older rev 3.01.01.02)

SDM3065X (Latest rev 3.01.01.03)

SDG1/2/6X Series:

SDG1032X (Latest 1.01.01.22R5)

SDG20122X (2.01.01.23R7)

SDG6052X (Latest 6.01.01.28R1): 405.3

The post Quick remote computer control using LXI Tools 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.

This process normally goes quite smoothly, but if there are problems, there are some basic troubleshooting steps that can help get your test up-and-running quickly.

In this note, we are going to show how to use Telnet to test the communications connection between an instrument and a remote computer using a LAN connection to ensure that it is working properly. Once the connection is verified, you can begin to work on the control software.

Telnet provides a means of communicating over a LAN connection. The Telnet client, run on a LAN connected computer, will create a login session on the instrument.

NOTE: The Telnet connection 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.

A connection, established between the computer and instrument, generates a user interface display screen with SCPI> prompts on the command line.

Using the Telnet protocol to send commands to the instrument is similar to communicating with USB. You establish a connection with the instrument and then send or receive information using SCPI commands. Communication is interactive: one command at a time.

The Windows operating systems use a command prompt style interface for the Telnet client.

STEPS

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. On the computer, click Start > All Programs > Accessories > Command Prompt.

4. At the command prompt, type in telnet.

5. Press the Enter key. The Telnet display screen will be displayed.

6. At the Telnet command line, type: open XXX.XXX.XXX.XXX 5024 where XXX.XXX.XXX.XXX is the instrument’s IP address and 5024 is the port. You should see a response similar to the following:

7. Now, you can enter any valid command for the specific instrument that you are controlling. See the specific programming guide for the instrument for more information.

This is especially helpful when you are planning a specific test sequence, the effect of delays/timing, or troubleshooting a command. You can send each command one-at-a-time and check the performance of the instrument.

*IDN? is a common identification string query (question or information request) that returns the information from the connected instrument

The post Verification of a LAN connection using Telnet appeared first on Siglent.