Newsgroup: it.hobby.elettronica.digitale
Titolo: piantare li tutto,salvare e aspettare spegnimento

Ciao
 
Ho un microcntrollore Cortex M0 che fa varie cose,chiama funzioni che 
chiamano funzioni,salta in interrupts ecc
 
Se mi va via l'alimentazione ,un condensatore relativamente grosso mi dà 
qualche centinaio di ms di autonomia.
Io vorrei in questo tempo salvare in Flash alcuni dati e attendere lo 
spegnimento
Al limite non nutro il watchdog,così se l'alimentazione ritorna non 
resto imbambolato,e mi resetto comunque
 
 
Durante il funzionamento normale non dovrei essere nidificato 
all'interno di qualche funzione .Sono nel main loop,e salto in qualche 
breve interrupt in continuazione.Se succede il blackout scatta un 
interrupt, nel peggiore dei casi in pochi us uscirò dall'interrupt 
attuale se ha stessa priorità,l'interrupt di blackout farà brevi 
operazioni,cambierà i flag che servono,e nel main loop:
...	
if(blackout_flag)
{
	SpegniPeriferiche();//riduco consumi,ho solo condensatore
	SalvaInFlashQualcosa();
	DisabilitaWatchDogRefresh();//per andare in reset comunque
 
	//attesa spegimento
	w
hile(1);//O si spegne tutto o si resetta tutto da WDog
}
Supponiamo di volere gestire anche il caso di blackout mentre sono 
nidificato in una funzione interna,so per certo che poi il uC si 
spegnerà,oppure disabilitando il rinfresco del watchdog andrà in 
reset,nel caso il blackout duri pochi ms
 
In poche parole,dando per certo uno spegnimento o un reset vorrei capire 
se posso fare una cosa che non si dovrebbe :
 
chiamare queste funzioni che precedono lo spegnimento direttamente dalla 
routine di interrupt,che di regola dovrebbe essere brevissima
e in questo caso non lo è
 
es
 
void My_PORTA_Interrupt(void)
{
 
   if(pin_PowerDownDetector==LOW)
   {
   	SpegniPeriferiche(); //riduco consumi,ho solo condensatore
   	SalvaInFlashQualcosa();
   	DisabilitaWatchDogRefresh();
 
	//attesa spegimento
   	while(1);//O si spegne tutto o si resetta tutto da WDog
   }
 
}
 
Pessima idea?
Cosa si rischia?Di sfondare il limite dello stack?
C'è modo più pulito ?
 
Grazie
 

 C'č modo piů pulito ?
 
Il problema dello stack lo avresti anche se chiamassi il codice da una
funzione normale. La chiamata a ISR occupa sicuramente qualche word
aggiuntiva di stack per il salvataggio del contesto, ma non mi sembra
niente di radicale.
 
Per il resto considerando che non uscirai mai piů dalla ISR, non vedo
problematiche a restarci dentro anche per sempre. Le ISR devono essere
brevi per non interrompere per troppo tempo tutto il resto, ma nel tuo
scenario tutto il resto non c'č piů!
 
Vedo solo due potenziali problemi:
 
1) Le funzioni che chiami devono essere sincrone, non devono aspettare
interrupt. Se piloti dei periferici dovrai fare delle "busy wait" sui flag
di completamento delle operazioni. Inoltre quando entri nella ISR č bene
(se non lo fa automaticamente il processore) disattivare qualsiasi
interrupt, in modo da essere certi di non perdere mai il controllo.
 
2) Anche se ti fermi dentro alla ISR, č comunque bene non chiamare funzioni
non rientranti. Pensa ad esempio a una tipica funzione di trasmissione SPI:
(1) abilito chip enable, (2) trasmetto/ricevo, (3) disabilito chip enable.
Se la tua ISR interviene fra (2) e (3) e poi dentro alla ISR torni a
chiamare la suddetta funzione, farai sicuramente dei casini.
 
-- 
Fletto i muscoli e sono nel vuoto.

 chiamare la suddetta funzione, farai sicuramente dei casini.
 
molto chiaro ,tengo presente ci medito e ringrazio