Kaleidoscope/etc/kaleidoscope-builder.conf

# -*- shell-script -*-

## NEEDS: LIBRARY, SKETCH, ROOT, SOURCEDIR
## Should be included when the current directory is the dir of the Sketch.

SKETCH="${SKETCH:-${DEFAULT_SKETCH}}"
LIBRARY="${LIBRARY:-${SKETCH}}"

########
######## Keyboard hardware definitions
########

BOARD="${BOARD:-model01}"
MCU="${MCU:-atmega32u4}"

if [ -z "${ARCH}" ]; then
   ARCH=$(echo "${FQBN}" | sed -n -e 's/^[^:]\+:\([^:]\+\).*/\1/p')
fi

if [ "${ARCH}" = "virtual" ]; then
    FQBN="${FQBN:-keyboardio:virtual:${BOARD}}"

    # Set the compiler path for virtual builds
    #
    if [ -z "${COMPILER_PATH}" ]; then
       COMPILER_PATH="/usr/bin/"
    fi

    if [ "${COMPILER_PREFIX}" = "avr-" ]; then
        COMPILER_PREFIX=""
    fi
else
   ARCH="avr"
fi

if [ -z "${FQBN}" ]; then
   FQBN="${FQBN:-keyboardio:avr:${BOARD}}"
fi

########
######## Host OS specific commands
########

## Platform-specific overrides
# Shamelessly stolen from git's Makefile
uname_S=$(uname -s 2>/dev/null || echo not)
uname_O=$(uname -o 2>/dev/null || echo not)


find_max_prog_size() {
    MAX_PROG_SIZE=${MAX_PROG_SIZE:-$(get_arduino_pref 'upload.maximum_size')}

}

find_device_vid_pid() {
    VID=${VID:-$(get_arduino_pref 'build.vid')}
    SKETCH_PID=${SKETCH_PID:-$(get_arduino_pref 'build.pid')}
    BOOTLOADER_PID=${BOOTLOADER_PID:-$(get_arduino_pref 'bootloader.pid')}
    BOOTLOADER_VID=${BOOTLOADER_VID:-$(get_arduino_pref 'bootloader.vid')}
}


get_arduino_pref() {
	pref=$1
	# Strip the preference name. And then strip leading and trailing quotations
	MESSAGE=$(dump_arduino_prefs | grep --max-count=1 ${pref}= | sed -e s/^.*${pref}=// -e 's/^"//' -e 's/"$//')
	echo $MESSAGE
}


dump_arduino_prefs() {
# SKETCH and -build-path in this command are here because of a bug introduced in Arduino 1.8.10
# https://github.com/arduino/arduino-builder/issues/341
    if [ "x${_ARDUINO_PREFS}x" == "xx" ]; then

	    _ARDUINO_PREFS=$("${ARDUINO_BUILDER}" \
		-hardware "${ARDUINO_PATH}/hardware" \
		-hardware "${BOARD_HARDWARE_PATH}" \
		${ARDUINO_TOOLS_FLAG:+"${ARDUINO_TOOLS_FLAG}"} ${ARDUINO_TOOLS_PARAM:+"${ARDUINO_TOOLS_PARAM}"} \
		-tools "${ARDUINO_PATH}/tools-builder" \
		-fqbn "${FQBN}" \
	 	-build-path "${ARDUINO_PATH}" \
   		-dump-prefs  "${SKETCH_DIR}/${SKETCH}.ino" )
    fi
    echo "$_ARDUINO_PREFS"

}

find_device_port() {
    find_device_vid_pid
    DIR=$(dirname "$(readlink -f "$0")")
    DEVICE_PORT_PROBER="${DIR}/find-device-port-linux-udev"
    if [[ "${DEVICE_PORT}" = "" ]]; then
      DEVICE_PORT="$(perl ${DEVICE_PORT_PROBER} ${VID} ${SKETCH_PID})"
    else
      echo "DEVICE_PORT=\"${DEVICE_PORT}\" predefined."
    fi
}

reset_device_cmd() {
    if [ -z ${NO_RESET} ]; then
        stty -F ${DEVICE_PORT} 1200 hupcl
    fi
}

find_bootloader_ports() {
    find_device_vid_pid
    DIR=$(dirname "$(readlink -f "$0")")
    BOOTLOADER_VID="${BOOTLOADER_VID:-${VID}}"
    DEVICE_PORT_PROBER="${DIR}/find-device-port-linux-udev"
    if [[ "${DEVICE_PORT_BOOTLOADER}" = "" ]]; then
      DEVICE_PORT_BOOTLOADER="$(perl ${DEVICE_PORT_PROBER} ${BOOTLOADER_VID} ${BOOTLOADER_PID})"
    else
      echo "DEVICE_PORT_BOOTLOADER=\"${DEVICE_PORT_BOOTLOADER}\" predefined."
    fi
}

find_bootloader_path() {
    BOOTLOADER_FILE=$( get_arduino_pref 'bootloader.file' )
    BOOTLOADER_FILE="${BOOTLOADER_FILE:-caterina/Caterina.hex}"
    BOOTLOADER_PATH="${BOOTLOADER_PATH:-${BOARD_HARDWARE_PATH}/keyboardio/avr/bootloaders/${BOOTLOADER_FILE}}"
}

MD5="md5sum"

if [ "${uname_S}" = "Darwin" ]; then

    find_device_port() {
	DIR=$(dirname "$0")
	DEVICE_PORT_PROBER="${DIR}/find-device-port-macos"
        DEVICE_PORT="$(perl ${DEVICE_PORT_PROBER} ${VID} ${SKETCH_PID})"
    }

    reset_device_cmd() {
	/bin/stty -f ${DEVICE_PORT} 1200
    }

    ARDUINO_PATH="${ARDUINO_PATH:-/Applications/Arduino.app/Contents/Java/}"
    ARDUINO_PACKAGE_PATH="${ARDUINO_PACKAGE_PATH:-${HOME}/Library/Arduino15/packages}"
    ARDUINO_LOCAL_LIB_PATH="${ARDUINO_LOCAL_LIB_PATH:-${HOME}/Documents/Arduino}"

    MD5="md5"

    find_bootloader_ports() {
        find_device_vid_pid
	DIR=$(dirname "$0")
        BOOTLOADER_VID="${BOOTLOADER_VID:-${VID}}"
	DEVICE_PORT_PROBER="${DIR}/find-device-port-macos"
        if [[ "${DEVICE_PORT_BOOTLOADER}" = "" ]]; then
          DEVICE_PORT_BOOTLOADER="$(perl ${DEVICE_PORT_PROBER} ${BOOTLOADER_VID} ${BOOTLOADER_PID})"
        else
          echo "DEVICE_PORT_BOOTLOADER=\"${DEVICE_PORT_BOOTLOADER}\" predefined."
        fi
    }

    if [ "${ARCH}" = "virtual" ]; then
        COMPILER_PREFIX="x86_64-apple-darwin19-"
        COMPILER_SUFFIX="-10"
        AR_BASENAME="gcc-ar"
    fi

elif [ "${uname_S}" = "FreeBSD" ]; then

    find_device_port() {
	DIR=$(dirname "$0")
	DEVICE_PORT_PROBER="${DIR}/find-device-port-freebsd"
	DEVICE_PORT="$(perl ${DEVICE_PORT_PROBER})"
    }

    reset_device_cmd() {
	/bin/stty -f ${DEVICE_PORT} 1200
    }

    MD5="md5"
    AVR_SIZE="${AVR_SIZE:-/usr/local/bin/avr-size}"
    AVR_NM="${AVR_NM:-/usr/local/bin/avr-nm}"
    AVR_OBJDUMP="${AVR_OBJDUMP:-/usr/local/bin/avr-objdump}"
    AVRDUDE="${AVRDUDE:-/usr/local/bin/avrdude}"
    AVRDUDE_CONF="${AVRDUDE_CONF:-/usr/local/etc/avrdude.conf}"
    ARDUINO_BUILDER="${ARDUINO_BUILDER:-/usr/local/bin/arduino-builder}"

    find_bootloader_ports() {
	DIR=$(dirname "$0")
	DEVICE_PORT_PROBER="${DIR}/find-device-port-freebsd"
	DEVICE_PORT_BOOTLOADER="$(perl ${DEVICE_PORT_PROBER})"
    }

    if [ "${ARCH}" = "virtual" ]; then
        COMPILER_PATH="${COMPILER_PATH:-/usr/local/bin/}"
    fi

elif [ "${uname_O}" = "Cygwin" ]; then
    # The Windows arduino-builder.exe doesn't understand being told to exec against Cygwin symlinks
    CCACHE_NOT_SUPPORTED=1

    # Note: the default ARDUINO_PATH here is the default Arduino installation path on Windows, but it won't actually
    # work in practice right now since we haven't fixed all bugs related to interpretation of spaces in these paths.
    #
    # It's important that all of these be underneath /cygdrive/c so they can be converted to Windows paths that the
    # Windows Arduino binaries can understand.
    ARDUINO_PATH="${ARDUINO_PATH:-/cygdrive/c/Program\ Files\ (x86)/Arduino}"
    ARDUINO_PACKAGE_PATH="${ARDUINO_PACKAGE_PATH:-/cygdrive/c/Users/${USER}/AppData/Local/Arduino15/packages}"
    ARDUINO_LOCAL_LIB_PATH="${ARDUINO_LOCAL_LIB_PATH:-/cygdrive/c/Users/${USER}/Arduino}"
    TMPDIR="${ARDUINO_LOCAL_LIB_PATH:-/cygdrive/c/Users/${USER}/AppData/Local/Temp}"

    # We need to prevent Windows executables from being passed parameters that are absolute paths, since they won't
    # be interpretable when of the form /cygdrive/c/foo. To work around this, we set the common path root variables
    # to use relative paths instead of absolute paths, since those have mostly platform-agnostic behavior.
    #
    # Note that this trick requires that all of these paths exist on the same drive letter as the current directory,
    # since otherwise even the relative paths would include Cygwin-specific components. So...
    if [[ $(realpath --relative-base=/cygdrive/c .) == /* ]]; then
        echo "kaleidoscope-builder's Cygwin support is currently limited to running from within /cygdrive/c"
        exit 1
    fi

    ARDUINO_PATH="$(realpath --relative-to=./ ${ARDUINO_PATH})"
    ARDUINO_PACKAGE_PATH="$(realpath --relative-to=./ ${ARDUINO_PACKAGE_PATH})"
    ARDUINO_LOCAL_LIB_PATH="$(realpath --relative-to=./ ${ARDUINO_LOCAL_LIB_PATH})"
    ROOT="$(realpath --relative-to=./ ${ROOT})"
    export ROOT
    TMPDIR="$(realpath --relative-to=./ ${ARDUINO_PATH})"

    find_device_port() {
        find_device_vid_pid
        DIR=$(dirname "$0")
        DEVICE_PORT_PROBER="${DIR}/find-device-port-windows.ps1"
        DEVICE_PORT="$(powershell -noprofile -executionpolicy bypass ${DEVICE_PORT_PROBER} ${VID} ${SKETCH_PID} -Format Cygwin)"
        DEVICE_COM_PORT="$(powershell -noprofile -executionpolicy bypass ${DEVICE_PORT_PROBER} ${VID} ${SKETCH_PID} -Format COM)"
    }

    reset_device_cmd() {
        cmd /c mode ${DEVICE_COM_PORT} baud=1200
    }

    find_bootloader_ports() {
        find_device_vid_pid
        DIR=$(dirname "$0")
        BOOTLOADER_VID="${BOOTLOADER_VID:-${VID}}"
        DEVICE_PORT_PROBER="${DIR}/find-device-port-windows.ps1"
        DEVICE_PORT_BOOTLOADER="$(powershell -noprofile -executionpolicy bypass ${DEVICE_PORT_PROBER} ${BOOTLOADER_VID} ${BOOTLOADER_PID} -Format COM)"
    }

fi

######
###### Arduino tools configuration
######

ARDUINO_PATH="${ARDUINO_PATH:-/usr/local/arduino}"
ARDUINO_LOCAL_LIB_PATH="${ARDUINO_LOCAL_LIB_PATH:-${HOME}/Arduino}"
ARDUINO_TOOLS_PATH="${ARDUINO_TOOLS_PATH:-${ARDUINO_PATH}/hardware/tools}"
ARDUINO_PACKAGE_PATH="${ARDUINO_PACKAGE_PATH:-${HOME}/.arduino15/packages}"

ARDUINO_BUILDER="${ARDUINO_BUILDER:-${ARDUINO_PATH}/arduino-builder}"
ARDUINO_IDE_VERSION="10607"

######
###### Executable paths
######

# Allow the compiler path to be empty for virtual builds
COMPILER_PATH="${COMPILER_PATH-${ARDUINO_TOOLS_PATH}/avr/bin/}"

C_COMPILER_BASENAME="${C_COMPILER_BASENAME:-$(basename ${CC:-gcc})}"
CXX_COMPILER_BASENAME="${CXX_COMPILER_BASENAME:-$(basename ${CXX:-g++})}"
AR_BASENAME="${AR_BASENAME:-$(basename ${AR:-ar})}"
OBJCOPY_BASENAME="${OBJCOPY_BASENAME:-$(basename ${OBJCOPY:-objcopy})}"

# Allow the compiler prefix to be empty for virtual builds
COMPILER_PREFIX="${COMPILER_PREFIX-avr-}"
AVR_SIZE="${AVR_SIZE:-${COMPILER_PATH}/${COMPILER_PREFIX}size}"
AVR_SIZE_FLAGS="${AVR_SIZE_FLAGS:--C --mcu=${MCU}}"
AVR_OBJDUMP="${AVR_OBJDUMP:-${COMPILER_PATH}/${COMPILER_PREFIX}objdump}"
AVR_OBJCOPY="${AVR_OBJCOPY:-${COMPILER_PATH}/${COMPILER_PREFIX}objcopy}"
AVR_NM="${AVR_NM:-${COMPILER_PATH}/${COMPILER_PREFIX}nm}"
AVR_AR="${AVR_AR:-${COMPILER_PATH}/${COMPILER_PREFIX}ar}"
AVR_GCC="${AVR_GCC:-${COMPILER_PATH}/${COMPILER_PREFIX}${C_COMPILER_BASENAME}}"
AVR_GPLUSPLUS="${AVR_GCC:-${COMPILER_PATH}/${COMPILER_PREFIX}${CXX_COMPILER_BASENAME}}"



AVRDUDE="${AVRDUDE:-${ARDUINO_TOOLS_PATH}/avr/bin/avrdude}"
AVRDUDE_CONF="${AVRDUDE_CONF:-${ARDUINO_TOOLS_PATH}/avr/etc/avrdude.conf}"

######
###### Source files and dependencies
######

BOARD_HARDWARE_PATH="${BOARD_HARDWARE_PATH:-${ARDUINO_LOCAL_LIB_PATH}/hardware}"

if [ ! -z "${ARDUINO_TOOLS_PATH}" ]; then
    ARDUINO_TOOLS_PARAM="${ARDUINO_TOOLS_PATH}"
    ARDUINO_TOOLS_FLAG="-tools"
fi

if [ ! -z "${AVR_GCC_PREFIX}" ]; then
    ARDUINO_AVR_GCC_PREFIX_PARAM="-prefs \"runtime.tools.avr-gcc.path=${AVR_GCC_PREFIX}\""
fi