dji_protocol_base.hpp

Go to the documentation of this file.

#ifndef ONBOARDSDK_INTERNAL_DJI_PROTOCOL_BASE_H
#define ONBOARDSDK_INTERNAL_DJI_PROTOCOL_BASE_H

#include "dji_ack.hpp"
#include "dji_aes.hpp"
#include "dji_hard_driver.hpp"
#include "dji_log.hpp"
#include "dji_thread_manager.hpp"
#include "dji_type.hpp"

#ifdef STM32
#include <string.h>
#else
#include <cstring>
#endif

namespace DJI
{
namespace OSDK
{

#ifndef DJI_VEHICLECALLBACK_H

typedef struct DispatchInfo
{
  bool    isAck;
  bool    isCallback;
  uint8_t callbackID;
} DispatchInfo;

typedef struct RecvContainer
{
  DJI::OSDK::ACK::Entry     recvInfo;
  DJI::OSDK::ACK::TypeUnion recvData;
  DJI::OSDK::DispatchInfo   dispatchInfo;
} RecvContainer;
#endif

class ProtocolBase
{
public:
  ProtocolBase();
  virtual ~ProtocolBase();

  /************************** Init ******************************************/
public:
  virtual void init(HardDriver* Driver, MMU* mmuPtr,
                    bool userCallbackThread = false) = 0;

  /************************** Send Pipeline *********************************/
  // @todo is there any benefit to have an unified send function?
  // public:
  //  //! highest level interface
  //  virtual void send(cmdContainer *cmd_container);

protected:
  virtual int sendInterface(void* cmdContainer) = 0;

  virtual int sendData(uint8_t* buf) = 0;

  /************************** Receive Pipeline ******************************/
public:
  virtual RecvContainer* receive();

protected:
  typedef struct SDKFilter
  {
    uint32_t reuseIndex;
    uint32_t reuseCount;
    uint32_t recvIndex;
    uint8_t* recvBuf;
    uint8_t  sdkKey[32]; // for encryption
    uint8_t  encode;
  } SDKFilter;

  virtual bool readPoll();

public:
  virtual bool byteHandler(const uint8_t in_data);

protected:
  virtual bool streamHandler(uint8_t in_data);

  virtual void storeData(uint8_t in_data);

  virtual bool checkStream() = 0;

  virtual bool verifyHead() = 0;

  virtual bool verifyData() = 0;

  virtual bool callApp() = 0;

  virtual bool appHandler(void* protocolHeader) = 0;

  void prepareDataStream();

  void shiftDataStream();

  void reuseDataStream();

  /********************************** CRC **********************************/
protected:
  virtual int crcHeadCheck(uint8_t* pMsg, size_t nLen) = 0;

  virtual int crcTailCheck(uint8_t* pMsg, size_t nLen) = 0;

  /*********************** Getters and setters ******************************/
public:
  HardDriver* getDriver() const;

  ThreadAbstract* getThreadHandle() const;

  void setDriver(HardDriver* hardDriver_ptr);

  void setThreadHandle(ThreadAbstract* threadAbstract_ptr);

  void setHeaderLength(uint8_t length);

  void setMaxRecvLength(int length);

  int getBufReadPos();

  int getReadLen();

  RecvContainer* getReceivedFrame();

  /******************************* Member variables ************************/
protected:
  HardDriver* deviceDriver;

  bool            stopCond;
  ThreadAbstract* threadHandle;

  uint16_t seq_num;

  int            buf_read_pos;
  int            read_len;
  int            BUFFER_SIZE; // this should not be changed, init this in constructor
  uint8_t*       buf;
  uint8_t        HEADER_LEN;
  int            MAX_RECV_LEN;
  RecvContainer* p_recvContainer;
  SDKFilter*     p_filter;

  bool reuse_buffer;

  bool is_large_data_protocol;

}; // class ProtocolBase

} // OSDK

} // DJI

#endif // ONBOARDSDK_INTERNAL_DJI_PROTOCOL_BASE_H