indiccd.h

Go to the documentation of this file.

/*******************************************************************************
 Copyright(c) 2010-2018 Jasem Mutlaq. All rights reserved.
 
 Copyright(c) 2010, 2011 Gerry Rozema. All rights reserved.
 
 Rapid Guide support added by CloudMakers, s. r. o.
 Copyright(c) 2013 CloudMakers, s. r. o. All rights reserved.
 
 Star detection algorithm is based on PHD Guiding by Craig Stark
 Copyright (c) 2006-2010 Craig Stark. All rights reserved.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "indiccdchip.h"
#include "defaultdevice.h"
#include "indiguiderinterface.h"
#include "indipropertynumber.h"
#include "inditimer.h"
#include "indielapsedtimer.h"
#include "dsp/manager.h"
#include "stream/streammanager.h"
 
#ifdef HAVE_WEBSOCKET
#include "indiwsserver.h"
#endif
 
#include <fitsio.h>
 
#include <memory>
#include <cstring>
#include <chrono>
#include <stdint.h>
#include <mutex>
#include <thread>
 
//JM 2019-01-17: Disabled until further notice
//#define WITH_EXPOSURE_LOOPING
 
extern const char * IMAGE_SETTINGS_TAB;
extern const char * IMAGE_INFO_TAB;
extern const char * GUIDE_HEAD_TAB;
//extern const char * RAPIDGUIDE_TAB;
 
namespace DSP
{
class Manager;
}
namespace INDI
{
 
class StreamManager;
 
class CCD : public DefaultDevice, GuiderInterface
{
    public:
        CCD();
        virtual ~CCD();
 
        enum
        {
            CCD_CAN_BIN        = 1 << 0, 
            CCD_CAN_SUBFRAME   = 1 << 1, 
            CCD_CAN_ABORT      = 1 << 2, 
            CCD_HAS_GUIDE_HEAD = 1 << 3, 
            CCD_HAS_ST4_PORT   = 1 << 4, 
            CCD_HAS_SHUTTER    = 1 << 5, 
            CCD_HAS_COOLER     = 1 << 6, 
            CCD_HAS_BAYER      = 1 << 7, 
            CCD_HAS_STREAMING  = 1 << 8, 
            CCD_HAS_WEB_SOCKET = 1 << 9, 
            CCD_HAS_DSP        = 1 << 10 
        } CCDCapability;
 
        typedef enum { UPLOAD_CLIENT, UPLOAD_LOCAL, UPLOAD_BOTH } CCD_UPLOAD_MODE;
 
        virtual bool initProperties() override;
        virtual bool updateProperties() override;
        virtual void ISGetProperties(const char * dev) override;
        virtual bool ISNewNumber(const char * dev, const char * name, double values[], char * names[], int n) override;
        virtual bool ISNewSwitch(const char * dev, const char * name, ISState * states, char * names[], int n) override;
        virtual bool ISNewText(const char * dev, const char * name, char * texts[], char * names[], int n) override;
        virtual bool ISNewBLOB(const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[],
                               char *names[], int n) override;
        virtual bool ISSnoopDevice(XMLEle * root) override;
 
        static void wsThreadHelper(void * context);
 
        static constexpr const char *GUIDE_CONTROL_TAB  = "Guider Control";
        static constexpr const char * WCS_TAB = "WCS";
 
 
    protected:
        uint32_t GetCCDCapability() const
        {
            return capability;
        }
 
        void SetCCDCapability(uint32_t cap);
 
        bool CanAbort()
        {
            return capability & CCD_CAN_ABORT;
        }
 
        bool CanBin()
        {
            return capability & CCD_CAN_BIN;
        }
 
        bool CanSubFrame()
        {
            return capability & CCD_CAN_SUBFRAME;
        }
 
        bool HasGuideHead()
        {
            return capability & CCD_HAS_GUIDE_HEAD;
        }
 
        bool HasShutter()
        {
            return capability & CCD_HAS_SHUTTER;
        }
 
        bool HasST4Port()
        {
            return capability & CCD_HAS_ST4_PORT;
        }
 
        bool HasCooler()
        {
            return capability & CCD_HAS_COOLER;
        }
 
        bool HasBayer()
        {
            return capability & CCD_HAS_BAYER;
        }
 
        bool HasStreaming()
        {
            if (capability & CCD_HAS_STREAMING)
            {
                if(Streamer.get() == nullptr)
                {
                    Streamer.reset(new StreamManager(this));
                    Streamer->initProperties();
                }
                return true;
            }
            return false;
        }
 
        bool HasWebSocket()
        {
            return capability & CCD_HAS_WEB_SOCKET;
        }
 
        bool HasDSP()
        {
            if (capability & CCD_HAS_DSP)
            {
                if(DSP.get() == nullptr)
                {
                    DSP.reset(new DSP::Manager(this));
                }
                return true;
            }
            return false;
        }
 
        virtual int SetTemperature(double temperature);
 
        virtual bool StartExposure(float duration);
 
        virtual bool ExposureComplete(CCDChip * targetChip);
 
        virtual bool AbortExposure();
 
        virtual bool StartGuideExposure(float duration);
 
        virtual bool AbortGuideExposure();
 
        virtual bool UpdateCCDFrame(int x, int y, int w, int h);
 
        virtual bool UpdateGuiderFrame(int x, int y, int w, int h);
 
        virtual bool UpdateCCDBin(int hor, int ver);
 
        virtual bool UpdateGuiderBin(int hor, int ver);
 
        virtual bool UpdateCCDFrameType(CCDChip::CCD_FRAME fType);
 
        virtual bool UpdateCCDUploadMode(CCD_UPLOAD_MODE mode)
        {
            INDI_UNUSED(mode);
            return true;
        }
 
        virtual bool UpdateGuiderFrameType(CCDChip::CCD_FRAME fType);
 
        virtual void SetCCDParams(int x, int y, int bpp, float xf, float yf);
 
        virtual void SetGuiderParams(int x, int y, int bpp, float xf, float yf);
 
        virtual IPState GuideNorth(uint32_t ms) override;
 
        virtual IPState GuideSouth(uint32_t ms) override;
 
        virtual IPState GuideEast(uint32_t ms) override;
 
        virtual IPState GuideWest(uint32_t ms) override;
 
        virtual bool StartStreaming();
 
        virtual bool StopStreaming();
 
        virtual void addFITSKeywords(fitsfile * fptr, CCDChip * targetChip);
 
        void fits_update_key_s(fitsfile * fptr, int type, std::string name, void * p, std::string explanation, int * status);
 
        virtual void activeDevicesUpdated() {}
 
        virtual bool saveConfigItems(FILE * fp) override;
 
        virtual void GuideComplete(INDI_EQ_AXIS axis) override;
 
        virtual void checkTemperatureTarget();
 
 
        // Epoch Position
        double RA, Dec;
 
        // pier side, read from mount if available, set to -1 if not available
        int pierSide;       // West = 0, East =1. No enum available
 
        // J2000 Position
        double J2000RA;
        double J2000DE;
 
        double primaryFocalLength, primaryAperture, guiderFocalLength, guiderAperture;
        bool InExposure;
        bool InGuideExposure;
        //bool RapidGuideEnabled;
        //bool GuiderRapidGuideEnabled;
 
        bool AutoLoop;
        bool GuiderAutoLoop;
        bool SendImage;
        bool GuiderSendImage;
        bool ShowMarker;
        bool GuiderShowMarker;
 
        double ExposureTime;
        double GuiderExposureTime;
 
        // Sky Quality
        double MPSAS;
 
        // Rotator Angle
        double RotatorAngle;
 
        // JJ ed 2019-12-10 current focuser position
        long FocuserPos;
        double FocuserTemp;
 
        // Airmass
        double Airmass;
        double Latitude;
        double Longitude;
        double Azimuth;
        double Altitude;
 
        // Temperature Control
        double m_TargetTemperature {0};
        INDI::Timer m_TemperatureCheckTimer;
        INDI::ElapsedTimer m_TemperatureElapsedTimer;
 
        // Threading
        std::mutex ccdBufferLock;
 
        std::vector<std::string> FilterNames;
        int CurrentFilterSlot {-1};
 
        std::unique_ptr<StreamManager> Streamer;
        std::unique_ptr<DSP::Manager> DSP;
        CCDChip PrimaryCCD;
        CCDChip GuideCCD;
 
 
 
        INumberVectorProperty EqNP;
        INumber EqN[2];
 
        ITextVectorProperty ActiveDeviceTP;
 
        // JJ ed 2019-12-10
        IText ActiveDeviceT[5] {};
        enum
        {
            ACTIVE_TELESCOPE,
            ACTIVE_ROTATOR,
            ACTIVE_FOCUSER,
            ACTIVE_FILTER,
            ACTIVE_SKYQUALITY
        };
 
        INumberVectorProperty TemperatureNP;
        INumber TemperatureN[1];
 
        INDI::PropertyNumber TemperatureRampNP {2};
        enum
        {
            RAMP_SLOPE,
            RAMP_THRESHOLD
        };
 
        ITextVectorProperty BayerTP;
        IText BayerT[3] {};
 
        ITextVectorProperty FileNameTP;
        IText FileNameT[1] {};
 
        ISwitch UploadS[3];
        ISwitchVectorProperty UploadSP;
 
        IText UploadSettingsT[2] {};
        ITextVectorProperty UploadSettingsTP;
        enum
        {
            UPLOAD_DIR,
            UPLOAD_PREFIX
        };
 
        ISwitch TelescopeTypeS[2];
        ISwitchVectorProperty TelescopeTypeSP;
        enum
        {
            TELESCOPE_PRIMARY,
            TELESCOPE_GUIDE
        };
 
        // Websocket Support
        ISwitch WebSocketS[2];
        ISwitchVectorProperty WebSocketSP;
        enum
        {
            WEBSOCKET_ENABLED,
            WEBSOCKET_DISABLED,
        };
 
 
        // Websocket Settings
        INumber WebSocketSettingsN[1];
        INumberVectorProperty WebSocketSettingsNP;
        enum
        {
            WS_SETTINGS_PORT,
        };
 
        // WCS
        ISwitch WorldCoordS[2];
        ISwitchVectorProperty WorldCoordSP;
 
        // WCS CCD Rotation
        INumber CCDRotationN[1];
        INumberVectorProperty CCDRotationNP;
 
#ifdef WITH_EXPOSURE_LOOPING
        // Exposure Looping
        ISwitch ExposureLoopS[2];
        ISwitchVectorProperty ExposureLoopSP;
        enum
        {
            EXPOSURE_LOOP_ON,
            EXPOSURE_LOOP_OFF
        };
 
        // Exposure Looping Count
        INumber ExposureLoopCountN[1];
        INumberVectorProperty ExposureLoopCountNP;
        double uploadTime = { 0 };
        std::chrono::system_clock::time_point exposureLoopStartup;
#endif
 
        // FITS Header
        IText FITSHeaderT[2] {};
        ITextVectorProperty FITSHeaderTP;
        enum
        {
            FITS_OBSERVER,
            FITS_OBJECT
        };
 
    private:
        uint32_t capability;
 
        bool m_ValidCCDRotation;
 
        bool uploadFile(CCDChip * targetChip, const void * fitsData, size_t totalBytes, bool sendImage, bool saveImage);
        void getMinMax(double * min, double * max, CCDChip * targetChip);
        int getFileIndex(const char * dir, const char * prefix, const char * ext);
        bool ExposureCompletePrivate(CCDChip * targetChip);
 
        // Threading for Websocket
#ifdef HAVE_WEBSOCKET
        std::thread wsThread;
        void wsThreadEntry();
        INDIWSServer wsServer;
#endif
 
        friend class StreamManager;
        friend class StreamManagerPrivate;
};
}