def test_tf_change_locals(self):
@nrp.MapVariable("shared_var", initial_value=2)
@nrp.Neuron2Robot(Topic("/vars/shared1", float))
def echo_shared_var(t, shared_var):
shared_var.value = shared_var.value + t
return shared_var.value
@nrp.MapVariable("shared_var", initial_value=5)
@nrp.Neuron2Robot(Topic("/vars/shared2", float))
def echo_shared_var2(t, shared_var):
shared_var.value = shared_var.value - t
return shared_var.value
nrp.initialize("MyTransferFunctions")
topic1 = echo_shared_var.topic
topic2 = echo_shared_var2.topic
config.active_node.run_neuron_to_robot(1)
config.active_node.run_robot_to_neuron(1)
config.active_node.run_neuron_to_robot(2)
config.active_node.run_robot_to_neuron(2)
self.assertEqual(len(topic1.sent), 2)
self.assertEqual(len(topic2.sent), 2)
self.assertListEqual(topic1.sent, [3, 5])
self.assertListEqual(topic2.sent, [4, 2])
def test_tf_delete(self, mock_cleanup):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
config.active_node.brain_adapter = brain
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
@nrp.MapCSVRecorder("recorder1", filename = "1", headers=["Name", "time", "Position"])
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0, recorder1):
return neuron0.voltage * 1.345
@nrp.MapCSVRecorder("recorder2", filename = "2", headers=["Name", "time", "Position"])
@nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neuron1, neuron2, recorder2):
if neuron1.voltage < 0.678:
if neuron2.voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neuron2.voltage < 0.789:
return 0.632
else:
return 0.256
nrp.initialize("MyTransferFunctions")
# Delete an existing transfer function
self.assertEqual(2, len(nrp.get_transfer_functions()))
self.assertEqual(True, nrp.delete_transfer_function("left_arm_tw"))
self.assertEqual(1, len(nrp.get_transfer_functions()))
self.assertEqual(mock_cleanup.call_count, 1)
# Try to delete it again
self.assertEqual(False, nrp.delete_transfer_function("left_arm_tw"))
self.assertEqual(1, len(nrp.get_transfer_functions()))
# Delete another existing transfer function
self.assertEqual(True, nrp.delete_transfer_function("right_arm"))
self.assertEqual(0, len(nrp.get_transfer_functions()))
self.assertEqual(0, len(config.active_node.brain_adapter.detector_devices))
self.assertEqual(mock_cleanup.call_count, 2)
def test_tf_globals(self):
self.assertEquals(len(config.active_node.global_data), 0)
@nrp.MapVariable("shared_var", initial_value=2, scope=nrp.GLOBAL)
@nrp.Neuron2Robot(Topic("/vars/shared1", float))
def echo_shared_var(t, shared_var):
shared_var.value = shared_var.value + t
return shared_var.value
@nrp.MapVariable("shared_var", scope=nrp.GLOBAL)
@nrp.Neuron2Robot(Topic("/vars/shared2", float))
def echo_shared_var2(t, shared_var):
shared_var.value = shared_var.value - t
return shared_var.value
@nrp.MapVariable("shared_var2",
global_key="second_var",
initial_value=5,
scope=nrp.GLOBAL)
@nrp.Neuron2Robot(Topic("/vars/shared3", float))
def echo_shared_var3(t, shared_var2):
shared_var2.value = shared_var2.value - t
return shared_var2.value
nrp.initialize("MyTransferFunctions")
self.assertEquals(len(config.active_node.global_data), 2)
self.assertIn("shared_var", config.active_node.global_data)
self.assertIn("second_var", config.active_node.global_data)
topic1 = echo_shared_var.topic
topic2 = echo_shared_var2.topic
topic3 = echo_shared_var3.topic
config.active_node.run_neuron_to_robot(1)
config.active_node.run_neuron_to_robot(2)
self.assertEqual(len(topic1.sent), 2)
self.assertEqual(len(topic2.sent), 2)
self.assertEqual(len(topic3.sent), 2)
self.assertListEqual(topic1.sent, [3, 4])
self.assertListEqual(topic2.sent, [2, 2])
self.assertListEqual(topic3.sent, [4, 2])
def test_spike_recorder_monitor(self):
nrp.start_new_tf_manager()
self.init_adapters()
@nrp.NeuronMonitor(nrp.brain.foo, nrp.spike_recorder)
def my_monitor(t):
return True
nrp.initialize("test")
my_monitor.run(42.0)
msg = my_monitor.publisher.sent[-1]
self.assertIsInstance(msg, SpikeEvent)
self.assertEqual(msg.simulationTime, 42.0)
self.assertEqual(msg.monitorName, "my_monitor")
self.assertEqual(msg.neuronCount, 42)
self.assertEqual(len(msg.spikes), 0)
my_monitor.unregister()
self.assertIsNone(my_monitor.device)
def test_population_rate_monitor(self):
nrp.start_new_tf_manager()
self.init_adapters()
@nrp.NeuronMonitor(nrp.brain.foo, nrp.population_rate)
def my_monitor(t):
return True
nrp.initialize("test")
my_monitor.run(42.0)
msg = my_monitor.publisher.sent[-1]
self.assertIsInstance(msg, SpikeRate)
self.assertEqual(msg.simulationTime, 42.0)
self.assertEqual(msg.monitorName, "my_monitor")
self.assertEqual(msg.rate, my_monitor.device.rate)
my_monitor.unregister()
self.assertIsNone(my_monitor.device)
def test_all_right(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
@nrp.MapSpikeSink("neuron0",
nrp.map_neurons(range(0, 2),
lambda i: nrp.brain.actors[i]),
nrp.leaky_integrator_alpha,
v_rest=1.0,
updates=[(1.0, [0.3, 0.0])])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return np.sum(neuron0.voltage) * 1.345
# Here is a another transfer function from neurons to robot messages
# This time, the neuron parameter is explicitly mapped to an array of neurons
# More precisely, the parameter is mapped to a group of __devices that are each connected to a single neuron
# The neuron2 parameter will thus be a list of recorders
@nrp.MapSpikeSink("neurons",
nrp.chain_neurons(nrp.brain.actors[slice(2, 4, 1)],
nrp.brain.actors[slice(4, 6, 1)]),
nrp.leaky_integrator_alpha,
updates=[(1.0, [0.4, 0.4])],
v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neurons):
if neurons[0].voltage < 0.678:
if neurons[1].voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neurons[1].voltage < 0.789:
return 0.632
else:
return 0.256
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
brain.__dict__["actors"] = MockPopulation(range(0, 60))
brain.__dict__["sensors"] = MockPopulation(range(45, 645))
config.brain_root = brain
nrp.initialize("MyTransferFunctions")
husky_right_arm = right_arm.topic
husky_left_arm = left_arm_tw.topic
brain.refresh_buffers(0.5)
robot.refresh_buffers(0.5)
config.active_node.run_neuron_to_robot(0.5)
config.active_node.run_robot_to_neuron(0.5)
brain.refresh_buffers(1.5)
robot.refresh_buffers(1.5)
config.active_node.run_neuron_to_robot(1.5)
config.active_node.run_robot_to_neuron(1.5)
self.assertIsInstance(husky_right_arm, MockPublishedTopic)
self.assertIsInstance(husky_left_arm, MockPublishedTopic)
self.assertEqual(len(husky_right_arm.sent), 2)
self.assertEqual(len(husky_left_arm.sent), 2)
self.assertEqual(husky_right_arm.sent[0], 1.345 * 2.0)
self.assertEqual(husky_right_arm.sent[1], 1.345 * 0.3)
self.assertEqual(husky_left_arm.sent[0], 0.256)
self.assertEqual(husky_left_arm.sent[1], 0.756)
config.active_node.reset()
def test_all_right(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return neuron0.voltage * 1.345
@nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neuron1, neuron2):
if neuron1.voltage < 0.678:
if neuron2.voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neuron2.voltage < 0.789:
return 0.632
else:
return 0.256
# Here is an example of a transfer function mapping robot sensor data to spikes
# As the image processing is a common task, this is done through a specialized
# device in the neuronal simulator. However, this device might not be mapped to
# physical Nest device, but do some processing internally and use a less specialized
# device type internally
@nrp.MapRobotSubscriber("camera", Husky.Eye.camera)
@nrp.MapSpikeSource("camera_device", nrp.brain.sensors[slice(0, 600, 1)],
TestDevice())
@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
camera_device.inner.amplitude = 42.0
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
brain.__dict__["actors"] = MockPopulation(range(0, 60))
brain.__dict__["sensors"] = MockPopulation(range(45, 645))
config.brain_root = brain
nrp.initialize("MyTransferFunctions")
husky_right_arm = right_arm.topic
husky_left_arm = left_arm_tw.topic
camera = transform_camera.camera
camera_device = transform_camera.camera_device
brain.refresh_buffers(0.5)
robot.refresh_buffers(0.5)
config.active_node.run_neuron_to_robot(0.5)
config.active_node.run_robot_to_neuron(0.5)
camera.value = "Definitely not an image"
brain.refresh_buffers(1.5)
robot.refresh_buffers(1.5)
config.active_node.run_neuron_to_robot(1.5)
config.active_node.run_robot_to_neuron(1.5)
assert isinstance(husky_right_arm, MockPublishedTopic)
assert isinstance(husky_left_arm, MockPublishedTopic)
assert len(husky_right_arm.sent) == 2
assert len(husky_left_arm.sent) == 2
assert husky_right_arm.sent[0] == 1.345
assert husky_right_arm.sent[1] == 1.345 * 0.3
assert husky_left_arm.sent[0] == 0.256
assert husky_left_arm.sent[1] == 0.756
assert camera_device.inner.amplitude == 42.0
config.active_node.reset()