code cleanup

src/temp.rs

@@ -1,5 +1,4 @@
 use std::ffi::CStr;
-use std::mem::MaybeUninit;
 use std::ptr::{null_mut, slice_from_raw_parts};
 
 use libusb_sys::*;
@@ -56,38 +55,6 @@ pub struct TemperType {
     pub has_humid: bool,
 }
 
-impl Default for TemperType {
-    fn default() -> Self {
-        Self {
-            vendor_id: 0,
-            product_id: 0,
-            product_name: "",
-            check_product_name: true,
-            has_sensor: false,
-            has_humid: false,
-        }
-    }
-}
-
-impl Copy for TemperType {}
-
-#[derive(Clone)]
-pub struct TemperDevice {
-    handle: *mut *mut libusb_device_handle,
-    t: TemperType,
-}
-
-impl Copy for TemperDevice {}
-
-impl Default for TemperDevice {
-    fn default() -> Self {
-        Self {
-            handle: null_mut(),
-            t: TemperType::default(),
-        }
-    }
-}
-
 impl TemperType {
     pub fn decode(&self, answer: &[u8; 100], tempd: &mut [f32; 2], calibration: &[f32; 2]) {
         match self.product_name {
@@ -115,6 +82,54 @@ impl TemperType {
     }
 }
 
+impl Default for TemperType {
+    fn default() -> Self {
+        Self {
+            vendor_id: 0,
+            product_id: 0,
+            product_name: "",
+            check_product_name: true,
+            has_sensor: false,
+            has_humid: false,
+        }
+    }
+}
+
+impl Copy for TemperType {}
+
+impl std::fmt::Display for TemperType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "vendor_id: {}, product_id: {}, product_name: {}",
+            self.vendor_id, self.product_id, self.product_name
+        )
+    }
+}
+
+#[derive(Clone)]
+pub struct TemperDevice {
+    handle: *mut *mut libusb_device_handle,
+    t: TemperType,
+}
+
+impl Copy for TemperDevice {}
+
+impl Default for TemperDevice {
+    fn default() -> Self {
+        Self {
+            handle: null_mut(),
+            t: TemperType::default(),
+        }
+    }
+}
+
+impl std::fmt::Display for TemperDevice {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.t)
+    }
+}
+
 pub fn usb_detach(lvr_winusb: *mut libusb_device_handle, i_interface: i32) {
     let ret;
 
@@ -152,7 +167,8 @@ pub fn find_lvr_winusb(ctx: *mut *mut libusb_context, devices: &mut Vec<TemperDe
     }
 
     while i < cnt && numdev < MAX_DEV {
-        let mut desc = libusb_device_descriptor {
+        let mut desc: libusb_device_descriptor;
+        /*let mut desc = libusb_device_descriptor {
             bLength: 0,
             bDescriptorType: 0,
             bcdUSB: 0,
@@ -167,7 +183,11 @@ pub fn find_lvr_winusb(ctx: *mut *mut libusb_context, devices: &mut Vec<TemperDe
             iProduct: 0,
             iSerialNumber: 0,
             bNumConfigurations: 0,
-        };
+        };*/
+
+        unsafe {
+            desc = std::mem::zeroed();
+        }
 
         let s;
         unsafe {
@@ -266,11 +286,10 @@ pub fn find_lvr_winusb(ctx: *mut *mut libusb_context, devices: &mut Vec<TemperDe
 }
 
 pub fn setup_libusb_access(
-    ctx: &mut MaybeUninit<*mut libusb_context>,
+    ctx: &mut *mut libusb_context,
     devices: &mut Vec<TemperDevice>,
 ) -> isize {
     let numdev;
-    let ctx = ctx.as_mut_ptr();
 
     unsafe {
         {
@@ -391,10 +410,7 @@ pub fn interrupt_read(dev: &mut TemperDevice, data: &mut [u8; 100]) {
     }
 }
 
-pub fn cleanup_usb_devices(
-    ctx: &mut MaybeUninit<*mut libusb_context>,
-    devices: &mut Vec<TemperDevice>,
-) {
+pub fn cleanup_usb_devices(ctx: &mut *mut libusb_context, devices: &mut Vec<TemperDevice>) {
     for device in devices {
         unsafe {
             libusb_release_interface(*device.handle, INTERFACE1);
@@ -405,30 +421,43 @@ pub fn cleanup_usb_devices(
     }
 
     unsafe {
-        libusb_exit(*ctx.as_mut_ptr());
+        libusb_exit(*ctx);
     }
 }
 
-pub fn get_temp_r() -> f32 {
-    let mut ctx = MaybeUninit::<*mut libusb_context>::uninit();
+pub fn get_temp_r() -> String {
+    let mut ctx: libusb_context;
+
+    unsafe {
+        ctx = std::mem::zeroed();
+    }
+    let mut ctx = &mut ctx as *mut _ as *mut libusb_context;
+
     let mut answer: &mut [u8; 100] = &mut [0; 100];
     let mut tempd: &mut [f32; 2] = &mut [0.; 2];
     let calibration: &[f32; 2] = &[1., 0.];
 
+    let mut results: Vec<String> = vec![];
+    let output: String;
+
     let mut devices: Vec<TemperDevice> = vec![];
     setup_libusb_access(&mut ctx, &mut devices);
 
-    unsafe {
-        if DEBUG {
-            println!("{:?}", devices[0].t);
+    for device in devices.iter_mut() {
+        unsafe {
+            if DEBUG {
+                println!("{:?}", device.t);
+            }
         }
-    }
-    control_transfer(&mut devices[0], &UTEMPERATURE);
-    interrupt_read(&mut devices[0], &mut answer);
+        control_transfer(device, &UTEMPERATURE);
+        interrupt_read(device, &mut answer);
 
-    devices[0].t.decode(&answer, &mut tempd, calibration);
+        device.t.decode(&answer, &mut tempd, calibration);
+        results.push(format!("{}", tempd[0]));
+    }
 
     cleanup_usb_devices(&mut ctx, &mut devices);
+    output = results.join(",");
 
-    return tempd[0];
+    return output;
 }