dji_telemetry.hpp

Go to the documentation of this file.

#ifndef ONBOARDSDK_DJI_Telemetry_H
#define ONBOARDSDK_DJI_Telemetry_H

#include "dji_type.hpp"

namespace DJI
{
namespace OSDK
{
namespace Telemetry
{
// clang-format off
typedef enum
{
  TOPIC_QUATERNION,
  TOPIC_ACCELERATION_GROUND,
  TOPIC_ACCELERATION_BODY,
  TOPIC_ACCELERATION_RAW,
  TOPIC_VELOCITY,
  TOPIC_ANGULAR_RATE_FUSIONED,
  TOPIC_ANGULAR_RATE_RAW,
  TOPIC_ALTITUDE_FUSIONED,
  TOPIC_ALTITUDE_BAROMETER,
  TOPIC_ALTITUDE_OF_HOMEPOINT,
  TOPIC_HEIGHT_FUSION,
  TOPIC_GPS_FUSED,
  TOPIC_GPS_DATE,
  TOPIC_GPS_TIME,
  TOPIC_GPS_POSITION,
  TOPIC_GPS_VELOCITY,
  TOPIC_GPS_DETAILS,
  TOPIC_RTK_POSITION,
  TOPIC_RTK_VELOCITY,
  TOPIC_RTK_YAW,
  TOPIC_RTK_POSITION_INFO,
  TOPIC_RTK_YAW_INFO,
  TOPIC_COMPASS,
  TOPIC_RC,
  TOPIC_GIMBAL_ANGLES,
  TOPIC_GIMBAL_STATUS,
  TOPIC_STATUS_FLIGHT,
  TOPIC_STATUS_DISPLAYMODE,
  TOPIC_STATUS_LANDINGGEAR,
  TOPIC_STATUS_MOTOR_START_ERROR,
  TOPIC_BATTERY_INFO,
  TOPIC_CONTROL_DEVICE,
  TOPIC_HARD_SYNC,
  TOPIC_GPS_SIGNAL_LEVEL,
  TOPIC_GPS_CONTROL_LEVEL,
  TOPIC_RC_FULL_RAW_DATA, //deprecated
  TOPIC_RC_WITH_FLAG_DATA,
  TOPIC_ESC_DATA,
  TOPIC_RTK_CONNECT_STATUS,
  TOPIC_GIMBAL_CONTROL_MODE,
  TOPIC_FLIGHT_ANOMALY,
  TOPIC_POSITION_VO,
  TOPIC_AVOID_DATA,
  TOPIC_HOME_POINT_SET_STATUS,
  TOPIC_HOME_POINT_INFO,
  TOPIC_DUAL_GIMBAL_DATA,
  TOPIC_THREE_GIMBAL_DATA,
  TOTAL_TOPIC_NUMBER              // Always put this line in the end
} TopicName;
// clang-format on

// clang-format off
typedef enum
{
  UID_QUATERNION               = 0xa493281f,
  UID_ACCELERATION_GROUND      = 0x8696c85b,
  UID_ACCELERATION_BODY        = 0xbb17d5fe,
  UID_ACCELERATION_RAW         = 0xc3503a6e,
  UID_VELOCITY                 = 0x18fb271d,
  UID_ANGULAR_RATE_FUSIONED    = 0x3599c4be,
  UID_ANGULAR_RATE_RAW         = 0x700389ee,
  UID_ALTITUDE_FUSIONED        = 0x11e9c81a,
  UID_ALTITUDE_BAROMETER       = 0x27396a39,
  UID_ALTITUDE_OF_HOMEPOINT    = 0x252c164b,
  UID_HEIGHT_FUSION            = 0x87cf419d,
  UID_GPS_FUSED                = 0x4b19a8c7,
  UID_GPS_DATE                 = 0x598f79bc,
  UID_GPS_TIME                 = 0xd48912c9,
  UID_GPS_POSITION             = 0x0c949e94,
  UID_GPS_VELOCITY             = 0x7ac7eb80,
  UID_GPS_DETAILS              = 0x81fed54e,
  UID_RTK_POSITION             = 0x1df9a6b6,
  UID_RTK_VELOCITY             = 0x763d13c3,
  UID_RTK_YAW                  = 0xf45d73fd,
  UID_RTK_POSITION_INFO        = 0xda4a57b5,
  UID_RTK_YAW_INFO             = 0xcb72b9e3,
  UID_HOME_POINT_SET_STATUS    = 0xb5c2211f,
  UID_HOME_POINT_INFO          = 0xbfe4b520,
  UID_COMPASS                  = 0xdf3d72b7,
  UID_RC                       = 0x739f7fe4,
  UID_GIMBAL_ANGLES            = 0x01f71678,
  UID_GIMBAL_STATUS            = 0x8b6cd45c,
  UID_STATUS_FLIGHT            = 0x20cfb02a,
  UID_STATUS_DISPLAYMODE       = 0x1a67d6a1,
  UID_STATUS_LANDINGGEAR       = 0x772d6e22,
  UID_STATUS_MOTOR_START_ERROR = 0x3a41e909,
  UID_BATTERY_INFO             = 0x69779dd9,
  UID_CONTROL_DEVICE           = 0x667ba86a,
  UID_HARD_SYNC                = 0xecbef06d,
  UID_GPS_SIGNAL_LEVEL         = 0xa6a0395f,
  UID_GPS_CONTROL_LEVEL        = 0xe30b17b0,
  UID_RC_FULL_RAW_DATA         = 0x16ec4d0e,
  UID_RC_WITH_FLAG_DATA        = 0xfe04cfcd,
  UID_ESC_DATA                 = 0xaaa0f589,
  UID_RTK_CONNECT_STATUS       = 0x6f349326,
  UID_GIMBAL_CONTROL_MODE      = 0x326a446d,
  UID_FLIGHT_ANOMALY           = 0x0a624b4b,
  UID_POSITION_VO              = 0xd3462697,
  UID_AVOID_DATA               = 0xf6405daa,
  UID_DUAL_GIMBAL_FULL_DATA    = 0xcfeea4fa,
  UID_THREE_GIMBAL_FULL_DATA   = 0x19d374a0,
} TOPIC_UID;

// clang-format on
#pragma pack(1)

typedef struct
{
  const TopicName name;
  const uint32_t  uid;
  const size_t    size;    /* The size of actual data for the topic */
  const uint16_t  maxFreq; /* max freq in Hz for the topic provided by FC */
  uint16_t        freq;    /* Frequency at which the topic is subscribed */
  uint8_t         pkgID;   /* Package ID in which the topic is subscribed */
  /* Point to topic's address in the data buffer which stores the latest data */
  uint8_t* latest;
} TopicInfo; // pack(1)

typedef struct Quaternion
{
  float32_t q0; 
  float32_t q1; 
  float32_t q2; 
  float32_t q3; 
} Quaternion;   // pack(1)

typedef struct Vector3f
{
  float32_t x;
  float32_t y;
  float32_t z;
} Vector3f; // pack(1)

typedef struct Vector3d
{
  int32_t x;
  int32_t y;
  int32_t z;
} Vector3d; // pack(1)

typedef struct TimeStamp
{
  uint32_t time_ms;
  uint32_t time_ns;
} TimeStamp; // pack(1)

typedef struct SyncStamp
{
  uint32_t time_2p5ms; 
  uint16_t tag;
  uint8_t  flag;
} SyncStamp; // pack(1)

typedef struct VelocityInfo
{

  uint8_t health : 1; 
  uint8_t reserve : 7;
} VelocityInfo; // pack(1)

typedef struct Velocity
{
  Vector3f data;
  VelocityInfo info;
} Velocity; // pack(1)

typedef struct GlobalPosition
{
  float64_t latitude;  
  float64_t longitude; 
  float32_t altitude;  
  float32_t height;    
  uint8_t   health;    
} GlobalPosition;      // pack(1)

typedef struct GPSFused
{
  float64_t longitude;              
  float64_t latitude;               
  float32_t altitude;               
  uint16_t  visibleSatelliteNumber; 
} GPSFused;                         // pack(1)

typedef struct RelativePosition
{
  float32_t down;            
  float32_t front;           
  float32_t right;           
  float32_t back;            
  float32_t left;            
  float32_t up;              
  uint8_t   downHealth : 1;  
  uint8_t   frontHealth : 1; 
  uint8_t   rightHealth : 1; 
  uint8_t   backHealth : 1;  
  uint8_t   leftHealth : 1;  
  uint8_t   upHealth : 1;    
  uint8_t   reserved : 2;    
} RelativePosition; // pack(1)

typedef struct PositionTimeStamp
{
  uint32_t date;     
  uint32_t time;     
} PositionTimeStamp; // pack(1)

typedef struct PositionData
{
  float64_t longitude; 
  float64_t latitude;  
  float32_t HFSL;      
} PositionData;        // pack(1)


typedef struct HomeLocationData
{
  float64_t latitude;  
  float64_t longitude; 
}HomeLocationData; // pack(1)

typedef struct HomeLocationSetStatus
{
  uint8_t status;     
}HomeLocationSetStatus;// pack(1)
typedef struct GPSDetail
{
  float32_t hdop;       
  float32_t pdop;       
  float32_t fix;        
  float32_t gnssStatus; 
  float32_t hacc;       
  float32_t sacc;       
  uint32_t  usedGPS;    
  uint32_t  usedGLN; 
  uint16_t  NSV;     
  uint16_t  GPScounter; 
} GPSDetail;            // pack(1)

typedef struct GPSInfo
{
  PositionTimeStamp time;
  int32_t           longitude;   
  int32_t           latitude;    
  int32_t           HFSL;        
  Vector3f          velocityNED; 
  GPSDetail         detail;
} GPSInfo; // pack(1)

typedef struct PositionFrame
{
  PositionTimeStamp time;
  PositionData      data;
} PositionFrame; // pack(1)

typedef struct RTK
{
  PositionFrame pos;
  Vector3f      velocityNED;
  int16_t yaw;
  uint8_t posHealthFlag;
  uint8_t yawHealthFlag; 
} RTK;                   // pack(1)

typedef struct Mag
{
  int16_t x;
  int16_t y;
  int16_t z;
} Mag; // pack(1)

typedef struct Compass
{
    uint8_t compassStatus;
} Compass;

typedef struct RC
{
  int16_t roll;     
  int16_t pitch;    
  int16_t yaw;      
  int16_t throttle; 
  int16_t mode;     
  int16_t gear;     
} RC;               // pack(1)

typedef struct GimbalStatus
{
  uint32_t mountStatus : 1; 
  uint32_t isBusy : 1;
  uint32_t pitchLimited : 1;           
  uint32_t rollLimited : 1;            
  uint32_t yawLimited : 1;             
  uint32_t calibrating : 1;            
  uint32_t prevCalibrationgResult : 1; 
  uint32_t installedDirection : 1;     
  uint32_t disabled_mvo : 1;
  uint32_t gear_show_unable : 1;
  uint32_t gyroFalut : 1;       
  uint32_t escPitchStatus : 1;  
  uint32_t escRollStatus : 1;   
  uint32_t escYawStatus : 1;    
  uint32_t droneDataRecv : 1;   
  uint32_t initUnfinished : 1;  
  uint32_t FWUpdating : 1;      
  uint32_t reserved2 : 15;
} GimbalStatus; // pack(1)

typedef struct Gimbal
{

  float32_t roll;            
  float32_t pitch;           
  float32_t yaw;             
  uint8_t   pitchLimit : 1;  
  uint8_t   rollLimit  : 1;  
  uint8_t   yawLimit   : 1;  
  uint8_t   reserved   : 5;
} Gimbal; // pack(1)

typedef struct Status
{
  uint8_t flight; 
  uint8_t mode;   
  uint8_t gear;   
  uint8_t error;  
} Status;         // pack(1)

typedef struct Battery
{
  uint32_t capacity;
  int32_t  voltage;
  int32_t  current;
  uint8_t  percentage;
} Battery; // pack(1)

typedef struct SDKInfo
{
  uint8_t controlMode;      
  uint8_t deviceStatus : 3; 
  uint8_t flightStatus : 1; 
  uint8_t vrcStatus : 1;
  uint8_t reserved : 3;
} SDKInfo; // pack(1)

typedef struct SyncTimestamp
{
  uint32_t time2p5ms; 
  uint32_t time1ns;   
  uint32_t resetTime2p5ms; 
  uint16_t index;   
  uint8_t flag;     
} SyncTimestamp;    // pack(1)

typedef struct HardSyncData
{
  SyncTimestamp ts; 
  Quaternion    q;  
  Vector3f      a;  
  Vector3f      w;  
} HardSyncData;     // pack(1)

typedef struct RTKConnectStatus
{
  uint16_t rtkConnected : 1;
  uint16_t reserve         : 15;
} RTKConnectStatus;

typedef struct RCWithFlagData
{
  float32_t pitch;       
  float32_t roll;        
  float32_t yaw;         
  float32_t throttle;    
  struct
  {
    uint8_t logicConnected  :1;  
    uint8_t skyConnected    :1;  
    uint8_t groundConnected :1;  
    uint8_t appConnected    :1;  
    uint8_t reserved        :4;
  } flag;
} RCWithFlagData;

typedef struct ESCStatusIndividual
{
  int16_t  current;              
  int16_t  speed;                
  uint16_t voltage;              
  int16_t  temperature;          
  uint16_t stall            : 1; 
  uint16_t empty            : 1; 
  uint16_t unbalanced       : 1; 
  uint16_t escDisconnected  : 1; 
  uint16_t temperatureHigh  : 1; 
  uint16_t reserved         : 11;
} ESCStatusIndividual;

#define MAX_ESC_NUM 8

typedef struct EscData
{
  ESCStatusIndividual esc[MAX_ESC_NUM];
} EscData;

typedef struct LB2RcFullRawData
{
  int16_t roll;             
  int16_t pitch;            
  int16_t yaw;              
  int16_t throttle;         
  int16_t mode;             
  int16_t gear;             
  int16_t camera;           
  int16_t video;            
  int16_t videoPause;       
  int16_t goHome;           
  int16_t leftWheel;        
  int16_t rightWheelButton; 
  int16_t rcC1;             
  int16_t rcC2;             
  int16_t rcD1;             
  int16_t rcD2;
  int16_t rcD3;
  int16_t rcD4;
  int16_t rcD5;
  int16_t rcD6;
  int16_t rcD7;
  int16_t rcD8;
} LB2RcFullRawData;

#define SDK_LB2_CHANNEL_NUM (sizeof(LB2RcFullRawData)/sizeof(int16_t))
#define SDK_SBUS_CHANNEL_NUM (16)

typedef struct SBUSFullRawData
{
  int16_t data[SDK_SBUS_CHANNEL_NUM];
  int16_t reserved[SDK_LB2_CHANNEL_NUM - SDK_SBUS_CHANNEL_NUM];
} SBUSFullRawData;

typedef union
{
  LB2RcFullRawData lb2;
  SBUSFullRawData  sbus;
} RCFullRawData;

typedef uint8_t GimbalControlMode;

typedef struct GimbalSingleData
{
  float32_t pitch;
  float32_t roll;
  float32_t yaw;
  uint32_t status;
  uint8_t mode;
} GimbalSingleData;

#define SDK_M210_GIMBAL_MAX_NUM 2
#define SDK_M300_GIMBAL_MAX_NUM 3

typedef struct GimbalDualData
{
  GimbalSingleData gbData[SDK_M210_GIMBAL_MAX_NUM];
} GimbalDualData;

typedef struct GimbalThreeData
{
  GimbalSingleData gbData[SDK_M300_GIMBAL_MAX_NUM];
} GimbalThreeData;

typedef struct FlightAnomaly
{
  uint32_t impactInAir               : 1;  
  uint32_t randomFly                 : 1;  
  uint32_t heightCtrlFail            : 1;  
  uint32_t rollPitchCtrlFail         : 1;  
  uint32_t yawCtrlFail               : 1;  
  uint32_t aircraftIsFalling         : 1;  
  uint32_t strongWindLevel1          : 1;  
  uint32_t strongWindLevel2          : 1;  
  uint32_t compassInstallationError  : 1;  
  uint32_t imuInstallationError      : 1;  
  uint32_t escTemperatureHigh        : 1;  
  uint32_t atLeastOneEscDisconnected : 1;  
  uint32_t gpsYawError               : 1;  
  uint32_t reserved                  : 19;
} FlightAnomaly;

typedef struct LocalPositionVO
{
    float32_t x;              
    float32_t y;              
    float32_t z;              
    uint8_t   xHealth   : 1;
    uint8_t   yHealth   : 1;
    uint8_t   zHealth   : 1;
    uint8_t   reserved  : 5;
} LocalPositionVO;
//---------------------------------Legacy commands below-----------------------------------//

typedef struct LegacyTimeStamp
{
  uint32_t time;
  uint32_t nanoTime;
  uint8_t  syncFlag;
} LegacyTimeStamp; // pack(1)

typedef struct LegacyVelocity
{
  float32_t x;
  float32_t y;
  float32_t z;
  uint8_t health   : 1;
  uint8_t sensorID : 4;
  uint8_t reserve  : 3;
} LegacyVelocity; // pack(1)

typedef uint16_t EnableFlag; // pack(1)

typedef uint8_t  LegacyStatus;  // pack(1)
typedef uint8_t  LegacyBattery; // pack(1)

typedef struct LegacyGPSInfo
{
  PositionTimeStamp time;
  int32_t           longitude;   
  int32_t           latitude;    
  int32_t           HFSL;        
  Vector3f          velocityNED; 
} LegacyGPSInfo; // pack(1)

#pragma pack()

extern TopicInfo TopicDataBase[];

template <TopicName T>
struct TypeMap
{
  typedef void type;
};

// clang-format off
template <> struct TypeMap<TOPIC_QUATERNION               > { typedef Quaternion      type;};
template <> struct TypeMap<TOPIC_ACCELERATION_GROUND      > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_ACCELERATION_BODY        > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_ACCELERATION_RAW         > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_VELOCITY                 > { typedef Velocity        type;};
template <> struct TypeMap<TOPIC_ANGULAR_RATE_FUSIONED    > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_ANGULAR_RATE_RAW         > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_ALTITUDE_FUSIONED        > { typedef float32_t       type;};
template <> struct TypeMap<TOPIC_ALTITUDE_BAROMETER       > { typedef float32_t       type;};
template <> struct TypeMap<TOPIC_ALTITUDE_OF_HOMEPOINT    > { typedef float32_t       type;};
template <> struct TypeMap<TOPIC_HEIGHT_FUSION            > { typedef float32_t       type;};
template <> struct TypeMap<TOPIC_GPS_FUSED                > { typedef GPSFused        type;};
template <> struct TypeMap<TOPIC_GPS_DATE                 > { typedef uint32_t        type;};
template <> struct TypeMap<TOPIC_GPS_TIME                 > { typedef uint32_t        type;};
template <> struct TypeMap<TOPIC_GPS_POSITION             > { typedef Vector3d        type;};
template <> struct TypeMap<TOPIC_GPS_VELOCITY             > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_GPS_DETAILS              > { typedef GPSDetail       type;};
template <> struct TypeMap<TOPIC_RTK_POSITION             > { typedef PositionData    type;};
template <> struct TypeMap<TOPIC_RTK_VELOCITY             > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_RTK_YAW                  > { typedef int16_t         type;};
template <> struct TypeMap<TOPIC_RTK_POSITION_INFO        > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_RTK_YAW_INFO             > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_COMPASS                  > { typedef Mag             type;};
template <> struct TypeMap<TOPIC_RC                       > { typedef RC              type;};
template <> struct TypeMap<TOPIC_GIMBAL_ANGLES            > { typedef Vector3f        type;};
template <> struct TypeMap<TOPIC_GIMBAL_STATUS            > { typedef GimbalStatus    type;};
template <> struct TypeMap<TOPIC_STATUS_FLIGHT            > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_STATUS_DISPLAYMODE       > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_STATUS_LANDINGGEAR       > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_STATUS_MOTOR_START_ERROR > { typedef uint16_t        type;};
template <> struct TypeMap<TOPIC_BATTERY_INFO             > { typedef Battery         type;};
template <> struct TypeMap<TOPIC_CONTROL_DEVICE           > { typedef SDKInfo         type;};
template <> struct TypeMap<TOPIC_HARD_SYNC                > { typedef HardSyncData    type;};
template <> struct TypeMap<TOPIC_GPS_SIGNAL_LEVEL         > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_GPS_CONTROL_LEVEL        > { typedef uint8_t         type;};
template <> struct TypeMap<TOPIC_RC_FULL_RAW_DATA         > { typedef RCFullRawData   type;};
template <> struct TypeMap<TOPIC_RC_WITH_FLAG_DATA        > { typedef RCWithFlagData  type;};
template <> struct TypeMap<TOPIC_ESC_DATA                 > { typedef EscData         type;};
template <> struct TypeMap<TOPIC_RTK_CONNECT_STATUS       > { typedef RTKConnectStatus type;};
template <> struct TypeMap<TOPIC_GIMBAL_CONTROL_MODE      > { typedef GimbalControlMode type;};
template <> struct TypeMap<TOPIC_FLIGHT_ANOMALY           > { typedef FlightAnomaly   type;};
template <> struct TypeMap<TOPIC_POSITION_VO              > { typedef LocalPositionVO type;};
template <> struct TypeMap<TOPIC_AVOID_DATA               > { typedef RelativePosition type;};
template <> struct TypeMap<TOPIC_HOME_POINT_SET_STATUS    > { typedef HomeLocationSetStatus type;};
template <> struct TypeMap<TOPIC_HOME_POINT_INFO          > { typedef HomeLocationData type;};
template <> struct TypeMap<TOPIC_DUAL_GIMBAL_DATA         > { typedef GimbalDualData   type;};
template <> struct TypeMap<TOPIC_THREE_GIMBAL_DATA        > { typedef GimbalThreeData  type;};
// clang-format on
}
}
}
#endif // ONBOARDSDK_DJI_Telemetry_H