Discussion :

[silenteagle]

Je n'est pas écrit le code sur le micro-contrôleur. Je vais donc essayer la solution que tu propose lilington.

Edit: je tente de faire la recherche de l'en-tête en utilisant bsearch() mais je ne sais pas comment obtenir la position du pointeur retourné par cette fonction.

[lilington]

bon comme ca a la va vite. on va essayer :

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
34
35
36
37
38
39
40
41
int findentete(const char *path,const char *entete,int enlen,int pos)
{
    int position=-1;
    FILE *f=fopen(path,"r");
    char c=-1;
 
    if(f==NULL)
        return -1; 
 
    fseek(f,pos,SEEK_SET); //on se place a la derniere position lue 
 
    while(!feof(f))
    {   
        fread(&c,1,sizeof(char),f); //on lit l'octet suivant
        if(c==entete[0]) //si ca correspond au premier octet de l'entet on continue
        {   
            int i;
            int eq=1;
            for(i=1;i<enlen;++i) //on test les octets suivant tantqu'il correspondent
            {   
                fread(&c,1,sizeof(char),f);
                if(c!=entete[i])
                {   
                    eq=0;
                    break;
                }   
            }   
 
            if(eq==1)//si on a trouver on retourne la position de l'entete
            {   
                position= ftell(f)-enlen;
                fclose(f);
                return position;
            }   
 
        }   
    }   
 
    fclose(f);
    return position;
}

bon il y a peut etre des erreurs j'ai pas tester j'ai ecris directement. sinon tu constate que tu la boucles qui appelle la fonction sera une boucle infinie donc il faut decaller pos avant de renvoyer dans la fonction. genre:

Code :

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

1
2
3
4
5
6
char entete [4] = {2,0,3,0};
int pos=0;
 
int last=findentete("fichier.ext",entete,4,pos);
pos=findentete("fichier.ext",entete,4,pos+1);
data = extract(fichier,last,pos);

[lilington]

bon en me relisant je trouve ca bien complique et surtout ca montre que mon esprits est sinueux et tourmente.
on peut faire plus simple avec des variables statics ou globals. va pour les globales ca parrait plus simple.

donc on veux juste la partie donnee on va faire:

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
 
FILE *glo_df=NULL; //globale
char glo_ENTETE[4] ={1,2,0,3};
int glo_lenEn=4;
 
int main()
{
    if(initialization("fichier.ext")==-1)
       return 0;
    for(;;)
    {
          char *datas = extractData();
          if(datas==NULL)
              break;
           //faire quelques chose avec data oubien l'ajouter dans un tabl de pointeurs
          free(datas);
    }
    termination();
}

donc la c'est plus simple on initialise en ouvrant le fichier avec la global glo_df et qu'on termine aussi d'ailleur. (note qu'on aurait put ne pas utiliser de globale et renvoyer le descriteur avec init puis utiliser cette variable pour l'extraction et la terminaison. l'avantage est qu'on peut traiter plusieurs fichier a la fois. or dans notre cas on ne traite qu'un seul)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int initialization(const char *path)
{
      glo_df=fopen(path,"r")
      if(glo_df==NULL)
         return -1;
      return 0;
}
void terminate()
{
    fclose(glo_df);
}

bon maintenant l'extraction:

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
34
35
36
char *extractData()
{   
    /*theoriquement ton fichier commence par l'entete 
    si ce n'est pas le cas dans la fonction initialization on devra chercher
    le debut de la premiere entete
 
    entrer dans cette fonction signifie qu'on est au niveau entete*/
    int position =-1;
    pos=ftell(glo_df)+glo_lenEn; //memorison la position des donnees
 
    if(pos==qqchose) //faut tester si c'est pas fini 
        return NULL;
 
    while(!feof(glo_df))
    {
        //la meme routine que le message precedent
        //pour trouver l'entete suivante.
        position=la_valeur_trouver;
    }   
 
    if(position==-1)
    {
        //c'est le cas ou c'est la derniere partie
        //donc on extrait depuis pos jusqu'a eof
        position=la_valeur_correspondant_au_dernier_octet;
    }
 
    char *result = malloc(sizeof(char)*(position-pos));
    if(result==NULL)
        return result;
 
    fseek(glo_df,pos,SEEK_SET);
    fread(result,postion-pos,sizeof(char),glo_df);
 
    return result;
}

bon l'idee c'est ca mais tu peux faire mieux.

[silenteagle]

Je viens de tester se que tu me propose mais, dans la fonction extractData(), le test avec le premier octet de l'en-tête échoue constamment.

Bon j'ai fait quelque modif donc sa doit venir de là, mais j'ai pas encore trouvé :/

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
34
35
 //Variables globales:
FILE	*glo_df			=	NULL;
char	*glo_ENTETE;
int		glo_lenEn		=	0;
long	glo_fileSize	=	0;
 
//Fonction init modifier pour récupérer l'en-tête.
int initialization(const char *path)
{
	size_t result=0;
 
	glo_df=fopen(path,"rb");
	if(glo_df==NULL)
		return -1;
 
	// recuperation de la taille du fichier:
	fseek (glo_df , 0 , SEEK_END);
	glo_fileSize = ftell (glo_df);
	rewind (glo_df);
 
	// recuperation de la taille du header:
	fseek(glo_df,5,SEEK_SET);
	glo_lenEn = 6 + 2 * fgetc(glo_df) + 53;
	rewind (glo_df);
 
	// allocation de memoire pour contenir le header
	glo_ENTETE = malloc (sizeof(char)*glo_lenEn);
	if (glo_ENTETE == NULL) {perror ("Memory error"); exit (2);}
 
	// copie le header dans le buffer:
	result = fread (glo_ENTETE,1,glo_lenEn,glo_df);
	if (result != glo_lenEn) {perror ("Reading error"); exit (3);}
 
	return 0;
}

Sinon je me demander dans la fonction extractData() tu utilise

Code :

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

fread(&c,1,sizeof(char),glo_df);

pourquoi ne pas utiliser fgetc() ?

Edit: j'ai fait quelques tests pour voir si glo_ENTETE contenais bien mon en-tête. Et c'est le cas je l'ai écrit dans un fichier et affichier à l'écran.
Par-contre quand je fait printf("%d\n",glo_ENTETE[i]) il y a certaines valeurs un peut étrange, par exemple dans le fichier j'ai la valeur 0x88 soit normalement en décimal 136, mais le printf lui me retourne -120 se qui fait en hexa 0xFFFF FF88. Si quelqu'un pouvais éclairé ma lanterne :p

Edit 2: Ce petit problème que je pensais anodin fait échoué tout le programme. En effet si on effectue ce test :

Code :

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

1
2
3
4
5
6
7
	char* c=-1;
	int i=0;
	for(i=0;i<glo_lenEn;i++)
	{
		fread(&c,1,sizeof(char),glo_df); //on lit l'octet suivant
		printf("%d == %d\n",(int)c,glo_ENTETE[i]);
	}

On obtient se résultat :

Code :

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

1
2
3
4
5
6
7
8
9
-129 == 127
-129 == 127
-178 == 78
-253 == 3
-256 == 0
-250 == 6
-238 == 18
-256 == 0
-185 == 71

Edit 3: j'ai trouvé d'où venais l'erreur. j'ai remplacé char* glo_ENTETE; en unsigned char* glo_ENTETE; Et le caractère lu par fread au lieu que sa soit un char c; c'est un unsigned char c;

[diogene]

Une trame de programme pour rechercher l'en tête si un bloc de données est trop petit par rapport à la taille annoncée et donc que (au moins) le début de l'en tete se trouve dans le bloc de données précédent (comme le bloc 117).
Note : Il faut également penser qu'il faut établir le vrai nombre de données du bloc trop petit, donc savoir qu'il est trop petit ce qui impose de vérifier l'en tete qui le suit.

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
//---------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define LENTETE 71
typedef struct
{
   unsigned char * data;              // les données (ici en alloc dynamique)
   int ndata;                         // le nombre de données
   unsigned char entete[LENTETE];     // en-tete du bloc
   unsigned char nextentete[LENTETE]; // en-tete du bloc suivant
}Data;
typedef enum {stOK, stEOF ,stENTETE_ERR, stALLOC_ERR} Status;
/*-----------------------------------------------------------------------*/
// Vérification de la validité de l'en-tete
#define maxindice 8 // l'indice max qui est testé dans entete
                    // utilisé par ChercheEntete()
#define CheckEntete(entete)\
((entete[0] == 0x7F && entete[1] == 0x7F && entete[8] == 0x47)\
         ? stOK \
         : stENTETE_ERR)
/*-----------------------------------------------------------------------*/
Status LireEntete(FILE * f, unsigned char * entete)
{
  int  i = fread(entete,1,LENTETE,f);
  if(i<LENTETE) return stEOF;
  return CheckEntete(entete);
}
/*-----------------------------------------------------------------------*/
Status LireData(FILE * f, Data *data)
{
  int i ;
  unsigned char *p;
  data->ndata = data->entete[3]*256+data->entete[2]+2- LENTETE;
  p = realloc(data->data,data->ndata);
  if(p==NULL)         // echec d'allocation
  {
     free(data->data), data->data = NULL;
     data->ndata = 0;
     return stALLOC_ERR;
  }
  data->data = p;
  i = fread(data->data,1,data->ndata,f);
  return (i< data->ndata)
          ? stEOF
          : stOK ;
}
/*-----------------------------------------------------------------------*/
// recherche un entete dans les données précédemment lues
Status ChercheEntete(FILE * f, Data *data)
{
   unsigned char * p = data->data;
   int i=0;
   do
   {
      if(CheckEntete(p)== stOK) break;
      p++;
      i++;
   }while(i< data->ndata-maxindice);
   if(i==data->ndata-maxindice)return stENTETE_ERR;  // pas trouvé
   fseek(f,i-data->ndata-LENTETE,SEEK_CUR);  // repositionner le fichier
   data->ndata = i;                // actualiser le nombre de données valides
   return LireEntete(f,data->nextentete); // lire l'en-tete suivant
}
/*-----------------------------------------------------------------------*/
int main(void)
{
   Data data = {NULL,0};
   Status status = stOK;
   int count = 0;                      // compte le nombre de blocs pour info
   FILE * f = fopen(....,"rb");
   if(f != NULL)
   {
      status = LireEntete(f,data.nextentete);
      if(status != stOK)
      {
        printf(" Premier en-tete incorrect");
      }
      while(status == stOK)
      {
         memcpy(data.entete, data.nextentete, LENTETE);
         count ++;
         status = LireData(f,&data);
         if(status == stOK)
         {
            // vérifier si le prochain en-tete est correct pour
            // établir le nombre correct de data actuels
            status = LireEntete(f,data.nextentete);
            if(status == stENTETE_ERR) //en tête incorrect. rechercher avant
            {
                 printf("INFO : Erreur en-tete %d %x (ox7F), %x (ox7F), %x (0x47)\n",count+1,data.nextentete[0],data.nextentete[1],data.nextentete[8]);
                 status = ChercheEntete(f,&data);
                 if(status != stOK) printf("ERREUR : en-tete non trouvé\n");
            }
            if(status == stOK)
            {
                 // les données sont prètes
            }
         }
      }
      fclose(f);
   }
   printf("%d blocs de données lues\n", count);
   free(data.data);
   return 0;
}
//---------------------------------------------------------------------------

[lilington]

merci diogene ca me sera utile
sinon attention:

Code :

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

result = fread (glo_ENTETE,1,glo_lenEn,glo_df);

le parametre 2 est le nombre d'element a lire quand le parametre 3 est la taille d'un element.
la tu lis 1 element de taille glo_lenEn, pour eviter des cas indebugable inverse le 1 et le glo_lenEn. d'ailleurs tu remarquera que j'ai mis sizeof(char) au parametre 2.

-effectivement si ce sont des unsigned char qui sont sur le fichier vaut mieux lire des unsigned char quoique tu peux aussi bien caster a l'utilisation.

-j'utilise fread/fwrite par habitude j'ai aucune raison particuliere, enfaite quand j'ai commence en C je ne connaissait qu'eux depuis j'ai pas trouve utile de changer, sauf si qu'elle qu'un me presente un avantage a utiliser autre chose.

-bon sinon ca marche ou pas? sinon donne mois un fichier, et la structure du fichier j'essais de le lire.

[diogene]

le parametre 2 est le nombre d'element a lire quand le parametre 3 est la taille d'un element.
la tu lis 1 element de taille glo_lenEn, pour eviter des cas indebugable inverse le 1 et le glo_lenEn. d'ailleurs tu remarquera que j'ai mis sizeof(char) au parametre 2.

Je ne pense pas qu'il y ait de différence : il va lire de toute façon paramètre1* paramètre2 bytes. On peut mettre sizeof(char), mais il vaut toujours 1

-effectivement si ce sont des unsigned char qui sont sur le fichier vaut mieux lire des unsigned char quoique tu peux aussi bien caster a l'utilisation.

Comme on ne connait pas la nature de ces bytes pour l'utilisateur, unsigned char me semble être le type assurant la plus grande neutralité.

-bon sinon ca marche ou pas? sinon donne mois un fichier, et la structure du fichier j'essais de le lire.

J'ai utilisé, pour tester brièvement le code, le fichier donné en pièce jointe d'une réponse du PO au début de la discussion.

[lilington]

Je ne pense pas qu'il y ait de différence : il va lire de toute façon paramètre1* paramètre2 bytes. On peut mettre sizeof(char), mais il vaut toujours 1
Comme on ne connait pas la nature de ces bytes pour l'utilisateur, unsigned char me semble être le type assurant la plus grande neutralité.
J'ai utilisé, pour tester brièvement le code, le fichier donné en pièce jointe d'une réponse du PO au début de la discussion.

oui de toute facon lire 3xsizeof(int) c'est ma memechose que lire sizeof(int) x 3.

donc tu as teste et?

[silenteagle]

Cette ligne ci m'as posé quelque problème:

Code :

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

dataPos=ftell(glo_df) + glo_lenEn;//memorison la position des donnees

En fait elle fonctionne très bien si le "curseur" interne du fichier est au debus d'un en-tête. Elle n'est plus pertinente lorsque le "curseur" est à la fin d'un en-tête.

Ma solution à était de crée un booléen qui indique si on est au début ou à la fin d'un en-tête.

Sinon je pense être arrivé à quelque chose qui fonctionne, faut encore que je fasse des tests, notamment le cas ou le fichier ne commence pas par un en-tête..

Et il faudra que j'utilise la méthode de diogene non pas pour corriger l'en-tête mais pour complété les données, avec des zeros par exemple. La finalité étant d'avoir une copie du fichier d'origine avec un seul en-tête en début. Le but étant de réduire la taille du fichier sans perdre les données.

Et après je devrais faire l'inverse, prendre le fichier avec un en-tête, et insérer cet en-tête entre chaque groupe de données

[lilington]

alors on vas vers la fin du probleme

sinon a la fin de la fonction on etait sense remetre le curseur au debut de l'entete. bref tu as du oublier ou alors j'ai mal ecris le code (je suis un peu etourdis)

[diogene]

notamment le cas ou le fichier ne commence pas par un en-tête..

Tes fichiers ne sont décidemment pas fiables

...non pas pour corriger l'en-tête mais pour complété les données, avec des zeros par exemple .

Une fois que tu auras fait ça, tu ne saura plus si ces zéros sont significatifs ou non

La finalité étant d'avoir une copie du fichier d'origine avec un seul en-tête en début. Le but étant de réduire la taille du fichier sans perdre les données.

Pour gagner 10% sur la taille du fichier, est-ce que ça vaut le coup d'introduire des données fausses ? .

[silenteagle]

Les fichiers qui ne commence pas par un en-tête c'est pas une erreur. Sa viens viens du dispositifs qui les génères. Y a un fichier généré par jours, comme le changement de fichier ne prend pas en compte le contenue du fichier fatalement elle se produit un peut n'importe où.

Les données sont issus d'un capteur, j'ai parler de zéro mais enfaite je vais plutôt mettre des données incohérentes.

A priori c'est pas utile je te l'accorde, sauf que se fichier doit être envoyer via une liaison satellitaire. Donc là j'enlève les donnée redondante, puis je compresse le fichier et enfin je l'envoi. Pour te donnée un ordre d'idée sa coute environ 7000€ d'envoyer 10 Mo donc moins on en envois mieux on se porte

sinon a la fin de la fonction on etait sense remetre le curseur au debut de l'entete.

Y a effectivement une ligne qui replace au début des données. Mais il arrive que cette position soit erroné vus que la position des donnée est définie comme étant egale à position du curseur+taille de l'en-tête

exemple :

[diogene]

Difficile de dire quelque chose vu que l'on ne sait pas l'importance et l'utilité de l'en-tete. Pour l'instant, telles que tu décris les choses, il n'est pas utilisé (pourtant, certains éléments changent d'un en-tete à l'autre : octets 50, 52, 58) : il comporte la taille de l'en-tete qui est fixe et l'offset de l'en-tete suivant qui est fixe mais parfois vrai et parfois faux.

C'est vrai qu'à ce coût, il est utile de réduire la taille des données émises.
Pourquoi ne pas simplement mettre un en-tete puis l'ensemble des données (sans les zéros ajoutés pour compenser une erreur) ?

Mais à ce prix là, il est bizarre de ne pas s'inquiéter du fonctionnement du capteur et de la raison qui lui fait engendrer des enregistrements erronés ou fractionnés.

Tout cela ne semble pas très "professionnel".

[lilington]

Mais à ce prix là, il est bizarre de ne pas s'inquiéter du fonctionnement du capteur et de la raison qui lui fait engendrer des enregistrements erronés ou fractionnés.

Tout est dit, visiblement si le capteur ne peut pas produire un fichier regulier tu peux avoir un jours (peut etre apres 1 ,2 ou meme 1000000000 lectures du fichier) une nouvelle incoherence qui fera tout planter.

[silenteagle]

Je voir si y a moyen de faire des modifs ce coté là, en tout cas merci pour votre aide.