ich habe bisher mit Eclipse und dem avr plugin meine Programme geschrieben. War damit jahrelang auch super zufrieden. Das Plugin hat zwar schon seit längerem mit avrdude nicht mehr funktioniert, aber das habe ich bisher über eine Batchdatei gemacht.
Letzte Woche hat mein PC den Geist aufgegeben und ich musste jetzt mit einem neuen PC auf Windows 11 umsteigen. Da funktioniert das avr plugin überhaupt nicht mehr vernünftig. Ich kann z.B. einen einmal eingestellten Controller nicht mehr ändern. Mir wurde geraten auf VSCode umzusteigen, weil das besser sei.
Ich habe mir zuerst die platformio angesehen, das gefällt mir aber gar nicht, weil die zu sehr auf arduino ausgerichtet ist. Ich will aber noch die reinen avr einzeln programmieren ohne Board.
Nach langem Kampf habe ich das hinbekommen mit vscode und den "avr utils" eine einzelne Datei zu compilieren. Ich finde da aber nirgends eine vernünftige Doku, wie ich die einzelnen Compiler- und Linkeroptionen einstelle. Mir ist klar, dass das in dieser .json-Datei gemacht wird. Aber wo finde ich, wie die einzelnen Variablen überhaupt heißen?
Ebenfalls soll man damit Projekte von Microchip Studio importieren können. Das Importieren hat funktioniert. Das Compilieren aber nicht. In Eclipse wurde mir über ein Fenster angezeigt, mit welchen Parametern Linker und Compiler aufgerufen werden. Auch das sehe ich nicht bei VScode und den avr utils.
Hier im Forum habe ich über avr helper gelesen. Aber auch dazu finde ich im Internet keine vernünftige Doku.
Kann mir jemand sagen, was die geeignete Methode ist um mit VSCode die AVRs zu programmieren und wo ich die Bezeichnungen der Variablen in der json-Datei finde?
Kann mir jemand sagen, was die geeignete Methode ist um mit VSCode die
AVRs zu programmieren und wo ich die Bezeichnungen der Variablen in der
json-Datei finde?
Was spricht dagegen das Original-Entwicklungstool von Atmel
bzw. jetzt Microchip zu verwenden? Funktioniert von Windows 7
bis Windows 11.
Kann mir jemand sagen, was die geeignete Methode ist um mit VSCode die
AVRs zu programmieren und wo ich die Bezeichnungen der Variablen in der
json-Datei finde?
Hier scheint das recht gut erklärt zu sein. Ich hab es aber nur überflogen bisher. Nutze auch eher Eclipse aber mit Makefiles. Früher(tm) auch das Plugin.
Was spricht dagegen das Original-Entwicklungstool von Atmel
bzw. jetzt Microchip zu verwenden? Funktioniert von Windows 7
bis Windows 11.
Bequemlichkeit. Ich habe mit Eclipse in Python und C++ programmiert. Das war immer angenehm, dass ich für alles eine IDE hatte. Da kannte ich die Bedienung. Die war immer gleich.
Hier scheint das recht gut erklärt zu sein. Ich hab es aber nur
überflogen bisher. Nutze auch eher Eclipse aber mit Makefiles.
Früher(tm) auch das Plugin.
Danke. Das hatte ich auch schon gefunden. Ich suche aber eigentlich ohne Makefile und die Erklärung der Variablen in den json-Dateiein.
Wie rufst Du aus Eclipse über das Makefile avrdude auf? Wenn das geht, würde ich doch wiederEclipse nehmen. Bisher habe ich das über eine Batch-Datei von der Console gemacht. Bequemer wäre es direkt aus Eclipse.
Ich suche aber eigentlich ohne
Makefile und die Erklärung der Variablen in den json-Dateiein.
Make ist auch nicht so mein Ding und json erst recht nicht.
Ich compiliere und flashe mit einer Batch.
Die Compiler- und Linkerschalter lasse ich die Batch in eine Textdatei schreiben, die ich dann avr-gcc.exe übergebe. Als Source übergibt man einfach *.c oder *.cpp, was dann zu allen Sourcefiles im aktuellen Verzeichnis expandiert.
Über errorlevel kann man abtesten, ob erfolgreich compiliert wurde, d.h. bei einem Fehler wird nicht geflasht.
Geflasht wird dann mit atprogram.exe.
Kann mir jemand sagen, was die geeignete Methode ist um mit VSCode die
AVRs zu programmieren und wo ich die Bezeichnungen der Variablen in der
json-Datei finde?
Danke, werde ich ausprobieren. Ich hatte mich schon damit abgefunden wieder mit Eclipse weiter zu machen. Sofern ich von dort aus vernünftig flashen kann ohne auf die Eingabeaufforderung zu gehen.
Aber wie rufst Du aus Eclipse das Makefile für avrdude auf?
Ich schreibe mir ein einziges Makefile wie in dem Artikel mit dem Beispiel. Das nutze ich zum Übersetzen, Linken und Flashen mittels AVRdude. Dafür gibt es unterschiedliche Build-Targets.
In Eclipse erzeuge ich ein C/C++ Makefile Project. Man kann dafür verschiedene Projekt-Targets anlegen mit unterschiedlichen Parametern, die dann an das Makefile als Build-Target übergeben werden.
Also ein Project-Target "Build", eines "Clean" und eines "Programm".
Also Eclipse erzeuge dann z.B. das Kommando "make Programm" mit dem Projekt-Target "Programm".
Letzte Woche hat mein PC den Geist aufgegeben und ich musste jetzt mit
einem neuen PC auf Windows 11 umsteigen.
Wäre das nicht ein guter Zeitpunkt, auch einen Linuxrechner aufzubauen? Klar gibt es da auch andere Probleme, aber gerade Java (oder JS) und Python sind da schon sehr gut aufgehoben.
Wenn es gut läuft, hättest du eine Alternative.
Wäre das nicht ein guter Zeitpunkt, auch einen Linuxrechner aufzubauen?
Klar gibt es da auch andere Probleme, aber gerade Java (oder JS) und
Python sind da schon sehr gut aufgehoben.
Wenn es gut läuft, hättest du eine Alternative.
Das hatte ich bei meinem vorherigen Rechner schon mal überlegt. Aber ich habe z.b. noch Word-Dateien, wo spezielle Funktionen drin sind, wie z.B. dass Anlagen automatisch durchnummeriert werden. Das hatte ich mir damals mit Openoffice angesehen. Openoffice konnte zu dem Zeitpunkt zwar Word-Dateien einlesen, aber die automatische Nummerierung hat dort nicht funktioniert. Daher bin ich bei Microsoft geblieben. Parallel wollte ich Ubuntu laufen lassen, aber beim Installieren habe ich es nicht hinbekommen, dass das Parallel lief. Ubuntu wollte mir meine Windows-Partition immer überschreiben. Hier lag aber der Fehler wohl bei mir. Weil ich es unter Windows XP Jahre vorher hinbekommen hatte.
In Eclipse erzeuge ich ein C/C++ Makefile Project. Man kann dafür
verschiedene Projekt-Targets anlegen mit unterschiedlichen Parametern,
die dann an das Makefile als Build-Target übergeben werden.
Das muss ich mir in Ruhe nochmal ansehen. Auf die Schnelle habe ich es nicht hinbekommen. Werde ich am Wochenende testen.
der Doppelpunkt ist in einer
Batchdatei für ein Label da
Genau das ist ja der Trick. Der Doppelpunkt macht aus einem Befehl ein Label. Und voilà, der Befehl wird nicht mehr ausgeführt.
Es macht auch nichts, wenn gleiche Label mehrfach dastehen. Sie werden ja niemals angesprungen.
Ubuntu wollte mir meine
Windows-Partition immer überschreiben.
Das ist nicht parallel, das ist ein typisches Dualboot, vor allem von Gamern genutzt. Mittlerweile ist aber auch die Spieleunterstüzung bei Linux ganz gut - ich hatte nicht schlecht gestaunt, als vor einiger Zeit ein paar potente (also bewährt gute) Emulatoren im Softwarekatalog auftauchten.
Allerdings ist das typische Dualboot-Problem, dass Windows das Bootmanagement von Linux überschreibt- weswegen die Reihenfolge erst Windows dann Linux beim Dualboot schon mal die praktischere ist.
Grundsätzlich kann man aber doch zwei Rechner einsetzen - oder drei, wenn man für das Windows Office noch einen kleinen Apple-Compi hernimmt.
Genau das ist ja der Trick. Der Doppelpunkt macht aus einem Befehl ein
Label. Und voilà, der Befehl wird nicht mehr ausgeführt.
Ja, das ist soweit schon klar, aber es ist ... Pfusch.
Ich würde mir an Deiner Stelle einfach mal den halben Tag Zeit nehmen, der nötig ist, um zu verstehen, wie make funktioniert, das ist, wenn man das Makefile selbst schreibt, nämlich ziemlich simpel.
Anders sieht es aus, wenn man versucht, ein von einem Makefilegenerator o.ä. erzeugtes Makefile zu verstehen, aber das muss man sich ja nicht unbedingt antun.
Und so ein Makefile kann eben mehr als ein Batchfile, und man muss darin nicht mit kaputten Labels herumpfuschen.
Genau das ist ja der Trick. Der Doppelpunkt macht aus einem Befehl ein
Label. Und voilà, der Befehl wird nicht mehr ausgeführt.
Ja, das ist soweit schon klar, aber es ist ... Pfusch.
In einem buntigen Editor sehen diese Trickkommentare ziemlich komisch
aus. Da Peter als MS-DOS-Veteran vermutlich den unbunten EDLIN benutzt,
ist ihm das sicher noch gar nicht aufgefallen ;-)
Und so ein Makefile kann eben mehr als ein Batchfile, und man muss darin
nicht mit kaputten Labels herumpfuschen.
Und das Allerbeste: Kommentare werden ganz regulär mit einem einzelnen
Zeichen (nämlich mit '#') eingeleitet, so dass man sich guten Gewissens
den extremen Schreibaufwand für die REMs in den Batch-Dateien sparen
kann.
Was halt bei makefiles für Anfänger gewöhnungsbedürftig ist, ist die Unterscheidung von Leerzeichen und Tabulatoren; man sollte sich entweder harte Disziplin beim Umgang damit angewöhnen oder einen Texteditor nutzen, der Tabulatoren anzeigt.
Nachdem ich mich einige Tage nicht gemeldet hatte, weil ich probiert habe, wie ich es letztendlich umsetze und dabei so manch harten Kampf mit meinem Rechner hatte, wollte ich mich nochmal bei allen für die Tipps bedanken.
Die Idee mit VSCode habe ich ganz schnell verworfen. Ich will im Fenster sehen, mit welchen Parametern Compiler und Linker aufgerufen werden. Bei all meinen Experimenten, konnte ich da nichts sehen. Nur, dass das Programm erfolgreich compiliert und gelinkt wurde.
Da war mir klar, dass ich wieder auf mein gewohntes Eclipse umsteige. Mein erster Gedanke, ich verzichte auf das eclipse-plugin und mache das alles über das Makefile, was hier im Forum ist und
so wie von
Also ein Project-Target "Build", eines "Clean" und eines "Programm".
vorgeschlagen.
Ich habe jetzt mehrere Tage dran gesessen und das über das Makefile, dass hier im Forum als Beispiel vorhanden ist, ans Laufen zu bringen. Es hat nicht funktioniert.
Bei dem Makefile habe ich auch immer eine Fehlermeldung bekommen. Glaube die hiess "Datei nicht gefunden". Selbst mit "make -n" konnte ich das nicht heraufinden. Ich muss aber auch zugeben, dass ich nicht der makefilespezialist bin.
Allerdings denke ich nicht, dass es an dem Makefile liegt. Irgendwas ist unter Windows 11 anders, wenn ich Make aufrufen. Eclipse gibt beim compilieren und Linken in dem Consolenfenster Texte aus. In den alten Makefiles wurden die Texte mit @echo 'Text' ausgegeben. Das wird jetzt auch genau so im Consolenfenster ausgegeben. Also mit ' oder ". Nur bei dem Aufruf von @echo kommt 'echo ist off'. Das liegt aber nicht an Eclipse. Wenn ich das händisch von der Eingabeaufforderung aufrufe, war das auch.
Nachdem ich dann aber weitere Ergänzungen und Änderungen vornehmen wollte, das aber mangels geeigneter Doku im internet oder meiner Unfähigkeit nicht funktioniert hatte, habe ich mir was anderes überlegt.
Ich habe mir das Eclipse-Plugin installiert. Das funktioniert auch noch. Nur eben mit avrdude nicht. Ich hätte auch versucht den Sourcecode von dem Plugin zu ändern. Wenn ich das überhaupt ans Laufen bekommen hätte, hätte ich mich versucht in maven einzuarbeiten und dann das zu ändern. Weil mir das Plugin eigentlich gut gefällt. Es ist auch schade, dass der Entwickler Thomas Holland nicht mehr greifbar ist. Aber selbst das in der bisherigen Form habe ich nicht ans Laufen bekommen. Trotz Installation von maven.
Bei eclipse gibt es im Makefile eine Zeile am Ende des Makefiles: "-include ../makefile.targets"
In diesem Targetmakefile stehen jetzt die Anweisungen für avrdude. Dafür kann man auch hervorragend die Variablen von eclipse nehmen wie. z.B. "$(BUILD_ARTIFACT_NAME)". Also brauche ich nur einmal händisch den Comport für avrdude in dem Targetmakefile und den programmer wie zb. STK500 eingeben. Dann lege ich mir im Eclipse-Projekt ein Project-Target "program", eines "eeprom" an und kann dann darüber die Software flashen.
Die Ausgabe der Texte mit den Hochkommas bzw. Gänsefüsschen ist zwar nach wie vor. Aber damit muss ich jetzt leben.
Den Code muss auch hoffentlich niemand sonst lesen.
Hast Du Dir die Batch-Datei mal angesehen? Ich finde das sehr gut zu lesen. Der einzige Grund, warum ich das nicht so mache, wie Peter, ist meine Faulheit. Dafür müsste ich immer vom Editor in die Eingabeaufforderung wechseln. Das habe ich seit längerem mit Eclipse schon gemacht, weil das avr-plugin mit avrdude nicht mehr funktioniert hatte. Dafür hatte ich mir eine Batch-Datei geschrieben. Aber bei einem Wechsel des Controllers musste ich immer in Eclipse und in der Batch-Datei ändern. Bei einem Projektwechsel dann auch immer wieder eine neue Eingabeaufforderung aufmachen und in diesen Pfad wechseln bzw. von der bereits geöffneten Eingabeaufforderung dahin mit "cd". Das ist zwar jammern auf hohem Niveau, aber wenn man jahrelang den Komfort gewöhnt war...
Allerdings ist das typische Dualboot-Problem, dass Windows das
Bootmanagement von Linux überschreibt- weswegen die Reihenfolge erst
Windows dann Linux beim Dualboot schon mal die praktischere ist.
War bei meinem Rechener, den ich davor hatte auch schon. Es hatte einige Sekunden gedauert und danach wurde automatisch Windows gestartet, sofern ich dem nicht gesagt hatte, er soll Ubuntu starten. Allerdings habe ich in den letzten zehn Jahren nichts mehr mit Ubuntu gemacht. Die Daten auf dem letzten Rechner waren mir einfach zu wichtig, trotz regelmäßiger Datensicherung. Mangels Kenntnisse in Ubuntu hatte ich einfach die Befürchtung, dass mir bei der Installation ein Fehler unterläuft und ich dann dumm gucke. Daher bin ich bei Windows geblieben.
Nochmal ganz lieben Dank an alle. Bei mir läuft es jetzt mit den avrs. Die nächsten Tage muss ich mich darum kümmern, dass der Rest wieder auf den neuen PC kommt.
Makefiles wurden die Texte mit @echo 'Text' ausgegeben. Das wird jetzt
auch genau so im Consolenfenster ausgegeben. Also mit ' oder ". Nur bei
dem Aufruf von @echo kommt 'echo ist off'. Das liegt aber nicht an
Eclipse.
Die mit Tab eingerückten Zeilen des Makefiles sind Shell-Kommandos. In
unixoiden Shells (bspw. Bash) werden Kommandos teilweise anders
interpretiert als in der Default-"Shell" von Windows (cmd.exe aka
"Eingabeaufforderung"). Deswegen wird ein für Unix/Linux geschriebenes
Makefile unter Windows nur eingeschränkt oder evtl. sogar gar nicht
funktionieren. Oft werden in Makefiles auch Programme wie sed und grep
aufgerufen, die es in Windows standardmäßig nicht gibt.
Um das Problem zu beheben, gibt es folgende Möglichkeiten:
Du lässt Windows links liegen und verwendest (zumindest für die
Softwareentwicklung) Linux. Ok, das ist natürlich ein ziemlich großer
Schritt und für die Entwicklung von ein paar AVR-Progrämmchen
vielleicht etwas übertrieben.
Du sorgst dafür, dass auch unter Windows eine Bash und ein Satz von
Standard-Unix/Linux-Tools verfügbar ist. Dafür gibt es bspw. die
Pakete MSYS und Cygwin. Da auch Microsoft erkannt hat, dass
heutzutage ohne Linux nichts mehr geht, gibt es inzwischen WSL, das
eine Linux-ähnliche Umgebung innerhalb von Windows schafft. Falls du
Git für die Versionsverwaltung deiner Software benutzt, hast du die
Bash und weitere Unix/Linux-Tools (vielleicht, ohne es zu wissen)
bereits installiert. Du musst Eclipse bzw. Make nur noch klar machen,
dass diese die Bash anstelle von cmd.exe verwenden sollen.
Du passt im Makefile alle Kommandos so an, dass sie in cmd.exe
ausführbar sind. Bei einfachen Dingen wie echo sollte dies kein
großes Problem sein. In erster Linie musst du dazu die " und '
entfernen.
Ich bin kein Windows-Experte, aber m.W. verwenden die meisten
Make-Nutzer unter Windows eine der in (2) genannten Varianten, um
stressfrei alles, was die Linuxer mit Make frabrizieren, auch in Windows
nutzen zu können.
Falls du Make nur für die AVR-Entwicklung nutzen möchtest und dort mit
mehr oder weniger einem einzigen Makefile auskommst, kann auch (3) ein
gangbarer Weg sein.
Ich habe das für mich so gelöst, dass Linux in einer von Windows aus aufrufbaren VM läuft. Die VM ist so konfiguriert, dass ich bequem auf gemeinsame Verzeichnisse zugreifen kann; sowohl von Windows als auch von Linux. Das funktioniert in der Praxis sehr gut, vor allem für Makefile-basierte Projekte, die ich dann unter Linux problemlos bauen kann.
Makefiles unter Windows waren für mich dagegen immer ein Krampf.
Windows hat sich ständig über Pfadsymbole oder Backslashes beschwert, da war immer mehr Frust als Fortschritt. Unter Linux hingegen läuft alles wie es soll, keine Umwege, keine Überraschungen.
Da ich das VM Linux selten herunterfahre, ust das System auch schnell einsatzbereit. Unterm Strich habe ich so das Beste aus beiden Welten und bin mit dem Setup rundum zufrieden und genügt für mich.
Das musste ich sowieso machen. Habe msys mit make installiert. Ansonsten liess sich das Makefile gar nicht aufrufen oder es gab die merkwürdigsten Fehlermeldungen. Auch weil beim clean rm nicht funktioniert hatte.
In erster Linie musst du dazu die " und '
entfernen.
Habe ich auch festgestellt. Allerdings habe ich es nicht geschafft eine Leerzeile auszugeben. Da kommt immer "Echo ist ausgeschaltet" oder so ähnlich.
Ausserdem generiert eclipse die Makefiles selbst und da stehen die ' und " drin. Ich könnte zwar sagen, dass ein externes Makefile verwendet werden soll, aber sobald ich eine neue c-datei einfüge, muss ich die dann auch im makefile eintragen. So kümmert sich eclipse selbst darum.
Mit den ' und " sieht zwar nicht schön aus, aber da werde ich dann wohl mit leben müssen. Unter meinem alten Windows war es nicht.
Du lässt Windows links liegen und verwendest (zumindest für die
Softwareentwicklung) Linux. Ok, das ist natürlich ein ziemlich großer
Schritt und für die Entwicklung von ein paar AVR-Progrämmchen
vielleicht etwas übertrieben.
Ich habe in den letzten zehn Jahren gar nichts mit Linux gemacht, dass ich mich da überhaupt nicht mehr auskenne. Gimp und Eclipse laufen zwar auch unter Linux, aber mich da jetzt wieder einzuarbeiten, steht glaube ich in keinem Verhältnis.
Ich habe das für mich so gelöst, dass Linux in einer von Windows aus
aufrufbaren VM läuft.
Danke für den Hinweis. Da werde ich drüber nachdenken, wenn neue Probleme auftreten. Ich hatte gestern bei einem Projekt, dass es sich nach dem Importieren nicht compilieren liess, obwohl es auf dem alten Rechner ohne Probleme lief, aber das habe ich neu angelegt und die Dateien da rein geschoben. Dann ging es auch.
Mit der VM hatte ich vor Jahren schon mal gemacht, weil ich unbedingt ein Programm benötigte, dass nur unter XP lief unter 8.1 aber nicht. Das hatte dann schon einwandfrei geklappt.
Du kannst auch ein Projekt erzeugen, wo Eclipse das Makefile nicht selber erzeugt. Stattdessen wird dann dein eigenes vollständig von Hand geschriebenes aufgerufen beim build.
Das ändert zwar nichts an der Problematik make unter Windows/Linux aber dann hast du den Makefile selber in der Hand. Wenn Eclipse den erzeugt, soll man den nicht selbst editieren, steht auch oben als erstes drin :)
Deine Änderungen daran werden sicher auch überschrieben wenn du z.B. einen neuen C-File hinzufügst, weil der Makefile von Eclipse geändert werden muss.
Das musste ich sowieso machen. Habe msys mit make installiert.
Damit hast du auch die Bash installiert. Jetzt musst du nur noch dafür
sorgen, dass diese auch benutzt wird (anstelle von cmd.exe). Ich kenne
mich weder in Windows noch in Eclipse gut aus, aber m.W. gibt es in
Eclipse irgendwo einen Menüpunkt, über den man Environment-Variablen
definieren kann. Dort musst du der Variable SHELL den Pfad der Bash
zuweisen, also
Ich kenne
mich weder in Windows noch in Eclipse gut aus, aber m.W. gibt es in
Eclipse irgendwo einen Menüpunkt, über den man Environment-Variablen
definieren kann.
Kann man in Windows auch über die Pfadvariablen machen, wird i.d.R. über die Systemeinstellungen eingestellt.
(hatte ich bei Cygwin so gemacht, bzw. auch umgekehrt, so dass die Bash da auch das debug.prg Fenster zeigt.)
Textfilekorrektur ging mit Notepad++
Kann man in Windows auch über die Pfadvariablen machen, wird i.d.R. über
die Systemeinstellungen eingestellt.
Alternativ, wenn man das nicht systemweit haben will, schreibt man sich ein Batchfile, in dem die Umgebungsvariablen so gesetzt werden, wie man sie haben möchte, das dann Eclipse oder welches Tool auch immer aufruft.
Vorteil: Das funktioniert sofort; Änderungen über die Systemeinstellungen werden nur für danach neu gestartete Prozesse aktiv, und oft erst nach einem Ab- und erneuten Anmelden.
Da ist eine Batchdatei mit
1
set BLAFUSEL=SÜLZ
2
set PATH=%PATH%;"c:\program files\wo auch immer eclipse steckt"
3
4
eclipse.exe
meist einfacher zu handhaben. Und Leute, die die Kommandozeile nicht mögen/verstehen, können die Batchdatei auch über eine Verknüpfung o.ä. aufrufen.
Ich würde mir an Deiner Stelle einfach mal den halben Tag Zeit nehmen,
der nötig ist, um zu verstehen, wie make funktioniert, das ist, wenn man
das Makefile selbst schreibt, nämlich ziemlich simpel.
Ein halber Tag reicht da nicht.
Zum Makefile findet man nur den absoluten Urschleim. Will man aber was komfortableres (Umgebunsvariablen, Pfade setzen, Kommandos mit Argumenten ausführen, Wildcards benutzen, Bedingungen abtesten, Operationen ausführen usw.) steht man ziemlich im Regen da. Zu Batch findet man dagegen schnell Hilfe im Web, auch für die kompliziertesten Wünsche.
Und nicht sichtbare Zeichen (Tab) als Syntaxelement zu verwenden, ist einfach nur krank. Wer denkt sich bloß solchen Unsinn aus.
Irritierend ist auch, daß man die Reihenfolge von Anweisungen durcheinander würfeln kann. Eine Batch wird dagegen streng zeilenweise abgearbeitet.
Ich hab mir mal eine Batch geschrieben, die ein makefile erzeugt für einen Kollegen:
1
@echo off & setlocal
2
SET PATH=C:\Program Files (x86)\Atmel\Studio\7.0\toolchain\avr8\avr8-gnu-toolchain\bin;C:\Program Files (x86)\Atmel\Studio\7.0\shellutils;;%PATH%
3
4
set vers_h=01
5
set vers_l=44
6
set name=PU-Module
7
set mcu=90can128
8
set fcpu=16000000
9
:set fcpu=8000000
10
set lib1=../../Devices2020/ModuleInterface
11
set lib2=../../ModuleInterface
12
set lib3=../Lib
13
set crcstart=0x2234
14
set main=%name%_V%vers_h%.%vers_l%
15
16
REM ************************************* generate makefile *********************
Irritierend ist auch, daß man die Reihenfolge von Anweisungen
durcheinander würfeln kann. Eine Batch wird dagegen streng zeilenweise
abgearbeitet.
Mir scheint, daß Du etwas elementares an Makefiles übersehen hast. Die /Anweisungen/ in einem Makefile werden ebenfalls streng zeilenweise abgearbeitet, nur hat jeder Anweisungsblock /Bedingungen/, aufgrund derer er ausgeführt wird, oder nicht.
Aber wenns schon an so etwas grundlegendem scheitert, wie zu akzeptieren, daß da halt tabs verwendet werden, dann ist die vorgefertigte Meinung halt ausreichend verhärtet.
Sieh Dir als Makefilegenerator mal CMake an. Das ist dann doch einiges leistungsfähiger als Dein Batchfile. Aber vermutlich gefällt Dir an dem auch irgendwas nicht.
Ja Harry, so kennen wir Dich. Du dichtest Dir schnell mal eben was dazu.
Ich habe erst auf ausdrücklichen Wunsch meine Batch gezeigt. Und später erklärt, was mir an make nicht gefällt.
Du kannst aber gerne mal zitieren, wo ich jemanden missioniert hätte.
Du kannst auch ein Projekt erzeugen, wo Eclipse das Makefile nicht
selber erzeugt. Stattdessen wird dann dein eigenes vollständig von Hand
geschriebenes aufgerufen beim build.
Das weiss ich. Aber da bin ich kläglich gescheitert. Daher habe ich das avr-eclipse-plugin wieder installiert.
Wenn Eclipse den erzeugt,
soll man den nicht selbst editieren, steht auch oben als erstes drin :)
Deine Änderungen daran werden sicher auch überschrieben wenn du z.B.
einen neuen C-File hinzufügst, weil der Makefile von Eclipse geändert
werden muss.
Ich habe nur ein makefile.target erstellt. Das wird nicht überschrieben. Das eigentliche Makefile wird von eclipse erzeugt und bei jedem compilieren neu erstellt. Da bin ich nicht dran gegangen.
Aber erstaunlicherweise bekomme ich jetzt mit echo eine vernünftige Anzeige wenn ich einen Text mit @echo ohne ' oder " ausgebe. Mir ist jetzt nur nicht klar, warum das plötzlich so ist.
Damit hast du auch die Bash installiert. Jetzt musst du nur noch dafür
sorgen, dass diese auch benutzt wird (anstelle von cmd.exe).
Werde ich mich in den nächsten Tagen mal dran setzen. Bei den automatisch von eclipse erzeugten Makefiles ist das ' nämlich immer noch drin und wird auch in der Console ausgegeben. Aber wie ich bereits geschrieben habe, ist das jammern auf hohem Niveau.
Leute, streitet Euch nicht ob Batch- oder Makefile. Zum einen bin ich froh, wenn mir hier geholfen wird oder Tipps gegeben werden. Zum anderen fand ich die Idee mit der Batch-Datei gar nicht schlecht. Es war für mich auch super lesbar und ist auf jeden Fall auf dem Rechner gespeichert. Warum ich mich letztendlich dagegen entschieden habe, hatte ich bereits erklärt. Ich mag es rein aus Bequemlichkeit, wenn ich alles an einer Stelle bedienen kann.
Hierzu ein anderes Beispiel. Ich hatte auf meinem alten Rechner in eclipse das Sloeber-Plugin installiert. Nicht weil ich damit arduinos programmieren kann oder wollte, sondern weil ich da Ausgaben über printf auf dem Mikrocontroller in einem Fenster von Eclipse anzeigen kann. Auf dem neuen Rechner hatte ich das auch installiert. Aber das hat mir schon bei meinem alten Rechner beim Start von eclipse immer gemeckert, dass der Pfad für das Plugin zu lang ist. Auf dem neuen Rechner hat es mich genervt, dass eclipse erst weiterlief, wenn ich diese Fehlermeldung bestätigt hatte und ich habe das wieder deinstalliert. Wenn ich jetzt die printf-Ausgaben sehen will, dann muss ich immer Hterm separat aufrufen. Die Hin- und Herschalterei hätte ich gerne umgangen und in einem Programm. Alles nur Bequemlichkeit.
Irritierend ist auch, daß man die Reihenfolge von Anweisungen
durcheinander würfeln kann.
Ein Makefile ist eben /kein/ Skript, das von oben nach unten abgearbeitet wird. Mit Abstand der häufigste Irrtum über Makefiles ist, es handle sich dabei um eine Skriptsprache.
Wenn alles andere versagt, könnte man auch mal die Doku lesen...
Du kannst auch ein Projekt erzeugen, wo Eclipse das Makefile nicht
selber erzeugt. Stattdessen wird dann dein eigenes vollständig von Hand
geschriebenes aufgerufen beim build.
Das weiss ich. Aber da bin ich kläglich gescheitert. Daher habe ich das
avr-eclipse-plugin wieder installiert.
Ich wollte das hier gerade nochmal ausprobieren.
Es funktioniert mit der aktuellen Version 2025-06 (4.36.0) unter Linux scheinbar nicht mehr. Man kann so ein Projekt erzeugen aber der Build liefert merkwürdige Fehler, das makefile wird scheinbar nicht verwendet bzw. es kommt garnicht bis zum Build dieses makefiles weil vorher im Prozess etwas schief läuft. Das hinzukonfigurieren ist mir nicht gelungen bisher.
Vorhandene Projekte mit makefile lassen sich allerdings noch bauen.
Leider scheint die CDT immer mehr buggy oder zu unübersichtlich zu sein. Mir ist das jedenfalls gerade nicht gelungen solch ein Projekt anzulegen und erfolgreich zu bauen.
Ein Managed C/C++ Projekt lässt sich anlegen und mit Aufwand dann auch so konfigurieren, dass es funktioniert mit den Project-Settings, sodass man nicht händisch im Makefile manipulieren muss.
Ein Makefile ist eben kein Skript, das von oben nach unten
abgearbeitet wird.
Ja, genau das ist es, was mich so irritiert hat. Es ist für einen Ungeübten nur schwer zu erkennen, was wann bzw. ob es überhaupt ausgeführt wird und mit welchen Argumenten.
Vielleicht kann man ja auch einen geschwätzigen Mode einschalten der alle Schritte anzeigt, ähnlich wie bei einer Batch mit "echo on".
Es funktioniert mit der aktuellen Version 2025-06 (4.36.0) unter Linux
scheinbar nicht mehr.
Habe es jetzt nochmal mit Version 2025-09 getestet und damit hab ich es hinbekommen. Aber nicht bei der direkten Auswahl des "Makefile Project" sondern über den Umweg "C Managed Build Project". Darunter kann man auch nochmal "Makefile project" auswählen. Und dann funktioniert es.
Also so (ich hoffe es ist verständlich):
1
- File -> New -Project...
2
- C/C++ -> C/C++ Project --> Next
3
- C Managed Build --> Next
4
- Makefile project -> Empty Project
5
Cross GCC auswählen
6
Projektnamen eintragen
7
Next
8
- Finish
Jetzt lässt sich ein Makefile (selbst geschrieben) aus dem Projekt Verzeichnis bauen.
Ich vermute auch, dass es mit der älteren Eclipse Version so funktionieren wird. Ich hab es da nur nicht auf diesem Wege ausprobiert.
Habe es erst jetzt gesehen. Danke für Deine Bemühungen. Ich werde das demnächst mal testen. Im Moment komme ich mit der Krücke über "makefile.target" ganz gut hin.
