COMMANDE DUN

MOTEUR PAS A PAS AVEC

UN HACHEUR

25/06/2013

Projet de Synthse
Il sagit ici dorienter laxe du moteur pas pas dans une direction voulue
par rapport au Nord magntique.

NICOLAS MENDES
BACHIR ME G HN IN E

LUDOVIC REYNOUARD
YOA N N D U T E L

Commande dun moteur pas pas avec un hacheur

REMERCIEMENTS

Nous remercions Mr James et Mr Laffont pour leur aide et les conseils quils nous ont donn tout
au long du projet durant les horaires encadres et en dehors. Nous tenons galement remercier Mr
Pasquier pour ses divers conseils quil nous a donns durant la ralisation et la rflexion du hacheur ainsi
que Mr Landrault pour ses conseils sur les transistors et les optocoupleurs.
Enfin nous remercions le technicien Mr Sanchez pour nous avoir mis disposition de manire trs
rgulire la salle de projet ainsi que pour le matriel prt pour raliser nos diffrents tests.

Page 1

Commande dun moteur pas pas avec un hacheur

INTRODUCTION

Dans le cadre du projet de synthse nous avons eu comme sujet :

Commande dun moteur pas pas avec hacheur . Un hacheur est un dispositif de llectronique
de puissance permettant de convertir une tension continu en une autre tension continu. Il peut y avoir
intervention de un ou plusieurs interrupteurs commands. Dans notre cas, on aura affaire un hacheur
dvolteur, c'est--dire quon diminuera la tension dentre laide dun circuit de puissance adapt qui
sera dvelopp plus tard dans ce rapport. Le moteur fournit, par Mr James, tait vraisemblablement un
ancien moteur dimprimante pris lIUT voisin. Nous avons ralis lensemble de nos programmes sur
MPLAB, un logiciel fournit par le fabricant du microcontrleur.
Comme indiqu par nos professeurs le but du TP de synthse est de synthtiser lensemble des
enseignements de la 1re anne du cycle Ingnieur de Gnie Electrique. De plus cet exercice est une
premire confrontation au travail dun ingnieur en entreprise.

Page 2

Commande dun moteur pas pas avec un hacheur

SOMMAIRE
REMERCIEMENTS ..................................................................................................................1
INTRODUCTION ...................................................................................................................2
SOMMAIRE ...........................................................................................................................3
1. ETUDE PRELIMINAIRE....................................................................................................4
1.1. Cahier des charges ...................................................................................................................... 4
1.2. Etude fonctionnelle ....................................................................................................................... 4
1.2.1. Schma fonctionnel .............................................................................................................. 4
1.2.2. Dcoupage fonctionnel ....................................................................................................... 4
1.3. Etude structurelle ........................................................................................................................... 5
1.3.1. Schma structurel.................................................................................................................. 5
1.3.2. Choix des solutions structurelles......................................................................................... 5
2. HACHEUR ......................................................................................................................6
2.1. Ralisation du hacheur................................................................................................................. 6
2.2. Choix des composants ................................................................................................................. 9
2.3. Routage ........................................................................................................................................10
3. PROGRAMMATION ................................................................................................... 12
3.1. Les composants utiliss ...............................................................................................................12
3.1.1. La boussole HMC6352 ..............................................................................................12
3.1.2. Lcran LCD JM164A .................................................................................................13
3.1.3. Le clavier .............................................................................................................................13
3.2. Les algorithmes............................................................................................................................14
3.2.1. Attribution des ports (setup.h) ..........................................................................................14
3.2.2. Fichier main.c.......................................................................................................................14
3.2.3. Fichier setup.c......................................................................................................................15
3.2.4. Fichier boussole.c ................................................................................................................16
3.2.5. Fichier lcd_4bits.c ...............................................................................................................19
3.2.6. Fichier can.c .........................................................................................................................21
3.2.7. Fichier commande_hacheur.c ...........................................................................................22
4. TESTS .......................................................................................................................... 25
4.1. Test hacheur .................................................................................................................................25
4.2. Test programmation ...................................................................................................................25
4.2.1. I2C et boussole ...................................................................................................................25
4.2.2. Ecran .....................................................................................................................................27
4.2.3. Clavier..................................................................................................................................28
CONCLUSION .................................................................................................................... 29

Page 3

Commande dun moteur pas pas avec un hacheur

1. ETUDE PRELIMINAIRE
1.1.

Cahier des charges

Le systme concevoir comporte une boussole numrique monte sur un moteur pas pas.
A l'aide d'un clavier matric et d'un afficheur, un oprateur choisira un angle par rapport au
Nord magntique et le moteur pas pas positionnera automatiquement le capteur boussole numrique
dans la bonne direction.
Pour raliser ce systme, nous devrons concevoir une interface de puissance isole galvaniquement
permettant de piloter les deux bobines du moteur pas pas.
Le moteur pas pas fourni par Mr James ralise 200 pas par tour et supporte une intensit
maximale de 1 ampre. Chaque pas ralise un angle de 1.8.
Des plaquettes sont mises notre disposition afin de raliser nos essais ainsi que des gnrateurs
de tous types.
De plus une plaquette contenant entre autre le microcontrleur nous a t donne au dbut du
projet. Mr Laffont a galement mis notre disposition divers logiciels et tutoriels permettant le
fonctionnement du microcontrleur sur nos machines et ce grce la forge (un site internet o nous devions
notamment crire lavancement de notre projet).

1.2.

Etude fonctionnelle

1.2.1. Schma fonctionnel

FP3

FP1

FP2

Acqurir les
donnes

Traiter les donnes

Afficher sur un
cran LCD

Commander le
moteur

1.2.2. Dcoupage fonctionnel

FP1.1 : Acquisition des donnes permettra au systme de rcuprer les donnes
corriger.
FP1.2 : Consigne entre par lutilisateur offrira la possibilit lutilisateur dentrer luimme une valeur dangle qui sera ensuite corrige en fonction du nord.
FP2 : Traitement des donnes permettra de traiter la donne c'est--dire de dfinir la
correction appliquer aux donnes.
FP3.1 : Affichage sur LCD permettra lutilisateur de connaitre la correction effectue.
FP3.2 : Commande du moteur agira directement sur le moteur et lorientera vers le nord
en fonction de la valeur de la donne corrige.

Page 4

Commande dun moteur pas pas avec un hacheur

1.3.

Etude structurelle

1.3.1. Schma structurel

Boussole
HMC6352

Deux hacheurs
quatre quadrants
Protocole I2C

Isolation galvanique
CNY74-4
Micro-Controlleur
PIC18F4550

Potentiomtre
100 k

Moteur
23LM-C303-10

Ecran LCD
JM164A

CAN
LEDS de contrle

1.3.2. Choix des solutions structurelles

Pour la boussole, on utilisera la boussole HMC6352 fourni par Mr James. Une recherche de la
documentation de cette boussole a t ncessaire. Cette dernire a t trouve sur le site du fabricant
Honeywell.
Pour le microcontrleur comme donn dans le cahier des charges, on utilisera le microcontrleur
PIC18F4550 de MICROCHIP.
Le Hacheur sera compos de deux hacheurs 4 quadrants chacun (les raisons de ce choix seront
expliques ultrieurement).
Pour laffichage on utilisera un afficheur LCD, fourni par le magasin de Polytech (que Francisco
Sanchez nous a donn). Cet afficheur en question est un afficheur du fabricant SHENZEN JINGUA DISPLAY,
et nous avons eu le modle JM164A. Ici encore une recherche de la documentation a t ncessaire. Le
fonctionnement et tous renseignements relatifs cet afficheur seront dvelopps plus tard.
Pour le clavier, on nutilisera pas un clavier matric comme dfini dans le cahier des charges, en
effet Mr James nous ayant inform de lindisponibilit de ce dernier, nous avons donc remplac le clavier
par un potentiomtre et un convertisseur analogique numrique (CAN) .Le potentiomtre sera un
potentiomtre classique disponible dans le magasin et pour le CAN on utilisera le CAN intgr au
microcontrleur.

Page 5

Commande dun moteur pas pas avec un hacheur

2. HACHEUR
2.1.

Ralisation du hacheur

La premire partie de la ralisation du hacheur consistait comprendre et dcouvrir le

fonctionnement dun moteur pas pas, pour ce faire nous avons test le moteur en question en alimentant
chaque bobine de ce dernier.
En effet, ce moteur possde 4 fils visibles, nous avons donc d au pralable dterminer quels fils
taient lis ensemble. Pour cela nous avons utilis un multimtre sur position mesure dinductance. On a
alors dduit que les fils rouge et bleu taient relis la mme bobine dinductance 5.21 mH, et que les fils
noir et vert taient relis la bobine de 5.26 mH.
On a ensuite cherch faire tourner le moteur dun pas. Pour cela, nous avons utilis une
alimentation en source de courant, c'est--dire que nous avons fix la tension une valeur trs basse
(infrieur 1 volt) et avons ensuite augment lintensit progressivement jusqu' voir le moteur effectuer un
pas. Nous avons conclu qu partir de 0.8 ampres le moteur effectuait un pas.
A partir de plusieurs essais dalimentation des bobines, on a mis en vidence le fait que la
rotation du moteur seffectue en alimentant les bobines lune aprs lautre. De plus, pour faire des pas
dans le mme sens, il faut veiller inverser les polarits des bobines lune aprs lautre comme suit :
Ordre
1
2
3
4

Polarits
+
Vert
Bleu
Noir
Rouge

Noir
Rouge
Vert
Bleu

On en a donc dduit qu'un hacheur 4 cadrans tait ncessaire.

On a d'abord ralis le hacheur sans prendre en compte la partie commande.

NB: Les caractristiques de chaque composant seront dveloppes dans la partie 2, de plus les diffrents
courants, rsistances, tensions seront visibles sur lillustration 1 reprsentant un hacheur 4 quadrants.
Page 6

Commande dun moteur pas pas avec un hacheur

On a tabli le calcul suivant pour trouver la valeur de Rlimite :

V

= (R

)+V

+V

IE_K1 = IEA + IC_K1

IC_K1 =IE_K1 - IEA = 0.8 - 0.1 = 0.7 A
R

AN:

= 0.6
.

= .

A partir de cette formule, on se retrouve avec deux inconnues : Rlimite et Vext.

On a uniquement les deux inconnues qui sont des variables dpendantes l'une de l'autre, quand
Rlimite augmente, Vext augmente galement. On a donc dcid de fixer arbitrairement Vext pour obtenir une
valeur de rsistance qui soit la plus petite possible. Ainsi on obtient une valeur de Vext petite et on perd le
moins d'nergie possible.
On a donc pour Vext = 9 Volts, une valeur de Rlimite gale 11,14 ohms.

On passe prsent au courant ncessaire pour la commande de nos transistors. Ayant choisi un
optocoupleur qui dlivre au maximum un courant de 50 mA dans l'metteur, on s'est donc confront au
problme de courant faible dans la base du transistor de commande (Kn sur lillustration 1). Pour remdier
ce problme on a dcid d'amplifier ce courant l'aide d'un transistor (TA sur lillustration 1).
On arrive donc au calcul de RA pour fixer le courant du collecteur du transistor d'amplification
50 mA pour ainsi avoir 100 ma dans le courant de l'metteur du mme transistor.
Calcul de RA :
V

= (R I

)+ V

+V

+V

IEA = ICA + IBA

ICA = IEA IBA
Pour saturer K1 il faut 0.1A dans IEA
ICA = 0.1 -0.05 =0.05 A
R =

I
V

= 1.2 V

= 1.3

A.N : =

.
.

Page 7

Commande dun moteur pas pas avec un hacheur

On arrive donc au rglage du courant dans l'optocoupleur, pour cela on utilise une rsistance que
l'on calcule comme suit :
Calcul de Ropto
V

=R
R

I
=

+V
V

(
)

+V

+V

+V

On prend donc I

A.N :

= 50mA

= 0.3V

= 1.2V

= 0.6V

= 1.3V

Maintenant que la partie courant fort de loptocoupleur a t dfinie, on va sintresser la

partie microcontrleur. Au niveau de la diode de loptocoupleur, il faut une tension de 1.6 volts, pour
rgler cette tension on utilise une rsistance RF que lon a calcul comme ci-dessous :
Calcul de RF :
Vcc = RF IF + VF
IFmax = 50 mA
On prend : IF = 20 mA
R =
AN: =

V V
I
.
.

= 170

Comme on peut le voir il y a des diodes prsentes au niveau des transistors de commandes (Kn sur
lillustration 1), celles-ci permettent de dissiper lnergie prsente dans lune des bobines lorsquaucun des
interrupteurs (Kn) nest passant et que lon passe un autre hacheur.
A partir de nos calculs, nous sommes alls voir ce quil y avait disposition dans le magasin afin
de choisir nos composants.
Les hacheurs 4 quadrants raliss sous le logiciel de CAO Proteus sont visibles sur lannexe 4.

Page 8

Commande dun moteur pas pas avec un hacheur

2.2.

Choix des composants

Pour les transistors Kn, nous avons cherch des transistors qui avaient un courant de saturation
proche de 1 Ampre. On a donc choisi les transistors SGS Thomson BD237. A saturation ce transistor a les
caractristiques suivantes :
Icsat = 1 A /// Ibsat = 0.1 A /// Vcesat = 0.6 V /// Vbesat = 1.3 V
Le choix de Rlimite a t dfini par la puissance dissipe qui vaut :
P = R * I2 = 11.14 * 0.72 = 5.46 W
On a donc d prendre une rsistance de puissance 10 Watts de 12 ohms.
Concernant le choix du transistor damplification, il nous fallait en sortie de lmetteur un courant
de 100 mA, nous avons donc choisi le transistor de PHILIPS semi-conductors 2N2219A avec les
caractristiques suivantes :
Iesat = 150 mA et Ibsat = 15 mA pour Vcesat = 0.3 V et Vbesat = 1.2 V
On a choisi loptocoupleur afin de faire une isolation galvanique, qui consiste sparer la partie
commande de la partie puissance, par sparation on entend aucune connexions lectrique entre les deux
parties. Ici on a choisi loptocoupleur CNY74-4 du fabricant TEMIC qui prsente les caractristiques
suivantes :
Une tension aux bornes de la diode de 1.6 Volts
Un courant dans le collecteur du phototransistor de 50 mA.
Concernant la diode, on a choisi une diode laissant passer un courant de 1 Ampre. Dans le
magasin on a trouv des diodes laissant passer un courant maximum de 1 Ampre. Cependant tant
donn que nous tions proche de notre courant circulant dans la bobine, nous avons opt pour une diode
laissant passer un courant maximum de 3 ampres afin davoir la certitude que tout le courant circulant
dans la bobine puisse circuler dans la diode.
Pour les autres rsistances, on a une puissance dissipe de :
P = Ra * Ica2 = 118 * 0.052 = 0.295 W pour Ra
P = Ropto * Ic_opto2 = 0.28 W pour Ropto
Ces puissances tant proches de 0.25 Watts, en accord avec les professeurs, nous avons dcid
de prendre des rsistances de 0.25 Watts (ces rsistances chaufferont durant lutilisation du moteur sans
aucun risque de perte du composant).
Concernant la rsistance RF, on a une puissance ses bornes de :
P = RF * IF2 = 170 * 0.022 = 0.068 W
Donc pour cette dernire une rsistance de 0.25 Watts est largement suffisante.
On ajoute que la tension Vext continue de 9V sera dlivre par une alimentation continue fourni
par Mr Sanchez.

Page 9

Commande dun moteur pas pas avec un hacheur

2.3.

Routage

Afin dapporter un complment ce projet nous avons dcid de raliser le routage de la

carte de commande du moteur, celle-ci contenant lisolation galvanique, ltage damplification et le
hacheur. Pour cela nous avons dcid de raliser deux cartes diffrentes, une pour chaque bobine du
moteur. Il aurait donc suffi de raliser le routage une fois, puis on aurait imprim deux fois la mme carte.
Pour cela nous avons repris le schma de commande dune des bobines ralis durant les
TP de CAO. Il a tout de mme fallu faire attention au choix des composants mettre sur le schma afin
que leurs empreintes soient en accord avec nos composants, c'est--dire quils aient la mme taille mais
aussi que les trous soit percs et placs correctement. Voici donc le schma ralis sous le logiciel Proteus :

Page 10

Commande dun moteur pas pas avec un hacheur

Ensuite on a conu le routage de la carte sous Ares toujours laide de Proteus. On a pu

remarquer que les pistes avaient une largeur par dfaut de 10th, ce qui est normalement suffisant pour
notre courant qui est au maximum de 1A. En effet aprs le calcul on a trouv une largeur de 2.6th pour ce
courant. Mais aprs plusieurs conseils nous avons choisi une largeur de piste de 30th pour la partie
puissance et de 20th pour la partie commande. Voici donc le routage ralis :

On peut remarquer que nous avons d crer le connecteur J1 avec dix broches, il en existait dj
un dans la librairie de Proteus mais cela ne nous convenait pas car les broches ntait pas plac au bon
endroit. Nous avons aussi d augmenter le diamtre des pastilles pour les diodes car celle de Proteus
ntait pas assez grosses, donc nous avons cr un nouveau package en plus de celui qui existait dj
dans la librairie Proteus.

Pour des raisons de manque de temps, mais aussi le fait de ne pas avoir de composants de secours
en cas de problmes. Nous avons dcid de ne pas raliser ces cartes.

Page 11

Commande dun moteur pas pas avec un hacheur

3. PROGRAMMATION
3.1.

Les composants utiliss

3.1.1. La boussole HMC6352

3.1.1.1.

FONCTIONNEMENT GENERAL

La boussole possde deux adresses desclave :

Ladresse 0x42 pour crire une commande dans la RAM ou dans lEEPROM
Ladresse 0x43 pour lire des donnes de la RAM ou de lEEPROM
La boussole possde deux modes de fonctionnement. On peut :
lui dire de calculer langle une certaine frquence et lors de la rception des donnes
on obtiendra la dernire valeur calcule et stocke dans la RAM
ou on peut lui commander de calculer langle un instant t et dacqurir cette valeur
calcule (beaucoup plus long car il faut attendre que le calcul soit effectu avant
dacqurir).
Voici les diffrentes adresses dcritures et de lectures de la boussole :

3.1.1.2.

LIAISON I2C

Pour la liaison I2C, on utilisera une mulation de cette dernire et non le priphrique intgr du
microcontrleur. Pour ce faire nous avons donc d crire plusieurs sous-programmes permettant de raliser
les oprations quaurait fait le priphrique. Ceci a notamment t commenc en TD.
Tout dabord entre chaque envoi et rception, il faut envoyer des conditions de start et de stop
pour signifier une communication sur le bus I2C.
Pour envoyer une commande, on configure la broche SDA en sortie et on envoie bit bit sur un
signal dhorloge les donnes. Puis on configure la broche SDA en entre pour rceptionner le 9me bit qui
est le bit confirmant la bonne rception de la commande (ou de la donne). Cet acknowledge est 0
pour une bonne commande et 1 pour une mauvaise.
Pour rceptionner une donne, on fonctionne en deux parties car la donne reue est sur 16 bits.
Tout dabord, on envoie ladresse de lesclave signifiant la lecture puis passe en mode rception. En
rception on configure le port SDA en entre et on lit sa valeur chaque coup dhorloge de SCL. Pour la
rception de la premire partie (MSB) il faut que le matre envoie un acknowledge et pour la
deuxime partie (LSB) il faut que le matre envoie un non-acknowledge .
Voir les algorithmes pour les diffrentes fonctions dinitialisations et de transferts au paragraphe
3.2.3.
Page 12

Commande dun moteur pas pas avec un hacheur

3.1.2. Lcran LCD JM164A

Cet cran LCD possde le mme fonctionnement que celui tudi lors des TP de SP. Ainsi, nous
avons choisi de communiquer avec lui sur 4 bits pour conomiser les ports du microcontrleur.
Nous avons donc connect :

RS la broche RD0
E la broche RD1
R/W la masse car nous sommes toujours en criture donc au potentielle 0
Le bus de donnes sur les broches RD5RD2

Pour envoyer une commande, il faut mettre la broche RS 0. Puis (comme nous sommes en
fonctionnement 4 bits) crire la partie haute de la donne sur le port de donne et mettre E 1 pour
valider lenvoi et faire la mme chose pour la partie basse.
Pour envoyer un caractre, lenvoi sexcute de la mme faon (en deux parties) mais cette fois il
faut mettre la broche RS 1.
Pour la question dinitialisation de cet afficheur (choix du mode de fonctionnement, prsence du
curseur,) se rfrer aux algorithmes prsents au paragraphe 3.2.4.

3.1.3. Le clavier
Comme dit prcdemment, aucun clavier matric n'tant disponible, il fut remplac par un CAN
(Convertisseur Analogique Numrique) et un potentiomtre. Lide tant que lorsque l'on augmente ou
diminue le potentiomtre, la boussole se dcale du nord en fonction du sens tourn du potentiomtre (donc
en fonction de l'augmentation ou diminution de la tension).
Le potentiomtre est un potentiomtre classique pris dans le magasin. Le CAN est celui intgr au
microcontrleur que nous avons programm l'aide de la documentation (dont les registres configurs ont
t mis en annexe paragraphe 2.3).
Il nous a fallu configurer trois registres pour le CAN:ADCON0, ADCON1 et ADCON2.
Pour ADCON0, on a mis le 1er bit 0 afin d'activer le CAN, les 5 bits suivants sont 0 afin de
slectionner le canal AN0 du microcontrleur (qui est sur le port RA0) et qu'aucune conversion n'est en cours
(bit 2).Les bits 7 et 8 sont 0 comme indiqu dans la documentation.
Pour ADCON1, la combinaison 1110 sur les bits de poids faible permet de mettra AN0 en
analogique est les autres AN en numriques (donc de les laisser par dfaut) .On met les 2 bits suivants 0
afin d'avoir comme tension de rfrence VCC (bit 5) et la masse (bit 6).Les deux derniers bits tant 0
comme indiqu dans la documentation (unimplement).
Pour ADCON2, on divise par 32 la frquence du microcontrleur, car sinon d'aprs nos test,
lorsque le pr-diviseur diminue et que l'on tourne le potentiomtre, les changements sont trop rapide.
Lorsquon augmente le pr diviseur et que l'on augmente le potentiomtre les changements sont trop lents.
Le pr-diviseur 32 est dans notre cas le juste milieu. On met donc la combinaison 010 sur les bits de poids
faible du registre. On a besoin de Tad (>0.7 us daprs le constructeur) pour convertir un bit, on aura donc
besoin de 8 Tad pour convertir 8 bits (on veut faire une conversion de 8 bits ) donc on aura la combinaison
100 sur les bits 4 6.Le bit numro 7 est 0 car indiqu dans la documentation et le dernier bit (le 8) est
0 car on justifie gauche, cest dire que le rsultat sur 8 bits sera contenu sur la partie haute de adres
(le registre contenant la conversion).
Les algorithmes relatifs au fonctionnement de ce potentiomtre se trouvent au paragraphe 3.2.5.

Page 13

Commande dun moteur pas pas avec un hacheur

3.2.

Les algorithmes

3.2.1. Attribution des ports (setup.h)

LED0
LED1
LED2

correspond
correspond
correspond

LATEbits.LATE0
LATEbits.LATE1
LATEbits.LATE2

T1
T2
T3
T4

correspond
correspond
correspond
correspond

LATBbits.LATB1
LATBbits.LATB2
LATBbits.LATB3
LATBbits.LATB4

RS
E
DATA

correspond
correspond
correspond

LATDbits.LATD0
LATDbits.LATD1
LATD

SCL
SDA
SDA_return
SDA_IO

correspond
correspond
correspond
correspond

LATCbits.LATC0
LATCbits.LATC1
PORTCbits.RC1
TRISCbits.TRISC1

Variables Globales
constante vitesse_moteur <- 40

3.2.2. Fichier main.c

Variables Globales
tableau de caracteres char_boussole[] <- {"-DIREC BOUSSOLE-"}
tableau de caracteres char_choix[] <- {"DIRECTION VOULUE"}
tableau de caracteres char_calibrage[] <- {"CALIBRAGE EN COURS"}
3.2.2.1.

INIT(ENTIER MODE)

Initialisation de tous les modules du programme.

Dbut
Initialiser les ports
Initialiser la boussole
Initialiser lcran
Initialiser le CAN
Initialiser le moteur pas pas
Si (mode)
Calibrer la boussole
Afficher char_calibrage sur lcran
Fin si
Afficher char_boussole sur lcran
Afficher char_choix sur lcran
Allumer la LED0
Fin

Page 14

Commande dun moteur pas pas avec un hacheur

3.2.2.2.

MAIN()

Fonction principale du programme.

Dbut
Initialisation de tout les composants avec init(0)
Tant que(1)
Obtenir langle de la boussole
Obtenir langle du potentiomtre
Orienter le moteur sur langle voulu du potentiomtre
Fin tant que
Fin

3.2.3. Fichier setup.c

3.2.3.1.

TEMP_MS(ENTIER DUREE)

Cette fonction a pour but de crer une temporisation variable de lordre du ms. Elle est utilise dans
toutes les parties du programme. Toutefois on ne peut pas dpasser 348 ms.
Variables
Entier buffer
Dbut
duree=0XFFFF-(188*duree)
buffer <- duree
Dcalage 8 fois droite de buffer
Configurer le registre T0CON //16 bits, pr diviseur 64
Mettre buffer dans le registre TMR0H
Mettre duree dans le registre TMR0L
Mettre 0 le flag du timer
Dmarrer le timer
Attendre dbordement
Stopper le timer
Fin
3.2.3.2.

TEMP_US(ENTIER DUREE)

Cette fonction a pour but de crer une temporisation variable de lordre du s. Elle est utilise dans
toutes les parties du programme. Toutefois on ne peut dpasser 50 s.
Dbut
duree=0xFF-5*duree
Configurer le registre T0CON // pr diviseur 64, 8bits
Mettre duree dans TMR0L
Initialiser 0 le flag du timer
Dmarrer le timer
Attendre le dbordement
Arrter le timer
Fin

Page 15

Commande dun moteur pas pas avec un hacheur

3.2.3.3.

INIT_PORT()

Cette fonction sert initialiser tous les ports du microcontrleur. Si ils sont en sorties, en entres, ainsi
que leurs valeurs initiales.
Dbut
Mettre le port D en sortie
Initialiser 0 le port D
Mettre le port B en sortie
Initialiser 0 le port B
Mettre RC0 en sortie
Mettre RC1 en sortie
Mettre le port E en sortie
Initialiser 0 le port E
Mettre RA0 en entre

// afficheur LCD en sortie

// hacheur en sortie
// SCL en sortie
// SDA en sortie
// LED en sortie
// potentiomtre en entre

Fin
3.2.3.4.

AFFICHER_DONNEES(ENTIER POSITION_CURSEUR, ENTIER ANGLE)

Cette fonction sert transformer un nombre dcimal de trois chiffres (angle) en caractres ascii dans
un tableau. Puis afficher ce nombre ascii sur lafficheur.
Variables
Tableau de caractre st[] <- {"
Entier buffer

deg NORD"}

Dbut
buffer <- angle/100;
st[0] <- buffer+'0';
angle <- angle - buffer*100
buffer <- angle/10
st[1] <- buffer+'0'

// exemple 320 : on rcupre le 3

// on le transforme en '3'
// on soustrait 300
// on rcupre le 2
// on le transforme en '2'

angle <- angle - buffer*10

st[2] <- angle+'0'
Afficher st sur lcran

// on soustrait 20 et on rcupre le 0
// on transforme en '0'

Fin

3.2.4. Fichier boussole.c

3.2.4.1.

TPO_I2C()

Cette fonction sert dfinir la frquence de fonctionnement de li2c. Ici on est rgler
Dbut
Mettre les bits du registre T2CON
Mettre le flag du registre PIR1 0
Mettre la valeur 250 dans le registre PR2
Mettre la valeur 0 dans le registre TMR2
Dmarrer le timer
Attendre dbordement
Arrter le timer
Fin

Page 16

//temporisation de 5us
//on compte de PR2 TMR2

Commande dun moteur pas pas avec un hacheur

3.2.4.2.

START()

Fonction ralisant la condition de start de li2c.

Debut
SDA <- 1
SCL <- 1
Attendre 5us
SDA <- 0
Attendre 5us
SCL<- 0
Attendre 5us
Fin
3.2.4.3.

STOP()

Fonction ralisant la condition de stop de li2c.

Debut:
SDA <- 0
SCL <- 0
Attendre 5us
SDA <- 1
Attendre 5us
SCL <- 1
Attendre 5us
Fin
3.2.4.4.

ENTIER SEND_I2C(ENTIER MOT)

Cette fonction sert envoyer un mot de 8 bits la boussole qui nous renvoie un ACK ou un NACK.
Variables
Entier i
Dbut
Pour i de 0 7
//on change la valeur de chaque bit
SDA <- bit de rang i
Attendre 5us
SCL <- 1
Attendre 5us
SCL <- 0
Fin pour
Configurer SDA en entre
Attendre 5us
SCL <- 1
// on gnre le 9me signal dhorloge
Lire et stocker SDA
Attendre 5us
SCL <- 0
Configurer SDA en sortie
Attendre 5us
Retourner la valeur stocke de SDA
Fin

Page 17

Commande dun moteur pas pas avec un hacheur

3.2.4.5.

ENTIER RECEPTION_I2C(ENTIER ACK)

Cette fonction sert rceptionner un mot de 8 bits venant de la boussole et de lui rpondre par un
ACK ou un NACK (suivant le paramtre dentre).
Variables
Entiers i, a=0x00
Dbut
Configurer SDA en entre
Pour i de 0 8
Attendre 5us
SCL <- 1
Attendre 5us
a = a|SDA_return;
Dcalage gauche de a
SCL <- 0;
Fin pour
Attendre 5us
Configurer SDA en sortie
Si ack = 1
SDA <- 0
Sinon
SDA <- 1
Fin si
SCL <- 1
Attendre 5us
SCL <- 0
SDA <- 0
Attendre 5us
Retourner a
Fin
3.2.4.6.

//on change la valeur de chaque bit

//gnration impulsion horloge

//on dcale a car on reoit du MSB vers le LSB

// test ACK envoy par le matre

// test NACK envoy par le maitre
//gnration 9eme impulsion horloge

CALIBRAGE()

Cette fonction sert lancer un talonnage de la boussole (ne sert pas chaque dmarrage cf init()).
Dbut
Envoyer la commande de calibrage
Attendre 30 s
Envoyer la commande de fin de calibrage
Attendre 15 ms
Fin
3.2.4.7.

INIT_BOUSSOLE()

Cette fonction initialise la boussole. On la rveille puis on lui dit de calculer langle une frquence
de 20Hz pour que lon rceptionne la valeur la plus rcente de langle lors de notre acquisition.
Dbut
Envoyer la commande de sortie du mode veille
Attendre 150 us
Envoyer la commande dcriture dans la RAM puis le mode de fonctionnement
Attendre 150 us
Envoyer la commande dcriture dans la RAM puis la faon dont la boussole doit nous
renvoyer la donne
Attendre 150 us
Fin

Page 18

Commande dun moteur pas pas avec un hacheur

3.2.4.8.

ENTIER RETOUR_ANGLE()

Cette fonction rceptionne les donnes de la boussole et renvoi langle par rapport au Nord en
degr.
Variables
entiers MSB, LSB, angle
Dbut
Rceptionner la partie haute (MSB) et la partie basse (LSB) de langle
Dcalage droite de 8 de MSB
angle <- (MSB|LSB)/20
Afficher langle sur lcran
Retourner angle
Fin

3.2.5. Fichier lcd_4bits.c

3.2.5.1.

LCD_CAR(ENTIER CARACTERE)

Cette fonction a pour but denvoyer un caractre de 8 bits sur lcran LCD rceptionnant sur 4 bits.
Variable
Entier buffer
Dbut
buffer <- caractere
buffer <<= 2
caractere >>= 2
Attendre 100 us
RS <- 1
E <- 0
DATA <- (caractere&0b00111100)|(DATA&0b00000011)
Attendre 5 us
E <- 1
Attendre 5 us
E <- 0
DATA <- (buffer&0b00111100)|(DATA&0b00000011)
Attendre 5 us
E <- 1
Attendre 5 us
E <- 0
Attendre 5 ms
Fin

// mode caractre
// envoi MSB de DATA
// dmarre l'envoi
// arrte l'envoi
// envoi LSB de DATA

Page 19

Commande dun moteur pas pas avec un hacheur

3.2.5.2.

LCD_COM(ENTIER COMMANDE)

Cette fonction a pour but denvoyer une commande de 8 bits sur lcran LCD rceptionnant sur 4 bits.
Variables
Entier buffer
Dbut
buffer <- commande
buffer <<= 2
commande >>= 2
Attendre 100 us
RS <- 0
E <- 0
DATA <- (commande&0b00111100)|(DATA&0b00000011)
Attendre 5 us
E <- 1
Attendre 5 us
E <- 0
DATA <- (buffer&0b00111100)|(DATA&0b00000011)
Attendre 5 us
E <- 1
Attendre 5 us
E <- 0
Attendre 5 ms
Fin
3.2.5.3.

// mode commande
// envoi MSB de DATA
// dmarre l'envoi
// arrte l'envoi
// envoi LSB de DATA

LCD_COM_INIT(ENTIER COMMANDE)

Cette fonction a pour but denvoyer une commande de 4 bits sur lcran LCD rceptionnant sur 4 bits.
Dbut
commande >>= 2
RS <- 0
E <- 0
DATA <- (commande&0b00111100) | (DATA&0b00000011)
Attendre 5 us
E <- 1;
Attendre 5 us
E <- 0

// mode commande

// dmarre lenvoi
// arrte l'envoi

Fin
3.2.5.4.

INIT_LCD()

Cette fonction sert initialiser lafficheur. Par exemple le choix du mode de fonctionnement en 4 bits
et non 8 bits, afficher le curseur, incrmenter ou dcrmenter le registre aprs lcriture dun caractre, La
mthode est dcrite sur la documentation du constructeur.
Dbut
Attendre 30 ms
lcd_com_init(0x30)
Attendre 5 ms
lcd_com_init(0x30)
Attendre 100 us
lcd_com_init(0x30)
lcd_com_init(0x20)
lcd_com(0x28)
lcd_com(0x0C)
lcd_com(0x06)
lcd_com(0x01)
Attendre 5 ms
Fin
Page 20

// 0x38 pour dire qu'on envoi sur 4bits

// 0x0C pour dire qu'on teint l'cran et qu'on affiche pas le curseur
// pour dcaler le curseur d'un cran vers la droite
// pour effacer l'cran

Commande dun moteur pas pas avec un hacheur

3.2.5.5.

LCD_STR(TABLEAU DE CARACTERE STR)

Fonction qui crit une chane de caractre.

Variables
Entier i <- 0
Dbut
Tant que str[i] != '\0'
lcd_car(str[i])
i++
Fin tant que
Fin

// tant quon nest pas la fin de la chaine

3.2.6. Fichier can.c

3.2.6.1.
INIT_CAN()
Cette fonction sert initialiser le convertisseur analogique numrique.

Dbut
ADCON0 <- 0b00000001
ADCON1 <- 0b00001110
ADCON2 <- 0b00100010
Fin
3.2.6.2.
ENTIER CONVERTIR()
Cette fonction sert covertir les valeur en sortie du potentiometre qui sont analogique en valeurs
numrique de 0 255.

Dbut
attente 5s
lancement conversion
attente fin de conversion
retourne ADRESH
Fin
3.2.6.3.
ENTIER CONVERTIR_VALEUR_CAN_VERS_ANGLE()
Cette fonction sert convertir la valeur de la conversion analogique numrique en degr.

Variables
Entier angle, valeur_can
Dbut
valeur_can <- convertir()
angle <- valeur_can
angle <- angle * 360 / 255
afficher_donnees(0xD2,angle)
retourne angle
Fin

Page 21

Commande dun moteur pas pas avec un hacheur

3.2.7. Fichier commande_hacheur.c

Variables Globales
Entier static etat <- 0
3.2.7.1.

INIT_MOTEUR()

Cette fonction sert initialiser les bobines du moteur pour que lon puisse dmarrer dans des
conditions optimales. Avec celle-ci, on est sr que le prochain transistor activer est le 1 (tat 0).
Dbut
T4 <- 1
Attendre 40 ms
T4 <- 0
Attendre 40 ms
T2 <- 1
Attendre 40 ms
T2 <- 0
Attendre 40 ms
T3 <- 1
Attendre 40 ms
T3 <- 0
Attendre 40 ms
T1 <- 1
Attendre 40 ms
T1 <- 0
Attendre 40 ms
Fin
3.2.7.2.

SENS_HORAIRE(ENTIER PAS)

Cette fonction sert faire tourner le moteur dans le sens horaire.

Variable
Entier i
Dbut
LED1 <- 1;
Pour i de 1 pas
Selon (etat)
cas 0 :

cas 1 :

cas 2 :

cas 3 :

Page 22

T4 <- 1
Attendre 40 ms
T4 <- 0
Attendre 40 ms
etat <- 1
T2 <- 1
Attendre 40 ms
T2 <- 0
Attendre 40 ms
etat <- 2
T3 <- 1
Attendre 40 ms
T3 <- 0
Attendre 40 ms
etat <- 3
T1 <- 1
Attendre 40 ms
T1 <- 0
Attendre 40 ms
etat <- 0

Commande dun moteur pas pas avec un hacheur

Fin selon
Fin pour
LED1 <- 0
Fin
3.2.7.3.

SENS_ANTI_HORAIRE(ENTIER PAS)

Cette fonction sert faire tourner le moteur dans le sens antihoraire.

Variable
Entier i
Dbut
LED2 <- 1
Pour i de 1 pas
Selon (etat)
cas 0 :

cas 1 :

cas 2 :

cas 3 :

T3 <- 1
Attendre 40 ms
T3 <- 0
Attendre 40 ms
etat <- 1
T2 <- 1
Attendre 40 ms
T2 <- 0
Attendre 40 ms
etat <- 2
T4 <- 1
Attendre 40 ms
T4 <- 0
Attendre 40 ms
etat <- 3
T1 <- 1
Attendre 40 ms
T1 <- 0
Attendre 40 ms
etat <- 0

Fin selon
Fin pour
LED2 <- 0
Fin
3.2.7.4.

TOURNER_VERS_NORD(ENTIER DEGRE)

Cette fonction sert diriger laxe du moteur vers le Nord.

Variables
Entier pas
Dbut
Si degre > 180
pas <- (360 - degre) * 200 / 360
Si pas > 2
Tourner dans le sens horaire de pas
Fin si
Sinon
pas <- (degre * 200) / 360
Si pas > 2
Tourner dans le sens antihoraire de pas
Fin si
Fin si
Fin
Page 23

Commande dun moteur pas pas avec un hacheur

3.2.7.5.

TOURNER_AVEC_POT(ENTIER DEGRE_BOUS, ENTIER DEGRE_POT)

Cette fonction sert diriger laxe du moteur vers la valeur que nous retourne le potentiomtre (entre
0 et 360).
Variables
Entier pas
Dbut
Si degre_bous < degre_pot
pas <- (degre_pot - degre_bous) * 200 / 360
Si pas > 2
Tourner dans le sens horaire de pas
Fin si
Sinon
pas <- (degre_bous - degre_pot) * 200 / 360
Si pas > 2
Tourner dans le sens antihoraire de pas
Fin si
Fin si
Fin

Page 24

Commande dun moteur pas pas avec un hacheur

4. TESTS
4.1.

Test hacheur

Nos premiers tests ont port sur les transistors Kn, pour ce faire nous avons remplac la bobine
par un ampremtre afin de relever la valeur et le sens du courant. On a donc command les transistors
K1 et K4 on a observ un courant de 0.8 A de plus lorsquon a command les transistors K2 et K3 on a
observ un courant de -0.8 A ce qui correspondait bien la valeur souhaite dans les calculs thorique. La
commande des transistors a ncessit l'utilisation d'une alimentation en source de courant que nous avons
rgl la valeur de 0.1 A. Lors de notre premier test, nous avions oubli de prendre en compte le fait
qu'une rsistance de quart de watt ntait pas suffisante au niveau de la rsistance Rlimite, on a donc eu une
surchauffe de cette rsistance.
Ensuite ayant constat que l'optocoupleur ne dlivrait pas assez de courant pour saturer le
transistor Kn, nous avons d ajouter un tage d'amplification, pour cela nous avons ajout le transistor Ta
qui a t command en simulant le courant de l'optocoupleur l'aide de l'alimentation. En faisant cet essai
nous avons eu les mmes rsultats que prcdemment.
Une fois ces essais effectus, nous avons ajout l'optocoupleur puis fait un nouvel essai avec les
sorties du microcontrleur.
Grce a cet essai on a remarqu que certains optocoupleurs prsents dans le boitier en contenant
quatre ne fonctionnaient pas, on a donc rsolu ce problme en les remplaants. Au pralable nous avons
mesur la tension Vcc et le courant maximal dlivr par le microcontrleur, nous avons mesur Vcc=5V et un
courant environ gale 36 mA en accord avec nos calculs thorique. Par la suite notre hacheur tait
oprationnel.
Pour finaliser l'tude du fonctionnement du hacheur, on a branch chaque bobine du moteur
leurs hacheurs respectifs. On a observ le moteur effectuait des pas ( l'aide d'un programme dvelopp
dans la partie programmation). Puis pour vrifier que les diodes effectuaient bien leur rle (dissipation de
l'nergie emmagasine dans la bobine) on a utilis un oscilloscope afin de s'assurer que le potentiel a la
sortie de la bobine tait inferieur au potentiel situ a la cathode de la diode suppos conductrice, cette
vrification s'est avr correcte.

4.2.

Test programmation

4.2.1. I2C et boussole

De manire gnrale, nous avons eu un gros souci de comprhension de la documentation de la
boussole. Au-del du fait que cette dernire est en anglais, elle est trs mal expliqu et galement mal
prsente. De ce fait, nous avons perdu beaucoup de temps sur la comprhension de cette documentation,
les problmes ci-dessous sont notamment dus la documentation mais pas uniquement.
Nous avons cherch comprendre ce que renvoyait la boussole mais aussi si nous pouvions lui
envoyer des commandes. Lors des premiers tests, cette dernire ne ragissait pas. On a voulu voir si les
acknowledge taient bien mis 1 (voir algorithme send_i2c). Nous avons alors constats que ce n'tait pas
le cas. Nous avons tudi de nouveau la documentation et c'est ce moment que l'on a vu un mode appel
exit sleep mode (commande 'W'). Nous avons alors test le rveil de la boussole, les acknowledges
sont ce moment passs 1 (pour le rveil dans un premier temps). Ce problme a t long debugger.

Page 25

Commande dun moteur pas pas avec un hacheur

A partir de l, nous avons alors dcid d'envoyer de nouvelles commandes pour tester le bon
fonctionnement de la boussole (crire dans la RAM, lire la RAM). L encore, on pouvait voir des
acknowledge 0 toutefois le rveil avait son acknowledge 1. Nous avons cherch longtemps ou tait le
problme. On a alors dcid d'observer les signaux l'oscilloscope sur conseil de nos professeurs. On a
alors observ le signal suivant pour SCL :

On a alors cherch supprimer les petits crneaux, nos tests nous ont mens diminuer la
frquence de l'horloge d'envoi de donnes (SCL). Ainsi nous avons pu supprimer les petits crneaux qui ne
devaient pas tre l. Ici encore, ce dbogage a t long.
Les deux problmes prcdents rsolus, toutes les conditions ncessaires afin d'envoyer des
commandes taient runis, du moins nous le pensions. Nous avions crit le programme send_i2c afin de
rceptionner des donnes. Ce programme ne renvoyait pas ce qu'il tait cens renvoyer. Nous nous y
sommes intresss de plus prs, cest l que nous avons vu sur le programme mme que SDA et SCL
ntaient pas remis 0 au bon moment (dans notre programme nous le faisions pas du tout). Le rsultat
tait donc logique. Seulement, il n'y avait pas qu'un unique problme, en effet aprs avoir relu la
documentation, nous avons pu constater que l'envoi d'un acknowledge(ACK) n'tait pas suffisant, il fallait
aussi envoyer un NACK (non acknowledge). Ici encore le rsultat ne pouvait tre correct. Aprs ces deux
corrections, le programme rception ralisait la fonction voulut.
Ensuite, nous pouvions priori raliser tous les envois de commande que nous voulions. Nous avons
ralis plusieurs essais, en observant chaque envoi les acknowledge. L nous avons constat que ces
acknowledges taient pour certains 1 d'autres 0. Nous tions surpris de voir cela car en thorie les
programmes fonctionnaient tous. L encore, une tude de la documentation a t ncessaire, et nous
n'avions pas remarqu le tableau suivant, et surtout la colonne delays .

Page 26

Commande dun moteur pas pas avec un hacheur

Comme on peut le voir des temporisations dure prcise (que nous avons considrs comme
minimale en raison des ventuelles imprcisions des temporisations). Nous avions au dpart mis des
temporisations de la dure gale la temporisation utilis dans le programme I2C, en prcautions nous en
avions mis plusieurs, cependant ce n'tait pas suffisant. Nous avons donc corrig cette erreur en rajoutant
des temporisations qui respectaient au moins les dlais voulus. Si cette temporisation tait trop longue, cela
ne posait en aucun cas de problme, il y aurait juste eu un dlai de rponse entre chaque instruction.

Une fois la rception des donnes de la boussole et l'envoi de commande rgl, nous pouvions
enfin tester les donnes que renvoyait la boussole. Nous avions trouv un registre dans la documentation
renvoyant les coordonnes X et Y par rapport au nord. Nous pensions tort que nous devions consulter ce
registre selon un ordre prcis et rcuprer au fur et mesure les donnes X et Y par rapport au nord.
Nous nous sommes alors lancs dans l'criture de programme rendant un angle en fonction des
coordonnes. Cependant la consultation de ces coordonnes ncessitait un accs au registre de la RAM.
Nous cherchions par tous les moyens rcuprer les coordonnes X et Y, que nous avons russi en
consultant la documentation :

Nous avons alors remarqu un mode supplmentaire : heading mode . Nous ne russissions pas
comprendre quoi correspondait ce mode, on a alors test ce mode en envoyant la commande en
question (0x00). A ce moment on a remarque que l'on recevait l'angle lui-mme. Notre programme de
conversion n'tait donc pas ncessaire, et la documentation n'avait pas prcis que l'angle pouvait tre
directement rcuprer (du moins nous ne l'avions pas compris).
Pour finir, nous prcisons que les valeurs d'angles ne sont pas exactes en raison des perturbations
magntiques que peuvent crer divers appareils lectronique autour mais aussi cause du fait que la
boussole est dsaxe.

4.2.2.

Ecran

Tout d'abord, le fonctionnement de l'cran a t long mettre en uvre car nous n'avions
pas reli la broche V5 de l'cran la masse. L'cran ne pouvait donc pas fonctionner. Ce bug a t rsolu
avec l'aide de nos collgues, ces derniers ont eu le mme problme.
Lors de l'insertion du CAN notre solution, nous avons d changer les ports de l'cran car
ce dernier se trouvait sur l'une des broches ncessaires au fonctionnement du CAN. Nous avons alors mis
l'cran sur le port C par accident (les broches du port C et D tant mlangs sur la carte), ce port tant
utiliss par l'USB, nous ne pouvions plus connecter notre PIC notre ordinateur. Nous avons l'aide de l'un
de nos professeurs remarqu cette erreur et remplac les broches utilises par le port C par uniquement
des broches du port D pour l'cran. Lcran tait aprs oprationnel.

Page 27

Commande dun moteur pas pas avec un hacheur

4.2.3. Clavier
Le principal problme constat rsidait dans la frquence, en augmentant le pr-diviseur et
en tournant le potentiomtre, les variations taient lentes arriver et l'inverse lorsque l'on diminue le
pr diviseur et qu'on augmente le potentiomtre, les variations sont plus rapides arriver .Nous avons
donc choisit le juste milieu et pris le pr-diviseur 32.

De manire gnrale, nous avions un problme avec nos temporisations variables, nous avions
envoy la partie basse avant la haute, ce qui tait une erreur. En envoyant la partie basse avant la haute,
lenvoi de la partie haute crasait la partie basse. Nous avons donc invers ces envois, la temporisation
fonctionnait ensuite comme voulu. Nous n'avions pas fait attention cela mais cette donne tait une
donne constructeur.

Page 28

Commande dun moteur pas pas avec un hacheur

CONCLUSION
Pour conclure, nous proposons une solution rpondant au cahier des charges, les petites
diffrences prsentes sont dues la boussole elle-mme qui peut tre perturbe par des appareils
lectroniques. En l'absence de clavier, ce point du cahier des charges n'est pas rempli et a donc t
remplac par un CAN et un potentiomtre.
Cependant, nous aurions pu avec plus d'heures de TP de synthse, amliorer nos programmes en
ajoutant notamment des interruptions ou simplement en les optimisant. De plus, pour pleinement remplir le
cahier des charges, avec plus de temps nous aurions pu commander un clavier et l'implanter dans notre
systme. Nous aurions pu galement crer une carte qui aurait comport les diffrents lments du
hacheur, ceci aurait fait suite au routage fait sur Proteus. Enfin, nous aurions pu nous passer des transistors
d'amplification en passant une commande de transistor ncessitant un courant dans la base plus petite.

Page 29