urgCtrl.h

Go to the documentation of this file.

#ifndef URG_CTRL_H
#define URG_CTRL_H

#include "coordinateCtrl.h"
#include "ticksCtrlInterface.h"
#include "urgCapture.h"
#include "timeUtils.h"
#include "ticksPositionInterface.h"


class URGCtrl : public URGInterface, public CoordinateCtrl,
                public TicksCtrlInterface {
  friend class URG_Simulator;
  friend class URGCtrlTest;

  enum {
    DefaultBaudrate = 115200,
    SimulatorPort = 49763,
  };
  URGCapture* con;
  bool isHandstand;

  int eachDataByte;
  bool enableOver4096;

  std::string error_message;
  static bool isVersionPrinted;
  static bool isHelpPrinted;

  bool ignore_beginTimeAdjust;
  unsigned short pre_module_ticks;
  long total_msec;

  ticksInfo_t ticksInfoObj;
  ticksInfo_t& getTicksInfo(void) {
    return ticksInfoObj;
  }

  void skipReply(int n);
  long decode(const char* data, int data_byte);
  int updateTicksDiff(unsigned short ticks);
  unsigned long getModuleRawTicks(void);

  void printVersion(void);
  void printHelp(void);
  int getIndexTicks(int index);
  URGCtrl(const URGCtrl& rhs);

protected:
  enum {
    SenseSteps = (1024 * 270 / 360) + 1,
  };
  bool to_simulator;            
  bool enableTimestamp;         
  void initTicksInfo(void);

  virtual unsigned long getHostTicks(void);

  virtual void beginTimeAdjust(void);

  virtual unsigned long getURGTimestamp(void);

  virtual void endTimeAdjust(void);

  urgParams_t params;

  long* getLengthData(void) {
    return length;
  }

  bool parseArgs(int* ret_value, int argc, char *argv[], bool autoCapture);

  void checkVersion(void);

  virtual int raw_capture(long length[],
                          int first_index, int last_index, int group,
                          unsigned long* raw_timestamp = NULL);

public:
  enum {
    VEND = 3,
    PROD,
    FIRM,
    PROT,
    SERI,
    DefaultTimeout = -1,
  };

  //virtual void adjustOwnTicks(unsigned long setTicks);

  urgParams_t& getParameters(void) {
    return params;
  }

  long length[SenseSteps];

  URGCtrl(void);
  ~URGCtrl(void);

  const char* what(void);

  void setHandstand(bool on);

  virtual int connect(const char* device, long baudrate = DefaultBaudrate,
                      bool autoCapture = URG::AutoCapture);

  int connectSocket(const char* host, short port, bool autoCapture);

  virtual int connect(int argc, char *argv[],
                      bool autoCapture = URG::AutoCapture);

  virtual int connect(bool autoCapture = true);

  virtual void disconnect(void);

  virtual bool isConnected(void);

  void set_recvTimeout(int timeout = DefaultTimeout);

  enum { LineLength = 64 + 16 };
  virtual int getVersionInfo(char lines[][LineLength]);

  int capture(int first_index, int last_index, int group = 1);

  int capture(int group = 1);

  int getCaptureTimes(void);

  void convert(void);

  void convert(const VXV::Position3D& crd_position);

  void convert(const VXV::TicksPositionInterface& position);
};


class URG_Exception : public std::exception {
  std::string error_message;

public:
  URG_Exception(const char* message) throw () : error_message(message) {}
  virtual ~URG_Exception(void) throw () {}

  virtual const char* what(void) const throw() {
    return error_message.c_str();
  }
};

#endif /* !URG_CTRL_H */