Architectures matérielles et Systèmes d'exploitation

I- Circuits logiques

Les booléens

Les booléens

1 - Vrai ou Faux ?
Regarder cette vidéo en introduction :
L'agèbre de Boole permet de traiter des raisonnements logiques comme des opérateurs mathématiques.
Une variable booléenne est soit vraie soit fausse.
Par défaut, on code le "vrai" par 1 et le "faux" par 0 (mais rien n'empêche de choisir l'inverse).
2 - Les opérateurs booléens
"Je te paierai ton permis si tu as la moyenne en maths et que tu arrêtes de laisser traiter tes vêtements dans toute la maison"
Cette phrase contient 3 propositions :
  • A : "Je te paierai ton permis"
  • B : "Tu as la moyenne en maths"
  • C : "Tu arrêtes de laisser trainer tes vêtements dans toute la maison"
La proposition A n'est vraie que si les propositions B et C le sont également
Les opérateurs booléens correspondent aux relations qui doivent exister entre différentes propositions pour qu'une autre proposition soit vérifiée ou non.
Il en existe 3 : "et", "ou", "non" ("and", "or", "not") qu'il est possible de combiner à l'aide de parenthèses.
On dispose d'un récipient contenant des billes de toutes les couleurs, translucides ou opaques.
  • On souhaite programmer un automate qui ne récupérera que les billes translucides rouges. Pour cela la variable ACCEPTABLE est définie. Le programme serait :
    ACCEPTABLE = TRANSLUCIDE ET ROUGE
  • Si ce robot doit maintenant enlever l'ensemble des billes opaques et des billes bleues, on modifiera le programme en :
    ACCEPTABLE = (NON TRANSLUCIDE) OU BLEUE
  • Dans l'exemple ci-dessus, vous remarquez la présence des parenthèses pour indiquer que l'opérateur NON ne s'applique qu'à translucide et pas NON (TRANSLUCIDE OU BLEUE).
    Quelles seraient les billes ramassées dans ce cas ?
    3 - Table de vérité
    La table de vérité récapitule les résultats différents d'une opération booléenne en fonction des valeurs des variables d'entrée.
    Opérateur "and"
    C = A and B
    A
    01
    B000
    101
    Opérateur "or"
    C = A or B
    A
    01
    B001
    111
    Opérateur "xor"
    C = A xor B
    A
    01
    B001
    110
    L'opérateur ou exclusif (xor) est souvent utilisé en logique mais il est construit à partir des 3 opérateurs de base : C = A xor B = ( A and ( not B ) ) or ( ( not A ) and B )
    Les circuits informatiques ne sont que assemblages de portes logiques, des dispositifs électroniques ayant pour but de fonctionner comme un opérateur logique.
    Une addition en binaire peut se réaliser à l'aide de portes logiques.

    Afficher Portes logiques

    Cacher Portes logiques

    1) Le transistor
    Inventé en 1947 par les Américains John Bardeen, William Shockley et Walter Brattain, le transistor est le composant fondamental de tout ordinateur moderne.
    Les ordinateurs plus anciens fonctionnaient à l'aide d'autres dispositifs, appelés tubes à vide, ou "lampes" (on en retrouve encore dans certains ampli audio pour leur manière particulière d'amplifier une signal analogique), mais ils consommaient beaucoup plus d'énergie, étaient moins fiables et bien moins rapides.

    Tube à vide

    Réplique du premier transistor
    Alcatel-Lucent©

    Transistor pour montages électroniques courants
    Les transistors sont de plus nettement plus simples à réduire et grâce à eux des ordinateurs tenant dans une grande salle ont vu leur taille réduire, tout en permettant d'augmenter leur vitesse de façon exponentielle

    L'ENIAC en 1953

    Intel8086 (1978)
    29000 transistors en 3µm

    Apple M1 (2020)
    16 milliards de transistors en 5nm

    Qu'est-ce qu'un transistor ?
    Dans le cadre de son utilisation en informatique, c'est essentiellement un interrupteur capable de laisser passer le courant en fonction d'un signal électrique.

    Schéma d'un transistor :
    La tension de référence est reliée au collecteur, et on peut lire le signal aux bornes de la résistance située entre la base et la masse. Si une tension suffisante est appliquée à l'émetteur, le transistor laisse passer le courant et la tension de référence se retrouve au point B. Dans le cas contraire, le point B reste au potentiel de la masse, soit 0V.

    Ainsi un transistor peut opérer des 0 et des 1 qui correspondront au potentiel haut ou bas.
    2) porte logique
    En combinant des transistors de différentes façon, il est possible de construire des portes logiques. Ces systèmes vont afficher une (ou plusieurs) sortie.s à l'état haut ou bas en fonction de l'état de leurs entrées : on peut alors réaliser une opération booléenne (vois ci-dessus).

    "ET" logique

    "OU" logique

    "NON-ET" logique

    "NON-OU" logique

    "OU exclusif" logique
    3) Circuit logique
    Un circuit logique est un assemblage de portes logiques. Il est possible de réaliser n'importe quel circuit logique simplement à partir des portes NON-ET (ou NAND).
    A vous de jouer !
    Le site NANDgame vous propose de construire progressivement les différentes fonctions présentes dans un ordinateur. Il n'est pas nécessaire d'aller aussi loin : votre objectif est d'assembler progressivement les portes et fonctions logiques jusqu'à réussir à assembler un additionneur.

    Cliquez sur l'image pour aller sur le site

    II-Architecture de Von Neumann

    Afficher chapitre

    Cacher chapitre

    1) L'ordinateur
    Grâce à l'assemblage des portes logiques, il est possible de réaliser un ordinateur moderne, notamment ses 2 principaux composants : la mémoire et le microprocesseur.

    Un ordinateur type "Desktop"

    Un ordinateur type "Laptop"
    Tous les ordinateurs modernes (desktop, laptop, smartphones, consoles, ...) sont constitués des mêmes éléments :
    • Une carte mère sur laquelle sont assemblés ou branchés tous les autres composants. Son rôle est d'assurer leur communication
    • Une microprocesseur (ou CPU, pour Central Processing Unit) qui a la charge de réaliser les opérations. Ce microprocesseur peut être épaulé par d'autres coprocesseurs qui s'occuperont de calculs spécialisés (typiquement dans un ordinateur moderne, une carte graphique)
    • Des mémoires qui stockeront les données. Il en existe de plusieurs type, car plus la mémoire est rapide, plus elle est chère.
      • La mémoire cache est directement incluse dans la puce du microprocesseur. C'est la plus rapide en débit (plusieurs centaines à quelques milliers de Go/s) et en latence (temps de réponse). Très chère, elle n'est présente qu'en quantités limitées et sur 3 niveaux dans le CPU.
      • La mémoire vive ou RAM (random access memory). Bien moins rapide (quelques milliers de Go/s) mais beaucoup moins chère, se présente sous forme de "barettes" à clipser ou des puces directement soudées sur la carte-mère.
      • La mémoire de stockage. Encore plus lente (quelques Go/s) mais évidemment la moins chère. Utilisée pour accéder à des données qui ne travaillent pas, elle a l'avantage de ne pas s'effacer en cas de coupure d'électricité. Elle est contenue dans les disques durs ou sous la forme de puces elles aussi soudées à la carte mère.
    2) L'architecture de Von Neumann
    Les ordinateurs actuels fonctionnent tous selon le principe proposé en 1945 par le mathématicien John Von Neumann dans lequel les données et les instructions sont stockées dans la même mémoire.

    schéma architecture de Von Neumann
    Ce modèle comporte quatre type de composants :
    • une unité arithmétique et logique (ALU)
    • une unité de contrôle
    • la mémoire de l'ordinateur
    • les périphériques d'entrée-sortie.
    Ces quatre composants forment deux grands circuits :
    • le processeur (ou microprocesseur ou CPU) dans lequel on trouve l'unité de contrôle et l'ALU
    • la mémoire.
    Ces deux circuits sont reliés entre eux par des liaisons physiques (câbles ou circuits intégrés) qui constituent un ou plusieurs bus de communication, notamment un bus de données et un bus d'adresses.
    Enfin, pour communiquer avec d'autres parties de l'ordinateur (les périphériques), le CPU dispose de bus d'entrée/sortie.
    2) Initiation à l'assembleur
    On l'a déjà vu, un ordinateur ne peut lire que des informations en binaire, de plus les commandes qu'il peut executer sont très sommaires, en voilà quelques types :
    • Les instructions arithmétiques (addition, soustraction, multiplication, ...)
    • Les instructions de transfert de données.
      On demande à l'ordinateur d'aller chercher une donnée en mémoire pour la traiter ou pour la placer à une autre endroit dans la mémoire
    • Les instructions de rupture de séquence.
      En assembleur les instructions sont traitées les unes à la suite des autres. Si l'instruction actuelle est à la ligne 458, alors l'ordinateur execute celle présente à la ligne 459 immédiatement après une fois la ligne 458 traitée.
      Dans le cas d'une opération conditionnelle où 2 calculs A ou B doivent être réalisés en fonction des donnée, on utilisera une rupture de séquence pour dire à l'ordinateur d'effectuer la commande suivante (459) dans le cas A ou de sauter directement à une autre ligne (par exemple 612) dans le cas B.
      Dans le cas d'une boucle, la rupture de séquence renverra à une ligne déjà traitée précédemment.
    L'ensemble des instructions sont codées dans la mémoire en binaire : c'est le langage machine, et il a généralement cette forme :
    champ code opérationchamp code opérande
    En binaire cela prendra la forme d'une série de 0 et de 1, illisible pour nous.

    Pour cette raison, ce code peut être traduit en langage assembleur. Ce langage correspond exactement à ce qu'execute le processeur, il met simplement un nom et une valeur au code binaire présent dans la mémoire.
    Ainsi, si la commande addition correspond au code 00100110, l'assembleur se contentera d'afficher ADD à chaque fois qu'il lira "00100110" dans le code binaire du champ code opération.

    Ce langage, propre à chaque architecture de processeur est dite bas niveau : elle est la plus proche de ce qu'execute un microprocesseur et par conséquent la plus rapide. C'est également la plus difficile à maîtriser, raison pour laquelle on utilise souvent un compilateur qui est un programme qui se chargera de "traduire" un programme écrit dans un langage de plus haut niveau (comme les langages C/C++ [le python étant, comme le javascript un langage interprété donc de niveau encore plus haut]) directement en langage machine.
    L'assembleur est encore largement utilisé sur des puces simples ou des projets très spécifiques.
    Les opérandes désignent les données sur lesquelles le code opération de l'instruction doit être réalisée.
    Une opérande peut être de 3 natures différentes :
    • une valeur immédiate : l'opération est effectuée directement sur la valeur donnée dans l'opérande
    • un registre du CPU : l'opération est effectuée sur la valeur située dans un des registres (R0,R1, R2,...), l'opérande indique de quel registre il s'agit
    • une donnée située en mémoire vive : l'opération est effectuée sur la valeur située en mémoire vive à l'adresse XXXXX. Cette adresse est indiquée dans l'opérande.
    Voyons un exemple pas à pas d'un code assembleur : tiré du site "informatique lycée" de David Roche
    LDR R1,78
    Place la valeur stockée à l'adresse mémoire 78 dans le registre R1 (par souci de simplification, nous continuons à utiliser des adresses mémoire codées en base 10)
    STR R3,125
    Place la valeur stockée dans le registre R3 en mémoire vive à l'adresse 125
    ADD R1,R0,#128
    Additionne le nombre 128 (une valeur immédiate est identifiée grâce au symbole #) et la valeur stockée dans le registre R0, place le résultat dans le registre R1
    ADD R0,R1,R2
    Additionne la valeur stockée dans le registre R1 et la valeur stockée dans le registre R2, place le résultat dans le registre R0
    SUB R1,R0,#128
    Soustrait le nombre 128 de la valeur stockée dans le registre R0, place le résultat dans le registre R1
    SUB R0,R1,R2
    Soustrait la valeur stockée dans le registre R2 de la valeur stockée dans le registre R1, place le résultat dans le registre R0
    MOV R1, #23
    Place le nombre 23 dans le registre R1
    MOV R0, R3
    Place la valeur stockée dans le registre R3 dans le registre R0
    B 45
    Nous avons une structure de rupture de séquence, la prochaine instruction à exécuter se situe en mémoire vive à l'adresse 45
    CMP R0, #23
    Compare la valeur stockée dans le registre R0 et le nombre 23. Cette instruction CMP doit précéder une instruction de branchement conditionnel BEQ, BNE, BGT, BLT (voir ci-dessous)
    CMP R0, R1
    Compare la valeur stockée dans le registre R0 et la valeur stockée dans le registre R1.
    CMP R0, #23
    BEQ 78
    La prochaine instruction à exécuter se situe à l'adresse mémoire 78 si la valeur stockée dans le registre R0 est égale à 23
    CMP R0, #23
    BNE 78
    La prochaine instruction à exécuter se situe à l'adresse mémoire 78 si la valeur stockée dans le registre R0 n'est pas égale à 23
    CMP R0, #23
    BGT 78
    La prochaine instruction à exécuter se situe à l'adresse mémoire 78 si la valeur stockée dans le registre R0 est plus grand que 23
    CMP R0, #23
    BLT 78
    La prochaine instruction à exécuter se situe à l'adresse mémoire 78 si la valeur stockée dans le registre R0 est plus petit que 23
    HALT
    Arrête l'exécution du programme

    III- Les protocoles TCP et IP

    Affiche protocoles

    Cacher protocoles

    1) Présentation

    un réseau de 2 ordinateurs
    Deux ordinateurs sont mis en réseau à partir du moment où il existe un moyen pour qu'ils communiquent entre eux.
    Cela correspond généralement à la mise en place d'un câble ethernet ou d'une liaison wifi, mais d'autres modes sont possibles (IR, bluetooth, ...)
    Une introduction à ces notions a déjà été vue en SNT → Cliquez ici pour vous rafraîchir la mémoire.

    2) Adresses IP

    Un adresse IP prend comme toujours en informatique la forme d'un nombre binaire. Pour des questions de lisibilité, celle-ci est généralement traduite en notation décimale ou hexadécimale.
    • L'IPv4 s'écrit sur 32 bits, que l'on représente sous la forme de 4 octets séparés par un point.
      l'adresse 192.168.0.13 correspond en fait à 11000000.10101000.00000000.00001101
    • L'IPv6 s'écrit sur 128 bits, mais on va la représenter sous la forme de 8 groupes de 2 octets en notation hexadécimale.
      l'adresse 2001:0db8:0000:85a3:0000:0000:ac1f:8001 mais qui peut à son tour être simplifiée en supprimant les 0 non significatifs 2001:db8:0:85a3:0:0:ac1f:8001 ou même en supprimant les blocs nuls consécutifs 2001:db8:0:85a3::ac1f:8001
    En IPv4 et au sein d'un même réseau, les machines partagent une partie de leur adresse IP :
    configuration d'un réseau domestique
    Dans le réseau domestique ci-dessus, on voit que chaque machine s'est vue attribuer une adresse en 192.168.1.x.
    Ce réseau est donc identifié par les 3 premiers octets tandis que le dernier octet identifie la machine dans le réseau.
    Dans des réseaux plus grands (ex : le lycée) où le nombre de machines peut dépasser 28=256, on peut utiliser les deux ou trois derniers octets pour identifier la machine.
    Comment savoir dès lors si 192.168.1.24 et 192.168.2.36 sont sur deux réseaux différents (cas du domicile) ou sur un seul (cas du lycée) ?
    Vous verrez dans ce cas un "/" suivi de 8,16 ou 24, ces 3 derniers nombres représentant le nombre de bits codant la machine (le reste permettant d'identifier le réseau).
    Ainsi, dans un réseau domestique on aura 192.168.1.24/24 et 192.168.2.36/24 seront sur 2 sous-réseaux différents et ne pourront communiquer directement entre eux, alors qu'avec 192.168.1.24/16 et 192.168.2.36/16 les 2 machines seront sur le même réseau et pourront communiquer directement.
    Si une machine a une adresse en 192.168.36.37/28 cela signifie 2 choses :
    • son adresse binaire est 11000000.10101000.00100100.00100101
    • les 28 premiers bits correspondent à l'adresse réseau et seuls les 4 derniers bits codent la partie machine
    on en déduit donc que toutes les adresses appartenant au même sous-reseau que cette machine vont de 11000000.10101000.00100100.00100000 (adresse de réseau) à 11000000.10101000.00100100.00101111 (adresse de diffusion), soit de 192.168.36.32 à 192.168.36.47
    Trouvez l'adresse générique des réseaux suivants
    1. 174.34.28.1/8
    2. 192.168.2.35/16
    3. 5.8.4.3/8
    Deux machines A et B sont reliées au travers d'un switch, avec les informations suivantes, indiquer si elles peuvent communiquer :
    1. A : 174.34.28.1/8 et B ; 174.35.28.2/8
    2. A : 192.168.2.15/16 et B ; 192.168.5.16/16
    3. A : 5.3.2.1/24 et B ; 6.3.2.1/24
    Combien de machines peut-on trouver au maximum dans les réseaux suivants :
    1. 192.168.1.0/8
    2. 174.178.0.0/16
    3. 1.5.3.0/24
    4. 121.257.32.0/8
    L'INTERNIC qui est l’organisme qui gère les affectations des adresses IP a réservé quelques adresses dans chaque classe pour permettre d'affecter une adresse IP aux ordinateurs d'un réseau local relié à Internet, sans risquer de créer des conflits d'adresses IP sur le réseau.
    Il s'agit des adresses suivantes:
    • 10.0.0.1 à 10.255.255.254
    • 172.16.0.1 à 172.31.255.254
    • 192.168.0.1 à 192.168.255.254
    Ces adresses ne sont pas affectées sur Internet.

    3) TCP, IP et ethernet

    Un message envoyé d'une machine A vers une machine B ne le fait pas d'un seul bloc. En effet, il arrive souvent qu'une partie du message soit corrompue lors du transfert et il est souvent difficile d'identifier les données corrompues. Pour ne pas avoir à ré-envoyer la totalité du fichier (imaginez que vous deviez retélécharger en boucle la mise à jour d'un jeu actuel, qui fait couramment plusieurs gigaoctets!) on découpe le message en petites parties qui vont être acheminées de façon indépendantes. Il est facile de contrôler leur intégrité individuellement et on ne renverra que les paquets corrompus en conservant les bons.
    Puisque les paquets circulent de façon indépendante, tous ne vont pas forcément prendre le même chemin et donc n'arriveront pas nécessairement dans le même ordre. Le protocole TCP va prendre en charge cette problématique :

    encapsulation d'une donnée

    La donnée transmise sera découpée et encapsulée dans un paquet TCP, qui indiquera également l'ordre du morceau de donnée pour pouvoir la reconstituer correctement ainsi qu'une somme de contrôle permettant de vérifier que le morceau de donnée n'a pas été corrompu.
    Remarque : le protocole TCP prévoit également un accusé de réception afin que l'émetteur sache que le paquet a bien été reçu et pouvoir le renvoyer dans le cas contraire. Ce n'est par exemple pas le cas pour un autre protocole : l'UDP.

    Une fois la donnée encapsulée dans le paquet TCP, elle va l'être dans un autre paquet : le paquet IP.
    Le protocole IP va prendre en charge le tranfert de chaque paquet sur internet, notamment en indiquant l'adresse IP du destinataire pour que la donnée arrive à bon port et celle de l'émetteur afin qu'une réponse puisse être envoyée.

    Enfin, une dernière encapsulation a lieu à l'intérieur d'une trame ethernet : en effet, ce qui identifie de façon unique un périphérique réseau, c'est son adresse MAC qui est (en théorie) propre à chaque carte réseau. Celle-ci est codée sur 6 octets, généralement écrits en hexadecimal, par exemple 00:E0:4C:68:02:11
    Cherchez les adresses MAC de la carte ethernet ainsi que de la carte wifi de votre ordi région
    C'est cette adresse MAC qui est stockée dans les switches et les routeurs de votre réseau et qui permettent à ces appareils de transférer les messages via les bons ports. On a finalement :
    données
    paquet TCP
    paquet IP
    trame ethernet

    4) Protocole du bit alterné

    On a écrit plus haut que le protocole TCP proposait un système d'accusé de réception ou d'acquittement, raison pour laquelle on le note généralement ACK. Cela permet de détecter que le paquet a été perdu (et non pas reçu) et donc permettre à l'émetteur de ré-envoyer ce paquet.

    Le protocole du bit alterné est un moyen simple de détecter une perte de paquet.
    Il ne fait pas partie du protocole TCP mais plutôt de la trame ethernet : un bit est alors ajouté à cette trame selon la logique suivante :

    • L'ordinateur A émet la première trame et y ajoute un 0 à la fin
    • L'ordinateur B reçoit cette trame et envoie en retour une trame d'acquittement en inversant le bit à la fin (soit un 1)
    • L'ordinateur A émet une nouvelle trame avec le même bit que celui reçu (donc 1)
    • L'ordinateur B reçoit cette trame et envoie en retour une trame d'acquittement en inversant le bit à la fin (soit un 0)
    • Et ainsi de suite...
    A cela s'ajoute un chronomètre côté émetteur : si la trame ACK n'est pas retournée dans le temps imparti, la machine A envoie de nouveau le paquet avec le même bit à la fin.
    Si B reçoit une trame avec un bit de fin différent de celui qu'il a envoyé dans le précédent ACK, il en déduit que son acquittement n'a pas été reçu. Il ne tient pas compte de la trame reçue et envoie de nouveau la même trame ACK que précédemment

    Chercher des situations dans lesquelles le protocole du bit alterné peut être pris en défaut.

    5) modèles en couches

    Le modèle OSI est un modèle théorique de références des différentes couches existantes lors d'un échange de données au travers d'un réseau :
    1
    2
    3
    4
    5
    6
    7
    Physique
    Liaison de données
    Réseau
    Transport
    Session
    Présentation
    Application
    Le modèle pour TCP/IP est légèrement différent :
    1
    Accès réseau
    Ethernet, Wifi, PPP, ...
    2
    Internet
    IP
    3
    Transport
    TCP, UDP
    4
    Application
    HTTP, FTP, DNS, ...

    IV - Interface Homme-Machine

    Affiche IHM

    Cacher IHM

    1) Introduction

    Ce que l'on appelle Interface Homme-Machine (ou IHM) est ce qui permet à un utilisateur d'interagir avec une machine.
    Dans le cas d'un ordinateur, cela prend la forme du couple clavier/souris et de l'écran et pour un smartphone l'écran tactile à lui seul peut assurer cette fonction.
    Vous remarquez que les rôles du clavier/souris d'une part et de l'écran d'autre part sont différents : les premiers reçoivent l'information de l'humain, tandis que le second transmet l'information.
    En réalité ces objets font partie de 2 catégories différentes :
    • les capteurs qui d'une façon générale permettent aux machines de connaître leur environnement
    • les actionneurs qui d'une façon générale permettent aux machines d'agir sur leur environnement
    Ces deux familles sont présentes sur toutes les machines, tout particulièrement ce qui va nous intéresser par la suite : les robots.

    2) Les robots

    Un robot est une machine munie de capteurs et d'actionneurs capable de réaliser de façon plus ou moins autonome un travail donné (le terme a été inventé par l'écrivain tchécoslovaque Karel Čapek, initialement il signifiait plus ou moins "esclave").
    Bien que la Science Fiction l'imagine plutôt ainsi :

    Ce que l'on imagine
    La quasi totalité des robots ressemblent en réalité à ça :

    la réalité
    Ou bien cela :

    chez vous
    Programmer un robot
    Nous allons nous intéresser au robot Thymio, qui avait déjà été abordé l'année dernière en SNT (voir Séances 8 et 10). L'environnement de simulation permet de prendre en main un robot dans un environnement virtuel.
    Vous pouvez télécharger le logiciel ici : Site de l'éditeur Thymio
    Une fois le logiciel Thymio Suite installé, choisissez Aseba Studio, choisissez "lancez un simulateur" et lancez le terrain test suivant : télécharger le terrain. Cliquez ensuite sur l'icône du robot.
    Collez maintenant dans la fenêtre le code suivant :
    onevent buttons
    
      if  button.forward==1 then
        motor.right.target=50
        motor.left.target=50
      end
    
     if  button.backward==1 then
        motor.right.target=-50
        motor.left.target=-50
      end
      
        if  button.center==1 then
        motor.right.target=0
        motor.left.target=0
      end
    
    La programmation dans le langage ASEBA est événementielle : des instructions s'executeront non pas dans une séquence donnée comme on a l'habitude en python, mais en fonction des événements (appui sur bouton, détection d'obstacle, ...). Dans le programme du dessus, le seul événment défini est l'appui d'un bouton (présent sur le dessus du robot) : appuyez sur "executer" et allez dans le simulateur appuyer sur le flèche vers l'avant puis vers l'arrière, vous verrez le robot avancer puis reculer. 3 documents sont intéressants pour comprendre le fonctionnement de ce robot :
    Le robot dispose pour se déplacer de 2 roues motrices. Il bouge comme un char et non comme une voiture.
    1. Proposez une modification du code précédent pour le faire tourner dans le bon sens lorsque les touches droite et gauche sont pressées
    2. Proposez une amélioration du code afin que le robot accélère par incrément de 50 à chaque fois que le bouton avant est pressé.
    Prise en compte de l'environnement
    Pour savoir où se trouvent les obstacles, le robot dispose de plusieurs capteurs de proximité : 5 devant et 2 derrière.
    Il est possible de "détecter" un obstacle grâce à l'événement prox, ainsi pour détecter un mur face au robot, on peut utiliser cette commande :
    onevent prox
    
      if prox.horizontal[2]>10 then
        motor.right.target=0
        motor.left.target=0
      end
    
    Cela aura pour effet de stopper le robot si un objet est détecté par le capteur central de la face avant, à une "distance" inférieure à 10.
    Compléter cet événement de façon à faire automatiquement :
    1. Stopper le robot en cas de détection d'obstacle en marche arrière
    2. Compléter cet événement de façon à faire automatiquement tourner à droite le robot si un objet est détecté à sa gauche, puis faire de même de l'autre côté
    3. Rendre le robot autonome de façon à ce qu'il puisse explorer le labyrinthe jusqu'à arriver dans la zone d'arrivée en jaune