La interfaz de un Arduino Uno (carga, etc.) con el Arduino IDE (usando el paquete Fedora) funciona bien en Fedora 21.

Pero prefiero usar vim + make + vim-quickfix-mode, etc.

¿Cómo puedo hacer eso?

Preferiblemente a través de las herramientas disponibles en los repositorios de Fedora.

Supongo que el IDE llama a utilidades de línea de comando externas para la carga, etc.

El equivalente al monitor en serie del IDE probablemente esté conectando un emulador de terminal (por ejemplo screen) a /dev/ttyACM0, ¿verdad?

¿Quizás hay un buen proyecto de ejemplo que uno puede ver en el archivo MAKE?

Sugeriría buscar en Google para proyectos Makefile. Hice uno hace un tiempo para el programa Blink, al ver básicamente lo que generó el IDE y replicarlo de una manera más general.

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

Debería cambiar ARDUINO_DIRal menos, para reflejar dónde instaló el IDE. Si usa otras cosas como la biblioteca Wire, necesitaría expandirla un poco para compilar bibliotecas adicionales. Nuevamente, puede usar lo que el IDE genera para guiar sus cambios.

Las líneas con los espacios iniciales anteriores necesitarían el carácter de tabulación en lugar de espacios, como es normal para un Makefile.

Yo uso la interfaz de línea de comandos para el arduinocomando .

Lo ejecuto así:

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

Hay una página que describe otras herramientas de línea de comandos, como inotool. Esa página también tiene un ejemplo Makefile. Estas alternativas parecen atractivas, pero aparentemente, a partir de este escrito, ninguna de ellas funciona. Supongo que esto se debe a algunos cambios recientes en los archivos de distribución Arduino IDE de los que dependen.

Ejecutar arduinocomo el anterior es un poco lento, porque tiene que cargar Java, supongo, pero al menos funciona. También hay un arduino-buildercomando que viene con la distribución Arduino IDE. Al momento de escribir esto, no estaba suficientemente documentado para que yo pudiera descubrir cómo usarlo. Por ejemplo, no hay líneas de comando de ejemplo en el archivo README o en ninguno de los tutoriales que encontré, y no pude descubrir cómo usarlo para cargar el código en el tablero. Sin embargo, presumiblemente es capaz de darnos una compilación más rápida que arduino. El archivo README también menciona la posibilidad de reutilizar archivos de objetos de una compilación anterior, por lo que hay algunas funcionalidades similares.

Para ver la salida en serie , uso algo como

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

El número 1000000 debe coincidir con el número que pasa Serial.begin()en el código de su tablero. También puede usarlo screensi tiene un programa de tablero que sea apropiadamente interactivo, o puede usar cualquier utilidad para escribir directamente en el dispositivo. Por cierto, mi Due aparece como /dev/ttyACM0(en lugar de /dev/ttyUSB0para el Uno).

Lo que necesitas es un Makefile. Hay algunos proyectos de Makefile para Arduino. Buscar en Google "Arduino Makefile" devuelve muchos resultados, incluido lo que parece bueno en Github: https://github.com/sudar/Arduino-Makefile

Compilar desde la línea de comandos no es trivial debido a la forma en que Arduino IDE maneja las bibliotecas.

El equivalente al monitor serie del IDE probablemente esté conectando un emulador de terminal (por ejemplo, pantalla) a / dev / ttyACM0, ¿verdad?

Para el monitor en serie, recomendaría minicom. Es un emulador de terminal completamente funcional (vt102) en la línea de comando.

minicom -D /dev/ttyACM0 -b 115200

... por ejemplo.

Si desea una solución totalmente compatible para su proyecto arduino (sí, puede compartir su proyecto con otras personas que usan simplemente Arduino IDE), debe verificar amake una herramienta para simplificar el cli del arduino, lo uso con Geany pero otros lo están usando con vi, Atom, etc.

Está inspirado y los proyectos ahora muertos de Ino y Arturo; Tómese 5 minutos para probarlo y envíe sus comentarios

Ejemplo 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]

Tiene un poco de pegamento inteligente, puede recordar el tablero y el archivo, e incluso detectar automáticamente el usb del tablero; así que después de un comando exitoso "amake -v" puede hacerlo en la línea de comando y funcionará.

amake -v
[to compile/verify your code]

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

Si usa algunas macros IDE, puede crear fácilmente los comandos de compilación y carga, por ejemplo, usando Geany IDE se convertirá en:

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

Puede obtener más ayuda ejecutando simplemente "amake" o "amake -h" una vez instalado.

Además, puede soportar CADA placa / lib / programador que haya instalado / configurado en su IDE Arduino, sí, placa moderna como Adafuit Trinket M0 / Arduino M0, etc.

Simplemente encienda su Arduino IDE, vaya al administrador de la placa, instale soporte y eso es todo, solo siga algunas instrucciones simples y listo.

¿La placa que tienes no es compatible? no es un problema, detecte el fqbn (lea el archivo README.md) y páselo como el nombre de la placa.

Estoy buscando probadores para aumentar el número o los alias de placa y la detección automática de las firmas USB adecuadas.

Recuerde que esta es una herramienta privada desarrollada, ahora compartida con el público, ya sabes, solo un programador rascando su picazón ...

Salud.

Herramienta oficial de CLI

El equipo de arduino está desarrollando un cliente cli https://github.com/arduino/arduino-cli

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

Puede hacer casi todo con esto, desde descargar tableros y bibliotecas, hasta compilar y cargar scripts. Lo que falta es la parte de monitoreo (puede usar el método Metamorphic usando stty cat, ¡funciona!)

Los comandos son muy similares a la respuesta de Metamorphic ya que esta herramienta se está ramificando de esa.

Instrucciones en el repositorio de Github y la 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.