dlms_cosem 0.2.0

A `no_std` library for parsing DLMS/COSEM messages.
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

use core::fmt;

use nom::{IResult, number::complete::u8};

#[derive(Clone, PartialEq)]
pub struct SecurityControl {
  security_control: u8
}

impl fmt::Debug for SecurityControl {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    f.debug_struct("SecurityControl")
      .field("suite_id", &self.suite_id())
      .field("authentication", &self.authentication())
      .field("encryption", &self.encryption())
      .field("broadcast", &self.broadcast())
      .field("compression", &self.compression())
      .finish()
  }
}

impl SecurityControl {
  const COMPRESSION_BIT: u8 =    0b10000000;
  const BROADCAST_BIT: u8 =      0b01000000;
  const ENCRYPTION_BIT: u8 =     0b00100000;
  const AUTHENTICATION_BIT: u8 = 0b00010000;

  pub fn parse(input: &[u8]) -> IResult<&[u8], Self> {
    let (input, security_control) = u8(input)?;
    Ok((input, Self { security_control }))
  }

  pub fn suite_id(&self) -> u8 {
    self.security_control & 0b00001111
  }

  pub fn authentication(&self) -> bool {
    (self.security_control & Self::AUTHENTICATION_BIT) != 0
  }

  pub fn set_authentication(&mut self, authentication: bool) {
    if authentication {
      self.security_control |= Self::AUTHENTICATION_BIT
    } else {
      self.security_control &= !Self::AUTHENTICATION_BIT
    }
  }

  pub fn encryption(&self) -> bool {
    (self.security_control & Self::ENCRYPTION_BIT) != 0
  }

  pub fn set_encryption(&mut self, encryption: bool) {
    if encryption {
      self.security_control |= Self::ENCRYPTION_BIT
    } else {
      self.security_control &= !Self::ENCRYPTION_BIT
    }
  }

  pub fn broadcast(&self) -> bool {
    (self.security_control & Self::BROADCAST_BIT) != 0
  }

  pub fn set_broadcast(&mut self, broadcast: bool) {
    if broadcast {
      self.security_control |= Self::BROADCAST_BIT
    } else {
      self.security_control &= !Self::BROADCAST_BIT
    }
  }

  pub fn compression(&self) -> bool {
    (self.security_control & Self::COMPRESSION_BIT) != 0
  }

  pub fn set_compression(&mut self, compression: bool) {
    if compression {
      self.security_control |= Self::COMPRESSION_BIT
    } else {
      self.security_control &= !Self::COMPRESSION_BIT
    }
  }
}