Bestes Muster für WFI (Wait-for-Interrupt) auf Cortex (ARM) -Mikrocontrollern

Ich bin gerade dabei, batteriebetriebene Software mit den EFM Gekko-Controllern (http://energymicro.com/) zu entwickeln, und möchte, dass der Controller schläft, wenn es nichts Sinnvolles dafür gibt. Zu diesem Zweck wird der WFI-Befehl (Wait For Interrupt) verwendet. Dadurch wird der Prozessor in den Ruhezustand versetzt, bis ein Interrupt auftritt.

Wenn der Schlaf durch Speichern von etwas in Anspruch genommen würde, könnte man Lade- / Speicherexklusivoperationen verwenden, um etwas zu tun wie:

  // dont_sleep wird immer dann mit 2 geladen, wenn etwas passiert
  // sollte die Hauptschleife zwingen, mindestens einmal zu zyklieren. Wenn ein Interrupt
  // tritt auf, wodurch es während der folgenden Anweisung auf 2 zurückgesetzt wird,
  // Verhalten wird so sein, als ob der Interrupt danach passiert wäre.

  store_exclusive (load_exclusive (dont_sleep) >> 1);

  while (! nicht schlafen)
  {
    // Wenn zwischen der nächsten Anweisung und store_exclusive ein Interrupt auftritt, schlafe nicht
    load_exclusive (SLEEP_TRIGGER);
    if (! dont_sleep)             
      store_exclusive (SLEEP_TRIGGER);
  }

Wenn ein Interrupt zwischen den Operationen load_exclusive und store_exclusive auftritt, wird store_exclusive übersprungen, wodurch das System die Schleife erneut durchläuft (um festzustellen, ob der Interrupt dont_sleep gesetzt hat). Leider verwendet der Gekko einen WFI-Befehl anstelle einer Schreibadresse, um den Schlafmodus auszulösen. Schreiben von Code wie

  if (! dont_sleep)
    WFI ();

Es besteht die Gefahr, dass ein Interrupt zwischen 'if' und 'wfi' auftritt und 'dont_sleep' gesetzt wird, aber die wfi wird trotzdem ausgeführt. Was ist das beste Muster, um das zu verhindern? Setzen Sie PRIMASK auf 1, um zu verhindern, dass Interrupts den Prozessor kurz vor der Ausführung der WFI unterbrechen, und löschen Sie sie sofort nach? Oder gibt es einen besseren Trick?

BEARBEITEN

Ich wundere mich über das Ereignis. Nach der allgemeinen Beschreibung wäre es für die Unterstützung mehrerer Prozessoren gedacht, aber ich habe mich gefragt, ob etwas wie das Folgende funktionieren könnte:

  if (dont_sleep)
    SEV (); / * Löscht das Ereignis-Flag der folgenden WFE, ohne jedoch zu schlafen * /
  WFE ();

Jeder Interrupt, der "don't_sleep" setzt, sollte auch einen SEV-Befehl ausführen. Wenn der Interrupt also nach dem "if" -Test auftritt, löscht die WFE das Ereignis-Flag, geht aber nicht in den Ruhezustand. Klingt das nach einem guten Paradigma?

Ich habe die dont_sleepSache nicht vollständig verstanden , aber Sie könnten versuchen, die "Hauptarbeit" im PendSV-Handler zu erledigen, der auf die niedrigste Priorität eingestellt ist. Dann planen Sie einfach jedes Mal einen PendSV von anderen Handlern ein, wenn Sie etwas erledigen müssen. Sehen Sie hier, wie es geht (es ist für M1, aber M3 ist nicht zu unterschiedlich).

Eine weitere Möglichkeit, die Sie (möglicherweise zusammen mit dem vorherigen Ansatz) nutzen können, ist die Funktion "Sleep-on-exit". Wenn Sie dies aktivieren, wird der Prozessor nach dem Beenden des letzten ISR-Handlers in den Ruhezustand versetzt, ohne dass Sie WFI anrufen müssen. Sehen Sie einige Beispiele hier .

Legen Sie es in einen kritischen Bereich. ISRs werden nicht ausgeführt, sodass Sie nicht das Risiko eingehen, dass sich dont_sleep vor WFI ändert. Sie wecken jedoch den Prozessor und die ISRs werden ausgeführt, sobald der kritische Abschnitt endet.

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

Ihre Entwicklungsumgebung verfügt wahrscheinlich über wichtige Abschnittsfunktionen, die jedoch ungefähr so ​​aussehen:

EnterCriticalSection ist:

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

ExitCriticalSection ist:

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

Ihre Idee ist in Ordnung, genau das implementiert Linux. Sehen Sie hier .

Nützliches Zitat aus dem oben erwähnten Diskussionsthread, um zu verdeutlichen, warum WFI auch bei deaktivierten Interrupts funktioniert:

Wenn Sie bis zum nächsten Interrupt inaktiv bleiben möchten, müssen Sie einige Vorbereitungen treffen. Während dieser Vorbereitung kann ein Interrupt aktiv werden. Eine solche Unterbrechung kann ein Weckereignis sein, nach dem Sie suchen.

Egal wie gut Ihr Code ist, wenn Sie Interrupts nicht deaktivieren, werden Sie immer einen Wettlauf zwischen der Vorbereitung des Einschlafens und dem tatsächlichen Einschlafen haben, was zu verlorenen Weckereignissen führt.

Aus diesem Grund werden alle mir bekannten ARM-CPUs aktiviert, auch wenn sie in der Kern-CPU maskiert sind (CPSR I-Bit).

Alles andere und Sie sollten den Leerlaufmodus vergessen.

Vorausgesetzt, dass:

1. Der Hauptthread führt Hintergrundaufgaben aus
2. Die Interrupts führen nur Aufgaben mit hoher Priorität und keine Hintergrundaufgaben aus
3. Der Haupt-Thread kann jederzeit unterbrochen werden (er maskiert normalerweise keine Interrupts)

Dann besteht die Lösung darin, PRIMASK zu verwenden, um Interrupts zwischen der Flagvalidierung und WFI zu blockieren:

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

Was ist mit Sleep on Exit-Modus? Dieser geht automatisch in den Ruhezustand, wenn ein IRQ-Handler beendet wird, sodass nach der Konfiguration kein "normaler Modus" mehr ausgeführt wird. Ein IRQ passiert, er wacht auf und führt den Handler aus und geht wieder in den Schlaf. Kein WFI benötigt.