def setV(self,c,v):
i_meas = 0
v_meas = 0
if(c != self.curchan):
self.curchan=c
msg="INST:NSEL " + str(self.curchan)
if(self.debug):
print(msg)
else:
gpib.write(self.pm2812,msg)
msg = "VOLT " + str(v)
if(self.debug):
print(msg)
else:
gpib.write(self.pm2812,msg)
time.sleep(0.5)
gpib.write(self.pm2812,"MEAS:VOLT?")
time.sleep(0.1)
v_meas=gpib.read(self.pm2812,100)
v_meas = float(v_meas.rstrip())
if(self.negative):
v_meas = -v_meas
gpib.write(self.pm2812,"MEAS:CURR?")
i_meas=gpib.read(self.pm2812,100)
i_meas = float(i_meas.rstrip())
time.sleep(.5)
return([v_meas,i_meas])
def hpsetV(self,v):
gpib.write(self.hp6633a ,"VSET " + str(v))
time.sleep(0.5)
gpib.write(self.hp6633a,"VOUT?")
time.sleep(0.1)
v_meas=gpib.read(self.hp6633a,100)
v_meas = float(v_meas.rstrip())
gpib.write(self.hp6633a,"IOUT?")
time.sleep(0.1)
i_meas=gpib.read(self.hp6633a,100)
i_meas = float(i_meas.rstrip())
return(v_meas,i_meas)
def update(self):
"""
updates the DMM;
set the mode variable appropriately:
0 = returns DMM to the local display (voltage)
1 = DMM display in TORR
2 = DMM display in buffer gas density
"""
# read voltage
self.V = float(gpib.read(self.dmm, self.__bytes__))
self.torr = (self.V - self.calib[0])\
* (self.atm/(self.calib[1]-self.calib[0]))
# read temperature
self.Tsensor.write('CDAT?\n')
self.T = float(self.Tsensor.readline())
# calculate density. 100^3 necessary to bring the density to
# 1/cm^3 that we are used to.
self.dens = (self.torr * self.pascalPerTorr) / \
(1000000 * self.boltzmann * self.T)
if self.mode == 2:
gpib.write(self.dmm, "D2%.4E %s\r\n" % (self.dens,self.BGUnit))
elif self.mode == 1:
gpib.write(self.dmm, "D2%.5f %s\r\n" % (self.torr,self.unit))
elif self.mode == 0:
gpib.write(self.dmm, "D1\n")
def read(self):
""" reads a message from remote device
Result:
(string) -- message from remote device
"""
return gpib.read(self.device, 512).rstrip()
def off(self):
gpib.write(self.smiq, ':FREQ:MODE?')
answer = gpib.read(self.smiq, 256)
if answer == 'LIST':
gpib.write(self.smiq, ':FREQ:MODE CW')
gpib.write(self.smiq, ':OUTP OFF')
gpib.write(self.smiq, '*WAI')
def get_mkr_amp(self):
"""Get marker amplitude
Return marker value in dBm
"""
gpib.write(self.device, "MA")
result = gpib.read(self.device, 8)
return float(result)
def read(self):
while True:
status = ord(gpib.serial_poll(self.dev))
#print ':', status,
if status & Poll.OUTPUT_READY != 0:
break
elif status & Poll.COMMAND_DONE != 0:
raise PARReadError("Nothing to read")
return gpib.read(self.dev, 1024)
def get_power(self,
filename='test_save_file_',
PLOT=False,
typ='BYTE',
SAVE=False):
print "ACQUIRING..."
#gpib.write(self.scope,'*IDN?')
gpib.write(self.scope, 'POWER?')
self.data = gpib.read(self.scope, 1000)
print "CHEERS!!!"
return self.data
def meas():
gpib.write(dc1, 'MEAS:CURR?')
s = gpib.read(dc1, 1000)
global t0
if t0 is None:
t0 = datetime.datetime.now()
t = datetime.timedelta(0)
else:
t = datetime.datetime.now() - t0
print('{}.{:06d},{}'.format(t.seconds, t.microseconds,
s.decode().rstrip()))
sys.stdout.flush()
def read(self, command=None, keep_open=False, decode="utf-8", **kwargs): #pylint: disable=R0912
"""Read the device and return the formatted value
Depending on the connection the return value has to be formatted and
and trailing termination characters removed.
Args:
command (:obj:`string`, optional): Command that initializes read
"""
if self._backend == 'usbtmcWR':
keep_open = True
if command is not None:
self.write(command, keep_open=True)
else:
self._open()
response = None
if self._backend == 'pySerial':
response = self._read_serialdata(decode)
elif self._backend == 'pyVISA':
if decode is None:
response = self._port.read_binary_values()
else:
response = self._port.read()
elif self._backend == 'linux-gpib':
response = gpib.read(self._port, kwargs.get("numbytes", 1024))
if decode is not None:
response = response.decode(decode)
elif self._backend == 'file':
try:
with open(self._port) as file:
response = file.read()
except OSError as error_object:
self.log.error(error_object)
response = -1
elif self._backend in ['usbtmc', 'usbtmcWR']:
if decode is None:
response = self._port.read_raw()
else:
response = self._port.read()
elif self._backend == 'vxi11':
if decode is None:
response = self._port.read_raw()
else:
response = self._port.read()
elif self._backend == 'modbus':
response = modbus_read(self._port, command, **kwargs)
if not keep_open:
self._close()
return response
def __init__(self, port='/dev/ttyUSB0', baudrate=1200,
calib=[-0.49125, 1.0613], Tident='LSCI,MODEL321', mode=0):
"""
initialize device connections and set up variables and constants
mode (0 = no change to DMM, 1 = update in torr, 2 = update in dens)
"""
# for the baratron reading and updating display
self.dmm = gpib.find('3478a')
self.__bytes__ = 32
# so that DMM knows to put something in the output buffer
gpib.read(self.dmm, self.__bytes__)
# for the temperature reading, many values hardcoded for
# Lakeshore 321 cryogenic temperature sensor
self.Tsensor = serial.Serial(port=port, baudrate=baudrate,
bytesize = 7, parity = 'O')
self.Tsensor.setTimeout(1)
self.Tsensor.flushInput()
self.Tsensor.write('*IDN?\n')
answer = self.Tsensor.readline()
if (re.match(Tident, answer) == None):
raise Exception, "LS321 ident string not matched"
# calibration factors consist of two numbers: voltage reading
# at vacuum, and voltage reading at 1 atm.
self.calib = calib
self.mode = mode
# some constants; declared here so that improved versions
# of front-ends could modify them.
self.atm = 760.0
self.unit='TORR'
self.pascalPerTorr = 133.322
self.boltzmann = 1.38065e-23
self.BGUnit='HE'
def read(self, len=512, calls=0):
try:
result = gpib.read(self.id, len).rstrip("\n")
except gpib.GpibError, e:
Logging.warning(str(e))
if str(e) == "read() failed: A read or write of data bytes has been aborted, possibly due to a timeout or reception of a device clear command.":
Logging.info("Last write didn't succeed. Resending...")
self.reset()
self.write(self.last_write)
if calls == 2:
Logging.error("Unrecoverable error. Please reboot")
raw_input("Press ENTER when done.")
exit(1)
self.reset()
result = self.read(calls=calls + 1)
def __init__(self, sad=0, timeout=13, send_eoi=1, eos_mode=0, debug=False, reset=False, interfaces=[]):
if os.geteuid() != 0:
Logging.error("You need to have root privileges to run this script.")
self.started = False
exit(1)
self.debug = debug
self.reset = reset
self.devices = {}
self.started = True
self.drivers = {}
# We go through each driver and look at the attribute DEVICES which contains all devices the driver should be loaded for.
for i in dir(Drivers.GPIB):
if i[0] != "_" and i != "GenericDriver":
driver = getattr(Drivers.GPIB, i)
if hasattr(driver, "DEVICES"):
self.drivers.update(driver.DEVICES)
if self.debug: Logging.info("Drivers for following devices have been loaded: %s" % self.drivers)
self.reset_usb_controller()
# Interface ids are used to determine which usb connections need to be reset
# Example:
"""
Bus 001 Device 006: ID 3923:709b National Instruments Corp. GPIB-USB-HS
"""
self.interfaces = ["3923:709b", "0957:0518"] + interfaces
self.reset_interfaces()
progress_bar = ProgressBar(30)
discovered = {}
for pad in range(0, 31):
id = gpib.dev(0, pad, sad, timeout, send_eoi, eos_mode)
try:
driver_avaliable = False
gpib.clear(id)
gpib.write(id, "*IDN?")
device_id = gpib.read(id, 1024).rstrip()
for i in self.drivers:
if i in device_id:
self.devices[pad] = self.drivers[i](GPIBCommunicator(id, self.reset_interfaces), device_id)
driver_avaliable = True
if not driver_avaliable:
self.devices[pad] = Drivers.GPIB.GenericDriver.GenericDriver(GPIBCommunicator(id, self.reset_interfaces), device_id)
discovered[id] = device_id
except gpib.GpibError:
pass
progress_bar.update(pad)
for i in discovered:
Logging.header("%s on %s" % (discovered[i], i - 16))
Logging.success("Discovery finished successfully!")
def read(self, len=512, calls=0):
try:
result = gpib.read(self.id, len).rstrip("\n")
except gpib.GpibError, e:
Logging.warning(str(e))
if str(
e
) == "read() failed: A read or write of data bytes has been aborted, possibly due to a timeout or reception of a device clear command.":
Logging.info("Last write didn't succeed. Resending...")
self.reset()
self.write(self.last_write)
if calls == 2:
Logging.error("Unrecoverable error. Please reboot")
raw_input("Press ENTER when done.")
exit(1)
self.reset()
result = self.read(calls=calls + 1)
def scanGpib(board):
if not has_gpib:
warnings.warn(
"Linux-GPIB is not available. ScanGpib with VISA not implemented at the moment.",
RuntimeWarning,
stacklevel=2,
)
else:
for pad in range(1, 31):
listen = gpib.listener(board, pad)
# print(board, pad, listen)
if listen:
print("GPIB" + str(board) + "::" + str(pad))
try:
ud = gpib.dev(board, pad, 0, 10, 1, 0)
if ud > 0:
gpib.write(ud, "*CLS;*IDN?")
description = gpib.read(ud, 256)
print(description.strip().decode("ascii"))
except Exception:
pass
) #set current limit. (only 25, 250, 2.5e-3, 25e-3 A)
gpib.write(picoam, "SOUR:VOLT 56.37") #set voltage, V
gpib.write(picoam, "SOUR:VOLT:STAT ON") #turn on
#monitor current
print('start monitoring!')
for icycle in range(ncycle):
print('getting data: %d/%d' % (icycle, ncycle))
vals = []
timestamp = time.time()
now = datetime.fromtimestamp(timestamp)
for imeas in range(nmeas):
gpib.write(picoam, "READ?")
time.sleep(1)
val = gpib.read(picoam, 100)
val = val[0:val.find('A')]
val = float(val) * microampere
vals.append(str(val))
filename = '%s/current%d_%04d_%02d_%02d.txt' % (path, index, now.year,
now.month, now.day)
with open(filename, mode='a') as f:
f.write(str(timestamp))
for imeas in range(nmeas):
f.write(' ' + vals[imeas])
f.write('\n')
if icycle < ncycle - 1:
print('waiting %d second...' % interval)
time.sleep(interval)
print('finished!')
def query(handle, command):
gpib.write(handle, command)
time.sleep(0.03)
response = gpib.read(handle, 200)
return response.decode('ascii').rstrip()
def _read(self) -> str:
return gpib.read(self._device_handler, 512).rstrip()
def read(self, len=512):
self.res = gpib.read(self.id, len)
return self.res
def read(self, length=512):
return gpib.read(self._handle, length)
def recv(self,size=DEFAULT_RECV_SIZE): return gpib.read(self.device,size)
def read(self, length):
# Read a number of bytes from the bus and return
# a decoded string with the results
ans = gpib.read(self.dev, length)
return ans.decode("ASCII").strip()
@author: jonathan
"""
import gpib
import numpy as np
# GPIB interface 0, address 15
con = gpib.dev(0,15)
status = gpib.write(con, "COMM_FORMAT OFF")
#status = gpib.write(con, "COMM_FORMAT OFF,WORD,BIN")
status = gpib.write(con, "COMM_HEADER OFF")
status = gpib.write(con, "*IDN?")
deviceID = gpib.read(con, 1000).decode()
print("found device: " + deviceID)
# get template
print("fetching template")
status = gpib.write(con, "TEMPLATE?")
template = ""
chunk_size = 1024
keepFetching = True
while keepFetching:
temp = gpib.read(con, chunk_size).decode()
template += temp
print("read " + np.str(len(template)) + " to " + np.str(len(template)+len(temp)))
if len(temp) < chunk_size:
# EXCLUDE ALL COMMENTED LINES
for line in cflines:
if line == '':
continue
elif line[0] == '#':
continue
else:
commands.append(line)
# IMPORT NEEDED MODULES
import gpib
# OPENING GPIB DEVICE (LASER)
herring = gpib.find("laser")
# SENDING COMMANDS TO DEVICE
for comm in commands:
gpib.write(herring, comm)
# DISPLAY SETTINGS
print('========================')
print(' NEW SETTINGS ')
print('========================')
for comm in commands:
gpib.write(herring, comm.split()[0] + ' ' + comm.split()[1])
print(
str(gpib.read(herring, 1024)).replace('b\'', '').replace('\\r\'', ''))
print('========================')
################################################################################
def read(self, bytesize=1024):
return gpib.read(self.handle, bytesize)
def _read_raw(self, num_bytes=100):
if self._gpib_used:
data = gpib.read(self._dev, num_bytes)
else:
data = self._dev.read(num_bytes)
return data
def _read(self, num_bytes=100):
if self._gpib_used:
data = gpib.read(self._dev, num_bytes)
else:
data = self._dev.readline(num_bytes)
return data.decode('ascii')
def query(self, msg, bytesize=1024):
gpib.write(self.handle, msg)
return gpib.read(self.handle, bytesize)
def _read(self, num_bytes=100):
data = gpib.read(self._dev, num_bytes)
time.sleep(self._sleep)
return data.decode('ascii')
def output(self):
gpib.write(self.smiq, ':OUTP?')
return gpib.read(self.smiq, 256)
def read(self):
ret = gpib.read(self.dev, 256).strip()
return ret
def query(self, msg, bytesize=1024):
gpib.write(self.handle, msg)
return gpib.read(self.handle, bytesize)
def read(self, len=512):
self.res = gpib.read(self.id, len)
return self.res
def read(self, bytesize=1024):
return gpib.read(self.handle, bytesize)
def read(self, numbytes):
"""Read the GPIB bus for a given number of bytes."""
return gpib.read(self.scope, numbytes)
def _read(self):
return gpib.read(self._dev, 512)
def query(handle, command, numbytes=100):
gpib.write(handle, command)
response = gpib.read(handle, numbytes)
response = response.rstrip("\r\n")
return response
def read(self, length=self.read_length): """Read from the gpib device, number of characters, defined by read_length""" return gpib.read(self.device, length)
def leer(self):
aa = gpib.read(self.equipo, 13)
return float(aa)
def __init__(self,
sad=0,
timeout=13,
send_eoi=1,
eos_mode=0,
debug=False,
reset=False,
interfaces=[]):
if os.geteuid() != 0:
Logging.error(
"You need to have root privileges to run this script.")
self.started = False
exit(1)
self.debug = debug
self.reset = reset
self.devices = {}
self.started = True
self.drivers = {}
# We go through each driver and look at the attribute DEVICES which contains all devices the driver should be loaded for.
for i in dir(Drivers.GPIB):
if i[0] != "_" and i != "GenericDriver":
driver = getattr(Drivers.GPIB, i)
if hasattr(driver, "DEVICES"):
self.drivers.update(driver.DEVICES)
if self.debug:
Logging.info("Drivers for following devices have been loaded: %s" %
self.drivers)
self.reset_usb_controller()
# Interface ids are used to determine which usb connections need to be reset
# Example:
"""
Bus 001 Device 006: ID 3923:709b National Instruments Corp. GPIB-USB-HS
"""
self.interfaces = ["3923:709b", "0957:0518"] + interfaces
self.reset_interfaces()
progress_bar = ProgressBar(30)
discovered = {}
for pad in range(0, 31):
id = gpib.dev(0, pad, sad, timeout, send_eoi, eos_mode)
try:
driver_avaliable = False
gpib.clear(id)
gpib.write(id, "*IDN?")
device_id = gpib.read(id, 1024).rstrip()
for i in self.drivers:
if i in device_id:
self.devices[pad] = self.drivers[i](GPIBCommunicator(
id, self.reset_interfaces), device_id)
driver_avaliable = True
if not driver_avaliable:
self.devices[
pad] = Drivers.GPIB.GenericDriver.GenericDriver(
GPIBCommunicator(id, self.reset_interfaces),
device_id)
discovered[id] = device_id
except gpib.GpibError:
pass
progress_bar.update(pad)
for i in discovered:
Logging.header("%s on %s" % (discovered[i], i - 16))
Logging.success("Discovery finished successfully!")
def power(self, power=None):
if power != None:
print(power)
gpib.write(self.smiq, ':POW '+str(power))
gpib.write(self.smiq, ':POW?')
return float(gpib.read(self.smiq, 256))
def query(handle, command, numbytes=100):
gpib.write(handle, command)
time.sleep(0.1)
response = gpib.read(handle, numbytes)
return response
def read( self, length = 512 ): data = gpib.read( self.__interface, length ) return data
def freq(self, freq=None):
if freq != None:
gpib.write(self.smiq, ':FREQ '+str(freq))
gpib.write(self.smiq, '*WAI')
gpib.write(self.smiq, ':FREQ?')
return float(gpib.read(self.smiq, 256))
def meas():
gpib.write(dc1, 'MEAS:CURR?')
s = gpib.read(dc1, 1000)
global t0
if t0 is None:
t0 = datetime.datetime.now()
t = datetime.timedelta(0)
else:
t = datetime.datetime.now() - t0
print('{}.{:06d},{}'.format(t.seconds, t.microseconds,
s.decode().rstrip()))
sys.stdout.flush()
gpib.write(dc1, '*IDN?')
s = gpib.read(dc1, 1000)
print('#', s.decode().rstrip())
gpib.write(dc1, 'SENS:CURR:DET DC')
gpib.write(dc1, 'SENS:CURR:DET?')
s = gpib.read(dc1, 1000)
print('#', s.decode().rstrip())
gpib.write(dc1, 'VOLT 5.0')
gpib.write(dc1, 'VOLT?')
s = gpib.read(dc1, 1000)
print('#', s.decode().rstrip(), 'V')
gpib.write(dc1, 'CURR 2.0')
gpib.write(dc1, 'CURR?')
s = gpib.read(dc1, 1000)
def query(handle, command, numbytes=100):
gpib.write(handle, command)
time.sleep(0.1)
response = gpib.read(handle, numbytes)
return response
def read(self,len=512):
self.res = gpib.read(self.id,len)
return self.res.replace('\n','').replace('\r','')
def read(self):
ret = gpib.read(self.dev, 256).strip()
return ret
