Add softpwm

Add support for software-based PWM using wiringpi

-PWMOutputDevice
-PWMLed

Author: rahul-thakoor

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_gpiozero"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Rahul Thakoor <[email protected]>"]
 repository = "https://github.com/rahul-thakoor/rust_gpiozero.git"
 homepage = "https://github.com/rahul-thakoor/rust_gpiozero.git"
@@ -9,13 +9,15 @@ readme = "README.md"
 description = "A library inspired by gpiozero written in Rust."
 keywords = ["embedded-hal", "raspberry","pi", "gpiozero", "rpi"]
 exclude = [".idea/*", "doc/**/*.html"]
+edition = "2018"
 
 [features]
 nightly = ["linux-embedded-hal"]
 
 [dependencies]
-sysfs_gpio = "0.5.1"
+sysfs_gpio = "0.5.3"
 linux-embedded-hal = {version="0.1.1",optional=true}
+wiringpi = "0.2.4"
 
 [badges]
 travis-ci = { repository = "rahul-thakoor/rust_gpiozero", branch = "master" }

examples/blink.rs

@@ -1,13 +1,10 @@
 //! Blinks an LED : on_time: 2 seconds and off_time: 3 seconds
 
-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
-    led.blink(2,3);
-
-  }
+    led.blink(2, 3);
+}

examples/button.rs

@@ -1,12 +1,10 @@
 //! Display message in console when a Button is pressed
-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();
     println!("button pressed");
-
 }

examples/softpwm.rs

@@ -0,0 +1,14 @@
+use rust_gpiozero::*;
+use std::io;
+use std::io::prelude::*;
+
+fn main() {
+    // Create a new LED attached to Pin 17
+    let mut led = PWMLED::new(17);
+
+    // blink the LED 5 times
+    led.blink(2.0, 2.0, 1.0, 1.0, Some(5));
+
+    // wait for key press to exit
+    let _ = io::stdin().read(&mut [0u8]).unwrap();
+}

src/devices.rs

@@ -1,40 +1,39 @@
 //! Describes generic devices such as `GPIODevice` and `CompositeDevice`
+use crate::traits::Device;
 use sysfs_gpio::Pin;
-use traits::Device;
 
 /// 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 pin: Pin,
 }
 
 impl GPIODevice {
-    pub fn new(pin:u64) -> 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
-       
+        let gpio = Pin::new(pin);
+        //check if pin is not already exported
+
         //try to export the selected pin
         //Todo implement better error handling
         gpio.export().expect("Could not export the selected gpio");
-        GPIODevice {pin:gpio}
+        GPIODevice { pin: gpio }
     }
-    
-    
 }
 
-
 impl Device for GPIODevice {
     fn pin(&self) -> Pin {
-       self.pin
+        self.pin
     }
 
-     /// Returns a value representing the device's state.
+    /// 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");
+        let value = self
+            .pin
+            .get_value()
+            .expect("Could not check if device is active");
         value as i8
     }
- 
 }
 
 //Todo CompositeDevice

src/input_devices.rs

@@ -1,54 +1,56 @@
 //! Input device component interfaces for devices such as `Button`
-use devices::GPIODevice;
-use traits::*;
-use sysfs_gpio::{Direction,Pin};
-
+use crate::devices::GPIODevice;
+use crate::traits::*;
+use sysfs_gpio::{Direction, Pin};
 
 /// Represents a generic GPIO input device.
 #[derive(Debug)]
 pub struct InputDevice {
-    pub pin : Pin
+    pub pin: Pin,
 }
 
-
 impl InputDevice {
     /// Creates a new input device with pin number `pin`
-    pub fn new(pin:u64) -> InputDevice{
+    pub fn new(pin: u64) -> InputDevice {
         let gpiodevice = GPIODevice::new(pin);
         // set direction to input
-        gpiodevice.pin.set_direction(Direction::In).expect("Could not set pin to Input mode");
+        gpiodevice
+            .pin
+            .set_direction(Direction::In)
+            .expect("Could not set pin to Input mode");
         InputDevice {
-            pin: gpiodevice.pin
-            }
+            pin: gpiodevice.pin,
+        }
     }
 }
 
 impl Device for InputDevice {
     fn pin(&self) -> Pin {
-       self.pin
+        self.pin
     }
 
     /// 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");
+        let value = self
+            .pin
+            .get_value()
+            .expect("Could not check if device is active");
         value as i8
     }
 }
 
-
 /// Represents a generic input device with typical on/off behaviour.
-/// Adds machinery to fire the active and inactive events for devices 
+/// Adds machinery to fire the active and inactive events for devices
 /// that operate in a typical digital manner: straight forward on / off
 /// states with (reasonably) clean transitions between the two.
 
 pub struct DigitalInputDevice {
-    pin : Pin
+    pin: Pin,
 }
 
-impl DigitalInputDevice{
+impl DigitalInputDevice {
     /// Create a new Digital Input Device
-    pub fn new(pin:u64) -> DigitalInputDevice {
+    pub fn new(pin: u64) -> DigitalInputDevice {
         let inpin = InputDevice::new(pin);
         DigitalInputDevice { pin: inpin.pin }
     }
@@ -57,34 +59,39 @@ impl DigitalInputDevice{
 /// gives DigitalInputDevice Device behaviours such as close, is_active, etc
 impl Device for DigitalInputDevice {
     fn pin(&self) -> Pin {
-       self.pin
+        self.pin
     }
 
     /// 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");
+    fn value(&self) -> i8 {
+        let value = self
+            .pin
+            .get_value()
+            .expect("Could not check if device is active");
         value as i8
     }
 }
 
-/// Give DigitalInputDevice event traits 
+/// Give DigitalInputDevice event traits
 impl EventsTrait for DigitalInputDevice {}
 
-
 /// Represents a simple push button or switch.
 /// Connect one side of the button to a ground pin, and the other to any GPIO pin
 
 pub struct Button {
-    pin: Pin
+    pin: Pin,
 }
 
 impl Device for Button {
     fn pin(&self) -> Pin {
-       self.pin
+        self.pin
     }
     /// 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");
+    fn value(&self) -> i8 {
+        let value = self
+            .pin
+            .get_value()
+            .expect("Could not check if device is active");
         value as i8
     }
 }
@@ -93,28 +100,23 @@ impl EventsTrait for Button {}
 
 impl Button {
     /// Create a new Button
-    pub fn new(pin:u64) -> Button{
+    pub fn new(pin: u64) -> Button {
         let din = DigitalInputDevice::new(pin);
-        Button{
-            pin : din.pin
-        }
+        Button { pin: din.pin }
     }
 
     /// Pause the script until the device is activated
-    pub fn wait_for_press(&self){
+    pub fn wait_for_press(&self) {
         self.wait_for_active();
     }
 
     /// Pause the script until the device is deactivated
-    pub fn wait_for_release(&self){
+    pub fn wait_for_release(&self) {
         self.wait_for_inactive();
     }
+}
 
-
-}    
-
-
-/// Represents a generic input device which takes its value 
+/// Represents a generic input device which takes its value
 /// from the average of a queue of historical values.
 
 pub struct SmoothedInputDevice;

src/lib.rs

@@ -52,20 +52,15 @@
 //!
 //! ```
 
-extern crate sysfs_gpio;
-
 #[cfg(nightly)]
 extern crate embedded_hal as hal;
 
-pub use self::output_devices::*;
 pub use self::devices::*;
-pub use self::traits::*;
 pub use self::input_devices::*;
+pub use self::output_devices::*;
+pub use self::traits::*;
 //pub mod led;
 pub mod devices;
-pub mod output_devices;
 pub mod input_devices;
+pub mod output_devices;
 pub mod traits;
-
-
-

src/main.rs

@@ -1,17 +1,11 @@
-extern crate rust_gpiozero;
-
 use std::thread;
 use std::time::Duration;
 
 use rust_gpiozero::*;
 
-
-
 fn main() {
-
-    let mut motor = Motor::new(17,27);
+    let mut motor = Motor::new(17, 27);
     motor.forward();
     thread::sleep(Duration::from_secs(3));
     motor.stop();
-
 }