zaber_controller/zaber_controller.h Source File

[[PREPROC_HEADER_GUARD_BEGIN]]
 
#include <HC_API.h>
#include <controllers_utils.h>
 
namespace zaber {
    namespace motion {
        namespace ascii {
            class Device;
            class AlertEvent;
            class Connection;
        }// namespace ascii
        namespace exceptions {
            class MotionLibException;
        }
    }// namespace motion
}// namespace zaber
 
 
namespace ZABM = zaber::motion;
 
#ifdef ZABER_API_V_5
namespace ZABMEX = zaber::motion::exceptions;
#else
namespace ZABMEX = ZABM;
#endif
namespace ZAB = ZABM::ascii;
 
 
 
 
namespace ControlAPI {
 
    struct HC_API ZaberAxisInfo : PhysicalAxisControlInfo {
        HC_SWIG_SHAREDPTR(ZaberAxisInfo)
        std::string alias = "";
        int apiAxisIdx = 0;
    };
 
    class ZaberDeviceInfoInternal;
    class ZaberMotionSim;
    class HC_API ZaberDeviceInfo : public DeviceInfo {
    public:
        HC_CLASS_META(ZaberDeviceInfo)
        HC_SWIG_SHAREDPTR(ZaberDeviceInfo)
        HC_CLASS_DEVICEINFO_META(ZaberDeviceInfo, CommandStatus)
        friend class zaberController;
 
        ZaberDeviceInfo();
        virtual ~ZaberDeviceInfo() = default;
 
        void AddAxisInfo(ZaberAxisInfo* axis);
 
        virtual DeviceCommandPackage* initializeCommand(DeviceCommandPackage* commandPacakge) override;
 
        //The index in the zaber chain of devices.  where 1 is the first device and so on.
        int zaberDeviceAddress = 1;
 
        std::shared_ptr<ZaberDeviceInfoInternal> internals;
        std::shared_ptr<ZaberMotionSim> motionSim;
 
 
    protected:
        zaber::motion::ascii::Device* mZaberDevice = nullptr;
 
        std::vector<ZaberAxisInfo*> axisInfoList;
        int nextAxisApiId = 0;
 
        float initialConnection_Position = 0.0f;
 
    };
 
    class HC_API ZaberCommandSetAxisMovement : public MovementCommandPackage {
    public:
        HC_CLASS_DEVICECOMMANDPACKAGE_META(ZaberCommandSetAxisMovement)
        virtual ~ZaberCommandSetAxisMovement() = default;
 
#ifdef HC_API_MACRO_EXCLUDE_DOCS
        virtual std::shared_ptr<CommandStateInfo> createCommandStateInfo() override { return std::make_shared<MovementStateInfo>(); }
        virtual void cloneFrom(DeviceCommandPackage* other) override { *this = *(dynamic_cast<ZaberCommandSetAxisMovement*>(other)); }
 
#endif
 
 
        bool doNativeHome = false;
 
        int zaberAxisId = 1;
    };
    std::shared_ptr<ZaberCommandSetAxisMovement> HC_API As_ZaberCommandSetAxisMovement(std::shared_ptr<DeviceCommandPackage> package);
 
    class HC_API ZaberCommandStorageKeyStateInfo : public CommandStateInfo {
    public:
        HC_CLASS_META(ZaberCommandStorageKeyStateInfo)
        HC_SWIG_SHAREDPTR(ZaberCommandStorageKeyStateInfo)
 
        float value = 0.0f;
#ifdef HC_API_FEATURE_NETWORKING
        void cacheOnNetwork(CommandStatus* command) override;
#endif
    };
 
    class HC_API ZaberCommandSetStorageKey : public DeviceCommandPackage {
    public:
        HC_CLASS_DEVICECOMMANDPACKAGE_META(ZaberCommandSetStorageKey)
        virtual ~ZaberCommandSetStorageKey() = default;
 
#ifdef HC_API_MACRO_EXCLUDE_DOCS
        virtual std::shared_ptr<CommandStateInfo> createCommandStateInfo() override { return std::make_shared<ZaberCommandStorageKeyStateInfo>(); }
#ifdef HC_API_FEATURE_NETWORKING
        virtual void syncFromNetwork(CommandStatus* command) override;
#endif
#endif
        std::string key;
 
        float number = 0.0f;
    };
    std::shared_ptr<ZaberCommandSetStorageKey> HC_API As_ZaberCommandSetStorageKey(std::shared_ptr<DeviceCommandPackage> package);
 
    class HC_API ZaberCommandGetStorageKey : public DeviceCommandPackage {
    public:
        HC_CLASS_DEVICECOMMANDPACKAGE_META(ZaberCommandGetStorageKey)
        virtual ~ZaberCommandGetStorageKey() = default;
 
#ifdef HC_API_MACRO_EXCLUDE_DOCS
        virtual std::shared_ptr<CommandStateInfo> createCommandStateInfo() override { return std::make_shared<ZaberCommandStorageKeyStateInfo>(); }
#ifdef HC_API_FEATURE_NETWORKING
        virtual void syncFromNetwork(CommandStatus* command) override;
#endif
#endif
        std::string key;
    };
    std::shared_ptr<ZaberCommandGetStorageKey> HC_API As_ZaberCommandGetStorageKey(std::shared_ptr<DeviceCommandPackage> package);
 
 
 
 
 
 
    class ZaberControllerInternals;
    class HC_API zaberController : public HardwareDeviceController {
    public:
        HC_CLASS_META(zaberController)
        HC_SWIG_SHAREDPTR(zaberController)
 
        explicit zaberController();
        virtual ~zaberController();
 
        friend class ZaberControllerInternals;
 
 
#ifdef HC_API_MACRO_EXCLUDE_DOCS
        virtual bool init() override;
        virtual bool deInit() override;
        virtual bool issueCommand(CommandStatus* command) override;
 
 
        virtual std::vector<std::pair<int, ZaberAxisInfo>> preConnect();
 
#endif
 
    private:
        bool StartTrackingCommand(int apiDeviceId, int deviceAxisIdx);
 
        bool SetStorageKey(int apiDeviceId, float number);
        bool GetStorageKey(int apiDeviceId, float *number_out);
 
        virtual bool checkCommandPackage(int apiDeviceId, DeviceCommandPackage* package) override;
 
        ZaberDeviceInfo *GetDeviceInfoFromZaberDeviceAddress(int address);
 
 
        ZAB::Device *GetZaberDeviceFromZaberDeviceAddress(int address);
        ZAB::Device *GetZaberDeviceFromSerialNumber(int serialNumber);
 
 
 
        /*
         * Connection information for Zaber device
         */
        std::shared_ptr<ZAB::Connection> mConnection;
 
 
        std::shared_ptr<ControlAPI::ZaberControllerInternals> internals;
 
 
 
    };
 
}// namespace ControlAPI
 
[[PREPROC_HEADER_GUARD_END]]