Nom de fichier variable avec PIC et Carte SD en C18

[invite7fe6fb1f]

Bonjour,

Je souhaite généré sur une carte SD des fichier qui ont un nom de fichier variable (incrément ou date, peu importe). Ce sont des fichiers de log au format .csv.

La création d'un unique fichier "log.csv" fonctionne tres bien avec la fonction : logFile = FSfopenpgm("log.csv",WRITE);

Seulement je souhaite generer automatiquement un fichier différent, je ne peux pas le créer à chaquefois en utilisant la même méthode.

J'ai donc utilisé ceci :

//Variable pour les noms de fichier
	char NomFichier[20];
	int time = 01234;

sprintf(NomFichier,"log_%d.csv",time); //Concaténation de la "date" et de l'extension du fichier
logFile = FSfopenpgm(NomFichier,WRITE); //Création et ouverture du fichier, attributtion du pointeur

C'est peu etre un peu "bourrin" mais c'est exactement ce qu'il me faut.
Cette méthode à l'air de fonctionner en C++ :

http://www.cppreference.com/wiki/fr/io/c/sprintf

Je n'ai pas d'erreur de compilation. J'utilise un pic18F46J50 + carte SD, en MCC18 avec Mplab v8.63.
Mais le programme reste bloqué à la création du fichier.

Est ce que quelqu'un saurait me dépanner?

Merci beaucoup.
-----

[sdec25]

Bonjour,
Problème récurrent en programmation sur les PIC : confusion de type de variable rom/ram.
FSfopenpgm a besoin d'une variable rom char* (chaîne définie dans la mémoire du programme d'où le suffixe de la fonction pgm).
Utilise une autre version de cette fonction qui accepte un ram char* (je suppose que c'est FSfopen sans suffixe). Il y a le même problème pour toutes les fonctions ayant des char* en paramètre (si tu regardes dans le fichier string.h, toutes les fonctions strxxx sont définies en 1, 2, ou 4 versions avec des suffixes différents).

[invite7fe6fb1f]

Bonjour sdec25,

Merci pour ta réponse.
J'avoue que je ne maîtrise pas encore les placement rom/ram et les pointeur en µP et ton aide est la bienvenue, car je suis sur que ça m'éviterais des soucis à l'avenir.

Comme je suis perdu j'ai essayer plusieurs solutions (j'essaie juste de placer une variable dans la fonction FSopen(pgm),je m'interesserai à sprintf quand j'aurai compris çà deja):
1/

char NomFichier[] = "myfile.csv";
logFile = FSfopen(NomFichier, WRITE);

2/Le principe me semble bon, je dis à la fonction d'utiliser la variable que pointe l'adresse adr_NomFichier non?

rom char NomFichier[] = "myfile.csv";
int * adr_NomFichier;
adr_NomFichier = &NomFichier;
logFile = FSfopen(*adr_NomFichier, WRITE);

3/

rom char *NomFichier[] = "myfile.csv";
logFile = FSfopenpgm((const rom char*)NomFichier, WRITE);

Dans tous les cas j'ai une compilation, mais rien qui ne s'écrit sur ma carte SD.

Quand je déclare om char *NomFichier[] = "myfile.csv"; j’ai bien un pointeur sur NomFichier qui se situe en Rom d'apres ce que j'ai lu. Comment utiliser mon pointeur dans une fonction? (FSopenpgm)

Si je pouvais avoir de l'aide pour regler ce probleme je serai tres reconnaissant.

Merci de l'aide.

[sdec25]

Bonjour,
Le plus simple si tu veux vérifier en debug si une variable est rom ou ram est de récupérer un caractère de cette chaîne, ou de copier cette chaîne avec une des fonctions strcpy.

char NomFichier[] = "myfile.csv";
logFile = FSfopen(NomFichier, WRITE);

A vérifier mais je crois que char NomFichier[] = "valeur" déclare une variable en rom (car la chaîne est constante), donc Fsfopenpgm

rom char NomFichier[] = "myfile.csv";
int * adr_NomFichier;
adr_NomFichier = &NomFichier;
logFile = FSfopen(*adr_NomFichier, WRITE);

Convertir un char* en int* ne sert à rien dans ce cas. Et ce n'est pas normal que ça compile, un bon compilateur doit interdire les conversions douteuses comme celle-là. De plus tu convertis un rom char* en ram int* avant d'appeler une fonction qui prend un ram. En oubliant l'erreur de type char/int, tu passes à une fonction ram un pointeur rom. Et mettre un pointeur rom dans un pointeur ram ne peut qu'apporter des problèmes. On ne doit jamais changer le type d'un pointeur (la seule modif autorisée est l'ajout d'un const).

rom char *NomFichier[] = "myfile.csv";
logFile = FSfopenpgm((const rom char*)NomFichier, WRITE);

D'abord tu n'est pas obligé de caster explicitement en const rom char* si la fonction accepte un const rom char*. Tu l'as sûrement fait parce que ça ne compilait pas sans ? Le cast doit être utilisé quand on sait exactement ce qu'on fait, si on l'utilise pour régler un problème de compilation, ça compile mais ça ne fonctionne pas.
Je te conseille de suivre un tuto sur les pointeurs et les tableaux en C, ça te permettrait d'éviter les erreur de ce type.
Dans ton cas tu as déclaré un char*variable[]. En C un tableau est un pointeur, l'opérateur [] est donc équivalent à *. Tu as donc une variable de type char** alors que la fonction accepte un char* => le compilateur ne laisse pas passer.

[A voir en vidéo sur Futura]

[invite7fe6fb1f]

Merci d'avoir pris le temps de répondre.

J'avais tirer un exemplede l'AN 1045b page 10 : http://ww1.microchip.com/downloads/e...tes/01045b.pdf

Prototypes:

FSFILE * FSfopen (const char * fileName, const char *mode)
Input:
    fileName -  The name of the file to be opened (ROM)
    mode -      The mode the file will be opened in (ROM)

int FSrenamepgm(const rom char * fileName, FSFILE * fo)
Input:
    fileName -  The new name of the file (in ROM) <= !!!
    fo -        The file to rename

FSFILE *pOldFile, pNewFile;
char newFile[] = “newfile.txt”;
pNewFile = FSfopen (newFile, writeArg);

Ca me semble suspicieux car leur pointeur pNewFile n'est pas déclareren tant que pointeur, car il manque '*' non? Le compilateur n'accepte pas. J'aurais plutot tendanceà écrire FSFILE *pOldFile, *pNewFile;
Et meme comme ca, ca ne fonctionne pas.

Ensuite j'ai bien fait ceci:

char NomFichier[] = "myfile.csv";
logFile = FSfopenpgm(NomFichier, WRITE);

Donc NomFichier est bien un pointeur de type char*. Ca devrait fonctionner?

Lorsque je tourne en debug, NomFichier est bien un tableau remplie avec myfile.csv, mais logFile est nul et reste nul après l’exécution de la fonction.

J'utilise mcc18 Pro en trial, cane serait pas un bon compilateur?
C'est vrai que j'ai remarqué des choses étranges depuis que j'ai débuter le projet mais bon ^^
Est ce que ca peux etre du au PicKit3 moins optimiser que l'ICD pour le debuggage?

Oui je suis entrain de revoir les pointeurs.

Merci pour l'aide.

[invite7fe6fb1f]

J'y pense, est ce que j'aurai un problème de fin de chaîne de caractère (\0) ?

[sdec25]

Après quelques tests c'est un peu plus clair :
"chaine" est en rom
char* maChaine = "chaine" est en rom
char maChaine[] = "chaine" est en ram

Donc ton premier exemple était correct.

Le compilateur te met des warnings quand un paramètre n'est pas bon, fais attention à ça. Par contre j'ai aussi un warning pour une conversion de const rom char* en const far rom char*.

Ca me semble suspicieux car leur pointeur pNewFile n'est pas déclareren tant que pointeur, car il manque '*' non? Le compilateur n'accepte pas. J'aurais plutot tendanceà écrire FSFILE *pOldFile, *pNewFile;

Exact, on doit mettre * au début de chaque nom de variable si c'est des pointeurs. La plupart des compilateurs te mettraient une erreur pour une conversion de char à char* mais C18 ne met qu'un warning.
Essaie d'arriver à 0 warnings et tu auras un code à peu près correct.

Est ce que ca peux etre du au PicKit3 moins optimiser que l'ICD pour le debuggage?

Pourquoi tu n'utilises pas le débugger MPSIM inclus dans MPLAB ? C'est beaucoup plus simple que débugger avec le PIC. Personnellement je ne mets jamais un programme sur un PIC avant de l'avoir testé sur simulateur.

J'y pense, est ce que j'aurai un problème de fin de chaîne de caractère (\0) ?

Non, une chaîne entre guillemets contient déjà le \0. sprintf l'ajoute également.

[invite7fe6fb1f]

Bonjour,

Merci de vous intéresser avec autant d'attention à mon problème.

J'ai compilé à la maison cette fois-ci, avec les mêmes outils.

Je n'ai plus de warning pour la partie:

rom char * NomFichier[] = "myfile.csv";
logFile = FSfopenpgm((rom char*)NomFichier, WRITE);

Maintenant il faut que je teste ca avec ma carte de test.
Je veux bien simuler avec MPSIM, mais je ne m'en suis jamais servie.

Je m'étais tromper pour les prototype, il s'agit de :

Function:
    FSFILE * FSfopenpgm(const rom char * fileName, const rom char *mode)
  Summary:
    Open a file named with a ROM string on PIC18
  Conditions:
    For read modes, file exists; FSInit performed
  Input:
    fileName -  The name of the file to be opened (ROM)
    mode -      The mode the file will be opened in (ROM)
  Return Values:
    FSFILE * - A pointer to the file object
    NULL -     File could not be opened

Il faut donc bien que j'ai ma chaine en rom.
Donc si je fais "rom char *" ou "char*" j'ai ma chaîne en rom pour la déclaration de la variable.

Mais, si j'utilise uniquement "char *", j'ai un warning du type :

Warning [2066] type qualifier mismatch in assignment

A mon avis il faut donc préciser de bien le stocker en rom avec "rom char*" .

Mais je trouve bizarre qu'il faille caster la variable dans la fonction en faisant un (rom char*)NomFichier...


Petite question bête. Même si ma variable est en rom, je peux quand même la modifier au cours du programme? (Sinon il n'y a pas d’intérêt pour moi ^^)

Je test cela demain.

Si j'ai fais une erreur n’hésitez pas à la relever ^^

Merci.

[RISC]

Salut,

Petite question bête. Même si ma variable est en rom, je peux quand même la modifier au cours du programme? (Sinon il n'y a pas d’intérêt pour moi ^^)

Mettre une variable en ROM ( = FLASH ) est possible sur les PIC...mais cela n'a pas de sens.
En effet, pour écrire la FLASH (qui a la base contient le programme) il faut plusieurs millisecondes car il faut tout d'abord effacer la FLASH.
Si tu veux utiliser des tableaux ou des chaines de caractères qui ne changent pas (de type const), ils/elles iront automatiquement en FLASH (pas besoin de mettre ROM).
Par contre si tu veux CHANGER tes chaines de caratères il faut IMPERATIVEMENT qu'elles soient en RAM car ce seront des variables.

Si tu utilises des librairies, les types sont figés. A toi de faire, si nécessaire des copies en RAM de chaines qui sont en FLASH. Pour cela tu devra caster pour simplement éviter les messages de type "suspicious pointer conversion"

a+

[sdec25]

Re,

Je n'ai plus de warning pour la partie:

rom char * NomFichier[] = "myfile.csv";
logFile = FSfopenpgm((rom char*)NomFichier, WRITE);

Relis ma remarque précédente, char* var[] est incorrect, c'est un tableau de chaînes de caractères. Pour une chaîne c'est soit char* soit char[] mais pas les 2.

[invite7fe6fb1f]

Bonjour,

sdec25 : Oui tu a été tout à fait clair.

RISC : Merci de l'information.

Donc je déclare ma variable ne RAM avec :

char NomFichier[] = "myfile.csv"; //ram

Puisque la fonction n'accepte que les variable ne ROM, il faut que je la caste en ROM comme l'a dit RISC avec :

logFile = FSfopenpgm((rom char*)NomFichier, WRITE);

Je n'ai pas de warning. Pourtant ça ne fonctionne pas...
Je commence à passé trop de temps sur cette simple erreur

Bien que j'ai encore beaucoup de choses à apprendre, il faut que j'avance sur mon programme...est ce que vous auriez une solution?

Merci de votre aide.

[sdec25]

Bonjour,

Puisque la fonction n'accepte que les variable ne ROM, il faut que je la caste en ROM comme l'a dit RISC

Ce n'est pas ce qu'il a dit. Il a dit qu'il faut faire des copies ROM->RAM et caster uniquement pour enlever le warning.

Donc :
Soit tu utilises une fonction ROM pour une chaîne constante.
Soit tu copies une chaîne constante (char* chaine=) en RAM avec strcpypgm2ram et tu utilises la fonction RAM.
Soit tu définis une chaîne constante char chaine[] = qui est en RAM et tu utilises une fonction RAM.
Soit tu utilises une chaînes variable et une fonction RAM.

[invite7fe6fb1f]

Bonjour,

Apres avoir mis ca de coté une semaine j'ai enfin réussi!
Voila ce que j'ai fais pour ceux que ca intéresse:

	//char FileName[11] = "MYFILE.DAT";
	int nb_de_fichier = 0;
	char FileName[11];
	char FileMode[3] = "w+";

	sprintf(FileName, "log_%d.csv",nb_de_fichier);
	nb_de_fichier ++;
	logFile = FSfopen(FileName, FileMode);

Merci à tous pour votre aide.