ISR in Assembler mit GCC

[Martin (Gast)]

Gude!

Ich hab mich schon daran gehalten:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Assembler-Dateien_2
Trotzdem krieg ich es nicht hin eine ISR in Assembler zu schreiben.

Eine externe Datei im Verzeichnis der anderen Quellcodedateien hab ich 
angelegt: isr.S der Code sieht so aus:

#include <io.h>

.global TIMER1_CAPT_vect
TIMER1_CAPT_vect:

push ...
push ...
[...]
pop ...
pop ...
reti
.end

Dann im Makefile die Zeile ASRC = isr.S eingefügt.

Jedoch findet der Compuler die isr.S nicht, compiliert auch nix.

Weiß jemand was ich da falsch mache?

[Neo (Gast)]

Hast du den Timer 1 für interrupt enabled? Das geht im TIMSK - Register. 
Ich habe das erst vergesen, du vielleicht auch?

[Martin (Gast)]

Ne der Fehler liegt nicht im Programm, sondern schon beim Compilieren, 
die isr.S findet er einfach nicht.

[Jörg W. (dl8dtl) (Moderator)]

Dann solltest du dir dein Makefile mal angucken.

[Martin (Gast)]

Also im Makefile hab ich wie schon erwähnt ASRC = isr.S eingefügt. Weiß 
jetzt nicht ob ich da noch was vergessen hab, im Tutorial stand 
jedenfalls nix oder ich bin blind...

[Karl heinz B. (kbucheg)]

Das weis keiner.
Solange du das Makefile nicht herzeigst, wirds auf dieser
Seite des Bildschirms auch keiner rausfinden können.

[Jörg W. (dl8dtl) (Moderator)]

Martin wrote:

> Also im Makefile hab ich wie schon erwähnt ASRC = isr.S eingefügt.

Das besagt gar nichts.  Wenn das Makefile im Weiteren ${ASRC} nie
referenziert, ist das Schall und Rauch.

[Wolfram (Gast)]

nur so als Tip:
Groß- /Kleinschreibung ist Trumpf!
bei >isr.S seh ich da einiges an Potential für Fehler...

[Martin (Gast)]

Also hier das Makefile:
Kenn mich mit Makefiles nicht aus, genügt es nicht die oben erwähnte 
Zeile einzufügen?


######################################################################## 
#######
# Makefile for the project F42
######################################################################## 
#######

## General Flags
PROJECT = F42
MCU = atmega8
TARGET = F42.elf
CC = avr-gcc.exe

## Options common to compile, link and assembly rules
COMMON = -mmcu=$(MCU)

## Compile options common for all C compilation units.
CFLAGS = $(COMMON)
CFLAGS += -Wall -gdwarf-2                -DF_CPU=16000000UL -Os 
-fsigned-char
CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d

## Assembly specific flags
ASMFLAGS = $(COMMON)
ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2

## Linker flags
LDFLAGS = $(COMMON)
LDFLAGS +=


## Intel Hex file production flags
HEX_FLASH_FLAGS = -R .eeprom

HEX_EEPROM_FLAGS = -j .eeprom
HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"
HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0

ASRC = isr.S

## Objects that must be built in order to link
OBJECTS = F42.o UartPrintF.o

## Objects explicitly added by the user
LINKONLYOBJECTS =

## Build
all: $(TARGET) F42.hex F42.eep F42.lss size

## Compile
F42.o: ../F42.c
  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

UartPrintF.o: ../UartPrintF.c
  $(CC) $(INCLUDES) $(CFLAGS) -c  $<

##Link
$(TARGET): $(OBJECTS)
   $(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o 
$(TARGET)

%.hex: $(TARGET)
  avr-objcopy -O ihex $(HEX_FLASH_FLAGS)  $< $@

%.eep: $(TARGET)
  avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@

%.lss: $(TARGET)
  avr-objdump -h -S $< > $@

size: ${TARGET}
  @echo
  @avr-size -C --mcu=${MCU} ${TARGET}

## Clean target
.PHONY: clean
clean:
  -rm -rf $(OBJECTS) F42.elf dep/* F42.hex F42.eep F42.lss

## Other dependencies
-include $(shell mkdir dep 2>/dev/null) $(wildcard dep/*)

[irgendein Rahul (Gast)]

>Das besagt gar nichts.  Wenn das Makefile im Weiteren ${ASRC} nie
>referenziert, ist das Schall und Rauch.

Jörg hat gewonnen!

[Karl heinz B. (kbucheg)]

> Kenn mich mit Makefiles nicht aus

Dann wirds Zeit.

> genügt es nicht die oben erwähnte Zeile einzufügen?

<Ausschnitt>

ASRC = isr.S

## Objects that must be built in order to link
OBJECTS = F42.o UartPrintF.o

</Ausschnitt>

Was denkst du was der Kommentar
## Objects that must be built in order to link

zu sagen hat?

Da wird also zumindest noch ein isr.o mit
aufgenommen werden müssen.
Dann brauchst du natürlich noch eine Regel im
Makefile, die besagt wie das isr.o aus dem
isr.S ensteht.

Schau doch einfach mal den Rest des Makefiles
durch und versuch zu verstehen wie das funktioniert.
Das ist wirklich Watscheneinfach.

[Karl heinz B. (kbucheg)]

Wobei eigentlich noch die Frage bleibt
warum du den ISR in Assembler schreiben willst.

Es gibt eigentlich nur 2 Gründe dafür
* Du hast dir den Compiler generierten angeschaut
  und festgestellt, dass du den einen oder anderen
  Zyklus einsparen kannst. Da du auf jeden einzelnen
  Zyklus angewiesen bist, bleibt dir nichts anderes
  übrig als den Compiler zu überstimmen und den ISR
  selbst zu schreiben.

* Dein Programmaufbau ist alles andere als optimal
  und du kommst hinten und vorne mit dem Timing nicht
  hin. Anstatt aber den Programmaufbau zu verbessern
  und eventuell das Verfahren (den Algorithmus) zu wechseln,
  denkst du das ein Wechseln auf Assembler das Problem
  lösen könnte.
  Was es meistens nicht tut.

Meistens liegt Fall 2 vor. Deshalb habe ich nachgefragt.

[Martin (Gast)]

Ja bei mir ist es Fall 2 wie Du schon sagst.
Der Wechsel auf Assembler hat auch nix gebracht, bzw. waren die 
Einsparungen nicht der Rede Wert. Ich glaub ich muss dann mal das 
Programm an sich optimiern, Verfahren usw.
Danke für die Hilfe. Das Makefile werd ich noch bearbeiten.

[irgendein Rahul (Gast)]

>Ich glaub ich muss dann mal das Programm an sich optimiern

Manchmal hilft es, wenn jemand anders auf das Programm guckt...