src/tests.rs

   1 use std::collections::HashMap;
   2
   3 use wmi::{COMLibrary, Variant, WMIConnection};
   4
   5 use crate::{
   6     a770, asus_aura_usb, corsair_lighting_pro, corsair_vengeance, cpu_temperature,
   7     lian_li_sl_infinity, machine, rgb::RGB, winring0, wrapper_winring0,
   8 };
   9
  10 pub fn tests() {
  11     println!("Running some tests...");
  12
  13     winring0::init();
  14
  15     // test_asus_aura_usb(asus_aura_usb::Motherboard::Asus650e);
  16     // test_corsair_lighting_pro();
  17     test_lianli_sl_infinity();
  18     // list_usb_devices();
  19     // test_roccat();
  20     // test_wmi();
  21     // test_corsair();
  22     // test_a770();
  23     // test_3080ti();
  24     // test_read_temperature_cpu();
  25     // test_read_temperature_a770();
  26     // test_read_temperature_3080();
  27
  28     winring0::deinit();
  29
  30     println!("Press any key to continue...");
  31     std::io::stdin().read_line(&mut String::new()).unwrap();
  32 }
  33
  34 fn test_wmi() {
  35     let com_con = COMLibrary::new().unwrap();
  36     let wmi_con = WMIConnection::new(com_con.into()).unwrap();
  37
  38     //let results: Vec<HashMap<String, Variant>> = wmi_con.raw_query("SELECT * FROM Win32_PnPSignedDriver WHERE Description LIKE '%SMBUS%' OR Description LIKE '%SM BUS%'").unwrap();
  39     //let results: Vec<HashMap<String, Variant>> = wmi_con.raw_query("SELECT * FROM Win32_PnPSignedDriver WHERE Description LIKE 'Intel(R) NF I2C Host Controller'").unwrap();
  40     let results: Vec<HashMap<String, Variant>> = wmi_con
  41         .raw_query("SELECT * FROM Win32_PnPSignedDriver")
  42         .unwrap();
  43     //let results: Vec<HashMap<String, Variant>> = wmi_con.raw_query("SELECT * FROM Win32_PnPAllocatedResource").unwrap();
  44
  45     for os in results {
  46         println!("-------------------");
  47         println!("{:#?}", os);
  48     }
  49 }
  50
  51 fn list_usb_devices() {
  52     let api = hidapi::HidApi::new().unwrap();
  53     for device in api.device_list() {
  54         println!("{:?}", device);
  55         println!("name: {}", device.product_string().unwrap());
  56         println!("interface number: {}", device.interface_number());
  57         println!("page: {}", device.usage_page());
  58         println!("usage: {}", device.usage());
  59         println!("----");
  60     }
  61 }
  62
  63 // fn test_roccat() {
  64 //     let api = hidapi::HidApi::new().unwrap();
  65 //     let roccat_device = roccat::get_device(&api);
  66
  67 //     let manufacturer = roccat_device.get_manufacturer_string().unwrap();
  68 //     dbg!(manufacturer);
  69
  70 //     let product = roccat_device.get_product_string().unwrap();
  71 //     dbg!(product);
  72
  73 //     let serial = roccat_device.get_serial_number_string().unwrap();
  74 //     dbg!(serial);
  75
  76 //     roccat::init(&roccat_device);
  77 //     roccat::set_color(
  78 //         &roccat_device,
  79 //         &RGB {
  80 //             red: 0,
  81 //             green: 255,
  82 //             blue: 40,
  83 //         },
  84 //     );
  85 // }
  86
  87 fn test_asus_aura_usb(motherboard: asus_aura_usb::Motherboard) {
  88     let api = hidapi::HidApi::new().unwrap();
  89
  90     let device = asus_aura_usb::Device::new(&api, motherboard).unwrap();
  91
  92     println!("Firmware: {}", device.get_firmware_string().unwrap());
  93
  94     let configuration = device.get_configuration_table().unwrap();
  95     println!("Configuration:");
  96     for i in 0..60 {
  97         print!("{:02X} ", configuration[i]);
  98         if (i + 1) % 6 == 0 {
  99             println!("");
 100         }
 101     }
 102     println!("Number of addressable header: {}", configuration[0x02]);
 103     println!("Number of leds: {}", configuration[0x1B]);
 104     println!("Number of RGB headers: {}", configuration[0x1D]);
 105
 106     device
 107         .set_color(&RGB {
 108             red: 0,
 109             green: 0,
 110             blue: 255,
 111         })
 112         .unwrap();
 113
 114     device.save_current_color().unwrap();
 115 }
 116
 117 fn test_corsair_lighting_pro() {
 118     let api = hidapi::HidApi::new().unwrap();
 119     let device = corsair_lighting_pro::Device::new(
 120         &api,
 121         &RGB {
 122             red: 0,
 123             green: 255,
 124             blue: 0,
 125         },
 126     );
 127
 128     for i in 0..=255 {
 129         if i % 10 == 0 || i == 255 || i == 0 {
 130             device.set_color(&RGB {
 131                 red: i as u8,
 132                 green: 255u8 - i as u8,
 133                 blue: 0,
 134             });
 135             std::thread::sleep(std::time::Duration::from_millis(200));
 136         }
 137     }
 138 }
 139
 140 fn test_lianli_sl_infinity() {
 141     let api = hidapi::HidApi::new().unwrap();
 142     let device = lian_li_sl_infinity::Device::new(&api);
 143
 144     device.set_color(&RGB {
 145         red: 0,
 146         green: 0,
 147         blue: 255,
 148     });
 149 }
 150
 151 fn test_corsair() {
 152     let corsair_controllers = [
 153         corsair_vengeance::Controller::new(0x19),
 154         corsair_vengeance::Controller::new(0x1B),
 155     ];
 156
 157     for controller in corsair_controllers {
 158         controller.set_color(&RGB {
 159             red: 0,
 160             green: 0,
 161             blue: 255,
 162         });
 163     }
 164 }
 165
 166 fn test_a770() {
 167     // a770::set_rgb(255, 0, 0);
 168     let mut a770 = a770::A770::new().unwrap();
 169     a770.set_color(255, 0, 0).unwrap();
 170 }
 171
 172 fn test_3080ti() {
 173     let machine: &mut dyn machine::Machine = &mut machine::MachineLyssMetal::new().unwrap();
 174
 175     machine.set_color(&RGB {
 176         red: 255,
 177         green: 0,
 178         blue: 0,
 179     });
 180 }
 181
 182 const F17H_M01H_THM_TCON_CUR_TMP: u32 = 0x00059800;
 183 const F17H_TEMP_OFFSET_FLAG: u32 = 0x80000;
 184 const FAMILY_17H_PCI_CONTROL_REGISTER: u32 = 0x60;
 185
 186 fn test_read_temperature_cpu() {
 187     println!("temp cpu: {}", cpu_temperature::read())
 188 }
 189
 190 fn test_read_temperature_a770() {
 191     let jiji: &dyn machine::Machine = &machine::MachineJiji::new().unwrap();
 192     println!("temp gpu: {}", jiji.get_gpu_tmp());
 193 }
 194
 195 fn test_read_temperature_3080() {
 196     nvapi::initialize().expect("Unable to initialize nvapi (Nvidia API)");
 197     // if let Ok(gpus) =  {
 198     //     for gpu in gpus {
 199     //         let thermal = gpu.thermal_settings(None).unwrap()[0];
 200     //         println!("{:?}", thermal.current_temperature.0)
 201     //     }
 202     // }
 203     let gpus = nvapi::PhysicalGpu::enumerate().unwrap();
 204     let gpu = &gpus[0];
 205     let sensor = gpu.thermal_settings(None).unwrap()[0];
 206     println!("{:?}", sensor.current_temperature.0);
 207     nvapi::unload().unwrap();
 208 }