Initial kinda working OSC->DDC server

src/bin/ddcmqtt.rs

@@ -0,0 +1,7 @@
+use ::ddcmqtt::{main as main_, StdError};
+
+
+fn main() -> StdError<()> {
+    main_()
+}
+

src/bin/setmon.rs

@@ -0,0 +1,23 @@
+use ddc_i2c::{I2cDeviceEnumerator, I2cDeviceDdc};
+use ddc::Ddc;
+
+use ::ddcmqtt::{StdError};
+
+fn main() -> StdError<()> {
+    let args_: Vec<_> = std::env::args().skip(1).collect();
+    let args: Vec<&str> = args_.iter().map(|s| &**s).collect();
+    match args.as_slice() {
+        ["brightness", arg] => ddc_all(0x10, arg.parse::<u16>()?),
+        ["input", arg] => ddc_all(0x60, arg.parse::<u16>()?),
+        _ => Err("Bad usage".into()),
+
+    }?;
+    Ok(())
+}
+
+fn ddc_all(feat: u8, val: u16) -> StdError<()> {
+    for mut display in I2cDeviceEnumerator::new()? {
+        display.set_vcp_feature(feat, val)?;
+    }
+    Ok(())
+}

src/lib.rs

@@ -0,0 +1,115 @@
+#![allow(unreachable_code)]
+use ddc::Ddc;
+use ddc_i2c::{I2cDeviceEnumerator, I2cDeviceDdc};
+use rosc;
+use std::net::UdpSocket;
+use std::thread;
+use std::sync::mpsc::{channel, Receiver, Sender};
+use std::time::{Duration, Instant};
+use std::collections::HashMap;
+
+use std::error::Error;
+
+pub type StdError<T> = Result<T, Box<dyn Error>>;
+
+enum Command {
+    Monitor((usize, MonitorCommand)),
+}
+
+enum MonitorCommand {
+    Brightness(u8),
+    Input(u8)
+}
+
+impl MonitorCommand {
+    fn cmd_str(&self) -> &'static str {
+        match self {
+            Self::Brightness(_) => "brightness",
+            Self::Input(_) => "input",
+        }
+    }
+
+    fn vcp(&self) -> u8 {
+        match self {
+            Self::Brightness(_) => 0x10,
+            Self::Input(_) => 0x60,
+        }
+    }
+}
+
+
+// Run an i2c command handler for a specific i2c device, rate limiting each type of command
+fn run_i2c(mut dev: I2cDeviceDdc, command_channel: Receiver<MonitorCommand>) {
+    let mut last_sent_command: HashMap<&str, Option<Instant>> = HashMap::new(); 
+    loop {
+        let cmd = command_channel.recv().unwrap();
+        if let Some(last) = last_sent_command.entry(cmd.cmd_str()).or_insert(None) {
+            if (*last + Duration::from_millis(100)) > Instant::now() {
+                // rate limit
+                continue;
+            }
+        }
+        match cmd {
+            MonitorCommand::Brightness(b) => dev.set_vcp_feature(0x10, b.into()).unwrap(),
+            // Hack - add 15 to align with DELL monitors
+            MonitorCommand::Input(i) => dev.set_vcp_feature(0x60, (i+15).into()).unwrap(),
+        }
+        last_sent_command.insert(cmd.cmd_str(), Some(Instant::now()));
+    }
+}
+
+pub fn main() -> StdError<()> {
+    let displays = I2cDeviceEnumerator::new().unwrap().collect::<Vec<_>>();
+    println!("Enumerated {} displays", displays.len());
+    let txes: Vec<_> = displays.into_iter().map(|d| {
+        let (tx, rx) = channel();
+        thread::spawn(move|| run_i2c(d, rx));
+        tx
+    }).collect();
+    let sock = UdpSocket::bind("0.0.0.0:1234").unwrap();
+    let mut buf = [0u8; rosc::decoder::MTU];
+
+    loop {
+        let (size, addr)  = sock.recv_from(&mut buf).unwrap();
+        println!("Got {} bytes from {}", size, addr);
+        let (_, pack) = rosc::decoder::decode_udp(&buf[..size]).unwrap();
+        match pack {
+            rosc::OscPacket::Message(msg) => {
+                match osc_message_to_command(msg) {
+                    Ok(cmd) => if let Err(e) = handle_cmd(cmd, &txes) {
+                        println!("Error handling command: {:?}", e);
+                    },
+                    Err(e) => println!("Unrecognised OSC command: {:?}", e),
+                };
+            }
+            rosc::OscPacket::Bundle(bundle) => {
+                println!("OSC Bundle: {:?}", bundle);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn handle_cmd(cmd: Command, txes: &Vec<Sender<MonitorCommand>>) -> StdError<()> {
+    match cmd {
+        Command::Monitor((idx, c)) => txes.get(idx).ok_or("Bad monitor index")?.send(c)?,
+    };
+    Ok(())
+}
+fn osc_message_to_command(msg: rosc::OscMessage) -> StdError<Command> {
+    println!("OSC: {}, args: {:?}", msg.addr, msg.args);
+    let splitaddr: Vec<_> = msg.addr.split("/").collect();
+    match &splitaddr[1..] {
+        ["monitor", idx, control] => {
+            println!("Monitor {}, control {}, args {:?}", idx, control, msg.args);
+            let command = match *control {
+                "brightness" => Some(MonitorCommand::Brightness((msg.args[0].clone().float().unwrap() * 100.0) as u8)),
+                "input" => Some(MonitorCommand::Input((msg.args[0].clone().int().unwrap()) as u8)),
+                _ => None,
+            }.ok_or(format!("Unrecognised monitor control: {}", *control))?;
+            let idx = idx.parse::<usize>().or(Err("Bad monitor index"))?;
+            Ok(Command::Monitor((idx, command)))
+        },
+        _ => Err("Unsupported osc address, ignoring".into()),
+    }
+}