You plan to upload a version of AVR-GCC that is compatible with both 32-bit and 64-bit Windows, including Binutils, AVR-LibC, AVRDUDE, Make, and GDB. This means you will provide a complete development toolchain, making it convenient for Windows users to develop AVR microcontroller projects.

You also mention that, except for AVRDUDE, all binary files are built from source code using MinGW on a Debian virtual machine. This ensures the reliability and consistency of the binary files.

Providing both 32-bit and 64-bit Windows binary files is also convenient for users to choose the suitable version. Moreover, you will provide a bash script that allows users to easily build AVR-GCC, AVR-Binutils, AVR-LibC, and AVR-GDB from source code. This is particularly useful for users who need to customize or optimize the toolchain.

Overall, your upload will provide a convenient, reliable, and customizable AVR microcontroller development toolchain for Windows users.

Included tools

Downloads

Older releases can be found [HERE]

Upgrading the Arduino IDE

Upgrading the Arduino IDE is pretty easy, though there could be some incompatibilities with certain libraries. Only tested with Arduino 1.8.13.

1. Download and extract one of the downloads above
2. Navigate to your Arduino IDE folder
3. Go to hardware/tools
4. Move the avr folder somewhere else, like to your desktop (renaming the folder won’t work, Arduino has some auto-detect thing which sometimes gets confused)
5. Move the extracted folder from earlier to the tools folder and rename it to avr
6. Copy bin/avrdude.exe and builtin_tools_versions.txt files and etc folder from the old avr folder to the new one
7. Done! Open up the Arduino IDE, load up the Blink example, upload it to your Arduino and make sure the LED is blinking!

Build Script

This build script will install the required packages, create directories and build the tools from source and should work on Debian and Ubuntu.

!/bin/bash

avr-gcc-build

https://blog.zakkemble.net/avr-gcc-builds/

https://github.com/ZakKemble/avr-gcc-build

Copyright (C) 2024, Zak Kemble

Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)

http://creativecommons.org/licenses/by-sa/4.0/

CWD=$(pwd)

++++ Error Handling and Backtracing ++++

set -eE -o functrace

function backtrace()
{
local deptn=${#FUNCNAME[@]}
local start=${1:-1}
for ((i=$start; i<$deptn; i++)); do
local func=”${FUNCNAME[$i]}”
local line=”${BASH_LINENO[$((i-1))]}”
local src=”${BASH_SOURCE[$((i-1))]}”
printf ‘%*s’ $i ” # indent
echo “at: $func(), $src, line $line”
done
}

suppressError=0

failure()
{
[ $suppressError -ne 0 ] && return 0
local lineno=$1
local msg=$2
echo “Failed at $lineno: $msg”
echo ” pwd: $CWD”
backtrace 2
}

trap ‘failure ${LINENO} “$BASH_COMMAND”‘ ERR

—- Erorr Handling and Backtracing —-

http://www.nongnu.org/avr-libc/user-manual/install_tools.html

VM with 4x AMD Ryzen 5 5600X cores & 5.5GB RAM

Debian 11 & GCC 10.2.1

AVR-GCC 12.1.0 compile time: Around 1 hour for all 3 hosts

For optimum compile time this should generally be set to the number of CPU cores your machine has.

Some systems with not much RAM may fail with “collect2: fatal error: ld terminated with signal 9 [Killed]”, if this happens try reducing the JOBCOUNT value or add more RAM.

In my case using GCC 8.3.0 on Debian 10 with 2GB RAM was fine, but Debian 11 and GCC 10.2.1 needed 5.5GB

JOBCOUNT=${JOBCOUNT:-$(getconf _NPROCESSORS_ONLN)}

Build for Linux

A Linux AVR-GCC toolchain is required to build a Windows toolchain

If the Linux toolchain has already been built then you can set this to 0

FOR_LINUX=${FOR_LINUX:-1}

Build for 32 bit Windows

FOR_WINX86=${FOR_WINX86:-0}

Build for 64 bit Windows

FOR_WINX64=${FOR_WINX64:-1}

Build Binutils for selected OSs

BUILD_BINUTILS=${BUILD_BINUTILS:-1}

Build GCC for selected OSs (requires AVR-Binutils)

BUILD_GCC=${BUILD_GCC:-1}

Build GDB for selected OSs

BUILD_GDB=${BUILD_GDB:-1}

Build AVR-LibC (requires AVR-GCC)

BUILD_LIBC=${BUILD_LIBC:-1}

NAME_BINUTILS=”binutils-${VER_BINUTILS:-2.42}”
NAME_GCC=”gcc-${VER_GCC:-14.1.0}”
NAME_GDB=”gdb-${VER_GDB:-14.2}”
NAME_GMP=”gmp-6.3.0″ # GDB 11+ needs libgmp
NAME_MPFR=”mpfr-4.2.1″ # GDB 14+ needs libmpfr
NAME_LIBC=(“avr-libc-2_2_0-release” “avr-libc-2.2.0”)

Output locations for built toolchains

BASE=${BASE:-${CWD}/build/}
PREFIX_GCC_LINUX=${BASE}avr-${NAME_GCC}-x64-linux
PREFIX_GCC_WINX86=${BASE}avr-${NAME_GCC}-x86-windows
PREFIX_GCC_WINX64=${BASE}avr-${NAME_GCC}-x64-windows

HOST_WINX86=”i686-w64-mingw32″
HOST_WINX64=”x86_64-w64-mingw32″

Uncomment the next 2 export lines and replace “–enable-plugin”

with “–disable-plugin” in OPTS_GCC for a fully static linux build.

NOTE: Plugin support is probably needed for LTO and some other stuff

export CFLAGS=”-static –static”

export CXXFLAGS=”${CFLAGS}”

OPTS_BINUTILS=”
–target=avr
–disable-nls
–disable-werror
“

OPTS_GCC=”
–target=avr
–enable-languages=c,c++
–disable-nls
–disable-libssp
–disable-libada
–with-dwarf2
–disable-shared
–enable-static
–enable-mingw-wildcard
–enable-plugin
–with-gnu-as
–with-gnu-ld
–without-zstd
“

OPTS_GDB=”
–target=avr
–with-static-standard-libraries
“

OPTS_LIBC=””

TMP_DIR=${CWD}/tmp
LOG_DIR=${CWD}

log()
{
echo “$1”
echo “[$(date +”%d %b %y %H:%M:%S”)]: $1″ >> “$LOG_DIR/avr-gcc-build.log”
}

disableErrorStop()
{
set +e
suppressError=1
}

enableErrorStop()
{
set -e
suppressError=0
}

installPackages()
{
local requiredPackages=(“wget” “make” “mingw-w64” “gcc” “g++” “bzip2” “xz-utils” “autoconf” “texinfo” “libgmp-dev” “libmpfr-dev”)

if [[ $EUID -ne 0 ]]; then
    log "Not running as root user. Checking whether all required packages are installed..."
    local packageMissing=0
    for package in "${requiredPackages[@]}"
    do
        disableErrorStop # disable stop on error for one line
        dpkg -s "$package" > /dev/null 2>&1
        local checkPackageResult=$?
        enableErrorStop
        if [[ $checkPackageResult -ne 0 ]]; then
            echo "ERROR: Package \"$package\" is not installed. But it is required."
            packageMissing=1
        fi
    done

    if [[ $packageMissing -ne 0 ]]; then
        echo "Not all required packages are installed. You need to install them manually or run the script with root (sudo)"
        exit 2
    fi

    echo "All required packages are installed. Continuing..."
else
    log "Running as root user. Installing required packages via apt..."
    apt install "${requiredPackages[@]}"
fi

}

makeDir()
{
rm -rf “$1/”
mkdir -p “$1”
}

fixGCCAVR()
{
# In GCC 7.1.0 there seems to be an issue with INT8_MAX and some other things being undefined in /gcc/config/avr/avr.c when building for Windows.
# Adding ‘#include ‘ doesn’t fix it, but manually defining the values does the trick.

echo "Fixing missing defines..."

DEFSFIX="
    #if (defined _WIN32 || defined __CYGWIN__)
    #define INT8_MIN (-128)
    #define INT16_MIN (-32768)
    #define INT8_MAX 127
    #define INT16_MAX 32767
    #define UINT8_MAX 0xff
    #define UINT16_MAX 0xffff
    #endif
"

ORIGINAL=$(cat ../gcc/config/avr/avr.c)
echo "$DEFSFIX" > ../gcc/config/avr/avr.c
echo "$ORIGINAL" >> ../gcc/config/avr/avr.c

}

cleanup()
{
log “Clearing output directories…”
[ $FOR_LINUX -eq 1 ] && makeDir “$PREFIX_GCC_LINUX”
[ $FOR_WINX86 -eq 1 ] && makeDir “$PREFIX_GCC_WINX86”
[ $FOR_WINX64 -eq 1 ] && makeDir “$PREFIX_GCC_WINX64”

log "Clearing old downloads..."
rm -f $NAME_BINUTILS.tar.xz
rm -rf $NAME_BINUTILS
rm -f $NAME_GCC.tar.xz
rm -rf $NAME_GCC
rm -f $NAME_GDB.tar.xz
rm -rf $NAME_GDB
rm -f $NAME_GMP.tar.xz
rm -rf $NAME_GMP
rm -f $NAME_MPFR.tar.xz
rm -rf $NAME_MPFR
rm -f ${NAME_LIBC[1]}.tar.bz2
rm -rf ${NAME_LIBC[1]}

}

downloadSources()
{
log “Downloading sources…”
[ $BUILD_BINUTILS -eq 1 ] && log “$NAME_BINUTILS” && wget https://ftpmirror.gnu.org/binutils/$NAME_BINUTILS.tar.xz
[ $BUILD_GCC -eq 1 ] && log “$NAME_GCC” && wget https://ftpmirror.gnu.org/gcc/$NAME_GCC/$NAME_GCC.tar.xz
if [ $BUILD_GDB -eq 1 ]; then
log “$NAME_GDB”
wget https://ftpmirror.gnu.org/gdb/$NAME_GDB.tar.xz
if [ $FOR_WINX86 -eq 1 ] || [ $FOR_WINX64 -eq 1 ]; then
log “$NAME_GMP”
wget https://ftpmirror.gnu.org/gmp/$NAME_GMP.tar.xz
log “$NAME_MPFR”
wget https://ftpmirror.gnu.org/mpfr/$NAME_MPFR.tar.xz
fi
fi
if [ $BUILD_LIBC -eq 1 ]; then
log “${NAME_LIBC[1]}”
wget https://github.com/avrdudes/avr-libc/releases/download/${NAME_LIBC[0]}/${NAME_LIBC[1]}.tar.bz2
fi
}

confMake()
{
../configure –prefix=$1 $2 $3 –build=../config.guess
make -j $JOBCOUNT
make install-strip
rm -rf *
}

buildBinutils()
{
log “Binutils“
[ $BUILD_BINUTILS -ne 1 ] && log “(Skipping)” && return 0

log "Extracting..."
tar xf $NAME_BINUTILS.tar.xz
mkdir -p $NAME_BINUTILS/obj-avr
cd $NAME_BINUTILS/obj-avr

[ $FOR_LINUX -eq 1 ] && log "Making for Linux..." && confMake "$PREFIX_GCC_LINUX" "$OPTS_BINUTILS"
[ $FOR_WINX86 -eq 1 ] && log "Making for Windows x86..." && confMake "$PREFIX_GCC_WINX86" "$OPTS_BINUTILS" --host=$HOST_WINX86
[ $FOR_WINX64 -eq 1 ] && log "Making for Windows x64..." && confMake "$PREFIX_GCC_WINX64" "$OPTS_BINUTILS" --host=$HOST_WINX64

cd ../../

}

buildGCC()
{
log “GCC“
[ $BUILD_GCC -ne 1 ] && log “(Skipping)” && return 0

log "Extracting..."
tar xf $NAME_GCC.tar.xz
mkdir -p $NAME_GCC/obj-avr
cd $NAME_GCC

log "Getting prerequisites..."
chmod +x ./contrib/download_prerequisites
./contrib/download_prerequisites

cd obj-avr
# fixGCCAVR

[ $FOR_LINUX -eq 1 ] && log "Making for Linux..." && confMake "$PREFIX_GCC_LINUX" "$OPTS_GCC"
[ $FOR_WINX86 -eq 1 ] && log "Making for Windows x86..." && confMake "$PREFIX_GCC_WINX86" "$OPTS_GCC" --host=$HOST_WINX86
[ $FOR_WINX64 -eq 1 ] && log "Making for Windows x64..." && confMake "$PREFIX_GCC_WINX64" "$OPTS_GCC" --host=$HOST_WINX64

cd ../../

}

buildGDB()
{
log “GDB (and GMP, MPFR for Windows)“
[ $BUILD_GDB -ne 1 ] && log “(Skipping)” && return 0

log "Extracting..."
tar xf $NAME_GDB.tar.xz
mkdir -p $NAME_GDB/obj-avr
if [ $FOR_WINX86 -eq 1 ] || [ $FOR_WINX64 -eq 1 ]; then
    tar xf $NAME_GMP.tar.xz
    mkdir -p $NAME_GMP/obj
    tar xf $NAME_MPFR.tar.xz
    mkdir -p $NAME_MPFR/obj
fi

if [ $FOR_LINUX -eq 1 ]; then
    log "Making for Linux..."
    cd $NAME_GDB/obj-avr
    confMake "$PREFIX_GCC_LINUX" "$OPTS_GDB"
    cd ../../
fi

buildGDBWin()
{
    log "GMP..."
    cd $NAME_GMP/obj
    confMake $TMP_DIR/$2 --host=$2
    cd ../../

    log "MPFR..."
    cd $NAME_MPFR/obj
    confMake $TMP_DIR/$2 "--with-gmp=$TMP_DIR/$2 --disable-shared --enable-static" --host=$2
    cd ../../

    log "GDB..."
    cd $NAME_GDB/obj-avr
    confMake "$1" "--with-gmp=$TMP_DIR/$2 --with-mpfr=$TMP_DIR/$2 $OPTS_GDB" --host=$2
    cd ../../
}

[ $FOR_WINX86 -eq 1 ] && log "Making for Windows x86..." && buildGDBWin "$PREFIX_GCC_WINX86" $HOST_WINX86
[ $FOR_WINX64 -eq 1 ] && log "Making for Windows x64..." && buildGDBWin "$PREFIX_GCC_WINX64" $HOST_WINX64

# For some reason we need some random command here otherwise
# the script exits with no error when FOR_WINX64=0
echo "" > /dev/null

}

buildAVRLIBC()
{
log “AVR-LibC“
[ $BUILD_LIBC -ne 1 ] && log “(Skipping)” && return 0

log "Extracting..."
bunzip2 -c ${NAME_LIBC[1]}.tar.bz2 | tar xf -
mkdir -p ${NAME_LIBC[1]}/obj-avr
cd ${NAME_LIBC[1]}/obj-avr

log "Making..."
../configure "$OPTS_LIBC" --host=avr --build=`../config.guess`
make -j $JOBCOUNT

log "Installing into toolchains..."
[ $FOR_LINUX -eq 1 ] && log "Linux" && make install prefix="${PREFIX_GCC_LINUX}"
[ $FOR_WINX86 -eq 1 ] && log "Windows x86" && make install prefix="${PREFIX_GCC_WINX86}"
[ $FOR_WINX64 -eq 1 ] && log "Windows x64" && make install prefix="${PREFIX_GCC_WINX64}"

cd ../../

}

installPackages

log “Start”

TIME_START=$(date +%s)

export PATH=”$PREFIX_GCC_LINUX”/bin:”$PATH”
export CC=””

cleanup
downloadSources
buildBinutils
buildGCC
buildGDB
buildAVRLIBC

TIME_END=$(date +%s)
TIME_RUN=$(($TIME_END – $TIME_START))

echo “”
log “Done in $TIME_RUN seconds”
log “Toolchains are in $BASE”

exit 0

view rawavr-gcc-build.sh delivered with ❤ by emgithub