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_rca_refresh_buffers(self, _, mock_init_node, mock_publisher):
t1, t2 = Topic('a', 'b'), Topic('c', 'd')
self.rca.register_publish_topic(t1)
self.rca.register_publish_topic(t2)
self.rca.initialize("test_node")
self.rca.refresh_buffers(0.1)
for key in self.rca.subscribed_topics:
self.assertTrue(self.rca.subscribed_topics[key].changed)
self.assertEquals(mock_init_node.call_count, 1)
self.assertEquals(mock_publisher.call_count, 2)
def test_rpt_send_message(self, mock_rospy_publisher):
rpt = RosPublishedTopic(Topic('topic_name', 'topic_type'))
pub = mock_rospy_publisher.return_value
rpt.send_message('message')
self.assertEquals(pub.publish.call_count, 1)
self.assertEquals(pub.publish.call_args_list[0][0][0], 'message')
rpt._unregister()
rpt.send_message('message')
self.assertEquals(pub.publish.call_count, 1)
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_invalid_missing_param(self):
with self.assertRaises(Exception):
@nrp.MapVariable("shared_var_not_available",
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
def test_invalid_scope(self):
@nrp.MapVariable("shared_var",
initial_value=2,
scope="something_invalid")
@nrp.Neuron2Robot(Topic("/vars/shared1", float))
def echo_shared_var(t, shared_var):
shared_var.value = shared_var.value + t
return shared_var.value
self.assertRaises(Exception, nrp.initialize, "MyTransferFunctions")
def test_rca_create_topic_subscriber_triggers_tf(self, mock_rospy_subscriber, mock_init_node):
self.rca.initialize("test_node")
tf = Mock()
tf.active = True
tf.elapsed_time = 0
tf.should_run.return_value = True
tested_module.sim_time = 42.0
sub = self.rca.create_topic_subscriber(Topic('topic', 'topic_type'))
self.assertIsInstance(sub, RosSubscribedTopic)
sub.register_tf_trigger(tf)
sub._callback("foo")
self.assertEqual(sub.value, "foo")
tf.should_run.assert_called_once_with(42.0)
tf.run.assert_called_once_with(42.0)
def test_rca_create_topic_publisher(self, _, mock_rospy_publisher, mock_init_node):
self.rca.initialize("test_node")
r = self.rca.create_topic_publisher(PreprocessedTopic(
'preprocessed_topic', 'topic_type', lambda x: ()
))
self.assertIsInstance(r, RosPublishedPreprocessedTopic)
r = self.rca.create_topic_publisher(Topic('topic', 'topic_type'))
self.assertIsInstance(r, RosPublishedTopic)
r = self.rca.create_topic_publisher("/rosout")
self.assertIsInstance(r, RosPublishedTopic)
with self.assertRaises(Exception):
self.rca.create_topic_publisher("/does_not_exist")
self.assertEquals(mock_init_node.call_count, 1)
self.assertGreater(mock_rospy_publisher.call_count, 0)
def create_topic_publisher(self, topic, **config):
"""
Creates a publisher object for the given topic
:param topic: The topic
:param config: Additional configuration for the publisher
:param **queue_size: ROS Publisher queue_size parameter, please refer to ROS documentation
:return: A publisher object
"""
if isinstance(topic, PreprocessedTopic):
return RosPublishedPreprocessedTopic(topic, **config)
elif isinstance(topic, str):
topic_type = self.get_topic_type(topic)
if topic_type is None:
raise Exception(
"The type of topic {0} is unknown. Please specify it explicitly"
.format(topic))
topic = Topic(topic, topic_type)
return RosPublishedTopic(topic, **config)
def create_topic_subscriber(self, topic, **config):
"""
Creates the subscription object for the given topic
:param topic: The topic
:param config: Additional configuration for the subscriber
:param **queue_size: ROS Subscriber queue_size parameter, please refer to ROS documentation
:param **buff_size: ROS Subscriber buff_size parameter, please refer to ROS documentation
:return: A subscription object
"""
if isinstance(topic, PreprocessedTopic):
return RosSubscribedPreprocessedTopic(
topic, config.get('initial_value', None), **config)
elif isinstance(topic, str):
topic_type = self.get_topic_type(topic)
if topic_type is None:
raise Exception(
"The type of topic {0} is unknown. Please specify it explicitly"
.format(topic))
topic = Topic(topic, topic_type)
return RosSubscribedTopic(topic, config.get('initial_value', None),
**config)
class Eye:
camera = Topic("/husky1/sensors/camera1", list)
class LeftArm:
twist = Topic("/husky1/leftArm/twist", float)
class RightArm:
pose = Topic("/husky1/joint325/pose", float)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import logging
@nrp.MapRobotSubscriber("dist0",
Topic('/epuck/distanceSensor0', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist1",
Topic('/epuck/distanceSensor1', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist2",
Topic('/epuck/distanceSensor2', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist3",
Topic('/epuck/distanceSensor3', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist4",
Topic('/epuck/distanceSensor4', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist5",
Topic('/epuck/distanceSensor5', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist6",
Topic('/epuck/distanceSensor6', sensor_msgs.msg.Range))
@nrp.MapRobotSubscriber("dist7",
Topic('/epuck/distanceSensor7', sensor_msgs.msg.Range))
@nrp.MapSpikeSource("sensor_neurons", nrp.brain.sensors, nrp.raw_signal)
@nrp.Robot2Neuron()
def distances(t, dist0, dist1, dist2, dist3, dist4, dist5, dist6, dist7,
sensor_neurons):
"""
This transfer function detects the distance values taken from the epuck and direct them to brain
"""
if dist5.value is not None and dist6.value is not None:
sensor_neurons.value[0] = min(dist5.value.range,
def test_rst_init(self, mock_rospy_subscriber):
RosSubscribedTopic(Topic('topic_name', 'topic_type'), None)
self.assertEquals(mock_rospy_subscriber.call_count, 1)
self.assertEquals(mock_rospy_subscriber.call_args_list[0][0][0], 'topic_name')
self.assertEquals(mock_rospy_subscriber.call_args_list[0][0][1], 'topic_type')
self.assertRaises(AssertionError, RosSubscribedTopic, None, None)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import geometry_msgs.msg
@nrp.MapVariable("sign", initial_value=None, scope=nrp.GLOBAL)
@nrp.Neuron2Robot(Topic('/husky/cmd_vel', geometry_msgs.msg.Twist))
def velo_control(t, sign):
coeff = 6
if sign.value == 'limit100':
return geometry_msgs.msg.Twist(
linear=geometry_msgs.msg.Vector3(x=1.0*coeff, y=0.0, z=0.0),
angular=geometry_msgs.msg.Vector3(x=0.0, y=0.0, z=0.0))
elif sign.value == 'limit20':
return geometry_msgs.msg.Twist(
linear=geometry_msgs.msg.Vector3(x=0.4*coeff, y=0.0, z=0.0),
angular=geometry_msgs.msg.Vector3(x=0.0, y=0.0, z=0.0))
elif sign.value == 'stop_sign':
return geometry_msgs.msg.Twist(
linear=geometry_msgs.msg.Vector3(x=0.0, y=0.0, z=0.0),
angular=geometry_msgs.msg.Vector3(x=0.0, y=0.0, z=0.0))
else:
return geometry_msgs.msg.Twist(
linear=geometry_msgs.msg.Vector3(x=0.6*coeff, y=0.0, z=0.0),
angular=geometry_msgs.msg.Vector3(x=0.0, y=0.0, z=0.0))
import gazebo_msgs.msg
@nrp.MapSpikeSink("left_wheel_forward_neuron", nrp.brain.actors[0],
nrp.population_rate)
@nrp.MapSpikeSink("left_wheel_back_neuron", nrp.brain.actors[1],
nrp.population_rate)
@nrp.MapSpikeSink("right_wheel_forward_neuron", nrp.brain.actors[2],
nrp.population_rate)
@nrp.MapSpikeSink("right_wheel_back_neuron", nrp.brain.actors[3],
nrp.population_rate)
@nrp.MapVariable("ideal_wheel_speed",
global_key="ideal_wheel_speed",
initial_value=[0.0, 0.0],
scope=nrp.GLOBAL)
@nrp.Neuron2Robot(Topic('/husky/wheel_speeds', gazebo_msgs.msg.WheelSpeeds))
def Brain2Motor(t, ideal_wheel_speed, left_wheel_forward_neuron,
left_wheel_back_neuron, right_wheel_forward_neuron,
right_wheel_back_neuron):
"""
The transfer function which calculates the linear twist of the husky robot based on the
voltage of left and right wheel neurons.
:param t: the current simulation time
:param left_wheel_forward_neuron: the left wheel forward neuron device
:param left_wheel_back_neuron: the left wheel back neuron device
:param right_wheel_forward_neuron: the right wheel forward neuron device
:param right_wheel_back_neuron: the right wheel back neuron device
:return: a gazebo_msgs/WheelSpeeds setting the speeds of the left and right pair of wheels of the husky robot for movement.
"""
left_wheel = 0.002 * (left_wheel_forward_neuron.rate -
left_wheel_back_neuron.rate)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import std_msgs.msg
import geometry_msgs.msg
@nrp.MapRobotPublisher('direction_topic', Topic('direction_topic', std_msgs.msg.Int32))
@nrp.MapRobotSubscriber('position', Topic('/gazebo/model_states', gazebo_msgs.msg.ModelStates))
@nrp.MapVariable('initial_pose', global_key='initial_pose', initial_value=None)
@nrp.MapVariable('step_index', global_key='step_index', initial_value=0)
@nrp.MapVariable('direction', global_key='direction', initial_value=0)
@nrp.MapVariable('action', global_key='action', initial_value=-1)
@nrp.MapVariable('t_old', global_key='t_old', initial_value=0)
@nrp.Neuron2Robot(Topic('/husky/husky/cmd_vel', geometry_msgs.msg.Twist))
def move(t, step_index, position, initial_pose, direction_topic, direction, t_old, action):
import math
import rospy
import numpy as np
import tf
linear = geometry_msgs.msg.Vector3(0, 0, 0)
angular = geometry_msgs.msg.Vector3(0, 0, 0)
if position.value is None:
return geometry_msgs.msg.Twist(linear=linear, angular=angular)
if initial_pose.value is None:
initial_pose.value = position.value.pose[position.value.name.index('husky')]
current_pose = position.value.pose[position.value.name.index('husky')]
directions = [0, math.pi / 2, math.pi, math.pi * 3 / 2]
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import geometry_msgs.msg
@nrp.MapRobotSubscriber("pose",
Topic('/gazebo/model_states',
gazebo_msgs.msg.ModelStates))
@nrp.MapVariable("step_index", global_key="step_index", initial_value=0)
@nrp.MapVariable("initial_position",
global_key="initial_position",
initial_value=None)
@nrp.MapVariable("initial_orientation",
global_key="initial_orientation",
initial_value=None)
@nrp.MapVariable("waypoints", global_key="waypoints", initial_value=None)
@nrp.MapVariable("lattice_points",
global_key="lattice_points",
initial_value=None)
@nrp.MapVariable("stage", global_key="stage", initial_value=1)
@nrp.Neuron2Robot(Topic('/robot/cmd_vel', geometry_msgs.msg.Twist))
def navigate(t, step_index, pose, initial_position, initial_orientation,
waypoints, lattice_points, stage):
import math
import numpy
import csv
from load_csv_positions import load_waypoints, load_lattice
if lattice_points.value is None:
# Load data of the SOM-lattice from a csv file
lattice_points.value = load_lattice("resources/lattice.csv")
def test_rpt_init(self, mock_rospy_publisher):
RosPublishedTopic(Topic('topic_name', 'topic_type'))
self.assertEquals(mock_rospy_publisher.call_count, 1)
self.assertEquals(mock_rospy_publisher.call_args_list[0][0][0], 'topic_name')
self.assertEquals(mock_rospy_publisher.call_args_list[0][0][1], 'topic_type')
self.assertRaises(AssertionError, RosPublishedTopic, None)
def test_rst_reset(self, mock_rospy_subscriber):
rst = RosSubscribedTopic(Topic('topic_name', 'topic_type'), None)
res = rst.reset(None)
self.assertFalse(rst.changed)
self.assertFalse(res.changed)
self.assertEquals(mock_rospy_subscriber.call_count, 1)
def test_rst_callback(self, mock_rospy_subscriber):
rst = RosSubscribedTopic(Topic('topic_name', 'topic_type'), 10)
rst._callback('data')
self.assertTrue(rst.changed)
self.assertEquals(rst.value, 'data')
self.assertEquals(mock_rospy_subscriber.call_count, 1)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
from sensor_msgs.msg import JointState
import std_msgs.msg
from std_msgs.msg import Float64
@nrp.MapRobotSubscriber("joints", Topic("/icub/joints", JointState))
@nrp.Neuron2Robot(Topic('/icub/neck_yaw/vel', Float64))
def head_twist(t, joints):
MAX_AMPLITUDE = 0.8
RELATIVE_AMPLITUDE = 1.0
joints = joints.value
head_pos = joints.position[joints.name.index('neck_yaw')]
desired_speed = -np.cos(
t * 2 * np.pi) * MAX_AMPLITUDE * RELATIVE_AMPLITUDE * 2.0 * 3.141592
desired_pos = -np.sin(t * 2 * np.pi) * MAX_AMPLITUDE * RELATIVE_AMPLITUDE
if desired_speed > 0:
desired_speed *= (1 + (desired_pos - head_pos) * 2)
else:
desired_speed *= (1 - (desired_pos - head_pos) * 2)
return std_msgs.msg.Float64(desired_speed)
@nrp.MapSpikeSink("arm_1_forward_neuron", nrp.brain.motors[0],
nrp.population_rate)
@nrp.MapSpikeSink("arm_2_forward_neuron", nrp.brain.motors[1],
nrp.population_rate)
@nrp.MapSpikeSink("arm_3_forward_neuron", nrp.brain.motors[2],
nrp.population_rate)
@nrp.MapSpikeSink("arm_4_forward_neuron", nrp.brain.motors[3],
nrp.population_rate)
@nrp.MapSpikeSink("arm_5_forward_neuron", nrp.brain.motors[4],
nrp.population_rate)
@nrp.MapSpikeSink("arm_6_forward_neuron", nrp.brain.motors[5],
nrp.population_rate)
@nrp.MapSpikeSink("hand_neuron", nrp.brain.motors[6], nrp.population_rate)
@nrp.MapRobotPublisher('arm_1',
Topic('/robot/arm_1_joint/cmd_pos',
std_msgs.msg.Float64))
@nrp.MapRobotPublisher('arm_2',
Topic('/robot/arm_2_joint/cmd_pos',
std_msgs.msg.Float64))
@nrp.MapRobotPublisher('arm_3',
Topic('/robot/arm_3_joint/cmd_pos',
std_msgs.msg.Float64))
@nrp.MapRobotPublisher('arm_4',
Topic('/robot/arm_4_joint/cmd_pos',
std_msgs.msg.Float64))
@nrp.MapRobotPublisher('arm_5',
Topic('/robot/arm_5_joint/cmd_pos',
std_msgs.msg.Float64))
@nrp.MapRobotPublisher('arm_6',
Topic('/robot/arm_6_joint/cmd_pos',
std_msgs.msg.Float64))
# Imported Python Transfer Function
import numpy as np
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import geometry_msgs.msg
import cv2
#@nrp.MapSpikeSink('line_recorder', nrp.brain.actors, nrp.spike_recorder)
@nrp.MapRobotSubscriber("lastTerm_sub",
Topic("robot/lastTermTime", std_msgs.msg.Float64))
@nrp.MapRobotPublisher("lastTerm_writer",
Topic("robot/lastTermTime", std_msgs.msg.Float64))
@nrp.MapRobotSubscriber("invert", Topic("robot/invertStart",
std_msgs.msg.Bool))
@nrp.MapRobotPublisher("invert_writer",
Topic("robot/invertStart", std_msgs.msg.Bool))
@nrp.MapRobotSubscriber("offsetHead",
Topic("/alphaS/offsetHead", std_msgs.msg.Float64))
@nrp.MapRobotSubscriber("offset", Topic("/alphaS/offset",
std_msgs.msg.Float64))
@nrp.MapRobotSubscriber("type", Topic("/alphaS/gait_type",
std_msgs.msg.String))
@nrp.MapRobotPublisher("joint_16",
Topic("/alphaS/joint_16/cmd_pos", std_msgs.msg.Float64))
@nrp.MapRobotPublisher("joint_15",
Topic("/alphaS/joint_15/cmd_pos", std_msgs.msg.Float64))
@nrp.MapRobotPublisher("joint_14",
Topic("/alphaS/joint_14/cmd_pos", std_msgs.msg.Float64))
@nrp.MapRobotPublisher("joint_13",
Topic("/alphaS/joint_13/cmd_pos", std_msgs.msg.Float64))
@nrp.MapRobotPublisher("joint_12",
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import std_msgs.msg
from std_msgs.msg import Float64
@nrp.MapSpikeSink("agonist_neuron", nrp.brain.VN_agonist[slice(0,100,1)], nrp.population_rate, tau_fall = 20.0, tau_rise = 10.0)
@nrp.MapSpikeSink("antagonist_neuron", nrp.brain.VN_antagonist[slice(0,100,1)], nrp.population_rate, tau_fall = 20.0, tau_rise = 10.0)
#@nrp.MapSpikeSink("agonist_neuron", nrp.brain.VN_agonist[slice(0,100,1)], nrp.leaky_integrator_alpha, delay = 1.0, cm = 13.6)
#@nrp.MapSpikeSink("antagonist_neuron", nrp.brain.VN_antagonist[slice(0,100,1)], nrp.leaky_integrator_alpha, delay = 1.0, cm = 13.6)
@nrp.Neuron2Robot(Topic('/icub/eye_version/vel', Float64))
def eye_twist(t, agonist_neuron, antagonist_neuron):
MAX_AMPLITUDE = 0.8
eye_velocity=((agonist_neuron.rate - antagonist_neuron.rate)/(100.0*85.0))*MAX_AMPLITUDE*2.0*3.141592*1.55
#clientLogger.info(t, agonist_neuron.rate, antagonist_neuron.rate, eye_velocity)
if abs(eye_velocity)>MAX_AMPLITUDE*2.0*3.141592*1.55*1.2:
sign=eye_velocity/(abs(eye_velocity))# + or -
eye_velocity=MAX_AMPLITUDE*2.0*3.141592*1.5*1.2*sign
return std_msgs.msg.Float64(eye_velocity)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
from geometry_msgs.msg import Twist, Vector3
'''
Transform actor neurons activity into velocity commands
'''
@nrp.MapSpikeSink("left_actor", nrp.brain.actors[1],
nrp.leaky_integrator_alpha)
@nrp.MapSpikeSink("right_actor", nrp.brain.actors[0],
nrp.leaky_integrator_alpha)
@nrp.Neuron2Robot(Topic("/robot/cmd_vel", geometry_msgs.msg.Twist))
def velocity_commands(t, right_actor, left_actor):
# In abscence of activity, the vehicle is moving forward (magnitude lin_max)
lin_max = 0. ###_TO_DO_###
# factor for the transformation from actor's voltage to linear translation component
lin_factor = 0. ###_TO_DO_###
# linear translation component obtained by substrackting actors voltage
x_lin = max(
0, lin_max - lin_factor * (right_actor.voltage + left_actor.voltage))
# factor for the transformation from actor's voltage to angular rotation component
ang_factor = 0. ###_TO_DO_###
# angular rotation component as the actors voltage difference
z_ang = ang_factor * (left_actor.voltage - right_actor.voltage)
# print information on the log console
if t % 2 < 0.02:
clientLogger.info('linear x: {}, angular z: {}'.format(x_lin, z_ang))
# build geometry messages
Vlin = geometry_msgs.msg.Vector3(x_lin, 0, 0)
Vang = geometry_msgs.msg.Vector3(0, 0, z_ang)
"""
This module contains the transfer function which is responsible for determining the linear twist
component of the husky's movement based on the left and right wheel neuron
"""
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
from std_msgs.msg import Float64
#This script is not necessary. It helps monitoring the monitoring wheel command.
@nrp.MapSpikeSink("right_wheel_neuron", nrp.brain.actors[1], nrp.raw_signal)
@nrp.Neuron2Robot(Topic('/right_velocity', std_msgs.msg.Float64))
def right_velocity(t, right_wheel_neuron):
return std_msgs.msg.Float64(right_wheel_neuron.value)
import hbp_nrp_cle.tf_framework as nrp
from hbp_nrp_cle.robotsim.RobotInterface import Topic
import numpy as np
'''
Transmit laser scan information into sensory neuron activity:
The laser scan is composed of 360 beams, these beams are divided into 2 slices: right and left.
Sensory signals (laser values) are summed up and transformed by an activation function.
The result is the rate of a Poisson generator that stimulates sensory neurons.
'''
@nrp.MapRobotSubscriber("laser",
Topic("/robot/p3dx/laser/scan",
sensor_msgs.msg.LaserScan))
@nrp.MapSpikeSource("right_sensor", nrp.brain.sensors[0], nrp.poisson)
@nrp.MapSpikeSource("left_sensor", nrp.brain.sensors[1], nrp.poisson)
@nrp.Robot2Neuron()
def laser_sensors_transmit(t, right_sensor, left_sensor, laser):
# Handles None value
if laser.value is None:
left_sensor.rate = 100.
return 0
# Activation function definition
def activation_fct(x, x_intercept, y_intercept):
slope = -y_intercept / x_intercept
return max(0, y_intercept + slope * x)
##_TO_DO_## Change 'idx_right' to modify the visual angle involved in the sensory process
idx_right = 0 # first right beam index
idx_middle = 180 # index separating left and right beams
idx_left = 360 - idx_right # last left beam index
def test_rpt_unregister(self, mock_rospy_publisher):
rpt = RosPublishedTopic(Topic('topic_name', 'topic_type'))
pub = mock_rospy_publisher.return_value
rpt._unregister()
self.assertEquals(pub.unregister.call_count, 1)
