Changeset View
Changeset View
Standalone View
Standalone View
kstars/ekos/capture/capture.cpp
| Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Line(s) | |||||
| 51 | { | 51 | { | ||
| 52 | setupUi(this); | 52 | setupUi(this); | ||
| 53 | 53 | | |||
| 54 | qRegisterMetaType<Ekos::CaptureState>("Ekos::CaptureState"); | 54 | qRegisterMetaType<Ekos::CaptureState>("Ekos::CaptureState"); | ||
| 55 | qDBusRegisterMetaType<Ekos::CaptureState>(); | 55 | qDBusRegisterMetaType<Ekos::CaptureState>(); | ||
| 56 | 56 | | |||
| 57 | new CaptureAdaptor(this); | 57 | new CaptureAdaptor(this); | ||
| 58 | QDBusConnection::sessionBus().registerObject("/KStars/Ekos/Capture", this); | 58 | QDBusConnection::sessionBus().registerObject("/KStars/Ekos/Capture", this); | ||
| 59 | QPointer<QDBusInterface> ekosInterface = new QDBusInterface("org.kde.kstars", "/KStars/Ekos", "org.kde.kstars.Ekos", | ||||
| 60 | QDBusConnection::sessionBus(), this); | ||||
| 61 | | ||||
| 62 | // Connecting DBus signals | ||||
| 63 | connect(ekosInterface, SIGNAL(newModule(QString)), this, SLOT(registerNewModule(QString))); | ||||
| 64 | | ||||
| 65 | // ensure that the mount interface is present | ||||
| 66 | registerNewModule("Mount"); | ||||
mutlaqja: Why are you initializing it here and then again in registerNewModule? | |||||
I am not sure what happens, if the interface is created before the mount module has registered at the DBus. Therefore I capture both situations with this construct:
wreissenberger: I am not sure what happens, if the interface is created **before** the mount module has… | |||||
Ok, not sure if in this instance using delete(mountInterface) in registerNewModule is required to free memory? The class is a child of "this" but not sure what happens when another "new" is used without deleting the first one. mutlaqja: Ok, not sure if in this instance using delete(mountInterface) in registerNewModule is required… | |||||
| 67 | | ||||
| 59 | 68 | | |||
| 60 | KStarsData::Instance()->userdb()->GetAllDSLRInfos(DSLRInfos); | 69 | KStarsData::Instance()->userdb()->GetAllDSLRInfos(DSLRInfos); | ||
| 61 | 70 | | |||
| 62 | dirPath = QUrl::fromLocalFile(QDir::homePath()); | 71 | dirPath = QUrl::fromLocalFile(QDir::homePath()); | ||
| 63 | 72 | | |||
| 64 | //isAutoGuiding = false; | 73 | //isAutoGuiding = false; | ||
| 65 | 74 | | |||
| 66 | rotatorSettings.reset(new RotatorSettings(this)); | 75 | rotatorSettings.reset(new RotatorSettings(this)); | ||
| ▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Line(s) | 368 | { | |||
| 360 | start(); | 369 | start(); | ||
| 361 | } | 370 | } | ||
| 362 | else | 371 | else | ||
| 363 | { | 372 | { | ||
| 364 | abort(); | 373 | abort(); | ||
| 365 | } | 374 | } | ||
| 366 | } | 375 | } | ||
| 367 | 376 | | |||
| 377 | | ||||
| 378 | void Capture::registerNewModule(const QString &name) | ||||
| 379 | { | ||||
| 380 | if (name == "Mount") | ||||
| 381 | { | ||||
| 382 | if (mountInterface != nullptr) | ||||
| 383 | delete mountInterface; | ||||
| 384 | mountInterface = new QDBusInterface("org.kde.kstars", "/KStars/Ekos/Mount", "org.kde.kstars.Ekos.Mount", | ||||
| 385 | QDBusConnection::sessionBus(), this); | ||||
| 386 | } | ||||
| 387 | | ||||
| 388 | } | ||||
| 389 | | ||||
| 390 | | ||||
| 391 | | ||||
| 368 | void Capture::start() | 392 | void Capture::start() | ||
| 369 | { | 393 | { | ||
| 370 | if (darkSubCheck->isChecked()) | 394 | if (darkSubCheck->isChecked()) | ||
| 371 | { | 395 | { | ||
| 372 | KMessageBox::error(this, i18n("Auto dark subtract is not supported in batch mode.")); | 396 | KMessageBox::error(this, i18n("Auto dark subtract is not supported in batch mode.")); | ||
| 373 | return; | 397 | return; | ||
| 374 | } | 398 | } | ||
| 375 | 399 | | |||
| ▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Line(s) | |||||
| 434 | // Scheduler will never ignore job progress and doesn't use this path | 458 | // Scheduler will never ignore job progress and doesn't use this path | ||
| 435 | else if (ignoreJobProgress) | 459 | else if (ignoreJobProgress) | ||
| 436 | { | 460 | { | ||
| 437 | appendLogText(i18n("Warning: option \"Always Reset Sequence When Starting\" is enabled and resets the sequence counts.")); | 461 | appendLogText(i18n("Warning: option \"Always Reset Sequence When Starting\" is enabled and resets the sequence counts.")); | ||
| 438 | foreach (SequenceJob *job, jobs) | 462 | foreach (SequenceJob *job, jobs) | ||
| 439 | job->resetStatus(); | 463 | job->resetStatus(); | ||
| 440 | } | 464 | } | ||
| 441 | 465 | | |||
| 442 | // Record initialHA and initialMount position when we are starting fresh | | |||
| 443 | // If recovering from deviation error, these values should not be recorded. | | |||
| 444 | // Refocus timer should not be reset on deviation error | 466 | // Refocus timer should not be reset on deviation error | ||
| 445 | if (m_DeviationDetected == false && m_State != CAPTURE_SUSPENDED) | 467 | if (m_DeviationDetected == false && m_State != CAPTURE_SUSPENDED) | ||
| 446 | { | 468 | { | ||
| 447 | initialHA = getCurrentHA(); | | |||
| 448 | qCDebug(KSTARS_EKOS_CAPTURE) << "Initial hour angle:" << initialHA; | | |||
| 449 | meridianFlipStage = MF_NONE; | 469 | meridianFlipStage = MF_NONE; | ||
| 450 | // Record initial mount coordinates that we may use later to perform a meridian flip | | |||
| 451 | if (currentTelescope) | | |||
| 452 | { | | |||
| 453 | double initialRA, initialDE; | | |||
| 454 | currentTelescope->getEqCoords(&initialRA, &initialDE); | | |||
| 455 | if (currentTelescope->isJ2000()) | | |||
| 456 | { | | |||
| 457 | initialMountCoords.setRA0(initialRA); | | |||
| 458 | initialMountCoords.setDec0(initialDE); | | |||
| 459 | initialMountCoords.apparentCoord(static_cast<long double>(J2000), KStars::Instance()->data()->ut().djd()); | | |||
| 460 | } | | |||
| 461 | else | | |||
| 462 | { | | |||
| 463 | initialMountCoords.setRA(initialRA); | | |||
| 464 | initialMountCoords.setDec(initialDE); | | |||
| 465 | } | | |||
| 466 | | ||||
| 467 | qCDebug(KSTARS_EKOS_CAPTURE) << "Initial mount coordinates RA:" << initialMountCoords.ra().toHMSString() | | |||
| 468 | << "DE:" << initialMountCoords.dec().toDMSString(); | | |||
| 469 | } | | |||
| 470 | | ||||
| 471 | // start timer to measure time until next forced refocus | 470 | // start timer to measure time until next forced refocus | ||
| 472 | startRefocusEveryNTimer(); | 471 | startRefocusEveryNTimer(); | ||
| 473 | } | 472 | } | ||
| 474 | 473 | | |||
| 475 | // Only reset these counters if we are NOT restarting from deviation errors | 474 | // Only reset these counters if we are NOT restarting from deviation errors | ||
| 476 | // So when starting a new job or fresh then we reset them. | 475 | // So when starting a new job or fresh then we reset them. | ||
| 477 | if (m_DeviationDetected == false) | 476 | if (m_DeviationDetected == false) | ||
| 478 | { | 477 | { | ||
| ▲ Show 20 Lines • Show All 2382 Lines • ▼ Show 20 Line(s) | 2857 | // } | |||
| 2861 | // if the guide deviations are within our limits, we resume the sequence | 2860 | // if the guide deviations are within our limits, we resume the sequence | ||
| 2862 | if (meridianFlipStage == MF_GUIDING) | 2861 | if (meridianFlipStage == MF_GUIDING) | ||
| 2863 | { | 2862 | { | ||
| 2864 | double deviation_rms = sqrt(delta_ra * delta_ra + delta_dec * delta_dec); | 2863 | double deviation_rms = sqrt(delta_ra * delta_ra + delta_dec * delta_dec); | ||
| 2865 | // If the user didn't select any guiding deviation, we fall through | 2864 | // If the user didn't select any guiding deviation, we fall through | ||
| 2866 | // otherwise we can for deviation RMS | 2865 | // otherwise we can for deviation RMS | ||
| 2867 | if (guideDeviationCheck->isChecked() == false || deviation_rms < guideDeviation->value()) | 2866 | if (guideDeviationCheck->isChecked() == false || deviation_rms < guideDeviation->value()) | ||
| 2868 | { | 2867 | { | ||
| 2869 | initialHA = getCurrentHA(); | | |||
| 2870 | appendLogText(i18n("Post meridian flip calibration completed successfully.")); | 2868 | appendLogText(i18n("Post meridian flip calibration completed successfully.")); | ||
| 2871 | resumeSequence(); | 2869 | resumeSequence(); | ||
| 2872 | // N.B. Set meridian flip stage AFTER resumeSequence() always | 2870 | // N.B. Set meridian flip stage AFTER resumeSequence() always | ||
| 2873 | meridianFlipStage = MF_NONE; | 2871 | meridianFlipStage = MF_NONE; | ||
| 2874 | return; | 2872 | return; | ||
| 2875 | } | 2873 | } | ||
| 2876 | } | 2874 | } | ||
| 2877 | 2875 | | |||
| ▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Line(s) | 3056 | { | |||
| 3085 | else if (count == 1) | 3083 | else if (count == 1) | ||
| 3086 | median = filterHFRList[0]; | 3084 | median = filterHFRList[0]; | ||
| 3087 | 3085 | | |||
| 3088 | // Add 2.5% (default) to the automatic initial HFR value to allow for minute changes in HFR without need to refocus | 3086 | // Add 2.5% (default) to the automatic initial HFR value to allow for minute changes in HFR without need to refocus | ||
| 3089 | // in case in-sequence-focusing is used. | 3087 | // in case in-sequence-focusing is used. | ||
| 3090 | HFRPixels->setValue(median + (median * (Options::hFRThresholdPercentage() / 100.0))); | 3088 | HFRPixels->setValue(median + (median * (Options::hFRThresholdPercentage() / 100.0))); | ||
| 3091 | } | 3089 | } | ||
| 3092 | 3090 | | |||
| 3091 | SkyPoint Capture::getInitialMountCoords() const | ||||
| 3092 | { | ||||
| 3093 | QVariant const result = mountInterface->property("currentTarget"); | ||||
mutlaqja: Where is mountInterface defined? | |||||
mountInterface is defined in registerNewModule() - see line 369. The strange thing is that it is not shown as changed. Seems like the created diff does not show all changes. wreissenberger: mountInterface is defined in registerNewModule() - see line 369. The strange thing is that it… | |||||
wreissenberger: There was one commit missing in the diff | |||||
| 3094 | SkyPoint point = result.value<SkyPoint>(); | ||||
| 3095 | return point; | ||||
| 3096 | } | ||||
| 3097 | | ||||
| 3098 | bool Capture::executeMeridianFlip() { | ||||
| 3099 | | ||||
| 3100 | QDBusReply<bool> const reply = mountInterface->call("executeMeridianFlip"); | ||||
| 3101 | | ||||
| 3102 | if (reply.error().type() == QDBusError::NoError) | ||||
| 3103 | return reply.value(); | ||||
| 3104 | | ||||
| 3105 | // error occured | ||||
| 3106 | qCCritical(KSTARS_EKOS_CAPTURE) << QString("Warning: execute meridian flip request received DBUS error: %1").arg(QDBusError::errorString(reply.error().type())); | ||||
Is there any action that needs to be taken here? Shouldn't this abort capture? I understand the decision is pushed to caller, but the management code is missing. TallFurryMan: Is there any action that needs to be taken here? Shouldn't this abort capture? I understand the… | |||||
I tend to simply reply "false" in case of a DBus error, i.e. meridian flip has not been executed. This is not super elegant, I know, but from a DBus error I guess there is no option of recovery. And simply issuing a shutdown seems too harsh to me. wreissenberger: I tend to simply reply "false" in case of a DBus error, i.e. meridian flip has not been… | |||||
If you're not aborting, what are the consequences? Either mount is lost, and we'd better stop the procedure, or mount will continue tracking. In that situation we'd better tell the caller, be it end-user of scheduler, that something cannot be done. Scheduler is able to restart the mount connection by itself now. TallFurryMan: If you're not aborting, what are the consequences? Either mount is lost, and we'd better stop… | |||||
| 3107 | | ||||
| 3108 | return false; | ||||
| 3109 | } | ||||
| 3110 | | ||||
| 3093 | int Capture::getTotalFramesCount(QString signature) | 3111 | int Capture::getTotalFramesCount(QString signature) | ||
| 3094 | { | 3112 | { | ||
| 3095 | int result = 0; | 3113 | int result = 0; | ||
| 3096 | bool found = false; | 3114 | bool found = false; | ||
| 3097 | 3115 | | |||
| 3098 | foreach (SequenceJob *job, jobs) | 3116 | foreach (SequenceJob *job, jobs) | ||
| 3099 | { | 3117 | { | ||
| 3100 | // FIXME: this should be part of SequenceJob | 3118 | // FIXME: this should be part of SequenceJob | ||
| ▲ Show 20 Lines • Show All 1022 Lines • ▼ Show 20 Line(s) | 4140 | if (nvp->s == IPS_BUSY) | |||
| 4123 | meridianFlipStage = MF_FLIPPING; | 4141 | meridianFlipStage = MF_FLIPPING; | ||
| 4124 | } | 4142 | } | ||
| 4125 | break; | 4143 | break; | ||
| 4126 | 4144 | | |||
| 4127 | case MF_FLIPPING: | 4145 | case MF_FLIPPING: | ||
| 4128 | { | 4146 | { | ||
| 4129 | double ra, dec; | 4147 | double ra, dec; | ||
| 4130 | currentTelescope->getEqCoords(&ra, &dec); | 4148 | currentTelescope->getEqCoords(&ra, &dec); | ||
| 4131 | double diffRA = initialMountCoords.ra().Hours() - ra; | 4149 | double diffRA = getInitialMountCoords().ra().Hours() - ra; | ||
TallFurryMan: Agreed, this is the core of the change. | |||||
| 4132 | // If the mount is actually flipping then we should see a difference in RA | 4150 | // If the mount is actually flipping then we should see a difference in RA | ||
| 4133 | // which if it exceeded MF_RA_DIFF_LIMIT (4 hours) then we consider it to be | 4151 | // which if it exceeded MF_RA_DIFF_LIMIT (4 hours) then we consider it to be | ||
| 4134 | // undertaking the flip. Otherwise, it's not flipping and let timeout takes care of | 4152 | // undertaking the flip. Otherwise, it's not flipping and let timeout takes care of | ||
| 4135 | // of that | 4153 | // of that | ||
| 4136 | // Are there any mounts that do NOT change RA while flipping? i.e. do it silently? | 4154 | // Are there any mounts that do NOT change RA while flipping? i.e. do it silently? | ||
| 4137 | // Need to investigate that bit | 4155 | // Need to investigate that bit | ||
| 4138 | if (fabs(diffRA) > MF_RA_DIFF_LIMIT /* || nvp->s == IPS_OK*/) | 4156 | if (fabs(diffRA) > MF_RA_DIFF_LIMIT /* || nvp->s == IPS_OK*/) | ||
| 4139 | meridianFlipStage = MF_SLEWING; | 4157 | meridianFlipStage = MF_SLEWING; | ||
| 4140 | } | 4158 | } | ||
| 4141 | break; | 4159 | break; | ||
| 4142 | 4160 | | |||
| 4143 | case MF_SLEWING: | 4161 | case MF_SLEWING: | ||
| 4144 | 4162 | | |||
| 4145 | if (nvp->s != IPS_OK) | 4163 | if (nvp->s != IPS_OK) | ||
| 4146 | break; | 4164 | break; | ||
| 4147 | 4165 | | |||
| 4148 | // If dome is syncing, wait until it stops | 4166 | // If dome is syncing, wait until it stops | ||
| 4149 | if (dome && dome->isMoving()) | 4167 | if (dome && dome->isMoving()) | ||
| 4150 | break; | 4168 | break; | ||
| 4151 | 4169 | | |||
| 4152 | // We are at a new initialHA | | |||
| 4153 | initialHA = getCurrentHA(); | | |||
| 4154 | | ||||
| 4155 | appendLogText(i18n("Telescope completed the meridian flip.")); | 4170 | appendLogText(i18n("Telescope completed the meridian flip.")); | ||
| 4156 | 4171 | | |||
| 4157 | //KNotification::event(QLatin1String("MeridianFlipCompleted"), i18n("Meridian flip is successfully completed")); | 4172 | //KNotification::event(QLatin1String("MeridianFlipCompleted"), i18n("Meridian flip is successfully completed")); | ||
| 4158 | KSNotification::event(QLatin1String("MeridianFlipCompleted"), i18n("Meridian flip is successfully completed"), KSNotification::EVENT_INFO); | 4173 | KSNotification::event(QLatin1String("MeridianFlipCompleted"), i18n("Meridian flip is successfully completed"), KSNotification::EVENT_INFO); | ||
| 4159 | 4174 | | |||
| 4160 | if (resumeAlignmentAfterFlip == true) | 4175 | if (resumeAlignmentAfterFlip == true) | ||
| 4161 | { | 4176 | { | ||
| 4162 | appendLogText(i18n("Performing post flip re-alignment...")); | 4177 | appendLogText(i18n("Performing post flip re-alignment...")); | ||
| Show All 37 Lines | 4209 | { | |||
| 4200 | 4215 | | |||
| 4201 | meridianFlipStage = MF_GUIDING; | 4216 | meridianFlipStage = MF_GUIDING; | ||
| 4202 | emit meridianFlipCompleted(); | 4217 | emit meridianFlipCompleted(); | ||
| 4203 | } | 4218 | } | ||
| 4204 | } | 4219 | } | ||
| 4205 | 4220 | | |||
| 4206 | double Capture::getCurrentHA() | 4221 | double Capture::getCurrentHA() | ||
| 4207 | { | 4222 | { | ||
| 4208 | double currentRA, currentDEC; | 4223 | QVariant HA = mountInterface->property("hourAngle"); | ||
| 4209 | 4224 | return HA.toDouble(); | |||
| 4210 | if (currentTelescope == nullptr) | 4225 | } | ||
| 4211 | return Ekos::INVALID_VALUE; | | |||
| 4212 | 4226 | | |||
| 4213 | if (currentTelescope->getEqCoords(¤tRA, ¤tDEC) == false) | 4227 | double Capture::getInitialHA() | ||
| 4214 | { | 4228 | { | ||
| 4215 | appendLogText(i18n("Failed to retrieve telescope coordinates. Unable to calculate telescope's hour angle.")); | 4229 | QVariant HA = mountInterface->property("initialHA"); | ||
| 4216 | return Ekos::INVALID_VALUE; | 4230 | return HA.toDouble(); | ||
| 4217 | } | 4231 | } | ||
| 4218 | 4232 | | |||
| 4219 | /* Edge case: undefined HA at poles */ | 4233 | bool Capture::slew(const SkyPoint target) | ||
| 4220 | if (90.0f == currentDEC || -90.0f == currentDEC) | 4234 | { | ||
| 4221 | return Ekos::INVALID_VALUE; | 4235 | QList<QVariant> telescopeSlew; | ||
| 4236 | telescopeSlew.append(target.ra().Hours()); | ||||
| 4237 | telescopeSlew.append(target.dec().Degrees()); | ||||
| 4238 | | ||||
| 4239 | QDBusReply<bool> const slewModeReply = mountInterface->callWithArgumentList(QDBus::AutoDetect, "slew", telescopeSlew); | ||||
| 4222 | 4240 | | |||
| 4223 | dms lst = KStarsData::Instance()->geo()->GSTtoLST(KStarsData::Instance()->clock()->utc().gst()); | 4241 | if (slewModeReply.error().type() == QDBusError::NoError) | ||
| 4242 | return true; | ||||
| 4224 | 4243 | | |||
| 4225 | dms ha = (lst - dms(currentRA * 15.0)); | 4244 | // error occured | ||
| 4226 | double HA = ha.Hours(); | 4245 | qCCritical(KSTARS_EKOS_CAPTURE) << QString("Warning: slew request received DBUS error: %1").arg(QDBusError::errorString(slewModeReply.error().type())); | ||
| 4227 | if (HA > 12) | 4246 | return false; | ||
| 4228 | HA -= 24; | | |||
| 4229 | return HA; | | |||
| 4230 | } | 4247 | } | ||
| 4231 | 4248 | | |||
| 4249 | | ||||
| 4232 | bool Capture::checkMeridianFlip() | 4250 | bool Capture::checkMeridianFlip() | ||
| 4233 | { | 4251 | { | ||
| 4234 | if (currentTelescope == nullptr || meridianCheck->isChecked() == false || initialHA > 0) | 4252 | if (currentTelescope == nullptr || meridianCheck->isChecked() == false || getInitialHA() > 0) | ||
| 4235 | return false; | 4253 | return false; | ||
| 4236 | 4254 | | |||
| 4237 | // If active job is taking flat field image at a wall source | 4255 | // If active job is taking flat field image at a wall source | ||
| 4238 | // then do not flip. | 4256 | // then do not flip. | ||
| 4239 | if (activeJob && activeJob->getFrameType() == FRAME_FLAT && activeJob->getFlatFieldSource() == SOURCE_WALL) | 4257 | if (activeJob && activeJob->getFrameType() == FRAME_FLAT && activeJob->getFlatFieldSource() == SOURCE_WALL) | ||
| 4240 | return false; | 4258 | return false; | ||
| 4241 | 4259 | | |||
| 4242 | double currentHA = getCurrentHA(); | 4260 | double currentHA = getCurrentHA(); | ||
| Show All 21 Lines | 4268 | { | |||
| 4264 | // If we are autoguiding, we should resume autoguiding after flip | 4282 | // If we are autoguiding, we should resume autoguiding after flip | ||
| 4265 | resumeGuidingAfterFlip = (guideState == GUIDE_GUIDING); | 4283 | resumeGuidingAfterFlip = (guideState == GUIDE_GUIDING); | ||
| 4266 | 4284 | | |||
| 4267 | emit meridianFlipStarted(); | 4285 | emit meridianFlipStarted(); | ||
| 4268 | 4286 | | |||
| 4269 | // Reset frame if we need to do focusing later on | 4287 | // Reset frame if we need to do focusing later on | ||
| 4270 | if (isInSequenceFocus || (refocusEveryNCheck->isChecked() && getRefocusEveryNTimerElapsedSec() > 0)) | 4288 | if (isInSequenceFocus || (refocusEveryNCheck->isChecked() && getRefocusEveryNTimerElapsedSec() > 0)) | ||
| 4271 | emit resetFocus(); | 4289 | emit resetFocus(); | ||
| 4272 | 4290 | | |||
| 4273 | //double dec; | 4291 | if (executeMeridianFlip()) | ||
TallFurryMan: Missing management of bool return code. | |||||
| 4274 | //currentTelescope->getEqCoords(&initialRA, &dec); | 4292 | { | ||
| 4275 | currentTelescope->Slew(&initialMountCoords); | | |||
| 4276 | secondsLabel->setText(i18n("Meridian Flip...")); | 4293 | secondsLabel->setText(i18n("Meridian Flip...")); | ||
| 4277 | 4294 | | |||
| 4278 | retries = 0; | 4295 | retries = 0; | ||
| 4279 | 4296 | | |||
| 4280 | m_State = CAPTURE_MERIDIAN_FLIP; | 4297 | m_State = CAPTURE_MERIDIAN_FLIP; | ||
| 4281 | emit newStatus(Ekos::CAPTURE_MERIDIAN_FLIP); | 4298 | emit newStatus(Ekos::CAPTURE_MERIDIAN_FLIP); | ||
| 4282 | 4299 | | |||
| 4283 | QTimer::singleShot(MF_TIMER_TIMEOUT, this, &Ekos::Capture::checkMeridianFlipTimeout); | 4300 | QTimer::singleShot(MF_TIMER_TIMEOUT, this, &Ekos::Capture::checkMeridianFlipTimeout); | ||
| 4284 | return true; | 4301 | return true; | ||
| 4285 | } | 4302 | } | ||
| 4303 | } | ||||
| 4286 | 4304 | | |||
| 4287 | return false; | 4305 | return false; | ||
| 4288 | } | 4306 | } | ||
| 4289 | 4307 | | |||
| 4290 | void Capture::checkMeridianFlipTimeout() | 4308 | void Capture::checkMeridianFlipTimeout() | ||
| 4291 | { | 4309 | { | ||
| 4292 | if (meridianFlipStage == MF_NONE) | 4310 | if (meridianFlipStage == MF_NONE) | ||
| 4293 | return; | 4311 | return; | ||
| 4294 | 4312 | | |||
| 4295 | if (meridianFlipStage < MF_ALIGNING) | 4313 | if (meridianFlipStage < MF_ALIGNING) | ||
| 4296 | { | 4314 | { | ||
| 4297 | appendLogText(i18n("Telescope meridian flip timed out. Please make sure your mount supports meridian flip.")); | 4315 | appendLogText(i18n("Telescope meridian flip timed out. Please make sure your mount supports meridian flip.")); | ||
| 4298 | 4316 | | |||
| 4299 | if (++retries == 3) | 4317 | if (++retries == 3) | ||
| 4300 | { | 4318 | { | ||
| 4301 | //KNotification::event(QLatin1String("MeridianFlipFailed"), i18n("Meridian flip failed")); | 4319 | //KNotification::event(QLatin1String("MeridianFlipFailed"), i18n("Meridian flip failed")); | ||
| 4302 | KSNotification::event(QLatin1String("MeridianFlipFailed"), i18n("Meridian flip failed"), KSNotification::EVENT_ALERT); | 4320 | KSNotification::event(QLatin1String("MeridianFlipFailed"), i18n("Meridian flip failed"), KSNotification::EVENT_ALERT); | ||
| 4303 | abort(); | 4321 | abort(); | ||
| 4304 | } | 4322 | } | ||
| 4305 | else | 4323 | else | ||
| 4306 | { | 4324 | { | ||
| 4307 | //double dec; | 4325 | if (executeMeridianFlip()) | ||
| 4308 | //currentTelescope->getEqCoords(&initialRA, &dec); | | |||
| 4309 | //currentTelescope->Slew(initialRA, dec); | | |||
| 4310 | currentTelescope->Slew(&initialMountCoords); | | |||
| 4311 | appendLogText(i18n("Retrying meridian flip again...")); | 4326 | appendLogText(i18n("Retrying meridian flip again...")); | ||
| 4312 | } | 4327 | } | ||
| 4313 | } | 4328 | } | ||
| 4314 | } | 4329 | } | ||
| 4315 | 4330 | | |||
| 4316 | void Capture::checkGuideDeviationTimeout() | 4331 | void Capture::checkGuideDeviationTimeout() | ||
| 4317 | { | 4332 | { | ||
| 4318 | if (activeJob && activeJob->getStatus() == SequenceJob::JOB_ABORTED && m_DeviationDetected) | 4333 | if (activeJob && activeJob->getStatus() == SequenceJob::JOB_ABORTED && m_DeviationDetected) | ||
| ▲ Show 20 Lines • Show All 431 Lines • ▼ Show 20 Line(s) | 4717 | { | |||
| 4750 | Options::setCalibrationADUValue(targetADU); | 4765 | Options::setCalibrationADUValue(targetADU); | ||
| 4751 | Options::setCalibrationADUValueTolerance(targetADUTolerance); | 4766 | Options::setCalibrationADUValueTolerance(targetADUTolerance); | ||
| 4752 | } | 4767 | } | ||
| 4753 | } | 4768 | } | ||
| 4754 | 4769 | | |||
| 4755 | IPState Capture::processPreCaptureCalibrationStage() | 4770 | IPState Capture::processPreCaptureCalibrationStage() | ||
| 4756 | { | 4771 | { | ||
| 4757 | // Unpark dust cap if we have to take light images. | 4772 | // Unpark dust cap if we have to take light images. | ||
| 4758 | if (activeJob->getFrameType() == FRAME_LIGHT && dustCap) | 4773 | if (activeJob->getFrameType() == FRAME_LIGHT) | ||
| 4759 | { | 4774 | { | ||
| 4775 | // step 1: unpark dust cap | ||||
| 4776 | if (dustCap != nullptr) { | ||||
TallFurryMan: Test against nullptr? | |||||
| 4760 | if (dustCap->isLightOn() == true) | 4777 | if (dustCap->isLightOn() == true) | ||
| 4761 | { | 4778 | { | ||
| 4762 | dustCapLightEnabled = false; | 4779 | dustCapLightEnabled = false; | ||
| 4763 | dustCap->SetLightEnabled(false); | 4780 | dustCap->SetLightEnabled(false); | ||
| 4764 | } | 4781 | } | ||
| 4765 | 4782 | | |||
| 4766 | // If cap is not unparked, unpark it | 4783 | // If cap is not unparked, unpark it | ||
| 4767 | if (calibrationStage < CAL_DUSTCAP_UNPARKING && dustCap->isParked()) | 4784 | if (calibrationStage < CAL_DUSTCAP_UNPARKING && dustCap->isParked()) | ||
| Show All 18 Lines | 4802 | { | |||
| 4786 | if (dustCap->isUnParked() == false) | 4803 | if (dustCap->isUnParked() == false) | ||
| 4787 | return IPS_BUSY; | 4804 | return IPS_BUSY; | ||
| 4788 | else | 4805 | else | ||
| 4789 | { | 4806 | { | ||
| 4790 | calibrationStage = CAL_DUSTCAP_UNPARKED; | 4807 | calibrationStage = CAL_DUSTCAP_UNPARKED; | ||
| 4791 | appendLogText(i18n("Dust cap unparked.")); | 4808 | appendLogText(i18n("Dust cap unparked.")); | ||
| 4792 | } | 4809 | } | ||
| 4793 | } | 4810 | } | ||
| 4811 | } | ||||
| 4812 | | ||||
| 4813 | // step 2: check if meridian flip is required | ||||
| 4814 | if (meridianFlipStage != MF_NONE || checkMeridianFlip()) | ||||
| 4815 | return IPS_BUSY; | ||||
| 4794 | 4816 | | |||
| 4795 | calibrationStage = CAL_PRECAPTURE_COMPLETE; | 4817 | calibrationStage = CAL_PRECAPTURE_COMPLETE; | ||
| 4796 | 4818 | | |||
| 4797 | if (guideState == GUIDE_SUSPENDED) | 4819 | if (guideState == GUIDE_SUSPENDED) | ||
| 4798 | { | 4820 | { | ||
| 4799 | appendLogText(i18n("Autoguiding resumed.")); | 4821 | appendLogText(i18n("Autoguiding resumed.")); | ||
| 4800 | emit resumeGuiding(); | 4822 | emit resumeGuiding(); | ||
| 4801 | } | 4823 | } | ||
| ▲ Show 20 Lines • Show All 1037 Lines • Show Last 20 Lines | |||||
Why are you initializing it here and then again in registerNewModule?