Newsgroup: it.comp.lang.c
Titolo: Segmentation fault, qualcuno mi può dare una mano?

Il programma da me sviluppato si compone di un ciclo infinito,
all'intrerno di tale ciclo il programma utilizza dei socket per la
comunicazione con un altro programma (in java).
Il problema è che dopo circa 7-8 minuti di esecuzione il programma
termina con l'errore: Segmentation Fault
Ecco il codice:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <NIDAQmx.h>
#include <stdlib.h>
#include <string.h>
#define LIV_MAX 0.21
#define N_LOOPS 720
#define V_M_TWO -0.0209
#define V_M_THR 0.2087
#define M_V_ONE -2.7947
#define M_V_TWO -46.5504
#define M_V_THR 9.832
#define EXIT 99
#define EXIT_B 100
/* ERROR LABEL */
#define DAQmxErrChk(functionCall) if( DAQmxFailed(error=(functionCall))
) goto Error; else
void errorsock(char *msg)  /* funzione error per socket */
{
perror(msg);
exit(0);
}
int main(void)
{
        /* VARIABILI INGRESSO ANALOGICO */
	TaskHandle  taskHandle=0;
	int32       numread;
	float64     data[10];
	/* VARIABILI USCITA ANALOGICA */
	TaskHandle  taskHandleOut=0;
	float64     dataOut[1];
	/* VARIABILI CONTROLLORE */
	float64 Kp = - 50;                  /* costante proporzionale
      */
	float64 Ki = - 10;                  /* costante integrale
    */
	float64 T  = 1.1;                  /* periodo di campionamento
     */
	float64 Y0 = 0.12;                /* segnale riferimento espresso in
metri */
	float64 Y0v;
	float64 Y;
	float64 umax = 10;               /* valore massimo saturazione     */
	float64 umin = 0;                /* valore minimo saturazione      */
	float64 uman = 5;                /* variabile di controllo manuale */
	float64 e;                       /* errore all'istante corrente    */
	float64 eold = 0;                /* errore all'istante passato     */
	float64 u;                       /* variabile di controllo         */
	float64 v;                       /* vedi schema pag 579            */
	float64 m;
	float64 mold = 0;
	float64 isAuto = 1;              /* se uguale a 1 modalitÃ
automatica */
	int     index = 0;
	/* VARIABILI ERRORE */
	int32       error=0;
	char        errBuff[2048]={'\0'};
	/* VARIABILI SOCKET  lettura */
	char servername[10] = "localhost";
	int sockfd, portno, n;
	struct sockaddr_in serv_addr;
	struct hostent *server;
	char buffer[256];
	portno = 8190;
	/* VARIABILI SOCKET scrittura */
	int sockfd1, portno1, n1;
	char buffer1[256];
	portno1 = 8191;
	while( isAuto != EXIT )   {
	/* CREAZIONE SOCKET  lettura */
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	server = gethostbyname(servername);
	bzero((char *) &serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr,
server->h_length);
	serv_addr.sin_port = htons(portno);
	if (connect(sockfd, &serv_addr, sizeof(serv_addr)) < 0)
	 errorsock("Errore connessione socket");
	bzero(buffer,256);
	/* LETTURA SOCKET */
	n = read(sockfd,buffer,255);
	 if (n < 0)
	 errorsock("Errore lettura socket");
	 printf("Buffer lettura : %s\n", buffer);
	/* FINE LETTURA SOCKET */
	/* GESTIONE PARAMETRI DA BUFFER */
	sscanf(buffer,"%lf %lf %lf %lf\n",&Kp ,&Ki ,&Y0 ,&isAuto );
	printf("Valore di Kp : %2.4f\n", Kp);
	printf("Valore di Ki : %2.4f\n", Ki);
	printf("Valore del Setpoint  : %2.4f\n", Y0);
	printf("Valore Reg. Auto : %f\n", isAuto);
	/*********************************************/
	// DAQmx Configure Code
	/*********************************************/
	DAQmxErrChk (DAQmxCreateTask("taskAI",&taskHandle));
	DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0","",DAQmx_Val_RSE,-10.0,10.0,DAQmx_Val_Volts,NULL));
	DAQmxErrChk
(DAQmxCfgSampClkTiming(taskHandle,"",10,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,10));
	/*********************************************/
	// DAQmx Start Code
	/*********************************************/
	DAQmxErrChk (DAQmxStartTask(taskHandle));
	/*********************************************/
	// DAQmx Read Code
	/*********************************************/
	DAQmxErrChk
(DAQmxReadAnalogF64(taskHandle,10,12.0,DAQmx_Val_GroupByScanNumber,data,10,&numread,NULL));
	/* printf("Acquired %d points\n",numread);  */
        printf("\n\n******\n");
        printf("Misura livello : %2.4f Volt\n",data[9]);
	Y = V_M_TWO*data[9] + V_M_THR;                 /* interpolazione da
volt a metri */
	printf("Misura livello : %2.4f Metri\n",Y);
	Y0v = M_V_ONE*Y0*Y0 + M_V_TWO*Y0 + M_V_THR;     /* interpolazione da
metri a volt */
	printf("Segnale di riferimento : %2.4f Volt\n",Y0v);
	printf("Segnale di riferimento : %2.4f Metri\n",Y0);
	if( taskHandle!=0 )  {
		DAQmxStopTask(taskHandle);
		DAQmxClearTask(taskHandle);
	}
	/* CONTROLLORE */
	if (isAuto == 1) {               /* regolazione automatica */
	e =  Y0v - data[9] ;               /* calcolo errore */
	printf("Errore : %2.4f Volt\n",e);
	v = ((Kp + T*Ki)*e) - (Kp*eold) ;    /* calcolo v */
	u = v + mold;                    /* calcolo u */
	if (u > umax)  { m = umax; }     /* Saturazione */
	if (u < umin)  { m = umin; }
	if (u >= umin && u<= umax)  { m = u; }
	}
	else  { m = uman ; }              /* regolazione manuale */
	/* if ( Y > LIV_MAX )   { m = 0; } */     /* controllo di sicurezza */
	dataOut[0] = m;
	eold = e;
	mold = m;
	printf("Variabile di controllo : %2.4f Volt\n",dataOut[0]);
	printf("******\n");
	/* FINE CONTROLLORE */
	/* CREAZIONE SOCKET scrittura */
	sockfd1 = socket(AF_INET, SOCK_STREAM, 0);
	server = gethostbyname(servername);
	bzero((char *) &serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr,
server->h_length);
	serv_addr.sin_port = htons(portno1);
	if (connect(sockfd1, &serv_addr, sizeof(serv_addr)) < 0)
	 errorsock("Errore connessione socket");
	bzero(buffer1,256);
	/* SCRITTURA SOCKET */
	sprintf(buffer1,"%f %f\n",Y,m);
	printf("Buffer scrittura : %s\n",buffer1);
	 n1 = write(sockfd1,buffer1,strlen(buffer1));
	if (n1<0)
	 errorsock("Errore scrittura socket");
	/* FINE SCRITTURA SOCKET */
	/* USCITA ANALOGICA */
	/*********************************************/
	// DAQmx Configure Code
	/*********************************************/
	DAQmxErrChk (DAQmxCreateTask("taskAO",&taskHandleOut));
	DAQmxErrChk
(DAQmxCreateAOVoltageChan(taskHandleOut,"Dev1/ao1","",-10.0,10.0,DAQmx_Val_Volts,""));
	/*********************************************/
	// DAQmx Start Code
	/*********************************************/
	DAQmxErrChk (DAQmxStartTask(taskHandleOut));
	/*********************************************/
	// DAQmx Write Code
	/*********************************************/
	DAQmxErrChk
(DAQmxWriteAnalogF64(taskHandleOut,1,1,10.0,DAQmx_Val_GroupByChannel,dataOut,NULL,NULL));
	if( taskHandleOut!=0 ) {
		/*********************************************/
		// DAQmx Stop Code
		/*********************************************/
		DAQmxStopTask(taskHandleOut);
		DAQmxClearTask(taskHandleOut);
	}
/* ERRORE PER INGRESSO E USCITA */
Error:
	if( DAQmxFailed(error) )
	  {
		DAQmxGetExtendedErrorInfo(errBuff,2048);
	   if( taskHandle!=0 )  {
		DAQmxStopTask(taskHandle);
		DAQmxClearTask(taskHandle);
	  }
	   if( taskHandleOut!=0 ) {
		DAQmxStopTask(taskHandleOut);
		DAQmxClearTask(taskHandleOut);
	}
	}
	if( DAQmxFailed(error) )
	      printf("DAQmx Error: %s\n",errBuff);
	 index++;
        }  /* FINE CICLO */
	DAQmxErrChk (DAQmxCreateTask("taskAO",&taskHandleOut));
	DAQmxErrChk
(DAQmxCreateAOVoltageChan(taskHandleOut,"Dev1/ao1","",-10.0,10.0,DAQmx_Val_Volts,""));
	DAQmxErrChk (DAQmxStartTask(taskHandleOut));
	dataOut[0] = 0;
	DAQmxErrChk
(DAQmxWriteAnalogF64(taskHandleOut,1,1,10.0,DAQmx_Val_GroupByChannel,dataOut,NULL,NULL));
	if( taskHandleOut!=0 ) {
		DAQmxStopTask(taskHandleOut);
		DAQmxClearTask(taskHandleOut);
	}
	 printf("******************* \n");
	 printf("writing zero to daq \n");
	 printf("End of program \n");
	 printf("******************* \n");
	 return 0;
}
Utilizzando il programma GDB mi viene detto che il segmentation fault
avviene alla chiamata:
bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr,
server->h_length);
Qualcuno mi può dare una mano? Grazie!
FF

 Qualcuno mi può dare una mano? Grazie!
ehm... a parte che non ho l'header NIDAQmx.h e quindi non posso provarlo...
siccome da fastidio su bcopy allora una piccola lettura del man e ti 
ritrovi questo:
This function is *deprecated*: use memcpy() or memmove() in new 
programs.  Note  that  the first two parameters are interchanged for 
memcpy() and memmove().
stessa cosa per bzero:
This function is *deprecated*: use memset() in new programs.
forse riesci a risolvere...

potevi postare almeno *qualche* riga di codice...
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 
sì infatti...

Cristosanto, manca poco e mi mandi in SIGSEGV thunderbird per leggere il
messaggio!
La prossima volta usa 
pastebin.com
 grazie..