motor.hpp

Go to the documentation of this file.

#pragma once

#include <memory>
#include <string>

#include "real_time_tools/timer.hpp"

#include "real_time_tools/threadsafe/threadsafe_object.hpp"
#include "real_time_tools/threadsafe/threadsafe_timeseries.hpp"
#include "blmc_drivers/devices/motor_board.hpp"
#include "blmc_drivers/devices/device_interface.hpp"

namespace blmc_drivers
{

class MotorInterface: public DeviceInterface
{
public:

    typedef real_time_tools::ThreadsafeTimeseries<double> ScalarTimeseries;
    template<typename Type> using Ptr = std::shared_ptr<Type>;

    enum MeasurementIndex {current, position, velocity, encoder_index,
                           measurement_count};

    virtual ~MotorInterface() {}

    virtual void send_if_input_changed() = 0;

    virtual Ptr<const ScalarTimeseries> get_measurement(
            const int& index = 0) const = 0;

    virtual Ptr<const ScalarTimeseries> get_current_target() const = 0;

    virtual Ptr<const ScalarTimeseries> get_sent_current_target() const = 0;

    virtual void set_current_target(const double& current_target) = 0;

    virtual void set_command(const MotorBoardCommand& command) = 0;
};

class Motor: public MotorInterface
{
public:
    Motor(Ptr<MotorBoardInterface> board, bool motor_id);

    virtual ~Motor() { }

    virtual void send_if_input_changed()
    {
        board_->send_if_input_changed();
    }
    
    virtual Ptr<const ScalarTimeseries> get_measurement(const int& index = 0)
    const;

    virtual Ptr<const ScalarTimeseries> get_current_target() const;

    virtual Ptr<const ScalarTimeseries> get_sent_current_target() const;

    virtual void set_current_target(const double& current_target);

    virtual void set_command(const MotorBoardCommand& command)
    {
        board_->set_command(command);
    }

    virtual void print() const;

protected:
    Ptr<MotorBoardInterface> board_;

    bool motor_id_;
};

class SafeMotor: public Motor
{
public:
    SafeMotor(Ptr<MotorBoardInterface> board, bool motor_id,
              const double& max_current_target = 2.0,
              const size_t& history_length = 1000,
              const double& max_velocity = std::numeric_limits<
                    double>::quiet_NaN());

    virtual Ptr<const ScalarTimeseries> get_current_target() const
    {
        return current_target_;
    }

    virtual void set_current_target(const double& current_target);
    
    void set_max_current(double max_current_target)
    {
      max_current_target_ = max_current_target;
    }

    void set_max_velocity(double max_velocity)
    {
      max_velocity_ = max_velocity;
    }

private:
    double max_current_target_;

    double max_velocity_;

    Ptr<ScalarTimeseries> current_target_;
};

} // namespace blmc_drivers