Geekly articles weekly

Arduino unter Linux: Konfigurieren von Qt Creator als Entwicklungsumgebung

Die Arduino-Plattform ist beliebt, unabhängig davon, ob sie gescholten oder gelobt wird. Seine Schöpfer haben es geschafft, die Eintrittsschwelle auf ein paar Mausklicks + ein paar Zeilen Code und Voila zu senken - hier haben Sie eine blinkende LED. Und im Allgemeinen ist das Arduino-Ding für das Rapid Prototyping von Handwerken auf AVR äußerst praktisch. Das einzige, was fehlschlug, war die IDE, die von der IDE nur schwer aufgerufen werden kann. Unter den Funktionen der IDE bietet sie nur eines - die Automatisierung der Erstellung und Montage eines Projekts.

Für Windows-Benutzer gibt es eine Alternative: MS Visual Studio Community + vMicro- Plugin, mit dem Sie Skizzen schreiben können, jedoch mit allen von der IDE bereitgestellten Extras . Das Plug-In schwingt problemlos im Studio selbst über das Menü "Extras" und funktioniert in der Testversion so oft, wie Sie möchten. Die kostenpflichtige Version unterstützt theoretisch das schrittweise Debuggen, war jedoch als Eigentümer der lizenzierten Kopie von vMicro nicht sehr beeindruckt.

Für Linux-Benutzer ist alles wie immer: Wir wollen eine gute IDE - wählen Sie das „Opfer“ aus und versuchen Sie, die erforderlichen Funktionen daran zu befestigen. Es gibt Lösungen, die auf Eclipse basieren, aber ich mag Eclipse nicht, über das ich bereits einmal geschrieben habe . Ich ertrage ihn als unvermeidliches Übel, wenn überhaupt nichts Passendes zur Hand ist. Von allen kostenlosen IDEs respektiere ich am meisten den mächtigen und wunderbaren Qt Creator , in dem ich und mein Team seit mehr als einem Jahr arbeiten. Daher werde ich darüber sprechen, wie man daraus eine Entwicklungsumgebung für Arduino macht.

1. Bodenvorbereitung


Qt Creator ist in den Repositorys jeder mehr oder weniger selbstbewussten Linux-Distribution verfügbar. Zum Beispiel in Archa bekommen Sie es so

$ sudo pacman -S qtcreator

Außerdem benötigen wir Pakete zum Arduino selbst.

 $ sudo pacman -S arduino arduino-avr-core

An dem Tag, an dem wir Arduino endlich vergessen, werden wir einen weiteren Compiler, Assembler, Linker und eine Standard-C-Bibliothek für AVR benötigen, also setzen wir sie ein

 $ sudo pacman -S avr-gcc avr-binutils avr-libc

Wir werden den Debugger und den Emulator in diesem Artikel testen, also werden wir solche Pakete installieren

 $ sudo pacman -S avr-gdb simavr

2. Erstellen Sie ein Projekt in Qt Creator


Führen Sie Qt Creator aus und erstellen Sie ein neues Projekt ohne Qt in C ++



Wählen Sie einen Ort für das Projekt und geben Sie ihm einen Namen



Nehmen Sie als Build-System ein regelmäßiges qmake



Wir belassen den Arbeitssatz standardmäßig und beheben ihn später



Fügen Sie unter Versionskontrolle das Projekt wie gewünscht hinzu



Wir bekommen das Standard C ++ Projekt



Das Projekt enthält nur zwei Dateien: main.cpp und led-blink.pro. Der erste wird gelöscht, der zweite wird von allem gelöscht, was dort geschrieben steht, und es wird ein vollständig leeres Projekt erstellt



Jetzt beginnen wir mit Stiften, Text in eine * .pro-Datei zu schreiben, die die Projektstruktur für Arduino bildet

 #     #    Arduino Core ARDUINO_DIR=/usr/share/arduino/hardware/archlinux-arduino/avr/ #    (Arduino Uno, Nano, Mini) ARDUINO_MCU=atmega328p #    ARDUINO_FCPU = 16000000L

Wir schließen alles, was mit Qt zu tun hat, aus dem Projekt aus und wählen die Projektvorlage aus

 #  ,   Qt   ! QT -= gui core CONFIG -= qt #   - ,      ELF TEMPLATE = app

Wir legen das Verzeichnis für die zusammengestellte Binärdatei und ihren Namen fest

 DESTDIR = ../bin TARGET = led-blink

Verbinden Sie als Nächstes die Header-Suchverzeichnisse

 #    INCLUDEPATH += $$ARDUINO_DIR/cores/arduino INCLUDEPATH += $$ARDUINO_DIR/variants/standard INCLUDEPATH += $$ARDUINO_DIR/libraries INCLUDEPATH += /usr/avr/include

Definieren Sie den C-Compiler und seine Schlüssel

 QMAKE_CC = /usr/bin/avr-gcc QMAKE_CFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections QMAKE_CFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU QMAKE_CFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR

und der C ++ - Compiler und seine Schlüssel

 QMAKE_CXX = /usr/bin/avr-g++ QMAKE_CXXFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections QMAKE_CXXFLAGS += -fno-exceptions -fno-threadsafe-statics QMAKE_CXXFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU QMAKE_CXXFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR

Setzen Sie den Linker und seine Schlüssel

 QMAKE_LINK = /usr/bin/avr-gcc QMAKE_LFLAGS = -w -Os -Wl,--gc-sections -mmcu=$$ARDUINO_MCU QMAKE_LIBS = -lm

Wir konfigurieren die Nachbearbeitung der ELF-Datei, um sie für die nachfolgende Firmware auf der Karte in Intel HEX umzuwandeln

 QMAKE_POST_LINK += /usr/bin/avr-objcopy -O ihex -j .text -j .data -S ${TARGET} ${TARGET}.hex

Geben Sie an, welche Header-Dateien im Projekt enthalten sind.

 HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h)

Definieren Sie Arduino Core-Quelldateien

 SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp)

Also, wann werden wir tatsächlich mit dem Skizzieren beginnen? Fangen wir jetzt an, aber was wir getan haben, edle Dons, ist das notwendige Minimum, damit der Skizzencode funktioniert.

Fügen Sie nun die Skizzenquelle zum Projekt hinzu. Klicken Sie mit der rechten Maustaste auf das Projekt in der Baumstruktur und wählen Sie "Neu hinzufügen ...". Fügen Sie die C ++ - Quelldatei hinzu



So organisieren Sie die Quellen innerhalb des Projekts im nächsten Fenster



Klicken Sie auf "Durchsuchen" und erstellen Sie den src-Ordner für * .cpp-Dateien



Geben Sie der Datei nun einen Namen



Klicken Sie auf das nächste Fenster "Fertig stellen". Wir bekommen so ein Bild



Die IDE fügt diese Datei dem Build-Skript led-blink.pro hinzu

 HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h) #  Arduino Core SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) \ src/led-blink.cpp SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp)

Aber um keine langen Quellenlisten zu erstellen, mag ich das normalerweise

 #  Arduino Core HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h) HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h) #  Arduino Core SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c) SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp) #   SOURCES += $$files(./src/*.cpp)

Jetzt werden wir das tun, was die Arduino-IDE niemals bereitstellen wird: Fügen Sie der Skizze eine Header-Datei hinzu, und führen Sie dabei die gleichen Schritte wie oben aus



Fügen Sie in dieser Datei die erforderlichen Header für das Projekt hinzu.

 #ifndef LED_BLINK_H #define LED_BLINK_H #include <Arduino.h> #endif // LED_BLINK_H

Konfigurieren Sie die Pfade zu den Headern und Quellen

 #  INCLUDEPATH += ./include HEADERS += $$files(./include/*.h) #   SOURCES += $$files(./src/*.cpp)

und jetzt endlich eine skizze schreiben

 #include "led-blink.h" //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void setup() { } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void loop() { }

Jetzt klicken wir mit der rechten Maustaste auf den Projektbaum und wählen "Zusammenstellen".



Wir gehen zum Projektordner. Wir haben jetzt das Verzeichnis bin /, das die Compiler-Arbeitsprodukte enthält



Alles ist in Ordnung, es gibt ELF, was beim Debuggen und Hex für Firmware im Controller nützlich ist. Schreiben wir nun einen weiteren Blinker mit LED an Pin 13

 #include "led-blink.h" #define LED_STAND_PIN 13 unsigned long time = 0; unsigned long DELAY = 500000; bool on = false; //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void setup() { pinMode(LED_STAND_PIN, OUTPUT); } //------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ void loop() { if ( micros() >= time + DELAY ) { time = micros(); on = !on; } uint8_t state = on ? HIGH : LOW; digitalWrite(LED_STAND_PIN, state); }

Wir sammeln das Projekt, gehen zu bin /. Wir stecken in Ihrem USB-Board. In meinem Fall ist es Uno, auf meinem System wird ein Port mit dem Namen / dev / ttyACM0 für die Programmierung eingerichtet. Führen Sie den Befehl aus

 $ avrdude -c arduino -p m328p -P /dev/ttyACM0 -b 115200 -U flash:w:led-blink.hex:i

Hier

  • -P / dev / ttyACM0 - Programmiererport
  • -p m328p - Controller-Modell
  • -c arduino - Programmierertyp: in die Uno-Karte integriert
  • -b 115200 - Portgeschwindigkeit
  • -U flash: w: led-blink.hex: i - Geben Sie den Bereich der Firmware, die Art des Vorgangs (Schreiben) und die Firmware-Datei an

Ein ähnlicher Auspuff

 avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.00s avrdude: Device signature = 0x1e950f (probably m328p) avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed To disable this feature, specify the -D option. avrdude: erasing chip avrdude: reading input file "led-blink.hex" avrdude: writing flash (2838 bytes): Writing | ################################################## | 100% 0.47s avrdude: 2838 bytes of flash written avrdude: verifying flash memory against led-blink.hex: avrdude: load data flash data from input file led-blink.hex: avrdude: input file led-blink.hex contains 2838 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 0.38s avrdude: verifying ... avrdude: 2838 bytes of flash verified avrdude: safemode: Fuses OK (E:00, H:00, L:00) avrdude done. Thank you.

sagt uns, dass der Prozess gut gelaufen ist. Die LED blinkt mit einer Frequenz von 2 Hz.

Grundsätzlich können Sie die Firmware in der IDE konfigurieren. Nehmen Sie dazu die Starteinstellungen wie z



Wenn Sie das Projekt starten (durch Drücken von Strg + R), führen wir die Firmware aus und starten sie genauso wie die Arduino IDE.

Schlussfolgerungen


Der beschriebene Einrichtungsprozess ist ziemlich zeitaufwändig. Im Gegenzug erhalten wir jedoch die volle Leistung einer der bemerkenswertesten IDEs, die auf Systemen existieren, die auf dem Linux-Kernel basieren (und Windows gilt auch). Autodescription, Refactoring, bequeme Code-Navigation - all dies kann jetzt erfolgreich genutzt werden.

Dieses Beispiel wird, wie sie sagen, "in die Stirn" gemacht. Tatsächlich kompiliert die Arduino IDE den Arduino Core in eine separate statische core.a-Bibliothek und verknüpft sie mit der ausführbaren Datei. Infolgedessen ist die in der Standardumgebung gesammelte Firmware kleiner als bei der im Artikel beschriebenen Methode. Ich muss diese Nuancen noch herausfinden. Gleichzeitig werden wir im folgenden Artikel zu diesem Thema darüber sprechen:

  • Finden Sie in der Struktur des Projekts heraus, wo sich die main () - Funktion befindet, und zeigen Sie, warum übermäßige Schleifen auf dem Arduino schlecht sind
  • Schritt-für-Schritt-Debugging mit Emulatoren
  • Wir werden uns mit den in der Assembly verwendeten Compileroptionen befassen

Im Allgemeinen werden wir versuchen, viele Probleme zu klären, die für das Verständnis der laufenden Prozesse nützlich sind, ohne die es in Zukunft schwierig sein wird, von Arduino auf etwas Fortgeschritteneres umzusteigen.

Source: https://habr.com/ru/post/de408261/

More articles:


All Articles