Motor.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Hardware
File: Motor
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Device.h>
#include <NDEVR/Angle.h>
namespace NDEVR
{
    class Log;
    class HARDWARE_API Motor : public Device
    {
    public:
        Motor(const Model& model,  LogPtr log = nullptr, QObject* parent = nullptr);
        [[nodiscard]] virtual Angle<fltp08> location() const;
        [[nodiscard]] virtual Angle<fltp08> speed() const { return m_current_speed; }
        [[nodiscard]] virtual Angle<fltp08> parkAngle() const { return m_park_angle; }
        [[nodiscard]] virtual Angle<fltp08> preferredSpeed() const { return m_preferred_speed; }
        [[nodiscard]] virtual Angle<fltp08> targetAngle() const { return m_target_angle; }
        [[nodiscard]] virtual bool supportsMoveTo() const;
        [[nodiscard]] virtual bool supportsSetSpeed() const;
        [[nodiscard]] virtual bool activated() const { return m_activated; };
        virtual void setLocation(const Angle<fltp08>& location);
        void setTarget(const Angle<fltp08>& location);
        void updatePositionFromSpeed(Time current_time);
        virtual void setTargetAndSpeed(const Angle<fltp08>& location, const Angle<fltp08>& speed);
        virtual void setModelTransformOffset(const Matrix<fltp08>& offset);
        virtual void setParkAngle(const Angle<fltp08>& location);
        virtual void setPreferredSpeed(const Angle<fltp08>& location) { m_preferred_speed = location; };
        virtual void setAxisOfRotation(const Vector<3, fltp08>& rotation_axis);
        virtual void setCenterOfRotation(const Vector<3, fltp08>& rotation_axis);
        virtual void setTorqueLimit(fltp08 limit) { m_torque_limit = limit; }
        virtual Bounds<2, Angle<fltp08>> speedRange() const { return m_speed_range; };
        virtual void setSpeed(const Angle<fltp08>& speed);
        virtual void setActivated(bool activated);
        void setSpeedRange(const Bounds<2, Angle<fltp08>>& speed_range);
        void parkMotor();
        virtual void parkMotorAtSpeed(const Angle<fltp08>& speed);
        virtual void updateModel();
    protected:
        Bounds<2, Angle<fltp08>> m_speed_range = Bounds<2, Angle<fltp08>>(Constant<Angle<fltp08>>::Invalid, Constant<Angle<fltp08>>::Invalid); 
        Bounds<1, Angle<fltp08>> m_bounds; 
        Vector<3, fltp08> m_axis_of_rotation; 
        Vector<3, fltp08> m_center_of_rotation; 
        Angle<fltp08> m_current_angle; 
        Angle<fltp08> m_current_speed; 
        Angle<fltp08> m_preferred_speed; 
        Angle<fltp08> m_target_angle; 
        Matrix<fltp08> m_model_transform_offset; 
        Angle<fltp08> m_park_angle; 
        Time m_last_speed_time = Constant<Time>::Invalid; 
        fltp08 m_torque_limit; 
        bool m_activated; 
    };
}