dji_flight_assistant_module.hpp

Go to the documentation of this file.

#ifndef DJI_FLIGHT_ASSISTANT_MODULE_HPP
#define DJI_FLIGHT_ASSISTANT_MODULE_HPP

#include "dji_vehicle_callback.hpp"

namespace DJI {
namespace OSDK {

#define MAX_PARAMETER_VALUE_LENGTH 8
class FlightLink;
class FlightAssistant {
 public:
  FlightAssistant(Vehicle *vehicle);
  ~FlightAssistant();

 public:
  const static uint16_t MAX_FLIGHT_HEIGHT = 500;
  const static uint16_t MIN_GO_HOME_HEIGHT = 20;
  const static uint32_t MAX_FLY_RADIUS = 20000;

  enum ParamHashValue : uint32_t {
    USE_RTK_DATA = 1288992843,      
    GO_HOME_ALTITUDE = 952919004,   
    HORIZ_AVOID = 3001460201, 
    UPWARDS_AVOID = 854709684,
  };

  enum  RtkEnableData : uint8_t {
    RTK_DISABLE = 0, 
    RTK_ENABLE = 1,  
  };
  enum AvoidEnable : uint8_t {
    AVOID_DISABLE = 0,
    AVOID_ENABLE = 1,
  };
  enum UpwardsAvoidEnable : uint8_t {
    UPWARDS_AVOID_DISABLE = 0,
    UPWARDS_AVOID_ENABLE = 1,
  };
  enum HomeLocationType : uint8_t {
    DJI_HOMEPOINT_AIRCRAFT_LOACTON =
        0, 
    DJI_HOMEPOINT_SDK_SET_LOCAIION =
        3, 
  };
  typedef uint16_t GoHomeAltitude; 
#pragma pack(1)
  typedef struct ParameterData {
    uint32_t hashValue; 
    uint8_t paramValue[MAX_PARAMETER_VALUE_LENGTH];
  } ParameterData;

  typedef struct RtkEnableAck {
    uint8_t retCode;
    uint32_t hashValue;
    uint8_t rtkEnable;
  } RtkEnableAck;

  typedef struct AvoidEnableAck {
    uint8_t retCode;
    uint32_t hashValue;
    uint8_t avoidEnable;
  } AvoidEnableAck;

  typedef struct UpwardsAvoidEnableAck {
    uint8_t retCode;
    uint32_t hashValue;
    uint8_t upwardsAvoidEnable;
  } UpwardsAvoidEnableAck;

  typedef struct GoHomeAltitudeAck {
    uint8_t retCode;
    uint32_t hashValue;
    GoHomeAltitude altitude;
  } GoHomeAltitudeAck;

  typedef struct SetHomeLocationData {
    HomeLocationType homeType; 
    double latitude;           
    double longitude;          
    uint8_t healthy;           
  } SetHomeLocationData;       // pack(1)

#pragma pack()

  typedef struct UCBRetCodeHandler {
    void (*UserCallBack)(ErrorCode::ErrorCodeType errCode, UserData userData);
    UserData userData;
  } UCBRetCodeHandler;

  static const int maxSize = 32;
  UCBRetCodeHandler ucbHandler[maxSize];

  template <typename T>
  struct UCBRetParamStruct {
    void (*UserCallBack)(ErrorCode::ErrorCodeType errCode, T param,
                         UserData userData);
    UserData userData;
  };

  template <typename T>
  using UCBRetParamHandler = UCBRetParamStruct<T>;

  UCBRetCodeHandler *allocUCBHandler(void *callback, UserData userData);

  ErrorCode::ErrorCodeType writeParameterByHashSync(uint32_t hashValue,
                                                    void *data, uint8_t len,
                                                    int timeout);
  void writeParameterByHashAsync(
      uint32_t hashValue, void *data, uint8_t len,
      void (*ackDecoderCB)(Vehicle *vehicle, RecvContainer recvFrame,
                           UCBRetCodeHandler *ucb),
      void (*userCB)(ErrorCode::ErrorCodeType, UserData userData),
      UserData userData, int timeout = 500, int retry_time = 2);

  ErrorCode::ErrorCodeType readParameterByHashSync(ParamHashValue hashValue,
                                                   void *param, int timeout);

  template <typename DataT>
  void readParameterByHashAsync(
      ParamHashValue hashValue,
      void (*ackDecoderCB)(Vehicle *vehicle, RecvContainer recvFrame,
                           UCBRetParamHandler<DataT> *ucb),
      void (*userCB)(ErrorCode::ErrorCodeType, DataT data, UserData userData),
      UserData userData, int timeout = 500, int retry_time = 2);

  ErrorCode::ErrorCodeType setRtkEnableSync(RtkEnableData rtkEnable,
                                            int timeout);

  void setRtkEnableAsync(RtkEnableData rtkEnable,
                         void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                              UserData userData),
                         UserData userData);

  ErrorCode::ErrorCodeType getRtkEnableSync(RtkEnableData &rtkEnable,
                                            int timeout);

  void getRtkEnableAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                              RtkEnableData rtkEnable,
                                              UserData userData),
                         UserData userData);

  ErrorCode::ErrorCodeType setUpwardsAvoidanceEnabledSync(UpwardsAvoidEnable upwardsAvoidEnable,
                                            int timeout);

  void setUpwardsAvoidanceEnabledAsync(UpwardsAvoidEnable upwardsAvoidEnable,
                         void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                              UserData userData),
                         UserData userData);

  ErrorCode::ErrorCodeType getUpwardsAvoidanceEnabledSync(UpwardsAvoidEnable &upwardsAvoidEnable,
                                            int timeout);

  void getUpwardsAvoidanceEnabledAsync(void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                                                            UpwardsAvoidEnable upwardsEnable,
                                              UserData userData),
                         UserData userData);
  ErrorCode::ErrorCodeType setGoHomeAltitudeSync(GoHomeAltitude altitude,
                                                 int timeout);

  void setGoHomeAltitudeAsync(
      GoHomeAltitude altitude,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType getGoHomeAltitudeSync(GoHomeAltitude &altitude,
                                                 int timeout);

  void getGoHomeAltitudeAsync(
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                           GoHomeAltitude altitude, UserData userData),
      UserData userData);

  ErrorCode::ErrorCodeType setCollisionAvoidanceEnabledSync(
      AvoidEnable avoidEnable, int timeout);

  void setCollisionAvoidanceEnabledAsync(
    AvoidEnable avoidEnable,
    void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
    UserData userData);

  ErrorCode::ErrorCodeType getCollisionAvoidanceEnabledSync(
      AvoidEnable &avoidEnable, int timeout);

  void getCollisionAvoidanceEnabledAsync(
    void (*UserCallBack)(ErrorCode::ErrorCodeType retCode,
                         AvoidEnable avoidEnable, UserData userData),
    UserData userData);

  ErrorCode::ErrorCodeType setHomeLocationSync(SetHomeLocationData homeLocation,
                                               int timeout);

  void setHomeLocationAsync(
      SetHomeLocationData homeLocation,
      void (*UserCallBack)(ErrorCode::ErrorCodeType retCode, UserData userData),
      UserData userData);

 private:
  FlightLink *flightLink;

  template <typename AckT>
  static ErrorCode::ErrorCodeType commonDataUnpacker(RecvContainer recvFrame,
                                                     AckT &ack);
  static void setParameterDecoder(Vehicle *vehicle, RecvContainer recvFrame,
                                  UCBRetCodeHandler *ucb);

  static void getRtkEnableDecoder(Vehicle *vehicle, RecvContainer recvFrame,
                                  UCBRetParamHandler<RtkEnableData> *ucb);

  static void getAvoidEnableDecoder(Vehicle *vehicle, RecvContainer recvFrame,
                                    UCBRetParamHandler<AvoidEnable > *ucb);
  static void getUpwardsAvoidEnableDecoder(Vehicle *vehicle, RecvContainer recvFrame,
                                           UCBRetParamHandler<UpwardsAvoidEnable > *ucb);
  static void getGoHomeAltitudeDecoder(Vehicle *vehicle,
                                       RecvContainer recvFrame,
                                       UCBRetParamHandler<GoHomeAltitude> *ucb);
  static void setHomePointAckDecoder(Vehicle *vehicle, RecvContainer recvFrame,
                                     UCBRetCodeHandler *ucb);
  static bool goHomeAltitudeValidCheck(uint16_t altitude);
};
}
}

#endif  // DJI_FLIGHT_ASSISTANT_MODULE_HPP