def run_forever_not_recorded(): sim.setup(1.0) stim = sim.Population(1, sim.SpikeSourcePoisson(rate=10.0)) pop = sim.Population(255, sim.IF_curr_exp(tau_syn_E=1.0), label="pop") sim.Projection( stim, pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=20.0)) conn = DatabaseConnection( start_resume_callback_function=start_callback, stop_pause_callback_function=stop_callback, local_port=None) SpynnakerExternalDevicePluginManager.add_database_socket_address( conn.local_ip_address, conn.local_port, None) sim.external_devices.run_forever() sim.end()
def run_forever_recorded(): sim.setup(1.0) source_spikes = range(0, 5000, 100) stim = sim.Population(1, sim.SpikeSourceArray(source_spikes)) pop = sim.Population(255, sim.IF_curr_exp(tau_syn_E=1.0), label="pop") sim.Projection(stim, pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=20.0)) pop.record(["v", "spikes"]) conn = DatabaseConnection(start_resume_callback_function=start_callback, stop_pause_callback_function=stop_callback, local_port=None) SpynnakerExternalDevicePluginManager.add_database_socket_address( conn.local_ip_address, conn.local_port, None) sim.external_devices.run_forever() spikes = pop.get_data("spikes").segments[0].spiketrains sim.end() for spiketrain in spikes: assert (len(spiketrain) > 0) for spike, source in zip(spiketrain, source_spikes[:len(spiketrain)]): assert (spike > source) assert (spike < source + 10)
def EthernetControlPopulation(n_neurons, model, label=None, local_host=None, local_port=None, database_notify_port_num=None, database_ack_port_num=None): """ Create a PyNN population that can be included in a network to\ control an external device which is connected to the host :param n_neurons: The number of neurons in the control population :param model:\ Class of a model that creates a vertex of type\ AbstractEthernetController :param label: An optional label for the population :param local_host:\ The optional local host IP address to listen on for commands :param local_port: The optional local port to listen on for commands :param database_ack_port_num:\ The optional port to which responses to the database notification\ protocol are to be sent :param database_notify_port_num:\ The optional port to which notifications from the database\ notification protocol are to be sent :return:\ A pyNN Population which can be used as the target of a Projection.\ Note that the Population can also be used as the source of a\ Projection, but it might not send spikes. """ # pylint: disable=protected-access, too-many-arguments, too-many-locals population = Population(n_neurons, model, label=label) vertex = population._get_vertex if not isinstance(vertex, AbstractEthernetController): raise Exception( "Vertex must be an instance of AbstractEthernetController") translator = vertex.get_message_translator() live_packet_gather_label = "EthernetControlReceiver" global __ethernet_control_connection if __ethernet_control_connection is None: __ethernet_control_connection = EthernetControlConnection( translator, vertex.label, live_packet_gather_label, local_host, local_port) add_database_socket_address( __ethernet_control_connection.local_ip_address, __ethernet_control_connection.local_port, database_ack_port_num) else: __ethernet_control_connection.add_translator(vertex.label, translator) devices_with_commands = [ device for device in vertex.get_external_devices() if isinstance(device, AbstractSendMeMulticastCommandsVertex) ] if devices_with_commands: ethernet_command_connection = EthernetCommandConnection( translator, devices_with_commands, local_host, database_notify_port_num) add_database_socket_address( ethernet_command_connection.local_ip_address, ethernet_command_connection.local_port, database_ack_port_num) Plugins.update_live_packet_gather_tracker( population._vertex, live_packet_gather_label, port=__ethernet_control_connection.local_port, hostname=__ethernet_control_connection.local_ip_address, message_type=EIEIOType.KEY_PAYLOAD_32_BIT, payload_as_time_stamps=False, use_payload_prefix=False, partition_ids=vertex.get_outgoing_partition_ids()) return population
Y_BITS = 8 # Game resolution X_RESOLUTION = 160 Y_RESOLUTION = 128 # UDP port to read spikes from UDP_PORT1 = 17893 UDP_PORT2 = 17894 # Setup pyNN simulation p.setup(timestep=1.0) # Create breakout population and activate live output for it breakout_pop = p.Population(1, spinn_breakout.Breakout, {}, label="breakout") ex.activate_live_output_for(breakout_pop, host="0.0.0.0", port=UDP_PORT1) ex.activate_live_output_for(breakout_pop, host="0.0.0.0", port=UDP_PORT2) # Create spike injector to send random spikes to the paddle spike_array = [[0, 2, 4, 6, 8, 10], [1, 3, 5, 7, 9, 11]] # Connect key spike injector to breakout population # array_input = p.Population(2, p.SpikeSourceArray(spike_times=spike_array), label="input_connect") # poisson = p.SpikeSourcePoisson(rate=20) rate = {'rate': 2} #, 'duration': 10000000} spike_input = p.Population(2, p.SpikeSourcePoisson, rate, label="input_connect") p.Projection(spike_input, breakout_pop, p.AllToAllConnector(weights=2)) # key_input_connection = SpynnakerLiveSpikesConnection(send_labels=["input_connect"])
# injector from spynnaker.pyNN.models.utility_models \ import SpikeInjector as ExternalDeviceSpikeInjector # useful functions add_database_socket_address = \ SpynnakerExternalDevicePluginManager.add_database_socket_address activate_live_output_to = \ SpynnakerExternalDevicePluginManager.activate_live_output_to activate_live_output_for = \ SpynnakerExternalDevicePluginManager.activate_live_output_for logger = logging.getLogger(__name__) spynnaker_external_devices = SpynnakerExternalDevicePluginManager() __all__ = [ "EIEIOType", # General Devices "ExternalCochleaDevice", "ExternalFPGARetinaDevice", "MunichRetinaDevice", "MunichMotorDevice", "ArbitraryFPGADevice", "PushBotRetinaViewer", # Pushbot Parameters "MunichIoSpiNNakerLinkProtocol", "PushBotLaser", "PushBotLED", "PushBotMotor", "PushBotSpeaker", "PushBotRetinaResolution",
# Game resolution sampling factors x_factor1 = 2 y_factor1 = x_factor1 bricking = 1 # ----------------------------------------------------------------------------- # Create Spiking Neural Network # ----------------------------------------------------------------------------- # Create breakout population and activate live output b1 = gym.Breakout(x_factor=x_factor1, y_factor=y_factor1, bricking=bricking) breakout_pop = p.Population(b1.neurons(), b1, label="breakout1") # ex is the external device plugin manager ex.activate_live_output_for(breakout_pop) # Connect key spike injector to breakout population key_input = p.Population(2, SpikeInjector, label="key_input") key_input_connection = SpynnakerLiveSpikesConnection(send_labels=["key_input"]) p.Projection(key_input, breakout_pop, p.AllToAllConnector(), p.StaticSynapse(weight=0.1)) # Create random spike input and connect to Breakout pop to stimulate paddle # (and enable paddle visualisation) spike_input = p.Population(2, p.SpikeSourcePoisson(rate=2), label="input_connect") p.Projection(spike_input, breakout_pop, p.AllToAllConnector(), p.StaticSynapse(weight=0.1))