spd3303x 0.2.1

Library for controlling the *Siglent SPD3303X* programmable power supply.
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

use anyhow::anyhow;
use spd3303x::{
    Result,
    channel_control::ChannelControl,
    commands::{Channel, LimitQuantity, MemorySlot, OperationMode, Quantity, State},
    spd3303x::Spd3303x,
};

fn test_device() -> Result<Spd3303x> {
    let hostname = std::env::var("TEST_SPD3303X")
        .map_err(|e| anyhow!("Environment variable TEST_SPD3303X not set! `{e}`"))?;

    let power_supply = Spd3303x::connect_hostname(hostname.as_str())?;
    Ok(power_supply)
}

fn test_channel() -> Result<ChannelControl> {
    let spd = test_device()?;
    Ok(spd.into_channels().0)
}

#[test]
fn test_identity() -> Result<()> {
    // This obviously only works with one specific device
    let mut spd = test_device()?;
    let identity = spd.get_identity()?;
    assert_eq!(identity.company_name, "Siglent Technologies");
    assert_eq!(identity.model_number, "SPD3303X");
    assert_eq!(identity.serial_number, "SPD3XJGQ805993");
    assert_eq!(identity.software_version, "1.01.01.03.11R1");
    assert_eq!(identity.hardware_version, "V6.2");
    Ok(())
}

#[test]
fn test_save_recall() -> Result<()> {
    let mut spd = test_device()?;

    spd.set_limit(Channel::One, LimitQuantity::Current, 1.0.into())?;
    spd.save(MemorySlot::One)?;

    spd.set_limit(Channel::One, LimitQuantity::Current, 2.0.into())?;
    spd.save(MemorySlot::Two)?;

    assert_eq!(spd.get_limit(Channel::One, LimitQuantity::Current)?, 2.0);

    spd.recall(MemorySlot::One)?;
    assert_eq!(spd.get_limit(Channel::One, LimitQuantity::Current)?, 1.0);

    spd.recall(MemorySlot::Two)?;
    assert_eq!(spd.get_limit(Channel::One, LimitQuantity::Current)?, 2.0);

    Ok(())
}

#[test]
fn test_measure() -> Result<()> {
    let channel = test_channel()?;

    channel.set_limit(LimitQuantity::Voltage, 1.337.into())?;
    channel.set_output(State::Off)?;
    assert_eq!(channel.measure(Quantity::Voltage)?, 0.0);
    channel.set_output(State::On)?;
    assert!(channel.measure(Quantity::Voltage)? > 1.250);
    channel.set_output(State::Off)?;

    Ok(())
}

#[test]
fn test_limit() -> Result<()> {
    let channel = test_channel()?;

    channel.set_limit(LimitQuantity::Voltage, 1.337.into())?;
    assert_eq!(channel.get_limit(LimitQuantity::Voltage)?, 1.337);

    channel.set_limit(LimitQuantity::Voltage, 2.337.into())?;
    assert_eq!(channel.get_limit(LimitQuantity::Voltage)?, 2.337);

    Ok(())
}

#[test]
fn test_output() -> Result<()> {
    let channel = test_channel()?;

    channel.set_output(State::On)?;
    assert_eq!(channel.get_output()?, State::On);

    channel.set_output(State::Off)?;
    assert_eq!(channel.get_output()?, State::Off);

    Ok(())
}

#[test]
fn test_operation_mode() -> Result<()> {
    let mut spd = test_device()?;
    spd.set_output_mode(OperationMode::Independent)?;
    assert_eq!(spd.get_status()?.operation_mode, OperationMode::Independent);

    spd.set_output_mode(OperationMode::Parallel)?;
    assert_eq!(spd.get_status()?.operation_mode, OperationMode::Parallel);

    spd.set_output_mode(OperationMode::Series)?;
    assert_eq!(spd.get_status()?.operation_mode, OperationMode::Series);

    spd.set_output_mode(OperationMode::Independent)?;
    assert_eq!(spd.get_status()?.operation_mode, OperationMode::Independent);

    Ok(())
}

#[test]
fn test_auto_turn_off() -> Result<()> {
    {
        let channel = test_channel()?.into_auto_turn_off();
        channel.set_output(State::On)?;
        assert_eq!(channel.get_output()?, State::On);
    }

    let channel = test_channel()?;
    assert_eq!(channel.get_output()?, State::Off);

    Ok(())
}