L'interfaccia di un Arduino Uno (upload ecc.) Con l'IDE Arduino (usando il pacchetto Fedora) funziona bene con Fedora 21.

Ma preferisco usare vim + make + vim-quickfix-mode ecc.

Come posso fare ciò?

Preferibilmente tramite gli strumenti disponibili nei repository Fedora.

Presumo che l'IDE chiami utilità da riga di comando esterne per il caricamento, ecc.

L'equivalente del monitor seriale dell'IDE sta probabilmente collegando un emulatore di terminale (ad es. screen) A /dev/ttyACM0, giusto?

Forse c'è un buon esempio di progetto che si può guardare al makefile?

Suggerirei Googling per i progetti Makefile. Ne ho fatto uno un po 'indietro per il programma Blink, essenzialmente vedendo ciò che è stato generato dall'IDE e replicandolo in un modo più generale.

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

Dovresti cambiare ARDUINO_DIRalmeno, per riflettere dove hai installato l'IDE. Se usi altre cose come la libreria Wire, dovrai espanderla in qualche modo per compilare ulteriori librerie. Ancora una volta, puoi utilizzare ciò che l'IDE si genera per guidare le tue modifiche.

Le linee con gli spazi iniziali sopra avrebbero bisogno del carattere tab invece che degli spazi, come è normale per un Makefile.

Uso l' interfaccia della riga di comando per il arduinocomando .

Lo eseguo così:

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

C'è una pagina che descrive altri strumenti da riga di comando, come inotool. Anche quella pagina ha un esempio Makefile. Queste alternative sembrano allettanti, ma apparentemente, al momento della stesura di questo articolo, nessuna di esse funziona. Suppongo che ciò sia dovuto ad alcune recenti modifiche nei file di distribuzione IDE di Arduino da cui dipendono.

L'esecuzione arduinocome sopra è un po 'lenta, perché deve caricare Java credo, ma almeno funziona. C'è anche un arduino-buildercomando fornito con la distribuzione IDE di Arduino. Al momento della stesura di questo documento, non è stato sufficientemente ben documentato per me per essere in grado di capire come usarlo. Ad esempio non ci sono linee di comando di esempio nel README o in nessuno dei tutorial che ho incontrato e non sono riuscito a capire come usarlo per caricare il codice sulla scheda. Tuttavia, presumibilmente è in grado di darci una compilazione più veloce di arduino. README menziona anche la possibilità di riutilizzare i file oggetto da una compilazione precedente, quindi esiste una funzionalità simile al make.

Per visualizzare l'output seriale uso qualcosa di simile

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

Il numero 1000000 dovrebbe corrispondere al numero a cui passi Serial.begin()nel codice della tua scheda. Puoi anche usare screense hai un programma di bordo che è opportunamente interattivo, oppure puoi usare qualunque utilità per scrivere direttamente sul dispositivo. A proposito, il mio Due si presenta come /dev/ttyACM0(piuttosto che /dev/ttyUSB0per Uno).

Ciò di cui hai bisogno è un Makefile. Ci sono alcuni progetti Makefile in giro per Arduino. Googling per "Arduino Makefile" restituisce molti risultati, incluso quello che sembra buono su Github: https://github.com/sudar/Arduino-Makefile

La compilazione dalla riga di comando non è banale a causa del modo in cui l'IDE di Arduino gestisce le librerie.

L'equivalente al monitor seriale dell'IDE sta probabilmente collegando un emulatore di terminale (ad esempio schermo) a / dev / ttyACM0, giusto?

Per il monitor seriale consiglierei minicom. È un emulatore di terminale completamente funzionale (vt102) sulla riga di comando.

minicom -D /dev/ttyACM0 -b 115200

... per esempio.

Se si desidera una soluzione completamente compatibile per il vostro progetto Arduino (sì, è possibile condividere il progetto con altre persone che utilizzano semplicemente Arduino IDE) è necessario verificare AAssicurarsi uno strumento per semplificare il cli del arduino, Io lo uso con Geany ma altri lo usano con vi, Atom, ecc.

È ispirato e i progetti Ino e Arturo ormai morti; attendere 5 minuti per testarlo e fornire feedback.

Esempio di utilizzo:

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]

Ha un po 'di colla intelligente dentro, può ricordare la scheda e il file e persino rilevare automaticamente l'USB della scheda; quindi dopo un comando "amake -v" riuscito puoi farlo sulla riga di comando e funzionerà.

amake -v
[to compile/verify your code]

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

Se usi alcune macro IDE puoi creare facilmente i comandi di compilazione e caricamento, ad esempio usando Geany IDE diventerà:

• Compila / Verifica: cd% d; tra -v uno% f
• Carica: cd% d; in pausa -u uno% f

Puoi ottenere ulteriore assistenza eseguendo solo "amake" o "amake -h" una volta installato.

Inoltre, può supportare OGNI scheda / lib / programmatore che hai installato / configurato nel tuo IDE Arduino, sì, scheda moderna come Adafuit Trinket M0 / Arduino M0 ecc ...

Basta avviare il tuo IDE Arduino, andare al gestore della scheda, installare il supporto e basta, basta seguire alcune semplici istruzioni e il gioco è fatto.

La scheda che hai non è supportata? non è un problema, rileva il file fqbn (leggi il file README.md) e passalo come nome della scheda.

Sto cercando tester per aumentare il numero o gli alias della scheda e il rilevamento automatico delle firme USB appropriate.

Ricorda che questo è uno strumento privato, ora condiviso con il pubblico, sai, solo un programmatore che gratta il prurito ...

Saluti.

Strumento CLI ufficiale

Il team di Arduino sta sviluppando un client cli https://github.com/arduino/arduino-cli

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

Puoi fare quasi tutto con questo, dal download di schede e librerie, alla compilazione e al caricamento di script. Ciò che manca è la parte di monitoraggio (puoi usare il metodo di Metamorphic usando stty cat, Funziona!)

I comandi sono molto simili alla risposta di Metamorphic poiché questo strumento si sta ramificando da quello

Istruzioni nel repository Github e nella pagina man:

    $ 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.