Interface2024Lev/InterfaceL.py

from idlelib.colorizer import color_config
from lib2to3.pgen2.driver import Driver
from logging import disable
from math import acosh
from tkinter import Tk, Label, Entry, Button, Spinbox, StringVar, BOTTOM, LEFT, SOLID, EW, END
from tkinter import ttk
from tkinter import filedialog
from tkinter.ttk import Combobox
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.backends._backend_tk import NavigationToolbar2Tk
from random import choice
import matplotlib.pyplot as plt
import matplotlib
import matplotlib.animation as animation
import numpy as np
from wrapper import GammaDevice
import threading
from typing import List
import time
import os
from matplotlib.animation import FuncAnimation
import tkinter as tk


class ScrollableFrame(ttk.Frame):
    def __init__(self, container, *args, **kwargs):
        super().__init__(container, *args, **kwargs)
        canvas = tk.Canvas(self, width=1600, height=900)
        scrollbar = ttk.Scrollbar(self, orient="vertical", command=canvas.yview)
        scrollbar_h = ttk.Scrollbar(self, orient="horizontal", command=canvas.xview)
        self.scrollable_frame = ttk.Frame(canvas)

        self.scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(
                scrollregion=canvas.bbox("all")
            )
        )

        canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")

        canvas.configure(yscrollcommand=scrollbar.set)
        canvas.configure(xscrollcommand=scrollbar_h.set)

        scrollbar_h.pack(side="bottom", fill="x")
        scrollbar.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True)

class Interface():
    window0 = Tk()
    windowq = ttk.Frame()
    windowq.pack()
    window = ScrollableFrame(windowq)
    window.pack(side='top', anchor='sw')
    t_list: List[float] = []
    c_list: List[float] = []
    adc_list: List[float] = []
    znach = {
        'temperature': t_list,
        'counts': c_list,
        'adc': adc_list}
    portID = ''  # нужно будет добавить порт
    GD = GammaDevice(portID)
    t = threading.Thread(target=GD.update_loop)
    t.start()

    def __init__(self):
        pass

    def create_widgets_S(self):
        Interface.window0.title("project_gamma_new_2vi")
        Interface.window0.geometry('500x250+100+100')
        photo = tk.PhotoImage(file='iconka.png')
        Interface.window0.iconphoto(False, photo)
        self.f_top = ttk.LabelFrame(Interface.window.scrollable_frame, text="Виртуальный COM порт", relief=SOLID, padding=(8, 10))
        self.combo = Combobox(self.f_top)
        self.combo['values'] = (1, 2, 3, 4, 5)
        self.combo.current(4)
        self.f_top.grid(column=0, row=0)
        self.combo.pack(side=BOTTOM)
        self.f_file = ttk.LabelFrame(Interface.window.scrollable_frame, text="Выбрать файл txt для записи", relief=SOLID,
                                     padding=(8, 10))
        self.f_file.grid(column=1, row=0)
        self.txt = Entry(self.f_file, width=40)
        self.txt.pack(side=LEFT)
        self.btn = Button(self.f_file, height=1, text='Файл', bg="gray", fg="red", command=self.clicked_file)
        self.btn.pack(side=LEFT)
        self.f_start = ttk.Frame(Interface.window.scrollable_frame, relief=SOLID, padding=(8, 10))
        self.t1 = Label(self.f_start, text="Состояние работы", fg="black")
        self.t2 = Label(self.f_start, text="Начать сбор данных", fg="black")
        self.t3 = Label(self.f_start, text="Остановить сбор данных", fg="black")
        self.t4 = Label(self.f_start, text="Выключено", fg="white", bg="black")
        self.button_start = Button(self.f_start, text="Пуск", bg="lightgray", fg="black", command=self.clicked_start1)
        self.button_startoff = Button(self.f_start, text="Стоп", bg="lightgray", fg="red",
                                      command=self.clicked_start2,
                                      state='disabled')
        self.f_start1 = ttk.LabelFrame(Interface.window.scrollable_frame, text='Принятые символы', relief=SOLID, padding=(8, 10))
        self.t_entry = Entry(self.f_start1, width=40, state=['disable'])
        self.f_start.grid(column=2, row=0)
        self.f_start1.grid(column=3, row=0)
        self.t1.grid(column=0, row=0)
        self.t2.grid(column=1, row=0)
        self.t3.grid(column=2, row=0)
        self.t4.grid(column=0, row=1)
        self.t_entry.grid(column=0, row=1)
        self.button_start.grid(column=1, row=1)
        self.button_startoff.grid(column=2, row=1)

    def create_widgets_W(self):
        self.f_W = ttk.Frame(Interface.window.scrollable_frame, relief=SOLID, padding=(8, 10))
        self.f_W.grid(column=0, row=1)
        self.tspin1 = Label(self.f_W, text="Время экспозиции, с", fg="black")
        self.tspin2 = Label(self.f_W, text="Макс. время сбора данных, с", fg="black")
        self.tspin3 = Label(self.f_W, text="Прошло времени, с", fg="black")
        self.spin1 = Spinbox(self.f_W, from_=0, to=100, width=7)
        self.spin2 = Spinbox(self.f_W, from_=0, to=10000000, increment=500, width=11)
        self.t_entry = Entry(self.f_W, width=20, state='disabled')
        self.tspin1.grid(column=0, row=0, ipadx=10)
        self.spin1.grid(column=0, row=1, pady=10)
        self.tspin2.grid(column=0, row=2, ipadx=10)
        self.spin2.grid(column=0, row=3, pady=10)
        self.tspin3.grid(column=0, row=4, pady=10)
        self.t_entry.grid(column=0, row=5)
        self.f_W1 = ttk.Frame(Interface.window.scrollable_frame, relief=SOLID, padding=(8, 10))
        self.f_W1.grid(column=0, row=2)
        self.tspin_0 = Label(self.f_W1, text="Коэффициент делителя", fg="black")
        self.spin_0 = Spinbox(self.f_W1, from_=0, to=100, width=7)
        self.tspin_0.grid(column=0, row=0, ipadx=10)
        self.spin_0.grid(column=0, row=1, pady=10)
        self.f_W2 = ttk.Frame(Interface.window.scrollable_frame, relief=SOLID, padding=(8, 10))
        self.f_W2.grid(column=0, row=3)
        self.spin1_zap = Spinbox(self.f_W2, from_=0.0, to=50.0, increment=0.1, width=6)
        self.spin2_zap = Spinbox(self.f_W2, from_=0, to=100, increment=1, width=6)
        self.spin3_zap = Spinbox(self.f_W2, from_=0, to=500, width=6)
        self.spin4_zap = Spinbox(self.f_W2, from_=0, to=500, width=6)
        self.tspin1_zap = Label(self.f_W2, text="ЦАП канал 1.0...3.29В", fg="black")
        self.tspin2_zap = Label(self.f_W2, text="ЦАП канал 2.0...3.29В", fg="black")
        self.tspin3_zap = Label(self.f_W2, text="ЦАП канал 3.1...256", fg="black")
        self.tspin4_zap = Label(self.f_W2, text="ЦАП канал 4.1...256", fg="black")
        self.tbut1_zap = Label(self.f_W2, text='''Обновить значение
        каналов DAC''', fg="black")
        self.tbut2_zap = Label(self.f_W2, text='''Прочесть текущее
        значение каналов DAC''', fg="black")
        self.button1_zap = Button(self.f_W2, text="Обновить", bg="lightgray", fg="black")
        self.button2_zap = Button(self.f_W2, text="Прочесть", bg="lightgray", fg="black")
        self.tspin1_zap.grid(column=0, row=0, ipadx=10)
        self.spin1_zap.grid(column=0, row=1, pady=10)
        self.tspin2_zap.grid(column=0, row=2, ipadx=10)
        self.spin2_zap.grid(column=0, row=3, pady=10)
        self.tspin3_zap.grid(column=0, row=4, ipadx=10)
        self.spin3_zap.grid(column=0, row=5, pady=10)
        self.tspin4_zap.grid(column=0, row=6, ipadx=10)
        self.spin4_zap.grid(column=0, row=7, pady=10)
        self.tbut1_zap.grid(column=0, row=8)
        self.button1_zap.grid(column=0, row=9)
        self.tbut2_zap.grid(column=0, row=10)
        self.button2_zap.grid(column=0, row=11)
        self.f_W3 = ttk.Frame(Interface.window.scrollable_frame, relief=SOLID, padding=(8, 10))
        self.txt0_fw3 = Label(self.f_W3, text="Порт В1 напряжения", fg="black")
        self.txt1_fw3 = Label(self.f_W3, text="      0 B      ", fg="black", bg="pink")
        self.m = '      0 B      '
        self.txt2_fw3 = Label(self.f_W3, text='''Выбор напряжения:
        0 В                 3.3B''')
        self.but_fw3 = Button(self.f_W3, text='<---', command=self.clicked_V)
        self.f_W3.grid(column=0, row=4)
        self.txt0_fw3.grid(column=0, row=0)
        self.txt1_fw3.grid(column=0, row=1, pady=10)
        self.txt2_fw3.grid(column=0, row=2)
        self.but_fw3.grid(column=0, row=3)

    def create_Figure(self):
        self.file1 = open('coordinates.txt', 'r')
        with self.file1 as f:
            self.lines = f.readlines()
        self.data = [line.strip().split() for line in self.lines]
        self.xdata, self.ydata = zip(*[(float(x), float(y)) for x, y in self.data])
        self.f_graf = ttk.LabelFrame(Interface.window.scrollable_frame,
                                     text='Количество импульсов в минуту', relief=SOLID)
        self.f_graf.grid(column=1, row=1, columnspan=2, rowspan=2)
        self.fig = Figure(figsize=(7, 4), dpi=80)
        self.ax = self.fig.add_subplot(111)
        self.ax.set_xlabel('Время, с')
        self.ax.set_ylabel('Импульсы')
        self.ax.grid(color='black', linewidth=1.0)
        self.ax.set_xlim(0, 3000)
        self.ax.set_ylim(0, 10000)
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.f_graf)
        self.canvas.draw()
        self.canvas.get_tk_widget().grid(column=0, row=0)
        self.line, = self.ax.plot([], [], 'ro-')

        def init():
            self.line.set_data([], [])
            return self.line,

        def update(frame):
            self.line.set_data(self.xdata[:frame], self.ydata[:frame])
            return self.line,

        self.ani = FuncAnimation(self.fig, update, frames=len(self.xdata),
                                 init_func=init, blit=True, interval=5, repeat=False)

        Interface.window.after(100, lambda: None)
        self.f_grafbtn = ttk.LabelFrame(self.f_graf, text='Время отоброжения', padding=(8, 10))
        self.f_grafbtn.grid(column=1, row=0)
        self.tgrafsp = Label(self.f_grafbtn, text="Начало времени, с", fg="black")
        self.tgrafsp.grid(column=0, row=0)
        self.grafspin = Spinbox(self.f_grafbtn, from_=0, to=1000, increment=100, width=7)
        self.grafspin.grid(column=0, row=1)
        self.t1grafbtn = Label(self.f_grafbtn, text="Выбор конца времени", fg="black")
        self.t1grafbtn.grid(column=0, row=2)
        self.button_time1 = Button(self.f_grafbtn, text="Текущее время",
                                   bg="lightgray", fg="black", command=self.clicked_time, state=['disable'])
        self.button_time1.grid(column=0, row=3, sticky=EW)
        self.tgrafsp1 = Label(self.f_grafbtn, text="Конец времени, с", fg="black")
        self.tgrafsp1.grid(column=0, row=4)
        self.Time_flag = 'disabled'
        self.grafspin1 = Entry(self.f_grafbtn, width=7,state=self.Time_flag)
        self.grafspin1.grid(column=0, row=5)
        self.spinbox_var1 = StringVar(value=str(0))
        self.tgrafspTmin = Label(self.f_grafbtn, text="Нижняя граница, имп/с", fg="black")
        self.tgrafspTmin.grid(column=0, row=6)
        self.grafspinTmin = Spinbox(self.f_grafbtn, from_=0, to=5000,
                                    textvariable=self.spinbox_var1, increment=500, width=7)
        self.grafspinTmin.grid(column=0, row=7)
        self.tgrafspTmax = Label(self.f_grafbtn, text="Верхняя граница, имп/с", fg="black")
        self.tgrafspTmax.grid(column=0, row=8)
        self.spinbox_var2 = StringVar(value=str(10000))
        self.grafspinTmax = Spinbox(self.f_grafbtn, from_=5000, to=10000, increment=500,
                                    textvariable=self.spinbox_var2, width=7)
        self.grafspinTmax.grid(column=0, row=9)

    def ADC_create_Figure(self):
        self.ADC_file1 = open('coordinates.txt', 'r')
        with self.ADC_file1 as f:
            self.ADC_lines = f.readlines()
        self.ADC_data = [line.strip().split() for line in self.ADC_lines]
        self.ADC_xdata, self.ADC_ydata = zip(*[(float(x), float(y)) for x, y in self.ADC_data])
        self.f_graf_ADC = ttk.LabelFrame(Interface.window.scrollable_frame,
                                         text='АЦП канал 1, В', relief=SOLID)
        self.f_graf_ADC.grid(column=3, row=1, columnspan=2, rowspan=2)
        self.fig_ADC = Figure(figsize=(7, 4), dpi=80)
        self.ax_ADC = self.fig_ADC.add_subplot(111)
        self.ax_ADC.set_xlabel('Время, с')
        self.ax_ADC.set_ylabel('Напряжение, В')
        self.ax_ADC.grid(color='black', linewidth=1.0)
        self.ax_ADC.set_xlim(0, 3000)
        self.ax_ADC.set_ylim(0, 10000)
        self.canvas_ADC = FigureCanvasTkAgg(self.fig_ADC, master=self.f_graf_ADC)
        self.canvas_ADC.draw()
        self.canvas_ADC.get_tk_widget().grid(column=0, row=0)
        self.ADC_line, = self.ax_ADC.plot([], [], 'ro-')

        def init():
            self.ADC_line.set_data([], [])
            return self.ADC_line,

        def update(frame):
            self.ADC_line.set_data(self.ADC_xdata[:frame], self.ADC_ydata[:frame])
            return self.ADC_line,

        self.ADC_ani = FuncAnimation(self.fig_ADC, update, frames=len(self.ADC_xdata),
                                     init_func=init, blit=True, interval=5, repeat=False)

        Interface.window.after(100, lambda: None)
        self.f_grafbtnADC = ttk.LabelFrame(self.f_graf_ADC, text='Время отоброжения', padding=(8, 10))
        self.f_grafbtnADC.grid(column=1, row=0)
        self.tgrafspADC = Label(self.f_grafbtnADC, text="Начало времени, с", fg="black")
        self.tgrafspADC.grid(column=0, row=0)
        self.grafspinADC = Spinbox(self.f_grafbtnADC, from_=0, to=1000, increment=100, width=7)
        self.grafspinADC.grid(column=0, row=1)
        self.t1grafbtnADC = Label(self.f_grafbtnADC, text="Выбор конца времени", fg="black")
        self.t1grafbtnADC.grid(column=0, row=2)
        self.button_time1ADC = Button(self.f_grafbtnADC, text="Текущее время",
                                      bg="lightgray", fg="black", command=self.clicked_timeADC, state=['disable'])
        self.button_time1ADC.grid(column=0, row=3, sticky=EW)
        self.tgrafsp1ADC = Label(self.f_grafbtnADC, text="Конец времени, с", fg="black")
        self.tgrafsp1ADC.grid(column=0, row=4)
        self.Time_flagADC = 'disabled'
        self.grafspin1ADC = Entry(self.f_grafbtnADC, width=7, state=self.Time_flagADC)
        self.grafspin1ADC.grid(column=0, row=5)
        self.spinbox_var1ADC = StringVar(value=str(0))
        self.tgrafspTminADC = Label(self.f_grafbtnADC, text="Нижняя граница, В", fg="black")
        self.tgrafspTminADC.grid(column=0, row=6)
        self.grafspinTminADC = Spinbox(self.f_grafbtnADC, from_=0, to=5000,
                                       textvariable=self.spinbox_var1ADC, increment=500, width=7)
        self.grafspinTminADC.grid(column=0, row=7)
        self.tgrafspTmaxADC = Label(self.f_grafbtnADC, text="Верхняя граница, В", fg="black")
        self.tgrafspTmaxADC.grid(column=0, row=8)
        self.spinbox_var2ADC = StringVar(value=str(10000))
        self.grafspinTmaxADC = Spinbox(self.f_grafbtnADC, from_=5000, to=10000, increment=500,
                                       textvariable=self.spinbox_var2ADC, width=7)
        self.grafspinTmaxADC.grid(column=0, row=9)

    def TEM_create_Figure(self):
        self.TEM_file1 = open('coordinates.txt', 'r')
        with self.TEM_file1 as f:
            self.TEM_lines = f.readlines()
        self.TEM_data = [line.strip().split() for line in self.TEM_lines]
        self.TEM_xdata, self.TEM_ydata = zip(*[(float(x), float(y)) for x, y in self.TEM_data])
        self.f_graf_TEM = ttk.LabelFrame(Interface.window.scrollable_frame,
                                         text='Температура, С', relief=SOLID)
        self.f_graf_TEM.grid(column=1, row=3, columnspan=2, rowspan=2)
        self.fig_TEM = Figure(figsize=(7, 4), dpi=80)
        self.ax_TEM = self.fig_TEM.add_subplot(111)
        self.ax_TEM.set_xlabel('Время, с')
        self.ax_TEM.set_ylabel('Температура, С')
        self.ax_TEM.grid(color='black', linewidth=1.0)
        self.ax_TEM.set_xlim(0, 3000)
        self.ax_TEM.set_ylim(0, 10000)
        self.canvas_TEM = FigureCanvasTkAgg(self.fig_TEM, master=self.f_graf_TEM)
        self.canvas_TEM.draw()
        self.canvas_TEM.get_tk_widget().grid(column=0, row=0)
        self.TEM_line, = self.ax_TEM.plot([], [], 'ro-')

        def init():
            self.TEM_line.set_data([], [])
            return self.TEM_line,

        def update(frame):
            self.TEM_line.set_data(self.TEM_xdata[:frame], self.TEM_ydata[:frame])
            return self.TEM_line,

        self.TEM_ani = FuncAnimation(self.fig_TEM, update, frames=len(self.TEM_xdata),
                                     init_func=init, blit=True, interval=5, repeat=False)

        Interface.window.after(100, lambda: None)
        self.f_grafbtnTEM = ttk.LabelFrame(self.f_graf_TEM, text='Время отоброжения', padding=(8, 10))
        self.f_grafbtnTEM.grid(column=1, row=0)
        self.tgrafspTEM = Label(self.f_grafbtnTEM, text="Начало времени, с", fg="black")
        self.tgrafspTEM.grid(column=0, row=0)
        self.grafspinTEM = Spinbox(self.f_grafbtnTEM, from_=0, to=1000, increment=100, width=7)
        self.grafspinTEM.grid(column=0, row=1)
        self.t1grafbtnTEM = Label(self.f_grafbtnTEM, text="Выбор конца времени", fg="black")
        self.t1grafbtnTEM.grid(column=0, row=2)
        self.button_time1TEM = Button(self.f_grafbtnTEM, text="Текущее время",
                                      bg="lightgray", fg="black", command=self.clicked_timeTEM, state=['disable'])
        self.button_time1TEM.grid(column=0, row=3, sticky=EW)
        self.tgrafsp1TEM = Label(self.f_grafbtnTEM, text="Конец времени, с", fg="black")
        self.tgrafsp1TEM.grid(column=0, row=4)
        self.Time_flagTEM = 'disabled'
        self.grafspin1TEM = Entry(self.f_grafbtnTEM, width=7, state=self.Time_flagTEM)
        self.grafspin1TEM.grid(column=0, row=5)
        self.spinbox_var1TEM = StringVar(value=str(0))
        self.tgrafspTminTEM = Label(self.f_grafbtnTEM, text="Нижняя граница, С", fg="black")
        self.tgrafspTminTEM.grid(column=0, row=6)
        self.grafspinTminTEM = Spinbox(self.f_grafbtnTEM, from_=0, to=5000,
                                       textvariable=self.spinbox_var1TEM, increment=500, width=7)
        self.grafspinTminTEM.grid(column=0, row=7)
        self.tgrafspTmaxTEM = Label(self.f_grafbtnTEM, text="Верхняя граница, С", fg="black")
        self.tgrafspTmaxTEM.grid(column=0, row=8)
        self.spinbox_var2TEM = StringVar(value=str(10000))
        self.grafspinTmaxTEM = Spinbox(self.f_grafbtnTEM, from_=5000, to=10000, increment=500,
                                       textvariable=self.spinbox_var2TEM, width=7)
        self.grafspinTmaxTEM.grid(column=0, row=9)

    def Driver(self):
        if Interface.GD.updated:
            Interface.znach['temperature'].append(Interface.GD.temperature)
            Interface.znach['counts'].append(Interface.GD.counts)
            Interface.znach['adc'].append(Interface.GD.adc)
            Interface.GD.updated = False
        else:
            pass
        Interface.window.after(1000, self.Driver)


    def start(self):
        self.mennuB()
        self.create_widgets_S()
        self.create_widgets_W()
        self.create_Figure()
        self.ADC_create_Figure()
        self.TEM_create_Figure()
        self.block_control()
        self.Driver()
        Interface.window.mainloop()

    def clicked_file(self):
        self.file1 = filedialog.askopenfile(filetypes=(("Text files", "*.txt"), ("all files", "*.*")))
        assert self.file1 is not None

        self.file = os.path.abspath(self.file1.name)
        self.txt.delete(0, END)
        self.txt.insert(0, self.file)

    def clicked_start1(self):
        self.button_start.configure(state="disabled")
        self.t4.configure(text="Включено", bg="black", fg="green")
        self.button_startoff.configure(state="active")
        self.seconds1 = time.time()
        self.clicked_time()
        self.clicked_timeADC()
        self.clicked_timeTEM()



    def clicked_start2(self):
        self.seconds2 = time.time()
        self.button_start.configure(state="active")
        self.t4.configure(text="Выключено", bg="black", fg="white")
        self.button_startoff.configure(state='disabled')
        self.grafspin1.configure(state="normal")
        self.grafspin1ADC.configure(state="normal")
        self.grafspin1TEM.configure(state="normal")
        self.IMP_entry.configure(state="normal")
        self.ADC_entry.configure(state="normal")
        self.TEM_entry.configure(state="normal")
        if self.ani is not None:
            self.ani.event_source.stop()
            self.ani = None
        if self.ADC_ani is not None:
            self.ADC_ani.event_source.stop()
            self.ADC_ani = None
        if self.TEM_ani is not None:
            self.TEM_ani.event_source.stop()
            self.TEM_ani = None
        if self.ani1 is not None:
            self.ani1.event_source.stop()
            self.ani1 = None
        if self.ADC_ani1 is not None:
            self.ADC_ani1.event_source.stop()
            self.ADC_ani1 = None
        if self.TEM_ani1 is not None:
            self.TEM_ani1.event_source.stop()
            self.TEM_ani1 = None

        self.indexxx = (self.seconds2 - self.seconds1)
        self.grafspin1.delete(0, last=END)
        self.grafspin1.insert(0, str(self.xdata[round(self.indexxx * 5)]))
        self.grafspin1ADC.delete(0, last=END)
        self.grafspin1ADC.insert(0, str(self.ADC_xdata[round(self.indexxx * 5)]))
        self.grafspin1TEM.delete(0, last=END)
        self.grafspin1TEM.insert(0, str(self.TEM_xdata[round(self.indexxx * 5)]))

        self.IMP_entry.delete(0, last=END)
        self.IMP_entry.insert(0, str(round(self.ydata[round(self.indexxx * 5)])))
        self.ADC_entry.delete(0, last=END)
        self.ADC_entry.insert(0, str(round(self.ADC_ydata[round(self.indexxx * 5)])))
        self.TEM_entry.delete(0, last=END)
        self.TEM_entry.insert(0, str(round(self.TEM_ydata[round(self.indexxx * 5)])))

        self.grafspin1.configure(state="disabled")
        self.grafspin1ADC.configure(state="disabled")
        self.grafspin1TEM.configure(state="disabled")
        self.IMP_entry.configure(state="disabled")
        self.ADC_entry.configure(state="disabled")
        self.TEM_entry.configure(state="disabled")


    def clicked_V(self):
        if self.m == "      0 B      ":
            self.m = '      3.3 B      '
            self.txt1_fw3.configure(text='      3.3 B      ')
            self.but_fw3.configure(text="--->")
        else:
            self.m = '      0 B      '
            self.but_fw3.configure(text='<---')
            self.txt1_fw3.configure(text='      0 B      ')

    def clicked_time(self):
        if self.ani is not None:
            self.ani.event_source.stop()
            self.ani = None

        self.file1 = open(self.file, 'r')
        with self.file1 as f:
            self.lines = f.readlines()

        self.data = [line.strip().split() for line in self.lines]
        self.xdata, self.ydata = zip(*[(float(x), float(y) + 100 * (-1) ** (round(float(y)) % 2)) for x, y in self.data])
        min_time = self.grafspin.get()
        self.xdata = list(filter(lambda x: x >= int(min_time), self.xdata))
        self.ax.clear()
        self.ax.set_xlabel('Время, с')
        self.ax.set_ylabel('Импульсы')
        self.ax.grid(color='black', linewidth=1.0)
        self.ax.set_xlim(min(self.xdata), 3000)
        self.ax.set_ylim(int(self.spinbox_var1.get()),
                         int(self.spinbox_var2.get()))
        self.line, = self.ax.plot([], [], 'ro-')

        def init1():
            self.line.set_data([], [])
            return self.line,

        def update1(frame):
            self.line.set_data(self.xdata[:frame], self.ydata[:frame])
            return self.line,

        self.ani1 = FuncAnimation(self.fig, update1, frames=len(self.xdata),
                                  init_func=init1, blit=True, interval=200, repeat=False)

        self.canvas.draw()
        Interface.window.after(10, lambda: None)


    def clicked_timeADC(self):
        if self.ADC_ani is not None:
            self.ADC_ani.event_source.stop()
            self.ADC_ani = None

        self.ADC_file1 = open(self.file, 'r')
        self.Time_flagADC = 'disabled'
        self.grafspin1.configure(state=self.Time_flagADC)
        with self.ADC_file1 as f:
            self.ADC_lines = f.readlines()

        self.ADC_data = [line.strip().split() for line in self.ADC_lines]
        self.ADC_xdata, self.ADC_ydata = zip(*[(float(x), float(y)) for x, y in self.ADC_data])
        max_time = self.grafspin1ADC.get()
        min_time = self.grafspinADC.get()
        self.ADC_xdata = list(filter(lambda x: x >= int(min_time), self.ADC_xdata))
        self.ax_ADC.clear()
        self.ax_ADC.set_xlabel('Время, с')
        self.ax_ADC.set_ylabel('Напряжение, В')
        self.ax_ADC.grid(color='black', linewidth=1.0)
        self.ax_ADC.set_xlim(min(self.ADC_xdata), 3000)
        self.ax_ADC.set_ylim(int(self.spinbox_var1ADC.get()),
                             int(self.spinbox_var2ADC.get()))
        self.ADC_line, = self.ax_ADC.plot([], [], 'ro-')

        def init1():
            self.ADC_line.set_data([], [])
            return self.ADC_line,

        def update1(frame):
            self.ADC_line.set_data(self.ADC_xdata[:frame], self.ADC_ydata[:frame])
            return self.ADC_line,

        self.ADC_ani1 = FuncAnimation(self.fig_ADC, update1, frames=len(self.ADC_xdata),
                                      init_func=init1, blit=True, interval=200, repeat=False)

        self.canvas_ADC.draw()
        Interface.window.after(10, lambda: None)


    def clicked_timeTEM(self):
        if self.TEM_ani is not None:
            self.TEM_ani.event_source.stop()
            self.TEM_ani = None

        self.TEM_file1 = open(self.file, 'r')
        self.Time_flagTEM = 'disabled'
        self.grafspin1TEM.configure(state=self.Time_flagTEM)
        with self.TEM_file1 as f:
            self.TEM_lines = f.readlines()

        self.TEM_data = [line.strip().split() for line in self.ADC_lines]
        self.TEM_xdata, self.TEM_ydata = zip(*[(float(x), float(y)) for x, y in self.TEM_data])
        max_time = self.grafspin1TEM.get()
        min_time = self.grafspinTEM.get()
        self.TEM_xdata = list(filter(lambda x: x >= int(min_time), self.TEM_xdata))
        self.ax_TEM.clear()
        self.ax_TEM.set_xlabel('Время, с')
        self.ax_TEM.set_ylabel('Температура, С')
        self.ax_TEM.grid(color='black', linewidth=1.0)
        self.ax_TEM.set_xlim(min(self.TEM_xdata), 3000)
        self.ax_TEM.set_ylim(int(self.spinbox_var1TEM.get()),
                             int(self.spinbox_var2TEM.get()))
        self.TEM_line, = self.ax_TEM.plot([], [], 'ro-')

        def init1():
            self.TEM_line.set_data([], [])
            return self.TEM_line,

        def update1(frame):
            self.TEM_line.set_data(self.TEM_xdata[:frame], self.TEM_ydata[:frame])
            return self.TEM_line,

        self.TEM_ani1 = FuncAnimation(self.fig_TEM, update1, frames=len(self.TEM_xdata),
                                      init_func=init1, blit=True, interval=200, repeat=False)

        self.canvas_TEM.draw()
        Interface.window.after(10, lambda: None)


    def block_control(self):
        self.f_BC = ttk.LabelFrame(Interface.window.scrollable_frame, text='Текущее значение данных:', relief=SOLID)
        self.f_BC.grid(column=3, row=3, columnspan=2, rowspan=2)
        self.text_BC = Label(self.f_BC, text="Кол-во импульсов", fg="black")
        self.text_BC.grid(column=0, row=0, pady=10)
        self.text_BC_ADC = Label(self.f_BC, text="АЦП канал 1, В", fg="black")
        self.text_BC_ADC.grid(column=1, row=0, ipadx=15, pady=10)
        self.text_BC_TEM = Label(self.f_BC, text="Температура, С", fg="black")
        self.text_BC_TEM.grid(column=2, row=0, ipady=10)
        self.impSV = StringVar(value=round(self.ydata[0]))
        self.adcSV = StringVar(value=round(self.ADC_ydata[0]))
        self.temSV = StringVar(value=round(self.TEM_ydata[0]))
        self.IMP_entry = Entry(self.f_BC, width=15, state='disabled', textvariable=self.impSV)
        self.IMP_entry.grid(column=0, row=1)
        self.ADC_entry = Entry(self.f_BC, width=15, state='disabled', textvariable=self.adcSV)
        self.ADC_entry.grid(column=1, row=1, padx=15)
        self.TEM_entry = Entry(self.f_BC, width=15, state='disabled', textvariable=self.temSV)
        self.TEM_entry.grid(column=2, row=1)
        self.bctext = Label(self.f_BC, text="Статус датчика Температуры", fg="black")
        self.bctext.grid(column=0, row=2, padx=10, ipady=5)
        self.bctext1 = Label(self.f_BC, text="Статус внешнего ЦАП", fg="black")
        self.bctext1.grid(column=2, row=2, padx=10, ipady=5)
        self.SDT = Label(self.f_BC, text="Работает", fg="black", bg="green")
        self.SDT.grid(column=0, row=3, pady=15, padx=10, sticky='NSEW')
        self.SVadc = Label(self.f_BC, text="Работает", fg="black", bg="green")
        self.SVadc.grid(column=2, row=3, padx=10, pady=15, sticky='NSEW')

        self.bctext11 = Label(self.f_BC, text="Проверить статус работы", fg="black")
        self.bctext11.grid(column=0, row=4, padx=10, ipady=5)
        self.bctext12 = Label(self.f_BC, text="Проинициализировать датчик", fg="black")
        self.bctext12.grid(column=2, row=4, padx=10, ipady=5)
        self.bcbtn = Button(self.f_BC, text='Проверка')
        self.bcbtn.grid(column=0, row=5, padx=10, ipady=5)
        self.bcbtn1 = Button(self.f_BC, text='INIT', state=['disable'])
        self.bcbtn1.grid(column=2, row=5, padx=10, ipady=5)
        self.bctext111 = Label(self.f_BC, text="При запуске exe приложения и сборе данных, проверка датчика температуры автоматическая", fg="black")
        self.bctext111.grid(column=0, row=6, columnspan=3, padx=10, ipady=5)

    def mennuB(self):
        menubar1 = tk.Menu(self.window0)
        self.window0.config(menu=menubar1)
        setting_menu1 = tk.Menu(menubar1)
        setting_menu1.add_command(label='---')
        menubar1.add_cascade(label='File', menu=setting_menu1)
        setting_menu2 = tk.Menu(menubar1)
        setting_menu2.add_command(label='----')
        menubar1.add_cascade(label='Edit', menu=setting_menu2)
        setting_menu3 = tk.Menu(menubar1)
        setting_menu3.add_command(label='---')
        menubar1.add_cascade(label='Operate', menu=setting_menu3)
        setting_menu4 = tk.Menu(menubar1)
        setting_menu4.add_command(label='-----')
        menubar1.add_cascade(label='Tools', menu=setting_menu4)
        setting_menu5 = tk.Menu(menubar1)
        setting_menu5.add_command(label='-----')
        menubar1.add_cascade(label='Window', menu=setting_menu5)
        setting_menu6 = tk.Menu(menubar1)
        setting_menu6.add_command(label='-----')
        menubar1.add_cascade(label='Help', menu=setting_menu6)


interface = Interface()
interface.start()