all of the things

Author: celaus

.gitignore

@@ -45,3 +45,15 @@ $RECYCLE.BIN/
 Network Trash Folder
 Temporary Items
 .apdisk
+
+
+#Added by cargo
+#
+#already existing elements are commented out
+
+/target
+**/*.rs.bk
+Cargo.lock
+
+
+**/target

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Chapter10/rusty-ml/fashion-mnist"]
+	path = Chapter10/rusty-ml/fashion-mnist
+	url = https://github.com/zalandoresearch/fashion-mnist.git

Chapter03/custom-build/out/.rustc_info.json

@@ -5,5 +5,5 @@ authors = ["Claus Matzinger <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-tokio = { version = "0.1", features = ["async-await-preview"] }
-hyper = "0.12"
+runtime = "0.3.0-alpha.6"
+surf = "1.0"

Chapter03/custom-build/out/debug/.cargo-lock

@@ -1,22 +1,15 @@
-#![feature(await_macro, async_await)]
+use surf::Exception;
+use surf::http::StatusCode;
 
-use tokio::await;
-use tokio::prelude::*;
-use hyper::{Client, StatusCode};
-use std::time::Duration;
-use std::str;
-
-async fn response_code(url: &str) -> StatusCode {
-    let uri = url.parse().unwrap();
-    let client = Client::new();
-    let response = await!(client.get(uri)
-                .timeout(Duration::from_secs(30))).unwrap();
-    response.status()
+async fn response_code(url: &str) -> Result<StatusCode, Exception> {
+    let res = surf::get(url).await?;
+    Ok(res.status())
 }
 
-fn main() {
-    tokio::run_async(async {
-        let status = await!(response_code("http://blog.x5ff.xyz"));
-        println!("Got the status: {}", status);
-    });
+#[runtime::main]
+async fn main() -> Result<(), Exception> {
+    let url = "https://www.rust-lang.org";
+    let status = response_code(url).await?;
+    println!("{} responded with HTTP {}", url, status);
+    Ok(())
 }

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/.cargo-lock

@@ -10,10 +10,10 @@ crate-type = ["cdylib"]
 
 [dependencies]
 sha2 = "0.8"
-wasm-bindgen = "0.2.47"
+wasm-bindgen = "0.2.48"
 
 [dependencies.web-sys]
-version = "0.3.4"
+version = "0.3.25"
 features = [
   'Document',
   'Element',

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/.fingerprint/custom-build-0354a0e8029ace12/bin-custom-build

@@ -26,14 +26,17 @@ pub fn start() -> Result<(), JsValue> {
 
 #[wasm_bindgen]
 pub extern "C" fn digest_attach(data: String, elem_id: String) -> Result<(), JsValue> {
-    let window = web_sys::window().expect("no global `window` exists");
-    let document = window.document().expect("should have a document on window");
-    //let body = document.body().expect("document should have a body");
-
-    // Manufacture the element we're gonna append
-    let val = document.get_element_by_id(&elem_id).expect(&format!("Could not get element with id '{}'", elem_id));
-    let signature = hex_digest(&data);
-    val.set_inner_html(&signature);
-    Ok(())
+    web_sys::window().map_or(Err("No window found".into()), |win| {
+        if let Some(doc) = win.document() {
+            doc.get_element_by_id(&elem_id).map_or(Err(format!("No element with id {} found", elem_id).into()), |val|{
+                let signature = hex_digest(&data);
+                val.set_inner_html(&signature);
+                Ok(())
+            })
+        }
+        else {
+            Err("No document found".into())
+        }
+    })
 }
 // No tests :( 

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/.fingerprint/custom-build-0354a0e8029ace12/bin-custom-build.json

@@ -1,3 +1,25 @@
+#[cfg(target_arch = "x86")]
+const ARCH: &str = "x86";
+
+#[cfg(target_arch = "x86_64")]
+const ARCH: &str = "x64";
+
+#[cfg(target_arch = "mips")]
+const ARCH: &str = "mips";
+
+#[cfg(target_arch = "powerpc")]
+const ARCH: &str = "powerpc";
+
+#[cfg(target_arch = "powerpc64")]
+const ARCH: &str = "powerpc64";
+
+#[cfg(target_arch = "arm")]
+const ARCH: &str = "ARM";
+
+#[cfg(target_arch = "aarch64")]
+const ARCH: &str = "ARM64";
+
 fn main() {
     println!("Hello, world!");
+    println!("Compiled for {}", ARCH);
 }

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/.fingerprint/custom-build-0354a0e8029ace12/dep-bin-custom-build

@@ -7,3 +7,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+rand = "0.5"

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/.fingerprint/custom-build-0354a0e8029ace12/invoked.timestamp

@@ -1,3 +1,16 @@
+
+mod sensor;
+
+use sensor::{Bmx42Device, RawI2CDeviceMock, Thermometer};
+use std::thread::sleep;
+use std::time::Duration;
+
+
 fn main() {
-    println!("Hello, world!");
-}
+    let mut device = Bmx42Device::new(RawI2CDeviceMock::new("/dev/i2c-1".into(), 0x5f)).unwrap();
+    let pause = Duration::from_secs(1);
+    loop {
+        println!("Current temperature {} °C", device.temp_celsius().unwrap());
+        sleep(pause);
+    }
+}

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/custom-build.d

@@ -0,0 +1,62 @@
+use std::io;
+use rand::prelude::*;
+
+pub trait Thermometer {
+    fn temp_celsius(&mut self) -> Result<f32>;
+}
+
+type Result<T> = std::result::Result<T, io::Error>;
+
+enum Register {
+    Calib0 = 0x00,
+    Data = 0x01,
+}
+
+#[allow(dead_code)]
+pub struct RawI2CDeviceMock {
+    path: String,
+    device_id: u8,
+}
+
+
+impl RawI2CDeviceMock {
+    pub fn new(path: String, device_id: u8) -> RawI2CDeviceMock {
+        RawI2CDeviceMock {
+            path: path,
+            device_id: device_id,
+        }
+    }
+
+    pub fn read(&self, register: u8) -> Result<u8> {
+        let register = register as usize;
+        if register == Register::Calib0 as usize {
+            Ok(1_u8)
+        } else { // register is the data register
+            Ok(random::<u8>())
+        }
+    }
+}
+
+pub struct Bmx42Device {
+    raw: RawI2CDeviceMock,
+    calibration: u8,
+}
+
+impl Bmx42Device {
+    pub fn new(device: RawI2CDeviceMock) -> Result<Bmx42Device> {
+        let calib = device.read(Register::Calib0 as u8)?;
+        Ok(Bmx42Device {
+            raw: device,
+            calibration: calib
+        })
+    }
+}
+
+
+impl Thermometer for Bmx42Device {
+    fn temp_celsius(&mut self) -> Result<f32> {
+        let raw_temp = self.raw.read(Register::Data as u8)?;
+        // converts the result into something usable; from the specification
+        Ok(((raw_temp as i8) << (self.calibration as i8)) as f32 / 10.0)
+    }
+}

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/custom-build.wasm

@@ -7,3 +7,6 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+tokio = "0.1"
+tokio-timer = "0.2"
+rand = "0.5"

Chapter03/custom-build/out/wasm32-unknown-unknown/debug/deps/custom-build.wasm

@@ -1,3 +1,48 @@
+mod sensor;
+use tokio::prelude::*;
+use tokio::timer::Interval;
+
+use sensor::{Bmx42Device, RawI2CDeviceMock, Thermometer};
+use std::time::{Duration, UNIX_EPOCH, SystemTime, Instant};
+use std::thread;
+
+use std::sync::mpsc::channel;
+
+fn current_timestamp_ms() -> u64 {
+    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
+}
+
+#[derive(Debug)]
+struct Reading {
+    timestamp: u64,
+    value: f32
+}
+
+
 fn main() {
-    println!("Hello, world!");
+    let mut device = Bmx42Device::new(RawI2CDeviceMock::new("/dev/i2c-1".into(), 0x5f)).unwrap();
+
+    let (sx, rx) = channel();
+
+    thread::spawn(move || {
+        while let Ok(reading) = rx.recv() {
+
+            // or batch and save/send to somewhere
+            println!("{:?}", reading);
+        }
+    });
+    let task = Interval::new(Instant::now(), Duration::from_secs(1))
+        .take(5)
+        .for_each(move |_instant| {
+            let sx = sx.clone();
+            let temp = device.temp_celsius().unwrap();
+            let _ = sx.send(Reading {
+                timestamp: current_timestamp_ms(),
+                value: temp
+            });
+            Ok(())
+        })
+        .map_err(|e| panic!("interval errored; err={:?}", e));
+
+    tokio::run(task);
 }