Добавление всех графиков

InterfaceL.py

@@ -1,4 +1,5 @@
 from idlelib.colorizer import color_config
+from logging import disable
 from tkinter import *
 import tkinter as tk
 from tkinter import ttk
@@ -138,8 +139,8 @@ class Interface():
         self.ax.set_xlabel('Время, с')
         self.ax.set_ylabel('Импульсы')
         self.ax.grid(color='black', linewidth=1.0)
-        self.ax.set_xlim(min(self.xdata), max(self.xdata))
-        self.ax.set_ylim(min(self.ydata), max(self.ydata))
+        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)
@@ -189,17 +190,149 @@ class Interface():
                                     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,
+                                     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, 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="start",
+                                   bg="lightgray", fg="black", command=self.clicked_timeADC)
+        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.spinbox_varTimeADC = StringVar(value=100)
+        self.grafspin1ADC = Spinbox(self.f_grafbtnADC, from_=100, to=50000, increment=100, width=7,
+                                 textvariable=self.spinbox_varTimeADC, state=[self.Time_flagADC])
+        self.grafspin1ADC.grid(column=0, row=5)
+        self.spinbox_var1ADC = StringVar(value=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=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,
+                                     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, 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="start",
+                                   bg="lightgray", fg="black", command=self.clicked_timeTEM)
+        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.spinbox_varTimeTEM = StringVar(value=100)
+        self.grafspin1TEM = Spinbox(self.f_grafbtnTEM, from_=100, to=50000, increment=100, width=7,
+                                 textvariable=self.spinbox_varTimeTEM, state=[self.Time_flagTEM])
+        self.grafspin1TEM.grid(column=0, row=5)
+        self.spinbox_var1TEM = StringVar(value=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=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 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()
         Interface.window.mainloop()
 
     def clicked_file(self):
         self.file1 = filedialog.askopenfile(filetypes=(("Text files","*.txt"),("all files","*.*")))
         self.file = os.path.abspath(self.file1.name)
-        print(self.file)
         self.txt.delete(0, END)
         self.txt.insert(0, self.file)
 
@@ -239,13 +372,17 @@ class Interface():
 
             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])
+            max_time = self.grafspin1.get()
+            min_time = self.grafspin.get()
+            self.xdata = list(filter(lambda x: x <= int(max_time), self.xdata))
+            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), max(self.xdata))
-            self.ax.set_ylim(min(min(self.ydata), int(self.spinbox_var1.get())),
-                                 max(max(self.ydata), int(self.spinbox_var2.get())))
+            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():
@@ -256,13 +393,116 @@ class Interface():
                 self.line.set_data(self.xdata[:frame], self.ydata[:frame])
                 return self.line,
 
-            self.ani = FuncAnimation(self.fig, update1, frames=len(self.xdata),
+            self.ani1 = FuncAnimation(self.fig, update1, frames=len(self.xdata),
                                      init_func=init1, blit=True, interval=5, repeat=False)
 
             self.canvas.draw()
-            print(self.ydata)
             Interface.window.after(10, None)
 
+    def clicked_timeADC(self):
+        if self.ADC_ani is not None:
+            self.ADC_ani.event_source.stop()
+            self.ADC_ani = None
+        if self.Time_flagADC == 'disabled':
+            self.Time_flagADC = 'normal'
+            self.grafspin1ADC.configure(state=[self.Time_flagADC])
+        else:
+            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(max_time), self.ADC_xdata))
+            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=5, repeat=False)
+
+            self.canvas_ADC.draw()
+            Interface.window.after(10, None)
+
+    def clicked_timeTEM(self):
+        if self.TEM_ani is not None:
+            self.TEM_ani.event_source.stop()
+            self.TEM_ani = None
+        if self.Time_flagTEM == 'disabled':
+            self.Time_flagTEM = 'normal'
+            self.grafspin1TEM.configure(state=[self.Time_flagTEM])
+        else:
+            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(max_time), self.TEM_xdata))
+            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=5, repeat=False)
+
+            self.canvas_TEM.draw()
+            Interface.window.after(10, None)
+
+    def block_control(self):
+        self.f_BC = ttk.LabelFrame(Interface.window, 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, ipady=10)
+        self.text_BC_ADC = Label(self.f_BC, text="АЦП канал 1, В", fg="black")
+        self.text_BC_ADC.grid(column=1, row=0, ipadx=15, ipady=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[-1]))
+        self.adcSV = StringVar(value=round(self.ADC_ydata[-1]))
+        self.temSV = StringVar(value=round(self.TEM_ydata[-1]))
+        self.IMP_entry = Entry(self.f_BC, width=15, state=['disable'], textvariable=self.impSV)
+        self.IMP_entry.grid(column=0, row=1)
+        self.ADC_entry = Entry(self.f_BC, width=15, state=['disable'], textvariable=self.adcSV)
+        self.ADC_entry.grid(column=1, row=1, ipadx=15)
+        self.TEM_entry = Entry(self.f_BC, width=15, state=['disable'], textvariable=self.temSV)
+        self.TEM_entry.grid(column=2, row=1)
 
     def mennuB(self):
         menubar1 = tk.Menu(self.window)