【MYD-Y6ULX试用体验】控制GPIO

1. $ git clone github.com/rust-embedded/rust-sysfs-gpio
   
2. $ cd rust-sysfs-gpio

编译完成后，可在target/armv7-unknown-linux-gnueabihf/debug/examples 目录下看到生成的可执行文件blinky，将该文件复制到开发板中，加入可执行权限。

1. $ cargo build --example blinky --target armv7-unknown-linux-gnueabihf

1. # ./blinky 26 10000 100

1. fn blink_my_led(led: u64, duration_ms: u64, period_ms: u64) -> sysfs_gpio::Result<()> {
   
2.     let my_led = Pin::new(led);
   
3.     my_led.with_exported(|| {
   
4.         my_led.set_direction(Direction::Low)?;
   
5.         let iterations = duration_ms / period_ms / 2;
   
6.         for _ in 0..iterations {
   
7.             my_led.set_value(0)?;
   
8.             sleep(Duration::from_millis(period_ms));
   
9.             my_led.set_value(1)?;
   
10.             sleep(Duration::from_millis(period_ms));
    
11.         }
    
12.         my_led.set_value(0)?;
    
13.         Ok(())
    
14.     })
    
15. }

1. my_led.with_exported(|| {
   
2.     ....
   
3. 
   

1. my_led.set_direction(Direction::Low)?

引用: my_led.set_value(1)?

1. extern crate sysfs_gpio;
   
2. 
   
3. use sysfs_gpio::{Direction, Pin};
   
4. use std::time::Duration;
   
5. use std::thread::sleep;
   
6. use std::env;
   
7. 
   
8. struct Arguments {
   
9.     pin: u64,
   
10.     duration_ms: u64,
    
11.     period_ms: u64,
    
12. }
    
13. 
    
14. // Export a GPIO for use.  This will not fail if already exported
    
15. fn blink_my_led(led: u64, duration_ms: u64, period_ms: u64) -> sysfs_gpio::Result<()> {
    
16.     let my_led = Pin::new(led);
    
17.     my_led.with_exported(|| {
    
18.         my_led.set_direction(Direction::Low)?;
    
19.         let iterations = duration_ms / period_ms / 2;
    
20.         for _ in 0..iterations {
    
21.             my_led.set_value(0)?;
    
22.             sleep(Duration::from_millis(period_ms));
    
23.             my_led.set_value(1)?;
    
24.             sleep(Duration::from_millis(period_ms));
    
25.         }
    
26.         my_led.set_value(0)?;
    
27.         Ok(())
    
28.     })
    
29. }
    
30. 
    
31. fn print_usage() {
    
32.     println!("Usage: ./blinky ");
    
33. }
    
34. 
    
35. fn get_args() -> Option {
    
36.     let args: Vec = env::args().collect();
    
37.     if args.len() != 4 {
    
38.         return None;
    
39.     }
    
40.     let pin = match args[1].parse::() {
    
41.         Ok(pin) => pin,
    
42.         Err(_) => return None,
    
43.     };
    
44.     let duration_ms = match args[2].parse::() {
    
45.         Ok(ms) => ms,
    
46.         Err(_) => return None,
    
47.     };
    
48.     let period_ms = match args[3].parse::() {
    
49.         Ok(ms) => ms,
    
50.         Err(_) => return None,
    
51.     };
    
52.     Some(Arguments {
    
53.              pin: pin,
    
54.              duration_ms: duration_ms,
    
55.              period_ms: period_ms,
    
56.          })
    
57. }
    
58. 
    
59. fn main() {
    
60.     match get_args() {
    
61.         None => print_usage(),
    
62.         Some(args) => {
    
63.             match blink_my_led(args.pin, args.duration_ms, args.period_ms) {
    
64.                 Ok(()) => println!("Success!"),
    
65.                 Err(err) => println!("We have a blinking problem: {}", err),
    
66.             }
    
67.         }
    
68.     }
    
69. }