import numpy as np import pandas as pd from typing import List import json from sqlalchemy import create_engine import math from app.config import dataBase from app.database import get_engine from app.logger import logger from app.services.DiagnosisLib import DiagnosisLib class Auto_diag: def __init__(self, ids: List[int], wind_code: str, engine_code: str): """ 初始化诊断类 参数: ids: 数据ID列表 wind_code: 风场编号 engine_code: 风机编号 """ self.ids = ids self.wind_code = wind_code self.engine_code = engine_code self.myDiagnosisLib = DiagnosisLib() self.diagnosis_results = [] # 存储所有诊断结果 self.bearing_frequencies = {} # 存储特征频率 self.teeth_count = {} # 存储齿数 # 从数据库加载振动数据 self.load_vibration_data() # 计算转速传动比 self.calculate_speed_ratio() # 提取轴承参数、齿轮参数 计算特征频率 self.Characteristic_Frequency() # 计算频谱 self.calculate_spectrums() def load_vibration_data(self): """从数据库中获取振动加速度数据""" try: engine = get_engine(dataBase.DATA_DB) with engine.connect() as conn: table_name = self.wind_code + '_wave' # 将所有id拼接到SQL语句中，一次性查询所有数据 ids_str = ','.join(map(str, self.ids)) sql = f"SELECT * FROM {table_name} WHERE id IN ({ids_str})" df = pd.read_sql(sql, conn) self.df_data = df # 提取公共参数 self.fspd = self.df_data['rotational_speed'].astype(float).values # 转速 self.fs_acc = self.df_data['sampling_frequency'].astype(float).values # 采样频率 self.mesure_point_names = self.df_data['mesure_point_name'].values # 处理加速度数据 self.Acc = [] self.t_acc = [] for i, row in self.df_data.iterrows(): measure_data_str = row['mesure_data'] try: measure_data_list = json.loads(measure_data_str) acc_data = np.array(measure_data_list, dtype=np.float32) except json.JSONDecodeError: stripped_str = measure_data_str.strip('[]') measure_data_list = [float(x.strip()) for x in stripped_str.split(',') if x.strip()] acc_data = np.array(measure_data_list, dtype=np.float32) self.Acc.append(acc_data) # 使用转换后的数值类型计算时间轴 self.t_acc.append(np.arange(0, len(acc_data) / self.fs_acc[i], 1 / self.fs_acc[i])) except Exception as e: raise Exception(f"Failed to load vibration data: {str(e)}") finally: engine.dispose() def calculate_spectrums(self): """计算各种频谱""" logger.info("计算频谱") self.fAcc = [] self.AccSpec = [] self.VelSpec = [] self.gE_10 = [] self.fAcc_gE = [] self.gESpec_10 = [] if self.fs_acc[0] < 12800: logger.info("当前采集频率不适合进行诊断分析") raise ValueError("当前采集频率不适合进行诊断分析") for i, acc in enumerate(self.Acc): # 获取当前 id 对应的采样频率 fs_acc = self.fs_acc[i] fmax_acc = fs_acc / 2.56 logger.info(fs_acc) logger.info(acc) lowcut = 500 # 最低值是固定的 /51.2 highcut = fs_acc / 2.56 # 计算振动加速度频谱 [f, spec] = self.myDiagnosisLib.Spectrum(acc, fs_acc) self.fAcc.append(f) self.AccSpec.append(spec) # 计算振动速度频谱 fCut = 0.1 vel_spec = self.myDiagnosisLib.FreqIntegration(spec, fmax_acc, fCut) self.VelSpec.append(vel_spec) # 计算加速度包络频谱 order = 6 acc_band = self.myDiagnosisLib.BandPassButter(acc, lowcut, highcut, fs_acc, order) fmax_gE_10 = 1000 DownSampleRate = int(fs_acc / 2.56 / fmax_gE_10) # 降采样 gE = self.myDiagnosisLib.EnvLopInTime(acc_band, DownSampleRate, Method="SKF") self.gE_10.append(gE) fs_gE_10 = 2.56 * fmax_gE_10 [f, spec] = self.myDiagnosisLib.Spectrum(gE, fs_gE_10) self.fAcc_gE.append(f) self.gESpec_10.append(spec) def Unbalance_diag(self): """不平衡诊断""" logger.info("不平衡诊断") status_codes = [] for i in range(len(self.ids)): ShaftSpd = self.fspd[i] * self.speed_ratio if ShaftSpd == 0: status_codes.append(-1) continue try: fs_acc = self.fs_acc[i] fmax_vel = 1000 # fmax_vel =max(1000,fs_acc/2.56) logger.info('ShaftSpd', ShaftSpd) fTarget = ShaftSpd / 60 logger.info('fTarget', fTarget) numHarmonics = 4 fRange = 0.05 fRangeMode = "Per" Detection = "RMS" logger.info(self.VelSpec[i]) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM', Vel_RunningSpd_HM) Vel_alert_mmsRMS = 4 # 速度报警阈值 Vel_danger_mmsRMS = 7 # 速度危险阈值 defectType = 'Unbalance' try: detection, severity = self.myDiagnosisLib.RunningSpd_Fault_Diag( Vel_RunningSpd_HM, Vel_alert_mmsRMS, Vel_danger_mmsRMS, defectType ) except Exception as e: detection = False severity = 0 logger.info("severity", severity) if not detection: status_code = 0 elif severity < 6: status_code = 1 else: status_code = 2 except Exception as e: status_code = 0 status_codes.append(status_code) logger.info("status_code", status_code) # 返回结果和统计信息 return { "type": "Unbalance", "results": status_codes, "statistics": { "max_status": max(status_codes), "count_0": status_codes.count(0), "count_1": status_codes.count(1), "count_2": status_codes.count(2) } } def Misalignment_diag(self): """不对中诊断""" status_codes = [] logger.info("不对中诊断") for i in range(len(self.ids)): ShaftSpd = self.fspd[i] * self.speed_ratio if ShaftSpd == 0: status_codes.append(-1) continue try: fs_acc = self.fs_acc[i] fmax_vel = 1000 # fmax_vel =max(1000,fs_acc/2.56) fTarget = ShaftSpd / 60 numHarmonics = 4 fRange = 0.05 fRangeMode = "Per" Detection = "RMS" logger.info('ShaftSpd', ShaftSpd) logger.info('fTarget', fTarget) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM', Vel_RunningSpd_HM) Vel_alert_mmsRMS = 4 # 速度报警阈值 Vel_danger_mmsRMS = 7 # 速度危险阈值 try: defectType = 'Misalignment' detection, severity = self.myDiagnosisLib.RunningSpd_Fault_Diag( Vel_RunningSpd_HM, Vel_alert_mmsRMS, Vel_danger_mmsRMS, defectType ) except Exception as e: detection = False severity = 0 logger.info('severity', severity) if not detection: status_code = 0 elif severity < 6: status_code = 1 else: status_code = 2 except Exception as e: status_code = 0 status_codes.append(status_code) return { "type": "Misalignment", "results": status_codes, "statistics": { "max_status": max(status_codes), "count_0": status_codes.count(0), "count_1": status_codes.count(1), "count_2": status_codes.count(2) } } def Looseness_diag(self): """松动诊断""" status_codes = [] logger.info("松动诊断") for i in range(len(self.ids)): ShaftSpd = self.fspd[i] * self.speed_ratio if ShaftSpd == 0: status_codes.append(-1) continue try: fs_acc = self.fs_acc[i] fmax_vel = 1000 # fmax_vel =max(1000,fs_acc/2.56) fTarget = ShaftSpd / 60 numHarmonics = 4 fRange = 0.05 fRangeMode = "Per" Detection = "RMS" logger.info('ShaftSpd', ShaftSpd) logger.info('fTarget', fTarget) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM', Vel_RunningSpd_HM) Vel_alert_mmsRMS = 4 # 速度报警阈值 Vel_danger_mmsRMS = 7 # 速度危险阈值 try: defectType = 'Looseness' detection, severity = self.myDiagnosisLib.RunningSpd_Fault_Diag( Vel_RunningSpd_HM, Vel_alert_mmsRMS, Vel_danger_mmsRMS, defectType ) except Exception as e: detection = False severity = 0 logger.info('severity', severity) if not detection: status_code = 0 elif severity < 6: status_code = 1 else: status_code = 2 except Exception as e: status_code = 0 status_codes.append(status_code) return { "type": "Looseness", "results": status_codes, "statistics": { "max_status": max(status_codes), "count_0": status_codes.count(0), "count_1": status_codes.count(1), "count_2": status_codes.count(2) } } def Bearing_diag(self): """轴承诊断""" logger.info("轴承诊断") # Vel_RunningSpd_HM，生成转频的1X-5X的倍频值 # VelSpec，振动速度频谱 # fmax_vel，最大分析频率 # fTarget，目标频率为转频 Vel_alert_mmsRMS = 4 # 速度总值预警阈值 （mm/s 有效值） Vel_danger_mmsRMS = 7 # 速度总值报警阈值 （mm/s 有效值） gE_alert = 3 # 包络总值预警阈值（gE） gE_danger = 10 # 包络总值报警阈值（gE） results = { "BPFO": {"status_codes": []}, "BPFI": {"status_codes": []}, "BSF": {"status_codes": []}, "FTF": {"status_codes": []} } # 获取第一个id的特征频率(所有id相同) id = self.ids[0] bearing_freq = self.bearing_frequencies.get(id, {}) BPFO = bearing_freq.get("BPFO", 0) BPFI = bearing_freq.get("BPFI", 0) BSF = bearing_freq.get("BSF", 0) FTF = bearing_freq.get("FTF", 0) for i in range(len(self.ids)): ShaftSpd = self.fspd[i] * self.speed_ratio if ShaftSpd == 0: results["BPFO"]["status_codes"].append(-1) results["BPFI"]["status_codes"].append(-1) results["BSF"]["status_codes"].append(-1) results["FTF"]["status_codes"].append(-1) continue fs_acc = self.fs_acc[i] # fmax_vel =1000 # fmax_vel如果直接取1000 还是会出现目标范围落不到搜寻范围的现象 fmax_vel = max(1000, fs_acc / 2.56) fRange = 0.05 fmax_gE_10 = 1000 try: """外圈故障诊断""" logger.info("外圈") fbr_BPFO = BPFO fTarget = fbr_BPFO # 在计算轴承特征频率的函数中已经乘过转速 if self.wind_code == 'WOF091200030': if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 1: fmax_gE_10 = 10 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 else: if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 10: fmax_gE_10 = 100 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 numHarmonics = 4 fRangeMode = "Per" Detection = "RMS" logger.info('BPFO', BPFO) logger.info('ShaftSpd', ShaftSpd) logger.info('speed_ratio', self.speed_ratio) logger.info('fTarget', fTarget) logger.info('VelSpec', self.VelSpec[i]) logger.info('gESpec_10', self.gESpec_10[i]) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature(self.VelSpec[i], fmax_vel, fTarget, fRange, \ fRangeMode, Detection, numHarmonics) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM\n', Vel_RunningSpd_HM) # 速度频谱特征 try: Vel_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_Bearing_Defect_HM 时出错: {e}") Vel_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('Vel_Bearing_Defect_HM\n', Vel_Bearing_Defect_HM) try: # 包络频谱特征 Detection = "Peak" gE_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 gE_Bearing_Defect_HM 时出错: {e}") gE_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('gE_Bearing_Defect_HM\n', gE_Bearing_Defect_HM) try: # 诊断外圈故障 BPFOdetection, BPFOseverity = self.myDiagnosisLib.Bearing_Fault_Diag( gE_Bearing_Defect_HM, Vel_Bearing_Defect_HM, Vel_RunningSpd_HM, gE_alert, gE_danger, Vel_alert_mmsRMS, Vel_danger_mmsRMS, 'BPFO' ) except Exception as e: BPFOdetection = False BPFOseverity = 0 logger.info("BPFOseverity", BPFOseverity) if not BPFOdetection: BPFOStatusCode = 0 elif BPFOseverity < 6: BPFOStatusCode = 1 else: BPFOStatusCode = 2 except Exception as e: BPFOStatusCode = 0 results["BPFO"]["status_codes"].append(BPFOStatusCode) try: """内圈故障诊断""" logger.info("内圈") fbr_BPFI = BPFI # fbr_BPFI = ShaftSpd * BPFI fTarget = fbr_BPFI if self.wind_code == 'WOF091200030': if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 1: fmax_gE_10 = 10 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 else: if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 10: fmax_gE_10 = 100 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 numHarmonics = 4 fRangeMode = "Per" Detection = "RMS" logger.info('BPFI', BPFI) logger.info('ShaftSpd', ShaftSpd) logger.info('fTarget', fTarget) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature(self.VelSpec[i], fmax_vel, fTarget, fRange, \ fRangeMode, Detection, numHarmonics) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM\n', Vel_RunningSpd_HM) # 速度频谱特征 try: Vel_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_Bearing_Defect_HM 时出错: {e}") Vel_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('Vel_Bearing_Defect_HM\n', Vel_Bearing_Defect_HM) # 包络频谱特征 try: Detection = "Peak" gE_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 gE_Bearing_Defect_HM 时出错: {e}") gE_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('gE_Bearing_Defect_HM\n', gE_Bearing_Defect_HM) try: # 诊断内圈故障 BPFIdetection, BPFIseverity = self.myDiagnosisLib.Bearing_Fault_Diag( gE_Bearing_Defect_HM, Vel_Bearing_Defect_HM, Vel_RunningSpd_HM, gE_alert, gE_danger, Vel_alert_mmsRMS, Vel_danger_mmsRMS, 'BPFI' ) except Exception as e: BPFIdetection = False BPFIseverity = 0 if not BPFIdetection: BPFIStatusCode = 0 elif BPFIseverity < 6: BPFIStatusCode = 1 else: BPFIStatusCode = 2 except Exception as e: # logger.info(f"处理内圈故障时发生未捕获的异常: {e}") BPFIStatusCode = 0 results["BPFI"]["status_codes"].append(BPFIStatusCode) try: """滚动体故障诊断""" logger.info("滚动体") fbr_BSF = BSF if self.wind_code == 'WOF091200030': if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 1: fmax_gE_10 = 10 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 else: if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 10: fmax_gE_10 = 100 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 numHarmonics = 4 fTarget = fbr_BSF fRangeMode = "Per" Detection = "RMS" logger.info('BSF', BSF) logger.info('ShaftSpd', ShaftSpd) logger.info('fTarget', fTarget) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature(self.VelSpec[i], fmax_vel, fTarget, fRange, \ fRangeMode, Detection, numHarmonics) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM\n', Vel_RunningSpd_HM) try: # 速度频谱特征 Vel_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_Bearing_Defect_HM 时出错: {e}") Vel_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('Vel_Bearing_Defect_HM\n', Vel_Bearing_Defect_HM) try: # 包络频谱特征S Detection = "Peak" gE_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 gE_Bearing_Defect_HM 时出错: {e}") gE_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('gE_Bearing_Defect_HM\n', gE_Bearing_Defect_HM) try: # 诊断滚动体故障 BSFdetection, BSFseverity = self.myDiagnosisLib.Bearing_Fault_Diag( gE_Bearing_Defect_HM, Vel_Bearing_Defect_HM, Vel_RunningSpd_HM, gE_alert, gE_danger, Vel_alert_mmsRMS, Vel_danger_mmsRMS, 'BSF' ) except Exception as e: BSFdetection = False BSFseverity = 0 if not BSFdetection: BSFStatusCode = 0 elif BSFseverity < 6: BSFStatusCode = 1 else: BSFStatusCode = 2 except Exception as e: # logger.info(f"处理滚动体故障时发生未捕获的异常: {e}") BSFStatusCode = 0 results["BSF"]["status_codes"].append(BSFStatusCode) try: """保持架故障诊断""" logger.info("保持架") fbr_FTF = FTF fTarget = fbr_FTF if self.wind_code == 'WOF091200030': if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 1: fmax_gE_10 = 10 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 else: if fTarget > 100: fmax_gE_10 = 10000 # elif fTarget <1: # fmax_gE_10 =0.001 # fmax_vel=min(1000,fs_acc/2.56) elif fTarget < 10: fmax_gE_10 = 10 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 numHarmonics = 4 fRangeMode = "Per" Detection = "RMS" logger.info('FTF', FTF) logger.info('ShaftSpd', ShaftSpd) logger.info('fTarget', fTarget) try: Vel_RunningSpd_HM = self.myDiagnosisLib.FixedFreqFeature(self.VelSpec[i], fmax_vel, fTarget, fRange, \ fRangeMode, Detection, numHarmonics) except Exception as e: # logger.info(f"计算 Vel_RunningSpd_HM 时出错: {e}") Vel_RunningSpd_HM = [0] * (numHarmonics + 1) logger.info('Vel_RunningSpd_HM\n', Vel_RunningSpd_HM) try: # 速度频谱特征 Vel_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_Bearing_Defect_HM 时出错: {e}") Vel_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('Vel_Bearing_Defect_HM\n', Vel_Bearing_Defect_HM) try: # 包络频谱特征 Detection = "Peak" gE_Bearing_Defect_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, fRangeMode, Detection, numHarmonics ) except Exception as e: # logger.info(f"计算 gE_Bearing_Defect_HM 时出错: {e}") gE_Bearing_Defect_HM = [0] * (numHarmonics + 1) logger.info('gE_Bearing_Defect_HM\n', gE_Bearing_Defect_HM) try: # 诊断保持架故障 FTFdetection, FTFseverity = self.myDiagnosisLib.Bearing_Fault_Diag( gE_Bearing_Defect_HM, Vel_Bearing_Defect_HM, Vel_RunningSpd_HM, gE_alert, gE_danger, Vel_alert_mmsRMS, Vel_danger_mmsRMS, 'FTF' ) except Exception as e: FTFdetection = False FTFseverity = 0 if not FTFdetection: FTFStatusCode = 0 elif FTFseverity < 6: FTFStatusCode = 1 else: FTFStatusCode = 2 except Exception as e: # logger.info(f"处理保持架故障时发生未捕获的异常: {e}") FTFStatusCode = 0 results["FTF"]["status_codes"].append(FTFStatusCode) # 计算统计信息 status_counts = {"count_0": 0, "count_1": 0, "count_2": 0} for fault_type in results: status_codes = results[fault_type]["status_codes"] results[fault_type]["max_status"] = max(status_codes) # 累加状态计数 status_counts["count_0"] += status_codes.count(0) status_counts["count_1"] += status_codes.count(1) status_counts["count_2"] += status_codes.count(2) return { "type": "Bearing", "results": results, "statistics": status_counts } def Gear_diag(self): """齿轮诊断""" logger.info('齿轮诊断') mesure_point_name = self.mesure_point_names[0].lower() if 'gearbox' not in mesure_point_name: logger.info("Can not perform gearbox diagnosis") raise ValueError("Can not perform gearbox diagnosis") results = { "wear": {"status_codes": []}, "crack": {"status_codes": []} } id = self.ids[0] numTeeth = int(self.teeth_count.get(id, 0)) logger.info(numTeeth) for i in range(len(self.ids)): ShaftSpd = self.fspd[i] * self.speed_ratio if ShaftSpd == 0: results["wear"]["status_codes"].append(-1) results["crack"]["status_codes"].append(-1) logger.info('speed_ratio', self.speed_ratio) logger.info('ShaftSpd', ShaftSpd) try: GMF = ShaftSpd * numTeeth / 60 fTarget = GMF logger.info('fTarget', fTarget) # numHarmonics = 2 numHarmonics = 2 fRange = 0.05 fmax_gE_10 = 1000 fs_acc = self.fs_acc[i] fmax_vel = max(1000, fs_acc / 2.56) if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 0.1: fmax_gE_10 = 10 elif fTarget < 1: fmax_gE_10 = 100 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 fmax_acc = fs_acc / 2.56 try: Vel_GMF_HM = self.myDiagnosisLib.FixedFreqFeature( self.VelSpec[i], fmax_vel, fTarget, fRange, "Per", "RMS", numHarmonics ) except Exception as e: # logger.info(f"计算 Vel_GMF_HM 时出错: {e}") Vel_GMF_HM = [0] * (numHarmonics + 1) logger.info('Vel_GMF_HM', Vel_GMF_HM) try: Acc_GMF_HM = self.myDiagnosisLib.FixedFreqFeature( self.AccSpec[i], fmax_acc, fTarget, fRange, "Per", "Peak", numHarmonics ) except Exception as e: # logger.info(f"计算 Acc_GMF_HM 时出错: {e}") Acc_GMF_HM = [0] * (numHarmonics + 1) logger.info('Acc_GMF_HM', Acc_GMF_HM) try: gE_GMF_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, "Per", "Peak", numHarmonics ) except Exception as e: # logger.info(f"计算 gE_GMF_HM 时出错: {e}") gE_GMF_HM = [0] * (numHarmonics + 1) logger.info('gE_GMF_HM', gE_GMF_HM) fTarget = ShaftSpd / 60 logger.info('fTarget', fTarget) if fTarget > 100: fmax_gE_10 = 10000 elif fTarget < 0.1: fmax_gE_10 = 10 elif fTarget < 1: fmax_gE_10 = 100 fmax_vel = min(1000, fs_acc / 2.56) else: fmax_gE_10 = 1000 numHarmonics = 4 try: gE_GTIF_HM = self.myDiagnosisLib.FixedFreqFeature( self.gESpec_10[i], fmax_gE_10, fTarget, fRange, "Per", "Peak", numHarmonics ) except Exception as e: # logger.info(f"计算 gE_GTIF_HM 时出错: {e}") gE_GTIF_HM = [0] * (numHarmonics + 1) logger.info('gE_GTIF_HM', gE_GTIF_HM) Acc_GMF_alert_gPk = 0.3 # 齿轮缺陷加速度预警阈值 (g 峰值) Acc_GMF_danger_gPk = 0.5 # 齿轮缺陷加速度报警阈值 (g 峰值) Vel_GMF_alert_mmsRMS = 4.0 # 速度总值预警阈值 （mm/s 有效值） Vel_GMF_danger_mmsRMS = 7.0 # 速度总值报警阈值 （mm/s 有效值） gE_GMF_alert_gE = 3.0 # 齿轮磨损缺陷加速度包络预警阈值 (gE 峰值) gE_GMF_danger_gE = 10.0 # 齿轮磨损缺陷加速度包络报警阈值 (gE 峰值) gE_GTIF_alert_gE = 3.0 # 齿轮断齿缺陷加速度包络预警阈值 (gE 峰值) gE_GTIF_danger_gE = 10.0 # 齿轮断齿缺陷加速度包络报警阈值 (gE 峰值) try: # 诊断齿轮故障 (GearToothWearDetection, GearToothWearSev, GearToothCrackBrokenDetection, GearToothCrackBrokenSev) = \ self.myDiagnosisLib.Gear_Fault_Diag(Acc_GMF_HM, Vel_GMF_HM, gE_GMF_HM, gE_GTIF_HM, Acc_GMF_alert_gPk, \ Acc_GMF_danger_gPk, Vel_GMF_alert_mmsRMS, Vel_GMF_danger_mmsRMS, gE_GMF_alert_gE, gE_GMF_danger_gE, \ gE_GTIF_alert_gE, gE_GTIF_danger_gE) except Exception as e: GearToothWearDetection = False GearToothCrackBrokenDetection = False GearToothWearSev = 0 GearToothCrackBrokenSev = 0 logger.info('齿轮磨损', GearToothWearSev, '齿轮断齿', GearToothCrackBrokenSev) # 处理磨损状态码 if not GearToothWearDetection: wear_status = 0 elif GearToothWearSev < 6: wear_status = 1 else: wear_status = 2 # 处理裂纹状态码 if not GearToothCrackBrokenDetection: crack_status = 0 elif GearToothCrackBrokenSev < 6: crack_status = 1 else: crack_status = 2 except Exception as e: wear_status = 0 crack_status = 0 results["wear"]["status_codes"].append(wear_status) results["crack"]["status_codes"].append(crack_status) # 计算统计信息 status_counts = {"count_0": 0, "count_1": 0, "count_2": 0} for fault_type in results: status_codes = results[fault_type]["status_codes"] results[fault_type]["max_status"] = max(status_codes) # 累加状态计数 status_counts["count_0"] += status_codes.count(0) status_counts["count_1"] += status_codes.count(1) status_counts["count_2"] += status_codes.count(2) return { "type": "Gear", "results": results, "statistics": status_counts } def Characteristic_Frequency(self): """提取轴承、齿轮等参数""" # 前端给的ids所对应的轴承参数、齿轮参数是一致的 计算一次即可 if not self.bearing_frequencies: id = self.ids[0] # 取第一个id计算 mesure_point_name = self.mesure_point_names[0] rpm = self.fspd[0] * self.speed_ratio # 应用转速传动比 # 1、从测点名称中提取部件名称（计算特征频率的部件） str1 = mesure_point_name logger.info(str1) # 2、连接233的数据库'energy_show'，从表'wind_engine_group'查找风机编号'engine_code'对应的机型编号'mill_type_code' engine_code = self.engine_code logger.info(engine_code) Engine = get_engine(dataBase.PLATFORM_DB) # Engine = create_engine('mysql+pymysql://admin:admin123456@106.120.102.238:16306/energy_show') df_sql2 = f"SELECT * FROM wind_engine_group WHERE engine_code = '{engine_code}'" df2 = pd.read_sql(df_sql2, Engine) mill_type_code = df2['mill_type_code'].iloc[0] logger.info(mill_type_code) # 3、从相关的表中通过机型编号'mill_type_code'或者齿轮箱编号gearbox_code查找部件'brand'、'model'的参数信息 # unit_bearings主轴承参数表 关键词"main_bearing" if 'main_bearing' in str1: logger.info("main_bearing") # df_sql3 = f"SELECT * FROM {'unit_bearings'} where mill_type_code = {'mill_type_code'} " df_sql3 = f"SELECT * FROM unit_bearings WHERE mill_type_code = '{mill_type_code}' " df3 = pd.read_sql(df_sql3, Engine) if df3.empty: logger.info("警告: 没有找到有效的机型信息") if 'front' in str1: brand = 'front_bearing' + '_brand' model = 'front_bearing' + '_model' front_has_value = not pd.isna(df3[brand].iloc[0]) and not pd.isna(df3[model].iloc[0]) if not front_has_value: logger.info("警告: 没有找到有效的品牌信息") elif 'rear' in str1: brand = 'rear_bearing' + '_brand' model = 'rear_bearing' + '_model' end_has_value = not pd.isna(df3[brand].iloc[0]) and not pd.isna(df3[model].iloc[0]) if not end_has_value: logger.info("警告: 没有找到有效的品牌信息") else: # 当没有指定 front 或 end 时，自动选择有值的轴承信息 front_brand_col = 'front_bearing_brand' front_model_col = 'front_bearing_model' rear_brand_col = 'rear_bearing_brand' rear_model_col = 'rear_bearing_model' # 检查 front_bearing 是否有值 front_has_value = not pd.isna(df3[front_brand_col].iloc[0]) and not pd.isna( df3[front_model_col].iloc[0]) # 检查 end_bearing 是否有值 end_has_value = not pd.isna(df3[rear_brand_col].iloc[0]) and not pd.isna( df3[rear_model_col].iloc[0]) # 根据检查结果选择合适的列 if front_has_value and end_has_value: # 如果两者都有值，默认选择 front brand = front_brand_col model = front_model_col elif front_has_value: brand = front_brand_col model = front_model_col elif end_has_value: brand = rear_brand_col model = rear_model_col else: # 如果两者都没有有效值，设置默认值或抛出异常 logger.info("警告: 没有找到有效的轴承信息") brand = front_brand_col # 默认使用 front model = front_model_col # 默认使用 front logger.info(brand) _brand = df3[brand].iloc[0] _model = df3[model].iloc[0] logger.info(_brand) logger.info(_model) # unit_dynamo 发电机参数表 关键词generator stator elif 'generator' in str1 or 'stator' in str1: logger.info("generator or 'stator'") # df_sql3 = f"SELECT * FROM {'unit_dynamo'} where mill_type_code = {'mill_type_code'} " df_sql3 = f"SELECT * FROM unit_dynamo WHERE mill_type_code = '{mill_type_code}' " df3 = pd.read_sql(df_sql3, Engine) if 'non' in str1: brand = 'non_drive_end_bearing' + '_brand' model = 'non_drive_end_bearing' + '_model' else: brand = 'drive_end_bearing' + '_brand' model = 'drive_end_bearing' + '_model' logger.info(brand) _brand = df3[brand].iloc[0] _model = df3[model].iloc[0] logger.info(_brand) logger.info(_model) # 齿轮箱区分行星轮/平行轮 和 轴承两个表 elif 'gearbox' in str1: logger.info("gearbox") # 根据mill_type_code从unit_gearbox表中获得gearbox_code df_sql3 = f"SELECT * FROM unit_gearbox WHERE mill_type_code = '{mill_type_code}' " df3 = pd.read_sql(df_sql3, Engine) gearbox_code = df3['code'].iloc[0] logger.info(gearbox_code) # 如果是行星轮/平行轮 则从unit_gearbox_structure 表中取数据 if 'planet' in str1 or 'sun' in str1: logger.info("'planet' or 'sun' ") gearbox_structure = 1 if 'planet' in str1 else 2 planetary_gear_grade = 1 if 'first' in str1: planetary_gear_grade = 1 elif 'second' in str1: planetary_gear_grade = 2 elif 'third' in str1: planetary_gear_grade = 3 # df_sql33 = f"SELECT * FROM unit_gearbox_structure WHERE gearbox_code = '{gearbox_code}' " df_sql33 = f""" SELECT bearing_brand, bearing_model,gear_ring_teeth_count FROM unit_gearbox_structure WHERE gearbox_code = '{gearbox_code}' AND gearbox_structure = '{gearbox_structure}' AND planetary_gear_grade = '{planetary_gear_grade}' """ df33 = pd.read_sql(df_sql33, Engine) if df33.empty: logger.info("unit_gearbox_structure没有该测点的参数") else: brand = 'bearing' + '_brand' model = 'bearing' + '_model' teeth_count = df33['gear_ring_teeth_count'].iloc[0] logger.info('teeth_count', teeth_count) logger.info(brand) _brand = df33[brand].iloc[0] _model = df33[model].iloc[0] has_value = not pd.isna(df33[brand].iloc[0]) and not pd.isna(df33[model].iloc[0]) if has_value: logger.info(_brand) logger.info(_model) else: logger.info("警告: 没有找到有效的轴承信息") # 如果是齿轮箱轴承 则从unit_gearbox_bearings 表中取数据 elif 'shaft' in str1 or 'input' in str1: logger.info("'shaft'or'input'") # 高速轴 低速中间轴 取bearing_rs/gs均可 parallel_wheel_grade = 1 if 'low_speed' in str1: parallel_wheel_grade = 1 elif 'low_speed_intermediate' in str1: parallel_wheel_grade = 2 elif 'high_speed' in str1: parallel_wheel_grade = 3 df_sql33 = f""" SELECT bearing_rs_brand, bearing_rs_model, bearing_gs_brand, bearing_gs_model,gear_ring_teeth_count FROM unit_gearbox_bearings WHERE gearbox_code = '{gearbox_code}' AND parallel_wheel_grade = '{parallel_wheel_grade}' """ df33 = pd.read_sql(df_sql33, Engine) if not df33.empty: if 'high_speed' in str1 or 'low_speed_intermediate' in str1: rs_brand = 'bearing_rs' + '_brand' rs_model = 'bearing_rs' + '_model' gs_brand = 'bearing_gs' + '_brand' gs_model = 'bearing_gs' + '_model' rs_has_value = not pd.isna(df33[rs_brand].iloc[0]) and not pd.isna(df33[rs_model].iloc[0]) gs_has_value = not pd.isna(df33[gs_brand].iloc[0]) and not pd.isna(df33[gs_model].iloc[0]) if rs_has_value and gs_has_value: brand = rs_brand model = rs_model elif rs_has_value: brand = rs_brand model = rs_model elif gs_has_value: brand = gs_brand model = gs_model else: logger.info("警告: 没有找到有效的品牌信息") brand = rs_brand model = rs_model # 低速轴 取bearing_model elif 'low_speed' in str1: brand = 'bearing' + '_brand' model = 'bearing' + '_model' else: logger.info("警告: 没有找到有效的轴承信息") if not df33.empty: if 'high_speed' in str1: teeth_count = df33['gear_ring_teeth_count'].iloc[0] logger.info('teeth_count', teeth_count) logger.info(brand) _brand = df33[brand].iloc[0] _model = df33[model].iloc[0] logger.info(_brand) logger.info(_model) # 4、从表'unit_dict_brand_model'中通过'_brand'、'_model'查找部件的参数信息 df_sql4 = f"SELECT * FROM unit_dict_brand_model where manufacture = %s AND model_number = %s" params = [(_brand, _model)] df4 = pd.read_sql(df_sql4, Engine, params=params) n_rolls = df4['rolls_number'].iloc[0] d_rolls = df4['rolls_diameter'].iloc[0] D_diameter = df4['circle_diameter'].iloc[0] theta_deg = df4['theta_deg'].iloc[0] # 计算特征频率 bearing_freq = self.calculate_bearing_frequencies(n_rolls, d_rolls, D_diameter, theta_deg, rpm) logger.info(bearing_freq) # 将结果赋给所有id for id in self.ids: self.bearing_frequencies[id] = bearing_freq logger.info('aaaa') if 'gearbox' in str1: self.teeth_count[id] = teeth_count def calculate_bearing_frequencies(self, n, d, D, theta_deg, rpm): """ 计算轴承各部件特征频率 参数： n (int): 滚动体数量 d (float): 滚动体直径（单位：mm） D (float): 轴承节圆直径（滚动体中心圆直径，单位：mm） theta_deg (float): 接触角（单位：度） rpm (float): 转速（转/分钟） 返回： dict: 包含各特征频率的字典（单位：Hz） """ # 转换角度为弧度 theta = math.radians(theta_deg) # 转换直径单位为米（保持单位一致性，实际计算中比值抵消单位影响） # 注意：由于公式中使用的是比值，单位可以保持mm不需要转换 ratio = d / D # 基础频率计算（转/秒） # f_r = rpm f_r = rpm / 60.0 # 计算各特征频率 BPFI = (n / 2) * (1 + ratio * math.cos(theta)) * f_r # 内圈故障频率 BPFO = (n / 2) * (1 - ratio * math.cos(theta)) * f_r # 外圈故障频率 BSF = (D / (2 * d)) * (1 - (ratio ** 2) * (math.cos(theta) ** 2)) * f_r # 滚动体故障频率 FTF = 0.5 * (1 - ratio * math.cos(theta)) * f_r # 保持架故障频率 return { "BPFI": round(BPFI, 2), "BPFO": round(BPFO, 2), "BSF": round(BSF, 2), "FTF": round(FTF, 2), } def calculate_speed_ratio(self): """ 根据风场编号和测点名称计算转速传动比 """ # 默认传动比为1 self.speed_ratio = 1.0 # WOF046400029风场 七台河需要特殊处理 if self.wind_code == "WOF046400029": # 获取第一个测点名称 mesure_point_name = self.mesure_point_names[0] if "gearbox" in mesure_point_name: if "high_speed" in mesure_point_name: # 高速轴输出端 self.speed_ratio = 1 elif "first" in mesure_point_name: # 一级行星级 self.speed_ratio = 1 / (5.3 * 5.5 * 3.8) elif "second" in mesure_point_name: # 二级行星级 self.speed_ratio = 1 / (5.5 * 3.8) if "generator" in mesure_point_name: self.speed_ratio = 1 else: # 非齿轮箱测点 self.speed_ratio = 1 / (5.3 * 5.5 * 3.8)