Add axserialport wrapper and example

Author: apljungquist

Cargo.lock

@@ -52,6 +52,8 @@ axevent = { path = "crates/axevent" }
 axevent-sys = { path = "crates/axevent-sys" }
 axparameter = { path = "crates/axparameter" }
 axparameter-sys = { path = "crates/axparameter-sys" }
+axserialport = { path = "crates/axserialport" }
+axserialport-sys = { path = "crates/axserialport-sys" }
 axstorage = { path = "crates/axstorage" }
 axstorage-sys = { path = "crates/axstorage-sys" }
 bbox = { path = "crates/bbox" }

Cargo.toml

@@ -241,6 +241,11 @@ check_tests:
 
 ## Attempt to fix formatting automatically
 fix_format:
+	find apps/axserialport_example crates/axserialport -type f -name '*.rs' \
+ 	| xargs rustfmt \
+ 		--config imports_granularity=Crate \
+ 		--config group_imports=StdExternalCrate \
+ 		--edition 2021
 	cargo fmt
 .PHONY: fix_format
 

Makefile

@@ -0,0 +1,18 @@
+[package]
+name = "axserialport_example"
+version = "0.0.0"
+edition.workspace = true
+publish = false
+
+[dependencies]
+anyhow = { workspace = true }
+glib = { workspace = true }
+log = { workspace = true }
+glib-sys = { workspace = true }
+
+acap-logging = { workspace = true }
+axserialport = { workspace = true }
+libc = "0.2.158"
+
+[features]
+default = ["acap-logging/default"]

apps/axserialport_example/Cargo.toml

@@ -0,0 +1,20 @@
+{
+    "schemaVersion": "1.7.0",
+    "acapPackageConf": {
+        "setup": {
+            "appName": "axserialport_example",
+            "vendor": "Axis Communications",
+            "runMode": "never",
+            "version": "0.0.0"
+        }
+    },
+    "resources": {
+        "linux": {
+            "user": {
+                "groups": [
+                    "admin"
+                ]
+            }
+        }
+    }
+}

apps/axserialport_example/manifest.json

@@ -0,0 +1,91 @@
+#![forbid(unsafe_code)]
+
+use std::time::Instant;
+
+use anyhow::Context;
+use axserialport::{
+    gio::{Condition, IOChannel},
+    BaudRate, Config, DataBits, Enable, Parity, PortMode, StopBits,
+};
+use glib::MainLoop;
+use libc::{SIGINT, SIGTERM};
+use log::{error, info};
+
+fn incoming_data(channel: &mut IOChannel, _condition: Condition) -> glib::ControlFlow {
+    match channel.read_chars(2) {
+        Ok(timestamp) => {
+            let min = timestamp[0];
+            let sec = timestamp[1];
+            info!("incoming_data() timestamp: {min:02}:{sec:02}");
+        }
+        Err(e) => {
+            error!("{}", e.message());
+        }
+    }
+    glib::ControlFlow::Continue
+}
+
+fn send_timer_data(channel: &mut IOChannel, timer: Instant) -> glib::ControlFlow {
+    let elapsed = timer.elapsed().as_secs();
+    let minutes = elapsed / 60;
+    let seconds = elapsed % 60;
+
+    match channel.write_chars(&[minutes as u8, seconds as u8]) {
+        Ok(bytes_written) => {
+            let status = channel.flush().unwrap();
+            info!("send_timer_data() wrote {bytes_written} bytes, status: {status:?}");
+        }
+        Err(e) => {
+            error!("{}", e.message());
+        }
+    }
+    glib::ControlFlow::Continue
+}
+
+fn main() -> anyhow::Result<()> {
+    acap_logging::init_logger();
+
+    let main_loop = MainLoop::new(None, false);
+    glib::unix_signal_add_once(SIGTERM, {
+        let main_loop = main_loop.clone();
+        move || main_loop.quit()
+    });
+    glib::unix_signal_add_once(SIGINT, {
+        let main_loop = main_loop.clone();
+        move || main_loop.quit()
+    });
+
+    info!("Starting AxSerialPort application");
+
+    // Config example (product dependent) see product datasheet.
+    let mut config = Config::try_new(0)?;
+    config
+        .port_enable(Enable::Enable)?
+        .baudrate(BaudRate::B19200)?
+        .bias(Enable::Disable)?
+        .databits(DataBits::Eight)?
+        .parity(Parity::None)?
+        .portmode(PortMode::Rs485Four)?
+        .stopbits(StopBits::One)?
+        .termination(Enable::Disable)?
+        .sync()?;
+
+    let fd = config.get_fd()?;
+
+    let mut iochannel = IOChannel::from_borrowed_fd(fd).context("Failed to get channel")?;
+    iochannel.set_encoding(None)?;
+
+    let timer = Instant::now();
+
+    // Add a watch that waits for incoming data, then calls 'incoming_data()'
+    // when the conditions are met.
+    iochannel.watch_local(Condition::In, incoming_data);
+
+    // Periodically call 'send_timer_data()' every 10 seconds
+    glib::timeout_add_seconds_local(10, move || send_timer_data(&mut iochannel, timer));
+
+    main_loop.run();
+
+    info!("Finish AXSerialPort application");
+    Ok(())
+}

apps/axserialport_example/src/main.rs

@@ -0,0 +1,13 @@
+[package]
+build = "build.rs"
+name = "axserialport-sys"
+version = "0.0.0"
+edition.workspace = true
+license = "MIT"
+
+[build-dependencies]
+bindgen = { workspace = true }
+pkg-config = { workspace = true }
+
+[dependencies]
+glib-sys = { workspace = true }

crates/axserialport-sys/Cargo.toml

@@ -0,0 +1,86 @@
+use bindgen::callbacks::{EnumVariantValue, ParseCallbacks};
+use std::{env, path};
+
+fn to_title_case(name: &str) -> String {
+    name.split('_')
+        .map(|word| {
+            let mut chars = word.chars();
+            match chars.next() {
+                Some(first) => {
+                    first.to_uppercase().collect::<String>()
+                        + &chars.collect::<String>().to_lowercase()
+                }
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("")
+}
+
+#[derive(Debug)]
+struct MyParseCallbacks;
+
+impl ParseCallbacks for MyParseCallbacks {
+    fn enum_variant_name(
+        &self,
+        enum_name: Option<&str>,
+        original_variant_name: &str,
+        variant_value: EnumVariantValue,
+    ) -> Option<String> {
+        if let Some(enum_name) = enum_name {
+            let new_variant_name = match enum_name {
+                "AXSerialParity" => original_variant_name.trim_start_matches("AX_SERIAL_PARITY_"),
+                "AXSerialPortmode" => match original_variant_name {
+                    "AX_SERIAL_RS485_4" => "RS485_FOUR",
+                    _ => original_variant_name.trim_start_matches("AX_SERIAL_"),
+                },
+                "AXSerialDatabits" => match variant_value {
+                    EnumVariantValue::Boolean(_) => panic!(),
+                    EnumVariantValue::Signed(_) => panic!(),
+                    EnumVariantValue::Unsigned(n) => match n {
+                        7 => "Seven",
+                        8 => "Eight",
+                        _ => panic!(),
+                    },
+                },
+                "AXSerialStopbits" => match variant_value {
+                    EnumVariantValue::Boolean(_) => panic!(),
+                    EnumVariantValue::Signed(_) => panic!(),
+                    EnumVariantValue::Unsigned(n) => match n {
+                        1 => "One",
+                        2 => "Two",
+                        _ => panic!(),
+                    },
+                },
+                _ => original_variant_name.trim_start_matches("AX_SERIAL_"),
+            };
+            Some(to_title_case(new_variant_name))
+        } else {
+            None
+        }
+    }
+}
+fn populated_bindings(dst: &path::PathBuf) {
+    let library = pkg_config::Config::new().probe("axserialport").unwrap();
+    let mut bindings = bindgen::Builder::default()
+        .header("wrapper.h")
+        .rustified_enum(".*")
+        .generate_comments(false)
+        .allowlist_recursively(false)
+        .allowlist_function("^(ax_.*)$")
+        .allowlist_type("^(_?AX.*)$")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(MyParseCallbacks))
+        .layout_tests(false);
+    for path in library.include_paths {
+        bindings = bindings.clang_args(&["-I", path.to_str().unwrap()]);
+    }
+    bindings.generate().unwrap().write_to_file(dst).unwrap();
+}
+
+fn main() {
+    let dst = path::PathBuf::from(env::var("OUT_DIR").unwrap()).join("bindings.rs");
+    if env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default() != "x86_64" {
+        populated_bindings(&dst);
+    }
+}