commit - e31f24367a0524530c36319b6afb94eea0c88792
commit + 83a396e439e278ba96582a6e060db346c7f2b4eb
blob - b06f69f722ea7e8af10ea6ba3a3d646c7b3846f5
blob + 50b22430279145c6ae277051bfe8755bc2d6604a
--- Cargo.lock
+++ Cargo.lock
@@ -671,6 +671,7 @@ dependencies = [
  "esp-idf-sys",
  "log",
  "ble_esp32c3",
+ "once_cell",
 ]
 
 [[package]]
blob - a59c4b554f953df362197ae05a3a8c56a0704f41
blob + 5633cec7ec2afe5d853eb36f51845fb56a35a654
--- Cargo.toml
+++ Cargo.toml
@@ -12,6 +12,7 @@ esp-idf-svc = "0.42.5"
 esp-idf-sys = "0.31.10"
 log = "0.4.17"
 ble_esp32c3 = "0.1.0"
+once_cell = "1.16.0"
 
 [build-dependencies]
 anyhow = "1.0.66"
blob - ccd86c349add283100c78ec5a89eed7d15290ee8
blob + 5d2514439a7abed37550f00b42a8ceac841dde6f
--- src/main.rs
+++ src/main.rs
@@ -1,39 +1,57 @@
-use ble_esp32c3::{gatt::*, Ble};
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
 
-const BUFFER_LEN: usize = 128;
+use ble_esp32c3::gatt::*;
 
+use once_cell::sync::Lazy;
+
+// maximum buffer size allowed (ATT_DATA = ATT_MAX_SIZE - ATT_HEADER_SIZE = 517 - 5 = 512)
+const BUFFER_LEN: usize = 512;
+
 const SERVICE_UUID: [u8; 16] = 0x061f8f7050293e727e62a46aa61cda68u128.to_le_bytes();
 const BUFFER_READY_UUID: [u8; 16] = 0x78844add576bb4cd3c40f1f3d536a38au128.to_le_bytes();
 const DATA_BUFFER_UUID: [u8; 16] = 0xb57fc8740ebd1d2695ae2d31db630a54u128.to_le_bytes();
 const BUFFER_LEN_UUID: [u8; 16] = 0x3e0fb4716b176bbc63b82b70b6cf54ddu128.to_le_bytes();
 
+static STATE: Lazy<Mutex<ThroughputState>> = Lazy::new(|| Mutex::new(ThroughputState::new()));
+
+struct ThroughputState {
+    time_passed: Instant,
+    write_len: usize,
+}
+
+impl ThroughputState {
+    pub fn new() -> Self {
+        Self {
+            time_passed: Instant::now(),
+            write_len: 0,
+        }
+    }
+
+    pub fn get_time_passed(&self) -> Duration {
+        self.time_passed.elapsed()
+    }
+
+    pub fn add_write_len(&mut self, len: usize) {
+        self.write_len += len;
+    }
+
+    pub fn get_write_len(&self) -> usize {
+        self.write_len
+    }
+}
+
 fn handle_buffer_write(payload: Vec<u8>) {
-    let buf_ready_handle = Ble::find_attribute_by_uuid(BUFFER_READY_UUID.into()).unwrap();
-    let buf_handle = Ble::find_attribute_by_uuid(DATA_BUFFER_UUID.into()).unwrap();
-
-    log::info!("Received buffer write of length {}", payload.len());
-
-    let buf = buf_handle.read_value().unwrap();
-    log::info!("buf: {:?}", buf);
-
-    // wipe buffer for new write
-    let handle = ble_esp32c3::Ble::find_attribute_by_uuid(DATA_BUFFER_UUID.into()).unwrap();
-    handle
-        .write_value(&mut std::iter::repeat(0).take(BUFFER_LEN).collect::<Vec<u8>>())
-        .unwrap();
-
-    // TODO: do work with buffer...
-
-    // done working with the buffer, client can send more data
-    buf_ready_handle.write_value(&mut [1]).unwrap();
+    let mut state = STATE.lock().unwrap();
+    state.add_write_len(payload.len());
 }
 
 fn setup(ble: &mut ble_esp32c3::Ble) {
     let mut buf_ready = Characteristic::new(
         BUFFER_READY_UUID.into(),
-        Permissions::Read,
+        Permissions::ReadWrite,
         1,
-        Some(vec![0]),
+        Some(vec![1]),
         vec![],
         None,
     );
@@ -42,7 +60,7 @@ fn setup(ble: &mut ble_esp32c3::Ble) {
 
     let mut buf_len = Characteristic::new(
         BUFFER_LEN_UUID.into(),
-        Permissions::Read,
+        Permissions::ReadWrite,
         std::mem::size_of::<usize>() as u16,
         Some(BUFFER_LEN.to_be_bytes().to_vec()),
         vec![],
@@ -52,7 +70,7 @@ fn setup(ble: &mut ble_esp32c3::Ble) {
 
     let mut buf_data = Characteristic::new(
         DATA_BUFFER_UUID.into(),
-        Permissions::Write,
+        Permissions::ReadWrite,
         BUFFER_LEN as u16,
         Some(std::iter::repeat(0).take(BUFFER_LEN).collect::<Vec<u8>>()),
         vec![],
@@ -71,14 +89,26 @@ fn main() {
 
     let mut ble = ble_esp32c3::Ble::new_with_name("ble-throughput");
     setup(&mut ble);
-    log::error!("ble: {:?}", ble.init());
+    if let Err(e) = ble.init() {
+        log::error!("error initialising ble: {:?}", e);
+    }
 
     loop {
-        if let Some(rssi) = ble_esp32c3::Ble::rssi() {
-            log::info!("RSSI {}", rssi);
-        } else {
+        if ble_esp32c3::Ble::rssi().is_none() {
             log::info!("Currently not connected.");
+        } else {
+            let s = STATE.lock().unwrap();
+            let passed = s.get_time_passed().as_secs().max(1);
+            let len = s.get_write_len();
+
+            log::info!(
+                "Throughput: {} ({} / {})",
+                len / passed as usize,
+                len,
+                passed
+            );
         }
+
         std::thread::sleep(std::time::Duration::from_millis(1000));
     }
 }