Geekly articles weekly

Arduino no Linux: configurando o Qt Creator como um ambiente de desenvolvimento

A plataforma Arduino é popular, independentemente de ser repreendida ou elogiada. Seus criadores conseguiram diminuir o limite de entrada para o nível de alguns cliques do mouse + algumas linhas de código e pronto - aqui você tem um LED piscando. E, em geral, para a rápida criação de protótipos de artesanato no AVR, a coisa do Arduino é extremamente conveniente. A única coisa que eles falharam foi o IDE, que é difícil de chamar. Entre as funções do IDE, ele fornece apenas uma coisa - a automação da criação e montagem de um projeto.

Para usuários do Windows, existe uma alternativa: MS Visual Studio Community + plugin vMicro que permite escrever esboços, mas com todas as vantagens fornecidas pelo IDE. O plug-in oscila sem problemas no próprio estúdio através do menu "Ferramentas" e funciona da maneira que você deseja na avaliação. A versão paga, em teoria, suporta a depuração passo a passo, mas eles, como proprietários da cópia licenciada do vMicro, não ficaram muito impressionados.

Para usuários de Linux, tudo está como sempre: queremos um bom IDE - selecione a "vítima" e tente fixar a funcionalidade necessária. Existem soluções baseadas no Eclipse , mas eu não gosto do eclipse, sobre o qual já escrevi uma vez . Suponho-o como um mal inevitável, quando não há nada adequado à mão. De todos os IDEs gratuitos, eu respeito muito o poderoso e maravilhoso Qt Creator , no qual eu e minha equipe trabalhamos há mais de um ano. Portanto, falarei sobre como transformá-lo em um ambiente de desenvolvimento para o Arduino.

1. Preparação do solo


O Qt Creator está disponível nos repositórios de qualquer distribuição Linux que se preze mais ou menos. Por exemplo, no archa, obtenha-o assim

$ sudo pacman -S qtcreator

Além disso, precisaremos de pacotes relacionados ao próprio Arduino.

 $ sudo pacman -S arduino arduino-avr-core

No dia em que finalmente esquecermos o Arduino, precisaremos de outro compilador, montador, vinculador e biblioteca C padrão para o AVR, então os colocamos

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

Vamos testar o depurador e o emulador neste artigo, portanto, instalaremos esses pacotes

 $ sudo pacman -S avr-gdb simavr

2. Crie um projeto no Qt Creator


Execute o Qt Creator e crie um novo projeto sem o Qt em C ++



Escolha um local para o projeto e dê um nome a ele



Como um sistema de construção, faça um qmake regular



Deixamos o conjunto de trabalho por padrão, corrigimos mais tarde



Sob controle de versão, adicione o projeto conforme desejado



Temos o projeto C ++ padrão



Existem apenas dois arquivos no projeto: main.cpp e led-blink.pro. O primeiro é excluído, o segundo é limpo de tudo o que está escrito lá, obtendo um projeto completamente vazio



Agora, com canetas, começamos a escrever texto em um arquivo * .pro, formando a estrutura do projeto para o Arduino

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

Excluímos tudo relacionado ao Qt do projeto e selecionamos o modelo do projeto

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

Definimos o diretório para o binário montado e seu nome

 DESTDIR = ../bin TARGET = led-blink

Em seguida, conecte os diretórios de pesquisa de cabeçalho

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

Definir o compilador C e suas chaves

 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

e o compilador C ++ e suas chaves

 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

definir o vinculador e suas chaves

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

Configuramos o pós-processamento do arquivo ELF, para transformá-lo no Intel HEX para o firmware subsequente na placa

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

Especifique quais arquivos de cabeçalho estão incluídos no projeto.

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

Definir arquivos de origem do Arduino Core

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

Então, bem, quando vamos realmente começar a desenhar? Vamos começar agora, mas o que fizemos, nobres dons, é o mínimo necessário para o código do esboço funcionar.

Agora adicione a fonte do esboço ao projeto. Clique com o botão direito do mouse no projeto na árvore e selecione "Adicionar novo ..." Adicione o arquivo de origem C ++



Para organizar as fontes dentro do projeto, na próxima janela



clique em "Procurar" e crie a pasta src para arquivos * .cpp



Agora dê um nome ao arquivo



Clique na próxima janela "Concluir". Ficamos com essa imagem



O IDE adicionará esse arquivo ao script de construção 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)

mas, para não fazer longas listas de fontes, geralmente faço assim

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

Agora, faremos o que o Arduino IDE nunca fornecerá: adicione um arquivo de cabeçalho ao esboço, executando as mesmas etapas acima



Neste arquivo, adicione os cabeçalhos necessários para o projeto.

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

configurar os caminhos para os cabeçalhos e fontes

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

e agora finalmente escreva um esboço

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

Agora clique com o botão direito na árvore do projeto e selecione "Montar"



Nós vamos para a pasta do projeto. Agora temos o diretório bin /, que contém os produtos de trabalho do compilador



Está tudo bem, existe o ELF, que é útil na depuração e hexadecimal para firmware no controlador. Agora vamos escrever outro pisca-pisca com LED no pino 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); }

Nós coletamos o projeto, vamos para o bin /. Colamos na sua placa usb. No meu caso, é Uno, no meu sistema, configura uma porta com o nome / dev / ttyACM0 para programação. Execute o comando

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

Aqui

  • -P / dev / ttyACM0 - porta do programador
  • -p m328p - modelo do controlador
  • -c arduino - tipo de programador: incorporado na placa Uno
  • -b 115200 - velocidade da porta
  • -U flash: w: led-blink.hex: i - indica a área do firmware, tipo de operação (gravação) e arquivo de firmware

Um escape semelhante 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 diz que o processo correu bem. O LED piscará na frequência de 2 Hz.

Em princípio, você pode configurar o firmware no IDE. Para fazer isso, faça as configurações de inicialização como



e optando por iniciar o projeto (pressionando Ctrl + R), executaremos o firmware e iniciaremos exatamente como o IDE do Arduino.

Conclusões


O processo de instalação descrito é um procedimento bastante demorado. Mas, em troca, temos todo o poder de um dos IDEs mais notáveis ​​que existem em sistemas baseados no kernel Linux (e o Windows também se aplica). Autodescrição, refatoração, navegação conveniente por código - tudo isso agora pode ser usado com sucesso.

Este exemplo é feito, como se costuma dizer, "na testa". De fato, o Arduino IDE compila o Arduino Core em uma biblioteca core.a estática separada e os links para o executável. Como resultado, o firmware coletado no ambiente padrão é menor em tamanho do que no método descrito no artigo. Eu ainda tenho que descobrir essas nuances. E, ao mesmo tempo, no seguinte artigo sobre este assunto, falaremos sobre:

  • a estrutura do projeto, descubra onde a função main () está localizada e mostre por que o loop excessivo no Arduino é ruim
  • depuração passo a passo usando emuladores
  • trataremos das opções do compilador usadas na montagem

Em geral, tentaremos esclarecer muitas questões úteis para entender os processos em andamento, sem as quais no futuro será difícil mudar do Arduino para algo mais avançado.

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

More articles:


All Articles