Update 2015-06-14: Was geht II?

Seit neuestem (Januar 2014) bin ich stolzer Besitzer eines Arduino Uno R3.

Warum Arduino? Einfaches Prototyping/Ausprobieren. Das Ding ist normiert (Hardware: Schaltung und Abmessungen), (Software: Firmware, Compiler). Es gibt eine nahezu unendliche Anzahl von Zubehör.

Warum Uno? Basisversion verspricht höchste Kompatibilität.

Warum R3? Dies ist einfach die neuste Version.

Erste Eindrücke:

Arduino an USB => einige LEDs blinken. Das ist das vorinstallierte Testprogramm. Windows richtet einen neuen Com-Port ein.

Installation der IDE ist problemlos.

Testprogramm kompiliert und hochgeladen: funktioniert problemlos.

Dann erst einmal die Einstellungen (Datei-Menü/Einstellungen) überprüfen: Bis auf "Externen Editor benutzen" sollten alle Häkchen gesetzt sein.

Pro & Cons

+ Große Anzahl Beispiele
+ Unendliche Anzahl von Programme im Netz
+ Viel Hardware-Zubehör (Shields)
+ Viele Hardware-Hersteller liefern Beispiele bzw. Treiber für Arduino
+ Programmierung über Bootloader per USB oder ISP.
+ Atmel Studio kann genutzt werden (Anleitung zur Einrichtung).
- Compiler meldet nur den Gesamtspeicherbedarf im Flash. RAM-Bedarf wird nicht angezeigt.
- Es gibt mittlerweile viele Arduino-Varianten, die nicht alle 100% kompatibel sind. Z.T. müssen Programme angepasst werden.
- In den Kompilier-Vorgang kann nicht eingegriffen werden, um z.B. besondere Konstellationen zu berücksichtigen.
- Löscht das Temp-Verzeichnis nicht.
- Die Dokumentation ist nur teilweise in deutsch. Viele Links führen auf englische Artikel.
- Die Präzision der Dokumentation ist teilweise nicht sehr gut. Dies ist wohl der Tatsache geschuldet, dass auch unerfahrene Entwickler Programme entwerfen sollen. Auch fehlt ein übersichtliches Klassenmodell.
- Die Implementierung mancher Typen / Methoden kann zu unvorhergesehenen Seiteneffekten führen:
- · Die Datentypen werden nicht einheitlich gebraucht. Z.B. wird uint8_t und unsigned char gemischt gebraucht. Dies ist aber nur so lange gleichwertig, wie typedef unsigned char uint8_t gilt. In Umgebungen in denen ein Zeichen zwei Byte belegt (Unicode) gilt das nicht mehr unbedingt.
- · Es werden Parameter vom Typ int, d.h. 16 Bit mit Vorzeichen, an Methoden weitergereicht, deren Parameter als uint8_t, d.h. 8 Bit ohne Vorzeichen, deklariert werden. Z.B. bei der Implementierung von Print::print(unsigned long n, int base) ⇒ Print::printNumber(unsigned long n, uint8_t base).
- · Die Prüfung der Parameter ist nicht sauber und nicht einheitlich.
       size_t Print::print(unsigned long n, int base)
       { if (base == 0) ...
  Mögliche negative Werte werden nicht abgeprüft. An einer späteren Stelle erfolgt dann
         if (base < 2) ...
- Es werden viele der µC-Ressourcen genutzt und entsprechend vorbelegt. Die Ressourcen-Nutzung ist nicht dokumentiert. Das gibt häufig Probleme, wenn man Nicht-Arduino-Funktionen nutzen möchte.
- Die Arduino-IDE und auch der Arduino Bootloader unterstütz keine vorbelegten EEPROM-Variablen. Eine .eep-Datei kann mit dem Bootloader nicht übertragen werden.

C++

Im Gegensatz zu den sonst im Embedded-Bereich üblichen Programmierung in C werden Arduino-Programme üblicherweise in C++ geschrieben. Dies hat Konsequenzen. Es gibt eine Reihe von Artikeln die, dieses Thema diskutieren:

Zusammenfassend kann man sagen:

+ Performance ist kein Problem, wenn entsprechend sorgfältig programmiert wird.
+ Strenge Typenprüfung bewirkt, dass viele Fehler bereits während der Kompilierung entdeckt werden und nicht erst zur Laufzeit.
+ Kapselung der Daten und Überladung der Methoden ermöglicht übersichtliche Programme.
- Es wird ein nicht unerheblicher Overhead erzeugt, wenn C++-Features unnötigerweise genutzt werden. Obacht ist bei der Nutzung der folgenden Funktionalitäten geboten:
- • Virtuelle Funktionen
- • new / free
- • Copy-Constructor
- Werden Member-Funktionen aufgerufen, wird jedes Mal ein Zeiger auf das entsprechende Objekt zusätzlich als erster Parameter an die Funktion übergeben. Der Zugriff auf Member-Felder erfolgt indirekt über diesen Zeiger. Wird von einer Klasse nur ein Objekt instanziiert, ist es effektiver mit globalen Funktionen zu arbeiten.