merge pipette leveling

Author: andy

dist/Productions.exe

@@ -5,7 +5,7 @@
 import serial
 import serial.tools.list_ports
 
-ReceiveBuffer = 200
+ReceiveBuffer = 500
 
 
 class SerialDriver:

drivers/serial_driver.py

@@ -7,17 +7,25 @@ class CalibrateMethod(enum.Enum):
     Dichotomy = "dichotomy"
 
 
-SlotLocationCH96 = {"C1-Y": {"Point": Point(223, 203, 318), "compensation": 0.0},
-                    "C3-Y": {"Point": Point(207, 203, 318), "compensation": 0.0},
-                    "A2-Y": {"Point": Point(387, 421, 318), "compensation": 0.0},
-                    "C1-X": {"Point": Point(50, 91, 300), "compensation": 0.0},
-                    "C3-X": {"Point": Point(382, 91, 300), "compensation": 0.0},
-                    "A2-X": {"Point": Point(213, 305, 300), "compensation": 0.0},
-                    "D1-Z": {"Point": Point(51, 99, 318), "compensation": 0.0},
+SlotLocationCH96 = {"C1-Y": {"Point": Point(223, 203, 318), "compensation": {"left_rear": 0, "left_front": 0}},
+                    "C3-Y": {"Point": Point(207, 203, 318), "compensation": {"right_rear": 0, "right_front": 0}},
+                    "A2-Y": {"Point": Point(387, 421, 318), "compensation": {"left_rear": 0, "left_front": 0}},
+                    "C1-X": {"Point": Point(50, 91, 300), "compensation": {"left": 0, "right": 0}},
+                    "C3-X": {"Point": Point(382, 91, 300), "compensation": {"left": 0, "right": 0}},
+                    "A2-X": {"Point": Point(213, 305, 300), "compensation": {"left": 0, "right": 0}},
+                    "D1-Z": {"Point": Point(51, 99, 318),
+                             "compensation": {"rear_left": -0.56664, "rear_right": -0.6685, "front_left": -0.43876,
+                                              "front_right": 0}},
                     # "B2-Z": Point(213, 324, 317),
-                    "D3-Z": {"Point": Point(377, 99, 318), "compensation": 0.0},
-                    "C2-Z": {"Point": Point(214, 210, 318), "compensation": 0.0},
-                    "A2-Z": {"Point": Point(218, 424, 390.5), "compensation": 0.0},
+                    "D3-Z": {"Point": Point(377, 99, 318),
+                             "compensation": {"rear_left": -0.56664, "rear_right": -0.70712, "front_left": -0.41324,
+                                              "front_right": 0}},
+                    "C2-Z": {"Point": Point(214, 210, 318),
+                             "compensation": {"rear_left": -0.60076, "rear_right": -0.679, "front_left": -0.32926,
+                                              "front_right": 0}},
+                    "A2-Z": {"Point": Point(218, 424, 390.5),
+                             "compensation": {"rear_left": -0.57076, "rear_right": -0.694, "front_left": -0.40876,
+                                              "front_right": 0}},
                     "UninstallPos": {"Point": Point(223, 203, 500)}
                     }
 
@@ -46,4 +54,3 @@ class CalibrateMethod(enum.Enum):
                    "Y-A2-Right": {"Point": Point(335.94, 412.22, 299.16), "compensation": -0.03},
                    "UninstallPos": {"Point": Point(223, 203, 500), "compensation": 0}
                    }
-

ot3_testing/test_config/pipette_leveling_config.py

@@ -366,22 +366,22 @@ async def run_96ch_test(self, flex_name: str, project_path=None):
         csv_title.append(time_str + flex_name)
         print("=" * 5 + "Test Result" + "=" * 5 + "\n")
         for key, value in test_result.items():
+            result = []  # 本次写入结果
             distance_list = list(value.values())
             # differences
-            if len(distance_list) <= 2:
-                difference = distance_list[0] - distance_list[1]
-            else:
-                difference = max(distance_list) - min(distance_list)
-            compensation = self.slot_location[key]["compensation"]
+            difference = round(abs(max(distance_list) - min(distance_list)), 3)
+            compensation: dict = self.slot_location[key]["compensation"]
             if ApplyCompensationFlag:
-                print(f"apply offset {compensation} to {difference}, difference -> {difference - compensation}")
-                difference = abs(difference - compensation)
-                # max_value_idx = self.get_max_index(distance_list)
-                # distance_list[max_value_idx] = distance_list[max_value_idx] - compensation
-            print(f"{key} --> {value} (mm) --> difference: {round(difference, 3)}(mm)")
+                compensation_idx = 0
+                for compensation_key, compensation_value in compensation.items():
+                    print(f"apply offset {compensation_key} -> {compensation_value} to {distance_list[compensation_idx]}")
+                    result.append(compensation_value + distance_list[compensation_idx])
+                    compensation_idx += 1
+                difference = round((abs(max(result) - min(result))), 3)
+            print(f"{key} --> {value} (mm) \ndifference: {difference}(mm)\n")
             for item_key, item_value in value.items():
                 csv_title.append(key + " " + item_key)
-            for values in distance_list:
+            for values in result:
                 csv_list.append(values)
             if 'Z' not in key:
                 csv_title.append(key + "-Result")
@@ -413,5 +413,5 @@ async def run_96ch_test(self, flex_name: str, project_path=None):
 
 if __name__ == '__main__':
     import asyncio
-    pipette_leveling = PipetteLeveling(SlotLocationCH96, ChannelDefinitionCH96, robot_ip="192.168.6.62")
-    asyncio.run(pipette_leveling.run_96ch_test(""))
+    pipette_leveling = PipetteLeveling(SlotLocationCH96, ChannelDefinitionCH96, )
+    asyncio.run(pipette_leveling.run_96ch_test("FLXA1020240513001"))