bool RollOff::SetupParms()
{
// If we have parking data
if (InitPark())
{
if (isParked())
{
fullOpenLimitSwitch = ISS_OFF;
fullClosedLimitSwitch = ISS_ON;
}
else
{
fullOpenLimitSwitch = ISS_ON;
fullClosedLimitSwitch = ISS_OFF;
}
}
// If we don't have parking data
else
{
fullOpenLimitSwitch = ISS_OFF;
fullClosedLimitSwitch = ISS_OFF;
}
return true;
}
bool ScopeSim::updateProperties()
{
INDI::Telescope::updateProperties();
if (isConnected())
{
defineNumber(&GuideNSNP);
defineNumber(&GuideWENP);
defineNumber(&GuideRateNP);
#ifdef USE_EQUATORIAL_PE
defineNumber(&EqPENV);
defineSwitch(&PEErrNSSP);
defineSwitch(&PEErrWESP);
#endif
if (InitPark())
{
// If loading parking data is successful, we just set the default parking values.
SetAxis1ParkDefault(currentRA);
SetAxis2ParkDefault(currentDEC);
if (isParked())
{
currentRA = ParkPositionN[AXIS_RA].value;
currentDEC= ParkPositionN[AXIS_DE].value;
}
}
else
{
// Otherwise, we set all parking data to default in case no parking data is found.
SetAxis1Park(currentRA);
SetAxis2Park(currentDEC);
SetAxis1ParkDefault(currentRA);
SetAxis2ParkDefault(currentDEC);
}
sendTimeFromSystem();
}
else
{
deleteProperty(GuideNSNP.name);
deleteProperty(GuideWENP.name);
#ifdef USE_EQUATORIAL_PE
deleteProperty(EqPENV.name);
deleteProperty(PEErrNSSP.name);
deleteProperty(PEErrWESP.name);
#endif
deleteProperty(GuideRateNP.name);
}
return true;
}
bool ScopeScript::ReadScopeStatus()
{
char name[1024];
char *s = tmpnam(name);
INDI_UNUSED(s);
bool status = RunScript(SCRIPT_STATUS, name, nullptr);
if (status)
{
int parked = 0;
float ra = 0, dec = 0;
FILE *file = fopen(name, "r");
int ret = 0;
ret = fscanf(file, "%d %f %f", &parked, &ra, &dec);
fclose(file);
unlink(name);
if (parked != 0)
{
if (!isParked())
{
SetParked(true);
LOG_INFO("Park succesfully executed");
}
}
else
{
if (isParked())
{
SetParked(false);
LOG_INFO("Unpark succesfully executed");
}
}
NewRaDec(ra, dec);
}
else
{
LOG_ERROR("Failed to read status");
}
return status;
}
bool SynscanDriver::ISNewNumber(const char * dev, const char * name, double values[], char * names[], int n)
{
if (dev && !strcmp(dev, getDeviceName()))
{
// Guide Rate
if (strcmp(name, "GUIDE_RATE") == 0)
{
IUUpdateNumber(&GuideRateNP, values, names, n);
GuideRateNP.s = IPS_OK;
IDSetNumber(&GuideRateNP, nullptr);
return true;
}
// Custom Slew Rate
if (strcmp(name, CustomSlewRateNP.name) == 0)
{
if (TrackState == SCOPE_SLEWING)
{
LOG_ERROR("Cannot change rate while slewing.");
CustomSlewRateNP.s = IPS_ALERT;
IDSetNumber(&CustomSlewRateNP, nullptr);
return true;
}
IUUpdateNumber(&CustomSlewRateNP, values, names, n);
CustomSlewRateNP.s = IPS_OK;
IDSetNumber(&CustomSlewRateNP, nullptr);
return true;
}
// Horizonal Coords
if (!strcmp(name, HorizontalCoordsNP.name))
{
if (isParked())
{
LOG_WARN("Unpark mount before issuing GOTO commands.");
HorizontalCoordsNP.s = IPS_IDLE;
IDSetNumber(&HorizontalCoordsNP, nullptr);
return true;
}
int nset = 0;
double newAlt = 0, newAz = 0;
for (int i = 0; i < n; i++)
{
INumber * horp = IUFindNumber(&HorizontalCoordsNP, names[i]);
if (horp == &HorizontalCoordsN[AXIS_AZ])
{
newAz = values[i];
nset += newAz >= 0. && newAz <= 360.0;
}
else if (horp == &HorizontalCoordsN[AXIS_ALT])
{
newAlt = values[i];
nset += newAlt >= -90. && newAlt <= 90.0;
}
}
if (nset == 2 && GotoAzAlt(newAz, newAlt))
return true;
HorizontalCoordsNP.s = IPS_ALERT;
IDSetNumber(&HorizontalCoordsNP, "Altitude or Azimuth missing or invalid.");
return false;
}
// Guiding
if (strcmp(name, GuideNSNP.name) == 0 || strcmp(name, GuideWENP.name) == 0)
{
processGuiderProperties(name, values, names, n);
return true;
}
}
return INDI::Telescope::ISNewNumber(dev, name, values, names, n);
}
void DomeScript::TimerHit()
{
if (!isConnected())
return;
char name[1024]={0};
// N.B. INDI_UNUSED to make it compile on MacOS
// DO NOT CHANGE
char *s = tmpnam(name);
INDI_UNUSED(s);
bool status = RunScript(SCRIPT_STATUS, name, nullptr);
if (status)
{
int parked = 0, shutter = 0;
float az = 0;
FILE *file = fopen(name, "r");
int ret = 0;
ret = fscanf(file, "%d %d %f", &parked, &shutter, &az);
fclose(file);
unlink(name);
DomeAbsPosN[0].value = az = round(range360(az) * 10) / 10;
if (parked != 0)
{
if (getDomeState() == DOME_PARKING || getDomeState() == DOME_UNPARKED)
{
SetParked(true);
TargetAz = az;
LOG_INFO("Park succesfully executed");
}
}
else
{
if (getDomeState() == DOME_UNPARKING || getDomeState() == DOME_PARKED)
{
SetParked(false);
TargetAz = az;
LOG_INFO("Unpark succesfully executed");
}
}
if (std::round(az * 10) != std::round(TargetAz * 10))
{
LOGF_INFO("Moving %g -> %g %d", std::round(az * 10) / 10,
std::round(TargetAz * 10) / 10, getDomeState());
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else if (getDomeState() == DOME_MOVING)
{
setDomeState(DOME_SYNCED);
IDSetNumber(&DomeAbsPosNP, nullptr);
}
if (shutterState == SHUTTER_OPENED)
{
if (shutter == 0)
{
shutterState = SHUTTER_CLOSED;
DomeShutterSP.s = IPS_OK;
IDSetSwitch(&DomeShutterSP, nullptr);
LOG_INFO("Shutter was succesfully closed");
}
}
else
{
if (shutter == 1)
{
shutterState = SHUTTER_OPENED;
DomeShutterSP.s = IPS_OK;
IDSetSwitch(&DomeShutterSP, nullptr);
LOG_INFO("Shutter was succesfully opened");
}
}
}
else
{
LOG_ERROR("Failed to read status");
}
SetTimer(POLLMS);
if (!isParked() && TimeSinceUpdate++ > 4)
{
TimeSinceUpdate = 0;
UpdateMountCoords();
}
}
void DomeSim::TimerHit()
{
int nexttimer=1000;
if(isConnected() == false) return; // No need to reset timer if we are not connected anymore
if (DomeAbsPosNP.s == IPS_BUSY)
{
if (targetAz > DomeAbsPosN[0].value)
{
DomeAbsPosN[0].value += DOME_SPEED;
}
else if (targetAz < DomeAbsPosN[0].value)
{
DomeAbsPosN[0].value -= DOME_SPEED;
}
DomeAbsPosN[0].value = range360(DomeAbsPosN[0].value);
if (fabs(targetAz - DomeAbsPosN[0].value) <= DOME_SPEED)
{
DomeAbsPosN[0].value = targetAz;
DEBUG(INDI::Logger::DBG_SESSION, "Dome reached requested azimuth angle.");
if (getDomeState() == DOME_PARKING)
SetParked(true);
else if (getDomeState() == DOME_UNPARKING)
SetParked(false);
else
setDomeState(DOME_SYNCED);
}
IDSetNumber(&DomeAbsPosNP, NULL);
}
if (DomeShutterSP.s == IPS_BUSY)
{
if (shutterTimer-- <= 0)
{
shutterTimer=0;
DomeShutterSP.s = IPS_OK;
DEBUGF(INDI::Logger::DBG_SESSION, "Shutter is %s.", (DomeShutterS[0].s == ISS_ON ? "open" : "closed"));
IDSetSwitch(&DomeShutterSP, NULL);
if (getDomeState() == DOME_UNPARKING)
SetParked(false);
}
}
SetTimer(nexttimer);
// Not all mounts update ra/dec constantly if tracking co-ordinates
// This is to ensure our alt/az gets updated even if ra/dec isn't being updated
// Once every 10 seconds is more than sufficient
// with this added, dome simulator will now correctly track telescope simulator
// which does not emit new ra/dec co-ords if they are not changing
if(isParked() == false && TimeSinceUpdate++ > 9)
{
TimeSinceUpdate=0;
UpdateMountCoords();
}
return;
}
bool IEQPro::ReadScopeStatus()
{
bool rc = false;
IEQInfo newInfo;
if (isSimulation())
mountSim();
rc = get_ieqpro_status(PortFD, &newInfo);
if (rc)
{
IUResetSwitch(&GPSStatusSP);
GPSStatusS[newInfo.gpsStatus].s = ISS_ON;
IDSetSwitch(&GPSStatusSP, NULL);
IUResetSwitch(&TimeSourceSP);
TimeSourceS[newInfo.timeSource].s = ISS_ON;
IDSetSwitch(&TimeSourceSP, NULL);
IUResetSwitch(&HemisphereSP);
HemisphereS[newInfo.hemisphere].s = ISS_ON;
IDSetSwitch(&HemisphereSP, NULL);
TelescopeTrackMode trackMode;
switch (newInfo.trackRate)
{
case TR_SIDEREAL:
trackMode = TRACK_SIDEREAL;
break;
case TR_SOLAR:
trackMode = TRACK_SOLAR;
break;
case TR_LUNAR:
trackMode = TRACK_LUNAR;
break;
case TR_KING:
trackMode = TRACK_SIDEREAL;
break;
case TR_CUSTOM:
trackMode = TRACK_CUSTOM;
break;
}
switch (newInfo.systemStatus)
{
case ST_STOPPED:
TrackModeSP.s = IPS_IDLE;
TrackState = SCOPE_IDLE;
break;
case ST_PARKED:
TrackModeSP.s = IPS_IDLE;
TrackState = SCOPE_PARKED;
if (isParked() == false)
SetParked(true);
break;
case ST_HOME:
TrackModeSP.s = IPS_IDLE;
TrackState = SCOPE_IDLE;
break;
case ST_SLEWING:
case ST_MERIDIAN_FLIPPING:
if (TrackState != SCOPE_SLEWING && TrackState != SCOPE_PARKING)
TrackState = SCOPE_SLEWING;
break;
case ST_TRACKING_PEC_OFF:
case ST_TRACKING_PEC_ON:
case ST_GUIDING:
TrackModeSP.s = IPS_BUSY;
TrackState = SCOPE_TRACKING;
if (scopeInfo.systemStatus == ST_SLEWING)
DEBUG(INDI::Logger::DBG_SESSION, "Slew complete, tracking...");
else if (scopeInfo.systemStatus == ST_MERIDIAN_FLIPPING)
DEBUG(INDI::Logger::DBG_SESSION, "Meridian flip complete, tracking...");
break;
}
IUResetSwitch(&TrackModeSP);
TrackModeS[trackMode].s = ISS_ON;
IDSetSwitch(&TrackModeSP, NULL);
scopeInfo = newInfo;
}
rc = get_ieqpro_coords(PortFD, ¤tRA, ¤tDEC);
if (rc)
NewRaDec(currentRA, currentDEC);
return rc;
}
void IEQPro::getStartupData()
{
DEBUG(INDI::Logger::DBG_DEBUG, "Getting firmware data...");
if (get_ieqpro_firmware(PortFD, &firmwareInfo))
{
IUSaveText(&FirmwareT[0], firmwareInfo.Model.c_str());
IUSaveText(&FirmwareT[1], firmwareInfo.MainBoardFirmware.c_str());
IUSaveText(&FirmwareT[2], firmwareInfo.ControllerFirmware.c_str());
IUSaveText(&FirmwareT[3], firmwareInfo.RAFirmware.c_str());
IUSaveText(&FirmwareT[4], firmwareInfo.DEFirmware.c_str());
FirmwareTP.s = IPS_OK;
IDSetText(&FirmwareTP, NULL);
}
DEBUG(INDI::Logger::DBG_DEBUG, "Getting guiding rate...");
double guideRate=0;
if (get_ieqpro_guide_rate(PortFD, &guideRate))
{
GuideRateN[0].value = guideRate;
IDSetNumber(&GuideRateNP, NULL);
}
double HA = ln_get_apparent_sidereal_time(ln_get_julian_from_sys());
double DEC = (HemisphereS[HEMI_NORTH].s == ISS_ON) ? 90 : -90;
if (InitPark())
{
// If loading parking data is successful, we just set the default parking values.
SetAxis1ParkDefault(HA);
SetAxis2ParkDefault(DEC);
}
else
{
// Otherwise, we set all parking data to default in case no parking data is found.
SetAxis1Park(HA);
SetAxis2Park(DEC);
SetAxis1ParkDefault(HA);
SetAxis2ParkDefault(DEC);
}
double utc_offset;
int yy, dd, mm, hh, minute, ss;
if (get_ieqpro_utc_date_time(PortFD, &utc_offset, &yy, &mm, &dd, &hh, &minute, &ss))
{
char isoDateTime[32];
char utcOffset[8];
snprintf(isoDateTime, 32, "%04d-%02d-%02dT%02d:%02d:%02d", yy, mm, dd, hh, minute, ss);
snprintf(utcOffset, 8, "%4.2f", utc_offset);
IUSaveText(IUFindText(&TimeTP, "UTC"), isoDateTime);
IUSaveText(IUFindText(&TimeTP, "OFFSET"), utcOffset);
DEBUGF(INDI::Logger::DBG_SESSION, "Mount UTC offset is %s. UTC time is %s", utcOffset, isoDateTime);
IDSetText(&TimeTP, NULL);
}
// Get Longitude and Latitude from mount
double longitude=0,latitude=0;
if (get_ieqpro_latitude(PortFD, &latitude) && get_ieqpro_longitude(PortFD, &longitude))
{
// Convert to INDI standard longitude (0 to 360 Eastward)
if (longitude < 0)
longitude += 360;
LocationN[LOCATION_LATITUDE].value = latitude;
LocationN[LOCATION_LONGITUDE].value= longitude;
LocationNP.s = IPS_OK;
IDSetNumber(&LocationNP, NULL);
}
if (isSimulation())
{
if (isParked())
set_sim_system_status(ST_PARKED);
else
set_sim_system_status(ST_STOPPED);
}
}
