Actuation

The Actuation service contains the actions and objects needed to make the robot move:

• the robot and gaze frames
• the factory for Animation objects
• the factories for GoTo, Animate and LookAt actions

ActuationConverter

Animate

Action to play animations on the robot.

Animation

Object representing a robot animation. An animation can be composed of gestures performed by the robot limbs, head, and/or trajectories performed by the robot base.

AttachedFrame

Object representing a frame attached to a parent frame. The link between the parent and the attached frame, i.e. the relative location of the attached frame to its parent, is editable. In order to compute transforms between frames, one should use the frame() function of an AttachedFrame.

EnforceTabletReachability

Action to limit robot movements in order to ease user interaction on the tablet. The robot will put the tablet at a suitable position then emit the positionReached() signal, and prevent further leg and base movements, while also ensuring that the arms movements do not bring them in front of the tablet.

ExplorationMap

Object encapsulating the data needed by the robot to localize himself inside his environment.

Frame

Object representing the location associated with an object or a person. This location is likely to change over time, for example when a person moves. Transforms can be computed out of two frames, at a given time, to get the relative position and orientation between two objects. If the robot is localized using external sensors, the transform between two frames can be computed with odometry drift compensation.

FreeFrame

Object representing a reference frame free to be placed anywhere, that does not move when other frames move. The global position of a free frame can be updated by giving its location at a given time in a given reference frame. In order to compute transforms between frames, one should use the frame() function of a FreeFrame. The FreeFrame will be invalid right after creation until first update.

GoTo

Action to make the robot go somewhere. The destination is represented by a target frame. The robot will try to reach safely the 2D location corresponding to the target frame while avoiding obstacles. The robot may look around and follow non-straight paths, in order to choose the safest way towards the target.

GoToConfig

Configuration parameters of a GoTo action. If a parameter is not set by the user, it is up to the action to set it to its default behavior.

LocalizationStatus

Localization process status

Localize

Action to make the robot localize himself in a map, previously built by a LocalizeAndMap action. Only one LocalizeAndMap or Localize action can run at a time. When run, the robot first executes a rotating base and head scan. During this initial scan, the action needs all the robot resources to run, and the action status is `Scanning`. After this scan, the robot is localized inside his map, and his position and orientation relatively to the map origin can be retrieved, at any time, by calling `Actuation.robotFrame().computeTransform(Mapping.mapFrame())` While the action is running, the robot may autonomously look around to confirm his location.

LocalizeAndMap

Action to make the robot explore an unknown environment, while localizing himself inside it and building a representation of this environment, known as an exploration map. Only one action among LocalizeAndMap or Localize can run at a time. When run, the robot first executes a rotating base and head scan. During this initial scan, the action needs all the robot resources to run and the action status is `Scanning`. After the scan, it is the developer's responsibility to make the robot move, and to stop the mapping when done. The developer thus has full control over the mapped area. While the action is running, the robot may autonomously look around to confirm his location. A given environment needs to be mapped once and only once. The result of this mapping can be dumped to a ExplorationMap object. Afterwards, the ExplorationMap object can be used to create a Localize action, that will enable the robot to keep track of his position relatively to the map.

LookAt

Action to look at and track a target. The target is represented by a frame, and the robot will look at the origin of that frame. In practice, the action will make the robot move so that the x-axis of the gaze frame gets aligned with the origin of the target frame. The robot will track the target until the run is canceled.

LookAtMovementPolicy

Strategies to look at a target.

Mapping

A service providing the mapping of the local area.

MapTopGraphicalRepresentation

Used to display map shape on a UI. Scale, x, y and theta can be used to switch from world coordinates relatively to mapFrame to image coordinates in pixels using the following formulas: //! x_map = scale * (cos(theta) * x_img + sin(theta) * y_img) + x y_map = scale * (sin(theta) * x_img - cos(theta) * y_img) + y x_img = 1/scale * (cos(theta) * (x_map - x) + sin(theta) * (y_map-y)) y_img = 1/scale * (sin(theta) * (x_map - x) - cos(theta) * (y_map-y)) Map frame Image pixel coordinates //! ^ y_map in meters + -----> x_img in pixels | | | | +-----> x_map v y_img

OrientationPolicy

Policy defining orientation control of a given frame with respect to a target frame.

PathPlanningPolicy

Path planning strategies to go to a target.