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 : Valider

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.

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.

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 ?

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

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) ?

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 :

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 ?

Proposer une trace écrite de la séance :

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.

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.

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 :

• pastille rouge : interaction directement par appui sur les boutons dans la maison comme dans la vie usuelle.

• pastille verte : interaction avec la console de programmation intégrée directement dans Home IO.
  Cette console est accessible avec l'icône .

• pastille bleue : interaction avec un programme extérieur à Home IO.
  C'est le mode à utiliser pour que le code python intéragisse avec les capteurs et actionneurs de la maison.

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.

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 ?

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 :

• d'utiliser la librairie keyboard qui permet avec la fonction is_pressed('nom_touche') de savoir si la touche considérée est appuyée.

• d'utiliser l'instruction break qui permet de quitter la boucle while dans laquelle elle est placée.

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.

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é.

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 :

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_votreprenom pour le lancer.

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 :

2. Gestion du titre de l'application :

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

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

   2. Renommer ce label sous le nom de Titre.

   3. Le mettre en gras.

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

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

   6. Saisir comme texte : Jeu du morpion.

   7. Centrer ce texte.

3. 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.

4. 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.

Voilà le visuel auquel vous devez avoir abouti :

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

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.

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.

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

• La zone inférieure gauche sera un bouton permettant de revenir à l'écran d'accueil, pour recommencer une partie.

• La zone inférieure gauche indiquera quel joueur rouge ou bleu doit jouer. Cette zone sera gérée ultérieurment par du code.

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.

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 :

• un bloc qui fait si on clique sur le rouge, fais basculer sur l'écran jeu en mémorisant le fait d'avoir cliqué sur "Rouge"

• un bloc similaire pour un clic sur le bleu.

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 :

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

• couleur_joueur1 qui permet de mémoriser tout au long du jeu la couleur choisie par le premier joueur du morpion.
  Cette couleur est la "valeur de départ" renvoyée par les blocs créés à l'exercice précédent sur l'écran screen1.

• coup qui stocke le nombre de coup déjà joué en partant de 0 si le premier joueur a choisi "rouge" mais 1 si ce premier joueur a choisi la couleur "bleu".
  Ainsi, un nombre pair dans coup signifie que le joueur jouant avec la couleur "rouge" doit jouer tandis qu'un nombre impair stocké dans coup indique que le joueur jouant avec la couleur "bleu" doit jouer.

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 :

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.

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 .

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.