Graph

Author: usbalbin

README.md

@@ -10,15 +10,19 @@ A set of tools to plot values from the target to graph in rerun with minimal per
 #![no_main]
 
 use cortex_m_rt::entry;
-use probe_plotter::{make_metric, make_setting};
+use probe_plotter::{make_graph, make_metric, make_setting};
 
 #[entry]
 fn main() -> ! {
-    let mut sawtooth = make_metric!(SAWTOOTH: i32 = 42, "(SAWTOOTH / 10) % 100").unwrap();
-    let mut sine = make_metric!(SINE: i32 = 42, "100 * sin(2 * pi * SINE / 4000)").unwrap();
+    make_graph!(SAWTOOTH = "(SAWTOOTH / 10) % 100");
+    make_graph!(SINE = "100 * sin(2 * pi * SINE / 4000)");
+    make_graph!(SINE_TIMES_SAWTOOTH = "100 * sin(2 * pi * SINE / 4000) * (SAWTOOTH / 10) % 100)");
+    make_graph!(SETTING = "SETTING");
+    make_graph!(SETTING_ROUNDTRIP = "SETTING_ROUNDTRIP");
 
-    let mut setting_roundtrip =
-        make_metric!(SETTING_ROUNDTRIP: i8 = 0, "SETTING_ROUNDTRIP").unwrap();
+    let mut sawtooth = make_metric!(SAWTOOTH: i32 = 42).unwrap();
+    let mut sine = make_metric!(SINE: i32 = 42).unwrap();
+    let mut setting_roundtrip = make_metric!(SETTING_ROUNDTRIP: i8 = 0).unwrap();
 
     // Allow values -1..=7, step by 2, so {-1, 1, 3, 5, 7}
     let mut setting = make_setting!(SETTING: i8 = 42, -1..=7, 2).unwrap();
@@ -29,6 +33,8 @@ fn main() -> ! {
             sine.set(i);
 
             setting_roundtrip.set(setting.get());
+
+            cortex_m::asm::delay(100_000);
         }
     }
 }

examples/simple/src/main.rs

@@ -5,17 +5,22 @@ use cortex_m_rt::entry;
 
 use defmt_rtt as _;
 use panic_halt as _;
-use probe_plotter::{make_metric, make_setting};
+use probe_plotter::{make_graph, make_metric, make_setting};
 
 #[entry]
 fn main() -> ! {
+    make_graph!(SAWTOOTH = "(SAWTOOTH / 10) % 100");
+    make_graph!(SINE = "100 * sin(2 * pi * SINE / 4000)");
+    make_graph!(SINE_TIMES_SAWTOOTH = "100 * sin(2 * pi * SINE / 4000) * (SAWTOOTH / 10) % 100)");
+    make_graph!(SETTING = "SETTING");
+    make_graph!(SETTING_ROUNDTRIP = "SETTING_ROUNDTRIP");
+
     defmt::println!("Running...");
-    let mut sawtooth = make_metric!(SAWTOOTH: i32 = 42, "(SAWTOOTH / 10) % 100").unwrap();
+    let mut sawtooth = make_metric!(SAWTOOTH: i32 = 42).unwrap();
     defmt::println!("foo initialized to: {}", sawtooth.get());
-    let mut sine = make_metric!(SINE: i32 = 42, "100 * sin(2 * pi * SINE / 4000)").unwrap();
+    let mut sine = make_metric!(SINE: i32 = 42).unwrap();
 
-    let mut setting_roundtrip =
-        make_metric!(SETTING_ROUNDTRIP: i8 = 0, "SETTING_ROUNDTRIP").unwrap();
+    let mut setting_roundtrip = make_metric!(SETTING_ROUNDTRIP: i8 = 0).unwrap();
 
     // Allow values -1..=7, step by 2, so {-1, 1, 3, 5, 7}
     let mut setting = make_setting!(SETTING: i8 = 42, -1..=7, 2).unwrap();

macros/src/args.rs

@@ -1,18 +1,16 @@
 // Based on defmt
 
 use syn::{
-    LitStr, RangeLimits, Token,
+    RangeLimits, Token,
     parse::{self, Parse, ParseStream},
     spanned::Spanned,
 };
 
-//FOO: i32 = 0, "x * 3.0"
-//FOO: i32 = 0 // defaults to "x"
+//FOO: i32 = 0
 pub(crate) struct MetricArgs {
     pub(crate) name: syn::Ident,
     pub(crate) ty: syn::Ident,
     pub(crate) initial_val: syn::Expr,
-    pub(crate) expression_string: syn::LitStr,
 }
 
 impl Parse for MetricArgs {
@@ -23,20 +21,10 @@ impl Parse for MetricArgs {
         let _comma: Token![=] = input.parse()?;
         let initial_val = input.parse()?;
 
-        let comma: parse::Result<Token![,]> = input.parse();
-        let expression_string = input.parse();
-
-        let expression_string = match (comma, expression_string) {
-            (Ok(_), Ok(expr)) => expr,
-            (Ok(_), Err(e)) => return Err(e),
-            (Err(_), _) => LitStr::new(&name.to_string(), name.span()),
-        };
-
         Ok(Self {
             name,
             ty,
             initial_val,
-            expression_string,
         })
     }
 }
@@ -100,6 +88,25 @@ impl Parse for SettingArgs {
     }
 }
 
+//FOO = "x * 3.0"
+pub(crate) struct GraphArgs {
+    pub(crate) name: syn::Ident,
+    pub(crate) expression_string: syn::LitStr,
+}
+
+impl Parse for GraphArgs {
+    fn parse(input: ParseStream) -> parse::Result<Self> {
+        let name: syn::Ident = input.parse()?;
+        let _comma: Token![=] = input.parse()?;
+        let expression_string = input.parse()?;
+
+        Ok(Self {
+            name,
+            expression_string,
+        })
+    }
+}
+
 // TODO: Clean up this mess
 fn expr_to_float_lit(e: syn::Expr) -> Result<syn::LitFloat, syn::Error> {
     let error_msg = "expected float or int literal";

macros/src/lib.rs

@@ -7,7 +7,7 @@ use proc_macro::{Span, TokenStream};
 use quote::quote;
 use syn::parse_macro_input;
 
-use crate::symbol::{MetricsSymbol, SettingSymbol};
+use crate::symbol::{GraphSymbol, MetricsSymbol, SettingSymbol};
 
 mod args;
 mod cargo;
@@ -16,26 +16,21 @@ mod symbol;
 /// Create a Metric instance that will be shown in the probe-plotter utility's graph
 ///
 /// ```
-/// make_metric!(NAME_AS_SHOWN_IN_GRAPH: DataType = defalt_value, "expression to convert from raw value (x) to the value to plot")
+/// make_metric!(NAME_AS_SHOWN_IN_GRAPH: DataType = defalt_value, "expression to convert from raw value (NAME_AS_SHOWN_IN_GRAPH) to the value to plot")
 /// ```
 ///
 /// Note that similar to `cortex_m::singleton!`, this should only be called once per metric. The macro will only return Some() the first time, then None.
 ///
 /// ```
-/// let mut metric_foo = probe_plotter::make_metric!(FOO: i32 = 0, "x * 3.0").unwrap();
+/// let mut metric_foo = probe_plotter::make_metric!(FOO: i32 = 0, "FOO * 3.0").unwrap();
 ///
-/// metric_foo.set(42); // The value 42 will be available for the host after this call. The value will be plotted as x * 3 = 42 * 3 = 126
+/// metric_foo.set(42); // The value 42 will be available for the host after this call. The value will be plotted as FOO * 3 = 42 * 3 = 126
 /// ```
 #[proc_macro]
 pub fn make_metric(args: TokenStream) -> TokenStream {
     let args = parse_macro_input!(args as args::MetricArgs);
 
-    let sym_name = MetricsSymbol::new(
-        args.ty.to_string(),
-        args.name.to_string(),
-        args.expression_string.value(),
-    )
-    .mangle();
+    let sym_name = MetricsSymbol::new(args.ty.to_string(), args.name.to_string()).mangle();
 
     let name = args.name;
     let ty = args.ty;
@@ -116,6 +111,68 @@ pub fn make_setting(args: TokenStream) -> TokenStream {
     .into()
 }
 
+/// Register a graph for the probe-plotter utility's to plot.
+///
+/// This has access to all metrics and settings which may be used in the expression
+///
+/// ```
+/// make_graph!(GRAPH_TITLE = "expression to convert from raw values to the value to plot, may refer to any metrics or settings")
+/// ```
+///
+/// ```
+/// probe_plotter::make_graph!(FOO_GRAPH = "FOO * 3.0");
+///
+///
+/// let mut metric_foo = probe_plotter::make_metric!(FOO: i32 = 0).unwrap();
+///
+/// metric_foo.set(42); // The value 42 will be available for the host after this call. The value will be plotted as FOO * 3 = 42 * 3 = 126
+/// ```
+#[proc_macro]
+pub fn make_graph(args: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as args::GraphArgs);
+
+    let sym_name = GraphSymbol::new(args.name.to_string(), args.expression_string.value()).mangle();
+    let section = linker_section(false, &sym_name);
+    let section_for_macos = linker_section(true, &sym_name);
+
+    let name = args.name;
+    quote!(
+        #[cfg_attr(target_os = "macos", unsafe(link_section = #section_for_macos))]
+        #[cfg_attr(not(target_os = "macos"), unsafe(link_section = #section))]
+        #[unsafe(export_name = #sym_name)]
+        static mut #name: u8 = 42;
+
+        #[allow(unsafe_code)]
+        unsafe {
+            // TODO: Find better way to ensure the compiler considers this static used
+            // the #[used] attribute does not seem enough
+            let mut x = &raw const #name as usize;
+            core::arch::asm!("mov {0}, {0}", inout(reg) x);
+        }
+    )
+    .into()
+}
+/*
+quote!(
+        #[cfg_attr(target_os = "macos", unsafe(link_section = #section_for_macos))]
+        #[cfg_attr(not(target_os = "macos"), unsafe(link_section = #section))]
+        #[used]
+        #[unsafe(export_name = #sym_name)]
+        static #name: u8 = 0;
+    )
+    .into()
+
+
+let name = args.name;
+    quote!(
+        #[used]
+        #[unsafe(export_name = #sym_name)]
+        static mut #name: (i8, bool) =
+            (0, false);
+    )
+    .into()
+    */
+
 pub(crate) fn crate_local_disambiguator() -> u64 {
     // We want a deterministic, but unique-per-macro-invocation identifier. For that we
     // hash the call site `Span`'s debug representation, which contains a counter that
@@ -128,3 +185,17 @@ fn hash(string: &str) -> u64 {
     string.hash(&mut hasher);
     hasher.finish()
 }
+
+/// work around restrictions on length and allowed characters imposed by macos linker
+/// returns (note the comma character for macos):
+///   under macos: ".defmt," + 16 character hex digest of symbol's hash
+///   otherwise:   ".defmt." + prefix + symbol
+pub(crate) fn linker_section(for_macos: bool, symbol: &str) -> String {
+    let mut sub_section = format!(".{symbol}");
+
+    if for_macos {
+        sub_section = format!(",{:x}", hash(&sub_section));
+    }
+
+    format!(".defmt{sub_section}")
+}

macros/src/symbol.rs

@@ -18,33 +18,28 @@ pub struct MetricsSymbol {
     /// Variable name
     name: String,
 
-    /// Expression used to calculate the value to plot
-    expression_string: String,
-
     /// Crate name obtained via CARGO_CRATE_NAME (added since a Cargo package can contain many crates).
     crate_name: String,
 }
 
 impl MetricsSymbol {
-    pub fn new(ty: String, name: String, expr: String) -> Self {
+    pub fn new(ty: String, name: String) -> Self {
         Self {
             // `CARGO_PKG_NAME` is set to the invoking package's name.
             package: cargo::package_name(),
             disambiguator: super::crate_local_disambiguator(),
             ty,
             name,
-            expression_string: expr,
             crate_name: cargo::crate_name(),
         }
     }
 
     pub fn mangle(&self) -> String {
         format!(
-            r#"{{"type":"Metric","package":"{}","ty":"{}","name":"{}","expr":"{}","disambiguator":"{}","crate_name":"{}"}}"#,
+            r#"{{"type":"Metric","package":"{}","ty":"{}","name":"{}","disambiguator":"{}","crate_name":"{}"}}"#,
             json_escape(&self.package),
             json_escape(&self.ty),
             json_escape(&self.name),
-            json_escape(&self.expression_string),
             self.disambiguator,
             json_escape(&self.crate_name),
         )
@@ -104,6 +99,48 @@ impl SettingSymbol {
     }
 }
 
+pub struct GraphSymbol {
+    /// Name of the Cargo package in which the symbol is being instantiated. Used for avoiding
+    /// symbol name collisions.
+    package: String,
+
+    /// Unique identifier that disambiguates otherwise equivalent invocations in the same crate.
+    disambiguator: u64,
+
+    /// Variable name
+    name: String,
+
+    /// Expression used to calculate the value to plot
+    expression_string: String,
+
+    /// Crate name obtained via CARGO_CRATE_NAME (added since a Cargo package can contain many crates).
+    crate_name: String,
+}
+
+impl GraphSymbol {
+    pub fn new(name: String, expr: String) -> Self {
+        Self {
+            // `CARGO_PKG_NAME` is set to the invoking package's name.
+            package: cargo::package_name(),
+            disambiguator: super::crate_local_disambiguator(),
+            name,
+            expression_string: expr,
+            crate_name: cargo::crate_name(),
+        }
+    }
+
+    pub fn mangle(&self) -> String {
+        format!(
+            r#"{{"type":"Graph","package":"{}","name":"{}","expr":"{}","disambiguator":"{}","crate_name":"{}"}}"#,
+            json_escape(&self.package),
+            json_escape(&self.name),
+            json_escape(&self.expression_string),
+            self.disambiguator,
+            json_escape(&self.crate_name),
+        )
+    }
+}
+
 fn json_escape(string: &str) -> String {
     use std::fmt::Write;
 

probe-plotter-tools/src/bin/viewer.rs

@@ -2,7 +2,7 @@
 
 use std::{sync::mpsc, thread, time::Duration};
 
-use probe_plotter_tools::{gui::MyApp, metric::Status, parse_elf_file, setting::Setting};
+use probe_plotter_tools::{graph::Status, gui::MyApp, parse_elf_file, setting::Setting};
 use rerun::external::{eframe, re_crash_handler, re_grpc_server, re_log, re_viewer, tokio};
 use shunting::MathContext;
 
@@ -16,7 +16,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .nth(2)
         .unwrap_or_else(|| "stm32g474retx".to_owned());
 
-    let (mut metrics, mut settings) = parse_elf_file(&elf_path);
+    let (mut metrics, mut settings, mut graphs) = parse_elf_file(&elf_path);
+
+    dbg!(&metrics, &settings, &graphs);
 
     let main_thread_token = rerun::MainThreadToken::i_promise_i_am_on_the_main_thread();
 
@@ -65,20 +67,29 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         initial_settings_sender.send(settings).unwrap();
 
         let mut math_ctx = MathContext::new();
+        let mut was_any_change = false;
         loop {
             for mut setting in settings_update_receiver.try_iter() {
                 setting.write(setting.value, &mut core).unwrap();
             }
 
             for m in &mut metrics {
                 m.read(&mut core, &mut math_ctx).unwrap();
-                let (x, s) = m.compute(&mut math_ctx);
-                if let Status::New = s {
-                    rec.log(m.name.clone(), &rerun::Scalars::single(x)).unwrap();
-                } else {
-                    std::thread::sleep(Duration::from_millis(1));
+            }
+
+            let mut is_any_change = false;
+            for g in &mut graphs {
+                let (x, s) = g.compute(&mut math_ctx);
+                if s == Status::New || was_any_change {
+                    // Force update of all values if one was changed last time
+                    rec.log(g.name.clone(), &rerun::Scalars::single(x)).unwrap();
+                    if s == Status::New {
+                        is_any_change = true;
+                    }
                 }
             }
+            was_any_change = is_any_change;
+            std::thread::sleep(Duration::from_millis(1));
         }
     });