STM32: HardFault simulieren

[Martin M. (gga)]

Hallo,

wie kann ich einen Hardfault per Software simulieren (auslösen)? Ich 
möchte prüfen, ob die in der Hardware Fault-Routine stehende Funktion 
geht.

Gruß
Martin

[Nop (Gast)]

Martin M. schrieb:

> wie kann ich einen Hardware Fault per Software simulieren (auslösen)?

Indem Du sie aufrufst oder Deine Hardware entsprechend veränderst, so 
daß Dein Programm sie als fehlerhaft erkennt.

Oder meinst Du etwas komplett anderes, nämlich den Hardfault mit seinem 
Hardfault-Handler? Der hat aber nichts mit einem Hardwarefault zu tun.

[Martin M. (gga)]

ich meinte den Hardfault-Handler. Wie kann ich den Prozessor dazu 
bringen, daß er mir diesen anspringt.

[Nop (Gast)]

Martin M. schrieb:
> ich meinte den Hardfault-Handler. Wie kann ich den Prozessor dazu
> bringen, daß er mir diesen anspringt.

Du kannst z.B. Speicher adressieren, den es gar nicht gibt.

[Vincent H. (vinci)]

Mal abgesehn von der zweifelhaften Praxis soetwas direkt auf der 
Hardware zu testen lässt sich der Hardfault-Handler aufrufen wie jede 
andere Funktion auch.

[Martin M. (gga)]

Speicher adressieren, den es gar nicht gibt geht nicht. Scheint der 
Compiler zu korrigieren. Ebenso Division durch Null bringt ihn nicht zum 
Absturz.

Grund für die Frage:
Es besteht der Verdacht, daß ein HardwareFault kommt. Um zu testen, ob 
das tatsächlich das Problem ist, soll eine gewisse Prozedur im 
Hard-Fault-Handler vollzogen werden. Man will nun testen, ob das auch so 
funktioniert wie gewünscht, oder ob irgend etwas davon in diesem Zustand 
nicht geht.

[Bernd K. (prof7bit)]

Vincent H. schrieb:
> lässt sich der Hardfault-Handler aufrufen wie jede
> andere Funktion auch.

Vielleicht hat er Code im Handler stehen der die Adresse und den Typ des 
Faults und den Stack beim Eintreten des Faults extrahieren soll, da 
nutzt es ihm wenig wenn er die Funktion einfach normal aufruft. Er will 
einen echten Hardfault provozieren um zu sehen ob es das macht was es 
soll.

[S. R. (svenska)]

Martin M. schrieb:
> Speicher adressieren, den es gar nicht gibt geht nicht.
> Scheint der Compiler zu korrigieren.

*(volatile uint32_t*)0x12345678 = 0x8765432;

funktioniert nicht? Schau ins Disassembly!

> Ebenso Division durch Null bringt ihn nicht zum Absturz.

Division durch Null führt nur bei Integer zu einem Absturz, bei 
Floating-Point gibt es ein (un)normales Ergebnis. Auch hier: Schau ins 
Disassembly!

Allgemein: Überprüfe deine Annahmen. Bringt ja nix, wenn der Prozessor 
seinen HardFault aufruft, scheitert, neu startet und dein Debugger so 
tut als wäre nichts gewesen.

[Bauform B. (bauformb)]

void breakpoint (void)
{
// verhaelt sich je nach Debugger-Status unterschiedlich
   __asm__ (" bkpt");
}

void undefined (void)
{
// es gibt auch andere, offizielle undefined opcodes
   __asm__ (" .word 0xffffffff");
}

void vector_table_crash (void)
{
   SCB->VTOR = 0xffffffff;
}

void MPU_test_null_pointer (void)
{
// crash, wenn 0x0 bis 0xirgendwas per MPU nicht gemappt ist und
// fuer den MemManage fault der hard fault handler eingetragen ist
   printf ("%lx\n", * (uint32_t *)4);
}

int recursion (int moe)
{
   recursion (moe + 1);
   return moe;
}

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Also wenn du keinen undefined Handler registriert hast (also alles auf 
den hardfault rauskommt), dann:
asm ("udf #0"); oder asm("udf");
Das ist eine definierte undefined Instruction ;)

div0 geht auch, aber den div0 Trap muss man im SCB ersteinmal 
aktivieren.
(was sich empfiehlt)

Vincent H. schrieb:
> Mal abgesehn von der zweifelhaften Praxis soetwas direkt auf der
> Hardware zu testen lässt sich der Hardfault-Handler aufrufen wie jede
> andere Funktion auch.

Unsinniges Geschwätz!
Er will ja grade gucken ob er die HW Register richtig ausließt, welche 
bei einem Fault vom ARM core gesetzt werden.

[drm (Gast)]

Simulieren ist zu ungenau.
Nur echte Tests geben relevante Aussagen.
Anleitung siehe Bild.

[TheBug (Gast)]

Auf eine ungrade Adresse einen Schreib- oder Lesezugriff in Wortbreite 
machen. Im Zweifelsfall halt ein paar Zeilen Assembler nehmen.

[Steffen R. (steffen_rose)]

Es wurde ja vieles dargestellt. Da sollte genug für die Umsetzung dabei 
sein. Nur ein paar zusätzliche Hinweise, warum es evtl. bisher nicht 
geklappt hat.

Je nach STM32 Typ gibt es leicht unterschiedliche Verhaltensweise. Das 
Core Handbuch hilft im Zweifelsfall.

Die Adressen sind teilweise gespiegelt. U.a. ist ab Adresse 0 gültiger 
Speicher. Die "ungültige Adresse" muss schon sinnvoll gewählt werden.

TheBug schrieb:
> Auf eine ungrade Adresse einen Schreib- oder Lesezugriff in Wortbreite
> machen.

Kommt auf den Typ an, ob unaligned Zugriffe gehen oder nicht.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Steffen R. schrieb:
> TheBug schrieb:
>> Auf eine ungrade Adresse einen Schreib- oder Lesezugriff in Wortbreite
>> machen.
>
> Kommt auf den Typ an, ob unaligned Zugriffe gehen oder nicht.

Bei M3, M4 und M7 muss man den unaligned Trap auch erstmal im SCB 
aktivieren.
Sonst ist das erlaubt.

Code lesen von einer graden Adresse (weil bei Thumb Bit 0 immer gesetzt 
ist) dürfte einen Hardfault ziemlich sicher auslösen.
Was jetzt auch nur für Cortex-M gilt.

[Jim M. (turboj)]

TheBug schrieb:
> Auf eine ungrade Adresse einen Schreib- oder Lesezugriff in Wortbreite
> machen. Im Zweifelsfall halt ein paar Zeilen Assembler nehmen.

Funktioner bei ArmV7-M (Cortex-M3 und aufwärts) per default nicht.

Witzigerweise wird beim 64-Bittigen Zugriffen (also unt64_t*) gerne mal 
die LDRD/STRD Tnstruktion verwendet, und die erzeugt wiederum 
Unaligned Faults.


Auf den Cortex-M4F könnte man unaligned Faults via FPU erzeugen, die 
möchte ihre Daten AFAIK auch word-aligned lesen.