dji_ack.hpp

Go to the documentation of this file.

#ifndef DJI_ACK_HPP
#define DJI_ACK_HPP

#include "dji_command.hpp"
#include "dji_mission_type.hpp"
#include "dji_type.hpp"
#include "dji_version.hpp"
#include <map>

namespace DJI
{
namespace OSDK
{
class ACK
{
public:
#pragma pack(1)
  typedef struct Entry
  {
    uint8_t           cmd_set;
    uint8_t           cmd_id;
    uint16_t          len;
    uint8_t*          buf; // ugly design before, now means the recv package data buf
    uint8_t           seqNumber;
    Version::FirmWare version;
  } Entry; // pack(1)

  /*
   * ACK structures exposed to user
   */

  typedef struct HotPointStartInternal
  {
    uint8_t   ack;
    float32_t maxRadius;
  } HotPointStartInternal; // pack(1)

  typedef struct HotPointReadInternal
  {
    uint8_t          ack;
    HotPointSettings data;

    // TODO fix/remove once verified with FC team
    uint8_t extraByte;
  } HotPointReadInternal; // pack(1)

  typedef struct WayPointAddPointInternal
  {
    uint8_t ack;
    uint8_t index;
  } WayPointAddPointInternal; // pack(1)

  typedef struct WayPointIndexInternal
  {
    uint8_t          ack;
    WayPointSettings data;
  } WayPointIndexInternal; // pack(1)

  typedef struct WayPoint2CommonRsp
  {
    Entry   info;
    bool    updated = false;
  } WayPoint2CommonRsp;

  typedef struct ExtendedFunctionRsp{
    Entry   info;
    bool    updated = false;
  } ExtendedFunctionRsp;

  typedef struct WayPointVelocityInternal
  {
    uint8_t   ack;
    float32_t idleVelocity;
  } WayPointVelocityInternal; // pack(1)

  typedef struct WayPointInitInternal
  {
    uint8_t              ack;
    WayPointInitSettings data;
  } WayPointInitInternal; // pack(1)

  typedef struct MFIOGetInternal
  {
    uint8_t  result;
    uint32_t value;
  } MFIOGetInternal; // pack(1)

  typedef struct ParamAckInternal
  {
    uint8_t retCode;       
    uint32_t hashValue;    
    uint8_t paramValue[8]; 
  } ParamAckInternal;      // pack(1)

  typedef struct SetHomeLocationAckInternal
  {
    uint8_t result;       
    uint8_t retCode;      
  } SetHomeLocationAckInternal;      // pack(1)
  /*
   * ACK structures exposed to user
   */

  typedef struct ErrorCode
  {
    Entry    info;
    uint32_t data;
  } ErrorCode; // pack(1)

  typedef struct ParamAck
  {
    Entry info;
    ParamAckInternal data;
    bool updated = false;
  } ParamAck;  // pack(1)

  typedef struct SetHomeLocationAck
  {
    Entry info;
    SetHomeLocationAckInternal data;
    bool updated = false;
  }SetHomeLocationAck;
  typedef struct MFIOGet
  {
    ErrorCode ack;
    uint32_t  value;
  } MFIOGet; // pack(1)

  typedef struct HotPointStart
  {
    ErrorCode ack;
    float32_t maxRadius;
  } HotPointStart; // pack(1)

  typedef struct HotPointRead
  {
    ErrorCode        ack;
    HotPointSettings data;

    // TODO fix/remove once verified with FC team
    uint8_t extraByte;
  } HotPointRead; // pack(1)

  typedef struct WayPointIndex
  {
    ErrorCode        ack;
    WayPointSettings data;
  } WayPointIndex; // pack(1)

  typedef struct WayPointAddPoint
  {
    ErrorCode ack;
    uint8_t   index;
  } WayPointAddPoint; // pack(1)

  typedef struct WayPointVelocity
  {
    ErrorCode ack;
    float32_t idleVelocity;
  } WayPointVelocity; // pack(1)

  typedef struct WayPointInit
  {
    ErrorCode            ack;
    WayPointInitSettings data;
  } WayPointInit; // pack(1)

  typedef struct DroneVersion
  {
    ACK::ErrorCode       ack;
    Version::VersionData data;
  } DroneVersion; // pack(1)

  typedef struct WayPointReachedData
  {
    uint8_t incident_type;  
    uint8_t waypoint_index; 
    uint8_t current_status; 
    uint8_t reserved_1;
    uint8_t reserved_2;
  } WayPointReachedData; // pack(1)

  typedef struct WayPointStatusPushData{
    uint8_t mission_type;      
    uint8_t waypoint_index;    
    uint8_t current_status;    
    uint8_t error_notification;
    uint16_t reserved_1;
  } WayPointStatusPushData;

  static const int IMG_240P_SIZE = 240 * 320;
  typedef uint8_t  Image[IMG_240P_SIZE];
  typedef struct ImageMeta
  {
      Image image;
      char  name[12];
  } ImageMeta; // pack(1)
  typedef struct StereoImgData
  {
      uint32_t frame_index;
      uint32_t time_stamp;
      uint8_t  num_imgs;
      /*
       * There could be 50 different kinds of images coming from the drone,
       * 5 camera pairs and 10 images types.
       * Here we use an uint64_t to describe which image is coming
       * from the USB line, each bit represents if there's data or not
       * Please use AdvancedSensing::ReceivedImgDesc to match them
       * For M210, we support up to 4 images at the same time
       */
      uint64_t img_desc;
      // @note for M210, at most 4 imgs come at the same time.
      ImageMeta img_vec[4];
  } StereoImgData; // pack(1)
  static const int IMG_VGA_SIZE = 640 * 480;
  typedef uint8_t  VGAImage[IMG_VGA_SIZE];
  typedef struct StereoVGAImgData
  {
      uint32_t frame_index;
      uint32_t time_stamp;
      uint8_t  num_imgs;
      uint8_t  direction;
      // @note VGA imgs always come in pair
      VGAImage img_vec[2];
  } StereoVGAImgData; // pack(1)

  typedef struct FCTimeInUTC
  {
    uint32_t fc_timestamp_us;
    uint32_t utc_yymmdd;
    uint32_t utc_hhmmss;
  } FCTimeInUTC; // pack(1)

  typedef struct HeartBeatAck
  {
      Entry             info;
      HeartBeatPack     data;
  } HeartBeatAck;  //pack(1)

  typedef union TypeUnion {
    uint8_t  raw_ack_array[MAX_INCOMING_DATA_SIZE];
    uint8_t  versionACK[MAX_ACK_SIZE];
    uint16_t ack;
    uint8_t  commandACK;
    uint8_t  missionACK;
    uint8_t  subscribeACK;
    uint8_t  mfioACK;

    /*
     * ACK(s) containing ACK data plus extra payload
     */
    HotPointStartInternal    hpStartACK;
    HotPointReadInternal     hpReadACK;
    WayPointInitInternal     wpInitACK;
    WayPointAddPointInternal wpAddPointACK;
    WayPointIndexInternal    wpIndexACK;
    WayPointVelocityInternal wpVelocityACK;
    MFIOGetInternal          mfioGetACK;
    ParamAckInternal         paramAckData;
    SetHomeLocationAckInternal   setHomeLocationACK;

    /*
     * Push Data in ground-station mode
     */
    WayPointReachedData wayPointReachedData;
    WayPointStatusPushData wayPointStatusPushData;

    /*
     * Push Data from AdvancedSensing protocol
     */
    StereoImgData           *stereoImgData;
    StereoVGAImgData        *stereoVGAImgData;

    /*
     * Push Data from GPS or RTK
     */
    FCTimeInUTC             fcTimeInUTC;
    uint8_t                 ppsSourceType;
   /*
    * Heart Beat Pack between FC and OSDK
    */
    HeartBeatPack           heartbeatpack;
  } TypeUnion; // pack(1)

#pragma pack()

public:
  static const bool SUCCESS;
  static const bool FAIL;

  // Since control authority is a single command, we keep track of state in the
  // ack-handling
  // to unify next steps on receiving a control authority ack.
  static const uint8_t OBTAIN_CONTROL  = 1;
  static const uint8_t RELEASE_CONTROL = 0;

public:
  static bool getError(ErrorCode ack);

  static void getErrorCodeMessage(ErrorCode ack, const char* func);

private:
  static void getCMDSetActivationMSG(ACK::ErrorCode ack);
  static void getCommonErrorCodeMessage(ACK::ErrorCode ack);
  static void getCMDSetSubscribeMSG(ACK::ErrorCode ack);
  static void getCMDSetControlMSG(ACK::ErrorCode ack);
  static void getMotorErrorMessage(ACK::ErrorCode ack);
  static void getCMDIDSetControlMSG(uint8_t ack, Version::FirmWare version);
  static void getCMDIDControlMSG(ACK::ErrorCode ack);
  static void getCMDIDTaskMSG(ACK::ErrorCode ack);
  static void getCMDIDSetArmMSG(ACK::ErrorCode ack);
  static void getSetBroadcastMSG(ACK::ErrorCode ack);
  static void getCMDSetMissionMSG(ACK::ErrorCode ack);
  static void getCMDSetSyncMSG(ACK::ErrorCode ack);
  static void getCMDSetVirtualRCMSG(ACK::ErrorCode ack);
  static void getCMDSetMFIOMSG(ACK::ErrorCode ack);

  static const std::map<const uint32_t, const char*> createCommonErrorCodeMap();
  static const std::map<const uint32_t, const char*>
  createActivateErrorCodeMap();
  static const std::map<const uint32_t, const char*>
  createSubscribeErrorCodeMap();
  static const std::map<const uint32_t, const char*>
  createSetControlErrorCodeMap();
  static const std::map<const uint32_t, const char*> createTaskErrorCodeMap();
  static const std::map<const uint32_t, const char*>
  createMissionErrorCodeMap();
  static const std::map<const uint32_t, const char*> createMFIOErrorCodeMap();
  static const std::map<const uint32_t, const char*> createSetArmErrorCodeMap();
  static const std::map<const uint32_t, const char*>
  createLegacyTaskErrorCodeMap();
}; // class ACK

} // namespace OSDK
} // namespace DJI
#endif // DJI_ACK_HPP