linux - recuperar - proteger codigo arduino

Línea de comandos Arduino compilando y descargando?

Question

¿Cómo compilo y cargo los sketches Arduino desde la línea de comandos en Mac y Linux? He instalado el entorno de programación Arduino. ¿Hay algunos archivos make de muestra en cualquier lugar?

Answer 1

En realidad, puede usar la GUI de Arduino para compilar y cargar, y configurar el editor como externo en las preferencias. De esta forma, puede editar los archivos C ++ (PDE) desde xcode y hacer que arduino genere el CPP real y cree todo el shebang.

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

Eche un vistazo a: https://.com/a/8192762/153835

A continuación, puede utilizar la herramienta de carga simple avrdude para programar el arduino. Eche 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 sé si la versión estándar de avrdude se actualizó, o si todavía tiene que recurrir a avrdude dentro de la carpeta Arduino.

Answer 2

Esta es mi repetición gnu make para proyectos de AVR, puede que necesite adaptar algo para adaptarse a su entorno. Crea dependencias, tiene una serie de opciones de gcc estándar que me parecen útiles o que optimizan para el tamaño, así como un directorio de biblioteca que uso. Utilicé esto con éxito para compilar el software arduino, también pirateé previamente el procesador PdePre en el editor arduino para ejecutarlo desde la línea de comando para generar todo el 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

Answer 3

Hay un juego de herramientas Arduino de línea de comandos llamado Ino . Simplemente hace eso.

Answer 4

La compilación y carga de bocetos (como se aplicó a las fuentes C / C ++) en la línea de comandos (en Windows, Mac y Linux) se admite directamente mediante indicadores en el ejecutable arduino desde 1.5.0.

Un ino puede compilarse y cargarse con arduino --upload [sketch.ino]

Documentation

Answer 5

Necesita crear un archivo cpp viable de su boceto Arduino. El entorno arduino hace eso automáticamente. Un truco para llegar a esos archivos es abrir su arduino preferences.txt (está en ~ / Library / Arduino en el mac, creo que en sus documentos y configuraciones o en Application Data en windows, no lo recuerdo exactamente), y establecer build .verbose = true y upload.verbose = true. Comience Arduino y compile su boceto (no lo suba). La consola en la parte inferior le mostrará qué archivos fueron compilados. Ahora puede ir a ese directorio, que contendrá el archivo cpp, y archivos de objetos compilados para todos los objetos arduino centrales. Puede copiarlos en su proyecto y usar el archivo cpp para hacer más piratería. Avíseme si necesita más información sobre el Makefile, puedo proporcionarle los que tengo.

Answer 6

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

Sus principales características son:

• Resolución de dependencias, de forma transitiva, como maven, pero sin archivos de configuración: lee las dependencias directamente del código fuente.
• Repositorio central, cualquiera puede subir sus bibliotecas. Se pueden explorar, navegar y descubrir en la web
• Control de versiones: comprueba la compatibilidad de versiones y permite actualizaciones seguras de dependencias
• Puedes usarlo con cualquier editor de texto (tiene integración de eclipse opcional)
• Gestiona la configuración del proyecto y las compilaciones, flashea el firmware generado a la placa

Puede ver una demostración rápida here y leer más en la documentation .

Answer 7

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

Answer 8

Si puede usar cmake, entonces hay algunos enlaces en la misma web ( this y this por ejemplo). El archivo MAKU es un poco diferente de CMAKE pero nada complicado. Solo busque Google un poco y podrá encontrar muchos ejemplos de Makefile sobre cómo compilar el código AVR.

Answer 9

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

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

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