/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
this.InitializeComponent();
this.Suspending += this.OnSuspending;
Amplitude amplitude = Amplitude.Initialize(this, "a2dbce0e18dfe5f8e74493843ff5c053");
amplitude.SetUserProperties(new Dictionary <string, object>()
{
{ "int", 1 },
{ "string", "str" },
{ "float", 1.1 },
{ "bool", true }
});
}
void Awake()
{
Amplitude amplitude = Amplitude.Instance;
amplitude.logging = true;
amplitude.init("24124fc176fddaf8f13b157c1586cb32");
manage = this;
if (PlayerPrefs.GetInt("Install") == 0)
{
Amplitude.Instance.logEvent("AppOpen", FirstTime);
PlayerPrefs.SetInt("Install", PlayerPrefs.GetInt("Install") + 1);
isFirstActivate = true;
}
}
public AmplitudeManager()
{
_subscriberList.Add(new Event <GameOverEvent> .Subscriber(OnGameOver));
_subscriberList.Add(new Event <InitializeEvent> .Subscriber(OnStartRun));
_subscriberList.Add(new Event <PlayerHaveJumped> .Subscriber(OnJump));
_subscriberList.Add(new Event <QuitEvent> .Subscriber(OnQuit));
_subscriberList.Add(new Event <ChangeMenuEvent> .Subscriber(OnMenuChange));
_subscriberList.Add(new Event <FrameEvent> .Subscriber(OnFrame));
_subscriberList.Add(new Event <AchievementSucessEvent> .Subscriber(OnAchievement));
_subscriberList.Subscribe();
_amplitude = Amplitude.Instance;
_amplitude.logging = true;
_amplitude.init(AppKey);
}
private void Update(EvaluationContext context)
{
var t = (float)EvaluationContext.BeatTime * SpeedFactor.GetValue(context);
//var value = Value.GetValue(context);
var amplitude = Amplitude.GetValue(context);
var period = Period.GetValue(context);
var offset = Offset.GetValue(context);
var phase = Phase.GetValue(context);
var amplitudeScale = AmplitudeScale.GetValue(context);
Result.Value = new System.Numerics.Vector2(
(float)Math.Sin(t / period.X + phase.X) * amplitude.X * amplitudeScale + offset.X,
(float)Math.Sin(t / period.Y + phase.Y) * amplitude.Y * amplitudeScale + offset.Y
);
}
private async void OnSignUpButtonClicked(object sender, EventArgs e)
{
try
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(Constants.WebAPIkey));
var auth = await authProvider.CreateUserWithEmailAndPasswordAsync(emailEntry.Text, passwordEntry.Text);
string gettoken = auth.FirebaseToken;
await Application.Current.MainPage.DisplayAlert("Alert", gettoken, "Ok");
Amplitude.InstanceFor(Constants.userId, Constants.userProperties).Track("sign up");
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Alert", ex.Message, "OK");
}
}
void Awake()
{
Amplitude amplitude = Amplitude.Instance;
amplitude.logging = true;
amplitude.init("192e38bc3f24f012cf6ce443cdc45db4");
if (!FB.IsInitialized)
{
// Initialize the Facebook SDK
FB.Init(InitCallback, OnHideUnity);
}
else
{
// Already initialized, signal an app activation App Event
FB.ActivateApp();
}
}
private void Update(EvaluationContext context)
{
var t = OverrideTime.IsConnected
? OverrideTime.GetValue(context)
: (float)context.LocalFxTime * SpeedFactor.GetValue(context);
//var value = Value.GetValue(context);
var amplitude = Amplitude.GetValue(context);
var period = Period.GetValue(context);
var offset = Offset.GetValue(context);
var phase = Phase.GetValue(context);
var amplitudeScale = AmplitudeScale.GetValue(context);
Result.Value = new Vector3(
(float)Math.Sin(t / period.X + phase.X) * amplitude.X * amplitudeScale + offset.X,
(float)Math.Sin(t / period.Y + phase.Y) * amplitude.Y * amplitudeScale + offset.Y,
(float)Math.Sin(t / period.Z + phase.Z) * amplitude.Z * amplitudeScale + offset.Z
);
}
void OnGUI()
{
// Make a background box
GUI.Box(new Rect(10, 10, 100, 90), "Loader Menu");
// Make the first button. If it is pressed, Application.Loadlevel (1) will be executed
if (GUI.Button(new Rect(20, 40, 80, 20), "Level 1"))
{
Amplitude amplitude = Amplitude.Instance;
amplitude.logEvent("tapped");
Dictionary <string, object> userProperties = new Dictionary <string, object>()
{
{ "float_gprop", 1.0 }
};
amplitude.setUserProperties(userProperties);
Dictionary <string, object> demoOptions = new Dictionary <string, object>()
{
{ "Bucket", "A" },
{ "Credits", 9001 }
};
amplitude.logEvent("unity event 2", demoOptions);
amplitude.logRevenue(0.03);
amplitude.logRevenue("sku", 1, 1.99);
amplitude.logRevenue("sku", 1, 1.99, "cmVjZWlwdA==", null);
Dictionary <string, object> revenueProperties = new Dictionary <string, object>()
{
{ "car", "blue" },
{ "price", 12.99 }
};
if (Application.platform == RuntimePlatform.IPhonePlayer)
{
amplitude.logRevenue("sku", 1, 1.99, "cmVjZWlwdA==", null, "purchase", revenueProperties);
}
else if (Application.platform == RuntimePlatform.Android)
{
amplitude.logRevenue("sku", 1, 1.99, "receipt", "receiptSignature", "purchase", revenueProperties);
}
amplitude.regenerateDeviceId();
amplitude.logEvent("log event with new device id");
}
}
/// <summary>
/// Initializes the Amplitude with your Amplitude api key and optional user ID.
/// </summary>
public void Initialize(string apiKey, string userId = null)
{
if (impl != null)
{
throw new Exception("Amplitude instance is already initialized!");
}
impl = String.IsNullOrEmpty(Name) ?
Amplitude.Instance() :
Amplitude.InstanceWithName(Name);
if (String.IsNullOrEmpty(userId))
{
impl.InitializeApiKey(apiKey);
}
else
{
impl.InitializeApiKey(apiKey, userId);
}
}
public AnaliticsCore()
{
FirebaseApp.CheckAndFixDependenciesAsync().ContinueWithOnMainThread(task => {
_dependencyStatus = task.Result;
if (_dependencyStatus == DependencyStatus.Available)
{
InitializeFirebase();
}
else
{
/*
* Debug.LogError("Could not resolve all Firebase dependencies: " + _dependencyStatus);
*/
}
});
_amplitude = Amplitude.getInstance();
_amplitude.trackSessionEvents(true);
_amplitude.init("94a37eb01d2b2e09b2e836dcd7b44ad0");
}
private void Update(EvaluationContext context)
{
_phase = Phase.GetValue(context);
_bias = Bias.GetValue(context);
_shape = (Shapes)Shape.GetValue(context);
_ratio = Ratio.GetValue(context);
var time = OverrideTime.IsConnected
? OverrideTime.GetValue(context)
: EvaluationContext.BeatTime;
var rate = Rate.GetValue(context);
var t = time * rate;
LastFraction = (float)MathUtils.Fmod(t, 1);
var normalizedValue = CalcNormalizedValueForFraction(t);
Result.Value = normalizedValue * Amplitude.GetValue(context) + Offset.GetValue(context);
}
public AmplitudeHelper()
{
amplitude = Amplitude.Instance;
amplitude.logging = true;
if (string.IsNullOrEmpty(AppId))
{
Debug.LogError("Cannot instantiate Amplitude without proper AppId");
return;
}
amplitude.trackSessionEvents(true);
amplitude.init(AppId);
// We chose to use the deviceId as unique userId
if (!String.IsNullOrEmpty(SystemInfo.deviceUniqueIdentifier))
{
amplitude.setUserId(SystemInfo.deviceUniqueIdentifier);
}
}
private void Update(EvaluationContext context)
{
var bang = Trigger.GetValue(context);
if (bang != _lastBang)
{
if (bang)
{
_lastTriggerTime = (float)EvaluationContext.BeatTime;
}
_lastBang = bang;
}
var timeSinceTrigger = (float)EvaluationContext.BeatTime - _lastTriggerTime;
if (timeSinceTrigger < 0)
{
timeSinceTrigger = 0;
}
Result.Value = Math.Max(Amplitude.GetValue(context) - timeSinceTrigger * Decay.GetValue(context), 0);
}
void Awake()
{
//ResetSave();
//ResetAchievement();
if (instance == null)
{
instance = this;
}
else
{
instance.loaded = true;
Destroy(gameObject);
}
Amplitude amplitude = Amplitude.Instance;
amplitude.logging = true;
amplitude.init("7cc53a06785cde378112e5cd205bae7d");
levelManager = GetComponent <LevelManager>();
uiManager = GetComponent <UIManager>();
player = GameObject.Find("Player").GetComponent <PlayerController>();
//Camera Initialization
Screen.orientation = ScreenOrientation.Portrait;
Camera.main.orthographicSize = ((Screen.height * (chunkSize + (0.5f * Screen.height / Screen.width))) / Screen.width) / 2;
InitGame();
//Comment or Uncomment this code to Reset saves for new version
if (PlayerPrefs.HasKey("GameVersion") == false || PlayerPrefs.GetString("GameVersion") != gameversion)
{
ResetSave();
PlayerPrefs.SetString("GameVersion", Application.version);
}
}
internal SoundEffect()
{
currentAmplitude = new Amplitude();
currentAmplitude.left_phase = 0f;
currentAmplitude.right_phase = 0f;
}
public Phasor(Amplitude amplitude, Phase phase)
{
Amplitude = amplitude;
Phase = phase;
}
public void Injection(Amplitude amplitude)
{
this.amplitude = amplitude;
}
public void Accept(ShaderGeneratorContext context)
{
Amplitude.Accept(context);
Frequency.Accept(context);
Speed.Accept(context);
}
void Awake()
{
amplitude = Amplitude.Instance;
amplitude.logging = true;
amplitude.init("3f32e017748124cb86c984f4756231d4");
}
private void Injection(Amplitude amplitude, INativeProvidable nativeProvider, MusicUnity music)
{
this.nativeProvider = nativeProvider;
this.amplitude = amplitude;
this.music = music;
}
public Vector4 Compute()
{
float phase = DirectX12GameEngine.Shaders.Numerics.Vector2.Length(Texturing.TexCoord - new Vector2(0.5f, 0.5f));
float value = (float)Math.Sin((phase + Global.TotalTime * Speed.Compute()) * 2.0f * 3.14f * Frequency.Compute()) * Amplitude.Compute();
value = value * 0.5f + 0.5f;
return(new Vector4(value, value, value, 1.0f));
}
public static E TriggerRelease(double t0, double e0, Amplitude sustainLevel, double release)
=> (t)
=> !HasElapsed(t0, t, release)
? Release(t0, e0 > Normalize(sustainLevel) ? e0 : Normalize(sustainLevel), release)(t)
: Mute()(t);
/// <summary>
/// Find the local Amplitude component
/// </summary>
public void FindAmplitude()
{
if (!amplitude) amplitude = GetComponent<Amplitude>();
}
public void Visit(MaterialGeneratorContext context)
{
Amplitude.Visit(context);
Frequency.Visit(context);
Speed.Visit(context);
}
public static E TriggerAttack(double t0, double e0, double attack, double decay, Amplitude sustainLevel)
=> (t)
=> !HasElapsed(t0, t, attack) ? Attack(t0, e0, attack)(t)
: !HasElapsed(t0 + attack, t, decay) ? Decay(t0 + attack, e0, decay, sustainLevel)(t)
: Sustain(sustainLevel)(t);
public override string ToString()
{
return("Amp: " + Amplitude.ToString() +
", Freq: " + Frequency.ToString() + ", Wave: " + WaveType);
}
public static NetWorkIO GetDiagnosticInfo(BaseWaveSignal vSg)
{
int classify = 0;
vSg.DiagnosticGrade = vSg.AlarmGrade;
vSg.DiagnosticResult = vSg.Result;
vSg.DiagnosticTime = vSg.ACQDatetime;
vSg.DiagnosticUnit = vSg.Unit;
if (vSg.Waveform == null || vSg.SampleFre == 0 || vSg.SamplePoint == 0)
{
vSg.DiagnosticInfo = "没有诊断波形";
vSg.DiagnosticAdvice = null;
return(null);
}
if (vSg.RPM == 0)
{
vSg.DiagnosticInfo = "没有上传转速";
vSg.DiagnosticAdvice = null;
return(null);
}
if (vSg.AlarmGrade == AlarmGrade.Invalid || vSg.AlarmGrade == AlarmGrade.Normal || vSg.AlarmGrade == AlarmGrade.DisConnect)
{
vSg.DiagnosticInfo = "没有发现故障";
vSg.DiagnosticAdvice = null;
return(null);
}
try
{
double[] Frequency;
double[] Amplitude;
//频率间隔
double frequencyInterval = vSg.SampleFre / vSg.SamplePoint;
int length = (int)(vSg.SamplePoint / 2.56) + 1;
Frequency = new double[length];
for (int i = 0; i < length; i++)
{
Frequency[i] = frequencyInterval * i;
}
var output = Algorithm.Instance.FFT2AndPhaseAction(vSg.Waveform, vSg.SamplePoint);
if (output != null)
{
Amplitude = output[0].Take(length).ToArray();
}
else
{
vSg.DiagnosticInfo = "没有频域波形";
vSg.DiagnosticAdvice = null;
return(null);
}
//频率
double frequency = vSg.RPM / 60;
double e1, e2, e3, e4, e5;
double m1, m2, m3, m4, m5;
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 1, out e1, out m1);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 2, out e2, out m2);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 3, out e3, out m3);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 4, out e4, out m4);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 5, out e5, out m5);
//求时域有效值
var paras = Algorithm.CalculatePara(vSg.Waveform);
var rms = paras[0];
//最大幅值
var mMax = Amplitude.Max();
if (m1 >= mMax && m1 >= (rms * 0.1 * Math.Sqrt(2)) && m1 > m2 && m3 <= (rms * 0.1 * Math.Sqrt(2)))
{
vSg.DiagnosticInfo = "不平衡";
vSg.DiagnosticAdvice = "建议：怀疑轴系的动平衡情况，请检查转子是否存在弯曲或临时弯曲、转子零部件掉块、转子偏磨或结垢、轴承间隙大、设备底板结构松动等故障，如是皮带驱动，可能是皮带轮偏心引起。\r\n";
double probability = e1 * 100.0 / rms;
vSg.DiagnosticAdvice += "概率：" + probability.ToString("0") + "%";
classify = 1;
}
else if (m2 >= mMax && m2 >= (rms * 0.1 * Math.Sqrt(2)) && m1 >= (rms * 0.1 * Math.Sqrt(2)) && m3 >= (rms * 0.1 * Math.Sqrt(2)))
{
vSg.DiagnosticInfo = "不对中";
vSg.DiagnosticAdvice = "建议：(1)请检查相关轴系的对中情况，如轴与轴的对中不良、同一轴的几个轴承安装同心或轴承间隙不等、 轴承座热膨胀不均、机壳变形或移位、 地基不均匀下沉。\r\n";
vSg.DiagnosticAdvice += " (2)另外，可能以下原因也表现为不对中现象：I.由于质量偏心而引起的动平衡不良(此时转子呈弓形弯曲),也可能造成对中不良，如果此时静态条件下对中良好，可以先解决动平衡不良故障，对中不良故障将随即消除. II.由于受热、负载过大等原因导致轴弯曲;\r\n";
vSg.DiagnosticAdvice += " (3).由于内环或外环安装不合适，导致轴承偏翘（翘曲）. III.轴承座松动。\r\n";
double probability = e2 * 100.0 / rms;
vSg.DiagnosticAdvice += "概率：" + probability.ToString("0") + "%";
classify = 2;
}
else if (m1 >= (rms * 0.1 * Math.Sqrt(2)) && m2 >= (rms * 0.1 * Math.Sqrt(2)) && m3 >= (rms * 0.1 * Math.Sqrt(2)) && m4 >= (rms * 0.1 * Math.Sqrt(2)) && m5 >= (rms * 0.1 * Math.Sqrt(2)))
{
vSg.DiagnosticInfo = "轴承座松动、轴承松动、（基础）松动等";
vSg.DiagnosticAdvice = "建议：(1)请检查相关轴系的润滑、基础的紧固、相关轴系的轴承、轴承座安装情况.\r\n";
vSg.DiagnosticAdvice += " (2)受热、负载过大等原因导致轴弯曲；\r\n";
vSg.DiagnosticAdvice += " (3)内环或外环安装不合适，导致轴承偏翘（翘曲）。";
classify = 3;
}
else if (mMax >= (rms * 0.3 * Math.Sqrt(2)))
{
double fMax = 0;
for (int i = 0; i < Amplitude.Length; i++)
{
if (Amplitude[i] == mMax)
{
fMax = Frequency[i];
break;
}
}
vSg.DiagnosticInfo = "频谱上有占能量很大比率的频率" + fMax.ToString("0.000") + "没有找到合适的故障原因";
vSg.DiagnosticAdvice = "建议：(1)没有设备结构模型，比如齿轮齿数、设置轴承型号等，不能确定故障的部位。\r\n";
vSg.DiagnosticAdvice += " (2)转速设置是否正确。";
classify = 4;
}
else
{
vSg.DiagnosticInfo = "没有找到合适的故障原因, 请进一步观察。";
vSg.DiagnosticAdvice = null;
classify = 5;
}
NetWorkIO io = new DiagnosticModels.NetWorkIO();
io.Input = new double[] { e1, e2, e3, e4, e5 };
io.Output = DecToBinArray(classify);
return(io);
}
catch (Exception ex)
{
EventAggregatorService.Instance.EventAggregator.GetEvent <ThrowExceptionEvent>().Publish(Tuple.Create <string, Exception>("诊断异常", ex));
}
return(null);
}
private void Update(EvaluationContext context)
{
Result.Value = (float)Math.Sin(Input.GetValue(context) / Period.GetValue(context) + Phase.GetValue(context))
* Amplitude.GetValue(context)
+ Offset.GetValue(context);
}
private void Update(EvaluationContext context)
{
var band = (FrequencyBands)Band.GetValue(context);
var mode = (Modes)Mode.GetValue(context);
var decay = Decay.GetValue(context);
var modulo = UseModulo.GetValue(context);
var t = context.LocalFxTime;
if (Math.Abs(t - _lastEvalTime) < 0.001f)
{
return;
}
_lastEvalTime = t;
//var a = _SetAudioAnalysis.AudioAnalysisResult;
var results = band == FrequencyBands.Bass
? AudioAnalysisResult.Bass
: AudioAnalysisResult.HiHats;
var peakDetected = results.PeakCount > _lastPeakCount;
var usingModulo = modulo > 0;
var isModuloPeak = peakDetected && (!usingModulo || results.PeakCount % modulo == 0);
if (peakDetected && isModuloPeak)
{
_lastModuloPeakTime = context.Playback.FxTimeInBars;
}
var timeSinceModuloPeak = (float)(context.Playback.FxTimeInBars - _lastModuloPeakTime);
var timeSincePeak = usingModulo
? timeSinceModuloPeak
: results.TimeSincePeak;
float value = 0;
switch (mode)
{
case Modes.TimeSincePeak:
value = timeSincePeak;
break;
case Modes.Count:
value = usingModulo
? results.PeakCount / modulo
: results.PeakCount;
break;
case Modes.Peaks:
value = (float)Math.Max(0, 1 - timeSincePeak * decay);
break;
case Modes.PeaksDecaying:
value = (float)Math.Pow(decay + 1, -timeSincePeak);
break;
case Modes.Level:
value = (float)results.AccumulatedEnergy;
break;
case Modes.MovingSum:
if (double.IsNaN(_movingSum))
{
_movingSum = 0;
}
var step = Math.Pow(results.AccumulatedEnergy, decay);
if (!double.IsNaN(step))
{
_movingSum += step;
}
value = (float)(_movingSum % 10000);
break;
case Modes.RandomValue:
if (isModuloPeak)
{
_lastRandomValue = (float)_random.NextDouble();
}
value = _lastRandomValue;
break;
default:
throw new ArgumentOutOfRangeException();
}
Level.Value = value * Amplitude.GetValue(context);
PeakCount.Value = results.PeakCount;
PeakDetected.Value = isModuloPeak;
_lastPeakCount = results.PeakCount;
Level.DirtyFlag.Clear();
PeakCount.DirtyFlag.Clear();
PeakDetected.DirtyFlag.Clear();
}
public static string GetDiagnosticInfo(string devicename, byte[] bytes, double SampleFre, int SamplePoint, float RPM, out string DiagnosticInfo, out string DiagnosticAdvice)
{
double[] Waveform = ByteToSingle(bytes);
if (Waveform == null || SampleFre == 0 || SamplePoint == 0)
{
DiagnosticInfo = devicename + "没有诊断波形";
DiagnosticAdvice = null;
return(DiagnosticInfo + "\r\n" + DiagnosticAdvice);
}
if (RPM == 0)
{
DiagnosticInfo = devicename + "没有上传转速";
DiagnosticAdvice = null;
return(DiagnosticInfo + "\r\n" + DiagnosticAdvice);
}
double[] Frequency;
double[] Amplitude;
//频率间隔
double frequencyInterval = SampleFre / SamplePoint;
int length = (int)(SamplePoint / 2.56) + 1;
Frequency = new double[length];
for (int i = 0; i < length; i++)
{
Frequency[i] = frequencyInterval * i;
}
var output = D2FFT(Waveform, SamplePoint);
if (output != null)
{
Amplitude = output.Take(length).ToArray();
}
else
{
DiagnosticInfo = devicename + "没有频域波形";
DiagnosticAdvice = null;
return(DiagnosticInfo + "\r\n" + DiagnosticAdvice);
}
//频率
double frequency = RPM / 60;
double e1, e2, e3, e4, e5;
double m1, m2, m3, m4, m5;
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 1, out e1, out m1);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 2, out e2, out m2);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 3, out e3, out m3);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 4, out e4, out m4);
GetEnergy(Frequency, Amplitude, frequency, frequencyInterval, 5, out e5, out m5);
//求时域有效值
var paras = CalculatePara(Waveform);
var rms = paras[0];
//最大幅值
var mMax = Amplitude.Max();
if (m1 >= mMax && m1 >= (rms * 0.1 * Math.Sqrt(2)) && m1 > m2 && m3 <= (rms * 0.1 * Math.Sqrt(2)))
{
DiagnosticInfo = devicename + "不平衡";
DiagnosticAdvice = "建议：怀疑轴系的动平衡情况，请检查转子是否存在弯曲或临时弯曲、转子零部件掉块、转子偏磨或结垢、轴承间隙大、设备底板结构松动等故障，如是皮带驱动，可能是皮带轮偏心引起。\r\n";
double probability = e1 * 100.0 / rms;
DiagnosticAdvice += "概率：" + probability.ToString("0") + "%";
}
else if (m2 >= mMax && m2 >= (rms * 0.1 * Math.Sqrt(2)) && m1 >= (rms * 0.1 * Math.Sqrt(2)) && m3 >= (rms * 0.1 * Math.Sqrt(2)))
{
DiagnosticInfo = devicename + "不对中";
DiagnosticAdvice = "建议：(1)请检查相关轴系的对中情况，如轴与轴的对中不良、同一轴的几个轴承安装同心或轴承间隙不等、 轴承座热膨胀不均、机壳变形或移位、 地基不均匀下沉。\r\n";
DiagnosticAdvice += " (2)另外，可能以下原因也表现为不对中现象：I.由于质量偏心而引起的动平衡不良(此时转子呈弓形弯曲),也可能造成对中不良，如果此时静态条件下对中良好，可以先解决动平衡不良故障，对中不良故障将随即消除. II.由于受热、负载过大等原因导致轴弯曲;\r\n";
DiagnosticAdvice += " (3).由于内环或外环安装不合适，导致轴承偏翘（翘曲）. III.轴承座松动。\r\n";
double probability = e2 * 100.0 / rms;
DiagnosticAdvice += "概率：" + probability.ToString("0") + "%";
}
else if (m1 >= (rms * 0.1 * Math.Sqrt(2)) && m2 >= (rms * 0.1 * Math.Sqrt(2)) && m3 >= (rms * 0.1 * Math.Sqrt(2)) && m4 >= (rms * 0.1 * Math.Sqrt(2)) && m5 >= (rms * 0.1 * Math.Sqrt(2)))
{
DiagnosticInfo = devicename + "轴承座松动、轴承松动、（基础）松动等";
DiagnosticAdvice = "建议：(1)请检查相关轴系的润滑、基础的紧固、相关轴系的轴承、轴承座安装情况.\r\n";
DiagnosticAdvice += " (2)受热、负载过大等原因导致轴弯曲；\r\n";
DiagnosticAdvice += " (3)内环或外环安装不合适，导致轴承偏翘（翘曲）。";
}
else if (mMax >= (rms * 0.3 * Math.Sqrt(2)))
{
double fMax = 0;
for (int i = 0; i < Amplitude.Length; i++)
{
if (Amplitude[i] == mMax)
{
fMax = Frequency[i];
break;
}
}
DiagnosticInfo = devicename + "频谱上有占能量很大比率的频率" + fMax.ToString("0.000") + "没有找到合适的故障原因";
DiagnosticAdvice = "建议：(1)没有设备结构模型，比如齿轮齿数、设置轴承型号等，不能确定故障的部位。\r\n";
DiagnosticAdvice += " (2)转速设置是否正确。";
}
else
{
DiagnosticInfo = devicename + "没有找到合适的故障原因, 请进一步观察。";
DiagnosticAdvice = null;
}
return(DiagnosticInfo + "\r\n" + DiagnosticAdvice);
}
public override int Read(float[] buffer, int offset, int count)
{
//if (phase > 1.0f)
//{
// //Console.WriteLine("Phase reset {0}", phase);
// phase = phase % 1.0f;
//}
float phaseinc = (1.0f / _samplerate);
float phaseinc2 = 0;
float t = 0;
float sine = 0;
float[] frequencysamples = new float[buffer.Length];
float[] amplitudesamples = new float[buffer.Length];
float[] phaseoffsetsamples = new float[buffer.Length];
float[] originsamples = new float[buffer.Length];
Frequency.Read(frequencysamples, offset, count);
Amplitude.Read(amplitudesamples, offset, count);
PhaseOffset.Read(phaseoffsetsamples, offset, count);
Origin.Read(originsamples, offset, count);
float freq = 0;
float amp = 0;
float offsetphase = 0;
float origin = 0;
float value = 0;
float twopi = (float)Math.PI * 2;
for (int i = offset; i < count; i++)
{
freq = frequencysamples[i];
amp = amplitudesamples[i];
//if (phase > freq)
//{
// phase = phase % (1.0f / freq);
//}
phaseinc2 = (1.0f / (_samplerate)) * freq;
offsetphase = (phase + phaseoffsetsamples[i]);
origin = originsamples[i];
switch (this.waveform)
{
case WaveType.SineWave:
value = (float)(Math.Sin(offsetphase * twopi));
break;
case WaveType.SquareWave:
t = (float)((offsetphase));
if (t < 0.5)
{
value = -1.0f;
}
else
{
value = 1.0f;
}
break;
case WaveType.TriangleWave:
t = (float)((offsetphase));
if (t <= 0.5)
{
value = -1.0f + (4 * t);
}
else
{
value = 1.0f - (4 * (t - 0.5f));
}
break;
case WaveType.SawtoothWave:
t = (float)((offsetphase));
value = -1.0f + (2 * t);
break;
case WaveType.InverseSawtoothWave:
t = (float)((offsetphase));
value = 1.0f - (2 * t);
break;
case WaveType.PulseWaveHalf:
t = (float)((offsetphase));
if (t < 0.25)
{
value = -1.0f;
}
else
{
value = 1.0f;
}
break;
case WaveType.PulseWaveQuarter:
t = (float)((offsetphase));
if (t < 0.125)
{
value = -1.0f;
}
else
{
value = 1.0f;
}
break;
default:
value = 0;
break;
}
buffer[i] = origin + (amp * value);
phase = (phase + phaseinc2) % 1.0f;
}
return(count);
}
