Bonjour
pour réaliser un chrono au 1/100s avec un pic @20mhz je pensais utiliser l'interruption sur le débordement de tmr2.
dans l'idée:
- a chaque interrupt ==> ms=ms+1
- if ms=1000 alors sec=sec+1 et ms =0
....
déja peux t'on avoir un débordement toutes les 1ms?
si oui comment configuré le prescaler et postscaler (je suis un peu perdu avec le datsheet)?
si non y a t'il une autre solution?
merci
ronan
1ère reflexion:
quartz=20Mhz
prescaler = 16
postscaler =8
fosc/4= 20000/4=5000
5000*16:8=10000
j'aurai donc un débordement toutes les 10ms!
mon raisonnemnt est il bon?
Bonjour,
C'est pour un PIC16F877 ??
Si c'est le cas le tmr2 est un compteur 8 bits donc j'aurais plutôt dit qu'avec 16 et 8 ça donnerait :
20000000/4 = 5000000 instructions par sec
Soit 1 instruction toutes les : 1/5000000 = 0,0000002 sec
Ce qui fait un dépassement toutes les : 0,0000002 * 256 (8 bits) * 16 * 8 = 0,0065536 sec
Mais il est possible que je me sois embrouillé ça fait longtemps que j'ai pas touché aux PICs.
la fosc c'est bien la fréquence du quartz?
fosc=20Mhz?
Si les 20MHz ne sont pas vraiment indispensables (pour faire autre chose que le chrono en même temps par exemple) tu pourrais utiliser un quartz de 4,096 MHz et faire un débordement toutes les :
4/4096000 * 256 = 0,00025 sec
Tu mets une variable qui compte les débordements et tous les 40 passages tu sais que tu as un centième de seconde...
On peut le faire avec un quartz de 10,24 MHz aussi, ça fait un débordement toutes les :
4/10240000 * 256 = 0,0001 sec
Même système, tous les 100 passages tu peux mettre à jour l'affichage du chrono ou ce que tu veux...
Oui mais si ma mémoire est bonne on a une instruction tous les 4 cycles (cf datasheet). Donc une instruction toutes les 4/Fosc sec.Envoyé par nicolasronan
oui j'y ai pensé a utiliser un autre quartz mais en parallele en + du 20mhz comme le propose bigonoff mais j'ai peur que ce soit plus compliqué (ou plutot trop compliqué pour moi). le quartz 20mhz est necessaire pour d'autre fonction du pic.
Il n'y a pas de division qui tombe juste pour compter le temps avec un quartz de 20 MHz. Tu peux accepter d'avoir une imprécision, utiliser un autre quartz ou utiliser un module RTC qui s'occupe de gérer le temps.
Sinon je viens de penser à une solution logicielle mais je ne l'ai jamais testée :
Avec le prescaler et le postscaler à 16 tous les deux ça donne un débordement toutes les :
4/20000000 * 256 * 16 * 16 = 0,0131072 sec
Donc on sait qu'à chaque débordement il se sera écoulé 1 cs (centième de seconde) depuis la dernière fois. Mais il se sera aussi écoulé 0,0031072 sec en plus ! Il faut donc stocker cette information quelque part dans une variable et penser à compenser cette erreur de temps en temps.
Pour le reste j'espère que tu es en C sinon ça va être chaud...
Il faut deux variables globales :
long cs = 0; // nombre de centièmes écoulés au total
long hn = 0; // compteur pour stocker la "retenue"
Dans la routine d'interruption du timer tu mets :
cs = cs + 1; // A chaque débordement on sait qu'on a un centième qui s'est écoulé donc on met à jour la variable
hn = hn + 31072; // On stocke aussi ce qui s'est écoulé en plus (en centaines de nanosecondes)
// Si hn vaut plus de 100000 c'est qu'on a un centième supplémentaire donc on incrémente encore la variable cs pour reprendre le retard qu'on a accumulé
if( hn > 100000) {
++cs;
hn -= 100000;
}
Si je ne me suis pas gourré la variable cs contiendra toujours le bon nombre de centièmes écoulés depuis le déclenchement (possible de remettre tout à zéro en réinitialisant les variables cs et hn). La variable hn sert en fait à stocker la "retenue". Il faut voir aussi si ce n'est pas trop gourmand en ressources parce que les opérations en type long ça doit prendre un peu de temps mais avec un quartz de 20 MHz et vu qu'il n'y a que quelques additions ça devrait aller je pense.
Il faudra que je teste ça de toutes façons pour voir si ça marche parce que ça pourrait être utile dans certains cas...
sur abcelectronique on me propose ceci:
"Ton raisonnement est faux tu mélanges périodes et fréquences !!
La période de FOSC/4 est de 0.2 µs il faut donc la multiplier par 10000 / 0.2 = 50000 pour obtenir 10 ms, ce qui ne peut pas se faire avec les valeurs imposées pour les PRESCALER et POSTSCALER, étant donné que la division maximale est de 65536 tu ne trouveras pas de combinaisons donnant 50000 !
Il faudra incrémenter une variable dans ton interruption et déclencher le comptage tous les X passages de celle-ci par la valeur choisie !
Ex
PRESCALER=4
PR2=250
POSTSCALER=10
X=5
4x250x10x5=50000 "
a chaque foi que pr2=250 j'ai une interruption et j'incremente un compteur. quand le compteur =5 les 10ms sont passé
ca doit etre bon ca non?
Ok je vois ! J'avais oublié cette histoire de période, je sais pas pourquoi mais dans me tête ça débordait toujours à 256 alors qu'on peut évidemment lui dire de déborder à n'importe quelle valeur !
Dans ce cas en effet c'est tout simple. Cette solution est la bonne. Le timer déborde toutes les 250 instructions (c'est la période de débordement). Avec tes scalers tu multiplies ça par 40, et encore par 5 avec ta variable donc le compte est bon. A chaque fois que X arrive à 5, 10ms sont passées (ne pas oublier de la remettre à zéro).
