Update 7.1.2016:

 VBTermie bietet die Möglichkeit, den Port während des Hochladens frei zu geben.  Details für Arduino-IDE oder Visual Micro Add-On siehe hier.

Update 8.12.2015:

Das Hochladen von Programmen mit avrdude funktioniert nicht, wenn gleichzeitig ein serieller Monitor den Port blockiert. VBTermie bietet die Möglichkeit, den Port während des Hochladens frei zu geben. Details siehe hier.

Update 7.5.2015:

Nach Installation der Arduino-IDE mit der Version 1.6.4 funktioniert das Upload mit avrdude nicht mehr. Das Problem wurde gelöst, indem die mit installierte Version von "avrdude.exe" und "avrdude.conf" in das vorgesehene Verzeichnis kopiert und dabei die alten Versionen ersetzt wurden (s. Abschnitt Verzeichnisse). Ursache ist unbekannt, ich habe auch nicht weiter nachgeforscht, da nach dem Ersetzen der Dateien anscheinend alles funktioniert.

Update 14.1.2015:

Mittlerweile gibt es das Atmel Studio in der Version 6.2. Erste Versuche zeigen: Funktioniert einwandfrei.

Visual Micro ist eine kostenlose Erweiterung Arduino IDE for Atmel Studio 6.1 & 6.2. Auch die scheint einwandfrei zu funktionieren. Wer Arduino-Programme mit und nach den Regeln des Standard-Frameworks entwickeln will, ist mit dieser Erweiterung gut bedient. U.a. öffnet sich nach dem Hochladen eines Programms automatisch der Serial Monitor. Das ist ganz praktisch.

Das Programm hat aber auch einige Schwachstellen: Die Zwischendateien werden im Verzeichnis  "<user>\AppData\Local\VMicro\Arduino\Builds" abgelegt und nicht wieder gelöscht. AppData\Local ist sowieso eine große Müllhalde, die muss man nicht noch weiter aufblähen. Zumal man hier nicht einfach löschen kann (oder nicht sollte), wie es mit Temp-Verzeichnis möglich ist, dass die Arduino-IDE nutzt.

Der zweite negativ aufgefallene Punkt ist, dass die Toolchain-Einstellungen bei jedem Kompilier-Vorgang wieder restauriert werden. Mir war es nicht möglich, ein zusätzliches Include-Directory hinzu zu fügen. Bein Kompilieren gab es dann Fehler und der Eintrag war jedes Mal wieder fort.

Wahrscheinlich lässt dich beides konfigurieren. Zu Visual Micro hat eine ausführliche Online-Bedienungsanleitung. Aber RTFM ist mir zu mühselig, zumal die im folgenden beschriebene Variante problemlos funktioniert und sehr flexibel ist. Es funktioniert übrigens beides parallel, aber nicht in Kombination.

Das Atmel Studio in der aktuellen Version 6.1 ist eine gute Wahl für alle die Anwender, die der integrierten Arduino-IDE entwachsen sind. Bei der Arduino IDE geschieht viel im Hintergrund. Das ermöglicht zwar Anfängern einen äußerst einfachen Einstieg in die Materie, begrenzt aber nachhaltig die Möglichkeiten für erfahrene Programmierer. Z.B. die fehlenden Compiler-Warnungen und Debugging-Funktionen machen das Leben bei Arbeiten an fortgeschrittenen Projekten schwer. Allerdings ist die Nutzung einiger dieser Arduino-Bibliotheken wirklich bequem: Serielle Schnittstelle? Gibt es! Ethernet-Fähigkeit? Ist dabei!

Also warum nicht das Beste aus beiden Welten? Die Arduino-IDE stellt im Grunde nur ein Wrapper über C / C++ dar. Technisch ist es deshalb möglich, jeden Sketch oder Arduino Bibliothek mit beliebigem Code zu kombinieren. Der Trick liegt bei der richtigen Einrichtung des Atmel Studio Projekts. Hier sind die Schritte zur Einrichtung eines voll funktionsfähigen Arduino-Projekts in Atmel Studio 6 beschrieben. Hierdurch hat man Zugriff auf die riesige Auswahl von Arduino Code-Bibliotheken in Kombination mit Zugriff auf alle Funktionen moderner AVR-Prozessoren und einer echten IDE.

Versionen

Die Test habe ich mit folgender Konfiguration gemacht:

Der Plan

Die Arduino-IDE benutzt den gleichen Compiler1) avr-gcc, den auch das Atmel Studio benutzt. Beim Kompilieren in der IDE wird zunächst eine Bibliothek (Library) mit allen Arduino-Funktionen erstellt, die zusätzlich zur avr-libc zum eigentlichen Sketch-Code eingebunden wird. Zunächst wird eine solche Bibliothek mit Hilfe der IDE erzeugt und gesichert. Programme, die mit dieser Bibliothek gelinkt werden, funktionieren zwar häufig nicht, dieser Zwischenschritt ermöglicht es aber auf einfache Weise, den Compile-Vorgang im Atmel Studio zu konfigurieren und zu testen.

Einige der folgenden Schritte müssen board-spezifisch angepasst werden. Die betreffenden Angaben sind grau hinterlegt.

1) Allerdings in einer anderen Version. Arduino 4.3.2, Atmel: 4.7.2.

Downloads

Damit man nicht lange suchen muss, hier zusammengefasst alle Downloads. Die Downloads enthalten z.T. Dateien für den Arduino Uno und solche für den Leonardo aus dem Abschnitt System an andere Boards anpassen. Der Arduino Uno Turbo ist hier beschrieben.

Verzeichnis ArduinoSupport mit bereinigten Quelldateien (s.u.)
Beispielprojekt ArduinoBlink
Bibliotheksprojekt ArduinoCore
Projektvorlagen ArduinoTemplate

Vorbereiten der Verzeichnisse

Es wird ein Verzeichnis benötigt, in dem die erstellte Library abgelegt werden kann. Weiterhin ist es sinnvoll, auch die Quellen und die Header-Dateien zu sichern, die dieser Library zu Grunde liegen. Denn nur genau diese passen zu der erstellten Library. So ist man vor unvorhergesehen Änderungen bei Updates geschützt. Des weiteren wird avrdude zum hochladen der Programme benötigt. Diesen kopiert man am besten auch, dann ist man vollkommen unabhängig von der Arduinio-IDE. Man kann sich dann im Falle von Updates der Arduino-IDE entscheiden, ob man die kopierten Dateien ebenfalls anpasst oder die alte Version beibehält.

Zunächst wird ein Basis-Verzeichnis benötigt. Ich habe hierzu im Ordner ...\Eigene Dokumente\Atmel Studio ein Unterverzeichnis ArduinoSupport angelegt. Dieser befindet sich somit auf der gleichen Stufe wie der "Projects"-Ordner.

Basis Verzeichnis

In diesem Ordner gibt es fünf Unterverzeichnisse: cores, bin, lib, src und variants.

Verzeichnis-Struktur

Nach cores kommen alle Header-Dateien aus ...\arduino-1.0.5\hardware\arduino\cores. Am besten man kopiert das gesamten Verzeichnis und löscht dann die nicht benötigten Dateien .c- und .cpp-Dateien. Ob man das Unterverzeichnis robot mit kopiert, hängt von den eigenen Wünschen ab. Achtung: Es gibt in diesen Verzeichnissen weitere Unterverzeichnisse!

Analog verfährt man mit variants. Das Quellverzeichnis ist ...\arduino-1.0.5\hardware\arduino\variants.

Nach src werden sämtliche ".c"- und ".cpp"-Dateien ...\arduino-1.0.5\hardware\arduino\cores kopiert.

Nach bin werden die Dateien avrdude.exe und avrdude.conf aus der Arduino-IDE-Installation kopiert. Am besten sucht man mit der Windows-Suche nach *dude*.* im Arduino-Installationsverzeichnis.

lib wird später gefüllt.

Dieser Schritt muss nur einmal durchgeführt werden. Der Inhalt des Verzeichnis kann hier heruntergeladen werden: ArduinoSupport.rar

Vorbereiten der Arduino-IDE

Bei einigen der im folgenden beschriebenen Punkte müssen Parameter entsprechend der board-spezifisch angepasst werden. Dazu gehören auch solche, die die Arduino-IDE vorgibt. Deshalb ist es sinnvoll, die IDE so einzustellen, dass sie möglichst viel verrät.

Dazu öffnet man die IDE, wählt den Menü-Punkt Datei => Einstellungen und hakt in dem erscheinenden Fenster beide Punkte bei "Ausführliche Ausgabe anzeigen während:" an:
Arduino-IDE Einstellungen

Wenn nun ein Arduino-Programm erstellt wird, erscheint im Protokoll-Fenster der IDE ein ausführlicher Bericht der Projekterstellung, dem man viele benötigte Einzelheiten entnehmen kann.

Standard-Meldung der IDE
Standard-Meldung der IDE
Ausführliche Meldung der IDE
Ausführlicher Bericht der Projekt-Erstellung

Dieser Schritt muss nur einmal durchgeführt werden.

Vorbereiten der Arduino-Core-Bibliothek

Viele der Arduino-Funktionalitäten werden von einem integrierten Framework bereit gestellt. Hierzu gehört auch das Aufrufen der zentralen Funktionen setup() und loop() eines Sketches.  Das Framework wird beim Erstellen eines Arduino-Programms von der IDE in Form einer Bibliothek bereitgestellt. Dies muss nachgestellt werden.

Dazu öffnet man die Arduino-IDE, stellt den korrekten Board-Typ ein (Menü: Tools => Board => Arduino Uno) und lädt ein beliebiges Beispiel-Programm. Ich benutze im folgenden das Programm "Blink" in der Rubrik "01.Basics". Wenn dieses Projekt dann erstellt wird (Menü: Sketch  =>  Überprüfen / Kompilieren), erzeugt die IDE neben anderen Dingen auch die benötigte Bibliothek. Die Dateien, die zur Projekterstellung erzeugt werden, findet man in einem Unterverzeichnis des TMP-Verzeichnisses. Dieses Verzeichnis hat üblicherweise einen Namen wie build3464833112909068451.tmp. Die Ziffernfolge wechselt. Der genaue Name lässt sich aus dem Erstellungsprotokoll entnehmen (s.o.). In diesem Verzeichnis befindet sich eine Datei mit dem Namen core.a. Dies ist die gesuchte Bibliothek.

Da diese Bibliothek board-spezifisch ist, nennt man sie am besten um in libArduinoCoreUno.a und kopiert in den vorher erstellten Ordner ArduinoSupport\lib. Das der Name der Bibliothek mit "lib" beginnt ist wichtig! An den Linker wird nur "ArduinoCoreUno" übergeben. Den Rest fügt der Linker selbst hinzu.

Dieser Schritt muss für jedes Board einmal durchgeführt werden.

Projektkonfiguration im Atmel Studio

Man startet zunächst mit einem ganz normalen neuen GCC C++ Executable Project. Projektname und Projektmappenname können frei gewählt werden. Für diese Anleitung heißt die Projektmappe ArduinoBlink und das Projekt heißt MyBlink, analog zum entsprechenden Arduino-Sketch. Als nächstes wird man aufgefordert den Prozessor-Typ auszuwählen. Für den Arduino Uno R3 ist dies ein ATmega328P. Hat man dies gemacht, wird das Projekt angelegt und eine Quellen-Datei mit dem Namen MyBlink.cpp erzeugt.

Im Projekt müssen nun die Compiler- und Linker-Optionen passend eingestellt werden. Dies ist ein wenig aufwändig, sollte man aber einmal gemacht haben. Für das nächste Projekt würde man dann entweder eine Kopie des einmal funktionierenden Projekts nehmen oder das unten beschriebene Template verwenden.

Bei der Anpassung der Einstellungen muss man darauf achten, dass man alle Stellen erwischt!  Ein Standard-Projekt besitzt zwei separate Konfigurationen,  Release und Debug, mit unabhängigen und auch z.T. unterschiedlichen Einstellungen. Außerdem gibt es je einen eigenständigen Satz an Einstellungen für den C- und den CPP-Compiler. Man kann das Projekt natürlich so konfigurieren bzw. manipulieren, dass  nur noch die Release-Konfiguration enthält und auch nur CPP-Quellen verwenden, aber dann verschenkt man vieles aus dem Leistungsumfang des Atmel Studio.

Zunächst muss das Eigenschaften-Fenster des Projekts geöffnet und der Reiter Toolchain gewählt werden. In diesem Fenster gibt es eine Drop-Down-Box mit der man die Konfiguration auswählen kann, für die man Änderungen vornehmen will.

Konfigurationswahl

Diese Auswahl bietet zwar die Möglichkeit, Änderungen an allen Konfigurationen gleichzeitig vorzunehmen. Bei mir führt diese Auswahl aber immer relativ schnell zu einer Fehlermeldung. Ich musste also immer jede Konfiguration einzeln bearbeiten.

Symbole definieren (C & C++)

Als erstes müssen vier Symbole definiert werden. Dies sind:

Diese werden dem bereits vorhandenen Symbol  "DEBUG" bzw. "NDEBUG" hinzugefügt.
Symbol-Definitionen

Achtung: Das Ganze muss vier Mal gemacht werden: Release und Debug, C und C++!  Das Kontextmenü (recht Maustaste) zu diesen Einträgen erlaubt Copy & Paste.

Include-Verzeichnisse definieren (C & C++)

Der nächste Schritt ist, dem Compiler die Include-Verzeichnisse für die Arduino-Header-Dateien bekannt zu geben. Dies geschieht durch die entsprechenden Einträge in die Rubrik Directories. Die allgemeinen Include-Dateien befinden sich im Verzeichnis ...\ArduinoSupport\cores\arduino (s.o.). Die board-spezifische Datei pins_arduino.h befindet sich in einem Unterverzeichnis von ...\ArduinoSupport\variants. Für den Arduino Uno ist das Unterverzeichnis standard zuständig.
Include-Verzeichnisse

Achtung: Das Ganze muss vier Mal gemacht werden: Release und Debug, C und C++!  Das Kontextmenü (recht Maustaste) zu diesen Einträgen erlaubt Copy & Paste.

Optimierungseinstellungen festlegen (C & C++)

Als nächstes müssen die Optimierungsoptionen überprüft bzw. angepasst werden. -ffunction-sections und -fdata-sections sollten beide angehakt sein. Der Optimization Level für die Release-Konfiguration ist Os, der für die Debug-Konfiguration ist O1.
Optimizer Einstellungen

Achtung: Das Ganze muss vier Mal gemacht werden: Release und Debug, C und C++!

Debugging-Einstellungen festlegen (C & C++)

Der Debugging-Level sollte auch in der Release-Konfiguration auf g2 gesetzt werden. Dann enthält das erzeugte Assembler-Listing (.lss-Datei) auch den Quellcode und man findet sich leichter zurecht.
Debugging-Einstellungen

Achtung: Das Ganze muss zwei Mal gemacht werden: C und C++!

Sonstige Einstellungen festlegen (C++)

Für den C++ Compiler muss noch eine separate Einstellung erfolgen, die das Einbinden von unnötigem Code zur Behandlung von Ausnahmen (Exceptions) unterbindet. Dies ist die Angabe "-fno-exceptions" in der Rubrik Miscellaneous des C++ Compilers.
Miscellaneous Options

Achtung: Das Ganze muss zwei Mal gemacht werden: Release und Debug!

Linker Einstellungen

Man kann nun gleich mit den Einstellungen für den Linker weitermachen. Hier sind die Einstellungen zur Optimierung zu überprüfen bzw. anzupassen. --gc-sections sollte angehakt sein.
Linker Optimization

Achtung: Das Ganze muss zwei Mal gemacht werden: Release und Debug!

Bibliotheken einbinden

Als letztes muss noch die zuvor erstellte Library eingebunden werden. Dies geschieht in dem Reiter Libraries bei den Linker-Einstellungen. In das Fenster Libraries fügt man über die Add Item Schaltfläche den Namen der Bibliothek hinzu. Der Name muss per Hand eingegeben werden. Danach muss man nun noch über die Move Up bzw. Move Down Schaltflächen die eingefügte Bibliothek vor libm bugsieren.

Den Pfad auf die Bibliothek wird im Fenster Library Search Path eingestellt, ebenfalls über die Add Item Schaltfläche.
Einbindungsreihenfolge

Achtung: Das Ganze muss zwei Mal gemacht werden: Release und Debug!

Programm-Quelle erstellen

Hier sind wir nun beim Pudels Kern. Hier ist die eigene Intuition gefragt! Die einzigen Bedingung, die erfüllt sein müssen, ist die Angabe #include "Arduino.h" im Programmcode und die Implementierung von setup() und loop(). Die minimale Version eines Programm sieht also wie folgt aus:

#include "Arduino.h"

void setup()
{
	  /* add setup code here, setup code runs once when the processor starts */
}

void loop()
{
	  /* add main program code here, this code starts again each time it ends */
}

Man kann aber auch direkt den Inhalt einer Sketch-Datei (".ino") nehmen und einfügen. In diese Quelle muss dann nur noch das #include "Arduino.h" eingefügt werden. Mit dem Beispiel "Blink" sähe das dann so aus:

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
 */

#include "Arduino.h"
 
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Wenn man alles richtig gemacht hat, sollte sich das Programm jetzt fehlerfrei erstellen lassen.

Leider ist es so, dass so das erstellte Programm i.d.R. nicht funktioniert. Der nächste Schritt besteht deshalb darin, auch die Arduino-Bibliothek mit Hilfe der Atmel Studio zu erzeugen. In dem Download ArduinoSupport.rar ist bereits die über das Atmel Studio erstellte Bibliothek enthalten. Das Beispiel-Projekt kann ebenfalls im Download-Abschnitt heruntergeladen werden,

Bibliothek erstellen

Am einfachsten geht es, wenn man das bereits oben erstellte Projekt als Basis für das Bibliotheksprojekt nimmt.

  1. Dazu wird erst einmal der Projektmappenordner ArduiboBlink kopiert und in ArduinoCore umbenannt. Im Ordner wird die Datei ArduinoBlink.atsou  gelöscht. Sie enthält lokale Einstellungen der Atmel Studio IDE und wird neu erstellt, wenn man die Solution öffnet.
  2. Die Solution-Datei ArduinoBlink.atsln wird umbenannt in ArduinoCore.atsln. Ebenso der Projektordner MyBlink in ArduinoCore.
  3. Die Solution-Datei ArduinoBlink.atsln öffnet man mit einem Editor, z.B. Notepad und ändert die Textstellen "MyBlink" zu "ArduinoCore". Es sind drei Stellen.
  4. Dann wechselt man in den Projektordner ArduinoCore. Die Projektdatei MyBlink.cppproj wird in ArduinoCore.cppproj umbenannt. Die Ordner Debug und Release werden gelöscht.
  5. Nun wird die Solution mit dem Atmel Studio geöffnet. Die enthaltene Quellendatei MyBlink wird gelöscht (Entfernen / Löschen).
  6. Danach müssen die Projekteigenschaften angepasst werden.
    1. Ich habe zunächst die Debug-Konfiguration mit Hilfe des Configuration Managers gelöscht. Bibliotheken werden üblicherweise in der Release-Konfiguration erstellt. Wer beide Konfigurationen beibehalten möchte, muss die folgenden Schritte für beide Konfigurationen durchführen. Im Projekteigenschaftenfenster den Link Configuration Manager anklicken.
      Configuaration Manager
      Im sich öffnenden Fenster des Konfigurations-Manager in der DropDown-Box <Bearbeiten...> auswählen.
      <Bearbeiten ...> auswählen
      Debug auswählen und entfernen. Danach alles wieder schließen.
      Debug entfernen
    2. Den Projekttyp auf Library umstellen. Im Reiter Build muss die Gruppe Build Artifact angepasst werden. Der Artifact Type ist Static Library und bei Artifact Name sollte man gleich libArduinoCoreUno eintragen.
      Artifact Type
    3. Für den C-Compiler wird ein zusätzliche Include-Search-Path benötigt. Dies ist das Verzeichnis ...\ArduinoSupport\cores\arduino\avr-libc.
      Include Search Paths
  7. Nun müssen die Programmquellen hinzugefügt werden. Im Projektmappen-Explorer Hinzufügen => vorhandenes Element anwählen.
    Quellen hinzufügen
    Im aufgehenden Explorer-Fenster ins Verzeichnis ...\ArduinoSupport\src wechseln und alle Dateien auswählen. Als Hinzufüge-Option wählt man Als Link hinzufügen.
    Hinzufüge-Option
  8. Das Projekt ist soweit vorbereitet und kann erstellt werden. Der Compiler wird ein paar Warnungen ausgeben. Die sind aber harmlos. Man kann die Quellen überarbeiten, damit dies nicht mehr geschieht. Die Datei ArduinoSupport.rar im Download enthält die bereinigten Quellen2).
  9. Als letztes muss die erstellte Bibliothek aus dem Release-Verzeichnis nach ...\ArduinoSupport\lib kopiert werden.
  10. Nun kann wieder ArduinoBlink geöffnet und das Projekt erstellt werden (neu erstellen auswählen!).

Die Anlage des Bibliotheks-Erstellungs-Projekts muss einmal durchgeführt. Für jedes Board muss jedoch die Konfiguration angepasst (s.u.) und eine entsprechende Bibliothek erstellt werden. Das Projekt für die Bibliothekserstellung kann unter Download ArduinoCore heruntergeladen werden.

2) Es wurden nur die Warnungen für den Arduino Uno bearbeitet. Die für den Leonardo erscheinen noch, hier sind die Quellen noch im Original. Da ich keinen Leonardo besitze, kann ich nicht testen, ob die Korrekturen korrekt wären.

Uploader konfigurieren

Die Arduino-IDE benutzt avrdude zum hochladen der Programme. Im Atmel Studio wird nun ein "Externes Tool" eingerichtet, mit dem avrdude mit den passenden Parametern gestartet wird. Dies geht über den Menüpunkt Extras => Externe Tools. Dort wählt man Hinzufügen.

Uploader Konfiguaration

In den Parametern zur Steuerung des avrdude müssen Angaben zum Controllertyp, zum vorgesehenen Com-Port und zur Baudrate gemacht werden, wobei Controllertyp und Baudrate board-spezifisch sind. Das Externe Tool nennt man demzufolge entsprechend. Das Feld Titel bekommt den Eintrag "avrdude Arduino Uno Com12". Com12 ist nahezu immer anzupassen (s.u.).

Im Feld Befehl wird avrdude.exe im Verzeichnis ...\ArduinoSupport\bin ausgewählt.

Das Feld Argumente erhält den Eintrag
 
 -C"..\..\ArduinoSupport\bin\avrdude.conf" -v -v -patmega328p -carduino -P\\.\COM12 -b115200 -D -Uflash:w:"$(TargetDir)$(TargetName).hex":i
 
Dieser Eintrag kann von hier kopiert und direkt in das Feld übertragen werden. Es muss dann allerdings noch der Com-Port angepasst werden. Den korrekten Port enthält man entweder aus dem Protokoll der Arduino-IDE oder über den Windows-Geräte-Manager.

Geräte-Manager

Für das Feld Ausgangsverzeichnis wählt man Projektmappenverzeichnis ($(SolutionDir)). Damit startet avrdude in dem Verzeichnis zu dem die relativen Pfade stimmen.

Von den Checkboxen hakt man nur Ausgabefenster verwenden an. Dann erscheint das Upload-Protokoll im Ausgabefenster des Atmel Studio.

Checkboxen-Auswahl

Zum Upload des fertigen Programms muss ein beliebiges Objekt im Projekt oder das Projekt selbst markiert sein! Ist die Projektmappe markiert stimmen die Verzeichnisse nicht. Nun kann im Menü Extras der neu eingerichtete Menüpunkt avrdude Arduino Uno Com12 ausgewählt und der Upload gestartet werden.

Uploader starten

Die Anlage eines Upload-Kommandos muss für jedes Board durchgeführt werden. Es kann sein, dass sich der Com-Port, mit dem Windows den Arduino anmeldet, mit der Zeit ändert. Windows hat da so seine Eigenheiten ... Ist die der Fall, legt man entweder ein neues Kommando an oder ändert das bestehende. Man kann auch Windows umkonfigurieren, damit wieder der alte Port benutzt wird.

Wer mag, kann auch die Menüstruktur des Atmel Studio anpassen um ein eigenes Upload-Menü oder passende Schaltflächen zu erhalten.

Ergänzung (8.12.2015):

Wenn man zum Zeitpunkt des Hochladens einen seriellen Monitor geöffnet hat, funktioniert der Upload nicht. avrdude meldet, dass der Port nicht geöffnet werden könne. Benutzt man VBTermie, gibt es die Möglichkeit, dieses zu veranlassen, den Port während des Hochladens freizugeben.

arvdude kann in diesem Fall nicht direkt aufgerufen werden, sondern muss in eine Batch-Datei (ArduinoUnoCom12.cmd) ausgelagert werden:

VbTermie DISCONNECT THROW
Sleep 1
C:\Develop\Arduino\hardware\tools\avr\bin\avrdude.exe %*
VbTermie RECONNECT THROW

Das Sleep-Kommando (ein selbst geschriebenes Programm) ist notwendig, damit VBTermie genügend Zeit hat, die Verbindung sicher abzubauen.

Bei der Konfiguration des externen Kommandos muss nun eine Verweis auf die Batch-Datei eingetragen werden:

 Alternatives Kommando

Wenn sich die Batch-Datei nicht im Such-Pfad befindet, muss der komplette Pfad eingetragen werden.

Ergänzung zur EPS8266 Plattform mit Visual Micro (9.8.2019)

Ab Version 2.5.2 wird der Upload über ein Python-Programm ausgeführt. Im Standard wird der Programm-Upload zum ESP8266 über diese Zeile in der Datei platform.txt gesteuert:

tools.esptool.upload.pattern="{cmd}" "{runtime.platform.path} ...

Zum Anpassen des Upload-Kommandos sind folgende Modifikationen sind notwendig:

Es wird eine Batch-Datei mit diesem Inhalt erstellt:

@echo off 
echo redirected esptool 
VbTermie DISCONNECT THROW 
Sleep 1 
%* 
set EL=%ERRORLEVEL% 
VbTermie RECONNECT THROW 
exit %EL%

Bei mir heißt diese Datei "urs-upload.cmd". Die Datei legt man am besten in einem Verzeichnis ab, zu dem ein Suchpfad existiert. Ist dies nicht möglich, muss später der komplette Pfad zu der Datei eingetragen werden.

Folgende Zeile muss der Datei platform.txt hinzugefügt werden:

tools.esptool.upload.pattern="urs-upload.cmd" "{cmd}" "{runtime.platform.path} ...

Original-Zeile kopieren und hinter das "="-Zeichen den Namen der Batch-Datei eingefügen. Ist diese nicht über die Suchpfade zu finden, muss der komplette Pfad eingetragen werden.

Man kann natürlich die Original-Zeile anpassen. Ich persönlich schreibe alle meine Modifikationen lieber an den Schluss der Datei. Damit kann man die Anpassungen einfacher zusammen halten. Hierbei wird ausgenutzt, das eine spätere Re-Definitionen des gleichen Tags die vorhergehende überschreibt.

 

Ergänzung (7.1.2016):

Um VBTermie dazu zu veranlassen, den Port bei Benutzung der Arduino-IDE oder bei Add-On Visual Micro freizugeben, muss man wie nachfolgend am Bespiel für das Board "Generic ESP8266" beschrieben vorgehen.

Seit der Arduino Version 1.5.3 kann man den Build-Vorgang stark beeinflussen. Siehe hierzu

Das Programm esptool.exe, das u.a. zum Upload des kompilierten Programm genutzt wird, findet man im Verzeichnis <user>\AppData\Local\Arduino15\packages\esp8266\tools\esptool\0.4.6 (wenn nicht dort, muss man suchen). Im gleichen Verzeichnis legt man eine Batch-Datei an. Sinnvollerweise unter dem Name "esptool.cmd". Die Datei hat folgenden Inhalt:

@echo off
echo redirected esptool
 
VbTermie DISCONNECT THROW
Sleep 1
%0\..\esptool.exe %*
set EL=%ERRORLEVEL%
VbTermie RECONNECT THROW
exit %EL%

"%0\..\" bewirkt, dass esptool.exe im gleichen Verzeichnis gesucht wird, unter dem die cmd-Datei aufgerufen wurde.

Nun muss noch die Datei platform.txt angepasst werden. Diese findet man im Verzeichnis <user>\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.0.0. In der Zeile "tools.esptool.cmd.windows=esptool.exe" ist "exe" durch "cmd" zu ersetzen (=> "tools.esptool.cmd.windows=esptool.cmd"). Dies bewirkt, dass zum Upload die oben erstellte Batch-Datei verwandt wird.

Achtung: esptool.exe taucht zweimal auf. Die Ersetzung muss an der richtigen Stelle geschehen!

Der Upload per avrdude kann analog angepasst werden:

In der Datei "...\Arduino\hardware\arduino\avr" muss in der Datei "platform.txt" die Zeile

tools.avrdude.cmd.path={path}/bin/avrdude

geändert werden in

tools.avrdude.cmd.path={path}/bin/avrdude.cmd

Im Verzeichnis "...\Arduino\hardware\tools\avr\bin" wird die Textdatei "avrdude.cmd" mit folgendem Inhalt angelegt:

@echo off 
echo redirected avrdude
VbTermie DISCONNECT THROW 
Sleep 1 
%0\..\avrdude.exe %*
set EL=%ERRORLEVEL%
VbTermie RECONNECT THROW
exit %EL%

Reload des ToolChains nicht vergessen: Tools->Visual Micro->Reload Toolchains.

Eine ausführliche Seite zum Umgang mit Windows-Batch-Scripten ist die von steve jansen.

Projekt-Vorlage erstellen

Ein Projektvorlage (Template) ist ein ZIP-Archiv mit einer Reihe von Vorlagen und Steuerdateien. Dank der Exportfunktion der Atmel Studio ist die Erstellung einer Vorlage verhältnismäßig einfach. Man öffnet ein bestehendes Projekt, hier ArduinoBlink, und wählt den Menüpunkt Datei => Vorlage exportieren. Daraufhin öffnet sich ein Fenster mit dem die Vorlage ein wenig angepasst werden kann. Zunächst wird der Vorlagentyp Projektvorlage ausgewählt. Im nächsten Fenster wird der Vorlagenname festgelegt: "Arduino Uno C++ Executable". Die restlichen Felder sind optional. Bei Vorlagenbeschreibung trägt man "Creates an Arduino Uno project" o.ä. ein. Weiterhin kann man ein Symbolbild und ein Vorschaubild einfügen. A diesen Stellen erscheinen die genannten Dinge dann bei der Anlage eines neuen Projekts im Amel Studio.

Projektvorlage

Die beiden Checkboxen am unteren Ende des Vorlagen-Export-Fensters lässt man sinnvoller Weise angehakt. Klickt man Fertig stellen, wird ein ZIP-Archiv mit den passenden Einstellungen erstellt. Einmal im aufgehenden Ordner ...\Documents\Atmel Studio\My Exported Templates (dort kann die Datei gleich wieder gelöscht werden) und im Verzeichnis ...\Documents\Atmel Studio\Templates.

 Beim Anlegen eines neuen Projekts schaut das Atmel Studio in den Ordner ...\Documents\Atmel Studio\Templates. Findet es dort ein ZIP-Archiv mit passenden Inhalten, erscheint der zugehörige Eintrag zur Auswahl bei der Anlage eines neuen Projekts. Das ganze ist aber noch nicht wirklich schön und sollte angepasst werden. Unnötige Dinge können entfernt und unpassende modifiziert werden. Vorlagen, in denen man nachschauen kann, findet man u.a. im Templates-Verzeichnis des Atmel Studio Programmverzeichnis

..\Atmel\Atmel Studio 6.1\extensions\Atmel\AtmelToolchainProvider\6.1.0.447\~PC\ProjectTemplates\CandCPP.

Weitere Hinweise zu den einzelnen Inhalten der Vorlagen findet man in der Microsoft-Dokumentation Visual Studio-Vorlagen. Ich habe mein Vorlage ein wenig über try & error angepasst.

Für jedes Board muss eine eigene Vorlage erstellt werden. Controller-Typ und eingebundene Bibliothek sind board-spezifisch. Die Vorlage kann im Download unter ArduinoTemplate herunter geladen werden.

System an andere Boards anpassen

Im folgenden wird beschrieben, wie man das System um einen Arduino Leonardo erweitern kann.

Am besten ist es, zunächst einmal ein beliebiges Programm mit der passenden Board-Einstellung in der Arduino-IDE zu übersetzen. Das Übersetzungsprotokoll liefert wieder wertvolle Hinweise:

Bibliothek erstellen

Als erstes muss die Basis-Bibliothek erstellt werden. Dazu wird im Projektmappenverzeichnis ArduinoCore der Order ArduinoCoreUno dupliziert. Der neue Ordner erhält den Namen ArduinoCoreLeonardo. Die darin enthaltene Projektdatei wird in ArduinoCoreLeonardo.cppproj umbenannt.

Die Solution zur Bibliothekserstellung wird nun mit dem Atmel Studio geöffnet. Es wird das neu erstellte Projekt hinzugefügt: Datei => Hinzufügen => Vorhandenes Projekt. In dem hinzugefügten Projekt werden nun die notwendigen Anpassungen der Projekteigenschaften vorgenommen.

 Nun kann die Projektmappe neu erstellt werden. Die entstanden Bibliotheken aus den Release-Verzeichnissen werden nach ArduinoSupport\lib kopiert. Die Projektmappe ArduinoCore im Download enthält Bibliotheks-Projekte für beide Arduino-Typen und zusätzlich Dateien für den Arduino Uno Turbo.

Wie bereits oben angemerkt, wurden die Warnungen für Arduino Leonardo nicht bearbeitet. Hier sind die Quellen noch im Original.

Projektvorlage erstellen

Bei der Anpassung der Projektvorlage geht man ähnlich vor. Das ZIP-Archiv wird dupliziert und das Duplikat erhält den Namen ArduinoLeonardo.zip.

Am besten entpackt man das Projekt in einen eigenen Ordner. Überall -sowohl in den Dateinamen als auch in den Dateiinhalten wird "Uno" durch "Leonardo" ersetzt. Auch das Vorschaubild sollte ausgetauscht werden.

In der Projektvorlage ArduinoLeonardo.cppproj müssen weitere Änderungen gemacht werden:

Die Dateien wieder in das ZIP-Archiv packen und die verbliebenen überflüssigen "Uno"-Dateien löschen. Das Archiv ArduinoTemplate im Download enthält Vorlagen für beide Arduino-Typen und zusätzlich Dateien für den Arduino Uno Turbo.

Uploader-Befehl einrichten

Es muss ein neuer Uploader-Befehl analog zum obigen Vorgehen eingerichtet werden. Es ändert sich: