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 "indipropertyswitch.h"
#include "inditimer.h"
#include "indielapsedtimer.h"
#include "fitskeyword.h"
#include "dsp/manager.h"
#include "stream/streammanager.h"
 
 
#include <fitsio.h>
 
#include <map>
#include <cstring>
#include <chrono>
#include <stdint.h>
#include <mutex>
#include <thread>
 
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 XISFWrapper;
 
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_DSP        = 1 << 10 
        } CCDCapability;
 
        typedef enum { UPLOAD_CLIENT, UPLOAD_LOCAL, UPLOAD_BOTH } CCD_UPLOAD_MODE;
 
        typedef struct CaptureFormat
        {
            std::string name;
            std::string label;
            uint8_t bitsPerPixel {8};
            bool isDefault {false};
            bool isLittleEndian {true};
        } CaptureFormat;
 
        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 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 bool SetCaptureFormat(uint8_t index);
 
        virtual void addFITSKeywords(CCDChip * targetChip, std::vector<FITSRecord> &fitsKeywords);
 
        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 UploadComplete(CCDChip *) {}
 
        virtual void checkTemperatureTarget();
 
        virtual bool processFastExposure(CCDChip * targetChip);
 
        virtual void addCaptureFormat(const CaptureFormat &format);
 
        // 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;
        bool J2000Valid;
 
        // exposure information
        char exposureStartTime[MAXINDINAME];
        double exposureDuration;
 
        double snoopedFocalLength, snoopedAperture;
        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;
 
        // Native absolute rotator position
        double RotatorPosition;
 
        // 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;
        // Tracking for warming-up stabilization detection (can't heat above ambient)
        double m_TemperatureStabilizationValue {0};
        INDI::ElapsedTimer m_TemperatureStabilizationTimer;
        // Temperature when the ramp was initiated, used to compute expected ramp duration
        double m_InitialRampTemperature {0};
 
        // Threading
        std::mutex ccdBufferLock;
 
        std::vector<std::string> FilterNames;
        int CurrentFilterSlot {-1};
 
        std::vector<CaptureFormat> m_CaptureFormats;
 
        std::unique_ptr<StreamManager> Streamer;
        std::unique_ptr<DSP::Manager> DSP;
        CCDChip PrimaryCCD;
        CCDChip GuideCCD;
 
 
 
        INDI::PropertyNumber EqNP {2};
 
        INDI::PropertyNumber J2000EqNP {2};
        enum
        {
            Ra,
            DEC,
        };
 
        INDI::PropertyText ActiveDeviceTP {5};
        enum
        {
            ACTIVE_TELESCOPE,
            ACTIVE_ROTATOR,
            ACTIVE_FOCUSER,
            ACTIVE_FILTER,
            ACTIVE_SKYQUALITY
        };
 
        INDI::PropertyNumber TemperatureNP {1};
 
        INDI::PropertyNumber TemperatureRampNP {2};
        enum
        {
            RAMP_SLOPE,
            RAMP_THRESHOLD
        };
 
        INDI::PropertyText BayerTP {3};
        enum
        {
            CFA_OFFSET_X,
            CFA_OFFSET_Y,
            CFA_TYPE
        };
        INDI::PropertyText FileNameTP {1};
 
        INDI::PropertySwitch CaptureFormatSP {0};
 
        INDI::PropertySwitch EncodeFormatSP {3};
        enum
        {
            FORMAT_FITS,     
            FORMAT_NATIVE,   
            FORMAT_XISF      
        };
 
        INDI::PropertySwitch UploadSP {3};
 
        INDI::PropertyText UploadSettingsTP {2};
        enum
        {
            UPLOAD_DIR,
            UPLOAD_PREFIX
        };
 
        // Telescope Information
        INDI::PropertyNumber ScopeInfoNP {2};
        enum
        {
            FOCAL_LENGTH,
            APERTURE
        };
 
        // WCS
        INDI::PropertySwitch WorldCoordSP{2};
        enum
        {
            WCS_ENABLE,
            WCS_DISABLE
        };
        // WCS CCD Rotation
        INDI::PropertyNumber CCDRotationNP{1};
 
        // Fast Exposure Toggle
        INDI::PropertySwitch FastExposureToggleSP {2};
 
        // Fast Exposure Frame Count
        INDI::PropertyNumber FastExposureCountNP {1};
        double m_UploadTime = { 0 };
        std::chrono::system_clock::time_point FastExposureToggleStartup;
 
        INDI::PropertyText FITSHeaderTP {3};
        enum
        {
            KEYWORD_NAME,
            KEYWORD_VALUE,
            KEYWORD_COMMENT,
        };
 
    private:
        uint32_t capability;
 
        bool m_ValidCCDRotation {false};
        std::string m_ConfigCaptureFormatName;
        int m_ConfigEncodeFormatIndex {-1};
        int m_ConfigFastExposureIndex {INDI_DISABLED};
 
        std::map<std::string, FITSRecord> m_CustomFITSKeywords;
 
        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 std::string &dir, const std::string &prefix, const std::string &ext);
        bool ExposureCompletePrivate(CCDChip * targetChip);
 
        friend class StreamManager;
        friend class StreamManagerPrivate;
};
}