dev: Внедрение склейки этапов по позиции

params/operator_params.json

@@ -44,7 +44,7 @@
         0.0
     ],
     "time_robot_movement": [
-        0.314,
+        0.14,
         0.331
     ],
     "object_thickness": [

params/system_params.json

@@ -12,10 +12,10 @@
         0.25
     ],
     "a_max_2": [
-        10.0
+        50.0
     ],
     "v_max_2": [
-        0.25
+        1.0
     ],
     "mass_1": [
         270.0

src/OptAlgorithm/OptAlgorithm.py

@@ -37,18 +37,40 @@ class OptAlgorithm(AutoConfigClass):
         return max(self.Ts["topen_2_mark"], self.Ts["topen_1_mark"]) - self.time_command
     
     def V1Close(self, t: float):
-        if t < self.Ts["tclose_1_acc"]:
-            return self.a_max_1 * t
-        else:
-            return self.a_max_1 * self.Ts["tclose_1_acc"]
+        if "v1close" in self.__dict__.keys():
+            return self.v1close(t)
+        self.v1close = PhaseCalc(cummulative=False)
+        xwait = lambda t: 0
+        xacc = lambda t: self.a_max_1 * t
+        v1 = (self.Ts["tclose_1_acc"]) * self.a_max_1
+        xspeed = lambda t: v1
+        xdec = lambda t: v1 - self.a_max_1 * t
+        xend = lambda t: 0
+        self.v1close.add_phase(self.Ts["tclose_1_wait"], xwait)
+        self.v1close.add_phase(self.Ts["tclose_1_acc"], xacc)
+        self.v1close.add_phase(self.Ts["tclose_1_speed"], xspeed)
+        self.v1close.add_phase(self.Ts["tclose_1_dec"], xdec)
+        self.v1close.add_phase(self.INF, xend)
+        return self.v1close(t)
 
-    def X1Close(self, t: float):
-        t1 = min(t, self.Ts["tclose_1_acc"])
-        x0 =  self.a_max_1 * t1 * t1 / 2
-        
-        t2 = max(t - self.Ts["tclose_1_acc"], 0)
-        x1 = self.a_max_1 * self.Ts["tclose_1_acc"] * t2
-        return x0 + x1 + self.x1_start
+    def X1Close(self, T: float):
+        if "x1close" in self.__dict__.keys():
+            return self.x1close(T)
+        self.x1close = PhaseCalc(cummulative=True)
+        xwait = lambda t: 0
+        xacc = lambda t: self.a_max_1 * t * t /2
+        v1 = (self.Ts["tclose_1_acc"]) * self.a_max_1
+        xspeed = lambda t: v1 * t
+        xdec = lambda t: v1 * t - self.a_max_1 * t * t /2
+        xstart = lambda t: self.x1_start
+        xend = lambda t: 0
+        self.x1close.add_phase(0, xstart)
+        self.x1close.add_phase(self.Ts["tclose_1_wait"], xwait)
+        self.x1close.add_phase(self.Ts["tclose_1_acc"], xacc)
+        self.x1close.add_phase(self.Ts["tclose_1_speed"], xspeed)
+        self.x1close.add_phase(self.Ts["tclose_1_dec"], xdec)
+        self.x1close.add_phase(self.INF, xend)
+        return self.x1close(T)
         
     def V2Close(self, t: float):
         if t < self.Ts["tclose_2_acc"]:

src/OptAlgorithm/OptTimeCalculator.py

@@ -21,8 +21,12 @@ class OptTimeCalculator(AutoConfigClass):
         v0q = min(sqrt(2 * self.a_max_1 * h1), self.v_max_1)
         v0 = min(v0q, sqrt(1 / (self.k_hardness_1 * self.mass_1)) * self.Ftogrow)
         t1 = v0 / self.a_max_1
-        t2t = max(0, (h1 - (self.a_max_1 * t1 * t1 / 2)) / v0)
-        T1 = t1 + t2t
+        hleft = (h1 - (self.a_max_1 * t1 * t1 / 2))
+        t3 = min((v0q - v0)/ self.a_max_1, sqrt(self.a_max_1 * hleft))
+        v1 = (t1 + t3) * self.a_max_1
+        hleft2 = h1 - (self.a_max_1 * (t1+t3) * (t1+t3) / 2) - v1 * t3 + t3**2 * self.a_max_1 / 2
+        t2t = max(0, hleft2 / v1)
+        T1 = t1 + t2t + t3
 
         t21 = sqrt(h2 / (self.a_max_2))
         t21 = min(self.v_max_2 / self.a_max_2, t21)
@@ -31,11 +35,13 @@ class OptTimeCalculator(AutoConfigClass):
 
         Tclose = max(T1, T2)
 
-        tclose_1_acc, tclose_1_speed = self.calcFirstClose(Tclose, h1)
+        tclose_1_wait, tclose_1_acc, tclose_1_speed, tclose_1_dec = self.calcFirstClose(Tclose, h1)
         tclose_2_acc, tclose_2_speed = self.calcSecondClose(Tclose, h2)
 
         self.allTimes["tclose_1_acc"] = tclose_1_acc
         self.allTimes["tclose_1_speed"] = tclose_1_speed
+        self.allTimes["tclose_1_wait"] = tclose_1_wait
+        self.allTimes["tclose_1_dec"] = tclose_1_dec
 
         self.allTimes["tclose_2_acc"] = tclose_2_acc
         self.allTimes["tclose_2_speed"] = tclose_2_speed
@@ -176,7 +182,7 @@ class OptTimeCalculator(AutoConfigClass):
         t5max = (Tfull - v0 / a) / 2 - t1
         v1 = v0 + a * t1
         S1 = v0 * t1 + a * t1 * t1 / 2 + v1 * t31 - a * t31 * t31 / 2 + v0 * t31
-        S2max = -Sfull + S1
+        S2max = abs(Sfull) + S1
         t5 = min(t5max, (vmax) / a, sqrt(S2max / a))
         t3 = abs(v0) / a + t1 + t5
         t32 = t5
@@ -189,6 +195,9 @@ class OptTimeCalculator(AutoConfigClass):
 
         t2max = (timeleft - Sleft / v3) / (1 + v1 / v3)
         Smovement = -v0 * t1 - a / 2 * t1 ** 2 - v1 * t31 + a / 2 * t31 ** 2
+        if v1 == 0:
+            t2 = 0
+        else:
             t2 = max(0, min(t2max, (abs(maxL) - abs(Smovement)) / v1))
         t4 = max(0, Sleft / v3 + v1 / v3 * t2)
 
@@ -206,14 +215,23 @@ class OptTimeCalculator(AutoConfigClass):
         T = Tfull
         self.allTimes["tmovement"] = T
 
-    def calcFirstClose(self, T: float, s: float) -> tuple[float, float]:
+    def calcFirstClose(self, T: float, s: float) -> tuple[float, float, float, float]:
         v0q = min(sqrt(2 * self.a_max_1 * s), self.v_max_1)
         v0 = min(v0q, sqrt(1 / (self.k_hardness_1 * self.mass_1)) * self.Ftogrow)
-        t1 = T - sqrt(max(0, T ** 2 - 2 * s / self.a_max_1))
-        if t1 > v0/ self.a_max_1 + self.check_eps:
-            raise Exception("""Мы вышли за границы разгона - смыкание FE, вообще не знаю как так получилось""")
-        t2 = max(0, (s - self.a_max_1 * t1 ** 2 / 2) / (self.a_max_1 * t1))
-        return t1, t2
+        t2 = T - sqrt(max(0, T ** 2 - 2 * s / self.a_max_1))
+        if t2 * self.a_max_1 < v0:
+            #we should wait to end with max speed
+            t2 = v0 / self.a_max_1
+            t3 = max(0, (s - self.a_max_1 * t2 ** 2 / 2) / (self.a_max_1 * t2))
+            t1 = T - t2 - t3
+            t4 = 0
+        else:
+            t1 = 0
+            t2 = min(v0q / self.a_max_1, (T + v0/self.a_max_1)/2 - sqrt(max(0, (T + v0/self.a_max_1)**2 - 4 * (v0**2 / (2 * self.a_max_1**2) + s / self.a_max_1))) / 2)
+            v1 = t2 * self.a_max_1
+            t4 = max(0, v1-v0) / self.a_max_1
+            t3 = max(0, T - t2 - t4)
+        return t1, t2, t3, t4
 
     def calcFirstOpen(self, T: float, s: float) -> tuple[float, float]:
         t1 = T / 2 - sqrt(max(0, T ** 2 - 4 * s / self.a_max_1)) / 2

src/controller/passportFormer.py

@@ -82,10 +82,10 @@ class PassportFormer(BasePointPassportFormer):
                     for key, value in self._params[0].items()
                 }
 
-                displacement_me = -0.005
-                displacement_fe = -0.005
+                displacement_me = -0.01
+                displacement_fe = -0.01
 
-                operator_settings["distance_h_end1"] += displacement_fe
+                operator_settings["distance_h_end1"] -= displacement_fe
                 operator_settings["distance_h_end2"] += displacement_me
 
             params_list = [operator_settings, system_settings]

src/gui/plotter.py

@@ -268,8 +268,12 @@ class PlotWidget(BasePlotWidget):
                     self._add_stage_regions(plot_item, point_events, dataframe_headers, reg_items, 75)
 
                 if settings["workpiece"]:
-                    x1 = point_timeframe[0]
-                    dx = point_timeframe[1] - x1
+                    #x1 = point_timeframe[0]
+                    #dx = point_timeframe[1] - x1
+
+                    x1 = point_events["Closing"][0]
+                    dx = point_events["Relief"][1] - x1
+
                     y1 = useful_p_data["position"]*1000
                     dy = useful_p_data["thickness"]*1000