gdatalogger.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GDATALOGGERVARIABLE
struct	GDATALOGGER
struct	GDATALOGGERIPC_SHM

Macros
#define	GDATALOGGER_MAXVARIABLES   150
#define	QUEUE_MAXDESTINATIONS   4
#define	QUEUE_DESTINATION_FILE   QUEUE_READ_GATE_0
#define	QUEUE_DESTINATION_IPC   QUEUE_READ_GATE_1
#define	QUEUE_DESTINATION_USER1   QUEUE_READ_GATE_2
#define	QUEUE_DESTINATION_USER2   QUEUE_READ_GATE_3
#define	GDATALOGGER_IPC_MAXQUEUESIZE   1000
#define	GDATALOGGER_IPC_FLAGIDDLE   0
#define	GDATALOGGER_IPC_FLAGREQUESTDATA   1
#define	GDATALOGGER_IPC_FLAGDATAAVAILABLE   2
#define	GDATALOGGER_IPC_FLAGNOTEXIST   3
#define	GDATALOGGER_IPC_FLAGTIMEOUT   4
#define	GDATALOGGER_IPC_STATEFILE   "/gdatalogger.shm"

Typedefs
typedef struct GDATALOGGERVARIABLE *	PGDATALOGGERVARIABLE
typedef struct GDATALOGGER *	PGDATALOGGER

Functions
int	gDataLogger_Init (PGDATALOGGER pgDataLogger, char *filename, char *dirname)
int	gDataLogger_DeclareVariable (PGDATALOGGER pgDataLogger, char *varname, char *varunit, int nrows, int ncols, int queuesize)
int	gDataLogger_InsertVariable (PGDATALOGGER pgDataLogger, char *varname, double *varvalue)
int	gDataLogger_IPC_RetrieveVariable (char *varname, char *varunit, double *pbuffer, int *bufferlen)
int	gDataLogger_MatfileUpdate (PGDATALOGGER pgDataLogger)
int	gDataLogger_IPCUpdate (PGDATALOGGER pgDataLogger)
int	gDataLogger_Close (PGDATALOGGER pgDataLogger)

Macro Definition Documentation

#define GDATALOGGER_IPC_FLAGDATAAVAILABLE   2

Definition at line 41 of file gdatalogger.h.

Referenced by gDataLogger_IPC_RetrieveVariable(), and gDataLogger_IPCUpdate().

#define GDATALOGGER_IPC_FLAGIDDLE   0

Definition at line 39 of file gdatalogger.h.

Referenced by gDataLogger_Init(), and gDataLogger_IPC_RetrieveVariable().

#define GDATALOGGER_IPC_FLAGNOTEXIST   3

Definition at line 42 of file gdatalogger.h.

Referenced by gDataLogger_IPC_RetrieveVariable(), and gDataLogger_IPCUpdate().

#define GDATALOGGER_IPC_FLAGREQUESTDATA   1

Definition at line 40 of file gdatalogger.h.

Referenced by gDataLogger_IPC_RetrieveVariable(), and gDataLogger_IPCUpdate().

#define GDATALOGGER_IPC_FLAGTIMEOUT   4

Definition at line 43 of file gdatalogger.h.

Referenced by gDataLogger_IPC_RetrieveVariable().

#define GDATALOGGER_IPC_MAXQUEUESIZE   1000

Definition at line 38 of file gdatalogger.h.

#define GDATALOGGER_IPC_STATEFILE   "/gdatalogger.shm"

Definition at line 56 of file gdatalogger.h.

Referenced by gDataLogger_Close(), and gDataLogger_Init().

#define GDATALOGGER_MAXVARIABLES   150

Definition at line 13 of file gdatalogger.h.

Referenced by gDataLogger_DeclareVariable(), and gDataLogger_Init().

#define QUEUE_DESTINATION_FILE   QUEUE_READ_GATE_0

Definition at line 33 of file gdatalogger.h.

Referenced by gDataLogger_InsertVariable(), and gDataLogger_MatfileUpdate().

#define QUEUE_DESTINATION_IPC   QUEUE_READ_GATE_1

Definition at line 34 of file gdatalogger.h.

Referenced by gDataLogger_IPCUpdate().

#define QUEUE_DESTINATION_USER1   QUEUE_READ_GATE_2

Definition at line 35 of file gdatalogger.h.

#define QUEUE_DESTINATION_USER2   QUEUE_READ_GATE_3

Definition at line 36 of file gdatalogger.h.

#define QUEUE_MAXDESTINATIONS   4

Definition at line 32 of file gdatalogger.h.

Referenced by gDataLogger_DeclareVariable().

Typedef Documentation

typedef struct GDATALOGGER* PGDATALOGGER

typedef struct GDATALOGGERVARIABLE* PGDATALOGGERVARIABLE

Function Documentation

int gDataLogger_Close

(

PGDATALOGGER

pgDataLogger

)

Definition at line 362 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, GDATALOGGER_IPC_STATEFILE, gDataLogger_MatfileUpdate(), gDataLoggerIPC_SHM_fd, gDataLoggerIPC_SHM_flagmodeserver, gMATLABDataFile_Close(), gMATLABDataFile_SaveVector(), GDATALOGGER::GMatlabDataFileConfig, GDATALOGGERVARIABLE::GMatlabDataFileIndex, GDATALOGGERVARIABLE::HasBeenWritten, GDATALOGGER::m_NumberOfVariables, GDATALOGGERVARIABLE::Nc, GDATALOGGERVARIABLE::Nr, TRUE, GDATALOGGERVARIABLE::VariableName, GDATALOGGER::Variables, and GDATALOGGERVARIABLE::VariableUnit.

Referenced by datalogger_close().

{
        int nvar,datasize;
        double v;
    double *value;
        char matvarname[70];

        /* Garante salvar ultimos dados inseridos: */
        if(pgDataLogger!=NULL){
                gDataLogger_MatfileUpdate(pgDataLogger);

                /* Se for um unico escalar, trata de forma especial: */
        for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
            if((pgDataLogger->Variables[nvar].Nc == 1)&&(pgDataLogger->Variables[nvar].Nr == 1)){
                    if(pgDataLogger->Variables[nvar].HasBeenWritten == 1){
                        value = (double *) malloc(sizeof(double));
                        value[0] = pgDataLogger->Variables[nvar].CircularQueue[0];
                        sprintf(matvarname,"%s_%li_%li",pgDataLogger->Variables[nvar].VariableName, (long int)0, (long int)0);
                        gMATLABDataFile_SaveVector(&pgDataLogger->GMatlabDataFileConfig, matvarname, value, 1);
                        free(value);
                        pgDataLogger->Variables[nvar].GMatlabDataFileIndex = 1;
                    }
            }
        }

                /* Cria variaveis que indicam o numero de cada variavel salva: */
                for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
                        v = (double)(pgDataLogger->Variables[nvar].GMatlabDataFileIndex);
                        datasize = 1;
                        sprintf(matvarname,"%s_size",pgDataLogger->Variables[nvar].VariableName);
                        gMATLABDataFile_SaveVector(&pgDataLogger->GMatlabDataFileConfig, matvarname, &v, datasize);
                }

                /* Salva o numero de linhas: */
                for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
                        v = (double)(pgDataLogger->Variables[nvar].Nr);
                        datasize = 1;
                        sprintf(matvarname,"%s_nr",pgDataLogger->Variables[nvar].VariableName);
                        gMATLABDataFile_SaveVector(&pgDataLogger->GMatlabDataFileConfig, matvarname, &v, datasize);
                }

                /* Salva o numero de colunas: */
                for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
                        v = (double)(pgDataLogger->Variables[nvar].Nc);
                        datasize = 1;
                        sprintf(matvarname,"%s_nc",pgDataLogger->Variables[nvar].VariableName);
                        gMATLABDataFile_SaveVector(&pgDataLogger->GMatlabDataFileConfig, matvarname, &v, datasize);
                }

                /* Fecha o arquivo. */
                gMATLABDataFile_Close(&pgDataLogger->GMatlabDataFileConfig);

                /* Deletar as filas: */
                for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
                        sprintf(pgDataLogger->Variables[nvar].VariableName," ");
                        sprintf(pgDataLogger->Variables[nvar].VariableUnit," ");
                        free(pgDataLogger->Variables[nvar].CircularQueue);
                        pgDataLogger->Variables[nvar].CircularQueue = NULL;
                        pgDataLogger->Variables[nvar].GMatlabDataFileIndex = 0;
                }
                pgDataLogger->m_NumberOfVariables = 0;
        }
        
        /* IPC: */
#if DATALOGGER_COMPILE_FOR_XENOMAI
        if(gDataLoggerIPC_SHM_flagmodeserver){
                rt_heap_free(&gDataLoggerIPC_SHM_hd,pgDataLoggerIPC_SHM);
                rt_heap_delete(&gDataLoggerIPC_SHM_hd);
        } else{
                rt_heap_unbind(&gDataLoggerIPC_SHM_hd);
        }
#else
        munmap(pgDataLoggerIPC_SHM, sizeof(GDATALOGGERIPC_SHM));
        close(gDataLoggerIPC_SHM_fd);
        shm_unlink(GDATALOGGER_IPC_STATEFILE);
#endif
        
        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gDataLogger_DeclareVariable	(	PGDATALOGGER	pgDataLogger,
		char *	varname,
		char *	varunit,
		int	nrows,
		int	ncols,
		int	queuesize
	)

Definition at line 173 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, GDATALOGGERVARIABLE::CircularQueueControl, FALSE, GDATALOGGER_MAXVARIABLES, GDATALOGGERVARIABLE::GMatlabDataFileIndex, gQUEUE_Init(), GDATALOGGER::m_NumberOfVariables, GDATALOGGERVARIABLE::Nc, GDATALOGGERVARIABLE::Nr, QUEUE_MAXDESTINATIONS, TRUE, GDATALOGGERVARIABLE::VariableName, GDATALOGGER::Variables, and GDATALOGGERVARIABLE::VariableUnit.

Referenced by datalogger_init().

{
        if(pgDataLogger->m_NumberOfVariables>=GDATALOGGER_MAXVARIABLES-1){
                return(FALSE);
        }
        queuesize = queuesize * nrows * ncols; /* no caso, o tamanho da fila eh calculado em numero de elementos double. */
        sprintf(pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].VariableName,"%s",varname);
        sprintf(pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].VariableUnit,"%s",varunit);
        pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].CircularQueue = (double *) malloc(queuesize * nrows * ncols * sizeof(double));
        if(pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].CircularQueue==NULL){
                return(FALSE);
        }
        pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].Nr = nrows;
        pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].Nc = ncols;
        gQUEUE_Init(&pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].CircularQueueControl, queuesize, QUEUE_MAXDESTINATIONS);
        pgDataLogger->Variables[pgDataLogger->m_NumberOfVariables].GMatlabDataFileIndex = 0;
        
        ++pgDataLogger->m_NumberOfVariables;

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gDataLogger_Init	(	PGDATALOGGER	pgDataLogger,
		char *	filename,
		char *	dirname
	)

Definition at line 42 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, FALSE, GDATALOGGERIPC_SHM::Flag, GDATALOGGER_IPC_FLAGIDDLE, GDATALOGGER_IPC_STATEFILE, GDATALOGGER_MAXVARIABLES, gDataLoggerIPC_SHM_fd, gDataLoggerIPC_SHM_flagmodeserver, gMATLABDataFile_OpenWrite(), GDATALOGGER::GMatlabDataFileConfig, GDATALOGGERVARIABLE::GMatlabDataFileIndex, GDATALOGGERVARIABLE::HasBeenWritten, GDATALOGGER::m_NumberOfVariables, GDATALOGGERVARIABLE::Nc, GDATALOGGERVARIABLE::Nr, status, TRUE, GDATALOGGERVARIABLE::VariableName, GDATALOGGER::Variables, and GDATALOGGERVARIABLE::VariableUnit.

Referenced by datalogger_init().

{
        int i;
        int first = 0;
#if DATALOGGER_COMPILE_FOR_XENOMAI
        int err;
#else
        int status = 0;
#endif

        /* GQueue */
        if(pgDataLogger!=NULL){
                for (i=0;i<GDATALOGGER_MAXVARIABLES;++i){
                        sprintf(pgDataLogger->Variables[i].VariableName," ");
                        sprintf(pgDataLogger->Variables[i].VariableUnit," ");
                        pgDataLogger->Variables[i].CircularQueue = NULL;
                        pgDataLogger->Variables[i].GMatlabDataFileIndex = 0;
                        pgDataLogger->Variables[i].Nc = 1;
                        pgDataLogger->Variables[i].Nr = 1;
            pgDataLogger->Variables[i].HasBeenWritten = 0;
                }
                pgDataLogger->m_NumberOfVariables = 0;
        }

        /* IPC */
#if DATALOGGER_COMPILE_FOR_XENOMAI
        if(pgDataLogger!=NULL){
                /* cria memoria compartilhada */
                int heapsize;
                if(sizeof(GDATALOGGERIPC_SHM) > ((256*1024))){
                        heapsize = sizeof(GDATALOGGERIPC_SHM);
                }
                else{
                        heapsize = ((256*1024));
                }
                
                if((err=rt_heap_create(&gDataLoggerIPC_SHM_hd,GDATALOGGER_IPC_STATEFILE,sizeof(GDATALOGGERIPC_SHM),H_SHARED))!=0){
                        printf("gDataLogger_Init: Could not create xenomai heap object (return %i)\n", err);
                        printf("\n EEXIST = %i",EEXIST);
                        printf("\n EINVAL = %i",EINVAL);
                        printf("\n ENOMEM = %i",ENOMEM);
                        printf("\n EPERM = %i",EPERM);
                        printf("\n EIDRM = %i",EIDRM);
                        printf("\n ENOSYS = %i",ENOSYS);
                        if(err==-EEXIST){
                                err=rt_heap_delete(&gDataLoggerIPC_SHM_hd);
                                printf("gDataLogger_Init: Deleting xenomai heap object (return %i)\n", err);
                        }
                        return FALSE;
                }

                if(rt_heap_alloc(&gDataLoggerIPC_SHM_hd,sizeof(GDATALOGGERIPC_SHM),TM_NONBLOCK,(void**)&pgDataLoggerIPC_SHM)!=0){
                        printf("gDataLogger_Init: Could not allocated xenomai heap object. (return %i)\n", err);
                        return FALSE;
                }

                first = 1; /* We are the first instance */
                gDataLoggerIPC_SHM_flagmodeserver = 1;
        }
        else{
                /* abre memoria compartilhada */
                if((err=rt_heap_bind(&gDataLoggerIPC_SHM_hd,GDATALOGGER_IPC_STATEFILE,TM_NONBLOCK))!=0){
                        /* printf("gDataLogger_Init: Could not create xenomai heap object (return %i)\n", err); */
/*                      printf("\n EEXIST = %i",EEXIST);
                        printf("\n EINVAL = %i",EINVAL);
                        printf("\n ENOMEM = %i",ENOMEM);
                        printf("\n EPERM = %i",EPERM);
                        printf("\n EIDRM = %i",EIDRM);
                        printf("\n ENOSYS = %i",ENOSYS);*/
                        return FALSE;
                }

                if(rt_heap_alloc(&gDataLoggerIPC_SHM_hd,0,TM_NONBLOCK,(void**)&pgDataLoggerIPC_SHM)!=0){
                        printf("gDataLogger_Init: Could not allocated xenomai heap object. (return %i)\n", err);
                        return FALSE;
                }

                gDataLoggerIPC_SHM_flagmodeserver = 0;
        }

#else
        /* Try to open the shm instance with  O_EXCL, this tests if the shm is already opened by someone else */
        if((gDataLoggerIPC_SHM_fd = shm_open(GDATALOGGER_IPC_STATEFILE, (O_CREAT | O_RDWR),(S_IREAD | S_IWRITE))) < 0) {
                /* Try to open the shm instance normally and share it with existing clients */
                printf("gDataLogger_Init: Could not create shm object. %s\n", strerror(errno));
                return FALSE;
        }       
        if(pgDataLogger!=NULL){
                gDataLoggerIPC_SHM_flagmodeserver = 1;
                first = 1;
        } else{
                gDataLoggerIPC_SHM_flagmodeserver = 0;
                first = 0;
        }
/*      if((gDataLoggerIPC_SHM_fd = shm_open(GDATALOGGER_IPC_STATEFILE, (O_CREAT | O_EXCL | O_RDWR),(S_IREAD | S_IWRITE))) > 0 ) {
*/                first = 1; /* We are the first instance */
/*                gDataLoggerIPC_SHM_flagmodeserver = 1;
        }
        else if((gDataLoggerIPC_SHM_fd = shm_open(GDATALOGGER_IPC_STATEFILE, (O_CREAT | O_RDWR),(S_IREAD | S_IWRITE))) < 0) {
*/              /* Try to open the shm instance normally and share it with existing clients */
/*              printf("gDataLogger_Init: Could not create shm object. %s\n", strerror(errno));
                return FALSE;
        } 
*/      /* Set the size of the SHM to be the size of the struct. */
        status = ftruncate(gDataLoggerIPC_SHM_fd, sizeof(GDATALOGGERIPC_SHM));

        /* Connect the conf pointer to set to the shared memory area, with desired permissions */
        if((pgDataLoggerIPC_SHM =  mmap(0, sizeof(GDATALOGGERIPC_SHM), (PROT_READ | PROT_WRITE), MAP_SHARED, gDataLoggerIPC_SHM_fd, 0)) == MAP_FAILED) {
                return FALSE;
        }

        /* Set permission so all can read/write to shared memory */
    status = fchmod(gDataLoggerIPC_SHM_fd, (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH));

#endif
        
        if(first){
                pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGIDDLE;
        }

        /* GMatlabDataFile */
        if((pgDataLogger!=NULL)&&(filename!=NULL)){
                return(gMATLABDataFile_OpenWrite(&pgDataLogger->GMatlabDataFileConfig, filename, dirname));
        }
        
        return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gDataLogger_InsertVariable	(	PGDATALOGGER	pgDataLogger,
		char *	varname,
		double *	varvalue
	)

Definition at line 199 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, GDATALOGGERVARIABLE::CircularQueueControl, FALSE, GQUEUECONTROL::FlagFull, gDataLogger_MatfileUpdate(), gQUEUE_RequestWriteIndex(), GDATALOGGERVARIABLE::HasBeenWritten, GDATALOGGER::m_NumberOfVariables, GDATALOGGERVARIABLE::Nc, GDATALOGGERVARIABLE::Nr, QUEUE_DESTINATION_FILE, TRUE, GDATALOGGERVARIABLE::VariableName, and GDATALOGGER::Variables.

Referenced by datalogger_init(), datalogger_set_Ts(), and datalogger_update().

{
        int queueindex,varindex,n;
        long int nr,nc;
        int FlagQueueFull;
        
        /* Procura pela variavel */
        varindex = -1;
        for(n=0;n<pgDataLogger->m_NumberOfVariables;++n){
                if(strcmp(varname,pgDataLogger->Variables[n].VariableName)==0){
                        varindex = n;
                        break;
                }
        }
        if(varindex<0){
                return(FALSE);
        }

    if(pgDataLogger->Variables[varindex].HasBeenWritten == 1) pgDataLogger->Variables[varindex].HasBeenWritten = 2; // Second write
    if(pgDataLogger->Variables[varindex].HasBeenWritten == 0) pgDataLogger->Variables[varindex].HasBeenWritten = 1; // First write (1 data point)

        /* Insere o conteudo */
        for(nr=0;nr<pgDataLogger->Variables[varindex].Nr;++nr){
                for(nc=0;nc<pgDataLogger->Variables[varindex].Nc;++nc){
                        FlagQueueFull = gQUEUE_RequestWriteIndex(&pgDataLogger->Variables[varindex].CircularQueueControl, &queueindex);

                        pgDataLogger->Variables[varindex].CircularQueue[queueindex] = varvalue[nr+(nc)*pgDataLogger->Variables[varindex].Nr];

                        if(!FlagQueueFull){
                                /* The queue is full. Test if it is the reading head associated to matlab data files. */
                                if(pgDataLogger->Variables[varindex].CircularQueueControl.FlagFull[QUEUE_DESTINATION_FILE]==TRUE){
                                        /* Empty in matlab data file. */
                                        gDataLogger_MatfileUpdate(pgDataLogger);
                                        /* Clear flag: */
                                        pgDataLogger->Variables[varindex].CircularQueueControl.FlagFull[QUEUE_DESTINATION_FILE] = FALSE;
                                }
                        }
                }
        }

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gDataLogger_IPC_RetrieveVariable	(	char *	varname,
		char *	varunit,
		double *	pbuffer,
		int *	bufferlen
	)

Definition at line 319 of file gdatalogger.c.

References GDATALOGGERIPC_SHM::Flag, GDATALOGGER_IPC_FLAGDATAAVAILABLE, GDATALOGGER_IPC_FLAGIDDLE, GDATALOGGER_IPC_FLAGNOTEXIST, GDATALOGGER_IPC_FLAGREQUESTDATA, GDATALOGGER_IPC_FLAGTIMEOUT, GDATALOGGERIPC_SHM::QueueData, GDATALOGGERIPC_SHM::QueueSize, GDATALOGGERIPC_SHM::VariableName, and GDATALOGGERIPC_SHM::VariableUnit.

{
        int counter;
        
        sprintf(pgDataLoggerIPC_SHM->VariableName, "%s", varname);
        pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGREQUESTDATA;
        
/*      printf("\ngDataLogger_IPC_RetrieveVariable: solicitação feita pela variavel %s",varname); */

        counter = 0;
        while(pgDataLoggerIPC_SHM->Flag == GDATALOGGER_IPC_FLAGREQUESTDATA){
                usleep(10000);
                if(++counter > 100){
                        *bufferlen = 0;
                        pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGIDDLE;
                        /* printf("\ngDataLogger_IPC_RetrieveVariable: solicitação não atendida"); */
                        return GDATALOGGER_IPC_FLAGTIMEOUT;
                }
        }
        
        if(pgDataLoggerIPC_SHM->Flag==GDATALOGGER_IPC_FLAGDATAAVAILABLE){
                memcpy(pbuffer,pgDataLoggerIPC_SHM->QueueData, pgDataLoggerIPC_SHM->QueueSize * sizeof(double));
                sprintf(varunit, "%s", pgDataLoggerIPC_SHM->VariableUnit);
                *bufferlen = pgDataLoggerIPC_SHM->QueueSize;
                pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGIDDLE;
                return GDATALOGGER_IPC_FLAGDATAAVAILABLE;
        }

        if(pgDataLoggerIPC_SHM->Flag==GDATALOGGER_IPC_FLAGNOTEXIST){
                *bufferlen = 0;
                pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGIDDLE;
                return GDATALOGGER_IPC_FLAGNOTEXIST;
        }
        
        *bufferlen = 0;
        pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGIDDLE;
        return GDATALOGGER_IPC_FLAGIDDLE;
}

int gDataLogger_IPCUpdate

(

PGDATALOGGER

pgDataLogger

)

Definition at line 274 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, GDATALOGGERVARIABLE::CircularQueueControl, FALSE, GDATALOGGERIPC_SHM::Flag, GDATALOGGER_IPC_FLAGDATAAVAILABLE, GDATALOGGER_IPC_FLAGNOTEXIST, GDATALOGGER_IPC_FLAGREQUESTDATA, gDataLoggerIPC_SHM_flagmodeserver, gQUEUE_GetNumberOfUnreadData(), gQUEUE_RequestReadIndex(), GDATALOGGER::m_NumberOfVariables, QUEUE_DESTINATION_IPC, GDATALOGGERIPC_SHM::QueueData, GDATALOGGERIPC_SHM::QueueSize, TRUE, GDATALOGGERVARIABLE::VariableName, GDATALOGGERIPC_SHM::VariableName, GDATALOGGER::Variables, GDATALOGGERVARIABLE::VariableUnit, and GDATALOGGERIPC_SHM::VariableUnit.

Referenced by datalogger_update_IPC().

{
        int QueueIndex,nvar,n,i;

        /********** IPC **********/
        if(gDataLoggerIPC_SHM_flagmodeserver==0){
                return FALSE;
        }
        
        if(pgDataLoggerIPC_SHM->Flag == GDATALOGGER_IPC_FLAGREQUESTDATA){
                
                /* Procura pela variavel */
                nvar = -1;
                for(n=0;n<pgDataLogger->m_NumberOfVariables;++n){
                        if(strcmp(pgDataLoggerIPC_SHM->VariableName,pgDataLogger->Variables[n].VariableName)==0){
                                nvar = n;
                                break;
                        }
                }
                if(nvar<0){
                        pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGNOTEXIST;
                        return FALSE; 
                }

                /* Metodo otimizado, que salva em uma variavel MATLAB todas as ultimas leituras. */
                if(!gQUEUE_GetNumberOfUnreadData(&pgDataLogger->Variables[nvar].CircularQueueControl, QUEUE_DESTINATION_IPC, &pgDataLoggerIPC_SHM->QueueSize)){
                        pgDataLoggerIPC_SHM->QueueSize = 0;
                }
                if(pgDataLoggerIPC_SHM->QueueSize>0){ /* Existem dados a serem salvos. */
                        for(i=0;i<pgDataLoggerIPC_SHM->QueueSize;++i){
                                gQUEUE_RequestReadIndex(&pgDataLogger->Variables[nvar].CircularQueueControl, QUEUE_DESTINATION_IPC, &QueueIndex);
                                pgDataLoggerIPC_SHM->QueueData[i] = pgDataLogger->Variables[nvar].CircularQueue[QueueIndex];
                        }
                }
                
                sprintf(pgDataLoggerIPC_SHM->VariableUnit, "%s", pgDataLogger->Variables[nvar].VariableUnit);
                pgDataLoggerIPC_SHM->Flag = GDATALOGGER_IPC_FLAGDATAAVAILABLE;
        }

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int gDataLogger_MatfileUpdate

(

PGDATALOGGER

pgDataLogger

)

Definition at line 245 of file gdatalogger.c.

References GDATALOGGERVARIABLE::CircularQueue, GDATALOGGERVARIABLE::CircularQueueControl, FALSE, gMATLABDataFile_SaveVector(), GDATALOGGER::GMatlabDataFileConfig, GDATALOGGERVARIABLE::GMatlabDataFileIndex, gQUEUE_GetNumberOfUnreadData(), gQUEUE_RequestReadIndex(), GDATALOGGER::m_NumberOfVariables, QUEUE_DESTINATION_FILE, TRUE, GDATALOGGERVARIABLE::VariableName, and GDATALOGGER::Variables.

Referenced by datalogger_close(), datalogger_write_file(), gDataLogger_Close(), and gDataLogger_InsertVariable().

{
        int QueueIndex,nvar,datasize,i;
        double *v;
        char matvarname[70];

        /********** MATFILE **********/
        /* Esvaziar queues de todas as variaveis que vao para o arquivo: */
        for(nvar=0;nvar<pgDataLogger->m_NumberOfVariables;++nvar){
                /* Metodo otimizado, que salva em uma variavel MATLAB todas as ultimas leituras. */
                if(!gQUEUE_GetNumberOfUnreadData(&pgDataLogger->Variables[nvar].CircularQueueControl, QUEUE_DESTINATION_FILE, &datasize)){
                        return(FALSE);
                }
                if(datasize>0){ /* Existem dados a serem salvos. */
                        v = (double *) malloc(datasize * sizeof(double));
                        for(i=0;i<datasize;++i){
                                gQUEUE_RequestReadIndex(&pgDataLogger->Variables[nvar].CircularQueueControl, QUEUE_DESTINATION_FILE, &QueueIndex);
                                v[i] = pgDataLogger->Variables[nvar].CircularQueue[QueueIndex];
                        }
                        sprintf(matvarname,"%s_%li_%li",pgDataLogger->Variables[nvar].VariableName,pgDataLogger->Variables[nvar].GMatlabDataFileIndex,pgDataLogger->Variables[nvar].GMatlabDataFileIndex+datasize-1);
                        gMATLABDataFile_SaveVector(&pgDataLogger->GMatlabDataFileConfig, matvarname, v, datasize);
                        free(v);
                        pgDataLogger->Variables[nvar].GMatlabDataFileIndex += datasize;
                }
        }

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function: