1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


use std::time;
use picollar::*;

use apigpio::*;
use apigpio::Level::*;

use sequence::*;

use tokio::time::delay_for;

async fn transmit(pi : &Connection, pulses : &[Pulse], ms : u32)
                  -> Result<()> {
  pi.wave_clear().await?;
  pi.wave_add_generic(&pulses).await?;
  println!("{}us / {}us",
           pi.wave_get_micros().await?,
           pi.wave_get_max_micros().await?);
  let w = pi.wave_create().await?;
  pi.wave_send_repeat(w).await?;
  delay_for(time::Duration::from_millis(ms as u64)).await;
  pi.wave_tx_stop().await?;
  pi.wave_clear().await?;
  pi.gpio_write(GPIO,L).await?;
  Ok(())
}

const USAGE : &str = 
"usage: sync KEY CHANNEL MODE [POWER] [MS]";

async fn execute() -> Result<()> {
  let mut args = picollar::args::Args::new(USAGE);

  let _ : String     = args.parse_next("argv0");

  let key = args.next().unwrap_or_else(|| args.badusage("missing key"));
  let key = u16::from_str_radix(&key, 16)
    .unwrap_or_else(|e| args.badusage(&format!("bad (hex) key: {:?}", e)));

  let channel        = args.parse_next("channel");
  let mode    : Mode = args.parse_next("mode");
  let power = if !mode.needs_power() { 1 } else {
                       args.parse_next("power")
  };
  let ms = if args.len()==0 { 400 } else {
                       args.parse_next("durationr")
  };
  let c = Command { key, channel, mode, power };

  let (pulses, desc) = mk_pulses(&c);
  println!("will transmit {}", desc);

  let pi = Connection::new().await?;
  transmit(&pi, &pulses, ms).await?;
  Ok(())
}

#[tokio::main]
async fn main(){
  execute().await.expect("error");
}