rxprog 1.0.2

Library implementing the Boot Mode protocol for specific Renesas microcontrollers and CLI for programming firmware images
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

/// A device supported by the boot program
#[derive(Debug, PartialEq)]
pub struct SupportedDevice {
    /// A 4 character identifier
    pub device_code: String,
    /// Human-readable name of the device
    pub series_name: String,
}

/// A clock prescaler ratio
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MultiplicationRatio {
    /// Divide the input clock by the given ratio
    DivideBy(u8),
    /// Multiply the input clock by the given ratio
    MultiplyBy(u8),
}

impl From<u8> for MultiplicationRatio {
    /// Parse a byte encoded ratio
    ///
    /// # Examples
    /// ```
    /// use rxprog::command::data::MultiplicationRatio;
    ///
    /// assert_eq!(MultiplicationRatio::from(0xFF), MultiplicationRatio::DivideBy(1));
    /// assert_eq!(MultiplicationRatio::from(0xFE), MultiplicationRatio::DivideBy(2));
    /// assert_eq!(MultiplicationRatio::from(0x01), MultiplicationRatio::MultiplyBy(1));
    /// assert_eq!(MultiplicationRatio::from(0x02), MultiplicationRatio::MultiplyBy(2));
    /// ```
    fn from(item: u8) -> Self {
        let item_signed = i8::from_le_bytes([item]);
        let ratio = item_signed.abs() as u8;

        match item_signed {
            x if x < 0 => MultiplicationRatio::DivideBy(ratio),
            x if x > 0 => MultiplicationRatio::MultiplyBy(ratio),
            _ => panic!("Multiplication ratio cannot be zero"),
        }
    }
}

impl From<MultiplicationRatio> for u8 {
    /// Convert the ratio to a byte, where division is represented as the negative ratio in 2's
    /// complement
    ///
    /// # Examples
    /// ```
    /// use rxprog::command::data::MultiplicationRatio;
    ///
    /// assert_eq!(u8::from(MultiplicationRatio::DivideBy(1)), 0xFF);
    /// assert_eq!(u8::from(MultiplicationRatio::DivideBy(2)), 0xFE);
    /// assert_eq!(u8::from(MultiplicationRatio::MultiplyBy(1)), 0x01);
    /// assert_eq!(u8::from(MultiplicationRatio::MultiplyBy(2)), 0x02);
    /// ```
    fn from(item: MultiplicationRatio) -> Self {
        match item {
            MultiplicationRatio::DivideBy(ratio) => -(ratio as i8) as u8,
            MultiplicationRatio::MultiplyBy(ratio) => ratio as u8,
        }
    }
}

/// Availability state of a data area
#[derive(Debug, PartialEq)]
pub enum DataAreaAvailability {
    /// The device supports a data area
    Available,
    /// The device does not support a data area
    Unavailable,
}

/// A distinct region of memory
#[derive(Debug)]
pub enum MemoryArea {
    /// User boot area, i.e. user specified bootloader
    UserBootArea,
    /// User area, i.e. typical application code and data
    UserArea,
}

/// State of the block
#[derive(Debug, PartialEq)]
pub enum ErasureState {
    /// No blocks programmed
    Blank,
    /// One or more blocks programmed
    NotBlank,
}

/// The state of the lock bit protecting a memory region
#[derive(Debug, PartialEq)]
pub enum LockBitStatus {
    /// Lock bit set - write/erase disallowed
    Locked,
    /// Lock bit not set - write/erase allowed
    Unlocked,
}