STM32F103 nach Interrupt im Nirvana

[Christian J. (Gast)]

Hallo,

ich arbeite mit Embitz und debugge mich grad durch meine Funkanwendung. 
Soweit so gut, die Daten kommen auch rein aber seltsamerweise hängt sich 
die CPU dann irgendwie auf. D.h. Breakpoints im Hauptprogramm werden 
nicht mehr erkannt aber die Interrupts die LEDs blinken lasse laufen 
munter weiter.

Im Debug Mode lässt sich das Problem soweit einkreisen, wie im Bild zu 
sehen. D.h. dsas Funkmodul hat gültige Daten empfangen, es wurde ein INT 
ausgelöst und die CPU holt sich diese rein. Tippe ich mich bis zum Ende 
durch ist bei der Klammer Schluss, danach ist er "weg". Kein gelber 
Balken mehr, keine Reaktion auf Breakpoints. Callstack stimmt aber 
soweit.

Ich habe beim Linken übrigens LTO eigeschaltet, benutze die Nano Lib.

Kennt das jemand?

Gruss,
Christian

[DraconiX (Gast)]

Den Interrupt Handler hast du ordnungsgemäß zurückgesetzt?! Die 
Komplette ISR zur Posten wäre eventuell Sinnvoll. ;-)

[hans im glück (Gast)]

Einfach mal pausieren? Wo steht er dann?

[Aruinoquäler (Gast)]

DraconiX schrieb:
> Den Interrupt Handler hast du ordnungsgemäß zurückgesetzt?!

Den Interrupt Handler kann man nicht zurücksetzen. Allenfalls
kann und sollte man ein Interrupt Flag zurücksetzen wenn es
gesetzt wurde.

[DraconiX (Gast)]

Aruinoquäler schrieb:
> DraconiX schrieb:
> Den Interrupt Handler hast du ordnungsgemäß zurückgesetzt?!
>
> Den Interrupt Handler kann man nicht zurücksetzen. Allenfalls
> kann und sollte man ein Interrupt Flag zurücksetzen wenn es
> gesetzt wurde.

Ja gut, dann halt im Interrupt-Handler die Interrupt-Flag zurück 
gesetzt. :-D

Und ja, wenn ein Int ausgelöst wurde, wurde die Flag ja auch sicherlich 
gesetzt. Gibt es denn beim STM32 ein Interrupt der ausgelöst werden 
kann, welcher nicht zurück gesetzt werden muss? Ist mir bis dato noch 
nicht übern Weg gelaufen, wäre aber Interessant zu wissen.

[Christian J. (Gast)]

Ich kapier es nicht!

In der for Schleife landet er im HardFault Handler! Das war doch vorher 
nicht....


/* Startet die RTC */
void Init_RTC()
{
        volatile uint32_t i;
        /* Enable PWR and BKP clocks */
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, 
ENABLE);
        /* LSI clock stabilization time */
        for(i=0;i<5000;i++);

[Christian J. (Gast)]

DraconiX schrieb:
> Den Interrupt Handler hast du ordnungsgemäß zurückgesetzt?! Die
> Komplette ISR zur Posten wäre eventuell Sinnvoll. ;-)

Ähm...... Den setze ich nicht zurück, der soll ja zur Laufzeit umgebogen 
sein. Ich setze nur die INT Flags zurück.....

Problem ist: Das Laufzeitverhalten ist anders als wenn ich rum debugge.
Mein Master sendet 150 Datensätze, die stehen beim "Run" im Debug Mode 
auch alle fein im Array of struct drin, läuft nichts über etc. Alle 3 
Timer lösen ihren Int aus, der RTC Int auch, die Dimmung über die PWM 
Outsputs läuft auch....  setze ich einen roten Break Punkt klebt er 
sofort da dran.
aber er ist aus main while (1) {...} einfach raus. Da kommt er gar nicht 
mehr hin.

Der Stop Knopf zum Pausieren geht nicht mehr, da passiert gar nichts 
mehr.

Habe testweise mal die Libs verändert, nehme ich die Link Time 
Optimization raus schmiert er mit hardFault ganz ab.


Hier die Int Routine:

/* ====================== Interrupt Handler RF Modul ============================*/

void IRQ_ROUTINE(void)
{

    static uint8_t tcnt = 0;

    if(EXTI_GetITStatus(IRQ_LINE)!=RESET)
    {
            // ISR Code.....
        if (RF_DataReady())
        {
            SetRedLED(ENABLE);
            // RF_CE_Enable(ENABLE);                    // TEST & FIXXXME !!!!

            /* In welcher Pipe sind Daten? */
            uint8_t pipe = RF_GetFilledPipe();
            /* Wie viele Bytes sind da ?*/
            uint8_t nrBytes = RF_GetPayloadSize();

            if ((pipe == 1) && (nrBytes <= sizeof(actual_data)))
            {
                f_RF_Timeout = false;
                ReceivedDataBlocks++;

                /* Daten auslesen */
                RF_ReadPayload((uint8_t*)&actual_data,nrBytes);

                if (actual_data.Feuchte_Now > 90)
                    actual_data.Feuchte_Now = 100;

                /* ----- Sind es historische Daten? ------------ */
                // Sind es historische Daten?
                if (actual_data.command == RX_CMD_HISTORY)
                {
                    // Neue Daten in Historie kopieren
                    uint8_t index = actual_data.nrDataSet;
                    if (index <= HISTORY_MAX_IDX)
                    {
                       /* Zeit gelegentlich neu setzen */
                        if (++tcnt >= 60) {
                            Set_NewTime(actual_data.unix);
                            tcnt = 0;
                        }
                       /* Daten aus Struct einsortieren usw */
                       Manage_RF_Data(index);
                       f_GotData = true;
                    }
                }

                /* ----- Sind es Daten für das E2PROM ? --------- */
                // ......
            }

            /* Fifo löschen, egal was noch drin war */
              RF_FlushRX();
              RF_ClearStatus();
              RF_CE_Enable(ENABLE);

              SetRedLED(DISABLE);
       }

    EXTI_ClearITPendingBit(IRQ_LINE);   // Remove LINE interrupt flag bit
    }
}

[Christian J. (Gast)]

Und hier der Init des Handlers für externe Pin Interrupst an GPIO A2.
DMA des AD Wandlers spielt auch noch munter weiter.

void RF_Init_Handler()
{

    /* PC1 Interrupt Pin konfigurieren auf Line 0 EXTI0_IRQn für Funbkmodul

        Line 0-4 haben einen eigenen Handler, 5-9 haben den Gleichen
        und 10-15 ebenfalls. Alle Px0 sind auf Line 0 angebunden usw.

        EXTI0_IRQn  EXTI0_IRQHandler  Handler for pins connected to line 0
        EXTI1_IRQn  EXTI1_IRQHandler  Handler for pins connected to line 1
        EXTI2_IRQn  EXTI2_IRQHandler  Handler for pins connected to line 2
        EXTI3_IRQn  EXTI3_IRQHandler  Handler for pins connected to line 3
        EXTI4_IRQn  EXTI4_IRQHandler  Handler for pins connected to line 4
        EXTI9_5_IRQn  EXTI9_5_IRQHandler  Handler for pins connected to line 5 to 9
        EXTI15_10_IRQn  EXTI15_10_IRQHandler  Handler for pins connected to line 10 to 15

    */

    GPIO_InitTypeDef GPIO_InitStruct;
    EXTI_InitTypeDef EXTI_InitStruct;
    NVIC_InitTypeDef NVIC_InitStruct;

    if (!spi_initialized)
       RF_Init_SPI();

     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    /* PA2 als Input */
    GPIO_StructInit (&GPIO_InitStruct);
    GPIO_InitStruct.GPIO_Pin    = IRQ_PIN;
    GPIO_InitStruct.GPIO_Mode   = GPIO_Mode_IN_FLOATING;
    GPIO_InitStruct.GPIO_Speed  = GPIO_Speed_50MHz;
    GPIO_Init(IRQ_PORT, &GPIO_InitStruct);

    // Line einem Port und Pin zuordnen, hier Port A, Pin 2 = PA2
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource2);

    /* Line 2 der External IRQs 2 konfigurieren */
    EXTI_InitStruct.EXTI_Line    = IRQ_LINE;                        /* PA2 ist verbunden mit EXTI_Line2 */
    EXTI_InitStruct.EXTI_LineCmd = ENABLE;                          /* Enable interrupt */
    EXTI_InitStruct.EXTI_Mode    = EXTI_Mode_Interrupt;             /* Interrupt mode */
    EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Falling;            /* Trigger auf fallende Flanke */
    EXTI_Init(&EXTI_InitStruct);                                    /* Aktivieren und zu EXTI hinzufügen */

    /* NVIC einbinden: PA2 ist auf EXTI_Line1 und hat den Vector EXT2_IRQn */
    NVIC_InitStruct.NVIC_IRQChannel = IRQ_HDL;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;          /* Höchste Priorität */
    NVIC_InitStruct.NVIC_IRQChannelSubPriority        = 0;          /* Sub Priorität */
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;                    /* Enable Interrupt */
    NVIC_Init(&NVIC_InitStruct);                                    /* Zum NVIC hinzufügen */

    NVIC_EnableIRQ(IRQ_HDL);                                     /* Interrupt ein */

}

[Christian J. (Gast)]

Globale Linker Settings

[(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· (Gast)]

Setz halt einen Brechpunkt in den Hardfaulthandler...

Dann kannst du dich mit den Moeglichkeiten beschaeftigen,
aus dem dort vorgefundenen Zustand auf den Fehler zu
schliessen.

[Christian J. (Gast)]

(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· schrieb im Beitrag 
#5105152:
> Dann kannst du dich mit den Moeglichkeiten beschaeftigen,
> aus dem dort vorgefundenen Zustand auf den Fehler zu
> schliessen.

Das lasse ich dann doch lieber sein, da ich mir dabei schon mal einen 
abgebrochen habe. Bisher hat eine Umschreibung mancher Probleme auf eine 
andere Art geholfen. Oder halt nested Interrupts verbieten, das 
eleminiert auch schon viele Fehler.

Wenn ich das unten auskommentiere ist das problem weg. Also ist da was 
strubbelig und sobald ich einen kaffee fertig habe geht die Nachtschicht 
weiter. Habe ja Urlaub und das Wetter ist mies :-)

                   // Neue Daten in Historie kopieren
                    uint8_t index = actual_data.nrDataSet;
                    if (index <= HISTORY_MAX_IDX)
                    {
                       /* Zeit gelegentlich neu setzen */
//                        if (++tcnt >= 60) {
//                            Set_NewTime(actual_data.unix);
//                            tcnt = 0;
//                        }
                       /* Daten aus Struct einsortieren usw */
//                       Manage_RF_Data(index);

PS:

Da liegt der Wurm drin... aber bisher lief die beanstandungsfrei

/* Zeit neu einstellen, läuft allein weiter per RTC ISR */
void Set_NewTime(uint32_t newtime)
{
   /* Unix Zeit für localtime casten */
   time_t value = (time_t)newtime;

   /* Interne RTC auf Masterstation sychronisieren */
   RTC_SetCounter(value);

   /* Unixzeit umwandeln */
   struct tm *ptr = localtime(&value);

   /* Zeit atomar in eigenen Struct holen */
   NVIC_DisableIRQ(RTC_IRQn);
   memcpy((void*)&mytime,ptr,sizeof(struct tm));  // mytime <- localtime Buffer
   NVIC_EnableIRQ(RTC_IRQn);
}

[(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· (Gast)]

Einen Brechpunkt im Hardfaulthandler zu setzen ist nun keine
Raketenwissenschaft.

Von TI gibt es eine recht informative Appnote wie Mann mit
den Informationen im Hardfault umgeht:

http://www.ti.com/lit/pdf/SPMA043

Da das alles ARM Systemregister sind, gilt das was dort steht
ohne Einschraenkungen auch fuer den M3 von ST (von der
Driverlib im ROM mal abgesehen...).

Aus der Appnote:
"The Stellaris Cortex-M processor provides a powerful fault
handling system and several features to help you find the
cause of a fault. After debugging a few faults, you will be
more comfortable handling and troubleshooting faults as they
happen, and will be able to find the cause in a few minutes."

Denk mal drueber nach!

[Christian J. (Gast)]

(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· schrieb im Beitrag 
#5105189:
> Einen Brechpunkt im Hardfaulthandler zu setzen ist nun keine
> Raketenwissenschaft.

Ich werde es mir mal anschauen, damals habe ich aber nur Bahnhof 
verstanden vor gut 1 Jahr. Dazu braucht man ja erstmal einen Einstieg 
und anschliessend "den Blick für das Wesentliche" um die Urache zu 
finden. Einen hardFault Handler schreiben ist easy, der Roohbau ist ja 
schon fertig.

PS: Habs! Auch ohne den Hardfault:

Diese Set_NewTime Routine rief localtime auf. Allerdings hatte ich in 
dieser die RTC Ints nicht abgeschaltet, so dass immer mal einer 
dazwischen haute. Die Routine ist nicht reentrant. Dachte der Compiler 
merkt das. Jetzt sind die aus und erstmal läuft es :-)

[Nop (Gast)]

Zum Hardfault Handler, da setzt man einen Breakpoint, greift sich den SP 
und guckt nach, was an der Adresse SP+24 steht. Das ist nämlich die 
Adresse, an der die Exception ausgelöst wurde.

Dann greift man sich das Mapfile und guckt, in welcher Funktion das ist. 
Oder man ist bequem und lädt die Firmware per Debugger und klickt sich 
dann zu der Adresse vor, dann sieht man auch gleich die Quelltextzeile.