Temporisation d'une seconde avec un microcontroleur PIC 16F877

[invite62696a75]

Bonsoir,

j'ai besoin d'aide pour deux questions :

a) Donner un organigramme décrivant le principe de réalisation d'une temporisation d'une seconde.
b) Ecrire un programme traduisant en langage assembleur l'organigramme de temporisation donné en a) puis vérifier le bon fonctionnement avec le simulateur MPSIM sachant que la fréquence du quartz utilisé est de 10 kHz.

Déjà je bloque sur le a). Je sais pas comment faire, je suis perdu avec les compteurs, les temps de cycles etc.
J'ai fait beaucoup d'efforts pour essayer de comprendre mais je n'y arrive pas.

Je demande donc votre aide s'il vous plaît.

Je vous remercie d'avance.
-----

[invitefaaca50b]

surement un quartz a 10MHz, soit 2.5 milions d'instructions a la seconde.
Ta tempo etant un exercice scolaire, il ne fallait pas dormir en cours...

[invite62696a75]

C'est 10 kHz et pas 10 MHz et pourtant je suivais en cours mais il peut m'arriver de pas tout comprendre sinon je viendrais pas ici. ^^

[invitefaaca50b]

Le but de ta routine c'est de faire un comptage (decomptage en boucle) qui tourne pendant 1000ms.
Avec les temps d'instructions, on va faire bien moins de 2500 boucles (plutot vers 1000 1300 boucles).


Exemple d'une boucle de 1 seconde avec un quartz de 10KHz.

; Clock frequency = 0.01 Mhz
; Actual delay = 1 Seconds
; (2500 Cycles)
	cblock
	     d0
	     d1
	endc

Boucle1s
	movlw D'61'
	movwf d0
	movlw D'4'
	movwf d1
Loop
	decfsz d0, f
	goto $-1
	decfsz d1, f
	goto $-3
; Rest = 2 Cycles
	goto $-1
	retlw 0

La boucle s'appelle grace a un call Tempo1s

[A voir en vidéo sur Futura]

[invite62696a75]

Et comment tu sais qu'il faut deux compteurs avec un de 61 et l'autre de 4 ?

[invitefaaca50b]

je t'ai donné la boucle complete tiree grace a un soft dedié
Sinon extrait du cours de base de Mr Bigonoff on a ca:

11.15 La sous-routine de temporisation
Nous n’avons pas encore vu le timer0, ni les interruptions. Le but ici est de vous faire comprendre le fonctionnement du 16F84. Pour réaliser une tempo, il suffit dans notre cas de faire perdre du temps au 16F84 entre chaque inversion de la LED.
102
Nous devons donc perdre approximativement 0.5s. Les secondes ne sont pas appropriées pour les PIC®, qui travaillent à une vitesse beaucoup plus élevée. Nous utiliserons donc des unités de temps compatibles avec les PIC®.
Notre PIC® est cadencé à la fréquence de notre quartz, soit 4MHz. Or, le PIC® exécute un cycle d’instruction tous les 4 cycles de l’horloge principale. Le PIC® exécutera donc (4.000.000/4) = 1 million de cycles par seconde.
La plupart des instructions (hormis les sauts) s’exécutent en 1 cycle, ce qui vous donne approximativement un million d’instructions par seconde. Vous verrez parfois la dénomination MIPS. Ceci signifie Million d’Instructions Par Seconde. Notre PIC® avec ce quartz a donc une puissance de traitement de près de 1MIPS.
Chaque cycle d’instruction dure donc 1 millionième de seconde, ou encore une microseconde (μs). Voilà donc l’unité pour travailler avec notre PIC®.
Donc, notre tempo de 0.5s est donc une tempo de 500.000 microsecondes. Autrement dit, nous devons « perdre pour rien » 500.000 cycles dans notre routine de temporisation. Vous voyez donc que votre PIC®, pour notre application, va passer son temps à ne rien faire d’utile.
La première idée qui vient à l’esprit est de réaliser une boucle qui va incrémenter ou décrémenter une variable.
Réalisons-la. Commençons donc par déclarer notre variable (cmpt1) dans la zone de RAM. Ajoutons donc cette déclaration . Nous obtenons :
;*********************************************************************
; DECLARATIONS DE VARIABLES *
;*********************************************************************
CBLOCK 0x00C ; début de la zone variables
cmpt1 : 1 ; compteur de boucles 1
ENDC ; Fin de la zone
Créons maintenant l’ossature de notre sous-routine, que nous placerons entre la routine d’initialisation et le programme principal. N’oubliez pas de toujours utiliser des commentaires :
;*********************************************************************
; SOUS-ROUTINE DE TEMPORISATION *
;*********************************************************************
;---------------------------------------------------------------------
; Cette sous-routine introduit un retard de 500.000 μs.
; Elle ne reçoit aucun paramètre et n'en retourne aucun
;---------------------------------------------------------------------
tempo
; nous allons placer notre code ici
return ; retour de la sous-routine
103
Réalisons maintenant notre boucle.
tempo
clrf cmpt1 ; effacer compteur1
boucle1
decfsz cmpt1 ; décrémenter compteur1
goto boucle1 ; si pas 0, boucler
return ; retour de la sous-routine
Lançons la compilation (F10) :
Nous obtenons dans la fenêtre des résultats une ligne supplémentaire de la forme :
Message[305] D:\DOCUME~1\LESSONS\DATAPIC\LED_CLI.ASM 134 : Using default destination of 1 (file).
Le numéro de ligne peut varier suivant votre code source. Comme la compilation s’est effectuée correctement, il s’agit une fois de plus d’un message de type warning. Positionnez-vous dans l’éditeur sur la ligne incriminée (ligne 134 pour moi). Vous êtes sur la ligne :
decfsz cmpt1 ; décrémenter compteur1
En effet, l’instruction decfsz est de la forme « decfsz f , d ». Nous avons donc oublié d’indiquer la destination de l’opération. MPLAB® vous signale qu’il a utilisé pour vous ‘,f’
Faites donc attention, car si vous aviez voulu obtenir le résultat dans w, votre programme était faux. Modifiez donc votre commande en ajoutant ‘,f’
decfsz cmpt1 , f ; décrémenter compteur1
Maintenant, nous allons calculer la durée de cette tempo.
tempo
clrf cmpt1 ; 1 cycle
boucle1
decfsz cmpt1 , f ; 1 cycle si on ne saute pas, 2 si on saute. Donc, on ; ne sautera pas 255 fois et on sautera 1 fois
goto boucle1 ; 2 cycles multiplié par 255 passages
return ; 2 cycles.
Le temps total est donc de :
2 cycles pour l’appel de la sous-routine (call tempo)
1 cycle pour le reset de la variable
257 cycles pour les 256 décrémentations
510 cycles pour les 255 goto
2 cycles pour le return.
Soit un total de 772 cycles. On est loin des 500.000 cycles nécessaires. Pour la suite des calculs, nous allons négliger les 2 cycles du call et les 2 cycles du return (comparés aux 500.000 cycles, c’est effectivement dérisoire).
104
Bon, nous allons allonger notre routine, en réalisant une seconde boucle qui va forcer la première boucle à s’exécuter 256 fois. Commençons par déclarer une nouvelle variable cmpt2 :
cmpt1 : 1 ; compteur de boucles 1
cmpt2 : 1 ; compteur de boucles 2
Ecrivons donc les 2 boucles imbriquées :
tempo
clrf cmpt2 ; effacer compteur2
boucle2
clrf cmpt1 ; effacer compteur1
boucle1
decfsz cmpt1 , f ; décrémenter compteur1
goto boucle1 ; si pas 0, boucler
decfsz cmpt2 , f ; si 0, décrémenter compteur 2
goto boucle2 ; si cmpt2 pas 0, recommencer boucle1
return ; retour de la sous-routine
Vous voyez que notre première boucle est toujours là, mais au lieu d’effectuer le return une fois terminée, nous recommençons la boucle tant que cmpt2 ne soit pas également égal à 0. Nous allons donc exécuter 256 fois notre boucle 1.
Quelle est la temporisation obtenue ? Calculons approximativement :
Durée de la boucle 1 : 257 cycles + 510 cycles + 1 cycle (clrf cmpt1) = 768 cycles.
Or cette boucle va être exécutée 256 fois, donc 768*256 = 196608 cycles, auquel il convient d’ajouter les quelques cycles d’initialisation etc.
Or, nous désirons 500.000 cycles. Nous devrons donc utiliser cette boucle (500.000/196608) = 2,54 fois. Nous ne savons pas faire de demi boucle. Nous effectuerons donc 2 boucles. Nous allons nous arranger pour que nos deux premières boucles durent 500.000/2 = 250.000 cycles.
Chaque instruction ajoutée dans la boucle1 est exécutée 256*256 fois. Chaque instruction ajoutée dans la boucle 2 est exécutée 256 fois. Chaque cycle extérieur aux boucles est exécuté 1 fois. Nous avons donc la possibilité de réaliser des temporisations très précises. Ce n’est pas nécessaire ici. Cependant, nous allons quand même améliorer la précision.
Si nous ajoutons 1 cycle inutile dans la boucle1, nous ajouterons 256*256 = 65536 cycles. Nous devons en ajouter 250.000 – 196608 = 53392. Cela nous donnerait une erreur de 12000 cycles, soit 12 millièmes de seconde (12ms). La précision est largement suffisante pour notre application, mais je rappelle que vous pouvez affiner cette précision en effectuant les calculs précis. Je vous conseille même de le faire vous-même comme exercice. Vous pourrez vérifier vos résultats avec un chronomètre.
Pour perdre un cycle, nous ajouterons simplement l’instruction NOP, qui ne fait rien.
Reste donc à réaliser la dernière boucle de 2. Créons une troisième variable cmpt3 et une troisième boucle. (Rassurez-vous, il y a des méthodes plus simples, ceci est expliqué dans un but didactique : il importe simplement d’avoir compris).
105
;*********************************************************************
; DECLARATIONS DE VARIABLES *
;*********************************************************************
CBLOCK 0x00C ; début de la zone variables
cmpt1 : 1 ; compteur de boucles 1
cmpt2 : 1 ; compteur de boucles 2
cmpt3 : 1 ; compteur de boucles 3
ENDC ; Fin de la zone
Voici le code final :
;*********************************************************************
; SOUS-ROUTINE DE TEMPORISATION *
;*********************************************************************
;---------------------------------------------------------------------
; Cette sous-routine introduit un retard de 500.000 μs.
; Elle ne reçoit aucun paramètre et n'en retourne aucun
;---------------------------------------------------------------------
tempo
movlw 2 ; pour 2 boucles
movwf cmpt3 ; initialiser compteur3
boucle3
clrf cmpt2 ; effacer compteur2
boucle2
clrf cmpt1 ; effacer compteur1
boucle1
nop ; perdre 1 cycle *256 *256 *2
decfsz cmpt1 , f ; décrémenter compteur1
goto boucle1 ; si pas 0, boucler
decfsz cmpt2 , f ; si 0, décrémenter compteur 2
goto boucle2 ; si cmpt2 pas 0, recommencer boucle1
decfsz cmpt3 , f ; si 0, décrémenter compteur 3
goto boucle3 ; si cmpt3 pas 0, recommencer boucle2
return ; retour de la sous-routine
Lancez la compilation avec <F10>. Si tout s’est bien passé, vous obtenez dans votre répertoire de travail le fichier LED_CLI.HEX
Envoyez-le dans votre PIC® à l’aide de votre programmateur.
Placez le PIC® sur la carte HORS TENSION, envoyez l’alimentation et regardez bien :
VOTRE LED CLIGNOTE A LA FREQUENCE DE 1HZ.
Félicitations, voici votre premier programme embarqué. La porte est ouverte à des tonnes de nouvelles applications.

Cours disponible sur le site de Mr Bigonoff www.bigonoff.org partie1