ATEsystem.PIRIS-driver: ATEsystem.PIRIS-driver/ATEsystem.PIRIS-driver-Shared/include/ATEsystem.PIRIS.h Source File

ATEsystem.PIRIS

ATEsystem.PIRIS-driver 1.0.1
ATEsystem.PIRIS-driver
 /******************************************
 *
 * Author: Jakub Parez
 * File: ATEsystem.PIRIS.h
 * Project: ATEsystem.PIRIS-driver
 * Version: 1.0.1
 * Company: ATEsystem s.r.o
 * Date: 2018/11/23 09:29
 * License: WTFPL
 * Require: C++17, Pylon 5, GenICam, Serial
 *
 *******************************************/
 
 #pragma once
 
 #ifdef _WIN32
  #include <windows.h>
 
  #define Interface class //__interface
  #define _sscanf sscanf_s
  #define _Sleep(ms) Sleep(ms)
 
 #elif __linux__ 
  #include <unistd.h>
  #include <stdlib.h>
  #include <cstdint>
 
  #define Interface struct
  #define _sscanf sscanf
  #define _Sleep(ms) usleep(ms * 1000)
 
 #else
  #error Unknown / unsupported platform
 #endif
 
 #include <string>
 #include <map>
 #include <vector>
 #include <list>
 
 #include "pylon/PylonIncludes.h"
 #include "serial.h"
 
 
 // ERROR TEXT
 #define OK "OK"
 #define ERR0 "Command was not recognized."
 #define ERR1 "Wrong input parameter."
 #define ERR2 "Device is not initialized."
 #define ERR3 "Internal driver circuit is in error state (overheat, undervoltage)."
 #define ERR4 "Wrong lens type."
 #define ERR5 "Damaged or missing rear sensor."
 #define ERR6 "Step generator timer overflow."
 #define ERR7 "Device is busy."
 #define ERR_UN "Unknown error."
 #define ERR_PA "Parse answer failed."
 
 // STATUS TEXT
 #define TXT_SUCCESS "Success"
 #define TXT_GENERAL_ERROR "General Error"
 #define TXT_OPEN_FAILED "Open failed"
 #define TXT_CLOSE_FAILED "CLose failed"
 #define TXT_ALREADY_OPEN "Already open"
 #define TXT_DEVICE_IS_BUSY "Device is busy"
 #define TXT_DEVICE_IS_CLOSED "Device is closed"
 #define TXT_INVALID_DEVICE "Invalid device"
 #define TXT_WRITE_ERROR "Write error"
 #define TXT_READ_ERROR "Read error"
 #define TXT_SCAN_FAILED "Scan failed"
 #define TXT_INTERNAL_ERROR "Internal error"
 #define TXT_RX_TIMEOUT "Receive timeout"
 #define TXT_DEV_SET_FAILED "Device set failed"
 #define TXT_WRONG_MODE "Wrong mode"
 #define TXT_DEVICE_NOT_EXIST "Device does not exist"
 #define TXT_PARSE_ANSWER_FAIL "Parse answer failed"
 
 // DEVICE MODE TEXT
 #define TXT_ETHERNET_DEVICE "Ethernet device"
 #define TXT_ETHERNET_PYLON "Ethernet pylon (camera overiden)"
 #define TXT_ETHERNET_CAMERA "Ethernet camera (camera overiden)"
 #define TXT_SERIAL "Serial"
 
 // VERBOSE OUTPUT TEXT
 #define TXT_SUCCESS2 "success"
 #define TXT_FAILED "failed"
 #define TXT_NAME "name"
 #define TXT_VERSION "version"
 #define TXT_FOCUS "focus"
 #define TXT_ZOOM "zoom"
 #define TXT_IRIS "iris"
 #define TXT_LENS "lens"
 #define TXT_IR_FILTER "ir_filter"
 #define TXT_IR_PRESENT "ir_present"
 #define TXT_SENS_PRESENT "sens_present"
 #define TXT_BUSY "busy"
 #define TXT_TYPE "type"
 
 // ATE PIRIS PROTOCOL
 #define CMD_READ_ID "IDN"
 #define CMD_READ_POS "GP"
 #define CMD_READ_TYPE "GT"
 #define CMD_READ_STATE "GS"
 #define CMD_RESET "RST"
 #define CMD_HOMING "INI"
 #define CMD_SET_ABS "SETA:"
 #define CMD_SET_REL "SETR:"
 #define CMD_SUFFIX "\r\n"
 #define RESP_FOCUS "F%hu"
 #define RESP_ZOOM "Z%hu"
 #define RESP_IRIS "P%hu"
 #define TRUE_VAL '1'
 #define DELIM ";"
 
 // RESPONSE CHAR LEN
 #define LEN_CMD_READ_ID 3
 #define LEN_CMD_READ_POS 5
 #define LEN_CMD_READ_TYPE 7
 #define LEN_CMD_READ_STATE1 2
 #define LEN_CMD_READ_STATE2 3
 #define LEN_CMD_RESET 0
 #define LEN_CMD_HOMING 1
 #define LEN_CMD_SET_ABS 1
 #define LEN_CMD_SET_REL 1
 
 #define FW_MIN_STAT_POLL 1, 7, 2 // minimum fw version which support cyclic status poll reading
 
 #define RX_TIMEOUT_OLD_FW 20000
 #define RX_TIMEOUT_NEW_FW 1000
 
 #define MSG(x) x CMD_SUFFIX
 
 #define STR_MAX_SIZE 200 
 #define GET_VAR_NAME(Variable) (#Variable)
 
 
 namespace ATEsystem_PIRIS
 {
  typedef int16_t Status_t; 
 
  typedef int16_t DevID_t;
 
  enum Mode : uint8_t
  {
  SERIAL = 0,
  ETHERNET = 1
  };
 
  enum Status : int16_t
  {
  SUCCESS = 0,
  GENERAL_ERROR = -1,
  OPEN_FAILED = -2, 
  CLOSE_FAILED = -3, 
  ALREADY_OPEN = -4,
  DEVICE_IS_BUSY = -5,
  DEVICE_IS_CLOSED = -6,
  INVALID_DEVICE = -7,
  WRITE_ERROR = -8,
  READ_ERROR = -9,
  SCAN_FAILED = -10,
  INTERNAL_ERROR = -11,
  RX_TIMEOUT = -12,
  DEV_SET_FAILED = -13,
  WRONG_MODE = -14,
  DEVICE_NOT_EXIST = -15,
  PARSE_ANSWER_FAIL = -16,
  UNDEFINED_ERROR = -20
  };
  std::ostream& operator<<(std::ostream& os, const Status stat);
 
  enum State : int8_t
  {
  UNKNOWN = 0,
  CLOSED = 1,
  BUSY = 2,
  READY = 3,
  };
 
  enum PirisDeviceType : uint8_t
  {
  ETHERNET_DEVICE = 0,
  ETHERNET_PYLON = 1,
  ETHERNET_CAMERA = 2,
  SERIAL_UART = 3
  };
  std::ostream& operator<<(std::ostream& os, const PirisDeviceType type);
  
  enum VerboseLevel : uint8_t
  {
  NONE = 0,
  BASIC = 1,
  FULL = 2
  };
 
  enum YesNoNA : uint8_t
  {
  NOT_AVAILABLE = 0,
  YES = 1,
  NO = 2
  };
 
 /* ******************************************************************************** */
 
  class Utils
  {
  public:
 
  static void CpyCStr2CStr(char* dest, const char* source, size_t max_len);
  static void CopySTLStr2CStr(char* dest, std::string source);
  static std::string CopyCStr2STLStr(const char* src);
  static std::string PadStr(const int total, const int minus = 0, const char ch = ' ');
  };
 
 /* ******************************************************************************** */
 
  class PirisDevice
  {
  private:
 
  const Mode mode = Mode::ETHERNET;
  const PirisDeviceType type = PirisDeviceType::ETHERNET_DEVICE;
  Pylon::CDeviceInfo dummy_dev;
  serial::PortInfo dummy_port;
 
  Pylon::CDeviceInfo& device_eth;
  Pylon::IPylonDevice* pylon_dev = nullptr;
  Pylon::CInstantCamera* camera = nullptr;
  serial::PortInfo& serial;
 
  public:
 
  PirisDevice(Pylon::CDeviceInfo& device);
  PirisDevice(Pylon::IPylonDevice* pylon_dev);
  PirisDevice(Pylon::CInstantCamera* camera);
  PirisDevice(serial::PortInfo& serial);
 
  Pylon::CDeviceInfo& get_device_eth() const;
  Pylon::IPylonDevice* get_pylon_dev() const;
  Pylon::CInstantCamera* get_camera() const;
  serial::PortInfo& get_serial() const;
  const Mode get_mode() const;
  const PirisDeviceType get_type() const;
 
  std::string ToString() const;
  friend std::ostream& operator<<(std::ostream& strm, const PirisDevice& dev)
  {
  strm << dev.ToString();
  return strm;
  }
  };
 
 /* ******************************************************************************** */
 
  class ErrorCluster
  {
  private:
 
  bool ok;
  int8_t err_num;
  std::string msg;
 
  static std::map<std::string, std::string> errors;
 
  public:
 
  ErrorCluster(std::string err_raw = "", bool overide = false);
  const bool getOk() const;
  const int8_t getErrNum() const;
  const std::string getMsg() const;
  const std::tuple<bool, int8_t, std::string> getErrorCluster() const;
 
  std::string ToString() const;
  friend std::ostream& operator<<(std::ostream& strm, const ErrorCluster& err) 
  { 
  strm << err.ToString();
  return strm;
  }
  };
 
 /* ******************************************************************************** */
 
  class Version
  {
  private:
 
  const uint16_t _major;
  const uint16_t _minor;
  const uint16_t _revision;
 
  public:
 
  Version(uint16_t major = 0, uint16_t minor = 0, uint16_t revision = 0);
  const uint16_t getMajor() const;
  const uint16_t getMinor() const;
  const uint16_t getRevision() const;
  const std::tuple<uint16_t, uint16_t, uint16_t> getVersion() const;
 
  std::string ToString() const;
  friend std::ostream& operator<<(std::ostream& strm, const Version& ver) 
  { 
  strm << ver.ToString();
  return strm;
  }
  friend bool operator==(const Version& ver1, const Version& ver2) 
  {
  return (ver1._major == ver2._major && ver1._minor == ver2._minor && ver1._revision == ver2._revision);
  }
  friend bool operator>(const Version& ver1, const Version& ver2)
  { 
  return (ver1._major > ver2._major || 
  (ver1._major == ver2._major && ver1._minor > ver2._minor) || 
  (ver1._major == ver2._major && ver1._minor == ver2._minor && ver1._revision > ver2._revision)); 
  }
  friend bool operator>=(const Version& ver1, const Version& ver2)
  {
  return (ver1._major >= ver2._major ||
  (ver1._major == ver2._major && ver1._minor >= ver2._minor) ||
  (ver1._major == ver2._major && ver1._minor == ver2._minor && ver1._revision >= ver2._revision));
  }
  friend bool operator<(const Version& ver1, const Version& ver2)
  {
  return (ver1._major < ver2._major ||
  (ver1._major == ver2._major && ver1._minor < ver2._minor) ||
  (ver1._major == ver2._major && ver1._minor == ver2._minor && ver1._revision < ver2._revision));
  }
  friend bool operator<=(const Version& ver1, const Version& ver2)
  {
  return (ver1._major <= ver2._major ||
  (ver1._major == ver2._major && ver1._minor <= ver2._minor) ||
  (ver1._major == ver2._major && ver1._minor == ver2._minor && ver1._revision <= ver2._revision));
  }
  };
 
 /* ******************************************************************************** */
 
  template <class T = uint16_t>
  class FocusZoomIris
  {
  private:
 
  int pad_len;
 
  const T _focus;
  const T _zoom;
  const T _iris;
 
  public:
 
  FocusZoomIris(T focus = NULL, T zoom = NULL, T iris = NULL, int str_pad_len = 25) :
  _focus(focus), _zoom(zoom), _iris(iris), pad_len(str_pad_len)
  {
  }
  const T getFocus() const
  {
  return this->_focus;
  }
  const T getZoom() const
  {
  return this->_zoom;
  }
  const T getIris() const
  {
  return this->_iris;
  }
  const std::tuple<T, T, T> getFocusZoomIris() const
  {
  return std::make_tuple(this->_focus, this->_zoom, this->_iris);
  }
 
  std::string ToString() const
  {
  std::stringstream ret;
  ret << TXT_FOCUS << "=" << Utils::PadStr(14, 5) << this->_focus << std::endl
  << Utils::PadStr(pad_len) << TXT_ZOOM << "=" << Utils::PadStr(14, 4) << this->_zoom << std::endl
  << Utils::PadStr(pad_len) << TXT_IRIS << "=" << Utils::PadStr(14, 4) << this->_iris;
  return ret.str();
  }
 
  friend std::ostream& operator<<(std::ostream& strm, const FocusZoomIris& vals)
  {
  strm << vals.ToString();
  return strm;
  }
  };
 
 /* ******************************************************************************** */
 
  class StatusEx : public ErrorCluster
  {
  public:
 
  const Status status;
  StatusEx(Status status = Status::GENERAL_ERROR, ErrorCluster err = ErrorCluster());
  };
 
  class DataID
  {
  public:
 
  const std::string name;
  const Version version;
 
  DataID(std::string name = "", Version version = Version());
  };
 
  class DataPosition
  {
  public:
 
  const FocusZoomIris<uint16_t> position;
  const bool ir_filter;
 
  DataPosition(FocusZoomIris<uint16_t> pos = FocusZoomIris<uint16_t>(), bool ir = false);
  };
 
  class DataParams
  {
  public:
 
  const FocusZoomIris<uint16_t> max_value;
  const std::string lens;
  const bool ir_present;
  const bool sens_present;
 
  DataParams(FocusZoomIris<uint16_t> max = FocusZoomIris<uint16_t>(), std::string lens = "", 
  bool ir = false, bool sens = false);
  };
 
  class DataState
  {
  public:
 
  const FocusZoomIris<bool> state;
  const bool motors_busy;
 
  DataState(FocusZoomIris<bool> state = FocusZoomIris<bool>(), bool busy = false);
  };
 
 /* ******************************************************************************** */
 
  Interface IDevice
  {
  public:
  
  //********************************************** open/close ***************************************************//
  virtual Status Open(void* dev, PirisDeviceType type, VerboseLevel verbose = VerboseLevel::NONE) = 0;
 
  virtual Status Open(const PirisDevice& dev, VerboseLevel verbose = VerboseLevel::NONE) = 0;
 
  virtual Status Close() = 0;
 
  //************************************************ read ******************************************************//
  virtual std::tuple<StatusEx, DataID> ReadID() = 0;
 
  virtual std::tuple<StatusEx, DataPosition> ReadPosition() = 0;
 
  virtual std::tuple<StatusEx, DataParams> ReadParams() = 0;
 
  virtual std::tuple<StatusEx, DataState> ReadState() = 0;
 
  //******************************************** reset/homing **************************************************//
  virtual StatusEx DevReset() = 0;
 
  virtual StatusEx DevHoming() = 0;
 
  //************************************************* set ******************************************************//
  virtual StatusEx SetAbsolute(uint16_t focus = 0, 
  uint16_t zoom = 0, 
  uint16_t iris = 0, 
  bool ir_filter = false) = 0;
 
  virtual StatusEx SetAbsolute(const FocusZoomIris<uint16_t>& values, 
  bool ir_filter = false) = 0;
 
  virtual StatusEx SetRelative(int16_t focus = 0, 
  int16_t zoom = 0, 
  int16_t iris = 0) = 0;
 
  virtual StatusEx SetRelative(const FocusZoomIris<int16_t>& values) = 0;
 
  //************************************************ utils *****************************************************//
 
  virtual YesNoNA GetFwPollSupport() = 0;
 
  virtual VerboseLevel GetVerboseLevel() = 0;
 
  virtual void SetVerboseLevel(VerboseLevel level) = 0;
 
  virtual ~IDevice() = 0;
  };
 
  Interface IComm
  {
  public:
 
  virtual Status open(const PirisDevice& dev, VerboseLevel verbose = VerboseLevel::NONE) = 0;
 
  virtual Status close(bool ignore_err = false) = 0;
 
  virtual Status write(const std::string data) = 0;
 
  virtual Status read(std::string& data) = 0;
 
  virtual Status flush(bool ignore_err = false) = 0;
 
  virtual void remove() = 0;
 
  virtual ~IComm() = 0;
  };
 
 /* ******************************************************************************** */
 
  class CPirisMain : public IComm, public IDevice
  {
  public:
 
  static int16_t ScanEthernet(std::vector<Pylon::CDeviceInfo>& devices, bool verbose = false);
  static int16_t ScanSerial(std::vector<serial::PortInfo>& devices, bool verbose = false);
 
  Status Open(void* dev, PirisDeviceType type, VerboseLevel verbose = VerboseLevel::NONE);
  Status Open(const PirisDevice& dev, VerboseLevel verbose = VerboseLevel::NONE);
  Status Close();
 
  std::tuple<StatusEx, DataID> ReadID(); // IDN - !! need to call this on every start to set timeouts
  std::tuple<StatusEx, DataPosition> ReadPosition(); // GP
  std::tuple<StatusEx, DataParams> ReadParams(); // GT
  std::tuple<StatusEx, DataState> ReadState(); // GS
 
  StatusEx DevReset(); // RST
  StatusEx DevHoming(); // INI
 
  StatusEx SetAbsolute(uint16_t focus = 0, 
  uint16_t zoom = 0, 
  uint16_t iris = 0, 
  bool ir_filter = false);
  StatusEx SetAbsolute(const FocusZoomIris<uint16_t>& values, // SETA:FX;ZX;PX;IX
  bool ir_filter = false); 
  StatusEx SetRelative(int16_t focus = 0, 
  int16_t zoom = 0, 
  int16_t iris = 0);
  StatusEx SetRelative(const FocusZoomIris<int16_t>& values); // SETR:FX;ZX;PX
 
  YesNoNA GetFwPollSupport();
  VerboseLevel GetVerboseLevel();
  void SetVerboseLevel(VerboseLevel level);
 
  CPirisMain();
  virtual ~CPirisMain() {};
 
  protected:
 
  uint16_t rx_timeout = RX_TIMEOUT_NEW_FW;
 
  void state_set(State _state);
  State state_get();
  bool state_is(State _state);
  void state_reset();
  bool verbose_is(VerboseLevel _verbose);
  void verbose_set(VerboseLevel _verbose);
 
  private:
 
  VerboseLevel _verbose;
  State state = State::CLOSED;
  State _state = State::CLOSED;
  YesNoNA fw_poll_support = YesNoNA::NOT_AVAILABLE; // device firmware is 1.7.2 and higher (stat read poll supp)
 
  ErrorCluster parse_answer(std::string answer_in, std::vector<std::string>& tokens_out, uint8_t n);
  StatusEx send_msg(std::vector<std::string>& tokens_out, std::string name, std::string cmd, uint8_t len);
  };
 
 /* ******************************************************************************** */
 
  template <class T>
  class SmartPointer
  {
  private:
 
  T* m_pT;
 
  public:
  SmartPointer(void) noexcept: m_pT(NULL)
  {
  }
 
  ~SmartPointer(void)
  {
  delete m_pT;
  }
 
  void operator=(T *pB)
  {
  m_pT = dynamic_cast<T*>(pB);
  }
 
  operator T*(void) const
  {
  return m_pT;
  }
 
  T& operator*(void) const
  {
  return *m_pT;
  }
 
  T& operator()(void) const
  {
  return *m_pT;
  }
 
  T* operator->(void) const
  {
  return m_pT;
  }
 
  bool IsValid() const throw()
  {
  return m_pT != NULL;
  }
 
  operator bool(void) const throw()
  {
  return m_pT != NULL;
  }
 
  bool operator==(T* pT) const
  {
  return m_pT == pT;
  }
  };
 
  typedef SmartPointer<IDevice> IPiris;
 
 /* ******************************************************************************** */
 
  typedef IDevice* (*CreateDeviceFn)(void);
 
  class Factory
  {
  private:
 
  typedef std::map<Mode, CreateDeviceFn> FactoryMap;
  typedef std::map<DevID_t, std::pair<std::string, IDevice*>> DeviceMap; // CPirisMain ?
  FactoryMap _factoryMap;
  DeviceMap _deviceMap;
 
  Factory();
  void Register(Mode mode, CreateDeviceFn pfnCreate);
 
  public:
 
  Factory(Factory const&) = delete;
  Factory &operator=(Factory const&) = delete;
  ~Factory() { _factoryMap.clear(); }
 
  static Factory* getInstance()
  {
  static Factory instance;
  return &instance;
  }
 
  DevID_t CreateDevice(Mode mode = Mode::ETHERNET);
 
  DevID_t CreateDevice(const std::string& name, Mode mode);
 
  IDevice* GetDeviceInstance(DevID_t id);
 
  std::string GetDeviceName(DevID_t id);
 
  Status RemoveDevice(DevID_t id);
  };
 }
Generated by
1.8.15
previous page start next page