def setupSpikeReceiver(self, network=None):
print "\tSetting up Spike Receiver..."
networkLabels = []
for pop in network:
ExternalDevices.activate_live_output_for(pop[1], database_notify_host="localhost", database_notify_port_num=19996)
networkLabels.append(pop[1].label)
liveConnection = SpynnakerLiveSpikesConnection(receive_labels=networkLabels, local_port=19996, send_labels=None)
for label in networkLabels:
liveConnection.add_receive_callback(label, self.plotReceivedSpike)
def setupSpikeReceiver(network=None):
print "Setting up Spike Receiver..."
networkLabels = []
for pop in network:
ExternalDevices.activate_live_output_for(pop[1], database_notify_host="localhost", database_notify_port_num=19996, board_address='10.162.177.122')
networkLabels.append(pop[1].label)
if not useCVisualiser:
liveConnection = SpynnakerLiveSpikesConnection(receive_labels=networkLabels, local_port=19996, send_labels=None)
for label in networkLabels:
liveConnection.add_receive_callback(label, receiveSpike)
return liveConnection
def setupVisualiser(network=None, retinaLeft=None, retinaRight=None):
print "Setting up Visualiser..."
global retinaThreads, disparityThread, logFile
logFile = open("dipsarities.txt", 'w')
print "\tSetting up Spike Receiver..."
networkLabels = []
for pop in network:
ExternalDevices.activate_live_output_for(pop[1], database_notify_host="localhost", database_notify_port_num=19996)
networkLabels.append(pop[1].label)
liveConnection_receiver = SpynnakerLiveSpikesConnection(receive_labels=networkLabels, local_port=19996, send_labels=None)
disparityThread = spike_plotter()
for label in networkLabels:
liveConnection_receiver.add_receive_callback(label, disparityThread.plotReceivedSpike)
disparityThread.start()
print "\tSetting up Spike Injectors for Retina Left and Retina Right..."
retinaLabels = []
for popL, popR in zip(retinaLeft, retinaRight):
retinaLabels.append(popL[1].label)
retinaLabels.append(popR[1].label)
liveConnection_sender = SpynnakerLiveSpikesConnection(receive_labels=None, local_port=19999, send_labels=retinaLabels)
bg_col=pygame.Color(230,230,230,0)
on_col=pygame.Color(10,220,10,0)
off_col=pygame.Color(220,10,10,0)
retinaThreads[ports[0]] = dvs_reader(port=ports[0], colors = {"bg": bg_col, "on": on_col, "off": off_col}, label="RetL", liveConnection=liveConnection_sender)
retinaThreads[ports[1]] = dvs_reader(port=ports[1], colors = {"bg": bg_col, "on": on_col, "off": off_col}, label="RetR", liveConnection=liveConnection_sender)
liveConnection_sender.add_start_callback(retinaLabels[0], startInjecting)
panelsDrawer = Thread(target=setupPanels)
panelsDrawer.start()
class _ROS_Spinnaker_Interface(object):
"""
Transform incoming ROS Messages into spikes and inject them into the Spinnaker Board and the other way round.
a
Args:
b
n_neurons_source (int): The number of neurons of the Spike Source.
transfer_function_send (function handle): A handle to the transfer function used to convert
the ROS input data into spikes.
transfer_function_recv (function handle): A handle to the transfer function used to convert
the live spikes to a ROS value.
output_population (pynn.Population): The pyNN.Population you want to get the live spikes from.
Defaults to None, so the live output is disabled.
ros_topic_send (str): The ROS Topic used for sending into spinnaker.
Defaults to "to_spinnaker".
ros_topic_recv (str): The ROS Topic used for sending into ROS.
Defaults to "from_spinnaker".
clk_rate (int): The frequency the ROS Node is running with in Hz.
Defaults to 1000 Hz.
ros_output_rate (int): The frequency with which ros messages are sent out.
Defaults to 10 Hz.
benchmark (bool): Receive a timing output at the end of the simulation.
Defaults to False.
Attributes:
InjectorPopulation: The ExternalDevices.SpikeInjector instance which is used internally.
Functions:
is_roscore_running(): True if the ros core is runnig else False.
activate_live_output_for(pynn.Population): Set the pynn population you want to get the live spikes from.
add_simulation_start_callback(function): Register the function as callback at simulation start.
Examples:
Have a look at the ros_spinnaker_interface_example.py or other example scripts.
Notes:
This interface uses the Spinnaker LiveSpikesConnection internally with the local ports
19999 and 17895 and the spinnaker port 12345. These ports are widely used for live spikes and
therefore should'nt cause any problems, however you can also simply change them in the constructor if needed.
For each parallel interface used, these port numbers are increased by one, so the second interface will use
the local ports 20000 and 17896 and 12346 on spinnaker, etc.
If you want to change or extend this interface, consider that there is a sub process started by the
interface itself, as well as a thread controlled by spinnaker. Make sure they terminate and communicate properly.
Currently only the std_msgs.msg.Int64 type is supported for ROS Messages. If you want to use your own
ros message types it is possible, but you need to change some code yourself:
- in the _incoming_ros_package_callback unpack the ros message fields and decide what to do with it.
- in run_ros_node adjust the Publisher and Subscriber message types and (if needed) the publisher callback.
"""
_instance_counter = count(0)
def __init__(self,
n_neurons_source=None,
Spike_Source_Class=None,
Spike_Sink_Class=None,
output_population=None,
ros_topic_send='to_spinnaker',
ros_topic_recv='from_spinnaker',
clk_rate=1000,
ros_output_rate=10,
benchmark=False):
# Members
self.n_neurons = n_neurons_source if n_neurons_source is not None else 1
self._Spike_Source_Class = Spike_Source_Class
self._Spike_Sink_Class = Spike_Sink_Class
self.interface_id = self._instance_counter.next()
self._output_population = output_population
self.send_topic = ros_topic_send
self.recv_topic = ros_topic_recv
self._clk_rate = clk_rate # in Hz
self._ros_output_rate = ros_output_rate # Hz
self._benchmark = benchmark
self._injector_label = 'injector{}'.format(self.interface_id)
spike_injector_port = 12345 + self.interface_id
local_port = 19999 + self.interface_id
local_recv_port = 17895
self._database_notify_port = local_port
self._queue_ros_spinnaker = Queue()
self._queue_spinnaker_ros = Queue()
# My own "population" data structures to send and receive spikes, initialized later.
self._spike_source = None
self._spike_sink = None
send_labels = [self._injector_label]
rcv_labels = None
self.sender_active = n_neurons_source is not None and self._Spike_Source_Class is not None
self.receiver_active = self._output_population is not None and self._Spike_Sink_Class is not None
if self.receiver_active:
rcv_labels = [self._output_population.label]
self._spike_injector_population = pynn.Population(size=self.n_neurons,
cellclass=ExternalDevices.SpikeInjector,
cellparams={'port': spike_injector_port,
'database_notify_port_num':local_port},
label=self._injector_label)
self._spinnaker_connection = LiveSpikesConnection(receive_labels=rcv_labels,
local_port=local_port,
send_labels=send_labels)
self._spinnaker_connection.add_start_callback(self._injector_label, self._init_ros_node) # spinnaker thread!
if self.receiver_active:
self._spinnaker_connection.add_receive_callback(self._output_population.label, self._incoming_spike_callback)
ExternalDevices.activate_live_output_for(self._output_population,
port=local_recv_port+self.interface_id,
database_notify_port_num=self._database_notify_port)
def _init_ros_node(self, label, sender):
"""
Initialize the spike source and start the ros node.
This is started as thread from the spinnaker LiveSpikesConnection at the beginning of the simulation.
"""
timestep = 1.0 / self._clk_rate * 1000
#if the readout population consists of more than one neuron -> set the readout_pop flag
if self._output_population.size > 1:
self._readout_pop_flag = True
print('**********readout_flag_activated*************'.format(self.interface_id))
if self.sender_active:
self._spike_source = self._Spike_Source_Class(self.n_neurons,
label,
sender,
self._queue_ros_spinnaker,
timestep)
if self.receiver_active:
self._spike_sink = self._Spike_Sink_Class(len(self._output_population), # get number of neurons
self._queue_spinnaker_ros,
timestep)
if not self.is_roscore_running():
sys.exit(0)
p = Process(target=self.run_ros_node)
p.daemon = True
print("Interface {} started".format(self.interface_id))
p.start()
def run_ros_node(self):
"""
Initialize a ROS Node and subscribe and publish to the given ROS Topics.
ROS requires this function to run in its own child process.
The tick generator makes sure that it runs once per timestep.
"""
rospy.init_node('spinnaker_ros_interface{}'.format(self.interface_id), anonymous=True)
if self._readout_pop_flag:
if self.receiver_active:
publisher = rospy.Publisher(self.recv_topic, Pop_List, queue_size=10)
if self.sender_active:
rospy.Subscriber(self.send_topic, Int64, self._incoming_ros_package_callback)
else:
if self.receiver_active:
publisher = rospy.Publisher(self.recv_topic, Int64, queue_size=10)
if self.sender_active:
rospy.Subscriber(self.send_topic, Int64, self._incoming_ros_package_callback)
rospy.on_shutdown(self.on_ros_node_shutdown)
def ros_publisher_callback(event):
if not self.receiver_active:
return
try:
publisher.publish(self._spike_sink._get_ros_value())
except rospy.ROSException:
return
rospy.Timer(rospy.Duration(1.0 / self._ros_output_rate), ros_publisher_callback) # 10 Hz default
ros_timer = rospy.Rate(self._clk_rate)
self.interface_start_time = time.time()
if self._benchmark:
last = time.clock()
self._num_timer_warnings = 0
self._num_ticks = 0
self._mainloop_execution_times = []
while not rospy.is_shutdown():
if self.sender_active:
self._spike_source._update()
if self.receiver_active:
self._spike_sink._update()
# Count if the mainloop execution takes too long
if self._benchmark:
self._num_ticks += 1
now = time.clock()
self._mainloop_execution_times.append(now - last)
if (now - last) > (1.0 / self._clk_rate):
self._num_timer_warnings += 1
last = now
ros_timer.sleep()
def _incoming_ros_package_callback(self, ros_msg):
"""
Callback for the incoming data. Forwards the data via UDP to the Spinnaker Board.
"""
self._queue_ros_spinnaker.put(ros_msg.data) # data is the name of the ros std_msgs data field.
def _incoming_spike_callback(self, label, time, neuron_ids):
"""
Call this callback to process incoming live spikes.
"""
for neuron_id in neuron_ids:
spike = (label, time, neuron_id)
self._queue_spinnaker_ros.put(spike)
def is_roscore_running(self):
"""
Returns True if the ROS Core is running and False otherwise.
"""
return True # TODO
try:
_, _, ros_master_pid = rospy.get_master().getPid()
return True
except socket.error:
print('\n\n[!] Cannot communicate with ROS Master. Please check if ROS Core is running.\n\n')
return False
@property
def InjectorPopulation(self):
"""
The handle to the ExternalDevices.SpikeInjector which is used internally.
Can be used for pynn.Connectors
"""
return self._spike_injector_population if self.sender_active else None
def __str__(self):
return 'ROS-Spinnaker-Interface'
def __repr__(self):
return self._spike_injector_population
def on_ros_node_shutdown(self):
# These do nothing on default. The plot functions need to be redefined in the SpikeSink/Source used to
# actually do something.
if self._benchmark:
lock.acquire()
print("Interface {} Benchmark".format(self.interface_id))
# print("startet running on time {}".format(self.interface_start_time))
# print("stopped runnning on time {}".format(time.time()))
print("Number of times the mainloop took too long: {}".format(self._num_timer_warnings))
print("Number of Mainloop Calls: {}".format(self._num_ticks))
import numpy as np
mean_execution_time = np.mean(self._mainloop_execution_times)
print("Mean Mainloop Execution Time: {} ms, (max {} ms)".format(mean_execution_time, 1.0 / self._clk_rate))
print("Highest possible interface clock rate: {} Hz\n".format(1.0 / mean_execution_time))
lock.release()
if self.sender_active:
self._spike_source.plot()
if self.receiver_active:
self._spike_sink.plot()
def add_simulation_start_callback(self, function):
if self.sender_active:
self._spinnaker_connection.add_start_callback(self._injector_label, function)
# Create a receiver of live spikes
def receive_spikes(label, time, neuron_ids):
for neuron_id in neuron_ids:
print "Received spike at time", time, "from", label, "-", neuron_id
# Set up the live connection for sending spikes
live_spikes_connection = SpynnakerLiveSpikesConnection(
receive_labels=None, local_port=19999, send_labels=["spike_injector_forward"])
# Set up callbacks to occur at the start of simulation
live_spikes_connection.add_start_callback("spike_injector_forward", send_input_forward)
# if not using the c visualiser, then a new spynnaker live spikes connection
# is created to define that there are python code which receives the
# outputted spikes.
live_spikes_connection = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward"], local_port=19996, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection.add_receive_callback("pop_forward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
live_spikes_connection_send = SpynnakerLiveSpikesConnection(
receive_labels=None, local_port=19999,
send_labels=["spike_injector"])
# Set up callbacks to occur at initialisation
live_spikes_connection_send.add_init_callback(
"spike_injector", init_pop)
live_spikes_connection_receive = SpynnakerLiveSpikesConnection(
receive_labels=["pop"],
local_port=19996, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection_receive.add_receive_callback(
"pop", receive_spikes)
def run():
Frontend.run(run_time)
Frontend.end()
if r == 1:
send_spike_retina("ret_right", liveConnectionRetina)
else:
send_spike_retina("ret_left", liveConnectionRetina)
time.sleep((tNext - t)/1000.0)
def init_thread(label, sender):
if label == "ret_left":
sender_thread = Thread(target=threadLeft_run, args=(sender,))
sender_thread.start()
else:
sender_thread = Thread(target=threadRight_run, args=(sender,))
sender_thread.start()
live_spikes_connection_receiver = SpynnakerLiveSpikesConnection(receive_labels=["collector", "inh_left", "inh_right"], local_port=19996, send_labels=None)
live_spikes_connection_receiver.add_receive_callback("collector", receive_spike_cell)
live_spikes_connection_receiver.add_receive_callback("inh_left", receive_spike_cell)
live_spikes_connection_receiver.add_receive_callback("inh_right", receive_spike_cell)
live_spikes_connection_sender = SpynnakerLiveSpikesConnection(receive_labels=None, local_port=19999, send_labels=["ret_right", "ret_left"])
# Set up callbacks to occur at the start of simulation
# live_spikes_connection_sender.add_start_callback("ret_left", init_thread)
live_spikes_connection_sender.add_start_callback("ret_right", init_thread)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_collector = collector.getSpikes()
print "Spikes count collector: ", len(spikes_collector)
live_spikes_connection_send.add_start_callback("spike_injector_forward",
send_input_forward)
live_spikes_connection_send.add_start_callback("spike_injector_backward",
send_input_backward)
if not using_c_vis:
# if not using the c visualiser, then a new spynnaker live spikes connection
# is created to define that there are python code which receives the
# outputted spikes.
live_spikes_connection_receive = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward", "pop_backward"],
local_port=19996,
send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection_receive.add_receive_callback(
"pop_forward", receive_spikes)
live_spikes_connection_receive.add_receive_callback(
"pop_backward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
def __init__(self):
# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
use_c_visualiser = True
use_spike_injector = True
# neurons per population and the length of runtime in ms for the
# simulation, as well as the expected weight each spike will contain
self.n_neurons = 100
# set up gui
p = None
if use_spike_injector:
from multiprocessing import Process
from multiprocessing import Event
ready = Event()
p = Process(target=GUI, args=[self.n_neurons, ready])
p.start()
ready.wait()
# different runtimes for demostration purposes
run_time = None
if not use_c_visualiser and not use_spike_injector:
run_time = 1000
elif use_c_visualiser and not use_spike_injector:
run_time = 10000
elif use_c_visualiser and use_spike_injector:
run_time = 100000
elif not use_c_visualiser and use_spike_injector:
run_time = 10000
weight_to_spike = 2.0
# neural parameters of the IF_curr model used to respond to injected
# spikes.
# (cell params for a synfire chain)
cell_params_lif = {'cm': 0.25,
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
##################################
# Parameters for the injector population. This is the minimal set of
# parameters required, which is for a set of spikes where the key is
# not important. Note that a virtual key *will* be assigned to the
# population, and that spikes sent which do not match this virtual key
# will be dropped; however, if spikes are sent using 16-bit keys, they
# will automatically be made to match the virtual key. The virtual
# key assigned can be obtained from the database.
##################################
cell_params_spike_injector = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12345
}
##################################
# Parameters for the injector population. Note that each injector
# needs to be given a different port. The virtual key is assigned
# here, rather than being allocated later. As with the above, spikes
# injected need to match this key, and this will be done automatically
# with 16-bit keys.
##################################
cell_params_spike_injector_with_key = {
# The port on which the spiNNaker machine should listen for
# packets. Packets to be injected should be sent to this port on
# the spiNNaker machine
'port': 12346,
# This is the base key to be used for the injection, which is used
# to allow the keys to be routed around the spiNNaker machine.
# This assignment means that 32-bit keys must have the high-order
# 16-bit set to 0x7; This will automatically be prepended to
# 16-bit keys.
'virtual_key': 0x70000
}
# create synfire populations (if cur exp)
pop_forward = Frontend.Population(
self.n_neurons, Frontend.IF_curr_exp,
cell_params_lif, label='pop_forward')
pop_backward = Frontend.Population(
self.n_neurons, Frontend.IF_curr_exp,
cell_params_lif, label='pop_backward')
# Create injection populations
injector_forward = None
injector_backward = None
if use_spike_injector:
injector_forward = Frontend.Population(
self.n_neurons, ExternalDevices.SpikeInjector,
cell_params_spike_injector_with_key,
label='spike_injector_forward')
injector_backward = Frontend.Population(
self.n_neurons, ExternalDevices.SpikeInjector,
cell_params_spike_injector, label='spike_injector_backward')
else:
spike_times = []
for _ in range(0, self.n_neurons):
spike_times.append([])
spike_times[0] = [0]
spike_times[20] = [(run_time / 100) * 20]
spike_times[40] = [(run_time / 100) * 40]
spike_times[60] = [(run_time / 100) * 60]
spike_times[80] = [(run_time / 100) * 80]
cell_params_forward = {'spike_times': spike_times}
spike_times_backwards = []
for _ in range(0, self.n_neurons):
spike_times_backwards.append([])
spike_times_backwards[0] = [(run_time / 100) * 80]
spike_times_backwards[20] = [(run_time / 100) * 60]
spike_times_backwards[40] = [(run_time / 100) * 40]
spike_times_backwards[60] = [(run_time / 100) * 20]
spike_times_backwards[80] = [0]
cell_params_backward = {'spike_times': spike_times_backwards}
injector_forward = Frontend.Population(
self.n_neurons, Frontend.SpikeSourceArray,
cell_params_forward,
label='spike_injector_forward')
injector_backward = Frontend.Population(
self.n_neurons, Frontend.SpikeSourceArray,
cell_params_backward, label='spike_injector_backward')
# Create a connection from the injector into the populations
Frontend.Projection(
injector_forward, pop_forward,
Frontend.OneToOneConnector(weights=weight_to_spike))
Frontend.Projection(
injector_backward, pop_backward,
Frontend.OneToOneConnector(weights=weight_to_spike))
# Synfire chain connections where each neuron is connected to its next
# neuron
# NOTE: there is no recurrent connection so that each chain stops once
# it reaches the end
loop_forward = list()
loop_backward = list()
for i in range(0, self.n_neurons - 1):
loop_forward.append((i, (i + 1) %
self.n_neurons, weight_to_spike, 3))
loop_backward.append(((i + 1) %
self.n_neurons, i, weight_to_spike, 3))
Frontend.Projection(pop_forward, pop_forward,
Frontend.FromListConnector(loop_forward))
Frontend.Projection(pop_backward, pop_backward,
Frontend.FromListConnector(loop_backward))
# record spikes from the synfire chains so that we can read off valid
# results in a safe way afterwards, and verify the behavior
pop_forward.record()
pop_backward.record()
# Activate the sending of live spikes
ExternalDevices.activate_live_output_for(
pop_forward, database_notify_host="localhost",
database_notify_port_num=19996)
ExternalDevices.activate_live_output_for(
pop_backward, database_notify_host="localhost",
database_notify_port_num=19996)
if not use_c_visualiser:
# if not using the c visualiser, then a new spynnaker live spikes
# connection is created to define that there are python code which
# receives the outputted spikes.
live_spikes_connection_receive = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward", "pop_backward"],
local_port=19999, send_labels=None)
# Set up callbacks to occur when spikes are received
live_spikes_connection_receive.add_receive_callback(
"pop_forward", receive_spikes)
live_spikes_connection_receive.add_receive_callback(
"pop_backward", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
if len(spikes_backward) != 0:
pylab.plot([i[1] for i in spikes_backward],
[i[0] for i in spikes_backward], "r.")
pylab.ylabel('neuron id')
pylab.xlabel('Time/ms')
pylab.title('spikes')
pylab.show()
else:
print "No spikes received"
# Clear data structures on spiNNaker to leave the machine in a clean
# state for future executions
Frontend.end()
if use_spike_injector:
p.join()
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
# echo population ----------------------------------------------------------
target = sim.Population(num_neurons, model, cell_params, label="echo")
target.record()
ExternalDevices.activate_live_output_for(target,
database_notify_host="localhost",
database_notify_port_num=live_out_port)
live_spikes_receive = SpynnakerLiveSpikesConnection(receive_labels=["echo",],
local_port=receive_port,
send_labels=None)
live_spikes_receive.add_receive_callback("echo", receive_spikes)
# END: echo population ----------------------------------------------------------
# stim population ----------------------------------------------------------
stimulation = sim.Population(num_neurons, ImageDvsEmulatorDevice, cam_params,
label="Webcam population")
# END: stim population ----------------------------------------------------------
# connections ----------------------------------------------------------
connector = sim.OneToOneConnector(weights=weight_to_spike)
projection = sim.Projection(stimulation, target, connector)
Frontend.Projection(source[pop], collector[pop], Frontend.OneToOneConnector(weights=22, delays=0.2), target='excitatory')
collector[pop].record()
counter_received_spikes.append(0)
collector_labels.append('{0}'.format(pop))
def receive_spike_cell(label, time, neuron_ids):
if time < 5050 :
counter_received_spikes[int(label)] += len(neuron_ids)
for col in collector:
ExternalDevices.activate_live_output_for(col, database_notify_host="localhost",database_notify_port_num=19996)
live_spikes_connection_receiver = SpynnakerLiveSpikesConnection(receive_labels=collector_labels, local_port=19996, send_labels=None)
for label in collector_labels:
live_spikes_connection_receiver.add_receive_callback(label, receive_spike_cell)
Frontend.run(run_time)
total_spikes_count = 0
for col in collector:
total_spikes_count += len(col.getSpikes())
print "Spikes count collector:", total_spikes_count
print "Spikes count received:", sum(counter_received_spikes)
Frontend.end()
if neuron_id == 0 and label== "pop_backward_parrot":
live_spikes_connection.send_spike("spike_injector_forward", 0)
elif neuron_id == 99 and label== "pop_forward_parrot":
live_spikes_connection.send_spike("spike_injector_forward", 1)
# Set up the live connection for sending spikes
live_spikes_connection = SpynnakerLiveSpikesConnection(
local_port=19996, send_labels=["spike_injector_forward"])
# Set up the live connection for sending spikes to closed loop
live_spikes_connection_receiver = SpynnakerLiveSpikesConnection(
receive_labels=["pop_forward_parrot", "pop_backward_parrot"],
local_port=19995)
# Set up callbacks to occur at the start of simulation
live_spikes_connection.add_start_callback("spike_injector_forward",
send_input_forward)
# Set up callbacks to occur when spikes are received
live_spikes_connection_receiver.add_receive_callback("pop_forward_parrot", receive_spikes)
live_spikes_connection_receiver.add_receive_callback("pop_backward_parrot", receive_spikes)
# Run the simulation on spiNNaker
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
spikes_forward = pop_forward.getSpikes()
spikes_backward = pop_backward.getSpikes()
# If there are spikes, plot using matplotlib
if len(spikes_forward) != 0 or len(spikes_backward) != 0:
pylab.figure()
if len(spikes_forward) != 0:
pylab.plot([i[1] for i in spikes_forward],
[i[0] for i in spikes_forward], "b.")
if len(spikes_backward) != 0:
pylab.plot([i[1] for i in spikes_backward],
sender.send_spike("med", n, send_full_keys=False)
n += 1
counter_sent += neuronCount
# time.sleep(0.007)
print time.time()
def init(label, sender):
pass
sender_thread = Thread(target=th_run, args=(sender,))
sender_thread.start()
ExternalDevices.activate_live_output_for(source, database_notify_host="localhost",database_notify_port_num=19996)
live_spikes_connection_receiver = SpynnakerLiveSpikesConnection(receive_labels=["src"], local_port=19996, send_labels=None)
live_spikes_connection_receiver.add_receive_callback("src", receive_spike_cell)
live_spikes_connection_sender = SpynnakerLiveSpikesConnection(receive_labels=None, local_port=19999, send_labels=["med"])
live_spikes_connection_sender.add_start_callback("med", init)
Frontend.run(run_time)
# Retrieve spikes from the synfire chain population
# print "Spikes count source:", len(source.getSpikes())
# print "Spikes count collector_ssa:", len(collector_ssa.getSpikes())
# print collector_ssa.getSpikes()[:20]
# print "Spikes count collector_inj:", len(collector_inj.getSpikes())
print counter_received, counter_sent
# print collector_inj.getSpikes()[:20]
# print source.getSpikes()
