DistanceEncoder.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/Device.h>
namespace NDEVR
{
    class PositionSensor;
    class DesignObjectLookup;
    class Battery;
    class Motor;
    class TemperatureSensor;
    struct DeploymentInfo
    {
        DesignObjectLookup* manager = nullptr;
        PositionSensor* sensor = nullptr;
        fltp08 deployment_segment_length = 1.0;
        bool active = false;
    };
    
    /**--------------------------------------------------------------------------------------------------
    \brief A distance encoder is a device that measures distance by generating pulses in response to an 
        object's movement. The pulses are then processed and converted into a distance measurement.
 
    Types of encoders include:
        -Linear encoders: These encoders are best suited for measuring distances of up to 10 feet and 
            can provide high accuracy and repeatability.
        -Rotary encoders: These encoders can measure linear distance by calculating the number of
            pulses compared to the known number of pulses per arc length.
        -Optical shaft encoders: These encoders can track distance, direction of motion, and 
            position of rotary components.
        Measuring wheel encoders: These encoders can measure linear distance by using a measuring 
            wheel that has direct contact with the surface being measured.
        Draw-wire encoders: These encoders use a spring-driven retractable cable spool 
            attached to a shaft encoder.
    **/
    class HARDWARE_API DistanceEncoder : public Device
    {
    public:
        DistanceEncoder(const Model& model, ProgressInfo* log = nullptr, QObject* parent = nullptr);
        virtual void setRawLengthEpsilon(fltp08 epsilon) { m_raw_length_epsilon = epsilon; }
        virtual void clearDeploymentInfo();
        virtual void setSpeed(fltp08 speed) { m_speed = speed; }
        virtual void setDistanceBounds(const Bounds<1, fltp08>& bounds) { m_bounds = bounds; }
        virtual void setRawLength(fltp08 length);
        virtual void setDeploymentInfo(const DeploymentInfo& info);
        virtual void startNewDeployment();
        virtual void updateModel();
        virtual fltp08 rawLength() const { return m_raw_length; }; 
        virtual fltp08 scale() const { return m_scale; };
        virtual fltp08 length() const;
        virtual void zeroRaw();
        fltp08 preferredSegmentLength() const;
        virtual void calibrateToLength(fltp08 length);
        virtual void setScale(fltp08 scale);
        virtual void setOffset(fltp08 offset);
        virtual void setLocation(const Vertex<3, fltp08>& location);
        virtual void setCanDeleteReadings(bool can_delete) { m_delete_encoder_readings = can_delete; }
        virtual Battery* battery() const { return m_battery; }
        virtual void setBattery(Battery* battery) { m_battery = battery; }
        virtual void setNewDeploymentOffset(fltp08 offset) { m_new_deployment_offset = offset; }
        virtual TemperatureSensor* temperatureSensor() const { return m_temperature_sensor; }
        virtual void setTemperatureSensor(TemperatureSensor* battery) { m_temperature_sensor = battery; }
        virtual bool isInUse() const { return m_is_in_use; }
        virtual void setInUse(bool is_in_use);
    public:
        static DistanceEncoder* PrimaryDistanceEncoder();
        static void SetPrimaryDistanceEncoderCallback(const std::function<DistanceEncoder*()>& encoder);
    protected:
        static std::function<DistanceEncoder*()> s_get_distance_encoder;
    protected:
        Bounds<1, fltp08> m_bounds;
        DeploymentInfo m_deployment_info;
        fltp08 m_raw_length = 0.0;
        fltp08 m_raw_offset = 0.0;
        fltp08 m_offset = 0.0;
        fltp08 m_scale = 1.0;
        fltp08 m_speed = 0.0;
        fltp08 m_new_deployment_offset = 0.0;
        fltp08 m_raw_length_epsilon = 0.01;
        Battery* m_battery = nullptr;
        TemperatureSensor* m_temperature_sensor = nullptr;
        bool m_delete_encoder_readings = false;
        bool m_is_in_use = true;
    };
}