bool SynscanDriver::UnPark()
{
SetParked(false);
SetTrackMode(m_isAltAz ? 1 : 2);
SetTrackEnabled(true);
return true;
}
bool Paramount::updateProperties()
{
INDI::Telescope::updateProperties();
if (isConnected())
{
if (isTheSkyTracking())
{
IUResetSwitch(&TrackModeSP);
TrackModeS[TRACK_SIDEREAL].s = ISS_ON;
TrackState = SCOPE_TRACKING;
}
else
{
IUResetSwitch(&TrackModeSP);
TrackState = SCOPE_IDLE;
}
//defineSwitch(&TrackModeSP);
//defineNumber(&TrackRateNP);
defineNumber(&JogRateNP);
defineNumber(&GuideNSNP);
defineNumber(&GuideWENP);
defineNumber(&GuideRateNP);
// Initial currentRA and currentDEC to LST and +90 or -90
if (InitPark())
{
// If loading parking data is successful, we just set the default parking values.
SetAxis1ParkDefault(currentRA);
SetAxis2ParkDefault(currentDEC);
}
else
{
// Otherwise, we set all parking data to default in case no parking data is found.
SetAxis1Park(currentRA);
SetAxis2Park(currentDEC);
SetAxis1ParkDefault(currentRA);
SetAxis2ParkDefault(currentDEC);
}
SetParked(isTheSkyParked());
}
else
{
//deleteProperty(TrackModeSP.name);
//deleteProperty(TrackRateNP.name);
deleteProperty(JogRateNP.name);
deleteProperty(GuideNSNP.name);
deleteProperty(GuideWENP.name);
deleteProperty(GuideRateNP.name);
}
return true;
}
void RollOff::TimerHit()
{
if(isConnected() == false) return; // No need to reset timer if we are not connected anymore
if (DomeMotionSP.s == IPS_BUSY)
{
// Abort called
if (MotionRequest < 0)
{
DEBUG(INDI::Logger::DBG_SESSION, "Roof motion is stopped.");
setDomeState(DOME_IDLE);
SetTimer(1000);
return;
}
// Roll off is opening
if (DomeMotionS[DOME_CW].s == ISS_ON)
{
if (getFullOpenedLimitSwitch())
{
DEBUG(INDI::Logger::DBG_SESSION, "Roof is open.");
SetParked(false);
return;
}
}
// Roll Off is closing
else if (DomeMotionS[DOME_CCW].s == ISS_ON)
{
if (getFullClosedLimitSwitch())
{
DEBUG(INDI::Logger::DBG_SESSION, "Roof is closed.");
SetParked(true);
return;
}
}
SetTimer(1000);
}
//SetTimer(1000);
}
bool IEQPro::UnPark()
{
if (unpark_ieqpro(PortFD))
{
SetParked(false);
TrackState = SCOPE_IDLE;
return true;
}
else
return false;
}
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;
}
/************************************************************************************
*
* ***********************************************************************************/
void ScopeDome::TimerHit()
{
if (!isConnected())
return; // No need to reset timer if we are not connected anymore
readU16(GetStatus, currentStatus);
// LOGF_INFO("Status: %x", currentStatus);
UpdatePosition();
UpdateShutterStatus();
IDSetSwitch(&DomeShutterSP, nullptr);
UpdateRelayStatus();
if (status == DOME_HOMING)
{
if ((currentStatus & 8) == 0 && getInputState(IN_HOME))
{
// Found home
status = DOME_READY;
targetAz = DomeHomePositionN[0].value;
// Reset counter
writeCmd(ResetCounter);
FindHomeSP.s = IPS_OK;
DomeAbsPosNP.s = IPS_OK;
IDSetSwitch(&FindHomeSP, nullptr);
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else if (status == DOME_DEROTATING)
{
if ((currentStatus & 2) == 0)
{
readS32(GetCounterExt, currentRotation);
LOGF_INFO("Current rotation is %d", currentRotation);
if (abs(currentRotation) < 100)
{
// Close enough
status = DOME_READY;
DerotateSP.s = IPS_OK;
DomeAbsPosNP.s = IPS_OK;
IDSetSwitch(&DerotateSP, nullptr);
}
else
{
if (currentRotation < 0)
{
writeU16(CCWRotation, compensateInertia(-currentRotation));
}
else
{
writeU16(CWRotation, compensateInertia(currentRotation));
}
}
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else if (DomeAbsPosNP.s == IPS_BUSY)
{
if ((currentStatus & 2) == 0)
{
// Rotation idle, are we close enough?
double azDiff = targetAz - DomeAbsPosN[0].value;
if (azDiff > 180)
{
azDiff -= 360;
}
if (azDiff < -180)
{
azDiff += 360;
}
if (fabs(azDiff) <= DomeParamN[0].value)
{
DomeAbsPosN[0].value = targetAz;
DomeAbsPosNP.s = IPS_OK;
LOG_INFO("Dome reached requested azimuth angle.");
if (getDomeState() == DOME_PARKING)
{
if (ParkShutterS[0].s == ISS_ON && getInputState(IN_CLOSED1) == ISS_OFF)
{
ControlShutter(SHUTTER_CLOSE);
}
else
{
SetParked(true);
}
}
else if (getDomeState() == DOME_UNPARKING)
SetParked(false);
else
setDomeState(DOME_SYNCED);
}
else
{
// Refine azimuth
MoveAbs(targetAz);
}
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else
IDSetNumber(&DomeAbsPosNP, nullptr);
// Read temperatures only every 10th time
static int tmpCounter = 0;
if (--tmpCounter <= 0)
{
UpdateSensorStatus();
tmpCounter = 10;
}
SetTimer(POLLMS);
}
/************************************************************************************
*
* ***********************************************************************************/
bool ScopeDome::UpdateShutterStatus()
{
int rc = readBuffer(GetAllDigitalExt, 5, digitalSensorState);
if (rc != 0)
{
LOGF_ERROR("Error reading input state: %d", rc);
return false;
}
// LOGF_INFO("digitalext %x %x %x %x %x", digitalSensorState[0],
// digitalSensorState[1], digitalSensorState[2], digitalSensorState[3],
// digitalSensorState[4]);
SensorsS[0].s = getInputState(IN_ENCODER);
SensorsS[1].s = ISS_OFF; // ?
SensorsS[2].s = getInputState(IN_HOME);
SensorsS[3].s = getInputState(IN_OPEN1);
SensorsS[4].s = getInputState(IN_CLOSED1);
SensorsS[5].s = getInputState(IN_OPEN2);
SensorsS[6].s = getInputState(IN_CLOSED2);
SensorsS[7].s = getInputState(IN_S_HOME);
SensorsS[8].s = getInputState(IN_CLOUDS);
SensorsS[9].s = getInputState(IN_CLOUD);
SensorsS[10].s = getInputState(IN_SAFE);
SensorsS[11].s = getInputState(IN_ROT_LINK);
SensorsS[12].s = getInputState(IN_FREE);
SensorsSP.s = IPS_OK;
IDSetSwitch(&SensorsSP, nullptr);
DomeShutterSP.s = IPS_OK;
IUResetSwitch(&DomeShutterSP);
if (getInputState(IN_OPEN1) == ISS_ON) // shutter open switch triggered
{
if (shutterState == SHUTTER_MOVING && targetShutter == SHUTTER_OPEN)
{
LOGF_INFO("%s", GetShutterStatusString(SHUTTER_OPENED));
setOutputState(OUT_OPEN1, ISS_OFF);
shutterState = SHUTTER_OPENED;
if (getDomeState() == DOME_UNPARKING)
SetParked(false);
}
DomeShutterS[SHUTTER_OPEN].s = ISS_ON;
}
else if (getInputState(IN_CLOSED1) == ISS_ON) // shutter closed switch triggered
{
if (shutterState == SHUTTER_MOVING && targetShutter == SHUTTER_CLOSE)
{
LOGF_INFO("%s", GetShutterStatusString(SHUTTER_CLOSED));
setOutputState(OUT_CLOSE1, ISS_OFF);
shutterState = SHUTTER_CLOSED;
if (getDomeState() == DOME_PARKING && DomeAbsPosNP.s != IPS_BUSY)
{
SetParked(true);
}
}
DomeShutterS[SHUTTER_CLOSE].s = ISS_ON;
}
else
{
shutterState = SHUTTER_MOVING;
DomeShutterSP.s = IPS_BUSY;
}
return true;
}
bool ScopeSim::UnPark()
{
SetParked(false);
return true;
}
bool ScopeSim::ReadScopeStatus()
{
static struct timeval ltv { 0, 0 };
struct timeval tv { 0, 0 };
double dt = 0, da_ra = 0, da_dec = 0, dx = 0, dy = 0, ra_guide_dt = 0, dec_guide_dt = 0;
static double last_dx = 0, last_dy = 0;
int nlocked, ns_guide_dir = -1, we_guide_dir = -1;
char RA_DISP[64], DEC_DISP[64], RA_GUIDE[64], DEC_GUIDE[64], RA_PE[64], DEC_PE[64], RA_TARGET[64], DEC_TARGET[64];
/* update elapsed time since last poll, don't presume exactly POLLMS */
gettimeofday(&tv, nullptr);
if (ltv.tv_sec == 0 && ltv.tv_usec == 0)
ltv = tv;
dt = tv.tv_sec - ltv.tv_sec + (tv.tv_usec - ltv.tv_usec) / 1e6;
ltv = tv;
if (fabs(targetRA - currentRA) * 15. >= GOTO_LIMIT)
da_ra = GOTO_RATE * dt;
else if (fabs(targetRA - currentRA) * 15. >= SLEW_LIMIT)
da_ra = SLEW_RATE * dt;
else
da_ra = FINE_SLEW_RATE * dt;
if (fabs(targetDEC - currentDEC) >= GOTO_LIMIT)
da_dec = GOTO_RATE * dt;
else if (fabs(targetDEC - currentDEC) >= SLEW_LIMIT)
da_dec = SLEW_RATE * dt;
else
da_dec = FINE_SLEW_RATE * dt;
if (MovementNSSP.s == IPS_BUSY || MovementWESP.s == IPS_BUSY)
{
int rate = IUFindOnSwitchIndex(&SlewRateSP);
switch (rate)
{
case SLEW_GUIDE:
da_ra = FINE_SLEW_RATE * dt * 0.05;
da_dec = FINE_SLEW_RATE * dt * 0.05;
break;
case SLEW_CENTERING:
da_ra = FINE_SLEW_RATE * dt * .1;
da_dec = FINE_SLEW_RATE * dt * .1;
break;
case SLEW_FIND:
da_ra = SLEW_RATE * dt;
da_dec = SLEW_RATE * dt;
break;
default:
da_ra = GOTO_RATE * dt;
da_dec = GOTO_RATE * dt;
break;
}
switch (MovementNSSP.s)
{
case IPS_BUSY:
if (MovementNSS[DIRECTION_NORTH].s == ISS_ON)
currentDEC += da_dec;
else if (MovementNSS[DIRECTION_SOUTH].s == ISS_ON)
currentDEC -= da_dec;
break;
default:
break;
}
switch (MovementWESP.s)
{
case IPS_BUSY:
if (MovementWES[DIRECTION_WEST].s == ISS_ON)
currentRA += da_ra / 15.;
else if (MovementWES[DIRECTION_EAST].s == ISS_ON)
currentRA -= da_ra / 15.;
break;
default:
break;
}
NewRaDec(currentRA, currentDEC);
return true;
}
/* Process per current state. We check the state of EQUATORIAL_EOD_COORDS_REQUEST and act acoordingly */
switch (TrackState)
{
/*case SCOPE_IDLE:
EqNP.s = IPS_IDLE;
break;*/
case SCOPE_SLEWING:
case SCOPE_PARKING:
/* slewing - nail it when both within one pulse @ SLEWRATE */
nlocked = 0;
dx = targetRA - currentRA;
// Always take the shortcut, don't go all around the globe
// If the difference between target and current is more than 12 hours, then we need to take the shortest path
if (dx > 12)
dx -= 24;
else if (dx < -12)
dx += 24;
// In meridian flip, alway force eastward motion (increasing RA) until target is reached.
if (forceMeridianFlip)
{
dx = fabs(dx);
if (dx == 0)
{
dx = 1;
da_ra = GOTO_LIMIT;
}
}
if (fabs(dx) * 15. <= da_ra)
{
currentRA = targetRA;
nlocked++;
}
else if (dx > 0)
currentRA += da_ra / 15.;
else
currentRA -= da_ra / 15.;
currentRA = range24(currentRA);
dy = targetDEC - currentDEC;
if (fabs(dy) <= da_dec)
{
currentDEC = targetDEC;
nlocked++;
}
else if (dy > 0)
currentDEC += da_dec;
else
currentDEC -= da_dec;
EqNP.s = IPS_BUSY;
if (nlocked == 2)
{
forceMeridianFlip = false;
if (TrackState == SCOPE_SLEWING)
{
// Initially no PE in both axis.
EqPEN[0].value = currentRA;
EqPEN[1].value = currentDEC;
IDSetNumber(&EqPENV, nullptr);
TrackState = SCOPE_TRACKING;
EqNP.s = IPS_OK;
DEBUG(INDI::Logger::DBG_SESSION, "Telescope slew is complete. Tracking...");
}
else
{
SetParked(true);
EqNP.s = IPS_IDLE;
}
}
break;
case SCOPE_IDLE:
//currentRA += (TRACKRATE_SIDEREAL/3600.0 * dt) / 15.0;
currentRA += (TrackRateN[AXIS_RA].value/3600.0 * dt) / 15.0;
currentRA = range24(currentRA);
break;
case SCOPE_TRACKING:
// In case of custom tracking rate
if (TrackModeS[1].s == ISS_ON)
{
currentRA += ( ((TRACKRATE_SIDEREAL/3600.0) - (TrackRateN[AXIS_RA].value/3600.0)) * dt) / 15.0;
currentDEC += ( (TrackRateN[AXIS_DE].value/3600.0) * dt);
}
dt *= 1000;
if (guiderNSTarget[GUIDE_NORTH] > 0)
{
DEBUGF(INDI::Logger::DBG_DEBUG, "Commanded to GUIDE NORTH for %g ms", guiderNSTarget[GUIDE_NORTH]);
ns_guide_dir = GUIDE_NORTH;
}
else if (guiderNSTarget[GUIDE_SOUTH] > 0)
{
DEBUGF(INDI::Logger::DBG_DEBUG, "Commanded to GUIDE SOUTH for %g ms", guiderNSTarget[GUIDE_SOUTH]);
ns_guide_dir = GUIDE_SOUTH;
}
// WE Guide Selection
if (guiderEWTarget[GUIDE_WEST] > 0)
{
we_guide_dir = GUIDE_WEST;
DEBUGF(INDI::Logger::DBG_DEBUG, "Commanded to GUIDE WEST for %g ms", guiderEWTarget[GUIDE_WEST]);
}
else if (guiderEWTarget[GUIDE_EAST] > 0)
{
we_guide_dir = GUIDE_EAST;
DEBUGF(INDI::Logger::DBG_DEBUG, "Commanded to GUIDE EAST for %g ms", guiderEWTarget[GUIDE_EAST]);
}
if (ns_guide_dir != -1)
{
dec_guide_dt = TrackRateN[AXIS_RA].value/3600.0 * GuideRateN[DEC_AXIS].value * guiderNSTarget[ns_guide_dir] / 1000.0 *
(ns_guide_dir == GUIDE_NORTH ? 1 : -1);
// If time remaining is more that dt, then decrement and
if (guiderNSTarget[ns_guide_dir] >= dt)
guiderNSTarget[ns_guide_dir] -= dt;
else
guiderNSTarget[ns_guide_dir] = 0;
if (guiderNSTarget[ns_guide_dir] == 0)
{
GuideNSNP.s = IPS_IDLE;
IDSetNumber(&GuideNSNP, nullptr);
}
EqPEN[DEC_AXIS].value += dec_guide_dt;
}
if (we_guide_dir != -1)
{
ra_guide_dt = (TrackRateN[AXIS_RA].value/3600.0) / 15.0 * GuideRateN[RA_AXIS].value * guiderEWTarget[we_guide_dir] / 1000.0 *
(we_guide_dir == GUIDE_WEST ? -1 : 1);
if (guiderEWTarget[we_guide_dir] >= dt)
guiderEWTarget[we_guide_dir] -= dt;
else
guiderEWTarget[we_guide_dir] = 0;
if (guiderEWTarget[we_guide_dir] == 0)
{
GuideWENP.s = IPS_IDLE;
IDSetNumber(&GuideWENP, nullptr);
}
EqPEN[RA_AXIS].value += ra_guide_dt;
}
//Mention the followng:
// Current RA displacemet and direction
// Current DEC displacement and direction
// Amount of RA GUIDING correction and direction
// Amount of DEC GUIDING correction and direction
dx = EqPEN[RA_AXIS].value - targetRA;
dy = EqPEN[DEC_AXIS].value - targetDEC;
fs_sexa(RA_DISP, fabs(dx), 2, 3600);
fs_sexa(DEC_DISP, fabs(dy), 2, 3600);
fs_sexa(RA_GUIDE, fabs(ra_guide_dt), 2, 3600);
fs_sexa(DEC_GUIDE, fabs(dec_guide_dt), 2, 3600);
fs_sexa(RA_PE, EqPEN[RA_AXIS].value, 2, 3600);
fs_sexa(DEC_PE, EqPEN[DEC_AXIS].value, 2, 3600);
fs_sexa(RA_TARGET, targetRA, 2, 3600);
fs_sexa(DEC_TARGET, targetDEC, 2, 3600);
if (dx != last_dx || dy != last_dy || ra_guide_dt != 0.0 || dec_guide_dt != 0.0)
{
last_dx = dx;
last_dy = dy;
//DEBUGF(INDI::Logger::DBG_DEBUG, "dt is %g\n", dt);
DEBUGF(INDI::Logger::DBG_DEBUG, "RA Displacement (%c%s) %s -- %s of target RA %s", dx >= 0 ? '+' : '-',
RA_DISP, RA_PE, (EqPEN[RA_AXIS].value - targetRA) > 0 ? "East" : "West", RA_TARGET);
DEBUGF(INDI::Logger::DBG_DEBUG, "DEC Displacement (%c%s) %s -- %s of target RA %s", dy >= 0 ? '+' : '-',
DEC_DISP, DEC_PE, (EqPEN[DEC_AXIS].value - targetDEC) > 0 ? "North" : "South", DEC_TARGET);
DEBUGF(INDI::Logger::DBG_DEBUG, "RA Guide Correction (%g) %s -- Direction %s", ra_guide_dt, RA_GUIDE,
ra_guide_dt > 0 ? "East" : "West");
DEBUGF(INDI::Logger::DBG_DEBUG, "DEC Guide Correction (%g) %s -- Direction %s", dec_guide_dt, DEC_GUIDE,
dec_guide_dt > 0 ? "North" : "South");
}
if (ns_guide_dir != -1 || we_guide_dir != -1)
IDSetNumber(&EqPENV, nullptr);
break;
default:
break;
}
char RAStr[64], DecStr[64];
fs_sexa(RAStr, currentRA, 2, 3600);
fs_sexa(DecStr, currentDEC, 2, 3600);
DEBUGF(DBG_SCOPE, "Current RA: %s Current DEC: %s", RAStr, DecStr);
NewRaDec(currentRA, currentDEC);
return true;
}
void ioptronHC8406::mountSim()
{
static struct timeval ltv;
struct timeval tv;
double dt, da, dx;
int nlocked;
/* update elapsed time since last poll, don't presume exactly POLLMS */
gettimeofday(&tv, nullptr);
if (ltv.tv_sec == 0 && ltv.tv_usec == 0)
ltv = tv;
dt = tv.tv_sec - ltv.tv_sec + (tv.tv_usec - ltv.tv_usec) / 1e6;
ltv = tv;
da = SLEWRATE * dt;
/* Process per current state. We check the state of EQUATORIAL_COORDS and act acoordingly */
switch (TrackState)
{
case SCOPE_TRACKING:
/* RA moves at sidereal, Dec stands still */
currentRA += (SIDRATE * dt / 15.);
break;
case SCOPE_SLEWING:
case SCOPE_PARKING:
/* slewing - nail it when both within one pulse @ SLEWRATE */
nlocked = 0;
dx = targetRA - currentRA;
if (fabs(dx) <= da)
{
currentRA = targetRA;
nlocked++;
}
else if (dx > 0)
currentRA += da / 15.;
else
currentRA -= da / 15.;
dx = targetDEC - currentDEC;
if (fabs(dx) <= da)
{
currentDEC = targetDEC;
nlocked++;
}
else if (dx > 0)
currentDEC += da;
else
currentDEC -= da;
if (nlocked == 2)
{
if (TrackState == SCOPE_SLEWING)
TrackState = SCOPE_TRACKING;
else
SetParked(true);
}
break;
default:
break;
}
NewRaDec(currentRA, currentDEC);
}
bool ioptronHC8406::UnPark()
{
SetParked(false);
return true;
}
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 BaaderDome::TimerHit()
{
if (!isConnected())
return; // No need to reset timer if we are not connected anymore
UpdatePosition();
if (DomeAbsPosNP.s == IPS_BUSY)
{
if (sim)
{
double speed = 0;
if (fabs(targetAz - DomeAbsPosN[0].value) > SIM_DOME_HI_SPEED)
speed = SIM_DOME_HI_SPEED;
else
speed = SIM_DOME_LO_SPEED;
if (DomeRelPosNP.s == IPS_BUSY)
{
// CW
if (DomeMotionS[0].s == ISS_ON)
DomeAbsPosN[0].value += speed;
// CCW
else
DomeAbsPosN[0].value -= speed;
}
else
{
if (targetAz > DomeAbsPosN[0].value)
{
DomeAbsPosN[0].value += speed;
}
else if (targetAz < DomeAbsPosN[0].value)
{
DomeAbsPosN[0].value -= speed;
}
}
if (DomeAbsPosN[0].value < DomeAbsPosN[0].min)
DomeAbsPosN[0].value += DomeAbsPosN[0].max;
if (DomeAbsPosN[0].value > DomeAbsPosN[0].max)
DomeAbsPosN[0].value -= DomeAbsPosN[0].max;
}
if (fabs(targetAz - DomeAbsPosN[0].value) < DomeParamN[0].value)
{
DomeAbsPosN[0].value = targetAz;
DEBUG(INDI::Logger::DBG_SESSION, "Dome reached requested azimuth angle.");
if (status != DOME_CALIBRATING)
{
if (getDomeState() == DOME_PARKING)
SetParked(true);
else if (getDomeState() == DOME_UNPARKING)
SetParked(false);
else
setDomeState(DOME_SYNCED);
}
if (status == DOME_CALIBRATING)
{
if (calibrationStage == CALIBRATION_STAGE1)
{
DEBUG(INDI::Logger::DBG_SESSION, "Calibration stage 1 complete. Starting stage 2...");
calibrationTarget2 = DomeAbsPosN[0].value + 2;
calibrationStage = CALIBRATION_STAGE2;
MoveAbs(calibrationTarget2);
DomeAbsPosNP.s = IPS_BUSY;
}
else if (calibrationStage == CALIBRATION_STAGE2)
{
DEBUGF(INDI::Logger::DBG_SESSION,
"Calibration stage 2 complete. Returning to initial position %g...", calibrationStart);
calibrationStage = CALIBRATION_STAGE3;
MoveAbs(calibrationStart);
DomeAbsPosNP.s = IPS_BUSY;
}
else if (calibrationStage == CALIBRATION_STAGE3)
{
calibrationStage = CALIBRATION_COMPLETE;
DEBUG(INDI::Logger::DBG_SESSION, "Dome reached initial position.");
}
}
}
IDSetNumber(&DomeAbsPosNP, nullptr);
}
else
IDSetNumber(&DomeAbsPosNP, nullptr);
UpdateShutterStatus();
if (sim && DomeShutterSP.s == IPS_BUSY)
{
if (simShutterTimer-- <= 0)
{
simShutterTimer = 0;
simShutterStatus = (targetShutter == SHUTTER_OPEN) ? SHUTTER_OPENED : SHUTTER_CLOSED;
}
}
else
IDSetSwitch(&DomeShutterSP, nullptr);
UpdateFlapStatus();
if (sim && DomeFlapSP.s == IPS_BUSY)
{
if (simFlapTimer-- <= 0)
{
simFlapTimer = 0;
simFlapStatus = (targetFlap == FLAP_OPEN) ? FLAP_OPENED : FLAP_CLOSED;
}
}
else
IDSetSwitch(&DomeFlapSP, nullptr);
SetTimer(POLLMS);
}
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 SynscanDriver::ReadScopeStatus()
{
if (isSimulation())
{
mountSim();
return true;
}
char res[SYN_RES] = {0};
// Goto in progress?
if (sendCommand("L", res))
m_MountInfo[MI_GOTO_STATUS] = res[0];
// Pier side
if (m_isAltAz == false && sendCommand("p", res))
{
m_MountInfo[MI_POINT_STATUS] = res[0];
// INDI and mount pier sides are opposite to each other
setPierSide(res[0] == 'W' ? PIER_EAST : PIER_WEST);
}
if (readTracking())
{
if (TrackState == SCOPE_SLEWING)
{
if (isSlewComplete())
{
TrackState = (m_TrackingFlag == 2) ? SCOPE_TRACKING : SCOPE_IDLE;
HorizontalCoordsNP.s = (m_TrackingFlag == 2) ? IPS_OK : IPS_IDLE;
IDSetNumber(&HorizontalCoordsNP, nullptr);
}
}
else if (TrackState == SCOPE_PARKING)
{
if (isSlewComplete())
{
HorizontalCoordsNP.s = IPS_IDLE;
IDSetNumber(&HorizontalCoordsNP, nullptr);
TrackState = SCOPE_PARKED;
SetTrackEnabled(false);
SetParked(true);
}
}
else if (TrackState == SCOPE_IDLE && m_TrackingFlag > 0)
TrackState = SCOPE_TRACKING;
else if (TrackState == SCOPE_TRACKING && m_TrackingFlag == 0)
TrackState = SCOPE_IDLE;
}
sendStatus();
// Get Precise RA/DE
memset(res, 0, SYN_RES);
if (!sendCommand("e", res))
return false;
uint32_t n1 = 0, n2 = 0;
sscanf(res, "%x,%x#", &n1, &n2);
double ra = static_cast<double>(n1) / 0x100000000 * 360.0;
double de = static_cast<double>(n2) / 0x100000000 * 360.0;
ln_equ_posn epochPos { 0, 0 }, J2000Pos { 0, 0 };
J2000Pos.ra = range360(ra);
J2000Pos.dec = rangeDec(de);
// Synscan reports J2000 coordinates so we need to convert from J2000 to JNow
ln_get_equ_prec2(&J2000Pos, JD2000, ln_get_julian_from_sys(), &epochPos);
CurrentRA = epochPos.ra / 15.0;
CurrentDE = epochPos.dec;
char Axis1Coords[MAXINDINAME] = {0}, Axis2Coords[MAXINDINAME] = {0};
fs_sexa(Axis1Coords, J2000Pos.ra / 15.0, 2, 3600);
fs_sexa(Axis2Coords, J2000Pos.dec, 2, 3600);
LOGF_DEBUG("J2000 RA <%s> DE <%s>", Axis1Coords, Axis2Coords);
memset(Axis1Coords, 0, MAXINDINAME);
memset(Axis2Coords, 0, MAXINDINAME);
fs_sexa(Axis1Coords, CurrentRA, 2, 3600);
fs_sexa(Axis2Coords, CurrentDE, 2, 3600);
LOGF_DEBUG("JNOW RA <%s> DE <%s>", Axis1Coords, Axis2Coords);
// Now feed the rest of the system with corrected data
NewRaDec(CurrentRA, CurrentDE);
// Get precise az/alt
memset(res, 0, SYN_RES);
if (!sendCommand("z", res))
return false;
sscanf(res, "%x,%x#", &n1, &n2);
double az = static_cast<double>(n1) / 0x100000000 * 360.0;
double al = static_cast<double>(n2) / 0x100000000 * 360.0;
al = rangeDec(al);
HorizontalCoordsN[AXIS_AZ].value = az;
HorizontalCoordsN[AXIS_ALT].value = al;
memset(Axis1Coords, 0, MAXINDINAME);
memset(Axis2Coords, 0, MAXINDINAME);
fs_sexa(Axis1Coords, az, 2, 3600);
fs_sexa(Axis2Coords, al, 2, 3600);
LOGF_DEBUG("AZ <%s> ALT <%s>", Axis1Coords, Axis2Coords);
IDSetNumber(&HorizontalCoordsNP, nullptr);
return true;
}
bool ioptronHC8406::ReadScopeStatus()
{
//return true; //for debug
if (!isConnected())
return false;
if (isSimulation())
{
mountSim();
return true;
}
switch (TrackState) {
case SCOPE_IDLE:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> IDLE");
break;
case SCOPE_SLEWING:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> SLEWING");
break;
case SCOPE_TRACKING:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> TRACKING");
break;
case SCOPE_PARKING:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> PARKING");
break;
case SCOPE_PARKED:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> PARKED");
break;
default:
DEBUG(INDI::Logger::DBG_WARNING, "<ReadScopeStatus> UNDEFINED");
break;
}
if (TrackState == SCOPE_SLEWING )
{
// Check if LX200 is done slewing
if (isSlewComplete())
{
usleep(1000000); //Wait until :MS# finish
if (IUFindSwitch(&CoordSP, "SYNC")->s == ISS_ON || IUFindSwitch(&CoordSP, "SLEW")->s == ISS_ON) {
TrackState = SCOPE_IDLE;
DEBUG(INDI::Logger::DBG_WARNING, "Slew is complete. IDLE");
SetTrackEnabled(false);
} else {
TrackState = SCOPE_TRACKING;
DEBUG(INDI::Logger::DBG_WARNING, "Slew is complete. TRACKING");
SetTrackEnabled(true);
}
}
}
else if (TrackState == SCOPE_PARKING)
{
// isSlewComplete() not work because is base on actual RA/DEC vs target RA/DEC. DO ALWAYS
if (true || isSlewComplete())
{
SetParked(true);
TrackState = SCOPE_PARKED;
}
}
if (getLX200RA(PortFD, ¤tRA) < 0 || getLX200DEC(PortFD, ¤tDEC) < 0)
{
EqNP.s = IPS_ALERT;
IDSetNumber(&EqNP, "Error reading RA/DEC.");
return false;
}
NewRaDec(currentRA, currentDEC);
//sendScopeTime();
//syncSideOfPier();
return true;
}
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;
}
