indi 5.1.1

Client library for interfacing with the Instrument Neutral Distributed Interface (INDI) protocol.
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

use futures::Stream;
use tokio_stream::wrappers::errors::BroadcastStreamRecvError;
use twinkle_client::notify::ArcCounter;

use crate::{
    client::{active_device::ActiveDevice, ChangeError},
    Number, Parameter, Text,
};

use super::{
    parameter_with_config::{
        get_parameter_value, ActiveParameterWithConfig, NumberParameter, OneOfMany,
        SingleValueParamConfig,
    },
    DeviceError, DeviceSelectionError,
};

#[derive(Clone, Debug, PartialEq)]
pub enum LightState {
    On,
    Off,
}

impl From<bool> for LightState {
    fn from(value: bool) -> Self {
        match value {
            true => LightState::On,
            false => LightState::Off,
        }
    }
}

pub struct FlatPanel {
    device: ActiveDevice,
    config: FlatPanelConfig,
}

struct FlatPanelConfig {
    brightness: SingleValueParamConfig<Number>,
    light: OneOfMany<LightState>,
}

#[derive(derive_more::Deref)]
pub struct Light(ActiveParameterWithConfig<OneOfMany<LightState>>);

impl FlatPanel {
    /// Connect to the flat panel.
    pub async fn connect(
        &self,
    ) -> Result<
        impl Stream<Item = Result<ArcCounter<Parameter>, BroadcastStreamRecvError>>,
        ChangeError<()>,
    > {
        self.device
            .change("CONNECTION", vec![("CONNECT", true)])
            .await
    }

    async fn get_driver_name(device: &ActiveDevice) -> Result<Text, super::DeviceSelectionError> {
        if let Some(driver_name) = get_parameter_value(device, "DRIVER_INFO", "DRIVER_NAME").await {
            return Ok(driver_name);
        }
        Err(DeviceSelectionError::DeviceMismatch)
    }

    fn get_config(driver_name: &Text) -> Result<FlatPanelConfig, super::DeviceSelectionError> {
        match driver_name.value.as_str() {
            "Light Panel Simulator" => Ok(FlatPanelConfig {
                brightness: SingleValueParamConfig::new(
                    "FLAT_LIGHT_INTENSITY",
                    "FLAT_LIGHT_INTENSITY_VALUE",
                ),
                light: OneOfMany::new(
                    "FLAT_LIGHT_CONTROL",
                    [
                        ("FLAT_LIGHT_ON", LightState::On),
                        ("FLAT_LIGHT_OFF", LightState::Off),
                    ]
                    .into_iter()
                    .collect(),
                ),
            }),
            "Deep Sky Dad FP" => Ok(FlatPanelConfig {
                brightness: SingleValueParamConfig::new(
                    "FLAT_LIGHT_INTENSITY",
                    "FLAT_LIGHT_INTENSITY_VALUE",
                ),
                light: OneOfMany::new(
                    "FLAT_LIGHT_CONTROL",
                    [
                        ("FLAT_LIGHT_ON", LightState::On),
                        ("FLAT_LIGHT_OFF", LightState::Off),
                    ]
                    .into_iter()
                    .collect(),
                ),
            }),
            _ => Err(DeviceSelectionError::DeviceMismatch),
        }
    }

    pub(in crate::telescope) async fn new(
        device: ActiveDevice,
    ) -> Result<Self, super::DeviceSelectionError> {
        let driver_name = Self::get_driver_name(&device).await?;
        let config = FlatPanel::get_config(&driver_name)?;

        Ok(FlatPanel { device, config })
    }

    /// Get the parameter that controls the brightness.
    pub async fn brightness(&self) -> Result<NumberParameter, DeviceError> {
        Ok(
            ActiveParameterWithConfig::new(&self.device, self.config.brightness.clone())
                .await?
                .into(),
        )
    }

    /// Get the parameter that controls whether the light is on/off.
    pub async fn light(&self) -> Result<Light, DeviceError> {
        let apwc = ActiveParameterWithConfig::new(&self.device, self.config.light.clone()).await?;
        Ok(Light(apwc))
    }
}