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
