metrology_insight 0.1.0

Embedded-first electrical metrology DSP library in Rust. Pre-compliance implementation of measurement algorithms derived from IEC 61000-4-30:2021 Class S and IEC 62053-21, fully no_std + alloc compatible.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Physical ADC channel types and channel-to-phase mapping.
//!
// Copyright © 2026 Francisco Arcos.
// SPDX-License-Identifier: Apache-2.0

/// Physical ADC channel type (voltage or current per phase).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum ChannelType {
    VoltageA = 0,
    CurrentA = 1,
    VoltageB = 2,
    CurrentB = 3,
    VoltageC = 4,
    CurrentC = 5,
    VoltageN = 6,
    CurrentN = 7,
}

/// Logical phase identifier.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Phase {
    A,
    B,
    C,
    Neutral,
}

/// A voltage–current pair belonging to the same phase.
#[derive(Debug, Clone, Copy)]
pub struct PhasePair {
    /// ADC channel index for voltage (0–7).
    pub voltage_channel: usize,
    /// ADC channel index for current (0–7).
    pub current_channel: usize,
    /// The logical phase this pair belongs to.
    pub phase: Phase,
}

/// Return the active phase pairs for a given system mode.
///
/// * `SinglePhase` → [PhaseA]
/// * `SinglePhaseN` → [PhaseA, Neutral]
/// * `ThreePhase3Wire` → [PhaseA, PhaseB, PhaseC]
/// * `ThreePhase4Wire` → [PhaseA, PhaseB, PhaseC, Neutral]
///
/// # Arguments
///
/// * `mode` — System wiring mode.
///
/// # Returns
///
/// The fixed array of active phase pairs for the given mode.
pub fn phase_pairs_for_mode(mode: crate::types::SystemMode) -> &'static [PhasePair; 4] {
    match mode {
        crate::types::SystemMode::SinglePhase
        | crate::types::SystemMode::SinglePhaseN
        | crate::types::SystemMode::ThreePhase3Wire
        | crate::types::SystemMode::ThreePhase4Wire => &DEFAULT_PAIRS,
    }
}

static DEFAULT_PAIRS: [PhasePair; 4] = [
    PhasePair {
        voltage_channel: 0,
        current_channel: 1,
        phase: Phase::A,
    },
    PhasePair {
        voltage_channel: 2,
        current_channel: 3,
        phase: Phase::B,
    },
    PhasePair {
        voltage_channel: 4,
        current_channel: 5,
        phase: Phase::C,
    },
    PhasePair {
        voltage_channel: 7,
        current_channel: 6,
        phase: Phase::Neutral,
    },
];

/// Signal polarity inversion flags for a phase pair.
///
/// Set when a transformer or CT is wired with reversed polarity.
#[derive(Debug, Clone, Copy)]
pub struct SignalInversion {
    pub invert_voltage: bool,
    pub invert_current: bool,
}

/// Default 3-phase + neutral channel map for ADS131M08.
///
/// CH0=V1, CH1=I1, CH2=V2, CH3=I2, CH4=V3, CH5=I3, CH6=VN, CH7=IN
pub const DEFAULT_CHANNEL_MAP: [ChannelType; 8] = [
    ChannelType::VoltageA,
    ChannelType::CurrentA,
    ChannelType::VoltageB,
    ChannelType::CurrentB,
    ChannelType::VoltageC,
    ChannelType::CurrentC,
    ChannelType::VoltageN,
    ChannelType::CurrentN,
];

/// Return the voltage–current phase pairs for the default 3-phase + neutral map.
///
/// # Returns
///
/// A copy of the default 3-phase + neutral [`PhasePair`] array.
pub fn default_phase_pairs() -> [PhasePair; 4] {
    DEFAULT_PAIRS
}

/// Group 8 channels into phase pairs using a channel-type map.
///
/// # Arguments
///
/// * `map` — Channel-type map for the 8 ADC channels.
///
/// # Returns
///
/// The four [`PhasePair`]s built from the map, falling back to default channel
/// indices when a channel type is not present.
pub fn channel_map_to_pairs(map: &[ChannelType; 8]) -> [PhasePair; 4] {
    /// Find the index of a channel type within the channel map.
    ///
    /// # Arguments
    ///
    /// * `map` — The 8-channel channel-type map.
    /// * `needle` — Channel type to locate.
    ///
    /// # Returns
    ///
    /// The matching channel index, or [`None`] when the channel is not present.
    fn find_ch(map: &[ChannelType; 8], needle: ChannelType) -> Option<usize> {
        map.iter().position(|&c| c == needle)
    }

    [
        PhasePair {
            voltage_channel: find_ch(map, ChannelType::VoltageA).unwrap_or(0),
            current_channel: find_ch(map, ChannelType::CurrentA).unwrap_or(1),
            phase: Phase::A,
        },
        PhasePair {
            voltage_channel: find_ch(map, ChannelType::VoltageB).unwrap_or(2),
            current_channel: find_ch(map, ChannelType::CurrentB).unwrap_or(3),
            phase: Phase::B,
        },
        PhasePair {
            voltage_channel: find_ch(map, ChannelType::VoltageC).unwrap_or(4),
            current_channel: find_ch(map, ChannelType::CurrentC).unwrap_or(5),
            phase: Phase::C,
        },
        PhasePair {
            voltage_channel: find_ch(map, ChannelType::VoltageN).unwrap_or(6),
            current_channel: find_ch(map, ChannelType::CurrentN).unwrap_or(7),
            phase: Phase::Neutral,
        },
    ]
}