poll: add support for poll command

This lets you block for changes with a timeout on the command
line.  Kinda handy for some scripts related to button
presses and the like (although some amount of debounce logic
might be nice to add in the future).

Signed-off-by: Paul Osborne <[email protected]>

Author: posborne

src/commands/gpio_poll.rs

@@ -0,0 +1,52 @@
+// Copyright (C) 2016, The gpio-utils Authors
+
+use options::GpioPollOptions;
+use config::GpioConfig;
+use sysfs_gpio::Edge;
+use std::process::exit;
+
+pub fn main(config: &GpioConfig, opts: &GpioPollOptions) {
+    let timeout = opts.timeout.unwrap_or(-1);
+    let pin_config = match config.get_pin(&opts.pin[..]) {
+        Some(pin) => pin,
+        None => {
+            println!("Unable to find config entry for pin '{}'", opts.pin);
+            exit(1)
+        }
+    };
+    let pin = pin_config.get_pin();
+    let edge = match &opts.edge[..] {
+        "rising" => Edge::RisingEdge,
+        "falling" => Edge::FallingEdge,
+        "both" => Edge::BothEdges,
+        other => {
+            println!("Unexpected edge value: {}", other);
+            exit(1);
+        }
+    };
+
+    // set the pin direction
+    pin.set_edge(edge).unwrap_or_else(|e| {
+        println!("Error setting edge on pin: {:?}", e);
+        exit(1);
+    });
+
+    let mut poller = pin.get_poller().unwrap_or_else(|e| {
+        println!("Error creating pin poller: {:?}", e);
+        exit(1);
+    });
+    match poller.poll(timeout) {
+        Ok(Some(value)) => {
+            println!("{}", value);
+            exit(0);
+        }
+        Ok(None) => {
+            println!("TIMEOUT");
+            exit(2)
+        }
+        Err(e) => {
+            println!("Error on Poll: {:?}", e);
+            exit(1);
+        }
+    }
+}

src/commands/mod.rs

@@ -6,3 +6,4 @@ pub mod gpio_exportall;
 pub mod gpio_write;
 pub mod gpio_unexport;
 pub mod gpio_unexportall;
+pub mod gpio_poll;

src/main.rs

@@ -44,7 +44,19 @@ fn main() {
                     .arg(Arg::with_name("pin")
                          .help("The pin name (or number)")
                          .index(1)
-                         .required(true)))
+                         .required(true))
+                    .arg(Arg::with_name("timeout")
+                         .help("Timeout (in ms) for the poll operation (-1 to wait forever, default)")
+                         .takes_value(true)
+                         .short("t")
+                         .long("timeout")
+                         .required(false))
+                    .arg(Arg::with_name("edge")
+                         .help("The edge to poll on")
+                         .takes_value(true)
+                         .short("e")
+                         .long("edge")
+                         .required(false)))
 
         // gpio write
         .subcommand(SubCommand::with_name("write")
@@ -140,7 +152,21 @@ fn main() {
             };
             gpio_read::main(&cfg, &read_options);
         }
-        ("poll", Some(_)) => {}
+        ("poll", Some(m)) => {
+            let timeout = m.value_of("timeout").map(|timeout| {
+                timeout.parse::<isize>().unwrap_or_else(|_| {
+                    println!("Unable to parse timeout value {:?} as integer", timeout);
+                    exit(1);
+                })
+            });
+            let poll_options = GpioPollOptions {
+                gpio_opts: gpio_options,
+                edge: String::from(m.value_of("edge").unwrap_or("both")),
+                timeout: timeout,
+                pin: String::from(m.value_of("pin").unwrap()),
+            };
+            gpio_poll::main(&cfg, &poll_options);
+        }
         ("write", Some(m)) => {
             let write_options = GpioWriteOptions {
                 gpio_opts: gpio_options,

src/options.rs

@@ -21,6 +21,8 @@ pub struct GpioWriteOptions {
 #[derive(Debug)]
 pub struct GpioPollOptions {
     pub gpio_opts: GpioOptions,
+    pub timeout: Option<isize>,
+    pub edge: String,
     pub pin: String,
 }