InterfaceDataTypes.idl

Go to the documentation of this file.

// -*- IDL -*-
#ifndef InterfaceDataTypes_idl
#define InterfaceDataTypes_idl

#include "BasicDataType.idl"
#include "ExtendedDataTypes.idl"

module RTC {
    //------------------------------------------------------------
    // ActArray
    //------------------------------------------------------------

    struct ActArrayActuatorPos
    {
        Time tm;
        unsigned short index;
        double position;
    };

    struct ActArrayActuatorSpeed
    {
        Time tm;
        unsigned short index;
        double speed;
    };

    struct ActArrayActuatorCurrent
    {
        Time tm;
        unsigned short index;
        double current;
    };

    enum ActArrayActuatorStatus {ACTUATOR_STATUS_IDLE,
                                 ACTUATOR_STATUS_MOVING,
                                 ACTUATOR_STATUS_BRAKED,
                                 ACTUATOR_STATUS_STALLED};

    struct Actuator
    {
        double position;
        double speed;
        double accel;
        double current;
        ActArrayActuatorStatus status;
    };

    typedef sequence<Actuator> ActuatorList;
    struct ActArrayState
    {
        Time tm;
        ActuatorList actuators;
    };

    enum ActArrayActuatorType {ACTARRAY_ACTUATORTYPE_LINEAR,
                               ACTARRAY_ACTUATORTYPE_ROTARY};

    struct ActArrayActuatorGeometry
    {
        ActArrayActuatorType type;
        double length;
        Orientation3D orientation;
        Vector3D axis;
        double minRange;
        double centre;
        double maxRange;
        double homePosition;
        boolean hasBrakes;
    };

    typedef sequence<ActArrayActuatorGeometry> ActArrayActuatorGeometryList;

    struct ActArrayGeometry
    {
        Geometry3D arrayGeometry;
        ActArrayActuatorGeometryList actuatorGeometry;
    };

    //------------------------------------------------------------
    // Bumper
    //------------------------------------------------------------

    struct BumperGeometry
    {
        Pose3D pose;
        Size3D size;
        double roc;
    };

    typedef sequence<BumperGeometry> BumperGeometryList;

    struct BumperArrayGeometry
    {
        Geometry3D arrayGeometry;
        BumperGeometryList bumperGeometry;
    };

    //------------------------------------------------------------
    // Camera
    //------------------------------------------------------------

    struct CameraImage
    {
        Time tm;
        unsigned short width;
        unsigned short height;
        unsigned short bpp;
        string format;
        double fDiv;
        sequence<octet> pixels;
    };

    struct CameraInfo
    {
        Vector2D focalLength;
        Point2D principalPoint;
        double k1;
        double k2;
        double p1;
        double p2;
    };

    //------------------------------------------------------------
    // Fiducial
    //------------------------------------------------------------

    struct FiducialInfo
    {
        unsigned long id;
        Pose3D pose;
        Pose3D poseUncertainty;
        Size3D size;
        Size3D sizeUncertainty;
    };

    typedef sequence<FiducialInfo> FiducialInfoList;

    struct Fiducials
    {
        Time tm;
        FiducialInfoList fiducialsList;
    };

    struct FiducialFOV
    {
        double minRange;
        double maxRange;
        double viewAngle;
    };

    //------------------------------------------------------------
    // GPS
    //------------------------------------------------------------

    struct GPSTime
    {
        unsigned long sec;
        unsigned long msec;
    };

    enum GPSFixType {GPS_FIX_NONE,
                     GPS_FIX_NORMAL,
                     GPS_FIX_DGPS};

    struct GPSData
    {
        Time tm;
        GPSTime timeFromGPS;
        double latitude;
        double longitude;
        double altitude;
        double horizontalError;
        double verticalError;
        double heading;
        double horizontalSpeed;
        double verticalSpeed;
        unsigned short numSatellites;
        GPSFixType fixType;
    };

    //------------------------------------------------------------
    // Gripper
    //------------------------------------------------------------

    enum GripperStatus {GRIPPER_STATE_OPEN,
                        GRIPPER_STATE_CLOSED,
                        GRIPPER_STATE_MOVING,
                        GRIPPER_STATE_UNKNOWN};

    struct GripperState
    {
        Time tm;
        GripperStatus status;
    };

    struct GripperGeometry
    {
        Geometry3D exterior;
        Geometry3D interior;
    };

    //------------------------------------------------------------
    // INS
    //------------------------------------------------------------

    struct INSData
    {
        Time tm;
        double latitude;
        double longitude;
        double altitude;
        double heightAMSL;
        Velocity3D velocityENU;
        Orientation3D orientation;
    };

    //------------------------------------------------------------
    // Limb
    //------------------------------------------------------------

    enum LimbStatus {LIMB_STATUS_IDLE,
                     LIMB_STATUS_BRAKED,
                     LIMB_STATUS_MOVING,
                     LIMB_STATUS_OOR,
                     LIMB_STATUS_COLLISION};

    struct LimbState
    {
        Time tm;
        OAP oapMatrix;
        LimbStatus status;
    };

    //------------------------------------------------------------
    // Localise
    //------------------------------------------------------------

    struct Hypothesis2D
    {
        Pose2D mean;
        Covariance2D covariance;
        double weight;
    };

    typedef sequence<Hypothesis2D> Hypothesis2DList;

    struct Hypotheses2D
    {
        Time tm;
        Hypothesis2DList hypotheses;
    };

    struct Hypothesis3D
    {
        Pose3D mean;
        Covariance3D covariance;
        double weight;
    };

    typedef sequence<Hypothesis3D> Hypothesis3DList;

    struct Hypotheses3D
    {
        Time tm;
        Hypothesis3DList hypotheses;
    };

    //------------------------------------------------------------
    // Map
    //------------------------------------------------------------

    struct OGMapConfig
    {
        double xScale;
        double yScale;
        unsigned long width;
        unsigned long height;
        Pose2D origin;
    };

    typedef sequence<octet> OGMapCells;

    struct OGMapTile
    {
        unsigned long column;
        unsigned long row;
        unsigned long width;
        unsigned long height;
        OGMapCells cells;
    };

    struct PointFeature
    {
        double probability;
        Point2D position;
        PointCovariance2D covariance;
    };
    typedef sequence<PointFeature> PointFeatureList;

    struct PoseFeature
    {
        double probability;
        Pose2D position;
        Covariance2D covariance;
    };
    typedef sequence<PoseFeature> PoseFeatureList;

    struct LineFeature
    {
        double probability;
        double rho;
        double alpha;
        PointCovariance2D covariance;
        Point2D start;
        Point2D end;
        boolean startSighted;
        boolean endSighted;
    };
    typedef sequence<LineFeature> LineFeatureList;

    struct Features
    {
        Time tm;
        PointFeatureList pointFeatures;
        PoseFeatureList poseFeatures;
        LineFeatureList lineFeatures;
    };

    //------------------------------------------------------------
    // Multicamera
    //------------------------------------------------------------

    typedef sequence<CameraImage> MulticameraImageList;
    struct MultiCameraImages
    {
        Time tm;
        MulticameraImageList images;
    };

    typedef sequence<CameraInfo> MulticameraInfoList;

    typedef sequence<Geometry3D> MulticameraGeometryList;

    struct MulticameraGeometry
    {
        Geometry3D geometry;
        MulticameraGeometryList cameraGeometries;
    };

    //------------------------------------------------------------
    // Paths
    //------------------------------------------------------------

    struct Waypoint2D
    {
        Pose2D target;
        double distanceTolerance;
        double headingTolerance;
        Time timeLimit;
        Velocity2D maxSpeed;
    };

    typedef sequence<Waypoint2D> Waypoint2DList;

    struct Path2D
    {
        Time tm;
        Waypoint2DList waypoints;
    };

    struct Waypoint3D
    {
        Pose3D target;
        double distanceTolerance;
        double headingTolerance;
        Time timeLimit;
        Velocity3D maxSpeed;
    };

    typedef sequence<Waypoint3D> Waypoint3DList;

    struct Path3D
    {
        Time tm;
        Waypoint3DList waypoints;
    };

    //------------------------------------------------------------
    // PointCloud
    //------------------------------------------------------------

    struct PointCloudPoint
    {
        Point3D point;
        RGBColour colour;
    };

    typedef sequence<PointCloudPoint> PointCloudPointList;

    struct PointCloud
    {
        Time tm;
        PointCloudPointList points;
    };

    //------------------------------------------------------------
    // PanTilt
    //------------------------------------------------------------

    struct PanTiltAngles
    {
        Time tm;
        double pan;
        double tilt;
    };

    struct PanTiltState
    {
        Time tm;
        PanTiltAngles angles;
        double panSpeed;
        double tiltSpeed;
    };

    //------------------------------------------------------------
    // Ranger
    //------------------------------------------------------------

    typedef sequence<Geometry3D> ElementGeometryList;

    struct RangerGeometry
    {
        Geometry3D geometry;
        ElementGeometryList elementGeometries;
    };

    struct RangerConfig
    {
        double minAngle;
        double maxAngle;
        double angularRes;
        double minRange;
        double maxRange;
        double rangeRes;
        double frequency;
    };

    typedef sequence<double> RangeList;

    struct RangeData
    {
        Time tm;
        RangeList ranges;
        RangerGeometry geometry;
        RangerConfig config;
    };

    typedef sequence<double> IntensityList;

    struct IntensityData
    {
        Time tm;
        IntensityList intensities;
        RangerGeometry geometry;
        RangerConfig config;
    };

    //------------------------------------------------------------
    // RFID
    //------------------------------------------------------------

    typedef sequence<octet> RFIDTagData;
};

#endif // InterfaceDataTypes_idl