[[PageOutline]]

= Flashage des Ardrone2 =

== Lexique ==

* ardrone2 original : un drone non modifié par nous, neuf donc
* ardrone2 hds : un drone avec nos noyaux et rootfs
* plf : format propriétaire Parrot pour paqueter des données (rootfs, noyau, ligne de commande noyau, etc). Le format a été plus ou moins décodé. Des outils existent pour lire/écrire des plf (intégrés dans robomap3)
* ardrone2-updater : machine (au sens poky) dans robomap3 ; permet de flasher le rootfs de production ; s’installe dans la flash (mtd2 pour le rootfs, mtd1 "alt_boot" pour le noyau )
* ardrone2-installer : machine (au sens poky) dans robomap3 ; permet de flasher complètement le système hds, c’est un ramfs
* ardrone2: machine (au sens poky) dans robomap3 ; le système de production sur lequel on vol, s’installe dans la flash (mtd3 pour le rootfs, mtd1 "main_boot" pour le noyau )

== Organisation de la flash ardrone2 original ==

* mtd0 : 0x000000000000-0x000000080000 : "Pbootloader" 512Ko
* mtd1 : 0x000000080000-0x000000880000 : "Pmain_boot" 8 Mo
* mtd2 : 0x000000880000-0x000001080000 : "Pfactory" 8Mo
* mtd3 : 0x000001080000-0x000003080000 : "Psystem" 32 Mo
* mtd4 : 0x000003080000-0x000008000000 : "Pupdate" 81408 Ko

mtd1 : contient les noyaux, 2 partitions ubifs
* "main_boot" (4,1 Mo) noyau principal au format plf
* "alt_boot" (2,9 Mo) noyau alternatif au format plf
mtd2 : contient des infos produit (mac address, no série, etc), ubifs ("factory") monté dans /factory

mtd3 : rootfs, ubifs ("system") monté dans /

mtd4 : 2 partitions ubifs
* "update" (16.1 Mo) monté dans /update
* "data" (59,7 Mo) monté dans /data

bootparams :
{{{
mtdparts=omap2-nand.0:512K(Pbootloader),8M(Pmain_boot),8M(Pfactory),32M(Psystem),81408K(Pupdate) console=ttyO3,115200 loglevel=4 ubi.mtd=Pfactory,2048 ubi.mtd=Psystem,2048 ubi.mtd=Pupdate,2048 root=ubi1:system rootfstype=ubifs parrot5.low_latency=1  androidboot.bootloader=ecos-bootloader-omap3630-start-65-g6a040b5
}}}

== Organisation de la flash ardrone2 hds ==

* mtd0 : 0x000000000000-0x000000080000 : "Pbootloader" 512Ko
* mtd1 : 0x000000080000-0x000000880000 : "Pmain_boot" 8 Mo
* mtd2 : 0x000000880000-0x000001080000 : "Pfactory" 8Mo
* mtd3 : 0x000001080000-0x000008000000 : "Psystem" 114176Ko

mtd1 : contient les noyaux, 2 partitions ubifs
* "main_boot" (4,1 Mo) noyau production (ardrone2) au format plf
* "alt_boot" (2,9 Mo) noyau updater (ardrone2-updater) au format plf
mtd2 : contient le rootfs du ardrone2-updater

mtd3 : 2 partitions ubifs
* "rootfs" (58 Mo) monté dans /
* "home" (45 Mo) monté dans /home/root

bootparams :
{{{
mtdparts=omap2-nand.0:512K(Pbootloader),8M(Pmain_boot),8M(Pfactory),114176K(Psystem) console=ttyO3,115200 loglevel=8 earlyprintk=ttyO3,115200 ubi.mtd=Pfactory,2048 ubi.mtd=Psystem,2048 root=ubi1:rootfs rootfstype=ubifs parrot5.low_latency=1 mem=80M mpurate=1000
}}}

== Bootloader Parrot ==

Programme propriétaire dont nous n’avons pas les sources. Pas d’alternative open source fonctionnelle pour l’instant. Devrait pouvoir se remplacer par xloader (TI) et u-boot.

Par défaut, le bootloader charge le noyau au format plf se trouvant dans la partition « main_boot » de mtd1. Pour booter sur un noyau alternatif (dans l’autre partition de mtd1, « alt_boot »), il faut au préalable échanger les étiquettes des deux partitions :
ubiattach -p /dev/mtd1
ubirename /dev/ubix main_boot alt_boot alt_boot main_boot (x donné par ubittach)
ubidetach -p /dev/mtd1
Ce renommage se fait automatiquement dans le script launch_update.sh (voir Mettre à jour le rootfs sur adrones2 hds).

Si le drone est branché en USB au PC, le bootloader peut charger un autre bootloader (voir Flasher ardrone2 original avec câble USB).

== Prérequis ==

un terminal série : cutecom, minicom, etc

cross toolchain : https://devel.hds.utc.fr/software/flair/wiki/toolchain/install

robomap3 : https://sourcesup.renater.fr/projects/robomap3-rt/

inst_usb_bootldr.bin :bootloader propriétaire Parrot, se charge et se lance en USB. Permet ensuite de charger en USB un fichier PLF (kernel+bootcmd+ramfs) et de lancer le noyau du PLF
https://devel.hds.utc.fr/svn/uav_dev/trunk/bin/i686/unix/mykonos2_flash/bin/inst_usb_bootldr.bin

ajouter une règle udev pour la connexion USB au drone (sinon faire les opérations USB en root):
{{{
SUBSYSTEM=="usb", ATTRS{idVendor}=="0451", ATTRS{idProduct}=="d00e", ACTION=="add", GROUP="gsanahuj", MODE="0664"
SUBSYSTEM=="usb", ATTRS{idVendor}=="19cf", ATTRS{idProduct}=="1111", ACTION=="add", GROUP="gsanahuj", MODE="0664"
}}}

== Flasher ardrone2 original avec câble USB ==

''bitbake core-image-minimal-mtdutils'' pour la machine ardrone2-installer (se lance en ram depuis l’usb)
''bitbake core-image-minimal-mtdutils'' pour la machine ardrone2-updater (se met en flash)
''bitbake core-image-flair-uav'' pour la machine ardrone2 (se met en flash)

brancher le câble USB et le série (115200bps), envoyer le ardrone2-installer :

{{{
$ source /opt/robomap3/1.7.3/armv7a-neon/environment-setup-armv7a-vfp-neon-poky-linux-gnueabi
$ ardrone2-usbloader inst_usb_bootldr.bin core-image-minimal-mtdutils-ardrone2-installer.plf
}}}
une fois le programme en attente, allumer le drone

le drone fait une interface réseau par USB (ssh root@192.168.7.2)

créer les partitions pour recevoir le système hds :
{{{
# create_partitions.sh
}}}

copier les éléments de ardrone2-updater (''tmp/deploy/images/ardrone2-updater/zImage.plf'' et ''tmp/deploy/images/ardrone2-updater/core-image-minimal-mtdutils-ardrone2-updater.tar.gz'') sur le drone

flasher le updater :
{{{
# update_kernel.sh zImage.plf (doit afficher found an updater kernel)
# install_updater_rootfs.sh core-image-minimal-mtdutils-ardrone2-updater.tar.gz
}}}

copier les éléments de ardrone2 (''tmp/deploy/images/ardrone2/zImage.plf'' et ''tmp/deploy/images/ardrone2/core-image-flair-uav-ardrone2.tar.bz2'') sur le drone

flasher le système :
{{{
# update_kernel.sh zImage.plf (doit afficher found a production kernel)
# flash_rootfs.sh core-image-flair-uav-ardrone2.tar.bz2 (choisir l’option 1 : production)
}}}
reboot !

== Flasher ardrone2 original sans câble USB ==

TODO : scripter un peu plus tout ça !

se connecter en wifi au drone :
ssid ardrone2_011152 (les 6 derniers chiffres dépendent du numéro de série, voir sur l’étiquette du drone)
ip pc : 192.168.1.2 (donné par le dhcp du drone)
ip drone : 192.168.1.1

On ne peut pas flasher d’un coup le système final hds. On commence par mettre le ardrone-updater ; puis on bootera sur celui la pour installer le reste.

Copier par ftp les scripts de flashage (dans ''robomap3-rt/meta-poky/recipes-hds/ardrone-tools/ardrone2-flash-scripts'') et les outils mtd/ubi (ubiattach, ubidetach, etc). Sur le drone, les fichiers envoyés en ftp sont dans /data/video par défaut. Mettre tout ca dans /usr/bin.

Copier les éléments de ardrone2-updater (''tmp/deploy/images/ardrone2-updater/zImage.plf'' et ''tmp/deploy/images/ardrone2-updater/core-image-minimal-mtdutils-ardrone2-updater.tar.gz'') sur le drone par ftp. Flasher le noyau et le rootfs de ardrone2-updater
{{{
# update_kernel.sh zImage.plf
# install_updater_rootfs.sh  core-image-minimal-mtdutils-ardrone2-updater.tar.gz
}}}

rebooter sur le système ardrone2-updater
{{{
# ubiattach -p /dev/mtd1
# ubirename /dev/ubix main_boot alt_boot alt_boot main_boot (x donné par ubittach)
# ubidetach -p /dev/mtd1
# reboot
}}}

une fois sur le ardrone2-updater : (en port série car procédure à automatiser)
{{{
# create_partitions.sh
# flash_rootfs core-image-flair-uav-ardrone.tar.bz2
# swap kernel ubi labels
# flash_kernel.sh zImage.plf
}}}

== Mettre à jour le noyau sur adrones2 hds ==
{{{
# flash_kernel.sh zImage.plf
}}}

== Mettre à jour le rootfs sur adrones2 hds ==

== Tester un noyau sans le flasher (avec câble USB) ==

Procédure identique au flash avec câble usb. On créé ici le plf avec noyau+rootfs à mettre en ram

faire un fichier image.ini (adapter le chemin des 3 fichiers, le !EntryPoint et le !LoadAddr du zImage) :
{{{
[file]
Type=kernel
EntryPoint=0x81588004
HdrVersion=11
VersionMajor=5
VersionMinor=8
VersionBugfix=0x1b
TargetPlat=0x5
TargetAppl=0x59
HwCompatibility=0x1d400a4e
LanguageZone=0

[zImage]
LoadAddr=0x81588004
File=/home/gsanahuj/HDS/igep/ardrone2_src/linux-ardrone2-2.6.32-9/arch/arm/boot/zImage

[InitRD]
LoadAddr=0x81000000
File=/home/poky/poky-robomap3/build/tmp/deploy/images/ardrone2-installer/core-image-minimal-mtdutils-ardrone2-installer.cpio

[BootParams]
LoadAddr=0x80700000
File=/home/gsanahuj/HDS/igep/ardrone2_src_svn/trunk/linux-ardrone2-2.6.32-9/bootparams.txt
}}}
créer un plf avec le noyau et le rootfs :
{{{
# /opt/robomap3/1.7.3/armv7a-neon/sysroots/x86_64-pokysdk-linux/usr/bin/plftool -b ./image.ini -o ./image.plf
}}}
brancher le câble USB et le série (115200bps), envoyer le ardrone2-installer :

{{{
# source /opt/robomap3/1.7.3/armv7a-neon/environment-setup-armv7a-vfp-neon-poky-linux-gnueabi
# ardrone2-usbload inst_usb_bootldr.bin image.plf
}}}
une fois le programme en attente, allumer le drone

== Flasher ardrone2 briqué (avec câble USB) ==

suivre la procédure ardrone2 original avec câble USB.
Envoyer le ardrone2-installer par USB, puis flasher le nécessaire pour dé-briquer (normalement le noyau).