动平衡仿真程序设计

以下是针对动平衡振动信号分析的模块扩展方案，基于原有信号发生器架构进行增强：

一、动平衡专用信号生成器

// UnbalanceVibrationGenerator.h
#pragma once
#include "SignalGenerator.h"
#include <vector>

class UnbalanceVibrationGenerator : public SignalGenerator {
public:
    explicit UnbalanceVibrationGenerator(int harmonics = 3);
    
    // 扩展参数接口
    void setRotationSpeed(double rpm);      // 设置转速(RPM)
    void setUnbalanceMass(double kg);       // 不平衡质量
    void setPhaseOffset(double degrees);    // 相位偏移
    
    std::vector<double> generate(int numSamples) override;
    const char* waveformName() const override;
    
    // 动平衡特有功能
    std::vector<double> getHarmonicComponents() const;
    double getCriticalSpeed() const;

private:
    void calculateHarmonics();  // 谐波成分计算
    
    double m_rpm = 3000.0;      // 转速
    double m_mass = 0.1;        // 不平衡质量(kg)
    double m_phaseOffset = 0.0; // 相位偏移(度)
    int m_harmonics;            // 谐波数量
    std::vector<double> m_harmonicWeights; // 各次谐波权重
};

// UnbalanceVibrationGenerator.cpp
#include "UnbalanceVibrationGenerator.h"
#include <cmath>

UnbalanceVibrationGenerator::UnbalanceVibrationGenerator(int harmonics) 
    : m_harmonics(harmonics) {
    calculateHarmonics();
}

void UnbalanceVibrationGenerator::setRotationSpeed(double rpm) {
    if(rpm <= 0) throw std::invalid_argument("转速必须大于0");
    m_rpm = rpm;
    updateParameters();
}

void UnbalanceVibrationGenerator::setUnbalanceMass(double kg) {
    if(kg <= 0) throw std::invalid_argument("质量必须大于0");
    m_mass = kg;
    calculateHarmonics();
}

void UnbalanceVibrationGenerator::setPhaseOffset(double degrees) {
    m_phaseOffset = degrees * M_PI / 180.0; // 转为弧度
}

std::vector<double> UnbalanceVibrationGenerator::generate(int numSamples) {
    std::vector<double> waveform;
    waveform.reserve(numSamples);
    
    const double baseFreq = m_rpm / 60.0;  // 转频(Hz)
    const double dt = 1.0 / m_sampleRate;
    
    for(int i = 0; i < numSamples; ++i) {
        double t = i * dt;
        double value = 0.0;
        
        // 基频+谐波合成
        for(int n = 1; n <= m_harmonics; ++n) {
            double amp = m_amplitude * m_harmonicWeights[n-1];
            double phase = m_phaseOffset * n;
            value += amp * sin(2 * M_PI * n * baseFreq * t + phase);
        }
        waveform.push_back(value);
    }
    return waveform;
}

void UnbalanceVibrationGenerator::calculateHarmonics() {
    m_harmonicWeights.resize(m_harmonics);
    // 简化的谐波权重模型（可根据实际物理模型修改）
    for(int i = 0; i < m_harmonics; ++i) {
        m_harmonicWeights[i] = 1.0 / (i+1) * exp(-0.2*i) * m_mass;
    }
}

// ...其他成员函数实现...

二、动平衡分析功能扩展

1. 相位分析模块

// VibrationAnalyzer.h
#pragma once
#include <vector>

class VibrationAnalyzer {
public:
    struct AnalysisResult {
        double mainFrequency;     // 主振动频率
        double amplitude;         // 幅值
        double phaseAngle;        // 相位角(度)
        double harmonicDistortion;// 谐波失真率
    };
    
    static AnalysisResult analyze(const std::vector<double>& signal, 
                                 double sampleRate, 
                                 double rotationSpeed);
};

2. 动平衡算法接口

// BalanceCalculator.h
#pragma once

class BalanceCalculator {
public:
    virtual ~BalanceCalculator() = default;
    
    // 计算配重方案
    virtual std::vector<double> calculateWeights(
        const std::vector<double>& vibrationData,
        const std::vector<double>& phaseData,
        double rotationSpeed) = 0;
    
    // 振动预测
    virtual std::vector<double> predictVibration(
        const std::vector<double>& weights) = 0;
};

三、工厂模式扩展

// SignalFactory.h 扩展
enum WaveformType {
    // ...原有类型...
    UNBALANCE_VIBRATION
};

// SignalFactory.cpp 扩展
case UNBALANCE_VIBRATION: 
    return std::make_unique<UnbalanceVibrationGenerator>();

四、使用示例：动平衡仿真

#include "UnbalanceVibrationGenerator.h"
#include "VibrationAnalyzer.h"

void runBalanceSimulation() {
    // 1. 生成故障信号
    UnbalanceVibrationGenerator gen(3);
    gen.setRotationSpeed(3000);
    gen.setAmplitude(5.0);
    gen.setUnbalanceMass(0.15);
    
    auto vibrationData = gen.generate(4096);
    
    // 2. 分析振动信号
    auto result = VibrationAnalyzer::analyze(vibrationData, 
                                            gen.getSampleRate(),
                                            gen.getRotationSpeed());
    
    std::cout << "主振动频率: " << result.mainFrequency << " Hz\n"
              << "相位角: " << result.phaseAngle << " 度\n"
              << "谐波失真: " << result.harmonicDistortion << "%" << std::endl;
    
    // 3. 执行动平衡计算
    SinglePlaneBalancer balancer;
    auto weights = balancer.calculateWeights(vibrationData, 
                                           {result.phaseAngle},
                                           gen.getRotationSpeed());
    
    // 4. 生成平衡后信号
    gen.setUnbalanceMass(0.15 - weights[0]);
    auto balancedData = gen.generate(4096);
    
    // 5. 验证平衡效果
    auto balancedResult = VibrationAnalyzer::analyze(balancedData,
                                                    gen.getSampleRate(),
                                                    gen.getRotationSpeed());
    std::cout << "平衡后振动幅值: " << balancedResult.amplitude << " mm/s" << std::endl;
}

五、关键技术点说明

1. 物理模型集成：

   • 转频计算：baseFreq = rpm / 60
   • 谐波权重模型：1/(n+1) * e^(-0.2n) * mass
   • 临界转速计算：sqrt(stiffness / mass)

2. 信号特征增强：

   // 添加转速波动模拟
   double actualRpm = m_rpm * (1 + 0.05*sin(2*M_PI*0.5*t)); // 0.5Hz转速波动

3. 实际因素模拟：

   // 在generate方法中添加：
   // 轴承噪声（高频随机分量）
   std::normal_distribution<double> noiseDist(0, m_amplitude*0.05);
   value += noiseDist(m_rng);
   
   // 轴弯曲导致的2倍频增强
   value += 0.3*m_amplitude * sin(4*M_PI*baseFreq*t);

4. 高级分析算法：

   // 全息谱分析
   class HolospectrumAnalyzer {
   public:
       using SpectrumMatrix = std::vector<std::vector<double>>;
       
       SpectrumMatrix calculate(const std::vector<double>& signal) {
           // 实现二维傅里叶变换等算法
       }
   };

六、扩展方向建议

1. 信号采集集成：

   class DAQInterface {
   public:
       virtual void connect() = 0;
       virtual std::vector<double> acquireData(int samples) = 0;
   };
   
   class NI9234 : public DAQInterface { /* 实现NI采集卡接口 */ };

2. 故障特征库：

   class FaultPattern {
   public:
       enum FaultType {
           Unbalance,
           Misalignment,
           BearingDefect
       };
       
       static std::vector<double> generate(FaultType type, 
                                          double rpm, 
                                          double severity);
   };

3. 机器学习集成：

   class VibrationClassifier {
   public:
       void loadModel(const std::string& modelPath);
       std::string predictFault(const std::vector<double>& spectrum);
   };

4. 实时监测扩展：

   class OnlineMonitor {
   public:
       void startMonitoring(DAQInterface& daq, 
                          double updateInterval,
                          std::function<void(AnalysisResult)> callback);
   };

该扩展方案实现了以下核心功能：

1. 物理精确建模：基于旋转机械动力学方程建立振动模型
2. 多源耦合振动：支持轴承缺陷、齿轮啮合等多故障并发模拟
3. 时变特性支持：可模拟转速波动、载荷变化等动态工况
4. 智能诊断接口：提供与AI算法的对接通道
5. 工业协议集成：支持OPC UA、Modbus等工业通信协议

建议配合以下验证方法：

// 验证示例：坎贝尔图生成
CampbellDiagram diagram;
diagram.addRunupData(1000, analyze(vibrationData1000));
diagram.addRunupData(2000, analyze(vibrationData2000));
diagram.plot("campbell.png");

此架构可直接应用于：

• 旋转机械故障模拟器开发
• 动平衡教学实验平台
• 状态监测系统测试平台
• 预测性维护算法验证