programmation C du 12f629

[marc2009]

Après, tout dépend de la précision souhaitée.

Hmm pied de parasol démarrage moteur pendant 1 seconde toutes les 20 minutes. ( donc la précision est quand même importante, enfin pas trop à négliger )

Pas sûr d'avoir été clair.

Ben je ne te caches pas que je n'arrive pas à comprendre ce que tu me dis depuis le début malgré le fait que je relis, relis et relis ce que tu as écrit, j'essaie de faire des calculs pour voir mais rien
Mais je dois comprendre, car si on me pose des questions à l'oral, je dois savoir quand même répondre.

Je vois où te veux me mener ( avec ton exemple du quartz de 3,2768MHz ), donc on aurait 25 interruptions par secondes, et donc on incrémenterait une variable temps par exemple qui, arrivée à une valeur ( 20 minutes donc 1200 ), exécute une commande ( démarrage moteur ), puis 1 seconde plus tard arrête le moteur reste à savoir comment on arrive à ça.

Merci
-----

[Gérard]

Reprenons :
tu as besoin d'un signal à "1" pendant 1 seconde et à "0" pendant 19mn et 59s.

Si j'ai juste :
Qz 3,2768MHz, TMR1 initialisé et rechargé dans l'IRQ à 80h,
une variable CPT initialisé à 0 et incrémentée à chaque IRQ.

Quand CPT = 25, CPT = 0 et SEC = SEC + 1 (SEC initialisée à 0, compte les secondes)
Quand SEC = 0, alors OUT = 1
Quand SEC = 1, alors OUT = 0
Quand SEC = 1199, alors SEC = 0 (20mn - 1s)

SEC devra être une variable de type word (2 octets)

Tu auras la précision du Qz qui n'est pas si mauvaise.

As-tu tout compris ?

[marc2009]

Reprenons :
tu as besoin d'un signal à "1" pendant 1 seconde et à "0" pendant 19mn et 59s.

Si j'ai juste :
Qz 3,2768MHz, TMR1 initialisé et rechargé dans l'IRQ à 80h,
une variable CPT initialisé à 0 et incrémentée à chaque IRQ.

Quand CPT = 25, CPT = 0 et SEC = SEC + 1 (SEC initialisée à 0, compte les secondes)
Quand SEC = 0, alors OUT = 1
Quand SEC = 1, alors OUT = 0
Quand SEC = 1199, alors SEC = 0 (20mn - 1s)

SEC devra être une variable de type word (2 octets)

Tu auras la précision du Qz qui n'est pas si mauvaise.

As-tu tout compris ?

Pourquoi pendant 19min et 59sec ? Car elle dure 20 minutes la "tempo".

Pourquoi recharger TMR1H avec une valeur de 128 ? ( 80h ) Tous les combien de temps est incrémenté le tmr1 ? ( par exemple, avec tmr0, on a une incrémentation toutes les 256us si utilisé avec un prédiviseur à 1:256, ou toutes les 1us si utilisé avec un prédiviseur à 1:1, comme ici avec le tmr1 ) Sinon, je vois ce que tu veux dire.

Merci

[Gérard]

Pourquoi pendant 19min et 59sec ? Car elle dure 20 minutes la "tempo".

Tu veux marche pendant 1s et arrêt pendant 20mn, tu remplaces 1199 par 1200.

Pourquoi recharger TMR1H avec une valeur de 128 ? ( 80h )

Pour avoir un nombre entier d'interruptions par secondes.

Tous les combien de temps est incrémenté le tmr1 ? ( par exemple, avec tmr0, on a une incrémentation toutes les 256us si utilisé avec un prédiviseur à 1:256, ou toutes les 1us si utilisé avec un prédiviseur à 1:1, comme ici avec le tmr1 ) Sinon, je vois ce que tu veux dire.

Merci

Si TMRCS est (comme dit hier !) = 0, c'est la fréquence du Qz/4 qui entre dans le prédiviseur .... déjà expliqué hier.

Il faut consulter les datasheet, c'est là pour.
Le schéma interne de TMR1 est simple à comprendre.

Pour ce que tu dis de TMR0, ce n'est valable que pour un Qz de 4MHz.

[marc2009]

Tu veux marche pendant 1s et arrêt pendant 20mn, tu remplaces 1199 par 1200.

oui

Pour avoir un nombre entier d'interruptions par secondes.

Oui, mais tu as fait un calcul pour trouver 128, non ?

Car si je mets 128 sans savoir d'où ça vient ...

Si TMRCS est (comme dit hier !) = 0, c'est la fréquence du Qz/4 qui entre dans le prédiviseur .... déjà expliqué hier.

oui, mais ce n'était pas ma question

je vais tenter d'y répondre.

Pour ton exemple, on a un quartz de 3,2768MHz. Donc une fréquence qui sort du prédiviseur ( avec 1:1 ) de 819 200 Hz.

Donc on a une incrémentation toutes les 1 / 819200 = 1.2207.. us, tu es d'accord ?

[Gérard]

oui

Oui, mais tu as fait un calcul pour trouver 128, non ?

Car si je mets 128 sans savoir d'où ça vient ...

oui, mais ce n'était pas ma question

je vais tenter d'y répondre.

Pour ton exemple, on a un quartz de 3,2768MHz. Donc une fréquence qui sort du prédiviseur ( avec 1:1 ) de 819 200 Hz.

Donc on a une incrémentation toutes les 1 / 819200 = 1.2207.. us, tu es d'accord ?

La fréquence qui sort du pré-diviseur est de 819200Hz (avec Qz = 3,2768MHz, pré-diviseur = 1 et TMR1CS = 0), nous sommes d'accord.

Si TMR1L et TMR1H sont = 0, il faut 65536 impulsions pour avoir un débordement. Dit autrement, on divise la fréquence d'entrée par cette valeur (65536), on a donc une fréquence de sortie de 12,5 Hz.
En mettant 128 dans TMR1H, sur 16 bit, TMR1 = 8000h, soit 32768.
Il faudra donc 32768 impulsions pour faire déborder TMR1.

Dit autrement, avec 8000h, TMR1 est à moitié plein, il faut donc y mettre encore une fois autant (32768) pour le faire déborder.

Et du coup, la fréquence de débordement est de 25Hz --> nombre entier. On retombe sur nos pieds (heureusement)

Et je dis : si tu as compris !

Nous irons (avec modération quand même)

[Gérard]

Hier je t'ai dit qu'on pouvait avoir 50 IRQ.
Avec TMR1 = C000h (soit 1100 0000 0000 0000b), en fait, le 2 bit de poids fort rechargé à chaque IRQ), on remplit TMR1 avec la valeur 49152 (C000h), il ne faut plus que compter 16384 impulsions pour déborder et du coup --> la fréquence d'IRQ est de 50 Hz. (819200/16384)

PS : IRQ = interruption

[marc2009]

Si TMR1L et TMR1H sont = 0, il faut 65536 impulsions pour avoir un débordement.

Nous sommes d'accord. ( spécifique au timer1 )

Dit autrement, on divise la fréquence d'entrée par cette valeur (65536), on a donc une fréquence de sortie de 12,5 Hz.

je vais la faire autrement pour être sûr d'avoir compris avec ma manière : on a une incrémentation toutes les 1 / 819200 Hz sec. Or pour avoir un débordement, il faut 65536 incrémentations, soit 65536 * ( 1 / 819200 Hz ) = 0.08 sec soit 80ms donc on a un débordement tous les 80ms ==> 1 / 80.10-3 = 12.5 Hz ! ( f = 1 / T donc T = 1 / f )

En mettant 128 dans TMR1H, sur 16 bit, TMR1 = 8000h, soit 32768.

Et là je comprends pas Bon faut aussi dire que je suis perdu avec les TMR1L, TMR1H et TIMER1

Quelles sont les valeurs limites de TMR1H ? car dans les précédents, tu parlaient de TMR1 ( où tu mettais 128 ) et là tu dis TMR1H à 128

Merci ( beaucoup pour tous tes explications ! ) @++

[Gérard]

Nous sommes d'accord. ( spécifique au timer1 )

Heureusement.

je vais la faire autrement pour être sûr d'avoir compris avec ma manière : on a une incrémentation toutes les 1 / 819200 Hz sec. Or pour avoir un débordement, il faut 65536 incrémentations, soit 65536 * ( 1 / 819200 Hz ) = 0.08 sec soit 80ms donc on a un débordement tous les 80ms ==> 1 / 80.10-3 = 12.5 Hz ! ( f = 1 / T donc T = 1 / f )

Ouf, on vient de prouver que T = 1/f

Et là je comprends pas Bon faut aussi dire que je suis perdu avec les TMR1L, TMR1H et TIMER1

Quelles sont les valeurs limites de TMR1H ? car dans les précédents, tu parlaient de TMR1 ( où tu mettais 128 ) et là tu dis TMR1H à 128

Ce PIC travaille avec des registres de 8 bit.
Le Timer 1 compte sur 16 bit.
Il a bien fallu trouver une solution :
TMR1 = TMR1H suivi de TMR1L
TMR1H est l'octet de poids fort du mot de 16 bit qui s'appelle TMR1
TMR1L est l'octet de poids faible du mot de 16 bit qui s'appelle TMR1

Merci ( beaucoup pour tous tes explications ! ) @++

Pas de quoi, le tout, c'est de ne pas se décourager.
L'apprentissage de ces bestioles n'est pas toujours facile.

Maintenant, c'est les plumes, demain matin, le réveil n'a pas de pitié.

[marc2009]

attends un peu, je vois d'où vient le 128 !

On a un total d'incrémentations de 65536 ! Or si TMR1H = 128; ( ou il faudra mettre TMR1 = 128; ? ) Il ne reste plus que 65536 - 128 = 65408 incrémentations restantes avant un débordement ( qui va déboucher sur une interruption )

or la valeur hexadécimal de 65408 est 0xFF80. Or

TMR1H est l'octet de poids fort du mot de 16 bit qui s'appelle TMR1

donc TMR1H = 0x80 soit 128 et TMR1L = 0xFF soit 255

Mais TMR1L est toujours égale à 255 ? Ou c'est fait exprès pour ainsi prendre la moitié de 65536 ?

++

[Gérard]

attends un peu, je vois d'où vient le 128 !

On a un total d'incrémentations de 65536 ! Or si TMR1H = 128; ( ou il faudra mettre TMR1 = 128; ? ) Il ne reste plus que 65536 - 128 = 65408 incrémentations restantes avant un débordement ( qui va déboucher sur une interruption )

or la valeur hexadécimal de 65408 est 0xFF80. Or donc TMR1H = 0x80 soit 128 et TMR1L = 0xFF soit 255

Mais TMR1L est toujours égale à 255 ? Ou c'est fait exprès pour ainsi prendre la moitié de 65536 ?

++

Relis bien ce que j'ai écris en #39.
Les 16 bit de TMR1 sont en fait l'assemblage de 2 registres 8 bit, TMR1L et TMR1H.
Si tu mets 128 (80h) dans TMR1H, TMR1 vaut 8000h.
Le débordement interviendra quand TMR1 passera de FFFFh à 0000h.

8000h = 32768 en décimal, il faut encore compter autant pour déborder.
FFFFh = 65535, si tu ajoutes 1, on a 0000h.

Ce n'est pas 65536 - 128 mais 65536 - 32768

Autre question ?

[marc2009]

Les 16 bit de TMR1 sont en fait l'assemblage de 2 registres 8 bit, TMR1L et TMR1H.

D'accord. Mais alors ils seraient des registres sans paramètres, n'est ce pas ?

Si tu mets 128 (80h) dans TMR1H, TMR1 vaut 8000h.

et voilà Pourquoi ?

Le débordement interviendra quand TMR1 passera de FFFFh à 0000h.

Je suis d'accord.

Ce n'est pas 65536 - 128 mais 65536 - 32768

Car il faut 65536 - 32768 = 32768 incrémentations encore à réaliser avant un débordement.

8000h = 32768 en décimal, il faut encore compter autant pour déborder.
FFFFh = 65535, si tu ajoutes 1, on a 0000h.

Là non plus j'ai pas compris. TMR1H doit effectivement compter encore 32768 incrémentations ( donc passage état haut/bas à état bas/haut n'est ce pas ? ) mais pourquoi TMR1L 1 seulement ? Car lorsque TMR1H s'incrémente, TMR1L ne s'incrémente pas avec ?

Merci

[Gérard]

D'accord. Mais alors ils seraient des registres sans paramètres, n'est ce pas ?

C'est quoi des registres sans paramètres ?
Un registre est une case mémoire qui peut contenir 255 au max.
Sauf dans le cas qui nous occupe où on compte sur 16 bit.
On va de 0000 0000 0000 0000 à 1111 1111 1111 1111.

Là non plus j'ai pas compris. TMR1H doit effectivement compter encore 32768 incrémentations ( donc passage état haut/bas à état bas/haut n'est ce pas ? ) mais pourquoi TMR1L 1 seulement ? Car lorsque TMR1H s'incrémente, TMR1L ne s'incrémente pas avec ?

Merci

TMR1H et TMR1L compte comme 1 seul registre, on "verse" des "1" dans TMR1L, quand il arrive à 255, le "1" suivant va faire TMR1L = 0 et TMR1H + 1

Si TMR1H =1 et TMR1L = 0, alors TMR1 = 256 (2^8).

[marc2009]

C'est quoi des registres sans paramètres ?

Je veux dire par là que ce n'est pas un "registre" comme ceux du datasheet avec des paramètres ( comme OPTION par exemple ) puisque TMR1H et TMR1L ne vont contenir que des valeurs.

TMR1H et TMR1L compte comme 1 seul registre, on "verse" des "1" dans TMR1L, quand il arrive à 255, le "1" suivant va faire TMR1L = 0 et TMR1H + 1

donc ça fonctionne un peu comme TMR0 : on a une incrémentation/impulsion ( passage état haut/bas à état bas/haut ) toutes les 1 / 819200 Hz = 1.2207 us et l'incrémentation est "validée" lors du passage de 255 à 0 de TMR0, tu es d'accord jusque là ? Bon entre le moment où il va commencer à "compter" de 0 à 255 avant de déborder et ainsi incrémenter une seconde variable, c'est ce que toi tu appelles "verser des 1". Bon pour TMR0, c'est la fréquence du quart divisée par la valeur du prédiviseur. ( donc ici 1:4 mais on s'intéresse à TMR1 )

C'est juste pour être sûr que l'on parle de la même chose, et que je comprenne déjà jusque là

Donc avec TMR1, TMR1L va "jouer" le rôle de TMR0 en comptant de 0 à 255 pour incrémenter une seconde variable qui est donc TMR1H, et là j'ai comprend d'où tu sors le 128 et le 32768

Comme on prend TMR1H = 128; au début ( et on le garde tout au long du programme ), TMR1L compte au maximum 256, et donc 128 * 256 = 32768 Donc il lui reste 65536 - 32768 = 32768 impulsions restantes !
Si on met TMR1H = 0; au début, il devra compter 256 * 256 = 65536 impulsions avant de déborder ( donc passage de TMR1H de 255 à 0 et TMR1L est donc aussi égale à 0 )

J'ai tout juste jusque là Chef ?

@++

[marc2009]

je continue : donc comme on a 32768 impulsions restantes, on aura un débordement toutes les 32768 * ( 1 / 819200 ) = 40 ms ( car on a calculé au post #38 : 65536 * ( 1 / 819200 Hz ) = 0.08 sec soit 80ms donc on a un débordement tous les 80ms ).

soit f = 1 / T donc f = 1 / 0.04 = 25 interruptions par secondes pour un quartz de 3.2768 MHz, avec TMR1H = 128; et TMR1L = 0; ( TMR1H devra toujours être réinitialisée à 128 ) et un prédiviseur à 1:1.

J'ai tout juste Chef jusque là ?

[Gérard]

Je veux dire par là que ce n'est pas un "registre" comme ceux du datasheet avec des paramètres ( comme OPTION par exemple ) puisque TMR1H et TMR1L ne vont contenir que des valeurs.

Un registre est un registre, c'est une case de RAM.
Ceux dont tu parles, s'appellent SFR (Special Function Register).
C'est de la RAM comme les autres, ils ont juste une affectation particulière pour le fonctionnement du µC.

donc ça fonctionne un peu comme TMR0 : on a une incrémentation/impulsion ( passage état haut/bas à état bas/haut ) toutes les 1 / 819200 Hz = 1.2207 us et l'incrémentation est "validée" lors du passage de 255 à 0 de TMR0, tu es d'accord jusque là ? Bon entre le moment où il va commencer à "compter" de 0 à 255 avant de déborder et ainsi incrémenter une seconde variable, c'est ce que toi tu appelles "verser des 1". Bon pour TMR0, c'est la fréquence du quart divisée par la valeur du prédiviseur. ( donc ici 1:4 mais on s'intéresse à TMR1 )

C'est juste pour être sûr que l'on parle de la même chose, et que je comprenne déjà jusque là

Donc avec TMR1, TMR1L va "jouer" le rôle de TMR0 en comptant de 0 à 255 pour incrémenter une seconde variable qui est donc TMR1H, et là j'ai comprend d'où tu sors le 128 et le 32768

TMR0 est un compteur sur 8 bit, TMR1 est un compteur sur 16 bit.
Quand TMR1L passe de 255 à 0, TMR1H est incrémenté.

Comme on prend TMR1H = 128; au début ( et on le garde tout au long du programme ), TMR1L compte au maximum 256, et donc 128 * 256 = 32768 Donc il lui reste 65536 - 32768 = 32768 impulsions restantes !

Non, TMR1H ne reste pas à 128, il est incrémenté à chaque fois que TMR1L passe de 255 à 0.
Comme au départ TMR1H est à 128, il ne lui reste que 128 à compter pour déborder.

Si on met TMR1H = 0; au début, il devra compter 256 * 256 = 65536 impulsions avant de déborder ( donc passage de TMR1H de 255 à 0 et TMR1L est donc aussi égale à 0 )

J'ai tout juste jusque là Chef ?

@++

La c'est bon, je crois que tu as compris.

[marc2009]

Quand TMR1L passe de 255 à 0, TMR1H est incrémenté.

C'est ce que j'ai dit, non ?

Non, TMR1H ne reste pas à 128, il est incrémenté à chaque fois que TMR1L passe de 255 à 0.
Comme au départ TMR1H est à 128, il ne lui reste que 128 à compter pour déborder.

je disais qu'au début, il fallait lui mettre 128, c'est faux ? ( TMR1H = 128;, au début du programme C )

La c'est bon, je crois que tu as compris.

ahhh oufff !! Merci encore Gérard. On peut alors passer à la suite ?

[Gérard]

Dans la routine d'IRQ, il faut chaque fois écrire 128 dans TMR1H.
Il faut aussi effacer TMR1IF.

[marc2009]

Dans la routine d'IRQ, il faut chaque fois écrire 128 dans TMR1H.
Il faut aussi effacer TMR1IF.

par contre, j'ai fait une bonne trentaine de calculs mais je n'ai rien trouvé pour 4MHz ! Car si j'ai bien compris, il faut :

( x est le nombre à mettre dans TMR1H au début )
- x * 256 = une valeur y cette valeur y doit être soustraite à 65536, puis avec le résultat noté z de cette différence, on fait 1 000 000 / z pour trouver le nombres d'IRQ par secondes, j'ai juste ?

Sinon, nous pouvons également utiliser Timer0 sur le même modèle, non ?

si on utilise un OPTION à 11001000 ( donc TOCS à 0, horloge interne, donc Fosc / 4 et PSA sur watchdog pour garder un prédiviseur à 1 sur le timer0 et un prédiviseur à 000 ), on met dans TMR0 au début TMR0 = 6; donc il reste 256 - 6 = 250 incrémentations à faire ; et 1 000 000 / 250 = 4 000 IRQ / s, c'est juste ? mais ça fait beaucoup et pour 1200 secondes, ça dépasse le nombres de chiffres autorisés !

Donc je vais devoir me rabattre sur le timer1 Si je trouve des nombres adéquats

[marc2009]

Si tu aurais une solution pour avoir un nombre entier d'interruptions par seconde, je suis preneur ( avec un quartz de 4MHz et oscillateur interne et en mode timer, soit Fosc / 4, comme avec ton exemple de quartz à 3.2768 MHz )
J'ai encore essayé en prenant 4 valeurs de fréquences suivant le prédiviseur du timer1 ( 1:1, 1:2, 1:4 et 1:8 ) et en essayant de trouver un nombre entier mais nada

Merci bien ( si tu as une autre solution, je suis aussi preneur )
++

[Gérard]

Si tu aurais une solution pour avoir un nombre entier d'interruptions par seconde, je suis preneur ( avec un quartz de 4MHz et oscillateur interne et en mode timer, soit Fosc / 4, comme avec ton exemple de quartz à 3.2768 MHz )
J'ai encore essayé en prenant 4 valeurs de fréquences suivant le prédiviseur du timer1 ( 1:1, 1:2, 1:4 et 1:8 ) et en essayant de trouver un nombre entier mais nada

Merci bien ( si tu as une autre solution, je suis aussi preneur )
++

Justement, avec 4MHz, il n'y a pas de chiffre rond.

[marc2009]

Justement, avec 4MHz, il n'y a pas de chiffre rond.

ah mince !! Aurais-tu une autre solution à me proposer stp ? ( donc j'ai fait les calculs pour rien !! T'aurais pu me le dire ! )

Je suis preneur de toute autre solution.

Merci encore.

[Gérard]

ah mince !! Aurais-tu une autre solution à me proposer stp ? ( donc j'ai fait les calculs pour rien !! T'aurais pu me le dire ! )

Je suis preneur de toute autre solution.

Merci encore.

Je te l'ai dit au post #26.

[marc2009]

ben oui, comme tu l'as dit, les résultats ne seront pas des nombres entiers, doncje ne pourrais pas les utiliser dans le programme C

Si tu as une idée, bien sûr je suis preneur

Pour ma part, je te propose ceci, dis moi ce que tu en penses, j'utilise une platine velleman k8048 :

#pragma chip PIC12F629
#pragma library 1
#pragma config = 0x30E4
#define sortie GPIO
unsigned temps : 16;
bit led1 @ GPIO2;
char newtmro;

void main(void)

{
	OSCCAL = 0b10000000;
	TRISIO = 0b11111011;
	OPTION = 0b11000101;
	CMCON =  0b00000111;
	sortie = 0;
	newtmro = TMR0+1;
	TMR0=0;
for (;;) {
    if (TMR0 ==newtmro) {++temps; ++newtmro;} //64us sont passés
	
	if (temps ==15625) 
		{
			led1=!led1; 
			temps=0;
		} 
}
}

donc la led1 reliée au port GP2 du 12f629 va clignoter toutes les secondes ( 1 seconde allumée et 1 seconde éteinte mais je suis sûr que tu as compris le programme )

Merci de tes précieux avis.
++

[Gérard]

Je suis nul en C et ne cherche pas à m'améliorer.

Je ne vois pas de routine d'interruption dans ton prog, c'est normal ?

[marc2009]

Je suis nul en C et ne cherche pas à m'améliorer.

Je ne vois pas de routine d'interruption dans ton prog, c'est normal ?

Déjà, ce programme ne me servira à rien pour l'utilisation dans le pied puisque temps est au maximum égal à 65535 ! Or là on va être largement au dessus ! Par contre, il y a un problème avec l'oscillateur ( j'en ai parlé avec alainav1 ), ça avance, ou ça retarde suivant son envie, là avec ce programme j'ai moins qu'une seconde ! donc sur une minute, je peux tomber jusqu'à plusieurs secondes d'erreurs, ce qui n'est pas génial.

Bon, sinon pour les routines d'interruptions, comment pourrais je faire pour avoir un nombre entier ? Car oui j'obtiens des nombres à virgules, et donc je ne peux pas les utiliser Si tu as des propositions, je suis preneur

Merci encore.

[Gérard]

Utilise un quartz au lieu de l'oscillateur interne, ce sera plus précis.

As-tu chargé OSCCAL ?

[marc2009]

Utilise un quartz au lieu de l'oscillateur interne, ce sera plus précis.

As-tu chargé OSCCAL ?

1- ben si je pouvais utiliser un quartz de 3.2768 MHz, ce serait super, je pourrais utiliser ta méthode !

2- dans le datasheet, OSCCAL peut prendre plusieurs valeurs : soit maximum frequency, soit center frequency soit minimal frequency. Bon moi je l'ai mis à "center frequency", donc il me semble OSCCAL=0b10000000;

Par contre, la valeur de l'oscillateur OSCCAL, celle dont il ne faut pas perdre la valeur, ben je l'ai pas C'est pour ça que je pense que lundi, je vais en racheter un autre, ou sinon, je prend un quartz externe et donc je n'aurais plus besoin de OSCCAL, n'est ce pas ?

Merci

[Gérard]

Si tu fais une lecture du PIC, la valeur à charger dans OSCCAL se trouve à la dernière adresse.

Si tu prends un QZ, achète un 3,2768MHZ et le problème sera résolu.

[marc2009]

Si tu fais une lecture du PIC, la valeur à charger dans OSCCAL se trouve à la dernière adresse.

Si tu prends un QZ, achète un 3,2768MHZ et le problème sera résolu.

1- je vais l'acheter demain, et je la noterai soigneusement ! Par contre, comment tu le mets dans un programme en C ? Je veux dire comment tu le paramètres ? ( à moins que cette valeur soit dans la EEprom auquel cas je devrais faire attention à ne pas supprimer les données de celles-ci )

2- Je doute que ce quartz soit disponible dans les magasins d'électronique, à moins qu'il soit très utilisé ?! ( par exemple chez Bric électronique, à Strasbourg ? )
Si j'utilise un quartz externe, je devrais alors le relier au port GP4 et GP5, n'est ce pas ? Et donc, OSCCAL ( la valeur et le registre du datasheet ) ne seront plus important, puisque j'utiliserais un quartz externe, dis moi si je me trompe.

Merci @++