tcsInterface.hpp

Go to the documentation of this file.

/** \file tcsInterface.hpp
 * \brief The MagAO-X TCS Interface header file
 *
 * \ingroup tcsInterface_files
 */
 
#ifndef tcsInterface_hpp
#define tcsInterface_hpp
 
#include <atomic>
#include <cmath>
#include <iostream>
 
#include "../../libMagAOX/libMagAOX.hpp" //Note this is included on command line to trigger pch
#include "../../magaox_git_version.h"
 
#include "../../libMagAOX/app/dev/telemeter.hpp"
 
// #define LOG_TCS_STATUS
 
/** \defgroup tcsInterface
 * \brief The MagAO-X application to do interface with the Clay TCS
 *
 * <a href="../handbook/operating/software/apps/tcsInterface.html">Application Documentation</a>
 *
 * \ingroup apps
 *
 */
 
/** \defgroup tcsInterface_files
 * \ingroup tcsInterface
 */
 
namespace MagAOX
{
namespace app
{
 
/// The MagAO-X Clay Telescope TCS Interface
/**
 * \ingroup tcsInterface
 */
class tcsInterface : public MagAOXApp<true>, public dev::ioDevice, public dev::telemeter<tcsInterface>
{
 
    // Give the test harness access.
    friend class tcsInterface_test;
 
    friend class dev::telemeter<tcsInterface>;
 
  protected:
    /** \name lab mode
     * @{
     */
 
    /// Tracks whether the app is operating in lab mode rather than on-sky mode.
    bool m_labMode{ true };
 
    pcf::IndiProperty m_indiP_labMode;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_labMode );
 
    ///@}
 
    /** \name TCS Networking
     *@{
     */
 
    std::string m_deviceAddr{ "localhost" }; ///< The IP address or resolvable name of the TCS.
    int m_devicePort{ 5811 }; ///< The IP port for TCS communications. Should be the command port.  Default is 5811
    int m_seeingInterval{ 2 };
 
    /// Mutex for locking TCS communications.
    std::mutex m_tcsMutex;
 
    tty::netSerial m_sock;
 
    ///@}
 
    // Telescope time:
    double m_telST{ 0 };
 
    pcf::IndiProperty m_indiP_teltime;
 
    // Telescope position:
    double m_telEpoch{ 0 };
    double m_telRA{ 0 };
    double m_telDec{ 0 };
    double m_telEl{ 0 };
    double m_telHA{ 0 };
    double m_telAM{ 0 };
    double m_telRotOff{ 0 };
 
    pcf::IndiProperty m_indiP_telpos;
 
    /// \name Telescope Data
    /**@{
     */
    int    m_telROI{ 0 };          ///< The rotator of interest
    int    m_telTracking{ 0 };     ///< tracking state
    int    m_telGuiding{ 0 };      ///< guider moving state
    int    m_telSlewing{ 0 };      ///< slewing state
    int    m_telGuiderMoving{ 0 }; ///< guider moving state
    double m_telAz{ 0 };           ///< azimuth
    double m_telZd{ 0 };           ///< zenith distance
    double m_telPA{ 0 };           ///< parallactic angle
    double m_telDomeAz{ 0 };       ///< dome azimuth
    int    m_telDomeStat{ 0 };     ///< dome status
 
    pcf::IndiProperty m_indiP_teldata;
    ///@}
 
    /// \name Telescope Catalog Information
    /**@{
     */
    double      m_catRA{ 0 };  ///< Catalog right ascension [degrees]
    double      m_catDec{ 0 }; ///< Catalog declination [degrees]
    double      m_catEp{ 0 };  ///< Catalog epoch
    double      m_catRo{ 0 };  ///< Catalog rotator offset
    std::string m_catRm;       ///< Catalog rotator mode
    std::string m_catObj;      ///< Catalog object name
 
    pcf::IndiProperty m_indiP_catalog; ///< INDI Property for the catalog text information
    pcf::IndiProperty m_indiP_catdata; ///< INDI Property for the catalog data
    ///@}
 
    // Telescope Vane-End positions
    double m_telSecZ{ 0 };
    double m_telEncZ{ 0 };
    double m_telSecX{ 0 };
    double m_telEncX{ 0 };
    double m_telSecY{ 0 };
    double m_telEncY{ 0 };
    double m_telSecH{ 0 };
    double m_telEncH{ 0 };
    double m_telSecV{ 0 };
    double m_telEncV{ 0 };
 
    pcf::IndiProperty m_indiP_vaneend; ///< INDI Property for the vane end positions
 
    // Environment
    double m_wxtemp{ 0 };     ///< Outside temperature, Celsius
    double m_wxpres{ 0 };     ///< Outside pressue, millibars
    double m_wxhumid{ 0 };    ///< Outside humidity, percent
    double m_wxwind{ 0 };     ///< outside wind intensity, mph
    double m_wxwdir{ 0 };     ///< outside wind direction, degrees
    double m_ttruss{ 0 };     ///< Telescope truss temperature, Celsius
    double m_tcell{ 0 };      ///< Primary mirror cell temperature, Celsius
    double m_tseccell{ 0 };   ///< Secondary mirror cell temperature, Celsius
    double m_tambient{ 0 };   ///< Dome air temperature, Celsius
    double m_wxdewpoint{ 0 }; ///< Dew point from weather station
 
    pcf::IndiProperty m_indiP_env; ///< INDI Property for environment
 
    // Seeing
    double m_dimm_el{ 0 };        ///< DIMM elevation at time of seeing measurement
    double m_dimm_fwhm_corr{ 0 }; ///< DIMM elevation corrected FWHM
    int    m_dimm_time{ 0 };      ///< Seconds since midnight of DIMM measurement.
 
    double m_mag1_fwhm_corr{ 0 }; ///< MAG1 elevation corrected FWHM
    int    m_mag1_time{ 0 };      ///< Seconds since midnight of MAG1 measurement.
 
    double m_mag2_fwhm_corr{ 0 }; ///< MAG2 elevation corrected FWHM
    int    m_mag2_time{ 0 };      ///< Seconds since midnight of MAG2 measurement.
 
    pcf::IndiProperty m_indiP_seeing; ///< INDI Property for seeing
 
  public:
    /// Default c'tor.
    tcsInterface();
 
    /// D'tor, declared and defined for noexcept.
    ~tcsInterface() noexcept
    {
    }
 
    virtual void setupConfig();
 
    /// Implementation of loadConfig logic, separated for testing.
    /** This is called by loadConfig().
     */
    int loadConfigImpl(
        mx::app::appConfigurator &_config /**< [in] an application configuration from which to load values*/ );
 
    virtual void loadConfig();
 
    /// Startup function
    /**
     *
     */
    virtual int appStartup();
 
    /// Implementation of the FSM for tcsInterface.
    /**
     * \returns 0 on no critical error
     * \returns -1 on an error requiring shutdown
     */
    virtual int appLogic();
 
    /// Shutdown the app.
    /**
     *
     */
    virtual int appShutdown();
 
    int getMagTelStatus( std::string &response, const std::string &statreq );
 
    int sendMagTelCommand( const std::string &command, int timeout );
 
    int parse_xms( double &x, double &m, double &s, const std::string &xmsstr );
 
    std::vector<std::string> parse_teldata( std::string &tdat );
 
    // The "dump" commands:
 
    int getTelTime();
    int getTelPos();
    int getTelData();
    int getCatData();
    int getVaneData();
    int getEnvData();
 
    /// Record bad seeing measurements on errors in getSeeing().
    int badSeeing();
 
    /// Query, parse, and record seeing measurements
    int getSeeing();
 
    int updateINDI();
 
    /** \name Telemeter Interface
     * @{
     */
    /// Check whether any telemetry records are due.
    int checkRecordTimes();
 
    /// Record telescope-position telemetry on a forced telemeter update.
    int recordTelem( const telem_telpos * );
 
    /// Record telescope-status telemetry on a forced telemeter update.
    int recordTelem( const telem_teldata * );
 
    /// Record vane-position telemetry on a forced telemeter update.
    int recordTelem( const telem_telvane * );
 
    /// Record telescope-environment telemetry on a forced telemeter update.
    int recordTelem( const telem_telenv * );
 
    /// Record catalog telemetry on a forced telemeter update.
    int recordTelem( const telem_telcat * );
 
    /// Record seeing telemetry on a forced telemeter update.
    int recordTelem( const telem_telsee * );
 
    /// Record tip/tilt offload-control telemetry on a forced telemeter update.
    int recordTelem( const telem_tcsi_tiptilt * );
 
    /// Record focus offload-control telemetry on a forced telemeter update.
    int recordTelem( const telem_tcsi_focus * );
 
    /// Record lab-mode telemetry on a forced telemeter update.
    int recordTelem( const telem_tcsi_labmode * );
 
    /// Record telescope-position telemetry when values change.
    int recordTelPos( bool force = false );
 
    /// Record telescope-status telemetry when values change.
    int recordTelData( bool force = false );
 
    /// Record vane-position telemetry when values change.
    int recordTelVane( bool force = false );
 
    /// Record telescope-environment telemetry when values change.
    int recordTelEnv( bool force = false );
 
    /// Record catalog telemetry when values change.
    int recordTelCat( bool force = false );
 
    /// Record seeing telemetry when values change.
    int recordTelSee( bool force = false );
 
    /// Record tip/tilt offload-control telemetry when values change.
    int recordTcsiTipTilt( bool force = false );
 
    /// Record focus offload-control telemetry when values change.
    int recordTcsiFocus( bool force = false );
 
    /// Record lab-mode telemetry when values change.
    int recordTcsiLabMode( bool force = false );
 
    ///@}
 
    /// Tracks the current loop state shared between the INDI callback and the offload thread.
    std::atomic<int>  m_loopState{ 0 };
    pcf::IndiProperty m_indiP_loopState; ///< Property used to report the loop state
 
    INDI_SETCALLBACK_DECL( tcsInterface, m_indiP_loopState );
 
    /** \name Pyramid Nudging and Acquisition
     * Handling of nudges on pyramid tip.
     * @{
     */
 
    // The Pyramid to AEG control matrix
    float m_pyrNudge_C_00{ 1 };
    float m_pyrNudge_C_01{ 0 };
    float m_pyrNudge_C_10{ 0 };
    float m_pyrNudge_C_11{ 1 };
    float m_pyrNudge_F_sign{ 1 };
 
    float m_pyrNudge_ang{ 45.0 };
    float m_pyrNudge_ang0{ 0.0 };
    float m_pyrNudge_parity{ -1 };
 
    int sendPyrNudge( float x, float y, float z );
 
    pcf::IndiProperty m_indiP_pyrNudge; ///< Property used to request a pyramid nudge
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_pyrNudge );
 
    int   m_acqZdSign{ -1 };
    float m_acqAz0{ 18.5 };
    float m_acqAzOff{ 0 };
    float m_acqEl0{ 10 };
    float m_acqElOff{ 0 };
    float m_acqFocus{ 1400 };
 
    int acquireFromGuider();
 
    pcf::IndiProperty m_indiP_acqFromGuider; ///< Property used to request a pyramid nudge
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_acqFromGuider );
 
    ///@}
 
    /** \name Woofer Offloading
     * Handling of offloads from the average woofer shape to the telescope
     * @{
     */
 
    bool m_offloadThreadInit{ true }; ///< Initialization flag for the offload thread.
 
    pid_t m_offloadThreadID{ 0 }; ///< Offload thread pid.
 
    pcf::IndiProperty m_offloadThreadProp; ///< Offload thread INDI property.
 
    std::thread m_offloadThread; ///< The offloading thread.
 
    /// Offload thread starter function
    static void offloadThreadStart( tcsInterface *t /**< [in] pointer to this */ );
 
    /// Offload thread function
    /** Runs until m_shutdown is true.
     */
    void offloadThreadExec();
 
    /// Apply tip/tilt offload controls to an averaged request vector.
    int doTToffload( float TT_0, /**< [in] averaged tip request */
                     float TT_1  /**< [in] averaged tilt request */
    );
 
    /// Send a tip/tilt offload command to the selected target.
    int sendTToffload( float TT_0, /**< [in] tip offload command */
                       float TT_1  /**< [in] tilt offload command */
    );
 
    /// Apply focus offload controls to an averaged request value.
    int doFoffload( float F_0 /**< [in] averaged focus request */
    );
 
    /// Send a focus offload command to the telescope.
    int sendFoffload( float F_0 /**< [in] focus offload command */
    );
 
    pcf::IndiProperty
        m_indiP_offloadCoeffs; ///< Property used to report the latest woofer modal coefficients for offloading
 
    INDI_SETCALLBACK_DECL( tcsInterface, m_indiP_offloadCoeffs );
 
    /// Protects shared offload control parameters accessed by callbacks and the offload thread.
    std::mutex m_offloadCtrlMutex;
 
    /// Protects the offload request ring and its queue-state indices across producer and consumer threads.
    std::mutex m_offloadMutex;
 
    /// Ring buffer of modal offload requests indexed by mode and request slot.
    std::vector<std::vector<float>> m_offloadRequests;
 
    /// Index of the oldest valid request in the offload ring.
    size_t m_firstRequest{ 0 };
 
    /// Index of the newest valid request in the offload ring.
    size_t m_lastRequest{ std::numeric_limits<size_t>::max() };
 
    /// Number of valid requests currently stored in the offload ring.
    size_t m_nRequests{ 0 };
 
    /// Request count last processed by the offload thread.
    size_t m_last_nRequests{ 0 };
 
    // The TT control matrix -- LAb
    float m_lab_offlTT_C_00{ 0.17 };
    float m_lab_offlTT_C_01{ 1.03 };
    float m_lab_offlTT_C_10{ -1.03 };
    float m_lab_offlTT_C_11{ 0.48 };
 
    // The TT control matrix -- Telescope
    float m_offlTT_C_00{ -0.5 };
    float m_offlTT_C_01{ 0 };
    float m_offlTT_C_10{ 0 };
    float m_offlTT_C_11{ -0.25 };
 
    /// Tracks whether tip/tilt offloading is currently enabled.
    bool m_offlTT_enabled{ false };
    bool m_offlTT_dump{ false };
    /// The number of recent requests included in each tip/tilt offload average.
    float m_offlTT_avgInt{ 1.0 };
    /// The operator-set gain applied to tip/tilt offload requests.
    float m_offlTT_gain{ 0.1 };
    /// The deadband threshold applied to tip/tilt offload requests.
    float m_offlTT_thresh{ 0.1 };
 
    pcf::IndiProperty m_indiP_offlTTenable;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlTTenable );
 
    pcf::IndiProperty m_indiP_offlTTdump;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlTTdump );
 
    pcf::IndiProperty m_indiP_offlTTavgInt;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlTTavgInt );
 
    pcf::IndiProperty m_indiP_offlTTgain;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlTTgain );
 
    pcf::IndiProperty m_indiP_offlTTthresh;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlTTthresh );
 
    // The Focus control constant
    float m_offlCFocus_00{ 1 };
 
    /// Tracks whether focus offloading is currently enabled.
    bool m_offlF_enabled{ false };
    bool m_offlF_dump{ false };
    /// The number of recent requests included in each focus offload average.
    float m_offlF_avgInt{ 1.0 };
    /// The operator-set gain applied to focus offload requests.
    float m_offlF_gain{ 0.1 };
    /// The deadband threshold applied to focus offload requests.
    float m_offlF_thresh{ 0.1 };
 
    pcf::IndiProperty m_indiP_offlFenable;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlFenable );
 
    pcf::IndiProperty m_indiP_offlFdump;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlFdump );
 
    pcf::IndiProperty m_indiP_offlFavgInt;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlFavgInt );
 
    pcf::IndiProperty m_indiP_offlFgain;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlFgain );
 
    pcf::IndiProperty m_indiP_offlFthresh;
    INDI_NEWCALLBACK_DECL( tcsInterface, m_indiP_offlFthresh );
 
    float m_offlCComa_00{ 1 };
    float m_offlCComa_01{ 0 };
    float m_offlCComa_10{ 1 };
    float m_offlCComa_11{ 0 };
 
    ///@}
};
 
inline tcsInterface::tcsInterface() : MagAOXApp( MAGAOX_CURRENT_SHA1, MAGAOX_REPO_MODIFIED )
{
    return;
}
 
inline void tcsInterface::setupConfig()
{
    config.add( "labMode",
                "",
                "labMode",
                argType::Required,
                "",
                "labMode",
                false,
                "bool",
                "Flag to enable lab mode.  Default is true." );
 
    config.add( "pyrNudger.C_00",
                "",
                "pyrNudger.C_00",
                argType::Required,
                "pyrNudger",
                "C_00",
                false,
                "float",
                "Pyramid to AEG control matrix [0,0] of a 2x2 matrix" );
    config.add( "pyrNudger.C_01",
                "",
                "pyrNudger.C_01",
                argType::Required,
                "pyrNudger",
                "C_01",
                false,
                "float",
                "Pyramid to AEG control matrix [0,1] of a 2x2 matrix " );
    config.add( "pyrNudger.C_10",
                "",
                "pyrNudger.C_10",
                argType::Required,
                "pyrNudger",
                "C_10",
                false,
                "float",
                "Pyramid to AEG control matrix [1,0] of a 2x2 matrix " );
    config.add( "pyrNudger.C_11",
                "",
                "pyrNudger.C_11",
                argType::Required,
                "pyrNudger",
                "C_11",
                false,
                "float",
                "Pyramid to AEG control matrix [1,1] of a 2x2 matrix " );
 
    config.add( "pyrNudger.ang", "", "pyrNudger.ang", argType::Required, "pyrNudger", "ang", false, "float", "" );
    config.add( "pyrNudger.ang0", "", "pyrNudger.ang0", argType::Required, "pyrNudger0", "ang0", false, "float", "" );
    config.add(
        "pyrNudger.parity", "", "pyrNudger.parity", argType::Required, "pyrNudger", "parity", false, "float", "" );
 
    config.add( "pyrNudger.F_sign",
                "",
                "pyrNudger.F_sign",
                argType::Required,
                "pyrNudger",
                "F_sign",
                false,
                "int",
                "Pyramid to AEG control matrix [1,1] of a 2x2 matrix " );
 
    config.add( "acqFromGuider.zdSign",
                "",
                "acqFromGuider.zdSign",
                argType::Required,
                "acqFromGuider",
                "zdSign",
                false,
                "int",
                "Sign of the Zd to rotation angle, +1 or -1, -1 default" );
    config.add( "acqFromGuider.az0",
                "",
                "acqFromGuider.az0",
                argType::Required,
                "acqFromGuider",
                "az0",
                false,
                "float",
                "az component of acquisition vector a 0 zd." );
    config.add( "acqFromGuider.azoff",
                "",
                "acqFromGuider.azoff",
                argType::Required,
                "acqFromGuider",
                "azoff",
                false,
                "float",
                "static offset to az component of acquisition vector" );
    config.add( "acqFromGuider.el0",
                "",
                "acqFromGuider.el0",
                argType::Required,
                "acqFromGuider",
                "el0",
                false,
                "float",
                "el component of acquisition vector a 0 zd." );
    config.add( "acqFromGuider.eloff",
                "",
                "acqFromGuider.eloff",
                argType::Required,
                "acqFromGuider",
                "eloff",
                false,
                "float",
                "static offset to el component of acquisition vector" );
    config.add( "acqFromGuider.focus",
                "",
                "acqFromGuider.focus",
                argType::Required,
                "acqFromGuider",
                "focus",
                false,
                "float",
                "static offset for focus acquisition" );
 
    config.add( "offload.TT_avgInt",
                "",
                "offload.TT_avgInt",
                argType::Required,
                "offload",
                "TT_avgInt",
                false,
                "float",
                "Woofer to Telescope T/T offload averaging interval [sec] " );
    config.add( "offload.TT_gain",
                "",
                "offload.TT_gain",
                argType::Required,
                "offload",
                "TT_gain",
                false,
                "float",
                "Woofer to Telescope T/T offload gain" );
    config.add( "offload.TT_thresh",
                "",
                "offload.TT_thresh",
                argType::Required,
                "offload",
                "TT_thresh",
                false,
                "float",
                "Woofer to Telescope T/T offload threshold" );
 
    config.add( "offload.lab_TT_C_00",
                "",
                "offload.lab_TT_C_00",
                argType::Required,
                "offload",
                "lab_TT_C_00",
                false,
                "float",
                "Woofer to TTM T/T offload control matrix [0,0] of a 2x2 matrix" );
    config.add( "offload.lab_TT_C_01",
                "",
                "offload.lab_TT_C_01",
                argType::Required,
                "offload",
                "lab_TT_C_01",
                false,
                "float",
                "Woofer to TTM T/T offload control matrix [0,1] of a 2x2 matrix " );
    config.add( "offload.lab_TT_C_10",
                "",
                "offload.lab_TT_C_10",
                argType::Required,
                "offload",
                "lab_TT_C_10",
                false,
                "float",
                "Woofer to TTM T/T offload control matrix [1,0] of a 2x2 matrix " );
    config.add( "offload.lab_TT_C_11",
                "",
                "offload.lab_TT_C_11",
                argType::Required,
                "offload",
                "lab_TT_C_11",
                false,
                "float",
                "Woofer to TTM T/T offload control matrix [1,1] of a 2x2 matrix " );
 
    config.add( "offload.TT_C_00",
                "",
                "offload.TT_C_00",
                argType::Required,
                "offload",
                "TT_C_00",
                false,
                "float",
                "Woofer to Telescope T/T offload control matrix [0,0] of a 2x2 matrix" );
    config.add( "offload.TT_C_01",
                "",
                "offload.TT_C_01",
                argType::Required,
                "offload",
                "TT_C_01",
                false,
                "float",
                "Woofer to Telescope T/T offload control matrix [0,1] of a 2x2 matrix " );
    config.add( "offload.TT_C_10",
                "",
                "offload.TT_C_10",
                argType::Required,
                "offload",
                "TT_C_10",
                false,
                "float",
                "Woofer to Telescope T/T offload control matrix [1,0] of a 2x2 matrix " );
    config.add( "offload.TT_C_11",
                "",
                "offload.TT_C_11",
                argType::Required,
                "offload",
                "TT_C_11",
                false,
                "float",
                "Woofer to Telescope T/T offload control matrix [1,1] of a 2x2 matrix " );
 
    config.add( "offload.F_avgInt",
                "",
                "offload.F_avgInt",
                argType::Required,
                "offload",
                "F_avgInt",
                false,
                "float",
                "Woofer to Telescope Focus offload averaging interval [sec] " );
    config.add( "offload.F_gain",
                "",
                "offload.F_gain",
                argType::Required,
                "offload",
                "F_gain",
                false,
                "float",
                "Woofer to Telescope Focus offload gain" );
    config.add( "offload.F_thresh",
                "",
                "offload.F_thresh",
                argType::Required,
                "offload",
                "F_thresh",
                false,
                "float",
                "Woofer to Telescope Focus offload threshold" );
 
    config.add( "offload.CFocus00",
                "",
                "offload.CFocus00",
                argType::Required,
                "offload",
                "CFocus00",
                false,
                "float",
                "Woofer to Telescope Focus offload control scale factor." );
 
    config.add( "offload.CComa00",
                "",
                "offload.CComa00",
                argType::Required,
                "offload",
                "CComa00",
                false,
                "float",
                "Woofer to Telescope Coma offload control matrix [0,0] of a 2x2 matrix" );
    config.add( "offload.CComa01",
                "",
                "offload.CComa01",
                argType::Required,
                "offload",
                "CComa01",
                false,
                "float",
                "Woofer to Telescope Coma offload control matrix [0,1] of a 2x2 matrix " );
    config.add( "offload.CComa10",
                "",
                "offload.CComa10",
                argType::Required,
                "offload",
                "CComa10",
                false,
                "float",
                "Woofer to Telescope Coma offload control matrix [1,0] of a 2x2 matrix " );
    config.add( "offload.CComa11",
                "",
                "offload.CComa11",
                argType::Required,
                "offload",
                "CComa11",
                false,
                "float",
                "Woofer to Telescope Coma offload control matrix [1,1] of a 2x2 matrix " );
 
    config.add( "device.address",
                "",
                "device.address",
                argType::Required,
                "device",
                "address",
                false,
                "string",
                "The IP address or resolvable name of the TCS." );
    config.add( "device.port",
                "",
                "device.port",
                argType::Required,
                "device",
                "port",
                false,
                "int",
                "The IP port for TCS communications. Should be the command port.  Default is 5811." );
 
    dev::ioDevice::setupConfig( config );
    dev::telemeter<tcsInterface>::setupConfig( config );
}
 
inline int tcsInterface::loadConfigImpl( mx::app::appConfigurator &_config )
{
 
    _config( m_labMode, "labMode" );
 
    _config( m_pyrNudge_C_00, "pyrNudger.C_00" );
    _config( m_pyrNudge_C_01, "pyrNudger.C_01" );
    _config( m_pyrNudge_C_10, "pyrNudger.C_10" );
    _config( m_pyrNudge_C_11, "pyrNudger.C_11" );
 
    _config( m_pyrNudge_ang, "pyrNudger.ang" );
    _config( m_pyrNudge_ang0, "pyrNudger.ang0" );
    _config( m_pyrNudge_parity, "pyrNudger.parity" );
 
    _config( m_acqZdSign, "acqFromGuider.zdSign" );
    _config( m_acqAz0, "acqFromGuider.az0" );
    _config( m_acqAzOff, "acqFromGuider.azoff" );
    _config( m_acqEl0, "acqFromGuider.el0" );
    _config( m_acqElOff, "acqFromGuider.eloff" );
    _config( m_acqFocus, "acqFromGuider.focus" );
 
    _config( m_offlTT_avgInt, "offload.TT_avgInt" );
    _config( m_offlTT_gain, "offload.TT_gain" );
    _config( m_offlTT_thresh, "offload.TT_thresh" );
 
    _config( m_lab_offlTT_C_00, "offload.lab_TT_C_00" );
    _config( m_lab_offlTT_C_01, "offload.lab_TT_C_01" );
    _config( m_lab_offlTT_C_10, "offload.lab_TT_C_10" );
    _config( m_lab_offlTT_C_11, "offload.lab_TT_C_11" );
 
    _config( m_offlTT_C_00, "offload.TT_C_00" );
    _config( m_offlTT_C_01, "offload.TT_C_01" );
    _config( m_offlTT_C_10, "offload.TT_C_10" );
    _config( m_offlTT_C_11, "offload.TT_C_11" );
 
    _config( m_offlF_avgInt, "offload.F_avgInt" );
    _config( m_offlF_gain, "offload.F_gain" );
    _config( m_offlF_thresh, "offload.F_thresh" );
 
    _config( m_offlCFocus_00, "offload.CFocus00" );
 
    _config( m_offlCComa_00, "offload.CComa00" );
    _config( m_offlCComa_01, "offload.CComa01" );
    _config( m_offlCComa_10, "offload.CComa10" );
    _config( m_offlCComa_11, "offload.CComa11" );
 
    _config( m_deviceAddr, "device.address" );
    _config( m_devicePort, "device.port" );
 
    dev::ioDevice::loadConfig( _config );
 
    dev::telemeter<tcsInterface>::loadConfig( _config );
 
    return 0;
}
 
inline void tcsInterface::loadConfig()
{
    loadConfigImpl( config );
}
 
inline int tcsInterface::appStartup()
{
    bool  labMode;
    float offlTTAvgInt;
    float offlTTGain;
    float offlTTThresh;
    float offlFAvgInt;
    float offlFGain;
    float offlFThresh;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        labMode      = m_labMode;
        offlTTAvgInt = m_offlTT_avgInt;
        offlTTGain   = m_offlTT_gain;
        offlTTThresh = m_offlTT_thresh;
        offlFAvgInt  = m_offlF_avgInt;
        offlFGain    = m_offlF_gain;
        offlFThresh  = m_offlF_thresh;
    }
 
    CREATE_REG_INDI_NEW_TOGGLESWITCH( m_indiP_labMode, "labMode" );
    if( labMode )
    {
        m_indiP_labMode["toggle"].setSwitchState( pcf::IndiElement::On );
        log<text_log>( "lab mode ON", logPrio::LOG_NOTICE );
    }
    else
    {
        m_indiP_labMode["toggle"].setSwitchState( pcf::IndiElement::Off );
        log<text_log>( "lab mode OFF", logPrio::LOG_NOTICE );
    }
 
    updateSwitchIfChanged( m_indiP_offlTTenable, "toggle", pcf::IndiElement::On, INDI_OK );
 
    createROIndiNumber( m_indiP_teltime, "teltime", "Telscope Time", "TCS" );
    indi::addNumberElement<double>(
        m_indiP_teltime, "sidereal_time", 0, std::numeric_limits<double>::max(), 0, "%0.6f" );
    m_indiP_teltime["sidereal_time"] = m_telST;
    registerIndiPropertyReadOnly( m_indiP_teltime );
 
    createROIndiNumber( m_indiP_telpos, "telpos", "Telscope Position", "TCS" );
    indi::addNumberElement<double>( m_indiP_telpos, "epoch", 0, std::numeric_limits<double>::max(), 0, "%0.6f" );
    m_indiP_telpos["epoch"] = m_telEpoch;
    indi::addNumberElement<double>( m_indiP_telpos, "ra", 0, 360, 0, "%0.6f" );
    m_indiP_telpos["ra"] = m_telRA;
    indi::addNumberElement<double>( m_indiP_telpos, "dec", -90, 90, 0, "%0.6f" );
    m_indiP_telpos["dec"] = m_telDec;
    indi::addNumberElement<double>( m_indiP_telpos, "el", 0, 90, 0, "%0.6f" );
    m_indiP_telpos["el"] = m_telEl;
    indi::addNumberElement<double>( m_indiP_telpos, "ha", -180, 160, 0, "%0.6f" );
    m_indiP_telpos["ha"] = m_telHA;
    indi::addNumberElement<double>( m_indiP_telpos, "am", 0, 4, 0, "%0.2f" );
    m_indiP_telpos["am"] = m_telAM;
    indi::addNumberElement<double>( m_indiP_telpos, "rotoff", 0, 360, 0, "%0.6f" );
    m_indiP_telpos["rotoff"] = m_telRotOff;
 
    registerIndiPropertyReadOnly( m_indiP_telpos );
 
    createROIndiNumber( m_indiP_teldata, "teldata", "Telscope Data", "TCS" );
    indi::addNumberElement<int>( m_indiP_teldata, "roi", 0, 10, 1, "%d" );
    m_indiP_teldata["roi"] = m_telROI;
    indi::addNumberElement<int>( m_indiP_teldata, "tracking", 0, 1, 1, "%d" );
    m_indiP_teldata["tracking"] = m_telTracking;
    indi::addNumberElement<int>( m_indiP_teldata, "guiding", 0, 1, 1, "%d" );
    m_indiP_teldata["guiding"] = m_telGuiding;
    indi::addNumberElement<int>( m_indiP_teldata, "slewing", 0, 1, 1, "%d" );
    m_indiP_teldata["slewing"] = m_telSlewing;
    indi::addNumberElement<int>( m_indiP_teldata, "guider_moving", 0, 1, 1, "%d" );
    m_indiP_teldata["guider_moving"] = m_telGuiderMoving;
    indi::addNumberElement<double>( m_indiP_teldata, "az", 0, 360, 0, "%0.6f" );
    m_indiP_teldata["az"] = m_telAz;
    indi::addNumberElement<double>( m_indiP_teldata, "zd", 0, 90, 0, "%0.6f" );
    m_indiP_teldata["zd"] = m_telZd;
    indi::addNumberElement<double>( m_indiP_teldata, "pa", 0, 360, 0, "%0.6f" );
    m_indiP_teldata["pa"] = m_telPA;
    indi::addNumberElement<double>( m_indiP_teldata, "dome_az", 0, 360, 0, "%0.6f" );
    m_indiP_teldata["dome_az"] = m_telDomeAz;
    indi::addNumberElement<int>( m_indiP_teldata, "dome_stat", 0, 1, 1, "%d" );
    m_indiP_teldata["dome_stat"] = m_telDomeStat;
 
    registerIndiPropertyReadOnly( m_indiP_teldata );
 
    createROIndiText( m_indiP_catalog, "catalog", "object", "Catalog Entry", "TCS", "Object Name" );
    m_indiP_catalog.add( pcf::IndiElement( "rotmode" ) );
    m_indiP_catalog["rotmode"].setLabel( "Rotator Mode" );
 
    registerIndiPropertyReadOnly( m_indiP_catalog );
 
    createROIndiNumber( m_indiP_catdata, "catdata", "Catalog Entry Data", "TCS" );
    indi::addNumberElement<double>( m_indiP_catdata, "ra", 0, 360, 0, "%0.6f" );
    m_indiP_catdata["ra"] = m_catRA;
    indi::addNumberElement<double>( m_indiP_catdata, "dec", -90, 90, 0, "%0.6f" );
    m_indiP_catdata["dec"] = m_catDec;
    indi::addNumberElement<double>( m_indiP_catdata, "epoch", 0, std::numeric_limits<double>::max(), 0, "%0.6f" );
    m_indiP_catdata["epoch"] = m_catEp;
    indi::addNumberElement<double>( m_indiP_catdata, "rotoff", 0, 360, 0, "%0.6f" );
    m_indiP_catdata["rotoff"] = m_catRo;
 
    registerIndiPropertyReadOnly( m_indiP_catdata );
 
    createROIndiNumber( m_indiP_vaneend, "vaneend", "Vane End Data", "TCS" );
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "secz",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["secz"] = m_telSecZ;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "encz",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["encz"] = m_telEncZ;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "secx",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["secx"] = m_telSecX;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "encx",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["encx"] = m_telEncX;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "secy",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["secy"] = m_telSecY;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "ency",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["ency"] = m_telEncY;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "sech",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["sech"] = m_telSecH;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "ench",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["ench"] = m_telEncH;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "secv",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["secv"] = m_telSecV;
    indi::addNumberElement<double>( m_indiP_vaneend,
                                    "encv",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.6f" );
    m_indiP_vaneend["encv"] = m_telEncV;
 
    registerIndiPropertyReadOnly( m_indiP_vaneend );
 
    createROIndiNumber( m_indiP_env, "environment", "Environment Data", "TCS" );
    indi::addNumberElement<double>( m_indiP_env,
                                    "temp-out",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["temp-out"] = m_wxtemp;
    indi::addNumberElement<double>( m_indiP_env,
                                    "pressure",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["pressure"] = m_wxpres;
    indi::addNumberElement<double>( m_indiP_env,
                                    "humidity",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["humidity"] = m_wxhumid;
    indi::addNumberElement<double>(
        m_indiP_env, "wind", std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max(), 0, "%0.2f" );
    m_indiP_env["wind"] = m_wxwind;
    indi::addNumberElement<double>(
        m_indiP_env, "winddir", std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max(), 0, "%0.2f" );
    m_indiP_env["winddir"] = m_wxwdir;
    indi::addNumberElement<double>( m_indiP_env,
                                    "temp-truss",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["temp-truss"] = m_ttruss;
    indi::addNumberElement<double>( m_indiP_env,
                                    "temp-cell",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["temp-cell"] = m_tcell;
    indi::addNumberElement<double>( m_indiP_env,
                                    "temp-seccell",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["temp-seccell"] = m_tseccell;
    indi::addNumberElement<double>( m_indiP_env,
                                    "temp-amb",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["temp-amb"] = m_tambient;
    indi::addNumberElement<double>( m_indiP_env,
                                    "dewpoint",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_env["dewpoint"] = m_wxdewpoint;
 
    registerIndiPropertyReadOnly( m_indiP_env );
 
    createROIndiNumber( m_indiP_seeing, "seeing", "Seeing Data", "TCS" );
    indi::addNumberElement<unsigned>( m_indiP_seeing,
                                      "dimm_time",
                                      std::numeric_limits<unsigned>::lowest(),
                                      std::numeric_limits<unsigned>::max(),
                                      0,
                                      "%d" );
    m_indiP_seeing["dimm_time"] = m_dimm_time;
    indi::addNumberElement<double>( m_indiP_seeing,
                                    "dimm_fwhm_corr",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_seeing["dimm_fwhm_corr"] = m_dimm_fwhm_corr;
    indi::addNumberElement<unsigned>( m_indiP_seeing,
                                      "mag1_time",
                                      std::numeric_limits<unsigned>::lowest(),
                                      std::numeric_limits<unsigned>::max(),
                                      0,
                                      "%d" );
    m_indiP_seeing["mag1_time"] = m_mag1_time;
    indi::addNumberElement<double>( m_indiP_seeing,
                                    "mag1_fwhm_corr",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_seeing["mag1_fwhm_corr"] = m_mag1_fwhm_corr;
    indi::addNumberElement<unsigned>( m_indiP_seeing,
                                      "mag2_time",
                                      std::numeric_limits<unsigned>::lowest(),
                                      std::numeric_limits<unsigned>::max(),
                                      0,
                                      "%d" );
    m_indiP_seeing["mag2_time"] = m_mag2_time;
    indi::addNumberElement<double>( m_indiP_seeing,
                                    "mag2_fwhm_corr",
                                    std::numeric_limits<double>::lowest(),
                                    std::numeric_limits<double>::max(),
                                    0,
                                    "%0.2f" );
    m_indiP_seeing["mag2_fwhm_corr"] = m_mag2_fwhm_corr;
 
    registerIndiPropertyReadOnly( m_indiP_seeing );
 
    signal( SIGPIPE, SIG_IGN );
 
    if( dev::ioDevice::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( dev::telemeter<tcsInterface>::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    REG_INDI_NEWPROP( m_indiP_pyrNudge, "pyrNudge", pcf::IndiProperty::Number );
    m_indiP_pyrNudge.add( pcf::IndiElement( "y" ) );
    m_indiP_pyrNudge.add( pcf::IndiElement( "x" ) );
    m_indiP_pyrNudge.add( pcf::IndiElement( "z" ) );
 
    createStandardIndiRequestSw( m_indiP_acqFromGuider, "acqFromGuider" );
    if( registerIndiPropertyNew( m_indiP_acqFromGuider, st_newCallBack_m_indiP_acqFromGuider ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiRequestSw( m_indiP_offlTTdump, "offlTT_dump" );
    if( registerIndiPropertyNew( m_indiP_offlTTdump, st_newCallBack_m_indiP_offlTTdump ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiToggleSw( m_indiP_offlTTenable, "offlTT_enable" );
    if( registerIndiPropertyNew( m_indiP_offlTTenable, st_newCallBack_m_indiP_offlTTenable ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlTTavgInt, "offlTT_avgInt", 0, 3600, 1, "%d" );
    m_indiP_offlTTavgInt["current"].set( offlTTAvgInt );
    m_indiP_offlTTavgInt["target"].set( offlTTAvgInt );
    if( registerIndiPropertyNew( m_indiP_offlTTavgInt, st_newCallBack_m_indiP_offlTTavgInt ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlTTgain, "offlTT_gain", 0.0, 1.0, 0.0, "%0.2f" );
    m_indiP_offlTTgain["current"].set( offlTTGain );
    m_indiP_offlTTgain["target"].set( offlTTGain );
    if( registerIndiPropertyNew( m_indiP_offlTTgain, st_newCallBack_m_indiP_offlTTgain ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlTTthresh, "offlTT_thresh", 0.0, 1.0, 0.0, "%0.2f" );
    m_indiP_offlTTthresh["current"].set( offlTTThresh );
    m_indiP_offlTTthresh["target"].set( offlTTThresh );
    if( registerIndiPropertyNew( m_indiP_offlTTthresh, st_newCallBack_m_indiP_offlTTthresh ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiRequestSw( m_indiP_offlFdump, "offlF_dump" );
    if( registerIndiPropertyNew( m_indiP_offlFdump, st_newCallBack_m_indiP_offlFdump ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiToggleSw( m_indiP_offlFenable, "offlF_enable" );
    if( registerIndiPropertyNew( m_indiP_offlFenable, st_newCallBack_m_indiP_offlFenable ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlFavgInt, "offlF_avgInt", 0, 3600, 1, "%d" );
    m_indiP_offlFavgInt["current"].set( offlFAvgInt );
    m_indiP_offlFavgInt["target"].set( offlFAvgInt );
    if( registerIndiPropertyNew( m_indiP_offlFavgInt, st_newCallBack_m_indiP_offlFavgInt ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlFgain, "offlF_gain", 0.0, 1.0, 0.0, "%0.2f" );
    m_indiP_offlFgain["current"].set( offlFGain );
    m_indiP_offlFgain["target"].set( offlFGain );
    if( registerIndiPropertyNew( m_indiP_offlFgain, st_newCallBack_m_indiP_offlFgain ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber( m_indiP_offlFthresh, "offlF_thresh", 0.0, 1.0, 0.0, "%0.2f" );
    m_indiP_offlFthresh["current"].set( offlFThresh );
    m_indiP_offlFthresh["target"].set( offlFThresh );
    if( registerIndiPropertyNew( m_indiP_offlFthresh, st_newCallBack_m_indiP_offlFthresh ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    // Get the loop state for managing offloading
    REG_INDI_SETPROP( m_indiP_loopState, "holoop", "loop_state" );
 
    m_offloadRequests.resize( 5 );
    for( size_t n = 0; n < m_offloadRequests.size(); ++n )
        m_offloadRequests[n].resize( 10, 0 );
 
    if( threadStart( m_offloadThread,
                     m_offloadThreadInit,
                     m_offloadThreadID,
                     m_offloadThreadProp,
                     0,
                     "",
                     "offload",
                     this,
                     offloadThreadStart ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    // Register to receive the coeff updates from Kyle
    REG_INDI_SETPROP( m_indiP_offloadCoeffs, "w2tcsOffloader", "zCoeffs" );
 
    recordTcsiTipTilt( true );
    recordTcsiFocus( true );
    recordTcsiLabMode( true );
 
    state( stateCodes::NOTCONNECTED );
 
    return 0;
}
 
inline int tcsInterface::appLogic()
{
    if( state() == stateCodes::ERROR )
    {
        int rv = m_sock.serialInit( m_deviceAddr.c_str(), m_devicePort );
 
        if( rv != 0 )
        {
            state( stateCodes::NOTCONNECTED );
            log<text_log>( "In state ERROR, connection lost, will retry.", logPrio::LOG_ERROR );
            return 0;
        }
 
        log<text_log>( "In state ERROR, but connected.  Trying to continue.", logPrio::LOG_WARNING );
 
        state( stateCodes::CONNECTED );
    }
 
    if( state() == stateCodes::NOTCONNECTED )
    {
        static int lastrv    = 0; // Used to handle a change in error within the same state.  Make general?
        static int lasterrno = 0;
 
        int rv = m_sock.serialInit( m_deviceAddr.c_str(), m_devicePort );
 
        if( rv == 0 )
        {
            state( stateCodes::CONNECTED );
 
            if( !stateLogged() )
            {
                std::stringstream logs;
                logs << "Connected to " << m_deviceAddr << ":" << m_devicePort;
                log<text_log>( logs.str() );
            }
            lastrv    = rv;
            lasterrno = errno;
        }
        else
        {
            if( !stateLogged() )
            {
                log<text_log>( { "Failed to connect to " + m_deviceAddr + ":" + std::to_string( m_devicePort ) },
                               logPrio::LOG_ERROR );
            }
            if( rv != lastrv )
            {
                log<software_error>( { __FILE__, __LINE__, 0, rv, tty::ttyErrorString( rv ) } );
                lastrv = rv;
            }
            if( errno != lasterrno )
            {
                log<software_error>( { __FILE__, __LINE__, errno } );
                lasterrno = errno;
            }
 
             telemeter<tcsInterface>::appLogic();
 
            return 0;
        }
    }
 
    if( state() == stateCodes::CONNECTED )
    {
        std::string response;
 
        // If any of these are unsuccesful we go around without recording data.
        if( getTelTime() < 0 )
        {
            return 0; // app state will be set based on what the error was
        }
 
        if( getTelPos() < 0 )
        {
            return 0; // app state will be set based on what the error was
        }
 
        if( getTelData() < 0 )
        {
            return 0;
        }
 
        if( getCatData() < 0 )
        {
            return 0;
        }
 
        if( getVaneData() < 0 )
        {
            return 0;
        }
 
        if( getEnvData() < 0 )
        {
            return 0;
        }
 
        if( getSeeing() < 0 )
        {
            return 0;
        }
 
        telemeter<tcsInterface>::appLogic();
 
        if( updateINDI() < 0 )
        {
            log<text_log>( "Error from updateINDI", logPrio::LOG_ERROR );
            return 0;
        }
    }
 
    return 0;
}
 
inline int tcsInterface::appShutdown()
{
    // Wait for offload thread to exit on m_shutdown.
    if( m_offloadThread.joinable() )
    {
        try
        {
            m_offloadThread.join(); // this will throw if it was already joined
        }
        catch( ... )
        {
        }
    }
 
    return 0;
}
 
inline int tcsInterface::getMagTelStatus( std::string &response, const std::string &statreq )
{
 
    int         stat;
    char        answer[512];
    std::string statreq_nl;
 
#ifdef LOG_TCS_STATUS
    log<text_log>( "Sending status request: " + statreq );
#endif
 
    std::lock_guard<std::mutex> guard( m_tcsMutex );
 
    statreq_nl = statreq;
    statreq_nl += '\n';
    stat = m_sock.serialOut( statreq_nl.c_str(), statreq_nl.length() );
 
    if( stat != NETSERIAL_E_NOERROR )
    {
        log<text_log>( "Error sending status request: " + statreq, logPrio::LOG_ERROR );
        response = "";
        return 0;
    }
 
    stat = m_sock.serialInString( answer, 512, m_readTimeout, '\n' );
 
    if( stat <= 0 )
    {
        log<text_log>( "No response received to status request: " + statreq, logPrio::LOG_ERROR );
        response = "";
        return 0;
    }
 
    char *nl = strchr( answer, '\n' );
    if( nl )
        answer[nl - answer] = '\0';
 
#ifdef LOG_TCS_STATUS
    log<text_log>( std::string( "Received response: " ) + answer );
#endif
 
    response = answer;
 
    return 0;
} // int tcsInterface::getMagTelStatus
 
inline int tcsInterface::sendMagTelCommand( const std::string &command, int timeout )
{
    int         stat;
    char        answer[512];
    std::string command_nl;
 
#ifdef LOG_TCS_STATUS
    log<text_log>( "Sending command: " + command );
#endif
 
    std::lock_guard<std::mutex> guard( m_tcsMutex );
 
    command_nl = command;
    command_nl += '\n';
    stat = m_sock.serialOut( command_nl.c_str(), command_nl.length() );
 
    if( stat != NETSERIAL_E_NOERROR )
    {
        log<text_log>( "Error sending command: " + command, logPrio::LOG_ERROR );
        return -1000;
    }
 
    stat = m_sock.serialInString( answer, sizeof( answer ), timeout, '\n' );
 
    if( stat <= 0 )
    {
        log<text_log>( "No response received to command: " + command, logPrio::LOG_ERROR );
        return -1000;
    }
 
    char *nl = strchr( answer, '\n' );
    if( nl )
        answer[nl - answer] = '\0';
 
#ifdef LOG_TCS_STATUS
    log<text_log>( std::string( "Received response: " ) + answer );
#endif
 
    return atoi( answer );
 
} // int tcsInterface::sendMagTelCommand
 
inline std::vector<std::string> tcsInterface::parse_teldata( std::string &tdat )
{
    std::vector<std::string> vres;
 
    std::string tok;
 
    int pos1, pos2;
 
    // skip all leading spaces
    pos1 = tdat.find_first_not_of( " ", 0 );
 
    if( pos1 == -1 )
        pos1 = 0;
 
    pos2 = tdat.find_first_of( " ", pos1 );
 
    while( pos2 > 0 )
    {
        tok = tdat.substr( pos1, pos2 - pos1 );
 
        vres.push_back( tok );
 
        // now move past end of current spaces - might be more than one.
        pos1 = pos2;
 
        pos2 = tdat.find_first_not_of( " ", pos1 );
 
        // and then find the end of this value.
        pos1 = pos2;
 
        pos2 = tdat.find_first_of( " ", pos1 );
    }
 
    // If there is another value, we pick it up here.
    if( pos1 >= 0 )
    {
        pos2 = tdat.length();
 
        tok = tdat.substr( pos1, pos2 - pos1 );
 
        pos2 = tok.find_first_of( " \n\r", 0 );
 
        if( pos2 >= 0 )
            tok.erase( pos2, tok.length() - pos2 );
 
        vres.push_back( tok );
    }
 
    return vres;
}
 
inline int tcsInterface::parse_xms( double &x, double &m, double &s, const std::string &xmsstr )
{
    size_t st, en;
 
    int sgn = 1;
 
    st = 0;
    en = xmsstr.find( ':', st );
 
    // Check not found
    if( en == std::string::npos )
    {
        log<software_error>( { __FILE__, __LINE__, "error parsing x:m:s (missing ':')" } );
        return -1;
    }
 
    // Check 0 length or invalid
    if( en - st < 2 || en < st )
    {
        log<software_error>( { __FILE__, __LINE__, "error parsing x:m:s (0 length or invalid)" } );
        return -1;
    }
 
    std::string xstr;
    try
    {
        xstr = xmsstr.substr( st, en - st );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    try
    {
        x = std::stod( xstr );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    // Check for negative
    if( std::signbit( x ) )
        sgn = -1;
    if( xmsstr[0] == '-' )
        sgn = -1;
 
    st = en + 1;
 
    en = xmsstr.find( ':', st );
 
    // Check not found
    if( en == std::string::npos )
    {
        log<software_error>( { __FILE__, __LINE__, "error parsing x:m:s (missing ':')" } );
        return -1;
    }
 
    // Check 0 length or invalid
    if( en - st < 2 || en < st )
    {
        log<software_error>( { __FILE__, __LINE__, "error parsing x:m:s (0 length or invalid)" } );
        return -1;
    }
 
    std::string mstr;
    try
    {
        mstr = xmsstr.substr( st, en - st );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    try
    {
        m = sgn * std::stod( mstr );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    st = en + 1;
 
    if( st >= xmsstr.length() - 1 )
    {
        log<software_error>( { __FILE__, __LINE__, "error parsing x:m:s" } );
        return -1;
    }
 
    std::string sstr;
    try
    {
        sstr = xmsstr.substr( st, xmsstr.length() - st );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    try
    {
        s = sgn * std::stod( sstr );
    }
    catch( const std::exception &e )
    {
        log<software_error>( { __FILE__, __LINE__, e.what() } );
        return -1;
    }
 
    return 0;
}
 
inline int tcsInterface::getTelTime()
{
    double h, m, s;
 
    std::vector<std::string> pdat;
    std::string              posstr;
 
    if( getMagTelStatus( posstr, "datetime" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope position (telpos)", logPrio::LOG_ERROR );
        return -1;
    }
 
    pdat = parse_teldata( posstr );
 
    if( pdat[0] == "-1" )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope time (datetime): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( pdat.size() != 3 )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope time (datetime): TCS response wrong size, returned " +
                           std::to_string( pdat.size() ) + " values",
                       logPrio::LOG_WARNING );
        return -1;
    }
 
    if( parse_xms( h, m, s, pdat[2] ) != 0 )
    {
        log<text_log>( "Error parsing telescope ST", logPrio::LOG_WARNING );
        return -1;
    }
 
    m_telST = ( h + m / 60. + s / 3600. );
 
    return 0;
} // int tcsInterface::getTelTime()
 
inline int tcsInterface::getTelPos()
{
    double h, m, s;
 
    std::vector<std::string> pdat;
    std::string              posstr;
 
    if( getMagTelStatus( posstr, "telpos" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope position (telpos)", logPrio::LOG_ERROR );
        return -1;
    }
 
    pdat = parse_teldata( posstr );
 
    if( pdat[0] == "-1" )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope position (telpos): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( pdat.size() != 6 )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope position (telpos): TCS response wrong size, returned " +
                           std::to_string( pdat.size() ) + " values",
                       logPrio::LOG_WARNING );
        return -1;
    }
 
    if( parse_xms( h, m, s, pdat[0] ) != 0 )
    {
        log<text_log>( "Error parsing telescope RA", logPrio::LOG_WARNING );
        return -1;
    }
 
    m_telRA = ( h + m / 60. + s / 3600. ) * 15.;
 
    if( parse_xms( h, m, s, pdat[1] ) != 0 )
    {
        log<text_log>( "Error parsing telescope Dec", logPrio::LOG_WARNING );
        return -1;
    }
 
    m_telDec = h + m / 60. + s / 3600.;
 
    // m_telEl = strtod(pdat[1].c_str(),0);// * 3600.;
 
    m_telEpoch = strtod( pdat[2].c_str(), 0 );
 
    if( parse_xms( h, m, s, pdat[3] ) != 0 )
    {
        log<text_log>( "Error parsing telescope HA", logPrio::LOG_WARNING );
        return -1;
    }
 
    /************ BUG: this won't handle -0!
     */
    m_telHA = h + m / 60. + s / 3600.;
 
    m_telAM = strtod( pdat[4].c_str(), 0 );
 
    m_telRotOff = strtod( pdat[5].c_str(), 0 );
 
    if( recordTelPos() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    return 0;
} // int tcsInterface::getTelPos()
 
inline int tcsInterface::getTelData()
{
    std::string              xstr;
    std::vector<std::string> tdat;
 
    if( getMagTelStatus( xstr, "teldata" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope data (teldata)", logPrio::LOG_ERROR );
        return -1;
    }
 
    tdat = parse_teldata( xstr );
 
    if( tdat[0] == "-1" )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope data (teldata): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( tdat.size() != 10 )
    {
        state( stateCodes::ERROR );
        log<text_log>( "[TCS] Error getting telescope data (teldata): TCS response wrong size, returned " +
                           std::to_string( tdat.size() ) + " values",
                       logPrio::LOG_WARNING );
        return -1;
    }
 
    m_telROI = atoi( tdat[0].c_str() );
 
    // Parse the telguide string
    char bit[2]   = { 0, 0 };
    bit[1]        = 0;
    bit[0]        = tdat[1].c_str()[0];
    m_telTracking = atoi( bit );
    bit[0]        = tdat[1].c_str()[1];
    m_telGuiding  = atoi( bit );
 
    // parse the gdrmountmv string
    bit[0]            = tdat[2].c_str()[0];
    m_telSlewing      = atoi( bit );
    bit[0]            = tdat[2].c_str()[1];
    m_telGuiderMoving = atoi( bit );
 
    // number 3 is mountmv
 
    m_telAz = strtod( tdat[4].c_str(), 0 );
 
    m_telEl = strtod( tdat[5].c_str(), 0 );
 
    m_telZd = strtod( tdat[6].c_str(), 0 ); // * 3600.;
 
    m_telPA = strtod( tdat[7].c_str(), 0 );
 
    m_telDomeAz = strtod( tdat[8].c_str(), 0 );
 
    m_telDomeStat = atoi( tdat[9].c_str() );
 
    if( recordTelData() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    return 0;
} // int tcsInterface::getTelData()
 
inline int tcsInterface::getCatData()
{
    double h, m, s;
 
    std::vector<std::string> cdat;
    std::string              cstr;
 
    if( getMagTelStatus( cstr, "catdata" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting catalog data (catdata)", logPrio::LOG_ERROR );
        return -1;
    }
 
    cdat = parse_teldata( cstr );
 
    if( cdat[0] == "-1" )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting catalog data (catdata): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( cdat.size() != 6 )
    {
        bool pointing = false;
 
        if( cdat.size() == 7 )
        {
            if( cdat[6] == "Pointing" )
            {
                pointing = true;
            }
        }
 
        if( !pointing )
        {
            // This can occur if no target selected by operator
            log<text_log>( "Catalog data (catdata): TCS response wrong size, returned " +
                               std::to_string( cdat.size() ) + " values",
                           logPrio::LOG_WARNING );
 
            for( size_t n = 0; n < cdat.size(); ++n )
            {
                std::cerr << n << " " << cdat[n] << "\n";
            }
            m_catRA = 0;
 
            m_catDec = 0;
 
            m_catEp = 0;
 
            m_catRo = 0;
 
            m_catRm = "";
 
            m_catObj = "none";
 
            return 1;
        }
    }
 
    if( parse_xms( h, m, s, cdat[0] ) != 0 )
    {
        log<text_log>( "Error parsing catalog RA", logPrio::LOG_WARNING );
        return -1;
    }
 
    m_catRA = ( h + m / 60. + s / 3600. ) * 15.;
 
    if( parse_xms( h, m, s, cdat[1] ) != 0 )
    {
        log<text_log>( "Error parsing catalog Dec", logPrio::LOG_WARNING );
        return -1;
    }
 
    m_catDec = h + m / 60. + s / 3600.;
 
    m_catEp = strtod( cdat[2].c_str(), 0 );
 
    m_catRo = strtod( cdat[3].c_str(), 0 );
 
    m_catRm = cdat[4];
 
    m_catObj = cdat[5];
 
    return 0;
} // int tcsInterface::getCatData()
 
inline int tcsInterface::getVaneData()
{
    std::string              xstr;
    std::vector<std::string> vedat;
 
    if( getMagTelStatus( xstr, "vedata" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope secondary positions (vedata)", logPrio::LOG_ERROR );
        return -1;
    }
 
    vedat = parse_teldata( xstr );
 
    if( vedat[0] == "-1" )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope secondary positions (vedata): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( vedat.size() != 10 )
    {
        state( stateCodes::ERROR );
        log<text_log>( "Error getting telescope secondary positions (vedata): TCS response wrong size, returned " +
                           std::to_string( vedat.size() ) + " values",
                       logPrio::LOG_WARNING );
        return -1;
    }
 
    m_telSecZ = strtod( vedat[0].c_str(), 0 );
    m_telEncZ = strtod( vedat[1].c_str(), 0 );
    m_telSecX = strtod( vedat[2].c_str(), 0 );
    m_telEncX = strtod( vedat[3].c_str(), 0 );
    m_telSecY = strtod( vedat[4].c_str(), 0 );
    m_telEncY = strtod( vedat[5].c_str(), 0 );
    m_telSecH = strtod( vedat[6].c_str(), 0 );
    m_telEncH = strtod( vedat[7].c_str(), 0 );
    m_telSecV = strtod( vedat[8].c_str(), 0 );
    m_telEncV = strtod( vedat[9].c_str(), 0 );
 
    if( recordTelVane() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    return 0;
} // int tcsInterface::getVaneData()
 
inline int tcsInterface::getEnvData()
{
    std::string              estr;
    std::vector<std::string> edat;
 
    if( getMagTelStatus( estr, "telenv" ) < 0 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope environment data (telenv)", logPrio::LOG_ERROR );
        return -1;
    }
 
    edat = parse_teldata( estr );
 
    if( edat[0] == "-1" )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope environment data (telenv): TCS returned -1", logPrio::LOG_WARNING );
        return -1;
    }
 
    if( edat.size() != 10 )
    {
        state( stateCodes::NOTCONNECTED );
        log<text_log>( "Error getting telescope environment data (telenv): TCS response wrong size, returned " +
                           std::to_string( edat.size() ) + "values",
                       logPrio::LOG_WARNING );
        return -1;
    }
 
    m_wxtemp     = strtod( edat[0].c_str(), 0 );
    m_wxpres     = strtod( edat[1].c_str(), 0 );
    m_wxhumid    = strtod( edat[2].c_str(), 0 );
    m_wxwind     = strtod( edat[3].c_str(), 0 );
    m_wxwdir     = strtod( edat[4].c_str(), 0 );
    m_ttruss     = strtod( edat[5].c_str(), 0 );
    m_tcell      = strtod( edat[6].c_str(), 0 );
    m_tseccell   = strtod( edat[7].c_str(), 0 );
    m_tambient   = strtod( edat[8].c_str(), 0 );
    m_wxdewpoint = strtod( edat[9].c_str(), 0 );
 
    if( recordTelEnv() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    return 0;
} // int tcsInterface::getEnvData()
 
int tcsInterface::badSeeing()
{
    m_dimm_time      = 0;
    m_dimm_fwhm_corr = -1;
    m_mag1_time      = 0;
    m_mag1_fwhm_corr = -1;
    m_mag2_time      = 0;
    m_mag2_fwhm_corr = -1;
 
    if( recordTelSee() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    return 0;
}
 
int tcsInterface::getSeeing()
{
    static int last_query = 0;
 
    if( time( 0 ) - last_query > m_seeingInterval )
    {
        time_t sec_midnight;
        time_t dt;
 
        int rv = system( "query_seeing > /dev/null" );
        if( rv < 0 )
        {
            if( badSeeing() < 0 )
            {
                log<software_error>( { __FILE__, __LINE__ } );
            }
 
            if( !m_labMode )
            {
                log<software_error>( { __FILE__, __LINE__, "Error from seeing query" } );
                return -1;
            }
 
            return 0;
        }
 
        last_query   = time( 0 );
        sec_midnight = last_query % 86400;
 
        std::ifstream fin;
        std::string   label, datestr, timestr, scopestr, fwhmcorrstr;
        double        h, m, s;
        // note: query seeing picks a temp file with the username included
        // to reduce file clobbering conflicts
        fin.open( "/tmp/xsup_query_seeing.txt" );
 
        if( fin.fail() )
        {
            if( badSeeing() < 0 )
            {
                log<software_error>( { __FILE__, __LINE__ } );
            }
 
            if( !m_labMode )
            {
                log<software_error>( { __FILE__, __LINE__, "Error reading dimm seeing" } );
                return -1;
            }
        }
 
        fin >> label;
        fin >> label;
        fin >> label;
        fin >> label;
 
        fin >> datestr;
        fin >> timestr;
        fin >> scopestr;
        fin >> m_dimm_fwhm_corr;
 
        // Handle no values from query
        if( !fin )
        {
            if( badSeeing() < 0 )
            {
                log<software_error>( { __FILE__, __LINE__ } );
            }
 
            if( !m_labMode )
            {
                log<software_error>( { __FILE__, __LINE__, "query_seeing returned not enough values" } );
                return -1;
            }
            else
            {
                return 0;
            }
        }
 
        if( scopestr != "dimm" )
        {
            log<software_error>(
                { __FILE__, __LINE__, "Unexpected order of telescope names.  Instead of dimm got: " + scopestr } );
        }
 
        parse_xms( h, m, s, timestr );
 
        m_dimm_time = (int)( h * 3600 + m * 60 + s + 0.5 );
 
        dt = sec_midnight - m_dimm_time;
        if( dt < 0 )
            dt = 86400 - dt;
 
        if( dt > 300 || m_dimm_fwhm_corr <= 0 )
        {
            m_dimm_fwhm_corr = -1;
        }
 
        // Next scope: mag1/baade
        fin >> datestr;
        fin >> timestr;
        fin >> scopestr;
        fin >> m_mag1_fwhm_corr;
 
        // Handle no values from query
        if( !fin )
        {
            if( badSeeing() < 0 )
            {
                log<software_error>( { __FILE__, __LINE__ } );
            }
 
            if( !m_labMode )
            {
                log<software_error>( { __FILE__, __LINE__, "query_seeing returned not enough values" } );
                return -1;
            }
            else
            {
                return 0;
            }
        }
 
        if( scopestr != "baade" )
        {
            log<software_error>(
                { __FILE__, __LINE__, "Unexpected order of telescope names.  Instead of baade got: " + scopestr } );
        }
 
        parse_xms( h, m, s, timestr );
 
        m_mag1_time = (int)( h * 3600 + m * 60 + s + 0.5 );
 
        dt = sec_midnight - m_mag1_time;
        if( dt < 0 )
            dt = 86400 - dt;
 
        if( dt > 300 || m_mag1_fwhm_corr <= 0 )
        {
            m_mag1_fwhm_corr = -1;
        }
 
        // Last scope: mag2/clay
        fin >> datestr;
        fin >> timestr;
        fin >> scopestr;
        fin >> m_mag2_fwhm_corr;
 
        // Handle no values from query
        if( !fin )
        {
            if( badSeeing() < 0 )
            {
                log<software_error>( { __FILE__, __LINE__ } );
            }
 
            if( !m_labMode )
            {
                log<software_error>( { __FILE__, __LINE__, "query_seeing returned not enough values" } );
                return -1;
            }
            else
            {
                return 0;
            }
        }
 
        if( scopestr != "clay" )
        {
            log<software_error>(
                { __FILE__, __LINE__, "Unexpected order of telescope names.  Instead of clay got: " + scopestr } );
        }
 
        fin.close();
 
        parse_xms( h, m, s, timestr );
 
        m_mag2_time = (int)( h * 3600 + m * 60 + s + 0.5 );
 
        dt = sec_midnight - m_mag2_time;
        if( dt < 0 )
            dt = 86400 - dt;
 
        if( dt > 300 || m_mag2_fwhm_corr <= 0 )
        {
            m_mag2_fwhm_corr = -1;
        }
 
        if( recordTelSee() < 0 )
        {
            return log<software_error, -1>( { __FILE__, __LINE__ } );
        }
    }
 
    return 0;
}
 
inline int tcsInterface::updateINDI()
{
    try
    {
        updateIfChanged( m_indiP_teltime, "sidereal_time", m_telST, INDI_OK );
        //      m_indiP_teltime["sidereal_time"] = m_telST;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    /* try
     {
        m_indiP_teltime.setState(INDI_OK);
     }
     catch(...)
     {
        log<software_error>({__FILE__,__LINE__,"INDI library exception"});
        return -1;
     }
 
     try
     {
        m_indiDriver->sendSetProperty(m_indiP_teltime);
     }
     catch(...)
     {
        log<software_error>({__FILE__,__LINE__,"INDI library exception"});
        return -1;
     }*/
 
    try
    {
        indi::updateIfChanged(
            m_indiP_telpos,
            std::vector<std::string>( { "epoch", "ra", "dec", "el", "ha", "am", "rotoff" } ),
            std::vector<double>( { m_telEpoch, m_telRA, m_telDec, m_telEl, m_telHA, m_telAM, m_telRotOff } ),
            m_indiDriver,
            INDI_OK );
        /*m_indiP_telpos["epoch"] = m_telEpoch;
        m_indiP_telpos["ra"] = m_telRA;
        m_indiP_telpos["dec"] = m_telDec;
        m_indiP_telpos["el"] = m_telEl;
        m_indiP_telpos["ha"] = m_telHA;
        m_indiP_telpos["am"] = m_telAM;
        m_indiP_telpos["rotoff"] = m_telRotOff;*/
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    /*try
    {
       m_indiP_telpos.setState(INDI_OK);
    }
    catch(...)
    {
       log<software_error>({__FILE__,__LINE__,"INDI library exception"});
       return -1;
    }
 
    try
    {
       m_indiDriver->sendSetProperty (m_indiP_telpos);
    }
    catch(...)
    {
       log<software_error>({__FILE__,__LINE__,"INDI library exception"});
       return -1;
    }*/
 
    try
    {
        m_indiP_teldata["roi"]           = m_telROI;
        m_indiP_teldata["tracking"]      = m_telTracking;
        m_indiP_teldata["guiding"]       = m_telGuiding;
        m_indiP_teldata["slewing"]       = m_telSlewing;
        m_indiP_teldata["guider_moving"] = m_telGuiderMoving;
        m_indiP_teldata["az"]            = m_telAz;
        m_indiP_teldata["zd"]            = m_telZd;
        m_indiP_teldata["pa"]            = m_telPA;
        m_indiP_teldata["dome_az"]       = m_telDomeAz;
        m_indiP_teldata["dome_stat"]     = m_telDomeStat;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiP_teldata.setState( INDI_OK );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiDriver->sendSetProperty( m_indiP_teldata );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        indi::updateIfChanged( m_indiP_catalog,
                               std::vector<std::string>( { "object", "rotmode" } ),
                               std::vector<std::string>( { m_catObj, m_catRm } ),
                               m_indiDriver,
                               INDI_OK );
        // m_indiP_catalog["object"] = m_catObj;
        // m_indiP_catalog["rotmode"] = m_catRo;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    /*   try
       {
          m_indiP_catalog.setState(INDI_OK);
       }
       catch(...)
       {
          log<software_error>({__FILE__,__LINE__,"INDI library exception"});
          return -1;
       }
 
       try
       {
          m_indiDriver->sendSetProperty (m_indiP_catalog);
       }
       catch(...)
       {
          log<software_error>({__FILE__,__LINE__,"INDI library exception"});
          return -1;
       }*/
 
    try
    {
        indi::updateIfChanged( m_indiP_catdata,
                               std::vector<std::string>( { "ra", "dec", "epoch", "rotoff" } ),
                               std::vector<double>( { m_catRA, m_catDec, m_catEp, m_catRo } ),
                               m_indiDriver,
                               INDI_OK );
        /*m_indiP_catdata["ra"] = m_catRA;
        m_indiP_catdata["dec"] = m_catDec;
        m_indiP_catdata["epoch"] = m_catEp;
        m_indiP_catdata["rotoff"] = m_catRo;*/
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    /*   try
       {
          m_indiP_catdata.setState(INDI_OK);
       }
       catch(...)
       {
          log<software_error>({__FILE__,__LINE__,"INDI library exception"});
          return -1;
       }
 
       try
       {
          m_indiDriver->sendSetProperty (m_indiP_catdata);
       }
       catch(...)
       {
          log<software_error>({__FILE__,__LINE__,"INDI library exception"});
          return -1;
       }*/
 
    //---- Vane End ----//
    try
    {
        m_indiP_vaneend["secz"] = m_telSecZ;
        m_indiP_vaneend["encz"] = m_telEncZ;
        m_indiP_vaneend["secx"] = m_telSecX;
        m_indiP_vaneend["encx"] = m_telEncX;
        m_indiP_vaneend["secy"] = m_telSecY;
        m_indiP_vaneend["ency"] = m_telEncY;
        m_indiP_vaneend["sech"] = m_telSecH;
        m_indiP_vaneend["ench"] = m_telEncH;
        m_indiP_vaneend["secv"] = m_telSecV;
        m_indiP_vaneend["encv"] = m_telEncV;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiP_vaneend.setState( INDI_OK );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiDriver->sendSetProperty( m_indiP_vaneend );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    //---- Environment ----//
    try
    {
        m_indiP_env["temp-out"]     = m_wxtemp;
        m_indiP_env["pressure"]     = m_wxpres;
        m_indiP_env["humidity"]     = m_wxhumid;
        m_indiP_env["wind"]         = m_wxwind;
        m_indiP_env["winddir"]      = m_wxwdir;
        m_indiP_env["temp-truss"]   = m_ttruss;
        m_indiP_env["temp-cell"]    = m_tcell;
        m_indiP_env["temp-seccell"] = m_tseccell;
        m_indiP_env["temp-amb"]     = m_tambient;
        m_indiP_env["dewpoint"]     = m_wxdewpoint;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiP_env.setState( INDI_OK );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiDriver->sendSetProperty( m_indiP_env );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    //---- Seeing ----//
    try
    {
        m_indiP_seeing["dimm_time"]      = m_dimm_time;
        m_indiP_seeing["dimm_fwhm_corr"] = m_dimm_fwhm_corr;
 
        m_indiP_seeing["mag1_time"]      = m_mag1_time;
        m_indiP_seeing["mag1_fwhm_corr"] = m_mag1_fwhm_corr;
 
        m_indiP_seeing["mag2_time"]      = m_mag2_time;
        m_indiP_seeing["mag2_fwhm_corr"] = m_mag2_fwhm_corr;
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiP_seeing.setState( INDI_OK );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        m_indiDriver->sendSetProperty( m_indiP_seeing );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    //--- Offloading ---//
 
    bool  offlTTDump;
    bool  offlTTEnabled;
    float offlTTAvgInt;
    float offlTTGain;
    float offlTTThresh;
    bool  offlFDump;
    bool  offlFEnabled;
    float offlFAvgInt;
    float offlFGain;
    float offlFThresh;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        offlTTDump    = m_offlTT_dump;
        offlTTEnabled = m_offlTT_enabled;
        offlTTAvgInt  = m_offlTT_avgInt;
        offlTTGain    = m_offlTT_gain;
        offlTTThresh  = m_offlTT_thresh;
        offlFDump     = m_offlF_dump;
        offlFEnabled  = m_offlF_enabled;
        offlFAvgInt   = m_offlF_avgInt;
        offlFGain     = m_offlF_gain;
        offlFThresh   = m_offlF_thresh;
    }
 
    try
    {
        if( offlTTDump )
        {
            updateSwitchIfChanged( m_indiP_offlTTdump, "request", pcf::IndiElement::On, INDI_OK );
        }
        else
        {
            updateSwitchIfChanged( m_indiP_offlTTdump, "request", pcf::IndiElement::Off, INDI_IDLE );
        }
 
        if( offlTTEnabled )
        {
            updateSwitchIfChanged( m_indiP_offlTTenable, "toggle", pcf::IndiElement::On, INDI_OK );
        }
        else
        {
            updateSwitchIfChanged( m_indiP_offlTTenable, "toggle", pcf::IndiElement::Off, INDI_IDLE );
        }
 
        updateIfChanged( m_indiP_offlTTavgInt, "current", offlTTAvgInt );
        updateIfChanged( m_indiP_offlTTgain, "current", offlTTGain );
        updateIfChanged( m_indiP_offlTTthresh, "current", offlTTThresh );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    try
    {
        if( offlFDump )
        {
            updateSwitchIfChanged( m_indiP_offlFdump, "request", pcf::IndiElement::On, INDI_OK );
        }
        else
        {
            updateSwitchIfChanged( m_indiP_offlFdump, "request", pcf::IndiElement::Off, INDI_IDLE );
        }
 
        if( offlFEnabled )
        {
            updateSwitchIfChanged( m_indiP_offlFenable, "toggle", pcf::IndiElement::On, INDI_OK );
        }
        else
        {
            updateSwitchIfChanged( m_indiP_offlFenable, "toggle", pcf::IndiElement::Off, INDI_IDLE );
        }
 
        updateIfChanged( m_indiP_offlFavgInt, "current", offlFAvgInt );
        updateIfChanged( m_indiP_offlFgain, "current", offlFGain );
        updateIfChanged( m_indiP_offlFthresh, "current", offlFThresh );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "INDI library exception" } );
        return -1;
    }
 
    return 0;
}
 
inline int tcsInterface::checkRecordTimes()
{
    return telemeter<tcsInterface>::checkRecordTimes( telem_telpos(),
                                                      telem_teldata(),
                                                      telem_telvane(),
                                                      telem_telenv(),
                                                      telem_telcat(),
                                                      telem_telsee(),
                                                      telem_tcsi_tiptilt(),
                                                      telem_tcsi_focus(),
                                                      telem_tcsi_labmode() );
}
 
inline int tcsInterface::recordTelem( const telem_telpos * )
{
    recordTelPos( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_teldata * )
{
    recordTelData( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_telvane * )
{
    recordTelVane( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_telenv * )
{
    recordTelEnv( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_telcat * )
{
    recordTelCat( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_telsee * )
{
    recordTelSee( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_tcsi_tiptilt * )
{
    recordTcsiTipTilt( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_tcsi_focus * )
{
    recordTcsiFocus( true );
    return 0;
}
 
inline int tcsInterface::recordTelem( const telem_tcsi_labmode * )
{
    recordTcsiLabMode( true );
    return 0;
}
 
inline int tcsInterface::recordTelPos( bool force )
{
    static double lastEpoch  = 0;
    static double lastRA     = 0;
    static double lastDec    = 0;
    static double lastEl     = 0;
    static double lastHA     = 0;
    static double lastAM     = 0;
    static double lastRotOff = 0;
 
    if( force || lastEpoch != m_telEpoch || lastRA != m_telRA || lastDec != m_telDec || lastEl != m_telEl ||
        lastHA != m_telHA || lastAM != m_telAM || lastRotOff != m_telRotOff )
    {
        telem<telem_telpos>( { m_telEpoch, m_telRA, m_telDec, m_telEl, m_telHA, m_telAM, m_telRotOff } );
 
        lastEpoch  = m_telEpoch;
        lastRA     = m_telRA;
        lastDec    = m_telDec;
        lastEl     = m_telEl;
        lastHA     = m_telHA;
        lastAM     = m_telAM;
        lastRotOff = m_telRotOff;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTelData( bool force )
{
    static int    lastROI          = -999;
    static int    lastTracking     = -999;
    static int    lastGuiding      = -999;
    static int    lastSlewing      = -999;
    static int    lastGuiderMoving = -999;
    static double lastAz           = 0;
    static double lastZd           = 0;
    static double lastPA           = 0;
    static double lastDomeAz       = 0;
    static int    lastDomeStat     = -999;
 
    if( force || lastROI != m_telROI || lastTracking != m_telTracking || lastGuiding != m_telGuiding ||
        lastSlewing != m_telSlewing || lastGuiderMoving != m_telGuiderMoving || lastAz != m_telAz ||
        lastZd != m_telZd || lastPA != m_telPA || lastDomeAz != m_telDomeAz || lastDomeStat != m_telDomeStat )
    {
        telem<telem_teldata>( { m_telROI,
                                m_telTracking,
                                m_telGuiding,
                                m_telSlewing,
                                m_telGuiderMoving,
                                m_telAz,
                                m_telZd,
                                m_telPA,
                                m_telDomeAz,
                                m_telDomeStat } );
 
        lastROI          = m_telROI;
        lastTracking     = m_telTracking;
        lastGuiding      = m_telGuiding;
        lastSlewing      = m_telSlewing;
        lastGuiderMoving = m_telGuiderMoving;
        lastAz           = m_telAz;
        lastZd           = m_telZd;
        lastPA           = m_telPA;
        lastDomeAz       = m_telDomeAz;
        lastDomeStat     = m_telDomeStat;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTelVane( bool force )
{
    static double lastSecZ = -999;
    static double lastEncZ = -999;
    static double lastSecX = -999;
    static double lastEncX = -999;
    static double lastSecY = -999;
    static double lastEncY = -999;
    static double lastSecH = -999;
    static double lastEncH = -999;
    static double lastSecV = -999;
    static double lastEncV = -999;
 
    if( force || lastSecZ != m_telSecZ || lastEncZ != m_telEncZ || lastSecX != m_telSecX || lastEncX != m_telEncX ||
        lastSecY != m_telSecY || lastEncY != m_telEncY || lastSecH != m_telSecH || lastEncH != m_telEncH ||
        lastSecV != m_telSecV || lastEncV != m_telEncV )
    {
        telem<telem_telvane>( { m_telSecZ,
                                m_telEncZ,
                                m_telSecX,
                                m_telEncX,
                                m_telSecY,
                                m_telEncY,
                                m_telSecH,
                                m_telEncH,
                                m_telSecV,
                                m_telEncV } );
 
        lastSecZ = m_telSecZ;
        lastEncZ = m_telEncZ;
        lastSecX = m_telSecX;
        lastEncX = m_telEncX;
        lastSecY = m_telSecY;
        lastEncY = m_telEncY;
        lastSecH = m_telSecH;
        lastEncH = m_telEncH;
        lastSecV = m_telSecV;
        lastEncV = m_telEncV;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTelEnv( bool force )
{
    static double lastWxtemp     = -999;
    static double lastWxpres     = -999;
    static double lastWxhumid    = -999;
    static double lastWxwind     = -999;
    static double lastWxwdir     = -999;
    static double lastTtruss     = -999;
    static double lastTcell      = -999;
    static double lastTseccell   = -999;
    static double lastTambient   = -999;
    static double lastWxdewpoint = -999;
 
    if( force || lastWxtemp != m_wxtemp || lastWxpres != m_wxpres || lastWxhumid != m_wxhumid ||
        lastWxwind != m_wxwind || lastWxwdir != m_wxwdir || lastTtruss != m_ttruss || lastTcell != m_tcell ||
        lastTseccell != m_tseccell || lastTambient != m_tambient || lastWxdewpoint != m_wxdewpoint )
    {
        telem<telem_telenv>( { m_wxtemp,
                               m_wxpres,
                               m_wxhumid,
                               m_wxwind,
                               m_wxwdir,
                               m_ttruss,
                               m_tcell,
                               m_tseccell,
                               m_tambient,
                               m_wxdewpoint } );
 
        lastWxtemp     = m_wxtemp;
        lastWxpres     = m_wxpres;
        lastWxhumid    = m_wxhumid;
        lastWxwind     = m_wxwind;
        lastWxwdir     = m_wxwdir;
        lastTtruss     = m_ttruss;
        lastTcell      = m_tcell;
        lastTseccell   = m_tseccell;
        lastTambient   = m_tambient;
        lastWxdewpoint = m_wxdewpoint;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTelCat( bool force )
{
    static std::string last_catObj;
    static std::string last_catRm;
    static double      last_catRA  = 0;
    static double      last_catDec = 0;
    static double      last_catEp  = 0;
    static double      last_catRo  = 0;
 
    if( force || m_catObj != last_catObj || m_catRm != last_catRm || m_catRA != last_catRA || m_catDec != last_catDec ||
        m_catEp != last_catEp || m_catRo != last_catRo )
    {
        telem<telem_telcat>( { m_catObj, m_catRm, m_catRA, m_catDec, m_catEp, m_catRo } );
 
        last_catObj = m_catObj;
        last_catRm  = m_catRm;
        last_catRA  = m_catRA;
        last_catDec = m_catDec;
        last_catEp  = m_catEp;
        last_catRo  = m_catRo;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTelSee( bool force )
{
    static int    last_dimm_time      = 0;
    static double last_dimm_fwhm_corr = 0;
 
    static int    last_mag1_time      = 0;
    static double last_mag1_fwhm_corr = 0;
 
    static int    last_mag2_time      = 0;
    static double last_mag2_fwhm_corr = 0;
 
    if( force || m_dimm_time != last_dimm_time || m_dimm_fwhm_corr != last_dimm_fwhm_corr ||
        m_mag1_time != last_mag1_time || m_mag1_fwhm_corr != last_mag1_fwhm_corr || m_mag2_time != last_mag2_time ||
        m_mag2_fwhm_corr != last_mag2_fwhm_corr )
 
    {
        telem<telem_telsee>(
            { m_dimm_time, m_dimm_fwhm_corr, m_mag1_time, m_mag1_fwhm_corr, m_mag2_time, m_mag2_fwhm_corr } );
 
        last_dimm_time      = m_dimm_time;
        last_dimm_fwhm_corr = m_dimm_fwhm_corr;
 
        last_mag1_time      = m_mag1_time;
        last_mag1_fwhm_corr = m_mag1_fwhm_corr;
 
        last_mag2_time      = m_mag2_time;
        last_mag2_fwhm_corr = m_mag2_fwhm_corr;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTcsiTipTilt( bool force )
{
    bool  enabled;
    float avgInt;
    float gain;
    float thresh;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        enabled = m_offlTT_enabled;
        avgInt  = m_offlTT_avgInt;
        gain    = m_offlTT_gain;
        thresh  = m_offlTT_thresh;
    }
 
    static bool  lastEnabled = !enabled;
    static float lastAvgInt  = std::numeric_limits<float>::quiet_NaN();
    static float lastGain    = std::numeric_limits<float>::quiet_NaN();
    static float lastThresh  = std::numeric_limits<float>::quiet_NaN();
 
    if( force || lastEnabled != enabled || lastAvgInt != avgInt || lastGain != gain || lastThresh != thresh )
    {
        telem<telem_tcsi_tiptilt>( { enabled, avgInt, gain, thresh } );
 
        lastEnabled = enabled;
        lastAvgInt  = avgInt;
        lastGain    = gain;
        lastThresh  = thresh;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTcsiFocus( bool force )
{
    bool  enabled;
    float avgInt;
    float gain;
    float thresh;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        enabled = m_offlF_enabled;
        avgInt  = m_offlF_avgInt;
        gain    = m_offlF_gain;
        thresh  = m_offlF_thresh;
    }
 
    static bool  lastEnabled = !enabled;
    static float lastAvgInt  = std::numeric_limits<float>::quiet_NaN();
    static float lastGain    = std::numeric_limits<float>::quiet_NaN();
    static float lastThresh  = std::numeric_limits<float>::quiet_NaN();
 
    if( force || lastEnabled != enabled || lastAvgInt != avgInt || lastGain != gain || lastThresh != thresh )
    {
        telem<telem_tcsi_focus>( { enabled, avgInt, gain, thresh } );
 
        lastEnabled = enabled;
        lastAvgInt  = avgInt;
        lastGain    = gain;
        lastThresh  = thresh;
    }
 
    return 0;
}
 
inline int tcsInterface::recordTcsiLabMode( bool force )
{
    bool labMode;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        labMode = m_labMode;
    }
 
    static bool lastLabMode = !labMode;
 
    if( force || lastLabMode != labMode )
    {
        telem<telem_tcsi_labmode>( { labMode } );
 
        lastLabMode = labMode;
    }
 
    return 0;
}
 
int tcsInterface::sendPyrNudge( float x, float y, float z )
{
    if( x != 0 || y != 0 )
    {
        float dx = m_pyrNudge_C_00 * x + m_pyrNudge_C_01 * y;
        float dy = m_pyrNudge_C_10 * x + m_pyrNudge_C_11 * y;
 
        // float cs = cos((m_pyrNudge_ang + m_pyrNudge_ang0 + m_telZd)*3.14159*180);
        // float ss = sin((m_pyrNudge_ang + m_pyrNudge_ang0 + m_telZd)*3.14159*180);
 
        // float dx = x * cs - y * ss;
        // float dy = m_pyrNudge_parity*(x * ss + y * cs);
 
        char ttstr[64];
        snprintf( ttstr, sizeof( ttstr ), "aeg %f %f", dx, dy );
 
        ///\todo need logtypes for nudges and offloads
        log<text_log>( std::string( "[PYRNUDGE] " ) + ttstr, logPrio::LOG_NOTICE );
        if( sendMagTelCommand( ttstr, m_readTimeout ) < 0 )
        {
            log<software_error>( { __FILE__, __LINE__, std::string( "error sending command: " ) + ttstr } );
            return -1;
        }
    }
 
    if( z != 0 )
    {
        char ttstr[64];
        snprintf( ttstr, sizeof( ttstr ), "zimr %f", z * m_pyrNudge_F_sign );
 
        log<text_log>( std::string( "[PYRNUDGE] " ) + ttstr, logPrio::LOG_NOTICE );
        if( sendMagTelCommand( ttstr, m_readTimeout ) < 0 )
        {
            log<software_error>( { __FILE__, __LINE__, std::string( "error sending command: " ) + ttstr } );
            return -1;
        }
    }
 
    return 0;
}
 
int tcsInterface::acquireFromGuider()
{
    // Convert current telescope rotator angle to radians
    float q = ( m_acqZdSign * m_telZd ) * 3.14159 / 180.;
 
    // The rotation matrix
    float az = m_acqAz0 * cos( q ) - m_acqEl0 * sin( q ) + m_acqAzOff;
    float el = m_acqAz0 * sin( q ) + m_acqEl0 * cos( q ) + m_acqElOff;
 
    char ttstr[64];
    snprintf( ttstr, sizeof( ttstr ), "aeg %f %f", az, el );
 
    ///\todo need logtypes for nudges and offloads
    log<text_log>( std::string( "[ACQUIRE] " ) + ttstr, logPrio::LOG_NOTICE );
    if( sendMagTelCommand( ttstr, m_readTimeout ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__, std::string( "error sending command: " ) + ttstr } );
        return -1;
    }
 
    float z = m_acqFocus;
    snprintf( ttstr, sizeof( ttstr ), "zimr %f", z * m_pyrNudge_F_sign );
 
    log<text_log>( std::string( "[ACQUIRE] " ) + ttstr, logPrio::LOG_NOTICE );
    if( sendMagTelCommand( ttstr, m_readTimeout ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__, std::string( "error sending command: " ) + ttstr } );
        return -1;
    }
 
    return 0;
}
 
void tcsInterface::offloadThreadStart( tcsInterface *t )
{
    t->offloadThreadExec();
}
 
void tcsInterface::offloadThreadExec()
{
    // Get the thread PID immediately so the caller can return.
    m_offloadThreadID = syscall( SYS_gettid );
 
    static int last_loopState = -1;
 
    while( ( m_offloadThreadInit == true || state() != stateCodes::CONNECTED ) && shutdown() == 0 )
    {
        sleep( 1 );
    }
 
    float avg_TT_0;
    float avg_TT_1;
    int   sincelast_TT = 0;
 
    float avg_F_0;
    int   sincelast_F = 0;
 
    while( shutdown() == 0 )
    {
        int   loopState = m_loopState.load();
        float offlTTAvgInt;
        float offlFAvgInt;
 
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            offlTTAvgInt = m_offlTT_avgInt;
            offlFAvgInt  = m_offlF_avgInt;
        }
 
        // Check if loop open
        if( loopState == 0 )
        {
            // If this is new, then reset the averaging buffer
            if( loopState != last_loopState )
            {
                { // mutex scope
                    std::lock_guard<std::mutex> lock( m_offloadMutex );
                    m_firstRequest   = 0;
                    m_lastRequest    = std::numeric_limits<size_t>::max();
                    m_nRequests      = 0;
                    m_last_nRequests = 0;
                }
                sincelast_TT = 0;
                sincelast_F  = 0;
            }
            sleep( 1 );
            last_loopState = loopState;
            continue;
        }
 
        // Check if loop paused
        if( loopState == 1 )
        {
            if( loopState != last_loopState )
            {
                sincelast_TT = 0;
                sincelast_F  = 0;
            }
            sleep( 1 );
            last_loopState = loopState;
            continue;
        }
 
        // Ok loop closed
 
        bool haveNewRequests = false;
 
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadMutex );
            haveNewRequests = ( m_nRequests > 0 && m_last_nRequests != m_nRequests );
        }
 
        // If we got a new offload request, process it
        if( haveNewRequests )
        {
            // std::cerr << m_firstRequest << " " << m_lastRequest << " " << m_nRequests << std::endl;
 
            ///\todo offloading: These sections ought to be separate functions for clarity
            { // mutex scope
                std::lock_guard<std::mutex> lock( m_offloadMutex );
 
                /* --- TT --- */
                avg_TT_0 = 0;
                avg_TT_1 = 0;
 
                int navg = 0;
 
                size_t i = m_lastRequest;
 
                for( size_t n = 0; n < offlTTAvgInt; ++n )
                {
                    avg_TT_0 += m_offloadRequests[0][i];
                    avg_TT_1 += m_offloadRequests[1][i];
                    ++navg;
 
                    if( i == m_firstRequest )
                        break;
 
                    if( i == 0 )
                        i = m_offloadRequests[0].size() - 1;
                    else
                        --i;
                }
 
                avg_TT_0 /= navg;
                avg_TT_1 /= navg;
 
                /* --- Focus --- */
                avg_F_0 = 0;
 
                navg = 0;
 
                i = m_lastRequest;
 
                for( size_t n = 0; n < offlFAvgInt; ++n )
                {
                    avg_F_0 += m_offloadRequests[2][i];
                    ++navg;
 
                    if( i == m_firstRequest )
                        break;
 
                    if( i == 0 )
                        i = m_offloadRequests[0].size() - 1;
                    else
                        --i;
                }
 
                avg_F_0 /= navg;
 
                m_last_nRequests = m_nRequests;
            }
 
            ++sincelast_TT;
            if( sincelast_TT >= offlTTAvgInt )
            {
                doTToffload( avg_TT_0, avg_TT_1 );
                sincelast_TT = 0;
            }
 
            ++sincelast_F;
            if( sincelast_F >= offlFAvgInt )
            {
                doFoffload( avg_F_0 );
                sincelast_F = 0;
            }
        }
        last_loopState = loopState;
 
        sleep( 1 );
    }
 
    return;
}
 
int tcsInterface::doTToffload( float tt_0, float tt_1 )
{
    bool  offlTTDump;
    float offlTTGain;
    float offlTTThresh;
    bool  offlTTEnabled;
    bool  labMode;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        offlTTDump    = m_offlTT_dump;
        offlTTGain    = m_offlTT_gain;
        offlTTThresh  = m_offlTT_thresh;
        offlTTEnabled = m_offlTT_enabled;
        labMode       = m_labMode;
    }
 
    if( offlTTDump )
    {
        log<text_log>( "[OFFL] TT dumping: " + std::to_string( tt_0 ) + " " + std::to_string( tt_1 ) );
        sendTToffload( tt_0, tt_1 );
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            m_offlTT_dump = false;
        }
    }
    else
    {
        tt_0 *= offlTTGain;
        tt_1 *= offlTTGain;
 
        if( fabs( tt_0 ) < offlTTThresh )
            tt_0 = 0;
        if( fabs( tt_1 ) < offlTTThresh )
            tt_1 = 0;
 
        if( tt_0 == 0 && tt_1 == 0 )
        {
            // Do nothing
        }
        else if( offlTTEnabled )
        {
            log<text_log>( "[OFFL] TT offloading: " + std::to_string( tt_0 ) + " " + std::to_string( tt_1 ) );
            sendTToffload( tt_0, tt_1 );
        }
        else if( !labMode )
        {
            log<text_log>( "TT offload above threshold but TT offloading disabled", logPrio::LOG_WARNING );
        }
    }
 
    return 0;
}
 
int tcsInterface::sendTToffload( float tt_0, float tt_1 )
{
    bool labMode;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        labMode = m_labMode;
    }
 
    if( labMode ) // If labMode we send offloads to the modulator
    {
        pcf::IndiProperty ip( pcf::IndiProperty::Number );
        ip.setDevice( "modwfs" );
        ip.setName( "offset12" );
        ip.add( pcf::IndiElement( "dC1" ) );
        ip.add( pcf::IndiElement( "dC2" ) );
 
        sendNewProperty( ip );
 
        ip["dC1"] = tt_0;
        ip["dC2"] = tt_1;
 
        sendNewProperty( ip );
        return 0;
    }
 
    char ttstr[64];
 
    snprintf( ttstr, sizeof( ttstr ), "aeg %f %f", tt_0, tt_1 );
 
    log<text_log>( std::string( "[OFFL] sending: " ) + ttstr );
 
    return sendMagTelCommand( ttstr, m_readTimeout );
}
 
int tcsInterface::doFoffload( float F_0 )
{
    bool  offlFDump;
    float offlFGain;
    float offlFThresh;
    bool  offlFEnabled;
    bool  labMode;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        offlFDump    = m_offlF_dump;
        offlFGain    = m_offlF_gain;
        offlFThresh  = m_offlF_thresh;
        offlFEnabled = m_offlF_enabled;
        labMode      = m_labMode;
    }
 
    if( offlFDump )
    {
        log<text_log>( "[OFFL] Focus dumping: " + std::to_string( F_0 ) );
        sendFoffload( F_0 );
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            m_offlF_dump = false;
        }
    }
    else
    {
        F_0 *= offlFGain;
 
        if( fabs( F_0 ) < offlFThresh )
            F_0 = 0;
 
        if( F_0 == 0 )
        {
        }
        else if( offlFEnabled )
        {
            log<text_log>( "[OFFL] Focus sending: " + std::to_string( F_0 ) );
            sendFoffload( F_0 );
        }
        else if( !labMode )
        {
 
            log<text_log>( "Focus offload above threshold but Focus offloading disabled", logPrio::LOG_WARNING );
        }
    }
    return 0;
}
 
int tcsInterface::sendFoffload( float F_0 )
{
    char fstr[64];
 
    // Use zimr to update the IMA values
    snprintf( fstr, sizeof( fstr ), "zimr %f", F_0 );
 
    log<text_log>( std::string( "[OFFL] sending: " ) + fstr );
 
    return sendMagTelCommand( fstr, m_readTimeout );
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_labMode )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_labMode, ipRecv );
 
    if( !ipRecv.find( "toggle" ) )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, "no toggle element" } );
    }
 
    bool labMode;
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::On )
    {
        labMode = true;
    }
    else
    {
        labMode = false;
    }
 
    bool changed = false;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        if( m_labMode != labMode )
        {
            m_labMode = labMode;
            changed   = true;
        }
    }
 
    if( !changed )
    {
        return 0;
    }
 
    if( labMode )
    {
        log<text_log>( "lab mode ON", logPrio::LOG_NOTICE );
        updateSwitchIfChanged( m_indiP_labMode, "toggle", pcf::IndiElement::On, INDI_OK );
    }
    else
    {
        log<text_log>( "lab mode OFF", logPrio::LOG_NOTICE );
        updateSwitchIfChanged( m_indiP_labMode, "toggle", pcf::IndiElement::Off, INDI_OK );
    }
 
    recordTcsiLabMode();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_pyrNudge )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_pyrNudge, ipRecv );
 
    float x = 0;
    float y = 0;
    float z = 0;
 
    if( ipRecv.find( "y" ) )
    {
        x = ipRecv["y"].get<float>();
    }
 
    if( ipRecv.find( "x" ) )
    {
        y = ipRecv["x"].get<float>();
    }
 
    if( ipRecv.find( "z" ) )
    {
        z = ipRecv["z"].get<float>();
    }
 
    return sendPyrNudge( x, y, z );
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_acqFromGuider )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_acqFromGuider, ipRecv );
 
    if( !ipRecv.find( "request" ) )
    {
        return 0;
    }
 
    if( ipRecv["request"].getSwitchState() == pcf::IndiElement::On )
    {
        return acquireFromGuider();
    }
 
    return 0;
}
 
INDI_SETCALLBACK_DEFN( tcsInterface, m_indiP_loopState )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_loopState, ipRecv );
 
    if( !ipRecv.find( "toggle" ) )
        return 0;
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::On )
    {
        m_loopState.store( 2 );
    }
    else
    {
        m_loopState.store( 0 );
    }
 
    return 0;
}
 
INDI_SETCALLBACK_DEFN( tcsInterface, m_indiP_offloadCoeffs )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offloadCoeffs, ipRecv );
 
    if( m_loopState.load() != 2 )
        return 0;
 
    // Tip-Tilt
    float tt0 = ipRecv["00"].get<float>();
    float tt1 = ipRecv["01"].get<float>();
 
    bool  labMode;
    float labOfflTTC00;
    float labOfflTTC01;
    float labOfflTTC10;
    float labOfflTTC11;
    float offlTTC00;
    float offlTTC01;
    float offlTTC10;
    float offlTTC11;
    float offlCFocus00;
    float offlCComa00;
    float offlCComa01;
    float offlCComa10;
    float offlCComa11;
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        labMode      = m_labMode;
        labOfflTTC00 = m_lab_offlTT_C_00;
        labOfflTTC01 = m_lab_offlTT_C_01;
        labOfflTTC10 = m_lab_offlTT_C_10;
        labOfflTTC11 = m_lab_offlTT_C_11;
        offlTTC00    = m_offlTT_C_00;
        offlTTC01    = m_offlTT_C_01;
        offlTTC10    = m_offlTT_C_10;
        offlTTC11    = m_offlTT_C_11;
        offlCFocus00 = m_offlCFocus_00;
        offlCComa00  = m_offlCComa_00;
        offlCComa01  = m_offlCComa_01;
        offlCComa10  = m_offlCComa_10;
        offlCComa11  = m_offlCComa_11;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadMutex );
 
        size_t nextReq = m_lastRequest + 1;
 
        if( nextReq >= m_offloadRequests[0].size() )
            nextReq = 0;
 
        if( labMode )
        {
            m_offloadRequests[0][nextReq] = labOfflTTC00 * tt0 + labOfflTTC01 * tt1;
            m_offloadRequests[1][nextReq] = labOfflTTC10 * tt0 + labOfflTTC11 * tt1;
        }
        else
        {
            m_offloadRequests[0][nextReq] = offlTTC00 * tt0 + offlTTC01 * tt1;
            m_offloadRequests[1][nextReq] = offlTTC10 * tt0 + offlTTC11 * tt1;
        }
 
        // Focus
        float f0 = ipRecv["02"].get<float>();
 
        m_offloadRequests[2][nextReq] = offlCFocus00 * f0;
 
        // Coma
        float c0 = ipRecv["03"].get<float>();
        float c1 = ipRecv["04"].get<float>();
 
        m_offloadRequests[3][nextReq] = offlCComa00 * c0 + offlCComa01 * c1;
        m_offloadRequests[4][nextReq] = offlCComa10 * c0 + offlCComa11 * c1;
 
        // Now update circ buffer
        m_lastRequest = nextReq;
        ++m_nRequests;
        if( m_nRequests > m_offloadRequests[0].size() )
            ++m_firstRequest;
        if( m_firstRequest >= m_offloadRequests[0].size() )
            m_firstRequest = 0;
    }
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlTTenable )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlTTenable, ipRecv );
 
    if( ipRecv.getName() != m_indiP_offlTTenable.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "wrong INDI property received." } );
        return -1;
    }
 
    if( !ipRecv.find( "toggle" ) )
        return 0;
 
    bool changed = false;
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::On )
    {
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            if( m_offlTT_enabled == false )
            {
                m_offlTT_enabled = true;
                changed          = true;
            }
        }
        if( changed )
        {
            updateSwitchIfChanged( m_indiP_offlTTenable, "toggle", pcf::IndiElement::On, INDI_OK );
            recordTcsiTipTilt();
        }
    }
    else if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::Off )
    {
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            if( m_offlTT_enabled == true )
            {
                m_offlTT_enabled = false;
                changed          = true;
            }
        }
        if( changed )
        {
            updateSwitchIfChanged( m_indiP_offlTTenable, "toggle", pcf::IndiElement::Off, INDI_IDLE );
            recordTcsiTipTilt();
        }
    }
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlTTdump )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlTTdump, ipRecv );
 
    if( !ipRecv.find( "request" ) )
        return 0;
 
    if( ipRecv["request"].getSwitchState() == pcf::IndiElement::On )
    {
        updateSwitchIfChanged( m_indiP_offlTTdump, "request", pcf::IndiElement::On, INDI_OK );
 
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            m_offlTT_dump = true;
        }
    }
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlTTavgInt )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlTTavgInt, ipRecv );
 
    int target;
 
    if( indiTargetUpdate( m_indiP_offlTTavgInt, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlTT_avgInt = target;
    }
    recordTcsiTipTilt();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlTTgain )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlTTgain, ipRecv );
 
    float target;
 
    if( indiTargetUpdate( m_indiP_offlTTgain, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlTT_gain = target;
    }
    recordTcsiTipTilt();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlTTthresh )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlTTthresh, ipRecv );
 
    float target;
 
    if( indiTargetUpdate( m_indiP_offlTTthresh, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlTT_thresh = target;
    }
    recordTcsiTipTilt();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlFenable )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlFenable, ipRecv );
 
    if( !ipRecv.find( "toggle" ) )
        return 0;
 
    bool changed = false;
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::On )
    {
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            if( m_offlF_enabled == false )
            {
                m_offlF_enabled = true;
                changed         = true;
            }
        }
        if( changed )
        {
            updateSwitchIfChanged( m_indiP_offlFenable, "toggle", pcf::IndiElement::On, INDI_OK );
            recordTcsiFocus();
        }
    }
    else if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::Off )
    {
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            if( m_offlF_enabled == true )
            {
                m_offlF_enabled = false;
                changed         = true;
            }
        }
        if( changed )
        {
            updateSwitchIfChanged( m_indiP_offlFenable, "toggle", pcf::IndiElement::Off, INDI_IDLE );
            recordTcsiFocus();
        }
    }
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlFdump )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlFdump, ipRecv );
 
    if( !ipRecv.find( "request" ) )
        return 0;
 
    if( ipRecv["request"].getSwitchState() == pcf::IndiElement::On )
    {
        updateSwitchIfChanged( m_indiP_offlFdump, "request", pcf::IndiElement::On, INDI_OK );
 
        { // mutex scope
            std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
            m_offlF_dump = true;
        }
    }
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlFavgInt )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlFavgInt, ipRecv );
 
    int target;
 
    if( indiTargetUpdate( m_indiP_offlFavgInt, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlF_avgInt = target;
    }
    recordTcsiFocus();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlFgain )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlFgain, ipRecv );
 
    float target;
 
    if( indiTargetUpdate( m_indiP_offlFgain, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlF_gain = target;
    }
    recordTcsiFocus();
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( tcsInterface, m_indiP_offlFthresh )( const pcf::IndiProperty &ipRecv )
{
    INDI_VALIDATE_CALLBACK_PROPS( m_indiP_offlFthresh, ipRecv );
 
    float target;
 
    std::cerr << "Got offl thresh\n";
 
    if( indiTargetUpdate( m_indiP_offlFthresh, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    { // mutex scope
        std::lock_guard<std::mutex> lock( m_offloadCtrlMutex );
        m_offlF_thresh = target;
    }
    recordTcsiFocus();
 
    return 0;
}
 
} // namespace app
} // namespace MagAOX
 
#endif // tcsInterface_hpp