télécharger le projet.

PARIS Mathieu
BISMUTH Eytan
Groupe G2
Le 6 février 2006
Tuteur : M. Fiol
1
Introduction au projet tuteuré
A partir du mois d’octobre, il nous a été demandé de réaliser un projet nommé
projet tuteuré. Le principe de ce projet est de laisser, durant trois mois, travailler
les étudiants, en 2eme année, par binôme sur un sujet proposé par eux-mêmes ou
par leur tuteur de projet.
Le but est de placer les étudiants en situation d’autonomie, sur un projet à
réaliser en dehors des heures de cours, et bien entendu en dehors de l’IUT et de
sa logistique. Pour leur faire acquérir des méthodes de travail qui leur serviront
dans le monde du travail.
Bien entendu, les étudiants ne sont pas lâchés dans la nature pour autant puis
qu’un tuteur de projet leur est octroyé parmi les enseignants disponibles. Le rôle
de celui-ci est d’aiguiller la réalisation du projet et de conseiller les étudiants si
besoin est. Mais surtout, son rôle est de noter le projet une fois celui-ci terminé.
N’ayant eu qu’une vague idée de projet, Mr.Fiol, notre tuteur nous a proposé la
réalisation d’un système de motorisation de monture équatoriale assisté par
microprocesseur.
Ce rapport fait état de l’avancement de notre projet jusqu’à son terme.
2
SOMMAIRE
I)
Cahier des charges………………………….P4
II)
La monture équatoriale……………………..P8
III)
L’affichage LCD……………………………P9
IV)
Le GD-200S…………………………….…P15
V)
Schéma électrique…………………………P19
VI)
Boite.………………………………………P25
VII) Programmation d’un système…………..…P26
VIII) Conclusions…………………………..........P36
IX)
Annexe : listing du programme.…………...P39
3
Cahier des charges
I) Présentation du projet
Ce projet tuteuré rendra compte de l’étude d’un système de commande de
motorisation de l’ascension droite d’une monture équatoriale de télescope
appliqué à l’observation astronomique.
Pour ce faire, le pilotage sera réalisé par un système autonome et facilement
transportable La programmation de la partie commande se fera grâce à
l’utilisation d’un microprocesseur. Celui-ci devra piloter le moteur du système,
au travers d’une interface puissance, et permettre à l’utilisateur de pouvoir
modifier les paramètres du système presque en temps réel, si ce n’est le cas.
II) Architecture fonctionnelle
Partie
Commande
Clavier pour
accéder au
paramétrage
et pour
piloter les
manœuvres
du télescope
Partie
Puissance
Syst. A µC
16F876
Interface
puissance
Pour moteur
pas à pas
bipolaire
Mot pas à pas
Bipolaire
Visualisation des
paramètres du système
Batt. 12V
4
III) Les fonctions
Après une mise en station manuelle du télescope par l’utilisateur, le logiciel de
commande offrira plusieurs possibilités :
- Pilotage automatique : Une compensation du
mouvement de rotation de la terre grâce à un
pilotage automatique de la partie puissance.
- Pilotage manuel : Un réglage manuel des axes du
télescope géré par l’utilisateur.
- Paramètres : réglages de paramètres relatifs aux
caractéristiques moteurs et aux vitesses de
pilotages.
IV) Contraintes
Ce système doit pouvoir être adaptable à la plupart des montures équatoriales
disponibles sur le marché.
Comme le système doit être facilement transportable et utilisable en plein air,
donc loin des réseaux de distribution électrique, l’alimentation du montage
devra être entièrement réalisée et desservie par une batterie de 12V.
V) Choix du matériel et résolution des problèmes
Nous avions plusieurs possibilités pour le choix des matériels.
a) Microprocesseur : Pour le microprocesseur une large gamme d’appareils
s’offrait à nous. Néanmoins, pour rester sur quelque chose que nous
connaissions, nous avons donc décidé de nous tourner vers la technologie
Microchip avec le PIC 16F876 que nous avions déjà abordé en travaux de
réalisation pour plusieurs raisons évidentes.
- La première, et la plus importante, est que le logiciel de
programmation de Microchip est gratuit. Nous n’aurions donc
pas besoin de tomber dans l’illégalité pour programmer notre PIC.
5
- Ensuite, ce PIC utilise un langage RISC. Autrement dit, le nombre
de mnémoniques disponibles est réduit à 35, ce qui facilite
l’écriture
- Nous avions choisi précisément ce PIC pour son nombre de ports
disponibles. Comme nous devions commander un moteur, un
afficheur et utiliser un clavier, nous avons préféré voir large sur le
nombre d’entrées/sorties disponible.
b) Afficheur : Le choix du composant s’imposait, ici, quasiment de luimême. A la question Quel écran devons nous prendre pour l’utiliser avec
un microprocesseur ? La réponse est bien entendu un afficheur à cristaux
liquides.
L’afficheur permettrait à l’utilisateur de rentrer dans quelques menus de
configurations de paramètres systèmes. Dans cette optique, il nous
faudrait donc écrire successivement un nom de paramètre et sa variable.
Ce qui revenait à écrire une trentaine de caractères par paramètre sur
l’afficheur.
Nous avons alors opté pour un afficheur deux lignes et 40 caractères (16
sur la première ligne, 24 sur la 2eme).
c) Interface puissance du moteur : Il nous a été directement imparti de
réaliser cette interface avec un GS-D200S, matériel conçu exclusivement
pour piloter un moteur pas à pas bipolaire à partir d’un microprocesseur.
Nous n’avons donc pas cherché plus loin de ce côté si pour voir si l’on
pouvait trouvé un meilleur module.
d) Moteur : Là aussi nos recherches ont été simplifiées. Comme le GSD200S sert exclusivement au pilotage de moteurs pas à pas bipolaires. Le
choix du moteur nous sautait aux yeux. Ce qui nous a conduit par la suite
à choisir un moteur pas à pas bipolaire 200 pas par tour, même si nous
voulions que tout type de moteur soit adaptable au système (entendre par
là que l’on pourrait changer ce moteur par un moteur X pas par tour).
6
e) Le clavier : Comme pour l’afficheur nous n’avions pas une infinité de
solutions. Il nous fallait un système de clavier simple que l’on pourrait
très facilement lier au microprocesseur. C’est pour cela que nous avons
choisi d’utiliser des boutons poussoirs. Il ne nous fallait pas de boutons
superflus, un bouton prenant une entrée, il ne fallait pas que l’on s’amuse
à en mettre une dizaine.
Nous avions deux objectifs. Avoir le moins de boutons possibles mais
aussi qu’un bouton ne serve pas à remplir plusieurs fonctions.
En mettre 4 semblait un bon compromis. Un bouton pour accéder au menu
de l’afficheur, un bouton pour faire défiler les sous-menus et deux
boutons + et – pour modifier les paramètres ou la position du télescope en
mode manuel.
7
La monture équatoriale : présentation
Qu’est ce qu’une monture équatoriale ?
C'est une monture (ou partie mécanique de l'instrument) qui permet de
compenser la rotation de la Terre manuellement ou automatiquement. Sans
monture équatoriale, l'image sort du champ de vision et il faut alors repointer
l'objet visé.
Principe de la monture équatoriale
Un télescope équipé de ce type de monture possède deux axes. Le premier,
appelé axe polaire ou horaire ou encore axe d’ascension droite est parallèle à
l’axe de rotation de la Terre ; le second, appelé axe de déclinaison, est
perpendiculaire au premier. Si l’on donne à l’axe horaire une vitesse égale à la
vitesse de la Terre mais en sens opposé, il y a compensation des deux vitesses et
un objet céleste observé reste fixe dans le champ de l'oculaire. Pour une monture
automatisée, une seule motorisation est donc nécessaire (mais une deuxième
peut être souhaitable). La monture suppose un réglage de latitude correspondant
à celle du lieu d’observation.
8
L’afficheur LCD
I)
Introduction
Les afficheurs LCD (Liquid Crystal Display) à logique intégrée sont un moyen
pratique et efficace pour afficher des informations par microprocesseur.
Plusieurs afficheurs sont disponibles sur le marché et diffèrent les uns des
autres, non seulement par leurs dimensions, (de 1 à 4 lignes de 6 à 80
caractères), mais aussi par leurs caractéristiques techniques et leur tension de
service. Certains sont dotés d'un rétro éclairage de l'affichage. Cette fonction fait
appel à des LED montées derrière l'écran du module, cependant, cet éclairage est
gourmand en intensité (de 80 à 250 mA).
Il existe deux modèles d'interfaces normalisées : Une version "parallèle" et une
version série. Les versions séries utilisent bien sur moins d'E/S, mais elles
monopolisent une liaison série.
Nous ne parlerons ici que des versions parallèles.
II)
La connexion
L'interface avec la version parallèle comporte 16 ports.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
1 masse
2 +5V
3 références pour le contraste
4 RS
5 R/W
6E
7 Data 0 (D0)
8 Data 1 (D1)
9 Data 2 (D2)
10 Data 3 (D3)
11 Data 4 (D4)
12 Data 5 (D5)
13 Data 6 (D6)
14 Data 7 (D7)
15 LED A
16 LED K
9
Broche Nom Niveau
1
Vss
Masse
Fonction
2
Vdd
-
3
Vo
0-5V
RS
Sélection du registre (Register Select)
Grâce à cette broche, l’afficheur est capable de faire la différence entre
TTL
une commande et une donnée. Un niveau bas indique une commande
et un niveau haut indique une donnée.
4
Alimentation positive +5V
Cette tension permet, en la faisant varier entre 0 et +5V, le réglage du
contraste de l’afficheur.
Lecture ou écriture (Read/Write)
TTL L : Écriture
H : Lecture
5
R/W
6
E
TTL
7
D0
TTL
8
9
D1
TTL
D2
TTL
10
D3
TTL
11
D4
TTL
12
D5
TTL
13
D6
TTL
14
D7
TTL
15
A
-
Anode rétro éclairage (+5V)
16
K
-
Cathode rétro éclairage (masse)
Entrée de validation (Enable) active sur front descendant. Le niveau
haut doit être maintenue pendant au moins 450 ns à l'état haut.
Bus de données bidirectionnel 3 états (haute impédance lorsque E=0)
Pour utiliser le LCD, il faut l'alimenter en +5V.
Ensuite il faut relier les entrées de contrôles RS, R/W et E au microcontrôleur
ainsi que les bits D0 à D7.
Cependant, on peut choisir pour un gain d’entrées/sorties sur le microprocesseur
de ne relier que les 4 bits de poids forts (à savoir D4 D5 D6 D7). Ce mode est
appelé le mode 4 bits tandis que celui où tout les bits sont reliés est appelé le
mode 8 bits.
10
III) La mémoire
L’afficheur possède deux types de mémoire, la DD RAM et la CG RAM. La DD
RAM est la mémoire d'affichage et la CG RAM est la mémoire du générateur de
caractères.
La mémoire d'affichage (DD RAM)
La DD RAM est la mémoire qui stocke les caractères actuellement affichés à
l'écran. Pour un afficheur de 2 lignes de 16 caractères, les adresses sont définies
de la façon suivante :
Ligne
Visible
Invisible
Haut 00H..........0FH 40H..........4FH
Bas
10H..........27H 50H..........67H
L'adresse 00H correspond à la ligne du haut à gauche, 0FH à droite. L'adresse
40H correspond à la ligne du haut à gauche, 4FH à droite. La zone invisible
correspond à la mémoire de l'afficheur (48 caractères).
La mémoire du générateur de caractères (CG RAM)
Le générateur de caractère est quelque chose de très utile. Il permet la création
d'un maximum de 8 caractères ou symboles 5x7. Une fois programmés les
nouveau caractères peuvent être accédés comme s'ils était dans le jeu de
caractères classique, stocké en ROM.
Cependant comme nous ne l’utiliserons pas pour notre projet, nous ne
détaillerons pas plus cette partie.
IV) Mode 8 bits / mode 4 bits et commandes standard
Mode 8 bits:
Dans ce mode 8 bits, les données sont envoyées à l’afficheur sur les broches D0
à D7. On place la ligne RS à 0 ou à 1 selon que l'on désire transmettre une
commande ou une donnée. Il faut aussi placer la ligne R/W à 0 pour indiquer à
l’afficheur que l'on désire effectuer une écriture. Il reste à envoyer une
impulsion d'au moins 450 ns sur l'entrée E, pour indiquer que des données
11
valides sont présentes sur les broches D0 à D7. L’afficheur lira la donnée sur le
front descendant de cette entrée.
Si on désire au contraire effectuer une lecture, la procédure est identique, mais
on place cette fois la ligne R/W à 1 pour demander une lecture. Les données
seront valide sur les lignes D0 à D7 lors de l'état haut de la ligne E.
Mode 4 bits:
Il peut, dans certains cas, être nécessaire de diminuer le nombre de fils utilisés
pour commander l’afficheur, comme, par exemple lorsqu'on dispose de très peu
de broches d'entrées sorties disponibles sur un microcontrôleur. Dans ce cas, on
peut utiliser le mode quatre bits de l’afficheur LCD. Dans ce mode, seuls les 4
bits de poids fort (D4 à D7) de l’afficheur sont utilisées pour transmettre les
données et les lire. Les 4 bits de poids faible (D0 à D3) sont alors connectés à la
masse. On a donc besoin, hors alimentation de sept fils pour commander
l’afficheur. Les données sont alors écrites ou lues en envoyant séquentiellement
les quatre bits de poids fort suivi des quatre bits de poids faible. Une impulsion
positive d'au moins 450 ns doit être envoyée sur la ligne E pour valider chaque
demi-octet ou nibble.
Il se peut qu'on dispose encore de moins de broches disponibles dans
l'application envisagée. Dans ce cas, on peut alors relier la ligne R/W à la masse
de façon à forcer l’afficheur en écriture. On a alors besoin, hors alimentation de
seulement six fils en mode 4 bits, et dix fils en mode 8 bits, pour commander
l’afficheur, mais on ne peut alors plus relire l’afficheur. Ceci n'est pas gênant
dans la mesure où on sait ce qu'on a écrit sur l’afficheur, mais on ne peut alors
plus relire le flag Busy. Il faut alors utiliser des temporisations après chaque
écriture sur l’afficheur. On perd alors un peu en temps d'affichage, mais on
gagne une broche d'entrée sortie.
Dans les deux modes, on peut, après chaque action sur l’afficheur, vérifier que
celui-ci est en mesure de traiter l'information suivante. Pour cela, il faut
demander une lecture en mode commande, et tester le flag Busy BF. Lorsque
BF=0, l’afficheur est près à recevoir une nouvelle commande ou donnée.
12
Jeu de commandes :
Instructions
Code
RS R/W D7 D6 D5 D4 D3 D2 D1 D0
Clear Display 0
Return home
Entry mode
set
0
0
Display
0
on/off control
Cursor and
display shift
Function set
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Description
Durée
0
Efface l'ensemble de la
mémoire de donnée sans
toucher au générateur de
1
caractères. Ramène le
curseur en position
« home », à l'adresse 00.
1,64
ms
1
Ramène le curseur en
position « home », à
l'adresse 00. Si l'affichage
X était décalé, il est remis à
sa position d'origine :
l'adresse 00 se trouve à
nouveau en haut à gauche.
1,64
ms
0
0
0
Définit le sens de
déplacement du curseur
après l'apparition d'un
caractère (vers la gauche si
1 I/D S I/D=1, vers la droite si
40 µs
I/D=0) et si l'affichage
accompagne le curseur
dans son déplacement ou
non (S).
1
0
0
0
Deplace le curseur (S/C=1)
ou l'affichage (S/C=0)
d'une position vers la
1 S/C R/L X X
40 µs
gauche (R/L=1) ou la
droite (R/L=0) sans
changer la DD RAM.
1 DL N
D
Met l'affichage en ou hors
fonction l'affichage (D), le
C B curseur (C), le
clignotement du curseur
(B).
F
40 µs
Définit la taille de
l'interface (DL=0 pour
mode 4 bits, DL=1 pour
mode 8 bits), le nombre de
lignes (NL=0 pour 1 ligne,
X X
40 µs
N=1 pour 2 ou 4 lignes), et
la taille des fontes (F=0
pour des caractères 5x7,
F=1 pour des caractères
5x10).
13
Set CG RAM
0
address
Set DD RAM
0
address
0
0
Définit l'adresse de la CG
RAM. Les données de la
1 A5 A4 A3 A2 A1 A0
CG RAM sont envoyées
après cette commande.
40 µs
0
Définit l'adresse de la DD
RAM. Les données de la
1 A6 A5 A4 A3 A2 A1 A0
DD RAM sont envoyées
après cette commande.
40 µs
Read busy
flag &
address
0
1
Lit le flag busy (BF), et
l'adresse de la position du
BF A6 A5 A4 A3 A2 A1 A0 curseur. BF vaut 0 si
1 µs
l’afficheur accepte une
instruction, 1 s'il est occupé
Write data to
CG or DD
RAM
1
0
D7 D6 D5 D4 D3 D2 D1 D0
Ecrit des données dans la
DD RAM ou la CG RAM.
40 µs
Read data
1
1
D7 D6 D5 D4 D3 D2 D1 D0
Lit les données de la DD
RAM ou de la CG RAM.
40 µs
V)
Jeu de caractères ASCII
14
Le GD-200S
I) Présentation :
Le GS-D200S est un module qui se relie directement au microprocesseur pour
faciliter le pilotage des moteurs pas à pas bipolaires tout en réalisant l’interface
puissance. Pour ce faire, en le cadençant par le microprocesseur, il génère luimême la séquence de conduction des phases pour permettre le déplacement des
pas du moteur. Ce qui simplifie grandement l’élaboration d’un programme de
contrôle de moteur.
II) Diagramme de connexion :
Voici comment se présente schématiquement le module
15
GND1 : masse
Sync : synchronisation du gs-200s en externe
/RESET : initialisation du module, et met les phases à leur état initial (ABCD =
0101)
Half/full : Si 1 ou déconnecté, le mode demi pas est choisi
Home : indique si les phases sont à leur état initial
/Step clk : Le moteur se déplace d’un pas sur un front montant de cette entrée
Cw/ccw : Si 1 ou déconnecté, le moteur tourne dans le sens horaire
Osc : sert à modifier l’horloge de l’oscillateur interne du module
Ioset : valeur de référence de l’intensité dans les phases
Control : propagation rapide ou lente
Enable : Après l’initialisation du module, doit être à 1
Vss : +5v
VS : 45v max
GND2 : masse
ABCD : phases
Voici comment se présente le module une fois relié au microprocesseur :
Certaines entrées peuvent être laissées déconnectés selon l’utilisation, comme
half/full home ou encore control, ce qui permet une économie d’entrées/sorties
sur le microprocesseur.
16
III) Modes de pilotages :
Le GS-D200S offre trois possibilités de pilotage de moteur :
- Le mode « onde » qui ne fait fonctionner qu’une seule phase en même temps.
Voici la séquence des phases : AB-CD-BA-DC
- Le mode deux phases simultanées
La séquence des phases est alors la suivante : AB&CD – CD&BA – BA&DC –
DC&AB
- Pour finir le mode demi pas, où comme son nom l’indique les déplacements
sont divisés par deux.
17
La séquence est : AB – AB&CD – CD – CD&BA – BA – BA&DC – DC –
DC&AB
Nous avons décidé d’utiliser ce mode de pilotage pour notre projet pour 3
raisons.
La première est qu’ainsi, l’entrée half/full est déconnectée, ce qui libère
un bit d’un des ports du PIC.
Deuxièmement, les déplacements sont plus nombreux et plus précis.
Le temps d’attente entre chaque déplacement est plus court.
18
Schéma électrique
I) Carte mère :
J6
IN
+5V
OUT
COM
+12V
1
2
C10
C9
CON2
1uF
1uF
100
IN
C2
R11
OUT
COM
IN
100
C5
C8
C3
100n
0
C12
C11
10u
100n
100n
0
OUT
COM
R12
1uF
1uF
0
0
CRY STAL Q3
0
0
R9
R10
U9
LM317L
3
D1
2
1
2
1
C1
1N4001
5V
10u
D1N4148
D3
2.2k
R8
D2
R5
0
D1N4148
220
10k
R7
BC547
1k
0
1k
D4
R1
D1N4148
0
0
Q2
BC547
0
2.2k
R4
R2
C4
100n
Q1
U19
R6
R3
10k
1k
0
0
C7
15p
0
D5
0
1k
C6
1k
R13
4.7k
1
PHONE JACK-O
P2
1
14
2
15
3
16
4
17
5
18
6
19
7
20
8
21
9
22
10
23
11
24
12
25
13
VOUT
VIN
2
ADJ
J5
11
12
13
14
15
16
17
18
10
RC0/T1OSO/T1CKI
RA0/AN0
RC1/T1OSI/CCP2
RA1/AN1
RC2/CCP1
RA2/AN2/VREFRC3/SCK/SCL
RA3/AN3/VREF+
RC4/SDI/SDA
RA4/T0CKI
RC5/SDO
RA5/SS/AN4
RC6/TX/CK
RC7/RX/DT
RB0/INT
RB1
RB2
OSC2/CLKOUT
RB3/PGM
RB4
RB5
RB6/PGC
RB7/PGD
OSC1/CLKIN
CONNECTOR DB25
MCLR/VPP/THV
0
VDD
2
3
4
5
6
7
0
af15p
f icheur + boutons
1
2
3
4
5
6
7
8
9
J1
10
11
12
13
14
15
16
0
1
2
3
4
5
6
7
8
9
10
21
22
23
24
25
26
27
28
9
1
J2
commande moteur
0
20
PIC16F876
La carte mère est composée de deux parties distinctes. La première partie,
située à gauche sur le schéma, sert à programmer le PIC. La partie situé a droite
gère les entrées sorties du microcontrôleur et l’alimentation à partir du 12V.
La partie programmatrice est alimentée en 17V grâce à une prise jack, et
est relié à l’ordinateur grâce au connecteur DB25 directement incluse dans la
carte. Pour programmer le PIC il faut rentré sur les ports RB6 et RB7 mais aussi
appliqué à l’entrée MCLR une tension.
Sur le terrain, et une fois que le PIC est programmé, on passe à la partie
droite du schéma.
Cette partie est alimentée grâce à une batterie de 12V. Le microcontrôleur
ainsi que le reste du montage, doit être alimenté en 5V ce qui nous a obligé à
créé un système permettant de passé du 12V au 5V. On a opté pour la solution
des deux 78L05 montée en parallèle pour des raisons d’efficacité, en effet en
faisant nos recherches sur Internet on a pus remarqué que beaucoup de monde
utilisé se type de montage dans leur voiture pour alimenté à partir de leur
batterie un appareil électrique tel qu’un lecteur MP3 ou autres.
19
Les information reçus ou délivrer par le microcontrôleur passe par des
borniers, se qui nous permet de pouvoir superposé lé carte afin de gagner en
place, les liaisons entre les carte se font grâce à des nappes. L’utilisation des
boutons poussoirs et de l’afficheur LCD nous obligés d’utilisé 13 places sur un
bornier, on a donc choisi d’utiliser un bornier à 16, soit en réalité un 2*8. Pour la
gestion du moteur on avait besoin de 7 places, on a donc pris un 2*5.
On remarquera que sur les deux borniers on y mets la masse et le +5V.
On a utilisé les ports B et C du 16F876, qui on chacun 8 ports, car on en
avait besoin de 16. Les ports sont reliés de la manière suivante :
PORT B :
RB0 /RESET (GS-D200S)
RB1 ENABLE (GS-D200S)
RB2 /STEP CLK (GS-D200S)
RB3 CW-/CCW (GS-D200S)
RB4 /HOME (GS-D200S)
RB5 Bp1 : bouton «–»
RB6 Bp2 : bouton «+»
RB7 Bp3 : bouton «défiler »
Les « / » signifient que les ports sont actif au niveau bas.
PORT C :
RC0
RC1
RC2
RC3
RC4
RC5
RC6
RC7
RS (afficheur)
R-W (afficheur)
E (afficheur)
Bp4 : bouton «OK »
D4 (afficheur)
D5 (afficheur)
D6 (afficheur)
D7 (afficheur)
20
II) Carte interphase boutons + LCD :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
J15
af f icheur LCD
0
CON16
0
-
Bp1
Bp2
0
S3
+
-
S2
+
-
Bp3
0
0
S1
+
-
S1
Bp4
+
1k
-
R16
1k
+
R15
1k
-
R14
1k
+
R17
+
-
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-
J3
0
On rentre sur cette carte grâce à la nappe 2*8 venant de la carte mère, on
utilise 8 port pour l’afficheur LCD, 4 ports pour les boutons poussoirs et enfin
un pour le +5V et un pour la masse, le ports 13, 14, 15 sont relié à la masse à
défaut d’être utilisé.
Les boutons poussoirs envoi en entrée du microprocesseur un niveau bas
quand l’interrupteur est ouvert, si l’utilisateur appui sur le bouton, l’alimentation
va être relié on va donc avoir un niveau haut en entrée de microprocesseur.
N’ayant pas de quoi simuler un afficheur LCD sur le logiciel «orcad »,
j’ai utilisé un connecteur 16 broches représentant les 16 entrée d’un afficheur.
Etant donnée que l’on programme l’afficheur en mode 4bits, les ports D0, D1,
D2, D3 sont reliés à la masse. Le bit du contraste est aussi mis, par défaut, à la
masse. Les bits 15 et 16 permettent le rétro éclairage de l’afficheur LCD, étant
donné que l’astronomie se fait durant la nuit, on n’a pensé qu’il serait utile
d’avoir un affichage rétro éclairé, on a donc tout simplement relié l’anode (port
15) au +5V, et la cathode (port 16) à la masse.
21
III) Carte commande moteur :
J20
0
J4
1
2
3
4
5
6
7
8
9
10
CON10
0
1
2
3
4
5
6
7
8
9
10
11
12
J21
1
2
3
4
5
6
CON6
CON12
Les borniers J20 et J21 représente le module GS-D200S avec d’un coté
les entrées et de l’autre les sorties vers le moteur.
Dans notre cas, on n’utilisera pas le bit 2 qui sert à synchroniser deux modules
ensemble. On ne connecte pas non plus le bit 4 (HALF-/FULL) qui, si il n’est
pas connecté fonctionne en demi pas, qui est le fonctionnement que l’on doit
utiliser. Les bits 8, 9 et 10 ne sont pas non plus connecté car on ne les utilise pas.
22
Nomenclature :
Nombre
2
4
2
4
1
3
1
4
4
1
2
2
1
2
1
11
2
2
1
1
1
3
1
1
1
1
Nom
C1, C8
C2, C3, C4, C5
C6, C7
C9, C10, C11, C12
D1
D2, D3, D4
D5
Bp1, Bp2, Bp3, Bp4
J5
J1, J3
J2, J4
P2
Q1, Q2
Q3
R1, R2, R3, R4, R9,
R11, R12, R14, R15,
R16, R17
R5, R6
R7, R10
R8
R13
U9
U11
Afficheur LCD
U16
Référence
Condensateur tantalum
Condensateur céramique
Condensateur céramique
Condensateur céramique
1N4001
1N4148
LED
Bouton poussoir
Capuchon noir
PHONE JACK-O
CON 16
CON 10
CONNECTOR DB25
BC547
CRYSTAL
Résistance plastique ¼ W
Valeurs
10µF
100nF
15pF
1µF
Résistance plastique ¼ W
Résistance plastique ¼ W
Résistance plastique ¼ W
Résistance métal ¼ W
LM317L
78LO5
Afficheur LCD rétro éclairé 2*16 lignes
Support CI 40 broches
PIC16F876
Moteur 200 pas par tour
10kOhm
2,2kOhm
220 Ohm
4,7kOhm
1kOhm
Prix
0,90
0,40
0,10
0,20
?
0,18
0,20
2,60
1,80
0,40
1,10
1,00
0,60
0,30
1,00
0,30
0,15
0,15
0,15
0,25
0,60
1,35
13,90
0,92
11,50
26,90
Prix d’après le catalogue « gotronic » téléchargeable gratuitement sur Internet :
www.gotronic.fr
23
Connecteur 16 broches :
N°
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Carte mère
+5V
RC0
RC1
RC2
RC4
RC5
RC6
RC7
RB5
RB6
RB7
RC3
GND
GND
GND
GND
Ports
11
12
13
15
16
17
18
26
27
28
14
Carte afficheur + boutons
+5V
RS
R/W
E
D4
D5
D6
D7
Bp1
Bp2
Bp3
Bp4
GND
GND
GND
GND
Ports
Carte commande moteur
/RESET
HOME
/STEPCLK
CW-/CCW
ENABLE
GND
GND
GND
+5V
GND
Ports
3
5
6
7
11
4
5
6
11
12
13
14
Connecteur 10 broches :
N°
1
2
3
4
5
6
7
8
9
10
Carte mère
RB0
RB4
RB2
RB3
RB1
GND
GND
GND
+5V
GND
Ports
21
25
23
24
22
12
1
24
Boite
8 cm
10 cm
15 cm
8 cm
10 cm
Entrée batterie
Sortie moteur
10 cm
15 cm
8 cm
25
Programmation du système
I) Mise en situation :
a) posons le problème :
Le but principal de ce programme est de piloter un moteur pas à pas pour
compenser le mouvement de rotation de la terre en agissant sur l’ascension
droite de la monture équatoriale. Pour ce faire, lorsque la terre tourne sur ellemême, il faut que le moteur se déplace d’autant de pas dans l’autre sens
Diagramme explicatif :
Légende : le point rouge symbolise la position initiale de la monture, le point bleu la position finale après une
certaine rotation de la terre. Le segment noir représente la direction dans laquelle pointe la monture et le segment
en pointillés la correction que doit apporter le moteur.
Pour calculer cette correction, il faut tout d’abord calculer le déplacement
de la planète sur elle-même.
En considérant que la terre fait un tour sur elle même en 24 h on a :
ça fait de tour par heure soit
tour par minute ou encore
tour par
seconde.
Ce qui ramène à dire que la terre fait un pas par seconde sur un total de
86400 pas.
Il suffit maintenant de faire un produit en croix avec le nombre de pas par
tour du moteur pour obtenir la durée d’un pas du moteur.
26
b) Choix du moteur :
Nous pensions, à la base, que le programme que nous allions développer,
permettrait de prendre n’importe quel moteur pour le système. Cependant, nous
nous sommes rendu compte que c’était inutile car le système étant entièrement
prit en charge par nous-même, nous choisirions un moteur pour faire le montage
et il n’y aurait nul besoin de le remplacer. Programmer une adaptation du pas
selon le moteur serait alors superflu vu que le moteur est toujours identique
(mais peut-être pas la monture, c’est pour cela que le rapport de réduction doit
être toujours réglable).
Nous avons donc opté pour un moteur 200 pas par tour. Ce qui en mode
demi pas donne du 400 pas par tour, ce qui est suffisamment précis.
Calcul de la durée d’un pas :
Terre : 1/86400 pas -> 1 seconde
Moteur : 1/200 pas -> ?
On a donc : durée d’un pas = 86400/200 = 432 secondes soit 7,2 minutes.
Le problème assimilé et la durée standard trouvée, nous pouvons donc
commencer l’élaboration du programme
27
II) Organigrammes généraux :
a) organigramme du déplacement automatique
La priorité du programme étant de faire tourner le moteur, nous allons
donc commencer par écrire l’organigramme du pilotage automatique :
Note : comme la rotation du moteur est prioritaire on pourra la placer en
interruption de timer lors de l’élaboration du programme.
DEBUT
Durée d’un pas
écoulée
?
Oui
non
on décale
d’un autre
pas
FIN
b) Organigramme du déplacement manuel
Cet organigramme est soumis à deux conditions :
- Si l’utilisateur appuie sur le bouton +, le moteur se décale d’un pas dans
son sens en cours.
28
- Si l’utilisateur appuie sur le bouton -, le moteur se décale d’un pas dans
son sens inverse de rotation.
Il faut donc tester l’état des boutons en permanence ou plutôt en « temps
réel ».
DEBUT
Bouton avancer
Enfoncé
?
oui
Un pas vers
l’avant
non
Bouton reculer
Enfoncé
?
non
oui
Un pas vers
l’arrière
FIN
29
c) organigramme des menus de l’afficheur
Cet organigramme doit s’embriquer dans celui de l’organigramme de la
commande manuel puis que l’utilisateur sollicite un bouton pour rentrer dans le
menu mais pour plus de clarté nous allons le présenter séparément.
Il y a normalement 4 sous-menus, celui du rapport de réduction, du sens
de rotation, de la durée d’un pas (appelé vitesse dans le programme) et le menu
retour.
Voici comment accéder aux différents sous menus grâce au bouton défiler :
Accès aux
menus de
l’afficheur
Rapport de
réduction
retour
vitesse
Sens
L’organigramme suivant n’est pas l’organigramme complet de l’afficheur à
cause d’un problème de place (cet organigramme ne rentre pas dans une feuille
format A4), il présente le lancement du menu ainsi que le premier sous menu.
Les sous-menus étant fait de la même façon, il suffit d’extrapoler le principe du
premier sous menu aux autres.
La seule différence notable est pour le menu retour. Dans celui-ci, peu importe
si l’utilisateur appuie sur le bouton + ou le bouton -, il sort des menus de
l’afficheur.
30
DEBUT
Bouton ok
Enfoncé
?
non
oui
Accès menu
Rapport de
réduction
Bouton
Défilé
Enfoncé ?
oui
Accès menu
vitesse
non
Bouton +
Enfoncé
?
oui
Numérateur
+1
non
Afficher le
changement
Bouton Enfoncé
?
non
oui
dénominateur
+1
Afficher le
changement
FIN
31
On remarque qu’il faut obligatoirement passer par le menu retour pour sortir de
l’afficheur.
Note : Le numérateur et le dénominateur du rapport peuvent s’incrémenter
jusqu’à 9, si l’on dépasse ce chiffre ils reviennent à 1.
32
III) Programmation en mnémoniques : problèmes rencontrés et
solutions
a) prise en compte du temps
Le moteur doit effectuer un pas toutes les X secondes. Pour faire cela, on
peut soit utiliser une horloge externe que l’on relit au microprocesseur, soit on
peut utiliser les timers internes d’interruption du microprocesseur.
Dans le cas présent, nous souhaitions gérer le système sans nouveaux
périphériques, il nous fallait donc utiliser les timers d’interruptions.
Pour cela, nous avons choisi de prendre le timer1 qui est un timer 16 bits il peut
donc s’incrémenter jusqu’à FFFF en héxa (soit 65535 en base 10) avant de
déborder et de générer une interruption. En supposant qu’un incrémentation dure
1µ (paramètre à gérer lors de l’initialisation du timer), un débordement complet
du timer vaut 0.06 s.
Il faut donc lancer l’interruption pour incrémenter (ou décrémenter) une variable
une fois par interruption. Ainsi lorsque la variable aura atteint X, si X fois 0.06 s
vaut le temps entre chaque pas du moteur, on décale le moteur d’un pas. Tout
ceci en interruption, ainsi le fonctionnement du moteur est prioritaire.
Cette méthode nous renvoie, et même crée, les deux problèmes suivants.
b) utilisation de variables 16 bits avec un PIC 16F876
Comme les temps entre chaque pas sont très longs à l’échelle d’un
microprocesseur, la variable contenant le nombre de débordements du timer
(autrement dit la variable qui s’incrémente à chaque lancement d’IT du timer1)
doit être 16 bits, sa valeur dépassant les 1000 en base 10. Cependant plusieurs
opérations doivent être effectuées dessus, comme par exemple la multiplication
par le rapport de réduction et une division par 2 pour le mode demi-pas. Or le
seul accumulateur d’un PIC 16F87X est un accumulateur 8 bits, donc des
opérations directes ne peuvent être effectuées avec une variable 16bits sous
peine de débordement.
Il faut donc traiter les 8 bits de poids fort et les 8 bits de poids faibles de la
variable séparément. Soit en jouant sur les adresses directement soit en séparant
la variable en deux variables. Une contenant les bits de poids fort et une les bits
de poids faible.
Remarque : ce problème n’aurait pas lieu d’être sur un µP 6809 vu que ce type
de microprocesseur possède 3 accumulateurs doubles longueurs ( D, X et Y).
33
c) Opérations de multiplications et de divisions :
Ces opérations sont requises dans le programme, par exemple, pour utiliser le
rapport de réduction.
Le PIC que l’on utilise ici possède un langage réduit. Il ne comprend donc
pas la multiplication et la division. Il a donc fallut faire des multiplications et
des divisions à l’aide d’additions, de soustractions, d’incrémentations et
décrémentations de variables ainsi que des jumps.
Solution trouvée :
Division de la variable « centut » par 13 :
xi2:
xa2:
movlw 0x0d
subwf centut,1
bz xa2
incf centut2,1
goto xi2
incf centut2,1
On entre le dénominateur dans W et puis on soustrait le numérateur (ici
centut) de W, puis on incrémente une variable (ici centut2). On reproduit cette
opération jusqu’à ce que le numérateur (centut) soit égal à 0 puis on incrémente
centut2 une dernière fois pour arrondir à l’unité supérieure vu que le
microprocesseur ne prend pas en compte les chiffres après la virgule.
Le résultat de l’opération est donc bien entendu contenu dans la variable qui
s’incrémente (centut2)
Multiplication de centut2 par 10
wu2:
wa2:
wi2:
decf centut2,1
bnz wu2
movlw 0x0a
goto wi2
movlw 0x0a
addlw 0x0a
decf centut2,1
bnz wa2
movwf centcompt
34
On décrémente une fois centut2, si le résultat est égal à zéro, ça veut dire
que centut2 = 1, on met la valeur dix dans centcompt et l’opération est terminée.
On a multiplié 1 par 10 et le résultat est contenu dans centcompt.
Maintenant voici le cas où si centut2 est supérieur à 1 :
On décrémente une fois centut2, puis on ajoute 10 à W (qui contient déjà la
valeur 10). On effectue cette manoeuvre jusqu’à ce que centut2 soit égal à zéro.
Le résultat de la multiplication est contenu dans l’accumulateur W.
Note: Lors de la multiplication, le multiplicateur doit toujours être le plus petit
nombre de la multiplication, ainsi le temps de calcul est plus court.
Note2 : les variables soumises à ses opérations sont toujours différentes de 0
donc le cas où elle pourrait être égale à 0 n’est pas prit en compte pour ses
opérations vu que ce cas est impossible.
Remarque: Avec un microprocesseur à language SISC ce contournement
n’aurait pas eu lieu puis que la multiplication et la division sont comprises dans
les mnémoniques.
Inconvenient de la solution:
Comme le microprocesseur ne prend pas en compte les chiffres après la
virgule, lors de nombreuses opérations successives sur de grosses variables, il se
peut qu’il y ait de fortes erreurs de calculs mais ces erreurs ne dépassent pas
l’ordre de la dizaine, elles peuvent être négligeables car les résultats des calculs
de ce programme sont de l’ordre de la centaine ou du millier. Néanmoins, il en
reste les calculs ne sont pas précis.
35
Conclusions
Conclusion générale :
Notre projet a été quasiment mené à bout, de notre cahier des charges le
seul point qui nous a manqué est la réalisation et les tests de notre solution.
Ce manque est du au fait qu’on a pas réussi à créer un typon, nous avions au
départ choisi d’utiliser «eagle» mais, avec ce logiciel, nous n’avons même pas
put réaliser le schéma électrique car nous n’avions pas toutes les librairies
nécessaire (par exemple les transistors BC547), nous somme après passés au
logiciel «orcad» que l’IUT nous a donné lors des séances de TR, là encore nous
Avons été bloqué par manque de librairie. Enfin nous avons réussi à récupérer
la dernière version de «orcad» avec toutes les librairies, nous avons donc réalisé
les schémas électriques. Dans le pack «orcad» il y a la possibilité de créer un
typon à partir de notre schéma. Nous avons donc utilisé l’aide pour comprendre
comment faire cette action, mais là encor nous n’avons pas put aller au bout du à
une erreur encor incomprise, le logiciel nous affiche un message d’erreur qui
est :
« AutoECO Report
FILE-A: G:\MES DOCUMENTS\COURS\CAPTURE\PTUTEQUAT.MAX
FILE-B: G:\MES DOCUMENTS\COURS\CAPTURE\PTUTEQUAT.MNL
If "*EOF*" immediately follows, no changes were made
Cannot load a metric netlist on top of an english board or template.
Please convert.
*EOF*
Unable to complete ECO due to errors
1 error found »
De plus même avec la réalisation d’un typon nous n’aurions pas put réaliser le
montage car le coût de construction aurait été trop important pour nous.
36
Conclusion Etyan Bismuth :
Ce projet tuteuré comporte deux parties, une partie électronique et une
partie programmation.
Ce qui m’a plus dans ce sujet c’est la partie programmation du 16F876 grâce au
logiciel MPLAB. La partie électronique par contre est la partie que je n’ai pas
appréciée, tout d’abord car mes connaissance en électronique n’était pas
suffisante pour mener, tout seul, à bien se projet, cependant il est vrai que de
travailler avec Mathieu sur se projet m’a beaucoup appris en domaine
d’électronique. De plus nous avons été confronté au problème des librairies qui
ne nous a pas permis de réaliser le typon de notre carte, étant le but final de
notre projet. La réalisation aurait été elle aussi intéressante toutefois nous étions
dans l’incapacité financière d’acheté nous-mêmes les composants.
37
Conclusion Mathieu Paris :
J’ai trouvé le principe du projet tuteuré très intéressant, et ce même si la
motorisation d’une monture équatoriale ne m’a passionné, je fini cette période
de recherches et de développement en étant plutôt satisfait de ces trois mois.
Surtout pour ce que nous sommes arrivés à faire et pour tout ce que nous avons
appris en plus de ce qui nous a été dispensé en cours.
Néanmoins, je pense que passer 300 heures sur un projet en plus de suivre 40
heures de cours par semaine est beaucoup trop.
38
39
Listing du programme
#INCLUDE P16F876.inc
list p=16F876
;****************************************
;
VARIABLES
*
;****************************************
CBLOCK
0x20
;debut de la zone des variables
num
den
table
total
cent
dix
uni
flag
t
var
var2
tit
centit
dixit
centut
dixut
centut2
centcompt
dixcompt
centcompt2
dixcompt2
compte
ENDC
CBLOCK
W_save
STATUS_save
ENDC
;fin de la zone
0x70
;zone de sauvegarde pour les interruptions
;registre pour sauvegarde de W
;registre pour sauvegarde de STATUS
;fin de la zone
;****************************************
;
MACROS
*
;****************************************
#INCLUDE macro.inc
;
;macro.inc doit etre present dans le
;meme repertoire que le reste du projet
;****************************************
;
VECTEUR RESET
*
;****************************************
org 0x000 ;vecteur RESET
goto Init
;****************************************
;
INTERRUPTIONS
*
40
;****************************************
org
0x004 ;vecteur Interruption
; sauvegarde de W et STATUS
movwf W_save
swapf STATUS,w
movwf STATUS_save
movf dixcompt2,1 ; si elle vaut zéro on va décrémente la variable des milliers
bz suite
decf dixcompt2,1 ; on décrémente la variable des centaines
bnz fin2
movf centcompt,0
movwf centcompt2
goto fin2
suite:
decf centcompt2,1 ; on décrémente la variable des milliers
bnz fin2 ; si elle vaut zéro on décrémente la variable de
; comptage puis on recommence à décrémenter la variable des centaines
; et ainsi de suite.
movf dixcompt,0
movwf dixcompt2
decf compte,1
bz interrup ; la variable compte = 0 on décale le moteur d'un pas
goto fin2
interrup:
bsf PORTB,2
nop
nop
bcf PORTB,2
fin2:
;restauration de W et STATUS
swapf STATUS_save,w
movwf STATUS
swapf W_save,f
swapf W_save,w
retfie
;retour d'interruption
;****************************************
;
INITIALISATIONS
*
;****************************************
Init:
;acces aux TRIS (dans bank1)
bsf STATUS,RP0
bcf
STATUS,RP1
movlw 0xE0
movwf TRISB
movlw 0x08
movwf TRISC
bsf PIE1,TMR1IE ; active les interruptions du timer
41
;acces aux PORTS (dans bank0)
bcf
bcf
STATUS,RP0
STATUS,RP1
;initialisation de l'écran LCD
movlw 0x34
movwf PORTC ; on force l'afficheur en mode 8bits
bcf PORTC,2 ; front descend dans de E
movwf PORTC
bcf PORTC,2
movwf PORTC
bcf PORTC,2
movlw 0x24
movwf PORTC ; on passe en mode 4bits
nop
bcf PORTC,2
movlw 0x24
movwf PORTC
nop
bcf PORTC,2
movlw 0x84
movwf PORTC ; mode 4 bits, afficheur 2 lignes, caractères 5x7
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0xc4
movwf PORTC ; pas de curseur
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x54
movwf PORTC ; le curseur de déplace vers la droite
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x14
movwf PORTC ;on efface l'écran
nop
bcf PORTC,2
; le rapport de reduction est de 1/1 à l'initialisation
movlw 0x01
movwf num
42
movwf den
; initailisation des variables pour l'écriture de la vitesse.
movlw 0x04
movwf cent
movlw 0x03
movwf dix
clrw
movwf uni
; initialisation du flag
movlw 0x01
movwf flag
; variable compte à 100
movlw 0x64
movwf compte
bcf INTCON,GIE ; active les interruptions globales
clrw
movwf TMR1L ; on met le timer 16 bits
movwf TMR1H ; à 0x0000
; initialisation moteur
bcf PORTB,0 ;reset du moteur
nop
bsf PORTB,0
bsf PORTB,1 ; enable = 1
bsf PORTB,3 ; sens de rotation horaire
;****************************************
;
PROGRAMME PRINCIPAL
*
;****************************************
Debut:
;##################### commande manuelle ################################;
movf flag,1 ;est-ce que l'utilisateur a changé des paramètres?
bnz operations
btfsc PORTB,6
goto pas
btfsc PORTB,5
goto seens
btfsc PORTC,3
goto menurapport
goto Debut
seens:
movlw 0x08
andwf PORTB,0
bz un
bcf PORTB,3 ; on met cw/ccw à 0
bsf PORTB,2
nop
43
nop
bcf PORTB,2
bsf PORTB,3 ;on met cw/ccw à 1 pour revenir dans le sens d'origine
goto Debut
un:
bsf PORTB,3 ; on met cw/ccw à 1
bsf PORTB,2
nop
nop
bcf PORTB,2
bcf PORTB,3 ;on met cw/ccw à 0 pour revenir dans le sens d'origine
goto Debut
pas:
bsf PORTB,2
nop
nop
bcf PORTB,2
goto Debut
operations:
; addition de cent et dix (voir menu vitesse dans l'afficheur)
clrw
movwf flag
movf cent,0
call conv
addwf dix,0
movwf t
; multiplication par le rapport de réduction
; d'abord on divise par le dénominateur
zu:
zo:
movf den,0
subwf t,1
bz zo
incf var2,1
goto zu
incf var2,1
; puis on multiplie par le numérateur
xa:
xi:
decf num,0
movwf var
movf var2,0
movf var,1
bz xi
addwf var2,0
decf var,1
bnz xa
;le résultat de la multiplication se trouve dans w
; on sépare le résultat en deux variables à l'aide du masquage
movwf tit
andlw 0x0f
movwf dixit
movf tit,0
andlw 0xf0
movwf centit
44
swapf centit,1
;gestion de centit et dixit pour arriver aux variables finales
;qui serviront à calculer les secondes par pas
; par décrémentation à l'aide du timer1
; multiplication par 10
wu:
wa:
wi:
wu1:
wa1:
wi1:
decf centit,1
bnz wu
movlw 0x0a
goto wi
movlw 0x0a
addlw 0x0a
decf centit,1
bnz wa
movwf centut
decf dixit,1
bnz wu1
movlw 0x0a
goto wi1
movlw 0x0a
addlw 0x0a
decf dixit,1
bnz wa1
movwf dixut
; division par 13
xi2:
xa2:
xi1:
xa1:
movlw 0x0d
subwf centut,1
bz xa2
incf centut2,1
goto xi2
incf centut2,1
movlw 0x0d
subwf dixut,1
bz xa1
incf dixcompt,1
goto xi1
incf dixcompt,1
; multiplication de centut2 par 10
wu2:
wa2:
wi2:
decf centut2,1
bnz wu2
movlw 0x0a
goto wi2
movlw 0x0a
addlw 0x0a
decf centut2,1
bnz wa2
movwf centcompt
conv addwf PCL,f ;table servant à convertir du décimal en héxa
nop
retlw 0x0a ;10
45
retlw 0x14 ;20
retlw 0x1e ;30
retlw 0x28 ;40
retlw 0x32 ;50
retlw 0x3c ;60
retlw 0x46 ;70
retlw 0x50 ;80
retlw 0x5a ;90
;##################### afficheur ######################################;
;----------- 1er menu -----------;
menurapport: ;l'utilisateur arrive directement dans le réglage
;du rapport de réduction en entrant dans le menu afficheur
;cleardisplay
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x14
movwf PORTC
nop
bcf PORTC,2
movlw 0x20
movwf table
la1: movf table,0
call rapp
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz la1
;écriture du rapport num/den
; curseur sur 2eme ligne
ecrit1: movlw 0x94
movwf PORTC
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
; le curseur est sur la 2eme ligne on peut écrire
movlw 0x35
movwf PORTC
nop
bcf PORTC,2
; les bits de poids forts ont été envoyés
movf num,0
call chif
movwf PORTC
nop
bcf PORTC,2
; suivi des bits de poids faibles. le numérateur est écrit
46
movlw 0x25
movwf PORTC
nop
bcf PORTC,2
movlw 0xF5
movwf PORTC
nop
bcf PORTC,2
; la fraction est écrite
movlw 0x35
movwf PORTC
nop
bcf PORTC,2
; les bits de poids forts ont été envoyés
movf den,0
call chif
movwf PORTC
nop
bcf PORTC,2
; suivi des bits de poids faibles. le dénominateur est écrit
test1: ; on attend que l'utilisateur appuie sur un bouton
btfsc PORTB,7
goto menuvitesse
btfsc PORTB,6
goto numplus
btfsc PORTB,5
goto denplus
goto test1
numplus:
incf num,1
movlw 0x0A
subwf num,0 ; num s'incrémente mais ne doit pas dépasser 9 sinon il revient à 1
bnz ici1
movlw 0x01
movwf num
ici1: goto ecrit1 ;on va réécrire le rapport
denplus:
incf den,1
movlw 0x0A
subwf den,0 ; même principe pour le dénominateur
bnz ici2
movlw 0x01
movwf den
ici2: goto ecrit1
;---------- 2eme menu ----------;
menuvitesse: ; en appuyant sur le bouton defiler,
; on passe au réglage de la vitesse exprimée en secondes par pas
;cleardisplay
movlw 0x04
movwf PORTC
nop
47
bcf PORTC,2
movlw 0x14
movwf PORTC
nop
bcf PORTC,2
la2:
;écriture du mot vitesse
movlw 0x0E
movwf table
movf table,0
call vit
nop
bcf PORTC,2
movwf PORTC
decf table,1
bnz la2
ecrit2: ;positionnement du curseur sur la 2eme ligne
movlw 0x94
movwf PORTC
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
; on peut maintenant écrire la vitesse en seconde par pas
movlw 0x35
movwf PORTC
nop
bcf PORTC,2
movf cent,0
call chif
movwf PORTC
nop
bcf PORTC,2
; le chiffre des centaines est écrit
movlw 0x35
movwf PORTC
nop
bcf PORTC,2
movf dix,0
call chif
movwf PORTC
nop
bcf PORTC,2
; celui des dixaines aussi
movlw 0x35
movwf PORTC
nop
bcf PORTC,2
movf uni,0
call chif
movwf PORTC
nop
bcf PORTC,2
; il faut maintenant écrire s/pas
movlw 0x0a
movwf table
la3: movf table,0
48
call spas
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz la3
test2:
btfsc PORTB,7
goto menusens
btfsc PORTB,6
goto dixplus
btfsc PORTB,5
goto dixmoins
goto test2
dixplus:
incf dix,1
movlw 0x0a
subwf dix,0 ; dix s'incrémente mais ne doit pas dépasser 9 sinon il revient à 0
bnz ici3
clrf dix
incf cent,1 ; dans ce cas là, les centaines s'incrémentent
movlw 0x0a
subwf cent,0 ; cent s'incrémente mais ne doit pas dépasser 9 sinon il revient à 0
bnz ici3
clrf cent
ici3: goto ecrit2 ;on va réécrire la vitesse
dixmoins: ;même principe que le sous-programme dixplus sauf qu'ici on décrémente
movf dix,1 ; on vérifie que dix ne soit pas à zéro avant de le décrémenter
bnz decdix
movlw 0x09 ; si c'est le cas il passe à 9
movwf dix ; et c'est cent que l'on devra décrémenter
movf cent,1 ;même opération sur cent si dix vallait 0
bnz deccent
movlw 0x09
movwf cent
goto ecrit2
deccent:decf cent,1 ; si dix est différent de zéro, on le décrémente
goto ecrit2
decdix: decf dix,1 ;si dix était égal à 0, et cent différent de 0 on le décrémente
goto ecrit2
;---------- 3eme menu ----------;
; ici on définit le sens de rotation du moteur
menusens:
;cleardisplay
49
la4:
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x14
movwf PORTC
nop
bcf PORTC,2
;écriture du mot sens
movlw 0x08
movwf table
movf table,0
call sens
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz la4
ecrit3: ;on positionne le curseur sur la 2eme ligne
movlw 0x94
movwf PORTC
nop
bcf PORTC,2
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
btfsc PORTB,3 ;on vérifie le sens du moteur
goto av
;si le bit cw/ccw est à 0 on écrit "trigo"
;si il est à 1 on écrit "horaire"
ar:
bcf PORTB,3
movlw 0x0a
movwf table
parla1: movf table,0
call arrie
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz parla1
goto test3
av:
bsf PORTB,3
movlw 0x0e
movwf table
parla: movf table,0
call avant
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz parla
test3:
btfsc PORTB,7
goto menuretour
50
btfsc PORTB,6
goto av
btfsc PORTB,5
goto ar
goto test3
;---------- 4eme menu ----------;
; ici l'utilisateur a la posibilité de quitter les menus de l'afficheur
menuretour:
la5:
;cleardisplay
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x14
movwf PORTC
nop
bcf PORTC,2
;écriture du mot retour
movlw 0x0c
movwf table
movf table,0
call ret
movwf PORTC
nop
bcf PORTC,2
decf table,1
bnz la5
test4:
btfsc PORTB,7
goto menurapport
btfsc PORTB,6
goto fin
btfsc PORTB,5
goto Debut
goto fin
fin:
;cleardisplay
movlw 0x04
movwf PORTC
nop
bcf PORTC,2
movlw 0x14
movwf PORTC
nop
bcf PORTC,2
movlw 0x01
movwf flag ;en testant cette varaible on saura
;si l'utilisateur est rentré dans le menu
goto Debut ; on quitte l'afficheur
51
;######## tables ##########
rapp addwf PCL,f ;cette table contient la séquence d'écriture RapporTreduction
nop
retlw 0xe5 ;n
retlw 0x65
retlw 0xf5 ;0
retlw 0x65
retlw 0x95 ;i
retlw 0x65
retlw 0x45 ;t
retlw 0x75
retlw 0x35 ;c
retlw 0x65
retlw 0x55 ;u
retlw 0x75
retlw 0x45 ;d
retlw 0x65
retlw 0x55 ;e
retlw 0x65
retlw 0x25 ;r
retlw 0x75
retlw 0x45 ;T
retlw 0x55
retlw 0x25 ;r
retlw 0x75
retlw 0xf5 ;o
retlw 0x65
retlw 0x05 ;p
retlw 0x75
retlw 0x05 ;p
retlw 0x75
retlw 0x15 ;a
retlw 0x65
retlw 0x25 ;R
retlw 0x55
chif addwf PCL,f ;cette table contient les poids faibles des chiffres de 1 à 9.
retlw 0x05 ;Les poids forts étant identiques il n'y pas besoin de table pour eux.
retlw 0x15 ;1
retlw 0x25 ;2
retlw 0x35 ;3
retlw 0x45 ;4
retlw 0x55 ;5
retlw 0x65 ;6
retlw 0x75 ;7
retlw 0x85 ;8
retlw 0x95 ;9
vit addwf PCL,f ;cette table contient la séquence d'écriture Vitesse
nop
retlw 0x55 ;e
retlw 0x65
retlw 0x35 ;s
retlw 0x75
52
retlw 0x35 ;s
retlw 0x75
retlw 0x55 ;e
retlw 0x65
retlw 0x45 ;t
retlw 0x75
retlw 0x95 ;i
retlw 0x65
retlw 0x65 ;V
retlw 0x55
spas addwf PCL,f ; cette table contient l'unité de la vitesse
nop
retlw 0x35 ;s
retlw 0x75
retlw 0x15 ;a
retlw 0x65
retlw 0x05 ;p
retlw 0x75
retlw 0xf5 ;/
retlw 0x25
retlw 0x35 ;s
retlw 0x75
sens addwf PCL,f ;table contenant le mot sens
nop
retlw 0x35 ;s
retlw 0x75
retlw 0xe5 ;n
retlw 0x65
retlw 0x55 ;e
retlw 0x65
retlw 0x35 ;S
retlw 0x55
avant addwf PCL,f ;table contenant le mot horaire
nop
retlw 0x55 ;e
retlw 0x65
retlw 0x25 ;r
retlw 0x75
retlw 0x95 ;i
retlw 0x65
retlw 0x15 ;a
retlw 0x65
retlw 0x25 ;r
retlw 0x75
retlw 0xf5 ;o
retlw 0x65
retlw 0x85 ;h
retlw 0x65
arrie addwf PCL,f ;table contenant le mot trigo
nop
retlw 0xf5 ;o
retlw 0x65
retlw 0x75 ;g
retlw 0x65
retlw 0x95 ;i
53
retlw
retlw
retlw
retlw
retlw
0x65
0x25 ;r
0x75
0x45 ;t
0x75
ret addwf PCL,f ;table contenant le mot retour
nop
retlw 0x25 ;r
retlw 0x75
retlw 0x55 ;u
retlw 0x75
retlw 0xf5 ;o
retlw 0x65
retlw 0x45 ;t
retlw 0x75
retlw 0x55 ;e
retlw 0x65
retlw 0x25 ;R
retlw 0x55
;****************************************
end ;derniere ligne du fichier
54