Analyse et détection des défauts de roulement dans un moteur électrique

Rapport du mini-projet Python

Réalisé par : AZONHOUMON Houénoumè Horacia Gloriéta

RAVELOHARISOA Mickaella Fandresena
ANDRIASAHY Tsikomia Scidelo

Mini-projet : N° 15
Filière : GSEA1

Supervisé par : Professeur Saad Chakkor

Année Universitaire : 2024/2025

Table des matières
I. Introduction...................................................................................................................... 2
II. Structure du code..............................................................................................................3
1. Importation des bibliothèques :.....................................................................................3
2. Fonctions Principales......................................................................................................3
a. get_frequences_harmonique..................................................................................3
b. generer_signal........................................................................................................ 4
c. enregistrer_sur_fichier...............................................................................................5
d. calculer_FFT............................................................................................................ 6
e. les_courbes.............................................................................................................6
f. run_simulation........................................................................................................... 7
3. Le code principal............................................................................................................ 7
a. Organisation en sections ........................................................................................8
b. Résultat................................................................................................................... 9
III. Conclusion.......................................................................................................................10

1
 I. Introduction

Les roulements, composants essentiels des machines industrielles, jouent un rôle clé
dans leur bon fonctionnement. La détection précoce de leurs défauts est cruciale pour
réduire les temps d'arrêt et les coûts de maintenance. Ce projet vise à étudier les signaux du
courant statorique d'un moteur électrique équipé de roulements, afin de simuler ces
signaux, d'analyser les signatures fréquentielles des défauts, de créer une interface
utilisateur graphique pour faciliter les simulations, et de sauvegarder les échantillons des
signaux générés dans un fichier texte.

Figure 1 extrait1 du code

2
II. Structure du code

Dans tout le code, on fixe que L=1

1. Importation des bibliothèques :

Le projet utilise plusieurs bibliothèques Python essentielles :

 numpy : pour les calculs numériques et la manipulation des tableaux de données.
 math : pour les opérations mathématiques avancées.
 matplotlib : pour la visualisation des signaux sous forme de graphiques.
 tkinter : pour la création d'une interface utilisateur graphique interactive.

2. Fonctions Principales

a. get_frequences_harmonique(f0,nb,fr,k) :

Cette fonction est utilisée pour calculer les fréquences harmoniques associées à un signal en
prenant en compte plusieurs paramètres physiques. Ces fréquences sont calculées à partir
d'une fréquence de base et des caractéristiques d'un roulement.

Figure 2 La signature fréquentielle d’un défaut de roulements endommagés (Bearing damage)

 Paramètres

3
  f0 (float) :La fréquence de base du système, généralement la fréquence
d'alimentation électrique.
 nb (int) :Le nombre de billes dans le roulement.
 fr (float) :La fréquence de rotation du rotor.
 k (int) :Un coefficient multiplicateur pour ajuster les fréquences harmoniques.

 Retour : un tableau de taille 2, contenant deux valeurs correspondant aux

fréquences harmoniques liées à la fréquence intérieure.

b. generer_signal(f0, nb, fr, k, nb_echantillon, Ts,ak, phik,

snr_db1, snr_db2) :
Cette fonction génère des signaux temporels simulant les conditions de fonctionnement d'un
moteur électrique. Elle produit un signal sain (sans défaut), un signal défectueux (avec des
fréquences harmoniques liées à un défaut) et ajoute différents niveaux de bruit pour simuler
des conditions réelles.

Figure 3 la formule du courant statorique x[n]

 Paramètres

 f0 (float) :La fréquence de base du signal

 nb (int) :Nombre de billes dans le roulement.
 fr (float) :Fréquence de rotation du rotor (en Hz).
 k (int) :Coefficient utilisé pour calculer les fréquences harmoniques.
 nb_echantillon (int) :Nombre total d'échantillons à générer.
 Ts (float) : Période d'échantillonnage (inverse de la fréquence d'échantillonnage).
 ak (list of float) :Amplitudes des composantes fréquentielles. La taille de la liste est
fixée à 3 car L=1.
 phik (list of float) :Phases des composantes fréquentielles. La taille de la liste est
également de 3.
 snr_db1, snr_db2 (float) :Niveaux de bruit en décibels (SNR : Signal-to-Noise Ratio)
pour générer deux variantes de signal défectueux bruités.

4
  Retour :
La fonction retourne quatre listes :

 t_list : la liste des temps.

 signal_sain : le signal sain.
 signal_defectueux1 : le signal défectueux avec le premier SNR (snr_db1).
 signal_defectueux2 : le signal défectueux avec le second SNR (snr_db2).

Figure 4 extrait2 du code

c. enregistrer_sur_fichier(t_list,signalSain,signalDefectueux1,si
gnalDefectueux2) :

Elle sauvegarde les signaux générés dans un fichier texte nommé “[Link]”

5
  Paramètres
 t_list (list ou numpy array) :Contient les valeurs de temps correspondantes aux
échantillons.
 signalSain (list ou numpy array) :Le signal sain généré (sans défaut ni bruit).
 signalDef1 (list ou numpy array) :Le premier signal défectueux, bruité avec un niveau
de SNR spécifique.
 signalDef2 (list ou numpy array) :Le deuxième signal défectueux, bruité avec un autre
niveau de SNR.
 Retour :
Cette fonction ne retourne rien.

d. calculer_FFT(signal1,signal2, fs) :

Cette fonction calcule la Transformée de Fourier Rapide (FFT) pour deux signaux donnés, ce
qui permet d'analyser leurs caractéristiques dans le domaine fréquentiel.
 Paramètres
 signal1 (list ou numpy array) :Le premier signal à analyser dans le domaine
fréquentiel.
 signal2 (list ou numpy array) :Le second signal à analyser dans le domaine
fréquentiel.
 fs (float) :La fréquence d'échantillonnage du signal (en Hz), utilisée pour calculer les
fréquences associées à la FFT.
 Retour :
 freq : Un tableau contenant les fréquences associées aux coefficients de la FFT.
 magnitude1 : La magnitude de la transformée de Fourier de signal1.
 magnitude2 : La magnitude de la transformée de Fourier de signal2.

e. les_courbes(t, signal_sain,
signal_def1,signal_def2,f,amp_TFF_def1,amp_TFF_def2) :

Cette fonction affiche quatre sous-graphes pour analyser les signaux :

 Haut gauche : Affiche le signal sain (sans défaut) en fonction du temps.
 Haut droite : Compare les deux signaux défectueux (avec deux niveaux de SNR -
rapport signal/bruit) sur la même échelle de temps.
 Bas gauche : Affiche la Transformée de Fourier (FFT) du premier signal défectueux en
amplitude/fréquence.

6
  Bas droite : Affiche la Transformée de Fourier du deuxième signal défectueux.
 Retour :
Cette fonction ne retourne rien.
f. run_simulation() :

Cette fonction est le point central qui exécute la simulation complète : Les valeurs saisies
sont récupérées à partir d'entrées utilisateur.
 Génération des signaux : Appelle generer_signal pour générer un signal sain et deux
signaux défectueux (avec différents niveaux de bruit).
 Sauvegarde des données : Utilise enregistrer_sur_fichier pour sauvegarder les
signaux générés dans un fichier.
 Analyse fréquentielle : Appelle calculer_FFT pour obtenir la FFT (Transformée de
Fourier) des signaux défectueux et leurs amplitudes spectrales.
 Affichage des courbes : Passe les données générées et analysées à la fonction
les_courbes pour afficher les quatre graphiques.

Figure 5 extrait3 du code

3. Le code principal

7
 a. Organisation en sections (LabelFrames)

Le code organise l'interface en 4 sections logiques pour la saisie des paramètres :

 Fréquences et Phases :
o Entrées pour :
 La fréquence d'alimentation électrique fo
 La fréquence du rotor fr
 La phase phiK
 Un entier K

 Fréquences Électriques :
o Entrée pour :
 La fréquence d'échantillonnage fs

 Paramètres de Roulement :
o Entrées pour :
 Le nombre d'échantillons n
 Le nombre de billes dans le roulement nb

 Amplitudes et SNR (Rapport Signal/Bruit) :

o Entrées pour :
 Les amplitudes a-1, a0, a1
 Deux valeurs de SNR snr1 et snr2

Un bouton "VALIDER" permet de lancer la simulation en appelant la fonction run_simulation

8
b. Résultat

 L’interface utilisateur

Figure 6 interface utilisateur

 Les courbes des signaux

Figure 7 les courbes des signaux

9
III. Conclusion

L'analyse et la détection des défauts de roulement dans un moteur électrique à l'aide

de techniques de programmation Python ont démontré l'efficacité et la précision des
approches modernes basées sur l'analyse vibratoire et le traitement du signal. Grâce à
l'application d'algorithmes avancés tels que la transformation de Fourier rapide (FFT).
Bref, ce projet souligne non seulement les avantages de l'utilisation de la
programmation Python dans le domaine de l'analyse vibratoire, mais aussi le potentiel de ces
technologies pour révolutionner la maintenance industrielle et la gestion des actifs. Les
perspectives futures incluent l'amélioration des algorithmes de détection, l'optimisation des
modèles prédictifs et l'élargissement des applications à d'autres types de machines et
d'industries.

10