公平地说，代码中的所有函数都很可能导致分段错误，而其他不会导致分段错误的函数则根本无法工作，很难解释错误在哪里。
1.如果要修改全局变量，请将其定义为global
1.通过重复使用window.after方法在主线程中更新GUI。
1.只有从微控制器阅读才应该在单独线程中完成。

1. Tkinter对象的创建应该在主线程中完成，在其他线程中只允许更新，但它不是线程安全的，因此虽然它可能工作，但有时会导致一些奇怪的行为或错误。
   1.调用matplotlib函数（如ion和flush_events）会导致错误，因为这些函数用于matplotlib交互式画布，而不是tkinter画布。
   1.线程化有一个非常坚韧的学习曲线，所以在你尝试使用它们之前，问问自己“我真的需要线程吗”和“有没有办法不使用线程”，因为一旦你开始使用线程，你就不再使用python的“安全代码”，尽管所有的努力，线程在任何任务中都是不安全的，你要让它们安全，老实说，这里不需要线程，除非你从你的微控制器阅读1 GB/s。
   1.不要用数字来表示状态，它不是pythonic，它会让读者感到困惑，而且与使用Enums相比，它没有任何性能优势。
   1.程序是以增量方式构建的，而不是从多个工作片段中复制粘贴，因为当代码的多个部分没有被验证为工作时，很难跟踪错误来自何处。

# Import Modules

import tkinter as tk
from threading import *
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)
from scipy.fft import fft
import numpy as np
import time
import random
from enum import Enum,auto

UPDATE_INTERVAL_MS = 300

class States(Enum):
    STREAM = auto()
    PAUSE = auto()
    SAVE = auto()
    START = auto()

# global variables

state = States.START  # check States Enum
x = [[0]]*12
y = [[0]]*12

# Thread buttons and plots separately

def threading():
    global state
    global window
    state = States.STREAM

    buttons()
    plots()
    data()
    t_grab_data = Thread(target=grab_data_loop,daemon=True)
    t_grab_data.start()
    # t_buttons = Thread(target=buttons)
    # t_plots = Thread(target=plots)
    # t_data = Thread(target=data)
    #
    # t_buttons.start()
    # t_plots.start()
    # t_data.start()

def hex_to_dec(x, y):
    for i in range(0, 12):
        for j in range(0, len(y)):
            x[i][j] = int(str(x[i][j]), 16)
            y[i][j] = int(str(y[i][j]), 16)

def data():
    global fig1,axs1,fig2,axs2
    fig1, axs1 = main_plot()
    fig2, axs2 = FFT_plot()
    # To be replaced with actual Arduino data
    window.after(UPDATE_INTERVAL_MS,draw_data_loop)

def grab_data_loop():
    while state != States.SAVE:
        for i in range(0, 12):
            x[i] = [j for j in range(101)]
            y[i] = [random.randint(0, 10) for j in range(-50, 51)]
        for i in range(0, 12):
            for j in range(0, len(y)):
                x[i][j] = int(str(x[i][j]), 16)
                y[i][j] = int(str(y[i][j]), 16)
        time.sleep(0.1)  # because we are not reading from a microcontroller

def draw_data_loop():
    if state == States.STREAM:
        update_main_plot(fig1, axs1)
        update_FFT_plot(fig2, axs2)
    window.after(UPDATE_INTERVAL_MS,draw_data_loop)

# create buttons

def stream_clicked():
    global state
    state = States.STREAM
    print("clicked")

def pause_clicked():
    global state
    state = States.PAUSE
    print("state")

def finish_clicked():
    global state
    state = States.SAVE
    window.destroy()

def buttons():
    continue_button = tk.Button(window, width=30, text="Stream data",
                                fg="black", bg='#98FB98', command=stream_clicked)
    continue_button.place(x=window.winfo_screenwidth() * 0.2, y=0)

    pause_button = tk.Button(window, width=30, text="Pause streaming data",
                             fg="black", bg='#FFA000', command=pause_clicked)
    pause_button.place(x=window.winfo_screenwidth() * 0.4, y=0)

    finish_button = tk.Button(window, width=30, text="End session and save",
                              fg='black', bg='#FF4500', command=finish_clicked)
    finish_button.place(x=window.winfo_screenwidth() * 0.6, y=0)

def plots():
    global state
    fig1, axs1 = main_plot()
    fig2, axs2 = FFT_plot()

    if state == States.STREAM:
        print("update")
        for i in range(0, 12):
            axs1[i].plot(x[i], y[i], 'blue')
            axs1[i].axes.get_yaxis().set_ticks([0], labels=["channel  " + str(i + 1)])
            axs1[i].grid(True)
            axs1[i].margins(x=0)

        # fig1.canvas.draw()
        # fig1.canvas.flush_events()
        # for i in range(0, 12):
        #     axs1[i].clear()
        for i in range(0, 12):
            axs2.plot(x[i], np.abs(fft(y[i])))
        plt.title("FFT of all 12 channels", x=0.5, y=1)

        # fig2.canvas.draw()
        # fig2.canvas.flush_events()
        # axs2.clear()

def main_plot():
    # plt.ion()
    global canvas1
    fig1, axs1 = plt.subplots(12, figsize=(10, 9), sharex=True)
    fig1.subplots_adjust(hspace=0)
    # Add fixed values for axis

    canvas1 = FigureCanvasTkAgg(fig1, master=window)
    # canvas.draw()
    canvas1.get_tk_widget().pack()
    canvas1.get_tk_widget().place(x=0, y=35)

    return fig1, axs1

def update_main_plot(fig1, axs1):
    if state == States.STREAM:
        for i in range(0, 12):
            axs1[i].clear()
        for i in range(0, 12):
            axs1[i].plot(x[i], y[i], 'blue')
            axs1[i].axes.get_yaxis().set_ticks([0], labels=["channel  " + str(i + 1)])
            axs1[i].grid(True)
            axs1[i].margins(x=0)
        axs1[0].set_title("Plot recordings", x=0.5, y=1)
        canvas1.draw()
        # fig1.canvas.draw()
        # fig1.canvas.flush_events()

def FFT_plot():
    # Plot FFT figure
    # plt.ion()
    global canvas2
    fig2, axs2 = plt.subplots(1, figsize=(7, 9))
    # Add fixed values for axis

    canvas2 = FigureCanvasTkAgg(fig2, master=window)
    # canvas.draw()
    canvas2.get_tk_widget().pack()
    canvas2.get_tk_widget().place(x=window.winfo_screenwidth() * 0.55, y=35)

    return fig2, axs2

def update_FFT_plot(fig2, axs2):
    # Update FFT plot
    if state == States.STREAM:
        axs2.clear()
        for i in range(0, 12):
            axs2.plot(x[i], np.abs(fft(y[i])))
        plt.title("FFT", x=0.5, y=1)
        canvas2.draw()
    # fig2.canvas.draw()
    # fig2.canvas.flush_events()
    # axs2.clear()

# create root window and set its properties

window = tk.Tk()
window.title("Data Displayer")
window.geometry("%dx%d" % (window.winfo_screenwidth(), window.winfo_screenheight()))
window.configure(background='white')

threading()

window.mainloop()

# put saving logic here