A interface de um Arduino Uno (upload, etc.) com o Arduino IDE (usando o pacote Fedora) funciona bem no Fedora 21.

Mas eu prefiro usar o vim + make + vim-quickfix-mode etc.

Como eu posso fazer isso?

De preferência através das ferramentas disponíveis nos repositórios do Fedora.

Presumo que o IDE chame utilitários de linha de comando externos para o upload etc.

O equivalente ao monitor serial do IDE provavelmente está conectando um emulador de terminal (por exemplo screen) a /dev/ttyACM0, certo?

Talvez haja um bom exemplo de projeto que se possa observar no makefile?

Eu sugeriria pesquisar no Google os projetos Makefile. Eu fiz um tempo atrás no programa Blink, basicamente vendo o que foi gerado pelo IDE e replicando isso de uma maneira mais geral.

#
# Simple Arduino Makefile
#
# Author: Nick Gammon
# Date: 18th March 2015

# where you installed the Arduino app
ARDUINO_DIR = C:/Documents and Settings/Nick/Desktop/arduino-1.0.6/

# various programs
CC = "$(ARDUINO_DIR)hardware/tools/avr/bin/avr-gcc"
CPP = "$(ARDUINO_DIR)hardware/tools/avr/bin/avr-g++"
AR = "$(ARDUINO_DIR)hardware/tools/avr/bin/avr-ar"
OBJ_COPY = "$(ARDUINO_DIR)hardware/tools/avr/bin/avr-objcopy"

MAIN_SKETCH = Blink.cpp

# compile flags for g++ and gcc

# may need to change these
F_CPU = 16000000
MCU = atmega328p

# compile flags
GENERAL_FLAGS = -c -g -Os -Wall -ffunction-sections -fdata-sections -mmcu=$(MCU) -DF_CPU=$(F_CPU)L -MMD -DUSB_VID=null -DUSB_PID=null -DARDUINO=106
CPP_FLAGS = $(GENERAL_FLAGS) -fno-exceptions
CC_FLAGS  = $(GENERAL_FLAGS)

# location of include files
INCLUDE_FILES = "-I$(ARDUINO_DIR)hardware/arduino/cores/arduino" "-I$(ARDUINO_DIR)hardware/arduino/variants/standard"

# library sources
LIBRARY_DIR = "$(ARDUINO_DIR)hardware/arduino/cores/arduino/"

build:

    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(MAIN_SKETCH) -o $(MAIN_SKETCH).o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)avr-libc/malloc.c -o malloc.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)avr-libc/realloc.c -o realloc.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)WInterrupts.c -o WInterrupts.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)wiring.c -o wiring.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)wiring_analog.c -o wiring_analog.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)wiring_digital.c -o wiring_digital.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)wiring_pulse.c -o wiring_pulse.c.o
    $(CC) $(CC_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)wiring_shift.c -o wiring_shift.c.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)CDC.cpp -o CDC.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)HardwareSerial.cpp -o HardwareSerial.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)HID.cpp -o HID.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)IPAddress.cpp -o IPAddress.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)main.cpp -o main.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)new.cpp -o new.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)Print.cpp -o Print.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)Stream.cpp -o Stream.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)Tone.cpp -o Tone.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)USBCore.cpp -o USBCore.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)WMath.cpp -o WMath.cpp.o
    $(CPP) $(CPP_FLAGS) $(INCLUDE_FILES) $(LIBRARY_DIR)WString.cpp -o WString.cpp.o
    rm core.a
    $(AR) rcs core.a malloc.c.o
    $(AR) rcs core.a realloc.c.o
    $(AR) rcs core.a WInterrupts.c.o
    $(AR) rcs core.a wiring.c.o
    $(AR) rcs core.a wiring_analog.c.o
    $(AR) rcs core.a wiring_digital.c.o
    $(AR) rcs core.a wiring_pulse.c.o
    $(AR) rcs core.a wiring_shift.c.o
    $(AR) rcs core.a CDC.cpp.o
    $(AR) rcs core.a HardwareSerial.cpp.o
    $(AR) rcs core.a HID.cpp.o
    $(AR) rcs core.a IPAddress.cpp.o
    $(AR) rcs core.a main.cpp.o
    $(AR) rcs core.a new.cpp.o
    $(AR) rcs core.a Print.cpp.o
    $(AR) rcs core.a Stream.cpp.o
    $(AR) rcs core.a Tone.cpp.o
    $(AR) rcs core.a USBCore.cpp.o
    $(AR) rcs core.a WMath.cpp.o
    $(AR) rcs core.a WString.cpp.o
    $(CC) -Os -Wl,--gc-sections -mmcu=$(MCU) -o $(MAIN_SKETCH).elf $(MAIN_SKETCH).o core.a -lm
    $(OBJ_COPY) -O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0 $(MAIN_SKETCH).elf $(MAIN_SKETCH).eep
    $(OBJ_COPY) -O ihex -R .eeprom $(MAIN_SKETCH).elf $(MAIN_SKETCH).hex

Você precisaria mudar ARDUINO_DIRpelo menos para refletir onde instalou o IDE. Se você usar outras coisas, como a biblioteca Wire, precisará expandi-la um pouco para compilar bibliotecas adicionais. Novamente, você pode usar o que o IDE gera para orientar suas alterações.

As linhas com os espaços à esquerda acima precisariam do caractere de tabulação em vez de espaços, como é normal para um Makefile.

Eu uso a interface da linha de comandos para o arduinocomando .

Eu corro assim:

arduino --upload sketch/sketch.ino --port /dev/ttyUSB*

Há uma página que descreve outras ferramentas de linha de comando, como inotool. Essa página também tem um exemplo Makefile. Essas alternativas parecem atraentes, mas aparentemente, até o momento, nenhuma delas funciona. Suponho que isso se deva a algumas alterações recentes nos arquivos de distribuição do Arduino IDE dos quais eles dependem.

Rodar arduinocomo acima é um pouco lento, porque ele precisa carregar o Java, mas pelo menos funciona. Há também um arduino-buildercomando que vem com a distribuição IDE do Arduino. No momento da redação deste documento, não estava suficientemente bem documentado para que eu pudesse descobrir como usá-lo. Por exemplo, não há exemplos de linhas de comando no README ou em qualquer um dos tutoriais que encontrei, e não consegui descobrir como usá-lo para fazer upload de código para o quadro. No entanto, presumivelmente é capaz de nos fornecer uma compilação mais rápida do que arduino. O README também menciona a possibilidade de reutilizar arquivos de objetos de uma compilação anterior, para que haja alguma funcionalidade semelhante à criação.

Para visualizar a saída serial , uso algo como

stty -F /dev/ttyUSB* 1000000 raw -clocal -echo
cat /dev/ttyUSB*

O número 1000000 deve corresponder ao número que você passa Serial.begin()no código do seu quadro. Você também pode usar screense tiver um programa de quadro que seja adequadamente interativo ou usar qualquer utilitário para gravar diretamente no dispositivo. A propósito, meu Due aparece como /dev/ttyACM0(em vez de /dev/ttyUSB0para o Uno).

O que você precisa é de um Makefile. Existem alguns projetos Makefile disponíveis para o Arduino. A pesquisa no "Arduino Makefile" retorna muitos resultados, incluindo o que parece ser bom no Github: https://github.com/sudar/Arduino-Makefile

Compilar a partir da linha de comando não é trivial devido à maneira como o Arduino IDE lida com as bibliotecas.

O equivalente ao monitor serial do IDE provavelmente está conectando um emulador de terminal (por exemplo, tela) ao / dev / ttyACM0, certo?

Para o monitor serial, eu recomendaria o minicom. É um emulador de terminal totalmente funcional (vt102) na linha de comando.

minicom -D /dev/ttyACM0 -b 115200

... por exemplo.

Se você quer uma solução compatível para o seu projeto arduino (sim, você pode compartilhar seu projeto com outras pessoas que usam simplesmente Arduino IDE), você precisa verificar amake uma ferramenta para simplificar a cli do arduino, eu usá-lo com Geany mas outros o estão usando com vi, Atom, etc.

É inspirado e os projetos Ino e Arturo agora mortos; dedique 5 minutos para testá-lo e envie um feedback.

Exemplo de uso:

cd ~/Arduino/Blink/
[move to your arduino project folder]

amake -v uno Blink.ino
[to compile/verify your code]

amake -u uno Blink.ino /dev/ttyUSB0
[to upload your code to an arduino connected via USB]

Ele tem um pouco de cola inteligente, pode lembrar a placa e o arquivo e até detectar automaticamente o usb da placa; portanto, após um comando "amake -v" bem-sucedido, você pode fazer isso na linha de comando e ele funcionará.

amake -v
[to compile/verify your code]

amake -u
[to upload your code to an arduino connected via USB]

Se você usar algumas macros do IDE, poderá criar os comandos de compilação e upload facilmente, por exemplo, usando o Geany IDE, ele se tornará:

• Compilar / Verificar: cd% d; amake -v uno% f
• Upload: cd% d; amake -u uno% f

Você pode obter mais ajuda executando apenas "amake" ou "amake -h" depois de instalado.

Além disso, ele suporta TODAS as placas / lib / programadores que você instalou / configurou no seu Arduino IDE, sim, placas modernas como a Adafuit Trinket M0 / Arduino M0 etc ...

Basta disparar o seu Arduino IDE, ir ao gerente do conselho, instalar o suporte e pronto, basta seguir algumas instruções simples e pronto.

O quadro que você possui não é suportado? sem problemas, detecte o fqbn (leia o arquivo README.md) e passe-o como o nome do quadro.

Estou procurando testadores para aumentar o número ou aliases da placa e a detecção automática das assinaturas USB apropriadas.

Lembre-se de que esta é uma ferramenta privada, agora compartilhada com o público, você sabe, apenas um programador que coça a coceira ...

Felicidades.

Ferramenta CLI oficial

A equipe do arduino está desenvolvendo um cliente cli https://github.com/arduino/arduino-cli

Anúncio : https://blog.arduino.cc/2018/08/24/announcing-the-arduino-command-line-interface-cli/

Você pode fazer quase tudo com isso, desde o download de placas e bibliotecas, até a compilação e upload de scripts. O que falta é a parte de monitoramento (você pode usar o método Metamórfico usando stty cat, Funciona!)

Os comandos são muito parecidos com a resposta metamórfica, pois essa ferramenta está se ramificando daquela

Instruções no repositório Github e na página de manual:

    $ arduino-cli Arduino Command Line Interface (arduino-cli).

    Usage:   arduino-cli [command]

    Examples: arduino <command> [flags...]

    Available Commands:
      board         Arduino board commands.
      compile       Compiles Arduino sketches.
      config        Arduino Configuration Commands.
      core          Arduino Core operations.
      help          Help about any command
      lib           Arduino commands about libraries.
      sketch        Arduino CLI Sketch Commands.
      upload        Upload Arduino sketches.
      version       Shows version number of Arduino CLI.