Interruptroutine verlassen AT91SAM7A3, Eclipse, GNU

[Tobias (Gast)]

Liebe Community,

ich habe ein Problem (so fangen wohl die meisten Forumbeiträge an):
Seit einiger Zeit habe ich meinen Mikrocontroller und die Umgebung 
einigermaßen im Griff - erfolgreich PWM Signale erzeugt, LCD angesteuert 
und LEDs blinken lassen (gesteuert über Warteschleifen).
Jetzt benötige ich zum Einlesen von PWM Signalen Interruptroutinen.
Das klappt auch soweit schon mal, allerdings bricht das Programm nach 
Abarbeiten der Interruptroutine ab und kehrt nicht ins Hauptprogramm 
zurück.
Tüftel nun seit vielen Wochen an dem Problem rum und bekomm es einfach 
nicht hin.
Kann mir jemand einen Tipp geben, woran es mit eröhter 
Wahrscheinlichkeit liegen könnte?
- Makefile
- Irgendwelche Speicherinitialisierung
Ich muss dazu sagen, dass ich die Entwicklungsumgebung nicht komplett 
durchblicke, habe sie aber eigenständig zum Laufen gebracht... auch viel 
in den Datenblättern gelesen, aber bekomme das Problem nicht in den 
Griff :-( SEUFZ
Habe ein AT91SAM7A3 Entwicklerboard, benutze Eclipse, USBProg und ein 
vorgefertigtes Makefile, das bisher immer funktioniert hat.
Gerne lade ich auch Files und Code hoch, wollte euch nur im ersten 
Schritt nicht zu-spammen, weil ich ja keine Ahnung habe, in welcher Ecke 
das Problem stecken könnte.

Vielen Dank im Voraus für alle Tips und Tricks!
Gruß
Tobias

[Clemens L. (c_l)]

Tobias schrieb:
> allerdings bricht das Programm nach Abarbeiten der Interruptroutine ab

Was genau meinst du damit?  Dass überhaupt nichts mehr ausgeführt wird?

> und kehrt nicht ins Hauptprogramm zurück.

Wurde das Hauptprogramm denn vorher überhaupt ausgeführt, oder war die 
CPU gerade schlafen?

[Tobias M. (tobias_m327)]

Habe das Programm gerade nochmals ausführen lassen:
In meiner main-Routine habe ich ein zeitgesteuertes Blinkmuster in einer 
Endlosschleife.
In der Interrupt-Routine (ausgelöst durch ein High-Signal an einem Pin) 
habe ich ein anderes Blink-Muster.
Sobald ich also den besagten Pin auf high setze, läuft die 
Interrupt-Routine. Und zwar dauernd wiederholt.
Bis vor ein paar Tagen blieb das Programm noch stehen, wenn ich den Pin 
wieder auf low gesetzt habe, nun läuft die Interrupt-Routine dauernd 
weiter (und ich weiß leider nicht mehr, an was ich alles rumgedreht habe 
:-/).

[Tobias M. (tobias_m327)]

Hier kommen noch drei Code-Schnipsel, die einen Hinweis auf das Problem 
enthalten könnten:
1. den Interrupt Handler:

static void interrupt_handler_PB18 (void)
{
    AT91C_BASE_AIC->AIC_IDCR = (1<<3); //disable interrupt 3 (=PIO B)
    AT91C_BASE_AIC->AIC_ICCR = (1<<3); //Interrupt Clear Command Register
    blink(10,100);
    blink(1,2000);
    while((AT91C_BASE_PIOB->PIO_PDSR & (1<<18)));//Wait for the PIOB 18 to be 0 (taster loslassen).
    blink(1,5000);

    blink(1,5000);
    AT91C_BASE_AIC->AIC_IVR = 0x0;
    blink(1,5000);
    AT91C_BASE_PIOA -> PIO_CODR = (LED_C | LED_D);
    AT91C_BASE_PIOA -> PIO_SODR = (LED_B );
    blink(20,100);
    AT91C_BASE_AIC->AIC_IECR = (1<<3); //enable interrupt 3
    blink(1,5000);
    AT91C_BASE_AIC->AIC_EOICR = 0x0;//End of interrupt command register
}

2. cstartup.S (wobei ich den Code 1:1 von Atmel übernommen habe)

#include "project.h"

#define TOP_OF_MEMORY    (AT91C_ISRAM + AT91C_ISRAM_SIZE)
#define ABT_STACK_SIZE   8*3*4
#define IRQ_STACK_SIZE   8*3*4

#define ARM_MODE_ABT     0x17
#define ARM_MODE_FIQ     0x11
#define ARM_MODE_IRQ     0x12
#define ARM_MODE_SVC     0x13

#define I_BIT            0x80
#define F_BIT            0x40


/* Application startup entry point */
        .globl reset_handler
        .align 4

.section .vectors
.arm


/* Exception vectors (should be a branch to be detected as a valid code by the rom */
_exception_vectors:
reset_vector:
        ldr      pc, =reset_handler
undef_vector:
        b        undef_vector    /* Undefined Instruction */
swi_vector:
        b        swi_vector      /* Software Interrupt */
pabt_vector:
        ldr      pc, =pabt_handler     /* Prefetch Abort */
dabt_vector:
        ldr      pc, =dabt_handler     /* Data Abort */
rsvd_vector:
        b        rsvd_vector     /* reserved */
irq_vector:
        b        irq_handler     /* IRQ : read the AIC */
fiq_vector:
    b    fiq_handler
/*------------------------------------------------------------------------------
 *- Function             : fiq_handler
 *- Treatments           : FIQ Interrupt Handler.
 *- Called Functions     :
 *------------------------------------------------------------------------------*/
fiq_handler:
  b        fiq_handler

/*------------------------------------------------------------------------------
 *- Function             : irq_handler
 *- Treatments           : IRQ Controller Interrupt Handler.
 *- Called Functions     : AIC_IVR[interrupt]
 *------------------------------------------------------------------------------*/
irq_handler:
/* Save interrupt context on the stack to allow nesting */
        sub     lr, lr, #4
        stmfd   sp!, {lr}
        mrs     lr, SPSR
        stmfd   sp!, {r0, lr}

/* Write in the IVR to support Protect Mode */
        ldr     lr, =AT91C_BASE_AIC
        ldr     r0, [r14, #AIC_IVR]
        str     lr, [r14, #AIC_IVR]

/* Branch to interrupt handler in Supervisor mode */
        msr     CPSR_c, #ARM_MODE_SVC
        stmfd   sp!, {r1-r3, r4, r12, lr}
        mov     lr, pc
        bx      r0
        ldmia   sp!, {r1-r3, r4, r12, lr}
        msr     CPSR_c, #ARM_MODE_IRQ | I_BIT

/* Acknowledge interrupt */
        ldr     lr, =AT91C_BASE_AIC
        str     lr, [r14, #AIC_EOICR]

/* Restore interrupt context and branch back to calling code */
        ldmia   sp!, {r0, lr}
        msr     SPSR_cxsf, lr
        ldmia   sp!, {pc}^


/*------------------------------------------------------------------------------
 *- Function             : reset_handler
 *- Treatments           : Reset Interrupt Handler.
 *- Called Functions     : lowlevel_init
 *                         main
 *------------------------------------------------------------------------------*/
.section .text
reset_handler:
  ldr     pc, =_low_level_init

/*------------------------------------------------------------------------------
 *- Low level Init is performed in a C function: lowlevel_init
 *- Init Stack Pointer to a valid memory area before calling lowlevel_init
 *------------------------------------------------------------------------------*/
/*- Temporary stack in internal RAM for Low Level Init execution */
_low_level_init:
  ldr      r2, =_lp_ll_init
        ldmia    r2, {r0, r1}
        mov      sp, r1
        mov      lr, pc
        bx       r0                      /* Branch on C function (interworking) */

/*------------------------------------------------------------------------------
 *- Remap SRAM at 0x0
 *------------------------------------------------------------------------------*/
_remap:
        ldr r2, _lp_remap
        mov r0, #AT91C_MC_RCB
        str r0, [r2]

/*------------------------------------------------------------------------------
 *- Setup the stack for each mode
 *------------------------------------------------------------------------------*/
_stack_init:
  ldr      r2, =_lp_stack_init
        ldmia    r2, {r0, r1, r2}

/*- Set up Abort Mode and set ABT Mode Stack */
        msr      CPSR_c, #ARM_MODE_ABT | I_BIT | F_BIT
        mov      sp, r0
        sub      r0, r0, r1

/*- Set up Interrupt Mode and set IRQ Mode Stack */
        msr      CPSR_c, #ARM_MODE_IRQ | I_BIT | F_BIT
        mov      sp, r0
        sub      r0, r0, r2

/*- Enable interrupt & Set up Supervisor Mode and set Supervisor Mode Stack */
        msr      CPSR_c, #ARM_MODE_SVC | F_BIT
        mov      sp, r0

/*------------------------------------------------------------------------------
 *- Segments initialization
 *------------------------------------------------------------------------------*/
/* Copy the data section in RAM at 0x0000 */
_init_data:
  ldr      r2, =_lp_data
        ldmia    r2, {r1, r3, r4}
1:
        cmp      r3, r4
        ldrcc    r2, [r1], #4
        strcc    r2, [r3], #4
        bcc      1b

/* Clear the bss segment */
_init_bss:
  ldr      r2, =_lp_bss
        ldmia    r2, {r3, r4}
        mov      r2, #0
1:
        cmp      r3, r4
        strcc    r2, [r3], #4
        bcc      1b

/*------------------------------------------------------------------------------
 *- Branch to the main
 *------------------------------------------------------------------------------*/
_branch_main:
        ldr      r0, =main
        mov      lr, pc
        bx       r0

/*------------------------------------------------------------------------------
 *- Litteral pools
 *------------------------------------------------------------------------------*/
_lp_ll_init:
        .word    lowlevel_init
        .word    TOP_OF_MEMORY              /* Default SVC stack after power up */

_lp_remap:
        .word    AT91C_MC_RCR

_lp_stack_init:
        .word    TOP_OF_MEMORY             /* Top of the stack */
        .word    ABT_STACK_SIZE            /* ABT stack size */
        .word    IRQ_STACK_SIZE            /* IRQ stack size */

_lp_bss:
        .word    _sbss
        .word    _ebss

_lp_data:
        .word    _etext
        .word    _sdata
        .word    _edata

3. Mein Makefile (davon habe ich ehrlich gesagt keine Ahnung - 
allerdings hat die Compiliererei bisher geklappt :) )

 ifndef ERASE_FCT
#ERASE_FCT=del /F
ERASE_FCT=rm
endif
ifndef CROSS_COMPILE
CROSS_COMPILE=arm-elf-
endif

TOOLCHAIN=gcc

OUTFILE_SRAM=at91sam7a3_getting_started_sram
OUTFILE_FLASH=at91sam7a3_getting_started_flash_neu

# Name of output binary file
TARGET=AT91SAM7A3

INCL=./include

# Comment the line below for debug mode
#OPTIM=-Os

ifeq ($(TOOLCHAIN), gcc)

AS=$(CROSS_COMPILE)gcc
CC=$(CROSS_COMPILE)gcc
LD=$(CROSS_COMPILE)gcc
NM= $(CROSS_COMPILE)nm
SIZE=$(CROSS_COMPILE)size
OBJCOPY=$(CROSS_COMPILE)objcopy
OBJDUMP=$(CROSS_COMPILE)objdump
CCFLAGS=-g -mcpu=arm7tdmi $(OPTIM) -Wall -I$(INCL) -D$(TARGET)
ASFLAGS=-D__ASSEMBLY__ -D$(TARGET) -g -mcpu=arm7tdmi -c $(OPTIM) -Wall -I$(INCL)

# Linker flags.
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to map file
#  -lc      :   tells the linker to tie in newlib
#  -lgcc   :   tells the linker to tie in newlib
LDFLAGS+=-nostartfiles -Wl,--cref
LDFLAGS+=-lc -lgcc
LDFLAGS+=-T elf32-littlearm.lds
OBJS=cstartup.o

endif

OBJS+= lowlevel.o \
       main.o

rebuild: clean all

all: sram flash

sram: $(OBJS)
  $(LD) $(LDFLAGS) -Ttext 0x201000 -Tdata 0x200000 -n -o $(OUTFILE_SRAM).elf $(OBJS)
  $(OBJCOPY) --strip-debug --strip-unneeded $(OUTFILE_SRAM).elf -O binary $(OUTFILE_SRAM).bin

flash: $(OBJS)
  $(LD) $(LDFLAGS) -Ttext 0x100000 -Tdata 0x200000 -n -o $(OUTFILE_FLASH).elf $(OBJS)
  $(OBJCOPY) --strip-debug --strip-unneeded $(OUTFILE_FLASH).elf -O binary $(OUTFILE_FLASH).bin

main.o: main.c 
  $(CC) -c $(CCFLAGS) main.c -o main.o

lowlevel.o: lowlevel.c
  $(CC) -c $(CCFLAGS) lowlevel.c -o lowlevel.o

cstartup.o:  cstartup.S
  $(AS) $(ASFLAGS) cstartup.S -o cstartup.o

clean:
  $(ERASE_FCT) *.o *.bin *.elf

[Jim M. (turboj)]

Tobias M. schrieb:
> Bis vor ein paar Tagen blieb das Programm noch stehen, wenn ich den Pin
> wieder auf low gesetzt habe, nun läuft die Interrupt-Routine dauernd
> weiter (und ich weiß leider nicht mehr, an was ich alles rumgedreht habe
> :-/).

Das ist meistens ein Hinweis darauf, das der Interrupt Handler das 
auslösende Bit im Peripherial nicht zurück setzt (hier wohl GPIO oder 
externer Interrupt). Dadurch wird der Handler beim Verlassen sofort 
erneut aufgerufen.

[Tobias (Gast)]

@Jim Meba:
Danke für deinen Hinweis. Habe einen extern getriggerten Interrupt (wenn 
Pin auf high gesetzt wird).
Ich werde heute Abend nochmal im Datenblatt unter Peripherals 
nachblättern.
Kannst du noch etwas spezifischerres zum Zurücksetzen des auslösenden 
Bits sagen? Das könnte evtl. meine Blätterdauer gewaltig reduzieren - 
für mich als Voll-Anfänger :-/

[W.S. (Gast)]

Tobias schrieb:
> Kann mir jemand einen Tipp geben, woran es mit eröhter
> Wahrscheinlichkeit liegen könnte?
> - Makefile
> - Irgendwelche Speicherinitialisierung
> Ich muss dazu sagen, dass ich die Entwicklungsumgebung nicht komplett
> durchblicke

Also, da gibt es eine ganze Reihe von möglichen Fehlerursachen, 
insbesondere weil es sich um einen ARM7TDMI handelt:

1. der Interrupt-Stack ist falsch oder garnicht aufgesetzt. Ort: 
Startupcode. Behebung: Lernbetty runterladen, den dortigen Startupcode 
verstehend lesen oder an deinen µC angepaßt verwenden. Bedenke, daß der 
ARM7TDMI mehrere verschiedene Modi nebst getrennten Stacks UND separate 
Stackpointer kennt.

2. dein Gnu-Compiler ist faul, sowas gab's schon mal. Abhilfe: die 
Bastlerversion vom Keil runterladen und damit erstmal soweit zu Potte 
kommen, bis daß du firm genug bist. Dann kannst du immer noch zum 
Gnu-Compiler wechseln.

3. falscher Modus überhaupt. Der GCC kennt keine Pragmas, um 
Interrupthandler (die im ARM-Modus ausgeführt werden müssen) 
entsprechend zu kennzeichnen. Hat Bedeutung, wenn du den Rest im 
THUMB-Modus compilieren läßt.

4. (siehe deine Quelle) du hast vergessen, die ISR als solche kenntlich 
zu machen. Also das GCC-Äquivalent von __irq in die Kopfzeile des 
Handlers reinschreiben. (den genauen Wortlaut merke ICH nir gewiß nicht, 
also auch dazu ein Blick in die Lernbetty, dort ist das ganze nämlich 
auch vorgeturnt)

W.S.

[Bernd K. (prof7bit)]

Tobias schrieb:
> Kannst du noch etwas spezifischerres zum Zurücksetzen des auslösenden
> Bits sagen? Das könnte evtl. meine Blätterdauer gewaltig reduzieren -

Schau mal in der Registerbeschreibung des betreffenden Peripheriegerätes 
das den Interrupt auslöst (jedes Peripheriegerät sollte sein eigenes 
Kapitel haben und in jedem findest Du einen Abschnitt mit der kompletten 
Beschreibung all der Register dieses Peripheriegerätes mit jedem 
einzelnen Bit).

Dann schau mal ob Du sowas wie ein Statusregister siehst oder eventuell 
auch nur ein paar verstreute Bits in anderen Registern die "Flag" oder 
den Buchstaben "F" an verdächtiger Stelle im Namen tragen, lies die 
Beschreibung dieses Bits. Meist steht dann dort sowas wie "Das Bit wird 
gesetzt wenn dieser oder jener Zustand aufgetreten ist, ist es wird 
zurückgesetzt indem eine 1 in das Bit geschrieben wird" oder auch je 
nach Gerät "es wird zurückgesetzt wenn das Datenregister gelesen wird" 
oder ähnliches.

Die Interrupts die das Peripheriegerät auslösen kann sind fast immer an 
solche Flags gekoppelt, wenn der zugehörige Interrupt enabled ist und 
das Flag gesetzt wird löst der Interrupt aus und dann musst Du das tun 
was nötig ist im dieses Flag wieder zu löschen.

Wenn das Gerät mehrere verschiedene Interrupts auslösen kann die alle in 
der selben Interruptroutine münden dann fragst Du dort zunächst ab 
welches der in Frage kommenden Flags gesetzt ist (dann weißt Du was die 
Ursache war, z,B. Welcher Pin es war der den PinChange ausgelöst hat, 
oder bei anderen Geräten ob es ankommende Daten, ein Fehler, ein 
Überlauf, oder was auch immer war, jedes davon hat sein eigenes Flag und 
jedes will auf eine ganz bestimmte Weise zurückgesetzt werden, wie das 
genau geht steht für jedes Flag in seiner jeweiligen Beschreibung)

> Das könnte evtl. meine Blätterdauer gewaltig reduzieren

Du wirst nicht umhinkommen das in ein paar ruhigen Stunden (Tagen, 
Wochen) mal ausgiebig zu studieren, daran führt mittelfristig kein Weg 
vorbei.

[Tobias (Gast)]

@Bernd und W.S.:
1000 Dank für die Mühe, die ihr euch gemacht habt! Damit werde ich 
weiter kommen.
Lernbetty zieh ich mir auf jeden fall mal rein :)
Ich hoffe noch, dass es mit dem von Bernd beschriebenen Thema 
zusammenhängt. Die Schritte von W.S. übersteigen mindestens teilweise 
meinen Horizont.
Ich melde mich auf jeden Fall, ob ich's hinkrieg, bzw. falls nicht frag 
ich sicher nochmal nach :)
Selbstverständlich nicht vor Lernbetty und ausgiebigem Testen ;)
Viele Grüße und Danke nochmal
Tobias

[Marco H. (damarco)]

Das Problem ist das die ARMs Tail-chaining unterstützen.  Heißt tritt 
ein weiterer oder auch der selbe Interrupt auf wird der hinten dran 
gehängt.

Von einer höheren Priorität kann dieser auch unterbrochen werden.

Flags von PIOs müssen meist zurückgesetzt werden in dem man in ein 
entsprechenden Register schreibt. Macht man das nicht wird die Routine 
wieder aufgerufen :) So lange bis sie von einen höheren unterbrochen 
wird. Oder in das clear Register geschrieben wurde.

Am Ende einer Interrupt Routine muss also das clear Register beschrieben 
werden oder das Interrupt Register am Anfang ausgelesen werden womit es 
zurückgesetzt wird.

Was wo wie nötig ist steht in der Referenz.

Das dass Vector table nicht stimmt ist unwahrscheinlich da der Pointer 
von der Routine ja gefunden wird.