lien vers le Market Android
Market Android
tuto.VDLys  
Android sur mini2440


ÔĽŅVoici une proc√©dure d'installation d'Android sur une carte ARM9 mini2440, √©quip√©e d'une dalle tactile 5.6" :

VDLysDom Srv commandé depuis une carte ARM mini2440 :


J'ai installé Android 1.5 et développé une appli pour un proto basé sur une carte mini2440, depuis une machine sous Windows.
Mais certaines op√©rations, comme la cross compilation d'un kernel, o√Ļ la g√©n√©ration d'un image du FS, obligent √† avoir un Linux sous la main.
Pour ma part, j'utilise un live Ubuntu installé sur une partition, avec un dual boot.

La carte mini2440
La carte mini2440 :
La carte boot de 2 manières :

S2 est en position NAND sur la photo.

Sur la flash NOR (switch S2 en position NOR), supervivi est déjà installé.
Sur la flash NAND (switch S2 en position NAND), l'emplacement est vierge...

La NOR est là uniquement pour configurer la NAND.
Supervivi est installé en NOR, et permet d'installer sur la NAND, soit Supervivi (oui encore), soit u-boot (plus compliqué, mais aussi plus évolué que supervivi).

Un bouton Reset est également disponible :


Le logiciel
DNW.exe

Le Logiciel DNW.exe :
Il y a systématiquement 3 parties à installer pour faire fonctionner la carte :
1/ Le bootloader (u-boot ou supervivi)
2/ Le kernel (zImage ou uImage)
3/ Le File System (FS)

Ces 3 parties sont à envoyer séparément sur la carte.
Pour cela, vous utilisez un logiciel : DNW.exe

DNW est sur le CD livré avec la mini2440.
Télécharger
Il utilise un port série pour afficher ce que la carte mini2440 envoie.

Il faut aller dans le menu "Configuration" pour saisir le numéro du port COM.
DNW utilise aussi un port USB pour envoyer les données sur la carte : bootloader, kernel, FS


Les fichiers pour la mini2440
Les fichiers pour la mini2440 :
  • u-boot
  • Ce fichier est sur le CD livr√© avec la mini2440.
    Télécharger
    U-Boot Quick Reference

  • supervivi
  • Ce fichier est sur le CD livr√© avec la mini2440.
    Télécharger

  • kernel TFT640480 (√©cran 5.6")
  • Le kernel contient les drivers et la configuration de votre carte : √©cran, dalle tactile, ethernet, WiFi, etc...
    Des kernels sont livrés sur le CD, en fonction de l'écran TFT utilisé.
    Le kernel pour mon écran 5.6" n'étant pas disponible, je l'ai donc compilé avec un cross compilateur arm/x86 :
    Le kernel zImage : Télécharger.
    Le kernel uImage : Télécharger.

  • Le File Systeme, il contient Android dans notre cas.
  • Un fichier au format tar d'Android est disponible en t√©l√©chargement sur internet.
    Le contenu de ce fichier est une arborescence de repertoires et de fichiers, et constitue Android.
    Ce système peut être converti en un fichier image .img, ou en fichier .jffs2
    Télécharger au format .img
    Télécharger le source (à copier sur la SD)

    Autres logiciels que l'on peut être amené à utiliser :
  • TFTP serveur (tftpd32.exe)
  • Ce fichier est sur le CD livr√© avec la mini2440.
  • NFS serveur
  • Gratuit sous Linux, payant sous Windows ($40 environ).

    Paramètre
    du kernel

    Paramètre du kernel
    Ma version du kernel est compilée spécifiquement pour un écran 5.6 pouces en 640x480.
    Utilisant la procédure 1/ décrite plus bas, et n'ayant donc pas besoin d'intervenir sur le paramètrage du bootloader pour configurer le kernel, l'installation d'une carte est donc très rapide.

    Habituellement les versions du kernel sont prévues pour plusieurs formats d'écrans.
    Pour sélectionner votre écran, il faut ajouter mini2440=?tb dans le paramètrage du bootloader.
    avec mini2440=0tb pour un écran 3.5" TFT (old model "N35")
    mini2440=1tb pour un écran 7" TFT
    mini2440=2tb pour un écran VGA 1024x768
    mini2440=3tb pour un écran 3.5" TFT (new model as Nov 2009 "T35")
    mini2440=4tb pour un écran 5.6" TFT (Innolux AT056TN52)

    Prêt à
    démarrer

    Prêt à démarrer
    Dans tous les cas, DNW doit être lancé. En bootant sur la NOR, un menu doit s'afficher.


    Vous êtes donc prêts à installer Android sur votre carte !

    Simple, rapide et efficace, du boulot comme je l'aime.

    Je vous propose pour information, les autres methodes d'installation que j'ai eu l'occasion de tester.

    1/
    Le plus simple : Booter avec
    Supervivi sur
    la NAND

    1/ Le plus simple : Booter avec Supervivi sur la NAND :
    Par défaut supervivi est paramétré, donc appuyer sur :
    f : pour formater la NAND
    x : pour la préparer pour Linux
    v : pour télécharger supervivi. Dans DNW, il faut cliquer sur "USB port", puis "Transmit" pour sélectionner le fichier supervivi à envoyer.
    k : pour télécharger le kernel. Dans DNW, sélectionner le fichier zImage
    y : pour télécharger le File système au format image : android.img

    Basculez le switch S2 sur NAND, appuyer sur Reset, et Android démarre.

    2/
    Booter avec
    u-boot sur
    la SD

    2/ Booter avec u-boot sur la SD :
    Il vous faut une machine sous Linux pour partitionner la SD avec Gparted.
    Vous devez également être loggé en tant que "root", pour créer ces partitions.
    Partition 1 : LINUX-SWAP de 512Mo
    Partition 2 : EXT2 de 20Mo
    Partition 3 : EXT3 avec le reste de la SD

    Copier uImage dans la partition 2.
    Copier le File System (fichiers et répertoires) dans la partition 3.

    La carte SD est prête, il faut maintenant installer et configurer le bootloader sur la NAND, pour booter sur le kernel et FS de la SD.

    Booter sur la NOR en mettant le switch S2 sur NOR, puis mettre la carte sous tension, ou appuyer sur le bouton reset.
    f : pour formater la NAND
    x : pour la préparer pour Linux
    q : pour passer sur le shell de supervivi
    Nous allons maintenant installer u-boot sur la NAND :
    > load ram 0x31000000 246164 u
    Dans "USB Port" sélectionner le fichier u-boot
    > go 0x31000000
    Vous êtes maintenant sur u-boot :

    Copiez u-boot dans la NAND :
    # nand write 0x31000000 u-boot
    # dynenv set 40000
    # saveenv

    Il reste à préparer la NAND :
    # nand scrub
    # nand createbbt
    Cette étape est très longue. Je ne peux pas dire combien de temps il faut, je n'ai jamais eu la patience d'attendre, je ne suis pas convaincu par son utilité...
    Maintenant on modifie le paramètrage de u-boot pour lui dire d'initialiser le lecteur de SD, et d'utiliser les partitions de la SD pour le kernel et le FS :
    # setenv bootargs console=ttySAC0,115200 root=/dev/mmcblk0p3 rootfstype=ext3 rootdelay=3 init=/linuxrc
    # setenv bootcmd mmcinit \; ext2load mmc 0:2 0x31000000 uImage \; bootm 0x31000000
    # saveenv

    Mettre la SD en place, et rebooter en NAND.
    Si vous voulez utiliser le swap de la SD, il faudra paramétrer Android pour qu'il le trouve.
    Utilisant actuellement des mini2440 avec 64Mo de RAM, mon FS est configuré pour créer un swap dans le FS. C'est indispensable, et loin d'être suffisant.

    3/
    Booter avec
    u-boot sur
    la NAND

    3/ Booter avec u-boot sur la NAND :
    Voir le 2/ pour installer le bootloader, mais cela se complique pour charger le kernel et le FS.
    En effet, u-boot ne peut les charger que depuis une SD, ou depuis un serveur TFTP.

    Cas de la SD :
    Il faut initialiser le lecteur de carte SD
    # mmcinit
    Il faut ensuite charger le kernel (uImage) depuis la SD.
    Dans le cas d'une SD formaté sous Windows :
    # fatload mmc 0:1 0x31000000 uImage
    Pour info, dans le cas o√Ļ vous utilisez la SD du 2/
    # ext2load mmc 0:2 0x31000000 uImage
    Et enfin enregistrer le kernel sur la NAND :
    # nand write 0x31000000 kernel

    Il faut maintenant charger le FS au format .jffs2 depuis une SD.
    # fatload mmc 0:1 0x31000000 android.jffs2
    Et enfin enregistrer le FS sur la NAND :
    # nand write 0x31000000 root

    Puis configurer u-boot :
    # setenv bootcmd nboot.e kernel \; bootm
    # setenv bootargs root=/dev/mtdblock3 rootfstype=jffs2 console=ttySAC0,115200
    # saveenv

    Cas du serveur TFTP :
    Coté PC, installer et lancer le logiciel, faire pointer le serveur sur le repertoire contenant tous vos fichiers.
    Le serveur TFTP est à l'adresse 192.168.1.53
    Coté mini2440, je configure le réseau IP :
    # setenv ipaddr 192.168.1.55
    # setenv serverip 192.168.1.53
    # setenv netmask 255.255.255.0
    # saveenv
    Je copie depuis le serveur TFTP vers la RAM : # tftp 0x31000000 uImage
    Puis de la RAM vers la NAND : # nand write 0x31000000 kernel
    Je copie depuis le serveur TFTP vers la RAM : # tftp 0x31000000 android.jffs2
    Puis de la RAM vers la NAND : # nand write 0x31000000 root

    4/
    Booter avec
    u-boot depuis
    NFS

    4/ Booter avec u-boot depuis NFS :
    sudo apt-get install nfs-common
    sudo apt-get install nfs-kernel-server

    Configurer le serveur NFS dans /etc/exports :
    /home *(rw,sync,no_subtree_check)

    Il faut ensuite démarrer le serveur NFS :
    sudo /etc/init.d/nfs-kernel-server start

    Et enfin configurer supervivi :
    noinitrd ip=192.168.2.80 root=/dev/nfs rw nfsroot=192.168.2.3:/.../fs,timeo=30 init=/linuxrc console=ttySAC0

    Version u-boot :
    # setenv bootargs init=/linuxrc console=ttySAC0,115200 ip=192.168.2.80 root=/dev/nfs rw nfsroot=192.168.2.3:/.../fs,timeo=30,retrans=3

    J'ai abandonné cette solution, le kernel ne semblant pas communiquer correctement avec le serveur NFS.
    Sur les forums, trop de monde se plaint du même problème, alors...

    Divers
    Divers
    Pour créer android.jffs2 (u-boot + NAND) à partir de l'arborescence du FS
    mkfs.jffs2 -r /.../fs -o /.../Android.jffs2 -e 0x20000 -n

    Pour créer android.img (supervivi + NAND) à partir de l'arborescence du FS
    mkyaffs2image-128M /.../fs /.../android.img

    Pour compiler zImage :
    sudo make zImage ARCH=arm CROSS_COMPILE=/usr/local/arm/4.3.2/bin/arm-linux-

    Pour convertir zImage en uImage :
    mkimage -A arm -O linux -T kernel -C none -a 0x30008000 -e 0x30008000 -d zImage uImage