Erstellen Sie Ihr Android für BeagleBoard


In diesem Artikel möchte ich über den Android-Erstellungsprozess für ARM-Controller sprechen. Ich hoffe, dass dieser Artikel für einige Leute nicht nur für den Entwickler, sondern auch für den erfahrenen Benutzer nützlich sein wird. Grundsätzlich möchte ich natürlich zeigen, wie der Montageprozess, das Betriebssystem für mobile Geräte, abläuft. Als „ Versuchskaninchen “ habe ich BeagleBoard-xM gewählt .
Dies ist eines der Debug-Boards, die für solche Zwecke perfekt geeignet sind. Es verfügt unter anderem über HDMI- und S-VIDEO-Ausgänge, um das Ergebnis "zu spüren". Und auch 4 USB-Anschlüsse, die ausreichen, um eine Tastatur, eine Maus usw. anzuschließen. In meinen Experimenten habe ich einen bei eBay gekauften BeadaFrame verwendetDiese Bedingung ist jedoch absolut nicht grundlegend, da jeder "Fernseher" geeignet ist.

Und so wird unser Board mit microSD geladen, und zum Erstellen von Android benötigen wir eine Linux-Maschine, zum Beispiel mit Ubuntu 13.04-AMD x64, es ist durchaus möglich, eine virtuelle Maschine zu verwenden, aber ich empfehle sicherzustellen, dass das MMC-Gerät für die virtuelle Maschine zugänglich ist, d. H. microSD-Karte selbst, aber zuerst müssen wir die folgenden Pakete installieren:
sudo apt-get install aptitude
sudo aptitude install ia32-libs
sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl libc6-dev libncurses5-dev:i386 x11proto-core-dev libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-glx:i386 libgl1-mesa-dev g++-multilib mingw32 openjdk-6-jdk tofrodos python-markdown libxml2-utils xsltproc zlib1g-dev:i386 curl


Für unser Android müssen Sie drei wichtige Dinge sammeln:
  • Der Kernel des Betriebssystems selbst ist eine Binärdatei, die vom Bootloader geladen wird.
  • Bootloader, in unserem Fall ist es U-Boot , obwohl Sie X-Loader verwenden können .
  • Dateisystem


Und für die Arbeit erstellen Sie eine Art Arbeitsverzeichnis, zum Beispiel: / home / ubuntu / Adroid /
mkdir /home/ubuntu/Android
cd /home/ubuntu/Android

und füge sofort dieses Verzeichnis zum Pfad hinzu:
export PATH=/home/ubuntu/Android:$PATH

Wenn git nicht auf Ihrer virtuellen Maschine installiert wurde, müssen Sie es tun:
sudo apt-get install git
git config --global user.email "you@example.com"
git config --global user.name "You Name"

Repository-Initialisierung


Jetzt müssen wir den Quellcode von Android selbst herunterladen, aus dem wir in Zukunft den Kernel des Betriebssystems und des Dateisystems erstellen werden. Führen Sie dazu im Arbeitsverzeichnis / home / ubuntu / Adroid den folgenden Befehl aus:
curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > androidrepo

Als Ergebnis haben wir die androidrepo- Datei erhalten , mit der wir mit dem Repository arbeiten werden. Weisen Sie dazu die Rechte der ausführbaren Datei für androidrepo zu .
chmod a+x androidrepo

Als nächstes erstellen Sie in unserem Arbeitsverzeichnis ein Verzeichnis für den Quellcode:
mkdir /home/ubuntu/Android/source
cd /home/ubuntu/Android/source

und starte das Repository:
androidrepo  init -u git://gitorious.org/rowboat/manifest.git -m rowboat-jb-am37x.xml

Nach erfolgreicher Initiierung synchronisieren wir mit dem Repository
androidrepo sync

Die Synchronisation ist ein ziemlich langer Prozess, da sie nicht nur den Quellcode des Kernels enthält, sondern auch das Dateisystem und den Compiler, mit dessen Hilfe sowohl der Loader als auch der Kernel zusammengesetzt werden.
Am Ende der Synchronisierung sollten Informationen über eine erfolgreiche Synchronisierung
angezeigt werden , etwa wie folgt : Synchronisierungsarbeitsbaum: 100% (261/261), fertig.
Jetzt müssen wir vor dem Erstellen den Pfad zum Compiler konfigurieren, mit dem wir sowohl den Kernel als auch den Loader erstellen. Der Compiler selbst befindet sich im Repository selbst im Verzeichnis prebuilts / gcc / linux-x86 / arm / arm-eabi-4.6 / bin. Daher legen wir den Pfad dazu in der Variablen PATH fest.
export PATH=/home/ubuntu/Android/source/prebuilts/gcc/linux-x86/arm/arm-eabi-4.6/bin:$PATH

In diesem Zusammenhang können die Vorarbeiten als abgeschlossen betrachtet werden.

Bootloader-Baugruppe


Wie ich bereits schrieb, werden wir als Bootloader u-boot verwenden. Zum Erstellen müssen wir einen Klon des U-Boot-Repository in unserem Arbeitsordner erstellen:
git clone git://git.denx.de/u-boot.git u-boot

Und wir sammeln unseren Bootloader, den ersten distclean-Befehl, den Sie beim allerersten Build überspringen können.
Um u-boot zu erstellen, verwenden wir den arm-eabi-gcc-Compiler, den Pfad, auf den wir bereits installiert haben.
сd u-boot-main
make CROSS_COMPILE=arm-eabi- distclean
make CROSS_COMPILE=arm-eabi- omap3_beagle_config
make CROSS_COMPILE=arm-eabi-

Das Ergebnis der Bootloader-Erstellung sind zwei MLO- Dateien und u-boot.bin . Beide Dateien befinden sich im Stammverzeichnis des U-Boot-Verzeichnisses. Übertragen Sie sie sofort an einen beliebigen Ort, beispielsweise im Build- Verzeichnis .

Kernel-Assembly


Nun kamen wir zum Aufbau des Kernels. Physisch handelt es sich hierbei um eine uImage- Datei , die eigentlich nichts weiter darstellt - den Linux-Kernel. Bevor Sie mit der Assembly fortfahren können, müssen Sie Java SE 1.6 installieren. Und es ist Version 1.6, die aus dem Repository installiert werden kann:
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java6-installer

oder zum Beispiel wie in diesem Artikel beschrieben .
Um den Kernel zu erstellen, müssen wir zum Kernelverzeichnis im Android-Repository gehen. In unserem Fall: / home / ubuntu / Adroid / source / kernel , und nach dem Beispiel des Aufbaus des U-Boot- Loaders :
make ARCH=arm CROSS_COMPILE=arm-eabi- distclean
make ARCH=arm CROSS_COMPILE=arm-eabi- omap3_beagle_android_defconfig
make ARCH=arm CROSS_COMPILE=arm-eabi- uImage

Es ist zu beachten, dass omap3_beagle_android_defconfig aus dem Verzeichnis kernel / arch / arm / configs stammt , in dem sich die Kernelkonfigurationen befinden. Wenn Sie möchten, können Sie die entsprechende Konfiguration für eine bestimmte Hardware ändern, hinzufügen oder auswählen.
Das Ergebnis der Assembly befindet sich im Ordner kernel / arch / arm / boot , d.h. In unserem Fall / home / ubuntu / Adroid / source / kernel / arch / arm / boot erhalten wir die uImage- Datei , den Kernel selbst und übertragen ihn in das für uns bereits geeignete Build-Verzeichnis.

Dateisystem-Assembly


Dies ist die letzte Phase der Zusammenstellung unseres Betriebssystems. Dazu müssen Sie zum Stammverzeichnis des Repositorys gehen und es zusammenstellen:
make TARGET_PRODUCT=beagleboard droid

Das Dateisystem ist schon lange in Betrieb, und der Festplattenspeicher benötigt etwa 20 GB. Nach dem Kompilieren des Dateisystems selbst müssen Sie das Archiv abrufen, das alle erforderlichen Dateien enthält.
make TARGET_PRODUCT=beagleboard fs_tarball

Nach Abschluss des Archivs erhalten wir die Datei footfs.tar.bz2 , die sich im Verzeichnis out befindet: /home/ubuntu/Adroid/source/out/target/product/beagleboard/rootfs.tar.bz2 . Sie enthält tatsächlich das Android-Dateisystem. Hier finden Sie alle Systemdateien, Anwendungen und Dienstprogramme, die Teil des Betriebssystems sind.

Systemkonfiguration


Der Konfigurationsprozess selbst ist recht einfach, aber zur Vereinfachung verwenden wir Rowboat Tools von Texas Instruments. Wir benötigen die Bootloader-Konfigurationsdatei boot.scr , die die Einstellungen für die Bootloader-Variablen enthält.
Laden Sie die Rowboat Tools selbst herunter und entpacken Sie sie:
cd /home/ubuntu/Android/
wget https://rowboat.googlecode.com/files/RowboatTools-JB.tar.gz
tar -xvzf RowboatTools-JB.tar.gz

Für uns ist jetzt die Datei mkbootscr von Interesse , die sich im Verzeichnis RowboatTools-JB / am37x / mk-bootscr befindet . Wenn Sie in die Datei schauen, finden Sie ähnliche Zeilen:
setenv bootargs 'console=ttyO2,115200n8 androidboot.console=ttyO2 mem=256M root=/dev/mmcblk0p2 rw rootfstype=ext4 rootwait init=/init ip=off omap_vout.vid1_static_vrfb_alloc=y vram=8M omapfb.vram=0:8M omapdss.def_disp=dvi omapfb.mode=dvi:1024x768-16'

Dies ist die Installation von Bootloader-Variablen, d.h. Zum Beispiel müssen wir die Bildschirmauflösung auf eine andere als die „Standardauflösung“ einstellen, also müssen wir den DVI- Wert ändern : 1024x768-16 und mkbootscr ausführen . Als Ergebnis erhalten wir die Datei boot.scr mit unseren neuen Einstellungen. Das sofortige Ändern von boot.scr funktioniert nicht, da es Informationen über die Prüfsumme enthält, die natürlich mit der Größe der Datei selbst übereinstimmen müssen.

Installation und Download


Die Karte selbst und die meisten Geräte an ARM-Controllern können grundsätzlich über NAND-Speicher, SD / MMC oder USB / RS-232 booten. In unserem Fall werden wir von der MMC booten. Erstens ist dies sicherer als NAND-Speicher-Firmware, und zweitens ist es meiner Meinung nach einfach bequemer, insbesondere zu Demonstrationszwecken.
Und so brauchen wir eine MMC, vorzugsweise von 2 bis 8 GB. Wir verbinden die MMC mit dem Linux-Rechner und bereiten das Dateisystem vor.
Eine startfähige MMC-Festplatte muss mindestens zwei Partitionen enthalten. Das erste FAT16 heißt boot, von dem aus der U-Boot und der Kernel des Betriebssystems tatsächlich booten, und das zweite Ext4, auf dem sich unser Dateisystem befindet, heißt rootfs.
Um die Erstellung des Dateisystems zu vereinfachen, habe ich ein kleines Bash-Skript vorbereitet, um die Verwendung zu vereinfachen. Wenn der Controller den Bootsektor nicht findet, kann unsere Plattform einfach nicht booten.
#!/bin/bash -e
if ! [ $(id -u) = 0 ] ; then
	echo "This script should be run as sudo user or root"
	exit 1
fi
mmcdisk=$1
conf_boot_startmb="1"
conf_boot_endmb="96"
sfdisk_fstype="0xE"
label_boot="boot"
label_rootfs="rootfs"
# Umount existion partitions
echo "Unmounting partitions"
mountpoints=$(mount | grep -v none | grep "$mmcdisk" | wc -l)
for ((i=1;i<=${mountpoints};i++))
do
    currentdisk=$(mount | grep -v none | grep "$mmcdisk" | tail -1 | awk '{print $1}')
    umount ${currentdisk} >/dev/null 2>&1 || true
done
dd if=/dev/zero of=${mmcdisk} bs=1M count=16
sync
# Create partition table
LC_ALL=C sfdisk --force --in-order --Linux --unit M "${mmcdisk}" <<-__EOF__
	$conf_boot_startmb,$conf_boot_endmb,$sfdisk_fstype,*
	,,,-
__EOF__
sync
partprobe ${mmcdisk}
# Setup partitions
echo "Setup partitions"
LC_ALL=C fdisk -l "${mmcdisk}"
LC_ALL=C mkfs.vfat -F 16 ${mmcdisk}p1 -n ${label_boot}
sync
LC_ALL=C mkfs.ext4 ${mmcdisk}p2 -L ${label_rootfs}
sync

Damit das Skript als Argument funktioniert, müssen Sie den Namen des MMC-Geräts übergeben, d. H. z.B. / dev / mmcblk0 . Gehen Sie mit dem Namen des Geräts äußerst vorsichtig und aufmerksam um, da das Skript selbst diese MMC oder Festplatte nicht überprüft.
Nach dem Erstellen der Bootdiskette müssen wir nur die gesammelten Dateien korrekt kopieren. Kopieren Sie dazu auf der Boot-Partition den uImage- Kernel selbst , die Datei u-boot.bin und den MLO- Loader sowie die Konfigurationsdatei boot.scr . Im zweiten Abschnitt: rootfs müssen Sie das Archiv mit unserem Dateisystem rootfs.tar.bz2 entpacken .
Das ist alles, unser frisch zusammengestelltes Android ist fertig, heben Sie unsere microSD ab, legen Sie sie in das Zielgerät ein und schalten Sie den Strom ein. Manchmal müssen Sie natürlich die Reset-Taste drücken, und der allererste Startvorgang dauert etwas länger als gewöhnlich. Aber trotzdem - das ist ein "Kaltstart".

Fazit


Der Android-Erstellungsprozess für Mobiltelefone und Tablets sieht ähnlich aus, mit der Ausnahme, dass der Bereitstellungsprozess auf dem Zielgerät unterschiedlich ist. Und für Debug-Boards wie BeagleBoard und BeagleBone usw. nur die Gerätekonfigurationen unterscheiden sich.

Jetzt auch beliebt: