Realiser une tempo sur microcontrolleur

Bonjour,

Est ce que quelqu'un a du code pour realiser une tempo sur microcontrolleur hc12.
genre:
/* permet d'attendre n secondes */
void Attendre (int n);

j'ai un code mais il marche pas et me fait bugger mon micro, mais je sais pas pkoi! :?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

void CycleWait(unsigned int delay) { int Endt;   Endt = TCNT+delay; /* Time (125ns cycles) to wait */   while((Endt-(int)TCNT)>0); /* wait */   }       //******** SecWait ***************   // wait 1 second, using TCNT       void SecWait(unsigned int sec) { unsigned int i,j;   for(i=0; i<sec; i++){   for(j=0; j<1000; j++){   CycleWait(8000); // 1ms wait   }   }   }

---

Merci a tous

Si tu mets un Sleep dans ton programme tu va faire une tempo et tu bouffera moins de cpu que de faire des boucle for imbriqué comme ça

c'est quoi ca? Sleep? une fonction de C? une option du microcontroleur.

est ce que tu peux etre precis avec un tout petit bout de code pour etre clair :)

Sleep c'est une fonction du systeme d'exploitation

Elle endors le thread qui execute cette instruction en gros cela te permets de faire une sorte de petite tempo exemple :

Code:

---

1 2 3 4 5

printf("Bonjour je m'apelle") ; Sleep(2000); printf("Toto");

---

Dé solé pour l'exemple j'ai pas trouvé meux
Donc j'affiche un premier message puis 2000ms apres j'en affiche un autre une tempo quoi
Ca c'est sous win et il faut inclure windows.h enfin je sais pas avec quoi tu taffes sinon sous nux c aussi Sleep mais avec un petit s :chin:

Citation:

---

Sleep c'est une fonction du systeme d'exploitation

---

Il ne peut pas mettre un sleep() qui est une fonction propre au système d'exploitation!

Il faut que tu crées toi même ta fonction delay, de préférence en assembleur sinon tu peux écrire ceci:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void Delay_100_ms(void) //avec un quartz de 8Mhz { unsigned short decrement = 7999; while(--decrement!=0) { asm{ nop nop } } }

---

Tu peux remplacer

Code:

---

1 2 3 4

asm{ nop nop }

---

par

Code:

---

1 2	nop(); nop();

---

si elle existe (c'est l'instruction qui prend juste un cycle d'horloge µc)

Je sais pas quel quartz j'ai. J'ai acheté une carte microcontroleur avec motorola hc12. (donc en effet je ne peux pas utiliser sleep)

l'idée est bonne mais je sais pas ce que c'est que ton "nop", rien?

moi je pensais a un:

Code:

---

1 2 3 4 5

void attendre(int i) { for (i=n;i>=0 ; i--); }

---

mais je ne sais pas comment calibrer mon i, je veux dire comment lui donner un ordre de grandeur... vous voyez ce que je veux dire?

le nop c l'instruction qui dis au microprocesseur de ne rien faire
Avec des boucles for tu vas bouffer du cpu Si tu peux pas utiliser sleep utilise la solution dites plus haut ca vaut mieux que des boulces for c sur

Si tu ne connais pas le quartz que tu as dessus alors tu ne seras pas capable de créer une tempo précise!
Le nop est effectivement une instruction qui ne sert à rien sauf prendre un cycle d'horloge, elle sert donc à paramétrer précisément ta tempo soft.
Je sais pourquoi ton processeur ne fonctionne pas, tu utilise le registre TCNT qui est un compteur interne à ton µc. Il faut que tu configures ce compteur et l'interruption qui va avec!

Tu peux uitiliser ta boucle for mais ta tempo ne sera pas précise.
Je te conseille quand même la boucle while (par expérience...)

james_ a dit :

Citation:

---

Tu peux uitiliser ta boucle for mais ta tempo ne sera pas précise.
Je te conseille quand même la boucle while (par expérience...)

---

:mouarf2:

La différence please ? :?: :!: :?: :!:

ca marche pas...
est ce que le style c'est pas

Code:

---

1 2 3 4 5 6 7

void attendre(int n) { int i; for (i=n;i>=0;i--) asm("nop"); }

---

Le probleme c'est qu'avec i=80000000000 il n'ya pas toujours pas d'attente... donc je me pose des questions.

mon prog principal:

Code:

---

1 2 3 4 5 6 7

void main (void) { LED_ON(vert); attendre(80000000000); LED_ON(rouge); }

---

mais les deux led s'allument en meme temps :(

juste un detail, j'ai deux trucs sur la specif qui font Mhz... :oops:

16 Mhz external clock
8 Mhz bus clock


le quartz c'est un des deux?

Citation:

---

james_ a dit :
Citation:
Tu peux uitiliser ta boucle for mais ta tempo ne sera pas précise.
Je te conseille quand même la boucle while (par expérience...)






La différence please ?

---

Je ne pense pas que tu puisses comprendre vu que ceci dépend du compilateur et du déassemblage, chose qui n'est pas utile lorsque l'on programme sous un système d'exploitation tel que W ou Unix...

------------------------------------------------------------------------------

Citation:

---

void main (void)
{
LED_ON(vert);
attendre(80000000000);
LED_ON(rouge);
}

---

C'est normal 80000000000 n'est pas un int, un int se code sur 16bits la valeur maxi est donc 65536-1, en plus un nombre int est par défaut un nombre signé et là tu as mis une valeur négative donc la tempo s'annule, essaye avec 50000.

me contacter en MP s'il faut d'autres renseignements:
---------------------------
modifié par HRS : pas de n° tel sur un forum

Oups 50000 est également un nombre négatif ;-P

Soit tu remplaces ton

Code:

---

int i

---

par

Code:

---

unsigned int i

---

,
soit tu mets la valeur maxi positif en gardant ton

Code:

---

int i = 32767;

---

l'attente n'est pas prise en compte ca c'est clair...

euh juste une question parce que la je suis plus

Code:

---

while((Endt-(int)TCNT)>0); /* wait */

---

ca s'arrête quand au juste .....?

il faut peut-être affecter Endt dans le while, c'est peut-être ca le problème...
non ?

Ben ca s'arrete quand ((Endt-(int)TCNT)>0 :lol:

je deconne, en fait je suis resté sur cette version:

Code:

---

1 2 3 4 5 6 7 8 9 10

void attendre(unsigned int n) // nb de secondes avec un quartz de 16Mhz { int i,compteur ; for(i=0;i<=20*n;i++) { compteur=13500; while (--compteur!=0); } }

---

Je sais pas si ca repond a ta question.

Voilà une tempo en assembleur 68HC11 ça devrait être le même pour HC12 mais c'est pas sur !!!

Code:

---

1 2 3 4 5 6

LDAA #$NA FTQ2 LDAB #$NB FTQ1 DECB BNE FTQ1 DECA BNE FTQ2

---

Je charge l'accu A (8bits) avec la valeur immédiate NA, l'accu B (8bits) avec la valeur immédiate NB, je décrémente B puis je le teste. Tant que B n'est pas égale à 0 je re-décrémente (BNE FTQ1). Une fois B passé à 0, je décrémente 1 fois A puis je recharge B (BNE FTQ2) avec la valeur immédiate NB et je recommence le tout, jusqu'a ce que A soit égale à 0.

Quartz 8 Mhz : 1 cycles = 500ns

Code:

---

1 2 3 4 5 6

LDAA = 2 cycles d'horloges LDAB = 2 cycles DECB = 2 cycles BNE = 3 cycles DECA = 2 cycles BNE = 3 cycles

---

Temps passe dans une boucle FTQ1 = (1 DECB) + (1 BNE) * NB
FTQ1 = 5cycles * NB

Temps passe dans la boucle FTQ2 : FTQ1 + 1 LDAB + 1 DECA + 1 BNE * NA
FTQ2 = (5cycles * NB + 7cycles ) * NA

Attention il reste 1 LDAA tout en haut donc + 2 cycles

Tempo = (5cycles * NB + 7cycles ) * NA + 2cycles

Si NA=NB=1 alors la tempo dure 14 cycles d'horloge.
Maintenant il faut voir avec ton quartz ?

Cela reste une solution, mais loin d'être la meilleur. Comme quelqu'un le fait remarqué le TIMER est la meilleur technique. Je ne suis pas expert en PC mais je pense que la fonction sleep fonctionne avec le TIMER du µP.

Dans le principe : il faut effacer le flag de débordement du TIMER puis charger une valeur dans le TCTNT puis venir scruter en boucle le flag de débordement de celui ci et une fois le flag passé à 1 (donc débordement) on sort de la boucle.

La tempo materielle est beaucoup plus courte que la tempo logiciel et cela à pour effet d'avoir une plus grande précision.

Si par exemple tu charges $FFF0 dans TCTNT celui ci débordera 15 cycles plus tard soit avec un quartz 8Mhz dans 7.5µs + quelques cycles pour sortir de la boucle

exemple:

Code:

---

1 2 3 4 5

LDX #1000 BCLR TFLG2,x $80 LDD #$FFFE STD TCTNT, x BRCLR TFLG2,x $80 *

---

Dès que TCTNT est chargé avec $FFFE on boucle sur le compteur programme, donc on fait rien, 1 cycles plus tard TCTNT vaut $FFFF => le bit TOF (Timer over flow) passe à 1 et il faut 6 cycles au BRCLR pour "réagir" et voilà donc ta tempo peut duré 7 cycles au minimum soit 3.5µs (pas mal quand même pour un µc !) tandis que la tempo logiciel dure elle 14 cycles minimum soit 7µs

Toujours avec un quartz 8Mhz sur un 68HC11.

Le code n'est peut être pas correcte je ne l'ai pas testé, mais je pense que l'idée est là, et c'est la plus propre à mon goût.

Voilà, si tu as d'autre(s) question(s)

Merci a tous et pour tout

Si tu veux écrire un timer en C (plus portable, mais bien sûr moins précis qu'un code ASM contrôlé à l'instruction près), il ne faut pas utiliser ton code : les compilateurs suppriment tout simplement la boucle :

Code:

---

int i; for (i=0; i<10; ++i);

---

ne fait rien, autant le supprimer. Par contre :

Code:

---

volatile int i; for (i=0; i<10; ++i);

---

ne sera pas modifiée car tu dis à ton compilateur que i peut être modifiée à tout instant (comprendre : il ne va pas utiliser un registre pour i, mais relire la valeur à chaque instruction).

Sinon, il faut chercher les timers que tu as sur ton micro-contrôleur. Sur PC, il y en a beaucoup. Ca va du timer à 18.6ms (interruption je sais plus quoi), à l'horloge RTC en passant par le RDTSC des CPU Pentium (= la fréquence du CPU !!!).

@+ Haypo

Salut

Je sais que dans la pluspart des micro-contrôleurs il exite des timers fait pour tous ce qui est temporisation, qui sont réglables à + ou - qql µs (dépend du quatrz). Je ne connais pas le 68hc12, mais je sais qu'il se trouve sur le même segment que le 8051, qui lui possède 2 timers minimum. Essaye de rechercher dans cette voie.
Une tempo écrite en C n'est pas viable si tu ne connais pas le code généré après compilation.
Une tempo écrite en assembleur est nettement meilleur, car tu peu connaitre le temps exacte d'execution en comptabilisant les durées de cycles de chaque instruction.
Exemple

Code:

---

1 2	MOV A,#01 ; = 1 cycle Avec 1 cycle = 1/12 de la fréquence d'horloge

---

Soit avec un quartz à 12MHz, un cycle = 12/12MHz = 1 ms. Cet exemple est bon pour un 8051, maintenant, je pense qu'un 68hc12 doit être du même calibre.

Bye...