VesselInstrumentsGeneric

Generic types for vessel instruments.

/** @file VesselInstrumentsGeneric.idl */
 
/** Types used in Ratatosk
@ingroup Types 
*/
module ratatosk
{
    module types
    {
        struct TypeTest
        {
            char               charVal;
            octet              uint8Val;
            short              int16Val;
            unsigned short     uint16Val;
            long               int32Val;
            unsigned long      uint32Val;
            long long          int64Val;
            unsigned long long uint64Val;
            float              floatVal;
            double             doubleVal;
            boolean            boolVal;
            string             stringVal;
        };
#pragma keylist TypeTest
 
        struct ArrayTest
        {
            long     vals[3];
            TypeTest test;
        };
 
        /// Char
        struct Int8Val
        {
            char val;
        };
#pragma keylist Int8Val
 
        /// Octadecimal
        struct Uint8Val
        {
            octet val;
        };
#pragma keylist Uint8Val
 
        /// Short
        struct Int16Val
        {
            short val;
        };
#pragma keylist Int16Val
 
        /// Unsigned short
        struct Uint16Val
        {
            unsigned short val;
        };
#pragma keylist Uint16Val
 
        /// Long
        struct Int32Val
        {
            long val;
        };
#pragma keylist Int32Val
 
        /// Unsigned long
        struct Uint32Val
        {
            unsigned long val;
        };
#pragma keylist Uint32Val
        
        /// Long long
        struct Int64Val
        {
            long long val;
        };
#pragma keylist Int64Val
 
        /// Unsigned long long
        struct Uint64Val
        {
            unsigned long long val;
        };
#pragma keylist Uint64Val
 
        /// Character
        struct CharVal
        {
            char val;
        };
#pragma keylist CharVal
 
        /// boolean 
        struct BoolVal
        {
            boolean val;
        };
#pragma keylist BoolVal
 
        /// Single presicion floating point
        struct FloatVal
        {
            float val;
        };
#pragma keylist FloatVal
 
        /// Short
        struct ShortVal
        {
            short val;
        };
#pragma keylist ShortVal
 
        /// Double presicion floating point
        struct DoubleVal
        {
            double val;
        };
#pragma keylist DoubleVal
 
        /// String
        struct StringVal
        {
            string val;
        };
#pragma keylist StringVal
        
        /// A 2D-vector with double precision elements.
        struct Double2
        {
            double x;
            double y;
        };
#pragma keylist Double2
 
        /// A 3D-vector with double precision elements.
        struct Double3
        {
            double x;
            double y;
            double z;
        };
#pragma keylist Double3
 
        /// A 4D-vector with double precision elements.
        struct Double4
        {
            double x;
            double y;
            double z;
            double w;
        };
#pragma keylist Double4
 
        /// A 3D-vector with single precision elements
        struct Float3
        {
            float x;
            float y;
            float z;
        };
#pragma keylist Float3
 
        /// A vector of characters.
        struct VectorChar
        {
            sequence<char> vals;
        };
#pragma keylist VectorChar
        
        /// An array of single precision floating point numbers, and a short array identifier.
        struct ArrayFloat
        {
            short           arrayid; ///< Identifier
            sequence<float> vals; ///< Vector of single precision floating point numbers
        };
#pragma keylist ArrayFloat arrayid
 
        /// An array of double precision floating point numbers, and a short array identifier.
        struct ArrayDouble
        {
            short            arrayid; ///< Identifier
            sequence<double> vals; ///< Vector of double precision floating point numbers
        };
#pragma keylist ArrayDouble arrayid
 
        /// A point in 2D euclidean space
        struct Point2D
        {
            float x; ///< X-coordinate
            float y; ///< Y-coordinate
        };
#pragma keylist Point2D
 
        /// A line in 2D eulidean space
        struct Line2D
        {
            sequence<float> x; ///< A vector of X-coordinates.
            sequence<float> y; ///< A vector of Y-coordinates.
        };
#pragma keylist Line2D
 
        /// 2D-vector with latitude and longitude.
        struct PositionGlobal2D
        {
            double lat; ///< Latitude [degreeN]
            double lon; ///< Longitude [degreeE]
        };
#pragma keylist PositionGlobal2D
 
        /// 2D-vector with coordinates x and y.
        struct PositionLocal2D
        {
            double x; ///< X-coordinate [degreeN]
            double y; ///< Y-coordinate [degreeE]
        };
#pragma keylist PositionLocal2D
        
        /// GPS information of an entity.
        struct PosInfo
        {
            double lat; ///< Latitude [degreeN]
            double lon; ///< Longitude [degreeE]
            double sog; ///< Speed over ground [m/s]
            double cog; ///< Course over ground [m/s]
        };
#pragma keylist PosInfo
        
        /// Gyro information of an entity.
        struct GyroInfo
        {
            double hdt; ///< True heading of entity [rad]
            double rot; ///< Rate of turn [rad/s]
        };
#pragma keylist GyroInfo
 
        /// Wind information.
        struct WindInfo
        {
            double trueSpeed; ///< True wind speed [m/s]
            double trueDir; ///< True wind direction [rad]
            double relSpeed; ///< Wind speed relative to entity [m/s]
            double relDir; ///< Wind direction relative to entity [rad]
            double trueWindRelDir; ///< True wind direction relative to entity heading [rad]
        };
#pragma keylist WindInfo
 
        /// Depth information, typically echo sounder.
        struct DepthInfo
        {
            double depth; ///< Depth [m]
            double depthBelowTransducer; ///< Depth below trancducer [m]
        };
#pragma keylist DepthInfo
 
        /// Log information from vessel speed log.
        struct LogInfo
        {
            double speed; ///< Speed [m/s]
        };
#pragma keylist LogInfo
 
        /// Winch information.
        struct WinchInfo
        {
            double extractedWire; ///< Length of extracted wire [m]
            double tension; ///< Tension of wire [N]
            double speed; ///< Extraction speed of wire [m/s]
            double rpm; ///< Rpm of spool [rpm]
            double oilPressure; ///< Oil pressure [psi]
        };
#pragma keylist WinchInfo
 
        /// Information about the flowrate of oil.
        struct FlowRateInfo
        {
            double rate; ///< [l/s]
            double rate1; ///< [l/s]
            double rate2; ///< [l/s]
        };
#pragma keylist FlowRateInfo
        
        ///  
        struct FlowTotalInfo
        {
            double total; ///< [l]
            double total1; ///< [l]
            double total2; ///< [l]
        };
#pragma keylist FlowTotalInfo
 
        /// Water current information at depths.
        struct CurrentAtDepth
        {
            double speed; ///< Magnitude of the current [m/s]
            double direction; ///< The direction at which the water is flowing [rad]
            double depth; ///< Depth of reading [m]
        };
#pragma keylist CurrentAtDepth
 
        /// A current profile containing one or more currents
        struct CurrentProfile
        {
            sequence<CurrentAtDepth> currents; ///< Vector of CurrentAtDepth structs.
        };
#pragma keylist CurrentProfile
 
        /// Common vessel info, machinery signals
        struct Machinery
        {
            double auxCons; ///< Oil consumption auxiliary engines [kg/h]
            double auxElProd; ///< Electricity production auxiliary motor [kW]
            double auxLoad_kW; ///< Load on auxiliary motor [kW]
            double meCons; ///< Oil consumption main motor [kg/h]
            double meLoad_kW; ///< Load on main motor [kW]
            double meRpm; ///< Rotational speed main motor [rpm]
            double sumCons; ///< Total oil consumption [kg/h]
            double sumElProd; ///< Total electricity production [kW]
            double sumLoad_kW; ///< Total load [kW]
            double ptiPower; ///< Power take in [kW]
            double ptoPower; ///< Power take off [kW]
            double sfc; ///< Total oil consumption divided by total electrical energy [g/kWh]
        };
 
        /// Common vessel info, propulsion signals
        struct Propulsion
        {
            double efficiency; ///< Propulsion efficiency [%]
            double pitchPd; ///< Propulsion pitch [-]
            double pitchPercent; ///< Propulsion pitch percent [%]
            double rpm; ///< Rotational speed of propeller [rpm]
            double power; ///< Propulsion power [kW]
            double thrust; ///< Propulsion thrust [kN]
            double torque; ///< Propulsion torque [kN.m]
            double speed; ///< Speed through water [m/s]
            double powerToPropellerJet; ///< Propulsion power to jet propeller [kW]
        };
 
        /// Common vessel information
        struct CommonVesselInfo
        {
            Machinery  machinery; 
            Propulsion propulsion;
            double     nfc;
        };
#pragma keylist CommonVesselInfo
    };
};