Notion d'informatique embarquée

Historique succinct

Regardez la vidéo suivante en essayant de mémoriser les grandes dates :

À l'issue du visionnage, réaliser l'exercice suivant pour vérifier la mémorisation des dates essentielles au programme.

Synthétiser les dates historiques présentées dans la vidéo ci-dessus :

  1. En est inventé le premier transistor.

  2. En , le premier système informatique de guidage est embarqué dans un objet : le véhicule spatial Appolo.

  3. En est commercialisé le premier processeur grand public.

  4. En sort l'Airbus 320, premier avion équipé de commandes électriques informatisées.

  5. En est mise en service le métro totalement informatisée (sans conducteur) Météor à Paris sur la ligne 14.

  6. En est commercialisé le premier smartphone.

Une fois les réponses saisies, vérifier leur validité en cliquant sur ce bouton :

Code de déblocage de la correction :

Système informatique embarqué

Fonctionnement simplifié d'un ordinateur

schéma éclairant ce qui suit

Lorsque vous utilisez votre ordinateur portable, vous saisissez des informations sur le clavier ou déplacez votre doigt sur le pavé tactile.

Un système informatique (embarqué) peut être vu de la même manière :

  1. Le système capte une information physique

  2. elle est convertie en binaire

  3. l'information est traitée par un (micro)processeur en permanence

  4. l'information traitée est reconvertie en signal électrique

  5. Ce signal électrique conduit à l'action d'un élément du sytème qui agit sur l'extérieur.

Voici une liste de différentes définitions. Chacune correspond à un des mots suivants : actionneur, capteur, logiciel, mémoire, processeur.

Dans un document modifiable comme LibreOffice, associer à chaque définition suivante, le mot lui correspondant :

  1. objet qui recueille des données provenant de ce que qui l'environne.

  2. objet qui stocke une information binaire composée de 0 et de 1.

  3. programme permettant de savoir comment traiter une information pour un objectif précis.

  4. objet qui traite des données numériques de manière automatique.

  5. objet qui en modifiant son état peut agir sur le monde physique qui l'environne.

Code de déblocage de la correction :

Un système informatique embarqué est une machine dédiée à une tâche définie. Il peut être vu comme une chaîne d'opérations en boucle traitées en permanence, chaîne entre le monde physique/réel et l'objet contenant ce système informatique embarqué.
Il est composé de :

Copier l'image du schéma suivant dans un document modifiable puis compléter ce schéma représentant visuellement un système informatique embarqué en précisant où se trouvent dans la boucle les capteurs et les actionneurs.

schéma

Convertisseur A/N signifie convertisseur analogique/numérique : objet qui transforme un signal électrique (tension, intensité, ...) en un numérique (en bits : 0 ou 1) ou inversement.

Code de déblocage de la correction :

Voici une liste d'objets, certains sont des capteurs, d'autres des actionneurs :

gyrophare ; Sonde d’humidité ; détecteur de présence ; lumière ; télécommande ; bouton poussoir ; sirène ; moteur électrique ; détecteur de lumière.

Dans cette liste, quels sont les capteurs ?

Code de déblocage de la correction :

Interface Homme Machine

un Interface Homme/Machine, d'acronyme IHM, est un dispositif permettant à un humain de communiquer avec une machine.

Voici un thermostat régulant la température d'une maison :

thermostat
  1. Citer des capteurs en lien avec ce thermostat ?

  2. Citer au moins un actionneur en lien avec ce thermostat ?

  3. Pourquoi ce thermostat peut être vu comme une Interface Homme Machine (IHM) ?

Code de déblocage de la correction :

Le thermostat régulant la température d'une maison fonctionne suivant des programmes précis.

thermostat

Voici un algorithme, intégré au logiciel de gestion du processeur du thermostat, qui permet de gérer la température d'une pièce :
(il est écrit en langage "courant" afin de faciliter son fonctionnement).

Tant que vrai :
	lire et stocker la température extérieure
	lire et stocker la température intérieure
	si la température intérieure est inférieure à 18 °C :
		mettre en chauffe les radiateurs
	sinon :
		mettre ou laisser les radiateurs en pause

Comme un ordinateur ne comprend pas un algorithme écrit ainsi, différents langage de programmation ont été développés afin de pouvoir faire comprendre à un processeur l'ensemble des tâches à réaliser. Python est un de ces langages de programmation.

Voici l'algorithme précédent réécrit en python :

while True :
	tempExt = temperatureExterieure()
	tempInt = temperatureInterieure()
	if tempInt < 18 :
		radiateur.run()
	else :
		radiateur.sleep()
  • c'est un code simplifiée fondée sur une pseudo-bibliothèque non énoncée : il n'a pas pour but d'être implémenté tel quel dans un processeur, mais est là pour donner à voir la structure globale d'un tel programme ;

  • temperatureExterieure() est une fonction servant à obtenir la température extérieure mesurée par un capteur extérieur ;

  • temperatureInterieure() est une fonction servant à obtenir la température intérieure mesurée par un capteur intérieur ;

  • radiateur.run() est une fonction mettant en marche l'actionneur radiateur.

  • radiateur.sleep() est une fonction mettant en pause l'actionneur radiateur.

  1. Quelle ligne dans l'algorithme écrit en Python permet de voir le système informatique embarqué comme une chaîne d'opérations en boucle traitées en permanence ?

  2. Sur quelle température est réglée l'algorithme du thermostat contrôlant la température intérieure ?

  3. On veut modifier cet algorithme écrit en Python pour que le radiateur ne se mette en marche que dans le cas où la température intérieure est inférieure à 16°C et est supérieure à celle extérieure (sinon, plutôt que d'allumer le radiateur, il suffit d'ouvrir une fenêtre pour réchauffer la maison : geste écologique et économique !).
    Compléter le script ci-dessous en remplaçant la ligne de pointillés :

    while True :
    	tempExt = temperatureExterieure()
    	tempInt = temperatureInterieure()
    	......................................................
    		radiateur.run()
    	else :
    		radiateur.sleep()
    

Code de déblocage de la correction :

Principe du système antoblocage ABS (de l'allemand Antiblockiertsystem) :

Un véhicule est équipé sur chacune de ses roues d'un mesureur de vitesse de rotation de la roue. Si, lors d'un freinage, la vitesse mesurée en temps réel est nulle, l'information est transmise au calculateur qui va alors commander de relâcher la pression hydraulique sur les freins afin que la roue se remmette à tourner. Le système va ainsi, jusqu'à vingt-quatre fois par seconde, bloquer et débloquer les freins, quand bien même le conducteur continue à appuyer à fond sur la pédale de frein. Ces réajustements répétés peuvent être ressentis par le conducteur au niveau de la pédale de freinage.

Voici un schéma représentant le système :

schéma
  1. Citer les capteurs en lien avec le système ABS.

  2. Citer les actionneurs en lien avec le système ABS.

  3. Écrire en langage naturel un programme permettant de décrire le fonctionnement du système ABS.

  4. Dans la seconde phrase décrivant le principe de fonctionnement, quel est le groupe de mot qui permet d'assurer que le pilotage du système se fait à une vitesse adaptée à l'évolution du système ?

  5. Est-ce à la base un "objet connecté" ? Pourquoi ?

Code de déblocage de la correction :

Voici un exercice qui vous permet de vérifier votre maîtrise des notions vues dans cette partie.
Un corrigé est accessible ici afin que vous puissiez vérifier votre travail autonome.
Pour un travail autonome, quoi de tel qu'une voiture "autonome" !

Lancé en 2014 sur la Model S, l’Autopilot Tesla n’a cessé d’évoluer grâce aux mises à jour, combinées à une technologie en progression constante. Tesla est un des constructeurs pionniers de l’automobile électrique moderne. Parmi les domaines où elle est en avance par rapport aux autres constructeurs figure la conduite semi-automatique. Baptisée Autopilot sur ses modèles depuis 2014, elle est en passe de devenir totalement autonome si l’on en croit le dirigeant. Ce serait pour 2022, où les voitures deviendraient de véritables « robotaxis »…

Quels sont les équipements de l’Autopilot ? L’Autopilot est la dénomination des systèmes d’aides à la conduite semi-autonome de Tesla. Selon les modèles, la date de construction et la version du logiciel installée, les capacités sont différentes. Depuis avril 2019, tous les véhicules Tesla sont équipés de la 3ème génération du système. Un dispositif qui serait compatible avec l’option «Capacité de conduite entièrement autonome». Dans le détail, cette V3 de l’Autopilot intègre :

Pour traiter les données reçues par les différents dispositifs, il faut un outil de calcul puissant. Entre 2014 et octobre 2016, Tesla a intégré des puces MobilEye, puis des nVidia jusqu’en avril 2019. Désormais, Tesla conçoit ses propres processeurs, avec la puce FSD autoproclamée «la plus puissante du monde».

Enfin, autre avantage des Tesla, c’est que le logiciel n’est pas figé. Le constructeur met à jour régulièrement le système embarqué, et améliore ainsi progressivement l’efficacité.

  1. Pourquoi les voitures Autopilot de Tesla peuvent être considérées comme un système informatique embarqué ?

  2. Citer des capteurs utiles à l’autopilote Tesla.

  3. Citer des actionneurs utiles aux voitures Autopilot de Tesla.

  4. Pourquoi peut-on parler d'objets connectés concernant les voitures Autopilot de Tesla ?

  5. Quels inconvénients peuvent avoir les objets connectés en général ?

Proposer une trace écrite de la séance :

Code de déblocage de la correction :

Un des domaines où l'informatique embarquée va se généraliser dans les années à venir est surement la domotique.
Visualiser ci-dessous une vidéo du CEA qui illustre le fonctionnement simplifié d'une maison connectée.
accès à la vidéo.

Home I/O

Home IO avec EduPython

2.1.1. Installations

Pour pouvoir gérer une maison virtuelle avec du code écrit en langage Python depuis l'IDLE EduPython, il vous suffit d'installer les logiciels et fichiers suivants :

Si vous avez le message d'erreur ci-dessous, il vous suffit de suivre le tutoriel présenté dans le document suivant.

2.1.2. Découverte de Home IO et de l'interaction avec EduPython

Découverte de Home IO
  1. Lancer Home IO.

  2. Cliquer sur l'icône nouveau .

  3. Cliquer sur l'icône confirmer :

  4. Se déplacer avec les flèches directionnelles dans votre maison virtuelle afin de la découvrir.
    En maintenant enfoncé le clic droit, vous pouvez changer d'angle de vision en déplaçant un doigt sur le pad.
    Vous pouvez ouvrir les portes pour accéder aux diférents lieux : vous pouvez vous déplacer comme vous le feriez en vrai.

  5. Pour accéder directement à une pièce donnée, il suffit de clique sur le lieu schématisé en bas de l'écran.
    Cliquer sur la pièce F afin d'accéder au garage : .
    Vous devez arriver alors directement dans le garage et avoir a peu près cette vue :

  6. Se déplacer dans la pièce afin de réperer les différents capteurs et actionneurs.

Code de déblocage de la correction :

Première interaction Home IO - EduPython

Chaque capteur ou actionneur présent dans la maison Home IO possède une pastille lumineuse à ses côtés.
Ces pastilles peuvent être de trois couleurs, chacune permettant une interaction différente :

  1. Aller dans le salon, pièce A de la maison.

  2. Passer en mode bleu la lumière du salon en cliquant deux fois (clics gauches) sur la pastille voisine de la lumière.

  3. Sur Eduptyhon, exécuter le programme le fichier python lancement.py normalement déjà téléchargé et exécuté.
    En revenant sur Home IO, vous devez voir, au bout de quelques secondes, la lumière du salon alternativement s'allumer 3 fois et s'éteindre 2 fois.

2.1.2. Gestion des deux lumières du garage

Dans cette partie, vous allez progressivement gérer la lumière du garage en fonction de plusieurs paramètres :

Gestion de l'appui sur un bouton de la télécommande

Dans Home IO, il est possible d'interagir avec une télécommande en cliquant sur l'icône télécommande : .
Ainsi apparait-elle : .

Le but de cet exercice est de faire en sorte que lorsque l'on appuie sur la touche 1 de la télécommande, la lumière "Lumières 1" du garage s'allume tandis qu'elle s'éteigne lorsque l'on appuie sur la touche 2.

  1. Revenir dans le garage, pièce F.

  2. Passer en mode bleu la lumière appelée "Lumières 1" se trouvant dans le mini-couloir reliant le garage au reste de la maison.

  3. Faire apparaître le télécommander et la passer en mode bleu en cliquant sur la zone sombre à côté de la zone allumée en vert :

  4. Voici le contenu d'un code Python à recopier sur EduPython :

    # Import des modules nécessaires (éventuellement à installer avec le module pip)
    import sys
    import time
    from pythonnet import load
    load("coreclr")
    import clr
    import keyboard
    
    clr.AddReference('EngineIO64') # Chargement du fichier EngineIO64.DLL
    
    from EngineIO import *
    
    print("Home I/O & Python sont bons amis ! Merci à pythonnet !")
    
    # iniatialisation de la lumière considérée
    # Output signifie que c'est un actionneur : la lumière "agit" sur l'environnement autour.
    # 68 est le numéro attribué à cette lumière particulière. (cf . https://docs.realgames.co/homeio/fr/memory-addresses/)
    lumiere1 = MemoryMap.Instance.GetBit(68, MemoryType.Output)
    
    # affichage de la valeur de l'état de la lumière ; booléen : True ou False
    print("État de la lumière 1 :",lumiere1.Value)
    
    
    # initialisation du bouton 1 de la télécommande
    # Input signifie que c'est un capteur : la télécommande "capte" l'appui exercé par l'utilisateur.
    # 274 est le numéro attribué à ce bouton de la télécommande. (cf . https://docs.realgames.co/homeio/fr/memory-addresses/)
    btn1 = MemoryMap.Instance.GetBit(274, MemoryType.Input)
    # initialisation du bouton 2 de la télécommande
    btn2 = MemoryMap.Instance.GetBit(275, MemoryType.Input)
    
    # Affichage de la valeur initiale de l'état du bouton 1 : True (pour enfoncé) False (pour relâché)
    print("État initial du bouton 1 :",...)
    
    while True: # boucle infinie pour que les événements soient pris en compte en continu sans limite de temps.
        # Cas où la lumière est éteinte et que l'on appuie sur le bouton1
        if lumiere1.Value == ... and btn1.Value == ...:
            lumiere1.Value = ...
    
        # Cas où la lumière est allumée et que l'on appuie sur le bouton2
        elif ...:
            lumiere1.Value = ...
    
        # mise à jour de l'état des variables en mémoire
        MemoryMap.Instance.Update()
    
    # Libération des variables en mémoire
    MemoryMap.Instance.Dispose()             

    Compléter le script précédent sur EduPython en remplaçant chaque ... par une instruction correcte.

    • Pour la ligne 32 print("État initial du bouton 1 :",...), s'aider de la ligne 21 :
      print("État de la lumière 1 :",lumiere1.Value),
      en réflechissant au nom de la variable corrrespondant au bouton 1.

    • Pour la ligne 36 if lumiere1.Value == ... and btn1.Value == ...:, traduire en langage Python le commentaire :
      # Cas où la lumière est éteinte et que l'on appuie sur le bouton1,
      sachant que lumiere1.Value et btn1.Value sont deux variables booléennes ne pouvant prendre comme valeur seulement True ou False.

    • Pour la ligne 37 lumiere1.Value = ..., réfléchir à l'état que doit prendre la variable lumiere1 dans le cas traité.
      Relire la fin de l'aide précédente.

    • Pour la ligne 40 elif ...:, traduire en langage Python le commentaire :
      # Cas où la lumière est allumée et que l'on appuie sur le bouton2

    • Pour la ligne 41 lumiere1.Value = ..., reprendre le raisonnement mis en oeuvre pour la ligne 37.

  5. Tester le script complété en l'exécutant et en vérifiant que la lumière concernée réagit correctement à la télécommande sur Home IO.

    Pour forcer l'arrêt d'un script exécuté spus EduPython, il suffit de cliquer sur le bouton .

    Si un message d'erreur apparaît une fois le script relancé, veuillez fermer EduPython puis ouvrir de nouveau cette application.
    De problème de fermeture sera réglé à l'exercice suivant.

  6. Quand la dernière ligne du script MemoryMap.Instance.Dispose() est-elle exécutée ? Quand déduire ?

Code de déblocage de la correction :

Le but de cet exercice est de créer une manière de quitter proprement la boucle infinie liée au while True.
L'idée est de faire en sorte qu'appuyer que la touche Q du clavier permette de quitter la boucle while et ainsi de permette l'exécution de la dernière ligne MemoryMap.Instance.Dispose().
Pour cela, il suffit :

  1. Rajouter dans la boucle while du script complété de l'exercice précédent le code suivant, avant la mise à jour de l'état des variables en mémoire :

    # gestion de la touche Q pour suitter la boucle infinie
        if keyboard.is_pressed('q'):
            break
  2. Lancer le programme complété afin de tester le bon fonctionnement du code.

Code de déblocage de la correction :

L'objectif de cet exercice est de voir s'il est possible de gérer l'état de la lumière1 avec une seule touche de la télécommande.

  1. Dans le script obtenu à l'exercice précédent, remplacer btn2 par btn1 dans la boucle infinie while.
    Tester le bon fonctionnement du script obtenu.
    Est-il possible de gérer ainsi l'état de la lumière en appuyant seulement le bouton1 ?

  2. Le problème rencontré vient du fait que l'appui dure un temps pendant lequel la boucle while effectue plusieurs tours qui conduisent à l'aternance d'allumages et d'extinctions répétées de la lumière 1, d'où le clignotement observé et l'état final non gérable.

    Pour gérer cela, nous allons créer une fonction relachement qui prend en paramètre un bouton et renvoie le booléen True lorsque le relachement du bouton a eu lieu.
    Cette fonction tourne en boucle tant que l'état du bouton (appuyé ou non) n'a pas changé.

    1. Rajouter le script suivant avant la ligne while True: dans le script obtenu précédemment puis compléter les ....

      def relachement(bouton):
          etat_initial = bouton.Value     # état initial du bouton
          etat_observe = bouton.Value
          while ...:                      # tant que l'état du bouton est inchangé
              etat_observe = ...          # état observé du bouton 
              MemoryMap.Instance.Update() # mise à jour des variables d'état
          return True
      1. Pour la ligne while ...:, traduire en langage Python le commentaire # tant que l'état du bouton est inchangé en utilisant les deux variables etat_initial et etat_observe.

      2. Pour la ligne etat_observe = ..., traduire en langage Python le commentaire # état observé du bouton en s'aidant du début du code de la fonction relachement.

    2. Utiliser cette fonction relachement à deux endroits dans la boucle while, en précisant quel bouton vous considérez, afin que la lumière 1 ne change d'état qu'une seule fois lors d'un appui prolongé sur la touche btn1.

    3. Tester le bon fonctionnement de votre code.

Code de déblocage de la correction :

Gestion de la présence d'une personne dans le garage

Le but est de faire en sorte que la lumière nommée "Lumières 2" du garage s'allume quand un mouvement est détecté dans le garage.

  1. Passer en mode bleu la lumière appelée "Lumières 2" ainsi que le détecteur de mouvement se trouvant dans le garage.

  2. Dans le script déjà obtenu, rajouter les lignes suivantes à la suite des initialisations de variables déjà écrites, c'est-à-dire avant la définition de la fonction relachement.

    # initialisation du détecteur de mouvement
    # 98 est le numéro attribué au détecteur de mouvement. (cf . https://docs.realgames.co/homeio/fr/memory-addresses/)
    mvt = MemoryMap.Instance.GetBit(98, MemoryType.???)
    print(mvt.Value)

    Ainsi, la variable qui gère la détection du mouvement dans le garage dans toute la suite sera la variable mvt.

    Remplacer dans ce script ??? par Input ou Output en prenant en compte si le détecteur de mouvement est un capteur ou un actionneur.

  3. La lumiere 1 a été initialisée dans le programme par la ligne suivante : lumiere1 = MemoryMap.Instance.GetBit(68, MemoryType.Output).

    Rajouter dans le script complet l'initialisation de la lumière 2 en s'aidant du code gérant l'initialisation de la lumière 1, sachant que le numéro attribuée à la lumière 2 dans Home IO est le 69. (cf. site officiel )

    Penser à utiliser un nouveau nom de variable pour gérer cette lumière 2. Pourquoi pas lumiere2 ?

  4. Rajouter dans la boucle while des lignes permettant de gérer l'allumage de la lumière 2 dans le cas où un mouvement est détecté ou non.

    • mvt.Value est un booléen permettant de savoir si un mouvement est détecté ou non.

    • lumiere2.Value = True force l'allumage de la lumiere2 : la valeur de son état est imposée à True.

  5. Tester le script réalisé.

Code de déblocage de la correction :

Prise en compte de la luminosité extérieure

Le but de cette partie est d'ouvrir les stores du mini-couloir reliant le couloir au reste du garage dans le cas où il fait suffisamment jour dehors afin d'éviter d'avoir à allumer la lumière 1, même lors d'un appui sur le bouton 1 de la télécommande.

  1. Sortir du garage, soit en passant par la porte du garage, soit en cliquant sur la zone externe à côté de cette porte.
    Mettre en mode bleu le capteur de luminosité externe.

  2. Revenir dans le garage (salle F).
    Mettre l'enrouleur du store en mode bleu.

  3. Dans le script déjà obtenu, rajouter à la suite des initialisations déjà écrites le script suivant :

    # initialisations pour la prise en compte de l'éclairage extérieur
    # cf. https://docs.realgames.co/homeio/fr/memory-addresses/ pour obtenir des informations sur ces instances.
    luminosite = MemoryMap.Instance.GetFloat(139, MemoryType.???)
    enrouler_store = MemoryMap.Instance.GetBit(70, MemoryType.???)
    derouler_store = MemoryMap.Instance.GetBit(71, MemoryType.???)

    Compléter chaque ??? du script par Input ou Output suivant que l'objet considéré est un capteur ou un actionneur.

  4. derouler_store.Value et enrouler_store.Value ne peuvent prendre que les valeurs booléennes True ou False.
    luminosite.Value est un flottant correspondant un nombre à virgule compris entre 0 et 10 :

    • 0 signifie une intensité lumineuse externe nulle : noir complet dehors.

    • 10 signifie une intensité lumineuse externe maximale : jour éclatant dehors.

    On considère qu'il fait suffisamment jour pour ourvir les stores lorsque luminosite.Value > 3.

    Rajouter dans la boucle while True la condition où il fait suffisamment jour pour ouvrir les stores.
    Pour cela, utiliser luminosite.Value, enrouler_store.Value et derouler_store.Value.

    Lorsque vous rajouter une condition indépendante de celles déjà écrites, ne pas l'insérer entre un if et un elif (ou un else ) pour ne pas casser le lien logique entre ces parties.

  5. Lorsqu'il fait suffisamment jour, on veut imposer l'extinction de la lumière 1 (sauf en cas où le bouton 1 est maintenu enfoncé).
    Rajouter une ligne de code dans la partie précédente du script pour forcer une telle extinction.

  6. Dans le script, rajouter la partie où on prend en compte une luminosité insuffisante où les stores doivent être automatiquement fermés.

  7. Tester le script réalisé.
    Pour cela vous pouvez faire avancer le temps de manière très accélérée en déplaçant le curseur :

Code de déblocage de la correction :

Dans les exercices qui suivent, vous aurez à reprendre et modifier des lignes de codes de sorte d'aider à résoudre ce problème concret :
Ce week-end toute la famille habitant la maison part voir des amis de vendredi soir à dimanche soir, comment gérer leur absence pendant ces 2 jours ?

Dans cet exercice, vous allez assurer la sécurité de la maison en gérant la détection d'une éventuelle intrusion dans la pièce E.

    1. Mettre en mode bleu les détecteurs d'ouverture de porte et de mouvement de la pièce E.

    2. Mettre en mode bleu la sirène extérieure se trouvant sur un mur proche de la porte du garage :

  1. Reprendre le fichier .py précédent et l'enregistrer sous un nouveau nom.
    Dans ce fichier, modifier les lignes 17 et 19 (et si possible les commentaires liés) de sorte de considérer à la place des lumière 1 et 2 du garage, les capteurs suivants :

    • Le détecteur d'ouverture de la porte 1, sachant que 78 est son numéro.

      La valeur de l'attribut Value de ce variable gérant de détecteur est True lorsque la porte 1 est fermée et False en cas d'ouverture.

    • Le détecteur d'ouverture de la porte 2, sachant que 79 est son numéro.

    • Le détecteur de mouvement dans la pièce E, sachant que 80 est son numéro.

    Vous pouvez rajouter des affichages afin de vérifier l'état booléen de chacun de ces capteurs.

  2. Créer une variable qui gère l'état de la sirène de la pièce E sachant que cet actionneur a pour numéro 58.

  3. Adapter le script afin que l'appui sur la touche 1 de la télécommande permette d'allumer la sirène de la pièce E tandis que l'appui sur la touche 2 de la télécommande permette d'éteindre cette sirène.

  4. Adapter le script afin que l'ouverture d'une porte de la pièce E ou la détection d'un mouvement conduise à la mise en son de la sirène et que le bouton 2 permette d'y mettre fin une fois toutes les portes refermées et plus aucune présence détectée.

  5. Tester le script modifié.

    Si vous êtes reparti d'un script précédent, l'appui sur la touche Q permet de quitter l'exécution du script.
    De plus, l'appui sur le bouton 1 de la télécommande doit permettre d'éteindre la sirène.

  6. Faire en sorte que la sirène exterieure soit aussi activée dans le cas d'une intrusion détectée. Cette sirène s'est vue attribuée le numéro 192.

  7. Afin que la famille ait le temps de quitter la pièce lors de l'activation de l'alarme lors de leur départ, rajouter une attente de 10 secondes.

    Importer en début de code la bibliothèque time.
    L'instruction time.sleep(1) permet faire une pause de 1 seconde dans le programme.

Code de déblocage de la correction :

Dans cet exercice, vous allez gérer la température de la maison lors d'une journée hivernale.

  1. Commencer par placer en mode bleu à la fois tous les radiateurs de la maison ainsi que les thermostats.
    Il y a en dans les pièces A, D, E, F, G (2 radiateurs), H, I, J, K, L, M et à l'étage N.
    Ne pas oublier d'allumer les thermostats en cliquant sur l'icône démarrer de chacun d'eux :

    Vous pouvez vérifier que tous les dispositifs de chauffage sont positionnés en mode bleu si dans la console, que vous atteignez en cliquant sur l'icône rectangulaire , la liste de l'onglet CHAUFFAGE - DISPOSITIFS est vide :

  2. Déplacer le curseur Min et Max permettant de gérer la température minimale et maximale de la journée afin de mettre la température minimale à 8°C et celle maximale à 20°C :

  3. Télécharger ce script Python, puis l'enregistrer dans le même répertoire que celui vos scripts précédents, dossier qui doit contenir le fichier EngineIO64.dll.

  4. Exécuter le script incomplet et comparer les affichages obtenus (sans prendre en compte pour l'instant le message d'erreur) avec les données temporelles apparaissant sur la simulation HomeIO afin de comprendre quel code permet d'obtenir l'heure de la simulation (Bien lire les lignes 24 à 30).
    En déduire comment compléter la ligne 36 du script.
    Lire aussi les lignes 15 à 22 pour comprendre comment sont gérer certains éléments de la maison virtuelle.

  5. Compléter les lignes 38 à 44 du script de sorte que :

    • Entre 6 heure et 22 heure, le radiateur de la pièce G2 est allumé si la mesurée dans la pièce n'atteint pas 18°C et est éteint sinon.

    • Avant 6 heure et après 22 heure, le radiateur de la pièce G2 est allumé si la mesurée dans la pièce n'atteint pas 15°C et est éteint sinon.

  6. Tester le programme en accélérant la simulation soit en déplaçant le curseur de l'horaire, soit en cliquant une ou plusieurs fois sur les derniers chevrons présents à droite de l'horaire :

  7. Faire en sorte de gérer les autres radiateurs de la maison pour qu'ils fonctionnent de la même manière : 15 °C visée la nuit et 18°C le jour.

    Voici un tableau associant à chaque pièce disposant d'un radiateur le numéro du capteur mesurant la température de la pièce, (le numéro pour la température attribuée (non utilisée pour l'instant)), le numéro attribué au radiateur de la pièce (pour la pièce G seule le radiateur 1 est donné puisque le radiateur 2 a déjà été pris en compte) :

    Pièce

    numéro capteur température pièce

    numéro température visée pièce

    numéro radiateur pièce

    D

    13

    14

    42

    E

    25

    26

    57

    G

    46

    47

    86

    H

    58

    59

    100

    I

    69

    70

    112

    J

    81

    82

    125

    K

    92

    93

    136

    L

    104

    105

    149

    M

    116

    117

    162

    N

    128

    129

    177

  8. Vérifier que passer la température gérée à 18°C le jour et 15°C la nuit vers une température constante de 20°C conduit une augmentation d'environ 70% de la consommation d'énergie. On voit bien ainsi l'importance de réduire la température d'un logement pour réduire la consommation énergétique !

Code de déblocage de la correction :

Home IO avec Scratch

2.2.1. Installations

Pour les TP des séances suivantes vous allez avoir besoin de télécharger trois logiciels :

Installation de Home I/O

Veuillez télécharger ce document et suivre la procédure d'installation.

Installation de Scratch2

Veuillez installer Scratch2 à partir de ce lien.

Installation de Foxit reader

Veuillez installer Scratch2 à partir de ce lien.

2.2.2. TP sur Home I/O avec Scratch

Première séance : découverte de HOME I/O et premiers programmes

Télécharger le document pdf suivant.
Vous y trouverez l'ensemble des questions à répondre.
Compléter le document au fur et à mesure sur Foxit Reader et réaliser les programmes demandés.

Pensez à sauvegarder vos différents programes dans un même répertoire avec un nom en lien avec la question afin de pouvoir y réaccéder si besoin pour d'autres questions.

Deuxième séance sur Home IO avec Scratch

Vous allez poursuivre le travail précédent pour gérer désormais les problèmes suivants :

Pour cela, vous allez :

Arduino

Présentation

Voici un document qui présente Arduino.

Premier TP

Voici la fiche correspondant au premier TP sur Arduino à effectuer.

Vous aurez besoin de ce programme en lanage Python.

Création d'un jeu sur téléphone portable

Présentations

L'objectif de cette partie est de réaliser grâce à la plateforme App Inventor développée par le MIT (Massachussetts Institute of Technology) le jeu du morpion sous forme d'une application fonctionnant sur téléphone portable.

Cette application comportera deux écrans successifs dans sa version de base :

Dans la version de base, la gestion de la victoire ou non d'un des joueurs n'est pas prise en compte.
Une version plus poussée, proposée en fin de partie, le fera.

  1. Créer un compte gmail de travail du type SNTnomprenom@gmail.com.

    Attention ! L'entreprise Google se donne le droit d'enregistrer et de lire les messages envoyés et reçus depuis une adresse gmail. Pour protéger votre vie privée, n'utilisez pas cette adresse créée SNTnomprenom@gmail.com pour communiquer par mail, mais seulement pour pouvoir utiliser ici la plateforme App Inventir !

  2. Muni.e de cette adresse SNTnomprenom@gmail.com, se connecter au site appinventor.mit.edu.

  3. Cliquer sur l'icône en haut à droite.
    Une novelle page apparaît pour se connecter à l'aide du compte SNTnomprenom@gmail.com.

  4. Cliquer sur l'icône en haut à droite.
    Appler ce projet morpion suivi de votre nom et prénom :

Maintenant que vous avez accéder à la plateforme, découvrons l'interface qui va vous permettre de créer une application de jeu.

Voici un résumé visuel des différentes zones de la plateforme :

Pour découvrir quelques premières fonctionnalités de cette plateforme, vous pouvez regarder cette vidéo :

Premier écran du jeu

Commençons par gérer le visuel du premier écran du jeu.

Les différents exercices qui suivent vont vous permettrent de créer progressivement le visuel du jeu.
Avec les deux exercices suivants, vous aboutirez à un visuel proche de l'image suivante :
Ces visuels sont avant tout une proposition. N'hésitez pas à adapter le visuel à vos envies et à votre esthétique personnelle. L'important est que vous vous fassiez plaisir en vous appropriant les visuels.

À la fin de chaque exercice une vidéo montre le travail à réaliser. N'hésitez pas à la visionner si besoin.

  1. Cliquer sur l'icône "Mes projets" puis dans le menu déroulant sur "Mes projets" :
    Cliquer ensuite sur le projet nommé morpion_votrenom_votre_prenom pour le lancer.

  2. L'objectif de cet exercice est de réaliser le début de l'écran d'accueil du jeu pour obtenir un visuel proche de celui-ci :
    Vos aurez pour cela besoin de télécharger et de placer dans un de vos répertoires de travil en SNT l'image suivante :

  3. Gestion du titre de l'application :

    1. Glisser déposer un Label sur l'interface, label qui servira de titre.

    2. Dans la partie de droite "Propriétés", réaliser les actions suivantes :

    3. Renommer ce label sous le nom de Titre.

    4. Le mettre en gras.

    5. Lui donner une taille de police de 20 pixels.

    6. Lui donner la largeur de l'écran en choisissant dans "Largeur" "Remplir parent...".

    7. Saisir comme texte : Jeu du morpion.

    8. Centrer ce texte.

  4. Gestion de l'affichage de la règle du jeu.

    1. Glisser en-dessous du titre un nouveau label.

    2. Le renommer règle mettre en italique, de taille de police 18, de hauteur 25 pixels, de largeur tout l'écran, de couleur gris foncé et centré.

    3. Saisir comme texte explicatif de la règle du jeu : BUT : aligner des carrés rouges ou bleus.

  5. Gestion de l'image du jeu, image que l'on veut centrée.

    1. Par défaut, toutes les images sont collées à gauche de l'écran.
      Pour centrer l'image, on va devoir la disposer dans un conteneur dans lequel on peut choisir la disposition.
      Pour cela, dans la partie "Palette", cliquer sur l'élément "Disposition".
      Glisser en dessous de la règle le conteneur "Arrangement horizontal".

    2. Dans la partie "Propriétés", choisir un alignement horizontal, aucune couleur de fondet une hauteur de 100 pixels.

    3. Dans la partie "Palette", revenir sur "Interface utilisateur" et glisser déposer dans le conteneur précédent une Image.
      Cette Image n'est liée pour l'instant à aucune image réelle.

    4. Pour lier cette image à une image réelle, cliquer dans la partie "Média" sur "Charger fichier...".
      Naviguer dans l'arborescence de vos répertoires pour sélectionner le fichier image téléchargée ici.

    5. Cliquer sur l'image au cnetre du conteneur.
      Dans "Propriétés", sélectionner dans "Image" le nom du fichier image chargé, normalement app_morpion_vue.png.

    6. Dimensionner l'image à 100 pixels de hauteur et de largeur.

  6. Voilà le visuel auquel vous devez avoir abouti :

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Dans cet exercice vous aller réaliser la partie inférieure du visuel de l'écran d'accueil du jeu :

Plutôt que de mettre des croix et des ronds, ce qui obligerait à importer deux telles images, nous avons préféré mettre deux couleurs différentes : cela permet de simplifier du codage du jeu.
De plus, nous avons pris des couleurs simples, rouge et bleu, si vous préférez d'autres couleurs, faites-vous plaisir. Vous pourrez adapter l'ensemble des travaux suivant à réaliser aux deux couleurs unies que vous aurez choisies.

Si vous choisissez deux autres couleurs, n'hésitez pas à modifier le texte explicant la règle du jeu déjà réalisé lors de l'exercice précédent.

  1. En-dessous de la zone où vous avez centré une image dans l'exercice précédent, rajouter un label.
    Ce label sera renommé consigne, aura une taille de police de 20 pixels, une hauteur de 50 pixels et comme largeur celle du parent ; ce label sera centré.

  2. Le texte de ce label sera Cliquer ci-dessous\n sur la couleur choisie.

    Les caractères \n ne seront pas visibles sur l'écran ; ils imposent seulement un retour à la ligne après le mot ci-dessous.
    Pour comprendre le rôle de ces deux caractères juxtaposés, n'hésitez pas à comparer l'affichage du texte avec et \n.

  3. En-dessous, vous devez créer un conteneur pour stocker horizontalement les deux boutons colorés.
    Pour cela, aller dans "Disposition" et glisser "Arrangement horizontal" dans l'interface.
    Choisir dans "Propriétés", une hauteur de 160 pixels, une largeur maximale (celle du parent) et un centrage horizontal.

  4. En cliquant sur "Interface utilisateur", glisser un "bouton" dans le conteneur fait précédemment.
    Dans "Composants", renommer ce bouton Bouton_rouge.
    Dans "Propriétés", choisir comme couleur de fond celle Rouge, laisser "activé" coché, donner comme hauteur celle du parent et comme largeur "50 percent" : ainsi, le bouton prendra 50% de la largeur du conteneur.
    De plus, supprimer le texte par défaut lié au bouton.

  5. Faire de même pour rajouter dans le conteneur un second bouton, de couleur bleue, occupant la moitié du conteneur en largeur.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Deuxième écran du jeu

L'objectif de cette partie est de réaliser le visuel du second écran proche de cette image :

L'objectif de cet exercice est de réaliser la partie supérieure du seconde écran : le titre et la zone de jeu :

  1. Cliquer sur le bouton .
    Nommer jeu ce nouvel écran :
    Automatiquement, l'interface doit basculer vers le nouvel écran et vous devez voir apparaître en haut à gauche l'onglet

  2. Comme fin dans l'exercice sur le visuel supérieur du premier écran, rajouter dans l'interface de ce nouvel écran le titre Jeu du morpion en gras, de taille de police 20 pixels, de largeur maximale et centré.

  3. Depuis le menu "Disposition", glisser dans l'interface un "Arrangement tableau" qui servira de zone de jeu du morpion.
    Il faut donc régler dans "Propriétés" 3 colonnes et 3 lignes. Vous pouvez imposer une hauteur de 320 pixels et une largeur de 320 pixels.

  4. Ce tableau nouvellement créer va pouvoir contenir 9 boutons : un par case.

    Glisser dans la case supérieure gauche de ce tableau un bouton.
    Afin de faciliter la différenciation de chaque bouton, renommer ce bouton Bouton11, pour bouton sur la la ligne 1 et sur la colonne 1.
    Imposer une hauteur et une largeur de 100 pixels et ôter le texte lié par défaut au bouton.

    Dans "Propriétés", imposer aussi une couleur à ce bouton. Cette couleur permettra de savoir qu'aucun joueur n'a encore cliqué sur la case.
    Dans la suite, nous prendrons comme couleur de case "gris clair".

  5. Faire de même sur les 8 autres boutons de la zone de jeu.
    Lors du renommage, nommer boutonij le bouton se trouvant en ligne $i$ et en colonne $j$. Par exemple, le bouton de la ligne 2 et et de la colonne 3 doit se nommer pour la suite bouton23.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Maintenant que la zone principale du jeu est réalisée au niveau visuel, il ne reste plus que gérer le zone inférieure.

Dans cet exercice, vous réaliserez la zone inférieure du second écran.

  1. Rajouter en dessous de la zone aux 9 cases du morpion un "Arrangement horizontal", de hauteur 45 pixels et centrer horizontalement et sans couleur de fond.

  2. Rajouter dans le conteneur précédemment créé, un bouton qui vous nommerez recommencer, affichant ce texte recommencer, de hauteur maximale et de largueur 31%, de taille de police 14 pixels, le texte étant centré.
    Pour visualiser ce bouton, choisir une couleur différente de celles déjà utilisées, le jaune par exemple, vous pouvez aussi choisir une forme arrondie.

  3. Rajouter à droite du bouton précédent une zone de texte.
    Faire en sorte que cette zone soit nommé qui_joue, de taille de police 25, le texte centré, que sa largeur prenne 68% du conteneur et sa hauteur soit maximale.

    Le contenu du texte peut être supprimé car il sera géré par codage et non directement dans "Propriétés" : ce texte permettra d'informer quel joueur doit efffectuer son action.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Codage

Maintenant que le visuel de vos deux écrans est terminé, il reste à gérer les interactions entre ces écrans et les utilisateurs humains. Ces interactions homme/machine seront gérés grâce à un codage par blocs permis par la plateforme de MIT App Inventor, codage par blocs très proche dans l'esprit au codage que vous avez déjà rencontré avec Scratch au collège.

Pour accéder à la partie de la plateforme permettant de programmer par blocs, il suffit de cliquer sur le bouton en haut à droite .

Voici un visuel présentant succinctement la zone de codage :

La vidéo suivante présente cette zone de codage, des blocs utiles pour le projet et comment organiser ces blocs :

Pour chacun des exercices suivants, vous trouverez en fin d'exercice une image des blocs que vous devez construire ainsi qu'ensuite une vidéo détaillant le travail à faire.

Le but de cet exercice est de coder l'écran de départ nommé screen1 afin de mémoriser la couleur choisie par le premier joueur du morpion et d'automatiquement basculer vers l'écran principal jeu.

Pour cela, il faudra au cours des questions suivantes, construire un algorithme où on crée :

Pour réussir cela, il vous suffit de suivre les questions suivantes :

  1. Dans la partie "Blocs" à gauche, descendre jusqu'à la zone

  2. Cliquer sur l'onglet .
    Dans la partie Interface, un ensemble de blocs apparaît.
    Déplacer vers la zone blanche de droite de l'interface le bloc .

  3. En haut de la zone "Blocs", cliquer sur l'onglet "Contrôle" de .
    Dans la partie Interface, un ensemble de blocs apparaît.
    Descendre dans cet ensemble jusqu'au bloc et le glisser à l'intérieur du bloc déjà positionné dans l'interface.
    Vous devez obtenir un visuel comme celui-ci :

  4. screen1 est l'écran d'accueil, il faut faire basculer vers l'écran jeu.
    Changer le nom de l'écran en cliquant sur la flèche permettant d'avoir la liste des possibilités : .

  5. Il reste à rajouter comme "valeur de départ" la couleur choisie.
    Pour simplifier, cette valeur sera saisie comme la chaîne de caractères "rouge".

    Pour cela, cliquer sur l'onglet , Déplacer le bloc pour le coller à "valeur de départ" et y saisir le mot rouge.

  6. Faire la même chose que précédemment pour créer un gros bloc gérant le cas où le joueur clique sur la zone bleue.

    Pour aller plus vite, vous pouvez "dupliquer" le bloc déjà réalisé :
    Après un clic droit sur le bloc externe, apparaît .
    Cliquer sur dupliquer puis modifier le nouveau bloc en changeant tous les "rouge" en "bleu".

Vous devez aboutir à la fin de cet exercice aux deux blocs suivant :

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de créer deux variables globales liées au second écran jeu :

  1. Basculer sur le second écran jeu : .

  2. Cliquer dans l'onglet .
    Glisser le bloc dans l'interface et nommer la nouvelle variable globale couleur_joueur1.

  3. Dans l'onglet "contrôle", aller cherche le bloc , onglet que vous collerait à la suite du bloc de la question précédente.
    Ainsi, la variable couleur_joueur1 vaut "rouge" si le premier joueur a cliqué sur le bouton rouge et "bleu" sinon.

  4. De même, glisser un bloc créant la variable globale nommée coup.

  5. Comme cette valeur vaut 0 ou 1 suivant le choix du premier joueur, vous devez lier un bloc permettant une alternative conditionnelle .

  6. La condition de ce bloc revient à comparer la "valeur de départ" renvoyé par l'écran d'accueil (qui est "rouge ou "bleu") avec la chaîne de caractères "rouge".
    Dans le cas où ces "textes sont égaux", la variable coup doit prendre la valeur 0, dans l'autre cas, cette variable doit prendre la valeur 1.
    En utilisant entre autre les blocs suivants, finaliser le bloc initialisation la varaible coup :

    • de l'onglet "Texte",

    • de l'onglet "Texte",

    • de l'onglet "Math".

Vous devez aboutir à la fin de cet exercice aux deux blocs suivant :

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de gérer le bouton recommencer qui permet de revenir à l'écran initial screen1.

En vous inspirant du code réalisé lors de cet exercice, créer un bloc qui permet de revenir à l'écran d'accueil screen1 lorsqu'un joueur appuie sur la touche recommencer.

Ici, aucune valeur de départ n'est nécessaire pour gérer la page d'accueil. Vous pouvez choisir un bloc plus réduit celui utilisé pour passer de l'écran screen1 à celui jeu.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de créer des éléments qui permettront de gérer la zone d'affichage pour savoir quel joueur doit jouer.

Pour cela vous allez créer dans cet exercice deux procédures, c'est-à-dire deux sous-programmes qui effectuent une action sans renvoyer de valeur, procédures qui seront appelées plus tard pour savoir quel texte affiché et sous quelle forme.

  1. Glisser le bloc et le nommer cette première procédure afficher_joueur_rouge.

  2. Le label qui a été créé pour faire apparaître le texte donnant le tour du joueur est nommé qui_joue.

    Pour pouvoir modifier cet élément par codage par blocs, cliquer sur son onglet .
    Apparaît alors un ensemble de blocs possibles. Parmi ceux-ci, vous aurez besoin pour cette première procédure de :

    • qui permet de modifier le texte en y ajoutant un texte particulier.

    • qui permet de modifier la couleur du fond sur lequel s'inscrit le texte en y ajoutant une couleur particulière.

    Sachant que les couleurs sont accessibles depuis l'onglet et qu'un texte se rajoute avec le bloc , placer à l'intérieur du bloc procédure précédent deux lignes de blocs de code, lignes qui permettent de

    • mettre comme couleur de fond du rouge dans la zone qui_joue,

    • mettre comme texte "Tour au joueur rouge" dans la zone qui_joue.

  3. Faire de même dans une seconde procédure nommée afficher_joueur_bleu qui permet de :

    • mettre comme couleur de fond du bleu dans la zone qui_joue,

    • mettre comme texte "Tour au joueur bleu" dans la zone qui_joue.

    • mettre comme couleur de texte du blanc afin de rendre le texte lisible.

    Il existe un bloc .

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de gérer l'initialisation de l'écran principal jeu lors de son lancement.
Grâce aux variables et aux préocédures précédentes, vous allez réussir à réaliser cette initialisation.

Pour cela, il vous faudra d'abord trouver dans l'onglet le bloc

Dans cet onglet, vous devrez insérer des blocs de sorte que si le premier joueur a choisi la couleur "rouge" alors il y a un appel à la procédure afficher_joueur_rouge et sinon un appel à la procédure afficher_joueur_bleu.

  • Pour appeler une procédure, il suffit d'utiliser le bloc

  • Pour gérer la condition, vous pouvez :

    • soit utiliser directement la variable globale coup avec un test d'égalité de deux nombres entiers ,

    • soit utiliser une comparaison de textes comme fait à l'exercice créant la variable coup.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de gérer le bouton Bouton11.

Le but est que si un joueur clique à son tour de jeu sur la case Bouton11 du morpion, il faut savoir si la case a déjà été choisie ou non, non dans le cas où la couleur de la case est encore "gris clair".
Dans le cas où cette case est encore non choisie, cette case doit être colorée de la couleur du joueur puis l'affichage doit indiquer que le joueur suivant doit jouer.
Deux cas alors :

De plus, dans chacun des deux cas précédents, la variable globale coup augmente de 1 (pour signifier que l'on passe ensuite au joueur suivant).

Pour coder par blocs les instructions précédemment décrites, vous aurez besoin des blocs suivant :

Réaliser avec entre autre les blocs ci-dessus, le code permettant de gérer le Bouton11.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Le but de cet exercice est de gérer les 8 autres boutons.

Dupliquer le code de l'exercice précédent et l'adapter pour coder les 8 autres boutons.

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Exportation

Maintenant que vous avez créé l'application de jeu pour téléphone, il ne vous rest eplus qu'à la transférer sur votre téléphone portable, ou celui d'un de vos proches.

  1. Premièrement, vous pouvez choisir le nom que portera votre application.
    Par défaut, elle portera la nom de votre fichier, soit morpion_nom_prenom.
    Comme ce nom peut vous disconvenir, vous pouvez le changer en revenant à l'écran de demarrage screen1, cliquer sur le composant "screen1" pour dans "Propriétés" changer le contenu de "AppName" : .
    Renommer votre application à votre guise.

  2. Deuxièmement, vous pouvez aussi intégrer une image comme icône pour votre application.
    Pour cela, cliquer dans la partie "Propriétés" sur le contenu de l'entrée "Icône" ; vous pouvez alors soit prendre comme icône l'image déjà importée, soit charger depuis votre ordinateur toute image libre de droit qui vous plaît, sans dévoiler toutefois de données personnelles.
    Enregistrer ces modifications pour leur bonne prise en compte.

  3. La principale chose restant à faire est de transformer votre programme en un fichier de format apk, format qui des applications fonctionnant sous Android.

    Pour cela, cliquer sur le menu "construire" puis sur l'onglet "Android App (.apk)" : .
    Une barre d'avancement de la construction du fichier .apk apparaît alors :

  4. Une fois la construction terminée, vous verrez apparaître un écran comme celui-ci : .
    Vous pouvez ainsi :

    • soit avec le lien de gauche télécharger directement le fichier de format .apk pour l'envoyer par exemple à des proches,

    • soit l'installer directement sur un téléphone portable en flashant le code QR de droite.

    • Le code QR a une durée de vie limitée à 2 heures. Passé ce déali, il vous faudra recommencer la construction du fichier .apk pour obtenir un nouveau code QR.

    • De plus, il est possible que pour pouvoir installer cette application maison, vous ayez à modifier certains propriétés du téléphone portable, propriétés permettant d'installer des applications non marchandes.

  5. Amusez-vous avec un.e ami.e sur ce jeu pour tester son bon fonctionnement !

Vous pouvez trouver dans la vidéo suivante la réalisation du travail demandé dans l'exercice précédent :

Prolongements possibles

Le jeu du morpion tel que programmé précédemment fonctionne très bien.
Cependant, il est possible d'apporter des améliorations, par exemple :

  1. Créer un nouvel écran nommé victoire.

  2. Intégrer un texte où s'affichera la couleur du joueur vainqueur (le contenu sera géré plus tard par codage).

  3. Intégrer une image libre de droit symbolisant pour vous la victoire.

  4. Intégrer un bouton permettant de revenir à l'écran de démarrage.

  5. Créer dans l'écran jeu, une nouvelle procédure est_victorieux qui analyse si un alignement existe et dans ce cas bascule l'application sur l'écran victoire avec comme valeur de départ la couleur du joueur gagnant.

  6. Modifier le code du bouton Bouton11 afin de rajouter la procédure est_victorieux.

  7. Modifier les autres boutons de case similairement.

  8. Gérer le texte de cet écran victoire afin qu'apparaisse clairement la couleur du joueur gagnant.

  9. Rajouter le code gérant le bouton de retour vers l'écran screen1, écran d'accueil du jeu.

  10. Construire le fichier .apk lié à votre application améliorée pour tester les améliorations apportées.

  1. Créer une procédure afficher_match_nul qui modifie le texte qui_joue pour y faire appraître le texte "Match nul !" avec une couleur de votre choix.

  2. Modifier le bloc qui gère le clic sur le bouton Bouton11 en rajoutant une condition utilisant les variables globales couleur_joueur1 et coup, condition qui permet de savoir lorsque toutes les cases sont colorées.
    Intégrer cette condition dans un test conditionnel pour appeler la procédure afficher_match_nul dans le cas où la condition est remplie.

  3. Modifier similairement les 8 autres boutons.

  4. Construire le fichier .apk lié à votre application améliorée pour tester les améliorations apportées.

Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International