1894 lines
46 KiB
Python
1894 lines
46 KiB
Python
# jds6600.py
|
|
# library to remote-control a JDS6600 signal generator
|
|
|
|
# Kristoff Bonne (c) 2018
|
|
# published under MIT license. See file "LICENSE" for full license text
|
|
|
|
# Revisions:
|
|
# Version 0.0.1: 2018/01/19: initial release, reading basic parameters
|
|
# version 0.0.2: 2018/01/28: added "measure" menu + support functions, documentation
|
|
# version 0.0.3: 2018/02/07: added "counter" and "sweep" menu
|
|
# version 0.0.4: 2018/02/14: added "pulse" and "burst" menu + code cleanup
|
|
# version 0.0.5: 2018/02/16: added system menu
|
|
# version 0.1.0: 2018/02/17: added arbitrary waveform
|
|
|
|
|
|
import serial
|
|
import binascii
|
|
|
|
|
|
###########
|
|
# Errors #
|
|
###########
|
|
|
|
class UnknownChannelError(ValueError):
|
|
pass
|
|
|
|
class UnexpectedValueError(ValueError):
|
|
pass
|
|
|
|
class UnexpectedReplyError(ValueError):
|
|
pass
|
|
|
|
class FormatError(ValueError):
|
|
pass
|
|
|
|
class WrongMode(RuntimeError):
|
|
# called when commands are issued with the jds6600 not in the correct
|
|
# mode
|
|
pass
|
|
|
|
|
|
#################
|
|
# jds6600 class #
|
|
#################
|
|
|
|
class jds6600:
|
|
'jds6600 top-level class'
|
|
|
|
# serial device (opened during object init))
|
|
ser = None
|
|
|
|
# commands
|
|
DEVICETYPE=0
|
|
SERIALNUMBER=1
|
|
|
|
CHANNELENABLE=20
|
|
WAVEFORM1=21
|
|
WAVEFORM2=22
|
|
FREQUENCY1=23
|
|
FREQUENCY2=24
|
|
AMPLITUDE1=25
|
|
AMPLITUDE2=26
|
|
OFFSET1=27
|
|
OFFSET2=28
|
|
DUTYCYCLE1=29
|
|
DUTYCYCLE2=30
|
|
PHASE=31
|
|
|
|
ACTION=32
|
|
MODE=33
|
|
|
|
MEASURE_COUP=36 # coupling (AC or DC)
|
|
MEASURE_GATE=37 # gatetime
|
|
MEASURE_MODE=38 # mode (Freq or Periode)
|
|
|
|
COUNTER_COUPL=MEASURE_COUP
|
|
COUNTER_RESETCOUNTER=39
|
|
|
|
SWEEP_STARTFREQ=40
|
|
SWEEP_ENDFREQ=41
|
|
SWEEP_TIME=42
|
|
SWEEP_DIRECTION=43
|
|
SWEEP_MODE=44 # mode: linair or Log
|
|
|
|
PULSE_PULSEWIDTH=45
|
|
PULSE_PERIOD=46
|
|
PULSE_OFFSET=47
|
|
PULSE_AMPLITUDE=48
|
|
|
|
BURST_NUMBER=49
|
|
BURST_MODE=50
|
|
|
|
|
|
SYSTEM_SOUND=51
|
|
SYSTEM_BRIGHTNESS=52
|
|
SYSTEM_LANGUAGE=53
|
|
SYSTEM_SYNC=54
|
|
SYSTEM_ARBMAXNUM=55
|
|
|
|
PROFILE_SAVE=70
|
|
PROFILE_LOAD=71
|
|
PROFILE_CLEAR=72
|
|
|
|
COUNTER_DATA_COUNTER=80
|
|
|
|
MEASURE_DATA_FREQ_LOWRES=81 # low resolution freq counter, used for mode "frequency"
|
|
MEASURE_DATA_FREQ_HIGHRES=82 # high resolution freq. counter, usef for mode "period". UI: valid up to 2 Khz
|
|
MEASURE_DATA_PW1=83
|
|
MEASURE_DATA_PW0=84
|
|
MEASURE_DATA_PERIOD=85
|
|
MEASURE_DATA_DUTYCYCLE=86
|
|
MEASURE_DATA_U1=87
|
|
MEASURE_DATA_U2=88
|
|
MEASURE_DATA_U3=89
|
|
|
|
|
|
|
|
|
|
# waveforms: registers 21 (ch1) and 22 (ch2))
|
|
# 0 to 16: predefined waveforms
|
|
__wave=("SINE","SQUARE","PULSE","TRIANGLE","PARTIALSINE","CMOS","DC","HALF-WAVE","FULL-WAVE","POS-LADDER","NEG-LADDER", "NOISE", "EXP-RIZE","EXP-DECAY","MULTI-TONE","SINC","LORENZ")
|
|
# 101 to 160: arbitrary waveforms
|
|
__awave=[]
|
|
for a in range(1,10):
|
|
__awave.append("ARBITRARY0"+str(a))
|
|
for a in range(10,61):
|
|
__awave.append("ARBITRARY"+str(a))
|
|
# end for
|
|
|
|
|
|
# modes: register 33
|
|
# note: use lowest 4 bits for wrting
|
|
# note: use highest 4 bits for reading
|
|
__modes = ((0,"WAVE_CH1"),(0,"WAVE_CH1"),(1,"WAVE_CH2"),(1,"WAVE_CH2"),(2,"SYSTEM"),(2,"SYSTEM"),(-1,""),(-1,""),(4,"MEASURE"),(5,"COUNTER"),(6,"SWEEP_CH1"),(7,"SWEEP_CH2"),(8,"PULSE"),(9,"BURST"))
|
|
|
|
# action: register 32
|
|
__actionlist=(("STOP","0,0,0,0"),("COUNT","1,0,0,0"),("SWEEP","0,1,0,0"),("PULSE","1,0,1,1"),("BURST","1,0,0,1"))
|
|
__action={}
|
|
for (actionname,actioncode) in __actionlist:
|
|
__action[actionname]=actioncode
|
|
# end for
|
|
|
|
|
|
# measure mode parameters
|
|
__measure_coupling=("AC(EXT.IN)","DC(EXT.IN)")
|
|
__measure_mode=("M.FREQ","M.PERIOD")
|
|
|
|
|
|
# sweep parameters
|
|
__sweep_direction=("RISE","FALL","RISE&FALL")
|
|
__sweep_mode=("LINEAR","LOGARITHM")
|
|
|
|
|
|
# burst parameters
|
|
__burst_mode=["MANUAL TRIG.","CH2 TRIG.","EXT.TRIG(AC)","EXT.TRIG(DC)"]
|
|
|
|
# frequency multiplier
|
|
__freqmultiply=(1,1,1,1/1000,1/1000000)
|
|
|
|
|
|
# language
|
|
__system_language=("ENGLISH","CHINESE")
|
|
|
|
###############
|
|
# oonstructor #
|
|
###############
|
|
|
|
def __init__(self,fname):
|
|
jds6600.ser = serial.Serial(
|
|
port= fname,
|
|
baudrate=115200,
|
|
parity=serial.PARITY_NONE,
|
|
stopbits=serial.STOPBITS_ONE,
|
|
bytesize=serial.EIGHTBITS,
|
|
timeout=1 )
|
|
# end constructor
|
|
|
|
|
|
|
|
#####################
|
|
# support functions #
|
|
#####################
|
|
|
|
#####
|
|
# low-level support function
|
|
|
|
# parse data from read command
|
|
def __parsedata(self,reg,data,a):
|
|
if a not in (0,1): raise RuntimeError(a)
|
|
|
|
try:
|
|
(one,two)=data.split("=")
|
|
except ValueError:
|
|
raise FormatError("Parsing Returned data: Invalid format, missing \"=\"")
|
|
|
|
two_b=two.split(".")
|
|
|
|
# reads from register are terminated by a "."
|
|
# reads of arbitrary waveform are not
|
|
if a == 0:
|
|
if len(two_b) < 2:
|
|
raise FormatError("Parsing Returned data: Invalid format, missing \".\"")
|
|
|
|
if len(two_b) > 2:
|
|
raise FormatError("Parsing Returned data: Invalid format, too many \".\"")
|
|
# end if
|
|
|
|
# command to look for;
|
|
# "r" for register read, "b" for arbitrary waveform read
|
|
c = 'r' if a == 0 else 'b'
|
|
|
|
# check if returned data matches reg that was send
|
|
if reg != None:
|
|
if one != ":"+c+reg:
|
|
errmsg="Parsing Return data: send/received reg mismatch: "+data+" / expected :"+c+reg
|
|
raise FormatError(errmsg)
|
|
# end if
|
|
# end if
|
|
|
|
# done: return data: part between "=" and ".", split on ","
|
|
return two_b[0].split(",")
|
|
# end __parsedata
|
|
|
|
# command in textual form
|
|
def __reg2txt(self,reg):
|
|
return "0"+str(reg) if int(reg) < 10 else str(reg)
|
|
# end reg2txt
|
|
|
|
# send read command (for n datapoint)
|
|
def __sendreadcmd(self,reg,n,a):
|
|
if type(n) != int: raise TypeError(n)
|
|
if a not in (0,1): raise ValueError(a)
|
|
|
|
regtxt=self.__reg2txt(reg)
|
|
if (n < 1):
|
|
raise ValueError(n)
|
|
|
|
if a == 0:
|
|
# a (arbitrary waveform) is 0 -> register read
|
|
c='r' # register
|
|
else:
|
|
c='b' # arbitrary waveform
|
|
# for n to 1
|
|
n=1
|
|
# end else - if
|
|
|
|
# "n" in command start with 0 for 1 read-request
|
|
n -= 1
|
|
|
|
if self.ser.is_open == True:
|
|
tosend=":"+c+regtxt+"="+str(n)+"."+chr(0x0a)
|
|
self.ser.write(tosend.encode())
|
|
# end __sendreadcmd
|
|
|
|
|
|
|
|
# get responds of read-request and parse ("n" reads)
|
|
def __getrespondsandparse(self,reg, n, a):
|
|
if type(n) != int: raise ValueError(n)
|
|
if a not in (0,1): raise ValueError(a) # a=0-> register read, a=1 -> arbitrary waveform read
|
|
|
|
ret=[] # return value
|
|
|
|
c = int(reg) # counter
|
|
c_expect=self.__reg2txt(c)
|
|
for l in range(n):
|
|
# get one line responds from serial device
|
|
retserial=self.ser.readline()
|
|
# convert bytearray into string, then strip off terminating \n and \r
|
|
retserial=str(retserial,'utf-8').rstrip()
|
|
|
|
# get parsed data
|
|
# assume all data are single-value fields
|
|
parseddata=self.__parsedata(c_expect,retserial,a)
|
|
|
|
# we receive a list of strings, all containing numeric (integer) values
|
|
|
|
if len(parseddata) == 1:
|
|
# if list with one value, return that value (converted to integer)
|
|
ret.append(int(parseddata[0]))
|
|
else:
|
|
# if list with multiple values, convert all strings to integers and return list
|
|
retlist=[]
|
|
retcount=0
|
|
for data in parseddata:
|
|
if data == "":
|
|
# we should not receive empty datafields, except for after the last element of an arbitrary waveform
|
|
if not ((a == 1) and (retcount == 2048)):
|
|
raise UnexpectedValueError(parseddata)
|
|
else:
|
|
retlist.append(int(data))
|
|
# end else - if
|
|
|
|
retcount += 1
|
|
# end for
|
|
ret.append(retlist)
|
|
# end else - if
|
|
|
|
# increase next expected to-receive data
|
|
c += 1
|
|
c_expect=self.__reg2txt(c)
|
|
# end for
|
|
|
|
# return parsed data
|
|
# if only one element, return that element
|
|
# if multiple elements, return list
|
|
return ret[0] if n == 1 else ret
|
|
# end __get responds and parse 1
|
|
|
|
|
|
# get data
|
|
def __getdata(self,reg, n=1, a=0):
|
|
if type(reg) != int: raise TypeError(reg)
|
|
if type(n) != int: raise TypeError(n)
|
|
|
|
# a is "arbitrary waveform or register"
|
|
# a=0 -> register read
|
|
# a=1 -> arbitrary waveform read
|
|
|
|
# send "read" commandline for "n" lines
|
|
# copy "a" parameter from calling function
|
|
self.__sendreadcmd(reg,n,a)
|
|
|
|
return self.__getrespondsandparse(reg,n,a)
|
|
# end __getdata 1
|
|
|
|
|
|
# send write command and wait for "ok"
|
|
def __sendwritecmd(self,reg, val, a=0):
|
|
# note: a = "arbitrary waveform?": 0 = no (register write), 1 = yes (arb. waveform write)
|
|
# add a "0" to the command if it one single character
|
|
reg=self.__reg2txt(reg)
|
|
|
|
# command to send: "w" for register write, "b" for arbitrary waveform write
|
|
cmd = "w" if a == 0 else "a"
|
|
|
|
if self.ser.is_open == True:
|
|
if type(val) == int: val = str(val)
|
|
if type(val) != str: raise TypeError(val)
|
|
|
|
tosend=":"+cmd+reg+"="+val+"."+chr(0x0a)
|
|
self.ser.write(tosend.encode())
|
|
|
|
# wait for "ok"
|
|
|
|
# get one line responds from serial device
|
|
ret=self.ser.readline()
|
|
# convert bytearray into string, then strip off terminating \n and \r
|
|
ret=str(ret,'utf-8').rstrip()
|
|
|
|
if ret != ":ok":
|
|
raise UnexpectedReplyError(ret)
|
|
# end if
|
|
|
|
#end if
|
|
# end __sendwritecmd
|
|
|
|
|
|
#####
|
|
# high-level support function
|
|
|
|
# set action
|
|
def __setaction(self,action):
|
|
# type check
|
|
if type(action) != str:
|
|
raise TypeError(action)
|
|
# end if
|
|
|
|
try:
|
|
self.__sendwritecmd(jds6600.ACTION,jds6600.__action[action])
|
|
except KeyError:
|
|
errmsg="Unknown Action: "+action
|
|
raise ValueError(errmsg)
|
|
# end try
|
|
|
|
# end set action
|
|
|
|
###################
|
|
# DEBUG functions #
|
|
###################
|
|
|
|
def DEBUG_readregister(self,register,count):
|
|
if self.ser.is_open == True:
|
|
regtxt=self.__reg2txt(register)
|
|
tosend=":r"+regtxt+"="+str(count)+"."+chr(0x0a)
|
|
self.ser.write(tosend.encode())
|
|
|
|
ret=self.ser.readline()
|
|
while ret != b'':
|
|
print(str(ret))
|
|
ret=self.ser.readline()
|
|
# end while
|
|
# end if
|
|
# end readregister
|
|
|
|
def DEBUG_writeregister(self,register,value):
|
|
if self.ser.is_open == True:
|
|
regtxt=self.__reg2txt(register)
|
|
if type(value) == int:
|
|
value=str(value)
|
|
|
|
tosend=":w"+regtxt+"="+value+"."+chr(0x0a)
|
|
self.ser.write(tosend.encode())
|
|
|
|
ret=self.ser.readline()
|
|
while ret != b'':
|
|
print(str(ret))
|
|
ret=self.ser.readline()
|
|
# end while
|
|
# end if
|
|
|
|
# end write register
|
|
|
|
|
|
##############
|
|
# PUBLIC API #
|
|
##############
|
|
|
|
#########################
|
|
# Part 0: API information
|
|
|
|
|
|
# API version
|
|
def getAPIinfo_version(self):
|
|
return 1
|
|
# end getAPIversion
|
|
|
|
# API release number
|
|
def getAPIinfo_release(self):
|
|
return "0.1.0 2018-02-17"
|
|
# end get API release
|
|
|
|
|
|
#############################
|
|
# Part 1: information queries
|
|
|
|
# list of waveforms
|
|
def getinfo_waveformlist(self):
|
|
waveformlist=list(enumerate(jds6600.__wave))
|
|
for aw in (enumerate(jds6600.__awave,101)):
|
|
waveformlist.append(aw)
|
|
# end for
|
|
|
|
return waveformlist
|
|
# end get waveform list
|
|
|
|
|
|
# get list of modes
|
|
def getinfo_modelist(self):
|
|
modelist=[]
|
|
|
|
lastmode=-1
|
|
|
|
# create list of modes, removing dups
|
|
for (modeid,modetxt) in jds6600.__modes:
|
|
# ignore modes with modeid < 0 (unused mode)
|
|
if modeid < 0:
|
|
continue
|
|
# end if
|
|
|
|
if modeid != lastmode:
|
|
modelist.append((modeid,modetxt))
|
|
lastmode = modeid
|
|
# end if
|
|
# end for
|
|
|
|
return modelist
|
|
# end getinfo modelist
|
|
|
|
|
|
##################################
|
|
# Part 2: reading basic parameters
|
|
|
|
# get device type
|
|
def getinfo_devicetype(self):
|
|
return self.__getdata(jds6600.DEVICETYPE)
|
|
# end get device type
|
|
|
|
|
|
# get serial number
|
|
def getinfo_serialnumber(self):
|
|
return self.__getdata(jds6600.SERIALNUMBER)
|
|
# end get serial number
|
|
|
|
|
|
# get channel enable status
|
|
def getchannelenable(self):
|
|
(ch1,ch2)=self.__getdata(jds6600.CHANNELENABLE)
|
|
try:
|
|
return (False,True)[ch1], (False,True)[ch2]
|
|
except IndexError:
|
|
errmsg="Unexpected value received: {},{}".format(ch1,ch2)
|
|
raise UnexpectedValueError(errmsg)
|
|
# end get channel enable status
|
|
|
|
# get waveform
|
|
def getwaveform(self, channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
#WAVEFORM for channel 2 is WAVEFORM1 + 1
|
|
waveform=self.__getdata(jds6600.WAVEFORM1+channel-1)
|
|
|
|
# waveform 0 to 16 are in "wave" list, 101 to 160 are in __awave
|
|
try:
|
|
return (waveform,jds6600.__wave[waveform])
|
|
except IndexError:
|
|
pass
|
|
|
|
try:
|
|
return (waveform,jds6600.__awave[waveform-101])
|
|
except IndexError:
|
|
raise UnexpectedValueError(waveform)
|
|
# end getwaveform
|
|
|
|
# get frequency _with multiplier
|
|
def getfrequency_m(self,channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
(f1,f2)=self.__getdata(jds6600.FREQUENCY1+channel-1)
|
|
|
|
# parse multiplier (value after ",")
|
|
# 0=Hz, 1=KHz,2=MHz, 3=mHz,4=uHz)
|
|
# note f1 is frequency / 100
|
|
try:
|
|
return((f1/100*self.__freqmultiply[f2],f2))
|
|
except IndexError:
|
|
# unexptected value of frequency multiplier
|
|
raise UnexpectedValueError(f2)
|
|
# end elsif
|
|
# end function getfreq
|
|
|
|
# get frequency _no multiplier information
|
|
def getfrequency(self,channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
(f1,f2)=self.__getdata(jds6600.FREQUENCY1+channel-1)
|
|
|
|
# parse multiplier (value after ","): 0=Hz, 1=KHz,2=MHz, 3=mHz,4=uHz)
|
|
# note1: frequency unit is Hz / 100
|
|
# note2: multiplier 1 (khz) and 2 (mhz) only changes the visualisation on the
|
|
# display of the jfs6600. The frequency itself is calculated in
|
|
# the same way as for multiplier 0 (Hz)
|
|
# mulitpliers 3 (mHZ) and 4 (uHz) do change the calculation of the frequency
|
|
try:
|
|
return(f1/100*self.__freqmultiply[f2])
|
|
except IndexError:
|
|
# unexptected value of frequency multiplier
|
|
raise UnexpectedValueError(f2)
|
|
# end elsif
|
|
# end function getfreq
|
|
|
|
|
|
# get amplitude
|
|
def getamplitude(self, channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
amplitude=self.__getdata(jds6600.AMPLITUDE1+channel-1)
|
|
|
|
# amplitude is mV -> so divide by 1000
|
|
return amplitude/1000
|
|
# end getamplitude
|
|
|
|
|
|
# get offset
|
|
def getoffset(self, channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
offset=self.__getdata(jds6600.OFFSET1+channel-1)
|
|
|
|
# offset unit is 10 mV, and then add 1000
|
|
return (offset-1000)/100
|
|
# end getoffset
|
|
|
|
# get dutcycle
|
|
def getdutycycle(self, channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
dutycycle=self.__getdata(jds6600.DUTYCYCLE1+channel-1)
|
|
|
|
# dutycycle unit is 0.1 %, so divide by 10
|
|
return dutycycle/10
|
|
# end getdutycycle
|
|
|
|
|
|
# get phase
|
|
def getphase(self):
|
|
phase=self.__getdata(jds6600.PHASE)
|
|
|
|
# phase unit is 0.1 degrees, so divide by 10
|
|
return phase/10
|
|
# end getphase
|
|
|
|
|
|
##################################
|
|
# Part 3: writing basic parameters
|
|
|
|
|
|
# set channel enable
|
|
def setchannelenable(self,ch1,ch2):
|
|
if type(ch1) != bool: raise TypeError(ch1)
|
|
if type(ch2) != bool: raise TypeError(ch1)
|
|
|
|
# channel 1
|
|
if ch1 == True: enable = "1"
|
|
else: enable = "0" # end else - if
|
|
|
|
if ch2 == True: enable += ",1"
|
|
else: enable += ",0" # end else - if
|
|
|
|
# write command
|
|
self.__sendwritecmd(jds6600.CHANNELENABLE,enable)
|
|
# end set channel enable
|
|
|
|
# set waveform
|
|
def setwaveform(self,channel,waveform):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if (type(waveform) != int) and (type(waveform) != str): raise TypeError(waveform)
|
|
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
# wzveform can be integer or string
|
|
w=None
|
|
|
|
if type(waveform) == int:
|
|
# waveform is an integer
|
|
if waveform < 101:
|
|
try:
|
|
jds6600.__wave[waveform]
|
|
except IndexError:
|
|
raise ValueError(waveform)
|
|
# end try
|
|
|
|
else:
|
|
try:
|
|
jds6600.__awave[waveform-101]
|
|
except IndexError:
|
|
raise ValueError(waveform)
|
|
# end try
|
|
# end if
|
|
|
|
# ok, it exists!
|
|
w=waveform
|
|
|
|
else:
|
|
# waveform is a string
|
|
|
|
# make everything uppercase
|
|
waveform=waveform.upper()
|
|
# check all waveform descriptions in wave and __awave
|
|
# w is already initialised as "none" above
|
|
|
|
try:
|
|
# try in "wave" list
|
|
w=jds6600.__wave.index(waveform)
|
|
except ValueError:
|
|
pass
|
|
|
|
if w == None:
|
|
#if not found in "wave", try the "awave" list
|
|
try:
|
|
w=jds6600.__awave.index(waveform)+101 # arbitrary waveforms state are index 101
|
|
except ValueError:
|
|
pass
|
|
# end try
|
|
# end if
|
|
|
|
if w == None:
|
|
# not in "wave" and "awave" error
|
|
errmsg="Unknown waveform "+waveform
|
|
raise ValueError (errmsg)
|
|
# end if
|
|
|
|
# ens else - if
|
|
|
|
|
|
self.__sendwritecmd(jds6600.WAVEFORM1+channel-1,w)
|
|
|
|
# end function set waveform
|
|
|
|
|
|
# set frequency (with multiplier)
|
|
def setfrequency(self,channel,freq,multiplier=0):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if (type(freq) != int) and (type(freq) != float): raise TypeError(freq)
|
|
if type(multiplier) != int: raise TypeError(multiplier)
|
|
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
|
|
if (freq < 0):
|
|
raise ValueError(freq)
|
|
|
|
# do not execute set-frequency when the device is in sweepfrequency mode
|
|
currentmode=self.getmode()
|
|
|
|
if (channel == 1) and (currentmode[1] == "SWEEP_CH1"):
|
|
# for channel 1
|
|
raise WrongMode()
|
|
elif (channel == 2) and (currentmode[1] == "SWEEP_CH2"):
|
|
# for channel 2
|
|
raise WrongMode()
|
|
# end elsif - if
|
|
|
|
|
|
|
|
# freqmultier should be one of the "frequency multiply" values
|
|
try:
|
|
self.__freqmultiply[multiplier]
|
|
except IndexError:
|
|
raise ValueError[multiplier]
|
|
|
|
# frequency limit:
|
|
# 60 Mhz for multiplier 0 (Hz), 1 (KHz) and 2 (MHz)
|
|
# 80 Khz for multiplier 3 (mHz)
|
|
# 80 Hz for multiplier 4 (uHz)
|
|
# trying to configure a higher value can result in incorrect frequencies
|
|
|
|
if multiplier < 3:
|
|
if freq > 60000000:
|
|
errmsg="Maximum frequency using multiplier {} is 60 MHz.".format(multiplier)
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
elif multiplier == 3:
|
|
if freq > 80000:
|
|
errmsg="Maximum frequency using multiplier 3 is 80 KHz."
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
else: # multiplier == 4
|
|
if freq > 80:
|
|
errmsg="Maximum frequency using multiplier 4 is 80 Hz."
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
# end else - elsif - if
|
|
|
|
|
|
|
|
# round to nearest 0.01 value
|
|
freq=int(round(freq*100/jds6600.__freqmultiply[multiplier]))
|
|
value=str(freq)+","+str(multiplier)
|
|
|
|
self.__sendwritecmd(jds6600.FREQUENCY1+channel-1,value)
|
|
# end set frequency (with multiplier)
|
|
|
|
|
|
# set amplitude
|
|
def setamplitude(self, channel, amplitude):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if (type(amplitude) != int) and (type(amplitude) != float): raise TypeError(amplitude)
|
|
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
# amplitude is between 0 and 20 V
|
|
if not (0 <= amplitude <= 20):
|
|
raise ValueError(amplitude)
|
|
|
|
# round to nearest 0.001 value
|
|
amplitude=int(round(amplitude*1000))
|
|
|
|
self.__sendwritecmd(jds6600.AMPLITUDE1+channel-1,amplitude)
|
|
# end setamplitude
|
|
|
|
|
|
|
|
# set offset
|
|
def setoffset(self, channel, offset):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if (type(offset) != int) and (type(offset) != float): raise TypeError(offset)
|
|
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
# offset is between -10 and +10 volt
|
|
if not (-10 <= offset <= 10):
|
|
raise ValueError(offset)
|
|
|
|
# note: althou the value-range for offset is able
|
|
# to accomodate an offset between -10 and +10 Volt
|
|
# the actual offset seams to be lmited to -2.5 to +2.5
|
|
|
|
# round to nearest 0.01 value
|
|
offset=int(round(offset*100))+1000
|
|
|
|
self.__sendwritecmd(jds6600.OFFSET1+channel-1, offset)
|
|
# end set offset
|
|
|
|
# set dutcycle
|
|
def setdutycycle(self, channel, dutycycle):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
if (type(dutycycle) != int) and (type(dutycycle) != float): raise TypeError(dutycycle)
|
|
|
|
if not (channel in (1,2)): raise ValueError(channel)
|
|
|
|
# dutycycle is between 0 and 100 %
|
|
if not (0 <= dutycycle <= 100):
|
|
raise ValueError(dutycycle)
|
|
|
|
# round to nearest 0.1 value
|
|
dutycycle=int(round(dutycycle*10))
|
|
|
|
self.__sendwritecmd(jds6600.DUTYCYCLE1+channel-1,dutycycle)
|
|
# end set dutycycle
|
|
|
|
|
|
# set phase
|
|
def setphase(self,phase):
|
|
if (type(phase) != int) and (type(phase) != float):
|
|
raise TypeError(phase)
|
|
|
|
# hase is between -360 and 360
|
|
if not (-360 <= phase <= 360):
|
|
raise ValueError(phase)
|
|
|
|
if phase < 0:
|
|
phase += 3600
|
|
|
|
# round to nearest 0.1 value
|
|
phase=int(round(phase*10))
|
|
|
|
self.__sendwritecmd(jds6600.PHASE,phase)
|
|
# end getphase
|
|
|
|
|
|
#######################
|
|
# Part 4: reading / changing mode
|
|
# get mode
|
|
def getmode(self):
|
|
mode=self.__getdata(jds6600.MODE)
|
|
|
|
|
|
# mode is in the list "modes". mode-name "" means undefinded
|
|
mode=int(mode)>>3
|
|
|
|
try:
|
|
(modeid,modetxt)=jds6600.__modes[mode]
|
|
except IndexError:
|
|
raise UnexpectedValueError(mode)
|
|
|
|
# modeid 3 is not valid and returns an id of -1
|
|
if modeid >= 0:
|
|
return modeid,modetxt
|
|
# end if
|
|
|
|
|
|
# modeid 4
|
|
raise UnexpectedValueError(mode)
|
|
|
|
# end getmode
|
|
|
|
|
|
# set mode
|
|
def setmode(self,mode, nostop=False):
|
|
if (type(mode) != int) and (type(mode) != str): raise TypeError(mode)
|
|
|
|
|
|
modeid=-1
|
|
# if mode is an integer, it should be between 0 and 9
|
|
if type(mode) == int:
|
|
if not (0 <= mode <= 9):
|
|
raise ValueError(mode)
|
|
# end if
|
|
|
|
# modeid 3 / modetxt "" does not exist
|
|
if mode == 3:
|
|
raise ValueError("mode 3 does not exist")
|
|
# end if
|
|
|
|
|
|
# valid modeid
|
|
modeid = mode
|
|
|
|
else:
|
|
# modeid 3 / modetxt "" does not exist
|
|
if mode == "":
|
|
raise ValueError("mode 3 does not exist")
|
|
# end if
|
|
|
|
# mode is string -> check list
|
|
# (note: the modes-list is not enumerated like the other lists, so an "array.index("text")" search is not possible
|
|
for mid,mtxt in jds6600.__modes:
|
|
if mode.upper() == mtxt:
|
|
# found it!!!
|
|
modeid=mid
|
|
break
|
|
# end if
|
|
else:
|
|
# mode not found -> error
|
|
raise ValueError(mode)
|
|
# end for
|
|
# end else - if
|
|
|
|
# before changing mode, disable all actions (unless explicitally asked not to do)
|
|
if nostop == False:
|
|
self.__setaction("STOP")
|
|
# endif
|
|
|
|
# set mode
|
|
self.__sendwritecmd(jds6600.MODE,modeid)
|
|
|
|
# if new mode is "burst", reset burst counter
|
|
if modeid == 9:
|
|
self.burst_resetcounter()
|
|
# end if
|
|
|
|
# end setmode
|
|
|
|
#######################
|
|
# Part 5: functions common for all modes
|
|
def stopallactions(self):
|
|
# just send stop
|
|
self.__setaction("STOP")
|
|
# end stop all actions
|
|
|
|
|
|
#######################
|
|
# Part 6: "measure" mode
|
|
|
|
# get coupling parameter (measure mode)
|
|
def measure_getcoupling(self):
|
|
coupling=self.__getdata(jds6600.MEASURE_COUP)
|
|
|
|
try:
|
|
return (coupling,jds6600.__measure_coupling[coupling])
|
|
except IndexError:
|
|
raise UnexpectedValueError(coupling)
|
|
# end try
|
|
# end get coupling (measure mode)
|
|
|
|
# get gate time (measure mode)
|
|
# get (measure mode)
|
|
def measure_getgate(self):
|
|
gate=self.__getdata(jds6600.MEASURE_GATE)
|
|
|
|
|
|
# gate unit is 0.01 seconds
|
|
return gate / 100
|
|
# end get gate (measure mode)
|
|
|
|
|
|
# get Measure mode (freq or period)
|
|
def measure_getmode(self):
|
|
mode=self.__getdata(jds6600.MEASURE_MODE)
|
|
|
|
try:
|
|
return (mode,jds6600.__measure_mode[mode])
|
|
except IndexError:
|
|
raise UnexpectedValueError(mode)
|
|
# end try
|
|
# end get mode (measure)
|
|
|
|
|
|
|
|
# set measure coupling
|
|
def measure_setcoupling(self,coupling):
|
|
# type checks
|
|
if (type(coupling) != int) and (type(coupling) != str): raise TypeError(coupling)
|
|
|
|
|
|
if type(coupling) == int:
|
|
# coupling is 0 (DC) or 1 (AC)
|
|
if not (coupling in (0,1)):
|
|
raise ValueError(coupling)
|
|
|
|
coupl=coupling
|
|
|
|
else:
|
|
# string based
|
|
|
|
coupling=coupling.upper()
|
|
# spme shortcuts:
|
|
if coupling == "AC": coupling = "AC(EXT.IN)"
|
|
if coupling == "DC": coupling = "DC(EXT.IN)"
|
|
|
|
try:
|
|
coupl=jds6600.__measure_coupling.index(coupling)
|
|
except ValueError:
|
|
errmsg="Unknown measure-mode coupling: "+coupling
|
|
raise ValueError(errmsg)
|
|
# end try
|
|
# end else ) if (type is int or str?)
|
|
|
|
# set mode
|
|
self.__sendwritecmd(jds6600.MEASURE_COUP,coupl)
|
|
|
|
# end set measure_coupling
|
|
|
|
# set gate time (measure mode)
|
|
def measure_setgate(self, gate):
|
|
# check type
|
|
if (type(gate) != int) and (type(gate) != float): raise TypeError(gate)
|
|
|
|
# gate unit is 0.01 and is between 0 and 10
|
|
if not (0 < gate <= 1000):
|
|
raise ValueError(gate)
|
|
|
|
gate = int(round(gate*100))
|
|
|
|
# minimum is 0.01 second
|
|
if gate == 0:
|
|
gate = 0.01
|
|
|
|
# set gate
|
|
self.__sendwritecmd(jds6600.MEASURE_GATE,gate)
|
|
# end get gate (measure mode)
|
|
|
|
|
|
# set measure mode
|
|
def measure_setmode(self,mode):
|
|
# type checks
|
|
if (type(mode) != int) and (type(mode) != str): raise TypeError(mode)
|
|
|
|
|
|
if type(mode) == int:
|
|
# mode is 0 (M.FREQ) or 1 (M.PRERIOD)
|
|
if not (mode in (0,1)):
|
|
raise ValueError(mode)
|
|
|
|
else:
|
|
# string based
|
|
|
|
# make uppercase
|
|
mode=mode.upper()
|
|
|
|
# spme shortcuts:
|
|
if mode== "FREQ": mode = "M.FREQ"
|
|
if mode== "PERIOD": mode = "M.PERIOD"
|
|
|
|
try:
|
|
mode=jds6600.__measure_mode.index(mode)
|
|
except ValueError:
|
|
errmsg="Unknown measure mode: "+mode
|
|
raise ValueError(errmsg)
|
|
# end try
|
|
|
|
# end else ) if (type is int or str?)
|
|
|
|
# set mode
|
|
self.__sendwritecmd(jds6600.MEASURE_MODE,mode)
|
|
|
|
# end set measure_coupling
|
|
|
|
# get Measure freq. (lowres / Freq-mode)
|
|
def measure_getfreq_f(self):
|
|
freq=self.__getdata(jds6600.MEASURE_DATA_FREQ_LOWRES)
|
|
|
|
# unit is 0.1 Hz
|
|
return freq/10
|
|
# end get freq-Lowres (measure)
|
|
|
|
# get Measure freq. (highes / Periode-mode)
|
|
def measure_getfreq_p(self):
|
|
freq=self.__getdata(jds6600.MEASURE_DATA_FREQ_HIGHRES)
|
|
|
|
# unit is 0.001 Hz
|
|
return freq/1000
|
|
# end get freq-Lowres (measure)
|
|
|
|
# get Measure pulsewith +
|
|
def measure_getpw1(self):
|
|
pw=self.__getdata(jds6600.MEASURE_DATA_PW1)
|
|
|
|
# unit is 0.01 microsecond
|
|
return pw/100
|
|
# end get pulsewidth -
|
|
|
|
# get Measure pulsewidth -
|
|
def measure_getpw0(self):
|
|
pw=self.__getdata(jds6600.MEASURE_DATA_PW0)
|
|
|
|
# unit is 0.01 microsecond
|
|
return pw/100
|
|
# end get pulsewidth +
|
|
|
|
# get Measure total period
|
|
def measure_getperiod(self):
|
|
period=self.__getdata(jds6600.MEASURE_DATA_PERIOD)
|
|
|
|
# unit is 0.01 microsecond
|
|
return period/100
|
|
# end get total period
|
|
|
|
# get Measure dutycycle
|
|
def measure_getdutycycle(self):
|
|
dutycycle=self.__getdata(jds6600.MEASURE_DATA_DUTYCYCLE)
|
|
|
|
# unit is 0.1 %
|
|
return dutycycle/10
|
|
# end get freq-Lowres (measure)
|
|
|
|
# get Measure unknown value 1 (related to freq, inverse-related to gatetime)
|
|
def measure_getu1(self):
|
|
# unit is unknown, just return it
|
|
return self.__getdata(jds6600.MEASURE_DATA_U1)
|
|
# end get freq-Lowres (measure)
|
|
|
|
# get Measure unknown value 2 (inverse related to freq)
|
|
def measure_getu2(self):
|
|
# unit is unknown, just return it
|
|
return self.__getdata(jds6600.MEASURE_DATA_U2)
|
|
# end get freq-Lowres (measure)
|
|
|
|
# get Measure unknown value 3 (nverse related to freq)
|
|
def measure_getu3(self):
|
|
# unit is unknown, just return it
|
|
return self.__getdata(jds6600.MEASURE_DATA_U3)
|
|
# end get freq-Lowres (measure)
|
|
|
|
|
|
# get Measure all (all usefull data: freq_f, freq_p, pw1, pw0, period, dutycycle
|
|
def measure_getall(self):
|
|
|
|
# do query for 6 values (start with freq_q)
|
|
(freq_f, freq_p, pw1, pw0, period, dutycycle)=self.__getdata(jds6600.MEASURE_DATA_FREQ_LOWRES,6)
|
|
|
|
# return all
|
|
return (freq_f / 10, freq_p / 1000, pw1/100, pw0/100, period/100, dutycycle/10)
|
|
# end get freq-Lowres (measure)
|
|
|
|
|
|
|
|
#######################
|
|
# Part 7: "Counter" mode
|
|
|
|
# counter getcoupling is the same as measure getcoupling
|
|
def counter_getcoupling(self):
|
|
return self.measure_getcoupling()
|
|
# end counter get coupling
|
|
|
|
# get counter - counter
|
|
def counter_getcounter(self):
|
|
# unit is 1, just return data
|
|
return self.__getdata(jds6600.COUNTER_DATA_COUNTER)
|
|
# end get counter - counter
|
|
|
|
# counter setcoupling is the same as measure setcoupling
|
|
def counter_setcoupling(self,coupling):
|
|
self.measure_setcoupling(coupling)
|
|
# end counter get coupling
|
|
|
|
|
|
# counter - reset counter
|
|
def counter_reset(self):
|
|
# write 0 to register "COUNTER_RESETCOUNTER"
|
|
self.__sendwritecmd(jds6600.COUNTER_RESETCOUNTER,0)
|
|
# end counter reset counter
|
|
|
|
# start counter mode
|
|
def counter_start(self):
|
|
mode=self.getmode()
|
|
|
|
if mode[1] != "COUNTER":
|
|
raise WrongMode()
|
|
# end if
|
|
|
|
# action start BURST mode
|
|
self.__setaction("COUNT")
|
|
# end counter_start
|
|
|
|
|
|
def counter_stop(self):
|
|
# just send stop
|
|
self.__setaction("STOP")
|
|
# end counter_stop
|
|
|
|
|
|
|
|
|
|
|
|
#######################
|
|
# Part 8: "Sweep" mode
|
|
|
|
# note, there are two "setmode" commands to enter "sweep" mode: "sweep_ch1' (mode 6) and "sweep_ch2" (mode 7)
|
|
|
|
def sweep_getstartfreq(self):
|
|
# unit is 0.01Hz -> divide by 100
|
|
return self.__getdata(jds6600.SWEEP_STARTFREQ)/100
|
|
# end get sweep - startfreq
|
|
|
|
def sweep_getendfreq(self):
|
|
# unit is 0.01 Hz -> divide by 100
|
|
return self.__getdata(jds6600.SWEEP_ENDFREQ)/100
|
|
# end get sweep - startfreq
|
|
|
|
def sweep_gettime(self):
|
|
# unit is 0.1 sec -> divide by 10
|
|
return self.__getdata(jds6600.SWEEP_TIME)/10
|
|
# end get sweep - startfreq
|
|
|
|
|
|
# get sweep direction
|
|
def sweep_getdirection(self):
|
|
direction=self.__getdata(jds6600.SWEEP_DIRECTION)
|
|
|
|
try:
|
|
return (direction,jds6600.__sweep_direction[direction])
|
|
except IndexError:
|
|
raise UnexpectedValueError(direction)
|
|
# end try
|
|
# end get direction (sweep)
|
|
|
|
# get sweep mode
|
|
def sweep_getmode(self):
|
|
mode=self.__getdata(jds6600.SWEEP_MODE)
|
|
|
|
try:
|
|
return (mode,jds6600.__sweep_mode[mode])
|
|
except IndexError:
|
|
raise UnexpectedValueError(mode)
|
|
# end try
|
|
# end get mode (measure)
|
|
|
|
def sweep_setstartfreq(self, frequency):
|
|
if (type(frequency) != int) and (type(frequency) != float): raise TypeError(frequency)
|
|
|
|
# frequency should be between 0 and 60 MHz
|
|
if not (0 <= frequency <= 60000000):
|
|
raise ValueError(frequency)
|
|
|
|
# frequency unit is 0.01 Hz
|
|
freq=int(round(frequency*100))
|
|
|
|
self.__sendwritecmd(jds6600.SWEEP_STARTFREQ,freq)
|
|
# end set start freq
|
|
|
|
def sweep_setendfreq(self, frequency):
|
|
if (type(frequency) != int) and (type(frequency) != float): raise TypeError(frequency)
|
|
|
|
# frequency should be between 0 and 60 MHz
|
|
if not (0 <= frequency <= 60000000):
|
|
raise ValueError(frequency)
|
|
|
|
# frequency unit is 0.01 Hz
|
|
freq=int(round(frequency*100))
|
|
|
|
self.__sendwritecmd(jds6600.SWEEP_ENDFREQ,freq)
|
|
# end set end freq
|
|
|
|
|
|
def sweep_settime(self, time):
|
|
if (type(time) != int) and (type(time) != float): raise TypeError(time)
|
|
|
|
# time should be between 0 and 999.9 seconds
|
|
if not (0 < time <= 999.9):
|
|
raise ValueError(time)
|
|
|
|
# time unit is 0.1 second
|
|
t=int(round(time*10))
|
|
|
|
self.__sendwritecmd(jds6600.SWEEP_TIME,t)
|
|
# end set end freq
|
|
|
|
|
|
def sweep_setdirection(self, direction):
|
|
if (type(direction) != int) and (type(direction) != str): raise TypeError(direction)
|
|
|
|
if type(direction) == int:
|
|
# mode is 0 (RISE), 1 (FALL) or 2 (RISE&FALL)
|
|
if not (direction in (0,1,2)):
|
|
raise ValueError(direction)
|
|
|
|
else:
|
|
# string based
|
|
|
|
# make uppercase
|
|
direction=direction.upper()
|
|
|
|
# spme shortcuts:
|
|
if direction == "RISEFALL": direction = "RISE&FALL"
|
|
if direction == "BOTH": direction = "RISE&FALL"
|
|
|
|
try:
|
|
direction=jds6600.__sweep_direction.index(direction)
|
|
except ValueError:
|
|
errmsg="Unknown sweep direction: "+direction
|
|
raise ValueError(errmsg)
|
|
# end else - for
|
|
# end else ) if (type is int or str?)
|
|
|
|
# set mode
|
|
self.__sendwritecmd(jds6600.SWEEP_DIRECTION,direction)
|
|
# end set direction (sweep)
|
|
|
|
|
|
def sweep_setmode(self, mode):
|
|
if (type(mode) != int) and (type(mode) != str): raise TypeError(mode)
|
|
|
|
if type(mode) == int:
|
|
# mode is 0 (LINEAR) or 1 (LOGARITHM))
|
|
if not (mode in (0,1)):
|
|
raise ValueError(mode)
|
|
|
|
else:
|
|
# string based
|
|
|
|
# make uppercase
|
|
mode=mode.upper()
|
|
|
|
# spme shortcuts:
|
|
if mode == "LIN": mode = "LINEAR"
|
|
if mode == "LOG": mode = "LOGARITHM"
|
|
|
|
try:
|
|
mode=jds6600.__sweep_mode.index(mode)
|
|
except ValueError:
|
|
errmsg="Unknown sweep mode: "+mode
|
|
raise ValueError(errmsg)
|
|
# end else - for
|
|
# end else ) if (type is int or str?)
|
|
|
|
# set mode
|
|
self.__sendwritecmd(jds6600.SWEEP_MODE,mode)
|
|
# end set direction (sweep)
|
|
|
|
|
|
|
|
|
|
# get sweep channel
|
|
def sweep_getchannel(self):
|
|
mode=self.getmode()
|
|
|
|
if mode[1] == "SWEEP_CH1":
|
|
return 1
|
|
elif mode[1] == "SWEEP_CH2":
|
|
return 2
|
|
# end if - elif
|
|
|
|
# not channel 1 or channel 2, return 0
|
|
return 0
|
|
# end sweep get_channel
|
|
|
|
# set sweep channel
|
|
def sweep_setchannel(self,channel):
|
|
if type(channel) != int: raise TypeError(channel)
|
|
|
|
# new channel should be 1 or 2
|
|
if not (channel in (1,2)):
|
|
raise ValueError(channel)
|
|
# end if
|
|
|
|
# get current channel (1 or 2, or 0 if not in sweep mode)
|
|
currentchannel=self.sweep_getchannel()
|
|
|
|
# only swich if already in sweep mode
|
|
if currentchannel == 0:
|
|
raise WrongMode()
|
|
#endif
|
|
|
|
# switch if the new channel is different from current channel
|
|
if channel != currentchannel:
|
|
if channel == 1:
|
|
self.setmode("SWEEP_CH1",nostop=True)
|
|
else:
|
|
self.setmode("SWEEP_CH2",nostop=True)
|
|
# end else - if
|
|
# end if
|
|
# end sweep set channel
|
|
|
|
|
|
# start sweep
|
|
def sweep_start(self):
|
|
mode=self.getmode()
|
|
|
|
if (mode[1] != "SWEEP_CH1") and (mode[1] != "SWEEP_CH2"):
|
|
raise WrongMode()
|
|
# end if
|
|
|
|
# action start BURST mode
|
|
self.__setaction("SWEEP")
|
|
# end sweep_start
|
|
|
|
|
|
# stop sweep
|
|
def sweep_stop(self):
|
|
# just send stop
|
|
self.__setaction("STOP")
|
|
# end sweep_start
|
|
|
|
|
|
|
|
##################################
|
|
|
|
|
|
#######################
|
|
# Part 9: PULSE
|
|
|
|
|
|
# get pulsewidth, normalised to s
|
|
def pulse_getpulsewidth(self):
|
|
# pulsewith returns two datafiels, periode + multiplier
|
|
time,multi = self.__getdata(jds6600.PULSE_PULSEWIDTH)
|
|
|
|
if multi==0: return time / 1000000000 # ns
|
|
elif multi == 1: return time / 1000000 # us
|
|
else:
|
|
UnexptectedValue(multi)
|
|
# end else - elsif - if
|
|
# end
|
|
|
|
# get pulsewidth, not normalised
|
|
def pulse_getpulsewidth_m(self):
|
|
# pulsewith returns two datafiels, periode + multiplier
|
|
return self.__getdata(jds6600.PULSE_PULSEWIDTH)
|
|
# end
|
|
|
|
|
|
# get period, normalised to s
|
|
def pulse_getperiod(self):
|
|
# period returns two datafiels, periode + multiplier
|
|
time,multi = self.__getdata(jds6600.PULSE_PERIOD)
|
|
|
|
if multi==0: return time / 1000000000 # ns
|
|
elif multi == 1: return time / 1000000 # us
|
|
else:
|
|
UnexptectedValue(multi)
|
|
# end else - elsif - if
|
|
# end
|
|
|
|
|
|
# get period, not normalised
|
|
def pulse_getperiod_m(self):
|
|
# period returns two datafiels, periode + multiplier
|
|
return self.__getdata(jds6600.PULSE_PERIOD)
|
|
# end
|
|
|
|
# get offset
|
|
def pulse_getoffset(self):
|
|
# unit is %, just return data
|
|
return self.__getdata(jds6600.PULSE_OFFSET)
|
|
# end
|
|
|
|
# get amplitude
|
|
def pulse_getamplitude(self):
|
|
# unit 0.01, divide by 100
|
|
return self.__getdata(jds6600.PULSE_AMPLITUDE)/100
|
|
# end
|
|
|
|
# set pulsewith or period (backend function)
|
|
def __pulse_setpw_period(self, var, data, multiplier, normalised):
|
|
maxval=([4e9,4e9],(4,4000)) # maximum data value
|
|
minval=((30,1),(30e-9,1e-6)) # minimum data value
|
|
multi=(1e9,1e6) # unit is 1ns or 1 us
|
|
data2reg=(jds6600.PULSE_PULSEWIDTH,jds6600.PULSE_PERIOD)
|
|
data2txt=("pulsewidth","period")
|
|
|
|
if (type(var) != int) or ((var != 0) and (var != 1)): raise RuntimeError("error __pulse_setpw_period: var") # var is 0 (for pulsewidth) or 1 (period)
|
|
if (type(data) != int) and (type(data) != float): raise TypeError(period)
|
|
if (type(normalised) != int) or not (normalised in (0,1)): raise RuntimeError("error __pulse_setpw_period: normalised")
|
|
|
|
if type(multiplier) != int: raise TypeError(multiplier)
|
|
|
|
# multiplier should be 0 or 1
|
|
if not (multiplier in (0,1)):
|
|
errmsg="multiplier must be 0 (ns) or 1 (us)"
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
|
|
# data must be between to allocated limits:
|
|
# not normalised: allowed values: 30 to 400000000 (multi=0) / 1 to 4000000000 (multi=1)
|
|
# normalised: allowed values: 30 ns to 4 sec. (multi=0) / 1 us to 4000 sec (multi=2)
|
|
if not (minval[normalised][multiplier] <= data <= maxval[normalised][multiplier]):
|
|
errmsg="{} must be between {} and {}".format(data2txt[var],minval[normalised][multiplier],maxval[normalised][multiplier])
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
|
|
|
|
# convert from s to ns/us, if needed
|
|
if normalised == 1:
|
|
data = str(round(data * multi[multiplier]))+","+str(multiplier)
|
|
else:
|
|
data = str(int(data))+","+str(multiplier)
|
|
# end if
|
|
|
|
# done: now write
|
|
self.__sendwritecmd(data2reg[var],data)
|
|
# end set pw/period, low-level function
|
|
|
|
|
|
# set pw, normalised
|
|
def pulse_setpulsewidth(self,pw,multiplier=0):
|
|
# convert to low-level function
|
|
self.__pulse_setpw_period(0,pw,multiplier,1)
|
|
# end pulse_setpw (normalised)
|
|
|
|
# set pw, not normalised
|
|
def pulse_setpulsewidth_m(self,pw,multiplier):
|
|
# convert to low-level function
|
|
self.__pulse_setpw_period(0,pw,multiplier,0)
|
|
# end pulse_setpw (normalised)
|
|
|
|
# set period, normalised
|
|
def pulse_setperiod(self,pw,multiplier=0):
|
|
# convert to low-level function
|
|
self.__pulse_setpw_period(1,pw,multiplier,1)
|
|
# end pulse_setperiod (normalised)
|
|
|
|
# set period, not normalised
|
|
def pulse_setperiod_m(self,pw,multiplier):
|
|
# convert to low-level function
|
|
self.__pulse_setpw_period(1,pw,multiplier,0)
|
|
# end pulse_setperiod (normalised)
|
|
|
|
|
|
# set pulse offset
|
|
def pulse_setoffset(self,offset):
|
|
if (type(offset) != int) and (type(offset) != float): raise TypeError(offset)
|
|
|
|
# offset is between 0 and 120 %
|
|
if not (0 <= offset <= 120):
|
|
errmsg="Offset must be between 0 and 120 %"
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
|
|
# unit = 1 -> just send
|
|
self.__sendwritecmd(jds6600.PULSE_OFFSET,offset)
|
|
# end off
|
|
|
|
|
|
# set pulse amplitude
|
|
def pulse_setamplitude(self,amplitude):
|
|
if (type(amplitude) != int) and (type(amplitude) != float): raise TypeError(amplitude)
|
|
|
|
# amplitude is between 0 and 10 V
|
|
if not (0 <= amplitude <= 10):
|
|
errmsg="Amplitude must be between 0 and 10 Volt"
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
|
|
# unit is 0.01V
|
|
amplitude=int(round(amplitude*100))
|
|
self.__sendwritecmd(jds6600.PULSE_AMPLITUDE,amplitude)
|
|
# end off
|
|
|
|
|
|
def pulse_start(self):
|
|
mode=self.getmode()
|
|
|
|
if mode[1] != "PULSE":
|
|
raise WrongMode()
|
|
# end if
|
|
|
|
# action start BURST mode
|
|
self.__setaction("PULSE")
|
|
# end pulse_start
|
|
|
|
|
|
def pulse_stop(self):
|
|
# just send stop
|
|
self.__setaction("STOP")
|
|
# end pulse_stop
|
|
|
|
|
|
#######################
|
|
# Part 10: BURST
|
|
|
|
|
|
def burst_getnumberofbursts(self):
|
|
# unit is 1, just return value
|
|
return self.__getdata(jds6600.BURST_NUMBER)
|
|
# end burst get number of bursts
|
|
|
|
def burst_getmode(self):
|
|
mode = self.__getdata(jds6600.BURST_MODE)
|
|
|
|
try:
|
|
return(mode,jds6600.__burst_mode[mode])
|
|
except IndexError:
|
|
raise UnexpectedValue(mode)
|
|
|
|
# end try
|
|
# end burst get mode
|
|
|
|
|
|
def burst_setnumberofbursts(self,burst):
|
|
if type(burst) != int: raise TypeError(burst)
|
|
|
|
# number of burst should be between 1 and 1048575
|
|
if not (1 <= burst <= 1048575):
|
|
errmsg="Number of bursts should be between 1 and 1048575"
|
|
raise ValueError(errmsg)
|
|
# end if
|
|
|
|
# unit is 1, just return value
|
|
self.__sendwritecmd(jds6600.BURST_NUMBER,burst)
|
|
# end burst get number of bursts
|
|
|
|
|
|
def burst_setmode(self,mode):
|
|
if (type(mode) != int) and (type(mode) != str): raise TypeError(mode)
|
|
|
|
if type(mode) == int:
|
|
# mode input is an integer
|
|
# mode should be between 0 and 3
|
|
if not (0 <= mode <= 3):
|
|
errmsg="Burst mode should between 0 and 3"
|
|
raise ValueError(mode)
|
|
# end if
|
|
else:
|
|
# mode input is a string
|
|
|
|
mode=mode.upper()
|
|
|
|
# shortcuts
|
|
if mode == "MANUAL": mode = "MANUAL TRIG."
|
|
if mode == "CH2": mode = "CH2 TRIG."
|
|
if mode == "EXT.AC": mode = "EXT.TRIG(AC)"
|
|
if mode == "EXT.DC": mode = "EXT.TRIG(DC)"
|
|
|
|
try:
|
|
mode=jds6600.__burst_mode.index(mode.upper())
|
|
except ValueError:
|
|
errmsg="Unknown burst mode: "+mode
|
|
raise ValueError(errmsg)
|
|
# end try
|
|
|
|
# end else - if
|
|
|
|
# stop if the burst-mode is running
|
|
self.burst_stop()
|
|
|
|
# write command
|
|
self.__sendwritecmd(jds6600.BURST_MODE,mode)
|
|
|
|
def burst_resetcounter(self):
|
|
# reset counter: same as counter_reset_counter
|
|
self.counter_reset()
|
|
# end reset counter
|
|
|
|
|
|
def burst_start(self):
|
|
mode=self.getmode()
|
|
|
|
if mode[1] != "BURST":
|
|
raise WrongMode()
|
|
# end if
|
|
|
|
# action start BURST mode
|
|
self.__setaction("BURST")
|
|
# end burst_start
|
|
|
|
|
|
def burst_stop(self):
|
|
# just send stop
|
|
self.__setaction("STOP")
|
|
# end burst_start
|
|
|
|
#######################
|
|
# Part 11: SYSTEM
|
|
|
|
########
|
|
# part 11.1: system parameters
|
|
|
|
# NOTE: there is a strange behaviour in some jds6600 devices where that the register to
|
|
# read the sysem-parameters is one higher then the registernumber use to write
|
|
# the parameter-value.
|
|
# This is probably a bug. The bug-fix code to deal with this situation can be
|
|
# be overwriten adding a "bugfix=0" option in the system_get* API-calls
|
|
|
|
# get sound setting
|
|
def system_getsound(self, bugfix=True):
|
|
if bugfix == True:
|
|
sound=self.__getdata(jds6600.SYSTEM_SOUND+1)
|
|
elif bugfix == False:
|
|
sound=self.__getdata(jds6600.SYSTEM_SOUND)
|
|
else: TypeError(bugfix)
|
|
|
|
# we should receive a 0 or 1
|
|
try:
|
|
return (False,True)[sound]
|
|
except IndexError:
|
|
raise UnexpectedValueError(sound)
|
|
#end system_getsound
|
|
|
|
# get brightness setting
|
|
def system_getbrightness(self, bugfix=True):
|
|
if bugfix == True:
|
|
return self.__getdata(jds6600.SYSTEM_BRIGHTNESS+1)
|
|
elif bugfix == False:
|
|
return self.__getdata(jds6600.SYSTEM_BRIGHTNESS)
|
|
else: TypeError(bugfix)
|
|
#end system_getbrightness
|
|
|
|
# get language setting
|
|
def system_getlanguage(self, bugfix=True):
|
|
if bugfix == True:
|
|
language=self.__getdata(jds6600.SYSTEM_LANGUAGE+1)
|
|
elif bugfix == False:
|
|
language=self.__getdata(jds6600.SYSTEM_LANGUAGE)
|
|
else: TypeError(bugfix)
|
|
|
|
# we should receive a 0 or a 1
|
|
try:
|
|
return language,jds6600.__system_language[language]
|
|
except KeyError:
|
|
raise UnexpectedValueError(sound)
|
|
#end system_getlanguage
|
|
|
|
def system_getsync(self, bugfix=True):
|
|
if bugfix == True:
|
|
sync=self.__getdata(jds6600.SYSTEM_SYNC+1)
|
|
elif bugfix == False:
|
|
sync=self.__getdata(jds6600.SYSTEM_SYNC)
|
|
else: TypeError(bugfix)
|
|
|
|
# returns a list of 5 fields: frequency, wave, amplitude, dutycycle and offset
|
|
if len(sync) != 5:
|
|
raise UnexpectedValueError(sync)
|
|
# end if
|
|
|
|
# return data
|
|
ret=[]
|
|
for s in sync:
|
|
if s not in (0,1): raise UnexpectedValueError(sync)
|
|
|
|
ret.append((False,True)[s])
|
|
# end for
|
|
|
|
# return data
|
|
return ret
|
|
# end system_getsync
|
|
|
|
|
|
# get maximum number of arbitrary waveforms
|
|
def system_getarbmaxnum(self, bugfix=True):
|
|
if bugfix == True:
|
|
return self.__getdata(jds6600.SYSTEM_ARBMAXNUM+1)
|
|
elif bugfix == False:
|
|
return self.__getdata(jds6600.SYSTEM_ARBMAXNUM)
|
|
else: TypeError(bugfix)
|
|
#end system_getlanguage
|
|
|
|
|
|
# set system sound
|
|
def system_setsound(self,sound):
|
|
if type(sound) != bool: raise TypeError(sound)
|
|
|
|
if sound == True:
|
|
self.__sendwritecmd(jds6600.SYSTEM_SOUND,1)
|
|
else:
|
|
self.__sendwritecmd(jds6600.SYSTEM_SOUND,0)
|
|
# end set sound
|
|
|
|
# set system brightness
|
|
def system_setbrightness(self,brightness):
|
|
if type(brightness) != int: raise TypeError(brightness)
|
|
|
|
# should be between 1 and 12
|
|
if not(1 <= brightness <= 12):
|
|
raise ValueError(brightness)
|
|
|
|
self.__sendwritecmd(jds6600.SYSTEM_BRIGHTNESS,brightness)
|
|
# end set sound
|
|
|
|
|
|
# set system language
|
|
def system_setlanguage(self,language):
|
|
if (type(language) != int) and (type(language) != str): raise TypeError(language)
|
|
|
|
if type(language) == int:
|
|
# integer
|
|
if language not in (0,1): raise ValueError(sound)
|
|
else:
|
|
# string
|
|
# shortcuts:
|
|
if language == "EN": language = "ENGLISH"
|
|
if language == "CH": language = "CHINESE"
|
|
|
|
try:
|
|
language=jds6600.__system_language.index(language.upper())
|
|
except ValueError:
|
|
errmsg="Unknown language: "+language
|
|
raise ValueError(errmsg)
|
|
# end try
|
|
# end else - if
|
|
|
|
self.__sendwritecmd(jds6600.SYSTEM_LANGUAGE,language)
|
|
|
|
# reinit "mode" to refresh screen for language change to become active
|
|
(mode,modetxt)=self.getmode()
|
|
self.setmode(mode)
|
|
# end set language
|
|
|
|
# set system sync
|
|
def system_setsync(self,freq,wave,ampl,duty,offs):
|
|
|
|
if type(freq) != bool: raise TypeError(freq)
|
|
if type(wave) != bool: raise TypeError(wave)
|
|
if type(ampl) != bool: raise TypeError(ampl)
|
|
if type(duty) != bool: raise TypeError(duty)
|
|
if type(offs) != bool: raise TypeError(offs)
|
|
|
|
# create command to send
|
|
sync=[freq,wave,ampl,duty,offs]
|
|
for i in range(5):
|
|
sync[i] = '1' if sync[i] == True else '0'
|
|
|
|
|
|
# merge all 5 elements in one command, seperated by ","
|
|
self.__sendwritecmd(jds6600.SYSTEM_SYNC,",".join(sync))
|
|
# end set sync
|
|
|
|
# set maximum number of arbitrary waveforms
|
|
def system_setarbmaxnum(self,arbmaxnum):
|
|
if type(arbmaxnum) != int: raise TypeError(arbmaxnum)
|
|
|
|
# abrmaxnum should be between 1 and 60
|
|
if not(1 <= arbmaxnum <= 60):
|
|
raise ValueError(arbmaxnum)
|
|
|
|
self.__sendwritecmd(jds6600.SYSTEM_ARBMAXNUM,arbmaxnum)
|
|
# end set arbmaxnum
|
|
|
|
|
|
|
|
|
|
######
|
|
# part 11.2: save / read / clear profile
|
|
|
|
def system_saveprofile(self,profile):
|
|
if type(profile) != int: raise TypeError(profile)
|
|
|
|
# profile is between 0 and 99
|
|
if not(0 <= profile <= 99): raise ValueError(errmsg)
|
|
|
|
# write profile to "PROFILE_SAVE"
|
|
self.__sendwritecmd(jds6600.PROFILE_SAVE,profile)
|
|
# end profile save
|
|
|
|
def system_loadprofile(self,profile):
|
|
if type(profile) != int: raise TypeError(profile)
|
|
|
|
# profile is between 0 and 99
|
|
if not(0 <= profile <= 99): raise ValueError(errmsg)
|
|
|
|
# write profile to "PROFILE_LOAD"
|
|
self.__sendwritecmd(jds6600.PROFILE_LOAD,profile)
|
|
# end profile load
|
|
|
|
def system_clearprofile(self,profile):
|
|
if type(profile) != int: raise TypeError(profile)
|
|
|
|
# profile is between 0 and 99
|
|
if not(0 <= profile <= 99): raise ValueError(errmsg)
|
|
|
|
# write profile to "PROFILE_CLEAR"
|
|
self.__sendwritecmd(jds6600.PROFILE_CLEAR,profile)
|
|
# end profile clear
|
|
|
|
|
|
|
|
#######################
|
|
# Part 12: Arbitrary waveform operations
|
|
|
|
def arb_getwave(self,waveid):
|
|
if type(waveid) != int: raise TypeError(waveid)
|
|
|
|
# waveid is between 1 and 60
|
|
if not(1 <= waveid <= 60): raise ValueError(waveid)
|
|
|
|
# getdata, reg=waveform id, data = 1, a=1 (register/waveform selector)
|
|
return self.__getdata(waveid,1,a=1)
|
|
# end get arbtrary waveform
|
|
|
|
|
|
def arb_setwave(self,waveid,wave):
|
|
if type(waveid) != int: raise TypeError(waveid)
|
|
if (type(wave) != tuple) and (type(wave) != list): raise TypeError(wave)
|
|
|
|
# waveid is between 1 and 60
|
|
if not(1 <= waveid <= 60): raise ValueError(waveid)
|
|
|
|
# wave should be a list or tuple of 2048 elements, all integers, with a value between 0 and 4095
|
|
if len(wave) != 2048: raise ValueError(wave)
|
|
|
|
tosend=""
|
|
for val in wave:
|
|
if type(val) != int: raise ValueError(wave)
|
|
if not (0 <= val <= 4095): raise ValueError(wave)
|
|
|
|
tosend += (str(val) if tosend=="" else ","+str(val))
|
|
# end for
|
|
|
|
# write waveform, reg=waveform id, data = waveform, a=1 (register/waveform selector)
|
|
self.__sendwritecmd(waveid,tosend,a=1)
|
|
|
|
# end set arbirtary waveform
|
|
|
|
##################################
|
|
|
|
# end class jds6600
|