linux - recuperar - proteger codigo arduino
Línea de comandos Arduino compilando y descargando? (9)
¿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?
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.
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
Hay un juego de herramientas Arduino de línea de comandos llamado Ino . Simplemente hace eso.
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]
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.
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 .
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.
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)