Il miglior modello per i microcontroller WMI (wait-for-interrupt) su Cortex (ARM)

Sto cercando di sviluppare software alimentato a batteria utilizzando i controller Gekko EFM (http://energymicro.com/) e vorrei che il controller si addormentasse ogni volta che non c'è nulla di utile da fare. L'istruzione WFI (Wait For Interrupt) viene utilizzata per questo scopo; metterà il processore in standby fino a quando si verifica un interrupt.

Se il sonno fosse impegnato memorizzando qualcosa da qualche parte, si potrebbero usare operazioni di esclusione del carico / esclusive del negozio per fare qualcosa del tipo:

  // dont_sleep viene caricato con 2 ogni volta che succede qualcosa
  // dovrebbe forzare il ciclo principale a scorrere almeno una volta. Se un interrupt
  // si verifica che provoca il ripristino su 2 durante la seguente istruzione,
  // il comportamento sarà come se l'interruzione avvenisse dopo di esso.

  store_exclusive (load_exclusive (dont_sleep) >> 1);

  while (! dont_sleep)
  {
    // Se si verifica l'interruzione tra la prossima istruzione e store_exclusive, non dormire
    load_exclusive (SLEEP_TRIGGER);
    if (! dont_sleep)             
      store_exclusive (SLEEP_TRIGGER);
  }

Se dovesse verificarsi un interrupt tra le operazioni load_exclusive e store_exclusive, l'effetto sarebbe quello di saltare store_exclusive, facendo in modo che il sistema esegua il ciclo ancora una volta (per vedere se l'interrupt aveva impostato dont_sleep). Sfortunatamente, Gekko utilizza un'istruzione WFI anziché un indirizzo di scrittura per attivare la modalità di sospensione; scrivere codice come

  if (! dont_sleep)
    WFI ();

correrebbe il rischio che si verifichi un'interruzione tra 'if' e 'wfi' e imposti dont_sleep, ma il wfi andrebbe avanti ed eseguirà comunque. Qual è il modello migliore per impedirlo? Impostare PRIMASK su 1 per impedire agli interrupt di interrompere il processore prima di eseguire WFI e cancellarlo immediatamente dopo? O c'è qualche trucco migliore?

MODIFICARE

Mi chiedo il bit dell'evento. Secondo la descrizione generale, vorrebbe che fosse destinato al supporto di più processori, ma si chiedeva se potesse funzionare qualcosa di simile al seguente:

  if (dont_sleep)
    SEV (); / * Renderanno il seguente flag di evento WFE chiaro ma non inattivo * /
  WFE ();

Ogni interrupt che imposta Don't_sleep dovrebbe anche eseguire un'istruzione SEV, quindi se l'interrupt si verifica dopo il test "if", il WFE cancellerebbe il flag di evento ma non andrebbe in sospensione. Suona come un buon paradigma?

Non ho capito appieno la dont_sleepcosa, ma una cosa che potresti provare è fare il "lavoro principale" nel gestore PendSV, impostato sulla priorità più bassa. Quindi pianifica un PendSV da altri gestori ogni volta che hai bisogno di fare qualcosa. Vedi qui come farlo (è per M1 ma M3 non è troppo diverso).

Un'altra cosa che potresti usare (forse insieme all'approccio precedente) è la funzione Sleep-on-exit. Se lo abiliti, il processore andrà in sospensione dopo essere uscito dall'ultimo gestore ISR, senza che tu debba chiamare WFI. Vedi alcuni esempi qui .

Inseriscilo in una sezione critica. Gli ISR ​​non verranno eseguiti, quindi non si corre il rischio che dont_sleep cambi prima di WFI, ma continueranno a riattivare il processore e gli ISR ​​verranno eseguiti non appena termina la sezione critica.

uint8 interruptStatus;
interruptStatus = EnterCriticalSection();
if (!dont_sleep)
  WFI();
ExitCriticalSection(interruptStatus);

Il tuo ambiente di sviluppo ha probabilmente funzioni di sezione critica, ma è più o meno così:

EnterCriticalSection è:

MRS r0, PRIMASK /* Save interrupt state. */
CPSID i /* Turn off interrupts. */
BX lr /* Return. */

ExitCriticalSection è:

MSR PRIMASK, r0 /* Restore interrupt states. */
BX lr /* Return. */

La tua idea va bene, questo è esattamente ciò che implementa Linux. Vedi qui .

Citazione utile dal thread di discussione sopra menzionato per chiarire perché WFI funziona anche con gli interrupt disabilitati:

Se hai intenzione di restare inattivo fino al prossimo interrupt, devi fare un po 'di preparazione. Durante quella preparazione, un interrupt può diventare attivo. Tale interruzione potrebbe essere un evento di sveglia che stai cercando.

Non importa quanto sia buono il tuo codice, se non disabiliti gli interrupt, avrai sempre una corsa tra prepararti ad andare a dormire e effettivamente andare a dormire, il che si traduce in eventi di sveglia persi.

Questo è il motivo per cui tutte le CPU ARM di cui sono a conoscenza si riattivano anche se sono mascherate nella CPU principale (bit CPSR I.)

Nient'altro e dovresti dimenticare di utilizzare la modalità di inattività.

Supponendo che:

1. Il thread principale esegue attività in background
2. Gli interrupt eseguono solo attività ad alta priorità e nessuna attività in background
3. Il thread principale può essere interrotto in qualsiasi momento (normalmente non maschera gli interrupt)

Quindi la soluzione è utilizzare PRIMASK per bloccare gli interrupt tra la validazione del flag e WFI:

mask_interrupts();
if (!dont_sleep)
    wfi();
unmask_interrupts();

Che dire della modalità Sleep on Exit? Questo si spegne automaticamente ogni volta che esce un gestore IRQ, quindi non esiste alcuna "modalità normale" in esecuzione dopo che è stata configurata. Si verifica un IRQ, si sveglia, esegue il gestore e torna a dormire. Nessun WFI necessario.