owon-spe 0.1.0

OWON SPE programmable power-suppy api crate
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

use std::io::{Read, Write};

use clap::{Parser, Subcommand};
use owon_spe::SPE;

#[derive(Debug, Subcommand)]
enum OutputCommand {
    On,
    Off,
    Volt { volt: f32 },
    VoltLimit { volt: f32 },
    Current { current: f32 },
    CurrentLimit { current: f32 },
}

#[derive(Debug, Subcommand)]
enum MeasureCommand {
    Volt,
    Current,
    Power,
    All,
    AllInfo,
}

#[derive(Debug, Subcommand)]
enum Command {
    Idn,
    Reset,
    Output {
        #[command(subcommand)]
        command: Option<OutputCommand>,
    },
    Measure {
        #[command(subcommand)]
        command: Option<MeasureCommand>,
    },
}

#[derive(clap::Parser)]
struct Opts {
    port: String,
    #[command(subcommand)]
    command: Command,
}

fn measure<T: Read + Write>(mut spe: SPE<T>, cmd: Option<MeasureCommand>) -> anyhow::Result<()> {
    match cmd {
        Some(MeasureCommand::Volt) => println!("Power: {}", spe.measure_volt()?),
        Some(MeasureCommand::Current) => println!("Power: {}", spe.measure_current()?),
        Some(MeasureCommand::Power) => println!("Power: {}", spe.measure_power()?),
        Some(MeasureCommand::All) => {
            let o = spe.measure_all()?;
            println!("Volt: {}", o.volt);
            println!("Current: {}", o.current);
        }
        Some(MeasureCommand::AllInfo) | None => {
            let o = spe.measure_all_info()?;
            println!("Volt: {}", o.volt);
            println!("Current: {}", o.current);
            println!("Power: {}", o.power);
            println!("Overvoltage: {}", o.over_voltage);
            println!("Overcurrent: {}", o.over_current);
            println!("OverTemperature: {}", o.over_temperature);
            println!("Mode: {}", o.mode);
        }
    }
    Ok(())
}

fn output<T: Read + Write>(mut spe: SPE<T>, cmd: Option<OutputCommand>) -> anyhow::Result<()> {
    if let Some(cmd) = cmd {
        match cmd {
            OutputCommand::On => spe.enable_output()?,
            OutputCommand::Off => spe.disable_output()?,
            OutputCommand::Volt { volt } => spe.set_volt(volt)?,
            OutputCommand::VoltLimit { volt } => spe.set_volt_limit(volt)?,
            OutputCommand::Current { current } => spe.set_current(current)?,
            OutputCommand::CurrentLimit { current } => spe.set_current_limit(current)?,
        }
    } else {
        println!("Output: {}", spe.output()?);
        println!("Voltage: {}", spe.volt()?);
        println!("Voltage Limit: {}", spe.volt_limit()?);
        println!("Current: {}", spe.current()?);
        println!("Current Limit: {}", spe.current_limit()?);
    }
    Ok(())
}

fn main() -> anyhow::Result<()> {
    env_logger::init();
    let opts = Opts::parse();

    let mut spe = SPE::from_serialport(&opts.port)?;
    match opts.command {
        Command::Idn => {
            let idn = spe.idn()?;
            println!(
                "Model: {}, Serial: {}, Firmware: {}",
                idn.model, idn.serial, idn.fw
            )
        }
        Command::Reset => spe.reset()?,
        Command::Output { command } => output(spe, command)?,
        Command::Measure { command } => measure(spe, command)?,
    }

    Ok(())
}