procédure sdcard

Toute la procédure suivante s'effectue sur Linux et en tant qu'administrateur (compte root)

Pour ceux qui utiliseraient Windows, il est possible d'émuler Linux avec une machine virtuelle genre VirtualBox ou bien VmWare.
Utiliser sous Windows un freeware comme Win32diskManager
Sinon jeter un oeil sur l'installation windows.

La partie 1 est une explication des différents composants nécessaires à la création d'une sdcard pour la RaspberryPi.
La partie 2 est utile si on télécharge directement ces composants en tant que fichiers compressés

La partie 3 est utile si on télécharge directement les images des partitions de la micro sd card
La partie 4 est utile si on fait l'installation directe de l'image iso de la sdcard

La lecture des partie 1 et 2 est recommandée (un peu technique pour quelqu'un qui ne connait pas linux).
Aller directement à la partie 3 ou 4 en cas de téléchargement des images de partition ou bien de la carte entière (images compressée).


Partie 1 - Exemple de résultat d'un build kernel avec Buildroot



Toutes les commandes sont à produire en tant que root (administrateur) ou avec sudo
Cette partie décrit les fichiers qui sont produits lors de la construction d'un système Linux avec l'utilitaire Buildroot.
Quand on compile un système linux pour une cible dédiée, par exemple avec buildroot, on obtient l'arborescence suivante dans ouput/images :

    output/images/
    +-- rootfs.tar
    +-- rpi-firmware/
    |   +-- bcm2708-rpi-b.dtb
    |   +-- bcm2708-rpi-b-plus.dtb
    |   +-- bcm2709-rpi-2-b.dtb
    |   +-- bootcode.bin
    |   +-- config.txt
    |   +-- fixup.dat
    |    -- start.elf
    -- zImage

Les fichiers obligatoires sont marqués en gras.

Pour une explication de ces fichiers, voir ici.
Le rootfs.tar est présent uniquement si l'option "compress rootfs" a été sélectionné avant la compilation.
Non obligatoire, on peut aussi ajouter les options passées au noyau via un fichier cmdline.txt,  notamment les options concernant la gestion du module usb dwc_otg, ainsi que le nom du terminal série (Uart), le nom du noyau, etc...
On trouvera des informations ici

Préparer la sdcard

pour plus d'informations, aller ici ou

La sdcard doit posséder une partition en FAT32 et être labellisée bootable
On peut ensuite créer le nombre de partitions qu'on veut avec au minimum une autre partition pour y loger le rootfs en mode persistent.
Le rootfs est le système de fichier linux que le noyau va charger au démarrage.
Utiliser la commande fdisk (en root) pour ce faire.

Exemple avec fdisk et sfdisk

# sfdisk -d
# partition table of /dev/sdX
unit: sectors

/dev/sdX1 : start=     8192, size=   114688, Id= c
/dev/sdX2 : start=   122880, size=  7651328, Id=83
/dev/sdX3 : start=        0, size=        0, Id= 0
/dev/sdX4 : start=        0, size=        0, Id= 0

# fdisk /dev/sdX

Disk /dev/sdc: 3,7 GiB, 3980394496 bytes, 7774208 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x00000000

Device     Boot       Start     End          Sectors      Size       Id    Type
/dev/sdX1  *        63        144584  144522    70,6M  c    W95 FAT32 (LBA)
/dev/sdX2           144585 7759394 7614810  3,6G    83  Linux


Il faut créer deux points de montage, monter les partitions de la sdcard, puis effectuer la copie des fichiers sur les partitions

mkdir /mnt/boot 2>/dev/null
mkdir /mnt/root 2>/dev/null

mount /dev/sdX1 /mnt/boot
mount /dev/sdX2 /mnt/root

Installer les fichiers sur la carte

On voit que l'ensemble de fichiers est ensuite copié sur la partition boot et le rootfs décompressé sur la partition root.

    * bcm2708-rpi-b.dtb         [1]
    * bcm2708-rpi-b-plus.dtb    [2]
    * bcm2709-rpi-2-b.dtb       [3]
    * bootcode.bin
    * config.txt
    * fixup.dat
    * start.elf
    * zImage

[1]  models A and B
[2]  models A+ and B+
[3]  model 2

cp -pf output/images/rpi-firmware/* /mnt/boot
cp -pf output/images/zImage             /mnt/boot/kernel.img

Ici le noyau qui est un binaire, porte le nom de kernel.img
Comme notre rootfs est persistent, on le détarre sur le point de montage root

tar xf ./output/images/rootfs.tar -C /mnt/root

On démonte les partitions

sync
umount /mnt/boot
umount /mnt/root      (seulement pour les rootfs persistent)

La sdcard est prête.
On peut éjecter la sdcard et l'installer sur la RaspberryPi2 qui doit booter sur le nouveau système installé.


Partie 2 - Préparer la sdcard avec les composants téléchargés


Toutes les commandes sont à produire en tant que root (administrateur) ou avec sudo
  • télécharger les fichiers compressés .gz
  • mettre la sdcard dans le lecteur sdcard
  • démonter la sdcard via un umount <point de montage> si elle a été montée automatiquement par l'automounter de linux
on peut voir le point de montage avec df -h
une fois installée dans le lecteur sd et démontée :
  • mkdir /mnt/boot 2>/dev/null
  • mkdir /mnt/root 2>/dev/null
  • mount /dev/sdX1 /mnt/boot
  • mount /dev/sdX2 /mnt/root
  • mkdir monrep
  • cd monrep
  • tar xvf composants.tar.gz
  • cp -pf output/images/rpi-firmware/* /mnt/boot
  • cp -pf output/images/zImage /mnt/boot/kernel.img
  • tar xf ./output/images/rootfs.tar -C /mnt/root
  • sync
  • umount /mnt/boot
  • umount /mnt/root
La sdcard est prête.
On peut éjecter la sdcard et l'installer sur la RaspberryPi2 qui doit booter sur le nouveau système installé


Partie 3 - Préparation de la sdcard directement à partir des images des partitions système (bootfs et rootfs)


Toutes les commandes en root (administrateur)
Si on n'est pas root, pour un utilisateur lambda, il faut le paquet sudo installé, qu'il ait les droits dans /etc/sudoers pour utiliser sudo

Fichiers à télécharger :
  • bootfs.iso.gz
  • roots.iso.gz
  • part_table.txt
Au lieu de travailler au niveau fichier, on peut directement installer les images des partitions à partir des téléchargements de ces images.
  • télécharger les fichiers compressés .gz
  • mettre la sdcard dans le lecteur sdcard
  • démonter la sdcard via un umount <point de montage> si elle a été montée automatiquement par l'automounter de linux
on peut voir le point de montage avec df -h
une fois installée dans le lecteur sd et démontée (on suppose que la carte est vue comme /dev/mmcblk0)
  • gunzip rootfs.iso.gz bootfs.iso.gz
  • dd if=/dev/zero of=/dev/mmcblk0 bs=1024
  • sfdisk /dev/mmcblk0 < part_table.txt
  • dd if=bootfs.iso of=/dev/mmcblk0p1
  • dd if=rootfs.iso of=/dev/mmcblk0p2
  • sync
La carte est prête.


Partie 4 - Préparation de la sdcard directement à partir de son image


Toutes les commandes en root (administrateur)
Si on n'est pas root, pour un utilisateur lambda, il faut le paquet sudo installé, qu'il ait les droits dans /etc/sudoers pour utiliser sudo
Il faut disposer de l'outil 7zip.

Fichiers à télécharger :
  • sdcard.img.7z
Cette fois, au lieu de travailler au niveau des images des partitions de la sdcard, on travaille directement sur le device en entier.
    • télécharger le fichier compressé .7z
    • mettre la sdcard dans le lecteur sdcard
    • démonter la sdcard via un umount <point de montage> si elle a été montée automatiquement par l'automounter de linux
    on peut voir le point de montage avec df -h
    une fois installée dans le lecteur sd et démontée (on suppose que la carte est vue comme /dev/mmcblk0)
    • 7z e sdcard.img.7z
    • dd if=/dev/zero of=/dev/mmcblk0 bs=512k
    • dd if=./sdcard.img of=/dev/mmcblk0 bs=512k
    • sync
    La carte est prête.