ubmsc 0.1.1

A client for Battery Management Systems (BMS).
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

use crate::{Error, MacAddr, Result};

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Device identifier
#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum DeviceId {
    /// MAC Address
    Mac(MacAddr),
    /// Device name
    Name(String),
}

impl core::str::FromStr for DeviceId {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        Ok(s.parse()
            .map(Self::Mac)
            .unwrap_or_else(|_| Self::Name(s.into())))
    }
}

impl From<MacAddr> for DeviceId {
    fn from(mac: MacAddr) -> Self {
        Self::Mac(mac)
    }
}

impl From<&'_ str> for DeviceId {
    fn from(name: &'_ str) -> Self {
        Self::Name(name.into())
    }
}

impl From<String> for DeviceId {
    fn from(name: String) -> Self {
        Self::Name(name)
    }
}

impl core::fmt::Display for DeviceId {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        match self {
            Self::Mac(mac) => mac.fmt(f),
            Self::Name(name) => name.fmt(f),
        }
    }
}

/// BMS device information
#[derive(Clone, Default, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DeviceInfo {
    /// Model name
    pub device_model: String,
    /// Hadrware version
    pub hardware_version: String,
    /// Firmware version
    pub software_version: String,
    /// Time in seconds since poweron
    pub up_time: usize,
    /// Number of powerons
    pub poweron_times: usize,
    /// Device name
    pub device_name: String,
    /// Device passcode
    pub device_passcode: String,
    /// Manufacturing date
    pub manufacturing_date: String,
    /// Serial number
    pub serial_number: String,
    /// Passcode
    pub passcode: String,
    /// Userdata
    pub userdata: String,
    /// Passcode to change settings
    pub setup_passcode: String,
    /// Second userdata
    pub userdata2: String,
}

/// BMS cell data
#[derive(Clone, Default, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct CellData {
    /// Cell voltages in Volts
    pub cell_voltage: Vec<f32>,
    /// Averate cell voltage in Volts
    pub average_cell_voltage: f32,
    /// Maximum voltage difference between cells in Volts
    pub delta_cell_voltage: f32,
    /// Balance current in Amperes
    pub balance_current: f32,
    /// Cell resistances in Ohms
    pub cell_resistance: Vec<f32>,
    /// Amount battery voltage between terminals in Volts
    pub battery_voltage: f32,
    /// Amount battery power in Watts
    pub battery_power: f32,
    /// Battery current in Amperes
    pub battery_current: f32,
    /// Battery temperatures in Celsius degrees
    pub battery_temperature: Vec<f32>,
    /// BMS power mosfet temperature in Celsius degrees
    pub mosfet_temperature: f32,
    /// Remain battery capacity in percents
    pub remain_percent: u8,
    /// Remain battery capacity in Amperes*Hours
    pub remain_capacity: f32,
    /// Nominal battery capacity in Amperes*Hours
    pub nominal_capacity: f32,
    /// Number of battery cycles
    pub cycle_count: usize,
    /// Cicle battery capacity in Amperes*Hours
    pub cycle_capacity: f32,
    /// Time in seconds since last poweron
    pub up_time: usize,
}