indifocuserinterface.h

Go to the documentation of this file.

/*
    Filter Interface
    Copyright (C) 2011 Jasem Mutlaq (mutlaqja@ikarustech.com)
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
*/
 
#pragma once
 
#include "indibase.h"
 
#include <stdint.h>
 
// Alias
using FI = INDI::FocuserInterface;
 
namespace INDI
{
 
class FocuserInterface
{
    public:
        enum FocusDirection
        {
            FOCUS_INWARD,
            FOCUS_OUTWARD
        };
 
        enum
        {
            FOCUSER_CAN_ABS_MOVE       = 1 << 0, 
            FOCUSER_CAN_REL_MOVE       = 1 << 1, 
            FOCUSER_CAN_ABORT          = 1 << 2, 
            FOCUSER_CAN_REVERSE        = 1 << 3, 
            FOCUSER_CAN_SYNC           = 1 << 4, 
            FOCUSER_HAS_VARIABLE_SPEED = 1 << 5, 
            FOCUSER_HAS_BACKLASH       = 1 << 6  
        } FocuserCapability;
 
        uint32_t GetCapability() const
        {
            return capability;
        }
 
        void SetCapability(uint32_t cap)
        {
            capability = cap;
        }
 
        bool CanAbsMove()
        {
            return capability & FOCUSER_CAN_ABS_MOVE;
        }
 
        bool CanRelMove()
        {
            return capability & FOCUSER_CAN_REL_MOVE;
        }
 
        bool CanAbort()
        {
            return capability & FOCUSER_CAN_ABORT;
        }
 
        bool CanReverse()
        {
            return capability & FOCUSER_CAN_REVERSE;
        }
 
        bool CanSync()
        {
            return capability & FOCUSER_CAN_SYNC;
        }
 
        bool HasVariableSpeed()
        {
            return capability & FOCUSER_HAS_VARIABLE_SPEED;
        }
 
        bool HasBacklash()
        {
            return capability & FOCUSER_HAS_BACKLASH;
        }
 
    protected:
        explicit FocuserInterface(DefaultDevice * defaultDevice);
        virtual ~FocuserInterface() = default;
 
        void initProperties(const char * groupName);
 
        bool updateProperties();
 
        bool processNumber(const char * dev, const char * name, double values[], char * names[], int n);
 
        bool processSwitch(const char * dev, const char * name, ISState * states, char * names[], int n);
 
        virtual bool SetFocuserSpeed(int speed);
 
        virtual IPState MoveFocuser(FocusDirection dir, int speed, uint16_t duration);
 
        virtual IPState MoveAbsFocuser(uint32_t targetTicks);
 
        virtual IPState MoveRelFocuser(FocusDirection dir, uint32_t ticks);
 
        virtual bool ReverseFocuser(bool enabled);
 
        virtual bool SyncFocuser(uint32_t ticks);
 
        virtual bool SetFocuserMaxPosition(uint32_t ticks);
 
        virtual bool SetFocuserBacklash(int32_t steps);
 
        virtual bool SetFocuserBacklashEnabled(bool enabled);
 
        virtual bool AbortFocuser();
 
        bool saveConfigItems(FILE * fp);
 
        // Focuser Speed (if variable speeds are supported)
        INumberVectorProperty FocusSpeedNP;
        INumber FocusSpeedN[1];
 
        // Focuser Motion switch.
        // For absolute focusers, this controls the directoin of FocusRelPos when updated.
        // For DC speed based focusers, this moves the focuser continues in the CW/CCW directions until stopped.
        ISwitchVectorProperty FocusMotionSP;
        ISwitch FocusMotionS[2];
 
        // Timer for user with DC focusers to run focuser in specific direction for this duration
        INumberVectorProperty FocusTimerNP;
        INumber FocusTimerN[1];
 
        // Absolute Focuser Position in steps
        INumberVectorProperty FocusAbsPosNP;
        INumber FocusAbsPosN[1];
 
        // Relative Focuser position to be commanded
        INumberVectorProperty FocusRelPosNP;
        INumber FocusRelPosN[1];
 
        // Absolute Focuser position is 0 to this maximum limit. By Default, it is set to 200,000.
        INumberVectorProperty FocusMaxPosNP;
        INumber FocusMaxPosN[1];
 
        // Sync
        INumberVectorProperty FocusSyncNP;
        INumber FocusSyncN[1];
 
        // Abort Focuser
        ISwitchVectorProperty FocusAbortSP;
        ISwitch FocusAbortS[1];
 
        // Reverse Focuser
        ISwitchVectorProperty FocusReverseSP;
        ISwitch FocusReverseS[2];
 
        // Backlash toogle
        ISwitchVectorProperty FocusBacklashSP;
        ISwitch FocusBacklashS[2];
 
        // Backlash steps
        INumberVectorProperty FocusBacklashNP;
        INumber FocusBacklashN[1];
 
        uint32_t capability;
 
        double lastTimerValue = { 0 };
 
        DefaultDevice * m_defaultDevice { nullptr };
};
}