espflash 1.7.0

A command-line tool for flashing Espressif devices over serial
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

use serde::{Deserialize, Serialize};

use crate::Chip;

/// Flash stub object (deserialized from json as used by `esptool.py`)
#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
pub struct FlashStub {
    /// Entry point (address)
    entry: u32,
    /// Text (b64 encoded)
    text: String,
    /// Start of text section address
    text_start: u32,
    /// Data
    data: String,
    /// Start of data section address
    data_start: u32,
}

// Include stub objects in binary

const STUB_32: &str = include_str!("../resources/stubs/stub_flasher_32.json");
const STUB_32C2: &str = include_str!("../resources/stubs/stub_flasher_32c2.json");
const STUB_32C3: &str = include_str!("../resources/stubs/stub_flasher_32c3.json");
const STUB_32S2: &str = include_str!("../resources/stubs/stub_flasher_32s2.json");
const STUB_32S3: &str = include_str!("../resources/stubs/stub_flasher_32s3.json");
const STUB_8266: &str = include_str!("../resources/stubs/stub_flasher_8266.json");

impl FlashStub {
    /// Fetch flash stub for the provided chip
    pub fn get(chip: Chip) -> FlashStub {
        let s = match chip {
            Chip::Esp32 => STUB_32,
            Chip::Esp32c2 => STUB_32C2,
            Chip::Esp32c3 => STUB_32C3,
            Chip::Esp32s2 => STUB_32S2,
            Chip::Esp32s3 => STUB_32S3,
            Chip::Esp8266 => STUB_8266,
        };

        let stub: FlashStub = serde_json::from_str(s).unwrap();

        stub
    }

    /// Fetch stub entry point
    pub fn entry(&self) -> u32 {
        self.entry
    }

    /// Fetch text start address and bytes
    pub fn text(&self) -> (u32, Vec<u8>) {
        let v = base64::decode(&self.text).unwrap();
        (self.text_start, v)
    }

    /// Fetch data start address and bytes
    pub fn data(&self) -> (u32, Vec<u8>) {
        let v = base64::decode(&self.data).unwrap();
        (self.data_start, v)
    }
}

#[cfg(test)]
mod tests {
    use strum::IntoEnumIterator;

    use super::FlashStub;
    use crate::Chip;

    #[test]
    fn check_stub_encodings() {
        for c in Chip::iter() {
            // Stub must be valid json
            let s = FlashStub::get(c);

            // Data decoded from b64
            let _ = s.text();
            let _ = s.data();
        }
    }
}