/************************************************************************************
*
* ***********************************************************************************/
IPState ScopeDome::MoveRel(double azDiff)
{
targetAz = DomeAbsPosN[0].value + azDiff;
if (targetAz < DomeAbsPosN[0].min)
targetAz += DomeAbsPosN[0].max;
if (targetAz > DomeAbsPosN[0].max)
targetAz -= DomeAbsPosN[0].max;
// It will take a few cycles to reach final position
return MoveAbs(targetAz);
}
/************************************************************************************
*
* ***********************************************************************************/
IPState ScopeDome::Park()
{
// First move to park position and then optionally close shutter
targetAz = GetAxis1Park();
IPState s = MoveAbs(targetAz);
if (s == IPS_OK && ParkShutterS[0].s == ISS_ON)
{
// Already at home, just close if needed
return ControlShutter(SHUTTER_CLOSE);
}
return s;
}
/************************************************************************************
*
* ***********************************************************************************/
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 BaaderDome::Abort()
{
DEBUGF(INDI::Logger::DBG_SESSION, "Attempting to abort dome motion by stopping at %g", DomeAbsPosN[0].value);
MoveAbs(DomeAbsPosN[0].value);
return true;
}
/************************************************************************************
*
* ***********************************************************************************/
IPState BaaderDome::Park()
{
targetAz = GetAxis1Park();
return MoveAbs(targetAz);
}
/************************************************************************************
*
* ***********************************************************************************/
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);
}
/************************************************************************************
*
* ***********************************************************************************/
bool BaaderDome::ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n)
{
if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)
{
if (strcmp(name, CalibrateSP.name) == 0)
{
IUResetSwitch(&CalibrateSP);
if (status == DOME_READY)
{
CalibrateSP.s = IPS_OK;
DEBUG(INDI::Logger::DBG_SESSION, "Dome is already calibrated.");
IDSetSwitch(&CalibrateSP, nullptr);
return true;
}
if (CalibrateSP.s == IPS_BUSY)
{
Abort();
DEBUG(INDI::Logger::DBG_SESSION, "Calibration aborted.");
status = DOME_UNKNOWN;
CalibrateSP.s = IPS_IDLE;
IDSetSwitch(&CalibrateSP, nullptr);
return true;
}
status = DOME_CALIBRATING;
DEBUG(INDI::Logger::DBG_SESSION, "Starting calibration procedure...");
calibrationStage = CALIBRATION_STAGE1;
calibrationStart = DomeAbsPosN[0].value;
// Goal of procedure is to reach south point to hit sensor
calibrationTarget1 = calibrationStart + 179;
if (calibrationTarget1 > 360)
calibrationTarget1 -= 360;
if (MoveAbs(calibrationTarget1) == IPS_IDLE)
{
CalibrateSP.s = IPS_ALERT;
DEBUG(INDI::Logger::DBG_ERROR, "Calibration failue due to dome motion failure.");
status = DOME_UNKNOWN;
IDSetSwitch(&CalibrateSP, nullptr);
return false;
}
DomeAbsPosNP.s = IPS_BUSY;
CalibrateSP.s = IPS_BUSY;
DEBUGF(INDI::Logger::DBG_SESSION, "Calibration is in progress. Moving to position %g.", calibrationTarget1);
IDSetSwitch(&CalibrateSP, nullptr);
return true;
}
if (strcmp(name, DomeFlapSP.name) == 0)
{
int ret = 0;
int prevStatus = IUFindOnSwitchIndex(&DomeFlapSP);
IUUpdateSwitch(&DomeFlapSP, states, names, n);
int FlapDome = IUFindOnSwitchIndex(&DomeFlapSP);
// No change of status, let's return
if (prevStatus == FlapDome)
{
DomeFlapSP.s = IPS_OK;
IDSetSwitch(&DomeFlapSP, nullptr);
}
// go back to prev status in case of failure
IUResetSwitch(&DomeFlapSP);
DomeFlapS[prevStatus].s = ISS_ON;
if (FlapDome == 0)
ret = ControlDomeFlap(FLAP_OPEN);
else
ret = ControlDomeFlap(FLAP_CLOSE);
if (ret == 0)
{
DomeFlapSP.s = IPS_OK;
IUResetSwitch(&DomeFlapSP);
DomeFlapS[FlapDome].s = ISS_ON;
IDSetSwitch(&DomeFlapSP, "Flap is %s.", (FlapDome == 0 ? "open" : "closed"));
return true;
}
else if (ret == 1)
{
DomeFlapSP.s = IPS_BUSY;
IUResetSwitch(&DomeFlapSP);
DomeFlapS[FlapDome].s = ISS_ON;
IDSetSwitch(&DomeFlapSP, "Flap is %s...", (FlapDome == 0 ? "opening" : "closing"));
return true;
}
DomeFlapSP.s = IPS_ALERT;
IDSetSwitch(&DomeFlapSP, "Flap failed to %s.", (FlapDome == 0 ? "open" : "close"));
return false;
}
}
return INDI::Dome::ISNewSwitch(dev, name, states, names, n);
}
