dji_subscription.hpp

Go to the documentation of this file.

#ifndef DJI_DATASUBSCRIPTION_H
#define DJI_DATASUBSCRIPTION_H

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

#ifdef __linux__
#include <cstring>
#elif STM32
#include <stdlib.h>
#include <string.h>
#endif

namespace DJI
{
namespace OSDK
{

// Forward Declarations
class Vehicle;

class SubscriptionPackage
{
public:
#pragma pack(1)
  typedef struct PackageInfo
  {
    uint8_t  packageID;
    uint16_t freq;
    uint8_t  config;
    uint8_t  numberOfTopics;
  } PackageInfo;
#pragma pack()

public:
  SubscriptionPackage();
  ~SubscriptionPackage();

  void setPackageID(uint8_t id);
  void setConfig(uint8_t config);

  bool setTopicList(Telemetry::TopicName* topics, int numberOfTopics,
                    uint16_t freq);
  void allocateDataBuffer();
  void clearDataBuffer();

  void cleanUpPackage();

  int serializePackageInfo(uint8_t* buffer);

  void setUserUnpackCallback(VehicleCallBack userFunctionAfterPackageExtraction,
                             UserData        userData);

  bool isOccupied();
  void setOccupied(bool status);

  bool hasLeftOverData();
  void setLeftOverDataFlag(bool flag);

  // Accessors to private variables:
  PackageInfo            getInfo();
  uint32_t*              getUidList(); // explicitly show it's a pointer
  Telemetry::TopicName*  getTopicList();
  uint32_t*              getOffsetList();
  uint8_t*               getDataBuffer();
  uint32_t               getBufferSize();
  VehicleCallBackHandler getUnpackHandler();

  void packageAddSuccessHandler();

  void packageRemoveSuccessHandler();

private: // Private variables
  bool        occupied;
  bool        leftOverDataFlag;
  PackageInfo info;

  // We have only 30 topics and 5 packages.
  // So let's not bother with dynamic memory for now.
  // The UID
  uint32_t uidList[Telemetry::TOTAL_TOPIC_NUMBER];
  // The Name enum, used as index in the DataBase
  Telemetry::TopicName topicList[Telemetry::TOTAL_TOPIC_NUMBER];
  // The offset of each topic in the data flow
  uint32_t offsetList[Telemetry::TOTAL_TOPIC_NUMBER];

  uint32_t packageDataSize;

  uint8_t* incomingDataBuffer;

  VehicleCallBackHandler userUnpackHandler;
}; // class SubscriptionPackage

class DataSubscription
{
public: // public methods
  DataSubscription(Vehicle* vehicle);
  ~DataSubscription();

  Vehicle* getVehicle();
  bool initPackageFromTopicList(int packageID, int numberOfTopics,
                                Telemetry::TopicName* topicList,
                                bool sendTimeStamp, uint16_t freq);

  void verify();

  ACK::ErrorCode verify(int timeout); // blocking call

  void startPackage(int packageID);

  ACK::ErrorCode startPackage(int packageID, int timeout); // blocking call

  void removePackage(int packageID);

  ACK::ErrorCode removePackage(int packageID, int timeout); // blocking call

  void removeLeftOverPackages();

  void removeAllExistingPackages();

  void reset();

  ACK::ErrorCode reset(int timeout);

  void registerUserPackageUnpackCallback(
    int packageID, VehicleCallBack userFunctionAfterPackageExtraction,
    UserData userData = NULL);

  // Not implemented yet
  // bool pausePackage(int packageID);
  // bool resumePackage(int packageID);
  // bool changePackageFrequency(int packageID, uint16_t newFreq);

  static void verifyCallback(Vehicle* vehiclePtr, RecvContainer rcvContainer,
                             UserData userData);

  static void addPackageCallback(Vehicle*      vehiclePtr,
                                 RecvContainer rcvContainer,
                                 UserData      pkgHandle);

  static void removePackageCallback(Vehicle*      vehiclePtr,
                                    RecvContainer rcvContainer,
                                    UserData      pkgHandle);

  static void resetCallback(Vehicle*      vehiclePtr,
                            RecvContainer rcvContainer,
                            UserData      pkgHandle);

  static void decodeCallback(Vehicle* vehiclePtr, RecvContainer rcvContainer,
                             UserData subscriptionPtr);

  template <Telemetry::TopicName           topic>
  typename Telemetry::TypeMap<topic>::type getValue()
  {
    typename Telemetry::TypeMap<topic>::type ans;

    void* p = Telemetry::TopicDataBase[topic].latest;

    lockMSG();
    if (p)
    {
      ans = *reinterpret_cast<typename Telemetry::TypeMap<topic>::type*>(p);
      freeMSG();
      return ans;
    }
    else
    {
      DERROR("Topic 0x%X value memory not initialized, return default", topic);
    }
    freeMSG();

    memset(&ans, 0xFF, sizeof(ans));
    return ans;
  }

public: // public variables
  const static uint8_t   MAX_NUMBER_OF_PACKAGE = 7;
  VehicleCallBackHandler subscriptionDataDecodeHandler;

private: // private variables
  Vehicle*            vehicle;
  SubscriptionPackage package[MAX_NUMBER_OF_PACKAGE];

private: // private methods
  void extractOnePackage(RecvContainer*       pRcvContainer,
                         SubscriptionPackage* pkg);
  T_OsdkMutexHandle m_msgLock;
  void lockMSG();
  void freeMSG();
};
}
}

#endif // DJI_DATASUBSCRIPTION_H