def test_double_array(self):
double_array = array('d', [1.0, 2.0, 3.0])
self.assertEqual(Parameter.Type.DOUBLE_ARRAY,
Parameter.Type.from_parameter_value(double_array))
# test that it doesn't raise
Parameter.from_parameter_msg(
ParameterMsg(name='double_array',
value=ParameterValue(
type=8, double_array_value=[1.0, 2.0, 3.0])))
def test_integer_array(self):
int_array = array('i', [1, 2, 3])
self.assertEqual(Parameter.Type.INTEGER_ARRAY,
Parameter.Type.from_parameter_value(int_array))
# test that it doesn't raise
Parameter.from_parameter_msg(
ParameterMsg(name='int_array',
value=ParameterValue(type=7,
integer_array_value=[1, 2, 3])))
def _on_parameter_event(self, event):
if event.node != self._remote_node_name:
return
if self._param_change_callback is not None:
self._param_change_callback([
Parameter.from_parameter_msg(p) for p in event.new_parameters
], [
Parameter.from_parameter_msg(p)
for p in event.changed_parameters
], [
Parameter.from_parameter_msg(p)
for p in event.deleted_parameters
])
def get_parameters(self, names):
get_params_request = GetParameters.Request()
get_params_request.names = names
get_params_response = self._get_params_client.call(get_params_request)
return [
Parameter.from_parameter_msg(ParameterMsg(name=name, value=value))
for name, value in zip(names, get_params_response.values)
]
def _set_parameters_atomically_callback(self, request, response):
try:
response.result = self._node.set_parameters_atomically(
[Parameter.from_parameter_msg(p) for p in request.parameters])
except ParameterNotDeclaredException as e:
response.result = SetParametersResult(successful=False,
reason=str(e))
return response
def _set_parameters_callback(self, request, response):
node = self._get_node()
for p in request.parameters:
param = Parameter.from_parameter_msg(p)
try:
result = node.set_parameters_atomically([param])
except ParameterNotDeclaredException as e:
result = SetParametersResult(successful=False, reason=str(e))
response.results.append(result)
return response
def param_event_callback(self, event):
for new_parameter in event.new_parameters:
self.get_logger().info('New parameter name : {0}'.format(
new_parameter.name))
for changed_parameter in event.changed_parameters:
self.get_logger().info('Changed parameter name : {0}'.format(
changed_parameter.name))
if changed_parameter.name == 'blind':
self.blind = Parameter.from_parameter_msg(
changed_parameter).value
elif changed_parameter.name == 'offset':
self.offset = Parameter.from_parameter_msg(
changed_parameter).value
elif changed_parameter.name == 'comment':
self.comment = Parameter.from_parameter_msg(
changed_parameter).value
for deleted_parameter in event.deleted_parameters:
self.get_logger().info('Deleted parameter name : {0}'.format(
deleted_parameter.name))
def _set_parameters_atomically_callback(self, request, response):
response.result = self._node.set_parameters_atomically(
[Parameter.from_parameter_msg(p) for p in request.parameters])
return response
def _set_parameters_callback(self, request, response):
for p in request.parameters:
param = Parameter.from_parameter_msg(p)
response.results.append(
self._node.set_parameters_atomically([param]))
return response
def declare_parameters(
self, namespace: str,
parameters: List[Tuple[str, Optional[ParameterValue],
Optional[ParameterDescriptor]]]
) -> List[Parameter]:
"""
Declare a list of parameters.
This method, if successful, will result in any callback registered with
:func:`set_parameters_callback` to be called once for each parameter.
If one of those calls fail, an exception will be raised and the remaining parameters will
not be declared.
Parameters declared up to that point will not be undeclared.
:param namespace: Namespace for parameters.
:param parameters: Tuple with parameters to declare, with a name, value and descriptor.
:return: Parameter list with the effectively assigned values for each of them.
:raises: ParameterAlreadyDeclaredException if the parameter had already been declared.
:raises: InvalidParameterException if the parameter name is invalid.
:raises: InvalidParameterValueException if the registered callback rejects any parameter.
"""
parameter_list = []
descriptor_list = []
for parameter_tuple in parameters:
name = parameter_tuple[0]
assert isinstance(name, str)
# Get value from initial parameters, of from tuple if it doesn't exist.
if name in self._initial_parameters:
value = self._initial_parameters[name].get_parameter_value()
elif parameter_tuple[1] is None:
value = ParameterValue()
else:
value = parameter_tuple[1]
assert isinstance(value, ParameterValue)
descriptor = parameter_tuple[2]
if descriptor is None:
descriptor = ParameterDescriptor()
assert isinstance(descriptor, ParameterDescriptor)
# Note(jubeira): declare_parameters verifies the name, but set_parameters doesn't.
full_name = namespace + name
validate_parameter_name(full_name)
parameter_list.append(
Parameter.from_parameter_msg(
ParameterMsg(name=full_name, value=value)))
descriptor_list.append(descriptor)
parameters_already_declared = [
parameter.name for parameter in parameter_list
if parameter.name in self._parameters
]
if any(parameters_already_declared):
raise ParameterAlreadyDeclaredException(
parameters_already_declared)
# Call the callback once for each of the parameters, using method that doesn't
# check whether the parameter was declared beforehand or not.
self._set_parameters(parameter_list,
descriptor_list=descriptor_list,
raise_on_failure=True)
return self.get_parameters(
[parameter.name for parameter in parameter_list])
def start_controller(self, req, res):
port_name = req.port_name
package_path = req.package_path
module_name = req.module_name
class_name = req.class_name
controller_name = req.controller_name
parameters = [Parameter.from_parameter_msg(p) for p in req.parameters]
self.start_controller_lock.acquire()
if controller_name in self.controllers:
self.start_controller_lock.release()
res.success = False
res.reason = 'Controller [%s] already started. If you want to restart it, call restart.' % controller_name
return res
try:
if module_name not in sys.modules:
# import if module not previously imported
package_module = __import__(package_path, globals(), locals(),
[module_name])
else:
# reload module if previously imported
package_module = reload(sys.modules[package_path])
controller_module = getattr(package_module, module_name)
except ImportError as ie:
self.start_controller_lock.release()
res.success = False
res.reason = 'Cannot find controller module. Unable to start controller %s\n%s' % (
module_name, str(ie))
return res
except SyntaxError as se:
self.start_controller_lock.release()
res.success = False
res.reason = 'Syntax error in controller module. Unable to start controller %s\n%s' % (
module_name, str(se))
return res
except Exception as e:
self.start_controller_lock.release()
res.success = False
res.reason = 'Unknown error has occured. Unable to start controller %s\n%s' % (
module_name, str(e))
return res
kls = getattr(controller_module, class_name)
if port_name == 'meta':
self.waiting_meta_controllers.append(
(controller_name, req.dependencies, kls))
self.check_deps()
self.start_controller_lock.release()
res.success = True
res.reason = ''
return res
if port_name != 'meta' and (port_name not in self.serial_proxies):
self.start_controller_lock.release()
res.success = False
res.reason = 'Specified port [%s] not found, available ports are %s. Unable to start controller %s' % (
port_name, str(self.serial_proxies.keys()), controller_name)
return res
controller = kls(self.serial_proxies[port_name].dxl_io,
controller_name,
port_name,
node_namespace=self.get_namespace(),
parameters=parameters)
if controller.initialize():
controller.start()
self.controllers[controller_name] = controller
rclpy.get_global_executor().add_node(controller)
self.check_deps()
self.start_controller_lock.release()
res.success = True
res.reason = 'Controller %s successfully started.' % controller_name
return res
else:
self.start_controller_lock.release()
res.success = False
res.reason = 'Initialization failed. Unable to start controller %s' % controller_name
return res
