def set_cap_mem_values(cap_mem, values):
for key, row in cap_mem_key_map.items():
fill_cap_mem_row(cap_mem, row, values[key])
# Global paramter vReset
cap_mem.set(pydls.Cap_mem_row(0),
pydls.Cap_mem_column(pydls.Neuron_index.num_neurons),
values["vReset"])
def loadConfig(self):
'''Load the configs'''
# set config for state neuron
for neuron_ind in range(dls.Neuron_index.num_neurons):
for k, v in self.capmem['neuron_params'][neuron_ind].items():
key = dict_conv.conversion_dict[k]
hp.fill_cap_mem_cell(self.chip.cap_mem, neuron_ind, key, v)
self.chip.cap_mem.set(dls.Cap_mem_row(0),
dls.Cap_mem_column(dls.Neuron_index.num_neurons),
self.capmem['global_params']['v_reset'])
if dls.get_allocated_board_ids()[0] != 'B291698':
# set config for state neurons
for stateNeuron in range(self.nStates):
for k, v in self.capmem['neuron_params'][stateNeuron].items():
key = dict_conv.conversion_dict[k]
if k == 'i_refr':
v = 1022 # minimal refractory period
# elif k == 'v_syn_in':
# v = 1022 # maximal inhibition
elif k == 'v_thresh':
v = self.capmem['neuron_params'][stateNeuron][
'v_leak'] + 100
hp.fill_cap_mem_cell(self.chip.cap_mem, stateNeuron, key,
v)
def fill_cap_mem_row(cap_mem, row, value):
for index in range(pydls.Neuron_index.num_neurons):
cap_mem.set(row, pydls.Cap_mem_column(index), value)
def fill_cap_mem_cell(cap_mem, neuron_ind, key, value):
cap_mem.set(pydls.Cap_mem_row(cap_mem_key_map[key]),
pydls.Cap_mem_column(neuron_ind), value)
def __init__(self, calibrated_config, dac_config, pulse_length):
self.connection = None
self.dac_config = dac_config
self.router = dls.Spike_router_bypass(self.recurrent_delay,
self.recurrent_address)
self.chip = dls.Chip()
self.chip.syndrv_config.pulse_length(pulse_length)
v_reset = calibrated_config['global_params']['v_reset']
for neuron_ind in range(32):
for k, v in calibrated_config['neuron_params'][neuron_ind].items():
key = dict_conv.conversion_dict[k]
hp.fill_cap_mem_cell(self.chip.cap_mem, neuron_ind, key, v)
self.chip.cap_mem.set(dls.Cap_mem_row(0),
dls.Cap_mem_column(dls.Neuron_index.num_neurons),
v_reset)
# state neuron recurrent spiking
for k, v in calibrated_config['neuron_params'][
self.stimulate_row].items():
key = dict_conv.conversion_dict[k]
if k == 'i_refr':
v = 1022 # minimal refractory period
elif k == 'v_thresh':
v = calibrated_config['neuron_params'][state_neuron][
'v_leak'] + 30
hp.fill_cap_mem_cell(self.chip.cap_mem, self.stimulate_row, key, v)
# __________________________________________________________________________
# configure neurons - setup spike counters for clear on read
for neuron_ind in range(32):
neuron = self.chip.neurons.get(dls.Neuron_index(neuron_ind))
if neuron_ind in mapping or neuron_ind == state_neuron:
neuron.fire_out_mode(dls.Neuron.Fire_out_mode.enable)
neuron.enable_out(True)
else:
neuron.fire_out_mode(dls.Neuron.Fire_out_mode.disable)
neuron.enable_out(False)
self.chip.neurons.set(dls.Neuron_index(neuron_ind), neuron)
self.chip.rate_counter.enable(dls.Neuron_index(neuron_ind), True)
self.chip.rate_counter.clear_on_read(True)
# --------------------------------------------------------------------------
# Setup synram control register
# These are magic numbers which configure the timing how the synram is
# written.
self.synram_config_reg = dls.Synram_config_reg()
self.synram_config_reg.pc_conf(1)
self.synram_config_reg.w_conf(1)
self.synram_config_reg.wait_ctr_clear(1)
self.fpga_conf = dls.Config_reg()
self.fpga_conf.spike_router_enable = True
# PPU control register
self.ppu_control_reg_start = dls.Ppu_control_reg()
self.ppu_control_reg_start.inhibit_reset(True)
self.ppu_control_reg_end = dls.Ppu_control_reg()
self.ppu_control_reg_end.inhibit_reset(False)
self.pre_builder = dls.Dls_program_builder()
self.pre_builder.set_time(0)
self.pre_builder.set_chip(self.chip)
self.pre_builder.wait_for(1000000)
self.pre_builder.halt()
self.board_id = None