Page 1
²&<
REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
Ministère de l’Enseignement Supérieur
et de la Recherche Scientifique
Université Abderrahmane Mira de Bejaia
Faculté de Technologie Département d’Electronique
En vue de l’obtention d’un diplôme des études universitaires
appliquées en électronique
Option : communication
Promotion : 2008-2009
Commande de deux moteurs pas à
pas via le port parallèle avec
Delphi
Encadré par:
Mr BOUDJELLABA.K
Réalisé par :
Mr ZENATI A/Hakim
Mr KERROUCHE Samir
Page 2
Dédicaces
Je dédie ce modeste travail : À Mes parents, symboles de courage et de volonté, qui ont consacré et sacrifié leurs vies pour mon bien être ;
À Ma grande mère « que Dieu la garde pour notre famille » ;
À Mes frères Farouk et sa femme Djahida, et Ghanni ;
À Mes sœurs et leurs maris: Noura et Djoudi, Soraya et Houcine, Naima et Samir, Souad et Rabah;
À Mes neveux: Halim, Aris, El-Hassen;
À Mes nièces: Lydia, et Alissia;
À Mes oncles et tantes, cousins et cousines;
À Toute la famille ZENATI;
À Mes chers amis: Nabil, Bazy, Redouane, Nadir, Halim, Fahim, Laid…etc.
À Mes amies: Salima et Nawal;
À Mon ami et celui que j’ai partagé ce modeste travail: Samir, ainsi qu’à toute sa famille.
À Toute la PROMOTION 2009.
Hakim
Page 3
Dédicaces
Je dédie ce modeste travail :
À Mes parents, symboles de courage et de volonté, qui ont consacré et sacrifié leurs vies pour mon bien être ;
À Mes frères;
À Mes sœurs;
À Mes neveux:;
À Mes nièces surtout Wassila;
À Mes oncles et tantes, cousins et cousines;
À Ma future femme;
À Mes chers amis: Nabil, Halim, Fahim, Nouri, Bob …etc.
À mon ami et celui que j’ai partagé ce modeste travail: Hakim, ainsi qu’à toute sa famille.
À Toute la PROMOTION 2009.
Samir
Page 4
Nous tenons à remercier notre Dieu, le tout puissant, de nous avoir
donné la santé et la volonté pour compléter ce modeste travail.
Nous tenons à exprimé nos profondes gratitudes et nos vifs
remerciements à notre promoteur Mr K.BOUDJELLABA, ainsi à
notre Co-promoteur, Mr O.GUENOUNOU pour l’aide, le suivi et les
conseils qu’ils nous ont prodigués tout au long de ce travail.
Nos remerciements s’adressent aussi au président de jury et à ses
membres qui ont accepté de juger notre travail.
Enfin nos remerciements s’adressent plus particulièrement à nos familles et nos amis(es) qui ont su nous soutenir, nous encourager, nous aider et nous supporter
tout au long des années.
Hakim et Samir
Page 5
Sommaire
Introduction général
Chapitre I Généralités sur les moteurs pas à pas
Introduction
I.1 Moteur pas à pas:………………………………………………………………………1
I.2 Les différents types de moteurs:…………………………………………………….3 I.2.1 Les moteurs à aimants permanents (moteur unipolaire et bipolaire):……………………3
I.2.1.1 Les moteurs unipolaires:……………………………………………………………….4
I.2.1.2 Les moteurs bipolaires:………………………………………………………………...6
I.2.2 Les moteurs à réluctance variable:……………………………………………………….9
I.2.3 Les moteurs hybrides:……………………………………………………………………9
I.2.4 Nombre de phase..............................................................................................................10
I.3 Alimentation des moteurs pas à pas:……………………………………………….11
I.3.2 Alimentation unidirectionnelle et bidirectionnelle:……………………………………..11
I.3.1 Alimentation en tension:………………………………………………………………...11
I.3.2.1 Alimentation unidirectionnelle:……………………………………………………….11
I.3.2.2 Alimentation bidirectionnelle:………………………………………………………...13
Conclusion
Chapitre II Port parallèle et programmation sous Delphi
Introduction
II.1 Port parallèle:………………………………………………………………………....15 II.1.1 Définition:……………………………………………………………………………...15
II.1.2 description du port:…………………………………………………………………….15
II.1.3 Les différentes broches du port:………………………………………………………..16
II.1.4 Programmation du port en assembleur:………………………………………………..16
II.1.5 Intérêt du port parallèle:………………………………………………………………..17
II.2 Delphi:............................................................................................................................17 II.2.1 Introduction au Delphi 7:………………………………………………………………17
II.2.2 Présentation de l’environnement de travail sous Delphi 7:……………………………17
II.2.3 Fenêtre des menus, de la barre des outils, et de la palette des composants:…………...18
II.2.4 Fenêtre de l’inspecteur d’objet:………………………………………………………..19
II.2.5 Fenêtre de la fiche principale:………………………………………………………….20
II.2.6 Fenêtre de code source:………………………………………………………………...21
II.2.7 Projet:…………………………………………………………………………………..22
II.2.8 Les fichiers créés par Delphi:………………………………………………………….22
Conclusion
Page 6
Chapitre III Réalisation de la carte d’interface
Introduction
III.1 Interface graphique:………………………………………………………………...24
III.1.1 Présentation de l’interface:……………………………………………………………24
III.1.2 Fonctionnement de l’interface graphique:………………………………………….....27
III.2 Carte d’interface:........................................................................................................27
III.2.1 Etude de la carte d’interface:……………………………………………………….....27
III.2.1.1 Verrou 74HCT573:……………………………………………………………….....28
III.2.1.2 Commutateur de puissance ULN2803:……………………………………………..30
III.3 Alimentation:...............................................................................................................32
III.4 Essai et résultat:……………………………………………………………………..33
Conclusion
Conclusion général
Annexe 1: 74HCT573.
Annexe 2: ULN2803.
Annexe 3: Circuit imprimé et l’implantation des composants.
Annexe 4: Source du programme.
Page 7
Introduction général
Le principe du moteur pas à pas est connu de longue date, mais son développement
commencé dans les années 1960 grâce à l’événement de l’électronique numérique.
Tout en variant la vitesse de déplacement et le sens de rotation, l’utilisation d’un
moteur pas à pas devient un choix impératif. Il est utilisé dans tout ce qui demande une
précision de positionnement tels que : la robotique, l’astronomie et dans un nombre de
périphérique informatique : imprimante, disque dur, lecteur de disquette, scanner, …etc.
Il existe de nombreux systèmes de commande dédie au moteur pas à pas. De nos jours,
la commande la plus utilisée est celle par le micro-ordinateur grâce aux interfaces qui
permettent d’établir la communication entre l’unité centrale et les périphériques.
On distingue deux type d’interfaces, les interfaces série et les interfaces parallèles.
L’utilisation du port série n’est pas très pratique dans certaines applications car il faudrait
dissérialiser les données [3], c’est pourquoi on s’oriente beaucoup plus au port parallèle, qui
présente l’avantage de transmettre les données simultanément, donc rapidement.
Notre objectif consiste à commander deux moteurs pas à pas par PC via le port
parallèle.
Le mémoire est organisé en trois chapitres: le premier est consacré aux moteurs pas à
pas où on donne leurs définitions, les différents type des moteurs est les modes
d’alimentation. Le deuxième est pour le port parallèle et la programmation sur Delphi, enfin
le dernier est consacré à la description des cartes graphique et d’interface.
Une conclusion générale achève le mémoire.
Page 9
Chapitre I: Généralités sur les moteurs pas à pas
1
Introduction:
Le moteur pas à pas est l’interface idéale entre l’électronique numérique et la
mécanique, il permet de convertir directement un signal électrique en un positionnement
angulaire à caractère incrémental. Pour cela on utilise le port parallèle d’un ordinateur de type
PC qu’on commande avec une interface créée avec Delphi.
I.1 Moteur pas à pas: [1]
Il existe trois types de moteur pas à pas: les moteurs à aimants permanents et les moteurs à
réluctance variable et les moteurs hybrides. Nous verrons plus loin que les moteurs à aimants
permanents se subdivisent également en deux catégories.
Malgré les différences existant entre les moteurs, le résultat recherché est l’avance d’un
seul pas, c'est-à-dire la rotation de leur axe suivant un angle déterminé à chaque impulsion
que l’une ou l’autre de leurs différentes bobines recevra. Cet angle, qui varie selon la
constitution interne du moteur, est en général compris entre 0.9° et 90°.
Les moteurs les plus couramment rencontrés présentent des pas de :
0,9° soit 400 pas par tour ;
1,8° soit 200 pas par tour ;
3,6° soit 100 pas par tour ;
7,5° soit 48 pas par tour ;
15° soit 24 pas par tour ;
Il est évident que les moteurs pas à pas, de par leur technologie, présentent une très grande
précision et une durée de vie quasi illimitée, l’usure mécanique étant pratiquement inexistante
(absence de frottements). La figure ci-dessous nous montre l’aspect externe d’un moteur pas à
pas.
Fig I.1: Moteur pas à pas
Page 10
Chapitre I: Généralités sur les moteurs pas à pas
2
Sa structure interne est donnée par la figure suivante :
Fig I.2: Structure interne d’un moteur pas à pas
Les moteurs pas à pas existent en différentes tailles qui varient de 1 cm à plus d’une
dizaine de centimètres. Tout dépendra des applications dans lesquelles ils seront utilisés. Le
plus petit moteur, par exemple, sera destiné au déplacement des têtes de lecture dans les
lecteurs de disquettes ou dans les disques durs où un couple très faible est requis. Par contre,
le déplacement d’un bras de robot demandera un couple nettement plus important, donc un
moteur de diamètre élevé.
Signalons que le couple est exprimé le plus souvent en kilogrammes par centimètre
(Kg/cm), ce qui définit le poids en kilogrammes que pourra soulever l’axe d’un moteur
pourvu d’un bras de longueur exprimée en centimètres.
La valeur de leur tension d’alimentation varie dans de grandes proportions, elle peut
être comprise entre 3V et plusieurs dizaines de volts. De même, selon la résistance ohmique
de leurs bobinages, le courant consommé s’étendra dans une gamme allant de quelques
dizaines de milliampères à plusieurs ampères. Alors on peut dire que plus le courant sera
élevé, plus le couple sera important.
En ce qui nous concerne, les détaillants commercialisent la plupart du temps, sauf
exception rare, des moteurs de type standard, de consommation moyenne et possédant un
couple de puissance relativement bas. Ce faible couple pourra être compensé par l’adjonction
d’une démultiplication constituée de pignons. La vitesse de rotation diminuera mais le couple
augmentera dans de fortes proportions, ce qui constituera une solution intermédiaire étant
donné le prix prohibitif des moteurs pas à pas de forte puissance.
Nous allons maintenant aborder plus en détail ce qui différencie chaque type de
moteur, leur technologie et les principaux types de commande.
Page 11
Chapitre I: Généralités sur les moteurs pas à pas
3
I.2 Les différents types de moteurs :
I.2.1 Les moteurs à aimants permanents (moteurs unipolaires et bipolaires) :
Les moteurs à aimants sont ceux que nous utiliserons dans notre projet de fin d’étude.
Ils sont constitués d’un stator supportant les bobinages et d’un rotor magnétique (aimant
bipolaire). Comme nous l’avons dit plus haut, cette catégorie de moteur se subdivise en
deux types : le moteur unipolaire et le moteur bipolaire.
Fig I.3: Fonctionnement schématique d’un moteur pas à pas.
Page 12
Chapitre I: Généralités sur les moteurs pas à pas
4
La Fig I.3 représente le schéma simplifié d’un moteur à aimant. Le dessin du haut de
la figure représente dans sa position de repos, lorsque les bobinages ne sont traversés par
aucun courant. Chacun des pôles du rotor se place devant une paire des plots de stator.
Les quatre dessins du bas de la figure illustrent ce qui se passe lorsque les bobinages
sont alimentés à tour de rôle : d’abord A puis B, ensuite C et enfin D. Le pôle nord du rotor
sera attiré par le pôle sud du stator, pôle créé par la circulation d’un courant dans le bobinage.
Cet exemple permet de comprendre la progression pas par pas du moteur. Ici, il
effectuera 4 pas par tour.
I.2.1.1 Les moteurs unipolaires :
Une représentation schématisée d’un moteur unipolaire est donnée en Fig I.4. Afin
d’inverser le sens du courant, les enroulements sont réalisés au moyen de deux fils dont l’une
des extrémités est reliée au pôle + ou au pôle – de l’alimentation. La commande de ce type
moteur est la plus simple de tous les moteurs pas à pas puisqu’il suffira d’alimenter les
bobinages à tour de rôle pour faire tourner l’axe d’un pas. Le schéma de la Fig I.5 résume la
séquence la plus simple.
Fig I.4: Représentation schématique d’un moteur unipolaire
Page 13
Chapitre I: Généralités sur les moteurs pas à pas
5
Fig I.5: Séquence de rotation simple
Comme pour chaque type de moteur, le modèle unipolaire peut être commandé en
mode monophasé, biphasé ou demi-pas. Le Tableau I.1 donne l’ordre des différentes
commandes.
Mode monophasé Mode biphasé Mode demi-pas
A
B
C
D
A
etc.
AB
BC
CD
DA
AB
etc.
A
AB
B
BC
C
CD
D
DA
A
etc.
Tableau I.1: Différentes commandes des phases
Page 14
Chapitre I: Généralités sur les moteurs pas à pas
6
Signalons que le moteur unipolaire présentera, à volume égal, un couple moins
important que le moteur bipolaire.
I.2.1.2 Les moteurs bipolaires :
La Fig I.6 représente la constitution interne d’un moteur de type bipolaire. Ce type de
moteur nécessite une commande plus complexe que celle du moteur unipolaire, le courant
devant changer de sens dans les enroulements à chaque pas effectué.
Fig I.6: Représentation schématique d’un moteur bipolaire
Comme pour le modèle précédent, ce moteur peut être alimenté sous trois séquences
différentes, le Tableau I.2, représentées par ailleurs sur la Fig I.7. (Ordre des différentes
commandes suivant le mode monophasé, biphasé ou demi-pas).
Mode monophasé Mode biphasé Mode demi-pas
AB
CD
BA
DC
AB
etc.
AB-CD
BA-CD
BA-DC
AB-DC
AB-CD
etc.
AB
AB-CD
CD
BA-CD
BA
BA-DC
DC
AB-DC
AB
etc.
Tableau I.2: Ordre des différentes commandes suivant le mode monophasé, biphasé ou demi-
pas.
Page 15
Chapitre I: Généralités sur les moteurs pas à pas
7
Pour ce type de moteur nous avons trois possibilités de commande.
La première consiste à alimenter les enroulements en suivant la séquence A vers B / C
vers D / B vers A / D vers C (BA est le même enroulement que AB mais alimenté par
un courant de polarité inverse). Par la suite nous simplifierons la notation pour une
meilleure correspondance avec les chronogrammes des phases en indiquant
uniquement la phase qui est alimentée par un courant "positif". Soit: A C B D.
Cette séquence est connue sous le nom de "one phase on full step" (traduisez
phase par phase ou une phase à la fois en pas entier). A tout moment il n'y a qu'une
seule phase d'alimentée et nous travaillons en mode pas entier.
Fig I.7: Mode monophasé
La seconde possibilité est d'alimenter une paire de phase en même temps de façon à ce
que le rotor se positionne entre deux pôles.
Appelé "two-phase-on full step" (deux phases à la fois en pas entier) ce mode de commande
est celui qui procure le couple le plus élevé.
La séquence sera donc : AC / CB / BD / DA.
Fig I.8: Mode biphasé
La troisième option est un mélange des deux premières puisque l'on alimente tour à
tour le moteur sur une phase puis deux puis une... Cette séquence connue sous le nom de
mode demi-pas procure effectivement un division par 2 de l'angle d'avance d'un pas, mais
aussi un couple moins régulier.
La séquence qui en découle est la suivante : A / AC / C / CB / B / BD / D /DA.
Page 16
Chapitre I: Généralités sur les moteurs pas à pas
8
Fig I.9: Mode demi-pas
Pour obtenir une rotation dans la direction opposée les mêmes séquences sont utilisées
en inversant l'ordre de défilement.
Comme nous pouvons le constater sur les diagrammes, les moteurs sont représentés avec une
avance de pas à 90°.
Dans les moteurs réels le nombres de pôles ont été multipliés pour réduire à quelques
degrés seulement l'angle d'avance d'un pas. Le nombre d'enroulements et la séquence de
commande restant, quand à eux, inchangés.
C’est dans le mode biphasé que le moteur développera la plus grande puissance
(couple élevé) car les deux phases seront alimentées dans le même temps.
Le mode demi-pas permet de doubler le nombre de pas qu’un moteur peut effectuer
par tour, mais cette précision supplémentaire engendre un couple irrégulier. En effet, dans ce
mode, la commande du moteur est un mélange de mode biphasé et monophasé. Dans ce cas, si
la charge est importante, des pas risquent de <<sauter>>, ce qui n’est pas le but recherché.
Dans notre projet, nous avons utilisé deux moteurs pas à pas unipolaires de type
57SHM-46B6A, avec une résistance interne de 5Ω et un pas de 1.8°. C’est-à-dire pour faire
un tour il faut 200 pas.
Page 17
Chapitre I: Généralités sur les moteurs pas à pas
9
I.2.2 Les moteurs à réluctance variable:
Les moteurs à réluctance variable fonctionnent selon un principe différent de celui des
moteurs à aimants permanents, Ils possèdent bien évidemment un stator et un rotor, mais ce
dernier est fabriqué en acier doux non magnétique. Il n’est pas lisse et possède plusieurs
dents. Ce type de moteur est représenté en Fig I.10. On peut voir, dans cet exemple, que le
stator est composé de 8 plots sur lesquels sont enroulés les bobinages, ce qui donne 4 phases.
Le rotor, quant à lui, ne comporte que 6 dents.
Fig I.10: Moteur à reluctance variable
1.2.3 Les moteurs hybrides:
Le rotor comporte en périphérie des dentures polarisées par aimants. La fonction
moteur est obtenue par deux effets :
· Effet de réluctance variable dû aux dents,
· Propriété des aimants permanents.
Ses principales caractéristiques sont :
· Bonne résolution (jusqu’à 400 pas par tour).
· Couple plus important que les moteurs à réluctance variable.
· Fréquence de commutation élevée.
Il est donné sur la Fig I.11
Fig I.11 La structure interne d’un moteur hybride
Page 18
Chapitre I: Généralités sur les moteurs pas à pas
10
I. 2. 4 Nombre de phase:
Il existe divers types de moteurs pas à pas mais la principale différence est le nombre
de bobines utilisées.
Configuration interne des bobines du moteur :
4 fils
5 fils
6 fils
I fils
I. 2.4.1 Les moteurs à 4 fils (bipolaires):
Bien que sur le schéma, 4 bobines ont été représentées, ce moteur agit comme s'il ne
possédait que 2 bobines. Ce moteur oblige d'alimenter soit une bobine à la fois, ou les deux en
même temps. À tout moment, donc, le moteur a la moitié ou la totalité de ses bobines
alimentées, ce qui a comme avantage de lui donner plus de force. Par contre, il est plus
complexe de contrôler un moteur bipolaire, au niveau de l'interface de puissance, puisqu'il
faut inverser la polarité de la bobine.
I.2.4.2 Les moteurs à 5 fils (unipolaires):
Le moteur unipolaire est conçu de sorte que l'interface de puissance soit grandement
simplifiée, mais au détriment de la force. Le moteur comporte en quelque sorte deux bobines
à points centraux, ces derniers étant communs. Habituellement, on relie ces points centraux, et
on applique l'alimentation à un des 4 autres fils.
Il est toutefois possible d'ignorer les points centraux et de faire fonctionner le moteur
unipolaire comme un moteur bipolaire, mais il faut être davantage rigoureux car
contrairement au moteur bipolaire, ici les deux bobines sont capables d'interagir entre elles.
Par exemple, si on alimente une des deux bobines, et qu'on relie une borne de l'autre bobine à
la masse, le courant se répartit maintenant dans trois demi-bobines, au lieu de deux demi-
bobines pour le moteur bipolaire.
I.2.4.3 Les moteurs à 6 fils:
Avec le moteur à 6 fils, on a alors réellement le choix de le contrôler comme un
moteur bipolaire, ou comme un moteur unipolaire. Dans le premier cas, on ignore simplement
les connexions centrales, et dans le second cas, on relie les deux points centraux à la masse,
pour alimenter l'un après l'autre les 4 autres fils.
Page 19
Chapitre I: Généralités sur les moteurs pas à pas
11
I.2.4.4 Les moteurs à 8 fils
Le moteur à 8 fils est celui qui permet le plus de flexibilité, quant au nombre de façons
différentes de le contrôler.
I.3 Alimentation des moteurs pas à pas: [2]
1.3.1 Alimentation unidirectionnelle et bidirectionnelle
Le moteur pas à pas peut être alimenté soit en courant soit en tension. On distingue
deux cas, dans le premier cas le courant dans les phases est toujours dans le même sens
(alimentation unidirectionnelle), il est valide pour les moteurs à réluctance variable qui ne
sont pas sensibles au sens de courant, ainsi qu’avec certains moteurs à aimant, en
particulier ceux qui sont munis d’enroulement bifilaire tandis que dans le deuxième cas, il
faut à chaque fois inverser le sens du courant (alimentation bidirectionnelle). Il est utilisé
pour les machines à aimant ou hybrides munies d’enroulements simples.
I.3.2 Alimentation en tension
Circuit de base :
Fig I.11: Alimentation en tension unidirectionnelle
1.3.2.1 Alimentation unidirectionnelle:
Le schéma pour phase Ø comporte une alimentation continue fixe Vcc, un interrupteur
commandé (transistor bipolaire, montage Darlington ou transistor MOS) et une diode de roue
libre (Fig I.11).
On considère tout d’abord que la force électromotrice de la rotation est négligeable. Le
schéma équivalent de la phase se réduit alors à un dipôle RL série. Le séquenceur bloque le
transistor lorsque la phase ne doit pas être alimentée et il le sature à l’instant de la
commutation où doit apparaître le courant. Le circuit étant inductif, la variation de l’intensité
ne peut pas être discontinue. La croissance est exponentiel1le, de constante de temps τ =R/L.
Page 20
Chapitre I: Généralités sur les moteurs pas à pas
12
On néglige la tension VCEsat aux bornes du transistor saturé, on a :
I= (1 - )
Dans le cas du moteur à réluctance variable, il faut noter que τ est variable puisque
l’inductance dépend de la position. Au bout de quelques constantes de temps, la courbe a
atteint son asymptote et le courant est constant. Pour obtenir l’intensité nominale In, il faut
une alimentation Vcc = R.In. Quand le séquenceur commande le blocage du transistor à la
fin de la durée d’alimentation de la phase considérée, la diode de roue libre devient passante
pour assurer la continuité du courant permettant l’évacuation de l’énergie magnétique
emmagasinée. Il faut évidement choisir un modèle de diode assez rapide (à commutation
rapide) pour limiter les conséquences du régime transitoire de mise en conduction. La
décroissance du courant est exponentielle, de même constante de temps τ. En négligeant la
tension aux bornes de la diode devant Vcc, on a :
i =
L’allure de la courbe du courant en fonction du temps (Fig I.12) s’éloigne un peu de
l’idéal à cause des temps de montée et de descente. Ceux-ci doivent rester faibles devant la
durée Tc de l’alimentation de la phase, ce qui est possible lors d’un fonctionnement à basse
fréquence. Jusqu’à présent, on n’a pas tenu compte de la force électromotrice de rotation. Or
celle-ci va avoir un effet néfaste puisque sa variation, liée à l’évolution de la vitesse et de la
position aura une influence sur le courant. On retrouve ainsi des oscillations de l’intensité
liées aux oscillations mécaniques lors de chaque commutation. Le courant n’est donc pas
constant pendant la durée d’alimentation de la phase.
Il faut remarquer que la mise en équation des phénomènes est complexe puisque les
équations mécaniques et électriques sont liées entre elles. Cet effet est d’autant plus
perturbateur que le moteur tourne vite puisque la force électromotrice de rotation est
proportionnelle à la vitesse de rotation. Ce circuit élémentaire est ainsi réservé aux machines
ne travaillant qu’en positionnement ou en basse fréquence et dont on n’attend que des
performances modestes.
Fig I.12 : Variations du courant en l’absence de force électromotrice de rotation
Page 21
Chapitre I: Généralités sur les moteurs pas à pas
13
I.3.2.2 Alimentation bidirectionnelle:
Pour pouvoir inverser le courant à partir d’une alimentation fixe unique, on utilise un
pont en H (Fig I.13). Un premier sens obtenu en saturant T1 et T4 et en bloquant T2 et T3.
Un second sens correspond à T2 et T3 saturés et T1 et T4 bloqués. Dans chaque cas, le
fonctionnement est analogue à celui de l’alimentation unidirectionnelle, cette structure est
disponible sous forme intégrée pour les domaines de courant employés ici.
Fig I.13: Montage en pont
Conclusion:
Selon le besoin, l’utilisateur peut choisir le moteur qui lui convient a son application,
avec l’alimentation et le mode d’excitation correspondant.
Pour notre projet, on a opté pour deux moteurs à aimant permanant, unipolaire
biphasé.
La commande de ces deux moteurs est le titre du chapitre suivant.
Page 23
Chapitre II: Port parallèle et programmation sous Delphi
14
II.1 Le port parallèle: [3], [5]
II.1.1 Définition :
Les ports d’entrée/sortie sont des éléments matériels de l’ordinateur, permettant au
système de communiquer avec le monde externe, c'est-à-dire d’échanger des données, d’où
l’appellation d’interface d’entée/sortie (noté parfois d’E/S). A son origine, le port parallèle
était conçu pour recevoir une imprimante. Aujourd’hui, il peut recevoir des périphériques
variés. Ainsi, il est possible d’y connecter une imprimante, un scanner, un disque dur externe,
etc. Le port parallèle se présente sous la forme d’un connecteur DB25 femelle, il est
aujourd’hui présent sur la totalité des ordinateurs.
Le port parallèle, a subi plusieurs changements et améliorations. Il est conçu pour transmettre
ou accueillir des données dans le domaine extérieur.
La transmission des données consiste à envoyer des données simultanément sur plusieurs
canaux (fils en parallèle), 8 bits (1 octet) par l’intermédiaire de 8 fils.
II.1.2 Description du port : Le port parallèle originel de l'IBM PC® comportait en tout 25 broches, 12 sorties
numériques et 5 entrées numériques accessibles via 3 ports consécutifs sur 8 bits dans l'espace
d'E/S du processeur. 8 broches reliées à la masse et les 17 autres sont dédiées principalement
pour une imprimante. Certaines ne fonctionnent qu’en entée, d’autres sont double sens, elles
sont reparties sur 3 groupes:
1. 8 broches de sortie accessibles via le port des DONNÉES ;
2. 5 broches d'entrée (une inversée) accessibles via le port d'ÉTAT ;
3. 4 broches de sortie (trois inversées) accessibles via le port de COMMANDE ;
Pour lire un octet (8 bits) entrant dans un port, appelez inb (port) ; pour produire un
octet, appelez outb (valeur, port) (notez l'ordre des paramètres).
Connecteur du port parallèle:
Fig II.2: Connecteur DB25
Page 24
Chapitre II: Port parallèle et programmation sous Delphi
15
II.1.3 Les différentes broches du port:
Les broches n° 2, 3, 4, …, 9, disponibles seulement en écriture par exemple, la broche
n°1 (STROB) disponible à la fois en lecture et en écriture. Exemple texte envoyé à
l’imprimante (D0, D1, D2, …... D8).
Les broches 10 (ACK), 11 (BUSY), 12 (PE), 13 (SELECT) disponibles seulement en
lecture (information sur l’état du périphérique).
Les broches 18, 19, …... 25, vers la masse.
II.1.4 Programmation du port en assembleur:
Nous allons examiner comment écrire et lire des données sur le port parallèle. Dans
notre travail on s’intéresse à l’assembleur.
- Ecriture:
Asm Mov dx, 0378h
Mov al, sortie
Out dx, al
- Lecture:
Asm
Mov dx, 0379h
IN al, dx
Mov entrée, al
End.
II.1.5 Intérêt du port parallèle:
Ses avantages par rapport à l’interface série sont:
1. Une plus grande rapidité, permettant par exemple un fonctionnement en scrutation (le
PC interroge en permanence les lignes d’entrée, pour voir si elles ont changé d’état).
2. La vitesse de transmission maximale est de l’ordre de 150Ko/s pour les ports les plus
anciens, et de 2Mo/s pour les types EEP.
Les connections par port parallèle actuelles sont aussi rapides que celle en USB.
Néanmoins, cette interface monopolise pratiquement 100% des ressources du processeur. En
théorie, le taux de transfert est de 1Mo/s ; néanmoins, la vitesse dépasse rarement les 600Kb/s
Page 25
Chapitre II: Port parallèle et programmation sous Delphi
16
II.2 Delphi 7:
II.2.1 Introduction au Delphi 7 : [4]
Delphi est un environnement de programmation permettant de développer des
applications pour Windows (95/98/2000). Il représente une version orientée objet de la famille
turbo pascal. On dispose pour cela d’une bibliothèque de composantes visuels (VCL).
A l’aide de ces composants, le développeur réalise ses programmes sans recourir à des
manipulations complexes. Delphi est un outil à double usage puisqu’il permet de créer des
applications de façons différentes : la première méthode est visuelle ; elle utilise le
déplacement de composants sur l’écran (par glissement). La deuxième méthode consiste en
une programmation traditionnelle, celle ou l’on produit le code source. On peut utiliser
exclusivement l’une ou l’autre de ces techniques, mais le plus souvent, les deux techniques
sont combinées.
II.2.2 Présentation de l’environnement de travail sous Delphi 7:
Delphi diffère des autres langages classiques tels que pascal ou fortran. Dans ces
derniers, on doit directement écrire des instructions l’une à la suite de l’autre jusqu’à la fin.
Delphi ressemble plus à un atelier où l’on dispose d’une boite à outils et d’un ensemble
d’objets qui servent à fabriquer une application. Ainsi Sous Delphi on n’écrit pas une
application mais on la fabrique.
A l’ouverture de Delphi, on constate que l’écran se compose de quatre fenêtres
essentielles, comme représentées sur la Fig II.3
Fig II.3: Représentation de la fenêtre de travail
On donne la description des principaux éléments que comporte la fenêtre d’application
Delphi comme suit :
Page 26
Chapitre II: Port parallèle et programmation sous Delphi
17
II.2.3 Fenêtre des menus, de la barre des outils et la palette des composants :
*barre de titre : affiche le nom de projet en cours de construction.
*barre de menus : elle est présente dans toutes applications Windows, elle permet d’accéder
à la plupart des commandes disponibles.
*barre d’outils : contient des raccourcis vers des applications préconçues.
*palette des composants: contient des raccourcis vers des soubroutines Delphi qui
permettent l’insertion de composants graphiques essentiels à une application
Tous ses paramètres sont représentés sur une fenêtre comme indiqué sur la figure suivante :
Fig II.4: Representation de la fenetre principale
II.2.4 Fenètre de l’inspecteur d’objets :
Cet outil est dédié à la gestion des composants. La fenêtre de l’inspecteur contient
deux volets :
- la liste des propriétés (attributs) du composant courant,
- la liste des événements associés au composant courant.
Propriétés :
Les noms des propriétés sont placés dans la colonne de gauche (dans l’ordre
alphabétique) et les valeurs sur la ligne correspondante à droite.
Les propriétés dont le nom est précédé d’un + ont plusieurs
niveaux imbriqués (ex. Font). Lorsqu’une propriété de ce type
est « déroulée », le signe – apparaît à la place du signe +.
Pour donner une valeur à une propriété, le plus simple est de
remplacer sa valeur par défaut par une nouvelle valeur dans la
boîte d’édition prévue à cet effet.
La propriété Name est particulièrement importante car elle
permet d’accéder au composant depuis les programmes. Par
défaut, Delphi lui confère une valeur peu explicite (ex. Form1,
Button1…). Il est préférable d’utiliser des noms plus « parlants
».
Les propriétés visibles dans l’inspecteur sont modifiables lors
de la phase de conception. D’autres propriétés sont
uniquement accessibles lors de l’exécution, grâce à du code
source.
Fig II.5: lnspecteur d’objet (Propriétés)
Page 27
Chapitre II: Port parallèle et programmation sous Delphi
18
Événements
La colonne de gauche contient l’ensemble des
événements associés à uncomposant donné. Ex. OnClick,
commun à un grand nombre de composants, qui est activé
lorsque l’utilisateur clique sur le composant.
La colonne de droite consiste en une série de boîtes
de listes combinées permettant d’associer un gestionnaire
d’événements à l’événement correspondant (i.e., un
ensemble d’instructions Pascal exécutées lorsque
l’événement survient).
Sur un double clic sur une de ces boîtes, l’éditeur de
code s’ouvre et le curseur se positionne à l’intérieur du
gestionnaire d’événements (une procédure).
.
Fig II.6: lnspecteur d’objet (Evenements)
II.2.5 Fenètre de la fiche principale :
Il s’agit d’une fenétre dans laquelle on place les différents objets (composants) dans
une certaine disposition selon l’apparence désirée de la future application
Les informations concernant la fiche se trouvent dans les fichiers ayant comme
extention <<.pas>> et <<.dfm>>. Elle est montée sur la fig II.7
Fig II.7: Représentation de la fiche
Page 28
Chapitre II: Port parallèle et programmation sous Delphi
19
II.2.6 Fenétre de code source (unité) : Les fichiers de code source composant un projet sont rassemblés dans l’éditeur de
code. À chaque fiche est associée une unité identifiée par un onglet situé en haut de la fenêtre
de l’éditeur. L’éditeur permet de modifier le code Pascal de ces unités. Elle est donnée sur la
Fig II.8.
Fig II.8: Représentation de l’unité
II.2.7 Projet:
Chaque application est représentée par un projet. Ce projet est consitué de fiches,
d’unité, de paramétres d’option…ect, lorsqu’on démare delphi, il ouvrira par défaut un projet
vide. si un autre projet est déjà ouvert, il faut choisir fichier/nouvelle application pour créer un
nouveau projet.
A l’ouverture d’un nouveau projet, delphi crée automatiquement les fichiers suivants :
**projet 1.DPR : le fichier de code source associé au projet, appelé fichier projet.
**Unité 1.PAS : le fichier de code source associé à la fiche principale du projet. C’est ce que
nous appelons un fichier d’unité.
**Unité1. DFM : le fichier de ressource stockant les informations sur la fiche principale de
projet, c’est ce que nous appelons un fichier fiche.
Le fichier projet consitue la partie principale de l’application en delphi. C’est à partir
de celle ci que le programme est lancé.
II.2.8 les fichiers créés par delphi : Dans n’importe quelle projet le langage delphi génère des fichiers. On donne la
description de ces fichiers comme suit :
** .dpr (delphi projet) : fichier projet, ce fichier sauvegarde les informations relatives aux
fiches et unités d’un programme.
** .pas (pascal) : fichier d’unité qui sauvegarde le code, dans la plupart des cas les fichiers
d’unité sont associés à des formes.
Page 29
Chapitre II: Port parallèle et programmation sous Delphi
20
** .dfm (delphi forme) : fichier de fiche, ce fichier est créé par le langage delphi pour
sauvegarder des informations concernant une fiche. chaque fiche correspond un fichier unité
(.pas) qui sera lié dans le fichier exécutable final.
** .dof (delphi option file) : fichier d’option du delphi , les paramétres d’option du projet y
sont sauvegardés.
** .res (ressource) fichier de ressource. Ce fichier contient une icône utilisée pour le projet.
Ce fichier ne doit pas étre créé ou modifié par le programmateur ou l’utilisteur.
**.˜dp, .˜df, .˜pa,….. : les fichiers sont créés lors des enregisterements successifs d’un projet,
ce sont des copies desauvegarde, des fichiers portant le méme nom.
**.exe (exécutable file ) : il s’agit d’un fichier exécutable indépendant qui n’a besoin de rien
d’autre que lui méme pour s’exécuter.
Conclusion:
Ce chapitre est consacré au port parallele et Delphi, car c’est le moyen de générer les 8
bits, qu’on commande avec une interface graphique et une carte d’interface qui sont données
dans la chapitre suivant.
Page 31
Chapitre III: Réalisation de la carte d’interface
III.1 Interface graphique:
III.1.1 Présentation de l’interface graphique:
La méthode pour bien débuter une séquence de travail reste la même. Lancez Delphi 7
à partir de Windows. Ouvrez un nouveau projet puis sélectionnez dans le menu FICHIER
l'option APPLICATION en cliquant simplement sur le bouton OK. Donnez ensuite un
nouveau nom à la feuille de travail qui s'est affichée. Modifiez pour cela la propriété Caption
en entrant "Pilotage programmable de moteurs pas à pas".
S'agissant des différents composants, il est toujours préférable de créer des zones
distinctes qui permettent d'identifier aisément leur fonction, c'est pourquoi vous devrez placer
3 boîtes de groupes (GroupBox) en modifiant leurs propriétés Caption avec "Moteur 1",
"Moteur 2" et "Editeur".
Toujours dans la barre d'outils STANDARD, allez chercher les boutons (Button) que
vous disposerez dans les boîtes de groupe de Moteur 1 et Moteur 2. Le bouton gauche de
Moteur 1 correspond au Button1, droit au Button2 alors que gauche de Moteur 2 doit être
Button3 et droit Button4. Et aussi maitre deux ComboBox (qui se trouve toujours dans la barre
d’outil STANDARD) dans la fenêtre de la fiche principale (c.à.d. ne pas les maitre dans les
GroupBox) pour agir sur la vitesse, un pour le moteur 1, le deuxième pour le moteur 2, dans la
fenêtre de l’inspecteur d’objet on cherche Item pour déclarer le contenu qu’ils vont afficher
ces derniers
Les valeurs de réglage sont données par le composant SpinEdit qui se trouve sous
l'onglet EXEMPLES de Delphi 7 et que vous déposerez entre les boutons "droit" et "gauche".
Dans la liste des propriétés de l'inspecteur d'objet, vérifiez que mini est égal à zéro, ce
qui limitera le choix du nombre de pas aux valeurs positives. Revenez ensuite à l'onglet
STANDARD de la palette de composants pour sélectionner une boîte de liste (ListBox) que
vous déposerez dans la boîte de groupe EDITEUR de votre feuille de travail.
Cette boîte de liste a la particularité de contenir une liste d'items (qui correspondront
aux mouvements de notre programme) repérés par un index. En positionnant correctement cet
index on peut donc lire la chaîne de caractères qui lui correspond (le mouvement). Il reste
enfin à placer les boutons qui permettront d'initialiser, d'exécuter ou d'effacer les lignes de
programme des mouvements de chaque moteur. Pour cela, vous trouverez sous l'onglet
SUPPLEMENT de la barre d'outils des boutons BitBtn que vous déposerez sur la feuille. Pour
qu'ils affichent ce que nous désirons, commencez par modifier leurs propriétés Caption dans
l'inspecteur d'objet pour que s'inscrive "Exécute", "Nouveau" et "Corrige". Pour que chaque
bouton à image Bitmap (BitBtn) affiche le dessin correspondant, sélectionnez la propriété
Kind de l'inspecteur d'objet de chaque BitBtn. Pour le bouton "Corrige", prenez BkNo puis
BkRetry pour "Exécute" et BkAbort pour "Nouveau". Votre écran est maintenant prêt, il ne
reste plus qu'à entrer le programme en commençant par l'inscription automatique du corps de
Page 32
Chapitre III: Réalisation de la carte d’interface
23
chaque procédure associée à un bouton. Pour les boutons "droite"' et "gauche" des moteurs 1
et 2, les noms que vous devrez entrer sous l'onglet EVENEMENTS de l'inspecteur d'objet sont:
Moteur_1_gauche
Moteur_1_droite
Moteur_2_gauche
Moteur_2_droite
Viennent ensuite corrige pour le bouton "Corrige", vide_la_liste pour le bouton
"Nouveau" et enfin exécute pour le bouton "Exécute". Il est bon de conserver à l'esprit que les
soulignés sont indispensables et que vous ne devez pas utiliser de caractères accentués pour
donner vos noms de procédure. Ce programme a l'avantage de vous permettre de vous
familiariser avec les boîtes de listes (ListBox) qui sont plus simples à manipuler qu'il n'y
paraît. En effet, comme cela à déjà été évoqué, elles peuvent contenir des chaînes de
caractères alphanumériques repérées par un index. Ces chaînes, pour être reconnues comme
des nombres, doivent être transformées à l'aide de l'instruction StrToInt( ) comme c'est le cas
pour l'extraction de la valeur dans la procédure exécute.
Un mouvement de moteur est repéré par des initiales (l'ordre) et une valeur, qui seront
affichés sous la forme M1G.12, ce qui signifie que le moteur 1 tourne à gauche de 12 fois 4
pas. Le point entre l'ordre et la valeur fait office de séparateur.
valeur:=StrToInt(copy((ListBox1.Items[i]),5,L-4)); signifie qu'on prend les caractères à
partir du cinquième jusqu'au dernier (ce qui est calculé par L) de l'item repéré par i dans la
boîte de liste puis qu'on les convertisse en nombres avant de les ranger dans valeur (donc
valeur dans notre exemple est égal à 12).
Pour extraire l'ordre de commander l’un des deux moteurs, on n’a pas besoin
d'effectuer une conversion. Nous écrirons simplement:
ordre:=copy ((ListBox1.Items[i]), 1, 3); qu'on peut traduire par "prendre les 3 caractères à
partir du premier de l'item repéré par i dans la boîte de liste", ce qui nous donne M1G. En
fonction de l'ordre ainsi récupéré dans la procédure exécute, on peut aiguiller le programme
vers la séquence d'action des enroulements de chaque moteur pas à pas.
Afin de simplifier le programme, le choix s'est porté vers le déroulement complet d'un
cycle d'action sur les enroulements d'un moteur, ce qui signifie que les valeurs de rotation
auront pour unité un angle de 30 degrés avec un moteur de 48 pas par tour. Si par exemple
vous exécutez l'ordre M1D.6, le moteur 1 effectuera une rotation à droite de 180 degrés. Pour
effectuer des tours complets, vous utiliserez donc des multiples de 12. Pour en venir aux
aspects matériels de ce programme, il est rappelé que l'adresse du port imprimante vers lequel
nous enverrons les données correspond au port 2. Pour un autre port, modifiez les adresses en
conséquence.
FONCTION DU PORT LPT1d LPT1h LPT2d LPT2h LPT3d LPT3h
de données 956 3BC 888 378 632 278
d'état 957 3BD 889 379 633 279
de contrôle 958 3BE 890 37A 634 27A
Page 33
Chapitre III: Réalisation de la carte d’interface
24
La procédure d'action des moteurs reprend le code que nous avons abordé au cours du
précédent chapitre et qui est développé ci-dessous pour mémoire. Le codage d’adresse
employé est hexadécimal (h) et binaire (b).
ASM
mov dx, 0378h chargement de l'adresse du port de données de LPT2 dans
DX
mov ax, sortie chargement de la valeur SORTIE dans AX
out dx, al sortie des 8 premiers bits de AX à l'adresse contenue dans
DX
mov dx, 037ah chargement de l'adresse du port de contrôle de LPT2 dans
DX
mov al,
00000001b
mise à 1 du bit correspondant au STROBE dans AL
out dx, al envoi du STROBE à l'adresse contenue dans DX
mov dx, 037ah chargement de l'adresse
mov al,
00000000b
mise à zéro du STROBE dans AL
out dx, al envoi à l'adresse contenue dans DX
End;
A la fin nous obtenons l’interface graphique donnée sur la Fig III.1
Fig III.1 : Interface graphique créée avec Delphi
Page 34
Chapitre III: Réalisation de la carte d’interface
25
III.1.2 Fonctionnement de l’interface graphique:
On ouvre la fenêtre (Pilotage de deux moteurs pas à pas), c’est cette interface qui nous
permet de piloter les deux moteurs. La commande se fait un par un, car le programme exécute
l’instruction trouvée dans ListeBox. On sélectionne le nombre de pas en utilisons le SpinEdit,
puis la vitesse en utilisons le ComboBox et enfin direction (gauche ou droite) en appuyons sur
l’un des boutons, tout ce que nous avons choisi sera recopier dans la ListBox (sauf la vitesse),
il nous reste qu’a appuyé sur le BitBtn qui va exécuter la rotation des deux moteurs moteur
tourne.
III.2 Carte d’interface:
III.2.1 Etude de la carte d’interface:
Conformément à notre souhait de privilégier avant tout l'initiation à la programmation
sous Windows avec DELPHI, notre maquette reste simple bien que parfaitement efficace. Les
deux circuits intégrés représentent la fonction commande et la fonction puissance. En effet, le
74HCT573 transmet les niveaux logiques qui correspondent à la mise sous tension ou pas de
chaque enroulement des moteurs. Les valeurs sont verrouillées sur les sorties Q1 à Q8 grâce
au transistor T3 via le signal STROBE.
Fig III.2: Carte d’interface
Chaque moteur pas à pas nécessitant une tension de 12V pour fonctionner
correctement, un ULN 2803A (qui constitue l'étage de puissance) est intercalé directement
entre les sorties du 74HCT573 et les enroulements.
Page 35
Chapitre III: Réalisation de la carte d’interface
26
III.2.1.1 Verrou 74HCT573:
Avec l’interface créée sous Delphi, on commande les huit sorties du port parallèle qui
génère des bits de 1 et de 0 qui attaque le CI 74HCT573, voir la Fig III.3 qui est composé de
huit bascules de D qui ont des sorties à 3 états, en fonction des entrées D (broches D1 à D7) et
de LE Latch Enable inpout (broche 11) on la met souvent comme une entrée d’horloge mais
dans notre projet elle est reliée vers le collecteur du transistor 2N2222, la commutation de ce
dernier est commander par le pin1 du port parallèle. Si le pin1 est au niveau haut (1) le
transistor est saturé alors la broche 11 est à 0, les sorties sont verrouillées, et si le pin1 est au
niveau bas (0) le transistor est bloqué alors la broche 11 est à 1, l’instruction est passée. Et
enfin Output Enable (broche 1) on la met souvent vers la masse car elle est inverser.
Pour plus de détail voir l’Annexe 1.
Fig III.3: 74HCT573
Page 36
Chapitre III: Réalisation de la carte d’interface
27
Fig III.4: Structure interne du 74HCT573
Le Tableau III.1 nous permet de comprendre le fonctionnement du CI 74HCT573 :
LE D
L
L
L
H
H
H
L
X
H
L
X
X
H
L
Q
Z
Tableau III.1: Les 3 états du CI 74HCT573
L : l’état bas (0).
H : l’état haut (1).
X : indéterminé.
Q : l’état précédent de Q+ .
Z : l’état en haute impédance.
III.2.1.2 Commutateur de puissance ULN2803:
Ce que nous avons vu jusqu’à maintenant c’est le bloc de verrouillage et de protection,
nous allons continuer notre explication sur le fonctionnement de la carte avec le bloc de
puissance, constitué d’un circuit intégré ULN2803 qui a le rôle de transformer les signaux
numériques en des signaux pouvant effectivement alimenter les deux moteurs.
Page 37
Chapitre III: Réalisation de la carte d’interface
28
Le circuit intégré ULN2803A est à la base de ce commutateur, il est composé de 8
Darlington (deux transistors NPN montés en cascade) de puissance et de diodes de protection.
Chaque étage d’amplification inverseur qui adapte le niveau de tension et d’intensité TTL de
l’entée pour fournir une intensité jusqu’à 500mA sous une tension pouvant aller jusqu’à 50V
en sortie.
Afin d’alimenter les huit phases des deux moteurs, on a utilisé les huit Darlington. Les
impulsions attaquant les Darlington commutent les bobines des deux moteurs à la masse. Voir
l’Annexe 2.
La Fig III.5 nous donne le schéma de l’ULN2803
Fig III.5: ULN2803
La structure interne du Darlington est donnée sur la Fig III.6:
Fig III.6: Montage d’un Darlington
Pour bien comprendre le fonctionnement de ce circuit intégré dans notre montage
visualiser la Fig III.7.
Page 38
Chapitre III: Réalisation de la carte d’interface
29
Fig III.7: Bloc de commutateur de puissance
III.3 Alimentation:
Nous avons besoin de deux alimentations continues une de 5V pour alimenter le
Verrou 74HCT573, et une autre de 12V pour le commutateur de puissance ULN 2803 et les
deux moteurs.
Pour diminué la tension du secteur 220V, on utilise un transformateur à point milieu
2×12V avec un courant de 600mA à chaque sortie. Après avoir abaissé la tension on passe au
redressement, avec une diode 1N4007 à chaque sortie on élimine l’alternance négative, alors
on aura un signal simple alternance. On commence le filtrage avec un condensateur de 470μF
électrolytique (chimique) avant de diminué les tensions, une vers 5V avec le 78LS05, et
l’autre vers 12V avec le 78LS12. On améliore bien le filtrage avec un autre condensateur
2.2μF, puis on utilise pour chaque sortie une résistance et une LED en parallèle pour le voyant
La Fig III.8 qui est donné dans la page suivante est le montage utilisé pour réaliser
cette alimentation.
Page 39
Chapitre III: Réalisation de la carte d’interface
30
Fig III.8: Circuit d’alimentation
III.4 Essai et résultat:
On va faire un essai pour expliquer bien le fonctionnement de notre interface
graphique, par exemple, on veut commander les deux moteurs (mais pas en même temps), le
premier moteur à gauche de 4 fois 4 pas avec une vitesse lente (la durée de déplacement d’un
pas à l’autre est de 1 second), et le deuxième moteur à droite de 2 fois 4 pas avec une vitesse
rapide (l0.1 second).
La Fig III.9 donné dans la page suivante est l’interface de l’expérience.
TR
R1100R
C1470u
C3470u
VI1
VO3
GN
D2
U27812
R21k
D3
1N4007
D4
1N4007
VI1
VO3
GN
D2
U17805
D2
D1
C22n2
C42n2
Page 40
Chapitre III: Réalisation de la carte d’interface
31
Fig III.9: L’interface graphique pour commander deux moteurs pas à pas
L’éditeur nous montre l’instruction à exécuter par le programme, et le
ComboBox la vitesse, M1G.4, i.e. moteur tourne à gauche de 4 fois 4 pas avec une vitesse
lente (1 s). Puis M2D.2 moteur 2 va tourner à droite de 2 fois 4 pas avec une vitesse rapide
(0.1 s).
La Fig III.10 est la partie des moteurs au point initial.
Page 41
Chapitre III: Réalisation de la carte d’interface
32
Fig III.10: L’état des deux moteurs pas à pas avant le test (point zéro)
Fig III.11: L’état des deux moteurs après avoir exécuté l’interface graphique
Page 42
Chapitre III: Réalisation de la carte d’interface
33
Le Tableau III.2 nous montre l’état des sorties du port qui doit être à 1 pour faire tourner le
moteur 1 à gauche de 4 pas, et le moteur 2 à droite de 4 pas aussi.
Tableau III.2: La table de vérité pour faire tourner le moteur 1 à gauche de 4 pas et le moteur
2 à droite de 4 pas
Conclusion:
Cette maquette permet d'actionner deux moteurs pas à pas de type unipolaire à partir de la
sortie imprimante parallèle du P.C.. Les signaux qui entraînent chaque moteur en rotation sont
délivrés directement par les huit lignes de données du port de sortie, ce qui constitue une
configuration matérielle suffisamment pratique pour que l'essentiel du travail soit reporté vers
la programmation. L'interface graphique est constituée de quatre boutons qui correspondent
respectivement aux rotations gauche et droite de chaque moteur. Le contrôle de la valeur
correspondant au nombre de pas pour chaque moteur est effectué avec deux zones de saisie,
une par moteur. Une zone d'édition permet l'affichage des séquences, une séquence consistant
à ajuster une valeur qui est automatiquement attribuée au mouvement correspondant aux
boutons de rotation. Il est possible de corriger la dernière valeur entrée, de dérouler toute la
séquence affichée ou de l'effacer.
D7 D6 D5 D4 D3 D2 D1 D0
0
1
0
0
1
0
0
0
0
0
1
0
0
0
0
1
0
0
1
0
0
0
0
1
0
1
0
0
1
0
0
0
Page 43
Chapitre III: Réalisation de la carte d’interface
34
Page 44
Conclusion général
En réalisant ce travail, nous avons touché trois domaines important, la
programmation sous Delphi, l’électronique digitale et l’électronique de
puissance.
Notre réalisation est intéressante à plus d’un titre, car en plus de sa
simplicité de conception, on peut commander deux moteurs soit en direction et
même leurs vitesses de rotation avec simplement une interface créée avec la
programmation Delphi. Alors son cout de réalisation est minimisé.
Perspectives:
Les travaux réalisés dans le cadre de ce projet peuvent se poursuivre sur
plusieurs axes:
Tout d’abord il serait intéressent d’améliorer la partie électrique on
ajoutant un capteur au niveau de chaque moteur pour permettre l’échange
d’informations dans les deux sens.
Remplacer l’ordinateur par un microcontrôleur, pour qu’il soit portatif.
L’amélioration de la carte graphique (ajout de quelques boutons,
utilisation d’un autre langage de programmation, ...) est également une
problématique intéressante qu’il faut aborder.
Page 46
Annexe 3
Circuit imprimé
Circuit imprimé de carte d’alimentation
Circuit imprimé de la carte d’interface
Page 47
Circuit d’implantation des composants
Circuit d’implantation des composants de la carte d’alimentation
Circuit d’implantation des composant de la carte d’interface
Page 49
Nomenclature
Résistances
R1 à R3: 12 kΩ (marron, rouge, orange).
R4 à R12 : 1.2 KΩ (marron, rouge, rouge).
R13, R14 : 1 KΩ (marron, noir, rouge).
Condensateurs
C1, C2 : 470µF.
C3, C4 : 2.2µF.
Semi-conducteurs
T: 2N2222A.
D1, D2 : 1N4007.
8 LEDs.
Circuits intégrés
CI1: 74HCT573.
CI2: ULN2803.
CI3:78LS05.
CI4:78LS12.
Divers
1 connecteur DB 25 mâle à souder sur circuit imprimé
2 morceaux de barrette à picots sécables de 6 points (pour les deux
moteurs).
1 borne à visser x3 (pour l’alimentation 5V-Gnd-12V)
1 connecteur DB 25 mâle et femelle à sertir sur nappe
1 nappe 25 fils de 1m de long
2 moteurs pas à pas type 55 SI.
1 Transformateur 220V/2×12V.
Page 51
Ouvrage:
[1] : Moteur pas à pas et PC 2eme
Edition, Patrice OGUIC, Edition Dunod, Paris
2004.
[2] : Moteur électrique pour la robotique, Pierre MAYE, Edition Dunod, Paris,
2006.
[3] : Architecture et technologie des ordinateurs, P.ZENELLA et Y.LIGIER,
Edition Dunod, 1998.
[4] : Delphi 6 créé une application de A à Z, C.KHECHANE, 2002.
Site Web:
[5] : Wikipédia encyclopédie online (www.wikipédia.com).