ANNEE UNIVERSITAIRE

2018-2019

ECOLE NATIONALE SUPERIEURE D’INGENIEURS (ENSI)

PROJET DE PROGRAMMATION ORIENTE OBJET

DIMENSIONNEMENT DES PARAMETRES DE FABRICATION

D’UN MOTEUR À COURANT CONTINU ET SIMULATION DE
LA ROTATION DU ROTOR

UE : PROGRAMMATION ORIENTE OBJET(POO)

INF 2117
Parcours : MP
Département : GE/GM
SEMESTRE 1

Présenté Par : Dirigé Par :

PALOUKI M.Raoul (GE) Mr SALAMI Akim (MC)

ALIFA-SABI Ibourahim (GM)

Table des matières
I. Introduction .......................................................................................................................................... 3
II. Problématique....................................................................................................................................... 3
III. Description du projet ........................................................................................................................ 3
IV. Algorithme........................................................................................................................................ 4
V. Implémentation du programme ............................................................................................................ 5
1. Classe moteurCc ................................................................................................................................... 5
2. Le module marche et arrêt du moteur................................................................................................... 6
3. Fonction fiche Technique ..................................................................................................................... 7
4. Fonction acquisition des paramètres : .................................................................................................. 7
5. Programme principal ............................................................................................................................ 8
VI. Simulation et validation.................................................................................................................... 9
VII. Conclusion ...................................................................................................................................... 12

Tables des figures

Figure 1 interface d'acceuil........................................................................................................................... 9

Figure 2 illustration d'un changement de paramètre................................................................................... 10
Figure 3 début de la rotation après un clic sur simuler ............................................................................... 11
Figure 4 rotation en cours du rotor ............................................................................................................. 11
Figure 5 illustration de la fiche technique .................................................................................................. 12

2
 I. Introduction

Devenu aujourd‘hui un outil incontournable de tout ingénieur la programmation est

de nos jours en train de révolutionner le monde dans tous ses aspects. Et il revient à
l’ingénieur d’être en mesure de manipuler cet outil et ceux de façon commode afin
de ne pas se laisser dépasser par l’évolution technologique. Ainsi dit, c’est dans le
but de nous familiariser avec cet outil que nous avons eu à faire le cours de
programmation orienté objet qui nous a permis de nous initier aux bases de la
programmation modulaire dit orienté objet.
Nous présentons dans la suite un mini projet dont l’objectif est de faire ressortir le
caractère modulaire de la programmation.

II. Problématique

Le coût des matières premières et leur rareté augmentant au cours du temps,

l’optimisation de leur utilisation devient un souci majeur. On ne peut plus se
permettre de passer à des tests directement sur les produits conçus sans prime
abord avoir assez de précision sur le comportement qu’il adopterait au risque
rendre non réutilisable la matière première utilisé en cas de réajustement du
produit. Ainsi avoir des précisions sur le comportement qu’adopterais un produit
qu’on teste peut se faire en créant virtuellement à l’aide d’un outil numérique un
environnement qui respect au mieux les règles d’utilisation du produit. Ainsi afin
de mieux conditionner avant d’ordonnancer la fabrication en industrie d’un moteur
il devient nécessaire de faire un dimensionnement de simuler ce moteur avec
comme paramètre d’entrée les données qu’on doit avoir pour qu’en sortie le
moteur nous fournissent le caractéristiques que nous voulons avoir

III. Description du projet

Ce projet intitulé DIMENSIONNEMENT DES PARAMETRES DE FABRICATION D’UN

MOTEUR À COURANT CONTINU ET SIMULATION DE LA ROTATION DU ROTOR vise à
permettre à l’utilisateur de régler les paramètres d’entrés du moteur afin d’avoir en
sortie les caractéristiques techniques escompté pour un moteur que l’on prévoit
construire.
Le projet se présentera comme une interface avec une partie commande des
interactions et une partie visualisation des interactions

3
  Dans la partie commande des interactions on pourra régler les paramètres
d’entrées du moteur : tel que le flux, le nombre de tour par seconde et la
force électromotrice ;
 Dans la partie visualisation des interactions on pourra observer une vue de
face de la section du rotor qui tournera à une vitesse lié au réglage des
paramètres d’entrées
Une fois le nombre de tour par seconde ainsi que la puissance en sortie du moteur
étant ceux désiré on pourra cliquez sur un bouton qui affichera une fiche des
caractéristiques techniques du moteur ; fiche qui sera utile pour la fabrication du
moteur.

IV. Algorithme

Dans le cas d’un programme qui utilise une interface graphique, l’organisation
interne est différente de celle de l’algorithme ordinaire. On dit d’un tel programme
qu’il est piloté par les événements. Après sa phase d’initialisation, un programme
de ce type se met en quelque sorte « en attente », et passe la main à un autre
logiciel, lequel est plus ou moins intimement intégré au système d’exploitation de
l’ordinateur et « tourne » en permanence.

Initialisation du
paramètre (flux, nombre
de tour et f-e-m)

 Réglage de
Ordinateur Réceptionnaires paramètre
d’évènements  Marche
 Arrêt
 Fiche
technique

Terminaison

4
Commentaire : une fois la phase d’initialisation terminé le réceptionnaire
d’évènement se met en marche et attend de détecter une action externe de
ordinateur (dans notre cas un clic sur un bouton) pour mettre en marche des
instructions préprogrammées à savoir :
 Réglage des paramètres
 Marche rotor
 Arrêt rotor
 Fiche Technique

V. Implémentation du programme

Bibliothèques utilisées :
from tkinter import *
import math
import time

L’implémentation de notre programme c’est fait en cinq parties :

1. Classe moteurCc

class MoteurCc(object):
def __init__(self):
self.flux = 1.2
self.fem = 50
self.nbre_tour_par_seconde = 1200

def parametrage(self,flux,fem,n):
self.flux=flux
self.fem=fem
self.nbre_tour_par_seconde=n

def vitesse_angulaire(self,n,flux):
Vang=(2*n*(math.pi))
return Vang

def nombre_de_conducteur(self,flux,fem,n):

global N
N=((2*int(math.pi))*int((fem))/n)

return N
5
 def fiche_technique(self,fcem,N,n):
fenetre = Tk()

fenetre.title('FICHE TECHNIQUE DU MOTEUR')

fenetre['bg']='grey'
titre = Label(fenetre, text="FICHE TECHNIQUE DU MOTEUR:", relief=RAISED, font=('arial',
15, 'bold'))
titre.grid(row=0,columnspan=5)

for (i,j) in ((1,"Type de Machine"),(2,"Nombres de Conducteur: " ),(3,"Nombres de tours par

seconde: "),(4,"Force contre électromotrice: "),(5,"Puissance de sortie: ")) :
Label(fenetre, text=' %s ' % (j), borderwidth=1).grid(row=i, columnspan=2)
fenetre.mainloop()

2. Le module marche et arrêt du moteur

def ajuster_ligne(line, x0, y0, angle, longueur):

global longueur

x = longueur * math.cos(angle)
y = longueur * math.sin(angle)
can1.coords(line, x0, y0, x0 + x, y0 + y)

def ajuster_angle(delta_angle):

global flag,angle,angle1,angle2, longueur

angle += delta_angle
angle1 += delta_angle
angle2 += delta_angle
display_line_angle(line, x0, y0, angle, longueur)
display_line_angle(line1, x0, y0, angle1, longueur)
display_line_angle(line2, x0, y0, angle2, longueur)
if flag <= 0:
return
if flag >0 :
fen1.after(50, update_angle,moteur.nbre_tour_par_seconde)
def rotation():
global flag
flag=1
update_angle(moteur.nbre_tour_par_seconde)

def arret():
global flag

6
 flag=0
return

3. Fonction fiche Technique

def fiche_technique():

fenetre = Toplevel(fen1)
global N
fenetre.title('FICHE TECHNIQUE DU MOTEUR')
fenetre['bg']='white'
titre = Label(fenetre, text="FICHE TECHNIQUE DU MOTEUR:", relief=RAISED, font=('arial', 15,
'bold'))
titre.grid(row=0,columnspan=5)

for (i,j) in ((1,"Type de Moteur:"),(2,"Nombres de conducteurs:"),(3,"vitesse du

rotor(tr/min):"),(4,"Fréquence nominale: "),(5,"flux de l'inducteur:"),(6,"Tension d''alimentation:
")) :
Label(fenetre, text=' %s ' % (j), borderwidth=1).grid(row=i, column=0,sticky =W)
for (i,j) in ((1,"Moteur à Courant continu"),(2,3),(3,moteur.nbre_tour_par_seconde),(4,"50Hz
"),(5,moteur.flux),(6,moteur.fem)) :
Label(fenetre, text=' %s ' % (j), borderwidth=1).grid(row=i, column=3,sticky =W)

4. Fonction acquisition des paramètres :

def aquisition():
def recupere_donnees():

global v1,v2,v3
v1=entr1.get()
v2=entr2.get()
v3=entr3.get()
txt4 = Label(fen1, text=v1 )
txt5 = Label(fen1, text=v2)
txt6 = Label(fen1, text=v3)
txt4.grid(row =0, column= 1, sticky =E)
txt5.grid(row =1, column= 1, sticky =E)
txt6.grid(row =2, column= 1, sticky =E)
print(v1)
fen2 = Toplevel(fen1)
fen2.title('réglage de parametre')
txt1 = Label(fen2, text ='flux de l''inducteeur(Wb) :')
txt2 = Label(fen2, text ='Vitesse de rotation du rotor (tr/s):')
txt3 = Label(fen2, text ='force contre électromotrice (E):')
bou = Button(fen2, text='valider',command=recupere_donnees )

7
 entr1 = Entry(fen2)
entr2 = Entry(fen2)
entr3 = Entry(fen2)
txt1.grid(row =1, sticky =E)
txt2.grid(row =2, sticky =E)
txt3.grid(row =3, sticky =E)
entr1.grid(row =1, column =2)
entr2.grid(row =2, column =2)
entr3.grid(row =3, column =2)
bou.grid(row=4,column=1)
global vang
vang=moteur.vitesse_angulaire

5. Programme principal

global v1,v2,v3
moteur=MoteurCc()
fen1=Tk()
fen1.title("simulation_moteur")

txt1 = Label(fen1, text = 'flux de l''inducteeur(Wb) :')

txt2 = Label(fen1, text = 'Vitesse de rotation du rotor (tr/s):')
txt3 = Label(fen1, text = 'force contre électromotrice (V):')
txt4 = Label(fen1, text=0 )
txt5 = Label(fen1, text=0)
txt6 = Label(fen1, text=0)

txt1.grid(row =0, sticky =E)

txt2.grid(row =1, sticky =E)
txt3.grid(row =2, column= 0, sticky =E)
txt4.grid(row =0, column= 1, sticky =E)
txt5.grid(row =1, column= 1, sticky =E)
txt6.grid(row =2, column= 1, sticky =E)

bout1 = Button(fen1,text='changer parametre', command =aquisition )

bout1.grid(row=3,sticky =W)
bout2 = Button(fen1,text='simuler',command=rotation )
bout2.grid(row=3, column=1, sticky =E)
bout3 = Button(fen1,text='arrêt',command=arret )
bout3.grid(row=4, column=1, sticky =E)
bout4 = Button(fen1,text='fiche technique',command=fchtq )
bout4.grid(row=4, column=0, sticky =W)

can1 = Canvas(fen1, width =300, height =300, bg ='green')

can1.grid(row =0, column =3, rowspan =4, padx =10, pady =15)

8
 can1.create_line(150, 0, 150, 300, fill ='blue')
can1.create_line(0, 150, 300, 150, fill ='blue')
can1.create_oval(50, 50, 250, 250, outline='black')

global x0, y0 ,flag,longueur,angle,angle1,angle2

x0, y0,flag,lenght,angle,angle1,angle2 = 150, 150,0,100,0,-(math.pi)*(2/3),2*(math.pi)/3
line = can1.create_line((x0, y0, 0, 0), width=4, fill='red', smooth=True)
line1 = can1.create_line((x0, y0, 71, 71), width=4, fill='red', smooth=True)
line2 = can1.create_line((x0, y0, -10,11), width=4, fill='red', smooth=True)
display_line_angle(line, x0, y0, angle, longueur)
display_line_angle(line1, x0, y0, angle1, longueur)
display_line_angle(line2, x0, y0, angle2, longueur)
fen1.mainloop()

VI. Simulation et validation

Une fois le programme exécuté nous obtenons une interface qui se présente comme
suit :

Figure 1 interface d'acceuil

Nous remarquons que nous avons quatre possibilités d’action sur le système :

 changer parametre pour le réglage des paramètres d’entrées

 simuler pour la Marche rotor
9
  Arrêt pour l’arrêt rotor
 Fiche Technique pour afficher la liste des caractéristiques du moteur

 nous cliquons sur changer paramètre pour initialiser nos paramètre de

simulation et nous obtenons l’interface ci-dessous où nous donnons des
valeurs voulues aux paramètres qui nous sont imposés :

Figure 2 illustration d'un changement de paramètre

 une fois les paramètres initialisés nous cliquons sur le bouton simuler .notre
rotor ici est représenter par trois ligne rouge représentant les trois phases ces
trois ligne se mettent à tourner à la vitesse calculer par la méthode
moteur.vitesse_angulaire()

10
 Figure 3 début de la rotation après un clic sur simuler

Figure 4 rotation en cours du rotor

Une fois la simulation lancée nous disposons de la touche arrêt pour arrêter
la simulation

 à chaque fois que nous initialisons les paramètres les méthodes de la classe
moteur s’exécutent et met à notre disposition les valeurs des paramètres
utiles pour ordonnancer la fabrication. Ainsi fait nous avons implémenter la
méthode fiche technique qui regroupe toute les caractéristiques du moteur
relativement à nos paramètres d’entrées :
11
 Figure 5 illustration de la fiche technique

VII. Conclusion

Par ce mini projet nous remarquons l’importance de la programmation modulaire

entre autre : l’amélioration de la lisibilité, chaque module peut être implémenter
par des personnes indépendantes réduisant ainsi le temps d’implémentation de
l’ensemble du code, et aussi la réutilisabilité des objets créer par d’autres
programmeurs pour d’autres applications.

12