ascom-alpaca-core 0.1.1

Framework-agnostic ASCOM Alpaca protocol types and traits for Rust — all 10 device types, no HTTP framework required
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::device::Device;
use crate::types::{AlpacaError, AlpacaResult};

/// ASCOM Switch device trait (ISwitchV3).
///
/// Multi-channel device supporting boolean (on/off), multi-state (selector),
/// and analog (continuous range) channels. All methods take a switch `id` parameter
/// (0 to `max_switch - 1`) to address individual channels.
///
/// Each channel has: min/max range, step size, read/write capability, and a name.
/// Boolean channels use min=0, max=1, step=1. Analog channels use finer steps.
///
/// ISwitchV3 adds optional async methods: `can_async`, `set_async`, `set_async_value`,
/// `cancel_async`, `state_change_complete`.
///
/// # Example
///
/// ```rust
/// use ascom_alpaca_core::prelude::*;
/// use ascom_alpaca_core::switch::Switch;
///
/// # struct MySwitch;
/// # impl Device for MySwitch {
/// #     fn static_name(&self) -> &str { "Sw" }
/// #     fn unique_id(&self) -> &str { "sw-001" }
/// #     fn device_type(&self) -> DeviceType { DeviceType::Switch }
/// # }
/// impl Switch for MySwitch {
///     fn max_switch(&self) -> AlpacaResult<i32> { Ok(2) }
///     fn can_write(&self, id: u32) -> AlpacaResult<bool> { Ok(true) }
///     fn get_switch(&self, id: u32) -> AlpacaResult<bool> { Ok(false) }
///     fn set_switch(&self, id: u32, state: bool) -> AlpacaResult<()> { Ok(()) }
///     fn get_switch_value(&self, id: u32) -> AlpacaResult<f64> { Ok(0.0) }
///     fn set_switch_value(&self, id: u32, value: f64) -> AlpacaResult<()> { Ok(()) }
///     fn min_switch_value(&self, id: u32) -> AlpacaResult<f64> { Ok(0.0) }
///     fn max_switch_value(&self, id: u32) -> AlpacaResult<f64> { Ok(1.0) }
///     fn switch_step(&self, id: u32) -> AlpacaResult<f64> { Ok(1.0) }
/// }
/// ```
pub trait Switch: Device {
    /// Returns the number of switch channels (0 to N-1).
    fn max_switch(&self) -> AlpacaResult<i32> {
        Err(AlpacaError::NotImplemented("max_switch".into()))
    }

    /// Returns whether the specified switch can be written to.
    fn can_write(&self, _id: u32) -> AlpacaResult<bool> {
        Err(AlpacaError::NotImplemented("can_write".into()))
    }

    /// Returns the state of the specified switch as a boolean.
    fn get_switch(&self, _id: u32) -> AlpacaResult<bool> {
        Err(AlpacaError::NotImplemented("get_switch".into()))
    }

    /// Sets the state of the specified switch.
    fn set_switch(&self, _id: u32, _state: bool) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("set_switch".into()))
    }

    /// Returns the value of the specified switch as a double.
    fn get_switch_value(&self, _id: u32) -> AlpacaResult<f64> {
        Err(AlpacaError::NotImplemented("get_switch_value".into()))
    }

    /// Sets the value of the specified switch.
    fn set_switch_value(&self, _id: u32, _value: f64) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("set_switch_value".into()))
    }

    /// Returns the name of the specified switch.
    fn get_switch_name(&self, _id: u32) -> AlpacaResult<String> {
        Err(AlpacaError::NotImplemented("get_switch_name".into()))
    }

    /// Sets the name of the specified switch.
    fn set_switch_name(&self, _id: u32, _name: &str) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("set_switch_name".into()))
    }

    /// Returns the description of the specified switch.
    fn get_switch_description(&self, _id: u32) -> AlpacaResult<String> {
        Err(AlpacaError::NotImplemented("get_switch_description".into()))
    }

    /// Returns the minimum value of the specified switch.
    fn min_switch_value(&self, _id: u32) -> AlpacaResult<f64> {
        Err(AlpacaError::NotImplemented("min_switch_value".into()))
    }

    /// Returns the maximum value of the specified switch.
    fn max_switch_value(&self, _id: u32) -> AlpacaResult<f64> {
        Err(AlpacaError::NotImplemented("max_switch_value".into()))
    }

    /// Returns the step size for the specified switch.
    fn switch_step(&self, _id: u32) -> AlpacaResult<f64> {
        Err(AlpacaError::NotImplemented("switch_step".into()))
    }

    // --- ISwitchV3 async methods ---

    /// Returns whether the specified switch supports asynchronous state changes.
    fn can_async(&self, _id: u32) -> AlpacaResult<bool> {
        Ok(false)
    }

    /// Asynchronously sets the boolean state of the specified switch.
    fn set_async(&self, _id: u32, _state: bool) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("set_async".into()))
    }

    /// Asynchronously sets the value of the specified switch.
    fn set_async_value(&self, _id: u32, _value: f64) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("set_async_value".into()))
    }

    /// Cancels an in-progress asynchronous state change on the specified switch.
    fn cancel_async(&self, _id: u32) -> AlpacaResult<()> {
        Err(AlpacaError::NotImplemented("cancel_async".into()))
    }

    /// Returns whether the most recent asynchronous operation on the specified switch has completed.
    fn state_change_complete(&self, _id: u32) -> AlpacaResult<bool> {
        Err(AlpacaError::NotImplemented("state_change_complete".into()))
    }
}