[[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


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"
}}}

If you want to compile all by yourself:

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

''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)

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

Plug USB and serial (115200bps) cables, send the [https://uav.hds.utc.fr/src/ardrone2-installer/robomap3/core-image-minimal-mtdutils-ardrone2-installer.plf ardrone2-installer] with the following commands:

{{{
$ source /opt/robomap3/2.1.3/armv7a-neon/environment-setup-armv7a-neon-poky-linux-gnueabi
$ ardrone2-usbload inst_usb_bootldr.bin core-image-minimal-mtdutils-ardrone2-installer.plf
}}}
You should get:
{{{
* Bootloader *
Trying to connect to VID: 0x0451 PID: 0xd000 .....
}}}
You can now power up the ardrone2. If everything goes well you should get:
{{{
* Bootloader *
Trying to connect to VID: 0x0451 PID: 0xd000 ......
Found device:
- Manufacturer: Texas Instruments
- Product: OMAP3630
Uploading parrot/mykonos2_flash/bin/inst_usb_bootldr.bin, size = 21440
Upload ok!

* Payload *
Trying to connect to VID: 0x19cf PID: 0x1111 ....
Found device:
- Manufacturer: Parrot SA
- Product: USB Stage 1
Uploading /home/poky/poky-robomap3_ros/build/tmp/deploy/images/ardrone2-installer/core-image-minimal-mtdutils-ardrone2-installer.plf, size = 7974932
Upload ok!
}}}

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 ([https://uav.hds.utc.fr/src/ardrone2-updater/robomap3/zImage.plf zImage.plf] et [https://uav.hds.utc.fr/src/ardrone2-updater/robomap3/core-image-minimal-mtdutils-ardrone2-updater.tar.gz 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 ([https://uav.hds.utc.fr/src/ardrone2/robomap3/zImage.plf zImage.plf] et [https://uav.hds.utc.fr/src/ardrone2/robomap3/core-image-flair-ardrone2.tar.bz2 core-image-flair-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-ardrone2.tar.bz2 (choisir l’option 1 : production)
}}}
reboot !

== Flasher original ardrone2 without USB cable ==

__TODO__: retester car dernière tentive a brické le drone

Boot the original ardrone2 system and connect to it:

ssid ardrone2_011152 (last 6 numbers depends on ardrone2's serial number)
ip pc : 192.168.1.2 (given by uav's dhcp)
ip uav : 192.168.1.1

We are going to flash the updater in the mtd2 partition from original system. Then we reboot to the updater and flash the final system in the mtd3 partition.

Copy with ftp the ardrone2-installer.tar.gz, in /data/video/installer then uncompress it:
{{{
# cd /data/video/installer
# tar -xzf core-image-minimal-mtdutils-ardrone2-installer.tar.gz 
}}}

Create a chroot script and execute it:
{{{
umount /factory
mount -o  bind /dev /data/video/installer/dev/
mount -t sysfs sys /data/video/installer/sys/
mount -t proc proc /data/video/installer/proc/

mount devpts /data/video/installer/dev/pts -t devpts
 
 
chroot  /data/video/installer /bin/sh
}}}

Copy with ftp the ardrone2-updater.plf and its kernel, in /data/video/installer then install it from the chroot:

{{{
# update_kernel.sh zImage.plf
# install_updater_rootfs.sh  core-image-minimal-mtdutils-ardrone2-updater.tar.gz
}}}

Change ubi names to reboot to 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
}}}

== 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 ([https://uav.hds.utc.fr/src/ardrone2-updater/robomap3/zImage.plf zImage.plf] et [https://uav.hds.utc.fr/src/ardrone2-updater/robomap3/core-image-minimal-mtdutils-ardrone2-updater.tar.gz 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/2.1.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/2.1.3/armv7a-neon/environment-setup-armv7a-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).