feat: wip - add json output to cli

Author: ckrenslehner

Cargo.lock

@@ -15,10 +15,15 @@ bpaf = { version = "0.9", features = ["derive"] }
 env_logger = "0.11.5"
 indicatif = "0.17.9"
 indicatif-log-bridge = "0.2.3"
-stm32cubeprogrammer = { path = "../stm32cubeprogrammer" }
+stm32cubeprogrammer = { path = "../stm32cubeprogrammer", features = [
+    "serde",
+    "validations",
+] }
 dotenvy.workspace = true
 log.workspace = true
 anyhow = "1.0.94"
+serde_json = "1"
+serde = { version = "1", features = ["derive"] }
 
 [dev-dependencies]
 test-log.workspace = true

stm32cubeprogrammer-cli/Cargo.toml

@@ -7,9 +7,9 @@
 //! - Enabling read protection
 //! - Disabling read protection
 //! - Resetting target
-//! 
+//!
 //! All commands above can be combined in a single command line invocation by chaining them.
-//! 
+//!
 //! If you need other commands, feel free to open an issue or a pull request. :smile:
 //!
 //! # Example usage:
@@ -28,7 +28,7 @@
 //! ```sh
 //! STM32_CUBE_PROGRAMMER_DIR=`installation_dir` stm32cubeprogrammer-cli unprotect reset flash-hex `path_to_hex_file` protect
 //! ```
-//! 
+//!
 //! Use the `--list` flag to list available probes.
 //! ```sh
 //! stm32cubeprogrammer-cli --stm32-cube-programmer-dir `installation_dir` --list
@@ -49,6 +49,7 @@
 
 mod display_handler;
 mod parse;
+mod output;
 
 use anyhow::Context;
 use display_handler::DisplayHandler;
@@ -198,8 +199,14 @@ fn main() -> Result<(), anyhow::Error> {
     // Parse command line arguments
     let options = parse::options().run();
 
+    let verbosity = if options.quiet {
+        log::LevelFilter::Error
+    } else {
+        options.verbose
+    };
+
     // Init api
-    let display_handler = init_display_handler(options.verbosity);
+    let display_handler = init_display_handler(verbosity);
     let api = stm32cubeprogrammer::CubeProgrammer::builder()
         .cube_programmer_dir(&options.stm32_cube_programmer_dir)
         .display_callback(display_handler.clone())
@@ -255,8 +262,10 @@ fn main() -> Result<(), anyhow::Error> {
 
     // Handle commands
     for command in options.target_commands {
-        match command {
+        let command_output = match command {
             parse::TargetCommand::FlashBin(bin_file_info) => {
+                log::info!("Flash binary file: {}", bin_file_info);
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -268,6 +277,8 @@ fn main() -> Result<(), anyhow::Error> {
                     .with_context(|| "Failed to flash binary file")?;
             }
             parse::TargetCommand::FlashHex { file } => {
+                log::info!("Flash hex file: `{:?}`", file);
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -279,6 +290,8 @@ fn main() -> Result<(), anyhow::Error> {
                     .with_context(|| "Failed to flash hex file")?;
             }
             parse::TargetCommand::UpdateBleStack(ble_stack_info) => {
+                log::info!("Update BLE stack: {}", ble_stack_info);
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -318,7 +331,23 @@ fn main() -> Result<(), anyhow::Error> {
                         .with_context(|| "Failed to start BLE stack")?;
                 }
             }
+            parse::TargetCommand::BleStackInfo { compare } => {
+                let fus_programmer = programmer_connection.fus_connection()?;
+                let target_version = fus_programmer.fus_info().wireless_stack_version;
+
+                log::info!("FUS info: {}", fus_programmer.fus_info());
+
+                if let Some(compare) = compare {
+                    log::info!("Comparing BLE stack versions. Given version: {} ; Version on target: {} ; Stack up to date: {}", compare, target_version, compare == target_version);
+                }
+
+                fus_programmer
+                    .start_wireless_stack()
+                    .with_context(|| "Failed to start BLE stack")?;
+            }
             parse::TargetCommand::Reset(reset_mode) => {
+                log::info!("Resetting target: {:?}", reset_mode);
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -330,6 +359,8 @@ fn main() -> Result<(), anyhow::Error> {
                     .with_context(|| "Failed to reset target")?;
             }
             parse::TargetCommand::MassErase => {
+                log::info!("Mass erase");
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -341,6 +372,8 @@ fn main() -> Result<(), anyhow::Error> {
                     .with_context(|| "Failed to mass erase target")?;
             }
             parse::TargetCommand::Protect => {
+                log::info!("Enable read protection");
+
                 display_handler
                     .lock()
                     .unwrap()
@@ -352,6 +385,8 @@ fn main() -> Result<(), anyhow::Error> {
                     .with_context(|| "Failed to enable read protection")?;
             }
             parse::TargetCommand::Unprotect => {
+                log::info!("Disable read protection");
+
                 display_handler
                     .lock()
                     .unwrap()

stm32cubeprogrammer-cli/src/main.rs

@@ -0,0 +1,79 @@
+use serde::Serialize;
+use std::env::ArgsOs;
+
+pub struct Output {
+    schema_version: String,
+    args: String,
+    list: Option<Vec<stm32cubeprogrammer::probe::Serial>>,
+    selected_probe: Option<stm32cubeprogrammer::probe::Serial>,
+    target_information: Option<stm32cubeprogrammer::api_types::TargetInformation>,
+    command_output: Option<Vec<CommandOutput>>,
+}
+
+impl Output {
+    const SCHEMA_VERSION: &str = "1";
+
+    pub fn new(args: ArgsOs) -> Self {
+        let schema_version = Self::SCHEMA_VERSION.to_string();
+        let args = args.map(|x| x.to_string_lossy().to_string()).collect();
+
+        Self {
+            schema_version,
+            args,
+            list: None,
+            selected_probe: None,
+            target_information: None,
+            command_output: None,
+        }
+    }
+
+    pub fn add_probe_list(&mut self, list: Vec<stm32cubeprogrammer::probe::Serial>) {
+        self.list = Some(list);
+    }
+
+    pub fn add_command_output(&mut self, command: CommandOutput) {
+        if let Some(ref mut command_output) = self.command_output {
+            command_output.push(command);
+        } else {
+            self.command_output = Some(vec![command]);
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(tag = "type")]
+pub enum CommandOutput {
+    Info(stm32cubeprogrammer::api_types::TargetInformation),
+    FlashBin {
+        file: std::path::PathBuf,
+        address: u32,
+    },
+    FlashHex {
+        file: std::path::PathBuf,
+    },
+    UpdateBleStack {
+        file: std::path::PathBuf,
+        address: u32,
+    },
+    BleStackInfo(stm32cubeprogrammer::fus::Information),
+    Reset(stm32cubeprogrammer::api_types::probe::ResetMode),
+    MassErase,
+    Protect,
+    Unprotect,
+}
+
+#[derive(Serialize)]
+pub enum BleStackUpdated {
+    NotUpdatet,
+    Updated(BleStackUpdateReason),
+}
+
+#[derive(Serialize)]
+pub enum BleStackUpdateReason {
+    Force,
+    VersionNotEqual {
+        expected: stm32cubeprogrammer::fus::Version,
+        on_target: stm32cubeprogrammer::fus::Version,
+    },
+    NoVersionProvided,
+}