LAB1
[Q1]
l'architecture utilisée par la carte est la "Arm cortex-A5 Processor V7-A

[Q2]
la version de gcc est la 8.2.1

[Q3]
La version de librairie uclib-ng est la 1.0.32

[Q4]
La version des linux headers est la 4.4.215

[Q5]
les fichiers binaires de la tool chain ce trouvent dans
armv7-eabihf--uclibc--stable-2020.02-2/arm-buildroot-linux-uclibcgnueabihf/bin/

[Q6]
Dans .bashrc ajouter la ligne suivant a la fin du fichier
     export PATH="/home/yoda/Desktop/armv7-eabihf--uclibc--stable-2020.02-2/bin/:$PATH"

[Q7]
Le programme ecrit fait 71 bytes compilé pour le arms il fait 7.1k bytes

[Q8]
Si on essaye d'executer le programme on recoit une erreur 
	cannot execute binary file: Exec format error

[Q9]
avec la commande file nous pouvons resortir les informations sur le fichier generé
     main: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV)

[Q10]
Avec l'option static de gcc le fichier fair 134.7K bytes

[Q11]
l'option static fait que les librairies utilisées par le programme sont mises dans le binaire

[Q12]
Avec le strip on a a fichier de 81.6K bytes

LAB2
Commencer par créer un dossier nommé bootloader et telecharger la 
version 2.18 de sam-ba de atmel
https://www.microchip.com/DevelopmentTools/ProductDetails/PartNO/SAM-BA%20In-system%20Programmer

[Q1]
La version de samba qui ce lance est le binaire sam-ba_64

[Q2]
Car le fichier n'a pas de linker attribué pour linux al linverse du 64 
qui a un linker dynamiquement attribué
CARTE
Nous sommes maintenant fin pres a etablir notre premiere communication 
avec la carte branchez le cable micro usb pour allumer la carte
Ensuite connectez le cable usb-serie entre le pc et les pins de debug de 
la carte avec:
     Le gnd (cable noir)sur le gnd
     Le RX (cable blanc) sur le TX
     Le TX (cable vert) sur le RX

PC
Ouvrez une communication serie avec picocom sur le ttyUSB0
     picocom -b 115200 -r -l /dev/ttyUSB0
Appuyez sur le rezet de la carte le message RomBOOT devrait safficher 
sur le terminal

Nous pouvons passer a la compilation de UBoot a telecharger la version 
2016.03
     ftp://ftp.denx.de/pub/u-boot/
Pour compiler u boot avec notre version de carte il faut dabord 
installer quelques librairies
     sudo apt install libncurses-dev/focal

Maintenant nous pouvons compiler u-boot

[Q3]
Il faut dabord valider notre configuration pour notre carte avec la commande
    make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- sama5d3_xplained_nandflash_defconfig

Nous pouvons ensuite compiler u-boot avec la commande
     make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf-

[Q4]
Plusieurs .bin sont generes et placés dans dans le dossier sources de uboot

[Q5]
le fichier u-boot.bin fait 515.9 KBytes

Compilation de AT91Bootstrap
Il faut aller chercher la version 3.9.3 sur github
     https://github.com/linux4sam/at91bootstrap/releases/tag/v3.9.3
Configuration de AT91Bootstrap
     make menu config
     CPU a 528Mhz
     256MB de RAM
     Image loading strategy load u-boot into last mbyte of sdram
     U-boot image sorage setup taille 0x101000

[Q6]
Les fichier de boot sont mis dans le dossier binaires

Flash de la carte avec les deux bootloaders
Pour “flasher” AT91Bootstrap et U-Boot, il est nécessaire d’utiliser l’outil sam-ba d’Atmel.
Pour ce faire, effectuez les étapes suivantes :
     Enlever le jumper JP5 (NAND CS) de la carte : ceci désactive l’accès à la NAND, empêchant ainsi le système de booter depuis la NAND.
     Effectuer un reset de la carte (boutton pressoir RESET).
     A ce moment là, le message “RomBoot” devrait s’afficher sur la ligne série et un nouveau périphérique série devrait être détecté par le kernel Linux : /dev/ttyACM0.
     Remettre alors le jumper JP5 en place.
     Lancer sam-ba, puis séléctionnez l’interface série /dev/ttyACM0 ainsi que la cartecorrespondant à votre cible. Cliquer ensuite sur “Connect”.
Dans le logiciel Sam-ba
     Dans l’onglet “NandFlash” :
     Choisir le script “Enable NandFlash” → “Execute”
     Choisir ensuite le script “Erase All” → “Execute”
     Choisir ensuite le script “Enable OS PMECC parameters” → “Execute”
     Choisir ensuite le script “Pmecc configuration” → “Execute”. Ceci permet de changer les paramètres ECC de la NAND afin que cela corresponde aux besoins de RomBOOT. Vérifiez que “ECC bits” est à 4 et “ECC offset” est à 36.
    Choisir le script “Send Boot File” puis envoyer le bootloader AT91Bootstrap; cette opération “flash” AT91Bootstrap dans la NAND de la carte.
    Dans la zone de l’onglet où est indiqué “Download / Upload File”, sélectionnez le fichier U-Boot compilé Spécifiez ensuite l’adresse 0x40000 dans le champs “Address” puis cliquez sur “Send File”. Cette opération “flash” U-Boot dans la NAND de la carte.

[Q7]
PC
Pour savoir si le tftp fonctionel le port 69 doit etre ouvert qui est le 
port du service tftp
     netstat -na | grep udp

Connecter le dongle usb->ethernet et configurer la connection 
wiredconnection 1 ou 2 avec les valeurs suivantes
     ip address 192.168.1.1
     mask 255.255.255.0
     gateway vide
CARTE
Maintenant nous devons configurer la carte pour quelle se connecte au server
     setenv ipaddr 192.168.1.32
     setenv serverip 192.168.1.1
     setenv ethaddr 00:10:09:08:07:06
     saveenv
La carte est maintenant configurée pour se connecter au service et on va 
chercher le fichier hello.txt qui est dans notre pc
     tftp 0x22000000 192.168.1.1:hello.txt
[Q8]
Le fichier va se telecharger a l'adresse 22000000 pour nous en assurer 
nous pouvons afficher l'adresse avec la commande md
     md 0x22000000

LAB3
[Q1]
La derniere version stable du kernel est la 5.8.14
	https://www.kernel.org/
[Q2]
La version du kernel linux est 5.4.0-48-generic
[Q3]
La version des headers est la 4.4.215 
[Q4]
La version 4.4.238
[Q5]
Pour trouver le nombre de fichier jai realisé plusieures commandes
	find -name *.c | wc -l ->22249
	find -name *.h | wc -l ->17289
	find -name *.S | wc -l ->1426
Ce qui nous donne un total de 40964
[Q6]
le nombre d'architectures supportées est 31
	cd arch/
	ls -l |grep dr|wc -l
[Q7]
le patch v4.3
le patch v4.4
le patch v4.4.x
[Q8]

Pour preparer la chaine de compilation il faut ajouter la ligne export ARCH=arm dans le ~/.bashrc
[Q9]
Pour la configuration jai choisit la sama_defconfig
[Q10] 
En fesant make menuconfig et en alant dans system type ensuite dans Atmel SoCS il y a la famille de cartes supportées
[Q11]
pour accelerer la compilation on peut faire make -j2 ou avec make -j pour ne pas limiter le nombre de thread que le process peut créer
	make -j2 CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf-
[Q12]
Le kernel ce trouve dans linux4.3.6/arch/arm/boot le fichier zimage qui fait 3.5MB
[Q13]
Le fichier device tree blob ce trouve dans linux4.3.6/arch/arm/boot/dts et le nom est at91-sama5d3_xplained.dtb
Pour modifier la compression pour passer a xz il faut aller dans le menuconfig dans general->setup->kernel->compression mode
[Q14]
Le fichier fait maintenant 2.5MB nous avons donc gagné 1MB
[Q15]

Pour charger l'image et le device tree il faut les mettre dans le fichier de transfer tftp
CARTE
Nous pouvons maintenant passer les fichier a la carter avec le tftp
	tftp 0x21000000 zImage
	tftp 0x22000000 at91-sama5d3_xplained.dtb
Ensuite nous pouvons lancer le boot du kernel avec la ligne
	bootz 0x21000000 - 0x22000000
	
[Q16]
Le kernel crash avec "end Kernel panic-not syncing: vfs:unable to mount root fs on unknown-block" ce qui veut dire que le kernel n'arrive pas a monter le file system car il nexiste pas
Pour configurer u-boot pour lancer le telechargement du kernel ave u boot il faut faire les lignes suivantes
CARTE
	setenv bootcmd 'tftpboot 0x21000000 zImage ;tftpboot 0x22000000 at91-sama5d3_xplained.dtb;bootz 0x21000000 - 0x22000000'
	setenv bootdelay 4
	saveenv
[Q17]
la taille reservée pour le device tree est de 0x20000 bytes c qui nous fait 131kB
[Q18]
La taille reservée pour le kernel est de 0x500000 bytes donc 5,2MB
Pour effacer les bons endroits il faut recuperer les données du tftp pour ecraser la bonne taille des fichiers
CARTE
	setenv update_dtb 'tftp 0x22000000 at91-sama5d3_xplained.dtb;nand erase 0x140000 0x20000;nand write 0x22000000 0x140000 0x20000'
	setenv update_kernel 'tftp 0x21000000 zImage;nand erase 0x160000 0x500000;nand write 0x21000000 0x160000 0x500000'
	saveenv
pour lancer le kernel depuis la nand
	setenv bootcmd 'nand read 0x22000000 0x140000 0x20000 ;nand read 0x21000000 0x160000 0x500000;bootz 0x21000000 - 0x22000000'
	saveenv
[Q20]
les commandes sont au dessus

LAB4
Pour commencer j'ai installé le packet qui permet d'installer le serveur nfs
	sudo apt install nfs-kernel-server
il faut aussi l'activer au demarage
	sudo systemctl enable nfs-kernel-server
Pour configurer le nfs_kernel_server il faut modifier le fichier etc/exports
	sudo nano /etc/exports
et rajoute la ligne suivante
	/home/yoda/Desktop/racine/tinysytem/nsfroot 192.168.1.32(rw,no_squash,no_subtree_check)
apres la modification on relance le server
	sudo systemctl start nfs-kernel-server
pour verifier si le server est lancé
	showmount -e 192.168.1.1
[Q1]
Le wr signifie que le fichier est en read write le no_root_squash donne les droits du repertoire au serveur nfs
CARTE
On rajoute les argument suivant au bootargs pour utiliser les nfs
	setenv bootargs "root=/dev/nfs ip=192.168.1.32:::::eth0 nfsroot=192.168.1.1:/home/yoda/Desktop/racine/tinysystem/nfsroot,v3 rw"
[Q2]
Il manque encore beaucoup de fichiers
[Q3]
Il faut installer busybox
Il faut aller cloner le repo de busybox dans le nfsroot
	git clone https://github.com/mirror/busybox
Et changer la version pour la 1.30.1 en fesant un checkout de la bonne branche
	git checkout origin/1_30_stable
Ensuite nous allons compiler le busybox
	make clean
	make defconfig
	make menuconfig
Puis il faut desactiver les reglages suivants
	Dans settings
		Enable compatibility for full-blown desktop system
		hystory saving
		support infiniband HW
	Dans print utilities
		toutes les options
	Dans mail Utilities
		toutes les options
	Dans Runit Utilites
		toutes les options
	Dans shells
		hush
Sasurer que dans shells il faut sassurer chose wich shell is aliased to sh name et chose which shell is aliased to bash name pointent les deux sur ash
Mettre la compilations en static dans Settings build static binary
Nous pouvons compiler maintenant
	make CROSS_COMPILE=arm-buildroot-linux-uclibcugnueabihf- ARCH=arm
Apres la compilation il faut changer la destination
	make menuconfig
		settings
			installation options ../nsfroot
	make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
	make install CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
[Q4]
Que se produit-il si vous executez la commande ps
[CARTE]
Le kernel dit
	ps: can open '/proc': No such file directory
Il faut creer un dossier proc et sys sur la carte avec le terminal
	mkdir proc
	mkdir sys
Nous pouvons maintenant les monter
	mount -t proc name /proc
	mount -t sysfs name /sys
La commande ps nous repond maintenant
Maintenant nous allons créer une configuation qui va ce lancer au demarage
	mkdir etc
	cd etc
	touch inittab
	mkdir init.d
	cd init.d
	touch rcS
[PC]
Sur le pc nous pouvons acceder au fichiers que nous avons crée
Dans le fichier rcS il faut ecrire:
	#! /bin/sh
	/bin/mount -t proc proc /proc
	/bin/mount -t sysfs sys /sys
Dans le fichier inittab:
	::sysinit:/etc/init.d/rcS
	ttyS0::askfirst:/bin/sh
maintenant si on redemare la carte on a l'erreur suivante
	cant run /etc/init.d/rcS: Permission denied
il faut ajouter les permissions au fichier rcS
[CARTE]
	cd etc
	cd init.d
	chmod +x rcS
Maintenant si on relance la carte tout fonctione nous pouvons tester le script
	sleep 10
la carte ce met en sleep
	CTRL-Z arrete le processus
	fg le reprend
Nous pouvons maintenant compiler un code simple sur le pc avec les parametres de compilation arm-buildroot-linux-uclicgnueabihf-gcc
Je met le fichier dans le nfsroot
[Q5]
[CARTE]
Si maintenant je lance le code 
	./main
La carte me repond
	/bin/sh: ./main:not found
[Q6]
Si je compile en statique le code fonctionne
Ce qui veut dire que les liens sur les librairies ne fonctionnent pas
[Q7]
Il me faut donc les librairies utilisées par mon programme
En prenant le fichier compilé sans static je peux trouver les librairies utilisées avec
	arm-buildroot-linux-uclibcgnueabihf-readelf -a main|grep .so
*lib a utiliser.png*
[Q8]
On peut voir que la librairie a utiliser est uClibc.so
Pour trouver ou il est on peut faire la commande suivante
	find . -name *uClibc* 2>dev/null
[Q9]
Je vais donc créer un dossier lib 
Et y copier le fichier lib qui est dans /home/yoda/Desktop/armv7-eabihf--uclibc--stable-2020.02-2/arm-buildroot-linux-uclibcgnueabihf/sysroot/lib/
Le ficher linuxrc fait 1'136'428 Bytes
Il faut modifier la configuration de busybox
	make menuconfig
Decocher la case dans 
settings
	build options
		build busyox as static binary(no shared libs)
Je sauvegarde et recompile
	make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
	make install CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
L'executable fait maintenant 928'376 bytes
[Q10]
Je peux maintenant recompiler le code sans option static
*code fonctionne.png*

Deployer le serveur web
Pour commencer il faut aller chercher l'archive du site web sur le git du cours la decompresser et la mettre dans notre nfs root
[CARTE]
On lance le serveur avec la commande
	httpd -p 192.168.1.32:80 -h /www
*serveur fonctione.png*
[Q11]
Pour corriger les scripts:
cpuinfo
	en dessous de la ligne echo "Your embedded device uses the following processor:<pre><font color=Blue>"
	ajouter la ligne cat/proc/cpuinfo
	*cpu info.jpeg*
uptime
	en dessous de la ligne echo "Your embedded device has been running for:<pre><font color=Blue>"
	ajouter la ligne uptime
	*uptime.png*
reboot
	en dessous de la ligne echo "System reboot initiated" 
	ajouter la ligne reboot
compiler upload.c
	arm-buildroot-linux-uclibcgnueabihf-gcc upload.c -o upload
Pour aficher les processes il faut rajouter un script procesus dans cgi-bin et mettre le code suivant
	*code Processus*
Et dans index rajouter une ligne a la suite de <li><a href="/cgi-bin/uptime">Uptime</a></li>
	<li><a href="/cgi-bin/procesus">Process</a></li>
Un bouton process aparait et le code fonctionne
	*processes.png*
Pour tester l'upload jai fait un fichier texte
*avant upload*
Je l'upload en le selectionant et en cliquant sur upload
*apres upload*
on voit bien que le fichier a ete uploadé
Pour lancer le serveur au demarage il suffit de modifier le code de etc/init.d/rcS et ajouter la ligne
	httpd -p 192.168.1.32:80 -h /www
[Q12]
Donnez le contenu final de votre fichier rcS
*rcs final*
LAB5
Modules mdev et automount
Nous allons mettre en place le montage USB automatisé avec mdev sur notre carte 
Nous avons 3 objectifs dans ce tp
	1.Obtenir un kernel où la gestion de l’USB est gérée par des modules kernel.
	2. Configurer votre système afin quemdevgère les droits d’accès auxdevice nodesainsique les périphériques insérés à chaud.
	3.Rendre automatiquement accessible au serveur web mis en place précédemment lesimages se trouvant sur tout périphérique de stockage de type USB (mass storage).
Et toutes ces etapes doivent etres faites automatiquement

Pour commencer nous devons changer les parametres du kernel pour inclure l'USB nous allons dans le fichier qui contient le fichier de notre kernel et on fait
	make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf-gcc ARCH=arm menuconfig
Et dans les Device Drivers
	USB Support -> changer les cases cochées avec * par un M
Apres modification nous pouvons recompiler le kernel
	 make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf-gcc ARCH=arm -j4
Si on veut voir que les drivers on bien etes ajoutés on peut faire la comande
	find drivers -name *.ko
*drivers ko*
On voit que les drivers usb on bien etés ajoutés mais que on a des drivers wireless d'ont nous n'avons pas besoin
Donc on va retourner dans le menuconfig
Dans Device Drivers 
	Network Device 
		Wireless Lan et on le desactive
[Q1]Quel modules avez-vous déployés sur votre système embarqué?
*drivers apres clean*
Il faut ensuite deployer les modules pour cela il nous faut une variable d'environement
	INSTALL_MOD_PATH=/home/yoda/Desktop
Ensuite on peut faire l'installation des modules dans la vraiable
	make modules_install CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm INSTALL_MOD_PATH=/home/yoda/Desktop -j4
*install_modules*
Il faut ensuite copier le fichier modules qui est dans lib sur le bureau dans le fichier /home/yoda/Desktop/racine/tinysystem/nfsroot/
Mettre a jour le kernel sur notre serveur nfs avec celui que nous avons generé
[CARTE]
On reboot la carte et on empeche le autoboot pour nous retrouver sur u-boot et faire la commande que nous avons crée dans un acien tp
	run update_kernel
Apres le telechargement du kernel on reboot la carte et tout devrais fonctionner comme avant
[PC]
Preparation de la clé USB
nous allons préparer la clé USB avant de la brancher sur la carte tout dabord nous devons connaitre la partition
pour cela je la branche sur le pc et je fait la commande 
	sudo fdisk -l
*cleUSB*
On voit que la clé est sur dev/sda
Maintenant nous alons recuperer le fichier disk_ext4.img.xz sur le git du cours et le decompresser sur le bureau de notre machine
nous allons dumper le fichier sur la clé USB avec la commande
	sudo dd if=/home/yoda/Desktop/disk_ext4.img of =/dev/sda
La clé USB devrai aparaitre sur notre machine maintenant
[Q2]
la taille du systeme de ficier est de 32MB on peut le voir avec la commande 
	sudo fdisk -l
*cléUSB2*
Détection de la clé USB
Déterminez quel(s) module(s) charger afin qu’une clé USB soit reconnue par le kernel. 
Ilfaut bien sûre que le système de fichiers présent sur la clé soit supporté par le kernel
Pour connaître les module a chargé, il faut utilisé la commande dans lib/modules/4.4.238
	cat modules.dep | grep usb
*libInstall*
[Q3]
il faut charger le module usbcore avec les commandes suivantes
	modprobe usbcore
	modprobe usb-storage
 	modprobe ehci-atmel
Pour charger le module au demarage on ajoute les lignes precedentes a etc/init.d/rcS
*rcs1*
Pour monter la clé manuelement il faut créer un dossier media et a literieur de celui ci un dossier sda1
mkdir media
	cd media
	mkdir sda1
ensuite on monte la clé avec la commande
	mount /dev/sda1 -t ext4 -r /media/sda1/
maintenant si nous alons dans le fichoer sda1 on peut voir les fichiers de la clé
*cléusbcartefonc*
Mise en place de Hotplug
pour cela nous ajoutons 
echo /sbin/mdev > /proc/sys/kernel/hotplug
et nous modifions le fichier rcs
*rcs2*
faire le fichier mdev.conf dans le dossier etc
ajouter la ligne sd[a-z][0-9]+ 1000:1000 660 */etc/KeyMount.sh
[Q4]
dans le fichier keyMount mettre les commandes suivantes
#!/bin/bash

if[$Action == "add"]
then
	mkdir /media/$MDEV
	mount /dev/$MDEV -t ext4 /media/$MDEV
	cp /media/$MDEV/*.jpg /www/upload/files/
elif [$ACTION=="remove"]
then
	rm /www/upload/files/*.jpg
	umount /media/$MDEV
	rmdir /media/$MDEV
fi
LAB6
[Q1]
Sur le terminal de la carte je fais la commande cat /proc/filesystems
*filesystems1*
on voit que ext4 est deja installé mais il nous manque les systemes de fichiers squashfs et f2fs
Il faut donc changer la configuration de notre kernel donc dans le fichier de notre kernel on fait:
	make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm menuconfig
Et on change les configurations suivantes
File system
	F2FS filesystem

	Miscellaneous filesystem
		SquashFS4.0
On peut recompiler notre kernel avec les nouvelles options
	make CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
Et on peut le mettre a jour sur notre carte en fesant la commnade run kernel_update sur uboot
On peut refaire la commande cat /proc/filesystems
*filesystems2*
On voit que squashfs et f2fs sont installés
[Q2]
Je branche la carte sd sur le pc et avec la commande 
	sudo fdisk -l
*fdisk*
on voit que la carte sd est montée sur sda
[Q3]
Avec la commande lsblk on peut voir les peripheriques de type block
*lsblk*
Il faut s'assurer quaucune partition ne soit montée on peut sen assurer avec la commande umount
	umount /dev/sda
*umount*
efface les 1024 premiers bits
sudo dd if=/dev/urandom of=/dev/sda bs=1024 count=1
*dd1024*
creaion de la partition avec fdisk
	sudo fdsik /dev/sda
jappuye ensuite sur o et w
*fdisk*
*config sdisk sur pdf lab6*
*configsdisk*
configuration de la deusieme partitions
*configsdisk2
configuration de la troisieme parition 
*confidisk3*
BOOT DU KERNEL DEPUIS LA CARTE SD
Je crée un systeme de fichier sur la premiere partition avec la commande
	mkfs.fat -n KERNEL /dev/sda1
La partition apparait sur le pc maintenant il nous reste a copier le kernel et le device tree qui ce trouvent sur le serveut tftp
On peut maintenant ejecter la partition kernel et brancher la carte sd sur le systeme embarqué
En entrant dans u boot on peut voir ou la carte est montée
*mmc*
Je vais créer un script qui va mettre a jour le kernel et le device tree depuis la carte sd
	setenv load_from_mmc "fatload mmc 0:1 0x22000000 at91-sama5d3_xplained.dtb ;fatload mmc 0:1 0x21000000 zImage"
Maintenant je vais mettre mon script dans le boot de la carte
	 setenv bootcmd "run load_from_mmc; bootz 0x21000000 - 0x22000000"
on savegarde l'environement (savenev) et on reboot la carte tout devrais fonctionner comme avant
[Q4]
quoi?

SERVEUR WEB
On veut maintenant que les fichiers upload sur le servuer soient stoqués sur la deusieme partition de la carte sd
Pour commencer on rebranche la carte sd au pc et on fait la commande
	sudo mkfs.f2fs -l data /dev/sda2
Une partition data devrais apartaitre sur le pc
On peut rebrancher la carte sur le systeme
Maintenant pour mettre les fichiers sur la carte sd on peut faire la commande
	mount /dev/mmccblk0p2 -t f2fs /www/upload/files/
on rajoute cette line dans rcs
[Q5]
Pour verifier on peut supprimer la ligne rm /www/upload/files/*.jpg de KeyMount.sh
On peut donc brancher la clé usb 
Maintenant si on la retire les fichier restent sur le site et si on brache la carte sd sur le pc et on va dans le dossier data on peut voir les images
*filessd*
[Q6]
quoi?

ficiers logs
pour commencer nous devons modfier le fichier uload.cfg qui ce trouve dans www/cgi-bin et on modifie la valeur de LogFile=/var/log/upload.log
et les fichiers var/log/upload.log
Ajouter la ligne suivante a rcS
	mount -t tmpfs varlog /var/log -o size=16M
On peut reboot


[Q7]
*tmpfs size*
systeme de fichiers racine
Pour créer une image squash de mon rootfs jutilise la commande:
	mksquashfs nfsroot/ squash.sqfs
*squash*
[Q8]
par defaut
setenv bootargs_vieux "root=/dev/nfs ip=192.168.1.32:::::eth0 nfsroot=192.168.1.1:/home/yoda/Desktop/racine/tinysystem/nfsroot,v3 rw"

setenv bootargs "root=/dev/mmcblk0p3 rootwait ip=192.168.1.32:::::eth0"

saveenv
[Q9]
si je debranche le cable ethernet on voit que le kernel demmare toujours
*sanscable*
on voit que on doit attendre lethernet ce connecte
[Q10]
si on fait un clear de la nand dans u boot
	nand erase 0x140000 0x20000
	nand erase 0x160000 0x500000
Le kernel demmare toujours
LAB7
Introduction
[Q1]
*nand_info*
on voit que la taille d'une page 2048 bit
la taille d'un bloc d'effacement est de 131072 bit
la taille de la zone OOB est de 64 bits
[Q2]
Pour uboot on fait la commande nand info
Sur linux on peut trouver ces informations dans le dossier sys/class/mtd/mtd0
*linux_info*
Activation du UBIFS
Si on va dans File system -> miscellaneousk files -> UBIFS file system support
Dans notre cas cette fonction est déja activée
[Q3]
pour trouver la taille des volumes on peut faire la commande cat /proc/mtd
*taille_particion*
la taille est de 0x40000 en hexa
ce qui fait 262144 en decimal
divsé par 1024 nous donne une taille de 256k
*MTD_particionement*
si on se refere au particions données ci dessus on voit donc que on a trois particions 
-root FS
-Data FS
-mount FS
elles meme dans une particion UBI device qui va de 0x660000 a 0x10000000 ce qui fait 261 750 784 Bytes
[Q4]
Les partitions ce definicent dans les bootargs de U-boot
On ajoute donc ces lignes dans les bootargs:
setenv bootargs "root=/dev/mmcblk0p3 rootwait ip=192.168.1.32:::::eth0 mtdparts=atmel_nand:256k(AT91Bootstrap)ro,512k(U-boot)ro,256k(U-boot_env),256k(U-Boot_env_backup),128k(DTB)ro,5m(Kernel)ro,-(UBI_Device)"
*nand_info2*
On voit bien les particions qui safichent bien
maintenant on peut commencer a travailler sur les particions pour commencer on va effacer ce qui ce trouve entre 0x660000 et 0xF9A0000 avec la commande:
nand erase 0x660000 0xF9A0000
Et on va créer les peripheiques UBI:
ubiattach -m 6 /dev/ubi_ctrl
*ubiatach*
[Q5]
ubimkvol -N RootFS -s 12MiB -t dynamic /dev/ubi0
ubimkvol -N DataFS -s 203MiB -t dynamic /dev/ubi0
ubimkvol -N MountFS -m -t dynamic /dev/ubi0
*ubi*
on voit bien que les devices aparaissent bien
[PC]
On va maintenant créer des images UBI et les mettres dans les partitions avec les commandes suivantes:
Pour connaître la taille de l’argument -c je fais (12* 2^20) / 126976 = 99.096 → 100
> mkfs.ubifs -m 2048 -e 126976 -c 100 -r ~/Desktop/racine/tinysystem/nfsroot imgRoot.img
Pour le dataFS, et le MountFS, je crée un répertoire vide, et l’utilise pour crée l’image UBI.
Pour DataFS : (203* 2^20) / 126976 = 1676.387 → 1677
> mkfs.ubifs -m 2048 -e 126976 -c 1677 -r ~/Desktop/racine/tinysystem/empty imgData.img
Pour Mount FS : (34* 2^20) / 126976 = 280.774→ 281
> mkfs.ubifs -m 2048 -e 126976 -c 281 -r ~/Desktop/racine/tinysystem/empty imgMount.img
Ensuite je transfert les image sur le systeme embarquée en passant par la page web.
Et je «flash» les image sur la nand :
ubiupdatevol /dev/ubi0_0 www/upload/files/imgRoot.img
ubiupdatevol /dev/ubi0_1 www/upload/files/imgData.img
ubiupdatevol /dev/ubi0_2 www/upload/files/imgMount.img
Je redémarre la carte, et stop le démarrage a U-Boot afin de modifier le bootargs (le rootfs) :
je modifie bootargs :
setenv bootargs "root=ubi0:RootFs rootfstype=ubifs ubi.mtd=6 ip=192.168.1.32:::::eth0 mtdparts=atmel_nand:256k(AT91Bootstrap)ro,512k(U-Boot)ro,256k(U-Boot_env),256k(UBoot_env_backup),128k(DTB)ro,5M(Kernel)ro,-(UBI-Device)"
LAB8
Pour commencer nous allons remettre le serveur nfs
setenv bootargs "root=/dev/nfs ip=192.168.1.32:::::eth0 nfsroot=192.168.1.1:/home/yoda/Desktop/racine/tinysystem/nfsroot,v3 rw rootwait mtdparts=atmel_nand:256k(AT91Bootstrap)ro,512k(U-Boot)ro,256k(U-Boot_env),256k(UBoot_env_backup),128k(DTB)ro,5M(Kernel)ro,-(UBI-Device)"
Je branche les pins de la carte sama5 a la carte my lab de cette maniere
samad 	mylab	correspondance
GND 	1.1	ground
3V3 	2.1	vcc
PE9 	2.25	joystick gauche
PE10 	1.27	joystick droite
PE11  	2.23	joystick button
maintenant sur la carte je vais exporter les gpio pour pouvoir les utiliser
le numero correspond a 128+le numero de PE
donc pour PE9 128+9 =137
echo 137 > /sys/class/gpio/export
echo 138 > /sys/class/gpio/export
echo 138 > /sys/class/gpio/export
*import1*
ensuite il faut configurer les pins en entrée
echo in> /sys/class/gpio/pioE9/direction
echo in> /sys/class/gpio/pioE10/direction
echo in> /sys/class/gpio/pioE11/direction
Pour lire les valeurs on peut faire un cat
cat /sys/class/gpio/pioE9/value
cat /sys/class/gpio/pioE10/value
cat /sys/class/gpio/pioE11/value
*values*
Jai donc rédigé un petit script qui va aller lire letat des pins toutes les 100 ms
*scrpit*
implémentation d’un driver kernel
make modules CROSS_COMPILE=arm-buildroot-linux-uclibcgnueabihf- ARCH=arm
Je mets le fichier .ko dans la racine et maintenant on peut installer le driver sur la carte
avec la commande
isnmod
maintenant dans le dossier /dev on peut voir la valeur des boutons
*cat_mydrive*
je vais developer un script qui va maficher les valeurs du joysitck
*scriptuserspace*

https://ftp.gnu.org/pub/gnu/ncurses/ncurses-6.2.tar.gz
https://sourceforge.net/projects/ninvaders/files/latest/download
*new_makefile*
*error*
*error2*
*error3*
telnett
*telnet1*
*telnet2*
