etherdream 0.1.1

An EtherDream (laser projector DAC) library.
Documentation 
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// Copyright (c) 2017 Brandon Thomas <bt@brand.io>, <echelon@gmail.com>
// Etherdream.rs, a library for the EtherDream laser projector DAC.

extern crate etherdream;

use etherdream::dac::Dac;
use etherdream::protocol::COLOR_MAX;
use etherdream::protocol::Point;
use etherdream::protocol::X_MAX;
use etherdream::protocol::X_MIN;
use etherdream::protocol::Y_MAX;
use etherdream::protocol::Y_MIN;
use std::f64::consts::PI;
use std::f64;
use std::sync::Arc;
use std::sync::RwLock;
use std::thread;

static DIV : i16 = 200;

/// A nifty circle.
struct Circle {
  // Color
  pub r: u16,
  pub g: u16,
  pub b: u16,
  // Size
  pub radius: i16,
  // Position
  pub x: i16,
  pub y: i16,
  // Velocity
  pub x_vel: i16,
  pub y_vel: i16,
}

impl Circle {
  pub fn new(radius: i16) -> Circle {
    Circle {
      r: COLOR_MAX,
      g: COLOR_MAX,
      b: 0,
      radius: radius,
      x: 0,
      y: 0,
      x_vel: 170,
      y_vel: 150,
    }
  }
}

impl Circle {
  pub fn get_points(&self, num_points: u16, position: &mut i16) -> Vec<Point> {
    let mut points = Vec::new();
    for _i in 0 .. num_points {
      *position = (*position + 1) % DIV;

      let j = (*position as f64 / DIV as f64) * 2 as f64 * PI;
      let x = j.cos() * self.radius as f64 + self.x as f64;
      let y = j.sin() * self.radius as f64 + self.y as f64;

      let x = x as i16;
      let y = y as i16;

      points.push(Point::xy_rgb(x, y, self.r, self.g, self.b))
    }
    points
  }

  pub fn animate(&mut self) {
    println!("x: {}, y: {}", self.x, self.y);

    let max = self.max_coordinate();
    let min = self.min_coordinate();

    let mut x = self.x.saturating_add(self.x_vel);

    if x > max {
      x = max;
      self.x_vel *= -1;
    } else if x < min {
      x = min;
      self.x_vel *= -1;
    }

    self.x = x;

    let mut y = self.y.saturating_add(self.y_vel);

    if y > max {
      y = max;
      self.y_vel *= -1;
    } else if y < min {
      y = min;
      self.y_vel *= -1;
    }

    self.y = y;
  }

  fn max_coordinate(&self) -> i16 {
    X_MAX - self.radius
  }

  fn min_coordinate(&self) -> i16 {
    X_MIN + self.radius
  }
}

fn main() {
  let ip_addr = etherdream::network::find_first_dac()
      .expect("Couldn't find DAC!")
      .ip_address;

  let mut dac = Dac::new(ip_addr);

  let mut circle = Arc::new(RwLock::new(Circle::new(8000)));
  let mut circle2 = circle.clone();

  let mut pos = 0;

  thread::spawn(move || {
    loop {
      // FIXME: Locking critical section is bigger than it has to be.
      circle.write().unwrap().animate();
      thread::sleep_ms(10);
    }
  });

  dac.play_function(|num_points: u16| {
    circle2.read().unwrap().get_points(num_points, &mut pos)
  });
}