def talker(message_name, number_of_cycles):
from message_fixtures import get_test_msg
import rclpy
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from rclpy.qos import qos_profile_default
message_pkg = 'test_communication'
module = importlib.import_module(message_pkg + '.msg')
msg_mod = getattr(module, message_name)
select_rmw_implementation(os.environ['RCLPY_IMPLEMENTATION'])
rclpy.init([])
node = rclpy.create_node('talker')
chatter_pub = node.create_publisher(msg_mod,
'test_message_' + message_name,
qos_profile_default)
cycle_count = 0
print('talker: beginning loop')
msgs = get_test_msg(message_name)
while rclpy.ok() and cycle_count < number_of_cycles:
cycle_count += 1
msg_count = 0
for msg in msgs:
chatter_pub.publish(msg)
msg_count += 1
print('publishing message #%d' % msg_count)
time.sleep(1)
rclpy.shutdown()
def replier(service_name, number_of_cycles):
from service_fixtures import get_test_srv
import rclpy
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from rclpy.qos import qos_profile_services_default
service_pkg = 'test_communication'
module = importlib.import_module(service_pkg + '.srv')
srv_mod = getattr(module, service_name)
select_rmw_implementation(os.environ['RCLPY_IMPLEMENTATION'])
rclpy.init([])
node = rclpy.create_node('replier')
srv_fixtures = get_test_srv(service_name)
chatter_callback = functools.partial(
replier_callback, srv_fixtures=srv_fixtures)
node.create_service(
srv_mod, 'test_service_' + service_name, chatter_callback,
qos_profile_services_default)
spin_count = 1
print('replier: beginning loop')
while rclpy.ok() and spin_count < number_of_cycles:
rclpy.spin_once(node, 2)
spin_count += 1
print('spin_count: ' + str(spin_count))
rclpy.shutdown()
def talker(message_name, rmw_implementation, number_of_cycles):
import rclpy
from rclpy.qos import qos_profile_default
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from message_fixtures import get_test_msg
message_pkg = 'test_communication'
module = importlib.import_module(message_pkg + '.msg')
msg_mod = getattr(module, message_name)
select_rmw_implementation(rmw_implementation)
rclpy.init([])
node = rclpy.create_node('talker')
chatter_pub = node.create_publisher(
msg_mod, 'test_message_' + message_name, qos_profile_default)
cycle_count = 0
print('talker: beginning loop')
msgs = get_test_msg(message_name)
while rclpy.ok() and cycle_count < number_of_cycles:
cycle_count += 1
msg_count = 0
for msg in msgs:
chatter_pub.publish(msg)
msg_count += 1
print('publishing message #%d' % msg_count)
time.sleep(0.1)
time.sleep(1)
rclpy.shutdown()
def func_import_each_available_rmw_implementation(rmw_implementation):
import rclpy
from rclpy.impl.rmw_implementation_tools import get_rmw_implementations
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
rmw_implementations = get_rmw_implementations()
assert(rmw_implementation in rmw_implementations)
select_rmw_implementation(rmw_implementation)
rclpy.init([])
set_rmw = rclpy.get_rmw_implementation_identifier()
assert set_rmw == rmw_implementation, \
"expected '{0}' but got '{1}'".format(
rmw_implementation, set_rmw)
return ctypes.c_bool(True)
def init(args=None):
rclpy_rmw_env = os.getenv(RCLPY_IMPLEMENTATION_ENV_NAME, None)
if rclpy_rmw_env is not None:
available_rmw_implementations = rmw_implementation_tools.get_rmw_implementations(
)
if rclpy_rmw_env not in available_rmw_implementations:
logger = logging.getLogger('rclpy')
logger.error(
"The rmw implementation specified in 'RCLPY_IMPLEMENTATION={0}', "
"is not one of the available implementations: {1}".format(
rclpy_rmw_env, available_rmw_implementations))
raise InvalidRCLPYImplementation()
rmw_implementation_tools.select_rmw_implementation(rclpy_rmw_env)
# This line changes what is in "_rclpy" to be the rmw implementation module that was imported.
implementation_singleton.set_rclpy_implementation(
rmw_implementation_tools.import_rmw_implementation())
# Now we can use _rclpy to call the implementation specific rclpy_init().
return _rclpy.rclpy_init(args if args is not None else sys.argv)
def init(args=None):
rclpy_rmw_env = os.getenv('RCLPY_IMPLEMENTATION', None)
if rclpy_rmw_env is not None:
available_rmw_implementations = rmw_implementation_tools.get_rmw_implementations()
if rclpy_rmw_env not in available_rmw_implementations:
logger = logging.getLogger('rclpy')
logger.error(
"The rmw implementation specified in 'RCLPY_IMPLEMENTATION={0}', "
"is not one of the available implementations: {1}"
.format(rclpy_rmw_env, available_rmw_implementations)
)
raise InvalidRCLPYImplementation()
rmw_implementation_tools.select_rmw_implementation(rclpy_rmw_env)
# This line changes what is in "_rclpy" to be the rmw implementation module that was imported.
implementation_singleton.set_rclpy_implementation(
rmw_implementation_tools.import_rmw_implementation()
)
# Now we can use _rclpy to call the implementation specific rclpy_init().
return _rclpy.rclpy_init(args if args is not None else sys.argv)
def func_import_each_available_rmw_implementation(rmw_implementation):
import rclpy
from rclpy.impl.rmw_implementation_tools import get_rmw_implementations
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
rmw_implementations = get_rmw_implementations()
assert(rmw_implementation in rmw_implementations)
select_rmw_implementation(rmw_implementation)
rclpy.init([])
set_rmw = rclpy.get_rmw_implementation_identifier()
assert set_rmw in identifiers_map, \
"expected identifier '{0}' to be in the map '{1}'".format(set_rmw, identifiers_map)
set_rmw_equivalent = identifiers_map[set_rmw]
assert set_rmw_equivalent == rmw_implementation, \
"expected '{0}' but got '{1}' (aka '{2}')".format(
rmw_implementation, set_rmw_equivalent, set_rmw)
return ctypes.c_bool(True)
def requester(service_name, number_of_cycles):
from service_fixtures import get_test_srv
import rclpy
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from rclpy.qos import qos_profile_services_default
service_pkg = 'test_communication'
module = importlib.import_module(service_pkg + '.srv')
srv_mod = getattr(module, service_name)
select_rmw_implementation(os.environ['RCLPY_IMPLEMENTATION'])
rclpy.init([])
node = rclpy.create_node('requester')
srv_fixtures = get_test_srv(service_name)
client = node.create_client(srv_mod, 'test_service_' + service_name,
qos_profile_services_default)
spin_count = 1
received_replies = []
print('requester: beginning loop')
while rclpy.ok() and spin_count < number_of_cycles:
for req, resp in srv_fixtures:
client.call(req)
client.wait_for_future()
assert repr(client.response) == repr(resp), \
'received unexpected response %r\n\nwas expecting %r' % (client.response, resp)
print('received reply #%d of %d' %
(srv_fixtures.index([req, resp]) + 1, len(srv_fixtures)))
received_replies.append(resp)
spin_count += 1
print('spin_count: ' + str(spin_count))
break
rclpy.shutdown()
assert len(received_replies) == len(srv_fixtures), \
'Should have received %d responsed from replier' % len(srv_fixtures)
print('everything went well !')
def listener(message_name, number_of_cycles):
from message_fixtures import get_test_msg
import rclpy
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from rclpy.qos import qos_profile_default
message_pkg = 'test_communication'
module = importlib.import_module(message_pkg + '.msg')
msg_mod = getattr(module, message_name)
select_rmw_implementation(os.environ['RCLPY_IMPLEMENTATION'])
rclpy.init([])
node = rclpy.create_node('listener')
received_messages = []
expected_msgs = get_test_msg(message_name)
chatter_callback = functools.partial(listener_cb,
received_messages=received_messages,
expected_msgs=expected_msgs)
node.create_subscription(msg_mod, 'test_message_' + message_name,
chatter_callback, qos_profile_default)
spin_count = 1
print('subscriber: beginning loop')
while (rclpy.ok() and spin_count < number_of_cycles
and len(received_messages) != len(expected_msgs)):
rclpy.spin_once(node)
spin_count += 1
print('spin_count: ' + str(spin_count))
rclpy.shutdown()
assert len(received_messages) == len(expected_msgs),\
'Should have received {} {} messages from talker'.format(len(expected_msgs), message_name)
def listener(message_name, rmw_implementation, number_of_cycles):
import rclpy
from rclpy.qos import qos_profile_default
from rclpy.impl.rmw_implementation_tools import select_rmw_implementation
from message_fixtures import get_test_msg
message_pkg = 'test_communication'
module = importlib.import_module(message_pkg + '.msg')
msg_mod = getattr(module, message_name)
select_rmw_implementation(rmw_implementation)
rclpy.init([])
node = rclpy.create_node('listener')
received_messages = []
expected_msgs = get_test_msg(message_name)
chatter_callback = functools.partial(
listener_cb, received_messages=received_messages, expected_msgs=expected_msgs)
node.create_subscription(
msg_mod, 'test_message_' + message_name, chatter_callback,
qos_profile_default)
spin_count = 1
print('subscriber: beginning loop')
while (rclpy.ok() and spin_count < number_of_cycles and
len(received_messages) != len(expected_msgs)):
rclpy.spin_once(node)
spin_count += 1
rclpy.shutdown()
assert len(received_messages) == len(expected_msgs),\
'Should have received {} {} messages from talker'.format(len(expected_msgs), message_name)