der oberling

ARM Programmierung

Hier finden sich verschiedene Dinge rund um die Programmierung von ARM Prozessoren. Ich arbeite hier mit dem Cortex M3 Design umgesetzt von NXP und auf dem Evaluationsboard der microbuilder.eu aufgebracht.

Immer wenn mir irgendwas unklar war und ich länger nachforschen musste, werde ich es hier niederschreiben. :)

---

Linux Entwicklungsumgebung LPC1343 Board von Microbuilder

Unter Ubuntu kann die Toolchain inzwischen einfach mittels

sudo apt install gcc-arm-none-eabi

installiert werden. Für das LPC1343 Reference Board von microBuilder.eu checkt man nun sinnvoller weise das Repo aus:

git clone https://github.com/microbuilder/LPC1343CodeBase.git

In diesem Repo finden sich allerhand Beispiele und letztlich muss man je Beispiel aus tools/examples/ die entsprechende main.c kopieren, die projectconfig.c anpassen und kann nun fast schon kompilieren. Einzig was für Linux noch fehlt ist das Tool, dass der Firmware die CRC-Summe LPC-konform hinzufügt. Ohne dies kann man zwar die Firmware auf das Board kopieren, aber sie wird nicht akzeptiert und daher auch nicht ausgeführt werden. Dazu kopiert man sich am Besten das lpcrc-linux binary als lpcrc in das Hauptverzeichnis des Projektes (dort wird es vom Makefile erwartet) und macht es für den Nutzer ausführbar.

cp tools/lpcrc/bin/lpcrc-linux . && chmod u+x lpcrc-linux

Alternativ kann es natürlich unter tools/lpcrc/ gebaut werden (der Quelltext nebst Makefile ist dabei).

cd tools/lpcrc/
make
cd ../../ && cp tools/lpcrc/lpcrc .

Nun kann das aktuelle Programm (per main.c) gebaut und anschließend geflasht werden.

---

Installation des Toolchains - Linux

Inzwischen ist der Toolchain für die ARM-MCUs unter Linux bereits in den großen Distributionen vorhanden und muss nicht mehr selbst kompiliert werden.
Die alte Anleitung dient nur noch Dokumentationszwecken.

Um den toolchain für den Cortex-M3 unter Linux aufzusetzen, bietet es sich an, das gnu-arm-installer paket von Waipot Ngamsaad an.
Um den Toolchain zu installieren müssen allerdings zunächst noch ein paar Pakete (unter Debian Lenny und Squeeze) installiert werden. Am Besten einfach die folgenden Befehle ausführen:

apt-get install patch texinfo libncurses5-dev libx11-dev libgmp3-dev libmpfr-dev

cd ~
mkdir arm-none-eabi
cd arm-none-eabi
svn checkout http://hobbycode.googlecode.com/svn/trunk/gnu-arm-installer gnu-arm-installer

cd gnu-arm-installer/src/
wget http://ftp.gnu.org/gnu/binutils/binutils-2.19.tar.bz2
wget http://ftp.gnu.org/gnu/gcc/gcc-4.3.2/gcc-4.3.2.tar.bz2
wget ftp://ftp.fi.debian.org/pub/gentoo/distfiles/newlib-1.16.0.tar.gz
wget ftp://gcc.gnu.org/pub/insight/releases/insight-6.8-1.tar.bz2
cd ..

Gnuarm war in den letzten Tagen nicht allzu zuverlässig erreichbar - daher sollte man vielleicht bei google nach den einzelnen Paketen inklusive "mirror" suchen und die entsprechenden Versionen von den Spiegelservern runterladen..
Da insight-6.8.tar.bz2 nicht die aktuellste Version ist bzw. es einen schwereren Fehler in dieser Version gibt, wurde oben insight-6.8-1.tar.bz2 heruntergeladen. Damit diese nun auch genutzt wird, müssen folgende Anpassungen in der gnu-arm-installer.sh vorgenommen werden:

INSIGHT_SRC=insight-6.8-1.tar.bz2
INSIGHT_VERSION=6.8-1
INSIGHT_DIR=insight-$INSIGHT_VERSION

Es ist Geschmackssache, ob man arm-elf oder arm-none-eabi nutzt (einige unsichere Quellen meinen, dass elf die alte Bezeichnung für eabi ist, andere Quellen meinen, dass elf ein Betriebssystem voraussetzt... Hauptsache ist jedoch, dass die hier gebauten Binaries am Ende firmwares rauswerfen, die auf die Cortex gespielt werden können ;-) ). Da die existierenden Makefiles (beispielsweise von microbuilder.eu) jedoch arm-none-eabi nutzen, bieteten sich folgende Möglichkeiten: Entweder man schreibt einmal in der Datei gnu-arm-installer.sh alle arm-elf zu arm-none-eabi um, oder zukünftig in allen Makefiles, oder aber man legt nach dem Bauen des toolchains symbolische Verknüpfungen von allen arm-elf binaries zu arm-non-eabi binaries an.
Für welchen Weg man sich auch entscheidet (ich habe in gnu-arm-installer.sh alle arm-elf zu arm-none-eabi ersetzt) - der Toolchain wird nun gebaut mit:

./gnu-arm-installer.sh

Abschließend muss noch der install/bin-Ordner in der PATH-Variable hinzugefügt werden

vim ~/.bashrc

und einfügen:

export PATH=~/arm-none-eabi/install/bin/:$PATH

und los geht's mit der Entwicklung für die Cortex M3 Plattform und diverse andere ARM-Plattformen.

---

Installation des Toolchains - Mac OS X

Neulich kam eine Lieferung von Bitmanufaktur mit 2 OpenBeacon USB 2 zum basteln.
Diese sind wie auch das oben abgebildete Board mit je einer 32 bit Cortex M3 ausgestattet.
Zur Programmierung dieser OpenBeacon Tags setzte ich mit dem unten zu sehendem Script den Toolchain für Mac OS X auf.
Wichtig ist, dass man vorher per MacPorts sowohl gmp, als auch mpfr installiert.

sudo port install gmp mpfr

Anschließend kann man mit folgendem abgewandelten Script den Toolchain aufsetzen:

#!/bin/sh
#
# Copyright (c) 2008 the NxOS developers
#
# See AUTHORS for a full list of the developers.
#
# Redistribution of this file is permitted under
# the terms of the GNU Public License (GPL) version 2.
#
# Build an ARM cross-compiler toolchain (including binutils, gcc and
# newlib) on autopilot.

ROOT=`pwd`
SRCDIR=$ROOT/src
BUILDDIR=$ROOT/build
PREFIX=$ROOT/install

GCC_URL=http://ftp.gnu.org/pub/gnu/gcc/gcc-4.4.0/gcc-core-4.4.0.tar.bz2
GCC_VERSION=4.4.0
GCC_DIR=gcc-$GCC_VERSION

BINUTILS_URL=http://ftp.gnu.org/gnu/binutils/binutils-2.19.1.tar.bz2
BINUTILS_VERSION=2.19.1
BINUTILS_DIR=binutils-$BINUTILS_VERSION

NEWLIB_URL=ftp://sources.redhat.com/pub/newlib/newlib-1.17.0.tar.gz
NEWLIB_VERSION=1.17.0
NEWLIB_DIR=newlib-$NEWLIB_VERSION

GDB_URL=ftp://ftp.gnu.org/gnu/gdb/gdb-6.8a.tar.bz2
GDB_VERSION=6.8
GDB_DIR=gdb-$GDB_VERSION

echo "I will build an arm-elf cross-compiler:

Prefix: $PREFIX
Sources: $SRCDIR
Build files: $BUILDDIR

Software: Binutils $BINUTILS_VERSION
Gcc $GCC_VERSION
Newlib $NEWLIB_VERSION
Gdb $GDB_VERSION

Press ^C now if you do NOT want to do this."
read IGNORE

#
# Helper functions.
#
ensure_source()
{
    URL=$1
    FILE=$(basename $1)

    if [ ! -e $FILE ]; then
        echo "getting $FILE"
curl -L -O$FILE $URL
    fi
}

unpack_source()
{
(
    cd $SRCDIR
    ARCHIVE_SUFFIX=${1##*.}
    if [ "$ARCHIVE_SUFFIX" = "gz" ]; then
tar zxvf $1
    elif [ "$ARCHIVE_SUFFIX" = "bz2" ]; then
tar jxvf $1
    else
echo "Unknown archive format for $1"
      exit 1
    fi
)
}

# Create all the directories we need.
mkdir -p $SRCDIR $BUILDDIR $PREFIX

(
cd $SRCDIR

# First grab all the source files...
ensure_source $GCC_URL
ensure_source $BINUTILS_URL
ensure_source $NEWLIB_URL
#rboissat: Adding GNU gdb
ensure_source $GDB_URL

# ... And unpack the sources.
unpack_source $(basename $GCC_URL)
unpack_source $(basename $BINUTILS_URL)
unpack_source $(basename $NEWLIB_URL)
unpack_source $(basename $GDB_URL)
)

# Set the PATH to include the binaries we're going to build.
OLD_PATH=$PATH
export PATH=$PREFIX/bin:$PATH

#
# Stage 1: Build binutils
#
(
mkdir -p $BUILDDIR/$BINUTILS_DIR
cd $BUILDDIR/$BINUTILS_DIR

$SRCDIR/$BINUTILS_DIR/configure --target=arm-elf --prefix=$PREFIX \
    --disable-werror --enable-interwork --enable-multilib --with-float=soft \
    && make all install
) || exit 1

#
# Stage 2: Patch the GCC multilib rules, then build the gcc compiler only
#
(
MULTILIB_CONFIG=$SRCDIR/$GCC_DIR/gcc/config/arm/t-arm-elf

echo "

MULTILIB_OPTIONS += mno-thumb-interwork/mthumb-interwork
MULTILIB_DIRNAMES += normal interwork

" >> $MULTILIB_CONFIG

mkdir -p $BUILDDIR/$GCC_DIR
cd $BUILDDIR/$GCC_DIR

$SRCDIR/$GCC_DIR/configure --target=arm-elf --prefix=$PREFIX \
    --enable-interwork --enable-multilib --with-float=soft \
    --with-libiconv-prefix=/opt/local \
    --with-gmp-include=/opt/local/include --with-mpfr-include=/opt/local/include \
    --with-gmp-lib=/opt/local/lib --with-mpfr-lib=/opt/local/lib \
    --enable-languages="c" --with-newlib \
    --with-headers=$SRCDIR/$NEWLIB_DIR/newlib/libc/include \
    && make all-gcc install-gcc
) || exit 1

#
# Stage 3: Build and install newlib
#
(
# And now we can build it.
mkdir -p $BUILDDIR/$NEWLIB_DIR
cd $BUILDDIR/$NEWLIB_DIR

$SRCDIR/$NEWLIB_DIR/configure --target=arm-elf --prefix=$PREFIX \
    --enable-interwork --enable-multilib --with-float=soft \
    && make all install
) || exit 1

#
# Stage 4: Build and install the rest of GCC.
#
(
cd $BUILDDIR/$GCC_DIR

make all install
) || exit 1

#
# Stage 5: Build and install GDB
#
(
mkdir -p $BUILDDIR/$GDB_DIR
cd $BUILDDIR/$GDB_DIR

$SRCDIR/$GDB_DIR/configure --target=arm-elf --prefix=$PREFIX \
    --disable-werror --enable-interwork --enable-multilib --with-float=soft \
    && make all install
) || exit 1

export PATH=$OLD_PATH

echo "export PATH=$PREFIX/bin:\$PATH">$ROOT/env.sh

echo "
Build complete! To use your new toolchain:

- Source the $ROOT/env.sh script in your shell. In bash:
source $ROOT/env.sh

- Or, just add $PREFIX/bin to your PATH manually.

"