dji_broadcast.hpp

Go to the documentation of this file.

#ifndef DJIBROADCAST_H
#define DJIBROADCAST_H

#include "dji_telemetry.hpp"
#include "dji_vehicle_callback.hpp"

namespace DJI
{
namespace OSDK
{

class DataBroadcast
{
public:
  /*
   * Frequency values
   */
  enum FREQ
  {
    FREQ_0HZ   = 0,
    FREQ_1HZ   = 1,
    FREQ_10HZ  = 2,
    FREQ_50HZ  = 3,
    FREQ_100HZ = 4,
    FREQ_200HZ = 6,
    FREQ_400HZ = 7,
    FREQ_HOLD  = 5,
  };

  /*
   * @note this enable flag helps you clarify what data
   *        is coming in from data broadcast
   *        If the user specify GPS @50Hz and gyro @10Hz
   *        The whole data packet from broadcast will come
   *        in @50 Hz but gyro will only come in every 5
   *        data packets.
   *        Use this enum with the passFlag then you can
   *        check what data is available
   *        EX:
   *        if (passFlag & DataBroadcast::DATA_ENABLE_FLAG::HAS_W){
   *          // you get gyro data
   *        }
   */
  enum DATA_ENABLE_FLAG
  {
    HAS_TIME = 0x0001,
    HAS_Q    = 0x0002,
    HAS_A    = 0x0004,
    HAS_V    = 0x0008,
    HAS_W    = 0x0010,
    HAS_POS  = 0x0020,
    // below flags are for M100
    HAS_MAG     = 0x0040,
    HAS_RC      = 0x0080,
    HAS_GIMBAL  = 0x0100,
    HAS_STATUS  = 0x0200,
    HAS_BATTERY = 0x0400,
    HAS_DEVICE  = 0x0800,
    // below flags are for A3
    A3_HAS_GPS     = 0x0040,
    A3_HAS_RTK     = 0x0080,
    A3_HAS_MAG     = 0x0100,
    A3_HAS_RC      = 0x0200,
    A3_HAS_GIMBAL  = 0x0400,
    A3_HAS_STATUS  = 0x0800,
    A3_HAS_BATTERY = 0x1000,
    A3_HAS_DEVICE  = 0x2000,
    A3_HAS_COMPASS = 0x4000,
  };

public:
  DataBroadcast(Vehicle* vehicle = 0);
  ~DataBroadcast();

public:
  // Non-Blocking local-cache API
  // clang-format off

  Telemetry::TimeStamp    getTimeStamp()          ;

  Telemetry::SyncStamp    getSyncStamp()          ;

  Telemetry::Quaternion    getQuaternion()         ;

  Telemetry::Vector3f    getAcceleration()       ;

  Telemetry::Vector3f    getVelocity()           ;

  Telemetry::Vector3f   getAngularRate()          ;

  Telemetry::VelocityInfo    getVelocityInfo()       ;

  Telemetry::GlobalPosition    getGlobalPosition()     ;

  Telemetry::RelativePosition    getRelativePosition()   ;

  Telemetry::GPSInfo     getGPSInfo()            ;

  Telemetry::RTK     getRTKInfo()            ;

  Telemetry::Mag     getMag()                ;

  Telemetry::RC     getRC()                 ;

  Telemetry::Gimbal     getGimbal()             ;

  Telemetry::Status     getStatus()             ;

  Telemetry::Battery     getBatteryInfo()        ;

  Telemetry::SDKInfo     getSDKInfo()            ;

  Telemetry::Compass     getCompassData();
    // clang-format on

public:
  void setBroadcastFreq(uint8_t* dataLenIs16, VehicleCallBack callback = 0,
                        UserData userData = 0);
  ACK::ErrorCode setBroadcastFreq(uint8_t* dataLenIs16, int wait_timeout);

  void setBroadcastFreqDefaults();

  ACK::ErrorCode setBroadcastFreqDefaults(int timeout);

  void setBroadcastFreqToZero();

  uint16_t getPassFlag();

public:
  Vehicle* getVehicle() const;
  void setVehicle(Vehicle* vehiclePtr);
  /*
   * @note Distinguish between different FW versions
   */
  void setVersionDefaults(uint8_t* frequencyBuffer);
  void setFreqDefaultsM100_31(uint8_t* frequencyBuffer);
  void setFreqDefaults(uint8_t* frequencyBuffer);

public:
  void setUserBroadcastCallback(VehicleCallBack callback, UserData userData);
  VehicleCallBackHandler unpackHandler;

public:
  static void unpackCallback(Vehicle* vehicle, RecvContainer recvFrame,
                             UserData userData);
  static void setFrequencyCallback(Vehicle* vehicle, RecvContainer recvFrame,
                                   UserData userData);

private:
  // clang-format off
  typedef enum FLAG {
    // Common to A3/N3 and M100
    FLAG_TIME           = 0X0001,
    FLAG_QUATERNION     = 0X0002,
    FLAG_ACCELERATION   = 0X0004,
    FLAG_VELOCITY       = 0X0008,
    FLAG_ANGULAR_RATE   = 0X0010,
    FLAG_POSITION       = 0X0020,

    // Following are A3/N3 specific
    FLAG_GPSINFO        = 0X0040,
    FLAG_RTKINFO        = 0X0080,
    FLAG_MAG            = 0X0100,
    FLAG_RC             = 0X0200,
    FLAG_GIMBAL         = 0X0400,
    FLAG_STATUS         = 0X0800,
    FLAG_BATTERY        = 0X1000,
    FLAG_DEVICE         = 0X2000,
    FLAG_COMPASS        = 0x4000,

    // Following are M100 specific
    FLAG_M100_MAG       = 0x0040,
    FLAG_M100_RC        = 0x0080,
    FLAG_M100_GIMBAL    = 0x0100,
    FLAG_M100_STATUS    = 0x0200,
    FLAG_M100_BATTERY   = 0x0400,
    FLAG_M100_DEVICE    = 0x0800
  } FLAG;
  // clang-format on

private:
  void unpackData(RecvContainer* recvFrame);

  void unpackM100Data(RecvContainer* pRecvFrame);

  void unpackOldM600Data(RecvContainer* recvFrame);

  inline void unpackOne(FLAG flag, void* data, uint8_t*& buf, size_t size);

public:
  void setBroadcastLength(uint16_t length);
  uint16_t getBroadcastLength();

private:
  // clang-format off
  Telemetry::TimeStamp           timeStamp   ;
  Telemetry::SyncStamp           syncStamp   ;
  Telemetry::Quaternion          q           ;
  Telemetry::Vector3f            a           ;
  Telemetry::Vector3f            v           ;
  Telemetry::Vector3f            w           ;
  Telemetry::VelocityInfo        vi          ;
  Telemetry::GlobalPosition      gp          ;
  Telemetry::RelativePosition    rp          ;
  Telemetry::GPSInfo             gps         ;
  Telemetry::RTK                 rtk         ;
  Telemetry::Mag                 mag         ;
  Telemetry::RC                  rc          ;
  Telemetry::Gimbal              gimbal      ;
  Telemetry::Status              status      ;
  Telemetry::Battery             battery     ;
  Telemetry::SDKInfo             info        ;
  Telemetry::Compass             compass     ;
  /*
   * @note Broadcast data for Matrice 100/600 older firmware that is fundamentally
   * different from the A3/N3/M600 newer firmware
   */
  Telemetry::LegacyTimeStamp      legacyTimeStamp;
  Telemetry::LegacyVelocity       legacyVelocity;
  Telemetry::LegacyStatus         legacyStatus;
  Telemetry::LegacyBattery        legacyBattery;
  Telemetry::LegacyGPSInfo        legacyGPSInfo;
  // clang-format on
private:
  Vehicle* vehicle;
  uint16_t passFlag;
  uint16_t broadcastLength;

  T_OsdkMutexHandle m_msgLock;
  void lockMSG();
  void freeMSG();

  VehicleCallBackHandler userCbHandler;
};

} // OSDK
} // DJI
#endif // DJIBROADCAST_H