Eclipse-Neuling "No rule to make target"

[Martin S. (mcklappstuhl)]

Hi @all,

Ich habe hier ein STK500 und würde gerne anfangen LEDs leuchten zu 
lassen :)

Zu dem Zweck hab ich mir Eclipse und WinAVR installiert. Das AVR-Plugin 
hab ich ebenfalls entpackt und die entsprechenden Dateien und Ordner 
kopiert.
Dazu habe ich mich an das Tutorial hier im Forum gehalten (Vielen Dank 
für das Tutorial, hat mir bis hierher doch weitergeholfen).

Ich habe also Eclipse runtergeladen und entpackt.
Dann habe ich Winavr installiert.
Dann habe ich das AVR-Plugin heruntergeladen und entsprechend dem 
Tutorial kopiert.

Dann habe ich dem Tutorial entsprechend ein neues Projekt angelegt.

Nun kann ich das aber nicht kompilieren (momentan ist main.c noch leer 
aber existent).
Es kommt die Meldung "No rule to make target".

Nun hab ich hier bereits gelesen, dass der Fehler beim Makefile (bzw. 
der Verwendung/Einbundung des Makefiles) liegt.
Ich hab auch gelesen, wie man makefiles schreiben kann, was sie machen, 
usw.
Aber leider keine Lösung für mein Problem gefunden.

Das Makefile unter C/WinAVR/utils habe ich gefunden.

Ich habe also ein Projekt, und ein makefile.
Aber wie bringe ich das zusammen?

Momentan gehts mir nicht darum am makefile was zu verändern/optimieren 
(ausser es muss sein). Sondern ich will erstmal nur Code compilieren und 
auf den Controller bringen.

Ich habe die Suche bemüht, aber wie gesagt nur viele Dinge über das 
Makefile gefunden, aber nicht wie ich mein makefile verwenden kann.

Ich hoffe ihr könnt mir helfen.

Vielen Dank.

mfg
Martin

[900ss (900ss)]

Wenn du alles richtig installiert hast dann schau mal hier:
Beitrag "Re: GCC-Toolchain mit IDE installieren"

Dort habe ich alles für den ARM beschrieben. Die Vorgehensweise ist für 
den AVR identisch. Du mußt für Step
(c) dann AVR Cross Target wählen
(d) AVR GCC Toolchain (ist auch nur diese Verfügbar dann)

Der Rest ist wieder identisch. Ab Step 12 ist es wieder ARM spezifisch. 
Wirst du aber erkennen. Dann erscheinen dort die AVR-Settings für den 
Compiler u.s.w.

Wenn das so nicht funktioniert, dann wird etwas nicht richtig installert 
sein.

[Oliver (Gast)]

Eigentlich brauchst du gar nichts einzustellen. Eclipse installieren, 
WinAVR installieren, AVR-Plugin installieren, fertig. Der Rest geht 
automatisch.

>Das Makefile unter C/WinAVR/utils habe ich gefunden.

Es gibt nicht DAS makefile, jedes Projekt braucht sein eigenes. Wenn du 
ein neues avr-gcc-Projekt mit Eclipse erstellst, erzeugt Eclipse 
automatisch ein passendes makefile. Auch da brauchst du nichts von Hand 
zu machen.

Was du mal machen könntest, ist, die WinAVR-Installation zu prüfen.

Dazu musst du dann doch ein makefile erstellen, am einfachsten mit MFile 
aus dem WinAVR-Paket. MFile starten, nichts weiter eingeben, sondern nur 
mit "File/save as..." unter dem Namen "makefile" in dem Ordner 
abspeichern, in dem auch dein main.c steht. Das soll ja nur ein Test 
sein.

Dann im gleichen Ordner ein Kommandofenster öffnen (Dos-Box), make 
eingeben, und schauen, was passiert.

Oliver

[Martin S. (mcklappstuhl)]

Vielen Dank für die schnellen Antworten.

Ich habe beides gestern Abend probiert.
Leider hat keine der Varianten zum Ziel geführt.

Werde also heute erstmal alles wieder löschen (Eclipse) bzw. 
deinstallieren (WinAVR) und dann wieder neu installieren.

Reihenfolge:
Eclipse runterladen, entpacken und dahin schieben wo ich es haben will.
Dann WinAVR runterladen und installieren.
Dann Das AVR-Plugin runterladen, entpacken und die Ordner und Dateien in 
die entsprechenden Ordner im Eclipse-Ordner kopieren (features und 
plugins wenn ich mich recht erinnere?)

Passt das so? Oder fehlt da was, bzw. ist etwas falsch?

mfg
Martin

[Oliver (Gast)]

Ob du erst Eclipse, oder erst WinAVR installierst, ist egal.

Aber welche Fehlermeldung gab es denn bei "make"?

Und was meldet "which make.exe" in einem Dos-Fenster?

Oliver

[900ss (Gast)]

Martin S. schrieb:
> Dann Das AVR-Plugin runterladen, entpacken und die Ordner und Dateien in
> die entsprechenden Ordner im Eclipse-Ordner kopieren (features und
> plugins wenn ich mich recht erinnere?)

Es gibt einen eleganteren Weg. Lies dir die Doku zu dem Plugin auf 
dessen Homepage durch. Das ist dort beschrieben. Stichwort: "Install New 
Software" oder "Software Updates".

[Martin S. (mcklappstuhl)]

@Oliver,

Ich hab gerade alles neu installiert. Hat allerdings nichts geändert, 
nur dass jetzt beim neuen C-File direkt ein Kommentar am Anfang 
eingefügt wird :-) (Author usw.)

Wenn ich per mfile ein makefile erstelle und in den Workspace in den 
Ordner "tutorial" (So heißt das Projekt) speichre, dann im cmd-Window in 
den Ordner gehe und "make" ausführe, bekomme ich folgende Ausgabe:


-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is 
NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR 
PURPOSE.

Compiling C: main.c
avr-gcc -c -mmcu=atmega128 -I. -gdwarf-2 -DF_CPU=8000000UL -Os 
-funsigned-char -
funsigned-bitfields -fpack-struct -fshort-enums -Wall 
-Wstrict-prototypes -Wa,-a
dhlns=./main.lst  -std=gnu99 -MMD -MP -MF .dep/main.o.d main.c -o main.o

Linking: main.elf
avr-gcc -mmcu=atmega128 -I. -gdwarf-2 -DF_CPU=8000000UL -Os 
-funsigned-char -fun
signed-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes 
-Wa,-adhl
ns=main.o  -std=gnu99 -MMD -MP -MF .dep/main.elf.d main.o --output 
main.elf -Wl,
-Map=main.map,--cref     -lm
c:/winavr-20100110/bin/../lib/gcc/avr/4.3.3/../../../../avr/lib/avr51/cr 
tm128.o:
(.init9+0x0): undefined reference to `main'
make: *** [main.elf] Error 1


Kann mir da jemand weiterhelfen? Mir sagt das leider alles nichts :-(
Mir ist nur aufgefallen, dass ich beim Projekt selbst einen ATMEGA88 mit 
4MHz eingestellt habe. Der hier erwähnte ATMEGA128 mit 8MHz ist die 
Standard-Einstellung des mfile-makefiles.

das "which make.exe" liefert mir den Dateipfad des makefiles im 
WinAVR-Ordner:
"C:\WinAVR-20100110\utils\bin\make.exe"



@900ss
Vielen Dank für den Tipp, aber ich bin auf der Homepage des Plugins 
(http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin)trotz 
langer Suche nicht fündig geworden.
Kann es sein, dass wir unterschiedliche Homepages meinen?

mfg
Martin

[900ss (900ss)]

Martin S. schrieb:
> Kann mir da jemand weiterhelfen? Mir sagt das leider alles nichts :-(

Ich glaube, du solltest mal das AVRStudio nutzen, dass ist für den 
Anfänger deutlich besser geeignet, wenn dir das da oben alles nichts 
sagt. Hast du eigentlcih eine Funktion main() eingebaut?
Und es gibt ein schönes GCC-Tutorial hier. Hast du das in deinem 
Eingangsposting gemeint? Ansonsten hier:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

Und zu Makefiles dieses:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Exkurs_Makefiles

Hat aber alles noch nichts mit Eclipse zu tun. Es ist kein Kinderspiel, 
Eclipse einzurichten (wie du schon bemerkt hast). Du mußt sehr 
frusttolerant sein, als Anfänger erst recht.

Martin S. schrieb:
> Kann es sein, dass wir unterschiedliche Homepages meinen?

Nöö, hier steht es (nicht direct Download sondern darüber je nach 
Eclipse-Version).
http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download

[900ss (900ss)]

Martin S. schrieb:
> Kann mir da jemand weiterhelfen? Mir sagt das leider alles nichts :-(

Ich glaube, du solltest mal das AVRStudio nutzen, dass ist für den 
Anfänger deutlich besser geeignet, wenn dir das da oben alles nichts 
sagt. Hast du eigentlich eine Funktion main() eingebaut?
Und es gibt ein schönes GCC-Tutorial hier. Hast du das in deinem 
Eingangsposting gemeint? Ansonsten hier:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

Und zu Makefiles dieses:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Exkurs_Makefiles

Hat aber alles noch nichts mit Eclipse zu tun. Es ist kein Kinderspiel, 
Eclipse einzurichten (wie du schon bemerkt hast). Du mußt sehr 
frusttolerant sein, als Anfänger erst recht.

Martin S. schrieb:
> Kann es sein, dass wir unterschiedliche Homepages meinen?

Nöö, hier steht es (nicht direct Download sondern darüber je nach 
Eclipse-Version).
http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download

[Oliver (Gast)]

Martin S. schrieb:
> Kann mir da jemand weiterhelfen? Mir sagt das leider alles nichts :-(

Martin S. schrieb:
>(momentan ist main.c noch leer aber existent).



Passt doch alles. Die WinAVR-Installation ist in Ordnung.
make funktioniert, avr-gcc wird richtig aufgerufen, der linker will 
linken.
Nur braucht halt jedes C-Programm zwingend eine Funktion "main". Da die 
fehlt, gibt es die Fehlermeldung:
>c:/winavr-20100110/bin/../lib/gcc/avr/4.3.3/../../../../avr/lib/avr51/c rtm128.o:
>(.init9+0x0): undefined reference to `main'

Schreib jetzt mal das folgende in die main.c:

#include <avr/io.h>

int main(void)
{}

Dann rufst du dein make nochmals auf, das sollte dann ohne Fehlemeldung 
durchlaufen.

Als nächstes Eclipse starten, dort mit "File/New->C-Project" eine neues 
Project als "AVR Cross target application" erstellen.

Dann links im project explorer auf das Projekt rechts-klicken, mit 
"New->Source File" ein neues File erzeugen, mit Namen "main.c". In das 
schreibst du dann das Progrämmchen von oben. Default mässig ist 
autobuild aktiv, damit fängt der Compiler dann direkt an, zu arbeiten, 
und unten im Consolenfensdessen Arbeit zu verfolgen sein. Falls 
autobuild nicht aktiv ist, braucht es Rechtsklick/build.

Oliver

[900ss (900ss)]

Oliver schrieb:
> Passt doch alles. Die WinAVR-Installation ist in Ordnung.
> make funktioniert,

Leider hast du etwas übersehen.

> avr-gcc wird richtig aufgerufen,

Nöö, der falsche Prozessor wird genutzt, wenn du sein Posting richtig 
liest.

> der linker will linken.

Konsequenterweise auch mit dem falschen Prozessor. Die 
Projekteinstellungen sind falsch. Project: rechter Mausklick, 
Properties, dort den Prozessor wählen, falls es korrigiert werden soll.

Ihm fehlt außerdem main(), wie du ihm richtig mitgeteilt hast.

Anfänger sollten erstmal mit einer einfachen Umgebung anfangen.
Meine Meinung. Dazu kann man Eclipse leider nicht zählen.

[Oliver (Gast)]

>Nöö, der falsche Prozessor wird genutzt, wenn du sein Posting richtig
>liest.

Je nun, das weiß ich, das und ist auch richtig so, denn es ging darum, 
die Installation zu testen, nicht, ein auf seinem Przessor lauffähiges 
Programm zu erstellen. Das mit mfile ohne weitere Einstellungen 
erstellte makefile passt natürlich nicht zum Prozessor, auch die 
taktfrequenz wird nicht stimmen, aber es beantwortet einen Teil des 
Ausgangsproblems, welches lautet "No rule to make target". An der 
WinAVR-Installation liegt es nicht.

>Konsequenterweise auch mit dem falschen Prozessor. Die
>Projekteinstellungen sind falsch. Project: rechter Mausklick,
>Properties, dort den Prozessor wählen, falls es korrigiert werden soll.

Da gibts kein Projekt, das war ein nacktes make. Nix mit Rechtsklick.

Und auch wenn ich mich wiederhole, Eclipse für den AVR ist supereinfach 
zu installieren. Das mag früher(tm) anders gewesen sein, ebenso für 
ARM's und andere Architekturen. Beim AVR ist es simpel.

AVRStudio sit natürlich ebenso simpel, wenn es nach der Installation 
funktioniert. Wenn nicht, wird es ebenso fies.

Aber jetzt lass doch erst einmal abwarten, was der nächste Versuch mit 
Eclipse bringt.

Oliver

[900ss (900ss)]

Oliver schrieb:
> Und auch wenn ich mich wiederhole, Eclipse für den AVR ist supereinfach
> zu installieren.

Ja das zeigen auch die vielen Anfragen hier im Forum zu dem Thema.

Oliver schrieb:
> Da gibts kein Projekt, das war ein nacktes make.

Mit MFile ja, alleine mit Eclipse nein.

[Martin S. (mcklappstuhl)]

So, danke erstmal für die schnellen Antworten.

Die Tatsache, dass mich Eclipse noch einige Stunden und graue Haare 
kosten wird ist mir bewusst. Aber ich kenne mich so gut, dass ich mich 
nur mit etwas beschäftige, was beim Programm auch irgendwo auftaucht.
Wenn AVRStudio mir also die ganze Arbeit abnimmt, dann beschäftige ich 
mich auch nicht damit. Bei Eclipse MUSS ich mich ja fast damit 
beschäftigen ;-)


Ich habe gedacht die "undefined reference to 'main'" bezieht sich auf 
main.c.
Aber jetzt ist einiges klarer.

Interessanterweise ändert es aber nichts :-(
Beim Build im Eclipse bekomme ich immernoch "No rule to make target"

Wenn ich allerdings in der DosBox "make" ausführe klappt alles.
Das Makefile wird mir dann auch im Eclipse im Project-Explorer 
angezeigt.
Habs mir kurz durchgeschaut und muss sagen, es ist verdammt gut 
dokumentiert.

Ich frag mich aber was bei den Einstellungen von Eclipse nicht passen 
kann. So dass Eclipse es nicht schafft, aber "von Hand" gehts.

Mal sehen was sich so an Einstellungen findet :-)

mfg
Martin

[Oliver (Gast)]

Nur noch mal als Hinweis, wenn du in Eclipse ein Projekt über "AVR Cross 
target application" erstellst, werden die makefiles von Eclispe 
automatisch erstellt (makefile, objects.mk, subdir.mk, und sources.mk). 
Die stehen dann in den zur aktuellen Konfiguration gehörenden Ordner im 
Projekt (Debug bzw. Release).

Sind die nicht vorhanden, oder gibt es gar kein "AVR Cross target 
application" unter File/New project, dann ist das plugin nicht richtig 
installiert.

In dem Fall würde ich Eclipse komplett löschen, neu installieren, und 
das plugin über den software manager, wie auf der plugin-homepage 
beschrieben, installieren:

Help > Software Updates...

Then select the Available Software tab. Click on the 'Add Site... button o the right hand side and enter the URL of the update site:
URL:   http://avr-eclipse.sourceforge.net/updatesite/ 
Then click on OK. The AVR Eclipse update site is now shown in the list of update sites. Select the "AVR Eclipse Plugin" and press the Install... button in the top right corner.

Oliver

[Martin S. (mcklappstuhl)]

So, ich hab das Plugin jetzt über den Software-Manager installiert.
Der im Verzeichnis "Tutorial" (so heißt mein Projekt) gibts einen Ordner 
"Debug" und da sind folgende Dateien drin:

- makefile
- objects.mk
- sources.mk
- subdir.mk

Das würde also soweit passen.

Die main() - Funktion ist drin.

Trotzdem bekomme ich die "No Rule To Make Target" - Meldung.
Wie bereits gesagt, über die Dosbox gehts einwandfrei.

Leider habe ich in Eclipse keine Einstellung gefunden, die daran schuld 
sein könnte.

Das ganze tritt übrigens bei beiden Konfigurationen auf. Also bei Debug 
und bei Release.

Wo könnte noch ein Fehler schlummern?

mfg
Martin


EDIT hat noch was wichtiges zu sagen:
Wenn ich statt "Project - Make Target - Build" einfach den Button "Build 
All" nehme. Dann klappts wunderbar.
Ich bekomme nur die Meldung, "control reaches End of non void function" 
weil die Endlosschleife fehlt.
Hat jemand eine Idee warum es mit "Build All" geht, aber mit "Project - 
Make Target - Build" nicht?

[900ss (900ss)]

Ach jetzt verstehe ich dein Problem :-)

Schaue dir mal den Aufruf von Make in der Eclipse Console an. Einmal 
wenn es funktioniert und dann wenn es nicht funktioniert. Da sollte dir 
etwas auffallen.
Und wenn du dir dann das Manual von Make unters Kopfkissen legst, dann 
wirst du selber drauf kommen.

[Martin S. (mcklappstuhl)]

Du meinst man sollte "make" vielleicht ein Target geben, das auch 
wirklich im makefile vorkommt? :-D
Ja gut ich habs geschnallt.

Vielen Dank für die Hilfe.

Ich geh jetzt mal das Manual ausdrucken. Mit dem Laptop unterm 
Kopfkissen schläft sichs schlecht.

mfg
Martin

[ameise123 (Gast)]

bei mir ein ähnliches problem. es lief alles wunderbar bis ich jetzt 
nach dem formatieren alles neu aufspielen musste.
ich erhalte diese meldung:

**** Build of configuration Release for project octo ****

make all 

-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

make: *** No rule to make target `main.elf', needed by `elf'.  Stop.

ich benutzte ein eingenes makefile welches im ordner mit main.c 
zusammenliegt. deshalb habe ich "generate makefile automatically" 
deaktiviert und als build location meinen ordner der beide dateien 
enthält angegeben!
als configuration ist release aktiv!
ich bin wirklich am verzweifeln!
danke

XP+winavr

[900ss (900ss)]

Wenn du ein eigenes Makefile verwendest, dann brauchst du das AVR-Plugin 
nicht. Es erleichtert dir fast nichst, nur die Nutzung von AVRDude.

Wenn du also das Projekt unter Einbeziehung des Plugins erstellt hast 
und dann alles mit "der Hand" zurück gestellt hast auf "manuelles Build" 
dann weiß ich nicht, ob das alles sauber abläuft.

Wenn Du mit deinem eigenen Makefile arbeiten willst, dann erstelle in 
Eclipse ein Makefile-Projekt. Wie das geht steht in der Hilfe von 
Eclipse. Dort unterstützt dich dann Eclipse auch sicher richtig beim 
Build-Process.

Du kannst dein eigenes Makefile testen ohne Eclipse, indem du ein 
Kommandozeilenfenster öffnest und dich in die Direktory begibst, in der 
dein Makefile steht. Hier kannst du dann "make all" oder auch nur "make" 
eingeben.

Zur Fehlersuche wäre es gut, wenn du dein Makefile mal mit als Anhang 
postest.

Wenn Du nicht unbedingt auf dein eigenes Makefile angewiesen bist, dann 
erstelle ein neues Projekt mit dem AVR-Plugin. Wie das geht ist unter 
Eclipse->Help->Help Contents->AVR Plugin sehr genau beschrieben.

[ameise123 (Gast)]

>Du kannst dein eigenes Makefile testen ohne Eclipse, indem du ein
>Kommandozeilenfenster öffnest und dich in die Direktory begibst, in der
>dein Makefile steht. Hier kannst du dann "make all" oder auch nur "make"
>eingeben.

da erhalte ich ebenfalls die antwort:

C:\Dokumente und Einstellungen\Administrator\Eigene Dateien\My Dropbox\µC\AVR\projects\octopususb-0.3\firmware>make all

-------- begin --------
avr-gcc (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

make: *** No rule to make target `main.elf', needed by `elf'.  Stop.

es muss n trivialen trick geben, denn so ging es bis vor kurzem auch 
ohne probleme, also mit exakt den selben settings etc..!

hier emin makefile:

# Hey Emacs, this is a -*- makefile -*-
#
# WinAVR makefile written by Eric B. Weddington, Jörg Wunsch, et al.
# Released to the Public Domain
# Please read the make user manual!
#
# Additional material for this makefile was submitted by:
#  Tim Henigan
#  Peter Fleury
#  Reiner Patommel
#  Sander Pool
#  Frederik Rouleau
#  Markus Pfaff
#
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF (for use with AVR Studio 3.x or VMLAB).
#
# make extcoff = Convert ELF to AVR Extended COFF (for use with AVR Studio
#                4.07 or greater).
#
# make program = Download the hex file to the device, using avrdude.  Please
#                customize the avrdude settings below first!
#
# make filename.s = Just compile filename.c into the assembler code only
#
# To rebuild project do "make clean" then "make all".
#

# mth 2004/09 
# Differences from WinAVR 20040720 sample:
# - DEPFLAGS according to Eric Weddingtion's fix (avrfreaks/gcc-forum)
# - F_OSC Define in CFLAGS and AFLAGS


# MCU name
#MCU = atmega128
MCU = at90can128

# Main Oscillator Frequency
# This is only used to define F_OSC in all assembler and c-sources.
F_OSC = 16000000

# Output format. (can be srec, ihex, binary)
FORMAT = ihex

# Target file name (without extension).
TARGET = main


# List C source files here. (C dependencies are automatically generated.)
#SRC = $(TARGET).c uart.c usbn2mc/main/usbn960x.c usbn2mc.c usbn2mc/main/usbnapi.c 

SRC = $(TARGET).c wait.c uart.c ../usbn2mc/main/usbn960x.c usbn2mc.c ../usbn2mc/main/usbnapi.c common.c fifo.c io.c adc.c i2c.c spi.c 93c46.c pwm.c debug.c can.c eeprom.c pin.c


# List Assembler source files here.
# Make them always end in a capital .S.  Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC = 



# Optimization level, can be [0, 1, 2, 3, s]. 
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s

# Debugging format.
# Native formats for AVR-GCC's -g are stabs [default], or dwarf-2.
# AVR (extended) COFF requires stabs, plus an avr-objcopy run.
DEBUG = stabs
#DEBUG = dwarf-2

# List any extra directories to look for include files here.
#     Each directory must be seperated by a space.
EXTRAINCDIRS = 


# Compiler flag to set the C Standard level.
# c89   - "ANSI" C
# gnu89 - c89 plus GCC extensions
# c99   - ISO C99 standard (not yet fully implemented)
# gnu99 - c99 plus GCC extensions
CSTANDARD = -std=gnu99

# Place -D or -U options here
CDEFS =

# Place -I options here
CINCS = 


# Compiler flags.
#  -g*:          generate debugging information
#  -O*:          optimization level
#  -f...:        tuning, see GCC manual and avr-libc documentation
#  -Wall...:     warning level
#  -Wa,...:      tell GCC to pass this to the assembler.
#    -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS) $(CINCS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -Wall -Wstrict-prototypes
#CFLAGS += -Wall
CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
CFLAGS += -DF_OSC=$(F_OSC)



# Assembler flags.
#  -Wa,...:   tell GCC to pass this to the assembler.
#  -ahlms:    create listing
#  -gstabs:   have the assembler create line number information; note that
#             for use in COFF files, additional information about filenames
#             and function names needs to be present in the assembler source
#             files -- see avr-libc docs [FIXME: not yet described there]
ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs 
ASFLAGS += -DF_OSC=$(F_OSC)


#Additional libraries.

# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

PRINTF_LIB = 

# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

SCANF_LIB = 

MATH_LIB = -lm

# External memory options

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff

EXTMEMOPTS =

# Linker flags.
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to  map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)




# Programming support using avrdude. Settings and variables.

# Programming hardware: alf avr910 avrisp bascom bsd 
# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
#
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = stk500

# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = com1    # programmer connected to serial device

AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep


# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y

# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V

# Increase verbosity level.  Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v

AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)



# ---------------------------------------------------------------------------

# Define directories, if needed.
DIRAVR = c:/winavr
DIRAVRBIN = $(DIRAVR)/bin
DIRAVRUTILS = $(DIRAVR)/utils/bin
DIRINC = .
DIRLIB = $(DIRAVR)/avr/lib


# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
NM = avr-nm
AVRDUDE = avrdude
REMOVE = rm -f
COPY = cp




# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = --------  end  --------
MSG_SIZE_BEFORE = Size before: 
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:




# Define all object files.
OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) 

# Define all listing files.
LST = $(ASRC:.S=.lst) $(SRC:.c=.lst)


# Compiler flags to generate dependency files.
### GENDEPFLAGS = -Wp,-M,-MP,-MT,$(*F).o,-MF,.dep/$(@F).d
GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d

# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)





# Default target.
all: begin gccversion sizebefore build sizeafter finished end

build: elf hex eep lss sym

elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss 
sym: $(TARGET).sym



# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
  @echo
  @echo $(MSG_BEGIN)

finished:
  @echo $(MSG_ERRORS_NONE)

end:
  @echo $(MSG_END)
  @echo


# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
ELFSIZE = $(SIZE) -A $(TARGET).elf
sizebefore:
  @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi

sizeafter:
  @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi



# Display compiler version information.
gccversion : 
  @$(CC) --version



# Program the device.  
program: $(TARGET).hex $(TARGET).eep
  $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)




# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT=$(OBJCOPY) --debugging \
--change-section-address .data-0x800000 \
--change-section-address .bss-0x800000 \
--change-section-address .noinit-0x800000 \
--change-section-address .eeprom-0x810000 


coff: $(TARGET).elf
  @echo
  @echo $(MSG_COFF) $(TARGET).cof
  $(COFFCONVERT) -O coff-avr $< $(TARGET).cof


extcoff: $(TARGET).elf
  @echo
  @echo $(MSG_EXTENDED_COFF) $(TARGET).cof
  $(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof



# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
  @echo
  @echo $(MSG_FLASH) $@
  $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@

%.eep: %.elf
  @echo
  @echo $(MSG_EEPROM) $@
  -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
  --change-section-lma .eeprom=0 -O $(FORMAT) $< $@

# Create extended listing file from ELF output file.
%.lss: %.elf
  @echo
  @echo $(MSG_EXTENDED_LISTING) $@
  $(OBJDUMP) -h -S $< > $@

# Create a symbol table from ELF output file.
%.sym: %.elf
  @echo
  @echo $(MSG_SYMBOL_TABLE) $@
  $(NM) -n $< > $@



# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
  @echo
  @echo $(MSG_LINKING) $@
  $(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS)


# Compile: create object files from C source files.
%.o : %.c
  @echo
  @echo $(MSG_COMPILING) $<
  $(CC) -c $(ALL_CFLAGS) $< -o $@ 


# Compile: create assembler files from C source files.
%.s : %.c
  $(CC) -S $(ALL_CFLAGS) $< -o $@


# Assemble: create object files from assembler source files.
%.o : %.S
  @echo
  @echo $(MSG_ASSEMBLING) $<
  $(CC) -c $(ALL_ASFLAGS) $< -o $@



# Target: clean project.
clean: begin clean_list finished end

clean_list :
  @echo
  @echo $(MSG_CLEANING)
  $(REMOVE) $(TARGET).hex
  $(REMOVE) $(TARGET).eep
  $(REMOVE) $(TARGET).obj
  $(REMOVE) $(TARGET).cof
  $(REMOVE) $(TARGET).elf
  $(REMOVE) $(TARGET).map
  $(REMOVE) $(TARGET).obj
  $(REMOVE) $(TARGET).a90
  $(REMOVE) $(TARGET).sym
  $(REMOVE) $(TARGET).lnk
  $(REMOVE) $(TARGET).lss
  $(REMOVE) $(OBJ)
  $(REMOVE) $(LST)
  $(REMOVE) $(SRC:.c=.s)
  $(REMOVE) $(SRC:.c=.d)
  $(REMOVE) .dep/*



# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)


# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff \
clean clean_list program

download_old:
  avrdude -p m128 -c avrispv2 -P usb -U flash:w:main.hex

download:
  avrdude -p c128 -c avrispv2 -P usb -U flash:w:main.hex -B 1

fuse_old:
  avrdude -p m128 -c avrispv2 -P usb -U lfuse:w:0xe0:m
  avrdude -p m128 -c avrispv2 -P usb -U efuse:w:0xff:m
  avrdude -p m128 -c avrispv2 -P usb -U hfuse:w:0xdd:m
  
fuse:
  avrdude -p c128 -c avrispv2 -B 10 -P usb -U lfuse:w:0xe0:m
  avrdude -p c128 -c avrispv2 -B 10 -P usb -U efuse:w:0xff:m
  avrdude -p c128 -c avrispv2 -B 10 -P usb -U hfuse:w:0xdd:m

usbprog:  
  avrdude -p c128 -c avrispv2 -P usb -U flash:w:main.hex

[ameise123 (Gast)]

achja: wenn ich debug anstelle von release als standard setze, rödelt er 
sogar, sprich er kompiliert! wieso denn bloß?

[900ss (900ss)]

900ss D. schrieb:
> Zur Fehlersuche wäre es gut, wenn du dein Makefile mal mit als Anhang
> postest.

Da stand "als Anhang", ganz bewußt. Warum packst du solch ein langes 
File hier in den Text? Es macht den Thread nicht gerade leserlich und so 
kann man das nicht ausprobieren, da die Formatierung des Makefiles 
kaputt geht.

Benutzt du nach wie vor das AVR-Plugin aber mit einem Makefile?
Ein mit dem Plugin erstelltest Projekt arbeitet mit einem eigenen 
Makefile.
Die Konfiguration, die du nutzt ist Blödsinn. Wenn du ein "normales" 
Make-Projekt erstellst (also kein AVR-Projekt), dann wäre das die 
richtige Vorgehensweise bei Verwendung eines eigenen Makefiles.

Wenn du die Konfiguration von Debug auf Release setzt, dann nutzt du 
eine andere Konfiguration und zwar die, die du für Release eingestellt 
hast.
Findest du unter Project->Properties. Sieh dir die Unterschiede für 
Debug und Release an.
Du hast oben geschrieben, dass du unter Konfiguration Release die 
Einstellungen für den Build-Prozess (Make) geändert hast. Wenn du dann 
auf Konfiguration Debug umstellst, sind dort natürlich andere 
Einstellungen für den Build-Prozess.

Das du die Fehlermeldung auch erhälst, wenn du das in dem 
Konsolenfenster probierst, ist seltsam. Dort dürfte es dann die Datei 
main.c nicht geben.

Poste mal den Output, wenn du mit Release kompilierst. Und zwar mit dem 
Aufruf von make posten.

Und vielleicht liegt das auch an deine Tastatur. Manche Dinge sind 
case-sensitiv und bei dir scheint die Shift-Taste defekt zu sein ;-)

[ameise123 (Gast)]

das macht doch keinen sinn. ich möchte mein makefile benutzen nicht mehr 
und nicht weniger, da kann ich doch- wie  im anhang geschehen- einfach 
den pfad angeben. aber dieses scheiss eclipse macht was es will. also 
langsam nervts wirklich!
benutze ich das standard makefile, also build automatically, gibts nur 
fehlermeldungen und die werden mir nicht mal wie üblich in rot 
angezeigt.

[900ss (900ss)]

ameise123 schrieb:
> das macht doch keinen sinn
Was macht keinen Sinn? Woher weißt du das?

> aber dieses scheiss eclipse macht was es will
Nein, das machst du.
Du mußt dich schon an die Regeln zur Nutzung von Eclipse halten. Das 
tust du nicht. Deshalb funktioniert es auch nicht.
Ich schrieb schon zweimal , du mußt für dein Projekt ein 
Makefile-Projekt erstellen ohne Einbeziehung des AVR-Plugins.
Das geht so:

1) File->New->Project....
2) Unter C/C++ "C Project" wählen
3) Projektname eintragen und unten Makefile Project -> Empty Project
   wählen
4) Next
5) Finish

Jetzt hast du ein leeres Projekt.

6) Rechten Mausklick auf das Projekt machen und Import wählen. Jetzt
   alle Files des Projektes inkl. Makefile importieren.

7) Oben im Menu: Project -> Build Project wählen

Dein Projekt wird gebaut. Vielleicht ;-)

Es wird dir aber wahrscheinlich nichts nutzen, da das Make in dem 
Konsolenfenster auch schief geht. Ich fragte, ob du eine Datei Namens 
main.c hast. Die fehlt dem Make laut der Fehlermeldung oben.

Lesen
Solange das Make in dem Konsolenfenster schief geht, wird es auch in 
Eclipse schiefgehen.

Übrigens, kleiner Tip: 
http://www.mikrocontroller.net/articles/Netiquette

Und solange du nicht meine Fragen beantwortest oder die Dinge nicht 
postest, die gebraucht werden um dir zu helfen, wird dir hier niemand 
helfen können. Ich leider auch nicht.

PS. Deine Shifttaste ist immer noch defekt.

[ameise123 (Gast)]

Entschuldige, bin etwas genervt!
Genauso habe ich es getan und wieder erscheint "no rule to make target".

Es scheint aber ein Problem zu geben, wenn ich make all schon im 
DOS-Fenster aufrufe.
Also liegt es an etwas anderem...
Anbei nochmal das makefile

Sehr merkwürdig, zumal es ja schon einmal geklappt hat!

[900ss (900ss)]

Wenn Du kannst, dann poste mal das gesamte Projekt als Zip-File.
Dann kann ich es hier probieren.

Wenn nicht, dann mach ein Screenshot aller Dateien aus dem Directory wo 
das Makefile liegt und schicke das als Anhang.

Die Fehlermeldung oben
"make: *** No rule to make target `main.elf', needed by `elf'.  Stop."
meint eigentlich, dass es keine Datei main.c gibt.

Ich habe deinen Makefile eben kurz mit nur einem Sourcefile getestet. 
Der Makefile scheint in Ordung zu sein. Der Beweis ist im Anhang ;-)

[900ss (900ss)]

Beweis im Anhang ;-) Mit Deinem Makefile generiert.

[ameise (Gast)]

Mach ich doch glatt.

[900ss (900ss)]

Wenn du in deinem Makefile nur die Sourcen angibst, die auch existieren, 
dann funktioniert es.

Z.B. so:

SRC = $(TARGET).c wait.c uart.c ../usbn2mc/main/usbn960x.c usbn2mc.c ../usbn2mc/main/usbnapi.c common.c fifo.c io.c adc.c i2c.c spi.c 93c46.c pwm.c

Wenn dort nur ein File steht, der nicht existiert, dann bekommst du die 
bekannte Fehlermeldung. Mit der SRC-Zeile oben hat es bei mir geklappt. 
Auch der Linker hat nicht genörgelt. Es hagelt beim kompilieren 
allerdings ein paar Warnungen, die ich aber nicht näher betrachtet habe 
jetzt.

[ameise (Gast)]

Gut ich habe 2 Dinge getan; zum einen bin ich auf eine älter winavr 
Version zurück, von der ich weiss, dass sie schon einmal funktioniert 
hat und zum Zweiten, habe ich alle nicht existierenden source files aus 
dem makefile gestrichen.

Danke soweit, kompiliert hat er nun!

[ameise (Gast)]

Und auch wenn du mir davon abgeraten hast, es klappt tatsächlich, ein 
mittels des avr plugins erstelltes programm, mit einem individuellen 
makefile zu versehen, auch wenn es, wie du bereits gesagt hast, 
schwachsinn ist. Wieder was gelernt, danke nochmals.

[900ss (900ss)]

ameise schrieb:
> ich auf eine älter winavr Version zurück

Sollte aber genauso gut mit der aktuellen funktionieren.

Man sollte normalerweise nicht zwei Dinge gleichzeitig ändern, da man 
dann nicht weiß, was jetzt wirklich der Fehler war.

ameise schrieb:
> es klappt tatsächlich, ein
> mittels des avr plugins erstelltes programm, mit einem individuellen
> makefile zu versehen

Hab nicht gesagt, dass das nicht klappt. Nur wo siehst du jetzt die 
Vorteile bei der Nutzung des Plugins?

ameise schrieb:
> Wieder was gelernt, danke nochmals.

Bitte schön :-)

[ameise (Gast)]

ja natürlich hast du recht, aber das plugin tut ja nochmehr, als nur das 
bereitstellen der toolchain, wie zB das flashen.

[900ss (900ss)]

ameise schrieb:
> das flashen

Wäre das einzige, was übrig bleibt.