dji_vehicle.hpp

Go to the documentation of this file.

#ifndef OSDK_CORE_INC_DJI_VEHICLE_H_
#define OSDK_CORE_INC_DJI_VEHICLE_H_

#include <stdio.h>
#include <cstdint>
#include "dji_status.hpp"
#include "dji_ack.hpp"
#include "dji_type.hpp"
#include "dji_vehicle_callback.hpp"
#include "dji_version.hpp"
#include "dji_legacy_linker.hpp"
#include "dji_log.hpp"
#include "dji_broadcast.hpp"
#include "dji_gimbal.hpp"
#include "dji_camera.hpp"
#include "dji_control.hpp"
#include "dji_subscription.hpp"
#include "dji_mobile_device.hpp"
#include "dji_payload_device.hpp"
#include "dji_hardware_sync.hpp"
#include "dji_mfio.hpp"
#include "dji_mission_manager.hpp"
#include "dji_camera_manager.hpp"
#include "dji_gimbal_manager.hpp"
#include "dji_flight_controller.hpp"
#include "dji_psdk_manager.hpp"
#include "dji_battery.hpp"
#include "dji_waypoint_v2.hpp"
#ifdef ADVANCED_SENSING
#include "dji_advanced_sensing.hpp"
#endif
#if defined(__linux__)
#include "dji_hms.hpp"
#include "dji_mop_server.hpp"
#endif

namespace DJI
{
namespace OSDK
{
//forward declaration
class Firewall;
class Linker;

class Vehicle
{
public:
#pragma pack(1)
  typedef struct ActivateData
  {
    uint32_t ID;
    uint32_t reserved;
    uint32_t version;
    uint8_t  iosID[32]; 
    char*    encKey;
  } ActivateData; // pack(1)
#pragma pack()

public:
  Vehicle(Linker* linker);
  ~Vehicle();

  Linker*              linker;
  LegacyLinker*        legacyLinker;
  DataSubscription*    subscribe;
  DataBroadcast*       broadcast;
  Control*             control;
  Camera*              camera;
  Gimbal*              gimbal;
  MFIO*                mfio;
  MobileDevice*        mobileDevice;
  MissionManager*      missionManager;
#if defined(__linux__)
  WaypointV2MissionOperator*   waypointV2Mission;
#endif
  HardwareSync*        hardSync;
  // Supported only on Matrice 100
  PayloadDevice*       payloadDevice;
  CameraManager*       cameraManager;
  FlightController*    flightController;
  PSDKManager*         psdkManager;
  GimbalManager*       gimbalManager;

#if defined(__linux__)
  DJIHMS*              djiHms;
  MopServer*           mopServer;
#endif

#ifdef ADVANCED_SENSING
  AdvancedSensing* advancedSensing;
#endif

  DJIBattery*         djiBattery;
  int functionalSetUp();

  void activate(ActivateData* data, VehicleCallBack callback = 0,
                UserData userData = 0);

  ACK::ErrorCode activate(ActivateData* data, uint32_t timeoutMs);

  bool setUSBFlightOn(bool en);

  bool setSimulationOn(bool en, float64_t latitude, float64_t longitude);

  static void activateCallback(Vehicle* vehiclePtr, RecvContainer recvFrame,
                               UserData userData = 0);
  static void getDroneVersionCallback(Vehicle*      vehiclePtr,
                                      RecvContainer recvFrame,
                                      UserData      userData = 0);
  ACK::DroneVersion getDroneVersion(uint32_t timeoutMs);

  void getDroneVersion(VehicleCallBack callback = 0, UserData userData = 0);


  ActivateData getAccountData() const;

  void setAccountData(const ActivateData& value);

  void setVersion(const Version::FirmWare& value);

private:
  static HeartBeatPack  heartBeatPack;
  static uint8_t        fcLostConnectCount;
  const static uint8_t  kMaxFCLostConnectCount = 5;
  const static uint8_t  kOSDKSendId;
  const static uint32_t kHeartBeatPackSendTimeInterval;

public:
  Version::FirmWare getFwVersion() const;
  char*             getHwVersion() const;
  char*             getHwSerialNum() const;
  bool              isLegacyM600();
  bool              isM100();
  bool              isM210V2();
  bool              isM300();

private:
  Version::VersionData versionData;
  ActivateData         accountData;

private:
  bool is_activated = false;
  bool encrypt = false;

public:

  // User space ACK types
  ACK::ErrorCode     ackErrorCode;
  ACK::DroneVersion  droneVersionACK;

public:
  bool init();

  bool initVersion();

public:
  static bool parseDroneVersionInfo(Version::VersionData& versionData,
                                    uint8_t*              ackPtr);

private:
  const int            wait_timeout   = 1000;
  const int            GIMBAL_MOUNTED = 1;
  static const uint8_t NUM_CMD_SET    = 10;
  CMD_SETSupportMatrix cmd_setSupportMatrix[NUM_CMD_SET];

public:
  void setEncryption(bool encryptSetting);
  bool getEncryption();
  bool getActivationStatus();

  bool initLegacyLinker();
  bool initSubscriber();
  bool initBroadcast();
  bool initControl();
  bool initCamera();
  bool initGimbal();
  bool initMFIO();
  bool initMobileDevice();
  bool initPayloadDevice();
  bool initMissionManager();
  bool initWaypointV2Mission();
  bool initHardSync();
  bool initCameraManager();
  bool initFlightController();
  bool initPSDKManager();
  bool initGimbalManager();
#if defined(__linux__)
  bool initDJIHms();
  bool initMopServer();
#endif
  bool initOSDKHeartBeatThread();
#ifdef ADVANCED_SENSING
  bool initAdvancedSensing();
#endif
  bool initDJIBattery();

#ifdef ADVANCED_SENSING

  void processAdvancedSensingImgs(RecvContainer* receivedFrame);

  bool advSensingErrorPrintOnce;
#endif
private:
  Firewall *firewall;
  bool initFirewall();

  void setActivationStatus(bool is_activated);
  void initCMD_SetSupportMatrix();
  bool isCmdSetSupported(const uint8_t cmdSet);

  void sendBuriedDataPkgToFC(void);

  static void fcLostConnectCallBack(void);
  static uint8_t sendHeartbeatToFCFunc(Linker * linker);
  T_OsdkTaskHandle sendHeartbeatToFCHandle;
  static void *sendHeartbeatToFCTask(void *arg);
};
}
}
#endif /* OSDK_CORE_INC_DJI_VEHICLE_H_ */