stm32-uart-loader 0.1.2

Library and utility for interacting with the STM32 factory UART bootloader
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

use std::{num::ParseIntError};

#[macro_use]
extern crate log;

use anyhow::Context;
use structopt::StructOpt;
use simplelog::{Config, LevelFilter, SimpleLogger};

use stm32_uart_loader::{Options, Programmer};

#[derive(Clone, Debug, StructOpt)]
pub struct Args {
    #[structopt(subcommand)]
    command: Commands,

    #[structopt(flatten)]
    options: Options,

    /// Serial port to connect to
    #[structopt(long, default_value = "/dev/ttyUSB0")]
    port: String,

    /// Serial port baud rate
    #[structopt(long, default_value = "57600")]
    baud: usize,

    /// Log level for console output
    #[structopt(long, default_value = "info")]
    log_level: LevelFilter,
}


#[derive(Clone, Debug, StructOpt)]
pub enum Commands {
    Read {
        /// Offset from which to start memory read
        #[structopt(long, parse(try_from_str=u32_from_hex), default_value="0x08000000")]
        offset: u32,

        /// Length of memory to read
        #[structopt(long, parse(try_from_str=bytefmt::parse))]
        length: u64,

        /// File to read data into
        #[structopt(long)]
        file: String,
    },
    Write {
        /// Offset from which to start memory write
        #[structopt(long, parse(try_from_str=u32_from_hex), default_value="0x08000000")]
        offset: u32,

        /// File to read data from
        #[structopt(long)]
        file: String,
    },
    Erase {
        /// Offset from which to start memory read
        #[structopt(long, default_value="0")]
        page_offset: u8,

        /// Length of memory to read
        #[structopt(long)]
        page_count: u8,
    },
    EraseAll,
    //ChipId,
}

fn u32_from_hex(s: &str) -> Result<u32, ParseIntError> {
    let s = s.trim_start_matches("0x");
    u32::from_str_radix(s, 16)
}

fn main() -> Result<(), anyhow::Error> {
    // Parse out arguments
    let o = Args::from_args();

    // Configure logger
    let _ = SimpleLogger::init(o.log_level, Config::default());

    debug!("Connecting to bootloader");

    let mut p = Programmer::linux(&o.port, o.baud, o.options.clone())
        .context("Error connecting to bootloader")?;

    // Execute commands
    match &o.command {
        Commands::Read{offset, length, file} => {
            info!("Reading {} bytes from memory at offset 0x{:08x}", length, offset);

            let mut data = vec![0u8; *length as usize];
            p.read(*offset, &mut data).context("Error reading memory")?;

            std::fs::write(file, data)
                .context("Failure writing to file")?;

            info!("Read complete!");
        },

        Commands::Write{offset, file} => {
            let data = std::fs::read(file)
                .context("Failure reading from file")?;

            info!("Writing {} bytes to memory at offset 0x{:08x}", data.len(), offset);

            p.write(*offset, &data)
                .context("Error writing memory")?;

            info!("Write complete!");
        },
        Commands::Erase{page_offset, page_count} => {
            info!("Erasing {} pages from index {}", page_count, page_offset);

            p.erase(*page_offset, *page_count)
                .context("Error erasing pages")?;
        },
        Commands::EraseAll => {
            info!("Erasing entire device flash");

            p.erase_all()
                .context("Error erasing pages")?;
        }
    }

    if !o.options.no_reset {
        debug!("Resetting device to application");
        p.reset(false)
            .context("Error resetting device")?;
    }

    Ok(())
}