scopinator-cli 0.1.2

CLI for the scopinator telescope control library
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

use std::net::Ipv4Addr;
use std::time::Duration;

use anyhow::{Context, Result};
use scopinator_seestar::command::Command;
use scopinator_seestar::response::DeviceStateResult;
use scopinator_seestar::{InteropKey, SeestarClient, SeestarConfig};

pub async fn status(host: Ipv4Addr, interop_key: Option<InteropKey>) -> Result<()> {
    println!("Connecting to {host}...");

    let client = SeestarClient::connect_with_config(host, SeestarConfig { interop_key }).await?;
    client
        .wait_for_connection(Duration::from_secs(10))
        .await
        .context("timed out waiting for connection")?;

    println!("Connected. Fetching device state...\n");

    let response = client.send_command(Command::GetDeviceState).await?;
    let result = response.result.unwrap_or_default();

    let state: DeviceStateResult = serde_json::from_value(result)
        .context("failed to parse device state")?;

    // Device info
    if let Some(device) = &state.device {
        if let Some(name) = &device.name {
            println!("Device:    {name}");
        }
        if let Some(model) = &device.product_model {
            println!("Model:     {model}");
        }
        if let Some(sn) = &device.sn {
            println!("Serial:    {sn}");
        }
        if let Some(fw) = &device.firmware_ver_string {
            println!("Firmware:  {fw}");
        }
    }

    // Pi status
    if let Some(pi) = &state.pi_status {
        if let Some(temp) = pi.temp {
            println!("Temp:      {temp:.1}C");
        }
        if let Some(batt) = pi.battery_capacity {
            println!("Battery:   {batt}%");
        }
        if let Some(charger) = &pi.charger_status {
            println!("Charger:   {charger}");
        }
    }

    // Mount
    if let Some(mount) = &state.mount
        && let Some(tracking) = mount.tracking
    {
        println!("Tracking:  {}", if tracking { "on" } else { "off" });
    }

    // Focuser
    if let Some(focuser) = &state.focuser
        && let Some(step) = focuser.step
    {
        let max = focuser.max_step.unwrap_or(0);
        println!("Focuser:   {step}/{max}");
    }

    client.shutdown().await;
    Ok(())
}