Vous êtes sur la page 1sur 51

²&<

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

Commande de deux moteurs pas à


pas via le port parallèle avec
Delphi

Réalisé par :
Mr ZENATI A/Hakim Encadré par:
r Mr BOUDJELLABA.K
M KERROUCHE Samir

Promotion : 2008-2009
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
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
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
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
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.
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.


Chapitre I: Généralités sur les moteurs pas à pas

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

1
Chapitre I: Généralités sur les moteurs pas à pas

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.

2
Chapitre I: Généralités sur les moteurs pas à pas

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.

3
Chapitre I: Généralités sur les moteurs pas à pas

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

4
Chapitre I: Généralités sur les moteurs pas à pas

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 AB A
B BC AB
C CD B
D DA BC
A AB C
etc. etc. CD
D
DA
A
etc.

Tableau I.1: Différentes commandes des phases

5
Chapitre I: Généralités sur les moteurs pas à pas

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 AB-CD AB
CD BA-CD AB-CD
BA BA-DC CD
DC AB-DC BA-CD
AB AB-CD BA
etc. etc. BA-DC
DC
AB-DC
AB
etc.

Tableau I.2: Ordre des différentes commandes suivant le mode monophasé, biphasé ou demi-
pas.

6
Chapitre I: Généralités sur les moteurs pas à pas

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.

7
Chapitre I: Généralités sur les moteurs pas à pas

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.

8
Chapitre I: Généralités sur les moteurs pas à pas

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

9
Chapitre I: Généralités sur les moteurs pas à pas

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.

10
Chapitre I: Généralités sur les moteurs pas à pas

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.

11
Chapitre I: Généralités sur les moteurs pas à pas

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

12
Chapitre I: Généralités sur les moteurs pas à pas

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.

13
Chapitre II: Port parallèle et programmation sous Delphi

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

14
Chapitre II: Port parallèle et programmation sous Delphi

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

15
Chapitre II: Port parallèle et programmation sous Delphi

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 :

16
Chapitre II: Port parallèle et programmation sous Delphi

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)

17
Chapitre II: Port parallèle et programmation sous Delphi

É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

18
Chapitre II: Port parallèle et programmation sous Delphi

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.

19
Chapitre II: Port parallèle et programmation sous Delphi

** .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.

20
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
Chapitre III: Réalisation de la carte d’interface

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

23
Chapitre III: Réalisation de la carte d’interface

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, {mise à 1 du bit correspondant au STROBE dans AL}
00000001b
out dx, al {envoi du STROBE à l'adresse contenue dans DX}
mov dx, 037ah {chargement de l'adresse}
mov al, {mise à zéro du STROBE dans AL}
00000000b
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

24
Chapitre III: Réalisation de la carte d’interface

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.

25
Chapitre III: Réalisation de la carte d’interface

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

26
Chapitre III: Réalisation de la carte d’interface

Fig III.4: Structure interne du 74HCT573

Le Tableau III.1 nous permet de comprendre le fonctionnement du CI 74HCT573 :

LE D

L H H H

L H L L

L L X Q

H X X 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.

27
Chapitre III: Réalisation de la carte d’interface

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.

28
Chapitre III: Réalisation de la carte d’interface

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.

29
Chapitre III: Réalisation de la carte d’interface

U1
D3 7805
1 3
VI VO

GND
1N4007
R1
100R

2
TR C1 C2
470u 2n2
D1

U2
D4 7812
1 3
VI VO

GND
1N4007

R2

2
1k
C3
470u C4
2n2
D2

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.

30
Chapitre III: Réalisation de la carte d’interface

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.

31
Chapitre III: Réalisation de la carte d’interface

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

32
Chapitre III: Réalisation de la carte d’interface

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.

D7 D6 D5 D4 D3 D2 D1 D0
0 1 0 0 0 0 0 1

1 0 0 0 0 0 1 0

0 0 1 0 1 0 0 0

0 0 0 1 0 1 0 0

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.

33
Chapitre III: Réalisation de la carte d’interface

34
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.
Annexe 3

Circuit imprimé

Circuit imprimé de carte d’alimentation

Circuit imprimé de la carte d’interface


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


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.
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).