Professional Documents
Culture Documents
Option : communication
Réalisé par :
Mr ZENATI A/Hakim Encadré par:
r Mr BOUDJELLABA.K
M KERROUCHE Samir
Promotion : 2008-2009
Dédicaces
Hakim
Dédicaces
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.
Hakim et Samir
Sommaire
Introduction général
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
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.
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.
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.
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°.
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.
1
Chapitre I: Généralités sur les moteurs 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.
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
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.
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.
4
Chapitre I: Généralités sur les moteurs pas à pas
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.
5
Chapitre I: Généralités sur les moteurs pas à pas
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é.
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).
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
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.
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
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
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.
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.
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.
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.
10
Chapitre I: Généralités sur les moteurs pas à pas
Le moteur à 8 fils est celui qui permet le plus de flexibilité, quant au nombre de façons
différentes de le contrôler.
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.
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
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.
12
Chapitre I: Généralités sur les moteurs pas à pas
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.
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é.
13
Chapitre II: Port parallèle et programmation sous Delphi
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).
14
Chapitre II: Port parallèle et programmation sous Delphi
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.
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]
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 :
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.
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).
18
Chapitre II: Port parallèle et programmation sous Delphi
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é.
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
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
nouveau nom à la feuille de travail qui s'est affichée. Modifiez pour cela la propriété Caption
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
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.
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;
24
Chapitre III: Réalisation de la 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
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.
26
Chapitre III: Réalisation de la carte d’interface
LE D
L H H H
L H L L
L L X Q
H X X Z
X : indéterminé.
Q : l’état précédent de Q+ .
27
Chapitre III: Réalisation de la carte d’interface
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.
28
Chapitre III: Réalisation de la carte d’interface
III.3 Alimentation:
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
30
Chapitre III: Réalisation de la carte d’interface
Fig III.9: L’interface graphique pour commander deux moteurs pas à pas
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
Perspectives:
Circuit imprimé
Résistances
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] : 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.
Site Web: