PEBDEV - v3 - Développements ARM

[MAC OSX] Installation d'une chaine de compilation ARM

2012-04-30T22:45:00+01:00

Dans la continuité d'une initiation au développement sur MAC OSX, nous allons installer une chaine de cross-compilation ARM EABI sur OSX Lion.

Soyons claire dès le début, l'installation peut être capricieuse. Alors comment arriver au bout sans soucis? En suivant à la lettre ce tuto, en ne sautant aucune ligne, pas même un simple redémarrage. :)

1- Installation de XCode

1- Installez la dernière version de Xcode 4.3 (sur l'AppStore)
2- REDEMARREZ
3- Lancez Xcode, Préférence > Download > Installez Command Line Tools
4- Mettez à jour le chemin de XCode (changement apparu dans la version 4.3). Lancez Terminal et entrez :

sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer

2- Installation d'Homebrew

Homebrew est un logiciel permettant de récupérer/installer simplement des packages Unix sur OSX. Lancez Terminal puis tapez les commandes suivantes :

cd /opt/
git clone https://github.com/mxcl/homebrew.git
cd homebrew
sudo cp -R * /usr/local
sudo chown -R votre_UserName /usr/local/
brew doctor

Ces commandes ont installé brew dans /usr/local et configuré ce chemin en lecture/écriture pour votre UserName. La commande brew doctor quand à elle permet de vérifier que l'installation c'est bien déroulée. Si vous avez des erreurs essayez de les corriger ou demandez de l'aide via les commentaires ci-dessous.

3- Compilation/Installation de CodeSourcery

Installons les outils nécessaires à la compilation :

brew install mpfr
brew install gmp
brew install libmpc
brew install texinfo
brew install libelf

Remarque : Si vous rencontrez une erreur lors de l'installation d'un des packages, ressayez plusieurs fois, cela peut finir par passer :)

cd /opt/
https://github.com/jsnyder/arm-eabi-toolchain.git
cd arm-eabi-toolchain
PREFIX=/opt/arm-eabi-toolchain/arm-cs-tools make install-cross

Et voila, dans le dossier /opt/arm-eabi-toolchain/arm-cs-tools vous trouverez votre bonheur :)
Pour utiliser le compilateur arm-none-gnueabi que nous venons de compiler, ajoutez simplement le path à la variable PATH :

export PATH=/opt/arm-eabi-toolchain/arm-cs-tools/bin:$PATH

Vous pouvez enfin vérifier que la compilation a réussi :

arm-none-eabi-gcc -v

Si vous rencontrez des soucis n'hésitez pas à poser vos questions dans les commentaires.

[IGEP v2][Angstrom] Construction d'Angstrom avec OpenEmbedded et Bitbake

2010-12-04T07:55:00+01:00

Après Android, nous allons tester une autre distribution orientée pour le monde de l'embarqué, Angstrom!
L'utilisation d'OpenEmbedded et de BitBake n'aura plus de secrets pour vous ;)

Angstrom est une distribution intéressante. Elle est légère, peut gourmande en ram et relativement simple à mettre en place. Si nous devions lui trouver un défaut, je ne pourrais en citer qu'un : le temps de construction de l'image rootfs extrêmement longue... Mais bon, après c'est le PC qui travaille, ce n'est donc pas vraiment un défaut^^.

Au niveau des informations sur cette distribution, il n'y en a pas beaucoup... Depuis peu, Archos s’intéresse à cette distribution pour ses tablettes, il est donc possible que les informations fleurissent petit à petit.
C'est un projet issu du regroupement de plusieurs autres projets : OpenZaurus, OpenEmbedded et OpenSimpad.

Voila pour les présentations. Je vous laisse le lien du site officiel : http://www.angstrom-distribution.org/.

Cet article fait appel à des notions vues dans les articles précédents. J'ai essayé de détailler au maximum, cependant certaines informations peuvent ne pas être ré-expliquées. Dans ce cas je vous conseil d’aller faire un petit tour dans la rubrique ARM ;)

Informations sur la construction d'Angstrom

La construction de cette distribution se fait à l'aide de deux outils :

OpenEmbedded : c'est un regroupement de composants libre pouvant être utilisés pour un système embarqué. Une sorte de grosse bibliothèque de l'embarquée :)
BitBake : c'est un exécuteur de tâches et un gestionnaire de metadata. Il permet de construire des packages en gérant les dépendances, la cross-compilation,... En gros, c'est le make pour OpenEmbedded (vulgarisation pour simplifier les choses).

Nous allons uniquement interagir avec ces deux outils, ce qui rend la construction simple.

Préparation de notre environnement de travail

Avant de commencer, nous devons installer quelques packages :

$ apt-get install diffstat texi2html git cvs subversion gawk chrpath gcc g++ python-psyco

Ensuite on se place dans notre dossier de travail habituel :

$ cd /srv/nfs/angstrom/image-base/igep020/

Installation des outils

Installation de BitBake
- Téléchargement de BitBake : bitbake-1.10.1.tar.gz (lien serveur).
- On créer nos dossiers de travail :

// Création de dossiers
$ mkdir -p build/conf
$ mkdir -p bibake

- On décompresse BitBake dans bitbake/

$ tar xfvz bitbake-1.10.1.tar.gz -C bitbake/
Installation d'OpenEmbedded
- On télécharge OpenEmbedded :

$ git clone git://git.openembedded.org/openembedded

Voila, c'est tout^^

Configuration pour la construction d'images/packages

- On doit créer un fichier de configuration pour spécifier à Bitbake notre cible.
Pour cela, suivez les étapes suivantes :

// Copie du fichier de configuration de base :
$ cp openembedded/conf/local.conf.sample build/conf/local.conf

// Edition du fichier de configuration
$ nano build/conf/local.conf

//Modifiez les lignes suivantes
- DL_DIR = "/srv/nfs/angstrom/image-base/igep020/sources"
- BBFILES = "/srv/nfs/angstrom/image-base/igep020/openembedded/recipes/*/*.bb"
- MACHINE = "igep0020"
- DISTRO = "angstrom-2008.1"
- Commentez la dernière ligne

Quelques petites explications sur ces modifications.

Pour connaitre les distributions possibles, vous pouvez faire un tour dans le dossier openembedded/conf/distro/. Les fichiers .conf représentent les différents distributions.
Pour connaitre les machines disponibles, suivez ce lien : http://gitorious.org/angstrom/openembedded/trees/org.openembedded.dev/conf/machine.

Dernière chose, on configure les variables d'environnements :

// Nos variables habituelles pour la cross-compilation
$ export ARCH=arm
$ export CROSS_COMPILE=/opt/codesourcery/bin/arm-none-linux-gnueabi-
$ export PATH=/opt/codesourcery/bin/:$PATH

// Variables pour BitBake
$ export BBPATH=$/nfs/angstrom/image-base/igep020/stuff/angstrom-setup-scripts/build:/nfs/angstrom/image-base/igep020/stuff/angstrom-setup-scripts/sources/openembedded
$ export PATH=/nfs/angstrom/image-base/igep020/stuff/angstrom-setup-scripts/sources/bitbake/bin:$PATH

Pensez bien à les configurer à chaque nouvelle session.

Comme nos variables commencent à devenir longue à taper, je vous conseil de créer un fichier qui permettra de les charger rapidement. Pour cela créer un fichier .vars_bashrc où vous souhaitez (le nom n'a pas d'importance), mettez toutes les variables d'environnement que vous souhaitez dedans.
Pour le charger (pour la session), tapez la commande suivante :

$ source .vars_bashrc

Voila, nous avons tous nos outils d'installés et configurés pour notre igep!
Pensez bien à mettre à jour BitBake et OpenEmbedded de temps en temps (je vous rappel qu'avec git, pour mettre à jour, vous devez faire un git pull).

Construction d'images/packages

Pour avoir la fameuse rootfs d'Angstrom, nous allons construire l'image à l'aide des outils précédements installés. Vous allez voir, c'est un jeu d'enfant :)

Nous allons commencer par construire une image de base d'Angstrom (très légère, mais "console" uniquement). Pour cela, tapez la commande suivante dans votre terminal :

$ MACHINE=igep0020 bitbake base-image

ATTENTION : La construction m'a pris environ 24h! Durant tout ce temps, le PC doit resté connecté à internet! Sachez le, le moindre package peut prendre plusieurs heures de construction! (exemple : nano = 9h).

Si vous souhaitez construire une image avec une interface, tapez ceci :

$ MACHINE=igep0020 bitbake x11-image

En gros vous devez saisir < nom_image_souhaitee >-image ou alors uniquement < package >.
Voila, il n'y a rien de plus à savoir pour la construction :)

Test de la rootfs Angstrom

La première chose à faire et à ne surtout pas oublier, c'est la configuration réseau du PC, du montage nfs, du serveur tftp et d'u-boot.

Pour ce qui est du PC : (en root)

$ ifconfig eth0 192.168.254.10 netmask 255.255.255.0

Pour le NFS ajoutez simplement les lignes suivantes au fichier /etc/exports :

# Angstrom image-base
/srv/nfs/angstrom/image-base/igep020/rootfs/ 192.168.254.254(rw,no_root_squash,no_subtree_check,sync)

Il n'est pas utile de supprimer les autres lignes ;).

On pense à relancer le serveur :

$ /etc/init.d/nfs-kernel-server restart

Pour le tftp, rien à faire. Pensez juste à mettre votre uImage (celle que vous avez utilisé pour BusyBox par exemple) dans le dossier :
/srv/tftp/angstrom/base-image/igep020/kernel/.

Pour uboot, lancez putty, allumez la carte et entrez dans le menu de config u-boot. Vérifiez ensuite les variables suivantes :

nfs-boot=if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/kernel/uImage; bootm; fi;

nfs-bootargs=setenv bootargs ${bootargs-base} init=/init root=/dev/nfs nfsroot=${serverip}:/srv/nfs/${distro}/${project}/${machine}/rootfs ; run addip

Si vous n'avez pas ces valeurs, je vous rappel la commande pour les modifier :

$ setenv nfs-boot 'if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/kernel/uImage; bootm; fi;'

$ setenv nfs-bootargs 'setenv bootargs ${bootargs-base} init=/init root=/dev/nfs nfsroot=${serverip}:/srv/nfs/${distro}/${project}/${machine}/rootfs ; run addip'

Voila! Tout est ok! Maintenant vous relancez la carte (par l'alimentation ou par un petit run bootcmd dans u-boot).

Si vous avez compilé une image de base, vous obtenez ceci :

(Comment ça mon image est floue? et pas centrée? et bien...oui^^)

Si vous avez compilé une image x11, vous obtenez ceci :

Nous avons terminé! Au cours de cet article, vous avez pu remarquer l'avantage majeur de cette distribution : sur quelques Mo vous avez une rootfs avec une interface graphique ultra légère! C'est une très bonne base de travail ;)
Pour la rootfs "console" par contre le gain est beaucoup moins important. En effet, environ 24h de construction est peut être beaucoup pour un simple rootfs... Après c'est intéressant de savoir que cela existe.

Si vous avez des questions, remarques ou autres, les com' ci-dessous sont là pour ça.

[IGEP v2][BusyBox] Créez votre distribution

2010-11-22T14:21:00+01:00

Allez, c'est parti! Aujourd'hui, nous allons créer notre distribution embarquée pour l'IGEP. L'avantage sera majeur : nous intégrerons uniquement ce que nous voulons.

Dans cet article nous utiliserons un montage NFS et un serveur tftp pour faire nos tests. Je vous conseil donc très fortement de lire le post à ce sujet avant d'attaquer ce morceau ([IGEPv2] Kernel et Rootfs via tftp et nfs).

Nous utiliserons aussi Git, un gestionnaire de version. Si vous ne l'avez pas, installez le :

$ apt-get install git

Nous aurons aussi besoin de la librairie ncurses pour disposer d'une interface plus conviviale lors des menuconfig :

$ apt-get install libncurses5-dev

Préparation de notre environnement de travail

On va commencer par le plus simple, créer nos dossiers. Comme dans l'article précédent, nous allons suivre cette hiérarchie de dossier :
/srv/tftp/pebdev-dist/image-base/igep020/kernel/
/srv/nfs/pebdev-dist/image-base/igep020/rootfs/

Nous devrons utiliser le Bourne Shell, si vous êtes sur Debian :

$ dpkg-reconfigure dash

Répondre NON.

Chaîne de compilation croisée

Nous allons compiler sur notre PC des fichiers qui devront être exécutés sur une plate-forme ARM. Nous ne pouvons donc pas utiliser le compilateur gcc classique. Si nous le faisons, les fichiers pourront être exécutés uniquement sur une plate-forme i386 (un PC). En effet, le compilateur va transformer un code source en une suite d'instructions compréhensible par la plate-forme cible. Voila pourquoi nous devons utiliser un compilateur croisé, et dans notre cas, pour une cible ARM.

Notre choix se portera sur CodeSourcery G++ Lite. Ne vous posez pas de question sur le G++, c'est bien un compilateur C/C++ :)

Lien du projet G++ : CodeSourcery G++

Commencez par le télécharger :

Allez sur la page de téléchargement.
Sélectionnez GNU/Linux.
Téléchargez la dernière version.

Ensuite nous l'installons :

$ chmod +x arm-2010q1-202-arm-none-linux-gnueabi.bin
$ mkdir /opt/codesourcery
$ chown peb /opt/codesourcery
$ ./arm-2010q1-202-arm-none-linux-gnueabi.bin

Rien de compliqué lors de l'installation. Notez juste que vous devez choisir une installation Custom pour définir le chemin d'installation /opt/codesourcery/.

Maintenant nous allons tester l'installation :

//On met à jour temporairement la variable PATH
$ export PATH=/opt/codesourcery/bin:$PATH

//Si vous souhaitez visualiser le résultat
$ echo PATH

//On regarde la version du compilateur
$ arm-none-linux-gnueabi-gcc -v

Normalement vous devriez avoir un pavé de texte qui s'affiche, si ce n'est pas le cas, c'est qu'il y a un problème avec l'installation ou que votre variable PATH n'a pas été mise à jour correctement...

Si vous fermez le terminal, les modifications faites sur la variable PATH seront perdues, pensez à la remettre à jour.
Sinon il existe une autre méthode plus rapide qui consiste à se loguer ainsi :
$ su - peb
Dans ce dernier cas, la variable sera ajoutée toute seule :)

Compilation d'un noyau de base

Attention aux âmes sensibles... On est entre nous, donc pour la préparation du noyau pour l'IGEP, on va bourrinner et en faire le strict minimum :p
Par là, comprenez que nous allons récupérer les sources d'un noyau linux omap, mais qu'on va le compiler en utilisant une configuration déjà préparée. Nous toucherons éventuellement 2,3 paramètres, mais attention, pas plus! ;)

Allez, on télécharge ce noyau omap qu'ISEE nous propose pour l'IGEP (http://git.igep.es/). Pour cela on va cloner le repo avec git (attention ça prend du temps : ~20min pour moi.NE PAS ETRE EN ROOT) :

$ cd /srv/tftp/pebdev-dist/image-base/igep020/kernel/
$ git clone git://git.igep.es/pub/scm/linux-omap-2.6.git

La première étape après le téléchargement, c'est de bien choisir le noyau que l'on souhaite :

$ cd linux-omap-2.6

//On regarde les différentes versions
$ git tag

//On choisi la dernière version
$ git checkout -b v2.6.35.9-0 v2.6.35.9-0

Juste avant, pour la compilation croisée, on doit configurer 2 variables :

$ export ARCH=arm
$ export CROSS_COMPILE=/opt/codesourcery/bin/arm-none-linux-gnueabi-

Cela permet de renseigner notre cible et le compilateur à utiliser.

Ensuite on charge la configuration pour notre carte. Pour cela on va chercher une configuration qui comporterait le mot igep :

$ cd linux-omap-2.6
$ make help | grep igep

Et là on cherche dans le résultat un fichier de configuration qui pourrait aller pour notre carte igep... et ça tombe bien! il y a un fichier qui se nomme igep0020_defconfig! On va donc utiliser cette configuration :)

Maintenant on charge le fichier de configuration :

$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- igep0020_defconfig

On lance ensuite le menu de configuration :

$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- menuconfig

A titre indicatif, ici on peut modifier la configuration du noyau. Bien sur nous, nous allons prendre soin de ne rien toucher, le fichier de configuration c'est chargé de tout ça^^

Donc c'est parti, on peut compiler (~45min) :

$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- uImage modules

Note : si à la fin de la compilation un message vous indique que l'uImage n'a pas pu être générée parce qu'il manque le package qui va bien (et dont je ne me souviens pas du nom^^⁾, installez le et retapez la commande précédente.

Voila, nous avons notre noyau. Il se nomme uImage et se trouve dans :
/srv/tftp/pebdev-dist/image-base/igep020/kernel/linux-omap-2.6/arch/arm/boot/.

A noter aussi, le mot modules va nous permettre de générer les drivers que l'on pourra ajouter à la rootfs par la suite.

Rootfs de base avec BusyBox

Nous avons un noyau, nous pouvons donc nous attaquer à la rootfs. Dans un premier temps, nous allons mettre le strict minimum de sorte à avoir un shell.
Pour cela il existe un petit outils assez pratique : BusyBox.

On le télécharge avec Git (NE PAS ETRE EN ROOT), faites bien attention au chemin cible :

$ cd /srv/nfs/pebdev-dist/image-base/igep020/
$ git clone git://git.busybox.net/busybox

Si vous avez fermé votre terminal après la compilation du noyau, pensez bien à vous loguer correctement et à configurer les 2 variables pour la compilation :

$ export ARCH=arm
$ export CROSS_COMPILE=/opt/codesourcery/bin/arm-none-linux-gnueabi-

On lance ensuite le menu de configuration :

$ cd busybox/
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- menuconfig

Ensuite dans le menu BusyBox Settings > Build Options.
Cochez la case (touche espace) : [*] Build BusyBox as a static bianry
Complétez aussi la ligne pour la cross-compilation : (/opt/codesourcery/bin/arm-none-linux-gnueabi-) Cross Compiler prefix

Nous allons aussi changer le chemin d'installation, pour cela revenez au menu principal, est allez dans BusyBox Settings > Installation Options.
Pour l'option BusyBox installation prefix configurez le chemin suivant ../rootfs/

Nous n'avons que cela à configurer. Faites donc Exit le nombre de fois qu'il faut pour quitter le menu. Lorsqu'on vous le demande, enregistrez la nouvelle configuration.

Tout est prêt, nous pouvons compiler!

$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- install

Nous avons notre rootfs dans /srv/nfs/pebdev-dist/image-base/igep020/rootfs/.

Nous ajoutons les modules du noyau :

$ cd /srv/tftp/pebdev-dist/image-base/igep020/kernel/linux-omap-2.6
$ make PREFIX=/opt/codesourcery/bin/arm-none-linux-gnueabi- modules_install INSTALL_MOD_PATH=/srv/nfs/pebdev-dist/image-base/igep020/rootfs/

Et enfin, pour terminer, nous ajoutons les noeuds de périphériques statiques. Pour cela nous utiliserons un petit programme que nous allons commencer par télécharger :

$ apt-get install makedev

Maintenant on l'utilise :

$ cd /srv/nfs/pebdev-dist/image-base/igep020/rootfs/
$ mkdir dev
$ cd dev/
$ su root
$ /sbin/MAKEDEV console
$ /sbin/MAKEDEV fb0
$ /sbin/MAKEDEV null
$ /sbin/MAKEDEV std
$ /sbin/MAKEDEV tty
$ /sbin/MAKEDEV ttyS
$ /sbin/MAKEDEV hd

Voila, notre rootfs est prête!

Test de la distribution par tftp et NFS

Si vous vous souvenez bien (cf. article précédent), la première chose à faire est de configurer le tftp et le nfs. Pour le tftp, nous n'avons rien à modifier sur le PC, par contre pour le nfs nous devons mettre à jour le chemin d'accès.

Pour cela on édite le fichier /etc/exports, on commente le chemin qui pointe vers la rootfs d'Android et on ajoute la ligne suivante :

# pebdev-dist image-base
/srv/nfs/pebdev-dist/image-base/igep020/rootfs/ 192.168.254.254(rw,no_root_squash,no_subtree_check,sync)

On redémarre le serveur nfs pour terminer :

$ /etc/init.d/nfs-kernel-server restart

On pense aussi à configurer l'adresse IP du PC :

$ ifconfig eth0 192.168.254.10

Maintenant on doit reconfigurer uboot. On branche la carte, on interrompt la séquence d'autoboot grâce à la liaison série (si cela ne vous parle pas, allez faire un tour sur l'article précédent), et on change les variables d'environnement qu'il faut :

//On change le nom de la distribution
$ setenv distro 'pebdev-dist'

//On change l'accès au noyau
$ setenv nfs-boot 'if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/kernel/linux-omap-2.6/arch/arm/boot/uImage; bootm; fi;'

//On sauvegarde les variables
$ saveenv

Voila! Tout est prêt! On lance la commande run bootcmd à uboot pour voir le résultat...

Si vous branchez un clavier et que vous appuyez sur une touche vous aurez accès au shell.

Nous verrons dans un prochain article comment rendre notre roofs plus conviviale.

Si vous avez des questions, comme d'habitude, n'hésitez pas à utiliser les com ci-dessous ;)

[IGEP v2] Kernel et Rootfs via tftp et nfs

2010-11-21T13:42:00+01:00

Après avoir réussi à démarrer Android sur l'IGEP à partir de la microSD, nous allons mettre en place un environnement de développement pour éviter d'avoir à manipuler sans cesse la microSD. Pour cela nous allons utiliser un serveur tftp pour que la carte récupère le noyau à partir du PC, et un montage nfs pour que la carte charge la rootfs directement à partir de notre dossier de travail.

Remarque : Il est fortement conseillé de lire l'article précédent : LIEN.

Commençons par installer les packages :

$ apt-get install tftpd nfs-kernel-server

On a va ensuite définir notre environnement de travail (hiérarchie de nos dossiers) ainsi :
/ srv / tftp /android / image-base / igep020 / kernel /
/ srv / nfs /android / image-base / igep020 / rootfs /

Pourquoi de cette manière? Afin de suivre la structure suivante :
[distribution] / [Projet] / [plate-forme] /

Respectez cette structure, c'est important pour la suite ;)

Important : pour éviter les Access violation dans le futur, et après avoir créé ces dossiers, revenez dans /srv et changez les accès :

$ chmod -R 777 tftp
$ chmod -R 777 nfs

Mise en place du serveur tftp

Rien de particulier à faire pour configurer le serveur tftp, sachez juste que le fichier de configuration est le suivant : /etc/inetd.conf. Si vous souhaitez le modifier n'oubliez pas de taper la commande killall -HUP inetd après.

Vous pouvez copier le noyau Android fourni par ISEE dans le dossier tftp/android/... (uImage-2.6.29-igep0020-20100407145010.bin).

Note : pensez bien à renommer le noyau uImage-2.6.29-igep0020-20100407145010.bin en uImage (pensez bien à enlever le .bin), sans quoi uboot ne trouvera pas l'image.

Pour le fichier boot.ini ne le copiez pas comme dans l'article précédent, je vous expliquerai plus bas le pourquoi ;)

Voila, pour le serveur tftp c'est bon!

Mise en place du montage NFS

Nous allons éditer le fichier de configuration NFS.
Éditez le fichier/etc/exports et ajoutez la ligne suivante :

# Android image-base
/srv/nfs/android/image-base/igep020/rootfs 192.168.254.254(rw,no_root_squash,no_subtree_check,sync)

Remarque : l'adresse IP 192.168.254.254 correspond à l'IP par défaut de l'IGEP.

On redémarre le serveur nfs pour terminer :

/etc/init.d/nfs-kernel-server restart

Vous pouvez extraire (en root) la rootfs dans le dossier nfs/android/... (android-image-eclair-2.1-update1-20100407145010.tar.bz2) :

$ tar xvfj android-image-eclair-2.1-update1-20100407145010.tar.bz2 -C /srv/nfs/android/image-base/igep020/rootfs/

Le NFS est prêt.

Configuration d'u-boot

U-boot permet à la carte de démarrer le système. Ainsi il est intéressant de connaître 2,3 commandes importantes pour interagir avec lui.

Vous vous souvenez du fichier boot.ini que nous avons créé dans l'article précédent? Vous deviez vous demander à quoi servait ce fichier? Et bien il permet de paramétrer uboot de façon "temporaire", afin de modifier certains paramètres. Si nous ne souhaitons pas utiliser ce fichier (notre cas ici), nous devons alors paramétrer directement uboot.

Lorsque vous branchez la carte, vous pouvez voir via la liaison série un message vous invitant à appuyer sur une touche pour stopper le processus de boot. Faites le, vous accéderez ainsi aux entrailles de uboot ;)

Juste à titre indicatif, je suis passé de minicom à putty pour l'interface série. La raison de ce changement est l'impossibilité d'envoyer des commandes avec minicom. En gros, si vous appuyez sur une touche et que le compteur continu son avancé folle, c'est que vous rencontrez le même problème que moi. Deux solutions s'offrent à vous, soit vous trouvez une solution avec minicom, soit vous utilisez putty :p

Si vous souhaitez passer aussi sur putty, pensez à aller dans Terminal, de cocher implicit CR in every LF, puis Force On pour les options Line discipline.
Minute astuce : pour copier dans putty faites un clic droit, pour coller faites un clic gauche-droit.

Revenons en à U-boot. Voici les principales commandes :

printenv : permet d'afficher les variables 'environnement.
setenv : permet de changer la valeur d'une variable.
run : lance ce que vous indiquez après cette commande.
saveenv : sauvegarde les changements.
help : aide d'u-boot

Maintenant intéressons nous aux variables plus en détail.

La variable bootcmd, permet de définir la séquence de boot. Si vous faites un printenv bootcmd vous obtiendrez l'ordre de boot suivant :

bootcmd=run mmc-boot; run nfs-boot; run onenand-boot

Si vous souhaitez intervertir la microSD et le NFS par exemple, vous pouvez utiliser la commande setenv :

$ setenv bootcmd 'run nfs-boot; run mmc-boot; run onenand-boot'
La variable serverip définit l'adresse IP du serveur (sérieux? :p), nous retiendrons donc que l'adresse ip du pc devra être 192.168.254.10.
Les variables distro, project et machine doivent vous rappeler quelque chose... En effet, je vous en ai parlé au tout début de cet article! Elles vont définir le chemin d'accès pour le montage nfs et pour accéder au serveur tftp.

Nous allons donc les modifier pour que cela puisse coller avec ce qu'on a défini plus haut :

$ setenv distro 'android'
$ setenv project 'image-base'
$ setenv machine 'igep020'

Les variables nfs-bootargs et nfs-boot contiennent le chemin d'accès nfs et tftp. Il faut donc les adapter à notre environnement. La variable bootargs-base paramètre divers périphériques, nous la reprendrons aussi pour adapter l'affichage :

Initialement nous avons :

bootargs-base=mem=512M console=ttyS2,115200n8 console=tty0 omapfb.mode=dvi:1024x768MR-16@60

nfs-bootargs=setenv bootargs ${bootargs-base} root=/dev/nfs nfsroot=${serverip}:/srv/nfs/${distro}/${project}/${machine} ; run addip

nfs-boot=if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/uImage; bootm; fi;

Nous les remplaçons par :

$ setenv bootargs-base 'mem=512M console=ttyS2,115200n8 console=tty0 omapfb.mode=dvi:1024x768MR-16@60 omap-dss.def_disp=dvi'

$ setenv nfs-bootargs 'setenv bootargs ${bootargs-base} init=/init root=/dev/nfs nfsroot=${serverip}:/srv/nfs/${distro}/${project}/${machine}/rootfs ; run addip'

$ setenv nfs-boot 'if ping ${serverip}; then run nfs-bootargs; tftp 0x80000000 ${distro}/${project}/${machine}/kernel/uImage; bootm; fi;'

Remarque : dans nfs-bootargs nous devons aussi ajouter l'accès init (init=/init). Lorsque nous travaillons avec la microSD, ce paramètre était dans le fichier boot.ini.

Voila, on a tout bien configuré, on peut sauvegarder :

$ saveenv

Voila! Maintenant vous êtes capable de, soit d'utiliser un fichier boot.ini, soit de paramétrer directement uboot :)

Lancement d'android

On configure la carte Ethernet du PC :

$ ifconfig eth0 192.168.254.10

Cet adressage est valable pour la session actuelle, si vous redémarrez votre PC n'oubliez pas de reconfigurer l'adresse IP d'eth0! Si vous souhaitez fixer définitivement l'adresse IP, modifiez le fichier /etc/network/interfaces.

Ensuite on pense à bien retirer la microSD (dans le cas où vous n'avez pas touché la variable bootcmd d'uboot) et on y va, on envoi un petit run bootcmd à uboot (via putty ou minicom) pour démarrer le système ou alors si vous aviez éteint votre IGEP, et bien vous la rebranchez^^

On observe ce qui se passe. Première étape, la récupération du noyau par tftp par la carte :

Using smc911x-0 device
TFTP from server 192.168.254.10; our IP address is 192.168.254.254
Filename 'android/image-base/igep020/kernel/uImage'.
Load address: 0x80000000
Loading: #################################################################
#################################################################
#################################################################
#################################################################
#################################################################
#################################################################
##########################
done

Ici la récupération c'est bien déroulée. Si jamais cela ne fonctionne pas :

Erreur (1) [Fichier non trouvé] : la configuration du chemin d'accès est mauvaise, soit dans uboot, soit dans le fichier de config de tftp. Comme vous n'avez théoriquement pas modifié la config de tftp, le problème vient de uboot ;).
Erreur (2) [Access Violation] : Faites un petit chmod -R 777 /srv.

Ensuite au tour du montage NFS. Les lignes importantes sont les suivantes :

IP-Config: Complete:
device=eth0, addr=192.168.254.254, mask=255.255.255.0, gw=192.168.254.10,
host=192.168.254.254, domain=, nis-domain=(none),
bootserver=192.168.254.10, rootserver=192.168.254.10, rootpath=
Looking up port of RPC 100003/2 on 192.168.254.10
Looking up port of RPC 100005/1 on 192.168.254.10
VFS: Mounted root (nfs filesystem) on device 0:13.

La dernière ligne nous informe que le montage NFS a été correctement fait.
Si ce n'est pas le cas, le problème vient soit du fichier de config du nfs, soit de uboot.

Dernière étape, le chargement du rootfs. Là, pas de secret. Si vous avez un kernel panic c'est que vous avez fait une bourde soit dans la configuration d'uboot, soit dans la mise en place des fichiers...

Si tout se passe bien vous devriez obtenir ça sur la sortie HDMI :

Si vous avez un soucis, une remarque ou autres, les commentaires ci-dessous sont là pour ça ;)

[IGEP v2] [Android] Kernel et Rootfs sur miniSD

2010-11-21T01:02:00+01:00

La présentation de l'IGEP étant faite, nous allons mettre les mains dans le cambouis avec comme objectif le boot d'Android pré-compilée, à partir d'une carte miniSD.

Lien vers l'article précédent : LIEN

Objectif : démarrer Android 2.1 (eclair) sur l'IGEP à partir de la microSD.

Formatage de la microSD

Nous allons tout d'abord faire deux partitions sur la microSD :

Une partition VFat pour le noyau
Une seconde partition au format ext2 pour le rootfs

On va utiliser l'utilitaire de disque (Applications > Outils système) pour faire ça rapidement :

Sélection du bon disque (Generic - Multi-Card pour ma part)
On démonte la partition
On supprime la partition déjà présente
On créer la première partition boot en Fat (200Mo est largement suffisant)
On créer la seconde partition rootfs en ext2 (le reste de la microSD) en décochant les cases

Mise en place du noyau

Maintenant nous allons mettre le noyau pour Android fourni par isee sur la partition boot.
Téléchargez l'image : uImage-2.6.29-igep0020-20100407145010.bin
Note : pensez bien à renommer le noyau uImage-2.6.29-igep0020-20100407145010.bin en uImage (pensez bien à enlever le .bin), sans quoi uboot ne trouvera pas l'image.

Créez ensuite sur votre disque le fichier boot.ini.android :

# Set bootargs for android MMC boot
setenv bootargs 'mem=512M androidboot.console=ttyS2 console=tty0 console=ttyS2,115200n8 root=/dev/mmcblk0p2 rw rootdelay=3 init=/init rootwait omap-dss.def_disp=dvi omapfb.video_mode=800x600MR-16@60'
# Read kernel from FAT partition
fatload mmc 0:1 80100000 uImage
# and boot ...
bootm 80100000

On le converti en fichier boot.ini pour uboot :

$ mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n 'Boot setup script' -d boot.ini.android /media/boot/boot.ini

Voila, le fichier boot.ini a été écrit sur la partition boot. Sachez juste pour le moment que ce fichier sert à paramétrer uboot (ci cela ne vous dit rien, ce n'est pas grave, nous en reparlerons dans un autre article). Avant de mettre la rootfs, nous allons nous assurer que le noyau démarre correctement. Mettez en place la liaison série, mettez la microSD dans l'IGEP et branchez.
Si vous faites attention à ce qui s'affiche, vous voyez les différentes étapes :

L'x-loader charge u-boot.bin
L'u-boot détecte le matériel de l'IGEP
La microSD est détectée :mmc0
Lecture de l'uImage sur la microSD/
Chargement du noyau

Si vous n'obtenez pas cela et que l'IGEP boot sur Poky, c'est que vous avez fait une bourde.

Mise en place du rootfs

Là non plus, rien de compliqué. Téléchargez l'image rootfs :
android-image-eclair-2.1-update1-20100407145010.tar.bz2

Ensuite nous décompressons l'archive sur la partition rootfs: (en root)

$ tar xvfj android-image-eclair-2.1-update1-20100407145010.tar.bz2 -C /media/rootfs/

Démontez la microSD, mettez la dans l'IGEP, branchez, patientez un peu et là... vous avez des Chocapics!

Si vous avez un soucis, une remarque ou autres, les commentaires ci-dessous sont là pour ça ;)

[IGEP v2] Premiers pas avec l'IGEP v2

2010-11-20T22:15:00+01:00

La carte IGEP v2 de la société ISEE est un véritable petit ordinateur pour le monde de l'embarqué. Vous pourrez trouver dans ce topic des infos pour bien débuter avec.

Commençons tout d'abord les présentations. En une phrase, ses caractéristiques sont assez impressionnantes! La carte n'est guère plus grande qu'une carte de crédit, et pourtant elle est vraiment très complète :

TI OMAP3530: ARM CORTEX A8 core (720Mhz) + POWERVR SGX 530 core + IVA2.2 + DSP TMS320C64+
4Gb NAND/ 4Gb Mobile Low Power DDR SDRAM @ 200 Mhz
Ethernet 10/100 Mb BaseT (SMSC LAN9221i)
Wifi IEEE 802.11b/g (Marvell 86w8686B1)
Bluetooth 2.0 (CSR BC4ROM/21e)
Antenne intégrée, connecteur pour une externe.
1 x USB 2.0 OTG
1 x USB 2.0 Host
Port MicroSD
Port HDMI
Stereo audio in et out.
Connecteur pour I/O, Camera, SPI, UART...
Connecteur pour LCD.
RS232
RS485
Connecteur JTAG(2x7)

Pour plus d'informations sur cette carte, je vous laisse le lien du fabricant : LIEN.

Petite précision avant d'attaquer le morceau et juste à titre indicatif, je développe sous Debian.

L'objectif de ce post va être de présenter les interfaces de la carte.

Utilisation de la liaison RS232

> Au niveau Hardware

Pour mettre en place la liaison série, vous devez disposer de :

Un convertisseur RS232 <-> USB
Un câble DB9-M TO IDC-10 pour l'interface avec l'IGEP. Pour info le schéma de câblage est disponible dans le manuel software, c'est pas vraiment logique tout ça^^
Le voici :
Un câble série croisé M-M (RX<->TX et TX<->RX) afin de relier les deux autres morceaux précédents. ;) Pour ce dernier, voici une petite illustration si vous ne voyez pas ;)

> Terminal : minicom

Je vous conseil minicom ou PuTTy.
Avant toute chose on configure le modem sur minicom (en root) :

//Lancement en root pour configurer le modem
$ minicom -s /dev/ttyUSB0

Dans Serial port Setup, pour E-, mettre 115200 8N1 (115200bps, sans parité, 1 bit de stop et 8 bits de données). Ensuite on sauvegarde et c'est bon, le modem est prêt.

Remarque : le menu de minicom est accessible avec CTRL+A.

Utilisation de la liaison Ethernet

Pour cela rien de bien compliqué, une simple connexion ssh est nécessaire. Si vous démarrez la carte avec la distribution déjà présente sur la NAND, vous devez procéder ainsi : (en root)

//Configuration de votre carte Ethernet
$ ifconfig eth0 192.168.254.10

//Connexion SSH (mot de passe letmein)
$ ssh root@192.168.254.254

Les ports USB

Deux ports USB sont présents sur la carte :

Un USB (mini) OTG (support USB 1.0/1.1./2.0)
Un USB A 2.0 uniquement (pour le support des USB 1.0/1.1./2.0 il vous faudra passer par un hub)

En gros, soit vous passez par un adaptateur [mini-USB]<->[USB A] avec un hub usb après, soit vous branchez le hub directement sur le port USB A.
Cependant méfiez-vous! Je me branche sur l'USB A, et pour ma part seul un hub alimenté fonctionne, les autres hubs auto-alimentés (sans alimentation externe) dont je dispose n'ont jamais fonctionné...

Le port JTAG

En cours de rédaction...

PEBDEV - v3 - Développements ARM

[MAC OSX] Installation d'une chaine de compilation ARM

1- Installation de XCode

2- Installation d'Homebrew

3- Compilation/Installation de CodeSourcery

[IGEP v2][Angstrom] Construction d'Angstrom avec OpenEmbedded et Bitbake

Informations sur la construction d'Angstrom

Préparation de notre environnement de travail

Installation des outils

Installation de BitBake

Installation d'OpenEmbedded

Configuration pour la construction d'images/packages

Construction d'images/packages

Test de la rootfs Angstrom

[IGEP v2][BusyBox] Créez votre distribution

Préparation de notre environnement de travail

Chaîne de compilation croisée

Compilation d'un noyau de base

Rootfs de base avec BusyBox

Test de la distribution par tftp et NFS

[IGEP v2] Kernel et Rootfs via tftp et nfs

Mise en place du serveur tftp

Mise en place du montage NFS

Configuration d'u-boot

Lancement d'android

[IGEP v2] [Android] Kernel et Rootfs sur miniSD

Formatage de la microSD

Mise en place du noyau

Mise en place du rootfs

[IGEP v2] Premiers pas avec l'IGEP v2

Utilisation de la liaison RS232

> Au niveau Hardware

> Terminal : minicom

Utilisation de la liaison Ethernet

Les ports USB

Le port JTAG