[Fault Diagnosis Analysis] Rolling bearing fault diagnosis feature extraction with Matlab code

?About the author: A Matlab simulation developer who loves scientific research. He cultivates his mind and improves his technology simultaneously.

For code acquisition, paper reproduction and scientific research simulation cooperation, please send a private message.

Personal homepage: Matlab Research Studio

Personal credo: Investigate things to gain knowledge.

For more complete Matlab code and simulation customization content, click

Intelligent optimization algorithm Neural network prediction Radar communication Wireless sensor Power system

Signal processing Image processing Path planning Cellular automaton Drone

Content introduction

Rolling bearings are one of the common key components in industrial equipment, and their normal operation is crucial to the reliability and performance of the equipment. However, due to the harsh working environment and wear and tear of long-term operation, rolling bearings are often prone to various failures. Therefore, timely and accurate fault diagnosis is crucial to the normal operation and maintenance of equipment.

In order to achieve fault diagnosis of rolling bearings, researchers have proposed many different methods and technologies. Among them, feature extraction algorithm is a commonly used method, which can extract feature information related to faults from vibration signals collected by sensors. This article will introduce the process of a feature extraction algorithm for rolling bearing fault diagnosis.

First, we need to collect the vibration signal of the rolling bearing. Normally, we use an acceleration sensor to convert vibration signals into electrical signals, which are recorded and stored through a data acquisition system.

Next, we need to preprocess the collected vibration signals. The purpose of preprocessing is to remove noise and interference from the signal to improve the accuracy of subsequent feature extraction. Commonly used preprocessing methods include filtering, noise reduction, and detrending.

After the preprocessing is completed, we can start feature extraction. The purpose of feature extraction is to extract fault-related feature information from vibration signals for subsequent fault diagnosis and classification. Common features include time domain features, frequency domain features, wavelet packet features, etc. Selecting appropriate features is critical to the accuracy and reliability of fault diagnosis.

After feature extraction is completed, we can use machine learning or pattern recognition algorithms for fault diagnosis and classification. Common algorithms include support vector machines, neural networks, and decision trees. These algorithms can accurately identify and classify rolling bearing fault types based on the extracted feature information.

Finally, we can display the fault diagnosis results in a visual way. Through charts and reports, we can clearly understand the fault type, extent and location of rolling bearings, thereby guiding subsequent maintenance and repair work.

To sum up, the rolling bearing fault diagnosis feature extraction algorithm process includes vibration signal collection, preprocessing, feature extraction, fault diagnosis and result display. Through this process, we can achieve accurate diagnosis of rolling bearing faults and provide strong support for the normal operation and maintenance of equipment.

Rolling bearing fault diagnosis is a complex and important field with broad application prospects. Future research can further explore more efficient and accurate feature extraction algorithms and fault diagnosis technologies to improve the reliability and performance of rolling bearings and make greater contributions to the development of industrial equipment.

Part of the code

%% Preliminary data processing of rolling bearing fault diagnosis
%================================================== ========================%
%% Data import processing G3015
%============================Bearing fault diagnosis data processing================== ==========%
%%Import Data
% fg=fopen('G3015.txt','r'); %Open the data file in reading mode

G302m=sum(G302j)/20000; %G302m is the mean value, G302j is the result after zero averaging processing, the same below
G302f=sum((G302j-G302m).^2); %G302f is the variance
G302rms=sqrt(sum(G302j.^2)/20000); %G302rms root mean square value
G302peak=(max(G302j)-min(G302j))/2; %G302peak is the peak value
G302c= G302peak/G302rms; %G302c is the peak factor
G302k=sum(G302j.^4)/((G302rms.^4)*20000); %G302k is the kurtosis coefficient
G302s=(G302rms*20000)/sum(abs(G302j)); %G302s is the waveform factor
G302cl=G302peak/(sum(sqrt(abs(G302j)))/20000).^2; %G302cl margin factor
G302i=(G302peak*20000)/sum(abs(G302j)); %G302i pulse factor

G303m=sum(G303j)/20000; %G303m is the mean value, G303j is the result after zero averaging processing, the same below
G303f=sum((G303j-G303m).^2); %G303f is the variance
G303rms=sqrt(sum(G303j.^2)/20000); %G303rms root mean square value
G303peak=(max(G303j)-min(G303j))/2; %G303peak is the peak value
G303c= G303peak/G303rms; %G303c is the peak factor
G303k=sum(G303j.^4)/((G303rms.^4)*20000); %G303k is the kurtosis coefficient
G303s=(G303rms*20000)/sum(abs(G303j)); %G303s is the waveform factor
G303cl=G303peak/(sum(sqrt(abs(G303j)))/20000).^2; %G303cl margin factor
G303i=(G303peak*20000)/sum(abs(G303j)); %G303i pulse factor

G304m=sum(G304j)/20000; %G304m is the mean value, G304j is the result after zero averaging processing, the same below
G304f=sum((G304j-G304m).^2); %G304f is the variance
G304rms=sqrt(sum(G304j.^2)/20000); %G304rms root mean square value
G304peak=(max(G304j)-min(G304j))/2; %G304peak is the peak value
G304c= G304peak/G304rms; %G304c is the peak factor
G304k=sum(G304j.^4)/((G304rms.^4)*20000); %G304k is the kurtosis coefficient
G304s=(G304rms*20000)/sum(abs(G304j)); %G304s is the waveform factor
G304cl=G304peak/(sum(sqrt(abs(G304j)))/20000).^2; %G304cl margin factor
G304i=(G304peak*20000)/sum(abs(G304j)); %G304i pulse factor

G305m=sum(G305j)/20000; %G305m is the mean value, G305j is the result after zero averaging processing, the same below
G305f=sum((G305j-G305m).^2); %G305f is the variance
G305rms=sqrt(sum(G305j.^2)/20000); %G305rms root mean square value
G305peak=(max(G305j)-min(G305j))/2; %G305peak is the peak value
G305c= G305peak/G305rms; %G305c is the peak factor
G305k=sum(G305j.^4)/((G305rms.^4)*20000); %G305k is the kurtosis coefficient
G305s=(G305rms*20000)/sum(abs(G305j)); %G305s is the waveform factor
G305cl=G305peak/(sum(sqrt(abs(G305j)))/20000).^2; %G305cl margin factor
G305i=(G305peak*20000)/sum(abs(G305j)); %G305i pulse factor

G306m=sum(G306j)/20000; %G306m is the mean value, G306j is the result after zero averaging processing, the same below
G306f=sum((G306j-G306m).^2); %G306f is the variance
G306rms=sqrt(sum(G306j.^2)/20000); %G306rms root mean square value
G306peak=(max(G306j)-min(G306j))/2; %G306peak is the peak value
G306c= G306peak/G306rms; %G306c is the peak factor
G306k=sum(G306j.^4)/((G306rms.^4)*20000); %G306k is the kurtosis coefficient
G306s=(G306rms*20000)/sum(abs(G306j)); %G306s is the waveform factor
G306cl=G306peak/(sum(sqrt(abs(G306j)))/20000).^2; %G306cl margin factor
G306i=(G306peak*20000)/sum(abs(G306j)); %G306i pulse factor

G307m=sum(G307j)/20000; %G307m is the mean value, G307j is the result after zero averaging processing, the same below
G307f=sum((G307j-G307m).^2); %G307f is the variance
G307rms=sqrt(sum(G307j.^2)/20000); %G307rms root mean square value
G307peak=(max(G307j)-min(G307j))/2; %G307peak is the peak value
G307c= G307peak/G307rms; %G307c is the peak factor
G307k=sum(G307j.^4)/((G307rms.^4)*20000); %G307k is the kurtosis coefficient
G307s=(G307rms*20000)/sum(abs(G307j)); %G307s is the waveform factor
G307cl=G307peak/(sum(sqrt(abs(G307j)))/20000).^2; %G307cl margin factor
G307i=(G307peak*20000)/sum(abs(G307j)); %G307i pulse factor

G308m=sum(G308j)/20000; %G308m is the mean value, G308j is the result after zero averaging processing, the same below
G308f=sum((G308j-G308m).^2); %G308f is the variance
G308rms=sqrt(sum(G308j.^2)/20000); %G308rms root mean square value
G308peak=(max(G308j)-min(G308j))/2; %G308peak is the peak value
G308c= G308peak/G308rms; %G308c is the peak factor
G308k=sum(G308j.^4)/((G308rms.^4)*20000); %G308k is the kurtosis coefficient
G308s=(G308rms*20000)/sum(abs(G308j)); %G308s is the waveform factor
G308cl=G308peak/(sum(sqrt(abs(G308j)))/20000).^2; %G308cl margin factor
G308i=(G308peak*20000)/sum(abs(G308j)); %G308i pulse factor

G309m=sum(G309j)/20000; %G309m is the mean value, G309j is the result after zero averaging processing, the same below
G309f=sum((G309j-G309m).^2); %G309f is the variance
G309rms=sqrt(sum(G309j.^2)/20000); %G309rms root mean square value
G309peak=(max(G309j)-min(G309j))/2; %G309peak is the peak value
G309c= G309peak/G309rms; %G309c is the peak factor
G309k=sum(G309j.^4)/((G309rms.^4)*20000); %G309k is the kurtosis coefficient
G309s=(G309rms*20000)/sum(abs(G309j)); %G309s is the waveform factor
G309cl=G309peak/(sum(sqrt(abs(G309j)))/20000).^2; %G309cl margin factor
G309i=(G309peak*20000)/sum(abs(G309j)); %G309i pulse factor

G3010m=sum(G3010j)/20000; %G3010m is the mean value, G3010j is the result after zero averaging processing, the same below
G3010f=sum((G3010j-G3010m).^2); %G3010f is the variance
G3010rms=sqrt(sum(G3010j.^2)/20000); %G3010rms root mean square value
G3010peak=(max(G3010j)-min(G3010j))/2; %G3010peak is the peak value
G3010c= G3010peak/G3010rms; %G3010c is the peak factor
G3010k=sum(G3010j.^4)/((G3010rms.^4)*20000); %G3010k is the kurtosis coefficient
G3010s=(G3010rms*20000)/sum(abs(G3010j)); %G3010s is the waveform factor
G3010cl=G3010peak/(sum(sqrt(abs(G3010j)))/20000).^2; %G3010cl margin factor
G3010i=(G3010peak*20000)/sum(abs(G3010j)); %G3010i pulse factor

%% Bearing Z3015 processing
%====================Data import and zero mean processing======================== =========%
%==============Read directly================================== ===================%
Z3015=textread('Z3015.txt','%f'); %read data to generate matrix
Z301=Z3015(1:1:20000); % Take the first 20000 elements of the array, which is the first set of data, and the number of sampling points is 20000
Z301j=Z301-mean(Z301); %zero mean processing, %Z301j=Z301-sum(Z301)/20000

Z302=Z3015(20001:1:40000);
Z302j=Z302-mean(Z302); %zero mean processing

Z303=Z3015(40001:1:60000);
Z303j=Z303-mean(Z303); %zero mean processing

Z304=Z3015(60001:1:80000);
Z304j=Z304-mean(Z304); %zero mean processing

Running results

[Fault Diagnosis Analysis] Rolling Bearing Fault Diagnosis Feature Extraction with Matlab Code_Feature Extraction

[Fault Diagnosis Analysis] Rolling Bearing Fault Diagnosis Feature Extraction with Matlab Code_Fault Diagnosis_02

[Fault Diagnosis Analysis] Rolling Bearing Fault Diagnosis Feature Extraction with Matlab Code_Feature Extraction_03

[Fault Diagnosis Analysis] Rolling Bearing Fault Diagnosis Feature Extraction with Matlab Code_Fault Diagnosis_04

References

[1] Zhao Peng. Research on rolling bearing fault diagnosis system based on virtual instrument[D]. Hebei Engineering University[2023-11-02].DOI:CNKI:CDMD:2.1017.010710.

[2] Wang Liang. Research on rolling bearing fault diagnosis system based on DSP [D]. Dalian University of Technology, 2008. DOI: 10.7666/d.y1418840.

Some theories are quoted from online literature. If there is any infringement, please contact the blogger to delete it

Follow me to receive massive matlab e-books and mathematical modeling materials

Private message complete code, paper reproduction, journal cooperation, paper tutoring and scientific research simulation customization

1 Improvement and application of various intelligent optimization algorithms

Production scheduling, economic scheduling, assembly line scheduling, charging optimization, workshop scheduling, departure optimization, reservoir scheduling, three-dimensional packing, logistics location selection, cargo space optimization, bus scheduling optimization, charging pile layout optimization, workshop layout optimization, Container ship stowage optimization, water pump combination optimization, medical resource allocation optimization, facility layout optimization, visible area base station and drone site selection optimization

2 Machine learning and deep learning

Convolutional neural network (CNN), LSTM, support vector machine (SVM), least squares support vector machine (LSSVM), extreme learning machine (ELM), kernel extreme learning machine (KELM), BP, RBF, width Learning, DBN, RF, RBF, DELM, XGBOOST, TCN realize wind power prediction, photovoltaic prediction, battery life prediction, radiation source identification, traffic flow prediction, load prediction, stock price prediction, PM2.5 concentration prediction, battery health status prediction, water body Optical parameter inversion, NLOS signal identification, accurate subway parking prediction, transformer fault diagnosis

2. Image processing

Image recognition, image segmentation, image detection, image hiding, image registration, image splicing, image fusion, image enhancement, image compressed sensing

3 Path planning

Traveling salesman problem (TSP), vehicle routing problem (VRP, MVRP, CVRP, VRPTW, etc.), UAV three-dimensional path planning, UAV collaboration, UAV formation, robot path planning, raster map path planning , multimodal transportation problems, vehicle collaborative UAV path planning, antenna linear array distribution optimization, workshop layout optimization

4 UAV application

UAV path planning, UAV control, UAV formation, UAV collaboration, UAV task allocation, and online optimization of UAV safe communication trajectories

5 Wireless sensor positioning and layout

Sensor deployment optimization, communication protocol optimization, routing optimization, target positioning optimization, Dv-Hop positioning optimization, Leach protocol optimization, WSN coverage optimization, multicast optimization, RSSI positioning optimization

6 Signal processing

Signal recognition, signal encryption, signal denoising, signal enhancement, radar signal processing, signal watermark embedding and extraction, EMG signal, EEG signal, signal timing optimization