pyetest: Electronics Testing Tool & Method

• Name: pyetest
• Github: https://github.com/snhobbs/pyetest
• pypi: TBD

pyetest is a Python library designed to simplify pass/fail test scripting for electronics by leveraging spreadsheets as test descriptions. The goal is to reduce custom code and make automated test setups more accessible to users who may not be programmers. By using structured spreadsheets to define measurements and criteria, pyetest generates both intermediate test data and final pass/fail outcomes making reports easier to generate and debug.

Example: In-Circuit Test System

This will be easier to describe with an example case. I have a in circuit test stand which is using a LabJack U3 (here after referred to as a data acquisition system AKA a DAQ) connected to a probe board. It is measuring several analog and digital channels as well as controlling the power to the device under test (DUT). The device has a suite of self tests and internal measurements which are readout over RS-485 using a USB-RS-485 dongle.

The test jig runs the following steps:

1. Programs the devices on the board using test points
2. Loads configuration data into the devices through RS-485
3. Read out all data from device and from DAQ system as described in the test description
4. Processes the resulting data into a test report
5. Reports a pass/fail result for the board

pyetest aims to improve steps 3, 4, & 5 with a minimal amount of single use code.

Here’s an example of a useful measurement:

Say we are measuring across a 500 mohm current sense resistor with a 0.1% tolerance. We care about the current but we the input voltage can vary by say 5%. In the template spreadsheet we have measurement fields using our DAQ to measure across the sense resistor and a calculated field for the current. The formula for this would look like: =(A1-A2)/0.5. Since our DAQ is measuring in ADC instead of volts we’ll have to add calculation fields to first calculate volts and then the current which is straight forward. The calculated value is filled in and accessible to the pass/fail test which might then use a min/max test with a some error bars. Sure this is easy to put into a python script but it’s even easier to put into a spreadsheet. In this case the control software is all the same and the tests are defined in the input files only. Different board versions can use the same control software with a different set of input files.

Justification & Background

pyetest relies on using what I believe to be the most commonly used interpreted language out there: excel. I’m not advocating for huge unwieldy excel spreadsheets but most people know how to use them and therefore it’s easier to get new people to maintain a test system built this way than one written from custom python. Spreadsheets have a large number of useful function built in and we don’t need to worry about supporting them or sweat the security issues that could come from other possible solutions (using eval statements did come to mind). pyetest uses the libreoffice calc program as a math interpreter to do the intermediate calculations and set the pass/fail criteria. The main bit of hackery here is save the workbooks as temporary files and forcing them to be recalculated. If there’s a better way to do this let me know!

The spreadsheets act as a plugin module to the software without needing the operator to know any python. You express the relationships in the data template and create the pass/fail criteria in the test template.

pyetest Operation

Steps

• Load spreadsheet template with relationships defined
• Fill the spreadsheet values, store as a new export. Have all intermediate values stored
• Reload spreadsheet to check thresholds. This way the requirements only knows about the high/low targets
• Steps are read, create spreadsheet

Inputs

Data template

This is an xlsx spreadsheet which contains the test names, data source, and field type. The field type specifies if the data is measured, fixed, or calculated. Measured values will be filled in during the test. Fixed values are used in the spreadsheet for calculations of other values such as the number of bits in an ADC. Calculated values have a formula in the value field.

Test template

A spreadsheet which defines the pass/fail criteria. The structure is open for extension but includes at a minimum the field name, a value field that will be filled in, and a passes column that contains an expression (usually something like =E1=B1 or =E1>=C1 & E1<=D1).

Measurements Data Frame

Data taken from all our sources.

Outputs

Measurement Results

This is the data template file with the measured values filled in. All the calculation expressions are retained in the file.

Test Results

This is the test template file with the values filled in. The boolean passes values can then be read out to determine which tests passed.

Procedure

1. Take all the measurements needed and generate a dataframe of data. This can be made all sorts of ways. I typically add a source column to the data template to parse the tag names to define the tests. How to set up these measurements is a separate section of a test suite and is essentially tied to the system you’re using.
2. Load the template files and call pyetest_run
3. Save the data workbook and test results for future retrieval and analysis
4. Turn the tests into a data frame and return a pass/fail analysis

import pandas
import openpyxl
import pyetest

data_template_file = "data_template.xlsx"
measurement_result_file = "measurement_result.xlsx"
measured_data_file = "dummy-values.xlsx"
test_template_file = "test_template.xlsx"
test_result_file = "test-results.xlsx"

data_template_workbook = openpyxl.open(data_template_file)
test_template_workbook = openpyxl.open(test_template_file)
dummy_values_df = pandas.read_excel(measured_data_file)

data_workbook, test_workbook = pyetest.pyetest_run(data_template_workbook, test_template_workbook, dummy_values_df)
test_results_df = pyetest.worksheet_to_df(test_workbook.active)
print(len(test_results_df[test_results_df["passes"] == False]) == 0)
print(test_results_df[test_results_df["passes"] == False])

test_workbook.save(test_result_file)
data_workbook.save(measurement_result_file)

False
         name expected value  unit  min  max value passes
         15   +5 Fault              0  None  NaN  NaN     1  False
         18  DAQ Fault              0  None  NaN  NaN     1  False

Further Work

There are some functions that excel doesn’t do easily that would be useful. When needing to add a new measurement type the first goal is to figure out an excel way to do it. It’s a well understood interpreter after all. Those that can’t be done using excel functions I am adding as plugins. The danger there is taking the plugin route and increasing complexity when a simpler solution is available.

I would like to add curve fitting but as this is a specialized function I would rather add this and other special functions to the data collection step. I expect pyetest to stay as it is with other libraries being used to add additional functionality to the system.

Other Options

For completeness some examples of existing ICT software are:

• Marvin Test Solutions: ATEasy
• Teradyne: Teststation
• Agilent: i3070
• National Instruments: LabVIEW NXG, Teststand, LabVIEW
• Blue Clover: PLT

I could not find any open source projects that fit the use case, if I missed any please let me know, I’d love to hear about them!

• ←Previous
• Next→