indisensorinterface.h

Go to the documentation of this file.

/*******************************************************************************
 Copyright(c) 2010, 2017 Ilia Platone, Jasem Mutlaq. 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 "defaultdevice.h"
#include "dsp.h"
#include "dsp/manager.h"
#include "stream/streammanager.h"
#include <fitsio.h>
 
#include <fitsio.h>
 
#include <memory>
#include <cstring>
#include <chrono>
#include <stdint.h>
#include <mutex>
#include <thread>
#include <stream/streammanager.h>
#include <connectionplugins/connectionserial.h>
#include <connectionplugins/connectiontcp.h>
 
//JM 2019-01-17: Disabled until further notice
//#define WITH_EXPOSURE_LOOPING
 
namespace DSP
{
class Manager;
}
namespace INDI
{
class StreamManager;
 
class SensorInterface : public DefaultDevice
{
 
    public:
        enum
        {
            SENSOR_CAN_ABORT                  = 1 << 0, 
            SENSOR_HAS_STREAMING              = 1 << 1, 
            SENSOR_HAS_SHUTTER                = 1 << 2, 
            SENSOR_HAS_COOLER                 = 1 << 3, 
            SENSOR_HAS_DSP                    = 1 << 4,
            SENSOR_MAX_CAPABILITY             = 1 << 5, 
        } SensorCapability;
 
        SensorInterface();
        ~SensorInterface();
 
 
        enum
        {
            CONNECTION_NONE   = 1 << 0, 
            CONNECTION_SERIAL = 1 << 1, 
            CONNECTION_TCP    = 1 << 2  
        } SensorConnection;
 
        bool initProperties();
        bool updateProperties();
        bool processNumber(const char *dev, const char *name, double values[], char *names[], int n);
        void processProperties(const char *dev);
        bool processText(const char *dev, const char *name, char *texts[], char *names[], int n);
        bool processSwitch(const char *dev, const char *name, ISState states[], char *names[], int n);
        bool processBLOB(const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[],
                         char *formats[], char *names[], int n);
        bool processSnoopDevice(XMLEle *root);
 
        inline int getBufferSize() const
        {
            return BufferSize;
        }
 
        inline double getIntegrationLeft() const
        {
            return FramedIntegrationN[0].value;
        }
 
        inline double getIntegrationTime() const
        {
            return integrationTime;
        }
 
        const char *getIntegrationStartTime();
 
        inline uint8_t *getBuffer()
        {
            return Continuum;
        }
 
        inline void setBuffer(uint8_t *buffer)
        {
            Continuum = buffer;
        }
 
        inline uint8_t *getReal()
        {
            return Real;
        }
 
        inline void setReal(uint8_t *buffer)
        {
            int x = 0;
            for(x = 0; x < getBufferSize(); x++) {
                getMagnitude()[x] = pow(pow(getReal()[x], 2)+pow(buffer[x], 2), 0.5);
                if(getMagnitude()[x] > 0) {
                    getPhase()[x] = acos(buffer[x]/getMagnitude()[x]);
                    if(asin(getReal()[x]/getMagnitude()[x]) < 0)
                        getPhase()[x] += M_PI;
                } else {
                    getPhase()[x] = 0;
                }
            }
 
            Real = buffer;
        }
 
        inline uint8_t *getImaginary()
        {
            return Imaginary;
        }
 
        inline void setImaginary(uint8_t *buffer)
        {
            int x = 0;
            for(x = 0; x < getBufferSize(); x++) {
                getMagnitude()[x] = pow(pow(getReal()[x], 2)+pow(buffer[x], 2), 0.5);
                if(getMagnitude()[x] > 0) {
                getPhase()[x] = acos(buffer[x]/getMagnitude()[x]);
                if(asin(getReal()[x]/getMagnitude()[x]) < 0)
                    getPhase()[x] += M_PI;
                } else {
                    getPhase()[x] = 0;
                }
            }
 
            Imaginary = buffer;
        }
 
        inline uint8_t *getMagnitude()
        {
            return Magnitude;
        }
 
        inline void setMagnitude(uint8_t *buffer)
        {
            int x = 0;
            for(x = 0; x < getBufferSize(); x++) {
                getReal()[x] = sin(getPhase()[x]*buffer[x]);
                getImaginary()[x] = cos(getPhase()[x]*buffer[x]);
            }
 
            Magnitude = buffer;
        }
 
        inline uint8_t *getPhase()
        {
            return Phase;
        }
 
        inline void setPhase(uint8_t *buffer)
        {
            int x = 0;
            for(x = 0; x < getBufferSize(); x++) {
                getReal()[x] = sin(getPhase()[x]*buffer[x]);
                getImaginary()[x] = cos(getPhase()[x]*buffer[x]);
            }
 
            Phase = buffer;
        }
 
        inline int getBPS() const
        {
            return BPS;
        }
 
        virtual void setMinMaxStep(const char *property, const char *element, double min, double max, double step,
                                   bool sendToClient = true);
 
        void setBufferSize(int nbuf, bool allocMem = true);
 
        void setBPS(int bps);
 
        void setIntegrationTime(double duration);
 
        void setIntegrationLeft(double duration);
 
        void setIntegrationFailed();
 
        int getNAxis() const;
 
        void setNAxis(int value);
 
        void setIntegrationFileExtension(const char *ext);
 
        inline char *getIntegrationFileExtension()
        {
            return integrationExtention;
        }
 
        inline bool isCapturing() const
        {
            return (FramedIntegrationNP.s == IPS_BUSY);
        }
 
        virtual int SetTemperature(double temperature);
 
        friend class StreamManager;
        friend class StreamManagerPrivate;
        virtual bool StartStreaming();
 
        virtual bool StopStreaming();
 
        virtual bool StartIntegration(double duration);
 
        virtual bool IntegrationComplete();
 
        virtual bool Handshake();
 
        void setSensorConnection(const uint8_t &value);
 
        inline uint8_t getSensorConnection()
        {
            return sensorConnection;
        }
 
        virtual void addFITSKeywords(fitsfile *fptr, uint8_t* buf, int len);
 
        void fits_update_key_s(fitsfile *fptr, int type, std::string name, void *p, std::string explanation, int *status);
 
        int getPortFD()
        {
            return PortFD;
        }
 
        Connection::Serial *getSerialConnection()
        {
            return serialConnection;
        }
 
        Connection::TCP *getTcpConnection()
        {
            return tcpConnection;
        }
 
    protected:
 
        bool HasShutter() const
        {
            return capability & SENSOR_HAS_SHUTTER;
        }
 
        bool HasCooler() const
        {
            return capability & SENSOR_HAS_COOLER;
        }
 
        bool CanAbort() const
        {
            return capability & SENSOR_CAN_ABORT;
        }
 
        bool HasDSP()
        {
            if (capability & SENSOR_HAS_DSP)
            {
                if(DSP.get() == nullptr)
                {
                    DSP.reset(new DSP::Manager(this));
                }
                return true;
            }
            return false;
        }
 
        bool HasStreaming()
        {
            if (capability & SENSOR_HAS_STREAMING)
            {
                if(Streamer.get() == nullptr)
                {
                    Streamer.reset(new StreamManager(this));
                    Streamer->initProperties();
                }
                return true;
            }
            return false;
        }
 
        uint32_t GetCapability() const
        {
            return capability;
        }
 
        void SetCapability(uint32_t cap);
 
        virtual bool AbortIntegration();
 
        uint32_t capability;
 
        INumberVectorProperty FramedIntegrationNP;
        INumber FramedIntegrationN[1];
 
        ISwitchVectorProperty AbortIntegrationSP;
        ISwitch AbortIntegrationS[1];
 
        IBLOB FitsB[5];
        IBLOBVectorProperty FitsBP;
        ITextVectorProperty ActiveDeviceTP;
        IText ActiveDeviceT[4] {};
 
        IText FileNameT[1] {};
        ITextVectorProperty FileNameTP;
        enum
        {
            TELESCOPE_PRIMARY
        };
 
        ISwitch DatasetS[1];
        ISwitchVectorProperty DatasetSP;
 
 
        ISwitch UploadS[3];
        ISwitchVectorProperty UploadSP;
 
        IText UploadSettingsT[2] {};
        ITextVectorProperty UploadSettingsTP;
        enum
        {
            UPLOAD_DIR,
            UPLOAD_PREFIX
        };
 
        ISwitch TelescopeTypeS[2];
        ISwitchVectorProperty TelescopeTypeSP;
 
        // FITS Header
        IText FITSHeaderT[2] {};
        ITextVectorProperty FITSHeaderTP;
        enum
        {
            FITS_OBSERVER,
            FITS_OBJECT
        };
 
        virtual bool saveConfigItems(FILE *fp);
 
        bool InIntegration;
 
        INumberVectorProperty EqNP;
        INumber EqN[2];
        double RA, Dec;
 
        INumberVectorProperty LocationNP;
        INumber LocationN[3];
        double Latitude, Longitude, Elevation;
 
        INumberVectorProperty ScopeParametersNP;
        INumber ScopeParametersN[4];
        double primaryAperture, primaryFocalLength;
 
        bool AutoLoop;
        bool SendIntegration;
        bool ShowMarker;
 
        double IntegrationTime;
 
        // Sky Quality
        double MPSAS;
 
        virtual void activeDevicesUpdated() {}
 
        INumber TemperatureN[1];
        INumberVectorProperty TemperatureNP;
 
        // Threading
        std::mutex detectorBufferLock;
 
        std::unique_ptr<StreamManager> Streamer;
        std::unique_ptr<DSP::Manager> DSP;
        Connection::Serial *serialConnection = NULL;
        Connection::TCP *tcpConnection       = NULL;
 
        int PortFD = -1;
 
    private:
        bool callHandshake();
        uint8_t sensorConnection = CONNECTION_NONE;
 
        int BPS;
        int NAxis;
        uint8_t *Continuum;
        uint8_t *Real;
        uint8_t *Imaginary;
        uint8_t *Magnitude;
        uint8_t *Phase;
        int BufferSize;
        double integrationTime;
        double startIntegrationTime;
        char integrationExtention[MAXINDIBLOBFMT];
 
        bool uploadFile(const void *fitsData, size_t totalBytes, IBLOB blob, bool sendIntegration, bool saveIntegration);
        void getMinMax(double *min, double *max, uint8_t *buf, int len, int bpp);
        int getFileIndex(const char *dir, const char *prefix, const char *ext);
 
        bool IntegrationCompletePrivate();
        void* sendFITS(uint8_t* buf, int len, IBLOB blob);
};
}