info@naparlinex.com
Para que funcione esto tendrás que hacer un directorio con el nombre del proyecto (como lo haría el IDE del arduino). Dentro de ese directorio pones este makefile, revisas que las direcciones de los directorios que contiene este makefile se corresponden con las de tu ordenador y ya estás preparado para usarlo.
Las instrucciones de como compilar están al final de makefile, pero básicamente es hacer un make, como si fuera un programa C normal y si no hay errores, hacer un make upload.
Si no te sale a la primera pues es cuestión de revisar bien los directorios y probar de nuevo.
Como cada cosa nueva en programación, tendrás que probar, estudiar, probar, estudiar, probar, leer algo en intenet, probar, estudiar, probar...
Un último apunte, recuerda que hemos puesto una tarjetita con un botón en el arduino. Si tienes pulsado el botón, el reset estará desactivado y el arduino no cargará el programa. Esto vale también si lo haces desde el IDE.
#Vidal 2013
#Makefile para compliar desde la linea de comandos para arduino
#Basado en el makefile.mk de Tim Marston ( http://ed.am/dev/make/arduino-mk)
#El makefile original esta en el directorio programas y funciona perfectamente. 
#Pero yo le he he cambiado un par de cositas (están marcadas) 

#----------------------------------------------------------------------------------------
#Esta la defino yo aquí. Es la que creo que tiene mi arduino
#----------------------------------------------------------------------------------------
BOARD = atmega328

#----------------------------------------------------------------------------------------
# directorio por defecto del arduino
# lo he puesto fijo por que en este ordenador solo está en un sitio
#----------------------------------------------------------------------------------------
ARDUINODIR = /usr/share/arduino

#----------------------------------------------------------------------------------------
# default arduino version
#----------------------------------------------------------------------------------------
ARDUINOCONST = 100

#----------------------------------------------------------------------------------------
# el path por defecto de avr tools
#---------------------------------------------------------------------------------------
AVRTOOLSPATH = $(subst :, , $(PATH)) $(ARDUINODIR)/hardware/tools $(ARDUINODIR)/hardware/tools/avr/bin

#----------------------------------------------------------------------------------------
# donde se pueden bscar librerias
#el SKETCHBOOKDIR en el original (.mk) aquí no tenia valor y se buscaba valor mas abajo
#Asi que yo se lo he puesto fijo 
#----------------------------------------------------------------------------------------

SKETCHBOOKDIR = $(HOME)/sketchbook
LIBRARYPATH = libraries libs $(SKETCHBOOKDIR)/libraries $(ARDUINODIR)/libraries

#----------------------------------------------------------------------------------------
# default serial device to a poor guess (something that might be an arduino)
#----------------------------------------------------------------------------------------
SERIALDEVGUESS := 0
ifndef SERIALDEV
SERIALDEV := $(firstword $(wildcard \
	/dev/ttyACM? /dev/ttyUSB? /dev/tty.usbserial* /dev/tty.usbmodem*))
SERIALDEVGUESS := 1
endif

#----------------------------------------------------------------------------------------------
# Los parametros de la tarjeta desde el fichero boards.txt 
# Hacen falta para luego los FLAGS del avr-gcc 
# readboardsparam = $(shell sed -ne "s/$(BOARD).$(1)=\(.*\)/\1/p" $(BOARDSFILE)) # Esta lo que hace es
# cargar en readboardasparam la intruccion del shell sed y sed lo que hace es sustituir $BOARD Y $(1)
# por los comandos que se ponen luego en el call (algo rebuscado pero efica) 
#----------------------------------------------------------------------------------------------
BOARDSFILE := $(ARDUINODIR)/hardware/arduino/boards.txt
readboardsparam = $(shell sed -ne "s/$(BOARD).$(1)=\(.*\)/\1/p" $(BOARDSFILE))
BOARD_BUILD_MCU = $(call readboardsparam,build.mcu)
BOARD_BUILD_FCPU := $(call readboardsparam,build.f_cpu)
BOARD_BUILD_VARIANT := $(call readboardsparam,build.variant)

#$(call readboardsparam,upload.speed)
#Le he cambiado la velocidad del serie a la que o quiero y no se corresponde con la del board.txt 
BOARD_UPLOAD_SPEED := 115200 

BOARD_UPLOAD_PROTOCOL := $(call readboardsparam,upload.protocol)
BOARD_USB_VID := $(call readboardsparam,build.vid)
BOARD_USB_PID := $(call readboardsparam,build.pid)
BOARD_BOOTLOADER_UNLOCK := $(call readboardsparam,bootloader.unlock_bits)
BOARD_BOOTLOADER_LOCK := $(call readboardsparam,bootloader.lock_bits)
BOARD_BOOTLOADER_LFUSES := $(call readboardsparam,bootloader.low_fuses)
BOARD_BOOTLOADER_HFUSES := $(call readboardsparam,bootloader.high_fuses)
BOARD_BOOTLOADER_EFUSES := $(call readboardsparam,bootloader.extended_fuses)
BOARD_BOOTLOADER_PATH := $(call readboardsparam,bootloader.path)
BOARD_BOOTLOADER_FILE := $(call readboardsparam,bootloader.file)

#----------------------------------------------------------------------------------------
# Si no se encuentra esta variable es que hay algun problema con el AVR seleccionado 
#----------------------------------------------------------------------------------------
ifeq "$(BOARD_BUILD_MCU)" ""
ifneq "$(MAKECMDGOALS)" "boards"
ifneq "$(MAKECMDGOALS)" "clean"
$(error ¿Seguro que es ese chip?. make boards te da una lista)
endif
endif
endif

#----------------------------------------------------------------------------------------
# comprueba que no haya más de un "ino" en el directorio
# (para que sea compatible con el IDE de arduino) 
#----------------------------------------------------------------------------------------
#INOFILE := $(wildcard *.ino *.pde)
INOFILE := $(wildcard *.ino)
ifdef INOFILE
ifneq "$(words $(INOFILE))" "1"
$(error Hay mas de un .ino en este directorio!) 
endif

#----------------------------------------------------------------------------------------
#Se saca el nombre de mi proyecto y se crea el tarjet y los sources que se van a compilar
#----------------------------------------------------------------------------------------
TARGET := $(basename $(INOFILE))
SOURCES := $(INOFILE) \
	$(wildcard *.c *.cc *.cpp *.C) \
	$(wildcard $(addprefix util/, *.c *.cc *.cpp *.C)) \
	$(wildcard $(addprefix utility/, *.c *.cc *.cpp *.C))

#----------------------------------------------------------------------------------------
# automatically determine included libraries
#----------------------------------------------------------------------------------------
LIBRARIES := $(filter $(notdir $(wildcard $(addsuffix /*, $(LIBRARYPATH)))), \
	$(shell sed -ne "s/^ *\# *include *[>\"]\(.*\)\.h[>\"]/\1/p" $(SOURCES)))

endif

#----------------------------------------------------------------------------------------
# software
#----------------------------------------------------------------------------------------
findsoftware = $(firstword $(wildcard $(addsuffix /$(1), $(AVRTOOLSPATH))))
CC := $(call findsoftware,avr-gcc)
CXX := $(call findsoftware,avr-g++)
LD := $(call findsoftware,avr-ld)
AR := $(call findsoftware,avr-ar)
OBJCOPY := $(call findsoftware,avr-objcopy)
AVRDUDE := $(call findsoftware,avrdude)
AVRSIZE := $(call findsoftware,avr-size)

#----------------------------------------------------------------------------------------
# directories
#----------------------------------------------------------------------------------------
ARDUINOCOREDIR := $(ARDUINODIR)/hardware/arduino/cores/arduino
LIBRARYDIRS := $(foreach lib, $(LIBRARIES), \
	$(firstword $(wildcard $(addsuffix /$(lib), $(LIBRARYPATH)))))
LIBRARYDIRS += $(addsuffix /utility, $(LIBRARYDIRS))

#----------------------------------------------------------------------------------------
#ficheros a compilar
#----------------------------------------------------------------------------------------
TARGET := $(if $(TARGET),$(TARGET),a.out)
OBJECTS := $(addsuffix .o, $(basename $(SOURCES)))
DEPFILES := $(patsubst %, .dep/%.dep, $(SOURCES))
ARDUINOLIB := .lib/arduino.a
ARDUINOLIBOBJS := $(foreach dir, $(ARDUINOCOREDIR) $(LIBRARYDIRS), \
	$(patsubst %, .lib/%.o, $(wildcard $(addprefix $(dir)/, *.c *.cpp))))
BOOTLOADERHEX := $(addprefix \
	$(ARDUINODIR)/hardware/arduino/bootloaders/$(BOARD_BOOTLOADER_PATH)/, \
	$(BOARD_BOOTLOADER_FILE))
#----------------------------------------------------------------------------------------
# configuracion avrdude 
#----------------------------------------------------------------------------------------
ifeq "$(AVRDUDECONF)" ""
ifeq "$(AVRDUDE)" "$(ARDUINODIR)/hardware/tools/avr/bin/avrdude"
AVRDUDECONF := $(ARDUINODIR)/hardware/tools/avr/etc/avrdude.conf
else
AVRDUDECONF := $(wildcard $(AVRDUDE).conf)
endif
endif

#----------------------------------------------------------------------------------------
# flags
#----------------------------------------------------------------------------------------
CPPFLAGS += -Os -Wall -fno-exceptions -ffunction-sections -fdata-sections
CPPFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CPPFLAGS += -mmcu=$(BOARD_BUILD_MCU)
CPPFLAGS += -DF_CPU=$(BOARD_BUILD_FCPU) -DARDUINO=$(ARDUINOCONST)
CPPFLAGS += -DUSB_VID=$(BOARD_USB_VID) -DUSB_PID=$(BOARD_USB_PID)
CPPFLAGS += -I. -Iutil -Iutility -I $(ARDUINOCOREDIR)
CPPFLAGS += -I $(ARDUINODIR)/hardware/arduino/variants/$(BOARD_BUILD_VARIANT)/
CPPFLAGS += $(addprefix -I , $(LIBRARYDIRS))
CPPDEPFLAGS = -MMD -MP -MF .dep/$<.dep
CPPINOFLAGS := -x c++ -include $(ARDUINOCOREDIR)/Arduino.h
AVRDUDEFLAGS += $(addprefix -C , $(AVRDUDECONF)) -DV
AVRDUDEFLAGS += -p $(BOARD_BUILD_MCU) -P $(SERIALDEV)
AVRDUDEFLAGS += -c $(BOARD_UPLOAD_PROTOCOL) -b $(BOARD_UPLOAD_SPEED)
LINKFLAGS += -Os -Wl,--gc-sections -mmcu=$(BOARD_BUILD_MCU)

#----------------------------------------------------------------------------------------
# figure out which arg to use with stty (for OS X, GNU and busybox stty)
#----------------------------------------------------------------------------------------
STTYFARG := $(shell stty --help 2<&1 | \
	grep -q 'illegal option' && echo -f || echo -F)

#----------------------------------------------------------------------------------------
# include dependencies
#----------------------------------------------------------------------------------------
ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEPFILES)
endif

#----------------------------------------------------------------------------------------
# default rule
#----------------------------------------------------------------------------------------
.DEFAULT_GOAL := all

#_______________________________________________________________________________
#                                                                          RULES

.PHONY:	all target upload clean boards monitor size bootloader

all: clear target

clear:
	clear

display: 
	@echo "\n\n "
	
	@echo "el ARDUINODIR: " $(ARDUINODIR)
	@echo "el ARDUINOCONST: " $(ARDUINOCONST)
	@echo "el AVRTOOLSPATH: " $(AVRTOOLSPATH)
	@echo "el LIBRARYPATH: " $(LIBRARYPATH)
	@echo "el SJATCHBOOKDIR: " $(SKETCHBOOKDIR)
	@echo "el BOARDSFILE: " $(BOARDSFILE)
	@echo "el readboardsparam: " $(readboardsparam)
	@echo "el call " $(call readboardsparam,upload.speed)
	@echo "el findsoftware: " $(findsoftware)
	@echo "el CC: " $(CC)
	@echo "el OBJECTS: " $(OBJECTS)
	@echo "el DEPFILES: " $(DEPFILES)
	@echo "el TARGET: " $(TARGET) 
	@echo "el SOURCES " $(SOURCES) 
	@echo "el BOARD_BOOTLOADER_PATH " $(BOARD_BOOTLOADER_PATH) 
	@echo "el AVRDUDEFLAGS " $(AVRDUDEFLAGS) 
	@echo "\n\n"

target: $(TARGET).hex

upload: target
	@echo "\nEnviando al arduino..."
	@test -n "$(SERIALDEV)" || { \
		echo "error: SERIALDEV could not be determined automatically.">&2; \
		exit 1; }
	@test 0 -eq $(SERIALDEVGUESS) || { \
		echo "*GUESSING* at serial device:" $(SERIALDEV); \
		echo; }
	stty $(STTYFARG) $(SERIALDEV) hupcl
	$(AVRDUDE) $(AVRDUDEFLAGS) -U flash:w:$(TARGET).hex:i

clean:
	rm -f $(OBJECTS)
	rm -f $(TARGET).elf $(TARGET).hex $(ARDUINOLIB) *~
	rm -rf .lib .dep

boards:
	@echo "Available values for BOARD:"
	@sed -nEe '/^#/d; /^[^.]+\.name=/p' $(BOARDSFILE) | \
		sed -Ee 's/([^.]+)\.name=(.*)/\1            \2/' \
			-e 's/(.{12}) *(.*)/\1 \2/'

monitor:
	@test -n "$(SERIALDEV)" || { \
		echo "error: SERIALDEV could not be determined automatically.">&2; \
		exit 1; }
	@test -n `which screen` || { \
		echo "error: can't find GNU screen, you might need to install it."
		>&2 \
		exit 1; }
	@test 0 -eq $(SERIALDEVGUESS) || { \
		echo "*GUESSING* at serial device:" $(SERIALDEV); \
		echo; }
	screen $(SERIALDEV)

size: $(TARGET).elf
	echo && $(AVRSIZE) --format=avr --mcu=$(BOARD_BUILD_MCU) $(TARGET).elf

bootloader:
	@echo "Burning bootloader to board..."
	@test -n "$(SERIALDEV)" || { \
		echo "error: SERIALDEV could not be determined automatically.">&2; \
		exit 1; }
	@test 0 -eq $(SERIALDEVGUESS) || { \
		echo "*GUESSING* at serial device:" $(SERIALDEV); \
		echo; }
	stty $(STTYFARG) $(SERIALDEV) hupcl
	$(AVRDUDE) $(AVRDUDEFLAGS) -U lock:w:$(BOARD_BOOTLOADER_UNLOCK):m
	$(AVRDUDE) $(AVRDUDEFLAGS) -eU lfuse:w:$(BOARD_BOOTLOADER_LFUSES):m
	$(AVRDUDE) $(AVRDUDEFLAGS) -U hfuse:w:$(BOARD_BOOTLOADER_HFUSES):m
ifneq "$(BOARD_BOOTLOADER_EFUSES)" ""
	$(AVRDUDE) $(AVRDUDEFLAGS) -U efuse:w:$(BOARD_BOOTLOADER_EFUSES):m
endif
ifneq "$(BOOTLOADERHEX)" ""
	$(AVRDUDE) $(AVRDUDEFLAGS) -U flash:w:$(BOOTLOADERHEX):i
endif
	$(AVRDUDE) $(AVRDUDEFLAGS) -U lock:w:$(BOARD_BOOTLOADER_LOCK):m

# building the target

$(TARGET).hex: $(TARGET).elf
	$(OBJCOPY) -O ihex -R .eeprom $< $@

.INTERMEDIATE: $(TARGET).elf

$(TARGET).elf: $(ARDUINOLIB) $(OBJECTS)
	$(CC) $(LINKFLAGS) $(OBJECTS) $(ARDUINOLIB) -lm -o $@

%.o: %.c
	mkdir -p .dep/$(dir $<)
	$(COMPILE.c) $(CPPDEPFLAGS) -o $@ $<

%.o: %.cpp
	mkdir -p .dep/$(dir $<)
	$(COMPILE.cpp) $(CPPDEPFLAGS) -o $@ $<

%.o: %.cc
	mkdir -p .dep/$(dir $<)
	$(COMPILE.cpp) $(CPPDEPFLAGS) -o $@ $<

%.o: %.C
	mkdir -p .dep/$(dir $<)
	$(COMPILE.cpp) $(CPPDEPFLAGS) -o $@ $<

%.o: %.ino
	mkdir -p .dep/$(dir $<)
	$(COMPILE.cpp) $(CPPDEPFLAGS) -o $@ $(CPPINOFLAGS) $<

%.o: %.pde
	mkdir -p .dep/$(dir $<)
	$(COMPILE.cpp) $(CPPDEPFLAGS) -o $@ $(CPPINOFLAGS) $<

# building the arduino library

$(ARDUINOLIB): $(ARDUINOLIBOBJS)
	$(AR) rcs $@ $?

.lib/%.c.o: %.c
	mkdir -p $(dir $@)
	$(COMPILE.c) -o $@ $<

.lib/%.cpp.o: %.cpp
	mkdir -p $(dir $@)
	$(COMPILE.cpp) -o $@ $<

.lib/%.cc.o: %.cc
	mkdir -p $(dir $@)
	$(COMPILE.cpp) -o $@ $<

.lib/%.C.o: %.C
	mkdir -p $(dir $@)
	$(COMPILE.cpp) -o $@ $<

# Local Variables:
# mode: makefile
# tab-width: 4
# End: