Objectifs pédagogiques

Les principaux objectifs de ce sujet de travaux pratiques sont :

  • de découvrir divers environnements de programmation en langages C/C++ – notamment dans le framework Arduino ;
  • d'apprendre à installer sur un poste de travail des outils‑logiciels de programmation, aussi bien sous Windows que Linux.

Pour traiter ces exercices, il est recommandé d'avoir étudié tous les chapitres de la partie C1. Des renvois aux principaux éléments de cours requis sont indiqués au fur et à mesure des questions.

Mise en situation

Les exercices consistent à mettre en œuvre différents environnements de développement gratuits prenant en charge les langages C et C++, qui seront utilisés dans le cadre de ce module de formation, et en particulier pour le codage de programmes embarqués sur carte à microcontrôleur.

Chaque environnement présente des avantages et des inconvénients qui le rendent bien adapté à tel ou tel contexte ou stade d'apprentissage, mais pas à d'autres.

Même si tous les programmes pour carte Arduino demandés dans les sujets de travaux pratiques de ce module de formation sont réalisables avec l'environnement de simulation en ligne Tinkercad, il est utile d'avoir expérimenté, au moins une fois, comment fonctionne une vraie carte Arduino, notamment dans son interaction avec le logiciel Arduino IDE.

Travail demandé

Même si les environnements de développement peuvent sembler indépendants les uns des autres, il est recommandé de traiter les exercices de ce sujet de travaux pratiques dans l'ordre.

Effectuer les manipulations sur ordinateur en veillant à enregistrer les fichiers au fur et à mesure, en créant pour chaque exercice un répertoire de projet :

  • tous placés dans un répertoire de TP nommé TP_C1-1,
  • lui‑même placé dans un répertoire principal de programmation, nommé Prog_C,
  • lui‑même placé dans le répertoire personnel d'étudiant sur la machine.

Répondre sur cahier ou fichier aux questions qui nécessitent une explication littérale.

  1. Le logiciel Arduino IDE
    2. Cet exercice est à effectuer si possible sous les deux systèmes d'exploitation Windows et Linux du poste de travail. Se référer aux recommandations de l'enseignant pour savoir quel système il est préférable de prioriser.
    1. Vérifier que le logiciel est déjà installé avec la version précisée ci‑dessous, sinon procéder à l'installation de la dernière version stable de la branche 2.x, conformément à la procédure recommandée dans le cours, chap. C1‑III .
    2. Raccorder la carte Arduino fournie à un port USB de l'ordinateur. Sélectionner le type de carte et le port USB ouvert par le branchement de la carte.
      3. Via la commande idoine du menu Outils, récupérer les informations de la carte, et vérifier ainsi que la liaison série fonctionne bien.
    3. Dans le menu Fichier/Exemples/01.Basics, ouvrir le fichier Blink.ino qui fait clignoter la led intégrée (builtin led – cf. chap. C1‑III )  avec une demi‑période de 1 seconde. Le téléverser dans la carte (la compilation est automatiquement faire préalablement – cf. chap. C1‑III ). Vérifier qu'il s'exécute correctement.
    4. Comment appelle‑t‑on le code source d'un programme dans le framework Arduino, en français et en anglais ?
  2. L'environnement en ligne Arduino Web editor
    1. En ligne, créer un compte Arduino A sur la base d'une adresse de courriel et d'un mot de passe (à recopier sur un mémo).
      2. Installer le plugin « Arduino create agent » en suivant la procédure indiquée au lien suivant A. Il s'agit d'un composant logiciel qui permet au navigateur de téléverser du code exécutable sur une carte Arduino raccordée au poste de travail.
    2. Dans l'éditeur de code en ligne, créer un nouveau programme ; le renommer Blink et copier le code source de l'exercice précédent.
      3. Modifier ce programme pour régler la durée d'allumage de la led à 100 millisecondes. Téléverser le programme dans la carte et vérifier son bon fonctionnement.
    3. Tester les paramètres réglables (preferences) de l'éditeur. Quelles sont les différences (avantages/inconvénients) entre l'éditeur en ligne et celui intégré au logiciel Arduino IDE ?
    4. Quelles sont les limites imposées à l'utilisation gratuite de cet environnement ?
    5. Pour finir, sous Linux Mint, via le menu Démarrer, cliquer sur le raccourci Applications au démarrage. Dans la liste des applications affichées, désactiver Arduino Create Agent.
  3. L'environnement en ligne Tinkercad 
    1. Sur le site de l'application , créer un compte personnel Tinkercad sur la base d'une adresse de courriel et d'un mot de passe (à recopier sur un mémo).
      2. Dans le navigateur, mémoriser par un favori la page web de connexion au compte Tinkercad.
    2. Une fois connecté, ouvrir la page Conceptions puis dans la rubrique Circuits, créer un nouveau circuit ; le renommer Blink.
    3. Sur l'espace de travail, placer une carte Arduino Uno. Via le menu déroulant sous le bouton Code, sélectionner le choix Texte pour visualiser le programme dans sa version littérale (et non pas sous forme de blocs semi‑graphique type langage scratch). Vérifier qu'il s'agit bien d'un programme de type « blink ».
    4. Lancer la simulation et vérifier que le programme fonctionne bien.
    5. Quelles sont les différences (avantages/inconvénients) entre l'éditeur en ligne de Tinkercad et l'éditeur de code du logiciel Arduino IDE ?
  4. L'éditeur de code Sublime Text  et la chaîne de compilation GCC 
    5. Cet exercice est également à effectuer si possible sous Windows et sous Linux.
    1. Sur le poste de travail, vérifier que le logiciel est déjà installé sinon procéder à son installation via la procédure recommandée dans le cours au chap. C1‑II .
      2. Ajouter un raccourci dans le tableau de bord (barre de tâche), puis exécuter le logiciel.
    2. Dans un nouveau fichier, copier‑coller le code source ci‑dessous : 
      3. #include <stdio.h>

int main(void)
{
  printf("Hello, World!\n");
  return 0;
}
      Enregistrer ce fichier sous le nom helloWorld.c dans un dossier nommé Hello_World, lui‑même placé dans le dossier TP_C1-1. Après cet enregistrement, comment le code source apparaît‑il ?
    3. Sur le poste de travail, vérifier que la chaîne compilation GCC (sous Linux) ou MinGW (sous Windows) est installée, sinon procéder d'abord à cette installation en suivant la procédure recommandée au. chap. C1‑II .
    4. Dans un terminal de commandes en lignes ouvert depuis le dossier Hello_World, saisir la commande : 
      5.   		
      gcc helloWorld.c -o helloWorld && ./helloWorld
      • Que s'est‑il passé ?
      • Saisir la commande ls -l. Que contient maintenant le répertoire Hello_World ? Quel est le type du fichier helloWorld ? Quelle est sa taille ?
      • Que se passe‑t‑il si l'on saisit maintenant simplement la commande ./helloWorld ?
      • Saisir la commande echo $?. Quelle valeur de retour obtient‑on ?
    5. Dans le fichier source, à la ligne n° 6, coder return 1; au lieu de 0 puis recompiler et exécuter le programme. Quelle valeur de retour obtient‑on maintenant ?
    6. Saisir maintenant la commande : 
      7.   		
      g++ helloWorld.c -o helloWorld && ./helloWorld
      Que se passe‑t‑il ? Le fichier helloWorld a‑t‑il changé de taille ? La valeur de retour est‑elle différente ?
    7. Dans le même dossier, créer un nouveau fichier nommé helloWorld.cpp et y coder le programme ci‑dessous : 
      8. #include <iostream>

using namespace std;

int main()
{
  cout << "Hello World!" << endl;
  return 0;
}
      • Quelles sont les principales différences que présente code avec la version précédente en langage C ?
      • Essayer de compiler ce programme avec la commande gcc comme auparavant. Que se passe‑t‑il ?
      • Recommencer avec la commande : 
        •   		
        g++ helloWorld.cpp -o helloWorldCpp && ./helloWorldCpp
        Conclure.
  5. L'environnement en ligne OnlineGDB 
    6. Cet exercice propose approximativement les mêmes expérimentations que le précédent, mais dans un environnement en ligne.
    1. Dans le navigateur, mémoriser par un favori la page d'accueil du site web OnlineGDB.
      2. Sur cette page d'accueil, sélectionner le langage C et exécuter le programme « Hello World » figurant par défaut dans le cadre d'édition de code. Vérifier la sortie obtenue dans le cadre inférieur, qui correspond à une console d'exécution.
    2. Modifier le code source en tapant return 1; au lieu de 0 pour la valeur de retour de la fonction main. La valeur 1 s'affiche‑t‑elle dans le message  en fin d'exécution ?
    3. Supprimer l'instruction return 1;. Le code source est‑il encore compilable ? Que donne le résultat d'exécution ?
    4. Avec le même programme, sélectionner le langage C++, puis tenter l'exécution. Que se passe‑t‑il ?
    5. Dans la fenêtre d'édition, copier‑coller la version en C++ du programme « Hello World » donnée à l'exercice précédent. Vérifier qu'il s'exécute bien.
    6. Avec ce programme en C++, sélectionner à nouveau le langage C puis tenter l'exécution. Que se passe‑t‑il ?
  1. * L'environnement intégré de développement VS Code 
    2. Cet exercice est est également à effectuer si possible sous Windows ou sous Linux.
    1. Sur le poste de travail, vérifier que le logiciel est déjà installé sinon procéder à l'installation de la dernière version du logiciel VS Code conformément à la procédure recommandée (cf. cours, chap. C1‑II ).
    2. Comme à l'exercice nº 4, vérifier que la chaîne compilation GCC (sous Linux) ou MinGW (sous Windows) est installée sur le poste de travail, sinon procéder d'abord à cette installation en suivant la procédure recommandée au. chap. C1‑II .
    3. Installer l'extension C/C++ et la paramétrer en spécifiant le chemin d'accès à la chaîne compilation (cf. chap. C1‑II ).
    4. Dans le répertoire de programmation, créer un nouveau dossier nommé par exemple HelloCPP. Ouvrir ce dossier via VS Code et créer un nouveau fichier source nommé helloWorld.cpp. Y copier‑coller le même code source qu'à l'exercice 4.
    5. Cliquer sur le bouton ▷ (Run) pour effectuer la compilation du programme en langage C++. Dans l'onglet TERMINAL de la fenêtre basse, vérifier que son exécution est conforme au code source.
      6. Où est placé le fichier exécutable ?
    6. Dans le dossier .vscode, ouvrir le fichier tasks.json. Ajouter toutes les options d'avertissement (-Wall -Wextra) recommandées dans les arguments de la commande de compilation (cf. chap. C1‑II ).
      7. Re‑cliquer le bouton ▷ et, dans l'onglet TERMINAL, vérifier que cette modification a bien été prise en compte.
      Fermer le répertoire de travail.
    7. Installer l'extension Arduino (cf. chap. C1‑III ).
    8. Dans le répertoire de programmation, créer un nouveau répertoire de projet nommé par exemple BlinkVS puis l'ouvrir via VS Code. Y créer un nouveau fichier source homonyme (cf. chap. C2‑I ), nommé BlinkVS.ino et y copier‑coller le programme de clignotement usuel : 
      9. void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}
      sans oublier de l'enregistrer.
    9. Brancher une carte Arduino sur le poste de travail et bien suivre la procédure (cf. chap. C1‑III ) pour pouvoir téléverser ce programme dans la carte : initialisation, choix du type de carte, choix du port USB .
      10. Une fois le téléversement effectué, vérifier que le clignotement de la led intégrée est conforme au code source.
    10. Dans le dossier .vscode, observer le contenu respectif des fichiers arduino.json et c_cpp_properties.json.
    11. Compléter le programme pour écrire un message sur le moniteur série (typiquement, Hello, World!) et, ce faisant, vérifier que la fonctionnalité Intellisense fonctionne correctement.
      12. Après avoir téléversé cette nouvelle version du programme, vérifier le bon fonctionnement du moniteur série sous VS Code.