middleware Package

middleware Package

abstract_datastream Module

class AbstractDatastream(component_instance, kwargs)

Bases: builtins.object

The class is inherited by all serializers/deserializers. Concrete classes need to implement default().

component_name

data

default(ci='unused')

default method called by MORSE logic

Sensor: must read local_data, format and publish them. Actuator: must read a new incoming command and update local_data.

finalize()

finalize the specific datastream

Can be overriden if needed

initialize()

initialize the specific datastream

Can be overriden if needed

moos_datastream Module

class MOOSDatastreamManager

Bases: morse.core.datastream.DatastreamManager

Handle communication between Blender and MOOS.

pocolibs_datastream Module

class DummyPoster(name)

Bases: builtins.object

exception InvalidRead(value)

Bases: builtins.Exception

class PocolibsDataStreamInput(component_instance, kwargs)

Bases: morse.middleware.abstract_datastream.AbstractDatastream

finalize()

initialize(kind)

read()

class PocolibsDataStreamOutput(component_instance, kwargs)

Bases: morse.middleware.abstract_datastream.AbstractDatastream

finalize()

initialize(kind)

write(obj)

class PocolibsDatastreamManager

Bases: morse.core.datastream.DatastreamManager

Handle communication between Blender and Pocolibs.

compute_date()

Compute the current time

( we only require that the date increases using a constant step so real time is ok)

exception PosterNotFound(value)

Bases: builtins.Exception

poster_name(component_name, mw_data)

pocolibs_request_manager Module

class PocolibsRequestManager

Bases: morse.core.request_manager.RequestManager

Implements Pocolibs requests to control the MORSE simulator.

This is done by re-implementing (parts of) the TCLserv protocol.

HOST = ''

PORT = 9473

finalization()

Terminate the ports used to accept requests

initialization()

main()

on_service_completion(intern_rqst_id, result)

post_registration(component, service, is_async)

ros_datastream Module

The ROS ‘datastream manager’ is responsible for ROS topic management in MORSE. It publishes simulated sensors and subscribes to topics controlling simulated actuators.

As you may have noticed, the morse.middleware.ros_datastream.ROSDatastreamManager class is actually empty: contrary to sockets, for instance, that always use direct JSON serialization of MORSE Python objects, there is no generic way to encode/decode ROS messages.

Thus, morse/middleware/ros contains one specific serialization/deserialization class for each sensor/actuator. These classes inherit either from morse.middleware.ros.abstract_ros.ROSPublisher or from:py:class:morse.middleware.ros.abstract_ros.ROSSubscriber.

If you want to add support for a new type of topic, you likely want to add it as a new serialization implementation in this directory.

Note also that management of ROS services and ROS actions takes place in ros_request_manager.py.

class ROSDatastreamManager

Bases: morse.core.datastream.DatastreamManager

Handle communication between Blender and ROS.

ros_request_manager Module

class RosAction(manager, component, action, rostype)

Bases: builtins.object

Implements a minimal action state machine.

See http://www.ros.org/wiki/actionlib/DetailedDescription for the possible states.

get_id_from_internal_id(morse_id)

getstatus(id)

manage_internal_id(morse_id)

Check if this ROS action manager manages the given internal request ID.

This is used by RosRequestManager to dispatch the service ‘on completion’ event.

on_cancel(goal_id)

on_goal(goal)

on_result(morse_id, state, result)

publish_result(goal_id, result)

set_internal_id(id, morse_id)

setstatus(id, status)

class RosRequestManager

Bases: morse.core.request_manager.RequestManager

add_ros_handler(component_name, service_name)

Dynamically creates custom ROS->MORSE dispatchers for ROS services only.

ROS actions are dealt with in the RosAction class.

finalization()

initialization()

main()

on_service_completion(request_id, result)

post_registration(component_name, service_name, is_async)

We create here ROS services (for synchronous services) and ROS actions (for asynchronous services).

In order not to interfere with neither ROS own service wrapping mechanism or MORSE service invokation mechanisms, we create here, ‘on the fly’, handlers for each service exposed through ROS.

ROS requires type for the services/actions. Those can be set with the ros_action() and ros_service() decorators. If none is set, the action/service is discarded.

register_ros_action(method, component_name, service_name)

register_ros_service(method, component_name, service_name)

ros_action(fn=None, type=None, name=None)

The @ros_action decorator.

This decorator is very similar to the standard morse.core.services.async_service() decorator. It sets a class method to be a asynchronous service, exposed as a ROS action of type type.

This decorator can only be used on methods in classes inheriting from morse.core.object.Object.

Parameters:

• fn (callable) – [automatically set by Python to point to the decorated function]
• type (class) – you MUST set this parameter to define the type of the ROS action.
• name (string) – by default, the name of the service is the name of the method. You can override it by setting the ‘name’ argument. Your ROS action will appear as /component_instance/<name>/...

ros_service(fn=None, type=None, component=None, name=None)

The @ros_service decorator.

This decorator is very similar to the standard morse.core.services.service() decorator. It sets a free function or class method to be a (synchronous) service, exposed as a ROS service of type type.

This decorator works both with free function and for methods in classes inheriting from morse.core.object.Object. In the former case, you must specify a component (your service will belong to this namespace), in the later case, it is automatically set to the name of the corresponding MORSE component.

Parameters:

• fn (callable) – [automatically set by Python to point to the decorated function]
• type (class) – you MUST set this parameter to define the type of the ROS action.
• component (string) – you MUST set this parameter to define the name of the component which export the service ONLY for free functions. Cf explanation above.
• name (string) – by default, the name of the service is the name of the method. You can override it by setting the ‘name’ argument. Your ROS service will appear as /<name>

ros_timer(callable_obj, frequency)

socket_datastream Module

class MorseEncoder(skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

default(obj)

class SocketDatastreamManager

Bases: morse.core.datastream.DatastreamManager

External communication using sockets.

get_all_stream_ports()

Get stream ports for all streams.

get_stream_port(name)

Get stream port for stream name.

list_streams()

List all publish streams.

register_component(component_name, component_instance, mw_data)

Open the port used to communicate by the specified component.

class SocketPublisher(component_instance, kwargs)

Bases: morse.middleware.socket_datastream.SocketServ

default(ci='unused')

encode()

class SocketReader(component_instance, kwargs)

Bases: morse.middleware.socket_datastream.SocketServ

decode(msg)

default(ci='unused')

class SocketServ(component_instance, kwargs)

Bases: morse.middleware.abstract_datastream.AbstractDatastream

close_socket(sock)

finalize()

Terminate the ports used to accept requests

initialize()

socket_request_manager Module

class SocketRequestManager

Bases: morse.core.request_manager.RequestManager

Implements services to control the MORSE simulator over raw ASCII sockets.

The syntax of requests is:

>>> id component_name service [params with Python syntax]

id is an identifier set by the client to conveniently identify the request. It must be less that 80 chars in [a-zA-Z0-9].

The server answers:

>>> id status result_in_python|error_msg

status is one of the constants defined in morse.core.status.

finalization()

Terminate the ports used to accept requests

initialization()

main()

on_service_completion(request_id, results)

post_registration(component, service, is_async)

text_datastream Module

class BasePublisher(component_instance, kwargs)

Bases: morse.middleware.abstract_datastream.AbstractDatastream

default(ci)

encode_data()

finalize()

header()

initialize()

class CSVPublisher(component_instance, kwargs)

Bases: morse.middleware.text_datastream.BasePublisher

encode_data()

header()

class Publisher(component_instance, kwargs)

Bases: morse.middleware.text_datastream.BasePublisher

encode_data()

header()

class TextDatastreamManager

Bases: morse.core.datastream.DatastreamManager

Produce text files as output for the components

yarp_datastream Module

class YarpDatastreamManager

Bases: morse.core.datastream.DatastreamManager

Handle communication between Blender and YARP.

finalize()

Close all currently opened ports and release the network.

class YarpImagePublisher(component_instance, kwargs)

Bases: morse.middleware.yarp_datastream.YarpPort

default(ci)

initialize()

class YarpPort(component_instance, kwargs)

Bases: morse.middleware.abstract_datastream.AbstractDatastream

connect2topic(topic)

Connect a yarp port to a specific yarp topic.

finalize()

initialize(port_creator_fn, is_input)

class YarpPublisher(component_instance, kwargs)

Bases: morse.middleware.yarp_datastream.YarpPort

default(ci)

encode(bottle)

encode_message(bottle, data, component_name)

Prepare the content of the bottle

This function can be recursively called in case of list processing

initialize()

class YarpReader(component_instance, kwargs)

Bases: morse.middleware.yarp_datastream.YarpPort

default(ci)

initialize()

yarp_json_request_manager Module

class YarpRequestManager

Bases: morse.core.request_manager.RequestManager

Implements services to control the MORSE simulator over YARP

The syntax of requests is: >>> id component_name service [params with Python syntax]

‘id’ is an identifier set by the client to conveniently identify the request. It must be less that 80 chars in [a-zA-Z0-9].

The server answers: >>> id OK|FAIL result_in_python|error_msg

finalization()

initialization()

main()

Read commands from the ports, and prepare the response

on_service_completion(request_id, results)

post_registration(component_name, service, is_async)

Register a connection of a service with YARP

yarp_request_manager Module

class YarpRequestManager

Bases: morse.core.request_manager.RequestManager

Implements services to control the MORSE simulator over YARP

The syntax of requests is: >>> id component_name service [params with Python syntax]

‘id’ is an identifier set by the client to conveniently identify the request. It must be less that 80 chars in [a-zA-Z0-9].

The server answers: >>> id OK|FAIL result_in_python|error_msg

finalization()

initialization()

main()

Read commands from the ports, and prepare the response

on_service_completion(request_id, results)

post_registration(component_name, service, is_async)

Register a connection of a service with YARP

Subpackages

• moos Package
  • moos Package
  • abstract_moos Module
  • gps Module
  • gyroscope Module
  • imu Module
  • motion Module
  • pose Module
  • sick Module
• pocolibs Package
  • Subpackages
    • actuators Package
      • genpos Module
      • lwr Module
      • niut Module
      • platine Module
    • overlays Package
      • fingers Module
      • platine_overlay Module
      • rflex_overlay Module
      • stereopixel_overlay Module
      • velodyne_overlay Module
      • viam_overlay Module
    • sensors Package
      • human_posture Module
      • platine_posture Module
      • pom Module
      • stereopixel Module
      • target Module
      • velodyne Module
      • viam Module
      • viman Module
• ros Package
  • ros Package
  • abstract_ros Module
  • accelerometer Module
  • battery Module
  • clock Module
  • depth_camera Module
  • destination Module
  • force_torque Module
  • gps Module
  • helpers Module
  • imu Module
  • infrared Module
  • jido_posture Module
  • jointpositions Module
  • jointstate Module
  • jointtrajectorycontrollers Module
  • kuka_jointpositions Module
  • kuka_jointstate Module
  • kuka_jointstate_pub Module
  • laserscanner Module
  • light Module
  • motion_vw Module
  • motion_xyw Module
  • odometry Module
  • orientation Module
  • platine Module
  • pose Module
  • ptu_posture Module
  • read_asctec_ctrl_input Module
  • read_pose Module
  • semantic_camera Module
  • tfMessage Module
  • velocity Module
  • video_camera Module
  • waypoint2D Module
  • Subpackages
    • overlays Package
      • armatures Module
      • waypoints Module
• sockets Package
  • depth_camera Module
  • jointstate Module
  • video_camera Module
• yarp Package
  • laserscanner Module
  • yarp_json Module