Hi, Habe da so ein Problem wo ich ein bischen ratlos bin. Verwende einen stm32F105 und die lib 3.3 sowie Code Sourcery light. Wenn ich in irgendeinen Interruppt will z.B. Can, macht er das auch wie er soll. Der Code wird ausgeführt und dann sollte der Rücksprung erfolgen. Da knallts! Er springt mir immer in den Hard fault. Auch wenn kein Code in der Routine steht (nur a++; oder so) geht er zwar ordendlich rein, aler nicht wieder raus. Es ist schwer zu prüfen da ich nicht sehe woher er genau kommt. Einsicht in den Assembler Code habe ich. Hat einer eine Idee?
Anton schrieb: > Hat einer eine Idee? Ja, du machst was falsch. Angefangen mit dem Beitrag, denn wer soll dir anhand dieser komplett nicht vorhanden Information helfen können?
Wahrscheinlich korrupter Stack. Schreibst Du irgendwo über ein Array hinaus oder ähnliches? Gruß Tom
Sowas ähnliches gab es doch in den letzten Tagen schon mal hier. Ein User hatte die Interruptfunktion nicht als Interrupt deklariert...
Beim STM32 wär's eher fatal, wenn er sie als Interrupt deklariert. Bei den Cortex-M3 sind Handler normale C Funktionen.
Anton schrieb: > Da knallts! Er springt mir immer in den Hard fault. Auch wenn kein Code > in der Routine steht (nur a++; oder so) geht er zwar ordendlich rein, > aler nicht wieder raus. Von AVRs verwöhnt? Bei den STM32 ist es nicht üblich, dass sich Interrupts von selbst zurücksetzen sobald der Handler aufgerufen wird. Muss man schon selbst Hand anlegen.
UI, so viele Ohrfeigen auf ein mal. Aber der Code steht fest, ich sagte lib 3.3. Habe das Beispiel für CAN 1.1 kopiert und aufgespielt, voher meine Prozessor eingestellt und geplänkel programmiert. Nichts besonderes. Mit dem Einblick in den Assembler Code meinte ich das ich einige Sachen überprüfen könnte wenn ich wüste wonach ich schauen soll. Das der Stack etwas damit zu tun hat ist mir klar, auch wie er allgemein funktioniert, aber wie genau bei Cortex, und wo kann ich mich auf die Fehlersuche begeben, das ist ja der Grund warum ich hier schreibe. Den Code in den Anhang zu stellen bringt glaube ich nicht viel.
AN A.K, Zum Zurücksetzen komme ich ja nicht, auch wird die Routine nur einmal aufgerufen, dann Hard Fault.
So stehts drin:
00146
/***********************************************************************
*******/
00147 /* STM32F10x Peripherals Interrupt Handlers
*/
00148
/***********************************************************************
*******/
00149
00150
00151 /**
00152 * @brief This function handles CAN1 Handler.
00153 * @param None
00154 * @retval None
00155 */
00156 #ifndef STM32F10X_CL
00157 void USB_LP_CAN1_RX0_IRQHandler(void)
00158 #else
00159 void CAN1_RX0_IRQHandler(void)
00160 #endif
00161 {
00162 CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
00163 if ((RxMessage.StdId == 0x321)&&(RxMessage.IDE ==
CAN_ID_STD)&&(RxMessage.DLC == 1))
00164 {
00165 LED_Display(RxMessage.Data[0]);
00166 Key_Pressed_Number = RxMessage.Data[0];
00167 }
00168 }
Anton schrieb: > Zum Zurücksetzen komme ich ja nicht, auch wird die Routine nur einmal > aufgerufen, dann Hard Fault. Du schreibst, dass er in den Handler rein, aber nicht wieder sauber rauskommt. Interrupt zurücksetzen tut man im Handler. Was ein Handler komplett ohne Code nicht tut. Darauf bezog ich mich.
Anton schrieb: > Den Code in den Anhang zu stellen bringt glaube ich nicht viel. Wenn es der Sample-Code ist, dann nicht. Allerdings hattest du das anfangs nicht erwähnt und so konnte das ja auch niemand wissen. Du wirst mal nachforschen müssen wie der Stack definiert wird. Das ist meist Sache des noch unbekannt gebliebenen Startup-Codes und des Linker-Scripts. Ich habe nicht parat, ob CS da was mitliefert oder das in der FwLib bzw. dem CSMIS mitschwimmt oder ob du es anderweitig organisiert hast.
Mir geht es ja um diesen blöden Stack. wo find ich diesen Schw....hund. Mein Linker script ist dieses hier. und der Startup Code der. Im Moment befinde ich mich auf dem STM3210E-Eval Board. Irgendwie sag ich mir aber das dieser dem Compiler sagt wie er in die IRQ reinkommt, aber raus ist doch eigentlich seine Sache.
Nebenbei: RxMessage und key_pressed werden im Handler geschrieben, sind aber nicht volatile.
Dein Stack hat die Grösse 0. Dessen oberes Ende ist _estack, dessen unteres Ende _ebss. Direkt davor steht der CAN RxBuffer. Jedenfalls definiert dies den Stack:
1 | _ebss = .; |
2 | *(.stack) |
3 | _estack = .; |
d.h. es muss irgenwo ein Array passender Grösse in eine section ".stack" gelegt werden.
Für die Cortex kannst du wunderbar fault handler schreiben. Der Cortex speichert eine ganze Menge Informationen in dafür vorgesehene Register. Folge mal dem Link, dort beschreibt der Autor des Buches "The Definitive Guide to the ARM Cortex-M3", wie man an die Infos kommt. Das Buch ist meiner Meinung nach auch zu empfehlen. 2. Posting lesen. https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/Hard%20Fault%20and%20stack%20pushing Ich meine wenn die Stackgröße 0 Byte lang ist, dann kannst du dir das sparen ;-) Aber der Link ist vielleicht allgemein für andere auch hilfreich.
wie kann ich den stack den anders definieren, zwar wird er bei diesem Programm nicht viel brauchen, aber irgendwo muss es ja dran liegen.
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.