Geekly articles weekly

Arduino sous Linux: configuration de Qt Creator comme environnement de développement

La plate-forme Arduino est populaire, qu'elle soit grondée ou louée. Ses créateurs ont réussi à abaisser le seuil d'entrée au niveau de quelques clics de souris + quelques lignes de code et le tour est joué - vous avez ici une LED clignotante. Et en général, pour le prototypage rapide d'artisanat sur AVR, la chose Arduino est extrêmement pratique. La seule chose qu'ils ont échoué était l'IDE, que l'IDE est difficile à appeler. Parmi les fonctions de l'IDE, il ne fournit qu'une seule chose: l'automatisation de la création et de l'assemblage d'un projet.

Pour les utilisateurs de Windows, il existe une alternative: MS Visual Studio Community + plugin vMicro qui vous permet d'écrire des croquis, mais avec tous les goodies fournis par l'IDE. Le plug-in oscille sans problème dans le studio lui-même via le menu "Outils" et fonctionne autant que vous le souhaitez dans la version d'essai. La version payante prend en charge le débogage étape par étape, mais en tant que propriétaire de la copie sous licence de vMicro, ils n'ont pas été très impressionnés.

Pour les utilisateurs de Linux, tout est comme toujours: nous voulons un bon IDE - sélectionnez la «victime» et essayez d'y attacher les fonctionnalités nécessaires. Il existe des solutions basées sur Eclipse , mais je n'aime pas l'éclipse, dont j'ai déjà parlé une fois . Je le supporte comme un mal inévitable, quand il n'y a rien du tout à portée de main. De tous les IDE gratuits, je respecte le plus puissant et merveilleux Qt Creator , dans lequel moi et mon équipe travaillons depuis plus d'un an. Par conséquent, je vais parler de la façon de le transformer en un environnement de développement pour Arduino.

1. Préparation du sol


Qt Creator est disponible dans les référentiels de toute distribution Linux plus ou moins qui se respecte. Par exemple, dans archa, obtenez-le comme ceci

$ sudo pacman -S qtcreator

De plus, nous aurons besoin de packages concernant l'Arduino lui-même.

 $ sudo pacman -S arduino arduino-avr-core

Le jour où nous oublierons enfin Arduino, nous aurons besoin d'un autre compilateur, assembleur, éditeur de liens et bibliothèque C standard pour AVR, nous les mettons donc

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

Nous allons tester le débogueur et l'émulateur dans cet article, nous allons donc installer ces packages

 $ sudo pacman -S avr-gdb simavr

2. Créez un projet dans Qt Creator


Exécutez Qt Creator et créez un nouveau projet sans Qt en C ++



Choisissez un emplacement pour le projet et donnez-lui un nom



En tant que système de construction, prenez un qmake régulier



Nous quittons le jeu de travail par défaut, corrigeons-le plus tard



Sous contrôle de version, ajoutez le projet comme vous le souhaitez



Nous obtenons le projet C ++ standard



Il n'y a que deux fichiers dans le projet: main.cpp et led-blink.pro. Le premier est supprimé, le second est effacé de tout ce qui y est écrit, obtenant un projet complètement vide



Maintenant, avec les stylos, nous commençons à écrire du texte dans un fichier * .pro, formant la structure du projet pour Arduino

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

Nous excluons tout ce qui concerne Qt du projet et sélectionnons le modèle de projet

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

Nous définissons le répertoire du binaire assemblé et son nom

 DESTDIR = ../bin TARGET = led-blink

Ensuite, connectez les répertoires de recherche d'en-tête

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

Définir le compilateur C et ses clés

 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

et le compilateur C ++ et ses clés

 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

définir l'éditeur de liens et ses clés

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

Nous configurons le post-traitement du fichier ELF, afin de le tordre dans Intel HEX pour le firmware suivant sur la carte

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

Spécifiez les fichiers d'en-tête à inclure dans le projet.

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

Définir les fichiers source Arduino Core

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

Alors, quand allons-nous commencer à dessiner? Commençons maintenant, mais ce que nous avons fait, nobles dons, est le minimum nécessaire pour que le code d'esquisse fonctionne.

Ajoutez maintenant la source d'esquisse au projet. Faites un clic droit sur le projet dans l'arborescence et sélectionnez "Ajouter nouveau ..." Ajoutez le fichier source C ++



Pour organiser les sources à l'intérieur du projet, dans la fenêtre suivante



cliquez sur "Parcourir" et créez le dossier src pour les fichiers * .cpp



Donnez maintenant un nom au fichier



Cliquez sur la fenêtre suivante "Terminer". Nous obtenons une telle image



L'IDE ajoutera ce fichier au script de construction led-blink.pro

 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)

mais pour ne pas faire de longues listes de sources, j'aime généralement ça

 #  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)

Nous allons maintenant faire ce que l'IDE Arduino ne fournira jamais: ajoutez un fichier d'en-tête à l'esquisse, en procédant comme ci-dessus



Dans ce fichier, ajoutez les en-têtes nécessaires au projet.

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

configurer les chemins vers les en-têtes et les sources

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

et enfin écrire un croquis

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

Maintenant, faites un clic droit sur l'arborescence du projet et sélectionnez «Assembler»



Nous allons dans le dossier du projet. Nous avons maintenant le répertoire bin /, qui contient les produits de travail du compilateur



Tout va bien, il y a ELF, qui est utile lors du débogage et hexadécimal pour le firmware dans le contrôleur. Écrivons maintenant un autre clignotant avec LED sur la broche 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); }

Nous récupérons le projet, allez dans bin /. Nous collons dans votre carte USB. Dans mon cas, c'est Uno, sur mon système, il configure un port avec le nom / dev / ttyACM0 pour la programmation. Exécutez la commande

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

Ici

  • -P / dev / ttyACM0 - port programmeur
  • -p m328p - modèle de contrôleur
  • -c arduino - type de programmeur: intégré à la carte Uno
  • -b 115200 - vitesse du port
  • -U flash: w: led-blink.hex: i - indique la zone du firmware, le type d'opération (écriture) et le fichier du firmware

Un échappement similaire à celui-ci

 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.

nous dit que le processus s'est bien passé. La LED clignote à une fréquence de 2 Hz.

En principe, vous pouvez configurer le firmware dans l'IDE. Pour ce faire, définissez les paramètres de lancement tels



et en choisissant de démarrer le projet (en appuyant sur Ctrl + R), nous exécuterons le firmware et le lancerons exactement comme le fait l'IDE Arduino.

Conclusions


Le processus d'installation décrit est une procédure assez longue. Mais en retour, nous obtenons la pleine puissance de l'un des IDE les plus remarquables qui existent sur les systèmes basés sur le noyau Linux (et Windows s'applique également). Autodescription, refactoring, navigation de code pratique - tout cela peut maintenant être utilisé avec succès.

Cet exemple est fait, comme on dit, «au front». En fait, l'IDE Arduino compile le noyau Arduino dans une bibliothèque core.a statique séparée et établit un lien vers l'exécutable. Par conséquent, le micrologiciel collecté dans l'environnement standard est de plus petite taille que dans la méthode décrite dans l'article. Je dois encore comprendre ces nuances. Et en même temps, dans l'article suivant sur ce sujet, nous parlerons:

  • la structure du projet, découvrez où se trouve la fonction main () et montrez pourquoi un bouclage excessif sur l'Arduino est mauvais
  • débogage étape par étape à l'aide d'émulateurs
  • nous traiterons des options du compilateur utilisées dans l'assemblage

En général, nous essaierons de clarifier de nombreux problèmes qui sont utiles pour comprendre les processus en cours, sans lesquels, à l'avenir, il sera difficile de passer d'Arduino à quelque chose de plus avancé.

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

More articles:


All Articles