SConstruct

#!/usr/bin/python

# arscons: scons script for the Arduino sketch
# http://github.com/suapapa/arscons
#
# Copyright (C) 2010-2013 by Homin Lee <homin.lee@suapapa.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.

# You'll need the serial module: http://pypi.python.org/pypi/pyserial

# Basic Usage:
# 1. make a folder which have same name of the sketch (ex. Blink/ for Blink.pde)
# 2. put the sketch and SConstruct(this file) under the folder.
# 3. to make the HEX. do following in the folder.
#     $ scons
# 4. to upload the binary, do following in the folder.
#     $ scons upload

# Thanks to:
# * Ovidiu Predescu <ovidiu@gmail.com> and Lee Pike <leepike@gmail.com>
#     for Mac port and bugfix.
#
# This script tries to determine the port to which you have an Arduino
# attached. If multiple USB serial devices are attached to your
# computer, you'll need to explicitly specify the port to use, like
# this:
#
# $ scons ARDUINO_PORT=/dev/ttyUSB0
#
# To add your own directory containing user libraries, pass EXTRA_LIB
# to scons, like this:
#
# $ scons EXTRA_LIB=<my-extra-library-dir>
#

from glob import glob
from itertools import ifilter, imap
from os import path
from subprocess import check_call, CalledProcessError
import json
import os
import re
import sys

# arscons version
__version__ = "1.0.0"

env = Environment()
platform = env['PLATFORM']

VARTAB = {}

try:
    config = json.load(open('arscons.json'))
except IOError:
    config = None

def config_get(varname, returns):
    if config:
        result = config.get(varname, returns)
    else:
        result = returns

    return result

def resolve_var(varname, default_value):
    global VARTAB
    # precedence: scons argument -> env. variable -> json config -> default value
    ret = ARGUMENTS.get(varname, None)
    VARTAB[varname] = ('arg', ret)
    if ret == None:
        ret = os.environ.get(varname, None)
        VARTAB[varname] = ('env', ret)
    if ret == None:
        ret = config_get(varname, None)
        VARTAB[varname] = ('cnf', ret)
    if ret == None:
        ret = default_value
        VARTAB[varname] = ('dfl', ret)
    return ret

def getUsbTty(rx):
    usb_ttys = glob(rx)
    return usb_ttys[0] if len(usb_ttys) == 1 else None

AVR_BIN_PREFIX = None
AVRDUDE_BIN_PREFIX = None
AVRDUDE_CONF = None

if platform == 'darwin':
    # For MacOS X, pick up the AVR tools from within Arduino.app
    ARDUINO_HOME        = resolve_var('ARDUINO_HOME',
                                      '/Applications/Arduino.app/Contents/Resources/Java')
    ARDUINO_PORT        = resolve_var('ARDUINO_PORT', getUsbTty('/dev/tty.usbserial*'))
    SKETCHBOOK_HOME     = resolve_var('SKETCHBOOK_HOME', '')
    AVR_HOME            = resolve_var('AVR_HOME',
                                      path.join(ARDUINO_HOME, 'hardware/tools/avr/bin'))
    AVRDUDE_BIN_PREFIX  = AVR_HOME

elif platform == 'win32':
    # For Windows, use environment variables.
    ARDUINO_HOME        = resolve_var('ARDUINO_HOME', None)
    ARDUINO_PORT        = resolve_var('ARDUINO_PORT', '')
    SKETCHBOOK_HOME     = resolve_var('SKETCHBOOK_HOME', '')
    if ARDUINO_HOME:
        AVR_HOME        = resolve_var('AVR_HOME',
                                      path.join(ARDUINO_HOME, 'hardware/tools/avr/bin'))
        AVRDUDE_BIN_PREFIX  = AVR_HOME

else:
    # For Ubuntu Linux (9.10 or higher)
    ARDUINO_HOME        = resolve_var('ARDUINO_HOME', '/usr/share/arduino/')
    ARDUINO_PORT        = resolve_var('ARDUINO_PORT', getUsbTty('/dev/ttyUSB*'))
    SKETCHBOOK_HOME     = resolve_var('SKETCHBOOK_HOME',
                                      path.expanduser('~/share/arduino/sketchbook/'))
    # Left blank because on linux the files are expected to be on your path
    # avr-gcc 
    AVR_HOME            = resolve_var('AVR_HOME', '')
    AVRDUDE_BIN_PREFIX  = resolve_var('AVRDUDE_BIN_PREFIX',
                                      path.join(ARDUINO_HOME, 'hardware/tools'))


ARDUINO_BOARD   = resolve_var('ARDUINO_BOARD', 'atmega328')
ARDUINO_VER     = resolve_var('ARDUINO_VER', 0) # Default to 0 if nothing is specified
RST_TRIGGER     = resolve_var('RST_TRIGGER', None) # use built-in pulseDTR() by default
EXTRA_LIB       = resolve_var('EXTRA_LIB', None) # handy for adding another arduino-lib dir

if not ARDUINO_HOME:
    print 'ARDUINO_HOME must be defined.'
    raise KeyError('ARDUINO_HOME')

ARDUINO_CONF = path.join(ARDUINO_HOME, 'hardware/arduino/boards.txt')
# check given board name, ARDUINO_BOARD is valid one
arduino_boards = path.join(ARDUINO_HOME,'hardware/*/boards.txt')
custom_boards = path.join(SKETCHBOOK_HOME,'hardware/*/boards.txt')
board_files = glob(arduino_boards) + glob(custom_boards)
ptnBoard = re.compile(r'^([^#]*)\.name=(.*)')
boards = {}
for bf in board_files:
    for line in open(bf):
        result = ptnBoard.match(line)
        if result:
            boards[result.group(1)] = (result.group(2), bf)

if ARDUINO_BOARD not in boards:
    print "ERROR! the given board name, %s is not in the supported board list:" % ARDUINO_BOARD
    print "all available board names are:"
    for name, description in boards.iteritems():
        print "\t%s for %s" % (name.ljust(14), description[0])
    #print "however, you may edit %s to add a new board." % ARDUINO_CONF
    sys.exit(-1)

ARDUINO_CONF = boards[ARDUINO_BOARD][1]

def getBoardConf(conf, default = None):
    for line in open(ARDUINO_CONF):
        line = line.strip()
        if '=' in line:
            key, value = line.split('=')
            if key == '.'.join([ARDUINO_BOARD, conf]):
                return value
    ret = default
    if ret == None:
        print "ERROR! can't find %s in %s" % (conf, ARDUINO_CONF)
        assert(False)
    return ret

ARDUINO_CORE = path.join(ARDUINO_HOME, path.dirname(ARDUINO_CONF),
                         'cores/', getBoardConf('build.core', 'arduino'))
ARDUINO_SKEL = path.join(ARDUINO_CORE, 'main.cpp')

if ARDUINO_VER == 0:
    arduinoHeader = path.join(ARDUINO_CORE, 'Arduino.h')
    #print "No Arduino version specified. Discovered version",
    if path.exists(arduinoHeader):
        #print "100 or above"
        ARDUINO_VER = 100
    else:
        #print "0023 or below"
        ARDUINO_VER = 23
else:
    print "Arduino version " + ARDUINO_VER + " specified"

# Some OSs need bundle with IDE tool-chain
if platform == 'darwin' or platform == 'win32':
    AVRDUDE_CONF = path.join(ARDUINO_HOME, 'hardware/tools/avr/etc/avrdude.conf')
else:
    AVRDUDE_CONF = path.join(ARDUINO_HOME, 'hardware/tools/avrdude.conf')

AVR_BIN_PREFIX = path.join(AVR_HOME, 'avr-')

ARDUINO_LIBS = [path.join(ARDUINO_HOME, 'libraries')]
if EXTRA_LIB:
    ARDUINO_LIBS.append(EXTRA_LIB)
if SKETCHBOOK_HOME:
    ARDUINO_LIBS.append(path.join(SKETCHBOOK_HOME, 'libraries'))


# Override MCU and F_CPU
MCU = ARGUMENTS.get('MCU', getBoardConf('build.mcu'))
F_CPU = ARGUMENTS.get('F_CPU', getBoardConf('build.f_cpu'))

# There should be a file with the same name as the folder and
# with the extension .pde or .ino
# Or, one can specify it via the ARSCONS_TARGET environment
# variable..

TARGET = resolve_var('ARSCONS_TARGET', None)
if TARGET is None:
    TARGET = path.basename(path.realpath(os.curdir))

assert(path.exists(TARGET + '.ino') or path.exists(TARGET + '.pde'))
sketchExt = '.ino' if path.exists(TARGET + '.ino') else '.pde'

cFlags = ['-ffunction-sections', '-fdata-sections', '-fno-exceptions',
          '-funsigned-char', '-funsigned-bitfields', '-fpack-struct',
          '-fshort-enums', '-Os', '-Wall', '-mmcu=%s' % MCU]

# Add some missing paths to CFLAGS
# Workaround for /usr/libexec/gcc/avr/ld: cannot open linker script file ldscripts/avr5.x: No such file or directory
# Workaround for /usr/libexec/gcc/avr/ld: crtm168.o: No such file: No such file or directory
extra_cflags = [
    '-L/usr/x86_64-pc-linux-gnu/avr/lib/',
    '-B/usr/avr/lib/avr5/',
    ]
cFlags += extra_cflags

if ARDUINO_BOARD == "leonardo":
    cFlags += ["-DUSB_VID="+getBoardConf('build.vid')]
    cFlags += ["-DUSB_PID="+getBoardConf('build.pid')]

envArduino = Environment(CC = AVR_BIN_PREFIX + 'gcc',
                         CXX = AVR_BIN_PREFIX + 'g++',
                         AS = AVR_BIN_PREFIX + 'gcc',
                         CPPPATH = ['build/core'],
                         CPPDEFINES = {'F_CPU': F_CPU, 'ARDUINO': ARDUINO_VER},
                         CFLAGS = cFlags + ['-std=gnu99'],
                         CCFLAGS = cFlags,
                         ASFLAGS = ['-assembler-with-cpp','-mmcu=%s' % MCU],
                         TOOLS = ['gcc','g++', 'as'])

hwVariant = path.join(ARDUINO_HOME, 'hardware/arduino/variants',
                     getBoardConf("build.variant", ""))
if hwVariant:
    envArduino.Append(CPPPATH = hwVariant)

# Show version
def printVersion(target, source, env):
    print "arscons v%s"%__version__

version = envArduino.Alias('version', None, [printVersion])
AlwaysBuild(version)

def run(cmd):
    """Run a command and decipher the return code. Exit by default."""
    # print ' '.join(cmd)
    try:
        check_call(cmd)
    except CalledProcessError as cpe:
        print "Error: return code: " + str(cpe.returncode)
        sys.exit(cpe.returncode)

# WindowXP not supported path.samefile
def sameFile(p1, p2):
    if platform == 'win32':
        ap1 = path.abspath(p1)
        ap2 = path.abspath(p2)
        return ap1 == ap2
    return path.samefile(p1, p2)

def fnProcessing(target, source, env):
    wp = open(str(target[0]), 'wb')
    wp.write(open(ARDUINO_SKEL).read())

    types='''void
             int char word long
             float double byte long
             boolean
             uint8_t uint16_t uint32_t
             int8_t int16_t int32_t'''
    types=' | '.join(types.split())
    re_signature = re.compile(r"""^\s* (
        (?: (%s) \s+ )?
        \w+ \s*
        \( \s* ((%s) \s+ \*? \w+ (?:\s*,\s*)? )* \)
        ) \s* {? \s* $""" % (types, types), re.MULTILINE | re.VERBOSE)

    prototypes = {}

    for file in glob(path.realpath(os.curdir) + "/*" + sketchExt):
        for line in open(file):
            result = re_signature.search(line)
            if result:
                prototypes[result.group(1)] = result.group(2)

    for name in prototypes.iterkeys():
        print "%s;" % name
        wp.write("%s;\n" % name)

    for file in glob(path.realpath(os.curdir) + "/*" + sketchExt):
        print file, TARGET
        if not sameFile(file, TARGET + sketchExt):
            wp.write('#line 1 "%s"\r\n' % file)
            wp.write(open(file).read())

    # Add this preprocessor directive to localize the errors.
    sourcePath = str(source[0]).replace('\\', '\\\\')
    wp.write('#line 1 "%s"\r\n' % sourcePath)
    wp.write(open(str(source[0])).read())

def fnCompressCore(target, source, env):
    core_prefix = 'build/core/'.replace('/', os.path.sep)
    core_files = (x for x in imap(str, source)
                  if x.startswith(core_prefix))
    for file in core_files:
        run([AVR_BIN_PREFIX + 'ar', 'rcs', str(target[0]), file])

def fnPrintInfo(target, source, env):
    for k in VARTAB:
        cameFrom, value = VARTAB[k]
        print "* %s: %s (%s)"%(k, value, cameFrom)
    print "* avr-size:"
    run([AVR_BIN_PREFIX + 'size', '--target=ihex', str(source[0])])
    # TODO: check binary size
    print "* maximum size for hex file: %s bytes" % getBoardConf('upload.maximum_size')


bldProcessing = Builder(action = fnProcessing) #, suffix = '.cpp', src_suffix = sketchExt)
bldCompressCore = Builder(action = fnCompressCore)
bldELF = Builder(action = AVR_BIN_PREFIX + 'gcc -mmcu=%s ' % MCU +
                          '-Os -Wl,--gc-sections -lm %s -o $TARGET $SOURCES -lc' % ' '.join(extra_cflags))
bldHEX = Builder(action = AVR_BIN_PREFIX + 'objcopy -O ihex -R .eeprom $SOURCES $TARGET')
bldInfo = Builder(action = fnPrintInfo)

envArduino.Append(BUILDERS = {'Processing' : bldProcessing})
envArduino.Append(BUILDERS = {'CompressCore': bldCompressCore})
envArduino.Append(BUILDERS = {'Elf' : bldELF})
envArduino.Append(BUILDERS = {'Hex' : bldHEX})
envArduino.Append(BUILDERS = {'BuildInfo' : bldInfo})

ptnSource = re.compile(r'\.(?:c(?:pp)?|S)$')
def gatherSources(srcpath):
    return [path.join(srcpath, f) for f
            in os.listdir(srcpath) if ptnSource.search(f)]

# add arduino core sources
VariantDir('build/core', ARDUINO_CORE)
core_sources = gatherSources(ARDUINO_CORE)
core_sources = [x.replace(ARDUINO_CORE, 'build/core/') for x
                in core_sources if path.basename(x) != 'main.cpp']

# add libraries
libCandidates = []
ptnLib = re.compile(r'^[ ]*#[ ]*include [<"](.*)\.h[>"]')
for line in open(TARGET + sketchExt):
    result = ptnLib.search(line)
    if not result:
        continue
    # Look for the library directory that contains the header.
    filename = result.group(1) + '.h'
    for libdir in ARDUINO_LIBS:
        for root, dirs, files in os.walk(libdir, followlinks=True):
            if filename in files:
                libCandidates.append(path.basename(root))

# Hack. In version 20 of the Arduino IDE, the Ethernet library depends
# implicitly on the SPI library.
if ARDUINO_VER >= 20 and 'Ethernet' in libCandidates:
    libCandidates.append('SPI')

all_libs_sources = []
for index, orig_lib_dir in enumerate(ARDUINO_LIBS):
    lib_dir = 'build/lib_%02d' % index
    VariantDir(lib_dir, orig_lib_dir)
    for libPath in ifilter(path.isdir, glob(path.join(orig_lib_dir, '*'))):
        libName = path.basename(libPath)
        if not libName in libCandidates:
            continue
        envArduino.Append(CPPPATH = libPath.replace(orig_lib_dir, lib_dir))
        lib_sources = gatherSources(libPath)
        utilDir = path.join(libPath, 'utility')
        if path.exists(utilDir) and path.isdir(utilDir):
            lib_sources += gatherSources(utilDir)
            envArduino.Append(CPPPATH = utilDir.replace(orig_lib_dir, lib_dir))
        lib_sources = (x.replace(orig_lib_dir, lib_dir) for x in lib_sources)
        all_libs_sources.extend(lib_sources)

# Add raw sources which live in sketch dir.
build_top = path.realpath('.')
VariantDir('build/local/', build_top)
local_sources = gatherSources(build_top)
local_sources = [x.replace(build_top, 'build/local/') for x in local_sources]
if local_sources:
    envArduino.Append(CPPPATH = 'build/local')

# Convert sketch(.pde) to cpp
envArduino.Processing('build/' + TARGET + '.cpp', 'build/' + TARGET + sketchExt)
VariantDir('build', '.')

sources = ['build/' + TARGET + '.cpp']
#sources += core_sources
sources += local_sources
sources += all_libs_sources

# Finally Build!!
core_objs = envArduino.Object(core_sources)
objs = envArduino.Object(sources) #, LIBS=libs, LIBPATH='.')
objs = objs + envArduino.CompressCore('build/core.a', core_objs)
envArduino.Elf(TARGET + '.elf', objs)
envArduino.Hex(TARGET + '.hex', TARGET + '.elf')
envArduino.BuildInfo(None, TARGET + '.hex')

# Reset
def pulseDTR(target, source, env):
    import serial
    import time
    ser = serial.Serial(ARDUINO_PORT)
    ser.setDTR(1)
    time.sleep(0.5)
    ser.setDTR(0)
    ser.close()

if RST_TRIGGER:
    reset_cmd = '%s %s' % (RST_TRIGGER, ARDUINO_PORT)
else:
    reset_cmd = pulseDTR

# Upload
UPLOAD_PROTOCOL = getBoardConf('upload.protocol')
UPLOAD_SPEED = getBoardConf('upload.speed')

if UPLOAD_PROTOCOL == 'stk500':
    UPLOAD_PROTOCOL = 'stk500v1'


avrdudeOpts = ['-V', '-F', '-c %s' % UPLOAD_PROTOCOL, '-b %s' % UPLOAD_SPEED,
               '-p %s' % MCU, '-P %s' % ARDUINO_PORT, '-U flash:w:$SOURCES']
if AVRDUDE_CONF:
    avrdudeOpts.append('-C %s' % AVRDUDE_CONF)

fuse_cmd = '%s %s' % (path.join(AVRDUDE_BIN_PREFIX, 'avrdude'),
                      ' '.join(avrdudeOpts))

upload = envArduino.Alias('upload', TARGET + '.hex', [reset_cmd, fuse_cmd])
AlwaysBuild(upload)

# Clean build directory
envArduino.Clean('all', 'build/')

# vim: et sw=4 fenc=utf-8: