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_FOCUS_ERROR }
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)
FocusAlgorithmInterface *	MakeLinearFocuser (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

enum Ekos::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

enum Ekos::CaptureState

Capture states.

They can be divided into several stages:

• No capturing is running (

  See also

  CAPTURE_IDLE,

  CAPTURE_COMPLETE or

  CAPTURE_ABORTED)

• A capture sequence job is in preparation (

  See also

  CAPTURE_PROGRESS as state and

  CAPTURE_SETTING_TEMPERATURE,

  CAPTURE_SETTING_ROTATOR and

  CAPTURE_CHANGING_FILTER as state events signaled to

  Capture::updatePrepareState(Ekos::CaptureState))

• Calibration activities to initialize the execution of a sequence job (

  See also

  CAPTURE_DITHERING,

  CAPTURE_FOCUSING,

  CAPTURE_ALIGNING and

  CAPTURE_CALIBRATING)

• Waiting for start of capturing (

  See also

  CAPTURE_PAUSE_PLANNED,

  CAPTURE_PAUSED,

  CAPTURE_SUSPENDED and

  CAPTURE_WAITING)

• Capturing (

  See also

  CAPTURE_CAPTURING and

  CAPTURE_IMAGE_RECEIVED)

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

enum Ekos::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.