Newsgroup: it.comp.lang.c
Titolo: letture temporizzate

Salve,
    ho bisogno di leggere il contenuto di una variabile ogni x microsecondi. 
Qualcuno sa come fare?
Grazie

 microsecondi. Qualcuno sa come fare?
Su che sistema?
-- 
Costantino Grana 

"Costantino Grana" <n...@invalid.inv> ha scritto nel messaggio 
news:ep2vo9$8rb$1...@news.cineca.it...

E' un dsp... dici che dipende dall'architettura?
Grazie 

 E' un dsp... dici che dipende dall'architettura?
Potrei sbagliarmi, ma la funzione standard più precisa dovrebbe essere 
clock, ma la precisione dipende dall'architettura. Vedi se fa al caso tuo.
-- 
Costantino Grana 

 Qualcuno sa come fare?
La funzione standard time non ha una risoluzione così alta, devi usare
un timer dipendende dal sistema operativo che usi. Sotto Linux (o
qualunque sistema POSIX) puoi usare:
- usleep(3)
- select(2) con set vuoto
- nanosleep(2)
Devi comunque tenere conto che la risoluzione teoria di questi
meccanismi di temporizzazione potrebbe non coincidere con quella
effettivamente ottenibile.
Luca
-- 
Alcuni pensano che io sia una persona orribile, ma non e` vero. Ho il
cuore di un ragazzino - in un vaso sulla scrivania.

Costantino Grana <n...@invalid.inv> ha scritto:

Attenzione che clock(3) restituisce il tempo CPU, non il tempo reale
trascorso. Se il programma è semplicemente idle in attesa di fare la
lettura seguente il tempo CPU usato sarà zero.
La risoluzione del risultato di clock(), inoltre, non è nota a priori.
Luca
-- 
Se non sei parte della soluzione, allora sei parte del problema.

 ha scritto nel messaggio
news:rq7th.3414$422....@twister2.libero.it...

In queste situazioni, cioč quando hai accesso
diretto all'hardware puoi tentare qualcosa di "basso livello".
OT {
    Normalmente dotresti avere una coppia di registri di
    programmazione del timer, TIMER_PERIOD_REGISTER
    e TIMER_COUNTER_REGISTER tanto per
    dargli un nome.
    Poniamo che mettendo il valore 0x200000
    imposti il periodo a 1/100 sec.
    Questo vuol dire che il secondo registro si incrementa
    continuamente da 0 a 0x200000-1 in un tempo
    pari a T = 0.01 sec.
    Gli step unitari del counter si chiamano spesso "tick".
    Questi numeri dipendono ovviamente dal clock fisico
    del tuo dispositivo.
}
Non devi fare altro che ciclare con un loop stretto
e contare i tick, fino a che non hai atteso
un valore opportuno di microsecondi.
Devi solo gestire correttamente il valore del counter
quando sei nei pressi della scadenza del periodo.
Cioč se TIMER_COUNTER_REGISTER = 0x1FFFFE
e subito dopo TIMER_COUNTER_REGISTER = 2
allora sono passati solo 4 tick.
Ricorda che per questo genere di operazioni
č opportuno utilizzare "volatile" per garantire
il "side-effect" dell'accesso.
Io farei qualcosa del genere (solo come esempio):
/* dsp-specific */
#define TIMER_PERIOD_REGISTER      (*(volatile unsigned int *)0x8840)
#define TIMER_COUNTER_REGISTER (*(volatile unsigned int *)0x8844)
volatile unsigned int v;
/* programmazione periodo: TIMER_PERIOD_REGISTER */
/* leggi var */
v = TIMER_COUNTER_REGISTER + GAP_TIME;
/*
 * Occhio!
 * non gestisco il passaggio 0xFFF --> 0x000 ecc.
 */
while (TIMER_COUNTER_REGISTER < v) {
    /* wait */
}
/* leggi ancora var ecc. */
Dove GAP_TIME č un valore in tick che corrisponde
al tuo 'x' micro secondi.
Cioč
#define MICRO_TO_TICK(micro)    /* mettere formula ... */
#define GAP_TIME            MICRO_TO_TICK(x)
Tutto ciň non č portabile.
Ma č un ultra-classico uso di "volatile".
--
Giorgio Silvestri
DSP/Embedded/Real Time OS   Software Engineer

 DSP/Embedded/Real Time OS   Software Engineer
Grazie mille, era proprio quello su cui mi stavo orientando, timer e cicli 
di attesa.
Saluti.

 Saluti.

 ha scritto nel messaggio 
news:1169654231.3...@m58g2000cwm.googlegroups.com...
ma hai un sistema operativo sotto o no?
No, il dsp funge da coprocessore e quindi ha un semplice sequenziatore.
Comunque penso di aver risolto.
Saluti.

 ha scritto nel messaggio 
news:QD6th.3316$qN4....@twister1.libero.it...

Dato che ho chiesto il vostro aiuto mi sembra giusto spiegarvi alla fine 
come ho risolto....
Effettivamente per la precisione da me richiesta e considerato che sul dsp 
non c'è SO non potevo utilizzare soluzioni già pronte. Quindi ho utilizzato 
il timer interno del dsp per farmi generare una interruzione ogni x 
microsecondi. La routine di gestione dell'interrupt incrementa un contatore 
che è il mio orologio di sistema e che mi permette di temporizzare tutte le 
altre operazioni.
Grazie a tutti.

 ha scritto nel messaggio
news:cS4uh.6723$qN4.1...@twister1.libero.it...

Che poi è il sistema che uso io.
Solo che a livello di microsecondi mi sembrava
eccessivamente pesante usare l'interrupt.
In realtà io uso un "mix" dei due.
Cioè per temporizzare le normali operazioni uso
un interrupt non troppo spinto (1 millisecondo)
mentre quando voglio qualcosa di più fine vado
in loop stretto "solo" nei punti che servono.
Se non hai problemi di "performance" direi che il
tuo metodo va bene senza dubbio.
Forse il tuo "x" è abbastanza grande quindi somiglia
alla mia situazione ...


 > altre operazioni.Che poi è il sistema che uso io.


loopando, non ottieni quello che cerchi.
Si era già stabilito che non c'è alcun S.O.
quindi tutto quello che viene eseguito è codice proprietario.
Quindi più facile da tenere sotto controllo, magari disabilitando
gli interrupt quando è opportuno.
