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_ */
Onboard SDK

Search Results
