使用雷达测量心率和呼吸频率项目（2）-启动所有线程和服务的主程序

导入 main 中使用的可用类

import time
import queue
import subprocess       # 用于树莓派关机
import os               # 用于使用终端命令
import matplotlib.pyplot as plt
from matplotlib.colors import BoundaryNorm
from matplotlib.ticker import MaxNLocator
import numpy as np

导入我们自己在 main 中使用的类

import bluetooth_server_module          # 导入蓝牙类以管理与设备的连接
import data_acquisition_module          # 从雷达收集和过滤相关数据的导入类
# 为施密特触发器和脉冲检测导入信号处理类
import signal_processing_module


def main():
    time.sleep(10)

用于从不同线程访问数据的队列

    HR_filtered_queue = queue.Queue()
    HR_final_queue = queue.Queue()
    RR_filtered_queue = queue.Queue()
    RR_final_queue = queue.Queue()
    RTB_final_queue = queue.Queue()  # 实时呼吸最终队列
    heart_rate_csv = []
    initiate_write_heart_rate = []
    start_write_to_csv_time = 0
    window_slide = 1

类之间发送的参数和数据列表

go = ["True"]       # 用于在树莓派关闭前关闭线程
    run_measurement = []        # 判断数据是否发送到设备
    sample_freq = 0         # 值在 DataAcquisition 中更新。需要在整个程序中相同
    list_of_variables_for_threads = {"HR_filtered_queue": HR_filtered_queue, "HR_final_queue": HR_final_queue,
                                     "RR_filtered_queue": RR_filtered_queue, "RR_final_queue": RR_final_queue,
                                     "RTB_final_queue": RTB_final_queue, "go": go, "run_measurement": run_measurement,
                                     "sample_freq": sample_freq, "heart_rate_csv": heart_rate_csv,
                                     "window_slide": window_slide, "initiate_write_heart_rate": initiate_write_heart_rate,
                                     "start_write_to_csv_time": start_write_to_csv_time}
    FFTfreq = [1, 2, 3]
    FFTamplitude = [1, 2, 3]
    peak_freq = [1]
    peak_amplitude = [1]
    len_fft = 0
    array = []
    #freq_array = np.linspace(0.8*60, 180, 2*33)
    run_times = 0

BluetoothServer 对象发送到本地发送数据的类

 bluetooth_server = bluetooth_server_module.BluetoothServer(list_of_variables_for_threads)

在 DataAcquisition 类中启动 run() 方法的线程

data_acquisition = data_acquisition_module.DataAcquisition(
        list_of_variables_for_threads, bluetooth_server)
    data_acquisition.start()

下面使用的 SignalProcessing 对象

signal_processing = signal_processing_module.SignalProcessing(
        list_of_variables_for_threads, bluetooth_server, FFTfreq, FFTamplitude)

    #plt.pcolormesh(specTime, specFreq, specSignal)
    # plt.pause(1)
    #plt.xlim(1, 3)

让线程和程序在 go 为 True 时运行。Go 是从应用程序设置的

while list_of_variables_for_threads.get('go'):
        # FFT 测试，稍后移除
        #plt.xlim(1, 3)
        #FFTfreq, FFTamplitude, peak_freq, peak_amplitude, len_fft, peak_weighted = signal_processing.getFFTvalues()
        #print("Length of FFT_amplitude", len(FFTamplitude))
        #if len(FFTamplitude) == len_fft:
            #time_array = np.linspace(0, (run_times+1)*1.5, run_times+1)
            # array.append(FFTamplitude)
            #plt.figure(1)
            #plt.clf()
            # try:
            #     #print('FFTfreq',len(FFTfreq), 'FFTamplitude',len(FFTamplitude))
            #     # print('peak_freq',len(peak_freq),'peak_amplitude',len(peak_amplitude),'peak_weighted',len(peak_weighted),peak_weighted)
            #     plt.plot(FFTfreq, FFTamplitude)
            #     plt.plot(peak_freq, peak_amplitude, 'bo')
            #     plt.plot(peak_freq, peak_weighted, 'ro')
            #     plt.pause(0.1)
            # except Exception as e:
            #     print('plot error:', e)

            # cmap = plt.get_cmap('PiYG')
            # levels = MaxNLocator(nbins=90).tick_values(-35, np.amax(array))
            # norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)

            # plt.figure(2)
            # plt.clf()
            # plt.pcolormesh(time_array, freq_array, np.transpose(array), norm=norm)
            # plt.colorbar()
            # plt.xlabel("Time (s)")
            # plt.ylabel("Frequency (bpm)")
            # run_times += 1
        #plt.pause(0.9)
        time.sleep(1)
        # plt.plot(FFTfreq, FFTamplitude)
        # plt.plot(peak_freq, peak_amplitude, 'bo')
        # plt.plot(peak_freq, peak_weighted, 'ro')

        # time.sleep(1)
        #print(FFTfreq, FFTamplitude)

等待正在运行的线程完成它们的循环

bluetooth_server.connect_device_thread.join()
    print("bluetooth_server is closed")
    signal_processing.heart_rate_thread.join()  # 心率线程
    print('Heart rate thread is closed')
    signal_processing.schmittTrigger_thread.join() # 施密特触发器呼吸线程
    print("signal_processing is closed")
    data_acquisition.join()
    print("data_acquisition is closed")

    print('Shut down succeed')
    #subprocess.call(["sudo", "shutdown", "-r", "now"])         # 关闭树莓派的终端命令Pi施密特触发器线程
    os.system("sudo shutdown -h now")


if __name__ == "__main__":      # 使主方法成为使用的主方法所必需的
    main()