commande d'un moteur pas-à-pas - porte paralele avec delphi.pdf

²&<

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

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

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 ;




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


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.


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.


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


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


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.


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.

http://www.positron-libre.com/cours/logique-combinatoire/table-verite.htm#chronogramme


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.


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


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.


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.


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


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.

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


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


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 :


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)


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


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.


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.

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


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


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


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.


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


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.


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.


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.


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


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.


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


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


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

commande d'un moteur pas-à-pas - porte paralele avec delphi.pdf

Documents