Bearing element analysis

Bearing fault diagnostics

clc;

clear all;

close all;

SR=48000; % Sample Rate

dt=1/SR;

%% Healthy Data

data_h=load('97 - Healthy.mat');

% DRIVE DATA LOADING

data_de_h = data_h.X097_DE_time;

data_de_h = data_de_h(1:48000);

data_de_h = data_de_h - mean(data_de_h);

time_de_h = length(data_de_h)/SR;

t_de_h = 0 : dt : time_de_h;

t_de_h = t_de_h(1 : length(data_de_h));

length_de_h = length(data_de_h);

%% Fault Data 1

data_fault1=load('213 - F1.mat');

%% DRIVE DATA LOADING

data_de_f1=data_fault1.X213_DE_time;

data_de_f1 = data_de_f1(1:48000);

data_de_f1 = data_de_f1 - mean(data_de_f1);

time_de_f1=length(data_de_f1)/SR;

t_de_f1=0:dt:time_de_f1;

t_de_f1=t_de_f1(1:length(data_de_f1));

length_de_f1 = length(data_de_f1);

%% Fault Data 2

data_fault2=load('238 - F2.mat');

% DRIVE DATA LOADING

data_de_f2=data_fault2.X238_DE_time;

data_de_f2 = data_de_f2(1:48000);

data_de_f2 = data_de_f2 - mean(data_de_f2);

time_de_f2=length(data_de_f2)/SR;

t_de_f2=0:dt:time_de_f2;

t_de_f2=t_de_f2(1:length(data_de_f2));

length_de_f2 = length(data_de_f2);

%% time series

figure();

plot(t_de_h,data_de_h);

title('Healthy Data Visualisation');

xlabel('Time');

ylabel('Amplitude');

xlim([0 0.45]);

figure();

plot(t_de_f1, data_de_f1);

title('Fault 1 Data Visualisation');

xlabel('Time');

ylabel('Amplitude');

xlim([0 0.45]);

figure();

plot(t_de_f2, data_de_f2);

title('Fault 2 Data Visualisation');

xlabel('Time');

ylabel('Amplitude');

xlim([0 0.45]);

%% fft

fft_de_h = 2 * abs(fft(data_de_h, length_de_h)) / length_de_h;

freq_de_h = 0:(1/t_de_h(end)): SR/2 - (1/t_de_h(end));

figure();

plot(freq_de_h, fft_de_h(1 : length(freq_de_h)));

title('Healthy Data FFT');

xlabel('Frequency');

ylabel('Amplitude');

xlim([0 1000]);

fft_de_f1 = 2*abs(fft(data_de_f1, length_de_f1))/ length_de_f1;

freq_de_f1 = 0:(1/t_de_f1(end)): SR/2 - (1/t_de_f1(end));

figure();

plot(freq_de_f1, fft_de_f1(1:length(freq_de_f1)));

title('Fault 1 FFT');

xlabel('Frequency');

ylabel('Amplitude');

xlim([0 1000]);

fft_de_f2 = 2*abs(fft(data_de_f2, length_de_f2))/ length_de_f2;

freq_de_f2 = 0:(1/t_de_f2(end)): SR/2 - (1/t_de_f2(end));

figure();

plot(freq_de_f2, fft_de_f2(1:length(freq_de_f2)));

title("Fault 2 FFT");

xlabel('Frequency');

ylabel('Amplitude');

xlim([0 1000]);

% %% Envelope

% [envelope_up0, envelope_lo0] = envelope(data_de_h);

% figure();

% plot(t_de_h, data_de_h);

% hold on

% plot(t_de_h, envelope_up0, t_de_h, envelope_lo0, 'linewidth',1.5);

% legend('Healthy','up','lo');

% title('Time Plot Healthy envelope');

% xlabel('Time');

% ylabel('Amplitude');

% xlim([0 0.3]);

% hold off

% envelope_up0 = envelope_up0 - mean(envelope_up0);

% fft_drive_healthy_envelope = 2 * abs(fft(envelope_up0, length_de_h)) / length_de_h;

% figure();

% plot(freq_de_h, fft_drive_healthy_envelope(1 : length(freq_de_h)));

% title('Healthy fft envelope' );

% xlabel('Frequency');

% ylabel('Amplitude');

% xlim([0 500]);

%

%

% [envelope_up1,envelope_lo1] = envelope(data_de_f1);

% figure();

% plot(t_de_f1, data_de_f1);

% hold on

% plot(t_de_f1,envelope_up1,t_de_f1,envelope_lo1,'linewidth',1.5)

% legend('Fault1','up','lo');

% title('Time Plot Fault 1 ENVELOPE', 'FontSize', 14);

% xlabel('Time');

% ylabel('Amplitude');

% xlim([0 0.3])

% hold off

% envelope_up1 = envelope_up1 - mean(envelope_up1);

% fft_drive_fault1_envelope = 2*abs(fft(envelope_up1, length_de_f1))/ length_de_f1;

% figure();

% plot(freq_de_f1, fft_drive_fault1_envelope(1:length(freq_de_f1)));

% title('Fault 1 fft envelope' );

% xlabel('Frequency');

% ylabel('Amplitude');

% xlim([0 500]);

%

%

% [envelope_up2,envelope_lo2] = envelope(data_de_f2);

% figure();

% plot(t_de_f2, data_de_f2);

% hold on

% plot(t_de_f2,envelope_up2,t_de_f2,envelope_lo2,'linewidth',1.5)

% legend('Fault2','up','lo');

% title('Time Plot Fault 2 ENVELOPE', 'FontSize', 14);

% xlabel('Time');

% ylabel('Amplitude');

% xlim([0 0.3])

% hold off

% envelope_up2 = envelope_up2 - mean(envelope_up2);

% fft_drive_fault2_envelope = 2*abs(fft(envelope_up2, length_de_f2))/ length_de_f2;

% figure();

% plot(freq_de_f2, fft_drive_fault2_envelope(1:length(freq_de_f2)));

% title('fault 2 fft envelope');

% xlabel('Frequency');

% ylabel('Amplitude');

% xlim([0 500]);

%% Kurtogram fault 1

level = 9;

figure()

kurtogram(data_de_f2, SR, level)

level = 9;

figure()

kurtogram(data_de_f1, SR, level)

%% Breaking the time

df_healthy = [];

df_fault1 = [];

df_fault2 = [];

df_healthy_envelope = [];

df_fault1_envelope = [];

df_fault2_envelope = [];

n = 50;

intreval = 0.5;

for i = 1:n

if i < n

df_healthy(:, i) = data_de_h((i-1) * (length_de_h - SR * intreval) / n + 1: (i-1) * (length_de_h - SR * intreval) / n + (SR * intreval));

df_fault1(:, i) = data_de_f1((i-1) * (length_de_f1 - SR * intreval) / n + 1: (i-1) * (length_de_f1 - SR * intreval) / n + (SR * intreval));

df_fault2(:, i) = data_de_f2((i-1) * (length_de_f2 - SR * intreval) / n + 1: (i-1) * (length_de_f2 - SR * intreval) / n + (SR * intreval));

df_healthy_envelope(:, i) = envelope_up0((i-1) * (length_de_h - SR * intreval) / n + 1: (i-1) * (length_de_h - SR * intreval) / n + (SR * intreval));

df_fault1_envelope(:, i) = envelope_up1((i-1) * (length_de_f1 - SR * intreval) / n + 1: (i-1) * (length_de_f1 - SR * intreval) / n + (SR * intreval));

df_fault2_envelope(:, i) = envelope_up2((i-1) * (length_de_f2 - SR * intreval) / n + 1: (i-1) * (length_de_f2 - SR * intreval) / n + (SR * intreval));

df_healthy(:, i) = df_healthy(:, i) - mean(df_healthy(:, i));

df_fault1(:, i) = df_fault1(:, i) - mean(df_fault1(:, i));

df_fault2(:, i) = df_fault2(:, i) - mean(df_fault2(:, i));

df_healthy_envelope(:, i) = df_healthy_envelope(:, i) - mean(df_healthy_envelope(:, i));

df_fault1_envelope(:, i) = df_fault1_envelope(:, i) - mean(df_fault1_envelope(:, i));

df_fault2_envelope(:, i) = df_fault2_envelope (:, i)- mean(df_fault2_envelope(:, i));

else

df_healthy(:, i) = data_de_h(end - SR * intreval + 1 : end);

df_fault1(:, i) = data_de_f1(end - SR * intreval + 1 : end);

df_fault2(:, i) = data_de_f2(end - SR * intreval + 1 : end);

df_healthy_envelope(:, i) = envelope_up0(end - SR * intreval + 1 : end);

df_fault1_envelope(:, i) = envelope_up0(end - SR * intreval + 1 : end);

df_fault2_envelope(:, i) = envelope_up0(end - SR * intreval + 1 : end);

df_healthy(:, i) = df_healthy(:, i) - mean(df_healthy(:, i));

df_fault1(:, i) = df_fault1(:, i) - mean(df_fault1(:, i));

df_fault2(:, i) = df_fault2(:, i) - mean(df_fault2(:, i));

df_healthy_envelope(:, i) = df_healthy_envelope(:, i) - mean(df_healthy_envelope(:, i));

df_fault1_envelope(:, i) = df_fault1_envelope(:, i) - mean(df_fault1_envelope(:, i));

df_fault2_envelope(:, i) = df_fault2_envelope(:, i) - mean(df_fault2_envelope(:, i));

end

end

%% FFT OF EACH TIME INTREVAL

fft_healthy = [];

fft_fault1 = [];

fft_fault2 = [];

fft_healthy_envelope = [];

fft_fault1_envelope = [];

fft_fault2_envelope = [];

for i = 1:n

df_length_healthy = length(df_healthy(:, i));

df_length_fault1 = length(df_fault1(:, i));

df_length_fault2 = length(df_fault2(:, i));

t_healthy = 0:dt:df_length_healthy/SR;

t_fault1 = 0:dt:df_length_fault1/SR;

t_fault2 = 0:dt:df_length_fault2/SR;

df_length_healthy_enev= length(df_healthy_envelope(:, i));

df_length_fault1_env = length(df_fault1_envelope(:, i));

df_length_fault2_env = length(df_fault2_envelope(:, i));

fft_healthy(:, i) = 2*abs(fft(df_healthy(:, i), df_length_healthy)) / df_length_healthy;

fft_fault1(:, i) = 2*abs(fft(df_fault1(:, i), df_length_fault1)) / df_length_fault1;

fft_fault2(:, i) = 2*abs(fft(df_fault2(:, i), df_length_fault2)) / df_length_fault2;

fft_healthy_envelope(:, i) = 2*abs(fft(df_healthy_envelope(:, i), df_length_healthy_enev)) / df_length_healthy_enev;

fft_fault1_envelope(:, i) = 2*abs(fft(df_fault1_envelope(:, i), df_length_fault1_env)) / df_length_fault1_env;

fft_fault2_envelope(:, i) = 2*abs(fft(df_fault2_envelope(:, i), df_length_fault2_env)) / df_length_fault2_env;

end

freq_healthy = 1/t_healthy(end);

freq_fault1 = 1/t_fault1(end);

freq_fault2 = 1/t_fault2(end);

feature_matrix = [];

for i = 1:n

feature_matrix(i, 1) = kurtosis(df_healthy(:, i));

feature_matrix(i, 2) = rms(df_healthy(:, i));

feature_matrix(i, 3) = skewness(df_healthy(:, i));

feature_matrix(i, 4) = kurtosis(df_healthy_envelope(:, i));

feature_matrix(i, 5) = rms(df_healthy_envelope(:, i));

feature_matrix(i, 6) = skewness(df_healthy_envelope(:, i));

feature_matrix(i, 7) = max(fft_healthy(100/freq_healthy : 108/freq_healthy, i));

feature_matrix(i, 8) = max(fft_healthy(154/freq_healthy : 162/freq_healthy, i));

feature_matrix(i, 9) = max(fft_healthy(204/freq_healthy : 212/freq_healthy, i));

feature_matrix(i, 10) = max(fft_healthy(312/freq_healthy : 320/freq_healthy, i));

feature_matrix(i, 11) = max(fft_healthy(308/freq_healthy : 316/freq_healthy, i));

feature_matrix(i, 12) = max(fft_healthy(470/freq_healthy : 478/freq_healthy, i));

feature_matrix(i, 13) = max(fft_healthy(412/freq_healthy : 420/freq_healthy, i));

feature_matrix(i, 14) = max(fft_healthy(628/freq_healthy : 636/freq_healthy, i));

feature_matrix(i, 15) = max(fft_healthy(518/freq_healthy : 524/freq_healthy, i));

feature_matrix(i, 16) = max(fft_healthy(628/freq_healthy : 636/freq_healthy, i));

feature_matrix(i, 17) = max(fft_healthy_envelope(100/freq_healthy : 108/freq_healthy, i));

feature_matrix(i, 18) = max(fft_healthy_envelope(154/freq_healthy : 162/freq_healthy, i));

feature_matrix(i, 19) = max(fft_healthy_envelope(204/freq_healthy : 212/freq_healthy, i));

feature_matrix(i, 20) = max(fft_healthy_envelope(312/freq_healthy : 320/freq_healthy, i));

feature_matrix(i, 21) = max(fft_healthy_envelope(308/freq_healthy : 316/freq_healthy, i));

feature_matrix(i, 22) = max(fft_healthy_envelope(470/freq_healthy : 478/freq_healthy, i));

feature_matrix(i, 23) = max(fft_healthy_envelope(412/freq_healthy : 420/freq_healthy, i));

feature_matrix(i, 24) = max(fft_healthy_envelope(628/freq_healthy : 636/freq_healthy, i));

feature_matrix(i, 25) = max(fft_healthy_envelope(518/freq_healthy : 524/freq_healthy, i));

feature_matrix(i, 26) = max(fft_healthy_envelope(628/freq_healthy : 636/freq_healthy, i));

% feature_martix(i ,17) = "Healthy";

end

for i = 1:n

feature_matrix(i+n, 1) = kurtosis(df_fault1(:, i));

feature_matrix(i+n, 2) = rms(df_fault1(:, i));

feature_matrix(i+n, 3) = skewness(df_fault1(:, i));

feature_matrix(i+n, 4) = kurtosis(df_fault1_envelope(:, i));

feature_matrix(i+n, 5) = rms(df_fault1_envelope(:, i));

feature_matrix(i+n, 6) = skewness(df_fault1_envelope(:, i));

feature_matrix(i+n, 7) = max(fft_fault1(100/freq_fault1 : 108/freq_fault1, i));

feature_matrix(i+n, 8) = max(fft_fault1(154/freq_fault1 : 162/freq_fault1, i));

feature_matrix(i+n, 9) = max(fft_fault1(204/freq_fault1 : 212/freq_fault1, i));

feature_matrix(i+n, 10) = max(fft_fault1(312/freq_fault1 : 320/freq_fault1, i));

feature_matrix(i+n, 11) = max(fft_fault1(308/freq_fault1 : 316/freq_fault1, i));

feature_matrix(i+n, 12) = max(fft_fault1(470/freq_fault1 : 478/freq_fault1, i));

feature_matrix(i+n, 13) = max(fft_fault1(412/freq_fault1 : 420/freq_fault1, i));

feature_matrix(i+n, 14) = max(fft_fault1(628/freq_fault1 : 636/freq_fault1, i));

feature_matrix(i+n, 15) = max(fft_fault1(518/freq_fault1 : 524/freq_fault1, i));

feature_matrix(i+n, 16) = max(fft_fault1(628/freq_fault1 : 636/freq_fault1, i));

feature_matrix(i+n, 17) = max(fft_fault1_envelope(100/freq_fault1 : 108/freq_fault1, i));

feature_matrix(i+n, 18) = max(fft_fault1_envelope(154/freq_fault1 : 162/freq_fault1, i));

feature_matrix(i+n, 19) = max(fft_fault1_envelope(204/freq_fault1 : 212/freq_fault1, i));

feature_matrix(i+n, 20) = max(fft_fault1_envelope(312/freq_fault1 : 320/freq_fault1, i));

feature_matrix(i+n, 21) = max(fft_fault1_envelope(308/freq_fault1 : 316/freq_fault1, i));

feature_matrix(i+n, 22) = max(fft_fault1_envelope(470/freq_fault1 : 478/freq_fault1, i));

feature_matrix(i+n, 23) = max(fft_fault1_envelope(412/freq_fault1 : 420/freq_fault1, i));

feature_matrix(i+n, 24) = max(fft_fault1_envelope(628/freq_fault1 : 636/freq_fault1, i));

feature_matrix(i+n, 25) = max(fft_fault1_envelope(518/freq_fault1 : 524/freq_fault1, i));

feature_matrix(i+n, 26) = max(fft_fault1_envelope(628/freq_fault1 : 636/freq_fault1, i));

% feature_martix(n+i ,17) = "Fault1";

end

for i = 1:n

feature_matrix(i+2*n, 1) = kurtosis(df_fault2(:, i));

feature_matrix(i+2*n, 2) = rms(df_fault2(:, i));

feature_matrix(i+2*n, 3) = skewness(df_fault2(:, i));

feature_matrix(i+2*n, 4) = kurtosis(df_fault2_envelope(:, i));

feature_matrix(i+2*n, 5) = rms(df_fault2_envelope(:, i));

feature_matrix(i+2*n, 6) = skewness(df_fault2_envelope(:, i));

feature_matrix(i+2*n, 7) = max(fft_fault2(100/freq_fault2 : 108/freq_fault2, i));

feature_matrix(i+2*n, 8) = max(fft_fault2(154/freq_fault2 : 162/freq_fault2, i));

feature_matrix(i+2*n, 9) = max(fft_fault2(204/freq_fault2 : 212/freq_fault2, i));

feature_matrix(i+2*n, 10) = max(fft_fault2(312/freq_fault2 : 320/freq_fault2, i));

feature_matrix(i+2*n, 11) = max(fft_fault2(308/freq_fault2 : 316/freq_fault2, i));

feature_matrix(i+2*n, 12) = max(fft_fault2(470/freq_fault2 : 478/freq_fault2, i));

feature_matrix(i+2*n, 13) = max(fft_fault2(412/freq_fault2 : 420/freq_fault2, i));

feature_matrix(i+2*n, 14) = max(fft_fault2(628/freq_fault2 : 636/freq_fault2, i));

feature_matrix(i+2*n, 15) = max(fft_fault2(518/freq_fault2 : 524/freq_fault2, i));

feature_matrix(i+2*n, 16) = max(fft_fault2(628/freq_fault2 : 636/freq_fault2, i));

feature_matrix(i+2*n, 17) = max(fft_fault2_envelope(100/freq_fault2 : 108/freq_fault2, i));

feature_matrix(i+2*n, 18) = max(fft_fault2_envelope(154/freq_fault2 : 162/freq_fault2, i));

feature_matrix(i+2*n, 19) = max(fft_fault2_envelope(204/freq_fault2 : 212/freq_fault2, i));

feature_matrix(i+2*n, 20) = max(fft_fault2_envelope(312/freq_fault2 : 320/freq_fault2, i));

feature_matrix(i+2*n, 21) = max(fft_fault2_envelope(308/freq_fault2 : 316/freq_fault2, i));

feature_matrix(i+2*n, 22) = max(fft_fault2_envelope(470/freq_fault2 : 478/freq_fault2, i));

feature_matrix(i+2*n, 23) = max(fft_fault2_envelope(412/freq_fault2 : 420/freq_fault2, i));

feature_matrix(i+2*n, 24) = max(fft_fault2_envelope(628/freq_fault2 : 636/freq_fault2, i));

feature_matrix(i+2*n, 25) = max(fft_fault2_envelope(518/freq_fault2 : 524/freq_fault2, i));

feature_matrix(i+2*n, 26) = max(fft_fault2_envelope(628/freq_fault2 : 636/freq_fault2, i));

end

%% Kurtosis-RMS-SKEWNESS plot

y = 1:1:n;

figure();

scatter(y, feature_matrix(1:50,1));

hold on

scatter(y+50, feature_matrix(51:100,1));

scatter(y+100, feature_matrix(101:150,1));

title('kurtosis');

ylabel('Value');

legend('Healthy', 'Fault1', 'Fault 2')

hold off

figure();

scatter(y, feature_matrix(1:50,2));

hold on

scatter(y+50, feature_matrix(51:100,2));

scatter(y+100, feature_matrix(101:150,2));

title('RMS');

ylabel('Value');

legend('Healthy', 'Fault1', 'Fault 2')

hold off

figure();

scatter(y, feature_matrix(1:50,3));

hold on

scatter(y+50, feature_matrix(51:100,3));

scatter(y+100, feature_matrix(101:150,3));

title('Skewness');

ylabel('Value');

legend('Healthy', 'Fault1', 'Fault 2')

hold off

%% Final Metrix

header = {'Kurtosis','RMS','Skewness','Envelope Kurtosis', 'Envelope RMS','Envelope Skewness', 'Outer', 'Inner', 'Outer 2x', 'Inner 2x', 'Outer 3x', 'Inner 3x','Outer 4x', 'Inner 4x', 'Outer 5x', 'Inner 5x','Envelope Outer', 'Envelope Inner', 'Envelope Outer 2x', 'Envelope Inner 2x', 'Envelope Outer 3x', 'Envelope Inner 3x', 'Envelope Outer 4x', 'Envelope Inner 4x', 'Envelope Outer 5x', 'Envelope Inner 5x' };

feature_matrix = [header; num2cell(feature_matrix)];

%%

% %% ANALYSIS

% % % figure();

% % % kurtogram(envelope_up1, SR, 10)

% % % fft_fault1_env = 2*abs(fft(envelope_up1, 480000)/480000);

% % % df = 1/t_drive_fault1(end);

% % % Freq_range = [20000 21000];

% % % R1 = round(Freq_range(1)/df);

% % % R2 = round(Freq_range(2)/df);

% % % fft_drive_fault1_1 = fft_fault1_env;

% % % fft_drive_fault1_1(R1:R2) = 0;

% % % fft_drive_fault1_1(SR/df-R2: SR/df-R1)=0;

% % % fft_filtered = fft_drive_fault1 - fft_drive_fault1_1;

% % % figure();

% % % plot(freq_drive_fault1, abs(fft_filtered(1:length(freq_drive_fault1))));

% % %

% % % ifft_fault1 = length_drive_fault1*ifft(fft_filtered, length_drive_fault1)/2;

% % % figure();

% % % plot(t_drive_fault1, real(ifft_fault1));

% % % title('IFFT fault 1', 'FontSize', 16);

% % % xlim([0.3 00.45]);

% %% kurtogram

%

% figure();

% kurtogram(data_drive_fault1, SR, 5);

% % title("kurtogram fault1")

% figure();

% pkurtosis(data_drive_fault1,SR)

% figure();

% kurtogram(data_drive_fault2, SR, 10);

% figure();

% pkurtosis(data_drive_fault2,SR)

% % title("kurtogram fault2")

%

% %% ifft

% df = 1/t_drive_fault1(end);

% Freq_range = [22000 24000];

% R1 = round(Freq_range(1)/df);

% R2 = round(Freq_range(2)/df);

% fft_drive_fault1_1 = fft_drive_fault1;

% fft_drive_fault1_1(R1:R2) = 0;

% fft_drive_fault1_1(SR/df-R2: SR/df-R1)=0;

% fft_filtered = fft_drive_fault1 - fft_drive_fault1_1;

% figure();

% plot(freq_drive_fault1, abs(fft_filtered(1:length(freq_drive_fault1))));

%

% ifft_fault1 = length_drive_fault1*ifft(fft_filtered, length_drive_fault1)/2;

% figure();

% plot(t_drive_fault1, real(ifft_fault1));

% title('IFFT fault 1', 'FontSize', 16);

% xlim([0.2 00.275]);

%

% df = 1/t_drive_fault2(end);

% Freq_range = [9000 10500];

% R1 = round(Freq_range(1)/df);

% R2 = round(Freq_range(2)/df);

% fft_drive_fault2_1 = fft_drive_fault2;

% fft_drive_fault2_1(R1:R2) = 0;

% fft_drive_fault2_1(SR/df-R2 : SR/df-R1)=0;

% fft_filtered = fft_drive_fault2 - fft_drive_fault2_1;

% figure();

% plot(freq_drive_fault2, abs(fft_filtered(1:length(freq_drive_fault2))));

%

% ifft_fault2 = length_drive_fault2*ifft(fft_filtered, length_drive_fault2)/2;

% figure();

% plot(t_drive_fault2, real(ifft_fault2));

% title('IFFT fault 2', 'FontSize', 16);

% % xlim([0.25 0.275]);

%

%% STFT

figure();

stft(data_de_h(1: 24000),SR,Window=kaiser(256,5),OverlapLength=255,FFTLength=512);

title('STFT Healthy');

figure();

stft(data_de_f1(1:24000),SR,Window=kaiser(256,5),OverlapLength=220,FFTLength=512);

title('STFT Fault 1');

figure();

stft(data_de_f2(1: 24000),SR,Window=kaiser(256,5),OverlapLength=255,FFTLength=512);

title('STFT Fault 2')

%% Spectrogram

figure();

spectrogram(data_de_h(1:24000),100,80,100,SR,'yaxis');

% xlim([0.3 0.45]);

title('Spectrogram Healthy');

figure();

spectrogram(data_de_f1(1:24000),100,80,100,SR,'yaxis');

% xlim([0.3 0.45]);

title('Spectrogram Fault 1');

figure();

spectrogram(data_de_f2(1:24000),100,80,100,SR,'yaxis');

% xlim([0.3 0.45]);

title('Spectrogram Fault 2');

%% CWT

figure();

cwt(data_de_h(1:24000), SR);

title('CWT Healthy');

figure();

cwt(data_de_f1(1:24000), SR);

title('CWT Fault 1');

figure();

cwt(data_de_f2(1:24000), SR);

title('CWT Fault 2');

%% EMD

figure();

imf_healthy = emd(data_de_h,'MaxNumIMF',5,'Display',1);

emd(data_de_h,'MaxNumIMF',5)

title('EMD Healthy')

figure();

imf_fault1 = emd(data_de_f1,'MaxNumIMF',5,'Display',1);

emd(data_de_f1,'MaxNumIMF',5)

title('EMD Fault 1')

figure();

imf_fault1 = emd(data_de_f2,'MaxNumIMF',5,'Display',1);

emd(data_de_f2,'MaxNumIMF',5)

title('EMD Fault 2')

% %% EMD

%

% figure();

% [imf,residual,info] = emd(data_drive_fault1,'Interpolation','pchip');

% figure();

% imf1 = imf(:, 3);

% stft(imf1(1: 2400),48000,Window=kaiser(256,5),OverlapLength=255,FFTLength=512);

% title('stft-fault1-emd3','FontSize', 16 );

% figure();

% cwt(imf1(1: 2400), SR)

% title('cwt-fault1-emd3','FontSize', 16 );

%

% figure();

% [imf,residual,info] = emd(data_drive_fault2,'Interpolation','pchip');

% figure();

% imf2 = imf(:, 3);

% stft(imf2(1: 2400),48000,Window=kaiser(256,5),OverlapLength=255,FFTLength=512);

% title('stft-fault2-emd3','FontSize', 16 );

% figure();

% cwt(imf2(1: 2400), SR);

% title('cwt-fault2-emd3','FontSize', 16 );

%

% %% CWT

% figure();

% cwt(data_drive_fault1(1:1200), SR);

% figure();

% cwt(data_drive_fault2(1:1200), SR);