version 0.1.1

Author: ChickenStorm

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "roccat-vulcan-api-rs"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["ChickenStorm <[email protected]>"]
 edition = "2018"
 readme = "README.md"
 repository = "https://github.com/ChickenStorm/roccat-vulcan-api-rs"
 license = "MIT"
-categories = ["api-bindings"]
+categories = ["hardware-support"]
 description  = "Roccat Vulcan keyboard illumination API"
 keywords  = ["roccat", "vulcan", "keyboard", "lighting", "api"]
 
@@ -17,4 +17,4 @@ keywords  = ["roccat", "vulcan", "keyboard", "lighting", "api"]
 hidapi = "1.2.5"
 
 [dev-dependencies]
-once_cell = "1.5.2"
+once_cell = "1.5.2"

README.md

@@ -7,7 +7,7 @@ Provide an API to control the lighting of the Roccat Vulcan 100 and 120.
 # Usage
 
 add on your dependencies of Cargo.toml
-`roccat_vulcan_api_rs = { version = "0.1.0", git = "https://github.com/ChickenStorm/roccat-vulcan-api-rs" }`.
+`roccat-vulcan-api-rs = { version = "0.1.1", git = "https://github.com/ChickenStorm/roccat-vulcan-api-rs", branch = "main" }`.
 
 
 The main way to interact with the API is through `KeyboardApi`.

examples/render_loop.rs

@@ -0,0 +1,66 @@
+extern crate roccat_vulcan_api_rs;
+
+use roccat_vulcan_api_rs::{
+    constants,
+    ColorRgb,
+    ColorBuffer,
+    Color,
+    KeyboardApi,
+    LayoutFrCh,
+    Layout,
+    Key,
+};
+use std::time::Duration;
+
+fn main() {
+    
+    let mut key_press_mask: [bool; constants::NUMBER_KEY_LED_BUFFER] = [false; constants::NUMBER_KEY_LED_BUFFER];
+    let keyboard = KeyboardApi::get_api().unwrap();
+    let base_color = ColorRgb::new(0,255,255);
+    let press_color = ColorRgb::new(255,0,255);
+    let mut buffer = ColorBuffer::<ColorRgb>::new(base_color);
+    let layout = LayoutFrCh::new();
+    keyboard.render(&buffer).unwrap();
+    'mainloop: loop {
+        let result = keyboard.read_key_press(Duration::from_millis(62));
+        if let Ok(val) = result {
+            for keypress in val {
+                let a = layout.find_key_info_from_press_code(&keypress.key_code());
+                if let Some(key) = a {
+                    if *key.key() == Key::Escape {
+                        break 'mainloop;
+                    }
+                    let index_key = *key.key_code_light() as usize;
+                    if index_key < buffer.buffer().len(){
+                        buffer.buffer_mut()[index_key] = press_color;
+                        key_press_mask[index_key] = keypress.is_pressed()
+                    }
+                }
+            }
+        }
+        keyboard.render(&buffer).unwrap();
+        for index in 0..buffer.buffer().len() {
+            let el = &mut buffer.buffer_mut()[index];
+            if *el != base_color && !key_press_mask[index] {
+                if el.r() > base_color.r(){
+                    *el.r_mut() -= 5.min(el.r() - base_color.r());
+                }
+                else {
+                    *el.r_mut() += 5.min(base_color.r() - el.r());
+                }
+                if el.g() > base_color.g(){
+                    *el.g_mut() -= 5.min(el.g() - base_color.g());
+                }
+                else {
+                    *el.g_mut() += 5.min(base_color.g() - el.g());
+                }
+                if el.b() > base_color.b(){
+                    *el.b_mut() -= 5.min(el.b() - base_color.b());
+                }
+                else {
+                    *el.b_mut() += 5.min(base_color.b() - el.b());
+                }
+            }
+        }
+    }
+}

src/color.rs

@@ -48,6 +48,31 @@ impl ColorRgb {
             b: array[2],
         }
     }
+    
+    pub fn r_mut(&mut self) -> &mut u8 {
+        return &mut self.r;
+    }
+    
+    pub fn g_mut(&mut self) -> &mut u8 {
+        return &mut self.g;
+    }
+    
+    pub fn b_mut(&mut self) -> &mut u8 {
+        return &mut self.b;
+    }
+    
+    pub fn set_r(&mut self, r: u8){
+        self.r = r;
+    }
+    
+    pub fn set_g(&mut self, g: u8){
+        self.g = g;
+    }
+    
+    pub fn set_b(&mut self, b: u8){
+        self.b = b;
+    }
+    
 }
 
 impl Color for ColorRgb {

src/keyboard.rs

@@ -5,7 +5,7 @@
 // todo verify that the device is not loaded.
 
 use super::{
-    layout,
+    layout::Keypress,
     color::{
         Color,
         ColorBuffer,
@@ -16,6 +16,7 @@ use super::{
 use std::{
     thread::sleep,
     time::{Duration, Instant},
+    vec::Vec,
 };
 
 /// Differents error returned by the API
@@ -32,6 +33,7 @@ pub enum ErrorRoccatVulcanApi {
     ToMuchTimeWaited(Duration),
     /// error while trying the get the hdiapi.
     HidApiError(hidapi::HidError),
+    InvalidInput,
 }
 
 /// get the product id of the detected divice
@@ -88,7 +90,7 @@ pub struct KeyboardApi {
 }
 
 /// Sleep duration for KeyboardApi::wait_for_control_device.
-const WAIT_FOR_CONTROL_DURATION: Duration = Duration::from_micros(1);
+const WAIT_FOR_CONTROL_DURATION: Duration = Duration::from_millis(1);
 /// Max time wating for device in KeyboardApi::wait_for_control_device.
 const MAX_WAIT_DURATION: Duration = Duration::from_millis(100);
 
@@ -189,7 +191,7 @@ impl KeyboardApi {
     }
 
     /// Wait until a key event and return the [`super::Keypress`] associated with it.
-    pub fn wait_for_key_press(&self) -> Result<layout::Keypress, ErrorRoccatVulcanApi> {
+    pub fn wait_for_key_press(&self) -> Result<Keypress, ErrorRoccatVulcanApi> {
         listen_key_press(&self.read).map_err(|err| ErrorRoccatVulcanApi::ReadDeviceError(err))
     }
 
@@ -198,11 +200,33 @@ impl KeyboardApi {
         let buffer_bite = buffer.get_led_buffer();
         let bite_to_write = constants::BITE_PACKET_SIZE + 1;
         for i in 0..(buffer_bite.len() / bite_to_write){
-            let buffer_write = &buffer_bite[(i * ( bite_to_write)).. (i + 1) * bite_to_write];
+            let buffer_write = &buffer_bite[(i * ( bite_to_write))..(i + 1) * bite_to_write];
             self.led.write(buffer_write).map_err(|error| ErrorRoccatVulcanApi::LedDeviceError(error))?;
         }
         Ok(())
     }
+    
+    /// read key press for a time of at least duration and return a vector of the keypress that occured for this duration.
+    pub fn read_key_press(&self, duration: Duration) -> Result<Vec<Keypress>, ErrorRoccatVulcanApi> {
+        if duration.as_millis() > i32::MAX as u128 {
+            return  Err(ErrorRoccatVulcanApi::InvalidInput);
+        }
+        let mut vector_result: Vec<Keypress> = Vec::new();
+        let now = Instant::now();
+        loop {
+            let elapsed = now.elapsed();
+            if duration <= elapsed {
+                break;
+            }
+            let mut buffer: [u8; 5] = [0; 5];
+            self.read.read_timeout(&mut buffer, (duration - elapsed).as_millis() as i32)
+                .map_err(|error| ErrorRoccatVulcanApi::ReadDeviceError(error))?;
+            if buffer[2] > 0 {
+                vector_result.push(Keypress::new_from_buffer(&buffer));
+            }
+        }
+        return Ok(vector_result);
+    }
 }
 
 impl Drop for KeyboardApi {
@@ -213,12 +237,12 @@ impl Drop for KeyboardApi {
 }
 
 fn listen_key_press_raw(device: &hidapi::HidDevice) -> Result<[u8; 5], hidapi::HidError> {
-    let mut buffer: [u8; 5]= [0; 5];
+    let mut buffer: [u8; 5] = [0; 5];
     device.read(&mut buffer)?;
     return Ok(buffer);
 }
 
-fn listen_key_press(device: &hidapi::HidDevice) -> Result<layout::Keypress, hidapi::HidError> {
+fn listen_key_press(device: &hidapi::HidDevice) -> Result<Keypress, hidapi::HidError> {
     let buffer = listen_key_press_raw(device)?;
-    return Ok(layout::Keypress::new_from_buffer(&buffer));
+    return Ok(Keypress::new_from_buffer(&buffer));
 }

src/lib.rs

@@ -4,7 +4,7 @@
 //! # Usage
 //! 
 //! add on your dependencies of Cargo.toml
-//! `roccat_vulcan_api_rs = { version = "0.1.0", git = "https://github.com/ChickenStorm/roccat-vulcan-api-rs" }`.
+//! `roccat-vulcan-api-rs = { version = "0.1.1", git = "https://github.com/ChickenStorm/roccat-vulcan-api-rs", branch = "main" }`.
 //!
 //! The main way to interact with the API is through [`KeyboardApi`].
 //! Note that when the structure is dropped the keyboard will go back to the default rainbow behavior.

src/main.rs

@@ -6,8 +6,12 @@ use roccat_vulcan_api_rs::layout::{
     Layout,
     layout_fr_ch::LayoutFrCh
 };
-use roccat_vulcan_api_rs::color::ColorBuffer;
-use roccat_vulcan_api_rs::color::ColorRgb;
+use roccat_vulcan_api_rs::color::{
+    ColorRgb,
+    ColorBuffer,
+    Color,
+};
+use roccat_vulcan_api_rs::constants;
 use std::{
     thread::sleep,
     time::{Duration, Instant},
@@ -16,37 +20,59 @@ use std::{
 fn main() {
 
     let api = hidapi::HidApi::new().unwrap();
-    for device in api.device_list() {
-        let product_id_list = roccat_vulcan_api_rs::config::get_products_id_default();
-        if product_id_list.contains(&(device.product_id())){
-            println!{"vendor : {}, usage page : {}, usage : {}, intreface : {}", device.vendor_id(), device.usage_page(), device.usage(), device.interface_number()}
-        }
-    }
-    
 
+    let mut key_press_mask: [bool; constants::NUMBER_KEY_LED_BUFFER] = [false; constants::NUMBER_KEY_LED_BUFFER];
     let keyboard = KeyboardApi::get_api_from_hidapi(&api).unwrap();
-    
-    let mut buffer = ColorBuffer::<ColorRgb>::new(ColorRgb::new(0,255,255));
+    let base_color = ColorRgb::new(255,255,255);
+    let press_color = vec![ColorRgb::new(255,0,255), ColorRgb::new(0,0,255), ColorRgb::new(255,0,0), ColorRgb::new(0,255,255)];
+    let mut press_count: usize = 0;
+    let mut buffer = ColorBuffer::<ColorRgb>::new(base_color);
     let layout = LayoutFrCh::new();
-    loop {
-        keyboard.render(&buffer).unwrap();
-        let result = keyboard.wait_for_key_press();
+    keyboard.render(&buffer).unwrap();
+    'mainloop: loop {
+        let result = keyboard.read_key_press(Duration::from_millis(62));
         if let Ok(val) = result {
-            let a = layout.find_key_info_from_press_code(&val.key_code());
-            if let Some(key) = a {
-                let index_key = *key.key_code_light() as usize;
-                if index_key < buffer.buffer().len(){
-                    if !val.is_pressed(){
-                        if let Key::Escape = key.key(){
-                            break;
-                        }
-                        buffer.buffer_mut()[index_key] = ColorRgb::new(0,255,255)
+            for keypress in val {
+                let a = layout.find_key_info_from_press_code(&keypress.key_code());
+                if let Some(key) = a {
+                    if *key.key() == Key::Escape {
+                        break 'mainloop;
                     }
-                    else {
-                        buffer.buffer_mut()[index_key] = ColorRgb::new(0,0,255)
+                    let index_key = *key.key_code_light() as usize;
+                    if index_key < buffer.buffer().len(){
+                        if keypress.is_pressed(){
+                            buffer.buffer_mut()[index_key] = press_color[press_count % press_color.len()];
+                            press_count += 1;
+                        }
+                        key_press_mask[index_key] = keypress.is_pressed();
+                        
                     }
                 }
             }
         }
+        keyboard.render(&buffer).unwrap();
+        for index in 0..buffer.buffer().len() {
+            let el = &mut buffer.buffer_mut()[index];
+            if *el != base_color && !key_press_mask[index] {
+                if el.r() > base_color.r(){
+                    *el.r_mut() -= 5.min(el.r() - base_color.r());
+                }
+                else {
+                    *el.r_mut() += 5.min(base_color.r() - el.r());
+                }
+                if el.g() > base_color.g(){
+                    *el.g_mut() -= 5.min(el.g() - base_color.g());
+                }
+                else {
+                    *el.g_mut() += 5.min(base_color.g() - el.g());
+                }
+                if el.b() > base_color.b(){
+                    *el.b_mut() -= 5.min(el.b() - base_color.b());
+                }
+                else {
+                    *el.b_mut() += 5.min(base_color.b() - el.b());
+                }
+            }
+        }
     }
 }