def measureImpulseResponse(fpga, scope, baseline, pulse, dacoffsettime=6, pulselength=1): """Measure the response to a DAC pulse fpga: connected fpga server scope: connected scope server dac: 'a' or 'b' returns: list list[0] : start time (s) list[1] : time step (s) list[2:]: actual data (V) """ #units clock cycles dacoffsettime = int(round(dacoffsettime)) triggerdelay = 30 looplength = 2000 pulseindex = triggerdelay - dacoffsettime scope.start_time(Value(triggerdelay, 'ns')) #calculate the baseline voltage by capturing a trace without a pulse data = np.resize(baseline, looplength) data[pulseindex:pulseindex + pulselength] = pulse data[0] |= trigger fpga.dac_run_sram(data.astype('u4'), True) data = (scope.get_trace(1)) data[0] -= Value(triggerdelay * 1e-9, 'V') # TODO: not sure about units here--pjjo return (data)
def get_trace(self, c, channel, start=1, stop=5000): """Get a trace from the scope. OUTPUT - (array voltage in volts, array time in seconds) """ ## DATA ENCODINGS ## RIB - signed, MSB first ## RPB - unsigned, MSB first ## SRI - signed, LSB first ## SRP - unsigned, LSB first wordLength = 4 #Hardcoding to set data transer word length to 2 bytes recordLength = stop - start + 1 dev = self.selectedDevice(c) #DAT:SOU - set waveform source channel yield dev.write('DAT:SOU CH%d' % channel) print '11111111' #DAT:ENC - data format (binary/ascii) yield dev.write('DAT:ENC RIB') #Set number of bytes per point yield dev.write('DAT:WID %d' % wordLength) print '222222' #Starting and stopping point yield dev.write('DAT:STAR %d' % start) yield dev.write('DAT:STOP %d' % stop) print '333333333' #Transfer waveform preamble position = yield dev.query('CH%d:POSITION?' % channel) # in units of divisions position = position.strip().split(' ')[0] #Transfer waveform data binary = yield dev.query('CURV?') #Parse waveform preamble # preamble = yield dev.query('WFMO?') # voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreambleWFMO(preamble) # print voltsPerDiv, secPerDiv, voltUnits, timeUnits voltsPerDiv = yield dev.query('CH%d:SCA?' % channel) voltsPerDiv = float(voltsPerDiv.strip()[voltsPerDiv.index('SCALE') + 5:]) secPerDiv = yield dev.query('HOR:MAI:SCA?') secPerDiv = float(secPerDiv.strip()[secPerDiv.index('SCALE') + 5:]) voltUnits = 'V' timeUnits = 's' voltUnitScaler = Value( 1, voltUnits)['mV'] # converts the units out of the scope to mV timeUnitScaler = Value(1, timeUnits)['ns'] #Parse binary # trace = _parseBinaryData(binary,wordLength = wordLength) print 'trace: ', trace[:20] trace = numpy.fromstring(binary[13:-1], dtype='<u4') #Convert from binary to volts traceVolts = (trace * (1 / 2.**31) * VERT_DIVISIONS / 2 * voltsPerDiv - float(position) * voltsPerDiv) * voltUnitScaler time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler, len(traceVolts)) #recordLength) returnValue((time, traceVolts))
def calibrateDCPulse(cxn, boardname, channel): reg = cxn.registry reg.cd(['', keys.SESSIONNAME, boardname]) fpga = cxn[FPGA_SERVER_NAME] fpga.select_device(boardname) dac_baseline = -0x2000 dac_pulse = 0x1FFF dac_neutral = 0x0000 if channel: pulse = makeSample(dac_neutral, dac_pulse) baseline = makeSample(dac_neutral, dac_baseline) else: pulse = makeSample(dac_pulse, dac_neutral) baseline = makeSample(dac_baseline, dac_neutral) #Set up the scope scope = cxn.sampling_scope scopeID = reg.get(keys.SCOPEID) print "scopeID:", scopeID p = scope.packet().\ select_device(scopeID).\ reset().\ channel(reg.get(keys.SSCOPECHANNEL, True, 2)).\ trace(1).\ record_length(5120).\ average(128).\ sensitivity(reg.get(keys.SSCOPESENSITIVITYDC, True, 200*labrad.units.mV)).\ offset(Value(0,'mV')).\ time_step(Value(5,'ns')).\ trigger_level(Value(0.18,'V')).\ trigger_positive() p.send() offsettime = reg.get(keys.TIMEOFFSET) print 'Measuring step response...' trace = measureImpulseResponse(fpga, scope, baseline, pulse, dacoffsettime=offsettime['ns'], pulselength=100) trace = trace[trace.unit] # strip units # set the output to zero so that the fridge does not warm up when the # cable is plugged back in fpga.dac_run_sram([makeSample(dac_neutral, dac_neutral)] * 20, False) ds = cxn.data_vault ds.cd(['', keys.SESSIONNAME, boardname], True) dataset = ds.new(keys.CHANNELNAMES[channel], [('Time', 'ns')], [('Voltage', '', 'V')]) ds.add_parameter(keys.TIMEOFFSET, offsettime) ds.add( np.transpose([ 1e9 * (trace[0] + trace[1] * np.arange(np.alen(trace) - 2)), trace[2:] ])) return (datasetNumber(dataset))
def connect(self, server, port): """Connect to a device""" print("Connecting to '%s' on port '%s'" % (server.name, port)) self.server = server self.ctx = server.context() self.port = port p = self.packet() p.open(port) print("opened on port '%s'" % port) self.baud = 9600 self.timeout = Value(2, 's') self.parity = 'E' self.data_bits = 7 self.stop_bits = 1 p.baudrate(self.baud) # set BAUDRATE p.read() # clear buffer p.timeout(self.timeout) # sets timeout p.parity(self.parity) p.bytesize(self.data_bits) p.stopbits(self.stop_bits) print("Connected.") yield p.send()
def zero(anr, spec, fpga, freq): """Calibrates the zeros for DAC A and B using the spectrum analyzer""" yield anr.frequency(Value(freq, 'GHz')) yield spectFreq(spec, freq) a = 0 b = 0 precision = 0x800 print ' calibrating at %g GHz...' % freq while precision > 0: al = yield measurePower(spec, fpga, a - precision, b) ar = yield measurePower(spec, fpga, a + precision, b) ac = yield measurePower(spec, fpga, a, b) corra = long(round(precision * minPos(al, ac, ar))) a += corra #print a bl = yield measurePower(spec, fpga, a, b - precision) br = yield measurePower(spec, fpga, a, b + precision) bc = yield measurePower(spec, fpga, a, b) corrb = long(round(precision * minPos(bl, bc, br))) b += corrb optprec = 2 * np.max([abs(corra), abs(corrb)]) precision /= 2 if precision > optprec: precision = optprec print ' a = %4d b = %4d uncertainty : %4d, power %6.1f dBm' % \ (a, b, precision, 10 * np.log(bc) / np.log(10.0)) returnValue([a, b])
def doSwitch(self, c, channel): cxn = self.client if type(c['device']['bits'][channel])==IntType: yield cxn[c['device']['server']].sequence([\ (c['device']['bits'][channel], True, Value(c['device']['delay'],'s')), (c['device']['bits'][channel], False, Value(c['device']['delay'],'s'))]) elif type(c['device']['bits'][channel])==ListType: # start assembling the multi-switch sequence seq = [] # open all darlington switches but the last one without any delays for i in range(len(c['device']['bits'][channel])-1): seq.append((c['device']['bits'][channel][i], True, Value(0,'s'))) # add a delay to the last one so that the mechanical switch can actuate once it has sufficient current seq.append((c['device']['bits'][channel][len(c['device']['bits'][channel])-1], True, Value(c['device']['delay'],'s'))) # close all the darlington switches afterwards for i in range(len(c['device']['bits'][channel])-1): seq.append((c['device']['bits'][channel][i], False, Value(0,'s'))) seq.append((c['device']['bits'][channel][len(c['device']['bits'][channel])-1], False, Value(c['device']['delay'],'s'))) yield cxn[c['device']['server']].sequence(seq)
def trigger_level(self, c, level = None): """Get or set the vertical zero position of a channel in voltage """ dev = self.selectedDevice(c) if level is None: resp = yield dev.query(':TRIG:EDGE:LEV?') else: yield dev.write((':TRIG:EDGE:LEV %f') %level['V']) resp = yield dev.query(':TRIG:EDGE:LEV?') level = Value(float(resp),'V') returnValue(level)
def scale(self, c, channel, scale = None): """Get or set the vertical scale per div of a channel in Volts """ dev = self.selectedDevice(c) if scale is None: resp = yield dev.query(':CHAN%d:SCAL?' %channel) else: scale = format(scale['V'],'E') yield dev.write((':CHAN%d:SCAL '+scale+' V') %channel) resp = yield dev.query(':CHAN%d:SCAL?' %channel) scale = (Value(float(resp),'V')) returnValue(scale)
def get_trace(self, c, channel, start=1, stop=10000): """Get a trace from the scope. OUTPUT - (array voltage in volts, array time in seconds) """ ## DATA ENCODINGS ## RIB - signed, MSB first ## RPB - unsigned, MSB first ## SRI - signed, LSB first ## SRP - unsigned, LSB first wordLength = 2 #Hardcoding to set data transer word length to 2 bytes recordLength = stop-start+1 dev = self.selectedDevice(c) #DAT:SOU - set waveform source channel yield dev.write('DAT:SOU CH%d' %channel) #DAT:ENC - data format (binary/ascii) yield dev.write('DAT:ENC RIB') #Set number of bytes per point yield dev.write('DAT:WID %d' %wordLength) #Starting and stopping point yield dev.write('DAT:STAR %d' %start) yield dev.write('DAT:STOP %d' %stop) #Transfer waveform preamble preamble = yield dev.query('WFMP?') position = yield dev.query('CH%d:POSITION?' %channel) # in units of divisions #Transfer waveform data binary = yield dev.query('CURV?') #Parse waveform preamble voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreamble(preamble) voltUnitScaler = Value(1, voltUnits)['mV'] # converts the units out of the scope to mV timeUnitScaler = Value(1, timeUnits)['ns'] #Parse binary trace = _parseBinaryData(binary,wordLength = wordLength) #Convert from binary to volts traceVolts = (trace * (1/32768.0) * VERT_DIVISIONS/2 * voltsPerDiv - float(position) * voltsPerDiv) * voltUnitScaler time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler,len(traceVolts))#recordLength) returnValue((time, traceVolts))
def connect(self, server, port): """Connect to a device.""" print 'connecting to "%s" on port "%s"...' % (server.name, port), self.server = server self.ctx = server.context() self.port = port p = self.packet() TIMEOUT = Value(5, 's') BAUD = 115200 p.open(port) p.baudrate(BAUD) p.read() # clear out the read buffer p.timeout(TIMEOUT) print(" CONNECTED ") yield p.send()
def sideband(anr, spect, fpga, corrector, carrierfreq, sidebandfreq): """When the IQ mixer is used for sideband mixing, imperfections in the IQ mixer and the DACs give rise to a signal not only at carrierfreq+sidebandfreq but also at carrierfreq-sidebandfreq. This routine determines amplitude and phase of the sideband signal for carrierfreq-sidebandfreq that cancels the undesired sideband at carrierfreq-sidebandfreq.""" reserveBuffer = corrector.dynamicReserve corrector.dynamicReserve = 4.0 if abs(sidebandfreq) < 3e-5: returnValue(0.0j) yield anr.frequency(Value(carrierfreq, 'GHz')) comp = 0.0j precision = 1.0 yield spectFreq(spect, carrierfreq - sidebandfreq) while precision > 2.0**-14: lR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp - precision) rR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp + precision) cR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp) corrR = precision * minPos(lR, cR, rR) comp += corrR lI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp - 1.0j * precision) rI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp + 1.0j * precision) cI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq, sidebandfreq, comp) corrI = precision * minPos(lI, cI, rI) comp += 1.0j * corrI precision = np.min( [2.0 * np.max([abs(corrR), abs(corrI)]), precision / 2.0]) print ' compensation: %.4f%+.4fj +- %.4f, opposite sb: %6.1f dBm' % \ (np.real(comp), np.imag(comp), precision, 10.0 * np.log(cI) / np.log(10.0)) corrector.dynamicReserve = reserveBuffer print '@@@@@@@@@@@@@@@' returnValue(comp)
def connect(self, server, port): """Connect to a device""" print("Connecting to '%s' on port '%s'" % (server.name, port)) self.server = server self.ctx = server.context() self.port = port p = self.packet() p.open(port) print("opened on port '%s'" % port) self.BAUDRATE = 115200 self.TIMEOUT = Value(5, 's') p.baudrate(self.BAUDRATE) # set BAUDRATE p.read() # clear buffer p.timeout(self.TIMEOUT) # sets timeout print("Connected.") yield p.send()
def measure(self, c, count=0, wait=Value(0.5, 's')): ''' returns the values from the measure function of the scope. if count >0, wait until scope has >= count stats before returning, waiting _wait_ time between calls. Note that the measurement must be set manually on the scope for this to work. ''' dev = self.selectedDevice(c) yield dev.write(":MEAS:STAT ON") def parse(s): s = s.split(',') d = [] while s: d += [[s[0]] + [float(x) for x in s[1:7]]] s = s[7:] return d d = [] while True: d = yield dev.query(":MEAS:RES?") d = parse(d) counts = [x[-1] for x in d] if min(counts) >= count: break yield util.wakeupCall(wait['s']) returnValue(d)
def sidebandScanCarrier(cxn, scanparams, boardname, corrector, use_switch=True): """Determines relative I and Q amplitudes by canceling the undesired sideband at different sideband frequencies.""" reg = cxn.registry reg.cd(['', keys.SESSIONNAME, boardname]) fpga = cxn[FPGA_SERVER_NAME] fpga.select_device(boardname) uwaveSourceID = reg.get(keys.ANRITSUID) uwaveSource = microwaveSourceServer(cxn, uwaveSourceID) spec = cxn.spectrum_analyzer_server ds = cxn.data_vault spectID = reg.get(keys.SPECTID) spec.select_device(spectID) spectInit(spec) assertSpecAnalLock(spec, spectID) uwaveSourcePower = reg.get(keys.ANRITSUPOWER) if use_switch: cxn.microwave_switch.switch(boardname) uwaveSource.select_device(uwaveSourceID) uwaveSource.amplitude(uwaveSourcePower) uwaveSource.output(True) print 'Sideband calibration from %g GHz to %g GHz in steps of %g GHz...' \ % (scanparams['carrierMin'],scanparams['carrierMax'], scanparams['sidebandCarrierStep']) sidebandfreqs = (np.arange(scanparams['sidebandFreqCount']) \ - (scanparams['sidebandFreqCount']-1) * 0.5) \ * validSBstep(scanparams['sidebandFreqStep']) dependents = [] for sidebandfreq in sidebandfreqs: dependents += [('relative compensation', 'Q at f_SB = %g MHz' % \ (sidebandfreq*1e3),''), ('relative compensation', 'I at f_SB = %g MHz' % \ (sidebandfreq*1e3),'')] ds.cd(['', keys.SESSIONNAME, boardname], True) dataset = ds.new(keys.IQNAME, [('Antritsu Frequency', 'GHz')], dependents) ds.add_parameter(keys.ANRITSUPOWER, (reg.get(keys.ANRITSUPOWER))) ds.add_parameter('Sideband frequency step', Value(scanparams['sidebandFreqStep'] * 1e3, 'MHz')) ds.add_parameter('Number of sideband frequencies', scanparams['sidebandFreqCount']) freq = scanparams['carrierMin'] while freq < scanparams['carrierMax'] + \ 0.001 * scanparams['sidebandCarrierStep']: print ' carrier frequency: %g GHz' % freq datapoint = [freq] for sidebandfreq in sidebandfreqs: print ' sideband frequency: %g GHz' % sidebandfreq comp = sideband(uwaveSource, spec, fpga, corrector, freq, sidebandfreq) datapoint += [np.real(comp), np.imag(comp)] ds.add(datapoint) freq += scanparams['sidebandCarrierStep'] uwaveSource.output(False) spectDeInit(spec) if use_switch: cxn.microwave_switch.switch(0) return (datasetNumber(dataset))
[startup] cmdline = %PYTHON% %FILE% timeout = 20 [shutdown] message = 987654321 timeout = 20 ### END NODE INFO """ from labrad.types import Value from labrad.devices import DeviceServer, DeviceWrapper from labrad.server import setting from twisted.internet.defer import inlineCallbacks, returnValue TIMEOUT = Value(1.0, 's') class TTLDevice(DeviceWrapper): @inlineCallbacks def connect(self, server, port): """Connect to a TTL device.""" print 'connecting to "%s" on port "%s"...' % (server.name, port), self.server = server self.ctx = server.context() self.port = port p = self.packet() p.open(port) p.baudrate(57600) p.read() # clear out the read buffer p.timeout(TIMEOUT)
[startup] cmdline = %PYTHON% %FILE% timeout = 5 [shutdown] message = 987654321 timeout = 5 ### END NODE INFO """ from labrad.types import Value from labrad.devices import DeviceServer, DeviceWrapper from labrad.server import setting from twisted.internet.defer import inlineCallbacks, returnValue TIMEOUT = Value(5.0, 's') API = { # name type write read 'channel': (int, 'C{}\n', 'C?\n'), # Select channel 'frequency': (float, 'f{:.8f}\n', 'f?\n'), # Frequency in MHz 'power': (float, 'W{:.3f}\n', 'W?\n'), # Power in dBm 'calibrated': (bool, None, 'V\n'), 'temp_comp_mode': (int, 'Z{}\n', 'Z?\n'), 'vga_dac': (int, 'a{}\n', 'a?\n'), # VGA DAC value [0, 45000] 'phase_step': (float, '~{:.3f}\n', '~?\n'), # Phase step in degrees 'rf_enable': (bool, 'h{}\n', 'h?\n'), 'pa_power_on': (bool, 'r{}\n', 'r?\n'), 'pll_power_on': (bool, 'E{}\n', 'E?\n'), 'model_type': (str, None, '+\n'), # Model type 'serial_number': (int, None, '-\n'), # Serial number
def sidebandScanCarrier(cxn, scanparams, boardname, corrector): """Determines relative I and Q amplitudes by canceling the undesired sideband at different sideband frequencies.""" fpga = cxn.ghz_fpgas yield fpga.select_device(boardname) spec = cxn.spectrum_analyzer_server scope = cxn.tektronix_dsa_8300_sampling_scope ds = cxn.data_vault reg = cxn.registry yield reg.cd(['', keys.SESSIONNAME, boardname]) spectID = yield reg.get(keys.SPECTID) spec.select_device(spectID) yield spectInit(spec) anritsuID = yield reg.get(keys.ANRITSUID) anritsuPower = yield reg.get(keys.ANRITSUPOWER) #yield cxn.microwave_switch.switch(boardname) anr = yield findServer(cxn, anritsuID) yield anr.select_device(anritsuID) yield anr.amplitude(anritsuPower) yield anr.output(True) print 'Sideband calibration from %g GHz to %g GHz in steps of %g GHz...' \ % (scanparams['carrierMin'],scanparams['carrierMax'], scanparams['sidebandCarrierStep']) sidebandfreqs = (np.arange(scanparams['sidebandFreqCount']) \ - (scanparams['sidebandFreqCount']-1) * 0.5) \ * validSBstep(scanparams['sidebandFreqStep']) # sidebandfreqs = [-0.325, -0.275, -0.225, -0.175, -0.125, -0.075, -0.025, 0.025, 0.075, 0.125, 0.175, 0.225, 0.275, 0.325] 20120411 LjHe dependents = [] for sidebandfreq in sidebandfreqs: dependents += [('relative compensation', 'Q at f_SB = %g MHz' % \ (sidebandfreq*1e3),''), ('relative compensation', 'I at f_SB = %g MHz' % \ (sidebandfreq*1e3),'')] yield ds.cd(['', keys.SESSIONNAME, boardname], True) dataset = yield ds.new(keys.IQNAME, [('Antritsu Frequency', 'GHz')], dependents) yield ds.add_parameter(keys.ANRITSUPOWER, (yield reg.get(keys.ANRITSUPOWER))) yield ds.add_parameter('Sideband frequency step', Value(scanparams['sidebandFreqStep'] * 1e3, 'MHz')) yield ds.add_parameter('Number of sideband frequencies', scanparams['sidebandFreqCount']) freq = scanparams['carrierMin'] while freq < scanparams['carrierMax'] + \ 0.001 * scanparams['sidebandCarrierStep']: print ' carrier frequency: %g GHz' % freq datapoint = [freq] for sidebandfreq in sidebandfreqs: print ' sideband frequency: %g GHz' % sidebandfreq comp = yield sideband(anr, spec, fpga, corrector, freq, sidebandfreq) datapoint += [np.real(comp), np.imag(comp)] yield ds.add(datapoint) freq += scanparams['sidebandCarrierStep'] yield anr.output(False) yield spectDeInit(spec) #yield cxn.microwave_switch.switch(0) returnValue(datasetNumber(dataset))
def to_type(value,type_): if type_.startswith('.'):return Value(value,type_[1:]) if type_ in ['string','str','s'] : return str(value) if type_ in ['float','f','v',''] : return float(value) if type_ in ['integer','int','i'] : return int(value) return Value(value,type_)
def toFloat(num, units): if hasattr(num, 'unit'): return num[units] elif isinstance(num, tuple): return Value(*num)[units] return num
def get_trace(self, c, channel, start=1, stop=16000, record_length=16000, numavg=128): """Get a trace from the scope. OUTPUT - (array voltage in volts, array time in seconds) record_length can be 50, 100, 250, 500, 1000, 2000, 4000, 8000, 16000 FIXME: This currently takes as a parameter and sets the number of averages. It should instead respect the number of averages set by self.average(). I think the scope can be made to do this by fiddling with the ACQUIRE:STOPAFTER series of commands. -- ERJ """ ## DATA ENCODINGS ## RIB - signed, MSB first ## RPB - unsigned, MSB first ## SRI - signed, LSB first ## SRP - unsigned, LSB first wordLength = 4 #Hardcoding to set data transer word length to 4 bytes recordLength = stop - start + 1 dev = self.selectedDevice(c) yield dev.write('ACQUIRE:STATE OFF') #DAT:SOU - set waveform source channel yield dev.write('DAT:SOU CH%d' % channel) #DAT:ENC - data format (binary/ascii) yield dev.write('DAT:ENC ASCI') yield dev.write('ACQUIRE:MODE AVERAGE') yield dev.write('ACQUIRE:NUMAVG %d' % numavg) yield dev.write('ACQUIRE:STOPAFTER COUNT %d' % numavg) yield dev.write('ACQUIRE:STOPAFTER:MODE CONDITION') #yield dev.write('ACQUIRE:STOPAFTER:CONDITION AVGComp') yield dev.write('ACQUIRE:DATA:CLEAR') #Starting and stopping point yield dev.write('DAT:STAR %d' % start) yield dev.write('DAT:STOP %d' % stop) yield dev.write('HOR:MAI:REC %d' % record_length) #Transfer waveform preamble position = yield dev.query('HOR:MAI:POS?') # in units of divisions yield dev.write('ACQUIRE:STATE ON') while True: busy = yield dev.query('BUSY?') if '1' in busy: sleep(2) else: break #Transfer waveform data stringData = yield dev.query('CURV?') trace = numpy.array(stringData.split(','), dtype='float') preamble = yield dev.query( 'WFMO?') # the preamble is always from the LAST curve sent # so its important that CURV? comes BEFORE WFMO? #Parse waveform preamble voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreamble(preamble) voltUnitScaler = Value( 1, voltUnits)['mV'] # converts the units out of the scope to mV timeUnitScaler = Value(1, timeUnits)['ns'] #Convert from binary to volts yUnit = yield dev.query('WFMO:YUNIT?') yUnit = re.search(r'"(.*?)"', yUnit).groups()[0] yUnit = Value(1.0, yUnit) yScale = yield dev.query('WFMO:YSCALE?') yScale = float(yScale) #traceVolts = (trace * (1/(2.**25)) * VERT_DIVISIONS/2 * voltsPerDiv - float(position) * voltsPerDiv) * voltUnitScaler traceVolts = trace * yUnit * yScale time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler, len(traceVolts)) #recordLength) returnValue((time, traceVolts))
def calibrateACPulse(cxn, boardname, baselineA, baselineB, use_switch=True): """Measures the impulse response of the DACs after the IQ mixer""" pulseheight = 0x1800 reg = cxn.registry reg.cd(['', keys.SESSIONNAME, boardname]) if use_switch: switch = cxn.microwave_switch uwaveSourceID = reg.get(keys.ANRITSUID) uwaveSource = microwaveSourceServer(cxn, uwaveSourceID) uwaveSourcePower = reg.get(keys.ANRITSUPOWER) carrierFreq = reg.get(keys.PULSECARRIERFREQ) sens = reg.get(keys.SCOPESENSITIVITY) offs = reg.get(keys.SCOPEOFFSET, True, Value(0, 'mV')) if use_switch: switch.switch(boardname) #Hack to select the correct microwave switch switch.switch(0) uwaveSource.select_device(uwaveSourceID) uwaveSource.frequency(carrierFreq) uwaveSource.amplitude(uwaveSourcePower) uwaveSource.output(True) #Set up the scope scope = cxn.sampling_scope scopeID = reg.get(keys.SCOPEID) scope.select_device(scopeID) p = scope.packet().\ reset().\ channel(reg.get(keys.SSCOPECHANNEL, True, 2)).\ trace(1).\ record_length(5120L).\ average(128).\ sensitivity(sens).\ offset(offs).\ time_step(Value(2,'ns')).\ trigger_level(Value(0.18,'V')).\ trigger_positive() p.send() fpga = cxn[FPGA_SERVER_NAME] fpga.select_device(boardname) offsettime = reg.get(keys.TIMEOFFSET) baseline = makeSample(baselineA, baselineB) # print "Measuring offset voltage..." # offset = (measureImpulseResponse(fpga, scope, baseline, baseline))[2:] # offset = sum(offset) / len(offset) print "Measuring pulse response DAC A..." traceA = measureImpulseResponse(fpga, scope, baseline, makeSample(baselineA + pulseheight, baselineB), dacoffsettime=offsettime['ns']) print "Measuring pulse response DAC B..." traceB = measureImpulseResponse(fpga, scope, baseline, makeSample(baselineA, baselineB + pulseheight), dacoffsettime=offsettime['ns']) starttime = traceA[0] timestep = traceA[1] if (starttime != traceB[0]) or (timestep != traceB[1]): print """Time scales are different for measurement of DAC A and B. Did you change settings on the scope during the measurement?""" exit #set output to zero fpga.dac_run_sram([baseline] * 20) uwaveSource.output(False) ds = cxn.data_vault ds.cd(['', keys.SESSIONNAME, boardname], True) dataset = ds.new(keys.PULSENAME, [('Time', 'ns')], [('Voltage', 'A', 'V'), ('Voltage', 'B', 'V')]) setupType = reg.get(keys.IQWIRING) ds.add_parameter(keys.IQWIRING, setupType) ds.add_parameter(keys.PULSECARRIERFREQ, carrierFreq) ds.add_parameter(keys.ANRITSUPOWER, uwaveSourcePower) ds.add_parameter(keys.TIMEOFFSET, offsettime) # begin unit strip party starttime = starttime[starttime.unit] # stripping units timestep = timestep[timestep.unit] # stripping units traceA = traceA[traceA.unit] # stripping units traceB = traceB[traceB.unit] # stripping units data = np.transpose(\ [1e9*(starttime+timestep*np.arange(np.alen(traceA)-2)), traceA[2:],traceB[2:]]) ds.add(data) # traceA[2:]-offset, # traceB[2:]-offset])) if np.abs(np.argmax(np.abs(traceA-np.average(traceA))) - \ np.argmax(np.abs(traceB-np.average(traceB)))) \ * timestep > 0.5e-9: print "Pulses from DAC A and B do not seem to be on top of each other!" print "Sideband calibrations based on this pulse calibration will" print "most likely mess up you sequences!" print print "Check the following pulse calibration file in the data vault:" print datasetDir(dataset) print "If the pulses are offset by more than 0.5 ns," print "bring up the board and try the pulse calibration again." print 5 return (datasetNumber(dataset))
message = 987654321 timeout = 20 ### END NODE INFO """ from labrad.server import setting, Signal from labrad.devices import DeviceServer, DeviceWrapper from twisted.internet.defer import inlineCallbacks, returnValue from twisted.internet import reactor, defer import labrad.units as units from labrad.types import Value import numpy as np import time #from exceptions import IndexError TIMEOUT = Value(5, 's') BAUD = 115200 def threeByteToIntAdc(DB1, DB2, DB3): # This gives a 16 bit integer (between +/- 2^16) return 65536 * DB1 + 256 * DB2 + DB3 def map2(x, in_min, in_max, out_min, out_max): return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min class AMI110Wrapper(DeviceWrapper): @inlineCallbacks def connect(self, server, port):
# names of server types (for classification of device type in registry) global serverNameAD5764_DCBOX; serverNameAD5764_DCBOX = "ad5764_dcbox" # ad5764 dcbox global serverNameAD5764_ACBOX; serverNameAD5764_ACBOX = "ad5764_acbox" # ad5764 acbox global serverNameAD5780_DCBOX; serverNameAD5780_DCBOX = "ad5780_dcbox" # ad5780 dcbox quad #Following servers are associated with the evaporator global serverNameRVC300; serverNameRVC300 = "RVC_server" # RVC Pressure Controller (Pressure read out and leak valve) global serverNameFTM2400; serverNameFTM2400 = "FTM_server" # Deposition Controller global serverNameValveRelayController; serverNameValveRelayController = "valve_relay_server" # Valve and Relay Controller global serverNameStepperController; serverNameStepperController = "stepper_server" # Stepper Motor Controller global serverNamePowerSupply; serverNamePowerSupply = "power_supply_server" # TDK Power Supply global IO_DELAY ;IO_DELAY = 0.1 # delay between read and write global PORT_DELAY;PORT_DELAY = 2.0 # delay after opening serial port global TIMEOUT; TIMEOUT = Value(1,'s') # timeout for reading # ports that the manager will always ignore. global blacklistedPorts blacklistedPorts = ['COM1'] class serialDeviceManager(object): def __init__(self): self.serialConnect() def serialConnect(self): """Initializes connection to LabRAD, the serial server, and the registry""" self.cxn = labrad.connect() # connect to labrad
instancename = itead_motor_server [startup] cmdline = %PYTHON% %FILE% timeout = 20 [shutdown] message = 987654321 timeout = 20 ### END NODE INFO """ from labrad.types import Value from labrad.devices import DeviceServer, DeviceWrapper from labrad.server import setting from twisted.internet.defer import inlineCallbacks, returnValue TIMEOUT = Value(5, 's') # serial read timeout BAUDRATE = 115200 class StepperController(DeviceWrapper): """ arduino dual stepper devices """ @inlineCallbacks def connect(self, server, port): """Here we make a connection to the serial server in LabRAD where all the serial communication is handled""" print 'connecting to "%s" on port "%s"...' % (server.name, port), self.server = server self.ctx = server.context( ) # grabs an identification number from the server
message = 987654321 timeout = 20 ### END NODE INFO """ from labrad.server import setting, Signal from labrad.devices import DeviceServer, DeviceWrapper from twisted.internet.defer import inlineCallbacks, returnValue from twisted.internet import reactor, defer #import labrad.units as units from labrad.types import Value #import numpy as np import time from exceptions import IndexError TIMEOUT = Value(1, 's') BAUD = 115200 def twoByteToInt(DB1, DB2): # This gives a 16 bit integer (between +/- 2^16) return 256 * DB1 + DB2 def map2(x, in_min, in_max, out_min, out_max): return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min class DAC_ADCWrapper(DeviceWrapper): channels = [0, 1, 2, 3] @inlineCallbacks