gclib.hpp

Go to the documentation of this file.

#pragma once
#include <gclib.h>
#include <string>
#include <vector>
#include <functional>
#include <system_error>
#include <bitset>
 
namespace gclib {
    enum result {
        InvalidArgument = GCLIB_INVALID_ARGUMENT,
        InternalError = GCLIB_INTERNAL_ERROR,
        Timeout = GCLIB_TIMEOUT,
        CommandError = GCLIB_COMMAND_ERROR,
        BufferTooSmall = GCLIB_BUFFER_TOO_SMALL,
        NotConnected = GCLIB_NOT_CONNECTED,
        NotSubscribed = GCLIB_NOT_SUBSCRIBED
    };
    const class error_category : public std::error_category {
    public:
        using std::error_category::error_category;
        virtual const char* name() const noexcept override {
            return "gclib::error::category";
        }
        virtual std::string message(int result) const override {
            switch (result) {
                case InvalidArgument:
                    return "An invalid argument was passed";
                case InternalError:
                    return "An internal error occurred";
                case Timeout:
                    return "The operation timed out";
                case CommandError:
                    return "The controller returned a question mark";
                case BufferTooSmall:
                    return "The data could not fit in the provided buffer";
                case NotConnected:
                    return "The controller or gcaps is not connected";
                case NotSubscribed:
                    return "Not subscribed to unsolicited data";
                default:
                    return "Unrecognized gclib result";
            }
        }
    } error_category;
    class error : public std::system_error {
    public:
        using std::system_error::system_error;
    };

    enum ConnectionType {
        Ethernet = GCLIB_ETHERNET,
        Serial = GCLIB_SERIAL,
        Pci = GCLIB_PCI
    };

    namespace internal {
        const size_t HUGE_BUFFER = 524288;
        inline void check(gclib_result result, gclib_handle h = NULL) {
            if (result) {
                std::string err = gclib_error(h);
                if (err.empty()) {
                    throw error(std::error_code(static_cast<enum result>(result), error_category));
                }
                throw error(std::error_code(static_cast<enum result>(result), error_category), err);
            }
        }
        template <typename ...Args>
        inline std::string wrap(std::function<gclib_result(char*, size_t, Args...)> func, Args... args) {
            char* huge_buffer = static_cast<char*>(std::malloc(sizeof(char) * HUGE_BUFFER));
            check(func(huge_buffer, sizeof(char) * HUGE_BUFFER, args...));
            std::string result(huge_buffer);
            std::free(huge_buffer);
            return result;
        }
    };

    struct Interrupt {
        Interrupt(gclib_interrupt_t interrupt) : type{static_cast<Type>(interrupt.type)}, axis{interrupt.axis}, status{interrupt.status} {}
        enum Type {
            NoInterrupts = GCLIB_NO_INTERRUPTS,
            UserInterrupt = GCLIB_USER_INTERRUPT,
            MotionComplete = GCLIB_MOTION_COMPLETE,
            AllAxesMotionComplete = GCLIB_ALL_AXES_MOTION_COMPLETE,
            ExcessPositionError = GCLIB_EXCESS_POSITION_ERROR, 
            LimitSwitch = GCLIB_LIMIT_SWITCH, 
            WatchdogTimer = GCLIB_WATCHDOG_TIMER,
            ProgramStopped = GCLIB_PROGRAM_STOPPED, 
            CommandDone = GCLIB_COMMAND_DONE,
            DigitalInputLow = GCLIB_DIGITAL_INPUT_LOW, 
            AllInterrupts = GCLIB_ALL_INTERRUPTS
        };
        Type type;
        union {
            char axis; 
            uint8_t digital_input; 
            uint8_t user_interrupt; 
        };
        uint8_t status; 
    };
 
    struct DataRecord {
        DataRecord(gclib_data_record_handle h) : h_(h) {}
        enum EthernetStatus {
            HandleFree = HANDLE_FREE,
            UdpSlave = UDP_SLAVE,
            TcpSlave = TCP_SLAVE,
            UdpMaster = UDP_MASTER,
            TcpMaster = TCP_MASTER,
            EstablishingUdp = ESTABLISHING_UDP,
            EstablishingTcp = ESTABLISHING_TCP
        };

        struct Amp {
            Amp(gclib_data_record_handle h, size_t amp) : h_{h}, amp_{amp} {}
            bool over_current() { return gclib_data_record_over_current(h_, amp_); }
            bool over_voltage() { return gclib_data_record_over_voltage(h_, amp_); }
            bool over_temp() { return gclib_data_record_over_temp(h_, amp_); }
            bool under_voltage() { return gclib_data_record_under_voltage(h_, amp_); }
            bool electronic_lock_out() { return gclib_data_record_electronic_lock_out(h_, amp_); }
        private:
            gclib_data_record_handle h_;
            size_t amp_;
        };

        struct Axis {
            Axis(gclib_data_record_handle h, char axis) : h_{h}, axis_{axis} {}
            enum ModeOfMotion {
                NoMotion = GCLIB_NO_MOTION,
                Contour = GCLIB_CONTOUR,
                PositionAbsolute = GCLIB_POSITION_ABSOLUTE,
                PositionRelative = GCLIB_POSITION_RELATIVE,
                FindEdge = GCLIB_FIND_EDGE,
                FindIndex = GCLIB_FIND_INDEX,
                Home = GCLIB_HOME,
                VectorMove = GCLIB_VECTOR_MOVE,
                LinearMove = GCLIB_LINEAR_MOVE
            };
            bool motor_off() { return gclib_data_record_motor_off(h_, axis_); }
            bool latch_armed() { return gclib_data_record_latch_armed(h_, axis_); }
            bool final_deceleration() { return gclib_data_record_final_deceleration(h_, axis_); }
            bool stopping() { return gclib_data_record_stopping(h_, axis_); }
            bool slewing() { return gclib_data_record_slewing(h_, axis_); }
            ModeOfMotion mode_of_motion() { return static_cast<ModeOfMotion>(gclib_data_record_mode_of_motion(h_, axis_)); }
            bool negative_direction_move() { return gclib_data_record_negative_direction_move(h_, axis_); }
            bool moving() { return gclib_data_record_moving(h_, axis_); }
            int home_phase() { return gclib_data_record_home_phase(h_, axis_); }
            bool stepper_mode() { return gclib_data_record_stepper_mode(h_, axis_); }
            bool home_input() { return gclib_data_record_home_input(h_, axis_); }
            bool reverse_limit() { return gclib_data_record_reverse_limit(h_, axis_); }
            bool forward_limit() { return gclib_data_record_forward_limit(h_, axis_); }
            bool latch_input() { return gclib_data_record_latch_input(h_, axis_); }
            bool latch_occurred() { return gclib_data_record_latch_occurred(h_, axis_); }
            uint8_t stop_code() { return gclib_data_record_stop_code(h_, axis_); }
            int32_t reference_position() { return gclib_data_record_reference_position(h_, axis_); }
            int32_t position() { return gclib_data_record_position(h_, axis_); }
            int32_t position_error() { return gclib_data_record_position_error(h_, axis_); }
            int32_t aux_position() { return gclib_data_record_aux_position(h_, axis_); }
            int32_t velocity() { return gclib_data_record_velocity(h_, axis_); }
            double torque() { return gclib_data_record_torque(h_, axis_); }
            double analog_input() { return gclib_data_record_analog_input(h_, axis_); }
            int8_t halls() { return gclib_data_record_halls(h_, axis_); }
            int32_t variable() { return gclib_data_record_variable(h_, axis_); }
            bool hall_error() { return gclib_data_record_hall_error(h_, axis_); }
            bool peak_current() { return gclib_data_record_peak_current(h_, axis_); }
        private:
            gclib_data_record_handle h_;
            char axis_;
        };

        struct CoordinatedMove {
            CoordinatedMove(gclib_data_record_handle h, char plane) : h_{h}, plane_{plane} {}
            uint16_t segment_count() { return gclib_data_record_coordinated_move_segment_count(h_, plane_); }
            uint16_t status() { return gclib_data_record_coordinated_move_status(h_, plane_); }
            bool final_deceleration() { return gclib_data_record_coordinated_move_final_deceleration(h_, plane_); }
            bool stopping() { return gclib_data_record_coordinated_move_stopping(h_, plane_); }
            bool slewing() { return gclib_data_record_coordinated_move_slewing(h_, plane_); }
            bool moving() { return gclib_data_record_coordinated_move_moving(h_, plane_); }
            int32_t distance() { return gclib_data_record_coordinated_move_distance(h_, plane_); }
            uint16_t buffer_available() { return gclib_data_record_coordinated_move_buffer_available(h_, plane_); }
        private:
            gclib_data_record_handle h_;
            char plane_;
        };
        uint16_t sample() { return gclib_data_record_sample(h_); }

        bool input(size_t index) { return gclib_data_record_input(h_, index); }

        bool output(size_t index) { return gclib_data_record_output(h_, index); }
        std::bitset<8> input_bank(size_t index) { return gclib_data_record_input_bank(h_, index); }
        std::bitset<8> output_bank(size_t index) { return gclib_data_record_output_bank(h_, index); }
        uint8_t error_code() { return gclib_data_record_error_code(h_); }
        uint32_t contour_segment_count() { return gclib_data_record_contour_segment_count(h_); }
        uint16_t contour_buffer_available() { return gclib_data_record_contour_buffer_available(h_); }
        bool thread_running(size_t thread) { return gclib_data_record_thread_running(h_, thread); }

        EthernetStatus ethernet_status(char handle) { return static_cast<EthernetStatus>(gclib_data_record_ethernet_status(h_, handle)); }

        std::vector<uint8_t> bytes() {
            std::string result(1024, '\0');
            internal::check(gclib_data_record_bytes(h_, result.data(), result.size()));
            return std::vector<uint8_t>(result.begin(), result.end());
        }
        Amp amp(size_t amp) { return Amp(h_, amp); } 
        Axis axis(char axis) { return Axis(h_, axis); } 
        CoordinatedMove coordinated_move(char plane) { return CoordinatedMove(h_, plane); } 
    private:
        gclib_data_record_handle h_;
    };

    inline std::string version() { return internal::wrap({&gclib_version}); }

    inline std::string addresses() { return internal::wrap({&gclib_addresses}); }

    inline std::string ip_requests() { return internal::wrap({&gclib_ip_requests}); }
    inline void assign_ip(std::string mac, std::string ip) { internal::check(gclib_assign_ip(mac.data(), ip.data())); }
 

    inline void force_gcaps(bool on) { gclib_force_gcaps(on); }
    inline std::string gcaps_version() { return internal::wrap({&gclib_gcaps_version}); }
    inline std::string list_servers() { return internal::wrap({gclib_list_servers}); }
    inline std::string server() { return internal::wrap({gclib_server}); }
    inline void set_server(std::string name = {}) { internal::check(gclib_set_server(name.empty() ? nullptr : name.c_str())); }
    inline std::string published() { return internal::wrap({&gclib_published}); }
    inline void set_published(std::string name = {}) { internal::check(gclib_set_published(name.empty() ? nullptr : name.c_str())); }

    class Controller {
    public:
        Controller(std::string address) : address_{address} {
            open(); 
            connection_type_ = connection_type();
        }

        Controller(std::string address, size_t baud_rate) : address_{address}, baud_rate_{baud_rate} {
            open();
            connection_type_ = connection_type();
        }
        ~Controller() { close(); }

        void open() {
            check(gclib_open(&h_, address_.data()));
            if (connection_type_ == Serial) {
                gclib_set_baud_rate(h_, baud_rate_);
            }
        }
        void close() { gclib_close(&h_); }

        std::string address() { return wrap({&gclib_address}); }
        ConnectionType connection_type() { return static_cast<ConnectionType>(wrap<gclib_connection_t>({&gclib_connection_type})); }

        std::string revision_information() { return wrap({&gclib_revision_information}); }
        uint32_t serial_number() { return wrap<uint32_t>({&gclib_serial_number}); }

        template <typename T = std::string>
        T command(std::string command) {
            std::string str = wrap({[command](gclib_handle h, char* buf, size_t len){ return gclib_command(h, command.c_str(), buf, len); }});
            if constexpr (std::is_integral<T>() || std::is_floating_point<T>()) {
                return std::stod(str);
            } else {
                return str;
            }
        };
        
        std::string program() { return wrap({&gclib_program}); }
        void set_program(std::string program, std::string insert = "") { check(gclib_set_program(h_, program.c_str(), insert.c_str())); }
        std::string array(std::string name, size_t start = 0, size_t end = 0) { return wrap({[name](gclib_handle h, char* buf, size_t len, size_t start, size_t end){ return gclib_array(h, name.c_str(), buf, len, start, end); }}, start, end); }
        void set_array(std::string name, std::string array, size_t start = 0, size_t end = 0) { check(gclib_set_array(h_, name.c_str(), array.c_str(), start, end)); }
        void set_firmware(std::string file_path) { check(gclib_set_firmware(h_, file_path.c_str())); }
 

        void set_interrupts(Interrupt::Type mask, std::bitset<8> motion_complete_axes = 0, std::bitset<8> digital_inputs = 0) {
            check(gclib_set_interrupts(h_, static_cast<gclib_interrupt_type>(mask), gclib_axis_flags(motion_complete_axes.to_ulong()), gclib_digital_input_flags(digital_inputs.to_ulong())));
        }

        void set_data_records(size_t period_ms) { check(gclib_set_data_records(h_, period_ms)); }

        void subscribe_messages(std::function<void(std::string message)> callback) {
            message_callback_ = std::function([callback](const char* message){ callback(message); });
            check(gclib_subscribe_messages(h_, wrap_message_callback, &message_callback_));
        }

        void subscribe_messages() {
            check(gclib_subscribe_messages(h_, nullptr, nullptr));
        }

        void subscribe_interrupts(std::function<void(Interrupt interrupt)> callback) {
            interrupt_callback_ = std::function([callback](gclib_interrupt_t interrupt){ callback(interrupt); });
            check(gclib_subscribe_interrupts(h_, wrap_interrupt_callback, &interrupt_callback_));
        }

        void subscribe_interrupts() {
            check(gclib_subscribe_interrupts(h_, nullptr, nullptr));
        }

        void subscribe_data_records(std::function<void(DataRecord data_record)> callback) {
            data_record_callback_ = std::function([callback](gclib_data_record_handle h){ callback(DataRecord(h)); });
            check(gclib_subscribe_data_records(h_, wrap_data_record_callback, &data_record_callback_));
        }

        void subscribe_data_records() {
            check(gclib_subscribe_data_records(h_, nullptr, nullptr));
        };

        void subscribe_progress(std::function<void(size_t current, size_t max)> callback) {
            progress_callback_ = callback;
            check(gclib_subscribe_progress(h_, wrap_progress_callback, &progress_callback_));
        };
 
        void unsubscribe_messages() { check(gclib_unsubscribe(h_, (void*)&wrap_message_callback)); }
        void unsubscribe_interrupts() { check(gclib_unsubscribe(h_, (void*)&wrap_interrupt_callback)); }
        void unsubscribe_data_records() { check(gclib_unsubscribe(h_, (void*)&wrap_data_record_callback)); }
        void unsubscribe_progress() { check(gclib_unsubscribe(h_, (void*)&wrap_progress_callback)); }

        std::string message(int timeout = -1) { return wrap({&gclib_message}, timeout); }
        Interrupt interrupt(int timeout = -1) { return wrap<gclib_interrupt_t>({&gclib_interrupt}, timeout); }
        DataRecord data_record(int timeout = -1) { return wrap<gclib_data_record_handle>({&gclib_data_record}, timeout); }
 
    private:
        std::string address_;
        size_t baud_rate_{115200};
        ConnectionType connection_type_;
        void check(gclib_result result) {
            internal::check(result, h_);
        }
        template <typename ...Args>
        std::string wrap(std::function<gclib_result(gclib_handle, char*, size_t, Args...)> func, Args... args) {
            char* huge_buffer = static_cast<char*>(std::malloc(sizeof(char) * internal::HUGE_BUFFER));
            check(func(h_, huge_buffer, sizeof(char) * internal::HUGE_BUFFER, args...));
            std::string result(huge_buffer);
            std::free(huge_buffer);
            return result;
        }
        template <typename T, typename ...Args>
        T wrap(std::function<gclib_result(gclib_handle, T*, Args...)> func, Args... args) {
            T result;
            check(func(h_, &result, args...));
            return result;
        }
        gclib_handle h_{nullptr};
 
        static inline void wrap_message_callback(void* context, const char* message){ (*(std::function<void(const char*)>*)(context))(message); }
        static inline void wrap_interrupt_callback(void* context, gclib_interrupt_t interrupt){ (*(std::function<void(gclib_interrupt_t)>*)(context))(interrupt); }
        static inline void wrap_data_record_callback(void* context, gclib_data_record_handle data_record){ (*(std::function<void(gclib_data_record_handle)>*)(context))(data_record); }
        static inline void wrap_progress_callback(void* context, size_t current, size_t max){ (*(std::function<void(size_t, size_t)>*)(context))(current, max); }
        std::function<void(const char*)> message_callback_;
        std::function<void(gclib_interrupt_t)> interrupt_callback_;
        std::function<void(gclib_data_record_handle)> data_record_callback_;
        std::function<void(size_t, size_t)> progress_callback_;
    };
}