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 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 read(self,len=512): self.res = gpib.read(self.id,len) return self.res.replace('\n','').replace('\r','')