Temporisation pic de 5 seconde
Bonjour à tous, très ravie d’être parmi vousEst ce qu'une personne de ce forum peut me donner la méthode exacte pour écrire un programme pic de temporisation de 5 secondes . La méthode classique que je sais c'est la boucle mais quand on précise le temps de temporisation, là je ne sais pas comment l'écrire surtout comment se procède le calcul des cycles. ( et meme la méthode de calcul de cette temporisation quelle que soit 5s ou autre)
ET MERCI A VOUS
Bonsoir et bienvenue,
le mieux est d'utiliser une interruption associé à un timer.
J'ai récemment expliqué cette méthode, faites un recherche avec l'outil du forum, tapez les mots clés: temporisation+PIC
La méthode ne s'applique pas uniquement aux PIC, c'est un principe général.
Bon j'ai fait une recherche mais ça n'a rien donné
Du coup je vais recommencer.
Je ne connais pas ton µC mais je vais prendre un PIC au hasard, le PIC16F628, le principe reste général à tout timer 8 bits.
Prenons un quartz de 4MHz, cela donne une base de temps de f=4MHz/4=1MHz soit t=1µs qui est le temps d'exécution par instruction ou la cadence maximale de chaque action du µC.
Nous prenons le timer0 qui est donc un 8 bits (256 possibilités), donc il compte de 0 à 255 puis repasse à 0 etc.
Lorsqu'il passe de 255 à 0 on dit qu'il déborde, à ce moment là un flag (drapeau) est levé pour signaler ce débordement.
Pour pouvoir temporiser 5 secondes il faut pouvoir compter jusqu'à 5000000µs.
Nous savons que nous débordons au niveau du timer0 au bout de 256µs il va donc falloir utiliser un ralentisseur, c'est le rôle du prescaler ou prédiviseur.
La valeur maximale est de 256 donc appliqué à notre timer cela donnera 256*256=65536µs on est pas encore arrivé.
Il est donc possible pour atteindre ce temps d'utiliser une astuce qui consiste à compter le nombre de débordements généré en interruption pour se rapprocher au plus près de l'objectif.
Par exemple si je calcule 5000000/65536=76.294
Comme ça ne tombe pas rond je vois que si je compte 77 je compte trop, donc je vais placer un offset dans mon timer0 pour réduire l'écart, en d'autres termes au lieu de le faire partir de 0 je vais le faire partir de x.
Déterminons x:
256*(256-x)=5000000/77 => x=256-5000000/(77*256)=2.3474
Si je prends x=2 je trouve une temporisation de 5006848µs
C'est pas trop mal, nous verrons une autre façon de faire plus précise ensuite.
Voilà déjà un bon point, résumons:
-> nous utilisons un timer 8 bits, le timer0
-> avec un pré-diviseur réglé à 1:256
-> un offset valant 2
-> une précision à 6ms près
Reste à écrire le code:
C'est le principe, il te reste à le comprendre et à le mettre en œuvre dans ton application.Code:char count=0; void init_timer0() { OPTION_REG=0b00000111; // Prescaler à 1:256 TMR0=2; //offset de 2 (254 compté au lieu de 256) INTCON = 0b11100000; // Configuration du registre d'interruption : GIE=1, PEIE=1,INT0IE=1 } void interrupt() { if (TMR0IF) //Si le flag de débordement est levé { TMR0IF=0; // on remet le flag à 0 pour pouvoir détecter un prochain débordement TMR0=2: // on recharge l'offset à 2 count=count+1; // On incrémente le compteur de débordement if(count == 77) led=1; // on teste si la valeur max est atteinte et si oui on allume une led qui indiquera que 5s se sont écoulées else led=0; // si non la led reste éteinte } }
@+
PS: code non testé, je te laisse le soin de le faire
5 000 000 µs c est un quartz de 20Mhz
Je doute que le gars du post #1 ai un compilateur C !
vu le nombre de message (1) ...
On ne sais pas pour quoi faire ?
Faut il de la précision ou environ 5s suffisent ?
A t il des outils ?
Quel Pic ?
Pas compris.Envoyé par freepicbasic
Si le quartz est à 4Mhz on ne pas tourner à 5Mhz...Prenons un quartz de 4MHz, cela donne une base de temps de f=4MHz/4=1MHz soit t=1µs qui est le temps d'exécution par instruction ou la cadence maximale de chaque action du µC.
Par exemple si je calcule 5000000/65536=76.294
4Mhz / 4 = 1 000 000 µs
20Mhz / 4 = 5 000 000 µs
1000000/65536=15.2588
Serais-tu en train de dire qu'il faut nécessairement un quartz de 20MHz pour faire une tempo de 5s
Je crois que freepicbasic n'as pas lu que c’était 5 Secondes et non 1 secondes qu'il fallait compter !
@HULK28 , ce genre d'explication c'est exactement ce que je cherche à tu sais ou ! Verrais tu un inconvenient a ce que je pompe quelques peu ton post , dans un futur proche ?
C'est en faisant des erreurs; que l'on apprend le mieux !!
Ce que je poste ici n'a rien de confidentiel
Pompe ce que tu veux.
C'est du vite fait, ça peut être amélioré, il y a plusieurs manières de faire, celle-ci est la plus facile à comprendre.
Comme le disait freepicbasic tout dépend de la précision voulue.
bon , ok,
Mais introduire une erreur volontairement pour voir si le gars suit , c'est pas ma façon de faire...
(de toute façon comme je suis distrait , j'en fais déjà assez comme ça)
D'ailleurs le genre de post avec la participation d'un coup unique,
ça fait penser à des habitués qui se connecteraient sous un pseudo différent, en jouant les A...(A comme sur les voitures LOL)
Bonjour à tous les membres qui ont lu ma question. Alors, on commence à poser la problématique.
J'essaye de faire un programme asm d'une temporisation logicielle de 2 secondes pour pic 16F84, prenons une horloge de 4Mhz comme exemple.
Cette question c'est pour m'éxercer et pas une réalisation, donc je veux comprendre juste comment on peux jouer sur des instructions qui durent des cycles données selon le temps de temporisation précisés soit 2s, 5s ..... ou n'importe. C'est quoi la méthode, l'astuce???
Je ne souhaite pas réaliser la temporisation à l'aide d'un tempo mais à l'aide juste des boucles d'insctructions.
Merci d'avance
merci à vous énormément,
Note: C'est moi qui ai postée la question, sous le nom de hananeelmokhlis mais j'ai du mal à me connecter à mon compte donc j'ai crée un autre.
Voilà ce que je souhaite comprendre:
J'essaye de faire un programme asm d'une temporisation logicielle de n'importe quel durée 1s, 3s (n'importe!) pour pic 16F84, prenons une horloge de 4Mhz comme exemple ou autre , je veux juste comprendre le principe.
Remarque: Cette question c'est pour m'éxercer pour un concours prochain et pas une réalisation, donc je veux comprendre juste comment on peux jouer sur des instructions qui durent des cycles données selon le temps de temporisation précisés soit 2s, 5s ..... ou n'importe. C'est quoi la méthode, l'astuce???
Je ne souhaite pas réaliser la temporisation à l'aide d'un tempo mais à l'aide juste des boucles d'insctructions.
Merci encore une fois à tous ceux qui ont répondu à ma question au début et j'attends vos nouvelles réponses après la précision que j'ai fait (le fait que c'était juste pour comprendre le principe des boucles d'instructions pour réaliser une temporisation de quelque secondes). Je suis encore débutante, et j'essaye de comprendre pas à pas.
Si c'était possible, je souhaite un exemple de programme pour la durée de temporisation et l'horloge de vos choix, aussi la méthode que vous avez utilisés.
J'ai oubliée de mentionner que c'étais pour le pic 16F84 car c'est celui que je sais.
Je ne comprend pas !
Tu veux réaliser une temporisation sans temporisation ?? !!
Uniquement des "boucles d'instructions" ?? !!
Le moyen le plus souple pour faire n'importe quelle tempo est d'utiliser des interruptions et des boucles d'instructions (il y a toujours des boucles d'instructions !).
C'est ça que tu veux comprendre ?
Notez d'abord que la méthode de HULK28 est la meilleure !
Au début on met PORTB à 0
Ici on fait 2 boucles
5 boucles pour 5 secondes.
5 boucles de 200ms pour faire 1 seconde
Manque les bits de config
Modifier ici le 5 qui est le nombre de secondes
En appelant la procédure "Seconde" qui fait elle même 5 fois 200 ms soit 1 secondeCode:;-------- next a -------- incf ATMP,F movlw D'5'
Après cette tempo on met PORT= 255
Pour finir on bloque sur une boucle "ForEver"
Code:;******************************************* ;* PICBASIC.EXE version 3.20 (Win32 Console) du 13/05/2008 ;******************************************* ;* tst.ASM ;******************************************* W equ 00 F equ 01 CY equ 00 Z equ 02 ;-------- device 16F84 -------- List p=16F84 ,r=DEC #include <P16F84.INC> BNK0 macro bcf STATUS,RP0 bcf STATUS,RP1 endm BNK1 macro bsf STATUS,RP0 bcf STATUS,RP1 endm BNK2 macro bcf STATUS,RP0 bsf STATUS,RP1 endm BNK3 macro bsf STATUS,RP0 bsf STATUS,RP1 endm goto _START_PIC nop nop nop GOTO _INT_PIC _START_PIC ;-------- define TRISB 6 -------- TRISB EQU 6 ;-------- define PORTB 6 -------- PORTB EQU 6 ;-------- dim a,b -------- ATMP equ D'21' BTMP equ D'22' ;-------- ' define le type entrée ou Sortie -------- ;-------- ' 0 pour sortie -------- ;-------- ' 1 pour entrée -------- ;-------- init portb = 00000000 -------- bsf STATUS,RP0 movlw D'0' movwf TRISB bcf STATUS,RP0 ;-------- -------- ;-------- start: -------- START ;-------- PORTB = 0 -------- clrw movwf PORTB ;-------- for a = 1 to 5 -------- movlw D'1' movwf ATMP pb_lab1 ;-------- gosub Seconde -------- call SECONDE ;-------- next a -------- incf ATMP,F movlw D'5' movwf D'12' movf ATMP,W subwf D'12',W btfss STATUS,Z goto pb_lab1 ;-------- PORTB = 255 -------- movlw D'255' movwf PORTB ;-------- forEver: -------- FOREVER ;-------- goto forever -------- goto FOREVER ;-------- Seconde: -------- SECONDE ;-------- for b = 1 to 5 -------- movlw D'1' movwf BTMP pb_lab2 ;-------- delayMs( 200 ) -------- movlw 200 call _DELAYMS ;-------- next b -------- incf BTMP,F movlw D'5' movwf D'12' movf BTMP,W subwf D'12',W btfss STATUS,Z goto pb_lab2 ;-------- return -------- return ;-------- end -------- sleep goto _START_PIC ;************************** ;****** Library Area ****** _RAM equ 12 _RAM1 equ 13 _RAM2 equ 14 _RAM3 equ 15 _RAM4 equ 16 _RAM5 equ 17 _RAM6 equ 18 _RAM7 equ 19 _FLAGS equ 20 _PIN equ 21 _DELAYMS movwf _RAM1 clrf _RAM pb_lab4 nop nop decfsz _RAM,F goto pb_lab4 decfsz _RAM1,F goto pb_lab4 retlw 0 ;****** Library Area ****** ;************************** ; ; ;*************************** ;******* PRINT AREA ******* ;******* PRINT AREA ******* ;******* STRING AREA ******* ;======= No String ======= ;******* STRING AREA ******* ;*************************** ; _INT_PIC RETFIE end
Code::1000000005280000000000002F288316003086001D :10001000831200018600013095001820950A0530F2 :100020008C0015080C02031D0D28FF3086001728D0 :1000300001309600C8302620960A05308C0016083C :100040000C02031D1A280800630005288D008C018E :10005000000000008C0B28288D0B28280034090094 :00000001FF
oui exactement @antek
merci @freepicbasic
Voilà j'ai trouvée la méthode qui se base sur le calcul de la somme des cycles dans un document PDF, j'ai mi le lien en dessous.
http://hervepage.ch/documents/pic/calc_tempo.pdf
J'ai une question concernant cette méthode:
pour obtenir le temps que dure la première boucle, pourquoi on multiplie par 248 (voir document deuxième page, formule pour calculer le temps en cycles)
pour obtenir le temps que dure la deuxième boucle, pourquoi on multiplie par 99
pour obtenir le temps que dure la troisième boucle, pourquoi on multiplie par 9
Comme je sais pas si la réponse de freepicbasic te convient, je me fend :
PRINCIPE
Tu connais Fcy
Tu paramètres un timer et son interruption
A chaque débordement, dans le programme d'interruption tu incrémentes (ou décrémentes) une variable
En sortie d'interruption tu compares le contenu de la variable avec la valeur attendue.
Des variations sur ce principe sont envisageables.
edit : en retard . . .
Parce qu'on a 248 boucles de 4 Tcy + 1 de 3 Tcy.
oui je leur remercie bcq çà m'étais utile mais pour le moment je cherche la méthode qui se base sur le calcul des cycles comme indique le document que j'ai mis au commentaire précédent,
d'autre part est ce que vous avez consulté le document, vous avez une idée sur cette méthode?
peut m'expliquer c'est quoi Tcy et comment tu a trouvé 248
Tcy - période cycle instruction
Tosc - période horloge
Tcy = 4 Tosc
C'est expliqué dans ton document, 2eme ligne après le goto : 248 boucles de 4 Tcy et la dernière dure 3 Tcy
PS - C'est une méthode qui mobilise le µC à temps plein.
Dernière modification par antek ; 11/08/2015 à 12h05.
est ce qu'ils y'a une temporisation logicielle et autre matérielle pour le pic 16F** car j'entend beaucoup parler de ces deux là?
Quel PIC16F (y'en a des tas) ?
Montre voir où !
Les 16F ont tous des timer mais je n'ai jamais entendu parler de modules de mesure de temps.
1 + 1 + (( 1+2+1) * a) + ((1 + 2) * 1 ) = 997
2 + (( 4) * a) + (1 + 2) = 997
2 + (1 + 2) + (( 4) * a) = 997
5 + (4*a) = 997
4 * a = 997 - 5
a = 992 / 4
a = 248
prenons l'exemple de la première boucle: on a la duns rée
1+1+(1+1+2)*248+(1+2)*1=997 cycles , les caractères que j'ai soulignée me semble flou, ambiguù je ne sais pas d'où çà vient.
comment peut savoir qu'on doit multiplie par 248, et le terme (1+2)*1 d'où vient t'il
pardonnez moi si je pose des questions qui vous emblent banale mais je voit rien de clair. Est ce que vous pouvez m'expliquer pas à pas pour que je comprend au moins juste cet exemple.
merci @freepic je suis entrain de lire votre réponse.
d'accord avec vous @antek ily'on a des timers internes
