Switch to rppal (#5)

* Use rppal for gpio access
- Device
- GpioDevice
- OutputDevice
- Add servo example
- Softpwm

Author: rahul-thakoor

.travis.yml

@@ -1,13 +1,23 @@
 branches:
   only:
-  - master
-  
+    - master
+
 language: rust
 sudo: required
 cache: cargo
+services: docker
 rust:
   - stable
   - nightly
+install:
+  - cargo install cross || true
+  - source ~/.cargo/env || true
+script:
+  - cross build --target $TARGET
+  - cross build --target $TARGET --release
+env:
+  - TARGET=armv7-unknown-linux-gnueabihf
+  - TARGET=aarch64-unknown-linux-gnu
 matrix:
   allow_failures:
     - rust: nightly

Cargo.toml

@@ -12,12 +12,10 @@ exclude = [".idea/*", "doc/**/*.html"]
 edition = "2018"
 
 [features]
-nightly = ["linux-embedded-hal"]
+
 
 [dependencies]
-sysfs_gpio = "0.5.3"
-linux-embedded-hal = {version="0.1.1",optional=true}
-wiringpi = "0.2.4"
+rppal = "0.11.1"
 
 [badges]
 travis-ci = { repository = "rahul-thakoor/rust_gpiozero", branch = "master" }

README.md

@@ -7,8 +7,6 @@ A simple interface to GPIO devices with Raspberry Pi.
 This library is based on [GPIOZero](https://gpiozero.readthedocs.io/en/stable/index.html)
 library.
 
-_Note: This is a work in progress. The library will eventually support `embedded-hal` based drivers_
-
 
 The idea is to get started with physical computing using Rust with little coding
 by hiding the underlying complexity.
@@ -19,37 +17,28 @@ The library uses [BCM Pin numbering](https://pinout.xyz/)
 
 ```rust
 
-extern crate rust_gpiozero;
 use rust_gpiozero::*;
 
 fn main() {
-
-// Create a new LED attached to Pin 17
-
-let mut led = LED::new(17);
-
-// blink the LED
-// on_time: 2 seconds and off_time: 3 seconds
-
-led.blink(2,3);
-
+    // Create a new LED attached to Pin 17
+    let mut led = LED::new(17);
+    // blink the LED
+    led.blink(2.0, 3.0);
 }
 
 ```
 
 
 ### Example : Wait for a Button Press
 ```rust
-extern crate rust_gpiozero;
-use rust_gpiozero::*;
 
+use rust_gpiozero::*;
 
 fn main() {
     // Create a button which is attached to Pin 17
-    let button = Button::new(17);
-    button.wait_for_press();
+    let mut button = Button::new(17);
+    button.wait_for_press(None);
     println!("button pressed");
-
 }
 
 ```
@@ -86,7 +75,7 @@ To use `rust_gpiozero`, first add this to your Cargo.toml:
 
 ```toml
 [dependencies]
- rust_gpiozero = "0.1.0"
+ rust_gpiozero = "0.2.0"
 ```
 Compiling your project on a Raspberry Pi directly can take significant time depending on the model. Ideally, you would cross compile your project then run it on the Raspberry Pi. 
 
@@ -96,7 +85,7 @@ Compiling your project on a Raspberry Pi directly can take significant time depe
 
 The following features are planned :
 
-- [ ] Support for `linux-embedded-hal`
+- [ ] Support for `embedded-hal`
 - [ ] Support for common devices such as Accelerometer, Temperature sensors, etc
 
 
@@ -105,6 +94,9 @@ The following features are planned :
 
 [GNU General Public License v3.0](https://github.com/rahul-thakoor/rust_gpiozero/blob/master/LICENSE.md)
 
+## Credits
+This library would not be possible without the great work of the maintainers of [GPIOZero](https://gpiozero.readthedocs.io/en/stable/index.html) and [rppal](https://github.com/golemparts/rppal)
+
 ## Contributing
 Thanks for your interest in `rust_gpiozero`. I am a newbie rustacean and just started using the language! I am using this project to learn more about Rust. Feel free to give feedback or send PRs. Your experiences and feedback will also benefit others who use this library.
 

examples/blink.rs

@@ -6,5 +6,5 @@ fn main() {
     // Create a new LED attached to Pin 17
     let mut led = LED::new(17);
     // blink the LED
-    led.blink(2, 3);
+    led.blink(2.0, 3.0);
 }

examples/button.rs

@@ -4,7 +4,7 @@ use rust_gpiozero::*;
 
 fn main() {
     // Create a button which is attached to Pin 17
-    let button = Button::new(17);
-    button.wait_for_press();
+    let mut button = Button::new(17);
+    button.wait_for_press(None);
     println!("button pressed");
 }

examples/servo.rs

@@ -0,0 +1,20 @@
+use rust_gpiozero::*;
+use std::io;
+use std::io::prelude::*;
+use std::thread;
+use std::time::Duration;
+
+fn main() {
+    // Create a new Servo attached to Pin 23
+    let mut servo = Servo::new(23);
+
+    loop{
+        servo.max();
+        thread::sleep(Duration::from_millis(2000));
+        servo.min();
+        thread::sleep(Duration::from_millis(2000));
+    }
+
+    // wait for key press to exit
+    let _ = io::stdin().read(&mut [0u8]).unwrap();
+}

examples/softpwm.rs

@@ -7,7 +7,8 @@ fn main() {
     let mut led = PWMLED::new(17);
 
     // blink the LED 5 times
-    led.blink(2.0, 2.0, 1.0, 1.0, Some(5));
+    led.set_blink_count(5);
+    led.blink(2.0, 2.0, 1.0, 1.0);
 
     // wait for key press to exit
     let _ = io::stdin().read(&mut [0u8]).unwrap();

src/devices.rs

@@ -1,39 +1,80 @@
 //! Describes generic devices such as `GPIODevice` and `CompositeDevice`
-use crate::traits::Device;
-use sysfs_gpio::Pin;
+
+use rppal::gpio::{Gpio, Level, Pin};
+
+/// Represents a single device of any type; GPIO-based, SPI-based, I2C-based,
+/// etc.  It defines the basic services applicable to all devices
+pub trait Device {
+    /// Shut down the device and release all associated resources.
+    fn close(self);
+
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    fn is_active(&self) -> bool;
+}
+#[macro_export]
+macro_rules! impl_device {
+    () => {
+    /// Returns ``True`` if the device is currently active and ``False`` otherwise.
+    pub fn is_active(&self) -> bool {
+        self.value()
+    }
+    /// Shut down the device and release all associated resources.
+    pub fn close(self) {
+        drop(self)
+    }
+    }
+}
 
 /// Represents a generic GPIO device and provides the services common to all single-pin GPIO devices
 #[derive(Debug)]
-pub struct GPIODevice {
-    pub pin: Pin,
+pub struct GpioDevice {
+    pin: Pin,
+    active_state: bool,
+    inactive_state: bool,
 }
 
-impl GPIODevice {
-    pub fn new(pin: u64) -> GPIODevice {
-        //Create a new Pin with the provided pin_num
-        let gpio = Pin::new(pin);
-        //check if pin is not already exported
+macro_rules! impl_gpio_device {
+    () => {
+    /// The `Pin` that the device is connected to.
+    pub fn pin(&self) -> u8 {
+        self.pin.pin()
+    }
 
-        //try to export the selected pin
-        //Todo implement better error handling
-        gpio.export().expect("Could not export the selected gpio");
-        GPIODevice { pin: gpio }
     }
 }
 
-impl Device for GPIODevice {
-    fn pin(&self) -> Pin {
-        self.pin
+impl GpioDevice {
+    /// Returns a GpioDevice with the pin number given
+    /// # Arguments
+    ///
+    /// * `pin` - The GPIO pin which the device is attached to
+    ///
+    pub fn new(pin: u8) -> GpioDevice {
+        match Gpio::new() {
+            Err(e) => panic!("{:?}", e),
+            Ok(gpio) => match gpio.get(pin) {
+                Err(e) => panic!("{:?}", e),
+                Ok(pin) => GpioDevice {
+                    pin,
+                    active_state: true,
+                    inactive_state: false,
+                },
+            },
+        }
     }
 
     /// Returns a value representing the device's state.
-    fn value(&self) -> i8 {
-        let value = self
-            .pin
-            .get_value()
-            .expect("Could not check if device is active");
-        value as i8
+    pub fn value(&self) -> bool {
+        self.state_to_value()
     }
-}
 
-//Todo CompositeDevice
+    fn state_to_value(&self) -> bool {
+        match self.pin.read() {
+            Level::High => self.active_state,
+            Level::Low => !self.active_state,
+        }
+    }
+
+    impl_device!();
+    impl_gpio_device!();
+}