Discussion :

[Goetz]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[hegros]

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

[Goetz]

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

[hegros]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[James_]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
asm{
    nop
    nop
    }

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
nop();
nop();

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

[Goetz]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[hegros]

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

[James_]

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...)

[hegros]

james_ a dit :

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 ? : :

[Goetz]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Goetz]

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

16 Mhz external clock
8 Mhz bus clock


le quartz c'est un des deux?

[James_]

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...

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

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

[James_]

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

Soit tu remplaces ton

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

unsigned int i

,
soit tu mets la valeur maxi positif en gardant ton

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int i = 32767;

[Goetz]

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

[boborde]

euh juste une question parce que la je suis plus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Goetz]

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Vincent PETIT]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[Goetz]

Merci a tous et pour tout

[haypo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

ne fait rien, autant le supprimer. Par contre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Elijha]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...