#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include "gqueue.h"
#include "gmatlabdatafile.h"
#include "gdatalogger.h"

Include dependency graph for gdatalogger.c:

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_MatfileUpdate (PGDATALOGGER pgDataLogger)

int	gDataLogger_IPCUpdate (PGDATALOGGER pgDataLogger)

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

int	gDataLogger_Close (PGDATALOGGER pgDataLogger)

Variables
static GDATALOGGERIPC_SHM *	pgDataLoggerIPC_SHM = NULL

static int	gDataLoggerIPC_SHM_flagmodeserver = 1

static int	gDataLoggerIPC_SHM_fd = 0

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);
 }