COMMANDE NUMERIQUE
D ' UN MOTEUR PAS A PAS
SOMMAIRE :
I°/ ETUDES DES MODES DE FONCTIONNEMENT :.........................
A°/ FONCTIONNEMENT MANUEL :..............................
1°/ Le cahier des charges :................
2°/ Le micro-contrôleur :.................
3°/ Les roues codeuses :......................
4°/ Les afficheurs et leurs étages de puissances :............................................................................................
5°/ L'interface micro-contrôleur / moteur :......................................................................................................................
a°) Le moteur pas à pas :..
b°) Etage Contrôleur et Driver :
6°/ Les leds :...............................................
B°/ FONCTIONNEMENT AUTOMATIQUE :.................
II°/ ETUDE EXPERIMENTALE DU SYSTEME :..................................
A°/ LE MODE MANUEL :..................................................
Le projet d’analogique consiste à réaliser une interface programmable pour moteur pas à pas. On peut ainsi "imager" tout objet se trouvant dans le champ d'une caméra. Imager permet d'obtenir des images en coupes de substances illuminées, comparable aux scanners. Les mouvements des objets doivent être connus avec précision et doivent donc être obtenus grâce à un système mécanique précis et reproductible (d'où l'utilisation d'un moteur pas à pas associé à un système de commande numérique programmable). Le projet a donc pour objet de développer le système de commande d’un moteur pas à pas en utilisant un micro-contrôleur, et de permettre la commande directe par l'utilisateur et l'interfaçage via la liaison série d'un ordinateur de type PC, RS232.
Pour réaliser ce projet, nous disposons d'un moteur pas à pas (Crouzet Servo de 12 Volts et 0,6 Ampères) 4 phases monté en unipolaire, d'un micro-contrôleur, des circuits de commande spécifiques du moteur (Contrôleur et Driver) et d'un circuit d'interface RS232 permettant l'échange d'information entre le PC et le micro-contrôleur. En ce qui concerne les tests, nous utiliserons un émulateur d' EPROM afin d'éviter la programmation et l'effacement répétés de la mémoire programme du micro-contrôleur pour chaque test de fonctionnement.
Nous analyserons tout d'abord les exigences du cahier des charges en fonction des modes de fonctionnement (manuel ou automatique) qui nous obligent à effectuer des choix au niveau hardware (matériel) et software (logiciel). Puis, nous évoluerons en fonction des programmes pour les modes de fonctionnement : programme Assembleur en mode manuel, et programme en Turbo C et Assembleur en mode automatique.
I°/ ETUDES DES MODES DE FONCTIONNEMENT :
A°/ FONCTIONNEMENT MANUEL :
1°/ Le cahier des charges :
L'utilisateur doit pouvoir obtenir en une seule opération le positionnement du système en un point choisi quelconque du cercle. Pour ce faire, il indique au système le sens et l'amplitude du déplacement souhaité en degrés (angle de rotation programmable de -180 à +180 degrés). La vitesse sera fixée et prise comme étant la moitié de la vitesse maximale de rotation du moteur. En pratique, la valeur angulaire sera entrée à l'aide de 3 roues codeuses pour la valeur absolue et un bouton poussoir en déterminera le signe. Toute intervention de l'utilisateur sera impossible durant la rotation, une LED rouge indiquera à l'utilisateur que les commandes sont de nouveau disponibles (led allumée). Cette rotation est effectuée par pression sur un bouton poussoir. La position angulaire absolue en degré est affichée en utilisant 3 afficheurs 7 segments. Cet angle peut être ré-initialisé (remise à zéro) permettant ainsi de prendre la position actuelle du rotor du moteur comme étant la nouvelle origine du repérage angulaire absolue. Cette origine est conservée jusqu'à la nouvelle remise à zéro de l'affichage.
2°/ Le micro-contrôleur :
Etant donné le nombre important de pattes du micro-contrôleur que nous devons utiliser pour l'interface moteur, roues codeuses et affichage; le micro-contrôleur 80C52 ne pouvait être adéquat (comme le préconise le cahier des charges). Il faut un micro-contrôleur avec un ROM interne ( mémoire programme) afin de bénéficier de tous les avantages que cela nous procurera : port zéro et port deux disponibles et câblage rapide.
Le micro-contrôleur est le 87C51 d'Intel (128 octets de RAM et 2 Koctets de ROM). Mais avant de l'utiliser, nous nous sommes servis pour les tests du 83C154 (Pickyback; ROM interne se fixant en externe au-dessus du micro-contrôleur simulant un 87C51).
Ce micro-contrôleur fonctionne avec une fréquence d'horloge de 12 Mhz et d'une tension d'alimentation de 5 Volts (découplée par 0,1 µF). La patte EA! (External address) doit être à 5 Volts (pas d'adressage externe).
Le reset actif au niveau haut sera câblé avec un circuit RC pour le démarrage à froid et un bouton poussoir pour le démarrage à chaud.
5 V
C = 10µF
C BP
Reset R = 10K
R
Nous devons avoir trois interruptions externes (changement de sens, remise à zéro de l'angle, demande de rotation). Or deux interruptions sont disponibles INT0! et INT1!, un bouton poussoir et une résistance seront donc nécessaires.
INT0! BP 1/2
5 V R INT1!
R = 1K
Un bouton poussoir servira pour deux fonctions (la différenciation entre les deux fonctions sera effectuée par le logiciel en assembleur).
3°/ Les roues codeuses :
Les trois roues codeuses sont codées en BCD sur 4 bits (Binary Codage Decimal). Le brochage de ces roues codeuses est le suivant ( A représentant le bit de poids fort et D le bit de poids faible ) :
Vue du dessous
c a Vcc b d
Vss
Ces roues codeuses sont montées en pull-down (résistances de 1 k reliées à la masse ; valeurs prises par défaut) puisque le niveau zéro de l'une des pattes est en fait fictif. Seul le niveau haut est imposé à 5V (le niveau bas correspond à une patte "en l'air"). De plus, pour la protection des entrées du micro-contrôleur, on a rajouté des résistances séries de 30 k (valeur prise pour obtenir une bonne régulation du courant d'entrée dans le port du micro-contrôleur).
R1
patte micro-contrôleur broche roue codeuse
R2 R1 = 30 k
R2 = 1 k
Deux roues codeuses permettent l'obtention d'un octet que l'on peut introduire sur un port du micro-contrôleur (le port 0 a été sélectionné). Quant à la troisième roue codeuse représentant les centaines, nous nous sommes permis de n'utiliser que le premier bit afin de définir l'angle de rotation du moteur pas à pas de 0 à 99 degrés ou de 100 à 180 degrés (180° étant l'angle de rotation maximal dont peut tourner le moteur). Cette broche représentant le bit des centaines est reliée à la patte P2.7 du micro-contrôleur. La recherche de la valeur inscrite sur les roues codeuses se fera au niveau logiciel.
4°/ Les afficheurs et leurs étages de puissances :
Les afficheurs sont des HP5082-7740 à cathode commune et sont câblés sur le port 1 du micro-contrôleur. Pour allumer un segment, le courant traversant celui-ci doit être d'environ 20 mA. Nous devons donc utiliser des buffers comme amplificateurs de courant car le courant maximum dans une patte d'un port est de 100 µA. De plus, le port 1 est de 8 bits, c'est-à-dire que nous disposons de 8 fils pour 21 segments (répartis sur 3 afficheurs, point à droite non-inclus). La tension aux bornes d'une des leds de l'afficheur doit être de 1,5 Volts pour que le segment soit bien éclairé. Nous savons que la tension d'un port est de 3 à 4 Volts (lorsque le niveau est haut) donc on ajoute en série avec chaque led, une résistance de (3V-1.5V)/20mA soit de 75 (on prendra des résistances de 68 ).
Il est nécessaire d'afficher par intermittence les centaines de l'angle sur un afficheur, les dizaines sur un autre et les unités sur le dernier. Pour sélectionner l'un des 3 afficheurs, on utilisera un transistor en bloqué-saturé afin que la connexion à la masse se fasse ou non pour chaque afficheur. Ce transistor devra être de forte puissance puisque le courant total traversant son collecteur et son émetteur est d'environ de 160 mA ( 8 * 20 mA), ce sera le transistor BD135 NPN. Etant donné que son béta est faible, environ 50, le courant dans sa base sera de 3,2 mA.
Le courant de base de ce transistor est trop grand pour qu'on relie sa base à une patte d'un port du micro-contrôleur. Il faut pour palier ce problème utiliser un transistor PNP, car les ports sont des pull-up, soit on a environ 3 à 4 Volts, soit on a une masse. Lorsqu' une patte est à 3 Volts, le transistor est bloqué, et si elle est à la masse, le transistor est passant (c'est un PNP). On relie donc le collecteur du transistor PNP à la base de notre transistor de puissance. Une résistance série à la base du PNP permettra de limiter le courant de base.
Le micro-contrôleur ne supporterait pas un courant d'entrée supérieur à 100 µA. De plus, la tension fournie par le micro-contrôleur est insuffisante pour bloquer le transistor PNP, nous avons besoin d'un pont diviseur sur l'émetteur du PNP. Les buffers seront câblés sur le port 1 et la sélection de l'afficheur des centaines sur P3.6, celui des dizaines sur P3.5 et celui des unités sur P3.4.
Lorsque T2 est bloqué, la tension de base est de 3V et le courant de base est nul. Il y a un blocage si Veb < 0.6 Volts. On a :
3volts + Veb = V (avec V=tension d'émetteur)
d'où V < 3,6 volts
On peut donc mettre un pont diviseur par 2 sur l'émetteur, on aura V=2,5 volts, le transistor sera bien bloqué (la résistance R1 a été choisie de 100 ). Lorsqu'il est conducteur, la tension de base est de :
Vb = R2 . Ic / avec = 70
Le Veb = 0,6 Volts et Ic = 4 mA permet de déterminer R2, Vb + Veb = 2,5 v R2 = 30 k
Le même montage doit être réalisé pour le second et le troisième afficheur afin que l'on puisse sélectionner l'un des trois afficheurs. On affichera la valeur de l'angle de rotation en sélectionnant l'afficheur centaine et pas les autres, et ensuite en sélectionnant l'afficheur dizaine et pas les autres... L'affichage se fera donc par intermittence, mais tellement rapidement que l'oeil humain ne puisse pas voir de clignotements. Si l'angle est de 150°, on affiche 1 puis 5 et 0 puis 1... (affichage jamais en même temps). Ainsi pour sélectionner un des afficheurs, il faut par le logiciel taper l'instruction :
CLR P3.x
5°/ L'interface micro-contrôleur / moteur :
a°) Le moteur pas à pas :
Le moteur pas à pas est unipolaire 4 phases. Ce fonctionnement est représenté par les schémas des figures page 5.1. Le moteur représenté possède un stator à deux enroulements à point milieu (points milieux reliés à la masse) et un rotor à une paire de pôles (N-S). Les commutateurs S1 et S2 permettent 4 combinaisons d'alimentation des enroulements, ceci par ½ enroulement. En fait, le moteur est considéré comme ayant 4 enroulements indépendants ou 4 phases. Ce mode d'alimentation est dit "unipolaire" parce que la même polarité de tension est toujours appliquée aux mêmes bornes des enroulements. La disposition des circuits magnétiques est effectuée de telle façon que le rotor s'anime d'un mouvement angulaire, en fonction de l'excitation des bobines du stator (notre moteur pas à pas n'a pas le point milieu des enroulements relié au plus mais à la masse; cela ne modifie en rien son fonctionnement : c'est un choix personnel). On comprend donc bien qu'il faille alimenter les quatre phases par des séries d'impulsion bien déphasées entre eux pour permettre la rotation du moteur.
Les caractéristiques précises du moteur sont les suivantes :
- Tension moyenne de 12 Vdc,
- intensité par phase de 0,6 A,
- résistance par phase de 20 ,
- angle de pas de 1,8° ramené à 1° grâce à un dispositif de 2 poulies et une courroie,
- couple statique de 0,35 Nm,
- vitesse de rotation maximale de 700 pas/s,
- inertie du rotor de 105 g.cm²
Pour plus d'information, nous avons fourni la documentation détaillée du moteur pas à pas à la page 5.2.
b°) Etage Contrôleur et Driver :
IL est nécessaire d'utiliser ces circuits d'interface afin de faire fonctionner le moteur pas à pas. Le contrôleur L297N (SGS-Thomson L297) fourni les signaux des 4 phases du moteur en fonction des impulsions qu'il reçoit sur son entrée clock, ainsi que le sens de rotation en fonction du niveau sur l'entrée CW/CCW!.
Le fonctionnement du moteur a été initialisé en pas entier (half/full!=0). Dans les 2 modes (pas entier ou ½ pas), deux signaux INH1! et INH2! sont générés et accélèrent la propagation du courant dans les enroulements du moteur pas à pas lorsque Control=0. Le "coeur" du L297 est un bloc appelé traducteur qui permet de générer convenablement les séquences des phases en pas entier ou en ½ pas (page 5.3 fig.1). En interne, le traducteur consiste en un compteur 3 bits qui génère un code séquentiel pour un pas comme montré à la fig. 2 p5.3.
En représentant les 8 états possibles que peut concevoir le circuit, on obtient un saut de pas (c'est-à-dire que les pas ne se font pas entièrement mais seulement en ½ pas).
On initialisera le circuit L297 en générant une impulsion négative sur son entrée "reset", et en mettant un niveau haut sur l'entrée "enable" afin d'autoriser les sorties. Quant à l'entrée CONTROL, elle sera fixée à 1.
Elle permet de réguler le courant de charge dans les enroulements du moteur pas à pas lorsque CONTROL=0 en agissant sur les signaux INH1! et INH2!. La fréquence d'oscillation fixée par un circuit RC détermine le taux de commutation des transistors : 2 kHz (donnée dans la documentation du circuit).
Et la broche Vréf. permet de fixer le courant de charge. Comme les résistances câblées aux pattes SENSE1 et SENSE2 sont traversées par 0,6A (courant de charge du moteur pas à pas), et que les valeurs des résistances sont de 0,5 chacune (valeurs typiques, voir doc. du constructeur), on a donc une tension à leurs bornes de Vréf., soit de 0,3V.
Nous avons câblé un potentiomètre sur cette entrée afin d'ajuster la tension. Le contrôleur L297 a été conçu pour fonctionner avec le circuit L298N Driver de puissance qui fournit le courant nécessaire au moteur pas à pas. Ce circuit peut fournir jusqu'à 4 A sous 46 V (voir fig. 1 p 6.1 ). Il est composé de logique combinatoire et de transistors de puissance qui fonctionnent en bloqués-saturés. Il reçoit les signaux A, B, C et D des 4 phases (signaux fournis par le L297) et fournit les mêmes signaux mais avec la tension et le courant nécessaire au moteur pas à pas (12V et 0,6A). Le circuit L298 sera donc alimenté en 12 V.
Si l'on représente la structure du circuit fig. 2 p6.1 pour un enroulement du moteur pas à pas, on peut aisément expliquer son principe de fonctionnement (INH1! Et INH2! niveaux hauts). Lorsque A est au niveau haut et B au bas, le flux de courant traverse Q1 et Q3 : l'enroulement se charge et le moteur tourne. Si maintenant B est haut et A bas alors l'enroulement se charge avec un courant inverse au précédemment : le moteur tourne. Mais entre les 2 étapes, le même phénomène se produit pour le second enroulement. En résumant les étapes, on a :
- chargement de l'enroulement 1 dans sens 1,
- chargement de l'enroulement 2 dans sens 1,
- chargement de l'enroulement 1 dans sens 2,
- chargement de l'enroulement 2 dans sens 2.
A chaque chargement des bobinages, le moteur tourne. Si par exemple, A et B sont au même niveau (ou ainsi que C et D), les 4 transistors sont bloqués : le courant recircule de la masse vers Vcc via D2 et D3 ou D1 et D4. D'où la nécessité d'utiliser 8 diodes à commutations rapides supportant un courant de 1 A (les diodes 1N4148 ont des caractéristiques qui correspondent à ce que nous recherchons).
6°/ Les leds :
Pour différencier les modes de fonctionnement, nous allumons des LED : rouge pour le fonctionnement manuel et orange pour le fonctionnement automatique. Ces leds sont câblées via 2 transistors PNP fonctionnant en bloqués-saturés.
R1 R3
T
R2 R1 = R2 = 100
R3 = 33 k
T = BC 557 PNP
B°/ FONCTIONNEMENT AUTOMATIQUE :
Le fonctionnement automatique consiste au chargement des paramètres tels que l'angle de rotation, le sens et la vitesse du PC vers le micro-contrôleur. Ces paramètres seront tout d'abord rentrés sur l'ordinateur par l'utilisateur.
Ce mode de fonctionnement est identifié par l'allumage d'une LED orange. Le micro-contrôleur identifiera le mode de fonctionnement et attendra les commandes du PC sur la liaison série RS232. Le logiciel de commande automatique sur le PC sera développé en Turbo C. On pourra ainsi gérer les vitesses de rotation. Un problème intéressant consiste à tirer le meilleur parti du moteur pas à pas en cherchant à optimiser le temps nécessaire pour effectuer une rotation demandée sans perdre de pas. On réalisera une commande de la vitesse en 3 phases :
- démarrage à accélération constante inférieure à la limite de décrochage du moteur,
- plateau à vitesse constante,
- arrêt progressif à décélération constante symétrique de la phase de démarrage.
Le circuit d'interface est un émetteur/récepteur pour la liaison série RS232 : le MAX232 de Maxim. Il permet l'échange d'informations entre le PC et le micro-contrôleur puisqu'il convertit les 0V;5V du micro-contrôleur en -10V;+10V du PC et inversement. Le micro-contrôleur ne reçoit et ne fournit que des signaux 0-5V contrairement au PC (-12V;+12V). La liaison se fera par des connecteurs DB9 (9 broches) dont le câble est entrelacé (émission entrée = réception sortie et inversement).
patte 2 - TxD <--------------------------------------------> patte 3 - RxD patte 3 - RxD <--------------------------------------------> patte 2 - TxD
patte 5 - GND <--------------------------------------------> patte 5 - GND
Un signal fourni par le micro-contrôleur permet au PC de savoir si le câble est bien connecté à la carte (patte 6-P1.7 <--> patte6-DSR).
II°/ ETUDE EXPERIMENTALE DU SYSTEME :
Le schéma final du circuit est représenté sur la page 7.1.
A°/ LE MODE MANUEL :
Avant toute chose, nous allons tester le programme suivant afin de voir si nous obtenons bien les signaux tels que ALE et !PSEN, et si le reset fonctionne bien.
org 0000h
setb P3.4
toto cpl P3.4
jmp toto
Ce programme complémente la patte P3.4 du micro-contrôleur. On observe ces signaux :
|<------->|<--->|
t1=300ns t2=130 ns
Sur la documentation du micro-contrôleur, on lit : t1min = 275ns
t2min = 127ns
Aucun signal PSEN! n'est visible, puisque nous avons EA!=1.
Ces signaux correspondent exactement à ce qu'on attendait. Observons la patte P3.4 .
|<--------->|
t = 1,2 µs
Ce temps t correspond à environ 1 cycle qui représente 1 µs.
Lorsque l'on appuie sur le bouton reset, le système se ré-initialise de nouveau et il "repart".
Attardons-nous maintenant, sur les afficheurs. Otons le microcontrôleur. Le courant dans la patte de sélection du microcontrôleur ne doit pas dépasser 100 µA lorsqu'ils sont allumés. Lorsque l'on met un ampèremètre, on peut lire un courant de 60 µA. Cela est correct, nous pouvons rajouter le microcontrôleur.
Le petit programme de la page 8.1 est un compteur qui affiche 111 222 333 444 ...
Les valeurs 7 segments de ces chiffres sont dans le programme, c'est-à-dire en mémoire programme. Pour y avoir accès, on doit effectuer les instructions :
mov dptr,#(adresse fictive)
movc a,@a+dptr
Comme l'adresse fictive est digit, on a dptr = digit. Or a=0 donc le contenu de l'adresse a+dptr (ou a+digit) est transféré dans a puis sur le port 1 puis on incrémente dptr (dptr+1=dptr). Après 2 s (interruption du timer), on transfère le contenu de dptr+1 sur le port 1, etc ... Dès que @a+dptr=0 alors nous sommes à 999 et on ré-initialise dptr à digit et on recommence. Nous avons bien un compteur.
Nous avons parlé précédemment du fait que l'affichage devait s'effectuer par intermittence car le port 1 était sur 8 bits. Si le temps entre l'affichage du premier, du second et du troisième "digit" (afficheur) est trop court, le chiffre de l'un va se superposer sur le chiffre de l'autre et inversement. S'il est trop long, nous allons apercevoir des clignotements.
Si l'on représente les signaux nécessaire pour la sélection des afficheurs, on obtient ceci (ne sont représenté que l'écart entre 2 afficheurs, le principe est le même pour 3 afficheurs) :
Si T0 est trop petit alors l'afficheur 1 n'aura pas le temps d'être désélectionné et les données normalement prévues pour l'afficheur 2 sont présentes sur le premier afficheur vu qu'il n'est pas désélectionné (cela provient du temps de commutation des transistors). On peut donc dans ce cas-ci distinguer un chiffre faiblement éclairé superposé sur un autre fortement éclairé.
Par contre, si T0 est trop grand alors l'écart entre chaque affichage est trop important, il y a un clignotement. C'est ce problème que nous devons résoudre. Ce clignotement doit être tellement rapide qu'un oeil humain ne puisse le déceler. Cette durée doit être inférieure à 10/3 ms pour qu'on ne s'en aperçoive pas (10 ms pour 1 afficheur), soit 3,3 ms.
A chaque acquisition d'un chiffre, on fait appel à un sous-programme d'affichage. Celui-ci affiche sur le port 1 la valeur 7 segments de l'angle de rotation.
Avant d'afficher le chiffre sur un autre l'afficheur, un sous-programme de temporisation est appelé. Ce programme est, en fait, une attente pour ainsi éviter que l'on puisse mal lire l'angle à l'affichage (affichage par intermittence).
Quelle est la durée de cette temporisation ?
tempo mov r3,#2 1 cycle
tempo1 mov r2,#200 1
tempo2 djnz r3,tempo2 2
djnz r4,tempo1 2
ret 2
Comme un cycle est de 1 µs, on a : T = 4 µs + ( 2 µs * 200 + 1 µs)*2 = 0,8 ms
A la vue de ces résultats, nous pouvons en conclure que presque toute la carte est opérationnelle. Il ne nous reste plus qu'à étudier la rotation du moteur.
Afin de savoir si le moteur peut tourner, on met les entrées qui configurent la rotation à leurs niveaux respectifs. Puis, on relie l'entrée Clock du L297 à un générateur d'impulsion. Ainsi, on constate que le moteur tourne correctement. La vitesse maximale atteinte a été d'environ 45 tours pour 30 secondes, soit 1,5 tours/s ou environ 500 pas/s. Cette vitesse a été obtenue pour une fréquence d'horloge de 250 Hz (ou To=4 ms).
Le programme assembleur pour la commande du moteur est à la page 9.1 à 9.8.
Nous allons examiner le fonctionnement manuel. Tout d'abord, il faut savoir que pour ce mode la vitesse de rotation du moteur sera fixée à la moitié de la vitesse de rotation maximale du moteur (T = To*2 = 8ms).
Le timer gérant la période d'horloge fournit des interruptions toutes les 156 µs (avec une boucle, on arrive à obtenir la bonne période T=7,8ms). Le registre R4 de la boucle contient la valeur 50.
Dès le départ, nous sommes dans une boucle d'attente, puisqu'il faut appuyer sur un bouton poussoir pour mettre en route la rotation. Durant la boucle d'attente, on affiche l'angle de rotation qui se trouve mémorisé dans le registre R0 (R0=0, au départ). Dès qu'il y a une interruption externe INT demandant la rotation, un bit de test (test) passe de 1 à 0. Dès lors, on sort de la boucle, et l'on lit et calcule le pas de rotation des roues codeuses. Si ce pas est de 0 ou supérieure à 180° alors il n'est pas pris en compte et l'on retourne dans la boucle. Ce pas est ajouté au pas précédent pour l'affichage. Toutes les interruptions externes sont inhibées. Puis, on met le timer0 en marche afin que l'on obtienne la fréquence d'horloge. Comme une période correspond à l'angle 1°, on décrémente le pas de rotation jusqu'à 0 pour obtenir l'angle de rotation souhaité. Lorsque le pas est de 0, on éteint le timer, on retourne dans la boucle d'attente et on affiche l'angle de rotation.
L'affichage de l'angle s'effectue intermittence. Une fois que l'on connaît l'angle à afficher, on le divise par 100 pour en extraire le chiffre des centaines, puis le reste de la division sera divisé par 10 pour en extraire les dizaines, puis le reste correspond aux unités. Chaque chiffre obtenue est ensuite affiché chacun leur tour sur l'afficheur le caractérisant. Pour l'obtention de l'angle à afficher, cela est très délicat puisqu'il faut tenir compte d'une valeur pouvant atteindre 360, d'où débordement puisque 255 est le maximum (registre de 8 bits).
Il faut donc différencier 3 calculs à effectuer.
0
3
2 1
255 -255
180
Tout d'abord, si l'on part de 0 et que l'on tourne sur le cercle de gauche à droite ou de droite à gauche. Dans ce cas, on ajoute les angles de rotations entre eux tant que la somme ne dépasse pas 255 (mouvement 1 et 2). Lorsque la somme dépasse 255, le Carry passe à 1 et le micro-contrôleur nous fournit le résultat suivant : resultat=resultat-256
L'angle par rapport à 255 est de : resultat=(resultat-256)+1
Pour l'affichage, on teste si resultat>44 (équivaut à angle 300) lors qu'il y a eu débordement. Si c'est le cas, le chiffre des centaines est 3, sinon il est de 2. Quant au chiffre des dizaines, il est obtenu en additionnant le resulat en cas de débordement avec 55 (normalement avec 255 mais il aurait débordement) puisque le résultat ne depasserait pas 255. On ote le chiffre des centaines et l'on garde celui des dizaines et unités que l'on divise par 10 pour l'extraire.
Si on a un angle de 320°, le micro-contrôleur nous donne le résultat : 64. On ajoute 1 pour le remettre par rapport à 255, et comme il est supérieur à 44, le chiffre des centaines à afficher est 3. Ensuite, on ajoute 55 à 65. On obtient 120 et isole le chiffre des centaines en divisant par 100 et en ne conservant que le reste, soit 20. On divise 20 par 10 pour obtenir le chiffre des dizaines qui est le quotient 2 et le chiffre des unités qui est le reste 0.
Par contre, si l'on ne démarre pas de 0, on soustrait l'angle de rotation actuel au précédent. Mais si l'on repasse par l'origine, on complémente à 2 l'angle de rotation pour obtenir le bon angle.
Si nous avions précédemment l'angle 100 et qu'à présent le pas est de 110, alors 100-110=-10 ou 10 en valeur absolue (valeur à afficher). Et bien, le micro-contrôleur, lors de la soustraction, nous indique qu'il y a débordement. Le résultat qu'il nous donne est : resultat=256-resultat soit 246.
246 ---> 1111 0110 , on complémente à 2 (inversion des niveaux => "Ou exclusif") 0000 1001 et on ajoute 1 pour rétablir le bon rapport sur 255 0000 1010 soit 10.
Une fois l'origine franchi, on peut additionner l'angle présent au précédent seulement si le sens de rotation n'a pas été modifié.
La commande permettant d'effectuer la remise à zéro des afficheurs est obtenue par pression sur un bouton poussoir, même bouton effectuant le changement de sens. Deux opérations sont obtenues par pression sur un seul bouton (une seule interruption externe). La différenciation est faite par une temporisation de 1,5 s. Si l'on appuie plus de 1,5 s sur le bouton, on fait une remise à 0. Sinon on change le sens de rotation. Cela est obtenu par le test de IE1 qui est à 1 lorsque INT1! est à 0.
Les modes de fonctionnement sont choisis par le logiciel en Turbo C sur le PC. Mais il est tout de même possible d'avoir accès au mode manuel pour ainsi permettre l'utilisation de la carte indépendament du PC. On doit pour cela mettre sur les roues codeuses la valeur 199 et effectuer un reset, le mode manuel devient prioritaire.
B°/ LE MODE AUTOMATIQUE :
Le mode automatique permet d'obtenir une plus vaste utilisation des réelles capacités que puisse nous offrir le moteur pas à pas. Dès le lancement du logiciel conçu en mode graphique, on nous demande d'initialiser la carte, puis on envoie un caractère vers le micro-contrôleur qui indique alors s'il l'a reçu ou non. Les caractères sont envoyés sur la liaison série en 1200 bauds (Timer 1 en générateur de Baud pour le micro-contrôleur). Lors de l'envoi de caractères du PC vers le micro-contrôleur, on place le micro-contrôleur dans un boucle d'attente. Le mode de fonctionnement est demandé à l'utilisateur par le menu principal. Lorsque l'on choisit automatique, le PC envoie le caractère 'A' au micro-contrôleur qui se place en position d'attente de réception des paramètres. Ensuite, on définit le type de rotation que l'on désire effectuer : rotation unique ou rotations enchaînées. Il est possible de se faire succéder jusqu'à 99 rotations successives (limites que nous nous sommes fixées, il est possible d'en obtenir beaucoup plus). Le choix déterminé permet de fournir au micro-contrôleur des informations supplémentaires quant au type de rotation sélectionné (envoi de 'U' à la fin de l'envoi des paramètres indique qu'une seule rotation a été demandée, sinon il se replace dans l'attente d'envoi de paramètres). Ces paramètres sont identiques quelquesoit le type de rotation défini, c'est-à-dire que l'on nous demande d'entrer un angle de rotation de 1 à 180, puis le sens CCW (Counter Clock Wise = sens inverse des aiguilles d'une montre) ou CW (Clock Wise = sens des aiguilles d'une montre), la vitesse de rotation de 1 à 9, le type de démarrage et d'arrêt et enfin pour les rotations enchainées l'attente entre 2 rotations. Il est clair que se posait la nécessité de pouvoir sauvegarder et lire les paramètres pour de nombreuses rotations enchaînées afin d'éviter l'entrée à chaque fois des paramètres sur le PC. Nous allons nous attarder sur les paramètres. L'angle est reçu par le micro-contrôleur qui le mémorise dans un registre. Le sens lui est directement modifié par mise à 1 ou à 0 de la patte P2.6 du micro-contrôleur.
La vitesse n'est pas directement envoyé vers le micro-contrôleur. Il faut savoir que la vitesse de rotation est modifiable par la fréquence d'horloge du L297N. Cette période peut être changée par la variation de la valeur de l'accumulateur lors de la boucle dans le programme d'interruption du timer0 (iT toutes les 156 µs). La vitesse maximale atteinte via le changement de cette valeur nous fournit la valeur minimale de A pour laquelle le moteur pas à pas ne perd pas de pas ( 30, soit 5 ms environ ½ tour par seconde). La vitesse minimale est obtenue lorsque A est au maximum soit 255 ( T=39,8ms ce qui correspond à 1 pas toutes les 1,5 s). On peut donc représenter la courbe de A en fonction de la vitesse.
A
255
30
1 9 Vitesse
On peut donc en tirer la pente (255-30)/(1-9) = -28,125
L'équation est : A= -28,125*vitesse+B si vitesse=1 alors A=255 d'où B=283,125
L'équation final est :
A= -28*vitesse+283
Cette équation sera résolue en Turbo C et seul le résultat sera envoyé vers le micro-contrôleur.
On doit également pouvoir gérer un démarrage et un arrêt progressif pour faire tourner un objet de poids assez élévé sans perdre de pas. On peut voir sur la page 12.1 que plus le couple résistant de la charge est élévé et plus la vitesse de démarrage doit être faible. Si l'on démarre le moteur à sa vitesse de rotation maximale avec une charge non négligeable sur son rotor, le moteur perdrait énormément de pas, ce qui n'est pas intéressant. Au démarrage, il faut donc réduire progressivement l'accumulateur sur la boucle d'interruption afin de réduire la période d'horloge jusqu'à ce que la vitesse ait atteinte la valeur souhaitée. Et réciproquement pour l'arrêt. On fera varier progressivement la vitesse en fonction de la valeur de l'angle de rotation. Si cette angle est de 180°, on fait augmenter la vitesse tous les 10° (180/18) de 0 à 80°(8*10°). La vitesse souhaitée est obtenue après 80° pendant 20°, puis, tous les 10° de 100 à 180° la vitesse diminue. Pour obtenir une variation suffisante de la vitesse, on utilise une variation de 2 puissance n, variation exponentielle de la vitesse. Avec un écart de A de 1, on a A=A+0 A=A+32
A=A+1 A=A+64
A=A+2 A=A+128
A=A+4 A=A+255 : Valeur maximale que l'on puisse atteindre
A=A+8
A=A+16
Pour le démarrage, on part de 255 et on additionne A à chaque coefficient dans un ordre décroissant et ce tous les 1/18 de l'angle de rotation souhaité jusqu'à atteindre la valeur de A souhaité. Quant à l'arrêt, le principe est le même sauf que l'on part de A et on ajoute les coefficients dans un ordre croissant.
Si l'on représente la courbe de la variation de A en fonction de l'angle rotation, on obtient ceci :
Une fois que les paramètres sont enregistrés dans des tableaux qui leur sont réservés, le PC attend que vous pressiez une touche pour démarrer la rotation. Au moment où vous pressez une touche, le micro-contrôleur reçoit les paramètres pour une seule rotation qui lui sont envoyés un par un. Un délai de 100 ms a été mis entre chaque envoi afin de laisser le temps au micro-contrôleur de traiter ces informations une par une. Lorsqu'il a tout reçu, il entame sa rotation. Une fois terminé, il envoie le caractère 't' au PC pour lui indiquer la fin de rotation. Le PC se replace au menu principal pour une rotation et le micro-contrôleur se place dans sa boucle d'attente du choix du mode de fonctionnement pour une rotation unique, ou le PC envoie les paramètres suivants vers le micro-contrôleur qui continue le cycle tant que le PC ne lui envoie pas un angle de 0°. Si c'est le cas les rotations enchaînées sont terminées. Après chaque rotation s'affiche à l'écran, l'angle de rotation effectué par le moteur (le même qu'en mode manuel); il y a possibilité de le remettre à 0 par une simple pression sur un bouton.
Le choix du mode de fonctionnement permet de choisir le mode manuel. Dès lors, le micro-contrôleur reçoit le caractère 'M' et il se met en manuel. Pour qu'il revienne en veille, il suffit d'appuyer sur "ESC" du clavier. L'appui sur cette touche n'importe où dans le déroulement du programme en Turbo C permet de revenir au menu principal et le micro-contrôleur se place dans sa boucle d'attente du choix du mode de fonctionnement. Quant à la touche F2, elle ré-initialise la carte et fait sortir du programme en Turboc.
La touche F1 est une aide générale expliquant le principe de fonctionnement de la carte et du logiciel.
La carte et les logiciels de commande numérique d'un moteur pas à pas sont des outils très performants qui permettent d'effectuer de nombreuses rotations d'une extrême précision d'objet pouvant peser quelques bons kilos. L'obtention d'une rotation est faite avec une facilité et une souplesse de manipulation qui permettra de développer par la suite de nombreuses extensions qui s'appliqueraient à ce type de projet d'analogique. La possibilité de sauvegarder sur disquette plusieurs centaines de rotations les unes à la suite des autres et de les charger pour obtenir les rotations permettra également à l'utilisateur de réunir précision et rapidité d'exécution en même temps. Nous avons essayé de ne négliger aucun détail au moment de la conception du logiciel, mais libre à vous d'ajouter des options afin de rendre cet outil de travail encore plus performant.