def __init__( self, n_neurons, machine_time_step, timescale_factor, spinnaker_link_id, speed=30, sample_time=4096, update_time=512, delay_time=5, delta_threshold=23, continue_if_not_different=True, label="RobotMotorControl"): """ """ if n_neurons != 6: logger.warn("The specified number of neurons for the munich motor" " device has been ignored; 6 will be used instead") AbstractDataSpecableVertex.__init__(self, machine_time_step, timescale_factor) AbstractPartitionableVertex.__init__(self, 6, label, 6, None) AbstractVertexWithEdgeToDependentVertices.__init__( self, [_MunichMotorDevice(spinnaker_link_id)], None) AbstractProvidesOutgoingEdgeConstraints.__init__(self) self._speed = speed self._sample_time = sample_time self._update_time = update_time self._delay_time = delay_time self._delta_threshold = delta_threshold self._continue_if_not_different = continue_if_not_different
def __init__( self, n_neurons, machine_time_step, timescale_factor, constraints=None, label="SpikeSourcePoisson", rate=1.0, start=0.0, duration=None, seed=None): AbstractPartitionableVertex.__init__( self, n_atoms=n_neurons, label=label, constraints=constraints, max_atoms_per_core=self._model_based_max_atoms_per_core) AbstractDataSpecableVertex.__init__( self, machine_time_step=machine_time_step, timescale_factor=timescale_factor) AbstractSpikeRecordable.__init__(self) ReceiveBuffersToHostBasicImpl.__init__(self) AbstractProvidesOutgoingEdgeConstraints.__init__(self) PopulationSettableChangeRequiresMapping.__init__(self) # Store the parameters self._rate = rate self._start = start self._duration = duration self._rng = numpy.random.RandomState(seed) # Prepare for recording, and to get spikes self._spike_recorder = SpikeRecorder(machine_time_step) self._spike_buffer_max_size = config.getint( "Buffers", "spike_buffer_size") self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._time_between_requests = config.getint( "Buffers", "time_between_requests")
def __init__(self, spinnaker_link_id, msg_key, msg_mask=0xFFFFFFFF): self.key = msg_key self.mask = msg_mask AbstractVirtualVertex.__init__( self, 1, spinnaker_link_id, "External IO Device", max_atoms_per_core=1) AbstractProvidesOutgoingEdgeConstraints.__init__(self)
def __init__(self): AbstractProvidesOutgoingEdgeConstraints.__init__(self) # The first partitioned edge of this population for any subvertex, # indexed by the subvertex lo atom self._first_partitioned_edge = dict() # Set of partitioned edges that have already had constraints added, # to avoid over processing self._seen_partitioned_edges = set()
def __init__(self, machine_time_step, timescale_factor): AbstractProvidesOutgoingEdgeConstraints.__init__(self) AbstractPartitionableVertex.__init__(self, 1, "Command Sender", 1) AbstractDataSpecableVertex.__init__( self, machine_time_step, timescale_factor) self._edge_constraints = dict() self._command_edge = dict() self._times_with_commands = set() self._commands_with_payloads = dict() self._commands_without_payloads = dict()
def __init__(self, n_neurons, machine_time_step, timescale_factor, label, images=None, port=12345, virtual_key=None, spikes_per_second=0, ring_buffer_sigma=None, database_socket=None, behaviour="SACCADE", max_saccade_distance=1, frames_per_microsaccade = 1, frames_per_saccade = 29, #~30 total_on_time_ms = 1000, inter_off_time_ms = 100, background_gray = 0, fps=90, mode="128", scale_img=True, polarity="MERGED", inhibition = False, inh_area_width = 2, threshold=12, adaptive_threshold = False, min_threshold=6, max_threshold=168, threshold_delta_down = 2, threshold_delta_up = 12, output_type="TIME", num_bits_per_spike=5, history_weight=0.99, save_spikes=None, local_port=19876): """ :param device_id: int for webcam modes, or string for video file :param mode: The retina "mode" :param retina_key: The value of the top 16-bits of the key :param polarity: The "polarity" of the retina data :param machine_time_step: The time step of the simulation :param timescale_factor: The timescale factor of the simulation :param label: The label for the population :param n_neurons: The number of neurons in the population """ self._loaded_idx = 0 self._total_images = 0 self._image_list = self.get_images_paths(images) fixed_n_neurons = n_neurons if mode == ExternalImageDvsEmulatorDevice.MODE_128 or \ mode == ExternalImageDvsEmulatorDevice.MODE_64 or \ mode == ExternalImageDvsEmulatorDevice.MODE_32 or \ mode == ExternalImageDvsEmulatorDevice.MODE_16: self._out_res = int(mode) else: raise exceptions.SpynnakerException("the model does not " "recongise this mode") if (polarity == ExternalImageDvsEmulatorDevice.UP_POLARITY or polarity == ExternalImageDvsEmulatorDevice.DOWN_POLARITY): fixed_n_neurons = self._out_res**2 else: fixed_n_neurons = 2*(self._out_res**2) if fixed_n_neurons != n_neurons and n_neurons is not None: logger.warn("The specified number of neurons for the DVS emulator" " device has been ignored {} will be used instead" .format(fixed_n_neurons)) self._center_x = 0 self._center_y = 0 self._max_saccade_distance = max_saccade_distance self._frames_per_microsaccade = frames_per_microsaccade self._frames_per_saccade = frames_per_saccade self._traverse_speed = (self._out_res*2.)/((total_on_time_ms/1000.)*fps) self._behaviour = behaviour self._total_on_time_ms = total_on_time_ms self._inter_off_time_ms = inter_off_time_ms self._background_gray = background_gray self._polarity = polarity self._polarity_n = ExternalImageDvsEmulatorDevice.POLARITY_DICT[polarity] self._global_max = int16(0) self._output_type = output_type self._raw_frame = None self._gray_frame = None self._tmp_frame = None self._ref_frame = 128*numpy.ones((self._out_res, self._out_res), dtype=int16) self._curr_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._moved_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._silence_frame = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._spikes_frame = numpy.zeros((self._out_res, self._out_res, 3), dtype=uint8) self._diff = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._abs_diff = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._spikes = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._adaptive_threshold = adaptive_threshold self._thresh_matrix = None if adaptive_threshold: self._thresh_matrix = numpy.zeros((self._out_res, self._out_res), dtype=int16) self._threshold_delta_down = int16(threshold_delta_down) self._threshold_delta_up = int16(threshold_delta_up) self._max_threshold = int16(max_threshold) self._min_threshold = int16(min_threshold) self._up_spikes = None self._down_spikes = None self._spikes_lists = None self._threshold = int16(threshold) self._data_shift = uint8(numpy.log2(self._out_res)) self._up_down_shift = uint8(2*self._data_shift) self._data_mask = uint8(self._out_res - 1) if self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN: self._num_bins = 8 #8-bit images don't need more elif self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN_THR: self._num_bins = 6 #should be enough? else: self._num_bins = int(1000./fps) self._num_bits_per_spike = min(num_bits_per_spike, self._num_bins) if self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN or \ self._output_type == ExternalImageDvsEmulatorDevice.OUTPUT_TIME_BIN_THR: self._log2_table = generate_log2_table(self._num_bits_per_spike, self._num_bins) else: self._log2_table = generate_log2_table(self._num_bits_per_spike, 8) #stupid hack, compatibility issues self._scale_img = scale_img self._img_height = 0 self._img_height_crop_u = 0 self._img_height_crop_b = 0 self._img_width = 0 self._img_width_crop_l = 0 self._img_width_crop_r = 0 self._img_ratio = 0. self._img_scaled_width = 0 self._scaled_width = 0 self._fps = fps self._half_frame = fps/2 self._max_time_ms = int16((1./fps)*1000) self._time_per_spike_pack_ms = self.calculate_time_per_pack() self._get_sizes = True self._scale_changed = False self._running = True self._label = label self._n_neurons = fixed_n_neurons self._local_port = local_port self._inh_area_width = inh_area_width self._inhibition = inhibition self._history_weight = history_weight ################################################################ if spinn_version == "2015.005": ReverseIpTagMultiCastSource.__init__(self, n_neurons=self._n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, port=self._local_port, label=self._label, virtual_key=virtual_key) else: ReverseIpTagMultiCastSource.__init__(self, n_keys=self._n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, label=self._label, receive_port=self._local_port, virtual_key=virtual_key) AbstractProvidesOutgoingConstraints.__init__(self) print "number of neurons for webcam = %d"%self._n_neurons self._live_conn = SpynnakerLiveSpikesConnection(send_labels = [self._label, ], local_port = self._local_port) def init(label, n_neurons, run_time_ms, machine_timestep_ms): print("Sending %d neuron sources from %s"%(n_neurons, label)) self._live_conn.add_init_callback(self._label, init) self._live_conn.add_start_callback(self._label, self.run) self._sender = None self._save_spikes = save_spikes self._spike_list = []
def __init__(self, n_neurons, machine_time_step, timescale_factor, database_socket, label, port=12345, virtual_key=None, spikes_per_second=0, ring_buffer_sigma=None, device_id=0, fps=60, mode="128", scale_img=True, polarity="MERGED", inhibition=False, inh_area_width=2, threshold=12, adaptive_threshold=False, min_threshold=6, max_threshold=168, threshold_delta_down=2, threshold_delta_up=12, output_type="TIME", num_bits_per_spike=4, history_weight=0.99, save_spikes=None, run_time_ms=None, local_port=19876): """ :param device_id: int for webcam modes, or string for video file :param mode: The retina "mode" :param retina_key: The value of the top 16-bits of the key :param polarity: The "polarity" of the retina data :param machine_time_step: The time step of the simulation :param timescale_factor: The timescale factor of the simulation :param label: The label for the population :param n_neurons: The number of neurons in the population """ fixed_n_neurons = n_neurons if mode == ExternalDvsEmulatorDevice.MODE_128 or \ mode == ExternalDvsEmulatorDevice.MODE_64 or \ mode == ExternalDvsEmulatorDevice.MODE_32 or \ mode == ExternalDvsEmulatorDevice.MODE_16: self._out_res = int(mode) self._res_2x = self._out_res * 2 else: raise exceptions.SpynnakerException("the model does not " "recongise this mode") if (polarity == ExternalDvsEmulatorDevice.UP_POLARITY or polarity == ExternalDvsEmulatorDevice.DOWN_POLARITY or polarity == ExternalDvsEmulatorDevice.RECTIFIED_POLARITY): fixed_n_neurons = self._out_res**2 else: fixed_n_neurons = 2 * (self._out_res**2) if fixed_n_neurons != n_neurons and n_neurons is not None: logger.warn( "The specified number of neurons for the DVS emulator" " device has been ignored {} will be used instead".format( fixed_n_neurons)) self._video_source = None self._device_id = device_id self._is_virtual_cam = False self._polarity = polarity self._polarity_n = ExternalDvsEmulatorDevice.POLARITY_DICT[polarity] self._global_max = int16(0) self._output_type = output_type self._raw_frame = None self._gray_frame = None self._tmp_frame = None self._ref_frame = 128 * np.ones( (self._out_res, self._out_res), dtype=int16) self._curr_frame = np.zeros((self._out_res, self._out_res), dtype=int16) self._spikes_frame = np.zeros((self._out_res, self._out_res, 3), dtype=uint8) self._diff = np.zeros((self._out_res, self._out_res), dtype=int16) self._abs_diff = np.zeros((self._out_res, self._out_res), dtype=int16) self._spikes = np.zeros((self._out_res, self._out_res), dtype=int16) self._adaptive_threshold = adaptive_threshold self._thresh_matrix = None if adaptive_threshold: self._thresh_matrix = np.zeros((self._out_res, self._out_res), dtype=int16) self._threshold_delta_down = int16(threshold_delta_down) self._threshold_delta_up = int16(threshold_delta_up) self._max_threshold = int16(max_threshold) self._min_threshold = int16(min_threshold) self._up_spikes = None self._down_spikes = None self._spikes_lists = None self._threshold = int16(threshold) self._data_shift = uint8(np.log2(self._out_res)) self._up_down_shift = uint8(2 * self._data_shift) self._data_mask = uint8(self._out_res - 1) if self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN: self._num_bins = 8 #8-bit images don't need more elif self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR: self._num_bins = 6 #should be enough? else: self._num_bins = int(1000. / fps) self._num_bits_per_spike = min(num_bits_per_spike, self._num_bins) if self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN or \ self._output_type == ExternalDvsEmulatorDevice.OUTPUT_TIME_BIN_THR: self._log2_table = gs.generate_log2_table(self._num_bits_per_spike, self._num_bins) else: self._log2_table = gs.generate_log2_table( self._num_bits_per_spike, 8) #stupid hack, compatibility issues self._scale_img = scale_img self._img_height = 0 self._img_height_crop_u = 0 self._img_height_crop_b = 0 self._img_width = 0 self._img_width_crop_l = 0 self._img_width_crop_r = 0 self._img_ratio = 0. self._img_scaled_width = 0 self._scaled_width = 0 self._fps = fps self._max_time_ms = 0 self._time_per_frame = 0. self._time_per_spike_pack_ms = 0 self._get_sizes = True self._scale_changed = False self._running = True self._label = label self._n_neurons = fixed_n_neurons self._local_port = local_port self._inh_area_width = inh_area_width self._inhibition = inhibition self._inh_coords = gs.generate_inh_coords(self._out_res, self._out_res, inh_area_width) self._history_weight = history_weight self._run_time_ms = run_time_ms ################################################################ if spinn_version == "2015.005": ReverseIpTagMultiCastSource.__init__( self, n_neurons=self._n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, port=self._local_port, label=self._label, virtual_key=virtual_key) else: ReverseIpTagMultiCastSource.__init__( self, n_keys=self._n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, label=self._label, receive_port=self._local_port, virtual_key=virtual_key) AbstractProvidesOutgoingConstraints.__init__(self) print("number of neurons for webcam = %d" % self._n_neurons) self._live_conn = SpynnakerLiveSpikesConnection( send_labels=[ self._label, ], local_port=self._local_port) def init(label, n_neurons, run_time_ms, machine_timestep_ms): print("Sending %d neuron sources from %s" % (n_neurons, label)) self._live_conn.add_init_callback(self._label, init) self._live_conn.add_start_callback(self._label, self.run) self._sender = None self._save_spikes = save_spikes
def __init__( self, n_keys, resources_required, machine_time_step, timescale_factor, label, constraints=None, # General input and output parameters board_address=None, # Live input parameters receive_port=None, receive_sdp_port=( constants.SDP_PORTS.INPUT_BUFFERING_SDP_PORT.value), receive_tag=None, # Key parameters virtual_key=None, prefix=None, prefix_type=None, check_keys=False, # Send buffer parameters send_buffer_times=None, send_buffer_max_space=( constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP), send_buffer_space_before_notify=640, send_buffer_notification_ip_address=None, send_buffer_notification_port=None, send_buffer_notification_tag=None): """ :param n_keys: The number of keys to be sent via this multicast source :param resources_required: The resources required by the vertex :param machine_time_step: The time step to be used on the machine :param timescale_factor: The time scaling to be used in the simulation :param label: The label of this vertex :param constraints: Any initial constraints to this vertex :param board_address: The IP address of the board on which to place\ this vertex if receiving data, either buffered or live (by\ default, any board is chosen) :param receive_port: The port on the board that will listen for\ incoming event packets (default is to disable this feature;\ set a value to enable it) :param receive_sdp_port: The SDP port to listen on for incoming event\ packets (defaults to 1) :param receive_tag: The IP tag to use for receiving live events\ (uses any by default) :param virtual_key: The base multicast key to send received events\ with (assigned automatically by default) :param prefix: The prefix to "or" with generated multicast keys\ (default is no prefix) :param prefix_type: Whether the prefix should apply to the upper or\ lower half of the multicast keys (default is upper half) :param check_keys: True if the keys of received events should be\ verified before sending (default False) :param send_buffer_times: An array of arrays of times at which keys\ should be sent (one array for each key, default disabled) :param send_buffer_max_space: The maximum amount of space to use of\ the SDRAM on the machine (default is 1MB) :param send_buffer_space_before_notify: The amount of space free in\ the sending buffer before the machine will ask the host for\ more data (default setting is optimised for most cases) :param send_buffer_notification_ip_address: The IP address of the host\ that will send new buffers (must be specified if a send buffer\ is specified) :param send_buffer_notification_port: The port that the host that will\ send new buffers is listening on (must be specified if a\ send buffer is specified) :param send_buffer_notification_tag: The IP tag to use to notify the\ host about space in the buffer (default is to use any tag) """ # Set up super types AbstractDataSpecableVertex.__init__( self, machine_time_step, timescale_factor) PartitionedVertex.__init__( self, resources_required, label, constraints) AbstractProvidesOutgoingEdgeConstraints.__init__(self) ReceiveBuffersToHostBasicImpl.__init__(self) # Set up for receiving live packets if receive_port is not None: self.add_constraint(TagAllocatorRequireReverseIptagConstraint( receive_port, receive_sdp_port, board_address, receive_tag)) # Work out if buffers are being sent self._first_machine_time_step = 0 self._send_buffer = None if send_buffer_times is None: self._send_buffer_times = None SendsBuffersFromHostPartitionedVertexPreBufferedImpl.__init__( self, None) else: self._send_buffer = BufferedSendingRegion(send_buffer_max_space) self._send_buffer_times = send_buffer_times self.add_constraint(TagAllocatorRequireIptagConstraint( send_buffer_notification_ip_address, send_buffer_notification_port, True, board_address, send_buffer_notification_tag)) SendsBuffersFromHostPartitionedVertexPreBufferedImpl.__init__( self, {self._REGIONS.SEND_BUFFER.value: self._send_buffer}) # buffered out parameters self._send_buffer_space_before_notify = send_buffer_space_before_notify self._send_buffer_notification_ip_address = \ send_buffer_notification_ip_address self._send_buffer_notification_port = send_buffer_notification_port self._send_buffer_notification_tag = send_buffer_notification_tag if self._send_buffer_space_before_notify > send_buffer_max_space: self._send_buffer_space_before_notify = send_buffer_max_space # Set up for recording (if requested) self._record_buffer_size = 0 self._buffer_size_before_receive = 0 # Sort out the keys to be used self._n_keys = n_keys self._virtual_key = virtual_key self._mask = None self._prefix = prefix self._prefix_type = prefix_type self._check_keys = check_keys # Work out the prefix details if self._prefix is not None: if self._prefix_type is None: self._prefix_type = EIEIOPrefix.UPPER_HALF_WORD if self._prefix_type == EIEIOPrefix.UPPER_HALF_WORD: self._prefix = prefix << 16 # If the user has specified a virtual key if self._virtual_key is not None: # check that virtual key is valid if self._virtual_key < 0: raise ConfigurationException( "Virtual keys must be positive") # Get a mask and maximum number of keys for the number of keys # requested self._mask, max_key = self._calculate_mask(n_keys) # Check that the number of keys and the virtual key don't interfere if n_keys > max_key: raise ConfigurationException( "The mask calculated from the number of keys will " "not work with the virtual key specified") if self._prefix is not None: # Check that the prefix doesn't change the virtual key in the # masked area masked_key = (self._virtual_key | self._prefix) & self._mask if self._virtual_key != masked_key: raise ConfigurationException( "The number of keys, virtual key and key prefix" " settings don't work together") else: # If no prefix was generated, generate one self._prefix_type = EIEIOPrefix.UPPER_HALF_WORD self._prefix = self._virtual_key
def __init__( self, n_neurons, machine_time_step, timescale_factor, spike_times=None, port=None, tag=None, ip_address=None, board_address=None, max_on_chip_memory_usage_for_spikes_in_bytes=(constants.SPIKE_BUFFER_SIZE_BUFFERING_IN), space_before_notification=640, constraints=None, label="SpikeSourceArray", spike_recorder_buffer_size=(constants.EIEIO_SPIKE_BUFFER_SIZE_BUFFERING_OUT), buffer_size_before_receive=(constants.EIEIO_BUFFER_SIZE_BEFORE_RECEIVE), ): self._ip_address = ip_address if ip_address is None: self._ip_address = config.get("Buffers", "receive_buffer_host") self._port = port if port is None: self._port = config.getint("Buffers", "receive_buffer_port") if spike_times is None: spike_times = [] ReverseIpTagMultiCastSource.__init__( self, n_keys=n_neurons, machine_time_step=machine_time_step, timescale_factor=timescale_factor, label=label, constraints=constraints, max_atoms_per_core=(SpikeSourceArray._model_based_max_atoms_per_core), board_address=board_address, receive_port=None, receive_sdp_port=None, receive_tag=None, virtual_key=None, prefix=None, prefix_type=None, check_keys=False, send_buffer_times=spike_times, send_buffer_max_space=max_on_chip_memory_usage_for_spikes_in_bytes, send_buffer_space_before_notify=space_before_notification, send_buffer_notification_ip_address=self._ip_address, send_buffer_notification_port=self._port, send_buffer_notification_tag=tag, ) AbstractSpikeRecordable.__init__(self) AbstractProvidesOutgoingEdgeConstraints.__init__(self) SimplePopulationSettable.__init__(self) AbstractMappable.__init__(self) AbstractHasFirstMachineTimeStep.__init__(self) # handle recording self._spike_recorder = EIEIOSpikeRecorder(machine_time_step) self._spike_recorder_buffer_size = spike_recorder_buffer_size self._buffer_size_before_receive = buffer_size_before_receive # Keep track of any previously generated buffers self._send_buffers = dict() self._spike_recording_region_size = None self._partitioned_vertices = list() self._partitioned_vertices_current_max_buffer_size = dict() # used for reset and rerun self._requires_mapping = True self._last_runtime_position = 0 self._max_on_chip_memory_usage_for_spikes = max_on_chip_memory_usage_for_spikes_in_bytes self._space_before_notification = space_before_notification if self._max_on_chip_memory_usage_for_spikes is None: self._max_on_chip_memory_usage_for_spikes = front_end_common_constants.MAX_SIZE_OF_BUFFERED_REGION_ON_CHIP # check the values do not conflict with chip memory limit if self._max_on_chip_memory_usage_for_spikes < 0: raise exceptions.ConfigurationException( "The memory usage on chip is either beyond what is supportable" " on the spinnaker board being supported or you have requested" " a negative value for a memory usage. Please correct and" " try again" ) if self._max_on_chip_memory_usage_for_spikes < self._space_before_notification: self._space_before_notification = self._max_on_chip_memory_usage_for_spikes
def __init__( self, n_neurons, binary, label, max_atoms_per_core, machine_time_step, timescale_factor, spikes_per_second, ring_buffer_sigma, model_name, neuron_model, input_type, synapse_type, threshold_type, additional_input=None, constraints=None): ReceiveBuffersToHostBasicImpl.__init__(self) AbstractPartitionableVertex.__init__( self, n_neurons, label, max_atoms_per_core, constraints) AbstractDataSpecableVertex.__init__( self, machine_time_step, timescale_factor) AbstractSpikeRecordable.__init__(self) AbstractVRecordable.__init__(self) AbstractGSynRecordable.__init__(self) AbstractProvidesOutgoingEdgeConstraints.__init__(self) AbstractProvidesIncomingEdgeConstraints.__init__(self) AbstractPopulationInitializable.__init__(self) AbstractPopulationSettable.__init__(self) AbstractMappable.__init__(self) self._binary = binary self._label = label self._machine_time_step = machine_time_step self._timescale_factor = timescale_factor self._model_name = model_name self._neuron_model = neuron_model self._input_type = input_type self._threshold_type = threshold_type self._additional_input = additional_input # Set up for recording self._spike_recorder = SpikeRecorder(machine_time_step) self._v_recorder = VRecorder(machine_time_step) self._gsyn_recorder = GsynRecorder(machine_time_step) self._spike_buffer_max_size = config.getint( "Buffers", "spike_buffer_size") self._v_buffer_max_size = config.getint( "Buffers", "v_buffer_size") self._gsyn_buffer_max_size = config.getint( "Buffers", "gsyn_buffer_size") self._buffer_size_before_receive = config.getint( "Buffers", "buffer_size_before_receive") self._time_between_requests = config.getint( "Buffers", "time_between_requests") # Set up synapse handling self._synapse_manager = SynapticManager( synapse_type, machine_time_step, ring_buffer_sigma, spikes_per_second) # Get buffering information for later use self._receive_buffer_host = config.get( "Buffers", "receive_buffer_host") self._receive_buffer_port = config.getint( "Buffers", "receive_buffer_port") self._enable_buffered_recording = config.getboolean( "Buffers", "enable_buffered_recording") # bool for if state has changed. self._change_requires_mapping = True