Ekos

Ekos Namespace Reference

Classes

class  Align
 
class  Analyze
 
class  ASTAPAstrometryParser
 
class  AstrometryParser
 
class  Capture
 
class  DarkLibrary
 
class  DarkProcessor
 
class  Focus
 
class  FocusAlgorithmInterface
 
class  Guide
 
class  GuideInterface
 
class  LinGuider
 
class  MosaicTilesModel
 
class  Mount
 
class  OpsCalibration
 
class  OpsDither
 
class  OpsGPG
 
class  OpsGuide
 
class  OpsLogs
 
class  OpticalTrainSettings
 
class  PHD2
 
class  PolarAlignmentAssistant
 
class  ProfileSettings
 
class  RemoteAstrometryParser
 
class  Scheduler
 

Typedefs

using PAA = PolarAlignmentAssistant
 

Enumerations

enum  AlignState {
  ALIGN_IDLE, ALIGN_COMPLETE, ALIGN_FAILED, ALIGN_ABORTED,
  ALIGN_PROGRESS, ALIGN_SUCCESSFUL, ALIGN_SYNCING, ALIGN_SLEWING,
  ALIGN_ROTATING, ALIGN_SUSPENDED
}
 
enum  CaptureAfterPulses { StartCaptureAfterPulses, DontCaptureAfterPulses }
 
enum  CAPTUREResult {
  CAPTURE_OK, CAPTURE_FRAME_ERROR, CAPTURE_BIN_ERROR, CAPTURE_FILTER_BUSY,
  CAPTURE_FOCUS_ERROR, CAPTURE_GUIDER_DRIFT_WAIT
}
 
enum  CaptureState {
  CAPTURE_IDLE, CAPTURE_PROGRESS, CAPTURE_CAPTURING, CAPTURE_PAUSE_PLANNED,
  CAPTURE_PAUSED, CAPTURE_SUSPENDED, CAPTURE_ABORTED, CAPTURE_WAITING,
  CAPTURE_IMAGE_RECEIVED, CAPTURE_DITHERING, CAPTURE_FOCUSING, CAPTURE_FILTER_FOCUS,
  CAPTURE_CHANGING_FILTER, CAPTURE_GUIDER_DRIFT, CAPTURE_SETTING_TEMPERATURE, CAPTURE_SETTING_ROTATOR,
  CAPTURE_ALIGNING, CAPTURE_CALIBRATING, CAPTURE_MERIDIAN_FLIP, CAPTURE_COMPLETE
}
 
enum  CommunicationStatus { Idle, Pending, Success, Error }
 
enum  FilterState { FILTER_IDLE, FILTER_CHANGE, FILTER_OFFSET, FILTER_AUTOFOCUS }
 
enum  FocusState {
  FOCUS_IDLE, FOCUS_COMPLETE, FOCUS_FAILED, FOCUS_ABORTED,
  FOCUS_WAITING, FOCUS_PROGRESS, FOCUS_FRAMING, FOCUS_CHANGING_FILTER
}
 
enum  GuideState {
  GUIDE_IDLE, GUIDE_ABORTED, GUIDE_CONNECTED, GUIDE_DISCONNECTED,
  GUIDE_CAPTURE, GUIDE_LOOPING, GUIDE_DARK, GUIDE_SUBFRAME,
  GUIDE_STAR_SELECT, GUIDE_CALIBRATING, GUIDE_CALIBRATION_ERROR, GUIDE_CALIBRATION_SUCCESS,
  GUIDE_GUIDING, GUIDE_SUSPENDED, GUIDE_REACQUIRE, GUIDE_DITHERING,
  GUIDE_MANUAL_DITHERING, GUIDE_DITHERING_ERROR, GUIDE_DITHERING_SUCCESS, GUIDE_DITHERING_SETTLE
}
 
enum  JOBStatus {
  JOB_IDLE, JOB_BUSY, JOB_ERROR, JOB_ABORTED,
  JOB_DONE
}
 
enum  ProfileGroup { AlignProfiles, FocusProfiles, GuideProfiles, HFRProfiles }
 
enum  SchedulerState {
  SCHEDULER_IDLE, SCHEDULER_STARTUP, SCHEDULER_RUNNING, SCHEDULER_PAUSED,
  SCHEDULER_SHUTDOWN, SCHEDULER_ABORTED, SCHEDULER_LOADING
}
 
enum  ScriptTypes {
  SCRIPT_PRE_JOB, SCRIPT_PRE_CAPTURE, SCRIPT_POST_CAPTURE, SCRIPT_POST_JOB,
  SCRIPT_N
}
 

Functions

QString commStatusString (Ekos::CommunicationStatus state)
 
QString ekosStateString (Scheduler::EkosState state)
 
const QString getAlignStatusString (AlignState state, bool translated)
 
const QString getCaptureStatusString (CaptureState state, bool translated)
 
QList< SSolver::Parameters > getDefaultAlignOptionsProfiles ()
 
QList< Parameters > getDefaultFocusOptionsProfiles ()
 
QList< SSolver::Parameters > getDefaultGuideOptionsProfiles ()
 
QList< Parameters > getDefaultHFROptionsProfiles ()
 
const QString getFilterStatusString (FilterState state, bool translated)
 
const QString getFocusStatusString (FocusState state, bool translated)
 
const QString getGuideStatusString (GuideState state, bool translated)
 
const QString getSchedulerStatusString (AlignState state, bool translated=true)
 
const QString getSchedulerStatusString (FilterState state, bool translated)
 
std::vector< double > gsl_polynomial_fit (const double *const data_x, const double *const data_y, const int n, const int order, double &chisq)
 
QString indiStateString (Scheduler::INDIState state)
 
bool isEqual (double a, double b)
 
FocusAlgorithmInterfaceMakeLinearFocuser (const FocusAlgorithmInterface::FocusParams &params)
 
QString parkWaitStateString (Scheduler::ParkWaitStatus state)
 
QString schedulerStateString (Ekos::SchedulerState state)
 
QString shutdownStateString (Scheduler::ShutdownState state)
 
QString stageString (Ekos::CalibrationProcess::CalibrationStage stage)
 
QString startupStateString (Scheduler::StartupState state)
 
QString timerStr (Scheduler::SchedulerTimerState state)
 

Variables

static const QList< const char * > alignStates
 
static const QList< const char * > captureStates
 
static const QList< const char * > filterStates
 
static const QList< const char * > focusStates
 
static const QList< const char * > guideStates
 
const int INVALID_VALUE = -1e6
 
static const QList< const char * > schedulerStates
 

Detailed Description

Ekos is an advanced Astrophotography tool for Linux. It is based on a modular extensible framework to perform common astrophotography tasks. This includes highly accurate GOTOs using astrometry solver, ability to measure and correct polar alignment errors , auto-focus & auto-guide capabilities, and capture of single or stack of images with filter wheel support.
Features:

A meridian flip is executed by issueing a scope motion to the target.

  • Control your telescope, CCD (& DSLRs), filter wheel, focuser, guider, adaptive optics unit, and any INDI-compatible auxiliary device from Ekos.
  • Extremely accurate GOTOs using astrometry.net solver (both Online and Offline solvers supported).
  • Load & Slew: Load a FITS image, slew to solved coordinates, and center the mount on the exact image coordinates in order to get the same desired frame.
  • Measure & Correct Polar Alignment errors using astrometry.net solver.
  • Auto and manual focus modes using Half-Flux-Radius (HFR) method.
  • Automated unattended meridian flip. Ekos performs post meridian flip alignment, calibration, and guiding to resume the capture session.
  • Automatic focus between exposures when a user-configurable HFR limit is exceeded.
  • Automatic focus between exposures when the temperature has changed a lot since last focus.
  • Auto guiding with support for automatic dithering between exposures and support for Adaptive Optics devices in addition to traditional guiders.
  • Powerful sequence queue for batch capture of images with optional prefixes, timestamps, filter wheel selection, and much more!
  • Export and import sequence queue sets as Ekos Sequence Queue (.esq) files.
  • Center the telescope anywhere in a captured FITS image or any FITS with World Coordinate System (WCS) header.
  • Automatic flat field capture, just set the desired ADU and let Ekos does the rest!
  • Automatic abort and resumption of exposure tasks if guiding errors exceed a user-configurable value.
  • Support for dome slaving.
  • Complete integration with KStars Observation Planner and SkyMap
  • Integrate with all INDI native devices.
  • Powerful scripting capabilities via DBus.

The primary class is Ekos::Manager. It handles startup and shutdown of local and remote INDI devices, manages and orchesterates the various Ekos modules, and provides advanced DBus interface to enable unattended scripting.

Author
Jasem Mutlaq
Version
1.9

Essentially, the meridian flip relies upon that the mount hardware selects the pier side of the scope on the appropriate side depending whether the scope points east or west of the meridian.

While tracking a certain object a pier side change is necessary as soon as the position crosses the meridian. As soon as this is detected, the meridian flip works as follows:

  • A meridian flip request is sent to Capture so that a currently running capture can be completed before the flip starts.
  • Capture completes the currently running capture, stops capturing and sends a confirmation so that the flip may start.
  • Now a slew command is issued to the current target (i.e. the last position where a slew has been executed). This will force the mount hardware to reconsider the pier side and slews to the same position but changing the pier side.
  • As soon as the slew has been completed alignment is executed, guiding restarted and Capture informed that capturing may continue.

Enumeration Type Documentation

◆ AlignState

Enumerator
ALIGN_IDLE 

No ongoing operations.

ALIGN_COMPLETE 

Alignment successfully completed.

No operations pending.

ALIGN_FAILED 

Alignment failed.

No operations pending.

ALIGN_ABORTED 

Alignment aborted by user or agent.

ALIGN_PROGRESS 

Alignment operation in progress.

This include capture and sovling.

ALIGN_SUCCESSFUL 

Alignment Astrometry solver successfully solved the image.

ALIGN_SYNCING 

Syncing mount to solution coordinates.

ALIGN_SLEWING 

Slewing mount to target coordinates.


ALIGN_ROTATING 

Rotating (Automatic or Manual) to target position angle.

ALIGN_SUSPENDED 

Alignment operations suspended.

Definition at line 144 of file ekos.h.

◆ CaptureState

Capture states.

They can be divided into several stages:

Enumerator
CAPTURE_IDLE 

no capture job active

CAPTURE_PROGRESS 

capture job sequence in preparation (temperature, filter, rotator)

CAPTURE_CAPTURING 

CCD capture running

CAPTURE_PAUSE_PLANNED 

user has requested to pause the capture sequence

CAPTURE_PAUSED 

paused capture sequence due to a user request

CAPTURE_SUSPENDED 

capture stopped since some limits are not met, but may be continued if all limits are met again

CAPTURE_ABORTED 

capture stopped by the user or aborted due to guiding problems etc.

CAPTURE_WAITING 

waiting for settling of the mount before start of capturing

CAPTURE_IMAGE_RECEIVED 

image received from the CDD device

CAPTURE_DITHERING 

dithering before starting to capture

CAPTURE_FOCUSING 

focusing before starting to capture

CAPTURE_FILTER_FOCUS 

not used

CAPTURE_CHANGING_FILTER 

preparation event changing the filter

CAPTURE_GUIDER_DRIFT 

preparation event waiting for the guider to settle

CAPTURE_SETTING_TEMPERATURE 

preparation event setting the camera temperature

CAPTURE_SETTING_ROTATOR 

preparation event setting the camera rotator

CAPTURE_ALIGNING 

aligning before starting to capture

CAPTURE_CALIBRATING 

startup of guiding running before starting to capture

CAPTURE_MERIDIAN_FLIP 

only used as signal that a meridian flip is ongoing

CAPTURE_COMPLETE 

capture job sequence completed successfully

Definition at line 91 of file ekos.h.

◆ ScriptTypes

Enumerator
SCRIPT_PRE_JOB 

Script to run before a sequence job is started.

SCRIPT_PRE_CAPTURE 

Script to run before a sequence capture is started.

SCRIPT_POST_CAPTURE 

Script to run after a sequence capture is completed.

SCRIPT_POST_JOB 

Script to run after a sequence job is completed.

Definition at line 172 of file ekos.h.

Variable Documentation

◆ alignStates

const QList<const char *> Ekos::alignStates
static
Initial value:
= { I18N_NOOP("Idle"), I18N_NOOP("Complete"), I18N_NOOP("Failed"),
I18N_NOOP("Aborted"), I18N_NOOP("In Progress"), I18N_NOOP("Successful"),
I18N_NOOP("Syncing"), I18N_NOOP("Slewing"), I18N_NOOP("Rotating"),
}

Definition at line 138 of file ekos.h.

◆ captureStates

const QList<const char *> Ekos::captureStates
static
Initial value:
=
{
I18N_NOOP("Idle"), I18N_NOOP("In Progress"), I18N_NOOP("Capturing"), I18N_NOOP("Pause Planned"), I18N_NOOP("Paused"),
I18N_NOOP("Suspended"), I18N_NOOP("Aborted"), I18N_NOOP("Waiting"), I18N_NOOP("Image Received"),
I18N_NOOP("Dithering"), I18N_NOOP("Focusing"), I18N_NOOP("Filter Focus"), I18N_NOOP("Changing Filter"), I18N_NOOP("Guider Settling"),
I18N_NOOP("Setting Temperature"), I18N_NOOP("Setting Rotator"), I18N_NOOP("Aligning"), I18N_NOOP("Calibrating"),
I18N_NOOP("Meridian Flip"), I18N_NOOP("Complete")
}

Definition at line 69 of file ekos.h.

◆ filterStates

const QList<const char *> Ekos::filterStates
static
Initial value:
= { I18N_NOOP("Idle"), I18N_NOOP("Changing Filter"), I18N_NOOP("Focus Offset"),
}

Definition at line 161 of file ekos.h.

◆ focusStates

const QList<const char *> Ekos::focusStates
static
Initial value:
= { I18N_NOOP("Idle"), I18N_NOOP("Complete"), I18N_NOOP("Failed"),
I18N_NOOP("Aborted"), I18N_NOOP("User Input"), I18N_NOOP("In Progress"),
I18N_NOOP("Framing"), I18N_NOOP("Changing Filter")
}

Definition at line 118 of file ekos.h.

◆ guideStates

const QList<const char *> Ekos::guideStates
static
Initial value:
= { I18N_NOOP("Idle"),
I18N_NOOP("Aborted"),
I18N_NOOP("Connected"),
I18N_NOOP("Disconnected"),
I18N_NOOP("Capturing"),
I18N_NOOP("Looping"),
I18N_NOOP("Subtracting"),
I18N_NOOP("Subframing"),
I18N_NOOP("Selecting star"),
I18N_NOOP("Calibrating"),
I18N_NOOP("Calibration error"),
I18N_NOOP("Calibrated"),
I18N_NOOP("Guiding"),
I18N_NOOP("Suspended"),
I18N_NOOP("Reacquiring"),
I18N_NOOP("Dithering"),
I18N_NOOP("Manual Dithering"),
I18N_NOOP("Dithering error"),
I18N_NOOP("Dithering successful"),
}

Definition at line 20 of file ekos.h.

◆ schedulerStates

const QList<const char *> Ekos::schedulerStates
static
Initial value:
= { I18N_NOOP("Idle"), I18N_NOOP("Startup"), I18N_NOOP("Running"),
I18N_NOOP("Paused"), I18N_NOOP("Shutdown"), I18N_NOOP("Aborted"),
}

Definition at line 187 of file ekos.h.

#define I18N_NOOP(text)
This file is part of the KDE documentation.
Documentation copyright © 1996-2022 The KDE developers.
Generated on Fri Dec 9 2022 03:59:26 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.