Hi,
I am experimenting with smuview and beginning to debug the ZKE-EBD-USB
driver lockup issue.
My first step is to understand the system, and I wrote a test script to
see what smuview is getting as data.
The idea of this script is to look at the last sample and sample number
every 0.4s, to see if I can see the core sample rate. From this I see
the ZKE is being sampled every 2 seconds.
smuview_configkey_trial.py > zke-ebd-usb-test1.txt
How is this 2sec set in smuview? I dont see any control over the sample
rate. Am I missing reading about a setup parameter to control this?
Smuview print() observation: When I stop then start scripts, sometimes
print() starts to do double prints. Then stop and start again. print()
does tripple prints. See smuview-stop.start.txt
When I enable updating the ZKE load current and always write the same
current, the observed sample rate is still 2sec.
smuview_configkey_trial_set_current.py > zke-ebd-usb-test2.txt
When I enable the code to alternate writes of the current of 0.0A and
0.01A, every 0.4sec, I get an observed sample rate of the 0.4sec write rate.
smuview_configkey_trial_change_current.py > zke-ebd-usb-test3.txt
There are a couple of surprises here for me:
1. it seems that the system code remembers what it sent last - and if
multiple requests of the same write data occurs, only the first one
occurs. This is bad when the underlying hardware has error checking but
no ack. If my application now needs to write zero current - and I need
to do this a few times to ensure it gets through, the system seems to be
now blocking the multiple writes to the hardware.
2. The sample data rate (say it is set to 2 seconds) - is now altered if
a write of the a config data occurs.
What I was expecting:
1. A sampling system that occurs irrespective of anything else - not get
additional data when writes occur
2. When the system is commanded to write something - the write occurs.
Not be blocked because the system thinks - well you just wrote that so I
wont send it to the hardware
What I think is happening in the zke-ebd-usb driver and hardware.
1. The zke-ebd-usb device consists of a pl23035A usb to uart IC, and a
st 8S003F3P6 microprocessor. The uart tx/rx and mcu reset pin is easily
accessible for debug and testing
2. When things go wrong and sigrok/zke device seem to lock up - the
comport device (Win10) is still present. Because the comport is still
there - the pl23035A and its device driver seems robust. The issues
seem to be at the sigrok zke-ebd-usb driver and timing of data
send/requests to the device
3. The mcu in the zke is a small micro - the timing of reads/writes to
it need to be managed. My observations with the supplier software is
that it is robust when time between messages are managed. I am going to
do an investigation on this and try to report back a number for this. I
expect the answer to be something like: Yes send a message, a response
will be returned within xxx ms. If a message has a response or no
response (many do), you should not send another message within xxx ms.
I am about to get the scope out and study this more - but my smuview
observations looks likes that the sigrok zke-ebd-usb driver level is not
honoring delay times correctly to the device, and gets locked up /
confused about what responses to expect.
I can observe 2 types of failure modes:
One where a restart of smuview device attachment recovers communications
(remove_device then connect_device)
Session.remove_device(loaddev)
loaddev = Session.connect_device(LOAD_DEV_CONN_STRING)[0]
- I want to explore this fault. I think it starts to occur when a
communications fault occurs
The second where the zke-ebd-usb mcu stops responding. The reset pin to
the mcu can be pulled low with a press-button - and then the system recovers
I am starting to get a handle on telling the two situations apart.
The first one is observable in running smuview_configkey_trial.py >
after some amount of time the 2sec sampling period just stops.
Understanding how the 2sec sampling is set up and what triggers it would
be nice to know. What should I watch to ensure the sampling point is
being triggered?
On the second one - how do I observe/debug at the lower level when
sigrok wants to send commands to the driver? Is there logs to look at to
see what is going on? Where is the source for zke-ebd-usb driver?
Any brief pointers to - yeah this is a known problem - read here
Or - no this is new - please provide more debug data - please read here
on how to get debug data the team needs
Regards
Stuart
#
# smuview config key trial
#
# Written by: Stuart Tyler - Relyt Designs
#
# IMPORTS
import smuview
import time
#import serial
from datetime import datetime
import sys
import inspect
import os
from decimal import *
print("Python version: ",sys.version)
print("Python install path: ",os.path.dirname(sys.executable))
# GLOBALS
# get the start time of the test
timestarttest=datetime.now()
OperatorWaitingTime=0.0
# The test hardware required for this is a PSU and LOAD.
# These are the conn strings to point to the hardware
# Edit the connection point below to the location needed on your setup
PSU_DEV_CONN_STRING="rdtech-rd:conn=COM21"
PSU_DEV_ID_STRING="RDTech:RD6006:18576"
LOAD_COMPORT="COM3"
LOAD_DEV_CONN_STRING="zketech-ebd-usb:conn="+LOAD_COMPORT
LOAD_DEV_ID_STRING="ZKETECH:EBD-USB:"+LOAD_COMPORT
skiphardware=False
#stop on Failure setting
#StopOnFailure = True
StopOnFailure = False
# declaring data variables being used as global floats
psuV = 0.0; psuI = 0.0; psuP = 0.0; loadV = 0.0; loadI = 0.0
testvalue=0.0
timestamp="<Unknown>"
samplenumber=0
sampletime=0.0
#END OF GLOBALS
#FUNCTIONS
# ApplyInstumentDefaultSettings() - sets all instruments to default values
def ApplyInstumentDefaultSettings():
if skiphardware:
return
# Set load to 0A
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
print("<D>")
def DeviceConnection():
global psudev
global loaddev
global psuconf
global loadconf
print_ttt("Information","Device,Connection")
# Get all connected devices from the session
devices = Session.devices()
print (devices)
for deviceId in devices:
device = devices[deviceId]
print (deviceId)
if deviceId == LOAD_DEV_ID_STRING:
print_ttt("Information","Device,ZKE Load device found")
loaddev = device
if 'loaddev' in globals():
print_ttt("Information","Load device connected")
else:
print_ttt("Information","Load device not connected... attempting
connect")
try:
loaddev = Session.connect_device(LOAD_DEV_CONN_STRING)[0]
except:
print_ttt("Information","Load device not connected. Please connect
and attempt script again. Aborting...")
sys.exit("Load device missing")
print_ttt("Information","Load device connected.",loaddev)
# get the configurables
loadconf = loaddev.configurables()[""]
# reset instrument settings to safe situation
ApplyInstumentDefaultSettings()
#end of DeviceConnection
#customised print function
#print_ttt
# ttt stands for time, test, title
#this should be the *only* print function used in here for recorded teest data
#to ensure the output data can be easily analysed
def print_ttt( * args):
#add timestamp
mystring="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))
print_ttt.linecounter+=1
mystring+=",Line,"+str(print_ttt.linecounter)
count = 0
for arg in args:
if count == 0:
mystring+=",Test,"+str(arg)
elif count == 1:
mystring+=",Title,"+str(arg)
else:
mystring+=","+str(arg)
count+=1
print (mystring)
#end of print_ttt
#static linecounter init in main
print_ttt.linecounter=0
# getdata() - aquires the instrument datapoints for this test rig
# the test rig consists of:
# PSU: rdtech-rd rd6006
# USB LOAD: zketech-ebd-usb
#
# PSU datapoints: Voltage, Current, Power (V,I,P)
# USB LOAD datapoints: Voltage, Current (V,I)
#
def getdata():
global loadV
global loadI
global loaddev
global timestamp
global samplenumber
global sampletime
timestamp="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))+","
loadV =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[1]))
loadI =
float("{:.5f}".format(loaddev.channels()["I"].actual_signal().get_last_sample(True)[1]))
samplenumber = loaddev.channels()["V"].actual_signal().sample_count()
sampletime =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[0]))
#end of getdata
#main
waitingtime=0.4
DeviceConnection()
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime)
time.sleep(waitingtime)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
previousnumber=samplenumber
previoustime=sampletime
while True:
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime,"dS",samplenumber-previousnumber,"dT",sampletime-previoustime)
previousnumber=samplenumber
previoustime=sampletime
time.sleep(waitingtime)
# loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.01)
# End of script
Python version: 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600
64 bit (AMD64)]
Python version: 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600
64 bit (AMD64)]
Python install path: C:\Program Files\sigrok\SmuView
Python install path: C:\Program Files\sigrok\SmuView
TimeFromStart,0.000,Line,1,Test,Information,Title,Device,Connection
TimeFromStart,0.000,Line,1,Test,Information,Title,Device,Connection
{'ZKETECH:EBD-USB:COM3': <smuview.BaseDevice object at 0x0000000009DC6F10>}
{'ZKETECH:EBD-USB:COM3': <smuview.BaseDevice object at 0x0000000009DC6F10>}
ZKETECH:EBD-USB:COM3
ZKETECH:EBD-USB:COM3
TimeFromStart,0.000,Line,2,Test,Information,Title,Device,ZKE Load device found
TimeFromStart,0.000,Line,2,Test,Information,Title,Device,ZKE Load device found
TimeFromStart,0.000,Line,3,Test,Information,Title,Load device connected
TimeFromStart,0.000,Line,3,Test,Information,Title,Load device connected
<D>
<D>
TimeFromStart,1.017,Line,4,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729
TimeFromStart,1.017,Line,4,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729
TimeFromStart,1.432,Line,5,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,1.432,Line,5,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,1.845,Line,6,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,1.845,Line,6,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,2.259,Line,7,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,2.259,Line,7,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,383,time,4049.729,dS,0,dT,0.0
TimeFromStart,2.670,Line,8,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,1,dT,2.005000000000109
TimeFromStart,2.670,Line,8,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,1,dT,2.005000000000109
TimeFromStart,3.085,Line,9,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,3.085,Line,9,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,3.499,Line,10,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,3.499,Line,10,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,3.912,Line,11,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,3.912,Line,11,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0
TimeFromStart,4.323,Line,12,Test,Main
0.00,Title,Measurements,loadV,5.058,loadI,0.0,sample,384,time,4051.734,dS,0,dT,0.0TimeFromStart,584.881,Line,1422,Test,Main
0.00,Title,Measurements,loadV,4.925,loadI,0.0,sample,291,time,3865.346,dS,0,dT,0.0
TimeFromStart,585.296,Line,1423,Test,Main
0.00,Title,Measurements,loadV,4.925,loadI,0.0,sample,291,time,3865.346,dS,0,dT,0.0
TimeFromStart,585.709,Line,1424,Test,Main
0.00,Title,Measurements,loadV,4.925,loadI,0.0,sample,291,time,3865.346,dS,0,dT,0.0
TimeFromStart,586.124,Line,1425,Test,Main
0.00,Title,Measurements,loadV,4.916,loadI,0.0,sample,292,time,3867.35,dS,1,dT,2.0039999999999054
TimeFromStart,586.539,Line,1426,Test,Main
0.00,Title,Measurements,loadV,4.916,loadI,0.0,sample,292,time,3867.35,dS,0,dT,0.0
TimeFromStart,586.939,Line,1427,Test,Main
0.00,Title,Measurements,loadV,4.916,loadI,0.0,sample,292,time,3867.35,dS,0,dT,0.0
TimeFromStart,587.353,Line,1428,Test,Main
0.00,Title,Measurements,loadV,4.916,loadI,0.0,sample,292,time,3867.35,dS,0,dT,0.0
TimeFromStart,587.766,Line,1429,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,293,time,3869.355,dS,1,dT,2.005000000000109
TimeFromStart,588.182,Line,1430,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,293,time,3869.355,dS,0,dT,0.0
TimeFromStart,588.595,Line,1431,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,293,time,3869.355,dS,0,dT,0.0
TimeFromStart,589.010,Line,1432,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,293,time,3869.355,dS,0,dT,0.0
TimeFromStart,589.426,Line,1433,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,293,time,3869.355,dS,0,dT,0.0
TimeFromStart,589.826,Line,1434,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,294,time,3871.359,dS,1,dT,2.0039999999999054
TimeFromStart,590.226,Line,1435,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,294,time,3871.359,dS,0,dT,0.0
TimeFromStart,590.626,Line,1436,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,294,time,3871.359,dS,0,dT,0.0
TimeFromStart,591.026,Line,1437,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,294,time,3871.359,dS,0,dT,0.0
TimeFromStart,591.441,Line,1438,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,294,time,3871.359,dS,0,dT,0.0
TimeFromStart,591.856,Line,1439,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,295,time,3873.364,dS,1,dT,2.005000000000109
TimeFromStart,592.270,Line,1440,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,295,time,3873.364,dS,0,dT,0.0
TimeFromStart,592.671,Line,1441,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,295,time,3873.364,dS,0,dT,0.0
TimeFromStart,593.071,Line,1442,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,295,time,3873.364,dS,0,dT,0.0
TimeFromStart,593.485,Line,1443,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,295,time,3873.364,dS,0,dT,0.0
TimeFromStart,593.885,Line,1444,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,296,time,3875.367,dS,1,dT,2.0030000000001564
TimeFromStart,594.300,Line,1445,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,296,time,3875.367,dS,0,dT,0.0
TimeFromStart,594.715,Line,1446,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,296,time,3875.367,dS,0,dT,0.0
TimeFromStart,595.115,Line,1447,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,296,time,3875.367,dS,0,dT,0.0
TimeFromStart,595.530,Line,1448,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,296,time,3875.367,dS,0,dT,0.0
TimeFromStart,595.945,Line,1449,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,297,time,3877.371,dS,1,dT,2.0039999999999054
TimeFromStart,596.361,Line,1450,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,297,time,3877.371,dS,0,dT,0.0
TimeFromStart,596.775,Line,1451,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,297,time,3877.371,dS,0,dT,0.0
TimeFromStart,597.175,Line,1452,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,297,time,3877.371,dS,0,dT,0.0
TimeFromStart,597.575,Line,1453,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,297,time,3877.371,dS,0,dT,0.0
TimeFromStart,597.976,Line,1454,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,298,time,3879.376,dS,1,dT,2.005000000000109
TimeFromStart,598.391,Line,1455,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,298,time,3879.376,dS,0,dT,0.0
TimeFromStart,598.791,Line,1456,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,298,time,3879.376,dS,0,dT,0.0
TimeFromStart,599.206,Line,1457,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,298,time,3879.376,dS,0,dT,0.0
TimeFromStart,599.617,Line,1458,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,298,time,3879.376,dS,0,dT,0.0
TimeFromStart,600.026,Line,1459,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,299,time,3881.38,dS,1,dT,2.0039999999999054
TimeFromStart,600.439,Line,1460,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,299,time,3881.38,dS,0,dT,0.0
TimeFromStart,600.854,Line,1461,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,299,time,3881.38,dS,0,dT,0.0
TimeFromStart,601.270,Line,1462,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,299,time,3881.38,dS,0,dT,0.0
TimeFromStart,601.684,Line,1463,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,299,time,3881.38,dS,0,dT,0.0
TimeFromStart,602.099,Line,1464,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,300,time,3883.384,dS,1,dT,2.0039999999999054
TimeFromStart,602.514,Line,1465,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,300,time,3883.384,dS,0,dT,0.0
TimeFromStart,602.926,Line,1466,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,300,time,3883.384,dS,0,dT,0.0
TimeFromStart,603.341,Line,1467,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,300,time,3883.384,dS,0,dT,0.0
TimeFromStart,603.742,Line,1468,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,300,time,3883.384,dS,0,dT,0.0
TimeFromStart,604.143,Line,1469,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,301,time,3885.387,dS,1,dT,2.0030000000001564
TimeFromStart,604.554,Line,1470,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,301,time,3885.387,dS,0,dT,0.0
TimeFromStart,604.954,Line,1471,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,301,time,3885.387,dS,0,dT,0.0
TimeFromStart,605.366,Line,1472,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,301,time,3885.387,dS,0,dT,0.0
TimeFromStart,605.779,Line,1473,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,301,time,3885.387,dS,0,dT,0.0
TimeFromStart,606.187,Line,1474,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,302,time,3887.392,dS,1,dT,2.0049999999996544
TimeFromStart,606.600,Line,1475,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,302,time,3887.392,dS,0,dT,0.0
TimeFromStart,607.010,Line,1476,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,302,time,3887.392,dS,0,dT,0.0
TimeFromStart,607.411,Line,1477,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,302,time,3887.392,dS,0,dT,0.0
TimeFromStart,607.825,Line,1478,Test,Main
0.00,Title,Measurements,loadV,5.055,loadI,0.0,sample,303,time,3889.396,dS,1,dT,2.00400000000036
TimeFromStart,608.235,Line,1479,Test,Main
0.00,Title,Measurements,loadV,5.055,loadI,0.0,sample,303,time,3889.396,dS,0,dT,0.0
TimeFromStart,608.649,Line,1480,Test,Main
0.00,Title,Measurements,loadV,5.055,loadI,0.0,sample,303,time,3889.396,dS,0,dT,0.0
TimeFromStart,609.064,Line,1481,Test,Main
0.00,Title,Measurements,loadV,5.055,loadI,0.0,sample,303,time,3889.396,dS,0,dT,0.0
TimeFromStart,609.475,Line,1482,Test,Main
0.00,Title,Measurements,loadV,5.055,loadI,0.0,sample,303,time,3889.396,dS,0,dT,0.0
TimeFromStart,609.886,Line,1483,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,304,time,3891.399,dS,1,dT,2.0029999999997017
TimeFromStart,610.296,Line,1484,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,304,time,3891.399,dS,0,dT,0.0
TimeFromStart,610.712,Line,1485,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,304,time,3891.399,dS,0,dT,0.0
TimeFromStart,611.123,Line,1486,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,304,time,3891.399,dS,0,dT,0.0
TimeFromStart,611.523,Line,1487,Test,Main
0.00,Title,Measurements,loadV,5.054,loadI,0.0,sample,304,time,3891.399,dS,0,dT,0.0
TimeFromStart,611.939,Line,1488,Test,Main
0.00,Title,Measurements,loadV,4.833,loadI,0.0,sample,305,time,3893.403,dS,1,dT,2.0039999999999054
TimeFromStart,612.339,Line,1489,Test,Main
0.00,Title,Measurements,loadV,4.833,loadI,0.0,sample,305,time,3893.403,dS,0,dT,0.0
TimeFromStart,612.739,Line,1490,Test,Main
0.00,Title,Measurements,loadV,4.833,loadI,0.0,sample,305,time,3893.403,dS,0,dT,0.0
TimeFromStart,613.153,Line,1491,Test,Main
0.00,Title,Measurements,loadV,4.833,loadI,0.0,sample,305,time,3893.403,dS,0,dT,0.0
TimeFromStart,34.358,Line,84,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,19,time,70.082,dS,0,dT,0.0
TimeFromStart,34.770,Line,85,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,19,time,70.082,dS,0,dT,0.0
TimeFromStart,35.180,Line,86,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,19,time,70.082,dS,0,dT,0.0
TimeFromStart,35.594,Line,87,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,19,time,70.082,dS,0,dT,0.0
TimeFromStart,36.009,Line,88,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,20,time,72.086,dS,1,dT,2.004000000000005
TimeFromStart,36.420,Line,89,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,20,time,72.086,dS,0,dT,0.0
TimeFromStart,36.835,Line,90,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,20,time,72.086,dS,0,dT,0.0
TimeFromStart,37.241,Line,91,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,20,time,72.086,dS,0,dT,0.0
TimeFromStart,37.649,Line,92,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,20,time,72.086,dS,0,dT,0.0
TimeFromStart,38.062,Line,93,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,21,time,74.09,dS,1,dT,2.004000000000005
TimeFromStart,38.473,Line,94,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,21,time,74.09,dS,0,dT,0.0
TimeFromStart,38.885,Line,95,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,21,time,74.09,dS,0,dT,0.0
TimeFromStart,39.298,Line,96,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,21,time,74.09,dS,0,dT,0.0
TimeFromStart,39.711,Line,97,Test,Main
0.00,Title,Measurements,loadV,4.701,loadI,0.0102,sample,21,time,74.09,dS,0,dT,0.0
TimeFromStart,40.125,Line,98,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,22,time,76.094,dS,1,dT,2.0039999999999907
TimeFromStart,40.536,Line,99,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,22,time,76.094,dS,0,dT,0.0
TimeFromStart,40.948,Line,100,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,22,time,76.094,dS,0,dT,0.0
TimeFromStart,41.361,Line,101,Test,Main
0.00,Title,Measurements,loadV,4.702,loadI,0.0102,sample,22,time,76.094,dS,0,dT,0.0
#
# smuview config key trial
#
# Written by: Stuart Tyler - Relyt Designs
#
# IMPORTS
import smuview
import time
#import serial
from datetime import datetime
import sys
import inspect
import os
from decimal import *
print("Python version: ",sys.version)
print("Python install path: ",os.path.dirname(sys.executable))
# GLOBALS
# get the start time of the test
timestarttest=datetime.now()
OperatorWaitingTime=0.0
# The test hardware required for this is a PSU and LOAD.
# These are the conn strings to point to the hardware
# Edit the connection point below to the location needed on your setup
PSU_DEV_CONN_STRING="rdtech-rd:conn=COM21"
PSU_DEV_ID_STRING="RDTech:RD6006:18576"
LOAD_COMPORT="COM3"
LOAD_DEV_CONN_STRING="zketech-ebd-usb:conn="+LOAD_COMPORT
LOAD_DEV_ID_STRING="ZKETECH:EBD-USB:"+LOAD_COMPORT
skiphardware=False
#stop on Failure setting
#StopOnFailure = True
StopOnFailure = False
# declaring data variables being used as global floats
psuV = 0.0; psuI = 0.0; psuP = 0.0; loadV = 0.0; loadI = 0.0
testvalue=0.0
timestamp="<Unknown>"
samplenumber=0
sampletime=0.0
#END OF GLOBALS
#FUNCTIONS
# ApplyInstumentDefaultSettings() - sets all instruments to default values
def ApplyInstumentDefaultSettings():
if skiphardware:
return
# Set load to 0A
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
print("<D>")
def DeviceConnection():
global psudev
global loaddev
global psuconf
global loadconf
print_ttt("Information","Device,Connection")
# Get all connected devices from the session
devices = Session.devices()
print (devices)
for deviceId in devices:
device = devices[deviceId]
print (deviceId)
if deviceId == LOAD_DEV_ID_STRING:
print_ttt("Information","Device,ZKE Load device found")
loaddev = device
if 'loaddev' in globals():
print_ttt("Information","Load device connected")
else:
print_ttt("Information","Load device not connected... attempting
connect")
try:
loaddev = Session.connect_device(LOAD_DEV_CONN_STRING)[0]
except:
print_ttt("Information","Load device not connected. Please connect
and attempt script again. Aborting...")
sys.exit("Load device missing")
print_ttt("Information","Load device connected.",loaddev)
# get the configurables
loadconf = loaddev.configurables()[""]
# reset instrument settings to safe situation
ApplyInstumentDefaultSettings()
#end of DeviceConnection
#customised print function
#print_ttt
# ttt stands for time, test, title
#this should be the *only* print function used in here for recorded teest data
#to ensure the output data can be easily analysed
def print_ttt( * args):
#add timestamp
mystring="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))
print_ttt.linecounter+=1
mystring+=",Line,"+str(print_ttt.linecounter)
count = 0
for arg in args:
if count == 0:
mystring+=",Test,"+str(arg)
elif count == 1:
mystring+=",Title,"+str(arg)
else:
mystring+=","+str(arg)
count+=1
print (mystring)
#end of print_ttt
#static linecounter init in main
print_ttt.linecounter=0
# getdata() - aquires the instrument datapoints for this test rig
# the test rig consists of:
# PSU: rdtech-rd rd6006
# USB LOAD: zketech-ebd-usb
#
# PSU datapoints: Voltage, Current, Power (V,I,P)
# USB LOAD datapoints: Voltage, Current (V,I)
#
def getdata():
global loadV
global loadI
global loaddev
global timestamp
global samplenumber
global sampletime
timestamp="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))+","
loadV =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[1]))
loadI =
float("{:.5f}".format(loaddev.channels()["I"].actual_signal().get_last_sample(True)[1]))
samplenumber = loaddev.channels()["V"].actual_signal().sample_count()
sampletime =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[0]))
#end of getdata
#main
waitingtime=0.4
DeviceConnection()
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime)
time.sleep(waitingtime)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
previousnumber=samplenumber
previoustime=sampletime
while True:
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime,"dS",samplenumber-previousnumber,"dT",sampletime-previoustime)
previousnumber=samplenumber
previoustime=sampletime
time.sleep(waitingtime)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.01)
# End of script
#
# smuview config key trial
#
# Written by: Stuart Tyler - Relyt Designs
#
# IMPORTS
import smuview
import time
#import serial
from datetime import datetime
import sys
import inspect
import os
from decimal import *
print("Python version: ",sys.version)
print("Python install path: ",os.path.dirname(sys.executable))
# GLOBALS
# get the start time of the test
timestarttest=datetime.now()
OperatorWaitingTime=0.0
# The test hardware required for this is a PSU and LOAD.
# These are the conn strings to point to the hardware
# Edit the connection point below to the location needed on your setup
PSU_DEV_CONN_STRING="rdtech-rd:conn=COM21"
PSU_DEV_ID_STRING="RDTech:RD6006:18576"
LOAD_COMPORT="COM3"
LOAD_DEV_CONN_STRING="zketech-ebd-usb:conn="+LOAD_COMPORT
LOAD_DEV_ID_STRING="ZKETECH:EBD-USB:"+LOAD_COMPORT
skiphardware=False
#stop on Failure setting
#StopOnFailure = True
StopOnFailure = False
# declaring data variables being used as global floats
psuV = 0.0; psuI = 0.0; psuP = 0.0; loadV = 0.0; loadI = 0.0
testvalue=0.0
timestamp="<Unknown>"
samplenumber=0
sampletime=0.0
#END OF GLOBALS
#FUNCTIONS
# ApplyInstumentDefaultSettings() - sets all instruments to default values
def ApplyInstumentDefaultSettings():
if skiphardware:
return
# Set load to 0A
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
time.sleep(0.5)
print("<D>")
def DeviceConnection():
global psudev
global loaddev
global psuconf
global loadconf
print_ttt("Information","Device,Connection")
# Get all connected devices from the session
devices = Session.devices()
print (devices)
for deviceId in devices:
device = devices[deviceId]
print (deviceId)
if deviceId == LOAD_DEV_ID_STRING:
print_ttt("Information","Device,ZKE Load device found")
loaddev = device
if 'loaddev' in globals():
print_ttt("Information","Load device connected")
else:
print_ttt("Information","Load device not connected... attempting
connect")
try:
loaddev = Session.connect_device(LOAD_DEV_CONN_STRING)[0]
except:
print_ttt("Information","Load device not connected. Please connect
and attempt script again. Aborting...")
sys.exit("Load device missing")
print_ttt("Information","Load device connected.",loaddev)
# get the configurables
loadconf = loaddev.configurables()[""]
# reset instrument settings to safe situation
ApplyInstumentDefaultSettings()
#end of DeviceConnection
#customised print function
#print_ttt
# ttt stands for time, test, title
#this should be the *only* print function used in here for recorded teest data
#to ensure the output data can be easily analysed
def print_ttt( * args):
#add timestamp
mystring="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))
print_ttt.linecounter+=1
mystring+=",Line,"+str(print_ttt.linecounter)
count = 0
for arg in args:
if count == 0:
mystring+=",Test,"+str(arg)
elif count == 1:
mystring+=",Title,"+str(arg)
else:
mystring+=","+str(arg)
count+=1
print (mystring)
#end of print_ttt
#static linecounter init in main
print_ttt.linecounter=0
# getdata() - aquires the instrument datapoints for this test rig
# the test rig consists of:
# PSU: rdtech-rd rd6006
# USB LOAD: zketech-ebd-usb
#
# PSU datapoints: Voltage, Current, Power (V,I,P)
# USB LOAD datapoints: Voltage, Current (V,I)
#
def getdata():
global loadV
global loadI
global loaddev
global timestamp
global samplenumber
global sampletime
timestamp="TimeFromStart,"+str('%.3f'%((datetime.now()-timestarttest).total_seconds()))+","
loadV =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[1]))
loadI =
float("{:.5f}".format(loaddev.channels()["I"].actual_signal().get_last_sample(True)[1]))
samplenumber = loaddev.channels()["V"].actual_signal().sample_count()
sampletime =
float("{:.5f}".format(loaddev.channels()["V"].actual_signal().get_last_sample(True)[0]))
#end of getdata
#main
waitingtime=0.4
DeviceConnection()
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime)
time.sleep(waitingtime)
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
previousnumber=samplenumber
previoustime=sampletime
dozerocurrent = True
while True:
getdata()
print_ttt("Main
0.00","Measurements","loadV",loadV,"loadI",loadI,"sample",samplenumber,"time",sampletime,"dS",samplenumber-previousnumber,"dT",sampletime-previoustime)
previousnumber=samplenumber
previoustime=sampletime
time.sleep(waitingtime)
if dozerocurrent:
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.0)
dozerocurrent = False
else:
loadconf.set_config(smuview.ConfigKey.CurrentLimit, 0.01)
dozerocurrent = True
# End of script
Python version: 3.4.4 (v3.4.4:737efcadf5a6, Dec 20 2015, 20:20:57) [MSC v.1600
64 bit (AMD64)]
Python install path: C:\Program Files\sigrok\SmuView
TimeFromStart,0.000,Line,1,Test,Information,Title,Device,Connection
{'ZKETECH:EBD-USB:COM3': <smuview.BaseDevice object at 0x000000000A80D228>}
ZKETECH:EBD-USB:COM3
TimeFromStart,0.000,Line,2,Test,Information,Title,Device,ZKE Load device found
TimeFromStart,0.000,Line,3,Test,Information,Title,Load device connected
<D>
TimeFromStart,1.024,Line,4,Test,Main
0.00,Title,Measurements,loadV,4.809,loadI,0.0102,sample,228,time,491.02
TimeFromStart,1.439,Line,5,Test,Main
0.00,Title,Measurements,loadV,4.809,loadI,0.0102,sample,228,time,491.02,dS,0,dT,0.0
TimeFromStart,1.854,Line,6,Test,Main
0.00,Title,Measurements,loadV,4.809,loadI,0.0102,sample,228,time,491.02,dS,0,dT,0.0
TimeFromStart,2.266,Line,7,Test,Main
0.00,Title,Measurements,loadV,4.809,loadI,0.0102,sample,228,time,491.02,dS,0,dT,0.0
TimeFromStart,2.678,Line,8,Test,Main
0.00,Title,Measurements,loadV,4.809,loadI,0.0102,sample,228,time,491.02,dS,0,dT,0.0
TimeFromStart,3.091,Line,9,Test,Main
0.00,Title,Measurements,loadV,4.81,loadI,0.0102,sample,229,time,492.857,dS,1,dT,1.837000000000046
TimeFromStart,3.504,Line,10,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,230,time,493.269,dS,1,dT,0.4119999999999777
TimeFromStart,3.919,Line,11,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,231,time,493.683,dS,1,dT,0.41399999999998727
TimeFromStart,4.334,Line,12,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,232,time,494.097,dS,1,dT,0.41399999999998727
TimeFromStart,4.745,Line,13,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,232,time,494.097,dS,0,dT,0.0
TimeFromStart,5.161,Line,14,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,232,time,494.097,dS,0,dT,0.0
TimeFromStart,5.576,Line,15,Test,Main
0.00,Title,Measurements,loadV,5.074,loadI,0.0,sample,233,time,495.34,dS,1,dT,1.242999999999995
TimeFromStart,5.989,Line,16,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,234,time,495.754,dS,1,dT,0.4140000000000441
TimeFromStart,6.389,Line,17,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,235,time,496.168,dS,1,dT,0.41399999999998727
TimeFromStart,6.803,Line,18,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,236,time,496.568,dS,1,dT,0.39999999999997726
TimeFromStart,7.217,Line,19,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,237,time,496.983,dS,1,dT,0.41500000000002046
TimeFromStart,7.630,Line,20,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,238,time,497.396,dS,1,dT,0.4130000000000109
TimeFromStart,8.041,Line,21,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,239,time,497.809,dS,1,dT,0.4130000000000109
TimeFromStart,8.441,Line,22,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,240,time,498.22,dS,1,dT,0.41100000000000136
TimeFromStart,8.855,Line,23,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,241,time,498.62,dS,1,dT,0.39999999999997726
TimeFromStart,9.255,Line,24,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,242,time,499.034,dS,1,dT,0.41399999999998727
TimeFromStart,9.655,Line,25,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,243,time,499.434,dS,1,dT,0.4000000000000341
TimeFromStart,10.069,Line,26,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,244,time,499.834,dS,1,dT,0.39999999999997726
TimeFromStart,10.469,Line,27,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,245,time,500.248,dS,1,dT,0.41399999999998727
TimeFromStart,10.884,Line,28,Test,Main
0.00,Title,Measurements,loadV,5.078,loadI,0.0,sample,246,time,500.649,dS,1,dT,0.40100000000001046
TimeFromStart,11.299,Line,29,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,247,time,501.063,dS,1,dT,0.41399999999998727
TimeFromStart,11.699,Line,30,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,248,time,501.477,dS,1,dT,0.41399999999998727
TimeFromStart,12.099,Line,31,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,249,time,501.878,dS,1,dT,0.40100000000001046
TimeFromStart,12.499,Line,32,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,250,time,502.279,dS,1,dT,0.40100000000001046
TimeFromStart,12.899,Line,33,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,251,time,502.679,dS,1,dT,0.39999999999997726
TimeFromStart,13.314,Line,34,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,252,time,503.079,dS,1,dT,0.4000000000000341
TimeFromStart,13.714,Line,35,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,253,time,503.493,dS,1,dT,0.41399999999998727
TimeFromStart,14.115,Line,36,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,254,time,503.894,dS,1,dT,0.40100000000001046
TimeFromStart,14.530,Line,37,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,255,time,504.294,dS,1,dT,0.39999999999997726
TimeFromStart,14.945,Line,38,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,256,time,504.709,dS,1,dT,0.41500000000002046
TimeFromStart,15.359,Line,39,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,257,time,505.124,dS,1,dT,0.41500000000002046
TimeFromStart,15.772,Line,40,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,258,time,505.538,dS,1,dT,0.41399999999998727
TimeFromStart,16.186,Line,41,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,258,time,505.538,dS,0,dT,0.0
TimeFromStart,16.599,Line,42,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,258,time,505.538,dS,0,dT,0.0
TimeFromStart,16.999,Line,43,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,259,time,506.778,dS,1,dT,1.240000000000009
TimeFromStart,17.412,Line,44,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,260,time,507.18,dS,1,dT,0.4019999999999868
TimeFromStart,17.826,Line,45,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,261,time,507.592,dS,1,dT,0.4119999999999777
TimeFromStart,18.233,Line,46,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,262,time,508.006,dS,1,dT,0.41399999999998727
TimeFromStart,18.647,Line,47,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,263,time,508.413,dS,1,dT,0.4070000000000391
TimeFromStart,19.063,Line,48,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,264,time,508.827,dS,1,dT,0.41399999999998727
TimeFromStart,19.478,Line,49,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,265,time,509.243,dS,1,dT,0.4159999999999968
TimeFromStart,19.885,Line,50,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,266,time,509.658,dS,1,dT,0.41500000000002046
TimeFromStart,20.296,Line,51,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,267,time,510.065,dS,1,dT,0.40699999999998226
TimeFromStart,20.702,Line,52,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,267,time,510.065,dS,0,dT,0.0
TimeFromStart,21.112,Line,53,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,268,time,510.882,dS,1,dT,0.8170000000000073
TimeFromStart,21.524,Line,54,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,268,time,510.882,dS,0,dT,0.0
TimeFromStart,21.934,Line,55,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,269,time,511.704,dS,1,dT,0.8220000000000027
TimeFromStart,22.345,Line,56,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,270,time,512.114,dS,1,dT,0.410000000000025
TimeFromStart,22.756,Line,57,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,271,time,512.525,dS,1,dT,0.4109999999999445
TimeFromStart,23.166,Line,58,Test,Main
0.00,Title,Measurements,loadV,5.077,loadI,0.0,sample,272,time,512.936,dS,1,dT,0.4110000000000582
TimeFromStart,23.579,Line,59,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,273,time,513.345,dS,1,dT,0.4089999999999918
TimeFromStart,23.994,Line,60,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,274,time,513.758,dS,1,dT,0.4130000000000109
TimeFromStart,24.410,Line,61,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,275,time,514.173,dS,1,dT,0.4149999999999636
TimeFromStart,24.820,Line,62,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,276,time,514.589,dS,1,dT,0.41600000000005366
TimeFromStart,25.234,Line,63,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,277,time,515.0,dS,1,dT,0.4109999999999445
TimeFromStart,25.645,Line,64,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,278,time,515.414,dS,1,dT,0.41399999999998727
TimeFromStart,26.059,Line,65,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,279,time,515.824,dS,1,dT,0.40999999999996817
TimeFromStart,26.469,Line,66,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,280,time,516.239,dS,1,dT,0.4150000000000773
TimeFromStart,26.882,Line,67,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,281,time,516.648,dS,1,dT,0.4089999999999918
TimeFromStart,27.296,Line,68,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,282,time,517.061,dS,1,dT,0.4130000000000109
TimeFromStart,27.710,Line,69,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,283,time,517.475,dS,1,dT,0.41399999999998727
TimeFromStart,28.123,Line,70,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,284,time,517.888,dS,1,dT,0.4130000000000109
TimeFromStart,28.523,Line,71,Test,Main
0.00,Title,Measurements,loadV,5.073,loadI,0.0,sample,285,time,518.301,dS,1,dT,0.4130000000000109
TimeFromStart,28.923,Line,72,Test,Main
0.00,Title,Measurements,loadV,5.076,loadI,0.0,sample,286,time,518.701,dS,1,dT,0.39999999999997726_______________________________________________
sigrok-devel mailing list
sigrok-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sigrok-devel
