Capturing data with an oscilloscope is straightforward but once you have the data it can be pretty tricky to dig into. That’s where GradientOne’s web interface can help! With the aid of the data visualization tool D3, and the power of web browsers, we enable you to easily recall saved results and explore what you have captured. In this blog post we will take a closer look at a few of the features available, how they work, and how they can help you make the most of your data. We'll also provide you with example code that can be used as a reference. Let’s start by loading a saved result from the Results Library, in this example we will be looking at a result from a Rigol DS1054Z oscilloscope.
First let’s take a look at the Tooltip. It’s easy to use, simply move your cursor across the plot window and the Tooltip will snap to the closest data point, giving you a quick look at the x, y values of your plot. It works by calculating the nearest data point to your cursor location and displaying its value. Take a look at the code snippet below for details.
Now that we have something to look at lets explore a bit using the Zoom feature. Using the left hand menu select ‘Zoom’, once activated this feature allows you to use your cursor to draw a rectangle around the part of the waveform you want a closer look at. It’s really that simple. This feature works by taking the dimensions of the rectangle dawn on the plot and calculating a new plot scale. The scale feature in D3 makes it easy to convert from pixel dimensions to plot scale. Take a look at the code snippet to see how it’s done.
GradientOne’s Overlay feature is a great way to compare two sets of data and identify discrepancies. Start by selecting two or more results of interest from your library then click ‘Overlay Results’ at the bottom left of your screen. When the page loads the first two results will automatically be overlaid on top of one another. Use the thumbnails at the top of the screen to select different results for overlay. Some of the more advanced features are disabled while using Overlay, however the Tooltip and Zoom are still available to use at your convenience. In order for Overlay to work the selected results must be compatible, i.e. have channels and y_values in the data. Once the data is gathered and compatibility is established, it’s just a matter of combining the channels and scaling the plot appropriately. Check out the code snippet for details.
Example Code: Tooltip
Example Code: Zoom
Example Code: Overlay
GradientOne's approach to test automation provides a simple way to implement a global test solution for your organization. One of the key design tenets enabling this capability is an API-First philosophy. This provides a simple and consistent interface to our instrument/DUT programming, data acquisition, waveform visualization, and analytical features.
This also helps customers use existing scripts and test programs they are currently using to test hardware, while also using GradientOne for data acquisition, search capabilities, and analysis. This post will provide an example of how to use the open source SCPI Runner provided by GradientOne to control multiple instruments, while storing the results on GradientOne's platform. Though this example uses the SCPI Runner which is written in Python, customers can use their own scripts, written in any language, to achieve the same results.
1) Setup: The function generator on the Tek MDO3012 is connected to Channel 4 on the RIGOL DS1054Z.
2. Script outline: This script will configure a Rigol 1054Z oscilloscope to trigger and acquire a signal on channel 4. The signal is a sine wave created by a Tektronix MDO3012 Function Generator. A few details about the script:
3. Run the script:
4. View the results: When the script runs, it provides the user with links to the screenshots and waveforms that are stored on the GradientOne cloud:
2019-08-20 11:45:06 :: [ INFO ] You can view the result at: https://gradientone-acme.appspot.com/results/R6154227045793447
2019-08-20 11:45:12 :: [ INFO ] You can view the result at: https://gradientone-acme.appspot.com/results/R9283269107066087
This is just one example of how to combine the use of your existing test automation scripts with GradientOne's cloud platform for storing results, collaboration, and visualization. Documentation is available here if you'd like to learn more about the analytical features that can be used for test results that are stored on GradientOne's servers.
If you are interested in seeing how your own scripts might work with GradientOne's cloud platform, click below to get started for your free trial.
GradientOne supports rich interactions between instruments and cloud databases. These include industry standard protocols such as SCPI, VISA, and VXI11. Data derived from the frequency of instrument's interaction with the database as well as information in the embedded operating system support a range of utilization estimates. This utilization data is presented to the user with automated reporting using bar graphs, pie charts, and other trend data. For the cases where customers have custom applications they need to use in conjunction with utilization data, GradientOne provides users with an API or downloadable CSVs to get access to data in its more raw form. This blog post will walk you through how to use the API to run custom queries for utilization data and generate CSV and JSON files containing the data.
Step 1: Download Configuration File
First, download your configuration file. The configuration file manages the authentication and access details to perform queries.
The name of the file must be: "GradientOneConfig.txt"
The file includes the following:
Step 2: Download the sample API script
The GradientOne API offers a wide range of capabilities for uploading and downloading instrument usage data. We've generated an example program written in Python you can execute.
Step 3: Run the API query
For this example, I will run a query against https://examples.gradientone.com to obtain a days worth of utilization data for an oscilloscope in the GradientOne lab. Its asset_id is GradientOne_Keysight_600MHZ.
The time arguments are in UTC. You will need to adjust accordingly for your time zone. I am running this program from the Pacific time zone, so a full day would be from 07:00 to 07:00.
The query requires these arguments:
asset_id -- the unique identifier string of the asset of interest (GradientOne_Keysight_600MHZ)
start_date -- start date of the query (2019-07-17)
start_time -- start time of the query (07:00)
end_date -- end date of the query (2019-07-18)
end_time -- end time of the query (07:00)
mode -- query GradientOne API for minute or hourly summaries (hours or minutes)
> python utilizationInfo.py GradientOne_Keysight_600MHZ 2019-07-17 07:00 2019-07-18 07:00 hours
The Response  means that the query was completed successfully. The data are available in the JSON and CSV files:
This returns 24 hours worth of data. Below is an example hour, which would be available in the .json file. Interesting takeaways are:
This script also generates a CSV file. This shows the average CPU for a given hour and how many minutes the instrument was online during that hour. It contains the below information:
Example CSV file
Example Python Script
If you'd like to see how this works in your environment, start your free trial today by clicking on the below link.
Building a test lab for an engineering team is easily a million dollar investment. Test equipment, chambers, networking gear, and PCs are 'must-have' assets that test engineers use to successfully do their job, yet oftentimes finance teams have limited visibility into their actual usage and status for reporting purposes. We've recently published an application note that describes how customers can use GradientOne's utilization reports to help provide both engineering leadership and the finance team with information they need to better optimize existing investments in lab gear, as well as improve budgetary planning for future equipment acquisitions.
Learn how to join data from GradientOne's utilization reports and a company's fixed asset register to help finance and engineering teams take specific actions that improve productivity and save money.
Read this application note to view:
Today we are releasing the first version of our SCPI command application. This is the first of several releases that delivers a Python based, multi-instrument, "hardened" software application that can be used for simple bench testing as well as more sophisticated design validation. There are many examples of Python scripts that are freely available for specific instrument use cases, but when building solutions for our customers we haven't come across many general purpose frameworks that allow for resiliency, failure recovery, logging, and multi-instrument control. We've designed this from the ground up with many of those capabilities included.
Read below for more on how it works.
First, you'll need to make sure you have the below software packages installed:
The scpi_runner.py reads a scpi_script file to open a connection with an instrument and send commands. The commands and their responses are logged to a log file. A sample script is provided in scpi_script.sample for you to modify as needed.
We've added features in the program to make it more "hardened". These include resiliency features for exception handling and other errors that can be caught without crashing the application.
The scpi_runner will time out commands and scripts that take too long to run. The command timeouts will raise an exception and run the next command. If the whole script times out then an exception is raised and the remaining commands are not run. These timeouts can be modified by editing the values set in settings.py
GradientOne Script Logic
The scpi_runner.py supports basic loops and sleeps (delays). The syntax for the GradienOne ScriptLogic objects is not case-sensitive, so G1:StartLoop and g1:startloop are equivalent.
To start a block of commands to loop, a StartLoop command is needed.
The Max is required, otherwise the block of commands will only run once. The BreakOn is optional. The string G1:StartLoop:Max=3 will start a loop that runs 3 times. You then enter as many commands as needed in the next lines and end the block of code to loop with a line with G1:EndLoop
Will run the *IDN? command 3 times.
To add a delay to your script in between commands, use a G1:Sleep.
For example, to sleep 2 seconds:
This calls python's time.sleep() function to delay running the next line. This can also be used within a loop.
Example SCPI Script
1. Establish a connection to the instrument: The above script opens a connection to the instrument using the IP address of 192.168.1.238, which can be found on most instruments network/LAN settings.
2. The next several lines include the SCPI commands *IDN?, *RST, and :SAVE:IMAGE D:\screenshot.png. These commands will obtain basic instrument information, reset the devoce, and download the screenshot to onboard instrument storage.
3. The next two commands are GradientOne specific commands for inserting a sleep and a loop. These are followed by a SYST:ERR? which checks to see if there is an error.
4. The last line is another GradientOne specific command signifying the end of the loop.
See below for the example in action:
Below is an example of the logging:
Stay tuned...more advanced features to come.
GradientOne's test automation can be used to remotely control multiple instruments over the web. In this video we demonstrate how that is done, along with the instrument screenshots and waveforms that are acquired.
1) Setup: The function generator on the Tek MDO3012 is connected to Channel 4 on the RIGOL DS1054Z.
2) Instrument Programming: The RIGOL needs to be programmed to enable channel 4, set the trigger, and the horizontal scale. The Tektronix needs to have the function generator enabled.
In this example two types of commands are used:
i. A previously stored test recipe of SCPI commands are used to program the test setup. An example is shown below.
ii. Abstracted commands for common test routines such as saving the screenshot and waveform.
RIGOL DS1054Z Setup
3) Data Acquisition: The data that is acquired from the test setup includes the raw waveform (times and voltages) as well as the screenshot of the oscilloscope and the current instrument settings. This gives engineers the ability to post-process the data, compare it to other results, and collaborate with their teammates.
Have you ever needed to compare a saved waveform to another waveform? Historically you may have needed to save a waveform on your oscilloscope, then load it on the same screen as a different waveform that you captured. GradientOne offers a new way to do this using your web browser.
GradientOne automatically stores waveforms and metadata when tests are run. So in addition to things like screenshots, test setups, and measurements, the raw waveform data, including times and voltages is stored.
While storing the screenshot gives the ability to view what the oscilloscope captured, storing the waveform data itself provides the ability to perform various measurements and analyses, including overlays.
In the video below, we show how you can compare waveforms using the overlay feature, use cursors (some engineers refer to these as rulers) to perform custom measurements, and use the integrated collaboration features to review with your teammates.
If you are interested in seeing for yourself, give the 14 day free trial a try, it is the best way to get familiar with some of the capabilities of the product.
Automation in test & measurement equipment unlocks many benefits across the entire industry, from scientific research, to R&D, to Manufacturing, and customer support. Industry standardization drove broad adoption of common command language of SCPI (Standard Commands for Programmable Instruments), that has formed the basis for controlling instruments, and building drivers and test system applications.
GradientOne offers a new approach for multi-instrument support for engineers to connect their devices to the web and send SCPI commands via any web browser for remote programming and control. The ability to pass SCPI commands in conjunction with a GradientOne’s mix of pre packaged test routines for capturing waveforms, screenshots, and instrument setups unlocks new capabilities for remote control as well as troubleshooting/debugging test rigs, bench setups, and more.
Getting set up is pretty easy. No need to program drivers, deal with VISA, etc. GradientOne takes care of this for you. Simply connect your instrument to the same network as your computer. Then download a configuration file that registers your setup with the GradientOne cloud. Then install the GradientOne agent.
In the video below you can see a quick demo of how you can easily send SCPI commands to control an instrument for troubleshooting, while also sending test routines to view screenshots, acquire data, and more.
We've set up an oscilloscope you can remotely control to try for yourself. To send a SCPI command try the following:
1) Click on the button below
2) Select "SCPI" from the drop down menu (chevron) on the upper right next to Get Data.
3) Enter a name for this configuration in the "Enter Config Name" field
4) Below that select "Ask" from the drop down menu
5) Enter "*IDN?" in the "Enter SCPI Command" field
6) Click "Get Data" and you should see the results of the oscilloscope processing the *IDN? command.
With GradientOne you can decode serial bus signals. We've set up an example customer instance that gives you the ability to take it for a test drive and see for yourself. You can reach this demo by going to the home page: www.gradientone.com, and then clicking on the image underneath "Acquire An I2C Signal". It will take you here.
In this setup, the RIGOL DS1054Z oscilloscope is connected to a demo board (see above), with Channel 1 to an I2C clock, and Channel 2 to I2C data (Channel 3 is connected to a UART signal). If you click "Get Data" you will initiate the GradientOne feature set that configures the RIGOL oscilloscope to capture the I2C waveform, screenshot, and instrument settings/metadata. Then you can click 'Decode', 'I2C', then 'Run Decode' to get the decoded waveform.
The initial capture will look like this:
GradientOne also offers the ability to zoom in for close inspection of the waveform. Below you see the zoom, as well as the tool-tip feature that will easily tell you the X-Y values of time = 2.47 msec and voltage = 3.38 volts.
You can also upload a CSV file of an I2C waveform and decode that as well.
The first thing you need to do is capture the waveform and upload it to GradientOne. There are two ways to do this:
Next, select the type of decode you want to do and configure it. GradientOne currently offers decode for I2C (7 or 10 bit addressing) and UART. The waveform is then decoded, the plot annotated, and a decode table presented to the user.
Once the signal is decoded a full range of search capabilities is available to you. Perhaps you wanted to find 'Start', 'Stop', 'Nack/missing acknowledge' bits, you could enter those text and find it on the signal. That is relatively trivial.
You can also search for multiple byte patterns. If you had a decoded signal and wanted to look for a specific pattern that is unique to your data stream, you can construct that search term and GradientOne would identify that byte sequence in your signal. E.g. If want to look for 0x474F as a search term, it finds all cases where 0x47 then 0x4F occurred chronologically/sequentially.
Demonstration Video For Waveform Upload and Decode
If you are interested in learning more, check out our white papers on Protocol Decode and Instrument Automation. Start decoding your signals using the web today with a free trial of GradientOne.
Debugging glitches is a common task for engineers. Modern oscilloscopes have good tools for triggering on a glitch, but what happens next can be cumbersome, time consuming. We'll show you how GradientOne's automated measurements simplifies the process, turning a multi-hour exercise into an exercise that takes a few minutes.
Oops You Detect A Glitch
The first thing to do when you detect a glitch is try to acquire the signal for further analysis. This can be done by setting up your scope with the appropriate trigger (glitch, runt, etc). Now that you have the signal captured, what do you do with it? Next steps typically include analyzing the signal further, performing some measurements, involving other members of your team for debug. This might entail:
There are ways to do these tasks using features on the scope, writing a software script, or a bit of both.
But they take time and programming expertise.
The GradientOne approach to test and measurement automation was designed to address all of those steps each time a test is run.
In this case, the you can still configure your oscilloscope manually, or you can configure it over the web. Once it is setup, you click the run button from the GradientOne web interface, and the test is run, automating steps 1-6, and providing a range of tools for post-acquisition analysis.
Demo of Automated Acquisition:
After the data is stored, you can easily use the the mouse and the GradientOne cursor feature to perform arithmetic calculations such as measuring the peak amplitude of the glitch. In the example below, the glitch is approximately 0.89 Volts.
The time savings for automating simple tasks is impactful on an individual level and transformative on an organization wide level. Compressing tasks that take an hour or two to a few minutes, several dozen times, during the course of a project, for a team of engineers, may mean the difference between shipping early, on time, or late. Automation with a cloud approach as the backbone can help make this happen.