Problème avec write sur fichier

Bonjour, voila j'ai un programme qui doit écrire 36 octets 30 fois par sec dans un fichier, mais voila qu'a un certain moment, j'ai un message "Segmentation fault", et l'enregistrement se stop.
Alors j'ai réduit mon nombre d'écriture par 2, le probleme est toujours présent.

mon fichier est ouvert avec O_APPEND,O_RDWR,O_TRUNC,O_CREAT.

Merci pour votre aide.

Nous sommes voyants,
Sans code source, il est difficile de trouver l'erreur d'un problème ;)

En générale les SegFault sont dû à un problème mémoire, on pourrais avoir ton code reduit au minimum et compilable ?

et bien le code oui, compilable c compliqué car j'ai un soft sous RT, une FIFO, et une appli Linux qui écrit sur mon fichier.

Mon main:

//lit ma FIFO
if (FIFO.change())
reveilleMaThread();

J'ai une Thread qui Write(monfichier,trame,36) quand elle est reveillé;

PS: ma tache est reveillé le bon nombre de fois mais mon fichier est tronqué a un moment quand mon erreur intervient.

comme le message d'erreur l'indique c'est effectivement un probleme mémoire donc l'algorithme est faux car il sature à un moment ou un autre.
il faut lui ajouter une allocation pour l'empecher de sortir de la taille aloué quelque soit l'instant de son execution.

/!\ ceci est le cas général /!\

à toi de voir pourquoi tu merdes et comment corriger en fonction de ton besoin précis mais je doute que ce soit autre chose.

En faites je tourne sur un PC indus avec 64M de RAm.

Ca nous donne pas le source de ton code. :p
Je pense que tu dois avoir un problème d'algo dans une boucle.

Code:

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
/***************************************************************************
                          main.c  -  description
                             -------------------
    begin                : mar oct 12 10:42:14 CEST 2004
    copyright            : (C) 2004 by 
    email                : 
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
 
#define FIFO_READ		"/dev/rtf0"
#define FIFO_WRITE	"/dev/rtf1"
#define FICHIER "/tmp/DMX"
 
#define STORE						1
#define STOP_STORE			2
#define RESTORE					3
#define STOP_RESTORE		4
#define STANDBY 				5
#define WAIT_MOVE_DMX		6
 
#define DEMANDE_ENTETE			0
#define FORCE_ENTETE				1
#define DONNEE							2
#define OPTION							3
#define LOOP_SHOW						4
 
int fifo_write,fifo_read,monfichier;
pthread_t thread1;
signed char TrameDMXToWrite[60];
signed char TrameDMXToRead[60];
signed char TrameEnTeteToWrite[60];
signed char TrameEnTeteToRead[60];
char Contenu_Fifo_Read[60];
char Contenu_Fifo_Write[60];
unsigned char Etat,lastetat=0,Demande_a_Traiter=0,Nbr_Trame_Sec_Recu,Nbr_Trame_Sec_Fichier;
unsigned char Cpt,Cpt2;
unsigned char LastNumTrameTraiter=0;
unsigned char DureeH,DureeM,DureeS,Jour,Mois,Annee;
unsigned char TypeTrame;
unsigned char Test;
//signed char Loop, AutoGO;
unsigned char Cpt;
unsigned long CptTrame=0;
unsigned long NbrDemande=0;
pthread_t thread1;
//unsigned char AStorerQQchose=0;
void *Thread(void *arg);
unsigned char DemandeEcriture=0,DemandeLecture=0;
 
// ***************************************************************************/
 
void Write_Trame()
{
int nlu;
nlu = write(monfichier,TrameDMXToWrite,36);
//if (nlu != 36)
//	printf("erreur ecriture\n");
//CptTrame++;
}
 
// ***************************************************************************/
 
void Read_Trame()
{
int nlu;
nlu = read(monfichier,TrameDMXToRead,36);
//if (nlu != 36)
//	printf("erreur lecture\n");
//NbrDemande++;
}
 
// ***************************************************************************/
 
void Envoi_FIFO(unsigned char type)
{
unsigned char cpt;
Contenu_Fifo_Write[0] = 0xAA; //trame par sec
Contenu_Fifo_Write[3] = LastNumTrameTraiter; //num trame traiter
Contenu_Fifo_Write[1] = DONNEE; //num trame traiter
Contenu_Fifo_Write[2] = RESTORE; //num trame traiter
Read_Trame();
 
//store une trame de 36
for(cpt=0;cpt<36;cpt++)
	Contenu_Fifo_Write[cpt+4] = TrameDMXToRead[cpt];
 
write(fifo_write,Contenu_Fifo_Write,40);
}
 
// ***************************************************************************/
 
int main(int argc, char *argv[])
{
fifo_write = open(FIFO_WRITE,O_WRONLY|O_NONBLOCK);
fifo_read = open(FIFO_READ,O_RDONLY|O_NONBLOCK);
monfichier = open(FICHIER,O_RDWR|O_NONBLOCK|O_CREAT|O_APPEND);
 
if (fifo_write != -1)	printf("Fifo write OK\n");
else									printf("Fifo write bad %d\n",fifo_write);
 
if (fifo_read != -1)	printf("Fifo read OK\n");
else									printf("Fifo read bad %d\n",fifo_read);
 
if (monfichier != -1)	printf("Fichier OK\n");
else									printf("Fichier bad %d\n",monfichier);
 
//printf("taille fichier %d\n",lseek(monfichier,0,SEEK_END));
//pthread_create(&thread1,NULL,Thread,NULL);
 
while(1)
	{
	read(fifo_read,Contenu_Fifo_Read,40);
 
	Test = Contenu_Fifo_Read[0];	
 
	if (Test == 0xAA) //test 1er octet
		{
		TypeTrame = Contenu_Fifo_Read[1];
 		Etat =  Contenu_Fifo_Read[2];
		Demande_a_Traiter = Contenu_Fifo_Read[3];
 
		switch(Etat)
			{
			case RESTORE:
				{
				//look si demande lecture
				if (lastetat != Etat)
					{
//					printf("Restore\n");
					lastetat = Etat;
					LastNumTrameTraiter = 0;
					lseek(monfichier,0,SEEK_SET); //place le pointeur au debut
					}
 
				if (Demande_a_Traiter != LastNumTrameTraiter)
					{
					if (TypeTrame == LOOP_SHOW)	
						{
						LastNumTrameTraiter = 0;
						lseek(monfichier,0,SEEK_SET); //place le pointeur au debut
	//					printf("loop\n");
						}
					else
						{
						//NbrDemande++;
						Envoi_FIFO(DONNEE);
						}
					LastNumTrameTraiter = Demande_a_Traiter ;
					}
				break;
				}
			case STORE:
				{
				if (lastetat != Etat)//decalage pour laisser place pour entete
					{
		//			printf("Store %d\n",Nbr_Trame_Sec_Recu);
					lastetat = Etat;
					//vide fichier existant
					close(monfichier);
					monfichier = open(FICHIER,O_RDWR|O_NONBLOCK|O_CREAT|O_TRUNC|O_APPEND);
					}
 
				//regarde si a traiter
				if (Demande_a_Traiter != LastNumTrameTraiter)
					{
					for(Cpt=0;Cpt<36;Cpt++)
						TrameDMXToWrite[Cpt] = Contenu_Fifo_Read[Cpt+4];
 
					//Write_Trame();
					//DemandeEcriture = 1;
					pthread_create(&thread1,NULL,Thread,NULL);
					LastNumTrameTraiter = Demande_a_Traiter ;
					}
				break;
				}	
			case STOP_STORE:
				{
				if (lastetat != Etat)//decalage pour laisser place pour entete
					{
		//			printf("Stop Store %d\n",CptTrame);
					lastetat = Etat;
					}
				break;
				}	
			case STOP_RESTORE:
				{
				break;
				}	
			case STANDBY:
				{
				if (lastetat != Etat)
					{
			//		printf("Standby %d\n",NbrDemande);
					lastetat = Etat;
					LastNumTrameTraiter = 0;
					NbrDemande =0;
					CptTrame = 0;
					}
 
				if (Demande_a_Traiter != LastNumTrameTraiter)
					{
					LastNumTrameTraiter = Demande_a_Traiter ;
					}
				break;
				}
			default:break;
			}
		}	
	}
close(monfichier);
return EXIT_SUCCESS;
}
 
//****************************************************************************
 
void *Thread(void *arg)
{
struct sched_param p;
p.sched_priority = 60;
pthread_setschedparam (pthread_self(),SCHED_FIFO,&p);
 
//while(1)
	{
	//if (DemandeEcriture)
		{
		Write_Trame();
	//	DemandeEcriture = 0;	
		}
//	else if (DemandeLecture)
//		{
//		ReadTrame();
//		DemandeEcriture = 0;	
//		}
	}
pthread_exit(NULL);
}

Meme si je mets un Write(monfichier,trame,1) ca plante !!!!!!!!!!!
et si je vire le Write, ca marche...
si qq'un peut m'aider SVP.