time.h para saber quantas aquisições fiz por segundo

Boa noite a todos, estou tendo um certo problema.

Antes de mais nada preciso explicar o que estou fazendo: um trabalho de aquisição de dados usando uma BeagleBone Black. E estou fazendo uma aquisição contínua de amostras.

Só que eu preciso saber de quantas aquisições estou fazendo a cada "1" segundo.

O código que tenho que pegar o tempo de aquisição é este:

while(1)
{

aval = fopen("/sys/devices/ocp.3/helper.15/AIN1", "r");
fseek(aval,0,SEEK_SET);
fscanf(aval,"%d",&value);
fclose(aval);
printf("value : %d\n",value);
}

Pensei em algo de como um contador de tempo que se incrementa, e quando houver estouro (1 s) pegar a quantidade de amostras que fiz e obtenho esse valor.


Desde já agradeço a todos que tentarem me ajudar, e aos que só olharam também.

Atenciosamente.

Cara faça algo assim :

#include <time.h>



clock_t tInicio, tFim, tDecorrido;



tInicio = clock();



/*seu codigo vem aqui*/



tFim = clock();



/*calcula aproximadamente o tempo em milisegundos gasto entre as duas chamadas de clock()*/



tDecorrido = ((tFim - tInicio) / (CLOCKS_PER_SEC / 1000));



 

Espero que ajude

Mas qualquer coisa pesquise por "contador em milissegundos C"

T+

Pesquisei um pouco mais a respeito do CLOCK_PER_SEC e consegui fazer com a ajuda de outro tutorial que postou esse código e com ele consegui fazer o que eu pretendia!

Código abençoado:

clock_t start;
clock_t finish;

start = clock();
finish = clock();

double delay = (double)(finish - start);

start = clock();
insertionsort();
finish = clock();

double elapsed = (double)(finish - start);
elapsed -= delay;


// calculate insertion time in seconds
double insertion_time = elapsed / CLOCKS_PER_SECOND;


// alternatively, we can calc it in milliseconds (ms)
const int MILLISEC_PER_SEC = 1000;
double time_in_ms = elapsed / CLOCKS_PER_SECOND * (double)(MILLISEC_PER_SEC);




Valeu!!

A função clock() não é adequada para fazer o que se perguntou. Teoricamente, ao menos, ela mede o tempo gasto de processador, não o tempo decorrido. Se o processo ficar basicamente esperando a operação de I/O, a diferença de tempo medida com clock() tende a ser baixa.

Veja o programa abaixo (minha resposta alternativa está implícita, mas só funciona no mundo UNIX-like, não em Windows).

#include <sys/time.h>

#include <time.h>

#include <unistd.h>

#include <stdio.h>



int main(void){

  clock_t c_start, c_end;

  struct timeval tv_start, tv_end;



  c_start=clock();

  gettimeofday(&tv_start, NULL);

  

  sleep(2);



  c_end=clock();

  gettimeofday(&tv_end, NULL);





  printf(

    "tv=%0.6lf, ticks=%d, cpu_time=%0.15lf\n",

    tv_end.tv_sec-tv_start.tv_sec+1.e-6*(tv_end.tv_usec-tv_start.tv_usec),

    (int)(c_end-c_start), (c_end-c_start)/(double)CLOCKS_PER_SEC

  );



  return 0;

} 

A saída do programa é a seguinte (note os valores zerados para ticks e cpu_time, embora a execução leve cerca de dois segundos).

tv=2.000073, ticks=0, cpu_time=0.000000000000000 

Outra forma de medir a quantidade de leituras por segundo é setar um alarme periódico com intervalo de um segundo (ou mais, se você quiser mais precisão, ao custo de ter de aguardar mais para ter a informação) e incrementar um contador a cada leitura lida. Quando "tocar" o alarme, a função tratadora computa/exibe o número de leituras, e reinicia o contador. Leia sobre setitimer() e sigaction().