mbrennwa / pypsucurvetrace Goto Github PK

Specify the resistance of the test leads and use the measured current to determine the voltage drop.

Example:

• Test lead resistance Rx = 0.01 Ohm
• Corrected U1 voltage is determined by subtracting the voltage drops across both test leads: U1_corr = U1_raw - 2I1Rx

Steps, to do:

• Add feature to specify the test lead resistance and write them to the data files
• Calculate corrected U2 values as described above when loading the raw data
• Also, revise schematic showing the U1/I1 and U2/I1 connections to the DUT to explicitly connect PSU2 to the DUT pins directly using separate test leads in order to avoid affecting the U2 voltage with the voltage drop due to I1 in the return flow to the PSU1.

Add a page with examples. There should be a single "landing page" for readers looking for examples, so examples should not be scattered around the other pages in the manual. It's better to have all examples in one place, and provide links to them from the other manual pages.

What would be a good structure for the Examples page?

• Structure by programs / tools? One section each for curvetrace, curveplot, curveprocess, curvematch?
• Present fully worked examples starting with data acquisition with ``curvetrace", followed by data plotting and processing?
• Best of both worlds: combine both! Use curvetrace examples than will be useful to continue in the other sections / examples!

Mount DUT on a heater block with high heat inertia (e.g., chunk of copper), equipped with heating elements (e.g., power resistors), mounted on a heat sink (to allow heat dissipation). Use a temperature sensor to read the temperature of the heater block, and regulate the heat output to the heater elements (PID regulation or similar). Implement the regulation/control in the curve tracer software, and make sure that DUT readings are taken only if/when the heater-block temperature is within a pre-defined tolerance of the intended DUT temperature.

• Add documentation for DUT test config files to the curvetrace page.
• Add example(s) to the Examples page (issue #17).

Consider curve sets from two (or more) different DUTs (I1 vs U1 for different U2 values). How well are the two (or more) DUTs matched?

Idea:

• Determine the range of U1 and I1 values where the curves should be matched. Remove all data outside of this range.
• For each U2 curve pair: calculate the differences ("residuals") of of the I1 values at all U1 measurement points
• Combine all residuals from all curve pairs into one array (delta_I1)
• optional: determine the mean residual (I1_offset) and subtract this from the residuals array (delta_I1 = delta_I1 - I1_offset) [this will yield overall small residuals if the curves are mostly parallel in the U1/I1 range considered]
• calculate the RMS value of the residuals: delta_I1_RMS = sqrt( sum(delta_I1^2) / length(delta_I1) )

--> report the delta_I1_RMS and optionally also the I1_offset:

• The delta_I1_RMS value is a measure for the "matching goodness" between the curves. A low delta_I1_RMS indicates a good match. With the optional subtraction of the mean residual, parallel curve sets will also have low delta_I1_RMS
• The I1_offset indicates the offset between the curve sets.

Check out PyInstaller, maybe others.

In batch mode, curvetrace uses the Uc value from the preheat of the previous DUT/part. This may not be a suitable starting value, and may result in long time to attain the targeted operating point (possibly too long, exceeding the preheat time).

Always use the value from the config file as Uc starting value instead.

See https://www.diyaudio.com/forums/solid-state/344199-idea-power-transistor-curve-tracer-post6826145.html

One of the wonderful features of the HP4145 / 4156 curve tracers, is their ability to accurately measure the partial derivatives

gm := partial(Ice)/partial(Vbe) ... and/or ... partial(Ids)/partial(Vgs)

go := partial(Ice)/partial(Vce) ... and/or ... partial(Ids)/partial(Vds)

ri := partial(Vbe)/partial(Ibe)

Also:
gain mu = partial(U1) / partial(U2)

1. Use the logging module for logging and warning messages
2. Write a handler for the logging module that sends the messages to the GUI

See here for inspiration (but need to make this thread safe):
https://stackoverflow.com/questions/2819791/how-can-i-redirect-the-logger-to-a-wxpython-textctrl-using-a-custom-logging-hand

When the 6012P is configured at high-current mode (12A range), the code goes wrong when it tries to get a reading where the current is higher than 6A. Is there something going on with register #20?

Configuring the BK9185 using BK9185B_LOW will establish the serial port connection, but the voltage setting does not work correctly. There is no error or warning message, but the voltage value set at the PSU unit is not correct.

The PSUs for DUT testing are currently represented as objects that allow setting/reading stuff at/from the PSU devices. This has the following drawbacks:

• Access to the PSUs is not thread safe as they don't have a locking mechanism implemented that prevents different parts of the code from accessing the PSUs at the same time
• Setting parameters at the PSUs is slow, and calling any "setting" methods from the PSU objects blocks the execution of the code.

A way out would be to use a dedicated, separated thread to control to each PSU object. The PSU object would not be exposed to the code outside of the thread. This would allow...

• ...speeding up the execution of the tester code / loops, because both PSUs could be manipulated by their dedicated threads at the same time
• ...isolating the access to the PSU object would allow introducing a queueing/locking layer in the thread in order to prevent parallel access issues to the PSU object.

See here for Python code that checks and lists the COM/serial ports available on the system: https://stackoverflow.com/questions/44056846/how-to-read-and-write-from-a-com-port-using-pyserial

import serial.tools.list_ports as port_list
ports = list(port_list.comports())
for p in ports:
    print (p)

Or maybe (even better?):
https://stackoverflow.com/questions/12090503/listing-available-com-ports-with-python

Add functions that plot the data being acuired (use a background thread for this for independence of the measurement processes). It's probably best to work on this only one there is a basic GUI available (#4).

The plot size (ranges of x and y axes) is determined by matplotlib using the x and y ranges covered by the data. The additional space consumed by the text labels (curve labels, added after data plotting) is not taken into account to set the x and y ranges. Depending on how the plot works out, the x and y ranges turn out too small once the curve labels are added and should therefore be increased after adding the curve labels.

Approach:

• When adding the curve text labels, keep track of the extension of the labels (min/max extension of on the x and y axes)
• After all text labels have been added to the plot, extend the x and y ranges according to the min/max extension of the text labels

Entering a data label / file name of a file that already exists will overwrite the existing file to save the new data without asking "are you sure you want to overwrite the exising file?" first.

The labels at the end of each curve are centered on the last data point of the curve. The text labels therefore cover the last data point (and possible other points that are nearby). The text labels should therefore be moved such that they do not cover any data points.

Approach:

• determine the size of the text label (width and height)
• extrapolate the curve beyond the last data value
• calculate the position (center point) of the text label on the extrapolated curve using the width and height of the label such that it does not overlap with the measured data points

Add documentation for heater block. This could go on the curvetrace page, but might be better to use a separate Heaterblock page because it will be rather long.

Add a GUI. Use a cross platform tool to make the code universal.

Thread-safe access to COM ports must ensure there is not simultaneous access to the PSU COM port from different threads. Need to add a "lock" thingy, and wrap the in/out to/from the the COM port such that it waits until the access is unlocked. See temperaturesensor_MAXIM class file ("UART lock").

Comparing complementary parts of opposite polarity would be a lot easier if their curves could be plotted using the same "polarity".

Add feature to use absolute values of U1, I1 (and U2?) for plotting in curveplot (i.e., in plot_curves).

Add (simple) examples to complete the Examples page.

• Examples can be simple and brief
• Can always add more examples and more details at a later stage

The live plots during curve tracing are sometimes delayed, especially if the curve tracing proceeds quickly. There's probably a timeout in the plotting that prevents quick(er) updating of the live plots.
Reduce that timeout.

Example (in the DUT-test config file):

VSTART = 0
VEND = 1.7
VSTEP = 0.1

--> voltage steps turn out as V = [0, 0.1. 0.2, ... , 1.6 ], but the last value should be 1.7.

curveplot needs a feature to limit the range of the curve levels, similar to the --xlimit, --ylimit, and --xylimit flags.

Current formatat is like this:

VSTART =
VEND =
VSTEP =

--> this is used to set up a linearly spaced sequence of test voltages

New suggested format:
U = [USTART:UEND,N] or U = [USTART:UEND,N,SCAL]
where USTART and UEND are the same as above, N is the number of steps (not increment size).
The optional parameter SCAL indicates the scaling. If SCAL = LOG, the voltage steps are log distributed between USTART and UEND.

Note: use U... instead of V... for consistency with documentation etc., where voltage is always denoted as U, while V is used for the "Volt" unit.

• implement parser for the new format. Is it possible to re-use the existing parser code used in the parsing of command-line arguments for curvematch and curveprocess?
• make parser "smart" to work both the old and the new format. If the voltage specs are given both formats: show a warning about this redundancy in the DUT test config file, and use the new-style format.
• revise generation of voltage step values in curvetrace program: adjust for new format/parser, implement log-scale option
• check/avoid 0 value when using log scale!
• Update documentation to reflect the new format
• Update the example DUT test config files to use the new format