Université Laval

Systèmes embarqués temps réel - GIF-3004

Laboratoire 1 : Construction d’une chaîne de compilation pour Raspberry Pi Zero W

1. Objectifs

Ce travail pratique vise les objectifs suivants :

  1. Mettre en place un environnement de développement complet;
  2. Comprendre les mécanismes derrière la compilation croisée;
  3. Maîtriser les rudiments du débogage et du profilage à distance;
  4. Analyser et déboguer un code C simple;
  5. Se familiariser avec l’utilisation du Raspberry Pi Zero W.

2. Préparation du Raspberry Pi

La carte MicroSD du kit qui vous a été fourni contient déjà l’image système nécessaire au cours. Toutefois, dans le cas où vous voudriez revenir à l’état initial de l’image, ou simplement créer une copie, vous pouvez télécharger le fichier .img contenant l’image du cours.

La première des tâches à réaliser est de démarrer le Raspberry Pi Zero W, de mettre en place sa configuration initiale et de vous assurer de son bon fonctionnement. Par la suite, vous devrez installer sur votre ordinateur l’environnement de développement et de compilation croisée qui vous servira tout au long de la session.

Important : le Raspberry Pi étant un ordinateur à part entière, il est techniquement possible de n’utiliser que ce dernier et y travailler localement en se passant de l’environnement de développement à distance. Cela n’est toutefois pas représentatif du développement des systèmes embarqués en pratique, où il est souvent impossible de travailler directement sur le matériel cible, que ce soit par manque de puissance ou par d’autres problèmes pratiques (pensons par exemple à un Raspberry Pi embarqué dans un dispositif lourd et encombrant). De plus, pour beaucoup de travaux, la puissance limitée du Raspberry Pi Zero W et son nombre de ports limité rendraient malaisée une telle utilisation. Pour cette raison, dans le cadre du cours, il vous est interdit d’utiliser le Raspberry Pi de cette manière, sauf lorsque qu’expressément mentionné autrement dans un énoncé ou autorisé par le professeur.

2.1. Mot de passe

Insérez la carte MicroSD avec l’image du cours dans la fente prévue à cet effet sur le Raspberry Pi. Branchez un écran (une sortie HDMI est disponible, n’oubliez pas d’utiliser le convertisseur mini-HDMI vers HDMI) ainsi qu’un clavier (utilisez la prise USB la plus proche du port HDMI pour brancher le clavier et la plus éloignée pour l’alimentation). Vous devrez d’abord vous authentifier avec le compte par défaut :

  • Nom d’utilisateur : pi
  • Mot de passe : gif3004

Si tout s’est bien passé, vous devriez vous retrouver face à un écran vous demandant de changer votre mot de passe. Le mot de passe par défaut de l’image est “gif3004”, nous vous recommandons fortement de le remplacer par un mot de passe plus sécuritaire (et personnel).

2.2. Réseau sans fil

Ensuite, vous devez faire la configuration pour que votre Raspberry Pi se connecte à votre réseau sans fil. Créer ou modifiez le fichier de configuration avec la commande sudo nano /etc/wpa_supplicant/wpa_supplicant.conf, son contenu doit ressembler à ceci:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=CA

network={
        ssid="nom_du_reseau"
        psk="mot_de_passe"
}

Si ce n’est pas le cas ou que le fichier n’existe pas, recopiez et sauvegardez avec Ctrl+X. Vous pouvez alors exécuter

sudo killall wpa_supplicant
sudo wpa_supplicant -c/etc/wpa_supplicant/wpa_supplicant.conf -iwlan0 -d

Si il n’y a pas eu d’erreur, rebootez, sinon en cas d’erreur de syntaxe, le message sera assez explicite. Après redémarrage, vérifiez avec un ifconfig que vous êtes bien connecté, vous devriez notamment avoir une adresse IP (inet dans la section wlan0).

2.3. Accès par SSH

Par la suite, redémarrez le Raspberry Pi et vérifiez que vous pouvez vous connecter à distance via SSH. Nous vous suggérons de mettre en place une authentification par clé publique, pour vous éviter de devoir réécrire le même mot de passe à chaque connexion :

# L'étape suivante est à effectuer sur votre machine (PAS le Raspberry Pi) et n'est nécessaire que si vous n'avez pas déjà de clé SSH
$ ssh-keygen -t rsa -b 4096 -C "ecrivez_votre_nom_ici"
# Pressez 3 fois sur Enter (les choix par défaut sont bons)

# Cette étape est commune à toutes les installations, mais assurer-vous d'utiliser ici la bonne adresse
$ ssh-copy-id pi@adresse_ip_de_votre_raspberry_pi

2.4. Configuration d’un résolveur DNS (optionnel)

Nous recommandons finalement l’installation et l’utilisation d’un résolveur DNS tel que DuckDNS (gratuit), qui vous permettra de vous connecter plus facilement à votre Raspberry Pi en vous permettant d’utiliser un nom de domaine tel que “tarteauxframboises.duckdns.org” plutôt qu’une adresse IP pouvant potentiellement varier au fil de la session.

Pour ce faire connectez-vous à Duck DNS. Créez un nom pour votre RPi.

Cependant, cette information n’est pas adéquate dans le contexte qui nous intéresse, comme on veut utiliser les adresses locales pour se connecter au RPi directement. Pour ce faire, voici un script shell que vous pouvez copier dans /usr/local/bin/duckdns.sh sur votre RPi.

#!/bin/bash
DUCKDNS_LOCALIP=`hostname -I`
DUCKDNS_TOKEN=ECRIRE VOTRE TOKEN DUCKDNS ICI
DUCKDNS_DOMAINS=ECRIRE VOTRE DOMAINS DUCKDNS ICI
DUCKDNS_LOGFILE=/var/log/duckdns.log
echo url="https://www.duckdns.org/update?domains=$DUCKDNS_DOMAINS&token=$DUCKDNS_TOKEN&ip=$DUCKDNS_LOCALIP" | curl -k -o $DUCKDNS_LOGFILE -K -

Changez les permissions permettant l’exécution du script avec la commande sudo chmod +x /usr/local/bin/duckdns.sh.

Éditez ce fichier (avec nano) en changeant les variables DUCKDNS_TOKEN et DUCKDNS_DOMAINS par ceux que vous obtenez dans les instructions pour le RPi du site de Duck DNS (dans la commande commençant par echo url=, utilisez la valeur après domains= et token=). Ensuite, vous pouvez ajouter la ligne /usr/local/bin/duckdns.sh au fichier /etc/rc.local, juste avant exit 0. Redémarrer votre RPi, et vous devriez pouvoir vous y connecter en utilisant une adresse de type VOTREDOMAINE.duckdns.org.

3. Installation de la machine virtuelle de développement

Ce cours requiert l’utilisation d’un système GNU/Linux. Dans le cadre du cours, vous avez deux options :

  • Télécharger une machine virtuelle VirtualBox à l’adresse suivante – le nom d’utilisateur est setr et le mot de passe gif3004, vous n’avez pas accès à la commande sudo, mais pouvez passer en mode root en utilisant su;
  • Utiliser votre propre installation Linux, notez que nous ne pouvons dans ce cas garantir que les étapes d’installation et de configuration seront exactement les mêmes (vous pouvez passer à la section suivante si vous choisissez cette option).

Commencez par décompresser le fichier .zip téléchargé, il devrait contenir un unique fichier .div. Pour importer la machine virtuelle dans VirtualBox, cliquez sur Nouvelle. Vous pouvez choisir le nom de la machine virtuelle, pour Type sélectionnez Other et Debian (64bit) pour Version. Validez en appuyant sur Suivant et choisissez la mémoire que vous allez allouer à la machine virtuelle (vous pourrez toujours ajuster plus tard au besoin), Suivant. Sélectionner la dernière option Utiliser un fichier de disque dur virtuel existant et choisissez le fichier .vdi en cliquant qur l’icône en forme de dossier. Créer pour finaliser l’étape de création de la machine virtuelle.

Vous pouvez ensuite la configurer avec Clic-droit/Configuration…. Sous Système/Processeur, choisissez le nombre de CPU à allouer. Sous Affichage/Écran, Ajustez la mémoire vidéo et Activer l’accélération 3D. La configuration de base est normalement terminée, vous pouvez valider et lancer la VM.

4. Installation de l’environnement de compilation croisée

Le Raspberry Pi possède un processeur dont l’architecture (ARM) diffère de celle de votre ordinateur (x86-64). Vous ne pouvez donc pas directement transférer un exécutable compilé sur votre ordinateur. Il faut plutôt utiliser un environnement de compilation croisée, qui permettra à votre ordinateur de générer des binaires compatibles avec l’architecture ARM du Raspberry Pi. Pour mettre en place cet environnement, nous devrons (dans l’ordre) :

  1. Installer Crosstool-NG, un outil nous permettant de créer des chaînes de compilation croisée;
  2. Configurer Crosstool-NG selon les spécificités du Raspberry Pi Zero;
  3. Compiler et installer l’environnement de compilation croisée sur votre ordinateur;
  4. Synchroniser les librairies et en-têtes depuis le Raspberry Pi Zero;
  5. Préparer une configuration CMake pour la compilation croisée.

Notez que la compilation de cet environnement peut prendre un certain temps.

4.1. Installation de Crosstool-NG

Pour installer Crosstool-NG, récupérez d’abord la version utilisée dans le cours, puis exécutez le script bootstrap :

$ git clone https://github.com/setr-ulaval/crosstool-ng.git
$ cd crosstool-ng
$ ./bootstrap

Dans ce même répertoire, utilisez ./configure pour préparer la compilation et make pour le compiler :

$ ./configure --prefix=$HOME/crosstool-install
$ make && make install

Le paramètre prefix indique l’endroit où les outils de Crosstool-NG doivent être installés. Vous devrez également ajouter ce chemin d’installation dans votre variable d’environnement PATH.

Note : il se peut que l’étape du configure échoue si vous effectuez l’installation sur votre ordinateur (sans utiliser la machine virtuelle du cours). Assurez-vous dans ce cas d’avoir installé toutes les dépendances de Crosstool-NG. Cette étape a déjà été effectuée pour vous sur les ordinateurs du lab ou avec la machine virtuelle fournie.

4.2. Configuration de l’environnement de compilation croisée

Nous allons maintenant préparer la compilation de l’environnement de compilation croisée (oui, c’est méta). Pour ce faire, Crosstool-NG a besoin d’informations sur notre système cible (le Raspberry Pi). Créez tout d’abord un dossier nommé ct-config-rpi-zero dans votre dossier personnel et allez à l’intérieur :

$ mkdir ct-config-rpi-zero
$ cd ct-config-rpi-zero

Au lieu de partir d’une configuration vide, nous allons utiliser le fichier de configuration fourni par le distributeur des Raspberry Pi. Dans le dossier ct-config-rpi-zero, téléchargez le fichier suivant et nommez le .config :

$ wget -O .config https://setr-ulaval.github.io/labo1-h21/etc/ct-ng-config

Par la suite, lancez l’utilitaire de configuration de Crosstool-NG :

$ ct-ng menuconfig

Vous devriez alors obtenir une interface de ce type :

Important : suivez scrupuleusement les instructions suivantes. Tout manquement risque d’entraîner des erreurs ultérieures difficiles à interpréter et à corriger.

Allez dans la section Paths and misc options et remplacez :

  • Prefix directory : ${HOME}/arm-cross-comp-env/${CT_TARGET} (il est important de le faire, car les scripts de compilation fournis assument ce chemin précis)
  • Log to a file (tout en bas): désactivez l’option

Voici la configuration requise sur votre machine virtuelle ou votre ordinateur.

Dans la section Operating System, remplacez :

  • Source of linux : Custom location
  • Une fois l’étape précédente effectuée, Custom location : chemin vers les sources du kernel

Dans la dernière étape, chemin vers les sources du kernel doit être le chemin absolu vers le dossier contenant les sources du noyau Linux utilisé sur le Raspberry Pi. Celui-ci peut-être situé à des endroits différents selon votre installation:

  • Si vous travaillez sur la machine virtuelle Fedora fournie, le chemin est /home/setr/rPi/linux-rpi-4.19.y-rt
  • Si vous travaillez sur votre propre ordinateur, téléchargez l’archive suivante, décompressez-la et indiquez son chemin absolu.

Dans la section Debug facilities :

  • Activez gdb et strace
  • Allez ensuite dans les options de configuration de gdb (la touche Espace active ou désactive, la touche Entrée permet d’entrer dans les options) et désactivez l’élément Enable python scripting

N’oubliez pas d’enregistrer votre configuration (utilisez les flèches horizontales du clavier pour vous déplacer dans le menu du bas) puis quittez l’utilitaire.

4.3. Compilation et installation de la chaîne de compilation

Utilisez la commande suivante pour lancer la compilation :

$ ct-ng build

Cette compilation peut prendre un bon moment (comptez au moins 30 minutes), dépendant de la puissance de votre ordinateur. Si vous utilisez une machine virtuelle, pensez à augmenter le nombre de processeurs alloués à celle-ci, puisque Crosstool-NG peut en tirer parti. Vous aurez également besoin d’une bonne connexion Internet.

Une fois cela fait, le répertoire ~/arm-cross-comp-env devrait contenir un dossier nommé arm-raspbian-linux-gnueabihf. Dans ce dossier, vous retrouverez plusieurs choses, mais en particulier :

  • bin/, qui contient des exécutables x86-64 capables de générer du code machine ARM. Assurez-vous que ce dossier soit dans votre chemin d’exécution (PATH). Lorsque nous voudrons compiler un programme vers un binaire ARM, nous n’utiliserons donc pas gcc (qui compilerait en x86-64), mais bien arm-raspbian-linux-gnueabihf-gcc
  • arm-raspbian-linux-gnueabihf/sysroot, qui contient les librairies et en-têtes des librairies centrales au système (libc, binutils, etc.). C’est là que le compilateur et l’éditeur de liens iront chercher les informations dont ils ont besoin.

4.4. Synchronisation avec le Raspberry Pi

Important : attendez que l’étape précédente soit terminée sans erreurs avant de continuer.

À ce stade, vous êtes en possession d’une chaîne de compilation croisée. Il vous faut toutefois maintenant la synchroniser avec le Raspberry Pi, de manière à vous assurer que les versions des librairies et des en-têtes soient les mêmes lorsque vous compilerez (sur votre ordinateur) et exécuterez (sur le Raspberry Pi). Il va falloir synchroniser trois répertoires :

  • /usr/lib et /lib, qui contiennent les librairies partagées (fichier .so) qui peuvent être utilisées par les programmes;
  • /usr/include, qui contient les en-têtes de ces librairies (nécessaires pour la compilation);
  • /opt, qui contient certains fichiers de configuration importants.

Pour synchroniser ces dossiers, nous allons utiliser rsync. Cet outil permet de faire des mises à jour incrémentales, c’est-à-dire que seules les différences sont transférées.

$ cd ~/arm-cross-comp-env/arm-raspbian-linux-gnueabihf/arm-raspbian-linux-gnueabihf
$ rsync -av --numeric-ids --exclude "*.ko" --exclude "*.fw" --exclude "/opt/vc/src" --delete pi@adresse_ip_ou_nom_dhote:{/lib,/opt} sysroot
$ rsync -av --numeric-ids --exclude "/usr/lib/.debug" --delete pi@adresse_ip_ou_nom_dhote:{/usr/lib,/usr/include} sysroot/usr

Il reste par la suite un petit problème à corriger. Beaucoup de fichiers sont en fait des liens, qui évitent de devoir stocker deux fois le même fichier inutilement. Toutefois, certains de ces liens sont absolus, c’est-à-dire qu’ils contiennent un chemin absolu. Vous pouvez constater ce problème en testant, par exemple :

$ ls -l sysroot/usr/lib/arm-linux-gnueabihf/libdl.so 
lrwxrwxrwx 1 setr setr 35 15 jun  2017 sysroot/usr/lib/arm-linux-gnueabihf/libdl.so -> /lib/arm-linux-gnueabihf/libdl.so.2

Comme on le voit, le lien pointe vers un chemin absolu, qui n’existe pas sur notre plateforme de compilation. Il y a plusieurs solutions pour corriger ce problème, vous pouvez consulter cette page pour en savoir plus, mais le plus simple est d’utiliser la commande suivante. Attention, le find doit être exécuté dans le répertoire sysroot, sinon les chemins ne seront pas convertis correctement!

$ cd ~/arm-cross-comp-env/arm-raspbian-linux-gnueabihf/arm-raspbian-linux-gnueabihf/sysroot
$ find . -lname '/*' | while read l ; do   echo ln -sf $(echo $(echo $l | sed 's|/[^/]*|/..|g')$(readlink $l) | sed 's/.....//') $l; done | sh

Vous devrez effectuer cette synchronisation à chaque fois que vous ajouterez une librairie ou mettrez à jour votre système sur le Raspberry Pi.

5. Configuration de l’environnement de développement

Dans le cadre du cours, nous allons utiliser Visual Studio Code (ci-après abbrévié VSC). Utilisez la version 1.19 comme les versions plus récentes causent certaines complications rendant la configuration initiale plus ardue. Vous êtes libres d’utiliser un autre environnement de développement, mais vous devez travailler en compilation croisée et nous ne pourrons potentiellement pas vous aider si vous choisissez un autre logiciel.

5.1. Préparation d’une configuration CMake

CMake est un outil permettant de mettre en place une chaîne de compilation efficace et portable. Nous allons l’utiliser dans le cadre du cours afin d’automatiser la compilation et l’édition de liens des TP. Pour ce faire, créez un nouveau fichier dans arm-cross-comp-env/, nommé rpi-zero-w-toolchain.cmake et insérez-y le contenu suivant :

# Identification du systeme cible
SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 4.19)
set(CMAKE_SYSTEM_PROCESSOR arm)

# Localisation du sysroot
set(CMAKE_SYSROOT $ENV{HOME}/arm-cross-comp-env/arm-raspbian-linux-gnueabihf/arm-raspbian-linux-gnueabihf/sysroot)

# Selection du compilateur
set(tools $ENV{HOME}/arm-cross-comp-env/arm-raspbian-linux-gnueabihf)
set(CMAKE_C_COMPILER ${tools}/bin/arm-raspbian-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER ${tools}/bin/arm-raspbian-linux-gnueabihf-g++)

# On ajoute des options au compilateur pour lui indiquer ou aller chercher les librairies
SET(FLAGS "-Wl,-rpath-link,${CMAKE_SYSROOT}/opt/vc/lib -Wl,-rpath-link,${CMAKE_SYSROOT}/lib/arm-linux-gnueabihf -Wl,-rpath-link,${CMAKE_SYSROOT}/usr/lib/arm-linux-gnueabihf -Wl,-rpath-link,${CMAKE_SYSROOT}/usr/local/lib")
SET(CMAKE_CXX_FLAGS ${FLAGS} CACHE STRING "" FORCE)
SET(CMAKE_C_FLAGS ${FLAGS} CACHE STRING "" FORCE)

# Quoi aller chercher dans la sysroot (on ne veut pas aller chercher les programmes puisqu'ils sont
# compiles en ARM et ne peuvent donc etre directement executes sur un processeur x86)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

Nous réutiliserons cette configuration générique pour tous les projets du cours. Nous verrons plus loin comment la lier aux dits projets.

5.2. Installer les extensions requises par VSC

Une fois VSC ouvert, sélectionnez l’interface de recherche des extensions en cliquant sur la cinquième icône dans la barre de gauche. Par la suite, recherchez l’extension “C/C++” et installez le premier résultat.

Afin d’être utilisée, l’extension doit maintenant recharger l’interface de VSC, cliquez sur le bouton Reload pour le faire.

Vous devez installer les extensions suivantes : C/C++, CMake, CMake Tools et Native Debug.

Si vous utilisez l’image VirtualBox fournie, ces extensions devraient déjà être installées.

6. Configuration du projet du laboratoire

Nous allons maintenant configurer un nouveau projet pour ce laboratoire.

6.1. Création d’un nouveau projet

Sur VSC, les projets sont simplement des dossiers. Créez donc dans votre dossier personnel un nouveau dossier nommé projets puis, dans celui-ci, clonez le dépôt Git suivant :

$ git clone https://github.com/setr-ulaval/labo1-h21.git

Rendez également le script src/syncAndStartGDB.sh exécutable :

$ chmod +x src/syncAndStartGDB.sh

Par la suite, dans VSC, allez dans Fichier > Ouvrir un dossier et sélectionnez labo1-h21/src. Vous devriez alors pouvoir accéder, via le menu de gauche, aux fichiers tp1.c et CMakeLists.txt.

6.2. Compilation croisée

Il est maintenant temps de tester votre chaîne de compilation croisée. Dans VSC, allez dans le menu Afficher, puis Palette de commandes.

Cette palette de commandes est la manière privilégiée d’interagir avec les outils de VSC. Dans la suite des énoncés, nous l’appelerons simplement “Palette”. Vous gagnerez probablement du temps à mémoriser le raccourci clavier permettant de l’ouvrir!

Dans la ligne d’édition qui apparaît en haut de l’écran, écrivez CMake (remarquez comment VSC modifie ses suggestions au fur et à mesure), puis sélectionnez CMake Build. VSC vous demandera alors de choisir entre Debug, Release, MinSizeRel et RelWithDebInfo. Pour le moment, sélectionnez Debug, mais sachez que Release pourra être fort utile lorsque vous aurez besoin du maximum de performance possible. Notez que vous pouvez également utiliser la touche F7 comme raccourci.

6.3. Exécution et débogage

Si la compilation se termine avec succès, vous pouvez maintenant passer à l’étape de l’exécution du programme. Ici, nous cherchons à exécuter le programme sur le Raspberry Pi, mais en vous permettant de voir sa sortie et de le contrôler depuis votre ordinateur. Nous vous fournissons des scripts permettant de configurer VSC à cet effet. Vous devez cependant préalablement configurer un paramètre important. Dans le fichier .vscode/tasks.json, remplacez adresse_de_votre_raspberry_pi par l’adresse (IP ou DNS) effective de votre Raspberry Pi. Faites de même dans le fichier .vscode/launch.json, en conservant toutefois le :4567 qui suit l’adresse du Raspberry Pi.

Une fois cela fait, vous pouvez synchroniser l’exécutable et lancer le débogage en allant dans le menu Déboguer puis Lancer le débogage (la touche F5 est un raccourci plus rapide ayant le même effet). Après quelques secondes (le script utilise rsync pour synchroniser les fichiers vers le Raspberry Pi), l’interface de débogage devrait s’afficher et vous permettre de déboguer le programme à distance.

À noter toutefois que lors d’un débogage, vous n’aurez pas accès à STDIN ou STDOUT. Aussi pour saisir des données ou voir les sorties du programme, il faut l’exécuter à distance sur le Raspberry Pi (àprès l’avoir synchroniser bien sûr). Pour cela, les commandes

rsync -av build/SETR_TP1 pi@addr_pi:projects/laboratoire1
ssh pi@addr_pi -t ./projects/laboratoire1/SETR_TP1

à exécuter depuis la racine du laboratoire pourraient vous être utiles (veillez à bien remplacer addr_pi par l’adresse IP de votre Raspberry).

6.4. Correction des bogues

À ce stade, vous devriez être en mesure de lancer une session de débogage à distance sur le Raspberry Pi. Il est maintenant temps d’utiliser tout cela à bon escient! Le fichier qui vous est fourni contient trois erreurs distinctes en plus de générer plusieurs avertissements de la part du compilateur. Ces erreurs ne sont pas des erreurs de compilation, mais des erreurs de logique, qui empêchent le programme d’avoir le bon comportement. Vous devez les identifier et les corriger en utilisant le débogueur de VSC. Vous devez également pouvoir expliquer leur cause, de même que les corrections à apporter pour que le programme fonctionne correctement.

Finalement, vous devez corriger le code de manière à ce que GCC ne renvoie plus aucun warning lors de la compilation (tout en conservant le fonctionnement du programme, bien entendu). Prenez l’habitude de lire et décortiquer les avertissements du compilateur; ceux-ci révèlent parfois des erreurs cachées (et c’est le cas ici…).

7. Modalités d’évaluation

Ce travail est individuel. Aucun rapport n’est à remettre, mais vous devez être en mesure de démontrer que votre environnement de développement est fonctionnel et que vous savez utiliser ses fonctions basiques dans une visioconférence Zoom. Cette évaluation sera faite lors des séances de laboratoire du 29 janvier 2021 et du 5 février 2021. Ce travail compte pour 5% de la note totale du cours.

Le barême d’évaluation détaillé sera le suivant (laboratoire noté sur 20 pts):

  • (4 pts) Raspberry Pi fonctionnel, y compris à distance (via SSH);
  • (6 pts) Chaîne de compilation croisée correctement construite et installée dans $HOME/arm-cross-comp-env, capacité à produire un binaire ARM;
  • (2 pts) Visual Studio Code installé et fonctionnel, débogage à distance utilisable;
  • (6 pts) Programme débogué: le programme doit s’exécuter sans erreur et produire un résultat correct. L’étudiant doit pouvoir expliquer les raisons des erreurs dans le programme initial;
  • (2 pts) Programme corrigé: le programme doit pouvoir être compilé sans générer aucun warning et ce en produisant toujours un résultat correct.

8. Ressources et lectures connexes