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

//! # Bits utilities
//! A toolbox of small utilities that manipulate bitstream data.
//! Useful for debugging streams from embedded devices.

/// Convert bits stream to vector (MSB is Vec[0])
pub fn bits_to_vec(bits: u64, out_len: u8) -> Vec<u8> {
    let mut in_bits = bits;
    let mut output: Vec<u8> = vec![];

    let mut idx = 0;
    while in_bits > 0 && idx < out_len {
        output.push((in_bits & 0x01) as u8);
        in_bits >>= 1;
        idx += 1;
    }

    for _i in idx..out_len {
        output.push(0);
    }

    output.into_iter().rev().collect()
}

/// Convert vector to bits stream (Vec[0] is MSB)
pub fn vec_to_bits(vec: &[u8]) -> u64 {
    vec.iter().fold(0b0, |acc, &x| (acc << 1) | x as u64)
}

pub fn bit_vec_to_hex_string(vec: &[u8]) -> String {
    let mut hex_string = String::new();

    let mod_vec = vec.len() % 4;
    let mut vec = vec.to_owned();

    if mod_vec != 0 {
        vec.append(&mut vec![0; 4 - mod_vec]);
    }

    for i in (0..vec.len()).step_by(4) {
        let bits = vec[i..i + 4].iter().fold(0b0, |acc, &x| (acc << 1) | x);

        let char = match bits {
            0..=9 => bits + 48,
            10..=15 => bits + 55,
            _ => unreachable!(),
        } as char;

        hex_string.push(char);
    }

    hex_string
}

#[cfg(test)]
mod tests {
    use crate::bits::*;

    #[test]
    fn bits_to_vec_test() {
        let received_bit_stream: u64 = 0b110101000100111010110;
        let expected_bytes_array: Vec<u8> = vec![
            1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,
        ];

        let bytes = bits_to_vec(received_bit_stream, 21);

        assert_eq!(expected_bytes_array, bytes);
    }

    #[test]
    fn bit_vec_to_hex_string_test() {
        let bit_array: Vec<u8> = vec![
            1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0,
        ];
        let expected_string = "D44EB0".to_string();

        let string = bit_vec_to_hex_string(&bit_array);

        assert_eq!(expected_string, string);
    }
}