STM8 Halt Mode / Wake Up über externen Interrupt

[Markus (markuswoe)]

Hallo Zusammen,

ich habe hier eine Hardware mit STM8AF und einem TJA1022 Dual LIN 
Transceiver.

Wenn einer der LIN Busse einschläft führt das System einen Reset durch, 
beim Neustart soll die Software die LIN Transceiver schlafen schicken 
und so lange in den Halt Mode gehen bis der LIN Transceiver einen 
externen Wakeup (sprich Busaktivität) erkennt.

Aussehen tut das so:

void main(void)
{
  delay_ms(50);
  // clock konfigurieren
  CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
  CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSE, DISABLE, CLK_CURRENTCLOCKSTATE_DISABLE);
  // LIN Transceiver in den Sleep Mode versetzen - EXTI_PORT_GPIOD sollt dann so lange floaten bis Aktivität erkannt wird
  GPIO_Init(SLIN_SLP_OUT_GPIO, (GPIO_Pin_TypeDef)SLIN_SLP_OUT_PIN, GPIO_MODE_OUT_PP_LOW_SLOW);
  GPIO_Init(MLIN_SLP_OUT_GPIO, (GPIO_Pin_TypeDef)MLIN_SLP_OUT_PIN, GPIO_MODE_OUT_PP_LOW_SLOW);
  // GPIO D6 als interruptfähigen Input mit PullUp konfigurieren
  GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6, GPIO_MODE_IN_PU_IT);
  // Externen interrupt konfigurieren 
  EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_FALL_ONLY);
  delay_ms(5);
  // prüfen, ob der Port schon LOW ist - falls Nein, Interrupts aktivieren und in den Halt Mode gehen
  if (GPIO_ReadInputPin(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6) == SET)
  {
    enableInterrupts();
    halt();
  }
  // ...
}

Das Problem ist nur es funktioniert nicht - halt() wird auch bei einem 
Reboot entweder nie aufgerufen oder das System kommt mehr oder weniger 
sofort zurück.

Hat irgendjemand eine Idee was ich hier falsch mache?

Danke und Gruß,
Markus

[Dieter S. (ds1)]

Mit dem hier

https://community.st.com/t5/stm8-mcus/stm8-library-bug-gpio-readinputpin/td-p/490178

beschriebenen Bug ("STM8 library bug - GPIO_ReadInputPin()"), der wohl 
davon abhängt welchen Compiler man benutzt, hat es nichts zu tun?

[Markus (markuswoe)]

OMG - ich hatte den Post sogar gesehen...
Habe mir den Quelltext von GPIO_ReadInputPin angesehen - das wird es 
gewesen sein.

Vielen Dank!

Habe es jetzt auf

if (GPIO_ReadInputPin(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6))

 geändert und werde es testen.

Mich stört aber noch, dass da eine Race Condition auftritt:

Was passiert wenn der Pegel GPIO D6 zwischen GPIO_ReadInputPin() und 
halt() auf Low geht? Dann kommt kein Interrupt (oder war schon da) und 
aus halt() wird nie zurückgekehrt - oder?

[Dieter S. (ds1)]

Eventuell hilft gegen die Race Condition wenn man in der ISR für den Pin 
ein Flag setzt und halt() nicht aufruft wenn das Flag gesetzt ist? 
Vermutlich müsste man dann aber auch den Ablauf bis zu halt() umstellen 
damit es passt.

[Markus (markuswoe)]

Das ändert aber nix - die Race condition geht nicht weg. Egal was man 
tut - wenn der Interrupt unmittelbar vor dem Aufruf von halt() kommt ist 
das Problem da. So kann man nur das Zeitfenster minimieren.

[Dieter S. (ds1)]

Muss man denn enableInterrupts() explizit vor halt() aufrufen?

Laut PM0044 ("STM8 CPU programming manual") für HALT:

"The interrupt mask is reset, allowing interrupts to be fetched."

[Markus (markuswoe)]

Danke - das probiere ich aus.
Da aber das prüfen des Input Pins und der Aufruf von halt() keine 
atomare Operation sind, kann da dennoch ein Interrupt 
dazwischengrätschen.

Anders wäre es, wenn Pegelwechsel nach Low nach Konfiguration des 
Interrupts "zwischengespeichert" würden und erst bei Reset der Interrupt 
Mask feuern würden.

Das weiß ich aber nicht.

[Peter D. (peda)]

Dieter S. schrieb:
> "The interrupt mask is reset, allowing interrupts to be fetched."

So ist es. HALT gibt die Interrupts wieder frei (atomar).

[Markus (markuswoe)]

Aber das hier ist keine atomare Operation:

if (GPIO_ReadInputPin(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6))
{
  // wenn der GPIO jetzt zwischen GPIO_ReadInputPin() und halt() auf LOW geht haben wir ein Problem.
  halt();
}

[Peter D. (peda)]

Markus schrieb:
> Aber das hier ist keine atomare Operation:

Vor das if kommt natürlich noch das Interrupt disable.

[Markus (markuswoe)]

Der Code läuft unmittelbar nach dem Reboot - da sind die Interrupts 
sowieso noch disabled. Aber bedeutet das konkret, dass es ggf. so 
ablaufen würde:

1) GPIO Pin geht von High nach Low
2) Aufruf halt() -> implizites enablen der Interrupts
3) Interrupt feuert, halt() kehrt zurück.

Das bedeutet, obwohl der GPIO Pin bei Aufruf von halt() schon Low ist 
feuert der Interrupt?

[Dieter S. (ds1)]

"EXTI_SENSITIVITY_FALL_LOW" ("Interrupt on Falling edge and Low level") 
anstelle "EXTI_SENSITIVITY_FALL_ONLY" ("Interrupt on Falling edge only") 
geht nicht?

[Markus (markuswoe)]

Und ob das geht - danke!

Genau das hatte ich gesucht, damit ist es nur noch dieser Dreizeiler:

GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6, GPIO_MODE_IN_PU_IT);
EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_FALL_ONLY);
halt();

[Dieter S. (ds1)]

Markus schrieb:
>
> Genau das hatte ich gesucht, damit ist es nur noch dieser Dreizeiler:
>
>

> GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6, GPIO_MODE_IN_PU_IT);
> EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_FALL_ONLY);
> halt();
>

Das sollte wohl "EXTI_SENSITIVITY_FALL_LOW" sein.

[Markus (markuswoe)]

> Das sollte wohl "EXTI_SENSITIVITY_FALL_LOW" sein.

Aber ja:

GPIO_Init(GPIOD, (GPIO_Pin_TypeDef)GPIO_PIN_6, GPIO_MODE_IN_PU_IT);
EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_FALL_LOW);
halt();

[Peter D. (peda)]

Markus schrieb:
> Mich stört aber noch, dass da eine Race Condition auftritt:

Die µC-Entwickler machen sich schon Gedanken, daß Race Conditions nicht 
auftreten, bzw. programmtechnisch ausgeschlossen werden können.
Der STM8 macht es dadurch einfach, daß HALT und Interrupt enable atomar 
erfolgen.

Bei den AVRs ist das deutlich umständlicher gelöst. Da kann man 
unendlich schlafen, wenn man nicht aufpaßt. Man muß direkt vor dem SLEEP 
die Interrupts enablen (SEI). Da der SEI-Befehl erst nach dem nächsten 
Befehl greift, ist sichergestellt, daß vor dem SLEEP kein Interrupt 
angesprungen werden kann:

      cli();
      if (some_condition)
      {
        sei();
        sleep_cpu();
      }
      sei();

[Markus (markuswoe)]

Ich hatte auch das Gefühl, dass es nicht sein kann, dass die Race 
Condition nicht zu vermeiden sein soll.

Habe aber einfach zu wenig Ahnung vom STM8.

Vielen Dank für die tolle Unterstützung!

P.S: Wie kriege ich den STM auf den kleinsten Stromverbrauch?

Aktuell: Alle Peripheral Clocks abschalten, alle GPIO auf 
GPIO_MODE_OUT_PP_LOW_SLOW, Halt.

Vorher wird noch die Clock auf 16 MHz Extern gesetzt, aber das sollte ja 
nichts ausmachen, da die Clock im Halt Mode ja ohnehin angehalten ist.

Das Ding braucht dennoch 2-4 mA (der "Hardware Guy" misst noch).
Kann natürlich an externen Komponneten liegen, auf die Hardware habe ich 
keinen direkten Einfluss.

Kann man da seitens der MCU noch was machen?

[Dieter S. (ds1)]

AN2857 ("STM8S and STM8A family power management") gibt einen guten 
Überlick mit Angaben zum jeweiligen Stomverbrauch.

[Markus (markuswoe)]

Ich kenne das Dokument. Hab's gerade nochmals durchgelesen.

Wenn ich es richtig sehe, kann ich mir das Abschalten der Peripheral 
clocks sparen, im Halt Mode sind sie sowieso aus - oder?

Ansonsten gab es keine Erleuchtungen.

[Markus (markuswoe)]

EXTI_SENSITIVITY_FALL_LOW hat leider nicht wie erwartet funktioniert - 
ich mutmaße weil ich den Interrupt in der ISR nicht richtig zurücksetze.

Was wäre da der richtige Weg?

[Markus (markuswoe)]

OK - nach langem hin- und herprobieren habe ich jetzt die scheinbar 
einzig funktionierende Variante gefunden. Ich schreibe das vor allem 
weil vielleicht ja jemand irgendwann über den Thread stolpert.

  // wait for external interrupt
  GPIO_Init(GPIOD, GPIO_PIN_6, GPIO_MODE_IN_PU_IT);
  EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_FALL_ONLY);  // EXTI_SENSITIVITY_FALL_LOW seems not to work
  delay_ms(1);
  if (GPIO_ReadInputPin(GPIOD, GPIO_PIN_6)) // don't compare with SET as GPIO_ReadInputPin will never return SET
  {
    enableInterrupts(); // halt() seems not to enable interrupts
    halt();
  }