core.backend package

Submodules

core.backend.config_interpreter module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

core.backend.config_interpreter.getConfig(configfilename='configuration.xml', config_id_to_use=None)

Read in the configuration file with path configfilename.

If config_id_to_use is set, use a configuration with this specific id.

Parameters:

• configfilename – the xml-file containing configuration(s) (default configuration.xml)
• config_id_to_use – use this specific configuration from within the configuration file (default None)

core.backend.config_interpreter.recursiveGet(domparent, parent)

Get information from dom element domparent and place in an abstraction called parent.

Recursively increase depth, stepping untill the deepest level of domparent. use objects from core.aero.objects to create an abstraction.

Parameters:

• domparent – the (current) dom parent
• parent – the parent to which abstractions of the domparent are to be added

core.backend.config_matcher module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

core.backend.config_matcher.matchConfig(configuration, available_mods)

Start matching modules and settings specified in configuration to available modules in available_mods.

Parameters:

• configuration – the abstraction of a configuration
• available_mods – list of all available modules (can be delivered by core.aero.scan.getAvailableModules() )

core.backend.config_matcher.recursiveMatch(parent, available_mods)

Find a the abstraction of an object mentioned in parent in available_mods and return.

Also step into every level of parent recusively and finally return is an abstraction of parent with all children abstracted.

Parameters:

• parent – the to-be-implemented object
• available_mods – list of all available modules (can be delivered by core.aero.scan.getAvailableModules()

core.backend.helpers module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

core.backend.helpers.findModuleById(available_mods, module_id)

Find a module from list of modules (available_mods) by its module_id and return the module.

Return None if the module is there is not a module with id module_id in available_mods.

Parameters:

• available_mods – list of all available modules
• module_id – id of the module to find

core.backend.helpers.getElements(node)

Return a list of al dom elements in the element node.

Parameters:node – the parent element

core.backend.helpers.getElementsOnFirstLevel(parent, element)

Return a list of elements below parent, that have tagname element.

Parameters:

• parent – the parent element
• element – tagname of elements to return in the list

core.backend.helpers.getElementsOnFirstLevelExceptTag(parent, element)

Return all elements below parent except for the ones tagged element.

Parameters:

• parent – the parent dom object
• elemnt – the tag-name of elements not to return

core.backend.helpers.getOptionalAttribute(element, attribute)

Return the value of an attribute from an element, but do not crash/throw if attribute does not exist.

Return None if attribute is not in the parent element.

Parameters:

• element – the parent element that (might) contain(s) the attribute
• attribute – the optional attribute to return the value of

core.backend.helpers.lookupMessageType(message_type)

Look up a message type from a list given its acronym message_type and returns the full message type.

If the message_type is not an acronym from the list, return message_type.

Parameters:message_type – the acronym to look up, or a non acronym message type

core.backend.helpers.toJSON(py_object)

Convert an object to JSON string using its __dict__

Parameters:py_object – object to create a JSON string of

core.backend.objects module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

class core.backend.objects.Cmdline_argument(executable_id, argument)

An argument to use when starting a specific rosnode. Used for instance when starting rviz with a configuration file.

Parameters:

• executable_id – id of the executable this argument is used for
• argument – string of all arguments to use for this executable

class core.backend.objects.Configuration(id)

A Configuration is a list of settings, usually from a configuration file, used to setup an experiment.

it contains: :param id: unique id for this configuration :param modules_to_add: list of modules needed in this configuration :param connections_to_add: list of connections needed :param namespaces: list of :class:Namespace in this configuration

class core.backend.objects.Connection_to_add(publisher, listener)

Representation of a connection desired to add to a configuration

Parameters:

• publisher – topic of the publisher to be connected
• subscriber – topic of the subscriber to be connected

class core.backend.objects.Executable(id, pkg, executable)

An executable represents a ROS node that can be launched through a ROS launch file, generated by the AeroWorks infrastructure.

addInput(interface)

Adds an input to the list of executable inputs (inputs).

Parameters:interface (Interface) – The interface to add

addOutput(interface)

Adds an output to the list of executable outputs (outputs).

Parameters:interface (Interface) – The interface to add

addParameter(parameter)

Adds a parameter to the list of executable parameters (params).

Parameters:parameter (Parameter) – The parameter to add

args = None

A string with default arguments

executable = None

The ROS node executable to launch. E.g. “joy_node”.

getInterface(name)

id = None

The ID of the executable, as given in the viki.xml.

inputs = None

A list of Interface describing all inputs of the executable.

outputs = None

A list of Interface describing all outputs of the executable.

params = None

A list of Parameter describing parameters to be set for the executable.

pkg = None

The ROS package that contains the executable. E.g.: “joy”

setArguments(argument)

class core.backend.objects.Interface(interface_type, name, message_type, required, link=None, namespace='base')

An interface represents an in- or output of a module. This in- and outputs can be connected to other module’s in- and outputs.

link = None

Contains the reference to the executable within the module that actually provides the in- or output. E.g.: “test_node/test_topic”

message_type = None

Represents the message type the interface can handle. E.g.: “twist” or “standard_msgs/Empty”

name = None

Represents the name of the interface. E.g.: “cmd_vel”

namespace = None

Namespace used in the ros package for this topic, “base”, “global” or “private”; according to wiki.ros.org/Names

required = None

Defines if the interface is required to be connected. Execution will halt if this requirement is not met.

type = None

Represents the type of the interface. E.g.: “ros_topic”

class core.backend.objects.Internal_Interface(publisher, listener)

An internal_interface represents a connection between an in- and output within a module. At this point, implicitly only implemented for ros_topic type interfaces.

Note

In the future, this might be a specific case of Interface.

listener = None

Refers to the topic where the node is listening for messages. This topic is remapped to listen to the publisher. E.g. “node2_name/i_listen_here”

publisher = None

Refers to the topic on which messages are be published. E.g. “node_name/command_giver”

class core.backend.objects.Launch_prefix(executable_id, prefix)

A launch prefix that will be run before the actual ROSnode. Can be very useful to for instance start a node in debug mode.

Parameters:

• executable_id – id of the executable this prefix is used for
• prefix – string of the prefix

class core.backend.objects.Machine(name, hostname, username, password)

class core.backend.objects.Module(type, id)

A module represents a separately distributable piece of software, that is able to work within the AeroWorks infrastructure.

addExecutable(executable)

Adds an executable to the list of module executables (executables). Those executables are ROS nodes.

Parameters:executable (Executable) – The executable to add.

addInput(interface)

Adds an input to the list of module inputs (inputs).

Parameters:interface (Interface) – The interface to add

addIntConnect(internal_interface)

Adds an internal connection to the list of module internal connections (config).

Parameters:internal_interface (Internal_Interface) – The connection to add

addMeta(key, value)

Adds metadata to meta.

Parameters:

• key (string) – The key of the metadata. E.g. “name”
• value (string) – The value of the metadata. E.g. “AeroWorks”

addMissingPackage(package_name)

addOutput(interface)

Adds an output to the list of module outputs (outputs).

Parameters:interface (Interface) – The interface to add

addPackageDependency(package_name, type='apt-get', src='')

config = None

A list of Internal_Interface describing all internal connections.

executables = None

A list of Executable describing all executables (ROS nodes) in the module.

getExecutable(exec_id)

Returns the executable with the id, within this module :param exec_id: the string id of the executable, as defined in the xml file :return: Executable

id = None

Represents the ID of the module, as defined in the viki.xml. This is used for identifying and selecting the module throughout the process, so this value should be unique.

inputs = None

A list of Interface describing all inputs of the module.

meta = None

Contains a dictionary with all module metadata, as defined in viki.xml.

missing_packages = None

List with missing packages, initially empty

outputs = None

A list of Interface describing all outputs of the module.

package_dependencies = None

List with names of dependent ROS packages

path = None

Contains the path to the module config

setPath(path)

Sets the path for the current module.

Parameters:path (string) – The path where to find the module

type = None

Represents the type of the module, as defined in the viki.xml. This categorization is added for the comfort of the user. Examples are “userinput”, “sensor”, “controller” and “vehicle”.

class core.backend.objects.Module_to_add(role, type, id, supress_warning=False)

An object representing a module that is desired to be in a configuration. It is a temporary container for all information to get the actual :class:Module classes, and contains an implementation where the :class:Module can be placed.

Parameters:

• role – role of this module eg. userinput, vehicle, etc.
• id – unique id of the module
• type – type of module
• supress_warning – suppress warnings given in/by this module (not yet implemented)
• parameters_to_add – list of parameters that are to be added to class:Executable in this module
• args – list of command line arguments that are used to start this modules nodes

add_cmdline_arg(arg)

Add a command line argument object arg to the list of arguments needed to run this module

Parameters:arg – The command line argument object to add

add_machine_selection(selection)

Add a machine selection object selection to the list of machine selections desired to run

Parameters:selection – machine selection object

add_prefix(pf)

Add a launch-prefix object pf to the list of prefixes desired to run

Parameters:pf – prefix object

class core.backend.objects.Namespace(id)

A namespace is in itself basically a :class:Configuration , which can in turn contain multiple namespaces.

Parameters:

• id – unique id for this configuration
• modules_to_add – list of modules needed in this configuration
• connections_to_add – list of connections needed
• namespaces – list of *namespace*s

class core.backend.objects.Parameter(name, type, default=None, value=None)

A Parameter represents a param in the rosparam server

Parameters:

• name – The name of the parameter
• default – A default value, when no specific value is given
• type – Type of parameter
• value – Value of the parameter

class core.backend.objects.Parameter_to_add(name, value)

A parameter to add to a module (and finally to an executable)

Parameters:

• name – name of the parameter
• value – value of the parameter

class core.backend.objects.Selected_machine(executable_id, machine_name)

A machine selection defines at what machine the ros_node will run.

Parameters:

• executable_id – id of the executable this selection is used for
• machine_name – name of the machine

core.backend.scan module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

core.backend.scan.getAvailableModules(viki_config)

Return a list of modules available in the framework at this moment.

1. Run through the entire project tree searching for files called ‘viki.xml’.
2. Create an abstraction from each .xml file as objects from core.aero.objects.
3. Put abstraction in a list
4. Return list when done.

core.backend.writeLaunch module

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License

core.backend.writeLaunch.getName(obj)

core.backend.writeLaunch.lookup(configPart, string, path)

core.backend.writeLaunch.lookupInternal(string, mod)

core.backend.writeLaunch.prettify(elem)

Return a pretty-printed XML string for the Element.

core.backend.writeLaunch.recursiveWrite(configPart, configElem, rootElem, path='')

core.backend.writeLaunch.write(configuration, filename='aeroworks.launch')

Module contents

VIKI: more than a GUI for ROS, https://github.com/UT-RAM/viki version: 0.2 - Alice copyright: Robin Hoogervorst, Alex Kamphuis, Cees Trouwborst, 2016 licensed under the MIT License