Newsgroup: it.comp.programmare
Titolo: rientro da interrupt..che non deve riprendere da quel punto

Ciao,sto programmando in C per un microcontrollore a 16bit,
avrei l'esigenza che quando avviene un certo evento esterno il controllo
vada alla routine di interrupt,e al rientro da questa vorrei che il mio
programma non ripartisse dal punto in cui l'interrupt è avvenuto ,ma in un
altro punto diciamo  precedente
qual'è il modo più elegante,in C senza dover ricorrere a  goto label?Non mi
interessa conservare i parametri nello stack ,ma naturalmente lo stack
pointer dovrebbe rpristinare il suo valore corretto
oppure ,appena + complicato:
il mio programma attende in un loop tipo
void main(void){
while(1){
   // non fare niente
}
}
in caso di interrupt salta a
void miaInterrupt Routine( ){
        faiquesto( );
        faiquestaltro( );
}
per esempio mentre sono in
void faiquesto( ){
        int a;
        a++;
        if ecc..ecc..
     }
vorrei , se avvenisse un certo altro interrupt, ritornare a main(qui
immagino che dovrò pulire il flag di interrupt per abilitarne un altro)
è possibile?
Grazie!

 è possibile?
E' possibile!
Devi usare le apposite funzioni setjmp() e longjmp() definite in 
setjmp.h concepite proprio per la tua esigenza.

 wrote in message
efqLi.11623$5f3....@tornado.fastwebnet.it...

grazie,prima di tutto
immagino che tu intenda in ambiente windows(che non è il mio caso),comunque
sai come implementarle?sono solo delle goto che si preoccupano di
ripristinare il puntatore allo stack e il program counter?

blisca ha scritto:

Non ho un ambiente unix sotto mano al momento, solo windows, ma mi pare 
proprio che siano funzioni C standard, e non vincolate al sistema operativo.
Comunque devi effettuare una chiamata alla setjmp() nel punto in cui 
vuoi salvare stack, registri e tutto quanto.
Quando effettui una chiamata alla longjmp(), l'esecuzione ritorna al 
punto in cui hai chiamato la setjmp() ripartendo dall'istruzione successiva.
Il parametro che passi alla longjmp(), che deve essere diverso da zero, 
   verra' usato come valore di ritorno della setjmp()
Se la longjmp() viene invocata in punti diversi del tuo programma, 
allora puoi gestire tutto comodamente con una switch.
Esempio.
#include <setjmp.h>
jmp_buf buf;
main()
{
	...
	switch(setjmp(buf))
	{
	case 0: /* qui arriva la prima volta */
		break;
	case 1: /* qui arriva quando eseguirai longjmp(buf, 1) */
		break;
	case 2: /* qui arriva quando eseguirai longjmp(buf, 2) */
		break;
		...
	}
	...
}
gestione_1()
{
	...
	longjmp(buf, 1); /* salta al case 1 in main() */
 
	/* qui non arriva mai */
	return;
}
 
gestione_2()
{
	...
	longjmp(buf, 2); /* salta al case 2 in main() */
 
	/* neanche qui arriva mai */
	return;
}


la coppia setjmp - longjmp sono fortissimamente compiler-dependent, 
tipicamente la prima salva lo stato del programma e la seconda lo 
ripristina e questo 'stato' e' compiler dependent.
sono usate,tipicamente, per ritornare da un numero ( virtualmente ) 
illimitato di chiamate di subroutine in un colpo solo.
SE il compilatore le implementa le puoi usare altrimenti ciccia.
attenzione, potrebbero non funzionare correttamente all'interno di una 
routine d'interrupt
all'interno di una singola funzione probabilmente la soluzione piu' 
semplice e' usare proprio i goto.

 semplice e' usare proprio i goto.
Vi ringrazio davvero per i pareri e l'esempio,ora provo e spero di avere
riusltati utili per il completamento di questa discussione
Buona serata o notte a tutti