Discussion :

[eki33]

Bonjour à tous,

Si je n'avais pas ce problème aigu de limite mémoire et performance de traitement de mon PIC, je crois que je ne chercherais pas si loin...

Mon programme "travaille" actuellement comme ceci :
- je stocke mes données (qui peuvent arriver aléatoirement) dans un tableau de structures TabStruct[50] et je compte le nombre d'enregistrements dans un variable X.

- si mon compteur X est supérieur à -1, le programme traite les données de TabStruct[X] et décrémente X jusqu'a ce qu'il soit à nouveau à -1

- si X arrive à 50 (overflow), il écrase les évênements plus anciens et X reste à 49

-> J'ai donc une pile LIFO (pas bien, je préfèrerais une file FIFO) et en cas d'overflow j'ai des données qui sont traitées aléatoirement par rapport à leur ordre d'arrivée (pas bien, pas bien!)

Je pense bien sur aux listes chainées pour faire un FIFO, mais en MPLAB C18 je doute de pouvoir faire cela efficacement (poids des pointeurs en mémoire, pas d'allocation dynamique possible...)

Donc voilà, si vous avez des idées, des exemples, je suis preneur!

[mala92]

Dans la programmation PIC tu ne peux pas utiliser les pointeurs ?

Si oui, tu as ton tableau (pile) de 50 éléments et tu utilises 2 pointeurs (lecture et écriture).
Le test le plus "chiant" à faire c'est la détection de la pile pleine : le pointeur d'écriture a rattrapé celui de la lecture et surtout le passage de l'élément 49 à 0.
Je pense qu'il y a des exemples de ce genre de code, c'est un exercice possible lors des entretien d'embauche.

Tu peux utiliser un compteur qui s'incrémente à l'écriture et décrémente à la lecture pour savoir si la pile est pleine.

[phi1981]

1) Ce n'est pas parce que tu ne peux pas allouer de mémoire dynamiquement que tu ne peux pas faire une liste chainée : rien ne t'empeche d'avoir deux listes, une de structures qui contiennent qqchose, et une autre de structures vides. Plutot que d'allouer une nouvelle, tu prends la première de la liste des vides.

2) Ce n'est pas parce que tu as un tableau fixe que tu ne peux pas faire une FIFO : Il suffit d'avoir deux index, un sur le prochain élément à lire, l'autre sur le prochain élément à écrire. Tu peux gérer ça comme un buffer circulaire de façon à ce que les nouvelles données écrasent les plus anciennes. Note : si le nombre d'élément à stocker est une puissance de deux, tu peux même profiter d'un & binaire pour faire un reset de l'index/éviter l'overflow, une technique bien pratique quand on veut éviter un coûteux if.

3) Enfin, ce n'est pas parce que les pointeurs prennent de la place que tu ne peux faire utiliser une liste chainée : académiquement on utilise des pointeurs pour lier deux objets, mais rien ne t'empeche d'utiliser un index dans un tableau. Mieux : vu que tu ne gères que 50 éléments, un index codé sur un octet suffira largement.

Evidemment, c'est à toi à déterminer ce qui te convient le mieux, je n'ai fait qu'énumérer ce qui me vient à l'esprit.

[Bktero]

As-tu consulté ce lien ?

http://www.microchip.com/stellent/id...pnote=en012157

[bpy1401]

Bonjour à tous

Moi, dan ce cas, je passe par un buffer circulaire. C'est un tableau comme tu en avais l'idée, mais j'ai deux entiers , un qui pointe sur la prochaine case à écrire, le second sur la prochaine case à lire. Lorsque l'un des index dépasse le max, je le remet à 0 (d'ou circulaire). Le tableau est vide si l'index de lecture est égale à l'index d'écriture.

Oublie l'allocation dynamique, c'est strictement interdit en embarqué , surtout sur des petits micros.

A+