Temporisation réglable avec un PIC16F876A

[invitef1f90160]

Bonjour tout le monde.
J’ai besoin, pour réaliser mon projet d’une temporisation réglable. J’ai bien regardé le cours de BIGONOFF sur le sujet et il parle de boucle. Or je tourne avec un PIC16F876A ayant un quartz de 20 Mhz. Du coup je n’ai pas 1 million de cycle/seconde mais 5 million de cycles/seconde ! Ce n’est pas tout. Le temps d’un cycle avec un quartz de 20 Mhz est de 200ns soit 0.2µs ce qui est bien jolie mais qui fait que tout se passe trop vitte.

Comment dois-je faire et quel valeur utiliser pour mes compteurs afin d’avoir des tempos de 1 µs, 1 ms, 1s, 5s, 1 min et ce avec la même sous-routine?

Car la j’ai beau chercher et je tombe pour le moment dans de l’approximation. La je cherche pour le fun et le détail des opération à taper au plus juste donc en évitant les erreurs. Cependant si j’ai un faible écart cela me suffira pour mieux comprendre et l’utiliser par la suite.

Je vous remercie par ailleurs de vos indications.
Amitiés.
-----

[invitef1f90160]

Je me suis un peu plus renseigné. Il semblerais qu'il faut passer par une interruption du timer. Cela m'amène à une question. Peut t ont depuis le programme principal déplancher le timer ?

Exemple

;Programme principal

start
bsf LED1 ;Allumer la led PORTC, 0
;Valeur pour le timer de 5s
;Déclenchement du timer et des interruption avec débordement.
bcf LED1 ;Eteindre la led PORTC, 0
;Valeur pour le timer de 5s
;Déclenchement du timer et des interruption avec débordement.
goto start

voila mon petit code de départ en sachant que j'ai autoriser les interruptions du timet avec les registres concerné et que j'ai pri soin de remplir le traitement de l'interruption avec un compteur qui compte un certain nombre de passage avant de revenir de l'interruption.

J'espère que je n'ai pas trop donner d'explication ambigues. Je vous remercie par ailleur de vos réponses.
Amitiés.

[Gérard]

Bonjour,
Utilise le timer1 que tu recharges avec 50000 (traduire cette valeur en hex pour les 2 registres de TMR1)
Il y aura une interruption toutes les 0,01s
Pour ta tempo, tu peux définir une variable que tu charges avant de lancer la tempo et contiendra le nombre de fois 0,01s qu'il te faut compter pour atteindre ta tempo

ex
var = 1000
goto tempo



tempo:
if var = 0 then fin
else goto tempo

fin: goto debut

tu dois décrémenter var dans la routine d'interruption

J'espère que j'ai été clair.
Gérard.

[invitef1f90160]

Bon alors j'ai essayer d'implémenter cela dans mon programme vierge et euh en fait j'arrive bien a comprendre le system de base mais pas a l'implémenter correctement.

Je m'explique:

J'ai inclue une initialisation des registres affin d'autoriser mes interruptions sur le TMR1. cela me donne:

;***************************** ****************************** ******************
; INITIALISATIONS *
;***************************** ****************************** ******************
init

;Initialisation PORTS (banque 0 et 1)
BANK0 ;Sélectionner banque0
clrf PORTA ;Sorties PORTA à 0
clrf PORTB ;Sorties PORTB à 0
clrf PORTC ;Sorties PORTC à 0
bsf STATUS,RP0 ;Passer en banque1
movlw ADCON1VAL ;PORTA en mode digital/analogique
movwf ADCON1 ;Ecriture dans contrôle A/D
movlw DIRPORTA ;Direction PORTA
movwf TRISA ;Ecriture dans registre direction
movlw DIRPORTB ;Direction PORTB
movwf TRISB ;Ecriture dans registre direction
movlw DIRPORTC ;Direction PORTC
movwf TRISC ;Ecriture dans registre direction

;Registre d'options (banque 1)
movlw OPTIONVAL ;Charger masque
movwf OPTION_REG ;Initialiser registre option

;Registres interruptions (banque 1)
movlw INTCONVAL ;Charger valeur registre interruption
movwf INTCON ;Initialiser interruptions
movlw PIE1VAL ;Initialiser registre
movwf PIE1 ;Interruptions périphériques 1
movlw PIE2VAL ;Initialiser registre
movwf PIE2 ;Interruptions périphériques 2

;Effacer RAM banque 0
bcf STATUS,RP0 ;Sélectionner banque 0
movlw 0x20 ;Initialisation pointeur
movwf FSR ;d'adressage indirect
init1
clrf INDF ;Effacer ram
incf FSR,f ;Pointer sur suivant
btfss FSR,7 ;Tester si fin zone atteinte (>7F)
goto init1 ;Non, boucler

;Initialisation des variables


;Autoriser interruptions (banque 0)
clrf PIR1 ;Effacer flags 1
clrf PIR2 ;Effacer flags 2

bsf STATUS, RP0 ;Passer en banque 1
bsf PEIE, TMR1IE ;Autoriser les interruption du timer 1
bcf STATUS, RP0 ;Repasser en banque 0
BSF INTCON, PEIE ;Interruptions périphériques en service

bsf INTCON,GIE ;Valider interruptions

;Saut au début du programme
goto start ;Programme principal

Ensuite je saute sur mon programme principal et la j'ai juste cela:

;***************************** ****************************** ******************
; PROGRAMME PRINCIPAL *
;***************************** ****************************** ******************

start

bsf LED1 ;Allumer la led 1 au PORTC,0

movlw H'C350' ;50000

bcf LED1 ;Eteindre la led 1 au PORTC,0


goto start




END ; directive fin de programme

Pour ce qui est de ma requette d'interruption, je l'ai pas encore implémenter vue que je n'ai pas encore compris comment fonctionnais le timer en lui même au niveau code. Pour une fois que je pige la théorie et pas le code !

Enfin la je bloque sérieux

Je vous remercie encore de votre aide.
Amitiés.

[A voir en vidéo sur Futura]

[Gérard]

movlw H'C350' ;50000
ceci n'est pas possible, w étant limité à 255
tu dois aussi tester var dans une boucle pour savoir si le temps est écoulé.
Gérard.

[invitef1f90160]

Bonsoir,

Déjà la je comprend pas du tout le fonctionnement des timers. Effectivement j’arrive pas a en appeler un et a compter la moindre chose. Donc tout ceci me sert à rien. La seule chose que j’ai comprise c’est que l’on charge une valeur puis on la passe à TMR1. Ensuite on gère un certain nombres de points au niveau des registres, ça encore j’ai compris. Mais pourquoi n’y a-t-il aucun exemple de comptage en lieu et place ?

start ;Boucle logiciel
bsf LED1 ;Allume la led du PORTC,0

movlw H’10’ ;Charge la valeur du timer1
movwf TMR1 ;Dans le timer1
;Est-ce cela l’appel du timer ?
;Cela provoque quoi exactement ?

;Fin de tempo
bcf LED1 ;Eteint la led du PORTC,0

movlw H’10’ ;Charge la valeur du timer1
movwf TMR1 ;Dans le timer1

goto start ;Boucler en fin de programme


Ensuite je suppose que lorsque déjà ça comptera correctement, il suffira de gérer le comptage d’une autre variable dans la partie interruption !
Mais comment ?
Avec quel code ?

Du coup je doute qu’un pic puisse avoir une temporisation digne de ce nom ! Auquel cas il faudrait que je songe de passer a un autre type de µc ! Mais je n’y compte pas par manque de moyen et surtout maintenant que g mon ICD2 et mes 16F876A !

Je vous remercie par ailleurs de vos indications.
Amitiés.

[Gérard]

movlw H’10’ ;Charge la valeur du timer1
movwf TMR1 ;Dans le timer1

non, TMR1 possède 2 registres, TMR1L et TMR1H
--> movwf TMR1 ceci n'est pas possible, c'est
movwf TMR1L

on n'appelle pas le Timer, on le charge (si on veut une valeur précise) et on le démarre avec le bit TMR1ON du registre T1CON
(datasheet page 51)
Gérard.

[Gérard]

Dans ton prog principal

debut:
LED = 1 ;tu traduiras en assembleur
var = 1000 ;par exemple

if var > 0 then goto debut

suite:
LED = 0
var = 1000
if var > 0 then goto suite
.....

;suite prog

.....


goto debut ;boucle infinie




;routine d'interruption

TMR1IE = 0 ;flag de débordement timer1
var = var - 1 ;décrémenter var qui est testé dans le prog principal

;recharger éventuellement TMR1L et TMR1H
retfie ;pour sortir de l'IRQ

Je te conseille de lire Bigonoff et de ne pas désespérer.
Ce n'est que très rarement la faute du µC .....

Gérard.

[invitef1f90160]

J'ai les deux premiers tomes de Bigonoff mais il y a des points qui me sont assez difficile. Malgré que je pratique un peu la programmation. C'est due entre autre que c difficile de s'adapter a un cas précis. Quand à abandonnée, si j'ai réussi jusque ici sans trop de bug, je voie pas pourquoi je n'arriverais pas a comprendre le reste!

Demain je me lance dans ton code Gérard. Je te dis ou j'en suis après.

Merci beaucoup pour ton aide et tes indications. Déjà maintenant j'ai un point de départ a peaufiner

Amitiés.

[Gérard]

movlf2 macro literal,reg0
movlw literal/256
movwf reg0 + 1
movlw literal % 256
movwf reg0
endm
La macro ci-dessus permet de charger une valeur > 255 dans 2 registres consécutifs

dans les déclarations tu écris entre CBLOCK et ENDC :
var : 2 ;ce qui réserve 2 octets pour la variable

;utilisation de la macro
movlf2 var,1000 ;ceci chargera 1000 en décimal dans les 2 octets de var
Fais le test et simule dans MPLAB, ça marche.
Gérard.

[invitef1f90160]

Bonjour.

Je ne vais pas aussi vite que cela. J’essai de comprendre étape par étape.
J’espère que mon code sera visible ici -> http://pastebin.com/664374

J’ai d’abord configuré mes registres pour permettre les interruptions périphériques sur tmr1.

J’ai ensuite mis un bout de code pour l’initialisation en test dans une sous-routine. De façon à n’avoir qu’une seule fois a taper mon code de temporisation.

Si j’ai bien compris, on commence par effacer les deux registres de TMR1 avec TMR1L et TMR1H et l’on charge dans T1CON la valeur de pré division. On met en marche le timer avec un bsf T1CON, TMR1ON. Cependant est cela qui arrête le programme principal pour compter ? Ou alors cela ne fait qu’initialiser un compteur ? Si tel est le cas quel fonctionnement pour timer1 ? Par ce que la je bloque. J’ai beau relire bigonoff, je ne pige pas comment le timer compte avant l’instinction de la led. C’est d’ailleurs pour cela que je doute fort qu’un timer puisse vraiment m’aider ! A moins que quelque chose m’échappe.

J’ai essayer le code effectivement ça marche oui mais je ne voie pas non plus comment de bsf LED1, j’ai après un arrêt de programme avec une tempo de 5s puis bcf LED1 et encore la même tempo. Peut être devrais je a ce moment la virer la quasi-totalité de mon code et faire des boucle a l’ancienne façon qui elle me permettais bien de temporiser mais cela était trop rapide !

Bref je ne voie pas trop de solution !

-_-

Merci encore de vos aides qui m’aident quand même et me font voir les possibilités.

Amitiés.

[Gérard]

Il y a quelques erreurs dans ton prog.
ligne 609 : le prédiviseur divide par 2 et non par 4

ligne 620 :
tu allumes la LED
tu appelles tempo_test

dans ce s/p tu remets les compteurs à 0 (TMR1L et H)
çà ne peut pas aller.
L'idée est de compter le nb d'interruptions pour obtenir la tempo voulue.
dans le prog principal tu charges une variable avec le nb d'interruptions que tu veux et tu testes cette variable pour voir si elle est à 0 ou pas.
Dans la routine d'irq tu décrémentes la variable.

Regarde mon post n°8 et dis moi ce que tu ne comprends pas.

Gérard.

[invitef1f90160]

En fait dans la réponse 8 on fait le travail par une boucle non ?
Enfin si j'ai bien compris !
Par contre pour la routine d'interruption ca je n'ai vraiment rien compris encore. Malgrès les saines lectures! Oui je sait sur ce coup je suis vraiment null mais bon on peux pas être parfait partout ! Helas

Merci encore pour vos réponses.
Amitiés.

[Gérard]

L'irq va se produire à intervalles régulier, c'est çà qui donne l'unité de temps.
Dans le prog principal, tu définis le nombre de boucles pour arriver au temps voulu.
L'irq doit décrémenter la variable qui définit le temps total que tu veux.
OK ou pas ?
Gérard.