GradientOne
  • Home
  • Solutions
    • Overview
    • Test Engineering
    • Compliance Labs
    • Product Features
    • Supported Instruments
  • Documentation
    • White Papers
    • Getting Started
    • Quality Analysis of Test Data
    • Rigol Automation
    • Waveform Upload
    • Visualization & Measurements
    • News
    • Case Study
  • Try For Free
  • Pricing
    • Buy Now
    • Pilot
  • RIGOL
  • Blog

Blog

Simple-SCPI:  The Easiest Open Source Tool For Instrument Programming

4/19/2020

0 Comments

 
SCPI is a programming language for controlling instrumentation using a computer.  It consists of ASCII characters, sent over Ethernet, USB, GPIB, RS232. Many test equipment vendors offer libraries and tools for their equipment. Serving as the bedrock of test engineering, it’s reach spans the engineer’s test bench to the manufacturing production line, with broad support across the test equipment vendor community.

However, the S in SCPI stands for "Standard", not "Simple".  Using it in conjunction with contemporary computer science fundamentals such as conditional statements, loops, and comparisons, with appropriate logging, error handling, and resiliency, requires a solid foundation in both software programming and the specifics of the hardware you are using in your test. 

We’ve recently introduced an open source, Python based, multi-instrument, "hardened" software application, called Simple-SCPI, that can be used for simple bench testing as well as more sophisticated design validation. While there are many examples of Python scripts that are freely available for specific instrument use cases, none of them were good solutions with failure recovery, logging, and multi-instrument control.  We've designed ours from the ground up with those capabilities included to provide an extensible and resilient tool for users.

How it works:

Getting started is easy.  It requires downloading and installing free software packages, via our instructions on Github.

Once installed, the user creates a configuration file for instrument control.  It contains addressing details (e.g. TCP/IP address resource string) and any additional SCPI related commands and control features.   

Then all the user needs to do is execute the scpi_runner.py program and it reads the configuration file and processes the SCPI commands accordingly.  The basic steps for getting started are available at the Github repository.  In this blog post, there are more detailed examples for various use cases that may prove helpful, ranging from simple, to more advanced.

Examples:


These examples use a Rigol oscilloscope connected via an ethernet cable to a Windows laptop.  This example would apply to any instrument that supports SCPI, though some of the SCPI related commands may vary.
​

#1:  Perform *IDN? query 
A common SCPI command in test plans includes using the *IDN? query to collect instrument specific metadata such as manufacturer and model number, serial number, firmware version, etc.  To do that, using simple-scpi, create a configuration file that includes the address of the instrument, and then the command for obtaining instrument info (*IDN?). 
Configuration File

    
The below log output shows the output into the terminal after running the scpi runner application.  It shows the instrument being initialized, the script construction, and then the response to the SCPI commands.  The response to the *IDN? is:   RIGOL TECHNOLOGIES,DS2202A,DS2D180100040,00.03.05.SP1
Log Output

    
#2 Take voltage measurements in 1 second intervals for 5 seconds using GradientOne commands
Now imagine you wanted to take waveform measurements in 1 second intervals.  The command is:  
:MEASure:VAMP?.  Additionally, in this case, you also wanted to do this over a 5 second period. We've also added a host of GradientOne specific commands.  In this case, to add a delay to your script in between commands, use a GradientOne provided command that inserts a user specified delay G1:Sleep(<NumberOfSeconds>) .  To simplify and minimize errors we've also provided loop commands G1:StartLoop:Max=<NumberOfTimes>.  In this example we will have a 1 second sleep and will perform the loop 5 times.  More details of the GradientOne specific commands are available in the Github repository.  
Configuration File

    
See below for the log output which includes the voltage measurements, in 1 second intervals.
Log Output

    
#3:  Save a screenshot of the Rigol DS2202A

Saving the screenshot of the instrument is a common task.  For many instruments there may be multiple SCPI commands and other data manipulation required to get the screenshot saved.  We've designed in a framework to allow for abstracted, common sets of SCPI commands such as fetching a screenshot, to be reduced to a one line entry in your configuration file.  In this case, you can use the GradientOne specific command:  G1:FetchScreenshot.  In a future blog post, we will walk through how to add a new instrument that supports this type of command.
Configuration File

    
Log Output

    
Below is the screenshot that was saved:
Picture
#4 Save the waveform of the Rigol DS2202A

Similar to saving the screenshot, saving a waveform is also a multi sequence set of SCPI commands with post processing of the data.  We have also streamlined this set of commands to the GradientOne specific command:  G1:FetchWaveform.  


Configuration File

    
Log Output

    
Waveform JSON Excerpt

    
Summary

Simple-SCPI provides a quick, easy to use, free tool for a variety of test automation use cases, from the hobbyist to the compliance lab.  It is also possible to use it in conjunction with the GradientOne service that automatically archives and plots your waveforms and screenshots.  In the next blog post we will show you how that works.  If you're interested in learning more about his, feel free to reach out and we can help you get started.
Contact Us
0 Comments

Run Your Test Lab From Home (Part 1)

4/6/2020

0 Comments

 
Current events highlight the need for enabling efficient and effective remote work environments around the world.  The impact on test engineers and lab managers is particularly acute due to the needs of accessing equipment and instrumentation in a lab.  If lab access is restricted, how can teams minimize the impact to product development while maintaining high levels of quality and test coverage?  This post will highlight different ways GradientOne can help support remote instrument control and collaboration via automatic waveform upload when lab access may be limited.  

Remote Instrument Control


With lab access potentially limited the test engineering function will be impacted by challenging access to instruments, developing test plans, and accessing/viewing test data in a collaborative approach.  Some tools such as VPNs and Remote Desktop Software have historically been used to address some of these issues, but they come with various limitations.  GradientOne’s approach is purpose built from the ground up to leverage contemporary technologies to enable instruments without the need of any software installed on the computer trying to access the instrument.  Regardless of whether it is a laptop, desktop, tablet, or smartphone, a user can securely log into a portal via a web browser, select an instrument to use, and then configure the device and execute tests.  
Below are example use cases of how an engineer might use GradientOne to control instruments and run tests remotely:
Acquire an I2C signal using an oscilloscope:
  1. An engineer would log into the GradientOne portal set up for their organization and then navigate to the view for their lab and select the appropriate instrument to run the test.  In this example, the lab shown in the GradientOne lab in Northern California that has a Tektronix MDO3012 along with a Rigol 1054z oscilloscope online.
  2. The engineer could select an instrument for programming, or in this case load a previously existing test setup from the Test Setup Library.  GradientOne offers a search feature to find the correct test setup for I2C Capture.
  3. The engineer runs the test and captures the full I2C waveform, including screenshot, times/voltages, and instrument settings related metadata.
​
Picture
View Available Online Instruments
Picture
Load Test Setup
Picture
Capture Waveform

SCPI programming to control multiple devices

  1. An engineer can send SCPI commands to any SCPI compatible device over Ethernet, USB, etc to develop and execute multi-device tests.
  2. This example shows how a user can use the GradientOne SCPI programming interface to configure a signal from the Tektronix Function Generator and send signals to the Rigol Oscilloscope.  ​
Picture
SCPI Programming Interface
 Test Automation Demo Video
Automatic Upload of Test Results
Another common challenge in remote environments is accessing the test results and archiving them for review, report generation, and collaboration.  
Our approach provides an automatic upload capability of every bit of relevant information from the test and index and archive it in the secure GradientOne cloud or a local server in the customer environment for users to access at any point in the future:
  • Waveform - all of the x,y values of the acquired data 
  • Screenshot - the screenshot of the instrument display
  • Measurements - any of the measurements parameters that are calculated by the device 
  • Instrument setup - the setup run for the test is stored for auditing and re-use
  • Metadata - any relevant metadata such as date time, lab location, serial number, firmware version, and other information specified by the user can be stored along with the test result.
Picture
Interactive Waveform & Screenshot
Picture
Measurements & Metadata
Enabling remote lab operations historically has required home grown solutions or technology designed for a different purpose, shoehorned into the lab environment.  In our next post we'll describe how we can help make data driven decisions around instrument asset utilization to optimize budgeting and lab allocations to meet your current operating environment.  We've developed an approach from the ground up, to address these issues in a way to simplify and streamline remote or local work flows.  We offer this to customers directly or via consulting services.  If you'd like to learn more click below to let us know how we can help.  
Request Free Consultation
0 Comments

A New Approach To Instrument Automation:  Unlocking Lean Hardware Testing Using A Plug and Play Solution To Automating Test Equipment

9/20/2019

0 Comments

 
With every new technology inflection point, Test Engineering teams have embraced these benefits to  accelerate time to market, reduce costs, and build higher quality products.  Internet technologies, powered by the web browser and cloud computing ushered a new opportunity for organizations to further advance the productivity of the test engineering function while unlocking new capabilities associated with test data analytics and collaboration.  

GradientOne provides a new approach to simplify the adoption of web technologies in test engineering by giving customers a 'Plug and Play' solution to programming instruments using SCPI in three simple steps.  
  1. Connect your instrument an internet-enabled computer (or the internet directly).
  2. Install GradientOne's gateway software on the computer (or the instrument).
  3. Open a web browser from anywhere, on any computer, and start using GradientOne's web app to write SCPI routines, automate instruments, and upload, index, and archive the results for long term storage.
Picture
The dividends this approach pays for customers compounds over several dimensions:
  • Elimination of ongoing maintenance and development of a global test engineering solution.  Test engineers can focus on higher-value elements of their test development and interpretation of results, instead of building the "plumbing" of their test lab infrastructure.
  • Simplified remote operation of instruments and test execution.  Whether it is operating RF chambers, running a battery of post-silicon validation tests remotely, or managing a production line, developing tests, scheduling instrument use, and viewing the results can all be done via a web browser from anywhere.
  • Store and reuse test routines and libraries from the cloud.  Reproducibility and traceability are critical to ensuring quality.  GradientOne provides an easy way to automate the use of previously developed tests, incorporate revision control, link test results to specific test plans, etc.
  • Improve quality with expanded analytical capabilities.  GradientOne offers customers the ability to analyze their test data using a variety of tools.  The near-infinite compute and storage of the cloud, coupled with standard functionality available in web browsers dramatically simplifies the steps needed for engineers to apply data analytics to gain insights into their product history and test results.

Whereas before, customers had to develop their own abstraction layers, API libraries, databases, and user interface/visualization tools, GradientOne has already taken care of this.  

Simply download the client software, open a web browser, and start running tests.  

You can try it here at our free customer facing demonstration site:  https://examples.gradientone.com

If you want to see how it works in your own lab, get started with a 14 day free trial.

​
Start Free Trial Today
0 Comments

Unlocking Insights Into Oscilloscope Waveforms Using GradientOne's UI

8/23/2019

0 Comments

 
       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.

TOOLTIP:
       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.
ZOOM:
​       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.
Overlay:
       
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

    
0 Comments

Simple SCPI Part 2:  Automated Testing Using Python & GradientOne

8/20/2019

0 Comments

 
 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.  
Picture
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:
  • identity string (e.g. TCPIP::192.168.5.2)  : provides the addressing for the instruments
  • SCPI commands (e.g. :CHANnel1:DISPlay Off):  instructions for the instruments
  • GradientOne provides abstracted commands for commonly used instrument features such as acquiring screenshots, waveforms, etc.  This is so users don't need to research the instrument specific commands for a variety of instruments.  These commands start with a 'G1', see below for more detail:
    • G1:FetchScreenshot: acquires the screenshot of the specific instrument and stores it to the computer running the script
    • G1:PostScreenshot: uploads the screenshot to the GradientOne cloud
    • G1:FetchWaveform: acquires the waveform and stores it to the computer running the script
    • G1:PostWaveform:  uploads the waveform to the GradientOne cloud
​
Example Script

    
3.  Run the script:  
Terminal output

    
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:

​Screenshot:  
2019-08-20 11:45:06 :: [ INFO ] You can view the result at: https://gradientone-acme.appspot.com/results/R6154227045793447
Picture
Waveform:
2019-08-20 11:45:12 :: [ INFO ] You can view the result at: https://gradientone-acme.appspot.com/results/R9283269107066087
Picture
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.
Start Your Free Trial Today
0 Comments

Using Python To Query The GradientOne API For Equipment Utilization

8/7/2019

0 Comments

 
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:
  • DOMAINNAME - this is the URL you are accessing via the API.
  • AUTH_TOKEN - this is the authentication string that allows access to the data.  To get your authentication token, visit your account page.  You can find this on  your dashboard url with /account  (example: https://examples.gradientone.com/account).  Click on Auth Info > Download Config.  Save the file in the location where you will be running the script.
Picture
Example GradientOneAuthConfig.txt

    
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
<Response [200]>

The Response [200] means that the query was completed successfully.  The data are available in the JSON and CSV files:

GradientOne_Keysight_600MHZ_avg_CPU.json
GradientOne_Keysight_600MHZ_avg_CPU.csv

This returns 24 hours worth of data.  Below is an example hour, which would be available in the .json file.  Interesting takeaways are:
  • utilization:  This instrument has an 85% utilization for this hour.  The default utilization uses historically defined baselines for CPU behavior that indicates usage above a certain threshold.  The CPU is the CPU usage of the test applications using this instrument.  The 85% utilization in this case is  determined by the minutes_active = 51 minutes divided by 60 minutes.
  • minutes_online:  This instrument was online for the entire hour (minutes_online = 60).
  • The remaining time, the instrument was idle (minutes_idle = 9).
  • ​The average CPU % for this hour was 43.5%.  This may be helpful for profiling different test routine behavior.
Example hour:

    
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.  
Start Free Trial
0 Comments

Provide Finance Team With Insight Into Engineering Asset Utilization

7/29/2019

0 Comments

 
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:
  • Example SQL commands to join two CSVs
  • Sample Python script
  • Sample insights for productivity and financial reporting​
Picture
0 Comments

Simple SCPI:  An Easy To Use SCPI Command Runner For Test Automation

6/25/2019

0 Comments

 
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.

Requirements
First, you'll need to make sure you have the below software packages installed:
  • Python:  download python
  • Python VXI11:  Python VXI11 provides a pure python TCP/IP driver for LAN based instruments that support the VXI11 protocol. This includes most LXI instruments.  GitHub repository: https://github.com/python-ivi/python-vxi11
Next, download the simple-scpi code from here:  ​https://github.com/gradientone/simple-scpi

Usage
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. 

Timeouts
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.

     G1:StartLoop:Max=<NumberOfTimes>:BreakOn=<ResponseToBreak>

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

Example:

     G1:StartLoop:Max=3
     *IDN?
     G1:EndLoop

Will run the *IDN? command 3 times.

Sleeps

To add a delay to your script in between commands, use a G1:Sleep.

     G1:Sleep=<NumberOfSeconds>

For example, to sleep 2 seconds:

     G1:Sleep=2

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:​
Terminal output

    
Below is an example of the logging:
Log Output

    
Download Simple SCPI
Stay tuned...more advanced features to come.
0 Comments

Oscilloscope Test Automation For Tektronix MDO3012 With Function Generator and RIGOL DS1054Z

6/10/2019

0 Comments

 
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.  
Picture
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.
Picture

Video Demonstration

0 Comments

Oscilloscope Waveform Overlays Using Your Web Browser

6/3/2019

0 Comments

 
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.  

Start A Free Trial Today
0 Comments
<<Previous

    Archives

    April 2020
    September 2019
    August 2019
    July 2019
    June 2019
    May 2019
    April 2019
    March 2018
    February 2018
    January 2018
    December 2017
    November 2017
    September 2017
    August 2017
    July 2017
    June 2017
    April 2017
    July 2016

    Categories

    All
    Instrument
    Usability

    RSS Feed


​Home
News
Jobs
​
Privacy Policy
Contact Us
OUR MISSION - 
GradientOne’s mission is to improve the work of engineers, manufacturing organizations, technical support teams, and scientists, by using cloud computing to streamline instrument management, data collection, analysis, reporting and search.
        ©2019 GradientOne Inc.  All Rights Reserved.
  • Home
  • Solutions
    • Overview
    • Test Engineering
    • Compliance Labs
    • Product Features
    • Supported Instruments
  • Documentation
    • White Papers
    • Getting Started
    • Quality Analysis of Test Data
    • Rigol Automation
    • Waveform Upload
    • Visualization & Measurements
    • News
    • Case Study
  • Try For Free
  • Pricing
    • Buy Now
    • Pilot
  • RIGOL
  • Blog