def generate_code(self, hdf5_file): # Generate the hardware instructions self.init_device_group(hdf5_file) PseudoclockDevice.generate_code(self, hdf5_file) dig_outputs, ignore = self.get_direct_outputs() pb_inst = self.convert_to_pb_inst(dig_outputs, [], {}, {}, {}) self.write_pb_inst_to_h5(pb_inst, hdf5_file)
def generate_code(self, hdf5_file): PseudoclockDevice.generate_code(self, hdf5_file) group = hdf5_file['devices'].create_group(self.name) # compress clock instructions with the same period: This will # halve the number of instructions roughly, since the PineBlaster # does not have a 'slow clock': reduced_instructions = [] for instruction in self.pseudoclock.clock: if instruction == 'WAIT': # The following period and reps indicates a wait instruction reduced_instructions.append({'period': 0, 'reps': 1}) continue reps = instruction['reps'] # period is in quantised units: period = int(round(instruction['step']/self.clock_resolution)) if reduced_instructions and reduced_instructions[-1]['period'] == period: reduced_instructions[-1]['reps'] += reps else: reduced_instructions.append({'period': period, 'reps': reps}) # The following period and reps indicates a stop instruction: reduced_instructions.append({'period': 0, 'reps': 0}) if len(reduced_instructions) > self.max_instructions: raise LabscriptError("%s %s has too many instructions. It has %d and can only support %d"%(self.description, self.name, len(reduced_instructions), self.max_instructions)) # Store these instructions to the h5 file: dtypes = [('period',int),('reps',int)] pulse_program = np.zeros(len(reduced_instructions),dtype=dtypes) for i, instruction in enumerate(reduced_instructions): pulse_program[i]['period'] = instruction['period'] pulse_program[i]['reps'] = instruction['reps'] group.create_dataset('PULSE_PROGRAM', compression = config.compression, data=pulse_program) # TODO: is this needed, the PulseBlasters don't save it... self.set_property('is_master_pseudoclock', self.is_master_pseudoclock, location='device_properties') self.set_property('stop_time', self.stop_time, location='device_properties')
def generate_code(self, hdf5_file): # Generate the hardware instructions hdf5_file.create_group('/devices/' + self.name) PseudoclockDevice.generate_code(self, hdf5_file) dig_outputs = self.direct_outputs.get_all_outputs() npg_inst = self.convert_to_npg_inst(dig_outputs) self.write_npg_inst_to_h5(npg_inst, hdf5_file)
def generate_code(self, hdf5_file): PseudoclockDevice.generate_code(self, hdf5_file) group = hdf5_file['devices'].create_group(self.name) # compress clock instructions with the same period: This will # halve the number of instructions roughly, since the PineBlaster # does not have a 'slow clock': reduced_instructions = [] current_wait_index = 0 wait_table = sorted(compiler.wait_table) if not self.is_master_pseudoclock: reduced_instructions.append({'on': 0, 'off': ((self.trigger_edge_type=='rising') << 1) + 1, 'reps': 0}) for instruction in self.pseudoclock.clock: if instruction == 'WAIT': # The following period and reps indicates a wait instruction wait_timeout = compiler.wait_table[wait_table[current_wait_index]][1] current_wait_index += 1 # The actual wait instruction. # on_counts correspond to teh number of reference clock cycles # to wait for external trigger before auto-resuming. # It overcounts by 1 here because the logic on the FPGA is different for the first reference clock cycle # (you cannot resume until the after second reference clock cycle), so we subtract 1 off the on counts # so that it times-out after the correct number of samples reduced_instructions.append({'on': round(wait_timeout/self.clock_resolution)-1, 'off': ((self.trigger_edge_type=='rising') << 1) + 1, 'reps': 0}) continue reps = instruction['reps'] # period is in quantised units: periods = int(round(instruction['step']/self.clock_resolution)) # Get the "high" half of the clock period on_period = int(periods/2) # Use the remainder to calculate the "off period" (allows slightly assymetric clock signals so to minimise timing errors) off_period = periods-on_period if reduced_instructions and reduced_instructions[-1]['on'] == on_period and reduced_instructions[-1]['off'] == off_period: reduced_instructions[-1]['reps'] += reps else: reduced_instructions.append({'on': on_period, 'off': off_period, 'reps': reps}) if len(reduced_instructions) > self.max_instructions: raise LabscriptError("%s %s has too many instructions. It has %d and can only support %d"%(self.description, self.name, len(reduced_instructions), self.max_instructions)) # Store these instructions to the h5 file: dtypes = [('on_period',np.int64),('off_period',np.int64),('reps',np.int64)] pulse_program = np.zeros(len(reduced_instructions),dtype=dtypes) for i, instruction in enumerate(reduced_instructions): pulse_program[i]['on_period'] = instruction['on'] pulse_program[i]['off_period'] = instruction['off'] pulse_program[i]['reps'] = instruction['reps'] group.create_dataset('PULSE_PROGRAM', compression = config.compression, data=pulse_program) self.set_property('is_master_pseudoclock', self.is_master_pseudoclock, location='device_properties') self.set_property('stop_time', self.stop_time, location='device_properties')
def generate_code(self, hdf5_file): from rfblaster import caspr import rfblaster.rfjuice rfjuice_folder = os.path.dirname(rfblaster.rfjuice.__file__) import rfblaster.rfjuice.const as c from rfblaster.rfjuice.cython.make_diff_table import make_diff_table from rfblaster.rfjuice.cython.compile import compileD # from rfblaster.rfjuice.compile import compileD import tempfile from subprocess import Popen, PIPE # Generate clock and save raw instructions to the h5 file: PseudoclockDevice.generate_code(self, hdf5_file) dtypes = [('time',float),('amp0',float),('freq0',float),('phase0',float),('amp1',float),('freq1',float),('phase1',float)] times = self.pseudoclock.times[self._clock_line] data = np.zeros(len(times),dtype=dtypes) data['time'] = times for dds in self.direct_outputs.child_devices: prefix, connection = dds.connection.split() data['freq%s'%connection] = dds.frequency.raw_output data['amp%s'%connection] = dds.amplitude.raw_output data['phase%s'%connection] = dds.phase.raw_output group = hdf5_file['devices'].create_group(self.name) group.create_dataset('TABLE_DATA',compression=config.compression, data=data) # Quantise the data and save it to the h5 file: quantised_dtypes = [('time',np.int64), ('amp0',np.int32), ('freq0',np.int32), ('phase0',np.int32), ('amp1',np.int32), ('freq1',np.int32), ('phase1',np.int32)] quantised_data = np.zeros(len(times),dtype=quantised_dtypes) quantised_data['time'] = np.array(c.tT*1e6*data['time']+0.5) for dds in range(2): # TODO: bounds checking # Adding 0.5 to each so that casting to integer rounds: quantised_data['freq%d'%dds] = np.array(c.fF*1e-6*data['freq%d'%dds] + 0.5) quantised_data['amp%d'%dds] = np.array((2**c.bitsA - 1)*data['amp%d'%dds] + 0.5) quantised_data['phase%d'%dds] = np.array(c.pP*data['phase%d'%dds] + 0.5) group.create_dataset('QUANTISED_DATA',compression=config.compression, data=quantised_data) # Generate some assembly code and compile it to machine code: assembly_group = group.create_group('ASSEMBLY_CODE') binary_group = group.create_group('BINARY_CODE') diff_group = group.create_group('DIFF_TABLES') # When should the RFBlaster wait for a trigger? quantised_trigger_times = np.array([c.tT*1e6*t + 0.5 for t in self.trigger_times], dtype=np.int64) for dds in range(2): abs_table = np.zeros((len(times), 4),dtype=np.int64) abs_table[:,0] = quantised_data['time'] abs_table[:,1] = quantised_data['amp%d'%dds] abs_table[:,2] = quantised_data['freq%d'%dds] abs_table[:,3] = quantised_data['phase%d'%dds] # split up the table into chunks delimited by trigger times: abs_tables = [] for i, t in enumerate(quantised_trigger_times): subtable = abs_table[abs_table[:,0] >= t] try: next_trigger_time = quantised_trigger_times[i+1] except IndexError: # No next trigger time pass else: subtable = subtable[subtable[:,0] < next_trigger_time] subtable[:,0] -= t abs_tables.append(subtable) # convert to diff tables: diff_tables = [make_diff_table(tab) for tab in abs_tables] # Create temporary files, get their paths, and close them: with tempfile.NamedTemporaryFile(delete=False) as f: temp_assembly_filepath = f.name with tempfile.NamedTemporaryFile(delete=False) as f: temp_binary_filepath = f.name try: # Compile to assembly: with open(temp_assembly_filepath,'w') as assembly_file: for i, dtab in enumerate(diff_tables): compileD(dtab, assembly_file, init=(i == 0), jump_to_start=(i == 0), jump_from_end=False, close_end=(i == len(diff_tables) - 1), local_loop_pre = str(i), set_defaults = (i==0)) # Save the assembly to the h5 file: with open(temp_assembly_filepath,) as assembly_file: assembly_code = assembly_file.read() assembly_group.create_dataset('DDS%d'%dds, data=assembly_code) for i, diff_table in enumerate(diff_tables): diff_group.create_dataset('DDS%d_difftable%d'%(dds,i), compression=config.compression, data=diff_table) # compile to binary: compilation = Popen([caspr,temp_assembly_filepath,temp_binary_filepath], stdout=PIPE, stderr=PIPE, cwd=rfjuice_folder,startupinfo=startupinfo) stdout, stderr = compilation.communicate() if compilation.returncode: print(stdout) raise LabscriptError('RFBlaster compilation exited with code %d\n\n'%compilation.returncode + 'Stdout was:\n %s\n'%stdout + 'Stderr was:\n%s\n'%stderr) # Save the binary to the h5 file: with open(temp_binary_filepath,'rb') as binary_file: binary_data = binary_file.read() # has to be numpy.string_ (string_ in this namespace, # imported from pylab) as python strings get stored # as h5py as 'variable length' strings, which 'cannot # contain embedded nulls'. Presumably our binary data # must contain nulls sometimes. So this crashes if we # don't convert to a numpy 'fixes length' string: binary_group.create_dataset('DDS%d'%dds, data=np.string_(binary_data)) finally: # Delete the temporary files: os.remove(temp_assembly_filepath) os.remove(temp_binary_filepath)
def generate_code(self, hdf5_file): """Generates the hardware instructions for the pseudoclocks. This is automatically called by the labscript compiler. Args: hdf5_file (:class:`h5py.File`): h5py file object for shot """ PseudoclockDevice.generate_code(self, hdf5_file) group = self.init_device_group(hdf5_file) current_wait_index = 0 wait_table = sorted(compiler.wait_table) # For each pseudoclock for i, pseudoclock in enumerate(self.pseudoclocks): current_wait_index = 0 # Compress clock instructions with the same half_period reduced_instructions = [] for instruction in pseudoclock.clock: if instruction == "WAIT": # If we're using the internal wait monitor, set the timeout if self.use_wait_monitor: # Get the wait timeout value wait_timeout = compiler.wait_table[ wait_table[current_wait_index]][1] current_wait_index += 1 # The following half_period and reps indicates a wait instruction reduced_instructions.append({ "half_period": round(wait_timeout / (self.clock_resolution / 2)), "reps": 0, }) continue # Else, set an indefinite wait and wait for a trigger from something else. else: # Two waits in a row are an indefinite wait reduced_instructions.append({ "half_period": 2**32 - 1, "reps": 0, }) reduced_instructions.append({ "half_period": 2**32 - 1, "reps": 0, }) # Normal instruction reps = instruction["reps"] # half_period is in quantised units: half_period = int( round(instruction["step"] / self.clock_resolution)) if ( # If there is a previous instruction reduced_instructions # And it's not a wait and reduced_instructions[-1]["reps"] != 0 # And the half_periods match and reduced_instructions[-1]["half_period"] == half_period # And the sum of the previous reps and current reps won't push it over the limit and (reduced_instructions[-1]["reps"] + reps) < (2**32 - 1)): # Combine instructions! reduced_instructions[-1]["reps"] += reps else: # New instruction reduced_instructions.append({ "half_period": half_period, "reps": reps }) # Only add this if there is room in the instruction table. The PrawnBlaster # firmware has extre room at the end for an instruction that is always 0 # and cannot be set over serial! if len(reduced_instructions) != self.max_instructions: # The following half_period and reps indicates a stop instruction: reduced_instructions.append({"half_period": 0, "reps": 0}) # Check we have not exceeded the maximum number of supported instructions # for this number of speudoclocks if len(reduced_instructions) > self.max_instructions: raise LabscriptError( f"{self.description} {self.name}.clocklines[{i}] has too many instructions. It has {len(reduced_instructions)} and can only support {self.max_instructions}" ) # Store these instructions to the h5 file: dtypes = [("half_period", int), ("reps", int)] pulse_program = np.zeros(len(reduced_instructions), dtype=dtypes) for j, instruction in enumerate(reduced_instructions): pulse_program[j]["half_period"] = instruction["half_period"] pulse_program[j]["reps"] = instruction["reps"] group.create_dataset(f"PULSE_PROGRAM_{i}", compression=config.compression, data=pulse_program) # This is needed so the BLACS worker knows whether or not to be a wait monitor self.set_property( "is_master_pseudoclock", self.is_master_pseudoclock, location="device_properties", ) self.set_property("stop_time", self.stop_time, location="device_properties")
def generate_code(self, hdf5_file): PseudoclockDevice.generate_code(self, hdf5_file) group = self.init_device_group(hdf5_file) self.set_property('stop_time', self.stop_time, location='device_properties')
def generate_code(self, hdf5_file): from rfblaster import caspr import rfblaster.rfjuice rfjuice_folder = os.path.dirname(rfblaster.rfjuice.__file__) import rfblaster.rfjuice.const as c from rfblaster.rfjuice.cython.make_diff_table import make_diff_table from rfblaster.rfjuice.cython.compile import compileD # from rfblaster.rfjuice.compile import compileD import tempfile from subprocess import Popen, PIPE # Generate clock and save raw instructions to the h5 file: PseudoclockDevice.generate_code(self, hdf5_file) dtypes = [('time',float),('amp0',float),('freq0',float),('phase0',float),('amp1',float),('freq1',float),('phase1',float)] times = self.pseudoclock.times[self._clock_line] data = np.zeros(len(times),dtype=dtypes) data['time'] = times for dds in self.direct_outputs.child_devices: prefix, connection = dds.connection.split() data['freq%s'%connection] = dds.frequency.raw_output data['amp%s'%connection] = dds.amplitude.raw_output data['phase%s'%connection] = dds.phase.raw_output group = hdf5_file['devices'].create_group(self.name) group.create_dataset('TABLE_DATA',compression=config.compression, data=data) # Quantise the data and save it to the h5 file: quantised_dtypes = [('time',np.int64), ('amp0',np.int32), ('freq0',np.int32), ('phase0',np.int32), ('amp1',np.int32), ('freq1',np.int32), ('phase1',np.int32)] quantised_data = np.zeros(len(times),dtype=quantised_dtypes) quantised_data['time'] = np.array(c.tT*1e6*data['time']+0.5) for dds in range(2): # TODO: bounds checking # Adding 0.5 to each so that casting to integer rounds: quantised_data['freq%d'%dds] = np.array(c.fF*1e-6*data['freq%d'%dds] + 0.5) quantised_data['amp%d'%dds] = np.array((2**c.bitsA - 1)*data['amp%d'%dds] + 0.5) quantised_data['phase%d'%dds] = np.array(c.pP*data['phase%d'%dds] + 0.5) group.create_dataset('QUANTISED_DATA',compression=config.compression, data=quantised_data) # Generate some assembly code and compile it to machine code: assembly_group = group.create_group('ASSEMBLY_CODE') binary_group = group.create_group('BINARY_CODE') diff_group = group.create_group('DIFF_TABLES') # When should the RFBlaster wait for a trigger? quantised_trigger_times = np.array([c.tT*1e6*t + 0.5 for t in self.trigger_times], dtype=np.int64) for dds in range(2): abs_table = np.zeros((len(times), 4),dtype=np.int64) abs_table[:,0] = quantised_data['time'] abs_table[:,1] = quantised_data['amp%d'%dds] abs_table[:,2] = quantised_data['freq%d'%dds] abs_table[:,3] = quantised_data['phase%d'%dds] # split up the table into chunks delimited by trigger times: abs_tables = [] for i, t in enumerate(quantised_trigger_times): subtable = abs_table[abs_table[:,0] >= t] try: next_trigger_time = quantised_trigger_times[i+1] except IndexError: # No next trigger time pass else: subtable = subtable[subtable[:,0] < next_trigger_time] subtable[:,0] -= t abs_tables.append(subtable) # convert to diff tables: diff_tables = [make_diff_table(tab) for tab in abs_tables] # Create temporary files, get their paths, and close them: with tempfile.NamedTemporaryFile(delete=False) as f: temp_assembly_filepath = f.name with tempfile.NamedTemporaryFile(delete=False) as f: temp_binary_filepath = f.name try: # Compile to assembly: with open(temp_assembly_filepath,'w') as assembly_file: for i, dtab in enumerate(diff_tables): compileD(dtab, assembly_file, init=(i == 0), jump_to_start=(i == 0), jump_from_end=False, close_end=(i == len(diff_tables) - 1), local_loop_pre = str(i), set_defaults = (i==0)) # Save the assembly to the h5 file: with open(temp_assembly_filepath,) as assembly_file: assembly_code = assembly_file.read() assembly_group.create_dataset('DDS%d'%dds, data=assembly_code) for i, diff_table in enumerate(diff_tables): diff_group.create_dataset('DDS%d_difftable%d'%(dds,i), compression=config.compression, data=diff_table) # compile to binary: compilation = Popen([caspr,temp_assembly_filepath,temp_binary_filepath], stdout=PIPE, stderr=PIPE, cwd=rfjuice_folder,startupinfo=startupinfo) stdout, stderr = compilation.communicate() if compilation.returncode: print stdout raise LabscriptError('RFBlaster compilation exited with code %d\n\n'%compilation.returncode + 'Stdout was:\n %s\n'%stdout + 'Stderr was:\n%s\n'%stderr) # Save the binary to the h5 file: with open(temp_binary_filepath,'rb') as binary_file: binary_data = binary_file.read() # has to be numpy.string_ (string_ in this namespace, # imported from pylab) as python strings get stored # as h5py as 'variable length' strings, which 'cannot # contain embedded nulls'. Presumably our binary data # must contain nulls sometimes. So this crashes if we # don't convert to a numpy 'fixes length' string: binary_group.create_dataset('DDS%d'%dds, data=np.string_(binary_data)) finally: # Delete the temporary files: os.remove(temp_assembly_filepath) os.remove(temp_binary_filepath)