dev: добавлено определение величины разъезда ME и позиции заготовки у заказчика

params/filter_params.json

@@ -1,4 +1,7 @@
 {
+    "act_pos_decrease": [
+        5.0
+    ],
     "act_vel_min": [
         1900.0
     ],
@@ -9,7 +12,7 @@
         10.0
     ],
     "act_vel_negative": [
-        200.0
+        0.0
     ],
     "rob_vel_thresh": [
         4.0
@@ -24,6 +27,6 @@
         200.0
     ],
     "force_decrease": [
-        200.0
+        80.0
     ]
 }

src/controller/passport_former.py

@@ -30,8 +30,9 @@ class PassportFormer(BasePointPassportFormer):
         В случае ошибки логируется сообщение и возвращается пустой список.
         """
         try:
-            dataframe, events = data
+            dataframe, events, ME_coords = data
             point_quantity = len(events["Squeeze"][0])
+            self._modify_coord_settings(ME_coords)
             data_passport = self._form_graphic_passport(dataframe, events, point_quantity)
             return_data = [data_passport]
         except Exception as e:
@@ -39,6 +40,13 @@ class PassportFormer(BasePointPassportFormer):
             return_data = []
         finally:
             self._mediator.notify(self, return_data)
+    
+    def _modify_coord_settings(self, ME_coords:tuple) -> None:
+        part_pos, open_pos = ME_coords
+        self._settings.operator["distance_l_2"] = open_pos
+        l1 = self._settings.operator["distance_l_1"]
+        self._settings.operator["part_pos"] = [part_pos[i] + l1[i] for i in range (len(part_pos))]
+        
 
     @staticmethod
     def _find_indexes(signal: str, dataframe: pd.DataFrame) -> tuple[np.ndarray, np.ndarray]:
@@ -157,6 +165,7 @@ class PassportFormer(BasePointPassportFormer):
                 events = None
                 key = list(self._settings.operator.keys())[0]
                 point_quantity = len(self._settings.operator[key])
+            self._settings.operator["part_pos"] = self._settings.operator["distance_l_2"]
             passport = self._form_graphic_passport(dataframe, events, point_quantity)
             return passport
         except Exception as e:
@@ -211,7 +220,7 @@ class PassportFormer(BasePointPassportFormer):
         try:
             useful_data = {
                 "thickness": operator_settings["object_thickness"],
-                "L2": operator_settings["distance_l_2"],
+                "part_pos": operator_settings["part_pos"],
                 "force": operator_settings["force_target"]
             }
             return useful_data
@@ -301,22 +310,16 @@ class IdealDataBuilder(BaseIdealDataBuilder):
             data = []
             X1, X2, V1, V2, F = self.calcPhaseGrow(self.Ts['tgrow'] - 0.0001)
             X1, X2, V1, V2 = X1 * 1000, X2 * 1000, V1 * 1000, V2 * 1000
-            data.append({
+            points_num = 5
-                "time": 0,
+            for i in range (points_num+1):
-                "Position FE": X1,
+                data.append({
-                "Position ME": X2,
+                    "time": self.welding_time*i/points_num,
-                "Rotor Speed FE": V1,
+                    "Position FE": X1,
-                "Rotor Speed ME": V2,
+                    "Position ME": X2,
-                "Force": F
+                    "Rotor Speed FE": V1,
-            })
+                    "Rotor Speed ME": V2,
-            data.append({
+                    "Force": F
-                "time": self.welding_time,
+                })
-                "Position FE": X1,
-                "Position ME": X2,
-                "Rotor Speed FE": V1,
-                "Rotor Speed ME": V2,
-                "Force": F
-            })
             return pd.DataFrame(data)
         except Exception as e:
             logger.error(f"get_weldingDF - Ошибка при получении данных для этапа сварки: {e}")

src/gui/plotter.py

@@ -329,22 +329,6 @@ class PlotItemGenerator:
         legend = plot_item.addLegend(offset=(70, 20))
         return plot_item, legend
 
-    def _create_curve_ideal(self,
-                            signal: dict[str, Any],
-                            ideal_data: pd.DataFrame,
-                            start_timestamp: float,
-                            finish_timestamp: float) -> Optional[pg.PlotDataItem]:
-        """
-        Создаёт идеальную кривую для сигнала, если заданы корректные временные рамки.
-        """
-        if start_timestamp is not None and finish_timestamp is not None:
-            return pg.PlotDataItem(
-                x=start_timestamp + ideal_data["time"],
-                y=ideal_data[signal["name"]],
-                pen=signal["pen"]
-            )
-        return None
-
     @staticmethod
     def _create_stage_region(colors:dict,
                              stage: str,
@@ -403,8 +387,8 @@ class PlotItemGenerator:
                 reg_items["ideal"].setdefault(stage, [])
                 reg_items["ideal"][stage].append(region) 
 
-    def _modify_ideal_df(self,
+    @staticmethod
-                        ideal_df: pd.DataFrame,
+    def _modify_ideal_df(ideal_df: pd.DataFrame,
                         ideal_data: dict[str, Any],
                         point_events: dict[str, list[float]]) -> None:
         """
@@ -422,12 +406,12 @@ class PlotItemGenerator:
                 ideal_df = ideal_data[stage].copy()
         return ideal_df
     
-    def _add_signals(self,
+    @staticmethod
-                          plot_item: pg.PlotItem,
+    def _add_signals(plot_item: pg.PlotItem,
-                          dataframe: pd.DataFrame,
+                    dataframe: pd.DataFrame,
-                          real_signals: list[dict[str, Any]],
+                    real_signals: list[dict[str, Any]],
-                          legend: pg.LegendItem, 
+                    legend: pg.LegendItem, 
-                          curve_items: dict) -> None:
+                    curve_items: dict) -> None:
         """
         Добавляет реальные сигналы из dataframe на виджет.
         """
@@ -449,7 +433,10 @@ class PlotItemGenerator:
         elif diapason >=4: plot_item.setDownsampling(ds=10, auto=True, mode='peak')
         else: plot_item.setDownsampling(ds=1, auto=True, mode='peak')
 
-    def _add_force_accuracy_region(self, event:list, force: float, plot_item:pg.PlotItem) -> None:
+    @staticmethod
+    def _add_force_accuracy_region(event:list, 
+                                   force: float, 
+                                   plot_item:pg.PlotItem) -> None:
         modifier = 0.05
         x1 = event[0]
         dx = event[1] - x1
@@ -462,10 +449,12 @@ class PlotItemGenerator:
         rect_item.setPen(pg.mkPen('black', width=0))
         plot_item.addItem(rect_item)
 
-    def _add_workpiece(self, point_data:PointPassport, plot_item: pg.PlotItem) -> None:
+    @staticmethod
-        x1 = point_data.timeframe[0]
+    def _add_workpiece(point_data:PointPassport, 
-        dx = point_data.timeframe[1] - x1
+                       plot_item: pg.PlotItem) -> None:
-        y1 = point_data.useful_data["L2"]*1000
+        x1 = point_data.events["Closing"][0]
+        dx = point_data.events["Relief"][1] - x1
+        y1 = point_data.useful_data["part_pos"]*1000
         dy = point_data.useful_data["thickness"]*1000
 
         rect_item = QGraphicsRectItem(x1, y1, dx, dy)
@@ -500,9 +489,9 @@ class PlotItemGenerator:
             timings.worst_performance = curr_perf
             timings.worst_timeframe = point_data.timeframe
         return timings
- 
+    
-    def _generate_synthetic_events(self, 
+    @staticmethod
-                                   timings:ChannelTimings, 
+    def _generate_synthetic_events(timings:ChannelTimings, 
                                    ideal_data:dict) -> Tuple[ChannelTimings, dict, list[float]]:
         timings.worst_timeframe = point_timeframe = [timings.shift, timings.shift+ ideal_data["Ideal cycle"]]
         point_events = {}
@@ -514,15 +503,15 @@ class PlotItemGenerator:
         timings.shift +=ideal_data["Ideal cycle"]
         return (timings, point_events, point_timeframe)
 
-    def _apply_force_compensation(self, 
+    @staticmethod
-                                  force: float, 
+    def _apply_force_compensation(force: float, 
                                   k_hardness: float,
                                   dataframe:pd.DataFrame, 
                                   point_timeframe:list, 
                                   real_signals:list[dict]) -> pd.DataFrame:
         F_comp = - force/k_hardness
         point_idxs = dataframe[(dataframe["time"] >= point_timeframe[0]) & (dataframe["time"] <= point_timeframe[1])].index
-        dataframe.loc[point_idxs] = self._shift_data("FE", real_signals, dataframe.loc[point_idxs], lambda x: x + F_comp)
+        dataframe.loc[point_idxs] = PlotItemGenerator._shift_data("FE", real_signals, dataframe.loc[point_idxs], lambda x: x + F_comp)
         return dataframe
 
 
@@ -606,4 +595,4 @@ class NavigatorPlot(pg.PlotItem):
         self.addItem(self.ROI_region)
         self.getViewBox().setLimits(xMin=0, xMax=maxBound)
 
-        
+

src/gui/settings_window.py

@@ -241,7 +241,8 @@ class OperatorSettings(settingsWindow):
 class FilterSettings(settingsWindow):
     def __init__(self, path, name, upd_func):
         assosiated_names = {
-             "act_vel_min" : "Minimum for ME speed in Closing mm/sec",
+            "act_pos_decrease": "ME max pos change in Relief, mm",
+            "act_vel_min" : "Minimum for ME speed in Closing mm/sec",
             "act_vel_close" : "Maximum for ME speed in Squeeze mm/sec",
             "act_vel_thresh" : "ME zero speed threshold mm/sec",
             "act_vel_negative" : "ME Relief speed mm/sec",