Línea de comandos Arduino compilar y descargar?

Existe un kit de herramientas Arduino de línea de comandos llamado Ino. Simplemente hace eso.

Este es mi modelo de gnu make include para proyectos AVR, es posible que necesite adaptar algunos de ellos para adaptarse a su entorno. Crea dependencias, tiene una serie de opciones estándar gcc que me parecen útiles o que optimizan para el tamaño, así como una biblioteca dir que uso. He utilizado esto con éxito para compilar el software arduino, también previamente hackeado el PdePreprocessor en el editor arduino para ser ejecutado desde la línea de comandos para generar todos los vudú:

Https://github.com/wesen/mididuino/blob/master/app/src/processing/app/preproc/PdePreprocessor.java

#
# generic AVR makefile
#
# (c)  July 2011 - Manuel Odendahl - [email protected]
#

# include this into your main Makefile, after having defined TARGET and TARGET_OBJS

all: $(TARGET).hex

CURDIR := $(dir $(lastword $(MAKEFILE_LIST)))
include $(CURDIR)MidiCtrl.mk

CC             = avr-gcc
CXX            = avr-g++
OBJCOPY        = avr-objcopy
AVR_ARCH       ?= atmega64
LDAVR_ARCH     ?= avrmega64
FLASH_PROTOCOL = jtag2

CFLAGS   += -Os -ffunction-sections -DAVR -I. -mmcu=$(AVR_ARCH) -mcall-prologues -fshort-enums -fpack-struct -Wall -Werror
CFLAGS   += -Wall -DLITTLE_ENDIAN -g -flto

CFLAGS += no-tree-loop-optimize -ffreestanding -morder1 -funsigned-char -funsigned-bitfields -fshort-enums -fpack-struct
CFLAGS += -fdata-sections -fno-split-wide-types -fno-inline-small-functions -mcall-prologues

CLDFLAGS += -Wl,--relax,--gc-sections -ffunction-sections
CLDFLAGS += -mmcu=$(AVR_ARCH)
LDFLAGS  = -m $(LDAVR_ARCH) -M

# generate list
# CFLAGS += -Wa,[email protected]

%.o: %.cpp
        $(CXX) $(CXXFLAGS) -c $< -o $@

%.o: %.c
        $(CC) $(CFLAGS) -c $< -o $@

%.o: %.s
        $(CC) $(CFLAGS) -c $< -o $@

%.s: %.c
        $(CC) -S $(CFLAGS) -fverbose-asm $< -o $@

%.o: %.S
        $(CC) $(CFLAGS) -c $< -o $@

%.syx: %.hex
        ihex2sysex $< $@

%.srec: %.elf
        $(OBJCOPY) -j .text -j .data -O srec $< $@

%.hex: %.elf
        $(OBJCOPY) -j .text -j .data -O ihex $< $@

%.ee_srec: %.elf
        $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O srec $< $@

AVR_BASE_DIR  ?= $(abspath $(CURDIR)..)
AVR_LIB_DIR   ?= $(AVR_BASE_DIR)/hardware/libraries

AVR_LIBS       += CommonTools Midi
AVR_LIB_DIRS   += $(foreach lib,$(AVR_LIBS),$(AVR_LIB_DIR)/$(lib))
AVR_INC_FLAGS  += $(foreach dir,$(AVR_LIB_DIRS),-I$(dir))
AVR_OBJS       += $(foreach dir,$(AVR_LIB_DIRS),$(foreach file,$(wildcard $(dir)/*.cpp),$(subst .cpp,.o,$(file))))
AVR_OBJS       += $(foreach dir,$(AVR_LIB_DIRS),$(foreach file,$(filter-out $(AVR_HOST_EXCLUDE),$(wildcard $(dir)/*.c)),$(subst .c,.o,$(file))))
AVR_DEPS       += $(subst .o,.d,$(AVR_OBJS))

# AVR_HOST_EXCLUDE can be used to exclude specific files later on

CXXFLAGS += $(AVR_INC_FLAGS)
CFLAGS += $(AVR_INC_FLAGS)

CXXFlags += -Werror -Wall
CFLAGS += -Werror -Wall

default: all

%.d:%.c
        set -e; $(CC) -MM $(CFLAGS) $< \
        | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@ ; \
        [ -s $@ ] || rm -f $@

%.d:%.cpp
        set -e; $(CXX) -MM $(CXXFLAGS) $< \
        | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@ ; \
        [ -s $@ ] || rm -f $@

%.host.d:%.c
        set -e; $(CC) -MM $(CFLAGS) $< \
        | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@ ; \
        [ -s $@ ] || rm -f $@

%.host.d:%.cpp
        set -e; $(CXX) -MM $(CXXFLAGS) $< \
        | sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' > $@ ; \
        [ -s $@ ] || rm -f $@

printlibs:
        echo $(AVR_LIBS)

$(TARGET).elf: $(TARGET).o $(TARGET_OBJS) $(AVR_OBJS)
        $(CXX) $(CLDFLAGS) -g -o $@ $^

_clean:
        - rm *.elf *.hex *.o .midictrl.flags

libclean:
        rm -rf $(TARGET_OBJS) $(OBJS)

# concrete settings for development environment

UNAME=$(shell uname)
ISWIN=$(findstring CYGWIN,$(UNAME))
ISMAC=$(findstring Darwin,$(UNAME))

CC = avr-gcc
CXX = avr-g++
OBJCOPY = avr-objcopy
AVR_ARCH = atmega64
F_CPU = 16000000L
CORE = minicommand2

Necesita crear un archivo cpp viable a partir de su boceto de arduino. El entorno arduino hace eso por usted automáticamente. Un truco para llegar a esos archivos es abrir sus preferencias de arduino.txt (está en ~ / Library / Arduino en mac, creo que en sus Documentos y Configuraciones o Datos de Aplicaciones en Windows, no recuerdo exactamente), y configure build.verbose = true y subir.verbose = true. Inicie arduino y compile su boceto (no lo cargue). La consola en la parte inferior le mostrará qué archivos fueron compilados. Ahora puede ir a ese directorio, que contendrá el archivo cpp y los archivos objeto compilados para todos los objetos arduino principales. Puedes copiarlos en tu proyecto y usar el archivo cpp para hacer más hacking. Hágame saber si necesita más información sobre el Makefile, puedo proporcionarle los que tengo.

Puedes usar biicode (es un proyecto en el que estoy trabajando) que está basado en CMake (pero en realidad no necesitas escribir ningún archivo cmake) y también es una herramienta para administrar bibliotecas Arduino

Sus principales características son:

• Resolución de dependencias, transitivamente, como hace maven, pero sin archivos de configuración: lee dependencias directamente desde el código fuente.
• Repositorio central, cualquiera puede subir sus bibliotecas. Pueden ser explorados, navegados y descubiertos en el web
• Control de versiones: comprueba la compatibilidad de versiones y permite actualizaciones seguras de dependencias
• Se puede utilizar con cualquier editor de texto (tiene opcional integración eclipse)
• Gestiona la configuración del proyecto y las compilaciones, flashea el firmware generado a la placa

Puede ver una demostración rápida aquí y leer más en la documentación .

Si puedes usar cmake entonces hay algunos enlaces en la misma web (this y this por ejemplo). GNU makefile es un poco diferente de cmake pero nada complicado. Solo Google un poco y usted puede encontrar una gran cantidad de Makefile ejemplos de cómo compilar código AVR.

Puede usar la interfaz gráfica de arduino para compilar y cargar, y establecer el editor como externo en las preferencias. De esa manera, puede editar los archivos C++ (PDE) desde xcode, y hacer que arduino genere el CPP real y construya todo el shebang.

También puede usar XCode para escribir C++/C llano para arduino, usando el compilador avr-gcc.

Echa un vistazo a: https://stackoverflow.com/a/8192762/153835

A continuación, puede utilizar la herramienta de carga avrdude simple para programar el arduino. Echa un vistazo a: http://www.ladyada.net/library/arduino/bootloader.html

Solía ser que el protocolo hablado por Arduino era una modificación del protocolo STK500, y que solo el avrdude incluido con arduino podía hablarlo. No se si el avrdude mainstream fue actualizado, o si todavía tienes que recurrir al avrdude dentro de la carpeta Arduino.

Tengo un makefile para Arduino que se puede usar para compilar y cargar programas Arduino (o AVR C) en Arduino.

Las siguientes son algunas de las características importantes de este makefile

• Soporta carga a través de Arduino como ISP o cualquier programador
• Soporta la compilación de programas AVR C simples
• Soporta bibliotecas de usuario y de sistema.
• Generar archivos de ensamblado y símbolo
• Programa usando el núcleo alternativo de Arduino (como ATtiny o Arduino núcleos alternativos)

Si no insistir en hacer que también hay scons/sconstruct scons/sconstruct. Dado que esto está básicamente escrito en Python, es mucho más simple de ajustar que hacer. Además se puede depurar con cualquier depurador Python.