Répondre à la discussion
Affichage des résultats 1 à 6 sur 6

Temporisation d'une seconde avec un microcontroleur PIC 16F877



  1. #1
    lemecdeparis

    Temporisation d'une seconde avec un microcontroleur PIC 16F877

    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.

    -----


  2. Publicité
  3. #2
    Franck-026

    Re : Temporisation d'une seconde avec un microcontroleur PIC 16F877

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

  4. #3
    lemecdeparis

    Re : Temporisation d'une seconde avec un microcontroleur PIC 16F877

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

  5. #4
    Franck-026

    Re : Temporisation d'une seconde avec un microcontroleur PIC 16F877

    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.

    Code:
    ; 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
    Dernière modification par Franck-026 ; 12/12/2011 à 18h16.

  6. #5
    lemecdeparis

    Re : Temporisation d'une seconde avec un microcontroleur PIC 16F877

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

  7. A voir en vidéo sur Futura
  8. #6
    Franck-026

    Re : Temporisation d'une seconde avec un microcontroleur PIC 16F877

    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:

    Code:
    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
    Dernière modification par Franck-026 ; 12/12/2011 à 18h44.

  9. Publicité

Sur le même thème :

Discussions similaires

  1. Diode RGB avec PIC 16F877
    Par melkaone dans le forum Électronique
    Réponses: 7
    Dernier message: 01/03/2012, 16h02
  2. Test servomoteur avec PIC 16F877
    Par magnatik dans le forum Électronique
    Réponses: 1
    Dernier message: 09/06/2011, 22h00
  3. Calcule de vitesse avec un pic 16f877
    Par sympahomme dans le forum Électronique
    Réponses: 3
    Dernier message: 09/03/2011, 15h30
  4. Premier pas avec le pic 16F877
    Par amirabou dans le forum Électronique
    Réponses: 1
    Dernier message: 12/11/2010, 00h55
  5. Réponses: 0
    Dernier message: 18/03/2007, 15h43