Add calibration support

Author: Jascha-N

Cargo.lock

@@ -16,7 +16,7 @@ doc = false
 [dependencies]
 chrono = "0.2"
 clap = "2.19"
-env_logger = "0.3"
+env_logger = "0.4"
 error-chain = "0.7"
 flate2 = "0.2"
 lazy_static = "0.2"
@@ -57,6 +57,13 @@ path = "../glutin"
 
 [build-dependencies]
 regex = "0.2"
+serde = "0.8"
+serde_derive = "0.8"
+
+[build-dependencies.toml]
+version = "0.2"
+default-features = false
+features = ["serde"]
 
 [features]
 default = ["conrod", "lang_en-US"]

Cargo.toml

@@ -1,15 +1,37 @@
 extern crate regex;
+extern crate serde;
+#[macro_use] extern crate serde_derive;
+extern crate toml;
 
 use regex::{Captures, Regex};
 
 use std::collections::HashMap;
 use std::env;
 use std::fs::{self, File};
-use std::io::{self, BufWriter, Write};
+use std::io::{self, BufReader, BufWriter, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::{self, SystemTime};
 
+#[derive(Deserialize)]
+struct Config {
+    board: String,
+    calibration_pin: Option<u8>,
+    sensor_pins: Vec<u8>,
+    paths: Paths
+}
+
+#[derive(Deserialize)]
+struct Paths {
+    home: Option<PathBuf>,
+    #[serde(default)]
+    hardware: Vec<PathBuf>,
+    #[serde(default)]
+    tools: Vec<PathBuf>,
+    #[serde(default)]
+    libraries: Vec<PathBuf>,
+}
+
 fn load_prefs_from_str(pref_str: &str) -> HashMap<&str, String> {
     let mut prefs = HashMap::new();
     for line in pref_str.lines() {
@@ -53,16 +75,16 @@ fn write_board_file(path: &Path, prefs: &HashMap<&str, String>, name: &str, time
     if *tool != "avrdude" {
         panic!("Only AVR boards are supported.");
     }
-    let protocol: String = prefs.get("upload.protocol").map(Clone::clone).unwrap_or_default();
+    let protocol: String = prefs.get("upload.protocol").cloned().unwrap_or_default();
     let speed: usize = prefs.get("upload.speed").and_then(|s| s.parse().ok()).unwrap_or_default();
     let use_1200bps_touch: bool = prefs.get("upload.use_1200bps_touch")
                                        .and_then(|s| s.parse().ok()).unwrap_or_default();
     let wait_for_upload_port: bool = prefs.get("upload.wait_for_upload_port")
                                           .and_then(|s| s.parse().ok()).unwrap_or_default();
-    let mcu: String = prefs.get("build.mcu").map(Clone::clone).unwrap_or_default();
+    let mcu: String = prefs.get("build.mcu").cloned().unwrap_or_default();
     let config_path: PathBuf = prefs.get("config.path").map_or(PathBuf::new(), PathBuf::from);
     let build_path: PathBuf = prefs.get("build.path").map_or(PathBuf::new(), PathBuf::from);
-    let project_name: String = prefs.get("build.project_name").map(Clone::clone).unwrap_or_default();
+    let project_name: String = prefs.get("build.project_name").cloned().unwrap_or_default();
 
     let mut writer = BufWriter::new(File::create(path).unwrap());
     writeln!(writer, r##"pub const PROTOCOL: &'static str = r#"{}"#;"##, protocol).unwrap();
@@ -77,51 +99,54 @@ fn write_board_file(path: &Path, prefs: &HashMap<&str, String>, name: &str, time
              name, env!("CARGO_PKG_VERSION"), timestamp).unwrap();
 }
 
-fn builder_command(compile: bool, src_path: &Path, out_path: &Path, prefs: Option<HashMap<&str, String>>) -> Command {
+fn builder_command(compile: bool, src_path: &Path, out_path: &Path, mut extra_flags: String, mut defines: Option<HashMap<&str, String>>) -> Command {
     let mut command = Command::new("arduino-builder");
     command.arg("-libraries").arg("libraries")
            .arg("-build-path").arg(out_path)
            .arg("-warnings").arg("all")
            .arg("-verbose")
            .arg(if compile { "-compile" } else { "-dump-prefs" });
 
-    if Path::new("build.options.json").exists() {
-        command.arg("-build-options-file").arg("build.options.json");
-    } else {
-        if let Some(home) = env::var_os("ARDUINO_HOME").map(PathBuf::from) {
-            command.arg("-built-in-libraries").arg(home.join("libraries"))
-                   .arg("-hardware").arg(home.join("hardware"))
-                   .arg("-tools").arg(home.join("hardware/tools/avr"))
-                   .arg("-tools").arg(home.join("tools-builder"));
-        }
-
-        if let Some(board) = env::var_os("ARDUINO_BOARD") {
-            command.arg("-fqbn").arg(board);
-        }
-
-        if let Some(hardware) = env::var_os("ARDUINO_HARDWARE") {
-            for path in env::split_paths(&hardware) {
-                command.arg("-hardware").arg(path);
-            }
-        }
-
-        if let Some(tools) = env::var_os("ARDUINO_TOOLS") {
-            for path in env::split_paths(&tools) {
-                command.arg("-tools").arg(path);
-            }
+    let mut reader = BufReader::new(File::open("build.toml").unwrap());
+    let mut toml = String::new();
+    reader.read_to_string(&mut toml).unwrap();
+    let config = toml::decode_str::<Config>(&toml).unwrap();
+
+    command.arg("-fqbn").arg(&config.board);
+    if let Some(home) = config.paths.home.or_else(|| env::var_os("ARDUINO_HOME").map(PathBuf::from)) {
+        command.arg("-built-in-libraries").arg(home.join("libraries"))
+                .arg("-hardware").arg(home.join("hardware"))
+                .arg("-tools").arg(home.join("hardware/tools/avr"))
+                .arg("-tools").arg(home.join("tools-builder"));
+    }
+    for path in &config.paths.hardware {
+        command.arg("-hardware").arg(path);
+    }
+    for path in &config.paths.tools {
+        command.arg("-tools").arg(path);
+    }
+    for path in &config.paths.libraries {
+        command.arg("-libraries").arg(path);
+    }
+    if let Some(ref mut defines) = defines.as_mut() {
+        if let Some(calibration_pin) = config.calibration_pin {
+            defines.insert("CALIBRATION_PIN", calibration_pin.to_string());
         }
+        let sensor_pins = config.sensor_pins.iter()
+                                            .map(|pin| format!("{{{:#04x}, A{}}}", pin, pin))
+                                            .collect::<Vec<_>>()
+                                            .join(", ");
+        defines.insert("SENSOR_PINS", format!("{{{}}}", sensor_pins));
+    }
 
-        if let Some(libraries) = env::var_os("ARDUINO_LIBRARIES") {
-            for path in env::split_paths(&libraries) {
-                command.arg("-libraries").arg(path);
-            }
+    if let Some(defines) = defines {
+        for (key, value) in defines {
+            extra_flags.push_str(&format!(" '-D{}={}'", key, value));
         }
     }
 
-    if let Some(prefs) = prefs {
-        for (key, value) in prefs {
-            command.arg("-prefs").arg(format!("{}={}", key, value));
-        }
+    if !extra_flags.is_empty() {
+        command.arg("-prefs").arg(format!("build.extra_flags={}", extra_flags));
     }
 
     command.arg(src_path);
@@ -131,13 +156,13 @@ fn builder_command(compile: bool, src_path: &Path, out_path: &Path, prefs: Optio
 
 pub fn main() {
     let timestamp = SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap().as_secs();
-    let out = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let src = Path::new("src/arduino/program.ino");
-    let arduino_out = out.join("arduino");
-    fs::create_dir_all(&arduino_out).unwrap();
+    let out_path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    let src_path = Path::new("src/arduino/program.ino");
+    let build_path = out_path.join("arduino");
+    fs::create_dir_all(&build_path).unwrap();
 
     // Dump preferences
-    let output = builder_command(false, src, &arduino_out, None).output().unwrap();
+    let output = builder_command(false, src_path, &build_path, String::new(), None).output().unwrap();
     let _ = io::stdout().write_all(&output.stdout);
     let _ = io::stderr().write_all(&output.stderr);
     if !output.status.success() {
@@ -148,21 +173,19 @@ pub fn main() {
     let prefs_str = String::from_utf8_lossy(&output.stdout);
     let prefs = load_prefs_from_str(&prefs_str);
     let expanded_prefs = expand_prefs(&prefs);
-    let name = expanded_prefs.get("name").map(Clone::clone).unwrap_or_default();
-    write_board_file(&out.join("board.rs"), &expanded_prefs, &name, timestamp);
+    let name = expanded_prefs.get("name").cloned().unwrap_or_default();
+    write_board_file(&out_path.join("board.rs"), &expanded_prefs, &name, timestamp);
 
 
 
     // Compile sketch
-    let mut extra_prefs = HashMap::new();
-    let extra_flags = format!(r#"{}'-DDEVICEINFO_NAME="{}"' '-DDEVICEINFO_VERSION="{}"' -DDEVICEINFO_TIMESTAMP={:#x}"#,
-                              prefs.get("build.extra_flags").map_or_else(String::new, |flags| format!("{} ", flags)),
-                              name,
-                              env!("CARGO_PKG_VERSION"),
-                              timestamp);
-    extra_prefs.insert("build.extra_flags", extra_flags);
-
-    let output = builder_command(true, src, &arduino_out, Some(extra_prefs)).output().unwrap();
+    let extra_flags = prefs.get("build.extra_flags").cloned().unwrap_or_default();
+    let mut defines = HashMap::new();
+    defines.insert("DEVICEINFO_NAME", format!(r#""{}""#, name));
+    defines.insert("DEVICEINFO_VERSION", format!(r#""{}""#, env!("CARGO_PKG_VERSION")));
+    defines.insert("DEVICEINFO_TIMESTAMP", format!("{:#x}", timestamp));
+
+    let output = builder_command(true, src_path, &build_path, extra_flags, Some(defines)).output().unwrap();
     let _ = io::stdout().write_all(&output.stdout);
     let _ = io::stderr().write_all(&output.stderr);
     if !output.status.success() {
@@ -176,6 +199,6 @@ pub fn main() {
         }
     }
 
-    println!("cargo:rerun-if-changed=src/arduino/program.ino");
-    println!("cargo:rerun-if-changed=build.options.json");
+    println!("cargo:rerun-if-changed={}", src_path.display());
+    println!("cargo:rerun-if-changed=build.toml");
 }

build.rs

@@ -165,37 +165,6 @@ impl DeviceInfo {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
-pub struct SensorConfig {
-    range: (u16, u16),
-    thresholds: (u8, u8)
-}
-
-impl SensorConfig {
-    pub fn new(min: u16, max: u16) -> SensorConfig {
-        debug_assert!(max < 1024);
-        debug_assert!(min < 1024);
-        SensorConfig {
-            range: (min, max),
-            thresholds: (u8::MIN, u8::MAX)
-        }
-    }
-
-    pub fn range(&self) -> (u16, u16) {
-        self.range
-    }
-
-    pub fn thresholds(&self) -> (u8, u8) {
-        self.thresholds
-    }
-
-    pub fn set_thresholds(&mut self, low: u8, high: u8) {
-        debug_assert!(low < high);
-        self.thresholds = (low, high);
-    }
-}
-
-
 
 pub struct Arduino(SystemPort);
 
@@ -253,8 +222,7 @@ impl Arduino {
         #[cfg(windows)]
         ::std::os::windows::process::CommandExt::creation_flags(&mut command, ::winapi::CREATE_NO_WINDOW);
 
-        let mut process = command.arg("-v").arg("-v")
-                                 .arg("-C").arg(avrdude_conf_path)
+        let mut process = command.arg("-C").arg(avrdude_conf_path)
                                  .arg("-p").arg(board::MCU)
                                  .arg("-c").arg(board::PROTOCOL)
                                  .arg("-P").arg(port.name())
@@ -428,26 +396,15 @@ impl Arduino {
         self.send_request("poll_event", &[])
     }
 
-    pub fn sensor_values(&mut self, raw: bool) -> Result<Vec<Option<u16>>> {
-        self.send_request("sensor_values", &[("raw", serde_json::to_value(raw))])
+    pub fn read_values(&mut self, raw: bool) -> Result<Vec<Option<u16>>> {
+        self.send_request("read_values", &[("raw", serde_json::to_value(raw))])
     }
 
-    pub fn set_sensor(&mut self, id: u8, config: &SensorConfig) -> Result<()> {
-        let (min, max) = config.range();
-        let (low, high) = config.thresholds();
-
-        self.send_request("set_sensor", &[
+    pub fn set_thresholds(&mut self, id: u8, trigger: u8, release: u8) -> Result<()> {
+        self.send_request("set_thresholds", &[
             ("id", serde_json::to_value(id)),
-            ("min", serde_json::to_value(min)),
-            ("max", serde_json::to_value(max)),
-            ("low", serde_json::to_value(low)),
-            ("high", serde_json::to_value(high))
-        ])
-    }
-
-    pub fn unset_sensor(&mut self, id: u8) -> Result<()> {
-        self.send_request("unset_sensor", &[
-            ("id", serde_json::to_value(id))
+            ("trigger", serde_json::to_value(trigger)),
+            ("release", serde_json::to_value(release))
         ])
     }
 }