indi_alpaca_telescope.cpp

Go to the documentation of this file.

/*
    INDI alpaca Driver
 
    Copyright (C) 2026 Gord Tulloch
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#include "indi_alpaca_telescope.h"
#include <connectionplugins/connectiontcp.h>
#include <memory>
#include <cstring>
#include <cmath>
#include <indicom.h>
#include <libnova/julian_day.h>
 
// We declare an auto pointer to alpacaTelescopeDriver instance
std::unique_ptr<alpacaTelescopeDriver> alpaca(new alpacaTelescopeDriver());
 
#define RA_AXIS     0
#define DEC_AXIS    1
 
alpacaTelescopeDriver::alpacaTelescopeDriver()
{
    DBG_SCOPE = static_cast<uint32_t>(INDI::Logger::getInstance().addDebugLevel("Scope Verbose", "SCOPE"));
 
    setVersion(1, 0);
    SetTelescopeCapability(
        TELESCOPE_CAN_GOTO |
        TELESCOPE_CAN_SYNC |
        TELESCOPE_CAN_ABORT |
        TELESCOPE_CAN_PARK |
        TELESCOPE_HAS_TIME,
        4
    );
    setTelescopeConnection(CONNECTION_TCP);
    m_ClientID = getpid();
    LOG_DEBUG("Initializing from alpacaTelescope device...");
}
 
const char *alpacaTelescopeDriver::getDefaultName()
{
    return "Alpaca Telescope";
}
 
bool alpacaTelescopeDriver::initProperties()
{
    INDI::Telescope::initProperties();
 
    // Use built-in TCP connection with default alpaca.local:32323
    tcpConnection->setDefaultHost("alpaca.local");
    tcpConnection->setDefaultPort(32323);
 
    // Device info
    DeviceInfoTP[DESCRIPTION].fill("DESCRIPTION", "Description", "");
    DeviceInfoTP[DRIVER_INFO].fill("DRIVER_INFO", "Driver Info", "");
    DeviceInfoTP[DRIVER_VERSION].fill("DRIVER_VERSION", "Driver Version", "");
    DeviceInfoTP[INTERFACE_VERSION].fill("INTERFACE_VERSION", "Interface Version", "");
    DeviceInfoTP.fill(getDeviceName(), "DEVICE_INFO", "Device Info", OPTIONS_TAB, IP_RO, 60, IPS_IDLE);
 
    SetParkDataType(PARK_RA_DEC);
 
    // RA is a rotating frame, while HA or Alt/Az is not
    SetParkDataType(PARK_HA_DEC);
 
    /* Add debug controls so we may debug driver if necessary */
    addDebugControl();
 
    return true;
}
 
bool alpacaTelescopeDriver::updateProperties()
{
    INDI::Telescope::updateProperties();
 
    if (isConnected())
    {
        defineProperty(DeviceInfoTP);
 
        if (InitPark())
        {
            // Load park data if available
            m_currentRA = ParkPositionNP[AXIS_RA].getValue();
            m_currentDEC = ParkPositionNP[AXIS_DE].getValue();
            SetAxis1ParkDefault(-6.);
            SetAxis2ParkDefault(0.);
        }
        else
        {
            SetAxis1Park(-6.);
            SetAxis2Park(0.);
            SetAxis1ParkDefault(-6.);
            SetAxis2ParkDefault(0.);
        }
    }
    else
    {
        deleteProperty(DeviceInfoTP);
    }
 
    return true;
}
 
bool alpacaTelescopeDriver::Connect()
{
    std::string host = tcpConnection->host();
    int port = tcpConnection->port();
 
    LOGF_INFO("Connecting to alpaca server at %s:%d", host.c_str(), port);
 
    httpClient = std::make_unique<httplib::Client>(host.c_str(), port);
    httpClient->set_connection_timeout(10);
    httpClient->set_read_timeout(30);  // Increased timeout for commands that may take time to respond
 
    nlohmann::json response;
    if (!sendAlpacaGET("/connected", response))
    {
        LOG_ERROR("Failed to connect to alpaca");
        httpClient.reset();
        return false;
    }
 
    LOGF_INFO("alpaca reachable, connected=%s",
              response.value("Value", false) ? "true" : "false");
 
    nlohmann::json request;
    request["Connected"] = true;
    if (!sendAlpacaPUT("/connected", request, response))
    {
        LOG_ERROR("Failed to set connected state");
        httpClient.reset();
        return false;
    }
 
    // Query device capabilities, location, time, and initial status now that the
    // HTTP client is ready (Handshake() also defines TrackModeSP via AddTrackMode(),
    // which must happen before updateProperties() is called)
    Handshake();
 
    // Start the timer
    SetTimer(getCurrentPollingPeriod());
 
    LOG_INFO("Successfully connected to alpaca");
    return true;
}
 
bool alpacaTelescopeDriver::Disconnect()
{
    if (httpClient)
    {
        nlohmann::json request, response;
        request["Connected"] = false;
        sendAlpacaPUT("/connected", request, response);
        httpClient.reset();
    }
    LOG_INFO("Disconnected from alpaca");
    return true;
}
 
bool alpacaTelescopeDriver::Handshake()
{
    nlohmann::json response;
 
    if (sendAlpacaGET("/description", response) && response.contains("Value"))
        DeviceInfoTP[DESCRIPTION].setText(response["Value"].get<std::string>().c_str());
 
    if (sendAlpacaGET("/driverinfo", response) && response.contains("Value"))
        DeviceInfoTP[DRIVER_INFO].setText(response["Value"].get<std::string>().c_str());
 
    if (sendAlpacaGET("/driverversion", response) && response.contains("Value"))
        DeviceInfoTP[DRIVER_VERSION].setText(response["Value"].get<std::string>().c_str());
 
    if (sendAlpacaGET("/interfaceversion", response) && response.contains("Value"))
        DeviceInfoTP[INTERFACE_VERSION].setText(std::to_string(response["Value"].get<int>()).c_str());
 
    DeviceInfoTP.apply();
 
    // Query alignment mode to determine mount behavior
    // 0 = algPolar (equatorial), 1 = algAltAz, 2 = algGermanPolar
    if (sendAlpacaGET("/alignmentmode", response) && response.contains("Value"))
    {
        int alignmentMode = response["Value"].get<int>();
        if (alignmentMode == 1)
        {
            LOG_INFO("Telescope alignment mode: Alt-Az (no meridian flips)");
        }
        else if (alignmentMode == 0 || alignmentMode == 2)
        {
            LOG_INFO("Telescope alignment mode: Equatorial (Fork mount - no meridian flips)");
        }
    }
 
    bool canPark = false;
    if (sendAlpacaGET("/canpark", response) && response.contains("Value"))
        canPark = response["Value"].get<bool>();
 
    if (canPark)
    {
        SetParkDataType(PARK_RA_DEC);
 
        // Initialize park position if not already set
        // Default to zenith (RA=0, Dec=observer latitude)
        if (!InitPark())
        {
            // Set default park position to zenith
            SetAxis1Park(0);
            SetAxis2Park(90);
            LOG_INFO("Park position initialized to zenith");
        }
 
        // Get current park state
        if (sendAlpacaGET("/atpark", response) && response.contains("Value"))
        {
            isParked = response["Value"].get<bool>();
            SetParked(isParked);
        }
    }
 
    // Get site location from device
    double latitude = 0.0, longitude = 0.0;
    bool locationValid = false;
 
    if (sendAlpacaGET("/sitelatitude", response) && response.contains("Value"))
    {
        latitude = response["Value"].get<double>();
        locationValid = true;
        LOGF_INFO("Site latitude from device: %.6f°", latitude);
    }
    else
    {
        LOG_WARN("Failed to get site latitude from device");
    }
 
    if (sendAlpacaGET("/sitelongitude", response) && response.contains("Value"))
    {
        longitude = response["Value"].get<double>();
        LOGF_INFO("Site longitude from device: %.6f°", longitude);
    }
    else
    {
        LOG_WARN("Failed to get site longitude from device");
        locationValid = false;
    }
 
    // Site elevation is optional - default to 0 if the device doesn't report it
    double elevation = 0.0;
    if (sendAlpacaGET("/siteelevation", response) && response.contains("Value"))
    {
        elevation = response["Value"].get<double>();
        LOGF_INFO("Site elevation from device: %.1fm", elevation);
    }
    else
    {
        LOG_WARN("Failed to get site elevation from device");
    }
 
    // Update INDI location property if we got valid data
    if (locationValid)
    {
        // INDI uses: LOCATION_LATITUDE = latitude (positive north), LOCATION_LONGITUDE = longitude (positive east)
        // Alpaca uses same convention
        LocationNP[LOCATION_LATITUDE].setValue(latitude);
        LocationNP[LOCATION_LONGITUDE].setValue(longitude);
        LocationNP[LOCATION_ELEVATION].setValue(elevation);
        LocationNP.setState(IPS_OK);
        LocationNP.apply();
 
        // Calculate and cache sin/cos for coordinate transformations
        double latRad = latitude * M_PI / 180.0;
        m_sinLat = sin(latRad);
        m_cosLat = cos(latRad);
 
        LOGF_INFO("Site location set: Lat=%.6f° Long=%.6f°", latitude, longitude);
    }
 
    // Get UTC date/time from device
    if (sendAlpacaGET("/utcdate", response) && response.contains("Value"))
    {
        std::string utcDate = response["Value"].get<std::string>();
        TimeTP[UTC].setText(utcDate.c_str());
        TimeTP[OFFSET].setText("0");
        TimeTP.setState(IPS_OK);
        TimeTP.apply();
        LOGF_INFO("Device UTC date/time: %s", utcDate.c_str());
    }
    else
    {
        LOG_WARN("Failed to get UTC date/time from device, using system time");
        sendTimeFromSystem();
    }
 
    // Query tracking capability
    if (sendAlpacaGET("/cansettracking", response) && response.contains("Value"))
    {
        if (response["Value"].get<bool>())
        {
            SetTelescopeCapability(GetTelescopeCapability() | TELESCOPE_CAN_CONTROL_TRACK, 4);
            LOG_INFO("Telescope supports tracking control - TELESCOPE_TRACK_STATE enabled");
        }
        else
        {
            LOG_INFO("Telescope does not support tracking control");
        }
    }
    else
    {
        LOG_WARN("Failed to query tracking capability from device");
    }
 
    // Query whether the mount supports the non-blocking slewtotargetasync/slewtoaltazasync
    // commands. If not, fall back to the blocking slewtotarget/slewtoaltaz commands.
    if (sendAlpacaGET("/canslewasync", response) && response.contains("Value"))
        m_CanSlewAsync = response["Value"].get<bool>();
    else
        m_CanSlewAsync = false;
    LOGF_INFO("Telescope supports async slew: %s", m_CanSlewAsync ? "Yes" : "No");
 
    // Query the list of supported tracking rates (Alpaca DriveRate enum: 0=Sidereal,
    // 1=Lunar, 2=Solar, 3=King) and build the TrackModeSP property accordingly.
    m_TrackModeAlpacaRates.clear();
    TrackModeSP.resize(0);
    if (sendAlpacaGET("/trackingrates", response) && response.contains("Value") && response["Value"].is_array())
    {
        static const struct { int rate; const char *name; const char *label; } alpacaRates[] =
        {
            {0, "TRACK_SIDEREAL", "Sidereal"},
            {1, "TRACK_LUNAR", "Lunar"},
            {2, "TRACK_SOLAR", "Solar"},
            {3, "TRACK_KING", "King"},
        };
 
        for (const auto &entry : alpacaRates)
        {
            for (const auto &value : response["Value"])
            {
                if (value.get<int>() == entry.rate)
                {
                    AddTrackMode(entry.name, entry.label, entry.rate == 0);
                    m_TrackModeAlpacaRates.push_back(entry.rate);
                    break;
                }
            }
        }
    }
 
    if (!m_TrackModeAlpacaRates.empty())
    {
        SetTelescopeCapability(GetTelescopeCapability() | TELESCOPE_HAS_TRACK_MODE, 4);
        LOGF_INFO("Telescope supports %zu tracking rate(s)", m_TrackModeAlpacaRates.size());
 
        // Sync the current tracking rate
        if (sendAlpacaGET("/trackingrate", response) && response.contains("Value"))
        {
            int currentRate = response["Value"].get<int>();
            for (size_t i = 0; i < m_TrackModeAlpacaRates.size(); i++)
            {
                if (m_TrackModeAlpacaRates[i] == currentRate)
                {
                    TrackModeSP.reset();
                    TrackModeSP[i].setState(ISS_ON);
                    break;
                }
            }
        }
    }
    else
    {
        LOG_WARN("Failed to query supported tracking rates from device");
    }
 
    // Query support for custom (offset) tracking rates
    m_CanSetRaRate = sendAlpacaGET("/cansetrightascensionrate", response) && response.contains("Value")
                     && response["Value"].get<bool>();
    m_CanSetDecRate = sendAlpacaGET("/cansetdeclinationrate", response) && response.contains("Value")
                      && response["Value"].get<bool>();
 
    if (m_CanSetRaRate && m_CanSetDecRate)
    {
        SetTelescopeCapability(GetTelescopeCapability() | TELESCOPE_HAS_TRACK_RATE, 4);
        LOG_INFO("Telescope supports custom tracking rates - TELESCOPE_TRACK_RATE enabled");
    }
    else
    {
        LOG_INFO("Telescope does not support custom tracking rates");
    }
 
    // Get initial coordinates
    ReadScopeStatus();
 
    LOG_INFO("alpaca connected successfully");
    return true;
}
 
bool alpacaTelescopeDriver::ReadScopeStatus()
{
    nlohmann::json response;
 
    // Get RA/Dec
    double newRA = m_currentRA, newDec = m_currentDEC;
 
    // Get current coordinates from Alpaca API
    bool raUpdated = false, decUpdated = false;
    if (sendAlpacaGET("/rightascension", response) && response.contains("Value"))
    {
        newRA = response["Value"].get<double>();
        raUpdated = true;
    }
    else
    {
        LOG_WARN("Failed to get RA from Alpaca API");
    }
 
    if (sendAlpacaGET("/declination", response) && response.contains("Value"))
    {
        newDec = response["Value"].get<double>();
        decUpdated = true;
    }
    else
    {
        LOG_WARN("Failed to get Dec from Alpaca API");
    }
 
    // Update current coordinates
    if (raUpdated && decUpdated)
    {
        m_currentRA = newRA;
        m_currentDEC = newDec;
 
        // Always call NewRaDec to update client display
        // This is critical during slewing to show real-time position updates
        NewRaDec(m_currentRA, m_currentDEC);
    }
    else
    {
        LOG_WARN("NewRaDec NOT called - coordinate update failed");
    }
 
    // Get slewing state
    if (sendAlpacaGET("/slewing", response) && response.contains("Value"))
        isSlewing = response["Value"].get<bool>();
 
    // Get tracking state
    if (sendAlpacaGET("/tracking", response) && response.contains("Value"))
        isTracking = response["Value"].get<bool>();
 
    // Keep TrackModeSP in sync with the device's current tracking rate
    if (HasTrackMode() && sendAlpacaGET("/trackingrate", response) && response.contains("Value"))
    {
        int currentRate = response["Value"].get<int>();
        int currentIndex = TrackModeSP.findOnSwitchIndex();
        for (size_t i = 0; i < m_TrackModeAlpacaRates.size(); i++)
        {
            if (m_TrackModeAlpacaRates[i] == currentRate && static_cast<int>(i) != currentIndex)
            {
                TrackModeSP.reset();
                TrackModeSP[i].setState(ISS_ON);
                TrackModeSP.setState(IPS_OK);
                TrackModeSP.apply();
                break;
            }
        }
    }
 
    // Get park state
    if (sendAlpacaGET("/atpark", response) && response.contains("Value"))
    {
        bool parked = response["Value"].get<bool>();
        if (parked != isParked)
        {
            isParked = parked;
            SetParked(isParked);
        }
    }
 
    // Update telescope state
    if (TrackState == SCOPE_PARKING)
    {
        // If we're parking and slewing stopped, we've reached park position
        if (!isSlewing)
        {
            TrackState = SCOPE_PARKED;
            LOG_INFO("Parking complete - telescope at park position");
        }
        // else keep SCOPE_PARKING state while slewing to park position
    }
    else if (isSlewing)
        TrackState = SCOPE_SLEWING;
    else if (isTracking)
        TrackState = SCOPE_TRACKING;
    else if (isParked)
        TrackState = SCOPE_PARKED;
    else
        TrackState = SCOPE_IDLE;
 
    return true;
}
 
bool alpacaTelescopeDriver::Goto(double ra, double dec)
{
    // Check if telescope is parked - must unpark before slewing
    if (isParked)
    {
        LOG_ERROR("Cannot GoTo while parked. Please unpark the telescope first.");
        return false;
    }
 
    LOGF_INFO("GoTo command: RA=%f Dec=%f", ra, dec);
 
    // Use ASCOM Alpaca pattern: set target coordinates first, then slew
    // Step 1: Set target RA
    nlohmann::json response;
    nlohmann::json raRequest;
    raRequest["TargetRightAscension"] = ra;
    if (!sendAlpacaPUT("/targetrightascension", raRequest, response))
    {
        LOG_ERROR("Failed to set target RA");
        return false;
    }
 
    // Step 2: Set target Dec
    nlohmann::json decRequest;
    decRequest["TargetDeclination"] = dec;
    if (!sendAlpacaPUT("/targetdeclination", decRequest, response))
    {
        LOG_ERROR("Failed to set target Dec");
        return false;
    }
 
    // Step 3: Start slew to target. Prefer the non-blocking /slewtotargetasync if the
    // device supports it, since /slewtotarget blocks the HTTP request (and therefore
    // this driver) until the slew completes.
    nlohmann::json emptyRequest;
    const char *slewEndpoint = m_CanSlewAsync ? "/slewtotargetasync" : "/slewtotarget";
    if (!sendAlpacaPUT(slewEndpoint, emptyRequest, response))
    {
        LOG_ERROR("Failed to send GoTo command");
        return false;
    }
 
    TrackState = SCOPE_SLEWING;
    LOGF_INFO("GoTo command sent (%s) - slewing to target", m_CanSlewAsync ? "async" : "sync");
    return true;
}
 
bool alpacaTelescopeDriver::Sync(double ra, double dec)
{
    nlohmann::json request, response;
    request["RightAscension"] = ra;
    request["Declination"] = dec;
 
    if (!sendAlpacaPUT("/synctocoordinates", request, response))
    {
        LOG_ERROR("Failed to sync");
        return false;
    }
 
    LOG_INFO("Sync successful");
    return true;
}
 
bool alpacaTelescopeDriver::Abort()
{
    nlohmann::json request, response;
 
    // Check if we're parking - parking cannot be aborted via AbortSlew
    if (TrackState == SCOPE_PARKING)
    {
        LOG_WARN("Cannot abort parking operation - park must complete");
        return false;
    }
 
    if (!sendAlpacaPUT("/abortslew", request, response))
    {
        LOG_ERROR("Failed to abort");
        return false;
    }
 
    TrackState = SCOPE_IDLE;
    LOG_INFO("Slew aborted");
    return true;
}
 
bool alpacaTelescopeDriver::Park()
{
    nlohmann::json request, response;
 
    // Abort any ongoing slew first
    if (isSlewing)
    {
        LOG_INFO("Aborting slew before park");
        nlohmann::json abortReq, abortResp;
        sendAlpacaPUT("/abortslew", abortReq, abortResp);
    }
 
    LOG_INFO("Sending park command to Alpaca device");
 
    // Use Alpaca park command
    if (!sendAlpacaPUT("/park", request, response))
    {
        LOG_ERROR("Failed to send park command to Alpaca device");
        return false;
    }
 
    // Mark as parked - set state to PARKED not PARKING since command is sent
    isParked = true;
    SetParked(true);
    TrackState = SCOPE_PARKED;
    LOG_INFO("Park command sent - telescope parked");
 
    return true;
}
 
bool alpacaTelescopeDriver::UnPark()
{
    nlohmann::json request, response;
 
    LOG_INFO("Sending unpark command to Alpaca device");
 
    // Use Alpaca unpark command
    if (!sendAlpacaPUT("/unpark", request, response))
    {
        LOG_ERROR("Failed to send unpark command to Alpaca device");
        return false;
    }
 
    // Immediately mark as unparked so INDI allows motion commands
    // ReadScopeStatus will sync with actual device state
    isParked = false;
    SetParked(false);
    TrackState = SCOPE_IDLE;
    LOG_INFO("Unpark command sent - telescope unparked");
 
    return true;
}
 
bool alpacaTelescopeDriver::SetCurrentPark()
{
    // Save current RA/Dec position as park position
    // This allows user to park at current position via "Park Options -> Set Current"
 
    // Get current coordinates
    nlohmann::json response;
    double ra = 0, dec = 0;
 
    if (sendAlpacaGET("/rightascension", response) && response.contains("Value"))
    {
        ra = response["Value"].get<double>();
    }
    else
    {
        LOG_ERROR("Failed to get current RA for SetCurrentPark");
        return false;
    }
 
    if (sendAlpacaGET("/declination", response) && response.contains("Value"))
    {
        dec = response["Value"].get<double>();
    }
    else
    {
        LOG_ERROR("Failed to get current Dec for SetCurrentPark");
        return false;
    }
 
    // Save current position as park position
    SetAxis1Park(ra);   // RA in hours
    SetAxis2Park(dec);  // Dec in degrees
 
    LOGF_INFO("Park position set to current coordinates: RA=%.6f hours, Dec=%.6f degrees", ra, dec);
 
    return true;
}
 
bool alpacaTelescopeDriver::SetTrackEnabled(bool enabled)
{
    nlohmann::json request, response;
    request["Tracking"] = enabled;
 
    if (!sendAlpacaPUT("/tracking", request, response))
    {
        LOGF_ERROR("Failed to %s tracking", enabled ? "enable" : "disable");
        return false;
    }
 
    isTracking = enabled;
    LOGF_INFO("Tracking %s", enabled ? "enabled" : "disabled");
    return true;
}
 
bool alpacaTelescopeDriver::SetTrackMode(uint8_t mode)
{
    if (mode >= m_TrackModeAlpacaRates.size())
    {
        LOG_ERROR("Invalid track mode index");
        return false;
    }
 
    nlohmann::json request, response;
    request["TrackingRate"] = m_TrackModeAlpacaRates[mode];
 
    if (!sendAlpacaPUT("/trackingrate", request, response))
    {
        LOG_ERROR("Failed to set track mode");
        return false;
    }
 
    LOGF_INFO("Track mode set to %s", TrackModeSP[mode].getLabel());
    return true;
}
 
bool alpacaTelescopeDriver::SetTrackRate(double raRate, double deRate)
{
    if (!m_CanSetRaRate || !m_CanSetDecRate)
    {
        LOG_WARN("Custom tracking rates are not supported by this telescope");
        return false;
    }
 
    nlohmann::json request, response;
 
    // Alpaca's RightAscensionRate is expressed in seconds of RA per sidereal second,
    // while INDI's raRate is in arcseconds/second. 1 second of RA = 15 arcseconds, and
    // the sidereal/solar second difference (~0.27%) is negligible for this offset.
    request["RightAscensionRate"] = raRate / 15.0;
    if (!sendAlpacaPUT("/rightascensionrate", request, response))
    {
        LOG_ERROR("Failed to set RA tracking rate");
        return false;
    }
 
    request.clear();
    request["DeclinationRate"] = deRate;
    if (!sendAlpacaPUT("/declinationrate", request, response))
    {
        LOG_ERROR("Failed to set DEC tracking rate");
        return false;
    }
 
    LOGF_INFO("Custom tracking rate set: RA=%.6f arcsec/s, DEC=%.6f arcsec/s", raRate, deRate);
    return true;
}
 
bool alpacaTelescopeDriver::MoveNS(INDI_DIR_NS dir, TelescopeMotionCommand command)
{
    nlohmann::json request, response;
 
    // Secondary axis (Dec/Altitude): 1
    // Positive rate = North/Up, Negative rate = South/Down
    request["Axis"] = 1;
 
    if (command == MOTION_START)
    {
        // Use moderate rate for manual movement (0.5 deg/sec)
        // TODO: Query /axisrates to get valid rates and use client-selected slew rate
        double rate = (dir == DIRECTION_NORTH) ? 0.5 : -0.5;
        request["Rate"] = rate;
        LOGF_INFO("Moving %s at rate %.2f deg/sec", (dir == DIRECTION_NORTH) ? "North" : "South", rate);
    }
    else
    {
        request["Rate"] = 0.0;
        LOG_INFO("Stopping NS motion");
    }
 
    if (!sendAlpacaPUT("/moveaxis", request, response))
    {
        LOG_ERROR("Failed to move NS");
        return false;
    }
 
    // Log response for debugging
    if (response.contains("ErrorNumber"))
    {
        int errNum = response["ErrorNumber"].get<int>();
        if (errNum != 0)
        {
            LOGF_WARN("MoveAxis NS returned error %d: %s", errNum,
                      response.value("ErrorMessage", "Unknown error").c_str());
        }
    }
 
    return true;
}
 
bool alpacaTelescopeDriver::MoveWE(INDI_DIR_WE dir, TelescopeMotionCommand command)
{
    nlohmann::json request, response;
 
    // Primary axis (RA/Azimuth): 0
    // Positive rate = East/Right, Negative rate = West/Left
    request["Axis"] = 0;
 
    if (command == MOTION_START)
    {
        // Use moderate rate for manual movement (0.5 deg/sec)
        // TODO: Query /axisrates to get valid rates and use client-selected slew rate
        double rate = (dir == DIRECTION_EAST) ? 0.5 : -0.5;
        request["Rate"] = rate;
        LOGF_INFO("Moving %s at rate %.2f deg/sec", (dir == DIRECTION_EAST) ? "East" : "West", rate);
    }
    else
    {
        request["Rate"] = 0.0;
        LOG_INFO("Stopping WE motion");
    }
 
    if (!sendAlpacaPUT("/moveaxis", request, response))
    {
        LOG_ERROR("Failed to move WE");
        return false;
    }
 
    // Log response for debugging
    if (response.contains("ErrorNumber"))
    {
        int errNum = response["ErrorNumber"].get<int>();
        if (errNum != 0)
        {
            LOGF_WARN("MoveAxis WE returned error %d: %s", errNum,
                      response.value("ErrorMessage", "Unknown error").c_str());
        }
    }
 
    return true;
}
 
bool alpacaTelescopeDriver::saveConfigItems(FILE *fp)
{
    INDI::Telescope::saveConfigItems(fp);
    return true;
}
 
bool alpacaTelescopeDriver::updateLocation(double latitude, double longitude, double elevation)
{
    // Update location on the Alpaca device
    nlohmann::json request, response;
 
    // Set latitude
    request["SiteLatitude"] = latitude;
    if (!sendAlpacaPUT("/sitelatitude", request, response))
    {
        LOG_ERROR("Failed to set site latitude on device");
        return false;
    }
 
    // Set longitude
    request.clear();
    request["SiteLongitude"] = longitude;
    if (!sendAlpacaPUT("/sitelongitude", request, response))
    {
        LOG_ERROR("Failed to set site longitude on device");
        return false;
    }
 
    // Set elevation (not all Alpaca devices support this, so just warn on failure)
    request.clear();
    request["SiteElevation"] = elevation;
    if (!sendAlpacaPUT("/siteelevation", request, response))
        LOG_WARN("Failed to set site elevation on device");
 
    // Calculate and cache sin/cos for coordinate transformations
    double latRad = latitude * M_PI / 180.0;
    m_sinLat = sin(latRad);
    m_cosLat = cos(latRad);
 
    LOGF_INFO("Site location updated: Lat=%.6f° Long=%.6f°", latitude, longitude);
 
    // Call base class to update INDI properties
    return INDI::Telescope::updateLocation(latitude, longitude, elevation);
}
 
bool alpacaTelescopeDriver::updateTime(ln_date *utc, double utc_offset)
{
    INDI_UNUSED(utc_offset);
 
    // Alpaca utcdate is always UTC, expressed as an ISO 8601 string
    char isoDate[32];
    snprintf(isoDate, sizeof(isoDate), "%04d-%02d-%02dT%02d:%02d:%06.3fZ",
             utc->years, utc->months, utc->days, utc->hours, utc->minutes, utc->seconds);
 
    nlohmann::json request, response;
    request["UTCDate"] = isoDate;
    if (!sendAlpacaPUT("/utcdate", request, response))
    {
        LOG_ERROR("Failed to set UTC date/time on device");
        return false;
    }
 
    return true;
}
 
// Alpaca helper methods
std::string alpacaTelescopeDriver::getAlpacaURL(const std::string& endpoint)
{
    return "/api/v1/telescope/" + std::to_string(m_DeviceNumber) + endpoint;
}
 
bool alpacaTelescopeDriver::sendAlpacaGET(const std::string& endpoint, nlohmann::json& response)
{
    if (!httpClient)
    {
        LOG_ERROR("HTTP client not initialized");
        return false;
    }
 
    std::string url = getAlpacaURL(endpoint);
    url += "?ClientID=" + std::to_string(m_ClientID) +
           "&ClientTransactionID=" + std::to_string(getTransactionId());
 
    auto result = httpClient->Get(url.c_str());
 
    if (!result)
    {
        LOGF_ERROR("GET %s failed: %s", endpoint.c_str(),
                   httplib::to_string(result.error()).c_str());
        return false;
    }
 
    if (result->status != 200)
    {
        LOGF_ERROR("GET %s HTTP %d", endpoint.c_str(), result->status);
        return false;
    }
 
    try
    {
        response = nlohmann::json::parse(result->body);
 
        if (response.contains("ErrorNumber") && response["ErrorNumber"].get<int>() != 0)
        {
            LOGF_ERROR("Alpaca error %s: %d - %s", endpoint.c_str(),
                       response["ErrorNumber"].get<int>(),
                       response.value("ErrorMessage", "").c_str());
            return false;
        }
 
        return true;
    }
    catch (const nlohmann::json::exception& e)
    {
        LOGF_ERROR("JSON parse error %s: %s", endpoint.c_str(), e.what());
        return false;
    }
}
 
bool alpacaTelescopeDriver::sendAlpacaPUT(const std::string& endpoint, const nlohmann::json& request,
        nlohmann::json& response)
{
    if (!httpClient)
    {
        LOG_ERROR("HTTP client not initialized");
        return false;
    }
 
    std::string url = getAlpacaURL(endpoint);
 
    // Build form data - Alpaca expects form-encoded parameters
    httplib::Params params;
 
    for (auto& [key, value] : request.items())
    {
        if (value.is_string())
            params.emplace(key, value.get<std::string>());
        else if (value.is_boolean())
            params.emplace(key, value.get<bool>() ? "true" : "false");
        else if (value.is_number_integer())
            params.emplace(key, std::to_string(value.get<int>()));
        else if (value.is_number())
            params.emplace(key, std::to_string(value.get<double>()));
    }
 
    params.emplace("ClientID", std::to_string(m_ClientID));
    params.emplace("ClientTransactionID", std::to_string(getTransactionId()));
 
    auto result = httpClient->Put(url.c_str(), params);
 
    if (!result)
    {
        // Some Alpaca devices (like Seestar) close connection immediately after
        // receiving /slewtotarget command. Log as debug instead of error.
        if (endpoint == "/slewtotarget")
        {
            LOGF_DEBUG("PUT %s: connection closed (expected for some devices)", endpoint.c_str());
        }
        else
        {
            LOGF_ERROR("PUT %s failed: %s", endpoint.c_str(),
                       httplib::to_string(result.error()).c_str());
        }
        return false;
    }
 
    if (result->status != 200)
    {
        LOGF_ERROR("PUT %s HTTP %d", endpoint.c_str(), result->status);
        return false;
    }
 
    try
    {
        response = nlohmann::json::parse(result->body);
 
        if (response.contains("ErrorNumber") && response["ErrorNumber"].get<int>() != 0)
        {
            int errorNum = response["ErrorNumber"].get<int>();
            std::string errorMsg = response.value("ErrorMessage", "");
            LOGF_ERROR("Alpaca error %s: %d - %s", endpoint.c_str(), errorNum, errorMsg.c_str());
            return false;
        }
 
        return true;
    }
    catch (const nlohmann::json::exception& e)
    {
        LOGF_ERROR("JSON parse error %s: %s", endpoint.c_str(), e.what());
        return false;
    }
}
 
void ISGetProperties(const char *dev)
{
    alpaca->ISGetProperties(dev);
}
 
void ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n)
{
    alpaca->ISNewSwitch(dev, name, states, names, n);
}
 
void ISNewText(const char *dev, const char *name, char *texts[], char *names[], int n)
{
    alpaca->ISNewText(dev, name, texts, names, n);
}
 
void ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n)
{
    alpaca->ISNewNumber(dev, name, values, names, n);
}
 
void ISNewBLOB(const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[],
               char *names[], int n)
{
    alpaca->ISNewBLOB(dev, name, sizes, blobsizes, blobs, formats, names, n);
}
 
void ISSnoopDevice(XMLEle *root)
{
    alpaca->ISSnoopDevice(root);
}