Добавлены адаптивный алгоритмы МНК, ПИД регулятор, примеры

control/adaptive_control.py

@@ -0,0 +1,146 @@
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+
+
+class AdaptiveControlAlgorithm:
+    def __init__(self, obj_model_expr, u1=0, u2=100, id_alg_idx=1):
+        self.obj_model_expr = obj_model_expr  # пользователь задает уравнение объекта
+        # пользователь задает ограничение на управление
+        self.u1 = u1  # ограничение снизу
+        self.u2 = u2  # ограничения сверху
+
+        self.identification_algorithm = id_alg_idx  # индекс алгоритма идентификации
+
+        self.obj_expr = None  # sympy выражение для уравнения объекта
+        self.model_expr = None  # sympy выражение для модели объекта
+
+        self.coefficients = []  # массив коэффициентов "альфа"
+
+        self.perfect_control = None  # sympy выражение для идеального управления
+
+        self.identification_error = None  # error 1, ошибка идентификации
+        self.error_limited_control = None  # error 2, ошибка связанная с накладываемыми на управление ограничениями
+
+    def get_control_action(self):
+        pass
+
+    @property
+    def obj_model_expr(self):
+        return self.obj_model_expr
+
+    @obj_model_expr.setter
+    def obj_model_expr(self, value):
+        self.obj_model_expr = value
+
+    @property
+    def u1(self):
+        return self.u1
+
+    @u1.setter
+    def u1(self, value):
+        self.u1 = value
+
+    @property
+    def u2(self):
+        return self.u2
+
+    @u2.setter
+    def u2(self, value):
+        self.u2 = value
+
+
+def generator(t):
+    # return math.sin(t) + math.cos(6*t) + 1
+    if t < 5:
+        return 5
+    elif 5 <= t < 10:
+        return 50
+    elif 10 <= t < 15:
+        return 20
+    else:
+        return 10 + np.math.sin(5 * t)
+    # y = 5 + 3 * np.math.sin(5 * t)
+    # return y
+
+
+def obj(u, x):
+    y = x + u + np.random.uniform(-1, 1)
+    return y
+
+
+def model(x, u, a):
+    y = x + u + a
+    return y
+
+
+def get_a(x, x_1, u):
+    return x - x_1 - u
+
+
+def test():
+    d_t = 0.1
+    t = 0
+    t_s = 35
+    u1 = -100
+    u2 = 100
+
+    x = []
+    u = []
+    y = []
+    s = []
+    c = []
+
+    idx = 0
+    fedback = 0
+    while t < t_s:
+        set_point = generator(t + d_t)
+
+        if t == 0:
+            # set_point = 0
+            x_t = 0
+            v = 0
+            coef_a = 0
+            # c.append(coef_a)
+        else:
+            # set_point = generator(t)
+            x_t = y[idx - 1] + u[idx - 1] + np.random.uniform(-0.5, 0.5)
+            coef_a = x_t - y[idx - 1] - u[idx - 1]
+            v = set_point - x_t - coef_a
+            if v < u1:
+                v = u1
+            elif v > u2:
+                v = u2
+
+        c.append(coef_a)
+        # y_model = model(x_t, v, a)
+        u.append(v)
+        y.append(x_t)
+        s.append(set_point)
+        x.append(t)
+        t = t + d_t
+        idx += 1
+    print(x)
+    print(u)
+    print(s)
+    print(y)
+    print(c)
+
+    plt.plot(x, u, label="Управление")
+    plt.plot(x, s, label="Уставка")
+    plt.plot(x, y, label="Объект")
+    plt.plot(x, c, label="Коэффициент")
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+
+def adaptive_alg(expr_obj, expr_model, s):
+    pass
+
+
+def main():
+    test()
+
+if __name__ == "__main__":
+    main()

control/q.py

@@ -0,0 +1,151 @@
+import random
+
+import sympy as sp
+from sympy.utilities.autowrap import ufuncify
+
+from identification.simplest_adaptive_algorithm import simplest_adaptive_algorithm
+from model.model_obj_builder import create_model
+
+
+import matplotlib.pyplot as plt
+import math
+
+
+def control(model, set_point):
+    # alpha = 1
+    idx_alpha = 0
+    for u in model.u_names_str:
+        if u == "u0":
+            alpha_str = str(sp.diff(model.model_expr, u))
+            idx_alpha = model.a_names_str.index(alpha_str)
+            # alpha = model.value_a(idx_alpha)
+            break
+    set_point_var = sp.Symbol("sp")
+    v_expr = (set_point_var - model.model_expr + sp.diff(model.model_expr, model.a_names[idx_alpha]) * model.a_names[idx_alpha]) / model.a_names[idx_alpha]
+    # print(v_expr)
+    if model.f is None:
+        model.f = ufuncify([set_point_var] + model.x_names + model.u_names + model.a_names, v_expr)
+    # f = ufuncify([set_point_var] + model.x_names + model.u_names + model.a_names, v_expr)
+    return set_point_var, v_expr
+
+
+def g(t):
+    # if t < 0.3:
+    #     return 0
+    if t < 5:
+        return 80
+    elif 5 <= t < 10:
+        return 40
+    elif 10 <= t < 20:
+        return 30
+    else:
+        return 60
+
+
+def main():
+    model = create_model("a_0+a_1*x(t-1)+a_2*u(t-1)")
+    print(model.model_expr)
+    print(model.obj_expr)
+
+    print(model.x_names)
+    print(model.u_names)
+    print(model.a_names)
+
+    model.initialization(a0=1, a1=1, a2=0.5)
+    print(model.value_x)
+    print(model.value_u)
+    print(model.value_a)
+
+    u = [0]
+    y = [0]
+    a0 = [0.1]
+    a1 = [0.1]
+    a2 = [0.1]
+    t_a = [0]
+    obj = [0]
+    setp = [0.]
+
+    model.value_u = u
+    model.value_x = obj
+
+    t = 0.
+    d_t = 0.25
+    u_t = 0
+    output_object = 0
+    v = 0
+    i = 0
+    model.number_averaged_values = 5
+    while t < 30:
+        t += d_t
+        i += 1
+        set_point = g(t)
+        setp.append(set_point)
+        output_object = -5 + 0.5 * obj[-1] + u[-1]  # + math.sin(10*t) + random.uniform(-3, 3)
+        # model.value_x = [output_object]
+
+        # model.value_x = [output_object]
+        # if t < 6:
+        # y1, new_a = simplest_adaptive_algorithm(model, output_object)
+        if i < 6:
+            y1, new_a = simplest_adaptive_algorithm(model, output_object, smoothing=0, n=i, l=0.9)
+        else:
+            y1, new_a = simplest_adaptive_algorithm(model, output_object, smoothing=1, n=i, l=0.9)
+        model.value_a = new_a
+
+        # y1 = model.func_model(*model.value_x, *model.value_u, *model.value_a)
+
+        model.value_x = [output_object]
+
+        # if t >= 0.2:
+        set_point_var, v_expr = control(model, set_point)
+
+        v = model.f(set_point, *model.value_x, *model.value_u, *model.value_a)
+        # else:
+        #     v = 1
+        # if v < 0:
+        #     v = 0
+        # elif v > 100:
+        #     v = 100
+
+        if v < 0:
+            v = 0
+        elif v > 100:
+            v = 100
+
+        model.value_u = [v]
+        u.append(v)
+
+        a0.append(new_a[0])
+        a1.append(new_a[1])
+        a2.append(new_a[2])
+
+        y.append(y1)
+
+        # u.append(v)
+        obj.append(output_object)
+        t_a.append(t)
+
+    print(v_expr)
+
+    # print(t_a)
+    print(u)
+    print(y)
+    print(obj)
+    print(a0)
+    print(a1)
+    print(a2)
+
+    plt.plot(t_a, y, label="Модель")
+    plt.plot(t_a, u, label="Управление")
+    plt.plot(t_a, obj, label="Объект")
+    plt.plot(t_a, setp, label="Уставка")
+    plt.plot(t_a, a0, label="a0")
+    plt.plot(t_a, a1, label="a1")
+    plt.plot(t_a, a2, label="a2")
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()