[c++] un millisecondo

[valentino861]

Sto cercando un algoritmo che mi stampi i valori del tempo con un delta T di 1 millesimo. Ho provato cosi:

#include <time.h>
#include <stdio.h>

double temp;
double tempf=0;
int millis;
int main()
{
	while (2<3){
	clock_t clock();	
	//Quanti cilci fa il PC in un millesimo di secondo		
	millis=CLOCKS_PER_SEC/1000;	
	temp=0.001*(clock()/millis);
	if(temp>1.000){getchar();}
	
	
	while (temp>=tempf)
	{
		
	printf("Stampa tempo %f tempf %f\n",temp,tempf);

	tempf=temp+0.001;
	}
	
	
}
return 0;
}

Trascurate i dettagli di come ho impostato il while iniziale :s . In ogni caso non ottengo ciò che cerco, l'intervallo tra i due valori è sempre maggiore, come potrei fare?

[valentino861]

anche cosi, vedo che non segna ogni singolo millisecondo, anche se dovrebbe in quanto in un millisecondo fa molte operazioni come si vede qui:

#include <time.h>
#include <stdio.h>

double temp,delta;
double tempf=0;
int count=0;
int millis;
int main()
{
	while (2<3){
	clock_t clock();	
	//Quanti cilci fa il PC in un millesimo di secondo		
	millis=CLOCKS_PER_SEC/1000;	
	temp=0.001*(clock()/millis);
	printf("contatore: %i tempo: %f\n",count,temp);
	count++;
	if (temp>1){getchar();}

	//prova=(temp+0.001)*millis/0.001;
}
return 0;
}

[apatriarca]

Perché stai cercando di misurare differenze di tempo così piccole? Esistono dei timer più precisi ma non nello standard C e non sono quindi portabili e a volte presentano alcuni problemi. Che cosa vuoi fare esattamente?

[valentino861]

Il problema è un pò complesso. Dovrei salvare un dato ogni millisecondo.

Sto lavorando con un accelerometro che ha una frequenza di acquisizione di 60Hz che significa un periodo di 16,67 ms. Ora il programma fa un refresh automatico ogni volta che sente una variazione di accelerazione ma questo ovviamente avviene ogni 16,67 ms e quindi sto cercando un modo di memorizzare cmq un valore ogni ms anche se risultano uguali per 16,67ms.

Capito? Cioè sto cercando di ottenere una acquisizione "fittizia" dei dati ogni millisecondi,anche se quella reale avviene ogni 16,67ms.
Quindi pensavo di fare un if imponendo che se rivela una variazione di accelerazione la memorizza sennò segna lo stesso valore per 16-17ms

[apatriarca]

Su quale sistema operativo stai lavorando? Il mio consiglio è quello di modificare i valori ogni 16,67ms e scrivere i 16-17 valori invece che uno solo. Garantire un framerate costante di 1000Hz è una cosa molto più complicata e probabilmente impossibile in molti casi...

[valentino861]

su windows.
Modificare i valori ogni 16,67ms significa scrivere 1 valore non 16-17 no?!

Cmq sto capendo che è più complicato di quello che credessi.

[apatriarca]

Puoi dare un occhiata alle funzioni QueryPerformanceCounter e QueryPerformanceFrequency che sono molto più precise di clock, ma scrivere una applicazione hard real-time che funziona a 1000Hz su Windows non è una cosa semplice (ricordati che la tua applicazione è solo una delle tante applicazioni aperte...). Il mio consiglio era di aspettare una modifica, verificare il tempo passato dall'ultimo aggiornamento e scrivere 16 o 17 valori nel tuo array (uno è quello nuovo e gli altri sono quelli vecchi ripetuti).

[valentino861]

infatti è quello che ho fatto ma ho poi visto che i tempi non coincidevano e che quindi non era in real-time.

[Umby2]

Ho fatto anche io un piccolo programma per contare i cicli, ed il risultato mette in evidenza quanto già detto nel topic precedente.
I valori ( si tratta di centesimi di secondo , e non millesimi ) oscillano tra i 9.600 e 10.400 cicli. Questo perchè il pc non stai mai fermo, anche quando sembra di esserlo.

[valentino861]

si si infatti. Ma alla fine mi sa che lascio la frequenza dell'accelerometro, almeno quel tempo è certo e non mi impazzisco più di tanto.

[Umby2]

Ultima mia osservazione:

se a te interessa avere un timer, che ti da il tempo (ad esempio, ogni centesimo di secondo, cosi' come ho fatto io nel mio programma di prova), poco deve interessare se in questo tempo hai 8000, 9000, o 10000 cicli. La cosa importante è che tu riesca a capire quando termina un "periodo" e ne inizia un altro.