Geekly articles weekly

Arduino en Linux: Configuración de Qt Creator como entorno de desarrollo

La plataforma Arduino es popular, independientemente de si es regañada o elogiada. Sus creadores lograron reducir el umbral de entrada al nivel de unos pocos clics del mouse + un par de líneas de código y listo, aquí tienes un LED parpadeante. Y, en general, para la creación rápida de prototipos de embarcaciones en AVR, lo de Arduino es extremadamente conveniente. Lo único que fallaron fue el IDE, que es difícil de llamar. Entre las funciones del IDE, proporciona solo una cosa: la automatización de la creación y el ensamblaje de un proyecto.

Para los usuarios de Windows, existe una alternativa: MS Visual Studio Community + vMicro plugin que le permite escribir bocetos, pero con todas las ventajas proporcionadas por el IDE. El plug-in se balancea sin problemas en el estudio mismo a través del menú "Herramientas" y funciona tanto como desee en la versión de prueba. La versión paga en teoría admite la depuración paso a paso, pero ellos, como propietarios de la copia con licencia de vMicro, no estaban muy impresionados.

Para los usuarios de Linux, todo es como siempre: queremos un buen IDE: seleccione la "víctima" e intente asegurarle la funcionalidad necesaria. Hay soluciones basadas en Eclipse , pero no me gusta el eclipse, sobre el que ya escribí una vez . Lo soporto como un mal inevitable, cuando no hay nada adecuado a la mano. De todos los IDE gratuitos, respeto mucho al poderoso y maravilloso Qt Creator , en el que yo y mi equipo hemos estado trabajando durante más de un año. Por lo tanto, hablaré sobre cómo convertirlo en un entorno de desarrollo para Arduino.

1. Preparación del suelo


Qt Creator está disponible en los repositorios de cualquier distribución Linux más o menos respetuosa. Por ejemplo en archa obtenlo así

$ sudo pacman -S qtcreator

Además, necesitaremos paquetes con respecto al Arduino mismo.

 $ sudo pacman -S arduino arduino-avr-core

El día en que finalmente olvidemos Arduino, necesitaremos otro compilador, ensamblador, enlazador y biblioteca C estándar para AVR, así que los colocamos

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

Probaremos el depurador y el emulador en este artículo, por lo que instalaremos dichos paquetes

 $ sudo pacman -S avr-gdb simavr

2. Crear un proyecto en Qt Creator


Ejecute Qt Creator y cree un nuevo proyecto sin Qt en C ++



Elija una ubicación para el proyecto y asígnele un nombre



Como sistema de compilación, tome un qmake regular



Dejamos el conjunto de trabajo por defecto, arreglelo más tarde



Bajo control de versiones, agregue el proyecto como desee



Obtenemos el proyecto estándar de C ++



Solo hay dos archivos en el proyecto: main.cpp y led-blink.pro. El primero se elimina, el segundo se borra de todo lo que está escrito allí, obteniendo un proyecto completamente vacío



Ahora con bolígrafos, comenzamos a escribir texto en un archivo * .pro, formando la estructura del proyecto para Arduino

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

Excluimos todo lo relacionado con Qt del proyecto y seleccionamos la plantilla del proyecto.

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

Establecemos el directorio para el binario ensamblado y su nombre.

 DESTDIR = ../bin TARGET = led-blink

A continuación, conecte los directorios de búsqueda de encabezado

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

Definir el compilador de C y sus claves.

 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

y el compilador de C ++ y sus claves

 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

configurar el enlazador y sus claves

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

Configuramos el postprocesamiento del archivo ELF, para convertirlo en Intel HEX para el firmware posterior en la placa

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

Especifique qué archivos de encabezado se incluyen en el proyecto.

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

Definir archivos fuente de Arduino Core

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

Entonces, bueno, ¿cuándo comenzaremos a dibujar? Comencemos ahora, pero lo que hemos hecho, nobles dons, es el mínimo necesario para que el código de boceto funcione.

Ahora agregue la fuente del boceto al proyecto. Haga clic derecho en el proyecto en el árbol y seleccione "Agregar nuevo ..." Agregue el archivo fuente C ++



Para organizar las fuentes dentro del proyecto, en la siguiente ventana



haga clic en "Examinar" y cree la carpeta src para archivos * .cpp



Ahora dale un nombre al archivo



Haga clic en la siguiente ventana "Finalizar". Tenemos una foto así



El IDE agregará este archivo al script de compilación 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)

pero para no hacer largas listas de fuentes, generalmente me gusta esto

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

Ahora haremos lo que el IDE de Arduino nunca proporcionará: agregue un archivo de encabezado al boceto, siguiendo los mismos pasos que arriba



En este archivo, agregue los encabezados necesarios para el proyecto.

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

configurar las rutas a los encabezados y fuentes

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

y ahora finalmente escribo un boceto

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

Ahora hacemos clic derecho en el árbol del proyecto y seleccionamos "Ensamblar"



Vamos a la carpeta del proyecto. Ahora tenemos el directorio bin /, que contiene los productos de trabajo del compilador.



Todo está bien, hay ELF, que es útil al depurar y hexadecimal para firmware en el controlador. Ahora escribamos otra luz intermitente con LED en el 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); }

Recolectamos el proyecto, vamos a bin /. Nos quedamos en su placa usb. En mi caso es Uno, en mi sistema configura un puerto con el nombre / dev / ttyACM0 para la programación. Ejecutar el comando

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

Aqui

  • -P / dev / ttyACM0 - puerto del programador
  • -p m328p - modelo de controlador
  • -c arduino - tipo de programador: integrado en la placa Uno
  • -b 115200 - velocidad del puerto
  • -U flash: w: led-blink.hex: i - indica el área del firmware, tipo de operación (escritura) y archivo de firmware

Un escape similar a este

 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.

nos dice que el proceso fue bien. El LED parpadeará a una frecuencia de 2 Hz.

En principio, puede configurar el firmware en el IDE. Para hacer esto, realice la configuración de inicio como



y al elegir iniciar el proyecto (presionando Ctrl + R) ejecutaremos el firmware y lo lanzaremos exactamente como lo hace el IDE de Arduino.

Conclusiones


El proceso de configuración descrito es un procedimiento bastante lento. Pero a cambio, obtenemos toda la potencia de uno de los IDE más notables que existen en los sistemas basados ​​en el kernel de Linux (y también se aplica Windows). Autodescripción, refactorización, navegación de código conveniente: todo esto ahora se puede utilizar con éxito.

Este ejemplo se hace, como dicen, "en la frente". De hecho, el IDE de Arduino compila el núcleo de Arduino en una biblioteca estática core.a separada y enlaza con el ejecutable. Como resultado, el firmware recopilado en el entorno estándar es más pequeño en tamaño que en el método descrito en el artículo. Todavía tengo que resolver estos matices. Y al mismo tiempo en el siguiente artículo sobre este tema hablaremos de:

  • la estructura del proyecto, descubra dónde se encuentra la función main () y muestre por qué el bucle excesivo en Arduino es malo
  • depuración paso a paso utilizando emuladores
  • trataremos las opciones del compilador usadas en el ensamblaje

En general, intentaremos aclarar muchos problemas que son útiles para comprender los procesos en curso, sin los cuales en el futuro será difícil cambiar de Arduino a algo más avanzado.

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

More articles:


All Articles