Trait ascom_alpaca::api::Camera

pub trait Camera: Device + Send + Sync {
    // Provided methods
    fn bayer_offset_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bayer_offset_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bin_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_bin_x<'life0, 'async_trait>(
        &'life0 self,
        bin_x: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bin_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_bin_y<'life0, 'async_trait>(
        &'life0 self,
        bin_y: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn camera_state<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<CameraState>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn camera_xsize<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn camera_ysize<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_abort_exposure<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_asymmetric_bin<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_fast_readout<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_get_cooler_power<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_pulse_guide<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_set_ccd_temperature<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn can_stop_exposure<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn ccd_temperature<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn cooler_on<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_cooler_on<'life0, 'async_trait>(
        &'life0 self,
        cooler_on: bool
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn cooler_power<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn electrons_per_adu<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn exposure_max<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn exposure_min<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn exposure_resolution<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn fast_readout<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_fast_readout<'life0, 'async_trait>(
        &'life0 self,
        fast_readout: bool
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn full_well_capacity<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn gain<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_gain<'life0, 'async_trait>(
        &'life0 self,
        gain: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn gain_max<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn gain_min<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn gains<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn has_shutter<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn heat_sink_temperature<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn image_array<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<ImageArray>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn image_ready<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn is_pulse_guiding<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn last_exposure_duration<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn last_exposure_start_time<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<SystemTime>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn max_adu<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn max_bin_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn max_bin_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn num_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_num_x<'life0, 'async_trait>(
        &'life0 self,
        num_x: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn num_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_num_y<'life0, 'async_trait>(
        &'life0 self,
        num_y: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn offset<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_offset<'life0, 'async_trait>(
        &'life0 self,
        offset: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn offset_max<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn offset_min<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn offsets<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn percent_completed<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn pixel_size_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn pixel_size_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn readout_mode<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_readout_mode<'life0, 'async_trait>(
        &'life0 self,
        readout_mode: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn readout_modes<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn sensor_name<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn sensor_type<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<SensorType>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_ccd_temperature<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_set_ccd_temperature<'life0, 'async_trait>(
        &'life0 self,
        set_ccd_temperature: f64
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn start_x<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_start_x<'life0, 'async_trait>(
        &'life0 self,
        start_x: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn start_y<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_start_y<'life0, 'async_trait>(
        &'life0 self,
        start_y: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn sub_exposure_duration<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn set_sub_exposure_duration<'life0, 'async_trait>(
        &'life0 self,
        sub_exposure_duration: f64
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn abort_exposure<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn pulse_guide<'life0, 'async_trait>(
        &'life0 self,
        direction: PutPulseGuideDirection,
        duration: i32
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn start_exposure<'life0, 'async_trait>(
        &'life0 self,
        duration: f64,
        light: bool
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn stop_exposure<'life0, 'async_trait>(
        &'life0 self
    ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
}

Available on crate feature camera only.

Camera Specific Methods

Provided Methods

fn bayer_offset_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the X offset of the Bayer matrix, as defined in SensorType.

Definition before the #[async_trait] expansion:

async fn bayer_offset_x(&self) -> ASCOMResult<i32>

fn bayer_offset_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Y offset of the Bayer matrix, as defined in SensorType.

Definition before the #[async_trait] expansion:

async fn bayer_offset_y(&self) -> ASCOMResult<i32>

fn bin_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the binning factor for the X axis.

Definition before the #[async_trait] expansion:

async fn bin_x(&self) -> ASCOMResult<i32>

fn set_bin_x<'life0, 'async_trait>( &'life0 self, bin_x: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the binning factor for the X axis.

Definition before the #[async_trait] expansion:

async fn set_bin_x(&self, bin_x: i32) -> ASCOMResult

fn bin_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the binning factor for the Y axis.

Definition before the #[async_trait] expansion:

async fn bin_y(&self) -> ASCOMResult<i32>

fn set_bin_y<'life0, 'async_trait>( &'life0 self, bin_y: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the binning factor for the Y axis.

Definition before the #[async_trait] expansion:

async fn set_bin_y(&self, bin_y: i32) -> ASCOMResult

fn camera_state<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<CameraState>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current camera operational state.

Definition before the #[async_trait] expansion:

async fn camera_state(&self) -> ASCOMResult<CameraState>

fn camera_xsize<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the width of the CCD camera chip in unbinned pixels.

Definition before the #[async_trait] expansion:

async fn camera_xsize(&self) -> ASCOMResult<i32>

fn camera_ysize<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the height of the CCD camera chip in unbinned pixels.

Definition before the #[async_trait] expansion:

async fn camera_ysize(&self) -> ASCOMResult<i32>

fn can_abort_exposure<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns true if the camera can abort exposures; false if not.

Definition before the #[async_trait] expansion:

async fn can_abort_exposure(&self) -> ASCOMResult<bool>

fn can_asymmetric_bin<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag showing whether this camera supports asymmetric binning

Definition before the #[async_trait] expansion:

async fn can_asymmetric_bin(&self) -> ASCOMResult<bool>

fn can_fast_readout<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Indicates whether the camera has a fast readout mode.

Definition before the #[async_trait] expansion:

async fn can_fast_readout(&self) -> ASCOMResult<bool>

fn can_get_cooler_power<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

If true, the camera’s cooler power setting can be read.

Definition before the #[async_trait] expansion:

async fn can_get_cooler_power(&self) -> ASCOMResult<bool>

fn can_pulse_guide<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicating whether this camera supports pulse guiding.

Definition before the #[async_trait] expansion:

async fn can_pulse_guide(&self) -> ASCOMResult<bool>

fn can_set_ccd_temperature<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicatig whether this camera supports setting the CCD temperature

Definition before the #[async_trait] expansion:

async fn can_set_ccd_temperature(&self) -> ASCOMResult<bool>

fn can_stop_exposure<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicating whether this camera can stop an exposure that is in progress

Definition before the #[async_trait] expansion:

async fn can_stop_exposure(&self) -> ASCOMResult<bool>

fn ccd_temperature<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current CCD temperature in degrees Celsius.

Definition before the #[async_trait] expansion:

async fn ccd_temperature(&self) -> ASCOMResult<f64>

fn cooler_on<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current cooler on/off state.

Definition before the #[async_trait] expansion:

async fn cooler_on(&self) -> ASCOMResult<bool>

fn set_cooler_on<'life0, 'async_trait>( &'life0 self, cooler_on: bool ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on and off the camera cooler. True = cooler on, False = cooler off

Definition before the #[async_trait] expansion:

async fn set_cooler_on(&self, cooler_on: bool) -> ASCOMResult

fn cooler_power<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the present cooler power level, in percent.

Definition before the #[async_trait] expansion:

async fn cooler_power(&self) -> ASCOMResult<f64>

fn electrons_per_adu<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the gain of the camera in photoelectrons per A/D unit.

Definition before the #[async_trait] expansion:

async fn electrons_per_adu(&self) -> ASCOMResult<f64>

fn exposure_max<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the maximum exposure time supported by StartExposure.

Definition before the #[async_trait] expansion:

async fn exposure_max(&self) -> ASCOMResult<f64>

fn exposure_min<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Minimium exposure time in seconds that the camera supports through StartExposure.

Definition before the #[async_trait] expansion:

async fn exposure_min(&self) -> ASCOMResult<f64>

fn exposure_resolution<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the smallest increment in exposure time supported by StartExposure.

Definition before the #[async_trait] expansion:

async fn exposure_resolution(&self) -> ASCOMResult<f64>

fn fast_readout<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns whenther Fast Readout Mode is enabled.

Definition before the #[async_trait] expansion:

async fn fast_readout(&self) -> ASCOMResult<bool>

fn set_fast_readout<'life0, 'async_trait>( &'life0 self, fast_readout: bool ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets whether Fast Readout Mode is enabled.

Definition before the #[async_trait] expansion:

async fn set_fast_readout(&self, fast_readout: bool) -> ASCOMResult

fn full_well_capacity<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reports the full well capacity of the camera in electrons, at the current camera settings (binning, SetupDialog settings, etc.).

Definition before the #[async_trait] expansion:

async fn full_well_capacity(&self) -> ASCOMResult<f64>

fn gain<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The camera’s gain (GAIN VALUE MODE) OR the index of the selected camera gain description in the Gains array (GAINS INDEX MODE).

Definition before the #[async_trait] expansion:

async fn gain(&self) -> ASCOMResult<i32>

fn set_gain<'life0, 'async_trait>( &'life0 self, gain: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The camera’s gain (GAIN VALUE MODE) OR the index of the selected camera gain description in the Gains array (GAINS INDEX MODE).

Definition before the #[async_trait] expansion:

async fn set_gain(&self, gain: i32) -> ASCOMResult

fn gain_max<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the maximum value of Gain.

Definition before the #[async_trait] expansion:

async fn gain_max(&self) -> ASCOMResult<i32>

fn gain_min<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Minimum value of Gain.

Definition before the #[async_trait] expansion:

async fn gain_min(&self) -> ASCOMResult<i32>

fn gains<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Gains supported by the camera.

Definition before the #[async_trait] expansion:

async fn gains(&self) -> ASCOMResult<Vec<String>>

fn has_shutter<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicating whether this camera has a mechanical shutter.

Definition before the #[async_trait] expansion:

async fn has_shutter(&self) -> ASCOMResult<bool>

fn heat_sink_temperature<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current heat sink temperature (called “ambient temperature” by some manufacturers) in degrees Celsius.

Definition before the #[async_trait] expansion:

async fn heat_sink_temperature(&self) -> ASCOMResult<f64>

fn image_array<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<ImageArray>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an array of 32bit integers containing the pixel values from the last exposure. This call can return either a 2 dimension (monochrome images) or 3 dimension (colour or multi-plane images) array of size NumX * NumY or NumX * NumY * NumPlanes. Where applicable, the size of NumPlanes has to be determined by inspection of the returned Array.

Since 32bit integers are always returned by this call, the returned JSON Type value (0 = Unknown, 1 = short(16bit), 2 = int(32bit), 3 = Double) is always 2. The number of planes is given in the returned Rank value.

When de-serialising to an object it is essential to know the array Rank beforehand so that the correct data class can be used. This can be achieved through a regular expression or by direct parsing of the returned JSON string to extract the Type and Rank values before de-serialising.

This regular expression accomplishes the extraction into two named groups Type and Rank, which can then be used to select the correct de-serialisation data class:

^*"Type":(?<Type>\d*),"Rank":(?<Rank>\d*)

When the SensorType is Monochrome, RGGB, CMYG, CMYG2 or LRGB, the serialised JSON array should have 2 dimensions. For example, the returned array should appear as below if NumX = 7, NumY = 5 and Pxy represents the pixel value at the zero based position x across and y down the image with the origin in the top left corner of the image.

Please note that this is “column-major” order (column changes most rapidly) from the image’s row and column perspective, while, from the array’s perspective, serialisation is actually effected in “row-major” order (rightmost index changes most rapidly). This unintuitive outcome arises because the ASCOM Camera Interface specification defines the image column dimension as the rightmost array dimension.

[

  [P00,P01,P02,P03,P04],

  [P10,P11,P12,P13,P14],

  [P20,P21,P22,P23,P24],

  [P30,P31,P32,P33,P34],

  [P40,P41,P42,P43,P44],

  [P50,P51,P52,P53,P54],

  [P60,P61,P62,P63,P64]

]

When the SensorType is Color, the serialised JSON array will have 3 dimensions. For example, the returned array should appear as below if NumX = 7, NumY = 5 and Rxy, Gxy and Bxy represent the red, green and blue pixel values at the zero based position x across and y down the image with the origin in the top left corner of the image. Please see note above regarding element ordering.

[

  [[R00,G00,B00],[R01,G01,B01],[R02,G02,B02],[R03,G03,B03],[R04,G04,B04]],

  [[R10,G10,B10],[R11,G11,B11],[R12,G12,B12],[R13,G13,B13],[R14,G14,B14]],

  [[R20,G20,B20],[R21,G21,B21],[R22,G22,B22],[R23,G23,B23],[R24,G24,B24]],

  [[R30,G30,B30],[R31,G31,B31],[R32,G32,B32],[R33,G33,B33],[R34,G34,B34]],

  [[R40,G40,B40],[R41,G41,B41],[R42,G42,B42],[R43,G43,B43],[R44,G44,B44]],

  [[R50,G50,B50],[R51,G51,B51],[R52,G52,B52],[R53,G53,B53],[R54,G54,B54]],

  [[R60,G60,B60],[R61,G61,B61],[R62,G62,B62],[R63,G63,B63],[R64,G64,B64]],

]

Performance

Returning an image from an Alpaca device as a JSON array is very inefficient and can result in delays of 30 or more seconds while client and device process and send the huge JSON string over the network. A new, much faster mechanic called ImageBytes - Alpaca ImageBytes Concepts and Implementation has been developed that sends data as a binary byte stream and can offer a 10 to 20 fold reduction in transfer time. It is strongly recommended that Alpaca Cameras implement the ImageBytes mechanic as well as the JSON mechanic.

Definition before the #[async_trait] expansion:

async fn image_array(&self) -> ASCOMResult<ImageArray>

fn image_ready<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicating whether the image is ready to be downloaded from the camera.

Definition before the #[async_trait] expansion:

async fn image_ready(&self) -> ASCOMResult<bool>

fn is_pulse_guiding<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a flag indicating whether the camera is currrently in a PulseGuide operation.

Definition before the #[async_trait] expansion:

async fn is_pulse_guiding(&self) -> ASCOMResult<bool>

fn last_exposure_duration<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reports the actual exposure duration in seconds (i.e. shutter open time).

Definition before the #[async_trait] expansion:

async fn last_exposure_duration(&self) -> ASCOMResult<f64>

fn last_exposure_start_time<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<SystemTime>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reports the actual exposure start in the FITS-standard CCYY-MM-DDThh:mm:ss[.sss…] format.

Definition before the #[async_trait] expansion:

async fn last_exposure_start_time(&self) -> ASCOMResult<std::time::SystemTime>

fn max_adu<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reports the maximum ADU value the camera can produce.

Definition before the #[async_trait] expansion:

async fn max_adu(&self) -> ASCOMResult<i32>

fn max_bin_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the maximum allowed binning for the X camera axis

Definition before the #[async_trait] expansion:

async fn max_bin_x(&self) -> ASCOMResult<i32>

fn max_bin_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the maximum allowed binning for the Y camera axis

Definition before the #[async_trait] expansion:

async fn max_bin_y(&self) -> ASCOMResult<i32>

fn num_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current subframe width, if binning is active, value is in binned pixels.

Definition before the #[async_trait] expansion:

async fn num_x(&self) -> ASCOMResult<i32>

fn set_num_x<'life0, 'async_trait>( &'life0 self, num_x: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the current subframe width.

Definition before the #[async_trait] expansion:

async fn set_num_x(&self, num_x: i32) -> ASCOMResult

fn num_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current subframe height, if binning is active, value is in binned pixels.

Definition before the #[async_trait] expansion:

async fn num_y(&self) -> ASCOMResult<i32>

fn set_num_y<'life0, 'async_trait>( &'life0 self, num_y: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the current subframe height.

Definition before the #[async_trait] expansion:

async fn set_num_y(&self, num_y: i32) -> ASCOMResult

fn offset<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the camera’s offset (OFFSET VALUE MODE) OR the index of the selected camera offset description in the offsets array (OFFSETS INDEX MODE).

Definition before the #[async_trait] expansion:

async fn offset(&self) -> ASCOMResult<i32>

fn set_offset<'life0, 'async_trait>( &'life0 self, offset: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the camera’s offset (OFFSET VALUE MODE) OR the index of the selected camera offset description in the offsets array (OFFSETS INDEX MODE).

Definition before the #[async_trait] expansion:

async fn set_offset(&self, offset: i32) -> ASCOMResult

fn offset_max<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the maximum value of offset.

Definition before the #[async_trait] expansion:

async fn offset_max(&self) -> ASCOMResult<i32>

fn offset_min<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Minimum value of offset.

Definition before the #[async_trait] expansion:

async fn offset_min(&self) -> ASCOMResult<i32>

fn offsets<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the offsets supported by the camera.

Definition before the #[async_trait] expansion:

async fn offsets(&self) -> ASCOMResult<Vec<String>>

fn percent_completed<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the percentage of the current operation that is complete. If valid, returns an integer between 0 and 100, where 0 indicates 0% progress (function just started) and 100 indicates 100% progress (i.e. completion).

Definition before the #[async_trait] expansion:

async fn percent_completed(&self) -> ASCOMResult<i32>

fn pixel_size_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the width of the CCD chip pixels in microns.

Definition before the #[async_trait] expansion:

async fn pixel_size_x(&self) -> ASCOMResult<f64>

fn pixel_size_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the Height of the CCD chip pixels in microns.

Definition before the #[async_trait] expansion:

async fn pixel_size_y(&self) -> ASCOMResult<f64>

fn readout_mode<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

ReadoutMode is an index into the array ReadoutModes and returns the desired readout mode for the camera. Defaults to 0 if not set.

Definition before the #[async_trait] expansion:

async fn readout_mode(&self) -> ASCOMResult<i32>

fn set_readout_mode<'life0, 'async_trait>( &'life0 self, readout_mode: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the ReadoutMode as an index into the array ReadoutModes.

Definition before the #[async_trait] expansion:

async fn set_readout_mode(&self, readout_mode: i32) -> ASCOMResult

fn readout_modes<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

This property provides an array of strings, each of which describes an available readout mode of the camera. At least one string must be present in the list.

Definition before the #[async_trait] expansion:

async fn readout_modes(&self) -> ASCOMResult<Vec<String>>

fn sensor_name<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The name of the sensor used within the camera.

Definition before the #[async_trait] expansion:

async fn sensor_name(&self) -> ASCOMResult<String>

fn sensor_type<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<SensorType>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a value indicating whether the sensor is monochrome, or what Bayer matrix it encodes.

Definition before the #[async_trait] expansion:

async fn sensor_type(&self) -> ASCOMResult<SensorType>

fn set_ccd_temperature<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the current camera cooler setpoint in degrees Celsius.

Definition before the #[async_trait] expansion:

async fn set_ccd_temperature(&self) -> ASCOMResult<f64>

fn set_set_ccd_temperature<'life0, 'async_trait>( &'life0 self, set_ccd_temperature: f64 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set’s the camera’s cooler setpoint in degrees Celsius.

Definition before the #[async_trait] expansion:

async fn set_set_ccd_temperature(&self, set_ccd_temperature: f64) -> ASCOMResult

fn start_x<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the subframe start position for the X axis (0 based) and returns the current value. If binning is active, value is in binned pixels.

Definition before the #[async_trait] expansion:

async fn start_x(&self) -> ASCOMResult<i32>

fn set_start_x<'life0, 'async_trait>( &'life0 self, start_x: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the current subframe X axis start position in binned pixels.

Definition before the #[async_trait] expansion:

async fn set_start_x(&self, start_x: i32) -> ASCOMResult

fn start_y<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<i32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the subframe start position for the Y axis (0 based) and returns the current value. If binning is active, value is in binned pixels.

Definition before the #[async_trait] expansion:

async fn start_y(&self) -> ASCOMResult<i32>

fn set_start_y<'life0, 'async_trait>( &'life0 self, start_y: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the current subframe Y axis start position in binned pixels.

Definition before the #[async_trait] expansion:

async fn set_start_y(&self, start_y: i32) -> ASCOMResult

fn sub_exposure_duration<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult<f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The Camera’s sub exposure duration in seconds. Only available in Camera Interface Version 3 and later.

Definition before the #[async_trait] expansion:

async fn sub_exposure_duration(&self) -> ASCOMResult<f64>

fn set_sub_exposure_duration<'life0, 'async_trait>( &'life0 self, sub_exposure_duration: f64 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets image sub exposure duration in seconds. Only available in Camera Interface Version 3 and later.

Definition before the #[async_trait] expansion:

async fn set_sub_exposure_duration(&self, sub_exposure_duration: f64) -> ASCOMResult

fn abort_exposure<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Aborts the current exposure, if any, and returns the camera to Idle state.

Definition before the #[async_trait] expansion:

async fn abort_exposure(&self) -> ASCOMResult

fn pulse_guide<'life0, 'async_trait>( &'life0 self, direction: PutPulseGuideDirection, duration: i32 ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Activates the Camera’s mount control sytem to instruct the mount to move in a particular direction for a given period of time

Definition before the #[async_trait] expansion:

async fn pulse_guide(&self, direction: PutPulseGuideDirection, duration: i32) -> ASCOMResult

fn start_exposure<'life0, 'async_trait>( &'life0 self, duration: f64, light: bool ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Starts an exposure. Use ImageReady to check when the exposure is complete.

Definition before the #[async_trait] expansion:

async fn start_exposure(&self, duration: f64, light: bool) -> ASCOMResult

fn stop_exposure<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = ASCOMResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stops the current exposure, if any. If an exposure is in progress, the readout process is initiated. Ignored if readout is already in process.

Definition before the #[async_trait] expansion:

async fn stop_exposure(&self) -> ASCOMResult

Trait Implementations

impl Hash for dyn Camera

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl PartialEq for dyn Camera

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for dyn Camera

Implementors