Essai PIC 16F628 en langage C

[invitee0b95ad8]

Bonjour à tous,

Voilà, je tente de faire du C, et j'ai un soucis de "facteur 16".

En testant le code ci-dessous, je tombe sur des durées de cycles environ 16 fois supérieur à ce qui est prévu.
Auriez vous une idée du problème ?

Merci pour votre aide

#include <pic16f62xa.h>

#define duree1 0x0019
#define duree2 0x001F //2 fois = 1kHz 1F4 ,ormalement
#define duree3 0xFFFF

#define RG RA3
#define OG RB0
#define VG RB1
#define RD RA1
#define OD RA0
#define VD RB4

#define FilBleu RB2
#define FilNoir RA7



int nombre;
void tempo(unsigned int duree);

void main(void)
{

PORTA=0x00;
PORTB=0x00;

CMCON=0b00000111;

EEADR=0b00000000;

OPTION=0b01001110;
OSCF=1; //4MHz soit 1us par instruction
T0IF=0; //

TRISA=0b11100000;
TRISB=0b00000000; //RB2 en sorite notamment

VRCON=0x00;//à enlever ?
FSR=0x0C; //à enlever ?



PORTA=0x00;
PORTB=0x00;

//Tâche principale
while(1){
FilBleu=1; //3 cycles
RG=1; //1 cycle
tempo(100);
FilBleu=0; //3 cycles
RG=0; //1 cycle
tempo(100);

}
}



void tempo(unsigned int duree)
{
// cycles
nombre=duree; //6 cycles
do
{
}
while(nombre--); //1 cycle * durée
}

-----

[invitee0b95ad8]

Dans cet exemple, duree=100 quand j'appelle la tempo, et elle dure 1,6ms selon mon oscilloscope, alors que je visais 1us (durée d'un cycle, vérifié par oscillo sur la patte CLKOUT) * 100.

[invited8c72a90]

Salut,

faudrait voir le code assembleur qui est généré, mais dans le meilleur des cas, ta boucle do-while va se traduire à peu près comme ça en assembleur:

boucle
  decfsz  nombre    ; 1 cycle
  goto boucle       ; 2 cycles

soit au minimum 3 cycle et donc 3 µs par tour de boucle, ce qui nous amène plus ou moins à 300 µs pour une boucle de 100 tours.

pour les 1.3 ms en rab, je sais pas trop... faudrait voir l'assembleur que ton code génère...

ce sont les instructions assembleurs qui prennent chacune 1 cycle (hormis les sauts qui en prennent 2).
une instruction en C est la plupart du temps traduite en plusieurs instructions assembleur.

[invitee0b95ad8]

Voilà la fin du code assembleur, en espérant qu'il ne soit pas trop lourd à lire...

59: //Tâche principale
60: while(1){
61: FilBleu=1; //3 cycles
7EC 1283 BCF 0x3, 0x5
7ED 1303 BCF 0x3, 0x6
7EE 1506 BSF 0x6, 0x2
62: RG=1; //1 cycle
7EF 1585 BSF 0x5, 0x3
63: tempo(100);
7F0 3064 MOVLW 0x64
7F1 00F0 MOVWF 0x70
7F2 3000 MOVLW 0
7F3 00F1 MOVWF 0x71
7F4 2770 CALL 0x770
64: FilBleu=0; //3 cycles
7F5 1283 BCF 0x3, 0x5
7F6 1303 BCF 0x3, 0x6
7F7 1106 BCF 0x6, 0x2
65: RG=0; //1 cycle
7F8 1185 BCF 0x5, 0x3
66: tempo(100);
7F9 3064 MOVLW 0x64
67:
68: }
69: }
70:
71:
72:
73: void tempo(unsigned int duree)
74: {
75: // cycles
76: nombre=duree; //6 cycles
770 0871 MOVF 0x71, W
771 01F3 CLRF 0x73
772 07F3 ADDWF 0x73, F
773 0870 MOVF 0x70, W
774 01F2 CLRF 0x72
775 07F2 ADDWF 0x72, F
77: do
78: {
79: }
80: while(nombre--); //1 cycle * durée
776 30FF MOVLW 0xff
--- W:\PIC\27avril2011\test_c.as ---------------------------------------------------------------
1: opt subtitle "HI-TECH Software Omniscient Code Generator (Lite mode) build 5239"
2:
3: opt pagewidth 120
4:

J'ai l'impression que la partie "while" se contente d'une instruction :
30FF MOVLW 0xff

[A voir en vidéo sur Futura]

[invited8c72a90]

le code que tu as copié est assez illisible avec le mélange entre les instructions C et assembleur, ça me plait pas trop

ce qu'on peut déjà y voir en tout cas (on peut le voir aussi en C en fait mais ça m'a moins sauté aux yeux) c'est que ta variable nombre est sur 16 bits et donc sur 2 cases RAM, et que donc, le code qui fait la boucle est sans doute plus complexe que ce que j'ai écrit au début.

en tout cas, ça m'étonnerait bien que le code de la boucle soit seulement traduit par le "MOVLW 0xff" qui ne fait que mettre le nombre FF dans le registre de travail et rien d'autre, ce qui ne fait en aucun cas une boucle.
à mon avis il en manque une bonne partie

déjà, tu peux déclarer ta variable nombre en char au lieu de int, ça devrait déjà bien réduire la durée de la boucle, mais c'est clair que ça suffira pas.
c'est difficile de faire des boucles d'une durée très précise en C étant donné qu'on ne maitrise pas le nombre d'instructions qui sont générées.
si t'as besoin d'une mesure de temps précise, il vaut mieux utiliser une interruption sur un timer à mon avis, ou éventuellement faire une tempo en assembleur et l'intégrer a ton code C (mais ça je l'ai jamais fait alors je peux pas t'en dire plus).

question bonus: tu utilises quel compilo?

[invitee0b95ad8]

Merci pour toutes les remarques.

En fait, je viens de trouver dans le "progam memory" la liste des instructions en assembleur, dans un ordre différent du précédent, et en effet, il y a plus d'une dizaine d'instruction pour le "while". Le "MOVLW" n'est que l'une d'entre elles.

Je vais me pencher sur le timer désormais.