{{tag>dev iot c embarqué cross-compilation arm nucleo}}
:TODO_DOCUPDATE:
Notes et transcriptions du cours [[https://openclassrooms.com/fr/courses/4117396-developpez-en-c-pour-lembarque|Développez en C pour l'embarqué]] disponible sur la plateforme [[https://openclassrooms.com/fr|Openclassrooms]].
====== Entraînez-vous en créant un projet ======
===== À vous de jouer ! =====
Pour vous entraîner, réalisez cet exercice étape par étape. Une fois terminé, vous pouvez comparer votre travail avec les pistes que je vous propose.
Cette première activité a pour but de vérifier que vous disposez de tous les outils nécessaires pour avancer dans la suite de ce cours.
Pour cela, vous allez créer un projet, importer du code, le compiler et l’exécuter tout en observant son comportement.
===== Documents à réaliser =====
Le rendu se fera sous la forme de captures d’écran sur lesquelles vous surlignerez les éléments à visualiser. Par exemple, vous pouvez montrer que votre code a bien compilé en indiquant par un cadre le résultat de la compilation :
{{tp1_resultat_compilation01.png|Résultat de la compilation}}
===== Travail à réaliser =====
Commencez par récupérer {{src_tp1.zip|l’archive du TP}} et décompressez-la.
==== Étape 1 ====
Créez un nouveau projet que vous nommerez Act1. Ajoutez un fichier C dans lequel vous copierez le code du fichier main.c de l’archive (vous pouvez aussi directement l’importer). Ne modifiez pas le contenu du code. Compilez.
Faites une capture d’écran montrant :
* les éléments composant votre projet,
* la fenêtre avec le code,
* le résultat de la compilation.
==== Étape 2 ====
Ajoutez à votre projet les fichiers librairie.lib et functions.h (qui sont dans l’archive) avec un clic droit sur le répertoire avec les sources ou bien en utilisant le bouton {{bt_composants.png}} .
Attention, pensez bien à sélectionner All files (*) comme type de fichiers.
Décommentez toutes les lignes commentées de votre fichier C (lignes 2, 6, 9 et 11). Vous devriez avoir un code similaire à :
{{tp1_c_3.png|Attendu pour l'étape 2}}
* Compilez et passez en mode debug ;
* Faites une capture d’écran montrant que vous êtes bien passé en mode debug simulé.
==== Étape 3 ====
* Mettez un point d’arrêt sur la ligne 9 et lancez l’exécution.
* Faites une capture d’écran montrant l’exécution arrêtée à la ligne 9.
==== Étape 4 ====
* Observez la valeur de la variable observable à chaque incrément de la boucle for ;
* Faites deux captures d’écran montrant la valeur de observable. Les captures doivent montrer de combien observable augmente à chaque pas de la boucle for. Autrement dit, faites une capture à un instant, puis une autre capture après avoir fait un pas de la boucle.
==== Étape 5 ====
* Combien de temps s’est écoulé entre le début de l’application et la ligne 13 ?
* Faites une capture d’écran sur laquelle vous montrez la durée qu’a pris la simulation pour arriver à la ligne 13.
==== Étape 6 ====
* Observez la valeur stockée à l’adresse mémoire 0x20000004 quand le programme atteint la ligne 13.
* Faites une capture d’écran montrant la valeur de la mémoire.
===== Vérifiez votre travail =====
Alors, vous êtes allé au bout ? Suivez le guide pour vérifier votre travail !
Sur chaque image, il vous faudra vérifier que les éléments demandés sont bien présents sur la capture et qu’ils ont été bien mis en évidence.
* Les éléments sont bien tous identifiés sur les captures d'écran ;
* Le mode debug est bien lancé ;
* Le point d'arrêt est présent à la bonne ligne et l'exécution est suspendu à ce niveau ;
* Les deux captures d'écran montrent bien un écart de 42 (ou 2A en hexadécimal) entre les deux valeurs de la variable ;
* La durée est indiquée et représente bien la durée d'exécution ;
* La fenêtre "Memory" est bien présente sur la capture d'écran ainsi que l'adresse, et la valeur est correcte.
===== Étape 1 =====
++++Correction|
* Créer un dossier dédié au projet nommé ''act1'' dans son répertoire de travail ;
* On crée notre projet dans Keil µVision via le menu Projet > New µVision Project... ;
* On crée le fichier projet "act1" dans notre dossier dédié au projet ''act1'' ;
* On sélectionne la cible initiale du projet ici ''STMicroelectronics > STM32F103 > STM32F103RB'' ;
* On sélectionne les fichiers ''Device > Startup'' et ''CMSIS > Core'' ;
Le projet existe à présent, on va y introduire les sources de l'activité.
* On peut décompresser l'archive de l'activité dans le dossier du projet, elle contient un répertoire ''src'' ;
* On va utiliser la gestion des composants du projet {{bt_composants.png}} pour associer nos sources au projet ;
* Pour plus de clarté, on renomme : "Target_1" en "EMULATION" et "Source Group 1" en "SRC";
* Dans notre source group "SRC" on associe notre premier fichier source via le bouton ''Add Files...''. On sélectionne ".\src\main.c" on clique sur les boutons ''Add'' puis ''Close'' ;
{{act1_src_01.png|Fenêtre de composants du projet µVision}}
Par défaut, les fichiers générés par la compilation sont stockés dans le répertoire du projet. Je préfère qu'ils soient créés et stockés en dehors des fichiers source du projet (dans mon cas dans un RAM disk car je ne souhaite pas conserver ces fichiers temporaires sur le disque). C'est paramétrable via le bouton Options for Target... {{bt_options_for_target.png}}.
* Sélectionner l'onglet "Output" ;
* Cliquer sur le bouton ''Select Folder for Objects...'' et sélectionner le répertoire dans lesquels les fichiers objets et le binaire seront générés.
* On peut maintenant supprimer le dossier ".\Objects" du dossier projet.
Pour lancer la compilation :
* Dans l'arborescence du projet sélectionner SRC > main.c ;
* Cliquer sur le bouton compiler {{bt_build.png}}.
{{act1_build_01.png|Activité 1, première compilation}}
* L’image doit mettre en évidence une zone avec la structure du projet, une zone avec le code principal et une dernière zone dans laquelle doit apparaître le résultat de la compilation.
Si vous n'avez pas réussi à éditer et compiler du code, veillez consulter les sections 1 et 2 du chapitre 1.3
++++
==== Étape 2 ====
++++Correction|
Vérifier les paramétrages du simulateur
* Cliquer sur le bouton Options for target () ;
* Sélectionner l' onglet "Debug" et assurez-vous que l'option ''Use Simulator'' est bien cochée ;
* Vérifiez que dans la partie à gauche qui sert pour la simulation, vous avez bien les valeurs suivantes pour :
* "CPU DLL" : ''SARMCM3.DLL'' ;
* "Dialog DLL" : ''DARMSTM.DLL'', "Parameter" : ''-pSTM32F103RB''.
* Vérifier que la partie droite qui sert pour l'exécution sur cible réelle et vous avez bien les valeurs suivantes :
* "Driver DLL" : ''SARMCM3.DLL'' ;
* "Dialog DLL" : ''TARMSTM.DLL'', "Parameter" : ''-pSTM32F103RB''.
{{cible_emulation_act1.png|Options cible emulation ARM STM32F103RB}}
* Placer un point d'arrêt en cliquant derrière le numéro de ligne souhaité ;
* Lancer le débogage via le bouton debug {{bt_debug.png}} ;
* Cliquer sur le bouton Run (F5){{bt_run.png}} pour exécuter le code jusqu'au point d'arrêt.
{{act1_mode_debug_01.png|Exécution de l'application en mode débogage sur la cible simulée}}
* L’image doit simplement montrer que le mode debug est bien lancé.
La méthode pour passer en mode debug est expliquée dans la section 3 du chapitre 1.3.
++++
==== Étape 3 ====
++++Correction|
L’image doit montrer le point d’arrêt sur la ligne 9 ainsi que les doubles flèches indiquant que le programme est arrêté sur cette ligne.
{{act1_mode_debug_02.png|Exécution en débogage, point d'arrêt sur ligne 9}}
Pour ajouter un point d'arrêt, il suffit de cliquer sur la partie gauche des lignes de code. Il faut ensuite lancer l'exécution en cliquant sur run (). L'exécution s'arrêtera au premier point d'arrêt qu'elle rencontre. La section 1 du chapitre 1.4 explique cela.
++++
==== Étape 4 ====
++++Correction|
* On lance le mode débogage via le bouton Debug Session {{bt_debug.png}} ;
* On clique sur le bouton Run {{bt_run.png}} pour continuer l'exécution jusqu'au point d'arrêt de la ligne 9 ;
* On affiche la fenêtre Watch 1 via le menu View > Watch Windows > Watch 1 ;
* On ajoute la variable nommée "observable" à la fenêtre via le menu contextuel. Sur la variable clic droit sélectionner l'option ''Add 'observable' to...'' > ''Watch 1'' ;
* Via le menu contextuel on peut sélectionner le format d'affichage de la variable ;
Initialement observable vaut 0. Via le bouton Run(F5){{bt_run.png}}, on relance l'exécution du code jusqu’à retomber sur le point d'arrêt. La variable "observable" vaut alors 42.
{{observable_passe_01.png}}
On clique a nouveau sur le Run(F5){{bt_run.png}} et "observable vaut 84.
{{observable_passe_02.png}}
A chaque appel de la fonction ''fonction1'' la variable observable est incrémentée de 42 unités.
++++
==== Étape 5 ====
++++Correction|
La durée de la simulation est indiquée en bas de la fenêtre. Pour avoir le temps simulé pour atteindre la ligne 13, il faut un point d’arrêt sur la ligne 13 et que le programme y soit arrêté.
Comme précisé dans la section 1 du chapitre 1.4, la durée du temps estimé en simulation est indiquée en bas de la fenêtre. Vous pouvez la remettre à zéro en effectuant un clic droit sur elle.
* On place le point d'arrêt en ligne 13 ;
* On lance le débogage via le bouton Start Debug Session {{bt_debug.png}} ;
* On continue l'exécution du code jusqu'au point darrêt via le bouton Run(F5) {{bt_run.png}} ;
{{temps_execution.png}}
++++
==== Étape 6 ====
++++Correction|
Pour observer la valeur de la mémoire, il faut que la fenêtre Memory soit sélectionnée et que l’adresse soit saisie. On observe à l’adresse ''0x20000004'' (contenue dans le registre R1) les bits 24 00 00 00 en hexadécimal, soit la valeur de 0x00000024 (ou 36 en décimal).
La fenêtre mémoire peut être affichée en allant dans le menu View et en sélectionnant Memory Windows comme cela est indiqué dans la section 3 du chapitre 1.4.
Une fois cette fenêtre apparue, en saisissant l'adresse de la mémoire dans Address, il est possible d'observer la valeur contenue dans cette plage mémoire.
{{act1_sonde_memoire.png}}
Attention, la lecture des octets se fait à l'envers (on parle d'architecture **little-endian**). La valeur 0x24000000 en mémoire correspond à la valeur 0x00000024
++++