#!/usr/bin/env python3 # -*-coding:utf-8-*- # SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD # SPDX-License-Identifier: Apache-2.0 # # WARNING: we don't check for Python build-time dependencies until # check_environment() function below. If possible, avoid importing # any external libraries here - put in external script, or import in # their specific function instead. import sys import csv import json import re import os import argparse import pandas as pd import numpy as np import serial from os import path from os import mkdir from io import StringIO from PyQt5.Qt import * from pyqtgraph import PlotWidget from PyQt5 import QtCore import pyqtgraph as pq from PyQt5.QtCore import QDate, QDate, QTime, QDateTime import threading import base64 import time from datetime import datetime from multiprocessing import Process, Queue from PyQt5.QtWidgets import QApplication, QMainWindow, QMessageBox # from PyQt5.QtChart import QChart, QLineSeries,QValueAxis from esp_csi_tool_gui import Ui_MainWindow from scipy import signal import signal as signal_key import socket CSI_SAMPLE_RATE = 100 # Remove invalid subcarriers # secondary channel : below, HT, 40 MHz, non STBC, v, HT-LTF: 0~63, -64~-1, 384 CSI_VAID_SUBCARRIER_INTERVAL = 5 csi_vaid_subcarrier_index = [] csi_vaid_subcarrier_color = [] color_step = 255 // (28 // CSI_VAID_SUBCARRIER_INTERVAL + 1) # LLTF: 52 # 26 red csi_vaid_subcarrier_index += [i for i in range( 0, 26, CSI_VAID_SUBCARRIER_INTERVAL)] csi_vaid_subcarrier_color += [(i * color_step, 0, 0) for i in range(1, 26 // CSI_VAID_SUBCARRIER_INTERVAL + 2)] # 26 green csi_vaid_subcarrier_index += [i for i in range( 26, 52, CSI_VAID_SUBCARRIER_INTERVAL)] csi_vaid_subcarrier_color += [(0, i * color_step, 0) for i in range(1, 26 // CSI_VAID_SUBCARRIER_INTERVAL + 2)] DEVICE_INFO_COLUMNS_NAMES = ['type', 'timestamp', 'compile_time', 'chip_name', 'chip_revision', 'app_revision', 'idf_revision', 'total_heap', 'free_heap', 'router_ssid', 'ip', 'port'] g_device_info_series = None CSI_DATA_INDEX = 500 # buffer size CSI_DATA_COLUMNS = len(csi_vaid_subcarrier_index) CSI_DATA_COLUMNS_NAMES = ['type', 'seq', 'timestamp', 'taget_seq', 'taget', 'mac', 'rssi', 'rate', 'sig_mode', 'mcs', 'cwb', 'smoothing', 'not_sounding', 'aggregation', 'stbc', 'fec_coding','sgi', 'noise_floor', 'ampdu_cnt', 'channel_primary', 'channel_secondary', 'local_timestamp', 'ant', 'sig_len', 'rx_state', 'agc_gain', 'fft_gain', 'len', 'first_word_invalid', 'data'] CSI_DATA_TARGETS = ['unknown', 'train', 'none', 'someone', 'static', 'move', 'front', 'after', 'left', 'right', 'go', 'jump', 'sit down', 'stand up', 'climb up', 'wave', 'applause'] RADAR_DATA_COLUMNS_NAMES = ['type', 'seq', 'timestamp', 'waveform_wander', 'wander_average', 'waveform_wander_threshold', 'someone_status', 'waveform_jitter', 'jitter_midean', 'waveform_jitter_threshold', 'move_status'] g_csi_amplitude_array = np.zeros( [CSI_DATA_INDEX, CSI_DATA_COLUMNS], dtype=np.int32) g_rssi_array = np.zeros(CSI_DATA_INDEX, dtype=np.int8) # 使用 object 类型以支持混合数据类型（字符串、数字、时间戳等） g_radio_header_pd = pd.DataFrame(np.empty([10, len( CSI_DATA_COLUMNS_NAMES[1:-1])], dtype=object), columns=CSI_DATA_COLUMNS_NAMES[1:-1]) RADAR_STATUS_RECORD = ['room', 'human', 'spend_time', 'start_time', 'stop_time'] g_status_record_pd = pd.DataFrame(np.zeros( [20, len(RADAR_STATUS_RECORD)], dtype=np.str_), columns=RADAR_STATUS_RECORD) RADAR_MOVE_RECORD = ['date', 'hour', 'minute', 'second', 'count'] g_move_record_pd = pd.DataFrame(columns=RADAR_MOVE_RECORD) RADAR_DATA = ['status', 'threshold', 'value', 'max', 'min', 'mean', 'std'] g_radar_data_room_pd = pd.DataFrame( np.zeros([10, len(RADAR_DATA)], dtype=np.float32), columns=RADAR_DATA) g_radar_data_human_pd = pd.DataFrame( np.zeros([10, len(RADAR_DATA)], dtype=np.float32), columns=RADAR_DATA) g_current_time = QDateTime.currentDateTime() RADAR_DATA_INDEX = 100 # buffer size ROOM_STATUS_NAMES = ['none', 'someone'] HUMAN_STATUS_NAMES = ['static', 'move'] RADAR_WAVEFORM_NAMES = ['wander', 'jitter'] RADAR_targetS_NAMES = ['someone', 'move'] RADAR_targetS_LEN = len(RADAR_targetS_NAMES) g_radar_eigenvalue_color = [(0, 0, 255), (0, 255, 0)] g_radar_eigenvalue_threshold_color = [(255, 255, 0), (255, 0, 255)] g_radar_eigenvalue_array = np.zeros( [RADAR_DATA_INDEX, RADAR_targetS_LEN], dtype=np.float32) g_radar_eigenvalue_threshold_array = np.zeros( [RADAR_DATA_INDEX, RADAR_targetS_LEN], dtype=np.float32) g_radar_status_array = np.zeros( [RADAR_DATA_INDEX, RADAR_targetS_LEN], dtype=np.int32) g_evaluate_statistics_array = np.zeros( [RADAR_targetS_LEN, RADAR_targetS_LEN], dtype=np.int32) g_display_raw_data = False g_display_radar_model = False g_display_eigenvalues_table = False def base64_decode_bin(str_data): try: # 清理数据：移除换行符、回车符、空格等无效字符 str_data = str(str_data).strip().replace('\n', '').replace('\r', '').replace(' ', '') # 如果数据包含日志信息（如 "->valid_len: 104"），只取 base64 部分 # 使用更智能的方式检测日志信息：查找常见的日志模式 # 例如：">valid_len", ": 104", "(120933)" 等 log_patterns = [ r'->valid_len', r':\s*\d+', # 冒号后跟数字（如 ": 104"） r'\(\d+\)', # 括号中的数字（如 "(120933)"） r'[DIWE]\s*\(', # 日志级别（如 "I ("） ] # 查找日志模式的起始位置，只保留 base64 部分 min_log_start = len(str_data) for pattern in log_patterns: import re match = re.search(pattern, str_data) if match: min_log_start = min(min_log_start, match.start()) # 如果找到日志信息，只保留 base64 部分（至少保留一定长度，避免误判） if min_log_start < len(str_data) and min_log_start > 10: str_data = str_data[:min_log_start] # 如果数据长度不是4的倍数，尝试添加填充 missing_padding = len(str_data) % 4 if missing_padding: str_data += '=' * (4 - missing_padding) bin_data = base64.b64decode(str_data, validate=True) except Exception as e: print(f'Exception: {e}, data: {str_data[:100]}') # 解码失败时返回空列表，避免后续错误 return [] list_data = list(bin_data) for i in range(len(list_data)): if list_data[i] > 127: list_data[i] = list_data[i] - 256 return list_data def base64_encode_bin(list_data): for i in range(len(list_data)): if list_data[i] < 0: list_data[i] = 256 + list_data[i] # print(list_data) str_data = 'test' try: str_data = base64.b64encode(bytes(list_data)).decode('utf-8') except Exception as e: print(f'Exception: {e}, data: {list_data}') return str_data def get_label(folder_path): parts = str.split(folder_path, os.path.sep) return parts[-1] def evaluate_data_send(serial_queue_write, folder_path): label = get_label(folder_path) if label == 'train': command = f'radar --train_start' serial_queue_write.put(command) tcpCliSock = socket.socket() device_info_series = pd.read_csv('log/device_info.csv').iloc[-1] print(f"connect:{device_info_series['ip']},{device_info_series['port']}") tcpCliSock.connect((device_info_series['ip'], device_info_series['port'])) file_name_list = sorted(os.listdir(folder_path)) print(file_name_list) for file_name in file_name_list: file_path = folder_path + os.path.sep + file_name data_pd = pd.read_csv(file_path) for index, data_series in enumerate(data_pd.iloc): csi_raw_data = json.loads(data_series['data']) data_pd.loc[index, 'data'] = base64_encode_bin(csi_raw_data) temp_list = base64_decode_bin(data_pd.loc[index, 'data']) # print(f"temp_list: {temp_list}") data_str = ','.join(str(value) for value in data_pd.loc[index]) + '\n' data_str = data_str.encode('utf-8') # print(f"data_str: {data_str}") tcpCliSock.send(data_str) tcpCliSock.close() time.sleep(1) if label == 'train': command = 'radar --train_stop' serial_queue_write.put(command) sys.exit(0) class DataGraphicalWindow(QMainWindow, Ui_MainWindow): def __init__(self, serial_queue_write, csi_output_type='LLTF', parent=None): super(DataGraphicalWindow, self).__init__(parent) self.setupUi(self) self.csi_output_type = csi_output_type global g_display_raw_data global g_display_radar_model global display_eigenvalues_table with open('./config/gui_config.json') as file: gui_config = json.load(file) # print(f"gui_config: {gui_config}") if len(gui_config['router_ssid']) > 0: self.lineEdit_router_ssid.setText(gui_config['router_ssid']) if len(gui_config['router_password']) >= 8: self.lineEdit_router_password.setText( gui_config['router_password']) g_display_raw_data = gui_config['display_raw_data'] if g_display_raw_data: self.checkBox_raw_data.setChecked(True) else: self.checkBox_raw_data.setChecked(False) g_display_radar_model = gui_config['display_radar_model'] if g_display_radar_model: self.checkBox_radar_model.setChecked(True) else: self.checkBox_radar_model.setChecked(False) g_display_eigenvalues_table = gui_config['display_eigenvalues_table'] if g_display_eigenvalues_table: self.checkBox_display_eigenvalues_table.setChecked(True) else: self.checkBox_display_eigenvalues_table.setChecked(False) if gui_config['router_auto_connect']: self.checkBox_router_auto_connect.setChecked(True) else: self.checkBox_router_auto_connect.setChecked(False) self.curve_subcarrier_range = np.array([10, 20]) self.graphicsView_subcarrier.setYRange( self.curve_subcarrier_range[0], self.curve_subcarrier_range[1]) self.graphicsView_subcarrier.addLegend() self.curve_subcarrier = [] self.serial_queue_write = serial_queue_write for i in range(CSI_DATA_COLUMNS): curve = self.graphicsView_subcarrier.plot( g_csi_amplitude_array[:, i], name=str(i), pen=csi_vaid_subcarrier_color[i]) self.curve_subcarrier.append(curve) self.curve_rssi = self.graphicsView_rssi.plot( g_rssi_array, name='rssi', pen=(255, 255, 255)) self.wave_filtering_flag = self.checkBox_wave_filtering.isCheckable() self.checkBox_wave_filtering.released.connect( self.show_curve_subcarrier_filter) # self.graphicsView_rssi.setYRange(-10, -65) self.checkBox_router_auto_connect.released.connect( self.show_router_auto_connect) self.curve_radar_eigenvalue = [] self.curve_radar_eigenvalue_threshold = [] # self.graphicsView_eigenvalues.setYRange(0.95, 1.0) self.graphicsView_eigenvalues.addLegend() self.graphicsView_eigenvalues.showGrid(x=True, y=True) self.dateTimeEdit_statistics_time.setDateTime(g_current_time) self.statistic_config = pd.Series(index=['time', 'mode', 'auto_update'], data=[ self.dateTimeEdit_statistics_time.dateTime().toPyDateTime(), self.comboBox_statistics_mode.currentText(), self.checkBox_statistics_auto_update.isChecked() ]) for i in range(RADAR_targetS_LEN): curve_eigenvalue = self.graphicsView_eigenvalues.plot( g_radar_eigenvalue_array[:, i], name=RADAR_WAVEFORM_NAMES[i], pen=g_radar_eigenvalue_color[i]) curve_eigenvalue_threshold = self.graphicsView_eigenvalues.plot( g_radar_eigenvalue_threshold_array[:, i], name=RADAR_WAVEFORM_NAMES[i] + '_' + RADAR_targetS_NAMES[i] + '_threshold', pen=g_radar_eigenvalue_threshold_color[i]) self.curve_radar_eigenvalue.append(curve_eigenvalue) self.curve_radar_eigenvalue_threshold.append( curve_eigenvalue_threshold) self.model_radio_header = QStandardItemModel( 1, len(g_radio_header_pd.columns.values)) self.model_radio_header.setHorizontalHeaderLabels( g_radio_header_pd.columns.values) self.tableView_radioHeader.setModel(self.model_radio_header) self.tableView_radioHeader.horizontalHeader( ).setSectionResizeMode(QHeaderView.ResizeToContents) self.tableView_values = { 'sig_mode': ['non HT(11bg)', 'HT(11n)', 'VHT(11ac)'], 'mcs': [f'MSC{i}' for i in range(76)], 'cwb': ['20MHz', '40MHz'], 'aggregation': ['MPDU', 'AMPDU'], 'channel_secondary': ['none', 'above', 'below'], 'stbc': ['non STBC', 'STBC'], 'sgi': ['Long GI', 'Short GI'], } self.model_device_info = QStandardItemModel( len(DEVICE_INFO_COLUMNS_NAMES), 2) self.tableView_device_info.setModel(self.model_device_info) self.tableView_device_info.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents) self.tableView_device_info.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents) self.model_status_record = QStandardItemModel( 1, len(g_status_record_pd.columns.values)) self.model_status_record.setHorizontalHeaderLabels( g_status_record_pd.columns.values) self.tableView_status_record.setModel(self.model_status_record) self.tableView_status_record.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents) self.tableView_status_record.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents) self.model_radar_data_room = QStandardItemModel(len( g_radar_data_room_pd.columns.values), len(g_radar_data_room_pd.columns.values)) self.model_radar_data_room.setHorizontalHeaderLabels(g_radar_data_room_pd.columns.values) self.tableView_radar_data_room.setModel(self.model_radar_data_room) self.tableView_radar_data_room.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents) self.model_radar_data_human = QStandardItemModel(len( g_radar_data_human_pd.columns.values), len(g_radar_data_human_pd.columns.values)) self.model_radar_data_human.setHorizontalHeaderLabels( g_radar_data_human_pd.columns.values) self.tableView_radar_data_human.setModel(self.model_radar_data_human) self.tableView_radar_data_human.horizontalHeader( ).setSectionResizeMode(QHeaderView.ResizeToContents) evaluate_STATISTICS_COLUMNS_NAMES = ['type', 'count', 'rate'] self.model_evaluate_statistics = QStandardItemModel( len(evaluate_STATISTICS_COLUMNS_NAMES), 3) self.model_evaluate_statistics.setHorizontalHeaderLabels( evaluate_STATISTICS_COLUMNS_NAMES) self.model_evaluate_statistics.setItem( 0, 0, QStandardItem('none static')) self.model_evaluate_statistics.setItem(1, 0, QStandardItem('none move')) self.model_evaluate_statistics.setItem( 2, 0, QStandardItem('someone static')) self.model_evaluate_statistics.setItem( 3, 0, QStandardItem('someone move')) self.pushButton_predict_config.released.connect(self.command_predict_config) self.pushButton_statistics_config.released.connect( self.show_statistics_status_record_move) self.comboBox_statistics_mode.activated.connect( self.show_statistics_status_record_move) # self.pushButton_evaluate_config.released.connect(self.command_evaluate_config) self.pushButton_router_connect.released.connect( self.command_router_connect) self.pushButton_command.released.connect(self.command_custom) self.comboBox_command.activated.connect(self.comboBox_command_show) self.pushButton_collect_start.released.connect( self.pushButton_collect_show) self.pushButton_train_start.released.connect( self.pushButton_train_show) self.pushButton_collect_clean.released.connect( self.pushButton_collect_clean_show) self.checkBox_raw_data.released.connect(self.checkBox_raw_data_show) self.checkBox_radar_model.released.connect(self.checkBox_radar_model_show) self.checkBox_display_eigenvalues_table.released.connect( self.checkBox_display_eigenvalues_table_show) self.splitter_eigenvalues.setStretchFactor(0, 8) self.splitter_eigenvalues.setStretchFactor(1, 1) self.splitter_status_record.setStretchFactor(0, 10) self.splitter_status_record.setStretchFactor(1, 1) self.splitter_raw_data.setStretchFactor(0, 1) self.splitter_raw_data.setStretchFactor(1, 8) self.splitter_raw_data.setStretchFactor(2, 2) self.textBrowser_log.setStyleSheet('background:black') self.timer_boot_command = QTimer() self.timer_boot_command.timeout.connect(self.command_boot) self.timer_boot_command.setInterval(3000) self.timer_boot_command.start() self.timer_curve_subcarrier = QTimer() self.timer_curve_subcarrier.timeout.connect(self.show_curve_subcarrier) self.timer_curve_subcarrier.setInterval(300) self.timer_curve_radar = QTimer() self.timer_curve_radar.timeout.connect(self.show_curve_eigenvalue) self.timer_curve_radar.setInterval(100) self.timer_eigenvalues_table = QTimer() self.timer_eigenvalues_table.timeout.connect( self.show_eigenvalue_table) self.timer_eigenvalues_table.setInterval(100) self.label_number = self.spinBox_collect_number.value() self.timer_collect_duration = QTimer() self.timer_collect_duration.timeout.connect( self.spinBox_collect_number_show) self.label_delay = self.timeEdit_collect_delay.time() self.timer_collect_delay = QTimer() self.timer_collect_delay.setInterval(1000) self.timer_collect_delay.timeout.connect(self.timeEdit_collect_delay_show) self.train_duration = self.timeEdit_train_duration.time() self.timer_train_duration = QTimer() self.timer_train_duration.setInterval(1000) self.timer_train_duration.timeout.connect( self.spinBox_train_duration_show) self.train_delay = self.timeEdit_train_delay.time() self.timer_train_delay = QTimer() self.timer_train_delay.setInterval(1000) self.timer_train_delay.timeout.connect(self.timeEdit_train_delay_show) self.timer_status_record = QTimer() self.timer_status_record.timeout.connect(self.show_statistics_status_record) self.timer_status_record.setInterval(1000) self.timer_evaluate_statistics = QTimer() self.timer_evaluate_statistics.timeout.connect(self.show_evaluate_statistics) self.timer_evaluate_statistics.setInterval(1000) self.checkBox_raw_data_show() self.checkBox_radar_model_show() self.checkBox_display_eigenvalues_table_show() def checkBox_raw_data_show(self): global g_display_raw_data g_display_raw_data = self.checkBox_raw_data.isChecked() if self.checkBox_raw_data.isChecked(): self.groupBox_raw_data.show() self.timer_curve_subcarrier.start() else: self.groupBox_raw_data.hide() self.timer_curve_subcarrier.stop() with open('./config/gui_config.json', 'r') as file: gui_config = json.load(file) gui_config['display_raw_data'] = self.checkBox_raw_data.isChecked() with open('./config/gui_config.json', 'w') as file: json.dump(gui_config, file) def checkBox_radar_model_show(self): global g_display_radar_model g_display_radar_model = self.checkBox_radar_model.isChecked() if self.checkBox_radar_model.isChecked(): self.groupBox_radar_model.show() self.timer_status_record.start() self.timer_curve_radar.start() else: self.groupBox_radar_model.hide() self.timer_status_record.stop() self.timer_curve_radar.stop() with open('./config/gui_config.json', 'r') as file: gui_config = json.load(file) gui_config['display_radar_model'] = self.checkBox_radar_model.isChecked() with open('./config/gui_config.json', 'w') as file: json.dump(gui_config, file) def checkBox_display_eigenvalues_table_show(self): global g_display_eigenvalues_table g_display_eigenvalues_table = self.checkBox_display_eigenvalues_table.isChecked() if self.checkBox_display_eigenvalues_table.isChecked(): self.tableView_eigenvalues.show() self.timer_eigenvalues_table.start() else: self.tableView_eigenvalues.hide() self.timer_eigenvalues_table.stop() with open('./config/gui_config.json', 'r') as file: gui_config = json.load(file) gui_config['display_eigenvalues_table'] = self.checkBox_display_eigenvalues_table.isChecked() with open('./config/gui_config.json', 'w') as file: json.dump(gui_config, file) def show_router_auto_connect(self): with open('./config/gui_config.json', 'r') as file: gui_config = json.load(file) gui_config['router_auto_connect'] = self.checkBox_router_auto_connect.isChecked() with open('./config/gui_config.json', 'w') as file: json.dump(gui_config, file) def median_filtering(self, waveform): tmp = waveform for i in range(1, waveform.shape[0] - 1): outliers_count = 0 for j in range(waveform.shape[1]): if ((waveform[i - 1, j] - waveform[i, j] > 2 and waveform[i + 1, j] - waveform[i, j] > 2) or (waveform[i - 1, j] - waveform[i, j] < -2 and waveform[i + 1, j] - waveform[i, j] < -2)): outliers_count += 1 continue if outliers_count > 16: for x in range(1, waveform.shape[1] - 1): tmp[i, x] = (waveform[i - 1, x] + waveform[i + 1, x]) / 2 waveform = tmp def show_curve_subcarrier(self): wn = 20 / (CSI_SAMPLE_RATE / 2) b, a = signal.butter(8, wn, 'lowpass') if self.wave_filtering_flag: self.median_filtering(g_csi_amplitude_array) csi_filtfilt_data = signal.filtfilt(b, a, g_csi_amplitude_array.T).T else: csi_filtfilt_data = g_csi_amplitude_array if self.curve_subcarrier_range[0] > csi_filtfilt_data.min() or self.curve_subcarrier_range[1] < csi_filtfilt_data.max(): if csi_filtfilt_data.min() > 0 and self.curve_subcarrier_range[0] > csi_filtfilt_data.min(): self.curve_subcarrier_range[0] = csi_filtfilt_data.min() - 1 if self.curve_subcarrier_range[1] < csi_filtfilt_data.max(): self.curve_subcarrier_range[1] = csi_filtfilt_data.max() + 1 self.graphicsView_subcarrier.setYRange( self.curve_subcarrier_range[0], self.curve_subcarrier_range[1]) for i in range(CSI_DATA_COLUMNS): self.curve_subcarrier[i].setData(csi_filtfilt_data[:, i]) if self.wave_filtering_flag: csi_filtfilt_rssi = signal.filtfilt( b, a, g_rssi_array).astype(np.int32) else: csi_filtfilt_rssi = g_rssi_array self.curve_rssi.setData(csi_filtfilt_rssi) for i in range(g_radio_header_pd.shape[0]): for j in range(g_radio_header_pd.shape[1]): cell_value = g_radio_header_pd.iloc[i, j] if cell_value is None or (isinstance(cell_value, float) and np.isnan(cell_value)): item = QStandardItem('') elif g_radio_header_pd.columns.values[j] in self.tableView_values.keys(): try: str_values = self.tableView_values[g_radio_header_pd.columns.values[j]][int(cell_value)] item = QStandardItem(str_values) except (ValueError, TypeError, KeyError): item = QStandardItem(str(cell_value)) else: # print(j, g_radio_header_pd.columns.values[j]) item = QStandardItem(str(cell_value) if cell_value is not None else '') self.model_radio_header.setItem(i, j, item) def show_curve_subcarrier_filter(self): self.wave_filtering_flag = self.checkBox_wave_filtering.isChecked() def show_curve_eigenvalue(self): for i in range(RADAR_targetS_LEN): self.curve_radar_eigenvalue[i].setData( g_radar_eigenvalue_array[:, i]) self.curve_radar_eigenvalue_threshold[i].setData( g_radar_eigenvalue_threshold_array[:, i]) curve_radar_title = f'{ROOM_STATUS_NAMES[g_radar_status_array[-1,0]]} {HUMAN_STATUS_NAMES[g_radar_status_array[-1,1]]}' self.graphicsView_eigenvalues.setTitle(curve_radar_title) def show_eigenvalue_table(self): for i in range(g_radar_data_room_pd.shape[0]): for j in range(g_radar_data_room_pd.shape[1]): # data_str = "%.5f" % 0.01 # print(f"{g_radar_data_room_pd.iloc[i,j]}, {type(g_radar_data_room_pd.iloc[i,j])}") data_str = '%.5f' % g_radar_data_room_pd.iloc[i, j] item = QStandardItem(data_str) self.model_radar_data_room.setItem(i, j, item) for i in range(g_radar_data_human_pd.shape[0]): for j in range(g_radar_data_human_pd.shape[1]): # print(f"{g_radar_data_human_pd.iloc[i,j]}, {type(g_radar_data_human_pd.iloc[i,j])}") data_str = '%.5f' % g_radar_data_human_pd.iloc[i, j] item = QStandardItem(data_str) self.model_radar_data_human.setItem(i, j, item) def show_device_info(self, device_info_series): # print(device_info_series) for i in range(len(device_info_series)): self.model_device_info.setItem( i, 0, QStandardItem(device_info_series.index[i])) self.model_device_info.setItem( i, 1, QStandardItem(str(device_info_series.values[i]))) # self.tableView_device_info.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents) def get_statistic_config(self): self.statistic_config['time'] = self.dateTimeEdit_statistics_time.dateTime().toPyDateTime() self.statistic_config['mode'] = self.comboBox_statistics_mode.currentText() self.statistic_config['auto_update'] = self.checkBox_statistics_auto_update.isChecked() def show_statistics_status_record_move(self): self.get_statistic_config() if self.statistic_config['mode'] == 'day': statistic_move_array = np.zeros(24, dtype=np.int32) statistic_move_title = datetime.strftime( self.statistic_config['time'], '%Y-%m-%d') statistic_move_pd = g_move_record_pd[g_move_record_pd['date'] == self.statistic_config['time'].date()] if len(statistic_move_pd): statistic_move_hour = statistic_move_pd.groupby(by='hour')[ 'count'].sum() for index, value in statistic_move_hour.items(): statistic_move_array[index] = value elif self.statistic_config['mode'] == 'hour': statistic_move_array = np.zeros(60, dtype=np.int32) statistic_move_title = datetime.strftime( self.statistic_config['time'], '%Y-%m-%d %H') statistic_move_pd = g_move_record_pd[(g_move_record_pd['date'] == self.statistic_config['time'].date()) & ( g_move_record_pd['hour'] == self.statistic_config['time'].time().hour)] if len(statistic_move_pd): statistic_move_minute = statistic_move_pd.groupby(by='minute')[ 'count'].sum() for index, value in statistic_move_minute.items(): statistic_move_array[index] = value elif self.statistic_config['mode'] == 'minute': statistic_move_array = np.zeros(60, dtype=np.int32) statistic_move_title = datetime.strftime( self.statistic_config['time'], '%Y-%m-%d %H:%M') statistic_move_pd = g_move_record_pd[(g_move_record_pd['date'] == self.statistic_config['time'].date()) & (g_move_record_pd['hour'] == self.statistic_config['time'].time().hour) & (g_move_record_pd['hour'] == self.statistic_config['time'].time().hour) & (g_move_record_pd['hour'] == self.statistic_config['time'].time().hour) & (g_move_record_pd['minute'] == self.statistic_config['time'].time().minute)] if len(statistic_move_pd): statistic_move_second = statistic_move_pd.groupby(by='second')[ 'count'].sum() for index, value in statistic_move_second.items(): statistic_move_array[index] = value else: print(f"fail mode: {self.statistic_config['mode']}") try: self.graphicsView_status_record.removeItem(self.bg) except Exception as e: # print(e) pass try: self.bg = pq.BarGraphItem(x=range( len(statistic_move_array)), height=statistic_move_array, width=0.3, brush='g') self.graphicsView_status_record.addItem(self.bg) self.graphicsView_status_record.showGrid(x=True, y=True) self.graphicsView_status_record.setXRange( 0, len(statistic_move_array)) # print(statistic_move_title) self.graphicsView_status_record.setTitle( statistic_move_title + ' Move Count') except Exception as e: print(e) def show_statistics_status_record(self): if self.checkBox_statistics_auto_update.isChecked(): self.dateTimeEdit_statistics_time.setDateTime(g_current_time) self.show_statistics_status_record_move() # print(f"g_status_record table: {g_status_record_pd.shape}") for i in range(g_status_record_pd.shape[0]): for j in range(g_status_record_pd.shape[1]): item = QStandardItem(g_status_record_pd.iloc[i, j]) self.model_status_record.setItem(i, j, item) def show_evaluate_statistics(self): if not g_evaluate_statistics_array.sum(): return for i in range(g_evaluate_statistics_array.shape[0]): for j in range(g_evaluate_statistics_array.shape[1]): row = i * 2 + j item = QStandardItem(str(g_evaluate_statistics_array[i][j])) self.model_evaluate_statistics.setItem(row, 1, item) data_str = '%.2f%%' % ( g_evaluate_statistics_array[i][j] * 100 / g_evaluate_statistics_array.sum()) item = QStandardItem(data_str) self.model_evaluate_statistics.setItem(row, 2, item) def command_boot(self): command = f'radar --csi_output_type {self.csi_output_type} --csi_output_format base64' self.serial_queue_write.put(command) if self.checkBox_router_auto_connect.isChecked() and len(self.lineEdit_router_ssid.text()) > 0: self.command_router_connect() self.timer_boot_command.stop() def command_predict_config(self): command = (f'radar --predict_someone_sensitivity {self.doubleSpinBox_predict_someone_sensitivity.value()}' + f' --predict_move_sensitivity {self.doubleSpinBox_predict_move_sensitivity.value()}') self.serial_queue_write.put(command) command = (f'radar --predict_buff_size {self.spinBox_predict_buffer_size.text()}' + f' --predict_outliers_number {self.spinBox_predict_outliers_number.text()}') self.serial_queue_write.put(command) def command_router_connect(self): if self.pushButton_router_connect.text() == 'connect': self.pushButton_router_connect.setText('disconnect') self.pushButton_router_connect.setStyleSheet('color: red') command = 'wifi_config --ssid ' + ("\"%s\"" % self.lineEdit_router_ssid.text()) if len(self.lineEdit_router_password.text()) >= 8: command += ' --password ' + self.lineEdit_router_password.text() self.serial_queue_write.put(command) else: self.pushButton_router_connect.setText('connect') self.pushButton_router_connect.setStyleSheet('color: black') command = 'ping --abort' self.serial_queue_write.put(command) command = 'wifi_config --disconnect' self.serial_queue_write.put(command) time.sleep(3) command = 'radar --csi_output_type ' + self.csi_output_type + ' --csi_output_format base64' self.serial_queue_write.put(command) with open('./config/gui_config.json', 'r') as file: gui_config = json.load(file) gui_config['router_ssid'] = self.lineEdit_router_ssid.text() gui_config['router_password'] = self.lineEdit_router_password.text() with open('./config/gui_config.json', 'w') as file: json.dump(gui_config, file) def command_custom(self): command = self.lineEdit_command.text() self.serial_queue_write.put(command) def command_collect_target_start(self): command = (f'radar --collect_number {self.spinBox_collect_number.value()}' + f' --collect_tagets {self.comboBox_collect_target.currentText()}' + f' --collect_duration {self.spinBox_collect_duration.value()}') self.serial_queue_write.put(command) def command_collect_target_stop(self): command = 'radar --collect_number 0 --collect_tagets unknown' self.serial_queue_write.put(command) def spinBox_collect_number_show(self): number = self.spinBox_collect_number.value() if number >= 1: self.spinBox_collect_number.setValue(number - 1) self.timer_collect_duration.start() # self.command_collect_target_start() else: self.timer_collect_duration.stop() # self.command_collect_target_stop() self.spinBox_collect_number.setValue(self.label_number) self.timeEdit_collect_delay.setTime(self.label_delay) self.pushButton_collect_start.setStyleSheet('color: black') self.spinBox_collect_number.setStyleSheet('color: black') self.pushButton_collect_start.setText('start') def timeEdit_collect_delay_show(self): time_temp = self.timeEdit_collect_delay.time() second = time_temp.hour() * 3600 + time_temp.minute() * 60 + time_temp.second() if second > 0: self.timeEdit_collect_delay.setTime(time_temp.addSecs(-1)) self.timer_collect_delay.start() else: self.timer_collect_delay.stop() duration = self.spinBox_collect_duration.value() self.timer_collect_duration.setInterval(duration) self.timer_collect_duration.start() self.command_collect_target_start() self.spinBox_collect_number.setStyleSheet('color: red') self.timeEdit_collect_delay.setStyleSheet('color: black') def pushButton_collect_show(self): if self.pushButton_collect_start.text() == 'start': if self.comboBox_collect_target.currentIndex() == 0 or self.spinBox_collect_number.value() == 0: err = QErrorMessage(self) err.setWindowTitle('Label parameter error') err.showMessage( "Please check whether 'taget' or 'number' is set") err.show() return self.pushButton_collect_start.setText('stop') self.pushButton_collect_start.setStyleSheet('color: red') self.timeEdit_collect_delay.setStyleSheet('color: red') self.timer_collect_delay.start() self.label_number = self.spinBox_collect_number.value() self.label_delay = self.timeEdit_collect_delay.time() else: self.spinBox_collect_number.setValue(self.label_number) self.timeEdit_collect_delay.setTime(self.label_delay) self.spinBox_collect_number.setStyleSheet('color: black') self.pushButton_collect_start.setStyleSheet('color: black') self.timer_collect_delay.stop() self.timer_collect_duration.stop() self.command_collect_target_stop() self.pushButton_collect_start.setText('start') def pushButton_collect_clean_show(self): folder_path = 'data' message = QMessageBox.warning( self, 'Warning', "will delete all files in 'data'", QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Ok) if message == QMessageBox.Cancel: return for root, dirs, files in os.walk(folder_path, topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) def command_train_start(self): command = f'radar --train_start' if self.checkBox_train_add.isChecked(): command += ' --train_add' self.serial_queue_write.put(command) def command_train_stop(self): command = 'radar --train_stop' self.serial_queue_write.put(command) def spinBox_train_duration_show(self): time_temp = self.timeEdit_train_duration.time() second = time_temp.hour() * 3600 + time_temp.minute() * 60 + time_temp.second() if second > 0: self.timeEdit_train_duration.setTime(time_temp.addSecs(-1)) self.timer_train_duration.start() else: self.timer_train_duration.stop() self.command_train_stop() self.timeEdit_train_delay.setTime(self.train_delay) self.timeEdit_train_duration.setTime(self.train_duration) self.timeEdit_train_duration.setStyleSheet('color: black') self.pushButton_train_start.setText('start') self.pushButton_train_start.setStyleSheet('color: black') def timeEdit_train_delay_show(self): time_temp = self.timeEdit_train_delay.time() second = time_temp.hour() * 3600 + time_temp.minute() * 60 + time_temp.second() if second > 0: self.timeEdit_train_delay.setTime(time_temp.addSecs(-1)) self.timer_train_delay.start() else: self.timer_train_delay.stop() self.command_train_start() self.spinBox_train_duration_show() self.timeEdit_train_duration.setStyleSheet('color: red') self.timeEdit_train_delay.setStyleSheet('color: black') def pushButton_train_show(self): if self.pushButton_train_start.text() == 'start': reply = QMessageBox.question(self, 'Note', 'During environmental calibration, it must be ensured that no one is in the room', QMessageBox.Yes | QMessageBox.Cancel, QMessageBox.Yes) if reply == QMessageBox.Cancel: return self.train_delay = self.timeEdit_train_delay.time() self.train_duration = self.timeEdit_train_duration.time() self.pushButton_train_start.setText('stop') self.pushButton_train_start.setStyleSheet('color: red') self.timeEdit_train_delay.setStyleSheet('color: red') self.timeEdit_train_delay_show() else: self.timer_train_delay.stop() self.timer_train_duration.stop() self.command_train_stop() self.timeEdit_train_delay.setTime(self.train_delay) self.timeEdit_train_duration.setTime(self.train_duration) self.pushButton_train_start.setText('start') self.pushButton_train_start.setStyleSheet('color: black') def comboBox_command_show(self): self.lineEdit_command.setText(self.comboBox_command.currentText()) def show_textBrowser_log(self, str): self.textBrowser_log.append(str) # self.textBrowser_log.moveCursor(self.textBrowser_log.textCursor().End) def closeEvent(self, event): self.serial_queue_write.put('exit') time.sleep(0.5) event.accept() try: os._exit(0) except Exception as e: print(f'GUI closeEvent: {e}') def csi_data_handle(self, data): # Rotate data g_csi_amplitude_array[:-1] = g_csi_amplitude_array[1:] g_rssi_array[:-1] = g_rssi_array[1:] g_radio_header_pd.iloc[1:] = g_radio_header_pd.iloc[:-1] csi_raw_data = data['data'] data_len = int(data['len']) if 'len' in data else len(csi_raw_data) if data_len == 104: for i in range(CSI_DATA_COLUMNS): idx = csi_vaid_subcarrier_index[i] if idx * 4 + 3 >= len(csi_raw_data): return real_high = csi_raw_data[idx * 4 + 1] imag_high = csi_raw_data[idx * 4 + 3] real_low = csi_raw_data[idx * 4] & 0xFF imag_low = csi_raw_data[idx * 4 + 2] & 0xFF real = (((int(real_high) << 12) >> 4) | real_low) imag = (((int(imag_high) << 12) >> 4) | imag_low) if real > 32767: real = real - 65536 if imag > 32767: imag = imag - 65536 g_csi_amplitude_array[-1][i] = np.abs(complex(real, imag)) else: for i in range(CSI_DATA_COLUMNS): if csi_vaid_subcarrier_index[i]*2+1 >= len(csi_raw_data): return g_csi_amplitude_array[-1][i] = np.abs(complex(csi_raw_data[csi_vaid_subcarrier_index[i]*2], csi_raw_data[csi_vaid_subcarrier_index[i]*2+1])) g_rssi_array[-1] = data['rssi'] g_radio_header_pd.loc[0] = data[1:len(CSI_DATA_COLUMNS_NAMES)-1] # print(g_radio_header_pd.loc[0]) return def radar_data_handle(self, data): g_radar_eigenvalue_array[:-1] = g_radar_eigenvalue_array[1:] g_radar_eigenvalue_threshold_array[:- 1] = g_radar_eigenvalue_threshold_array[1:] g_radar_status_array[:-1] = g_radar_status_array[1:] global g_current_time current_time_str = data['timestamp'] g_current_time = datetime.strptime( data['timestamp'], '%Y-%m-%d %H:%M:%S.%f') for taget_index in range(RADAR_targetS_LEN): g_radar_eigenvalue_array[-1][taget_index] = data[f'waveform_{RADAR_WAVEFORM_NAMES[taget_index]}'] g_radar_eigenvalue_threshold_array[-1][taget_index] = data[ f'waveform_{RADAR_WAVEFORM_NAMES[taget_index]}_threshold'] g_radar_status_array[-1][taget_index] = data[f'{RADAR_targetS_NAMES[taget_index]}_status'] if g_radar_status_array[-1][0] != g_radar_status_array[-2][0] or g_radar_status_array[-1][1] != g_radar_status_array[-2][1]: g_status_record_pd[1:] = g_status_record_pd[:-1] g_status_record_pd.loc[0, 'start_time'] = current_time_str g_status_record_pd.loc[0, 'room'] = ROOM_STATUS_NAMES[g_radar_status_array[-1][0]] g_status_record_pd.loc[0, 'human'] = HUMAN_STATUS_NAMES[g_radar_status_array[-1][1]] if len(g_status_record_pd.loc[1, 'start_time']): g_status_record_pd.loc[1, 'stop_time'] = current_time_str if len(g_status_record_pd.loc[0, 'start_time']): temp_time = g_current_time - \ datetime.strptime( g_status_record_pd.loc[0, 'start_time'], '%Y-%m-%d %H:%M:%S.%f') g_status_record_pd.loc[0, 'spend_time'] = f'{temp_time}'[:-3] if g_radar_status_array[-1][1]: index = len(g_move_record_pd) g_move_record_pd.loc[index] = [g_current_time.date(), g_current_time.time( ).hour, g_current_time.time().minute, g_current_time.time().second, 1] g_evaluate_statistics_array[g_radar_status_array[-1, 0], g_radar_status_array[-1, 1]] += 1 if (g_radar_eigenvalue_threshold_array[-1, 0] != g_radar_eigenvalue_threshold_array[-2, 0] or g_radar_eigenvalue_threshold_array[-1, 1] != g_radar_eigenvalue_threshold_array[-2, 1]): self.signal_wareform_threshold.emit() if g_display_eigenvalues_table: try: g_radar_data_room_pd[1:] = g_radar_data_room_pd[:-1] g_radar_data_room_pd.loc[0]['status'] = g_radar_status_array[-1, 0] g_radar_data_room_pd.loc[0]['threshold'] = g_radar_eigenvalue_threshold_array[-1, 0] g_radar_data_room_pd.loc[0]['value'] = g_radar_eigenvalue_array[-1, 0] value_buff = g_radar_eigenvalue_array[-10:, 0] g_radar_data_room_pd.loc[0]['max'] = np.max(value_buff) g_radar_data_room_pd.loc[0]['min'] = np.min(value_buff) g_radar_data_room_pd.loc[0]['mean'] = np.mean(value_buff) g_radar_data_room_pd.loc[0]['std'] = np.std(value_buff) g_radar_data_human_pd[1:] = g_radar_data_human_pd[:-1] g_radar_data_human_pd.loc[0]['status'] = g_radar_status_array[-1, 1] g_radar_data_human_pd.loc[0]['threshold'] = g_radar_eigenvalue_threshold_array[-1, 1] g_radar_data_human_pd.loc[0]['value'] = g_radar_eigenvalue_array[-1, 1] value_buff = g_radar_eigenvalue_array[-10:, 1] g_radar_data_human_pd.loc[0]['max'] = np.max(value_buff) g_radar_data_human_pd.loc[0]['min'] = np.min(value_buff) g_radar_data_human_pd.loc[0]['mean'] = np.mean(value_buff) g_radar_data_human_pd.loc[0]['std'] = np.std(value_buff) except Exception as e: print(e) return class DataHandleThread(QThread): signal_log_msg = pyqtSignal(str) signal_radar_time_domain = pyqtSignal(str) signal_exit = pyqtSignal() signal_device_info = pyqtSignal(pd.Series) signal_wareform_threshold = pyqtSignal() def __init__(self, serial_queue_read): super().__init__() self.serial_queue_read = serial_queue_read self.taget_count = 0 def run(self): while True: # print(f"g_display_raw_data: {g_display_raw_data}") series = self.serial_queue_read.get() if series['type'] == 'DEVICE_INFO' and g_display_raw_data: g_device_info_series = series.copy() self.signal_device_info.emit(series) elif series['type'] == 'CSI_DATA' and g_display_raw_data: csi_data_handle(self, series) elif series['type'] == 'RADAR_DADA' and g_display_radar_model: radar_data_handle(self, series) elif series['type'] == 'LOG_DATA' and g_display_raw_data: if series['tag'] == 'I': color = 'green' elif series['tag'] == 'W': color = 'yellow' elif series['tag'] == 'E': color = 'red' else: color = 'white' data = "%s (%s) %s " % ( color, series['tag'], series['timestamp'], series['data']) self.signal_log_msg.emit(data) elif series['type'] == 'FAIL_EVENT': print(f"Failed: {series['data']}") self.signal_exit.emit() time.sleep(1) sys.exit(0) else: # print("error: ", series) pass QApplication.processEvents() def serial_handle(queue_read, queue_write, port): try: set = serial.Serial(port=port, baudrate=2000000, bytesize=8, parity='N', stopbits=1, timeout=0.1) except Exception as e: print(f'serial_handle: {e}') data_series = pd.Series(index=['type', 'data'], data=['FAIL_EVENT', 'Failed to open serial port']) queue_read.put(data_series) sys.exit() return print('open serial port: ', port) # Wait a second to let the port initialize set.flushInput() folder_list = ['log', 'data'] for folder in folder_list: if not path.exists(folder): mkdir(folder) data_valid_list = pd.DataFrame(columns=['type', 'columns_names', 'file_name', 'file_fd', 'file_writer'], data=[['CSI_DATA', CSI_DATA_COLUMNS_NAMES, 'log/csi_data.csv', None, None], ['RADAR_DADA', RADAR_DATA_COLUMNS_NAMES, 'log/radar_data.csv', None, None], ['DEVICE_INFO', DEVICE_INFO_COLUMNS_NAMES, 'log/device_info.csv', None, None]]) for data_valid in data_valid_list.iloc: # print(type(data_valid), data_valid) # print(f"file_name: {data_valid['file_name']}") data_valid['file_fd'] = open(data_valid['file_name'], 'w') data_valid['file_writer'] = csv.writer(data_valid['file_fd']) data_valid['file_writer'].writerow(data_valid['columns_names']) log_data_writer = open('log/log_data.txt', 'w+') taget_last = 'unknown' taget_seq_last = 0 set.write('restart\r\n'.encode('utf-8')) time.sleep(0.01) while True: if not queue_write.empty(): command = queue_write.get() if command == 'exit': sys.exit() break command = command + '\r\n' set.write(command.encode('utf-8')) print(f'{datetime.now()}, serial write: {command}') continue try: strings = str(set.readline()) if not strings: continue except Exception as e: data_series = pd.Series(index=['type', 'data'], data=['FAIL_EVENT', 'Failed to read serial']) queue_read.put(data_series) sys.exit() strings = strings.lstrip('b\'').rstrip('\\r\\n\'') if not strings: continue # print(f"fail: {strings}") for data_valid in data_valid_list.iloc: index = strings.find(data_valid['type']) if index >= 0: strings = strings[index:] # 只取第一行，避免日志信息混入 first_line_end = strings.find('\n') if first_line_end > 0: strings = strings[:first_line_end] # 移除可能的回车符 strings = strings.rstrip('\r') csv_reader = csv.reader(StringIO(strings)) try: data = next(csv_reader) except StopIteration: continue if len(data) == len(data_valid['columns_names']): # 清理 base64 数据字段（最后一个字段），移除可能的日志信息 if data_valid['type'] == 'CSI_DATA' and len(data) > 0: data_field = data[-1] # 使用正则表达式查找日志模式，只保留 base64 部分 log_patterns = [ r'->valid_len', r':\s*\d+', # 冒号后跟数字 r'\(\d+\)', # 括号中的数字 r'[DIWE]\s*\(', # 日志级别 ] min_log_start = len(data_field) for pattern in log_patterns: match = re.search(pattern, data_field) if match: min_log_start = min(min_log_start, match.start()) # 如果找到日志信息且位置合理（避免误判），只保留 base64 部分 if min_log_start < len(data_field) and min_log_start > 10: data[-1] = data_field[:min_log_start] data_series = pd.Series( data, index=data_valid['columns_names']) try: datetime.strptime( data_series['timestamp'], '%Y-%m-%d %H:%M:%S.%f') except Exception as e: data_series['timestamp'] = datetime.now().strftime( '%Y-%m-%d %H:%M:%S.%f')[:-3] # print(e) # print(data_series) if data_series['type'] == 'CSI_DATA': try: # csi_raw_data = json.loads(data_series['data']) csi_raw_data = base64_decode_bin( data_series['data']) # 如果解码失败返回空列表，跳过这条数据 if len(csi_raw_data) == 0: print(f"CSI_DATA decode failed, skipping data: {data_series['data'][:50]}...") break if len(csi_raw_data) != int(data_series['len']): # if len(csi_raw_data) != 104 and len(csi_raw_data) != 216 and len(csi_raw_data) != 328 and len(csi_raw_data) != 552: print( f"CSI_DATA, expected: {data_series['len']}, actual: {len(csi_raw_data)}") break except Exception as e: print( f"json.JSONDecodeError: {e}, data: {data_series['data']}") break data_series['data'] = csi_raw_data if data_series['taget'] != 'unknown': if data_series['taget'] != taget_last or data_series['taget_seq'] != taget_seq_last: folder = f"data/{data_series['taget']}" if not path.exists(folder): mkdir(folder) csi_target_data_file_name = f"{folder}/{datetime.now().strftime('%Y-%m-%d_%H-%M-%S-%f')[:-3]}_{data_series['len']}_{data_series['taget_seq']}.csv" print(csi_target_data_file_name) csi_target_data_file_fd = open( csi_target_data_file_name, 'w+') taget_data_writer = csv.writer( csi_target_data_file_fd) taget_data_writer.writerow(data_series.index) taget_data_writer.writerow( data_series.astype(str)) taget_last = data_series['taget'] taget_seq_last = data_series['taget_seq'] if queue_read.full(): # print('============== queue_full ==========') pass else: # print("data_series", len(data_series), type(data_series), data_series) queue_read.put(data_series) else: queue_read.put(data_series) data_valid['file_writer'].writerow(data_series.astype(str)) data_valid['file_fd'].flush() break else: strings = re.sub(r'\\x1b.*?m', '', strings) log_data_writer.writelines(strings + '\n') log = re.match(r'.*([DIWE]) \((\d+)\) (.*)', strings, re.I) if not log: continue data_series = pd.Series(index=['type', 'tag', 'timestamp', 'data'], data=['LOG_DATA', log.group(1), log.group(2), log.group(3)]) if not queue_read.full(): queue_read.put(data_series) def quit(signum, frame): print('Exit the system') sys.exit() if __name__ == '__main__': if sys.version_info < (3, 6): print(' Python version should >= 3.6') exit() parser = argparse.ArgumentParser( description='Read CSI data from serial port and display it graphically') parser.add_argument('-p', '--port', dest='port', action='store', required=True, help='Serial port number of csv_recv device') parser.add_argument('-t', '--csi_output_type', dest='csi_output_type', action='store', choices=['LLTF', 'HT_LTF', 'HE_LTF', 'STBC-HT-LTF', 'STBC-HE-LTF'], default='LLTF', help='CSI output type: LLTF, HT_LTF, HE_LTF, STBC-HT-LTF, or STBC-HE-LTF (default: LLTF)') args = parser.parse_args() serial_port = args.port csi_output_type = args.csi_output_type serial_queue_read = Queue(maxsize=64) serial_queue_write = Queue(maxsize=64) signal_key.signal(signal_key.SIGINT, quit) signal_key.signal(signal_key.SIGTERM, quit) serial_handle_process = Process(target=serial_handle, args=( serial_queue_read, serial_queue_write, serial_port)) serial_handle_process.start() app = QApplication(sys.argv) app.setWindowIcon(QIcon('../../../docs/_static/icon.png')) window = DataGraphicalWindow(serial_queue_write, csi_output_type) data_handle_thread = DataHandleThread(serial_queue_read) data_handle_thread.signal_device_info.connect(window.show_device_info) data_handle_thread.signal_log_msg.connect(window.show_textBrowser_log) data_handle_thread.signal_exit.connect(window.close) data_handle_thread.start() window.show() sys.exit(app.exec()) serial_handle_process.join()