gemini_flatpanel_adapters.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
 
// Forward declaration to avoid circular dependencies
class GeminiFlatpanel;
 
// Constants that may be needed by adapters
#define GEMINI_MIN_BRIGHTNESS 0
#define GEMINI_MAX_BRIGHTNESS 255
#define SERIAL_TIMEOUT_SEC 10
#define SERIAL_TIMEOUT_SEC_LONG 120
#define NO_VALUE 1000 // Used to indicate that no value is provided
// Note: MAXRBUF is already defined in INDI headers
 
// Gemini device constants
enum GeminiRevision
{
    GEMINI_REVISION_UNKNOWN = 0,
    GEMINI_REVISION_1 = 1,
    GEMINI_REVISION_2 = 2,
    GEMINI_REVISION_LITE = 3,
    GEMINI_REVISION_PRO = 4
};
 
enum GeminiConfigStatus
{
    GEMINI_CONFIG_NOTREADY = 0,
    GEMINI_CONFIG_READY = 1,
    GEMINI_CONFIG_CLOSED = 2,
    GEMINI_CONFIG_OPEN = 3,
};
 
enum GeminiBrightnessMode
{
    GEMINI_BRIGHTNESS_MODE_LOW = 0,
    GEMINI_BRIGHTNESS_MODE_HIGH = 1
};
 
// Status constants used by all adapters
enum GeminiCoverStatus
{
    GEMINI_COVER_STATUS_MOVING = 0,
    GEMINI_COVER_STATUS_CLOSED = 1,
    GEMINI_COVER_STATUS_OPEN = 2,
    GEMINI_COVER_STATUS_TIMED_OUT = 3
};
 
enum GeminiLightStatus
{
    GEMINI_LIGHT_STATUS_OFF = 0,
    GEMINI_LIGHT_STATUS_ON = 1
};
 
enum GeminiMotorStatus
{
    GEMINI_MOTOR_STATUS_STOPPED = 0,
    GEMINI_MOTOR_STATUS_RUNNING = 1
};
 
enum GeminiDirection
{
    GEMINI_DIRECTION_CLOSE = -1,
    GEMINI_DIRECTION_OPEN = 1
};
 
enum GeminiBeepStatus
{
    GEMINI_BEEP_OFF = 0,
    GEMINI_BEEP_ON = 1
};
 
class GeminiFlatpanelAdapter
{
    public:
        virtual ~GeminiFlatpanelAdapter() = default;
 
        // Device detection and identification
 
        virtual bool ping() = 0;
 
        virtual int getRevision() const = 0;
 
        virtual bool getFirmwareVersion(int *version) = 0;
 
        // Capability checks
 
        virtual bool supportsBeep() const = 0;
 
        virtual bool supportsDustCap() const = 0;
 
        virtual bool supportsBrightnessMode() const = 0;
 
        // Basic device commands (supported by all revisions)
 
        virtual bool getConfigStatus(int *status) = 0;
 
        virtual bool getBrightness(int *brightness) = 0;
 
        virtual bool setBrightness(int value) = 0;
 
        virtual bool lightOn() = 0;
 
        virtual bool lightOff() = 0;
 
        virtual bool openCover() = 0;
 
        virtual bool closeCover() = 0;
 
        virtual bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) = 0;
 
        // Motion/calibration commands
 
        virtual bool move(uint16_t value, int direction) = 0;
 
        virtual bool setClosePosition() = 0;
 
        virtual bool setOpenPosition() = 0;
 
        // Advanced commands (may not be supported by all revisions)
 
        virtual bool setBeep(bool enable) = 0;
 
        virtual bool setBrightnessMode(int mode) = 0;
 
        // Communication setup
 
        virtual char getCommandTerminator() const = 0;
 
        virtual void setupCommunication(int portFD) = 0;
};
 
class GeminiFlatpanelRev1Adapter : public GeminiFlatpanelAdapter
{
    private:
        int portFD;
 
        // Internal helper methods for Rev1 protocol
 
        bool formatCommand(char commandLetter, char *commandString, int value = NO_VALUE);
 
        bool sendCommand(const char *command, char *response, int timeout = SERIAL_TIMEOUT_SEC, bool log = true);
 
        bool extractIntValue(const char *response, int startPos, int *value);
 
    public:
        GeminiFlatpanelRev1Adapter() : portFD(-1) {}
 
        // Device detection and identification
        bool ping() override;
        int getRevision() const override
        {
            return GEMINI_REVISION_1;
        }
        bool getFirmwareVersion(int *version) override;
 
        // Capability checks
        bool supportsBeep() const override
        {
            return false;
        }
        bool supportsDustCap() const override
        {
            return true;
        }
        bool supportsBrightnessMode() const override
        {
            return false;
        }
 
        // Basic device commands
        bool getConfigStatus(int *status) override;
        bool getBrightness(int *brightness) override;
        bool setBrightness(int value) override;
        bool lightOn() override;
        bool lightOff() override;
        bool openCover() override;
        bool closeCover() override;
        bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) override;
 
        // Motion/calibration commands
        bool move(uint16_t value, int direction) override;
        bool setClosePosition() override;
        bool setOpenPosition() override;
 
        // Advanced commands (not supported by Rev1)
        bool setBeep(bool enable) override
        {
            (void)enable;    // Not supported
            return false;
        }
        bool setBrightnessMode(int mode) override
        {
            (void)mode;    // Not supported
            return false;
        }
 
        // Communication setup
        char getCommandTerminator() const override
        {
            return '\n';
        }
        void setupCommunication(int portFD) override
        {
            this->portFD = portFD;
        }
};
 
class GeminiFlatpanelRev2Adapter : public GeminiFlatpanelAdapter
{
    private:
        int portFD;
 
        // Internal helper methods for Rev2 protocol
 
        bool formatCommand(char commandLetter, char *commandString, int value = NO_VALUE);
 
        bool sendCommand(const char *command, char *response, int timeout = SERIAL_TIMEOUT_SEC, bool log = true);
 
        bool extractIntValue(const char *response, int startPos, int *value);
 
    public:
        GeminiFlatpanelRev2Adapter() : portFD(-1) {}
 
        // Device detection and identification
        bool ping() override;
        int getRevision() const override
        {
            return GEMINI_REVISION_2;
        }
        bool getFirmwareVersion(int *version) override;
 
        // Capability checks
        bool supportsBeep() const override
        {
            return true;
        }
        bool supportsDustCap() const override
        {
            return true;
        }
        bool supportsBrightnessMode() const override
        {
            return true;
        }
 
        // Basic device commands
        bool getConfigStatus(int *status) override;
        bool getBrightness(int *brightness) override;
        bool setBrightness(int value) override;
        bool lightOn() override;
        bool lightOff() override;
        bool openCover() override;
        bool closeCover() override;
        bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) override;
 
        // Motion/calibration commands
        bool move(uint16_t value, int direction) override;
        bool setClosePosition() override;
        bool setOpenPosition() override;
 
        // Advanced commands (fully supported by Rev2)
        bool setBeep(bool enable) override;
        bool setBrightnessMode(int mode) override;
 
        // Communication setup
        char getCommandTerminator() const override
        {
            return '#';
        }
        void setupCommunication(int portFD) override
        {
            this->portFD = portFD;
        }
};
 
class GeminiFlatpanelLiteAdapter : public GeminiFlatpanelAdapter
{
    private:
        int portFD;
 
        // Internal helper methods for Lite protocol
 
        bool formatCommand(char commandLetter, char *commandString, int value = NO_VALUE);
 
        bool sendCommand(const char *command, char *response, int timeout = SERIAL_TIMEOUT_SEC, bool log = true);
 
        bool extractIntValue(const char *response, int startPos, int *value);
 
    public:
        GeminiFlatpanelLiteAdapter() : portFD(-1) {}
 
        // Device detection and identification
        bool ping() override;
        int getRevision() const override
        {
            return GEMINI_REVISION_LITE;
        }
        bool getFirmwareVersion(int *version) override;
 
        // Capability checks
        bool supportsBeep() const override
        {
            return true;
        }
        bool supportsDustCap() const override
        {
            return false;    // Lite version is not motorized
        }
        bool supportsBrightnessMode() const override
        {
            return true;
        }
 
        // Basic device commands
        bool getConfigStatus(int *status) override;
        bool getBrightness(int *brightness) override;
        bool setBrightness(int value) override;
        bool lightOn() override;
        bool lightOff() override;
        bool openCover() override;   // Not supported, always returns false
        bool closeCover() override;  // Not supported, always returns false
        bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) override;
 
        // Motion/calibration commands (not supported by Lite)
        bool move(uint16_t value, int direction) override
        {
            (void)value;
            (void)direction;
            return false;
        }
        bool setClosePosition() override
        {
            return false;
        }
        bool setOpenPosition() override
        {
            return false;
        }
 
        // Advanced commands (fully supported by Lite)
        bool setBeep(bool enable) override;
        bool setBrightnessMode(int mode) override;
 
        // Communication setup
        char getCommandTerminator() const override
        {
            return '#';
        }
        void setupCommunication(int portFD) override
        {
            this->portFD = portFD;
        }
};
 
class GeminiFlatpanelProAdapter : public GeminiFlatpanelAdapter
{
    private:
        int portFD;
 
        // Internal helper methods for Pro protocol
 
        bool formatCommand(char commandLetter, char *commandString, int value = NO_VALUE);
 
        bool sendCommand(const char *command, char *response, int timeout = SERIAL_TIMEOUT_SEC, bool log = true);
 
        bool extractIntValue(const char *response, int startPos, int *value);
 
    public:
        GeminiFlatpanelProAdapter() : portFD(-1) {}
 
        // Device detection and identification
        bool ping() override;
        int getRevision() const override
        {
            return GEMINI_REVISION_PRO;
        }
        bool getFirmwareVersion(int *version) override;
 
        // Capability checks
        bool supportsBeep() const override
        {
            return false;
        }
        bool supportsDustCap() const override
        {
            return true; 
        }
        bool supportsBrightnessMode() const override
        {
            return false;
        }
 
        // Basic device commands
        bool getConfigStatus(int *status) override;
        bool getBrightness(int *brightness) override;
        bool setBrightness(int value) override;
        bool lightOn() override;
        bool lightOff() override;
        bool openCover() override;   // Not supported, always returns false
        bool closeCover() override;  // Not supported, always returns false
        bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) override;
 
        // Motion/calibration commands
        bool move(uint16_t value, int direction) override;
        bool setClosePosition() override;
        bool setOpenPosition() override;
 
        // Advanced commands (fully supported by Pro)
        bool setBeep(bool enable) override;
        bool setBrightnessMode(int mode) override;
 
        // Communication setup
        char getCommandTerminator() const override
        {
            return '#';
        }
        void setupCommunication(int portFD) override
        {
            this->portFD = portFD;
        }
};
 
class GeminiFlatpanelSimulationAdapter : public GeminiFlatpanelAdapter
{
    public:
        GeminiFlatpanelSimulationAdapter(bool simulateRev2Features = true);
 
        // Device detection and identification
        bool ping() override;
        int getRevision() const override;
        bool getFirmwareVersion(int *version) override;
 
        // Capability checks
        bool supportsBeep() const override;
        bool supportsDustCap() const override;
        bool supportsBrightnessMode() const override;
 
        // Basic device commands
        bool getConfigStatus(int *status) override;
        bool getBrightness(int *brightness) override;
        bool setBrightness(int value) override;
        bool lightOn() override;
        bool lightOff() override;
        bool openCover() override;
        bool closeCover() override;
        bool getStatus(int *coverStatus, int *lightStatus, int *motorStatus) override;
 
        // Motion/calibration commands
        bool move(uint16_t value, int direction) override;
        bool setClosePosition() override;
        bool setOpenPosition() override;
 
        // Advanced commands
        bool setBeep(bool enable) override;
        bool setBrightnessMode(int mode) override;
 
        // Communication setup
        char getCommandTerminator() const override;
        void setupCommunication(int portFD) override;
 
    private:
        // Simulation state
        enum SimulationIndex
        {
            SIM_MOTOR = 0,
            SIM_LIGHT,
            SIM_COVER,
            SIM_BRIGHTNESS,
            SIM_CONFIG_STATUS,
            SIM_BEEP_ENABLED,
            SIM_BRIGHTNESS_MODE,
            SIM_N
        };
 
        int simulationValues[SIM_N];
        bool simulateRev2Features;
        int simulatedRevision;
        int simulatedFirmwareVersion;
};