Untitled

mail@pastecode.io avatar
unknown
python
2 years ago
31 kB
9
Indexable
Never
import tkinter as tk
from tkinter import scrolledtext
from tkinter import filedialog
from tkinter import messagebox
import os, sys

import matplotlib

matplotlib.use("TkAgg")
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

import time

import math


def sind(x):
    return math.sin(x * math.pi / 180)


def cosd(x):
    return math.cos(x * math.pi / 180)


def EqvualsZero(date):
    for i in range(0, len(date)):
        if not (date[i] <= 0.000001):
            return False
    return True


def addTointerp(x1, x2, y1, y2, my_x):
    k = (y1 - y2) / (x1 - x2)
    b = (x1 * y2 - y1 * x2) / (x1 - x2)
    return k * my_x + b


def interp1(X, Y, my_x):
    num = len(X)
    if num != len(Y):
        return 0.0

    r = -1

    for i in range(0, num + 1):
        if my_x > X[i]:
            r = i
        else:
            break

    if r < 0:
        return X[0]
    if r >= num - 1:
        return X[num - 1]
    return addTointerp(X[r], X[r + 1], Y[r], Y[r + 1], my_x)


def interp2(X, Y, Z, my_x, my_y):
    rows = len(X)
    columns = len(X[0])
    rowsY = len(Y)
    columnsY = len(Y[0])
    rowsZ = len(Z)
    columnsZ = len(Z[0])

    if not (rows == rowsY and rows == rowsZ and columns == columnsY and columns == columnsZ):
        return 0.0

    rx = -1
    ry = -1
    for x in range(0, columns):
        if (my_x > X[0][x]):
            rx = x
        else:
            break

    for y in range(0, rows):
        if (my_y > Y[y][0]):
            ry = y
        else:
            break

    if rx < 0 and ry < 0:
        return Z[0][0]
    if rx < 0 and ry >= rows - 1:
        return Z[rows - 1][0]
    if rx >= columns - 1 and ry < 0:
        return Z[0][columns - 1]
    if rx >= columns - 1 and ry >= rows - 1:
        return Z[rows - 1][columns - 1]

    if rx < 0 or rx >= columns - 1:
        xx = 0 if (rx < 0) else columns - 1
        Y1ud = Y[ry][0]
        Y2ud = Y[ry + 1][0]
        return addTointerp(Y1ud, Y2ud, Z[ry][xx], Z[ry + 1][xx], my_y)

    if (ry < 0 or ry >= rows - 1):
        yy = 0 if (ry < 0) else rows - 1
        X1rl = X[0][rx]
        X2rl = X[0][rx + 1]
        return addTointerp(X1rl, X2rl, Z[yy][rx], Z[yy][rx + 1], my_x)

    #  (X,Y)
    #  (ry, rx ) --- (ry+, rx )
    #     |             |
    #     |             |
    #     |             |
    #  (ry, rx+) --- (ry+, rx+)

    X1 = X[0][rx]
    X2 = X[0][rx + 1]
    Y1 = Y[ry][0]
    Y2 = Y[ry + 1][0]

    tempZ1 = addTointerp(X1, X2, Z[ry][rx], Z[ry][rx + 1], my_x)
    tempZ2 = addTointerp(X1, X2, Z[ry + 1][rx], Z[ry + 1][rx + 1], my_x)

    return addTointerp(Y1, Y2, tempZ1, tempZ2, my_y)


class application:

    def __init__(self):
        # .txt
        self.ImStr = ""
        self.nStr = ""
        self.UmStr = ""
        self.QuStr = ""

        # Загрузка оптимальных зависимостей:> Um=f(Im,n); Qu=f(Im,n) в узловых точках
        self.Count_Imx = 0
        self.Count_nx = 0
        self.tempImx = []
        self.tempnx = []
        self.Imx = None  # [A] амплитуда фазного тока(модуль вектора фазного тока)
        self.nx = None  # [об/мин] амплитуда фазного тока (модуль вектора фазного тока)
        self.Umx = None  # [В] амплитуда фазного напряжения (модуль вектора фазного напряжения)
        self.Qux = None  # [рад] оптим. угол сдв. фазы напр. в обм.А статора относит. вект. МДС

        # ПАРАМЕТРЫ И ХАРАКТЕРИСТИКИ ТЯГОВОГО ДВИГАТЕЛЯ ЭЛЕКТРОМОБИЛЯ

        # Параметры вентильного двигателя:
        self.pp = 2  # [пары полюсов]
        self.F = 0.1040  # [Вб] магнитный поток ротора
        self.Ld = 0.00023  # [Гн] индуктивность фазы по оси d
        self.Lq = 0.00056  # [Гн] индуктивность фазы по оси q
        self.R = 0.0079  # [Ом] сопротивление фазы

        # Ограничения тяговой бортовой сети
        self.Umax = 190  # [B] максимальное значение напряжения фазы(Umax= Udc / sqrt(3))
        self.Imax = 226.3  # [А] максимальное значение тока фазы
        self.nmax = 8800  # [об/мин] максимальное значение частоты вращения ротора
        self.Mvd_max = 80  # [Нм] максимальный момент вращения ВД(!Для модели электромобиля!)

        # ЗАДАЮЩИЕ И ВОЗМУЩАЮЩИЕ ВОЗДЕЙСТВИЯ
        # ЕВРОПЕЙСКИЙ ЕЗДОВОЙ ЦИКЛ (Задающее воздействие)

        # Время моделирования [c]
        self.tA = [
            0, 6, 11, 15, 23, 25, 28, 44, 49, 54,  # I этап городского цикла
            56, 61, 85, 93, 96, 112, 117, 122, 124, 133,
            135, 143, 155, 163, 176, 178, 185, 188, 195,
            201, 206, 210, 218, 220, 223, 239, 244, 249,  # II этап городского цикла
            251, 256, 280, 288, 291, 307, 312, 317, 319, 328,
            330, 338, 350, 358, 371, 373, 380, 383, 390,
            396, 401, 405, 413, 415, 418, 434, 439, 444,  # III этап городского цикла
            446, 451, 475, 483, 486, 502, 507, 512, 514, 523,
            525, 533, 545, 553, 566, 568, 575, 578, 585,
            591, 596, 600, 608, 610, 613, 629, 634, 639,  # IV этап городского цикла
            641, 646, 670, 678, 681, 697, 702, 707, 709, 718,
            720, 728, 740, 748, 761, 763, 770, 773, 780,
            786, 798, 803, 805, 814, 816, 824, 826, 839,  # загородный цикл
            889, 903, 970, 984, 1034, 1070, 1098, 1118, 1127, 1164, 1180
        ]
        # Скорость автомобиля [км/ч]
        self.Va_kmph = [
            0, 0, 0, 15, 15, 10, 0, 0, 0, 15,  # I этап городского цикла
            15, 32, 32, 10, 0, 0, 0, 15, 15, 35,
            35, 50, 50, 35, 35, 35, 10, 0, 0,
            0, 0, 15, 15, 10, 0, 0, 0, 15,  # II этап городского цикла
            15, 32, 32, 10, 0, 0, 0, 15, 15, 35,
            35, 50, 50, 35, 35, 35, 10, 0, 0,
            0, 0, 15, 15, 10, 0, 0, 0, 15,  # III этап городского цикла
            15, 32, 32, 10, 0, 0, 0, 15, 15, 35,
            35, 50, 50, 35, 35, 35, 10, 0, 0,
            0, 0, 15, 15, 10, 0, 0, 0, 15,  # IV этап городского цикла
            15, 32, 32, 10, 0, 0, 0, 15, 15, 35,
            35, 50, 50, 35, 35, 35, 10, 0, 0,
            0, 0, 15, 15, 35, 35, 50, 50, 70,  # загородный цикл
            70, 50, 50, 70, 70, 100, 100, 120, 120, 0, 0
        ]

        self.Va_mps = None  # Скорость автомобиля   [м/с]
        self.V = []  # [км/ч] скорость автомобиля

        # ВОЗМУЩЕНИЯ, действующие на ГСУ
        self.tP = [0, 210, 211, 350, 351, 508, 509, 680, 681, 1180]  # [c] время моделирования
        self.aP = [0, 0, 6, 4, 0, 0, -5, -2, 0, 0]  # [грд] уклон дороги

        self.dt = 0.5  # [с] период дискретизации
        self.t = []  # [c] время моделирования
        self.V_zd = []  # [м/с] заданная скорость автомобиля корость автомобиля
        self.a_pt = []  # [грд] уклон дороги

        # ПАРАМЕТРЫ ЭЛЕКТРОМОБИЛЯ

        self.ma = 1500  # [кг] масса автомобиля(Снар.авт+водит.+пассаж+груз)
        self.Rkol = 0.263  # [м] статический радиус колеса(для шины 175/70R13)
        # [м] радиус качения ведущего колеса
        self.Cw = 0.35  # коэффициент аэродинамического сопротивления
        self.Sa = 3.8  # [м2] площадь поперечного сечения автомобиля
        self.fkach = 0.013  # коэффициент сопротивления качению
        self.po = 1.209  # [кг/м3] плотность воздуха
        self.ge = 9.81  # [м/с2] ускорение свободного падения

        self.ue = 7.605  # Передат.отнош.трансм.от ротора ВД к вед.колесам

        self.Mtrm_max = 500  # [Нм] максимальный момент торможения(гидравлическая система торможения)
        self.Mf = 0.02  # [Нм] привед. момент сопрот., обусл.силами трения в элем.трансмис.

        self.Bvm = 1.02  # коэфф.,учитывающий кинет.энергию вращ.масс автомобиля
        self.Jrvd = 0.0059  # [кг*м2] момент инерции ротора вентильного двигателя

        # --- Коэффициенты ПИД-регулятора скорости автомобиля ---
        self.KRp = 200  # пропорциональной составляющей
        self.KRd = 0  # дифференциальной составляющей
        self.KRi = 8  # интегральной составляющей

        # Данные для вывода графиков
        self.Mvr = []  # [Нм] момент вращения, приложенный к вед. колёсам
        self.Mvd = []  # [Нм] электромагнитный момент ВЭД

        self.Mc = []  # [Нм] момент сил сопротивления
        self.Mtrm = []  # [Нм] момент торможения (гидравлическая система торможения)

        self.Um = []  # [В] амплитуда фазного напряжения cтатора ВЭД
        self.Qu = []  # [рад] оптим. угол сдв. фазы напр. cтатора ВЭД
        self.Im = []  # [A] ток статора ВЭД

        self.wk_zd = []  # [рад/ с] заданная скор.вращен.вед.колес
        self.wk = []  # [рад/с] скорость вращен.вед.колес
        self.ewk = []  # [рад/с] ошибка регулирования по скорости

        # Визуальные компоненты
        self.file_list = ['Im.txt', 'n.txt', 'Qu.txt', 'Um.txt']
        self.filename_to_filetext = {'Im.txt': self.ImStr, 'n.txt': self.nStr, 'Qu.txt': self.QuStr,
                                     'Um.txt': self.UmStr}
        self.plot_list = [1, 2, 3, 4, 5, 6]

        self.main = tk.Tk()
        self.main.title("Расчёт параметров электромобиля")
        self.main.geometry("800x400")

        self.plot_container = []

        self.menu_file_list_var = tk.StringVar(self.main)
        self.menu_file_list_var.set(self.file_list[0])
        self.menu_file_list_var.trace("w", self.menu_file_callback)
        self.menu_file_list = tk.OptionMenu(self.main, self.menu_file_list_var, *self.file_list)
        self.menu_file_list.grid(row=1, column=0, sticky=tk.E + tk.W, padx=2, pady=4)

        self.is_calculated = False
        self.menu_plot_list_var = tk.IntVar(self.main)
        self.menu_plot_list_var.set(self.plot_list[0])
        self.menu_plot_list_var.trace("w", self.menu_plot_callback)
        self.menu_plot_list = tk.OptionMenu(self.main, self.menu_plot_list_var, *self.plot_list)
        self.menu_plot_list.grid(row=1, column=2, sticky=tk.E + tk.W, padx=2, pady=4)

        self.lbl_file_list = tk.Label(master=self.main, text="Список введённых файлов")
        self.lbl_file_list.grid(row=0, column=0)

        self.lbl_plot_list = tk.Label(master=self.main, text="Список рассчётных графиков")
        self.lbl_plot_list.grid(row=0, column=2)

        self.btn_clear = tk.Button(master=self.main, text="Очистить", command=self.clear_fields)
        self.btn_clear.grid(row=1, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_load_Im = tk.Button(master=self.main, text="Загрузить Im", command=self.btn_load_Im_Click)
        self.btn_load_Im.grid(row=2, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_load_n = tk.Button(master=self.main, text="Загрузить n", command=self.btn_load_n_Click)
        self.btn_load_n.grid(row=3, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_load_xQu = tk.Button(master=self.main, text="Загрузить Qu", command=self.btn_load_xQu_Click)
        self.btn_load_xQu.grid(row=4, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_load_xUm = tk.Button(master=self.main, text="Загрузить Um", command=self.btn_load_xUm_Click)
        self.btn_load_xUm.grid(row=5, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_calculate = tk.Button(master=self.main, text="Расчёт", command=self.btn_calculate_Click)
        self.btn_calculate.grid(row=6, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.btn_exit = tk.Button(master=self.main, text="Выход", command=self.close)
        self.btn_exit.grid(row=7, column=1, sticky=tk.E + tk.W, padx=4, pady=4)

        self.show_file = scrolledtext.ScrolledText(
            master=self.main,
            width=30,
            height=19
        )
        self.show_file.grid(row=2, column=0, rowspan=6)

    def start(self):
        self.main.mainloop()

    def close(self):
        exit()

    def menu_file_callback(self, *args):
        if self.filename_to_filetext[self.menu_file_list_var.get()] == '':
            self.show_file.delete(1.0, tk.END)
            return

        self.show_file.delete(1.0, tk.END)
        self.show_file.insert(tk.INSERT, self.filename_to_filetext[self.menu_file_list_var.get()])

    def clear_fields(self):
        self.ImStr = ""
        self.nStr = ""
        self.UmStr = ""
        self.QuStr = ""
        self.tempImx = []
        self.tempnx = []
        self.Qux = []
        self.Umx = []
        self.Count_Imx = 0
        self.Count_nx = 0
        self.filename_to_filetext = {'Im.txt': self.ImStr, 'n.txt': self.nStr, 'Qu.txt': self.QuStr,
                                     'Um.txt': self.UmStr}
        self.filename_to_filetext['Im.txt'] = ""
        self.filename_to_filetext['n.txt'] = ""
        self.filename_to_filetext['Qu.txt'] = ""
        self.filename_to_filetext['Um.txt'] = ""
        self.menu_file_list_var.set(self.file_list[0])
        self.menu_file_list_var.set(self.file_list[1])
        self.menu_file_list_var.set(self.file_list[2])
        self.menu_file_list_var.set(self.file_list[3])

        self.V = []
        self.V_zd = []
        self.a_pt = []
        self.Mvr = []
        self.Mvd = []

        self.Mc = []
        self.Mtrm = []

        self.Um = []
        self.Qu = []
        self.Im = []

        self.wk_zd = []
        self.wk = []
        self.ewk = []
        self.plot_container = []
        self.canvas.get_tk_widget().grid_forget()
        self.is_calculated = False

    def menu_plot_callback(self, *args):
        if not self.is_calculated:
            return

        now_showing = self.menu_plot_list_var.get() - 1

        for i in range(6):
            self.plot_container[i].set_visible(False)

        self.plot_container[now_showing].set_visible(True)

        self.canvas.get_tk_widget().grid_forget()

        self.canvas = FigureCanvasTkAgg(self.figure, self.main)
        self.canvas.get_tk_widget().grid(row=2, column=2, rowspan=6, padx=4, pady=4)

    def btn_load_Im_Click(self):
        inp_file_name = str(filedialog.askopenfilename())

        if inp_file_name == '()' or inp_file_name == '':
            messagebox.showwarning("Warning", "No file chosen")
            return
        else:
            inp = open(inp_file_name, 'r')

            self.ImStr = inp.read()
            inp.close()

            self.tempImx = list(map(float, self.ImStr.strip().split(' ')))

            self.Count_Imx = len(self.tempImx)

            self.filename_to_filetext['Im.txt'] = '\n'.join(self.ImStr.split(' '))  # ________
            self.menu_file_list_var.set(self.file_list[0])

    def btn_load_n_Click(self):
        inp_file_name = str(filedialog.askopenfilename())

        if inp_file_name == '()' or inp_file_name == '':
            messagebox.showwarning("Warning", "No file chosen")
            return
        else:
            inp = open(inp_file_name, 'r')

            self.nStr = inp.read()

            inp.close()

            self.tempnx = list(map(float, self.nStr.strip().split(' ')))

            self.Count_nx = len(self.tempnx)

            self.filename_to_filetext['n.txt'] = '\n'.join(self.nStr.split(' '))  # ______
            self.menu_file_list_var.set(self.file_list[1])

    def btn_load_xQu_Click(self):

        # добавил простенькую проверку, на загрузку двух предыдущих файлов, раньше если Qu загружалась до n и Im прога крашилась
        if self.ImStr == "" or self.nStr == "":
            messagebox.showwarning("Warning!", "Upload n and Im first!")
            return

        inp_file_name = str(filedialog.askopenfilename())

        if inp_file_name == '()' or inp_file_name == '':
            messagebox.showwarning("Warning", "No file chosen")
            return
        else:
            inp = open(inp_file_name, 'r')

            self.QuStr = inp.read()

            inp.close()

            temp = self.QuStr.strip().split('\n')
            Count = len(temp)

            self.Qux = [[0 for _ in range(self.Count_Imx)] for _ in range(self.Count_nx)]

            for i in range(0, Count):
                self.Qux[i % self.Count_nx][i // self.Count_nx] = float(temp[i])
            self.filename_to_filetext['Qu.txt'] = self.QuStr  # _____
            self.menu_file_list_var.set(self.file_list[2])

    def btn_load_xUm_Click(self):
        # добавил простенькую проверку, на загрузку двух предыдущих файлов, раньше если Um загружалась до n и Im программа крашилась
        if self.ImStr == "" or self.nStr == "":
            messagebox.showwarning("Warning!", "Upload n and Im first!")
            return

        inp_file_name = str(filedialog.askopenfilename())

        if inp_file_name == '()' or inp_file_name == '':
            messagebox.showwarning("Warning", "No file chosen")
            return
        else:
            inp = open(inp_file_name, 'r')

            self.UmStr = inp.read()

            inp.close()

            temp = self.UmStr.strip().split('\n')
            Count = len(temp)

            self.Umx = [[0 for _ in range(self.Count_Imx)] for _ in range(self.Count_nx)]

            for i in range(0, Count):
                self.Umx[i % self.Count_nx][i // self.Count_nx] = float(temp[i])

            self.filename_to_filetext['Um.txt'] = self.UmStr  # _____
            self.menu_file_list_var.set(self.file_list[3])

    def btn_calculate_Click(self):
        # Not enought date
        if not (self.ImStr != "" and self.nStr != "" and self.UmStr != "" and self.QuStr != ""):
            return
        # print("count_nx, Imx", self.Count_nx, self.Count_Imx)

        self.Imx = [[0 for _ in range(self.Count_Imx)] for _ in range(self.Count_nx)]  # [45, 21]
        self.nx = [[0 for _ in range(self.Count_Imx)] for _ in range(self.Count_nx)]  # [45, 21]
        for i in range(self.Count_nx):
            for j in range(self.Count_Imx):
                self.Imx[i][j] = self.tempImx[j]
                self.nx[i][j] = self.tempnx[i]

        # print('Imx', self.Imx)
        # print('nx', self.nx)

        self.Va_mps = []  # CHEKED
        for i in range(len(self.Va_kmph)):
            self.Va_mps.append(self.Va_kmph[i] * 1000 / 3600)
        # print('Va_mps', self.Va_mps)

        t_count = int((self.tA[len(self.tA) - 1] - self.tA[0]) / self.dt) + 1

        self.t = []  # CHEKED
        for i in range(t_count):
            self.t.append(self.dt * i)
        # print('t', self.t)

        self.V_zd = []  # cheked
        self.a_pt = []  # cheked
        for i in range(t_count):
            self.V_zd.append(interp1(self.tA, self.Va_mps, self.t[i]))
            self.a_pt.append(interp1(self.tP, self.aP, self.t[i]))

        # print('V_zd', self.V_zd)
        # print('a_pt', self.a_pt)

        # МОДЕЛИРОВАНИЕ ДВИЖЕНИЯ ЭЛЕКТРОМОБИЛЯ
        self.wk_zd = []  # [рад/ с] заданная скор.вращен.вед.колес
        self.wk = []  # [рад/с] скорость вращен.вед.колес
        self.ewk = []  # [рад/с] ошибка регулирования по скорости
        iewk = 0.0  # начальная накопленная ошибка
        self.Mvr = []  # [Нм] момент вращения, приложенный к вед. колёсам
        self.Mc = []  # [Нм] момент сил сопротивления
        self.Mvd = []  # [Нм] электромагнитный момент ВЭД
        self.Mtrm = []  # [Нм] момент торможения (гидравлическая система торможения)
        self.Um = []  # [В] амплитуда фазного напряжения cтатора ВЭД
        self.Qu = []  # [рад] оптим. угол сдв. фазы напр. cтатора ВЭД
        self.Im = []  # [A] ток статора ВЭД

        for i in range(t_count):
            self.wk_zd.append(self.V_zd[i] / self.Rkol)
            self.wk.append(0)
            self.ewk.append(0)

            self.Mvr.append(0)
            self.Mc.append(0)
            self.Mvd.append(0)
            self.Mtrm.append(0)

            self.Um.append(0)
            self.Qu.append(0.5 * math.pi)
            self.Im.append(0)

        self.wk[0] = self.wk_zd[0]
        # print('wk_zd', self.wk_zd)
        # print('wk', self.wk)

        for k in range(1, t_count - 1):

            # Ошибка регулирования по скорости автомобиля
            self.ewk[k] = self.wk_zd[k] - self.wk[k]  # [рад / с] ошибка регулирования по скорости
            dewk = self.ewk[k] - self.ewk[k - 1]  # [рад / с] приращение ошибки за один шаг дискретизации
            iewk += self.ewk[k]  # [рад / с] накопленная ошибка за предыдущие шаги

            if (self.wk[k]) < 0.00001:  # поскольку в модели автомобиля не предусмотрено wk<0
                iewk = 0

            # ПИД-регулятор скорости автомобиля
            self.Mvr[k] = self.KRp * self.ewk[
                k] + self.KRd * dewk + self.KRi * iewk  # [Нм] требуемый момент вращения, приложенный к вед.колёсам

            # Момент сил сопротивления, приложенный к ведущим колесам
            if self.wk[k] < 0.00001:
                self.Mc[k] = self.ma * self.ge * sind(self.a_pt[k]) * self.Rkol  # [Нм] момент сопротивления уклона пути
            else:
                FL = 0.5 * self.po * self.Cw * self.Sa * (self.wk[k] * self.Rkol) * (
                            self.wk[k] * self.Rkol)  # [Н] аэродинамическое сопротивление
                FK = self.ma * self.fkach * self.ge * cosd(self.a_pt[k])  # [Н] сопротивление качению
                FA = self.ma * self.ge * sind(self.a_pt[k])  # [Н] сопротивление уклона пути
                self.Mc[k] = (FL + FK + FA) * self.Rkol  # [Нм] момент сил сопротивления

            Msu = self.Mvr[k] - self.Mc[k]  # [Нм] требуемый момент вращения / торможения от СУ электромобиля

            if Msu > 0.00001:
                Imz = (Msu / self.ue) * self.Imax / self.Mvd_max  # [А] требуемый ток статора

                if Imz > self.Imax:
                    Imz = self.Imax

                wvd = self.wk[k] * self.ue  # [рад / с] скорость вращения ротора вент. двиг.
                nvd = wvd * 60 / (2 * math.pi)  # [об / мин] частота вращения ротора вентильного двигателя

                if (nvd > self.nmax):
                    nvd = self.nmax

                self.Um[k] = interp2(self.Imx, self.nx, self.Umx, Imz, nvd)
                self.Qu[k] = interp2(self.Imx, self.nx, self.Qux, Imz, nvd)

                ud = self.Um[k] * math.cos(self.Qu[k])  # [В] проекции вектора напряжения на оси вращ.с.к.
                uq = self.Um[k] * math.sin(self.Qu[k])

                we = self.pp * wvd  # [эл.рад / с] скорость вращения поля
                a = 1 / (self.R * self.R + self.Lq * self.Ld * we * we)

                id = a * (
                            self.R * ud + self.Lq * we * uq - self.Lq * self.F * we * we)  # [А] проекции вектора тока статора на оси вращ.с.к.
                iq = a * (self.R * uq - self.Ld * we * ud - self.R * self.F * we)

                self.Im[k] = math.sqrt(id * id + iq * iq)  # [A] амплитуда фазного тока
                if self.Im[k] > self.Imax:
                    self.Im[k] = self.Imax  # [A] ограничение величины фазного тока

                self.Mvd[k] = 1.5 * self.pp * (
                            self.F + id * (self.Ld - self.Lq)) * iq  # [Нм] электромагнитный момент ВЭД

                # --- Момент торможения (гидравлическая система торможения)

            if Msu < 0.00001 and self.wk[k] > 0.00001:  # [Нм] момент торможения
                self.Mtrm[k] = Msu

                if self.Mtrm[k] > self.Mtrm_max:
                    self.Mtrm[k] = self.Mtrm_max

                # --- Момент сил, приложенных к ведущим колёсам
            SM = 0.0
            if EqvualsZero(self.wk):
                SM = self.ue * self.Mvd[k] - self.Mc[k]  # [Нм] сумма моментов, прилож. к оси вр.вед.колёс
            else:
                SM = self.ue * self.Mvd[k] - self.Mc[k] - self.Mf + self.Mtrm[k]

            Jpr = self.Jrvd * self.ue * self.ue + self.Bvm * self.ma * self.Rkol * self.Rkol  # [кг * м2] момент инерции, прив.к оси вращ.вед.кол.

            self.wk[k + 1] = self.wk[k] + self.dt * SM / Jpr  # [рад / с]

            if self.wk[k + 1] < - 0.00001:
                self.wk[k + 1] = 0

        self.V = []
        for i in range(0, len(self.wk)):
            self.V.append(self.wk[i] * self.Rkol * 3.6)  # [км / ч] скорость автомобиля

        self.figure = Figure(figsize=(4, 3), dpi=100)

        plot1 = self.figure.add_subplot()
        # print('ewk', self.ewk)

        # PLOT 1 работает
        plot1.plot(self.t, self.V, color="blue")  # работает
        plot1.plot(self.t, list(map(lambda x: x * 3.6, self.V_zd)), color="red")  # работает
        plot1.set_xlabel('t, [c]')
        plot1.set_ylabel('Vzd, V, [km/h]')
        self.plot_container.append(plot1)

        # PLOT 2 работает
        plot2 = self.figure.add_subplot()
        plot2.plot(self.t, self.a_pt, color="blue")  # работает
        plot2.set_xlabel('t, [c]')
        plot2.set_ylabel('apt, [deg]')
        self.plot_container.append(plot2)

        # PLOT 3 работает
        plot3 = self.figure.add_subplot()
        plot3.plot(self.t, self.Mvr, color="blue")
        plot3.plot(self.t, list(map(lambda x: x * self.ue, self.Mvd)), color="red")
        plot3.plot(self.t, list(map(lambda x: -x, self.Mc)), color="pink")
        plot3.plot(self.t, self.Mtrm, color="green")
        plot3.set_xlabel('t, [c]')
        plot3.set_ylabel('Mvr, ue*Mvd, Mc, Mtrm, [N*m]')
        self.plot_container.append(plot3)

        # plot 4 работает
        plot4 = self.figure.add_subplot()
        plot4.plot(self.t, self.Um, color="green")
        plot4.set_xlabel('t, [c]')
        plot4.set_ylabel('Um, [V]')
        self.plot_container.append(plot4)

        # plot 5 работает
        plot5 = self.figure.add_subplot()
        plot5.plot(self.t, list(map(lambda x: x / math.pi, self.Qu)), color="pink")
        plot5.set_xlabel('t, [c]')
        plot5.set_ylabel('Qu, [pi*rad]')
        self.plot_container.append(plot5)

        # plot 6 работает
        plot6 = self.figure.add_subplot()
        plot6.plot(self.t, self.Im, color="red")
        plot6.plot(self.t, [self.Imax for _ in range(len(self.Im))], color="red")
        plot6.set_xlabel('t, [c]')
        plot6.set_ylabel('Im, [A]')
        self.plot_container.append(plot6)

        for i in range(0, 6):
            self.plot_container[i].set_visible(False)

        self.canvas = FigureCanvasTkAgg(self.figure, self.main)
        self.canvas.get_tk_widget().grid(row=2, column=2, rowspan=6, padx=4, pady=4)
        self.is_calculated = True  # нужна для переключения графиков ВРЕМЕННОЕ решение
        self.menu_plot_list_var.set(1)


application_exemplar = application()
application_exemplar.start()