Newsgroup: it.hobby.elettronica.digitale
Titolo: quesito sorgente C

Sorry ma sono un vero principiante:
Sto modificando un sorgente e mi sono "intoppato" su come fa "girare" una
funzione per un TOT numero di secondi.
Mi date una dritta?
questo è il pezzo di codice interessato:
***********************************
flush_ON=FALSO;
  while(flush_ON==FALSO)
       {
     esegui_calibrazione();
       }
     flush_ON=VERO;
*************************************
e questa e la funzione, se servisse....................
********************************
unsigned char
esegui_calibrazione(void)
{
  unsigned int valore;
  unsigned int valore1;
  unsigned int valore2;
     LED_GIALLO=ON;      //apre il solenoide
              valore=leggi_PPO2(0);   //Legge il canale 0
      valore1=leggi_PPO2(1);   //legge il canale 1
      valore2=leggi_PPO2(2);   //legge il canale 3
       lcd_clear();
       lcd_puts("  FLUSHING BAG");
       lcd_2rigo();
       lcd_putchdec_PPO2(valore);
       lcd_puts("  ");
       lcd_putchdec_PPO2(valore1);
       lcd_puts("  ");
       lcd_putchdec_PPO2(valore2);
      DelayMs(250);
}
****************************************
grazie
Fabio

 *************************************
Questo ciclo while va in loop perchè non c'è nessuna istruzione che cambi
il valore di flush_ON in VERO all'interno del ciclo e se non è una
variabile globale non ti serve a nulla metterla all'interno della funzione
.. vedo che l'hai messa fuori dal ciclo : se ti va bene spostala dentro
ma a questo punto a cosa servirebbe il ciclo ? Tanto varrebbe eseguire
direttamente la funzione.
Ciao
Francesco Fontana
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Francesco Fontana
Ops ... forse nei micro è diverso ... 


flush_ON=FALSO;
  while(flush_ON==FALSO)
       {
     esegui_calibrazione();
       }
     flush_ON=VERO;
L'ultima istruzione non serve a niente, perché se è uscito dal ciclo è
perché flush_ON era VERO... ovviamente ragionando in logica booleana, cioè
flush_ON può solo assumere valore VERO o FALSO.
--
ColdShine
"L'esperienza è un'insegnante severa: prima ci esamina e solo dopo ci fa
lezione."
 - legge di Vernon Sanders

Non mi sono spiegato bene, scusate...
L'obbiettivo è quello di eseguire la funzione "esegui_calibrazione per ,
diciamo , 15 secondi. poi devo poter uscire dal ciclo che inizia con la
dichiarazione di flush_ON.
Il flusso del programma continua con la chiamata di un ciclo infinito che è
la parte più importante (for(;;) etc etc etc........)
Ho creato questo ciclo perchè questa operazione  deve iniziare e concludersi
prima dell'inizio del nuovo loop che costituisce il "cuore" del Main. E' un
controllo preliminare, diciamo.
Quindi la funzione suddetta mi serve che "giri" per il numero di secondi che
decido io, ma poi si deve interrompere.
Solo resettando il micro si deve ripetere.
Non sò se mi sono spiegato meglio....abbiate pazienza e grazie .
Credo non sia difficile ma non ci sono ancora arrivato (da solo).
Fabio M.


ma la funzione di calibrazione devi continuare a chiamarla per tutti i 15
secondi ?!? cioè deve ripetersi chessò 150 volte se impiega 1/10 ad essere
eseguita, ad esempio ?
beh... se è così semplicemente utilizza un timer e metti come condizione di
uscita dal ciclo il valore che deve esserci nel registro (oppure nella
variabile di conteggio se non riesci ad ottenere 15 secondi solamente con il
registro del timer) allo scadere del 15° secondo.
ciao!
Marco

eseguita, ad esempio ?
si, è così!
deve essere eseguita in continuazione per tutto il tempo che voglio io
(15-20 secondi)
ho risolto, non credo sia una maniera elegante ma sembra funzionare....così
flush_ON=FALSO;
  while(flush_ON==FALSO)
       {
       int i
        for (i=0;i<80;i++)     // valore scelto a caso provando con il
cronometro
            {
             esegui_calibrazione();
            }
          altra istruzione;
            altra istruzione1;
            altra istruzione2;
        flush_ON=VERO
       }
Grazie a tutti, mi avete fatto "pensare" nel verso giusto.
Si accettano critiche e migliorie di queste povere 4 righe
Ciao
Fabio

 Si accettano critiche e migliorie di queste povere 4 righe
così però ottieni la ripetizione di 80 volte della calibrazione, ma appena
finito il ciclo interno flush_ON diventa vero ed esci immediatamente dal
ciclo esterno... tanto vale toglierlo a questo punto, no ?
ripeto, come soluzione più "elegante" ci sarebbe l'uso del timer. giusto per
curiosità con che microC stai lavorando ?
ciao!
Marco

Il 16f876,
ma in effetti questa calibrazione consiste nel leggere il valore fornito da
questi benedetti sensori per un certo lasso di tempo,in certe condizioni
particolari, che durano il tempo della calibrazione stessa.
I sensori vengono "stimolati" forniscono un valore stabile che ho il tempo
di "registrare" e poi esco dal loop. Il valore lo uso dopo per correggere
un'altra lettura.
Per questo devo leggerli continuamente per un tot, il tempo che mi serve
perchè mi restituiscano un valore stabile.
Mi sono spiegato?
I timers non li conosco ancora ,devo studiare:-)
Ciao
Fabio
Marco Trapanese ha scritto nel messaggio ...


 ho risolto, non credo sia una maniera elegante ma sembra
funzionare....cosě
