Ich habe lange nach einer guten Antwort auf diese Frage gesucht.

In der Regel umfasst jedes Arduino-Projekt, außer dem einfachsten, Folgendes:

• Die Hauptquellcode-Datei MyProject.ino
• Projektspezifische Bibliotheken ( MyProjectLibrary1.h, MyProjectLibrary1.cpp...)
• Bibliotheken von Drittanbietern (im Allgemeinen kostenlos, Open Source, manuell zum Arduino-Bibliotheksverzeichnis hinzugefügt)
• Schaltpläne, PCB-Diagramme
• Dokumentation
• ...

All dies macht es schwierig, den gesamten Code und das Dokument eines Projekts unter Quellcodeverwaltung zu halten (z. B. auf Subversion, Git oder GitHub).

Die Verwaltung der Quellcodeverwaltung Ihres Projekts umfasst die Verwaltung der Version aller vom Projekt verwendeten Dateien, einschließlich der Bibliotheken von Drittanbietern.

Jetzt muss ich für ein einzelnes Projekt eine Verzeichnisstruktur definieren, die:

• Schließt alle Projektdateien wie oben beschrieben ein
• Ich kann mich vollständig auf ein Quellcode-Management-Tool festlegen (einschließlich Abhängigkeiten von Drittanbietern)
• Ich kann überall auf meiner Festplatte auschecken und das Projekt von dort aus erstellen (muss es ein einzelner Speicherort sein, wie von Arduino IDE vorgeschrieben)
• Ich kann in ein eigenständiges Archiv zipgen, das ich einem Freund senden kann, damit er es so einfach wie möglich erstellt (kein zusätzlicher manueller Download).

Was ich bei Arduino-Projekten besonders schwierig finde, ist die Verwaltung der Abhängigkeiten externer Bibliotheken. Java-Projektentwickler haben dafür Maven- Repositorys, die bei der Verwaltung aller externen Deps sehr hilfreich sind. Wir haben jedoch kein gleichwertiges System für Arduino-Bibliotheken.

Es würde mich interessieren, wie andere Arduino-Projekthersteller in ihren eigenen Projekten mit diesen Aspekten umgehen.

Beachten Sie auch, dass ich bereit bin, meinen Entwicklungsprozess, einschließlich meiner IDE, zu ändern (derzeit verwende ich Eclipse die meiste Zeit mit dem Arduino-Plugin und stelle dann sicher, dass meine Projekte auch direkt mit der Arduino-IDE funktionieren).

Meine Art, ein Arduino-Projekt zu organisieren, ist recht einfach. Alle meine Projekte sind Git-Repositorys, sodass es mindestens Folgendes gibt:

• Projekt/
  • project.ino
  • Makefile

Ich bevorzuge es, meinen Lieblingseditor und ein Makefile zu verwenden, das ich für die meisten Anwendungsfälle entwickelt habe (und ich habe sogar das verbessert, das ich bald teilen werde).

Für die Bibliotheken bevorzuge ich es, sie als eigene Repositorys zu behalten und sie mit dem Git-Submodul in das Projekt einzubinden. Da viele von der Community geschriebene Bibliotheken als Git-Repositorys gemeinsam genutzt werden, ist dies eine gute generische Lösung. Dann muss ich im Makefile nur den Bibliothekspfad hinzufügen, den ich in die Variable LOCALLIBS aufnehmen möchte .

Obwohl es für einige Projekte sinnvoll ist, die Bibliotheken in eine für das Projekt erstellte Hardwareabstraktionsebenenbibliothek zu kapseln, bevorzuge ich die Verwendung eines Pfads wie:

• project
  • project.ino
  • Makefile
  • project_hal_lib
    • library1
    • library2
    • library3
    • …

Obwohl mit arduino 1.5.x eine neue Möglichkeit zum Spezifizieren von Bibliotheken angeboten wird, bietet diese Möglichkeit die gleiche Möglichkeit zum Erstellen und Erstellen von Arduino-Projekten wie bei Pipy und Virtualenv in Python, dh Sie definieren die von Ihnen benötigten Bibliotheken und diese heruntergeladen werden.

Der einfachste Weg, dies zu tun, besteht darin, die Header- und Codedateien der Bibliothek in Ihr Quellverzeichnis zu kopieren und sie einzuschließen.

myproject/
    myproject.ino
    somelib.h
    somelib.cpp

In Ihrem Code können Sie tun include "somelib.h"

Der Nachteil dabei ist, dass sich die Bibliotheken im selben Ordner und nicht in Unterordnern befinden müssen, sodass Ihr Verzeichnis chaotisch aussieht.

In Bezug auf die Verzeichnisstruktur meines gesamten Projekts, einschließlich Schaltplänen und Dokumentation, sieht meins normalerweise so aus:

myproject/
  schematics/ - eagle files or whatever you may have
  docs/       - include relevant datasheets here
  test/       - any test cases or other code to test parts of the system.
  myproject/  - since Arduino code must be in a directory of the same name
    myproject.ino
    ...

Git-Submodule sind äußerst leistungsstark, wenn es darum geht, mehrere verschachtelte Repositorys zu organisieren. Der Umgang mit mehreren Bibliotheken aus verschiedenen Quellen und sogar der Umgang mit Teilen Ihres eigenen Projekts, die möglicherweise in verschiedenen Quellen gespeichert sind, wird mit Git-Submodulen einfacher.

Verzeichnisaufbau

Eine Möglichkeit, Ihre Projekte zu organisieren, wäre:

• projectA - Elternverzeichnis

  • projectA - Quellcodeverzeichnis mit Arduino-Code

    1. projectA.ino
    2. header.h
    3. Implementation.cpp

  • docs - Ihr Hauptdokumentationsverzeichnis

  • Schaltpläne - Diese können separat auf einem separaten Git-Repo oder einem Teil desselben Repos verwaltet werden

  • libs - Dies wird Ihre Bibliotheken von Drittanbietern enthalten.

    1. libA - Diese können als Drittanbieter-Repositorys verwaltet werden
    2. libC - ...

  • Lizenz

  • Liesmich

  • Makefile - Erforderlich, um Abhängigkeiten zwischen Verzeichnissen zu behandeln

Arbeitsablauf

Sie folgen Ihrem normalen Zyklus, indem Sie Änderungen vornehmen, hinzufügen und festschreiben, was das Haupt-Repository betrifft. Interessant wird es bei den Sub-Repositories.

Sie haben die Möglichkeit, ein Repository in das übergeordnete Verzeichnis Ihres Hauptrepositorys einzufügen. Dies bedeutet, dass jeder Teil Ihrer Verzeichnisstruktur, dh Dokumente, Schaltpläne usw., als separates Repository verwaltet und fortlaufend aktualisiert werden kann.

Sie können dies mit dem git submodule add <repo.git>Befehl tun . Um es auf dem neuesten Stand zu halten, können Sie verwenden git submodule update <path>.

Wenn es darum geht, mehrere Bibliotheken von Drittanbietern in Ihrem Repository so zu verwalten, dass jede für sich versioniert oder bei Bedarf auf dem neuesten Stand gehalten werden kann, spart git submodule erneut Ihren Tag!

Verwenden Sie den Befehl, um ein Drittanbieter-Repo zu libs hinzuzufügen git submodule add <lib1.git> libs/lib1. Um die Bibliothek an einem festen Punkt im Release-Zyklus zu halten, checken Sie die Bibliothek aus und führen Sie ein Commit durch. Verwenden Sie den Befehl, um die Bibliothek auf dem neuesten Stand zu halten git submodule update <path>.

Jetzt können Sie mehrere Repositorys in einem Hauptrepository sowie mehrere Bibliotheken von Drittanbietern in ihren unabhängigen Release-Phasen verwalten.

Versus Single Directory-Ansatz

Während der Ansatz mit einem einzelnen Verzeichnis der einfachste ist, ist es nicht möglich, Teile eines Verzeichnisses ohne großen Aufwand einer Versionskontrolle zu unterziehen. Daher kann der einfache Ansatz keine unterschiedlichen Repositorys mit unterschiedlichen Status im Projekt berücksichtigen.

Dieser Ansatz ermöglicht die Verwaltung mehrerer Repositorys, erfordert jedoch ein Makefile, um den Kompilierungs- und Verknüpfungsprozess zu verwalten.

Abhängig von der Komplexität Ihres Projekts kann der optimale Ansatz ausgewählt werden.

Hier ist der Weg, den ich für meine Projekte beschloss.

Arduino-CMake

Die erste wichtige Entscheidung, die ich getroffen habe, war die Wahl eines Build-Tools, das für meine Umgebung (Windows) geeignet ist, aber nicht darauf beschränkt ist (ich möchte, dass meine Projekte von anderen Personen problemlos wiederverwendet werden können).

Ich habe verschiedene Open Source Arduino make tools getestet:

• Guyzmo-Makefile (vorgeschlagen von @zmo answer): Dies ist nur ein handgefertigtes Standard-Makefile für Arduino-Builds. Dies ist ein Unix-Makefile, aber es gibt eine gute Portierung von Unix make für Windows . Leider funktioniert dieses Makefile nur unter Unix. Natürlich könnte es für Windows angepasst werden, aber ich wollte ein Tool, das "out of the box" funktioniert.
• Arduino-Makefile (vorgeschlagen von @adnues answer): Dies ist ein fortgeschritteneres Projekt, das auf Unix-Makefile basiert und auf einfache Weise von allen Arduino-Projekten wiederverwendet werden soll. Es ist dokumentiert, dass es auf Mac, Linux und Windows funktioniert, aber die Windows-Unterstützung hat sich in meinen ersten Experimenten als falsch erwiesen (viele Abhängigkeiten von der Unix-Shell).
• Graduino (von keiner Antwort vorgeschlagen): Dieses Build-Tool basiert auf dem bekannten Gradle- Build-Tool aus der Groovy- Welt. Das Tool scheint recht gut gemacht zu sein, erfordert jedoch ein (kleines) Wissen über Groovy / Gradle und verfügt nur über eine geringe Dokumentation. Ich habe mich entschieden, es nicht zu tun, weil ich groovy und gradle nur dafür installiert habe (ich möchte Leuten, die meine Projekte auf ihre Umgebung aufbauen wollen, zu viele Voraussetzungen ersparen).
• Arduino-CMake (von keiner Antwort vorgeschlagen): Dies scheint das Beste zu sein, es hat eine lange Geschichte, hat viele Unterstützer und Betreuer, ist sehr gut dokumentiert, kommt mit einfachen Beispielen und hat auch ein paar gute Tutorial-Blog-Beiträge auf Web, zB hier und da . Es basiert auf CMake , einem "Cross-Platform Make".

Ich habe auch ArduinoDevel gefunden , ein anderes Arduino-Build-Tool, mit dem ich nicht experimentiert habe. Es kann Unix-Makefiles oder Ant- build.xml Dateien generieren . das wirkte interessant, aber funktional etwas eingeschränkt.

Schließlich habe ich mich für Arduino-CMake entschieden :

• Es war einfach einzurichten: Installieren Sie einfach CMake auf Ihrem Computer und kopieren Sie Arduino-CMake in ein Verzeichnis, auf das Sie (über relative Pfade) aus Ihren Projektverzeichnissen leicht zugreifen können.
• Die Beispiele haben sich für mich sofort bewährt (ich habe nur die Kommentare in der CMakeLists.txtKonfigurationsdatei befolgt , um die für meine Umgebung erforderlichen Eigenschaften anzupassen, z. B. Arduino-Typ, serielle Schnittstelle).
• Sie können Ihre Projekte nach Belieben organisieren
• Es kann Konfigurationsdateien für verschiedene Build-Tools generieren (ich habe allerdings nur Unix Makefiles getestet ), einschließlich Eclipse- Projekte.

• In der generierten Marke werden mehrere Ziele erstellt, um Folgendes zu unterstützen:

  • Bibliotheken bauen
  • programme bauen
  • Programm auf Boards hochladen
  • serieller Monitor starten
  • und ein paar andere habe ich noch nicht getestet

Projektstruktur

Da Arduono-CMake Ihrem Projekt keine Verzeichnisstruktur auferlegt, können Sie diejenige auswählen, die am besten zu Ihnen passt.

Folgendes habe ich persönlich gemacht (das muss noch verfeinert werden, aber jetzt bin ich damit zufrieden):

Ich habe beschlossen, alle meine Projekte in einem gemeinsamen arduino-stuffVerzeichnis abzulegen (das ich mich für github als Ganzes engagiere. Ich weiß, dass ich Git-Submodule für eine bessere Organisation von github verwenden kann, hatte aber noch keine Zeit, dies zu überprüfen.)

arduino-stuff hat folgenden Inhalt:

• build: das ist ein Verzeichnis, in dem cmake und make all ihre Sachen generieren (Makefiles, Cache, Objektdateien ...); Dieser wird nicht zum Github
• cmake: das ist nur eine Kopie (unverändert) des Arduino-CMake-cmake- Verzeichnisses. Dieser bekommt auf Github, so dass es einfacher für jemanden ist, der meine Projekte bauen möchte
• CMakeLists.txt: das ist die "globale" CMake-Konfiguration, die alle Standardeinstellungen für meine Umgebung (Karte, serielle Schnittstelle) und die Liste der Build-Ziel-Unterverzeichnisse deklariert
• TaskManager: Dies ist mein erstes Projekt basierend auf Arduino-CMake, dies ist eine Bibliothek mit Beispielen; Dieses Verzeichnis enthält auch ein CMakeLists.txt, das die Ziele für das Projekt angibt

Punkte zu verbessern

Die derzeitige Lösung ist jedoch nicht perfekt. Unter den Verbesserungen, die ich sehe (das ist eher für das Arduino-CMake-Projekt, um diese Verbesserungen einzuschließen, wenn sie es für richtig halten):

• Funktion zum Kopieren eines Bibliotheksverzeichnisses aus dem aktuellen Projekt in das Arduino-Bibliotheksverzeichnis
• Funktion zum Hochladen einer Bibliothek auf Github
• Funktion zum Herunterladen einer Bibliothek von Github

MyProject
|_MyProject
  |_MyProject.ino
  |_data
  |  |_documentation 
  |  |_PCB
  |  |_schematics
  |_src
     |_MyProjectLibrary1
     |_ThirdPartyLibrary

MyProject-Ordner (Repository-Stammverzeichnis)

Der Grund, warum ich den scheinbar redundanten MyProjectStammordner vorschlage, ist der, den Sie bei der Verwendung von GitHub erwähnt haben. Wenn Sie den Inhalt eines GitHub-Repository herunterladen (anstatt zu klonen), wird der Zweig- oder Tag-Name an den Repository-Namen angehängt (z. B.MyProject-master). Die Arduino IDE erfordert, dass der Name des Skizzenordners mit dem Namen der Skizzendatei übereinstimmt. Wenn Sie eine .ino-Datei öffnen, die sich in einem Ordner befindet, der nicht mit dem Skizzennamen übereinstimmt, fordert die Arduino IDE Sie auf, einen entsprechend benannten Skizzenordner zu erstellen und die Skizze in diesen Ordner zu verschieben. Das größere Problem ist, dass die Arduino IDE möglicherweise nicht alle anderen zugehörigen Dateien in den neu erstellten Ordner kopiert, was dazu führen kann, dass das Programm nicht mehr kompiliert wird. Indem Sie die Skizze in einen Unterordner legen, vermeiden Sie, dass GitHub den Namen des Skizzenordners ändert.

Wenn der GitHub-Dateiname für Sie kein Problem darstellt, ist der redundante Stammordner nicht erforderlich.

Datenordner

Ich empfehle, den dataUnterordner für Ihre Nicht-Code-Dateien zu verwenden, da die Arduino IDE eine spezielle Behandlung für Unterordner dieses Namens bietet. Sie werden an den neuen Speicherort kopiert, wenn Sie eine Datei> Speichern unter ... ausführen . Unterordner mit einem anderen Namen sind es nicht.

src ordner

Der srcUnterordner hat die besondere Eigenschaft, eine rekursive Kompilierung zu ermöglichen . Dies bedeutet, dass Sie die Bibliotheken in diesem Ordner belassen und sie wie folgt aus Ihrer Skizze einfügen können:

#include "src/MyProjectLibrary1/MyProjectLibrary1.h"
#include "src/ThirdPartyLibrary/ThirdPartyLibrary.h"

Die Ordnerstruktur im Arduino 1.5 Library-Format wird ebenfalls unterstützt. Sie müssen lediglich Ihre #includeAnweisungen entsprechend anpassen .

Beachten Sie, dass nur Arduino IDE 1.6.10 (Arduino Builder 1.3.19) und neuere Versionen die rekursive Skizzenkompilierung unterstützen.

Leider verwenden einige Bibliotheken die falsche #includeSyntax für lokale Datei-Includes (zB #include <ThirdPartyLibrary.h>anstelle von #include "ThirdPartyLibrary.h"). Dies funktioniert immer noch, wenn die Bibliothek in einem der Arduino- librariesOrdner installiert ist , jedoch nicht, wenn die Bibliothek mit der Skizze gebündelt ist. Daher erfordern einige Bibliotheken möglicherweise geringfügige Änderungen, um diese Methode zu verwenden.

Ich bevorzuge dies der Alternative, alle Bibliotheksdateien im Stammverzeichnis des Skizzenordners abzulegen, da dies chaotisch ist und jede Bibliotheksdatei in der Arduino IDE als Registerkarten angezeigt wird, wenn Sie die Skizze öffnen (natürlich alle Quelldateien, die Sie erstellen) in der Arduino-IDE editierbar sein möchten, sollte im Skizzenstammordner abgelegt werden).

Die Möglichkeit, gebündelte Bibliotheken zu verwenden, entspricht auch einem anderen Ihrer Ziele:

Sende es an einen Freund, damit er es so einfach wie möglich baut

Durch das Entfernen der Anforderung, Bibliotheken manuell zu installieren, wird die Verwendung des Projekts erheblich vereinfacht.

Auf diese Weise werden auch mögliche Konflikte mit anderen Versionen von Bibliotheksdateien mit demselben Namen vermieden, die möglicherweise zuvor installiert wurden.

Sie können das Makefile https://github.com/sudar/Arduino-Makefile zum Kompilieren von Arduino-Codes verwenden. Sie brauchen nicht unbedingt die IDE.

Wahrscheinlich sehr spät im Spiel, aber es ist eine Frage, die populär genug ist, um sie mit etwas anderen Methoden als den bereits veröffentlichten zu beantworten.

Wenn Sie die Kompatibilität mit Arduino IDE direkt aufrechterhalten müssen, können Sie etwas wie das hier beschriebene verwenden:

https://gitlab.com/mikealger/ExampleArduinoProjectStructure/tree/master/ExampleSketchBook

Ich habe das meiste davon aus den Notizen von Arduino - Projektstruktur und Erstellungsprozess und einigen Tipps abgeleitet, die ich im Laufe der Jahre gesammelt habe.

Ich weiß wirklich nicht, warum dies über Arduino-Seiten direkt so schwer zu finden ist. Es scheint albern, wenn man von einem semi-professionellen Hintergrund ausgeht, dass der Erstellungsprozess so stumpf ist.

Viel Glück da draußen